diff --git a/Detectors/GenericTracking/.clang-tidy b/Detectors/GenericTracking/.clang-tidy
new file mode 100644
index 0000000000000..b9af34ed01651
--- /dev/null
+++ b/Detectors/GenericTracking/.clang-tidy
@@ -0,0 +1,137 @@
+---
+# GenericTracking: a generic, GPU-capable CA track finder.
+#
+# Three properties of this code shape the disabled list below.
+#
+#  1. Parts of it compile as device code.  std::array, std::span, exceptions
+#     and RTTI are unavailable there, so the checks that push C arrays and
+#     pointer arithmetic towards those replacements are actively wrong.
+#
+#  2. It is detector software.  Short identifiers are the domain's notation --
+#     x, y, z, r, phi, eta, pt, bz -- and spelling them out makes formulas
+#     harder to check, not easier.
+#
+#  3. It interoperates with ROOT and O2.  Generated dictionary code and
+#     macro expansions are not ours to fix.
+
+Checks:
+  - -*
+  - bugprone-*
+  - performance-*
+  - modernize-*
+  - portability-*
+  - cppcoreguidelines-*
+  - misc-*
+  - readability-*
+  - clang-analyzer-*
+
+  # -- device code cannot use the recommended replacements ------------------
+  - -cppcoreguidelines-avoid-c-arrays        # GPUd() paths take raw pointers
+  - -modernize-avoid-c-arrays                #   and fixed C arrays by design
+  - -cppcoreguidelines-pro-bounds-pointer-arithmetic
+  - -cppcoreguidelines-pro-bounds-constant-array-index
+  - -cppcoreguidelines-pro-bounds-array-to-pointer-decay
+  - -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access  # Eigen v[i]
+  - -cppcoreguidelines-init-variables        # T x{} is already value-initialised
+
+  # -- the domain's notation ------------------------------------------------
+  - -readability-identifier-length           # r, z, phi, pt, bz are the names
+  - -bugprone-easily-swappable-parameters    # (x, y, z) is the whole API
+  - -readability-math-missing-parentheses    # transcribed formulas stay flat
+  # Geometry is arithmetic.  The offending literals are rotation-matrix element
+  # indices (rot[5]), the 2 in "twice the half-width" and the 0.5 in "half the
+  # span"; a named constant for any of them obscures the formula it appears in.
+  - -cppcoreguidelines-avoid-magic-numbers
+  - -readability-magic-numbers
+
+  # -- POD data model -------------------------------------------------------
+  # Sensor, Layer, Digit, Cluster and the SoA views are deliberately public
+  # aggregates: they are uploaded to the device as-is, so an accessor layer
+  # would be a lie about their layout.
+  - -misc-non-private-member-variables-in-classes
+  - -cppcoreguidelines-non-private-member-variables-in-classes
+  - -cppcoreguidelines-pro-type-member-init  # aggregate init at the use site
+  # Small index enums -- kLoc0..kQOverP, kFree/kShared/kExclusive, the reports'
+  # kinds ending in a count -- stay unscoped with a fixed underlying type: they
+  # index arrays and size them without a cast (BoundIndex, Definitions.h).
+  - -cppcoreguidelines-use-enum-class
+
+  # -- ROOT and Boost own memory their own way ------------------------------
+  # ROOT's object model is `new` handing ownership to a manager singleton:
+  # gGeoManager owns every TGeoMaterial, TGeoVolume and TGeoMatrix created
+  # under it, and deleting one ourselves is a crash.  There is no owner<> to
+  # be had, so the check has nothing correct to suggest.
+  - -cppcoreguidelines-owning-memory
+  - -cppcoreguidelines-no-malloc
+  # Fires inside Boost.ProgramOptions' own headers, on instantiations our TU
+  # triggers rather than on anything we wrote.  HeaderFilterRegex cannot
+  # suppress it because the diagnostic is attributed to our source file.
+  - -portability-template-virtual-member-function
+
+  # -- style choices --------------------------------------------------------
+  - -modernize-use-trailing-return-type
+  # A multi-way choice of a label or a kind reads best as one chained
+  # conditional: `a ? x : b ? y : z`.
+  - -readability-avoid-nested-conditional-operator
+
+  # -- untrue of a Boost.Test suite -----------------------------------------
+  # Every BOOST_TEST expands to branches, so a test case that checks a dozen
+  # properties in a loop scores as deeply nested code that nobody wrote.
+  - -readability-function-cognitive-complexity
+  # BOOST_AUTO_TEST_CASE expands to a static function; the check fires on the
+  # macro expansion, so there is nothing at the call site to fix.
+  - -misc-use-anonymous-namespace
+  # Fixed seeds are the point -- digitiser noise and MC closure tests are only
+  # meaningful if the sequence reproduces.
+  - -bugprone-random-generator-seed
+
+  # -- IWYU enforcement, deliberately off -----------------------------------
+  # misc-include-cleaner cannot see through O2's GPUCommon* include structure
+  # and would demand every TU name the header behind each type rather than the
+  # one it actually uses.  Too much churn for the benefit.
+  - -misc-include-cleaner
+
+WarningsAsErrors: '*'
+
+HeaderFilterRegex: 'GenericTracking/.*\.(h|cuh)$'
+
+CheckOptions:
+  # Naming follows O2's conventions.
+  readability-identifier-naming.ClassCase: CamelCase
+  readability-identifier-naming.StructCase: CamelCase
+  readability-identifier-naming.EnumCase: CamelCase
+  readability-identifier-naming.EnumConstantCase: CamelCase
+  readability-identifier-naming.EnumConstantIgnoredRegexp: '^k[A-Z][a-zA-Z0-9]*$'
+  readability-identifier-naming.ConceptCase: CamelCase
+  readability-identifier-naming.TypeAliasCase: CamelCase
+  readability-identifier-naming.TypedefCase: CamelCase
+  readability-identifier-naming.TemplateParameterCase: CamelCase
+  readability-identifier-naming.TypeTemplateParameterCase: CamelCase
+  readability-identifier-naming.FunctionCase: camelBack
+  readability-identifier-naming.ParameterCase: camelBack
+  readability-identifier-naming.VariableCase: camelBack
+  readability-identifier-naming.NamespaceCase: lower_case
+  # O2 spells non-public members mFoo; the POD aggregates keep plain camelBack
+  # public names because they are part of the wire format.
+  readability-identifier-naming.PrivateMemberCase: CamelCase
+  readability-identifier-naming.PrivateMemberPrefix: m
+  readability-identifier-naming.ProtectedMemberCase: CamelCase
+  readability-identifier-naming.ProtectedMemberPrefix: m
+  readability-identifier-naming.PublicMemberCase: camelBack
+  readability-identifier-naming.MacroDefinitionCase: UPPER_CASE
+  readability-identifier-naming.MacroDefinitionIgnoredRegexp: '^[A-Z][A-Z0-9_]*_?$'
+  readability-identifier-naming.ConstexprVariableCase: camelBack
+  readability-identifier-naming.ConstexprVariableIgnoredRegexp: '^k[A-Z][a-zA-Z0-9]*$'
+  readability-identifier-naming.GlobalConstantCase: camelBack
+  readability-identifier-naming.GlobalConstantIgnoredRegexp: '^k[A-Z][a-zA-Z0-9]*$'
+  # BOOST_AUTO_TEST_CASE(SomeName) expands its argument into a function name;
+  # the diagnostic points into the macro, so there is no per-case fix.
+  readability-identifier-naming.FunctionIgnoredRegexp: '^[A-Z][A-Za-z0-9]*$'
+
+  misc-include-cleaner.IgnoreHeaders: 'Eigen/.*;GPUCommon.*'
+  # Values and references only: the pointee analysis does not count a pointer
+  # handed out -- returned as void*, stored in an allocation's void* data -- as
+  # a use of the pointee, and asks for const where it cannot compile.
+  misc-const-correctness.WarnPointersAsPointers: false
+  performance-move-const-arg.CheckTriviallyCopyableMove: false
+...
diff --git a/Detectors/GenericTracking/CMakeLists.txt b/Detectors/GenericTracking/CMakeLists.txt
index 2c865e20d88a5..2d6b535792065 100644
--- a/Detectors/GenericTracking/CMakeLists.txt
+++ b/Detectors/GenericTracking/CMakeLists.txt
@@ -8,8 +8,15 @@
 # In applying this license CERN does not waive the privileges and immunities
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
-o2_add_library(GenericTracking
-               SOURCES src/BoundedAllocator.cxx
-               PRIVATE_LINK_LIBRARIES O2::GPUCommon O2::FrameworkLogger)
+# Every unit that instantiates the header tracker -- the tracking device's, the
+# study library's, the sink's and the benches' -- compiles at -O3 in
+# RelWithDebInfo, where the tracker runs faster than at O2's -O2.
+set(GTRK_TRACKER_OPTIMIZATION "$<$<AND:$<CONFIG:RelWithDebInfo>,$<COMPILE_LANGUAGE:CXX>>:-O3>")
 
-add_subdirectory(test)
+add_subdirectory(base)
+add_subdirectory(tracking)
+add_subdirectory(workflow)
+if(ENABLE_UPGRADES)
+  add_subdirectory(tools)
+  add_subdirectory(study)
+endif()
diff --git a/Detectors/GenericTracking/base/CMakeLists.txt b/Detectors/GenericTracking/base/CMakeLists.txt
new file mode 100644
index 0000000000000..4915ff0996a82
--- /dev/null
+++ b/Detectors/GenericTracking/base/CMakeLists.txt
@@ -0,0 +1,30 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+# The base: what includes no tracking code -- the geometry and time model
+# (Base/, the detectors' layouts in Detectors/), the bounded allocator, the SoA
+# columns, the host algorithms, the lanes, the portable math and the capacity
+# estimator. Header code but for the three sources; host only.
+o2_add_library(GTrkBase
+               SOURCES src/BoundedAllocator.cxx
+                       src/CapacityEstimator.cxx
+                       src/LayerEnvelopes.cxx
+               PUBLIC_LINK_LIBRARIES O2::GPUCommon
+               TARGETVARNAME targetName)
+
+# o2_add_library installs the headers of include/<library name> only.
+target_include_directories(${targetName} PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+target_include_directories(${targetName} SYSTEM PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/External>
+                           $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/GenericTracking/External>)
+install(DIRECTORY include/GenericTracking DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+install(DIRECTORY External/memlayout DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GenericTracking/External)
+
+add_subdirectory(test)
diff --git a/Detectors/GenericTracking/base/External/memlayout/wrapper.h b/Detectors/GenericTracking/base/External/memlayout/wrapper.h
new file mode 100644
index 0000000000000..f193d686577c6
--- /dev/null
+++ b/Detectors/GenericTracking/base/External/memlayout/wrapper.h
@@ -0,0 +1,564 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef MEMLAYOUT_H
+#define MEMLAYOUT_H
+
+// Upstream forward-declares std::iterator_traits here.  libc++ declares it
+// differently, so the two are ambiguous in any translation unit that also
+// includes a standard container.  Including the real header instead.
+#include <iterator>
+#include <type_traits>
+
+#ifndef MEMLAYOUT_HOST_DEVICE
+#ifdef GPUhdi
+#define MEMLAYOUT_HOST_DEVICE GPUhdi()
+#else
+#define MEMLAYOUT_HOST_DEVICE
+#endif
+#endif
+
+// Local addition: the element access -- operator[] and what it calls -- is
+// always inlined. It builds a proxy of one reference per column; inlined,
+// the references a caller never reads fold away and `view[i].x` is one load,
+// but a compiler that keeps it out of line (GCC at -O2 does, for a record of
+// many columns) computes and stores every one of them on each call. nvcc and
+// HIP's clang take the attribute as they take __forceinline__.
+//
+// It only reaches as far as the proxy does inline: a proxy returned by, or
+// passed to, a function the compiler keeps out of line is built whole again.
+// Code that needs a few columns of a row is better served reading them from
+// the view, `view.x[i]`, which builds no proxy at all.
+#ifndef MEMLAYOUT_INLINE
+#if defined(__GNUC__) || defined(__clang__)
+#define MEMLAYOUT_INLINE __attribute__((always_inline))
+#else
+#define MEMLAYOUT_INLINE
+#endif
+#endif
+
+namespace memlayout
+{
+
+using size_t = decltype(sizeof(0));
+using ptrdiff_t = decltype(static_cast<int*>(nullptr) - static_cast<int*>(nullptr));
+
+template <class T>
+using value = T;
+template <class T>
+using reference = T&;
+template <class T>
+using const_reference = const T&;
+template <class T>
+using pointer = T*;
+template <class T>
+using const_pointer = const T*;
+
+// Local addition: a default value for a field of a struct templated on its
+// storage.  In the record form, Container = value, the field takes `v`; in
+// every other form it is value-initialised -- a null pointer, an empty
+// container -- so one declaration serves as record and as columns:
+//
+//   C<float> x = memlayout::default_value<C>(0.F);
+//
+// The reference forms have no default; that is safe because a default member
+// initializer of a class template is instantiated only where it is used, and
+// the wrapper always initialises every member.
+template <template <class> class Container, class T>
+MEMLAYOUT_HOST_DEVICE constexpr Container<T> default_value(T v)
+{
+  if constexpr (std::is_same_v<Container<T>, T>) {
+    return v;
+  } else {
+    return Container<T>{};
+  }
+}
+
+struct Dummy {
+};
+
+// The concepts are stated over a type, Container<Dummy>, and the SoA
+// specialisations are constrained through those. nvcc (13.1, 13.2) mishandles
+// concepts over a template template parameter used in a partial
+// specialisation's constraint: it picks the mutable random-access
+// specialisation for const_pointer -- or its front end, cudafe++, aborts on a
+// larger translation unit. The type forms mean the same and keep the
+// subsumption the specialisations are ordered by: the const one's constraint
+// contains the random-access one.
+template <class It>
+concept random_access_like_type = requires(It it, size_t n) {
+  it + n;
+  it - n;
+  it - it;
+  it[n];
+  ++it;
+  --it;
+  *it;
+};
+
+template <class It>
+concept writable_iterator_type = requires(It it) { *it = Dummy{}; };
+
+template <class It>
+concept const_random_access_like_type = random_access_like_type<It> && !writable_iterator_type<It>;
+
+template <template <class> class Container>
+concept random_access_like = random_access_like_type<Container<Dummy>>;
+
+template <template <class> class Iterator>
+concept non_const_iterator_like = writable_iterator_type<Iterator<Dummy>>;
+
+template <class ReturnType>
+struct RandomAccessAt {
+  memlayout::size_t i;
+  template <class... Args>
+  MEMLAYOUT_INLINE MEMLAYOUT_HOST_DEVICE constexpr ReturnType operator()(Args&... args) const
+  {
+    return {args[i]...};
+  }
+  template <class... Args>
+  MEMLAYOUT_INLINE MEMLAYOUT_HOST_DEVICE constexpr ReturnType operator()(const Args&... args) const
+  {
+    return {args[i]...};
+  }
+};
+
+template <class ReturnType>
+struct GetPointer {
+  template <class... Args>
+  MEMLAYOUT_HOST_DEVICE constexpr ReturnType operator()(Args&... args) const
+  {
+    return {&args...};
+  }
+  template <class... Args>
+  MEMLAYOUT_HOST_DEVICE constexpr ReturnType operator()(const Args&... args) const
+  {
+    return {&args...};
+  }
+};
+
+template <class ReturnType>
+struct AggregateConstructor {
+  template <class... Args>
+  MEMLAYOUT_HOST_DEVICE constexpr ReturnType operator()(Args&... args) const
+  {
+    return {args...};
+  }
+  template <class... Args>
+  MEMLAYOUT_HOST_DEVICE constexpr ReturnType operator()(const Args&... args) const
+  {
+    return {args...};
+  }
+};
+
+struct FirstMember {
+  template <class T, class... Args>
+  MEMLAYOUT_HOST_DEVICE constexpr T& operator()(T& t, Args&... args) const
+  {
+    return t;
+  }
+  template <class T, class... Args>
+  MEMLAYOUT_HOST_DEVICE constexpr const T& operator()(const T& t, const Args&... args) const
+  {
+    return t;
+  }
+};
+
+template <class ReturnType>
+struct PreIncrement {
+  template <class... Args>
+  MEMLAYOUT_HOST_DEVICE constexpr ReturnType operator()(Args&... args) const
+  {
+    return {++args...};
+  }
+};
+
+template <class ReturnType>
+struct PreDecrement {
+  template <class... Args>
+  MEMLAYOUT_HOST_DEVICE constexpr ReturnType operator()(Args&... args) const
+  {
+    return {--args...};
+  }
+};
+
+template <class ReturnType>
+struct Advance {
+  ptrdiff_t i;
+  template <class... Args>
+  MEMLAYOUT_HOST_DEVICE constexpr ReturnType operator()(const Args&... args) const
+  {
+    return {(args + i)...};
+  }
+};
+
+struct CopyAssignment {
+  template <class Left, class Right>
+  MEMLAYOUT_HOST_DEVICE constexpr Left& operator()(Left& left, const Right& right) const
+  {
+    return left = right;
+  }
+};
+
+template <class ReturnType>
+struct Begin {
+  template <class... Args>
+  constexpr ReturnType operator()(Args&... args) const
+  {
+    return {args.begin()...};
+  }
+  template <class... Args>
+  constexpr ReturnType operator()(const Args&... args) const
+  {
+    return {args.cbegin()...};
+  }
+};
+
+template <class ReturnType>
+struct End {
+  template <class... Args>
+  constexpr ReturnType operator()(Args&... args) const
+  {
+    return {args.end()...};
+  }
+  template <class... Args>
+  constexpr ReturnType operator()(const Args&... args) const
+  {
+    return {args.cend()...};
+  }
+};
+
+enum class Layout { aos = 0,
+                    soa = 1 };
+
+template <template <template <class> class> class Struct, template <class> class Container, Layout L = Layout::soa>
+struct Wrapper;
+
+template <template <template <class> class> class Struct, template <class> class Container>
+struct Wrapper<Struct, Container, Layout::aos> : public Container<Struct<value>> {
+  static constexpr Layout layout_type = Layout::aos;
+  using Base = Container<Struct<value>>;
+  using Base::Base;
+
+  constexpr Wrapper() = default;
+  template <template <class> class other_Container>
+  constexpr Wrapper(Wrapper<Struct, other_Container, Layout::aos>& other) : Base(other)
+  {
+  }
+
+  MEMLAYOUT_INLINE constexpr Wrapper<Struct, reference> operator[](size_t i) { return Base::operator[](i); }
+  MEMLAYOUT_INLINE constexpr Wrapper<Struct, const_reference> operator[](size_t i) const { return Base::operator[](i); }
+
+  constexpr Wrapper<Struct, reference> operator*() { return operator[](0); }
+  constexpr Wrapper<Struct, const_reference> operator*(ptrdiff_t) const { return operator[](0); }
+};
+
+template <template <template <class> class> class Struct>
+struct Wrapper<Struct, pointer, Layout::aos> {
+  static constexpr Layout layout_type = Layout::aos;
+
+  pointer<Struct<value>> data;
+  using Data = pointer<Struct<value>>;
+
+  operator Data&() { return data; }
+  operator const Data&() const { return data; }
+
+  constexpr bool operator==(const Wrapper& other) const { return data == other.data; }
+  constexpr bool operator!=(const Wrapper& other) const { return data != other.data; }
+  constexpr bool operator<(const Wrapper& other) const { return data < other.data; }
+
+  constexpr Wrapper operator+(ptrdiff_t i) const { return {data + i}; }
+  constexpr Wrapper operator-(ptrdiff_t i) const { return {data - i}; }
+  constexpr ptrdiff_t operator-(const Wrapper& other) const { return {data - other.data}; }
+
+  constexpr Wrapper operator++() { return {++data}; }
+  constexpr Wrapper operator+=(ptrdiff_t i) { return {data += i}; }
+  constexpr Wrapper operator--() { return {--data}; }
+  constexpr Wrapper operator-=(ptrdiff_t i) { return {data -= i}; }
+
+  MEMLAYOUT_INLINE constexpr Wrapper<Struct, reference> operator[](size_t i) { return data[i]; }
+  MEMLAYOUT_INLINE constexpr Wrapper<Struct, const_reference> operator[](size_t i) const { return data[i]; }
+
+  constexpr Wrapper<Struct, reference> operator*() { return *data; }
+  constexpr Wrapper<Struct, const_reference> operator*(ptrdiff_t) const { return *data; }
+
+  constexpr Wrapper<Struct, reference> operator->() { return operator[](0); }
+  constexpr Wrapper<Struct, const_reference> operator->() const { return operator[](0); }
+};
+
+template <template <template <class> class> class Struct>
+struct Wrapper<Struct, const_pointer, Layout::aos> {
+  static constexpr Layout layout_type = Layout::aos;
+
+  const_pointer<Struct<value>> data;
+  using Data = const_pointer<Struct<value>>;
+
+  operator const Data&() const { return data; }
+
+  constexpr bool operator==(const Wrapper& other) const { return data == other.data; }
+  constexpr bool operator!=(const Wrapper& other) const { return data != other.data; }
+  constexpr bool operator<(const Wrapper& other) const { return data < other.data; }
+
+  constexpr Wrapper operator+(ptrdiff_t i) const { return {data + i}; }
+  constexpr Wrapper operator-(ptrdiff_t i) const { return {data - i}; }
+  constexpr ptrdiff_t operator-(const Wrapper& other) const { return {data - other.data}; }
+
+  constexpr Wrapper operator++() { return {++data}; }
+  constexpr Wrapper operator+=(ptrdiff_t i) { return {data += i}; }
+  constexpr Wrapper operator--() { return {--data}; }
+  constexpr Wrapper operator-=(ptrdiff_t i) { return {data -= i}; }
+
+  MEMLAYOUT_INLINE constexpr Wrapper<Struct, const_reference> operator[](size_t i) const { return data[i]; }
+  constexpr Wrapper<Struct, const_reference> operator*() const { return *data; }
+  constexpr Wrapper<Struct, const_reference> operator->() const { return operator[](0); }
+};
+
+template <template <template <class> class> class Struct, template <class> class Container>
+struct Wrapper<Struct, Container, Layout::soa> : public Struct<Container> {
+  static constexpr Layout layout_type = Layout::soa;
+  using Base = Struct<Container>;
+  using Base::Base;
+  template <class T>
+  using iterator = typename Container<T>::iterator;
+  template <class T>
+  using const_iterator = typename Container<T>::const_iterator;
+
+  constexpr Wrapper() = default;
+  constexpr Wrapper(Base b) : Base{static_cast<Base&&>(b)} {}
+  template <template <class> class other_Container>
+  constexpr Wrapper(Struct<other_Container>& other) : Base{other.apply(AggregateConstructor<Base>{})}
+  {
+  }
+  template <template <class> class other_Container>
+  constexpr Wrapper(const Struct<other_Container>& other) : Base{other.apply(AggregateConstructor<Base>{})}
+  {
+  }
+
+  MEMLAYOUT_INLINE constexpr Wrapper<Struct, reference> operator[](size_t i) { return Base::apply(RandomAccessAt<Struct<reference>>{i}); }
+  MEMLAYOUT_INLINE constexpr Wrapper<Struct, const_reference> operator[](size_t i) const { return Base::apply(RandomAccessAt<Struct<const_reference>>{i}); }
+
+  constexpr Wrapper<Struct, reference> operator*() { return operator[](0); }
+  constexpr Wrapper<Struct, const_reference> operator*(ptrdiff_t) const { return operator[](0); }
+
+  constexpr Wrapper<Struct, iterator> begin() { return Base::apply(Begin<Struct<iterator>>{}); }
+  constexpr Wrapper<Struct, iterator> end() { return Base::apply(End<Struct<iterator>>{}); }
+  constexpr Wrapper<Struct, const_iterator> cbegin() const { return Base::apply(Begin<Struct<const_iterator>>{}); }
+  constexpr Wrapper<Struct, const_iterator> cend() const { return Base::apply(End<Struct<const_iterator>>{}); }
+};
+
+template <template <template <class> class> class Struct, template <class> class Container>
+  requires random_access_like_type<Container<Dummy>>
+struct Wrapper<Struct, Container, Layout::soa> : public Struct<Container> {
+  using iterator_category = std::iterator_traits<Container<Dummy>>::iterator_category;
+  using difference_type = ptrdiff_t;
+  using value_type = Wrapper<Struct, memlayout::value>;
+  using pointer = void;
+  using reference = Wrapper<Struct, memlayout::reference>;
+
+  static constexpr Layout layout_type = Layout::soa;
+  using Base = Struct<Container>;
+
+  constexpr Wrapper() = default;
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper(Base b) : Base{static_cast<Base&&>(b)} {}
+
+  MEMLAYOUT_INLINE MEMLAYOUT_HOST_DEVICE constexpr Wrapper<Struct, memlayout::reference> operator[](size_t i) { return Base::apply(RandomAccessAt<Struct<memlayout::reference>>{i}); }
+  MEMLAYOUT_INLINE MEMLAYOUT_HOST_DEVICE constexpr const Wrapper<Struct, memlayout::const_reference> operator[](size_t i) const { return Base::apply(RandomAccessAt<Struct<memlayout::const_reference>>{i}); }
+
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper<Struct, memlayout::reference> operator*() { return operator[](0); }
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper<Struct, memlayout::const_reference> operator*() const { return operator[](0); }
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper<Struct, memlayout::reference> operator->() { return operator[](0); }
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper<Struct, memlayout::const_reference> operator->() const { return operator[](0); }
+
+  MEMLAYOUT_HOST_DEVICE constexpr bool operator==(const Wrapper& other) const { return Base::apply(FirstMember{}) == other.apply(FirstMember{}); }
+  MEMLAYOUT_HOST_DEVICE constexpr bool operator!=(const Wrapper& other) const { return !this->operator==(other); }
+  MEMLAYOUT_HOST_DEVICE constexpr bool operator<(const Wrapper& other) const { return Base::apply(FirstMember{}) < other.apply(FirstMember{}); }
+
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper operator+(ptrdiff_t i) const { return Base::apply(Advance<Base>{i}); }
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper operator-(ptrdiff_t i) const { return operator+(-i); }
+  MEMLAYOUT_HOST_DEVICE constexpr ptrdiff_t operator-(const Wrapper& other) const { return Base::apply(FirstMember{}) - other.apply(FirstMember{}); }
+
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper& operator++()
+  {
+    Base::apply(PreIncrement<Base>{});
+    return *this;
+  }
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper& operator+=(ptrdiff_t i) { return *this = *this + i; }
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper& operator--()
+  {
+    Base::apply(PreDecrement<Base>{});
+    return *this;
+  }
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper& operator-=(ptrdiff_t i) { return *this = *this - i; }
+};
+
+template <template <template <class> class> class Struct, template <class> class Container>
+  requires const_random_access_like_type<Container<Dummy>>
+struct Wrapper<Struct, Container, Layout::soa> : public Struct<Container> {
+  using iterator_category = std::iterator_traits<Container<Dummy>>::iterator_category;
+  using difference_type = ptrdiff_t;
+  using value_type = Wrapper<Struct, memlayout::value>;
+  using pointer = void;
+  using reference = Wrapper<Struct, memlayout::const_reference>;
+
+  static constexpr Layout layout_type = Layout::soa;
+  using Base = Struct<Container>;
+
+  constexpr Wrapper() = default;
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper(Base b) : Base{static_cast<Base&&>(b)} {}
+
+  template <template <class> class OtherContainer>
+    requires random_access_like_type<OtherContainer<Dummy>>
+  constexpr Wrapper(const Struct<OtherContainer>& other) : Base(other.apply(AggregateConstructor<Base>{}))
+  {
+  }
+
+  MEMLAYOUT_INLINE MEMLAYOUT_HOST_DEVICE constexpr Wrapper<Struct, const_reference> operator[](size_t i) const { return Base::apply(RandomAccessAt<Struct<const_reference>>{i}); }
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper<Struct, const_reference> operator*() const { return operator[](0); }
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper<Struct, const_reference> operator->() const { return operator[](0); }
+
+  MEMLAYOUT_HOST_DEVICE constexpr bool operator==(const Wrapper& other) const { return Base::apply(FirstMember{}) == other.apply(FirstMember{}); }
+  MEMLAYOUT_HOST_DEVICE constexpr bool operator!=(const Wrapper& other) const { return !this->operator==(other); }
+  MEMLAYOUT_HOST_DEVICE constexpr bool operator<(const Wrapper& other) const { return Base::apply(FirstMember{}) < other.apply(FirstMember{}); }
+
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper operator+(ptrdiff_t i) const { return Base::apply(Advance<Base>{i}); }
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper operator-(ptrdiff_t i) const { return operator+(-i); }
+  MEMLAYOUT_HOST_DEVICE constexpr ptrdiff_t operator-(const Wrapper& other) const { return Base::apply(FirstMember{}) - other.apply(FirstMember{}); }
+
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper& operator++()
+  {
+    Base::apply(PreIncrement<Base>{});
+    return *this;
+  }
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper& operator+=(ptrdiff_t i) { return *this = *this + i; }
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper& operator--()
+  {
+    Base::apply(PreDecrement<Base>{});
+    return *this;
+  }
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper& operator-=(ptrdiff_t i) { return *this = *this - i; }
+};
+
+template <template <template <class> class> class Struct>
+struct Wrapper<Struct, value, Layout::soa> : public Struct<value> {
+  using Base = Struct<value>;
+
+  constexpr Wrapper() = default;
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper(Base b) : Base{static_cast<Base&&>(b)} {}
+  constexpr Wrapper(const Struct<reference>& other) : Base(other.apply(AggregateConstructor<Base>{})) {}
+  constexpr Wrapper(const Struct<const_reference>& other) : Base(other.apply(AggregateConstructor<Base>{})) {}
+};
+
+template <template <template <class> class> class Struct>
+struct Wrapper<Struct, reference, Layout::soa> : public Struct<reference> {
+  using Base = Struct<reference>;
+
+  constexpr Wrapper() = delete;
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper(Base b) : Base{static_cast<Base&&>(b)} {}
+  constexpr Wrapper(Struct<value>& other) : Base(other.apply(AggregateConstructor<Base>{})) {}
+
+  constexpr Wrapper(const Wrapper& other) = default;
+
+  constexpr Wrapper& operator=(const Wrapper<Struct, value>& other)
+  {
+    Base::apply(other, CopyAssignment{});
+    return *this;
+  }
+  constexpr Wrapper& operator=(const Wrapper& other)
+  {
+    Base::apply(other, CopyAssignment{});
+    return *this;
+  }
+  constexpr Wrapper& operator=(const Wrapper<Struct, const_reference>& other)
+  {
+    Base::apply(other, CopyAssignment{});
+    return *this;
+  }
+
+  constexpr Wrapper(Wrapper&& other) = default;
+
+  constexpr Wrapper& operator=(Wrapper&& other) { return operator=(other); }
+
+  constexpr Wrapper<Struct, pointer> operator&() { return Base::apply(GetPointer<Struct<pointer>>{}); }
+  // constexpr Wrapper<Struct, const_pointer> operator&() const { return Base::apply(GetPointer<Struct<const_pointer>>{}); }
+  constexpr pointer<Wrapper<Struct, reference>> operator->() { return this; }
+};
+
+template <template <template <class> class> class Struct>
+struct Wrapper<Struct, const_reference, Layout::soa> : public Struct<const_reference> {
+  using Base = Struct<const_reference>;
+
+  constexpr Wrapper() = delete;
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper(Base b) : Base{static_cast<Base&&>(b)} {}
+  constexpr Wrapper(const Struct<value>& other) : Base(other.apply(AggregateConstructor<Base>{})) {}
+  constexpr Wrapper(const Struct<reference>& other) : Base(other.apply(AggregateConstructor<Base>{})) {}
+
+  MEMLAYOUT_HOST_DEVICE constexpr Wrapper<Struct, const_pointer> operator&() const { return Base::apply(GetPointer<Struct<const_pointer>>{}); }
+  MEMLAYOUT_HOST_DEVICE constexpr const_pointer<Wrapper<Struct, const_reference>> operator->() const { return this; }
+};
+
+} // namespace memlayout
+
+#define MEMLAYOUT_PARENS ()
+
+#define MEMLAYOUT_EXPAND(...) MEMLAYOUT_EXPAND4(MEMLAYOUT_EXPAND4(MEMLAYOUT_EXPAND4(__VA_ARGS__)))
+#define MEMLAYOUT_EXPAND4(...) MEMLAYOUT_EXPAND3(MEMLAYOUT_EXPAND3(MEMLAYOUT_EXPAND3(__VA_ARGS__)))
+#define MEMLAYOUT_EXPAND3(...) MEMLAYOUT_EXPAND2(MEMLAYOUT_EXPAND2(MEMLAYOUT_EXPAND2(__VA_ARGS__)))
+#define MEMLAYOUT_EXPAND2(...) MEMLAYOUT_EXPAND1(MEMLAYOUT_EXPAND1(MEMLAYOUT_EXPAND1(__VA_ARGS__)))
+#define MEMLAYOUT_EXPAND1(...) __VA_ARGS__
+
+#define MEMLAYOUT_FOR_EACH(macro, ...) __VA_OPT__(MEMLAYOUT_EXPAND(MEMLAYOUT_FOR_EACH_HELPER(macro, __VA_ARGS__)))
+#define MEMLAYOUT_FOR_EACH_HELPER(macro, a1, ...) macro(a1) __VA_OPT__(, MEMLAYOUT_FOR_EACH_AGAIN MEMLAYOUT_PARENS(macro, __VA_ARGS__))
+#define MEMLAYOUT_FOR_EACH_AGAIN() MEMLAYOUT_FOR_EACH_HELPER
+
+// per-member transforms: bare name for the unary case, `f(m, other.m)` for binary
+#define MEMLAYOUT_UNARY_ONE(m) m
+#define MEMLAYOUT_BINARY_ONE(m) f(m, other.m)
+
+// One macro per struct, member list written exactly once. Generates a column
+// enum in the same order as the apply arguments. The final enumerator gives
+// the number of columns; member names must not use ColumnCount.
+// Also generates the four `apply(other, f)` overloads and the two unary
+// `apply(f)` overloads.
+#define MEMLAYOUT_APPLY(STRUCT_NAME, ...)                                                    \
+  enum class Column : memlayout::size_t { __VA_ARGS__,                                       \
+                                          ColumnCount };                                     \
+  template <class Function>                                                                  \
+  MEMLAYOUT_INLINE MEMLAYOUT_HOST_DEVICE constexpr auto apply(Function&& f)                  \
+  {                                                                                          \
+    return f(MEMLAYOUT_FOR_EACH(MEMLAYOUT_UNARY_ONE, __VA_ARGS__));                          \
+  }                                                                                          \
+  template <class Function>                                                                  \
+  MEMLAYOUT_INLINE MEMLAYOUT_HOST_DEVICE constexpr auto apply(Function&& f) const            \
+  {                                                                                          \
+    return f(MEMLAYOUT_FOR_EACH(MEMLAYOUT_UNARY_ONE, __VA_ARGS__));                          \
+  }                                                                                          \
+  template <template <class> class other_Container, class Function>                          \
+  constexpr STRUCT_NAME apply(STRUCT_NAME<other_Container>& other, Function&& f)             \
+  {                                                                                          \
+    return {MEMLAYOUT_FOR_EACH(MEMLAYOUT_BINARY_ONE, __VA_ARGS__)};                          \
+  }                                                                                          \
+  template <template <class> class other_Container, class Function>                          \
+  constexpr STRUCT_NAME apply(STRUCT_NAME<other_Container>& other, Function&& f) const       \
+  {                                                                                          \
+    return {MEMLAYOUT_FOR_EACH(MEMLAYOUT_BINARY_ONE, __VA_ARGS__)};                          \
+  }                                                                                          \
+  template <template <class> class other_Container, class Function>                          \
+  constexpr STRUCT_NAME apply(const STRUCT_NAME<other_Container>& other, Function&& f)       \
+  {                                                                                          \
+    return {MEMLAYOUT_FOR_EACH(MEMLAYOUT_BINARY_ONE, __VA_ARGS__)};                          \
+  }                                                                                          \
+  template <template <class> class other_Container, class Function>                          \
+  constexpr STRUCT_NAME apply(const STRUCT_NAME<other_Container>& other, Function&& f) const \
+  {                                                                                          \
+    return {MEMLAYOUT_FOR_EACH(MEMLAYOUT_BINARY_ONE, __VA_ARGS__)};                          \
+  }
+
+#endif // MEMLAYOUT_H
diff --git a/Detectors/GenericTracking/include/GenericTracking/BoundedAllocator.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/BoundedAllocator.h
similarity index 67%
rename from Detectors/GenericTracking/include/GenericTracking/BoundedAllocator.h
rename to Detectors/GenericTracking/base/include/GenericTracking/Base/BoundedAllocator.h
index d523a10bb2c63..c339b0019b52a 100644
--- a/Detectors/GenericTracking/include/GenericTracking/BoundedAllocator.h
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/BoundedAllocator.h
@@ -10,17 +10,13 @@
 // or submit itself to any jurisdiction.
 ///
 /// \file BoundedAllocator.h
-/// \brief Shared budgeted host allocation and bounded-vector utilities.
-///
-/// Reconciles GTRK's overflow-safe allocator, profiling counters and vector
-/// rebuilds with the owned-resource, mutable-budget and stage-peak contracts
-/// used by the upstream legacy ITS tracker and vertexer.
+/// \brief A std::pmr::memory_resource that throws instead of exceeding a
+///        budget, and the helpers that release and rebuild vectors on it.
 ///
 
-#ifndef ALICEO2_GENERICTRACKING_BOUNDEDALLOCATOR_H_
-#define ALICEO2_GENERICTRACKING_BOUNDEDALLOCATOR_H_
+#ifndef GTRK_BASE_BOUNDEDALLOCATOR_H_
+#define GTRK_BASE_BOUNDEDALLOCATOR_H_
 
-#include <algorithm>
 #include <array>
 #include <atomic>
 #include <limits>
@@ -34,7 +30,6 @@
 namespace o2::gtrk
 {
 
-// #define BOUNDED_MR_STATS
 class BoundedMemoryResource final : public std::pmr::memory_resource
 {
  public:
@@ -42,19 +37,18 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
   {
    public:
     MemoryLimitExceeded(size_t attempted, size_t used, size_t max);
-    const char* what() const noexcept final;
+    [[nodiscard]] const char* what() const noexcept final;
 
    private:
     std::string mMsg;
   };
 
-  static std::pmr::memory_resource* cachingUpstream();
-
-  BoundedMemoryResource(size_t maxBytes = std::numeric_limits<size_t>::max(),
-                        std::pmr::memory_resource* upstream = nullptr);
+  /// At most \a maxBytes in use at once: an allocation past it throws
+  /// MemoryLimitExceeded. Without \a upstream the shared caching pool serves.
+  explicit BoundedMemoryResource(size_t maxBytes = std::numeric_limits<size_t>::max(), std::pmr::memory_resource* upstream = nullptr);
 
-  BoundedMemoryResource(std::unique_ptr<std::pmr::memory_resource> upstream,
-                        size_t maxBytes = std::numeric_limits<size_t>::max());
+  /// As above, owning its \a upstream.
+  explicit BoundedMemoryResource(std::unique_ptr<std::pmr::memory_resource> upstream, size_t maxBytes = std::numeric_limits<size_t>::max());
 
   [[nodiscard]] size_t getUsedMemory() const noexcept;
   [[nodiscard]] size_t getMaxMemory() const noexcept;
@@ -62,22 +56,28 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
   [[nodiscard]] size_t getPeakMemory() const noexcept;
   [[nodiscard]] size_t getPeakMemoryDelta() const noexcept;
 
-  // Reset the stage peak/baseline, returning the previous peak for nested profiling.
+  /// Open a window on the peak: peak and baseline become what is in use now,
+  /// and the peak before is returned, for raisePeakMemory to restore when the
+  /// window closes (nested stages).
   size_t resetPeakMemory() noexcept;
+  /// The peak becomes at least \a peak.
   void raisePeakMemory(size_t peak) noexcept;
+  /// Allocations served, and their bytes, since construction.
   [[nodiscard]] size_t getAllocationCount() const noexcept { return mAllocations.load(std::memory_order_relaxed); }
   [[nodiscard]] size_t getAllocatedBytes() const noexcept { return mAllocatedBytes.load(std::memory_order_relaxed); }
   void setMaxMemory(size_t max);
 
 #if !defined(__HIPCC__) && !defined(__CUDACC__)
-  std::string asString() const;
+  [[nodiscard]] std::string asString() const;
   void print() const;
 #endif
 
  private:
+  static std::pmr::memory_resource* cachingUpstream();
+
   void* do_allocate(size_t bytes, size_t alignment) final;
   void do_deallocate(void* p, size_t bytes, size_t alignment) final;
-  bool do_is_equal(const std::pmr::memory_resource& other) const noexcept final;
+  [[nodiscard]] bool do_is_equal(const std::pmr::memory_resource& other) const noexcept final;
 
   std::atomic<size_t> mMaxMemory{std::numeric_limits<size_t>::max()};
   std::atomic<size_t> mCountThrow{0};
@@ -88,27 +88,13 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
   std::atomic<size_t> mPeakBaselineMemory{0};
   std::unique_ptr<std::pmr::memory_resource> mOwnedUpstream;
   std::pmr::memory_resource* mUpstream{nullptr};
-
-#ifdef BOUNDED_MR_STATS
-  struct Stats {
-    std::atomic<size_t> peak{0};
-    std::atomic<size_t> live{0};
-    std::atomic<size_t> nAlloc{0};
-    std::atomic<size_t> nFree{0};
-    std::atomic<size_t> totalAlloc{0};
-    std::atomic<size_t> totalFreed{0};
-    std::atomic<size_t> maxAlign{0};
-    std::atomic<size_t> upstreamFailures{0};
-  };
-  Stats mStats{};
-#endif
 };
 
 template <typename T>
 using BoundedVector = std::pmr::vector<T>;
 
 template <typename T>
-using bounded_vector = BoundedVector<T>;
+using bounded_vector = BoundedVector<T>; // NOLINT(readability-identifier-naming): ITS's spelling
 
 template <typename T>
 inline void deepVectorClear(std::vector<T>& vec)
@@ -141,7 +127,7 @@ inline void deepVectorClear(std::array<bounded_vector<T>, S>& arr, std::pmr::mem
 }
 
 template <typename T>
-inline void clearResizeBoundedVector(bounded_vector<T>& vec, size_t sz, std::pmr::memory_resource* mr = nullptr, T def = T())
+inline void clearResizeBoundedVector(bounded_vector<T>& vec, size_t sz, std::pmr::memory_resource* mr = nullptr, const T& def = T())
 {
   // Rebuild a valid empty vector before allocation or element construction can
   // throw. The old allocation is released first, as required by bounded pools.
@@ -149,8 +135,11 @@ inline void clearResizeBoundedVector(bounded_vector<T>& vec, size_t sz, std::pmr
   vec.assign(sz, def);
 }
 
-// GTRK's capacity-reusing resize: retained storage is intended for arrays
-// rewritten by the caller. A non-null different resource requires a rebuild.
+// \a vec at \a sz elements: in its storage where that holds them (the old
+// elements kept, the added ones value-initialised; the caller rewrites the
+// array whole before reading it), otherwise
+// rebuilt as clearResizeBoundedVector rebuilds it, the old storage released
+// first. A non-null different resource requires a rebuild.
 template <typename T>
 inline void resizeBoundedVector(BoundedVector<T>& vec, size_t sz, std::pmr::memory_resource* mr = nullptr)
 {
@@ -178,22 +167,6 @@ inline void clearResizeBoundedVector(std::vector<bounded_vector<T>>& vec, size_t
   }
 }
 
-template <typename T, size_t S>
-inline void clearResizeBoundedArray(std::array<bounded_vector<T>, S>& arr, size_t size, std::pmr::memory_resource* mr = nullptr, T def = T())
-{
-  for (size_t i{0}; i < S; ++i) {
-    clearResizeBoundedVector(arr[i], size, mr, def);
-  }
-}
-
-template <typename T>
-inline std::vector<T> toSTDVector(const bounded_vector<T>& b)
-{
-  std::vector<T> t(b.size());
-  std::copy(b.cbegin(), b.cend(), t.begin());
-  return t;
-}
-
 } // namespace o2::gtrk
 
-#endif /* ALICEO2_GENERICTRACKING_BOUNDEDALLOCATOR_H_ */
+#endif /* GTRK_BASE_BOUNDEDALLOCATOR_H_ */
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Base/CapacityEstimator.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/CapacityEstimator.h
new file mode 100644
index 0000000000000..c857f18d2b644
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/CapacityEstimator.h
@@ -0,0 +1,61 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CapacityEstimator.h
+/// \brief Per stage, the staging each thread's buffer is given at a
+///        timeframe's start, learned from the timeframes before.
+
+#ifndef GTRK_BASE_CAPACITYESTIMATOR_H_
+#define GTRK_BASE_CAPACITYESTIMATOR_H_
+
+#include <array>
+#include <cstddef>
+
+namespace o2::gtrk
+{
+
+/// What each stage's per-thread staging buffer is given at a timeframe's
+/// start: the largest use any
+/// of its buffers had over a timeframe, per measurement row, smoothed over the
+/// timeframes before, times a margin that rises when a buffer grew during a
+/// timeframe and falls when none did. Within a timeframe the buffers grow as
+/// they must and are not predicted again. One entry per stage, a site
+/// index below `kSites` (the tracker's `StagingSite`), read and written by
+/// the tracker's thread alone.
+///
+/// ITSMFTTracking's CapacityEstimator is the same model, keyed, locked and
+/// transactional, in a library this one cannot link.
+class CapacityEstimator
+{
+ public:
+  static constexpr std::size_t kSites = 4U;
+
+  /// The records to stage per thread for \a site in a timeframe of \a rows
+  /// measurement rows.
+  [[nodiscard]] std::size_t perThread(std::size_t site, std::size_t rows) const;
+  /// Learn from a timeframe of \a rows rows: \a largestUse, the most records
+  /// one of \a site's buffers held at the end of a run; \a granted, the
+  /// records per thread it was given; \a grew, whether a buffer grew past
+  /// them.
+  void learn(std::size_t site, std::size_t largestUse, std::size_t granted, std::size_t rows, bool grew);
+
+ private:
+  struct Entry {
+    float ratio{0.F}; ///< records per measurement row
+    float margin{0.F};
+    bool learned{false};
+  };
+  std::array<Entry, kSites> mEntries{};
+};
+
+} // namespace o2::gtrk
+
+#endif /* GTRK_BASE_CAPACITYESTIMATOR_H_ */
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Base/Columns.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/Columns.h
new file mode 100644
index 0000000000000..6a741edef1d79
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/Columns.h
@@ -0,0 +1,123 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Columns.h
+/// \brief Owned SoA columns of any memlayout struct, from a bounded pool.
+///
+/// Every artefact the tracker produces -- tracklets, triplets, and whatever
+/// follows -- is declared once as `S<C>` with MEMLAYOUT_APPLY. This owns its
+/// columns as bounded vectors and hands out the pointer views kernels write
+/// and read. Each operation is written over `S::apply`, so a new artefact
+/// needs no code here. Host-side: a device backend owns device allocations
+/// and builds the same views over them.
+
+#ifndef GTRK_BASE_COLUMNS_H_
+#define GTRK_BASE_COLUMNS_H_
+
+#include "GenericTracking/Base/BoundedAllocator.h"
+
+#include <memlayout/wrapper.h>
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <memory_resource>
+
+namespace o2::gtrk
+{
+
+template <template <template <class> class> class S>
+class BoundedColumns
+{
+ public:
+  using Record = S<memlayout::value>;
+  using View = memlayout::Wrapper<S, memlayout::pointer, memlayout::Layout::soa>;
+  using ConstView = memlayout::Wrapper<S, memlayout::const_pointer, memlayout::Layout::soa>;
+
+  /// Reseat every column on \a resource, releasing what it held.
+  void setMemoryResource(std::pmr::memory_resource* resource)
+  {
+    mColumns.apply([resource](auto&... column) { (deepVectorClear(column, resource), ...); });
+  }
+
+  /// Every column to \a size live elements; capacity is kept when shrinking.
+  /// All or nothing: if a column's allocation throws, every column goes back
+  /// to its size before -- which allocates nothing -- and the exception goes
+  /// on. Columns of different sizes would let `size()`, which reads the first,
+  /// promise rows a later column does not have.
+  void resize(std::size_t size)
+  {
+    const std::size_t before = this->size();
+    try {
+      mColumns.apply([size](auto&... column) { (column.resize(size), ...); });
+    } catch (...) {
+      mColumns.apply([before](auto&... column) { (column.resize(before), ...); });
+      throw;
+    }
+  }
+
+  /// Every column at \a size rows for a pass that writes them all before it
+  /// reads one: `resizeBoundedVector` per column -- in its storage where that
+  /// holds them, otherwise rebuilt at exactly \a size, the old storage released
+  /// first, so that a growing slice neither copies rows it overwrites nor
+  /// doubles the capacity. If an allocation
+  /// throws, every column is left empty, and the exception goes on.
+  void resizeRewritten(std::size_t size)
+  {
+    try {
+      mColumns.apply([size](auto&... column) { (resizeBoundedVector(column, size), ...); });
+    } catch (...) {
+      mColumns.apply([](auto&... column) { (column.clear(), ...); });
+      throw;
+    }
+  }
+
+  [[nodiscard]] std::size_t size() const
+  {
+    return mColumns.apply([](const auto& first, const auto&... /*rest*/) { return first.size(); });
+  }
+
+  [[nodiscard]] View view()
+  {
+    return mColumns.apply([](auto&... column) { return View{S<memlayout::pointer>{column.data()...}}; });
+  }
+
+  [[nodiscard]] ConstView view() const
+  {
+    return mColumns.apply([](const auto&... column) { return ConstView{S<memlayout::const_pointer>{column.data()...}}; });
+  }
+
+  void write(std::size_t index, const Record& record)
+  {
+    assert(index < size());
+    mColumns.apply([&](auto&... column) { record.apply([&](const auto&... value) { ((column[index] = value), ...); }); });
+  }
+
+  [[nodiscard]] Record read(std::size_t index) const
+  {
+    assert(index < size());
+    return mColumns.apply([index](const auto&... column) { return Record{column[index]...}; });
+  }
+
+  /// Copy \a count rows starting at \a from into \a destination at \a to.
+  void copyTo(std::size_t from, BoundedColumns& destination, std::size_t to, std::size_t count) const
+  {
+    assert(from + count <= size() && to + count <= destination.size());
+    mColumns.apply([&](const auto&... source) { destination.mColumns.apply([&](auto&... target) { (std::copy_n(source.begin() + static_cast<std::ptrdiff_t>(from), count, target.begin() + static_cast<std::ptrdiff_t>(to)), ...); }); });
+  }
+
+ private:
+  S<BoundedVector> mColumns;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_BASE_COLUMNS_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Base/Definitions.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/Definitions.h
new file mode 100644
index 0000000000000..d94851c54f19a
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/Definitions.h
@@ -0,0 +1,95 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Definitions.h
+/// \brief Index types and GPU annotations shared by every GTRK header.
+///
+/// This is the single place GPUCommonDef.h is pulled in from, so that the
+/// host/device annotations arrive identically everywhere.
+///
+/// Nothing in this file may depend on ROOT or on anything that cannot be
+/// compiled by a device compiler. The STL is limited to <cstdint> and <limits>,
+/// both of which are pure compile-time facilities here.
+
+#ifndef GTRK_BASE_DEFINITIONS_H_
+#define GTRK_BASE_DEFINITIONS_H_
+
+#include "GPUCommonDef.h"
+
+#include <cstdint>
+#include <limits>
+
+// The function qualifiers. GTRK writes them in O2's vocabulary (GPUCommonDef.h),
+// so that a header reads the same here and in O2:
+//
+//   GPUhdi() GPUAlwaysInline()
+//              host and device, always inlined -- every helper a kernel can
+//              reach: the cuts, terms, fits, steps, accessors and math a stage
+//              calls per candidate. Forced, so that a caller growing past
+//              GCC's inlining limits cannot push one out of line and add a
+//              call per candidate.
+//   GPUhdnii() host and device, `inline` on the host and never inlined on the
+//              device -- the heavy leaf every stage carries a state through,
+//              which the device otherwise copies into every search and window
+//              of every variant.
+//   GPUhdi()   host and device, `inline`, the compiler decides -- the stage
+//              bodies only: a stage's per-element `operator()`, the walks and
+//              drivers around the candidates, and the few large computations
+//              a compiler keeps out of line; test/testQualifiers.cxx lists them.
+//   GPUdi()    device only (`inline` on the host) -- what calls one of O2's
+//              device-only functions, `CAMath`'s atomics or the material
+//              budget's `getMatBudget`; the device
+//              compiler refuses it as `GPUhdi()`, so this is never a choice.
+//   GPUg()     a kernel.
+//
+// Host-only functions carry plain C++ (`inline`, `constexpr`) and no qualifier.
+// An attribute comes first, the qualifier next, the other specifiers after it:
+// `[[nodiscard]] GPUhdi() GPUAlwaysInline() constexpr bool f(...)`.
+
+namespace o2::gtrk
+{
+
+/// Global index of a sensor (chip) within a Layout.
+///
+/// Dense and stable: sensor IDs run 0 ... nSensors-1 in a fixed geometric
+/// order, which is what lets every downstream stage index chip-keyed arrays
+/// directly instead of going through a map. It is the detector's own chip
+/// index (O2's chip ID for the ITS, the MFT and the TRK), so a cluster's
+/// sensorID needs no decoding.
+using SensorID = std::uint32_t;
+
+/// Index of a layer within a Layout. Layers are few; the narrow type keeps the
+/// per-cluster records small, which matters once they are uploaded per ROF.
+using LayerID = std::uint16_t;
+
+/// Sentinel for "no sensor". Chosen as the maximum representable value rather
+/// than -1 so that the unsigned comparison `id < nSensors` rejects it without a
+/// separate check -- the form that survives being written as a device-side
+/// bounds test.
+inline constexpr SensorID kInvalidSensorID = std::numeric_limits<SensorID>::max();
+
+/// Sentinel for "no layer", same reasoning as kInvalidSensorID.
+inline constexpr LayerID kInvalidLayerID = std::numeric_limits<LayerID>::max();
+
+/// `a == b` for floating point, for values that are equal by construction
+/// rather than by arithmetic: a switched-off field, an absent neighbour's
+/// zero, a constant a test pins down. The same result as `==` for every input,
+/// NaN and signed zeros included, written without `==` because GCC's
+/// -Wfloat-equal, unlike Clang's, also flags comparisons with a literal.
+template <typename T>
+GPUhdi() constexpr bool exactlyEqual(T a, T b)
+{
+  return a <= b && a >= b;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_BASE_DEFINITIONS_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Base/FrameTiming.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/FrameTiming.h
new file mode 100644
index 0000000000000..8b34e97a5478c
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/FrameTiming.h
@@ -0,0 +1,54 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file FrameTiming.h
+/// \brief A layer's readout frames, which its time boxes, the grid's time
+///        blocks and the slices' reach follow.
+
+#ifndef GTRK_BASE_FRAMETIMING_H_
+#define GTRK_BASE_FRAMETIMING_H_
+
+#include "GenericTracking/Base/TimeEstPS.h"
+
+#include <cstdint>
+
+namespace o2::gtrk
+{
+
+/// Frame `k` of a layer starts at `firstStartBC + k * lengthBC` BC from the
+/// timeframe's first orbit: O2's `ROFLookupTables` layer timing
+/// (`getROFStartInBC`), the delay and the bias together -- for the ITS and
+/// the MFT from the detector's `DPLAlpideParam` in the CCDB, for ALICE 3's
+/// TRK from `TRKAlmiraParam`. The frames' records do not hold the bias:
+/// frame `k`'s record is at `k * lengthBC`, in the MC and in data alike, and
+/// O2's digitiser puts a collision at BC `t` into the frame of `t - bias`.
+/// Every layer has frames: the grid refuses a length that is not positive.
+/// O2's `ROFTimingLayer` (ITSMFTTracking) holds the same frames, in its ITS/MFT
+/// library; this one also serves ALICE 3's TRK.
+struct FrameTiming {
+  std::int32_t lengthBC = 0;
+  std::int32_t firstStartBC = 0;
+
+  /// Whether \a box is exactly one of these frames, as `frameBox` makes it
+  /// with no margin: its start a frame's start and its width the length, each
+  /// rounded down from BC. A box widened by a margin is not.
+  [[nodiscard]] constexpr bool isFrame(const TimeEstPS& box) const
+  {
+    const std::int64_t startBC = bcOfPS(box.start);
+    return startBC >= firstStartBC && (startBC - firstStartBC) % lengthBC == 0 && box.start == psOfBC(startBC) && box.width == psOfBC(lengthBC);
+  }
+
+  friend constexpr bool operator==(const FrameTiming&, const FrameTiming&) = default;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_BASE_FRAMETIMING_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Base/Geometry.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/Geometry.h
new file mode 100644
index 0000000000000..baa08ec661359
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/Geometry.h
@@ -0,0 +1,109 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Geometry.h
+/// \brief The runtime half of a detector description: where each sensor sits.
+///
+/// The sensors are the experiment's, handed in whole at construction (for the
+/// ALICE detectors from O2's GeometryTGeo, Alice/Placement.h). They are
+/// runtime rather than constexpr data because alignment corrections apply to
+/// them.
+///
+/// The array extent is Det::nSensors, a compile-time constant, so the whole
+/// geometry is one contiguous fixed-size block.
+///
+/// Everything here is double.  See Sensor.h for why, and for where the float
+/// view the tracking wants gets built instead.
+
+#ifndef GTRK_BASE_GEOMETRY_H_
+#define GTRK_BASE_GEOMETRY_H_
+
+#include "GenericTracking/Base/Definitions.h"
+#include "GenericTracking/Base/LayerEnvelopes.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Base/Sensor.h"
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <span>
+#include <stdexcept>
+
+namespace o2::gtrk
+{
+
+/// Sensor placements of one detector, indexed by chip ID. The sensors need
+/// not be grouped by layer.
+template <DetectorLayout Det>
+class Geometry
+{
+ public:
+  /// Take the layout's sensors, indexed by chip ID. Checks the count and that
+  /// every layer index exists, then measures each layer's envelope from the
+  /// sensors (rounded outwards to kEnvelopeResolution) and publishes the
+  /// table as this process's PlacedEnvelopes<Det>, which the extent functions
+  /// of Tracking/SearchWindow.h read. \a depths: each layer's
+  /// `measurementDepth`, or none for 0 on every layer. Throws
+  /// std::invalid_argument on the counts, std::runtime_error on a layer
+  /// without a sensor.
+  explicit Geometry(std::span<const Sensor> sensors, std::span<const double> depths = {})
+  {
+    if (sensors.size() != static_cast<std::size_t>(Det::nSensors)) {
+      throw std::invalid_argument("placed geometry: sensor count differs from the layout's");
+    }
+    if (!depths.empty() && depths.size() != static_cast<std::size_t>(Detector<Det>::nLayers)) {
+      throw std::invalid_argument("placed geometry: measurement depths for another number of layers");
+    }
+    std::ranges::copy(depths, mDepths.begin());
+    if (std::ranges::any_of(sensors, [](const Sensor& s) { return s.layer >= Detector<Det>::nLayers; })) {
+      throw std::invalid_argument("placed geometry: layer index outside the layout");
+    }
+    std::ranges::copy(sensors, mSensors.begin());
+    PlacedEnvelopes<Det>::publish(measureEnvelopes(sensors, layerSpecs(), Detector<Det>::nBarrelLayers, kEnvelopeResolution));
+  }
+
+  [[nodiscard]] const Sensor& sensor(SensorID id) const { return mSensors[id]; }
+  [[nodiscard]] const std::array<Sensor, Det::nSensors>& sensors() const { return mSensors; }
+
+  /// Where layer \a layer's measurements lie in its sensors' silicon: the
+  /// unrolled z of the plane whose crossing a cluster's position follows
+  /// [cm], about a flat sensor's mid-plane and outwards from a curved one's
+  /// radius (SensorSpec::unrolledToFrame). The digitiser collects charge from
+  /// part of the depth only; 0 unless
+  /// given.
+  [[nodiscard]] double measurementDepth(LayerID layer) const { return mDepths[layer]; }
+
+  void toGlobal(SensorID id, const double l[3], double g[3]) const { mSensors[id].toGlobal(l, g); }
+
+  /// The sensor shape of each layer, in layer order.
+  [[nodiscard]] static constexpr std::array<SensorSpec, Detector<Det>::nLayers> layerSpecs()
+  {
+    std::array<SensorSpec, Detector<Det>::nLayers> specs{};
+    for (int layer = 0; layer < Detector<Det>::nLayers; ++layer) {
+      specs[static_cast<std::size_t>(layer)] = layerSpec(static_cast<LayerID>(layer));
+    }
+    return specs;
+  }
+
+  /// The shape of a layer's sensors.
+  [[nodiscard]] static constexpr const SensorSpec& layerSpec(LayerID layer) { return Detector<Det>::isBarrelLayer(layer) ? Det::barrelLayers[layer].sensor : Det::discLayers[Detector<Det>::discIndex(layer)].sensor; }
+
+  /// The shape of the sensor a chip carries.
+  [[nodiscard]] const SensorSpec& specOf(SensorID id) const { return layerSpec(mSensors[id].layer); }
+
+ private:
+  std::array<Sensor, Det::nSensors> mSensors{};
+  std::array<double, Detector<Det>::nLayers> mDepths{}; ///< [cm]
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_BASE_GEOMETRY_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Base/HostAlgorithms.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/HostAlgorithms.h
new file mode 100644
index 0000000000000..b0a77dd0b3dde
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/HostAlgorithms.h
@@ -0,0 +1,119 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file HostAlgorithms.h
+/// \brief An ordered compaction and an exclusive scan on the host threads.
+///
+/// Both cut [0, n) into chunks of consecutive indices, work on the chunks in
+/// parallel, and join them with a scan of the chunks' totals on one thread:
+/// one total per chunk. A chunk works through its indices in order, so the
+/// result is the serial loop's at any thread count and any schedule.
+///
+/// \a forEach(count, body) runs body(i) for every i in [0, count), serially or
+/// in parallel -- the tracker passes a backend's `forEachElement`. The chunks
+/// are its elements.
+///
+/// Not the standard parallel algorithms: they run outside the tracker's arena,
+/// allocate outside the bounded pool, and report no 32-bit overflow.
+
+#ifndef GTRK_BASE_HOSTALGORITHMS_H_
+#define GTRK_BASE_HOSTALGORITHMS_H_
+
+#include "GenericTracking/Base/BoundedAllocator.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory_resource>
+#include <span>
+
+namespace o2::gtrk::host_algorithms
+{
+
+using Index = std::uint32_t;
+
+/// How [0, \a n) is cut: chunks of \a chunkSize indices, the last one shorter.
+struct Chunking {
+  Index n = 0U;
+  Index size = 1U;
+
+  Chunking(Index items, Index chunkSize) : n(items), size(std::max<Index>(1U, chunkSize)) {}
+  [[nodiscard]] Index count() const { return n == 0U ? 0U : 1U + ((n - 1U) / size); }
+  [[nodiscard]] Index begin(Index chunk) const { return chunk * size; }
+  [[nodiscard]] Index end(Index chunk) const { return static_cast<Index>(std::min<std::uint64_t>(n, (std::uint64_t{chunk} + 1U) * size)); }
+};
+
+/// The indices in [0, \a n) for which \a keep(i) holds, in increasing order,
+/// into \a out, resized to their number. \a keep is called twice per index.
+template <typename ForEach, typename Keep>
+void compactIndices(const ForEach& forEach, Index n, Index chunkSize, const Keep& keep, BoundedVector<Index>& out)
+{
+  const Chunking chunks{n, chunkSize};
+  BoundedVector<Index> offsets(std::size_t{chunks.count()} + 1U, Index{0}, out.get_allocator());
+  forEach(chunks.count(), [&](Index chunk) {
+    Index count = 0U;
+    for (Index i = chunks.begin(chunk); i < chunks.end(chunk); ++i) {
+      count += keep(i) ? 1U : 0U;
+    }
+    offsets[chunk + 1U] = count;
+  });
+  for (Index chunk = 0; chunk < chunks.count(); ++chunk) {
+    offsets[chunk + 1U] += offsets[chunk];
+  }
+  resizeBoundedVector(out, offsets[chunks.count()]);
+  forEach(chunks.count(), [&](Index chunk) {
+    Index at = offsets[chunk];
+    for (Index i = chunks.begin(chunk); i < chunks.end(chunk); ++i) {
+      if (keep(i)) {
+        out[at++] = i;
+      }
+    }
+  });
+}
+
+/// `offsets[i]` = the sum of \a value(j) over j < i, for i in [0, \a n];
+/// \a offsets holds n + 1 entries. False, with \a offsets unspecified, when the
+/// total does not fit an Index -- as the serial loop's running check, since the
+/// sums only grow. \a value(i) must not read \a offsets.
+template <typename ForEach, typename Value>
+[[nodiscard]] bool exclusiveScan(const ForEach& forEach, Index n, Index chunkSize, const Value& value, std::span<Index> offsets, std::pmr::memory_resource* resource)
+{
+  const Chunking chunks{n, chunkSize};
+  BoundedVector<std::uint64_t> totals(std::size_t{chunks.count()} + 1U, std::uint64_t{0}, std::pmr::polymorphic_allocator<std::uint64_t>{resource});
+  forEach(chunks.count(), [&](Index chunk) {
+    std::uint64_t sum = 0U;
+    for (Index i = chunks.begin(chunk); i < chunks.end(chunk); ++i) {
+      sum += value(i);
+    }
+    totals[chunk + 1U] = sum;
+  });
+  for (Index chunk = 0; chunk < chunks.count(); ++chunk) {
+    totals[chunk + 1U] += totals[chunk];
+  }
+  const std::uint64_t total = totals[chunks.count()];
+  if (total > std::numeric_limits<Index>::max()) {
+    return false;
+  }
+  forEach(chunks.count(), [&](Index chunk) {
+    auto running = static_cast<Index>(totals[chunk]);
+    for (Index i = chunks.begin(chunk); i < chunks.end(chunk); ++i) {
+      offsets[i] = running;
+      running += value(i);
+    }
+  });
+  offsets[n] = static_cast<Index>(total);
+  return true;
+}
+
+} // namespace o2::gtrk::host_algorithms
+
+#endif // GTRK_BASE_HOSTALGORITHMS_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Base/Lanes.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/Lanes.h
new file mode 100644
index 0000000000000..8457e5c729e50
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/Lanes.h
@@ -0,0 +1,60 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Lanes.h
+/// \brief A lane's share of a walk that several lanes make together, and
+///        the lanes that make one in step.
+
+#ifndef GTRK_BASE_LANES_H_
+#define GTRK_BASE_LANES_H_
+
+#include "GPUCommonDef.h"
+
+#include <cstdint>
+
+namespace o2::gtrk
+{
+
+/// A share of one walk's rows: lane `lane` of `count` visits the `lane`-th row
+/// of every range and each `count`-th after it, so the lanes together visit
+/// every row once. One lane of one visits them all in order: the walk of a
+/// single thread.
+struct Lanes {
+  std::uint32_t lane = 0U;
+  std::uint32_t count = 1U;
+};
+
+/// The lanes of a group walk in step: each takes
+/// its `Lanes` share of a walk's rows, and every lane makes every step, so
+/// that the group can decide together after each. A group type gives its
+/// width `kLanes`, the lane's index `lane()`, `ballot(set)` -- bit `i` for
+/// lane `i` -- and `broadcast(value, from)`, lane `from`'s value of a
+/// trivially copyable type on every lane. Every lane of a group calls every
+/// collective, in the same order.
+///
+/// This one is a single lane: the host's, and a one-thread kernel's. Its
+/// `lane()` is 0 and `ballot(set)` is `set`; `broadcast` only groups of
+/// several lanes need. The devices' groups of several lanes are `WarpGroup`
+/// (LaneGroup.cuh).
+struct SoloGroup {
+  static constexpr std::uint32_t kLanes = 1U;
+  // Members, not static: the interface is the device groups', whose lanes are
+  // their state; a static one would leave `group.lane()` a static call through
+  // an instance.
+  // NOLINTBEGIN(readability-convert-member-functions-to-static)
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint32_t lane() const { return 0U; }
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint64_t ballot(bool set) const { return set ? 1U : 0U; }
+  // NOLINTEND(readability-convert-member-functions-to-static)
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_BASE_LANES_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Base/LayerEnvelopes.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/LayerEnvelopes.h
new file mode 100644
index 0000000000000..e79898d270369
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/LayerEnvelopes.h
@@ -0,0 +1,120 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file LayerEnvelopes.h
+/// \brief Where a layout's layers are: measured from the sensors it was
+///        loaded with, and held for the process.
+///
+/// A layout (the ITS, the MFT, the TRK) has no compile-time positions: where its
+/// chips sit is the loaded geometry's business, aligned as that geometry is.
+/// Constructing its Geometry measures each layer's envelope from the sensors
+/// and publishes the table here; the extent functions of
+/// Tracking/SearchWindow.h, and with them the grid, the search windows, the
+/// scattering table and the material sampling, read it. Nothing on the device
+/// does. The compiled layout keeps topology only: the layer count, each layer's
+/// kind and sensor count, the links.
+
+#ifndef GTRK_BASE_LAYERENVELOPES_H_
+#define GTRK_BASE_LAYERENVELOPES_H_
+
+#include "GenericTracking/Base/Definitions.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Base/Sensor.h"
+
+#include <array>
+#include <limits>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+/// The rounding a geometry measures its envelopes with [cm]: 1 um, the
+/// minima down, the maxima up, the position to the nearest.
+inline constexpr double kEnvelopeResolution = 1e-4;
+
+/// The hull in r and z of one sensor's active silicon, with its effective
+/// thickness. A curved sensor's axis must be the beam's (std::runtime_error).
+struct SensorExtent {
+  double rMin = std::numeric_limits<double>::infinity();
+  double rMax = 0.;
+  double zMin = std::numeric_limits<double>::infinity();
+  double zMax = -std::numeric_limits<double>::infinity();
+};
+
+[[nodiscard]] SensorExtent extentOf(const Sensor& sensor, const SensorSpec& spec);
+
+/// The envelope of each layer's active silicon: the hull in r and z of every
+/// sensor's active matrix with its effective thickness, and as position the
+/// mean radius of its sensors' centres on a barrel or their mean z on a disc.
+/// \a specs holds each layer's sensor shape, layers numbered barrel first:
+/// the first \a nBarrelLayers are barrel layers. A curved sensor's centre is
+/// the middle of its silicon at the middle of its arc; its axis must be the
+/// beam's. With a \a resolution, the minima are rounded down to it, the maxima
+/// up and the position to the nearest; 0 leaves the values exact. Throws
+/// std::runtime_error for a sensor beyond the layers, a layer without one or a
+/// curved sensor whose axis is not the beam's.
+[[nodiscard]] std::vector<LayerEnvelope> measureEnvelopes(std::span<const Sensor> sensors, std::span<const SensorSpec> specs, int nBarrelLayers, double resolution = 0.);
+
+/// One line per layer, for a log; layers numbered barrel first.
+[[nodiscard]] std::string describeEnvelopes(std::span<const LayerEnvelope> envelopes, int nBarrelLayers);
+
+/// The envelopes of the layout \a Det loaded in this process.
+///
+/// One table per layout per process, as O2's `GeometryTGeo::Instance()` holds
+/// the one loaded detector for everything that asks: `Geometry<Det>` publishes
+/// at construction, a later geometry of the same layout replaces the table,
+/// and reading before any exists throws std::logic_error. Published once at
+/// set-up, before any tracking thread runs, and read-only after.
+template <DetectorLayout Det>
+class PlacedEnvelopes
+{
+ public:
+  static void publish(std::span<const LayerEnvelope> envelopes)
+  {
+    if (envelopes.size() != sTable.size()) {
+      throw std::invalid_argument(std::string{Det::name} + ": " + std::to_string(envelopes.size()) + " envelopes for " + std::to_string(sTable.size()) + " layers");
+    }
+    for (std::size_t layer = 0; layer < sTable.size(); ++layer) {
+      sTable[layer] = envelopes[layer];
+    }
+    sPublished = true;
+  }
+
+  [[nodiscard]] static const LayerEnvelope& get(LayerID layer)
+  {
+    if (!sPublished) {
+      throw std::logic_error(std::string{Det::name} + ": no geometry loaded, so no layer envelopes; construct Geometry<" + Det::name + "> first");
+    }
+    if (layer >= sTable.size()) {
+      throw std::out_of_range(std::string{Det::name} + ": layer " + std::to_string(layer) + " of " + std::to_string(sTable.size()));
+    }
+    return sTable[layer];
+  }
+
+  [[nodiscard]] static std::span<const LayerEnvelope> all()
+  {
+    if (!sPublished) {
+      throw std::logic_error(std::string{Det::name} + ": no geometry loaded, so no layer envelopes; construct Geometry<" + Det::name + "> first");
+    }
+    return sTable;
+  }
+
+ private:
+  inline static std::array<LayerEnvelope, Detector<Det>::nLayers> sTable{};
+  inline static bool sPublished = false;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_BASE_LAYERENVELOPES_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Base/LayerLinks.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/LayerLinks.h
new file mode 100644
index 0000000000000..9148c57cadef7
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/LayerLinks.h
@@ -0,0 +1,223 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file LayerLinks.h
+/// \brief What follows at compile time from a detector's link table.
+///
+/// `Det::layerLinks` says which layer a track reaches next. The grid and the
+/// CA read it; neither encodes
+/// adjacency again. Everything here is a constexpr function of that table:
+///
+///  - the links leaving and entering each layer, as index lists;
+///  - a topological order of the layers -- a table with a cycle does not
+///    compile;
+///  - each layer's depth, and the longest chain, which bounds the level;
+///  - the first link joining two layers (`linkOf`).
+///
+/// The index lists do not depend on the order the table is written in. The
+/// tool emits it sorted by `(from, to)` only so that it reads well.
+
+#ifndef GTRK_BASE_LAYERLINKS_H_
+#define GTRK_BASE_LAYERLINKS_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+
+namespace o2::gtrk
+{
+
+template <DetectorLayout Det>
+inline constexpr std::size_t nLinks = std::size(Det::layerLinks);
+
+/// Link indices grouped by one of their ends: the links of layer `l` are
+/// `links[offsets[l]]` up to `links[offsets[l + 1]]`, in table order.
+template <DetectorLayout Det>
+struct LinksByLayer {
+  std::array<std::size_t, static_cast<std::size_t>(Detector<Det>::nLayers) + 1> offsets{};
+  std::array<std::size_t, nLinks<Det>> links{};
+
+  [[nodiscard]] constexpr std::size_t begin(LayerID layer) const { return offsets[layer]; }
+  [[nodiscard]] constexpr std::size_t end(LayerID layer) const { return offsets[layer + 1U]; }
+  [[nodiscard]] constexpr std::size_t count(LayerID layer) const { return end(layer) - begin(layer); }
+};
+
+namespace detail
+{
+
+/// A counting sort of the link indices by their source or target layer.
+template <DetectorLayout Det, bool ByTarget>
+[[nodiscard]] constexpr LinksByLayer<Det> groupLinks()
+{
+  const auto key = [](const LayerLink& link) { return static_cast<std::size_t>(ByTarget ? link.to : link.from); };
+  LinksByLayer<Det> result{};
+  for (const auto& link : Det::layerLinks) {
+    ++result.offsets[key(link) + 1U];
+  }
+  for (std::size_t layer = 0; layer + 1U < result.offsets.size(); ++layer) {
+    result.offsets[layer + 1U] += result.offsets[layer];
+  }
+  auto next = result.offsets;
+  for (std::size_t i = 0; i < nLinks<Det>; ++i) {
+    result.links[next[key(Det::layerLinks[i])]++] = i;
+  }
+  return result;
+}
+
+} // namespace detail
+
+/// The links leaving each layer.
+template <DetectorLayout Det>
+inline constexpr LinksByLayer<Det> outLinks = detail::groupLinks<Det, false>();
+
+/// The links entering each layer.
+template <DetectorLayout Det>
+inline constexpr LinksByLayer<Det> inLinks = detail::groupLinks<Det, true>();
+
+namespace detail
+{
+
+template <DetectorLayout Det>
+struct TopologicalSort {
+  std::array<LayerID, static_cast<std::size_t>(Detector<Det>::nLayers)> order{};
+  std::size_t sorted = 0;
+};
+
+/// Kahn's algorithm, with `order` doubling as the queue. Layers with nothing
+/// entering them start it in index order, so a chain of barrel layers comes
+/// out as 0, 1, 2, ... A cycle leaves its layers unsorted.
+template <DetectorLayout Det>
+[[nodiscard]] constexpr TopologicalSort<Det> topologicalSort()
+{
+  constexpr auto kLayers = static_cast<std::size_t>(Detector<Det>::nLayers);
+  TopologicalSort<Det> result{};
+  std::array<std::size_t, kLayers> pending{};
+  for (const auto& link : Det::layerLinks) {
+    ++pending[link.to];
+  }
+  for (std::size_t layer = 0; layer < kLayers; ++layer) {
+    if (pending[layer] == 0) {
+      result.order[result.sorted++] = static_cast<LayerID>(layer);
+    }
+  }
+  for (std::size_t head = 0; head < result.sorted; ++head) {
+    const auto layer = result.order[head];
+    for (auto i = outLinks<Det>.begin(layer); i < outLinks<Det>.end(layer); ++i) {
+      const auto to = Det::layerLinks[outLinks<Det>.links[i]].to;
+      if (--pending[to] == 0) {
+        result.order[result.sorted++] = to;
+      }
+    }
+  }
+  return result;
+}
+
+template <DetectorLayout Det>
+consteval std::array<LayerID, static_cast<std::size_t>(Detector<Det>::nLayers)> checkedLayerOrder()
+{
+  constexpr auto sort = topologicalSort<Det>();
+  static_assert(sort.sorted == static_cast<std::size_t>(Detector<Det>::nLayers), "Det::layerLinks contains a cycle");
+  return sort.order;
+}
+
+} // namespace detail
+
+/// The layers in an order where every link points forward, so that one pass
+/// over them sees every link's source layer before its target.
+template <DetectorLayout Det>
+inline constexpr auto layerOrder = detail::checkedLayerOrder<Det>();
+
+/// Each layer's depth in the link DAG: 0 for a layer no link enters, else one
+/// more than the deepest source of a link into it.
+template <DetectorLayout Det>
+inline constexpr auto layerDepth = [] {
+  std::array<std::size_t, static_cast<std::size_t>(Detector<Det>::nLayers)> depth{};
+  for (const auto layer : layerOrder<Det>) {
+    for (auto i = outLinks<Det>.begin(layer); i < outLinks<Det>.end(layer); ++i) {
+      const auto to = Det::layerLinks[outLinks<Det>.links[i]].to;
+      depth[to] = std::max(depth[to], depth[layer] + 1U);
+    }
+  }
+  return depth;
+}();
+
+/// The layers by depth (`layerDepth`), a topological order too, and where each
+/// depth's run begins in it: `order[groups[d]]` up to `order[groups[d + 1]]`
+/// are the layers of depth `d`, `count` depths in all. The layers of one depth
+/// have no link between them and every link into them from a smaller depth,
+/// so an ordered pass over the layers may take a depth's layers together.
+template <DetectorLayout Det>
+struct LayerDepthGroups {
+  static constexpr std::size_t kLayers = static_cast<std::size_t>(Detector<Det>::nLayers);
+  std::array<LayerID, kLayers> order{};
+  std::array<std::size_t, kLayers + 1U> groups{};
+  std::size_t count = 0U;
+};
+
+template <DetectorLayout Det>
+inline constexpr LayerDepthGroups<Det> layerDepthGroups = [] {
+  LayerDepthGroups<Det> result{};
+  std::size_t next = 0U;
+  for (std::size_t depth = 0U; next < LayerDepthGroups<Det>::kLayers; ++depth) {
+    result.groups[depth] = next;
+    for (std::size_t layer = 0U; layer < LayerDepthGroups<Det>::kLayers; ++layer) {
+      if (layerDepth<Det>[layer] == depth) {
+        result.order[next++] = static_cast<LayerID>(layer);
+      }
+    }
+    result.count = depth + 1U;
+  }
+  result.groups[result.count] = LayerDepthGroups<Det>::kLayers;
+  return result;
+}();
+
+/// No link of the layout.
+inline constexpr std::size_t kNoLink = std::numeric_limits<std::size_t>::max();
+
+/// Per (from, to) layer pair, the first link of Det's table joining them;
+/// kNoLink for none.
+template <DetectorLayout Det>
+inline constexpr auto kLinkIndex = [] {
+  constexpr auto kLayers = static_cast<std::size_t>(Detector<Det>::nLayers);
+  std::array<std::size_t, kLayers * kLayers> result{};
+  result.fill(kNoLink);
+  for (std::size_t link = 0; link < nLinks<Det>; ++link) {
+    auto& at = result[(static_cast<std::size_t>(Det::layerLinks[link].from) * kLayers) + Det::layerLinks[link].to];
+    if (at == kNoLink) {
+      at = link;
+    }
+  }
+  return result;
+}();
+
+/// The first link of Det's table from layer \a from to layer \a to; kNoLink
+/// for none or a layer outside the layout.
+template <DetectorLayout Det>
+[[nodiscard]] constexpr std::size_t linkOf(LayerID from, LayerID to)
+{
+  constexpr auto kLayers = static_cast<std::size_t>(Detector<Det>::nLayers);
+  const auto fromIndex = static_cast<std::size_t>(from);
+  const auto toIndex = static_cast<std::size_t>(to);
+  return fromIndex < kLayers && toIndex < kLayers ? kLinkIndex<Det>[(fromIndex * kLayers) + toIndex] : kNoLink;
+}
+
+/// The most layers any path through the links visits, the deepest layer's
+/// depth + 1, which bounds a cell's level at `maxChainLayers - 2`.
+template <DetectorLayout Det>
+inline constexpr std::size_t maxChainLayers = layerDepthGroups<Det>.count;
+
+} // namespace o2::gtrk
+
+#endif // GTRK_BASE_LAYERLINKS_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Base/LayerSpec.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/LayerSpec.h
new file mode 100644
index 0000000000000..91a146ac00099
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/LayerSpec.h
@@ -0,0 +1,259 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file LayerSpec.h
+/// \brief The compile-time half of a detector description.
+///
+/// A detector is a type, not a file: a struct of static constexpr members
+/// satisfying the DetectorLayout concept below.  The layer count, the
+/// barrel/disc split, each layer's sensor count and sensor shape are fixed at
+/// compile time, which is what lets `if constexpr (Detector<Det>::hasDiscs)`
+/// remove the forward tracking paths entirely from a barrel-only detector.
+/// Where each sensor sits is runtime data, the experiment's geometry -- see
+/// Geometry.h.
+///
+/// Barrel and disc layers are kept in two separate arrays rather than one
+/// tagged array on purpose.  It makes a detector without discs express that as
+/// an empty array, and it makes the loops over each kind naturally separable,
+/// so the eliminated branch does not have to be found by the optimiser.
+///
+/// Units are centimetres and radians, following O2 and TGeo, and every
+/// geometric quantity is double.  Geometry is built once, so the precision is
+/// free here, and it keeps alignment clear of rounding that has to be reasoned
+/// about.  The tracking narrows to float at its own boundary, where bandwidth
+/// and registers actually matter; O2 draws the same line, with DetMatrixCache
+/// holding double Transform3D but float Rotation2D.
+
+#ifndef GTRK_BASE_LAYERSPEC_H_
+#define GTRK_BASE_LAYERSPEC_H_
+
+#include "GenericTracking/Base/Definitions.h"
+
+#include <algorithm>
+#include <cmath>
+#include <concepts>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <utility>
+
+namespace o2::gtrk
+{
+
+/// Outline of a sensor in its own plane -- or, for a curved sensor, in the
+/// plane its surface unrolls into.
+enum class ShapeType : std::uint8_t {
+  kRectangle, ///< halfX applies along the whole length
+  kCylinder   ///< a rectangle rolled onto a cylinder; see SensorSpec::radius
+};
+
+/// The sensor's local frame is right-handed with
+///   x across the sensor (pixel rows),
+///   y along it (pixel columns),
+///   z normal to it (thickness).
+/// Every sensor of a layer -- or of a disc ring -- shares one of these.
+struct SensorSpec {
+  ShapeType shape;
+  double halfX;         ///< half width
+  double halfY;         ///< half length
+  double halfThickness; ///< half the active silicon thickness
+  double pitchX;        ///< pixel pitch across the sensor
+  double pitchY;        ///< pixel pitch along the sensor
+  /// kCylinder only: the radius of the sensor's inner surface about its local z
+  /// axis, as O2 measures a curved sensor's flat coordinate on it
+  /// (TRKBase/SegmentationChip.h, `curvedToFlat`). The unrolled x is the arc
+  /// length at this radius from the local +x axis, counter-clockwise, and y is
+  /// the local z; the silicon runs from here outwards over 2 halfThickness.
+  double radius = 0.;
+
+  [[nodiscard]] constexpr bool curved() const { return shape == ShapeType::kCylinder; }
+
+  /// A point of the sensor in its own frame, from its unrolled coordinates:
+  /// \a x across, \a y along, \a z off the surface. A flat sensor's frame is
+  /// those coordinates; a curved one's is the cylinder's, the point at angle
+  /// x / radius from the local +x axis and radius + z from the local z axis.
+  void unrolledToFrame(double x, double y, double z, double frame[3]) const
+  {
+    if (!curved()) {
+      frame[0] = x;
+      frame[1] = y;
+      frame[2] = z;
+      return;
+    }
+    const double angle = x / radius;
+    frame[0] = (radius + z) * std::cos(angle);
+    frame[1] = (radius + z) * std::sin(angle);
+    frame[2] = y;
+  }
+
+  /// The range of the unrolled z the silicon spans: +-halfThickness about a
+  /// flat sensor's plane, 2 halfThickness outwards from a curved one's radius.
+  [[nodiscard]] constexpr double surfaceMin() const { return curved() ? 0. : -halfThickness; }
+  [[nodiscard]] constexpr double surfaceMax() const { return curved() ? 2. * halfThickness : halfThickness; }
+};
+
+/// Where a layer's silicon is, as the measurement grid, the search windows
+/// and the material sampling ask for it: the nominal distance from the
+/// interaction point and the hull of the active silicon in r and z.
+///
+/// Measured from the geometry the layout was loaded with (LayerEnvelopes.h):
+/// where its chips sit is run-time data, aligned as the geometry is, and
+/// nothing compiled states or checks it.
+struct LayerEnvelope {
+  double position; ///< barrel: nominal radius; disc: signed z [cm]
+  double rMin;     ///< [cm]
+  double rMax;
+  double zMin;
+  double zMax;
+};
+
+/// A layer whose sensors are placed from outside, from an experiment's own
+/// geometry, as O2's GeometryTGeo places the ALICE ITS and MFT chips.
+///
+/// Only topology is compile-time: the sensor count, which sizes the geometry
+/// and tells a wrong file apart, and the sensor shape. The layer's envelope is
+/// measured when the geometry is loaded (LayerEnvelopes.h).
+///
+/// A layout uses this type for both its barrel and its disc arrays. Barrel
+/// and disc still differ in which second coordinate a layer is binned in, and
+/// that is all the tracking asks of the kind.
+struct PlacedLayerSpec {
+  int sensorCount;
+  SensorSpec sensor;
+
+  [[nodiscard]] constexpr int nSensors() const { return sensorCount; }
+};
+
+/// One directed link of a detector's layer graph: a track from the luminous
+/// region crosses `from` and then `to`, with no active layer in between.
+///
+/// The links are part of the detector's specification, like the ring radii
+/// they follow from. `o2-gtrk-layer-links` traces them from the layout once
+/// and prints the table to paste in; nothing derives them at run time.
+///
+/// The source interval is the range of the seed's second coordinate -- z on a
+/// barrel layer, r on a disc -- from which the trace reaches `to`, padded by
+/// the margin the tool was given. A seed outside it does not query the link.
+/// `skipsLayer` is traced too: true when every traced trajectory on the link
+/// crosses another layer's envelope between its ends, so no pair on it can be
+/// direct. On the other links each pair's own segment decides
+/// (Tracking/LinkHoles.h).
+struct LayerLink {
+  LayerID from;
+  LayerID to;
+  double sourceMin; ///< [cm]
+  double sourceMax; ///< [cm]
+  bool skipsLayer;
+};
+
+/// Passive material that scatters but measures nothing -- the beam pipe first
+/// -- placed by its own position among the measurement layers, which may lie
+/// on both sides of it.
+///
+/// A cylinder or a disc. `position` is where its kink is taken, the radius or
+/// the signed z; `bandLow`/`bandHigh` are the stretch of that axis whose
+/// material it owns -- a layer's material slab stops there, so nothing is
+/// counted twice; `low`/`high` its extent along the other axis. `x2X0` is the
+/// nominal normal-incidence budget, for a run without a material LUT; with
+/// one, the LUT's across the band stands in.
+struct PassiveSpec {
+  enum class Kind : std::uint8_t { kBarrel,
+                                   kDisc };
+  Kind kind;
+  double position; ///< barrel: radius; disc: signed z [cm]
+  double bandLow;  ///< [cm], along the same axis as position
+  double bandHigh;
+  double low; ///< extent along the other axis: z for a barrel, r for a disc [cm]
+  double high;
+  double x2X0; ///< nominal normal-incidence x/X0
+};
+
+/// O2's beryllium beam pipe, as the ALICE ITS and MFT see it (O2's
+/// Detectors/Passive/src/Pipe.cxx): outer radius 1.9 cm, 0.8 mm thick, over
+/// |z| < 44.4 cm; 0.08 cm over beryllium's X0 of 35.28 cm.
+inline constexpr PassiveSpec kAliceBerylliumPipe{.kind = PassiveSpec::Kind::kBarrel, .position = 1.86, .bandLow = 1.8, .bandHigh = 1.95, .low = -44.4, .high = 44.4, .x2X0 = 0.08 / 35.28};
+
+/// What a detector type has to provide.
+///
+/// Derived quantities -- layer counts, hasBarrel, hasDiscs -- are deliberately
+/// not required members: they are computed below, so a detector cannot state
+/// one of them inconsistently with its own arrays. What follows from the link
+/// table is in LayerLinks.h.
+template <typename Det>
+concept DetectorLayout = requires {
+  { Det::name } -> std::convertible_to<const char*>;
+  { Det::nSensors } -> std::convertible_to<int>;
+  { Det::layerLinks[0] } -> std::convertible_to<const LayerLink&>;
+  { Det::barrelLayers[0] } -> std::convertible_to<const PlacedLayerSpec&>;
+  { Det::discLayers[0] } -> std::convertible_to<const PlacedLayerSpec&>;
+};
+
+/// Compile-time queries derived from one detector layout.
+///
+/// Keeping them on one traits type gives tracking code a detector-level API
+/// without requiring each layout to repeat facts that follow from its arrays.
+template <DetectorLayout Layout>
+struct Detector {
+  static constexpr int nBarrelLayers = static_cast<int>(std::size(Layout::barrelLayers));
+  static constexpr int nDiscLayers = static_cast<int>(std::size(Layout::discLayers));
+  static constexpr int nLayers = nBarrelLayers + nDiscLayers;
+  static constexpr bool hasBarrel = nBarrelLayers > 0;
+  static constexpr bool hasDiscs = nDiscLayers > 0;
+  /// Whether any layer's sensors are curved (SensorSpec::curved).
+  static constexpr bool hasCurvedSensors = [] {
+    const auto curved = [](const auto& layer) { return layer.sensor.curved(); };
+    return std::ranges::any_of(Layout::barrelLayers, curved) || std::ranges::any_of(Layout::discLayers, curved);
+  }();
+  /// Passive scatterers (PassiveSpec), if the layout declares any.
+  static constexpr int nPassives = [] {
+    if constexpr (requires { Layout::passives; }) {
+      return static_cast<int>(std::size(Layout::passives));
+    } else {
+      return 0;
+    }
+  }();
+
+  /// Layers are numbered barrel first, then discs.
+  [[nodiscard]] static constexpr bool isBarrelLayer(LayerID layer) { return hasBarrel && std::cmp_less(layer, nBarrelLayers); }
+
+  /// Position of a disc layer within Layout::discLayers.
+  [[nodiscard]] static constexpr std::size_t discIndex(LayerID layer) { return static_cast<std::size_t>(layer) - static_cast<std::size_t>(nBarrelLayers); }
+
+  /// Passive scatterer \a index of the layout.
+  [[nodiscard]] static constexpr const PassiveSpec& passive(std::size_t index)
+    requires(nPassives > 0)
+  {
+    return Layout::passives[index];
+  }
+
+  /// A layer's stated sensor count.
+  [[nodiscard]] static constexpr int sensorCount(LayerID layer) { return isBarrelLayer(layer) ? Layout::barrelLayers[layer].sensorCount : Layout::discLayers[discIndex(layer)].sensorCount; }
+};
+
+/// Total sensor count of a detector, for the detector struct to use when
+/// declaring its own nSensors -- keeping that number derived rather than typed
+/// in a second time.
+template <typename BarrelArray, typename DiscArray>
+[[nodiscard]] constexpr int countSensors(const BarrelArray& barrel, const DiscArray& discs)
+{
+  int n = 0;
+  for (const auto& layer : barrel) {
+    n += layer.nSensors();
+  }
+  for (const auto& layer : discs) {
+    n += layer.nSensors();
+  }
+  return n;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_BASE_LAYERSPEC_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Base/PortableMath.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/PortableMath.h
new file mode 100644
index 0000000000000..1dc2dcd301f3d
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/PortableMath.h
@@ -0,0 +1,503 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file PortableMath.h
+/// \brief sin, cos, atan, atan2, asin and log in double, the same bits on the
+///        host and on every device.
+///
+/// The deterministic build asks the host and the devices for bit-identical
+/// results, and their math libraries do not give them: none of glibc's,
+/// CUDA's or ROCm's double sin, cos or atan2 is correctly rounded, and each
+/// rounds differently in the last place. CUDA's atan2 differs from glibc's
+/// on many of the propagator's turn angles, by up to 2 ulp. O2's deterministic
+/// mode survives this in float, since a double result rounded to float hides
+/// an ulp of double almost always; the propagator's arithmetic is double, and
+/// the ulp reaches the tracks' times.
+///
+/// So the deterministic build computes them here, from fdlibm's algorithms as
+/// FreeBSD's msun has them: only +, -, *, / and sqrt, which IEEE 754 rounds
+/// correctly everywhere, and integer operations on the bits. With contraction
+/// off -- -ffp-contract=off, nvcc's --fmad=false, as the deterministic build
+/// sets -- every step is the same operation on the same operands on any
+/// target. The accuracy is fdlibm's: under 1 ulp, atan2 under 2.
+///
+/// Arguments of sin and cos beyond 2^20 pi/2 (1.6e6) fall back to the native
+/// functions: fdlibm reduces them with a 1584-bit table of 2/pi, and no
+/// tracking angle comes near. A NaN argument is returned as it is, and an
+/// invalid one gives one quiet NaN, so even those are the same bits.
+
+#ifndef GTRK_BASE_PORTABLEMATH_H_
+#define GTRK_BASE_PORTABLEMATH_H_
+
+#include "GenericTracking/Base/Definitions.h"
+
+#include "GPUCommonMath.h"
+
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <bit>
+#endif
+#include <cstdint>
+#include <numbers>
+
+namespace o2::gtrk::portable
+{
+
+namespace detail
+{
+
+GPUhdi() GPUAlwaysInline() std::uint64_t bits(double x)
+{
+#ifdef GPUCA_GPUCODE_DEVICE
+  return static_cast<std::uint64_t>(__double_as_longlong(x));
+#else
+  return std::bit_cast<std::uint64_t>(x);
+#endif
+}
+
+GPUhdi() GPUAlwaysInline() double fromBits(std::uint64_t b)
+{
+#ifdef GPUCA_GPUCODE_DEVICE
+  return __longlong_as_double(static_cast<long long>(b));
+#else
+  return std::bit_cast<double>(b);
+#endif
+}
+
+/// The high word, fdlibm's GET_HIGH_WORD.
+GPUhdi() GPUAlwaysInline() std::uint32_t high(double x) { return static_cast<std::uint32_t>(bits(x) >> 32U); }
+GPUhdi() GPUAlwaysInline() std::uint32_t low(double x) { return static_cast<std::uint32_t>(bits(x)); }
+GPUhdi() GPUAlwaysInline() double withHigh(double x, std::uint32_t word) { return fromBits((std::uint64_t{word} << 32U) | low(x)); }
+GPUhdi() GPUAlwaysInline() double withLowZero(double x) { return fromBits(bits(x) & 0xFFFFFFFF00000000ULL); }
+GPUhdi() GPUAlwaysInline() double absOf(double x) { return fromBits(bits(x) & 0x7FFFFFFFFFFFFFFFULL); }
+GPUhdi() GPUAlwaysInline() bool negative(double x) { return (bits(x) >> 63U) != 0U; }
+/// By the bits, not by comparison: -Wfloat-equal, and no fast-math
+/// assumption about NaNs can remove them.
+GPUhdi() GPUAlwaysInline() bool isNaN(double x) { return (bits(x) & 0x7FFFFFFFFFFFFFFFULL) > 0x7FF0000000000000ULL; }
+GPUhdi() GPUAlwaysInline() bool isZero(double x) { return (bits(x) & 0x7FFFFFFFFFFFFFFFULL) == 0U; }
+GPUhdi() GPUAlwaysInline() int biasedExponent(double x) { return static_cast<int>((high(x) >> 20U) & 0x7FFU); }
+
+GPUhdi() GPUAlwaysInline() double quietNaN() { return fromBits(0x7FF8000000000000ULL); }
+GPUhdi() GPUAlwaysInline() double infinity() { return fromBits(0x7FF0000000000000ULL); }
+
+/// pi/2, pi/4 and pi/2's tail (pi/2 - kPio2), as fdlibm splits them.
+constexpr double kPio2 = 1.57079632679489655800e+00;
+constexpr double kPio4 = 7.85398163397448278999e-01;
+constexpr double kPio2Lo = 6.12323399573676603587e-17;
+
+/// sin on [-pi/4, pi/4] of x + y, y the tail of a reduced argument;
+/// \a hasTail false when y is zero. fdlibm's __kernel_sin.
+GPUhdi() GPUAlwaysInline() double kernelSin(double x, double y, bool hasTail)
+{
+  constexpr double kS1 = -1.66666666666666324348e-01;
+  constexpr double kS2 = 8.33333333332248946124e-03;
+  constexpr double kS3 = -1.98412698298579493134e-04;
+  constexpr double kS4 = 2.75573137070700676789e-06;
+  constexpr double kS5 = -2.50507602534068634195e-08;
+  constexpr double kS6 = 1.58969099521155010221e-10;
+  const double z = x * x;
+  const double w = z * z;
+  const double r = kS2 + z * (kS3 + z * kS4) + z * w * (kS5 + z * kS6);
+  const double v = z * x;
+  if (!hasTail) {
+    return x + v * (kS1 + z * r);
+  }
+  return x - ((z * (0.5 * y - v * r) - y) - v * kS1);
+}
+
+/// cos on [-pi/4, pi/4] of x + y. fdlibm's __kernel_cos, as msun has it.
+GPUhdi() GPUAlwaysInline() double kernelCos(double x, double y)
+{
+  constexpr double kC1 = 4.16666666666666019037e-02;
+  constexpr double kC2 = -1.38888888888741095749e-03;
+  constexpr double kC3 = 2.48015872894767294178e-05;
+  constexpr double kC4 = -2.75573143513906633035e-07;
+  constexpr double kC5 = 2.08757232129817482790e-09;
+  constexpr double kC6 = -1.13596475577881948265e-11;
+  const double z = x * x;
+  double w = z * z;
+  const double r = z * (kC1 + z * (kC2 + z * kC3)) + w * w * (kC4 + z * (kC5 + z * kC6));
+  const double hz = 0.5 * z;
+  w = 1.0 - hz;
+  return w + (((1.0 - w) - hz) + (z * r - x * y));
+}
+
+/// x - n pi/2 as y0 + y1, and n, for pi/4 < |x| < 2^20 pi/2: fdlibm's
+/// __ieee754_rem_pio2, the medium-size path, pi/2 in three parts of 33 bits
+/// so that n times each is exact.
+GPUhdi() GPUAlwaysInline() int remPio2(double x, double& y0, double& y1)
+{
+  constexpr double kInvPio2 = 6.36619772367581382433e-01;
+  constexpr double kPio2Part1 = 1.57079632673412561417e+00;
+  constexpr double kPio2Tail1 = 6.07710050650619224932e-11;
+  constexpr double kPio2Part2 = 6.07710050630396597660e-11;
+  constexpr double kPio2Tail2 = 2.02226624879595063154e-21;
+  constexpr double kPio2Part3 = 2.02226624871116645580e-21;
+  constexpr double kPio2Tail3 = 8.47842766036889956997e-32;
+  // 1.5 * 2^52: adding and subtracting it rounds to the nearest integer.
+  constexpr double kToInteger = 6755399441055744.0;
+  const double fn = (x * kInvPio2 + kToInteger) - kToInteger;
+  const int n = static_cast<int>(fn);
+  double r = x - fn * kPio2Part1;
+  double w = fn * kPio2Tail1;
+  const int j = biasedExponent(x);
+  y0 = r - w;
+  if (j - biasedExponent(y0) > 16) { // cancellation: a second round, 118 bits
+    double t = r;
+    w = fn * kPio2Part2;
+    r = t - w;
+    w = fn * kPio2Tail2 - ((t - r) - w);
+    y0 = r - w;
+    if (j - biasedExponent(y0) > 49) { // and a third, 151 bits
+      t = r;
+      w = fn * kPio2Part3;
+      r = t - w;
+      w = fn * kPio2Tail3 - ((t - r) - w);
+      y0 = r - w;
+    }
+  }
+  y1 = (r - y0) - w;
+  return n;
+}
+
+/// atan(c) for c = 1/2, 1, 3/2 and infinity, as a high and a low part. A
+/// switch, not a local array: HIP, compiling with real calls and relocatable
+/// device code, reads wrong values from such an array.
+GPUhdi() GPUAlwaysInline() double atanHi(int id)
+{
+  switch (id) {
+    case 0:
+      return 4.63647609000806093515e-01;
+    case 1:
+      return kPio4;
+    case 2:
+      return 9.82793723247329054082e-01;
+    default:
+      return kPio2;
+  }
+}
+
+GPUhdi() GPUAlwaysInline() double atanLo(int id)
+{
+  switch (id) {
+    case 0:
+      return 2.26987774529616870924e-17;
+    case 1:
+      return 3.06161699786838301793e-17;
+    case 2:
+      return 1.39033110312309984516e-17;
+    default:
+      return kPio2Lo;
+  }
+}
+
+/// |x| at or above 2^20 pi/2, where remPio2 no longer applies.
+constexpr std::uint32_t kLargeArgument = 0x413921FBU;
+
+} // namespace detail
+
+GPUhdi() GPUAlwaysInline() double sin(double x)
+{
+  const std::uint32_t ix = detail::high(x) & 0x7FFFFFFFU;
+  if (ix <= 0x3FE921FBU) {  // |x| <~ pi/4
+    if (ix < 0x3E500000U) { // |x| < 2^-26: sin x is x
+      return x;
+    }
+    return detail::kernelSin(x, 0., false);
+  }
+  if (ix >= 0x7FF00000U) {
+    return detail::isNaN(x) ? x : detail::quietNaN();
+  }
+  if (ix >= detail::kLargeArgument) {
+    return o2::gpu::CAMath::Sind(x); // beyond remPio2's reach
+  }
+  double y0 = 0.;
+  double y1 = 0.;
+  switch (detail::remPio2(x, y0, y1) & 3) {
+    case 0:
+      return detail::kernelSin(y0, y1, true);
+    case 1:
+      return detail::kernelCos(y0, y1);
+    case 2:
+      return -detail::kernelSin(y0, y1, true);
+    default:
+      return -detail::kernelCos(y0, y1);
+  }
+}
+
+GPUhdi() GPUAlwaysInline() double cos(double x)
+{
+  const std::uint32_t ix = detail::high(x) & 0x7FFFFFFFU;
+  if (ix <= 0x3FE921FBU) {
+    if (ix < 0x3E46A09EU) { // |x| < 2^-27 sqrt(2): cos x is 1
+      return 1.;
+    }
+    return detail::kernelCos(x, 0.);
+  }
+  if (ix >= 0x7FF00000U) {
+    return detail::isNaN(x) ? x : detail::quietNaN();
+  }
+  if (ix >= detail::kLargeArgument) {
+    return o2::gpu::CAMath::Cosd(x); // beyond remPio2's reach
+  }
+  double y0 = 0.;
+  double y1 = 0.;
+  switch (detail::remPio2(x, y0, y1) & 3) {
+    case 0:
+      return detail::kernelCos(y0, y1);
+    case 1:
+      return -detail::kernelSin(y0, y1, true);
+    case 2:
+      return -detail::kernelCos(y0, y1);
+    default:
+      return detail::kernelSin(y0, y1, true);
+  }
+}
+
+/// fdlibm's s_atan.c: atan(x) = atan(c) + atan((x - c) / (1 + x c)) for c
+/// one of 0, 1/2, 1, 3/2 and infinity, then an odd polynomial.
+GPUhdi() GPUAlwaysInline() double atan(double x)
+{
+  constexpr double kAt0 = 3.33333333333329318027e-01;
+  constexpr double kAt1 = -1.99999999998764832476e-01;
+  constexpr double kAt2 = 1.42857142725034663711e-01;
+  constexpr double kAt3 = -1.11111104054623557880e-01;
+  constexpr double kAt4 = 9.09088713343650656196e-02;
+  constexpr double kAt5 = -7.69187620504482999495e-02;
+  constexpr double kAt6 = 6.66107313738753120669e-02;
+  constexpr double kAt7 = -5.83357013379057348645e-02;
+  constexpr double kAt8 = 4.97687799461593236017e-02;
+  constexpr double kAt9 = -3.65315727442169155270e-02;
+  constexpr double kAt10 = 1.62858201153657823623e-02;
+
+  const bool sign = detail::negative(x);
+  const std::uint32_t ix = detail::high(x) & 0x7FFFFFFFU;
+  if (ix >= 0x44100000U) { // |x| >= 2^66, or not finite
+    if (detail::isNaN(x)) {
+      return x;
+    }
+    return sign ? -detail::atanHi(3) - detail::atanLo(3) : detail::atanHi(3) + detail::atanLo(3);
+  }
+  int id = -1;
+  if (ix < 0x3FDC0000U) {   // |x| < 0.4375
+    if (ix < 0x3E400000U) { // |x| < 2^-27: atan x is x
+      return x;
+    }
+  } else {
+    x = detail::absOf(x);
+    if (ix < 0x3FF30000U) {   // |x| < 1.1875
+      if (ix < 0x3FE60000U) { // 7/16 <= |x| < 11/16
+        id = 0;
+        x = (2.0 * x - 1.0) / (2.0 + x);
+      } else { // 11/16 <= |x| < 19/16
+        id = 1;
+        x = (x - 1.0) / (x + 1.0);
+      }
+    } else if (ix < 0x40038000U) { // |x| < 2.4375
+      id = 2;
+      x = (x - 1.5) / (1.0 + 1.5 * x);
+    } else { // 2.4375 <= |x| < 2^66
+      id = 3;
+      x = -1.0 / x;
+    }
+  }
+  const double z = x * x;
+  const double w = z * z;
+  // The odd and the even terms of the polynomial, apart.
+  const double s1 = z * (kAt0 + w * (kAt2 + w * (kAt4 + w * (kAt6 + w * (kAt8 + w * kAt10)))));
+  const double s2 = w * (kAt1 + w * (kAt3 + w * (kAt5 + w * (kAt7 + w * kAt9))));
+  if (id < 0) {
+    return x - x * (s1 + s2);
+  }
+  const double result = detail::atanHi(id) - ((x * (s1 + s2) - detail::atanLo(id)) - x);
+  return sign ? -result : result;
+}
+
+/// fdlibm's e_atan2.c: atan(|y / x|), placed in its quadrant.
+GPUhdi() GPUAlwaysInline() double atan2(double y, double x)
+{
+  constexpr double kPi = std::numbers::pi;
+  constexpr double kPiLo = 2.0 * detail::kPio2Lo;
+  constexpr double kPiOver2 = detail::kPio2;
+  constexpr double kPiOver4 = detail::kPio4;
+
+  if (detail::isNaN(x)) {
+    return x;
+  }
+  if (detail::isNaN(y)) {
+    return y;
+  }
+  if (detail::bits(x) == 0x3FF0000000000000ULL) { // x = 1
+    return atan(y);
+  }
+  const bool yNegative = detail::negative(y);
+  const bool xNegative = detail::negative(x);
+  const auto ix = static_cast<std::int32_t>(detail::high(x) & 0x7FFFFFFFU);
+  const auto iy = static_cast<std::int32_t>(detail::high(y) & 0x7FFFFFFFU);
+
+  if (detail::isZero(y)) {
+    if (!xNegative) {
+      return y; // atan2(+-0, +anything) = +-0
+    }
+    return yNegative ? -kPi : kPi; // atan2(+-0, -anything) = +-pi
+  }
+  if (detail::isZero(x)) {
+    return yNegative ? -kPiOver2 : kPiOver2;
+  }
+  if (ix == 0x7FF00000) { // x infinite
+    if (iy == 0x7FF00000) {
+      const double angle = xNegative ? 3.0 * kPiOver4 : kPiOver4;
+      return yNegative ? -angle : angle;
+    }
+    const double angle = xNegative ? kPi : 0.;
+    return yNegative ? -angle : angle;
+  }
+  if (iy == 0x7FF00000) {
+    return yNegative ? -kPiOver2 : kPiOver2;
+  }
+
+  double z = 0.;
+  const std::int32_t k = (iy - ix) >> 20;
+  bool leftHalf = xNegative;
+  if (k > 60) { // |y / x| > 2^60
+    z = kPiOver2 + 0.5 * kPiLo;
+    leftHalf = false;
+  } else if (xNegative && k < -60) { // 0 > |y| / x > -2^-60
+    z = 0.;
+  } else {
+    z = atan(detail::absOf(y / x));
+  }
+  if (!leftHalf) {
+    return yNegative ? -z : z;
+  }
+  return yNegative ? (z - kPiLo) - kPi : kPi - (z - kPiLo);
+}
+
+/// fdlibm's e_asin.c: a rational approximation below 1/2, and above it
+/// asin x = pi/2 - 2 asin(sqrt((1 - x) / 2)).
+GPUhdi() GPUAlwaysInline() double asin(double x)
+{
+  constexpr double kPio2Hi = detail::kPio2;
+  constexpr double kPio2Lo = detail::kPio2Lo;
+  constexpr double kPio4Hi = detail::kPio4;
+  constexpr double kPS0 = 1.66666666666666657415e-01;
+  constexpr double kPS1 = -3.25565818622400915405e-01;
+  constexpr double kPS2 = 2.01212532134862925881e-01;
+  constexpr double kPS3 = -4.00555345006794114027e-02;
+  constexpr double kPS4 = 7.91534994289814532176e-04;
+  constexpr double kPS5 = 3.47933107596021167570e-05;
+  constexpr double kQS1 = -2.40339491173441421878e+00;
+  constexpr double kQS2 = 2.02094576023350569471e+00;
+  constexpr double kQS3 = -6.88283971605453293030e-01;
+  constexpr double kQS4 = 7.70381505559019352791e-02;
+
+  const std::uint32_t ix = detail::high(x) & 0x7FFFFFFFU;
+  if (ix >= 0x3FF00000U) { // |x| >= 1, or not a number
+    if (detail::isNaN(x)) {
+      return x;
+    }
+    if (((ix - 0x3FF00000U) | detail::low(x)) == 0U) { // asin(+-1) = +-pi/2
+      return x * kPio2Hi + x * kPio2Lo;
+    }
+    return detail::quietNaN();
+  }
+  if (ix < 0x3FE00000U) {   // |x| < 1/2
+    if (ix < 0x3E500000U) { // |x| < 2^-26: asin x is x
+      return x;
+    }
+    const double t = x * x;
+    const double p = t * (kPS0 + t * (kPS1 + t * (kPS2 + t * (kPS3 + t * (kPS4 + t * kPS5)))));
+    const double q = 1.0 + t * (kQS1 + t * (kQS2 + t * (kQS3 + t * kQS4)));
+    return x + x * (p / q);
+  }
+  // 1/2 <= |x| < 1
+  const double w = 1.0 - detail::absOf(x);
+  double t = w * 0.5;
+  double p = t * (kPS0 + t * (kPS1 + t * (kPS2 + t * (kPS3 + t * (kPS4 + t * kPS5)))));
+  double q = 1.0 + t * (kQS1 + t * (kQS2 + t * (kQS3 + t * kQS4)));
+  const double s = o2::gpu::CAMath::Sqrtd(t);
+  if (ix >= 0x3FEF3333U) { // |x| > 0.975
+    t = kPio2Hi - (2.0 * (s + s * (p / q)) - kPio2Lo);
+  } else {
+    // s split as its high word and the rest, c, for the extra bits.
+    const double high = detail::withLowZero(s);
+    const double c = (t - high * high) / (s + high);
+    const double r = p / q;
+    p = 2.0 * s * r - (kPio2Lo - 2.0 * c);
+    q = kPio4Hi - 2.0 * high;
+    t = kPio4Hi - (p - q);
+  }
+  return detail::negative(x) ? -t : t;
+}
+
+/// fdlibm's e_log.c: x = 2^k (1 + f), sqrt(2)/2 < 1 + f < sqrt(2), and
+/// log(1 + f) from s = f / (2 + f).
+GPUhdi() GPUAlwaysInline() double log(double x)
+{
+  constexpr double kLn2Hi = 6.93147180369123816490e-01; // NOLINT(modernize-use-std-numbers): ln 2 split, not ln 2
+  constexpr double kLn2Lo = 1.90821492927058770002e-10;
+  constexpr double kTwo54 = 1.80143985094819840000e+16;
+  constexpr double kLg1 = 6.666666666666735130e-01;
+  constexpr double kLg2 = 3.999999999940941908e-01;
+  constexpr double kLg3 = 2.857142874366239149e-01;
+  constexpr double kLg4 = 2.222219843214978396e-01;
+  constexpr double kLg5 = 1.818357216161805012e-01;
+  constexpr double kLg6 = 1.531383769920937332e-01;
+  constexpr double kLg7 = 1.479819860511658591e-01;
+
+  if (detail::isNaN(x)) {
+    return x;
+  }
+  auto hx = static_cast<std::int32_t>(detail::high(x));
+  std::int32_t k = 0;
+  if (hx < 0x00100000) { // x < 2^-1022: zero, negative or subnormal
+    if (((static_cast<std::uint32_t>(hx) & 0x7FFFFFFFU) | detail::low(x)) == 0U) {
+      return -detail::infinity();
+    }
+    if (hx < 0) {
+      return detail::quietNaN();
+    }
+    k -= 54;
+    x *= kTwo54;
+    hx = static_cast<std::int32_t>(detail::high(x));
+  }
+  if (hx >= 0x7FF00000) {
+    return x; // +infinity
+  }
+  k += (hx >> 20) - 1023;
+  hx &= 0x000FFFFF;
+  const std::int32_t i = (hx + 0x95F64) & 0x100000;
+  x = detail::withHigh(x, static_cast<std::uint32_t>(hx | (i ^ 0x3FF00000))); // x or x/2 into [sqrt(2)/2, sqrt(2))
+  k += i >> 20;
+  const double f = x - 1.0;
+  const auto dk = static_cast<double>(k);
+  if ((0x000FFFFF & (2 + hx)) < 3) { // -2^-20 <= f < 2^-20
+    if (detail::isZero(f)) {
+      return k == 0 ? 0. : dk * kLn2Hi + dk * kLn2Lo;
+    }
+    const double r = f * f * (0.5 - 0.33333333333333333 * f);
+    return k == 0 ? f - r : dk * kLn2Hi - ((r - dk * kLn2Lo) - f);
+  }
+  const double s = f / (2.0 + f);
+  const double z = s * s;
+  const double w = z * z;
+  const double t1 = w * (kLg2 + w * (kLg4 + w * kLg6));
+  const double t2 = z * (kLg1 + w * (kLg3 + w * (kLg5 + w * kLg7)));
+  const double r = t2 + t1;
+  if (((hx - 0x6147A) | (0x6B851 - hx)) > 0) {
+    const double hfsq = 0.5 * f * f;
+    return k == 0 ? f - (hfsq - s * (hfsq + r)) : dk * kLn2Hi - ((hfsq - (s * (hfsq + r) + dk * kLn2Lo)) - f);
+  }
+  return k == 0 ? f - s * (f - r) : dk * kLn2Hi - ((s * (f - r) - dk * kLn2Lo) - f);
+}
+
+} // namespace o2::gtrk::portable
+
+#endif // GTRK_BASE_PORTABLEMATH_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Base/Sensor.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/Sensor.h
new file mode 100644
index 0000000000000..afcdbf2f3d564
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/Sensor.h
@@ -0,0 +1,54 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Sensor.h
+/// \brief Placement of one sensor, and the transform between its frame and the
+///        global one.
+///
+/// Plain doubles, no TGeoHMatrix: a Sensor is trivially copyable and an array
+/// of them is one contiguous block.  The rotation is stored whole rather than
+/// as angles because the callers apply it, they do not interpolate it.
+///
+/// This is the host-side geometry, and it is deliberately double.  It is built
+/// once, so the precision costs nothing, and it keeps alignment and the
+/// differencing of large coordinates clear of rounding.  Device code does not
+/// use this type: the tracking builds its own float SoA at its boundary, which
+/// is where narrow types start to pay for themselves.
+
+#ifndef GTRK_BASE_SENSOR_H_
+#define GTRK_BASE_SENSOR_H_
+
+#include "GenericTracking/Base/Definitions.h"
+
+namespace o2::gtrk
+{
+
+/// A sensor's position and orientation.
+///
+/// \c rot is row-major and maps local to global, so its columns are the local
+/// axes expressed in global coordinates.
+struct Sensor {
+  double rot[9];   ///< row-major local -> global rotation
+  double trans[3]; ///< sensor centre in the global frame
+  LayerID layer;   ///< index into the barrel-then-disc layer numbering
+
+  /// global = rot * local + trans
+  void toGlobal(const double l[3], double g[3]) const
+  {
+    g[0] = rot[0] * l[0] + rot[1] * l[1] + rot[2] * l[2] + trans[0];
+    g[1] = rot[3] * l[0] + rot[4] * l[1] + rot[5] * l[2] + trans[1];
+    g[2] = rot[6] * l[0] + rot[7] * l[1] + rot[8] * l[2] + trans[2];
+  }
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_BASE_SENSOR_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Base/TimeEstPS.h b/Detectors/GenericTracking/base/include/GenericTracking/Base/TimeEstPS.h
new file mode 100644
index 0000000000000..ae48dd52e7a0e
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Base/TimeEstPS.h
@@ -0,0 +1,93 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TimeEstPS.h
+/// \brief A measurement's time as a box in picoseconds: O2's `its::TimeEstBC`
+///        with picoseconds for bunch crossings.
+///
+/// A box is `[start, start + width)`, both unsigned 32-bit picoseconds from
+/// the timeframe's start. A 32-orbit timeframe is 2.85e9 ps of the 4.29e9 the
+/// type holds. Nothing in a timeframe is before its start, so nothing stored
+/// is negative.
+///
+/// A bunch crossing is 10^10 / 400789 ps = 24950.78 ps (O2's
+/// `LHCBunchSpacingNS`), not a whole number of picoseconds. A box made from BC
+/// takes its start and its length each rounded down (`psOfBC`): every frame of
+/// one length is equally wide, two boxes overlap exactly when their BC
+/// intervals do -- the rounding, under a picosecond, cannot undo an overlap of
+/// a BC nor make one -- and two frames that touch in BC leave at most a
+/// picosecond between them. A point time in such a gap lies in neither box:
+/// a vertex's containment is quantised to the picosecond, not exact.
+
+#ifndef GTRK_BASE_TIMEESTPS_H_
+#define GTRK_BASE_TIMEESTPS_H_
+
+#include "GenericTracking/Base/Definitions.h"
+
+#include <cstdint>
+
+namespace o2::gtrk
+{
+
+/// A bunch crossing is `kPSPerBCNumerator / kPSPerBCDenominator` ps, exactly
+/// (O2's LHCBunchSpacingNS, a double, is not).
+inline constexpr std::int64_t kPSPerBCNumerator = 10'000'000'000;
+inline constexpr std::int64_t kPSPerBCDenominator = 400'789;
+
+/// \a bc bunch crossings in picoseconds, rounded down, \a bc >= 0.
+GPUhdi() constexpr std::int64_t psOfBC(std::int64_t bc) { return (bc * kPSPerBCNumerator) / kPSPerBCDenominator; }
+
+/// The bunch crossings whose `psOfBC` is \a ps, \a ps >= 0: exact for every
+/// value `psOfBC` returns, which lies less than a picosecond -- far less than
+/// a BC -- below the exact time.
+GPUhdi() constexpr std::int64_t bcOfPS(std::int64_t ps) { return ((ps * kPSPerBCDenominator) + kPSPerBCNumerator - 1) / kPSPerBCNumerator; }
+
+/// A time box `[start, start + width)` in picoseconds, O2's `its::TimeEstBC`.
+struct TimeEstPS {
+  std::uint32_t start = 0U;
+  std::uint32_t width = 0U;
+
+  [[nodiscard]] GPUhdi() constexpr std::uint32_t lower() const { return start; }
+
+  /// The box's end, saturating at the type's range as O2's.
+  [[nodiscard]] GPUhdi() constexpr std::uint32_t upper() const
+  {
+    constexpr std::uint32_t kMax = std::numeric_limits<std::uint32_t>::max();
+    return start > kMax - width ? kMax : start + width;
+  }
+
+  /// The boxes overlap.
+  [[nodiscard]] GPUhdi() constexpr bool isCompatible(const TimeEstPS& other) const { return upper() > other.lower() && other.upper() > lower(); }
+
+  /// Narrows to the intersection with \a other, which must overlap.
+  GPUhdi() constexpr TimeEstPS& operator+=(const TimeEstPS& other)
+  {
+    const std::uint32_t lo = lower() > other.lower() ? lower() : other.lower();
+    const std::uint32_t hi = upper() < other.upper() ? upper() : other.upper();
+    start = lo;
+    width = hi - lo;
+    return *this;
+  }
+};
+
+/// The box of a readout frame `[startBC, endBC)` widened by \a marginBC at
+/// both ends and clamped at the timeframe's start in BC, as O2's
+/// `getROFTimeBounds(rof, true)`; its start and its length rounded down.
+GPUhdi() constexpr TimeEstPS frameBox(std::int64_t startBC, std::int64_t endBC, std::int64_t marginBC)
+{
+  const std::int64_t lowerBC = startBC > marginBC ? startBC - marginBC : 0;
+  const std::int64_t upperBC = endBC + marginBC;
+  return {.start = static_cast<std::uint32_t>(psOfBC(lowerBC)), .width = static_cast<std::uint32_t>(psOfBC(upperBC - lowerBC))};
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_BASE_TIMEESTPS_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Detectors/Alpide.h b/Detectors/GenericTracking/base/include/GenericTracking/Detectors/Alpide.h
new file mode 100644
index 0000000000000..b39c53f3e8cb4
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Detectors/Alpide.h
@@ -0,0 +1,52 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Alpide.h
+/// \brief The ALPIDE chip of the ALICE ITS and MFT, as a sensor shape.
+///
+/// Only the active matrix: 512 rows of 26.88 um across the chip, 1024
+/// columns of 29.24 um along it, and the 28 um effective sensitive
+/// thickness. The passive edges are not silicon a cluster can come from, and
+/// the adapter centres each surface on the active matrix rather than on the
+/// chip (GenericTracking/Alice/Placement.h), so the bounds stay symmetric.
+///
+/// Our local x is ALICE's local x (across the rows) and our y is ALICE's
+/// local z (along the columns). The numbers are O2's
+/// ITSMFTBase/SegmentationAlpide.h, restated here in double (O2's are float)
+/// so that the layouts need no O2 detector library; Placement.cxx asserts
+/// that they agree.
+
+#ifndef GTRK_DETECTORS_ALPIDE_H_
+#define GTRK_DETECTORS_ALPIDE_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+
+namespace o2::gtrk::detectors::alpide
+{
+
+inline constexpr int kRows = 512;
+inline constexpr int kColumns = 1024;
+inline constexpr double kPitchRow = 26.88e-4;        ///< across the chip [cm]
+inline constexpr double kPitchColumn = 29.24e-4;     ///< along the chip [cm]
+inline constexpr double kEffectiveThickness = 28e-4; ///< [cm]
+
+inline constexpr SensorSpec kSensor{
+  .shape = ShapeType::kRectangle,
+  .halfX = 0.5 * kRows * kPitchRow,
+  .halfY = 0.5 * kColumns * kPitchColumn,
+  .halfThickness = 0.5 * kEffectiveThickness,
+  .pitchX = kPitchRow,
+  .pitchY = kPitchColumn,
+};
+
+} // namespace o2::gtrk::detectors::alpide
+
+#endif // GTRK_DETECTORS_ALPIDE_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Detectors/ITS.h b/Detectors/GenericTracking/base/include/GenericTracking/Detectors/ITS.h
new file mode 100644
index 0000000000000..7eb36ac3a5077
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Detectors/ITS.h
@@ -0,0 +1,77 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ITS.h
+/// \brief The ALICE ITS: seven barrel layers of ALPIDE chips, placed by O2.
+///
+/// A placed layout (PlacedLayerSpec): the chips' placements come from O2's
+/// o2::its::GeometryTGeo at run time (GenericTracking/Alice/Placement.h), and what is
+/// stated here is what the tracking needs at compile time -- each layer's chip
+/// count and the chip. The tables are
+/// generated, not typed: `o2-gtrk-import-geometry` prints the layers,
+/// `o2-gtrk-layer-links` the links.
+
+#ifndef GTRK_DETECTORS_ITS_H_
+#define GTRK_DETECTORS_ITS_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Detectors/Alpide.h"
+
+#include <array>
+
+namespace o2::gtrk::detectors
+{
+
+struct ITS {
+  static constexpr const char* name = "ITS";
+  // clang-format off
+  // Measured values that happen to lie near mathematical constants are not them.
+  // NOLINTBEGIN(modernize-use-std-numbers)
+  // Chip counts measured by o2-gtrk-import-geometry from an aligned o2sim_geometry-aligned.root: 24120 chips.
+  static constexpr std::array<PlacedLayerSpec, 7> barrelLayers{{
+    {.sensorCount = 108, .sensor = alpide::kSensor},
+    {.sensorCount = 144, .sensor = alpide::kSensor},
+    {.sensorCount = 180, .sensor = alpide::kSensor},
+    {.sensorCount = 2688, .sensor = alpide::kSensor},
+    {.sensorCount = 3360, .sensor = alpide::kSensor},
+    {.sensorCount = 8232, .sensor = alpide::kSensor},
+    {.sensorCount = 9408, .sensor = alpide::kSensor},
+  }};
+
+  // Traced by o2-gtrk-layer-links for ITS: pT >= 0.1 GeV at Bz = 5 kG,
+  // beam spot z in [-18, 18] cm, |eta| <= 6, source intervals padded by 0.5 cm.
+  // skipsLayer is traced from intervening layer extents, not alternative graph paths.
+  // The comment on each link is the fraction of its source layer's crossings that take it.
+  static constexpr std::array<LayerLink, 12> layerLinks{{
+    {.from = 0, .to = 1, .sourceMin = -14.06, .sourceMax = 14.06, .skipsLayer = false}, // 0.9833
+    {.from = 0, .to = 3, .sourceMin = -14.06, .sourceMax = 14.06, .skipsLayer = false}, // 0.0126
+    {.from = 0, .to = 5, .sourceMin = -13.89, .sourceMax = 13.89, .skipsLayer = false}, // 0.0042
+    {.from = 1, .to = 2, .sourceMin = -14.06, .sourceMax = 14.06, .skipsLayer = false}, // 0.9858
+    {.from = 1, .to = 3, .sourceMin = -14.06, .sourceMax = 14.06, .skipsLayer = false}, // 0.0133
+    {.from = 1, .to = 5, .sourceMin = -12.69, .sourceMax = 12.69, .skipsLayer = false}, // 0.0009
+    {.from = 2, .to = 3, .sourceMin = -14.06, .sourceMax = 14.06, .skipsLayer = false}, // 0.9957
+    {.from = 2, .to = 5, .sourceMin = -14.05, .sourceMax = 14.05, .skipsLayer = false}, // 0.0043
+    {.from = 3, .to = 4, .sourceMin = -37.84, .sourceMax = 37.84, .skipsLayer = false}, // 0.8916
+    {.from = 3, .to = 5, .sourceMin = -42.71, .sourceMax = 42.71, .skipsLayer = false}, // 0.1084
+    {.from = 4, .to = 5, .sourceMin = -42.71, .sourceMax = 42.71, .skipsLayer = false}, // 1.0000
+    {.from = 5, .to = 6, .sourceMin = -67.33, .sourceMax = 67.33, .skipsLayer = false}, // 1.0000
+  }};
+  // NOLINTEND(modernize-use-std-numbers)
+  // clang-format on
+  static constexpr std::array<PlacedLayerSpec, 0> discLayers{};
+  /// O2's beryllium pipe, inside the first layer.
+  static constexpr std::array<PassiveSpec, 1> passives{kAliceBerylliumPipe};
+  static constexpr int nSensors = countSensors(barrelLayers, discLayers);
+};
+
+} // namespace o2::gtrk::detectors
+
+#endif // GTRK_DETECTORS_ITS_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Detectors/MFT.h b/Detectors/GenericTracking/base/include/GenericTracking/Detectors/MFT.h
new file mode 100644
index 0000000000000..eebd483b3a64f
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Detectors/MFT.h
@@ -0,0 +1,101 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MFT.h
+/// \brief The ALICE MFT: ten disc faces of ALPIDE chips, placed by O2.
+///
+/// A placed layout (PlacedLayerSpec) like ITS.h, placed from
+/// o2::mft::GeometryTGeo. A layer is one face of a half-disc pair: five discs,
+/// two faces each, both halves at the same z. A face covers only part of its
+/// disc -- the two faces of a disc together are what is hermetic -- so a track
+/// usually crosses one face of a disc, not both, and the links skip faces.
+///
+/// Chip IDs are O2's, which run half, disc, ladder, chip and so are not
+/// grouped by layer. The tables are generated: `o2-gtrk-import-geometry`
+/// prints the layers, `o2-gtrk-layer-links --min-share 0.005` the links: the
+/// ones carrying under 0.5 % of their source face's crossings are left out,
+/// which saves tracking time for few findable tracks.
+
+#ifndef GTRK_DETECTORS_MFT_H_
+#define GTRK_DETECTORS_MFT_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Detectors/Alpide.h"
+
+#include <array>
+
+namespace o2::gtrk::detectors
+{
+
+struct MFT {
+  static constexpr const char* name = "MFT";
+  static constexpr std::array<PlacedLayerSpec, 0> barrelLayers{};
+  // clang-format off
+  // Measured values that happen to lie near mathematical constants are not them.
+  // NOLINTBEGIN(modernize-use-std-numbers)
+  // Chip counts measured by o2-gtrk-import-geometry from an aligned o2sim_geometry-aligned.root: 936 chips.
+  static constexpr std::array<PlacedLayerSpec, 10> discLayers{{
+    {.sensorCount = 66, .sensor = alpide::kSensor},
+    {.sensorCount = 66, .sensor = alpide::kSensor},
+    {.sensorCount = 66, .sensor = alpide::kSensor},
+    {.sensorCount = 66, .sensor = alpide::kSensor},
+    {.sensorCount = 82, .sensor = alpide::kSensor},
+    {.sensorCount = 82, .sensor = alpide::kSensor},
+    {.sensorCount = 118, .sensor = alpide::kSensor},
+    {.sensorCount = 118, .sensor = alpide::kSensor},
+    {.sensorCount = 136, .sensor = alpide::kSensor},
+    {.sensorCount = 136, .sensor = alpide::kSensor},
+  }};
+
+  // Placed discs traced in 3D against the sensors of an aligned o2sim_geometry-aligned.root.
+  // Traced by o2-gtrk-layer-links for MFT: pT >= 0.1 GeV at Bz = 5 kG,
+  // beam spot z in [-18, 18] cm, |eta| <= 6, source intervals padded by 0.5 cm.
+  // skipsLayer is traced from intervening layer extents, not alternative graph paths.
+  // The comment on each link is the fraction of its source layer's crossings that take it.
+  // Links below 0.005 of their source layer's crossings are left out (19 of 45).
+  static constexpr std::array<LayerLink, 26> layerLinks{{
+    {.from = 0, .to = 1, .sourceMin = 1.80, .sourceMax = 12.01, .skipsLayer = false}, // 0.7276
+    {.from = 0, .to = 2, .sourceMin = 1.80, .sourceMax = 12.12, .skipsLayer = true}, // 0.2596
+    {.from = 0, .to = 4, .sourceMin = 3.37, .sourceMax = 11.96, .skipsLayer = true}, // 0.0072
+    {.from = 1, .to = 2, .sourceMin = 1.80, .sourceMax = 11.96, .skipsLayer = false}, // 0.7236
+    {.from = 1, .to = 3, .sourceMin = 1.80, .sourceMax = 12.13, .skipsLayer = true}, // 0.2591
+    {.from = 1, .to = 4, .sourceMin = 3.36, .sourceMax = 12.32, .skipsLayer = true}, // 0.0132
+    {.from = 2, .to = 3, .sourceMin = 1.80, .sourceMax = 12.01, .skipsLayer = false}, // 0.7208
+    {.from = 2, .to = 4, .sourceMin = 1.80, .sourceMax = 12.26, .skipsLayer = true}, // 0.2622
+    {.from = 2, .to = 5, .sourceMin = 3.37, .sourceMax = 12.42, .skipsLayer = true}, // 0.0131
+    {.from = 3, .to = 4, .sourceMin = 1.80, .sourceMax = 12.64, .skipsLayer = false}, // 0.7446
+    {.from = 3, .to = 5, .sourceMin = 1.80, .sourceMax = 11.83, .skipsLayer = true}, // 0.2489
+    {.from = 3, .to = 6, .sourceMin = 3.34, .sourceMax = 12.63, .skipsLayer = true}, // 0.0051
+    {.from = 4, .to = 5, .sourceMin = 1.80, .sourceMax = 13.67, .skipsLayer = false}, // 0.7600
+    {.from = 4, .to = 6, .sourceMin = 1.87, .sourceMax = 12.88, .skipsLayer = true}, // 0.1696
+    {.from = 4, .to = 7, .sourceMin = 1.83, .sourceMax = 13.35, .skipsLayer = true}, // 0.0577
+    {.from = 4, .to = 8, .sourceMin = 1.82, .sourceMax = 13.35, .skipsLayer = true}, // 0.0112
+    {.from = 5, .to = 6, .sourceMin = 1.95, .sourceMax = 13.35, .skipsLayer = false}, // 0.7651
+    {.from = 5, .to = 7, .sourceMin = 1.88, .sourceMax = 12.86, .skipsLayer = false}, // 0.1962
+    {.from = 5, .to = 8, .sourceMin = 1.84, .sourceMax = 13.47, .skipsLayer = false}, // 0.0180
+    {.from = 5, .to = 9, .sourceMin = 1.80, .sourceMax = 13.41, .skipsLayer = false}, // 0.0207
+    {.from = 6, .to = 7, .sourceMin = 2.90, .sourceMax = 16.32, .skipsLayer = false}, // 0.7482
+    {.from = 6, .to = 8, .sourceMin = 2.91, .sourceMax = 15.72, .skipsLayer = true}, // 0.2030
+    {.from = 6, .to = 9, .sourceMin = 2.94, .sourceMax = 16.03, .skipsLayer = true}, // 0.0489
+    {.from = 7, .to = 8, .sourceMin = 2.90, .sourceMax = 16.53, .skipsLayer = false}, // 0.7957
+    {.from = 7, .to = 9, .sourceMin = 2.90, .sourceMax = 16.02, .skipsLayer = false}, // 0.2043
+    {.from = 8, .to = 9, .sourceMin = 3.30, .sourceMax = 17.14, .skipsLayer = false}, // 1.0000
+  }};
+  // NOLINTEND(modernize-use-std-numbers)
+  // clang-format on
+  /// O2's beryllium pipe, inside the first layer.
+  static constexpr std::array<PassiveSpec, 1> passives{kAliceBerylliumPipe};
+  static constexpr int nSensors = countSensors(barrelLayers, discLayers);
+};
+
+} // namespace o2::gtrk::detectors
+
+#endif // GTRK_DETECTORS_MFT_H_
diff --git a/Detectors/GenericTracking/base/include/GenericTracking/Detectors/TRKFT3.h b/Detectors/GenericTracking/base/include/GenericTracking/Detectors/TRKFT3.h
new file mode 100644
index 0000000000000..7ec4720f7a6d9
--- /dev/null
+++ b/Detectors/GenericTracking/base/include/GenericTracking/Detectors/TRKFT3.h
@@ -0,0 +1,304 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TRKFT3.h
+/// \brief The ALICE 3 tracker: the TRK barrel and the FT3 discs, placed by O2.
+///
+/// A placed layout (PlacedLayerSpec) like ITS.h, placed from O2's
+/// o2::trk::GeometryTGeo. The barrel is
+/// eleven layers: the vertex detector's (VD) three, each four curved sensors
+/// that are quarter-cylinders about the beam; then the five middle (ML) and
+/// three outer (OT) layers of flat chips. Then FT3's twelve discs of the same
+/// flat chip, in FT3's order: six at -z from the inside out, then
+/// their mirrors at +z. One layout for barrel and discs, because a forward
+/// track crosses both.
+///
+/// The sensors are chip types, restated from O2's TRKBase/Specs.h, which
+/// exists only with ENABLE_UPGRADES while the base library builds this
+/// layout in every build; workflow/src/TRK.cxx holds them to O2's. Where
+/// each chip sits is the loaded geometry's. Sensor IDs are O2's TRK chip IDs
+/// for the barrel -- the twelve VD sensors first, petal by petal, then ML and
+/// OT chip by chip -- and kFirstDiscSensor plus O2's FT3 chip ID for the discs. The
+/// tables are generated: `o2-gtrk-import-geometry -d TRKFT3` prints the chip
+/// counts and, with `--passives`, the passive scatterers; `o2-gtrk-layer-links
+/// -d TRKFT3` the links.
+
+#ifndef GTRK_DETECTORS_TRKFT3_H_
+#define GTRK_DETECTORS_TRKFT3_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+
+#include <array>
+#include <cstddef>
+#include <numbers>
+
+namespace o2::gtrk::detectors
+{
+
+namespace trkft3
+{
+
+// O2's units, so that each value below is O2's to the bit.
+inline constexpr double kCm = 1.;
+inline constexpr double kMm = 0.1;
+inline constexpr double kUm = 1e-4;
+
+/// A VD sensor: a quarter of a cylinder of radius kVDRadius less the gap
+/// between petals, 50 cm long, 20 um of silicon, 10 um pixels. O2 measures its
+/// flat coordinate on the inner surface (SensorSpec::radius).
+inline constexpr std::array<double, 3> kVDRadius{0.5 * kCm, 1.2 * kCm, 2.5 * kCm};
+inline constexpr std::array<double, 3> kVDPetalGap{1.63 * kMm, 1.2 * kMm, 1.2 * kMm};
+inline constexpr double kVDLength = 50 * kCm;
+inline constexpr double kVDThickness = 20 * kUm;
+inline constexpr double kVDPitch = 10 * kUm;
+
+/// The arc width of a VD sensor of layer \a layer [cm], as O2 computes it.
+[[nodiscard]] constexpr double vdWidth(int layer) { return (kVDRadius[static_cast<std::size_t>(layer)] * 2 * std::numbers::pi / 4) - kVDPetalGap[static_cast<std::size_t>(layer)]; }
+
+[[nodiscard]] constexpr SensorSpec vdSensor(int layer)
+{
+  return {
+    .shape = ShapeType::kCylinder,
+    .halfX = 0.5 * vdWidth(layer),
+    .halfY = 0.5 * kVDLength,
+    .halfThickness = 0.5 * kVDThickness,
+    .pitchX = kVDPitch,
+    .pitchY = kVDPitch,
+    .radius = kVDRadius[static_cast<std::size_t>(layer)],
+  };
+}
+
+/// The ML, OT and FT3 chip: 2.5 x 2.9 cm, of which a 1.5 mm strip along one
+/// long side is its readout and has no pixels; 100 um of silicon, 20 um
+/// pixels. O2's sensor volume is the active matrix alone, in the barrel and in
+/// FT3, so the chip's frame is centred on it.
+inline constexpr double kChipWidth = 25 * kMm;
+inline constexpr double kChipPassiveEdgeReadOut = 1.5 * kMm;
+inline constexpr double kChipLength = 29 * kMm;
+inline constexpr double kChipThickness = 100 * kUm;
+inline constexpr double kChipPitch = 20 * kUm;
+inline constexpr SensorSpec kChip{
+  .shape = ShapeType::kRectangle,
+  .halfX = 0.5 * (kChipWidth - kChipPassiveEdgeReadOut),
+  .halfY = 0.5 * kChipLength,
+  .halfThickness = 0.5 * kChipThickness,
+  .pitchX = kChipPitch,
+  .pitchY = kChipPitch,
+};
+
+} // namespace trkft3
+
+struct TRKFT3 {
+  static constexpr const char* name = "TRKFT3";
+  // clang-format off
+  // Chip counts measured by o2-gtrk-import-geometry from an ALICE 3 sgn_geometry-aligned.root: 50876 chips.
+  static constexpr std::array<PlacedLayerSpec, 11> barrelLayers{{
+    {.sensorCount = 4, .sensor = trkft3::vdSensor(0)},
+    {.sensorCount = 4, .sensor = trkft3::vdSensor(1)},
+    {.sensorCount = 4, .sensor = trkft3::vdSensor(2)},
+    {.sensorCount = 880, .sensor = trkft3::kChip},
+    {.sensorCount = 1232, .sensor = trkft3::kChip},
+    {.sensorCount = 1584, .sensor = trkft3::kChip},
+    {.sensorCount = 2288, .sensor = trkft3::kChip},
+    {.sensorCount = 3344, .sensor = trkft3::kChip},
+    {.sensorCount = 10560, .sensor = trkft3::kChip},
+    {.sensorCount = 13376, .sensor = trkft3::kChip},
+    {.sensorCount = 17600, .sensor = trkft3::kChip},
+  }};
+  // Chip counts measured by o2-gtrk-import-geometry from an ALICE 3 sgn_geometry-aligned.root: 13824 FT3 chips.
+  static constexpr std::array<PlacedLayerSpec, 12> discLayers{{
+    {.sensorCount = 440, .sensor = trkft3::kChip},
+    {.sensorCount = 440, .sensor = trkft3::kChip},
+    {.sensorCount = 440, .sensor = trkft3::kChip},
+    {.sensorCount = 1864, .sensor = trkft3::kChip},
+    {.sensorCount = 1864, .sensor = trkft3::kChip},
+    {.sensorCount = 1864, .sensor = trkft3::kChip},
+    {.sensorCount = 440, .sensor = trkft3::kChip},
+    {.sensorCount = 440, .sensor = trkft3::kChip},
+    {.sensorCount = 440, .sensor = trkft3::kChip},
+    {.sensorCount = 1864, .sensor = trkft3::kChip},
+    {.sensorCount = 1864, .sensor = trkft3::kChip},
+    {.sensorCount = 1864, .sensor = trkft3::kChip},
+  }};
+  // Traced by o2-gtrk-layer-links -d TRKFT3 from an ALICE 3 geometry, the discs placed: pT >= 0.1 GeV at Bz = 20 kG
+  // (the ALICE 3 field object's at the origin), beam spot z in [-18, 18] cm, |eta| <= 6, source intervals padded by 0.5 cm.
+  // skipsLayer is traced from intervening layer extents, not alternative graph paths.
+  // The comment on each link is the fraction of its source layer's crossings that take it.
+  static constexpr std::array<LayerLink, 140> layerLinks{{
+    {.from = 0, .to = 1, .sourceMin = -21.42, .sourceMax = 21.42, .skipsLayer = false}, // 0.9664
+    {.from = 0, .to = 3, .sourceMin = -21.75, .sourceMax = 21.75, .skipsLayer = false}, // 0.0041
+    {.from = 0, .to = 12, .sourceMin = -22.64, .sourceMax = -18.67, .skipsLayer = false}, // 0.0023
+    {.from = 0, .to = 13, .sourceMin = -23.75, .sourceMax = -16.92, .skipsLayer = false}, // 0.0067
+    {.from = 0, .to = 14, .sourceMin = -22.73, .sourceMax = -18.67, .skipsLayer = true}, // 0.0001
+    {.from = 0, .to = 15, .sourceMin = -23.69, .sourceMax = -18.67, .skipsLayer = true}, // 0.0009
+    {.from = 0, .to = 16, .sourceMin = -24.96, .sourceMax = -15.17, .skipsLayer = false}, // 0.0046
+    {.from = 0, .to = 18, .sourceMin = 18.67, .sourceMax = 22.64, .skipsLayer = false}, // 0.0023
+    {.from = 0, .to = 19, .sourceMin = 16.92, .sourceMax = 23.75, .skipsLayer = false}, // 0.0067
+    {.from = 0, .to = 20, .sourceMin = 18.67, .sourceMax = 22.73, .skipsLayer = true}, // 0.0001
+    {.from = 0, .to = 21, .sourceMin = 18.67, .sourceMax = 23.69, .skipsLayer = true}, // 0.0009
+    {.from = 0, .to = 22, .sourceMin = 15.17, .sourceMax = 24.96, .skipsLayer = false}, // 0.0046
+    {.from = 1, .to = 2, .sourceMin = -21.86, .sourceMax = 21.86, .skipsLayer = false}, // 0.8459
+    {.from = 1, .to = 3, .sourceMin = -25.50, .sourceMax = 25.50, .skipsLayer = false}, // 0.0796
+    {.from = 1, .to = 12, .sourceMin = -25.50, .sourceMax = -11.50, .skipsLayer = false}, // 0.0069
+    {.from = 1, .to = 13, .sourceMin = -25.50, .sourceMax = -8.38, .skipsLayer = false}, // 0.0183
+    {.from = 1, .to = 14, .sourceMin = -25.50, .sourceMax = -13.05, .skipsLayer = true}, // 0.0004
+    {.from = 1, .to = 15, .sourceMin = -25.50, .sourceMax = -9.93, .skipsLayer = true}, // 0.0021
+    {.from = 1, .to = 16, .sourceMin = -25.50, .sourceMax = -6.82, .skipsLayer = false}, // 0.0095
+    {.from = 1, .to = 18, .sourceMin = 11.50, .sourceMax = 25.50, .skipsLayer = false}, // 0.0069
+    {.from = 1, .to = 19, .sourceMin = 8.38, .sourceMax = 25.50, .skipsLayer = false}, // 0.0183
+    {.from = 1, .to = 20, .sourceMin = 13.05, .sourceMax = 25.50, .skipsLayer = true}, // 0.0004
+    {.from = 1, .to = 21, .sourceMin = 9.93, .sourceMax = 25.50, .skipsLayer = true}, // 0.0021
+    {.from = 1, .to = 22, .sourceMin = 6.82, .sourceMax = 25.50, .skipsLayer = false}, // 0.0095
+    {.from = 2, .to = 3, .sourceMin = -25.50, .sourceMax = 25.50, .skipsLayer = false}, // 0.9432
+    {.from = 2, .to = 12, .sourceMin = -25.50, .sourceMax = -10.19, .skipsLayer = false}, // 0.0031
+    {.from = 2, .to = 13, .sourceMin = -25.50, .sourceMax = -10.19, .skipsLayer = false}, // 0.0165
+    {.from = 2, .to = 14, .sourceMin = -25.50, .sourceMax = -18.11, .skipsLayer = true}, // 0.0001
+    {.from = 2, .to = 15, .sourceMin = -25.50, .sourceMax = -10.19, .skipsLayer = true}, // 0.0016
+    {.from = 2, .to = 16, .sourceMin = -25.50, .sourceMax = -10.19, .skipsLayer = false}, // 0.0071
+    {.from = 2, .to = 18, .sourceMin = 10.19, .sourceMax = 25.50, .skipsLayer = false}, // 0.0031
+    {.from = 2, .to = 19, .sourceMin = 10.19, .sourceMax = 25.50, .skipsLayer = false}, // 0.0165
+    {.from = 2, .to = 20, .sourceMin = 18.11, .sourceMax = 25.50, .skipsLayer = true}, // 0.0001
+    {.from = 2, .to = 21, .sourceMin = 10.19, .sourceMax = 25.50, .skipsLayer = true}, // 0.0016
+    {.from = 2, .to = 22, .sourceMin = 10.19, .sourceMax = 25.50, .skipsLayer = false}, // 0.0071
+    {.from = 3, .to = 4, .sourceMin = -54.45, .sourceMax = 54.45, .skipsLayer = false}, // 0.8386
+    {.from = 3, .to = 11, .sourceMin = -60.88, .sourceMax = -45.34, .skipsLayer = false}, // 0.0100
+    {.from = 3, .to = 12, .sourceMin = -64.49, .sourceMax = -45.34, .skipsLayer = false}, // 0.0484
+    {.from = 3, .to = 13, .sourceMin = -64.49, .sourceMax = -45.34, .skipsLayer = true}, // 0.0189
+    {.from = 3, .to = 14, .sourceMin = -64.49, .sourceMax = -45.46, .skipsLayer = true}, // 0.0005
+    {.from = 3, .to = 15, .sourceMin = -64.49, .sourceMax = -45.37, .skipsLayer = true}, // 0.0009
+    {.from = 3, .to = 16, .sourceMin = -64.49, .sourceMax = -45.54, .skipsLayer = true}, // 0.0020
+    {.from = 3, .to = 17, .sourceMin = 45.34, .sourceMax = 60.88, .skipsLayer = false}, // 0.0100
+    {.from = 3, .to = 18, .sourceMin = 45.34, .sourceMax = 64.49, .skipsLayer = false}, // 0.0484
+    {.from = 3, .to = 19, .sourceMin = 45.34, .sourceMax = 64.49, .skipsLayer = true}, // 0.0189
+    {.from = 3, .to = 20, .sourceMin = 45.46, .sourceMax = 64.49, .skipsLayer = true}, // 0.0005
+    {.from = 3, .to = 21, .sourceMin = 45.37, .sourceMax = 64.49, .skipsLayer = true}, // 0.0009
+    {.from = 3, .to = 22, .sourceMin = 45.54, .sourceMax = 64.49, .skipsLayer = true}, // 0.0020
+    {.from = 4, .to = 5, .sourceMin = -53.12, .sourceMax = 53.12, .skipsLayer = false}, // 0.7777
+    {.from = 4, .to = 11, .sourceMin = -64.49, .sourceMax = -42.63, .skipsLayer = false}, // 0.0820
+    {.from = 4, .to = 12, .sourceMin = -64.49, .sourceMax = -42.63, .skipsLayer = true}, // 0.0279
+    {.from = 4, .to = 13, .sourceMin = -64.49, .sourceMax = -42.67, .skipsLayer = true}, // 0.0012
+    {.from = 4, .to = 14, .sourceMin = -64.49, .sourceMax = -43.27, .skipsLayer = true}, // 0.0000
+    {.from = 4, .to = 15, .sourceMin = -64.49, .sourceMax = -43.40, .skipsLayer = true}, // 0.0000
+    {.from = 4, .to = 16, .sourceMin = -64.48, .sourceMax = -48.06, .skipsLayer = true}, // 0.0000
+    {.from = 4, .to = 17, .sourceMin = 42.63, .sourceMax = 64.49, .skipsLayer = false}, // 0.0820
+    {.from = 4, .to = 18, .sourceMin = 42.63, .sourceMax = 64.49, .skipsLayer = true}, // 0.0279
+    {.from = 4, .to = 19, .sourceMin = 42.67, .sourceMax = 64.49, .skipsLayer = true}, // 0.0012
+    {.from = 4, .to = 20, .sourceMin = 43.27, .sourceMax = 64.49, .skipsLayer = true}, // 0.0000
+    {.from = 4, .to = 21, .sourceMin = 43.40, .sourceMax = 64.49, .skipsLayer = true}, // 0.0000
+    {.from = 4, .to = 22, .sourceMin = 48.06, .sourceMax = 64.48, .skipsLayer = true}, // 0.0000
+    {.from = 5, .to = 6, .sourceMin = -46.99, .sourceMax = 46.99, .skipsLayer = false}, // 0.5203
+    {.from = 5, .to = 8, .sourceMin = -48.04, .sourceMax = 48.04, .skipsLayer = true}, // 0.0000
+    {.from = 5, .to = 11, .sourceMin = -64.49, .sourceMax = -30.29, .skipsLayer = false}, // 0.2372
+    {.from = 5, .to = 12, .sourceMin = -64.49, .sourceMax = -30.32, .skipsLayer = true}, // 0.0026
+    {.from = 5, .to = 13, .sourceMin = -64.49, .sourceMax = -31.27, .skipsLayer = true}, // 0.0000
+    {.from = 5, .to = 14, .sourceMin = -64.48, .sourceMax = -32.10, .skipsLayer = true}, // 0.0000
+    {.from = 5, .to = 15, .sourceMin = -63.91, .sourceMax = -34.79, .skipsLayer = true}, // 0.0000
+    {.from = 5, .to = 16, .sourceMin = -58.92, .sourceMax = -32.99, .skipsLayer = true}, // 0.0000
+    {.from = 5, .to = 17, .sourceMin = 30.29, .sourceMax = 64.49, .skipsLayer = false}, // 0.2372
+    {.from = 5, .to = 18, .sourceMin = 30.32, .sourceMax = 64.49, .skipsLayer = true}, // 0.0026
+    {.from = 5, .to = 19, .sourceMin = 31.27, .sourceMax = 64.49, .skipsLayer = true}, // 0.0000
+    {.from = 5, .to = 20, .sourceMin = 32.10, .sourceMax = 64.48, .skipsLayer = true}, // 0.0000
+    {.from = 5, .to = 21, .sourceMin = 34.79, .sourceMax = 63.91, .skipsLayer = true}, // 0.0000
+    {.from = 5, .to = 22, .sourceMin = 32.99, .sourceMax = 58.92, .skipsLayer = true}, // 0.0000
+    {.from = 6, .to = 7, .sourceMin = -47.81, .sourceMax = 47.81, .skipsLayer = false}, // 0.1654
+    {.from = 6, .to = 8, .sourceMin = -64.49, .sourceMax = 64.49, .skipsLayer = false}, // 0.1386
+    {.from = 6, .to = 11, .sourceMin = -64.49, .sourceMax = -25.80, .skipsLayer = false}, // 0.3430
+    {.from = 6, .to = 12, .sourceMin = -64.49, .sourceMax = -26.95, .skipsLayer = true}, // 0.0011
+    {.from = 6, .to = 13, .sourceMin = -64.45, .sourceMax = -37.92, .skipsLayer = true}, // 0.0000
+    {.from = 6, .to = 14, .sourceMin = -64.49, .sourceMax = -30.59, .skipsLayer = false}, // 0.0038
+    {.from = 6, .to = 15, .sourceMin = -64.48, .sourceMax = -33.05, .skipsLayer = true}, // 0.0001
+    {.from = 6, .to = 16, .sourceMin = -64.46, .sourceMax = -36.83, .skipsLayer = true}, // 0.0000
+    {.from = 6, .to = 17, .sourceMin = 25.80, .sourceMax = 64.49, .skipsLayer = false}, // 0.3430
+    {.from = 6, .to = 18, .sourceMin = 26.95, .sourceMax = 64.49, .skipsLayer = true}, // 0.0011
+    {.from = 6, .to = 19, .sourceMin = 37.92, .sourceMax = 64.45, .skipsLayer = true}, // 0.0000
+    {.from = 6, .to = 20, .sourceMin = 30.59, .sourceMax = 64.49, .skipsLayer = false}, // 0.0038
+    {.from = 6, .to = 21, .sourceMin = 33.05, .sourceMax = 64.48, .skipsLayer = true}, // 0.0001
+    {.from = 6, .to = 22, .sourceMin = 36.83, .sourceMax = 64.46, .skipsLayer = true}, // 0.0000
+    {.from = 7, .to = 8, .sourceMin = -64.49, .sourceMax = 64.49, .skipsLayer = false}, // 0.9844
+    {.from = 7, .to = 11, .sourceMin = -64.49, .sourceMax = -47.69, .skipsLayer = false}, // 0.0068
+    {.from = 7, .to = 14, .sourceMin = -64.48, .sourceMax = -59.59, .skipsLayer = false}, // 0.0010
+    {.from = 7, .to = 17, .sourceMin = 47.69, .sourceMax = 64.49, .skipsLayer = false}, // 0.0068
+    {.from = 7, .to = 20, .sourceMin = 59.59, .sourceMax = 64.48, .skipsLayer = false}, // 0.0010
+    {.from = 8, .to = 9, .sourceMin = -101.31, .sourceMax = 101.31, .skipsLayer = false}, // 0.1297
+    {.from = 8, .to = 14, .sourceMin = -128.88, .sourceMax = -70.15, .skipsLayer = false}, // 0.4250
+    {.from = 8, .to = 15, .sourceMin = -128.88, .sourceMax = -77.47, .skipsLayer = true}, // 0.0101
+    {.from = 8, .to = 16, .sourceMin = -128.88, .sourceMax = -87.08, .skipsLayer = true}, // 0.0001
+    {.from = 8, .to = 20, .sourceMin = 70.15, .sourceMax = 128.88, .skipsLayer = false}, // 0.4250
+    {.from = 8, .to = 21, .sourceMin = 77.47, .sourceMax = 128.88, .skipsLayer = true}, // 0.0101
+    {.from = 8, .to = 22, .sourceMin = 87.08, .sourceMax = 128.88, .skipsLayer = true}, // 0.0001
+    {.from = 9, .to = 10, .sourceMin = -101.25, .sourceMax = 101.25, .skipsLayer = false}, // 0.1171
+    {.from = 9, .to = 14, .sourceMin = -128.88, .sourceMax = -91.29, .skipsLayer = false}, // 0.4406
+    {.from = 9, .to = 15, .sourceMin = -128.88, .sourceMax = -110.80, .skipsLayer = true}, // 0.0009
+    {.from = 9, .to = 20, .sourceMin = 91.29, .sourceMax = 128.88, .skipsLayer = false}, // 0.4406
+    {.from = 9, .to = 21, .sourceMin = 110.80, .sourceMax = 128.88, .skipsLayer = true}, // 0.0009
+    {.from = 11, .to = 8, .sourceMin = 23.87, .sourceMax = 35.17, .skipsLayer = false}, // 0.0952
+    {.from = 11, .to = 12, .sourceMin = 9.50, .sourceMax = 33.31, .skipsLayer = false}, // 0.7973
+    {.from = 11, .to = 13, .sourceMin = 9.50, .sourceMax = 30.66, .skipsLayer = true}, // 0.0066
+    {.from = 11, .to = 14, .sourceMin = 9.56, .sourceMax = 35.14, .skipsLayer = false}, // 0.0969
+    {.from = 11, .to = 15, .sourceMin = 9.53, .sourceMax = 34.13, .skipsLayer = true}, // 0.0039
+    {.from = 11, .to = 16, .sourceMin = 9.96, .sourceMax = 32.62, .skipsLayer = true}, // 0.0001
+    {.from = 12, .to = 8, .sourceMin = 33.24, .sourceMax = 35.16, .skipsLayer = false}, // 0.0000
+    {.from = 12, .to = 13, .sourceMin = 9.50, .sourceMax = 33.83, .skipsLayer = false}, // 0.8259
+    {.from = 12, .to = 14, .sourceMin = 10.57, .sourceMax = 35.17, .skipsLayer = false}, // 0.1645
+    {.from = 12, .to = 15, .sourceMin = 9.57, .sourceMax = 35.16, .skipsLayer = true}, // 0.0088
+    {.from = 12, .to = 16, .sourceMin = 9.55, .sourceMax = 34.99, .skipsLayer = true}, // 0.0008
+    {.from = 13, .to = 14, .sourceMin = 12.06, .sourceMax = 35.17, .skipsLayer = false}, // 0.6962
+    {.from = 13, .to = 15, .sourceMin = 9.90, .sourceMax = 35.16, .skipsLayer = false}, // 0.1845
+    {.from = 13, .to = 16, .sourceMin = 9.51, .sourceMax = 35.05, .skipsLayer = false}, // 0.1193
+    {.from = 14, .to = 15, .sourceMin = 15.18, .sourceMax = 68.75, .skipsLayer = false}, // 0.9588
+    {.from = 14, .to = 16, .sourceMin = 15.18, .sourceMax = 63.29, .skipsLayer = true}, // 0.0412
+    {.from = 15, .to = 16, .sourceMin = 15.18, .sourceMax = 68.29, .skipsLayer = false}, // 1.0000
+    {.from = 17, .to = 8, .sourceMin = 23.87, .sourceMax = 35.17, .skipsLayer = false}, // 0.0952
+    {.from = 17, .to = 18, .sourceMin = 9.50, .sourceMax = 33.31, .skipsLayer = false}, // 0.7973
+    {.from = 17, .to = 19, .sourceMin = 9.50, .sourceMax = 30.66, .skipsLayer = true}, // 0.0066
+    {.from = 17, .to = 20, .sourceMin = 9.56, .sourceMax = 35.14, .skipsLayer = false}, // 0.0969
+    {.from = 17, .to = 21, .sourceMin = 9.53, .sourceMax = 34.13, .skipsLayer = true}, // 0.0039
+    {.from = 17, .to = 22, .sourceMin = 9.96, .sourceMax = 32.62, .skipsLayer = true}, // 0.0001
+    {.from = 18, .to = 8, .sourceMin = 33.24, .sourceMax = 35.16, .skipsLayer = false}, // 0.0000
+    {.from = 18, .to = 19, .sourceMin = 9.50, .sourceMax = 33.83, .skipsLayer = false}, // 0.8259
+    {.from = 18, .to = 20, .sourceMin = 10.57, .sourceMax = 35.17, .skipsLayer = false}, // 0.1645
+    {.from = 18, .to = 21, .sourceMin = 9.57, .sourceMax = 35.16, .skipsLayer = true}, // 0.0088
+    {.from = 18, .to = 22, .sourceMin = 9.55, .sourceMax = 34.99, .skipsLayer = true}, // 0.0008
+    {.from = 19, .to = 20, .sourceMin = 12.06, .sourceMax = 35.17, .skipsLayer = false}, // 0.6962
+    {.from = 19, .to = 21, .sourceMin = 9.90, .sourceMax = 35.16, .skipsLayer = false}, // 0.1845
+    {.from = 19, .to = 22, .sourceMin = 9.51, .sourceMax = 35.05, .skipsLayer = false}, // 0.1193
+    {.from = 20, .to = 21, .sourceMin = 15.18, .sourceMax = 68.75, .skipsLayer = false}, // 0.9588
+    {.from = 20, .to = 22, .sourceMin = 15.18, .sourceMax = 63.29, .skipsLayer = true}, // 0.0412
+    {.from = 21, .to = 22, .sourceMin = 15.18, .sourceMax = 68.29, .skipsLayer = false}, // 1.0000
+  }};
+  // Measured by o2-gtrk-import-geometry -d TRKFT3 --passives from O2's full ALICE 3 geometry: one per gap between
+  // barrel layers, its x/X0 across the gap at 65536 random azimuths and z, its radius the x/X0-weighted mean of
+  // 0.01 cm steps at 2048. Each owns its gap's material; a layer, its silicon envelope's. The gap from 20 to 30 cm
+  // holds the inner TOF at 21 cm (2.0 % X0). A gap lies between the layers' chips, their sensors' metal stacks
+  // included (tools::withStacks; the OT's first layer has its stack on the inner face): the stacks' material is the
+  // layers', not the gaps'.
+  static constexpr std::array<PassiveSpec, 11> passives{{
+    {.kind = PassiveSpec::Kind::kBarrel, .position = 0.4899, .bandLow = 0.0000, .bandHigh = 0.4999, .low = -25.00, .high = 25.00, .x2X0 = 2.224e-03},
+    {.kind = PassiveSpec::Kind::kBarrel, .position = 0.8002, .bandLow = 0.5096, .bandHigh = 1.1999, .low = -25.00, .high = 25.00, .x2X0 = 1.228e-03},
+    {.kind = PassiveSpec::Kind::kBarrel, .position = 1.7708, .bandLow = 1.2096, .bandHigh = 2.5000, .low = -25.00, .high = 25.00, .x2X0 = 9.985e-04},
+    {.kind = PassiveSpec::Kind::kBarrel, .position = 3.7955, .bandLow = 2.5096, .bandHigh = 6.8657, .low = -63.98, .high = 63.98, .x2X0 = 1.132e-02},
+    {.kind = PassiveSpec::Kind::kBarrel, .position = 7.9710, .bandLow = 7.8977, .bandHigh = 8.8055, .low = -63.98, .high = 63.98, .x2X0 = 3.692e-04},
+    {.kind = PassiveSpec::Kind::kBarrel, .position = 10.0133, .bandLow = 9.8542, .bandHigh = 11.7623, .low = -63.98, .high = 63.98, .x2X0 = 4.094e-04},
+    {.kind = PassiveSpec::Kind::kBarrel, .position = 13.8492, .bandLow = 12.7722, .bandHigh = 18.7300, .low = -63.98, .high = 63.98, .x2X0 = 4.863e-04},
+    {.kind = PassiveSpec::Kind::kBarrel, .position = 21.2092, .bandLow = 20.1379, .bandHigh = 29.9999, .low = -63.98, .high = 63.98, .x2X0 = 2.027e-02},
+    {.kind = PassiveSpec::Kind::kBarrel, .position = 38.2067, .bandLow = 31.0792, .bandHigh = 44.8000, .low = -128.38, .high = 128.38, .x2X0 = 2.557e-02},
+    {.kind = PassiveSpec::Kind::kBarrel, .position = 52.1226, .bandLow = 45.3527, .bandHigh = 59.8000, .low = -128.38, .high = 128.38, .x2X0 = 4.899e-04},
+    {.kind = PassiveSpec::Kind::kBarrel, .position = 69.6851, .bandLow = 60.2898, .bandHigh = 79.8000, .low = -128.38, .high = 128.38, .x2X0 = 6.376e-04},
+  }};
+  // clang-format on
+  static constexpr int nSensors = countSensors(barrelLayers, discLayers);
+  /// The first disc sensor's ID: FT3's chip ID 0, after every barrel chip.
+  static constexpr int kFirstDiscSensor = countSensors(barrelLayers, std::array<PlacedLayerSpec, 0>{});
+};
+
+} // namespace o2::gtrk::detectors
+
+#endif // GTRK_DETECTORS_TRKFT3_H_
diff --git a/Detectors/GenericTracking/src/BoundedAllocator.cxx b/Detectors/GenericTracking/base/src/BoundedAllocator.cxx
similarity index 64%
rename from Detectors/GenericTracking/src/BoundedAllocator.cxx
rename to Detectors/GenericTracking/base/src/BoundedAllocator.cxx
index 111e6fe5ce6e0..cf79bc678754a 100644
--- a/Detectors/GenericTracking/src/BoundedAllocator.cxx
+++ b/Detectors/GenericTracking/base/src/BoundedAllocator.cxx
@@ -9,9 +9,8 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 
-#include <cstdio>
 #include <format>
 
 #include "GPUCommonLogger.h"
@@ -25,19 +24,14 @@ constexpr double kGigabyte = 1024. * 1024. * 1024.;
 
 BoundedMemoryResource::MemoryLimitExceeded::MemoryLimitExceeded(size_t attempted, size_t used, size_t max)
 {
-  char buf[256];
   if (attempted != 0) {
-    (void)snprintf(buf, sizeof(buf), "Reached set memory limit (attempted: %zu, used: %zu, max: %zu)", attempted, used, max);
+    mMsg = std::format("Reached set memory limit (attempted: {}, used: {}, max: {})", attempted, used, max);
   } else {
-    (void)snprintf(buf, sizeof(buf), "New set maximum below current used (newMax: %zu, used: %zu)", max, used);
+    mMsg = std::format("New set maximum below current used (newMax: {}, used: {})", max, used);
   }
-  mMsg = buf;
 }
 
-const char* BoundedMemoryResource::MemoryLimitExceeded::what() const noexcept
-{
-  return mMsg.c_str();
-}
+const char* BoundedMemoryResource::MemoryLimitExceeded::what() const noexcept { return mMsg.c_str(); }
 
 std::pmr::memory_resource* BoundedMemoryResource::cachingUpstream()
 {
@@ -46,12 +40,15 @@ std::pmr::memory_resource* BoundedMemoryResource::cachingUpstream()
 }
 
 BoundedMemoryResource::BoundedMemoryResource(size_t maxBytes, std::pmr::memory_resource* upstream)
-  : mMaxMemory(maxBytes), mUpstream(upstream != nullptr ? upstream : cachingUpstream())
+  : mMaxMemory(maxBytes),
+    mUpstream(upstream != nullptr ? upstream : cachingUpstream())
 {
 }
 
 BoundedMemoryResource::BoundedMemoryResource(std::unique_ptr<std::pmr::memory_resource> upstream, size_t maxBytes)
-  : mMaxMemory(maxBytes), mOwnedUpstream(std::move(upstream)), mUpstream(mOwnedUpstream.get())
+  : mMaxMemory(maxBytes),
+    mOwnedUpstream(std::move(upstream)),
+    mUpstream(mOwnedUpstream.get())
 {
 }
 
@@ -78,9 +75,6 @@ void* BoundedMemoryResource::do_allocate(size_t bytes, size_t alignment)
     p = mUpstream->allocate(bytes, alignment);
   } catch (...) {
     mUsedMemory.fetch_sub(bytes, std::memory_order_relaxed);
-#ifdef BOUNDED_MR_STATS
-    mStats.upstreamFailures.fetch_add(1, std::memory_order_relaxed);
-#endif
     throw;
   }
 
@@ -91,18 +85,6 @@ void* BoundedMemoryResource::do_allocate(size_t bytes, size_t alignment)
   while (newUsed > peak && !mPeakUsedMemory.compare_exchange_weak(peak, newUsed, std::memory_order_relaxed)) {
   }
 
-#ifdef BOUNDED_MR_STATS
-  size_t statsPeak = mStats.peak.load(std::memory_order_relaxed);
-  while (newUsed > statsPeak && !mStats.peak.compare_exchange_weak(statsPeak, newUsed, std::memory_order_relaxed)) {
-  }
-  mStats.live.fetch_add(1, std::memory_order_relaxed);
-  mStats.nAlloc.fetch_add(1, std::memory_order_relaxed);
-  mStats.totalAlloc.fetch_add(bytes, std::memory_order_relaxed);
-
-  size_t maxAlignment = mStats.maxAlign.load(std::memory_order_relaxed);
-  while (alignment > maxAlignment && !mStats.maxAlign.compare_exchange_weak(maxAlignment, alignment, std::memory_order_relaxed)) {
-  }
-#endif
   return p;
 }
 
@@ -110,37 +92,17 @@ void BoundedMemoryResource::do_deallocate(void* p, size_t bytes, size_t alignmen
 {
   mUpstream->deallocate(p, bytes, alignment);
   mUsedMemory.fetch_sub(bytes, std::memory_order_relaxed);
-#ifdef BOUNDED_MR_STATS
-  mStats.live.fetch_sub(1, std::memory_order_relaxed);
-  mStats.nFree.fetch_add(1, std::memory_order_relaxed);
-  mStats.totalFreed.fetch_add(bytes, std::memory_order_relaxed);
-#endif
 }
 
-bool BoundedMemoryResource::do_is_equal(const std::pmr::memory_resource& other) const noexcept
-{
-  return this == &other;
-}
+bool BoundedMemoryResource::do_is_equal(const std::pmr::memory_resource& other) const noexcept { return this == &other; }
 
-size_t BoundedMemoryResource::getUsedMemory() const noexcept
-{
-  return mUsedMemory.load(std::memory_order_relaxed);
-}
+size_t BoundedMemoryResource::getUsedMemory() const noexcept { return mUsedMemory.load(std::memory_order_relaxed); }
 
-size_t BoundedMemoryResource::getMaxMemory() const noexcept
-{
-  return mMaxMemory.load(std::memory_order_relaxed);
-}
+size_t BoundedMemoryResource::getMaxMemory() const noexcept { return mMaxMemory.load(std::memory_order_relaxed); }
 
-size_t BoundedMemoryResource::getThrowCount() const noexcept
-{
-  return mCountThrow.load(std::memory_order_relaxed);
-}
+size_t BoundedMemoryResource::getThrowCount() const noexcept { return mCountThrow.load(std::memory_order_relaxed); }
 
-size_t BoundedMemoryResource::getPeakMemory() const noexcept
-{
-  return mPeakUsedMemory.load(std::memory_order_relaxed);
-}
+size_t BoundedMemoryResource::getPeakMemory() const noexcept { return mPeakUsedMemory.load(std::memory_order_relaxed); }
 
 size_t BoundedMemoryResource::getPeakMemoryDelta() const noexcept
 {
@@ -197,23 +159,9 @@ std::string BoundedMemoryResource::asString() const
   } else {
     result += std::format("maxthrow={} maxmem={:.2f} GB used={:.2f} GB ({:.2f}%) stagepeak={:.2f} GB stagealloc={:.2f} GB", throwCount, static_cast<double>(maxMemory) / kGigabyte, used / kGigabyte, 100.0 * used / static_cast<double>(maxMemory), peak / kGigabyte, peakDelta / kGigabyte);
   }
-#ifdef BOUNDED_MR_STATS
-  result += std::format("  peak={:.2f} GB live={} nAlloc={} nFree={} totalAlloc={:.2f} GB totalFreed={:.2f} GB maxAlign={} upstreamFail={}",
-                        static_cast<float>(mStats.peak.load(std::memory_order_relaxed)) / kGigabyte,
-                        mStats.live.load(std::memory_order_relaxed),
-                        mStats.nAlloc.load(std::memory_order_relaxed),
-                        mStats.nFree.load(std::memory_order_relaxed),
-                        static_cast<float>(mStats.totalAlloc.load(std::memory_order_relaxed)) / kGigabyte,
-                        static_cast<float>(mStats.totalFreed.load(std::memory_order_relaxed)) / kGigabyte,
-                        mStats.maxAlign.load(std::memory_order_relaxed),
-                        mStats.upstreamFailures.load(std::memory_order_relaxed));
-#endif
   return result;
 }
 
-void BoundedMemoryResource::print() const
-{
-  LOGP(info, "{}", asString());
-}
+void BoundedMemoryResource::print() const { LOGP(info, "{}", asString()); }
 
 } // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/base/src/CapacityEstimator.cxx b/Detectors/GenericTracking/base/src/CapacityEstimator.cxx
new file mode 100644
index 0000000000000..78c8054576de7
--- /dev/null
+++ b/Detectors/GenericTracking/base/src/CapacityEstimator.cxx
@@ -0,0 +1,67 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Base/CapacityEstimator.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+struct Config {
+  float alpha{0.2F}; ///< the ratio's exponential smoothing
+  float marginInit{1.30F};
+  float marginMin{1.10F};
+  float marginMax{4.00F};
+  float marginUp{1.50F};        ///< the most a timeframe that grew raises the margin by
+  float marginDown{0.98F};      ///< what a timeframe without growth lowers it by
+  std::size_t floorSlots{1024}; ///< per thread: before anything is learned, and never below
+};
+constexpr Config kConfig{};
+
+} // namespace
+
+std::size_t CapacityEstimator::perThread(std::size_t site, std::size_t rows) const
+{
+  const auto& entry = mEntries[site];
+  if (!entry.learned || rows == 0U) {
+    return kConfig.floorSlots;
+  }
+  const double raw = static_cast<double>(entry.ratio) * static_cast<double>(rows) * static_cast<double>(entry.margin);
+  return std::max(kConfig.floorSlots, static_cast<std::size_t>(std::ceil(raw)));
+}
+
+void CapacityEstimator::learn(std::size_t site, std::size_t largestUse, std::size_t granted, std::size_t rows, bool grew)
+{
+  if (rows == 0U) {
+    return;
+  }
+  auto& entry = mEntries[site];
+  const auto sample = static_cast<float>(static_cast<double>(largestUse) / static_cast<double>(rows));
+  const bool first = !entry.learned;
+  entry.ratio = first ? sample : (kConfig.alpha * sample) + ((1.F - kConfig.alpha) * entry.ratio);
+  if (first) {
+    entry.margin = kConfig.marginInit;
+  } else if (grew) {
+    // By the shortfall: a little at least, marginUp at most.
+    const float shortfall = granted != 0U ? static_cast<float>(static_cast<double>(largestUse) / static_cast<double>(granted)) : kConfig.marginUp;
+    entry.margin = std::min(kConfig.marginMax, entry.margin * std::clamp(shortfall, 1.02F, kConfig.marginUp));
+  } else {
+    entry.margin = std::max(kConfig.marginMin, entry.margin * kConfig.marginDown);
+  }
+  entry.learned = true;
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/base/src/LayerEnvelopes.cxx b/Detectors/GenericTracking/base/src/LayerEnvelopes.cxx
new file mode 100644
index 0000000000000..8c6499295e679
--- /dev/null
+++ b/Detectors/GenericTracking/base/src/LayerEnvelopes.cxx
@@ -0,0 +1,224 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Base/LayerEnvelopes.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <format>
+#include <limits>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+/// The eight corners of a sensor's active silicon, in the global frame.
+std::array<std::array<double, 3>, 8> corners(const Sensor& sensor, const SensorSpec& spec)
+{
+  std::array<std::array<double, 3>, 8> result{};
+  std::size_t n = 0;
+  for (const double u : {-spec.halfX, spec.halfX}) {
+    for (const double v : {-spec.halfY, spec.halfY}) {
+      for (const double w : {-spec.halfThickness, spec.halfThickness}) {
+        const double local[3] = {u, v, w};
+        sensor.toGlobal(local, result[n++].data());
+      }
+    }
+  }
+  return result;
+}
+
+/// Distance from the beam line to the nearest point of a convex body, given
+/// its corners: the distance from the origin to the convex hull of their
+/// transverse projections, zero if the hull contains it.
+double nearestRadius(const std::array<std::array<double, 3>, 8>& points)
+{
+  std::array<std::array<double, 2>, 8> p{};
+  for (std::size_t i = 0; i < p.size(); ++i) {
+    p[i] = {points[i][0], points[i][1]};
+  }
+  std::ranges::sort(p);
+  const auto cross = [](const auto& o, const auto& a, const auto& b) { return ((a[0] - o[0]) * (b[1] - o[1])) - ((a[1] - o[1]) * (b[0] - o[0])); };
+  // Andrew's monotone chain, counter-clockwise.
+  std::array<std::array<double, 2>, 16> hull{};
+  std::size_t k = 0;
+  for (const auto& point : p) {
+    while (k >= 2 && cross(hull[k - 2], hull[k - 1], point) <= 0.) {
+      --k;
+    }
+    hull[k++] = point;
+  }
+  for (std::size_t i = p.size() - 1, lower = k + 1; i-- > 0;) {
+    while (k >= lower && cross(hull[k - 2], hull[k - 1], p[i]) <= 0.) {
+      --k;
+    }
+    hull[k++] = p[i];
+  }
+  const std::size_t n = k - 1; // the last point repeats the first
+  bool inside = n >= 3;
+  double nearest = std::numeric_limits<double>::infinity();
+  const std::array<double, 2> origin{0., 0.};
+  for (std::size_t i = 0; i < std::max<std::size_t>(n, 1); ++i) {
+    const auto& a = hull[i];
+    const auto& b = hull[(i + 1) % std::max<std::size_t>(n, 1)];
+    inside = inside && cross(a, b, origin) >= 0.;
+    const double dx = b[0] - a[0];
+    const double dy = b[1] - a[1];
+    const double length2 = (dx * dx) + (dy * dy);
+    const double t = length2 > 0. ? std::clamp(-((a[0] * dx) + (a[1] * dy)) / length2, 0., 1.) : 0.;
+    nearest = std::min(nearest, std::hypot(a[0] + (t * dx), a[1] + (t * dy)));
+  }
+  return inside ? 0. : nearest;
+}
+
+/// The hull in r and z of a curved sensor's silicon, exactly: an annular
+/// sector about the sensor's axis, which must be the beam's, so that z is the
+/// same along the arc. In the transverse plane the silicon is the points
+/// c + rho d, with c where the axis crosses it, rho from the radius to the
+/// outer surface and d within the arc's half-angle of its middle direction.
+/// Its distance from the beam line is extremal on the arc's two ends or where
+/// d points along +-c; along a direction it is least at rho = -c.d, clamped.
+SensorExtent curvedExtentOf(const Sensor& sensor, const SensorSpec& spec)
+{
+  // The sensor's local z axis is column 2 of the local -> global rotation.
+  if (!exactlyEqual(sensor.rot[2], 0.) || !exactlyEqual(sensor.rot[5], 0.) || !exactlyEqual(std::abs(sensor.rot[8]), 1.)) {
+    throw std::runtime_error(std::format("a curved sensor of layer {} whose axis is not the beam's", sensor.layer));
+  }
+  const double rhoMin = spec.radius + spec.surfaceMin();
+  const double rhoMax = spec.radius + spec.surfaceMax();
+  const double halfAngle = spec.halfX / spec.radius;
+  const std::array<double, 2> c{sensor.trans[0], sensor.trans[1]};
+  // A transverse direction of the sensor's frame, in the global one.
+  const auto direction = [&](double angle) {
+    const double local[3] = {std::cos(angle), std::sin(angle), 0.};
+    return std::array<double, 2>{(sensor.rot[0] * local[0]) + (sensor.rot[1] * local[1]), (sensor.rot[3] * local[0]) + (sensor.rot[4] * local[1])};
+  };
+  const auto middle = direction(0.);
+  std::vector<std::array<double, 2>> directions{direction(-halfAngle), direction(halfAngle)};
+  const double cNorm = std::hypot(c[0], c[1]);
+  if (cNorm > 0.) {
+    for (const double sign : {1., -1.}) {
+      const std::array<double, 2> d{sign * c[0] / cNorm, sign * c[1] / cNorm};
+      if ((d[0] * middle[0]) + (d[1] * middle[1]) >= std::cos(halfAngle)) {
+        directions.push_back(d);
+      }
+    }
+  }
+  SensorExtent extent;
+  for (const auto& d : directions) {
+    const auto radiusAt = [&](double rho) { return std::hypot(c[0] + (rho * d[0]), c[1] + (rho * d[1])); };
+    extent.rMin = std::min(extent.rMin, radiusAt(std::clamp(-((c[0] * d[0]) + (c[1] * d[1])), rhoMin, rhoMax)));
+    extent.rMax = std::max({extent.rMax, radiusAt(rhoMin), radiusAt(rhoMax)});
+  }
+  for (const double y : {-spec.halfY, spec.halfY}) {
+    const double z = (sensor.rot[8] * y) + sensor.trans[2];
+    extent.zMin = std::min(extent.zMin, z);
+    extent.zMax = std::max(extent.zMax, z);
+  }
+  return extent;
+}
+
+/// Where a sensor's silicon is centred, in the global frame: a flat sensor's
+/// origin, a curved sensor's middle of the silicon at the middle of its arc.
+std::array<double, 3> centreOf(const Sensor& sensor, const SensorSpec& spec)
+{
+  double local[3];
+  spec.unrolledToFrame(0., 0., 0.5 * (spec.surfaceMin() + spec.surfaceMax()), local);
+  std::array<double, 3> global{};
+  sensor.toGlobal(local, global.data());
+  return global;
+}
+
+// The value in units of the resolution, floored, ceiled or rounded, as the
+// nearest double to that decimal: the integer divided by the units per cm.
+double down(double value, double resolution) { return std::floor(value / resolution) / std::round(1. / resolution); }
+double up(double value, double resolution) { return std::ceil(value / resolution) / std::round(1. / resolution); }
+double nearest(double value, double resolution) { return std::round(value / resolution) / std::round(1. / resolution); }
+
+} // namespace
+
+SensorExtent extentOf(const Sensor& sensor, const SensorSpec& spec)
+{
+  if (spec.curved()) {
+    return curvedExtentOf(sensor, spec);
+  }
+  const auto points = corners(sensor, spec);
+  SensorExtent extent;
+  extent.rMin = nearestRadius(points);
+  for (const auto& point : points) {
+    extent.rMax = std::max(extent.rMax, std::hypot(point[0], point[1]));
+    extent.zMin = std::min(extent.zMin, point[2]);
+    extent.zMax = std::max(extent.zMax, point[2]);
+  }
+  return extent;
+}
+
+std::vector<LayerEnvelope> measureEnvelopes(std::span<const Sensor> sensors, std::span<const SensorSpec> specs, int nBarrelLayers, double resolution)
+{
+  const int nLayers = static_cast<int>(specs.size());
+  std::vector<SensorExtent> extents(static_cast<std::size_t>(nLayers));
+  std::vector<double> position(static_cast<std::size_t>(nLayers), 0.);
+  std::vector<std::size_t> count(static_cast<std::size_t>(nLayers), 0U);
+  for (const auto& sensor : sensors) {
+    if (std::cmp_greater_equal(sensor.layer, nLayers)) {
+      throw std::runtime_error(std::format("sensor on layer {}, beyond the {} layers", sensor.layer, nLayers));
+    }
+    const auto& spec = specs[sensor.layer];
+    const auto extent = extentOf(sensor, spec);
+    auto& layer = extents[sensor.layer];
+    layer.rMin = std::min(layer.rMin, extent.rMin);
+    layer.rMax = std::max(layer.rMax, extent.rMax);
+    layer.zMin = std::min(layer.zMin, extent.zMin);
+    layer.zMax = std::max(layer.zMax, extent.zMax);
+    const auto centre = centreOf(sensor, spec);
+    position[sensor.layer] += std::cmp_less(sensor.layer, nBarrelLayers) ? std::hypot(centre[0], centre[1]) : centre[2];
+    ++count[sensor.layer];
+  }
+  std::vector<LayerEnvelope> result;
+  for (std::size_t layer = 0; layer < extents.size(); ++layer) {
+    if (count[layer] == 0U) {
+      throw std::runtime_error(std::format("no sensor on layer {}", layer));
+    }
+    const auto& e = extents[layer];
+    const double centre = position[layer] / static_cast<double>(count[layer]);
+    if (resolution > 0.) {
+      result.push_back({
+        .position = nearest(centre, resolution),
+        .rMin = down(e.rMin, resolution),
+        .rMax = up(e.rMax, resolution),
+        .zMin = down(e.zMin, resolution),
+        .zMax = up(e.zMax, resolution),
+      });
+    } else {
+      result.push_back({.position = centre, .rMin = e.rMin, .rMax = e.rMax, .zMin = e.zMin, .zMax = e.zMax});
+    }
+  }
+  return result;
+}
+
+std::string describeEnvelopes(std::span<const LayerEnvelope> envelopes, int nBarrelLayers)
+{
+  std::string result;
+  for (std::size_t layer = 0; layer < envelopes.size(); ++layer) {
+    const auto& e = envelopes[layer];
+    const bool barrel = std::cmp_less(layer, nBarrelLayers);
+    result += std::format("layer {}: {} {:.4f}, r [{:.4f}, {:.4f}], z [{:.4f}, {:.4f}]\n", layer, barrel ? "mean radius" : "mean z", e.position, e.rMin, e.rMax, e.zMin, e.zMax);
+  }
+  return result;
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/test/CMakeLists.txt b/Detectors/GenericTracking/base/test/CMakeLists.txt
similarity index 60%
rename from Detectors/GenericTracking/test/CMakeLists.txt
rename to Detectors/GenericTracking/base/test/CMakeLists.txt
index 988c8811540da..3740d0de2487d 100644
--- a/Detectors/GenericTracking/test/CMakeLists.txt
+++ b/Detectors/GenericTracking/base/test/CMakeLists.txt
@@ -12,4 +12,16 @@ o2_add_test(bounded-allocator
             SOURCES testBoundedAllocator.cxx
             COMPONENT_NAME generic-tracking
             LABELS "generic-tracking"
-            PUBLIC_LINK_LIBRARIES O2::GenericTracking)
+            PUBLIC_LINK_LIBRARIES O2::GTrkBase)
+
+o2_add_test(portable-math
+            SOURCES testPortableMath.cxx
+            COMPONENT_NAME generic-tracking
+            LABELS "generic-tracking"
+            PUBLIC_LINK_LIBRARIES O2::GTrkBase)
+
+o2_add_test(time-est-ps
+            SOURCES testTimeEstPS.cxx
+            COMPONENT_NAME generic-tracking
+            LABELS "generic-tracking"
+            PUBLIC_LINK_LIBRARIES O2::GTrkBase O2::CommonConstants)
diff --git a/Detectors/GenericTracking/test/testBoundedAllocator.cxx b/Detectors/GenericTracking/base/test/testBoundedAllocator.cxx
similarity index 66%
rename from Detectors/GenericTracking/test/testBoundedAllocator.cxx
rename to Detectors/GenericTracking/base/test/testBoundedAllocator.cxx
index d68134c488bc3..c34c403f68593 100644
--- a/Detectors/GenericTracking/test/testBoundedAllocator.cxx
+++ b/Detectors/GenericTracking/base/test/testBoundedAllocator.cxx
@@ -14,7 +14,7 @@
 #define BOOST_TEST_DYN_LINK
 #include <boost/test/unit_test.hpp>
 
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 
 #include <stdexcept>
 
@@ -24,15 +24,16 @@ namespace
 {
 class ThrowingResource final : public std::pmr::memory_resource
 {
-  void* do_allocate(size_t, size_t) final { throw std::bad_alloc{}; }
-  void do_deallocate(void*, size_t, size_t) final {}
-  bool do_is_equal(const std::pmr::memory_resource& other) const noexcept final { return this == &other; }
+  void* do_allocate(size_t /*bytes*/, size_t /*alignment*/) final { throw std::bad_alloc{}; }
+  void do_deallocate(void* /*p*/, size_t /*bytes*/, size_t /*alignment*/) final {}
+  [[nodiscard]] bool do_is_equal(const std::pmr::memory_resource& other) const noexcept final { return this == &other; }
 };
 
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions): the throwing copy is the point; moves fall back to it
 struct ThrowingCopy {
   static inline int copiesBeforeFailure = -1;
   ThrowingCopy() = default;
-  ThrowingCopy(const ThrowingCopy&)
+  ThrowingCopy(const ThrowingCopy& /*unused*/)
   {
     if (copiesBeforeFailure == 0) {
       throw std::runtime_error{"copy"};
@@ -49,21 +50,21 @@ BOOST_AUTO_TEST_CASE(huge_request_cannot_wrap_past_budget)
 {
   BoundedMemoryResource pool;
   void* held = pool.allocate(8);
-  BOOST_CHECK_THROW(static_cast<void>(pool.allocate(std::numeric_limits<size_t>::max())), BoundedMemoryResource::MemoryLimitExceeded);
-  BOOST_CHECK_EQUAL(pool.getUsedMemory(), 8u);
-  BOOST_CHECK_EQUAL(pool.getThrowCount(), 1u);
+  BOOST_CHECK_THROW(static_cast<void>(pool.allocate(std::numeric_limits<size_t>::max())), BoundedMemoryResource::MemoryLimitExceeded); // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks): the allocation throws, which the check asserts
+  BOOST_CHECK_EQUAL(pool.getUsedMemory(), 8U);
+  BOOST_CHECK_EQUAL(pool.getThrowCount(), 1U);
   pool.deallocate(held, 8);
-  BOOST_CHECK_EQUAL(pool.getUsedMemory(), 0u);
+  BOOST_CHECK_EQUAL(pool.getUsedMemory(), 0U);
 }
 
 BOOST_AUTO_TEST_CASE(upstream_failure_rolls_back_reserved_bytes)
 {
   ThrowingResource upstream;
   BoundedMemoryResource pool{1024, &upstream};
-  BOOST_CHECK_THROW(static_cast<void>(pool.allocate(16)), std::bad_alloc);
-  BOOST_CHECK_EQUAL(pool.getUsedMemory(), 0u);
-  BOOST_CHECK_EQUAL(pool.getAllocationCount(), 0u);
-  BOOST_CHECK_EQUAL(pool.getAllocatedBytes(), 0u);
+  BOOST_CHECK_THROW(static_cast<void>(pool.allocate(16)), std::bad_alloc); // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks): the allocation throws, which the check asserts
+  BOOST_CHECK_EQUAL(pool.getUsedMemory(), 0U);
+  BOOST_CHECK_EQUAL(pool.getAllocationCount(), 0U);
+  BOOST_CHECK_EQUAL(pool.getAllocatedBytes(), 0U);
 }
 
 BOOST_AUTO_TEST_CASE(legacy_mutable_budget_and_stage_peak_are_preserved)
@@ -71,21 +72,21 @@ BOOST_AUTO_TEST_CASE(legacy_mutable_budget_and_stage_peak_are_preserved)
   BoundedMemoryResource pool{64};
   void* first = pool.allocate(16);
   BOOST_CHECK_THROW(pool.setMaxMemory(8), BoundedMemoryResource::MemoryLimitExceeded);
-  BOOST_CHECK_EQUAL(pool.getMaxMemory(), 64u);
+  BOOST_CHECK_EQUAL(pool.getMaxMemory(), 64U);
   const size_t previousPeak = pool.resetPeakMemory();
-  BOOST_CHECK_EQUAL(previousPeak, 16u);
-  BOOST_CHECK_EQUAL(pool.getPeakMemoryDelta(), 0u);
+  BOOST_CHECK_EQUAL(previousPeak, 16U);
+  BOOST_CHECK_EQUAL(pool.getPeakMemoryDelta(), 0U);
   pool.setMaxMemory(24);
   void* second = pool.allocate(8);
-  BOOST_CHECK_EQUAL(pool.getPeakMemoryDelta(), 8u);
-  BOOST_CHECK_THROW(static_cast<void>(pool.allocate(1)), BoundedMemoryResource::MemoryLimitExceeded);
+  BOOST_CHECK_EQUAL(pool.getPeakMemoryDelta(), 8U);
+  BOOST_CHECK_THROW(static_cast<void>(pool.allocate(1)), BoundedMemoryResource::MemoryLimitExceeded); // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks): the allocation throws, which the check asserts
   pool.deallocate(second, 8);
   pool.deallocate(first, 16);
-  BOOST_CHECK_EQUAL(pool.getAllocationCount(), 2u);
-  BOOST_CHECK_EQUAL(pool.getAllocatedBytes(), 24u);
-  BOOST_CHECK_EQUAL(pool.resetPeakMemory(), 24u);
+  BOOST_CHECK_EQUAL(pool.getAllocationCount(), 2U);
+  BOOST_CHECK_EQUAL(pool.getAllocatedBytes(), 24U);
+  BOOST_CHECK_EQUAL(pool.resetPeakMemory(), 24U);
   pool.raisePeakMemory(24);
-  BOOST_CHECK_EQUAL(pool.getPeakMemory(), 24u);
+  BOOST_CHECK_EQUAL(pool.getPeakMemory(), 24U);
 }
 
 BOOST_AUTO_TEST_CASE(failed_rebuild_leaves_valid_vector_on_requested_resource)
@@ -95,7 +96,7 @@ BOOST_AUTO_TEST_CASE(failed_rebuild_leaves_valid_vector_on_requested_resource)
   values.assign(8, 7);
   BOOST_CHECK_THROW(clearResizeBoundedVector(values, 32, &pool, 3), BoundedMemoryResource::MemoryLimitExceeded);
   BOOST_CHECK(values.empty());
-  BOOST_CHECK_EQUAL(pool.getUsedMemory(), 0u);
+  BOOST_CHECK_EQUAL(pool.getUsedMemory(), 0U);
   BOOST_CHECK(values.get_allocator().resource() == &pool);
   values.push_back(9);
   BOOST_CHECK_EQUAL(values.front(), 9);
@@ -106,20 +107,21 @@ BOOST_AUTO_TEST_CASE(element_constructor_failure_leaves_vector_destructible)
   BoundedMemoryResource pool;
   BoundedVector<ThrowingCopy> values{&pool};
   values.resize(2);
-  ThrowingCopy sample;
+  const ThrowingCopy sample;
   ThrowingCopy::copiesBeforeFailure = 1;
   // The by-value default argument succeeds; assign throws after rebuilding.
   BOOST_CHECK_THROW(clearResizeBoundedVector(values, 4, &pool, sample), std::runtime_error);
   ThrowingCopy::copiesBeforeFailure = -1;
   BOOST_CHECK(values.empty());
   deepVectorClear(values);
-  BOOST_CHECK_EQUAL(pool.getUsedMemory(), 0u);
+  BOOST_CHECK_EQUAL(pool.getUsedMemory(), 0U);
   values.resize(1);
 }
 
 BOOST_AUTO_TEST_CASE(resize_reuses_capacity_and_honors_resource_changes)
 {
-  BoundedMemoryResource first, second;
+  BoundedMemoryResource first;
+  BoundedMemoryResource second;
   BoundedVector<int> values{&first};
   values.reserve(16);
   const auto allocations = first.getAllocationCount();
@@ -129,28 +131,31 @@ BOOST_AUTO_TEST_CASE(resize_reuses_capacity_and_honors_resource_changes)
   BOOST_CHECK_EQUAL(first.getAllocationCount(), allocations);
   resizeBoundedVector(values, 4, &second);
   BOOST_CHECK(values.get_allocator().resource() == &second);
-  BOOST_CHECK_EQUAL(first.getUsedMemory(), 0u);
+  BOOST_CHECK_EQUAL(first.getUsedMemory(), 0U);
 }
 
 BOOST_AUTO_TEST_CASE(nested_vectors_and_arrays_retain_legacy_clear_semantics)
 {
-  BoundedMemoryResource first, second;
+  BoundedMemoryResource first;
+  BoundedMemoryResource second;
   std::vector<BoundedVector<int>> nested;
   clearResizeBoundedVector(nested, 3, &first);
   for (auto& values : nested) {
     values.assign(4, 5);
   }
   deepVectorClear(nested, &second);
-  BOOST_CHECK_EQUAL(nested.size(), 3u);
-  BOOST_CHECK_EQUAL(first.getUsedMemory(), 0u);
+  BOOST_CHECK_EQUAL(nested.size(), 3U);
+  BOOST_CHECK_EQUAL(first.getUsedMemory(), 0U);
   for (const auto& values : nested) {
     BOOST_CHECK(values.empty());
     BOOST_CHECK(values.get_allocator().resource() == &second);
   }
   std::array<BoundedVector<int>, 2> array;
-  clearResizeBoundedArray(array, 4, &second, 7);
+  for (auto& values : array) {
+    clearResizeBoundedVector(values, 4, &second, 7);
+  }
   BOOST_CHECK_EQUAL(array[0][0], 7);
   deepVectorClear(array, &first);
-  BOOST_CHECK_EQUAL(second.getUsedMemory(), 0u);
+  BOOST_CHECK_EQUAL(second.getUsedMemory(), 0U);
   BOOST_CHECK(array[0].get_allocator().resource() == &first);
 }
diff --git a/Detectors/GenericTracking/base/test/testPortableMath.cxx b/Detectors/GenericTracking/base/test/testPortableMath.cxx
new file mode 100644
index 0000000000000..dcae2ed7192cd
--- /dev/null
+++ b/Detectors/GenericTracking/base/test/testPortableMath.cxx
@@ -0,0 +1,219 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testPortableMath.cxx
+/// \brief The deterministic build's sin, cos, atan, atan2, asin and log
+///        (PortableMath.h) against long double: fdlibm's accuracy, and the
+///        special values. That they give the device the same bits is
+///        testDeviceRuntime.cxx's.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK PortableMath
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Base/PortableMath.h"
+
+#include <bit>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <numbers>
+#include <random>
+#include <vector>
+
+namespace portable = o2::gtrk::portable;
+
+namespace
+{
+
+/// |value - exact| in units of the last place of \a value.
+double ulpError(double value, long double exact)
+{
+  const double ulp = std::nextafter(std::abs(value), std::numeric_limits<double>::infinity()) - std::abs(value);
+  return static_cast<double>(std::abs(static_cast<long double>(value) - exact) / static_cast<long double>(ulp));
+}
+
+std::vector<double> uniform(double low, double high, std::size_t count, std::uint64_t seed)
+{
+  std::mt19937_64 generator{seed};
+  std::uniform_real_distribution<double> distribution{low, high};
+  std::vector<double> values(count);
+  for (auto& value : values) {
+    value = distribution(generator);
+  }
+  return values;
+}
+
+/// Arguments within a few ulp of multiples of pi/2, where the reduction
+/// cancels most: the 2nd and 3rd rounds of remPio2.
+std::vector<double> nearMultiplesOfHalfPi()
+{
+  std::vector<double> values;
+  for (int n = -2000; n <= 2000; ++n) {
+    double x = n * (std::numbers::pi / 2.);
+    for (int step = 0; step < 4; ++step) {
+      values.push_back(x);
+      x = std::nextafter(x, std::numeric_limits<double>::infinity());
+    }
+  }
+  values.push_back(6381956970095103.0 * 0x1p-50); // 5.67e0, a hard case of Kahan's
+  values.push_back(1.e6);
+  values.push_back(-1.6e6);
+  return values;
+}
+
+bool sameBits(double a, double b) { return std::bit_cast<std::uint64_t>(a) == std::bit_cast<std::uint64_t>(b); }
+
+constexpr double kInf = std::numeric_limits<double>::infinity();
+constexpr double kNaN = std::numeric_limits<double>::quiet_NaN();
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(SinAndCosWithinAnUlp)
+{
+  auto values = uniform(-50., 50., 1'000'000U, 1U);
+  const auto small = uniform(-1.e-3, 1.e-3, 100'000U, 2U);
+  const auto hard = nearMultiplesOfHalfPi();
+  values.insert(values.end(), small.begin(), small.end());
+  values.insert(values.end(), hard.begin(), hard.end());
+  double worstSin = 0.;
+  double worstCos = 0.;
+  for (const double x : values) {
+    worstSin = std::max(worstSin, ulpError(portable::sin(x), std::sin(static_cast<long double>(x))));
+    worstCos = std::max(worstCos, ulpError(portable::cos(x), std::cos(static_cast<long double>(x))));
+  }
+  BOOST_TEST_MESSAGE("sin " << worstSin << " ulp, cos " << worstCos << " ulp");
+  BOOST_TEST(worstSin < 1.);
+  BOOST_TEST(worstCos < 1.);
+}
+
+BOOST_AUTO_TEST_CASE(AtanAndAsinWithinAnUlp)
+{
+  auto values = uniform(-4., 4., 1'000'000U, 3U);
+  const auto wide = uniform(-1.e8, 1.e8, 100'000U, 4U);
+  values.insert(values.end(), wide.begin(), wide.end());
+  double worstAtan = 0.;
+  for (const double x : values) {
+    worstAtan = std::max(worstAtan, ulpError(portable::atan(x), std::atan(static_cast<long double>(x))));
+  }
+  double worstAsin = 0.;
+  for (const double x : uniform(-1., 1., 1'000'000U, 5U)) {
+    worstAsin = std::max(worstAsin, ulpError(portable::asin(x), std::asin(static_cast<long double>(x))));
+  }
+  for (const double x : {0.49999999999999994, 0.5, 0.97499999999999998, 0.975, 0.99999999999999989}) {
+    worstAsin = std::max(worstAsin, ulpError(portable::asin(x), std::asin(static_cast<long double>(x))));
+    worstAsin = std::max(worstAsin, ulpError(portable::asin(-x), std::asin(static_cast<long double>(-x))));
+  }
+  BOOST_TEST_MESSAGE("atan " << worstAtan << " ulp, asin " << worstAsin << " ulp");
+  BOOST_TEST(worstAtan < 1.);
+  BOOST_TEST(worstAsin < 1.);
+}
+
+BOOST_AUTO_TEST_CASE(Atan2WithinTwoUlpInEveryQuadrant)
+{
+  const auto ys = uniform(-3., 3., 1'000'000U, 6U);
+  const auto xs = uniform(-3., 3., 1'000'000U, 7U);
+  double worst = 0.;
+  for (std::size_t i = 0; i < ys.size(); ++i) {
+    worst = std::max(worst, ulpError(portable::atan2(ys[i], xs[i]), std::atan2(static_cast<long double>(ys[i]), static_cast<long double>(xs[i]))));
+  }
+  // The propagator's turn: sine and cosine of up to about 100 degrees.
+  const auto sines = uniform(-1., 1., 1'000'000U, 8U);
+  const auto cosines = uniform(-0.2, 1., 1'000'000U, 9U);
+  for (std::size_t i = 0; i < sines.size(); ++i) {
+    worst = std::max(worst, ulpError(portable::atan2(sines[i], cosines[i]), std::atan2(static_cast<long double>(sines[i]), static_cast<long double>(cosines[i]))));
+  }
+  BOOST_TEST_MESSAGE("atan2 " << worst << " ulp");
+  BOOST_TEST(worst < 2.);
+}
+
+BOOST_AUTO_TEST_CASE(LogWithinAnUlp)
+{
+  auto values = uniform(0., 4., 1'000'000U, 10U);
+  const auto nearOne = uniform(1. - 1.e-6, 1. + 1.e-6, 100'000U, 11U);
+  values.insert(values.end(), nearOne.begin(), nearOne.end());
+  // No subnormals: the test links O2's libO2GPUDataTypes.so, which sets the
+  // host's DAZ at load (crtfastmath.o), and under DAZ one reads as zero.
+  for (const double x : {1.e-300, std::numeric_limits<double>::min(), 1.e-200, 1.e300, std::numeric_limits<double>::max(), 2., 0.5}) {
+    values.push_back(x);
+  }
+  double worst = 0.;
+  for (const double x : values) {
+    if (x > 0.) {
+      worst = std::max(worst, ulpError(portable::log(x), std::log(static_cast<long double>(x))));
+    }
+  }
+  BOOST_TEST_MESSAGE("log " << worst << " ulp");
+  BOOST_TEST(worst < 1.);
+}
+
+BOOST_AUTO_TEST_CASE(SpecialValues)
+{
+  BOOST_TEST(sameBits(portable::sin(0.), 0.));
+  BOOST_TEST(sameBits(portable::sin(-0.), -0.));
+  BOOST_TEST(sameBits(portable::cos(0.), 1.));
+  BOOST_TEST(sameBits(portable::cos(-0.), 1.));
+  BOOST_TEST(std::isnan(portable::sin(kInf)));
+  BOOST_TEST(std::isnan(portable::cos(-kInf)));
+  BOOST_TEST(std::isnan(portable::sin(kNaN)));
+
+  BOOST_TEST(sameBits(portable::atan(-0.), -0.));
+  BOOST_TEST(sameBits(portable::atan(kInf), std::numbers::pi / 2.));
+  BOOST_TEST(sameBits(portable::atan(-kInf), -std::numbers::pi / 2.));
+  BOOST_TEST(std::isnan(portable::atan(kNaN)));
+
+  BOOST_TEST(sameBits(portable::atan2(0., 1.), 0.));
+  BOOST_TEST(sameBits(portable::atan2(-0., 1.), -0.));
+  BOOST_TEST(sameBits(portable::atan2(0., 0.), 0.));
+  BOOST_TEST(sameBits(portable::atan2(-0., 0.), -0.));
+  BOOST_TEST(sameBits(portable::atan2(0., -0.), std::numbers::pi));
+  BOOST_TEST(sameBits(portable::atan2(-0., -0.), -std::numbers::pi));
+  BOOST_TEST(sameBits(portable::atan2(0., -1.), std::numbers::pi));
+  BOOST_TEST(sameBits(portable::atan2(-0., -1.), -std::numbers::pi));
+  BOOST_TEST(sameBits(portable::atan2(1., 0.), std::numbers::pi / 2.));
+  BOOST_TEST(sameBits(portable::atan2(-1., -0.), -std::numbers::pi / 2.));
+  BOOST_TEST(sameBits(portable::atan2(kInf, kInf), std::numbers::pi / 4.));
+  BOOST_TEST(sameBits(portable::atan2(-kInf, -kInf), -3. * std::numbers::pi / 4.));
+  BOOST_TEST(sameBits(portable::atan2(1., kInf), 0.));
+  BOOST_TEST(sameBits(portable::atan2(-1., kInf), -0.));
+  BOOST_TEST(sameBits(portable::atan2(1., -kInf), std::numbers::pi));
+  BOOST_TEST(sameBits(portable::atan2(-kInf, 1.), -std::numbers::pi / 2.));
+  BOOST_TEST(sameBits(portable::atan2(1.e300, 1.e-300), std::numbers::pi / 2.));
+  BOOST_TEST(sameBits(portable::atan2(1.e-300, -1.e300), std::numbers::pi));
+  BOOST_TEST(sameBits(portable::atan2(0.5, 1.), portable::atan(0.5)));
+  BOOST_TEST(std::isnan(portable::atan2(kNaN, 1.)));
+  BOOST_TEST(std::isnan(portable::atan2(1., kNaN)));
+
+  BOOST_TEST(sameBits(portable::asin(1.), std::numbers::pi / 2.));
+  BOOST_TEST(sameBits(portable::asin(-1.), -std::numbers::pi / 2.));
+  BOOST_TEST(sameBits(portable::asin(-0.), -0.));
+  BOOST_TEST(std::isnan(portable::asin(1.0000000000000002)));
+  BOOST_TEST(std::isnan(portable::asin(-2.)));
+
+  BOOST_TEST(sameBits(portable::log(1.), 0.));
+  BOOST_TEST(sameBits(portable::log(0.), -kInf));
+  BOOST_TEST(sameBits(portable::log(-0.), -kInf));
+  BOOST_TEST(sameBits(portable::log(kInf), kInf));
+  BOOST_TEST(std::isnan(portable::log(-1.)));
+  BOOST_TEST(std::isnan(portable::log(-kInf)));
+  BOOST_TEST(std::isnan(portable::log(kNaN)));
+}
+
+/// Invalid arguments give one NaN, the same bits everywhere, not whichever
+/// NaN the target's arithmetic makes.
+BOOST_AUTO_TEST_CASE(InvalidArgumentsGiveTheQuietNaN)
+{
+  const auto quiet = std::bit_cast<double>(0x7FF8000000000000ULL);
+  BOOST_TEST(sameBits(portable::sin(kInf), quiet));
+  BOOST_TEST(sameBits(portable::cos(-kInf), quiet));
+  BOOST_TEST(sameBits(portable::asin(2.), quiet));
+  BOOST_TEST(sameBits(portable::log(-1.), quiet));
+}
diff --git a/Detectors/GenericTracking/base/test/testTimeEstPS.cxx b/Detectors/GenericTracking/base/test/testTimeEstPS.cxx
new file mode 100644
index 0000000000000..2cf158d713b80
--- /dev/null
+++ b/Detectors/GenericTracking/base/test/testTimeEstPS.cxx
@@ -0,0 +1,142 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTimeEstPS.cxx
+/// \brief The time box in picoseconds and its edges rounded from BC
+///        (GenericTracking/Base/TimeEstPS.h).
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK time box
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Base/FrameTiming.h"
+#include "GenericTracking/Base/TimeEstPS.h"
+
+#include "CommonConstants/LHCConstants.h"
+
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+/// The BC of a 48-orbit timeframe, beyond any the boxes hold.
+constexpr std::int64_t kBCs = std::int64_t{48} * o2::constants::lhc::LHCMaxBunches;
+constexpr std::int64_t kFrameBC = 198;
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(BunchCrossingsArePicosecondsOfO2sSpacingRoundedDown)
+{
+  for (std::int64_t bc = 0; bc <= kBCs; bc += 997) {
+    const double exactPS = static_cast<double>(bc) * o2::constants::lhc::LHCBunchSpacingNS * 1000.;
+    const double below = exactPS - static_cast<double>(psOfBC(bc));
+    BOOST_TEST(below > -1e-3);
+    BOOST_TEST(below < 1. + 1e-3);
+  }
+  BOOST_TEST(psOfBC(0) == 0);
+  BOOST_TEST(psOfBC(kFrameBC) == 4'940'255);
+  BOOST_TEST(psOfBC(2 * kFrameBC) == 9'880'510);
+}
+
+BOOST_AUTO_TEST_CASE(PicosecondsGiveTheirBunchCrossingBack)
+{
+  for (std::int64_t bc = 0; bc <= kBCs; ++bc) {
+    if (bcOfPS(psOfBC(bc)) != bc) {
+      BOOST_FAIL("bcOfPS(psOfBC(" << bc << ")) is " << bcOfPS(psOfBC(bc)));
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(FramesAreEquallyWideAndOverlapOnlyWithAMargin)
+{
+  const std::int64_t frames = (std::int64_t{32} * o2::constants::lhc::LHCMaxBunches) / kFrameBC;
+  for (std::int64_t k = 0; k + 2 < frames; ++k) {
+    const auto start = 64 + (k * kFrameBC); // a frame bias as data has one
+    const auto box = frameBox(start, start + kFrameBC, 0);
+    const auto next = frameBox(start + kFrameBC, start + (2 * kFrameBC), 0);
+    BOOST_REQUIRE(box.width == static_cast<std::uint32_t>(psOfBC(kFrameBC)));
+    BOOST_REQUIRE(box.upper() <= next.lower());
+    BOOST_REQUIRE(next.lower() - box.upper() <= 1U);
+    BOOST_REQUIRE(!box.isCompatible(next));
+    const auto wide = frameBox(start, start + kFrameBC, 30);
+    BOOST_REQUIRE(wide.width == static_cast<std::uint32_t>(psOfBC(kFrameBC + 60)));
+    BOOST_REQUIRE(wide.isCompatible(frameBox(start + kFrameBC, start + (2 * kFrameBC), 30)));
+    BOOST_REQUIRE(!wide.isCompatible(frameBox(start + (2 * kFrameBC), start + (3 * kFrameBC), 30)));
+  }
+}
+
+/// Two boxes overlap exactly when their BC intervals do, whatever their
+/// lengths -- staggered frames, margins -- and wherever they start.
+BOOST_AUTO_TEST_CASE(BoxesOverlapExactlyWhenTheirBunchCrossingsDo)
+{
+  constexpr std::array<std::int64_t, 8> kLengths{1, 2, 60, 197, 198, 228, 258, 891};
+  std::int64_t checked = 0;
+  for (std::int64_t a = 0; a < 1200; a += 3) {
+    for (const auto la : kLengths) {
+      for (std::int64_t b = a - 900 < 0 ? 0 : a - 900; b < a + 900; ++b) {
+        for (const auto lb : kLengths) {
+          const bool bc = a < b + lb && b < a + la;
+          if (frameBox(a, a + la, 0).isCompatible(frameBox(b, b + lb, 0)) != bc) {
+            BOOST_FAIL("[" << a << ", " << a + la << ") and [" << b << ", " << b + lb << ") BC");
+          }
+          ++checked;
+        }
+      }
+    }
+  }
+  BOOST_TEST(checked > 1'000'000);
+}
+
+/// A box is one of a layer's frames exactly when `frameBox` made it from
+/// one of them with no margin.
+BOOST_AUTO_TEST_CASE(ABoxIsAFrameOnlyAsFrameBoxMakesIt)
+{
+  constexpr FrameTiming kFrames{.lengthBC = 22, .firstStartBC = 64};
+  for (std::int64_t frame = 0; frame < 5184; ++frame) {
+    const auto start = 64 + (frame * 22);
+    BOOST_REQUIRE(kFrames.isFrame(frameBox(start, start + 22, 0)));
+  }
+  BOOST_TEST(!kFrames.isFrame(frameBox(64 + 22, 64 + 44, 1))); // widened
+  BOOST_TEST(!kFrames.isFrame(frameBox(64 + 11, 64 + 33, 0))); // between frame starts
+  BOOST_TEST(!kFrames.isFrame(frameBox(64 - 22, 64, 0)));      // before the first frame
+  BOOST_TEST(!kFrames.isFrame(frameBox(64, 64 + 81, 0)));      // another length
+  BOOST_TEST(!kFrames.isFrame({.start = 1U + static_cast<std::uint32_t>(psOfBC(64)), .width = static_cast<std::uint32_t>(psOfBC(22))}));
+  BOOST_TEST(!FrameTiming{}.isFrame(frameBox(0, 22, 0))); // no frames
+}
+
+BOOST_AUTO_TEST_CASE(TheFirstFrameIsClampedAtTheTimeframesStart)
+{
+  const auto box = frameBox(0, kFrameBC, 30);
+  BOOST_TEST(box.lower() == 0U);
+  BOOST_TEST(box.width == static_cast<std::uint32_t>(psOfBC(kFrameBC + 30)));
+}
+
+BOOST_AUTO_TEST_CASE(TheIntersectionNarrowsAndTheEndSaturates)
+{
+  TimeEstPS box{.start = 0U, .width = 10U};
+  BOOST_TEST(box.isCompatible(TimeEstPS{.start = 5U, .width = 10U}));
+  box += TimeEstPS{.start = 5U, .width = 10U};
+  box += TimeEstPS{.start = 9U, .width = 10U};
+  BOOST_TEST(box.lower() == 9U);
+  BOOST_TEST(box.upper() == 10U);
+  BOOST_TEST(!box.isCompatible(TimeEstPS{.start = 10U, .width = 5U}));
+
+  const TimeEstPS late{.start = std::numeric_limits<std::uint32_t>::max() - 3U, .width = 10U};
+  BOOST_TEST(late.upper() == std::numeric_limits<std::uint32_t>::max());
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/study/CMakeLists.txt b/Detectors/GenericTracking/study/CMakeLists.txt
new file mode 100644
index 0000000000000..05bdee5616360
--- /dev/null
+++ b/Detectors/GenericTracking/study/CMakeLists.txt
@@ -0,0 +1,108 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+# What measures or checks the tracking: the bench and its analyses, the replay
+# format of the dumps, the study workflow's sink and its QA, the MC vertex
+# reader, the checks of the material LUT, the clusters and the hits. Built
+# with the upgrades (the bench, the hits and the replay format name the TRK).
+# The library, the sink and the benches instantiate the header tracker
+# (GTRK_TRACKER_OPTIMIZATION).
+function(gtrk_study_o3 target)
+  target_compile_options(${target} PRIVATE ${GTRK_TRACKER_OPTIMIZATION})
+endfunction()
+
+# What the study's sources and public headers include, outside GenericTracking.
+set(studyLibraries O2::GTrkTools O2::GTrkWorkflow O2::GTrkTracking O2::Framework O2::CommonUtils O2::CommonConstants
+                   O2::DetectorsBase O2::SimulationDataFormat O2::ReconstructionDataFormats)
+o2_add_library(GTrkStudy
+               SOURCES src/Hits.cxx
+                       src/Tracks.cxx
+                       src/MCVertexParam.cxx
+                       src/MCVertexReaderSpec.cxx
+                       src/ProfileReport.cxx
+                       src/TrackComparison.cxx
+                       src/TrackPulls.cxx
+                       src/TrackingInput.cxx
+                       src/TrackingQA.cxx
+               PUBLIC_LINK_LIBRARIES ${studyLibraries}
+               PRIVATE_LINK_LIBRARIES O2::ITSMFTSimulation O2::DataFormatsTRKFT3 O2::DataFormatsITS O2::DataFormatsMFT O2::Steer O2::DetectorsRaw
+                                      ROOT::Core ROOT::RIO ROOT::Tree
+               TARGETVARNAME targetName)
+gtrk_study_o3(${targetName})
+
+# o2_add_library installs the headers of include/<library name> only.
+target_include_directories(${targetName} PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+install(DIRECTORY include/GenericTracking DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+# GTRKMCVertex, a ConfigurableParam: a dictionary for --configKeyValues.
+o2_target_root_dictionary(GTrkStudy
+                          HEADERS include/GenericTracking/Study/MCVertexParam.h
+                          LINKDEF src/GTrkStudyLinkDef.h)
+
+# The sink, one unit per detector: each instantiates the tracker and its QA.
+foreach(detector ITS MFT TRKFT3)
+  add_library(gtrk_sink_${detector} OBJECT src/MeasurementSinkSpec.cxx)
+  set_property(TARGET gtrk_sink_${detector} PROPERTY POSITION_INDEPENDENT_CODE ON)
+  target_compile_definitions(gtrk_sink_${detector} PRIVATE GTRK_SINK_DETECTOR=${detector})
+  target_include_directories(gtrk_sink_${detector} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+  target_link_libraries(gtrk_sink_${detector} PRIVATE ${studyLibraries} O2::Steer)
+  gtrk_study_o3(gtrk_sink_${detector})
+  target_sources(${targetName} PRIVATE $<TARGET_OBJECTS:gtrk_sink_${detector}>)
+endforeach()
+
+# The study workflows, one per detector (tools/StudyWorkflow.h).
+o2_add_executable(its-study-workflow
+                  SOURCES tools/gtrk-its-study-workflow.cxx
+                  COMPONENT_NAME gtrk
+                  PUBLIC_LINK_LIBRARIES O2::GTrkStudy O2::DetectorsRaw O2::ITSMFTWorkflow)
+o2_add_executable(mft-study-workflow
+                  SOURCES tools/gtrk-mft-study-workflow.cxx
+                  COMPONENT_NAME gtrk
+                  PUBLIC_LINK_LIBRARIES O2::GTrkStudy O2::DetectorsRaw O2::ITSMFTWorkflow)
+o2_add_executable(trk-study-workflow
+                  SOURCES tools/gtrk-trk-study-workflow.cxx
+                  COMPONENT_NAME gtrk
+                  PUBLIC_LINK_LIBRARIES O2::GTrkStudy O2::DetectorsRaw O2::TRKWorkflow)
+
+# One unit per detector's run (TrackBench.h), the options and the dispatch in
+# trackBench.cxx: the detectors compile in parallel.
+o2_add_executable(track-bench
+                  SOURCES tools/trackBench.cxx tools/trackBenchITS.cxx tools/trackBenchMFT.cxx tools/trackBenchTRKFT3.cxx
+                  COMPONENT_NAME gtrk
+                  PUBLIC_LINK_LIBRARIES O2::GTrkStudy O2::Steer O2::CCDB Boost::program_options
+                  TARGETVARNAME benchTarget)
+gtrk_study_o3(${benchTarget})
+
+o2_add_executable(fit-bench
+                  SOURCES tools/fitBench.cxx
+                  COMPONENT_NAME gtrk
+                  PUBLIC_LINK_LIBRARIES O2::GTrkStudy Boost::program_options
+                  TARGETVARNAME fitBenchTarget)
+gtrk_study_o3(${fitBenchTarget})
+
+o2_add_executable(check-matlut
+                  SOURCES tools/checkMatLUT.cxx
+                  COMPONENT_NAME gtrk
+                  PUBLIC_LINK_LIBRARIES O2::GTrkStudy O2::DetectorsBase O2::Steer ROOT::Geom ROOT::RIO ROOT::Tree Boost::program_options)
+
+o2_add_executable(cluster-closure
+                  SOURCES tools/clusterClosure.cxx
+                  COMPONENT_NAME gtrk
+                  PUBLIC_LINK_LIBRARIES O2::GTrkStudy O2::ITSBase O2::MFTBase O2::DataFormatsITSMFT O2::TRKBase O2::FT3Base
+                                        O2::TRKReconstruction O2::DataFormatsTRKFT3 O2::DetectorsRaw O2::CommonUtils ROOT::RIO ROOT::Tree
+                                        Boost::program_options)
+
+o2_add_executable(check-hits
+                  SOURCES tools/checkHits.cxx
+                  COMPONENT_NAME gtrk
+                  PUBLIC_LINK_LIBRARIES O2::GTrkStudy Boost::program_options)
+
+add_subdirectory(test)
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/Alice/Hits.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/Alice/Hits.h
new file mode 100644
index 0000000000000..6a69241db79c9
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/Alice/Hits.h
@@ -0,0 +1,98 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Hits.h
+/// \brief O2's simulated ITS, MFT and TRK hits, as the segments a particle crossed
+///        each chip along.
+
+#ifndef GTRK_STUDY_ALICE_HITS_H_
+#define GTRK_STUDY_ALICE_HITS_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+
+#include <array>
+#include <concepts>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+class TFile;
+class TTree;
+
+namespace o2::gtrk::study
+{
+
+/// Whose MC files: the ITS's, the MFT's, or the ALICE 3 tracker's (TRK's barrel, then FT3's discs).
+enum class Chips : std::uint8_t { kITS,
+                                  kMFT,
+                                  kTRK };
+
+/// Whose MC files a layout's are.
+template <DetectorLayout Det>
+  requires std::same_as<Det, detectors::ITS> || std::same_as<Det, detectors::MFT> || std::same_as<Det, detectors::TRKFT3>
+[[nodiscard]] constexpr Chips chipsOf()
+{
+  if constexpr (std::same_as<Det, detectors::ITS>) {
+    return Chips::kITS;
+  } else if constexpr (std::same_as<Det, detectors::MFT>) {
+    return Chips::kMFT;
+  } else {
+    return Chips::kTRK;
+  }
+}
+
+/// One particle's crossing of one chip, in the global frame [cm, GeV].
+struct HitSegment {
+  int track = -1;          ///< MC track ID within its event
+  std::uint32_t chip = 0U; ///< our sensor ID: O2's chip ID; FT3's after TRK's (TRKFT3::kFirstDiscSensor)
+  std::array<double, 3> start{};
+  std::array<double, 3> end{};
+  std::array<double, 3> momentum{}; ///< at the start
+  double time = 0.;                 ///< the time of flight at the end: the order along the particle's path
+};
+
+/// `sgn_HitsITS.root`, `sgn_HitsMFT.root` or `sgn_HitsTRK.root`, one tree entry per MC event;
+/// for the TRK, with `sgn_HitsFT3.root` beside it, FT3's hits too.
+class HitFile
+{
+ public:
+  /// Throws std::runtime_error if \a path, or a non-empty \a discPath, has
+  /// no o2sim tree. \a discPath, FT3's hits, only for Chips::kTRK.
+  HitFile(const std::string& path, Chips chips, const std::string& discPath = {});
+  ~HitFile();
+  HitFile(const HitFile&) = delete;
+  HitFile& operator=(const HitFile&) = delete;
+  HitFile(HitFile&&) = delete;
+  HitFile& operator=(HitFile&&) = delete;
+
+  /// The segments of event \a event; every event's read at the first call and kept.
+  [[nodiscard]] const std::vector<HitSegment>& event(int event);
+
+  /// How many MC events the file holds.
+  [[nodiscard]] int nEvents() const;
+
+ private:
+  Chips mChips;
+  std::unique_ptr<TFile> mFile;
+  TTree* mTree = nullptr;
+  std::unique_ptr<TFile> mDiscFile; ///< FT3's, for the TRK
+  TTree* mDiscTree = nullptr;
+  bool mRead = false;
+  std::vector<std::vector<HitSegment>> mEvents; ///< by event
+};
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_ALICE_HITS_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/Alice/Tracks.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/Alice/Tracks.h
new file mode 100644
index 0000000000000..04a434bb60bc7
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/Alice/Tracks.h
@@ -0,0 +1,71 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Tracks.h
+/// \brief O2's ITS and MFT tracks, as the clusters they hold, their MC labels'
+///        fake flags and, for the ITS, their states at the innermost cluster.
+///
+/// All a comparison with our tracks needs, because both trackers read the
+/// same clusters in the same order (Clusters.h): a track is its list of O2
+/// cluster indices, which are our measurements' `clusterIndex`.
+
+#ifndef GTRK_STUDY_ALICE_TRACKS_H_
+#define GTRK_STUDY_ALICE_TRACKS_H_
+
+#include "GenericTracking/Study/Alice/Hits.h"
+
+#include "ReconstructionDataFormats/Track.h"
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+class TFile;
+class TTree;
+
+namespace o2::gtrk::study
+{
+
+/// One timeframe's tracks, each as its cluster indices.
+using TrackClusters = std::vector<std::vector<std::uint32_t>>;
+
+/// Reads `o2trac_its.root` or `mfttracks.root`, one tree entry per timeframe.
+class TrackFile
+{
+ public:
+  /// Throws std::runtime_error if \a path has no o2sim tree.
+  TrackFile(const std::string& path, Chips chips);
+  ~TrackFile();
+  TrackFile(const TrackFile&) = delete;
+  TrackFile& operator=(const TrackFile&) = delete;
+  TrackFile(TrackFile&&) = delete;
+  TrackFile& operator=(TrackFile&&) = delete;
+
+  /// The tracks of entry \a entry; empty past the last. Throws
+  /// std::runtime_error if a track points past the cluster index array.
+  [[nodiscard]] TrackClusters read(long long entry);
+
+  /// Whether each track's own MC label is flagged fake, as O2's tracker set it.
+  [[nodiscard]] std::vector<bool> fakeFlags(long long entry);
+
+  /// Every ITS track's state at its innermost cluster. Throws
+  /// std::runtime_error for the MFT, whose tracks are parameterised in z.
+  [[nodiscard]] std::vector<o2::track::TrackParCov> innerStates(long long entry);
+
+ private:
+  Chips mChips;
+  std::unique_ptr<TFile> mFile;
+  TTree* mTree = nullptr;
+};
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_ALICE_TRACKS_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/Digest.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/Digest.h
new file mode 100644
index 0000000000000..9c18630b355ae
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/Digest.h
@@ -0,0 +1,305 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Digest.h
+/// \brief A 64-bit fingerprint of output columns, as their values' bits.
+///
+/// A change to how the host reaches the tracks may not change a single bit
+/// of them, and comparing two runs' digests is how that is checked without
+/// keeping either run's output.
+///
+/// Every value is hashed as the bits of its fields, never as the bytes of its
+/// object, whose padding nobody writes. A column type is accepted only when its
+/// object representation is its value (integers, `ClusterList`), when it is
+/// floating point, or when it is decomposed here field by field; anything else
+/// fails to compile rather than hash its padding.
+
+#ifndef GTRK_STUDY_DIGEST_H_
+#define GTRK_STUDY_DIGEST_H_
+
+#include "GenericTracking/Tracking/BoundTrackState.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/TrackRefit.h"
+
+#include <algorithm>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory_resource>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+/// A running 64-bit hash over words: stable across runs, builds and
+/// machines of one byte order. Not cryptographic; a fingerprint.
+class Digest
+{
+ public:
+  /// One value, as the bits of its fields.
+  template <typename T>
+  void add(const T& value)
+  {
+    if constexpr (std::is_same_v<T, BoundTrackState>) {
+      for (const auto parameter : value.par) {
+        add(parameter);
+      }
+      for (const auto covariance : value.cov) {
+        add(covariance);
+      }
+      add(value.surface);
+      // 0 on every flat sensor: hashed only when set, so that a layout without
+      // curved sensors digests without it.
+      if (!exactlyEqual(value.surfacePhi, Scalar{0})) {
+        add(value.surfacePhi);
+      }
+    } else if constexpr (std::is_same_v<T, VertexSeed>) {
+      add(value.timePS);
+      add(value.widthPS);
+      add(value.z);
+      add(value.varZ);
+      add(value.varTransverse);
+    } else {
+      static_assert(std::is_floating_point_v<T> || std::has_unique_object_representations_v<T>, "a digest reads a value's bits; decompose types with padding field by field");
+      bytes(&value, sizeof(T));
+    }
+  }
+
+  /// \a count values at \a values, preceded by their count.
+  template <typename T>
+  void column(const T* values, std::size_t count)
+  {
+    mix(count);
+    if constexpr (std::is_floating_point_v<T> || std::has_unique_object_representations_v<T>) {
+      bytes(values, count * sizeof(T));
+    } else {
+      for (std::size_t index = 0; index < count; ++index) {
+        add(values[index]);
+      }
+    }
+  }
+
+  template <typename T>
+  void column(std::span<T> values)
+  {
+    column(values.data(), values.size());
+  }
+
+  /// Every column of a memlayout view, \a rows rows each, in schema order.
+  template <typename View>
+  void columns(const View& view, std::size_t rows)
+  {
+    view.apply([&](const auto*... columns) { (column(columns, rows), ...); });
+  }
+
+  /// The fingerprint so far, avalanched; the digest itself is unchanged.
+  [[nodiscard]] std::uint64_t result() const
+  {
+    std::uint64_t hash = mState ^ mWords;
+    hash ^= hash >> 33U;
+    hash *= 0xff51afd7ed558ccdULL;
+    hash ^= hash >> 33U;
+    hash *= 0xc4ceb9fe1a85ec53ULL;
+    hash ^= hash >> 33U;
+    return hash;
+  }
+
+ private:
+  /// The bytes \a data, \a size of them, in order.
+  void bytes(const void* data, std::size_t size)
+  {
+    const auto* at = static_cast<const unsigned char*>(data);
+    while (size >= sizeof(std::uint64_t)) {
+      std::uint64_t word = 0U;
+      std::memcpy(&word, at, sizeof(word));
+      mix(word);
+      at += sizeof(word);
+      size -= sizeof(word);
+    }
+    if (size != 0U) {
+      std::uint64_t word = 0U;
+      std::memcpy(&word, at, size);
+      mix(word ^ (std::uint64_t{size} << 56U));
+    }
+  }
+
+  void mix(std::uint64_t word)
+  {
+    mState = std::rotl(mState ^ (word * 0x9e3779b97f4a7c15ULL), 31) * 0xbf58476d1ce4e5b9ULL;
+    ++mWords;
+  }
+
+  std::uint64_t mState = 0x243f6a8885a308d3ULL;
+  std::uint64_t mWords = 0U;
+};
+
+/// The counts of every iteration's summary of \a result (a tracker's
+/// `TimeframeResult`): part of both digests. The counts of the earlier
+/// iterations' follow and the length cut (`tracksFollowedEarlier`,
+/// `tracksDropped`...) are left out; the tracks they change are in both.
+template <typename Result>
+void addSummaries(Digest& digest, const Result& result)
+{
+  for (const auto& summary : result.iterations) {
+    for (const std::size_t count : {static_cast<std::size_t>(summary.status), summary.slices, summary.roads, summary.records, summary.duplicates, summary.mismatches, summary.rounds, summary.tracks, summary.refitFailures, summary.tracksFollowed, summary.clustersFollowedOutward, summary.clustersFollowedInward}) {
+      digest.add(static_cast<std::uint64_t>(count));
+    }
+    digest.add(summary.haloPS);
+  }
+}
+
+/// The fingerprint of a complete run's output: every column of every track,
+/// the used mask \a used the run left (the tracker's `used()`), and the counts
+/// of every iteration's summary -- nothing that is a time, nor a size in
+/// bytes, which a record's layout changes without changing the output. Two
+/// runs that agree on it produced the same tracks bit for bit.
+template <typename Result>
+[[nodiscard]] std::uint64_t trackingDigest(const Result& result, std::span<const std::uint8_t> used)
+{
+  Digest digest;
+  digest.add(static_cast<std::uint32_t>(result.status));
+  if (result.tracks != nullptr) {
+    digest.columns(result.tracks->view(), result.tracks->size());
+  }
+  digest.column(used);
+  addSummaries(digest, result);
+  return digest.result();
+}
+
+/// \a tracks in cluster numbers into \a digest: each track's rows as cluster
+/// indices, the tracks in the order of their cluster lists, and every other
+/// column as is. The part of `clusterDigest` that reads only the tracks, so
+/// that a device's tracks digest alike.
+template <DetectorLayout Det>
+void addTracksInClusters(Digest& digest, const typename TrackRefit<Det>::Tracks& tracks, const TimeFrame<Det>& frame)
+{
+  constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  const auto columns = frame.measurements();
+  const auto clusterOf = [&](std::uint32_t row) { return row == ClusterList<kMaxClusters>::kNoCluster ? row : columns.clusterIndex[row]; };
+  const auto view = tracks.view();
+  const std::size_t n = tracks.size();
+  std::vector<ClusterList<kMaxClusters>> clusters(n);
+  for (std::size_t track = 0; track < n; ++track) {
+    for (std::size_t at = 0; at < kMaxClusters; ++at) {
+      clusters[track].index[at] = at < view.count[track] ? clusterOf(view.clusters[track].index[at]) : ClusterList<kMaxClusters>::kNoCluster;
+    }
+  }
+  std::vector<std::size_t> order(n);
+  for (std::size_t track = 0; track < n; ++track) {
+    order[track] = track;
+  }
+  std::sort(order.begin(), order.end(), [&](std::size_t a, std::size_t b) {
+    const auto& first = clusters[a].index;
+    const auto& second = clusters[b].index;
+    const auto differ = std::mismatch(std::begin(first), std::end(first), std::begin(second));
+    if (differ.first != std::end(first)) {
+      return *differ.first < *differ.second;
+    }
+    return view.iteration[a] < view.iteration[b];
+  });
+  digest.add(static_cast<std::uint64_t>(n));
+  for (const auto track : order) {
+    view.apply([&](const auto*... column) {
+      (
+        [&](const auto* values) {
+          if constexpr (std::is_same_v<std::remove_cv_t<std::remove_pointer_t<decltype(values)>>, ClusterList<kMaxClusters>>) {
+            digest.add(clusters[track]);
+          } else {
+            digest.add(values[track]);
+          }
+        }(column),
+        ...);
+    });
+  }
+}
+
+/// The same output in the producer's cluster numbers instead of the frame's
+/// rows. Rows are numbered in grid order, so another grid layout renumbers
+/// them without changing a track; this does not see the renumbering. Every
+/// column of every track, its clusters as cluster numbers, the tracks ordered
+/// by those numbers (then by iteration); which cluster the used mask \a used
+/// marks how; and every count of the iteration summaries. \a frame is the one
+/// \a result was tracked on.
+template <DetectorLayout Det, typename Result>
+[[nodiscard]] std::uint64_t clusterDigest(const Result& result, const TimeFrame<Det>& frame, std::span<const std::uint8_t> used)
+{
+  const auto columns = frame.measurements();
+  Digest digest;
+  digest.add(static_cast<std::uint32_t>(result.status));
+  if (result.tracks != nullptr) {
+    addTracksInClusters<Det>(digest, *result.tracks, frame);
+  }
+  std::uint32_t clusterEnd = 0U;
+  for (std::uint32_t row = 0; row < frame.size(); ++row) {
+    clusterEnd = std::max(clusterEnd, columns.clusterIndex[row] + 1U);
+  }
+  std::vector<std::uint8_t> usedByCluster(clusterEnd, std::uint8_t{0xFFU});
+  for (std::uint32_t row = 0; row < frame.size(); ++row) {
+    usedByCluster[columns.clusterIndex[row]] = used[row];
+  }
+  digest.column(std::span<const std::uint8_t>{usedByCluster});
+  addSummaries(digest, result);
+  return digest.result();
+}
+
+/// \a tracks' columns, as "digest, tracks" of a device's tracks.
+template <class Tracks>
+[[nodiscard]] std::uint64_t tracksDigest(const Tracks& tracks)
+{
+  Digest digest;
+  digest.columns(std::as_const(tracks).view(), tracks.size());
+  return digest.result();
+}
+
+/// A vertex list and its contributor counts, as the vertexer gives them.
+[[nodiscard]] inline std::uint64_t vertexDigest(std::span<const VertexSeed> vertices, std::span<const std::uint32_t> contributors)
+{
+  Digest digest;
+  digest.add(vertices.size());
+  for (const auto& vertex : vertices) {
+    digest.add(vertex);
+  }
+  digest.column(contributors.data(), contributors.size());
+  return digest.result();
+}
+
+/// \a records (the tracking device's product) as the tracker's columns, on
+/// \a resource: what the digests of a device's tracks take.
+template <DetectorLayout Det>
+[[nodiscard]] typename TrackRefit<Det>::Tracks recordsTracks(std::span<const typename TrackRefit<Det>::Tracks::Record> records, std::pmr::memory_resource* resource)
+{
+  typename TrackRefit<Det>::Tracks tracks;
+  tracks.setMemoryResource(resource);
+  tracks.resize(records.size());
+  for (std::size_t track = 0; track < records.size(); ++track) {
+    tracks.write(track, records[track]);
+  }
+  return tracks;
+}
+
+/// \a tracks in cluster numbers alone: unchanged by a grid layout, and the
+/// same for a device's tracks as for the host's where they are the same.
+template <DetectorLayout Det>
+[[nodiscard]] std::uint64_t tracksClusterDigest(const typename TrackRefit<Det>::Tracks& tracks, const TimeFrame<Det>& frame)
+{
+  Digest digest;
+  addTracksInClusters<Det>(digest, tracks, frame);
+  return digest.result();
+}
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_DIGEST_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/MCTruth.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/MCTruth.h
new file mode 100644
index 0000000000000..9d86c0ad3a28e
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/MCTruth.h
@@ -0,0 +1,139 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MCTruth.h
+/// \brief The study's MC label rules: a primary's first outward pass, a
+///        particle's origin, its collision, a triplet's common particle.
+
+#ifndef GTRK_STUDY_MCTRUTH_H_
+#define GTRK_STUDY_MCTRUTH_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/MathUtils.h"
+#include "GenericTracking/Tracking/SearchWindow.h"
+#include "GenericTracking/Study/TrackComparison.h"
+
+#include "SimulationDataFormat/DigitizationContext.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTrack.h"
+#include "SimulationDataFormat/MCUtils.h"
+
+#include <TMCProcess.h>
+#include <numbers>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+using workflow::carriesParticle;
+
+/// Whether a primary's measurement lies on its first outward helix pass.
+template <DetectorLayout Det>
+[[nodiscard]] bool onFirstOutwardPass(const o2::MCTrack& mc, LayerID layer, Scalar phi, Scalar second, double bzKiloGauss)
+{
+  constexpr double kPhiTolerance = 0.3;
+  constexpr double kZTolerance = 2.;
+  if (!Detector<Det>::isBarrelLayer(layer)) {
+    return true;
+  }
+  const double pt = mc.GetPt();
+  const double radius = curvatureRadius(pt, bzKiloGauss);
+  const double layerRadius = layerDistance<Det>(layer);
+  if (!(2. * radius > layerRadius)) {
+    return false;
+  }
+  const double deflection = std::asin(layerRadius / (2. * radius));
+  const double cotTheta = mc.GetStartVertexMomentumZ() / pt;
+  const double predictedZ = mc.Vz() + (cotTheta * 2. * radius * deflection);
+  const double zTolerance = std::max(kZTolerance, std::numbers::pi_v<double> * radius * std::abs(cotTheta));
+  if (std::abs(static_cast<double>(second) - predictedZ) > zTolerance) {
+    return false;
+  }
+  const double phi0 = std::atan2(mc.GetStartVertexMomentumY(), mc.GetStartVertexMomentumX());
+  const auto offset = [phi](double predicted) { return std::abs(std::remainder(static_cast<double>(phi) - predicted, 2 * std::numbers::pi_v<double>)); };
+  return std::min(offset(phi0 + deflection), offset(phi0 - deflection)) < kPhiTolerance;
+}
+
+/// Where \a particle comes from, given whether it is a physical primary:
+/// otherwise a decay's daughter if the generator made it -- feed-down it
+/// decayed -- or transport made it in a decay, and the material's if neither.
+[[nodiscard]] inline study::ParticleOrigin particleOrigin(const o2::MCTrack& particle, bool physicalPrimary)
+{
+  if (physicalPrimary) {
+    return study::ParticleOrigin::kPhysicalPrimary;
+  }
+  if (particle.isPrimary() || particle.getProcess() == kPDecay) {
+    return study::ParticleOrigin::kDecay;
+  }
+  return study::ParticleOrigin::kMaterial;
+}
+
+/// The same for \a particle, one of \a event's, by O2's physical-primary
+/// test, which takes a transported particle's mother for granted: without
+/// one, it is not a physical primary.
+[[nodiscard]] inline study::ParticleOrigin particleOrigin(const o2::MCTrack& particle, const std::vector<o2::MCTrack>& event)
+{
+  using o2::mcutils::MCTrackNavigator;
+  const bool navigable = particle.isPrimary() || MCTrackNavigator::getMother(particle, event) != nullptr;
+  return particleOrigin(particle, navigable && MCTrackNavigator::isPhysicalPrimary(particle, event));
+}
+
+/// The collision of a packed particle identity (`study::TruthRow`'s
+/// particles): its source and event, the bits above the track's.
+[[nodiscard]] inline std::uint64_t collisionOf(std::uint64_t particle) { return particle >> o2::MCCompLabel::nbitsTrackID; }
+
+/// Calls \a body for each particle of the first of \a held's rows that all
+/// the other rows carry, in that first row's label order; whether there was one.
+template <typename Body>
+bool forEachCommonParticle(std::span<const TruthRow> rows, std::span<const std::uint32_t> held, const Body& body)
+{
+  if (held.empty()) {
+    return false;
+  }
+  bool any = false;
+  const auto& first = rows[held.front()];
+  for (std::size_t at = 0; at < first.count; ++at) {
+    const auto id = first.particles[at];
+    if (std::all_of(held.begin() + 1, held.end(), [&](std::uint32_t row) { return rows[row].carries(id); })) {
+      body(id);
+      any = true;
+    }
+  }
+  return any;
+}
+
+/// The particle a triplet's three rows \a triple of \a rows share: the first
+/// of the middle row's labels the other two also carry; none if no label is
+/// on all three.
+[[nodiscard]] inline std::optional<std::uint64_t> commonParticle(std::span<const study::TruthRow> rows, const std::array<std::uint32_t, 3>& triple)
+{
+  std::optional<std::uint64_t> result;
+  const std::array ordered{triple[1], triple[0], triple[2]};
+  forEachCommonParticle(rows, ordered, [&](std::uint64_t particle) {
+    if (!result) {
+      result = particle;
+    }
+  });
+  return result;
+}
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_MCTRUTH_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/MCVertexParam.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/MCVertexParam.h
new file mode 100644
index 0000000000000..5303601b302d3
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/MCVertexParam.h
@@ -0,0 +1,42 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MCVertexParam.h
+/// \brief The smearing of the MC vertex list: the MC vertex reader's
+///        parameter, GTRKMCVertex.
+
+#ifndef GTRK_STUDY_MCVERTEXPARAM_H_
+#define GTRK_STUDY_MCVERTEXPARAM_H_
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+
+#include <cstdint>
+
+namespace o2::gtrk::study
+{
+
+/// The smearing of the MC vertex list (the MC vertex reader, which the study
+/// workflow adds with `--mc-vertices`). The published variances are these values squared; its
+/// time is the collision's, a box of width 0. The fixed seed makes the resulting vertex lists reproducible.
+// O2ParamDef deletes the copy constructor and supplies the rest of the boilerplate.
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
+struct MCVertexParam : public o2::conf::ConfigurableParamHelper<MCVertexParam> {
+  double sigmaZ = 0.01;           ///< [cm]
+  double sigmaTransverse = 0.002; ///< [cm], independently in x and y
+  std::uint64_t randomSeed = 0x4754524b56455254ULL;
+
+  O2ParamDef(MCVertexParam, "GTRKMCVertex");
+};
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_MCVERTEXPARAM_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/MCVertexReaderSpec.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/MCVertexReaderSpec.h
new file mode 100644
index 0000000000000..ca97aa4f1e1c2
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/MCVertexReaderSpec.h
@@ -0,0 +1,32 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MCVertexReaderSpec.h
+/// \brief Publishes one smeared MC vertex seed per collision in a timeframe.
+
+#ifndef GTRK_STUDY_MCVERTEXREADERSPEC_H_
+#define GTRK_STUDY_MCVERTEXREADERSPEC_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+
+#include "Framework/DataProcessorSpec.h"
+
+namespace o2::gtrk::study
+{
+
+/// \a Det's MC vertices as the native seeds (DataSpecs.h's `kVertices`),
+/// smeared by GTRKMCVertex's widths (MCVertexParam.h).
+template <DetectorLayout Det>
+o2::framework::DataProcessorSpec getMCVertexReaderSpec();
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_MCVERTEXREADERSPEC_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/MeasurementSinkSpec.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/MeasurementSinkSpec.h
new file mode 100644
index 0000000000000..a3c4aaf8bef85
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/MeasurementSinkSpec.h
@@ -0,0 +1,44 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MeasurementSinkSpec.h
+/// \brief The study's sink: the tracker over the producer's measurements, with
+///        the truth reports, the QA trees and the comparison with O2's tracks.
+
+#ifndef GTRK_STUDY_MEASUREMENTSINKSPEC_H_
+#define GTRK_STUDY_MEASUREMENTSINKSPEC_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+
+#include "Framework/DataProcessorSpec.h"
+
+#include <cstdint>
+
+namespace o2::gtrk::study
+{
+
+/// The sink for \a Det. Its tracker seeds each iteration from the
+/// source GTRKReco<DET>.iterationVertexSource configures, the beam line by default.
+/// \a withVertices adds the vertex list input, which a vertex-list iteration
+/// needs. With \a products other than kNone it also takes the tracking
+/// device's products (workflow/TrackerSpec.h), every timeframe. Defined for
+/// ITS, MFT and TRKFT3, each by its own compilation of MeasurementSinkSpec.cxx.
+enum class TrackerProducts : std::uint8_t {
+  kNone,
+  kCompare, ///< --compare-tracks: against its own tracker's, every track record field by field, every vertex and contributor count; the run fails on a difference
+  kDigests, ///< --tracker-digests: their digests logged, as the bench prints a device's
+};
+template <DetectorLayout Det>
+o2::framework::DataProcessorSpec getMeasurementSinkSpec(bool useMC, bool withVertices, TrackerProducts products);
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_MEASUREMENTSINKSPEC_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/ProfileReport.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/ProfileReport.h
new file mode 100644
index 0000000000000..08404428c88e1
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/ProfileReport.h
@@ -0,0 +1,59 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ProfileReport.h
+/// \brief The host profile's reports: a profile (Tracking/Profile.h) as an
+///        indented tree for people and as JSON for the scripts, and one
+///        iteration's summary line, the sink's and the bench's.
+
+#ifndef GTRK_STUDY_PROFILEREPORT_H_
+#define GTRK_STUDY_PROFILEREPORT_H_
+
+#include "GenericTracking/Tracking/Profile.h"
+
+#include <cstddef>
+#include <format>
+#include <ostream>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+/// A profile as an indented tree: each phase with its share of its parent,
+/// and an `(other)` line for the time its children do not cover.
+void report(std::ostream& out, const profile::Profile& profile, profile::Phase root, int threads);
+
+/// A profile as one JSON object, phase name to stats, for the scripts.
+void writeJson(std::ostream& out, const profile::Profile& profile);
+
+/// One iteration's summary (a tracker's IterationSummary) as the lines the
+/// sink logs and the bench prints: the counts and
+/// the phases' times, and the earlier iterations' tracks followed when there
+/// are any.
+template <typename Summary>
+[[nodiscard]] std::vector<std::string> describeIteration(const Summary& summary, std::size_t iteration)
+{
+  std::vector<std::string> lines;
+  lines.push_back(
+    std::format("  iteration {}: {} slices, halo {} ps; {} roads, {} records ({:.1f} MB), {} duplicates, {} mismatches, {} rounds, {} tracks; "
+                "{} refit failed; {} followed (+{} outward, +{} inward), {} dropped; {:.3f} s slices, {:.3f} s roads, {:.3f} s selection, {:.3f} s refit, "
+                "{:.3f} s follow",
+                iteration, summary.slices, summary.haloPS, summary.roads, summary.records, static_cast<double>(summary.recordBytes) / 1.e6, summary.duplicates, summary.mismatches, summary.rounds, summary.tracks, summary.refitFailures, summary.tracksFollowed, summary.clustersFollowedOutward, summary.clustersFollowedInward, summary.tracksDropped, summary.seconds(profile::Phase::kSlices), summary.seconds(profile::Phase::kRoads), summary.seconds(profile::Phase::kSelection), summary.seconds(profile::Phase::kRefit), summary.seconds(profile::Phase::kFollow)));
+  if (summary.tracksFollowedEarlier != 0U || summary.seconds(profile::Phase::kFollowEarlier) > 0.) {
+    lines.push_back(std::format("    earlier iterations' tracks followed: {} (+{} outward, +{} inward) in {:.3f} s", summary.tracksFollowedEarlier, summary.clustersFollowedEarlierOutward, summary.clustersFollowedEarlierInward, summary.seconds(profile::Phase::kFollowEarlier)));
+  }
+  return lines;
+}
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_PROFILEREPORT_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/SpeciesOracle.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/SpeciesOracle.h
new file mode 100644
index 0000000000000..abfe927d8cc5a
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/SpeciesOracle.h
@@ -0,0 +1,124 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file SpeciesOracle.h
+/// \brief The MC oracle refits: a good track's rows
+///        fitted again with its particle's true mass, the scattering's and
+///        the energy loss's apart, for the `oracle` QA tree.
+///
+/// The fit takes one mass hypothesis for both (`Propagator::massGeV`). An
+/// `OraclePropagator` carries the energy loss's own (`lossMassGeV`);
+/// `stepPropagator` hands it on whole, so the fit's steps see it. The
+/// tracking never instantiates it.
+
+#ifndef GTRK_STUDY_SPECIESORACLE_H_
+#define GTRK_STUDY_SPECIESORACLE_H_
+
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Tracking/TrackFitter.h"
+
+#include "CommonConstants/PhysicsConstants.h"
+
+#include <array>
+#include <cstdint>
+#include <cstdlib>
+#include <optional>
+
+namespace o2::gtrk::study
+{
+
+/// A propagator whose energy loss takes \a lossMass, its scattering
+/// `massGeV`.
+struct OraclePropagator : Propagator {
+  Scalar lossMass = static_cast<Scalar>(o2::constants::physics::MassPionCharged);
+};
+
+[[nodiscard]] inline Scalar lossMassGeV(const OraclePropagator& prop) { return prop.lossMass; }
+
+/// The oracle's propagator for every step: itself, as `stepPropagator`
+/// gives a `Propagator`.
+template <typename Geometry, typename Chain>
+[[nodiscard]] const OraclePropagator& stepPropagator(const OraclePropagator& prop, const Geometry& /*geometry*/, const Chain& /*measurements*/, int /*from*/, int /*to*/)
+{
+  return prop; // NOLINT(bugprone-return-const-ref-from-parameter)
+}
+
+/// The refits, each without kinks: the pion's two passes (the control); the
+/// true mass's, for both, for the scattering alone, for the energy loss
+/// alone; the true mass's inward pass alone from the track's own outward
+/// state (the pion's), as the tracking's refit. Then the electron
+/// hypothesis for every species, the inward pass from the same outward state.
+enum class OracleVariant : std::uint8_t { kPion,
+                                          kTrue,
+                                          kTrueScattering,
+                                          kTrueLoss,
+                                          kTrueInward,
+                                          kElectronInward,
+                                          kCount };
+inline constexpr std::size_t kOracleVariants = static_cast<std::size_t>(OracleVariant::kCount);
+
+/// The mass of \a pdg's species [GeV]: e, mu, pi, K, p; none for another.
+[[nodiscard]] inline std::optional<Scalar> oracleMass(std::int32_t pdg)
+{
+  namespace physics = o2::constants::physics;
+  switch (std::abs(pdg)) {
+    case 11:
+      return static_cast<Scalar>(physics::MassElectron);
+    case 13:
+      return static_cast<Scalar>(physics::MassMuon);
+    case 211:
+      return static_cast<Scalar>(physics::MassPionCharged);
+    case 321:
+      return static_cast<Scalar>(physics::MassKaonCharged);
+    case 2212:
+      return static_cast<Scalar>(physics::MassProton);
+    default:
+      return std::nullopt;
+  }
+}
+
+/// \a variant's refit of the \a n rows of \a chain, with \a base's field and
+/// tolerances and \a mass, the particle's; \a outward is the track's outward
+/// state for the inward-only variants.
+template <DetectorLayout Det, typename Material, typename Chain>
+[[nodiscard]] TrackFitResult oracleFit(OracleVariant variant, Scalar mass, const Propagator& base, const TrackingGeometry<Det>& geometry, const Material& material, const Chain& chain, int n, const BoundTrackState& outward)
+{
+  const auto pion = static_cast<Scalar>(o2::constants::physics::MassPionCharged);
+  const auto electron = static_cast<Scalar>(o2::constants::physics::MassElectron);
+  const auto with = [&](Scalar scattering, Scalar loss) {
+    OraclePropagator prop;
+    static_cast<Propagator&>(prop) = base;
+    prop.massGeV = scattering;
+    prop.lossMass = loss;
+    return prop;
+  };
+  switch (variant) {
+    case OracleVariant::kPion:
+      return fitMeasurements(with(pion, pion), geometry, material, chain, n);
+    case OracleVariant::kTrue:
+      return fitMeasurements(with(mass, mass), geometry, material, chain, n);
+    case OracleVariant::kTrueScattering:
+      return fitMeasurements(with(mass, pion), geometry, material, chain, n);
+    case OracleVariant::kTrueLoss:
+      return fitMeasurements(with(pion, mass), geometry, material, chain, n);
+    case OracleVariant::kTrueInward:
+      return fitInward(with(mass, mass), geometry, material, chain, n, outward);
+    case OracleVariant::kElectronInward:
+    case OracleVariant::kCount:
+      break;
+  }
+  return fitInward(with(electron, electron), geometry, material, chain, n, outward);
+}
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_SPECIESORACLE_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/StageComparison.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/StageComparison.h
new file mode 100644
index 0000000000000..7543a0940702c
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/StageComparison.h
@@ -0,0 +1,242 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file StageComparison.h
+/// \brief Two outputs of one stage compared so that a difference is located,
+///        not only detected.
+///
+/// The outputs are canonical: element e's records
+/// at offset[e] + k. Two runs of the same stage over the same inputs -- the
+/// host and a device, two thread counts -- must agree byte for byte. When
+/// they do not, the comparison says which kind of difference it is, element
+/// by element:
+///
+///   another count   the element emitted a different number of records: a cut
+///                   decided differently, or an input that differs
+///   reordered       the same records in another order: the output's order,
+///                   not its content, differs
+///   records differ  equal counts, other values: counted per column, with the
+///                   largest difference of each arithmetic column's values
+///
+/// Records are compared as their exact bytes, whatever the column types (a
+/// track state has no padding, BoundTrackState.h). compareColumns does the
+/// same row by row for column sets without elements. Each keeps the first few
+/// differences as (element, ordinal, column, both values). Host code.
+
+#ifndef GTRK_STUDY_STAGECOMPARISON_H_
+#define GTRK_STUDY_STAGECOMPARISON_H_
+
+#include "GenericTracking/Tracking/StageOutput.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <type_traits>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+template <template <template <class> class> class S>
+struct StageComparison {
+  static constexpr std::size_t kColumns = static_cast<std::size_t>(S<memlayout::value>::Column::ColumnCount);
+  /// The column of a difference in an element's record count.
+  static constexpr std::size_t kCount = kColumns;
+
+  struct Difference {
+    std::uint32_t element = 0U;
+    std::uint32_t ordinal = 0U; ///< within the element; for kCount, 0
+    std::size_t column = 0U;    ///< memlayout's column order, or kCount
+    double reference = 0.;
+    double other = 0.;
+  };
+
+  bool sameElements = true; ///< the same number of elements; nothing else is compared otherwise
+  std::size_t referenceElements = 0U;
+  std::size_t otherElements = 0U;
+  std::size_t referenceRecords = 0U;
+  std::size_t otherRecords = 0U;
+  std::size_t elementsWithOtherCount = 0U;
+  std::size_t elementsReordered = 0U;
+  std::size_t recordsDiffering = 0U; ///< in elements of equal count, not merely reordered
+  std::array<std::size_t, kColumns> differingByColumn{};
+  std::array<double, kColumns> maxAbsDifference{};
+  std::vector<Difference> first;
+
+  [[nodiscard]] bool identical() const noexcept { return sameElements && elementsWithOtherCount == 0U && elementsReordered == 0U && recordsDiffering == 0U; }
+};
+
+namespace stage_comparison_detail
+{
+
+/// A record's columns laid end to end, as their exact bytes: any column type,
+/// arithmetic or not (a ClusterList of 17 rows is 68 bytes).
+template <template <template <class> class> class S>
+struct RecordLayout {
+  static constexpr std::size_t kColumns = StageComparison<S>::kColumns;
+  static constexpr std::size_t kBytes = S<memlayout::pointer>{}.apply([](auto*... column) { return (sizeof(*column) + ... + std::size_t{0}); });
+  static constexpr std::array<std::size_t, kColumns + 1U> kOffsets = S<memlayout::pointer>{}.apply([](auto*... column) {
+    std::array<std::size_t, kColumns + 1U> offsets{};
+    std::size_t index = 0U;
+    ((offsets[index + 1U] = offsets[index] + sizeof(*column), ++index), ...);
+    return offsets;
+  });
+};
+
+template <template <template <class> class> class S>
+struct Record {
+  using Layout = RecordLayout<S>;
+  std::array<std::byte, Layout::kBytes> bytes{};
+  std::array<double, Layout::kColumns> values{}; ///< arithmetic columns only; 0 for the others
+
+  [[nodiscard]] bool operator==(const Record& other) const { return bytes == other.bytes; }
+  [[nodiscard]] bool sameColumn(const Record& other, std::size_t column) const
+  {
+    const auto begin = Layout::kOffsets[column];
+    return std::memcmp(bytes.data() + begin, other.bytes.data() + begin, Layout::kOffsets[column + 1U] - begin) == 0;
+  }
+};
+
+template <template <template <class> class> class S, typename View>
+[[nodiscard]] Record<S> recordAt(const View& view, std::size_t at)
+{
+  Record<S> record;
+  std::size_t column = 0U;
+  view.apply([&](const auto&... columns) {
+    const auto take = [&](const auto& value) {
+      using Value = std::remove_cvref_t<decltype(value)>;
+      std::byte* const to = record.bytes.data() + RecordLayout<S>::kOffsets[column];
+      std::memcpy(to, &value, sizeof(Value));
+      if constexpr (std::is_arithmetic_v<Value>) {
+        record.values[column] = static_cast<double>(value);
+      }
+      ++column;
+    };
+    (take(columns[at]), ...);
+  });
+  return record;
+}
+
+/// Count how \a right differs from \a left, column by column, into \a
+/// result.
+template <template <template <class> class> class S>
+void noteRecord(const Record<S>& left, const Record<S>& right, std::uint32_t element, std::uint32_t ordinal, std::size_t keep, StageComparison<S>& result)
+{
+  ++result.recordsDiffering;
+  for (std::size_t column = 0; column < StageComparison<S>::kColumns; ++column) {
+    if (left.sameColumn(right, column)) {
+      continue;
+    }
+    ++result.differingByColumn[column];
+    const double difference = std::abs(left.values[column] - right.values[column]);
+    result.maxAbsDifference[column] = std::max(result.maxAbsDifference[column], difference);
+    if (result.first.size() < keep) {
+      result.first.push_back({.element = element, .ordinal = ordinal, .column = column, .reference = left.values[column], .other = right.values[column]});
+    }
+  }
+}
+
+} // namespace stage_comparison_detail
+
+/// Compare two column sets row by row: \a other's \a otherRows rows with
+/// \a reference's \a referenceRows. Each row is an element of one record, so
+/// a difference is (row, 0, column, both values); rows of another number are
+/// not compared. The views are any memlayout column views of `S`.
+template <template <template <class> class> class S, typename View>
+[[nodiscard]] StageComparison<S> compareColumns(const View& reference, std::size_t referenceRows, const View& other, std::size_t otherRows, std::size_t keep = 8U)
+{
+  StageComparison<S> result;
+  result.referenceElements = referenceRows;
+  result.otherElements = otherRows;
+  result.referenceRecords = referenceRows;
+  result.otherRecords = otherRows;
+  if (referenceRows != otherRows) {
+    result.sameElements = false;
+    return result;
+  }
+  for (std::size_t row = 0; row < referenceRows; ++row) {
+    const auto left = stage_comparison_detail::recordAt<S>(reference, row);
+    const auto right = stage_comparison_detail::recordAt<S>(other, row);
+    if (!(left == right)) {
+      stage_comparison_detail::noteRecord(left, right, static_cast<std::uint32_t>(row), 0U, keep, result);
+    }
+  }
+  return result;
+}
+
+/// Compare \a other with \a reference, element by element, keeping the first
+/// \a keep differences.
+template <template <template <class> class> class S>
+[[nodiscard]] StageComparison<S> compareStageOutputs(const StageOutput<S>& reference, const StageOutput<S>& other, std::size_t keep = 8U)
+{
+  using Comparison = StageComparison<S>;
+  using Record = stage_comparison_detail::Record<S>;
+  Comparison result;
+  result.referenceElements = reference.elementCount();
+  result.otherElements = other.elementCount();
+  result.referenceRecords = reference.size();
+  result.otherRecords = other.size();
+  if (reference.elementCount() != other.elementCount()) {
+    result.sameElements = false;
+    return result;
+  }
+  const auto referenceOffsets = reference.offsets();
+  const auto otherOffsets = other.offsets();
+  const auto referenceView = reference.view();
+  const auto otherView = other.view();
+  std::vector<Record> left;
+  std::vector<Record> right;
+  for (std::uint32_t element = 0; element < reference.elementCount(); ++element) {
+    const auto referenceBegin = referenceOffsets[element];
+    const auto otherBegin = otherOffsets[element];
+    const auto count = referenceOffsets[element + 1U] - referenceBegin;
+    const auto otherCount = otherOffsets[element + 1U] - otherBegin;
+    if (count != otherCount) {
+      ++result.elementsWithOtherCount;
+      if (result.first.size() < keep) {
+        result.first.push_back({.element = element, .ordinal = 0U, .column = Comparison::kCount, .reference = static_cast<double>(count), .other = static_cast<double>(otherCount)});
+      }
+      continue;
+    }
+    left.clear();
+    right.clear();
+    bool equal = true;
+    for (std::uint32_t ordinal = 0; ordinal < count; ++ordinal) {
+      left.push_back(stage_comparison_detail::recordAt<S>(referenceView, referenceBegin + ordinal));
+      right.push_back(stage_comparison_detail::recordAt<S>(otherView, otherBegin + ordinal));
+      equal = equal && left.back() == right.back();
+    }
+    if (equal) {
+      continue;
+    }
+    auto sortedLeft = left;
+    auto sortedRight = right;
+    std::ranges::sort(sortedLeft, {}, &Record::bytes);
+    std::ranges::sort(sortedRight, {}, &Record::bytes);
+    if (sortedLeft == sortedRight) {
+      ++result.elementsReordered;
+      continue;
+    }
+    for (std::uint32_t ordinal = 0; ordinal < count; ++ordinal) {
+      if (!(left[ordinal] == right[ordinal])) {
+        stage_comparison_detail::noteRecord(left[ordinal], right[ordinal], element, ordinal, keep, result);
+      }
+    }
+  }
+  return result;
+}
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_STAGECOMPARISON_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/StageFunnel.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/StageFunnel.h
new file mode 100644
index 0000000000000..65691ace7858b
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/StageFunnel.h
@@ -0,0 +1,1439 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file StageFunnel.h
+/// \brief Where the findable particles are lost, stage by stage, in the
+///        tracker's own run.
+///
+/// A particle above the pT floor with measurements on a chain of `minLayers`
+/// layers is findable (TrackComparison.h). The funnel observes every
+/// slice of every iteration and records, per findable particle, the longest
+/// chain in clusters that is entirely its own -- every measurement carries it
+/// among its labels -- at each stage: kept tracklets joined end to end, kept
+/// triplets joined by a shared tracklet, kept triplets joined by kept
+/// neighbours, the roads the walk gives, and the roads that passed the fit
+/// and the pT floor (the selection's records). The longest of any iteration
+/// counts. A particle without a good track is lost at the first stage whose
+/// chain is shorter than `minLayers`; with a record of its own, at the
+/// selection.
+///
+/// For the tracklets, the reason: each adjacent-layer pair of the particle's
+/// own measurements that no iteration kept is tested again with the
+/// iteration's parameters, in the order the stage tests -- the link not taken,
+/// a measurement held by an earlier iteration's track, the source interval,
+/// time, the turning point, the curvature (the pair's circle through the beam
+/// line below the iteration's pT_min), the longitudinal test -- and what passes
+/// them all was lost elsewhere: the grid's window, or the slicing. An
+/// iteration from the vertex list records no reasons.
+///
+/// A particle is seeded in an iteration if one of that iteration's roads,
+/// before the road fit, is entirely its own.
+///
+/// Beyond the stages, for the bench: the length funnel (`lengthReport`, the
+/// found against their ceiling) and every record's chi2 (`recordChi2`, for
+/// `--fakes-out`), whose inputs are kept only when asked (`keepReportInputs`).
+
+#ifndef GTRK_STUDY_STAGEFUNNEL_H_
+#define GTRK_STUDY_STAGEFUNNEL_H_
+
+#include "GenericTracking/Base/LayerLinks.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/LinkHoles.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/Parallel.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/TrackletStage.h"
+#include "GenericTracking/Study/Statistics.h"
+#include "GenericTracking/Study/TrackComparison.h"
+#include "GenericTracking/Study/MCTruth.h"
+#include "GenericTracking/Study/Validation.h"
+
+#include "DetectorsBase/MatLayerCylSet.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <format>
+#include <limits>
+#include <map>
+#include <numbers>
+#include <optional>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+/// The stages of the funnel, in order; kFound last.
+enum class FunnelStage : std::uint8_t { kTracklets,
+                                        kTriplets,
+                                        kNeighbours,
+                                        kRoads,
+                                        kFit,
+                                        kSelection,
+                                        kFound,
+                                        kCount };
+inline constexpr std::size_t kFunnelStages = static_cast<std::size_t>(FunnelStage::kCount);
+inline constexpr std::array<const char*, kFunnelStages> kFunnelStageNames{"tracklets", "triplets", "neighbours", "roads", "road fit", "selection", "found"};
+
+/// Why an adjacent-layer pair of a particle was not kept, in the order the
+/// tracklet stage tests.
+/// The curvature test is split by the particle's pT: below the iteration's
+/// pT_min the loss is the iteration's choice; above it, the pair's circle
+/// through the beam line is not the particle's.
+enum class PairLoss : std::uint8_t { kLinkNotTaken,
+                                     kUsed,
+                                     kSourceInterval,
+                                     kTime,
+                                     kTurning,
+                                     kCurvatureBelowPtMin,
+                                     kCurvature,
+                                     kLongitudinal,
+                                     kWindow,
+                                     kHole,
+                                     kElsewhere,
+                                     kCount };
+inline constexpr std::size_t kPairLosses = static_cast<std::size_t>(PairLoss::kCount);
+inline constexpr std::array<const char*, kPairLosses> kPairLossNames{"link not taken", "used", "source interval", "time", "turning point", "curvature below pT_min", "curvature above pT_min", "longitudinal", "outside the query's cells", "crosses another layer", "window or slicing"};
+
+/// The losses the pair cut itself gives (pairCutLoss), in its order.
+inline constexpr std::array<PairLoss, 8> kPairCutLosses{PairLoss::kSourceInterval, PairLoss::kTime, PairLoss::kTurning, PairLoss::kCurvature, PairLoss::kLongitudinal, PairLoss::kWindow, PairLoss::kHole, PairLoss::kElsewhere};
+
+/// The pair cut on a pair of rows on \a link from \a vertex: the first test the
+/// tracklet stage applies that it fails -- the source interval, time, the
+/// turning point, the curvature, the longitudinal test -- or kElsewhere if it
+/// passes them all; and the spatial terms as far as they were evaluated. In a
+/// displaced iteration the curvature is the displaced test's transverse part
+/// (its own turning point included) and the longitudinal its z; no terms.
+/// Includes the query's cells and direct-pair rule; the stage's used,
+/// shape and bound tests are not replayed.
+struct PairCutVerdict {
+  PairLoss loss = PairLoss::kElsewhere;
+  PairTerms terms{};
+  bool emptyDirectRange = false; ///< no direct part of the query, rather than a pair crossing a hole
+};
+
+template <DetectorLayout Det>
+[[nodiscard]] PairCutVerdict pairCutLoss(const TimeFrame<Det>& frame, const IterationParameters<Det>& parameters, const VertexSeed& vertex, std::size_t link, std::uint32_t sourceRow, std::uint32_t targetRow)
+{
+  PairCutVerdict verdict;
+  const auto sourceMeasurement = frame.measurement(sourceRow);
+  const auto targetMeasurement = frame.measurement(targetRow);
+  const auto source = pairPoint(sourceMeasurement);
+  const auto target = pairPoint(targetMeasurement);
+  const auto from = Det::layerLinks[link].from;
+  const Scalar second = secondCoordinate<Det>(from, source.r, source.z);
+  if (second < parameters.sourceMin[link] || second > parameters.sourceMax[link]) {
+    verdict.loss = PairLoss::kSourceInterval;
+    return verdict;
+  }
+  if (!timeBox(sourceMeasurement).isCompatible(timeBox(targetMeasurement))) {
+    verdict.loss = PairLoss::kTime;
+    return verdict;
+  }
+  const auto to = Det::layerLinks[link].to;
+  // Only this target's membership matters: its width gives the same spatial
+  // cells and suffices for the temporal extent of a compatible pair.
+  auto window = candidateWindow(parameters.windows[link], timeBox(sourceMeasurement), sourceMeasurement.phi, source.r, source.z, timeBox(targetMeasurement).width);
+  const auto holes = parameters.holeLayers[link];
+  if (holes != 0U) {
+    const auto& span = parameters.layerSpans[to];
+    const auto direct = directPairRange(holes, parameters.barrelLayers, parameters.layerSpans, to, source.r, source.z, span.low, span.high);
+    const Scalar low = std::max(direct.low, window.secondCentre - window.secondHalfWidth);
+    const Scalar high = std::min(direct.high, window.secondCentre + window.secondHalfWidth);
+    if (!(low <= high)) {
+      verdict.loss = PairLoss::kHole;
+      verdict.emptyDirectRange = true;
+      return verdict;
+    }
+    window.secondCentre = 0.5F * (low + high);
+    window.secondHalfWidth = 0.5F * (high - low);
+  }
+  const auto& grid = frame.grid();
+  const auto cells = grid.cellSpan(to, window, grid.geometry().allBlocks());
+  const Scalar phi = targetMeasurement.phi < 0.F ? targetMeasurement.phi + (2 * std::numbers::pi_v<Scalar>) : targetMeasurement.phi;
+  const auto phiBin = grid.geometry().phiBinOf(to, phi);
+  const auto secondBin = grid.geometry().secondBinOf(to, secondCoordinate<Det>(to, target.r, target.z));
+  const bool inPhi = (phiBin >= cells.firstPhi && phiBin < cells.phiEnd) || phiBin < cells.wrapEnd;
+  const bool inSecond = secondBin >= cells.firstSecond && secondBin <= cells.lastSecond;
+  if (cells.blocks.empty() || !inPhi || !inSecond) {
+    verdict.loss = PairLoss::kWindow;
+    return verdict;
+  }
+  const auto directPair = [&] {
+    if (verdict.loss == PairLoss::kElsewhere && holes != 0U && segmentLeavesHole(holes, parameters.barrelLayers, parameters.layerSpans, source.r, source.z, target.r, target.z)) {
+      verdict.loss = PairLoss::kHole;
+    }
+    return verdict;
+  };
+  const Scalar scatter = sourceScattering<Det>(parameters.scattering, parameters.pairCut, vertex, from, source);
+  const Scalar between = parameters.passiveBetween[link] ? betweenScattering<Det>(parameters.scattering, parameters.pairCut, vertex, source, target, parameters.betweenPassives[link]) : 0.F;
+  if (parameters.impactMax > 0.F) {
+    // A displaced iteration's test (TrackletStage.h, `displacedPairOf`): its
+    // transverse part as the curvature, its z as the longitudinal test.
+    const auto result = displacedPairOf(parameters, vertex, source, scatter, target, between);
+    if (!result.transverse) {
+      verdict.loss = PairLoss::kCurvature;
+    } else if (!result.longitudinal) {
+      verdict.loss = PairLoss::kLongitudinal;
+    }
+    return directPair();
+  }
+  verdict.terms = transversePairTerms(parameters.pairCut, vertex, source, scatter, target, between);
+  if (!verdict.terms.beforeTurn) {
+    verdict.loss = PairLoss::kTurning;
+  } else if (!transverseCompatible(parameters.pairCut, verdict.terms)) {
+    verdict.loss = PairLoss::kCurvature;
+  } else {
+    addLongitudinalPairTerms(verdict.terms, parameters.pairCut, vertex, source, scatter, target, between);
+    if (!longitudinalCompatible(parameters.pairCut, verdict.terms)) {
+      verdict.loss = PairLoss::kLongitudinal;
+    }
+  }
+  return directPair();
+}
+
+/// Why a particle with a chain of kept triplets and neighbours of its own got
+/// no road of its own: its outermost triplet below the iteration's start
+/// level, raised above its own chain's level by a predecessor not its own (the
+/// walk descends one level at a time) -- inside its chain, the walk leaving
+/// it for the other's; below it, no triplet of its own before its innermost,
+/// so the walk descends through the whole chain and on into the other's; or
+/// with a triplet of its own before it but no neighbour to it (the neighbour
+/// cut, or ordered generation linking only the highest level that has one) --
+/// continued outward by a successor not its own (so not a start), or ending
+/// off the iteration's end layers.
+enum class RoadLoss : std::uint8_t { kNoChain,
+                                     kStartLevel,
+                                     kRaised,
+                                     kRaisedBelow,
+                                     kRaisedUnlinked,
+                                     kContinued,
+                                     kEndLayer,
+                                     kOther,
+                                     kCount };
+inline constexpr std::size_t kRoadLosses = static_cast<std::size_t>(RoadLoss::kCount);
+inline constexpr std::array<const char*, kRoadLosses> kRoadLossNames{"no chain this iteration", "below the start level", "raised inside its chain", "raised below its chain", "raised, own predecessor not linked", "continued by another's successor", "off the end layers", "other"};
+
+/// Why a particle's longest road of its own was no record: its boxes share
+/// no time, the fit's chi2, its propagation, the iteration's pT floor for the
+/// road's length, the beam line; other if the road fit stage's tests take it
+/// (`roadFitRefusal`).
+enum class FitLoss : std::uint8_t { kNoRoad,
+                                    kChi2,
+                                    kPropagation,
+                                    kPtFloor,
+                                    kBeamLine,
+                                    kOther,
+                                    kTime,
+                                    kCount };
+inline constexpr std::size_t kFitLosses = static_cast<std::size_t>(FitLoss::kCount);
+inline constexpr std::array<const char*, kFitLosses> kFitLossNames{"no road this iteration", "chi2", "propagation", "pT floor by length", "beam line", "other", "time"};
+
+/// What a missed particle's fake -- a track it labels, with a measurement not
+/// its own -- got wrong: one measurement, the innermost; one elsewhere; more.
+enum class FakeKind : std::uint8_t { kNone,
+                                     kInnermost,
+                                     kOtherOne,
+                                     kMore,
+                                     kCount };
+inline constexpr std::size_t kFakeKinds = static_cast<std::size_t>(FakeKind::kCount);
+inline constexpr std::array<const char*, kFakeKinds> kFakeKindNames{"no fake of its own", "one wrong, the innermost", "one wrong elsewhere", "more wrong"};
+
+/// The first stage a particle's chains fall short of \a minimum at, from the
+/// longest chain of each stage; kSelection if all reach it, kFound if found.
+[[nodiscard]] inline FunnelStage firstLoss(const std::array<std::uint32_t, 5>& longest, std::uint32_t minimum, bool found)
+{
+  if (found) {
+    return FunnelStage::kFound;
+  }
+  for (std::size_t stage = 0; stage < longest.size(); ++stage) {
+    if (longest[stage] < minimum) {
+      return static_cast<FunnelStage>(stage);
+    }
+  }
+  return FunnelStage::kSelection;
+}
+
+/// The longest chain in nodes ending at each node of \a edges that one ends
+/// at, each edge from a node to one on a later layer; \a layerOf orders them.
+template <typename LayerOf>
+[[nodiscard]] std::unordered_map<std::uint32_t, std::uint32_t> chainLengths(std::vector<std::pair<std::uint32_t, std::uint32_t>> edges, LayerOf layerOf)
+{
+  std::ranges::sort(edges, {}, [&](const auto& edge) { return layerOf(edge.first); });
+  std::unordered_map<std::uint32_t, std::uint32_t> length;
+  for (const auto& [from, to] : edges) {
+    const auto before = length.find(from);
+    const std::uint32_t reached = (before == length.end() ? 1U : before->second) + 1U;
+    auto& at = length[to];
+    at = std::max(at, reached);
+  }
+  return length;
+}
+
+/// The longest chain in nodes of \a edges; 0 without any.
+template <typename LayerOf>
+[[nodiscard]] std::uint32_t longestChain(std::vector<std::pair<std::uint32_t, std::uint32_t>> edges, LayerOf layerOf)
+{
+  std::uint32_t result = 0U;
+  for (const auto& [node, length] : chainLengths(std::move(edges), layerOf)) {
+    result = std::max(result, length);
+  }
+  return result;
+}
+
+/// A pair of rows as one key, the source's in the upper half.
+[[nodiscard]] inline std::uint64_t pairKey(std::uint32_t source, std::uint32_t target) { return (static_cast<std::uint64_t>(source) << 32U) | static_cast<std::uint64_t>(target); }
+
+template <DetectorLayout Det, typename Controller>
+class StageFunnel
+{
+ public:
+  using Frame = TimeFrame<Det>;
+  using SliceObservation = typename Controller::SliceObservation;
+  using IterationObservation = typename Controller::IterationObservation;
+
+  /// \a minPtGeV: each iteration's pT_min. Throws std::invalid_argument for
+  /// more iterations than a seeded mask holds.
+  StageFunnel(const Frame& frame, std::span<const TruthRow> rows, const ParticleTable& truth, const ComparisonSettings& settings, const VertexSeed& beamLine, std::vector<double> minPtGeV)
+    : mRows{rows},
+      mSettings{settings},
+      mBeamLine{beamLine},
+      mFrame{&frame},
+      mMinPtGeV{std::move(minPtGeV)}
+  {
+    if (mMinPtGeV.size() > static_cast<std::size_t>(std::numeric_limits<std::uint64_t>::digits)) {
+      throw std::invalid_argument(std::format("stage funnel: {} iterations, a seeded mask holds {}", mMinPtGeV.size(), std::numeric_limits<std::uint64_t>::digits));
+    }
+    for (const auto& [id, bits] : particleLayers(rows, settings)) {
+      const auto found = truth.find(id);
+      if (found == truth.end() || !isFindable(found->second.pt, bits, settings)) {
+        continue;
+      }
+      mIndex[id] = static_cast<std::uint32_t>(mParticles.size());
+      mParticles.push_back({
+        .id = id,
+        .pt = found->second.pt,
+        .species = std::abs(found->second.pdg),
+        .group = groupOf(found->second),
+        .bin = productionBin(found->second, settings),
+        .rows = {},
+        .longestBy = {},
+        .reasons = {},
+        .roadLosses = {},
+        .fitLosses = {},
+        .recordChi2 = {},
+        .pairsKept = 0U,
+        .lostPairs = {},
+        .fitRoadLayers = {},
+        .raisedFits = {},
+      });
+    }
+    // Each row's findable particles, and each particle's rows.
+    mRowOffsets.assign(rows.size() + 1U, 0U);
+    for (std::size_t row = 0; row < rows.size(); ++row) {
+      mRowOffsets[row + 1U] = mRowOffsets[row];
+      for (std::uint8_t i = 0; i < rows[row].count; ++i) {
+        const auto found = mIndex.find(rows[row].particles[i]);
+        if (found != mIndex.end()) {
+          mRowParticles.push_back(found->second);
+          mParticles[found->second].rows.push_back(static_cast<std::uint32_t>(row));
+          ++mRowOffsets[row + 1U];
+        }
+      }
+    }
+  }
+
+  void observeSlice(const Controller& tracker, const SliceObservation& slice)
+  {
+    beginIteration();
+    const auto& parameters = tracker.iteration(slice.iteration);
+    const auto& result = *slice.result;
+    const auto tracklets = result.tracklets->view();
+    const auto triplets = result.triplets->view();
+    for (std::size_t i = 0; i < result.tracklets->size(); ++i) {
+      const std::array<std::uint32_t, 2> ends{tracklets.source[i], tracklets.target[i]};
+      const bool owned = forEachOwner(ends, [&](std::uint32_t particle) { mPairs[particle].emplace_back(ends[0], ends[1]); });
+      if (owned) {
+        mKept.insert(pairKey(ends[0], ends[1]));
+      }
+    }
+    for (std::size_t i = 0; i < result.triplets->size(); ++i) {
+      const auto first = triplets.first[i];
+      const std::array<std::uint32_t, 3> rows{tracklets.source[first], tracklets.target[first], tracklets.target[triplets.second[i]]};
+      // The road counts of the slice that owns it: its first measurement in the core.
+      const auto core = slice.slice->core[parameters.linkSources[tracklets.link[first]]];
+      const bool owned = rows[0] >= core.begin && rows[0] < core.end;
+      forEachOwner(rows, [&](std::uint32_t particle) {
+        mTriplets[particle].emplace_back(pairKey(rows[0], rows[1]), pairKey(rows[1], rows[2]));
+        if (owned) {
+          mTripletInfo[particle][{pairKey(rows[0], rows[1]), rows[2]}] = {
+            .level = triplets.level[i],
+            .successorAbove = slice.roads->successorAbove()[i] != 0U,
+            .endLayer = parameters.linkTargets[tracklets.link[triplets.second[i]]],
+          };
+        }
+      });
+    }
+    const auto from = result.neighbours->view().from;
+    const auto offsets = result.neighbours->offsets();
+    for (std::size_t to = 0; to + 1U < offsets.size(); ++to) {
+      const auto shared = triplets.first[to];
+      const auto b = tracklets.source[shared];
+      const auto c = tracklets.target[shared];
+      const auto d = tracklets.target[triplets.second[to]];
+      for (auto edge = offsets[to]; edge < offsets[to + 1U]; ++edge) {
+        const std::array<std::uint32_t, 4> rows{tracklets.source[triplets.first[from[edge]]], b, c, d};
+        forEachOwner(rows, [&](std::uint32_t particle) { mNeighbours[particle].push_back(rows); });
+      }
+    }
+    constexpr std::size_t kMax = maxChainLayers<Det>;
+    const auto walk = slice.roads->walk(*result.triplets, *result.neighbours);
+    for (std::uint32_t road = 0; road < slice.roads->roadCount(); ++road) {
+      std::array<std::uint32_t, kMax - 2U> chain{};
+      const auto length = walk(road, chain.data());
+      std::array<std::uint32_t, kMax> rows{};
+      rows[0] = tracklets.source[triplets.first[chain[0]]];
+      rows[1] = tracklets.target[triplets.first[chain[0]]];
+      for (std::uint32_t i = 0; i < length; ++i) {
+        rows[i + 2U] = tracklets.target[triplets.second[chain[i]]];
+      }
+      const auto count = length + 2U;
+      forEachOwner(std::span<const std::uint32_t>{rows.data(), count}, [&](std::uint32_t particle) {
+        raise(particle, slice.iteration, FunnelStage::kRoads, count);
+        mParticles[particle].seededBy |= std::uint64_t{1} << slice.iteration;
+        auto& own = mOwnRoad[particle];
+        if (count > own.size()) {
+          own.assign(rows.begin(), rows.begin() + count);
+        }
+      });
+    }
+    const auto records = slice.records->view();
+    for (std::size_t record = 0; record < slice.records->size(); ++record) {
+      const auto count = static_cast<std::uint32_t>(records.count[record]);
+      const std::span<const std::uint32_t> rows{records.clusters[record].index, count};
+      const auto chi2 = static_cast<float>(records.chi2[record]);
+      if (mKeepRecordChi2s) {
+        const auto [kept, inserted] = mRecordChi2.try_emplace(recordKey(slice.iteration, rows), chi2);
+        if (!inserted) {
+          kept->second = std::min(kept->second, chi2);
+        }
+      }
+      forEachOwner(rows, [&](std::uint32_t particle) {
+        auto& p = mParticles[particle];
+        const auto before = slice.iteration < p.longestBy.size() ? p.longestBy[slice.iteration][static_cast<std::size_t>(FunnelStage::kFit)] : 0U;
+        raise(particle, slice.iteration, FunnelStage::kFit, count);
+        p.recordChi2.resize(std::max(p.recordChi2.size(), slice.iteration + 1U), -1.F);
+        auto& best = p.recordChi2[slice.iteration];
+        if (count > before || best < 0.F) {
+          best = chi2;
+        } else if (count == before) {
+          best = std::min(best, chi2);
+        }
+        auto& own = mOwnRecord[particle];
+        own = std::max(own, count);
+      });
+    }
+  }
+
+  /// The end of an iteration: its chains, the reasons for its lost pairs, and
+  /// the used mask the next one reads.
+  void observeIteration(const Controller& tracker, const IterationObservation& iteration)
+  {
+    beginIteration();
+    const auto layerOf = [&](std::uint32_t row) { return mRows[row].layer; };
+    if (mKeepOwnKept) {
+      for (const auto& [particle, edges] : mPairs) {
+        auto& kept = mOwnKept[particle];
+        for (const auto& [a, b] : edges) {
+          kept.insert(pairKey(a, b));
+        }
+      }
+    }
+    for (auto& [particle, edges] : mPairs) {
+      raise(particle, iteration.iteration, FunnelStage::kTracklets, longestChain(std::move(edges), layerOf));
+    }
+    for (auto& [particle, edges] : mTriplets) {
+      // A triplet is an edge between its two tracklets; one more measurement each.
+      std::vector<std::pair<std::uint32_t, std::uint32_t>> compact;
+      std::unordered_map<std::uint64_t, std::uint32_t> ids;
+      std::vector<LayerID> layers;
+      const auto id = [&](std::uint64_t key) {
+        const auto [at, inserted] = ids.try_emplace(key, static_cast<std::uint32_t>(ids.size()));
+        if (inserted) {
+          layers.push_back(mRows[static_cast<std::uint32_t>(key >> 32U)].layer);
+        }
+        return at->second;
+      };
+      for (const auto& [first, second] : edges) {
+        compact.emplace_back(id(first), id(second));
+      }
+      raise(particle, iteration.iteration, FunnelStage::kTriplets, longestChain(std::move(compact), [&](std::uint32_t node) { return layers[node]; }) + 1U);
+    }
+    for (auto& [particle, chains] : mNeighbours) {
+      std::vector<std::pair<std::uint32_t, std::uint32_t>> compact;
+      std::map<std::pair<std::uint64_t, std::uint32_t>, std::uint32_t> ids;
+      std::vector<LayerID> layers;
+      const auto id = [&](std::uint32_t a, std::uint32_t b, std::uint32_t c) {
+        const auto [at, inserted] = ids.try_emplace({pairKey(a, b), c}, static_cast<std::uint32_t>(ids.size()));
+        if (inserted) {
+          layers.push_back(mRows[a].layer);
+        }
+        return at->second;
+      };
+      for (const auto& rows : chains) {
+        compact.emplace_back(id(rows[0], rows[1], rows[2]), id(rows[1], rows[2], rows[3]));
+      }
+      // The chain's outermost triplet: the longest chain's end.
+      std::uint32_t longest = 0U;
+      std::uint32_t end = 0U;
+      for (const auto& [node, length] : chainLengths(std::move(compact), [&](std::uint32_t node) { return layers[node]; })) {
+        if (length > longest) {
+          longest = length;
+          end = node;
+        }
+      }
+      raise(particle, iteration.iteration, FunnelStage::kNeighbours, longest + 2U);
+      if (longest + 2U >= static_cast<std::uint32_t>(mSettings.minLayers)) {
+        const auto key = std::ranges::find_if(ids, [&](const auto& entry) { return entry.second == end; })->first;
+        roadLoss(particle, iteration.iteration, tracker.iteration(iteration.iteration), longest, key, chains);
+      }
+    }
+    lostPairReasons(tracker.iteration(iteration.iteration), iteration.iteration);
+    fitLosses(tracker.iteration(iteration.iteration), iteration.iteration);
+    raisedFitLosses(tracker.iteration(iteration.iteration), iteration.iteration);
+    mIterations = std::max(mIterations, iteration.iteration + 1U);
+    mUsed.assign(iteration.used.begin(), iteration.used.end());
+    mPairs.clear();
+    mTriplets.clear();
+    mTripletInfo.clear();
+    mRaisedChain.clear();
+    mNeighbours.clear();
+    mKept.clear();
+    mOwnRoad.clear();
+    mOwnRecord.clear();
+  }
+
+  /// What only the bench's reports read, kept from here on (none by
+  /// default): each particle's own kept pairs, for `lengthReport`, and with
+  /// \a recordChi2s every record's chi2, for `recordChi2`.
+  void keepReportInputs(bool recordChi2s)
+  {
+    mKeepOwnKept = true;
+    mKeepRecordChi2s = recordChi2s;
+  }
+
+  /// The road fit to refit the roads that were no record with: the run's.
+  void setRoadFit(const TrackingGeometry<Det>& tracking, const o2::base::MatLayerCylSet& material, const Propagator& propagator)
+  {
+    mTracking = &tracking;
+    mMaterial = &material;
+    mPropagator = propagator;
+  }
+
+  /// What one iteration did with a findable particle: its longest chain of its
+  /// own at each stage (FunnelStage, tracklets to the road fit), its
+  /// adjacent-layer pairs the iteration did not keep by the first test each
+  /// fails, if its chain of neighbours reached the minimum without a road,
+  /// why, and if its road was no record, why.
+  struct IterationStages {
+    std::array<std::uint32_t, 5> longest{};
+    std::array<std::uint32_t, kPairLosses> lostPairs{};
+    RoadLoss roadLoss = RoadLoss::kNoChain;
+    FitLoss fitLoss = FitLoss::kNoRoad;
+    float recordChi2 = -1.F; ///< the best chi2 of its longest records; -1 without one
+  };
+
+  /// Particle \a id's in \a iteration; none for a particle not findable.
+  [[nodiscard]] std::optional<IterationStages> stages(std::uint64_t id, std::size_t iteration) const
+  {
+    const auto found = mIndex.find(id);
+    if (found == mIndex.end()) {
+      return std::nullopt;
+    }
+    const auto& particle = mParticles[found->second];
+    IterationStages result;
+    if (iteration < particle.longestBy.size()) {
+      result.longest = particle.longestBy[iteration];
+    }
+    if (iteration < particle.reasons.size()) {
+      result.lostPairs = particle.reasons[iteration];
+    }
+    if (iteration < particle.roadLosses.size()) {
+      result.roadLoss = particle.roadLosses[iteration];
+    }
+    if (iteration < particle.fitLosses.size()) {
+      result.fitLoss = particle.fitLosses[iteration];
+    }
+    if (iteration < particle.recordChi2.size()) {
+      result.recordChi2 = particle.recordChi2[iteration];
+    }
+    return result;
+  }
+
+  /// Particle \a id's verdict over the whole run: the first stage without a chain of its own as long as the minimum,
+  /// as if not found; of its adjacent-layer pairs no iteration kept, the test
+  /// most fail first over the iterations whose pT_min it clears; why its chain
+  /// of neighbours gave no road, and why its longest road of its own was no
+  /// record, with that road's layers -- each in the last iteration that saw
+  /// one, and every reason any iteration gave, a bit per RoadLoss and FitLoss;
+  /// for a chain raised from below, the fit of its own part.
+  /// None where nothing was lost; none at all for a particle not findable.
+  struct ParticleVerdict {
+    FunnelStage lostAt = FunnelStage::kSelection;
+    std::optional<PairLoss> pairLoss;
+    std::optional<RoadLoss> roadLoss;
+    std::optional<FitLoss> fitLoss;
+    std::uint64_t fitRoadLayers = 0U; ///< the refused road's layers, a bit each; 0 without a fit loss
+    std::uint8_t roadLosses = 0U;     ///< a bit per RoadLoss of any iteration, kNoChain's never
+    std::uint8_t fitLosses = 0U;      ///< a bit per FitLoss of any iteration, kNoRoad's never
+    std::optional<FitLoss> raisedFit; ///< the fit of a raised chain's own part, kOther if it takes it (`raisedFitLosses`)
+  };
+  [[nodiscard]] std::optional<ParticleVerdict> particleVerdict(std::uint64_t id) const
+  {
+    const auto found = mIndex.find(id);
+    if (found == mIndex.end()) {
+      return std::nullopt;
+    }
+    const auto& particle = mParticles[found->second];
+    std::array<std::uint32_t, kPairLosses> lost{};
+    for (const auto& pair : particle.lostPairs) {
+      if (((particle.pairsKept >> pair.from) & 1U) != 0U || (pair.iteration < mMinPtGeV.size() && static_cast<double>(particle.pt) < mMinPtGeV[pair.iteration])) {
+        continue;
+      }
+      ++lost[static_cast<std::size_t>(pair.loss)];
+    }
+    ParticleVerdict result{
+      .lostAt = firstLoss(particle.longest, static_cast<std::uint32_t>(mSettings.minLayers), false),
+      .pairLoss = std::nullopt,
+      .roadLoss = std::nullopt,
+      .fitLoss = std::nullopt,
+      .fitRoadLayers = 0U,
+      .roadLosses = 0U,
+      .fitLosses = 0U,
+      .raisedFit = std::nullopt,
+    };
+    if (const auto* const most = std::ranges::max_element(lost); *most > 0U) {
+      result.pairLoss = static_cast<PairLoss>(most - lost.begin());
+    }
+    for (const auto loss : particle.roadLosses) {
+      if (loss != RoadLoss::kNoChain) {
+        result.roadLoss = loss;
+        result.roadLosses |= static_cast<std::uint8_t>(1U << static_cast<unsigned>(loss));
+      }
+    }
+    for (std::size_t iteration = 0; iteration < particle.fitLosses.size(); ++iteration) {
+      if (const auto loss = particle.fitLosses[iteration]; loss != FitLoss::kNoRoad) {
+        result.fitLoss = loss;
+        result.fitRoadLayers = particle.fitRoadLayers[iteration];
+        result.fitLosses |= static_cast<std::uint8_t>(1U << static_cast<unsigned>(loss));
+      }
+    }
+    for (const auto loss : particle.raisedFits) {
+      if (loss != FitLoss::kNoRoad) {
+        result.raisedFit = loss;
+      }
+    }
+    return result;
+  }
+
+  /// The chi2 of \a iteration's record on exactly \a rows, in any order
+  /// (the best of its duplicates); none if no slice gave one, or without
+  /// `keepReportInputs(true)` (for the road fakes).
+  [[nodiscard]] std::optional<float> recordChi2(std::size_t iteration, std::span<const std::uint32_t> rows) const
+  {
+    const auto found = mRecordChi2.find(recordKey(iteration, rows));
+    if (found == mRecordChi2.end()) {
+      return std::nullopt;
+    }
+    return found->second;
+  }
+
+  /// Each findable particle's iterations with a road of its own, a bit each,
+  /// by particle id.
+  [[nodiscard]] std::unordered_map<std::uint64_t, std::uint64_t> seededBy() const
+  {
+    std::unordered_map<std::uint64_t, std::uint64_t> result;
+    for (const auto& particle : mParticles) {
+      result[particle.id] = particle.seededBy;
+    }
+    return result;
+  }
+
+  /// The report, against the run's \a tracks.
+  [[nodiscard]] std::vector<std::string> report(const TrackRows& tracks) const
+  {
+    std::vector<bool> found(mParticles.size(), false);
+    std::vector<FakeKind> fakes(mParticles.size(), FakeKind::kNone);
+    for (const auto& track : tracks) {
+      const auto particle = goodParticle(mRows, track);
+      const auto at = mIndex.find(particle);
+      if (at != mIndex.end()) {
+        found[at->second] = true;
+        continue;
+      }
+      // A fake: its label is the findable particle most of its measurements carry.
+      std::uint32_t label = 0U;
+      std::size_t most = 0U;
+      for (const auto row : track) {
+        for (auto candidate = mRowOffsets[row]; candidate < mRowOffsets[row + 1U]; ++candidate) {
+          const auto id = mParticles[mRowParticles[candidate]].id;
+          const auto count = static_cast<std::size_t>(std::ranges::count_if(track, [&](std::uint32_t other) { return mRows[other].carries(id); }));
+          if (count > most) {
+            most = count;
+            label = mRowParticles[candidate];
+          }
+        }
+      }
+      if (most == 0U || most == track.size()) {
+        continue;
+      }
+      const auto id = mParticles[label].id;
+      const auto innermost = *std::ranges::min_element(track, {}, [&](std::uint32_t row) { return mRows[row].layer; });
+      auto kind = FakeKind::kMore;
+      if (most + 1U == track.size()) {
+        kind = mRows[innermost].carries(id) ? FakeKind::kOtherOne : FakeKind::kInnermost;
+      }
+      auto& fake = fakes[label];
+      fake = fake == FakeKind::kNone ? kind : std::min(fake, kind);
+    }
+    const auto bins = mSettings.productionEdges.size() + 1U;
+    struct Row {
+      std::uint64_t findable = 0U;
+      std::array<std::uint64_t, kFunnelStages> byStage{};
+      std::vector<std::array<std::uint64_t, kPairLosses>> reasons;
+      std::vector<std::array<std::uint64_t, kRoadLosses>> roadLosses;
+      std::vector<std::array<std::uint64_t, kFitLosses>> fitLosses;
+      std::array<std::uint64_t, kFakeKinds> fakes{}; ///< of the missed
+      /// Lost at the road fit, by species: all of them, and by the chi2 in the
+      /// last iteration that gave them a road.
+      std::map<std::int32_t, std::array<std::uint64_t, 2>> fitBySpecies;
+    };
+    // Physical primaries, material, other decays: one row each; V0s and
+    // hyperons, decays in flight: one per production bin, then their sum.
+    std::vector<std::pair<std::string, Row>> rows;
+    const auto rowOf = [&](const Particle& particle) -> std::size_t {
+      switch (particle.group) {
+        case kPrimary:
+          return 0U;
+        case kV0:
+          return 1U + particle.bin;
+        case kInFlight:
+          return 2U + bins + particle.bin;
+        case kOtherDecay:
+          return 3U + (2U * bins);
+        default:
+          return 4U + (2U * bins);
+      }
+    };
+    rows.resize(5U + (2U * bins));
+    std::string edges = "0";
+    for (const auto edge : mSettings.productionEdges) {
+      edges += std::format(", {:.1f}", edge);
+    }
+    const auto binName = [&](std::size_t bin) {
+      const auto low = bin == 0U ? 0. : mSettings.productionEdges[bin - 1U];
+      return bin < mSettings.productionEdges.size() ? std::format("[{:.1f},{:.1f})", low, mSettings.productionEdges[bin]) : std::format("[{:.1f},inf)", low);
+    };
+    rows[0].first = "physical primaries";
+    for (std::size_t bin = 0; bin < bins; ++bin) {
+      rows[1U + bin].first = "V0s, hyperons " + binName(bin);
+      rows[2U + bins + bin].first = "in flight " + binName(bin);
+    }
+    rows[1U + bins].first = "V0s, hyperons, all";
+    rows[2U + (2U * bins)].first = "in flight, all";
+    rows[3U + (2U * bins)].first = "other decays";
+    rows[4U + (2U * bins)].first = "material";
+    const auto add = [&](Row& row, const Particle& particle, FunnelStage stage, FakeKind fake) {
+      ++row.findable;
+      ++row.byStage[static_cast<std::size_t>(stage)];
+      if (stage != FunnelStage::kFound) {
+        ++row.fakes[static_cast<std::size_t>(fake)];
+      }
+      if (stage == FunnelStage::kFit) {
+        auto last = FitLoss::kNoRoad;
+        for (const auto loss : particle.fitLosses) {
+          last = loss == FitLoss::kNoRoad ? last : loss;
+        }
+        auto& species = row.fitBySpecies[particle.species];
+        ++species[0];
+        species[1] += last == FitLoss::kChi2 ? 1U : 0U;
+        row.fitLosses.resize(std::max(row.fitLosses.size(), mIterations));
+        for (std::size_t iteration = 0; iteration < mIterations; ++iteration) {
+          const auto loss = iteration < particle.fitLosses.size() ? particle.fitLosses[iteration] : FitLoss::kNoRoad;
+          ++row.fitLosses[iteration][static_cast<std::size_t>(loss)];
+        }
+      }
+      if (stage == FunnelStage::kRoads) {
+        row.roadLosses.resize(std::max(row.roadLosses.size(), mIterations));
+        for (std::size_t iteration = 0; iteration < mIterations; ++iteration) {
+          const auto loss = iteration < particle.roadLosses.size() ? particle.roadLosses[iteration] : RoadLoss::kNoChain;
+          ++row.roadLosses[iteration][static_cast<std::size_t>(loss)];
+        }
+      }
+      if (stage == FunnelStage::kTracklets) {
+        row.reasons.resize(std::max(row.reasons.size(), particle.reasons.size()));
+        for (std::size_t iteration = 0; iteration < particle.reasons.size(); ++iteration) {
+          for (std::size_t reason = 0; reason < kPairLosses; ++reason) {
+            row.reasons[iteration][reason] += particle.reasons[iteration][reason];
+          }
+        }
+      }
+    };
+    for (std::size_t index = 0; index < mParticles.size(); ++index) {
+      const auto& particle = mParticles[index];
+      const auto stage = firstLoss(particle.longest, static_cast<std::uint32_t>(mSettings.minLayers), found[index]);
+      add(rows[rowOf(particle)].second, particle, stage, fakes[index]);
+      if (particle.group == kV0) {
+        add(rows[1U + bins].second, particle, stage, fakes[index]);
+      } else if (particle.group == kInFlight) {
+        add(rows[2U + (2U * bins)].second, particle, stage, fakes[index]);
+      }
+    }
+    std::vector<std::string> lines{
+      std::format("stage funnel: the findable above {} GeV on a chain of {} layers, production {} [cm] in bins from {}; "
+                  "found %, then the missed by the first stage without a chain of {} of their own (% of the findable)",
+                  mSettings.minPtGeV, mSettings.minLayers, mSettings.productionAlongZ ? "|z|" : "radius", edges, mSettings.minLayers)};
+    std::string seeded = std::format("  seeded, a road of its own, of {} findable, by iteration:", mParticles.size());
+    for (std::size_t iteration = 0; iteration < mIterations; ++iteration) {
+      seeded += std::format(" {} {}", iteration, std::ranges::count_if(mParticles, [&](const Particle& p) { return ((p.seededBy >> iteration) & 1U) != 0U; }));
+    }
+    lines.push_back(seeded + std::format(", any {}", std::ranges::count_if(mParticles, [](const Particle& p) { return p.seededBy != 0U; })));
+    for (const auto& [name, row] : rows) {
+      if (row.findable == 0U) {
+        continue;
+      }
+      std::string line = std::format("  {:<28} {:>6} findable, found {:5.1f} %; lost at", name, row.findable, percent(row.byStage[static_cast<std::size_t>(FunnelStage::kFound)], row.findable));
+      for (std::size_t stage = 0; stage + 1U < kFunnelStages; ++stage) {
+        line += std::format(" {} {:.1f}", kFunnelStageNames[stage], percent(row.byStage[stage], row.findable));
+      }
+      lines.push_back(line);
+      for (std::size_t iteration = 0; iteration < row.reasons.size(); ++iteration) {
+        std::uint64_t total = 0U;
+        for (const auto count : row.reasons[iteration]) {
+          total += count;
+        }
+        std::string reasons = std::format("    lost at tracklets, iteration {}: {} adjacent pairs not kept:", iteration, total);
+        for (std::size_t reason = 0; reason < kPairLosses; ++reason) {
+          reasons += std::format(" {} {:.1f}", kPairLossNames[reason], percent(row.reasons[iteration][reason], total));
+        }
+        lines.push_back(reasons);
+      }
+      for (std::size_t iteration = 0; iteration < row.roadLosses.size(); ++iteration) {
+        const auto lost = row.byStage[static_cast<std::size_t>(FunnelStage::kRoads)];
+        std::string reasons = std::format("    lost at roads, iteration {}, of {}:", iteration, lost);
+        for (std::size_t reason = 0; reason < kRoadLosses; ++reason) {
+          reasons += std::format(" {} {:.1f}", kRoadLossNames[reason], percent(row.roadLosses[iteration][reason], lost));
+        }
+        lines.push_back(reasons);
+      }
+      for (std::size_t iteration = 0; iteration < row.fitLosses.size(); ++iteration) {
+        const auto lost = row.byStage[static_cast<std::size_t>(FunnelStage::kFit)];
+        std::string reasons = std::format("    lost at the road fit, iteration {}, of {}:", iteration, lost);
+        for (std::size_t reason = 0; reason < kFitLosses; ++reason) {
+          reasons += std::format(" {} {:.1f}", kFitLossNames[reason], percent(row.fitLosses[iteration][reason], lost));
+        }
+        lines.push_back(reasons);
+      }
+      const auto missed = row.findable - row.byStage[static_cast<std::size_t>(FunnelStage::kFound)];
+      std::string fakeLine = std::format("    the {} missed, by their fake:", missed);
+      for (std::size_t kind = 0; kind < kFakeKinds; ++kind) {
+        fakeLine += std::format(" {} {:.1f}", kFakeKindNames[kind], percent(row.fakes[kind], missed));
+      }
+      lines.push_back(fakeLine);
+      if (!row.fitBySpecies.empty()) {
+        std::string species = "    lost at the road fit by species, all (by chi2):";
+        for (const auto& [pdg, counts] : row.fitBySpecies) {
+          species += std::format(" {} {} ({})", speciesName(pdg), counts[0], counts[1]);
+        }
+        lines.push_back(species);
+      }
+    }
+    return lines;
+  }
+
+  /// Why the particles found are found shorter than they could be:
+  /// for each findable particle with a
+  /// good track among \a tracks, its ceiling -- the longest chain its own
+  /// measurements make over the layout's links, any link, whatever an
+  /// iteration takes -- against its longest good track, and, if shorter, the
+  /// first stage whose longest chain of its own, over the iterations, falls
+  /// below the ceiling; the selection if its records reached it.
+  ///
+  /// A particle short at the tracklets with a direct pair not kept: each
+  /// pair of its longest chain of direct pairs that no iteration kept, by the
+  /// first test it fails in the iteration of its track, \a iterations[i]
+  /// being track i's.
+  [[nodiscard]] std::vector<std::string> lengthReport(const TrackRows& tracks, std::span<const std::size_t> iterations, const Controller& tracker) const
+  {
+    std::vector<std::uint32_t> found(mParticles.size(), 0U);
+    std::vector<std::size_t> foundIn(mParticles.size(), 0U);
+    for (std::size_t track = 0; track < tracks.size(); ++track) {
+      const auto at = mIndex.find(goodParticle(mRows, tracks[track]));
+      if (at != mIndex.end() && tracks[track].size() > found[at->second]) {
+        found[at->second] = static_cast<std::uint32_t>(tracks[track].size());
+        foundIn[at->second] = iterations[track];
+      }
+    }
+    constexpr std::size_t kLayerBits = std::numeric_limits<std::uint64_t>::digits;
+    const auto links = [] {
+      std::array<std::uint64_t, kLayerBits> result{};
+      for (const auto& link : Det::layerLinks) {
+        result[link.from] |= std::uint64_t{1} << link.to;
+      }
+      return result;
+    }();
+    const std::uint64_t barrels = barrelLayerBits<Det>();
+    std::array<LayerSpan, kLayerBits> spans{};
+    for (std::size_t layer = 0; layer < Detector<Det>::nLayers; ++layer) {
+      spans[layer] = layerSpan<Det>(static_cast<LayerID>(layer));
+    }
+    std::array<std::uint32_t, kLayerBits> order{};
+    for (std::size_t position = 0; position < layerOrder<Det>.size(); ++position) {
+      order[layerOrder<Det>[position]] = static_cast<std::uint32_t>(position);
+    }
+    struct Counts {
+      std::uint64_t found = 0U;
+      std::uint64_t complete = 0U;
+      std::uint64_t belowLayers = 0U; ///< the ceiling below its distinct layers
+      std::array<std::uint64_t, kFunnelStages - 1U> shortAt{};
+      std::array<std::uint64_t, kFunnelStages - 1U> missingAt{};      ///< ceiling - found, summed
+      std::array<std::uint64_t, kFunnelStages - 1U> stageShortfall{}; ///< ceiling - that stage's chain, summed
+      /// Short at the tracklets: their chain as long as the direct pairs'
+      /// longest, so only a pair over a layer crossed without a row joins the
+      /// rest; or shorter, a direct pair not kept.
+      std::array<std::uint64_t, 2> trackletsBy{};
+      std::uint64_t overMiss = 0U;                           ///< of them, the direct pairs' longest below the ceiling
+      std::array<std::uint64_t, kPairLosses> missingPairs{}; ///< the direct pairs not kept, by reason
+      std::array<std::uint64_t, kPairLosses> firstMissing{}; ///< the innermost of each particle's
+      std::map<std::pair<LayerID, LayerID>, std::uint64_t> missingLinks;
+    };
+    std::array<Counts, 2> counts; // physical primaries, all
+    for (std::size_t index = 0; index < mParticles.size(); ++index) {
+      if (found[index] == 0U) {
+        continue;
+      }
+      const auto& particle = mParticles[index];
+      std::vector<std::pair<std::uint32_t, std::uint32_t>> edges;
+      std::uint64_t layers = 0U;
+      for (const auto a : particle.rows) {
+        layers |= std::uint64_t{1} << mRows[a].layer;
+        for (const auto b : particle.rows) {
+          if (((links[mRows[a].layer] >> mRows[b].layer) & 1U) != 0U) {
+            edges.emplace_back(a, b);
+          }
+        }
+      }
+      // The same over the direct pairs alone, which cross no other layer
+      // inside its span: what an iteration without skips can join.
+      std::vector<std::pair<std::uint32_t, std::uint32_t>> direct;
+      for (const auto& [a, b] : edges) {
+        const auto holes = linkHoleLayers<Det>(mRows[a].layer, mRows[b].layer);
+        if (!segmentLeavesHole(holes, barrels, spans.data(), mRows[a].r, mRows[a].z, mRows[b].r, mRows[b].z)) {
+          direct.emplace_back(a, b);
+        }
+      }
+      const auto layerOrderOf = [&](std::uint32_t row) { return order[mRows[row].layer]; };
+      const auto directPath = longestPath(direct, layerOrderOf);
+      const auto directCeiling = static_cast<std::uint32_t>(directPath.size());
+      const auto ceiling = std::max(longestChain(std::move(edges), layerOrderOf), found[index]);
+      std::size_t stage = kFunnelStages - 2U; // the selection
+      for (std::size_t s = 0; s < particle.longest.size(); ++s) {
+        if (particle.longest[s] < ceiling) {
+          stage = s;
+          break;
+        }
+      }
+      for (std::size_t group = 0; group < counts.size(); ++group) {
+        if (group == 0U && particle.group != kPrimary) {
+          continue;
+        }
+        auto& count = counts[group];
+        ++count.found;
+        count.belowLayers += ceiling < static_cast<std::uint32_t>(std::popcount(layers)) ? 1U : 0U;
+        if (found[index] >= ceiling) {
+          ++count.complete;
+          continue;
+        }
+        ++count.shortAt[stage];
+        if (stage == 0U) {
+          ++count.trackletsBy[particle.longest[0] >= directCeiling ? 0U : 1U];
+          count.overMiss += directCeiling < ceiling ? 1U : 0U;
+          if (particle.longest[0] < directCeiling) {
+            const auto& parameters = tracker.iteration(foundIn[index]);
+            const auto kept = mOwnKept.find(static_cast<std::uint32_t>(index));
+            bool first = true;
+            for (std::size_t i = 1; i < directPath.size(); ++i) {
+              const auto a = directPath[i - 1U];
+              const auto b = directPath[i];
+              if (kept != mOwnKept.end() && kept->second.contains(pairKey(a, b))) {
+                continue;
+              }
+              const auto link = linkOf<Det>(mRows[a].layer, mRows[b].layer);
+              auto loss = link == kNoLink || !linkTaken(parameters, link) ? PairLoss::kLinkNotTaken : pairCutLoss(*mFrame, parameters, mBeamLine, link, a, b).loss;
+              if (loss == PairLoss::kCurvature && foundIn[index] < mMinPtGeV.size() && static_cast<double>(particle.pt) < mMinPtGeV[foundIn[index]]) {
+                loss = PairLoss::kCurvatureBelowPtMin;
+              }
+              ++count.missingPairs[static_cast<std::size_t>(loss)];
+              ++count.missingLinks[{mRows[a].layer, mRows[b].layer}];
+              if (first) {
+                ++count.firstMissing[static_cast<std::size_t>(loss)];
+                first = false;
+              }
+            }
+          }
+        }
+        count.missingAt[stage] += ceiling - found[index];
+        count.stageShortfall[stage] += stage < particle.longest.size() ? ceiling - particle.longest[stage] : 0U;
+      }
+    }
+    std::vector<std::string> lines{
+      "length funnel: the found against their ceiling, the longest chain of their own over the layout's links; the shorter by the first stage "
+      "whose longest chain of their own falls below it: particles (layers the found track misses, layers that stage's chain misses)"};
+    constexpr std::array<const char*, 2> kNames{"physical primaries", "all"};
+    for (std::size_t group = 0; group < counts.size(); ++group) {
+      const auto& count = counts[group];
+      std::string line = std::format("  {:<18} {} found, complete {:.1f} %, ceiling below their layers {:.1f} %; shorter at", kNames[group], count.found, percent(count.complete, count.found), percent(count.belowLayers, count.found));
+      for (std::size_t stage = 0; stage < count.shortAt.size(); ++stage) {
+        line += std::format(" {} {} ({}, {})", kFunnelStageNames[stage], count.shortAt[stage], count.missingAt[stage], count.stageShortfall[stage]);
+      }
+      lines.push_back(line);
+      lines.push_back(
+        std::format("    short at the tracklets: {} with a chain as long as their direct pairs' longest (only a pair over a layer crossed "
+                    "without a row joins the rest), {} with a direct pair not kept; {} whose direct pairs' longest is below the ceiling",
+                    count.trackletsBy[0], count.trackletsBy[1], count.overMiss));
+      std::string reasons = "    their direct pairs not kept, by the first test failing in the iteration of their track, all (the innermost):";
+      for (std::size_t reason = 0; reason < kPairLosses; ++reason) {
+        reasons += std::format(" {} {} ({})", kPairLossNames[reason], count.missingPairs[reason], count.firstMissing[reason]);
+      }
+      lines.push_back(reasons);
+      std::vector<std::pair<std::uint64_t, std::pair<LayerID, LayerID>>> byLink;
+      byLink.reserve(count.missingLinks.size());
+      for (const auto& [link, pairs] : count.missingLinks) {
+        byLink.emplace_back(pairs, link);
+      }
+      std::ranges::sort(byLink, std::greater{});
+      std::string top = "    by link (layers), the most:";
+      for (std::size_t i = 0; i < std::min<std::size_t>(byLink.size(), 12U); ++i) {
+        top += std::format(" {}-{}: {}", byLink[i].second.first, byLink[i].second.second, byLink[i].first);
+      }
+      lines.push_back(top);
+    }
+    return lines;
+  }
+
+  /// The longest chain of \a edges, as its nodes in order; \a orderOf orders
+  /// the nodes' layers.
+  template <typename OrderOf>
+  [[nodiscard]] static std::vector<std::uint32_t> longestPath(std::vector<std::pair<std::uint32_t, std::uint32_t>> edges, OrderOf orderOf)
+  {
+    std::ranges::sort(edges, {}, [&](const auto& edge) { return orderOf(edge.first); });
+    std::unordered_map<std::uint32_t, std::pair<std::uint32_t, std::uint32_t>> best; ///< node: length, predecessor
+    std::uint32_t end = 0U;
+    std::uint32_t longest = 0U;
+    for (const auto& [from, to] : edges) {
+      const auto before = best.find(from);
+      const std::uint32_t reached = (before == best.end() ? 1U : before->second.first) + 1U;
+      auto& at = best[to];
+      if (reached > at.first) {
+        at = {reached, from};
+        if (reached > longest) {
+          longest = reached;
+          end = to;
+        }
+      }
+    }
+    std::vector<std::uint32_t> path;
+    if (longest == 0U) {
+      return path;
+    }
+    for (std::uint32_t node = end;;) {
+      path.push_back(node);
+      const auto at = best.find(node);
+      if (at == best.end()) {
+        break;
+      }
+      node = at->second.second;
+    }
+    std::ranges::reverse(path);
+    return path;
+  }
+
+ private:
+  enum Group : std::uint8_t { kPrimary,
+                              kV0,
+                              kInFlight,
+                              kOtherDecay,
+                              kMaterial };
+
+  /// An adjacent-layer pair of a particle's own measurements an iteration did
+  /// not keep: the iteration, the pair's inner layer, the first test failing.
+  struct LostPair {
+    std::size_t iteration = 0U;
+    LayerID from = 0;
+    PairLoss loss = PairLoss::kElsewhere;
+  };
+
+  struct Particle {
+    std::uint64_t id = 0U;
+    float pt = 0.F;           ///< [GeV]
+    std::int32_t species = 0; ///< |PDG code|
+    Group group = kMaterial;
+    std::size_t bin = 0U;
+    std::vector<std::uint32_t> rows;
+    std::array<std::uint32_t, 5> longest{};                      ///< per stage, tracklets to the fit
+    std::vector<std::array<std::uint32_t, 5>> longestBy;         ///< the same per iteration
+    std::uint64_t seededBy = 0U;                                 ///< a bit per iteration with a road of its own
+    std::vector<std::array<std::uint32_t, kPairLosses>> reasons; ///< per iteration
+    std::vector<RoadLoss> roadLosses;                            ///< per iteration
+    std::vector<FitLoss> fitLosses;                              ///< per iteration
+    std::vector<float> recordChi2;                               ///< per iteration, the best chi2 of its longest records
+    /// The inner layers of its adjacent-layer pairs of its own some iteration
+    /// kept, a bit each.
+    std::uint64_t pairsKept = 0U;
+    std::vector<LostPair> lostPairs;          ///< every iteration's pairs of its own not kept there
+    std::vector<std::uint64_t> fitRoadLayers; ///< per iteration, the layers of the road `fitLosses` fitted, a bit each
+    std::vector<FitLoss> raisedFits;          ///< per iteration, the fit of a raised chain's own part (`raisedFitLosses`)
+  };
+
+  /// Why each particle's longest road of its own in \a iteration, if it
+  /// reaches the minimum and gave no record as long, was no record.
+  void fitLosses(const IterationParameters<Det>& parameters, std::size_t iteration)
+  {
+    if (mTracking == nullptr || !mPropagator) {
+      return;
+    }
+    const auto minimum = static_cast<std::size_t>(mSettings.minLayers);
+    for (const auto& [particle, rows] : mOwnRoad) {
+      if (rows.size() < minimum) {
+        continue;
+      }
+      const auto record = mOwnRecord.find(particle);
+      if (record != mOwnRecord.end() && record->second >= minimum) {
+        continue;
+      }
+      auto& losses = mParticles[particle].fitLosses;
+      losses.resize(std::max(losses.size(), iteration + 1U), FitLoss::kNoRoad);
+      auto& layers = mParticles[particle].fitRoadLayers;
+      layers.resize(std::max(layers.size(), iteration + 1U), 0U);
+      for (const auto row : rows) {
+        layers[iteration] |= std::uint64_t{1} << mRows[row].layer;
+      }
+      losses[iteration] = fitLoss(parameters, *mPropagator, rows);
+    }
+  }
+
+  /// The fit of the own part of each chain the walk raised from below it
+  /// (`raisedHow`) with no record of its own: kOther if the fit, the floor
+  /// and the beam line all take it -- a road without the other's triplets
+  /// below would have been a record.
+  void raisedFitLosses(const IterationParameters<Det>& parameters, std::size_t iteration)
+  {
+    if (mTracking == nullptr || !mPropagator) {
+      return;
+    }
+    const auto minimum = static_cast<std::size_t>(mSettings.minLayers);
+    for (const auto& [particle, rows] : mRaisedChain) {
+      const auto record = mOwnRecord.find(particle);
+      if (rows.size() < minimum || (record != mOwnRecord.end() && record->second >= minimum)) {
+        continue;
+      }
+      auto& fits = mParticles[particle].raisedFits;
+      fits.resize(std::max(fits.size(), iteration + 1U), FitLoss::kNoRoad);
+      fits[iteration] = fitLoss(parameters, *mPropagator, rows);
+    }
+  }
+
+  /// Why the road of \a rows is no record (`roadFitRefusal`): its boxes
+  /// share no time, the fit's chi2 or propagation, the pT floor for its
+  /// length, the beam line; kOther if none.
+  [[nodiscard]] FitLoss fitLoss(const IterationParameters<Det>& parameters, const Propagator& propagator, const std::vector<std::uint32_t>& rows) const
+  {
+    switch (roadFitRefusal(parameters, propagator, *mTracking, *mMaterial, *mFrame, std::span<const std::uint32_t>{rows})) {
+      case FitRefusal::kTime:
+        return FitLoss::kTime;
+      case FitRefusal::kChi2:
+        return FitLoss::kChi2;
+      case FitRefusal::kPropagation:
+        return FitLoss::kPropagation;
+      case FitRefusal::kPtFloor:
+        return FitLoss::kPtFloor;
+      case FitRefusal::kBeamLine:
+        return FitLoss::kBeamLine;
+      case FitRefusal::kTaken:
+        break;
+    }
+    return FitLoss::kOther;
+  }
+
+  /// What the road counting saw of a triplet.
+  struct TripletInfo {
+    std::uint32_t level = 0U;
+    bool successorAbove = false;
+    LayerID endLayer = 0;
+  };
+
+  /// Why \a particle's chain of \a length triplets ending at \a end is no road
+  /// of its own in \a iteration; \a chains, its neighbours.
+  void roadLoss(std::uint32_t particle, std::size_t iteration, const IterationParameters<Det>& parameters, std::uint32_t length, const std::pair<std::uint64_t, std::uint32_t>& end, const std::vector<std::array<std::uint32_t, 4>>& chains)
+  {
+    auto& losses = mParticles[particle].roadLosses;
+    losses.resize(std::max(losses.size(), iteration + 1U), RoadLoss::kNoChain);
+    const auto& infos = mTripletInfo[particle];
+    const auto found = infos.find(end);
+    auto loss = RoadLoss::kOther;
+    if (found != infos.end()) {
+      const auto& info = found->second;
+      if (info.level > length) {
+        std::vector<std::uint32_t> own;
+        loss = raisedHow(infos, end, chains, mTriplets[particle], own);
+        if (loss != RoadLoss::kRaised) {
+          mRaisedChain[particle] = std::move(own);
+        }
+      } else if (info.level < parameters.minRoadStartLevel) {
+        loss = RoadLoss::kStartLevel;
+      } else if (parameters.roadEndLayers != 0U && ((parameters.roadEndLayers >> info.endLayer) & 1U) == 0U) {
+        loss = RoadLoss::kEndLayer;
+      } else if (parameters.roadEndLayers == 0U && info.successorAbove) {
+        loss = RoadLoss::kContinued;
+      }
+    }
+    losses[iteration] = loss;
+  }
+
+  /// How a chain whose end \a end is raised loses its road: the walk from
+  /// it, descending through triplets of its own exactly one level below
+  /// (\a chains, its neighbours), reaches one without a neighbour of its own
+  /// below -- with no triplet of its own before it (\a triplets, as pairs of
+  /// tracklets) or with one -- or never does: it leaves the chain. In the
+  /// first two, \a own is the walked part of the chain, its rows innermost
+  /// first: the road the walk would give without the other's triplets below.
+  [[nodiscard]] static RoadLoss raisedHow(const std::map<std::pair<std::uint64_t, std::uint32_t>, TripletInfo>& infos, const std::pair<std::uint64_t, std::uint32_t>& end, const std::vector<std::array<std::uint32_t, 4>>& chains, const std::vector<std::pair<std::uint64_t, std::uint64_t>>& triplets, std::vector<std::uint32_t>& own)
+  {
+    using Key = std::pair<std::uint64_t, std::uint32_t>;
+    std::vector<Key> stack{end};
+    std::map<Key, Key> above{{end, end}}; // each triplet walked, and the one it was walked from
+    while (!stack.empty()) {
+      const auto current = stack.back();
+      stack.pop_back();
+      const auto level = infos.at(current).level;
+      bool predecessor = false;
+      for (const auto& rows : chains) {
+        if (pairKey(rows[1], rows[2]) != current.first || rows[3] != current.second) {
+          continue;
+        }
+        const std::pair<std::uint64_t, std::uint32_t> below{pairKey(rows[0], rows[1]), rows[2]};
+        const auto found = infos.find(below);
+        if (found == infos.end()) {
+          continue;
+        }
+        predecessor = true;
+        if (found->second.level + 1U == level && above.try_emplace(below, current).second) {
+          stack.push_back(below);
+        }
+      }
+      if (!predecessor) {
+        own = {static_cast<std::uint32_t>(current.first >> 32U), static_cast<std::uint32_t>(current.first), current.second};
+        for (auto at = current; at != end;) {
+          at = above.at(at);
+          own.push_back(at.second);
+        }
+        const bool before = std::ranges::any_of(triplets, [&](const auto& triplet) { return triplet.second == current.first; });
+        return before ? RoadLoss::kRaisedUnlinked : RoadLoss::kRaisedBelow;
+      }
+    }
+    return RoadLoss::kRaised;
+  }
+
+  [[nodiscard]] static Group groupOf(const ParticleTruth& truth)
+  {
+    switch (truth.origin) {
+      case ParticleOrigin::kPhysicalPrimary:
+        return kPrimary;
+      case ParticleOrigin::kDecay: {
+        const auto family = decayFamily(truth.motherPdg);
+        if (family == DecayFamily::kOther) {
+          return kOtherDecay;
+        }
+        return inFlight(family) ? kInFlight : kV0;
+      }
+      default:
+        return kMaterial;
+    }
+  }
+
+  /// The first iteration reads an empty mask.
+  void beginIteration()
+  {
+    if (mUsed.empty()) {
+      mUsed.assign(mRows.size(), std::uint8_t{0});
+    }
+  }
+
+  /// Calls \a body with every findable particle all of \a rows carry; whether
+  /// there was one.
+  template <typename Body>
+  bool forEachOwner(std::span<const std::uint32_t> rows, Body body) const
+  {
+    bool any = false;
+    forEachCommonParticle(mRows, rows, [&](std::uint64_t id) {
+      if (const auto at = mIndex.find(id); at != mIndex.end()) {
+        body(at->second);
+        any = true;
+      }
+    });
+    return any;
+  }
+
+  /// A record's key: \a iteration and its rows, sorted, hashed (FNV-1a).
+  [[nodiscard]] static std::uint64_t recordKey(std::size_t iteration, std::span<const std::uint32_t> rows)
+  {
+    std::vector<std::uint32_t> sorted(rows.begin(), rows.end());
+    std::ranges::sort(sorted);
+    std::uint64_t hash = 14695981039346656037ULL;
+    const auto mix = [&](std::uint64_t value) {
+      hash ^= value;
+      hash *= 1099511628211ULL;
+    };
+    mix(iteration);
+    for (const auto row : sorted) {
+      mix(row);
+    }
+    return hash;
+  }
+
+  void raise(std::uint32_t particle, std::size_t iteration, FunnelStage stage, std::uint32_t length)
+  {
+    auto& p = mParticles[particle];
+    auto& longest = p.longest[static_cast<std::size_t>(stage)];
+    longest = std::max(longest, length);
+    p.longestBy.resize(std::max(p.longestBy.size(), iteration + 1U));
+    auto& here = p.longestBy[iteration][static_cast<std::size_t>(stage)];
+    here = std::max(here, length);
+  }
+
+  /// Every findable particle's adjacent-layer pairs of its own measurements
+  /// that this iteration did not keep, by the first test each fails.
+  void lostPairReasons(const IterationParameters<Det>& parameters, std::size_t iteration)
+  {
+    // The cut's vertex is the beam line's here; an iteration from the vertex
+    // list keeps none.
+    if (parameters.vertexSource != VertexSource::kBeamLine) {
+      return;
+    }
+    // Each particle its own: in parallel, the same as one after the other.
+    detail::parallelFor(mArena, 0U, mParticles.size(), kParticlesPerTask, [&](std::size_t begin, std::size_t end) {
+      for (std::size_t index = begin; index < end; ++index) {
+        lostPairReasons(parameters, iteration, mParticles[index]);
+      }
+    });
+  }
+
+  /// lostPairReasons for one particle.
+  void lostPairReasons(const IterationParameters<Det>& parameters, std::size_t iteration, Particle& particle) const
+  {
+    auto& reasons = particle.reasons;
+    reasons.resize(std::max(reasons.size(), iteration + 1U));
+    for (std::size_t first = 0; first < particle.rows.size(); ++first) {
+      const auto fromLayer = mRows[particle.rows[first]].layer;
+      const auto toLayer = static_cast<LayerID>(fromLayer + 1U);
+      const auto link = linkOf<Det>(fromLayer, toLayer);
+      // The layer pair once, from its first measurement on the inner layer.
+      if (std::any_of(particle.rows.begin(), particle.rows.begin() + static_cast<std::ptrdiff_t>(first), [&](std::uint32_t row) { return mRows[row].layer == fromLayer; })) {
+        continue;
+      }
+      bool any = false;
+      bool kept = false;
+      auto furthest = PairLoss::kLinkNotTaken;
+      for (const auto source : particle.rows) {
+        if (mRows[source].layer != fromLayer) {
+          continue;
+        }
+        for (const auto target : particle.rows) {
+          if (mRows[target].layer != toLayer) {
+            continue;
+          }
+          any = true;
+          if (mKept.contains(pairKey(source, target))) {
+            kept = true;
+            particle.pairsKept |= std::uint64_t{1} << fromLayer;
+            break;
+          }
+          auto loss = link == kNoLink ? PairLoss::kLinkNotTaken : pairLoss(parameters, link, source, target);
+          if (loss == PairLoss::kCurvature && iteration < mMinPtGeV.size() && static_cast<double>(particle.pt) < mMinPtGeV[iteration]) {
+            loss = PairLoss::kCurvatureBelowPtMin;
+          }
+          furthest = std::max(furthest, loss);
+        }
+      }
+      if (any && !kept) {
+        ++reasons[iteration][static_cast<std::size_t>(furthest)];
+        particle.lostPairs.push_back({.iteration = iteration, .from = fromLayer, .loss = furthest});
+      }
+    }
+  }
+
+  [[nodiscard]] PairLoss pairLoss(const IterationParameters<Det>& parameters, std::size_t link, std::uint32_t sourceRow, std::uint32_t targetRow) const
+  {
+    if (!linkTaken(parameters, link)) {
+      return PairLoss::kLinkNotTaken;
+    }
+    if (mUsed[sourceRow] != 0U || mUsed[targetRow] != 0U) {
+      return PairLoss::kUsed;
+    }
+    return pairCutLoss(*mFrame, parameters, mBeamLine, link, sourceRow, targetRow).loss;
+  }
+
+  static constexpr std::size_t kParticlesPerTask = 256U;
+
+  std::span<const TruthRow> mRows;
+  ComparisonSettings mSettings;
+  VertexSeed mBeamLine;
+  const Frame* mFrame = nullptr;
+  const TrackingGeometry<Det>* mTracking = nullptr;
+  const o2::base::MatLayerCylSet* mMaterial = nullptr;
+  std::optional<Propagator> mPropagator;
+  std::unordered_map<std::uint32_t, std::vector<std::uint32_t>> mOwnRoad;     ///< each particle's longest road of its own, this iteration
+  std::unordered_map<std::uint32_t, std::vector<std::uint32_t>> mRaisedChain; ///< the own part of a chain raised from below it, this iteration
+  std::unordered_map<std::uint32_t, std::uint32_t> mOwnRecord;                ///< and its longest record
+  std::unordered_map<std::uint64_t, float> mRecordChi2;                       ///< every record's chi2 by recordKey
+  std::vector<double> mMinPtGeV;
+  std::vector<Particle> mParticles;
+  detail::TaskArena mArena; ///< lostPairReasons' threads: every core
+  std::unordered_map<std::uint64_t, std::uint32_t> mIndex;
+  std::vector<std::uint32_t> mRowOffsets;
+  std::vector<std::uint32_t> mRowParticles;
+  // The open iteration's, over its slices.
+  std::unordered_map<std::uint32_t, std::vector<std::pair<std::uint32_t, std::uint32_t>>> mPairs;
+  std::unordered_map<std::uint32_t, std::vector<std::pair<std::uint64_t, std::uint64_t>>> mTriplets;
+  std::unordered_map<std::uint32_t, std::map<std::pair<std::uint64_t, std::uint32_t>, TripletInfo>> mTripletInfo;
+  std::unordered_map<std::uint32_t, std::vector<std::array<std::uint32_t, 4>>> mNeighbours;
+  std::unordered_set<std::uint64_t> mKept;
+  std::unordered_map<std::uint32_t, std::unordered_set<std::uint64_t>> mOwnKept; ///< each particle's own kept pairs, over the iterations
+  std::vector<std::uint8_t> mUsed;                                               ///< the mask the open iteration read
+  bool mKeepOwnKept = false;                                                     ///< `keepReportInputs`
+  bool mKeepRecordChi2s = false;
+  std::size_t mIterations = 0U; ///< observed
+};
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_STAGEFUNNEL_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/Statistics.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/Statistics.h
new file mode 100644
index 0000000000000..64ed7f9bd35bf
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/Statistics.h
@@ -0,0 +1,55 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Statistics.h
+/// \brief The median, the quantile and the percentage the study's reports share.
+
+#ifndef GTRK_STUDY_STATISTICS_H_
+#define GTRK_STUDY_STATISTICS_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <span>
+
+namespace o2::gtrk::study
+{
+
+/// The median of \a values, the upper of the two middle ones for an even
+/// count, 0 for none. Reorders \a values (nth_element); pass a copy to keep
+/// their order.
+[[nodiscard]] inline double median(std::span<double> values)
+{
+  if (values.empty()) {
+    return 0.;
+  }
+  const auto middle = values.begin() + static_cast<std::ptrdiff_t>(values.size() / 2U);
+  std::ranges::nth_element(values, middle);
+  return *middle;
+}
+
+/// The element at rank floor(\a q (n - 1)) of \a values (n of them, not
+/// empty: the caller says what an empty set gives), \a q in [0, 1]: 0 the
+/// smallest, 1 the largest. Reorders \a values (nth_element).
+template <typename T>
+[[nodiscard]] T quantile(std::span<T> values, double q)
+{
+  const auto at = values.begin() + static_cast<std::ptrdiff_t>(q * static_cast<double>(values.size() - 1U));
+  std::ranges::nth_element(values, at);
+  return *at;
+}
+
+/// \a part as a percentage of \a whole, 0 for none.
+[[nodiscard]] inline double percent(std::uint64_t part, std::uint64_t whole) { return whole == 0U ? 0. : 100. * static_cast<double>(part) / static_cast<double>(whole); }
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_STATISTICS_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/TrackComparison.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/TrackComparison.h
new file mode 100644
index 0000000000000..471ae872a5818
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/TrackComparison.h
@@ -0,0 +1,398 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackComparison.h
+/// \brief Two trackers' tracks on the same measurements, under one set of
+///        truth rules.
+///
+/// Both track sets are lists of measurement rows, so the rules cannot depend
+/// on either tracker:
+///
+/// - a particle is **findable** if it is a primary above the pT floor with a
+///   measurement on every layer (the ITS standard: 7 of 7), and, as a second
+///   class, on a chain of at least `minLayers` layers (`isFindable`);
+/// - a track takes the particle most of its measurements carry among their
+///   labels, and is **good** if every one of them carries it and a **fake**
+///   otherwise -- one wrong measurement is enough. This follows O2's rule
+///   (`its::Tracker::computeTracksMClabels`): a measurement of two particles,
+///   which pile-up makes common, counts for both, and one carrying no
+///   particle -- noise -- for none;
+/// - a findable particle is **found** with a good track, **found with a fake**
+///   if its only track is a fake labelled with it, and **cloned** if it has
+///   more than one good track; it is found **complete** when its good track
+///   with the most layers has one on every layer the particle has a
+///   measurement on (a 4-cluster stub of a 7-layer particle is found, not
+///   complete).
+///
+/// The tracks short of a measurement on every layer are counted by their
+/// layers, which shows holes and where roads end. The all-layer class is also
+/// split by eta and phi, and counted once more under O2's own QA definition
+/// (`CheckTracksCA.C`): a primary whose clusters' first labels name it on
+/// every layer, at any pT.
+///
+/// Then track by track, by their measurement sets: identical, one a strict
+/// subset of the other, overlapping, or sharing nothing; and particle by
+/// particle, which of the findable each tracker found.
+///
+/// The decay daughters are split once more:
+/// by their mother's family and by where they were produced, in bins at the
+/// layers' positions, and counted on `minLayers` layers or more and, the
+/// findable among them, on a chain of `minLayers` layers (`isFindable`).
+
+#ifndef GTRK_STUDY_TRACKCOMPARISON_H_
+#define GTRK_STUDY_TRACKCOMPARISON_H_
+
+#include "GenericTracking/Base/Definitions.h"
+#include "GenericTracking/Base/LayerEnvelopes.h"
+#include "GenericTracking/Base/LayerLinks.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/LinkHoles.h"
+#include "GenericTracking/Workflow/TrackLabel.h"
+
+#include <algorithm>
+#include <cmath>
+#include <array>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <map>
+#include <optional>
+#include <span>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+/// What the comparison knows about one measurement: the particles its labels
+/// carry (the label rule's, TrackLabel.h), its layer and where it is.
+struct TruthRow : workflow::RowParticles {
+  LayerID layer = 0;
+  /// The measurement's global radius and z [cm], which a findable chain's
+  /// steps are tested with (LinkHoles.h).
+  Scalar r = 0.F;
+  Scalar z = 0.F;
+};
+
+// The label rule is the workflow's, shared with the O2-format adaptors.
+using workflow::goodParticle;
+using workflow::kNoTrackParticle;
+using workflow::majorityParticle;
+using workflow::MajorityParticle;
+
+/// Where a particle comes from.
+enum class ParticleOrigin : std::uint8_t {
+  kPhysicalPrimary, ///< ALICE's definition (O2's MCTrackNavigator::isPhysicalPrimary)
+  kDecay,           ///< otherwise a decay's: in transport, or feed-down the generator decayed
+  kMaterial,        ///< otherwise the detector's: hadronic interactions, conversions, delta rays, ...
+  kCount
+};
+inline constexpr std::size_t kParticleOrigins = static_cast<std::size_t>(ParticleOrigin::kCount);
+
+/// A particle's MC truth.
+struct ParticleTruth {
+  float pt = 0.F;       ///< [GeV]
+  bool primary = false; ///< the generator's (MCTrack::isPrimary), which O2's QA takes
+  float eta = 0.F;
+  float phi = 0.F; ///< [rad]
+  ParticleOrigin origin = ParticleOrigin::kMaterial;
+  std::int32_t pdg = 0;
+  std::int32_t motherPdg = 0; ///< 0 without a mother
+  std::uint8_t process = 0;   ///< how it was produced: a TMCProcess
+  float vx = 0.F;             ///< the production vertex [cm]
+  float vy = 0.F;
+  float vz = 0.F;
+};
+
+using ParticleTable = std::unordered_map<std::uint64_t, ParticleTruth>;
+
+/// Tracks as the measurement rows they hold, in any order.
+using TrackRows = std::vector<std::vector<std::uint32_t>>;
+
+/// \a tracks (a tracker's tracks) as the measurement rows each holds, in the
+/// tracks' and their clusters' order.
+template <typename Tracks>
+[[nodiscard]] TrackRows trackRows(const Tracks& tracks)
+{
+  TrackRows rows(tracks.size());
+  const auto view = tracks.view();
+  for (std::size_t track = 0; track < tracks.size(); ++track) {
+    rows[track].assign(std::begin(view.clusters[track].index), std::begin(view.clusters[track].index) + view.count[track]);
+  }
+  return rows;
+}
+
+/// The bins of the efficiencies: pT [GeV], eta, and phi in octants from 0.
+inline constexpr std::array<double, 9> kScorePtEdges{0.05, 0.1, 0.2, 0.3, 0.5, 1., 2., 5., std::numeric_limits<double>::infinity()};
+inline constexpr std::size_t kScorePtBins = kScorePtEdges.size() - 1U;
+/// The eta bins of a barrel; a disc-only layout takes its own acceptance
+/// (`comparisonSettings`), the same number of bins.
+inline constexpr std::array<double, 7> kScoreEtaEdges{-1.5, -1., -0.5, 0., 0.5, 1., 1.5};
+inline constexpr std::size_t kScoreEtaBins = kScoreEtaEdges.size() - 1U;
+inline constexpr std::size_t kScorePhiBins = 8U;
+/// Track lengths in measurements; the last slot holds the longer ones too.
+inline constexpr std::size_t kScoreLengthSlots = 16U;
+
+/// A link of a findable chain: its layers, and the layers a step on it can
+/// cross (`linkHoleLayers`), a bit per layer.
+struct ChainLink {
+  LayerID from = 0;
+  LayerID to = 0;
+  std::uint64_t holes = 0U;
+};
+
+struct ComparisonSettings {
+  int nLayers = 0;       ///< the detector's
+  int minLayers = 4;     ///< the second findable class
+  double minPtGeV = 0.1; ///< the findable floor
+  /// The QA's second findable rule (TrackingQA.h, `outwardLayers`): the
+  /// layers its MC hits reach on their way out, at the same floor.
+  int minOutwardLayers = 7;
+  /// The inner edges of the decay daughters' production bins after the first,
+  /// which starts at 0 [cm]: the layers' radii for a barrel, their |z| for
+  /// discs. Empty, one bin.
+  std::vector<double> productionEdges{}; // NOLINT(readability-redundant-member-init): GCC's -Wmissing-field-initializers wants it
+  bool productionAlongZ = false;         ///< production measured as |vz|, not as the radius
+  /// The efficiency's eta bins; outside them a particle counts in the nearest.
+  std::array<double, kScoreEtaBins + 1U> etaEdges = kScoreEtaEdges;
+  /// The links a findable chain follows, in topological source order: the
+  /// table's links that do not skip a layer, each with the layers a step on
+  /// it can cross. A step counts when its segment crosses none of them, as a
+  /// tracklet of an iteration without skips.
+  std::vector<ChainLink> chainLinks{}; // NOLINT(readability-redundant-member-init): GCC's -Wmissing-field-initializers wants it
+  /// The barrel layers, a bit per layer, and each layer's span, for that test.
+  std::uint64_t barrelLayers = 0U;
+  std::vector<LayerSpan> layerSpans{}; // NOLINT(readability-redundant-member-init): GCC's -Wmissing-field-initializers wants it
+  /// The layers the "on every layer" classes ask a measurement on, a bit per
+  /// layer; 0 for every layer of the detector (e.g. the TRK's eleven barrel
+  /// layers).
+  std::uint64_t allLayersMask = 0U;
+};
+
+/// Whether a particle measured on \a layers is on every layer of \a settings.
+[[nodiscard]] inline bool onEveryLayer(std::uint64_t layers, const ComparisonSettings& settings)
+{
+  if (settings.allLayersMask != 0U) {
+    return (layers & settings.allLayersMask) == settings.allLayersMask;
+  }
+  return std::popcount(layers) == settings.nLayers;
+}
+
+/// The settings for detector \a Det: the decay daughters' production bins at
+/// its layers' positions -- for a placed layout of barrel layers or of discs;
+/// one bin otherwise. A placed disc-only layout bins eta over its own
+/// acceptance, from the outer edge of its first disc to the inner edge of its
+/// last, seen from the origin, rounded outwards to 0.1 -- the MFT's
+/// [-3.8, -2.0] rather than the barrel's [-1.5, 1.5], which would hold every
+/// one of its tracks in one bin.
+template <DetectorLayout Det>
+[[nodiscard]] ComparisonSettings comparisonSettings(int minLayers = 4, double minPtGeV = 0.1)
+{
+  ComparisonSettings settings{.nLayers = Detector<Det>::nLayers, .minLayers = minLayers, .minPtGeV = minPtGeV, .productionAlongZ = !Detector<Det>::hasBarrel};
+  for (const auto from : layerOrder<Det>) {
+    for (auto at = outLinks<Det>.begin(from); at < outLinks<Det>.end(from); ++at) {
+      const auto link = outLinks<Det>.links[at];
+      if (!Det::layerLinks[link].skipsLayer) {
+        const auto to = Det::layerLinks[link].to;
+        settings.chainLinks.push_back({.from = from, .to = to, .holes = linkHoleLayers<Det>(from, to)});
+      }
+    }
+  }
+  settings.barrelLayers = barrelLayerBits<Det>();
+  for (int layer = 0; layer < Detector<Det>::nLayers; ++layer) {
+    settings.layerSpans.push_back(layerSpan<Det>(static_cast<LayerID>(layer)));
+  }
+  if constexpr (!(Detector<Det>::hasBarrel && Detector<Det>::hasDiscs)) {
+    for (int layer = 0; layer < Detector<Det>::nLayers; ++layer) {
+      settings.productionEdges.push_back(std::abs(static_cast<double>(PlacedEnvelopes<Det>::get(static_cast<LayerID>(layer)).position)));
+    }
+  }
+  if constexpr (!Detector<Det>::hasBarrel && Detector<Det>::hasDiscs) {
+    const auto eta = [](double r, double z) { return std::asinh(z / r); };
+    const auto& first = PlacedEnvelopes<Det>::get(static_cast<LayerID>(0));
+    const auto& last = PlacedEnvelopes<Det>::get(static_cast<LayerID>(Detector<Det>::nLayers - 1));
+    const double wide = eta(static_cast<double>(first.rMax), static_cast<double>(first.position));
+    const double narrow = eta(static_cast<double>(last.rMin), static_cast<double>(last.position));
+    // Rounded outwards to 0.1, then split evenly.
+    const double low = std::floor(std::min(wide, narrow) * 10.) / 10.;
+    const double high = std::ceil(std::max(wide, narrow) * 10.) / 10.;
+    for (std::size_t bin = 0; bin <= kScoreEtaBins; ++bin) {
+      settings.etaEdges[bin] = low + (high - low) * static_cast<double>(bin) / static_cast<double>(kScoreEtaBins);
+    }
+  }
+  return settings;
+}
+
+/// A decay daughter's mother, as the score splits them: the V0s and
+/// hyperons, then the decays in flight, then the rest.
+enum class DecayFamily : std::uint8_t {
+  kK0S,
+  kLambda,
+  kSigma,   ///< Sigma+ and Sigma-
+  kCascade, ///< Xi and Omega, charged or not
+  kK0L,
+  kPion, ///< in flight
+  kKaon, ///< in flight
+  kOther,
+  kCount
+};
+inline constexpr std::size_t kDecayFamilies = static_cast<std::size_t>(DecayFamily::kCount);
+[[nodiscard]] DecayFamily decayFamily(std::int32_t motherPdg);
+[[nodiscard]] constexpr bool inFlight(DecayFamily family) { return family == DecayFamily::kPion || family == DecayFamily::kKaon; }
+
+/// The particles a study takes: the physical primaries, the decay daughters,
+/// or those of a K0S or a hyperon (a K0S, Lambda, Sigma or cascade mother).
+enum class Population : std::uint8_t { kPrimaries,
+                                       kDecays,
+                                       kV0s };
+inline constexpr std::array<std::string_view, 3> kPopulationNames{"primaries", "decay daughters", "V0 daughters"};
+
+/// The population an option names: primary, decay or v0; none for another.
+[[nodiscard]] constexpr std::optional<Population> populationOf(std::string_view name)
+{
+  if (name == "primary") {
+    return Population::kPrimaries;
+  }
+  if (name == "decay") {
+    return Population::kDecays;
+  }
+  if (name == "v0") {
+    return Population::kV0s;
+  }
+  return std::nullopt;
+}
+
+/// \a particle belongs to \a population.
+[[nodiscard]] inline bool inPopulation(const ParticleTruth& particle, Population population)
+{
+  switch (population) {
+    case Population::kPrimaries:
+      return particle.origin == ParticleOrigin::kPhysicalPrimary;
+    case Population::kDecays:
+      return particle.origin == ParticleOrigin::kDecay;
+    case Population::kV0s: {
+      const auto family = decayFamily(particle.motherPdg);
+      return particle.origin == ParticleOrigin::kDecay && (family == DecayFamily::kK0S || family == DecayFamily::kLambda || family == DecayFamily::kSigma || family == DecayFamily::kCascade);
+    }
+  }
+  return false;
+}
+
+/// A particle's layers: a bit per layer with a measurement carrying it, and
+/// its longest chain, the most layers a path of `chainLinks` visits whose
+/// every step joins two of its measurements without crossing another layer.
+struct ParticleLayers {
+  std::uint64_t layers = 0U;
+  std::uint32_t chain = 0U;
+};
+
+/// Whether a particle of transverse momentum \a pt [GeV] whose longest chain
+/// has \a chain layers is findable: at or above
+/// the pT floor, on a chain of `minLayers`.
+[[nodiscard]] constexpr bool isFindable(float pt, const ParticleLayers& layers, const ComparisonSettings& settings) { return static_cast<double>(pt) >= settings.minPtGeV && settings.minLayers > 0 && std::cmp_greater_equal(layers.chain, settings.minLayers); }
+
+/// Each particle the rows carry, with its rows in ascending order: every row
+/// among whose labels it is.
+[[nodiscard]] std::unordered_map<std::uint64_t, std::vector<std::uint32_t>> rowsOfParticles(std::span<const TruthRow> rows);
+
+/// Each particle the rows carry, with its layers and longest chain.
+[[nodiscard]] std::unordered_map<std::uint64_t, ParticleLayers> particleLayers(std::span<const TruthRow> rows, const ComparisonSettings& settings);
+
+/// A species, |PDG code|, as the score prints it: e, mu, pi, K, p, ...
+[[nodiscard]] std::string speciesName(std::int32_t species);
+
+/// \a particle's production bin under \a settings: 0 before the first edge.
+[[nodiscard]] std::size_t productionBin(const ParticleTruth& particle, const ComparisonSettings& settings);
+
+/// One family's decay daughters above the pT floor in one production bin.
+struct DecayCounts {
+  std::uint64_t onMinLayers = 0U; ///< with measurements on `minLayers` layers or more
+  std::uint64_t foundOnMinLayers = 0U;
+  std::uint64_t findable = 0U; ///< of them, on a chain of `minLayers` layers (`isFindable`)
+  std::uint64_t found = 0U;
+};
+
+/// One tracker's particles of one findable class: found with a good track,
+/// found only with a fake, cloned.
+struct FindableScore {
+  std::uint64_t findable = 0U;
+  std::uint64_t found = 0U;
+  std::uint64_t fakeOnly = 0U;
+  std::uint64_t cloned = 0U;
+  std::array<std::uint64_t, kScorePtBins> findableByPt{};
+  std::array<std::uint64_t, kScorePtBins> foundByPt{};
+  std::array<std::uint64_t, kScoreEtaBins> findableByEta{};
+  std::array<std::uint64_t, kScoreEtaBins> foundByEta{};
+  std::array<std::uint64_t, kScorePhiBins> findableByPhi{};
+  std::array<std::uint64_t, kScorePhiBins> foundByPhi{};
+  std::uint64_t cloneTracks = 0U; ///< good tracks beyond each particle's first
+  std::uint64_t withFake = 0U;    ///< particles some fake is labelled with, found or not
+  /// Found complete: the good track with the most layers covers every layer
+  /// the particle has a measurement on. The layers that track covers and the
+  /// layers the found particles have, for the fraction attached.
+  std::uint64_t complete = 0U;
+  std::array<std::uint64_t, kScorePtBins> completeByPt{};
+  std::uint64_t layersFound = 0U;
+  std::uint64_t layersOf = 0U;
+  /// The layer fraction, summed over the findable: each found particle adds
+  /// the fraction of its layers its good track with the most layers covers, an unfound one 0, clones and fakes nothing;
+  /// divided by `findable` it is the mean a stub counts in part towards.
+  double layerFraction = 0.;
+  std::array<double, kScorePtBins> layerFractionByPt{};
+  /// By species, |PDG code|: findable and found.
+  std::map<std::int32_t, std::array<std::uint64_t, 2>> bySpecies;
+};
+
+/// `TrackScore::primaryRegion`'s classes: on no disc, on a disc too.
+inline constexpr std::size_t kPrimaryRegions = 2;
+
+/// One tracker's tracks under the truth rules, as numbers:
+/// what `compareTrackSets` reports of it.
+struct TrackScore {
+  std::uint64_t tracks = 0U;
+  std::uint64_t fakes = 0U;
+  std::array<std::uint64_t, kScoreLengthSlots> tracksByLength{};
+  std::array<std::uint64_t, kScoreLengthSlots> fakesByLength{};
+  FindableScore allLayers; ///< primaries above the pT floor on every layer
+  FindableScore minLayers; ///< the same on `minLayers` layers or more
+  FindableScore o2;        ///< O2's QA definition (`CheckTracksCA.C`)
+  /// Every particle above the pT floor by its origin, primary or not, on
+  /// every layer and on `minLayers` or more.
+  std::array<FindableScore, kParticleOrigins> originAllLayers;
+  std::array<FindableScore, kParticleOrigins> originMinLayers;
+  /// The same on a chain of `minLayers` layers: the findable (`isFindable`).
+  std::array<FindableScore, kParticleOrigins> originFindable;
+  /// The physical primaries of `originFindable` by where they are measured:
+  /// [0] on no disc, [1] on a disc too. The
+  /// class is the layers the particle crosses, not an eta cut.
+  std::array<FindableScore, kPrimaryRegions> primaryRegion;
+  /// The decay daughters by their mother's family and production bin, one
+  /// more bin than `productionEdges`.
+  std::array<std::vector<DecayCounts>, kDecayFamilies> decays;
+};
+
+/// \a tracks scored against \a truth.
+[[nodiscard]] TrackScore scoreTracks(std::span<const TruthRow> rows, const ParticleTable& truth, const TrackRows& tracks, const ComparisonSettings& settings);
+
+/// \a score as the lines `compareTrackSets` prints for the tracker \a name,
+/// in its order.
+[[nodiscard]] std::vector<std::string> describeScore(const TrackScore& score, const ComparisonSettings& settings, const std::string& name);
+
+/// The comparison's report, one line per entry.
+[[nodiscard]] std::vector<std::string> compareTrackSets(std::span<const TruthRow> rows, const ParticleTable& truth, const TrackRows& ours, const TrackRows& theirs, const ComparisonSettings& settings, const std::string& ourName, const std::string& theirName);
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_TRACKCOMPARISON_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/TrackPulls.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/TrackPulls.h
new file mode 100644
index 0000000000000..9ec3475e50a47
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/TrackPulls.h
@@ -0,0 +1,69 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackPulls.h
+/// \brief Residuals and pulls of fitted track parameters against MC truth,
+///        by parameter and pT.
+///
+/// Robust statistics throughout: a pull's width is 1.4826 times its median
+/// absolute deviation, so a tail of wrong assignments does not hide the core,
+/// and the tail is reported on its own as the fraction beyond 5 sigma.
+
+#ifndef GTRK_STUDY_TRACKPULLS_H_
+#define GTRK_STUDY_TRACKPULLS_H_
+
+#include <array>
+#include <cstddef>
+#include <limits>
+#include <span>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+/// One fitted parameter as a table shows it.
+struct PullParameter {
+  std::string name;
+  std::string unit;  ///< of the residual as reported
+  double scale = 1.; ///< from the parameter's own unit to `unit`
+};
+
+class PullTable
+{
+ public:
+  static constexpr std::array<double, 4> kPtEdges{0.1, 0.3, 1., std::numeric_limits<double>::infinity()};
+  static constexpr std::size_t kPtBins = kPtEdges.size() - 1U;
+
+  PullTable(std::string name, std::vector<PullParameter> parameters);
+
+  /// One track: each parameter's residual (fitted less true) and its fitted
+  /// sigma; a sigma of zero records the residual without a pull.
+  void add(double pt, std::span<const double> residuals, std::span<const double> sigmas);
+
+  /// One line per parameter and pT bin, and one for all pT.
+  [[nodiscard]] std::vector<std::string> report() const;
+
+ private:
+  struct Samples {
+    std::vector<double> residuals;
+    std::vector<double> pulls;
+  };
+
+  std::string mName;
+  std::vector<PullParameter> mParameters;
+  std::vector<std::array<Samples, kPtBins>> mSamples; ///< per parameter, per pT bin
+  std::size_t mTracks = 0U;
+};
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_TRACKPULLS_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/TrackingInput.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/TrackingInput.h
new file mode 100644
index 0000000000000..154ae6cbd0e38
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/TrackingInput.h
@@ -0,0 +1,110 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackingInput.h
+/// \brief What the sink's tracker reads for one timeframe, on disk.
+///
+/// The measurement columns, the grid offsets and the vertex list exactly as
+/// the sink received them, so that `o2-gtrk-track-bench` runs the tracking
+/// loop on the same input without DPL, the producer or the QA around it.
+/// The configuration the sink ran with
+/// goes beside it as `<file>.ini`, which `ConfigurableParam::updateFromFile`
+/// reads back to the bit.
+///
+/// The file is raw and native-endian: a header with the blocks' counts and the
+/// beam line, then the readout frames, every column in schema order, the
+/// offsets, the vertices and the measurement depths, each block with its
+/// element count and its `Digest`, which the reader checks.
+///
+/// With MC, the truth the comparison reads goes beside it as `<file>.truth`:
+/// each row's particles and layer, and
+/// the particles' kinematics, laid out the same way, so that the bench scores
+/// its tracks as the sink does.
+
+#ifndef GTRK_STUDY_TRACKINGINPUT_H_
+#define GTRK_STUDY_TRACKINGINPUT_H_
+
+#include "GenericTracking/Base/FrameTiming.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Workflow/BeamLine.h"
+#include "GenericTracking/Study/TrackComparison.h"
+
+#include <cstdint>
+#include <format>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+/// One timeframe's tracking input, owned.
+struct TrackingInput {
+  MeasurementStore columns;
+  std::vector<std::uint32_t> offsets; ///< the grid's bucket prefix offsets, then the row count
+  std::vector<VertexSeed> vertices;   ///< time-sorted
+  workflow::BeamLine beamLine;        ///< the one the rows were placed and binned about
+  /// Each layer's readout frames, which the grid's time blocks and the slices'
+  /// reach follow.
+  std::vector<FrameTiming> frames;
+  /// Each layer's measurement depth [cm] (Geometry::measurementDepth), which
+  /// the rows were placed at.
+  std::vector<double> depths;
+};
+
+/// Write \a view's \a rows rows, \a offsets, \a vertices, \a beamLine,
+/// \a frames and \a depths to \a path; the caller writes the parameters to
+/// `<path>.ini` with `writeParameters`. Throws std::runtime_error.
+void writeTrackingInput(const std::string& path, const MeasurementView& view, std::size_t rows, std::span<const std::uint32_t> offsets, std::span<const VertexSeed> vertices, const workflow::BeamLine& beamLine, std::span<const FrameTiming> frames, std::span<const double> depths);
+
+/// Every configurable parameter to \a path as INI, as
+/// `ConfigurableParam::writeINI` writes it, but GTRKReco<DET>'s floating-point
+/// values at full precision: ROOT prints them with `%g`, and a field of
+/// -5.0066791 kG would read back as -5.00668.
+void writeParameters(const std::string& path);
+
+/// Read what `writeTrackingInput` wrote to \a path; the parameters are not
+/// touched. Throws std::runtime_error on a short, foreign or corrupt file.
+[[nodiscard]] TrackingInput readTrackingInput(const std::string& path);
+
+/// \a input's readout frames, one per layer of \a Det. Throws
+/// std::runtime_error for another count.
+template <DetectorLayout Det>
+[[nodiscard]] std::vector<FrameTiming> layerFrames(const TrackingInput& input)
+{
+  constexpr auto kLayers = static_cast<std::size_t>(Detector<Det>::nLayers);
+  if (input.frames.size() != kLayers) {
+    throw std::runtime_error(std::format("tracking input: readout frames for {} layers, {} has {}", input.frames.size(), Det::name, kLayers));
+  }
+  return input.frames;
+}
+
+/// One timeframe's MC truth, as `compareTrackSets` reads it.
+struct TrackingTruth {
+  std::vector<TruthRow> rows; ///< one per row of the tracking input, in its order
+  ParticleTable particles;
+};
+
+/// Write \a rows -- one per row of the tracking input, whose cluster indices
+/// are \a clusterIndex -- and \a particles to \a path. Throws std::runtime_error.
+void writeTrackingTruth(const std::string& path, std::span<const std::uint32_t> clusterIndex, std::span<const TruthRow> rows, const ParticleTable& particles);
+
+/// Read what `writeTrackingTruth` wrote to \a path for \a input. Throws
+/// std::runtime_error on a short, foreign or corrupt file, or one whose rows
+/// are not \a input's by count and cluster index.
+[[nodiscard]] TrackingTruth readTrackingTruth(const std::string& path, const TrackingInput& input);
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_TRACKINGINPUT_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/TrackingQA.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/TrackingQA.h
new file mode 100644
index 0000000000000..ff6cb3ea1e004
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/TrackingQA.h
@@ -0,0 +1,356 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackingQA.h
+/// \brief One tracker run's MC truth QA as trees, binned only by the plotting
+///        macro.
+///
+/// Per timeframe, one record per findable particle -- by TrackComparison.h's
+/// `isFindable`, its `findable`, or at the same pT floor by its MC hits'
+/// outward leg on `minOutwardLayers` layers or more (`outwardLayers`) -- and
+/// one per track:
+///
+///   particles: the truth's pT, eta and phi, its origin, `foundBy`, a bit
+///              per iteration with a good track of it (`goodParticle`, the
+///              text report's label rule), and `seededBy`, a bit per
+///              iteration with a road of its own before the road fit
+///              (StageFunnel.h); its PDG codes, decay geometry, layers,
+///              the funnel's verdict and the other tracker's
+///              (`QAParticle`)
+///   tracks:    the fit's pT, eta and phi, its iteration, fake and clone
+///
+/// Every efficiency follows from the two; for iteration i, `bit` = 1 << i:
+///
+///   exclusive:   found by i                       (foundBy & bit) of all
+///   cumulative:  found by some iteration <= i     (foundBy & (2 bit - 1)) of all
+///   conditional: found by i, not found before i   (foundBy & bit) of !(foundBy & (bit - 1))
+///
+/// and the same for seeding with `seededBy`, the conditional one's condition
+/// still "not found before i".
+///
+/// A fake is a track no particle is on every measurement of; a clone is a good
+/// track of a particle with a good track before it, in iteration and then
+/// track order.
+
+#ifndef GTRK_STUDY_TRACKINGQA_H_
+#define GTRK_STUDY_TRACKINGQA_H_
+
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Study/TrackComparison.h"
+
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <numbers>
+#include <span>
+#include <unordered_map>
+#include <vector>
+
+namespace o2::utils
+{
+class TreeStreamRedirector;
+}
+
+namespace o2::gtrk::study
+{
+
+/// The eta range the QA's axes span [low, high).
+struct EtaRange {
+  double low = 0.;
+  double high = 0.;
+};
+
+/// The eta range a layout's silicon reaches from the origin: the extreme
+/// eta of the envelopes' corners in r and z, rounded outwards to 0.5. The
+/// comparison's eta edges are report bins, not an acceptance.
+[[nodiscard]] EtaRange etaReach(std::span<const LayerEnvelope> envelopes);
+
+/// \a phi [rad] in [0, 2 pi), the one wrapping of every phi the QA keeps:
+/// in double for any number of turns, then float (O2's `bringTo02Pi` works in
+/// float).
+[[nodiscard]] inline float wrapPhi(double phi)
+{
+  constexpr double kTwoPi = 2. * std::numbers::pi;
+  const auto wrapped = static_cast<float>(phi - (kTwoPi * std::floor(phi / kTwoPi)));
+  return wrapped < static_cast<float>(kTwoPi) ? wrapped : 0.F;
+}
+
+/// A track as the QA reads it besides its rows: its fitted pT, eta and phi
+/// at its innermost measurement, the iteration that found it, and its fit's
+/// chi2 and degrees of freedom.
+struct TrackKinematics {
+  float pt = 0.F; ///< [GeV]
+  float eta = 0.F;
+  float phi = 0.F; ///< [rad]
+  std::uint8_t iteration = 0U;
+  float chi2 = 0.F;
+  std::int32_t ndf = 0;
+};
+
+/// Iterations a particle's `foundBy` holds.
+inline constexpr int kQAMaxIterations = std::numeric_limits<std::uint64_t>::digits;
+
+/// The value of `QAParticle::lostAt` and `pairLoss` where nothing was
+/// observed: no stage funnel, or a particle it does not hold.
+inline constexpr std::uint8_t kQANotObserved = std::numeric_limits<std::uint8_t>::max();
+
+/// What the sink knows of a findable particle beyond the truth table: its
+/// decay geometry -- where it was
+/// produced and how it passes the beam line, and its mother's direction
+/// there -- and its stage funnel's verdict.
+struct ParticleExtras {
+  float vr = 0.F; ///< the production point's transverse distance from the beam line [cm]
+  /// The truth helix's transverse distance of closest approach to the beam
+  /// line, signed: the beam line's distance from the circle's centre less the
+  /// radius; a straight line's, signed by the side, for a neutral or no field
+  /// [cm]. NaN without the particle's kinematics.
+  float d0 = std::numeric_limits<float>::quiet_NaN();
+  float z0 = std::numeric_limits<float>::quiet_NaN(); ///< its z there less the beam spot's [cm]
+  /// The angle between its momentum at production and its mother's at the
+  /// same point [rad]; NaN without a mother.
+  float openingAngle = std::numeric_limits<float>::quiet_NaN();
+  /// How far the production point lies from the mother's circle,
+  /// transversely [cm]: the check on the mother's helix; NaN without a
+  /// mother, 0 for a neutral one's straight line through it.
+  float motherMiss = std::numeric_limits<float>::quiet_NaN();
+  /// The stage funnel's first stage without a chain of its own as long as the
+  /// minimum, a FunnelStage (StageFunnel.h), kFound if found.
+  std::uint8_t lostAt = kQANotObserved;
+  /// Of its adjacent-layer pairs no iteration kept, the test most fail first,
+  /// a PairLoss (StageFunnel.h), over the iterations whose pT_min it clears;
+  /// kQANotObserved if none was lost.
+  std::uint8_t pairLoss = kQANotObserved;
+  /// Lost at the roads: why its chain of neighbours gave no road of its own,
+  /// a RoadLoss (StageFunnel.h), in the last iteration that saw one;
+  /// kQANotObserved otherwise.
+  std::uint8_t roadLoss = kQANotObserved;
+  /// Lost at the road fit: why its longest road of its own was no record, a
+  /// FitLoss (StageFunnel.h), in the last iteration that fitted one, and that
+  /// road's layers, a bit each; kQANotObserved and 0 otherwise.
+  std::uint8_t fitLoss = kQANotObserved;
+  std::uint64_t fitRoadLayers = 0U;
+  /// The same particles: every reason any iteration gave, a bit per RoadLoss
+  /// and per FitLoss; 0 otherwise.
+  std::uint8_t roadLosses = 0U;
+  std::uint8_t fitLosses = 0U;
+  /// Lost at the roads to a chain raised from below it: the road fit of its
+  /// own part, a FitLoss, kOther if the fit takes it; kQANotObserved
+  /// otherwise.
+  std::uint8_t raisedFit = kQANotObserved;
+  std::uint8_t outwardLayers = 0U; ///< the layers of its MC hits' outward leg (`outwardLayers`)
+};
+
+/// A findable particle of the `particles` tree.
+struct QAParticle {
+  float pt = 0.F; ///< [GeV]
+  float eta = 0.F;
+  float phi = 0.F;             ///< [rad], [0, 2 pi)
+  std::uint8_t origin = 0U;    ///< ParticleOrigin
+  std::uint64_t foundBy = 0U;  ///< a bit per iteration with a good track of it
+  std::uint64_t seededBy = 0U; ///< a bit per iteration with a road of its own
+  std::int32_t pdg = 0;
+  std::int32_t motherPdg = 0; ///< 0 without a mother
+  float vz = 0.F;             ///< the production point's z [cm]
+  std::uint64_t layers = 0U;  ///< the layers it has measurements on, a bit each
+  bool foundByO2 = false;     ///< a good track of it among the other tracker's
+  bool findable = true;       ///< by `isFindable`; otherwise by its outward leg alone
+  ParticleExtras extras;      ///< its decay geometry and funnel verdict, the tree's branches in between
+};
+
+/// One crossing of a sensor by a particle, from its MC hit [cm].
+struct HitCrossing {
+  double time = 0.; ///< any clock along the particle's path
+  std::array<double, 3> position{};
+  LayerID layer = 0;
+  std::array<double, 3> momentum{}; ///< [GeV]
+};
+
+/// A particle's outward leg: its \a crossings in time order up to the first
+/// one nearer its \a production point than the one before -- a curler's turn
+/// back.
+[[nodiscard]] std::vector<HitCrossing> outwardLeg(std::vector<HitCrossing> crossings, const std::array<double, 3>& production);
+
+/// The layers of an outward \a leg (`outwardLeg`), a layer counted once
+/// however often it is crossed.
+[[nodiscard]] std::uint8_t outwardLayers(std::span<const HitCrossing> leg);
+
+/// A particle's helix as the MC kinematics give it at its production point.
+struct TruthHelix {
+  std::array<double, 3> position{}; ///< [cm]
+  std::array<double, 3> momentum{}; ///< [GeV]
+  double charge = 0.;               ///< [e]
+};
+
+/// Where a helix passes an axis parallel to z: its transverse distance of
+/// closest approach, signed as `QAParticle::d0`, and its z there [cm]; NaN
+/// both for kinematics or a field not finite, or no transverse momentum.
+struct HelixImpact {
+  double d0 = 0.;
+  double z = 0.;
+};
+
+/// \a helix in the uniform field \a bzKiloGauss against the axis through
+/// (\a x, \a y): the circle's centre lies on the side the Lorentz force
+/// points to, and of the closest points the nearer pass to the production
+/// point is taken, the turn from it in (-pi, pi]. A neutral, or no field: the
+/// straight line.
+[[nodiscard]] HelixImpact helixImpact(const TruthHelix& helix, double bzKiloGauss, double x, double y);
+
+/// The unit direction of \a helix at the transverse point (\a x, \a y): the
+/// tangent to its circle there in the sense of motion, the point taken by
+/// its direction from the centre; the same direction as at production for a
+/// neutral, no field or no transverse momentum. NaN for kinematics, a field or
+/// a point not finite, no momentum, or the point at the centre.
+[[nodiscard]] std::array<double, 3> helixDirectionAt(const TruthHelix& helix, double bzKiloGauss, double x, double y);
+
+/// The transverse distance of (\a x, \a y) from \a helix's circle, or its
+/// straight line [cm], a line along z without transverse momentum; NaN for
+/// kinematics, a field or a point not finite, or no momentum.
+[[nodiscard]] double helixMiss(const TruthHelix& helix, double bzKiloGauss, double x, double y);
+
+/// Each particle's extras, by particle id.
+using ParticleExtrasTable = std::unordered_map<std::uint64_t, ParticleExtras>;
+
+/// A track of the `tracks` tree.
+struct QATrack {
+  float pt = 0.F; ///< [GeV]
+  float eta = 0.F;
+  float phi = 0.F; ///< [rad], [0, 2 pi)
+  std::uint8_t iteration = 0U;
+  bool fake = false;
+  bool clone = false;
+  float chi2 = 0.F; ///< the fit's; TMath::Prob(chi2, ndf) is its probability
+  std::int32_t ndf = 0;
+};
+
+/// A good track against its particle's MC crossing of its innermost
+/// measurement's sensor, on the plane its state is bound to
+/// (TrackingGeometry::planeOf): an entry of the `resolution` tree.
+/// Residuals are fitted less true, in
+/// the state's units (cm, rad, 1/GeV); sigmas the fit's. pT directly: its
+/// relative residual, and its sigma from the theta-q/p block of the
+/// covariance, J C J^T.
+struct QAResolution {
+  float pt = 0.F; ///< the truth's [GeV]
+  float eta = 0.F;
+  float phi = 0.F;        ///< [rad], [0, 2 pi)
+  std::int8_t charge = 0; ///< [e]
+  std::int32_t pdg = 0;
+  std::uint8_t origin = 0U; ///< ParticleOrigin
+  std::uint8_t iteration = 0U;
+  std::uint8_t kinks = 0U;
+  std::uint8_t clusters = 0U;
+  std::uint8_t layer = 0U;         ///< the innermost measurement's, where the state is
+  std::array<float, 5> residual{}; ///< loc0, loc1, phi, theta, q/p
+  std::array<float, 5> sigma{};
+  float fitPt = 0.F;      ///< [GeV]
+  float ptResidual = 0.F; ///< (fitPt - pt) / pt
+  float ptSigma = 0.F;    ///< of fitPt [GeV]
+  /// The closest approach to the MC event's vertex, d0 and z0 [cm]:
+  /// on the plane through the vertex
+  /// along the beam, normal to the track's transverse direction there; the
+  /// fit's sigma of each (J C J^T), and the scattering's between the vertex
+  /// and the innermost measurement; NaN where the propagation failed.
+  std::array<float, 2> dca{std::numeric_limits<float>::quiet_NaN(), std::numeric_limits<float>::quiet_NaN()};
+  std::array<float, 2> dcaSigma{std::numeric_limits<float>::quiet_NaN(), std::numeric_limits<float>::quiet_NaN()};
+  std::array<float, 2> dcaScattering{std::numeric_limits<float>::quiet_NaN(), std::numeric_limits<float>::quiet_NaN()};
+  /// The particle's production point's distance from that vertex [cm]: 0
+  /// for one made at the collision, a heavy-flavour decay's daughter's
+  /// flight otherwise, whose d0 is its own and not a residual.
+  float productionOffset = std::numeric_limits<float>::quiet_NaN();
+};
+
+/// A good track's oracle refit (SpeciesOracle.h) against
+/// its particle's MC crossing of its innermost measurement's sensor: an
+/// entry of the `oracle` tree, one per track and variant, as `QAResolution`'s
+/// residuals and sigmas. \a momentum is the crossing's.
+struct QAOracle {
+  std::int32_t pdg = 0;
+  std::int8_t charge = 0; ///< [e]
+  std::uint8_t origin = 0U;
+  float eta = 0.F; ///< the truth's at production
+  std::uint8_t layer = 0U;
+  std::uint8_t kinks = 0U; ///< the tracking's own refit's
+  std::uint8_t clusters = 0U;
+  float productionOffset = std::numeric_limits<float>::quiet_NaN();
+  float momentum = 0.F; ///< at the crossing [GeV]
+  /// At the crossing of the outermost measurement's sensor [GeV]: the
+  /// momentum lost inside the fitted chain, 1 - pOuter / momentum.
+  float pOuter = std::numeric_limits<float>::quiet_NaN();
+  std::uint8_t variant = 0U; ///< OracleVariant
+  std::uint8_t status = 0U;  ///< the refit's PropagationStatus; the rest only for kOk
+  float chi2 = 0.F;
+  std::int16_t ndf = 0;
+  std::array<float, 5> residual{};
+  std::array<float, 5> sigma{};
+  float ptResidual = 0.F; ///< fitted pT over the crossing's, less 1
+};
+
+/// A findable particle's momentum along its outward leg: an entry of the
+/// `momenta` tree, with --species-oracle, for every electron and every 16th
+/// pion. \a pAtLayer: |p| entering the
+/// layer's first crossing on the outward leg (`outwardLeg`), NaN
+/// without one [GeV].
+struct QAMomenta {
+  std::int32_t pdg = 0;
+  std::uint8_t origin = 0U;
+  float pt = 0.F; ///< at production [GeV]
+  float eta = 0.F;
+  float p0 = 0.F; ///< |p| at production [GeV]
+  bool found = false;
+  std::uint8_t lostAt = 0U;   ///< QAParticle's
+  std::uint8_t pairLoss = 0U; ///< QAParticle's
+  std::uint64_t layers = 0U;  ///< the layers with a measurement of it
+  /// Its fakes -- tracks most of whose measurements carry it, not all: the
+  /// fewest wrong measurements among them, 0 without one; with one wrong, its
+  /// layer (0xFF otherwise).
+  std::uint8_t fakeWrong = 0U;
+  std::uint8_t fakeWrongLayer = 0xFFU;
+  std::vector<float> pAtLayer;
+};
+
+/// \a entries into \a output's `momenta` tree.
+void streamMomenta(o2::utils::TreeStreamRedirector& output, std::span<const QAMomenta> entries);
+
+/// \a entries into \a output's `oracle` tree.
+void streamOracle(o2::utils::TreeStreamRedirector& output, std::span<const QAOracle> entries);
+
+/// One timeframe's records.
+struct TrackingQA {
+  std::vector<QAParticle> particles;
+  std::vector<QATrack> tracks; ///< in the order of the tracks given
+};
+
+/// Each particle's `seededBy`, by particle id (StageFunnel::seededBy).
+using SeededBy = std::unordered_map<std::uint64_t, std::uint64_t>;
+
+/// One timeframe: its rows' truth, its particles and its tracks, as rows
+/// and as kinematics, track by track, the seeded, each particle's extras,
+/// and the other tracker's tracks, if any. Throws std::invalid_argument for a
+/// track's iteration outside \a iterations, or more than kQAMaxIterations.
+[[nodiscard]] TrackingQA trackingQA(std::span<const TruthRow> rows, const ParticleTable& truth, const TrackRows& tracks, std::span<const TrackKinematics> kinematics, const SeededBy& seeded, const ParticleExtrasTable& extras, const TrackRows* theirs, int iterations, const ComparisonSettings& settings);
+
+/// \a qa's records into \a output's `particles` and `tracks` trees.
+void stream(o2::utils::TreeStreamRedirector& output, const TrackingQA& qa);
+
+/// \a entries into \a output's `resolution` tree.
+void streamResolution(o2::utils::TreeStreamRedirector& output, std::span<const QAResolution> entries);
+
+/// The run's one entry of the `run` tree: what the macro's axes need,
+/// \a settings' findable rules (`minLayers`, `minPtGeV`, `minOutwardLayers`)
+/// for its definitions, and the run's MC \a events.
+void streamRun(o2::utils::TreeStreamRedirector& output, int iterations, EtaRange eta, const ComparisonSettings& settings, std::size_t events);
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_TRACKINGQA_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/Validation.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/Validation.h
new file mode 100644
index 0000000000000..5bdc919720b40
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/Validation.h
@@ -0,0 +1,144 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Validation.h
+/// \brief The point-only overloads of the triplet and scattering functions,
+///        and the stage rules, that the studies call.
+///
+/// What a stage has at hand -- the kink terms, the scattering -- computed from
+/// the points alone, the link and chi2 rules the stages apply, and the road
+/// fit stage's tests on one road. Host code; the tests' own overloads are
+/// test/Oracles.h's.
+
+#ifndef GTRK_STUDY_VALIDATION_H_
+#define GTRK_STUDY_VALIDATION_H_
+
+#include "GenericTracking/Base/Definitions.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/NeighbourCut.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/TrackFitter.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tracking/TripletCut.h"
+#include "GenericTracking/Tracking/TripletFit.h"
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <span>
+#include <string_view>
+
+namespace o2::gtrk::study
+{
+
+// ---- the triplet and neighbour fits from the points alone ----
+
+/// The triplet's kink variance with theta from the first to the third
+/// measurement.
+template <DetectorLayout Det>
+[[nodiscard]] inline Scalar tripletScattering(const ScatteringTable<Det>& table, const PairCut& cut, LayerID middleLayer, const PairPoint& first, const PairPoint& middle, const PairPoint& third)
+{
+  return tripletScattering(table, cut, middleLayer, first, middle, third, detail::referenceSinTheta(first, third));
+}
+
+/// The fit factor from the points and a given angular variance, the kink
+/// terms computed here.
+[[nodiscard]] inline bool makeTripletFitFactor(const PairPoint& first, const PairPoint& middle, const PairPoint& third, Scalar angularVariance, TripletFitFactor& result)
+{
+  KinkTerms terms;
+  return makeKinkTerms(first, middle, third, terms) && makeTripletFitFactor(terms, first, middle, third, angularVariance, result);
+}
+
+/// Whether the iteration takes \a link: it is among its source's out-links,
+/// which hold the links `takenLinks` gives: the skip rule, the layer mask and
+/// the path length.
+template <DetectorLayout Det>
+[[nodiscard]] inline bool linkTaken(const IterationParameters<Det>& parameters, std::size_t link)
+{
+  const auto source = static_cast<std::size_t>(parameters.linkSources[link]);
+  for (auto at = parameters.outLinkOffsets[source]; at < parameters.outLinkOffsets[source + 1U]; ++at) {
+    if (parameters.outLinkIndices[at] == link) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/// The road fit's chi2 bound for \a clusters clusters and \a kinks kinks.
+template <DetectorLayout Det>
+[[nodiscard]] inline Scalar roadChi2Cut(const IterationParameters<Det>& parameters, std::uint32_t clusters, std::uint32_t kinks = 0U)
+{
+  return parameters.roadChi2MaxByNdf[(2U * clusters) - kNBoundParams - (2U * kinks)];
+}
+
+/// Why the road fit stage refuses a road, in the order of its tests, or that
+/// it takes it.
+enum class FitRefusal : std::uint8_t { kTime,
+                                       kChi2,
+                                       kPropagation,
+                                       kPtFloor,
+                                       kBeamLine,
+                                       kTaken };
+inline constexpr std::size_t kFitRefusals = 6U;
+inline constexpr std::array<std::string_view, kFitRefusals> kFitRefusalNames{"time", "chi2", "propagation", "pT floor", "beam line", "taken"};
+
+/// The road fit (`o2::gtrk::fitRoad`) with the host's choice at run time,
+/// where the iteration has the allowance (`takesLastStepAllowance`), for the
+/// studies that repeat it; the stages choose at compile time.
+template <typename Parameters, typename Prop, DetectorLayout Det, typename Material, typename Chain>
+[[nodiscard]] RoadFitResult fitRoad(const Parameters& parameters, const Prop& prop, const TrackingGeometry<Det>& geometry, const Material& material, const Chain& measurements, int n)
+{
+  return takesLastStepAllowance(parameters) ? o2::gtrk::fitRoad<true>(parameters, prop, geometry, material, measurements, n) : o2::gtrk::fitRoad<false>(parameters, prop, geometry, material, measurements, n);
+}
+
+/// The road fit stage's tests on the road of \a rows of \a frame, innermost
+/// first, in its order (RoadFit.h, `fitRows`): its boxes share no time, the
+/// outward fit's chi2 or propagation (the run-time `fitRoad`, the last-step
+/// allowance as the stage's), the pT floor for its length, and with the beam
+/// constraint the beam line. The road as given: `iterationInnerTrim`'s
+/// shorter fits of a refused road are not replayed.
+template <DetectorLayout Det, typename Material>
+[[nodiscard]] FitRefusal roadFitRefusal(const IterationParameters<Det>& parameters, const Propagator& propagator, const TrackingGeometry<Det>& tracking, const Material& material, const TimeFrame<Det>& frame, std::span<const std::uint32_t> rows)
+{
+  const auto columns = frame.measurements();
+  auto common = timeBoxAt(columns, rows[0]);
+  for (std::size_t i = 1; i < rows.size(); ++i) {
+    const auto box = timeBoxAt(columns, rows[i]);
+    if (!common.isCompatible(box)) {
+      return FitRefusal::kTime;
+    }
+    common += box;
+  }
+  const auto count = static_cast<std::uint32_t>(rows.size());
+  const auto fit = fitRoad(parameters, propagator, tracking, material, RowChain<Det>{.frame = &frame, .rows = rows.data()}, static_cast<int>(count));
+  if (fit.status == RoadFitStatus::kRejected) {
+    return FitRefusal::kChi2;
+  }
+  if (fit.status != RoadFitStatus::kAccepted) {
+    return FitRefusal::kPropagation;
+  }
+  if (!clearsPtFloor(parameters, count, fit)) {
+    return FitRefusal::kPtFloor;
+  }
+  if (Scalar beamChi2 = 0.F; parameters.beamConstraint && !clearsBeamLine(propagator, parameters, frame, tracking, material, rows.data(), count, fit.state, beamChi2)) {
+    return FitRefusal::kBeamLine;
+  }
+  return FitRefusal::kTaken;
+}
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_VALIDATION_H_
diff --git a/Detectors/GenericTracking/study/include/GenericTracking/Study/VertexQA.h b/Detectors/GenericTracking/study/include/GenericTracking/Study/VertexQA.h
new file mode 100644
index 0000000000000..b95cd3e009d69
--- /dev/null
+++ b/Detectors/GenericTracking/study/include/GenericTracking/Study/VertexQA.h
@@ -0,0 +1,259 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file VertexQA.h
+/// \brief The own vertexer's vertices against the MC collisions, under the
+///        vertex study's rules (the bench's vertex study, VertexStudy.h).
+///
+/// A collision is a generator event, its z the median of its measured
+/// primaries' production z (the generator's primaries include displaced
+/// decay daughters, so no single one will do). A triplet of the pass belongs
+/// to a collision when one primary of it carries all three measurements. A
+/// vertex belongs to the collision most of its claimed triplets belong to,
+/// and is a fake when background -- no such primary -- is the most. A
+/// collision is found when a vertex belongs to it, the one with the most
+/// contributors; any other is a split. A collision without one whose
+/// triplets went mostly to another collision's vertex is merged. What a
+/// missed collision costs the tracking is its findable primaries: 0.1 GeV or
+/// more on a chain of four layers, the sink's findable (TrackComparison.h).
+
+#ifndef GTRK_STUDY_VERTEXQA_H_
+#define GTRK_STUDY_VERTEXQA_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/VertexStage.h"
+#include "GenericTracking/Study/MCTruth.h"
+#include "GenericTracking/Study/Statistics.h"
+#include "GenericTracking/Study/TrackComparison.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <format>
+#include <limits>
+#include <map>
+#include <span>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+/// One timeframe's vertices against its collisions.
+struct VertexScore {
+  std::size_t vertices = 0U;
+  std::size_t collisions = 0U; ///< with a measured primary
+  std::size_t found = 0U;
+  std::uint64_t findable = 0U; ///< the collisions' findable primaries
+  std::uint64_t covered = 0U;  ///< those of the found collisions
+  std::size_t fakes = 0U;
+  std::size_t splits = 0U;
+  std::size_t merged = 0U;
+  std::vector<double> residualsUM; ///< |z - z_true| of each found collision's vertex [um]
+  std::vector<double> pulls;       ///< (z - z_true) / its sigma z, the same vertices
+  /// A collision no vertex is the best of, and where its triplets went.
+  struct Missed {
+    double z = 0.; ///< the median production z of its primaries [cm]
+    std::uint32_t findable = 0U;
+    std::uint32_t triplets = 0U; ///< the pass's triplets of one of its primaries, in the slices owning their frames
+    std::uint32_t cut = 0U;      ///< of those, none (kNone: cut, degenerate or deduplicated)
+    std::uint32_t free = 0U;     ///< a candidate no vertex claimed (kFree)
+    std::uint32_t other = 0U;    ///< claimed by a vertex another collision (or none) is the majority of
+  };
+  std::vector<Missed> missed;
+};
+
+/// The shared majority, best-vertex, split and merge rule. Ordered maps
+/// make the first collision/vertex win a tie; equal contributors keep the
+/// first vertex. Negative labels denote background or unclaimed triplets.
+struct VertexClaimsScore {
+  std::vector<std::int64_t> collision;
+  std::vector<std::int64_t> best;
+  std::uint32_t fakes = 0U;
+  std::uint32_t splits = 0U;
+  std::uint32_t merged = 0U;
+};
+
+[[nodiscard]] inline VertexClaimsScore scoreVertexClaims(std::span<const std::map<std::int64_t, std::uint32_t>> labels, std::span<const std::uint32_t> contributors, std::span<const std::map<std::int64_t, std::uint32_t>> wentTo)
+{
+  VertexClaimsScore result;
+  result.best.assign(wentTo.size(), -1);
+  for (std::size_t v = 0; v < labels.size(); ++v) {
+    const auto collision = labels[v].empty() ? -1 : std::ranges::max_element(labels[v], {}, [](const auto& entry) { return entry.second; })->first;
+    result.collision.push_back(collision);
+    if (collision < 0) {
+      ++result.fakes;
+      continue;
+    }
+    auto& top = result.best[static_cast<std::size_t>(collision)];
+    result.splits += top >= 0 ? 1U : 0U;
+    if (top < 0 || contributors[static_cast<std::size_t>(top)] < contributors[v]) {
+      top = static_cast<std::int64_t>(v);
+    }
+  }
+  for (std::size_t c = 0; c < wentTo.size(); ++c) {
+    if (result.best[c] < 0 && !wentTo[c].empty()) {
+      const auto top = std::ranges::max_element(wentTo[c], {}, [](const auto& entry) { return entry.second; })->first;
+      result.merged += top >= 0 ? 1U : 0U;
+    }
+  }
+  return result;
+}
+
+/// \a found's vertices against the collisions of \a rows (one per frame row)
+/// and \a particles, from the pass's \a claims (`VertexingPass::Result`).
+template <DetectorLayout Det>
+[[nodiscard]] VertexScore scoreVertices(std::span<const TruthRow> rows, const ParticleTable& particles, std::span<const TripletClaim> claims, const VertexerResult& found)
+{
+  // Per particle, its layers and longest chain: the findable's rule.
+  const auto settings = comparisonSettings<Det>();
+  const auto layers = particleLayers(rows, settings);
+  struct Collision {
+    std::vector<double> productionZ;
+    std::uint32_t findable = 0U;
+  };
+  // The collisions with a measured primary, by `collisionOf` (the vertex
+  // study's index takes every generator primary's).
+  std::unordered_map<std::uint64_t, std::size_t> index;
+  std::vector<Collision> collisions;
+  for (const auto& [particle, info] : particles) {
+    const auto measured = layers.find(particle);
+    if (!info.primary || measured == layers.end()) {
+      continue;
+    }
+    const auto [at, inserted] = index.try_emplace(collisionOf(particle), collisions.size());
+    if (inserted) {
+      collisions.emplace_back();
+    }
+    auto& collision = collisions[at->second];
+    collision.productionZ.push_back(static_cast<double>(info.vz));
+    collision.findable += isFindable(info.pt, measured->second, settings) ? 1U : 0U;
+  }
+  // Each triplet's collision, -1 for background.
+  const auto tripletCollision = [&](const TripletClaim& claim) -> std::int64_t {
+    const auto particle = commonParticle(rows, claim.rows);
+    if (!particle) {
+      return -1;
+    }
+    const auto info = particles.find(*particle);
+    return info != particles.end() && info->second.primary ? static_cast<std::int64_t>(index.at(collisionOf(*particle))) : -1;
+  };
+  VertexScore score;
+  score.vertices = found.vertices.size();
+  score.collisions = collisions.size();
+  std::vector<std::map<std::int64_t, std::uint32_t>> labels(found.vertices.size());
+  std::vector<std::map<std::int64_t, std::uint32_t>> wentTo(collisions.size()); // per collision: the vertices its triplets went to, -1 free, -2 cut
+  for (const auto& claim : claims) {
+    const auto vertex = claim.vertex;
+    const auto collision = tripletCollision(claim);
+    if (vertex >= 0) {
+      ++labels[static_cast<std::size_t>(vertex)][collision];
+    }
+    if (collision >= 0) {
+      ++wentTo[static_cast<std::size_t>(collision)][vertex];
+    }
+  }
+  const auto assigned = scoreVertexClaims(labels, found.contributors, wentTo);
+  const auto& best = assigned.best;
+  score.fakes = assigned.fakes;
+  score.splits = assigned.splits;
+  score.merged = assigned.merged;
+  for (std::size_t c = 0; c < collisions.size(); ++c) {
+    auto& collision = collisions[c];
+    score.findable += collision.findable;
+    if (best[c] < 0) {
+      VertexScore::Missed miss{.z = median(collision.productionZ), .findable = collision.findable};
+      for (const auto& [vertex, count] : wentTo[c]) {
+        if (vertex == VertexerResult::kNotOwned) {
+          continue; // a halo's copy, counted in the slice that owns its frame
+        }
+        miss.triplets += count;
+        (vertex == VertexerResult::kNone ? miss.cut : vertex == VertexerResult::kFree ? miss.free
+                                                                                      : miss.other) += count;
+      }
+      score.missed.push_back(miss);
+      continue;
+    }
+    ++score.found;
+    score.covered += collision.findable;
+    const double z = median(collision.productionZ); // a collision has a primary: never empty
+    const auto& vertex = found.vertices[static_cast<std::size_t>(best[c])];
+    score.residualsUM.push_back(std::abs((static_cast<double>(vertex.z) - z) * 1.e4));
+    if (vertex.varZ > 0.F) {
+      score.pulls.push_back((static_cast<double>(vertex.z) - z) / std::sqrt(static_cast<double>(vertex.varZ)));
+    }
+  }
+  return score;
+}
+
+/// \a score as the sink logs it.
+[[nodiscard]] inline std::string describe(const VertexScore& score)
+{
+  auto residuals = score.residualsUM;
+  std::ranges::sort(residuals);
+  const auto at = [&](double q) { return residuals.empty() ? 0. : residuals[std::min(residuals.size() - 1U, static_cast<std::size_t>(q * static_cast<double>(residuals.size())))]; };
+  return std::format(
+    "vertex QA: {} vertices; collisions found {}/{}, their findable primaries {}/{} ({:.2f} %); fakes {}, splits {}, merged {}; "
+    "|dz| 68/95/99/max [um] {:.0f} {:.0f} {:.0f} {:.0f}",
+    score.vertices, score.found, score.collisions, score.covered, score.findable, 100. * static_cast<double>(score.covered) / std::max(1., static_cast<double>(score.findable)), score.fakes, score.splits, score.merged, at(0.68), at(0.95), at(0.99), residuals.empty() ? 0. : residuals.back());
+}
+
+/// \a score's missed collisions by their findable primaries: per bin the
+/// collisions, their findable primaries and where their triplets went.
+[[nodiscard]] inline std::string describeMissed(const VertexScore& score)
+{
+  constexpr std::array<std::uint32_t, 7> kLow{0U, 1U, 5U, 10U, 20U, 50U, 100U};
+  std::string line = "vertex QA, the missed collisions by findable primaries (collisions, findable; their triplets: none / free / another's):";
+  for (std::size_t bin = 0; bin < kLow.size(); ++bin) {
+    const auto high = bin + 1U < kLow.size() ? kLow[bin + 1U] : std::numeric_limits<std::uint32_t>::max();
+    std::uint64_t collisions = 0U;
+    std::uint64_t findable = 0U;
+    std::uint64_t cut = 0U;
+    std::uint64_t free = 0U;
+    std::uint64_t other = 0U;
+    for (const auto& miss : score.missed) {
+      if (miss.findable >= kLow[bin] && miss.findable < high) {
+        ++collisions;
+        findable += miss.findable;
+        cut += miss.cut;
+        free += miss.free;
+        other += miss.other;
+      }
+    }
+    line += std::format(" [{}{}] {}, {}; {} / {} / {}", kLow[bin], high == std::numeric_limits<std::uint32_t>::max() ? "+" : std::format("-{}", high - 1U), collisions, findable, cut, free, other);
+  }
+  return line;
+}
+
+/// \a score's pulls, (z - z_true) / sigma z of each found collision's vertex,
+/// their mean and rms and every one of them, for sums over timeframes.
+[[nodiscard]] inline std::string describePulls(const VertexScore& score)
+{
+  double sum = 0.;
+  double sum2 = 0.;
+  for (const double pull : score.pulls) {
+    sum += pull;
+    sum2 += pull * pull;
+  }
+  const auto n = static_cast<double>(std::max<std::size_t>(score.pulls.size(), 1U));
+  std::string line = std::format("vertex pulls: {} vertices, mean {:+.3f}, rms {:.3f}:", score.pulls.size(), sum / n, std::sqrt(sum2 / n));
+  for (const double pull : score.pulls) {
+    line += std::format(" {:.3f}", pull);
+  }
+  return line;
+}
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_VERTEXQA_H_
diff --git a/Detectors/GenericTracking/study/src/GTrkStudyLinkDef.h b/Detectors/GenericTracking/study/src/GTrkStudyLinkDef.h
new file mode 100644
index 0000000000000..2cb3de26a5624
--- /dev/null
+++ b/Detectors/GenericTracking/study/src/GTrkStudyLinkDef.h
@@ -0,0 +1,21 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class o2::gtrk::study::MCVertexParam + ;
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::gtrk::study::MCVertexParam> + ;
+
+#endif
diff --git a/Detectors/GenericTracking/study/src/Hits.cxx b/Detectors/GenericTracking/study/src/Hits.cxx
new file mode 100644
index 0000000000000..ab49557c6be53
--- /dev/null
+++ b/Detectors/GenericTracking/study/src/Hits.cxx
@@ -0,0 +1,111 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Study/Alice/Hits.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+
+#include "DataFormatsTRKFT3/Hit.h"
+#include "ITSMFTSimulation/Hit.h"
+
+#include <TFile.h>
+#include <TTree.h>
+
+#include <format>
+#include <stdexcept>
+
+namespace o2::gtrk::study
+{
+
+namespace
+{
+/// Every event's hits of type \a HitType from \a branch, as segments, appended to its event's.
+template <typename HitType>
+void readSegments(TTree& tree, const char* branch, std::vector<std::vector<HitSegment>>& events, std::uint32_t firstSensor = 0U)
+{
+  std::vector<HitType> hits;
+  auto* pointer = &hits;
+  tree.SetBranchAddress(branch, &pointer);
+  for (std::size_t event = 0; event < events.size(); ++event) {
+    tree.GetEntry(static_cast<Long64_t>(event));
+    auto& segments = events[event];
+    segments.reserve(segments.size() + hits.size());
+    for (const auto& hit : hits) {
+      segments.push_back({
+        .track = hit.GetTrackID(),
+        .chip = firstSensor + hit.GetDetectorID(),
+        .start = {hit.GetStartX(), hit.GetStartY(), hit.GetStartZ()},
+        .end = {hit.GetX(), hit.GetY(), hit.GetZ()},
+        .momentum = {hit.GetPx(), hit.GetPy(), hit.GetPz()},
+        .time = hit.GetTime(),
+      });
+    }
+  }
+  tree.ResetBranchAddresses();
+}
+
+TTree* openTree(const std::string& path, std::unique_ptr<TFile>& file)
+{
+  file.reset(TFile::Open(path.c_str()));
+  if (!file || file->IsZombie()) {
+    throw std::runtime_error("cannot open " + path);
+  }
+  auto* tree = file->Get<TTree>("o2sim");
+  if (tree == nullptr) {
+    throw std::runtime_error("no o2sim tree in " + path);
+  }
+  return tree;
+}
+} // namespace
+
+HitFile::HitFile(const std::string& path, Chips chips, const std::string& discPath) : mChips(chips), mTree(openTree(path, mFile))
+{
+  if (!discPath.empty()) {
+    if (chips != Chips::kTRK) {
+      throw std::invalid_argument("HitFile: a second file of disc hits is FT3's, for the TRK only");
+    }
+    mDiscTree = openTree(discPath, mDiscFile);
+    if (mDiscTree->GetEntries() != mTree->GetEntries()) {
+      throw std::runtime_error(std::format("{} has {} events, {} has {}", path, mTree->GetEntries(), discPath, mDiscTree->GetEntries()));
+    }
+  }
+}
+
+HitFile::~HitFile() = default;
+
+int HitFile::nEvents() const { return static_cast<int>(mTree->GetEntries()); }
+
+const std::vector<HitSegment>& HitFile::event(int event)
+{
+  // Every event at the first call, in the file's order: the callers ask in their particles' order, and
+  // a basket holds many events, so entry by entry would read the file many times over.
+  if (!mRead) {
+    mRead = true;
+    mEvents.resize(static_cast<std::size_t>(mTree->GetEntries()));
+    switch (mChips) {
+      case Chips::kITS:
+        readSegments<o2::itsmft::Hit>(*mTree, "ITSHit", mEvents);
+        break;
+      case Chips::kMFT:
+        readSegments<o2::itsmft::Hit>(*mTree, "MFTHit", mEvents);
+        break;
+      case Chips::kTRK:
+        readSegments<o2::trkft3::Hit>(*mTree, "TRKHit", mEvents);
+        if (mDiscTree != nullptr) {
+          readSegments<o2::trkft3::Hit>(*mDiscTree, "FT3Hit", mEvents, static_cast<std::uint32_t>(detectors::TRKFT3::kFirstDiscSensor));
+        }
+        break;
+    }
+  }
+  static const std::vector<HitSegment> kNone;
+  return event < 0 || static_cast<std::size_t>(event) >= mEvents.size() ? kNone : mEvents[static_cast<std::size_t>(event)];
+}
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/src/MCVertexParam.cxx b/Detectors/GenericTracking/study/src/MCVertexParam.cxx
new file mode 100644
index 0000000000000..de1ec54b2a633
--- /dev/null
+++ b/Detectors/GenericTracking/study/src/MCVertexParam.cxx
@@ -0,0 +1,14 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Study/MCVertexParam.h"
+
+O2ParamImpl(o2::gtrk::study::MCVertexParam);
diff --git a/Detectors/GenericTracking/study/src/MCVertexReaderSpec.cxx b/Detectors/GenericTracking/study/src/MCVertexReaderSpec.cxx
new file mode 100644
index 0000000000000..706cd71c36847
--- /dev/null
+++ b/Detectors/GenericTracking/study/src/MCVertexReaderSpec.cxx
@@ -0,0 +1,175 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Study/MCVertexReaderSpec.h"
+#include "GenericTracking/Study/MCVertexParam.h"
+
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Workflow/Conditions.h"
+#include "GenericTracking/Workflow/ConditionsTRK.h"
+#include "GenericTracking/Workflow/DataSpecs.h"
+#include "GenericTracking/Workflow/GridConfig.h"
+#include "GenericTracking/Workflow/RecoParam.h"
+
+#include "CommonConstants/LHCConstants.h"
+#include "CommonUtils/StringUtils.h"
+#include "DetectorsRaw/HBFUtils.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/Logger.h"
+#include "Framework/Task.h"
+#include "Framework/TimingInfo.h"
+#include "SimulationDataFormat/DigitizationContext.h"
+#include "Steer/MCKinematicsReader.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <random>
+#include <ranges>
+#include <string>
+#include <vector>
+
+using namespace o2::framework;
+
+namespace o2::gtrk::study
+{
+
+namespace
+{
+
+/// splitmix64's finaliser: a mix, not a generator.  Cheap, stateless, and it
+/// decorrelates the small consecutive integers an identity is made of.
+[[nodiscard]] constexpr std::uint64_t mix64(std::uint64_t x)
+{
+  x += 0x9e3779b97f4a7c15ULL;
+  x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9ULL;
+  x = (x ^ (x >> 27)) * 0x94d049bb133111ebULL;
+  return x ^ (x >> 31);
+}
+
+/// Fold a run seed and a collision's index into one seed.
+[[nodiscard]] constexpr std::uint64_t seedFrom(std::uint64_t seed, std::size_t collision) { return mix64(mix64(seed) ^ static_cast<std::uint64_t>(collision)); }
+
+/// Reads truth only at this workflow boundary and publishes the VertexSeed
+/// payload the own vertexer's list has too (GTRKReco<DET>.vertexer).
+template <DetectorLayout Det>
+class MCVertexReaderTask : public Task
+{
+ public:
+  void init(InitContext& ic) final
+  {
+    const auto& param = MCVertexParam::Instance();
+    if (!std::isfinite(param.sigmaZ) || !std::isfinite(param.sigmaTransverse) || param.sigmaZ < 0. || param.sigmaTransverse < 0.) {
+      LOG(fatal) << "GTRKMCVertex: the smearing sigmas must be finite and non-negative";
+      return;
+    }
+    const auto filename = o2::utils::Str::concat_string(o2::utils::Str::rectifyDirectory(ic.options().get<std::string>("input-dir")), ic.options().get<std::string>("collision-context"));
+    mContext.reset(o2::steer::DigitizationContext::loadFromFile(filename));
+    if (!mContext) {
+      LOGP(fatal, "cannot load collision context from {}", filename);
+      return;
+    }
+    if (mContext->getEventRecords().size() != mContext->getEventParts().size()) {
+      LOGP(fatal, "collision context has {} records but {} event-part lists", mContext->getEventRecords().size(), mContext->getEventParts().size());
+      return;
+    }
+    if (!std::ranges::is_sorted(mContext->getEventRecords(), {}, [](const auto& record) { return record.getTimeNS(); })) {
+      LOG(fatal) << "collision times are not sorted";
+      return;
+    }
+
+    mKinematics = std::make_unique<o2::steer::MCKinematicsReader>(mContext.get());
+    if (!mKinematics->isInitialized()) {
+      LOGP(fatal, "cannot open MC kinematics referenced by {}", filename);
+      return;
+    }
+  }
+
+  void run(ProcessingContext& pc) final
+  {
+    const auto& param = MCVertexParam::Instance();
+    const auto& timing = pc.services().get<TimingInfo>();
+    const double startNS = static_cast<double>(timing.firstTForbit) * o2::constants::lhc::LHCOrbitNS;
+    // The simulation's timeframes, which cut the collision context.
+    const double endNS = startNS + (1.e-3 * static_cast<double>(workflow::timeframeDurationPS(o2::raw::HBFUtils::Instance().getNOrbitsPerTF())));
+    const auto& records = mContext->getEventRecords();
+    const auto& parts = mContext->getEventParts();
+    const auto first = std::ranges::lower_bound(records, startNS, {}, [](const auto& record) { return record.getTimeNS(); });
+    const auto last = std::ranges::lower_bound(first, records.end(), endNS, {}, [](const auto& record) { return record.getTimeNS(); });
+
+    std::vector<VertexSeed> vertices;
+    vertices.reserve(static_cast<std::size_t>(last - first));
+    const auto varZ = static_cast<Scalar>(param.sigmaZ * param.sigmaZ);
+    const auto varTransverse = static_cast<Scalar>(param.sigmaTransverse * param.sigmaTransverse);
+
+    for (auto record = first; record != last; ++record) {
+      const auto collision = static_cast<std::size_t>(record - records.begin());
+      if (parts[collision].empty()) {
+        LOGP(fatal, "collision {} has no MC event part", collision);
+        return;
+      }
+      const auto& part = parts[collision].front();
+      const auto& header = mKinematics->getMCEventHeader(part.sourceID, part.entryID);
+
+      // Per-collision seeding keeps the result independent of scheduling,
+      // skipped timeframes and the order in which devices are run.
+      std::mt19937_64 generator(seedFrom(param.randomSeed, collision));
+      std::normal_distribution<double> normal;
+      const double zSmear = normal(generator);
+
+      // The collision's time, a box of width 0.
+      constexpr double kPSPerNS = 1.e3;
+      const auto timePS = std::max<std::int64_t>(std::llround((record->getTimeNS() - startNS) * kPSPerNS), 0);
+      const VertexSeed vertex{
+        .timePS = static_cast<std::uint32_t>(timePS),
+        .widthPS = 0U,
+        .z = static_cast<Scalar>(header.GetZ() + param.sigmaZ * zSmear),
+        .varZ = varZ,
+        .varTransverse = varTransverse,
+      };
+      vertices.push_back(vertex);
+    }
+    std::ranges::sort(vertices, {}, &VertexSeed::timePS);
+
+    pc.outputs().snapshot(Output{workflow::gDataOrigin, workflow::description<Det>(workflow::kVertices), 0}, vertices);
+    LOGP(info, "published {} MC vertex seeds for TF {} starting at orbit {}", vertices.size(), timing.tfCounter, timing.firstTForbit);
+  }
+
+ private:
+  std::unique_ptr<o2::steer::DigitizationContext> mContext;
+  std::unique_ptr<o2::steer::MCKinematicsReader> mKinematics;
+};
+
+} // namespace
+
+template <DetectorLayout Det>
+DataProcessorSpec getMCVertexReaderSpec()
+{
+  // The clusters only trigger each timeframe; their content is not read.
+  return DataProcessorSpec{
+    .name = workflow::deviceName<Det>("mc-vertex-reader"),
+    .inputs = Inputs{InputSpec{"clusters", workflow::gDataOrigin, workflow::description<Det>(workflow::kClusters), 0, Lifetime::Timeframe}},
+    .outputs = Outputs{OutputSpec{workflow::gDataOrigin, workflow::description<Det>(workflow::kVertices), 0, Lifetime::Timeframe}},
+    .algorithm = AlgorithmSpec{adaptFromTask<MCVertexReaderTask<Det>>()},
+    .options = Options{{"collision-context", VariantType::String, "collisioncontext.root", {"collision context and MC-event mapping"}}, {"input-dir", VariantType::String, "none", {"input directory"}}},
+  };
+}
+
+template DataProcessorSpec getMCVertexReaderSpec<detectors::ITS>();
+template DataProcessorSpec getMCVertexReaderSpec<detectors::MFT>();
+template DataProcessorSpec getMCVertexReaderSpec<detectors::TRKFT3>();
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/src/MeasurementSinkSpec.cxx b/Detectors/GenericTracking/study/src/MeasurementSinkSpec.cxx
new file mode 100644
index 0000000000000..48088f1403cf7
--- /dev/null
+++ b/Detectors/GenericTracking/study/src/MeasurementSinkSpec.cxx
@@ -0,0 +1,4329 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Study/MCVertexReaderSpec.h"
+#include "GenericTracking/Study/Digest.h"
+#include "GenericTracking/Study/MeasurementSinkSpec.h"
+
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Base/LayerLinks.h"
+#include "GenericTracking/Study/Alice/Hits.h"
+#include "GenericTracking/Study/Alice/Tracks.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/MeasurementGridBuilder.h"
+#include "GenericTracking/Tracking/LayerMaterial.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/SlicePlan.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/Tracker.h"
+#include "GenericTracking/Study/Validation.h"
+#include "GenericTracking/Tracking/VertexingPass.h"
+#include "GenericTracking/Study/VertexQA.h"
+#include "GenericTracking/Workflow/DataSpecs.h"
+#include "GenericTracking/Workflow/BeamLine.h"
+#include "GenericTracking/Workflow/Conditions.h"
+#include "GenericTracking/Workflow/ConditionsTRK.h"
+#include "GenericTracking/Workflow/TrackingInterface.h"
+#include "GenericTracking/Workflow/TrackerSpec.h"
+#include "GenericTracking/Study/TrackComparison.h"
+#include "GenericTracking/Study/TrackPulls.h"
+#include "GenericTracking/Workflow/GridConfig.h"
+#include "GenericTracking/Study/MCTruth.h"
+#include "GenericTracking/Workflow/RecoParam.h"
+#include "GenericTracking/Study/StageFunnel.h"
+#include "GenericTracking/Study/ProfileReport.h"
+#include "GenericTracking/Study/Statistics.h"
+#include "GenericTracking/Study/TrackingInput.h"
+#include "GenericTracking/Study/SpeciesOracle.h"
+#include "GenericTracking/Study/TrackingQA.h"
+
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/EndOfStreamContext.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/Logger.h"
+#include "Framework/Task.h"
+#include "Framework/TimingInfo.h"
+#include "SimulationDataFormat/ConstMCTruthContainer.h"
+#include "SimulationDataFormat/DigitizationContext.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTrack.h"
+#include "SimulationDataFormat/O2DatabasePDG.h"
+#include "Steer/MCKinematicsReader.h"
+
+#include "CommonUtils/StringUtils.h"
+#include "CommonUtils/TreeStreamRedirector.h"
+
+#include <fmt/format.h>
+#include <gsl/span>
+
+#include <algorithm>
+#include <array>
+#include <initializer_list>
+#include <bit>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <fstream>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <numbers>
+#include <numeric>
+#include <optional>
+#include <memory>
+#include <ranges>
+#include <span>
+#include <stdexcept>
+#include <tuple>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+using namespace o2::framework;
+
+namespace o2::gtrk::study
+{
+
+namespace
+{
+
+// The sink is compiled once per detector, which GTRK_SINK_DETECTOR names
+// (CMakeLists.txt): everything below is bound to it through this one alias.
+#ifndef GTRK_SINK_DETECTOR
+#error "GTRK_SINK_DETECTOR names the sink's detector"
+#endif
+using Det = detectors::GTRK_SINK_DETECTOR;
+using Frame = TimeFrame<Det>;
+using Tracklets = StageOutput<TrackletT>;
+using Controller = workflow::TrackingInterface<Det>::Controller;
+/// The stage funnel of a tracker's own run (StageFunnel.h), read by the text
+/// reports per iteration.
+using Funnel = StageFunnel<Det, Controller>;
+
+/// One tracklet's bytes across its columns.
+constexpr std::size_t kTrackletBytes = Tracklet{}.apply([](const auto&... field) { return (sizeof(field) + ... + 0U); });
+constexpr std::size_t kCountBins = 20U;
+constexpr std::array<Scalar, 13> kPtEdges{0.F, 0.1F, 0.2F, 0.3F, 0.5F, 1.F, 1.25F, 1.5F, 2.F, 3.F, 5.F, 10.F, std::numeric_limits<Scalar>::infinity()};
+constexpr std::array<Scalar, 17> kCotThetaEdges{-std::numeric_limits<Scalar>::infinity(), -3.F, -2.F, -1.5F, -1.F, -0.75F, -0.5F, -0.25F, 0.F, 0.25F, 0.5F, 0.75F, 1.F, 1.5F, 2.F, 3.F, std::numeric_limits<Scalar>::infinity()};
+constexpr std::size_t kPtBins = kPtEdges.size() - 1U;
+constexpr std::size_t kCotThetaBins = kCotThetaEdges.size() - 1U;
+using TruthBreakdown = std::array<std::array<std::array<std::uint64_t, kCotThetaBins>, kPtBins>, nLinks<Det>>;
+
+struct TrackletRunSummary {
+  std::uint64_t sources = 0U;
+  std::uint64_t tracklets = 0U;
+  std::uint64_t haloSourceTracklets = 0U;
+  std::uint64_t haloTriplets = 0U;
+  std::array<std::uint64_t, kCountBins> countHistogram{};
+  std::uint32_t maxPerSource = 0U;
+  std::size_t trackletHighWater = 0U;
+  std::size_t stagingHighWater = 0U;
+  std::size_t stagingPredictionMisses = 0U;
+  std::size_t poolHighWater = 0U;
+  std::array<std::uint64_t, nLinks<Det>> truePairs{};
+  std::array<std::uint64_t, nLinks<Det>> truePairsKept{};
+  TruthBreakdown truthBreakdown{};
+  TruthBreakdown truthBreakdownKept{};
+  // Triplets: a true triplet is two MC-true pairs (a, b) and (b, c) of one
+  // particle, a row being every particle's it carries among its labels.
+  std::uint64_t firstTracklets = 0U;
+  std::uint64_t triplets = 0U;
+  std::uint64_t trueTriplets = 0U;
+  std::uint64_t trueTripletsPairsKept = 0U; ///< both pairs kept as tracklets
+  std::uint64_t trueTripletsKept = 0U;
+  std::uint64_t trueTripletsKinked = 0U; ///< of them, kept only with the kink allowance
+  std::uint64_t tripletsKinked = 0U;     ///< all core-owned triplets kept only with it
+  std::array<std::uint64_t, kPtBins> trueTripletsPairsKeptByPt{};
+  std::array<std::uint64_t, kPtBins> trueTripletsKeptByPt{};
+  double curvaturePullSum = 0.;
+  double curvaturePullSum2 = 0.;
+  double curvatureResidualSum2 = 0.; ///< relative to the MC curvature
+  // The same pull by the particle's pT: the triplet's scattering is taken at
+  // pT_min, so above it the pull's rms falls below 1 by design.
+  std::array<double, kPtBins> curvaturePullSumByPt{};
+  std::array<double, kPtBins> curvaturePullSum2ByPt{};
+  std::size_t tripletHighWater = 0U;
+  // What the triplets that are not MC-true are.
+  std::uint64_t notTrueCombinatorial = 0U; ///< a, b, c not one particle
+  std::uint64_t notTrueSecondary = 0U;
+  std::uint64_t notTrueSoftPrimary = 0U;  ///< a primary below the iteration's pT_min
+  std::uint64_t notTrueOtherPrimary = 0U; ///< a primary above it, off its first pass or not consecutive
+  // Neighbours, each owned by the slice whose core holds its first
+  // measurement. A true neighbour is two true triplets (a, b, c), (b, c, d).
+  std::uint64_t neighbours = 0U;
+  std::uint64_t trueNeighbours = 0U;
+  std::uint64_t trueNeighboursTripletsKept = 0U; ///< both true triplets kept
+  std::uint64_t trueNeighboursKept = 0U;
+  std::array<std::uint64_t, kPtBins> trueNeighboursTripletsKeptByPt{};
+  std::array<std::uint64_t, kPtBins> trueNeighboursKeptByPt{};
+  std::array<std::uint64_t, kCotThetaBins> trueNeighboursTripletsKeptByCot{};
+  std::array<std::uint64_t, kCotThetaBins> trueNeighboursKeptByCot{};
+  std::uint64_t neighboursNotTrueCombinatorial = 0U;
+  std::uint64_t neighboursNotTrueSecondary = 0U;
+  std::uint64_t neighboursNotTrueSoftPrimary = 0U;
+  std::uint64_t neighboursNotTrueOtherPrimary = 0U;
+  std::array<std::uint64_t, kCountBins> neighbourHistogram{}; ///< predecessors per core-owned triplet
+  std::uint32_t maxNeighbours = 0U;
+  // Per MC track, the highest level of its kept true triplets against the
+  // longest chain of them the true neighbours allow, by that length.
+  std::array<std::uint64_t, 12> tracksByChain{};
+  std::array<std::uint64_t, 12> tracksReachingChain{};
+  std::array<std::uint64_t, 12> tracksBelowChain{};
+  std::array<std::uint64_t, 12> tracksAboveChain{};
+  std::uint64_t tripletsWorked = 0U; ///< core and halo, summed over the slices
+  std::uint64_t chained = 0U;        ///< of those, swept: with a predecessor
+  std::uint64_t slices = 0U;
+  std::size_t neighbourHighWater = 0U;
+};
+
+/// A true triplet as the owning slice found it.
+struct TrueTripletState {
+  bool kept = false;
+  std::uint32_t level = 0U;
+};
+
+struct TruePair {
+  std::uint64_t key = 0U;
+  std::uint64_t particle = 0U; ///< whose pair it is (MCCompLabel::getTrackEventSourceID)
+  std::uint16_t link = 0U;
+  Scalar pt = 0.F;       ///< of the MC track [GeV]
+  Scalar cotTheta = 0.F; ///< pz / pT of the MC track at its origin
+  Scalar originR = 0.F;  ///< transverse distance of the MC track's origin from the beam [cm]
+};
+
+/// The longest MC-true chain along a pair: one particle's pairs joined end
+/// to start, its length in clusters up to the pair's target, and the pair
+/// before it on it.
+struct TrueChain {
+  static constexpr std::size_t kNoPair = std::numeric_limits<std::size_t>::max();
+  std::uint32_t length = 2U;
+  std::size_t previous = kNoPair;
+};
+
+/// Each of \a pairs' (in key order) longest chain.
+[[nodiscard]] inline std::vector<TrueChain> trueChains(std::span<const TruePair> pairs)
+{
+  std::vector<TrueChain> chains(pairs.size());
+  for (bool changed = true; changed;) {
+    changed = false;
+    for (std::size_t pair = 0; pair < pairs.size(); ++pair) {
+      const auto target = pairs[pair].key & 0xffffffffU;
+      const auto next = std::ranges::lower_bound(pairs, target << 32U, {}, &TruePair::key);
+      for (auto at = next; at != pairs.end() && (at->key >> 32U) == target; ++at) {
+        const auto successor = static_cast<std::size_t>(at - pairs.begin());
+        if (at->particle == pairs[pair].particle && chains[pair].length + 1U > chains[successor].length) {
+          chains[successor] = {.length = chains[pair].length + 1U, .previous = pair};
+          changed = true;
+        }
+      }
+    }
+  }
+  return chains;
+}
+
+template <std::size_t N>
+[[nodiscard]] std::size_t binOf(Scalar value, const std::array<Scalar, N>& edges)
+{
+  const auto upper = std::ranges::upper_bound(edges, value);
+  if (upper == edges.begin()) {
+    return 0U;
+  }
+  return std::min<std::size_t>(static_cast<std::size_t>(upper - edges.begin() - 1), N - 2U);
+}
+
+/// One MC-true kept triplet's curvature pull and relative residual, overall
+/// and in its particle's pT bin.
+void addCurvaturePull(TrackletRunSummary& summary, Scalar pt, double pull, double relativeResidual)
+{
+  summary.curvaturePullSum += pull;
+  summary.curvaturePullSum2 += pull * pull;
+  summary.curvaturePullSumByPt[binOf(pt, kPtEdges)] += pull;
+  summary.curvaturePullSum2ByPt[binOf(pt, kPtEdges)] += pull * pull;
+  summary.curvatureResidualSum2 += relativeResidual * relativeResidual;
+}
+
+/// The MC-true kept triplets' curvature pulls, overall and by pT.
+void logTripletCurvature(const TrackletRunSummary& summary)
+{
+  const auto count = static_cast<double>(summary.trueTripletsKept);
+  if (count > 0.) {
+    const double mean = summary.curvaturePullSum / count;
+    LOGP(info, "  curvature against MC 1/R(p): pull mean {:.3f}, rms {:.3f}; relative residual rms {:.4f}", mean, std::sqrt(std::max(summary.curvaturePullSum2 / count - (mean * mean), 0.)), std::sqrt(summary.curvatureResidualSum2 / count));
+    std::string pullByPt;
+    for (std::size_t bin = 1; bin < kPtBins; ++bin) {
+      const auto inBin = static_cast<double>(summary.trueTripletsKeptByPt[bin]);
+      if (inBin > 0.) {
+        const double binMean = summary.curvaturePullSumByPt[bin] / inBin;
+        pullByPt += fmt::format(" {}-{}: {:.2f} ({:.2f})", kPtEdges[bin], kPtEdges[bin + 1U], binMean, std::sqrt(std::max(summary.curvaturePullSum2ByPt[bin] / inBin - (binMean * binMean), 0.)));
+      }
+    }
+    LOGP(info, "    by pT [GeV], pull mean (rms), the scattering at pT_min:{}", pullByPt);
+  }
+}
+
+[[nodiscard]] std::size_t countBin(std::uint32_t count)
+{
+  if (count < 16U) {
+    return count;
+  }
+  if (count < 32U) {
+    return 16U;
+  }
+  if (count < 64U) {
+    return 17U;
+  }
+  if (count < 128U) {
+    return 18U;
+  }
+  return 19U;
+}
+
+/// One true crossing of a layer by a particle, from the MC hits (Hits.h): the
+/// chip segment's midpoint, the momentum entering it and the particle's mass.
+struct TrueCrossing {
+  std::uint32_t layer = 0U;
+  Frame::Index row = 0U; ///< the cluster the crossing made
+  std::array<double, 3> position{};
+  std::array<double, 3> momentum{};
+  double mass = 0.;
+  int pdg = 0;
+};
+
+/// A particle's crossings of its rows' chips, in layer order; empty without
+/// the hits, or where one row has no crossing.
+using TrueCrossings = std::function<std::vector<TrueCrossing>(std::uint64_t particle, std::span<const Frame::Index> rows)>;
+
+/// What the MC hits say of one crossing (for the tracks still found
+/// shorter): how far the particle's cluster sits from where it
+/// crossed, how hard it had scattered on the way from the previous crossing,
+/// and its pT there.
+struct TrueCrossingReport {
+  std::uint32_t layer = 0U;
+  /// The space angle between the momentum entering this layer and the helix
+  /// continued from the previous crossing, over the previous layer's Highland
+  /// theta0 at the true momentum: Rayleigh with unit scale for the model's
+  /// Gaussian core, so 5 is a hard scatter (P = 4e-6). NaN on the first
+  /// crossing.
+  double kink = std::numeric_limits<double>::quiet_NaN();
+  /// The same angle over theta0 from the LUT's x/X0 along the straight path
+  /// between the two crossings: what the material actually crossed allows,
+  /// against the model's per-layer attribution. NaN without a LUT.
+  double kinkPath = std::numeric_limits<double>::quiet_NaN();
+  double pathX2X0 = 0.;         ///< the LUT's x/X0 along that path
+  double pathNormalX2X0 = 0.;   ///< the same at normal incidence: over the path factor at the previous crossing
+  std::uint32_t scatterer = 0U; ///< the layer the kink is attributed to: the previous crossing's
+  double offsetCM = 0.;         ///< the cluster's distance from the crossing, the larger of r-phi and z
+  double pt = 0.;               ///< entering the layer [GeV]
+  double z = 0.;                ///< of the crossing [cm]
+  int pdg = 0;
+};
+
+/// \a crossings' reports, one per layer (a second crossing of the same layer,
+/// in a stave overlap, is skipped).
+std::vector<TrueCrossingReport> trueAnatomy(const Frame& frame, const ScatteringTable<Det>& scattering, double bzKiloGauss, std::span<const TrueCrossing> crossings, const o2::base::MatLayerCylSet* lut = nullptr)
+{
+  std::vector<TrueCrossingReport> result;
+  const TrueCrossing* previous = nullptr;
+  for (const auto& crossing : crossings) {
+    if (previous != nullptr && previous->layer == crossing.layer) {
+      continue;
+    }
+    const auto m = frame.measurement(crossing.row);
+    const auto& position = crossing.position;
+    const auto& p = crossing.momentum;
+    TrueCrossingReport report{.layer = crossing.layer, .pt = std::hypot(p[0], p[1]), .z = position[2], .pdg = crossing.pdg};
+    {
+      const double r = std::hypot(position[0], position[1]);
+      const double dx = static_cast<double>(m.x) - position[0];
+      const double dy = static_cast<double>(m.y) - position[1];
+      const double across = r > 0. ? ((position[0] * dy) - (position[1] * dx)) / r : std::hypot(dx, dy);
+      report.offsetCM = std::max(std::abs(across), std::abs(static_cast<double>(m.z) - position[2]));
+    }
+    if (previous != nullptr) {
+      const auto& pa = previous->momentum;
+      const double ptA = std::hypot(pa[0], pa[1]);
+      const double pA = std::hypot(ptA, pa[2]);
+      const double pB = std::hypot(report.pt, p[2]);
+      if (ptA > 0. && pA > 0. && pB > 0.) {
+        // The helix from the previous crossing turns by the angle its chord
+        // subtends, towards the side the chord lies on; the dip stays.
+        const double cx = position[0] - previous->position[0];
+        const double cy = position[1] - previous->position[1];
+        const double chord = std::hypot(cx, cy);
+        const double radius = curvatureRadius(ptA, bzKiloGauss);
+        const double alpha = radius > 0. && std::isfinite(radius) ? 2. * std::asin(std::min(chord / (2. * radius), 1.)) : 0.;
+        const double sign = (pa[0] * cy) - (pa[1] * cx) >= 0. ? 1. : -1.;
+        const double phi = std::atan2(pa[1], pa[0]) + (sign * alpha);
+        const double lambda = std::atan2(pa[2], ptA);
+        const std::array<double, 3> expected{std::cos(lambda) * std::cos(phi), std::cos(lambda) * std::sin(phi), std::sin(lambda)};
+        const std::array<double, 3> actual{p[0] / pB, p[1] / pB, p[2] / pB};
+        const double dot = (expected[0] * actual[0]) + (expected[1] * actual[1]) + (expected[2] * actual[2]);
+        const std::array<double, 3> cross{(expected[1] * actual[2]) - (expected[2] * actual[1]), (expected[2] * actual[0]) - (expected[0] * actual[2]), (expected[0] * actual[1]) - (expected[1] * actual[0])};
+        const double angle = std::atan2(std::hypot(cross[0], cross[1], cross[2]), dot);
+        // Highland's theta0 for the previous layer at the true momentum and
+        // incidence: k x (path factor) / (beta p)^2.
+        const auto id = static_cast<LayerID>(previous->layer);
+        const double rPrevious = std::hypot(previous->position[0], previous->position[1]);
+        double normal = std::abs(pa[2]);
+        if (Detector<Det>::isBarrelLayer(id)) {
+          normal = rPrevious > 0. ? std::abs((pa[0] * previous->position[0]) + (pa[1] * previous->position[1])) / rPrevious : ptA;
+        }
+        const double pathFactor = normal > 0. ? pA / normal : 1.;
+        const double beta = pA / std::hypot(pA, previous->mass);
+        // NOLINTNEXTLINE(clang-analyzer-security.ArrayBound): a hit's layer is one of Det's
+        const double theta0 = std::sqrt(static_cast<double>(scattering.layers[previous->layer].k) * pathFactor) / (beta * pA);
+        report.kink = theta0 > 0. ? angle / theta0 : 0.;
+        report.scatterer = previous->layer;
+        if (lut != nullptr) {
+          // The LUT along the straight path between the two crossings; its
+          // x/X0 is the path's own, so no path factor.
+          const auto budget = lut->getMatBudget(static_cast<float>(previous->position[0]), static_cast<float>(previous->position[1]), static_cast<float>(previous->position[2]), static_cast<float>(position[0]), static_cast<float>(position[1]), static_cast<float>(position[2]));
+          report.pathX2X0 = static_cast<double>(budget.meanX2X0);
+          report.pathNormalX2X0 = report.pathX2X0 / pathFactor;
+          const double theta0Path = std::sqrt(detail::highlandFactor(report.pathX2X0)) / (beta * pA);
+          report.kinkPath = theta0Path > 0. ? angle / theta0Path : 0.;
+        }
+      }
+    }
+    result.push_back(report);
+    previous = &crossing;
+  }
+  return result;
+}
+
+/// The bins the kinks are reported in: a Rayleigh of unit scale puts 39.3 %
+/// below 1, 86.5 % below 2, 98.9 % below 3; 5 and beyond is a hard scatter.
+constexpr std::array<double, 6> kKinkEdges{0., 1., 2., 3., 5., 10.};
+constexpr double kHardKink = 5.;
+constexpr double kTailKink = 3.;
+[[nodiscard]] std::size_t kinkBin(double kink)
+{
+  std::size_t bin = 0U;
+  for (std::size_t i = 1; i < kKinkEdges.size(); ++i) {
+    if (kink >= kKinkEdges[i]) {
+      bin = i;
+    }
+  }
+  return bin;
+}
+[[nodiscard]] std::string kinkBinsLine(std::span<const std::uint64_t> counts)
+{
+  std::string line;
+  for (std::size_t bin = 0; bin < kKinkEdges.size(); ++bin) {
+    const auto upper = bin + 1U < kKinkEdges.size() ? fmt::format("{:.0f}", kKinkEdges[bin + 1U]) : std::string{"inf"};
+    line += fmt::format(" [{:.0f},{}) {}", kKinkEdges[bin], upper, counts[bin]);
+  }
+  return line;
+}
+
+/// A cluster this far from its crossing [cm] is off it: six pixel sigmas.
+constexpr double kOffsetCM = 0.003;
+
+/// Every primary's MC-true pairs: consecutive layers of its first outward
+/// pass, a row being every particle's it carries among its labels (\a rows,
+/// the comparison's truth). A pair carried by two particles is the first's.
+/// \a mcOf: a particle's MC track, by id.
+template <typename McOf>
+[[nodiscard]] std::vector<TruePair> mcTruePairs(const Frame& frame, std::span<const TruthRow> rows, const McOf& mcOf, const Geometry<Det>& geometry, const RecoSettings& param, double bzKiloGauss)
+{
+  struct SignalRow {
+    std::uint64_t track = 0U;
+    Frame::Index row = 0U;
+  };
+
+  std::vector<SignalRow> signalRows;
+  signalRows.reserve(frame.size() / 4U);
+  for (Frame::Index row = 0U; row < frame.size(); ++row) {
+    for (std::uint8_t i = 0; i < rows[row].count; ++i) {
+      signalRows.push_back({.track = rows[row].particles[i], .row = row});
+    }
+  }
+  std::ranges::stable_sort(signalRows, {}, &SignalRow::track);
+
+  // Down to the lowest iteration's pT_min: every particle some iteration is for.
+  double minPtGeV = workflow::iterationSettings(param, 0).windows.minPtGeV;
+  for (int iteration = 1; iteration < workflow::iterationCount(param); ++iteration) {
+    minPtGeV = std::min(minPtGeV, workflow::iterationSettings(param, iteration).windows.minPtGeV);
+  }
+  std::vector<Frame::Index> firstPass;
+  std::vector<TruePair> result;
+  for (std::size_t begin = 0; begin < signalRows.size();) {
+    std::size_t end = begin + 1U;
+    while (end < signalRows.size() && signalRows[end].track == signalRows[begin].track) {
+      ++end;
+    }
+    const auto* mc = mcOf(signalRows[begin].track);
+    if (mc == nullptr || !mc->isPrimary() || mc->GetPt() < minPtGeV) {
+      begin = end;
+      continue;
+    }
+
+    firstPass.clear();
+    for (std::size_t at = begin; at < end; ++at) {
+      const auto row = signalRows[at].row;
+      const auto measurement = frame.measurement(row);
+      const auto layer = geometry.sensor(measurement.surface).layer;
+      if (onFirstOutwardPass<Det>(*mc, layer, measurement.phi, secondCoordinate<Det>(layer, measurement.r, measurement.z), bzKiloGauss)) {
+        firstPass.push_back(row);
+      }
+    }
+    const auto distance = [&](Frame::Index row) {
+      const auto measurement = frame.measurement(row);
+      return std::hypot(static_cast<double>(measurement.x) - mc->Vx(), static_cast<double>(measurement.y) - mc->Vy(), static_cast<double>(measurement.z) - mc->Vz());
+    };
+    std::ranges::sort(firstPass, {}, distance);
+
+    for (std::size_t from = 0; from < firstPass.size();) {
+      const auto layerOf = [&](std::size_t at) { return geometry.sensor(frame.measurement(firstPass[at]).surface).layer; };
+      const auto fromLayer = layerOf(from);
+      std::size_t fromEnd = from + 1U;
+      while (fromEnd < firstPass.size() && layerOf(fromEnd) == fromLayer) {
+        ++fromEnd;
+      }
+      if (fromEnd == firstPass.size()) {
+        break;
+      }
+      const auto toLayer = layerOf(fromEnd);
+      std::size_t toEnd = fromEnd + 1U;
+      while (toEnd < firstPass.size() && layerOf(toEnd) == toLayer) {
+        ++toEnd;
+      }
+      const auto link = linkOf<Det>(fromLayer, toLayer);
+      if (link != kNoLink) {
+        for (std::size_t source = from; source < fromEnd; ++source) {
+          for (std::size_t target = fromEnd; target < toEnd; ++target) {
+            result.push_back({
+              .key = pairKey(firstPass[source], firstPass[target]),
+              .particle = signalRows[begin].track,
+              .link = static_cast<std::uint16_t>(link),
+              .pt = static_cast<Scalar>(mc->GetPt()),
+              .cotTheta = static_cast<Scalar>(mc->GetStartVertexMomentumZ() / mc->GetPt()),
+              .originR = static_cast<Scalar>(std::hypot(mc->Vx(), mc->Vy())),
+            });
+          }
+        }
+      }
+      from = fromEnd;
+    }
+    begin = end;
+  }
+
+  std::ranges::stable_sort(result, {}, &TruePair::key);
+  const auto duplicates = std::ranges::unique(result, {}, &TruePair::key);
+  result.erase(duplicates.begin(), duplicates.end());
+  return result;
+}
+
+std::string histogramText(const std::array<std::uint64_t, kCountBins>& histogram)
+{
+  std::string result;
+  for (std::size_t bin = 0; bin < histogram.size(); ++bin) {
+    if (!result.empty()) {
+      result += ' ';
+    }
+    if (bin < 16U) {
+      result += std::to_string(bin);
+    } else if (bin == 16U) {
+      result += "16-31";
+    } else if (bin == 17U) {
+      result += "32-63";
+    } else if (bin == 18U) {
+      result += "64-127";
+    } else {
+      result += "128+";
+    }
+    result += ':';
+    result += std::to_string(histogram[bin]);
+  }
+  return result;
+}
+
+/// The species the reports split by: e, mu, pi, K, p and the others.
+inline constexpr std::size_t kSpeciesCount = 6U;
+
+/// A PDG code's species index (below kSpeciesCount).
+[[nodiscard]] std::size_t speciesOf(int pdg)
+{
+  switch (std::abs(pdg)) {
+    case 11:
+      return 0U;
+    case 13:
+      return 1U;
+    case 211:
+      return 2U;
+    case 321:
+      return 3U;
+    case 2212:
+      return 4U;
+    default:
+      return 5U;
+  }
+}
+
+/// The true pairs the tracklet stage lost, against the beam line: the first
+/// requirement of a tracklet each fails, by kind of link and pT; for the
+/// curvature and longitudinal cuts, how far beyond them (the pull), to see a
+/// tail's shape. Pairs on a link the iteration does not take (one that skips a
+/// layer, in an iteration without holes) cannot be found and are counted
+/// apart.
+/// The cut is the stage funnel's (pairCutLoss, StageFunnel.h).
+void reportLostPairs(const Frame& frame, const IterationParameters<Det>& parameters, const VertexSeed& beamLine, std::span<const TruePair> truePairs, const std::vector<bool>& pairKept, std::span<const TruthRow> rows, const TrueCrossings& crossings = {}, const ScatteringTable<Det>* scattering = nullptr, double bzKiloGauss = 0., double minPtGeV = 0., const o2::base::MatLayerCylSet* material = nullptr)
+{
+  if (!truePairs.empty()) {
+    // The pairs the two spatial cuts lost, for the MC hits' verdict below.
+    struct LostPair {
+      std::size_t pair;
+      std::size_t pullBin;
+      PairLoss reason;
+    };
+    std::vector<LostPair> lostSpatial;
+    constexpr auto kReasons = kPairLosses;
+    std::array<std::array<std::uint64_t, kReasons>, 3> byKind{}; // barrel-barrel, with a disc, disc-disc
+    std::array<std::array<std::uint64_t, kReasons>, kPtBins> byPt{};
+    std::array<std::uint64_t, 3> lostByKind{};
+    std::array<std::uint64_t, 3> pairsByKind{};
+    std::array<std::uint64_t, kPtBins> pairsByPt{};
+    std::array<std::uint64_t, kPtBins> keptByPt{};
+    std::uint64_t notTaken = 0U;
+    // Where the particle came from, transversely from the beam: a primary of
+    // a displaced decay is no track from the beam line.
+    constexpr std::array<Scalar, 6> kOriginEdges{0.F, 0.005F, 0.01F, 0.03F, 0.1F, std::numeric_limits<Scalar>::infinity()};
+    std::array<std::uint64_t, kOriginEdges.size() - 1U> originAll{};
+    std::array<std::uint64_t, kOriginEdges.size() - 1U> originCurvature{};
+    constexpr std::array<double, 6> kPullEdges{3., 4., 5., 7., 10., 20.};
+    std::array<std::uint64_t, kPullEdges.size()> longitudinalPulls{};
+    std::array<std::uint64_t, kPullEdges.size()> curvaturePulls{};
+    // The pairs lost to time: the target's box start less the source's, in
+    // source boxes, by the link's inner layer.
+    constexpr std::size_t kTickSlots = 7U; // <= -3, -2, -1, 0, 1, 2, >= 3
+    std::array<std::array<std::uint64_t, kTickSlots>, Frame::kLayerCount> timeTicksByLayer{};
+    for (std::size_t pair = 0; pair < truePairs.size(); ++pair) {
+      const auto& truth = truePairs[pair];
+      const auto from = Det::layerLinks[truth.link].from;
+      const auto to = Det::layerLinks[truth.link].to;
+      std::size_t kind = 1U;
+      if (Detector<Det>::isBarrelLayer(from) && Detector<Det>::isBarrelLayer(to)) {
+        kind = 0U;
+      } else if (!Detector<Det>::isBarrelLayer(from) && !Detector<Det>::isBarrelLayer(to)) {
+        kind = 2U;
+      }
+      if (!linkTaken(parameters, truth.link)) {
+        ++notTaken;
+        continue;
+      }
+      const auto ptBin = binOf(truth.pt, kPtEdges);
+      ++pairsByKind[kind];
+      ++pairsByPt[ptBin];
+      ++originAll[binOf(truth.originR, kOriginEdges)];
+      if (pairKept[pair]) {
+        ++keptByPt[ptBin];
+        continue;
+      }
+      ++lostByKind[kind];
+      const auto sourceIndex = static_cast<Frame::Index>(truth.key >> 32U);
+      const auto targetIndex = static_cast<Frame::Index>(truth.key & 0xffffffffU);
+      const auto verdict = pairCutLoss(frame, parameters, beamLine, truth.link, sourceIndex, targetIndex);
+      const auto reason = verdict.loss;
+      const auto& terms = verdict.terms;
+      const auto pullBin = [&](double pull, auto& histogram) {
+        std::size_t at = 0U;
+        for (std::size_t bin = kPullEdges.size(); bin-- > 0U;) {
+          if (pull >= kPullEdges[bin]) {
+            at = bin;
+            break;
+          }
+        }
+        ++histogram[at];
+        return at;
+      };
+      if (reason == PairLoss::kTime) {
+        // How many of the source's boxes apart the two start.
+        const auto sourceRow = frame.measurement(sourceIndex);
+        const auto targetRow = frame.measurement(targetIndex);
+        const auto ticks = std::lround((static_cast<double>(targetRow.timePS) - static_cast<double>(sourceRow.timePS)) / static_cast<double>(sourceRow.widthPS));
+        ++timeTicksByLayer[from][static_cast<std::size_t>(std::clamp<long>(ticks, -3L, 3L) + 3L)];
+      } else if (reason == PairLoss::kCurvature) {
+        ++originCurvature[binOf(truth.originR, kOriginEdges)];
+        const auto pullAt = pullBin((static_cast<double>(terms.curvature) - static_cast<double>(terms.bound)) / std::sqrt(static_cast<double>(terms.varCurvature)), curvaturePulls);
+        lostSpatial.push_back({.pair = pair, .pullBin = pullAt, .reason = reason});
+      } else if (reason == PairLoss::kLongitudinal) {
+        const auto pullAt = pullBin(std::sqrt(static_cast<double>(terms.collinearity2) / static_cast<double>(terms.varCollinearity)), longitudinalPulls);
+        lostSpatial.push_back({.pair = pair, .pullBin = pullAt, .reason = reason});
+      }
+      ++byKind[kind][static_cast<std::size_t>(reason)];
+      ++byPt[ptBin][static_cast<std::size_t>(reason)];
+    }
+    {
+      std::string ticksLine;
+      for (std::size_t layer = 0; layer < timeTicksByLayer.size(); ++layer) {
+        const auto& slots = timeTicksByLayer[layer];
+        if (std::accumulate(slots.begin(), slots.end(), std::uint64_t{0}) == 0U) {
+          continue;
+        }
+        ticksLine += fmt::format(" {}->: <=-3 {} -2 {} -1 {} 0 {} +1 {} +2 {} >=+3 {};", layer, slots[0], slots[1], slots[2], slots[3], slots[4], slots[5], slots[6]);
+      }
+      LOGP(info, "    true pairs lost to time, target less source in source boxes, by the link's inner layer:{}", ticksLine);
+    }
+    constexpr std::array<const char*, 3> kKindNames{"barrel-barrel", "with a disc", "disc-disc"};
+    const auto taken = std::accumulate(pairsByKind.begin(), pairsByKind.end(), std::uint64_t{0});
+    const auto lost = std::accumulate(lostByKind.begin(), lostByKind.end(), std::uint64_t{0});
+    LOGP(info, "  true pairs on the links the iteration takes: {}/{} found ({:.3f}%); {} more on links it does not take", taken - lost, taken, percent(taken - lost, taken), notTaken);
+    for (std::size_t kind = 0; kind < kKindNames.size(); ++kind) {
+      std::string reasons;
+      for (const auto reason : kPairCutLosses) {
+        reasons += fmt::format(" {} {}", kPairLossNames[static_cast<std::size_t>(reason)], byKind[kind][static_cast<std::size_t>(reason)]);
+      }
+      LOGP(info, "  true pairs lost, {:<13}: {}/{} ({:.3f}%):{}", kKindNames[kind], lostByKind[kind], pairsByKind[kind], percent(lostByKind[kind], pairsByKind[kind]), reasons);
+    }
+    for (std::size_t bin = 1; bin < kPtBins; ++bin) {
+      if (pairsByPt[bin] == 0U) {
+        continue;
+      }
+      std::string reasons;
+      for (const auto reason : kPairCutLosses) {
+        reasons += fmt::format(" {} {}", kPairLossNames[static_cast<std::size_t>(reason)], byPt[bin][static_cast<std::size_t>(reason)]);
+      }
+      LOGP(info, "    pT [{:.2f},{:.2f}): {}/{} found ({:.2f}%), {} lost:{}", kPtEdges[bin], kPtEdges[bin + 1U], keptByPt[bin], pairsByPt[bin], percent(keptByPt[bin], pairsByPt[bin]), pairsByPt[bin] - keptByPt[bin], reasons);
+    }
+    std::string longitudinal;
+    std::string curvature;
+    for (std::size_t bin = 0; bin < kPullEdges.size(); ++bin) {
+      const auto upper = bin + 1U < kPullEdges.size() ? fmt::format("{:.0f}", kPullEdges[bin + 1U]) : std::string{"inf"};
+      longitudinal += fmt::format(" [{:.0f},{}) {}", kPullEdges[bin], upper, longitudinalPulls[bin]);
+      curvature += fmt::format(" [{:.0f},{}) {}", kPullEdges[bin], upper, curvaturePulls[bin]);
+    }
+    std::string origins;
+    for (std::size_t bin = 0; bin < originAll.size(); ++bin) {
+      const auto upper = bin + 1U < originAll.size() ? fmt::format("{:.0f}", 1.e4 * static_cast<double>(kOriginEdges[bin + 1U])) : std::string{"inf"};
+      origins += fmt::format(" [{:.0f},{}) {}/{}", 1.e4 * static_cast<double>(kOriginEdges[bin]), upper, originCurvature[bin], originAll[bin]);
+    }
+    LOGP(info, "    origin radius [um] of the particle, pairs lost to the curvature cut / all:{}", origins);
+    LOGP(info, "    longitudinal pulls of those lost to it:{}", longitudinal);
+    LOGP(info, "    curvature pulls beyond the bound of those lost to it:{}", curvature);
+    // The MC hits' verdict on each lost pair: the particle scattered hard
+    // somewhere up to the target (a kink of 5 theta0 or more, theta0 of the
+    // material actually crossed where a LUT is loaded), a cluster of
+    // the pair sits off its crossing, the particle had slowed below the
+    // floor by the source -- or none of these, and the cut itself lost it.
+    if (crossings && scattering != nullptr && !lostSpatial.empty()) {
+      std::unordered_map<std::uint64_t, std::vector<Frame::Index>> rowsOf;
+      for (const auto& spatial : lostSpatial) {
+        rowsOf[truePairs[spatial.pair].particle];
+      }
+      for (Frame::Index row = 0U; row < frame.size() && row < rows.size(); ++row) {
+        for (std::uint8_t i = 0; i < rows[row].count; ++i) {
+          if (const auto found = rowsOf.find(rows[row].particles[i]); found != rowsOf.end()) {
+            found->second.push_back(row);
+          }
+        }
+      }
+      std::unordered_map<std::uint64_t, std::vector<TrueCrossingReport>> reportsOf;
+      for (auto& [id, particleRows] : rowsOf) {
+        reportsOf[id] = trueAnatomy(frame, *scattering, bzKiloGauss, crossings(id, particleRows), material);
+      }
+      enum Verdict : std::uint8_t { kVerdictKink,
+                                    kVerdictOff,
+                                    kVerdictSoft,
+                                    kVerdictDrop,
+                                    kVerdictDisplaced,
+                                    kVerdictNone,
+                                    kVerdictNoHits,
+                                    kVerdicts };
+      constexpr std::array<const char*, kVerdicts> kVerdictNames{"kink >= 5 theta0", "cluster off", "pT below the floor", "pT drops > 10 % on the link", "origin beyond 50 um", "none", "no hits"};
+      constexpr std::array<const char*, kSpeciesCount> kSpeciesNames{"e", "mu", "pi", "K", "p", "other"};
+      std::array<std::array<std::uint64_t, kSpeciesCount>, 2> noneBySpecies{};
+      std::array<std::array<std::array<std::uint64_t, kVerdicts>, kPullEdges.size()>, 2> byPull{}; // curvature, longitudinal
+      std::array<std::array<std::uint64_t, nLinks<Det>>, 2> noneByLink{};
+      std::array<std::array<std::uint64_t, Frame::kLayerCount>, 2> kinkAtScatterer{}; // the kinked ones: the layer that scattered them hardest
+      for (const auto& spatial : lostSpatial) {
+        const auto& truth = truePairs[spatial.pair];
+        const auto from = static_cast<std::uint32_t>(Det::layerLinks[truth.link].from);
+        const auto to = static_cast<std::uint32_t>(Det::layerLinks[truth.link].to);
+        const auto which = spatial.reason == PairLoss::kCurvature ? 0U : 1U;
+        Verdict verdict = kVerdictNoHits;
+        const auto found = reportsOf.find(truth.particle);
+        if (found != reportsOf.end() && !found->second.empty()) {
+          verdict = kVerdictNone;
+          double hardest = 0.;
+          std::uint32_t hardestAt = 0U;
+          bool off = false;
+          auto ptAtSource = static_cast<double>(truth.pt);
+          double ptAtTarget = ptAtSource;
+          int pdg = 0;
+          for (const auto& report : found->second) {
+            pdg = report.pdg;
+            if (report.layer > to) {
+              break;
+            }
+            const double kink = std::isfinite(report.kinkPath) ? report.kinkPath : report.kink;
+            if (std::isfinite(kink) && kink > hardest) {
+              hardest = kink;
+              hardestAt = report.scatterer;
+            }
+            if ((report.layer == from || report.layer == to) && report.offsetCM > kOffsetCM) {
+              off = true;
+            }
+            if (report.layer == from) {
+              ptAtSource = report.pt;
+            }
+            if (report.layer == to) {
+              ptAtTarget = report.pt;
+            }
+          }
+          if (hardest >= kHardKink) {
+            verdict = kVerdictKink;
+            ++kinkAtScatterer[which][hardestAt];
+          } else if (off) {
+            verdict = kVerdictOff;
+          } else if (ptAtSource < minPtGeV) {
+            verdict = kVerdictSoft;
+          } else if (ptAtTarget < 0.9 * ptAtSource) {
+            verdict = kVerdictDrop;
+          } else if (truth.originR > 0.005F) {
+            verdict = kVerdictDisplaced;
+          } else {
+            ++noneByLink[which][truth.link];
+            ++noneBySpecies[which][speciesOf(pdg)];
+          }
+        }
+        ++byPull[which][spatial.pullBin][verdict];
+      }
+      constexpr std::array<const char*, 2> kCutNames{"curvature", "longitudinal"};
+      for (std::size_t which = 0; which < 2U; ++which) {
+        std::string line;
+        for (std::size_t bin = 0; bin < kPullEdges.size(); ++bin) {
+          const auto upper = bin + 1U < kPullEdges.size() ? fmt::format("{:.0f}", kPullEdges[bin + 1U]) : std::string{"inf"};
+          line += fmt::format(" [{:.0f},{}):", kPullEdges[bin], upper);
+          for (std::size_t verdict = 0; verdict < kVerdicts; ++verdict) {
+            line += fmt::format(" {} {}", kVerdictNames[verdict], byPull[which][bin][verdict]);
+          }
+          line += ";";
+        }
+        LOGP(info, "    the MC hits on the pairs the {} cut lost, by pull:{}", kCutNames[which], line);
+        std::string links;
+        for (std::size_t link = 0; link < nLinks<Det>; ++link) {
+          if (noneByLink[which][link] != 0U) {
+            links += fmt::format(" {}->{}: {}", Det::layerLinks[link].from, Det::layerLinks[link].to, noneByLink[which][link]);
+          }
+        }
+        std::string scatterers;
+        for (std::size_t layer = 0; layer < Frame::kLayerCount; ++layer) {
+          if (kinkAtScatterer[which][layer] != 0U) {
+            scatterers += fmt::format(" {}: {}", layer, kinkAtScatterer[which][layer]);
+          }
+        }
+        std::string species;
+        for (std::size_t i = 0; i < kSpeciesNames.size(); ++i) {
+          species += fmt::format(" {} {}", kSpeciesNames[i], noneBySpecies[which][i]);
+        }
+        LOGP(info, "      none of these, by the link:{}, by species:{}; the kinked, by the layer that scattered them hardest:{}", links, species, scatterers);
+      }
+    }
+  }
+}
+
+/// One iteration of a tracker's own run against the MC truth, slice by slice
+/// as the run's observers see them: its
+/// tracklets, triplets and neighbours against the MC-true pairs, triplets and
+/// neighbours above the iteration's pT_min on the clusters it found free; the
+/// lost pairs' anatomy. A
+/// cluster is every particle's it carries among its labels (TruthRow), the
+/// rule of the comparison and the stage funnel.
+class StageTruth
+{
+ public:
+  /// At the iteration's first slice, with the used mask it read.
+  StageTruth(const Frame& frame, const Controller& tracker, std::size_t iteration, const RecoSettings& param, const Propagator& propagator, std::span<const TruePair> allPairs, std::span<const TruthRow> rows, const ParticleTable& particles, const ScatteringTable<Det>& scattering, const o2::base::MatLayerCylSet* material, const TrueCrossings& crossings)
+    : mFrame{&frame},
+      mParam{&param},
+      mIteration{iteration},
+      mSettings{workflow::iterationSettings(param, static_cast<int>(iteration))},
+      mParameters{tracker.iteration(iteration)},
+      mBeamLine{tracker.beamLine()},
+      mBzKiloGauss{propagator.bzKiloGauss},
+      mRows{rows},
+      mParticles{&particles},
+      mScattering{&scattering},
+      mMaterial{material},
+      mCrossings{&crossings},
+      mUsed(tracker.used().begin(), tracker.used().end()),
+      mInitialPredictionMisses{tracker.stagingPredictionMisses()}
+  {
+    auto& summary = mSummary;
+    for (const auto& pair : allPairs) {
+      if (static_cast<double>(pair.pt) >= mSettings.windows.minPtGeV && mUsed[pair.key >> 32U] == 0U && mUsed[pair.key & 0xffffffffU] == 0U) {
+        mTruePairs.push_back(pair);
+      }
+    }
+    const auto& truePairs = mTruePairs;
+    for (const auto& pair : truePairs) {
+      ++summary.truePairs[pair.link];
+      ++summary.truthBreakdown[pair.link][binOf(pair.pt, kPtEdges)][binOf(pair.cotTheta, kCotThetaEdges)];
+    }
+    // Every MC-true triplet, as the indices of its two pairs, one particle's,
+    // in truePairs.
+    for (std::size_t first = 0; first < truePairs.size(); ++first) {
+      const auto middle = static_cast<std::uint32_t>(truePairs[first].key & 0xffffffffU);
+      const auto next = std::ranges::lower_bound(truePairs, pairKey(middle, 0U), {}, &TruePair::key);
+      for (auto second = next; second != truePairs.end() && (second->key >> 32U) == middle; ++second) {
+        if (second->particle == truePairs[first].particle) {
+          mTrueTriplets.emplace_back(first, static_cast<std::size_t>(second - truePairs.begin()));
+        }
+      }
+    }
+    summary.trueTriplets = mTrueTriplets.size();
+    mPairKept.assign(truePairs.size(), false);
+    // Every MC-true neighbour, as the indices of its two triplets in
+    // trueTriplets; both lists are in lexicographic order.
+    for (std::size_t first = 0; first < mTrueTriplets.size(); ++first) {
+      const auto shared = mTrueTriplets[first].second;
+      const auto next = std::ranges::lower_bound(mTrueTriplets, std::pair<std::size_t, std::size_t>{shared, 0U});
+      for (auto second = next; second != mTrueTriplets.end() && second->first == shared; ++second) {
+        mTrueChains.emplace_back(first, static_cast<std::size_t>(second - mTrueTriplets.begin()));
+      }
+    }
+    summary.trueNeighbours = mTrueChains.size();
+    mTrueTripletStates.assign(mTrueTriplets.size(), TrueTripletState{});
+    mChainKept.assign(mTrueChains.size(), false);
+    if (!mRows.empty()) {
+      LOGP(info, "iteration {} in the run: {} MC-true pairs above {} GeV on the clusters it found free", mIteration, truePairs.size(), mSettings.windows.minPtGeV);
+    }
+  }
+
+  void observeSlice(const Controller& tracker, const Controller::SliceObservation& observation)
+  {
+    const auto& parameters = mParameters;
+    const auto& truePairs = mTruePairs;
+    const auto& trueTriplets = mTrueTriplets;
+    const auto& trueChains = mTrueChains;
+    auto& summary = mSummary;
+    auto& pairKept = mPairKept;
+    auto& trueTripletStates = mTrueTripletStates;
+    auto& chainKept = mChainKept;
+    const auto& slice = *observation.slice;
+    const auto& run = *observation.result;
+    const auto truePairIndex = [&](Frame::Index source, Frame::Index target) {
+      const auto key = pairKey(source, target);
+      const auto found = std::ranges::lower_bound(truePairs, key, {}, &TruePair::key);
+      return found != truePairs.end() && found->key == key ? static_cast<std::size_t>(found - truePairs.begin()) : truePairs.size();
+    };
+    const auto trueTripletIndex = [&](std::size_t firstPair, std::size_t secondPair) {
+      const std::pair<std::size_t, std::size_t> key{firstPair, secondPair};
+      const auto found = std::ranges::lower_bound(trueTriplets, key);
+      return found != trueTriplets.end() && *found == key ? static_cast<std::size_t>(found - trueTriplets.begin()) : trueTriplets.size();
+    };
+    // Core sources only: the halo rows are worked within the slice gate so the
+    // core's output does not depend on the slicing, and counting them would
+    // count them once per slice that reaches them.
+    const auto& sources = tracker.sources();
+    const auto counts = run.tracklets->counts();
+    for (Tracklets::Index element = 0U; element < run.tracklets->elementCount(); ++element) {
+      const auto at = sources.row(element);
+      const auto core = slice.core[at.layer];
+      if (at.row < core.begin || at.row >= core.end) {
+        continue;
+      }
+      ++summary.sources;
+      ++summary.countHistogram[countBin(counts[element])];
+      summary.maxPerSource = std::max(summary.maxPerSource, counts[element]);
+    }
+    const auto tracklets = run.tracklets->view();
+    for (Tracklets::Index i = 0U; i < run.tracklets->size(); ++i) {
+      const auto link = static_cast<std::size_t>(tracklets[i].link);
+      const LayerID sourceLayer = parameters.linkSources[link];
+      const auto core = slice.core[sourceLayer];
+      const bool coreSource = tracklets[i].source >= core.begin && tracklets[i].source < core.end;
+      if (!coreSource) {
+        ++summary.haloSourceTracklets;
+        continue;
+      }
+      ++summary.tracklets;
+      const auto key = pairKey(tracklets[i].source, tracklets[i].target);
+      const auto found = std::ranges::lower_bound(truePairs, key, {}, &TruePair::key);
+      if (found != truePairs.end() && found->key == key) {
+        ++summary.truePairsKept[link];
+        ++summary.truthBreakdownKept[link][binOf(found->pt, kPtEdges)][binOf(found->cotTheta, kCotThetaEdges)];
+        pairKept[static_cast<std::size_t>(found - truePairs.begin())] = true;
+      }
+    }
+
+    // Core-owned triplets only -- first measurement in the core -- which
+    // partitions them over the slices.
+    const auto& triplets = *run.triplets;
+    summary.firstTracklets += triplets.elementCount();
+    const auto tripletView = triplets.view();
+    for (Tracklets::Index i = 0U; i < triplets.size(); ++i) {
+      const auto first = tripletView.first[i];
+      const auto second = tripletView.second[i];
+      const auto firstCore = slice.core[parameters.linkSources[tracklets[first].link]];
+      if (tracklets[first].source < firstCore.begin || tracklets[first].source >= firstCore.end) {
+        ++summary.haloTriplets;
+        continue;
+      }
+      ++summary.triplets;
+      const bool kinkedTriplet = tripletView.kinked[i] != 0U;
+      summary.tripletsKinked += kinkedTriplet ? 1U : 0U;
+      const auto firstPair = std::ranges::lower_bound(truePairs, pairKey(tracklets[first].source, tracklets[first].target), {}, &TruePair::key);
+      const auto secondPair = std::ranges::lower_bound(truePairs, pairKey(tracklets[second].source, tracklets[second].target), {}, &TruePair::key);
+      const bool trueFirst = firstPair != truePairs.end() && firstPair->key == pairKey(tracklets[first].source, tracklets[first].target);
+      const bool trueSecond = secondPair != truePairs.end() && secondPair->key == pairKey(tracklets[second].source, tracklets[second].target);
+      if (!trueFirst || !trueSecond) {
+        classify({tracklets[first].source, tracklets[first].target, tracklets[second].target}, summary.notTrueCombinatorial, summary.notTrueSecondary, summary.notTrueSoftPrimary, summary.notTrueOtherPrimary);
+        continue;
+      }
+      ++summary.trueTripletsKept;
+      summary.trueTripletsKinked += kinkedTriplet ? 1U : 0U;
+      ++summary.trueTripletsKeptByPt[binOf(firstPair->pt, kPtEdges)];
+      const auto trueIndex = trueTripletIndex(static_cast<std::size_t>(firstPair - truePairs.begin()), static_cast<std::size_t>(secondPair - truePairs.begin()));
+      if (trueIndex < trueTriplets.size()) {
+        trueTripletStates[trueIndex] = {.kept = true, .level = tripletView.level[i]};
+      }
+      // The fit's curvature is the 3D one, 1/R at the momentum p.
+      const double momentum = static_cast<double>(firstPair->pt) * std::hypot(1., static_cast<double>(firstPair->cotTheta));
+      const double truth = 1. / curvatureRadius(momentum, mBzKiloGauss);
+      const double fitted = std::abs(static_cast<double>(tripletView.curvature[i]));
+      addCurvaturePull(summary, firstPair->pt, (fitted - truth) / std::sqrt(static_cast<double>(tripletView.varCurvature[i])), (fitted - truth) / truth);
+    }
+
+    // Neighbours: each edge is owned by the slice whose core holds its first
+    // measurement a; the predecessors per triplet by the triplet's owner.
+    const auto& neighbours = *run.neighbours;
+    const auto* const from = neighbours.view().from;
+    const auto neighbourOffsets = neighbours.offsets();
+    summary.tripletsWorked += triplets.size();
+    // The triplets with predecessors.
+    for (std::size_t triplet = 0; triplet + 1U < neighbourOffsets.size(); ++triplet) {
+      summary.chained += neighbourOffsets[triplet + 1U] != neighbourOffsets[triplet] ? 1U : 0U;
+    }
+    ++summary.slices;
+    const auto inCore = [&](Tracklets::Index tracklet) {
+      const auto core = slice.core[parameters.linkSources[tracklets[tracklet].link]];
+      return tracklets[tracklet].source >= core.begin && tracklets[tracklet].source < core.end;
+    };
+    for (Tracklets::Index to = 0U; to < triplets.size(); ++to) {
+      const auto shared = tripletView.first[to];
+      if (inCore(shared)) {
+        const auto count = neighbourOffsets[to + 1U] - neighbourOffsets[to];
+        ++summary.neighbourHistogram[countBin(count)];
+        summary.maxNeighbours = std::max(summary.maxNeighbours, count);
+      }
+      for (auto edge = neighbourOffsets[to]; edge < neighbourOffsets[to + 1U]; ++edge) {
+        const auto first = tripletView.first[from[edge]];
+        if (!inCore(first)) {
+          continue;
+        }
+        ++summary.neighbours;
+        const auto a = tracklets[first].source;
+        const auto b = tracklets[shared].source;
+        const auto c = tracklets[shared].target;
+        const auto d = tracklets[tripletView.second[to]].target;
+        const auto ab = truePairIndex(a, b);
+        const auto bc = truePairIndex(b, c);
+        const auto cd = truePairIndex(c, d);
+        const auto firstTriplet = ab < truePairs.size() && bc < truePairs.size() ? trueTripletIndex(ab, bc) : trueTriplets.size();
+        const auto secondTriplet = bc < truePairs.size() && cd < truePairs.size() ? trueTripletIndex(bc, cd) : trueTriplets.size();
+        if (firstTriplet < trueTriplets.size() && secondTriplet < trueTriplets.size()) {
+          const std::pair<std::size_t, std::size_t> key{firstTriplet, secondTriplet};
+          const auto chain = std::ranges::lower_bound(trueChains, key);
+          if (chain != trueChains.end() && *chain == key) {
+            chainKept[static_cast<std::size_t>(chain - trueChains.begin())] = true;
+            continue;
+          }
+        }
+        classify({a, b, c, d}, summary.neighboursNotTrueCombinatorial, summary.neighboursNotTrueSecondary, summary.neighboursNotTrueSoftPrimary, summary.neighboursNotTrueOtherPrimary);
+      }
+    }
+  }
+
+  /// The iteration's end: its report, and its summary.
+  [[nodiscard]] TrackletRunSummary finish(const Controller& tracker, const Controller::IterationObservation& observed)
+  {
+    const auto& frame = *mFrame;
+    const auto& param = *mParam;
+    const auto& parameters = mParameters;
+    const auto& settings = mSettings;
+    const auto& beamLine = mBeamLine;
+    const auto& truePairs = mTruePairs;
+    const auto& trueTriplets = mTrueTriplets;
+    const auto& trueChains = mTrueChains;
+    const auto& pairKept = mPairKept;
+    const auto& trueTripletStates = mTrueTripletStates;
+    const auto& chainKept = mChainKept;
+    const auto& rows = mRows;
+    const auto& crossings = *mCrossings;
+    const auto& scattering = *mScattering;
+    const auto* material = mMaterial;
+    const auto vertexSource = parameters.vertexSource;
+    const auto initialPredictionMisses = mInitialPredictionMisses;
+    const std::int64_t requiredHalo = sliceReach(frameBounds(frame), frame.grid().geometry()).haloPS();
+    auto& summary = mSummary;
+    if (vertexSource == VertexSource::kBeamLine) {
+      reportLostPairs(frame, parameters, beamLine, truePairs, pairKept, rows, crossings, &scattering, mBzKiloGauss, settings.windows.minPtGeV, material);
+    }
+
+    // The true neighbours whose triplets were both kept, and of them the ones
+    // found.
+    for (std::size_t chain = 0; chain < trueChains.size(); ++chain) {
+      const auto& [firstTriplet, secondTriplet] = trueChains[chain];
+      if (!trueTripletStates[firstTriplet].kept || !trueTripletStates[secondTriplet].kept) {
+        continue;
+      }
+      const auto& ab = truePairs[trueTriplets[firstTriplet].first];
+      const auto ptBin = binOf(ab.pt, kPtEdges);
+      const auto cotBin = binOf(ab.cotTheta, kCotThetaEdges);
+      ++summary.trueNeighboursTripletsKept;
+      ++summary.trueNeighboursTripletsKeptByPt[ptBin];
+      ++summary.trueNeighboursTripletsKeptByCot[cotBin];
+      if (chainKept[chain]) {
+        ++summary.trueNeighboursKept;
+        ++summary.trueNeighboursKeptByPt[ptBin];
+        ++summary.trueNeighboursKeptByCot[cotBin];
+      }
+    }
+
+    // Per MC track: the longest chain its kept true triplets allow, through
+    // the true neighbours between them, against the highest level they got.
+    {
+      std::vector<std::uint32_t> longest(trueTriplets.size(), 0U);
+      for (std::size_t triplet = 0; triplet < trueTriplets.size(); ++triplet) {
+        longest[triplet] = trueTripletStates[triplet].kept ? 1U : 0U;
+      }
+      for (bool changed = true; changed;) {
+        changed = false;
+        for (const auto& [first, second] : trueChains) {
+          if (longest[first] != 0U && longest[second] != 0U && longest[first] + 1U > longest[second]) {
+            longest[second] = longest[first] + 1U;
+            changed = true;
+          }
+        }
+      }
+      std::vector<std::pair<std::uint64_t, std::pair<std::uint32_t, std::uint32_t>>> tracks; // track, (longest, level)
+      for (std::size_t triplet = 0; triplet < trueTriplets.size(); ++triplet) {
+        if (trueTripletStates[triplet].kept) {
+          tracks.push_back({truePairs[trueTriplets[triplet].first].particle, {longest[triplet], trueTripletStates[triplet].level}});
+        }
+      }
+      std::ranges::sort(tracks);
+      for (std::size_t begin = 0; begin < tracks.size();) {
+        std::size_t end = begin;
+        std::uint32_t chain = 0U;
+        std::uint32_t level = 0U;
+        for (; end < tracks.size() && tracks[end].first == tracks[begin].first; ++end) {
+          chain = std::max(chain, tracks[end].second.first);
+          level = std::max(level, tracks[end].second.second);
+        }
+        const auto bin = std::min<std::size_t>(chain, summary.tracksByChain.size() - 1U);
+        ++summary.tracksByChain[bin];
+        summary.tracksReachingChain[bin] += level == chain ? 1U : 0U;
+        summary.tracksBelowChain[bin] += level < chain ? 1U : 0U;
+        summary.tracksAboveChain[bin] += level > chain ? 1U : 0U;
+        begin = end;
+      }
+    }
+
+    for (const auto& [first, second] : trueTriplets) {
+      if (pairKept[first] && pairKept[second]) {
+        ++summary.trueTripletsPairsKept;
+        ++summary.trueTripletsPairsKeptByPt[binOf(truePairs[first].pt, kPtEdges)];
+      }
+    }
+    summary.tripletHighWater = tracker.tripletHighWater();
+    summary.neighbourHighWater = tracker.neighbourHighWater();
+    summary.trackletHighWater = tracker.trackletHighWater();
+    summary.stagingHighWater = tracker.stagingHighWater();
+    summary.stagingPredictionMisses = tracker.stagingPredictionMisses() - initialPredictionMisses;
+    summary.poolHighWater = tracker.memoryHighWater();
+
+    const auto label = fmt::format("iteration {}, {}", mIteration, vertexSource == VertexSource::kBeamLine ? "beam line" : "vertex list");
+    const double trackletSeconds = observed.summary->seconds(profile::Phase::kTracklets);
+    const double timePerSourceNS = summary.sources == 0U ? 0. : 1.e9 * trackletSeconds / static_cast<double>(summary.sources);
+    LOGP(info, "tracklets, {}: {} sources, {} accepted, {:.3f} s, {:.1f} ns/source", label, summary.sources, summary.tracklets, trackletSeconds, timePerSourceNS);
+    const auto allTracklets = summary.tracklets + summary.haloSourceTracklets;
+    const double haloTrackletFraction = allTracklets == 0U ? 0. : static_cast<double>(summary.haloSourceTracklets) / static_cast<double>(allTracklets);
+    LOGP(info, "  halo-source tracklets, within the slice gate: {}/{} ({:.3f}%)", summary.haloSourceTracklets, allTracklets, 100. * haloTrackletFraction);
+    LOGP(info, "  halo configured/required/used {}/{}/{} ps", param.sliceHaloPS, requiredHalo, observed.summary->haloPS);
+    LOGP(info,
+         "  arena/staging high-water {} / {} records ({:.1f} / {:.1f} MB), "
+         "pool {:.1f} MB, {} staging prediction misses",
+         summary.trackletHighWater, summary.stagingHighWater, static_cast<double>(summary.trackletHighWater * kTrackletBytes) / 1.e6, static_cast<double>(summary.stagingHighWater * kTrackletBytes) / 1.e6, static_cast<double>(summary.poolHighWater) / 1.e6, summary.stagingPredictionMisses);
+    LOGP(info, "  accepted per source, max {}: {}", summary.maxPerSource, histogramText(summary.countHistogram));
+    std::uint64_t trueTotal = 0U;
+    std::uint64_t trueKept = 0U;
+    for (std::size_t link = 0; link < nLinks<Det>; ++link) {
+      trueTotal += summary.truePairs[link];
+      trueKept += summary.truePairsKept[link];
+    }
+    if (trueTotal != 0U) {
+      LOGP(info, "  MC-true primary pairs: {}/{} kept ({:.3f}%)", trueKept, trueTotal, percent(trueKept, trueTotal));
+      for (std::size_t link = 0; link < nLinks<Det>; ++link) {
+        LOGP(info, "    {:>2} -> {:<2}: {}/{} ({:.3f}%)", Det::layerLinks[link].from, Det::layerLinks[link].to, summary.truePairsKept[link], summary.truePairs[link], percent(summary.truePairsKept[link], summary.truePairs[link]));
+      }
+    }
+
+    const double tripletSeconds = observed.summary->seconds(profile::Phase::kTriplets);
+    const double timePerFirstNS = summary.firstTracklets == 0U ? 0. : 1.e9 * tripletSeconds / static_cast<double>(summary.firstTracklets);
+    LOGP(info, "triplets, {}: {} from {} first tracklets, {:.3f} s, {:.1f} ns/first tracklet", label, summary.triplets, summary.firstTracklets, tripletSeconds, timePerFirstNS);
+    LOGP(info, "  arena high-water {} records ({:.1f} MB); halo-owned triplets, within the slice gate: {} ({:.3f}%)", summary.tripletHighWater, static_cast<double>(summary.tripletHighWater * sizeof(Triplet)) / 1.e6, summary.haloTriplets, percent(summary.haloTriplets, summary.triplets + summary.haloTriplets));
+    if (summary.trueTriplets != 0U) {
+      LOGP(info, "  MC-true triplets: {}/{} kept ({:.3f}%); with both pairs kept as tracklets {}/{} ({:.3f}%)", summary.trueTripletsKept, summary.trueTriplets, percent(summary.trueTripletsKept, summary.trueTriplets), summary.trueTripletsKept, summary.trueTripletsPairsKept, percent(summary.trueTripletsKept, summary.trueTripletsPairsKept));
+      if (summary.tripletsKinked != 0U) {
+        LOGP(info, "  kept only with the kink allowance: {} triplets ({:.3f}%), {} of them MC-true ({:.3f}% of the kinked; {:.3f}% of the true kept)", summary.tripletsKinked, percent(summary.tripletsKinked, summary.triplets), summary.trueTripletsKinked, percent(summary.trueTripletsKinked, summary.tripletsKinked), percent(summary.trueTripletsKinked, summary.trueTripletsKept));
+      }
+      const auto notTrue = summary.triplets - summary.trueTripletsKept;
+      LOGP(info, "  not MC-true: {}/{} ({:.3f}%)", notTrue, summary.triplets, percent(notTrue, summary.triplets));
+      LOGP(info,
+           "    one particle: secondary {} ({:.2f}%), primary below pT_min {} ({:.2f}%), other primary {} ({:.2f}%); "
+           "combinatorial {} ({:.2f}%)",
+           summary.notTrueSecondary, percent(summary.notTrueSecondary, summary.triplets), summary.notTrueSoftPrimary, percent(summary.notTrueSoftPrimary, summary.triplets), summary.notTrueOtherPrimary, percent(summary.notTrueOtherPrimary, summary.triplets), summary.notTrueCombinatorial, percent(summary.notTrueCombinatorial, summary.triplets));
+      std::string byPt;
+      for (std::size_t bin = 1; bin < kPtBins; ++bin) {
+        byPt += fmt::format(" {}-{}: {:.2f}%", kPtEdges[bin], kPtEdges[bin + 1U], percent(summary.trueTripletsKeptByPt[bin], summary.trueTripletsPairsKeptByPt[bin]));
+      }
+      LOGP(info, "  kept with both pairs kept, by pT [GeV]:{}", byPt);
+      logTripletCurvature(summary);
+    }
+
+    const double neighbourSeconds = observed.summary->seconds(profile::Phase::kNeighbours);
+    const double neighbourPerTripletNS = summary.tripletsWorked == 0U ? 0. : 1.e9 * neighbourSeconds / static_cast<double>(summary.tripletsWorked);
+    LOGP(info, "neighbours, {}: {} from {} triplets worked, {:.3f} s, {:.1f} ns/triplet", label, summary.neighbours, summary.tripletsWorked, neighbourSeconds, neighbourPerTripletNS);
+    LOGP(info, "  arena high-water {} records ({:.1f} MB); swept {:.2f}% of the triplets", summary.neighbourHighWater, static_cast<double>(summary.neighbourHighWater * sizeof(Neighbour)) / 1.e6, percent(summary.chained, summary.tripletsWorked));
+    LOGP(info, "  predecessors per triplet, max {}: {}", summary.maxNeighbours, histogramText(summary.neighbourHistogram));
+    if (summary.trueNeighbours != 0U) {
+      LOGP(info, "  MC-true neighbours: {}/{} kept; with both triplets kept {}/{} ({:.3f}%)", summary.trueNeighboursKept, summary.trueNeighbours, summary.trueNeighboursKept, summary.trueNeighboursTripletsKept, percent(summary.trueNeighboursKept, summary.trueNeighboursTripletsKept));
+      std::string byPt;
+      for (std::size_t bin = 1; bin < kPtBins; ++bin) {
+        byPt += fmt::format(" [{:.2f},{:.2f}) {:.2f}%", kPtEdges[bin], kPtEdges[bin + 1U], percent(summary.trueNeighboursKeptByPt[bin], summary.trueNeighboursTripletsKeptByPt[bin]));
+      }
+      LOGP(info, "    kept with both triplets kept, by pT [GeV]:{}", byPt);
+      std::string byCot;
+      for (std::size_t bin = 0; bin < kCotThetaBins; ++bin) {
+        if (summary.trueNeighboursTripletsKeptByCot[bin] != 0U) {
+          byCot += fmt::format(" [{:.2f},{:.2f}) {:.2f}%", kCotThetaEdges[bin], kCotThetaEdges[bin + 1U], percent(summary.trueNeighboursKeptByCot[bin], summary.trueNeighboursTripletsKeptByCot[bin]));
+        }
+      }
+      LOGP(info, "    by cot(theta):{}", byCot);
+      const auto notTrue = summary.neighbours - summary.trueNeighboursKept;
+      LOGP(info,
+           "  not MC-true: {}/{} ({:.3f}%); one particle: secondary {:.2f}%, primary below pT_min {:.2f}%, other primary {:.2f}%; "
+           "combinatorial {:.2f}%",
+           notTrue, summary.neighbours, percent(notTrue, summary.neighbours), percent(summary.neighboursNotTrueSecondary, summary.neighbours), percent(summary.neighboursNotTrueSoftPrimary, summary.neighbours), percent(summary.neighboursNotTrueOtherPrimary, summary.neighbours), percent(summary.neighboursNotTrueCombinatorial, summary.neighbours));
+      std::string byChain;
+      for (std::size_t chain = 1; chain < summary.tracksByChain.size(); ++chain) {
+        if (summary.tracksByChain[chain] != 0U) {
+          byChain += fmt::format(" {}: {} ({:.2f}% reach it, {:.2f}% below, {:.2f}% above)", chain, summary.tracksByChain[chain], percent(summary.tracksReachingChain[chain], summary.tracksByChain[chain]), percent(summary.tracksBelowChain[chain], summary.tracksByChain[chain]), percent(summary.tracksAboveChain[chain], summary.tracksByChain[chain]));
+        }
+      }
+      LOGP(info, "  MC tracks by their longest chain of kept true triplets, and the level they reach:{}", byChain);
+    }
+    return summary;
+  }
+
+ private:
+  /// Counts a stage's element that is no MC-true one by what made it: no
+  /// particle on every row of \a of, a secondary's, a primary's below the
+  /// iteration's pT_min, another primary's.
+  void classify(std::initializer_list<Frame::Index> of, std::uint64_t& combinatorial, std::uint64_t& secondary, std::uint64_t& softPrimary, std::uint64_t& otherPrimary) const
+  {
+    if (mRows.empty()) {
+      return;
+    }
+    const auto id = goodParticle(mRows, std::span<const Frame::Index>{of.begin(), of.size()});
+    const auto truth = id == kNoTrackParticle ? mParticles->end() : mParticles->find(id);
+    if (truth == mParticles->end()) {
+      ++combinatorial;
+    } else if (!truth->second.primary) {
+      ++secondary;
+    } else if (static_cast<double>(truth->second.pt) < mSettings.windows.minPtGeV) {
+      ++softPrimary;
+    } else {
+      ++otherPrimary;
+    }
+  }
+
+  const Frame* mFrame;
+  const RecoSettings* mParam;
+  std::size_t mIteration;
+  IterationSettings mSettings;
+  IterationParameters<Det> mParameters;
+  VertexSeed mBeamLine;
+  double mBzKiloGauss;
+  std::span<const TruthRow> mRows;
+  const ParticleTable* mParticles;
+  const ScatteringTable<Det>* mScattering;
+  const o2::base::MatLayerCylSet* mMaterial;
+  const TrueCrossings* mCrossings;
+  std::vector<std::uint8_t> mUsed; ///< the mask the iteration read
+  std::size_t mInitialPredictionMisses;
+  std::vector<TruePair> mTruePairs; ///< above pT_min, on free clusters
+  std::vector<std::pair<std::size_t, std::size_t>> mTrueTriplets;
+  std::vector<std::pair<std::size_t, std::size_t>> mTrueChains;
+  std::vector<bool> mPairKept;
+  std::vector<TrueTripletState> mTrueTripletStates;
+  std::vector<bool> mChainKept;
+  TrackletRunSummary mSummary;
+};
+
+/// The MC-true chains whose fit fails: where
+/// -- the pass, the propagation status, the step as layer to layer -- and
+/// what -- pT, eta, species, origin, the chain's layers -- with the chain
+/// reference's pT against the true one, and every chain printed up to a cap.
+struct TrueRoadFitFailure {
+  std::uint64_t id = 0U; ///< the particle
+  std::vector<std::uint32_t> rows;
+  TrackFitResult fit;
+};
+
+void reportTrueRoadFitFailures(const Frame& frame, std::span<const TrueRoadFitFailure> failures, const ParticleTable& particles, const TrackingGeometry<Det>& tracking, const Propagator& propagator, const TrueCrossings& crossings, const ScatteringTable<Det>& scattering, const o2::base::MatLayerCylSet& material)
+{
+  if (failures.empty()) {
+    return;
+  }
+  constexpr std::array<const char*, 3> kPasses{"none", "outward", "inward"};
+  constexpr std::array<const char*, 8> kStatuses{"ok", "no intersection", "wrong direction", "out of bounds", "grazing", "not finite", "too many turns", "stopped"};
+  constexpr std::size_t kExamples = 12U;
+  std::map<std::pair<std::uint8_t, std::uint8_t>, std::uint64_t> byPassStatus;
+  std::map<std::tuple<std::uint8_t, int, int>, std::uint64_t> bySteps;
+  std::map<int, std::uint64_t> bySpecies;
+  std::map<std::size_t, std::uint64_t> byCount;
+  std::array<std::uint64_t, 2> byPrimary{};
+  // From the MC hits, in the chain's order: the particle loops -- it turns
+  // more than half a turn between two crossings (|dz| pT / |pz| over its
+  // radius at the first), a second pass --; it turns back otherwise -- its
+  // momentum points inwards at a barrel crossing, or its pz changes sign --;
+  // it loses more than a fifth of its momentum (brems); it scatters hard
+  // (a kink of 5 theta0 or more); none of these; no hits.
+  enum Kind : std::uint8_t { kLoops,
+                             kTurnsBack,
+                             kLoses,
+                             kHard,
+                             kNone,
+                             kNoHits,
+                             kKinds };
+  constexpr std::array<const char*, kKinds> kKindNames{"loops (> half a turn between crossings)", "turns back", "loses > 20 % of p", "hard scatter (>= 5 theta0)", "none of these", "no hits"};
+  std::array<std::uint64_t, kKinds> byKind{};
+  std::size_t examples = 0U;
+  for (const auto& failure : failures) {
+    const auto& rows = failure.rows;
+    const auto& fit = failure.fit;
+    const int n = static_cast<int>(rows.size());
+    const auto layerOf = [&](int index) { return static_cast<int>(tracking.surface(frame.measurement(rows[static_cast<std::size_t>(index)]).surface).layer); };
+    const int to = fit.failedMeasurement;
+    const int from = fit.failedPass == FitPass::kInward ? to + 1 : to - 1;
+    const bool stepInChain = std::min(from, to) >= 0 && std::max(from, to) < n;
+    ++byPassStatus[{static_cast<std::uint8_t>(fit.failedPass), static_cast<std::uint8_t>(fit.status)}];
+    ++bySteps[{static_cast<std::uint8_t>(fit.failedPass), stepInChain ? layerOf(from) : -1, to >= 0 && to < n ? layerOf(to) : -1}];
+    ++byCount[rows.size()];
+    const auto found = particles.find(failure.id);
+    const ParticleTruth truth = found == particles.end() ? ParticleTruth{} : found->second;
+    ++bySpecies[truth.pdg];
+    ++byPrimary[truth.primary ? 0U : 1U];
+    Kind kind = kNoHits;
+    std::string hits;
+    if (crossings) {
+      auto sorted = crossings(failure.id, std::span<const Frame::Index>{rows});
+      if (sorted.size() == rows.size()) {
+        std::vector<TrueCrossing> ordered;
+        ordered.reserve(rows.size());
+        for (const auto row : rows) {
+          ordered.push_back(*std::ranges::find(sorted, row, &TrueCrossing::row));
+        }
+        const auto reports = trueAnatomy(frame, scattering, static_cast<double>(propagator.bzKiloGauss), ordered, &material);
+        bool back = false;
+        double maxTurn = 0.;
+        const double pzFirst = ordered.front().momentum[2];
+        for (std::size_t i = 0; i < ordered.size(); ++i) {
+          const auto& crossing = ordered[i];
+          const auto& x = crossing.position;
+          const auto& p = crossing.momentum;
+          back = back || (Detector<Det>::isBarrelLayer(static_cast<LayerID>(crossing.layer)) && (x[0] * p[0]) + (x[1] * p[1]) < 0.) || pzFirst * p[2] < 0.;
+          if (i > 0U) {
+            const auto& before = ordered[i - 1U];
+            const double pt = std::hypot(before.momentum[0], before.momentum[1]);
+            const double turn = std::abs(x[2] - before.position[2]) * pt / std::abs(before.momentum[2]) / curvatureRadius(pt, static_cast<double>(propagator.bzKiloGauss));
+            maxTurn = std::isfinite(turn) ? std::max(maxTurn, turn) : maxTurn;
+          }
+          hits += fmt::format(" {}(p {:.3f}, pT {:.3f})", crossing.layer, std::hypot(p[0], p[1], p[2]), std::hypot(p[0], p[1]));
+        }
+        const auto& first = ordered.front().momentum;
+        const auto& last = ordered.back().momentum;
+        const double ratio = std::hypot(last[0], last[1], last[2]) / std::hypot(first[0], first[1], first[2]);
+        double hardest = 0.;
+        for (const auto& report : reports) {
+          hardest = std::isfinite(report.kink) ? std::max(hardest, report.kink) : hardest;
+        }
+        hits += fmt::format("; p last/first {:.3f}, hardest kink {:.1f} theta0, largest turn {:.2f} rad", ratio, hardest, maxTurn);
+        if (maxTurn > std::numbers::pi) {
+          kind = kLoops;
+        } else if (back) {
+          kind = kTurnsBack;
+        } else if (ratio < 0.8) {
+          kind = kLoses;
+        } else if (hardest >= kHardKink) {
+          kind = kHard;
+        } else {
+          kind = kNone;
+        }
+      }
+    }
+    ++byKind[kind];
+    if (examples < kExamples) {
+      ++examples;
+      const auto seed = makeChainSeed(propagator, tracking, RowChain<Det>{.frame = &frame, .rows = rows.data()}, n);
+      const auto qOverP = static_cast<double>(std::abs(seed.state.qOverP()));
+      const double seedPt = qOverP > 0. ? std::abs(std::sin(static_cast<double>(seed.state.theta()))) / qOverP : 0.;
+      std::string layers;
+      for (int i = 0; i < n; ++i) {
+        const auto m = frame.measurement(rows[static_cast<std::size_t>(i)]);
+        layers += fmt::format(" {}(r {:.2f}, z {:.2f}, phi {:.3f})", layerOf(i), m.r, m.z, std::atan2(m.y, m.x));
+      }
+      LOGP(info,
+           "    true chain {:#x}: {} {} at index {} of {}; pdg {} (mother {}, process {}), {} at ({:.2f}, {:.2f}, {:.2f}); MC pT {:.3f}, eta {:.3f}; seed pT "
+           "{:.3f}, theta {:.4f}; {}; layers{}; hits{}",
+           failure.id, kPasses[static_cast<std::size_t>(fit.failedPass)], kStatuses[static_cast<std::size_t>(fit.status)], to, n, truth.pdg, truth.motherPdg, static_cast<int>(truth.process), truth.primary ? "primary" : "secondary", truth.vx, truth.vy, truth.vz, truth.pt, truth.eta, seedPt, seed.state.theta(), kKindNames[kind], layers, hits);
+    }
+  }
+  LOGP(info, "  true chains whose fit fails: {}; primary {}, secondary {}", failures.size(), byPrimary[0], byPrimary[1]);
+  for (const auto& [key, count] : byPassStatus) {
+    LOGP(info, "    {}, {}: {}", kPasses[key.first], kStatuses[key.second], count);
+  }
+  std::string steps;
+  for (const auto& [key, count] : bySteps) {
+    steps += fmt::format(" {} {}->{}: {};", kPasses[std::get<0>(key)], std::get<1>(key), std::get<2>(key), count);
+  }
+  LOGP(info, "    by the failing step (pass, layer to layer):{}", steps);
+  std::string species;
+  for (const auto& [pdg, count] : bySpecies) {
+    species += fmt::format(" {}: {}", pdg, count);
+  }
+  LOGP(info, "    by species:{}", species);
+  std::string counts;
+  for (const auto& [count, chains] : byCount) {
+    counts += fmt::format(" {}: {}", count, chains);
+  }
+  LOGP(info, "    by clusters:{}", counts);
+  std::string kinds;
+  for (std::size_t kind = 0; kind < kKinds; ++kind) {
+    kinds += fmt::format("{} {}: {}", kind == 0U ? "" : ";", kKindNames[kind], byKind[kind]);
+  }
+  LOGP(info, "    by the MC hits:{}", kinds);
+}
+
+/// The road fit on the MC-true roads: every particle the
+/// first iteration could find, by its longest true chain -- first-pass
+/// clusters joined by true pairs, the innermost `maxChainLayers` of it --
+/// fitted as the road fit and the refit fit it. Against the cut: how many fail
+/// by length, next to what a calibrated chi2 loses at nSigma. Where the chi2
+/// comes from: the outward chi2 per degree of freedom, and per layer the
+/// median of each spatial update's increment against the median of its chi2
+/// distribution -- the square of the scale its errors are off by, robust to a
+/// tail -- and the fraction beyond the nSigma quantile. An increment counts
+/// once its pass has fixed the helix (three earlier clusters, two dof); both
+/// passes, so the inner layers are seen too.
+void reportTrueRoadChi2(const Frame& frame, const RecoSettings& param, const Controller& tracker, std::span<const TruePair> truePairs, const ParticleTable& particles, const TrackingGeometry<Det>& tracking, const o2::base::MatLayerCylSet& material, const Propagator& propagator, const TrueCrossings& crossings, const ScatteringTable<Det>& scattering)
+{
+  constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  constexpr double kMedianChi2Two = 1.3862943611198906; // 2 ln 2
+  const auto settings = workflow::iterationSettings(param, 0);
+  const auto& parameters = tracker.iteration(0);
+  const auto minClusters = static_cast<std::uint32_t>(std::max(settings.minClusters, 4));
+  const double nSigma = settings.windows.nSigma;
+  const double tailTwo = chiSquareQuantile(2, nSigma);
+
+  // The longest true chain along each pair, one particle's, and each
+  // particle's longest: its last pair and pT.
+  const auto chains = trueChains(truePairs);
+  std::unordered_map<std::uint64_t, std::pair<std::size_t, Scalar>> ends;
+  for (std::size_t pair = 0; pair < truePairs.size(); ++pair) {
+    auto [end, inserted] = ends.try_emplace(truePairs[pair].particle, pair, truePairs[pair].pt);
+    if (!inserted && chains[pair].length > chains[end->second.first].length) {
+      end->second.first = pair;
+    }
+  }
+
+  struct ByLength {
+    std::uint64_t chains = 0U;
+    std::uint64_t failed = 0U;
+    std::uint64_t fitFailed = 0U;
+  };
+  std::array<ByLength, kMaxClusters + 1U> byLength{};
+  std::array<std::vector<float>, static_cast<std::size_t>(Detector<Det>::nLayers)> spatial;
+  std::array<std::uint64_t, static_cast<std::size_t>(Detector<Det>::nLayers)> worstOfFailed{};
+  double chi2Sum = 0.;
+  double ndfSum = 0.;
+  std::uint64_t kinked = 0U;                         ///< chains whose outward pass took a kink
+  std::vector<float> chi2PerNdf;                     ///< every chain's outward chi2 / ndf
+  std::array<std::uint64_t, 4> failedByBeyondGate{}; ///< failing chains by their outward steps beyond the kink gate: 0, 1, 2, 3+
+  std::array<std::uint64_t, 4> failedByWorstShare{}; ///< failing chains by the worst step's share of their chi2: <25, 25-50, 50-75, >75 %
+  std::array<std::uint64_t, 3> diffuseByKind{};      ///< failing chains without a step beyond the gate, by their layers: barrel only, discs only, both
+  // Why the kink did not save a failing chain:
+  // the budget spent before the miss; the miss on the last step, where no kink
+  // is taken; a miss beyond the gate elsewhere
+  // although kinks were left; no step beyond the gate. For each, how many the
+  // inward pass -- which kinks one step later, at the last cluster too -- passes.
+  enum Why : std::uint8_t { kWhySpent,
+                            kWhyLastStep,
+                            kWhyOtherMiss,
+                            kWhyDiffuse,
+                            kWhys };
+  constexpr std::array<const char*, kWhys> kWhyNames{"the budget spent", "the miss on the last step", "a miss elsewhere", "no step beyond the gate"};
+  std::array<std::uint64_t, kWhys> failedByWhy{};
+  std::array<std::uint64_t, kWhys> inwardPassesByWhy{};
+  std::array<std::uint64_t, kWhys> fullLengthByWhy{}; ///< of them, chains over every layer
+  // The chains whose fit fails, for their anatomy below.
+  std::vector<TrueRoadFitFailure> failures;
+  std::vector<std::uint32_t> rows;
+  for (const auto& [id, end] : ends) {
+    if (static_cast<double>(end.second) < settings.windows.minPtGeV || chains[end.first].length < minClusters) {
+      continue;
+    }
+    rows.clear();
+    auto pair = end.first;
+    rows.push_back(static_cast<std::uint32_t>(truePairs[pair].key & 0xffffffffU));
+    for (; chains[pair].previous != TrueChain::kNoPair; pair = chains[pair].previous) {
+      rows.push_back(static_cast<std::uint32_t>(truePairs[pair].key >> 32U));
+    }
+    rows.push_back(static_cast<std::uint32_t>(truePairs[pair].key >> 32U));
+    std::ranges::reverse(rows);
+    rows.resize(std::min(rows.size(), kMaxClusters));
+    const int n = static_cast<int>(rows.size());
+    std::array<float, kMaxClusters> outwardSpatial{};
+    std::array<float, kMaxClusters> inwardSpatial{};
+    const auto observe = [&](PropagationDirection direction, int index, Scalar increment) { (direction == PropagationDirection::kForward ? outwardSpatial : inwardSpatial)[static_cast<std::size_t>(index)] = increment; };
+    const auto fit = fitMeasurements(propagator, tracking, material, RowChain<Det>{.frame = &frame, .rows = rows.data()}, n, kinkBudget(parameters), observe);
+    auto& length = byLength[static_cast<std::size_t>(n)];
+    ++length.chains;
+    if (fit.status != PropagationStatus::kOk) {
+      ++length.fitFailed;
+      failures.push_back({.id = id, .rows = rows, .fit = fit});
+      continue;
+    }
+    const int outwardNdf = (2 * n) - kNBoundParams - (2 * fit.outwardKinks);
+    chi2Sum += static_cast<double>(fit.outwardChi2);
+    ndfSum += static_cast<double>(outwardNdf);
+    const auto layerOf = [&](int index) { return static_cast<std::size_t>(tracking.surface(frame.measurement(rows[static_cast<std::size_t>(index)]).surface).layer); };
+    for (int index = 0; index < n; ++index) {
+      const auto at = static_cast<std::size_t>(index);
+      if (index >= 3) {
+        spatial[layerOf(index)].push_back(outwardSpatial[at]);
+      }
+      if (index <= n - 4) {
+        spatial[layerOf(index)].push_back(inwardSpatial[at]);
+      }
+    }
+    kinked += fit.outwardKinks != 0U ? 1U : 0U;
+    chi2PerNdf.push_back(fit.outwardChi2 / static_cast<float>(outwardNdf));
+    if (!(fit.outwardChi2 <= roadChi2Cut(parameters, static_cast<std::uint32_t>(n), fit.outwardKinks))) {
+      ++length.failed;
+      int worst = 0;
+      for (int index = 1; index < n; ++index) {
+        if (outwardSpatial[static_cast<std::size_t>(index)] > outwardSpatial[static_cast<std::size_t>(worst)]) {
+          worst = index;
+        }
+      }
+      ++worstOfFailed[layerOf(worst)];
+      std::size_t beyond = 0U;
+      for (int index = 1; index < n; ++index) {
+        beyond += outwardSpatial[static_cast<std::size_t>(index)] > parameters.kinkChi2Min ? 1U : 0U;
+      }
+      ++failedByBeyondGate[std::min<std::size_t>(beyond, 3U)];
+      {
+        Why why = kWhyDiffuse;
+        if (beyond != 0U) {
+          const bool lastBeyond = outwardSpatial[static_cast<std::size_t>(n - 1)] > parameters.kinkChi2Min;
+          if (fit.outwardKinks >= parameters.maxKinks) {
+            why = kWhySpent;
+          } else if (lastBeyond && beyond == 1U) {
+            why = kWhyLastStep;
+          } else {
+            why = kWhyOtherMiss;
+          }
+        }
+        ++failedByWhy[why];
+        inwardPassesByWhy[why] += fit.chi2 <= roadChi2Cut(parameters, static_cast<std::uint32_t>(n), fit.kinks) ? 1U : 0U;
+        fullLengthByWhy[why] += static_cast<std::size_t>(n) >= static_cast<std::size_t>(Detector<Det>::nLayers) ? 1U : 0U;
+      }
+      if (beyond == 0U) {
+        bool barrel = false;
+        bool disc = false;
+        for (int index = 0; index < n; ++index) {
+          (Detector<Det>::isBarrelLayer(static_cast<LayerID>(layerOf(index))) ? barrel : disc) = true;
+        }
+        std::size_t kind = 0U;
+        if (barrel && disc) {
+          kind = 2U;
+        } else if (disc) {
+          kind = 1U;
+        }
+        ++diffuseByKind[kind];
+      }
+      const auto worstShare = static_cast<double>(outwardSpatial[static_cast<std::size_t>(worst)]) / std::max(static_cast<double>(fit.outwardChi2), 1e-30);
+      ++failedByWorstShare[std::min<std::size_t>(static_cast<std::size_t>(worstShare * 4.), 3U)];
+    }
+  }
+
+  ByLength all;
+  std::string lengths;
+  for (std::size_t n = 0; n < byLength.size(); ++n) {
+    if (byLength[n].chains != 0U) {
+      all.chains += byLength[n].chains;
+      all.failed += byLength[n].failed;
+      all.fitFailed += byLength[n].fitFailed;
+      lengths += fmt::format(" {}: {} {:.2f}%", n, byLength[n].chains, percent(byLength[n].failed, byLength[n].chains));
+    }
+  }
+  LOGP(info,
+       "true roads, iteration 0 (pT_min {} GeV, {} clusters or more): {} chains; the road cut fails {} ({:.2f}%), a calibrated chi2 {:.2f}%; fit failed {}; "
+       "a kink taken by {} ({:.2f}%, at most {})",
+       settings.windows.minPtGeV, minClusters, all.chains, all.failed, percent(all.failed, all.chains), 100. * std::erfc(nSigma / std::sqrt(2.)), all.fitFailed, kinked, percent(kinked, all.chains), static_cast<int>(parameters.maxKinks));
+  LOGP(info, "  by clusters, chains and failing:{}", lengths);
+  reportTrueRoadFitFailures(frame, failures, particles, tracking, propagator, crossings, scattering, material);
+  if (!chi2PerNdf.empty()) {
+    std::ranges::sort(chi2PerNdf);
+    const auto quantile = [&](double q) { return static_cast<double>(chi2PerNdf[std::min(chi2PerNdf.size() - 1U, static_cast<std::size_t>(q * static_cast<double>(chi2PerNdf.size())))]); };
+    LOGP(info, "  outward chi2/ndf quantiles: 50% {:.2f}, 90% {:.2f}, 99% {:.2f}, 99.9% {:.2f}, max {:.1f}", quantile(0.5), quantile(0.9), quantile(0.99), quantile(0.999), static_cast<double>(chi2PerNdf.back()));
+  }
+  LOGP(info,
+       "  failing chains by outward steps beyond the kink gate: 0 {}, 1 {}, 2 {}, 3+ {}; by the worst step's share of the chi2: <25% {}, 25-50% {}, "
+       "50-75% {}, >75% {}",
+       failedByBeyondGate[0], failedByBeyondGate[1], failedByBeyondGate[2], failedByBeyondGate[3], failedByWorstShare[0], failedByWorstShare[1], failedByWorstShare[2], failedByWorstShare[3]);
+  {
+    std::string whys;
+    for (std::size_t why = 0; why < kWhys; ++why) {
+      whys += fmt::format("{} {} {} (all-layer {}; the inward pass passes {})", why == 0U ? "" : ";", kWhyNames[why], failedByWhy[why], fullLengthByWhy[why], inwardPassesByWhy[why]);
+    }
+    LOGP(info, "  failing chains by why the kink did not save them:{}", whys);
+  }
+  LOGP(info, "  failing chains without a step beyond the gate: barrel only {}, discs only {}, both {}", diffuseByKind[0], diffuseByKind[1], diffuseByKind[2]);
+  LOGP(info, "  chi2/ndf {:.3f}", chi2Sum / std::max(ndfSum, 1.));
+  for (std::size_t layer = 0; layer < spatial.size(); ++layer) {
+    if (spatial[layer].empty()) {
+      continue;
+    }
+    const auto beyondTwo = static_cast<std::uint64_t>(std::ranges::count_if(spatial[layer], [&](float v) { return static_cast<double>(v) > tailTwo; }));
+    const auto count = spatial[layer].size();
+    std::vector<double> updates(spatial[layer].begin(), spatial[layer].end()); // exact: the float values' median
+    LOGP(info, "  layer {:>2} ({}): {:>7} updates, scale^2 {:.2f}, beyond {:.2f}%; worst of the failing {}", layer, Detector<Det>::isBarrelLayer(static_cast<LayerID>(layer)) ? "barrel" : "disc", count, median(updates) / kMedianChi2Two, percent(beyondTwo, count), worstOfFailed[layer]);
+  }
+}
+
+/// Where the fakes go wrong, under the comparison's rule (TrackComparison.h:
+/// the label is the particle most clusters carry, one cluster without it
+/// makes a fake), by the track's layers -- every layer, the innermost four,
+/// the outermost four, other -- and, for the fakes with one wrong cluster, by
+/// what the label's own cluster on that layer could have made of it: none
+/// there (the particle ended before the layer, or skipped it), or there, and
+/// the track with it in place of the wrong one refitted as the road fit:
+/// whether it passes the road cut, and whether it would have outranked the
+/// fake in the selection (fewer kinks, then the lower outward chi2). A
+/// passing alternative that outranks the fake never reached the selection,
+/// so the label's stage record says where its chain was lost (the fake's
+/// iteration's, in the tracker's own run: \a funnel; none for a label not
+/// findable by the funnel's rule); one
+/// that ranks below it was beaten by the wrong cluster on chi2. Also the
+/// refit's chi2 per degree of freedom of the good tracks against the fakes',
+/// for what a cut on it would reach.
+void reportFakeAnatomy(const Frame& frame, const RecoSettings& param, std::span<const TruthRow> rows, const ParticleTable& particles, const Funnel* funnel, const Controller& tracker, const TrackRefit<Det>::Tracks& tracks, const TrackingGeometry<Det>& tracking, const o2::base::MatLayerCylSet& material, const Propagator& propagator, const char* label)
+{
+  constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  constexpr std::size_t kClasses = 4U;
+  constexpr std::array<const char*, kClasses> kClassNames{"every layer", "innermost four", "outermost four", "other layers"};
+  const auto nLayers = static_cast<std::uint32_t>(Detector<Det>::nLayers);
+  const std::uint32_t innerFour = nLayers >= 4U ? 0xFU : 0U;
+  std::uint32_t outerFour = 0U;
+  for (std::uint32_t layer = nLayers >= 4U ? nLayers - 4U : 0U; layer < std::min(nLayers, 32U); ++layer) {
+    outerFour |= 1U << layer;
+  }
+  const auto classOf = [&](std::uint32_t pattern) -> std::size_t {
+    if (std::cmp_equal(std::popcount(pattern), nLayers)) {
+      return 0U;
+    }
+    if (pattern == innerFour) {
+      return 1U;
+    }
+    if (pattern == outerFour) {
+      return 2U;
+    }
+    return 3U;
+  };
+  const auto primary = [&](std::uint64_t id) {
+    const auto found = particles.find(id);
+    return found != particles.end() && found->second.primary;
+  };
+
+  // Every track: its label and class; the fakes kept for the second look.
+  struct Fake {
+    std::size_t track = 0U;
+    std::uint64_t label = kNoTrackParticle;
+    std::uint32_t most = 0U;
+    std::size_t cls = 0U;
+  };
+  std::vector<Fake> fakes;
+  std::array<std::array<std::vector<float>, 2>, kClasses> chi2PerNdf; // [class][good, fake]
+  std::array<std::array<std::uint64_t, 2>, kClasses> tracksByClass{};
+  std::array<std::array<std::uint64_t, 2>, kClasses> kinkedByClass{};
+  std::unordered_map<std::uint64_t, std::vector<std::uint32_t>> ownRows; // the fakes' labels -> every row carrying them
+  const auto view = tracks.view();
+  for (std::size_t track = 0; track < tracks.size(); ++track) {
+    const auto count = view.count[track];
+    const std::span<const std::uint32_t> trackRows{view.clusters[track].index, count};
+    const auto [id, most] = majorityParticle(rows, trackRows);
+    std::uint32_t pattern = 0U;
+    for (const auto row : trackRows) {
+      pattern |= 1U << rows[row].layer;
+    }
+    const auto cls = classOf(pattern);
+    const bool good = id != kNoTrackParticle && most == count;
+    const std::size_t which = good ? 0U : 1U;
+    ++tracksByClass[cls][which];
+    kinkedByClass[cls][which] += view.kinks[track] != 0U ? 1U : 0U;
+    if (view.ndf[track] > 0) {
+      chi2PerNdf[cls][which].push_back(view.chi2[track] / static_cast<float>(view.ndf[track]));
+    }
+    if (!good && id != kNoTrackParticle) {
+      fakes.push_back({.track = track, .label = id, .most = most, .cls = cls});
+      ownRows.try_emplace(id);
+    }
+  }
+  for (Frame::Index row = 0U; row < frame.size(); ++row) {
+    const auto& truth = rows[row];
+    for (std::uint8_t p = 0; p < truth.count; ++p) {
+      const auto found = ownRows.find(truth.particles[p]);
+      if (found != ownRows.end()) {
+        found->second.push_back(row);
+      }
+    }
+  }
+
+  // The fakes with one wrong cluster, and the alternative with the label's own.
+  struct ClassTally {
+    std::uint64_t oneWrong = 0U;
+    std::array<std::uint64_t, 3> wrongAt{}; ///< innermost, outermost, inside
+    std::uint64_t wrongSecondary = 0U;      ///< the wrong cluster carries no primary
+    std::uint64_t holeEnded = 0U;           ///< the label has no cluster on the layer, nor beyond it
+    std::uint64_t holeSkipped = 0U;         ///< none on the layer, some beyond
+    std::uint64_t altFitFailed = 0U;
+    std::uint64_t altFailsCut = 0U;
+    std::uint64_t altAbove = 0U;                ///< passes and outranks the fake
+    std::uint64_t altBelow = 0U;                ///< passes and ranks below it
+    std::array<std::uint64_t, 7> aboveLostAt{}; ///< tracklets, triplets, neighbours, roads, road cut, not lost, no record
+    std::array<std::uint64_t, 3> noRecord{};    ///< of the last: a primary below the iteration's pT floor, a secondary, other
+    std::vector<float> belowGap;                ///< ranks below: the alternative's outward chi2 less the fake's
+  };
+  std::array<ClassTally, kClasses> tally{};
+  std::array<std::uint32_t, kMaxClusters> trackRows{};
+  std::array<std::uint32_t, kMaxClusters> altRows{};
+  for (const auto& fake : fakes) {
+    const auto count = view.count[fake.track];
+    if (count - fake.most != 1U) {
+      continue;
+    }
+    auto& t = tally[fake.cls];
+    ++t.oneWrong;
+    std::uint32_t wrong = 0U;
+    for (std::uint32_t i = 0; i < count; ++i) {
+      trackRows[i] = view.clusters[fake.track].index[i];
+      if (!rows[trackRows[i]].carries(fake.label)) {
+        wrong = i;
+      }
+    }
+    std::size_t at = 2U;
+    if (wrong == 0U) {
+      at = 0U;
+    } else if (wrong == count - 1U) {
+      at = 1U;
+    }
+    ++t.wrongAt[at];
+    const auto& wrongTruth = rows[trackRows[wrong]];
+    t.wrongSecondary += std::none_of(wrongTruth.particles.begin(), wrongTruth.particles.begin() + wrongTruth.count, primary) ? 1U : 0U;
+    const auto layer = wrongTruth.layer;
+    const auto& own = ownRows[fake.label];
+    std::uint32_t labelLayers = 0U;
+    for (const auto row : own) {
+      labelLayers |= 1U << rows[row].layer;
+    }
+    if ((labelLayers & (1U << layer)) == 0U) {
+      ++((labelLayers >> layer) == 0U ? t.holeEnded : t.holeSkipped);
+      continue;
+    }
+    const auto& parameters = tracker.iteration(view.iteration[fake.track]);
+    const int n = static_cast<int>(count);
+    const auto fitRows = [&](const std::uint32_t* chain) { return fitMeasurements(propagator, tracking, material, RowChain<Det>{.frame = &frame, .rows = chain}, n, kinkBudget(parameters)); };
+    const auto fakeFit = fitRows(trackRows.data());
+    const auto passes = [&](const TrackFitResult& fit) { return fit.status == PropagationStatus::kOk && fit.outwardChi2 <= roadChi2Cut(parameters, count, fit.outwardKinks); };
+    // The best alternative: a passing one with the lowest chi2, else the lowest.
+    std::optional<TrackFitResult> best;
+    for (const auto row : own) {
+      if (rows[row].layer != layer) {
+        continue;
+      }
+      altRows = trackRows;
+      altRows[wrong] = row;
+      const auto fit = fitRows(altRows.data());
+      if (fit.status != PropagationStatus::kOk) {
+        if (!best) {
+          best = fit;
+        }
+        continue;
+      }
+      const bool better = !best || best->status != PropagationStatus::kOk || (passes(fit) && !passes(*best)) || (passes(fit) == passes(*best) && fit.outwardChi2 < best->outwardChi2);
+      if (better) {
+        best = fit;
+      }
+    }
+    if (!best || best->status != PropagationStatus::kOk) {
+      ++t.altFitFailed;
+      continue;
+    }
+    if (!passes(*best)) {
+      ++t.altFailsCut;
+      continue;
+    }
+    const bool above = fakeFit.status != PropagationStatus::kOk || best->outwardKinks < fakeFit.outwardKinks || (best->outwardKinks == fakeFit.outwardKinks && best->outwardChi2 < fakeFit.outwardChi2);
+    if (!above) {
+      ++t.altBelow;
+      if (fakeFit.status == PropagationStatus::kOk) {
+        t.belowGap.push_back(best->outwardChi2 - fakeFit.outwardChi2);
+      }
+      continue;
+    }
+    ++t.altAbove;
+    std::size_t lostAt = 6U;
+    if (const auto stage = funnel != nullptr ? funnel->stages(fake.label, view.iteration[fake.track]) : std::nullopt; stage.has_value()) {
+      lostAt = static_cast<std::size_t>(firstLoss(stage->longest, count, false));
+    }
+    ++t.aboveLostAt[lostAt];
+    if (lostAt == 6U) {
+      const auto found = particles.find(fake.label);
+      std::size_t kind = 2U;
+      if (found != particles.end() && !found->second.primary) {
+        kind = 1U;
+      } else if (found != particles.end() && static_cast<double>(found->second.pt) < workflow::iterationSettings(param, static_cast<int>(view.iteration[fake.track])).windows.minPtGeV) {
+        kind = 0U;
+      }
+      ++t.noRecord[kind];
+    }
+  }
+
+  const auto quantile = [](std::vector<float>& values, double q) {
+    if (values.empty()) {
+      return 0.;
+    }
+    const auto at = std::min(values.size() - 1U, static_cast<std::size_t>(q * static_cast<double>(values.size())));
+    std::ranges::nth_element(values, values.begin() + static_cast<std::ptrdiff_t>(at));
+    return static_cast<double>(values[at]);
+  };
+  LOGP(info, "fake anatomy, {}: the comparison's rule, by the track's layers; the one-wrong-cluster fakes by the label's own cluster on that layer", label);
+  for (std::size_t cls = 0; cls < kClasses; ++cls) {
+    const auto good = tracksByClass[cls][0];
+    const auto bad = tracksByClass[cls][1];
+    if (good + bad == 0U) {
+      continue;
+    }
+    auto& goodChi2 = chi2PerNdf[cls][0];
+    auto& fakeChi2 = chi2PerNdf[cls][1];
+    const double good90 = quantile(goodChi2, 0.9);
+    const double good99 = quantile(goodChi2, 0.99);
+    const auto fakesAbove = [&](double bound) { return percent(static_cast<std::uint64_t>(std::ranges::count_if(fakeChi2, [&](float v) { return static_cast<double>(v) > bound; })), fakeChi2.size()); };
+    LOGP(info,
+         "  {:<14} {:>7} tracks, {:>6} fake ({:.2f} %); kinked {:.1f} % of the good, {:.1f} % of the fakes; refit chi2/ndf 50/90/99 %: good "
+         "{:.2f}/{:.2f}/{:.2f}, fakes {:.2f}/{:.2f}/{:.2f}; fakes above the good's 90 % {:.1f} %, above its 99 % {:.1f} %",
+         kClassNames[cls], good + bad, bad, percent(bad, good + bad), percent(kinkedByClass[cls][0], good), percent(kinkedByClass[cls][1], bad), quantile(goodChi2, 0.5), good90, good99, quantile(fakeChi2, 0.5), quantile(fakeChi2, 0.9), quantile(fakeChi2, 0.99), fakesAbove(good90), fakesAbove(good99));
+    const auto& t = tally[cls];
+    if (t.oneWrong == 0U) {
+      continue;
+    }
+    const auto swaps = t.altFitFailed + t.altFailsCut + t.altAbove + t.altBelow;
+    auto& gap = tally[cls].belowGap;
+    LOGP(info,
+         "    one wrong cluster {} ({:.1f} % of the fakes): innermost {}, outermost {}, inside {}; it carries no primary {:.1f} %; the label has none on "
+         "that layer {} (ended before it {}, skipped it {}), its own there {}: with it the track fails to fit {}, fails the road cut {}, passes and "
+         "outranks the fake {} (its chain lost at tracklets {}, triplets {}, neighbours {}, roads {}, the road cut {}; not lost {}; no record {}: a "
+         "primary below the pT floor {}, a secondary {}, other {}), passes but ranks below the fake {} (the chi2 gap, 10/50/90 %: {:.2f}/{:.2f}/{:.2f})",
+         t.oneWrong, percent(t.oneWrong, bad), t.wrongAt[0], t.wrongAt[1], t.wrongAt[2], percent(t.wrongSecondary, t.oneWrong), t.holeEnded + t.holeSkipped, t.holeEnded, t.holeSkipped, swaps, t.altFitFailed, t.altFailsCut, t.altAbove, t.aboveLostAt[0], t.aboveLostAt[1], t.aboveLostAt[2], t.aboveLostAt[3], t.aboveLostAt[4], t.aboveLostAt[5], t.aboveLostAt[6], t.noRecord[0], t.noRecord[1], t.noRecord[2], t.altBelow, quantile(gap, 0.1), quantile(gap, 0.5), quantile(gap, 0.9));
+  }
+}
+
+/// Every track's time box, its rows' intersection: none may be empty; narrower than a row's box only where boxes are
+/// widened or staggered. And the frames a track's rows come from, told apart
+/// by their boxes' starts: more than one only with a margin.
+void reportTrackTimeBoxes(const Frame& frame, const typename TrackRefit<Det>::Tracks& tracks)
+{
+  const auto view = tracks.view();
+  std::uint64_t empty = 0U;
+  std::uint64_t narrowed = 0U;
+  std::array<std::uint64_t, 3> byFrames{}; // 1, 2, 3 or more
+  double widthSumNS = 0.;
+  for (std::size_t track = 0; track < tracks.size(); ++track) {
+    const auto& clusters = view.clusters[track];
+    const auto count = view.count[track];
+    const auto box = trackTimeBox(frame.measurements(), clusters, count);
+    empty += box.width == 0U ? 1U : 0U;
+    narrowed += box.width < timeBoxAt(frame.measurements(), clusters.index[0]).width ? 1U : 0U;
+    widthSumNS += 1.e-3 * static_cast<double>(box.width);
+    std::array<std::uint32_t, std::extent_v<std::remove_cvref_t<decltype(clusters.index)>>> starts{};
+    const auto rows = std::min<std::size_t>(count, starts.size());
+    for (std::size_t i = 0; i < rows; ++i) {
+      starts[i] = timeBoxAt(frame.measurements(), clusters.index[i]).start;
+    }
+    const auto used = std::span{starts}.first(rows);
+    std::ranges::sort(used);
+    const auto frames = static_cast<std::size_t>(std::ranges::distance(used.begin(), std::ranges::unique(used).begin()));
+    ++byFrames[std::min<std::size_t>(frames, 3U) - 1U];
+  }
+  LOGP(info, "track time boxes: {} tracks, {} empty, {} narrower than their first row's, mean width {:.1f} ns; by frames: 1: {} 2: {} 3+: {}", tracks.size(), empty, narrowed, tracks.size() > 0U ? widthSumNS / static_cast<double>(tracks.size()) : 0., byFrames[0], byFrames[1], byFrames[2]);
+}
+
+/// The pT edges [GeV] of measureTracks' and reportIncomplete's tables.
+constexpr std::array<Scalar, 11> kTrackPtEdges{0.F, 0.5F, 0.75F, 1.F, 1.25F, 1.5F, 2.F, 3.F, 5.F, 10.F, std::numeric_limits<Scalar>::infinity()};
+constexpr std::size_t kTrackPtBins = kTrackPtEdges.size() - 1U;
+
+/// A particle lost at the tracklets: its lost true pairs of \a survived into
+/// \a pairs by the cut, or one more in \a none if it has none recorded.
+void addLostPairs(const Funnel::IterationStages& survived, std::array<std::uint64_t, kPairLosses>& pairs, std::uint64_t& none)
+{
+  bool any = false;
+  for (std::size_t reason = 0; reason < kPairLosses; ++reason) {
+    pairs[reason] += survived.lostPairs[reason];
+    any |= survived.lostPairs[reason] != 0U;
+  }
+  none += any ? 0U : 1U;
+}
+
+/// Found incomplete: a particle whose true
+/// chain spans every layer, found with a good track short of one. By the
+/// iteration of its longest good track; whether the particle's pT is below
+/// that iteration's floor or its floor for a full-length road (the stub
+/// passed, the full road could not); which layers the track lacks; whether
+/// a lacking cluster is held by another track, good or fake, or is free;
+/// and, if every lacking cluster is free, the first stage where the
+/// particle's chain fell short in that iteration of the tracker's own run (\a
+/// funnel; none without one). \a particles:
+/// measureTracks's, by id, with `pt` and `longest`; \a goodTracks: each
+/// particle's good tracks.
+template <typename Particles>
+void reportIncomplete(const Frame& frame, const RecoSettings& param, double bzKiloGauss, const TrackingGeometry<Det>& tracking, const typename TrackRefit<Det>::Tracks& tracks, std::span<const TruthRow> truthRows, const Funnel* funnel, const Particles& particles, const std::unordered_map<std::uint64_t, std::vector<std::size_t>>& goodTracks, std::size_t iterations, const char* set, const TrueCrossings& crossings = {}, const ScatteringTable<Det>* scattering = nullptr, const o2::base::MatLayerCylSet* material = nullptr)
+{
+  const auto view = tracks.view();
+  constexpr auto nLayers = static_cast<std::uint32_t>(Detector<Det>::nLayers);
+  std::vector<std::uint32_t> holder(frame.size(), std::numeric_limits<std::uint32_t>::max());
+  for (std::size_t track = 0; track < tracks.size(); ++track) {
+    for (std::uint32_t i = 0; i < view.count[track]; ++i) {
+      holder[view.clusters[track].index[i]] = static_cast<std::uint32_t>(track);
+    }
+  }
+  std::vector<bool> isGood(tracks.size(), false);
+  for (const auto& [id, list] : goodTracks) {
+    for (const auto track : list) {
+      isGood[track] = true;
+    }
+  }
+  std::unordered_map<std::uint64_t, std::vector<Frame::Index>> rowsOf; // the all-layer particles' rows
+  for (const auto& [id, particle] : particles) {
+    if (particle.longest >= nLayers && goodTracks.contains(id)) {
+      rowsOf[id];
+    }
+  }
+  for (Frame::Index row = 0U; row < frame.size(); ++row) {
+    for (std::uint8_t i = 0; i < truthRows[row].count; ++i) {
+      if (const auto found = rowsOf.find(truthRows[row].particles[i]); found != rowsOf.end()) {
+        found->second.push_back(row);
+      }
+    }
+  }
+  const auto layerOfRow = [&](Frame::Index row) { return static_cast<std::uint32_t>(tracking.surface(frame.measurement(row).surface).layer); };
+  enum Why : std::uint8_t { kWhyBelowFloor,
+                            kWhyTaken,
+                            kWhyFreeTracklets,
+                            kWhyFreeTriplets,
+                            kWhyFreeNeighbours,
+                            kWhyFreeRoads,
+                            kWhyFreeFit,
+                            kWhyFreeSelection,
+                            kWhyFreeLater,
+                            kWhys };
+  constexpr std::array<const char*, kWhys> kWhyNames{"below the iteration's floors", "a lacking cluster taken by another track", "free, chain lost at tracklets", "free, at triplets", "free, at neighbours", "free, at roads", "free, at the road fit", "free, in the selection", "free, not in the funnel"};
+  std::array<std::uint64_t, kWhys> whys{};
+  std::array<std::array<std::uint64_t, 3>, kWhys> whysByPt{}; // below 0.3 GeV, 0.3-1, above 1
+  constexpr auto kLayerSlots = static_cast<std::size_t>(Detector<Det>::nLayers);
+  constexpr std::size_t kNotALink = nLinks<Det>;                               // the link that broke is none of the table's
+  std::array<std::array<std::uint64_t, nLinks<Det> + 1U>, kWhys> brokenLink{}; // by why, the link that broke
+  std::array<std::uint64_t, kPairLosses> trackletLostPairs{};
+  std::uint64_t trackletLostNone = 0U;
+  std::vector<std::uint64_t> byIteration(iterations, 0U);
+  std::uint64_t allLayerFound = 0U;
+  std::uint64_t incomplete = 0U;
+  std::uint64_t lacksOuter = 0U;  // only layers beyond the track's outermost
+  std::uint64_t lacksInner = 0U;  // only layers inside its innermost
+  std::uint64_t lacksMiddle = 0U; // a hole, or both ends
+  std::uint64_t takenByGood = 0U;
+  std::uint64_t takenByFake = 0U;
+  std::array<std::uint64_t, kTrackPtBins> incompleteByPt{};
+  std::array<std::uint64_t, kTrackPtBins> allLayerByPt{};
+  // The MC hits along every all-layer particle found: the kink at each
+  // crossing over its layer's theta0, as a check of the scattering model
+  // itself, and the clusters off their crossing; for the incomplete, the
+  // hardest kink, whether at the link that broke, by why.
+  const bool withHits = static_cast<bool>(crossings) && scattering != nullptr;
+  std::uint64_t particlesWithHits = 0U;
+  std::array<std::array<std::uint64_t, kKinkEdges.size()>, kLayerSlots> kinkByScatterer{};
+  // The same by |z| of the crossing the kink shows at: the material between
+  // the barrels depends on z (the services), the layer's band average does not.
+  constexpr std::array<double, 4> kZEdges{0., 10., 20., std::numeric_limits<double>::infinity()};
+  const auto zBinOf = [&](double z) {
+    std::size_t zBin = 0U;
+    while (zBin + 2U < kZEdges.size() && std::abs(z) >= kZEdges[zBin + 1U]) {
+      ++zBin;
+    }
+    return zBin;
+  };
+  std::array<std::array<std::array<std::uint64_t, kKinkEdges.size()>, kZEdges.size() - 1U>, kLayerSlots> kinkByScattererZ{};
+  // Over the LUT's own theta0 along the path, and that path's mean x/X0.
+  std::array<std::array<std::uint64_t, kKinkEdges.size()>, kLayerSlots> kinkPathByScatterer{};
+  std::array<double, kLayerSlots> pathX2X0Sum{};
+  std::array<std::uint64_t, kLayerSlots> pathCount{};
+  std::array<std::array<double, kZEdges.size() - 1U>, kLayerSlots> pathNormalSumZ{}; // normal-incidence x/X0 by |z| of the outer crossing
+  std::array<std::array<std::uint64_t, kZEdges.size() - 1U>, kLayerSlots> pathCountZ{};
+  std::array<std::uint64_t, kLayerSlots> offByLayer{};
+  std::array<std::array<std::uint64_t, kKinkEdges.size()>, kWhys> incompleteKink{};
+  std::array<std::array<std::uint64_t, kLayerSlots>, kWhys> incompleteKinkLayer{}; // the hardest kink's scatterer, for the hard ones
+  std::array<std::uint64_t, kWhys> incompleteKinkAtBroken{};
+  std::array<std::uint64_t, kWhys> incompleteOff{};
+  std::array<std::uint64_t, kWhys> incompleteNoHits{};
+  for (const auto& [id, rows] : rowsOf) {
+    const auto& list = goodTracks.at(id);
+    const auto best = *std::ranges::max_element(list, {}, [&](std::size_t track) { return view.count[track]; });
+    const auto& particle = particles.at(id);
+    const auto ptBin = binOf(particle.pt, kTrackPtEdges);
+    ++allLayerFound;
+    ++allLayerByPt[ptBin];
+    std::vector<TrueCrossingReport> reports;
+    double hardest = 0.;
+    std::uint32_t hardestAt = 0U;
+    bool anyOff = false;
+    if (withHits) {
+      reports = trueAnatomy(frame, *scattering, bzKiloGauss, crossings(id, rows), material);
+      particlesWithHits += reports.empty() ? 0U : 1U;
+      for (const auto& report : reports) {
+        if (std::isfinite(report.kinkPath)) {
+          const auto slot = std::min<std::size_t>(report.scatterer, kLayerSlots - 1U);
+          ++kinkPathByScatterer[slot][kinkBin(report.kinkPath)];
+          pathX2X0Sum[slot] += report.pathX2X0;
+          ++pathCount[slot];
+          const auto zBin = zBinOf(report.z);
+          pathNormalSumZ[slot][zBin] += report.pathNormalX2X0;
+          ++pathCountZ[slot][zBin];
+        }
+        // The hardest kink by the theta0 of the material actually crossed, with a LUT.
+        if (const double kink = std::isfinite(report.kinkPath) ? report.kinkPath : report.kink; std::isfinite(kink) && kink > hardest) {
+          hardest = kink;
+          hardestAt = report.scatterer;
+        }
+        if (std::isfinite(report.kink)) {
+          ++kinkByScatterer[std::min<std::size_t>(report.scatterer, kLayerSlots - 1U)][kinkBin(report.kink)];
+          ++kinkByScattererZ[std::min<std::size_t>(report.scatterer, kLayerSlots - 1U)][zBinOf(report.z)][kinkBin(report.kink)];
+        }
+        if (report.offsetCM > kOffsetCM) {
+          ++offByLayer[std::min<std::size_t>(report.layer, kLayerSlots - 1U)];
+          anyOff = true;
+        }
+      }
+    }
+    if (view.count[best] >= nLayers) {
+      continue;
+    }
+    ++incomplete;
+    ++incompleteByPt[ptBin];
+    const auto iteration = std::min<std::size_t>(view.iteration[best], iterations - 1U);
+    ++byIteration[iteration];
+    std::uint32_t has = 0U;
+    for (std::uint32_t i = 0; i < view.count[best]; ++i) {
+      has |= 1U << layerOfRow(view.clusters[best].index[i]);
+    }
+    const auto innermost = static_cast<std::uint32_t>(std::countr_zero(has));
+    const auto outermost = static_cast<std::uint32_t>(std::bit_width(has)) - 1U;
+    bool outer = true;
+    bool inner = true;
+    bool anyTaken = false;
+    for (const auto row : rows) {
+      const auto layer = layerOfRow(row);
+      if ((has & (1U << layer)) != 0U) {
+        continue;
+      }
+      outer &= layer > outermost;
+      inner &= layer < innermost;
+      const auto other = holder[row];
+      if (other != std::numeric_limits<std::uint32_t>::max() && other != best) {
+        anyTaken = true;
+        ++(isGood[other] ? takenByGood : takenByFake);
+      }
+    }
+    if (outer) {
+      ++lacksOuter;
+    } else if (inner) {
+      ++lacksInner;
+    } else {
+      ++lacksMiddle;
+    }
+    const auto settings = workflow::iterationSettings(param, static_cast<int>(iteration));
+    const double fullFloor = nLayers < settings.minPtGeVByClusters.size() ? settings.minPtGeVByClusters[nLayers] : 0.;
+    const auto survived = funnel != nullptr ? funnel->stages(id, iteration) : std::nullopt;
+    Why why = kWhyFreeLater;
+    if (static_cast<double>(particle.pt) < std::max(settings.windows.minPtGeV, fullFloor)) {
+      why = kWhyBelowFloor;
+    } else if (anyTaken) {
+      why = kWhyTaken;
+    } else if (survived.has_value()) {
+      switch (firstLoss(survived->longest, nLayers, false)) {
+        case FunnelStage::kTracklets:
+          why = kWhyFreeTracklets;
+          addLostPairs(*survived, trackletLostPairs, trackletLostNone);
+          break;
+        case FunnelStage::kTriplets:
+          why = kWhyFreeTriplets;
+          break;
+        case FunnelStage::kNeighbours:
+          why = kWhyFreeNeighbours;
+          break;
+        case FunnelStage::kRoads:
+          why = kWhyFreeRoads;
+          break;
+        case FunnelStage::kFit:
+          why = kWhyFreeFit;
+          break;
+        default:
+          why = kWhyFreeSelection;
+          break;
+      }
+    }
+    ++whys[why];
+    std::size_t ptSlot = 2U;
+    if (particle.pt < 0.3F) {
+      ptSlot = 0U;
+    } else if (particle.pt < 1.F) {
+      ptSlot = 1U;
+    }
+    ++whysByPt[why][ptSlot];
+    // The link that broke: into the first lacking layer beyond the track, or
+    // out of the last lacking layer inside it -- from its inner layer to the
+    // next (the particle has a row on every layer), as the table's link.
+    std::uint32_t brokenInner = outermost;
+    if (!outer) {
+      brokenInner = 0U;
+      for (const auto row : rows) {
+        const auto layer = layerOfRow(row);
+        if ((has & (1U << layer)) == 0U && layer < innermost) {
+          brokenInner = std::max(brokenInner, layer);
+        }
+      }
+    }
+    const auto broken = std::ranges::find_if(Det::layerLinks, [&](const auto& link) { return std::cmp_equal(link.from, brokenInner) && std::cmp_equal(link.to, brokenInner + 1U); });
+    ++brokenLink[why][static_cast<std::size_t>(broken - Det::layerLinks.begin())];
+    if (withHits) {
+      if (reports.empty()) {
+        ++incompleteNoHits[why];
+      } else {
+        ++incompleteKink[why][kinkBin(hardest)];
+        if (hardest >= kHardKink) {
+          ++incompleteKinkLayer[why][std::min<std::size_t>(hardestAt, kLayerSlots - 1U)];
+          incompleteKinkAtBroken[why] += hardestAt == brokenInner ? 1U : 0U;
+        }
+        incompleteOff[why] += anyOff ? 1U : 0U;
+      }
+    }
+  }
+  std::string whyLine;
+  for (std::size_t why = 0; why < kWhys; ++why) {
+    whyLine += fmt::format("{} {} {} ({}/{}/{} below 0.3, 0.3-1, above 1 GeV)", why == 0U ? "" : ",", kWhyNames[why], whys[why], whysByPt[why][0], whysByPt[why][1], whysByPt[why][2]);
+  }
+  std::string iterationLine;
+  for (std::size_t iteration = 0; iteration < iterations; ++iteration) {
+    iterationLine += fmt::format(" {}: {}", iteration, byIteration[iteration]);
+  }
+  std::string ptLine;
+  for (std::size_t bin = 0; bin < kTrackPtBins; ++bin) {
+    if (allLayerByPt[bin] != 0U) {
+      ptLine += fmt::format(" [{:.2f},{:.2f}) {:.1f}", kTrackPtEdges[bin], kTrackPtEdges[bin + 1U], percent(incompleteByPt[bin], allLayerByPt[bin]));
+    }
+  }
+  LOGP(info,
+       "  found incomplete, {}: {} of {} all-layer particles found ({:.2f}%); by the iteration of the longest good track:{}; lacking layers beyond it "
+       "{}, inside it {}, a hole or both ends {}; lacking clusters held by a good track {}, by a fake {}",
+       set, incomplete, allLayerFound, percent(incomplete, allLayerFound), iterationLine, lacksOuter, lacksInner, lacksMiddle, takenByGood, takenByFake);
+  LOGP(info, "    why:{}", whyLine);
+  std::string cuts;
+  for (std::size_t reason = 0; reason < kPairLosses; ++reason) {
+    cuts += fmt::format(" {} {}", kPairLossNames[reason], trackletLostPairs[reason]);
+  }
+  LOGP(info, "    the tracklet losses' adjacent-layer pairs of their own their iteration did not keep, by the first test each fails:{}; none recorded {}", cuts, trackletLostNone);
+  for (std::size_t why = 0; why < kWhys; ++why) {
+    if (whys[why] == 0U) {
+      continue;
+    }
+    std::string links;
+    for (std::size_t link = 0; link < nLinks<Det>; ++link) {
+      if (brokenLink[why][link] != 0U) {
+        links += fmt::format(" {}->{}: {}", Det::layerLinks[link].from, Det::layerLinks[link].to, brokenLink[why][link]);
+      }
+    }
+    if (brokenLink[why][kNotALink] != 0U) {
+      links += fmt::format(" no such link: {}", brokenLink[why][kNotALink]);
+    }
+    LOGP(info, "    {}, by the link that broke:{}", kWhyNames[why], links);
+  }
+  LOGP(info, "    incomplete % by pT [GeV]:{}", ptLine);
+  if (withHits) {
+    std::string spectrum;
+    std::string off;
+    for (std::size_t layer = 0; layer < kLayerSlots; ++layer) {
+      if (std::accumulate(kinkByScatterer[layer].begin(), kinkByScatterer[layer].end(), std::uint64_t{0}) != 0U) {
+        spectrum += fmt::format(" {}:{};", layer, kinkBinsLine(kinkByScatterer[layer]));
+      }
+      if (offByLayer[layer] != 0U) {
+        off += fmt::format(" {}: {}", layer, offByLayer[layer]);
+      }
+    }
+    LOGP(info,
+         "    the MC hits on the {} all-layer particles found with hits -- the kink over the layer's theta0, by the layer that scattered:{} clusters off "
+         "their crossing by more than {:.0f} um, by layer:{}",
+         particlesWithHits, spectrum, 1e4 * kOffsetCM, off);
+    std::string byZ;
+    for (std::size_t layer = 0; layer < kLayerSlots; ++layer) {
+      std::string bins;
+      for (std::size_t zBin = 0; zBin + 1U < kZEdges.size(); ++zBin) {
+        const auto& counts = kinkByScattererZ[layer][zBin];
+        const auto all = std::accumulate(counts.begin(), counts.end(), std::uint64_t{0});
+        if (all == 0U) {
+          continue;
+        }
+        std::uint64_t tail = 0U;
+        std::uint64_t hard = 0U;
+        for (std::size_t bin = 0; bin < kKinkEdges.size(); ++bin) {
+          tail += kKinkEdges[bin] >= kTailKink ? counts[bin] : 0U;
+          hard += kKinkEdges[bin] >= kHardKink ? counts[bin] : 0U;
+        }
+        bins += fmt::format(" |z| {:.0f}-{}: {} ({:.1f} % >= 3, {:.2f} % >= 5)", kZEdges[zBin], std::isfinite(kZEdges[zBin + 1U]) ? fmt::format("{:.0f}", kZEdges[zBin + 1U]) : std::string{"inf"}, all, percent(tail, all), percent(hard, all));
+      }
+      if (!bins.empty()) {
+        byZ += fmt::format(" layer {}:{};", layer, bins);
+      }
+    }
+    LOGP(info, "    the kink over theta0 by the layer that scattered and |z| [cm] of the crossing it shows at:{}", byZ);
+    if (material != nullptr) {
+      std::string path;
+      for (std::size_t layer = 0; layer < kLayerSlots; ++layer) {
+        if (pathCount[layer] != 0U) {
+          path += fmt::format(" {} (mean x/X0 {:.3f} %):{};", layer, 100. * pathX2X0Sum[layer] / static_cast<double>(pathCount[layer]), kinkBinsLine(kinkPathByScatterer[layer]));
+        }
+      }
+      LOGP(info, "    the same kink over theta0 from the LUT's x/X0 along the path between the two crossings, by the layer left:{}", path);
+      std::string normal;
+      for (std::size_t layer = 0; layer < kLayerSlots; ++layer) {
+        std::string bins;
+        for (std::size_t zBin = 0; zBin + 1U < kZEdges.size(); ++zBin) {
+          if (pathCountZ[layer][zBin] != 0U) {
+            bins += fmt::format(" |z| {:.0f}-{} {:.3f} %", kZEdges[zBin], std::isfinite(kZEdges[zBin + 1U]) ? fmt::format("{:.0f}", kZEdges[zBin + 1U]) : std::string{"inf"}, 100. * pathNormalSumZ[layer][zBin] / static_cast<double>(pathCountZ[layer][zBin]));
+          }
+        }
+        if (!bins.empty()) {
+          normal += fmt::format(" {}:{};", layer, bins);
+        }
+      }
+      LOGP(info, "    the LUT's x/X0 along the path at normal incidence, by the layer left and |z| [cm] of the crossing reached:{}", normal);
+    }
+    for (std::size_t why = 0; why < kWhys; ++why) {
+      if (whys[why] == 0U) {
+        continue;
+      }
+      std::string layers;
+      for (std::size_t layer = 0; layer < kLayerSlots; ++layer) {
+        if (incompleteKinkLayer[why][layer] != 0U) {
+          layers += fmt::format(" {}: {}", layer, incompleteKinkLayer[why][layer]);
+        }
+      }
+      LOGP(info,
+           "    {}: hardest kink over theta0{}; the kinks >= 5 by the layer that scattered:{}, at the link that broke {}; a cluster off its crossing {}; no "
+           "hits {}",
+           kWhyNames[why], kinkBinsLine(incompleteKink[why]), layers, incompleteKinkAtBroken[why], incompleteOff[why], incompleteNoHits[why]);
+    }
+  }
+}
+
+/// The lost true pairs by the cut, and the particles with none recorded.
+[[nodiscard]] std::string describeLostPairs(const std::array<std::uint64_t, kPairLosses>& pairs, std::uint64_t none)
+{
+  std::string text;
+  for (std::size_t reason = 0; reason < kPairLosses; ++reason) {
+    if (pairs[reason] != 0U) {
+      text += fmt::format(" {} {}", kPairLossNames[reason], pairs[reason]);
+    }
+  }
+  return fmt::format("{}; particles with none {}", text.empty() ? " -" : text, none);
+}
+
+/// The findable particles by their origin's distance in z from the beam spot,
+/// in its sigmaZ: the beam line's pair cut reaches nSigma of them.
+class OriginZTally
+{
+ public:
+  explicit OriginZTally(const VertexConstraint& beamSpot) : mBeamSpot(beamSpot) {}
+
+  void addFindable(Scalar originZ, bool found)
+  {
+    const auto bin = binOfZ(originZ);
+    ++mFindable[bin];
+    mFound[bin] += found ? 1U : 0U;
+  }
+
+  void addTrackletLoss(Scalar originZ) { ++mTrackletLosses[binOfZ(originZ)]; }
+
+  void report(const char* set) const
+  {
+    std::string line;
+    for (std::size_t bin = 0; bin < kBins; ++bin) {
+      line += fmt::format(" [{:g},{:g}) {}/{} ({:.2f}%), {} lost at the tracklets;", kEdges[bin], kEdges[bin + 1U], mFound[bin], mFindable[bin], percent(mFound[bin], mFindable[bin]), mTrackletLosses[bin]);
+    }
+    LOGP(info, "  {}, found of the findable by the origin's |z - z_beam| in the beam spot's sigmaZ ({:.2f} cm):{}", set, mBeamSpot.sigmaZ, line);
+  }
+
+ private:
+  static constexpr std::array<Scalar, 6> kEdges{0.F, 1.F, 2.F, 3.F, 4.F, std::numeric_limits<Scalar>::infinity()};
+  static constexpr std::size_t kBins = kEdges.size() - 1U;
+
+  [[nodiscard]] std::size_t binOfZ(Scalar originZ) const { return binOf(static_cast<Scalar>(std::abs(static_cast<double>(originZ) - mBeamSpot.z) / mBeamSpot.sigmaZ), kEdges); }
+
+  VertexConstraint mBeamSpot;
+  std::array<std::uint64_t, kBins> mFindable{};
+  std::array<std::uint64_t, kBins> mFound{};
+  std::array<std::uint64_t, kBins> mTrackletLosses{};
+};
+
+/// The tracker's run on the timeframe: its digests, the per-iteration line
+/// and the track time boxes; with MC, the tracks against the truth. A particle is **findable** by the
+/// comparison's rule (comparisonSettings, particleLayers, isFindable: its pT
+/// and the layers its clusters cover), in two sets, the physical primaries
+/// and the rest. A track is **good** if every cluster carries one particle,
+/// a **fake** otherwise (ITS's convention); a findable particle is **found**
+/// if a good track is its; each further good track of it is a **clone**.
+/// \a tracked, the comparisons, gets the tracks of a complete run first. The
+/// run is \a interface's; its timeframe ends with the caller's guard.
+void measureTracks(const Frame& frame, const RecoSettings& param, const VertexConstraint& beamSpot, std::span<const VertexSeed> vertices, std::span<const TruthRow> truthRows, const ParticleTable& truth, const Funnel* funnel, workflow::TrackingInterface<Det>& interface, const std::function<void(const TrackRefit<Det>::Tracks&)>& tracked = {}, const TrueCrossings& crossings = {})
+{
+  const auto* label = interface.trackerLabel().c_str();
+  const auto& tracking = interface.tracking();
+  const auto& material = interface.material();
+  const auto* scattering = &interface.scattering();
+  // Findable by the comparison's rule (isFindable): the funnel's, the QA's.
+  const auto first = workflow::iterationSettings(param, 0);
+  const auto findableRule = comparisonSettings<Det>();
+  const auto minLayers = static_cast<std::uint32_t>(findableRule.minLayers);
+  const auto iterations = static_cast<std::size_t>(workflow::iterationCount(param));
+  auto& tracker = interface.tracker();
+  const auto run = interface.track(frame, vertices);
+  if (run.dropped) {
+    return;
+  }
+  const auto& result = run.result;
+  const double seconds = run.seconds;
+  if (tracked) {
+    tracked(*result.tracks);
+  }
+  const auto& tracks = *result.tracks;
+  const auto view = tracks.view();
+  LOGP(info, "tracks, {}: {} in {:.3f} s", label, tracks.size(), seconds);
+  // The output's fingerprint: what a speed change must leave alone.
+  LOGP(info, "digest, {}: {:016x}", label, trackingDigest(result, tracker.used()));
+  LOGP(info, "digest, {}, clusters: {:016x}", label, clusterDigest(result, frame, tracker.used()));
+  using profile::Phase;
+  for (std::size_t iteration = 0; iteration < result.iterations.size(); ++iteration) {
+    const auto& summary = result.iterations[iteration];
+    for (const auto& line : study::describeIteration(summary, iteration)) {
+      LOGP(info, "{}", line);
+    }
+    // The serial passes between the parallel stages, inside the slice and road
+    // times above, from the profile. The share is of those two.
+    LOGP(info, "    slices by stage: {:.3f} s tracklets, {:.3f} s triplets, {:.3f} s neighbours", summary.seconds(Phase::kTracklets), summary.seconds(Phase::kTriplets), summary.seconds(Phase::kNeighbours));
+    if (summary.roads == 0U) {
+      continue; // an empty timeframe times nothing; the shares would be noise
+    }
+    const auto sum = [&](std::initializer_list<Phase> phases) {
+      double total = 0.;
+      for (const auto phase : phases) {
+        total += summary.seconds(phase);
+      }
+      return total;
+    };
+    const double resets = sum({Phase::kTrackletReset, Phase::kTripletReset, Phase::kNeighbourReset, Phase::kRoadFitReset});
+    const double scans = sum({Phase::kTrackletScan, Phase::kTripletScan, Phase::kNeighbourScan, Phase::kRoadFitScan});
+    const double serial = resets + scans + sum({Phase::kPermutation, Phase::kEndIndex, Phase::kRoadStarts});
+    const double staged = summary.seconds(Phase::kSlices) + summary.seconds(Phase::kRoads);
+    LOGP(info,
+         "    serial host passes: {:.3f} s of {:.3f} s slices+roads ({:.1f} %); {:.3f} s stage resets, {:.3f} s stage scans, "
+         "{:.3f} s permutation, {:.3f} s end index, {:.3f} s road scans",
+         serial, staged, staged > 0. ? 100. * serial / staged : 0., resets, scans, summary.seconds(Phase::kPermutation), summary.seconds(Phase::kEndIndex), summary.seconds(Phase::kRoadStarts));
+  }
+  reportTrackTimeBoxes(frame, tracks);
+  if (truthRows.empty()) {
+    return;
+  }
+
+  // The MC particles: every particle on a row, with its longest chain
+  // (particleLayers) and the kinds of layers it has; findable by the
+  // comparison's rule, in two sets: the physical primaries and the rest.
+  struct Particle {
+    Scalar pt = 0.F;
+    Scalar cotTheta = 0.F;
+    Scalar originZ = 0.F;
+    std::uint32_t longest = 0U; ///< its longest chain (particleLayers)
+    bool barrel = false;        ///< has a barrel layer
+    bool disc = false;          ///< has a disc layer
+    bool findable = false;
+    std::size_t set = 0U;      ///< 0 a physical primary, 1 another particle
+    std::uint32_t good = 0U;   ///< good tracks of it
+    std::uint8_t foundBy = 0U; ///< the iteration of its first good track
+  };
+  std::unordered_map<std::uint64_t, Particle> particles;
+  for (const auto& [id, layers] : particleLayers(truthRows, findableRule)) {
+    const auto found = truth.find(id);
+    if (found == truth.end()) {
+      continue;
+    }
+    const auto& t = found->second;
+    Particle particle{
+      .pt = t.pt,
+      .cotTheta = static_cast<Scalar>(std::sinh(static_cast<double>(t.eta))),
+      .originZ = t.vz,
+      .findable = isFindable(t.pt, layers, findableRule),
+      .set = t.origin == ParticleOrigin::kPhysicalPrimary ? 0U : 1U,
+    };
+    particle.longest = layers.chain;
+    for (auto bits = layers.layers; bits != 0U; bits &= bits - 1U) {
+      (Detector<Det>::isBarrelLayer(static_cast<LayerID>(std::countr_zero(bits))) ? particle.barrel : particle.disc) = true;
+    }
+    particles.emplace(id, particle);
+  }
+
+  // The tracks.
+  constexpr std::size_t kCountSlots = 18U;
+  std::array<std::uint64_t, kCountSlots> tracksByCount{};
+  std::array<std::uint64_t, kCountSlots> fakesByCount{};
+  std::array<std::uint64_t, kCountSlots> extensionsByCount{};
+  std::array<std::uint64_t, 5> fakePurity{}; // majority fraction: <50, 50-75, 75-90, 90-100, noise-only
+  std::uint64_t good = 0U;
+  std::uint64_t goodNotFindable = 0U;
+  std::uint64_t extendedTracks = 0U;
+  std::uint64_t addedClusters = 0U;
+  std::uint64_t ownAddedClusters = 0U;
+  std::vector<std::uint64_t> tracksByIteration(iterations, 0U);
+  std::vector<std::uint64_t> fakesByIteration(iterations, 0U);
+  std::uint64_t kinkedTracks = 0U;
+  std::uint64_t kinkedFakes = 0U;
+  std::array<std::uint64_t, static_cast<std::size_t>(Detector<Det>::nLayers)> kinksByLayer{};
+  // Who holds a particle's rows among the fakes: one whose majority is the
+  // particle itself -- it was found with a wrong cluster -- or another.
+  std::unordered_map<std::uint64_t, bool> heldByOwnFake;
+  std::unordered_map<std::uint64_t, bool> heldByOtherFake;
+  // Every good track of a particle, in output order: iteration, then best first.
+  std::unordered_map<std::uint64_t, std::vector<std::size_t>> goodTracks;
+  for (std::size_t track = 0; track < tracks.size(); ++track) {
+    const auto count = view.count[track];
+    const auto iteration = std::min<std::size_t>(view.iteration[track], iterations - 1U);
+    ++tracksByIteration[iteration];
+    ++tracksByCount[std::min<std::size_t>(count, kCountSlots - 1U)];
+    const std::span<const std::uint32_t> trackRows{view.clusters[track].index, count};
+    const std::uint32_t addedInward = view.addedInward[track];
+    const std::uint32_t addedOutward = view.addedOutward[track];
+    const std::uint32_t added = addedInward + addedOutward;
+    ++extensionsByCount[std::min<std::size_t>(added, kCountSlots - 1U)];
+    if (added != 0U) {
+      ++extendedTracks;
+      addedClusters += added;
+      const std::uint32_t originalEnd = count - addedOutward;
+      const auto owner = majorityParticle(truthRows, trackRows.subspan(addedInward, originalEnd - addedInward)).particle;
+      for (std::uint32_t i = 0; i < count; ++i) {
+        const bool addedHere = i < addedInward || i >= originalEnd;
+        ownAddedClusters += addedHere && owner != kNoTrackParticle && truthRows[trackRows[i]].carries(owner) ? 1U : 0U;
+      }
+    }
+    const auto goodId = goodParticle(truthRows, trackRows);
+    const bool one = goodId != kNoTrackParticle;
+    if (view.kinks[track] != 0U) {
+      ++kinkedTracks;
+      kinkedFakes += one ? 0U : 1U;
+      const auto kinkRow = view.clusters[track].index[view.kinkCluster[track]];
+      ++kinksByLayer[static_cast<std::size_t>(tracking.surface(frame.measurement(kinkRow).surface).layer)];
+    }
+    if (one) {
+      ++good;
+      goodTracks[goodId].push_back(track);
+      const auto particle = particles.find(goodId);
+      if (particle != particles.end() && particle->second.findable) {
+        if (particle->second.good == 0U) {
+          particle->second.foundBy = static_cast<std::uint8_t>(iteration);
+        }
+        ++particle->second.good;
+      } else {
+        ++goodNotFindable;
+      }
+      continue;
+    }
+    ++fakesByCount[std::min<std::size_t>(count, kCountSlots - 1U)];
+    ++fakesByIteration[iteration];
+    const auto [majorityId, majority] = majorityParticle(truthRows, trackRows);
+    for (const auto row : trackRows) {
+      for (std::uint8_t i = 0; i < truthRows[row].count; ++i) {
+        const auto id = truthRows[row].particles[i];
+        (id == majorityId ? heldByOwnFake : heldByOtherFake)[id] = true;
+      }
+    }
+    const double purity = static_cast<double>(majority) / static_cast<double>(count);
+    std::size_t bin = 3U;
+    if (majority == 0U) {
+      bin = 4U;
+    } else if (purity < 0.5) {
+      bin = 0U;
+    } else if (purity < 0.75) {
+      bin = 1U;
+    } else if (purity < 0.9) {
+      bin = 2U;
+    }
+    ++fakePurity[bin];
+  }
+
+  // The particles, per set: findable or not, found, cloned; by pT,
+  // cot(theta), kind of layers and longest run; the missed by the first stage
+  // of the first iteration without a chain of the minimum of their own.
+  enum Loss : std::uint8_t { kTracklets,
+                             kTriplets,
+                             kNeighbours,
+                             kRoads,
+                             kFit,
+                             kSelectionOwnFake,
+                             kSelectionOtherFake,
+                             kSelectionElse,
+                             kLosses };
+  struct SetTally {
+    explicit SetTally(const VertexConstraint& beamSpot) : byOriginZ{beamSpot} {}
+    std::uint64_t withCluster = 0U; ///< above the findable floor with a cluster
+    std::uint64_t findable = 0U;
+    std::uint64_t found = 0U;
+    std::uint64_t clones = 0U;
+    std::uint64_t findableAboveFirst = 0U; ///< the funnel's denominator
+    std::uint64_t missedBelowFirst = 0U;
+    std::array<std::uint64_t, 3> findableByKind{};
+    std::array<std::uint64_t, 3> foundByKind{};
+    std::array<std::uint64_t, kTrackPtBins> findableByPt{};
+    std::array<std::uint64_t, kTrackPtBins> foundByPt{};
+    std::array<std::uint64_t, kCotThetaBins> findableByCot{};
+    std::array<std::uint64_t, kCotThetaBins> foundByCot{};
+    std::array<std::uint64_t, kCountSlots> findableByChain{};
+    std::array<std::uint64_t, kCountSlots> foundByChain{};
+    std::array<std::uint64_t, kCountSlots> notFindableByChain{};
+    std::array<std::uint64_t, kLosses> losses{};
+    std::uint64_t lostAtRoadsRaised = 0U;
+    // Of those lost at the tracklet stage: their adjacent-layer pairs of their
+    // own the first iteration did not keep, by the first test each fails (the
+    // funnel's); and the particles with none recorded (from the vertex list).
+    std::array<std::uint64_t, kPairLosses> trackletLossPairs{};
+    std::uint64_t trackletLossNone = 0U;
+    OriginZTally byOriginZ;
+  };
+  constexpr std::array<const char*, 2> kSetNames{"physical primaries", "other findable"};
+  std::array<SetTally, 2> sets{SetTally{beamSpot}, SetTally{beamSpot}};
+  std::vector<std::uint64_t> foundByIteration(iterations, 0U);
+  for (const auto& [id, particle] : particles) {
+    if (static_cast<double>(particle.pt) < findableRule.minPtGeV) {
+      continue;
+    }
+    auto& set = sets[particle.set];
+    ++set.withCluster;
+    const auto chain = std::min<std::size_t>(particle.longest, kCountSlots - 1U);
+    if (!particle.findable) {
+      ++set.notFindableByChain[chain];
+      continue;
+    }
+    std::size_t kind = 0U; // barrel only
+    if (particle.barrel && particle.disc) {
+      kind = 2U;
+    } else if (particle.disc) {
+      kind = 1U;
+    }
+    const bool hit = particle.good != 0U;
+    ++set.findable;
+    set.findableAboveFirst += static_cast<double>(particle.pt) >= first.windows.minPtGeV ? 1U : 0U;
+    ++set.findableByKind[kind];
+    ++set.findableByPt[binOf(particle.pt, kTrackPtEdges)];
+    ++set.findableByCot[binOf(particle.cotTheta, kCotThetaEdges)];
+    ++set.findableByChain[chain];
+    set.byOriginZ.addFindable(particle.originZ, hit);
+    if (hit) {
+      ++set.found;
+      ++set.foundByKind[kind];
+      ++set.foundByPt[binOf(particle.pt, kTrackPtEdges)];
+      ++foundByIteration[particle.foundBy];
+      ++set.foundByCot[binOf(particle.cotTheta, kCotThetaEdges)];
+      ++set.foundByChain[chain];
+      set.clones += particle.good - 1U;
+      continue;
+    }
+    // The funnel's stages are the first iteration's: a softer particle is
+    // counted apart.
+    if (static_cast<double>(particle.pt) < first.windows.minPtGeV) {
+      ++set.missedBelowFirst;
+      continue;
+    }
+    // Every findable particle is the funnel's: the same rule.
+    const auto survived = funnel != nullptr ? funnel->stages(id, 0U) : std::nullopt;
+    if (!survived.has_value()) {
+      continue;
+    }
+    Loss loss = kSelectionElse;
+    switch (firstLoss(survived->longest, minLayers, false)) {
+      case FunnelStage::kTracklets:
+        loss = kTracklets;
+        addLostPairs(*survived, set.trackletLossPairs, set.trackletLossNone);
+        set.byOriginZ.addTrackletLoss(particle.originZ);
+        break;
+      case FunnelStage::kTriplets:
+        loss = kTriplets;
+        break;
+      case FunnelStage::kNeighbours:
+        loss = kNeighbours;
+        break;
+      case FunnelStage::kRoads:
+        loss = kRoads;
+        set.lostAtRoadsRaised += survived->roadLoss == RoadLoss::kRaised || survived->roadLoss == RoadLoss::kRaisedBelow || survived->roadLoss == RoadLoss::kRaisedUnlinked ? 1U : 0U;
+        break;
+      case FunnelStage::kFit:
+        loss = kFit;
+        break;
+      default:
+        if (heldByOwnFake.contains(id)) {
+          loss = kSelectionOwnFake;
+        } else if (heldByOtherFake.contains(id)) {
+          loss = kSelectionOtherFake;
+        }
+        break;
+    }
+    ++set.losses[loss];
+  }
+  for (std::size_t index = 0; index < sets.size(); ++index) {
+    std::unordered_map<std::uint64_t, Particle> ofSet;
+    for (const auto& [id, particle] : particles) {
+      if (particle.findable && particle.set == index) {
+        ofSet.emplace(id, particle);
+      }
+    }
+    reportIncomplete(frame, param, interface.propagator().bzKiloGauss, tracking, tracks, truthRows, funnel, ofSet, goodTracks, iterations, kSetNames[index], crossings, scattering, &material);
+  }
+  const std::uint64_t fakes = tracks.size() - good;
+  LOGP(info, "  tracks: {} fakes of {} ({:.2f}%)", fakes, tracks.size(), percent(fakes, tracks.size()));
+  constexpr std::array<const char*, 3> kKinds{"barrel layers", "disc layers", "both"};
+  for (std::size_t index = 0; index < sets.size(); ++index) {
+    const auto& set = sets[index];
+    LOGP(info, "  MC, {}: {} above {} GeV with a cluster; findable (a chain of {} layers): {}", kSetNames[index], set.withCluster, findableRule.minPtGeV, minLayers, set.findable);
+    LOGP(info, "  efficiency, {}: {:.2f}% of the findable, {:.2f}% of all above {} GeV with a cluster; clones {:.2f}%", kSetNames[index], percent(set.found, set.findable), percent(set.found, set.withCluster), findableRule.minPtGeV, percent(set.clones, set.found));
+    for (std::size_t kind = 0; kind < kKinds.size(); ++kind) {
+      LOGP(info, "    {:<13} findable {:>7}, found {:.2f}%", kKinds[kind], set.findableByKind[kind], percent(set.foundByKind[kind], set.findableByKind[kind]));
+    }
+    std::string byPt;
+    for (std::size_t bin = 0; bin < kTrackPtBins; ++bin) {
+      if (set.findableByPt[bin] != 0U) {
+        byPt += fmt::format(" [{:.2f},{:.2f}) {} {:.2f}%", kTrackPtEdges[bin], kTrackPtEdges[bin + 1U], set.findableByPt[bin], percent(set.foundByPt[bin], set.findableByPt[bin]));
+      }
+    }
+    LOGP(info, "    by pT [GeV]:{}", byPt);
+    std::string byCot;
+    for (std::size_t bin = 0; bin < kCotThetaBins; ++bin) {
+      if (set.findableByCot[bin] != 0U) {
+        byCot += fmt::format(" [{:.2f},{:.2f}) {:.2f}%", kCotThetaEdges[bin], kCotThetaEdges[bin + 1U], percent(set.foundByCot[bin], set.findableByCot[bin]));
+      }
+    }
+    LOGP(info, "    by cot(theta):{}", byCot);
+    std::string byChain;
+    std::string notFindable;
+    for (std::size_t chain = 1; chain < kCountSlots; ++chain) {
+      if (set.findableByChain[chain] != 0U) {
+        byChain += fmt::format(" {}: {} {:.2f}%", chain, set.findableByChain[chain], percent(set.foundByChain[chain], set.findableByChain[chain]));
+      }
+      if (set.notFindableByChain[chain] != 0U) {
+        notFindable += fmt::format(" {}: {}", chain, set.notFindableByChain[chain]);
+      }
+    }
+    LOGP(info, "    findable by their longest chain: count, found:{}", byChain);
+    LOGP(info, "    not findable, by their longest chain:{}", notFindable);
+  }
+  std::string byCount;
+  for (std::size_t count = 1; count < kCountSlots; ++count) {
+    if (tracksByCount[count] != 0U) {
+      byCount += fmt::format(" {}: {} ({:.2f}% fake)", count, tracksByCount[count], percent(fakesByCount[count], tracksByCount[count]));
+    }
+  }
+  LOGP(info, "  tracks by clusters:{}", byCount);
+  std::string kinkLayers;
+  for (std::size_t layer = 0; layer < kinksByLayer.size(); ++layer) {
+    if (kinksByLayer[layer] != 0U) {
+      kinkLayers += fmt::format(" {}: {}", layer, kinksByLayer[layer]);
+    }
+  }
+  LOGP(info, "  kinks: {} tracks ({:.2f}%), {:.2f}% of them fake; by the layer of the kink's cluster:{}", kinkedTracks, percent(kinkedTracks, tracks.size()), percent(kinkedFakes, kinkedTracks), kinkLayers);
+  std::string extensions;
+  for (std::size_t count = 1; count < kCountSlots; ++count) {
+    if (extensionsByCount[count] != 0U) {
+      extensions += fmt::format(" {}: {}", count, extensionsByCount[count]);
+    }
+  }
+  LOGP(info, "  follow: {} tracks, {} clusters, {:.2f} per followed track; tracks by clusters added:{}", extendedTracks, addedClusters, extendedTracks == 0U ? 0. : static_cast<double>(addedClusters) / static_cast<double>(extendedTracks), extensions);
+  LOGP(info, "  follow MC: {}/{} added clusters ({:.2f}%) belong to the original track's majority particle", ownAddedClusters, addedClusters, percent(ownAddedClusters, addedClusters));
+  LOGP(info, "  fakes by their majority particle's share: <50% {}, 50-75% {}, 75-90% {}, 90-100% {}, noise only {}", fakePurity[0], fakePurity[1], fakePurity[2], fakePurity[3], fakePurity[4]);
+  LOGP(info, "  good tracks of a particle not findable (below {} GeV, or no chain of {} layers): {}", findableRule.minPtGeV, minLayers, goodNotFindable);
+  for (std::size_t iteration = 0; iteration < result.iterations.size(); ++iteration) {
+    const auto settings = workflow::iterationSettings(param, static_cast<int>(iteration));
+    std::string shape = fmt::format(", {} clusters or more", std::max(settings.minClusters, 4));
+    if (!settings.skipLinks) {
+      shape += ", no holes";
+    }
+    if (settings.layerMask != 0U) {
+      shape += ", links within layers";
+      for (auto bits = settings.layerMask; bits != 0U; bits &= bits - 1U) {
+        shape += fmt::format(" {}", std::countr_zero(bits));
+      }
+    }
+    if (settings.roadEndLayers != 0U) {
+      shape += ", roads ending on layers";
+      for (auto bits = settings.roadEndLayers; bits != 0U; bits &= bits - 1U) {
+        shape += fmt::format(" {}", std::countr_zero(bits));
+      }
+    }
+    std::string floors;
+    for (std::size_t count = 0; count < settings.minPtGeVByClusters.size(); ++count) {
+      if (settings.minPtGeVByClusters[count] > 0.) {
+        floors += fmt::format(" {}: {:.3g}", count, settings.minPtGeVByClusters[count]);
+      }
+    }
+    if (!floors.empty()) {
+      shape += ", pT floor by clusters" + floors;
+    }
+    LOGP(info, "  iteration {} (pT_min {} GeV{}): {} tracks, {:.2f}% fake; first to find {} particles", iteration, settings.windows.minPtGeV, shape, tracksByIteration[iteration], percent(fakesByIteration[iteration], tracksByIteration[iteration]), foundByIteration[iteration]);
+  }
+  // The clones: each further good track B of a particle against its first, A,
+  // by the iterations that found them and by where B lies -- inside A's
+  // innermost cluster, beyond its outermost (by distance from the origin), on
+  // layers A has too, or interleaved with A.
+  std::array<std::pair<Frame::Index, Frame::Index>, Frame::kLayerCount> layerRows{};
+  for (std::size_t layer = 0; layer < Frame::kLayerCount; ++layer) {
+    const auto rows = frame.grid().layerRows(static_cast<LayerID>(layer));
+    layerRows[layer] = {rows.begin, rows.end};
+  }
+  const auto layerOf = [&](Frame::Index row) {
+    for (std::size_t layer = 0; layer < Frame::kLayerCount; ++layer) {
+      if (row >= layerRows[layer].first && row < layerRows[layer].second) {
+        return layer;
+      }
+    }
+    return Frame::kLayerCount;
+  };
+  const auto distance = [&](Frame::Index row) {
+    const auto m = frame.measurement(row);
+    return std::hypot(static_cast<double>(m.x), static_cast<double>(m.y), static_cast<double>(m.z));
+  };
+  enum Relation : std::uint8_t { kInner,
+                                 kOuter,
+                                 kSameLayers,
+                                 kInterleaved,
+                                 kRelations };
+  // A split -- the clone inside or beyond the first -- by the first stage of
+  // the first iteration whose longest surviving chain of the particle is
+  // shorter than the two tracks together: there the particle's chain broke.
+  enum Split : std::uint8_t { kSplitTracklets,
+                              kSplitTriplets,
+                              kSplitNeighbours,
+                              kSplitRoads,
+                              kSplitFit,
+                              kSplitElse,
+                              kSplitBelowFirst,
+                              kSplitNotFindable,
+                              kSplits };
+  std::array<std::uint64_t, kSplits> splits{};
+  std::array<std::uint64_t, kPairLosses> splitLostPairs{};
+  std::uint64_t splitLostNone = 0U;
+  std::vector<std::vector<std::array<std::uint64_t, kRelations>>> cloneRelations(iterations, std::vector<std::array<std::uint64_t, kRelations>>(iterations));
+  std::array<std::uint64_t, kCountSlots> cloneClusters{};
+  for (const auto& [id, list] : goodTracks) {
+    if (list.size() < 2U) {
+      continue;
+    }
+    const auto a = list.front();
+    double innerA = std::numeric_limits<double>::max();
+    double outerA = 0.;
+    std::array<bool, Frame::kLayerCount> layersA{};
+    for (std::uint32_t i = 0; i < view.count[a]; ++i) {
+      const auto row = view.clusters[a].index[i];
+      innerA = std::min(innerA, distance(row));
+      outerA = std::max(outerA, distance(row));
+      layersA[std::min(layerOf(row), Frame::kLayerCount - 1U)] = true;
+    }
+    for (std::size_t other = 1; other < list.size(); ++other) {
+      const auto b = list[other];
+      double innerB = std::numeric_limits<double>::max();
+      double outerB = 0.;
+      bool sameLayers = true;
+      for (std::uint32_t i = 0; i < view.count[b]; ++i) {
+        const auto row = view.clusters[b].index[i];
+        innerB = std::min(innerB, distance(row));
+        outerB = std::max(outerB, distance(row));
+        sameLayers &= layersA[std::min(layerOf(row), Frame::kLayerCount - 1U)];
+      }
+      Relation relation = kInterleaved;
+      if (outerB < innerA) {
+        relation = kInner;
+      } else if (innerB > outerA) {
+        relation = kOuter;
+      } else if (sameLayers) {
+        relation = kSameLayers;
+      }
+      const auto iterationA = std::min<std::size_t>(view.iteration[a], iterations - 1U);
+      const auto iterationB = std::min<std::size_t>(view.iteration[b], iterations - 1U);
+      ++cloneRelations[iterationA][iterationB][relation];
+      if (relation == kInner || relation == kOuter) {
+        const auto need = static_cast<std::uint32_t>(view.count[a]) + view.count[b];
+        const auto stage = funnel != nullptr ? funnel->stages(id, 0U) : std::nullopt;
+        const auto splitParticle = particles.find(id);
+        Split split = kSplitElse;
+        if (splitParticle == particles.end() || !splitParticle->second.findable || !stage.has_value()) {
+          split = kSplitNotFindable;
+        } else if (static_cast<double>(splitParticle->second.pt) < first.windows.minPtGeV) {
+          // The first iteration's windows admit a softer particle's short
+          // fragment; the iteration it belongs to then finds the rest.
+          split = kSplitBelowFirst;
+        } else {
+          switch (firstLoss(stage->longest, need, false)) {
+            case FunnelStage::kTracklets:
+              split = kSplitTracklets;
+              addLostPairs(*stage, splitLostPairs, splitLostNone);
+              break;
+            case FunnelStage::kTriplets:
+              split = kSplitTriplets;
+              break;
+            case FunnelStage::kNeighbours:
+              split = kSplitNeighbours;
+              break;
+            case FunnelStage::kRoads:
+              split = kSplitRoads;
+              break;
+            case FunnelStage::kFit:
+              split = kSplitFit;
+              break;
+            default:
+              break;
+          }
+        }
+        ++splits[split];
+      }
+      ++cloneClusters[std::min<std::size_t>(view.count[b], kCountSlots - 1U)];
+    }
+  }
+  for (std::size_t iterationA = 0; iterationA < result.iterations.size(); ++iterationA) {
+    for (std::size_t iterationB = iterationA; iterationB < result.iterations.size(); ++iterationB) {
+      const auto& relations = cloneRelations[iterationA][iterationB];
+      const auto total = relations[kInner] + relations[kOuter] + relations[kSameLayers] + relations[kInterleaved];
+      if (total != 0U) {
+        LOGP(info, "  clones, first found by iteration {}, clone by {}: {} -- inside the first {}, beyond it {}, on its layers {}, interleaved {}", iterationA, iterationB, total, relations[kInner], relations[kOuter], relations[kSameLayers], relations[kInterleaved]);
+      }
+    }
+  }
+  std::string cloneCounts;
+  for (std::size_t count = 1; count < kCountSlots; ++count) {
+    if (cloneClusters[count] != 0U) {
+      cloneCounts += fmt::format(" {}: {}", count, cloneClusters[count]);
+    }
+  }
+  LOGP(info, "  clones by their clusters:{}", cloneCounts);
+  LOGP(info,
+       "  split clones (inside or beyond the first), by the first stage of the first iteration whose longest chain of the particle is "
+       "shorter than both tracks together: tracklets {}, triplets {}, neighbours {}, roads {}, road fit {}, none {}; "
+       "below the first iteration's pT_min {}; not findable {}",
+       splits[kSplitTracklets], splits[kSplitTriplets], splits[kSplitNeighbours], splits[kSplitRoads], splits[kSplitFit], splits[kSplitElse], splits[kSplitBelowFirst], splits[kSplitNotFindable]);
+  LOGP(info, "    the tracklet splits' adjacent-layer pairs of their own the first iteration did not keep, by the first test:{}", describeLostPairs(splitLostPairs, splitLostNone));
+  for (std::size_t index = 0; index < sets.size(); ++index) {
+    const auto& set = sets[index];
+    const auto& losses = set.losses;
+    const auto missed = set.findable - set.found - set.missedBelowFirst;
+    LOGP(info,
+         "  missed {} above the first iteration's pT_min {} ({:.2f}% of their findable): the first stage without a chain of {} clusters "
+         "entirely theirs -- tracklets {}, triplets {}, neighbours {}, roads {} ({} raised by another's predecessor), fit {}; lost in the "
+         "selection to a fake of their own {}, to another's fake {}, otherwise {}; missed below it {}",
+         kSetNames[index], missed, percent(missed, set.findableAboveFirst), minLayers, losses[kTracklets], losses[kTriplets], losses[kNeighbours], losses[kRoads], set.lostAtRoadsRaised, losses[kFit], losses[kSelectionOwnFake], losses[kSelectionOtherFake], losses[kSelectionElse], set.missedBelowFirst);
+    LOGP(info, "    the tracklet losses' adjacent-layer pairs of their own the first iteration did not keep, by the first test:{}", describeLostPairs(set.trackletLossPairs, set.trackletLossNone));
+    set.byOriginZ.report(kSetNames[index]);
+  }
+}
+
+void writeTruthBreakdown(std::ostream& output, std::size_t timeframe, const char* vertexSource, const TrackletRunSummary& summary)
+{
+  for (std::size_t link = 0; link < nLinks<Det>; ++link) {
+    for (std::size_t pt = 0; pt < kPtBins; ++pt) {
+      for (std::size_t cot = 0; cot < kCotThetaBins; ++cot) {
+        const auto total = summary.truthBreakdown[link][pt][cot];
+        if (total == 0U) {
+          continue;
+        }
+        output << timeframe << ',' << vertexSource << ',' << static_cast<unsigned int>(Det::layerLinks[link].from) << ',' << static_cast<unsigned int>(Det::layerLinks[link].to) << ',' << kPtEdges[pt] << ',' << kPtEdges[pt + 1U] << ',' << kCotThetaEdges[cot] << ',' << kCotThetaEdges[cot + 1U] << ',' << summary.truthBreakdownKept[link][pt][cot] << ',' << total << '\n';
+      }
+    }
+  }
+}
+
+/// O2's MC hits for \a D, or none if \a path is not there: the pulls are an
+/// addition to the comparison, not a condition of it.
+template <DetectorLayout D>
+std::unique_ptr<study::HitFile> openHits(const std::string& path, const std::string& discPath)
+{
+  try {
+    return std::make_unique<study::HitFile>(path, study::chipsOf<D>(), discPath);
+  } catch (const std::runtime_error& error) {
+    LOGP(warning, "no pulls: {}", error.what());
+    return nullptr;
+  }
+}
+
+/// Binds the producer's message after checking its layout and positions
+/// against the sink's geometry, and tracks it with the study's observers.
+class MeasurementSinkTask : public Task
+{
+ public:
+  MeasurementSinkTask(bool useMC, bool withVertices, TrackerProducts products, std::shared_ptr<workflow::Conditions<Det, true>> conditions)
+    : mUseMC(useMC),
+      mWithVertices(withVertices),
+      mTrackerProducts(products),
+      mInterface(withVertices),
+      mConditions(std::move(conditions))
+  {
+  }
+
+  void init(InitContext& ic) final
+  {
+    // O2's tracks of the same clusters, to put through the same truth rules:
+    // the ITS's or the MFT's file; no other detector has one.
+    if (const auto o2Tracks = ic.options().get<std::string>("o2-tracks"); !o2Tracks.empty()) {
+      mO2Tracks = std::make_unique<study::TrackFile>(o2Tracks, study::chipsOf<Det>());
+    }
+    // The MC hits: the pulls with --o2-tracks, the true kinks behind the
+    // lost pairs and the tracks found incomplete, and the QA's outward legs.
+    if (mUseMC) {
+      mHits = openHits<Det>(ic.options().get<std::string>("mc-hits"), std::is_same_v<Det, detectors::TRKFT3> ? ic.options().get<std::string>("mc-ft3-hits") : "");
+    }
+    if (mUseMC) {
+      const auto contextFile = o2::utils::Str::concat_string(o2::utils::Str::rectifyDirectory(ic.options().get<std::string>("input-dir")), ic.options().get<std::string>("collision-context"));
+      mContext.reset(o2::steer::DigitizationContext::loadFromFile(contextFile));
+      if (!mContext) {
+        LOGP(fatal, "cannot read collision context {}", contextFile);
+        return;
+      }
+      mKinematics = std::make_unique<o2::steer::MCKinematicsReader>(mContext.get());
+      if (!mKinematics->isInitialized()) {
+        LOGP(fatal, "cannot open MC kinematics referenced by {}", contextFile);
+        return;
+      }
+      const auto truthOutput = ic.options().get<std::string>("tracklet-truth-output");
+      if (!truthOutput.empty()) {
+        mTruthOutput.open(truthOutput, std::ios::out | std::ios::trunc);
+        if (!mTruthOutput) {
+          LOGP(fatal, "cannot create tracklet truth output {}", truthOutput);
+          return;
+        }
+        mTruthOutput << "timeframe,vertex_source,from,to,pt_min_gev,"
+                        "pt_max_gev,cot_theta_min,cot_theta_max,"
+                        "kept,true_pairs\n";
+      }
+    }
+
+    mTruthReports = !ic.options().get<bool>("no-truth-reports");
+    mSpeciesOracle = ic.options().get<bool>("species-oracle");
+    // The MC truth QA's file.
+    if (const auto qaOutput = ic.options().get<std::string>("qa-output"); !qaOutput.empty()) {
+      if (mUseMC) {
+        mQAOutput = std::make_unique<o2::utils::TreeStreamRedirector>(qaOutput.c_str(), "recreate");
+      } else {
+        LOGP(warning, "--qa-output {}: without MC there is nothing to fill, no file written", qaOutput);
+      }
+    }
+
+    mDumpInput = ic.options().get<std::string>("dump-tracking-input");
+    // The dump's parameters now, before the conditions: the CCDB's
+    // AlpideParam registers a second instance, whose section the INI writer
+    // refuses as a duplicate. The configuration does not change after init.
+    if (!mDumpInput.empty()) {
+      writeParameters(mDumpInput + ".ini");
+    }
+    mDumpTimeframe = static_cast<std::size_t>(std::max(ic.options().get<int>("dump-timeframe"), 0));
+    mDumpOnly = ic.options().get<bool>("dump-only");
+    mConditions->init(ic);
+  }
+
+  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final { mConditions->finaliseCCDB(matcher, obj); }
+
+  /// The study's observers on the tracker, again whenever the interface
+  /// builds one (TrackingInterface.h's `configureFor`).
+  void observeTracker()
+  {
+    auto& tracker = mInterface.tracker();
+    // The iteration lines and the stage truth's times read the profile.
+    tracker.setProfiling(true);
+    // The host tracker's stages: into its stage truth, every iteration
+    // against the clusters it found free; with MC into its stage funnel, read
+    // by the text reports and the QA's seeded.
+    tracker.setIterationObserver([this](const Controller& observed, const Controller::IterationObservation& iteration) {
+      if (mObservers.funnel.has_value()) {
+        mObservers.funnel->observeIteration(observed, iteration);
+      }
+      if (mObservers.stage.has_value()) {
+        mObservers.summaries.push_back(mObservers.stage->finish(observed, iteration));
+        mObservers.stage.reset();
+      }
+    });
+    tracker.setSliceObserver([this](const Controller& observed, const Controller::SliceObservation& slice) {
+      if (!mObservers.stage.has_value() && mObservers.openStage) {
+        mObservers.openStage(observed, slice.iteration, mObservers.stage);
+      }
+      if (mObservers.stage.has_value()) {
+        mObservers.stage->observeSlice(observed, slice);
+      }
+      if (mObservers.funnel.has_value()) {
+        mObservers.funnel->observeSlice(observed, slice);
+      }
+    });
+  }
+
+  void run(ProcessingContext& pc) final
+  {
+    mConditions->checkUpdates(pc);
+    LOGP(info, "{}: the timeframe at orbit {}", Det::name, pc.services().get<o2::framework::TimingInfo>().firstTForbit);
+    // The tracking's timeframe ends on every way out of this one.
+    const auto ended = mInterface.endTimeframeOnExit();
+    // The trackers are built for the timeframe's beam line and grid, again when they change.
+    const auto input = workflow::readTimeframe<Det>(pc, mWithVertices);
+    if (mInterface.configureFor(*mConditions, input.shipped)) {
+      observeTracker();
+    }
+    const auto& columns = input.columns;
+    const auto offsets = input.offsets;
+
+    const auto view = measurementView(columns);
+
+    const auto n = columns.loc0.size();
+    static_assert(std::is_same_v<decltype(view[0].timePS), const std::uint32_t&>, "the view must not be writable");
+
+    const auto& param = recoParam<Det>();
+    const auto& geometry = mInterface.grid();
+    if (const char* invalid = workflow::TrackingInterface<Det>::checkInput(columns, offsets, static_cast<std::size_t>(geometry.bucketCount()), input.seeds)) {
+      LOGP(fatal, "{}", invalid);
+      return;
+    }
+
+    // Every row's bucket is recomputed from the shipped position alone, as the
+    // tracker will see it, and the shipped position -- Cartesian, radius,
+    // azimuth and projected variances -- is compared bit for bit with what the
+    // geometry gives for the row's own sensor and local measurement.
+    const auto sameBits = [](Scalar a, Scalar b) { return std::bit_cast<std::uint32_t>(a) == std::bit_cast<std::uint32_t>(b); };
+    const auto& sensors = mInterface.geometry();
+    const auto& beamLine = mInterface.beamLine();
+    bool bucketsValid = true;
+    bool positionsExact = true;
+    for (std::uint32_t bucket = 0; bucket < geometry.bucketCount(); ++bucket) {
+      for (auto row = offsets[bucket]; row < offsets[bucket + 1U]; ++row) {
+        const auto measurement = view[row];
+        if (row != offsets[bucket]) {
+          bucketsValid &= view[row - 1U].timePS <= measurement.timePS;
+        }
+        if (measurement.surface >= static_cast<SensorID>(Det::nSensors)) {
+          bucketsValid = false;
+          continue;
+        }
+        const auto layer = sensors.sensor(measurement.surface).layer;
+        bucketsValid &= geometry.bucketAt(layer, measurement.timePS, measurement.phi, secondCoordinate<Det>(layer, measurement.r, measurement.z)) == bucket;
+        const auto point = gridPoint<Det>(sensors, measurement.surface, static_cast<double>(measurement.loc0), static_cast<double>(measurement.loc1), beamLine.x, beamLine.y);
+        const auto variances = pointVariances<Det>(sensors, measurement.surface, static_cast<double>(measurement.loc0), point, measurement.varLoc0, measurement.covLoc01, measurement.varLoc1);
+        positionsExact &= sameBits(point.x, measurement.x) && sameBits(point.y, measurement.y) && sameBits(point.z, measurement.z) && sameBits(point.r, measurement.r) && sameBits(point.phi, measurement.phi) && sameBits(variances.z, measurement.varZ) && sameBits(variances.r, measurement.varR) && sameBits(variances.rPhi, measurement.varRPhi);
+      }
+    }
+    if (!bucketsValid || !positionsExact) {
+      LOGP(fatal, "measurements do not match their grid buckets, bucket time order or geometry");
+      return;
+    }
+
+    const Frame frame{view, geometry, offsets};
+    // The vertex list: the input's, or the own vertexer's, which keeps its
+    // triplets' claims for the QA with MC.
+    const auto found = mInterface.vertices(frame, input.seeds, mUseMC);
+    if (found.dropped) {
+      ++mTimeframe;
+      return;
+    }
+    const auto* pass = found.pass;
+    const std::span<const VertexSeed> seeds = found.seeds;
+    if (pass != nullptr) {
+      LOGP(info, "vertexer: {} vertices from {} candidates of {} triplets in {:.4f} s", seeds.size(), pass->found.candidates, pass->found.triplets, found.seconds);
+    }
+    LOGP(info, "bound {} measurements over {} columns, {} layers and {} buckets", n, kNMeasurementColumns, Frame::kLayerCount, geometry.bucketCount());
+    for (std::size_t layer = 0; layer < Frame::kLayerCount; ++layer) {
+      const auto rows = frame.grid().layerRows(static_cast<LayerID>(layer));
+      LOGP(info, "  layer {:>2}  {:>9} measurements  [{:>9}, {:>9})", layer, rows.size(), rows.begin, rows.end);
+    }
+
+    const auto blocksPerSlice = geometry.blocksPerSlice(param.sliceWidthPS);
+    LOGP(info, "slicing {} blocks in groups of {} with halo {} ps", geometry.blockCount(), blocksPerSlice, param.sliceHaloPS);
+
+    std::vector<TruePair> truePairs;
+    const bool dumping = !mDumpInput.empty() && n != 0U && mTimeframe == mDumpTimeframe;
+    std::vector<TruthRow> comparisonRows;
+    ParticleTable comparisonParticles;
+    if (mUseMC) {
+      const auto labels = pc.inputs().get<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>("labels");
+      // Every row's particles: a cluster is every particle's it carries among
+      // its labels, for every report of the sink and the dump's truth.
+      comparisonTruth(frame, labels, comparisonRows, comparisonParticles);
+      const auto mcOf = [&](std::uint64_t id) -> const o2::MCTrack* {
+        const auto found = mParticleLabels.find(id);
+        return found == mParticleLabels.end() ? nullptr : mKinematics->getTrack(found->second.source, found->second.event, found->second.track);
+      };
+      if (mTruthReports) {
+        truePairs = mcTruePairs(frame, comparisonRows, mcOf, mInterface.geometry(), param, mInterface.propagator().bzKiloGauss);
+        LOGP(info, "  MC-true primary pairs  {}", truePairs.size());
+      }
+      if (pass != nullptr) {
+        const auto score = scoreVertices<Det>(comparisonRows, comparisonParticles, pass->claims, pass->found);
+        LOGP(info, "{}", describe(score));
+        LOGP(info, "{}", describePulls(score));
+      }
+    }
+    if (mTrackerProducts == TrackerProducts::kDigests) {
+      logTrackerDigests(pc, frame);
+    }
+    if (dumping) {
+      // The tracker's input for o2-gtrk-track-bench, once per process: the
+      // configured timeframe (--dump-timeframe), if it has measurements, and
+      // with MC the truth to score its tracks by.
+      std::vector<double> depths;
+      depths.reserve(Detector<Det>::nLayers);
+      for (int layer = 0; layer < Detector<Det>::nLayers; ++layer) {
+        depths.push_back(mInterface.geometry().measurementDepth(static_cast<LayerID>(layer)));
+      }
+      writeTrackingInput(mDumpInput, view, n, offsets, seeds, mInterface.beamLine(), mInterface.frames(), depths);
+      LOGP(info, "tracking input written to {} and {}.ini", mDumpInput, mDumpInput);
+      if (mUseMC) {
+        writeTrackingTruth(mDumpInput + ".truth", std::span<const std::uint32_t>{columns.clusterIndex.data(), n}, comparisonRows, comparisonParticles);
+        LOGP(info, "tracking truth written to {}.truth ({} particles)", mDumpInput, comparisonParticles.size());
+      }
+      mDumpInput.clear();
+      if (mDumpOnly) {
+        ++mTimeframe;
+        return;
+      }
+    }
+    const auto beamSpot = workflow::beamSpotConstraint(mInterface.beamLine(), param);
+    const Propagator propagator = mInterface.propagator();
+    // The MC hits behind the truth's particles, for the lost pairs' and the
+    // incomplete tracks' anatomy.
+    const TrueCrossings crossingsOf = mUseMC ? trueCrossings(frame) : TrueCrossings{};
+    // The tracker's observers for this timeframe: every iteration's stages
+    // against the truth, from its first slice, and with MC the stage funnel.
+    mObservers.summaries.clear();
+    if (mTruthReports) {
+      mObservers.openStage = [&](const Controller& tracker, std::size_t iteration, std::optional<StageTruth>& stage) { stage.emplace(frame, tracker, iteration, param, propagator, truePairs, comparisonRows, comparisonParticles, mInterface.scattering(), &mInterface.material(), crossingsOf); };
+    }
+    if (!comparisonRows.empty() && mTruthReports) {
+      reportTrueRoadChi2(frame, param, mInterface.tracker(), truePairs, comparisonParticles, mInterface.tracking(), mInterface.material(), propagator, crossingsOf, mInterface.scattering());
+    }
+    // O2's tracks of this timeframe as rows, once, for the comparison and
+    // the QA, with MC.
+    const auto theirs = mO2Tracks && !comparisonRows.empty() ? o2TrackRows(frame) : TrackRows{};
+    // --qa-output: the tracker's tracks into the QA, after what else reads
+    // them.
+    using Tracked = std::function<void(const TrackRefit<Det>::Tracks&)>;
+    const auto withQA = [&](Tracked tracked) -> Tracked {
+      if (!mQAOutput || comparisonRows.empty()) {
+        return tracked;
+      }
+      return [&, tracked = std::move(tracked)](const TrackRefit<Det>::Tracks& tracks) {
+        if (tracked) {
+          tracked(tracks);
+        }
+        const auto& funnel = mObservers.funnel;
+        streamQA(frame, comparisonRows, comparisonParticles, funnel.has_value() ? &*funnel : nullptr, tracks, mO2Tracks ? &theirs : nullptr);
+      };
+    };
+    const auto comparisons = [&]() -> Tracked {
+      if (!comparisonRows.empty()) {
+        return [&](const TrackRefit<Det>::Tracks& tracks) {
+          if (mO2Tracks) {
+            compareWithO2(frame, comparisonRows, comparisonParticles, tracks, theirs);
+          }
+          if (!mTruthReports) {
+            return;
+          }
+          const auto& funnel = mObservers.funnel;
+          reportFakeAnatomy(frame, param, comparisonRows, comparisonParticles, funnel.has_value() ? &*funnel : nullptr, mInterface.tracker(), tracks, mInterface.tracking(), mInterface.material(), propagator, mInterface.trackerLabel().c_str());
+        };
+      }
+      if (mO2Tracks && !mUseMC) {
+        // Real data: no truth, O2's tracks of the same clusters are the yardstick.
+        return [&](const TrackRefit<Det>::Tracks& tracks) { compareWithO2ByClusters(frame, tracks); };
+      }
+      return {};
+    };
+    // The tracker's stage funnel of this timeframe, with MC.
+    const auto makeFunnel = [&](std::optional<Funnel>& funnel) {
+      if (comparisonRows.empty()) {
+        return;
+      }
+      std::vector<double> minPtGeV(static_cast<std::size_t>(workflow::iterationCount(param)));
+      for (std::size_t iteration = 0; iteration < minPtGeV.size(); ++iteration) {
+        minPtGeV[iteration] = workflow::iterationSettings(param, static_cast<int>(iteration)).windows.minPtGeV;
+      }
+      funnel.emplace(frame, comparisonRows, comparisonParticles, comparisonSettings<Det>(), vertexSeed(beamSpot), std::move(minPtGeV));
+      // The refused roads refitted for their reason, as the bench's funnel.
+      funnel->setRoadFit(mInterface.tracking(), mInterface.material(), propagator);
+    };
+    const auto funnelOf = [](const std::optional<Funnel>& funnel) { return funnel.has_value() ? &*funnel : nullptr; };
+    // --compare-tracks: the device's products against this tracker's, before
+    // what else reads the tracks.
+    const auto withDevice = [&](Tracked tracked) -> Tracked {
+      if (mTrackerProducts != TrackerProducts::kCompare) {
+        return tracked;
+      }
+      return [&, tracked = std::move(tracked)](const TrackRefit<Det>::Tracks& tracks) {
+        compareWithDevice(pc, tracks, pass != nullptr ? &pass->found : nullptr);
+        if (tracked) {
+          tracked(tracks);
+        }
+      };
+    };
+    makeFunnel(mObservers.funnel);
+    measureTracks(frame, param, beamSpot, seeds, comparisonRows, comparisonParticles, funnelOf(mObservers.funnel), mInterface, withDevice(withQA(comparisons())), crossingsOf);
+    if (mTruthOutput) {
+      // The first iteration's.
+      if (!mObservers.summaries.empty()) {
+        writeTruthBreakdown(mTruthOutput, mTimeframe, mInterface.trackerSource() == VertexSource::kBeamLine ? "beam_line" : "vertex_list", mObservers.summaries[0]);
+      }
+      mTruthOutput.flush();
+    }
+    mObservers.funnel.reset();
+    mObservers.stage.reset();
+    mObservers.openStage = nullptr;
+    ++mTimeframe;
+  }
+
+  void endOfStream(EndOfStreamContext& /*ec*/) final
+  {
+    if (!mQAOutput) {
+      return;
+    }
+    const std::string name = mQAOutput->GetFile()->GetName();
+    if (mInterface.configured()) {
+      // The MC events: the signal source's, as the truth is.
+      streamRun(*mQAOutput, workflow::iterationCount(recoParam<Det>()), etaReach(PlacedEnvelopes<Det>::all()), comparisonSettings<Det>(), mKinematics ? mKinematics->getNEvents(0) : 0U);
+    }
+    mQAOutput->Close();
+    mQAOutput.reset();
+    LOGP(info, "the QA written to {}", name);
+  }
+
+ private:
+  /// --tracker-digests: the tracking device's products of this timeframe
+  /// (TrackerSpec.h) on \a frame, digested as the bench digests a device's
+  /// tracks and its vertexer's list. One line per timeframe.
+  static void logTrackerDigests(ProcessingContext& pc, const Frame& frame)
+  {
+    using Record = workflow::TrackRecord<Det>;
+    const auto records = pc.inputs().get<gsl::span<Record>>("deviceTracks");
+    const auto vertices = pc.inputs().get<gsl::span<VertexSeed>>("deviceVertices");
+    const auto contributors = pc.inputs().get<gsl::span<std::uint32_t>>("deviceContributors");
+    BoundedMemoryResource resource;
+    const auto tracks = recordsTracks<Det>(std::span<const Record>{records.data(), records.size()}, &resource);
+    LOGP(info, "tracker-digests, {}, orbit {}: {} tracks, {} vertices; digest, tracks: {:016x}; digest, tracks in clusters: {:016x}; digest, vertices: {:016x}", Det::name, pc.services().get<o2::framework::TimingInfo>().firstTForbit, tracks.size(), vertices.size(), tracksDigest(tracks), tracksClusterDigest<Det>(tracks, frame), vertexDigest(std::span<const VertexSeed>{vertices.data(), vertices.size()}, std::span<const std::uint32_t>{contributors.data(), contributors.size()}));
+  }
+
+  /// --compare-tracks: the tracking device's products of this timeframe
+  /// (TrackerSpec.h) against this tracker's \a tracks and the own vertexer's
+  /// \a found (none without it): every record field by field, failed refits
+  /// included, every vertex and contributor count. One line per timeframe;
+  /// the run fails on the first difference.
+  static void compareWithDevice(ProcessingContext& pc, const typename TrackRefit<Det>::Tracks& tracks, const VertexerResult* found)
+  {
+    using Record = workflow::TrackRecord<Det>;
+    const auto theirs = pc.inputs().get<gsl::span<Record>>("deviceTracks");
+    const auto theirVertices = pc.inputs().get<gsl::span<VertexSeed>>("deviceVertices");
+    const auto theirContributors = pc.inputs().get<gsl::span<std::uint32_t>>("deviceContributors");
+    const std::span<const VertexSeed> vertices = found != nullptr ? std::span<const VertexSeed>{found->vertices} : std::span<const VertexSeed>{};
+    const std::span<const std::uint32_t> contributors = found != nullptr ? std::span<const std::uint32_t>{found->contributors} : std::span<const std::uint32_t>{};
+    const auto orbit = pc.services().get<o2::framework::TimingInfo>().firstTForbit;
+    std::string difference;
+    if (theirs.size() != tracks.size()) {
+      difference = fmt::format("the device has {} tracks", theirs.size());
+    } else {
+      for (std::size_t track = 0; track < tracks.size(); ++track) {
+        if (const auto field = differingField(tracks.read(track), theirs[track]); field >= 0) {
+          difference = fmt::format("track {}, field {} (memlayout order)", track, field);
+          break;
+        }
+      }
+    }
+    const auto sameBytes = []<class T>(std::span<const T> mine, gsl::span<const T> other) { return mine.size() == other.size() && (mine.empty() || std::memcmp(mine.data(), other.data(), mine.size_bytes()) == 0); };
+    if (difference.empty() && !sameBytes(vertices, theirVertices)) {
+      difference = fmt::format("the vertices (the device {})", theirVertices.size());
+    }
+    if (difference.empty() && !sameBytes(contributors, theirContributors)) {
+      difference = "the vertices' contributors";
+    }
+    if (!difference.empty()) {
+      LOGP(fatal, "compare-tracks, {}, orbit {}: {} tracks, {} vertices: differ, {}", Det::name, orbit, tracks.size(), vertices.size(), difference);
+      return;
+    }
+    LOGP(info, "compare-tracks, {}, orbit {}: {} tracks, {} vertices: equal", Det::name, orbit, tracks.size(), vertices.size());
+  }
+
+  /// The first field of \a mine whose bytes differ from \a theirs, in
+  /// memlayout's column order; -1 if none. Field by field: the record's
+  /// padding between fields is not compared, and no field has padding of
+  /// its own (BoundTrackState.h).
+  template <class Record>
+  [[nodiscard]] static int differingField(const Record& mine, const Record& theirs)
+  {
+    constexpr auto kFields = static_cast<std::size_t>(Record::Column::ColumnCount);
+    using Fields = std::array<std::pair<const void*, std::size_t>, kFields>;
+    const auto fieldsOf = [](const Record& record) {
+      Fields fields{};
+      record.apply([&](const auto&... field) {
+        std::size_t index = 0;
+        ((fields[index++] = {static_cast<const void*>(&field), sizeof(field)}), ...);
+        return 0;
+      });
+      return fields;
+    };
+    const auto left = fieldsOf(mine);
+    const auto right = fieldsOf(theirs);
+    for (std::size_t field = 0; field < kFields; ++field) {
+      if (std::memcmp(left[field].first, right[field].first, left[field].second) != 0) {
+        return static_cast<int>(field);
+      }
+    }
+    return -1;
+  }
+
+  /// The tracker's tracks of this timeframe into the QA's trees;
+  /// \a theirs O2's (`o2TrackRows`), none
+  /// without --o2-tracks.
+  void streamQA(const Frame& frame, std::span<const TruthRow> rows, const ParticleTable& particles, const Funnel* funnel, const typename TrackRefit<Det>::Tracks& tracks, const TrackRows* theirs)
+  {
+    const auto view = tracks.view();
+    const TrackRows ours = trackRows(tracks);
+    std::vector<TrackKinematics> kinematics(tracks.size());
+    std::vector<QAResolution> resolution;
+    std::vector<QAOracle> oracle;
+    const Propagator propagator = mInterface.propagator();
+    for (std::size_t track = 0; track < tracks.size(); ++track) {
+      const auto& state = view.state[track];
+      const auto theta = static_cast<double>(state.theta());
+      kinematics[track] = {
+        .pt = static_cast<float>(std::sin(theta) / std::abs(static_cast<double>(state.qOverP()))),
+        .eta = static_cast<float>(-std::log(std::tan(theta / 2.))),
+        .phi = state.phi(),
+        .iteration = view.iteration[track],
+        .chi2 = view.chi2[track],
+        .ndf = view.ndf[track],
+      };
+      // A good track against its particle's crossing, with the hits.
+      const auto particle = goodParticle(rows, ours[track]);
+      const auto innermost = std::ranges::find_if(ours[track], [&](std::uint32_t row) { return frame.measurement(row).surface == state.surface; });
+      const auto found = particles.find(particle);
+      if (!mHits || particle == kNoTrackParticle || innermost == ours[track].end() || found == particles.end()) {
+        continue;
+      }
+      const auto truth = stateTruth(frame, state, particle, *innermost);
+      if (!truth.has_value()) {
+        continue;
+      }
+      QAResolution entry{
+        .pt = found->second.pt,
+        .eta = found->second.eta,
+        .phi = wrapPhi(static_cast<double>(found->second.phi)),
+        .charge = static_cast<std::int8_t>(std::lround(mParticleLabels[particle].charge)),
+        .pdg = found->second.pdg,
+        .origin = static_cast<std::uint8_t>(found->second.origin),
+        .iteration = view.iteration[track],
+        .kinks = view.kinks[track],
+        .clusters = view.count[track],
+        .layer = static_cast<std::uint8_t>(rows[*innermost].layer),
+        .fitPt = static_cast<float>(truth->fittedPt),
+        .ptResidual = static_cast<float>((truth->fittedPt / truth->pt) - 1.),
+        .ptSigma = static_cast<float>(truth->ptSigma),
+      };
+      for (std::size_t i = 0; i < 5U; ++i) {
+        entry.residual[i] = static_cast<float>(truth->residual[i]);
+        entry.sigma[i] = static_cast<float>(truth->sigma[i]);
+      }
+      vertexApproach(frame, state, particle, *innermost, propagator, found->second, entry);
+      if (mSpeciesOracle) {
+        speciesOracle(frame, view, track, particle, *innermost, propagator, entry, oracle);
+      }
+      resolution.push_back(entry);
+    }
+    // Each particle's decay geometry and the funnel's verdict,
+    // against the beam line in the
+    // run's nominal field.
+    std::unordered_set<std::uint64_t> found;
+    for (const auto& track : ours) {
+      found.insert(goodParticle(rows, track));
+    }
+    const double bz = mInterface.propagator().bzKiloGauss;
+    const double beamX = mInterface.beamLine().x;
+    const double beamY = mInterface.beamLine().y;
+    // Each signal particle's outward leg in its MC hits (TrackingQA.h), its
+    // event's segments ordered by track once.
+    std::unordered_map<std::uint64_t, std::uint8_t> outward;
+    std::unordered_map<std::uint64_t, std::vector<float>> legMomenta; // --species-oracle
+    if (mHits) {
+      std::unordered_map<int, std::vector<std::uint64_t>> byEvent;
+      for (const auto& [id, truth] : particles) {
+        if (const auto label = mParticleLabels.find(id); label != mParticleLabels.end() && label->second.source == 0) {
+          byEvent[label->second.event].push_back(id);
+        }
+      }
+      const auto trackOf = [](const study::HitSegment* segment) { return segment->track; };
+      std::vector<const study::HitSegment*> segments;
+      std::vector<HitCrossing> crossings;
+      for (const auto& [event, ids] : byEvent) {
+        segments.clear();
+        for (const auto& segment : mHits->event(event)) {
+          segments.push_back(&segment);
+        }
+        std::ranges::sort(segments, {}, trackOf);
+        for (const auto id : ids) {
+          crossings.clear();
+          for (const auto* segment : std::ranges::equal_range(segments, mParticleLabels[id].track, {}, trackOf)) {
+            crossings.push_back({
+              .time = segment->time,
+              .position = {0.5 * (segment->start[0] + segment->end[0]), 0.5 * (segment->start[1] + segment->end[1]), 0.5 * (segment->start[2] + segment->end[2])},
+              .layer = mInterface.geometry().sensor(segment->chip).layer,
+              .momentum = segment->momentum,
+            });
+          }
+          const auto& truth = particles.at(id);
+          const auto leg = outwardLeg(crossings, {static_cast<double>(truth.vx), static_cast<double>(truth.vy), static_cast<double>(truth.vz)});
+          outward[id] = outwardLayers(leg);
+          if (mSpeciesOracle && (std::abs(truth.pdg) == 11 || (std::abs(truth.pdg) == 211 && id % 16U == 0U))) {
+            legMomenta[id] = momentaAlongLeg(leg);
+          }
+        }
+      }
+    }
+    ParticleExtrasTable extras;
+    for (const auto& [id, truth] : particles) {
+      const auto label = mParticleLabels.find(id);
+      if (label == mParticleLabels.end()) {
+        continue;
+      }
+      const auto& helix = label->second.helix;
+      auto& extra = extras[id];
+      if (const auto leg = outward.find(id); leg != outward.end()) {
+        extra.outwardLayers = leg->second;
+      }
+      extra.vr = static_cast<float>(std::hypot(helix.position[0] - beamX, helix.position[1] - beamY));
+      const auto impact = helixImpact(helix, bz, beamX, beamY);
+      extra.d0 = static_cast<float>(impact.d0);
+      extra.z0 = static_cast<float>(impact.z - mInterface.beamLine().z);
+      if (const auto& mother = label->second.mother; mother.has_value()) {
+        const auto direction = helixDirectionAt(*mother, bz, helix.position[0], helix.position[1]);
+        const double p = std::hypot(helix.momentum[0], helix.momentum[1], helix.momentum[2]);
+        const double cosine = ((direction[0] * helix.momentum[0]) + (direction[1] * helix.momentum[1]) + (direction[2] * helix.momentum[2])) / p;
+        extra.openingAngle = static_cast<float>(std::acos(std::clamp(cosine, -1., 1.)));
+        extra.motherMiss = static_cast<float>(helixMiss(*mother, bz, helix.position[0], helix.position[1]));
+      }
+      const auto verdict = funnel != nullptr ? funnel->particleVerdict(id) : std::nullopt;
+      if (found.contains(id)) {
+        extra.lostAt = static_cast<std::uint8_t>(FunnelStage::kFound);
+      } else if (verdict.has_value()) {
+        extra.lostAt = static_cast<std::uint8_t>(verdict->lostAt);
+        // Why, where it was lost.
+        if (verdict->lostAt == FunnelStage::kRoads && verdict->roadLoss.has_value()) {
+          extra.roadLoss = static_cast<std::uint8_t>(*verdict->roadLoss);
+          extra.roadLosses = verdict->roadLosses;
+          if (verdict->raisedFit.has_value()) {
+            extra.raisedFit = static_cast<std::uint8_t>(*verdict->raisedFit);
+          }
+        }
+        if (verdict->lostAt == FunnelStage::kFit && verdict->fitLoss.has_value()) {
+          extra.fitLoss = static_cast<std::uint8_t>(*verdict->fitLoss);
+          extra.fitRoadLayers = verdict->fitRoadLayers;
+          extra.fitLosses = verdict->fitLosses;
+        }
+      }
+      if (verdict.has_value() && verdict->pairLoss.has_value()) {
+        extra.pairLoss = static_cast<std::uint8_t>(*verdict->pairLoss);
+      }
+    }
+    stream(*mQAOutput, trackingQA(rows, particles, ours, kinematics, funnel != nullptr ? funnel->seededBy() : SeededBy{}, extras, theirs, workflow::iterationCount(recoParam<Det>()), comparisonSettings<Det>()));
+    streamResolution(*mQAOutput, resolution);
+    streamOracle(*mQAOutput, oracle);
+    if (!legMomenta.empty()) {
+      const auto settings = comparisonSettings<Det>();
+      const auto chains = particleLayers(rows, settings);
+      // Each followed particle's fakes (StageFunnel::report's label rule: the
+      // particle most of a fake's measurements carry).
+      std::unordered_map<std::uint64_t, std::pair<std::uint8_t, std::uint8_t>> fakes; // fewest wrong, its layer
+      for (const auto& track : ours) {
+        if (goodParticle(rows, track) != kNoTrackParticle) {
+          continue;
+        }
+        const auto [label, carried] = majorityParticle(rows, track);
+        const std::size_t most = carried;
+        if (most == 0U || most == track.size() || !legMomenta.contains(label)) {
+          continue;
+        }
+        const auto wrong = static_cast<std::uint8_t>(track.size() - most);
+        std::uint8_t layer = 0xFFU;
+        if (wrong == 1U) {
+          const auto row = *std::ranges::find_if(track, [&](std::uint32_t r) { return !rows[r].carries(label); });
+          layer = static_cast<std::uint8_t>(rows[row].layer);
+        }
+        auto [entry, inserted] = fakes.try_emplace(label, wrong, layer);
+        if (!inserted && wrong < entry->second.first) {
+          entry->second = {wrong, layer};
+        }
+      }
+      std::vector<QAMomenta> momenta;
+      for (auto& [id, pAtLayer] : legMomenta) {
+        const auto& truth = particles.at(id);
+        const auto chain = chains.find(id);
+        if (chain == chains.end() || !isFindable(truth.pt, chain->second, settings)) {
+          continue;
+        }
+        const auto& extra = extras.at(id);
+        momenta.push_back({
+          .pdg = truth.pdg,
+          .origin = static_cast<std::uint8_t>(truth.origin),
+          .pt = truth.pt,
+          .eta = truth.eta,
+          .p0 = static_cast<float>(static_cast<double>(truth.pt) * std::cosh(static_cast<double>(truth.eta))),
+          .found = found.contains(id),
+          .lostAt = extra.lostAt,
+          .pairLoss = extra.pairLoss,
+          .layers = chain->second.layers,
+          .fakeWrong = fakes.contains(id) ? fakes.at(id).first : std::uint8_t{0},
+          .fakeWrongLayer = fakes.contains(id) ? fakes.at(id).second : std::uint8_t{0xFF},
+          .pAtLayer = std::move(pAtLayer),
+        });
+      }
+      streamMomenta(*mQAOutput, momenta);
+    }
+  }
+
+  /// |p| entering each layer's first crossing on the outward \a leg
+  /// (`outwardLeg`); NaN for a layer without one [GeV].
+  [[nodiscard]] static std::vector<float> momentaAlongLeg(std::span<const HitCrossing> leg)
+  {
+    std::vector<float> pAtLayer(static_cast<std::size_t>(Detector<Det>::nLayers), std::numeric_limits<float>::quiet_NaN());
+    for (const auto& crossing : leg) {
+      auto& p = pAtLayer.at(crossing.layer);
+      if (std::isnan(p)) {
+        p = static_cast<float>(std::hypot(crossing.momentum[0], crossing.momentum[1], crossing.momentum[2]));
+      }
+    }
+    return pAtLayer;
+  }
+
+  /// Our beam-line tracks and O2's for this timeframe, under one set of truth
+  /// rules and cluster set by cluster set (TrackComparison.h). O2's tracks
+  /// name O2's cluster indices, which are our measurements' clusterIndex.
+  /// Every row's signal particles, all of them, and those particles' truth:
+  /// what O2's label rule counts (TrackComparison.h).
+  void comparisonTruth(const Frame& frame, const o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>& labels, std::vector<TruthRow>& rows, ParticleTable& particles)
+  {
+    rows.assign(frame.size(), {});
+    mParticleLabels.clear();
+    for (Frame::Index row = 0U; row < frame.size(); ++row) {
+      const auto measurement = frame.measurement(row);
+      auto& truth = rows[row];
+      truth.layer = mInterface.geometry().sensor(measurement.surface).layer;
+      truth.r = measurement.r;
+      truth.z = measurement.z;
+      const auto all = labels.getLabels(measurement.clusterIndex);
+      static_cast<workflow::RowParticles&>(truth) = workflow::rowParticles(std::span<const o2::MCCompLabel>{all.data(), all.size()});
+      // The particle table: each particle the rows carry, once.
+      for (const auto& label : all) {
+        if (!carriesParticle(label)) {
+          continue;
+        }
+        const auto id = label.getTrackEventSourceID(); // source, event and track in one word
+        if (!truth.carries(id)) {
+          continue; // past the rule's kMaxParticles
+        }
+        if (!particles.contains(id)) {
+          const auto* mc = mKinematics->getTrack(label);
+          const o2::MCTrack* mother = nullptr;
+          if (mc == nullptr) {
+            particles[id] = ParticleTruth{};
+          } else {
+            const auto& event = mKinematics->getTracks(label.getSourceID(), label.getEventID());
+            mother = o2::mcutils::MCTrackNavigator::getMother(*mc, event);
+            particles[id] = ParticleTruth{
+              .pt = static_cast<float>(mc->GetPt()),
+              .primary = mc->isPrimary(),
+              .eta = static_cast<float>(mc->GetEta()),
+              .phi = static_cast<float>(mc->GetPhi()),
+              .origin = particleOrigin(*mc, event),
+              .pdg = mc->GetPdgCode(),
+              .motherPdg = mother == nullptr ? 0 : mother->GetPdgCode(),
+              .process = static_cast<std::uint8_t>(mc->getProcess()),
+              .vx = static_cast<float>(mc->Vx()),
+              .vy = static_cast<float>(mc->Vy()),
+              .vz = static_cast<float>(mc->Vz()),
+            };
+          }
+          const auto* pdg = mc == nullptr ? nullptr : o2::O2DatabasePDG::Instance()->GetParticle(mc->GetPdgCode());
+          auto& entry = mParticleLabels[id];
+          entry = {
+            .event = label.getEventID(),
+            .track = label.getTrackID(),
+            .source = label.getSourceID(),
+            .charge = pdg == nullptr ? 0. : pdg->Charge() / 3.,
+            .pdg = mc == nullptr ? 0 : mc->GetPdgCode(),
+          };
+          if (mc != nullptr) {
+            const auto helixOf = [](const o2::MCTrack& track, double charge) { return TruthHelix{.position = {track.Vx(), track.Vy(), track.Vz()}, .momentum = {track.Px(), track.Py(), track.Pz()}, .charge = charge}; };
+            entry.helix = helixOf(*mc, entry.charge);
+            if (mother != nullptr) {
+              const auto* motherPdg = o2::O2DatabasePDG::Instance()->GetParticle(mother->GetPdgCode());
+              entry.mother = helixOf(*mother, motherPdg == nullptr ? 0. : motherPdg->Charge() / 3.);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /// Without MC truth: GTRK's tracks against
+  /// O2's of the same clusters by the clusters they share. An O2 track is
+  /// found when a GTRK track holds four or more of its clusters, and
+  /// reproduced when one holds exactly its clusters; a GTRK track is O2's
+  /// when it shares four or more with an O2 track, and GTRK's own otherwise.
+  /// Both by the track's cluster count.
+  void compareWithO2ByClusters(const Frame& frame, const typename TrackRefit<Det>::Tracks& tracks)
+  {
+    constexpr std::uint32_t kSharedToMatch = 4U;
+    const auto rowOfCluster = rowsOfClusters(frame);
+    // Which GTRK tracks hold each row.
+    const auto view = tracks.view();
+    std::vector<std::vector<std::uint32_t>> tracksOfRow(frame.size());
+    std::vector<std::uint32_t> ourCount(tracks.size(), 0U);
+    for (std::size_t track = 0; track < tracks.size(); ++track) {
+      ourCount[track] = view.count[track];
+      for (std::uint32_t i = 0; i < view.count[track]; ++i) {
+        tracksOfRow[view.clusters[track].index[i]].push_back(static_cast<std::uint32_t>(track));
+      }
+    }
+    const auto theirs = mO2Tracks->read(static_cast<long long>(mTimeframe));
+    constexpr auto kMaxClusters = static_cast<std::size_t>(Detector<Det>::nLayers) + 1U;
+    std::array<std::size_t, kMaxClusters> o2Total{};
+    std::array<std::size_t, kMaxClusters> o2Found{};
+    std::array<std::size_t, kMaxClusters> o2Reproduced{};
+    std::vector<std::uint32_t> bestShared(tracks.size(), 0U); // per GTRK track, the most clusters shared with any O2 track
+    std::vector<std::uint32_t> sharedWith;                    // scratch: per GTRK track, the clusters shared with the O2 track at hand
+    sharedWith.assign(tracks.size(), 0U);
+    std::vector<std::uint32_t> touched;
+    std::size_t unknownClusters = 0U;
+    // Of O2's full-length tracks that GTRK finds shorter: the layers GTRK's
+    // track lacks, and GTRK's track length.
+    std::array<std::size_t, kMaxClusters> lackingLayer{};
+    std::array<std::size_t, kMaxClusters> shorterLength{};
+    std::size_t fullFoundShorter = 0U;
+    std::size_t shorterLackingTaken = 0U; // of those, with a lacking cluster held by another GTRK track
+    std::size_t shorterLackingFree = 0U;  // with every lacking cluster free
+    // O2's full-length tracks by their pT and |tan lambda| at the innermost
+    // cluster (the ITS only): found full-length, found shorter, missed.
+    constexpr std::array<double, 7> kO2PtEdges{0., 0.1, 0.2, 0.3, 0.5, 1., std::numeric_limits<double>::infinity()};
+    constexpr std::array<double, 6> kO2TglEdges{0., 0.3, 0.6, 0.9, 1.2, std::numeric_limits<double>::infinity()};
+    std::array<std::array<std::size_t, 3>, kO2PtEdges.size() - 1U> fullByPt{};
+    std::array<std::array<std::size_t, 3>, kO2TglEdges.size() - 1U> fullByTgl{};
+    std::vector<o2::track::TrackParCov> states;
+    if constexpr (std::same_as<Det, detectors::ITS>) {
+      states = mO2Tracks->innerStates(static_cast<long long>(mTimeframe));
+    }
+    const auto binOf = [](const auto& edges, double value) {
+      std::size_t bin = 0U;
+      while (bin + 2U < edges.size() && value >= edges[bin + 1U]) {
+        ++bin;
+      }
+      return bin;
+    };
+    const auto layerOfRow = [&](std::uint32_t row) { return static_cast<std::size_t>(mInterface.geometry().sensor(frame.measurement(row).surface).layer); };
+    for (std::size_t theirIndex = 0; theirIndex < theirs.size(); ++theirIndex) {
+      const auto& track = theirs[theirIndex];
+      touched.clear();
+      std::uint32_t best = 0U;
+      std::uint32_t bestTrack = std::numeric_limits<std::uint32_t>::max();
+      for (const auto cluster : track) {
+        if (cluster >= rowOfCluster.size() || rowOfCluster[cluster] == std::numeric_limits<std::uint32_t>::max()) {
+          ++unknownClusters;
+          continue;
+        }
+        for (const auto ours : tracksOfRow[rowOfCluster[cluster]]) {
+          if (sharedWith[ours]++ == 0U) {
+            touched.push_back(ours);
+          }
+          if (sharedWith[ours] > best) {
+            best = sharedWith[ours];
+            bestTrack = ours;
+          }
+        }
+      }
+      const auto n = std::min(track.size(), kMaxClusters - 1U);
+      ++o2Total[n];
+      if (track.size() == static_cast<std::size_t>(Detector<Det>::nLayers) && theirIndex < states.size()) {
+        const auto& state = states[theirIndex];
+        std::size_t outcome = 0U; // full, shorter, missed
+        if (best < kSharedToMatch) {
+          outcome = 2U;
+        } else if (ourCount[bestTrack] < track.size()) {
+          outcome = 1U;
+        }
+        const auto q2pt = std::abs(static_cast<double>(state.getParam(4)));
+        const auto pt = q2pt > 0. ? 1. / q2pt : std::numeric_limits<double>::infinity();
+        ++fullByPt[binOf(kO2PtEdges, pt)][outcome];
+        ++fullByTgl[binOf(kO2TglEdges, std::abs(static_cast<double>(state.getParam(3))))][outcome];
+      }
+      if (best >= kSharedToMatch) {
+        ++o2Found[n];
+        if (track.size() == static_cast<std::size_t>(Detector<Det>::nLayers) && ourCount[bestTrack] < track.size()) {
+          ++fullFoundShorter;
+          ++shorterLength[std::min<std::size_t>(ourCount[bestTrack], kMaxClusters - 1U)];
+          bool taken = false;
+          for (const auto cluster : track) {
+            if (cluster >= rowOfCluster.size() || rowOfCluster[cluster] == std::numeric_limits<std::uint32_t>::max()) {
+              continue; // counted in unknownClusters above
+            }
+            const auto row = rowOfCluster[cluster];
+            const auto& ours = tracksOfRow[row];
+            if (std::ranges::find(ours, bestTrack) == ours.end()) {
+              ++lackingLayer[std::min(layerOfRow(row), kMaxClusters - 1U)];
+              taken |= !ours.empty();
+            }
+          }
+          ++(taken ? shorterLackingTaken : shorterLackingFree);
+        }
+      }
+      for (const auto ours : touched) {
+        if (sharedWith[ours] == track.size() && sharedWith[ours] == ourCount[ours]) {
+          ++o2Reproduced[n];
+          break;
+        }
+      }
+      for (const auto ours : touched) {
+        bestShared[ours] = std::max(bestShared[ours], sharedWith[ours]);
+        sharedWith[ours] = 0U;
+      }
+    }
+    std::array<std::size_t, kMaxClusters> ourTotal{};
+    std::array<std::size_t, kMaxClusters> ourMatched{};
+    std::map<std::uint32_t, std::size_t> shortPatterns; // GTRK's tracks short of a layer, by their layer mask
+    for (std::size_t track = 0; track < tracks.size(); ++track) {
+      const auto n = std::min<std::size_t>(ourCount[track], kMaxClusters - 1U);
+      ++ourTotal[n];
+      if (bestShared[track] >= kSharedToMatch) {
+        ++ourMatched[n];
+      }
+      if (ourCount[track] < static_cast<std::uint32_t>(Detector<Det>::nLayers)) {
+        std::uint32_t mask = 0U;
+        for (std::uint32_t i = 0; i < view.count[track]; ++i) {
+          mask |= 1U << layerOfRow(view.clusters[track].index[i]);
+        }
+        ++shortPatterns[mask];
+      }
+    }
+    const auto sum = [](const auto& counts) { return std::accumulate(counts.begin(), counts.end(), std::size_t{0}); };
+    const auto byClusters = [&](const auto& part, const auto& whole) {
+      std::string line;
+      for (std::size_t n = kSharedToMatch; n < kMaxClusters; ++n) {
+        if (whole[n] != 0U) {
+          line += std::format(" {}: {}/{} ({:.1f})", n, part[n], whole[n], percent(part[n], whole[n]));
+        }
+      }
+      return line;
+    };
+    LOGP(info, "  against O2's tracks of these clusters, by shared clusters (no truth; {} or more shared is a match):", kSharedToMatch);
+    LOGP(info, "    O2: {} tracks, {} found by GTRK ({:.2f} %), {} reproduced exactly ({:.2f} %); found by clusters (%):{}", theirs.size(), sum(o2Found), percent(sum(o2Found), theirs.size()), sum(o2Reproduced), percent(sum(o2Reproduced), theirs.size()), byClusters(o2Found, o2Total));
+    LOGP(info, "    GTRK: {} tracks, {} with an O2 track ({:.2f} %), {} GTRK's own ({:.2f} %); with O2 by clusters (%):{}", tracks.size(), sum(ourMatched), percent(sum(ourMatched), tracks.size()), tracks.size() - sum(ourMatched), percent(tracks.size() - sum(ourMatched), tracks.size()), byClusters(ourMatched, ourTotal));
+    if (fullFoundShorter != 0U) {
+      std::string lacking;
+      for (std::size_t layer = 0; layer < static_cast<std::size_t>(Detector<Det>::nLayers); ++layer) {
+        lacking += std::format(" {}: {:.1f}", layer, percent(lackingLayer[layer], fullFoundShorter));
+      }
+      std::string lengths;
+      for (std::size_t n = kSharedToMatch; n < kMaxClusters; ++n) {
+        if (shorterLength[n] != 0U) {
+          lengths += std::format(" {}: {:.1f}", n, percent(shorterLength[n], fullFoundShorter));
+        }
+      }
+      LOGP(info,
+           "    O2's full-length tracks GTRK finds shorter: {}; the layer GTRK's track lacks (% of them, several per track):{}; GTRK's length (%):{}; "
+           "a lacking cluster held by another GTRK track {} ({:.1f} %), all free {}",
+           fullFoundShorter, lacking, lengths, shorterLackingTaken, percent(shorterLackingTaken, fullFoundShorter), shorterLackingFree);
+    }
+    if (!states.empty()) {
+      const auto bins = [&](const auto& edges, const auto& counts) {
+        std::string line;
+        for (std::size_t bin = 0; bin + 1U < edges.size(); ++bin) {
+          const auto total = counts[bin][0] + counts[bin][1] + counts[bin][2];
+          if (total != 0U) {
+            line += std::format(" [{:.1f},{:.1f}) {}: {:.1f}/{:.1f}/{:.1f}", edges[bin], edges[bin + 1U], total, percent(counts[bin][0], total), percent(counts[bin][1], total), percent(counts[bin][2], total));
+          }
+        }
+        return line;
+      };
+      LOGP(info, "    O2's full-length tracks by pT [GeV] (count: % full / % shorter / % missed):{}", bins(kO2PtEdges, fullByPt));
+      LOGP(info, "    O2's full-length tracks by |tan lambda| (count: % full / % shorter / % missed):{}", bins(kO2TglEdges, fullByTgl));
+    }
+    {
+      std::vector<std::pair<std::size_t, std::uint32_t>> top;
+      top.reserve(shortPatterns.size());
+      for (const auto& [mask, count] : shortPatterns) {
+        top.emplace_back(count, mask);
+      }
+      std::ranges::sort(top, std::ranges::greater{});
+      std::string line;
+      std::size_t shortTotal = 0U;
+      for (const auto& [count, mask] : top) {
+        shortTotal += count;
+      }
+      for (std::size_t i = 0; i < std::min<std::size_t>(top.size(), 6U); ++i) {
+        std::string layers;
+        for (std::size_t layer = 0; layer < static_cast<std::size_t>(Detector<Det>::nLayers); ++layer) {
+          if ((top[i].second & (1U << layer)) != 0U) {
+            layers += std::to_string(layer);
+          }
+        }
+        line += std::format(" {}: {} ({:.1f})", layers, top[i].first, percent(top[i].first, shortTotal));
+      }
+      LOGP(info, "    GTRK's tracks short of a layer, by layers (%):{}", line);
+    }
+    if (unknownClusters != 0U) {
+      LOGP(warning, "    {} clusters of O2's tracks are not among the {} measurements", unknownClusters, frame.size());
+    }
+  }
+
+  /// Each cluster index's measurement row, the maximum for none: one
+  /// measurement per cluster, so a cluster index at or past the row count
+  /// has none either.
+  [[nodiscard]] static std::vector<std::uint32_t> rowsOfClusters(const Frame& frame)
+  {
+    std::vector<std::uint32_t> rowOfCluster(frame.size(), std::numeric_limits<std::uint32_t>::max());
+    for (Frame::Index row = 0U; row < frame.size(); ++row) {
+      const auto cluster = frame.measurement(row).clusterIndex;
+      if (cluster < rowOfCluster.size()) {
+        rowOfCluster[cluster] = row;
+      }
+    }
+    return rowOfCluster;
+  }
+
+  /// O2's tracks of this timeframe as our measurement rows: O2's tracks name
+  /// O2's cluster indices, which are our measurements' clusterIndex.
+  [[nodiscard]] TrackRows o2TrackRows(const Frame& frame) const
+  {
+    const auto rowOfCluster = rowsOfClusters(frame);
+    const auto clusters = mO2Tracks->read(static_cast<long long>(mTimeframe));
+    TrackRows theirs;
+    theirs.reserve(clusters.size());
+    for (const auto& track : clusters) {
+      auto& rowsOfTrack = theirs.emplace_back();
+      for (const auto cluster : track) {
+        if (cluster >= rowOfCluster.size() || rowOfCluster[cluster] == std::numeric_limits<std::uint32_t>::max()) {
+          LOGP(fatal, "an O2 track holds cluster {}, which is not among the {} measurements", cluster, frame.size());
+        }
+        rowsOfTrack.push_back(rowOfCluster[cluster]);
+      }
+    }
+    return theirs;
+  }
+
+  /// Our tracks against O2's, \a theirs (`o2TrackRows`), with MC.
+  void compareWithO2(const Frame& frame, std::span<const TruthRow> rows, const ParticleTable& particles, const typename TrackRefit<Det>::Tracks& tracks, const TrackRows& theirs)
+  {
+    const TrackRows ours = trackRows(tracks);
+    for (const auto& line : compareTrackSets(rows, particles, ours, theirs, comparisonSettings<Det>(), "GTRK", "O2")) {
+      LOGP(info, "{}", line);
+    }
+    // The rule held to O2's own: its track labels' fake flags.
+    const auto flags = mO2Tracks->fakeFlags(static_cast<long long>(mTimeframe));
+    const auto fakes = std::ranges::count(flags, true);
+    LOGP(info, "  O2's own track labels: {} of {} fake ({:.2f} %)", fakes, flags.size(), percent(static_cast<std::uint64_t>(fakes), flags.size()));
+    if (mHits) {
+      measurePulls(frame, rows, tracks, theirs);
+    }
+  }
+
+  /// The species the q/p pulls are split by: electrons, muons, pions, kaons,
+  /// protons, and the rest.
+  static constexpr std::array<const char*, kSpeciesCount> kSpecies{"electrons", "muons", "pions", "kaons", "protons", "others"};
+
+  /// The crossing of \a chip by \a particle nearest to \a near, from the MC
+  /// hits; none if the particle is not the signal's or crossed no such chip.
+  [[nodiscard]] const study::HitSegment* crossingOf(std::uint64_t particle, std::uint32_t chip, const std::array<double, 3>& near)
+  {
+    const auto found = mParticleLabels.find(particle);
+    if (found == mParticleLabels.end() || found->second.source != 0) {
+      return nullptr;
+    }
+    const study::HitSegment* best = nullptr;
+    double bestDistance = std::numeric_limits<double>::infinity();
+    for (const auto& segment : mHits->event(found->second.event)) {
+      if (segment.track != found->second.track || segment.chip != chip) {
+        continue;
+      }
+      double distance = 0.;
+      for (std::size_t i = 0; i < 3U; ++i) {
+        const double d = (0.5 * (segment.start[i] + segment.end[i])) - near[i];
+        distance += d * d;
+      }
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        best = &segment;
+      }
+    }
+    return best;
+  }
+
+  /// The MC hits' crossings of a particle's rows' chips, in layer order, for
+  /// trueAnatomy; an empty function without the hits, and an empty list where
+  /// a row has no crossing of the particle's.
+  [[nodiscard]] TrueCrossings trueCrossings(const Frame& frame)
+  {
+    if (!mHits) {
+      return {};
+    }
+    return [this, &frame](std::uint64_t particle, std::span<const Frame::Index> rows) {
+      std::vector<TrueCrossing> result;
+      const auto found = mParticleLabels.find(particle);
+      if (found == mParticleLabels.end()) {
+        return result;
+      }
+      const auto* pdg = o2::O2DatabasePDG::Instance()->GetParticle(found->second.pdg);
+      const double mass = pdg == nullptr ? 0.13957 : pdg->Mass();
+      for (const auto row : rows) {
+        const auto m = frame.measurement(row);
+        const auto* segment = crossingOf(particle, m.surface, {static_cast<double>(m.x), static_cast<double>(m.y), static_cast<double>(m.z)});
+        if (segment == nullptr) {
+          return std::vector<TrueCrossing>{};
+        }
+        result.push_back({
+          .layer = static_cast<std::uint32_t>(mInterface.geometry().sensor(m.surface).layer),
+          .row = row,
+          .position = {0.5 * (segment->start[0] + segment->end[0]), 0.5 * (segment->start[1] + segment->end[1]), 0.5 * (segment->start[2] + segment->end[2])},
+          .momentum = segment->momentum,
+          .mass = mass,
+          .pdg = found->second.pdg,
+        });
+      }
+      std::ranges::stable_sort(result, {}, &TrueCrossing::layer);
+      return result;
+    };
+  }
+
+  /// A fitted state against its particle's MC crossing of the state's
+  /// sensor, the one nearest the measurement at \a row.
+  struct StateTruth {
+    std::array<double, 5> residual{}; ///< fitted less true: loc0, loc1, phi, theta, q/p
+    std::array<double, 5> sigma{};    ///< the fit's
+    double pt = 0.;                   ///< the truth's [GeV]
+    double momentum = 0.;             ///< the truth's [GeV]
+    double fittedPt = 0.;             ///< [GeV]
+    double ptSigma = 0.;              ///< of fittedPt, J C J^T over theta and q/p [GeV]
+  };
+
+  /// The truth on the plane the state is bound to (TrackingGeometry::planeOf:
+  /// a flat sensor's own at its measurement depth, a curved sensor's tangent
+  /// plane at the state's angle): where the MC segment's normal coordinate is
+  /// zero; its direction and momentum there. None without the segment, for a
+  /// neutral particle or a segment along the plane.
+  [[nodiscard]] std::optional<StateTruth> stateTruth(const Frame& frame, const BoundTrackState& state, std::uint64_t particle, Frame::Index row)
+  {
+    const auto m = frame.measurement(row);
+    const auto* segment = crossingOf(particle, state.surface, {static_cast<double>(m.x), static_cast<double>(m.y), static_cast<double>(m.z)});
+    const double charge = mParticleLabels[particle].charge;
+    if (segment == nullptr || exactlyEqual(charge, 0.) || !mInterface.configured()) {
+      return std::nullopt;
+    }
+    const TrackingSurface plane = mInterface.tracking().planeOf(state); // a copy: a curved sensor's is made on the spot
+    const auto local = [&](const std::array<double, 3>& global) {
+      std::array<double, 3> l{};
+      for (std::size_t i = 0; i < 3U; ++i) {
+        const double d = global[i] - static_cast<double>(plane.origin[i]);
+        l[0] += d * static_cast<double>(plane.axis0[i]);
+        l[1] += d * static_cast<double>(plane.axis1[i]);
+        l[2] += d * static_cast<double>(plane.normal[i]);
+      }
+      return l;
+    };
+    const auto start = local(segment->start);
+    const auto end = local(segment->end);
+    if (std::abs(start[2] - end[2]) < 1e-9) {
+      return std::nullopt;
+    }
+    const double t = start[2] / (start[2] - end[2]);
+    const auto& p = segment->momentum;
+    StateTruth truth;
+    truth.pt = std::hypot(p[0], p[1]);
+    const double momentum = std::hypot(truth.pt, p[2]);
+    truth.momentum = momentum;
+    truth.residual = {static_cast<double>(state.par[kLoc0]) - (start[0] + (t * (end[0] - start[0]))), static_cast<double>(state.par[kLoc1]) - (start[1] + (t * (end[1] - start[1]))), std::remainder(static_cast<double>(state.par[kPhi]) - std::atan2(p[1], p[0]), 2. * std::numbers::pi), static_cast<double>(state.par[kTheta]) - std::atan2(truth.pt, p[2]), static_cast<double>(state.par[kQOverP]) - (charge / momentum)};
+    for (int i = 0; i < 5; ++i) {
+      truth.sigma[static_cast<std::size_t>(i)] = std::sqrt(std::max(static_cast<double>(state.covAt(i, i)), 0.));
+    }
+    // pT = sin(theta) / |q/p|: d/dtheta = cos(theta) / |q/p|, d/d(q/p) = -pT / (q/p).
+    const auto theta = static_cast<double>(state.par[kTheta]);
+    const auto qOverP = static_cast<double>(state.par[kQOverP]);
+    truth.fittedPt = std::sin(theta) / std::abs(qOverP);
+    const double dTheta = std::cos(theta) / std::abs(qOverP);
+    const double dQOverP = -truth.fittedPt / qOverP;
+    const double variance = (dTheta * dTheta * static_cast<double>(state.covAt(kTheta, kTheta))) + (2. * dTheta * dQOverP * static_cast<double>(state.covAt(kTheta, kQOverP))) + (dQOverP * dQOverP * static_cast<double>(state.covAt(kQOverP, kQOverP)));
+    truth.ptSigma = std::sqrt(std::max(variance, 0.));
+    return truth;
+  }
+
+  /// The oracle refits of good track \a track of \a particle
+  /// (SpeciesOracle.h) into \a out, each against the particle's
+  /// crossing of \a row's sensor, \a entry its resolution entry; none for a
+  /// species without an oracle mass.
+  void speciesOracle(const Frame& frame, const typename TrackRefit<Det>::Tracks::ConstView& view, std::size_t track, std::uint64_t particle, Frame::Index row, const Propagator& propagator, const QAResolution& entry, std::vector<QAOracle>& out)
+  {
+    const auto mass = oracleMass(entry.pdg);
+    if (!mass.has_value()) {
+      return;
+    }
+    const RowChain<Det> chain{.frame = &frame, .rows = view.clusters[track].index};
+    const int count = view.count[track];
+    // The momentum lost inside the fitted chain: the crossing of the
+    // outermost measurement's sensor.
+    float pOuter = std::numeric_limits<float>::quiet_NaN();
+    const auto outer = frame.measurement(view.clusters[track].index[count - 1]);
+    if (const auto* segment = crossingOf(particle, outer.surface, {static_cast<double>(outer.x), static_cast<double>(outer.y), static_cast<double>(outer.z)}); segment != nullptr) {
+      pOuter = static_cast<float>(std::hypot(segment->momentum[0], segment->momentum[1], segment->momentum[2]));
+    }
+    for (std::size_t v = 0; v < kOracleVariants; ++v) {
+      const auto fit = oracleFit(static_cast<OracleVariant>(v), *mass, propagator, mInterface.tracking(), mInterface.material(), chain, count, view.outwardState[track]);
+      QAOracle o{
+        .pdg = entry.pdg,
+        .charge = entry.charge,
+        .origin = entry.origin,
+        .eta = entry.eta,
+        .layer = entry.layer,
+        .kinks = entry.kinks,
+        .clusters = entry.clusters,
+        .productionOffset = entry.productionOffset,
+        .pOuter = pOuter,
+        .variant = static_cast<std::uint8_t>(v),
+        .status = static_cast<std::uint8_t>(fit.status),
+        .chi2 = fit.chi2,
+        .ndf = fit.ndf,
+      };
+      const auto truth = fit.status == PropagationStatus::kOk ? stateTruth(frame, fit.state, particle, row) : std::nullopt;
+      if (truth.has_value()) {
+        o.momentum = static_cast<float>(truth->momentum);
+        o.ptResidual = static_cast<float>((truth->fittedPt / truth->pt) - 1.);
+        for (std::size_t i = 0; i < 5U; ++i) {
+          o.residual[i] = static_cast<float>(truth->residual[i]);
+          o.sigma[i] = static_cast<float>(truth->sigma[i]);
+        }
+      } else if (fit.status == PropagationStatus::kOk) {
+        o.status = std::numeric_limits<std::uint8_t>::max();
+      }
+      out.push_back(o);
+    }
+  }
+
+  /// \a state's closest approach to its particle's MC event vertex into
+  /// \a entry: carried to the plane
+  /// through the vertex along the beam, normal to its transverse direction
+  /// at the perigee (`beamLinePlane`), loc0 there d0 and loc1 less the
+  /// vertex's z z0; their sigmas J C J^T, J the analytic Jacobian; and the
+  /// scattering between the vertex and \a row, the innermost measurement, as
+  /// the beam-line update takes it (`sourceScattering`) but without the
+  /// measurement's own layer, whose stave the state is on: theta_k^2 s_k^2
+  /// for d0, over sin^2(theta) for z0. Left NaN where the propagation fails.
+  /// And \a truth's production point's distance from the vertex.
+  void vertexApproach(const Frame& frame, const BoundTrackState& state, std::uint64_t particle, Frame::Index row, const Propagator& propagator, const ParticleTruth& truth, QAResolution& entry) const
+  {
+    const auto& label = mParticleLabels.at(particle);
+    if (!mKinematics || label.source < 0 || label.event < 0) {
+      return;
+    }
+    const auto& header = mKinematics->getMCEventHeader(label.source, label.event);
+    entry.productionOffset = static_cast<float>(std::hypot(static_cast<double>(truth.vx) - header.GetX(), static_cast<double>(truth.vy) - header.GetY(), static_cast<double>(truth.vz) - header.GetZ()));
+    const auto& surface = mInterface.tracking().planeOf(state);
+    const auto plane = beamLinePlane(static_cast<Scalar>(header.GetX()), static_cast<Scalar>(header.GetY()), perigeePhi(propagator, state, surface));
+    SolenoidJacobian jacobian;
+    BoundTrackState predicted;
+    const auto status = jacobianAnalytic(propagator, state, surface, plane, PropagationDirection::kBackward, jacobian, &predicted);
+    if (status != PropagationStatus::kOk && status != PropagationStatus::kOutOfBounds) {
+      return;
+    }
+    const auto variance = [&](const Scalar* h) {
+      double v = 0.;
+      for (int i = 0; i < kNBoundParams; ++i) {
+        for (int j = 0; j < kNBoundParams; ++j) {
+          v += static_cast<double>(h[i]) * static_cast<double>(state.covAt(i, j)) * static_cast<double>(h[j]);
+        }
+      }
+      return v;
+    };
+    const double sinTheta = std::sin(static_cast<double>(state.theta()));
+    const auto layer = mInterface.tracking().surface(state.surface).layer;
+    const auto source = pairPointAt(frame.measurements(), row);
+    PairCut ownMomentum;
+    const Scalar betaPT = betaMomentum(1.F / std::abs(state.qOverP()), propagator.massGeV) * std::abs(std::sin(state.theta()));
+    ownMomentum.invBetaMomentum2 = 1.F / (betaPT * betaPT);
+    const VertexSeed vertex{.z = static_cast<Scalar>(header.GetZ())};
+    // sourceScattering's sum without the source's own layer.
+    const Scalar dz = source.z - vertex.z;
+    const Scalar slope = dz / source.r;
+    const Scalar absDz = std::abs(dz);
+    const Scalar invAbsDz = absDz > 0.F ? 1.F / absDz : 0.F;
+    const Scalar discFactor = source.r * source.r * source.r * invAbsDz * invAbsDz * invAbsDz;
+    Scalar inside = 0.F;
+    Scalar term = 0.F;
+    for (std::size_t other = 0; other < ScatteringTable<Det>::kLayerCount; ++other) {
+      const auto id = static_cast<LayerID>(other);
+      if (id != layer && detail::crossedBeforeSource(mInterface.scattering().layers[other], Detector<Det>::isBarrelLayer(id), false, vertex, source, dz, slope, absDz, discFactor, term)) {
+        inside += term;
+      }
+    }
+    if constexpr (ScatteringTable<Det>::kPassiveCount > 0) {
+      for (const auto& passive : mInterface.scattering().passives) {
+        if (detail::crossedBeforeSource(passive.at, passive.barrel, false, vertex, source, dz, slope, absDz, discFactor, term)) {
+          inside += term;
+        }
+      }
+    }
+    inside *= std::sqrt(1.F + (slope * slope)) * ownMomentum.invBetaMomentum2;
+    entry.dca = {predicted.loc0(), static_cast<float>(static_cast<double>(predicted.loc1()) - header.GetZ())};
+    entry.dcaSigma = {static_cast<float>(std::sqrt(std::max(variance(jacobian.loc0), 0.))), static_cast<float>(std::sqrt(std::max(variance(jacobian.loc1), 0.)))};
+    entry.dcaScattering = {std::sqrt(inside), static_cast<float>(static_cast<double>(std::sqrt(inside)) / std::abs(sinTheta))};
+  }
+
+  /// The fitted state at the innermost measurement of every good track, ours
+  /// and O2's, against the MC hit on that measurement's chip, each in its
+  /// own parameters and covariance, and both as common residuals
+  /// (TrackPulls.h). Ours are bound to the sensor plane; O2's are in its
+  /// tracking frame, which only the ITS's tracks are.
+  void measurePulls(const Frame& frame, std::span<const TruthRow> rows, const typename TrackRefit<Det>::Tracks& tracks, const TrackRows& theirs)
+  {
+    const std::vector<PullParameter> common{{.name = "across", .unit = "um", .scale = 1e4}, {.name = "along", .unit = "um", .scale = 1e4}, {.name = "phi", .unit = "mrad", .scale = 1e3}, {.name = "dip", .unit = "mrad", .scale = 1e3}, {.name = "pT", .unit = "%", .scale = 1e2}};
+    PullTable ours{"GTRK at the innermost measurement, bound parameters", {{.name = "loc0", .unit = "um", .scale = 1e4}, {.name = "loc1", .unit = "um", .scale = 1e4}, {.name = "phi", .unit = "mrad", .scale = 1e3}, {.name = "theta", .unit = "mrad", .scale = 1e3}, {.name = "q/p", .unit = "1/GeV", .scale = 1.}}};
+    PullTable oursCommon{"GTRK, common residuals", common};
+    // The q/p pull and the pT bias split by species, whose mass the fit's
+    // energy loss does not know, and by kink.
+    const std::vector<PullParameter> qOverPAndPt{{.name = "q/p", .unit = "1/GeV", .scale = 1.}, {.name = "pT", .unit = "%", .scale = 1e2}};
+    const auto split = [&](const std::string& who, std::span<const char* const> classes) {
+      std::vector<PullTable> tables;
+      tables.reserve(classes.size());
+      for (const auto* name : classes) {
+        tables.emplace_back(fmt::format("{}, {}", who, name), qOverPAndPt);
+      }
+      return tables;
+    };
+    auto oursBySpecies = split("GTRK q/p by species", kSpecies);
+    constexpr std::array<const char*, 2> kKinkClasses{"without a kink", "with a kink"};
+    auto oursByKink = split("GTRK q/p", kKinkClasses);
+    const auto view = tracks.view();
+    std::vector<std::uint32_t> trackRows;
+    for (std::size_t track = 0; track < tracks.size(); ++track) {
+      const auto& clusters = view.clusters[track];
+      trackRows.assign(std::begin(clusters.index), std::begin(clusters.index) + view.count[track]);
+      const auto particle = goodParticle(rows, trackRows);
+      const auto& state = view.state[track];
+      const auto innermost = std::ranges::find_if(trackRows, [&](std::uint32_t row) { return frame.measurement(row).surface == state.surface; });
+      if (particle == kNoTrackParticle || innermost == trackRows.end()) {
+        continue;
+      }
+      const auto truth = stateTruth(frame, state, particle, *innermost);
+      if (!truth.has_value()) {
+        continue;
+      }
+      const auto& residual = truth->residual;
+      const auto& sigma = truth->sigma;
+      const double pt = truth->pt;
+      ours.add(pt, residual, sigma);
+      const double fittedPt = truth->fittedPt;
+      oursCommon.add(pt, std::array<double, 5>{residual[0], residual[1], residual[2], -residual[3], (fittedPt / pt) - 1.}, std::array<double, 5>{});
+      const std::array<double, 2> qOverP{residual[4], (fittedPt / pt) - 1.};
+      const std::array<double, 2> qOverPSigma{sigma[4], 0.};
+      oursBySpecies[speciesOf(mParticleLabels[particle].pdg)].add(pt, qOverP, qOverPSigma);
+      oursByKink[view.kinks[track] == 0U ? 0U : 1U].add(pt, qOverP, qOverPSigma);
+    }
+    std::vector<std::string> lines = ours.report();
+    const auto append = [&](const PullTable& table) {
+      const auto more = table.report();
+      lines.insert(lines.end(), more.begin(), more.end());
+    };
+    append(oursCommon);
+    for (const auto* tables : {&oursBySpecies, &oursByKink}) {
+      for (const auto& table : *tables) {
+        append(table);
+      }
+    }
+
+    if constexpr (std::is_same_v<Det, detectors::ITS>) {
+      const auto point = [&](Frame::Index row) {
+        const auto m = frame.measurement(row);
+        return std::array<double, 3>{static_cast<double>(m.x), static_cast<double>(m.y), static_cast<double>(m.z)};
+      };
+      const auto states = mO2Tracks->innerStates(static_cast<long long>(mTimeframe));
+      PullTable o2{"O2 at the innermost cluster, tracking-frame parameters", {{.name = "y", .unit = "um", .scale = 1e4}, {.name = "z", .unit = "um", .scale = 1e4}, {.name = "snp", .unit = "1e-3", .scale = 1e3}, {.name = "tgl", .unit = "1e-3", .scale = 1e3}, {.name = "q/pT", .unit = "1/GeV", .scale = 1.}}};
+      PullTable o2Common{"O2, common residuals", common};
+      auto o2BySpecies = split("O2 q/pT by species", kSpecies);
+      for (std::size_t track = 0; track < std::min(theirs.size(), states.size()); ++track) {
+        const auto particle = goodParticle(rows, theirs[track]);
+        const auto innermost = std::ranges::min_element(theirs[track], {}, [&](std::uint32_t row) { return rows[row].layer; });
+        if (particle == kNoTrackParticle || innermost == theirs[track].end()) {
+          continue;
+        }
+        const auto chip = frame.measurement(*innermost).surface;
+        const auto* segment = crossingOf(particle, chip, point(*innermost));
+        const double charge = mParticleLabels[particle].charge;
+        if (segment == nullptr || exactlyEqual(charge, 0.)) {
+          continue;
+        }
+        const auto& state = states[track];
+        const double c = std::cos(static_cast<double>(state.getAlpha()));
+        const double s = std::sin(static_cast<double>(state.getAlpha()));
+        const auto rotate = [&](const std::array<double, 3>& v) { return std::array<double, 3>{(c * v[0]) + (s * v[1]), (c * v[1]) - (s * v[0]), v[2]}; };
+        const auto a = rotate(segment->start);
+        const auto b = rotate(segment->end);
+        const auto p = rotate(segment->momentum);
+        if (std::abs(b[0] - a[0]) < 1e-9) {
+          continue;
+        }
+        const double t = (static_cast<double>(state.getX()) - a[0]) / (b[0] - a[0]);
+        const double pt = std::hypot(p[0], p[1]);
+        const std::array<double, 5> truth{a[1] + (t * (b[1] - a[1])), a[2] + (t * (b[2] - a[2])), p[1] / pt, p[2] / pt, charge / pt};
+        std::array<double, 5> residual{};
+        std::array<double, 5> sigma{};
+        for (std::size_t i = 0; i < 5U; ++i) {
+          residual[i] = static_cast<double>(state.getParam(static_cast<int>(i))) - truth[i];
+          sigma[i] = std::sqrt(std::max(static_cast<double>(state.getDiagError2(static_cast<int>(i))), 0.));
+        }
+        o2.add(pt, residual, sigma);
+        o2Common.add(pt, std::array<double, 5>{residual[0], residual[1], std::asin(std::clamp(static_cast<double>(state.getParam(2)), -1., 1.)) - std::asin(truth[2]), std::atan(static_cast<double>(state.getParam(3))) - std::atan(truth[3]), (std::abs(truth[4]) / std::abs(static_cast<double>(state.getParam(4)))) - 1.}, std::array<double, 5>{});
+        o2BySpecies[speciesOf(mParticleLabels[particle].pdg)].add(pt, std::array<double, 2>{residual[4], (std::abs(truth[4]) / std::abs(static_cast<double>(state.getParam(4)))) - 1.}, std::array<double, 2>{sigma[4], 0.});
+      }
+      append(o2);
+      append(o2Common);
+      for (const auto& table : o2BySpecies) {
+        append(table);
+      }
+    }
+    LOGP(info, "pulls against the MC hits");
+    for (const auto& line : lines) {
+      LOGP(info, "{}", line);
+    }
+  }
+
+  std::unique_ptr<study::TrackFile> mO2Tracks; ///< O2's tracks of these clusters; none unless --o2-tracks
+  std::unique_ptr<study::HitFile> mHits;       ///< O2's MC hits, with MC; none if the file is not there
+  /// Every particle the comparison saw, as its MC label and charge.
+  struct ParticleLabel {
+    int event = -1;
+    int track = -1;
+    int source = -1;
+    double charge = 0.;
+    int pdg = 0;
+    TruthHelix helix{}; ///< at production
+    // NOLINTNEXTLINE(readability-redundant-member-init): GCC's -Wmissing-field-initializers wants it
+    std::optional<TruthHelix> mother{}; ///< the mother's at its own production
+  };
+  std::unordered_map<std::uint64_t, ParticleLabel> mParticleLabels;
+  bool mUseMC = true;
+  bool mSpeciesOracle = false;                               ///< --species-oracle: the `oracle` QA tree
+  bool mTruthReports = true;                                 ///< the stages' truth, the true roads' chi2 and the fakes' anatomy in the log; on unless --no-truth-reports, data runs too
+  bool mWithVertices = true;                                 ///< the vertex list is an input
+  TrackerProducts mTrackerProducts = TrackerProducts::kNone; ///< the tracking device's products, an input: compared, or digested
+  workflow::TrackingInterface<Det> mInterface;               ///< the tracking: geometry, material, tracker, vertexer (TrackingInterface.h)
+  std::unique_ptr<o2::steer::DigitizationContext> mContext;
+  std::unique_ptr<o2::steer::MCKinematicsReader> mKinematics;
+  std::shared_ptr<workflow::Conditions<Det, true>> mConditions; ///< the run's field, geometry, MeanVertex and material LUT (Conditions.h)
+  std::ofstream mTruthOutput;
+  std::unique_ptr<o2::utils::TreeStreamRedirector> mQAOutput; ///< --qa-output's file; none without it
+  /// The tracker's observers over one timeframe: the open iteration's stage
+  /// truth, made at its first slice, and each finished iteration's summary;
+  /// with MC its stage funnel.
+  struct RunObservers {
+    std::optional<StageTruth> stage;
+    std::vector<TrackletRunSummary> summaries;
+    std::function<void(const Controller&, std::size_t, std::optional<StageTruth>&)> openStage; ///< set per timeframe
+    std::optional<Funnel> funnel;
+  };
+  RunObservers mObservers;
+  std::string mDumpInput;          ///< where the dumped timeframe's tracking input goes; empty: nowhere
+  std::size_t mDumpTimeframe = 0U; ///< which timeframe, counting from 0
+  bool mDumpOnly = false;          ///< the dumped timeframe is not tracked
+  std::size_t mTimeframe = 0U;
+};
+
+/// The detector's MC hits in an O2 production's timeframe directory.
+[[nodiscard]] constexpr const char* hitFileName()
+{
+  if constexpr (std::is_same_v<Det, detectors::MFT>) {
+    return "sgn_HitsMFT.root";
+  } else if constexpr (std::is_same_v<Det, detectors::TRKFT3>) {
+    return "sgn_HitsTRK.root";
+  } else {
+    return "sgn_HitsITS.root";
+  }
+}
+
+} // namespace
+
+template <>
+DataProcessorSpec getMeasurementSinkSpec<Det>(bool useMC, bool withVertices, TrackerProducts products)
+{
+  auto inputs = workflow::measurementInputs<Det>(withVertices);
+  if (useMC) {
+    inputs.emplace_back("labels", workflow::gDataOrigin, workflow::description<Det>(workflow::kClustersMCTruth), 0, Lifetime::Timeframe);
+  }
+  if (products != TrackerProducts::kNone) {
+    inputs.emplace_back("deviceTracks", workflow::gDataOrigin, workflow::description<Det>(workflow::kTracks), 0, Lifetime::Timeframe);
+    inputs.emplace_back("deviceVertices", workflow::gDataOrigin, workflow::description<Det>(workflow::kVertexSeeds), 0, Lifetime::Timeframe);
+    inputs.emplace_back("deviceContributors", workflow::gDataOrigin, workflow::description<Det>(workflow::kVertexContributors), 0, Lifetime::Timeframe);
+  }
+  auto conditions = std::make_shared<workflow::Conditions<Det, true>>(inputs);
+
+  DataProcessorSpec spec{
+    .name = workflow::deviceName<Det>("measurement-sink"),
+    .inputs = inputs,
+    .outputs = Outputs{},
+    .algorithm = AlgorithmSpec{adaptFromTask<MeasurementSinkTask>(useMC, withVertices, products, conditions)},
+    .options = Options{{"collision-context", VariantType::String, "collisioncontext.root", {"collision context and MC-event mapping"}}, {"input-dir", VariantType::String, "none", {"input directory"}}, {"tracklet-truth-output", VariantType::String, "gtrk_tracklet_truth.csv", {"per-link pT and cot(theta) truth breakdown; empty disables"}}, {"dump-tracking-input", VariantType::String, "", {"write one timeframe's tracking input here, for o2-gtrk-track-bench"}}, {"dump-timeframe", VariantType::Int, 0, {"which timeframe --dump-tracking-input writes, counting from 0"}}, {"dump-only", VariantType::Bool, false, {"with --dump-tracking-input, the dumped timeframe is not tracked"}}, {"qa-output", VariantType::String, "", {"the MC truth QA as ROOT trees; empty disables"}}, {"species-oracle", VariantType::Bool, false, {"with --qa-output, refit every good track of e, mu, pi, K, p with its true mass: the oracle tree"}}, {"no-truth-reports", VariantType::Bool, false, {"with MC, no truth reports in the log (stages, true roads' chi2, fake anatomy): for the QA alone"}}, {"o2-tracks", VariantType::String, "", {"O2's tracks of the same clusters (o2trac_its.root, mfttracks.root), compared under one set of truth rules"}}, {"mc-hits", VariantType::String, hitFileName(), {"O2's MC hits, for the pulls, the true kinks and the QA's outward legs"}}},
+  };
+  if constexpr (std::is_same_v<Det, detectors::TRKFT3>) {
+    spec.options.push_back({"mc-ft3-hits", VariantType::String, "sgn_HitsFT3.root", {"O2's MC hits of FT3's discs, with --mc-hits TRK's"}});
+  }
+  return spec;
+}
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/src/ProfileReport.cxx b/Detectors/GenericTracking/study/src/ProfileReport.cxx
new file mode 100644
index 0000000000000..9a61510f4525f
--- /dev/null
+++ b/Detectors/GenericTracking/study/src/ProfileReport.cxx
@@ -0,0 +1,171 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Study/ProfileReport.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <format>
+#include <ostream>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+namespace
+{
+
+using enum profile::Phase;
+
+/// The chunk duration below which \a fraction of the chunks lie, from the
+/// histogram: the upper edge of the bin that crosses it [s].
+[[nodiscard]] double chunkQuantile(const profile::PhaseStats& stats, double fraction)
+{
+  if (stats.chunks == 0U) {
+    return 0.;
+  }
+  const auto target = fraction * static_cast<double>(stats.chunks);
+  std::uint64_t below = 0U;
+  for (std::size_t bin = 0; bin < profile::kChunkBins; ++bin) {
+    below += stats.chunkHistogram[bin];
+    if (static_cast<double>(below) >= target) {
+      return std::ldexp(1., static_cast<int>(bin) + 1) * 1.e-9;
+    }
+  }
+  return stats.maxChunkSeconds;
+}
+
+} // namespace
+
+void report(std::ostream& out, const profile::Profile& profile, profile::Phase root, int threads)
+{
+  const auto& top = profile[root];
+  if (top.calls == 0U) {
+    return;
+  }
+  const auto parentOf = [](std::size_t index) { return info(static_cast<profile::Phase>(index)).parent; };
+  // Per phase: its own serial time -- what neither a child, a parallel loop
+  // nor an opaque parallel call covers -- and that summed over its subtree;
+  // children follow their parents in the enum, so a reverse pass sums them.
+  std::array<double, profile::kPhaseCount> childSeconds{};
+  std::array<std::uint64_t, profile::kPhaseCount> childFaults{};
+  std::array<std::uint64_t, profile::kPhaseCount> childBytes{};
+  for (std::size_t index = 0; index < profile::kPhaseCount; ++index) {
+    if (parentOf(index) != kNone) {
+      const auto parent = static_cast<std::size_t>(parentOf(index));
+      childSeconds[parent] += profile.phases[index].seconds;
+      childFaults[parent] += profile.phases[index].minorFaults;
+      childBytes[parent] += profile.phases[index].allocatedBytes;
+    }
+  }
+  std::array<double, profile::kPhaseCount> ownSerial{};
+  std::array<double, profile::kPhaseCount> subtreeSerial{};
+  for (std::size_t index = 0; index < profile::kPhaseCount; ++index) {
+    const auto& stats = profile.phases[index];
+    ownSerial[index] = std::max(0., stats.seconds - childSeconds[index] - stats.regionSeconds - stats.opaqueSeconds);
+    subtreeSerial[index] = ownSerial[index];
+  }
+  for (std::size_t index = profile::kPhaseCount; index-- > 0U;) {
+    if (parentOf(index) != kNone) {
+      subtreeSerial[static_cast<std::size_t>(parentOf(index))] += subtreeSerial[index];
+    }
+  }
+  const auto depthOf = [&](std::size_t index) {
+    int depth = 0;
+    for (auto phase = static_cast<profile::Phase>(index); phase != root; phase = parentOf(static_cast<std::size_t>(phase))) {
+      ++depth;
+    }
+    return depth;
+  };
+
+  out << std::format("{:<36} {:>8} {:>6} {:>6} {:>8} {:>11} {:>8} {:>5} {:>5} {:>7} {:>8} {:>8} {:>8} {:>8} {:>8} {:>8} {:>8}\n", "phase", "wall s", "share", "calls", "serial s", "elements", "ns/elem", "util", "imbal", "tail s", "chunk50", "chunk99", "chunkmax", "faults", "alloc MB", "peak MB", "+peak MB");
+  // The parallel columns describe the loops opened directly in a phase: on a
+  // leaf's row, or on the `(other)` row under a parent.
+  const auto parallelColumns = [](const profile::PhaseStats& stats) {
+    if (stats.regions == 0U || stats.busySeconds <= 0. || stats.regionSeconds <= 0.) {
+      return std::format("{:>11} {:>8} {:>5} {:>5} {:>7} {:>8} {:>8} {:>8}", "", "", "", "", "", "", "", "");
+    }
+    const double concurrency = stats.capacitySeconds / stats.regionSeconds;
+    return std::format("{:>11} {:>8.1f} {:>5.2f} {:>5.2f} {:>7.4f} {:>8.1e} {:>8.1e} {:>8.1e}", stats.elements, stats.elements != 0U ? 1.e9 * stats.busySeconds / static_cast<double>(stats.elements) : 0., stats.busySeconds / stats.capacitySeconds, stats.maxSlotSeconds * concurrency / stats.busySeconds, stats.tailSeconds / concurrency, chunkQuantile(stats, 0.5), chunkQuantile(stats, 0.99), stats.maxChunkSeconds);
+  };
+  const auto row = [&](std::string_view label, int depth, double seconds, double parentSeconds, std::uint64_t calls, double serial, const std::string& parallel, std::uint64_t faults, std::uint64_t bytes, const std::string& peak) {
+    const std::string indented = std::string(static_cast<std::size_t>(2 * depth), ' ') + std::string{label};
+    out << std::format("{:<36} {:>8.4f} {:>5.1f}% {:>6} {:>8.4f} {} {:>8} {:>8.1f} {}\n", indented, seconds, parentSeconds > 0. ? 100. * seconds / parentSeconds : 100., calls, serial, parallel, faults, static_cast<double>(bytes) / 1.e6, peak);
+  };
+  // A peak is the phase's own; the `(other)` row has none.
+  const auto peakColumn = [](const profile::PhaseStats& stats) { return std::format("{:>8.1f} {:>8.1f}", static_cast<double>(stats.peakBytes) / 1.e6, static_cast<double>(stats.peakGrowthBytes) / 1.e6); };
+
+  double idle = 0.;
+  double tails = 0.;
+  double opaque = 0.;
+  // The rows in tree order -- a phase, its `(other)` row, then its children
+  // in enum order -- since a child need not follow its parent closely in the
+  // enum (the paths' phases, the road fills): a depth-first walk, the
+  // children pushed last first so the first comes out first.
+  std::vector<std::size_t> pending{static_cast<std::size_t>(root)};
+  while (!pending.empty()) {
+    const auto index = pending.back();
+    pending.pop_back();
+    const auto& stats = profile.phases[index];
+    if (stats.calls != 0U) {
+      const double parentSeconds = static_cast<profile::Phase>(index) == root ? stats.seconds : profile[parentOf(index)].seconds;
+      const bool parent = childSeconds[index] > 0.;
+      row(info(static_cast<profile::Phase>(index)).name, depthOf(index), stats.seconds, parentSeconds, stats.calls, subtreeSerial[index], parent ? parallelColumns(profile::PhaseStats{}) : parallelColumns(stats), stats.minorFaults, stats.allocatedBytes, peakColumn(stats));
+      if (parent) {
+        row("(other)", depthOf(index) + 1, stats.seconds - childSeconds[index], stats.seconds, stats.calls, ownSerial[index], parallelColumns(stats), stats.minorFaults - std::min(stats.minorFaults, childFaults[index]), stats.allocatedBytes - std::min(stats.allocatedBytes, childBytes[index]), std::format("{:>8} {:>8}", "", ""));
+      }
+      idle += stats.capacitySeconds - stats.busySeconds;
+      tails += stats.tailSeconds;
+      opaque += stats.opaqueSeconds;
+    }
+    for (std::size_t child = profile::kPhaseCount; child-- > index + 1U;) {
+      if (parentOf(child) == static_cast<profile::Phase>(index)) {
+        pending.push_back(child);
+      }
+    }
+  }
+  const double wall = top.seconds;
+  const double serial = subtreeSerial[static_cast<std::size_t>(root)];
+  const auto perThread = [&](double threadSeconds) { return threads > 0 ? threadSeconds / threads : 0.; };
+  out << std::format(
+    "{}: {:.4f} s; serial {:.4f} s ({:.1f} %); opaque parallel {:.4f} s; parallel loops idle {:.4f} s of {} threads "
+    "({:.1f} %), of which tails {:.4f} s\n",
+    info(root).name, wall, serial, wall > 0. ? 100. * serial / wall : 0., opaque, perThread(idle), threads, wall > 0. ? 100. * perThread(idle) / wall : 0., perThread(tails));
+}
+
+void writeJson(std::ostream& out, const profile::Profile& profile)
+{
+  out << '{';
+  bool first = true;
+  for (std::size_t phase = 0; phase < profile::kPhaseCount; ++phase) {
+    const auto& stats = profile.phases[phase];
+    if (stats.calls == 0U) {
+      continue;
+    }
+    out << (first ? "" : ",");
+    first = false;
+    out << std::format(R"("{}":{{"parent":"{}","seconds":{:.9f},"calls":{},"elements":{},"outputs":{},"regions":{},"chunks":{},)"
+                       R"("regionSeconds":{:.9f},"capacitySeconds":{:.9f},"busySeconds":{:.9f},"maxSlotSeconds":{:.9f},"tailSeconds":{:.9f},)"
+                       R"("maxChunkSeconds":{:.9f},"opaqueSeconds":{:.9f},"minorFaults":{},"dramBytes":{},"allocations":{},"allocatedBytes":{},"peakBytes":{},"peakGrowthBytes":{},"chunkHistogram":[)",
+                       info(static_cast<profile::Phase>(phase)).name, info(static_cast<profile::Phase>(phase)).parent == kNone ? "" : info(info(static_cast<profile::Phase>(phase)).parent).name, stats.seconds, stats.calls, stats.elements, stats.outputs, stats.regions, stats.chunks, stats.regionSeconds, stats.capacitySeconds, stats.busySeconds, stats.maxSlotSeconds, stats.tailSeconds, stats.maxChunkSeconds, stats.opaqueSeconds, stats.minorFaults, stats.dramBytes, stats.allocations, stats.allocatedBytes, stats.peakBytes, stats.peakGrowthBytes);
+    for (std::size_t bin = 0; bin < profile::kChunkBins; ++bin) {
+      out << (bin == 0U ? "" : ",") << stats.chunkHistogram[bin];
+    }
+    out << "]}";
+  }
+  out << '}';
+}
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/src/TrackComparison.cxx b/Detectors/GenericTracking/study/src/TrackComparison.cxx
new file mode 100644
index 0000000000000..3c640646df927
--- /dev/null
+++ b/Detectors/GenericTracking/study/src/TrackComparison.cxx
@@ -0,0 +1,785 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Study/TrackComparison.h"
+#include "GenericTracking/Study/Statistics.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cmath>
+#include <cstdlib>
+#include <cstddef>
+#include <format>
+#include <functional>
+#include <iterator>
+#include <map>
+#include <numbers>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+namespace
+{
+
+struct Particle {
+  float pt = 0.F;
+  bool primary = false;
+  float eta = 0.F;
+  float phi = 0.F;
+  std::uint64_t layers = 0U;      ///< a bit per layer with a measurement of it
+  std::uint64_t firstLayers = 0U; ///< the same, from the first labels O2's QA counts
+  ParticleLayers chain;           ///< its layers and longest chain (particleLayers)
+  ParticleOrigin origin = ParticleOrigin::kMaterial;
+  std::int32_t species = 0; ///< |PDG code|
+  DecayFamily family = DecayFamily::kOther;
+  std::size_t production = 0U; ///< its production bin (productionBin)
+};
+
+/// Where one tracker's fakes go wrong: every measurement of a fake that does
+/// not carry its label, by layer, by whether the label's particle had a
+/// measurement of its own on that layer, and by whose it is instead.
+struct FakeAnatomy {
+  static constexpr std::size_t kWrongSlots = 5U; ///< 1, 2, 3, 4 or more wrong; slot 0: no label at all
+  static constexpr std::size_t kLayerSlots = 64U;
+  std::array<std::uint64_t, kWrongSlots> byWrong{};
+  std::array<std::uint64_t, kLayerSlots> wrongByLayer{};
+  std::uint64_t wrong = 0U;
+  std::uint64_t swaps = 0U; ///< the label had its own measurement on the layer
+  std::uint64_t holes = 0U; ///< it had none there
+  std::uint64_t noise = 0U; ///< the wrong measurement carries no particle
+  std::uint64_t primaryStranger = 0U;
+  std::uint64_t secondaryStranger = 0U;
+  std::uint64_t labelPrimary = 0U;
+  std::uint64_t labelSecondary = 0U;
+  std::vector<std::uint64_t> labels; ///< every fake's label, for the other tracker's view of it
+};
+
+/// One tracker's tracks against the particles.
+struct Tally {
+  std::unordered_map<std::uint64_t, std::uint32_t> good;       ///< good tracks per particle
+  std::unordered_map<std::uint64_t, std::uint64_t> goodLayers; ///< per particle, the layers of its good track with the most
+  std::unordered_map<std::uint64_t, bool> fakeLabel;           ///< particles some fake is labelled with
+  std::array<std::uint64_t, kScoreLengthSlots> byLength{};
+  std::array<std::uint64_t, kScoreLengthSlots> fakesByLength{};
+  /// Tracks short of every layer, and their fakes, by their layers' bits.
+  std::map<std::uint64_t, std::array<std::uint64_t, 2>> byPattern;
+  std::uint64_t tracks = 0U;
+  std::uint64_t fakes = 0U;
+  FakeAnatomy anatomy;
+};
+
+/// Each track's particle by `majorityParticle`, and whether every
+/// measurement carries it.
+Tally tally(std::span<const TruthRow> rows, const TrackRows& tracks, const std::unordered_map<std::uint64_t, Particle>& particles, int nLayers)
+{
+  Tally result;
+  auto& anatomy = result.anatomy;
+  const auto primary = [&](std::uint64_t id) {
+    const auto found = particles.find(id);
+    return found != particles.end() && found->second.primary;
+  };
+  for (const auto& track : tracks) {
+    const auto [label, most] = majorityParticle(rows, track);
+    const auto length = std::min<std::size_t>(track.size(), kScoreLengthSlots - 1U);
+    std::uint64_t pattern = 0U;
+    for (const auto row : track) {
+      pattern |= std::uint64_t{1} << rows[row].layer;
+    }
+    // Every layer of the detector: the comparison with O2 runs on the ITS
+    // and MFT, whose class has no mask.
+    const bool partial = std::cmp_less(std::popcount(pattern), nLayers);
+    ++result.tracks;
+    ++result.byLength[length];
+    if (partial) {
+      ++result.byPattern[pattern][0];
+    }
+    if (label != kNoTrackParticle && most == track.size()) {
+      ++result.good[label];
+      auto& layers = result.goodLayers[label];
+      if (std::popcount(pattern) > std::popcount(layers)) {
+        layers = pattern;
+      }
+      continue;
+    }
+    ++result.fakes;
+    ++result.fakesByLength[length];
+    if (partial) {
+      ++result.byPattern[pattern][1];
+    }
+    if (label == kNoTrackParticle) {
+      ++anatomy.byWrong[0];
+      continue;
+    }
+    result.fakeLabel[label] = true;
+    anatomy.labels.push_back(label);
+    ++(primary(label) ? anatomy.labelPrimary : anatomy.labelSecondary);
+    ++anatomy.byWrong[std::min<std::size_t>(track.size() - most, FakeAnatomy::kWrongSlots - 1U)];
+    const auto own = particles.find(label);
+    const std::uint64_t ownLayers = own == particles.end() ? 0U : own->second.layers;
+    for (const auto row : track) {
+      const auto& truth = rows[row];
+      if (truth.carries(label)) {
+        continue;
+      }
+      ++anatomy.wrong;
+      ++anatomy.wrongByLayer[std::min<std::size_t>(truth.layer, FakeAnatomy::kLayerSlots - 1U)];
+      ++((ownLayers & (std::uint64_t{1} << truth.layer)) != 0U ? anatomy.swaps : anatomy.holes);
+      if (truth.count == 0U) {
+        ++anatomy.noise;
+      } else if (std::any_of(truth.particles.begin(), truth.particles.begin() + truth.count, primary)) {
+        ++anatomy.primaryStranger;
+      } else {
+        ++anatomy.secondaryStranger;
+      }
+    }
+  }
+  return result;
+}
+
+/// \a mine's fakes, and what \a other made of their particles.
+void describeFakes(std::vector<std::string>& report, const std::string& name, const Tally& mine, const Tally& other, int nLayers)
+{
+  const auto& a = mine.anatomy;
+  report.push_back(
+    std::format("  {:>6} fakes: {}; labelled with a primary {:.1f} %, a secondary {:.1f} %, nothing {:.1f} %; by wrong measurements 1 / 2 / 3 / "
+                "4+: {:.1f} / {:.1f} / {:.1f} / {:.1f} %",
+                name, mine.fakes, percent(a.labelPrimary, mine.fakes), percent(a.labelSecondary, mine.fakes), percent(a.byWrong[0], mine.fakes), percent(a.byWrong[1], mine.fakes), percent(a.byWrong[2], mine.fakes), percent(a.byWrong[3], mine.fakes), percent(a.byWrong[4], mine.fakes)));
+  std::string layers;
+  for (int layer = 0; layer < nLayers; ++layer) {
+    layers += std::format(" {}: {:.1f}", layer, percent(a.wrongByLayer[static_cast<std::size_t>(layer)], a.wrong));
+  }
+  report.push_back(std::format("         {} wrong measurements, by layer (%):{}", a.wrong, layers));
+  report.push_back(
+    std::format("         the label's own measurement on that layer passed over {:.1f} %, none of its own there {:.1f} %; the wrong one "
+                "noise {:.1f} %, another primary's {:.1f} %, a secondary's {:.1f} %",
+                percent(a.swaps, a.wrong), percent(a.holes, a.wrong), percent(a.noise, a.wrong), percent(a.primaryStranger, a.wrong), percent(a.secondaryStranger, a.wrong)));
+  std::uint64_t cleanElsewhere = 0U;
+  for (const auto label : a.labels) {
+    cleanElsewhere += other.good.contains(label) ? 1U : 0U;
+  }
+  report.push_back(std::format("         their particles found with a good track by the other tracker: {:.1f} %", percent(cleanElsewhere, a.labels.size())));
+}
+
+/// The tracks short of every layer by their layers, most common first: every
+/// pattern with at least 0.5 % of them, the rest summed.
+std::string describePatterns(const std::string& name, const Tally& tally)
+{
+  std::vector<std::pair<std::uint64_t, std::array<std::uint64_t, 2>>> patterns(tally.byPattern.begin(), tally.byPattern.end());
+  std::ranges::stable_sort(patterns, std::greater{}, [](const auto& entry) { return entry.second[0]; });
+  std::uint64_t total = 0U;
+  for (const auto& [pattern, counts] : patterns) {
+    total += counts[0];
+  }
+  std::string line = std::format("  {:>6}: {} tracks short of a layer, by layers (fake %):", name, total);
+  std::array<std::uint64_t, 2> rest{};
+  for (const auto& [pattern, counts] : patterns) {
+    if (200U * counts[0] < total) {
+      rest[0] += counts[0];
+      rest[1] += counts[1];
+      continue;
+    }
+    std::string layers;
+    for (std::uint64_t bits = pattern; bits != 0U; bits &= bits - 1U) {
+      const auto layer = std::countr_zero(bits);
+      layers += layer < 10 ? std::format("{}", layer) : std::format("[{}]", layer);
+    }
+    line += std::format(" {}: {} ({:.1f})", layers, counts[0], percent(counts[1], counts[0]));
+  }
+  if (rest[0] != 0U) {
+    line += std::format(" other: {} ({:.1f})", rest[0], percent(rest[1], rest[0]));
+  }
+  return line;
+}
+
+std::size_t ptBin(float pt)
+{
+  const auto bin = static_cast<std::size_t>(std::ranges::upper_bound(kScorePtEdges, static_cast<double>(pt)) - kScorePtEdges.begin());
+  return bin == 0U ? 0U : std::min(bin - 1U, kScorePtBins - 1U);
+}
+
+using EtaEdges = std::array<double, kScoreEtaBins + 1U>;
+
+std::size_t etaBin(float eta, const EtaEdges& edges)
+{
+  const auto bin = static_cast<std::size_t>(std::ranges::upper_bound(edges, static_cast<double>(eta)) - edges.begin());
+  return std::clamp<std::size_t>(bin, 1U, kScoreEtaBins) - 1U;
+}
+
+/// In double, unlike `wrapPhi` (TrackingQA.h).
+std::size_t phiBin(float phi)
+{
+  constexpr double kTwoPi = 2. * std::numbers::pi;
+  const double wrapped = std::fmod(std::fmod(static_cast<double>(phi), kTwoPi) + kTwoPi, kTwoPi);
+  return std::min(static_cast<std::size_t>(wrapped / kTwoPi * static_cast<double>(kScorePhiBins)), kScorePhiBins - 1U);
+}
+
+/// Efficiency, fake-only and clone rates of one tracker for one findable class.
+FindableScore rates(const std::unordered_map<std::uint64_t, Particle>& particles, const Tally& tally, const EtaEdges& etaEdges, auto findable)
+{
+  FindableScore result;
+  for (const auto& [id, particle] : particles) {
+    if (!findable(particle)) {
+      continue;
+    }
+    const auto bin = ptBin(particle.pt);
+    const auto eta = etaBin(particle.eta, etaEdges);
+    const auto phi = phiBin(particle.phi);
+    ++result.findable;
+    ++result.findableByPt[bin];
+    ++result.findableByEta[eta];
+    ++result.findableByPhi[phi];
+    auto& species = result.bySpecies[particle.species];
+    ++species[0];
+    const auto good = tally.good.find(id);
+    const std::uint32_t count = good == tally.good.end() ? 0U : good->second;
+    result.withFake += tally.fakeLabel.contains(id) ? 1U : 0U;
+    if (count != 0U) {
+      ++result.found;
+      ++result.foundByPt[bin];
+      ++result.foundByEta[eta];
+      ++result.foundByPhi[phi];
+      ++species[1];
+      result.cloned += count > 1U ? 1U : 0U;
+      result.cloneTracks += count - 1U;
+      const auto layers = tally.goodLayers.find(id);
+      const std::uint64_t covered = layers == tally.goodLayers.end() ? 0U : (layers->second & particle.layers);
+      result.layersFound += static_cast<std::uint64_t>(std::popcount(covered));
+      result.layersOf += static_cast<std::uint64_t>(std::popcount(particle.layers));
+      const double fraction = static_cast<double>(std::popcount(covered)) / static_cast<double>(std::popcount(particle.layers));
+      result.layerFraction += fraction;
+      result.layerFractionByPt[bin] += fraction;
+      if (covered == particle.layers) {
+        ++result.complete;
+        ++result.completeByPt[bin];
+      }
+    } else if (tally.fakeLabel.contains(id)) {
+      ++result.fakeOnly;
+    }
+  }
+  return result;
+}
+
+std::string describe(const std::string& name, const FindableScore& r)
+{
+  std::string line = std::format("  {:>6}: {:6.2f} % found ({:.2f} % complete, {:.1f} % of their layers), {:5.2f} % only with a fake, {:5.2f} % cloned; by pT, found (complete):", name, percent(r.found, r.findable), percent(r.complete, r.findable), percent(r.layersFound, r.layersOf), percent(r.fakeOnly, r.findable), percent(r.cloned, r.findable));
+  for (std::size_t bin = 0; bin < kScorePtBins; ++bin) {
+    line += std::format(" [{:g},{:g}) {:.1f} ({:.1f})", kScorePtEdges[bin], kScorePtEdges[bin + 1U], percent(r.foundByPt[bin], r.findableByPt[bin]), percent(r.completeByPt[bin], r.findableByPt[bin]));
+  }
+  return line;
+}
+
+/// Found by eta and by phi, one line.
+std::string describeAngles(const std::string& name, const FindableScore& r, const EtaEdges& etaEdges)
+{
+  std::string line = std::format("  {:>6} by eta:", name);
+  for (std::size_t bin = 0; bin < kScoreEtaBins; ++bin) {
+    line += std::format(" [{:.3g},{:.3g}) {:.1f}", etaEdges[bin], etaEdges[bin + 1U], percent(r.foundByEta[bin], r.findableByEta[bin]));
+  }
+  line += "; by phi, octants from 0:";
+  for (std::size_t bin = 0; bin < kScorePhiBins; ++bin) {
+    line += std::format(" {:.1f}", percent(r.foundByPhi[bin], r.findableByPhi[bin]));
+  }
+  return line;
+}
+
+/// Every particle the rows carry, with the layers it has measurements on
+/// and its longest chain.
+std::unordered_map<std::uint64_t, Particle> particlesOf(std::span<const TruthRow> rows, const ParticleTable& truth, const ComparisonSettings& settings)
+{
+  std::unordered_map<std::uint64_t, Particle> particles;
+  for (const auto& row : rows) {
+    for (std::uint8_t i = 0; i < row.count; ++i) {
+      const auto found = truth.find(row.particles[i]);
+      if (found == truth.end()) {
+        continue;
+      }
+      auto& particle = particles[row.particles[i]];
+      particle.pt = found->second.pt;
+      particle.primary = found->second.primary;
+      particle.eta = found->second.eta;
+      particle.phi = found->second.phi;
+      particle.origin = found->second.origin;
+      particle.species = std::abs(found->second.pdg);
+      particle.family = decayFamily(found->second.motherPdg);
+      particle.production = productionBin(found->second, settings);
+      particle.layers |= std::uint64_t{1} << row.layer;
+      if (i == 0U && row.firstLabelCounts) {
+        particle.firstLayers |= std::uint64_t{1} << row.layer;
+      }
+    }
+  }
+  for (const auto& [id, layers] : particleLayers(rows, settings)) {
+    const auto particle = particles.find(id);
+    if (particle != particles.end()) {
+      particle->second.chain = layers;
+    }
+  }
+  return particles;
+}
+
+/// The findable classes.
+bool onAllLayers(const Particle& p, const ComparisonSettings& settings) { return p.primary && static_cast<double>(p.pt) >= settings.minPtGeV && onEveryLayer(p.layers, settings); }
+
+bool onMinLayers(const Particle& p, const ComparisonSettings& settings) { return p.primary && static_cast<double>(p.pt) >= settings.minPtGeV && std::popcount(p.layers) >= settings.minLayers; }
+
+/// O2's own QA definition (CheckTracksCA.C): first labels on every layer, a
+/// primary, any pT; found with a good track, its further good tracks clones.
+bool o2Findable(const Particle& p, const ComparisonSettings& settings)
+{
+  const std::uint64_t everyLayer = settings.nLayers >= 64 ? ~std::uint64_t{0} : (std::uint64_t{1} << settings.nLayers) - 1U;
+  return p.primary && p.firstLayers == everyLayer;
+}
+
+/// The decay daughters by family and production bin.
+std::array<std::vector<DecayCounts>, kDecayFamilies> decayCounts(const std::unordered_map<std::uint64_t, Particle>& particles, const Tally& tally, const ComparisonSettings& settings)
+{
+  std::array<std::vector<DecayCounts>, kDecayFamilies> result;
+  for (auto& bins : result) {
+    bins.resize(settings.productionEdges.size() + 1U);
+  }
+  for (const auto& [id, particle] : particles) {
+    if (particle.origin != ParticleOrigin::kDecay || static_cast<double>(particle.pt) < settings.minPtGeV || std::popcount(particle.layers) < settings.minLayers) {
+      continue;
+    }
+    auto& counts = result[static_cast<std::size_t>(particle.family)][particle.production];
+    const bool found = tally.good.contains(id);
+    ++counts.onMinLayers;
+    counts.foundOnMinLayers += found ? 1U : 0U;
+    if (isFindable(particle.pt, particle.chain, settings)) {
+      ++counts.findable;
+      counts.found += found ? 1U : 0U;
+    }
+  }
+  return result;
+}
+
+/// Whether \a p is a findable physical primary with (\a onDisc) or without a
+/// measurement on a disc: a layer that is not a barrel layer.
+bool primaryInRegion(const Particle& p, bool onDisc, const ComparisonSettings& settings)
+{
+  const bool disc = (p.layers & ~settings.barrelLayers) != 0U;
+  return p.origin == ParticleOrigin::kPhysicalPrimary && disc == onDisc && isFindable(p.pt, p.chain, settings);
+}
+
+/// \a score of each origin.
+std::array<FindableScore, kParticleOrigins> byOrigin(auto score)
+{
+  std::array<FindableScore, kParticleOrigins> result;
+  for (std::size_t origin = 0; origin < kParticleOrigins; ++origin) {
+    result[origin] = score(static_cast<ParticleOrigin>(origin));
+  }
+  return result;
+}
+
+TrackScore scoreOf(const std::unordered_map<std::uint64_t, Particle>& particles, const Tally& tally, const ComparisonSettings& settings)
+{
+  return {
+    .tracks = tally.tracks,
+    .fakes = tally.fakes,
+    .tracksByLength = tally.byLength,
+    .fakesByLength = tally.fakesByLength,
+    .allLayers = rates(particles, tally, settings.etaEdges, [&](const Particle& p) { return onAllLayers(p, settings); }),
+    .minLayers = rates(particles, tally, settings.etaEdges, [&](const Particle& p) { return onMinLayers(p, settings); }),
+    .o2 = rates(particles, tally, settings.etaEdges, [&](const Particle& p) { return o2Findable(p, settings); }),
+    .originAllLayers = byOrigin([&](ParticleOrigin origin) { return rates(particles, tally, settings.etaEdges, [&](const Particle& p) { return p.origin == origin && static_cast<double>(p.pt) >= settings.minPtGeV && onEveryLayer(p.layers, settings); }); }),
+    .originMinLayers = byOrigin([&](ParticleOrigin origin) { return rates(particles, tally, settings.etaEdges, [&](const Particle& p) { return p.origin == origin && static_cast<double>(p.pt) >= settings.minPtGeV && std::popcount(p.layers) >= settings.minLayers; }); }),
+    .originFindable = byOrigin([&](ParticleOrigin origin) { return rates(particles, tally, settings.etaEdges, [&](const Particle& p) { return p.origin == origin && isFindable(p.pt, p.chain, settings); }); }),
+    .primaryRegion = {rates(particles, tally, settings.etaEdges, [&](const Particle& p) { return primaryInRegion(p, false, settings); }), rates(particles, tally, settings.etaEdges, [&](const Particle& p) { return primaryInRegion(p, true, settings); })},
+    .decays = decayCounts(particles, tally, settings),
+  };
+}
+
+/// The lines of a score, each for one tracker or for the findable they share.
+std::string describeTracks(const std::string& name, const TrackScore& score)
+{
+  std::string line = std::format("  {:>6}: {} tracks, {:.2f} % fake; by clusters (fake %):", name, score.tracks, percent(score.fakes, score.tracks));
+  for (std::size_t length = 0; length < kScoreLengthSlots; ++length) {
+    if (score.tracksByLength[length] != 0U) {
+      line += std::format(" {}: {} ({:.1f})", length, score.tracksByLength[length], percent(score.fakesByLength[length], score.tracksByLength[length]));
+    }
+  }
+  return line;
+}
+
+std::string allLayersHeader(const ComparisonSettings& settings, std::uint64_t findable)
+{
+  if (settings.allLayersMask != 0U) {
+    return std::format("  findable, primaries above {} GeV on every layer of mask {}: {}", settings.minPtGeV, settings.allLayersMask, findable);
+  }
+  return std::format("  findable, primaries above {} GeV on all {} layers: {}", settings.minPtGeV, settings.nLayers, findable);
+}
+
+std::string minLayersHeader(const ComparisonSettings& settings, std::uint64_t findable) { return std::format("  findable, primaries above {} GeV on {} layers or more: {}", settings.minPtGeV, settings.minLayers, findable); }
+
+std::string o2Header(const ComparisonSettings& settings, std::uint64_t findable) { return std::format("  O2's QA definition (CheckTracksCA.C), first labels on all {} layers, any pT: {} findable", settings.nLayers, findable); }
+
+std::string describeO2(const std::string& name, const FindableScore& r) { return std::format("  {:>6}: found {} ({:.2f} %), clone tracks {}, with a fake track {}", name, r.found, percent(r.found, r.findable), r.cloneTracks, r.withFake); }
+
+constexpr std::array<const char*, kParticleOrigins> kOriginNames{"physical primaries", "decay daughters", "material"};
+
+std::string originHeader(const ComparisonSettings& settings, const TrackScore& score)
+{
+  std::string line = std::format("  findable by origin above {} GeV, on all {} layers / on {} or more / on a chain of {}:", settings.minPtGeV, settings.nLayers, settings.minLayers, settings.minLayers);
+  for (std::size_t origin = 0; origin < kParticleOrigins; ++origin) {
+    line += std::format("{} {} {} / {} / {}", origin == 0U ? "" : ",", kOriginNames[origin], score.originAllLayers[origin].findable, score.originMinLayers[origin].findable, score.originFindable[origin].findable);
+  }
+  return line;
+}
+
+std::string describeOrigins(const std::string& name, const ComparisonSettings& settings, const TrackScore& score)
+{
+  std::string line = std::format("  {:>6} by origin, found % on all layers / {}+ / a chain of {}:", name, settings.minLayers, settings.minLayers);
+  for (std::size_t origin = 0; origin < kParticleOrigins; ++origin) {
+    const auto& all = score.originAllLayers[origin];
+    const auto& some = score.originMinLayers[origin];
+    const auto& adjacent = score.originFindable[origin];
+    line += std::format("{} {} {:.2f} / {:.2f} / {:.2f}", origin == 0U ? "" : ",", kOriginNames[origin], percent(all.found, all.findable), percent(some.found, some.findable), percent(adjacent.found, adjacent.findable));
+  }
+  return line;
+}
+
+/// One origin's particles on `minLayers` or more by species, most findable
+/// first: every species with at least 0.5 % of them, the rest summed.
+std::string describeSpecies(const std::string& name, const ComparisonSettings& settings, const TrackScore& score, std::size_t origin)
+{
+  const auto& r = score.originMinLayers[origin];
+  std::vector<std::pair<std::int32_t, std::array<std::uint64_t, 2>>> species(r.bySpecies.begin(), r.bySpecies.end());
+  std::ranges::stable_sort(species, std::greater{}, [](const auto& entry) { return entry.second[0]; });
+  std::string line = std::format("  {:>6} {} on {}+ layers by species, found % (findable):", name, kOriginNames[origin], settings.minLayers);
+  std::array<std::uint64_t, 2> rest{};
+  for (const auto& [pdg, counts] : species) {
+    if (200U * counts[0] < r.findable) {
+      rest[0] += counts[0];
+      rest[1] += counts[1];
+      continue;
+    }
+    line += std::format(" {} {:.1f} ({})", speciesName(pdg), percent(counts[1], counts[0]), counts[0]);
+  }
+  if (rest[0] != 0U) {
+    line += std::format(" other {:.1f} ({})", percent(rest[1], rest[0]), rest[0]);
+  }
+  return line;
+}
+
+constexpr std::array<const char*, kDecayFamilies> kFamilyNames{"K0S", "Lambda", "Sigma+-", "Xi, Omega", "K0L", "pi", "K", "other"};
+
+DecayCounts operator+(DecayCounts a, const DecayCounts& b)
+{
+  return {
+    .onMinLayers = a.onMinLayers + b.onMinLayers,
+    .foundOnMinLayers = a.foundOnMinLayers + b.foundOnMinLayers,
+    .findable = a.findable + b.findable,
+    .found = a.found + b.found,
+  };
+}
+
+std::string decaysHeader(const ComparisonSettings& settings)
+{
+  std::string edges = "0";
+  for (const auto edge : settings.productionEdges) {
+    edges += std::format(", {:.1f}", edge);
+  }
+  return std::format(
+    "  decay daughters above {} GeV by mother and production {} [cm] (bins from {}): found % of the findable, on a chain of {} "
+    "layers (their count / all on {}+ layers)",
+    settings.minPtGeV, settings.productionAlongZ ? "|z|" : "radius", edges, settings.minLayers, settings.minLayers);
+}
+
+/// One line of decay daughters: the total, then bin by bin.
+std::string describeDecays(const std::string& name, const std::string& family, std::span<const DecayCounts> bins)
+{
+  DecayCounts total;
+  for (const auto& bin : bins) {
+    total = total + bin;
+  }
+  std::string line = std::format("  {:>6} {:<16} {:6.2f} ({}/{}), of all {:.2f} %; by production:", name, family, percent(total.found, total.findable), total.findable, total.onMinLayers, percent(total.foundOnMinLayers, total.onMinLayers));
+  for (const auto& bin : bins) {
+    line += std::format(" {:.1f} ({}/{})", percent(bin.found, bin.findable), bin.findable, bin.onMinLayers);
+  }
+  return line;
+}
+
+/// The decay daughters' lines: the V0s and hyperons and the decays in
+/// flight summed, then each family.
+std::vector<std::string> describeDecays(const std::string& name, const TrackScore& score)
+{
+  const auto bins = score.decays[0].size();
+  std::vector<DecayCounts> hyperons(bins);
+  std::vector<DecayCounts> flight(bins);
+  for (std::size_t family = 0; family < kDecayFamilies; ++family) {
+    const auto kind = static_cast<DecayFamily>(family);
+    if (kind == DecayFamily::kOther) {
+      continue;
+    }
+    auto& group = inFlight(kind) ? flight : hyperons;
+    for (std::size_t bin = 0; bin < bins; ++bin) {
+      group[bin] = group[bin] + score.decays[family][bin];
+    }
+  }
+  std::vector<std::string> lines{describeDecays(name, "V0s and hyperons", hyperons), describeDecays(name, "in flight", flight)};
+  for (std::size_t family = 0; family < kDecayFamilies; ++family) {
+    lines.push_back(describeDecays(name, kFamilyNames[family], score.decays[family]));
+  }
+  return lines;
+}
+
+} // namespace
+
+std::string speciesName(std::int32_t species)
+{
+  switch (species) {
+    case 11:
+      return "e";
+    case 13:
+      return "mu";
+    case 211:
+      return "pi";
+    case 321:
+      return "K";
+    case 2212:
+      return "p";
+    case 3112:
+      return "Sigma-";
+    case 3222:
+      return "Sigma+";
+    case 3312:
+      return "Xi";
+    case 3334:
+      return "Omega";
+    case 1000010020:
+      return "d";
+    case 1000010030:
+      return "t";
+    case 1000020030:
+      return "He3";
+    case 1000020040:
+      return "alpha";
+    default:
+      return std::format("{}", species);
+  }
+}
+
+std::size_t productionBin(const ParticleTruth& particle, const ComparisonSettings& settings)
+{
+  const auto production = settings.productionAlongZ ? std::abs(static_cast<double>(particle.vz)) : std::hypot(static_cast<double>(particle.vx), static_cast<double>(particle.vy));
+  return static_cast<std::size_t>(std::ranges::upper_bound(settings.productionEdges, production) - settings.productionEdges.begin());
+}
+
+DecayFamily decayFamily(std::int32_t motherPdg)
+{
+  switch (std::abs(motherPdg)) {
+    case 310:
+      return DecayFamily::kK0S;
+    case 3122:
+      return DecayFamily::kLambda;
+    case 3112:
+    case 3222:
+      return DecayFamily::kSigma;
+    case 3312:
+    case 3322:
+    case 3334:
+      return DecayFamily::kCascade;
+    case 130:
+      return DecayFamily::kK0L;
+    case 211:
+      return DecayFamily::kPion;
+    case 321:
+      return DecayFamily::kKaon;
+    default:
+      return DecayFamily::kOther;
+  }
+}
+
+std::unordered_map<std::uint64_t, std::vector<std::uint32_t>> rowsOfParticles(std::span<const TruthRow> rows)
+{
+  std::unordered_map<std::uint64_t, std::vector<std::uint32_t>> rowsOf;
+  for (std::uint32_t row = 0; row < rows.size(); ++row) {
+    for (std::uint8_t i = 0; i < rows[row].count; ++i) {
+      rowsOf[rows[row].particles[i]].push_back(row);
+    }
+  }
+  return rowsOf;
+}
+
+std::unordered_map<std::uint64_t, ParticleLayers> particleLayers(std::span<const TruthRow> rows, const ComparisonSettings& settings)
+{
+  const auto rowsOf = rowsOfParticles(rows);
+  std::unordered_map<std::uint64_t, ParticleLayers> result;
+  result.reserve(rowsOf.size());
+  std::array<std::uint32_t, std::numeric_limits<std::uint64_t>::digits> depth{};
+  // A step joins one of the particle's measurements on each of its layers
+  // without crossing another layer.
+  const auto direct = [&](std::span<const std::uint32_t> own, const ChainLink& link) {
+    for (const auto a : own) {
+      for (const auto b : own) {
+        const auto& from = rows[a];
+        const auto& to = rows[b];
+        if (from.layer == link.from && to.layer == link.to && !segmentLeavesHole(link.holes, settings.barrelLayers, settings.layerSpans.data(), from.r, from.z, to.r, to.z)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+  for (const auto& [id, own] : rowsOf) {
+    ParticleLayers particle;
+    depth.fill(0U);
+    for (const auto row : own) {
+      particle.layers |= std::uint64_t{1} << rows[row].layer;
+      depth[rows[row].layer] = 1U;
+    }
+    // Links in topological order: a link's `from` is complete when it comes.
+    for (const auto& link : settings.chainLinks) {
+      if (depth[link.from] != 0U && depth[link.to] != 0U && depth[link.from] + 1U > depth[link.to] && direct(own, link)) {
+        depth[link.to] = depth[link.from] + 1U;
+      }
+    }
+    particle.chain = *std::ranges::max_element(depth);
+    result.emplace(id, particle);
+  }
+  return result;
+}
+
+TrackScore scoreTracks(std::span<const TruthRow> rows, const ParticleTable& truth, const TrackRows& tracks, const ComparisonSettings& settings)
+{
+  const auto particles = particlesOf(rows, truth, settings);
+  return scoreOf(particles, tally(rows, tracks, particles, settings.nLayers), settings);
+}
+
+std::vector<std::string> describeScore(const TrackScore& score, const ComparisonSettings& settings, const std::string& name)
+{
+  std::vector<std::string> lines{describeTracks(name, score), allLayersHeader(settings, score.allLayers.findable), describe(name, score.allLayers), describeAngles(name, score.allLayers, settings.etaEdges), minLayersHeader(settings, score.minLayers.findable), describe(name, score.minLayers), o2Header(settings, score.o2.findable), describeO2(name, score.o2), originHeader(settings, score), describeOrigins(name, settings, score), describe(name + " primaries", score.originFindable[0]), describeSpecies(name, settings, score, 0U), describeSpecies(name, settings, score, 1U), describeSpecies(name, settings, score, 2U), decaysHeader(settings)};
+  std::ranges::move(describeDecays(name, score), std::back_inserter(lines));
+  return lines;
+}
+
+std::vector<std::string> compareTrackSets(std::span<const TruthRow> rows, const ParticleTable& truth, const TrackRows& ours, const TrackRows& theirs, const ComparisonSettings& settings, const std::string& ourName, const std::string& theirName)
+{
+  const auto particles = particlesOf(rows, truth, settings);
+  std::vector<std::string> report;
+  const auto ourTally = tally(rows, ours, particles, settings.nLayers);
+  const auto theirTally = tally(rows, theirs, particles, settings.nLayers);
+  const auto ourScore = scoreOf(particles, ourTally, settings);
+  const auto theirScore = scoreOf(particles, theirTally, settings);
+  report.push_back(std::format("comparison with {}: one set of truth rules for both", theirName));
+  report.push_back(describeTracks(ourName, ourScore));
+  report.push_back(describeTracks(theirName, theirScore));
+  report.push_back(describePatterns(ourName, ourTally));
+  report.push_back(describePatterns(theirName, theirTally));
+  report.push_back(allLayersHeader(settings, ourScore.allLayers.findable));
+  report.push_back(describe(ourName, ourScore.allLayers));
+  report.push_back(describe(theirName, theirScore.allLayers));
+  report.push_back(describeAngles(ourName, ourScore.allLayers, settings.etaEdges));
+  report.push_back(describeAngles(theirName, theirScore.allLayers, settings.etaEdges));
+  report.push_back(minLayersHeader(settings, ourScore.minLayers.findable));
+  report.push_back(describe(ourName, ourScore.minLayers));
+  report.push_back(describe(theirName, theirScore.minLayers));
+  report.push_back(o2Header(settings, ourScore.o2.findable));
+  report.push_back(describeO2(ourName, ourScore.o2));
+  report.push_back(describeO2(theirName, theirScore.o2));
+  report.push_back(originHeader(settings, ourScore));
+  report.push_back(describeOrigins(ourName, settings, ourScore));
+  report.push_back(describeOrigins(theirName, settings, theirScore));
+  report.push_back(describe(ourName + " primaries", ourScore.originFindable[0]));
+  report.push_back(describe(theirName + " primaries", theirScore.originFindable[0]));
+  for (std::size_t origin = 0; origin < kParticleOrigins; ++origin) {
+    report.push_back(describeSpecies(ourName, settings, ourScore, origin));
+    report.push_back(describeSpecies(theirName, settings, theirScore, origin));
+  }
+  report.push_back(decaysHeader(settings));
+  const auto ourDecays = describeDecays(ourName, ourScore);
+  const auto theirDecays = describeDecays(theirName, theirScore);
+  for (std::size_t line = 0; line < ourDecays.size(); ++line) {
+    report.push_back(ourDecays[line]);
+    report.push_back(theirDecays[line]);
+  }
+
+  describeFakes(report, ourName, ourTally, theirTally, settings.nLayers);
+  describeFakes(report, theirName, theirTally, ourTally, settings.nLayers);
+
+  // Track by track, by measurement sets.
+  std::unordered_map<std::uint32_t, std::vector<std::size_t>> ourTracksOfRow;
+  std::vector<std::vector<std::uint32_t>> ourSorted(ours.size());
+  for (std::size_t track = 0; track < ours.size(); ++track) {
+    ourSorted[track] = ours[track];
+    std::ranges::sort(ourSorted[track]);
+    for (const auto row : ours[track]) {
+      ourTracksOfRow[row].push_back(track);
+    }
+  }
+  enum Relation : std::uint8_t { kIdentical,
+                                 kTheirsInside,
+                                 kOursInside,
+                                 kOverlap,
+                                 kDisjoint,
+                                 kRelations };
+  std::array<std::uint64_t, kRelations> relations{};
+  std::vector<std::uint32_t> sorted;
+  std::map<std::size_t, std::size_t> shared;
+  for (const auto& track : theirs) {
+    sorted = track;
+    std::ranges::sort(sorted);
+    shared.clear();
+    for (const auto row : sorted) {
+      const auto found = ourTracksOfRow.find(row);
+      if (found != ourTracksOfRow.end()) {
+        for (const auto our : found->second) {
+          ++shared[our];
+        }
+      }
+    }
+    if (shared.empty()) {
+      ++relations[kDisjoint];
+      continue;
+    }
+    const auto best = std::ranges::max_element(shared, {}, [](const auto& entry) { return entry.second; });
+    const auto& our = ourSorted[best->first];
+    if (best->second == sorted.size() && our.size() == sorted.size()) {
+      ++relations[kIdentical];
+    } else if (best->second == sorted.size()) {
+      ++relations[kTheirsInside];
+    } else if (best->second == our.size()) {
+      ++relations[kOursInside];
+    } else {
+      ++relations[kOverlap];
+    }
+  }
+  report.push_back(
+    std::format("  {}'s {} tracks against ours, by clusters: identical {:.2f} %, inside one of ours {:.2f} %, containing one of ours "
+                "{:.2f} %, overlapping {:.2f} %, sharing none {:.2f} %",
+                theirName, theirs.size(), percent(relations[kIdentical], theirs.size()), percent(relations[kTheirsInside], theirs.size()), percent(relations[kOursInside], theirs.size()), percent(relations[kOverlap], theirs.size()), percent(relations[kDisjoint], theirs.size())));
+
+  std::array<std::uint64_t, 4> who{}; // both, ours only, theirs only, neither
+  for (const auto& [id, particle] : particles) {
+    if (!onAllLayers(particle, settings)) {
+      continue;
+    }
+    const bool mine = ourTally.good.contains(id);
+    const bool other = theirTally.good.contains(id);
+    std::size_t slot = 3U;
+    if (mine && other) {
+      slot = 0U;
+    } else if (mine) {
+      slot = 1U;
+    } else if (other) {
+      slot = 2U;
+    }
+    ++who[slot];
+  }
+  report.push_back(std::format("  the all-layer findable: found by both {}, by {} only {}, by {} only {}, by neither {}", who[0], ourName, who[1], theirName, who[2], who[3]));
+  return report;
+}
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/src/TrackPulls.cxx b/Detectors/GenericTracking/study/src/TrackPulls.cxx
new file mode 100644
index 0000000000000..a8f11d7587add
--- /dev/null
+++ b/Detectors/GenericTracking/study/src/TrackPulls.cxx
@@ -0,0 +1,98 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Study/TrackPulls.h"
+#include "GenericTracking/Study/Statistics.h"
+
+#include <algorithm>
+#include <cmath>
+#include <format>
+#include <span>
+#include <utility>
+
+namespace o2::gtrk::study
+{
+
+namespace
+{
+
+/// 1.4826 times the median absolute deviation: a Gaussian's sigma, blind to
+/// a tail. Reorders \a values.
+double robustSigma(std::span<double> values)
+{
+  const double centre = median(values);
+  std::vector<double> deviations;
+  deviations.reserve(values.size());
+  for (const double value : values) {
+    deviations.push_back(std::abs(value - centre));
+  }
+  return 1.4826 * median(deviations);
+}
+
+/// Their copies: the medians reorder them.
+std::string summary(std::vector<double> residuals, std::vector<double> pulls, double scale)
+{
+  if (residuals.empty()) {
+    return "     --";
+  }
+  std::string text = std::format("{:7} residual median {:8.2f} sigma {:8.2f}", residuals.size(), scale * median(residuals), scale * robustSigma(residuals));
+  if (!pulls.empty()) {
+    const auto tail = std::ranges::count_if(pulls, [](double pull) { return std::abs(pull) > 5.; });
+    text += std::format("; pull median {:6.3f} sigma {:6.3f} beyond 5 {:5.2f} %", median(pulls), robustSigma(pulls), percent(static_cast<std::uint64_t>(tail), pulls.size()));
+  }
+  return text;
+}
+
+} // namespace
+
+PullTable::PullTable(std::string name, std::vector<PullParameter> parameters)
+  : mName(std::move(name)),
+    mParameters(std::move(parameters)),
+    mSamples(mParameters.size())
+{
+}
+
+void PullTable::add(double pt, std::span<const double> residuals, std::span<const double> sigmas)
+{
+  if (pt < kPtEdges.front() || residuals.size() != mParameters.size() || sigmas.size() != mParameters.size()) {
+    return;
+  }
+  const auto bin = std::min<std::size_t>(static_cast<std::size_t>(std::ranges::upper_bound(kPtEdges, pt) - kPtEdges.begin()) - 1U, kPtBins - 1U);
+  ++mTracks;
+  for (std::size_t parameter = 0; parameter < mParameters.size(); ++parameter) {
+    auto& samples = mSamples[parameter][bin];
+    samples.residuals.push_back(residuals[parameter]);
+    if (sigmas[parameter] > 0.) {
+      samples.pulls.push_back(residuals[parameter] / sigmas[parameter]);
+    }
+  }
+}
+
+std::vector<std::string> PullTable::report() const
+{
+  std::vector<std::string> lines;
+  lines.push_back(std::format("  {}: {} good tracks", mName, mTracks));
+  for (std::size_t parameter = 0; parameter < mParameters.size(); ++parameter) {
+    const auto& p = mParameters[parameter];
+    std::vector<double> allResiduals;
+    std::vector<double> allPulls;
+    for (std::size_t bin = 0; bin < kPtBins; ++bin) {
+      const auto& samples = mSamples[parameter][bin];
+      allResiduals.insert(allResiduals.end(), samples.residuals.begin(), samples.residuals.end());
+      allPulls.insert(allPulls.end(), samples.pulls.begin(), samples.pulls.end());
+      lines.push_back(std::format("    {:>8} [{}] pT [{:g}, {:g}): {}", p.name, p.unit, kPtEdges[bin], kPtEdges[bin + 1U], summary(samples.residuals, samples.pulls, p.scale)));
+    }
+    lines.push_back(std::format("    {:>8} [{}] all pT:      {}", p.name, p.unit, summary(allResiduals, allPulls, p.scale)));
+  }
+  return lines;
+}
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/src/TrackingInput.cxx b/Detectors/GenericTracking/study/src/TrackingInput.cxx
new file mode 100644
index 0000000000000..10410996e5c58
--- /dev/null
+++ b/Detectors/GenericTracking/study/src/TrackingInput.cxx
@@ -0,0 +1,444 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Study/TrackingInput.h"
+
+#include "GenericTracking/Study/Digest.h"
+#include "GenericTracking/Workflow/RecoParam.h"
+
+#include "CommonUtils/ConfigurableParam.h"
+
+#include <TClass.h>
+#include <TDataMember.h>
+#include <TDataType.h>
+#include <TList.h>
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstring>
+#include <format>
+#include <fstream>
+#include <map>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+namespace
+{
+
+constexpr std::array<char, 8> kMagic{'G', 'T', 'R', 'K', 'T', 'I', 'N', '1'};
+
+/// Bumped whenever the layout below or a column's type changes.
+constexpr std::uint32_t kVersion = 9U;
+
+/// The header: the blocks' element counts and the beam line the rows were
+/// placed about. The blocks follow: the readout frames, every measurement
+/// column in schema order, the grid offsets, the vertices, the measurement
+/// depths.
+struct Header {
+  std::array<char, 8> magic = kMagic;
+  std::uint32_t version = kVersion;
+  std::uint32_t columns = kNMeasurementColumns;
+  std::uint64_t rowBytes = kMeasurementRowBytes;
+  std::uint64_t rows = 0U;
+  std::uint64_t offsets = 0U;
+  std::uint64_t vertices = 0U;
+  std::uint64_t frameLayers = 0U;
+  std::uint64_t depthLayers = 0U;
+  double beamX = 0.;
+  double beamY = 0.;
+  double beamZ = 0.;
+  double beamSigmaX = 0.;
+  double beamSigmaY = 0.;
+  double beamSigmaZ = 0.;
+};
+static_assert(std::is_trivially_copyable_v<Header> && sizeof(Header) == 112U, "the header has no padding");
+static_assert(std::is_trivially_copyable_v<VertexSeed> && std::is_trivially_copyable_v<FrameTiming>);
+
+constexpr std::array<char, 8> kTruthMagic{'G', 'T', 'R', 'K', 'T', 'R', 'U', '1'};
+
+/// Bumped whenever the truth's layout below or a field's type changes.
+constexpr std::uint32_t kTruthVersion = 2U;
+
+/// The truth's header; then the rows' cluster indices, particles
+/// (`TruthRow::kMaxParticles` per row), counts, layers and first-label flags,
+/// then the particles' identities, pT, primary flags, eta, phi, origins, PDG
+/// codes, mothers' PDG codes, production processes and vertices, by identity.
+struct TruthHeader {
+  std::array<char, 8> magic = kTruthMagic;
+  std::uint32_t version = kTruthVersion;
+  std::uint32_t maxParticles = TruthRow::kMaxParticles;
+  std::uint64_t rows = 0U;
+  std::uint64_t particles = 0U;
+};
+static_assert(std::has_unique_object_representations_v<TruthHeader>);
+
+/// A stream's view of an object's bytes.
+[[nodiscard]] const char* bytesOf(const void* data) { return static_cast<const char*>(data); }
+[[nodiscard]] char* bytesOf(void* data) { return static_cast<char*>(data); }
+
+template <typename T>
+std::uint64_t digestOf(const T* data, std::size_t count)
+{
+  Digest digest;
+  if constexpr (std::is_same_v<T, VertexSeed>) {
+    for (std::size_t index = 0; index < count; ++index) {
+      digest.add(data[index]);
+    }
+  } else {
+    digest.column(data, count);
+  }
+  return digest.result();
+}
+
+template <typename T>
+void writeBlock(std::ofstream& out, const T* data, std::size_t count)
+{
+  const std::uint64_t elements = count;
+  const std::uint64_t digest = digestOf(data, count);
+  out.write(bytesOf(&elements), sizeof(elements));
+  out.write(bytesOf(&digest), sizeof(digest));
+  if (count != 0U) {
+    out.write(bytesOf(data), static_cast<std::streamsize>(count * sizeof(T)));
+  }
+}
+
+template <typename T>
+void readBlock(std::ifstream& in, T* data, std::size_t count, const char* what)
+{
+  std::uint64_t elements = 0U;
+  std::uint64_t digest = 0U;
+  in.read(bytesOf(&elements), sizeof(elements));
+  in.read(bytesOf(&digest), sizeof(digest));
+  if (!in || elements != count) {
+    throw std::runtime_error(std::string{"tracking input: bad block header for "} + what);
+  }
+  if (count != 0U) {
+    in.read(bytesOf(data), static_cast<std::streamsize>(count * sizeof(T)));
+  }
+  if (!in || digestOf(data, count) != digest) {
+    throw std::runtime_error(std::string{"tracking input: short or corrupt "} + what);
+  }
+}
+
+} // namespace
+
+void writeTrackingInput(const std::string& path, const MeasurementView& view, std::size_t rows, std::span<const std::uint32_t> offsets, std::span<const VertexSeed> vertices, const workflow::BeamLine& beamLine, std::span<const FrameTiming> frames, std::span<const double> depths)
+{
+  std::ofstream out{path, std::ios::binary | std::ios::trunc};
+  if (!out) {
+    throw std::runtime_error("tracking input: cannot create " + path);
+  }
+  const Header header{
+    .rows = rows,
+    .offsets = offsets.size(),
+    .vertices = vertices.size(),
+    .frameLayers = frames.size(),
+    .depthLayers = depths.size(),
+    .beamX = beamLine.x,
+    .beamY = beamLine.y,
+    .beamZ = beamLine.z,
+    .beamSigmaX = beamLine.sigmaX,
+    .beamSigmaY = beamLine.sigmaY,
+    .beamSigmaZ = beamLine.sigmaZ,
+  };
+  out.write(bytesOf(&header), sizeof(header));
+  writeBlock(out, frames.data(), frames.size());
+  view.apply([&](const auto*... columns) { (writeBlock(out, columns, rows), ...); });
+  writeBlock(out, offsets.data(), offsets.size());
+  writeBlock(out, vertices.data(), vertices.size());
+  writeBlock(out, depths.data(), depths.size());
+  out.close();
+  if (!out) {
+    throw std::runtime_error("tracking input: cannot write " + path);
+  }
+}
+
+void writeParameters(const std::string& path)
+{
+  o2::conf::ConfigurableParam::writeINI(path);
+
+  // Each floating-point member of every detector's RecoSettings, by its
+  // parameter's section, named as ConfigurableParam names it, in the shortest
+  // form that reads back to the same bits.
+  std::map<std::string, std::map<std::string, std::string>> exact;
+  const auto add = [&exact](const std::string& section, const RecoSettings& param) {
+    auto& values = exact[section];
+    auto* members = TClass::GetClass(typeid(RecoSettings))->GetListOfDataMembers();
+    for (int i = 0; i < members->GetEntries(); ++i) {
+      const auto* member = dynamic_cast<const TDataMember*>(members->At(i));
+      const auto* type = member == nullptr ? nullptr : member->GetDataType();
+      if (type == nullptr || (member->Property() & kIsStatic) != 0 || (type->GetType() != kDouble_t && type->GetType() != kFloat_t)) {
+        continue;
+      }
+      if (member->GetArrayDim() > 1) {
+        throw std::runtime_error(std::format("parameters: {}.{} has more than one dimension", section, member->GetName()));
+      }
+      const int size = member->GetArrayDim() == 1 ? member->GetMaxIndex(0) : 1;
+      const auto bytes = std::span{bytesOf(&param), sizeof(param)}.subspan(static_cast<std::size_t>(member->GetOffset()));
+      const auto value = [&]<typename T>(T, int index) {
+        T number;
+        std::memcpy(&number, bytes.subspan(static_cast<std::size_t>(index) * sizeof(T), sizeof(T)).data(), sizeof(T));
+        return std::format("{}", number);
+      };
+      for (int index = 0; index < size; ++index) {
+        const auto name = size > 1 ? std::format("{}[{}]", member->GetName(), index) : std::string{member->GetName()};
+        values[name] = type->GetType() == kDouble_t ? value(0., index) : value(0.F, index);
+      }
+    }
+  };
+  const auto& its = RecoParam<o2::detectors::DetID::ITS>::Instance();
+  const auto& mft = RecoParam<o2::detectors::DetID::MFT>::Instance();
+  const auto& trk = RecoParam<o2::detectors::DetID::TRK>::Instance();
+  add(its.getName(), its);
+  add(mft.getName(), mft);
+  add(trk.getName(), trk);
+
+  std::vector<std::string> lines;
+  {
+    std::ifstream in{path};
+    if (!in) {
+      throw std::runtime_error("parameters: cannot read " + path);
+    }
+    const std::map<std::string, std::string>* section = nullptr;
+    for (std::string line; std::getline(in, line);) {
+      if (!line.empty() && line.front() == '[') {
+        const auto found = exact.find(line.substr(1, line.size() - 2));
+        section = found == exact.end() ? nullptr : &found->second;
+      } else if (const auto equals = line.find('='); section != nullptr && equals != std::string::npos) {
+        if (const auto value = section->find(line.substr(0, equals)); value != section->end()) {
+          line = line.substr(0, equals + 1) + value->second;
+        }
+      }
+      lines.push_back(std::move(line));
+    }
+  }
+  std::ofstream out{path, std::ios::trunc};
+  for (const auto& line : lines) {
+    out << line << '\n';
+  }
+  if (!out) {
+    throw std::runtime_error("parameters: cannot write " + path);
+  }
+}
+
+TrackingInput readTrackingInput(const std::string& path)
+{
+  std::ifstream in{path, std::ios::binary};
+  if (!in) {
+    throw std::runtime_error("tracking input: cannot open " + path);
+  }
+  Header header;
+  in.read(bytesOf(&header), sizeof(header));
+  if (!in || header.magic != kMagic) {
+    throw std::runtime_error("tracking input: " + path + " is not a tracking input");
+  }
+  if (header.version != kVersion || header.columns != kNMeasurementColumns || header.rowBytes != kMeasurementRowBytes) {
+    throw std::runtime_error("tracking input: " + path + " was written with another layout; dump it again");
+  }
+  TrackingInput input;
+  input.beamLine = {.x = header.beamX, .y = header.beamY, .z = header.beamZ, .sigmaX = header.beamSigmaX, .sigmaY = header.beamSigmaY, .sigmaZ = header.beamSigmaZ};
+  input.frames.resize(header.frameLayers);
+  readBlock(in, input.frames.data(), input.frames.size(), "the readout frames");
+  resizeMeasurementColumns(input.columns, header.rows);
+  input.columns.apply([&](auto&... columns) { (readBlock(in, columns.data(), header.rows, "a measurement column"), ...); });
+  input.offsets.resize(header.offsets);
+  readBlock(in, input.offsets.data(), input.offsets.size(), "the grid offsets");
+  input.vertices.resize(header.vertices);
+  readBlock(in, input.vertices.data(), input.vertices.size(), "the vertices");
+  input.depths.resize(header.depthLayers);
+  readBlock(in, input.depths.data(), input.depths.size(), "the measurement depths");
+  return input;
+}
+
+void writeTrackingTruth(const std::string& path, std::span<const std::uint32_t> clusterIndex, std::span<const TruthRow> rows, const ParticleTable& particles)
+{
+  if (clusterIndex.size() != rows.size()) {
+    throw std::runtime_error(std::format("tracking truth: {} rows for {} cluster indices", rows.size(), clusterIndex.size()));
+  }
+  // Field by field: a TruthRow has padding, which neither the file nor its
+  // digest may hold.
+  std::vector<std::uint64_t> rowParticles;
+  std::vector<std::uint8_t> counts;
+  std::vector<LayerID> layers;
+  std::vector<std::uint8_t> firstLabelCounts;
+  rowParticles.reserve(rows.size() * TruthRow::kMaxParticles);
+  counts.reserve(rows.size());
+  layers.reserve(rows.size());
+  firstLabelCounts.reserve(rows.size());
+  for (const auto& row : rows) {
+    rowParticles.insert(rowParticles.end(), row.particles.begin(), row.particles.end());
+    counts.push_back(row.count);
+    layers.push_back(row.layer);
+    firstLabelCounts.push_back(row.firstLabelCounts ? 1U : 0U);
+  }
+  // By identity, so that the same truth gives the same file.
+  std::vector<std::uint64_t> ids;
+  ids.reserve(particles.size());
+  for (const auto& [id, particle] : particles) {
+    ids.push_back(id);
+  }
+  std::ranges::sort(ids);
+  std::vector<float> pt;
+  std::vector<std::uint8_t> primary;
+  std::vector<float> eta;
+  std::vector<float> phi;
+  std::vector<std::uint8_t> origin;
+  std::vector<std::int32_t> pdg;
+  std::vector<std::int32_t> motherPdg;
+  std::vector<std::uint8_t> process;
+  std::vector<float> vx;
+  std::vector<float> vy;
+  std::vector<float> vz;
+  for (const auto id : ids) {
+    const auto& particle = particles.at(id);
+    pt.push_back(particle.pt);
+    primary.push_back(particle.primary ? 1U : 0U);
+    eta.push_back(particle.eta);
+    phi.push_back(particle.phi);
+    origin.push_back(static_cast<std::uint8_t>(particle.origin));
+    pdg.push_back(particle.pdg);
+    motherPdg.push_back(particle.motherPdg);
+    process.push_back(particle.process);
+    vx.push_back(particle.vx);
+    vy.push_back(particle.vy);
+    vz.push_back(particle.vz);
+  }
+
+  std::ofstream out{path, std::ios::binary | std::ios::trunc};
+  if (!out) {
+    throw std::runtime_error("tracking truth: cannot create " + path);
+  }
+  const TruthHeader header{.rows = rows.size(), .particles = ids.size()};
+  out.write(bytesOf(&header), sizeof(header));
+  writeBlock(out, clusterIndex.data(), clusterIndex.size());
+  writeBlock(out, rowParticles.data(), rowParticles.size());
+  writeBlock(out, counts.data(), counts.size());
+  writeBlock(out, layers.data(), layers.size());
+  writeBlock(out, firstLabelCounts.data(), firstLabelCounts.size());
+  writeBlock(out, ids.data(), ids.size());
+  writeBlock(out, pt.data(), pt.size());
+  writeBlock(out, primary.data(), primary.size());
+  writeBlock(out, eta.data(), eta.size());
+  writeBlock(out, phi.data(), phi.size());
+  writeBlock(out, origin.data(), origin.size());
+  writeBlock(out, pdg.data(), pdg.size());
+  writeBlock(out, motherPdg.data(), motherPdg.size());
+  writeBlock(out, process.data(), process.size());
+  writeBlock(out, vx.data(), vx.size());
+  writeBlock(out, vy.data(), vy.size());
+  writeBlock(out, vz.data(), vz.size());
+  out.close();
+  if (!out) {
+    throw std::runtime_error("tracking truth: cannot write " + path);
+  }
+}
+
+TrackingTruth readTrackingTruth(const std::string& path, const TrackingInput& input)
+{
+  std::ifstream in{path, std::ios::binary};
+  if (!in) {
+    throw std::runtime_error("tracking truth: cannot open " + path);
+  }
+  TruthHeader header;
+  in.read(bytesOf(&header), sizeof(header));
+  if (!in || header.magic != kTruthMagic) {
+    throw std::runtime_error("tracking truth: " + path + " is not a tracking truth");
+  }
+  if (header.version != kTruthVersion || header.maxParticles != TruthRow::kMaxParticles) {
+    throw std::runtime_error("tracking truth: " + path + " was written with another layout; dump it again");
+  }
+  const auto rows = static_cast<std::size_t>(header.rows);
+  if (rows != input.columns.clusterIndex.size()) {
+    throw std::runtime_error(std::format("tracking truth: {} has {} rows, the tracking input {}", path, rows, input.columns.clusterIndex.size()));
+  }
+  std::vector<std::uint32_t> clusterIndex(rows);
+  std::vector<std::uint64_t> rowParticles(rows * TruthRow::kMaxParticles);
+  std::vector<std::uint8_t> counts(rows);
+  std::vector<LayerID> layers(rows);
+  std::vector<std::uint8_t> firstLabelCounts(rows);
+  readBlock(in, clusterIndex.data(), clusterIndex.size(), "the truth's cluster indices");
+  readBlock(in, rowParticles.data(), rowParticles.size(), "the truth's row particles");
+  readBlock(in, counts.data(), counts.size(), "the truth's particle counts");
+  readBlock(in, layers.data(), layers.size(), "the truth's layers");
+  readBlock(in, firstLabelCounts.data(), firstLabelCounts.size(), "the truth's first-label flags");
+  if (!std::ranges::equal(clusterIndex, input.columns.clusterIndex)) {
+    throw std::runtime_error("tracking truth: " + path + " is not the tracking input's: their cluster indices differ");
+  }
+
+  const auto particles = static_cast<std::size_t>(header.particles);
+  std::vector<std::uint64_t> ids(particles);
+  std::vector<float> pt(particles);
+  std::vector<std::uint8_t> primary(particles);
+  std::vector<float> eta(particles);
+  std::vector<float> phi(particles);
+  std::vector<std::uint8_t> origin(particles);
+  std::vector<std::int32_t> pdg(particles);
+  std::vector<std::int32_t> motherPdg(particles);
+  std::vector<std::uint8_t> process(particles);
+  std::vector<float> vx(particles);
+  std::vector<float> vy(particles);
+  std::vector<float> vz(particles);
+  readBlock(in, ids.data(), ids.size(), "the particles' identities");
+  readBlock(in, pt.data(), pt.size(), "the particles' pT");
+  readBlock(in, primary.data(), primary.size(), "the particles' primary flags");
+  readBlock(in, eta.data(), eta.size(), "the particles' eta");
+  readBlock(in, phi.data(), phi.size(), "the particles' phi");
+  readBlock(in, origin.data(), origin.size(), "the particles' origins");
+  readBlock(in, pdg.data(), pdg.size(), "the particles' PDG codes");
+  readBlock(in, motherPdg.data(), motherPdg.size(), "the particles' mothers' PDG codes");
+  readBlock(in, process.data(), process.size(), "the particles' production processes");
+  readBlock(in, vx.data(), vx.size(), "the particles' production x");
+  readBlock(in, vy.data(), vy.size(), "the particles' production y");
+  readBlock(in, vz.data(), vz.size(), "the particles' production z");
+  if (std::ranges::any_of(origin, [](std::uint8_t value) { return value >= kParticleOrigins; })) {
+    throw std::runtime_error("tracking truth: " + path + " has a particle of no known origin");
+  }
+
+  TrackingTruth truth;
+  truth.rows.resize(rows);
+  for (std::size_t row = 0; row < rows; ++row) {
+    auto& entry = truth.rows[row];
+    std::copy_n(rowParticles.begin() + static_cast<std::ptrdiff_t>(row * TruthRow::kMaxParticles), TruthRow::kMaxParticles, entry.particles.begin());
+    if (counts[row] > TruthRow::kMaxParticles) {
+      throw std::runtime_error("tracking truth: " + path + " has a row of more than TruthRow::kMaxParticles particles");
+    }
+    entry.count = counts[row];
+    entry.layer = layers[row];
+    entry.r = input.columns.r[row];
+    entry.z = input.columns.z[row];
+    entry.firstLabelCounts = firstLabelCounts[row] != 0U;
+  }
+  truth.particles.reserve(particles);
+  for (std::size_t index = 0; index < particles; ++index) {
+    truth.particles[ids[index]] = ParticleTruth{
+      .pt = pt[index],
+      .primary = primary[index] != 0U,
+      .eta = eta[index],
+      .phi = phi[index],
+      .origin = static_cast<ParticleOrigin>(origin[index]),
+      .pdg = pdg[index],
+      .motherPdg = motherPdg[index],
+      .process = process[index],
+      .vx = vx[index],
+      .vy = vy[index],
+      .vz = vz[index],
+    };
+  }
+  return truth;
+}
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/src/TrackingQA.cxx b/Detectors/GenericTracking/study/src/TrackingQA.cxx
new file mode 100644
index 0000000000000..1568cfb075124
--- /dev/null
+++ b/Detectors/GenericTracking/study/src/TrackingQA.cxx
@@ -0,0 +1,311 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Study/TrackingQA.h"
+
+#include "GenericTracking/Tracking/MathUtils.h"
+
+#include "CommonUtils/TreeStreamRedirector.h"
+
+#include <algorithm>
+#include <bit>
+#include <cmath>
+#include <format>
+#include <limits>
+#include <numbers>
+#include <stdexcept>
+#include <optional>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+namespace o2::gtrk::study
+{
+
+std::vector<HitCrossing> outwardLeg(std::vector<HitCrossing> crossings, const std::array<double, 3>& production)
+{
+  std::ranges::stable_sort(crossings, {}, &HitCrossing::time);
+  double last = 0.;
+  for (std::size_t i = 0; i < crossings.size(); ++i) {
+    const auto& position = crossings[i].position;
+    const double distance = std::hypot(position[0] - production[0], position[1] - production[1], position[2] - production[2]);
+    if (distance < last) {
+      crossings.resize(i);
+      break;
+    }
+    last = distance;
+  }
+  return crossings;
+}
+
+std::uint8_t outwardLayers(std::span<const HitCrossing> leg)
+{
+  std::uint64_t layers = 0U;
+  for (const auto& crossing : leg) {
+    layers |= std::uint64_t{1} << crossing.layer;
+  }
+  return static_cast<std::uint8_t>(std::popcount(layers));
+}
+
+EtaRange etaReach(std::span<const LayerEnvelope> envelopes)
+{
+  double low = std::numeric_limits<double>::infinity();
+  double high = -std::numeric_limits<double>::infinity();
+  for (const auto& envelope : envelopes) {
+    for (const double r : {envelope.rMin, envelope.rMax}) {
+      for (const double z : {envelope.zMin, envelope.zMax}) {
+        const double eta = std::asinh(z / r);
+        low = std::min(low, eta);
+        high = std::max(high, eta);
+      }
+    }
+  }
+  if (!(low < high)) {
+    throw std::invalid_argument("QA: the envelopes span no eta");
+  }
+  return {.low = std::floor(low * 2.) / 2., .high = std::ceil(high * 2.) / 2.};
+}
+
+namespace
+{
+
+/// A helix's circle: its centre, its radius, and the sense of motion, +1
+/// counter-clockwise; none for a neutral or no field.
+struct Circle {
+  double x = 0.;
+  double y = 0.;
+  double radius = 0.;
+  double sense = 0.;
+};
+
+std::optional<Circle> circleOf(const TruthHelix& helix, double bzKiloGauss)
+{
+  const double pt = std::hypot(helix.momentum[0], helix.momentum[1]);
+  const double charge = helix.charge;
+  if (exactlyEqual(charge, 0.) || exactlyEqual(bzKiloGauss, 0.) || !(pt > 0.)) {
+    return std::nullopt;
+  }
+  const double radius = curvatureRadius(pt, bzKiloGauss) / std::abs(charge);
+  // F = q v x B: with q Bz > 0 the force points to the right of the
+  // direction, (uy, -ux), and the motion is clockwise.
+  const double side = std::copysign(1., charge * bzKiloGauss);
+  const double ux = helix.momentum[0] / pt;
+  const double uy = helix.momentum[1] / pt;
+  return Circle{.x = helix.position[0] + (side * radius * uy), .y = helix.position[1] - (side * radius * ux), .radius = radius, .sense = -side};
+}
+
+/// Whether \a helix, \a bzKiloGauss and the point (\a x, \a y) are finite,
+/// and the helix has some momentum.
+bool followable(const TruthHelix& helix, double bzKiloGauss, double x, double y)
+{
+  const auto finite = [](const std::array<double, 3>& v) { return std::isfinite(v[0]) && std::isfinite(v[1]) && std::isfinite(v[2]); };
+  return finite(helix.position) && finite(helix.momentum) && std::isfinite(helix.charge) && std::isfinite(bzKiloGauss) && std::isfinite(x) && std::isfinite(y) && std::hypot(helix.momentum[0], helix.momentum[1], helix.momentum[2]) > 0.;
+}
+
+/// Whether \a helix moves transversely at all.
+bool transverse(const TruthHelix& helix) { return std::hypot(helix.momentum[0], helix.momentum[1]) > 0.; }
+
+constexpr double kNaN = std::numeric_limits<double>::quiet_NaN();
+
+} // namespace
+
+HelixImpact helixImpact(const TruthHelix& helix, double bzKiloGauss, double x, double y)
+{
+  if (!followable(helix, bzKiloGauss, x, y) || !transverse(helix)) {
+    return {.d0 = kNaN, .z = kNaN};
+  }
+  const double pt = std::hypot(helix.momentum[0], helix.momentum[1]);
+  const double cotTheta = helix.momentum[2] / pt;
+  const auto circle = circleOf(helix, bzKiloGauss);
+  if (!circle) {
+    // The straight line: the axis's side by the cross product of the
+    // direction with it, the transverse path back to the closest point.
+    const double ux = helix.momentum[0] / pt;
+    const double uy = helix.momentum[1] / pt;
+    const double dx = x - helix.position[0];
+    const double dy = y - helix.position[1];
+    const double along = (ux * dx) + (uy * dy);
+    return {.d0 = (ux * dy) - (uy * dx), .z = helix.position[2] + (along * cotTheta)};
+  }
+  const double cx = x - circle->x;
+  const double cy = y - circle->y;
+  const double distance = std::hypot(cx, cy);
+  // The closest point is on the centre's ray through the axis; the turn
+  // from it to the production point in the sense of motion, in (-pi, pi].
+  const double px = helix.position[0] - circle->x;
+  const double py = helix.position[1] - circle->y;
+  double turn = std::atan2((cx * py) - (cy * px), (cx * px) + (cy * py)) * circle->sense;
+  if (turn <= -std::numbers::pi) {
+    turn += 2. * std::numbers::pi; // the half turn's tie: the convention's +pi
+  }
+  return {.d0 = distance - circle->radius, .z = helix.position[2] - (circle->radius * turn * cotTheta)};
+}
+
+std::array<double, 3> helixDirectionAt(const TruthHelix& helix, double bzKiloGauss, double x, double y)
+{
+  if (!followable(helix, bzKiloGauss, x, y)) {
+    return {kNaN, kNaN, kNaN};
+  }
+  const double p = std::hypot(helix.momentum[0], helix.momentum[1], helix.momentum[2]);
+  const double pt = std::hypot(helix.momentum[0], helix.momentum[1]);
+  const auto circle = circleOf(helix, bzKiloGauss);
+  if (!circle) {
+    return {helix.momentum[0] / p, helix.momentum[1] / p, helix.momentum[2] / p};
+  }
+  const double rx = x - circle->x;
+  const double ry = y - circle->y;
+  const double r = std::hypot(rx, ry);
+  if (!(r > 0.)) {
+    return {kNaN, kNaN, kNaN};
+  }
+  // Counter-clockwise, the tangent is the radius turned by +90 degrees.
+  const double tx = -circle->sense * ry / r;
+  const double ty = circle->sense * rx / r;
+  return {tx * pt / p, ty * pt / p, helix.momentum[2] / p};
+}
+
+double helixMiss(const TruthHelix& helix, double bzKiloGauss, double x, double y)
+{
+  if (!followable(helix, bzKiloGauss, x, y)) {
+    return kNaN;
+  }
+  if (!transverse(helix)) {
+    return std::hypot(x - helix.position[0], y - helix.position[1]); // a line along z
+  }
+  const auto circle = circleOf(helix, bzKiloGauss);
+  if (!circle) {
+    return std::abs(helixImpact(helix, bzKiloGauss, x, y).d0);
+  }
+  return std::abs(std::hypot(x - circle->x, y - circle->y) - circle->radius);
+}
+
+TrackingQA trackingQA(std::span<const TruthRow> rows, const ParticleTable& truth, const TrackRows& tracks, std::span<const TrackKinematics> kinematics, const SeededBy& seeded, const ParticleExtrasTable& extras, const TrackRows* theirs, int iterations, const ComparisonSettings& settings)
+{
+  if (iterations < 1 || iterations > kQAMaxIterations) {
+    throw std::invalid_argument(std::format("QA: {} iterations, 1 to {} supported", iterations, kQAMaxIterations));
+  }
+  if (kinematics.size() != tracks.size()) {
+    throw std::invalid_argument(std::format("QA: {} tracks, {} kinematics", tracks.size(), kinematics.size()));
+  }
+  TrackingQA qa;
+
+  // The tracks: each one's particle, a clone after the particle's first good
+  // track in iteration and then track order.
+  std::vector<std::size_t> order(tracks.size());
+  for (std::size_t track = 0; track < order.size(); ++track) {
+    order[track] = track;
+    if (std::cmp_greater_equal(kinematics[track].iteration, iterations)) {
+      throw std::invalid_argument(std::format("QA: a track of iteration {}, {} configured", kinematics[track].iteration, iterations));
+    }
+  }
+  std::ranges::stable_sort(order, {}, [&](std::size_t track) { return kinematics[track].iteration; });
+  std::unordered_map<std::uint64_t, std::uint64_t> foundBy;
+  qa.tracks.resize(tracks.size());
+  for (const auto track : order) {
+    const auto& k = kinematics[track];
+    const auto particle = goodParticle(rows, tracks[track]);
+    auto& record = qa.tracks[track];
+    record = {
+      .pt = k.pt,
+      .eta = k.eta,
+      .phi = wrapPhi(static_cast<double>(k.phi)),
+      .iteration = k.iteration,
+      .fake = particle == kNoTrackParticle,
+      .chi2 = k.chi2,
+      .ndf = k.ndf,
+    };
+    if (!record.fake) {
+      auto& mask = foundBy[particle];
+      record.clone = mask != 0U;
+      mask |= std::uint64_t{1} << k.iteration;
+    }
+  }
+
+  // The other tracker's good particles.
+  std::unordered_set<std::uint64_t> foundByTheirs;
+  if (theirs != nullptr) {
+    for (const auto& track : *theirs) {
+      if (const auto particle = goodParticle(rows, track); particle != kNoTrackParticle) {
+        foundByTheirs.insert(particle);
+      }
+    }
+  }
+
+  // The findable, by either rule.
+  for (const auto& [id, layers] : particleLayers(rows, settings)) {
+    const auto found = truth.find(id);
+    if (found == truth.end()) {
+      continue;
+    }
+    const auto more = extras.find(id);
+    const ParticleExtras extra = more == extras.end() ? ParticleExtras{} : more->second;
+    const bool findable = isFindable(found->second.pt, layers, settings);
+    if (!findable && (static_cast<double>(found->second.pt) < settings.minPtGeV || std::cmp_less(extra.outwardLayers, settings.minOutwardLayers))) {
+      continue;
+    }
+    const auto& particle = found->second;
+    const auto entry = foundBy.find(id);
+    const auto seeds = seeded.find(id);
+    qa.particles.push_back({
+      .pt = particle.pt,
+      .eta = particle.eta,
+      .phi = wrapPhi(static_cast<double>(particle.phi)),
+      .origin = static_cast<std::uint8_t>(particle.origin),
+      .foundBy = entry == foundBy.end() ? 0U : entry->second,
+      .seededBy = seeds == seeded.end() ? 0U : seeds->second,
+      .pdg = particle.pdg,
+      .motherPdg = particle.motherPdg,
+      .vz = particle.vz,
+      .layers = layers.layers,
+      .foundByO2 = foundByTheirs.contains(id),
+      .findable = findable,
+      .extras = extra,
+    });
+  }
+  return qa;
+}
+
+void stream(o2::utils::TreeStreamRedirector& output, const TrackingQA& qa)
+{
+  for (const auto& p : qa.particles) {
+    const auto& e = p.extras;
+    output << "particles" << "pt=" << p.pt << "eta=" << p.eta << "phi=" << p.phi << "origin=" << p.origin << "foundBy=" << p.foundBy << "seededBy=" << p.seededBy << "pdg=" << p.pdg << "motherPdg=" << p.motherPdg << "vr=" << e.vr << "vz=" << p.vz << "d0=" << e.d0 << "z0=" << e.z0 << "openingAngle=" << e.openingAngle << "motherMiss=" << e.motherMiss << "layers=" << p.layers << "lostAt=" << e.lostAt << "pairLoss=" << e.pairLoss << "roadLoss=" << e.roadLoss << "fitLoss=" << e.fitLoss << "fitRoadLayers=" << e.fitRoadLayers << "roadLosses=" << e.roadLosses << "fitLosses=" << e.fitLosses << "raisedFit=" << e.raisedFit << "foundByO2=" << p.foundByO2 << "findable=" << p.findable << "outwardLayers=" << e.outwardLayers << "\n";
+  }
+  for (const auto& t : qa.tracks) {
+    output << "tracks" << "pt=" << t.pt << "eta=" << t.eta << "phi=" << t.phi << "iteration=" << t.iteration << "fake=" << t.fake << "clone=" << t.clone << "chi2=" << t.chi2 << "ndf=" << t.ndf << "\n";
+  }
+}
+
+void streamResolution(o2::utils::TreeStreamRedirector& output, std::span<const QAResolution> entries)
+{
+  for (const auto& r : entries) {
+    output << "resolution" << "pt=" << r.pt << "eta=" << r.eta << "phi=" << r.phi << "charge=" << r.charge << "pdg=" << r.pdg << "origin=" << r.origin << "iteration=" << r.iteration << "kinks=" << r.kinks << "clusters=" << r.clusters << "layer=" << r.layer << "dLoc0=" << r.residual[0] << "dLoc1=" << r.residual[1] << "dPhi=" << r.residual[2] << "dTheta=" << r.residual[3] << "dQOverP=" << r.residual[4] << "sLoc0=" << r.sigma[0] << "sLoc1=" << r.sigma[1] << "sPhi=" << r.sigma[2] << "sTheta=" << r.sigma[3] << "sQOverP=" << r.sigma[4] << "fitPt=" << r.fitPt << "dPtRel=" << r.ptResidual << "sPt=" << r.ptSigma << "dD0=" << r.dca[0] << "dZ0=" << r.dca[1] << "sD0=" << r.dcaSigma[0] << "sZ0=" << r.dcaSigma[1] << "scatD0=" << r.dcaScattering[0] << "scatZ0=" << r.dcaScattering[1] << "productionOffset=" << r.productionOffset << "\n";
+  }
+}
+
+void streamOracle(o2::utils::TreeStreamRedirector& output, std::span<const QAOracle> entries)
+{
+  for (const auto& o : entries) {
+    output << "oracle" << "pdg=" << o.pdg << "charge=" << o.charge << "origin=" << o.origin << "eta=" << o.eta << "layer=" << o.layer << "kinks=" << o.kinks << "clusters=" << o.clusters << "productionOffset=" << o.productionOffset << "p=" << o.momentum << "pOuter=" << o.pOuter << "variant=" << o.variant << "status=" << o.status << "chi2=" << o.chi2 << "ndf=" << o.ndf << "dLoc0=" << o.residual[0] << "dLoc1=" << o.residual[1] << "dPhi=" << o.residual[2] << "dTheta=" << o.residual[3] << "dQOverP=" << o.residual[4] << "sLoc0=" << o.sigma[0] << "sLoc1=" << o.sigma[1] << "sPhi=" << o.sigma[2] << "sTheta=" << o.sigma[3] << "sQOverP=" << o.sigma[4] << "dPtRel=" << o.ptResidual << "\n";
+  }
+}
+
+void streamMomenta(o2::utils::TreeStreamRedirector& output, std::span<const QAMomenta> entries)
+{
+  for (const auto& m : entries) {
+    const std::vector<float> pAtLayer = m.pAtLayer;
+    output << "momenta" << "pdg=" << m.pdg << "origin=" << m.origin << "pt=" << m.pt << "eta=" << m.eta << "p0=" << m.p0 << "found=" << m.found << "lostAt=" << m.lostAt << "pairLoss=" << m.pairLoss << "layers=" << m.layers << "fakeWrong=" << m.fakeWrong << "fakeWrongLayer=" << m.fakeWrongLayer << "pAtLayer=" << pAtLayer << "\n";
+  }
+}
+
+void streamRun(o2::utils::TreeStreamRedirector& output, int iterations, EtaRange eta, const ComparisonSettings& settings, std::size_t events) { output << "run" << "iterations=" << iterations << "etaLow=" << eta.low << "etaHigh=" << eta.high << "minLayers=" << settings.minLayers << "minPtGeV=" << settings.minPtGeV << "minOutwardLayers=" << settings.minOutwardLayers << "events=" << static_cast<std::uint64_t>(events) << "\n"; }
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/src/Tracks.cxx b/Detectors/GenericTracking/study/src/Tracks.cxx
new file mode 100644
index 0000000000000..2dae027f5be69
--- /dev/null
+++ b/Detectors/GenericTracking/study/src/Tracks.cxx
@@ -0,0 +1,131 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Study/Alice/Tracks.h"
+
+#include "DataFormatsITS/TrackITS.h"
+#include "DataFormatsMFT/TrackMFT.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+
+#include <TFile.h>
+#include <TTree.h>
+
+#include <format>
+#include <stdexcept>
+
+namespace o2::gtrk::study
+{
+
+namespace
+{
+
+/// The cluster indices of every track in \a tracks, whose own range into
+/// \a indices \a range gives as (first, count).
+template <typename Track, typename Range>
+TrackClusters clustersOf(const std::vector<Track>& tracks, const std::vector<int>& indices, Range range)
+{
+  TrackClusters result;
+  result.reserve(tracks.size());
+  for (const auto& track : tracks) {
+    const auto [first, count] = range(track);
+    if (first < 0 || count < 0 || static_cast<std::size_t>(first) + static_cast<std::size_t>(count) > indices.size()) {
+      throw std::runtime_error(std::format("a track's clusters [{}, {}) run past the {} cluster indices", first, first + count, indices.size()));
+    }
+    auto& clusters = result.emplace_back();
+    clusters.reserve(static_cast<std::size_t>(count));
+    for (int i = 0; i < count; ++i) {
+      clusters.push_back(static_cast<std::uint32_t>(indices[static_cast<std::size_t>(first) + static_cast<std::size_t>(i)]));
+    }
+  }
+  return result;
+}
+
+template <typename Track>
+TrackClusters readEntry(TTree& tree, long long entry, const char* trackBranch, const char* indexBranch, auto range)
+{
+  std::vector<Track> tracks;
+  std::vector<int> indices;
+  auto* trackPointer = &tracks;
+  auto* indexPointer = &indices;
+  tree.SetBranchAddress(trackBranch, &trackPointer);
+  tree.SetBranchAddress(indexBranch, &indexPointer);
+  tree.GetEntry(entry);
+  auto result = clustersOf(tracks, indices, range);
+  tree.ResetBranchAddresses();
+  return result;
+}
+
+} // namespace
+
+TrackFile::TrackFile(const std::string& path, Chips chips) : mChips(chips), mFile(TFile::Open(path.c_str()))
+{
+  if (!mFile || mFile->IsZombie()) {
+    throw std::runtime_error("cannot open " + path);
+  }
+  mTree = mFile->Get<TTree>("o2sim");
+  if (mTree == nullptr) {
+    throw std::runtime_error("no o2sim tree in " + path);
+  }
+}
+
+TrackFile::~TrackFile() = default;
+
+TrackClusters TrackFile::read(long long entry)
+{
+  if (entry >= mTree->GetEntries()) {
+    return {};
+  }
+  if (mChips == Chips::kITS) {
+    return readEntry<o2::its::TrackITS>(*mTree, entry, "ITSTrack", "ITSTrackClusIdx", [](const o2::its::TrackITS& track) { return std::pair{track.getFirstClusterEntry(), track.getNumberOfClusters()}; });
+  }
+  return readEntry<o2::mft::TrackMFT>(*mTree, entry, "MFTTrack", "MFTTrackClusIdx", [](const o2::mft::TrackMFT& track) { return std::pair{track.getExternalClusterIndexOffset(), track.getNumberOfPoints()}; });
+}
+
+std::vector<bool> TrackFile::fakeFlags(long long entry)
+{
+  if (entry >= mTree->GetEntries()) {
+    return {};
+  }
+  std::vector<o2::MCCompLabel> labels;
+  auto* pointer = &labels;
+  mTree->SetBranchAddress(mChips == Chips::kITS ? "ITSTrackMCTruth" : "MFTTrackMCTruth", &pointer);
+  mTree->GetEntry(entry);
+  mTree->ResetBranchAddresses();
+  std::vector<bool> result;
+  result.reserve(labels.size());
+  for (const auto& label : labels) {
+    result.push_back(label.isFake());
+  }
+  return result;
+}
+
+std::vector<o2::track::TrackParCov> TrackFile::innerStates(long long entry)
+{
+  if (mChips != Chips::kITS) {
+    throw std::runtime_error("innerStates: only the ITS's tracks are parameterised in the tracking frame");
+  }
+  if (entry >= mTree->GetEntries()) {
+    return {};
+  }
+  std::vector<o2::its::TrackITS> tracks;
+  auto* pointer = &tracks;
+  mTree->SetBranchAddress("ITSTrack", &pointer);
+  mTree->GetEntry(entry);
+  mTree->ResetBranchAddresses();
+  std::vector<o2::track::TrackParCov> result;
+  result.reserve(tracks.size());
+  for (const auto& track : tracks) {
+    result.push_back(track);
+  }
+  return result;
+}
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/test/CMakeLists.txt b/Detectors/GenericTracking/study/test/CMakeLists.txt
new file mode 100644
index 0000000000000..a5e8245f05066
--- /dev/null
+++ b/Detectors/GenericTracking/study/test/CMakeLists.txt
@@ -0,0 +1,29 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+# The study's tests; the toy layouts and the fixtures are the tracking's.
+function(gtrk_study_test name source)
+  o2_add_test(${name} SOURCES ${source} COMPONENT_NAME generic-tracking
+              PUBLIC_LINK_LIBRARIES O2::GTrkStudy ${ARGN}
+              LABELS generic-tracking TARGETVARNAME target)
+  if(target)
+    target_include_directories(${target} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../tracking/test)
+  endif()
+endfunction()
+
+gtrk_study_test(mc-truth testMCTruth.cxx)
+gtrk_study_test(track-comparison testTrackComparison.cxx)
+gtrk_study_test(stage-funnel testStageFunnel.cxx)
+gtrk_study_test(tracking-qa testTrackingQA.cxx)
+gtrk_study_test(tracking-truth testTrackingTruth.cxx)
+gtrk_study_test(vertex-qa testVertexQA.cxx)
+gtrk_study_test(study-profile testProfile.cxx)
+gtrk_study_test(stage-comparison testStageComparison.cxx)
diff --git a/Detectors/GenericTracking/study/test/testMCTruth.cxx b/Detectors/GenericTracking/study/test/testMCTruth.cxx
new file mode 100644
index 0000000000000..8b0addfbbe14d
--- /dev/null
+++ b/Detectors/GenericTracking/study/test/testMCTruth.cxx
@@ -0,0 +1,60 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testMCTruth.cxx
+/// \brief The sink's MC label rules.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK MCTruth
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Study/MCTruth.h"
+
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+BOOST_AUTO_TEST_CASE(AParticleIsAPrimaryADecaysOrTheMaterials)
+{
+  using study::ParticleOrigin;
+  // The generator's: no mother, produced in the primary interaction.
+  const o2::MCTrack generated;
+  BOOST_TEST(generated.isPrimary());
+  BOOST_TEST((particleOrigin(generated, true) == ParticleOrigin::kPhysicalPrimary));
+  // Feed-down the generator decayed.
+  BOOST_TEST((particleOrigin(generated, false) == ParticleOrigin::kDecay));
+
+  o2::MCTrack decayed;
+  decayed.SetMotherTrackId(0);
+  decayed.setProcess(kPDecay);
+  BOOST_TEST((particleOrigin(decayed, false) == ParticleOrigin::kDecay));
+  // A heavy-flavour daughter of transport is a physical primary.
+  BOOST_TEST((particleOrigin(decayed, true) == ParticleOrigin::kPhysicalPrimary));
+
+  for (const auto process : {kPHadronic, kPPair, kPCompton, kPDeltaRay}) {
+    o2::MCTrack secondary;
+    secondary.SetMotherTrackId(0);
+    secondary.setProcess(process);
+    BOOST_TEST((particleOrigin(secondary, false) == ParticleOrigin::kMaterial));
+  }
+}
+
+BOOST_AUTO_TEST_CASE(AnOrphanOfTransportIsNoPhysicalPrimary)
+{
+  // Its mother is not in the event: O2's test would read through a null one.
+  o2::MCTrack orphan;
+  orphan.SetMotherTrackId(5);
+  orphan.setProcess(kPHadronic);
+  BOOST_TEST((particleOrigin(orphan, std::vector<o2::MCTrack>{orphan}) == study::ParticleOrigin::kMaterial));
+}
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/test/testProfile.cxx b/Detectors/GenericTracking/study/test/testProfile.cxx
new file mode 100644
index 0000000000000..9f376663dafd8
--- /dev/null
+++ b/Detectors/GenericTracking/study/test/testProfile.cxx
@@ -0,0 +1,114 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testProfile.cxx
+/// \brief The output digest and the phase profile: a digest reads values,
+///        not padding; a profile's zones
+///        nest, its parallel loops fold into the zone around them, and nothing
+///        is recorded without an activation.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Profile
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/BoundTrackState.h"
+#include "GenericTracking/Study/Digest.h"
+#include "GenericTracking/Study/ProfileReport.h"
+#include "GenericTracking/Tracking/Profile.h"
+
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <sstream>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+namespace
+{
+
+using profile::Phase;
+
+BoundTrackState stateOver(unsigned char fill)
+{
+  // Every byte, padding included, set to \a fill before the fields are.
+  BoundTrackState state;
+  std::memset(static_cast<void*>(&state), fill, sizeof(state));
+  for (std::size_t index = 0; index < std::size(state.par); ++index) {
+    state.par[index] = static_cast<Scalar>(index) * 0.5F;
+  }
+  for (std::size_t index = 0; index < std::size(state.cov); ++index) {
+    state.cov[index] = static_cast<Scalar>(index) * 0.25F;
+  }
+  state.surface = 7;
+  state.surfacePhi = 0.F;
+  return state;
+}
+
+std::uint64_t digestOf(const std::vector<BoundTrackState>& states)
+{
+  Digest digest;
+  digest.column(states.data(), states.size());
+  return digest.result();
+}
+
+BOOST_AUTO_TEST_CASE(DigestReadsValuesNotPadding)
+{
+  const std::vector<BoundTrackState> zeros{stateOver(0x00), stateOver(0x00)};
+  const std::vector<BoundTrackState> ones{stateOver(0xFF), stateOver(0xFF)};
+  BOOST_TEST(digestOf(zeros) == digestOf(ones));
+
+  auto changed = zeros;
+  changed[1].cov[3] = std::nextafter(changed[1].cov[3], 1.F);
+  BOOST_TEST(digestOf(zeros) != digestOf(changed));
+
+  // A curved sensor's plane angle is part of the state; 0 is not hashed.
+  auto curved = zeros;
+  curved[0].surfacePhi = 0.25F;
+  BOOST_TEST(digestOf(zeros) != digestOf(curved));
+}
+
+BOOST_AUTO_TEST_CASE(DigestKeepsColumnBoundaries)
+{
+  const std::array<std::uint32_t, 3> values{1U, 2U, 3U};
+  Digest split;
+  split.column(values.data(), 2U);
+  split.column(values.data() + 2, 1U);
+  Digest other;
+  other.column(values.data(), 1U);
+  other.column(values.data() + 1, 2U);
+  BOOST_TEST(split.result() != other.result());
+
+  // Signed zeros are different bits, so a different digest.
+  Digest positive;
+  positive.add(0.F);
+  Digest negative;
+  negative.add(-0.F);
+  BOOST_TEST(positive.result() != negative.result());
+}
+
+BOOST_AUTO_TEST_CASE(TheReportNamesItsPhasesAndUnattributedTime)
+{
+  profile::Profile result;
+  result[Phase::kTracklets].calls = 1U;
+  result[Phase::kTracklets].seconds = 2.;
+  result[Phase::kTrackletGenerate].calls = 1U;
+  result[Phase::kTrackletGenerate].seconds = 1.;
+  std::ostringstream report;
+  study::report(report, result, Phase::kTracklets, 4);
+  BOOST_TEST(report.str().find("tracklet generate") != std::string::npos);
+  BOOST_TEST(report.str().find("(other)") != std::string::npos);
+}
+
+} // namespace
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/test/testStageComparison.cxx b/Detectors/GenericTracking/study/test/testStageComparison.cxx
new file mode 100644
index 0000000000000..f7917989feb75
--- /dev/null
+++ b/Detectors/GenericTracking/study/test/testStageComparison.cxx
@@ -0,0 +1,259 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testStageComparison.cxx
+/// \brief compareStageOutputs reports each kind of difference as what it is.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK StageComparison
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Study/StageComparison.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/TrackRefit.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "SerialReferences.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstring>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+namespace
+{
+
+using Output = StageOutput<TrackletT>;
+using Comparison = StageComparison<TrackletT>;
+using Elements = std::vector<std::vector<Tracklet>>;
+
+constexpr std::size_t kSourceColumn = 0U;
+constexpr std::size_t kTargetColumn = 1U;
+constexpr std::size_t kLambdaColumn = 3U;
+constexpr std::size_t kPhiColumn = 4U;
+
+/// Four elements, the second empty, the others with one to three records.
+Elements sample()
+{
+  const auto tracklet = [](std::uint32_t source, std::uint32_t target, Scalar lambda) { return Tracklet{.source = source, .target = target, .link = 1U, .lambda = lambda, .phi = 0.5F}; };
+  return {{tracklet(0U, 10U, 0.1F), tracklet(0U, 11U, 0.2F)}, {}, {tracklet(2U, 12U, -0.3F)}, {tracklet(3U, 13U, 0.4F), tracklet(3U, 14U, 0.5F), tracklet(3U, 15U, 0.6F)}};
+}
+
+std::unique_ptr<Output> output(const Elements& elements)
+{
+  auto result = std::make_unique<Output>();
+  result->setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  result->prepare(static_cast<Output::Index>(elements.size()));
+  const auto generate = [&](Output::Index element, auto& emitter) {
+    for (const auto& record : elements[element]) {
+      emitter.emit(record);
+    }
+  };
+  BOOST_REQUIRE(runSerial(*result, generate) == StageStatus::kComplete);
+  return result;
+}
+
+} // namespace
+
+/// A cut decided differently: one element has a record more.
+BOOST_AUTO_TEST_CASE(AChangedCountIsReportedPerElement)
+{
+  auto changed = sample();
+  changed[1].push_back(Tracklet{.source = 1U, .target = 9U, .link = 0U, .lambda = 0.F, .phi = 0.F});
+  const auto comparison = compareStageOutputs(*output(sample()), *output(changed));
+  BOOST_TEST(!comparison.identical());
+  BOOST_TEST(comparison.elementsWithOtherCount == 1U);
+  BOOST_TEST(comparison.recordsDiffering == 0U);
+  BOOST_REQUIRE(comparison.first.size() == 1U);
+  BOOST_TEST(comparison.first[0].element == 1U);
+  BOOST_TEST(comparison.first[0].column == Comparison::kCount);
+  BOOST_TEST(comparison.first[0].reference == 0.);
+  BOOST_TEST(comparison.first[0].other == 1.);
+  // The later elements, shifted by the extra record, still compare as equal.
+  BOOST_TEST(comparison.elementsReordered == 0U);
+}
+
+/// A value in its last bit: counted in its column, with the difference.
+BOOST_AUTO_TEST_CASE(AChangedFieldIsReportedInItsColumn)
+{
+  auto changed = sample();
+  changed[3][1].lambda = std::nextafter(changed[3][1].lambda, 1.F);
+  changed[0][0].target = 99U;
+  const auto comparison = compareStageOutputs(*output(sample()), *output(changed));
+  BOOST_TEST(!comparison.identical());
+  BOOST_TEST(comparison.elementsWithOtherCount == 0U);
+  BOOST_TEST(comparison.elementsReordered == 0U);
+  BOOST_TEST(comparison.recordsDiffering == 2U);
+  BOOST_TEST(comparison.differingByColumn[kLambdaColumn] == 1U);
+  BOOST_TEST(comparison.differingByColumn[kTargetColumn] == 1U);
+  BOOST_TEST(comparison.differingByColumn[kSourceColumn] == 0U);
+  BOOST_TEST(comparison.differingByColumn[kPhiColumn] == 0U);
+  BOOST_TEST(comparison.maxAbsDifference[kLambdaColumn] > 0.);
+  BOOST_TEST(comparison.maxAbsDifference[kLambdaColumn] < 1.e-6);
+  BOOST_TEST(comparison.maxAbsDifference[kTargetColumn] == 89.);
+  BOOST_REQUIRE(comparison.first.size() == 2U);
+  BOOST_TEST(comparison.first[0].element == 0U);
+  BOOST_TEST(comparison.first[0].ordinal == 0U);
+  BOOST_TEST(comparison.first[0].column == kTargetColumn);
+  BOOST_TEST(comparison.first[1].element == 3U);
+  BOOST_TEST(comparison.first[1].ordinal == 1U);
+  BOOST_TEST(comparison.first[1].column == kLambdaColumn);
+}
+
+/// The same records of an element in another order: its order differs, not
+/// its content.
+BOOST_AUTO_TEST_CASE(AMovedRecordIsAReordering)
+{
+  auto moved = sample();
+  std::swap(moved[3][0], moved[3][2]);
+  const auto comparison = compareStageOutputs(*output(sample()), *output(moved));
+  BOOST_TEST(!comparison.identical());
+  BOOST_TEST(comparison.elementsReordered == 1U);
+  BOOST_TEST(comparison.recordsDiffering == 0U);
+  BOOST_TEST(comparison.elementsWithOtherCount == 0U);
+}
+
+BOOST_AUTO_TEST_CASE(OtherElementCountsAreNotCompared)
+{
+  auto shorter = sample();
+  shorter.pop_back();
+  const auto comparison = compareStageOutputs(*output(sample()), *output(shorter));
+  BOOST_TEST(!comparison.sameElements);
+  BOOST_TEST(comparison.referenceElements == 4U);
+  BOOST_TEST(comparison.otherElements == 3U);
+  BOOST_TEST(!comparison.identical());
+}
+
+namespace
+{
+
+constexpr std::size_t kRoadRows = 17U;
+using Records = StageOutput<SelectionRecordOf<kRoadRows>::RecordT>;
+using SelectionRecord = Records::Record;
+
+SelectionRecord selectionRecord(std::uint32_t first, std::uint8_t count, float chi2)
+{
+  SelectionRecord record;
+  for (std::uint32_t i = 0; i < kRoadRows; ++i) {
+    record.clusters.index[i] = i < count ? first + i : ClusterList<kRoadRows>::kNoCluster;
+  }
+  record.count = count;
+  record.chi2 = chi2;
+  record.kinks = 0U;
+  return record;
+}
+
+std::unique_ptr<Records> recordsOf(const std::vector<SelectionRecord>& records)
+{
+  auto output = std::make_unique<Records>();
+  output->setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  output->prepare(static_cast<Records::Index>(records.size()));
+  BOOST_REQUIRE(runSerial(*output, [&](Records::Index element, auto& emitter) { emitter.emit(records[element]); }) == StageStatus::kComplete);
+  return output;
+}
+
+} // namespace
+
+/// A column wider than 64 bits -- a road's 17 rows -- is compared by its
+/// bytes; it has no numeric difference.
+BOOST_AUTO_TEST_CASE(AWideColumnIsComparedByItsBytes)
+{
+  const std::vector<SelectionRecord> records{selectionRecord(10U, 8U, 1.5F), selectionRecord(40U, 11U, 2.5F), selectionRecord(70U, 17U, 0.5F)};
+  auto changed = records;
+  changed[1].clusters.index[9] += 1U;
+  const auto comparison = compareStageOutputs(*recordsOf(records), *recordsOf(changed));
+  BOOST_TEST(!comparison.identical());
+  BOOST_TEST(comparison.recordsDiffering == 1U);
+  BOOST_TEST(comparison.differingByColumn[0] == 1U);
+  BOOST_TEST(comparison.differingByColumn[1] == 0U);
+  BOOST_TEST(comparison.differingByColumn[2] == 0U);
+  BOOST_TEST(comparison.maxAbsDifference[0] == 0.);
+  BOOST_REQUIRE(comparison.first.size() == 1U);
+  BOOST_TEST(comparison.first[0].element == 1U);
+  BOOST_TEST(comparison.first[0].column == 0U);
+  BOOST_TEST(compareStageOutputs(*recordsOf(records), *recordsOf(records)).identical());
+}
+
+/// Column sets without elements -- an iteration's gathered records -- row by
+/// row.
+BOOST_AUTO_TEST_CASE(ColumnsCompareRowByRow)
+{
+  const std::vector<SelectionRecord> records{selectionRecord(1U, 4U, 1.F), selectionRecord(9U, 5U, 3.F)};
+  auto changed = records;
+  changed[1].chi2 = 3.25F;
+  const auto reference = recordsOf(records);
+  const auto other = recordsOf(changed);
+  const auto same = compareColumns<SelectionRecordOf<kRoadRows>::RecordT>(reference->view(), reference->size(), reference->view(), reference->size());
+  BOOST_TEST(same.identical());
+  const auto comparison = compareColumns<SelectionRecordOf<kRoadRows>::RecordT>(reference->view(), reference->size(), other->view(), other->size());
+  BOOST_TEST(comparison.recordsDiffering == 1U);
+  BOOST_TEST(comparison.differingByColumn[2] == 1U);
+  BOOST_TEST(comparison.maxAbsDifference[2] == 0.25);
+  BOOST_REQUIRE(comparison.first.size() == 1U);
+  BOOST_TEST(comparison.first[0].element == 1U);
+  const auto shorter = compareColumns<SelectionRecordOf<kRoadRows>::RecordT>(reference->view(), reference->size(), other->view(), 1U);
+  BOOST_TEST(!shorter.sameElements);
+}
+
+/// Tracks row by row: a covariance entry of a state makes its record differ,
+/// in the state's column alone.
+BOOST_AUTO_TEST_CASE(TracksCompareTheirStates)
+{
+  using Tracks = BoundedColumns<TrackOf<kRoadRows>::RecordT>;
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto make = [&]() {
+    auto tracks = std::make_unique<Tracks>();
+    tracks->setMemoryResource(pool.get());
+    tracks->resize(2U);
+    const auto view = tracks->view();
+    for (std::size_t row = 0; row < 2U; ++row) {
+      for (auto* state : {&view.state[row], &view.outwardState[row]}) {
+        *state = BoundTrackState{};
+        state->par[0] = 1.F + static_cast<Scalar>(row);
+        state->cov[3] = 0.5F;
+        state->surface = 7U;
+      }
+      view.timePS[row] = 0U;
+      view.widthPS[row] = 0U;
+      view.chi2[row] = 0.F;
+      view.outwardChi2[row] = 0.F;
+      view.ndf[row] = 0;
+      view.status[row] = PropagationStatus::kOk;
+      view.count[row] = 0U;
+      view.iteration[row] = 0U;
+      view.addedOutward[row] = 0U;
+      view.addedInward[row] = 0U;
+      view.kinks[row] = 0U;
+      view.kinkCluster[row] = 0U;
+      view.clusters[row] = {};
+    }
+    return tracks;
+  };
+  const auto reference = make();
+  const auto other = make();
+  BOOST_TEST(compareColumns<TrackOf<kRoadRows>::RecordT>(std::as_const(*reference).view(), 2U, std::as_const(*other).view(), 2U).identical());
+
+  other->view().state[1].cov[3] = 0.75F;
+  const auto differing = compareColumns<TrackOf<kRoadRows>::RecordT>(std::as_const(*reference).view(), 2U, std::as_const(*other).view(), 2U);
+  constexpr auto kState = static_cast<std::size_t>(TrackOf<kRoadRows>::RecordT<memlayout::value>::Column::state);
+  BOOST_TEST(differing.recordsDiffering == 1U);
+  BOOST_TEST(differing.differingByColumn[kState] == 1U);
+  BOOST_TEST(std::ranges::count_if(differing.differingByColumn, [](std::size_t count) { return count != 0U; }) == 1);
+  BOOST_REQUIRE(differing.first.size() == 1U);
+  BOOST_TEST(differing.first[0].element == 1U);
+}
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/test/testStageFunnel.cxx b/Detectors/GenericTracking/study/test/testStageFunnel.cxx
new file mode 100644
index 0000000000000..7d36be5be3081
--- /dev/null
+++ b/Detectors/GenericTracking/study/test/testStageFunnel.cxx
@@ -0,0 +1,192 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testStageFunnel.cxx
+/// \brief The stage funnel's chains, first losses and seeded iterations
+///        (StageFunnel.h).
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK stage funnel
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Study/StageFunnel.h"
+
+#include "ToyBarrel8Fixture.h"
+#include "UniformMaterial.h"
+
+#include <array>
+#include <cstdint>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+namespace
+{
+using Controller = toybarrel8::Controller;
+using Funnel = StageFunnel<toybarrel8::Det, Controller>;
+
+std::unique_ptr<Funnel> runFunnel(const toybarrel8::Fixture& fixture, std::span<const TruthRow> rows, const ParticleTable& truth, const std::vector<IterationSettings>& settings)
+{
+  using namespace toybarrel8;
+  Controller tracker{settings, Fixture::kBeamConstraint, scatteringTable<Det>(std::array<double, kLayers>{}), std::make_shared<BoundedMemoryResource>(), 2U, 1};
+  const UniformMaterial none{};
+  tracker.setTrackModel(trackingGeometry(), none, Propagator{});
+  std::vector<double> floors;
+  floors.reserve(settings.size());
+  for (const auto& setting : settings) {
+    floors.push_back(setting.windows.minPtGeV);
+  }
+  auto funnel = std::make_unique<Funnel>(*fixture.frame, rows, truth, comparisonSettings<Det>(), vertexSeed(Fixture::kBeamConstraint), floors);
+  tracker.setSliceObserver([&](const Controller& observed, const Controller::SliceObservation& slice) { funnel->observeSlice(observed, slice); });
+  tracker.setIterationObserver([&](const Controller& observed, const Controller::IterationObservation& iteration) { funnel->observeIteration(observed, iteration); });
+  const auto result = tracker.run(*fixture.frame, tracker.planTimeframe(*fixture.frame, {}, fixture.geometry.blockCount(), 0.));
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  return funnel;
+}
+
+std::vector<TruthRow> truthRows(const toybarrel8::Fixture& fixture)
+{
+  std::vector<TruthRow> rows(fixture.frame->size());
+  for (std::uint32_t row = 0; row < rows.size(); ++row) {
+    const auto hit = fixture.frame->measurement(row).clusterIndex;
+    rows[row].layer = static_cast<LayerID>(hit % toybarrel8::kLayers);
+    rows[row].particles[rows[row].count++] = (hit / toybarrel8::kLayers) + 1U;
+  }
+  return rows;
+}
+} // namespace
+
+BOOST_AUTO_TEST_CASE(ChainsAreCountedInNodesWhateverTheEdgeOrder)
+{
+  // Rows 0-3 on layers 0-3, a branch 1 -> 4 on layer 2; listed outermost first.
+  const std::array<int, 5> layer{0, 1, 2, 3, 2};
+  const std::vector<std::pair<std::uint32_t, std::uint32_t>> edges{{2, 3}, {1, 4}, {1, 2}, {0, 1}};
+  const auto layerOf = [&](std::uint32_t node) { return layer[node]; };
+  BOOST_TEST(longestChain(edges, layerOf) == 4U);
+  const auto lengths = chainLengths(edges, layerOf);
+  BOOST_TEST(lengths.at(4) == 3U);
+  BOOST_TEST(lengths.at(3) == 4U);
+  BOOST_TEST(!lengths.contains(0));
+  BOOST_TEST(longestChain({}, layerOf) == 0U);
+}
+
+BOOST_AUTO_TEST_CASE(AParticleIsLostAtTheFirstStageShortOfTheMinimum)
+{
+  BOOST_TEST((firstLoss({3, 3, 3, 3, 3}, 4, false) == FunnelStage::kTracklets));
+  BOOST_TEST((firstLoss({7, 7, 7, 3, 0}, 4, false) == FunnelStage::kRoads));
+  BOOST_TEST((firstLoss({7, 7, 7, 7, 4}, 4, false) == FunnelStage::kSelection));
+  BOOST_TEST((firstLoss({0, 0, 0, 0, 0}, 4, true) == FunnelStage::kFound));
+}
+
+BOOST_AUTO_TEST_CASE(EachParticleIsSeededByTheIterationsWithARoadOfItsOwn)
+{
+  using namespace toybarrel8;
+  // Particle 1 at 2 GeV, above both iterations' pT_min; particle 2 at
+  // 0.45 GeV, below the first's 1 GeV, above the second's 0.3.
+  std::vector<Hit> hits = sensorHelixHits(0.3, 0.03, 2., 37.);
+  const auto soft = sensorHelixHits(1.2, 0.01, 0.45, 120.);
+  BOOST_REQUIRE(hits.size() == kLayers);
+  BOOST_REQUIRE(soft.size() == kLayers);
+  hits.insert(hits.end(), soft.begin(), soft.end());
+  const Fixture fixture{hits, 300.};
+  // Each row's particle: its hit's track.
+  const auto rows = truthRows(fixture);
+  const ParticleTable truth{{1, {.pt = 2.F, .primary = true, .origin = ParticleOrigin::kPhysicalPrimary}}, {2, {.pt = 0.45F, .primary = true, .origin = ParticleOrigin::kPhysicalPrimary}}};
+  auto first = iterationSettings();
+  auto second = iterationSettings();
+  second.windows.minPtGeV = 0.3;
+  const std::vector<IterationSettings> settings{first, second};
+
+  const auto funnel = runFunnel(fixture, rows, truth, settings);
+
+  const auto seeded = funnel->seededBy();
+  BOOST_REQUIRE(seeded.size() == 2U);
+  BOOST_TEST(seeded.at(1) == 0b01U); // its measurements used after iteration 0
+  BOOST_TEST(seeded.at(2) == 0b10U);
+}
+
+BOOST_AUTO_TEST_CASE(APairCountsAsLostOnlyIfNoIterationKeptIt)
+{
+  using namespace toybarrel8;
+  // Particle 1 at 2 GeV, found by iteration 0, its rows used in iteration 1;
+  // particle 2 at 0.45 GeV, below iteration 0's 1 GeV, found by iteration 1;
+  // particle 3 at 0.45 GeV with its layer-3 measurement 100 ns late, so that
+  // its pairs 2 -> 3 and 3 -> 4 fail the time test wherever they are tried.
+  std::vector<Hit> hits = sensorHelixHits(0.3, 0.03, 2., 37.);
+  const auto soft = sensorHelixHits(1.2, 0.01, 0.45, 120.);
+  auto late = sensorHelixHits(2.4, -0.02, 0.45, 60.);
+  BOOST_REQUIRE(hits.size() == kLayers);
+  BOOST_REQUIRE(soft.size() == kLayers);
+  BOOST_REQUIRE(late.size() == kLayers);
+  late[3].timeNS += 100.;
+  hits.insert(hits.end(), soft.begin(), soft.end());
+  hits.insert(hits.end(), late.begin(), late.end());
+  const Fixture fixture{hits, 300.};
+  const auto rows = truthRows(fixture);
+  const ParticleTable truth{{1, {.pt = 2.F, .primary = true, .origin = ParticleOrigin::kPhysicalPrimary}}, {2, {.pt = 0.45F, .primary = true, .origin = ParticleOrigin::kPhysicalPrimary}}, {3, {.pt = 0.45F, .primary = true, .origin = ParticleOrigin::kPhysicalPrimary}}};
+  auto first = iterationSettings();
+  auto second = iterationSettings();
+  second.windows.minPtGeV = 0.3;
+  const std::vector<IterationSettings> settings{first, second};
+
+  const auto funnel = runFunnel(fixture, rows, truth, settings);
+
+  const auto one = funnel->particleVerdict(1);
+  const auto two = funnel->particleVerdict(2);
+  const auto three = funnel->particleVerdict(3);
+  BOOST_REQUIRE((one.has_value() && two.has_value() && three.has_value()));
+  // NOLINTBEGIN(bugprone-unchecked-optional-access): BOOST_REQUIRE checks them, which the check does not model
+  // Kept by iteration 0: iteration 1's "used" does not count.
+  BOOST_TEST(!one->pairLoss.has_value());
+  BOOST_TEST((one->lostAt == FunnelStage::kSelection)); // as if not found: every stage reached
+  // Iteration 0 is above its pT, iteration 1 kept its pairs.
+  BOOST_TEST(!two->pairLoss.has_value());
+  BOOST_REQUIRE(three->pairLoss.has_value());
+  BOOST_TEST((*three->pairLoss == PairLoss::kTime));
+  // NOLINTEND(bugprone-unchecked-optional-access)
+  BOOST_TEST(!funnel->particleVerdict(4).has_value());
+}
+
+BOOST_AUTO_TEST_CASE(AChainRaisedFromBelowIsLostAtTheRoads)
+{
+  using namespace toybarrel8;
+  // One helix at 2 GeV whose layer-0 measurement belongs to another particle
+  // (9, not findable): its triplet on layers 0-2 is a predecessor of the
+  // particle's chain on layers 1-7, which it raises by a level, so the only
+  // road through the chain carries the other's measurement.
+  const auto hits = sensorHelixHits(0.3, 0.03, 2., 37.);
+  BOOST_REQUIRE(hits.size() == kLayers);
+  const Fixture fixture{hits, 300.};
+  std::vector<TruthRow> rows(hits.size());
+  for (std::uint32_t row = 0; row < rows.size(); ++row) {
+    const auto hit = fixture.frame->measurement(row).clusterIndex;
+    rows[row].layer = static_cast<LayerID>(hit % kLayers);
+    rows[row].particles[rows[row].count++] = rows[row].layer == 0 ? 9U : 1U;
+  }
+  const ParticleTable truth{{1, {.pt = 2.F, .primary = true, .origin = ParticleOrigin::kPhysicalPrimary}}};
+  const auto first = iterationSettings();
+  const std::vector<IterationSettings> settings{first};
+
+  const auto funnel = runFunnel(fixture, rows, truth, settings);
+
+  const auto verdict = funnel->particleVerdict(1);
+  BOOST_REQUIRE(verdict.has_value());
+  // NOLINTBEGIN(bugprone-unchecked-optional-access): BOOST_REQUIRE checks them, which the check does not model
+  BOOST_TEST((verdict->lostAt == FunnelStage::kRoads));
+  BOOST_REQUIRE(verdict->roadLoss.has_value());
+  BOOST_TEST((*verdict->roadLoss == RoadLoss::kRaisedBelow));
+  BOOST_TEST(!verdict->raisedFit.has_value()); // no road fit set: nothing fitted
+  // NOLINTEND(bugprone-unchecked-optional-access)
+}
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/test/testTrackComparison.cxx b/Detectors/GenericTracking/study/test/testTrackComparison.cxx
new file mode 100644
index 0000000000000..006ebfcac4227
--- /dev/null
+++ b/Detectors/GenericTracking/study/test/testTrackComparison.cxx
@@ -0,0 +1,365 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTrackComparison.cxx
+/// \brief The truth rules two trackers are compared under (TrackComparison.h).
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK track comparison
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Study/TrackComparison.h"
+#include "GenericTracking/Study/TrackPulls.h"
+#include "ToyBarrel3.h"
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+namespace
+{
+
+/// Numbering differs from path order; an alternate direct link need not skip.
+struct ReorderedDirect : detectors::ToyBarrel3 {
+  static constexpr std::array<LayerLink, 3> layerLinks{{
+    {.from = 0, .to = 2, .sourceMin = -1., .sourceMax = 1., .skipsLayer = false},
+    {.from = 2, .to = 1, .sourceMin = -1., .sourceMax = 1., .skipsLayer = false},
+    {.from = 0, .to = 1, .sourceMin = -1., .sourceMax = 1., .skipsLayer = true},
+  }};
+};
+
+/// ToyBarrel3 with a link 0 -> 2 beside 0 -> 1 -> 2 that skips no layer:
+/// whether a step on it leaves a hole is the pair's.
+struct PastTheEnd : detectors::ToyBarrel3 {
+  static constexpr std::array<LayerLink, 3> layerLinks{{
+    {.from = 0, .to = 1, .sourceMin = -1.5, .sourceMax = 1.5, .skipsLayer = false},
+    {.from = 0, .to = 2, .sourceMin = -1.5, .sourceMax = 1.5, .skipsLayer = false},
+    {.from = 1, .to = 2, .sourceMin = -1.5, .sourceMax = 1.5, .skipsLayer = false},
+  }};
+};
+
+[[maybe_unused]] const bool kReorderedDirectPublished = publishToy<ReorderedDirect>();
+[[maybe_unused]] const bool kPastTheEndPublished = publishToy<PastTheEnd>();
+
+/// Whether some report line contains \a text.
+bool reports(const std::vector<std::string>& lines, const std::string& text)
+{
+  return std::ranges::any_of(lines, [&](const std::string& line) { return line.find(text) != std::string::npos; });
+}
+
+TruthRow row(LayerID layer, std::initializer_list<std::uint64_t> particles)
+{
+  TruthRow result;
+  result.layer = layer;
+  for (const auto particle : particles) {
+    result.particles[result.count++] = particle;
+  }
+  return result;
+}
+
+/// A measurement of particle \a particle on \a layer at radius \a r and \a z.
+TruthRow at(LayerID layer, std::uint64_t particle, float r, float z)
+{
+  auto result = row(layer, {particle});
+  result.r = r;
+  result.z = z;
+  return result;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(FindabilityFollowsTheLinksThatSkipNoLayer)
+{
+  const auto settings = comparisonSettings<ReorderedDirect>(2);
+  // Particle 1 on 0 and 2, joined by 0 -> 2 despite the numbering gap;
+  // particle 2 on 0 and 1, joined only by the skipping 0 -> 1; particle 3 on
+  // all three, 0 -> 2 -> 1.
+  const std::vector<TruthRow> rows{row(0, {1, 3}), row(2, {1, 3}), row(0, {2}), row(1, {2, 3})};
+  const auto layers = particleLayers(rows, settings);
+  BOOST_TEST(layers.at(1).chain == 2U);
+  BOOST_TEST(layers.at(2).chain == 1U);
+  BOOST_TEST(layers.at(3).chain == 3U);
+  BOOST_TEST(layers.at(3).layers == 0b111U);
+  BOOST_TEST(isFindable(1.F, layers.at(1), settings));
+  BOOST_TEST(!isFindable(1.F, layers.at(2), settings));
+  BOOST_TEST(!isFindable(0.05F, layers.at(1), settings));
+  // The score and decay-family denominator use exactly the same predicate.
+  const std::vector<TruthRow> decayRows{row(0, {1}), row(2, {1}), row(0, {2}), row(1, {2})};
+  const ParticleTable particles{{1, {.pt = 1.F, .origin = ParticleOrigin::kDecay, .motherPdg = 310}}, {2, {.pt = 1.F, .origin = ParticleOrigin::kDecay, .motherPdg = 310}}};
+  const auto score = scoreTracks(decayRows, particles, {{0, 1}, {2, 3}}, settings);
+  BOOST_TEST(score.originFindable[static_cast<std::size_t>(ParticleOrigin::kDecay)].findable == 1U);
+  BOOST_TEST(score.originFindable[static_cast<std::size_t>(ParticleOrigin::kDecay)].found == 1U);
+  BOOST_TEST(score.decays[static_cast<std::size_t>(DecayFamily::kK0S)][0].onMinLayers == 2U);
+  BOOST_TEST(score.decays[static_cast<std::size_t>(DecayFamily::kK0S)][0].findable == 1U);
+}
+
+BOOST_AUTO_TEST_CASE(AChainStepCrossingAnotherLayerIsAHole)
+{
+  // ToyBarrel3 with 0 -> 2 as a link that skips nothing: past layer 1's ends
+  // (|z| 1 cm at r 4) a step 0 -> 2 is direct; through its length a hole.
+  const auto settings = comparisonSettings<PastTheEnd>(2);
+  BOOST_TEST(settings.chainLinks.size() == 3U);
+  const auto step = std::ranges::find_if(settings.chainLinks, [](const ChainLink& link) { return link.from == 0 && link.to == 2; });
+  BOOST_TEST((step != settings.chainLinks.end() && step->holes == 0b010U));
+  // Particle 1 at z 0 on both: the segment crosses layer 1 at z 0. Particle 2
+  // from z 0.9 to 3.9: at r 4 it is at z 1.9, past the end.
+  const std::vector<TruthRow> rows{at(0, 1, 2.F, 0.F), at(2, 1, 8.F, 0.F), at(0, 2, 2.F, 0.9F), at(2, 2, 8.F, 3.9F)};
+  const auto layers = particleLayers(rows, settings);
+  BOOST_TEST(layers.at(1).chain == 1U);
+  BOOST_TEST(layers.at(2).chain == 2U);
+}
+
+BOOST_AUTO_TEST_CASE(DirectChainsIncludeLayersAboveThirtyOne)
+{
+  const ComparisonSettings settings{.nLayers = 36, .minLayers = 3, .chainLinks = {{.from = 32, .to = 34}, {.from = 34, .to = 35}}};
+  const std::vector<TruthRow> rows{row(32, {1}), row(34, {1}), row(35, {1})};
+  const auto layers = particleLayers(rows, settings);
+  BOOST_TEST(layers.at(1).chain == 3U);
+  const ParticleTable particles{{1, {.pt = 1.F, .primary = true, .origin = ParticleOrigin::kPhysicalPrimary}}};
+  const auto score = scoreTracks(rows, particles, {{0, 1, 2}}, settings);
+  BOOST_TEST(score.originFindable[0].findable == 1U);
+  BOOST_TEST(score.originFindable[0].complete == 1U);
+}
+
+BOOST_AUTO_TEST_CASE(ASharedMeasurementCountsForEveryParticleItCarries)
+{
+  // Particle 1 on layers 0-2, particle 2 on layers 0-2; the layer-1
+  // measurement carries both. Row 6 is noise.
+  const std::vector<TruthRow> rows{row(0, {1}), row(1, {1, 2}), row(2, {1}), row(0, {2}), row(2, {2}), row(1, {3}), row(2, {})};
+  const ParticleTable particles{{1, {.pt = 1.F, .primary = true}}, {2, {.pt = 1.F, .primary = true}}, {3, {.pt = 1.F, .primary = true}}};
+  const ComparisonSettings settings{.nLayers = 3, .minLayers = 2, .minPtGeV = 0.1, .chainLinks = {{.from = 0, .to = 1}, {.from = 1, .to = 2}}};
+
+  // Ours: particle 1 through the shared measurement, good; particle 2 through
+  // it too, good; particle 1 again with the noise row, a fake labelled 1.
+  const TrackRows ours{{0, 1, 2}, {3, 1, 4}, {0, 5, 6}};
+  // Theirs: particle 1 without the shared measurement's alternative -- the
+  // same set as ours -- and particle 2 with one wrong measurement.
+  const TrackRows theirs{{2, 1, 0}, {3, 5, 4}};
+
+  const auto lines = compareTrackSets(rows, particles, ours, theirs, settings, "A", "B");
+  BOOST_TEST(reports(lines, "A: 3 tracks, 33.33 % fake"));
+  BOOST_TEST(reports(lines, "B: 2 tracks, 50.00 % fake"));
+  // All three layers: particles 1 and 2. A finds both, B particle 1 only, and
+  // particle 2 only with its fake.
+  BOOST_TEST(reports(lines, "on all 3 layers: 2"));
+  BOOST_TEST(reports(lines, "A: 100.00 % found (100.00 % complete, 100.0 % of their layers),  0.00 % only with a fake,  0.00 % cloned"));
+  BOOST_TEST(reports(lines, "B:  50.00 % found (50.00 % complete, 100.0 % of their layers), 50.00 % only with a fake"));
+  // Theirs track by track: {0,1,2} is identical to ours; {3,5,4} overlaps
+  // {3,1,4} in two of three.
+  BOOST_TEST(reports(lines, "identical 50.00 %"));
+  BOOST_TEST(reports(lines, "overlapping 50.00 %"));
+  BOOST_TEST(reports(lines, "found by both 1, by A only 1, by B only 0, by neither 0"));
+}
+
+BOOST_AUTO_TEST_CASE(TheScoreIsWhatTheComparisonReports)
+{
+  // As above: A finds particles 1 and 2, the second through the measurement
+  // they share, and makes a fake labelled 1 with a noise row.
+  const std::vector<TruthRow> rows{row(0, {1}), row(1, {1, 2}), row(2, {1}), row(0, {2}), row(2, {2}), row(1, {3}), row(2, {})};
+  const ParticleTable particles{{1, {.pt = 1.F, .primary = true, .origin = ParticleOrigin::kPhysicalPrimary, .pdg = 211}}, {2, {.pt = 0.15F, .primary = true, .origin = ParticleOrigin::kDecay, .pdg = -2212}}, {3, {.pt = 1.F, .primary = true, .origin = ParticleOrigin::kMaterial, .pdg = 11}}};
+  const ComparisonSettings settings{.nLayers = 3, .minLayers = 1, .minPtGeV = 0.1, .chainLinks = {{.from = 0, .to = 1}, {.from = 1, .to = 2}}};
+  const TrackRows ours{{0, 1, 2}, {3, 1, 4}, {0, 5, 6}};
+  const TrackRows theirs{{2, 1, 0}};
+
+  const auto score = scoreTracks(rows, particles, ours, settings);
+  BOOST_TEST(score.tracks == 3U);
+  BOOST_TEST(score.fakes == 1U);
+  BOOST_TEST(score.tracksByLength[3] == 3U);
+  BOOST_TEST(score.fakesByLength[3] == 1U);
+  BOOST_TEST(score.allLayers.findable == 2U);
+  BOOST_TEST(score.allLayers.found == 2U);
+  BOOST_TEST(score.allLayers.withFake == 1U); // particle 1, found too
+  BOOST_TEST(score.allLayers.fakeOnly == 0U);
+  BOOST_TEST(score.allLayers.foundByPt[1] == 1U); // particle 2, [0.1, 0.2)
+  BOOST_TEST(score.allLayers.foundByPt[5] == 1U); // particle 1, [1, 2)
+  // Particle 3, on layer 1 alone, is findable on one layer or more and not found.
+  BOOST_TEST(score.minLayers.findable == 3U);
+  BOOST_TEST(score.minLayers.found == 2U);
+  // No row's first label counts for O2's QA here.
+  BOOST_TEST(score.o2.findable == 0U);
+
+  // By origin, primary or not: particle 1 a physical primary, 2 a decay's
+  // (an antiproton), 3 the material's (an electron) and on one layer only.
+  BOOST_TEST(score.originAllLayers[0].findable == 1U);
+  BOOST_TEST(score.originAllLayers[1].found == 1U);
+  BOOST_TEST(score.originAllLayers[2].findable == 0U);
+  BOOST_TEST(score.originMinLayers[2].findable == 1U);
+  BOOST_TEST(score.originMinLayers[2].found == 0U);
+  BOOST_TEST((score.originMinLayers[1].bySpecies.at(2212) == std::array<std::uint64_t, 2>{1U, 1U}));
+  BOOST_TEST((score.minLayers.bySpecies.at(11) == std::array<std::uint64_t, 2>{1U, 0U}));
+
+  // Every line of the score is one the comparison prints, for the same tracker.
+  const auto lines = compareTrackSets(rows, particles, ours, theirs, settings, "A", "B");
+  for (const auto& line : describeScore(score, settings, "A")) {
+    BOOST_TEST(std::ranges::count(lines, line) == 1, line);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(AStubIsFoundButNotComplete)
+{
+  // Particle 1 on three layers: track A holds two of them, found; track B all
+  // three, complete. Particle 2 on three layers, found with a stub only.
+  const std::vector<TruthRow> rows{row(0, {1}), row(1, {1}), row(2, {1}), row(0, {2}), row(1, {2}), row(2, {2})};
+  const ParticleTable particles{{1, {.pt = 1.F, .primary = true, .origin = ParticleOrigin::kPhysicalPrimary, .pdg = 211}}, {2, {.pt = 0.15F, .primary = true, .origin = ParticleOrigin::kPhysicalPrimary, .pdg = 211}}};
+  const ComparisonSettings settings{.nLayers = 3, .minLayers = 2, .minPtGeV = 0.1, .chainLinks = {{.from = 0, .to = 1}, {.from = 1, .to = 2}}};
+
+  const auto stubs = scoreTracks(rows, particles, {{0, 1}, {3, 4}}, settings);
+  BOOST_TEST(stubs.allLayers.findable == 2U);
+  BOOST_TEST(stubs.allLayers.found == 2U);
+  BOOST_TEST(stubs.allLayers.complete == 0U);
+  BOOST_TEST(stubs.allLayers.layersFound == 4U);
+  BOOST_TEST(stubs.allLayers.layersOf == 6U);
+  BOOST_TEST(stubs.allLayers.layerFraction == 4. / 3., boost::test_tools::tolerance(1e-9)); // two stubs of 2 of 3 layers
+  BOOST_TEST(stubs.allLayers.layerFractionByPt[1] == 2. / 3., boost::test_tools::tolerance(1e-9));
+
+  const auto mixed = scoreTracks(rows, particles, {{0, 1}, {0, 1, 2}, {3, 4}}, settings);
+  BOOST_TEST(mixed.allLayers.found == 2U);
+  BOOST_TEST(mixed.allLayers.cloned == 1U);
+  BOOST_TEST(mixed.allLayers.complete == 1U); // particle 1, by its longer track
+  BOOST_TEST(mixed.allLayers.completeByPt[5] == 1U);
+  BOOST_TEST(mixed.allLayers.completeByPt[1] == 0U);
+  BOOST_TEST(mixed.allLayers.layersFound == 5U);
+  BOOST_TEST(mixed.allLayers.layerFraction == 5. / 3., boost::test_tools::tolerance(1e-9)); // the complete one 1, the stub 2 of 3; the clone nothing
+  BOOST_TEST(reports(describeScore(mixed, settings, "A"), "100.00 % found (50.00 % complete, 83.3 % of their layers)"));
+}
+
+BOOST_AUTO_TEST_CASE(SecondariesAndSoftParticlesAreNotFindable)
+{
+  const std::vector<TruthRow> rows{row(0, {1}), row(1, {1}), row(0, {2}), row(1, {2})};
+  const ParticleTable particles{{1, {.pt = 1.F, .primary = false}}, {2, {.pt = 0.05F, .primary = true}}};
+  const TrackRows tracks{{0, 1}, {2, 3}};
+  const auto lines = compareTrackSets(rows, particles, tracks, tracks, {.nLayers = 2, .minLayers = 2, .minPtGeV = 0.1, .chainLinks = {{.from = 0, .to = 1}}}, "A", "B");
+  BOOST_TEST(reports(lines, "on all 2 layers: 0"));
+  BOOST_TEST(reports(lines, "A: 2 tracks, 0.00 % fake"));
+}
+
+BOOST_AUTO_TEST_CASE(TwoGoodTracksOfOneParticleAreAClone)
+{
+  const std::vector<TruthRow> rows{row(0, {1}), row(1, {1}), row(0, {1}), row(1, {1})};
+  const ParticleTable particles{{1, {.pt = 0.4F, .primary = true}}};
+  const TrackRows ours{{0, 1}, {2, 3}};
+  const TrackRows theirs{{0, 1}};
+  const auto lines = compareTrackSets(rows, particles, ours, theirs, {.nLayers = 2, .minLayers = 2, .minPtGeV = 0.1, .chainLinks = {{.from = 0, .to = 1}}}, "A", "B");
+  BOOST_TEST(reports(lines, "A: 100.00 % found (100.00 % complete, 100.0 % of their layers),  0.00 % only with a fake, 100.00 % cloned"));
+  BOOST_TEST(reports(lines, "B: 100.00 % found (100.00 % complete, 100.0 % of their layers),  0.00 % only with a fake,  0.00 % cloned"));
+}
+
+BOOST_AUTO_TEST_CASE(OneWrongMeasurementIsAFakeAndItsLayerIsCounted)
+{
+  // Particle 1 on layers 0-2, with its own layer-1 measurement passed over for
+  // particle 2's.
+  const std::vector<TruthRow> rows{row(0, {1}), row(1, {1}), row(2, {1}), row(1, {2})};
+  const ParticleTable particles{{1, {.pt = 1.F, .primary = true}}, {2, {.pt = 1.F, .primary = false}}};
+  const TrackRows ours{{0, 3, 2}};
+  const auto lines = compareTrackSets(rows, particles, ours, {}, {.nLayers = 3, .minLayers = 2, .minPtGeV = 0.1, .chainLinks = {{.from = 0, .to = 1}, {.from = 1, .to = 2}}}, "A", "B");
+  BOOST_TEST(reports(lines, "A fakes: 1; labelled with a primary 100.0 %"));
+  BOOST_TEST(reports(lines, "by wrong measurements 1 / 2 / 3 / 4+: 100.0 / 0.0 / 0.0 / 0.0 %"));
+  BOOST_TEST(reports(lines, "1 wrong measurements, by layer (%): 0: 0.0 1: 100.0 2: 0.0"));
+  BOOST_TEST(reports(lines, "passed over 100.0 %, none of its own there 0.0 %"));
+  BOOST_TEST(reports(lines, "a secondary's 100.0 %"));
+  BOOST_TEST(goodParticle(rows, std::vector<std::uint32_t>{0, 1, 2}) == 1U);
+  BOOST_TEST(goodParticle(rows, std::vector<std::uint32_t>{0, 3, 2}) == kNoTrackParticle);
+}
+
+BOOST_AUTO_TEST_CASE(ShortTracksAreCountedByTheirLayers)
+{
+  // Particles 1 and 2 on layers 0-2, particle 3 on layers 0, 1 and 3; a
+  // four-layer detector, so every track is short of a layer.
+  const std::vector<TruthRow> rows{row(0, {1}), row(1, {1}), row(2, {1}), row(0, {2}), row(1, {2}), row(2, {2}), row(0, {3}), row(1, {3}), row(3, {3})};
+  const ParticleTable particles{{1, {.pt = 1.F, .primary = true}}, {2, {.pt = 1.F, .primary = true}}, {3, {.pt = 1.F, .primary = true}}};
+  // Two good tracks on 0-2, one fake with a hole on layer 2, and the one good
+  // track of the full set: none.
+  const TrackRows ours{{0, 1, 2}, {3, 4, 5}, {0, 7, 8}};
+  const auto lines = compareTrackSets(rows, particles, ours, {}, {.nLayers = 4, .minLayers = 3, .minPtGeV = 0.1, .chainLinks = {{.from = 0, .to = 1}, {.from = 1, .to = 2}, {.from = 2, .to = 3}}}, "A", "B");
+  BOOST_TEST(reports(lines, "A: 3 tracks short of a layer, by layers (fake %): 012: 2 (0.0) 013: 1 (100.0)"));
+  BOOST_TEST(reports(lines, "B: 0 tracks short of a layer, by layers (fake %):"));
+}
+
+BOOST_AUTO_TEST_CASE(O2sQADefinitionReadsOnlyTheFirstLabel)
+{
+  // Particles 1 and 2 on both layers of a two-layer detector, at 50 MeV --
+  // below our findable floor, not O2's. On layer 1 particle 2's measurement
+  // is shared and its first label is particle 3's, so O2's QA does not count
+  // it findable; ours, reading every label, would above the floor.
+  auto first = [](TruthRow row) {
+    row.firstLabelCounts = true;
+    return row;
+  };
+  const std::vector<TruthRow> rows{first(row(0, {1})), first(row(1, {1})), first(row(0, {2})), first(row(1, {3, 2}))};
+  const ParticleTable particles{{1, {.pt = 0.05F, .primary = true, .eta = 0.2F, .phi = 1.F}}, {2, {.pt = 0.05F, .primary = true, .eta = -0.7F, .phi = 4.F}}, {3, {.pt = 1.F, .primary = false}}};
+  const TrackRows ours{{0, 1}, {0, 1}, {2, 3}};
+  const auto lines = compareTrackSets(rows, particles, ours, {}, {.nLayers = 2, .minLayers = 2, .minPtGeV = 0.1, .chainLinks = {{.from = 0, .to = 1}}}, "A", "B");
+  BOOST_TEST(reports(lines, "first labels on all 2 layers, any pT: 1 findable"));
+  BOOST_TEST(reports(lines, "A: found 1 (100.00 %), clone tracks 1, with a fake track 0"));
+  BOOST_TEST(reports(lines, "on all 2 layers: 0"));
+}
+
+BOOST_AUTO_TEST_CASE(DecayDaughtersAreSplitByMotherAndProduction)
+{
+  // A five-layer detector, production bins [0,1), [1,5), [5,inf) cm.
+  // Particle 1, a K0S's at 3 cm, on layers 2-4: findable, found. Particle 2,
+  // an antilambda's at 0.5 cm, on layers 0, 1, 3, 4: on three layers or more
+  // but no three adjacent, found. Particle 3, a pion's in flight at |z| 2 and
+  // radius 10 cm, on layers 0-2: findable, not found. Particle 4, a primary,
+  // and particle 5, a K0S's below the pT floor, are not decay daughters here.
+  const std::vector<TruthRow> rows{row(2, {1}), row(3, {1}), row(4, {1}), row(0, {2}), row(1, {2}), row(3, {2}), row(4, {2}), row(0, {3}), row(1, {3}), row(2, {3}), row(0, {4}), row(1, {4}), row(2, {4}), row(2, {5}), row(3, {5}), row(4, {5})};
+  const ParticleTable particles{{1, {.pt = 0.5F, .origin = ParticleOrigin::kDecay, .pdg = 211, .motherPdg = 310, .vx = 3.F}}, {2, {.pt = 0.5F, .origin = ParticleOrigin::kDecay, .pdg = -2212, .motherPdg = -3122, .vx = 0.3F, .vy = 0.4F}}, {3, {.pt = 0.5F, .origin = ParticleOrigin::kDecay, .pdg = 13, .motherPdg = 211, .vx = 10.F, .vz = -2.F}}, {4, {.pt = 0.5F, .primary = true, .origin = ParticleOrigin::kPhysicalPrimary, .pdg = 211}}, {5, {.pt = 0.05F, .origin = ParticleOrigin::kDecay, .pdg = 211, .motherPdg = 310, .vx = 3.F}}};
+  const TrackRows tracks{{0, 1, 2}, {3, 4, 5, 6}, {10, 11, 12}};
+  ComparisonSettings settings{
+    .nLayers = 5,
+    .minLayers = 3,
+    .minPtGeV = 0.1,
+    .productionEdges = {1., 5.},
+    .chainLinks = {{.from = 0, .to = 1}, {.from = 1, .to = 2}, {.from = 2, .to = 3}, {.from = 3, .to = 4}},
+  };
+
+  const auto score = scoreTracks(rows, particles, tracks, settings);
+  const auto counts = [&](DecayFamily family, std::size_t bin) {
+    const auto& c = score.decays[static_cast<std::size_t>(family)][bin];
+    return std::array<std::uint64_t, 4>{c.onMinLayers, c.foundOnMinLayers, c.findable, c.found};
+  };
+  BOOST_TEST(score.decays[0].size() == 3U);
+  BOOST_TEST((counts(DecayFamily::kK0S, 1) == std::array<std::uint64_t, 4>{1U, 1U, 1U, 1U}));
+  BOOST_TEST((counts(DecayFamily::kLambda, 0) == std::array<std::uint64_t, 4>{1U, 1U, 0U, 0U}));
+  BOOST_TEST((counts(DecayFamily::kPion, 2) == std::array<std::uint64_t, 4>{1U, 0U, 1U, 0U}));
+  BOOST_TEST((counts(DecayFamily::kOther, 0) == std::array<std::uint64_t, 4>{}));
+
+  const auto lines = compareTrackSets(rows, particles, tracks, {}, settings, "A", "B");
+  BOOST_TEST(reports(lines, "production radius [cm] (bins from 0, 1.0, 5.0)"));
+  BOOST_TEST(reports(lines, "A V0s and hyperons 100.00 (1/2), of all 100.00 %; by production: 0.0 (0/1) 100.0 (1/1) 0.0 (0/0)"));
+  BOOST_TEST(reports(lines, "A in flight          0.00 (1/1), of all 0.00 %; by production: 0.0 (0/0) 0.0 (0/0) 0.0 (1/1)"));
+  BOOST_TEST(reports(lines, "B K0S                0.00 (1/1)"));
+
+  // Along z, particle 3 moves to the middle bin.
+  settings.productionAlongZ = true;
+  const auto alongZ = scoreTracks(rows, particles, tracks, settings);
+  BOOST_TEST(alongZ.decays[static_cast<std::size_t>(DecayFamily::kPion)][1].findable == 1U);
+}
+
+BOOST_AUTO_TEST_CASE(PullWidthsAreRobust)
+{
+  PullTable table{"t", {{.name = "x", .unit = "um", .scale = 1e4}}};
+  // Pulls -2 .. 2 in one bin: median 0, median absolute deviation 1; a
+  // thousand-sigma outlier does not move either much.
+  for (const double residual : {-2., -1., 0., 1., 2., 1000.}) {
+    table.add(0.5, std::array<double, 1>{residual * 1e-4}, std::array<double, 1>{1e-4});
+  }
+  table.add(0.5, std::array<double, 1>{0.}, std::array<double, 1>{1e-4});
+  const auto lines = table.report();
+  BOOST_TEST(reports(lines, "7 residual median     0.00 sigma     1.48; pull median  0.000 sigma  1.483 beyond 5 14.29 %"));
+}
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/test/testTrackingQA.cxx b/Detectors/GenericTracking/study/test/testTrackingQA.cxx
new file mode 100644
index 0000000000000..cb4de9739d965
--- /dev/null
+++ b/Detectors/GenericTracking/study/test/testTrackingQA.cxx
@@ -0,0 +1,371 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTrackingQA.cxx
+/// \brief The QA's records per timeframe (TrackingQA.h), against the text
+///        score (TrackComparison.h).
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK tracking QA
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/MathUtils.h"
+#include "GenericTracking/Study/TrackingQA.h"
+#include "GenericTracking/Study/TrackComparison.h"
+
+#include "CommonConstants/MathConstants.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <initializer_list>
+#include <numbers>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+namespace
+{
+
+TruthRow row(LayerID layer, std::initializer_list<std::uint64_t> particles)
+{
+  TruthRow result;
+  result.layer = layer;
+  for (const auto particle : particles) {
+    result.particles[result.count++] = particle;
+  }
+  return result;
+}
+
+/// Three layers, two adjacent ones findable, two iterations.
+///   particle 1: a primary on every layer, found by iteration 0 and again by 1
+///   particle 2: a decay daughter on every layer, found by iteration 1 only
+///   particle 3: a primary on layers 0 and 2 only, not findable
+///   particle 4: from the material on layers 1 and 2, findable, not found
+///   particle 5: a primary on every layer below the pT floor, not findable
+struct Toy {
+  std::vector<TruthRow> rows{row(0, {1}), row(1, {1}), row(2, {1}), row(0, {2}), row(1, {2}), row(2, {2}), row(0, {3}), row(2, {3}), row(1, {4}), row(2, {4}), row(0, {5}), row(1, {5}), row(2, {5})};
+  ParticleTable truth{{1, {.pt = 1.F, .primary = true, .eta = 0.2F, .phi = 1.F, .origin = ParticleOrigin::kPhysicalPrimary}}, {2, {.pt = 0.5F, .eta = -0.3F, .phi = -1.F, .origin = ParticleOrigin::kDecay}}, {3, {.pt = 2.F, .primary = true, .eta = 0.4F, .origin = ParticleOrigin::kPhysicalPrimary}}, {4, {.pt = 0.3F, .eta = 0.9F, .phi = 3.F, .origin = ParticleOrigin::kMaterial}}, {5, {.pt = 0.05F, .primary = true, .eta = 0.F, .origin = ParticleOrigin::kPhysicalPrimary}}};
+  ComparisonSettings settings{.nLayers = 3, .minLayers = 2, .minPtGeV = 0.1, .chainLinks = {{.from = 0, .to = 1}, {.from = 1, .to = 2}}};
+  // Particle 1 in iteration 1, particle 2, a fake of particles 4 and 2, and
+  // particle 1 in iteration 0.
+  TrackRows tracks{{0, 1, 2}, {3, 4, 5}, {8, 5}, {0, 1, 2}};
+  std::vector<TrackKinematics> kinematics{{.pt = 1.F, .eta = 0.2F, .phi = 1.F, .iteration = 1}, {.pt = 0.5F, .eta = -0.3F, .phi = -1.F, .iteration = 1}, {.pt = 0.4F, .eta = 0.5F, .phi = 2.F, .iteration = 0}, {.pt = 1.F, .eta = 0.2F, .phi = 1.F, .iteration = 0, .chi2 = 3.5F, .ndf = 4}};
+  // Particle 1 seeded by both, 2 by both, 4 by iteration 0; 3 is not findable.
+  SeededBy seeded{{1, 0b11U}, {2, 0b11U}, {3, 0b01U}, {4, 0b01U}};
+};
+
+/// \a helix carried along its path by the Lorentz force alone, in \a steps
+/// steps of \a step [cm] of transverse path, backward for a negative one:
+/// the field's equations of motion, midpoint rule, with no circle in them.
+TruthHelix integrate(TruthHelix helix, double bzKiloGauss, double step, int steps)
+{
+  const double pt = std::hypot(helix.momentum[0], helix.momentum[1]);
+  // du/ds = (q Bz c / pT) (uy, -ux): F = q v x B with B along z.
+  const double k = helix.charge * bzKiloGauss * 0.299792458e-3 / pt;
+  double ux = helix.momentum[0] / pt;
+  double uy = helix.momentum[1] / pt;
+  for (int i = 0; i < steps; ++i) {
+    const double mx = ux + (0.5 * step * k * uy);
+    const double my = uy - (0.5 * step * k * ux);
+    helix.position[0] += step * mx;
+    helix.position[1] += step * my;
+    helix.position[2] += step * helix.momentum[2] / pt;
+    const double nx = ux + (step * k * my);
+    const double ny = uy - (step * k * mx);
+    const double norm = std::hypot(nx, ny);
+    ux = nx / norm;
+    uy = ny / norm;
+  }
+  helix.momentum[0] = ux * pt;
+  helix.momentum[1] = uy * pt;
+  return helix;
+}
+
+const QAParticle* particleOf(const TrackingQA& qa, float pt)
+{
+  const auto found = std::ranges::find(qa.particles, pt, &QAParticle::pt);
+  return found == qa.particles.end() ? nullptr : &*found;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(TheFindableAndTheIterationsThatFoundAndSeededThem)
+{
+  const Toy toy;
+  const auto qa = trackingQA(toy.rows, toy.truth, toy.tracks, toy.kinematics, toy.seeded, {}, nullptr, 2, toy.settings);
+  BOOST_TEST(qa.particles.size() == 3U); // 1, 2 and 4
+  const auto* first = particleOf(qa, 1.F);
+  const auto* decay = particleOf(qa, 0.5F);
+  const auto* material = particleOf(qa, 0.3F);
+  BOOST_REQUIRE(first != nullptr);
+  BOOST_REQUIRE(decay != nullptr);
+  BOOST_REQUIRE(material != nullptr);
+  BOOST_TEST(first->foundBy == 0b11U);
+  BOOST_TEST(first->origin == static_cast<std::uint8_t>(ParticleOrigin::kPhysicalPrimary));
+  BOOST_TEST(decay->foundBy == 0b10U);
+  BOOST_TEST(decay->origin == static_cast<std::uint8_t>(ParticleOrigin::kDecay));
+  BOOST_TEST(material->foundBy == 0U);
+  BOOST_TEST(first->seededBy == 0b11U);
+  BOOST_TEST(decay->seededBy == 0b11U);
+  BOOST_TEST(material->seededBy == 0b01U);
+  BOOST_TEST(material->origin == static_cast<std::uint8_t>(ParticleOrigin::kMaterial));
+}
+
+BOOST_AUTO_TEST_CASE(FakesAndClonesInIterationOrder)
+{
+  const Toy toy;
+  const auto qa = trackingQA(toy.rows, toy.truth, toy.tracks, toy.kinematics, toy.seeded, {}, nullptr, 2, toy.settings);
+  BOOST_REQUIRE(qa.tracks.size() == 4U);
+  // In the order given; particle 1's track of iteration 1 is the clone,
+  // although it comes first.
+  BOOST_TEST((!qa.tracks[0].fake && qa.tracks[0].clone));
+  BOOST_TEST((!qa.tracks[1].fake && !qa.tracks[1].clone));
+  BOOST_TEST((qa.tracks[2].fake && !qa.tracks[2].clone));
+  BOOST_TEST((!qa.tracks[3].fake && !qa.tracks[3].clone));
+  BOOST_TEST(qa.tracks[2].iteration == 0U);
+  BOOST_TEST(qa.tracks[3].chi2 == 3.5F);
+  BOOST_TEST(qa.tracks[3].ndf == 4);
+}
+
+BOOST_AUTO_TEST_CASE(EveryPhiInZeroToTwoPi)
+{
+  const Toy toy;
+  const auto qa = trackingQA(toy.rows, toy.truth, toy.tracks, toy.kinematics, toy.seeded, {}, nullptr, 2, toy.settings);
+  BOOST_TEST(particleOf(qa, 0.5F)->phi == wrapPhi(-1.));
+  BOOST_TEST(qa.tracks[1].phi == wrapPhi(-1.));
+  constexpr double kTwoPi = 2. * std::numbers::pi;
+  BOOST_TEST(wrapPhi(-1.) == static_cast<float>(kTwoPi - 1.));
+  BOOST_TEST(wrapPhi(kTwoPi) == 0.F);
+  BOOST_TEST(wrapPhi(std::nextafter(kTwoPi, 0.)) == 0.F); // 2 pi as a float
+  BOOST_TEST(wrapPhi(-std::numbers::pi) == static_cast<float>(std::numbers::pi));
+  BOOST_TEST(wrapPhi(7.) == static_cast<float>(7. - kTwoPi));
+}
+
+BOOST_AUTO_TEST_CASE(TheTotalsAreTheTextScore)
+{
+  const Toy toy;
+  const auto qa = trackingQA(toy.rows, toy.truth, toy.tracks, toy.kinematics, toy.seeded, {}, nullptr, 2, toy.settings);
+  const auto score = scoreTracks(toy.rows, toy.truth, toy.tracks, toy.settings);
+  for (std::size_t origin = 0; origin < score.originFindable.size(); ++origin) {
+    const auto of = [&](const QAParticle& p) { return p.origin == origin; };
+    const auto findable = std::ranges::count_if(qa.particles, of);
+    const auto found = std::ranges::count_if(qa.particles, [&](const QAParticle& p) { return of(p) && p.foundBy != 0U; });
+    BOOST_TEST(static_cast<std::uint64_t>(findable) == score.originFindable[origin].findable);
+    BOOST_TEST(static_cast<std::uint64_t>(found) == score.originFindable[origin].found);
+  }
+  // The primaries' two classes split the findable primaries.
+  BOOST_TEST(score.primaryRegion[0].findable + score.primaryRegion[1].findable == score.originFindable[0].findable);
+  BOOST_TEST(score.primaryRegion[0].found + score.primaryRegion[1].found == score.originFindable[0].found);
+  BOOST_TEST(qa.tracks.size() == score.tracks);
+  BOOST_TEST(static_cast<std::uint64_t>(std::ranges::count_if(qa.tracks, &QATrack::fake)) == score.fakes);
+}
+
+BOOST_AUTO_TEST_CASE(TheEtaReachOfEnvelopes)
+{
+  // A barrel layer at r 2.3 cm, |z| < 13.5 cm, and a disc at z 77 cm over r 3.4-15 cm.
+  const std::array<LayerEnvelope, 2> envelopes{LayerEnvelope{.position = 2.3, .rMin = 2.3, .rMax = 2.4, .zMin = -13.5, .zMax = 13.5}, LayerEnvelope{.position = 77., .rMin = 3.4, .rMax = 15., .zMin = 76.9, .zMax = 77.1}};
+  const auto reach = etaReach(envelopes);
+  BOOST_TEST(reach.low == -2.5); // asinh(-13.5 / 2.3) = -2.47
+  BOOST_TEST(reach.high == 4.0); // asinh(77.1 / 3.4) = 3.81
+}
+
+BOOST_AUTO_TEST_CASE(TheExtrasLayersAndTheOtherTrackersParticles)
+{
+  const Toy toy;
+  const ParticleExtrasTable extras{{2, {.vr = 1.5F, .d0 = 0.25F, .z0 = -0.5F, .openingAngle = 0.1F, .motherMiss = 0.01F, .lostAt = 6U, .raisedFit = 5U}}, {4, {.vr = 3.F, .lostAt = 4U, .pairLoss = 6U, .fitLoss = 1U, .fitRoadLayers = 0b110U, .fitLosses = 0b1010U}}};
+  const TrackRows theirs{{3, 4, 5}, {8, 9, 0}}; // particle 2, and a fake
+  const auto qa = trackingQA(toy.rows, toy.truth, toy.tracks, toy.kinematics, toy.seeded, extras, &theirs, 2, toy.settings);
+  const auto* first = particleOf(qa, 1.F);
+  const auto* decay = particleOf(qa, 0.5F);
+  const auto* material = particleOf(qa, 0.3F);
+  BOOST_REQUIRE((first != nullptr && decay != nullptr && material != nullptr));
+  BOOST_TEST(first->layers == 0b111U);
+  BOOST_TEST(material->layers == 0b110U);
+  BOOST_TEST(decay->extras.d0 == 0.25F);
+
+  BOOST_TEST(decay->foundByO2);
+  BOOST_TEST(!first->foundByO2);
+  BOOST_TEST(!material->foundByO2);
+  // Without extras: nothing observed, the geometry NaN.
+  BOOST_TEST(first->extras.lostAt == kQANotObserved);
+  BOOST_TEST(first->extras.pairLoss == kQANotObserved);
+  BOOST_TEST(std::isnan(first->extras.d0));
+  BOOST_TEST(std::isnan(first->extras.openingAngle));
+}
+
+BOOST_AUTO_TEST_CASE(TheOutwardLegEndsWhereTheCurlerTurnsBack)
+{
+  // Out through layers 0, 1 (twice: an overlap) and 2, back through 1, then on
+  // layer 3 inside layer 2's radius: the return's layers do not count. Given
+  // out of time order.
+  const std::vector<HitCrossing> crossings{{.time = 5., .position = {1.5, 0., 0.}, .layer = 3}, {.time = 1., .position = {1., 0., 0.}, .layer = 0}, {.time = 4., .position = {0., 2., 0.}, .layer = 1}, {.time = 2., .position = {2., 0., 0.}, .layer = 1}, {.time = 2.5, .position = {2.01, 0.1, 0.}, .layer = 1}, {.time = 3., .position = {3., 0., 0.}, .layer = 2}};
+  BOOST_TEST(outwardLayers(outwardLeg(crossings, {0., 0., 0.})) == 3U);
+  // Seen from a production point beyond them, the leg ends at its first crossing.
+  BOOST_TEST(outwardLayers(outwardLeg(crossings, {10., 0., 0.})) == 1U);
+}
+
+BOOST_AUTO_TEST_CASE(TheOutwardLegMakesAParticleFindableAboveTheFloor)
+{
+  const Toy toy;
+  // Particle 3 (no chain) and particle 5 (below the floor) on the outward rule's layers.
+  const ParticleExtrasTable extras{{3, {.outwardLayers = 7U}}, {5, {.outwardLayers = 7U}}, {4, {.outwardLayers = 2U}}};
+  const auto qa = trackingQA(toy.rows, toy.truth, toy.tracks, toy.kinematics, toy.seeded, extras, nullptr, 2, toy.settings);
+  BOOST_TEST(qa.particles.size() == 4U); // 1, 2, 4 and 3
+  const auto* outward = particleOf(qa, 2.F);
+  const auto* material = particleOf(qa, 0.3F);
+  BOOST_REQUIRE((outward != nullptr && material != nullptr));
+  BOOST_TEST(!outward->findable);
+  BOOST_TEST(outward->extras.outwardLayers == 7U);
+  BOOST_TEST(material->findable);
+  BOOST_TEST(material->extras.outwardLayers == 2U);
+  BOOST_TEST(particleOf(qa, 0.05F) == nullptr);
+}
+
+BOOST_AUTO_TEST_CASE(AParticleFromTheBeamLineMissesItByNothing)
+{
+  for (const double charge : {-1., 1.}) {
+    for (const double bz : {-5., 5.}) {
+      const TruthHelix helix{.position = {0.03, -0.02, 2.5}, .momentum = {-0.2, 0.15, 0.4}, .charge = charge};
+      const auto impact = helixImpact(helix, bz, 0.03, -0.02);
+      BOOST_TEST(std::abs(impact.d0) < 1e-12);
+      BOOST_TEST(std::abs(impact.z - 2.5) < 1e-12);
+      const auto direction = helixDirectionAt(helix, bz, 0.03, -0.02);
+      BOOST_TEST(std::abs(direction[0] - (-0.2 / std::hypot(0.2, 0.15, 0.4))) < 1e-12);
+      BOOST_TEST(std::abs(direction[2] - (0.4 / std::hypot(0.2, 0.15, 0.4))) < 1e-12);
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(ADaughterOnItsMothersHelixPointsBackAlongIt)
+{
+  // From the beam line, 10 cm of transverse path by the equations of motion:
+  // the helix there passes the beam line where it started, and the helix at
+  // the start has there the direction the motion gives.
+  for (const double charge : {-1., 1.}) {
+    for (const double bz : {-5., 5.}) {
+      const TruthHelix start{.position = {0., 0., 0.5}, .momentum = {0.3, 0.1, 0.2}, .charge = charge};
+      const auto later = integrate(start, bz, 1e-3, 10000);
+      const auto impact = helixImpact(later, bz, 0., 0.);
+      BOOST_TEST(std::abs(impact.d0) < 1e-5);
+      BOOST_TEST(std::abs(impact.z - 0.5) < 1e-5);
+      BOOST_TEST(helixMiss(start, bz, later.position[0], later.position[1]) < 1e-6);
+      const auto direction = helixDirectionAt(start, bz, later.position[0], later.position[1]);
+      const double p = std::hypot(later.momentum[0], later.momentum[1], later.momentum[2]);
+      for (std::size_t i = 0; i < 3U; ++i) {
+        BOOST_TEST(std::abs(direction[i] - (later.momentum[i] / p)) < 1e-6);
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(ADisplacedHelixMissesTheBeamLineByItsCircle)
+{
+  // A circle about (3, 4), 5 cm from the beam line: radius 2 cm misses it by
+  // +3, 7 cm by -2. The closest point's z from the motion run backward.
+  for (const double charge : {-1., 1.}) {
+    for (const double bz : {-5., 5.}) {
+      for (const double radius : {2., 7.}) {
+        const double pt = radius * std::abs(charge * bz) * 0.299792458e-3;
+        const double angle = 0.3;
+        // Clockwise for q Bz > 0: the direction is the radius turned by -90 degrees.
+        const double sense = charge * bz > 0. ? -1. : 1.;
+        const TruthHelix helix{
+          .position = {3. + (radius * std::cos(angle)), 4. + (radius * std::sin(angle)), 1.},
+          .momentum = {-sense * pt * std::sin(angle), sense * pt * std::cos(angle), 0.5 * pt},
+          .charge = charge,
+        };
+        // The motion keeps to that circle: the setup's sense is the field's.
+        const auto ahead = integrate(helix, bz, 1e-3, 3000);
+        BOOST_TEST(std::abs(std::hypot(ahead.position[0] - 3., ahead.position[1] - 4.) - radius) < 1e-6);
+        const auto impact = helixImpact(helix, bz, 0., 0.);
+        // The radius from O2's B2C, a float: 1e-7 of it.
+        BOOST_TEST(std::abs(impact.d0 - (5. - radius)) < 1e-5);
+        // The nearer pass: half a turn back and half a turn ahead, step by step.
+        double best = std::hypot(helix.position[0], helix.position[1]);
+        double bestZ = helix.position[2];
+        const int halfTurn = static_cast<int>(std::numbers::pi * radius / 1e-3);
+        for (const double step : {-1e-3, 1e-3}) {
+          auto walker = helix;
+          for (int i = 0; i < halfTurn; ++i) {
+            walker = integrate(walker, bz, step, 1);
+            if (const double distance = std::hypot(walker.position[0], walker.position[1]); distance < best) {
+              best = distance;
+              bestZ = walker.position[2];
+            }
+          }
+        }
+        BOOST_TEST(std::abs(impact.z - bestZ) < 1e-3);
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(HalfATurnAwayIsTheTurnBehind)
+{
+  // The unit circle about the origin, clockwise (q Bz > 0) from (0, 1, 0) with
+  // pz = pT; the axis at (0, -1) is half a turn away either way: the
+  // convention's turn is +pi, behind, so z = -pi.
+  const double bz = 5.;
+  const double pt = std::abs(static_cast<double>(o2::constants::math::B2C) * bz); // radius exactly 1
+  const TruthHelix helix{.position = {0., 1., 0.}, .momentum = {pt, 0., pt}, .charge = 1.};
+  const auto impact = helixImpact(helix, bz, 0., -1.);
+  BOOST_TEST(std::abs(impact.d0) < 1e-12);
+  BOOST_TEST(std::abs(impact.z + std::numbers::pi) < 1e-12);
+}
+
+BOOST_AUTO_TEST_CASE(KinematicsNoHelixFollowsAreNaN)
+{
+  // A NaN momentum, a NaN field, no momentum at all.
+  const TruthHelix invalid{.position = {1., 2., 3.}, .momentum = {std::nan(""), 0., 1.}, .charge = 1.};
+  const TruthHelix fine{.position = {1., 2., 3.}, .momentum = {0.3, 0., 1.}, .charge = 1.};
+  const TruthHelix atRest{.position = {1., 2., 3.}, .momentum = {0., 0., 0.}, .charge = 1.};
+  for (const auto& [helix, bz] : {std::pair{invalid, -5.}, std::pair{fine, std::nan("")}, std::pair{atRest, -5.}}) {
+    const auto impact = helixImpact(helix, bz, 0., 0.);
+    BOOST_TEST(std::isnan(impact.d0));
+    BOOST_TEST(std::isnan(impact.z));
+    BOOST_TEST(std::isnan(helixMiss(helix, bz, 0., 0.)));
+    BOOST_TEST(std::isnan(helixDirectionAt(helix, bz, 0., 0.)[0]));
+  }
+  // No transverse momentum: a line along z, with no closest point to an axis.
+  const TruthHelix alongZ{.position = {1., 2., 3.}, .momentum = {0., 0., 1.}, .charge = 1.};
+  BOOST_TEST(std::isnan(helixImpact(alongZ, -5., 0., 0.).d0));
+  BOOST_TEST(std::abs(helixMiss(alongZ, -5., 0., 0.) - std::sqrt(5.)) < 1e-12);
+  BOOST_TEST(std::abs(helixDirectionAt(alongZ, -5., 0., 0.)[2] - 1.) < 1e-12);
+  // The point at the circle's centre has no tangent.
+  const auto r = curvatureRadius(0.3, -5.);
+  const auto atCentre = helixDirectionAt(TruthHelix{.position = {0., 0., 0.}, .momentum = {0.3, 0., 0.}, .charge = 1.}, -5., 0., r);
+  BOOST_TEST(std::isnan(atCentre[0]));
+}
+
+BOOST_AUTO_TEST_CASE(ANeutralsLineMissesByItsDistance)
+{
+  const TruthHelix neutral{.position = {1., 0., 2.}, .momentum = {0., 0.5, 0.5}, .charge = 0.};
+  const auto impact = helixImpact(neutral, -5., 0., 0.);
+  BOOST_TEST(std::abs(std::abs(impact.d0) - 1.) < 1e-12);
+  BOOST_TEST(std::abs(impact.z - 2.) < 1e-12);
+  BOOST_TEST(std::abs(helixMiss(neutral, -5., 1., 3.)) < 1e-12);
+  const auto direction = helixDirectionAt(neutral, -5., 1., 3.);
+  BOOST_TEST(std::abs(direction[1] - std::numbers::sqrt2 / 2.) < 1e-12);
+}
+
+BOOST_AUTO_TEST_CASE(AnIterationOutsideTheConfiguredIsRefused)
+{
+  Toy toy;
+  toy.kinematics[0].iteration = 2;
+  BOOST_CHECK_THROW((void)trackingQA(toy.rows, toy.truth, toy.tracks, toy.kinematics, toy.seeded, {}, nullptr, 2, toy.settings), std::invalid_argument);
+  BOOST_CHECK_THROW((void)trackingQA(toy.rows, toy.truth, toy.tracks, toy.kinematics, toy.seeded, {}, nullptr, kQAMaxIterations + 1, toy.settings), std::invalid_argument);
+}
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/test/testTrackingTruth.cxx b/Detectors/GenericTracking/study/test/testTrackingTruth.cxx
new file mode 100644
index 0000000000000..3c576de8f7f8f
--- /dev/null
+++ b/Detectors/GenericTracking/study/test/testTrackingTruth.cxx
@@ -0,0 +1,169 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTrackingTruth.cxx
+/// \brief The MC truth beside a tracking input (TrackingInput.h): it reads
+///        back as written, and only for its own tracking input.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK tracking truth
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Study/TrackingInput.h"
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <filesystem>
+#include <fstream>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <unistd.h>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+namespace
+{
+
+/// A file in the temporary directory, removed with the object.
+struct TemporaryFile {
+  std::string path = (std::filesystem::temp_directory_path() / ("gtrk-test-truth-" + std::to_string(getpid()))).string();
+  TemporaryFile() = default;
+  TemporaryFile(const TemporaryFile&) = delete;
+  TemporaryFile& operator=(const TemporaryFile&) = delete;
+  TemporaryFile(TemporaryFile&&) = delete;
+  TemporaryFile& operator=(TemporaryFile&&) = delete;
+  ~TemporaryFile() { std::filesystem::remove(path); }
+};
+
+/// A tracking input of \a clusterIndex's rows, only their cluster indices set.
+TrackingInput inputOf(const std::vector<std::uint32_t>& clusterIndex)
+{
+  TrackingInput input;
+  resizeMeasurementColumns(input.columns, clusterIndex.size());
+  std::ranges::copy(clusterIndex, input.columns.clusterIndex.begin());
+  return input;
+}
+
+const std::vector<std::uint32_t> kClusters{7U, 3U, 11U};
+
+std::vector<TruthRow> someRows()
+{
+  return {{{.particles = {5U, 9U}, .count = 2, .firstLabelCounts = true}, 0}, {{.particles = {9U}, .count = 1, .firstLabelCounts = false}, 1}, {{.count = 0, .firstLabelCounts = false}, 6}}; // noise
+}
+
+const ParticleTable kParticles{{5U, {.pt = 0.25F, .primary = true, .eta = -0.5F, .phi = 1.5F, .origin = ParticleOrigin::kPhysicalPrimary, .pdg = 211}},
+                               {9U,
+                                {
+                                  .pt = 3.F,
+                                  .primary = false,
+                                  .eta = 0.75F,
+                                  .phi = -2.F,
+                                  .origin = ParticleOrigin::kDecay,
+                                  .pdg = -2212,
+                                  .motherPdg = -3122,
+                                  .process = 4,
+                                  .vx = 1.5F,
+                                  .vy = -2.25F,
+                                  .vz = 7.F,
+                                }}};
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(ItReadsBackAsWritten)
+{
+  const TemporaryFile file;
+  const auto rows = someRows();
+  writeTrackingTruth(file.path, kClusters, rows, kParticles);
+  const auto truth = readTrackingTruth(file.path, inputOf(kClusters));
+
+  BOOST_REQUIRE_EQUAL(truth.rows.size(), rows.size());
+  for (std::size_t row = 0; row < rows.size(); ++row) {
+    BOOST_TEST(truth.rows[row].particles == rows[row].particles);
+    BOOST_TEST(truth.rows[row].count == rows[row].count);
+    BOOST_TEST(truth.rows[row].layer == rows[row].layer);
+    BOOST_TEST(truth.rows[row].firstLabelCounts == rows[row].firstLabelCounts);
+  }
+  BOOST_REQUIRE_EQUAL(truth.particles.size(), kParticles.size());
+  for (const auto& [id, particle] : kParticles) {
+    const auto& read = truth.particles.at(id);
+    BOOST_TEST(read.pt == particle.pt);
+    BOOST_TEST(read.primary == particle.primary);
+    BOOST_TEST(read.eta == particle.eta);
+    BOOST_TEST(read.phi == particle.phi);
+    BOOST_TEST((read.origin == particle.origin));
+    BOOST_TEST(read.pdg == particle.pdg);
+    BOOST_TEST(read.motherPdg == particle.motherPdg);
+    BOOST_TEST(read.process == particle.process);
+    BOOST_TEST(read.vx == particle.vx);
+    BOOST_TEST(read.vy == particle.vy);
+    BOOST_TEST(read.vz == particle.vz);
+  }
+}
+
+/// A tracking input keeps each layer's readout frames and the boxes its
+/// producer made -- widened by the margin it applied -- whatever margin the
+/// reader is configured with: the slices' reach reads the boxes against the
+/// frames; and the depths its
+/// rows were placed at.
+BOOST_AUTO_TEST_CASE(TheInputKeepsEachLayersFramesAndItsBoxes)
+{
+  const TemporaryFile file;
+  auto input = inputOf(kClusters);
+  const std::vector<FrameTiming> frames{{.lengthBC = 22, .firstStartBC = 0}, {.lengthBC = 22, .firstStartBC = 0}, {.lengthBC = 81, .firstStartBC = 3}};
+  const std::array<TimeEstPS, 3> boxes{frameBox(154, 176, 0), frameBox(154, 176, 30), frameBox(165, 246, 0)};
+  for (std::size_t row = 0; row < boxes.size(); ++row) {
+    input.columns.timePS[row] = boxes[row].start;
+    input.columns.widthPS[row] = boxes[row].width;
+  }
+  const std::vector<std::uint32_t> offsets{0U, 3U};
+  const std::vector<double> depths{8.25e-4, -41.25e-4, -40.73e-4};
+  writeTrackingInput(file.path, measurementView(input.columns), kClusters.size(), offsets, {}, workflow::nominalBeamLine(), frames, depths);
+  const auto read = readTrackingInput(file.path);
+  BOOST_TEST(read.frames == frames);
+  BOOST_TEST(read.depths == depths);
+  for (std::size_t row = 0; row < boxes.size(); ++row) {
+    BOOST_TEST(read.columns.timePS[row] == boxes[row].start);
+    BOOST_TEST(read.columns.widthPS[row] == boxes[row].width);
+  }
+}
+
+/// Frames for another count than the layout's layers are refused.
+BOOST_AUTO_TEST_CASE(ItReadsOnlyForItsOwnInput)
+{
+  const TemporaryFile file;
+  writeTrackingTruth(file.path, kClusters, someRows(), kParticles);
+  BOOST_CHECK_THROW((void)readTrackingTruth(file.path, inputOf({7U, 3U})), std::runtime_error);
+  BOOST_CHECK_THROW((void)readTrackingTruth(file.path, inputOf({7U, 11U, 3U})), std::runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(ItRefusesAShortOrForeignFile)
+{
+  const TemporaryFile file;
+  BOOST_CHECK_THROW(writeTrackingTruth(file.path, std::span{kClusters}.first(2), someRows(), kParticles), std::runtime_error);
+
+  writeTrackingTruth(file.path, kClusters, someRows(), kParticles);
+  const auto size = std::filesystem::file_size(file.path);
+  std::filesystem::resize_file(file.path, size - 1U);
+  BOOST_CHECK_THROW((void)readTrackingTruth(file.path, inputOf(kClusters)), std::runtime_error);
+
+  {
+    std::ofstream out{file.path, std::ios::binary | std::ios::trunc};
+    out << "GTRKTIN1 not a truth";
+  }
+  BOOST_CHECK_THROW((void)readTrackingTruth(file.path, inputOf(kClusters)), std::runtime_error);
+}
+
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/test/testVertexQA.cxx b/Detectors/GenericTracking/study/test/testVertexQA.cxx
new file mode 100644
index 0000000000000..16e44d45aed97
--- /dev/null
+++ b/Detectors/GenericTracking/study/test/testVertexQA.cxx
@@ -0,0 +1,83 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testVertexQA.cxx
+/// \brief Vertex truth assignment, coverage, splits, fakes and merges.
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK VertexQA
+#include <boost/test/unit_test.hpp>
+#include "GenericTracking/Study/VertexQA.h"
+#include "ToyBarrel8.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <map>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+BOOST_AUTO_TEST_CASE(ClaimsDetermineCoverageSplitsFakesAndMerges)
+{
+  std::vector<TruthRow> rows;
+  ParticleTable particles;
+  // Two findable primaries in separate collisions, each measured on four
+  // layers. The second collision contributes to the first's vertex.
+  for (std::uint64_t collision = 0; collision < 2; ++collision) {
+    const auto particle = (collision << o2::MCCompLabel::nbitsTrackID) | 1U;
+    particles[particle] = {.pt = 1.F, .primary = true, .vz = 0.F};
+    for (LayerID layer = 0; layer < 4; ++layer) {
+      TruthRow row;
+      row.particles[0] = particle;
+      row.count = 1U;
+      row.layer = layer;
+      rows.push_back(row);
+    }
+  }
+  rows.emplace_back(); // noise
+  const std::vector<TripletClaim> claims{{.rows = {0, 1, 2}, .vertex = 0}, {.rows = {1, 2, 3}, .vertex = 0}, {.rows = {0, 1, 3}, .vertex = 1}, {.rows = {4, 5, 6}, .vertex = 0}, {.rows = {8, 8, 8}, .vertex = 2}};
+  VertexerResult found;
+  found.vertices = {{.z = 0.01F, .varZ = 0.0001F}, {.z = 0.02F, .varZ = 0.0001F}, {.z = 3.F}};
+  found.contributors = {3U, 1U, 1U};
+  const auto score = scoreVertices<detectors::ToyBarrel8>(rows, particles, claims, found);
+  BOOST_TEST(score.vertices == 3U);
+  BOOST_TEST(score.collisions == 2U);
+  BOOST_TEST(score.found == 1U);
+  BOOST_TEST(score.findable == 2U);
+  BOOST_TEST(score.covered == 1U);
+  BOOST_TEST(score.fakes == 1U);
+  BOOST_TEST(score.splits == 1U);
+  BOOST_TEST(score.merged == 1U);
+  BOOST_REQUIRE(score.residualsUM.size() == 1U);
+  BOOST_TEST(score.residualsUM[0] == 100., boost::test_tools::tolerance(1e-6));
+  BOOST_REQUIRE(score.pulls.size() == 1U);
+  BOOST_TEST(score.pulls[0] == 1., boost::test_tools::tolerance(1e-6));
+  // Of two vertices of a collision the contributor maximum supplies its
+  // residual; this split has more contributors than the original vertex.
+  found.contributors[1] = 4U;
+  const auto splitWins = scoreVertices<detectors::ToyBarrel8>(rows, particles, claims, found);
+  BOOST_TEST(splitWins.residualsUM[0] == 200., boost::test_tools::tolerance(1e-6));
+}
+
+BOOST_AUTO_TEST_CASE(TiesKeepTheFirstCollisionAndFirstVertex)
+{
+  const std::vector<std::map<std::int64_t, std::uint32_t>> labels{{{0, 2U}, {1, 2U}}, {{0, 1U}}, {{-1, 1U}, {1, 1U}}};
+  const std::array<std::uint32_t, 3> contributors{4U, 4U, 2U};
+  const std::vector<std::map<std::int64_t, std::uint32_t>> wentTo{{{0, 2U}, {1, 1U}}, {{0, 2U}, {2, 1U}}};
+  const auto score = scoreVertexClaims(labels, contributors, wentTo);
+  BOOST_TEST(score.collision == (std::vector<std::int64_t>{0, 0, -1}), boost::test_tools::per_element());
+  BOOST_TEST(score.best == (std::vector<std::int64_t>{0, -1}), boost::test_tools::per_element());
+  BOOST_TEST(score.fakes == 1U);
+  BOOST_TEST(score.splits == 1U);
+  BOOST_TEST(score.merged == 1U);
+}
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/tools/CompleteAnatomy.h b/Detectors/GenericTracking/study/tools/CompleteAnatomy.h
new file mode 100644
index 0000000000000..921306a73b6b2
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/CompleteAnatomy.h
@@ -0,0 +1,8202 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CompleteAnatomy.h
+/// \brief The bench's anatomy of the findable on every layer of a mask:
+///        found whole, short and why, not found and why, against the
+///        decisions the tracker actually made, and the particles' true kinks
+///        from the MC hits.
+///
+/// The class is the physical primaries above the score's floor with a
+/// measurement on every layer of the mask (`--findable-all-layers`),
+/// narrowed by `ClassCuts` (`--anatomy-*`). A particle's rows are taken in
+/// the order it crossed them: with the MC hits (`--hits`), by their time of
+/// flight, its path order; without them, or for a particle
+/// with a row the hits do not have, by the distance from its production
+/// vertex, which grows along a first outward pass but falls on a looper's
+/// way back.
+///
+/// Its parts: each class particle's fate after every iteration (complete,
+/// short and why, not found and why, with the graph audit of a road never
+/// made; `--fate-out`); the seeding funnel, the record losses and the
+/// dropped records' follow replayed (`printSeeding`); the beam-line test
+/// and the follow's losses against the MC (`--anatomy-beam-line`,
+/// `--anatomy-follow-loss`); the path order and the true kinks, the truth
+/// walk (`--truth-walk`), the inward refit's states (`--inward-history`)
+/// and the steps against the MC (`--step-anatomy`), with the hits; the
+/// fakes' transitions, the follow's end evidence and decisions
+/// (`--end-decisions`, `--end-edits`), the own steps, the hole calls and the
+/// road ends; the clutter test of the follow's steps with the MC
+/// kinematics (`--kine`) and who blocks the not found.
+///
+/// For the tracks an iteration made, its follow is done again, outward and
+/// inward: every track's proposal by the follow's own code
+/// (`FollowStage::follow`) from the refit of its road, on the used mask as
+/// the follow found it, with an observer on every decision; then the
+/// bidding and the refit's acceptance, as the follow makes them (not the
+/// refit's prefix second chance, its trim of an ambiguous last row or the
+/// crossing rule). What that gives is checked against what the
+/// iteration kept (`fidelity`), and a short track's stop is the decision
+/// that made it: its particle's next row lost in the bidding, dropped with
+/// a kink step's witness, dropped with the refit (failed or above its
+/// chi2), or, at the proposal step, never queried, held, outside the
+/// window, crossing a layer, without an update, above the chi2 gate, or
+/// passing with another row taken (by the lookahead or not); where the step
+/// had the kink allowance, what its kink step did with the row instead: no
+/// budget left, refused under the scaled gate, passing it but unconfirmed,
+/// or another confirmed row taken. With followEarlier the earlier tracks'
+/// follow before the iteration's seeds is replayed the same way, from the
+/// tracks and the mask as the previous iteration left them.
+
+#ifndef GTRK_STUDY_COMPLETEANATOMY_H_
+#define GTRK_STUDY_COMPLETEANATOMY_H_
+
+#include "GenericTracking/Study/Alice/Hits.h"
+#include "GenericTracking/Tracking/BeamConstraint.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/Follow.h"
+#include "GenericTracking/Tracking/NeighbourCut.h"
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Tracking/SensorCells.h"
+#include "GenericTracking/Tracking/Parallel.h"
+#include "GenericTracking/Tracking/TrackFitter.h"
+#include "GenericTracking/Tracking/TripletCut.h"
+#include "GenericTracking/Study/Validation.h"
+#include "GenericTracking/Study/MCTruth.h"
+#include "GenericTracking/Study/StageFunnel.h"
+#include "GenericTracking/Study/Statistics.h"
+#include "GenericTracking/Study/TrackComparison.h"
+#include "GenericTracking/Study/TrackingInput.h"
+
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/O2DatabasePDG.h"
+#include "Steer/MCKinematicsReader.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <chrono>
+#include <cmath>
+#include <cstring>
+#include <cstdint>
+#include <filesystem>
+#include <format>
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <limits>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <random>
+#include <numbers>
+#include <numeric>
+#include <optional>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+template <DetectorLayout Det>
+// NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding): a study's members, ordered by what they hold
+class CompleteAnatomy
+{
+ public:
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  static constexpr std::size_t kLayers = static_cast<std::size_t>(Detector<Det>::nLayers);
+
+  /// Why a short track is short: its particle's next row inward, the first
+  /// layer of the mask it misses.
+  enum Short : std::uint8_t {
+    kGapInside,       ///< a layer missing between the track's own
+    kLostBid,         ///< proposed, lost in the bidding on that row or one before
+    kWitnessLost,     ///< proposed and won, dropped with a kink step's witness lost in the bidding
+    kRefitFailed,     ///< proposed and won, dropped with the extended refit: the fit failed
+    kRefitChi2,       ///< proposed and won, dropped with the extended refit: above its chi2
+    kNotQueried,      ///< the step's grid query never visited it
+    kUsed,            ///< held by a track when the step ran
+    kWindow,          ///< visited, outside the step's window
+    kHole,            ///< crossing another layer
+    kNoUpdate,        ///< no usable update
+    kChi2,            ///< above the chi2 gate
+    kOtherTaken,      ///< passing, another row taken
+    kLookaheadOther,  ///< passing, the lookahead took another row
+    kKinkBudget,      ///< refused by the step, its kink step not made: the budget spent
+    kKinkRefused,     ///< refused by the step and by its kink step's scaled gate (or window)
+    kKinkUnconfirmed, ///< refused by the step, passing its kink step's, nothing confirming it
+    kKinkOther,       ///< refused by the step, passing its kink step's, confirmed, another row taken
+    kNoStep,          ///< the proposal never stepped from the layer outside it
+    kShortReasons
+  };
+  static constexpr std::array<const char*, kShortReasons> kShortNames{"gap inside", "lost the bid", "dropped with a kink step's witness", "refit failed", "refit chi2", "not queried", "held", "outside the window", "crossing a layer", "no update", "chi2", "passing, another row taken", "passing, the lookahead took another", "kink budget spent", "kink step refused it", "kink step unconfirmed", "kink step took another", "no step from the layer outside"};
+  /// Who holds a particle's own row at the end (the short tracks that lost
+  /// the bid): an earlier iteration's track, or this one's.
+  enum Holder : std::uint8_t { kNoOwnRow = 0U,
+                               kRowFree = 1U,
+                               kHeldByFake = 2U,
+                               kHeldByOther = 3U,
+                               kHeldByOwn = 4U,
+                               kThisIteration = 3U,
+                               kHolderKinds = 8U };
+  static constexpr std::array<const char*, kHolderKinds> kHolderNames{"no own row", "free", "an earlier fake", "an earlier track of another particle", "an earlier track of its own", "a fake of this iteration", "a track of another particle of this iteration", "a track of its own of this iteration"};
+
+  /// Why a class particle has no good track (`missedReason`); the values
+  /// are the `--fate-out` codes.
+  enum Missed : std::uint8_t { kLostToFake,
+                               kTakenByOther,
+                               kRoadChi2,
+                               kRoadPropagation,
+                               kFloor,
+                               kBeamLine,
+                               kNoRoad,
+                               kTooFewRows,
+                               kRoadTime,
+                               kMissedReasons };
+  static constexpr std::array<const char*, kMissedReasons> kMissedNames{"road rows held by a fake", "held by another particle's track", "road fit chi2", "road fit propagation", "pT floor", "beam line", "passing: no road made", "fewer road rows than the pass's clusters", "road rows share no time"};
+
+  /// The first predicate of the graph that refuses a "no road made"
+  /// particle's true outer rows, the triplets inner first, then the
+  /// neighbours; a triplet's with the kink allowance
+  /// where the iteration has one and the nominal cuts refuse.
+  enum Graph : std::uint8_t {
+    kGraphLambda,
+    kGraphTime,
+    kGraphCurvature,
+    kGraphFitFailed,
+    kGraphChi2,
+    kGraphOwnMomentum,
+    kGraphBothKinked,
+    kGraphNeighbourCurvature,
+    kGraphNeighbourTime,
+    kGraphNeighbourFitFailed,
+    kGraphNeighbourChi2,
+    kGraphLinkRange,    ///< a row outside the z range its link admits sources from
+    kGraphLinkNotTaken, ///< the layout's link between two consecutive true rows is not one the iteration takes
+    kGraphStart,        ///< a start-layer mask: the chain's innermost row on a layer roads may not start on
+    kGraphPairTime,     ///< the tracklet stage's own tests, as `pairCutLoss` orders them
+    kGraphPairTurning,
+    kGraphPairCurvature,
+    kGraphPairLongitudinal,
+    kGraphPairWindow, ///< the target outside the cells the source's query visits
+    kGraphPairHole,   ///< no direct pair: the segment crosses another layer's silicon (LinkHoles.h)
+    kGraphPasses,
+    kGraphReasons
+  };
+  static constexpr std::array<const char*, kGraphReasons> kGraphNames{"triplet: dip window", "triplet: time", "triplet: curvature", "triplet: fit failed", "triplet: fit chi2", "triplet: own-momentum chi2", "neighbour: both triplets kinked", "neighbour: curvature agreement", "neighbour: time", "neighbour: fit failed", "neighbour: fit chi2", "link: source outside its z range", "link: not taken by the iteration", "start: the chain's innermost row on a layer roads may not start on", "pair: time", "pair: turning point", "pair: curvature", "pair: longitudinal", "pair: outside the query's cells", "pair: crosses another layer", "every predicate passes"};
+
+  /// The class restricted to a species and optionally the QA's findable.
+  struct ClassCuts {
+    std::int32_t pdg = 0; ///< |PDG code| of the class's species; 0, every species
+    /// Only the findable by these settings (`isFindable`, the QA's rule:
+    /// a chain of `minLayers`); none, no such cut.
+    const study::ComparisonSettings* findable = nullptr;
+  };
+
+  /// \a roadLayers: each iteration's `layerMask`, 0 for every layer (kept
+  /// with every bit set, so that its readers test bits only).
+  CompleteAnatomy(const study::TrackingTruth& truth, std::uint64_t mask, double minPtGeV, std::vector<std::uint64_t> roadLayers, ClassCuts cuts = {})
+    : mTruth(&truth),
+      mMask(mask),
+      mMinPtGeV(minPtGeV),
+      mRoadLayers([&] {
+        std::ranges::replace(roadLayers, std::uint64_t{0}, ~std::uint64_t{0});
+        return std::move(roadLayers);
+      }()),
+      mRowsOf(study::rowsOfParticles(truth.rows)),
+      mWalkIteration([&] {
+        for (std::size_t i = 0; i < mRoadLayers.size(); ++i) {
+          if ((mRoadLayers[i] & mask) == mask) {
+            return i;
+          }
+        }
+        return std::size_t{0};
+      }())
+  {
+    const auto chains = cuts.findable != nullptr ? study::particleLayers(truth.rows, *cuts.findable) : std::unordered_map<std::uint64_t, study::ParticleLayers>{};
+    for (auto& [particle, rows] : mRowsOf) {
+      const auto found = truth.particles.find(particle);
+      std::uint64_t layers = 0U;
+      for (const auto row : rows) {
+        layers |= std::uint64_t{1} << truth.rows[row].layer;
+      }
+      // The class's reach in pT: physical primaries in |eta| < 1, every one and
+      // those on every layer of the mask, in steps of 50 MeV to 1 GeV.
+      if (found != truth.particles.end() && found->second.origin == study::ParticleOrigin::kPhysicalPrimary && std::abs(found->second.eta) < 1.F) {
+        const auto bin = std::min<std::size_t>(static_cast<std::size_t>(found->second.pt / 0.05F), mReach.size() - 1U);
+        ++mReach[bin][0];
+        if ((layers & mMask) == mMask) {
+          ++mReach[bin][1];
+          mLowestPt = std::min(mLowestPt, static_cast<double>(found->second.pt));
+        }
+      }
+      if (found != truth.particles.end() && found->second.origin == study::ParticleOrigin::kPhysicalPrimary && static_cast<double>(found->second.pt) >= minPtGeV && (layers & mMask) == mMask && (cuts.pdg == 0 || std::abs(found->second.pdg) == cuts.pdg) && (cuts.findable == nullptr || (chains.contains(particle) && study::isFindable(found->second.pt, chains.at(particle), *cuts.findable)))) {
+        mIndex[particle] = static_cast<std::uint32_t>(mFindable.size());
+        mFindable.push_back(particle);
+      }
+      sortByTraversal(particle, rows);
+    }
+    mFate.assign(mFindable.size(), kNotFound);
+    mReason.assign(mFindable.size(), 0U);
+    mGraph.assign(mFindable.size(), kGraphReasons);
+    mStop.assign(mFindable.size(), kShortReasons);
+    mStopDetail.assign(mFindable.size(), 0U);
+    mStopLayer.assign(mFindable.size(), kInvalidLayerID);
+    mStopTaken.assign(mFindable.size(), kNoTaken);
+    mOutStop.assign(mFindable.size(), kShortReasons);
+    mOutStopLayer.assign(mFindable.size(), kInvalidLayerID);
+    mOutHolder.assign(mFindable.size(), kHolderKinds);
+    mOutRefitWrong.assign(mFindable.size(), 0U);
+    mOutRefitRows.assign(mFindable.size(), 0U);
+    mOutRefitRatio.assign(mFindable.size(), 0);
+    mRefitFailures.clear();
+    mRefitReplay.clear();
+    mOutRefitKink.assign(mFindable.size(), 3U);
+    mOutStopTaken.assign(mFindable.size(), kNoTaken);
+    mInNext.assign(mFindable.size(), 255U);
+    mOutNext.assign(mFindable.size(), 255U);
+    mInDropKink.assign(mFindable.size(), 255U);
+    mOutDropKink.assign(mFindable.size(), 255U);
+    mOutStepKink.assign(mFindable.size(), 255U);
+    mInStepKink.assign(mFindable.size(), 255U);
+    mLayersHeld.assign(mFindable.size(), 0U);
+    mMissedKink.assign(mFindable.size(), 3U);
+    mInChi2.assign(mFindable.size(), 0.F);
+    mOutChi2.assign(mFindable.size(), 0.F);
+    mInNextChi2.assign(mFindable.size(), 0.F);
+    mOutNextChi2.assign(mFindable.size(), 0.F);
+    mRecordLoss.assign(mFindable.size(), std::string{});
+    mFurthest.assign(mFindable.size(), kSeedNotEligible);
+  }
+
+  /// The CSV of the inward refit's states: each state of
+  /// the inward pass -- the seed, then each filtered state -- of the refits
+  /// failing inward and of a control of good low-momentum refits, against
+  /// the MC truth at the row.
+  void openInwardHistory(const std::string& csv)
+  {
+    mInwardCsv = std::make_unique<std::ofstream>(csv);
+    if (!*mInwardCsv) {
+      throw std::runtime_error("cannot write " + csv);
+    }
+    *mInwardCsv << "kind,particle,pt,pdg,n,status,failStep,k,row,layer,leg,p,pTrue,phi,phiTrue,theta,thetaTrue,sigQOverPRel,sigPhi,chi2,loc0,loc1,loc0True,loc1True,"
+                   "qOverP,charge,stepRoot\n";
+  }
+
+  /// The CSV of every follow walk's end, written after each iteration
+  /// (`endDecisions`).
+  void openEndDecisions(const std::string& csv)
+  {
+    mEndCsv = std::make_unique<std::ofstream>(csv);
+    if (!*mEndCsv) {
+      throw std::runtime_error("cannot write " + csv);
+    }
+    *mEndCsv << "track,iteration,direction,particle,pt,end,crossed,links,unconfirmedDrop,walked,bidKept,kept,lastRow,lastLayer,lastChi2,lastKink,lastKind,lastBeyond,"
+                "droppedRow,droppedLayer,droppedChi2,droppedKind,droppedBeyond,survives,refit,agrees,trackGood,trackCount,trackLayers,ownLayers,"
+                "endWindows,endSeen,endRefused,lastStepChi2,lastSqrtDet,lastRhoWindow,lastRhoLayer,lastReach,lastOverlapPS,lastBoxPS,lastRowPS,lastRest,"
+                "lastBeamWith,lastBeamWithout,lastFloatDet,lastFactorDet,"
+                "droppedStepChi2,droppedSqrtDet,droppedRhoWindow,droppedRhoLayer,droppedReach,droppedOverlapPS,droppedBoxPS,droppedRowPS,droppedRest,"
+                "droppedBeamWith,droppedBeamWithout,droppedFloatDet,droppedFactorDet,"
+                "endBeamChi2,endBeamPasses,refRefused,refStep,refRow,refKind,refLast,refAlt,refAltKind,refNew,refNewKind,lastRefChi2,lastRefPasses,refInvalid,"
+                "lastSearch,edit,editCount,editFit,editKept,editLayers\n";
+  }
+
+  /// The CSV of each track's end edits (`endDecisions`): the
+  /// track as it is, with its rows, and each truth-free edit of its ends.
+  void openEndEdits(const std::string& csv)
+  {
+    mEditCsv = std::make_unique<std::ofstream>(csv);
+    if (!*mEditCsv) {
+      throw std::runtime_error("cannot write " + csv);
+    }
+    *mEditCsv << "track,iteration,in,out,count,fit,kept,good,majority,layers,rows\n";
+  }
+
+  /// The MC kinematics (\a path, a `<prefix>_Kine.root` such as
+  /// `sgn_Kine.root`), each MC track's mother, for the clutter test's
+  /// lineage: every event read now through O2's reader, as
+  /// the test looks the mothers up from several threads.
+  void openKine(const std::string& path)
+  {
+    constexpr std::string_view kSuffix = "_Kine.root";
+    if (!path.ends_with(kSuffix) || !std::filesystem::exists(path)) {
+      throw std::runtime_error("--kine: no file " + path + " (a <prefix>_Kine.root)");
+    }
+    o2::steer::MCKinematicsReader reader(path.substr(0, path.size() - kSuffix.size()), o2::steer::MCKinematicsReader::Mode::kMCKine);
+    mMothers.resize(reader.getNEvents(0));
+    if (mMothers.empty()) {
+      throw std::runtime_error("--kine: no MC events in " + path);
+    }
+    for (std::size_t event = 0; event < mMothers.size(); ++event) {
+      const auto& tracks = reader.getTracks(0, static_cast<int>(event));
+      mMothers[event].reserve(tracks.size());
+      for (const auto& track : tracks) {
+        mMothers[event].push_back(track.getMotherTrackId());
+      }
+      // Only the mothers are kept: the reader's copy of the event goes.
+      reader.releaseTracksForSourceAndEvent(0, static_cast<int>(event));
+    }
+  }
+
+  /// The truth walk on iteration \a iteration instead of the first holding
+  /// the class's mask (for the inward steps into the VD of the iterations
+  /// starting outside it).
+  void setWalkIteration(std::size_t iteration) { mWalkIteration = iteration; }
+
+  /// The CSV of the truth walks' steps:
+  /// each step of every findable's walk along its own rows, inward from
+  /// the true road's refit and outward from its outward state, whatever the
+  /// step's chi2, against the cluster and the MC crossing.
+  void openTruthWalk(const std::string& csv)
+  {
+    mWalkCsv = std::make_unique<std::ofstream>(csv);
+    if (!*mWalkCsv) {
+      throw std::runtime_error("cannot write " + csv);
+    }
+    *mWalkCsv << "direction,iteration,particle,pt,eta,pdg,fromLayer,layer,status,r0,r1,i00,i11,p00,p11,chi2,c0,c1,kinkLocal,kinkUpstream,onLayer\n";
+  }
+
+  /// The fate of every particle of the class after the last iteration
+  /// observed: one CSV line each, for a comparison between runs.
+  void writeFates(const std::string& csv) const
+  {
+    std::ofstream out(csv);
+    if (!out) {
+      throw std::runtime_error("cannot write " + csv);
+    }
+    out << "particle,pt,eta,pdg,fate,layers,stop,stopLayer,outStop,outStopLayer,reason,crossed,rowsBack,overlaps,seedStage\n";
+    for (std::size_t index = 0; index < mFindable.size(); ++index) {
+      const auto found = mTruth->particles.find(mFindable[index]);
+      const float pt = found != mTruth->particles.end() ? found->second.pt : 0.F;
+      const float eta = found != mTruth->particles.end() ? found->second.eta : 0.F;
+      const int pdg = found != mTruth->particles.end() ? found->second.pdg : 0;
+      // The layers it crossed, its rows on later legs and its
+      // overlaps (-1 without a timed path), its last iteration's SeedStage.
+      std::uint64_t crossed = 0U;
+      int back = -1;
+      int overlaps = -1;
+      const auto& own = mRowsOf.at(mFindable[index]);
+      for (const auto row : own) {
+        crossed |= std::uint64_t{1} << mTruth->rows[row].layer;
+      }
+      if (!mLegs.empty() && mTimed[index] != 0U) {
+        back = 0;
+        overlaps = 0;
+        for (std::size_t k = 0; k < own.size(); ++k) {
+          back += mLegs[index][k] != 0U ? 1 : 0;
+          for (std::size_t j = 0; j < k; ++j) {
+            overlaps += mLegs[index][j] == mLegs[index][k] && mTruth->rows[own[j]].layer == mTruth->rows[own[k]].layer ? 1 : 0;
+          }
+        }
+      }
+      const int seedStage = mSeedStage.empty() ? -1 : static_cast<int>(mSeedStage.back()[index]);
+      out << std::format("{},{:.4f},{:.3f},{},{},{},{},{},{},{},{},{},{},{},{}\n", mFindable[index], static_cast<double>(pt), static_cast<double>(eta), pdg, static_cast<int>(mFate[index]), mLayersHeld[index], mFate[index] == kShortFate ? static_cast<int>(mStop[index]) : -1, mFate[index] == kShortFate && mStopLayer[index] < kLayers ? static_cast<int>(mStopLayer[index]) : -1, mFate[index] == kShortFate && mStop[index] == kGapInside ? static_cast<int>(mOutStop[index]) : -1, mFate[index] == kShortFate && mOutStopLayer[index] < kLayers ? static_cast<int>(mOutStopLayer[index]) : -1, mFate[index] == kNotFound ? static_cast<int>(mReason[index]) : -1, crossed, back, overlaps, seedStage);
+    }
+  }
+
+  /// The CSV of the replayed steps, if \a csv is given; the MC hits, if
+  /// \a hits is, which the steps and the true kinks are held to.
+  void open(const std::string& csv, const std::string& hits, const std::string& discHits = {})
+  {
+    if (!csv.empty()) {
+      mCsv = std::make_unique<std::ofstream>(csv);
+      if (!*mCsv) {
+        throw std::runtime_error("cannot write " + csv);
+      }
+      *mCsv << "kind,particle,iteration,layer,pt,pdg,labels,rowsOnLayer,chi2,r0,r1,v00,v01,v11,p00,p01,p11,hit,c0,c1,q0,q1,dphi,dtheta,pphi,ptheta,hitP,stateP,"
+               "startHit,sdphi,sdtheta,sphi,stheta,staveKink,stavePhiKink,staveTheta0,staveX2x0,ref,chi2NoBeam,qn0,qn1,pn00,pn11,chi2Joint,qj0,qj1,pj00,pj11\n";
+    }
+    if (!hits.empty()) {
+      if constexpr (std::is_same_v<Det, detectors::TRKFT3>) {
+        mHits = std::make_unique<study::HitFile>(hits, study::Chips::kTRK, discHits); // FT3's hits beside TRK's (the disc crossings)
+      } else if constexpr (std::is_same_v<Det, detectors::ITS>) {
+        mHits = std::make_unique<study::HitFile>(hits, study::Chips::kITS);
+      } else if constexpr (std::is_same_v<Det, detectors::MFT>) {
+        mHits = std::make_unique<study::HitFile>(hits, study::Chips::kMFT);
+      } else {
+        throw std::runtime_error("--hits: no MC hits for this detector");
+      }
+      // Every event read now: the truth walks look the segments up from
+      // several threads, which must find them and never read.
+      for (int event = 0; event < mHits->nEvents(); ++event) {
+        static_cast<void>(mHits->event(event));
+      }
+      // Each MC track's segments, for `segmentOf` (the path order looks up
+      // every row of every particle).
+      for (int event = 0; event < mHits->nEvents(); ++event) {
+        for (const auto& segment : mHits->event(event)) {
+          mSegmentsOf[segmentKey(event, segment.track)].push_back(&segment);
+        }
+      }
+    }
+  }
+
+  template <typename Observation, typename Material>
+  void observe(const Observation& iteration, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    Phases phases;
+    const auto now = [] { return std::chrono::steady_clock::now(); };
+    const auto seconds = [](auto from, auto to) { return std::chrono::duration<double>(to - from).count(); };
+    auto clock = now();
+    if (mHits && !mPathOrdered) {
+      pathOrder(frame);
+      mPathOrdered = true;
+    }
+    if (mHits && !mKinksDone) {
+      trueKinks(frame, material, propagator);
+      mKinksDone = true;
+      phases.kinks = seconds(clock, now());
+      clock = now();
+    }
+    if (mCells.empty()) {
+      mCells = SensorCells<Det>(geometry);
+    }
+    if (mMaxWidthPS.empty()) {
+      mMaxWidthPS.assign(kLayers, 0U);
+      const auto columns = frame.measurements();
+      for (std::uint32_t row = 0; row < mTruth->rows.size(); ++row) {
+        const auto layer = mTruth->rows[row].layer;
+        mMaxWidthPS[layer] = std::max(mMaxWidthPS[layer], columns.widthPS[row]);
+        auto& bounds = mBounds[layer];
+        bounds.varZ = std::max(bounds.varZ, columns.varZ[row]);
+        bounds.varR = std::max(bounds.varR, columns.varR[row]);
+        bounds.varRPhi = std::max(bounds.varRPhi, columns.varRPhi[row]);
+      }
+    }
+    // The truth walk once, on the first iteration whose road layers hold
+    // the class's mask -- its road is then the class's whole chain, the
+    // barrel-to-the-rest leg included -- else on the first.
+    if (mHits && !mWalkDone && iteration.iteration == mWalkIteration) {
+      truthWalk(iteration.iteration, parameters, frame, geometry, material, propagator);
+      mWalkDone = true;
+      phases.walk = seconds(clock, now());
+      clock = now();
+    }
+    const auto view = iteration.tracks->view();
+    const auto tracks = iteration.tracks->size();
+    std::vector<std::uint32_t> holder(mTruth->rows.size(), kNoTrack);
+    std::vector<std::uint64_t> particles(tracks);
+    std::unordered_map<std::uint64_t, std::uint32_t> goodTrack;
+    for (std::size_t track = 0; track < tracks; ++track) {
+      const std::span<const std::uint32_t> rows{view.clusters[track].index, view.count[track]};
+      particles[track] = study::goodParticle(mTruth->rows, rows);
+      for (const auto row : rows) {
+        holder[row] = static_cast<std::uint32_t>(track);
+      }
+      if (particles[track] != study::kNoTrackParticle) {
+        goodTrack.emplace(particles[track], static_cast<std::uint32_t>(track));
+      }
+    }
+    // The iteration's follow of its own tracks; with followEarlier the
+    // earlier tracks' before it, from the previous observation's snapshot.
+    // The mask as the follow read it: the tracker's copy, taken with the
+    // starting states. An iteration without a follow has no copy
+    // and no proposals: the mask after it, which nothing replays.
+    std::vector<std::uint8_t> ownUsed = iteration.followUsed.empty() ? std::vector<std::uint8_t>(iteration.used.begin(), iteration.used.end()) : std::vector<std::uint8_t>(iteration.followUsed.begin(), iteration.followUsed.end());
+    mFollowUsedNow = ownUsed;
+    const auto replayed = replayExtension(iteration, iteration.trackOffset, static_cast<std::uint32_t>(tracks), iteration.proposals, iteration.kinkSteps, ownUsed, false, parameters, frame, geometry, material, propagator);
+    std::vector<Replay> recovered;
+    if (!iteration.earlierProposals.empty() && iteration.earlierProposals.size() == mSnapshot.size()) {
+      recovered = replayExtension(iteration, 0U, iteration.trackOffset, iteration.earlierProposals, iteration.earlierKinkSteps, mSnapshotUsed, true, parameters, frame, geometry, material, propagator);
+    }
+    phases.replay = seconds(clock, now());
+    clock = now();
+    const auto replayOf = [&](std::uint32_t track) -> const Replay* {
+      if (track >= iteration.trackOffset) {
+        return track - iteration.trackOffset < replayed.size() ? &replayed[track - iteration.trackOffset] : nullptr;
+      }
+      return track < recovered.size() ? &recovered[track] : nullptr;
+    };
+
+    // The fate is decided anew each iteration; a short track's diagnosis is
+    // made once, when the iteration that made it is observed (the only one
+    // replaying it without followEarlier), and kept: the fields below are
+    // reset per track where it is replayed, not here (else a track made by an
+    // earlier pass reads "not replayed").
+    std::fill(mFate.begin(), mFate.end(), kNotFound);
+    mLastGate = parameters.clusterChi2Max;
+    mLayersFound = {};
+    // The graph audit's histograms are the iteration's, like the fates.
+    mAuditFloor = iteration.iteration < mFloors.size() ? mFloors[iteration.iteration] : 0.;
+    if (mTrackOffsets.size() <= iteration.iteration) {
+      // An iteration not observed made no tracks: the last
+      // offset, which keeps the list sorted for the holders' lookup.
+      mTrackOffsets.resize(iteration.iteration + 1U, mTrackOffsets.empty() ? 0U : mTrackOffsets.back());
+    }
+    mTrackOffsets[iteration.iteration] = iteration.trackOffset;
+    mFakeHolders.clear();
+    mCurvatureTriplets.clear();
+    mLinkRangeRefusals.clear();
+    mPairRefusals.clear();
+    mRoadFitRefusals.clear();
+    for (std::uint32_t index = 0; index < mFindable.size(); ++index) {
+      const auto particle = mFindable[index];
+      const auto& own = mRowsOf.at(particle);
+      const auto good = goodTrack.find(particle);
+      mLayersHeld[index] = 0U;
+      if (good == goodTrack.end()) {
+        mReason[index] = missedReason(own, holder, particles, iteration.iteration, parameters, frame, geometry, material, propagator);
+        if (mReason[index] == kLostToFake) {
+          // The fake holding the first of its road rows: the iteration that
+          // made it (whose fakes take the rows).
+          for (const auto row : roadRows(own, iteration.iteration)) {
+            if (holder[row] != kNoTrack && particles[holder[row]] == study::kNoTrackParticle) {
+              const auto made = static_cast<std::size_t>(std::upper_bound(mTrackOffsets.begin(), mTrackOffsets.end(), holder[row]) - mTrackOffsets.begin());
+              const double pt = truePt(mTruth->particles.find(particle));
+              ++mFakeHolders[std::format("pT {} the floor, a fake of iteration {}", pt >= mAuditFloor ? "at or above" : "below", made == 0U ? 0U : made - 1U)];
+              break;
+            }
+          }
+        }
+        if (mReason[index] == kNoRoad || mReason[index] == kRoadTime) {
+          mGraph[index] = graphAudit(roadRows(own, iteration.iteration), parameters, frame, particle);
+        } else if (mReason[index] == kRoadChi2 || mReason[index] == kBeamLine) {
+          // The road refused whole: its largest true kink over the road's
+          // layers, for the floor split.
+          const auto road = roadRows(own, iteration.iteration);
+          const auto kink = largestKink(particle, mTruth->rows[road.front()].layer, mTruth->rows[road.back()].layer);
+          mMissedKink[index] = kinkBin(kink);
+          const auto found = mTruth->particles.find(particle);
+          const double floor = iteration.iteration < mFloors.size() ? mFloors[iteration.iteration] : 0.;
+          if (mReason[index] == kRoadChi2 && found != mTruth->particles.end() && static_cast<double>(found->second.pt) >= floor) {
+            describeRefusedRoad(found->second, kink, road, parameters, frame, geometry, material, propagator);
+          }
+        }
+        continue;
+      }
+      const auto track = good->second;
+      std::uint64_t layers = 0U;
+      LayerID innermost = std::numeric_limits<LayerID>::max();
+      for (std::uint8_t i = 0; i < view.count[track]; ++i) {
+        const auto layer = mTruth->rows[view.clusters[track].index[i]].layer;
+        layers |= std::uint64_t{1} << layer;
+        innermost = std::min(innermost, layer);
+      }
+      mLayersHeld[index] = layers;
+      ++mLayersFound[static_cast<std::size_t>(std::popcount(layers & mMask))];
+      const auto missing = mMask & ~layers;
+      if (missing == 0U) {
+        mFate[index] = kComplete;
+        // The control of the refit's increments: a complete track this
+        // iteration followed outward, its refit kept.
+        if (const Replay* replay = replayOf(track); replay != nullptr && !replay->outward.empty() && replay->outward.front().kept != 0U && replay->outward.front().refit == kRefitKept) {
+          addIncrements(mKeptIncrements, replay->outward.front());
+        }
+        // The inward states' control: a good refit of a
+        // low-momentum track, the follow's rows in it.
+        if (const Replay* replay = replayOf(track); mHits && replay != nullptr && replay->refit == kRefitKept && replay->refitCount != 0U && pathPtBin(particle) < 3U) {
+          inwardStudy(kInwardControl, particle, replay->refitRows, parameters, frame, geometry, material, propagator);
+        }
+        continue;
+      }
+      mFate[index] = kShortFate;
+      const Replay* replay = replayOf(track);
+      if (replay == nullptr) {
+        // Diagnosed when its iteration was observed; that diagnosis stands.
+        continue;
+      }
+      mStopTaken[index] = kNoTaken;
+      mOutStop[index] = kShortReasons;
+      mOutStopLayer[index] = kInvalidLayerID;
+      mOutHolder[index] = kHolderKinds;
+      mOutStopTaken[index] = kNoTaken;
+      mInNext[index] = 255U;
+      mOutNext[index] = 255U;
+      mInDropKink[index] = 255U;
+      mOutDropKink[index] = 255U;
+      mOutStepKink[index] = 255U;
+      mInStepKink[index] = 255U;
+      if ((missing >> innermost) != 0U) {
+        mStop[index] = kGapInside;
+        mStopLayer[index] = kInvalidLayerID;
+        // Outward: the first layer of the mask it misses
+        // outward of its innermost, decided at the outward walk's step from
+        // the track's layer nearest below it.
+        if (!replay->outward.empty()) {
+          const auto gap = static_cast<LayerID>(std::countr_zero(missing & (~std::uint64_t{0} << innermost)));
+          const auto below = layers & ((std::uint64_t{1} << gap) - 1U);
+          const auto outside = static_cast<LayerID>(63 - std::countl_zero(below));
+          const auto ownRow = ownRowOn(particle, gap);
+          mOutStop[index] = stopReason(replay->outward.front(), ownRow, outside, particle, mStopDetail[index]);
+          mOutStepKink[index] = kinkBin(largestKink(particle, outside, gap));
+          mOutStopLayer[index] = gap;
+          if (mOutStop[index] == kWindow || mOutStop[index] == kNotQueried) {
+            const auto& out = replay->outward.front();
+            const auto step = std::ranges::find(out.steps, outside, &Step::layer);
+            if (step != out.steps.end()) {
+              std::array<float, 4> offsets{};
+              const auto kind = mOutStop[index] == kWindow ? 0U : 1U;
+              ++mOutWindowAudit[kind][windowAudit(*step, ownRow, gap, parameters, frame, geometry, material, propagator, PropagationDirection::kForward, &offsets)];
+              mOutWindowOffsets[kind].push_back(offsets);
+            }
+          }
+          if (mOutStop[index] == kRefitFailed) {
+            const auto& out = replay->outward.front();
+            ++mRefitFailures[std::format("{} / pass {} / layer {}", static_cast<int>(out.refitStatus), static_cast<int>(out.refitFailedPass), static_cast<int>(out.refitFailedLayer))];
+            ++mRefitFailures[std::format("trimmed: {} of {} outward rows kept, chi2 {}", out.refitTrimmedKept, out.kept, out.refitTrimmedChi2 ? "under" : "over")];
+            std::uint32_t wrong = 0U;
+            for (std::uint32_t i = 0; i < out.kept; ++i) {
+              wrong += mTruth->rows[out.raw[i]].carries(particle) ? 0U : 1U;
+            }
+            const char* rows = wrong == 0U ? "own rows" : (wrong == 1U ? "1 wrong row" : "2+ wrong rows");
+            ++mRefitReplay[std::format("{} | 1. all", rows)];
+            if (mHits && out.refitFailedPass == FitPass::kInward) {
+              inwardStudy(wrong == 0U ? kInwardOwn : kInwardWrong, particle, replay->refitRows, parameters, frame, geometry, material, propagator);
+            }
+            const auto& step = out.failedStep;
+            if (!step.replayed) {
+              ++mRefitReplay[std::format("{} | 2. not replayed", rows)];
+            } else {
+              ++mRefitReplay[std::format("{} | 2. pass {}: status {}", rows, static_cast<int>(out.refitFailedPass), static_cast<int>(step.state))];
+              const auto missBin = [](float miss) {
+                constexpr std::array<float, 4> kEdges{0.01F, 0.1F, 0.5F, 2.F};
+                constexpr std::array<const char*, 5> kNames{"< 0.01", "0.01-0.1", "0.1-0.5", "0.5-2", ">= 2"};
+                return kNames[static_cast<std::size_t>(std::ranges::upper_bound(kEdges, miss) - kEdges.begin())];
+              };
+              ++mRefitReplay[std::format("{} | 4. pass {}: failing step {} (1: the first from the pass's start), seed's miss of its first row [cm] {}", rows, static_cast<int>(out.refitFailedPass), std::min(step.step, 4), missBin(step.startMiss))];
+              if (step.barrel) {
+                const auto found = mTruth->particles.find(particle);
+                const double trueReach = found != mTruth->particles.end() ? 2. / std::abs(propagator.curvature(1.F / found->second.pt, 1.F)) : 0.;
+                const auto bin = [](double value) {
+                  constexpr std::array<double, 7> kEdges{-20., -5., -1., 0., 1., 5., 20.};
+                  constexpr std::array<const char*, 8> kNames{"< -20", "-20..-5", "-5..-1", "-1..0", "0..1", "1..5", "5..20", ">= 20"};
+                  return kNames[static_cast<std::size_t>(std::ranges::upper_bound(kEdges, value) - kEdges.begin())];
+                };
+                ++mRefitReplay[std::format("{} | 3a. pass {}: far side beyond the plane [cm] {}", rows, static_cast<int>(out.refitFailedPass), bin(static_cast<double>(step.farMargin)))];
+                ++mRefitReplay[std::format("{} | 3b. pass {}: plane beyond the near side {}", rows, static_cast<int>(out.refitFailedPass), bin(static_cast<double>(step.nearMargin)))];
+                ++mRefitReplay[std::format("{} | 3c. true 2R - plane distance {}", rows, bin(trueReach - static_cast<double>(step.planeDistance)))];
+              }
+            }
+          }
+          if (mOutStop[index] == kRefitChi2) {
+            // The rows the refit took outward: how many not the particle's,
+            // and its chi2 against the cut.
+            const auto& out = replay->outward.front();
+            std::uint32_t wrong = 0U;
+            for (std::uint32_t i = 0; i < out.kept; ++i) {
+              wrong += mTruth->rows[out.raw[i]].carries(particle) ? 0U : 1U;
+            }
+            mOutRefitWrong[index] = static_cast<std::uint8_t>(std::min(wrong, 2U) + (std::ranges::any_of(out.steps, &Step::kink) ? 3U : 0U));
+            mOutRefitRows[index] = static_cast<std::uint8_t>(out.kept);
+            // The particle's largest true kink from the road's first layer to the last outward row's.
+            const auto last = out.kept == 0U ? gap : mTruth->rows[out.raw[out.kept - 1U]].layer;
+            const auto kink = largestKink(particle, mTruth->rows[out.road.index[0]].layer, last);
+            mOutRefitKink[index] = kinkBin(kink);
+            if (wrong == 0U) {
+              addIncrements(mRefusedIncrements, out);
+            }
+            mOutRefitRatio[index] = out.refitChi2Max > 0 ? out.refitChi2 / out.refitChi2Max : 0;
+          }
+          // Who has the own row there at the end: none, a fake, another
+          // particle's good track, another track of its own; of this
+          // iteration or an earlier one.
+          if (ownRow == kNoTrack) {
+            mOutHolder[index] = kNoOwnRow;
+          } else if (holder[ownRow] == kNoTrack) {
+            mOutHolder[index] = kRowFree;
+          } else {
+            const auto by = holder[ownRow];
+            const std::uint8_t kind = particles[by] == study::kNoTrackParticle ? kHeldByFake : (particles[by] == particle ? kHeldByOwn : kHeldByOther);
+            mOutHolder[index] = static_cast<std::uint8_t>(kind + (by >= iteration.trackOffset ? std::uint8_t{kThisIteration} : std::uint8_t{0U}));
+          }
+          mOutStopTaken[index] = takenKind(replay->outward.front(), ownRow, outside, particle);
+          mOutChi2[index] = candidateChi2(replay->outward.front(), ownRow, outside);
+          // A direct unconfirmed drop: the step took the own row and nothing later
+          // (the bid, a witness, the refit) accounts for its loss.
+          if (mOutStopTaken[index] == kOwnDropped && (mOutStop[index] == kOtherTaken || mOutStop[index] == kLookaheadOther)) {
+            std::tie(mOutNext[index], mOutNextChi2[index]) = afterDrop(replay->outward.front(), ownRow, particle);
+            // The particle's true deflection over the step that refused its
+            // next row: between its crossings of the dropped row's layer
+            // and the next.
+            mOutDropKink[index] = kinkBin(largestKink(particle, gap, static_cast<LayerID>(gap + 1U)));
+            if (mOutNext[index] == static_cast<std::uint8_t>(StepOutcome::kPasses) && mDebugDrops < 5U) {
+              ++mDebugDrops;
+              dumpWalk(replay->outward.front(), particle, ownRow);
+            }
+          }
+        }
+        continue;
+      }
+      // The first layer inward of the track's innermost that it misses.
+      auto target = static_cast<LayerID>(innermost - 1U);
+      while (((missing >> target) & 1U) == 0U) {
+        --target;
+      }
+      std::uint32_t row = kNoTrack;
+      for (const auto candidate : own) {
+        if (mTruth->rows[candidate].layer == target) {
+          row = candidate;
+          break;
+        }
+      }
+      mStop[index] = stopReason(*replay, row, static_cast<LayerID>(target + 1U), particle, mStopDetail[index]);
+      mStopLayer[index] = target;
+      mStopTaken[index] = takenKind(*replay, row, static_cast<LayerID>(target + 1U), particle);
+      mInChi2[index] = candidateChi2(*replay, row, static_cast<LayerID>(target + 1U));
+      if (mStopTaken[index] == kOwnDropped && (mStop[index] == kOtherTaken || mStop[index] == kLookaheadOther)) {
+        std::tie(mInNext[index], mInNextChi2[index]) = afterDrop(*replay, row, particle);
+        mInDropKink[index] = target == 0U ? std::uint8_t{3U} : kinkBin(largestKink(particle, static_cast<LayerID>(target - 1U), target));
+        // And over the step before, the one that took the dropped row (an
+        // upstream scatter the position update absorbed, not the direction).
+        mInStepKink[index] = kinkBin(largestKink(particle, target, static_cast<LayerID>(target + 1U)));
+      }
+      if (mStop[index] == kWindow || mStop[index] == kNotQueried) {
+        const auto step = std::ranges::find(replay->steps, static_cast<LayerID>(target + 1U), &Step::layer);
+        if (step != replay->steps.end()) {
+          ++mWindowAudit[mStop[index] == kWindow ? 0U : 1U][windowAudit(*step, row, target, parameters, frame, geometry, material, propagator, PropagationDirection::kBackward)];
+        }
+      }
+    }
+    pathReport(iteration, goodTrack, replayOf);
+    seedingFunnel(iteration, parameters, frame, geometry, material, propagator, holder, particles, goodTrack);
+    phases.diagnosis = seconds(clock, now());
+    clock = now();
+    progress(iteration.iteration);
+    // The control: each step a complete track of this iteration took onto its
+    // particle's own row, from the state the proposal had.
+    if (mCsv) {
+      for (std::uint32_t index = 0; index < mFindable.size(); ++index) {
+        const auto good = goodTrack.find(mFindable[index]);
+        if (good == goodTrack.end() || replayOf(good->second) == nullptr) {
+          continue;
+        }
+        const auto& replay = *replayOf(good->second);
+        const char* kind = mFate[index] == kComplete ? "control" : nullptr;
+        for (std::size_t stepIndex = 0; stepIndex < replay.steps.size(); ++stepIndex) {
+          const auto& step = replay.steps[stepIndex];
+          const auto own = ownRowOn(mFindable[index], static_cast<LayerID>(step.layer - 1U));
+          if (own == kNoTrack) {
+            continue;
+          }
+          const auto seen = std::ranges::find(step.candidates, own, &Candidate::row);
+          const bool refused = mFate[index] == kShortFate && step.choice != own;
+          if (kind == nullptr && !refused) {
+            continue;
+          }
+          const char* label = kind;
+          if (refused) {
+            label = seen == step.candidates.end() ? "notQueried" : kOutcomeNames[static_cast<std::size_t>(seen->outcome)];
+          }
+          record(label, mFindable[index], iteration.iteration, replay, stepIndex, own, seen == step.candidates.end() ? -1.F : seen->chi2, parameters, frame, geometry, material, propagator);
+        }
+      }
+    }
+    std::array<double, 5> rest{};
+    fakeTransitions(iteration, replayed, recovered);
+    if (!mMothers.empty()) {
+      clutterStudy(iteration, replayed, parameters, frame, geometry, material, propagator);
+      decisionStudy(iteration, replayed, parameters, frame, geometry, material, propagator, goodTrack);
+    }
+    blockerStudy(iteration, holder, particles);
+    rest[0] = seconds(clock, now());
+    clock = now();
+    endEvidence(iteration, replayed);
+    rest[1] = seconds(clock, now());
+    clock = now();
+    lookaheadPairs(iteration, replayed);
+    rest[2] = seconds(clock, now());
+    clock = now();
+    endPolicies(iteration, replayed, parameters);
+    if (mEndCsv) {
+      endDecisions(iteration, replayed, parameters, frame, geometry, material, propagator);
+    }
+    if (mHits) {
+      holeCalls(iteration, replayed, parameters, geometry, propagator);
+      ownSteps(iteration, replayed, parameters);
+    }
+    rest[3] = seconds(clock, now());
+    clock = now();
+    if (parameters.kinkScale2 > 1.F) {
+      roadEndAudit(iteration, parameters, frame, geometry, material, propagator);
+    }
+    rest[4] = seconds(clock, now());
+    std::cout << std::format(
+      "  anatomy after iteration {} [s]: true kinks {:.1f}, truth walk {:.1f}, replay {:.1f}, diagnosis {:.1f}, fakes {:.1f}, evidence {:.1f}, pairs {:.1f}, "
+      "ends {:.1f}, road ends {:.1f}\n",
+      iteration.iteration, phases.kinks, phases.walk, phases.replay, phases.diagnosis, rest[0], rest[1], rest[2], rest[3], rest[4]);
+    // What the next iteration's follow of the earlier tracks starts from
+    // (followEarlier): the tracks and the mask as this one leaves them.
+    mSnapshot.resize(tracks);
+    for (std::size_t track = 0; track < tracks; ++track) {
+      mSnapshot[track] = {.clusters = view.clusters[track], .count = view.count[track], .state = view.state[track], .outwardState = view.outwardState[track]};
+    }
+    mSnapshotUsed.assign(iteration.used.begin(), iteration.used.end());
+  }
+
+  /// How far an iteration took a particle of the class not found before it,
+  /// in the funnel's order: eligible -- its floor, and
+  /// own rows free on as many of the iteration's road layers as its seeds
+  /// hold -- a record of its own (the road fit and the floor passed), that
+  /// record selected, and then kept good, kept as a fake (its follow took a
+  /// wrong row), or dropped (the length cut after the follow). A pure road
+  /// before the fit is the funnel's (`printSeeding`).
+  enum SeedStage : std::uint8_t { kSeedFoundBefore,
+                                  kSeedNotEligible,
+                                  kSeedEligible,
+                                  kSeedRecord,
+                                  kSeedSelected,
+                                  kSeedDropped,
+                                  kSeedKeptFake,
+                                  kSeedKept,
+                                  kSeedStages };
+  static constexpr std::array<const char*, kSeedStages> kSeedStageNames{"found before", "not eligible", "eligible", "a record of its own, not selected", "selected", "selected, dropped", "selected, kept as a fake", "selected, kept good"};
+
+  /// `SeedStage` of every class particle in \a iteration, and for the ones
+  /// dropped the follow replayed from their record (`replayDropped`).
+  template <typename Observation, typename Material>
+  void seedingFunnel(const Observation& iteration, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator, const std::vector<std::uint32_t>& holder, const std::vector<std::uint64_t>& particles, const std::unordered_map<std::uint64_t, std::uint32_t>& goodTrack)
+  {
+    const auto it = iteration.iteration;
+    if (mSeedStage.size() <= it) {
+      mSeedStage.resize(it + 1U);
+      mMinClusters.resize(it + 1U, 0U);
+      mDropped.resize(it + 1U);
+    }
+    mMinClusters[it] = parameters.minClusters;
+    auto& stage = mSeedStage[it];
+    stage.assign(mFindable.size(), kSeedNotEligible);
+    for (std::uint32_t track = 0; track < iteration.trackOffset && track < particles.size(); ++track) {
+      if (const auto found = mIndex.find(particles[track]); found != mIndex.end()) {
+        stage[found->second] = kSeedFoundBefore;
+      }
+    }
+    const double floor = it < mFloors.size() ? mFloors[it] : 0.;
+    const std::uint64_t roadLayers = it < mRoadLayers.size() ? mRoadLayers[it] : ~std::uint64_t{0};
+    // Eligible on the mask the previous iteration left: with followEarlier
+    // the earlier tracks' follow takes rows before this iteration's seeds,
+    // which read free here (the observation carries no mask at seeding).
+    for (std::uint32_t index = 0; index < mFindable.size(); ++index) {
+      if (stage[index] == kSeedFoundBefore) {
+        continue;
+      }
+      const auto found = mTruth->particles.find(mFindable[index]);
+      if (found == mTruth->particles.end() || static_cast<double>(found->second.pt) < floor) {
+        continue;
+      }
+      std::uint64_t free = 0U;
+      for (const auto row : mRowsOf.at(mFindable[index])) {
+        const auto bit = std::uint64_t{1} << mTruth->rows[row].layer;
+        free |= (roadLayers & bit) != 0U && (mSnapshotUsed.empty() || mSnapshotUsed[row] == kFree) ? bit : 0U;
+      }
+      stage[index] = std::cmp_greater_equal(std::popcount(free), parameters.minClusters) ? kSeedEligible : kSeedNotEligible;
+    }
+    // The records of their own, and the selected ones.
+    const auto& selection = *iteration.selection;
+    const auto records = selection.records();
+    std::vector<std::uint8_t> chosen(static_cast<std::size_t>(selection.recordCount()), 0U);
+    for (const auto record : selection.selected()) {
+      chosen[static_cast<std::size_t>(record)] = 1U;
+    }
+    std::vector<std::uint32_t> selectedRecord(mFindable.size(), kNoTrack);
+    std::vector<std::uint32_t> bestRecord(mFindable.size(), kNoTrack); // its own, not selected: the best by the quality key
+    for (std::size_t record = 0; record < chosen.size(); ++record) {
+      const std::span<const std::uint32_t> rows{records.clusters[record].index, records.count[record]};
+      const auto found = mIndex.find(study::goodParticle(mTruth->rows, rows));
+      if (found == mIndex.end() || stage[found->second] == kSeedFoundBefore) {
+        continue;
+      }
+      auto& one = stage[found->second];
+      one = std::max<std::uint8_t>(one, chosen[record] != 0U ? kSeedSelected : kSeedRecord);
+      if (chosen[record] != 0U) {
+        selectedRecord[found->second] = static_cast<std::uint32_t>(record);
+      } else if (auto& best = bestRecord[found->second]; best == kNoTrack || selection::qualityKey(records.count[record], records.kinks[record], records.chi2[record]) < selection::qualityKey(records.count[best], records.kinks[best], records.chi2[best])) {
+        best = static_cast<std::uint32_t>(record);
+      }
+    }
+    recordLosses(iteration, stage, bestRecord, chosen);
+    beamLineStudy(iteration, stage, parameters, frame, geometry, material, propagator);
+    std::vector<std::uint32_t> dropped;
+    for (std::uint32_t index = 0; index < mFindable.size(); ++index) {
+      const auto good = goodTrack.find(mFindable[index]);
+      if (good != goodTrack.end() && good->second >= iteration.trackOffset) {
+        stage[index] = kSeedKept;
+        continue;
+      }
+      if (selectedRecord[index] == kNoTrack) {
+        continue;
+      }
+      const auto first = records.clusters[selectedRecord[index]].index[0];
+      const auto by = holder[first];
+      if (by != kNoTrack && by >= iteration.trackOffset) {
+        stage[index] = particles[by] == mFindable[index] ? kSeedKept : kSeedKeptFake;
+      } else {
+        stage[index] = kSeedDropped;
+        dropped.push_back(index);
+      }
+      if (mKeepFollowLoss && (stage[index] == kSeedDropped || stage[index] == kSeedKeptFake)) {
+        mFollowLossRows.push_back(followLoss(iteration, index, stage[index], selectedRecord[index], stage[index] == kSeedKeptFake ? by : kNoTrack, parameters, frame));
+      }
+    }
+    for (std::uint32_t index = 0; index < mFindable.size(); ++index) {
+      if (stage[index] != kSeedFoundBefore) {
+        mFurthest[index] = std::max(mFurthest[index], stage[index]);
+      }
+    }
+    replayDropped(iteration, dropped, selectedRecord, parameters, frame, geometry, material, propagator);
+    // The drops' verdicts, from the replay.
+    for (auto i = mFollowLossRows.size(); mKeepFollowLoss && i-- > 0U && mFollowLossRows[i].iteration == iteration.iteration;) {
+      if (mFollowLossRows[i].stage == kSeedDropped) {
+        const auto why = mLastDropWhy.find(mFollowLossRows[i].index);
+        mFollowLossRows[i].why = why != mLastDropWhy.end() ? why->second : std::string{"not replayed"};
+      }
+    }
+  }
+
+  /// Why a class particle's own records lost the selection:
+  /// its best own record (the quality key's) against the selected records
+  /// sharing a row with it, the best of them by the same key -- another
+  /// particle's good record, a fake most of whose rows are this particle's,
+  /// or another's fake; and how it ranks: longer, as long with fewer kinks,
+  /// as long and kinks with a lower chi2, or ranked below the loser (the
+  /// selection is not a plain greedy order) -- or no selected record shares a
+  /// row. Kept per particle from the last iteration where it had a record
+  /// and none selected; `printRecordLosses` tallies the missed.
+  template <typename Observation>
+  void recordLosses(const Observation& iteration, const std::vector<std::uint8_t>& stage, const std::vector<std::uint32_t>& bestRecord, const std::vector<std::uint8_t>& chosen)
+  {
+    const auto records = iteration.selection->records();
+    // The selected records by row, once.
+    std::unordered_map<std::uint32_t, std::uint32_t> selectedByRow;
+    for (std::size_t record = 0; record < chosen.size(); ++record) {
+      if (chosen[record] == 0U) {
+        continue;
+      }
+      for (std::uint8_t i = 0; i < records.count[record]; ++i) {
+        selectedByRow[records.clusters[record].index[i]] = static_cast<std::uint32_t>(record);
+      }
+    }
+    for (std::uint32_t index = 0; index < mFindable.size(); ++index) {
+      if (stage[index] != kSeedRecord || bestRecord[index] == kNoTrack) {
+        continue;
+      }
+      const auto own = bestRecord[index];
+      const auto ownKey = selection::qualityKey(records.count[own], records.kinks[own], records.chi2[own]);
+      // The selection prunes a record holding a row an earlier iteration's
+      // track took before its first round (`selection::Prune`); read on the
+      // mask the previous iteration left, which misses the rows a
+      // followEarlier follow takes before the seeds.
+      if (!mSnapshotUsed.empty() && std::ranges::any_of(std::span<const std::uint32_t>{records.clusters[own].index, records.count[own]}, [&](std::uint32_t row) { return mSnapshotUsed[row] != kFree; })) {
+        mRecordLoss[index] = "a row taken by an earlier iteration";
+        continue;
+      }
+      std::uint32_t winner = kNoTrack;
+      std::size_t shared = 0U;
+      for (std::uint8_t i = 0; i < records.count[own]; ++i) {
+        const auto at = selectedByRow.find(records.clusters[own].index[i]);
+        if (at == selectedByRow.end()) {
+          continue;
+        }
+        ++shared;
+        if (winner == kNoTrack || selection::qualityKey(records.count[at->second], records.kinks[at->second], records.chi2[at->second]) < selection::qualityKey(records.count[winner], records.kinks[winner], records.chi2[winner])) {
+          winner = at->second;
+        }
+      }
+      if (winner == kNoTrack) {
+        mRecordLoss[index] = "no selected record shares a row";
+        continue;
+      }
+      const std::span<const std::uint32_t> rows{records.clusters[winner].index, records.count[winner]};
+      const auto good = study::goodParticle(mTruth->rows, rows);
+      const char* kind = good != study::kNoTrackParticle ? "another's good record" : study::majorityParticle(mTruth->rows, rows).particle == mFindable[index] ? "a fake mostly its own"
+                                                                                                                                                              : "another's fake";
+      const auto winnerKey = selection::qualityKey(records.count[winner], records.kinks[winner], records.chi2[winner]);
+      const char* why = winnerKey > ownKey ? "ranked below it" : records.count[winner] > records.count[own] ? "longer"
+                                                               : records.kinks[winner] < records.kinks[own] ? "as long, fewer kinks"
+                                                               : winnerKey < ownKey                         ? "as long, lower chi2"
+                                                                                                            : "tied, the cluster set";
+      mRecordLoss[index] = std::format("{} | {} | {} of {} rows shared", kind, why, shared, records.count[own]);
+    }
+  }
+
+  /// One class particle's own road in a pass with the beam constraint: its own free rows on the pass's
+  /// road layers, the first crossing of each, fitted as the road fit does;
+  /// for an accepted road above its floor, the beam-line test's inward pass
+  /// and update (`clearsBeamLine`) taken apart, and the update again with
+  /// the inward state's direction, momentum or both replaced by the MC's at
+  /// the road's first row (the fitted covariance kept).
+  struct BeamLineRow {
+    std::uint32_t index = 0U; ///< into mFindable
+    std::uint32_t iteration = 0U;
+    std::uint8_t stage = 0U; ///< its SeedStage in the pass
+    std::uint8_t count = 0U;
+    LayerID first = 0;
+    LayerID last = 0;
+    std::uint8_t fit = 0U; ///< 0 accepted, 1 the chi2, 2 the propagation, 3 the floor
+    float roadChi2 = 0.F;
+    std::int8_t inward = -1; ///< the inward pass's PropagationStatus; -1 not run
+    std::uint8_t inwardKinks = 0U;
+    float chi2 = -1.F; ///< the nominal update's; -1 where it failed
+    float residual = 0.F;
+    float variance = 0.F;
+    float scattering = 0.F;
+    float allowanceChi2 = -1.F; ///< with the kink allowance, where the nominal one is above the gate
+    float gate = 0.F;
+    float dxy = 0.F;             ///< the production vertex's distance from the beam line [cm]
+    float pFirst = -1.F;         ///< MC |p| entering the road's first row; -1 without its hit
+    float pLast = -1.F;          ///< and its last
+    float mcChi2 = -1.F;         ///< the update with the MC direction and momentum
+    float mcAnglesChi2 = -1.F;   ///< with the MC direction alone
+    float mcMomentumChi2 = -1.F; ///< with the MC momentum alone
+    float dPhi = 0.F;            ///< the inward state less the MC [rad]
+    float dTheta = 0.F;
+    float dQOverPRel = 0.F; ///< (q/p - q/p_MC) / |q/p_MC|
+  };
+
+  /// `BeamLineRow` of every class particle eligible in \a iteration (stage
+  /// \a stage), if the beam-line rows are kept (`keepBeamLine`). Its own
+  /// rows read free on the mask the previous iteration left (with
+  /// followEarlier the earlier tracks' follow takes rows before the seeds).
+  /// The road fit stage refuses a road whose rows share no time before its
+  /// fit; this study has no such test: its question is the fit's and the
+  /// beam line's.
+  template <typename Observation, typename Material>
+  void beamLineStudy(const Observation& iteration, const std::vector<std::uint8_t>& stage, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    if (!mKeepBeamLine || !parameters.beamConstraint) {
+      return;
+    }
+    for (std::uint32_t index = 0; index < mFindable.size(); ++index) {
+      if (stage[index] < kSeedEligible) {
+        continue;
+      }
+      const auto particle = mFindable[index];
+      std::vector<std::uint32_t> road;
+      for (const auto row : roadRows(mRowsOf.at(particle), iteration.iteration)) {
+        if (mSnapshotUsed.empty() || mSnapshotUsed[row] == kFree) {
+          road.push_back(row);
+        }
+      }
+      if (road.size() < parameters.minClusters) {
+        continue;
+      }
+      const auto& truth = mTruth->particles.at(particle);
+      BeamLineRow entry{
+        .index = index,
+        .iteration = static_cast<std::uint32_t>(iteration.iteration),
+        .stage = stage[index],
+        .count = static_cast<std::uint8_t>(road.size()),
+        .first = mTruth->rows[road.front()].layer,
+        .last = mTruth->rows[road.back()].layer,
+        .gate = parameters.beamChi2Max,
+        .dxy = std::hypot(truth.vx - parameters.beamX, truth.vy - parameters.beamY),
+      };
+      const auto* firstHit = segmentOfRow(particle, frame, road.front());
+      const auto* lastHit = segmentOfRow(particle, frame, road.back());
+      entry.pFirst = firstHit != nullptr ? static_cast<float>(std::hypot(firstHit->momentum[0], firstHit->momentum[1], firstHit->momentum[2])) : -1.F;
+      entry.pLast = lastHit != nullptr ? static_cast<float>(std::hypot(lastHit->momentum[0], lastHit->momentum[1], lastHit->momentum[2])) : -1.F;
+      const auto count = static_cast<std::uint32_t>(road.size());
+      const RowChain<Det> chain{.frame = &frame, .rows = road.data()};
+      const auto fit = fitRoad(parameters, propagator, geometry, material, chain, static_cast<int>(count));
+      entry.roadChi2 = fit.chi2;
+      entry.fit = fit.status == RoadFitStatus::kRejected ? 1U : (fit.status == RoadFitStatus::kPropagationFailed ? 2U : 0U);
+      if (entry.fit == 0U && !clearsPtFloor(parameters, count, fit)) {
+        entry.fit = 3U;
+      }
+      if (entry.fit != 0U) {
+        mBeamLineRows.push_back(entry);
+        continue;
+      }
+      const auto inward = fitInward(propagator, geometry, material, chain, static_cast<int>(count), fit.state, kinkBudget(parameters));
+      entry.inward = static_cast<std::int8_t>(inward.status);
+      entry.inwardKinks = static_cast<std::uint8_t>(inward.kinks);
+      if (inward.status != PropagationStatus::kOk) {
+        mBeamLineRows.push_back(entry);
+        continue;
+      }
+      const auto& plane = geometry.planeOf(inward.state);
+      const LayerID layer = geometry.surface(inward.state.surface).layer;
+      const auto point = pairPointAt(frame.measurements(), road.front());
+      const auto updated = [&](BoundTrackState state, Scalar scale) { return updateWithBeamLine(propagator, parameters, plane, layer, point, state, scale); };
+      const auto nominal = updated(inward.state, 1.F);
+      if (nominal.ok) {
+        entry.chi2 = nominal.chi2;
+        entry.residual = nominal.residual;
+        entry.variance = nominal.variance;
+        entry.scattering = nominal.scattering;
+        if (!(nominal.chi2 <= parameters.beamChi2Max) && parameters.kinkScale2 > 1.F) {
+          const auto allowance = updated(inward.state, parameters.kinkScale2);
+          entry.allowanceChi2 = allowance.ok ? allowance.chi2 : -1.F;
+        }
+      }
+      if (firstHit != nullptr) {
+        const auto& p = firstHit->momentum;
+        const double pMc = std::hypot(p[0], p[1], p[2]);
+        const auto phiMc = static_cast<Scalar>(std::atan2(p[1], p[0]));
+        const auto thetaMc = static_cast<Scalar>(std::atan2(std::hypot(p[0], p[1]), p[2]));
+        const auto qOverPMc = static_cast<Scalar>(std::copysign(1. / pMc, static_cast<double>(inward.state.qOverP())));
+        entry.dPhi = static_cast<float>(std::remainder(static_cast<double>(inward.state.phi() - phiMc), 2. * std::numbers::pi));
+        entry.dTheta = inward.state.theta() - thetaMc;
+        entry.dQOverPRel = static_cast<float>((static_cast<double>(inward.state.qOverP()) - static_cast<double>(qOverPMc)) * pMc);
+        const auto replaced = [&](bool angles, bool momentum) {
+          BoundTrackState state = inward.state;
+          if (angles) {
+            state.par[kPhi] = phiMc;
+            state.par[kTheta] = thetaMc;
+          }
+          if (momentum) {
+            state.par[kQOverP] = qOverPMc;
+          }
+          const auto update = updated(state, 1.F);
+          return update.ok ? update.chi2 : -1.F;
+        };
+        entry.mcChi2 = replaced(true, true);
+        entry.mcAnglesChi2 = replaced(true, false);
+        entry.mcMomentumChi2 = replaced(false, true);
+      }
+      mBeamLineRows.push_back(entry);
+    }
+  }
+
+  /// Keep `beamLineStudy`'s rows, for `writeBeamLine`.
+  void keepBeamLine() { mKeepBeamLine = true; }
+
+  /// `beamLineStudy`'s rows as a CSV, with each particle's truth and its fate
+  /// at the end.
+  void writeBeamLine(const std::string& csv) const
+  {
+    std::ofstream out(csv);
+    if (!out) {
+      throw std::runtime_error("cannot write " + csv);
+    }
+    out << "particle,pdg,motherPdg,origin,pt,eta,fate,furthest,iteration,stage,count,first,last,fit,roadChi2,inward,inwardKinks,chi2,residual,variance,"
+           "scattering,allowanceChi2,gate,dxy,pFirst,pLast,mcChi2,mcAnglesChi2,mcMomentumChi2,dPhi,dTheta,dQOverPRel\n";
+    for (const auto& row : mBeamLineRows) {
+      const auto particle = mFindable[row.index];
+      const auto& truth = mTruth->particles.at(particle);
+      out << std::format(
+        "{},{},{},{},{:.4f},{:.3f},{},{},{},{},{},{},{},{},{:.4g},{},{},{:.4g},{:.4g},{:.4g},{:.4g},{:.4g},{:.4g},{:.4g},{:.5g},{:.5g},{:.4g},{:.4g},{:.4g},{:."
+        "4g},{:.4g},{:.4g}\n",
+        particle, truth.pdg, truth.motherPdg, static_cast<int>(truth.origin), truth.pt, truth.eta, static_cast<int>(mFate[row.index]), static_cast<int>(mFurthest[row.index]), row.iteration, static_cast<int>(row.stage), static_cast<int>(row.count), static_cast<int>(row.first), static_cast<int>(row.last), static_cast<int>(row.fit), row.roadChi2, static_cast<int>(row.inward), static_cast<int>(row.inwardKinks), row.chi2, row.residual, row.variance, row.scattering, row.allowanceChi2, row.gate, row.dxy, row.pFirst, row.pLast, row.mcChi2, row.mcAnglesChi2, row.mcMomentumChi2, row.dPhi, row.dTheta, row.dQOverPRel);
+    }
+  }
+
+  /// A class particle's selected record that ended dropped or kept as a fake
+  /// in an iteration, against the MC: the particle's leg of the record's last row in path
+  /// order, its |p| at each own row (the hit's entrance), where it dropped
+  /// most; for a fake, the first wrong row after the record in the track's
+  /// chain and the momentum lost over the step that took it.
+  struct FollowLossRow {
+    std::uint32_t index = 0U; ///< into mFindable
+    std::uint32_t iteration = 0U;
+    std::uint8_t stage = 0U; ///< kSeedDropped or kSeedKeptFake
+    std::uint8_t recordCount = 0U;
+    std::uint8_t minAfter = 0U;       ///< the iteration's length after the follow
+    float dxy = 0.F;                  ///< the production vertex's distance from the beam line [cm]
+    std::int8_t legLayers = -1;       ///< the distinct layers of the leg's own rows; -1 without path order
+    std::int8_t beyond = -1;          ///< the leg's own rows after the record's last
+    float pLegFirst = -1.F;           ///< MC |p| at the leg's first own row
+    float pRecordLast = -1.F;         ///< at the record's last row
+    float pLegLast = -1.F;            ///< at the leg's last own row
+    float rLegLast = -1.F;            ///< that row's radius [cm]
+    float maxDrop = 0.F;              ///< the largest drop of |p| between consecutive own rows of the leg
+    std::int8_t maxDropLayer = -1;    ///< the layer of the row after it
+    std::int8_t maxDropWhere = -1;    ///< 0 up to the record's first row, 1 inside the record, 2 beyond it
+    std::int8_t trackCount = -1;      ///< a fake: its rows
+    std::int8_t wrong = -1;           ///< and how many not the particle's
+    std::int8_t wrongLayer = -1;      ///< the first wrong row after the record's last in the chain; -1 none
+    std::int8_t wrongBefore = -1;     ///< 1 if a wrong row precedes the record's first in the chain
+    std::int8_t ownOnWrongLayer = -1; ///< 1 if the leg has an own row on that layer after the last own row held before it
+    float pBeforeWrong = -1.F;        ///< MC |p| at the last own row the track holds before the wrong row
+    float pAtWrong = -1.F;            ///< at the leg's own row on the wrong row's layer
+    std::int8_t afterWrong = -1;      ///< the track's rows after that wrong row in the chain (0: it is the last)
+    std::int8_t ownAfterWrong = -1;   ///< of them, the particle's own
+    std::string why;                  ///< dropped: `replayDropped`'s verdict
+  };
+
+  /// `FollowLossRow` of \a index in \a iteration.
+  template <typename Observation>
+  [[nodiscard]] FollowLossRow followLoss(const Observation& iteration, std::uint32_t index, std::uint8_t stage, std::uint32_t record, std::uint32_t track, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame) const
+  {
+    const auto particle = mFindable[index];
+    const auto records = iteration.selection->records();
+    const auto count = records.count[record];
+    FollowLossRow row;
+    row.index = index;
+    row.iteration = static_cast<std::uint32_t>(iteration.iteration);
+    row.stage = stage;
+    row.recordCount = count;
+    row.minAfter = static_cast<std::uint8_t>(parameters.minClustersAfterFollow);
+    const auto& truth = mTruth->particles.at(particle);
+    row.dxy = std::hypot(truth.vx - parameters.beamX, truth.vy - parameters.beamY);
+    const auto& own = mRowsOf.at(particle);
+    const auto momentum = [&](std::uint32_t at) {
+      const auto* hit = segmentOfRow(particle, frame, at);
+      return hit != nullptr ? static_cast<float>(std::hypot(hit->momentum[0], hit->momentum[1], hit->momentum[2])) : -1.F;
+    };
+    const std::span<const std::uint32_t> recordRows{records.clusters[record].index, count};
+    std::size_t first = own.size();
+    std::size_t last = own.size();
+    for (std::size_t k = 0; k < own.size(); ++k) {
+      if (std::ranges::find(recordRows, own[k]) != recordRows.end()) {
+        first = first == own.size() ? k : first;
+        last = k;
+      }
+    }
+    const bool ordered = !mLegs.empty() && mTimed[index] != 0U && last < own.size();
+    std::vector<std::size_t> leg; // own row positions on the record's leg, in path order
+    if (ordered) {
+      const auto& legs = mLegs[index];
+      std::uint64_t layers = 0U;
+      for (std::size_t k = 0; k < own.size(); ++k) {
+        if (legs[k] == legs[last]) {
+          leg.push_back(k);
+          layers |= std::uint64_t{1} << mTruth->rows[own[k]].layer;
+        }
+      }
+      row.legLayers = static_cast<std::int8_t>(std::popcount(layers));
+      row.beyond = static_cast<std::int8_t>(std::ranges::count_if(leg, [&](std::size_t k) { return k > last; }));
+      row.pLegFirst = momentum(own[leg.front()]);
+      row.pRecordLast = momentum(own[last]);
+      row.pLegLast = momentum(own[leg.back()]);
+      const auto point = frame.measurement(own[leg.back()]);
+      row.rLegLast = std::hypot(point.x, point.y);
+      for (std::size_t i = 1; i < leg.size(); ++i) {
+        const auto before = momentum(own[leg[i - 1U]]);
+        const auto after = momentum(own[leg[i]]);
+        if (before > 0.F && after > 0.F && 1.F - (after / before) > row.maxDrop) {
+          row.maxDrop = 1.F - (after / before);
+          row.maxDropLayer = static_cast<std::int8_t>(mTruth->rows[own[leg[i]]].layer);
+          row.maxDropWhere = static_cast<std::int8_t>(leg[i] <= first ? 0 : (leg[i] <= last ? 1 : 2));
+        }
+      }
+    }
+    if (stage != kSeedKeptFake || track == kNoTrack) {
+      return row;
+    }
+    const auto view = iteration.tracks->view();
+    const std::span<const std::uint32_t> rows{view.clusters[track].index, view.count[track]};
+    row.trackCount = static_cast<std::int8_t>(rows.size());
+    row.wrong = static_cast<std::int8_t>(std::ranges::count_if(rows, [&](std::uint32_t r) { return !mTruth->rows[r].carries(particle); }));
+    std::size_t recordFirst = rows.size();
+    std::size_t recordLast = rows.size();
+    for (std::size_t i = 0; i < rows.size(); ++i) {
+      if (std::ranges::find(recordRows, rows[i]) != recordRows.end()) {
+        recordFirst = recordFirst == rows.size() ? i : recordFirst;
+        recordLast = i;
+      }
+    }
+    if (recordLast == rows.size()) {
+      return row;
+    }
+    row.wrongBefore = std::any_of(rows.begin(), rows.begin() + static_cast<std::ptrdiff_t>(recordFirst), [&](std::uint32_t r) { return !mTruth->rows[r].carries(particle); }) ? 1 : 0;
+    std::size_t held = recordLast; // the last own row before the first wrong one
+    for (std::size_t i = recordLast + 1U; i < rows.size(); ++i) {
+      if (mTruth->rows[rows[i]].carries(particle)) {
+        held = i;
+        continue;
+      }
+      const auto layer = mTruth->rows[rows[i]].layer;
+      row.wrongLayer = static_cast<std::int8_t>(layer);
+      row.afterWrong = static_cast<std::int8_t>(rows.size() - i - 1U);
+      row.ownAfterWrong = static_cast<std::int8_t>(std::count_if(rows.begin() + static_cast<std::ptrdiff_t>(i) + 1, rows.end(), [&](std::uint32_t r) { return mTruth->rows[r].carries(particle); }));
+      row.pBeforeWrong = momentum(rows[held]);
+      if (ordered) {
+        const auto heldAt = static_cast<std::size_t>(std::ranges::find(own, rows[held]) - own.begin());
+        row.ownOnWrongLayer = 0;
+        for (const auto k : leg) {
+          if (k > heldAt && mTruth->rows[own[k]].layer == layer) {
+            row.ownOnWrongLayer = 1;
+            row.pAtWrong = momentum(own[k]);
+            break;
+          }
+        }
+      }
+      break;
+    }
+    return row;
+  }
+
+  /// Keep `followLoss`'s rows, for `writeFollowLoss`.
+  void keepFollowLoss() { mKeepFollowLoss = true; }
+
+  /// `followLoss`'s rows as a CSV, with each particle's truth and its fate at
+  /// the end.
+  void writeFollowLoss(const std::string& csv) const
+  {
+    std::ofstream out(csv);
+    if (!out) {
+      throw std::runtime_error("cannot write " + csv);
+    }
+    out << "particle,pdg,motherPdg,pt,eta,dxy,fate,furthest,iteration,stage,recordCount,minAfter,legLayers,beyond,pLegFirst,pRecordLast,pLegLast,rLegLast,"
+           "maxDrop,maxDropLayer,maxDropWhere,trackCount,wrong,wrongLayer,wrongBefore,ownOnWrongLayer,pBeforeWrong,pAtWrong,afterWrong,ownAfterWrong,why\n";
+    for (const auto& row : mFollowLossRows) {
+      const auto particle = mFindable[row.index];
+      const auto& truth = mTruth->particles.at(particle);
+      out << std::format("{},{},{},{:.4f},{:.3f},{:.5f},{},{},{},{},{},{},{},{},{:.5g},{:.5g},{:.5g},{:.4g},{:.4g},{},{},{},{},{},{},{},{:.5g},{:.5g},{},{},\"{}\"\n", particle, truth.pdg, truth.motherPdg, truth.pt, truth.eta, row.dxy, static_cast<int>(mFate[row.index]), static_cast<int>(mFurthest[row.index]), row.iteration, static_cast<int>(row.stage), static_cast<int>(row.recordCount), static_cast<int>(row.minAfter), static_cast<int>(row.legLayers), static_cast<int>(row.beyond), row.pLegFirst, row.pRecordLast, row.pLegLast, row.rLegLast, row.maxDrop, static_cast<int>(row.maxDropLayer), static_cast<int>(row.maxDropWhere), static_cast<int>(row.trackCount), static_cast<int>(row.wrong), static_cast<int>(row.wrongLayer), static_cast<int>(row.wrongBefore), static_cast<int>(row.ownOnWrongLayer), row.pBeforeWrong, row.pAtWrong, static_cast<int>(row.afterWrong), static_cast<int>(row.ownAfterWrong), row.why);
+    }
+  }
+
+  /// The missed class particles by their furthest stage over the
+  /// iterations, and for the ones whose furthest was an own record never
+  /// selected, why it lost (`recordLosses`), by pT.
+  void printRecordLosses() const
+  {
+    if (mSeedStage.empty() || mFurthest.empty()) {
+      return;
+    }
+    std::map<std::string, std::size_t> furthest; // NOLINT(misc-const-correctness): written in a dependent call the check does not see
+    std::map<std::string, std::size_t> losses;   // NOLINT(misc-const-correctness): written in a dependent call the check does not see
+    std::size_t missed = 0U;
+    for (std::uint32_t index = 0; index < mFindable.size(); ++index) {
+      if (mFate[index] != kNotFound) {
+        continue;
+      }
+      ++missed;
+      const auto pt = kPathPtNames[pathPtBin(mFindable[index])];
+      ++furthest[std::format("{} | {}", pt, kSeedStageNames[mFurthest[index]])];
+      if (mFurthest[index] == kSeedRecord) {
+        ++losses[std::format("{} | {}", pt, mRecordLoss[index].empty() ? "no reason kept" : mRecordLoss[index])];
+      }
+    }
+    std::string text = std::format("  the class's {} missed by their furthest stage over the iterations, pT [GeV] | stage: particles", missed);
+    for (const auto& [key, n] : furthest) {
+      text += std::format("\n    {}: {}", key, n);
+    }
+    text += "\n  of them, the furthest an own record never selected: what beat it (the best selected record sharing a row) | how it ranks | rows shared";
+    for (const auto& [key, n] : losses) {
+      text += std::format("\n    {}: {}", key, n);
+    }
+    std::cout << text << '\n';
+  }
+
+  /// The follow of each dropped record again: from the
+  /// record's rows refitted, the outward walk and the inward walk on the
+  /// mask the follow read, and the extended refit of what they took -- no
+  /// bidding -- and why the track stayed below the length after the follow:
+  /// the walks short (and the particle's next row beyond them on its leg,
+  /// as the step from its last row decided it, or none: only the way back
+  /// beyond), or the refit dropping what they took. With each, the
+  /// particle's second rows on a layer and its own rows free beyond the
+  /// record on its leg: what the follow could have added.
+  template <typename Observation, typename Material>
+  void replayDropped(const Observation& iteration, const std::vector<std::uint32_t>& dropped, const std::vector<std::uint32_t>& selectedRecord, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    auto& lines = mDropped[iteration.iteration];
+    lines.clear();
+    mDroppedWalks.clear();
+    mLastDropWhy.clear();
+    if (dropped.empty() || !parameters.follow || iteration.followUsed.empty()) {
+      return;
+    }
+    if (!mMothers.empty()) {
+      mDroppedWalks.resize(dropped.size());
+    }
+    const auto records = iteration.selection->records();
+    std::vector<std::string> keys(dropped.size());
+    // The stage as the iteration instantiated it (see replayExtension).
+    withFollowStage(iteration, parameters, frame, geometry, material, propagator, iteration.followUsed.data(), iteration.trackOffset, [&](const auto& stage) {
+      o2::gtrk::detail::parallelFor(*mArena, 0U, dropped.size(), 64, [&](std::size_t a, std::size_t b) {
+        for (std::size_t i = a; i < b; ++i) {
+          const auto index = dropped[i];
+          const auto particle = mFindable[index];
+          const auto record = selectedRecord[index];
+          ClusterList<kMaxClusters> road{};
+          const auto count = records.count[record];
+          for (std::size_t k = 0; k < kMaxClusters; ++k) {
+            road.index[k] = k < count ? records.clusters[record].index[k] : kNoRow;
+          }
+          // The particle's rows: second rows, and own rows free beyond the
+          // record's outermost on its leg.
+          const auto& own = mRowsOf.at(particle);
+          std::string seconds = "no second row";
+          std::size_t beyondFree = 0U;
+          std::size_t last = own.size();
+          if (!mLegs.empty() && mTimed[index] != 0U) {
+            const auto& legs = mLegs[index];
+            bool overlap = false;
+            bool back = false;
+            std::array<std::uint8_t, kLayers> legOnLayer{};
+            legOnLayer.fill(255U);
+            for (std::size_t k = 0; k < own.size(); ++k) {
+              const auto layer = mTruth->rows[own[k]].layer;
+              if (legOnLayer[layer] != 255U) {
+                overlap = overlap || legOnLayer[layer] == legs[k];
+                back = back || legOnLayer[layer] != legs[k];
+              }
+              legOnLayer[layer] = legs[k];
+              if (std::find(road.index, road.index + count, own[k]) != road.index + count) {
+                last = k;
+              }
+            }
+            seconds = overlap ? (back ? "an overlap and the way back" : "an overlap") : (back ? "the way back" : "no second row");
+            for (std::size_t k = last + 1U; last < own.size() && k < own.size(); ++k) {
+              beyondFree += legs[k] == legs[last] && iteration.followUsed[own[k]] == kFree ? 1U : 0U;
+            }
+          }
+          // The starts as the iteration's refit made them (TrackRefit.h):
+          // the inward pass from the record's outward state, which is the
+          // track's outward state.
+          const auto& outwardState = records.outwardState[record];
+          const auto fit = fitInward(propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = road.index}, static_cast<int>(count), outwardState, kinkBudget(parameters));
+          std::string why;
+          std::string extra = "first wrong row: n/a | cut before it: n/a | own rows taken from later legs: n/a";
+          if (fit.status != PropagationStatus::kOk) {
+            why = "the record's refit failed";
+          } else {
+            Walk outward;
+            Walk inward;
+            const auto walkedProposal = recordFollow(stage, fit.state, outwardState, road, count, inward, outward);
+            const auto* outRows = walkedProposal.outward;
+            const auto* inRows = walkedProposal.inward;
+            const auto walked = walkedProposal.outwardCount;
+            const auto inWalked = walkedProposal.inwardCount;
+            if (!mDroppedWalks.empty()) {
+              mDroppedWalks[i] = {.outward = outward, .inward = inward, .road = road, .roadCount = static_cast<std::uint8_t>(count), .walked = true};
+            }
+            // Each direction cut back to its kink steps' witnesses, as
+            // before the refit (`KeepWitnesses`); no bidding.
+            const bool kinkSteps = parameters.kinkScale2 > 1.F && parameters.maxKinks != 0U;
+            const auto keptOut = kinkSteps ? follow::keptWithWitnesses(walked, outward.witnessed) : walked;
+            const auto keptIn = kinkSteps ? follow::keptWithWitnesses(inWalked, inward.witnessed) : inWalked;
+            std::vector<std::uint32_t> combined;
+            for (auto k = static_cast<std::size_t>(keptIn); k-- > 0U;) {
+              combined.push_back(inRows[k]);
+            }
+            combined.insert(combined.end(), road.index, road.index + count);
+            combined.insert(combined.end(), outRows, outRows + keptOut);
+            const auto need = parameters.minClustersAfterFollow > count ? parameters.minClustersAfterFollow - count : 0U;
+            const auto added = static_cast<std::uint32_t>(keptOut + keptIn);
+            std::size_t wrong = 0U;
+            for (std::size_t k = 0; k < added; ++k) {
+              wrong += mTruth->rows[k < keptOut ? outRows[k] : inRows[k - keptOut]].carries(particle) ? 0U : 1U;
+            }
+            const std::string took = std::format("took +{} ({} not its own) of the +{} needed", added, wrong, need);
+            // The outward walk's first wrong row: its layer and the particle's
+            // own row at that step; the walk cut before it, refitted (a
+            // truth-aided bound, not a policy); its own rows from later legs.
+            std::string firstWrong = "first wrong row: none outward";
+            std::string cut = "cut before it: n/a";
+            std::size_t wayBack = 0U;
+            if (!mLegs.empty() && mTimed[index] != 0U && last < own.size()) {
+              for (std::size_t k = 0; k < keptOut; ++k) {
+                const auto here = std::ranges::find(own, outRows[k]);
+                wayBack += here != own.end() && mLegs[index][static_cast<std::size_t>(here - own.begin())] > mLegs[index][last] ? 1U : 0U;
+              }
+            }
+            for (std::size_t w = 0; w < keptOut; ++w) {
+              if (mTruth->rows[outRows[w]].carries(particle)) {
+                continue;
+              }
+              const auto layer = mTruth->rows[outRows[w]].layer;
+              const auto step = std::ranges::find(outward.steps, outRows[w], &Step::choice);
+              std::string own0 = "no own row on its layer";
+              bool onLayer = false;
+              for (const auto row : own) {
+                if (mTruth->rows[row].layer != layer || step == outward.steps.end()) {
+                  continue;
+                }
+                onLayer = true;
+                const auto& seen = step->kink ? step->scaled : step->candidates;
+                const auto at = std::ranges::find(seen, row, &Candidate::row);
+                const auto taken = std::ranges::find(seen, outRows[w], &Candidate::row);
+                if (at == seen.end()) {
+                  own0 = "own row not visited";
+                } else if (at->outcome == StepOutcome::kPasses) {
+                  own0 = taken != seen.end() && taken->chi2 > at->chi2 ? "own row passing, taken higher" : "own row passing, taken lower";
+                  break;
+                } else {
+                  own0 = std::format("own row {}", kOutcomeNames[static_cast<std::size_t>(at->outcome)]);
+                }
+              }
+              if (!onLayer && !mLegs.empty() && mTimed[index] != 0U) {
+                // Own rows of the leg beyond the last own row the walk held.
+                std::size_t at = last;
+                for (std::size_t k = 0; k < w; ++k) {
+                  const auto here = std::ranges::find(own, outRows[k]);
+                  at = here != own.end() ? std::max(at, static_cast<std::size_t>(here - own.begin())) : at;
+                }
+                bool sameLeg = false;
+                bool later = false;
+                for (std::size_t k = at + 1U; at < own.size() && k < own.size(); ++k) {
+                  sameLeg = sameLeg || mLegs[index][k] == mLegs[index][at];
+                  later = later || mLegs[index][k] != mLegs[index][at];
+                }
+                own0 = sameLeg ? "no own row on its layer, own rows of its leg beyond" : (later ? "past its last on its leg, the way back beyond" : "past its last row");
+              }
+              firstWrong = std::format("first wrong row: layer {}, {}{}", static_cast<int>(layer), own0, step != outward.steps.end() && step->kink ? " (kink step)" : "");
+              std::vector<std::uint32_t> trimmed(road.index, road.index + count);
+              // The prefix's own witnesses kept too: a kink step whose
+              // witness the cut removes goes with it.
+              const auto prefix = kinkSteps ? follow::keptWithWitnesses(static_cast<std::uint8_t>(w), outward.witnessed) : static_cast<std::uint8_t>(w);
+              trimmed.insert(trimmed.end(), outRows, outRows + prefix);
+              if (trimmed.size() < parameters.minClustersAfterFollow) {
+                cut = std::format("cut before it: {} rows, short of the length", trimmed.size());
+              } else {
+                const auto refit = fitMeasurements(propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = trimmed.data()}, static_cast<int>(trimmed.size()), kinkBudget(parameters));
+                // Kept by the refit and the length: and its rows still free
+                // after the iteration's bids and marks?
+                const bool held = std::any_of(outRows, outRows + prefix, [&](std::uint32_t row) { return iteration.used[row] != kFree; });
+                cut = refit.status != PropagationStatus::kOk ? std::format("cut before it: the refit fails in the {} pass", refit.failedPass == FitPass::kInward ? "inward" : "outward") : (follow::passesRoadChi2(parameters, refit) ? std::string{held ? "cut before it: kept, a row held after the iteration" : "cut before it: kept"} : std::string{"cut before it: chi2 over the cut"});
+              }
+              break;
+            }
+            extra = std::format("{} | {} | own rows taken from later legs: {}", firstWrong, cut, wayBack);
+            if (added < need) {
+              // The particle's next row beyond the outward walk on its leg.
+              std::size_t at = last;
+              for (std::size_t k = 0; k < walked; ++k) {
+                const auto here = std::ranges::find(own, outRows[k]);
+                at = here != own.end() ? std::max(at == own.size() ? 0U : at, static_cast<std::size_t>(here - own.begin())) : at;
+              }
+              std::uint32_t next = kNoTrack;
+              bool laterLeg = false;
+              if (at < own.size() && !mLegs.empty() && mTimed[index] != 0U) {
+                const auto& legs = mLegs[index];
+                for (std::size_t k = at + 1U; k < own.size(); ++k) {
+                  if (legs[k] == legs[at]) {
+                    next = own[k];
+                    break;
+                  }
+                  laterLeg = true;
+                }
+              }
+              if (next == kNoTrack) {
+                why = std::format("the walks short, {}: no own row beyond on its leg, {}", took, laterLeg ? "the way back beyond" : "none beyond");
+              } else {
+                outward.bidKept = walked;
+                outward.kept = walked;
+                outward.refit = kRefitKept;
+                std::uint8_t detail = 0U;
+                const auto reason = stopReason(outward, next, mTruth->rows[own[at]].layer, particle, detail);
+                const bool droppedUnconfirmed = outward.dropped == next;
+                why = std::format("the walks short, {}: its next row (layer {}) {}", took, static_cast<int>(mTruth->rows[next].layer), droppedUnconfirmed ? "taken, dropped after (the unconfirmed drop)" : kShortNames[reason]);
+              }
+            } else {
+              const auto refit = fitMeasurements(propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = combined.data()}, static_cast<int>(combined.size()), kinkBudget(parameters));
+              if (refit.status != PropagationStatus::kOk) {
+                why = std::format("the walks long enough, {}: the refit failed, status {} in the {} pass", took, static_cast<int>(refit.status), refit.failedPass == FitPass::kInward ? "inward" : "outward");
+              } else if (!(follow::passesRoadChi2(parameters, refit))) {
+                why = std::format("the walks long enough, {}: the refit's chi2 over the cut", took);
+              } else {
+                why = std::format("the walks long enough, {}: the refit keeps it (the bid, or the iteration's follow differs)", took);
+              }
+            }
+          }
+          keys[i] = std::format("{} | {} | {} | second rows: {} | own rows free beyond on its leg: {}", kPathPtNames[pathPtBin(particle)], why, extra, seconds, std::min<std::size_t>(beyondFree, 3U) == 3U ? std::string{"3+"} : std::to_string(beyondFree));
+        }
+      });
+    });
+    for (std::size_t i = 0; i < keys.size(); ++i) {
+      ++lines[keys[i]];
+      if (mKeepFollowLoss) {
+        mLastDropWhy[dropped[i]] = keys[i];
+      }
+    }
+  }
+
+  /// The seeding funnel of every iteration, the class's
+  /// particles not found before it, by pT; with \a longestRoad (the stage
+  /// funnel's longest road of a particle's own in an iteration and why its
+  /// road made no record, a `study::FitLoss`, if the funnel ran) the
+  /// eligible without a record split by a pure road and that reason; and
+  /// the dropped records' replays. Particle counts: one selected record a
+  /// particle.
+  void printSeeding(const std::function<std::optional<std::pair<std::uint32_t, int>>(std::uint64_t, std::size_t)>& longestRoad) const
+  {
+    for (std::size_t it = 0; it < mSeedStage.size(); ++it) {
+      const auto& stage = mSeedStage[it];
+      if (stage.empty()) {
+        continue;
+      }
+      std::array<std::array<std::size_t, kSeedStages + 2U>, kPathPtNames.size()> counts{};
+      std::array<std::map<std::string, std::size_t>, kPathPtNames.size()> pureWhy{};
+      for (std::uint32_t index = 0; index < stage.size(); ++index) {
+        const auto bin = pathPtBin(mFindable[index]);
+        ++counts[bin][stage[index]];
+        if (stage[index] == kSeedEligible) {
+          const auto road = longestRoad ? longestRoad(mFindable[index], it) : std::nullopt;
+          const bool pure = road && road->first >= mMinClusters[it];
+          counts[bin][kSeedStages + (pure ? 1U : 0U)] += road ? 1U : 0U;
+          if (pure) {
+            ++pureWhy[bin][study::kFitLossNames[static_cast<std::size_t>(road->second)]];
+          }
+        }
+      }
+      // "selected" is only a step on the way: every selected record ends
+      // dropped, kept as a fake or kept good, so its column is not printed.
+      std::string text = std::format("  seeding funnel of iteration {}, by pT [GeV]:", it);
+      for (std::size_t s = 0; s < kSeedStages; ++s) {
+        text += s == kSeedSelected ? std::string{} : std::format(" {}{}", kSeedStageNames[s], s + 1U < kSeedStages ? " /" : "");
+      }
+      text += " | eligible without a record: no pure road / a pure road, no record (the stage funnel's; by its reason)";
+      for (std::size_t b = 0; b < counts.size(); ++b) {
+        text += std::format("\n    {}:", kPathPtNames[b]);
+        for (std::size_t s = 0; s < kSeedStages; ++s) {
+          text += s == kSeedSelected ? std::string{} : std::format(" {}", counts[b][s]);
+        }
+        text += std::format(" | {} / {} (", counts[b][kSeedStages], counts[b][kSeedStages + 1U]);
+        for (const auto& [why, n] : pureWhy[b]) {
+          text += std::format("{} {}; ", why, n);
+        }
+        text += ")";
+      }
+      if (it < mDropped.size() && !mDropped[it].empty()) {
+        text += std::format("\n    the dropped of iteration {}, the follow replayed from the record (pT | why | the particle's rows):", it);
+        for (const auto& [key, count] : mDropped[it]) {
+          text += std::format("\n      {}: {}", key, count);
+        }
+      }
+      std::cout << text << '\n';
+    }
+    // The not found at the end, by their last iteration's stage.
+    if (!mSeedStage.empty()) {
+      std::array<std::array<std::size_t, kSeedStages>, kMissedReasons> cross{};
+      const auto& last = mSeedStage.back();
+      for (std::uint32_t index = 0; index < last.size(); ++index) {
+        if (mFate[index] == kNotFound) {
+          ++cross[mReason[index]][last[index]];
+        }
+      }
+      std::string text = "  the not found by the anatomy's reason, against the last iteration's seeding stage:";
+      for (std::size_t reason = 0; reason < kMissedReasons; ++reason) {
+        std::size_t total = 0U;
+        for (const auto n : cross[reason]) {
+          total += n;
+        }
+        if (total == 0U) {
+          continue;
+        }
+        text += std::format("\n    {} ({}):", kMissedNames[reason], total);
+        for (std::size_t s = 0; s < kSeedStages; ++s) {
+          text += cross[reason][s] != 0U ? std::format(" {} {};", kSeedStageNames[s], cross[reason][s]) : std::string{};
+        }
+      }
+      std::cout << text << '\n';
+    }
+  }
+
+  /// The pT bins of the path tables [GeV]: the 0.1 and 0.15 rungs apart.
+  static constexpr std::array<double, 4> kPathPtEdges{0.15, 0.2, 0.3, 0.5};
+  static constexpr std::array<const char*, 5> kPathPtNames{"0.1-0.15", "0.15-0.2", "0.2-0.3", "0.3-0.5", ">= 0.5"};
+  [[nodiscard]] std::size_t pathPtBin(std::uint64_t particle) const
+  {
+    const double pt = truePt(mTruth->particles.find(particle));
+    return static_cast<std::size_t>(std::ranges::upper_bound(kPathPtEdges, pt) - kPathPtEdges.begin());
+  }
+
+  /// How a follow walk ended (`FollowEnd`), as the printed tables name it.
+  static constexpr std::array<const char*, 4> kFollowEndNames{"no target", "holes", "no row", "capacity"};
+  /// A replayed step's outcome on a row, as the printed tables name it: the
+  /// six `StepOutcome`s, then `kNotVisited` and `kNoOwnNext`.
+  static constexpr std::array<const char*, 8> kStepOutcomeNames{"held", "outside the window", "crossing a layer", "no update", "chi2", "passing", "not visited", "no own next row"};
+  /// The names of the bins of `kWalkPtEdges` [GeV].
+  static constexpr std::array<const char*, 5> kWalkPtNames{"< 0.2", "0.2-0.3", "0.3-0.6", "0.6-1", ">= 1"};
+
+  /// Where a track's outermost own row (in path order) leaves the particle:
+  /// at its last row; the next an overlap (its layer again, its leg); rows of
+  /// its leg beyond (the walk could go on); only rows of later legs beyond
+  /// (it ends at the turning point, the way back left).
+  enum PathEnd : std::uint8_t { kEndLast,
+                                kEndOverlap,
+                                kEndLegBeyond,
+                                kEndTurning,
+                                kPathEnds };
+  static constexpr std::array<const char*, kPathEnds> kPathEndNames{"at its last row", "an overlap next", "rows of its leg beyond", "at the turning point, only later legs beyond"};
+  /// \a index's (a findable's) path end after the own rows \a held, a bit
+  /// per path position; kPathEnds without a timed path or a held row.
+  [[nodiscard]] PathEnd pathEnd(std::uint32_t index, const std::vector<bool>& held) const
+  {
+    if (mLegs.empty() || mTimed[index] == 0U) {
+      return kPathEnds;
+    }
+    const auto& legs = mLegs[index];
+    const auto& rows = mRowsOf.at(mFindable[index]);
+    std::size_t last = rows.size();
+    for (std::size_t k = 0; k < rows.size(); ++k) {
+      last = held[k] ? k : last;
+    }
+    if (last == rows.size()) {
+      return kPathEnds;
+    }
+    if (last + 1U == rows.size()) {
+      return kEndLast;
+    }
+    if (legs[last + 1U] == legs[last] && mTruth->rows[rows[last + 1U]].layer == mTruth->rows[rows[last]].layer) {
+      return kEndOverlap;
+    }
+    for (std::size_t k = last + 1U; k < rows.size(); ++k) {
+      if (legs[k] == legs[last]) {
+        return kEndLegBeyond;
+      }
+    }
+    return kEndTurning;
+  }
+
+  /// The class in path order, after each iteration (the
+  /// last one's printed): the particles' rows by leg, their second rows on a
+  /// layer split into overlaps (the same leg) and returns (a later one); the
+  /// rows a track could reach -- the distinct layers of the first outward
+  /// leg, the tracker's one row per layer, an upper bound (no holes, links), and
+  /// with the way back's distinct layers too; where each good track ends
+  /// against its particle's rows (`PathEnd`); for the iteration's own
+  /// tracks, by how their outward walk ended.
+  template <typename Observation, typename ReplayOf>
+  void pathReport(const Observation& iteration, const std::unordered_map<std::uint64_t, std::uint32_t>& goodTrack, const ReplayOf& replayOf)
+  {
+    if (mLegs.empty()) {
+      return;
+    }
+    const auto view = iteration.tracks->view();
+    struct Bin {
+      std::size_t particles = 0U, timed = 0U, withReturn = 0U, withOverlap = 0U, overlapOnly = 0U, returnOnly = 0U, both = 0U;
+      std::size_t rows0 = 0U, rows1 = 0U, rows2 = 0U, ceiling0 = 0U, ceilingBack = 0U, reach7 = 0U, reach7Back = 0U;
+      std::size_t found = 0U, held = 0U, heldReturn = 0U, heldLater = 0U, ceilingFound = 0U;
+      std::array<std::size_t, kPathEnds + 1U> ends{};
+    };
+    std::array<Bin, kPathPtNames.size()> bins{};
+    std::array<std::array<std::size_t, kPathEnds + 1U>, 4> walkEnds{}; // [FollowEnd][PathEnd], the iteration's own good tracks
+    std::vector<bool> held;
+    for (std::uint32_t index = 0; index < mFindable.size(); ++index) {
+      const auto particle = mFindable[index];
+      auto& bin = bins[pathPtBin(particle)];
+      ++bin.particles;
+      if (mTimed[index] == 0U) {
+        continue;
+      }
+      ++bin.timed;
+      const auto& rows = mRowsOf.at(particle);
+      const auto& legs = mLegs[index];
+      std::uint64_t layers0 = 0U;
+      std::uint64_t layers1 = 0U;
+      bool overlap = false;
+      bool back = false;
+      std::array<std::uint8_t, kLayers> legOnLayer{};
+      legOnLayer.fill(255U);
+      for (std::size_t k = 0; k < rows.size(); ++k) {
+        const auto layer = mTruth->rows[rows[k]].layer;
+        const auto bit = std::uint64_t{1} << layer;
+        bin.rows0 += legs[k] == 0U ? 1U : 0U;
+        bin.rows1 += legs[k] == 1U ? 1U : 0U;
+        bin.rows2 += legs[k] >= 2U ? 1U : 0U;
+        layers0 |= legs[k] == 0U ? bit : 0U;
+        layers1 |= legs[k] == 1U ? bit : 0U;
+        if (legOnLayer[layer] != 255U) {
+          overlap = overlap || legOnLayer[layer] == legs[k];
+          back = back || legOnLayer[layer] != legs[k];
+        }
+        legOnLayer[layer] = legs[k];
+      }
+      const bool returns = std::ranges::any_of(legs, [](std::uint8_t leg) { return leg != 0U; });
+      bin.withReturn += returns ? 1U : 0U;
+      bin.withOverlap += overlap ? 1U : 0U;
+      bin.overlapOnly += overlap && !back ? 1U : 0U;
+      bin.returnOnly += back && !overlap ? 1U : 0U;
+      bin.both += overlap && back ? 1U : 0U;
+      const auto ceiling0 = static_cast<std::size_t>(std::popcount(layers0));
+      const auto ceilingBack = ceiling0 + static_cast<std::size_t>(std::popcount(layers1));
+      bin.ceiling0 += ceiling0;
+      bin.ceilingBack += ceilingBack;
+      bin.reach7 += ceiling0 >= 7U ? 1U : 0U;
+      bin.reach7Back += ceilingBack >= 7U ? 1U : 0U;
+      const auto good = goodTrack.find(particle);
+      if (good == goodTrack.end()) {
+        continue;
+      }
+      const auto track = good->second;
+      held.assign(rows.size(), false);
+      std::size_t count = 0U;
+      for (std::uint8_t i = 0; i < view.count[track]; ++i) {
+        const auto at = std::ranges::find(rows, view.clusters[track].index[i]);
+        if (at != rows.end()) {
+          held[static_cast<std::size_t>(at - rows.begin())] = true;
+          ++count;
+          const auto leg = legs[static_cast<std::size_t>(at - rows.begin())];
+          bin.heldReturn += leg == 1U ? 1U : 0U;
+          bin.heldLater += leg >= 2U ? 1U : 0U;
+        }
+      }
+      ++bin.found;
+      bin.held += count;
+      bin.ceilingFound += ceiling0;
+      const auto end = pathEnd(index, held);
+      ++bin.ends[end];
+      if (track >= iteration.trackOffset) {
+        if (const auto* replay = replayOf(track); replay != nullptr && !replay->outward.empty() && replay->outward.front().agrees) {
+          ++walkEnds[static_cast<std::size_t>(replay->outward.front().end)][end];
+        }
+      }
+    }
+    const auto mean = [](std::size_t sum, std::size_t n) { return n == 0U ? 0. : static_cast<double>(sum) / static_cast<double>(n); };
+    std::string text = std::format(
+      "  path order, after iteration {}: rows by the MC hits' time; reordered against the distance from the vertex: class {} of {} (first "
+      "row on a "
+      "layer changed {}), others {} of {}; kept in the distance's order (a row without its segment): class {}, others {}",
+      iteration.iteration, mPathCounts[1][1], mPathCounts[1][0] + mPathCounts[1][1] + mPathCounts[1][2], mPathCounts[1][3], mPathCounts[0][1], mPathCounts[0][0] + mPathCounts[0][1] + mPathCounts[0][2], mPathCounts[1][2], mPathCounts[0][2]);
+    text +=
+      "\n    by pT [GeV]: particles (timed) | a second row on a layer: overlap only (its leg) / a later leg only / both | mean rows out (leg 0) / the first "
+      "way "
+      "back (leg 1) / later legs | distinct layers out (today's ceiling, an upper bound) / with the first way back | % reaching 7 out / with the first way "
+      "back";
+    for (std::size_t b = 0; b < bins.size(); ++b) {
+      const auto& one = bins[b];
+      text += std::format("\n      {}: {} ({}) | {} / {} / {} | {:.2f} / {:.2f} / {:.2f} | {:.2f} / {:.2f} | {:.1f} / {:.1f}", kPathPtNames[b], one.particles, one.timed, one.overlapOnly, one.returnOnly, one.both, mean(one.rows0, one.timed), mean(one.rows1, one.timed), mean(one.rows2, one.timed), mean(one.ceiling0, one.timed), mean(one.ceilingBack, one.timed), study::percent(one.reach7, one.timed), study::percent(one.reach7Back, one.timed));
+    }
+    text += "\n    the good tracks by pT: found | mean own rows held / the ceiling out | rows held from the first way back / later legs | where the track ends:";
+    for (std::size_t end = 0; end < kPathEnds; ++end) {
+      text += std::format(" {} /", kPathEndNames[end]);
+    }
+    for (std::size_t b = 0; b < bins.size(); ++b) {
+      const auto& one = bins[b];
+      text += std::format("\n      {}: {} | {:.2f} / {:.2f} | {} / {} |", kPathPtNames[b], one.found, mean(one.held, one.found), mean(one.ceilingFound, one.found), one.heldReturn, one.heldLater);
+      for (std::size_t end = 0; end < kPathEnds; ++end) {
+        text += std::format(" {}", one.ends[end]);
+      }
+    }
+    text += std::format("\n    the iteration's own good tracks, by how the outward walk ended (replayed, agreeing) and where the track ends:");
+    for (std::size_t end = 0; end < kFollowEndNames.size(); ++end) {
+      text += std::format("\n      {}:", kFollowEndNames[end]);
+      for (std::size_t at = 0; at < kPathEnds; ++at) {
+        text += std::format(" {} {};", kPathEndNames[at], walkEnds[end][at]);
+      }
+    }
+    mPathLines = text;
+  }
+
+  /// \a particle's largest true kink, either plane, over theta0, between
+  /// crossings of consecutive layers from \a first to \a last; -1 without one.
+  /// The kinks are grouped by particle (`mKinkBegin`): the truth walk asks
+  /// for them at every step, too often for a scan of them all.
+  [[nodiscard]] float largestKink(std::uint64_t particle, LayerID first, LayerID last) const
+  {
+    const auto at = mIndex.find(particle);
+    if (at == mIndex.end() || at->second + 1U >= mKinkBegin.size()) {
+      return -1.F;
+    }
+    float largest = -1.F;
+    for (auto i = mKinkBegin[at->second]; i < mKinkBegin[at->second + 1U]; ++i) {
+      const auto& kink = mKinks[i];
+      if (kink.layer >= first && kink.to <= last) {
+        largest = std::max({largest, std::abs(kink.theta), std::abs(kink.phi)});
+      }
+    }
+    return largest;
+  }
+
+  /// \a particle's true kink over the crossing ending at \a layer (\a into)
+  /// or starting there, either plane over theta0; -1 without one (the
+  /// crossing before C1 is ML 4 -> C1, not 10 -> 11).
+  [[nodiscard]] float kinkAt(std::uint64_t particle, LayerID layer, bool into) const
+  {
+    const auto at = mIndex.find(particle);
+    if (at == mIndex.end() || at->second + 1U >= mKinkBegin.size()) {
+      return -1.F;
+    }
+    for (auto i = mKinkBegin[at->second]; i < mKinkBegin[at->second + 1U]; ++i) {
+      const auto& kink = mKinks[i];
+      if ((into ? kink.to : kink.layer) == layer) {
+        return std::max(std::abs(kink.theta), std::abs(kink.phi));
+      }
+    }
+    return -1.F;
+  }
+
+  void print() const
+  {
+    std::array<std::size_t, 3> fates{};
+    for (const auto fate : mFate) {
+      ++fates[fate];
+    }
+    const auto n = mFindable.size();
+    const auto pc = [&](std::size_t count) { return study::percent(count, n); };
+    std::cout << std::format(
+      "complete anatomy: {} physical primaries on every layer of mask {}: complete {} ({:.2f} %), short {} ({:.2f} %), not found {} "
+      "({:.2f} %); the replayed follow agrees with the iteration's on {} of {} tracks\n",
+      n, mMask, fates[kComplete], pc(fates[kComplete]), fates[kShortFate], pc(fates[kShortFate]), fates[kNotFound], pc(fates[kNotFound]), mAgree, mReplayed);
+    printFidelity();
+    {
+      std::string text = "  good tracks of the findable by the layers of the mask they hold:";
+      for (std::size_t layers = 0; layers < mLayersFound.size(); ++layers) {
+        if (mLayersFound[layers] != 0U) {
+          text += std::format(" {}: {} ({:.2f} %);", layers, mLayersFound[layers], pc(mLayersFound[layers]));
+        }
+      }
+      std::cout << text << '\n';
+    }
+    std::array<std::size_t, kShortReasons + 1U> stops{};
+    std::array<std::size_t, kMissedReasons> missed{};
+    for (std::size_t index = 0; index < n; ++index) {
+      if (mFate[index] == kShortFate) {
+        ++stops[mStop[index]];
+      } else if (mFate[index] == kNotFound) {
+        ++missed[mReason[index]];
+      }
+    }
+    std::string line = "  short, by the decision that stopped it:";
+    for (std::size_t reason = 0; reason < kShortReasons; ++reason) {
+      if (stops[reason] != 0U) {
+        line += std::format(" {} {} ({:.2f} %);", kShortNames[reason], stops[reason], pc(stops[reason]));
+      }
+    }
+    std::cout << line << '\n';
+    // The blocks of the follow's replay, on a run whose iterations followed
+    // (none on the ITS: they would be empty or zero).
+    const bool followed = mReplayed + mOutReplayed != 0U;
+    if (followed) {
+      std::array<std::size_t, 8> kinkRefused{};
+      std::array<std::array<std::size_t, 8>, 2> unconfirmed{};
+      for (std::size_t index = 0; index < n; ++index) {
+        if (mFate[index] == kShortFate && mStop[index] == kKinkRefused) {
+          ++kinkRefused[mStopDetail[index] % 8U];
+        } else if (mFate[index] == kShortFate && mStop[index] == kKinkUnconfirmed) {
+          ++unconfirmed[mStopDetail[index] / 8U][mStopDetail[index] % 8U];
+        }
+      }
+      line = "  kink step refused it, under the scaled gate:";
+      for (std::size_t outcome = 0; outcome < kStepOutcomeNames.size(); ++outcome) {
+        if (kinkRefused[outcome] != 0U) {
+          line += std::format(" {} {};", kStepOutcomeNames[outcome], kinkRefused[outcome]);
+        }
+      }
+      std::cout << line << '\n';
+      for (std::size_t beam = 0; beam < 2U; ++beam) {
+        line = beam == 0U ? "  kink step unconfirmed, the particle's next row under the nominal gate:" : "  kink step unconfirmed, the beam line:";
+        for (std::size_t outcome = 0; outcome < kStepOutcomeNames.size(); ++outcome) {
+          if (unconfirmed[beam][outcome] != 0U) {
+            line += std::format(" {} {};", kStepOutcomeNames[outcome], unconfirmed[beam][outcome]);
+          }
+        }
+        std::cout << line << '\n';
+      }
+    }
+    line = "  short, by the layer it missed:";
+    std::array<std::size_t, kLayers> stopLayers{};
+    for (std::size_t index = 0; index < n; ++index) {
+      if (mFate[index] == kShortFate && mStopLayer[index] < kLayers) {
+        ++stopLayers[mStopLayer[index]];
+      }
+    }
+    for (std::size_t layer = 0; layer < kLayers; ++layer) {
+      if (stopLayers[layer] != 0U) {
+        line += std::format(" {}:{}", layer, stopLayers[layer]);
+      }
+    }
+    std::cout << line << '\n';
+    // What the passing step took instead of the own row,
+    // inward; then the short of an outer layer, by the outward step.
+    const auto takenLine = [&](const char* title, const std::vector<std::uint8_t>& taken, const std::vector<std::uint8_t>& stop) {
+      std::array<std::array<std::size_t, 2>, kTakenKinds> counts{};
+      for (std::size_t index = 0; index < n; ++index) {
+        if (mFate[index] == kShortFate && taken[index] % kLowerChi2 != kNoTaken && (stop[index] == kOtherTaken || stop[index] == kLookaheadOther)) {
+          ++counts[taken[index] % kLowerChi2][taken[index] / kLowerChi2];
+        }
+      }
+      std::string text = title;
+      for (std::size_t kind = 1; kind < kTakenKinds; ++kind) {
+        if (counts[kind][0] + counts[kind][1] != 0U) {
+          text += std::format(" {} {} ({} with a lower chi2);", kTakenNames[kind], counts[kind][0] + counts[kind][1], counts[kind][1]);
+        }
+      }
+      std::cout << text << '\n';
+    };
+    if (followed) {
+      takenLine("  short, its own row passing, the row taken instead:", mStopTaken, mStop);
+    }
+    {
+      std::array<std::size_t, kShortReasons + 1U> outStops{};
+      std::array<std::size_t, kLayers> outLayers{};
+      std::size_t outShort = 0U;
+      for (std::size_t index = 0; index < n; ++index) {
+        if (mFate[index] == kShortFate && mStop[index] == kGapInside) {
+          ++outShort;
+          ++outStops[mOutStop[index]];
+          if (mOutStopLayer[index] < kLayers) {
+            ++outLayers[mOutStopLayer[index]];
+          }
+        }
+      }
+      line = std::format("  short of an outer layer ({}, {:.2f} %; outward walks replayed {}, {} agree), by the decision at the first it missed:", outShort, pc(outShort), mOutReplayed, mOutAgree);
+      for (std::size_t reason = 0; reason <= kShortReasons; ++reason) {
+        if (outStops[reason] != 0U) {
+          line += std::format(" {} {} ({:.2f} %);", reason < kShortReasons ? kShortNames[reason] : "not replayed", outStops[reason], pc(outStops[reason]));
+        }
+      }
+      std::cout << line << '\n';
+      line = "  short of an outer layer, by the first it missed:";
+      for (std::size_t layer = 0; layer < kLayers; ++layer) {
+        if (outLayers[layer] != 0U) {
+          line += std::format(" {}:{}", layer, outLayers[layer]);
+        }
+      }
+      std::cout << line << '\n';
+      if (followed) {
+        takenLine("  short of an outer layer, its own row passing, the row taken instead:", mOutStopTaken, mOutStop);
+        line =
+          "  short of an outer layer, refit failed, by status (1 no intersection, 4 grazing, 5 not finite, 6 too many turns, 7 stopped) / pass (1 outward, 2 "
+          "inward) / layer:";
+        for (const auto& [key, count] : mRefitFailures) {
+          line += std::format(" {}: {};", key, count);
+        }
+        std::cout << line << '\n';
+        std::cout << "  short of an outer layer, refit failed, replayed by the outward rows not the particle's (2: the failing step's propagation status; 3: the "
+                     "filtered state's circle against the failing plane, barrel planes):\n";
+        for (const auto& [key, count] : mRefitReplay) {
+          std::cout << std::format("    {}: {}\n", key, count);
+        }
+        {
+          // The refit-chi2 stops: the outward rows the refit took, the wrong
+          // ones among them, and the chi2 over the cut.
+          std::array<std::array<std::size_t, 6>, 6> bins{};
+          std::array<std::size_t, kMaxClusters + 1U> rows{};
+          constexpr std::array<double, 5> kEdges{1.5, 2., 3., 5., 10.};
+          for (std::size_t index = 0; index < n; ++index) {
+            if (mFate[index] == kShortFate && mStop[index] == kGapInside && mOutStop[index] == kRefitChi2) {
+              const auto ratio = static_cast<double>(mOutRefitRatio[index]);
+              const auto bin = static_cast<std::size_t>(std::ranges::upper_bound(kEdges, ratio) - kEdges.begin());
+              ++bins[mOutRefitWrong[index]][bin];
+              ++rows[mOutRefitRows[index]];
+            }
+          }
+          line =
+            "  short of an outer layer, refit chi2: outward rows not the particle's 0 / 1 / 2+ (k: with a kink step), by chi2 over the cut (1-1.5 / 1.5-2 / 2-3 "
+            "/ 3-5 / 5-10 / >10):";
+          for (std::size_t wrong = 0; wrong < 6U; ++wrong) {
+            line += std::format(" [{}{}] {} {} {} {} {} {};", wrong % 3U, wrong >= 3U ? "k" : "", bins[wrong][0], bins[wrong][1], bins[wrong][2], bins[wrong][3], bins[wrong][4], bins[wrong][5]);
+          }
+          std::array<std::array<std::size_t, 6>, 4> kinkBins{};
+          for (std::size_t index = 0; index < n; ++index) {
+            if (mFate[index] == kShortFate && mStop[index] == kGapInside && mOutStop[index] == kRefitChi2 && mOutRefitWrong[index] % 3U == 0U) {
+              const auto ratio = static_cast<double>(mOutRefitRatio[index]);
+              ++kinkBins[mOutRefitKink[index]][static_cast<std::size_t>(std::ranges::upper_bound(kEdges, ratio) - kEdges.begin())];
+            }
+          }
+          constexpr std::array<const char*, 4> kKinkNames{"<= 3 theta0", "3-5", "> 5", "no hits"};
+          line += " | all own, by the largest true kink over the rows:";
+          for (std::size_t kink = 0; kink < 4U; ++kink) {
+            line += std::format(" [{}] {} {} {} {} {} {};", kKinkNames[kink], kinkBins[kink][0], kinkBins[kink][1], kinkBins[kink][2], kinkBins[kink][3], kinkBins[kink][4], kinkBins[kink][5]);
+          }
+          line += " outward rows taken:";
+          for (std::size_t count = 0; count <= kMaxClusters; ++count) {
+            if (rows[count] != 0U) {
+              line += std::format(" {}:{}", count, rows[count]);
+            }
+          }
+          std::cout << line << '\n';
+        }
+        for (const auto& [title, group] : {std::pair<const char*, const Increments*>{"refused (refit chi2, all own rows)", &mRefusedIncrements}, std::pair<const char*, const Increments*>{"control (complete, refit kept)", &mKeptIncrements}}) {
+          line = std::format("  refit inward increments by layer, {} {}: layer mean / % > 9.21 / % the largest:", title, group->tracks);
+          for (std::size_t layer = 0; layer < kLayers; ++layer) {
+            if (group->count[layer] != 0U) {
+              const auto c = static_cast<double>(group->count[layer]);
+              line += std::format(" {}: {:.2f} / {:.1f} / {:.1f};", layer, group->sum[layer] / c, study::percent(group->above[layer], group->count[layer]), study::percent(group->largest[layer], group->tracks));
+            }
+          }
+          std::cout << line << '\n';
+        }
+        // Who holds the own row on the first layer missed, by the decision there.
+        for (const std::uint8_t reason : {static_cast<std::uint8_t>(kLostBid), static_cast<std::uint8_t>(kShortReasons)}) {
+          std::array<std::size_t, kHolderKinds> holders{};
+          for (std::size_t index = 0; index < n; ++index) {
+            if (mFate[index] == kShortFate && mStop[index] == kGapInside && mOutStop[index] == reason && mOutHolder[index] < kHolderKinds) {
+              ++holders[mOutHolder[index]];
+            }
+          }
+          line = std::format("  short of an outer layer, {}: the own row on that layer at the end:", reason < kShortReasons ? kShortNames[reason] : "not replayed");
+          for (std::size_t kind = 0; kind < kHolderKinds; ++kind) {
+            if (holders[kind] != 0U) {
+              line += std::format(" {} {};", kHolderNames[kind], holders[kind]);
+            }
+          }
+          std::cout << line << '\n';
+        }
+      }
+    }
+    {
+      // The unconfirmed drops' next step, and the chi2 of the own
+      // rows refused by the gate, against it.
+      constexpr std::size_t kNextOutcomes = kNotVisited + 1U; // the step outcomes and "not visited"
+      constexpr std::array<double, 6> kChi2Edges{0., 15., 25., 50., 100., 1.e300};
+      const auto chi2Bins = [&](const std::vector<Scalar>& chi2, auto&& select) {
+        std::array<std::size_t, kChi2Edges.size() - 1U> bins{};
+        for (std::size_t index = 0; index < n; ++index) {
+          if (select(index)) {
+            for (std::size_t bin = 0; bin + 1U < kChi2Edges.size(); ++bin) {
+              const auto value = static_cast<double>(chi2[index]);
+              bins[bin] += value >= kChi2Edges[bin] && value < kChi2Edges[bin + 1U] ? 1U : 0U;
+            }
+          }
+        }
+        return std::format("gate-15 {} / 15-25 {} / 25-50 {} / 50-100 {} / >100 {}", bins[0], bins[1], bins[2], bins[3], bins[4]);
+      };
+      if (followed) {
+        for (std::size_t outward = 0; outward < 2U; ++outward) {
+          const auto& next = outward == 0U ? mInNext : mOutNext;
+          const auto& nextChi2 = outward == 0U ? mInNextChi2 : mOutNextChi2;
+          std::array<std::size_t, kNextOutcomes> counts{};
+          for (std::size_t index = 0; index < n; ++index) {
+            if (mFate[index] == kShortFate && next[index] < kNextOutcomes) {
+              ++counts[next[index]];
+            }
+          }
+          std::string text = std::format("  {}, unconfirmed drops: the next step with the particle's own row there:", outward == 0U ? "inward" : "outward");
+          for (std::size_t outcome = 0; outcome < kNextOutcomes; ++outcome) {
+            if (counts[outcome] != 0U) {
+              text += std::format(" {} {};", kStepOutcomeNames[outcome], counts[outcome]);
+            }
+          }
+          std::cout << text << '\n';
+          std::cout << std::format("    its chi2 where the gate ({:.2f}) refused it: {}\n", static_cast<double>(mLastGate), chi2Bins(nextChi2, [&](std::size_t index) { return mFate[index] == kShortFate && next[index] == static_cast<std::uint8_t>(StepOutcome::kChi2); }));
+          const auto& own = outward == 0U ? mInChi2 : mOutChi2;
+          const auto& stop = outward == 0U ? mStop : mOutStop;
+          std::cout << std::format("    the own row refused by the gate at the deciding step, its chi2: {}\n", chi2Bins(own, [&](std::size_t index) { return mFate[index] == kShortFate && stop[index] == kChi2; }));
+          // The particle's true kink over the step that refused its next row:
+          // by that step's outcome on the own row.
+          const auto& dropKink = outward == 0U ? mInDropKink : mOutDropKink;
+          std::string kinkText = "    the particle's true kink over that next step, over theta0 (<= 3 / 3-5 / > 5 / no hits), by the step's outcome on the own row:";
+          for (std::size_t outcome = 0; outcome < kNextOutcomes; ++outcome) {
+            std::array<std::size_t, 4> bins{};
+            for (std::size_t index = 0; index < n; ++index) {
+              if (mFate[index] == kShortFate && next[index] == outcome && dropKink[index] < 4U) {
+                ++bins[dropKink[index]];
+              }
+            }
+            if (bins[0] + bins[1] + bins[2] + bins[3] != 0U) {
+              kinkText += std::format(" {} {}/{}/{}/{};", kStepOutcomeNames[outcome], bins[0], bins[1], bins[2], bins[3]);
+            }
+          }
+          std::cout << kinkText << '\n';
+          // The same over the step before, the one that took the dropped row
+          // (outward: the step from the layer below the gap, mOutStepKink).
+          const auto& stepKink = outward == 0U ? mInStepKink : mOutStepKink;
+          kinkText =
+            "    the particle's true kink over the step before, the one that took the dropped row (<= 3 / 3-5 / > 5 / no hits), by the next step's outcome on "
+            "the own row:";
+          for (std::size_t outcome = 0; outcome < kNextOutcomes; ++outcome) {
+            std::array<std::size_t, 4> bins{};
+            for (std::size_t index = 0; index < n; ++index) {
+              if (mFate[index] == kShortFate && next[index] == outcome && stepKink[index] < 4U) {
+                ++bins[stepKink[index]];
+              }
+            }
+            if (bins[0] + bins[1] + bins[2] + bins[3] != 0U) {
+              kinkText += std::format(" {} {}/{}/{}/{};", kStepOutcomeNames[outcome], bins[0], bins[1], bins[2], bins[3]);
+            }
+          }
+          std::cout << kinkText << '\n';
+        }
+      }
+      // The outward kink step's refusal of the own row, under the scaled
+      // gate (the inward one is printed with the short reasons), and the
+      // outward decisions by the particle's pT.
+      {
+        if (followed) {
+          std::array<std::size_t, kNextOutcomes> refused{};
+          for (std::size_t index = 0; index < n; ++index) {
+            if (mFate[index] == kShortFate && mStop[index] == kGapInside && mOutStop[index] == kKinkRefused && mStopDetail[index] % 8U < kNextOutcomes) {
+              ++refused[mStopDetail[index] % 8U];
+            }
+          }
+          std::string text = "  short of an outer layer, kink step refused it, under the scaled gate:";
+          for (std::size_t outcome = 0; outcome < kNextOutcomes; ++outcome) {
+            if (refused[outcome] != 0U) {
+              text += std::format(" {} {};", kStepOutcomeNames[outcome], refused[outcome]);
+            }
+          }
+          std::cout << text << '\n';
+          // The particle's true kink over the step from the layer below the
+          // gap, by the decision there.
+          text =
+            "  short of an outer layer, by the decision at the first it missed, the particle's true kink over the step from the layer below (<= 3 / 3-5 / > 5 "
+            "theta0 / no hits):";
+          for (std::size_t reason = 0; reason <= kShortReasons; ++reason) {
+            std::array<std::size_t, 4> bins{};
+            for (std::size_t index = 0; index < n; ++index) {
+              if (mFate[index] == kShortFate && mStop[index] == kGapInside && mOutStop[index] == reason && mOutStepKink[index] < 4U) {
+                ++bins[mOutStepKink[index]];
+              }
+            }
+            if (bins[0] + bins[1] + bins[2] + bins[3] != 0U) {
+              text += std::format(" {} {}/{}/{}/{};", reason < kShortReasons ? kShortNames[reason] : "not replayed", bins[0], bins[1], bins[2], bins[3]);
+            }
+          }
+          std::cout << text << '\n';
+        }
+        for (std::size_t bin = 0; bin <= kWalkPtEdges.size(); ++bin) {
+          std::array<std::size_t, kShortReasons + 1U> stopsByPt{};
+          std::array<std::size_t, kLayers> layersByPt{};
+          std::size_t total = 0U;
+          std::size_t dropped = 0U;
+          for (std::size_t index = 0; index < n; ++index) {
+            if (mFate[index] != kShortFate || mStop[index] != kGapInside) {
+              continue;
+            }
+            const double pt = truePt(mTruth->particles.find(mFindable[index]));
+            if (std::cmp_not_equal(std::ranges::upper_bound(kWalkPtEdges, pt) - kWalkPtEdges.begin(), bin)) {
+              continue;
+            }
+            ++total;
+            ++stopsByPt[mOutStop[index]];
+            dropped += mOutStopTaken[index] == kOwnDropped && (mOutStop[index] == kOtherTaken || mOutStop[index] == kLookaheadOther) ? 1U : 0U;
+            if (mOutStopLayer[index] < kLayers) {
+              ++layersByPt[mOutStopLayer[index]];
+            }
+          }
+          if (total == 0U) {
+            continue;
+          }
+          std::string byPt = std::format("  short of an outer layer, pT {} GeV: {} (the own row taken and dropped after, by the unconfirmed drop: {}); by the decision:", kWalkPtNames[bin], total, dropped);
+          for (std::size_t reason = 0; reason <= kShortReasons; ++reason) {
+            if (stopsByPt[reason] != 0U) {
+              byPt += std::format(" {} {};", reason < kShortReasons ? kShortNames[reason] : "not replayed", stopsByPt[reason]);
+            }
+          }
+          byPt += " | by the first layer missed:";
+          for (std::size_t layer = 0; layer < kLayers; ++layer) {
+            if (layersByPt[layer] != 0U) {
+              byPt += std::format(" {}:{}", layer, layersByPt[layer]);
+            }
+          }
+          std::cout << byPt << '\n';
+        }
+      }
+    }
+    if (followed) {
+      for (std::size_t kind = 0; kind < 2U; ++kind) {
+        for (std::size_t direction = 0; direction < 2U; ++direction) {
+          const auto& audit = direction == 0U ? mWindowAudit[kind] : mOutWindowAudit[kind];
+          std::cout << std::format("  {}{}, the row against the windows (pair window / covariance window at nSigma / at the gate's sqrt(chi2 max)): ", direction == 0U ? "" : "outward, ", kind == 0U ? "outside the window" : "not queried");
+          for (std::size_t flags = 0; flags < 8U; ++flags) {
+            if (audit[flags] != 0U) {
+              std::cout << std::format("{}{}{} {}; ", (flags & 1U) != 0U ? "P" : "p", (flags & 2U) != 0U ? "N" : "n", (flags & 4U) != 0U ? "G" : "g", audit[flags]);
+            }
+          }
+          std::cout << "(capital: inside)\n";
+        }
+        // How far outside the gate's window the outward rows lie, per axis.
+        auto offsets = mOutWindowOffsets[kind];
+        if (!offsets.empty()) {
+          std::string offsetLine = std::format("  outward, {}, the row's offset from the window's centre over the gate window's half-width, 50/90/99 % (1/50/99 % signed):", kind == 0U ? "outside the window" : "not queried");
+          for (std::size_t axis = 0; axis < 4U; ++axis) {
+            std::ranges::sort(offsets, {}, [axis](const std::array<float, 4>& offset) { return offset[axis]; });
+            const auto quantile = [&](double q) { return offsets[std::min(offsets.size() - 1U, static_cast<std::size_t>(q * static_cast<double>(offsets.size())))][axis]; };
+            constexpr std::array<const char*, 4> kAxes{"azimuth", "second", "azimuth times the charge's sign", "azimuth half-width [um]"};
+            const bool signedAxis = axis == 2U;
+            offsetLine += std::format(" {} {:.2f} {:.2f} {:.2f};", kAxes[axis], quantile(signedAxis ? 0.01 : 0.5), quantile(signedAxis ? 0.5 : 0.9), quantile(0.99));
+          }
+          std::cout << offsetLine << '\n';
+        }
+      }
+    }
+    line = "  not found (the last iteration's cuts):";
+    for (std::size_t reason = 0; reason < kMissedReasons; ++reason) {
+      if (missed[reason] != 0U) {
+        line += std::format(" {} {} ({:.2f} %);", kMissedNames[reason], missed[reason], pc(missed[reason]));
+      }
+    }
+    std::cout << line << '\n';
+    // The same above and below the last iteration's pT floor: a
+    // road refused by the triplet's curvature below the floor is the floor.
+    {
+      const double floor = mFloors.empty() ? 0. : mFloors.back();
+      for (const bool above : {true, false}) {
+        std::array<std::size_t, kMissedReasons> part{};
+        std::size_t total = 0U;
+        std::size_t population = 0U;
+        for (std::size_t index = 0; index < n; ++index) {
+          const double pt = truePt(mTruth->particles.find(mFindable[index]));
+          if ((pt >= floor) != above) {
+            continue;
+          }
+          ++population;
+          if (mFate[index] == kNotFound) {
+            ++total;
+            ++part[mReason[index]];
+          }
+        }
+        std::string text = std::format("  not found, pT {} the last floor {:.2f} GeV ({} of {}):", above ? "at or above" : "below", floor, total, population);
+        for (std::size_t reason = 0; reason < kMissedReasons; ++reason) {
+          if (part[reason] != 0U) {
+            text += std::format(" {} {};", kMissedNames[reason], part[reason]);
+          }
+        }
+        // Of those with no road (made, or its rows sharing no time), the
+        // first graph predicate refusing the true rows.
+        std::array<std::size_t, kGraphReasons + 1U> graph{};
+        for (std::size_t index = 0; index < n; ++index) {
+          const double pt = truePt(mTruth->particles.find(mFindable[index]));
+          if ((pt >= floor) == above && mFate[index] == kNotFound && (mReason[index] == kNoRoad || mReason[index] == kRoadTime)) {
+            ++graph[std::min<std::size_t>(mGraph[index], kGraphReasons)];
+          }
+        }
+        text += " | no road made or its rows sharing no time, by the first predicate refusing the true rows:";
+        for (std::size_t reason = 0; reason <= kGraphReasons; ++reason) {
+          if (graph[reason] != 0U) {
+            text += std::format(" {} {};", reason < kGraphReasons ? kGraphNames[reason] : "not audited", graph[reason]);
+          }
+        }
+        // The roads refused whole, by their largest true kink over the
+        // road's layers.
+        for (const auto reason : {kRoadChi2, kBeamLine}) {
+          std::array<std::size_t, 4> bins{};
+          for (std::size_t index = 0; index < n; ++index) {
+            const double pt = truePt(mTruth->particles.find(mFindable[index]));
+            if ((pt >= floor) == above && mFate[index] == kNotFound && mReason[index] == reason) {
+              ++bins[mMissedKink[index]];
+            }
+          }
+          if (bins[0] + bins[1] + bins[2] + bins[3] != 0U) {
+            text += std::format(" | {} by the road's true kink (<= 3 / 3-5 / > 5 theta0 / no hits): {}/{}/{}/{}", kMissedNames[reason], bins[0], bins[1], bins[2], bins[3]);
+          }
+        }
+        std::cout << text << '\n';
+      }
+    }
+    {
+      std::array<std::array<std::size_t, 3>, kGraphReasons + 1U> graph{};
+      std::vector<float> worstRoad(mFindable.size(), -1.F);
+      // Between the road's layers: the last iteration's.
+      const std::uint64_t road = mRoadLayers.empty() ? ~std::uint64_t{0} : mRoadLayers.back();
+      for (const auto& kink : mKinks) {
+        if (((road >> kink.layer) & 1U) != 0U && ((road >> kink.to) & 1U) != 0U) {
+          worstRoad[kink.particle] = std::max({worstRoad[kink.particle], std::abs(kink.theta), std::abs(kink.phi)});
+        }
+      }
+      for (std::size_t index = 0; index < n; ++index) {
+        if (mFate[index] == kNotFound && (mReason[index] == kNoRoad || mReason[index] == kRoadTime)) {
+          std::size_t kind = worstRoad[index] > 3.F ? 1U : 0U;
+          if (worstRoad[index] < 0.F) {
+            kind = 2U;
+          }
+          ++graph[mGraph[index]][kind];
+        }
+      }
+      line = "  no road made or its rows sharing no time, the first graph predicate refusing the true rows (road kink <= 3 theta0 / > 3 / no hits):";
+      for (std::size_t reason = 0; reason < kGraphReasons; ++reason) {
+        if (graph[reason][0] + graph[reason][1] + graph[reason][2] != 0U) {
+          line += std::format(" {} {}/{}/{};", kGraphNames[reason], graph[reason][0], graph[reason][1], graph[reason][2]);
+        }
+      }
+      std::cout << line << '\n';
+      if (!mCurvatureTriplets.empty()) {
+        std::string text = "  the curvature predicate's refusals of the true rows, by the triplet's layers:";
+        for (const auto& [layers, count] : mCurvatureTriplets) {
+          text += std::format(" {} {};", layers, count);
+        }
+        std::cout << text << '\n';
+      }
+      if (!mLinkRangeRefusals.empty()) {
+        // By the link and the side, the distance outside summed into 1-cm
+        // bins would be too fine: the map's keys hold it to 0.1 cm, so
+        // print the links' totals and the farthest.
+        std::map<std::string, std::pair<std::size_t, double>> byLink;
+        for (const auto& [key, count] : mLinkRangeRefusals) {
+          const auto at = key.find(" by ");
+          const auto distance = std::stod(key.substr(at + 4U));
+          auto& entry = byLink[key.substr(0, at)];
+          entry.first += count;
+          entry.second = std::max(entry.second, distance);
+        }
+        std::string text = "  rows outside their link's source z range, by the link (count, the farthest outside [cm]):";
+        for (const auto& [link, entry] : byLink) {
+          text += std::format(" {} {} ({:.1f});", link, entry.first, entry.second);
+        }
+        std::cout << text << '\n';
+      }
+      const auto sorted = [](const std::map<std::string, std::size_t>& counts) {
+        std::vector<std::pair<std::string, std::size_t>> entries(counts.begin(), counts.end());
+        std::ranges::stable_sort(entries, std::ranges::greater{}, &std::pair<std::string, std::size_t>::second);
+        return entries;
+      };
+      if (!mFakeHolders.empty()) {
+        std::string text = "  road rows held by a fake, by the iteration that made the fake holding the first:";
+        for (const auto& [key, count] : sorted(mFakeHolders)) {
+          text += std::format(" {} {};", key, count);
+        }
+        std::cout << text << '\n';
+      }
+      if (!mPairRefusals.empty()) {
+        std::string text = "  the pair tests' refusals of the true rows, by the link and the true kink over it:";
+        for (const auto& [key, count] : sorted(mPairRefusals)) {
+          text += std::format(" {} {};", key, count);
+        }
+        std::cout << text << '\n';
+      }
+      if (!mRoadFitRefusals.empty()) {
+        std::cout << "  the road fit's chi2 refusals of true roads at or above the floor, by side, species, rows, the road's true kink, chi2 over the "
+                     "kink-free cut (a lower bound), and the fit of the barrel rows and the other rows alone:\n";
+        for (const auto& [key, count] : sorted(mRoadFitRefusals)) {
+          std::cout << std::format("    {} : {}\n", key, count);
+        }
+      }
+      std::cout << std::format("  the graph audit held to the stages' own cuts: {} triplet and neighbour decisions, {} decided otherwise\n", mAuditDecisions, mAuditDisagreements);
+    }
+    if (mWalkDone) {
+      // The beam spot the class was produced in: its production vertices.
+      double sx = 0.;
+      double sy = 0.;
+      double mx = 0.;
+      double my = 0.;
+      std::size_t vertices = 0U;
+      for (const auto particle : mFindable) {
+        const auto found = mTruth->particles.find(particle);
+        if (found == mTruth->particles.end()) {
+          continue;
+        }
+        const auto vx = static_cast<double>(found->second.vx);
+        const auto vy = static_cast<double>(found->second.vy);
+        mx += vx;
+        my += vy;
+        sx += vx * vx;
+        sy += vy * vy;
+        ++vertices;
+      }
+      if (vertices != 0U) {
+        const auto c = static_cast<double>(vertices);
+        mx /= c;
+        my /= c;
+        std::vector<double> ax;
+        std::vector<double> ay;
+        std::size_t beyond = 0U;
+        for (const auto particle : mFindable) {
+          const auto found = mTruth->particles.find(particle);
+          if (found != mTruth->particles.end()) {
+            ax.push_back(std::abs(static_cast<double>(found->second.vx)));
+            ay.push_back(std::abs(static_cast<double>(found->second.vy)));
+            beyond += std::hypot(static_cast<double>(found->second.vx), static_cast<double>(found->second.vy)) > 0.01 ? 1U : 0U;
+          }
+        }
+        // The median |v| of a Gaussian is 0.6745 sigma.
+        std::cout << std::format(
+          "  the class's production vertices: mean ({:.2f}, {:.2f}) um, rms ({:.2f}, {:.2f}) um, core sigma from the median |v| ({:.2f}, "
+          "{:.2f}) um, beyond 100 um from the axis {:.2f} %\n",
+          1.e4 * mx, 1.e4 * my, 1.e4 * std::sqrt(std::max(0., (sx / c) - (mx * mx))), 1.e4 * std::sqrt(std::max(0., (sy / c) - (my * my))), 1.e4 * study::median(ax) / 0.6745, 1.e4 * study::median(ay) / 0.6745, study::percent(beyond, vertices));
+      }
+      constexpr std::array<const char*, 3> kConstructions{"follow", "clusters only", "joint"};
+      std::cout << "  truth walk (every findable, its own rows inward whatever their chi2): prediction against the MC crossing, pull rms loc0 / loc1 (% beyond 3)\n";
+      constexpr std::array<const char*, 3> kSelections{"all", "quiet", "quiet, prompt"};
+      for (std::size_t selection = 0; selection < 3U; ++selection) {
+        for (std::size_t layer = 0; layer < kLayers; ++layer) {
+          if (mWalk[selection][0][layer].n == 0U) {
+            continue;
+          }
+          std::string text = std::format("    {} target {}:", kSelections[selection], layer);
+          for (std::size_t construction = 0; construction < 3U; ++construction) {
+            const auto& sum = mWalk[selection][construction][layer];
+            if (sum.n == 0U) {
+              continue;
+            }
+            const auto count = static_cast<double>(sum.n);
+            text += std::format(" | {} {}: {:.2f} ({:.2f}) / {:.2f} ({:.2f})", kConstructions[construction], sum.n, std::sqrt(sum.s0 / count), study::percent(sum.out0, sum.n), std::sqrt(sum.s1 / count), study::percent(sum.out1, sum.n));
+          }
+          std::cout << text << '\n';
+        }
+      }
+      // The same walks against the cluster, unselected, the
+      // gate's quantity, by target layer and pT: the robust core and the
+      // tails.
+      std::cout << std::format(
+        "  truth walk against the cluster, unselected (by target layer and pT [GeV]): n | median pull loc0 / loc1 | core width "
+        "(1.4826 MAD) loc0 / loc1 | % beyond 3 loc0 / loc1 | % chi2 above the gate ({:.2f}) | transport failed\n",
+        static_cast<double>(mWalkGate));
+      const auto robust = [](std::vector<float> values) {
+        std::ranges::sort(values);
+        const auto med = static_cast<double>(values[values.size() / 2U]);
+        std::vector<float> deviations(values.size());
+        for (std::size_t i = 0; i < values.size(); ++i) {
+          deviations[i] = std::abs(values[i] - static_cast<float>(med));
+        }
+        std::ranges::sort(deviations);
+        const double width = 1.4826 * static_cast<double>(deviations[deviations.size() / 2U]);
+        std::size_t beyond = 0U;
+        for (const auto value : values) {
+          beyond += std::abs(value) > 3.F ? 1U : 0U;
+        }
+        return std::tuple{med, width, study::percent(beyond, values.size())};
+      };
+      for (std::size_t direction = 0; direction < 3U; ++direction) {
+        for (std::size_t layer = 0; layer < kLayers; ++layer) {
+          for (std::size_t bin = 0; bin <= kWalkPtEdges.size(); ++bin) {
+            const auto& pulls = mWalkPulls[direction][layer][bin];
+            if (pulls.pull0.empty() && pulls.fails == 0U) {
+              continue;
+            }
+            if (pulls.pull0.empty()) {
+              std::cout << std::format("    {} target {} pT {}: 0 | transport failed {}\n", kWalkDirectionNames[direction], layer, kWalkPtNames[bin], pulls.fails);
+              continue;
+            }
+            const auto [med0, width0, beyond0] = robust(pulls.pull0);
+            const auto [med1, width1, beyond1] = robust(pulls.pull1);
+            std::cout << std::format("    {} target {} pT {}: {} | {:+.3f} / {:+.3f} | {:.3f} / {:.3f} | {:.2f} / {:.2f} | {:.2f} | {}\n", kWalkDirectionNames[direction], layer, kWalkPtNames[bin], pulls.pull0.size(), med0, med1, width0, width1, beyond0, beyond1, study::percent(pulls.overGate, pulls.pull0.size()), pulls.fails);
+          }
+        }
+      }
+    }
+    for (const auto& text : mTransitionLines) {
+      std::cout << text << '\n';
+    }
+    for (const auto& text : mProgressLines) {
+      std::cout << text << '\n';
+    }
+    {
+      std::string text = std::format("  physical primaries in |eta| < 1 on every layer of the mask, of all, by pT (the lowest {:.3f} GeV):", mLowestPt);
+      for (std::size_t bin = 0; bin < mReach.size(); ++bin) {
+        if (mReach[bin][0] == 0U) {
+          continue;
+        }
+        const std::string range = bin + 1U == mReach.size() ? std::format(">= {:.2f}", 0.05 * static_cast<double>(bin)) : std::format("{:.2f}-{:.2f}", 0.05 * static_cast<double>(bin), 0.05 * static_cast<double>(bin + 1U));
+        text += std::format("\n    {} GeV: {} of {} ({:.1f} %)", range, mReach[bin][1], mReach[bin][0], study::percent(mReach[bin][1], mReach[bin][0]));
+      }
+      std::cout << text << '\n';
+    }
+    printKinks();
+    if (!mPathLines.empty()) {
+      std::cout << mPathLines << '\n';
+    }
+    printInward();
+    printClutter();
+    printDecisions();
+    printBlockers();
+  }
+
+  /// Each iteration's pT floor [GeV], for the class's fates by pT range
+  /// after each iteration (`progress`).
+  void setIterationFloors(std::vector<double> floors) { mFloors = std::move(floors); }
+
+  /// The beam line the tracklet stage's pair cut pairs through, for the
+  /// graph audit.
+  void setBeamLine(const VertexSeed& beamLine) { mBeamLine = beamLine; }
+
+ private:
+  static constexpr std::uint32_t kNoTrack = std::numeric_limits<std::uint32_t>::max();
+  static constexpr std::uint32_t kNoRow = ClusterList<kMaxClusters>::kNoCluster;
+  enum Fate : std::uint8_t { kComplete,
+                             kShortFate,
+                             kNotFound };
+  static constexpr std::array<const char*, 6> kOutcomeNames{"used", "window", "hole", "noUpdate", "chi2", "passesOtherTaken"};
+
+  struct Candidate {
+    std::uint32_t row = 0U;
+    StepOutcome outcome = StepOutcome::kPasses;
+    Scalar chi2 = 0.F;
+    LayerID layer = 0;
+  };
+  /// A layer a step searched and its window.
+  struct TargetSeen {
+    LayerID layer = 0;
+    CandidateWindow window;
+  };
+  /// A row a recovery search's confirmation visited for \a row: \a next,
+  /// kNoRow for the beam line, and its outcome under the nominal gate.
+  struct Witness {
+    std::uint32_t row = 0U;
+    std::uint32_t next = 0U;
+    StepOutcome outcome = StepOutcome::kPasses;
+    Scalar chi2 = 0.F;
+  };
+  /// One step of a replayed proposal: the layer it stepped from, its state
+  /// and factors before it, the row it stepped from, what it visited, what
+  /// it took; of the recovery pass's searches, the kink budget left where
+  /// the kink step was considered (-1: not), whether it looked ahead, the
+  /// rows their search visited under its gate and their witnesses, and
+  /// whether it took a kink step.
+  struct Step {
+    LayerID layer = 0;
+    BoundTrackState state;
+    CovarianceFactors factors;
+    std::uint32_t from = 0U;
+    std::vector<Candidate> candidates;
+    std::vector<TargetSeen> targets;
+    std::uint32_t choice = 0U;
+    int kinksLeft = -1;
+    bool lookahead = false;
+    bool kink = false;
+    std::vector<Candidate> scaled;
+    std::vector<Witness> witnesses;
+    /// The lookahead's confirmations at a nominal step more than one row passed:
+    /// each passing row, its chi2, the next step's row that
+    /// confirmed it (kNoCluster: none) and that row's chi2.
+    struct Lookahead {
+      std::uint32_t row = 0U;
+      Scalar chi2 = 0.F;
+      std::uint32_t next = 0U;
+      Scalar nextChi2 = 0.F;
+    };
+    std::vector<Lookahead> lookaheads;
+    /// The nominal pass's targets without a row, each with whether
+    /// `crossesSensor` called it crossed.
+    std::vector<std::pair<LayerID, bool>> holes;
+  };
+  enum RefitOutcome : std::uint8_t { kRefitKept,
+                                     kRefitFailedFit,
+                                     kRefitAboveChi2 };
+  /// A failed refit's step replayed: the pass run again up to the
+  /// measurement it failed on, the filtered state's propagation there tried,
+  /// and how far its transverse circle reaches beyond the failing plane along
+  /// the plane's transverse normal, and how far its near side stays short of
+  /// it [cm]: it crosses the plane only where both are positive.
+  struct FailedStep {
+    bool replayed = false;
+    bool barrel = false; ///< the plane's normal transverse: the margins are measured
+    PropagationStatus state = PropagationStatus::kOk;
+    float farMargin = 0.F;     ///< the circle's far side beyond the plane
+    float nearMargin = 0.F;    ///< the plane beyond the circle's near side
+    float planeDistance = 0.F; ///< the plane's distance from the beam axis
+    int step = 0;              ///< the failing step, counted from the pass's first measurement
+    float startMiss = 0.F;     ///< the pass's seed against its first measurement, on its surface [cm]
+  };
+  /// One replayed walk of the follow: its raw proposal, its steps, the
+  /// rows the bidding kept of it, of them the rows every kept kink step's
+  /// witness is among, and what the refit did with them.
+  struct Walk {
+    ClusterList<kMaxClusters> road{};
+    std::uint8_t roadCount = 0U;
+    std::vector<std::uint32_t> raw;
+    std::vector<Step> steps;
+    std::uint64_t witnessed = 0U;
+    std::uint32_t bidKept = 0U;
+    std::uint32_t kept = 0U;
+    RefitOutcome refit = kRefitKept;
+    Scalar refitChi2 = 0;    ///< the extended refit's chi2
+    Scalar refitChi2Max = 0; ///< and its cut, the road fit's at its ndf
+    /// A failed refit: the step's status, its pass and the layer it propagated to.
+    PropagationStatus refitStatus = PropagationStatus::kOk;
+    FitPass refitFailedPass = FitPass::kNone;
+    LayerID refitFailedLayer = kInvalidLayerID;
+    /// The failed refit tried again without its outermost outward rows, one
+    /// at a time: the outward rows the first fit that succeeds keeps (-1:
+    /// none), and whether its chi2 is under the cut.
+    int refitTrimmedKept = -1;
+    bool refitTrimmedChi2 = false;
+    FailedStep failedStep;
+    /// The refit's inward pass, the chi2 it decides on: each measurement's
+    /// increment and layer, in the chain's order.
+    std::array<Scalar, kMaxClusters> refitIncrement{};
+    std::array<LayerID, kMaxClusters> refitLayer{};
+    std::uint8_t refitCount = 0U;
+    /// The extended refit's rows as `replayExtension` fits them: the inward
+    /// rows kept, innermost first, then the track's other rows (the road
+    /// and the outward rows kept; for a snapshot's replay the track's rows
+    /// less its inward proposal). Empty without a refit. The inward study's
+    /// chain.
+    std::vector<std::uint32_t> refitRows;
+    /// How the walk ended, the row the unconfirmed drop removed (kNoRow: none), the last row
+    /// refused after it -- at the layout's end (EndDensity) or against the
+    /// beam line (BeamEnd) -- and whether its rows
+    /// begin with the ones the iteration kept.
+    FollowEnd end = FollowEnd::kCapacity;
+    std::uint32_t dropped = kNoRow;
+    std::uint32_t refused = kNoRow;
+    bool agrees = false;
+  };
+  /// A track's replayed follow: its inward walk, and the outward walk
+  /// replayed too: one, its kept rows the iteration's, including a
+  /// snapshot's replay.
+  struct Replay : Walk {
+    std::vector<Walk> outward;
+  };
+
+  struct Recorder : follow::NoObserver {
+    mutable Walk* replay = nullptr;
+    std::uint32_t* from = nullptr;
+    Walk* outward = nullptr;
+    Walk* inward = nullptr;
+    std::uint32_t outerFrom = kNoRow;
+    std::uint32_t innerFrom = kNoRow;
+    void begin(PropagationDirection direction) const
+    {
+      if (outward != nullptr) {
+        replay = direction == PropagationDirection::kForward ? outward : inward;
+        *from = direction == PropagationDirection::kForward ? outerFrom : innerFrom;
+      }
+    }
+    void step(LayerID layer, const BoundTrackState& state, const CovarianceFactors& factors, std::uint32_t /*rows*/) const
+    {
+      Step one;
+      one.layer = layer;
+      one.state = state;
+      one.factors = factors;
+      one.from = *from;
+      one.choice = kNoRow;
+      replay->steps.push_back(std::move(one));
+    }
+    void target(LayerID layer, const CandidateWindow& window) const { replay->steps.back().targets.push_back({.layer = layer, .window = window}); }
+    void hole(LayerID layer, bool crossed) const { replay->steps.back().holes.emplace_back(layer, crossed); }
+    void candidate(LayerID layer, std::uint32_t row, StepOutcome outcome, Scalar chi2) const { replay->steps.back().candidates.push_back({.row = row, .outcome = outcome, .chi2 = chi2, .layer = layer}); }
+    void taken(std::uint32_t row, Scalar /*chi2*/, bool kinked) const
+    {
+      replay->steps.back().choice = row;
+      replay->steps.back().kink = kinked;
+      *from = row;
+    }
+    void kink(std::uint32_t kinksLeft) const { replay->steps.back().kinksLeft = static_cast<int>(kinksLeft); }
+    void lookahead(std::uint32_t /*passing*/) const { replay->steps.back().lookahead = true; }
+    void scaled(LayerID /*layer*/, std::uint32_t row, StepOutcome outcome, Scalar chi2) const { replay->steps.back().scaled.push_back({.row = row, .outcome = outcome, .chi2 = chi2}); }
+    void confirmation(std::uint32_t row, bool confirmed, std::uint32_t next, Scalar chi2) const { replay->steps.back().witnesses.push_back({.row = row, .next = next, .outcome = confirmed ? StepOutcome::kPasses : StepOutcome::kChi2, .chi2 = chi2}); }
+    void lookaheadConfirmation(std::uint32_t row, Scalar chi2, std::uint32_t next, Scalar nextChi2) const { replay->steps.back().lookaheads.push_back({.row = row, .chi2 = chi2, .next = next, .nextChi2 = nextChi2}); }
+    void unconfirmed(std::uint32_t row) const { replay->dropped = row; }
+    void refusedEnd(std::uint32_t row) const { replay->refused = row; }
+    void refusedBeamEnd(std::uint32_t row) const { replay->refused = row; }
+    void end(FollowEnd why) const { replay->end = why; }
+  };
+  /// The iteration's follow stage, with the same dispatch for both replays.
+  template <typename Observation, typename Material, typename Body>
+  void withFollowStage(const Observation& iteration, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator, const std::uint8_t* used, std::uint32_t first, const Body& body)
+  {
+    withBools(
+      [&]<bool BeamLine, bool Greedy, bool EndDensity, bool BeamEnd>(std::bool_constant<BeamLine>, std::bool_constant<Greedy>, std::bool_constant<EndDensity>, std::bool_constant<BeamEnd>) {
+        if constexpr (BeamLine || !BeamEnd) {
+          const FollowStage<Det, Material, BeamLine, false, Greedy, EndDensity, BeamEnd> stage{&parameters, &frame, &geometry, &material, propagator, iteration.tracks->view(), used, mMaxWidthPS.data(), mCells.view(), nullptr, nullptr, parameters.sharedInnermost == 0U, first};
+          body(stage);
+        }
+      },
+      parameters.beamConstraint, parameters.followGreedy, Follow<Det>::endDensity(parameters), parameters.followBeamEnd);
+  }
+
+  /// Both walks through the stage's sequencing: outward first, its narrowed
+  /// time box and walked count carried into the inward walk.
+  template <typename Stage>
+  static auto recordFollow(const Stage& stage, const BoundTrackState& inner, const BoundTrackState& outer, const ClusterList<kMaxClusters>& road, std::uint8_t count, Walk& inward, Walk& outward)
+  {
+    FollowProposal<kMaxClusters> proposal{};
+    follow::KinkSteps steps{};
+    std::uint32_t from = road.index[0];
+    const Recorder recorder{{}, &inward, &from, &outward, &inward, road.index[count - 1U], road.index[0]};
+    stage.follow(inner, outer, road, count, proposal, steps, recorder);
+    outward.raw.assign(proposal.outward, proposal.outward + proposal.outwardCount);
+    outward.witnessed = steps.outwardWitnessed;
+    inward.raw.assign(proposal.inward, proposal.inward + proposal.inwardCount);
+    inward.witnessed = steps.inwardWitnessed;
+    return proposal;
+  }
+
+  /// A track as an iteration left it, for the next one's follow of it.
+  struct Snapshot {
+    ClusterList<kMaxClusters> clusters{};
+    std::uint8_t count = 0U;
+    BoundTrackState state;
+    BoundTrackState outwardState;
+  };
+
+  /// A track's road: its \a rows less those its follow added (\a proposal's
+  /// inward and outward rows), all of them without a proposal (no follow).
+  /// Not `roadRows`, the truth's road.
+  template <typename Proposal>
+  [[nodiscard]] static std::vector<std::uint32_t> roadOf(std::span<const std::uint32_t> rows, const Proposal* proposal)
+  {
+    std::vector<std::uint32_t> road;
+    for (const auto row : rows) {
+      if (proposal == nullptr || (std::find(proposal->inward, proposal->inward + proposal->inwardCount, row) == proposal->inward + proposal->inwardCount && std::find(proposal->outward, proposal->outward + proposal->outwardCount, row) == proposal->outward + proposal->outwardCount)) {
+        road.push_back(row);
+      }
+    }
+    return road;
+  }
+  /// The true pT [GeV] of the particle \a found points to, 0 for none (the
+  /// table's end).
+  [[nodiscard]] double truePt(study::ParticleTable::const_iterator found) const { return found != mTruth->particles.end() ? static_cast<double>(found->second.pt) : 0.; }
+  /// The production vertex in r-z [cm] of the particle \a found points to,
+  /// the origin for none (the table's end): the reference of `pathDistance`.
+  [[nodiscard]] std::array<double, 2> vertexRZ(study::ParticleTable::const_iterator found) const
+  {
+    if (found == mTruth->particles.end()) {
+      return {0., 0.};
+    }
+    return {std::hypot(static_cast<double>(found->second.vx), static_cast<double>(found->second.vy)), static_cast<double>(found->second.vz)};
+  }
+  /// How far \a row is from a particle's production \a vertex (`vertexRZ`)
+  /// in r-z [cm]: the order of "further along the particle's path" for the
+  /// fake transitions, the end decisions and the hole calls.
+  [[nodiscard]] double pathDistance(std::uint32_t row, const std::array<double, 2>& vertex) const { return std::hypot(static_cast<double>(mTruth->rows[row].r) - vertex[0], static_cast<double>(mTruth->rows[row].z) - vertex[1]); }
+
+  /// Where the iteration's fakes came from: each fake track after the iteration, by its length, as an
+  /// earlier track it was before -- a fake kept, a fake lengthened, a good
+  /// track made fake by the rows its follow again added -- or as the
+  /// iteration's own, its road holding a wrong row or its follow adding
+  /// one. Of the rows made wrong by a follow, the first: the step that
+  /// took it (a kink step, a step more than one row passed, a step one row
+  /// passed, outward) and what that step did with the particle's own row on
+  /// its layer.
+  template <typename Observation>
+  void fakeTransitions(const Observation& iteration, const std::vector<Replay>& replayed, const std::vector<Replay>& recovered)
+  {
+    const auto view = iteration.tracks->view();
+    const auto tracks = iteration.tracks->size();
+    enum Kind : std::uint8_t { kFakeKept,
+                               kFakeLonger,
+                               kMadeFake,
+                               kRoadFake,
+                               kFollowFake,
+                               kKinds };
+    enum Source : std::uint8_t { kKinkSource,
+                                 kSeveralPassed,
+                                 kOnePassed,
+                                 kSources };
+    constexpr std::array<const char*, kKinds> kKindNames{"earlier fake, kept", "earlier fake, lengthened", "earlier good, made fake", "own: road holds a wrong row", "own: its follow adds one"};
+    constexpr std::array<const char*, kSources> kSourceNames{"kink step", "more than one row passed", "one row passed"};
+    // The particle's own rows at the step (StepOutcome's names first, the
+    // best outcome of its rows on the layer), and the refinements: no
+    // own row there with own rows further along the particle's path (by
+    // `sortByTraversal`'s distance from its vertex) free or all held, or past
+    // its last one; its own row passing with the taken row's chi2 below,
+    // equal to or above its own (the lookahead's choice); the walk's replay
+    // not agreeing with the rows the iteration kept.
+    enum OwnStatus : std::uint8_t { kOwnNotVisited = 6,
+                                    kOwnGapFree,
+                                    kOwnNotReplayed,
+                                    kOwnPastLast,
+                                    kOwnPassingTakenHigher,
+                                    kOwnPassingEqual,
+                                    kOwnGapHeld,
+                                    kOwnDisagrees,
+                                    kOwnPastLastReturn,
+                                    kOwnStatuses };
+    constexpr std::array<const char*, kOwnStatuses> kOwnNames{"held", "outside the window", "crossing a layer", "no update", "chi2", "passing, taken lower", "not visited", "no own row, free own rows beyond", "not replayed", "no own row, past its last", "passing, taken higher", "passing, equal", "no own row, own rows beyond all held", "replay disagrees", "no own row, past its last on this leg, own rows on later legs"};
+    constexpr std::array<double, 4> kPtEdges{0.2, 0.3, 0.6, 1e9};
+    constexpr std::array<const char*, 4> kPtNames{"< 0.2", "0.2-0.3", "0.3-0.6", ">= 0.6"};
+    std::array<std::array<std::array<std::size_t, kOwnStatuses>, kPtEdges.size()>, 2> byPt{}; // [inward, outward][pT][own status]
+    std::array<std::array<std::size_t, kMaxClusters + 1U>, kKinds> kinds{};
+    std::array<std::array<std::array<std::size_t, kOwnStatuses>, kSources>, 2> sources{}; // [inward, outward][source][own status]
+    // The same for the class's particles,
+    // and their first wrong row's layer by the own row's status there.
+    std::array<std::array<std::array<std::size_t, kOwnStatuses>, kSources>, 2> classSources{};
+    std::array<std::array<std::size_t, kOwnStatuses>, kLayers> classByLayer{};
+    std::array<std::size_t, 4> roadWrong{}; // own road fakes: 0..2 wrong rows, 3 or more
+    std::array<std::size_t, kLayers> roadWrongLayer{};
+    std::array<std::size_t, 5> roadWhose{};              // the majority particle: the class, a primary missing a layer, one below the floor, not a primary, none
+    std::array<std::size_t, 3> roadOwnThere{};           // its own row on a wrong row's layer: none, held by a track, free
+    std::array<std::size_t, kLayers> followWrongLayer{}; // follow fakes: the first wrong row's layer
+    std::array<std::size_t, kLayers> followRoadInner{};  // follow fakes: the road's innermost layer
+    std::array<std::size_t, kLayers> goodRoadInner{};    // the iteration's own good tracks: the road's innermost layer
+    std::array<std::size_t, kLayers> roadFakeInner{};    // own road fakes: the road's innermost layer
+    std::vector<bool> held(mTruth->rows.size(), false);
+    for (std::uint32_t track = 0; track < tracks; ++track) {
+      for (std::uint8_t i = 0; i < view.count[track]; ++i) {
+        held[view.clusters[track].index[i]] = true;
+      }
+    }
+    const auto holderOf = [&](std::uint32_t row) { return static_cast<bool>(held[row]); };
+    const auto wrongRow = [&](std::uint64_t particle, std::span<const std::uint32_t> rows) -> std::uint32_t {
+      for (const auto row : rows) {
+        if (!mTruth->rows[row].carries(particle)) {
+          return row;
+        }
+      }
+      return kNoTrack;
+    };
+    // The step of \a replay that took \a row, and the particle's own rows there:
+    // the inward walk's, or with \a outward the outward walk's.
+    const auto attribute = [&](const Replay* replay, std::uint64_t particle, std::uint32_t row, bool outward) {
+      const Walk* walk = replay;
+      if (outward) {
+        walk = replay != nullptr && !replay->outward.empty() ? &replay->outward.front() : nullptr;
+      }
+      const auto found = mTruth->particles.find(particle);
+      const double pt = truePt(found);
+      const auto bin = static_cast<std::size_t>(std::ranges::upper_bound(kPtEdges, pt) - kPtEdges.begin());
+      auto& counts = sources[outward ? 1U : 0U];
+      auto& binned = byPt[outward ? 1U : 0U][std::min(bin, kPtEdges.size() - 1U)];
+      const bool inClass = mIndex.contains(particle);
+      const auto count = [&](Source source, std::size_t status) {
+        ++counts[source][status];
+        ++binned[status];
+        if (inClass) {
+          ++classSources[outward ? 1U : 0U][source][status];
+          ++classByLayer[mTruth->rows[row].layer][status];
+        }
+      };
+      if (walk == nullptr) {
+        count(kOnePassed, kOwnNotReplayed);
+        return;
+      }
+      if (!walk->agrees) {
+        count(kOnePassed, kOwnDisagrees);
+        return;
+      }
+      const auto step = std::ranges::find(walk->steps, row, &Step::choice);
+      if (step == walk->steps.end()) {
+        count(kOnePassed, kOwnNotReplayed);
+        return;
+      }
+      std::size_t passed = 0U;
+      for (const auto& candidate : step->candidates) {
+        passed += candidate.outcome == StepOutcome::kPasses ? 1U : 0U;
+      }
+      Source source = passed > 1U ? kSeveralPassed : kOnePassed;
+      if (step->kink) {
+        source = kKinkSource;
+      }
+      const auto layer = mTruth->rows[row].layer;
+      const auto& seen = step->kink ? step->scaled : step->candidates;
+      const auto taken = std::ranges::find(seen, row, &Candidate::row);
+      // Every own row on the layer: the best outcome among them (passing
+      // first, then by StepOutcome's order from the end).
+      const auto& ownRows = mRowsOf.at(particle);
+      bool onLayer = false;
+      const Candidate* best = nullptr;
+      for (const auto own : ownRows) {
+        if (mTruth->rows[own].layer != layer) {
+          continue;
+        }
+        onLayer = true;
+        const auto at = std::ranges::find(seen, own, &Candidate::row);
+        if (at != seen.end() && (best == nullptr || static_cast<int>(at->outcome) > static_cast<int>(best->outcome) || (at->outcome == best->outcome && at->chi2 < best->chi2))) {
+          best = &*at;
+        }
+      }
+      std::size_t status = kOwnNotVisited;
+      // The step's row in the particle's path order: where
+      // it is the particle's and its rows are timed, the rows beyond it are
+      // the later ones (outward) or the earlier (inward), and those on its
+      // own leg are what the walk could still take.
+      const auto inClassIndex = mIndex.find(particle);
+      const auto fromAt = std::ranges::find(ownRows, step->from);
+      const bool pathKnown = inClassIndex != mIndex.end() && !mLegs.empty() && mTimed[inClassIndex->second] != 0U && fromAt != ownRows.end();
+      if (!onLayer && pathKnown) {
+        const auto& legs = mLegs[inClassIndex->second];
+        const auto from = static_cast<std::size_t>(fromAt - ownRows.begin());
+        bool sameLeg = false;
+        bool otherLeg = false;
+        bool free = false;
+        for (std::size_t k = 0; k < ownRows.size(); ++k) {
+          if (outward ? k <= from : k >= from) {
+            continue;
+          }
+          if (legs[k] == legs[from]) {
+            sameLeg = true;
+            free = free || (ownRows[k] < mFollowUsedNow.size() && mFollowUsedNow[ownRows[k]] == kFree);
+          } else {
+            otherLeg = true;
+          }
+        }
+        status = sameLeg ? (free ? std::size_t{kOwnGapFree} : std::size_t{kOwnGapHeld}) : (otherLeg ? std::size_t{kOwnPastLastReturn} : std::size_t{kOwnPastLast});
+      } else if (!onLayer) {
+        // Further along the particle's path than the taken row, in the
+        // walk's direction: free at the follow, or all held.
+        const auto vertex = vertexRZ(found);
+        const auto distance = [&](std::uint32_t one) { return pathDistance(one, vertex); };
+        const double here = distance(row);
+        bool beyond = false;
+        bool free = false;
+        for (const auto own : ownRows) {
+          if (outward ? distance(own) > here : distance(own) < here) {
+            beyond = true;
+            free = free || (own < mFollowUsedNow.size() && mFollowUsedNow[own] == kFree);
+          }
+        }
+        status = !beyond ? std::size_t{kOwnPastLast} : (free ? std::size_t{kOwnGapFree} : std::size_t{kOwnGapHeld});
+      } else if (best != nullptr) {
+        status = static_cast<std::size_t>(best->outcome);
+        if (best->outcome == StepOutcome::kPasses && taken != seen.end()) {
+          status = taken->chi2 > best->chi2 ? std::size_t{kOwnPassingTakenHigher} : (taken->chi2 < best->chi2 ? static_cast<std::size_t>(StepOutcome::kPasses) : std::size_t{kOwnPassingEqual});
+        }
+      }
+      count(source, status);
+    };
+    for (std::uint32_t track = 0; track < tracks; ++track) {
+      const std::span<const std::uint32_t> rows{view.clusters[track].index, view.count[track]};
+      if (study::goodParticle(mTruth->rows, rows) != study::kNoTrackParticle) {
+        if (track >= iteration.trackOffset) {
+          const auto element = track - iteration.trackOffset;
+          const auto* proposal = element < iteration.proposals.size() ? &iteration.proposals[element] : nullptr;
+          std::uint8_t innermost = std::numeric_limits<std::uint8_t>::max();
+          for (const auto row : roadOf(rows, proposal)) {
+            innermost = std::min(innermost, static_cast<std::uint8_t>(mTruth->rows[row].layer));
+          }
+          if (innermost < kLayers) {
+            ++goodRoadInner[innermost];
+          }
+        }
+        continue;
+      }
+      const auto length = static_cast<std::size_t>(view.count[track]);
+      if (track < iteration.trackOffset) {
+        // An earlier track: as the previous iteration left it.
+        if (track >= mSnapshot.size()) {
+          continue;
+        }
+        const std::span<const std::uint32_t> before{mSnapshot[track].clusters.index, mSnapshot[track].count};
+        const auto particle = study::goodParticle(mTruth->rows, before);
+        if (particle == study::kNoTrackParticle) {
+          ++kinds[before.size() == rows.size() ? kFakeKept : kFakeLonger][length];
+          continue;
+        }
+        ++kinds[kMadeFake][length];
+        const auto* proposal = track < iteration.earlierProposals.size() ? &iteration.earlierProposals[track] : nullptr;
+        if (proposal == nullptr) {
+          continue;
+        }
+        const auto inward = wrongRow(particle, {proposal->inward, proposal->inwardCount});
+        attribute(track < recovered.size() ? &recovered[track] : nullptr, particle, inward != kNoTrack ? inward : wrongRow(particle, {proposal->outward, proposal->outwardCount}), inward == kNoTrack);
+        continue;
+      }
+      // The iteration's own: its road, the rows its follow did not add.
+      const auto element = track - iteration.trackOffset;
+      // Without a follow (no proposal) the track is its road.
+      const auto* proposal = element < iteration.proposals.size() ? &iteration.proposals[element] : nullptr;
+      const auto road = roadOf(rows, proposal);
+      const auto particle = study::goodParticle(mTruth->rows, road);
+      if (particle == study::kNoTrackParticle) {
+        ++kinds[kRoadFake][length];
+        // Its wrong rows, where they are, and whose track it mostly is.
+        const auto majority = study::majorityParticle(mTruth->rows, rows);
+        ++roadWrong[std::min<std::size_t>(rows.size() - majority.carried, 3U)];
+        ++roadFakeInner[mTruth->rows[std::ranges::min(road, {}, [&](std::uint32_t row) { return mTruth->rows[row].layer; })].layer];
+        for (const auto row : road) {
+          if (!mTruth->rows[row].carries(majority.particle)) {
+            ++roadWrongLayer[mTruth->rows[row].layer];
+            const auto own = ownRowOn(majority.particle, mTruth->rows[row].layer);
+            ++roadOwnThere[own == kNoTrack ? 0U : (holderOf(own) ? 1U : 2U)];
+          }
+        }
+        const auto found = mTruth->particles.find(majority.particle);
+        std::size_t whose = 4U;
+        if (mIndex.contains(majority.particle)) {
+          whose = 0U;
+        } else if (found != mTruth->particles.end() && found->second.origin != study::ParticleOrigin::kPhysicalPrimary) {
+          whose = 3U;
+        } else if (found != mTruth->particles.end()) {
+          whose = static_cast<double>(found->second.pt) < mMinPtGeV ? 2U : 1U;
+        }
+        ++roadWhose[whose];
+        continue;
+      }
+      ++kinds[kFollowFake][length];
+      const auto inward = wrongRow(particle, {proposal->inward, proposal->inwardCount});
+      const auto first = inward != kNoTrack ? inward : wrongRow(particle, {proposal->outward, proposal->outwardCount});
+      if (first != kNoTrack) {
+        ++followWrongLayer[mTruth->rows[first].layer];
+      }
+      const auto innermost = std::ranges::min(road, {}, [&](std::uint32_t row) { return mTruth->rows[row].layer; });
+      ++followRoadInner[mTruth->rows[innermost].layer];
+      attribute(element < replayed.size() ? &replayed[element] : nullptr, particle, inward != kNoTrack ? inward : wrongRow(particle, {proposal->outward, proposal->outwardCount}), inward == kNoTrack);
+    }
+    std::string text = std::format("  fakes after iteration {}, by where they came from (by length):", iteration.iteration);
+    for (std::size_t kind = 0; kind < kKinds; ++kind) {
+      std::size_t total = 0U;
+      std::string lengths;
+      for (std::size_t length = 0; length <= kMaxClusters; ++length) {
+        total += kinds[kind][length];
+        if (kinds[kind][length] != 0U) {
+          lengths += std::format(" {}:{}", length, kinds[kind][length]);
+        }
+      }
+      if (total != 0U) {
+        text += std::format("\n    {} {} ({} )", kKindNames[kind], total, lengths);
+      }
+    }
+    if (std::ranges::any_of(kinds[kRoadFake], [](std::size_t count) { return count != 0U; })) {
+      text += std::format("\n    own road fakes: wrong rows 1: {}, 2: {}, 3+: {}; their road's wrong rows by layer:", roadWrong[1], roadWrong[2], roadWrong[3]);
+      for (std::size_t layer = 0; layer < kLayers; ++layer) {
+        if (roadWrongLayer[layer] != 0U) {
+          text += std::format(" {}:{}", layer, roadWrongLayer[layer]);
+        }
+      }
+      text += std::format(
+        "; mostly the track of: the class {}, a physical primary missing a layer of the mask {}, one below the pT floor {}, not a primary {}, "
+        "unknown {}; its own row on a wrong row's layer: none {}, held {}, free {}",
+        roadWhose[0], roadWhose[1], roadWhose[2], roadWhose[3], roadWhose[4], roadOwnThere[0], roadOwnThere[1], roadOwnThere[2]);
+      text += "; the road's innermost layer:";
+      for (std::size_t layer = 0; layer < kLayers; ++layer) {
+        if (roadFakeInner[layer] != 0U) {
+          text += std::format(" {}:{}", layer, roadFakeInner[layer]);
+        }
+      }
+    }
+    if (std::ranges::any_of(kinds[kFollowFake], [](std::size_t count) { return count != 0U; })) {
+      text += "\n    own follow fakes: the first wrong row's layer:";
+      for (std::size_t layer = 0; layer < kLayers; ++layer) {
+        if (followWrongLayer[layer] != 0U) {
+          text += std::format(" {}:{}", layer, followWrongLayer[layer]);
+        }
+      }
+      text += "; the road's innermost layer:";
+      for (std::size_t layer = 0; layer < kLayers; ++layer) {
+        if (followRoadInner[layer] != 0U) {
+          text += std::format(" {}:{}", layer, followRoadInner[layer]);
+        }
+      }
+    }
+    text += "\n    own good tracks, the road's innermost layer:";
+    for (std::size_t layer = 0; layer < kLayers; ++layer) {
+      if (goodRoadInner[layer] != 0U) {
+        text += std::format(" {}:{}", layer, goodRoadInner[layer]);
+      }
+    }
+    text += "\n    the first wrong row a follow added, by the walk and the step that took it | the particle's own row at that step:";
+    for (std::size_t walk = 0; walk < 2U; ++walk) {
+      for (std::size_t source = 0; source < kSources; ++source) {
+        std::size_t total = 0U;
+        std::string own;
+        for (std::size_t status = 0; status < kOwnNames.size(); ++status) {
+          total += sources[walk][source][status];
+          if (sources[walk][source][status] != 0U) {
+            own += std::format(" {} {};", kOwnNames[status], sources[walk][source][status]);
+          }
+        }
+        if (total != 0U) {
+          text += std::format("\n      {}, {} {} |{}", walk == 0U ? "inward" : "outward", kSourceNames[source], total, own);
+        }
+      }
+    }
+    text += "\n    the same by the particle's pT:";
+    for (std::size_t walk = 0; walk < 2U; ++walk) {
+      for (std::size_t bin = 0; bin < kPtEdges.size(); ++bin) {
+        std::size_t total = 0U;
+        std::string own;
+        for (std::size_t status = 0; status < kOwnNames.size(); ++status) {
+          total += byPt[walk][bin][status];
+          if (byPt[walk][bin][status] != 0U) {
+            own += std::format(" {} {};", kOwnNames[status], byPt[walk][bin][status]);
+          }
+        }
+        if (total != 0U) {
+          text += std::format("\n      {}, pT {} GeV {} |{}", walk == 0U ? "inward" : "outward", kPtNames[bin], total, own);
+        }
+      }
+    }
+    text += "\n    the same for the class's particles:";
+    for (std::size_t walk = 0; walk < 2U; ++walk) {
+      for (std::size_t source = 0; source < kSources; ++source) {
+        std::size_t total = 0U;
+        std::string own;
+        for (std::size_t status = 0; status < kOwnNames.size(); ++status) {
+          total += classSources[walk][source][status];
+          if (classSources[walk][source][status] != 0U) {
+            own += std::format(" {} {};", kOwnNames[status], classSources[walk][source][status]);
+          }
+        }
+        if (total != 0U) {
+          text += std::format("\n      {}, {} {} |{}", walk == 0U ? "inward" : "outward", kSourceNames[source], total, own);
+        }
+      }
+    }
+    text += "\n    the class's particles, by the first wrong row's layer | the particle's own row at that step:";
+    for (std::size_t layer = 0; layer < kLayers; ++layer) {
+      std::size_t total = 0U;
+      std::string own;
+      for (std::size_t status = 0; status < kOwnNames.size(); ++status) {
+        total += classByLayer[layer][status];
+        if (classByLayer[layer][status] != 0U) {
+          own += std::format(" {} {};", kOwnNames[status], classByLayer[layer][status]);
+        }
+      }
+      if (total != 0U) {
+        text += std::format("\n      layer {} {} |{}", layer, total, own);
+      }
+    }
+    mTransitionLines.push_back(text);
+  }
+
+  /// What the unconfirmed drop saw where it removed a row,
+  /// over the walks of the iteration's own good roads: whether the dropped
+  /// row was the road's particle's, and what the step that found nothing
+  /// (the walk's last) had seen: a row of the particle or of another within
+  /// the window but above the gate (a failed update does not count), a row
+  /// passing the kink pass's scaled gate (unconfirmed, or the pass not made
+  /// for want of a budget or an allowance), or nothing of either. The
+  /// strongest kind is counted: scaled before gated, the particle's before
+  /// another's.
+  template <typename Observation>
+  void endEvidence(const Observation& iteration, const std::vector<Replay>& replayed)
+  {
+    enum Seen : std::uint8_t { kSeenOwnScaled,
+                               kSeenOtherScaled,
+                               kSeenOwnGated,
+                               kSeenOtherGated,
+                               kSeenNone,
+                               kSeenNoKinkPass,
+                               kSeenKinds };
+    constexpr std::array<const char*, kSeenKinds> kSeenNames{"the particle's row passing the scaled gate", "another row passing the scaled gate", "the particle's row within the window, above the gate", "another row within the window, above the gate", "nothing in the window", "nothing in the window, no kink pass"};
+    constexpr std::array<double, 4> kPtEdges{0.3, 0.6, 1., 1e9};
+    constexpr std::array<const char*, 4> kPtNames{"< 0.3", "0.3-0.6", "0.6-1", ">= 1"};
+    // [walk][dropped the particle's / another's][pT][seen]
+    std::array<std::array<std::array<std::array<std::size_t, kSeenKinds>, kPtEdges.size()>, 2>, 2> counts{};
+    for (const auto& replay : replayed) {
+      const std::span<const std::uint32_t> road{replay.road.index, replay.roadCount};
+      const auto particle = study::goodParticle(mTruth->rows, road);
+      if (particle == study::kNoTrackParticle) {
+        continue;
+      }
+      const auto found = mTruth->particles.find(particle);
+      const double pt = truePt(found);
+      const auto bin = std::min(static_cast<std::size_t>(std::ranges::upper_bound(kPtEdges, pt) - kPtEdges.begin()), kPtEdges.size() - 1U);
+      const auto one = [&](const Walk& walk, std::size_t direction) {
+        // Agreeing walks only; a gated row is one the update was made for
+        // (a failed update is no evidence); the scaled evidence exists only
+        // where the kink pass ran (a spent budget shows as none).
+        if (walk.dropped == kNoRow || walk.steps.empty() || !walk.agrees) {
+          return;
+        }
+        const auto& last = walk.steps.back();
+        bool ownScaled = false;
+        bool otherScaled = false;
+        bool ownGated = false;
+        bool otherGated = false;
+        for (const auto& candidate : last.scaled) {
+          if (candidate.outcome == StepOutcome::kPasses) {
+            (mTruth->rows[candidate.row].carries(particle) ? ownScaled : otherScaled) = true;
+          }
+        }
+        for (const auto& candidate : last.candidates) {
+          if (candidate.outcome == StepOutcome::kChi2) {
+            (mTruth->rows[candidate.row].carries(particle) ? ownGated : otherGated) = true;
+          }
+        }
+        const std::size_t seen = ownScaled ? kSeenOwnScaled : (otherScaled ? kSeenOtherScaled : (ownGated ? kSeenOwnGated : (otherGated ? kSeenOtherGated : (last.kinksLeft < 0 ? kSeenNoKinkPass : kSeenNone))));
+        ++counts[direction][mTruth->rows[walk.dropped].carries(particle) ? 0U : 1U][bin][seen];
+      };
+      one(replay, 0U);
+      if (!replay.outward.empty()) {
+        one(replay.outward.front(), 1U);
+      }
+    }
+    std::string text = std::format("  the unconfirmed drops after iteration {} (the walks of the iteration's own good roads), by the dropped row and what the refusing step saw:", iteration.iteration);
+    for (std::size_t direction = 0; direction < 2U; ++direction) {
+      for (std::size_t own = 0; own < 2U; ++own) {
+        for (std::size_t bin = 0; bin < kPtEdges.size(); ++bin) {
+          std::size_t total = 0U;
+          std::string seen;
+          for (std::size_t kind = 0; kind < kSeenKinds; ++kind) {
+            total += counts[direction][own][bin][kind];
+            if (counts[direction][own][bin][kind] != 0U) {
+              seen += std::format(" {} {};", kSeenNames[kind], counts[direction][own][bin][kind]);
+            }
+          }
+          if (total != 0U) {
+            text += std::format("\n    {}, dropped {} row, pT {} GeV {} |{}", direction == 0U ? "inward" : "outward", own == 0U ? "the particle's" : "another's", kPtNames[bin], total, seen);
+          }
+        }
+      }
+    }
+    mTransitionLines.push_back(text);
+  }
+
+  /// The lookahead against the step's own chi2
+  /// ranking, paired, at every nominal step of the iteration's own tracks'
+  /// agreeing walks where more than one row passed and the road's particle
+  /// is among them: whether the lookahead's choice and the smallest chi2 are the
+  /// particle's row (both, the lookahead corrects, the lookahead spoils, neither), by the rows
+  /// passing and the particle's pT; where they differ, what confirmed each
+  /// (the particle's next row, another row, none).
+  template <typename Observation>
+  void lookaheadPairs(const Observation& iteration, const std::vector<Replay>& replayed)
+  {
+    enum Pair : std::uint8_t { kBoth,
+                               kCorrects,
+                               kSpoils,
+                               kNeither,
+                               kPairs };
+    constexpr std::array<const char*, kPairs> kPairNames{"both the particle's", "the lookahead corrects", "the lookahead spoils", "neither"};
+    constexpr std::array<const char*, 3> kPassing{"2 passing", "3 passing", "4+ passing"};
+    constexpr std::array<double, 4> kPtEdges{0.2, 0.3, 0.6, 1e9};
+    constexpr std::array<const char*, 4> kPtNames{"< 0.2", "0.2-0.3", "0.3-0.6", ">= 0.6"};
+    constexpr std::array<const char*, 3> kWitness{"own next", "other next", "none"};
+    std::array<std::array<std::size_t, kPairs>, 3> byPassing{};
+    std::array<std::array<std::size_t, kPairs>, 4> byPt{};
+    // Where the lookahead and chi2 differ: [corrects, spoils][the lookahead's choice's witness][the chi2 choice's witness]
+    std::array<std::array<std::array<std::size_t, 3>, 3>, 2> witnesses{};
+    std::size_t noOwn = 0U;
+    std::size_t steps = 0U;
+    for (std::uint32_t element = 0; element < replayed.size(); ++element) {
+      const auto& replay = replayed[element];
+      if (replay.roadCount == 0U) {
+        continue;
+      }
+      const auto particle = study::goodParticle(mTruth->rows, std::span<const std::uint32_t>{replay.road.index, replay.roadCount});
+      if (particle == study::kNoTrackParticle) {
+        continue;
+      }
+      const auto found = mTruth->particles.find(particle);
+      const double pt = truePt(found);
+      const auto ptBin = std::min(static_cast<std::size_t>(std::ranges::upper_bound(kPtEdges, pt) - kPtEdges.begin()), kPtEdges.size() - 1U);
+      const auto witnessOf = [&](const Step::Lookahead& one) { return one.next == ClusterList<kMaxClusters>::kNoCluster ? 2U : (mTruth->rows[one.next].carries(particle) ? 0U : 1U); };
+      const auto walks = [&](const Walk& walk) {
+        if (!walk.agrees) {
+          return;
+        }
+        for (const auto& step : walk.steps) {
+          if (step.kink || step.lookaheads.size() < 2U || step.choice == kNoRow) {
+            continue;
+          }
+          ++steps;
+          const auto r2 = std::ranges::find(step.lookaheads, step.choice, &Step::Lookahead::row);
+          const auto chi2 = std::ranges::min_element(step.lookaheads, [](const Step::Lookahead& a, const Step::Lookahead& b) { return a.chi2 < b.chi2 || (!(b.chi2 < a.chi2) && a.row < b.row); });
+          const bool ownPassing = std::ranges::any_of(step.lookaheads, [&](const Step::Lookahead& one) { return mTruth->rows[one.row].carries(particle); });
+          if (!ownPassing || r2 == step.lookaheads.end()) {
+            noOwn += ownPassing ? 0U : 1U;
+            continue;
+          }
+          const bool r2Own = mTruth->rows[r2->row].carries(particle);
+          const bool chi2Own = mTruth->rows[chi2->row].carries(particle);
+          const Pair pair = r2Own ? (chi2Own ? kBoth : kCorrects) : (chi2Own ? kSpoils : kNeither);
+          ++byPassing[std::min<std::size_t>(step.lookaheads.size() - 2U, 2U)][pair];
+          ++byPt[ptBin][pair];
+          if (pair == kCorrects || pair == kSpoils) {
+            ++witnesses[pair == kCorrects ? 0U : 1U][witnessOf(*r2)][witnessOf(*chi2)];
+          }
+        }
+      };
+      walks(replay);
+      for (const auto& outward : replay.outward) {
+        walks(outward);
+      }
+    }
+    std::string text = std::format(
+      "  the lookahead against the smallest chi2 after iteration {} (nominal steps of agreeing walks, more than one row passing: {}, "
+      "{} without the particle's row among them):",
+      iteration.iteration, steps, noOwn);
+    const auto line = [&](const char* name, const std::array<std::size_t, kPairs>& counts) {
+      std::string one = std::format("\n    {}:", name);
+      for (std::size_t pair = 0; pair < kPairs; ++pair) {
+        one += std::format(" {} {};", kPairNames[pair], counts[pair]);
+      }
+      return one;
+    };
+    for (std::size_t k = 0; k < kPassing.size(); ++k) {
+      text += line(kPassing[k], byPassing[k]);
+    }
+    for (std::size_t k = 0; k < kPtNames.size(); ++k) {
+      text += line(std::format("pT {} GeV", kPtNames[k]).c_str(), byPt[k]);
+    }
+    for (std::size_t kind = 0; kind < 2U; ++kind) {
+      text += std::format("\n    where the lookahead {}, the lookahead's choice confirmed by / the smallest chi2's by:", kind == 0U ? "corrects" : "spoils");
+      for (std::size_t a = 0; a < 3U; ++a) {
+        for (std::size_t b = 0; b < 3U; ++b) {
+          if (witnesses[kind][a][b] != 0U) {
+            text += std::format(" {} / {} {};", kWitness[a], kWitness[b], witnesses[kind][a][b]);
+          }
+        }
+      }
+    }
+    mTransitionLines.push_back(text);
+  }
+
+  /// End rules replayed on the iteration's
+  /// own tracks, against what the iteration did (the unconfirmed drop included): (a) every
+  /// direction's last added row dropped; (b) the last added row dropped
+  /// where one row alone passed its step and the walk ended searching
+  /// (a hole crossed or nothing found), not at the layout's end. Only a
+  /// walk's last row, kept whole by the bid; agreeing walks. For each: the
+  /// rows dropped (the particle's or not), fakes made good, good tracks
+  /// losing a true row, tracks under the length cut (good, fake).
+  template <typename Observation>
+  void endPolicies(const Observation& iteration, const std::vector<Replay>& replayed, const IterationParameters<Det>& parameters)
+  {
+    const auto view = iteration.tracks->view();
+    enum Rule : std::uint8_t { kTrimLast,
+                               kLoneUnconfirmed,
+                               kRules };
+    constexpr std::array<const char*, kRules> kRuleNames{"(a) the last row dropped", "(b) a lone last row dropped where the walk ended searching"};
+    struct Counts {
+      std::size_t tracks = 0U, wrongDropped = 0U, ownDropped = 0U, fakeToGood = 0U, goodLosesRow = 0U, goodUnderCut = 0U, fakeUnderCut = 0U;
+    };
+    std::array<Counts, kRules> counts{};
+    std::array<std::array<std::size_t, 4>, 2> ends{}; // the walks' ends, [last row the particle's, not][FollowEnd]
+    for (std::uint32_t element = 0; element < replayed.size() && element < iteration.proposals.size(); ++element) {
+      const auto track = iteration.trackOffset + element;
+      const auto& proposal = iteration.proposals[element];
+      const auto& replay = replayed[element];
+      const std::span<const std::uint32_t> rows{view.clusters[track].index, view.count[track]};
+      const auto before = study::goodParticle(mTruth->rows, rows);
+      const auto roadParticle = replay.roadCount == 0U ? study::kNoTrackParticle : study::goodParticle(mTruth->rows, std::span<const std::uint32_t>{replay.road.index, replay.roadCount});
+      for (std::size_t rule = 0; rule < kRules; ++rule) {
+        std::vector<std::uint32_t> dropped;
+        const auto consider = [&](const Walk& walk, const std::uint32_t* kept, std::uint8_t keptCount) {
+          if (!walk.agrees || keptCount == 0U || keptCount != walk.raw.size()) {
+            return;
+          }
+          const auto last = kept[keptCount - 1U];
+          if (rule == 0U) {
+            ++ends[roadParticle != study::kNoTrackParticle && mTruth->rows[last].carries(roadParticle) ? 0U : 1U][static_cast<std::size_t>(walk.end)];
+          }
+          const auto step = std::ranges::find(walk.steps, last, &Step::choice);
+          std::size_t passed = 0U;
+          if (step != walk.steps.end()) {
+            for (const auto& candidate : step->candidates) {
+              passed += candidate.outcome == StepOutcome::kPasses ? 1U : 0U;
+            }
+          }
+          const bool lone = step != walk.steps.end() && !step->kink && passed == 1U;
+          const bool searching = walk.end == FollowEnd::kHoles || walk.end == FollowEnd::kNoRow;
+          if (rule == kTrimLast || (lone && searching)) {
+            dropped.push_back(last);
+          }
+        };
+        if (!replay.outward.empty()) {
+          consider(replay.outward.front(), proposal.outward, proposal.outwardCount);
+        }
+        consider(replay, proposal.inward, proposal.inwardCount);
+        if (dropped.empty()) {
+          continue;
+        }
+        auto& c = counts[rule];
+        ++c.tracks;
+        std::vector<std::uint32_t> after;
+        for (const auto row : rows) {
+          if (std::ranges::find(dropped, row) == dropped.end()) {
+            after.push_back(row);
+          }
+        }
+        const auto particle = before != study::kNoTrackParticle ? before : roadParticle;
+        for (const auto row : dropped) {
+          const bool own = particle != study::kNoTrackParticle && mTruth->rows[row].carries(particle);
+          c.ownDropped += own ? 1U : 0U;
+          c.wrongDropped += own ? 0U : 1U;
+        }
+        const bool under = parameters.minClustersAfterFollow != 0U && after.size() < parameters.minClustersAfterFollow;
+        const auto afterParticle = study::goodParticle(mTruth->rows, after);
+        if (before == study::kNoTrackParticle) {
+          c.fakeUnderCut += under ? 1U : 0U;
+          c.fakeToGood += !under && afterParticle != study::kNoTrackParticle ? 1U : 0U;
+        } else {
+          c.goodUnderCut += under ? 1U : 0U;
+          c.goodLosesRow += !under ? 1U : 0U;
+        }
+      }
+    }
+    std::string text = std::format("  end rules after iteration {} (against the iteration as it ran, the unconfirmed drop included):", iteration.iteration);
+    for (std::size_t own = 0; own < 2U; ++own) {
+      text += std::format("\n    walks whose kept last row is {}, by how they ended:", own == 0U ? "the road's particle's" : "another's");
+      for (std::size_t end = 0; end < kFollowEndNames.size(); ++end) {
+        text += std::format(" {} {};", kFollowEndNames[end], ends[own][end]);
+      }
+    }
+    for (std::size_t rule = 0; rule < kRules; ++rule) {
+      const auto& c = counts[rule];
+      text += std::format(
+        "\n    {}: {} tracks; rows dropped {} not the particle's, {} its own; fakes made good {}, fakes under the length cut {}; good "
+        "tracks losing a true row {}, good tracks under the length cut {}",
+        kRuleNames[rule], c.tracks, c.wrongDropped, c.ownDropped, c.fakeToGood, c.fakeUnderCut, c.goodLosesRow, c.goodUnderCut);
+    }
+    mTransitionLines.push_back(text);
+  }
+
+  /// Every walk of the iteration's own tracks at its end, one
+  /// CSV line each: the track, the direction, the road's particle (0: the
+  /// road is not one particle's) and its pT; how the walk ended
+  /// (`FollowEnd`), whether its last step called a sensor crossed (the
+  /// unconfirmed drop's condition) and how many links leave the layer it ended on that way
+  /// (none: the layout's end; else a `noTarget` is a failed prediction);
+  /// the unconfirmed drop's verdict -- the last row dropped, kept on evidence (the keep's chi2
+  /// or inward's near miss), kept unconfirmed (no sensor crossed), or no row
+  /// walked; the rows walked, kept by the bid, kept with the witnesses; the
+  /// last row walked (with whether a kink step took it) and the row the unconfirmed drop
+  /// dropped, each with its layer, chi2 and what it is to the road's particle: its
+  /// own, noise, past the end (no own row on that layer; then its own rows
+  /// further along its path in the walk's direction, by the distance from
+  /// its vertex as `attribute` measures it: free at the follow, all held,
+  /// none), or a swap (an own row there free at the follow, or held);
+  /// whether the last row is on the track the iteration left, the refit's
+  /// outcome, and whether the replay agrees with the iteration; then that
+  /// track: good or not, its rows, its layers and those of its rows carrying
+  /// the road's particle (hex) -- the track without its wrong rows; then the
+  /// track edited, on both its lines: (a) a fake whose
+  /// rows not carrying the road's particle are exactly the wrong last rows
+  /// its agreeing walks left on it, without them; (b) a good track with the
+  /// particle's own rows the unconfirmed drop removed from its agreeing walks put back where
+  /// they were dropped (after the outward end, before the inward one, when
+  /// that end is still the walk's last row or, the walk keeping none, the
+  /// road's); "-" for neither. The edit's rows, its refit as `follow::Refit`
+  /// makes it (`fitMeasurements`, the road's chi2 cut: ok, failedFit,
+  /// aboveChi2), whether it then stays (`keptAfterFollow`: the length after
+  /// the follow and the pT floor for its count; -1 without a refit) and its
+  /// layers (hex). Between them: what the ending step saw --
+  /// windows opened, rows in them, rows the gate refused -- and the evidence
+  /// for the last row (when it ends the track that way) and the unconfirmed
+  /// drop's row, truth-free, from the state before the row: the nominal chi2 and
+  /// sqrt|V| (`oneStep`; a kink step's own chi2 is the scaled one), the
+  /// density of the window's other rows beyond the gate and the layer's, the
+  /// reach of its layer (`reachChance`), its time box's overlap with the
+  /// walk's box before it, both widths [ps]; the chi2 predicted for it from the
+  /// rest of the track (a fit without it; the dropped row: the track's fit)
+  /// and, inward, the beam line's chi2 at the inner state with and without
+  /// it; -1 where missing. Parallel over the tracks, written in their order.
+  template <typename Observation, typename Material>
+  void endDecisions(const Observation& iteration, const std::vector<Replay>& replayed, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    const auto view = iteration.tracks->view();
+    const auto gate = static_cast<double>(parameters.clusterChi2Max);
+    constexpr std::array<const char*, 4> kEnds{"noTarget", "holes", "noRow", "capacity"};
+    constexpr std::array<const char*, 3> kRefits{"kept", "failedFit", "aboveChi2"};
+    layerOccupancy(frame, geometry);
+    std::vector<std::string> text(replayed.size());
+    std::vector<std::string> edits(mEditCsv ? replayed.size() : 0U);
+    o2::gtrk::detail::parallelFor(*mArena, 0U, replayed.size(), 256, [&](std::size_t a, std::size_t b) {
+      for (auto element = static_cast<std::uint32_t>(a); element < b; ++element) {
+        const auto track = iteration.trackOffset + element;
+        const auto& replay = replayed[element];
+        const std::span<const std::uint32_t> rows{view.clusters[track].index, view.count[track]};
+        const auto particle = replay.roadCount == 0U ? study::kNoTrackParticle : study::goodParticle(mTruth->rows, std::span<const std::uint32_t>{replay.road.index, replay.roadCount});
+        const auto found = particle == study::kNoTrackParticle ? mTruth->particles.end() : mTruth->particles.find(particle);
+        const double pt = truePt(found);
+        const bool trackGood = study::goodParticle(mTruth->rows, rows) != study::kNoTrackParticle;
+        std::uint64_t trackLayers = 0U;
+        std::uint64_t ownLayers = 0U;
+        for (const auto row : rows) {
+          trackLayers |= std::uint64_t{1} << mTruth->rows[row].layer;
+          ownLayers |= particle != study::kNoTrackParticle && mTruth->rows[row].carries(particle) ? std::uint64_t{1} << mTruth->rows[row].layer : 0U;
+        }
+        const auto vertex = vertexRZ(found);
+        const auto distance = [&](std::uint32_t one) { return pathDistance(one, vertex); };
+        // What \a row is to the road's particle, and for a row past its end
+        // its own rows beyond.
+        const auto kindOf = [&](std::uint32_t row, bool outward) -> std::pair<const char*, const char*> {
+          if (particle == study::kNoTrackParticle) {
+            return {"-", "-"};
+          }
+          const auto& at = mTruth->rows[row];
+          if (at.carries(particle)) {
+            return {"own", "-"};
+          }
+          if (at.count == 0U) {
+            return {"noise", "-"};
+          }
+          const auto& ownRows = mRowsOf.at(particle);
+          bool onLayer = false;
+          bool freeOnLayer = false;
+          for (const auto own : ownRows) {
+            if (mTruth->rows[own].layer == at.layer) {
+              onLayer = true;
+              freeOnLayer = freeOnLayer || (own < mFollowUsedNow.size() && mFollowUsedNow[own] == kFree);
+            }
+          }
+          if (onLayer) {
+            return {freeOnLayer ? "swapFree" : "swapHeld", "-"};
+          }
+          const double here = distance(row);
+          bool beyond = false;
+          bool free = false;
+          for (const auto own : ownRows) {
+            if (outward ? distance(own) > here : distance(own) < here) {
+              beyond = true;
+              free = free || (own < mFollowUsedNow.size() && mFollowUsedNow[own] == kFree);
+            }
+          }
+          return {"past", !beyond ? "none" : (free ? "free" : "held")};
+        };
+        // The chi2 of \a row at the step that took it, and whether a kink step did.
+        const auto chi2Of = [](const Walk& walk, std::uint32_t row) -> std::pair<double, int> {
+          const auto step = std::ranges::find(walk.steps, row, &Step::choice);
+          if (step == walk.steps.end()) {
+            return {-1., -1};
+          }
+          const auto& seen = step->kink ? step->scaled : step->candidates;
+          const auto at = std::ranges::find(seen, row, &Candidate::row);
+          return {at == seen.end() ? -1. : static_cast<double>(at->chi2), step->kink ? 1 : 0};
+        };
+        // The fits of the track's rows: all of them, without the
+        // outermost, without the innermost, with a row before the innermost.
+        const auto fitOf = [&](std::vector<std::uint32_t> list) {
+          if (list.empty()) {
+            throw std::logic_error("CompleteAnatomy: a fit of no rows");
+          }
+          return fitMeasurements(propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = list.data()}, static_cast<int>(list.size()), kinkBudget(parameters));
+        };
+        // The beam line's chi2 at the inner state of \a fit, whose innermost row is \a innermost; -1 without.
+        const auto beamOf = [&](const auto& fit, std::uint32_t innermost) {
+          if (fit.status != PropagationStatus::kOk) {
+            return -1.;
+          }
+          BoundTrackState state = fit.state;
+          const auto& plane = geometry.planeOf(state);
+          const LayerID layer = geometry.surface(state.surface).layer;
+          const auto update = updateWithBeamLine(propagator, parameters, plane, layer, pairPointAt(frame.measurements(), innermost), state);
+          return update.ok ? static_cast<double>(update.chi2) : -1.;
+        };
+        std::optional<decltype(fitOf({}))> fitAll;
+        const auto all = [&]() -> const auto& {
+          if (!fitAll) {
+            fitAll = fitOf(std::vector<std::uint32_t>(rows.begin(), rows.end()));
+          }
+          return *fitAll;
+        };
+        const auto& proposal = iteration.proposals[element];
+        // The evidence for \a row (the walk's last, or the unconfirmed drop's), from
+        // the state before it: the step that took it, its window's density
+        // of other rows beyond the gate and the layer's, the reach of its
+        // layer, its time box against the walk's before it; then the chi2
+        // predicted from the rest of the track (\a rest: a fit without it;
+        // \a restState its end state toward the row) and inward the beam
+        // line's chi2 with and without it.
+        struct Evidence {
+          double chi2 = -1., sqrtDet = -1., rhoWindow = -1., rhoLayer = -1., reach = -1., overlapPS = -1., boxPS = -1., rowPS = -1., rest = -1., beamWith = -1., beamWithout = -1., floatDet = -1., factorDet = -1.;
+        };
+        const auto evidenceOf = [&](const Walk& walk, std::uint32_t row, bool outward) {
+          Evidence out;
+          const auto direction = outward ? PropagationDirection::kForward : PropagationDirection::kBackward;
+          const auto step = std::ranges::find(walk.steps, row, &Step::choice);
+          if (step == walk.steps.end()) {
+            return out;
+          }
+          const LayerID layer = mTruth->rows[row].layer;
+          const auto taken = oneStep(row, step->state, step->factors, direction, frame, geometry, material, propagator);
+          out.chi2 = taken.valid ? taken.chi2 : -1.;
+          out.sqrtDet = taken.valid ? taken.sqrtDet : -1.;
+          out.floatDet = taken.valid ? taken.floatDet : -1.;
+          out.factorDet = taken.valid ? taken.factorDet : -1.;
+          const auto target = std::ranges::find(step->targets, layer, &TargetSeen::layer);
+          if (target != step->targets.end()) {
+            const auto& window = target->window;
+            out.rhoWindow = windowRho(parameters, *step, layer, window, gate, taken.valid ? taken.sqrtDet : 0., direction, frame, geometry, material, propagator, [row](std::uint32_t candidate) { return candidate == row; }, -1.);
+            out.rhoLayer = layerDensity(layer, window);
+            out.reach = reachChance(parameters, step->state, step->factors, layer, window, direction, geometry, propagator, row);
+          }
+          // The time box before the row: the road's, the outward rows kept
+          // (inward), the walk's rows before it.
+          auto box = trackTimeBox(frame.measurements(), replay.road, replay.roadCount);
+          if (!outward) {
+            for (std::uint8_t i = 0; i < proposal.outwardCount; ++i) {
+              box += timeBoxAt(frame.measurements(), proposal.outward[i]);
+            }
+          }
+          for (const auto before : walk.raw) {
+            if (before == row) {
+              break;
+            }
+            box += timeBoxAt(frame.measurements(), before);
+          }
+          const auto mine = timeBoxAt(frame.measurements(), row);
+          out.boxPS = static_cast<double>(box.width);
+          out.rowPS = static_cast<double>(mine.width);
+          out.overlapPS = static_cast<double>(std::min(box.upper(), mine.upper())) - static_cast<double>(std::max(box.lower(), mine.lower()));
+          return out;
+        };
+        std::vector<std::string> lines;
+        std::uint32_t wrongLast = 0U;
+        std::uint32_t appendOut = kNoRow;
+        std::uint32_t prependIn = kNoRow;
+        bool allAgree = true;
+        // The truth-free edits each walk allows: its last row refused
+        // where it ends the track, the unconfirmed drop's row put back where it attaches.
+        std::array<bool, 2> refuse{}; // inward, outward
+        std::array<std::uint32_t, 2> restore{kNoRow, kNoRow};
+        const auto one = [&](const Walk& walk, bool outward) {
+          bool crossed = false;
+          std::uint32_t links = 0U;
+          std::size_t windows = 0U;
+          std::size_t seen = 0U;
+          std::size_t refused = 0U;
+          if (!walk.steps.empty()) {
+            const auto& ending = walk.steps.back();
+            for (const auto& [layer, called] : ending.holes) {
+              crossed = crossed || called;
+            }
+            const auto current = ending.layer;
+            const auto* offsets = outward ? parameters.allOutLinkOffsets : parameters.allInLinkOffsets;
+            links = offsets[current + 1U] - offsets[current];
+            windows = ending.targets.size();
+            seen = ending.candidates.size();
+            for (const auto& candidate : ending.candidates) {
+              refused += candidate.outcome == StepOutcome::kChi2 ? 1U : 0U;
+            }
+          }
+          const bool dropped = walk.dropped != kNoRow;
+          const char* verdict = dropped ? "dropped" : (walk.raw.empty() ? "none" : (crossed ? "evidence" : "unconfirmed"));
+          const std::uint32_t last = walk.raw.empty() ? kNoRow : walk.raw.back();
+          const auto [lastChi2, lastKink] = last == kNoRow ? std::pair{-1., -1} : chi2Of(walk, last);
+          const auto [lastKind, lastBeyond] = last == kNoRow ? std::pair{"-", "-"} : kindOf(last, outward);
+          const double droppedChi2 = dropped ? chi2Of(walk, walk.dropped).first : -1.;
+          const auto [droppedKind, droppedBeyond] = dropped ? kindOf(walk.dropped, outward) : std::pair{"-", "-"};
+          const bool survives = last != kNoRow && std::ranges::find(rows, last) != rows.end();
+          wrongLast += survives && particle != study::kNoTrackParticle && !mTruth->rows[last].carries(particle) ? 1U : 0U;
+          // Where a dropped row would go: past the walk's last row, or the road's end where the walk kept none.
+          bool attachable = false;
+          if (dropped && !rows.empty() && replay.roadCount != 0U) {
+            const std::uint32_t end = last != kNoRow ? last : (outward ? replay.road.index[replay.roadCount - 1U] : replay.road.index[0]);
+            attachable = (outward ? rows.back() : rows.front()) == end;
+          }
+          if (attachable && walk.agrees && particle != study::kNoTrackParticle && mTruth->rows[walk.dropped].carries(particle)) {
+            (outward ? appendOut : prependIn) = walk.dropped;
+          }
+          refuse[outward ? 1 : 0] = walk.agrees && survives && rows.size() >= 4U && (outward ? rows.back() : rows.front()) == last;
+          restore[outward ? 1 : 0] = walk.agrees && attachable && rows.size() < kMaxClusters ? walk.dropped : kNoRow;
+          // The evidence, for every agreeing walk; the rules apply to all tracks.
+          Evidence lastEvidence;
+          Evidence droppedEvidence;
+          if (walk.agrees) {
+            const auto direction = outward ? PropagationDirection::kForward : PropagationDirection::kBackward;
+            if (survives && rows.size() >= 4U && (outward ? rows.back() : rows.front()) == last) {
+              lastEvidence = evidenceOf(walk, last, outward);
+              std::vector<std::uint32_t> rest(rows.begin(), rows.end());
+              outward ? rest.pop_back() : static_cast<void>(rest.erase(rest.begin()));
+              const auto fit = fitOf(rest);
+              if (fit.status == PropagationStatus::kOk) {
+                const auto& state = outward ? fit.outwardState : fit.state;
+                const auto at = oneStep(last, state, factorCovariance(state.cov), direction, frame, geometry, material, propagator);
+                lastEvidence.rest = at.valid ? at.chi2 : -1.;
+                if (!outward) {
+                  lastEvidence.beamWithout = beamOf(fit, rest.front());
+                  lastEvidence.beamWith = beamOf(all(), rows.front());
+                }
+              }
+            }
+            if (dropped) {
+              droppedEvidence = evidenceOf(walk, walk.dropped, outward);
+              if (attachable) {
+                const auto& fit = all();
+                if (fit.status == PropagationStatus::kOk) {
+                  const auto& state = outward ? fit.outwardState : fit.state;
+                  const auto at = oneStep(walk.dropped, state, factorCovariance(state.cov), direction, frame, geometry, material, propagator);
+                  droppedEvidence.rest = at.valid ? at.chi2 : -1.;
+                  if (!outward) {
+                    std::vector<std::uint32_t> with{walk.dropped};
+                    with.insert(with.end(), rows.begin(), rows.end());
+                    droppedEvidence.beamWithout = beamOf(fit, rows.front());
+                    droppedEvidence.beamWith = beamOf(fitOf(with), walk.dropped);
+                  }
+                }
+              }
+            }
+          }
+          const auto evidence = [](const Evidence& e) { return std::format("{:.5g},{:.5g},{:.5g},{:.5g},{:.4g},{:.0f},{:.0f},{:.0f},{:.5g},{:.5g},{:.5g},{:.9g},{:.9g}", e.chi2, e.sqrtDet, e.rhoWindow, e.rhoLayer, e.reach, e.overlapPS, e.boxPS, e.rowPS, e.rest, e.beamWith, e.beamWithout, e.floatDet, e.factorDet); };
+          // The beam line inward: its update's chi2 at the state after
+          // the last row walked, as `confirmation` makes it for a kink row at
+          // the innermost layer, and whether it passes beamChi2Max; and the
+          // beam line as the reference of each nominal step (`oneStep` with
+          // it): the rows the walk took that the reference's prediction puts
+          // above the gate, the first of them -- its position among the rows
+          // taken, whether it is the walk's last kept row (1) or the unconfirmed
+          // drop's (2), the step's best other free row the reference passes (the
+          // first target with one, the smallest chi2) -- and, where it refuses
+          // none, a row of the ending step the nominal gate refused that the
+          // reference passes; the reference's chi2 of the walk's last kept row
+          // on its own, whatever came before (-1: a kink step's, -2: the
+          // transport or the beam update failed); the rows taken it could not
+          // judge so. Kink steps are not judged; a row it cannot judge is not
+          // refused.
+          double endBeam = -1.;
+          int endBeamPasses = -1;
+          int refRefused = -1;
+          int refInvalid = -1;
+          double lastRef = -1.;
+          int refStep = -1;
+          int refLast = -1;
+          std::uint32_t refRow = kNoRow;
+          std::uint32_t refAlt = kNoRow;
+          std::uint32_t refNew = kNoRow;
+          if (!outward && walk.agrees) {
+            const auto at = last == kNoRow ? walk.steps.end() : std::ranges::find(walk.steps, last, &Step::choice);
+            if (at != walk.steps.end() && std::next(at) != walk.steps.end()) {
+              BoundTrackState after = std::next(at)->state;
+              covarianceFromFactors(std::next(at)->factors, after.cov);
+              const auto update = updateWithBeamLine(propagator, parameters, geometry.planeOf(after), geometry.surface(after.surface).layer, pairPointAt(frame.measurements(), last), after);
+              if (update.ok) {
+                endBeam = static_cast<double>(update.chi2);
+                endBeamPasses = update.chi2 <= parameters.beamChi2Max ? 1 : 0;
+              }
+            }
+            refRefused = 0;
+            refInvalid = 0;
+            int position = 0;
+            for (std::size_t s = 0; s < walk.steps.size(); ++s) {
+              const auto& step = walk.steps[s];
+              const auto referenced = [&](std::uint32_t row) {
+                const auto update = oneStep(row, step.state, step.factors, PropagationDirection::kBackward, frame, geometry, material, propagator, &parameters);
+                return update.valid ? update.chi2 : -2.;
+              };
+              const auto bestOther = [&](std::uint32_t besides) {
+                for (const auto& target : step.targets) {
+                  std::uint32_t best = kNoRow;
+                  double smallest = gate;
+                  for (const auto& candidate : step.candidates) {
+                    if (candidate.layer != target.layer || candidate.row == besides || (candidate.outcome != StepOutcome::kPasses && candidate.outcome != StepOutcome::kChi2)) {
+                      continue;
+                    }
+                    const double chi2 = referenced(candidate.row);
+                    if (chi2 >= 0. && chi2 <= smallest) {
+                      best = candidate.row;
+                      smallest = chi2;
+                    }
+                  }
+                  if (best != kNoRow) {
+                    return best;
+                  }
+                }
+                return kNoRow;
+              };
+              if (step.choice == kNoRow) {
+                if (s + 1U == walk.steps.size() && refStep < 0) {
+                  refNew = bestOther(kNoRow);
+                }
+                continue;
+              }
+              const double chi2 = step.kink ? -1. : referenced(step.choice);
+              lastRef = step.choice == last ? chi2 : lastRef;
+              refInvalid += chi2 < -1.5 ? 1 : 0;
+              if (chi2 > gate) {
+                ++refRefused;
+                if (refStep < 0) {
+                  refStep = position;
+                  refRow = step.choice;
+                  refLast = step.choice == last ? 1 : (step.choice == walk.dropped ? 2 : 0);
+                  refAlt = bestOther(step.choice);
+                }
+              }
+              ++position;
+            }
+          }
+          const auto rowOf = [](std::uint32_t row) { return row == kNoRow ? std::int64_t{-1} : static_cast<std::int64_t>(row); };
+          const auto kindName = [&](std::uint32_t row) { return row == kNoRow ? "-" : kindOf(row, outward).first; };
+          // The step that took the last row: each
+          // layer it searched, in its order, with what it found -- r the
+          // row, h a hole (a sensor crossed without a row), m a miss (no
+          // sensor crossed: no hole) -- "/"-separated; "-" without one.
+          std::string search = "-";
+          if (walk.agrees && last != kNoRow) {
+            const auto at = std::ranges::find(walk.steps, last, &Step::choice);
+            if (at != walk.steps.end()) {
+              search.clear();
+              for (const auto& target : at->targets) {
+                const auto hole = std::ranges::find(at->holes, target.layer, &std::pair<LayerID, bool>::first);
+                const char code = target.layer == mTruth->rows[last].layer ? 'r' : (hole == at->holes.end() ? '?' : (hole->second ? 'h' : 'm'));
+                search += std::format("{}{}{}", search.empty() ? "" : "/", static_cast<int>(target.layer), code);
+              }
+            }
+          }
+          const auto beam = std::format("{:.5g},{},{},{},{},{},{},{},{},{},{},{:.5g},{},{},{}", endBeam, endBeamPasses, refRefused, refStep, rowOf(refRow), kindName(refRow), refLast, rowOf(refAlt), kindName(refAlt), rowOf(refNew), kindName(refNew), lastRef, lastRef >= 0. ? (lastRef <= gate ? 1 : 0) : -1, refInvalid, search);
+          lines.push_back(std::format("{},{},{},{},{:.6g},{},{},{},{},{},{},{},{},{},{:.5g},{},{},{},{},{},{:.5g},{},{},{},{},{},{},{},{:x},{:x},{},{},{},{},{}", track, iteration.iteration, outward ? "out" : "in", particle == study::kNoTrackParticle ? 0U : particle, pt, kEnds[static_cast<std::size_t>(walk.end)], crossed ? 1 : 0, links, verdict, walk.raw.size(), walk.bidKept, walk.kept, last == kNoRow ? -1 : static_cast<std::int64_t>(last), last == kNoRow ? -1 : static_cast<int>(mTruth->rows[last].layer), lastChi2, lastKink, lastKind, lastBeyond, dropped ? static_cast<std::int64_t>(walk.dropped) : -1, dropped ? static_cast<int>(mTruth->rows[walk.dropped].layer) : -1, droppedChi2, droppedKind, droppedBeyond, survives ? 1 : 0, kRefits[replay.refit], walk.agrees ? 1 : 0, trackGood ? 1 : 0, rows.size(), trackLayers, ownLayers, windows, seen, refused, evidence(lastEvidence), evidence(droppedEvidence)) + "," + beam);
+          allAgree = allAgree && walk.agrees;
+        };
+        if (!replay.outward.empty()) {
+          one(replay.outward.front(), true);
+        }
+        one(replay, false);
+        // The edit: (a) the fake without its wrong last rows, (b) the good track with its own dropped rows back.
+        std::uint32_t wrongRows = 0U;
+        for (const auto row : rows) {
+          wrongRows += particle != study::kNoTrackParticle && !mTruth->rows[row].carries(particle) ? 1U : 0U;
+        }
+        std::vector<std::uint32_t> edited;
+        const char* edit = "-";
+        if (particle != study::kNoTrackParticle && allAgree && !trackGood && wrongRows != 0U && wrongRows == wrongLast && study::majorityParticle(mTruth->rows, rows).particle == particle) {
+          edit = "a";
+          for (const auto row : rows) {
+            if (mTruth->rows[row].carries(particle)) {
+              edited.push_back(row);
+            }
+          }
+        } else if (trackGood && (appendOut != kNoRow || prependIn != kNoRow) && rows.size() + 2U <= kMaxClusters) {
+          edit = "b";
+          if (prependIn != kNoRow) {
+            edited.push_back(prependIn);
+          }
+          edited.insert(edited.end(), rows.begin(), rows.end());
+          if (appendOut != kNoRow) {
+            edited.push_back(appendOut);
+          }
+        }
+        std::string tail = ",-,-1,-,-1,0";
+        if (*edit != '-') {
+          const auto fit = fitOf(edited);
+          const bool ok = fit.status == PropagationStatus::kOk;
+          const bool under = follow::passesRoadChi2(parameters, fit);
+          std::uint64_t layers = 0U;
+          for (const auto row : edited) {
+            layers |= std::uint64_t{1} << mTruth->rows[row].layer;
+          }
+          tail = std::format(",{},{},{},{},{:x}", edit, edited.size(), !ok ? "failedFit" : (under ? "ok" : "aboveChi2"), under ? (keptAfterFollow(parameters, static_cast<std::uint32_t>(edited.size()), fit.state) ? 1 : 0) : -1, layers);
+        }
+        for (const auto& line : lines) {
+          text[element] += line;
+          text[element] += tail;
+          text[element] += '\n';
+        }
+        // The truth-free end edits: the track as it is, then every
+        // combination of the edits its walks allow -- inward and outward
+        // each none (0), the last row refused (R), the unconfirmed drop's row back (K)
+        // -- refitted and floored as (a) and (b): the rows, the refit, kept
+        // after the floors, the good particle (0: a fake), the majority's.
+        if (mEditCsv) {
+          const auto idOf = [](std::uint64_t id) { return id == study::kNoTrackParticle ? std::uint64_t{0} : id; };
+          auto& out = edits[element];
+          out += std::format("{},{},0,0,{},ok,1,{},{},{:x},", track, iteration.iteration, rows.size(), idOf(study::goodParticle(mTruth->rows, rows)), idOf(study::majorityParticle(mTruth->rows, rows).particle), trackLayers);
+          for (std::size_t i = 0; i < rows.size(); ++i) {
+            out += std::format("{}{}", i == 0U ? "" : ";", rows[i]);
+          }
+          out += '\n';
+          for (const char in : {'0', 'R', 'K'}) {
+            for (const char outer : {'0', 'R', 'K'}) {
+              const auto allowed = [&](char change, std::size_t side) { return change == '0' || (change == 'R' ? refuse[side] : restore[side] != kNoRow); };
+              if ((in == '0' && outer == '0') || !allowed(in, 0U) || !allowed(outer, 1U) || (in == 'K' && outer == 'K' && rows.size() + 2U > kMaxClusters)) {
+                continue;
+              }
+              std::vector<std::uint32_t> list(rows.begin(), rows.end());
+              if (outer == 'R') {
+                list.pop_back();
+              } else if (outer == 'K') {
+                list.push_back(restore[1]);
+              }
+              if (in == 'R') {
+                list.erase(list.begin());
+              } else if (in == 'K') {
+                list.insert(list.begin(), restore[0]);
+              }
+              const auto fit = fitOf(list);
+              const bool ok = fit.status == PropagationStatus::kOk;
+              const bool under = follow::passesRoadChi2(parameters, fit);
+              std::uint64_t layers = 0U;
+              for (const auto row : list) {
+                layers |= std::uint64_t{1} << mTruth->rows[row].layer;
+              }
+              out += std::format("{},{},{},{},{},{},{},{},{},{:x},\n", track, iteration.iteration, in, outer, list.size(), !ok ? "failedFit" : (under ? "ok" : "aboveChi2"), under && keptAfterFollow(parameters, static_cast<std::uint32_t>(list.size()), fit.state) ? 1 : 0, idOf(study::goodParticle(mTruth->rows, list)), idOf(study::majorityParticle(mTruth->rows, list).particle), layers);
+            }
+          }
+        }
+      }
+    });
+    for (const auto& one : text) {
+      *mEndCsv << one;
+    }
+    for (const auto& one : edits) {
+      *mEditCsv << one;
+    }
+  }
+
+  /// The particle's own row at every step of the follow: on the agreeing walks of the correct roads of the class's
+  /// particles, each step's target layers the particle has a row on, the
+  /// best outcome of its rows there -- passing (taken or not) or refused by
+  /// the chi2 gate, with the chi2; outside the window; held; no update; not
+  /// visited -- by direction, link, pT range and the particle's true kink
+  /// over the step (the crossing pair from the inner layer to the outer,
+  /// over theta0). Without a kink (<= 3 theta0) the update's chi2 is a
+  /// chi-square of two degrees of freedom where the error model holds: the
+  /// gate's tail is exp(-gate / 2), 0.27 % at 11.83. Also the outward unconfirmed drops
+  /// on every agreeing walk: whether the dropped row is the road particle's,
+  /// and whether the last step saw a row near (a row in its window the gate
+  /// refused, inward's evidence) and whose -- the gain and the cost of
+  /// inward's evidence rule outward.
+  template <typename Observation>
+  void ownSteps(const Observation& iteration, const std::vector<Replay>& replayed, const IterationParameters<Det>& parameters)
+  {
+    enum Outcome : std::uint8_t { kPass,
+                                  kRefused,
+                                  kOutside,
+                                  kHeld,
+                                  kNoUpdateOwn,
+                                  kUnvisited,
+                                  kOutcomes };
+    constexpr std::array<double, 10> kChi2Edges{2., 4., 6., 9.21, 0., 15., 25., 50., 100., std::numeric_limits<double>::infinity()};
+    struct Cell {
+      std::array<std::size_t, kOutcomes> outcome{};
+      std::array<std::size_t, kChi2Edges.size()> chi2{};
+    };
+    // [direction][link from][link to][pT range][kink bin]
+    std::map<std::tuple<std::size_t, int, int, std::size_t, std::size_t>, Cell> cells;
+    const auto gate = static_cast<double>(parameters.clusterChi2Max);
+    auto edges = kChi2Edges;
+    edges[4] = gate;
+    std::ranges::sort(edges);
+    // Unconfirmed drops outward: [dropped row the particle's][near row: none, the particle's, another's]
+    std::array<std::array<std::size_t, 3>, 2> unconfirmedDrops{};
+    // and by the dropped row's chi2 at the step that took it: [own][near][bin] (< 1 / 1-2 / 2-4 / 4-6 / 6-9.21 / >= 9.21)
+    constexpr std::array<double, 6> kDropEdges{1., 2., 4., 6., 9.21, std::numeric_limits<double>::infinity()};
+    std::array<std::array<std::array<std::size_t, kDropEdges.size()>, 3>, 2> r1Chi2{};
+    for (std::uint32_t element = 0; element < replayed.size(); ++element) {
+      const auto& replay = replayed[element];
+      if (replay.roadCount == 0U) {
+        continue;
+      }
+      const auto particle = study::goodParticle(mTruth->rows, std::span<const std::uint32_t>{replay.road.index, replay.roadCount});
+      if (!replay.outward.empty() && replay.outward.front().agrees && replay.outward.front().dropped != kNoRow && particle != study::kNoTrackParticle) {
+        const auto& walk = replay.outward.front();
+        const bool ownDropped = mTruth->rows[walk.dropped].carries(particle);
+        std::size_t near = 0U;
+        if (!walk.steps.empty()) {
+          for (const auto& candidate : walk.steps.back().candidates) {
+            if (candidate.outcome == StepOutcome::kChi2) {
+              near = std::max<std::size_t>(near, mTruth->rows[candidate.row].carries(particle) ? 1U : 2U);
+            }
+          }
+        }
+        // the particle's near row wins over another's
+        if (near == 2U) {
+          for (const auto& candidate : walk.steps.back().candidates) {
+            near = candidate.outcome == StepOutcome::kChi2 && mTruth->rows[candidate.row].carries(particle) ? 1U : near;
+          }
+        }
+        ++unconfirmedDrops[ownDropped ? 0U : 1U][near];
+        for (const auto& step : walk.steps) {
+          if (step.choice != walk.dropped) {
+            continue;
+          }
+          const auto taken = std::ranges::find(step.candidates, walk.dropped, &Candidate::row);
+          if (taken != step.candidates.end()) {
+            const auto bin = static_cast<std::size_t>(std::ranges::upper_bound(kDropEdges, static_cast<double>(taken->chi2)) - kDropEdges.begin());
+            ++r1Chi2[ownDropped ? 0U : 1U][near][std::min(bin, kDropEdges.size() - 1U)];
+          }
+        }
+      }
+      if (particle == study::kNoTrackParticle || !mIndex.contains(particle)) {
+        continue;
+      }
+      const auto truth = mTruth->particles.find(particle);
+      const double pt = truePt(truth);
+      const std::size_t ptRange = pt < 0.6 ? 0U : (pt < 1. ? 1U : 2U);
+      const auto tally = [&](const Walk& walk, std::size_t direction) {
+        if (!walk.agrees) {
+          return;
+        }
+        for (const auto& step : walk.steps) {
+          for (const auto& target : step.targets) {
+            const auto layer = target.layer;
+            if (ownRowOn(particle, layer) == kNoTrack) {
+              continue;
+            }
+            Outcome best = kUnvisited;
+            double chi2 = std::numeric_limits<double>::infinity();
+            for (const auto& candidate : step.candidates) {
+              if (candidate.layer != layer || !mTruth->rows[candidate.row].carries(particle)) {
+                continue;
+              }
+              const auto kind = candidate.outcome == StepOutcome::kPasses ? kPass : candidate.outcome == StepOutcome::kChi2          ? kRefused
+                                                                                  : candidate.outcome == StepOutcome::kOutsideWindow ? kOutside
+                                                                                  : candidate.outcome == StepOutcome::kUsed          ? kHeld
+                                                                                                                                     : kNoUpdateOwn;
+              if (kind < best || (kind == best && static_cast<double>(candidate.chi2) < chi2)) {
+                best = kind;
+                chi2 = kind <= kRefused ? static_cast<double>(candidate.chi2) : chi2;
+              }
+            }
+            const auto outer = direction == 0U ? layer : step.layer;
+            const auto bin = kinkBin(kinkAt(particle, outer, true));
+            auto& cell = cells[{direction, static_cast<int>(step.layer), static_cast<int>(layer), ptRange, bin}];
+            ++cell.outcome[best];
+            if (best <= kRefused) {
+              const auto at = static_cast<std::size_t>(std::ranges::upper_bound(edges, chi2) - edges.begin());
+              ++cell.chi2[std::min(at, edges.size() - 1U)];
+            }
+          }
+        }
+      };
+      if (!replay.outward.empty()) {
+        tally(replay.outward.front(), 0U);
+      }
+      tally(replay, 1U);
+    }
+    // The chi2 bins' labels from the sorted edges, the gate's by name: where
+    // it falls among the fixed edges is printed, not assumed.
+    const auto edgeName = [&](double edge) { return edge == gate ? std::string{"gate"} : std::format("{}", edge); };
+    std::string bins = "<" + edgeName(edges[0]);
+    for (std::size_t k = 1; k < edges.size(); ++k) {
+      bins += std::isinf(edges[k]) ? "/>" + edgeName(edges[k - 1]) : "/" + edgeName(edges[k - 1]) + "-" + edgeName(edges[k]);
+    }
+    std::string text = std::format("  own steps after iteration {} (gate {:.2f}): direction link pT kink: pass/refused/outside/held/noupdate/unvisited | chi2 {}", iteration.iteration, gate, bins);
+    for (const auto& [key, cell] : cells) {
+      const auto& [direction, from, to, ptRange, bin] = key;
+      text += std::format("\n    O {} {}-{} {} {}: {}/{}/{}/{}/{}/{} |", direction, from, to, ptRange, bin, cell.outcome[0], cell.outcome[1], cell.outcome[2], cell.outcome[3], cell.outcome[4], cell.outcome[5]);
+      for (const auto n : cell.chi2) {
+        text += std::format(" {}", n);
+      }
+    }
+    text += std::format("\n    outward unconfirmed drops (dropped row the particle's / another's; near row none / the particle's / another's): {}/{}/{} {}/{}/{}", unconfirmedDrops[0][0], unconfirmedDrops[0][1], unconfirmedDrops[0][2], unconfirmedDrops[1][0], unconfirmedDrops[1][1], unconfirmedDrops[1][2]);
+    for (std::size_t own = 0; own < 2U; ++own) {
+      for (std::size_t near = 0; near < 3U; ++near) {
+        const auto& c = r1Chi2[own][near];
+        text += std::format("\n    outward unconfirmed drops by the dropped row's chi2 (<1/1-2/2-4/4-6/6-9.21/>=9.21), dropped {} near {}: {}/{}/{}/{}/{}/{}", own == 0U ? "own" : "wrong", near == 0U ? "none" : (near == 1U ? "own" : "other"), c[0], c[1], c[2], c[3], c[4], c[5]);
+      }
+    }
+    mTransitionLines.push_back(text);
+  }
+
+  /// \a particle's MC hit segments (`--hits`: the signal source's only);
+  /// none (nullptr) for another source or a particle without hits.
+  [[nodiscard]] const std::vector<const study::HitSegment*>* segmentsOf(std::uint64_t particle) const
+  {
+    const auto label = workflow::labelOfParticle(particle);
+    if (label.getSourceID() != 0) {
+      return nullptr;
+    }
+    const auto found = mSegmentsOf.find(segmentKey(label.getEventID(), label.getTrackID()));
+    return found != mSegmentsOf.end() ? &found->second : nullptr;
+  }
+
+  /// The follow's hole calls against the MC hits: on
+  /// the agreeing walks of the iteration's correct roads (every road row the
+  /// road's particle's), each nominal target without a row, by direction and
+  /// layer: whether `crossesSensor` called it crossed, whether the particle
+  /// has an MC hit on that layer, and whether it has a row there. Crossed
+  /// without a hit is a gap called a crossing; a hit and no row the
+  /// detector's own miss; a row the particle's row refused. Also the calls
+  /// that ended a walk (its end `holes`, the last step's last call), with
+  /// whether the particle has a row further along than the walk's last --
+  /// by the distance from its production vertex, outward farther, inward
+  /// nearer: what the end loses.
+  template <typename Observation>
+  void holeCalls(const Observation& iteration, const std::vector<Replay>& replayed, const IterationParameters<Det>& parameters, const TrackingGeometry<Det>& geometry, const Propagator& propagator)
+  {
+    // The crossed ending calls' `reachChance` (the step's state drawn from
+    // its covariance, as crossesSensor carried): [direction][hit][further][bin]
+    constexpr std::array<double, 5> kChanceEdges{0.1, 0.5, 0.9, 0.99, 2.};
+    std::array<std::array<std::array<std::array<std::size_t, kChanceEdges.size()>, 2>, 2>, 2> chances{};
+    // [direction][ended the walk][layer][crossed][hit][row]
+    using Cube = std::array<std::array<std::array<std::size_t, 2>, 2>, 2>;
+    std::array<std::array<std::array<Cube, kLayers>, 2>, 2> calls{};
+    // The ending calls: [direction][layer][crossed][hit][a row further along]
+    std::array<std::array<Cube, kLayers>, 2> further{};
+    for (std::uint32_t element = 0; element < replayed.size(); ++element) {
+      const auto& replay = replayed[element];
+      if (replay.roadCount == 0U) {
+        continue;
+      }
+      const auto particle = study::goodParticle(mTruth->rows, std::span<const std::uint32_t>{replay.road.index, replay.roadCount});
+      if (particle == study::kNoTrackParticle) {
+        continue;
+      }
+      std::uint64_t hitLayers = 0U;
+      const auto* segments = segmentsOf(particle);
+      if (segments == nullptr) {
+        continue;
+      }
+      for (const auto* segment : *segments) {
+        hitLayers |= std::uint64_t{1} << geometry.surface(static_cast<SensorID>(segment->chip)).layer;
+      }
+      std::uint64_t rowLayers = 0U;
+      if (const auto rows = mRowsOf.find(particle); rows != mRowsOf.end()) {
+        for (const auto row : rows->second) {
+          rowLayers |= std::uint64_t{1} << mTruth->rows[row].layer;
+        }
+      }
+      const auto vertex = vertexRZ(mTruth->particles.find(particle));
+      const auto distance = [&](std::uint32_t row) { return pathDistance(row, vertex); };
+      const auto tally = [&](const Walk& walk, std::size_t direction) {
+        if (!walk.agrees) {
+          return;
+        }
+        // The walk's last row: its last step's taken row, else the road's end on that side.
+        double last = direction == 0U ? 0. : std::numeric_limits<double>::infinity();
+        for (std::uint8_t i = 0; i < replay.roadCount; ++i) {
+          last = direction == 0U ? std::max(last, distance(replay.road.index[i])) : std::min(last, distance(replay.road.index[i]));
+        }
+        for (const auto& step : walk.steps) {
+          if (step.choice != kNoRow) {
+            last = distance(step.choice);
+          }
+        }
+        bool beyond = false;
+        if (const auto rows = mRowsOf.find(particle); rows != mRowsOf.end()) {
+          for (const auto row : rows->second) {
+            beyond = beyond || (direction == 0U ? distance(row) > last + 0.5 : distance(row) < last - 0.5);
+          }
+        }
+        for (std::size_t s = 0; s < walk.steps.size(); ++s) {
+          const auto& holes = walk.steps[s].holes;
+          for (std::size_t h = 0; h < holes.size(); ++h) {
+            const auto [layer, crossed] = holes[h];
+            const bool ended = walk.end == FollowEnd::kHoles && s + 1U == walk.steps.size() && h + 1U == holes.size();
+            ++calls[direction][ended ? 1U : 0U][layer][crossed ? 1U : 0U][(hitLayers >> layer) & 1U][(rowLayers >> layer) & 1U];
+            if (ended) {
+              ++further[direction][layer][crossed ? 1U : 0U][(hitLayers >> layer) & 1U][beyond ? 1U : 0U];
+              const auto& step = walk.steps[s];
+              const auto target = std::ranges::find(step.targets, layer, &TargetSeen::layer);
+              if (crossed && target != step.targets.end()) {
+                const double chance = reachChance(parameters, step.state, step.factors, layer, target->window, direction == 0U ? PropagationDirection::kForward : PropagationDirection::kBackward, geometry, propagator, element, 32);
+                const auto bin = static_cast<std::size_t>(std::ranges::upper_bound(kChanceEdges, chance) - kChanceEdges.begin());
+                ++chances[direction][(hitLayers >> layer) & 1U][beyond ? 1U : 0U][std::min(bin, kChanceEdges.size() - 1U)];
+              }
+            }
+          }
+        }
+      };
+      if (!replay.outward.empty()) {
+        tally(replay.outward.front(), 0U);
+      }
+      tally(replay, 1U);
+    }
+    std::string text = std::format(
+      "  hole calls after iteration {} on the correct roads' walks (crossed / not, by the particle's MC hit and row on "
+      "the layer: hit+row hit-row nohit+row nohit-row):",
+      iteration.iteration);
+    for (std::size_t direction = 0; direction < 2U; ++direction) {
+      for (std::size_t ended = 0; ended < 2U; ++ended) {
+        text += std::format("\n    {}{}:", direction == 0U ? "outward" : "inward", ended == 1U ? ", the call that ended the walk" : "");
+        for (std::size_t layer = 0; layer < kLayers; ++layer) {
+          const auto& c = calls[direction][ended][layer];
+          std::size_t all = 0U;
+          for (const auto& a : c) {
+            for (const auto& b : a) {
+              all += b[0] + b[1];
+            }
+          }
+          if (all == 0U) {
+            continue;
+          }
+          text += std::format(" L{} crossed {}/{}/{}/{} not {}/{}/{}/{};", layer, c[1][1][1], c[1][1][0], c[1][0][1], c[1][0][0], c[0][1][1], c[0][1][0], c[0][0][1], c[0][0][0]);
+        }
+      }
+      text += std::format("\n    {}, the ending calls by a row further along (crossed: hit+further hit-further nohit+further nohit-further):", direction == 0U ? "outward" : "inward");
+      for (std::size_t layer = 0; layer < kLayers; ++layer) {
+        const auto& c = further[direction][layer];
+        if (c[1][1][1] + c[1][1][0] + c[1][0][1] + c[1][0][0] != 0U) {
+          text += std::format(" F{} {}/{}/{}/{};", layer, c[1][1][1], c[1][1][0], c[1][0][1], c[1][0][0]);
+        }
+      }
+      text += std::format("\n    {}, the crossed ending calls' reach chance (< 0.1 / 0.1-0.5 / 0.5-0.9 / 0.9-0.99 / > 0.99):", direction == 0U ? "outward" : "inward");
+      constexpr std::array<const char*, 4> kKinds{"hit, further", "hit, none", "no hit, further", "no hit, none"};
+      for (std::size_t hit = 0; hit < 2U; ++hit) {
+        for (std::size_t beyond = 0; beyond < 2U; ++beyond) {
+          const auto& c = chances[direction][1U - hit][1U - beyond];
+          text += std::format(" {}: {}/{}/{}/{}/{};", kKinds[(2U * hit) + beyond], c[0], c[1], c[2], c[3], c[4]);
+        }
+      }
+    }
+    mTransitionLines.push_back(text);
+  }
+
+  /// Which of the kink allowance's tests each of the iteration's own roads
+  /// needs, and how its outermost row fits the rest (the road-end fakes): the
+  /// roads of fakes with one wrong row, the
+  /// outermost, against the good roads, those of a particle with a true kink
+  /// above 3 theta0 just inside that row apart. The allowance's tests, each
+  /// against its nominal twin: a kinked triplet at the road's outer end, one
+  /// elsewhere, the road fit's last-step kink (the nominal fit refuses, the
+  /// one with the last step allowed accepts), the beam gate's tail. The
+  /// outermost row's chi2: the road less that row fitted (nominal), carried
+  /// to the row and updated with it.
+  template <typename Observation, typename Material>
+  void roadEndAudit(const Observation& iteration, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    const auto view = iteration.tracks->view();
+    const auto tracks = iteration.tracks->size();
+    const auto columns = frame.measurements();
+    auto nominal = std::make_unique<IterationParameters<Det>>(parameters);
+    nominal->kinkScale2 = 1.F;
+    const KinkBudget nominalBudget{.max = static_cast<int>(parameters.maxKinks), .gate = parameters.kinkChi2Min};
+    enum Population : std::uint8_t { kEndFake,
+                                     kOtherFake,
+                                     kGoodEndKink,
+                                     kGoodQuiet,
+                                     kGoodInnerKink,
+                                     kGoodOther,
+                                     kPopulations };
+    constexpr std::array<const char*, kPopulations> kPopulationNames{"fakes, one wrong row, the outermost", "other road fakes", "good, a true kink > 3 theta0 inside the outermost row", "good, no true kink > 3 theta0 in the road", "good, a true kink > 3 theta0 inside the road, not at its end", "good, not the class's or without MC hits"};
+    // The allowance's tests a road needs, a bit each.
+    enum Need : std::uint8_t { kOuterTriplet = 1U,
+                               kInnerTriplet = 2U,
+                               kLastStep = 4U,
+                               kBeamTail = 8U };
+    constexpr std::array<double, 8> kChi2Edges{0., 2., 4., 6., 9., 13.8, 25., 100.};
+    std::array<std::array<std::size_t, 16>, kPopulations> needs{};
+    std::array<std::array<std::size_t, kChi2Edges.size() + 1U>, kPopulations> chi2s{};
+    std::array<std::array<std::size_t, kChi2Edges.size() + 1U>, kPopulations> scaledChi2s{};
+    std::array<std::size_t, kPopulations> scaledPass{};
+    std::array<std::size_t, kPopulations> counts{};
+    std::array<std::size_t, kPopulations> unfitted{};
+    for (std::uint32_t track = iteration.trackOffset; track < tracks; ++track) {
+      const auto element = track - iteration.trackOffset;
+      const auto* proposal = element < iteration.proposals.size() ? &iteration.proposals[element] : nullptr;
+      auto road = roadOf(std::span<const std::uint32_t>{view.clusters[track].index, view.count[track]}, proposal);
+      if (road.size() < 4U) {
+        continue;
+      }
+      std::ranges::sort(road, [&](std::uint32_t a, std::uint32_t b) { return mTruth->rows[a].layer < mTruth->rows[b].layer; });
+      const auto outer = road.back();
+      const auto outerLayer = mTruth->rows[outer].layer;
+      // The population.
+      const auto good = study::goodParticle(mTruth->rows, road);
+      Population population = kOtherFake;
+      if (good == study::kNoTrackParticle) {
+        const auto majority = study::majorityParticle(mTruth->rows, road);
+        std::size_t wrong = 0U;
+        for (const auto row : road) {
+          wrong += mTruth->rows[row].carries(majority.particle) ? 0U : 1U;
+        }
+        population = wrong == 1U && !mTruth->rows[outer].carries(majority.particle) ? kEndFake : kOtherFake;
+      } else {
+        const auto at = mIndex.find(good);
+        population = kGoodOther;
+        if (at != mIndex.end() && mKinksDone && at->second + 1U < mKinkBegin.size()) {
+          population = kGoodQuiet;
+          for (auto i = mKinkBegin[at->second]; i < mKinkBegin[at->second + 1U]; ++i) {
+            const auto& kink = mKinks[i];
+            if (kink.layer < mTruth->rows[road.front()].layer || kink.to > outerLayer) {
+              continue;
+            }
+            const float size = std::max(std::abs(kink.theta), std::abs(kink.phi));
+            if (size > 3.F && kink.to == outerLayer) {
+              population = kGoodEndKink;
+              break;
+            }
+            if (size > 3.F) {
+              population = kGoodInnerKink;
+            }
+          }
+        }
+      }
+      ++counts[population];
+      // The triplets, nominal or kinked.
+      unsigned need = 0U;
+      for (std::size_t i = 0; i + 2U < road.size(); ++i) {
+        const auto a = timedPointAt(columns, road[i]);
+        const auto b = timedPointAt(columns, road[i + 1U]);
+        const auto c = timedPointAt(columns, road[i + 2U]);
+        TripletFitResult fit;
+        KinkTerms terms;
+        if (tripletAudit(parameters, mTruth->rows[road[i + 1U]].layer, a, b, c, 1.F, fit, terms) != kGraphPasses) {
+          need |= i + 3U == road.size() ? kOuterTriplet : kInnerTriplet;
+        }
+      }
+      // The road fit, its last step nominal and allowed.
+      const RowChain<Det> chain{.frame = &frame, .rows = road.data()};
+      const auto count = static_cast<int>(road.size());
+      const auto plain = fitOutward(propagator, geometry, material, chain, count, parameters.roadChi2MaxByNdf, nominalBudget);
+      const auto allowed = fitRoad(parameters, propagator, geometry, material, chain, count);
+      if (plain.status != RoadFitStatus::kAccepted && allowed.status == RoadFitStatus::kAccepted) {
+        need |= kLastStep;
+      }
+      // The beam gate, nominal and with its tail.
+      const auto& fitted = plain.status == RoadFitStatus::kAccepted ? plain : allowed;
+      Scalar beamChi2 = 0.F;
+      if (parameters.beamConstraint && fitted.status == RoadFitStatus::kAccepted && !clearsBeamLine(propagator, *nominal, frame, geometry, material, road.data(), static_cast<std::uint32_t>(road.size()), fitted.state, beamChi2)) {
+        need |= kBeamTail;
+      }
+      ++needs[population][need];
+      // The outermost row against the rest.
+      const auto inner = fitOutward(propagator, geometry, material, chain, count - 1, parameters.roadChi2MaxByNdf, nominalBudget);
+      BoundTrackState output;
+      CovarianceFactors outputFactors;
+      Scalar chi2 = 0.F;
+      if (inner.status != RoadFitStatus::kAccepted || !follow::updateCandidate<false>(propagator, geometry, material, measurementAt(frame, outer), PropagationDirection::kForward, inner.state, factorCovariance(inner.state.cov), output, outputFactors, chi2, 1.F)) {
+        ++unfitted[population];
+        continue;
+      }
+      const auto binOf = [&](Scalar value) {
+        std::size_t bin = 0U;
+        while (bin < kChi2Edges.size() && static_cast<double>(value) >= kChi2Edges[bin]) {
+          ++bin;
+        }
+        return bin;
+      };
+      ++chi2s[population][binOf(chi2)];
+      // The same step with its scattering scaled by the allowance, as the
+      // follow's kink step takes it, against the follow's gate.
+      Scalar scaled = 0.F;
+      if (follow::updateCandidate<true>(propagator, geometry, material, measurementAt(frame, outer), PropagationDirection::kForward, inner.state, factorCovariance(inner.state.cov), output, outputFactors, scaled, std::sqrt(parameters.kinkScale2))) {
+        ++scaledChi2s[population][binOf(scaled)];
+        scaledPass[population] += scaled <= parameters.clusterChi2Max ? 1U : 0U;
+      }
+    }
+    std::string text = std::format("  the road ends after iteration {} (its own roads; the allowance's tests each needs, against its nominal twin):", iteration.iteration);
+    constexpr std::array<const char*, 4> kNeedNames{"outer triplet", "inner triplet", "last-step kink", "beam tail"};
+    for (std::size_t population = 0; population < kPopulations; ++population) {
+      if (counts[population] == 0U) {
+        continue;
+      }
+      text += std::format("\n    {} {}: needs", kPopulationNames[population], counts[population]);
+      for (unsigned need = 0; need < 16U; ++need) {
+        if (needs[population][need] == 0U) {
+          continue;
+        }
+        std::string name;
+        for (std::size_t bit = 0; bit < kNeedNames.size(); ++bit) {
+          if (((need >> bit) & 1U) != 0U) {
+            name += name.empty() ? kNeedNames[bit] : std::string{" + "} + kNeedNames[bit];
+          }
+        }
+        text += std::format(" {} {};", name.empty() ? "none" : name, needs[population][need]);
+      }
+      text += " | the outermost row's chi2 on the rest:";
+      for (std::size_t bin = 0; bin <= kChi2Edges.size(); ++bin) {
+        if (chi2s[population][bin] != 0U) {
+          text += bin == kChi2Edges.size() ? std::format(" >= {} {};", kChi2Edges.back(), chi2s[population][bin]) : std::format(" < {} {};", kChi2Edges[bin], chi2s[population][bin]);
+        }
+      }
+      text += std::format(" the rest not fitted {} | scaled by the allowance:", unfitted[population]);
+      for (std::size_t bin = 0; bin <= kChi2Edges.size(); ++bin) {
+        if (scaledChi2s[population][bin] != 0U) {
+          text += bin == kChi2Edges.size() ? std::format(" >= {} {};", kChi2Edges.back(), scaledChi2s[population][bin]) : std::format(" < {} {};", kChi2Edges[bin], scaledChi2s[population][bin]);
+        }
+      }
+      text += std::format(" within the step gate ({:.1f}) {}", parameters.clusterChi2Max, scaledPass[population]);
+    }
+    mTransitionLines.push_back(text);
+  }
+
+  /// The class's fates after iteration \a iteration, cumulative: complete,
+  /// short, not found and found at all, over the class and by the pT ranges
+  /// the iterations' floors bound (from each floor up to the next higher).
+  void progress(std::size_t iteration)
+  {
+    std::vector<double> edges = mFloors;
+    std::ranges::sort(edges);
+    edges.erase(std::ranges::unique(edges).begin(), edges.end());
+    const std::size_t ranges = edges.size() + 1U;           // the last: the whole class
+    std::vector<std::array<std::size_t, 3>> counts(ranges); // by Fate
+    for (std::size_t index = 0; index < mFindable.size(); ++index) {
+      const auto found = mTruth->particles.find(mFindable[index]);
+      const double pt = truePt(found);
+      ++counts.back()[mFate[index]];
+      for (std::size_t range = edges.size(); range-- > 0U;) {
+        if (pt >= edges[range]) {
+          ++counts[range][mFate[index]];
+          break;
+        }
+      }
+    }
+    std::string text = std::format("  after iteration {} (cumulative; complete / short / not found / found, % of the class in each range):", iteration);
+    for (std::size_t range = ranges; range-- > 0U;) {
+      const auto& c = counts[range];
+      const std::size_t n = c[kComplete] + c[kShortFate] + c[kNotFound];
+      if (n == 0U) {
+        continue;
+      }
+      const auto pc = [&](std::size_t k) { return study::percent(k, n); };
+      const std::string name = range == ranges - 1U ? std::string{"all"} : (range + 1U < edges.size() ? std::format("{}-{} GeV", edges[range], edges[range + 1U]) : std::format(">= {} GeV", edges[range]));
+      text += std::format("\n    {} ({}): {:.2f} / {:.2f} / {:.2f} / {:.2f}", name, n, pc(c[kComplete]), pc(c[kShortFate]), pc(c[kNotFound]), pc(c[kComplete] + c[kShortFate]));
+    }
+    mProgressLines.push_back(text);
+  }
+
+  /// The inward pass of a refit of \a rows from \a seed, as
+  /// `detail::inwardPass` runs it: its status, the chain
+  /// index and the step it failed at, the state the failing step started
+  /// from, and with \a record each state: the seed, then each filtered one
+  /// with its row and increment, the covariance written. It is the backward
+  /// loop of `detail::runPass` (`TrackFitter.h`), recording; kept in step
+  /// with it, a difference counted as a mismatch (`mInwardMismatch`).
+  struct InwardStep {
+    std::uint32_t row = 0U;
+    BoundTrackState state;
+    Scalar chi2 = 0.F;
+  };
+  struct InwardRun {
+    PropagationStatus status = PropagationStatus::kOk;
+    int failedIndex = -1;
+    int failedStep = 0;
+    BoundTrackState before;
+    std::vector<InwardStep> history;
+  };
+  template <typename Material>
+  [[nodiscard]] static InwardRun runInward(const BoundTrackState& seed, const std::vector<std::uint32_t>& rows, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator, bool record)
+  {
+    InwardRun out;
+    const int n = static_cast<int>(rows.size());
+    const RowChain<Det> chain{.frame = &frame, .rows = rows.data()};
+    const auto budget = o2::gtrk::detail::kinkBudgetFor(kinkBudget(parameters), n);
+    BoundTrackState state = seed;
+    CovarianceFactors factors;
+    if (record) {
+      out.history.push_back({.row = rows[static_cast<std::size_t>(n - 1)], .state = seed, .chi2 = 0.F});
+    }
+    const auto first = o2::gtrk::detail::startOnMeasurement(state, factors, chain[n - 1]);
+    if (!updateUsable(first, factors)) {
+      out.status = PropagationStatus::kNotFinite;
+      out.failedIndex = n - 1;
+      return out;
+    }
+    Scalar chi2 = first.chi2;
+    int kinks = 0;
+    for (int step = 1; step < n; ++step) {
+      const int index = n - 1 - step;
+      const auto& stepProp = stepPropagator(propagator, geometry, chain, index + 1, index);
+      out.before = state;
+      covarianceFromFactors(factors, out.before.cov);
+      const Scalar before = chi2;
+      const auto status = o2::gtrk::detail::kinkStep(stepProp, geometry, material, chain[index], PropagationDirection::kBackward, state, factors, chi2, budget, step < n - 1, kinks);
+      if (status != PropagationStatus::kOk) {
+        out.status = status;
+        out.failedIndex = index;
+        out.failedStep = step;
+        return out;
+      }
+      if (record) {
+        InwardStep one{.row = rows[static_cast<std::size_t>(index)], .state = state, .chi2 = chi2 - before};
+        covarianceFromFactors(factors, one.state.cov);
+        out.history.push_back(one);
+      }
+    }
+    return out;
+  }
+
+  /// Both crossings of a barrel plane's line by \a state's transverse circle,
+  /// from the geometry here rather than by the solve's
+  /// quadratic: each one's 3D path in \a direction's sense (positive: along
+  /// it), turn [rad], offset along the line from the start's foot, local
+  /// coordinates, whether inside the sensor, incidence and distance from the
+  /// plane's centre; which the solve tries first (the smaller offset).
+  struct Root {
+    double path = 0.;
+    double turn = 0.;
+    double mu = 0.;
+    double loc0 = 0.;
+    double loc1 = 0.;
+    double cosInc = 0.;
+    double offCentre = 0.;
+    bool inside = false;
+  };
+  struct Roots {
+    bool barrel = false;
+    bool crosses = false;
+    std::array<Root, 2> root{};
+    std::size_t first = 0U;
+  };
+  [[nodiscard]] static Roots rootsOf(const BoundTrackState& state, const TrackingSurface& from, const TrackingSurface& to, PropagationDirection direction, const Propagator& propagator)
+  {
+    Roots out;
+    const auto nx = static_cast<double>(to.normal[0]);
+    const auto ny = static_cast<double>(to.normal[1]);
+    const double transverse = std::hypot(nx, ny);
+    out.barrel = transverse > 0.9;
+    if (!out.barrel) {
+      return out;
+    }
+    Scalar global[3]{};
+    surfaceToGlobal(from, state.loc0(), state.loc1(), global);
+    const auto x0 = static_cast<double>(global[0]);
+    const auto y0 = static_cast<double>(global[1]);
+    const auto z0 = static_cast<double>(global[2]);
+    const auto phi = static_cast<double>(state.phi());
+    const double sinTheta = std::sin(static_cast<double>(state.theta()));
+    const double cosTheta = std::cos(static_cast<double>(state.theta()));
+    const double kappa = propagator.curvature(static_cast<double>(state.qOverP()), sinTheta);
+    if (!(std::abs(kappa) > 0.)) {
+      return out;
+    }
+    const double dx = std::cos(phi);
+    const double dy = std::sin(phi);
+    const double cx = x0 - (dy / kappa);
+    const double cy = y0 + (dx / kappa);
+    const double radius = 1. / std::abs(kappa);
+    const double ux = nx / transverse;
+    const double uy = ny / transverse;
+    const double tx = -uy;
+    const double ty = ux;
+    const auto ox = static_cast<double>(to.origin[0]);
+    const auto oy = static_cast<double>(to.origin[1]);
+    const auto oz = static_cast<double>(to.origin[2]);
+    const double d = ((cx - ox) * ux) + ((cy - oy) * uy);
+    if (std::abs(d) > radius) {
+      return out;
+    }
+    out.crosses = true;
+    const double half = std::sqrt((radius * radius) - (d * d));
+    const double fx = cx - (d * ux);
+    const double fy = cy - (d * uy);
+    const auto sense = static_cast<double>(static_cast<int>(direction));
+    for (std::size_t i = 0; i < 2U; ++i) {
+      const double s = i == 0U ? -1. : 1.;
+      const double px = fx + (s * half * tx);
+      const double py = fy + (s * half * ty);
+      const double ax = px - x0;
+      const double ay = py - y0;
+      const double along = (ax * dx) + (ay * dy);
+      const double across = (-ax * dy) + (ay * dx);
+      const double turn = std::atan2(kappa * along, 1. - (kappa * across));
+      const double ell = std::abs(turn) < 1e-6 ? along : turn / kappa;
+      auto& root = out.root[i];
+      root.turn = turn;
+      root.path = sense * ell / sinTheta;
+      root.mu = (ax * tx) + (ay * ty);
+      const double pz = z0 + (ell / sinTheta * cosTheta);
+      const double rel[3] = {px - ox, py - oy, pz - oz};
+      root.loc0 = (rel[0] * static_cast<double>(to.axis0[0])) + (rel[1] * static_cast<double>(to.axis0[1])) + (rel[2] * static_cast<double>(to.axis0[2]));
+      root.loc1 = (rel[0] * static_cast<double>(to.axis1[0])) + (rel[1] * static_cast<double>(to.axis1[1])) + (rel[2] * static_cast<double>(to.axis1[2]));
+      root.inside = to.bounds.isInside(static_cast<Scalar>(root.loc0), static_cast<Scalar>(root.loc1));
+      const double phi1 = phi + turn;
+      root.cosInc = (static_cast<double>(to.normal[0]) * sinTheta * std::cos(phi1)) + (static_cast<double>(to.normal[1]) * sinTheta * std::sin(phi1)) + (static_cast<double>(to.normal[2]) * cosTheta);
+      root.offCentre = std::hypot(rel[0], rel[1], rel[2]);
+    }
+    out.first = std::abs(out.root[0].mu) <= std::abs(out.root[1].mu) ? 0U : 1U;
+    return out;
+  }
+
+  enum InwardKind : std::uint8_t { kInwardOwn,
+                                   kInwardWrong,
+                                   kInwardControl,
+                                   kInwardKinds };
+  static constexpr std::array<const char*, kInwardKinds> kInwardKindNames{"failing, own rows", "failing, wrong rows", "control"};
+  /// The seeds the failing inward passes are tried again from: as the fit has
+  /// it, the outward end state with its own
+  /// covariance and that times 100, and the diffuse seed with the MC truth's
+  /// momentum and direction at the outermost row, its q/p alone, its
+  /// direction alone.
+  static constexpr std::array<const char*, 6> kSeedNames{"as the fit (diffuse)", "the outward covariance", "the outward covariance x 100", "MC momentum and direction, diffuse", "MC q/p only, diffuse", "MC direction only, diffuse"};
+
+  /// A particle's charge [e] from its PDG code, by O2's particle table as
+  /// the sink takes it (`Charge()` in thirds); 0 for a code it does not know.
+  [[nodiscard]] static int chargeOf(int pdg)
+  {
+    const auto* particle = o2::O2DatabasePDG::Instance()->GetParticle(pdg);
+    return particle == nullptr ? 0 : static_cast<int>(std::lround(particle->Charge() / 3.));
+  }
+  /// The sign relating the state's q/p to the charge: q/p = sign x charge / p
+  /// (Propagator's curvature convention, checked by the control's agreement,
+  /// `mChargeAgree`).
+  static constexpr double kChargeSign = 1.;
+
+  /// One refit's inward pass against the truth: its states
+  /// to the CSV and the tables by step, the pass from other seeds, both roots
+  /// of a failing step on a barrel plane.
+  template <typename Material>
+  void inwardStudy(InwardKind kind, std::uint64_t particle, const std::vector<std::uint32_t>& rows, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    const int n = static_cast<int>(rows.size());
+    if (n < 3) {
+      return;
+    }
+    const RowChain<Det> chain{.frame = &frame, .rows = rows.data()};
+    const auto fit = fitMeasurements(propagator, geometry, material, chain, n, kinkBudget(parameters));
+    if (fit.failedPass == FitPass::kOutward) {
+      ++mInwardMismatch[kind];
+      return;
+    }
+    const auto chainSeed = makeChainSeed(propagator, geometry, chain, n);
+    BoundTrackState seed = fit.outwardState;
+    setDiffuseCovariance(seed, chainSeed.qOverPSigma);
+    const auto run = runInward(seed, rows, parameters, frame, geometry, material, propagator, true);
+    if ((run.status == PropagationStatus::kOk) != (kind == kInwardControl)) {
+      ++mInwardMismatch[kind];
+      return;
+    }
+    ++mInwardCount[kind];
+    const auto found = mTruth->particles.find(particle);
+    const auto pt = static_cast<float>(truePt(found));
+    const int pdg = found != mTruth->particles.end() ? found->second.pdg : 0;
+    const auto index = mIndex.find(particle);
+    const auto& own = mRowsOf.at(particle);
+    const auto legOf = [&](std::uint32_t row) -> int {
+      if (index == mIndex.end() || mLegs.empty() || mTimed[index->second] == 0U) {
+        return -1;
+      }
+      const auto at = std::ranges::find(own, row);
+      return at == own.end() ? -1 : static_cast<int>(mLegs[index->second][static_cast<std::size_t>(at - own.begin())]);
+    };
+    const auto nan = std::numeric_limits<double>::quiet_NaN();
+    const int charge = chargeOf(pdg);
+    for (std::size_t k = 0; k < run.history.size(); ++k) {
+      const auto& one = run.history[k];
+      const auto& state = one.state;
+      const auto* segment = mTruth->rows[one.row].carries(particle) ? segmentOfRow(particle, frame, one.row) : nullptr;
+      const double p = 1. / std::abs(static_cast<double>(state.qOverP()));
+      const double sigmaQOverP = std::sqrt(std::max(0., static_cast<double>(state.variance(kQOverP))));
+      const double sigmaPhi = std::sqrt(std::max(0., static_cast<double>(state.variance(kPhi))));
+      double pTrue = nan;
+      double phiTrue = nan;
+      double thetaTrue = nan;
+      std::array<double, 2> locTrue{nan, nan};
+      if (segment != nullptr) {
+        pTrue = std::hypot(segment->momentum[0], segment->momentum[1], segment->momentum[2]);
+        phiTrue = std::atan2(segment->momentum[1], segment->momentum[0]);
+        thetaTrue = std::atan2(std::hypot(segment->momentum[0], segment->momentum[1]), segment->momentum[2]);
+        locTrue = crossingOn(*segment, geometry.planeOf(state));
+        auto& by = mInwardSteps[kind][std::min<std::size_t>(k, kInwardStepSlots - 1U)];
+        // Signed: the state's q/p against the truth's charge over its
+        // momentum; the charge's sign agreement.
+        const double truthQOverP = charge != 0 ? static_cast<double>(charge) * kChargeSign / pTrue : nan;
+        if (charge != 0 && k == 0U) {
+          ++mChargeAgree[kind][(static_cast<double>(state.qOverP()) * truthQOverP) > 0. ? 0U : 1U];
+        }
+        by.ratio.push_back(p / pTrue);
+        by.pullQOverP.push_back((static_cast<double>(state.qOverP()) - truthQOverP) / sigmaQOverP);
+        const double dphi = std::remainder(static_cast<double>(state.phi()) - phiTrue, 2. * std::numbers::pi);
+        by.dphi.push_back(1e3 * dphi);
+        by.pullPhi.push_back(dphi / sigmaPhi);
+        by.relSigma.push_back(sigmaQOverP * p);
+      }
+      // Both crossings of this step's plane from the state it started from:
+      // whether the one the solve takes is the particle's.
+      int stepRoot = -1;
+      if (k >= 1U && segment != nullptr) {
+        BoundTrackState from = run.history[k - 1U].state;
+        if (k == 1U) {
+          const auto start = measurementAt(frame, run.history[0].row);
+          from.par[kLoc0] = start.loc0;
+          from.par[kLoc1] = start.loc1;
+        }
+        const auto& to = geometry.planeOf(state);
+        const auto roots = rootsOf(from, geometry.planeOf(from), to, PropagationDirection::kBackward, propagator);
+        stepRoot = !roots.barrel ? 0 : 3;
+        if (roots.barrel && roots.crosses) {
+          const auto& first = roots.root[roots.first];
+          const auto& second = roots.root[1U - roots.first];
+          const Root* taken = first.path >= 0. ? &first : (second.path >= 0. && second.offCentre < first.offCentre ? &second : nullptr);
+          if (taken != nullptr) {
+            const Root& other = taken == &first ? second : first;
+            stepRoot = std::hypot(taken->loc0 - locTrue[0], taken->loc1 - locTrue[1]) <= std::hypot(other.loc0 - locTrue[0], other.loc1 - locTrue[1]) ? 1 : 2;
+            // Whether the sensor's bounds tell the two apart, and the turns.
+            const auto turnBin = [](double turn) { return std::abs(turn) < std::numbers::pi / 2. ? "< 90" : "90-180"; };
+            ++mStepRootDetail[std::format("{} | {} | taken {} the sensor, turn {} deg, path {} | the other {} the sensor, turn {} deg, path {}", kInwardKindNames[kind], stepRoot == 1 ? "the solve's the particle's" : "the other the particle's", taken->inside ? "inside" : "outside", turnBin(taken->turn), taken->path >= 0. ? "ahead" : "behind", other.inside ? "inside" : "outside", turnBin(other.turn), other.path >= 0. ? "ahead" : "behind")];
+            // A rule among the crossings ahead:
+            // the one nearer the plane's centre, against the particle's.
+            if (other.path >= 0.) {
+              const bool nearerIsTaken = taken->offCentre <= other.offCentre;
+              ++mStepRootDetail[std::format("{} | both ahead: the crossing nearer the plane's centre is {}", kInwardKindNames[kind], nearerIsTaken == (stepRoot == 1) ? "the particle's" : "not the particle's")];
+              const double margin = std::abs(taken->offCentre - other.offCentre);
+              ++mStepRootDetail[std::format("{} | both ahead, {}: the two centres' distances differ by {}", kInwardKindNames[kind], stepRoot == 1 ? "the solve's the particle's" : "the other the particle's", margin < 1. ? "< 1 cm" : (margin < 5. ? "1-5 cm" : (margin < 20. ? "5-20 cm" : ">= 20 cm")))];
+            }
+          }
+        }
+        ++mStepRoots[kind][std::min<std::size_t>(k, kInwardStepSlots - 1U)][static_cast<std::size_t>(stepRoot)];
+      }
+      if (mInwardCsv) {
+        *mInwardCsv << std::format("{},{},{:.4f},{},{},{},{},{},{},{},{},{:.5g},{:.5g},{:.6g},{:.6g},{:.6g},{:.6g},{:.4g},{:.4g},{:.4g},{:.5g},{:.5g},{:.5g},{:.5g},{:.6g},{},{}\n", static_cast<int>(kind), particle, static_cast<double>(pt), pdg, n, static_cast<int>(run.status), run.failedStep, k, one.row, static_cast<int>(mTruth->rows[one.row].layer), legOf(one.row), p, pTrue, static_cast<double>(state.phi()), phiTrue, static_cast<double>(state.theta()), thetaTrue, sigmaQOverP * p, sigmaPhi, static_cast<double>(one.chi2), static_cast<double>(state.loc0()), static_cast<double>(state.loc1()), locTrue[0], locTrue[1], static_cast<double>(state.qOverP()), charge, stepRoot);
+      }
+    }
+    ruleStudy(kind, particle, rows, parameters, frame, geometry, material, propagator);
+    if (kind == kInwardControl) {
+      return;
+    }
+    // Both roots at the failing step, on a barrel plane.
+    {
+      const auto& to = geometry.planeOf(chain[run.failedIndex]);
+      const auto roots = rootsOf(run.before, geometry.planeOf(run.before), to, PropagationDirection::kBackward, propagator);
+      const std::string key = std::format("{} | status {}", kInwardKindNames[kind], static_cast<int>(run.status));
+      if (!roots.barrel) {
+        ++mRoots[key + " | a disc plane"];
+      } else if (!roots.crosses) {
+        ++mRoots[key + " | the circle misses the line"];
+      } else {
+        const auto& first = roots.root[roots.first];
+        const auto& second = roots.root[1U - roots.first];
+        std::string what;
+        if (first.path >= 0.) {
+          what = "the first crossing ahead: the solve takes it";
+        } else if (!(second.path >= 0.)) {
+          what = "both crossings behind";
+        } else if (second.offCentre < first.offCentre) {
+          what = "the second ahead and nearer the centre: the solve takes it";
+        } else {
+          what = std::format("the second ahead, farther from the centre (the guard), {} the sensor, turn {}", second.inside ? "inside" : "outside", std::abs(second.turn) < std::numbers::pi / 2. ? "< 90 deg" : "90-180 deg");
+        }
+        ++mRoots[key + " | " + what];
+        // Which crossing the particle's own row is at (own rows only).
+        if (const auto* segment = mTruth->rows[rows[static_cast<std::size_t>(run.failedIndex)]].carries(particle) ? segmentOfRow(particle, frame, rows[static_cast<std::size_t>(run.failedIndex)]) : nullptr; segment != nullptr) {
+          const auto truth = crossingOn(*segment, to);
+          const double toFirst = std::hypot(first.loc0 - truth[0], first.loc1 - truth[1]);
+          const double toSecond = std::hypot(second.loc0 - truth[0], second.loc1 - truth[1]);
+          ++mRoots[key + std::format(" | the MC crossing nearer the {} crossing", toFirst <= toSecond ? "first" : "second")];
+        }
+      }
+    }
+    if (kind != kInwardOwn) {
+      return;
+    }
+    // The same pass from other seeds.
+    const auto* outer = segmentOfRow(particle, frame, rows.back());
+    for (std::size_t variant = 0; variant < kSeedNames.size(); ++variant) {
+      BoundTrackState other = seed;
+      if (variant == 1U || variant == 2U) {
+        other = fit.outwardState;
+        if (variant == 2U) {
+          for (auto& value : other.cov) {
+            value *= 100.F;
+          }
+        }
+      } else if (variant >= 3U) {
+        if (outer == nullptr) {
+          ++mSeedOutcomes[variant][3];
+          continue;
+        }
+        const double pTrue = std::hypot(outer->momentum[0], outer->momentum[1], outer->momentum[2]);
+        if (variant != 5U) {
+          other.par[kQOverP] = static_cast<Scalar>(charge != 0 ? static_cast<double>(charge) * kChargeSign / pTrue : (seed.qOverP() < 0.F ? -1. : 1.) / pTrue);
+        }
+        if (variant != 4U) {
+          other.par[kPhi] = static_cast<Scalar>(std::atan2(outer->momentum[1], outer->momentum[0]));
+          other.par[kTheta] = static_cast<Scalar>(std::atan2(std::hypot(outer->momentum[0], outer->momentum[1]), outer->momentum[2]));
+        }
+      }
+      const auto again = runInward(other, rows, parameters, frame, geometry, material, propagator, false);
+      // [passes, fails at the same step, fails later, fails earlier]
+      std::size_t outcome = 0U;
+      if (again.status != PropagationStatus::kOk) {
+        outcome = again.failedStep == run.failedStep ? 1U : (again.failedStep > run.failedStep ? 2U : 3U);
+      }
+      ++mSeedOutcomes[variant][outcome];
+    }
+  }
+
+  /// The crossing rules and the seeds compared: the refit of the same rows as `follow::Refit` takes it, under
+  /// each `CrossingRule`, from the diffuse seed as production and from the
+  /// outward end state with its own covariance.
+  static constexpr std::array<CrossingRule, 3> kCrossingRules{CrossingRule::kFirstAhead, CrossingRule::kNearerCentre, CrossingRule::kInsideFirst};
+  static constexpr std::array<const char*, 3> kCrossingRuleNames{"the first ahead (default)", "nearer the centre", "inside first"};
+  static constexpr std::array<const char*, 2> kRuleSeedNames{"diffuse seed", "outward covariance"};
+  enum RuleOutcome : std::uint8_t { kRuleOutward,
+                                    kRuleInward,
+                                    kRuleChi2,
+                                    kRuleAccepted,
+                                    kRuleOutcomes };
+  struct RuleTally {
+    std::array<std::size_t, kRuleOutcomes> outcome{};
+    /// Against the default from the same seed: accepted by both, the state
+    /// or chi2 not bit for bit; accepted by the default only; by this only.
+    std::array<std::size_t, 3> against{};
+    /// The accepted fits' state on the innermost row against the MC truth.
+    std::vector<double> pullQOverP, pullPhi, pullTheta, pullLoc0, pullLoc1;
+  };
+
+  /// One chain's refits under every rule and seed (`kCrossingRules`), each
+  /// against the default's from the same seed.
+  template <typename Material>
+  void ruleStudy(InwardKind kind, std::uint64_t particle, const std::vector<std::uint32_t>& rows, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    const int n = static_cast<int>(rows.size());
+    const RowChain<Det> chain{.frame = &frame, .rows = rows.data()};
+    const auto found = mTruth->particles.find(particle);
+    const int charge = found != mTruth->particles.end() ? chargeOf(found->second.pdg) : 0;
+    const auto* inner = mTruth->rows[rows.front()].carries(particle) ? segmentOfRow(particle, frame, rows.front()) : nullptr;
+    struct Outcome {
+      RuleOutcome outcome = kRuleOutward;
+      BoundTrackState state;
+      Scalar chi2 = 0.F;
+    };
+    const auto refit = [&]<CrossingRule Rule>(bool outwardCovariance) {
+      Outcome out;
+      const auto one = fitMeasurements<Rule>(propagator, geometry, material, chain, n, kinkBudget(parameters));
+      if (one.failedPass == FitPass::kOutward) {
+        return out;
+      }
+      out.state = one.state;
+      out.chi2 = one.chi2;
+      int ndf = one.ndf;
+      bool ok = one.status == PropagationStatus::kOk;
+      if (outwardCovariance) {
+        std::int16_t failed = -1;
+        std::int16_t kinkAt = -1;
+        int kinks = 0;
+        out.state = BoundTrackState{};
+        ok = o2::gtrk::detail::runPass<Rule>(propagator, geometry, material, chain, n, PropagationDirection::kBackward, one.outwardState, out.state, out.chi2, failed, kinkBudget(parameters), kinks, kinkAt, NoFitObserver{}) == PropagationStatus::kOk;
+        ndf = (2 * n) - kNBoundParams - (2 * kinks);
+      }
+      if (!ok) {
+        out.outcome = kRuleInward;
+        return out;
+      }
+      out.outcome = out.chi2 <= parameters.roadChi2MaxByNdf[ndf] ? kRuleAccepted : kRuleChi2;
+      return out;
+    };
+    for (std::size_t seed = 0; seed < kRuleSeedNames.size(); ++seed) {
+      std::array<Outcome, kCrossingRules.size()> outcomes { refit.template operator()<kCrossingRules[0]>(seed == 1U),
+                                                            refit.template operator()<kCrossingRules[1]>(seed == 1U),
+                                                            refit.template operator()<kCrossingRules[2]>(seed == 1U) };
+      for (std::size_t rule = 0; rule < kCrossingRules.size(); ++rule) {
+        auto& tally = mRuleTallies[kind][rule][seed];
+        const auto& one = outcomes[rule];
+        ++tally.outcome[one.outcome];
+        const bool accepted = one.outcome == kRuleAccepted;
+        const bool byDefault = outcomes[0].outcome == kRuleAccepted;
+        if (accepted && byDefault) {
+          // Bit identity is intentional; these records have no padding.
+          // NOLINTNEXTLINE(bugprone-suspicious-memory-comparison)
+          tally.against[0] += std::memcmp(&one.state, &outcomes[0].state, sizeof(BoundTrackState)) != 0 || std::bit_cast<std::uint32_t>(one.chi2) != std::bit_cast<std::uint32_t>(outcomes[0].chi2) ? 1U : 0U;
+        } else if (byDefault) {
+          ++tally.against[1];
+        } else if (accepted) {
+          ++tally.against[2];
+        }
+        if (!accepted || inner == nullptr || one.state.surface != geometry.planeOf(chain[0]).id) {
+          continue;
+        }
+        const auto& state = one.state;
+        const double pTrue = std::hypot(inner->momentum[0], inner->momentum[1], inner->momentum[2]);
+        const double sigma[kNBoundParams] = {std::sqrt(static_cast<double>(state.variance(kLoc0))), std::sqrt(static_cast<double>(state.variance(kLoc1))), std::sqrt(static_cast<double>(state.variance(kPhi))), std::sqrt(static_cast<double>(state.variance(kTheta))), std::sqrt(static_cast<double>(state.variance(kQOverP)))};
+        const auto locTrue = crossingOn(*inner, geometry.planeOf(state));
+        tally.pullLoc0.push_back((static_cast<double>(state.loc0()) - locTrue[0]) / sigma[kLoc0]);
+        tally.pullLoc1.push_back((static_cast<double>(state.loc1()) - locTrue[1]) / sigma[kLoc1]);
+        tally.pullPhi.push_back(std::remainder(static_cast<double>(state.phi()) - std::atan2(inner->momentum[1], inner->momentum[0]), 2. * std::numbers::pi) / sigma[kPhi]);
+        tally.pullTheta.push_back((static_cast<double>(state.theta()) - std::atan2(std::hypot(inner->momentum[0], inner->momentum[1]), inner->momentum[2])) / sigma[kTheta]);
+        if (charge != 0) {
+          tally.pullQOverP.push_back((static_cast<double>(state.qOverP()) - (static_cast<double>(charge) * kChargeSign / pTrue)) / sigma[kQOverP]);
+        }
+      }
+    }
+  }
+
+  /// The clutter test on the follow: at
+  /// each step of a follow whose core -- the road and the rows the walks
+  /// took before -- is one particle's, every time-compatible row in each
+  /// target's window refitted from the step's state: its chi2 against the
+  /// prediction and the predicted residual covariance V. The non-own rows
+  /// beyond the gate in the window give the local clutter density rho; the
+  /// uniform expectation of strangers within chi2 t is rho pi t sqrt|V|,
+  /// summed over the targets where the window leaves room for rho, against
+  /// the strangers seen on the same targets by their lineage, and the
+  /// held-out own row's chi2 against chi2(2). The follows are the
+  /// iteration's kept tracks' and its dropped records' (`replayDropped`).
+  static constexpr std::array<double, 5> kClutterEdges{1., 2., 4., 8., 0.}; ///< the last is the gate
+  enum Lineage : std::uint8_t { kLineOwnHeldOut,
+                                kLineOwnOverlap,
+                                kLineOwnOtherLeg,
+                                kLineNoise,
+                                kLineDelta,
+                                kLineDecay,
+                                kLineDaughterOther,
+                                kLineGrandDaughter,
+                                kLineMother,
+                                kLineSibling,
+                                kLineUnknown,
+                                kLineUnrelated,
+                                kLineages };
+  static constexpr std::array<const char*, kLineages> kLineageNames{"own, held out", "own, an overlap on its leg", "own, another leg", "no signal label", "daughter: delta ray", "daughter: decay", "daughter: other", "granddaughter", "its mother", "sibling", "lineage unknown", "unrelated"};
+  /// Why a target has no held-out own row: the particle's row on the layer
+  /// and the core's leg exists but is not in the window (outside it, or its
+  /// transport failed); the leg has rows beyond the layer but none on it (a
+  /// gap); its rows there are on another leg; it turned (rows on later legs
+  /// only); or it has no row after the core's last at all.
+  enum NoOwn : std::uint8_t { kNoOwnOutside,
+                              kNoOwnGap,
+                              kNoOwnOtherLeg,
+                              kNoOwnTurned,
+                              kNoOwnEnded,
+                              kNoOwnReasons };
+  static constexpr std::array<const char*, kNoOwnReasons> kNoOwnNames{"own row outside the window", "a gap on its leg", "own row on another leg", "turned: rows on later legs only", "past its last row"};
+  struct ClutterTally {
+    std::size_t targets = 0U;
+    std::size_t empty = 0U;    ///< targets with no row in the window
+    std::size_t measured = 0U; ///< targets whose window leaves room beyond the gate for rho
+    std::array<double, kClutterEdges.size()> expected{};
+    /// The same within the gate from the layer's mean density: its rows in
+    /// the window's time range over its sensors' area (rho, read from the
+    /// grid's counts).
+    double expectedLayer = 0.;
+    std::array<std::array<std::size_t, kClutterEdges.size()>, kLineages> seen{}; ///< on the measured targets, cumulative, chi2 <= edge
+    std::size_t ownInBox = 0U;                                                   ///< measured targets with the held-out own row in the window
+    std::array<std::size_t, kClutterEdges.size()> ownSeen{};                     ///< its chi2 <= edge
+    std::size_t anyStrangerInGate = 0U;                                          ///< measured targets with a non-own row within the gate
+    double anyPredicted = 0.;                                                    ///< sum of 1 - exp(-E(gate)) over them
+    double sqrtDetV = 0.;                                                        ///< over the measured targets, for the mean
+    /// The targets without the held-out own row, by why (`NoOwn`): all, the
+    /// ones a stranger was taken at, an own row of another leg taken.
+    std::array<std::array<std::size_t, 3>, kNoOwnReasons> noOwn{};
+    /// The own row there but not seen: not visited (beyond the window's cells
+    /// or time), visited outside the box, in the box but its transport failed.
+    std::array<std::size_t, 3> outsideWhy{};
+    /// The swaps, the held-out own row within the gate and a stranger (not
+    /// the particle's) taken on its layer: the own row available to the step
+    /// (it passed in production) or not (held, refused), by whether the step
+    /// looked ahead: [available][plain, lookahead, kink]; of the available,
+    /// the stranger's chi2 the lower, and the one-step evidence (-chi2/2 -
+    /// log sqrt|V|) preferring the own row.
+    std::array<std::array<std::size_t, 3>, 2> swaps{};
+    std::array<std::size_t, 3> swapsTakenLower{};
+    std::array<std::size_t, 3> swapsEvidenceOwn{};
+    std::size_t swapsVolumeDecides = 0U; ///< available: the evidence prefers the own row while its chi2 is the larger
+    std::size_t ownOtherTaken = 0U;      ///< the held-out row in the gate, an own row of an overlap or another leg taken
+    /// The lookahead against the greedy choice at the steps that looked ahead: of the
+    /// rows that passed (the production outcomes: free, within the gate),
+    /// the smallest chi2 against what the lookahead took, each the particle's own on
+    /// its leg or not: [greedy own][lookahead own].
+    std::array<std::array<std::size_t, 2>, 2> versusGreedy{};
+    /// The recomputed chi2 against production's, for its rows that passed
+    /// or were refused by the gate: |relative difference| < 1e-4 / 1e-3 /
+    /// 1e-2 / more; and the gate decided differently.
+    std::array<std::size_t, 5> chi2Agreement{};
+  };
+  /// \a particle's mother: none for a primary (kNoTrackParticle), nullopt
+  /// where it cannot be looked up (another source, an event or track beyond
+  /// the kinematics file).
+  [[nodiscard]] std::optional<std::uint64_t> motherOf(std::uint64_t particle) const
+  {
+    const auto label = workflow::labelOfParticle(particle);
+    const int track = label.getTrackID();
+    const int event = label.getEventID();
+    if (label.getSourceID() != 0 || event < 0 || static_cast<std::size_t>(event) >= mMothers.size()) {
+      return std::nullopt;
+    }
+    const auto& mothers = mMothers[static_cast<std::size_t>(event)];
+    if (track < 0 || static_cast<std::size_t>(track) >= mothers.size()) {
+      return std::nullopt;
+    }
+    if (mothers[static_cast<std::size_t>(track)] < 0) {
+      return study::kNoTrackParticle;
+    }
+    // The mother is of the same event and source.
+    return o2::MCCompLabel(mothers[static_cast<std::size_t>(track)], event, label.getSourceID()).getTrackEventSourceID();
+  }
+  /// A stranger's row against \a particle: every label of the row, the
+  /// closest relation of any (a row is unrelated only if all its labels are).
+  [[nodiscard]] Lineage lineageOf(std::uint64_t particle, std::uint32_t row) const
+  {
+    const auto& truth = mTruth->rows[row];
+    if (truth.count == 0U) {
+      return kLineNoise;
+    }
+    const auto mine = motherOf(particle);
+    auto best = kLineUnrelated;
+    for (std::uint8_t k = 0; k < truth.count; ++k) {
+      const auto other = truth.particles[k];
+      const auto theirs = motherOf(other);
+      Lineage line = kLineUnrelated;
+      if (!theirs || !mine) {
+        line = kLineUnknown;
+      } else if (*theirs == particle) {
+        const auto found = mTruth->particles.find(other);
+        const int process = found != mTruth->particles.end() ? static_cast<int>(found->second.process) : -1;
+        line = process == 9 ? kLineDelta : (process == 4 ? kLineDecay : kLineDaughterOther); // TMCProcess kPDeltaRay, kPDecay
+      } else if (const auto grand = *theirs != study::kNoTrackParticle ? motherOf(*theirs) : std::optional<std::uint64_t>{}; grand && *grand == particle) {
+        line = kLineGrandDaughter;
+      } else if (other == *mine) {
+        line = kLineMother;
+      } else if (*mine != study::kNoTrackParticle && *theirs == *mine) {
+        line = kLineSibling;
+      }
+      best = std::min(best, line);
+    }
+    return best;
+  }
+  /// \a layer's group for the clutter tables: TRKFT3's VD, ML or OT barrel
+  /// or its discs, else barrel or discs.
+  [[nodiscard]] static std::string layerGroupOf(LayerID layer, const IterationParameters<Det>& parameters)
+  {
+    const bool barrel = ((parameters.barrelLayers >> layer) & 1U) != 0U;
+    if constexpr (std::is_same_v<Det, detectors::TRKFT3>) {
+      // TRKFT3.h's barrel: the VD layers (kVDRadius), then the five middle
+      // (ML) and three outer (OT) layers.
+      constexpr std::size_t kVD = detectors::trkft3::kVDRadius.size();
+      return !barrel ? "discs" : (layer < kVD ? "VD" : (layer < kVD + 5U ? "ML" : "OT"));
+    } else {
+      return barrel ? "barrel" : "discs";
+    }
+  }
+  /// The positions of a particle's rows (`own`, in its path order) beyond
+  /// \a lastAt in the walk's direction: later along the path outward,
+  /// earlier inward.
+  [[nodiscard]] static std::vector<std::size_t> positionsBeyond(std::size_t lastAt, std::size_t size, PropagationDirection direction)
+  {
+    std::vector<std::size_t> out;
+    if (lastAt >= size) {
+      return out;
+    }
+    if (direction == PropagationDirection::kForward) {
+      for (std::size_t k = lastAt + 1U; k < size; ++k) {
+        out.push_back(k);
+      }
+    } else {
+      for (std::size_t k = lastAt; k-- > 0U;) {
+        out.push_back(k);
+      }
+    }
+    return out;
+  }
+  /// A followed road for `clutterStudy`: its walks, the outward one first as
+  /// the follow runs them (either may be absent), and its rows.
+  struct ClutterWalks {
+    const Walk* outward = nullptr;
+    const Walk* inward = nullptr;
+    ClusterList<kMaxClusters> road{};
+    std::uint8_t roadCount = 0U;
+    const char* population = "";
+  };
+  /// The dropped records' walks of the iteration being observed, kept by
+  /// `replayDropped` for `clutterStudy`.
+  struct DroppedWalks {
+    Walk outward;
+    Walk inward;
+    ClusterList<kMaxClusters> road{};
+    std::uint8_t roadCount = 0U;
+    bool walked = false;
+  };
+
+  /// Each layer's rows by their time boxes' ends, and its sensors' area
+  /// [cm2], for `layerDensity`; made once per timeframe.
+  void layerOccupancy(const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry)
+  {
+    if (!mLayerLower.empty()) {
+      return;
+    }
+    mLayerLower.assign(kLayers, {});
+    mLayerUpper.assign(kLayers, {});
+    mLayerArea.assign(kLayers, 0.);
+    const auto columns = frame.measurements();
+    std::vector<std::vector<std::pair<std::uint32_t, std::uint32_t>>> boxes(kLayers);
+    for (std::uint32_t row = 0; row < mTruth->rows.size(); ++row) {
+      const auto box = timeBoxAt(columns, row);
+      boxes[static_cast<std::size_t>(mTruth->rows[row].layer)].emplace_back(box.lower(), box.upper());
+    }
+    // By start, each with its end: the grid's test (`visitIfCompatible`).
+    for (std::size_t layer = 0; layer < kLayers; ++layer) {
+      std::ranges::sort(boxes[layer]);
+      for (const auto& [lower, upper] : boxes[layer]) {
+        mLayerLower[layer].push_back(lower);
+        mLayerUpper[layer].push_back(upper);
+      }
+    }
+    for (const auto& surface : geometry.surfaces()) {
+      if (static_cast<std::size_t>(surface.layer) < kLayers) {
+        mLayerArea[surface.layer] += 4. * static_cast<double>(surface.bounds.halfX) * static_cast<double>(surface.bounds.halfY);
+      }
+    }
+  }
+  /// \a layer's rows the grid would let through \a window's time test --
+  /// a start within [earliestPS, latestPS] and an end after afterPS
+  /// (`visitIfCompatible`) -- over the layer's
+  /// sensors' area [1/cm2].
+  [[nodiscard]] double layerDensity(LayerID layer, const CandidateWindow& window) const
+  {
+    const auto& lower = mLayerLower[layer];
+    const auto& upper = mLayerUpper[layer];
+    if (lower.empty() || !(mLayerArea[layer] > 0.)) {
+      return 0.;
+    }
+    const auto earliest = static_cast<std::uint32_t>(std::clamp<std::int64_t>(window.earliestPS, 0, std::numeric_limits<std::uint32_t>::max()));
+    const auto latest = static_cast<std::uint32_t>(std::clamp<std::int64_t>(window.latestPS, 0, std::numeric_limits<std::uint32_t>::max()));
+    const auto first = static_cast<std::size_t>(std::ranges::lower_bound(lower, earliest) - lower.begin());
+    const auto last = static_cast<std::size_t>(std::ranges::upper_bound(lower, latest) - lower.begin());
+    std::size_t compatible = 0U;
+    for (std::size_t k = first; k < last; ++k) {
+      compatible += upper[k] > window.afterPS ? 1U : 0U;
+    }
+    return static_cast<double>(compatible) / mLayerArea[layer];
+  }
+
+  /// The innovation of \a measurement against the prediction \a predicted
+  /// (its covariance filled), in double: V = H P H^T + R on the two local
+  /// coordinates, its determinant and r^T V^-1 r (NaN where the determinant
+  /// is not positive).
+  struct Innovation {
+    double chi2 = 0.;
+    double det = 0.;
+  };
+  template <typename Measurement>
+  [[nodiscard]] static Innovation innovation(const BoundTrackState& predicted, const Measurement& measurement)
+  {
+    const double v00 = static_cast<double>(predicted.variance(kLoc0)) + static_cast<double>(measurement.varLoc0);
+    const double v11 = static_cast<double>(predicted.variance(kLoc1)) + static_cast<double>(measurement.varLoc1);
+    const double v01 = static_cast<double>(predicted.covAt(kLoc0, kLoc1)) + static_cast<double>(measurement.covLoc01);
+    const double det = (v00 * v11) - (v01 * v01);
+    if (!(det > 0.)) {
+      return {.chi2 = std::numeric_limits<double>::quiet_NaN(), .det = det};
+    }
+    const double r0 = static_cast<double>(measurement.loc0) - static_cast<double>(predicted.loc0());
+    const double r1 = static_cast<double>(measurement.loc1) - static_cast<double>(predicted.loc1());
+    return {.chi2 = ((r0 * r0 * v11) - (2. * r0 * r1 * v01) + (r1 * r1 * v00)) / det, .det = det};
+  }
+
+  /// The area [cm2] of \a window on \a layer: the phi half width (at most
+  /// pi) at the barrel layer's radius or the window's second centre, times
+  /// the second coordinate's full width.
+  [[nodiscard]] static double windowArea(const IterationParameters<Det>& parameters, LayerID layer, const CandidateWindow& window)
+  {
+    const bool barrel = ((parameters.barrelLayers >> layer) & 1U) != 0U;
+    const double radius = barrel ? static_cast<double>(parameters.layerSpans[layer].position) : static_cast<double>(window.secondCentre);
+    return 4. * std::min(static_cast<double>(window.phiHalfWidth), std::numbers::pi) * radius * static_cast<double>(window.secondHalfWidth);
+  }
+
+  /// The clutter test: the follow's steps from
+  /// a clean core, every time-compatible row in each target's window
+  /// refitted from the step's state; the strangers within the gate against
+  /// a uniform-density expectation, the held-out own row, the swaps -- per
+  /// population, iteration, pT, walk and layers (`printClutter`).
+  template <typename Observation, typename Material>
+  void clutterStudy(const Observation& iteration, const std::vector<Replay>& replayed, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    const auto gate = static_cast<double>(parameters.clusterChi2Max);
+    auto edges = kClutterEdges;
+    edges.back() = gate;
+    layerOccupancy(frame, geometry);
+    std::vector<ClutterWalks> walks;
+    walks.reserve(replayed.size() + mDroppedWalks.size());
+    for (const auto& replay : replayed) {
+      walks.push_back({
+        .outward = replay.outward.empty() ? nullptr : &replay.outward.front(),
+        .inward = &replay,
+        .road = replay.road,
+        .roadCount = replay.roadCount,
+        .population = "kept",
+      });
+    }
+    for (const auto& dropped : mDroppedWalks) {
+      if (dropped.walked) {
+        walks.push_back({.outward = &dropped.outward, .inward = &dropped.inward, .road = dropped.road, .roadCount = dropped.roadCount, .population = "dropped"});
+      }
+    }
+    std::mutex merge;
+    o2::gtrk::detail::parallelFor(*mArena, 0U, walks.size(), 64, [&](std::size_t a, std::size_t b) {
+      std::map<std::string, ClutterTally> local;
+      for (std::size_t element = a; element < b; ++element) {
+        const auto& followed = walks[element];
+        if (followed.roadCount == 0U) {
+          continue;
+        }
+        const std::span<const std::uint32_t> road{followed.road.index, followed.roadCount};
+        if (mTruth->rows[road[0]].count == 0U) {
+          continue;
+        }
+        const auto particle = mTruth->rows[road[0]].particles[0];
+        if (!std::ranges::all_of(road, [&](std::uint32_t row) { return mTruth->rows[row].carries(particle); })) {
+          continue;
+        }
+        const auto index = mIndex.find(particle);
+        if (index == mIndex.end()) {
+          continue; // the class's particles: their rows by leg
+        }
+        const auto& own = mRowsOf.at(particle);
+        const bool timed = !mLegs.empty() && mTimed[index->second] != 0U;
+        const auto positionOf = [&](std::uint32_t row) -> std::size_t { return static_cast<std::size_t>(std::ranges::find(own, row) - own.begin()); };
+        const auto legAt = [&](std::size_t k) -> int { return !timed || k >= own.size() ? -1 : static_cast<int>(mLegs[index->second][k]); };
+        const auto legOf = [&](std::uint32_t row) -> int { return legAt(positionOf(row)); };
+        const std::string ptName = kPathPtNames[pathPtBin(particle)];
+        bool clean = true;
+        std::uint32_t last = road.back();
+        std::size_t core = road.size();
+        const auto walkOf = [&](const Walk& walk, PropagationDirection direction) {
+          last = direction == PropagationDirection::kForward ? road.back() : road.front();
+          for (const auto& step : walk.steps) {
+            if (!clean) {
+              return;
+            }
+            const int coreLeg = legOf(last);
+            const std::size_t lastAt = positionOf(last);
+            for (const auto& target : step.targets) {
+              auto& tally = local[std::format("{} | {} | {} | {} | {} | core {}", followed.population, iteration.iteration, ptName, direction == PropagationDirection::kForward ? "outward" : "inward", layerGroupOf(target.layer, parameters), std::min<std::size_t>(core, 9U))];
+              ++tally.targets;
+              const double boxArea = windowArea(parameters, target.layer, target.window);
+              struct Seen {
+                std::uint32_t row;
+                double chi2;
+                double sqrtDet;
+                StepOutcome outcome;
+              };
+              std::vector<Seen> inBox;
+              for (const auto& candidate : step.candidates) {
+                if (candidate.layer != target.layer) {
+                  continue;
+                }
+                const auto measurement = frame.measurement(candidate.row);
+                if (!spatiallyCompatible(target.window, measurement.phi, secondCoordinate<Det>(target.layer, measurement.r, measurement.z))) {
+                  continue;
+                }
+                const auto at = measurementAt(frame, candidate.row);
+                BoundTrackState predicted;
+                CovarianceFactors factors;
+                if (!follow::transportCandidate<false>(propagator, geometry, material, geometry.planeOf(at), direction, step.state, step.factors, predicted, factors, 1.F)) {
+                  continue;
+                }
+                covarianceFromFactors(factors, predicted.cov);
+                const auto [chi2, det] = innovation(predicted, at);
+                if (!(det > 0.)) {
+                  continue;
+                }
+                inBox.push_back({.row = candidate.row, .chi2 = chi2, .sqrtDet = std::sqrt(det), .outcome = candidate.outcome});
+                if (candidate.outcome == StepOutcome::kPasses || candidate.outcome == StepOutcome::kChi2) {
+                  const auto production = static_cast<double>(candidate.chi2);
+                  const double relative = std::abs(chi2 - production) / std::max(production, 1e-6);
+                  ++tally.chi2Agreement[relative < 1e-4 ? 0U : (relative < 1e-3 ? 1U : (relative < 1e-2 ? 2U : 3U))];
+                  tally.chi2Agreement[4] += (chi2 <= gate) != (candidate.outcome == StepOutcome::kPasses) ? 1U : 0U;
+                }
+              }
+              // The held-out own row: the particle's on this layer and the
+              // core's leg, the nearest to the prediction if there are two.
+              std::uint32_t heldOut = kNoRow;
+              double heldChi2 = std::numeric_limits<double>::infinity();
+              for (const auto& one : inBox) {
+                if (mTruth->rows[one.row].carries(particle) && legOf(one.row) == coreLeg && one.chi2 < heldChi2) {
+                  heldOut = one.row;
+                  heldChi2 = one.chi2;
+                }
+              }
+              const auto lineage = [&](std::uint32_t row) {
+                if (row == heldOut) {
+                  return kLineOwnHeldOut;
+                }
+                if (mTruth->rows[row].carries(particle)) {
+                  return legOf(row) == coreLeg ? kLineOwnOverlap : kLineOwnOtherLeg;
+                }
+                return lineageOf(particle, row);
+              };
+              const bool tookHere = step.choice != kNoRow && mTruth->rows[step.choice].layer == target.layer;
+              if (inBox.empty()) {
+                ++tally.empty;
+              }
+              if (heldOut == kNoRow) {
+                // Why: the particle's rows on this layer and beyond the core's
+                // last, by leg, in its path order.
+                bool sameLegHere = false;
+                bool otherLegHere = false;
+                bool sameLegBeyond = false;
+                bool laterLegs = false;
+                const auto beyond = positionsBeyond(lastAt, own.size(), direction);
+                for (const auto k : beyond) {
+                  const bool here = mTruth->rows[own[k]].layer == target.layer;
+                  const bool sameLeg = legAt(k) == coreLeg;
+                  sameLegHere = sameLegHere || (here && sameLeg);
+                  otherLegHere = otherLegHere || (here && !sameLeg);
+                  sameLegBeyond = sameLegBeyond || sameLeg;
+                  laterLegs = laterLegs || !sameLeg;
+                }
+                const NoOwn why = sameLegHere ? kNoOwnOutside : (sameLegBeyond ? kNoOwnGap : (otherLegHere ? kNoOwnOtherLeg : (laterLegs ? kNoOwnTurned : kNoOwnEnded)));
+                auto& counts = tally.noOwn[why];
+                ++counts[0];
+                if (why == kNoOwnOutside) {
+                  std::uint32_t mine = kNoRow;
+                  for (const auto k : beyond) {
+                    if (mTruth->rows[own[k]].layer == target.layer && legAt(k) == coreLeg) {
+                      mine = own[k];
+                      break;
+                    }
+                  }
+                  const auto visited = std::ranges::find(step.candidates, mine, &Candidate::row);
+                  std::size_t miss = 0U;
+                  if (visited != step.candidates.end()) {
+                    const auto measurement = frame.measurement(mine);
+                    miss = spatiallyCompatible(target.window, measurement.phi, secondCoordinate<Det>(target.layer, measurement.r, measurement.z)) ? 2U : 1U;
+                  }
+                  ++tally.outsideWhy[miss];
+                }
+                if (tookHere) {
+                  counts[1] += mTruth->rows[step.choice].carries(particle) ? 0U : 1U;
+                  counts[2] += mTruth->rows[step.choice].carries(particle) ? 1U : 0U;
+                }
+              }
+              if (inBox.empty()) {
+                continue;
+              }
+              double sqrtDet = 0.;
+              for (const auto& one : inBox) {
+                sqrtDet += one.sqrtDet;
+              }
+              sqrtDet /= static_cast<double>(inBox.size());
+              const double ellipse = std::numbers::pi * gate * sqrtDet;
+              if (boxArea > 1.25 * ellipse) {
+                // The measured targets: the strangers seen and expected on the same ones.
+                ++tally.measured;
+                tally.sqrtDetV += sqrtDet;
+                std::size_t outside = 0U;
+                bool stranger = false;
+                for (const auto& one : inBox) {
+                  const auto line = lineage(one.row);
+                  const bool ownRow = line <= kLineOwnOtherLeg;
+                  if (one.chi2 > gate) {
+                    outside += ownRow ? 0U : 1U;
+                    continue;
+                  }
+                  stranger = stranger || !ownRow;
+                  for (std::size_t e = 0; e < edges.size(); ++e) {
+                    tally.seen[line][e] += one.chi2 <= edges[e] ? 1U : 0U;
+                  }
+                }
+                const double rho = static_cast<double>(outside) / (boxArea - ellipse);
+                for (std::size_t e = 0; e < edges.size(); ++e) {
+                  tally.expected[e] += rho * std::numbers::pi * edges[e] * sqrtDet;
+                }
+                tally.expectedLayer += layerDensity(target.layer, target.window) * ellipse;
+                tally.anyStrangerInGate += stranger ? 1U : 0U;
+                tally.anyPredicted += 1. - std::exp(-rho * ellipse);
+                if (heldOut != kNoRow) {
+                  ++tally.ownInBox;
+                  for (std::size_t e = 0; e < edges.size(); ++e) {
+                    tally.ownSeen[e] += heldChi2 <= edges[e] ? 1U : 0U;
+                  }
+                }
+              }
+              const auto takenSeen = std::ranges::find(inBox, step.choice, &Seen::row);
+              const auto ownSeen = std::ranges::find(inBox, heldOut, &Seen::row);
+              if (heldOut != kNoRow && heldChi2 <= gate && tookHere && step.choice != heldOut && takenSeen != inBox.end()) {
+                if (mTruth->rows[step.choice].carries(particle)) {
+                  ++tally.ownOtherTaken;
+                } else {
+                  const std::size_t how = step.kink ? 2U : (step.lookahead ? 1U : 0U);
+                  const bool available = ownSeen->outcome == StepOutcome::kPasses;
+                  ++tally.swaps[available ? 1U : 0U][how];
+                  if (available) {
+                    tally.swapsTakenLower[how] += takenSeen->chi2 < ownSeen->chi2 ? 1U : 0U;
+                    const double evidenceOwn = (-0.5 * ownSeen->chi2) - std::log(ownSeen->sqrtDet);
+                    const double evidenceTaken = (-0.5 * takenSeen->chi2) - std::log(takenSeen->sqrtDet);
+                    tally.swapsEvidenceOwn[how] += evidenceOwn > evidenceTaken ? 1U : 0U;
+                    tally.swapsVolumeDecides += evidenceOwn > evidenceTaken && ownSeen->chi2 > takenSeen->chi2 ? 1U : 0U;
+                  }
+                }
+              }
+              if (step.lookahead && tookHere) {
+                std::uint32_t greedy = kNoRow;
+                Scalar best = std::numeric_limits<Scalar>::infinity();
+                for (const auto& candidate : step.candidates) {
+                  if (candidate.layer == target.layer && candidate.outcome == StepOutcome::kPasses && (candidate.chi2 < best || (!(candidate.chi2 > best) && candidate.row < greedy))) {
+                    best = candidate.chi2;
+                    greedy = candidate.row;
+                  }
+                }
+                const auto ownOnLeg = [&](std::uint32_t row) { return mTruth->rows[row].carries(particle) && legOf(row) == coreLeg ? 1U : 0U; };
+                if (greedy != kNoRow) {
+                  ++tally.versusGreedy[ownOnLeg(greedy)][ownOnLeg(step.choice)];
+                }
+              }
+            }
+            if (step.choice != kNoRow) {
+              clean = mTruth->rows[step.choice].carries(particle);
+              last = step.choice;
+              ++core;
+            }
+          }
+        };
+        if (followed.outward != nullptr) {
+          walkOf(*followed.outward, PropagationDirection::kForward);
+        }
+        if (followed.inward != nullptr) {
+          walkOf(*followed.inward, PropagationDirection::kBackward);
+        }
+      }
+      const std::scoped_lock lock(merge);
+      for (const auto& [key, one] : local) {
+        auto& sum = mClutter[key];
+        sum.targets += one.targets;
+        sum.empty += one.empty;
+        sum.measured += one.measured;
+        sum.ownInBox += one.ownInBox;
+        sum.anyStrangerInGate += one.anyStrangerInGate;
+        sum.anyPredicted += one.anyPredicted;
+        sum.sqrtDetV += one.sqrtDetV;
+        sum.expectedLayer += one.expectedLayer;
+        for (std::size_t w = 0; w < 3U; ++w) {
+          sum.outsideWhy[w] += one.outsideWhy[w];
+        }
+        for (std::size_t e = 0; e < edges.size(); ++e) {
+          sum.expected[e] += one.expected[e];
+          sum.ownSeen[e] += one.ownSeen[e];
+          for (std::size_t l = 0; l < kLineages; ++l) {
+            sum.seen[l][e] += one.seen[l][e];
+          }
+        }
+        for (std::size_t r = 0; r < kNoOwnReasons; ++r) {
+          for (std::size_t c = 0; c < 3U; ++c) {
+            sum.noOwn[r][c] += one.noOwn[r][c];
+          }
+        }
+        for (std::size_t h = 0; h < 3U; ++h) {
+          sum.swaps[0][h] += one.swaps[0][h];
+          sum.swaps[1][h] += one.swaps[1][h];
+          sum.swapsTakenLower[h] += one.swapsTakenLower[h];
+          sum.swapsEvidenceOwn[h] += one.swapsEvidenceOwn[h];
+        }
+        sum.swapsVolumeDecides += one.swapsVolumeDecides;
+        sum.ownOtherTaken += one.ownOtherTaken;
+        for (std::size_t g = 0; g < 2U; ++g) {
+          for (std::size_t r = 0; r < 2U; ++r) {
+            sum.versusGreedy[g][r] += one.versusGreedy[g][r];
+          }
+        }
+        for (std::size_t c = 0; c < sum.chi2Agreement.size(); ++c) {
+          sum.chi2Agreement[c] += one.chi2Agreement[c];
+        }
+      }
+    });
+  }
+
+  /// `clutterStudy`'s tables.
+  void printClutter() const
+  {
+    if (mClutter.empty()) {
+      return;
+    }
+    std::string text = std::format(
+      "  the clutter test: the follow's steps from a clean core, every time-compatible row in each target's window refitted "
+      "from the step's state; per population (the iteration's kept tracks, its dropped records) | iteration | pT | walk | layers:\n"
+      "    targets (empty, measured: room for rho beyond the gate) | on the measured: mean sqrt|V| [cm2] | the held-out own row in the window | "
+      "strangers within chi2 <= 1 / 2 / 4 / 8 / gate, every non-own row (the unrelated among them) against the uniform expectation rho pi t sqrt|V| (rho "
+      "from the window's non-own rows beyond the gate), and within the gate from the layer's mean density | targets with a stranger in the gate: seen / "
+      "Poisson | the held-out row's chi2 <= 1 / 2 / 4 / 8 / "
+      "gate as a fraction (chi2(2): {:.3f} / {:.3f} / {:.3f} / {:.3f} / gate) | the other lineages within the gate",
+      1. - std::exp(-0.5), 1. - std::exp(-1.), 1. - std::exp(-2.), 1. - std::exp(-4.));
+    for (const auto& [key, t] : mClutter) {
+      text += std::format("\n    {}: {} ({}, {}) | {:.4f} | {} |", key, t.targets, t.empty, t.measured, t.measured != 0U ? t.sqrtDetV / static_cast<double>(t.measured) : 0., t.ownInBox);
+      for (std::size_t e = 0; e < kClutterEdges.size(); ++e) {
+        std::size_t strangers = 0U;
+        for (std::size_t l = kLineNoise; l < kLineages; ++l) {
+          strangers += t.seen[l][e];
+        }
+        text += std::format(" {} ({}) / {:.1f}{}", strangers, t.seen[kLineUnrelated][e], t.expected[e], e + 1U < kClutterEdges.size() ? ";" : " |");
+      }
+      text += std::format(" layer {:.1f} | {} / {:.1f} |", t.expectedLayer, t.anyStrangerInGate, t.anyPredicted);
+      for (std::size_t e = 0; e < kClutterEdges.size(); ++e) {
+        text += std::format(" {:.3f}", t.ownInBox != 0U ? static_cast<double>(t.ownSeen[e]) / static_cast<double>(t.ownInBox) : 0.);
+      }
+      text += " |";
+      for (std::size_t l = kLineOwnOverlap; l < kLineUnrelated; ++l) {
+        text += t.seen[l].back() != 0U ? std::format(" {} {};", kLineageNames[l], t.seen[l].back()) : std::string{};
+      }
+    }
+    text +=
+      "\n    the same keys: the targets without the held-out own row, by why: targets / a stranger taken / an own row of another leg taken | the swaps "
+      "(the held-out row in the gate, a stranger taken), the own row not available to the step (held, refused) plain / lookahead / kink, and "
+      "available: plain / lookahead / kink, each (the stranger's chi2 the lower, the one-step evidence -chi2/2 - log sqrt|V| preferring the own "
+      "row); the own preferred while its chi2 is the larger | an own row of an overlap or another leg taken instead | the lookahead against the greedy "
+      "smallest chi2 among the passing rows: both own / greedy own, lookahead not (it costs) / greedy not, lookahead own (it saves) / neither | the "
+      "recomputed chi2 against production's: |relative difference| < 1e-4 / 1e-3 / 1e-2 / more, the gate decided otherwise";
+    for (const auto& [key, t] : mClutter) {
+      text += std::format("\n    {}:", key);
+      for (std::size_t r = 0; r < kNoOwnReasons; ++r) {
+        text += t.noOwn[r][0] != 0U ? std::format(" {} {} / {} / {};", kNoOwnNames[r], t.noOwn[r][0], t.noOwn[r][1], t.noOwn[r][2]) : std::string{};
+      }
+      text += std::format(" (seen not: not visited {}, outside the box {}, transport {})", t.outsideWhy[0], t.outsideWhy[1], t.outsideWhy[2]);
+      text += std::format(" | not available {} / {} / {}; available", t.swaps[0][0], t.swaps[0][1], t.swaps[0][2]);
+      for (std::size_t h = 0; h < 3U; ++h) {
+        text += std::format(" {} ({}, {}){}", t.swaps[1][h], t.swapsTakenLower[h], t.swapsEvidenceOwn[h], h < 2U ? " /" : ";");
+      }
+      text += std::format(" {} | {} | {} / {} / {} / {} | {} / {} / {} / {}, {}", t.swapsVolumeDecides, t.ownOtherTaken, t.versusGreedy[1][1], t.versusGreedy[1][0], t.versusGreedy[0][1], t.versusGreedy[0][0], t.chi2Agreement[0], t.chi2Agreement[1], t.chi2Agreement[2], t.chi2Agreement[3], t.chi2Agreement[4]);
+    }
+    std::cout << text << '\n';
+  }
+
+  /// The first wrong rows' alternatives on the follow: at the first
+  /// wrong row of each followed road whose road is one particle's -- the
+  /// iteration's dropped records, and its kept tracks with one wrong row --
+  /// the three alternatives of that step: the row taken (T), the
+  /// particle's own row on that layer and leg (O), and stopping there (D,
+  /// the prefix). For T and O, from the step's state: the chi2, `|V|`, the
+  /// window's and the layer's clutter density, and the one-step evidence
+  /// against stopping, log(g / rho) + log(p / (1 - p)), with p the chance of
+  /// reaching a live sensor of the layer, sampled from the state's
+  /// covariance. Each alternative's chain refitted as `follow::Refit`, and the
+  /// two particles' fates; each chain's evidence (the innovations, the seed prior's determinant, flat in the
+  /// diffuse limit), with the seed's covariance as made and 10 and 100 times
+  /// wider: whether the alternatives' order holds; and the prefix's evidence
+  /// fitted alone against the same rows' running sum inside the longer chain.
+  enum Decision : std::uint8_t { kDecideTaken,
+                                 kDecideOwn,
+                                 kDecideStop,
+                                 kDecisions };
+  static constexpr std::array<const char*, kDecisions> kDecisionNames{"taken", "own", "stop"};
+  enum OwnThere : std::uint8_t { kOwnAvailable,
+                                 kOwnHeld,
+                                 kOwnRefused,
+                                 kOwnNotSeen,
+                                 kOwnNone,
+                                 kOwnTheres };
+  static constexpr std::array<const char*, kOwnTheres> kOwnThereNames{"passing", "held by a track", "refused (gate, update)", "not in the window", "none on the layer and leg"};
+  struct DecisionTally {
+    std::size_t events = 0U;
+    std::array<std::size_t, kOwnTheres> own{};
+    std::array<std::size_t, kLineages> taken{};
+    /// The one-step evidence's choice among T, O (where seen) and stopping:
+    /// with the window's rho, with the layer's.
+    std::array<std::size_t, kDecisions> stepLocal{};
+    std::array<std::size_t, kDecisions> stepLayer{};
+    std::array<std::size_t, 4> reach{}; ///< p < 0.25 / < 0.5 / < 0.9 / >= 0.9
+    double reachSum = 0.;
+    /// The refits: T accepted, O accepted (where there is one), the prefix
+    /// accepted and as long as the length cut; refused or failed counted apart.
+    std::size_t refitTaken = 0U;
+    std::size_t refitOwn = 0U;
+    std::size_t ownChains = 0U;
+    std::size_t refitPrefix = 0U;
+    std::size_t prefixLong = 0U;
+    /// The particles at the iteration's end: the road's found (by any track),
+    /// the taken row's found; the taken row's being a class particle.
+    std::size_t particleFound = 0U;
+    std::size_t strangerFound = 0U;
+    std::size_t strangerParticles = 0U;
+    /// The chains' evidence (S, the clutter of the last row
+    /// and the reach included): the choice with the seed's covariance as
+    /// made, the same choice at 10 and 100 times; it against the one-step
+    /// choice; the prefix alone against its running sum (|difference| < 0.1
+    /// / < 1 / more).
+    std::array<std::size_t, kDecisions> chainChoice{};
+    std::array<std::size_t, 2> chainStable{};
+    std::size_t chainAgreesStep = 0U;
+    std::size_t chains = 0U;
+    std::array<std::size_t, 3> prefixInherited{};
+  };
+
+  /// The evidence of \a rows: the outward filter
+  /// from the chain's seed (`makeChainSeed`), its covariance times \a scale,
+  /// each step's innovation density (-chi2/2 - log sqrt|V| - log 2 pi), plus
+  /// half the seed's log-determinant and 5/2 log 2 pi; no kinks. \a running,
+  /// where given, gets the sum after each row (without the seed's terms).
+  /// NaN where a step fails.
+  template <typename Material>
+  [[nodiscard]] double chainEvidence(const std::vector<std::uint32_t>& rows, double scale, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator, std::vector<double>* running = nullptr) const
+  {
+    const auto nan = std::numeric_limits<double>::quiet_NaN();
+    const int n = static_cast<int>(rows.size());
+    if (n < 3) {
+      return nan;
+    }
+    const RowChain<Det> chain{.frame = &frame, .rows = rows.data()};
+    BoundTrackState state = makeChainSeed(propagator, geometry, chain, n).state;
+    for (auto& value : state.cov) {
+      value = static_cast<Scalar>(static_cast<double>(value) * scale);
+    }
+    // log|P0| by Cholesky, in double.
+    std::array<double, static_cast<std::size_t>(kNBoundParams) * kNBoundParams> l{}; // NOLINT(misc-const-correctness): written through at(), which the check does not follow
+    const auto at = [](int row, int column) { return (static_cast<std::size_t>(row) * kNBoundParams) + static_cast<std::size_t>(column); };
+    double logDet = 0.;
+    for (int i = 0; i < kNBoundParams; ++i) {
+      for (int j = 0; j <= i; ++j) {
+        auto sum = static_cast<double>(state.cov[covIndex(i, j)]);
+        for (int k = 0; k < j; ++k) {
+          sum -= l[at(i, k)] * l[at(j, k)];
+        }
+        if (i == j) {
+          if (!(sum > 0.)) {
+            return nan;
+          }
+          l[at(i, i)] = std::sqrt(sum);
+          logDet += std::log(sum);
+        } else {
+          l[at(i, j)] = sum / l[at(j, j)];
+        }
+      }
+    }
+    auto factors = factorCovariance(state.cov);
+    double evidence = 0.;
+    const double log2pi = std::log(2. * std::numbers::pi);
+    for (int k = 0; k < n; ++k) {
+      const auto measurement = chain[k];
+      if (k > 0) {
+        BoundTrackState next;
+        CovarianceFactors nextFactors;
+        if (!follow::transportCandidate<false>(propagator, geometry, material, geometry.planeOf(measurement), PropagationDirection::kForward, state, factors, next, nextFactors, 1.F)) {
+          return nan;
+        }
+        state = next;
+        factors = nextFactors;
+      }
+      BoundTrackState predicted = state;
+      covarianceFromFactors(factors, predicted.cov);
+      const auto [chi2, det] = innovation(predicted, measurement);
+      if (!(det > 0.)) {
+        return nan;
+      }
+      evidence += (-0.5 * chi2) - (0.5 * std::log(det)) - log2pi;
+      const auto update = updateWithMeasurement(state, factors, measurement);
+      if (!updateUsable(update, factors)) {
+        return nan;
+      }
+      if (running != nullptr) {
+        running->push_back(evidence);
+      }
+    }
+    return evidence + (0.5 * logDet) + (2.5 * log2pi);
+  }
+
+  /// The chance that \a state, with the covariance \a factors, crosses a
+  /// live sensor of \a layer in \a direction: \a samples draws of the state,
+  /// each carried to the sensors listed within \a window about its centre
+  /// (as `FollowStage::crossesSensor`); clipped away from 0 and 1 by half a
+  /// draw.
+  [[nodiscard]] double reachChance(const IterationParameters<Det>& parameters, const BoundTrackState& state, const CovarianceFactors& factors, LayerID layer, const CandidateWindow& window, PropagationDirection direction, const TrackingGeometry<Det>& geometry, const Propagator& propagator, std::uint32_t seed, int samples = 64) const
+  {
+    BoundTrackState mean = state;
+    covarianceFromFactors(factors, mean.cov);
+    std::array<double, static_cast<std::size_t>(kNBoundParams) * kNBoundParams> l{}; // NOLINT(misc-const-correctness): written through at(), which the check does not follow
+    const auto at = [](int row, int column) { return (static_cast<std::size_t>(row) * kNBoundParams) + static_cast<std::size_t>(column); };
+    for (int i = 0; i < kNBoundParams; ++i) {
+      for (int j = 0; j <= i; ++j) {
+        auto sum = static_cast<double>(mean.cov[covIndex(i, j)]);
+        for (int k = 0; k < j; ++k) {
+          sum -= l[at(i, k)] * l[at(j, k)];
+        }
+        if (i == j) {
+          l[at(i, i)] = sum > 0. ? std::sqrt(sum) : 0.;
+        } else {
+          const double d = l[at(j, j)];
+          l[at(i, j)] = d > 0. ? sum / d : 0.;
+        }
+      }
+    }
+    Scalar crossing[3]{};
+    follow::crossingPoint(parameters, layer, {.phi = window.phiCentre, .second = window.secondCentre}, crossing);
+    const auto& from = geometry.planeOf(state);
+    std::mt19937 rng(seed);
+    std::normal_distribution<double> gauss(0., 1.);
+    int crossed = 0;
+    for (int s = 0; s < samples; ++s) {
+      std::array<double, kNBoundParams> normal{};
+      for (auto& x : normal) {
+        x = gauss(rng);
+      }
+      BoundTrackState sample = state;
+      for (int i = 0; i < kNBoundParams; ++i) {
+        double shift = 0.;
+        for (int k = 0; k <= i; ++k) {
+          shift += l[at(i, k)] * normal[static_cast<std::size_t>(k)];
+        }
+        sample.par[i] = static_cast<Scalar>(static_cast<double>(state.par[i]) + shift);
+      }
+      const auto phiReach = window.phiHalfWidth;
+      const auto secondReach = window.secondHalfWidth;
+      const bool hit = mCells.view().anySensor(layer, window.phiCentre, phiReach, window.secondCentre, secondReach, [&](std::uint32_t id) {
+        const TrackingSurface& surface = geometry.surface(static_cast<SensorID>(id));
+        TrackingSurface plane = surface;
+        if (surface.radius > 0.F) {
+          // The tangent plane at the stage's nominal layer crossing.
+          Scalar along0 = 0.F;
+          Scalar along1 = 0.F;
+          for (int i = 0; i < 3; ++i) {
+            along0 += (crossing[i] - surface.origin[i]) * surface.axis0[i];
+            along1 += (crossing[i] - surface.origin[i]) * surface.axis1[i];
+          }
+          plane = tangentPlane(surface, o2::gpu::CAMath::ATan2(along1, along0));
+        }
+        BoundTrackState at = sample;
+        const auto result = propagate(propagator, at, from, plane, direction);
+        // The half-turn veto at the sample's own curvature.
+        const ExactScalar curvature = propagator.curvature(static_cast<ExactScalar>(sample.qOverP()), 1.);
+        return result.status == PropagationStatus::kOk && !follow::beyondHalfTurn(curvature * static_cast<ExactScalar>(result.pathLength));
+      });
+      crossed += hit ? 1 : 0;
+    }
+    const double half = 0.5 / static_cast<double>(samples);
+    return std::clamp(static_cast<double>(crossed) / static_cast<double>(samples), half, 1. - half);
+  }
+
+  /// \a row's update from \a state (its \a factors) as one step of the
+  /// follow makes it, carried to the row's own sensor (`transportCandidate`,
+  /// nominal scattering): the chi2 and sqrt|V|, V = H P H^T + R the
+  /// residual's predicted covariance. With
+  /// \a beamLine the prediction is first updated with the beam line
+  /// (`updateWithBeamLine`, the scattering inside the row's layer): the row
+  /// against the beam line as the walk's reference. Without
+  /// it also |V| as the follow's EndDensity has it, the product of the
+  /// update's float innovations, and from the carried factors in double
+  /// (the variant's quantity against its oracle).
+  struct OneStep {
+    bool valid = false;
+    double chi2 = 0.;
+    double sqrtDet = 0.;
+    double floatDet = -1.;
+    double factorDet = -1.;
+  };
+  /// The window's clutter beyond the nominal gate; callers choose which
+  /// rows to exclude and the value for an area too small to measure it.
+  template <typename Material, typename Skip>
+  [[nodiscard]] double windowRho(const IterationParameters<Det>& parameters, const Step& step, LayerID layer, const CandidateWindow& window, double gate, double sqrtDet, PropagationDirection direction, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator, const Skip& skip, double missing) const
+  {
+    const double boxArea = windowArea(parameters, layer, window);
+    std::size_t outside = 0U;
+    for (const auto& candidate : step.candidates) {
+      if (candidate.layer != layer || skip(candidate.row)) {
+        continue;
+      }
+      const auto one = oneStep(candidate.row, step.state, step.factors, direction, frame, geometry, material, propagator);
+      const auto measurement = frame.measurement(candidate.row);
+      outside += one.valid && one.chi2 > gate && spatiallyCompatible(window, measurement.phi, secondCoordinate<Det>(layer, measurement.r, measurement.z)) ? 1U : 0U;
+    }
+    const double ellipse = std::numbers::pi * gate * sqrtDet;
+    return boxArea > 1.25 * ellipse ? std::max(static_cast<double>(outside), 0.5) / (boxArea - ellipse) : missing;
+  }
+
+  template <typename Material>
+  [[nodiscard]] OneStep oneStep(std::uint32_t row, const BoundTrackState& state, const CovarianceFactors& factors, PropagationDirection direction, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator, const IterationParameters<Det>* beamLine = nullptr) const
+  {
+    const auto measurement = measurementAt(frame, row);
+    BoundTrackState predicted;
+    CovarianceFactors carried;
+    if (!follow::transportCandidate<false>(propagator, geometry, material, geometry.planeOf(measurement), direction, state, factors, predicted, carried, 1.F)) {
+      return {};
+    }
+    double floatDet = -1.;
+    double factorDet = -1.;
+    if (beamLine == nullptr) {
+      BoundTrackState updated = predicted;
+      CovarianceFactors updatedFactors = carried;
+      Scalar determinant = 0.F;
+      static_cast<void>(updateWithMeasurement<true>(updated, updatedFactors, measurement, &determinant));
+      floatDet = static_cast<double>(determinant);
+      const auto covariance = [&](int i, int j) {
+        double sum = 0.;
+        for (int k = std::max(i, j); k < kNBoundParams; ++k) {
+          const double ui = k == i ? 1. : static_cast<double>(carried.upper[o2::gtrk::detail::strictUpperIndex(i, k)]);
+          const double uj = k == j ? 1. : static_cast<double>(carried.upper[o2::gtrk::detail::strictUpperIndex(j, k)]);
+          sum += ui * static_cast<double>(carried.diagonal[k]) * uj;
+        }
+        return sum;
+      };
+      const double w00 = covariance(kLoc0, kLoc0) + static_cast<double>(measurement.varLoc0);
+      const double w11 = covariance(kLoc1, kLoc1) + static_cast<double>(measurement.varLoc1);
+      const double w01 = covariance(kLoc0, kLoc1) + static_cast<double>(measurement.covLoc01);
+      factorDet = (w00 * w11) - (w01 * w01);
+    }
+    covarianceFromFactors(carried, predicted.cov);
+    if (beamLine != nullptr && !updateWithBeamLine(propagator, *beamLine, geometry.planeOf(measurement), mTruth->rows[row].layer, pairPointAt(frame.measurements(), row), predicted).ok) {
+      return {};
+    }
+    const auto [chi2, det] = innovation(predicted, measurement);
+    if (!(det > 0.)) {
+      return {};
+    }
+    return {.valid = true, .chi2 = chi2, .sqrtDet = std::sqrt(det), .floatDet = floatDet, .factorDet = factorDet};
+  }
+
+  template <typename Observation, typename Material>
+  void decisionStudy(const Observation& iteration, const std::vector<Replay>& replayed, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator, const std::unordered_map<std::uint64_t, std::uint32_t>& goodTrack)
+  {
+    const auto gate = static_cast<double>(parameters.clusterChi2Max);
+    const auto view = iteration.tracks->view();
+    std::vector<ClutterWalks> walks;
+    for (std::size_t element = 0; element < replayed.size(); ++element) {
+      // The kept tracks with one wrong row, their road one particle's.
+      const auto track = iteration.trackOffset + static_cast<std::uint32_t>(element);
+      const auto& replay = replayed[element];
+      if (replay.roadCount == 0U || track >= iteration.tracks->size() || mTruth->rows[replay.road.index[0]].count == 0U) {
+        continue;
+      }
+      const auto particle = mTruth->rows[replay.road.index[0]].particles[0];
+      std::size_t wrong = 0U;
+      for (std::uint8_t i = 0; i < view.count[track]; ++i) {
+        wrong += mTruth->rows[view.clusters[track].index[i]].carries(particle) ? 0U : 1U;
+      }
+      if (wrong == 1U) {
+        walks.push_back({
+          .outward = replay.outward.empty() ? nullptr : &replay.outward.front(),
+          .inward = &replay,
+          .road = replay.road,
+          .roadCount = replay.roadCount,
+          .population = "kept, one wrong row",
+        });
+      }
+    }
+    for (const auto& dropped : mDroppedWalks) {
+      if (dropped.walked) {
+        walks.push_back({.outward = &dropped.outward, .inward = &dropped.inward, .road = dropped.road, .roadCount = dropped.roadCount, .population = "dropped"});
+      }
+    }
+    std::mutex merge;
+    o2::gtrk::detail::parallelFor(*mArena, 0U, walks.size(), 16, [&](std::size_t a, std::size_t b) {
+      std::map<std::string, DecisionTally> local;
+      for (std::size_t element = a; element < b; ++element) {
+        const auto& followed = walks[element];
+        const std::span<const std::uint32_t> road{followed.road.index, followed.roadCount};
+        const auto particle = mTruth->rows[road[0]].particles[0];
+        if (!std::ranges::all_of(road, [&](std::uint32_t row) { return mTruth->rows[row].carries(particle); })) {
+          continue;
+        }
+        const auto index = mIndex.find(particle);
+        if (index == mIndex.end()) {
+          continue;
+        }
+        const auto& own = mRowsOf.at(particle);
+        const bool timed = !mLegs.empty() && mTimed[index->second] != 0U;
+        const auto positionOf = [&](std::uint32_t row) -> std::size_t { return static_cast<std::size_t>(std::ranges::find(own, row) - own.begin()); };
+        const auto legAt = [&](std::size_t k) -> int { return !timed || k >= own.size() ? -1 : static_cast<int>(mLegs[index->second][k]); };
+        // The first wrong row: the outward walk first, as the follow runs.
+        const Step* at = nullptr;
+        PropagationDirection direction = PropagationDirection::kForward;
+        std::vector<std::uint32_t> outwardTaken;
+        std::vector<std::uint32_t> inwardTaken;
+        const auto scan = [&](const Walk* walk, PropagationDirection dir, std::vector<std::uint32_t>& taken) {
+          if (walk == nullptr || at != nullptr) {
+            return;
+          }
+          for (const auto& step : walk->steps) {
+            if (step.choice == kNoRow) {
+              continue;
+            }
+            if (!mTruth->rows[step.choice].carries(particle)) {
+              at = &step;
+              direction = dir;
+              return;
+            }
+            taken.push_back(step.choice);
+          }
+        };
+        scan(followed.outward, PropagationDirection::kForward, outwardTaken);
+        scan(followed.inward, PropagationDirection::kBackward, inwardTaken);
+        if (at == nullptr) {
+          continue;
+        }
+        const auto& step = *at;
+        const LayerID layer = mTruth->rows[step.choice].layer;
+        const auto target = std::ranges::find(step.targets, layer, &TargetSeen::layer);
+        if (target == step.targets.end()) {
+          continue;
+        }
+        const std::uint32_t last = direction == PropagationDirection::kForward ? (outwardTaken.empty() ? road.back() : outwardTaken.back()) : (inwardTaken.empty() ? road.front() : inwardTaken.back());
+        const std::size_t lastAt = positionOf(last);
+        const int coreLeg = legAt(lastAt);
+        // The particle's own row on the layer and leg, beyond the core's last.
+        std::uint32_t mine = kNoRow;
+        for (const auto k : positionsBeyond(lastAt, own.size(), direction)) {
+          if (mTruth->rows[own[k]].layer == layer && legAt(k) == coreLeg) {
+            mine = own[k];
+            break;
+          }
+        }
+        auto& tally = local[std::format("{} | {} | {} | {} | {}", followed.population, iteration.iteration, kPathPtNames[pathPtBin(particle)], direction == PropagationDirection::kForward ? "outward" : "inward", layerGroupOf(layer, parameters))];
+        ++tally.events;
+        ++tally.taken[lineageOf(particle, step.choice)];
+        OwnThere there = kOwnNone;
+        if (mine != kNoRow) {
+          const auto seen = std::ranges::find(step.candidates, mine, &Candidate::row);
+          there = seen == step.candidates.end() ? kOwnNotSeen : (seen->outcome == StepOutcome::kPasses ? kOwnAvailable : (seen->outcome == StepOutcome::kUsed ? kOwnHeld : kOwnRefused));
+        }
+        ++tally.own[there];
+        // T and O from the step's state.
+        struct Alternative {
+          bool valid = false;
+          double chi2 = 0.;
+          double sqrtDet = 0.;
+        };
+        const auto alternative = [&](std::uint32_t row) {
+          const auto one = row == kNoRow ? OneStep{} : oneStep(row, step.state, step.factors, direction, frame, geometry, material, propagator);
+          return Alternative{.valid = one.valid, .chi2 = one.chi2, .sqrtDet = one.sqrtDet};
+        };
+        const auto taken = alternative(step.choice);
+        const auto ownAlt = there == kOwnNone || there == kOwnNotSeen ? Alternative{} : alternative(mine);
+        // rho: the window's rows beyond the gate (the clutter test's), and the layer's.
+        const auto& window = target->window;
+        const double rhoLocal = windowRho(parameters, step, layer, window, gate, taken.valid ? taken.sqrtDet : 0., direction, frame, geometry, material, propagator, [&](std::uint32_t row) { return mTruth->rows[row].carries(particle); }, std::numeric_limits<double>::quiet_NaN());
+        const double rhoLayer = std::max(layerDensity(layer, window), 1e-12);
+        const double p = reachChance(parameters, step.state, step.factors, layer, window, direction, geometry, propagator, step.choice);
+        tally.reachSum += p;
+        ++tally.reach[p < 0.25 ? 0U : (p < 0.5 ? 1U : (p < 0.9 ? 2U : 3U))];
+        const double odds = std::log(p / (1. - p));
+        const auto logG = [](const Alternative& one) { return (-0.5 * one.chi2) - std::log(one.sqrtDet) - std::log(2. * std::numbers::pi); };
+        const auto choose = [&](double rho) {
+          std::array<double, kDecisions> score{-std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity(), 0.};
+          if (taken.valid) {
+            score[kDecideTaken] = logG(taken) - std::log(rho) + odds;
+          }
+          if (ownAlt.valid) {
+            score[kDecideOwn] = logG(ownAlt) - std::log(rho) + odds;
+          }
+          return static_cast<Decision>(std::ranges::max_element(score) - score.begin());
+        };
+        Decision stepChoice = kDecisions;
+        if (std::isfinite(rhoLocal)) {
+          stepChoice = choose(rhoLocal);
+          ++tally.stepLocal[stepChoice];
+        }
+        ++tally.stepLayer[choose(rhoLayer)];
+        // The chains, in the fit's order: the inward rows innermost first, the
+        // road, the outward rows.
+        const auto chainWith = [&](std::uint32_t extra) {
+          std::vector<std::uint32_t> rows;
+          std::vector<std::uint32_t> inward = inwardTaken;
+          if (direction == PropagationDirection::kBackward && extra != kNoRow) {
+            inward.push_back(extra);
+          }
+          for (auto k = inward.size(); k-- > 0U;) {
+            rows.push_back(inward[k]);
+          }
+          rows.insert(rows.end(), road.begin(), road.end());
+          rows.insert(rows.end(), outwardTaken.begin(), outwardTaken.end());
+          if (direction == PropagationDirection::kForward && extra != kNoRow) {
+            rows.push_back(extra);
+          }
+          return rows;
+        };
+        const auto accepted = [&](const std::vector<std::uint32_t>& rows) {
+          const auto fit = fitMeasurements(propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = rows.data()}, static_cast<int>(rows.size()), kinkBudget(parameters));
+          return follow::passesRoadChi2(parameters, fit);
+        };
+        const auto withTaken = chainWith(step.choice);
+        const auto prefix = chainWith(kNoRow);
+        tally.refitTaken += accepted(withTaken) ? 1U : 0U;
+        std::vector<std::uint32_t> withOwn;
+        if (ownAlt.valid) {
+          withOwn = chainWith(mine);
+          ++tally.ownChains;
+          tally.refitOwn += accepted(withOwn) ? 1U : 0U;
+        }
+        const bool prefixOk = accepted(prefix);
+        tally.refitPrefix += prefixOk ? 1U : 0U;
+        tally.prefixLong += prefixOk && prefix.size() >= parameters.minClustersAfterFollow ? 1U : 0U;
+        tally.particleFound += goodTrack.contains(particle) ? 1U : 0U;
+        if (mTruth->rows[step.choice].count != 0U) {
+          const auto stranger = mTruth->rows[step.choice].particles[0];
+          tally.strangerFound += goodTrack.contains(stranger) ? 1U : 0U;
+          tally.strangerParticles += mIndex.contains(stranger) ? 1U : 0U;
+        }
+        // The chains' evidence, the last row's clutter and the reach in.
+        if (std::isfinite(rhoLocal)) {
+          std::array<std::array<double, kDecisions>, 3> score{};
+          bool usable = true;
+          // The running sums and the two chains' evidences at the seed's own
+          // covariance (s = 0), for the prefix's inherited evidence below.
+          std::vector<double> running;
+          std::vector<double> prefixRunning;
+          double withTakenEvidence = std::numeric_limits<double>::quiet_NaN();
+          double alone = std::numeric_limits<double>::quiet_NaN();
+          for (std::size_t s = 0; s < 3U; ++s) {
+            const double scale = s == 0U ? 1. : (s == 1U ? 10. : 100.);
+            const double takenEvidence = chainEvidence(withTaken, scale, frame, geometry, material, propagator, s == 0U ? &running : nullptr);
+            const double stopEvidence = chainEvidence(prefix, scale, frame, geometry, material, propagator, s == 0U ? &prefixRunning : nullptr);
+            if (s == 0U) {
+              withTakenEvidence = takenEvidence;
+              alone = stopEvidence;
+            }
+            score[s][kDecideTaken] = takenEvidence - std::log(rhoLocal) + std::log(p);
+            score[s][kDecideOwn] = ownAlt.valid ? chainEvidence(withOwn, scale, frame, geometry, material, propagator) - std::log(rhoLocal) + std::log(p) : -std::numeric_limits<double>::infinity();
+            score[s][kDecideStop] = stopEvidence + std::log(1. - p);
+            usable = usable && std::isfinite(score[s][kDecideTaken]) && std::isfinite(score[s][kDecideStop]) && (!ownAlt.valid || std::isfinite(score[s][kDecideOwn]));
+          }
+          if (usable) {
+            ++tally.chains;
+            const auto best = [&](std::size_t s) { return static_cast<Decision>(std::ranges::max_element(score[s]) - score[s].begin()); };
+            ++tally.chainChoice[best(0)];
+            tally.chainStable[0] += best(1) == best(0) ? 1U : 0U;
+            tally.chainStable[1] += best(2) == best(0) ? 1U : 0U;
+            tally.chainAgreesStep += best(0) == stepChoice ? 1U : 0U;
+            // The seed's own dependence on the chain: the prefix's evidence
+            // fitted alone, with its own seed's terms, against its rows'
+            // running sum inside the chain with T plus that chain's seed terms.
+            if (direction == PropagationDirection::kForward && !prefixRunning.empty() && running.size() > prefixRunning.size() && std::isfinite(alone) && std::isfinite(withTakenEvidence)) {
+              const double inherited = running[prefixRunning.size() - 1U] + (withTakenEvidence - running.back());
+              const double gap = std::abs(alone - inherited);
+              ++tally.prefixInherited[gap < 0.1 ? 0U : (gap < 1. ? 1U : 2U)];
+            }
+          }
+        }
+      }
+      const std::scoped_lock lock(merge);
+      for (const auto& [key, one] : local) {
+        auto& sum = mDecisions[key];
+        sum.events += one.events;
+        sum.reachSum += one.reachSum;
+        sum.refitTaken += one.refitTaken;
+        sum.refitOwn += one.refitOwn;
+        sum.ownChains += one.ownChains;
+        sum.refitPrefix += one.refitPrefix;
+        sum.prefixLong += one.prefixLong;
+        sum.particleFound += one.particleFound;
+        sum.strangerFound += one.strangerFound;
+        sum.strangerParticles += one.strangerParticles;
+        sum.chainAgreesStep += one.chainAgreesStep;
+        sum.chains += one.chains;
+        for (std::size_t i = 0; i < kOwnTheres; ++i) {
+          sum.own[i] += one.own[i];
+        }
+        for (std::size_t i = 0; i < kLineages; ++i) {
+          sum.taken[i] += one.taken[i];
+        }
+        for (std::size_t i = 0; i < kDecisions; ++i) {
+          sum.stepLocal[i] += one.stepLocal[i];
+          sum.stepLayer[i] += one.stepLayer[i];
+          sum.chainChoice[i] += one.chainChoice[i];
+        }
+        for (std::size_t i = 0; i < 4U; ++i) {
+          sum.reach[i] += one.reach[i];
+        }
+        for (std::size_t i = 0; i < 2U; ++i) {
+          sum.chainStable[i] += one.chainStable[i];
+        }
+        for (std::size_t i = 0; i < 3U; ++i) {
+          sum.prefixInherited[i] += one.prefixInherited[i];
+        }
+      }
+    });
+  }
+
+  /// `decisionStudy`'s tables.
+  void printDecisions() const
+  {
+    if (mDecisions.empty()) {
+      return;
+    }
+    std::string text =
+      "  the first wrong rows' alternatives: per population | iteration | pT | walk | layers of the wrong row:\n"
+      "    events | the own row on that layer and leg: passing / held by a track / refused / not in the window / none | the taken row's lineage | "
+      "the reach chance p: < 0.25 / < 0.5 / < 0.9 / >= 0.9 (mean) | the one-step evidence log(g/rho) + log(p/(1-p)) against stopping chooses taken / own / "
+      "stop, with the window's rho; with the layer's | refits accepted: with the taken row, with the own row (of the chains that have one), the prefix "
+      "(and as long as the length cut) | at the iteration's end: the particle found, the taken row's particle found (of them class particles) | "
+      "the chains' evidence chooses taken / own / stop (of the chains computed), the same choice with the seed's covariance x 10 / x 100, agreeing with "
+      "the one-step choice; the prefix alone against its rows' running sum in the chain with the taken row: |difference| < 0.1 / < 1 / more";
+    for (const auto& [key, t] : mDecisions) {
+      text += std::format("\n    {}: {} |", key, t.events);
+      for (std::size_t i = 0; i < kOwnTheres; ++i) {
+        text += std::format(" {}{}", t.own[i], i + 1U < kOwnTheres ? " /" : " |");
+      }
+      for (std::size_t i = 0; i < kLineages; ++i) {
+        text += t.taken[i] != 0U ? std::format(" {} {};", kLineageNames[i], t.taken[i]) : std::string{};
+      }
+      text += std::format(
+        " | {} / {} / {} / {} ({:.2f}) | {} / {} / {}; {} / {} / {} | {} / {} (of {}) / {} ({}) | {} / {} ({}) | {} / {} / {} (of {}), {} / {}, {} | "
+        "{} / {} / {}",
+        t.reach[0], t.reach[1], t.reach[2], t.reach[3], t.events != 0U ? t.reachSum / static_cast<double>(t.events) : 0., t.stepLocal[0], t.stepLocal[1], t.stepLocal[2], t.stepLayer[0], t.stepLayer[1], t.stepLayer[2], t.refitTaken, t.refitOwn, t.ownChains, t.refitPrefix, t.prefixLong, t.particleFound, t.strangerFound, t.strangerParticles, t.chainChoice[0], t.chainChoice[1], t.chainChoice[2], t.chains, t.chainStable[0], t.chainStable[1], t.chainAgreesStep, t.prefixInherited[0], t.prefixInherited[1], t.prefixInherited[2]);
+    }
+    std::cout << text << '\n';
+  }
+
+  /// The blockers: the class's particles not found after the iteration, by their seeding stage in it, and the rows
+  /// of theirs held by tracks: how many, by how many distinct tracks (more
+  /// than one: removing the first holder exposes another), fakes or another
+  /// particle's good tracks, and the holders' iterations.
+  struct BlockerTally {
+    std::size_t particles = 0U;
+    std::size_t blocked = 0U;             ///< with a row of theirs held
+    std::array<std::size_t, 3> holders{}; ///< 1 / 2 / 3 or more distinct holders
+    std::size_t heldRows = 0U;
+    std::size_t byFake = 0U; ///< held rows whose holder is a fake
+    std::size_t byGood = 0U; ///< held rows whose holder is another particle's good track
+    std::size_t byThis = 0U; ///< held rows whose holder is the iteration's own
+    /// Held rows whose holder is the particle's own track made fake (its
+    /// majority particle, below the purity a good track needs), and the
+    /// particles whose only holder is that.
+    std::size_t byOwnFake = 0U;
+    std::size_t onlyOwnFake = 0U;
+  };
+  template <typename Observation>
+  void blockerStudy(const Observation& iteration, const std::vector<std::uint32_t>& holder, const std::vector<std::uint64_t>& particles)
+  {
+    const auto view = iteration.tracks->view();
+    auto& tallies = mBlockers;
+    tallies.clear(); // the last iteration's stand: the end
+    const auto* stage = iteration.iteration < mSeedStage.size() && !mSeedStage[iteration.iteration].empty() ? &mSeedStage[iteration.iteration] : nullptr;
+    for (std::uint32_t index = 0; index < mFindable.size(); ++index) {
+      if (mFate[index] != kNotFound) {
+        continue;
+      }
+      const auto particle = mFindable[index];
+      auto& tally = tallies[std::format("{} | {}", kPathPtNames[pathPtBin(particle)], stage != nullptr ? kSeedStageNames[(*stage)[index]] : "no stage")];
+      ++tally.particles;
+      std::vector<std::uint32_t> distinct;
+      bool otherHolder = false;
+      for (const auto row : mRowsOf.at(particle)) {
+        const auto track = holder[row];
+        if (track == kNoTrack) {
+          continue;
+        }
+        ++tally.heldRows;
+        const std::span<const std::uint32_t> rows{view.clusters[track].index, view.count[track]};
+        const bool ownFake = particles[track] == study::kNoTrackParticle && study::majorityParticle(mTruth->rows, rows).particle == particle;
+        tally.byOwnFake += ownFake ? 1U : 0U;
+        otherHolder = otherHolder || !ownFake;
+        tally.byFake += particles[track] == study::kNoTrackParticle ? 1U : 0U;
+        tally.byGood += particles[track] != study::kNoTrackParticle ? 1U : 0U;
+        tally.byThis += track >= iteration.trackOffset ? 1U : 0U;
+        if (std::ranges::find(distinct, track) == distinct.end()) {
+          distinct.push_back(track);
+        }
+      }
+      if (!distinct.empty()) {
+        ++tally.blocked;
+        tally.onlyOwnFake += otherHolder ? 0U : 1U;
+        ++tally.holders[std::min<std::size_t>(distinct.size(), 3U) - 1U];
+      }
+    }
+  }
+  void printBlockers() const
+  {
+    if (mBlockers.empty()) {
+      return;
+    }
+    std::string text =
+      "  the class's particles not found at the end, by pT and their seeding stage in the last iteration: "
+      "particles | with a row held by a track | of them by 1 / 2 / 3+ distinct holders | held rows: by a fake / by another particle's good "
+      "track / by the last iteration's own tracks; by its own track made fake (the majority its, the purity short), and the particles held by that alone";
+    for (const auto& [key, t] : mBlockers) {
+      text += std::format("\n    {}: {} | {} | {} / {} / {} | {}: {} / {} / {}; {}, {}", key, t.particles, t.blocked, t.holders[0], t.holders[1], t.holders[2], t.heldRows, t.byFake, t.byGood, t.byThis, t.byOwnFake, t.onlyOwnFake);
+    }
+    std::cout << text << '\n';
+  }
+
+  /// `inwardStudy`'s tables.
+  void printInward() const
+  {
+    if (mInwardCount[0] + mInwardCount[1] + mInwardCount[2] == 0U) {
+      return;
+    }
+    const auto median = [](std::vector<double> values) {
+      std::erase_if(values, [](double v) { return !std::isfinite(v); });
+      return values.empty() ? std::numeric_limits<double>::quiet_NaN() : study::median(values);
+    };
+    const auto width = [&](const std::vector<double>& values) {
+      const double centre = median(values);
+      std::vector<double> deviations;
+      deviations.reserve(values.size());
+      for (const auto v : values) {
+        deviations.push_back(std::abs(v - centre));
+      }
+      return 1.4826 * median(deviations);
+    };
+    std::string text = std::format(
+      "  the refit's inward pass against the truth: passes replayed {} / {} / {} ({}, {}, {}); not reproduced {} / {} / {}\n"
+      "    by state (0: the seed, the outward end state; k: after k updates inward), per kind: n | median p / p_true | % off by > 20 % | q/p pull median / "
+      "width | median |dphi| [mrad] | phi pull width | median sigma(q/p) / (q/p)",
+      mInwardCount[0], mInwardCount[1], mInwardCount[2], kInwardKindNames[0], kInwardKindNames[1], kInwardKindNames[2], mInwardMismatch[0], mInwardMismatch[1], mInwardMismatch[2]);
+    for (std::size_t kind = 0; kind < kInwardKinds; ++kind) {
+      for (std::size_t k = 0; k < kInwardStepSlots; ++k) {
+        const auto& by = mInwardSteps[kind][k];
+        if (by.ratio.empty()) {
+          continue;
+        }
+        std::size_t off = 0U;
+        std::vector<double> absPhi;
+        for (std::size_t i = 0; i < by.ratio.size(); ++i) {
+          off += std::abs(by.ratio[i] - 1.) > 0.2 ? 1U : 0U;
+          absPhi.push_back(std::abs(by.dphi[i]));
+        }
+        text += std::format("\n    {} | {}{}: {} | {:.3f} | {:.1f} | {:+.2f} / {:.2f} | {:.2f} | {:.2f} | {:.3f}", kInwardKindNames[kind], k, k + 1U == kInwardStepSlots ? "+" : "", by.ratio.size(), median(by.ratio), 100. * static_cast<double>(off) / static_cast<double>(by.ratio.size()), median(by.pullQOverP), width(by.pullQOverP), median(absPhi), width(by.pullPhi), median(by.relSigma));
+      }
+    }
+    text += std::format("\n    the seed's q/p sign against the MC charge (convention: q/p = {} charge / p): agree / disagree:", kChargeSign > 0. ? "+" : "-");
+    for (std::size_t kind = 0; kind < kInwardKinds; ++kind) {
+      text += std::format(" {} {} / {};", kInwardKindNames[kind], mChargeAgree[kind][0], mChargeAgree[kind][1]);
+    }
+    text += "\n    each successful inward step onto a barrel plane: the crossing the solve takes against the MC crossing (nearer / the other nearer / none taken)";
+    for (std::size_t kind = 0; kind < kInwardKinds; ++kind) {
+      for (std::size_t k = 1; k < kInwardStepSlots; ++k) {
+        const auto& r = mStepRoots[kind][k];
+        if (r[1] + r[2] + r[3] == 0U) {
+          continue;
+        }
+        text += std::format("\n      {} | {}{}: {} / {} / {}", kInwardKindNames[kind], k, k + 1U == kInwardStepSlots ? "+" : "", r[1], r[2], r[3]);
+      }
+    }
+    text += "\n    the same steps by the crossings' place (inside the sensor's bounds, turn, ahead or behind along the inward pass):";
+    for (const auto& [key, count] : mStepRootDetail) {
+      text += std::format("\n      {}: {}", key, count);
+    }
+    text += "\n    the failing own-row passes from other seeds (completion only, not acceptance): passes / fails at the same step / later / earlier (or no MC row)";
+    for (std::size_t variant = 0; variant < kSeedNames.size(); ++variant) {
+      text += std::format("\n      {}: {} / {} / {} / {}", kSeedNames[variant], mSeedOutcomes[variant][0], mSeedOutcomes[variant][1], mSeedOutcomes[variant][2], mSeedOutcomes[variant][3]);
+    }
+    text += "\n    the failing step's two crossings of the plane's line, from the filtered state it started from (status 1 no intersection, 2 wrong direction):";
+    for (const auto& [key, count] : mRoots) {
+      text += std::format("\n      {}: {}", key, count);
+    }
+    text +=
+      "\n    the same rows refitted under each crossing rule: failed outward / failed inward / chi2 over the cut / accepted | against the "
+      "default from the same seed: accepted by both, not bit for bit / the default's only / this one's only | the accepted's pulls on the innermost "
+      "row, median / width: q/p, phi, theta, loc0, loc1";
+    for (std::size_t kind = 0; kind < kInwardKinds; ++kind) {
+      for (std::size_t seed = 0; seed < kRuleSeedNames.size(); ++seed) {
+        for (std::size_t rule = 0; rule < kCrossingRules.size(); ++rule) {
+          const auto& t = mRuleTallies[kind][rule][seed];
+          text += std::format("\n      {} | {} | {}: {} / {} / {} / {} | {} / {} / {} |", kInwardKindNames[kind], kRuleSeedNames[seed], kCrossingRuleNames[rule], t.outcome[kRuleOutward], t.outcome[kRuleInward], t.outcome[kRuleChi2], t.outcome[kRuleAccepted], t.against[0], t.against[1], t.against[2]);
+          for (const auto* pulls : {&t.pullQOverP, &t.pullPhi, &t.pullTheta, &t.pullLoc0, &t.pullLoc1}) {
+            text += std::format(" {:+.2f} / {:.2f};", median(*pulls), width(*pulls));
+          }
+        }
+      }
+    }
+    std::cout << text << '\n';
+  }
+
+  /// `FailedStep` of the refit \a fit of \a rows, failed.
+  template <typename Material>
+  [[nodiscard]] static FailedStep replayFailure(const std::vector<std::uint32_t>& rows, const TrackFitResult& fit, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    FailedStep out;
+    const int n = static_cast<int>(rows.size());
+    const int failed = fit.failedMeasurement;
+    if ((fit.failedPass != FitPass::kOutward && fit.failedPass != FitPass::kInward) || failed < 0 || failed >= n) {
+      return out;
+    }
+    const RowChain<Det> chain{.frame = &frame, .rows = rows.data()};
+    // The failing plane's transverse normal and distance; a circle's farthest
+    // point along that normal, its centre's projection plus its radius.
+    const auto& target = geometry.planeOf(chain[failed]);
+    const auto nx = static_cast<double>(target.normal[0]);
+    const auto ny = static_cast<double>(target.normal[1]);
+    const double transverse = std::hypot(nx, ny);
+    out.barrel = transverse > 0.9;
+    const double ux = transverse > 0. ? nx / transverse : 0.;
+    const double uy = transverse > 0. ? ny / transverse : 0.;
+    const double distance = std::abs((static_cast<double>(target.origin[0]) * ux) + (static_cast<double>(target.origin[1]) * uy));
+    const double sign = ((static_cast<double>(target.origin[0]) * ux) + (static_cast<double>(target.origin[1]) * uy)) < 0. ? -1. : 1.;
+    out.planeDistance = static_cast<float>(distance);
+    const auto margins = [&](const BoundTrackState& one) {
+      Scalar global[3]{};
+      surfaceToGlobal(geometry.planeOf(one), one.loc0(), one.loc1(), global);
+      const double curvature = propagator.curvature(one.qOverP(), std::sin(one.theta()));
+      const double cx = static_cast<double>(global[0]) - (std::sin(static_cast<double>(one.phi())) / curvature);
+      const double cy = static_cast<double>(global[1]) + (std::cos(static_cast<double>(one.phi())) / curvature);
+      const double centre = sign * ((cx * ux) + (cy * uy));
+      const double radius = 1. / std::abs(curvature);
+      out.farMargin = static_cast<float>(centre + radius - distance);
+      out.nearMargin = static_cast<float>(distance - (centre - radius));
+    };
+    const auto chainSeed = makeChainSeed(propagator, geometry, chain, n);
+    const bool forward = fit.failedPass == FitPass::kOutward;
+    BoundTrackState seed = chainSeed.state;
+    if (!forward) {
+      // `inwardPass`'s seed: the outward pass's end state.
+      seed = fit.outwardState;
+      setDiffuseCovariance(seed, chainSeed.qOverPSigma);
+    }
+    // `runPass` up to the failing measurement.
+    const auto direction = forward ? PropagationDirection::kForward : PropagationDirection::kBackward;
+    const int first = forward ? 0 : n - 1;
+    const int increment = forward ? 1 : -1;
+    const auto budget = o2::gtrk::detail::kinkBudgetFor(kinkBudget(parameters), n);
+    BoundTrackState state = seed;
+    CovarianceFactors factors;
+    {
+      const auto measurement = chain[first];
+      out.startMiss = std::hypot(seed.loc0() - measurement.loc0, seed.loc1() - measurement.loc1);
+    }
+    o2::gtrk::detail::startOnMeasurement(state, factors, chain[first]);
+    Scalar chi2 = 0.F;
+    int kinks = 0;
+    for (int step = 1; step < n; ++step) {
+      const int index = first + (step * increment);
+      const auto& stepProp = stepPropagator(propagator, geometry, chain, index - increment, index);
+      if (index == failed) {
+        out.step = step;
+        BoundTrackState filtered = state;
+        out.state = propagate(stepProp, filtered, geometry.planeOf(state), geometry.planeOf(chain[index]), direction).status;
+        margins(state);
+        out.replayed = true;
+        return out;
+      }
+      if (o2::gtrk::detail::kinkStep(stepProp, geometry, material, chain[index], direction, state, factors, chi2, budget, step < n - 1, kinks) != PropagationStatus::kOk) {
+        return out;
+      }
+    }
+    return out;
+  }
+
+  /// One follow of the iteration again (see the file's comment): of the
+  /// tracks from \a first to \a last, with their \a proposals and
+  /// \a kinkSteps as it made them, on the mask \a used as it found it; each
+  /// track from the refit of its road, or with \a fromSnapshot from the
+  /// previous iteration's track whole (followEarlier).
+  template <typename Observation, typename Proposals, typename Material>
+  [[nodiscard]] std::vector<Replay> replayExtension(const Observation& iteration, std::uint32_t first, std::uint32_t last, const Proposals& proposals, std::span<const follow::KinkSteps> kinkSteps, std::vector<std::uint8_t>& used, bool fromSnapshot, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    const bool kinks = !kinkSteps.empty();
+    const auto view = iteration.tracks->view();
+    std::vector<Replay> replays(last - first);
+    if (!parameters.follow || proposals.size() != replays.size()) {
+      return replays;
+    }
+    // The stage as the iteration instantiated it (Follow's dispatch): the
+    // choice among passing rows and the end decisions on the last row's
+    // density change which rows a walk takes. FollowEnd stays off: its end
+    // states are the follow's own.
+    withFollowStage(iteration, parameters, frame, geometry, material, propagator, used.data(), first, [&](const auto& stage) {
+      // Each track's walks on its own thread: the stage is read-only, the
+      // replay is the track's.
+      o2::gtrk::detail::parallelFor(*mArena, first, last, 256, [&](std::size_t a, std::size_t b) {
+        for (auto track = static_cast<std::uint32_t>(a); track < b; ++track) {
+          const auto& proposal = proposals[track - first];
+          auto& replay = replays[track - first];
+          // The road: the track's rows less the ones its follow added, in
+          // the road's order, and its refit as the iteration had it -- or the
+          // earlier track as it was, with its state.
+          ClusterList<kMaxClusters> road{};
+          std::uint8_t count = 0U;
+          BoundTrackState start;
+          BoundTrackState outer;
+          if (fromSnapshot) {
+            road = mSnapshot[track].clusters;
+            count = mSnapshot[track].count;
+            start = mSnapshot[track].state;
+            outer = mSnapshot[track].outwardState;
+          } else {
+            for (std::uint8_t i = 0; i < view.count[track]; ++i) {
+              const auto row = view.clusters[track].index[i];
+              const bool added = std::find(proposal.inward, proposal.inward + proposal.inwardCount, row) != proposal.inward + proposal.inwardCount || std::find(proposal.outward, proposal.outward + proposal.outwardCount, row) != proposal.outward + proposal.outwardCount;
+              if (!added) {
+                road.index[count++] = row;
+              }
+            }
+            for (auto i = static_cast<std::size_t>(count); i < kMaxClusters; ++i) {
+              road.index[i] = kNoRow;
+            }
+            // The states the follow started from where the tracker kept them,
+            // else the road's refit again.
+            const auto element = track - first;
+            if (element < iteration.followStart.size() && element < iteration.followStartInner.size()) {
+              start = iteration.followStartInner[element];
+              outer = iteration.followStart[element];
+            } else {
+              const auto fit = fitMeasurements(propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = road.index}, static_cast<int>(count), kinkBudget(parameters));
+              if (fit.status != PropagationStatus::kOk) {
+                continue;
+              }
+              start = fit.state;
+              outer = fit.outwardState;
+            }
+          }
+          Walk outward;
+          const auto walked = recordFollow(stage, start, outer, road, count, replay, outward);
+          replay.road = road;
+          replay.roadCount = count;
+          replay.agrees = walked.inwardCount >= proposal.inwardCount && std::equal(proposal.inward, proposal.inward + proposal.inwardCount, walked.inward);
+          outward.road = road;
+          outward.roadCount = count;
+          outward.bidKept = proposal.outwardCount;
+          outward.kept = proposal.outwardCount;
+          outward.agrees = walked.outwardCount >= proposal.outwardCount && std::equal(proposal.outward, proposal.outward + proposal.outwardCount, walked.outward);
+          replay.outward.push_back(std::move(outward));
+        }
+      });
+    });
+    for (const auto& replay : replays) {
+      if (!replay.outward.empty()) {
+        ++mOutReplayed;
+        mOutAgree += replay.outward.front().agrees ? 1U : 0U;
+      }
+    }
+    // The bidding: each row to the proposing track first in output order;
+    // each track keeps its proposal up to its first row lost (`Bid`,
+    // `Resolve`), then up to the last kink step whose witness it keeps
+    // (`KeepWitnesses`). Outward proposals bid with what the iteration kept
+    // of them.
+    std::vector<std::uint32_t> slots(mTruth->rows.size(), 0U);
+    for (std::uint32_t track = first; track < last; ++track) {
+      const std::uint32_t priority = last - track;
+      for (const auto row : replays[track - first].raw) {
+        slots[row] = std::max(slots[row], priority);
+      }
+      // The outward proposal as walked (the replayed walk, which the
+      // iteration's agrees with), else what the iteration kept of it.
+      const auto& proposal = proposals[track - first];
+      if (!replays[track - first].outward.empty()) {
+        for (const auto row : replays[track - first].outward.front().raw) {
+          slots[row] = std::max(slots[row], priority);
+        }
+      } else {
+        for (std::uint8_t i = 0; i < proposal.outwardCount; ++i) {
+          slots[proposal.outward[i]] = std::max(slots[proposal.outward[i]], priority);
+        }
+      }
+    }
+    // Each track's bid outcome and refit on its own thread; the fidelity
+    // counted after.
+    std::vector<std::uint8_t> faithful(last - first, 0U);
+    o2::gtrk::detail::parallelFor(*mArena, first, last, 256, [&](std::size_t a, std::size_t b) {
+      for (auto track = static_cast<std::uint32_t>(a); track < b; ++track) {
+        auto& replay = replays[track - first];
+        const std::uint32_t priority = last - track;
+        replay.bidKept = static_cast<std::uint32_t>(replay.raw.size());
+        for (std::uint32_t i = 0; i < replay.raw.size(); ++i) {
+          if (slots[replay.raw[i]] != priority) {
+            replay.bidKept = i;
+            break;
+          }
+        }
+        replay.kept = kinks ? follow::keptWithWitnesses(static_cast<std::uint8_t>(replay.bidKept), replay.witnessed) : replay.bidKept;
+        // The outward walk's bid the same way.
+        const auto& proposal = proposals[track - first];
+        for (auto& outward : replay.outward) {
+          outward.bidKept = static_cast<std::uint32_t>(outward.raw.size());
+          for (std::uint32_t i = 0; i < outward.raw.size(); ++i) {
+            if (slots[outward.raw[i]] != priority) {
+              outward.bidKept = i;
+              break;
+            }
+          }
+          outward.kept = kinks ? follow::keptWithWitnesses(static_cast<std::uint8_t>(outward.bidKept), outward.witnessed) : outward.bidKept;
+        }
+        const std::uint32_t outwardKept = replay.outward.empty() ? proposal.outwardCount : replay.outward.front().kept;
+        // The extended refit's acceptance (`follow::Refit`): the inward rows
+        // kept, the road, the outward rows kept.
+        if (replay.kept + outwardKept != 0U) {
+          std::vector<std::uint32_t> combined;
+          for (auto i = replay.kept; i-- > 0U;) {
+            combined.push_back(replay.raw[i]);
+          }
+          if (replay.outward.empty()) {
+            for (std::uint8_t i = 0; i < view.count[track]; ++i) {
+              const auto row = view.clusters[track].index[i];
+              if (std::find(proposal.inward, proposal.inward + proposal.inwardCount, row) == proposal.inward + proposal.inwardCount) {
+                combined.push_back(row);
+              }
+            }
+          } else {
+            combined.insert(combined.end(), replay.road.index, replay.road.index + replay.roadCount);
+            const auto& outward = replay.outward.front().raw;
+            combined.insert(combined.end(), outward.begin(), outward.begin() + outwardKept);
+          }
+          replay.refitRows = combined;
+          replay.refitCount = static_cast<std::uint8_t>(std::min(combined.size(), kMaxClusters));
+          for (std::size_t i = 0; i < replay.refitCount; ++i) {
+            replay.refitLayer[i] = mTruth->rows[combined[i]].layer;
+            replay.refitIncrement[i] = 0;
+          }
+          const auto increments = [&replay](PropagationDirection direction, int index, Scalar chi2) {
+            if (direction == PropagationDirection::kBackward && index >= 0 && index < replay.refitCount) {
+              replay.refitIncrement[static_cast<std::size_t>(index)] = chi2;
+            }
+          };
+          const auto fit = fitMeasurements(propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = combined.data()}, static_cast<int>(combined.size()), kinkBudget(parameters), increments);
+          if (fit.status != PropagationStatus::kOk) {
+            replay.refit = kRefitFailedFit;
+            replay.refitStatus = fit.status;
+            replay.refitFailedPass = fit.failedPass;
+            replay.refitFailedLayer = fit.failedMeasurement >= 0 && static_cast<std::size_t>(fit.failedMeasurement) < combined.size() ? mTruth->rows[combined[static_cast<std::size_t>(fit.failedMeasurement)]].layer : kInvalidLayerID;
+            replay.failedStep = replayFailure(combined, fit, parameters, frame, geometry, material, propagator);
+            for (int kept = static_cast<int>(outwardKept) - 1; kept >= 0 && !replay.outward.empty(); --kept) {
+              const auto size = combined.size() - (outwardKept - static_cast<std::size_t>(kept));
+              const auto trimmed = fitMeasurements(propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = combined.data()}, static_cast<int>(size), kinkBudget(parameters));
+              if (trimmed.status == PropagationStatus::kOk) {
+                replay.refitTrimmedKept = kept;
+                replay.refitTrimmedChi2 = follow::passesRoadChi2(parameters, trimmed);
+                break;
+              }
+            }
+          } else if (!follow::passesRoadChi2(parameters, fit)) {
+            replay.refit = kRefitAboveChi2;
+          }
+          if (fit.status == PropagationStatus::kOk) {
+            replay.refitChi2 = fit.chi2;
+            replay.refitChi2Max = parameters.roadChi2MaxByNdf[fit.ndf];
+          }
+        }
+        for (auto& outward : replay.outward) {
+          outward.refit = replay.refit;
+          outward.refitChi2 = replay.refitChi2;
+          outward.refitChi2Max = replay.refitChi2Max;
+          outward.refitStatus = replay.refitStatus;
+          outward.refitFailedPass = replay.refitFailedPass;
+          outward.refitFailedLayer = replay.refitFailedLayer;
+          outward.refitTrimmedKept = replay.refitTrimmedKept;
+          outward.refitTrimmedChi2 = replay.refitTrimmedChi2;
+          outward.failedStep = replay.failedStep;
+          outward.refitIncrement = replay.refitIncrement;
+          outward.refitLayer = replay.refitLayer;
+          outward.refitCount = replay.refitCount;
+        }
+        // Fidelity: the rows the replay says the iteration kept are the ones it
+        // kept, and its kink steps' witnesses are the ones it recorded.
+        const std::uint32_t replayKept = replay.refit == kRefitKept ? replay.kept : 0U;
+        bool agrees = replayKept == proposal.inwardCount && (!kinks || replay.witnessed == kinkSteps[track - first].inwardWitnessed);
+        for (std::uint32_t i = 0; agrees && i < replayKept; ++i) {
+          agrees = replay.raw[i] == proposal.inward[i];
+        }
+        // A disagreement where the replay refuses the refit and the
+        // iteration kept rows inward: what the stage's prefix second chance
+        // (`iterationFollowPrefix`), not replayed, would explain.
+        faithful[track - first] = agrees ? kFaithful : (replay.refit != kRefitKept && proposal.inwardCount != 0U ? kRefusedKept : kUnfaithful);
+      }
+    });
+    if (mFidelity.size() <= iteration.iteration) {
+      mFidelity.resize(iteration.iteration + 1U);
+    }
+    auto& fidelity = mFidelity[iteration.iteration][fromSnapshot ? 1U : 0U];
+    for (const auto one : faithful) {
+      ++mReplayed;
+      ++fidelity.replayed;
+      mAgree += one == kFaithful ? 1U : 0U;
+      fidelity.agree += one == kFaithful ? 1U : 0U;
+      fidelity.refusedKept += one == kRefusedKept ? 1U : 0U;
+    }
+    return replays;
+  }
+
+  /// The replay's fidelity per iteration, the iteration's own tracks and the
+  /// earlier tracks it extends (`followEarlier`) apart.
+  void printFidelity() const
+  {
+    std::string text;
+    for (std::size_t it = 0; it < mFidelity.size(); ++it) {
+      for (std::size_t kind = 0; kind < 2U; ++kind) {
+        const auto& f = mFidelity[it][kind];
+        if (f.replayed != 0U) {
+          text += std::format("\n    iteration {}, {}: {} of {} agree; of the {} others, the replay refuses the refit where the iteration kept rows inward {}", it, kind == 0U ? "its own tracks" : "the earlier tracks", f.agree, f.replayed, f.replayed - f.agree, f.refusedKept);
+        }
+      }
+    }
+    if (!text.empty()) {
+      std::cout << "  the replayed follow against the iteration's, per iteration (not replayed: the refit's prefix second chance, its trim of an "
+                   "ambiguous last row, the crossing rule):"
+                << text << '\n';
+    }
+  }
+
+  /// The decision that left \a row, the particle's next row inward, out of
+  /// the track: in the bidding or the refit if the replay proposed it, else
+  /// at the step from \a outside, the layer just outside it -- or, where the
+  /// step had the kink allowance, at its kink step.
+  [[nodiscard]] Short stopReason(const Walk& replay, std::uint32_t row, LayerID outside, std::uint64_t particle, std::uint8_t& detail) const
+  {
+    if (row == kNoTrack) {
+      return kNoStep;
+    }
+    const auto at = std::ranges::find(replay.raw, row);
+    if (at != replay.raw.end()) {
+      const auto position = static_cast<std::uint32_t>(at - replay.raw.begin());
+      if (position >= replay.bidKept) {
+        return kLostBid;
+      }
+      if (position >= replay.kept) {
+        return kWitnessLost;
+      }
+      return replay.refit == kRefitFailedFit ? kRefitFailed : kRefitChi2;
+    }
+    const auto step = std::ranges::find(replay.steps, outside, &Step::layer);
+    if (step == replay.steps.end()) {
+      return kNoStep;
+    }
+    const auto seen = std::ranges::find(step->candidates, row, &Candidate::row);
+    if (step->kinksLeft >= 0 && (seen == step->candidates.end() || seen->outcome != StepOutcome::kUsed)) {
+      // No row passed the step: its kink step decided.
+      if (step->kinksLeft == 0) {
+        return kKinkBudget;
+      }
+      const auto scaled = std::ranges::find(step->scaled, row, &Candidate::row);
+      if (scaled == step->scaled.end() || scaled->outcome != StepOutcome::kPasses) {
+        detail = static_cast<std::uint8_t>(scaled == step->scaled.end() ? kNotVisited : static_cast<std::size_t>(scaled->outcome));
+        return kKinkRefused;
+      }
+      bool confirmed = false;
+      for (const auto& witness : step->witnesses) {
+        confirmed = confirmed || (witness.row == row && witness.outcome == StepOutcome::kPasses);
+      }
+      if (confirmed) {
+        return kKinkOther;
+      }
+      // What became of the particle's own next row, or of the beam line. The
+      // next row is taken on the layer numbered two below \a outside: the
+      // class's barrel layers numbered consecutively from the beam outward
+      // and an inward walk (an outward one's witness is on the layer above;
+      // a skipped layer or a disc is not supported).
+      const auto next = outside >= 2U ? ownRowOn(particle, static_cast<LayerID>(outside - 2U)) : kNoTrack;
+      std::size_t beam = 0U;
+      std::size_t outcome = next == kNoTrack ? kNoOwnNext : kNotVisited;
+      for (const auto& witness : step->witnesses) {
+        if (witness.row == row && witness.next == kNoRow) {
+          beam = 1U;
+          outcome = static_cast<std::size_t>(witness.outcome);
+        } else if (witness.row == row && next != kNoTrack && witness.next == next) {
+          outcome = static_cast<std::size_t>(witness.outcome);
+        }
+      }
+      detail = static_cast<std::uint8_t>((8U * beam) + outcome);
+      return kKinkUnconfirmed;
+    }
+    if (seen == step->candidates.end()) {
+      return kNotQueried;
+    }
+    switch (seen->outcome) {
+      case StepOutcome::kUsed:
+        return kUsed;
+      case StepOutcome::kOutsideWindow:
+        return kWindow;
+      case StepOutcome::kHole:
+        return kHole;
+      case StepOutcome::kNoUpdate:
+        return kNoUpdate;
+      case StepOutcome::kChi2:
+        return kChi2;
+      case StepOutcome::kPasses:
+        return step->lookahead ? kLookaheadOther : kOtherTaken;
+    }
+    return kNoStep;
+  }
+
+  /// What the step from \a outside took where \a row, the particle's own,
+  /// passed it too (kOtherTaken, kLookaheadOther): the
+  /// taken row's `TakenKind`, plus `kLowerChi2` where its chi2 was below the
+  /// own row's. kNoTaken where the step does not apply.
+  enum TakenKind : std::uint8_t { kNoTaken,
+                                  kOwnOtherLayer,
+                                  kOtherSameLayer,
+                                  kOtherOtherLayer,
+                                  kNoiseSameLayer,
+                                  kNoiseOtherLayer,
+                                  kOwnDropped,
+                                  kOwnRefusedLast,
+                                  kNothingTaken,
+                                  kTakenKinds };
+  static constexpr std::uint8_t kLowerChi2 = 16U;
+  static_assert(kTakenKinds <= kLowerChi2);
+  static constexpr std::array<const char*, kTakenKinds> kTakenNames{"", "its own row on another layer", "another particle's on its layer", "another particle's on another layer", "noise on its layer", "noise on another layer", "the own row itself, dropped after (the unconfirmed drop: the next step crossed a sensor without a row)", "the own row itself, refused after as the walk's last (EndDensity, BeamEnd)", "nothing"};
+  [[nodiscard]] std::uint8_t takenKind(const Walk& replay, std::uint32_t row, LayerID outside, std::uint64_t particle) const
+  {
+    if (row == kNoTrack) {
+      return kNoTaken;
+    }
+    const auto step = std::ranges::find(replay.steps, outside, &Step::layer);
+    if (step == replay.steps.end()) {
+      return kNoTaken;
+    }
+    if (step->choice == row) {
+      return replay.refused == row ? kOwnRefusedLast : kOwnDropped;
+    }
+    if (step->choice == kNoRow) {
+      return kNothingTaken;
+    }
+    const auto own = std::ranges::find(step->candidates, row, &Candidate::row);
+    const auto taken = std::ranges::find(step->candidates, step->choice, &Candidate::row);
+    if (own == step->candidates.end() || own->outcome != StepOutcome::kPasses) {
+      return kNoTaken;
+    }
+    const auto& truth = mTruth->rows[step->choice];
+    const bool sameLayer = truth.layer == mTruth->rows[row].layer;
+    std::uint8_t kind = kOtherOtherLayer;
+    if (truth.carries(particle)) {
+      kind = kOwnOtherLayer;
+    } else if (truth.count == 0U) {
+      kind = sameLayer ? kNoiseSameLayer : kNoiseOtherLayer;
+    } else if (sameLayer) {
+      kind = kOtherSameLayer;
+    }
+    const bool lower = taken != step->candidates.end() && taken->chi2 < own->chi2;
+    return static_cast<std::uint8_t>(kind + (lower ? kLowerChi2 : 0U));
+  }
+
+  /// A true kink over theta0 binned as the refit-chi2 report bins it: <= 3,
+  /// 3-5, > 5, no hits (-1).
+  [[nodiscard]] static std::uint8_t kinkBin(float kink) { return static_cast<std::uint8_t>(kink < 0.F ? 3U : (kink <= 3.F ? 0U : (kink <= 5.F ? 1U : 2U))); }
+
+  /// A replayed walk's steps, for one track: each step's layer,
+  /// the row it stepped from, its choice, and every candidate with its
+  /// layer, outcome, chi2 and whether it carries \a particle; \a own the
+  /// row the diagnosis asked about.
+  void dumpWalk(const Walk& walk, std::uint64_t particle, std::uint32_t own) const
+  {
+    std::cout << std::format("  walk dump: particle {} own row {} (layer {}), dropped {}, end {}, raw", particle, own, static_cast<int>(mTruth->rows[own].layer), walk.dropped, static_cast<int>(walk.end));
+    for (const auto row : walk.raw) {
+      std::cout << ' ' << row;
+    }
+    std::cout << '\n';
+    for (const auto& step : walk.steps) {
+      std::cout << std::format("    step from layer {} row {}: choice {}{}{}, candidates:", static_cast<int>(step.layer), step.from, step.choice, step.kink ? " (kink)" : "", step.lookahead ? " (lookahead)" : "");
+      for (const auto& candidate : step.candidates) {
+        std::cout << std::format(" [{} L{} {} {:.2f}{}]", candidate.row, static_cast<int>(mTruth->rows[candidate.row].layer), kOutcomeNames[static_cast<std::size_t>(candidate.outcome)], static_cast<double>(candidate.chi2), mTruth->rows[candidate.row].carries(particle) ? " own" : "");
+      }
+      std::cout << '\n';
+    }
+  }
+
+  /// For a row the unconfirmed drop removed (kOwnDropped): what the step from it did with the
+  /// particle's own row there, a `StepOutcome`, or 6 where none of the
+  /// particle's rows was among its candidates; and that row's chi2.
+  [[nodiscard]] std::pair<std::uint8_t, Scalar> afterDrop(const Walk& replay, std::uint32_t row, std::uint64_t particle) const
+  {
+    const auto step = std::ranges::find(replay.steps, row, &Step::from);
+    if (step == replay.steps.end()) {
+      return {6U, 0.F};
+    }
+    for (const auto& candidate : step->candidates) {
+      if (candidate.row != row && mTruth->rows[candidate.row].carries(particle)) {
+        return {static_cast<std::uint8_t>(candidate.outcome), candidate.chi2};
+      }
+    }
+    return {6U, 0.F};
+  }
+  /// The chi2 of \a row among the candidates of the step from \a outside; 0
+  /// where it was not one.
+  [[nodiscard]] Scalar candidateChi2(const Walk& replay, std::uint32_t row, LayerID outside) const
+  {
+    const auto step = std::ranges::find(replay.steps, outside, &Step::layer);
+    if (step == replay.steps.end()) {
+      return 0.F;
+    }
+    const auto seen = std::ranges::find(step->candidates, row, &Candidate::row);
+    return seen == step->candidates.end() ? 0.F : seen->chi2;
+  }
+
+  /// Where \a row lies against the step's windows: inside the pair window
+  /// (1), inside the covariance window at the pair cut's nSigma (2), inside
+  /// it at the update gate's sqrt(chi2 max) (4) -- the covariance windows
+  /// unclipped by the pair window. The window's sigma is the gate's,
+  /// sqrt(clusterChi2Max), so a scaled copy of the parameters sets it.
+  /// The step walks in \a direction. With \a offsets, the row's distance
+  /// from the window's centre in azimuth and in the second coordinate, each
+  /// over the gate window's half-width (above 1: outside it on that axis);
+  /// the azimuth's signed by the track's charge; the azimuth half-width
+  /// along r phi [um].
+  template <typename Material>
+  [[nodiscard]] std::size_t windowAudit(const Step& step, std::uint32_t row, LayerID target, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator, PropagationDirection direction, std::array<float, 4>* offsets = nullptr) const
+  {
+    const auto nominal = predictLayerCrossing(propagator, parameters, geometry.planeOf(step.state), step.state, target, direction);
+    if (nominal.status != PropagationStatus::kOk) {
+      return 0U;
+    }
+    // The link from the inner of the two layers to the outer.
+    const auto link = direction == PropagationDirection::kBackward ? linkOf<Det>(target, step.layer) : linkOf<Det>(step.layer, target);
+    const auto point = frame.measurement(row);
+    const Scalar second = secondCoordinate<Det>(target, point.r, point.z);
+    // The window's centre as the follow has it: about the beam line.
+    Scalar phiCentre = 0.F;
+    Scalar secondCentre = 0.F;
+    follow::windowCentre(parameters, target, nominal, phiCentre, secondCentre);
+    const auto inside = [&](Scalar phiHalfWidth, Scalar secondHalfWidth) {
+      const CandidateWindow window{
+        .earliestPS = 0,
+        .latestPS = 0,
+        .afterPS = 0U,
+        .phiCentre = phiCentre,
+        .phiHalfWidth = phiHalfWidth,
+        .secondCentre = secondCentre,
+        .secondHalfWidth = secondHalfWidth,
+      };
+      return spatiallyCompatible(window, point.phi, second);
+    };
+    const auto covariance = [&](Scalar sigma, std::array<float, 4>* ratios = nullptr) {
+      auto scaled = std::make_unique<IterationParameters<Det>>(parameters);
+      scaled->clusterChi2Max = sigma * sigma;
+      CandidateWindow window{
+        .earliestPS = 0,
+        .latestPS = 0,
+        .afterPS = 0U,
+        .phiCentre = phiCentre,
+        .phiHalfWidth = std::numeric_limits<Scalar>::infinity(),
+        .secondCentre = secondCentre,
+        .secondHalfWidth = std::numeric_limits<Scalar>::infinity(),
+      };
+      follow::predictedWindow<false>(propagator, *scaled, geometry, material, step.state, step.factors, target, direction, nominal, window, 1.F);
+      if (ratios != nullptr) {
+        const Scalar dPhi = std::remainder(point.phi - phiCentre, 2.F * std::numbers::pi_v<Scalar>);
+        (*ratios)[0] = static_cast<float>(std::abs(dPhi) / window.phiHalfWidth);
+        (*ratios)[1] = static_cast<float>(std::abs(second - secondCentre) / window.secondHalfWidth);
+        (*ratios)[2] = static_cast<float>((step.state.qOverP() < 0.F ? -dPhi : dPhi) / window.phiHalfWidth);
+        (*ratios)[3] = static_cast<float>(window.phiHalfWidth * point.r * 1.e4F);
+      }
+      return inside(window.phiHalfWidth, window.secondHalfWidth);
+    };
+    std::size_t flags = 0U;
+    flags |= link != kNoLink && inside(parameters.windows[link].phiHalfWidth, parameters.windows[link].secondHalfWidth) ? 1U : 0U;
+    flags |= covariance(parameters.pairCut.nSigma) ? 2U : 0U;
+    flags |= covariance(std::sqrt(parameters.clusterChi2Max), offsets) ? 4U : 0U;
+    return flags;
+  }
+
+  /// A true road the road fit refuses: the fit repeated for its
+  /// chi2 against the cut (a lower bound: the fit stops at the first step
+  /// over it), and the road's barrel rows and its other rows fitted alone,
+  /// each where they make a road; binned by the particle's side, species and
+  /// true kink.
+  template <typename Material>
+  void describeRefusedRoad(const study::ParticleTruth& particle, float kink, const std::vector<std::uint32_t>& road, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    const auto fitOf = [&](const std::vector<std::uint32_t>& rows) {
+      if (rows.size() < 4U) {
+        return std::string{"n/a"};
+      }
+      const auto fit = fitRoad(parameters, propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = rows.data()}, static_cast<int>(rows.size()));
+      return std::string{fit.status == RoadFitStatus::kAccepted ? "passes" : (fit.status == RoadFitStatus::kRejected ? "chi2" : "propagation")};
+    };
+    const auto count = static_cast<std::uint32_t>(road.size());
+    const auto fit = fitRoad(parameters, propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = road.data()}, static_cast<int>(count));
+    // Against the kink-free cut: a lower bound of the ratio to the cut the
+    // fit applied, whose kink count a refused fit need not report.
+    const double ratio = static_cast<double>(fit.chi2) / static_cast<double>(roadChi2Cut(parameters, count, 0U));
+    std::vector<std::uint32_t> barrel;
+    std::vector<std::uint32_t> other;
+    for (const auto row : road) {
+      (((parameters.barrelLayers >> mTruth->rows[row].layer) & 1U) != 0U ? barrel : other).push_back(row);
+    }
+    const auto pdg = std::abs(particle.pdg);
+    const char* species = pdg == 11 ? "e" : (pdg == 13 ? "mu" : (pdg == 211 ? "pi" : (pdg == 321 ? "K" : (pdg == 2212 ? "p" : "other"))));
+    ++mRoadFitRefusals[std::format("{} {} {} rows kink {} chi2/cut {} | barrel rows alone {} | other rows alone {}", particle.eta < 0.F ? "-z" : "+z", species, count, kink < 0.F ? "no hits" : (kink <= 3.F ? "<= 3" : (kink <= 5.F ? "3-5" : "> 5")), ratio < 1.5 ? "1-1.5" : (ratio < 2. ? "1.5-2" : (ratio < 4. ? "2-4" : "> 4")), fitOf(barrel), fitOf(other))];
+  }
+
+  /// A particle without a good track: its rows on the iteration's road
+  /// layers held by a fake or another particle's track, fewer of them than
+  /// the iteration's chains reach (`minClusters`), or the road fit stage's
+  /// refusal of them (`roadFitRefusal`, Validation.h, in the stage's order).
+  template <typename Material>
+  [[nodiscard]] std::uint8_t missedReason(const std::vector<std::uint32_t>& own, const std::vector<std::uint32_t>& holder, const std::vector<std::uint64_t>& particles, std::size_t iteration, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator) const
+  {
+    const auto road = roadRows(own, iteration);
+    bool fake = false;
+    bool other = false;
+    for (const auto row : road) {
+      if (holder[row] != kNoTrack) {
+        (particles[holder[row]] == study::kNoTrackParticle ? fake : other) = true;
+      }
+    }
+    if (fake) {
+      return kLostToFake;
+    }
+    if (other) {
+      return kTakenByOther;
+    }
+    if (road.empty() || road.size() < parameters.minClusters) {
+      return kTooFewRows;
+    }
+    switch (roadFitRefusal(parameters, propagator, geometry, material, frame, std::span<const std::uint32_t>{road})) {
+      case FitRefusal::kTime:
+        return kRoadTime;
+      case FitRefusal::kChi2:
+        return kRoadChi2;
+      case FitRefusal::kPropagation:
+        return kRoadPropagation;
+      case FitRefusal::kPtFloor:
+        return kFloor;
+      case FitRefusal::kBeamLine:
+        return kBeamLine;
+      case FitRefusal::kTaken:
+        break;
+    }
+    return kNoRoad;
+  }
+
+  /// The particle's rows \a own on iteration \a iteration's road layers,
+  /// the first it crossed on each.
+  [[nodiscard]] std::vector<std::uint32_t> roadRows(const std::vector<std::uint32_t>& own, std::size_t iteration) const
+  {
+    std::vector<std::uint32_t> road;
+    std::uint64_t taken = 0U;
+    const std::uint64_t roadLayers = iteration < mRoadLayers.size() ? mRoadLayers[iteration] : ~std::uint64_t{0};
+    for (const auto row : own) {
+      const auto layer = mTruth->rows[row].layer;
+      if (((roadLayers >> layer) & 1U) == 0U || ((taken >> layer) & 1U) != 0U) {
+        continue;
+      }
+      taken |= std::uint64_t{1} << layer;
+      road.push_back(row);
+    }
+    return road;
+  }
+
+  /// The triplet cut's predicates after the time (TripletCut.h), the middle
+  /// layer's scattering times \a scale; kGraphPasses with \a fit and \a terms.
+  [[nodiscard]] static Graph tripletAudit(const IterationParameters<Det>& parameters, LayerID middle, const TimedPoint& a, const TimedPoint& b, const TimedPoint& c, Scalar scale, TripletFitResult& fit, KinkTerms& terms)
+  {
+    if (!tripletCurvatureCompatible(parameters, middle, a.point, b.point, c.point, scale)) {
+      return kGraphCurvature;
+    }
+    if (!fitTriplet(a.point, b.point, c.point, middle, parameters.scattering, parameters.pairCut, fit, terms, scale)) {
+      return kGraphFitFailed;
+    }
+    const Scalar nSigma = parameters.pairCut.nSigma;
+    if (!(fit.chi2 <= nSigma * nSigma)) {
+      return kGraphChi2;
+    }
+    if (!o2::gtrk::detail::tripletOwnMomentumCompatible(parameters, middle, a.point, b.point, c.point, scale, fit, terms)) {
+      return kGraphOwnMomentum;
+    }
+    return kGraphPasses;
+  }
+
+  /// The graph's predicates on \a road's consecutive triplets and their
+  /// neighbours, in the stages' order, as the iteration takes them: a
+  /// triplet the nominal cuts refuse tried again with the kink allowance
+  /// (its refusal then recorded), two kinked triplets never neighbours, a
+  /// kinked middle point's scattering scaled in the adjacent fit; the dip
+  /// window with each layer's largest variances in the frame, which bounds
+  /// the slice's. Each decision is held to the stage's own cut
+  /// (tripletCompatible, neighbourCompatible), disagreements counted.
+  [[nodiscard]] Graph graphAudit(const std::vector<std::uint32_t>& road, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, std::uint64_t particle = 0U) const
+  {
+    if (parameters.roadStartLayers == 0U) {
+      return auditChain(road, parameters, frame, particle, true);
+    }
+    // A start-layer mask (`iterationRoadStartLayers`, RoadCount.h
+    // `roadCores`): a road whose innermost measurement lies on a layer roads
+    // may not start on is none, and its suffix with it, since the roads are
+    // the maximal chains. The chain the stages make of the true rows is the
+    // suffix from the first row every predicate passes from; its innermost
+    // row's layer decides.
+    const auto need = std::max<std::size_t>(parameters.minClusters, 3U);
+    for (std::size_t k = 0; k + need <= road.size(); ++k) {
+      const std::vector<std::uint32_t> chain(road.begin() + static_cast<std::ptrdiff_t>(k), road.end());
+      if (auditChain(chain, parameters, frame, particle, false) == kGraphPasses) {
+        return ((parameters.roadStartLayers >> mTruth->rows[road[k]].layer) & 1U) != 0U ? kGraphPasses : kGraphStart;
+      }
+    }
+    return auditChain(road, parameters, frame, particle, true);
+  }
+
+  /// The first predicate refusing the chain \a road of true rows of
+  /// \a particle, in the stages' order; \a record whether the refusal
+  /// histograms count it.
+  [[nodiscard]] Graph auditChain(const std::vector<std::uint32_t>& road, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, std::uint64_t particle, bool record) const
+  {
+    const auto columns = frame.measurements();
+    const auto layerOf = [&](std::uint32_t row) { return mTruth->rows[row].layer; };
+    // A pair refusal, by the link, the particle's true kink over it and
+    // whether it was produced within the beam line's z reach.
+    const auto pairRefused = [&](const char* what, std::size_t link) {
+      if (!record) {
+        return;
+      }
+      const auto kink = largestKink(particle, Det::layerLinks[link].from, Det::layerLinks[link].to);
+      const auto found = mTruth->particles.find(particle);
+      const double vz = found != mTruth->particles.end() ? std::abs(static_cast<double>(found->second.vz)) : 0.;
+      const double reach = static_cast<double>(parameters.pairCut.nSigma) * std::sqrt(static_cast<double>(mBeamLine.varZ));
+      const double pt = truePt(found);
+      ++mPairRefusals[std::format("pT {} the floor: {} {}->{} kink {} |vz| {} the beam line's {:.0f} cm", pt >= mAuditFloor ? "at or above" : "below", what, static_cast<int>(Det::layerLinks[link].from), static_cast<int>(Det::layerLinks[link].to), kink < 0.F ? "no hits" : (kink <= 3.F ? "<= 3" : "> 3"), vz <= reach ? "within" : "beyond", reach)];
+    };
+    const auto dip = [&](const TimedPoint& from, const TimedPoint& to) { return std::atan2(static_cast<double>(to.point.z - from.point.z), std::hypot(static_cast<double>(to.point.x - from.point.x), static_cast<double>(to.point.y - from.point.y))); };
+    std::vector<TripletFitResult> fits;
+    std::vector<KinkTerms> terms;
+    std::vector<bool> kinked;
+    const bool allowance = parameters.graphKinkScale2 > 1.F;
+    // The tracklet stage's own tests on every consecutive pair first, in the
+    // stage's order: the link's source range, the time, the cells
+    // the query visits (the window rounded out to the grid's cells, its second
+    // range clipped to the direct part where the iteration has no skip
+    // links: `prepareQuery`), the pair cut from the beam line
+    // (`pairCutLoss`; this schedule's iterations pair through it), and the
+    // direct-pair rule on the pair itself (`segmentLeavesHole`).
+    for (std::size_t i = 0; i + 1U < road.size(); ++i) {
+      const auto link = linkOf<Det>(layerOf(road[i]), layerOf(road[i + 1U]));
+      if (link == kNoLink) {
+        return kGraphLambda;
+      }
+      if (!linkTaken(parameters, link)) {
+        return kGraphLinkNotTaken;
+      }
+      const auto source = frame.measurement(road[i]);
+      const auto pair = study::pairCutLoss(frame, parameters, mBeamLine, link, road[i], road[i + 1U]);
+      const auto verdict = pair.loss;
+      if (verdict == study::PairLoss::kSourceInterval && !record) {
+        return kGraphLinkRange;
+      }
+      if (verdict == study::PairLoss::kSourceInterval) {
+        const auto z = static_cast<double>(secondCoordinate<Det>(Det::layerLinks[link].from, source.r, source.z));
+        const auto low = static_cast<double>(parameters.sourceMin[link]);
+        const auto high = static_cast<double>(parameters.sourceMax[link]);
+        ++mLinkRangeRefusals[std::format("{}->{} {} [{:.1f}, {:.1f}] by {:.1f}", static_cast<int>(Det::layerLinks[link].from), static_cast<int>(Det::layerLinks[link].to), z < low ? "below" : "above", low, high, z < low ? low - z : z - high)];
+        return kGraphLinkRange;
+      }
+      if (verdict == study::PairLoss::kTime) {
+        pairRefused("time", link);
+        return kGraphPairTime;
+      }
+      switch (verdict) {
+        case study::PairLoss::kWindow:
+          pairRefused("outside the cells", link);
+          return kGraphPairWindow;
+        case study::PairLoss::kHole:
+          pairRefused(pair.emptyDirectRange ? "no direct part" : "crosses another layer", link);
+          return kGraphPairHole;
+        case study::PairLoss::kTurning:
+          pairRefused("turning point", link);
+          return kGraphPairTurning;
+        case study::PairLoss::kCurvature:
+          pairRefused("curvature", link);
+          return kGraphPairCurvature;
+        case study::PairLoss::kLongitudinal:
+          pairRefused("longitudinal", link);
+          return kGraphPairLongitudinal;
+        default:
+          break;
+      }
+    }
+    for (std::size_t i = 0; i + 2U < road.size(); ++i) {
+      const auto a = timedPointAt(columns, road[i]);
+      const auto b = timedPointAt(columns, road[i + 1U]);
+      const auto c = timedPointAt(columns, road[i + 2U]);
+      const auto middle = layerOf(road[i + 1U]);
+      const auto firstLink = linkOf<Det>(layerOf(road[i]), middle);
+      const auto second = linkOf<Det>(middle, layerOf(road[i + 2U]));
+      if (firstLink == kNoLink || second == kNoLink) {
+        return kGraphLambda;
+      }
+      // A link admits sources from a z range (`LayerLink::sourceMin/Max`,
+      // traced from the MC transitions): a row outside it makes no pair,
+      // whatever the predicates say.
+      // The source coordinate is the layer's second one: z on a barrel
+      // layer, r on a disc (`TrackletStage`, `secondCoordinate`).
+      const auto inRange = [&](std::size_t link, const TimedPoint& source) {
+        const auto z = static_cast<double>(secondCoordinate<Det>(Det::layerLinks[link].from, source.point.r, source.point.z));
+        return z >= Det::layerLinks[link].sourceMin && z <= Det::layerLinks[link].sourceMax;
+      };
+      if (!inRange(firstLink, a) || !inRange(second, b)) {
+        const auto link = inRange(firstLink, a) ? second : firstLink;
+        const auto& source = inRange(firstLink, a) ? b : a;
+        const auto z = static_cast<double>(secondCoordinate<Det>(Det::layerLinks[link].from, source.point.r, source.point.z));
+        if (record) {
+          ++mLinkRangeRefusals[std::format("{}->{} {} [{:.1f}, {:.1f}] by {:.1f}", static_cast<int>(Det::layerLinks[link].from), static_cast<int>(Det::layerLinks[link].to), z < Det::layerLinks[link].sourceMin ? "below" : "above", Det::layerLinks[link].sourceMin, Det::layerLinks[link].sourceMax, z < Det::layerLinks[link].sourceMin ? Det::layerLinks[link].sourceMin - z : z - Det::layerLinks[link].sourceMax)];
+        }
+        return kGraphLinkRange;
+      }
+      // GCC 14 finds a path with `middle` one past the last layer once the
+      // half width's helpers are inlined; `second` holds a link
+      // out of `middle`, so there is none.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+      const auto half = static_cast<double>(tripletLambdaHalfWidth(parameters, second, middle, a.point, b.point, mBounds[layerOf(road[i + 2U])]));
+#pragma GCC diagnostic pop
+      if (std::abs(dip(b, c) - dip(a, b)) > half) {
+        return kGraphLambda;
+      }
+      if (!tripletTimeCompatible(a, c)) {
+        return kGraphTime;
+      }
+      TripletFitResult fit;
+      KinkTerms kink;
+      auto reason = tripletAudit(parameters, middle, a, b, c, 1.F, fit, kink);
+      bool withAllowance = false;
+      if (reason != kGraphPasses && allowance) {
+        reason = tripletAudit(parameters, middle, a, b, c, parameters.graphKinkScale2, fit, kink);
+        withAllowance = reason == kGraphPasses;
+      }
+      TripletFitResult stageFit;
+      KinkTerms stageTerms;
+      bool stageKinked = false;
+      const bool stage = tripletCompatible(parameters, middle, a, b, c, stageFit, stageTerms, stageKinked);
+      mAuditDecisions += record ? 1U : 0U;
+      mAuditDisagreements += record && (stage != (reason == kGraphPasses) || (stage && stageKinked != withAllowance)) ? 1U : 0U;
+      if (reason == kGraphCurvature) {
+        // The disc pass's seeds: which triplet, and the predicate's
+        // numbers for the first few.
+        if (record) {
+          ++mCurvatureTriplets[std::format("{}-{}-{}", static_cast<int>(layerOf(road[i])), static_cast<int>(middle), static_cast<int>(layerOf(road[i + 2U])))];
+        }
+        if (record && mDebugTriplets < 16U) {
+          ++mDebugTriplets;
+          const auto chords = tripletChords(a.point, b.point, c.point);
+          const double cross = (static_cast<double>(b.point.x - a.point.x) * static_cast<double>(c.point.y - b.point.y)) - (static_cast<double>(b.point.y - a.point.y) * static_cast<double>(c.point.x - b.point.x));
+          const double l01 = chords.length01;
+          const double l12 = chords.length12;
+          const double l02 = chords.length02;
+          const double curvature = 2. * std::abs(cross) / (l01 * l12 * l02);
+          const double dz = static_cast<double>(c.point.z) - static_cast<double>(a.point.z);
+          const double cosine2 = (l02 * l02) / ((l02 * l02) + (dz * dz));
+          const double scattering = static_cast<double>(tripletScattering(parameters.scattering, parameters.pairCut, middle, a.point, b.point, c.point, static_cast<Scalar>(std::sqrt(cosine2)), 1.F)) / cosine2;
+          const auto ux = static_cast<Scalar>(static_cast<double>(c.point.x - a.point.x) / l02);
+          const auto uy = static_cast<Scalar>(static_cast<double>(c.point.y - a.point.y) / l02);
+          const double inFirst = 1. / l01;
+          const double inSecond = 1. / l12;
+          const double inMiddle = inFirst + inSecond;
+          const double m0 = static_cast<double>(o2::gtrk::detail::varianceAcross(a.point, ux, uy)) * inFirst * inFirst;
+          const double m1 = static_cast<double>(o2::gtrk::detail::varianceAcross(b.point, ux, uy)) * inMiddle * inMiddle;
+          const double m2 = static_cast<double>(o2::gtrk::detail::varianceAcross(c.point, ux, uy)) * inSecond * inSecond;
+          const double tolerance = static_cast<double>(parameters.pairCut.nSigma) * (2. / l02) * std::sqrt(scattering + m0 + m1 + m2);
+          const auto found = mTruth->particles.find(particle);
+          std::cout << std::format(
+            "  curvature refused: pT {:.3f} eta {:.2f}, layers {}-{}-{}, (r, z) a ({:.2f}, {:.1f}) b ({:.2f}, {:.1f}) c ({:.2f}, {:.1f}), chords {:.2f} {:.2f} "
+            "{:.2f}, curvature {:.5f} max {:.5f}, tolerance {:.5f} = nSigma {:.1f} x 2/L x sqrt(scattering {:.2e} + meas {:.2e} {:.2e} {:.2e}), cos2 {:.3f}\n",
+            truePt(found), found != mTruth->particles.end() ? static_cast<double>(found->second.eta) : 0., static_cast<int>(layerOf(road[i])), static_cast<int>(middle), static_cast<int>(layerOf(road[i + 2U])), static_cast<double>(a.point.r), static_cast<double>(a.point.z), static_cast<double>(b.point.r), static_cast<double>(b.point.z), static_cast<double>(c.point.r), static_cast<double>(c.point.z), l01, l12, l02, curvature, static_cast<double>(parameters.pairCut.maxCurvature), tolerance, static_cast<double>(parameters.pairCut.nSigma), scattering, m0, m1, m2, cosine2);
+        }
+      }
+      if (reason != kGraphPasses) {
+        return reason;
+      }
+      fits.push_back(fit);
+      terms.push_back(kink);
+      kinked.push_back(withAllowance);
+    }
+    for (std::size_t i = 0; i + 3U < road.size(); ++i) {
+      if (kinked[i] && kinked[i + 1U]) {
+        return kGraphBothKinked;
+      }
+      if (!neighbourCurvatureCompatible(parameters, fits[i].curvature, fits[i].varCurvature, fits[i + 1U].curvature, fits[i + 1U].varCurvature)) {
+        return kGraphNeighbourCurvature;
+      }
+      const auto a = timedPointAt(columns, road[i]);
+      const auto b = timedPointAt(columns, road[i + 1U]);
+      const auto c = timedPointAt(columns, road[i + 2U]);
+      const auto d = timedPointAt(columns, road[i + 3U]);
+      const Scalar secondScale = kinked[i] ? parameters.graphKinkScale2 : 1.F;
+      const Scalar thirdScale = kinked[i + 1U] ? parameters.graphKinkScale2 : 1.F;
+      auto reason = kGraphPasses;
+      TripletFitResult adjacent;
+      if (!neighbourTimeCompatible(a, d)) {
+        reason = kGraphNeighbourTime;
+      } else if (!fitAdjacentTriplets(terms[i], terms[i + 1U], a.point, b.point, c.point, d.point, layerOf(road[i + 1U]), layerOf(road[i + 2U]), parameters.scattering, parameters.pairCut, adjacent, secondScale, thirdScale)) {
+        reason = kGraphNeighbourFitFailed;
+      } else if (!(adjacent.chi2 <= parameters.neighbourChi2Max)) {
+        reason = kGraphNeighbourChi2;
+      }
+      // The stage's own cut (NeighbourCut.h), its kink terms made from the points.
+      TripletFitResult stageFit;
+      KinkTerms stageTerms;
+      bool stageMade = false;
+      bool stageValid = false;
+      const bool stage = neighbourCompatible(parameters, layerOf(road[i + 1U]), layerOf(road[i + 2U]), a, b, c, d, stageTerms, stageMade, stageValid, stageFit, secondScale, thirdScale);
+      mAuditDecisions += record ? 1U : 0U;
+      mAuditDisagreements += record && stage != (reason == kGraphPasses) ? 1U : 0U;
+      if (reason != kGraphPasses) {
+        return reason;
+      }
+    }
+    return kGraphPasses;
+  }
+
+  /// \a rows of \a particle in the order it crossed them: by the distance
+  /// from its production vertex -- `pathOrder`'s fallback, which falls on a
+  /// looper's way back.
+  void sortByTraversal(std::uint64_t particle, std::vector<std::uint32_t>& rows) const
+  {
+    const auto found = mTruth->particles.find(particle);
+    const auto vertex = vertexRZ(found);
+    const auto distance = [&](std::uint32_t row) { return pathDistance(row, vertex); };
+    std::ranges::sort(rows, [&](std::uint32_t a, std::uint32_t b) { return distance(a) < distance(b) || (!(distance(b) < distance(a)) && a < b); });
+  }
+
+  /// The ensemble without gate selection: every
+  /// findable particle along its own rows inward from its true road, the
+  /// rows taken whatever their chi2; at each target inner layer three
+  /// predictions held to the MC crossing: the follow's construction (the
+  /// road's refit updated once with the beam line, then filtered through the
+  /// rows), the clusters-only fit, and the joint reference (the
+  /// clusters-only prediction updated at the target with the beam line).
+  template <typename Material>
+  void truthWalk(std::size_t iteration, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    mWalkGate = parameters.clusterChi2Max;
+    std::vector<float> worst(mFindable.size(), 0.F);
+    for (const auto& kink : mKinks) {
+      worst[kink.particle] = std::max({worst[kink.particle], std::abs(kink.theta), std::abs(kink.phi)});
+    }
+    // Each particle's walks on its own thread, the sums, the pulls and the
+    // CSV lines gathered per thread and merged after (the hits' events are
+    // all read before, `open`); the CSV lines per range of particles, written
+    // in the particles' order.
+    struct Local {
+      std::array<std::array<std::array<WalkSum, kLayers>, 3>, 3> walk{};
+      std::array<std::array<std::array<WalkPulls, kWalkPtEdges.size() + 1U>, kLayers>, 3> pulls{};
+      std::vector<std::pair<std::size_t, std::string>> csv;
+    };
+    std::vector<Local> locals(static_cast<std::size_t>(std::max(1, mArena->maxConcurrency())) + 1U);
+    o2::gtrk::detail::parallelFor(*mArena, 0U, mFindable.size(), 64, [&](std::size_t a, std::size_t b) {
+      auto& mine = locals[static_cast<std::size_t>(std::max(0, o2::gtrk::detail::currentArenaThreadIndex()))];
+      std::string& csv = mine.csv.emplace_back(a, std::string{}).second;
+      for (auto index = static_cast<std::uint32_t>(a); index < b; ++index) {
+        const auto particle = mFindable[index];
+        const auto& own = mRowsOf.at(particle);
+        const auto road = roadRows(own, iteration);
+        if (road.size() < 4U) {
+          continue;
+        }
+        const auto firstRoadLayer = mTruth->rows[road.front()].layer;
+        // One row per layer inside the road, innermost first.
+        std::array<std::uint32_t, kLayers> inner{};
+        inner.fill(kNoTrack);
+        for (const auto row : own) {
+          const auto layer = mTruth->rows[row].layer;
+          if (layer < firstRoadLayer && ((mMask >> layer) & 1U) != 0U && inner[layer] == kNoTrack) {
+            inner[layer] = row;
+          }
+        }
+        // The follow's construction, input along the rows.
+        const auto roadFit = fitMeasurements(propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = road.data()}, static_cast<int>(road.size()), kinkBudget(parameters));
+        if (roadFit.status != PropagationStatus::kOk) {
+          continue;
+        }
+        BoundTrackState input = roadFit.state;
+        static_cast<void>(updateWithBeamLine(propagator, parameters, geometry.planeOf(input), geometry.surface(input.surface).layer, pairPointAt(frame.measurements(), road.front()), input));
+        CovarianceFactors inputFactors = factorCovariance(input.cov);
+        const bool quiet = worst[index] < 2.F;
+        // Produced within 50 um of the axis, 2.5 of the beam's widths.
+        const auto truthOf = mTruth->particles.find(particle);
+        const bool prompt = truthOf != mTruth->particles.end() && std::hypot(truthOf->second.vx, truthOf->second.vy) < 0.005F;
+        const double pt = truePt(truthOf);
+        const double eta = truthOf != mTruth->particles.end() ? static_cast<double>(truthOf->second.eta) : 0.;
+        const int pdg = truthOf != mTruth->particles.end() ? truthOf->second.pdg : 0;
+        const auto ptBin = static_cast<std::size_t>(std::ranges::upper_bound(kWalkPtEdges, pt) - kWalkPtEdges.begin());
+        // The step's prediction at the
+        // particle's own row \a row from \a state in \a dir, as the follow's
+        // step makes it (`transportCandidate`, the nominal noise), against the
+        // cluster -- the residuals, the innovation's diagonal, the update's
+        // chi2, the gate's quantity -- and against the MC crossing; the true
+        // kink over the step and over the one before. One CSV line and the
+        // summary's pulls; whether the transport worked.
+        const auto walkStep = [&](std::size_t direction, PropagationDirection dir, LayerID fromLayer, std::uint32_t row, const BoundTrackState& state, const CovarianceFactors& stateFactors) {
+          const auto measurement = measurementAt(frame, row);
+          const auto plane = geometry.planeOf(measurement);
+          const auto layer = mTruth->rows[row].layer;
+          const float local = largestKink(particle, std::min(fromLayer, layer), std::max(fromLayer, layer));
+          const float upstream = kinkAt(particle, fromLayer, direction != 0U);
+          std::size_t onLayer = 0U;
+          for (const auto at : own) {
+            onLayer += mTruth->rows[at].layer == layer ? 1U : 0U;
+          }
+          auto& pulls = mine.pulls[direction][layer][ptBin];
+          BoundTrackState predicted;
+          CovarianceFactors predictedFactors;
+          if (!follow::transportCandidate<false>(propagator, geometry, material, plane, dir, state, stateFactors, predicted, predictedFactors, 1.F)) {
+            ++pulls.fails;
+            if (mWalkCsv) {
+              csv += std::format("{},{},{},{:.4f},{:.3f},{},{},{},1,0,0,0,0,0,0,0,0,0,{:.3f},{:.3f},{}\n", direction, iteration, particle, pt, eta, pdg, static_cast<int>(fromLayer), static_cast<int>(layer), static_cast<double>(local), static_cast<double>(upstream), onLayer);
+            }
+            return false;
+          }
+          covarianceFromFactors(predictedFactors, predicted.cov);
+          const double r0 = static_cast<double>(measurement.loc0) - static_cast<double>(predicted.loc0());
+          const double r1 = static_cast<double>(measurement.loc1) - static_cast<double>(predicted.loc1());
+          const auto p00 = static_cast<double>(predicted.covAt(kLoc0, kLoc0));
+          const auto p11 = static_cast<double>(predicted.covAt(kLoc1, kLoc1));
+          const double i00 = p00 + static_cast<double>(measurement.varLoc0);
+          const double i11 = p11 + static_cast<double>(measurement.varLoc1);
+          // The update on the factors, as the follow's step makes it
+          // (`updateCandidate`), and its usability.
+          BoundTrackState updated = predicted;
+          CovarianceFactors updatedFactors = predictedFactors;
+          const auto update = updateWithMeasurement(updated, updatedFactors, measurement);
+          const double chi2 = updateUsable(update, updatedFactors) ? static_cast<double>(update.chi2) : -1.;
+          const double pull0 = i00 > 0. ? r0 / std::sqrt(i00) : 0.;
+          const double pull1 = i11 > 0. ? r1 / std::sqrt(i11) : 0.;
+          pulls.pull0.push_back(static_cast<float>(pull0));
+          pulls.pull1.push_back(static_cast<float>(pull1));
+          pulls.overGate += chi2 > static_cast<double>(mWalkGate) ? 1U : 0U;
+          double c0 = -99.;
+          double c1 = -99.;
+          if (const auto* segment = segmentOfRow(particle, frame, row); segment != nullptr) {
+            const auto crossing = crossingOn(*segment, plane);
+            c0 = p00 > 0. ? (static_cast<double>(predicted.loc0()) - crossing[0]) / std::sqrt(p00) : 0.;
+            c1 = p11 > 0. ? (static_cast<double>(predicted.loc1()) - crossing[1]) / std::sqrt(p11) : 0.;
+          }
+          if (mWalkCsv) {
+            csv += std::format("{},{},{},{:.4f},{:.3f},{},{},{},0,{:.6g},{:.6g},{:.6g},{:.6g},{:.6g},{:.6g},{:.4f},{:.3f},{:.3f},{:.3f},{:.3f},{}\n", direction, iteration, particle, pt, eta, pdg, static_cast<int>(fromLayer), static_cast<int>(layer), r0, r1, i00, i11, p00, p11, chi2, c0, c1, static_cast<double>(local), static_cast<double>(upstream), onLayer);
+          }
+          return true;
+        };
+        // Outward from the road's outward state along the particle's own rows
+        // beyond the road, in crossing order, one per layer of the mask, each
+        // taken whatever its chi2.
+        {
+          BoundTrackState state = roadFit.outwardState;
+          CovarianceFactors factors = factorCovariance(state.cov);
+          std::uint64_t seen = 0U;
+          for (const auto row : road) {
+            seen |= std::uint64_t{1} << mTruth->rows[row].layer;
+          }
+          bool beyond = false;
+          for (const auto row : own) {
+            if (!beyond) {
+              beyond = row == road.back();
+              continue;
+            }
+            const auto layer = mTruth->rows[row].layer;
+            if (((mMask >> layer) & 1U) == 0U || ((seen >> layer) & 1U) != 0U) {
+              continue;
+            }
+            seen |= std::uint64_t{1} << layer;
+            const LayerID from = geometry.surface(state.surface).layer;
+            if (!walkStep(1U, PropagationDirection::kForward, from, row, state, factors)) {
+              break;
+            }
+            BoundTrackState output;
+            CovarianceFactors outputFactors;
+            Scalar chi2 = 0.F;
+            if (!follow::updateCandidate<false>(propagator, geometry, material, measurementAt(frame, row), PropagationDirection::kForward, state, factors, output, outputFactors, chi2, 1.F)) {
+              break;
+            }
+            state = output;
+            factors = outputFactors;
+            covarianceFromFactors(factors, state.cov);
+          }
+        }
+        // The disc class's road-fit refusals: the road's barrel rows
+        // fitted alone, then the step to each of its other rows (the discs) in
+        // crossing order, each taken whatever its chi2 (direction 2).
+        {
+          std::vector<std::uint32_t> barrel;
+          std::vector<std::uint32_t> other;
+          for (const auto row : road) {
+            (((parameters.barrelLayers >> mTruth->rows[row].layer) & 1U) != 0U ? barrel : other).push_back(row);
+          }
+          if (barrel.size() >= 4U && !other.empty()) {
+            const auto barrelFit = fitMeasurements(propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = barrel.data()}, static_cast<int>(barrel.size()), kinkBudget(parameters));
+            if (barrelFit.status == PropagationStatus::kOk) {
+              BoundTrackState state = barrelFit.outwardState;
+              CovarianceFactors factors = factorCovariance(state.cov);
+              for (const auto row : other) {
+                const LayerID from = geometry.surface(state.surface).layer;
+                if (!walkStep(2U, PropagationDirection::kForward, from, row, state, factors)) {
+                  break;
+                }
+                BoundTrackState output;
+                CovarianceFactors outputFactors;
+                Scalar chi2 = 0.F;
+                if (!follow::updateCandidate<false>(propagator, geometry, material, measurementAt(frame, row), PropagationDirection::kForward, state, factors, output, outputFactors, chi2, 1.F)) {
+                  break;
+                }
+                state = output;
+                factors = outputFactors;
+                covarianceFromFactors(factors, state.cov);
+              }
+            }
+          }
+        }
+        // Inward layer by layer by number: the class's barrel layers
+        // consecutive from the beam outward (a skipped layer or a disc is
+        // not supported).
+        for (auto target = static_cast<int>(firstRoadLayer) - 1; target >= 0; --target) {
+          const auto row = inner[static_cast<std::size_t>(target)];
+          if (row == kNoTrack) {
+            break;
+          }
+          const auto measurement = measurementAt(frame, row);
+          const auto plane = geometry.planeOf(measurement);
+          const auto* segment = segmentOfRow(particle, frame, row);
+          static_cast<void>(walkStep(0U, PropagationDirection::kBackward, geometry.surface(input.surface).layer, row, input, inputFactors));
+          // The clusters-only fit over the rows outside the target.
+          std::vector<std::uint32_t> chain;
+          for (auto layer = static_cast<std::size_t>(target) + 1U; layer < static_cast<std::size_t>(firstRoadLayer); ++layer) {
+            chain.push_back(inner[layer]);
+          }
+          chain.insert(chain.end(), road.begin(), road.end());
+          const auto clusters = fitMeasurements(propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = chain.data()}, static_cast<int>(chain.size()), kinkBudget(parameters));
+          std::array<BoundTrackState, 3> predicted{};
+          std::array<bool, 3> ok{};
+          CovarianceFactors factors;
+          ok[0] = follow::transportCandidate<false>(propagator, geometry, material, plane, PropagationDirection::kBackward, input, inputFactors, predicted[0], factors, 1.F);
+          if (ok[0]) {
+            covarianceFromFactors(factors, predicted[0].cov);
+          }
+          if (clusters.status == PropagationStatus::kOk) {
+            ok[1] = follow::transportCandidate<false>(propagator, geometry, material, plane, PropagationDirection::kBackward, clusters.state, factorCovariance(clusters.state.cov), predicted[1], factors, 1.F);
+            if (ok[1]) {
+              covarianceFromFactors(factors, predicted[1].cov);
+              predicted[2] = predicted[1];
+              ok[2] = updateWithBeamLine(propagator, parameters, plane, static_cast<LayerID>(target), pairPointAt(frame.measurements(), row), predicted[2]).ok;
+            }
+          }
+          if (segment != nullptr) {
+            const auto crossing = crossingOn(*segment, plane);
+            for (std::size_t construction = 0; construction < 3U; ++construction) {
+              if (!ok[construction]) {
+                continue;
+              }
+              const auto& state = predicted[construction];
+              const double pull0 = (static_cast<double>(state.loc0()) - crossing[0]) / std::sqrt(static_cast<double>(state.covAt(kLoc0, kLoc0)));
+              const double pull1 = (static_cast<double>(state.loc1()) - crossing[1]) / std::sqrt(static_cast<double>(state.covAt(kLoc1, kLoc1)));
+              for (std::size_t selection = 0; selection < 3U; ++selection) {
+                if ((selection >= 1U && !quiet) || (selection == 2U && !prompt)) {
+                  continue;
+                }
+                auto& sum = mine.walk[selection][construction][static_cast<std::size_t>(target)];
+                ++sum.n;
+                sum.s0 += pull0 * pull0;
+                sum.s1 += pull1 * pull1;
+                sum.out0 += std::abs(pull0) > 3. ? 1U : 0U;
+                sum.out1 += std::abs(pull1) > 3. ? 1U : 0U;
+              }
+            }
+          }
+          // The follow's construction takes the row, whatever its chi2.
+          BoundTrackState output;
+          CovarianceFactors outputFactors;
+          Scalar chi2 = 0.F;
+          if (!follow::updateCandidate<false>(propagator, geometry, material, measurement, PropagationDirection::kBackward, input, inputFactors, output, outputFactors, chi2, 1.F)) {
+            break;
+          }
+          input = output;
+          inputFactors = outputFactors;
+          covarianceFromFactors(inputFactors, input.cov);
+        }
+      }
+    });
+    for (auto& each : locals) {
+      for (std::size_t s = 0; s < 3U; ++s) {
+        for (std::size_t c = 0; c < 3U; ++c) {
+          for (std::size_t layer = 0; layer < kLayers; ++layer) {
+            auto& sum = mWalk[s][c][layer];
+            const auto& one = each.walk[s][c][layer];
+            sum.n += one.n;
+            sum.s0 += one.s0;
+            sum.s1 += one.s1;
+            sum.out0 += one.out0;
+            sum.out1 += one.out1;
+          }
+        }
+      }
+      for (std::size_t direction = 0; direction < 3U; ++direction) {
+        for (std::size_t layer = 0; layer < kLayers; ++layer) {
+          for (std::size_t bin = 0; bin <= kWalkPtEdges.size(); ++bin) {
+            auto& pulls = mWalkPulls[direction][layer][bin];
+            auto& one = each.pulls[direction][layer][bin];
+            pulls.pull0.insert(pulls.pull0.end(), one.pull0.begin(), one.pull0.end());
+            pulls.pull1.insert(pulls.pull1.end(), one.pull1.begin(), one.pull1.end());
+            pulls.overGate += one.overGate;
+            pulls.fails += one.fails;
+          }
+        }
+      }
+    }
+    if (mWalkCsv) {
+      std::vector<std::pair<std::size_t, std::string>*> ranges;
+      for (auto& each : locals) {
+        for (auto& range : each.csv) {
+          ranges.push_back(&range);
+        }
+      }
+      std::ranges::sort(ranges, {}, [](const auto* range) { return range->first; });
+      for (const auto* range : ranges) {
+        *mWalkCsv << range->second;
+      }
+    }
+  }
+
+  /// The MC segment's crossing of \a plane in its local coordinates.
+  [[nodiscard]] static std::array<double, 2> crossingOn(const study::HitSegment& segment, const TrackingSurface& plane)
+  {
+    double along[3]{};
+    double offset = 0.;
+    double slope = 0.;
+    for (std::size_t i = 0; i < 3U; ++i) {
+      along[i] = segment.end[i] - segment.start[i];
+      offset += (segment.start[i] - static_cast<double>(plane.origin[i])) * static_cast<double>(plane.normal[i]);
+      slope += along[i] * static_cast<double>(plane.normal[i]);
+    }
+    const double t = std::abs(slope) > 0. ? -offset / slope : 0.5;
+    const Scalar global[3] = {static_cast<Scalar>(segment.start[0] + (t * along[0])), static_cast<Scalar>(segment.start[1] + (t * along[1])), static_cast<Scalar>(segment.start[2] + (t * along[2]))};
+    Scalar local[3]{};
+    surfaceToLocal(plane, global, local);
+    return {static_cast<double>(local[0]), static_cast<double>(local[1])};
+  }
+
+  /// The particle's first row on \a layer in its crossing order; none for a
+  /// particle without rows (a fake's majority of noise rows).
+  [[nodiscard]] std::uint32_t ownRowOn(std::uint64_t particle, LayerID layer) const
+  {
+    const auto rows = mRowsOf.find(particle);
+    if (rows == mRowsOf.end()) {
+      return kNoTrack;
+    }
+    for (const auto row : rows->second) {
+      if (mTruth->rows[row].layer == layer) {
+        return row;
+      }
+    }
+    return kNoTrack;
+  }
+
+  /// The MC segment of \a particle on \a chip nearest \a near; none without the hits.
+  [[nodiscard]] const study::HitSegment* segmentOf(std::uint64_t particle, std::uint32_t chip, const Scalar near[3]) const
+  {
+    const auto* segments = mHits ? segmentsOf(particle) : nullptr;
+    if (segments == nullptr) {
+      return nullptr;
+    }
+    const study::HitSegment* best = nullptr;
+    double bestDistance = std::numeric_limits<double>::infinity();
+    for (const auto* segment : *segments) {
+      if (segment->chip != chip) {
+        continue;
+      }
+      double d2 = 0.;
+      for (std::size_t i = 0; i < 3U; ++i) {
+        const double d = (0.5 * (segment->start[i] + segment->end[i])) - static_cast<double>(near[i]);
+        d2 += d * d;
+      }
+      if (d2 < bestDistance) {
+        bestDistance = d2;
+        best = segment;
+      }
+    }
+    return best;
+  }
+
+  [[nodiscard]] static std::uint64_t segmentKey(int event, int track) { return (static_cast<std::uint64_t>(static_cast<std::uint32_t>(event)) << 32U) | static_cast<std::uint32_t>(track); }
+
+  /// The radial direction of \a segment: +1 outward, -1 inward; from its
+  /// ends, or where they are at one radius (a crossing at the turning point)
+  /// from its momentum.
+  [[nodiscard]] static int radialSign(const study::HitSegment& segment)
+  {
+    const double dr = std::hypot(segment.end[0], segment.end[1]) - std::hypot(segment.start[0], segment.start[1]);
+    if (std::abs(dr) > 1e-4) {
+      return dr > 0. ? 1 : -1;
+    }
+    const double along = (0.5 * (segment.start[0] + segment.end[0]) * segment.momentum[0]) + (0.5 * (segment.start[1] + segment.end[1]) * segment.momentum[1]);
+    return along >= 0. ? 1 : -1;
+  }
+
+  /// Every particle's rows in path order: by its MC
+  /// segments' time of flight, where every row has its segment; the distance
+  /// from the vertex the constructor sorted by falls on a looper's way back,
+  /// which comes nearer the vertex in r while it goes on in z and in time. A
+  /// particle with a row the hits do not have keeps the distance's order. For
+  /// the class, each row's leg (`mLegs`): 0 out to the first turning point, 1
+  /// back from it, 2 out again, ...: where the radius along the path turns.
+  void pathOrder(const TimeFrame<Det>& frame)
+  {
+    std::vector<std::pair<const std::uint64_t, std::vector<std::uint32_t>>*> all;
+    all.reserve(mRowsOf.size());
+    for (auto& entry : mRowsOf) {
+      all.push_back(&entry);
+    }
+    // Per particle: 0 timed, its order the distance's; 1 timed and
+    // reordered; 2 kept (a row without its segment); plus 4 where the first
+    // row on some layer changed.
+    std::vector<std::uint8_t> outcome(all.size(), 0U);
+    mLegs.assign(mFindable.size(), {});
+    mTimed.assign(mFindable.size(), 0U);
+    o2::gtrk::detail::parallelFor(*mArena, 0U, all.size(), 1024, [&](std::size_t a, std::size_t b) {
+      std::vector<std::pair<double, std::uint32_t>> keyed;
+      std::vector<int> signs;
+      for (std::size_t i = a; i < b; ++i) {
+        const auto particle = all[i]->first;
+        auto& rows = all[i]->second;
+        keyed.clear();
+        signs.clear();
+        for (const auto row : rows) {
+          const auto* segment = segmentOfRow(particle, frame, row);
+          if (segment == nullptr) {
+            break;
+          }
+          keyed.emplace_back(segment->time, row);
+          signs.push_back(radialSign(*segment));
+        }
+        if (keyed.size() != rows.size()) {
+          outcome[i] = 2U;
+          continue;
+        }
+        std::array<std::uint32_t, kLayers> firstBefore{};
+        firstBefore.fill(kNoTrack);
+        for (const auto row : rows) {
+          auto& first = firstBefore[mTruth->rows[row].layer];
+          first = first == kNoTrack ? row : first;
+        }
+        // Sorted by time, the row as the tie-break; the signs with them.
+        std::vector<std::size_t> order(rows.size());
+        std::iota(order.begin(), order.end(), std::size_t{0});
+        std::ranges::sort(order, [&](std::size_t x, std::size_t y) { return keyed[x] < keyed[y]; });
+        bool same = true;
+        for (std::size_t k = 0; k < rows.size(); ++k) {
+          same = same && rows[k] == keyed[order[k]].second;
+        }
+        std::vector<int> sortedSigns(rows.size());
+        for (std::size_t k = 0; k < rows.size(); ++k) {
+          rows[k] = keyed[order[k]].second;
+          sortedSigns[k] = signs[order[k]];
+        }
+        std::array<std::uint32_t, kLayers> firstAfter{};
+        firstAfter.fill(kNoTrack);
+        for (const auto row : rows) {
+          auto& first = firstAfter[mTruth->rows[row].layer];
+          first = first == kNoTrack ? row : first;
+        }
+        outcome[i] = static_cast<std::uint8_t>((same ? 0U : 1U) | (firstBefore != firstAfter ? 4U : 0U));
+        const auto index = mIndex.find(particle);
+        if (index == mIndex.end()) {
+          continue;
+        }
+        auto& legs = mLegs[index->second];
+        legs.resize(rows.size());
+        std::uint8_t leg = 0U;
+        for (std::size_t k = 0; k < rows.size(); ++k) {
+          if (k != 0U && sortedSigns[k] != sortedSigns[k - 1U] && leg < 255U) {
+            ++leg;
+          }
+          legs[k] = leg;
+        }
+        mTimed[index->second] = 1U;
+      }
+    });
+    for (std::size_t i = 0; i < all.size(); ++i) {
+      const bool inClass = mIndex.contains(all[i]->first);
+      auto& counts = mPathCounts[inClass ? 1U : 0U];
+      ++counts[(outcome[i] & 3U) == 2U ? 2U : (outcome[i] & 1U)];
+      counts[3] += (outcome[i] & 4U) != 0U ? 1U : 0U;
+    }
+  }
+
+  [[nodiscard]] const study::HitSegment* segmentOfRow(std::uint64_t particle, const TimeFrame<Det>& frame, std::uint32_t row) const
+  {
+    const auto point = frame.measurement(row);
+    const Scalar near[3] = {point.x, point.y, point.z};
+    return segmentOf(particle, measurementAt(frame, row).surface, near);
+  }
+
+  static float midOf(const study::HitSegment& one, std::size_t i) { return static_cast<float>(0.5 * (one.start[i] + one.end[i])); }
+
+  /// Highland's theta0 at \a p for the LUT's x/X0 between two crossings, and that x/X0.
+  template <typename Material>
+  static std::pair<double, double> theta0Between(const Material& material, const Propagator& propagator, const study::HitSegment& a, const study::HitSegment& b, double p)
+  {
+    const auto budget = material.getMatBudget(midOf(a, 0), midOf(a, 1), midOf(a, 2), midOf(b, 0), midOf(b, 1), midOf(b, 2));
+    const auto x2x0 = static_cast<double>(budget.meanX2X0);
+    const auto mass = static_cast<double>(propagator.massGeV);
+    const double betaP = p * p / std::sqrt((p * p) + (mass * mass));
+    return {x2x0 > 0. ? 0.0136 / betaP * std::sqrt(x2x0) * (1. + (0.038 * std::log(x2x0))) : 0., x2x0};
+  }
+
+  /// The true kinks from crossing \a a to crossing \a b, theta and the
+  /// bending plane's, in radians: the momentum's change less the field's
+  /// turn over the transverse arc at the true pT, its sign the one leaving
+  /// the smaller kink (the turn is tens of mrad, a kink a few).
+  static std::pair<double, double> kinksBetween(const study::HitSegment& a, const study::HitSegment& b, double bzKiloGauss)
+  {
+    const auto& pa = a.momentum;
+    const auto& pb = b.momentum;
+    const double theta = std::atan2(std::hypot(pb[0], pb[1]), pb[2]) - std::atan2(std::hypot(pa[0], pa[1]), pa[2]);
+    const double pt = std::hypot(pa[0], pa[1]);
+    const double p = std::hypot(pa[0], pa[1], pa[2]);
+    const double radius = 100. * pt / (0.0299792458 * std::abs(bzKiloGauss));
+    const double chord = std::hypot(static_cast<double>(midOf(b, 0) - midOf(a, 0)), static_cast<double>(midOf(b, 1) - midOf(a, 1)));
+    const double turn = 2. * std::asin(std::min(1., 0.5 * chord / radius));
+    const double dphi = std::remainder(std::atan2(pb[1], pb[0]) - std::atan2(pa[1], pa[0]), 2. * std::numbers::pi);
+    const double phi = (std::abs(dphi - turn) < std::abs(dphi + turn) ? dphi - turn : dphi + turn) * pt / p;
+    return {theta, phi};
+  }
+
+  /// Every findable particle's kinks between its crossings of consecutive
+  /// layers of the mask, its first row on each in crossing order; which pairs
+  /// were evaluated, a bit each; and whether it crossed a layer twice.
+  template <typename Material>
+  void trueKinks(const TimeFrame<Det>& frame, const Material& material, const Propagator& propagator)
+  {
+    mEvaluated.assign(mFindable.size(), 0U);
+    mCrossed.assign(mFindable.size(), 0U);
+    mRepeated.assign(mFindable.size(), false);
+    for (std::uint32_t index = 0; index < mFindable.size(); ++index) {
+      const auto particle = mFindable[index];
+      std::array<const study::HitSegment*, kLayers> crossing{};
+      std::uint64_t seen = 0U;
+      // Every layer the particle crossed, the class's mask or not: a road
+      // holds rows beyond the mask (the VD under a disc class), and its
+      // "quiet" has to cover them.
+      for (const auto row : mRowsOf.at(particle)) {
+        const auto layer = mTruth->rows[row].layer;
+        if (((seen >> layer) & 1U) != 0U) {
+          mRepeated[index] = true;
+          continue;
+        }
+        seen |= std::uint64_t{1} << layer;
+        crossing[layer] = segmentOfRow(particle, frame, row);
+        mMissingSegment += crossing[layer] == nullptr ? 1U : 0U;
+      }
+      // Between consecutive crossings of the mask's layers, whatever lies
+      // between them (the disc classes' ML 4 -> C1 is not between layers L
+      // and L + 1).
+      std::size_t previous = kLayers;
+      mCrossed[index] = seen;
+      for (std::size_t layer = 0; layer < kLayers; ++layer) {
+        if (crossing[layer] == nullptr) {
+          continue;
+        }
+        const auto from = previous;
+        previous = layer;
+        if (from == kLayers) {
+          continue;
+        }
+        const auto* a = crossing[from];
+        const auto* b = crossing[layer];
+        const double p = std::hypot(a->momentum[0], a->momentum[1], a->momentum[2]);
+        const auto [theta0, x2x0] = theta0Between(material, propagator, *a, *b, p);
+        if (!(theta0 > 0.)) {
+          ++mZeroMaterial;
+          continue;
+        }
+        const auto [theta, phi] = kinksBetween(*a, *b, static_cast<double>(propagator.bzKiloGauss));
+        mEvaluated[index] |= std::uint64_t{1} << from;
+        mKinks.push_back({
+          .particle = index,
+          .layer = static_cast<LayerID>(from),
+          .to = static_cast<LayerID>(layer),
+          .p = static_cast<float>(p),
+          .theta = static_cast<float>(theta / theta0),
+          .phi = static_cast<float>(phi / theta0),
+          .x2x0 = static_cast<float>(x2x0),
+        });
+      }
+    }
+    // The kinks are pushed in particle order: each particle's first, for
+    // `largestKink`.
+    mKinkBegin.assign(mFindable.size() + 1U, 0U);
+    for (const auto& kink : mKinks) {
+      ++mKinkBegin[kink.particle + 1U];
+    }
+    for (std::size_t i = 1; i < mKinkBegin.size(); ++i) {
+      mKinkBegin[i] += mKinkBegin[i - 1U];
+    }
+  }
+
+  void printKinks() const
+  {
+    if (mKinks.empty()) {
+      return;
+    }
+    // Every pair evaluated: a kink from every layer crossed but the last.
+    const auto wholeOf = [&](std::size_t index) {
+      const auto crossed = mCrossed[index];
+      const auto pairs = crossed == 0U ? 0U : crossed & ~(std::uint64_t{1} << (63 - std::countl_zero(crossed)));
+      return mEvaluated[index] == pairs;
+    };
+    std::size_t whole = 0U;
+    std::size_t repeated = 0U;
+    for (std::size_t index = 0; index < mFindable.size(); ++index) {
+      whole += wholeOf(index) ? 1U : 0U;
+      repeated += mRepeated[index] ? 1U : 0U;
+    }
+    std::cout << std::format(
+      "  true kinks (MC hits): {} of {} particles with every pair evaluated; rows without a segment {}, pairs without material {}; particles "
+      "crossing a layer twice {}\n",
+      whole, mFindable.size(), mMissingSegment, mZeroMaterial, repeated);
+    std::cout << "  kinks over theta0 between consecutive crossings (Gaussian: 0.27 % beyond 3): theta rms within 3, % beyond 3, beyond 5 | the bending "
+                 "plane's the same\n";
+    const auto summary = [&](const auto& select) {
+      std::array<std::size_t, 2> count{};
+      std::array<double, 2> core2{};
+      std::array<std::array<std::size_t, 2>, 2> beyond{};
+      std::size_t all = 0U;
+      for (const auto& kink : mKinks) {
+        if (!select(kink)) {
+          continue;
+        }
+        ++all;
+        for (std::size_t plane = 0; plane < 2U; ++plane) {
+          const auto a = std::abs(static_cast<double>(plane == 0U ? kink.theta : kink.phi));
+          if (a < 3.) {
+            ++count[plane];
+            core2[plane] += a * a;
+          }
+          beyond[plane][0] += a > 3. ? 1U : 0U;
+          beyond[plane][1] += a > 5. ? 1U : 0U;
+        }
+      }
+      const auto share = [&](std::size_t k) { return all != 0U ? 100. * static_cast<double>(k) / static_cast<double>(all) : 0.; };
+      const auto rms = [&](std::size_t plane) { return count[plane] != 0U ? std::sqrt(core2[plane] / static_cast<double>(count[plane])) : 0.; };
+      return std::format("{}: {:.2f} {:.2f} {:.3f} | {:.2f} {:.2f} {:.3f}", all, rms(0), share(beyond[0][0]), share(beyond[0][1]), rms(1), share(beyond[1][0]), share(beyond[1][1]));
+    };
+    for (std::size_t layer = 0; layer + 1U < kLayers; ++layer) {
+      if (std::ranges::any_of(mKinks, [&](const TrueKink& kink) { return kink.layer == layer; })) {
+        std::cout << std::format("    crossings from {}, {}\n", layer, summary([&](const TrueKink& kink) { return kink.layer == layer; }));
+      }
+    }
+    constexpr std::array<double, 6> kPEdges{1., 1.5, 2., 3., 5., 1.e9};
+    for (std::size_t bin = 0; bin + 1U < kPEdges.size(); ++bin) {
+      std::cout << std::format("    p [{}, {}) GeV, {}\n", kPEdges[bin], kPEdges[bin + 1U], summary([&](const TrueKink& kink) { return static_cast<double>(kink.p) >= kPEdges[bin] && static_cast<double>(kink.p) < kPEdges[bin + 1U]; }));
+    }
+    // The particles by their largest kink, either plane; those without every
+    // pair evaluated apart.
+    std::vector<float> worst(mFindable.size(), 0.F);
+    for (const auto& kink : mKinks) {
+      worst[kink.particle] = std::max({worst[kink.particle], std::abs(kink.theta), std::abs(kink.phi)});
+    }
+    std::cout << "  the findable by their largest kink, either plane (theta0): n (% of all) | complete, short, not found (% of them); short and not found by reason\n";
+    constexpr std::array<double, 7> kWorstEdges{0., 2., 3., 4., 5., 10., 1.e30};
+    const auto row = [&](const std::string& name, const auto& select) {
+      std::array<std::size_t, 3> fates{};
+      std::array<std::size_t, kShortReasons + 1U> stops{};
+      std::array<std::size_t, kMissedReasons> missed{};
+      std::size_t count = 0U;
+      for (std::size_t index = 0; index < mFindable.size(); ++index) {
+        if (!select(index)) {
+          continue;
+        }
+        ++count;
+        ++fates[mFate[index]];
+        if (mFate[index] == kShortFate) {
+          ++stops[mStop[index]];
+        } else if (mFate[index] == kNotFound) {
+          ++missed[mReason[index]];
+        }
+      }
+      const auto share = [&](std::size_t k) { return count != 0U ? 100. * static_cast<double>(k) / static_cast<double>(count) : 0.; };
+      std::string line = std::format("    {}: {} ({:.2f} %) | {:.2f} {:.2f} {:.2f} |", name, count, 100. * static_cast<double>(count) / static_cast<double>(std::max<std::size_t>(mFindable.size(), 1U)), share(fates[0]), share(fates[1]), share(fates[2]));
+      for (std::size_t reason = 0; reason < kShortReasons; ++reason) {
+        if (stops[reason] != 0U) {
+          line += std::format(" {} {:.2f};", kShortNames[reason], share(stops[reason]));
+        }
+      }
+      line += " |";
+      for (std::size_t reason = 0; reason < kMissedReasons; ++reason) {
+        if (missed[reason] != 0U) {
+          line += std::format(" {} {:.2f};", kMissedNames[reason], share(missed[reason]));
+        }
+      }
+      std::cout << line << '\n';
+    };
+    for (std::size_t bin = 0; bin + 1U < kWorstEdges.size(); ++bin) {
+      row(std::format("[{}, {})", kWorstEdges[bin], kWorstEdges[bin + 1U]), [&](std::size_t index) { return wholeOf(index) && static_cast<double>(worst[index]) >= kWorstEdges[bin] && static_cast<double>(worst[index]) < kWorstEdges[bin + 1U]; });
+    }
+    row("not every pair evaluated", [&](std::size_t index) { return !wholeOf(index); });
+  }
+
+  /// One CSV line: the step \a step's state, carried to its particle's row
+  /// \a row as the step's update does, against the cluster and the MC
+  /// crossing; the start's own stave's true kink.
+  template <typename Material>
+  void record(const char* kind, std::uint64_t particle, std::size_t iteration, const Walk& replay, std::size_t stepIndex, std::uint32_t row, Scalar chi2, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    const auto& step = replay.steps[stepIndex];
+    const auto measurement = measurementAt(frame, row);
+    const auto plane = geometry.planeOf(measurement);
+    BoundTrackState predicted;
+    CovarianceFactors predictedFactors;
+    if (!follow::transportCandidate<false>(propagator, geometry, material, plane, PropagationDirection::kBackward, step.state, step.factors, predicted, predictedFactors, 1.F)) {
+      return;
+    }
+    covarianceFromFactors(predictedFactors, predicted.cov);
+    // The references: the clusters-only inward filter
+    // over the road and the rows the proposal took before this step, carried
+    // to the row's plane; and that prediction updated there with the beam
+    // line, whose variance holds the scattering inside the target only --
+    // the joint linear-Gaussian prediction with the beam point.
+    // The rows taken before this step are the earlier steps' choices: the
+    // walk takes at most one per step, and `raw` is the walk's result, short
+    // of the rows its end dropped (the unconfirmed drop, the end refusals) that this step's
+    // state still carries.
+    std::vector<std::uint32_t> chain;
+    for (auto i = std::min(stepIndex, replay.steps.size()); i-- > 0U;) {
+      if (replay.steps[i].choice != kNoRow) {
+        chain.push_back(replay.steps[i].choice);
+      }
+    }
+    for (std::uint8_t i = 0; i < replay.roadCount; ++i) {
+      chain.push_back(replay.road.index[i]);
+    }
+    const auto clusters = fitMeasurements(propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = chain.data()}, static_cast<int>(chain.size()), kinkBudget(parameters));
+    BoundTrackState noBeam;
+    BoundTrackState joint;
+    bool references = false;
+    if (clusters.status == PropagationStatus::kOk) {
+      CovarianceFactors noBeamFactors;
+      references = follow::transportCandidate<false>(propagator, geometry, material, plane, PropagationDirection::kBackward, clusters.state, factorCovariance(clusters.state.cov), noBeam, noBeamFactors, 1.F);
+      if (references) {
+        covarianceFromFactors(noBeamFactors, noBeam.cov);
+        joint = noBeam;
+        references = updateWithBeamLine(propagator, parameters, plane, mTruth->rows[row].layer, pairPointAt(frame.measurements(), row), joint).ok;
+      }
+    }
+    const auto chi2Of = [&](BoundTrackState state) {
+      auto factors = factorCovariance(state.cov);
+      return updateWithMeasurement(state, factors, measurement).chi2;
+    };
+    const Scalar chi2NoBeam = references ? chi2Of(noBeam) : -1.F;
+    const Scalar chi2Joint = references ? chi2Of(joint) : -1.F;
+    BoundTrackState start = step.state;
+    covarianceFromFactors(step.factors, start.cov);
+    const auto& truthRow = mTruth->rows[row];
+    std::size_t onLayer = 0U;
+    for (const auto at : mRowsOf.at(particle)) {
+      onLayer += mTruth->rows[at].layer == truthRow.layer ? 1U : 0U;
+    }
+    const auto found = mTruth->particles.find(particle);
+    const auto* segment = segmentOfRow(particle, frame, row);
+    double c0 = 0.;
+    double c1 = 0.;
+    double q0 = 0.;
+    double q1 = 0.;
+    double qn0 = 0.;
+    double qn1 = 0.;
+    double qj0 = 0.;
+    double qj1 = 0.;
+    double dphi = 0.;
+    double dtheta = 0.;
+    double hitP = 0.;
+    if (segment != nullptr) {
+      const auto local = crossingOn(*segment, plane);
+      c0 = static_cast<double>(measurement.loc0) - local[0];
+      c1 = static_cast<double>(measurement.loc1) - local[1];
+      q0 = static_cast<double>(predicted.loc0()) - local[0];
+      q1 = static_cast<double>(predicted.loc1()) - local[1];
+      qn0 = static_cast<double>(noBeam.loc0()) - local[0];
+      qn1 = static_cast<double>(noBeam.loc1()) - local[1];
+      qj0 = static_cast<double>(joint.loc0()) - local[0];
+      qj1 = static_cast<double>(joint.loc1()) - local[1];
+      const auto& p = segment->momentum;
+      hitP = std::hypot(p[0], p[1], p[2]);
+      dphi = std::remainder(static_cast<double>(predicted.phi()) - std::atan2(p[1], p[0]), 2. * std::numbers::pi);
+      dtheta = static_cast<double>(predicted.theta()) - std::atan2(std::hypot(p[0], p[1]), p[2]);
+    }
+    // The start against the truth there, and across the start's own stave:
+    // from entering the start's layer to entering the next one out.
+    const auto* startSegment = segmentOfRow(particle, frame, step.from);
+    double sdphi = 0.;
+    double sdtheta = 0.;
+    double staveTheta = 0.;
+    double stavePhi = 0.;
+    double staveTheta0 = 0.;
+    double staveX2x0 = 0.;
+    if (startSegment != nullptr) {
+      const auto& ps = startSegment->momentum;
+      sdphi = std::remainder(static_cast<double>(start.phi()) - std::atan2(ps[1], ps[0]), 2. * std::numbers::pi);
+      sdtheta = static_cast<double>(start.theta()) - std::atan2(std::hypot(ps[0], ps[1]), ps[2]);
+      // The stave beyond the start: the layer numbered one above (the
+      // class's barrel layers consecutive from the beam outward).
+      const auto next = ownRowOn(particle, static_cast<LayerID>(mTruth->rows[step.from].layer + 1U));
+      const auto* nextSegment = next == kNoTrack ? nullptr : segmentOfRow(particle, frame, next);
+      if (nextSegment != nullptr) {
+        std::tie(staveTheta, stavePhi) = kinksBetween(*startSegment, *nextSegment, static_cast<double>(propagator.bzKiloGauss));
+        std::tie(staveTheta0, staveX2x0) = theta0Between(material, propagator, *startSegment, *nextSegment, std::hypot(ps[0], ps[1], ps[2]));
+      }
+    }
+    *mCsv << std::format(
+      "{},{},{},{},{:.4f},{},{},{},{:.3f},{:.6g},{:.6g},{:.6g},{:.6g},{:.6g},{:.6g},{:.6g},{:.6g},{},{:.6g},{:.6g},{:.6g},{:.6g},{:.6g},{:.6g},"
+      "{:.6g},{:.6g},{:.4f},{:.4f},{},{:.6g},{:.6g},{:.6g},{:.6g},{:.6g},{:.6g},{:.6g},{:.6g},{},{:.3f},{:.6g},{:.6g},{:.6g},{:.6g},{:.3f},{:.6g},{:.6g},"
+      "{:.6g},{:.6g}\n",
+      kind, particle, iteration, static_cast<int>(truthRow.layer), found != mTruth->particles.end() ? found->second.pt : 0.F, found != mTruth->particles.end() ? found->second.pdg : 0, static_cast<int>(truthRow.count), onLayer, chi2, measurement.loc0 - predicted.loc0(), measurement.loc1 - predicted.loc1(), measurement.varLoc0, measurement.covLoc01, measurement.varLoc1, predicted.covAt(kLoc0, kLoc0), predicted.covAt(kLoc0, kLoc1), predicted.covAt(kLoc1, kLoc1), segment != nullptr ? 1 : 0, c0, c1, q0, q1, dphi, dtheta, predicted.covAt(kPhi, kPhi), predicted.covAt(kTheta, kTheta), hitP, 1. / std::abs(static_cast<double>(predicted.qOverP())), startSegment != nullptr ? 1 : 0, sdphi, sdtheta, start.covAt(kPhi, kPhi), start.covAt(kTheta, kTheta), staveTheta, stavePhi, staveTheta0, staveX2x0, references ? 1 : 0, chi2NoBeam, qn0, qn1, noBeam.covAt(kLoc0, kLoc0), noBeam.covAt(kLoc1, kLoc1), chi2Joint, qj0, qj1, joint.covAt(kLoc0, kLoc0), joint.covAt(kLoc1, kLoc1));
+  }
+
+  struct TrueKink {
+    std::uint32_t particle = 0U; ///< its index in mFindable
+    LayerID layer = 0;           ///< the inner of the two crossings
+    LayerID to = 0;              ///< the outer: the next layer of the mask the particle crossed (ML 4 -> C1 is one)
+    float p = 0.F;               ///< [GeV], entering it
+    float theta = 0.F;           ///< the theta kink over theta0
+    float phi = 0.F;             ///< the bending plane's
+    float x2x0 = 0.F;
+  };
+
+  const study::TrackingTruth* mTruth = nullptr;
+  std::uint64_t mMask = 0U;
+  double mMinPtGeV = 0.;
+  std::vector<std::uint64_t> mRoadLayers;
+  std::unordered_map<std::uint64_t, std::vector<std::uint32_t>> mRowsOf;
+  std::unordered_map<std::uint64_t, std::uint32_t> mIndex;
+  std::vector<std::uint64_t> mFindable;
+  std::vector<std::uint8_t> mFate;
+  std::vector<std::uint8_t> mReason;       ///< a Missed, for those not found
+  std::vector<std::uint8_t> mStop;         ///< a Short, for the short, from their iteration
+  std::vector<LayerID> mStopLayer;         ///< for the short with a stop decision, the layer it missed
+  std::vector<std::uint8_t> mStopTaken;    ///< for the short whose own row passed: `takenKind`
+  std::vector<std::uint8_t> mOutStop;      ///< for the short of an outer layer: the outward step's Short
+  std::vector<LayerID> mOutStopLayer;      ///< for those: the first outer layer it missed
+  std::vector<std::uint8_t> mOutStopTaken; ///< for those whose own row passed: `takenKind`
+  std::vector<std::uint8_t> mInNext;       ///< for an unconfirmed drop: the next step's outcome on the own row (`afterDrop`), inward
+  std::vector<std::uint8_t> mOutNext;      ///< the same outward
+  std::vector<std::uint8_t> mInDropKink;   ///< for an unconfirmed drop: the particle's true kink over that next step (<= 3 / 3-5 / > 5 theta0 / no hits), inward
+  std::vector<std::uint8_t> mOutDropKink;  ///< the same outward
+  std::vector<std::uint8_t> mOutStepKink;  ///< for the short of an outer layer: the particle's true kink over the step from the layer below the gap (binned as above)
+  std::vector<std::uint8_t> mInStepKink;   ///< for an inward unconfirmed drop: the true kink over the step that took the dropped row
+  std::vector<std::uint64_t> mLayersHeld;  ///< the good track's layers, a bit each (0: no good track), for `writeFates`
+  std::unique_ptr<std::ofstream> mWalkCsv; ///< --truth-walk: one line per step of the truth walks
+  /// The truth walks' predictions against the cluster, unselected, for the
+  /// robust summary: [inward, outward][target layer][pT bin].
+  struct WalkPulls {
+    std::vector<float> pull0;
+    std::vector<float> pull1;
+    std::size_t overGate = 0U; ///< the update's chi2 above the gate
+    std::size_t fails = 0U;    ///< the transport failed
+  };
+  static constexpr std::array<double, 4> kWalkPtEdges{0.2, 0.3, 0.6, 1.};
+  std::array<std::array<std::array<WalkPulls, kWalkPtEdges.size() + 1U>, kLayers>, 3> mWalkPulls{};
+  static constexpr std::array<const char*, 3> kWalkDirectionNames{"inward", "outward", "barrel to the rest"};
+  Scalar mWalkGate = 0.F;                            ///< the gate the truth walks were held to
+  std::size_t mDebugDrops = 0U;                      ///< unconfirmed drops whose next step saw the own row passing, dumped
+  std::vector<Scalar> mInChi2;                       ///< the own row's chi2 at the deciding step, inward
+  std::vector<Scalar> mOutChi2;                      ///< the same outward
+  std::vector<std::uint8_t> mOutRefitWrong;          ///< refit-chi2 stops: the outward rows kept not the particle's (0, 1, 2+), +3 with a kink step
+  std::vector<std::uint8_t> mOutRefitRows;           ///< and how many outward rows the refit took
+  std::vector<Scalar> mOutRefitRatio;                ///< and its chi2 over the cut
+  std::map<std::string, std::size_t> mRefitFailures; ///< refit-failed stops: status / pass / layer
+  std::map<std::string, std::size_t> mRefitReplay;   ///< and their failing step replayed (`FailedStep`)
+  /// The extended refit's inward increments by layer: the sum,
+  /// the count, those above 9.21 (2 dof, 1 %), and how often the layer's is
+  /// the track's largest.
+  struct Increments {
+    std::array<double, kLayers> sum{};
+    std::array<std::size_t, kLayers> count{};
+    std::array<std::size_t, kLayers> above{};
+    std::array<std::size_t, kLayers> largest{};
+    std::size_t tracks = 0U;
+  };
+  Increments mRefusedIncrements; ///< refit-chi2 stops, the rows all the particle's own
+  Increments mKeptIncrements;    ///< complete tracks the iteration followed outward, refit kept
+  void addIncrements(Increments& into, const Walk& replay)
+  {
+    ++into.tracks;
+    std::size_t top = 0U;
+    for (std::size_t i = 0; i < replay.refitCount; ++i) {
+      const auto layer = replay.refitLayer[i];
+      const auto increment = static_cast<double>(replay.refitIncrement[i]);
+      into.sum[layer] += increment;
+      ++into.count[layer];
+      into.above[layer] += increment > 9.21 ? 1U : 0U;
+      top = replay.refitIncrement[i] > replay.refitIncrement[top] ? i : top;
+    }
+    if (replay.refitCount != 0U) {
+      ++into.largest[replay.refitLayer[top]];
+    }
+  }
+  std::vector<std::uint8_t> mOutRefitKink;                            ///< and the largest true kink over the rows (<= 3 / 3-5 / > 5 theta0 / no hits)
+  std::vector<std::uint8_t> mOutHolder;                               ///< for those: who holds the own row on that layer at the end (`kHolderNames`)
+  std::vector<Scalar> mInNextChi2;                                    ///< for an unconfirmed drop: the own next row's chi2, inward
+  std::vector<Scalar> mOutNextChi2;                                   ///< the same outward
+  std::size_t mOutReplayed = 0U;                                      ///< outward walks replayed
+  Scalar mLastGate = 0.F;                                             ///< the last iteration's update gate, clusterChi2Max
+  std::size_t mOutAgree = 0U;                                         ///< of them, agreeing with the iteration's kept rows
+  std::array<std::size_t, 65> mLayersFound{};                         ///< good tracks of the findable, by the mask's layers they hold
+  std::array<std::array<std::size_t, 8>, 2> mWindowAudit{};           ///< window, not queried; by windowAudit's flags
+  std::array<std::array<std::size_t, 8>, 2> mOutWindowAudit{};        ///< the same of the outward stops
+  std::array<std::vector<std::array<float, 4>>, 2> mOutWindowOffsets; ///< their rows' offsets (`windowAudit`)
+  std::array<TripletTargetBounds, kLayers> mBounds{};                 ///< each layer's largest variances in the frame
+  mutable std::size_t mAuditDecisions = 0U;                           ///< the graph audit's triplet and neighbour decisions
+  mutable std::map<std::string, std::size_t> mCurvatureTriplets;      ///< the graph audit's curvature refusals by the triplet's layers
+  mutable std::map<std::string, std::size_t> mLinkRangeRefusals;      ///< the graph audit's link-range refusals by the link and the distance outside [cm], 1-cm bins
+  VertexSeed mBeamLine;                                               ///< the beam line the pair cut is held to (`setBeamLine`)
+  mutable std::map<std::string, std::size_t> mPairRefusals;           ///< the graph audit's pair refusals by the test, the link and the true kink
+  double mAuditFloor = 0.;                                            ///< the iteration's pT floor, for the pair refusals' split
+  std::vector<std::uint32_t> mTrackOffsets;                           ///< per iteration observed, its first track's index
+  std::map<std::string, std::size_t> mFakeHolders;                    ///< the not-found whose road rows a fake holds, by the fake's iteration
+  std::map<std::string, std::size_t> mRoadFitRefusals;                ///< the road fit's refusals of true roads, binned (`describeRefusedRoad`)
+  std::vector<std::uint8_t> mMissedKink;                              ///< for a particle not found: the largest true kink over its road's layers (binned as `kinkBin`)
+
+  mutable std::size_t mDebugTriplets = 0U;      ///< of them, dumped
+  mutable std::size_t mAuditDisagreements = 0U; ///< of them, those the stage's own cut decided otherwise
+  std::vector<std::uint8_t> mGraph;             ///< a Graph, for those not found for kNoRoad or kRoadTime
+  struct WalkSum {
+    std::size_t n = 0U;
+    double s0 = 0.;
+    double s1 = 0.;
+    std::size_t out0 = 0U;
+    std::size_t out1 = 0U;
+  };
+  /// truthWalk's pulls: [all, quiet, quiet and prompt][follow, clusters only, joint][target layer]
+  std::array<std::array<std::array<WalkSum, kLayers>, 3>, 3> mWalk{};
+  bool mWalkDone = false;
+  std::size_t mWalkIteration = 0U; ///< the iteration the truth walk runs on (`observe`)
+  std::vector<std::uint32_t> mMaxWidthPS;
+  SensorCells<Det> mCells; ///< the sensors by place, which the follow's hole test reads
+  std::size_t mReplayed = 0U;
+  std::size_t mAgree = 0U;
+  /// A replayed track's fidelity: as the iteration made it; a refused refit
+  /// where the iteration kept rows; otherwise not.
+  enum Fidelity : std::uint8_t { kUnfaithful,
+                                 kFaithful,
+                                 kRefusedKept };
+  struct FidelityCount {
+    std::size_t replayed = 0U;
+    std::size_t agree = 0U;
+    std::size_t refusedKept = 0U;
+  };
+  std::vector<std::array<FidelityCount, 2>> mFidelity;        ///< per iteration, its own tracks' replays and the earlier tracks' (`printFidelity`)
+  std::vector<std::string> mTransitionLines;                  ///< fakeTransitions', one per iteration
+  std::vector<std::uint8_t> mFollowUsedNow;                   ///< the mask the iteration's follow read
+  std::vector<std::string> mProgressLines;                    ///< progress', one per iteration
+  std::vector<double> mFloors;                                ///< each iteration's pT floor [GeV]
+  std::array<std::array<std::size_t, 2>, 21> mReach{};        ///< physical primaries in |eta| < 1 by 50 MeV of pT: all, on every layer
+  double mLowestPt = std::numeric_limits<double>::infinity(); ///< the lowest pT of one on every layer
+  std::vector<Snapshot> mSnapshot;                            ///< the tracks as the last iteration observed left them
+  std::vector<std::uint8_t> mSnapshotUsed;                    ///< and its mask
+  /// A kink step's refusals of the particle's row by its outcome
+  /// (StepOutcome, then not visited); its unconfirmed rows by what became
+  /// of their witness, the particle's next row [0] or the beam line [1]
+  /// (StepOutcome, not visited, no own next row).
+  static constexpr std::size_t kNotVisited = 6U;
+  static constexpr std::size_t kNoOwnNext = 7U;
+  std::vector<std::uint8_t> mStopDetail; ///< for kKinkRefused and kKinkUnconfirmed: the outcome, plus 8 for the beam line
+  std::unique_ptr<std::ofstream> mCsv;
+  std::unique_ptr<study::HitFile> mHits;
+  std::vector<std::vector<int>> mMothers;              ///< `openKine`'s: per MC event, each track's mother
+  std::map<std::string, ClutterTally> mClutter;        ///< `clutterStudy`'s, by iteration, pT, walk and layers
+  std::vector<DroppedWalks> mDroppedWalks;             ///< the observed iteration's dropped records' walks (`replayDropped`, for `clutterStudy`)
+  std::map<std::string, DecisionTally> mDecisions;     ///< `decisionStudy`'s, by population, iteration, pT, walk and layers
+  std::map<std::string, BlockerTally> mBlockers;       ///< `blockerStudy`'s, the last observed iteration's
+  std::vector<std::vector<std::uint32_t>> mLayerLower; ///< per layer: its rows' time boxes' starts, sorted (`layerOccupancy`)
+  std::vector<std::vector<std::uint32_t>> mLayerUpper; ///< and their ends
+  std::vector<double> mLayerArea;                      ///< per layer: its sensors' area [cm2]
+  /// Each MC track's segments, by `segmentKey`.
+  std::unordered_map<std::uint64_t, std::vector<const study::HitSegment*>> mSegmentsOf;
+  bool mPathOrdered = false;
+  /// Per findable: each row's leg in path order (`pathOrder`), parallel to its rows; whether its rows are in path order.
+  std::vector<std::vector<std::uint8_t>> mLegs;
+  std::vector<std::uint8_t> mTimed;
+  /// The path order's outcome, [not in the class, the class][timed as the distance had it, reordered, kept, first row on a layer changed].
+  std::array<std::array<std::size_t, 4>, 2> mPathCounts{};
+  std::string mPathLines;                                      ///< `pathReport`'s, the last iteration's
+  std::vector<std::vector<std::uint8_t>> mSeedStage;           ///< per iteration, per findable: a SeedStage
+  std::vector<std::uint8_t> mFurthest;                         ///< per findable: its furthest SeedStage over the iterations
+  std::vector<std::string> mRecordLoss;                        ///< per findable: `recordLosses`' verdict, its last record never selected
+  bool mKeepBeamLine = false;                                  ///< `keepBeamLine`
+  std::vector<BeamLineRow> mBeamLineRows;                      ///< `beamLineStudy`, every iteration
+  bool mKeepFollowLoss = false;                                ///< `keepFollowLoss`
+  std::vector<FollowLossRow> mFollowLossRows;                  ///< `followLoss`, every iteration
+  std::unordered_map<std::uint32_t, std::string> mLastDropWhy; ///< per findable: the last verdict of `replayDropped`
+  std::vector<std::uint32_t> mMinClusters;                     ///< per iteration: its seeds' length
+  std::vector<std::map<std::string, std::size_t>> mDropped;    ///< per iteration: `replayDropped`'s lines
+  /// `inwardStudy`'s: per kind and state, the truth
+  /// comparisons; the passes replayed and those the replay did not
+  /// reproduce; the failing passes from other seeds; the failing steps'
+  /// roots.
+  static constexpr std::size_t kInwardStepSlots = 6U;
+  struct InwardSlot {
+    std::vector<double> ratio, pullQOverP, dphi, pullPhi, relSigma;
+  };
+  std::array<std::array<InwardSlot, kInwardStepSlots>, kInwardKinds> mInwardSteps{};
+  std::array<std::size_t, kInwardKinds> mInwardCount{};
+  std::array<std::size_t, kInwardKinds> mInwardMismatch{};
+  std::array<std::array<std::size_t, 4>, kSeedNames.size()> mSeedOutcomes{};
+  std::map<std::string, std::size_t> mRoots;
+  /// `ruleStudy`'s, per kind, rule and seed.
+  std::array<std::array<std::array<RuleTally, kRuleSeedNames.size()>, kCrossingRules.size()>, kInwardKinds> mRuleTallies{};
+  std::unique_ptr<std::ofstream> mInwardCsv;
+  std::unique_ptr<std::ofstream> mEndCsv;  ///< `endDecisions`' CSV
+  std::unique_ptr<std::ofstream> mEditCsv; ///< and its end edits'
+  std::array<std::array<std::size_t, 2>, kInwardKinds> mChargeAgree{};
+  /// Per kind and step, the step's crossing [disc, the solve's the particle's, the other the particle's, none].
+  std::array<std::array<std::array<std::size_t, 4>, kInwardStepSlots>, kInwardKinds> mStepRoots{};
+  std::map<std::string, std::size_t> mStepRootDetail;
+  bool mKinksDone = false;
+  std::vector<TrueKink> mKinks;
+  std::vector<std::uint32_t> mKinkBegin;                                                                  ///< particle index -> its first kink in mKinks (grouped by particle), one past the end last
+  std::unique_ptr<o2::gtrk::detail::TaskArena> mArena = std::make_unique<o2::gtrk::detail::TaskArena>(0); ///< the replays' and the truth walks' threads
+  /// Timings of the phases of `observe`, printed per iteration [s].
+  struct Phases {
+    double kinks = 0.;
+    double walk = 0.;
+    double replay = 0.;
+    double diagnosis = 0.;
+  };
+  std::vector<std::uint64_t> mEvaluated;
+  std::vector<std::uint64_t> mCrossed; ///< per findable, the layers with a crossing (one row per layer, the first)
+  std::vector<bool> mRepeated;
+  std::size_t mMissingSegment = 0U;
+  std::size_t mZeroMaterial = 0U;
+};
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_COMPLETEANATOMY_H_
diff --git a/Detectors/GenericTracking/study/tools/FitInputs.h b/Detectors/GenericTracking/study/tools/FitInputs.h
new file mode 100644
index 0000000000000..c30782e153285
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/FitInputs.h
@@ -0,0 +1,126 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file FitInputs.h
+/// \brief The triplet and neighbour fits' inputs, as o2-gtrk-track-bench
+///        writes them for o2-gtrk-fit-bench.
+///
+/// One record per accepted triplet and per accepted neighbour of a run: the
+/// measurements the fit reads and the scattering variances already taken from
+/// the iteration's table, so that the fit needs no detector. A triplet carries
+/// the curvature and its variance the stage stored, which the fit bench checks
+/// bit for bit, and each record the chi2 bound it passed. The file is raw and
+/// native-endian, like the tracking input, and rests on the records' layouts
+/// (`PairPoint`'s among them): the magic changes with any of them, and a new
+/// run of the bench is the only migration, as for the dumps.
+
+#ifndef GTRK_STUDY_FITINPUTS_H_
+#define GTRK_STUDY_FITINPUTS_H_
+
+#include "GenericTracking/Tracking/PairCut.h"
+
+#include <array>
+#include <cstdint>
+#include <fstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+struct TripletFitInput {
+  PairPoint first;
+  PairPoint middle;
+  PairPoint third;
+  Scalar variance = 0.F; ///< the space-angle scattering variance at the middle (`tripletScattering`)
+  Scalar chi2Max = 0.F;  ///< the stage's bound on the fit's chi2
+  Scalar curvature = 0.F;
+  Scalar varCurvature = 0.F;
+  std::uint32_t iteration = 0U;
+};
+
+struct NeighbourFitInput {
+  PairPoint a;
+  PairPoint b;
+  PairPoint c;
+  PairPoint d;
+  Scalar varianceSecond = 0.F; ///< at `b`, from `a -> c`
+  Scalar varianceThird = 0.F;  ///< at `c`, from `b -> d`
+  Scalar covariance = 0.F;     ///< of the two, from a passive scatterer between `b` and `c`
+  Scalar chi2Max = 0.F;        ///< the stage's bound on the fit's chi2
+  std::uint32_t iteration = 0U;
+};
+
+struct FitInputs {
+  std::vector<TripletFitInput> triplets;
+  std::vector<NeighbourFitInput> neighbours;
+};
+
+namespace fit_inputs_detail
+{
+constexpr std::array<char, 8> kFitInputsMagic{'G', 'T', 'R', 'K', 'F', 'I', 'T', '2'};
+static_assert(std::is_trivially_copyable_v<TripletFitInput> && std::is_trivially_copyable_v<NeighbourFitInput>);
+
+/// A stream's view of an object's bytes.
+[[nodiscard]] inline const char* bytesOf(const void* data) { return static_cast<const char*>(data); }
+[[nodiscard]] inline char* bytesOf(void* data) { return static_cast<char*>(data); }
+
+template <typename T>
+void writeVector(std::ofstream& out, const std::vector<T>& values)
+{
+  const auto count = static_cast<std::uint64_t>(values.size());
+  out.write(bytesOf(&count), sizeof(count));
+  out.write(bytesOf(values.data()), static_cast<std::streamsize>(values.size() * sizeof(T)));
+}
+
+template <typename T>
+void readVector(std::ifstream& in, std::vector<T>& values)
+{
+  std::uint64_t count = 0U;
+  in.read(bytesOf(&count), sizeof(count));
+  values.resize(count);
+  in.read(bytesOf(values.data()), static_cast<std::streamsize>(count * sizeof(T)));
+}
+} // namespace fit_inputs_detail
+
+inline void writeFitInputs(const std::string& path, const FitInputs& inputs)
+{
+  std::ofstream out{path, std::ios::binary | std::ios::trunc};
+  out.write(fit_inputs_detail::kFitInputsMagic.data(), fit_inputs_detail::kFitInputsMagic.size());
+  fit_inputs_detail::writeVector(out, inputs.triplets);
+  fit_inputs_detail::writeVector(out, inputs.neighbours);
+  if (!out) {
+    throw std::runtime_error("fit inputs: cannot write " + path);
+  }
+}
+
+[[nodiscard]] inline FitInputs readFitInputs(const std::string& path)
+{
+  std::ifstream in{path, std::ios::binary};
+  std::array<char, 8> magic{};
+  in.read(magic.data(), magic.size());
+  if (!in || magic != fit_inputs_detail::kFitInputsMagic) {
+    throw std::runtime_error("fit inputs: " + path + " is not a fit-input file");
+  }
+  FitInputs inputs;
+  fit_inputs_detail::readVector(in, inputs.triplets);
+  fit_inputs_detail::readVector(in, inputs.neighbours);
+  if (!in) {
+    throw std::runtime_error("fit inputs: " + path + " is short");
+  }
+  return inputs;
+}
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_FITINPUTS_H_
diff --git a/Detectors/GenericTracking/study/tools/FollowAnatomy.h b/Detectors/GenericTracking/study/tools/FollowAnatomy.h
new file mode 100644
index 0000000000000..5a4f38e097ee9
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/FollowAnatomy.h
@@ -0,0 +1,498 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file FollowAnatomy.h
+/// \brief The follow's steps on correct roads, against the truth: a bench
+///        observer.
+///
+/// After each iteration with the follow, every one of its tracks whose rows
+/// before the follow are all one particle's -- a correct road -- is followed
+/// again, outward and inward, from the states the follow started from and
+/// with the used mask as the follow read it (the tracker's copy). The replay
+/// must propose what the tracking proposed: the rows the track kept are a
+/// prefix of the replay's in each direction. Each step is recorded: the
+/// targets in their order, the free rows in each window with their chi2, the
+/// kink pass and the row taken.
+///
+/// Per track and direction (0 outward, 1 inward) an `F` line: iteration,
+/// track, the particle, its pT, the rows before the follow, the direction,
+/// the rows the replay proposed, kept, of them wrong, whether the kept rows
+/// are a prefix of the replay's (1), the first wrong step (-1 for none), its
+/// class, how the direction ended, and the wrong rows proposed. Per step an
+/// `S` line: iteration, track, direction, step, the layer it took a row on
+/// (-1 for none), whether it took one, that row's chi2, whether it is the
+/// particle's, the rows passing the gate on that layer, the particle's own
+/// row there (its chi2, -1 where the step did not see one), the class of the
+/// step (`kClassNames`), whether a kink step took it, the rows the lookahead ranked
+/// (`lookaheadConfirmation`; 0 where one passed, or in a greedy pass),
+/// whether the row taken was confirmed there (1, 0; -1 not ranked) and
+/// whether the particle's own row on that layer was (1, 0; -1 not ranked or
+/// none passing the gate). After each `S`
+/// line a `Q` line per layer the step targeted that holds a row of the
+/// particle: iteration, track, direction, step, the layer, whether
+/// that row is free, then for the row predicted from the step's own state
+/// (the best of the particle's rows there, by chi2) its chi2, its two pulls,
+/// the prediction's two widths and the row's two errors [cm] (NaN where the
+/// prediction fails).
+///
+/// `--follow-stops` prints, at the end, why the directions of the correct
+/// roads ended (`printStops`).
+
+#ifndef GTRK_STUDY_FOLLOWANATOMY_H_
+#define GTRK_STUDY_FOLLOWANATOMY_H_
+
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/Follow.h"
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Tracking/SensorCells.h"
+#include "GenericTracking/Tracking/SlicePlan.h"
+#include "GenericTracking/Tracking/TrackFitter.h"
+#include "GenericTracking/Study/TrackComparison.h"
+#include "GenericTracking/Study/TrackingInput.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <format>
+#include <fstream>
+#include <iostream>
+#include <limits>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+/// What a step that took a row did, against its particle's own rows:
+/// - own: it took the particle's row;
+/// - swap: the particle's row on that layer passed the gate and lost;
+/// - refused: the particle's free row on that layer was seen, above the gate;
+/// - not in window: the particle has a free row on that layer, not seen;
+/// - refused nearer: the particle's free row was on a nearer target the step
+///   searched first and did not take;
+/// - held: the particle's row on that layer is another track's;
+/// - filled hole: no row of the particle on that layer, but free ones further
+///   along;
+/// - past the end: no FREE row of the particle further along -- none, or only
+///   rows other tracks hold.
+/// "Further along" is a larger r^2 + z^2 than the direction's last row so far
+/// outward, a smaller one inward: a proxy for the rows ahead, wrong for a
+/// particle that turns back.
+enum class StepClass : std::uint8_t { kOwn,
+                                      kSwap,
+                                      kRefused,
+                                      kNotInWindow,
+                                      kRefusedNearer,
+                                      kHeld,
+                                      kFilledHole,
+                                      kPastEnd,
+                                      kCount };
+inline constexpr const char* kClassNames[] = {"own", "swap", "refused", "not-in-window", "refused-nearer", "held", "filled-hole", "past-end"};
+
+/// `FollowEnd`'s names: no target, the holes, no row (gaps), the capacity;
+/// with dashes, a word each, for the `F` lines split at whitespace.
+inline constexpr const char* kEndNames[] = {"no-target", "holes", "no-row", "capacity"};
+
+template <DetectorLayout Det, typename Material>
+class FollowAnatomy
+{
+ public:
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  using Proposal = FollowProposal<kMaxClusters>;
+
+  /// Steps into \a path, none where it is empty (`--follow-stops` alone).
+  FollowAnatomy(const std::string& path, const study::TrackingTruth& truth) : mPath(path), mTruth(&truth)
+  {
+    if (!mPath.empty()) {
+      mOut.open(mPath);
+      if (!mOut) {
+        throw std::runtime_error("cannot write " + path);
+      }
+    }
+    mRowsOf = study::rowsOfParticles(truth.rows);
+  }
+
+  /// One iteration of the tracking, seen by its observer.
+  template <typename Observation>
+  void observe(const Observation& iteration, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    // One run's steps: a repetition writes its own from the start.
+    if (iteration.iteration == 0U) {
+      if (!mPath.empty()) {
+        mOut.close();
+        mOut.open(mPath);
+      }
+      mStops = {};
+      mReplayed = 0U;
+      mAgree = 0U;
+    }
+    if (iteration.followStart.empty()) {
+      return;
+    }
+    if (mCells.empty()) {
+      mCells = SensorCells<Det>(geometry);
+      mWidths = frameBounds(frame).widthPS;
+    }
+    if (parameters.followEnd) {
+      throw std::runtime_error("--follow-steps and --follow-stops cannot replay an iteration with iterationFollowEnd");
+    }
+    // The follow as the iteration ran it: the beam line, the greedy choice
+    // and the end decisions on the density and the beam line.
+    withBools(
+      [&]<bool BeamLine, bool Greedy, bool EndDensity, bool BeamEnd>(std::bool_constant<BeamLine>, std::bool_constant<Greedy>, std::bool_constant<EndDensity>, std::bool_constant<BeamEnd>) {
+        if constexpr (BeamLine || !BeamEnd) {
+          replay<BeamLine, Greedy, EndDensity, BeamEnd>(iteration, parameters, frame, geometry, material, propagator);
+        }
+      },
+      parameters.beamConstraint, parameters.followGreedy, Follow<Det>::endDensity(parameters), parameters.followBeamEnd);
+  }
+
+  /// Why the directions of the correct roads ended (`--follow-stops`): per
+  /// direction and end, the follows whose particle still had a free row
+  /// further along, and those without; and how many replays agreed with the
+  /// tracking.
+  void printStops() const
+  {
+    std::cout << std::format("follow stops of the correct roads: {} replayed, {} agree with the tracking\n", mReplayed, mAgree);
+    for (std::size_t direction = 0; direction < 2U; ++direction) {
+      std::string line = std::format("  {}: end (particle's free row further along / none):", direction == 0U ? "outward" : "inward");
+      for (std::size_t end = 0; end < mStops[direction].size(); ++end) {
+        line += std::format(" {} {}/{}", kEndNames[end], mStops[direction][end][1], mStops[direction][end][0]);
+      }
+      std::cout << line << '\n';
+    }
+  }
+
+ private:
+  struct Candidate {
+    LayerID layer = 0;
+    std::uint32_t row = 0;
+    Scalar chi2 = 0.F;
+  };
+  struct Step {
+    std::size_t direction = 0U; ///< 0 outward, 1 inward
+    BoundTrackState state;
+    CovarianceFactors factors;
+    std::vector<LayerID> targets;
+    std::vector<Candidate> candidates;
+    std::uint32_t taken = ClusterList<kMaxClusters>::kNoCluster;
+    Scalar chi2 = 0.F;
+    bool kinked = false;
+    /// The lookahead's confirmations (`lookaheadConfirmation`): each passing row it
+    /// ranked, and whether a row of the next step confirmed it.
+    std::vector<std::pair<std::uint32_t, bool>> confirmations;
+  };
+  struct Recorder {
+    std::vector<Step> steps;
+    std::size_t direction = 0U;
+    std::array<FollowEnd, 2> end{FollowEnd::kCapacity, FollowEnd::kCapacity};
+  };
+  /// The stage's observer, writing into a recorder.
+  struct Observer : follow::NoObserver {
+    Recorder* recorder = nullptr;
+    void begin(PropagationDirection direction) const { recorder->direction = direction == PropagationDirection::kForward ? 0U : 1U; }
+    void step(LayerID /*layer*/, const BoundTrackState& state, const CovarianceFactors& factors, std::uint32_t /*rows*/) const
+    {
+      auto& step = recorder->steps.emplace_back();
+      step.direction = recorder->direction;
+      step.state = state;
+      step.factors = factors;
+    }
+    void target(LayerID layer, const CandidateWindow& /*window*/) const { recorder->steps.back().targets.push_back(layer); }
+    /// The rows the update was made for, its chi2 (infinity where it failed).
+    void candidate(LayerID layer, std::uint32_t row, StepOutcome outcome, Scalar chi2) const
+    {
+      if (outcome == StepOutcome::kUsed || outcome == StepOutcome::kOutsideWindow || outcome == StepOutcome::kHole) {
+        return;
+      }
+      const Scalar seen = outcome == StepOutcome::kNoUpdate ? std::numeric_limits<Scalar>::infinity() : chi2;
+      recorder->steps.back().candidates.push_back({.layer = layer, .row = row, .chi2 = seen});
+    }
+    void lookaheadConfirmation(std::uint32_t row, Scalar /*chi2*/, std::uint32_t next, Scalar /*nextChi2*/) const { recorder->steps.back().confirmations.emplace_back(row, next != ClusterList<kMaxClusters>::kNoCluster); }
+    void taken(std::uint32_t row, Scalar chi2, bool kinked) const
+    {
+      recorder->steps.back().taken = row;
+      recorder->steps.back().chi2 = chi2;
+      recorder->steps.back().kinked = kinked;
+    }
+    void end(FollowEnd why) const { recorder->end[recorder->direction] = why; }
+  };
+
+  /// What a track's checks read.
+  struct Context {
+    std::size_t iteration = 0U;
+    std::uint32_t track = 0U;
+    std::uint64_t particle = 0U;
+    const IterationParameters<Det>* parameters = nullptr;
+    const TimeFrame<Det>* frame = nullptr;
+    const TrackingGeometry<Det>* geometry = nullptr;
+    const Material* material = nullptr;
+    const Propagator* propagator = nullptr;
+    const std::vector<std::uint8_t>* used = nullptr;
+  };
+
+  /// The iteration's follow again, with \a BeamLine, \a Greedy,
+  /// \a EndDensity and \a BeamEnd as it ran.
+  template <bool BeamLine, bool Greedy, bool EndDensity, bool BeamEnd, typename Observation>
+  void replay(const Observation& iteration, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    const auto view = std::as_const(*iteration.tracks).view();
+    const auto trackCount = static_cast<std::uint32_t>(std::min(iteration.followStart.size(), iteration.proposals.size()));
+    // The mask as the follow read it: the tracker's copy, taken with the
+    // starting states.
+    std::vector<std::uint8_t> used(iteration.followUsed.begin(), iteration.followUsed.end());
+    const FollowStage<Det, Material, BeamLine, false, Greedy, EndDensity, BeamEnd> stage{&parameters, &frame, &geometry, &material, propagator, view, used.data(), mWidths.data(), mCells.view(), nullptr, nullptr, parameters.sharedInnermost == 0U, iteration.trackOffset};
+    for (std::uint32_t i = 0; i < trackCount; ++i) {
+      const auto track = iteration.trackOffset + i;
+      if (view.status[track] != PropagationStatus::kOk) {
+        continue;
+      }
+      // The road: the track's rows less the follow's, inward ones first.
+      const auto& kept = iteration.proposals[i];
+      const std::uint32_t before = iteration.followStartCount[i];
+      ClusterList<kMaxClusters> road;
+      std::ranges::fill(road.index, ClusterList<kMaxClusters>::kNoCluster);
+      for (std::uint32_t at = 0; at < before; ++at) {
+        road.index[at] = view.clusters[track].index[kept.inwardCount + at];
+      }
+      const auto particle = study::goodParticle(mTruth->rows, std::span<const std::uint32_t>{road.index, before});
+      if (particle == study::kNoTrackParticle) {
+        continue;
+      }
+      Recorder recorder;
+      Proposal proposal;
+      std::ranges::fill(proposal.outward, ClusterList<kMaxClusters>::kNoCluster);
+      std::ranges::fill(proposal.inward, ClusterList<kMaxClusters>::kNoCluster);
+      follow::KinkSteps steps;
+      stage.follow(iteration.followStartInner[i], iteration.followStart[i], road, before, proposal, steps, Observer{{}, &recorder});
+      const Context context{
+        .iteration = iteration.iteration,
+        .track = track,
+        .particle = particle,
+        .parameters = &parameters,
+        .frame = &frame,
+        .geometry = &geometry,
+        .material = &material,
+        .propagator = &propagator,
+        .used = &used,
+      };
+      const bool agrees = write(context, road, before, kept, proposal, recorder);
+      ++mReplayed;
+      mAgree += agrees ? 1U : 0U;
+    }
+  }
+
+  /// The prediction of \a row from \a state and \a factors in \a direction:
+  /// the update's chi2, the two pulls on the row's own plane, the
+  /// prediction's two widths and the row's two errors; NaN where it fails.
+  [[nodiscard]] std::array<Scalar, 7> predict(const Context& context, const BoundTrackState& state, const CovarianceFactors& factors, std::uint32_t row, PropagationDirection direction) const
+  {
+    constexpr Scalar kNaN = std::numeric_limits<Scalar>::quiet_NaN();
+    std::array<Scalar, 7> result{};
+    result.fill(kNaN);
+    const auto measurement = measurementAt(*context.frame, row);
+    BoundTrackState updated;
+    CovarianceFactors updatedFactors;
+    Scalar chi2 = 0.F;
+    if (follow::updateCandidate<false>(*context.propagator, *context.geometry, *context.material, measurement, direction, state, factors, updated, updatedFactors, chi2, 1.F)) {
+      result[0] = chi2;
+    }
+    BoundTrackState predicted;
+    CovarianceFactors predictedFactors;
+    if (follow::transportCandidate<false>(*context.propagator, *context.geometry, *context.material, context.geometry->planeOf(measurement), direction, state, factors, predicted, predictedFactors, 1.F)) {
+      covarianceFromFactors(predictedFactors, predicted.cov);
+      result[1] = (measurement.loc0 - predicted.loc0()) / std::sqrt(predicted.variance(kLoc0) + measurement.varLoc0);
+      result[2] = (measurement.loc1 - predicted.loc1()) / std::sqrt(predicted.variance(kLoc1) + measurement.varLoc1);
+      result[3] = std::sqrt(predicted.variance(kLoc0));
+      result[4] = std::sqrt(predicted.variance(kLoc1));
+      result[5] = std::sqrt(measurement.varLoc0);
+      result[6] = std::sqrt(measurement.varLoc1);
+    }
+    return result;
+  }
+
+  [[nodiscard]] Scalar distance2(std::uint32_t row) const
+  {
+    const auto& at = mTruth->rows[row];
+    return (at.r * at.r) + (at.z * at.z);
+  }
+
+  /// The `S` and `F` lines of a track's replay and its stops; whether the
+  /// rows the tracking kept are a prefix of the replay's in both directions.
+  bool write(const Context& context, const ClusterList<kMaxClusters>& road, std::uint32_t before, const Proposal& kept, const Proposal& proposal, const Recorder& recorder)
+  {
+    const auto& truthRows = mTruth->rows;
+    const auto owns = [&](std::uint32_t row) { return truthRows[row].carries(context.particle); };
+    const auto found = mTruth->particles.find(context.particle);
+    bool agrees = true;
+    for (std::size_t direction = 0; direction < 2U; ++direction) {
+      const bool outward = direction == 0U;
+      const std::uint32_t* proposed = outward ? proposal.outward : proposal.inward;
+      const std::uint32_t proposedCount = outward ? proposal.outwardCount : proposal.inwardCount;
+      const std::uint32_t* keptRows = outward ? kept.outward : kept.inward;
+      const std::uint32_t keptCount = outward ? kept.outwardCount : kept.inwardCount;
+      bool prefix = keptCount <= proposedCount;
+      std::uint32_t keptWrong = 0U;
+      for (std::uint32_t i = 0; i < keptCount; ++i) {
+        prefix = prefix && proposed[i] == keptRows[i];
+        keptWrong += owns(keptRows[i]) ? 0U : 1U;
+      }
+      agrees = agrees && prefix;
+      // The reach so far: the road's outermost (innermost) row, then each
+      // taken one.
+      Scalar reached = outward ? 0.F : std::numeric_limits<Scalar>::max();
+      for (std::uint32_t i = 0; i < before; ++i) {
+        reached = outward ? std::max(reached, distance2(road.index[i])) : std::min(reached, distance2(road.index[i]));
+      }
+      int firstWrong = -1;
+      auto firstClass = StepClass::kOwn;
+      std::size_t k = 0U;
+      for (const auto& step : recorder.steps) {
+        if (step.direction != direction) {
+          continue;
+        }
+        int takenLayer = -1;
+        bool takenOwn = false;
+        std::uint32_t passing = 0U;
+        Scalar ownChi2 = -1.F;
+        std::uint32_t ownRow = ClusterList<kMaxClusters>::kNoCluster;
+        auto stepClass = StepClass::kOwn;
+        if (step.taken != ClusterList<kMaxClusters>::kNoCluster) {
+          takenLayer = truthRows[step.taken].layer;
+          takenOwn = owns(step.taken);
+          for (const auto& candidate : step.candidates) {
+            if (candidate.layer != takenLayer) {
+              continue;
+            }
+            passing += candidate.chi2 <= context.parameters->clusterChi2Max ? 1U : 0U;
+            if (owns(candidate.row) && (ownChi2 < 0.F || candidate.chi2 < ownChi2)) {
+              ownChi2 = candidate.chi2;
+              ownRow = candidate.row;
+            }
+          }
+          if (!takenOwn) {
+            stepClass = classify(step, takenLayer, ownChi2, outward, reached, *context.used, *context.parameters, context.particle);
+            if (firstWrong < 0) {
+              firstWrong = static_cast<int>(k);
+              firstClass = stepClass;
+            }
+          }
+          reached = outward ? std::max(reached, distance2(step.taken)) : std::min(reached, distance2(step.taken));
+        }
+        if (!mPath.empty()) {
+          const auto ranked = std::ranges::find(step.confirmations, step.taken, &std::pair<std::uint32_t, bool>::first);
+          const int confirmed = ranked == step.confirmations.end() ? -1 : (ranked->second ? 1 : 0);
+          const auto ownRanked = std::ranges::find(step.confirmations, ownRow, &std::pair<std::uint32_t, bool>::first);
+          const int ownConfirmed = ownRow == ClusterList<kMaxClusters>::kNoCluster || ownRanked == step.confirmations.end() ? -1 : (ownRanked->second ? 1 : 0);
+          mOut << std::format("S {} {} {} {} {} {} {:.4f} {} {} {:.4f} {} {} {} {} {}\n", context.iteration, context.track, direction, k, takenLayer, step.taken == ClusterList<kMaxClusters>::kNoCluster ? 0 : 1, static_cast<double>(step.chi2), takenOwn ? 1 : 0, passing, static_cast<double>(ownChi2), kClassNames[static_cast<std::size_t>(stepClass)], step.kinked ? 1 : 0, step.confirmations.size(), confirmed, ownConfirmed);
+          writePredictions(context, step, k);
+        }
+        ++k;
+      }
+      std::uint32_t proposedWrong = 0U;
+      for (std::uint32_t i = 0; i < proposedCount; ++i) {
+        proposedWrong += owns(proposed[i]) ? 0U : 1U;
+      }
+      const auto end = recorder.end[direction];
+      if (k != 0U) {
+        const bool beyond = std::ranges::any_of(mRowsOf[context.particle], [&](std::uint32_t row) { return (*context.used)[row] == kFree && (outward ? distance2(row) > reached : distance2(row) < reached); });
+        ++mStops[direction][static_cast<std::size_t>(end)][beyond ? 1U : 0U];
+      }
+      if (!mPath.empty()) {
+        mOut << std::format("F {} {} {} {:.4f} {} {} {} {} {} {} {} {} {} {}\n", context.iteration, context.track, context.particle, found != mTruth->particles.end() ? static_cast<double>(found->second.pt) : 0., before, direction, proposedCount, keptCount, keptWrong, prefix ? 1 : 0, firstWrong, kClassNames[static_cast<std::size_t>(firstClass)], kEndNames[static_cast<std::size_t>(end)], proposedWrong);
+      }
+    }
+    return agrees;
+  }
+
+  /// The `Q` lines of step \a k: per layer it targeted, the particle's row
+  /// there predicted from the step's own state (`predict`), the best by chi2.
+  void writePredictions(const Context& context, const Step& step, std::size_t k)
+  {
+    const auto direction = step.direction == 0U ? PropagationDirection::kForward : PropagationDirection::kBackward;
+    for (const auto target : step.targets) {
+      std::array<Scalar, 7> best{};
+      std::uint32_t bestRow = ClusterList<kMaxClusters>::kNoCluster;
+      for (const auto row : mRowsOf[context.particle]) {
+        if (mTruth->rows[row].layer != target) {
+          continue;
+        }
+        const auto prediction = predict(context, step.state, step.factors, row, direction);
+        if (bestRow == ClusterList<kMaxClusters>::kNoCluster || prediction[0] < best[0]) {
+          best = prediction;
+          bestRow = row;
+        }
+      }
+      if (bestRow == ClusterList<kMaxClusters>::kNoCluster) {
+        continue;
+      }
+      mOut << std::format("Q {} {} {} {} {} {} {:.4g} {:.4g} {:.4g} {:.4g} {:.4g} {:.4g} {:.4g}\n", context.iteration, context.track, step.direction, k, static_cast<int>(target), (*context.used)[bestRow] == kFree ? 1 : 0, static_cast<double>(best[0]), static_cast<double>(best[1]), static_cast<double>(best[2]), static_cast<double>(best[3]), static_cast<double>(best[4]), static_cast<double>(best[5]), static_cast<double>(best[6]));
+    }
+  }
+
+  /// The class of a step that took a row not of the particle (`StepClass`).
+  [[nodiscard]] StepClass classify(const Step& step, int takenLayer, Scalar ownChi2, bool outward, Scalar reached, const std::vector<std::uint8_t>& used, const IterationParameters<Det>& parameters, std::uint64_t particle) const
+  {
+    if (!(ownChi2 < 0.F)) {
+      return ownChi2 <= parameters.clusterChi2Max ? StepClass::kSwap : StepClass::kRefused;
+    }
+    // The targets searched up to the taken one, in their order.
+    const auto upTo = std::ranges::find(step.targets, static_cast<LayerID>(takenLayer));
+    bool ownFreeOnTaken = false;
+    bool ownHeldOnTaken = false;
+    bool ownFreeNearer = false;
+    bool ownFreeBeyond = false;
+    for (const auto row : mRowsOf.at(particle)) {
+      if (outward ? !(distance2(row) > reached) : !(distance2(row) < reached)) {
+        continue;
+      }
+      const LayerID layer = mTruth->rows[row].layer;
+      const bool free = used[row] == kFree;
+      ownFreeBeyond = ownFreeBeyond || free;
+      if (std::cmp_equal(layer, takenLayer)) {
+        (free ? ownFreeOnTaken : ownHeldOnTaken) = true;
+      } else if (free && std::find(step.targets.begin(), upTo, layer) != upTo) {
+        ownFreeNearer = true;
+      }
+    }
+    if (ownFreeNearer) {
+      return StepClass::kRefusedNearer;
+    }
+    if (ownFreeOnTaken) {
+      return StepClass::kNotInWindow;
+    }
+    if (ownHeldOnTaken) {
+      return StepClass::kHeld;
+    }
+    return ownFreeBeyond ? StepClass::kFilledHole : StepClass::kPastEnd;
+  }
+
+  std::string mPath;
+  std::ofstream mOut;
+  const study::TrackingTruth* mTruth = nullptr;
+  std::unordered_map<std::uint64_t, std::vector<std::uint32_t>> mRowsOf;
+  SensorCells<Det> mCells;
+  std::array<std::uint32_t, static_cast<std::size_t>(Detector<Det>::nLayers)> mWidths{};
+  /// Per direction and end, the follows whose particle had no free row
+  /// further along, and those that had one.
+  std::array<std::array<std::array<std::uint64_t, 2>, 4>, 2> mStops{};
+  std::uint64_t mReplayed = 0U;
+  std::uint64_t mAgree = 0U;
+};
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_FOLLOWANATOMY_H_
diff --git a/Detectors/GenericTracking/study/tools/SeedingStrategy.h b/Detectors/GenericTracking/study/tools/SeedingStrategy.h
new file mode 100644
index 0000000000000..f48bb1f3b37db
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/SeedingStrategy.h
@@ -0,0 +1,759 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file SeedingStrategy.h
+/// \brief The truth-removal seeding study: the configured iterations as
+///        seeding passes, each on the rows the earlier passes' seeded
+///        particles left, scored against the MC truth.
+///
+/// A pass is an iteration's graph alone (`Tracker::runGraph`): tracklets to
+/// the numbered roads, with no road fit, selection, refit or follow. A road
+/// seeds every particle all of its rows carry among their labels (the one
+/// truth rule, as the funnel's `forEachOwner`); a road no particle owns is
+/// impure. After the pass every row of every particle it seeded is held
+/// exclusively -- a perfect follow -- whatever the particle's origin, and the
+/// next pass runs on what is left. Without removal every pass reads the whole
+/// frame (the check against the real run's first iteration).
+///
+/// The denominator is the score's `originFindable` population of physical
+/// primaries (`isFindable`: a chain of `minLayers` layers, the score's pT
+/// floor), counted at each of the study's pT steps -- or, by the study's
+/// population, the findable decay daughters, or only those of a K0S or a
+/// hyperon. Coverage is cumulative:
+/// the share of the findable at or above a step that some pass so far seeded.
+/// Per pass: the graph's sizes (tracklets, triplets, neighbours, roads; the
+/// triplet and neighbour fits in a counters build), its wall time and pool
+/// peak, the impure roads, the owners per seeded particle (the multiplicity),
+/// the particles seeded by origin, the pass's own gain and the cumulative
+/// coverage by class at its floor -- the barrel, the discs on one side by the
+/// sign of their z, both sides -- the layer patterns of the findable at or
+/// above that floor still unseeded, and what the rows left free are: noise,
+/// the findable's, other particles' at or above the lowest step,
+/// or only particles below it.
+///
+/// A shadow pass runs on the same free rows as the
+/// pass after it and holds nothing: what it seeds and the next pass does not,
+/// and the reverse, are the two settings' differences on identical rows, each
+/// with the other's mechanism -- the particle's rows inside a road with
+/// foreign rows (at least the pass's minimum of its own), only partly in a
+/// road, in none, or (with the fit) in a pure road the fit refused. With the
+/// fit, a particle is seeded by an accepted road
+/// fit record all of whose rows carry it (`Tracker::runGraph`'s fit), and the
+/// findable with a pure road but no pure record are counted by the length of
+/// their longest pure road, and by why the fit refuses that road
+/// (`roadFitRefusal`, the road fit stage's tests replayed).
+///
+/// After a real run's first iterations (`startAfter`): their
+/// good tracks seed their particles before the first pass, and every pass
+/// starts from the used mask they left, so that the passes are judged on the
+/// rows such a run leaves to an appended iteration.
+///
+/// A real run's iterations are scored the same way (`observeReal`): each
+/// iteration's good tracks (O2's rule, `goodParticle`) seed their particles, the used mask after it is the held rows, and the
+/// gap to truth removal is counted -- the rows of the particles found so far
+/// the iteration left free (an incomplete follow), and the held rows that
+/// carry no found particle (fakes' rows).
+
+#ifndef GTRK_STUDY_SEEDINGSTRATEGY_H_
+#define GTRK_STUDY_SEEDINGSTRATEGY_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/RoadCount.h"
+#include "GenericTracking/Study/Statistics.h"
+#include "GenericTracking/Study/TrackComparison.h"
+#include "GenericTracking/Study/TrackingInput.h"
+#include "GenericTracking/Study/Validation.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <format>
+#include <functional>
+#include <map>
+#include <optional>
+#include <ostream>
+#include <span>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+template <DetectorLayout Det>
+class SeedingStrategy
+{
+ public:
+  /// The road fit stage replayed on one road's rows, innermost first.
+  using Refit = std::function<FitRefusal(std::span<const std::uint32_t>)>;
+
+  /// What a pass's graph cost, beyond the sizes `observe` counts.
+  struct PassCost {
+    double seconds = 0.;            ///< the graph's wall time, the truth's bookkeeping left out
+    std::size_t poolPeakBytes = 0U; ///< the pool's peak inside the pass, from a released pool
+    bool counted = false;           ///< the fits below were counted (a counters build)
+    std::uint64_t tripletFits = 0U;
+    std::uint64_t neighbourFits = 0U;
+    double fitSeconds = 0.; ///< with the fit: its wall time, inside `seconds`
+  };
+
+  /// The particles of \a truth, the findable of \a comparison, coverage at
+  /// \a steps [GeV]; with \a remove, each pass's seeded particles' rows held;
+  /// with \a fit, seeded by the road fit's records rather than the roads;
+  /// the findable of \a population.
+  SeedingStrategy(const study::TrackingTruth& truth, const study::ComparisonSettings& comparison, std::vector<double> steps, bool remove, bool fit, Population population = Population::kPrimaries)
+    : mTruth(&truth),
+      mComparison(&comparison),
+      mSteps(std::move(steps)),
+      mRemove(remove),
+      mFit(fit),
+      mPopulation(kPopulationNames[static_cast<std::size_t>(population)])
+  {
+    const auto& rows = truth.rows;
+    // Every particle the rows carry, numbered, and the rows of each.
+    std::vector<std::size_t> counts;
+    for (const auto& row : rows) {
+      for (std::uint8_t at = 0U; at < row.count; ++at) {
+        const auto [found, inserted] = mIndex.try_emplace(row.particles[at], static_cast<std::uint32_t>(mIds.size()));
+        if (inserted) {
+          mIds.push_back(row.particles[at]);
+          counts.push_back(0U);
+        }
+        ++counts[found->second];
+      }
+    }
+    mParticleOffsets.assign(mIds.size() + 1U, 0U);
+    for (std::size_t particle = 0; particle < mIds.size(); ++particle) {
+      mParticleOffsets[particle + 1U] = mParticleOffsets[particle] + counts[particle];
+    }
+    mParticleRows.resize(mParticleOffsets.back());
+    std::vector<std::size_t> filled(mParticleOffsets.begin(), mParticleOffsets.end() - 1);
+    for (std::uint32_t row = 0; row < rows.size(); ++row) {
+      for (std::uint8_t at = 0U; at < rows[row].count; ++at) {
+        mParticleRows[filled[mIndex.at(rows[row].particles[at])]++] = row;
+      }
+    }
+    mRowOffsets.assign(rows.size() + 1U, 0U);
+    for (std::size_t row = 0; row < rows.size(); ++row) {
+      mRowOffsets[row + 1U] = mRowOffsets[row] + rows[row].count;
+    }
+    mRowParticles.resize(mRowOffsets.back());
+    for (std::size_t row = 0; row < rows.size(); ++row) {
+      for (std::uint8_t at = 0U; at < rows[row].count; ++at) {
+        mRowParticles[mRowOffsets[row] + at] = mIndex.at(rows[row].particles[at]);
+      }
+    }
+    mHeld.assign(rows.size(), std::uint8_t{0});
+    mPt.assign(mIds.size(), 0.F);
+    for (std::size_t particle = 0; particle < mIds.size(); ++particle) {
+      const auto found = truth.particles.find(mIds[particle]);
+      mPt[particle] = found == truth.particles.end() ? 0.F : found->second.pt;
+    }
+    mIsFindable.assign(mIds.size(), std::uint8_t{0});
+    mSeededBy.assign(mIds.size(), kUnseeded);
+    mSeededIn.assign(mIds.size(), kUnseeded);
+    mShadowIn.assign(mIds.size(), kUnseeded);
+    mShadowBy.assign(mIds.size(), kUnseeded);
+    mRoadIn.assign(mIds.size(), kUnseeded);
+    mRoadBy.assign(mIds.size(), kUnseeded);
+    mEver.assign(mIds.size(), Mechanism::kNone);
+    mRefusal.assign(mIds.size(), std::int8_t{-1});
+    mRefusals.assign(mIds.size(), std::uint8_t{0});
+    for (std::size_t layer = 0; layer < comparison.layerSpans.size(); ++layer) {
+      if (((comparison.barrelLayers >> layer) & 1U) == 0U) {
+        (comparison.layerSpans[layer].position > 0.F ? mPositiveDiscs : mNegativeDiscs) |= std::uint64_t{1} << layer;
+      }
+    }
+    for (const auto& [id, layers] : study::particleLayers(rows, comparison)) {
+      const auto found = truth.particles.find(id);
+      if (found == truth.particles.end() || !inPopulation(found->second, population) || !study::isFindable(found->second.pt, layers, comparison)) {
+        continue;
+      }
+      const bool positive = (layers.layers & mPositiveDiscs) != 0U;
+      const bool negative = (layers.layers & mNegativeDiscs) != 0U;
+      const auto kind = positive && negative ? Class::kDiscBoth : (positive ? Class::kDiscPositive : (negative ? Class::kDiscNegative : Class::kBarrel));
+      mFindable.push_back({.particle = mIndex.at(id), .pt = found->second.pt, .layers = layers.layers, .kind = kind});
+      mIsFindable[mIndex.at(id)] = 1U;
+    }
+  }
+
+  /// A pass starts: its counts at zero; a \a shadow pass holds nothing.
+  void beginPass(bool shadow)
+  {
+    mPass = {};
+    mSeeded.clear();
+    mShadow = shadow;
+    mBest.assign(mIds.size(), std::uint8_t{0});
+    mPureLength.assign(mIds.size(), std::uint8_t{0});
+    mPureRows.clear();
+  }
+
+  /// One slice of the pass: its roads, walked over its graph, and with the
+  /// fit its \a records.
+  template <typename Result, typename Roads, typename Records>
+  void observe(const Result& result, const Roads& roads, const Records* records)
+  {
+    constexpr std::size_t kMax = maxChainLayers<Det>;
+    const auto tracklets = result.tracklets->view();
+    const auto triplets = result.triplets->view();
+    mPass.tracklets += result.tracklets->size();
+    mPass.triplets += result.triplets->size();
+    mPass.neighbours += result.neighbours->size();
+    const auto walk = roads.walk(*result.triplets, *result.neighbours);
+    std::array<std::uint32_t, kMax - 2U> chain{};
+    std::array<std::uint32_t, kMax> rows{};
+    for (std::uint32_t road = 0; road < roads.roadCount(); ++road) {
+      const auto length = walk(road, chain.data());
+      rows[0] = tracklets.source[triplets.first[chain[0]]];
+      rows[1] = tracklets.target[triplets.first[chain[0]]];
+      for (std::uint32_t i = 0; i < length; ++i) {
+        rows[i + 2U] = tracklets.target[triplets.second[chain[i]]];
+      }
+      const std::span<const std::uint32_t> held{rows.data(), length + 2U};
+      ++mPass.roads;
+      noteOwnRows(held);
+      const bool owned = forEachOwner(held, [&](std::uint32_t particle) {
+        ++mPass.owners;
+        if (mFit && !mShadow && mIsFindable[particle] != 0U && held.size() > mPureLength[particle]) {
+          mPureRows[particle].assign(held.begin(), held.end());
+        }
+        mPureLength[particle] = std::max(mPureLength[particle], static_cast<std::uint8_t>(held.size()));
+        if (!mShadow) {
+          mRoadIn[particle] = mPassIndex;
+          mRoadBy[particle] = mRoadBy[particle] == kUnseeded ? mPassIndex : mRoadBy[particle];
+        }
+        if (!mFit) {
+          seed(particle);
+        }
+      });
+      mPass.pureRoads += owned ? 1U : 0U;
+      mPass.impureRoads += owned ? 0U : 1U;
+    }
+    if (records == nullptr) {
+      return;
+    }
+    const auto view = records->view();
+    mPass.records += records->size();
+    for (std::size_t record = 0; record < records->size(); ++record) {
+      const std::span<const std::uint32_t> held{view.clusters[record].index, static_cast<std::size_t>(view.count[record])};
+      const bool owned = forEachOwner(held, [&](std::uint32_t particle) { seed(particle); });
+      mPass.pureRecords += owned ? 1U : 0U;
+    }
+  }
+
+  /// Before the first pass: a real run's first \a iterations iterations left
+  /// \a tracks and the \a used mask. Their good tracks seed
+  /// their particles (`seededBy` -2), the rows the mask holds exclusively are
+  /// held, and the passes are numbered on from \a iterations; reported to
+  /// \a out.
+  template <typename Tracks>
+  void startAfter(std::size_t iterations, const Tracks& tracks, std::span<const std::uint8_t> used, std::ostream& out)
+  {
+    std::uint64_t fakes = 0U;
+    for (const auto& track : tracks) {
+      const auto id = study::goodParticle(mTruth->rows, std::span<const std::uint32_t>{track.clusters.index, static_cast<std::size_t>(track.count)});
+      if (id == study::kNoTrackParticle) {
+        ++fakes;
+        continue;
+      }
+      const auto particle = mIndex.at(id);
+      mSeededBy[particle] = kByRun;
+      mSeededIn[particle] = kByRun;
+    }
+    std::uint64_t held = 0U;
+    for (std::size_t row = 0; row < mHeld.size(); ++row) {
+      mHeld[row] = used[row] == kExclusive ? 1U : 0U;
+      held += mHeld[row];
+    }
+    mPassIndex = static_cast<std::uint32_t>(iterations);
+    std::string line = std::format("after the run's first {} iterations: {} tracks, {} fake; {} rows held ({:.2f} %); found of the findable {} at or above:", iterations, tracks.size(), fakes, held, study::percent(held, mHeld.size()), mPopulation);
+    for (const auto step : mSteps) {
+      std::uint64_t findable = 0U;
+      std::uint64_t found = 0U;
+      for (const auto& particle : mFindable) {
+        if (static_cast<double>(particle.pt) >= step) {
+          ++findable;
+          found += mSeededBy[particle.particle] != kUnseeded ? 1U : 0U;
+        }
+      }
+      line += std::format(" {} {:.2f}", step, study::percent(found, findable));
+    }
+    out << line << '\n';
+  }
+
+  /// Iteration \a pass's tracks of a real run, \a first to \a end of \a view,
+  /// with \a used the mask after it and \a roads its roads: the pass as
+  /// `observe` would have it, its good tracks seeding; `endPass` reports it
+  /// with the real-run counts (a study made without removal).
+  template <typename TrackView>
+  void observeReal(const TrackView& view, std::size_t first, std::size_t end, std::span<const std::uint8_t> used, std::uint64_t roads)
+  {
+    beginPass(false);
+    mPass.roads = roads;
+    auto& real = mReal.emplace();
+    for (std::size_t track = first; track < end; ++track) {
+      const std::span<const std::uint32_t> rows{view.clusters[track].index, static_cast<std::size_t>(view.count[track])};
+      ++real.tracks;
+      const auto id = study::goodParticle(mTruth->rows, rows);
+      if (id == study::kNoTrackParticle) {
+        ++real.fakes;
+        continue;
+      }
+      seed(mIndex.at(id));
+    }
+    for (std::size_t row = 0; row < mHeld.size(); ++row) {
+      mHeld[row] = used[row] == kExclusive ? 1U : 0U;
+      real.heldRows += mHeld[row];
+    }
+    for (std::size_t particle = 0; particle < mIds.size(); ++particle) {
+      if (mSeededBy[particle] == kUnseeded) {
+        continue;
+      }
+      std::uint64_t free = 0U;
+      for (auto at = mParticleOffsets[particle]; at < mParticleOffsets[particle + 1U]; ++at) {
+        free += mHeld[mParticleRows[at]] == 0U ? 1U : 0U;
+      }
+      real.foundRows += mParticleOffsets[particle + 1U] - mParticleOffsets[particle];
+      real.foundRowsFree += free;
+      real.foundWithFree += free != 0U ? 1U : 0U;
+      real.findableWithFree += free != 0U && mIsFindable[particle] != 0U ? 1U : 0U;
+    }
+    for (std::size_t row = 0; row < mHeld.size(); ++row) {
+      if (mHeld[row] == 0U) {
+        continue;
+      }
+      bool found = false;
+      for (auto at = mRowOffsets[row]; at < mRowOffsets[row + 1U] && !found; ++at) {
+        found = mSeededBy[mRowParticles[at]] != kUnseeded;
+      }
+      real.wrongHeld += found ? 0U : 1U;
+    }
+  }
+
+  /// The pass ends: its report to \a out and \a json, and the rows the next
+  /// pass must not read -- every row of the particles it seeded, with removal.
+  /// With the fit, \a refit says why it refused the pure roads of the
+  /// findable without a pure record.
+  [[nodiscard]] std::vector<std::uint32_t> endPass(const IterationSettings& settings, const PassCost& cost, std::ostream& out, std::ostream* json, const Refit& refit = {})
+  {
+    std::vector<std::uint32_t> hold;
+    if (mRemove && !mShadow) {
+      for (const auto particle : mSeeded) {
+        const std::span<const std::uint32_t> rows{mParticleRows};
+        hold.insert(hold.end(), rows.begin() + static_cast<std::ptrdiff_t>(mParticleOffsets[particle]), rows.begin() + static_cast<std::ptrdiff_t>(mParticleOffsets[particle + 1U]));
+      }
+      std::ranges::sort(hold);
+      const auto [last, end] = std::ranges::unique(hold);
+      hold.erase(last, end);
+      for (const auto row : hold) {
+        mHeld[row] = 1U;
+      }
+    }
+    const double floor = settings.windows.minPtGeV;
+    // The particles the pass seeded, by origin: the findable among them
+    // below.
+    std::array<std::uint64_t, study::kParticleOrigins> seededByOrigin{};
+    for (const auto particle : mSeeded) {
+      const auto found = mTruth->particles.find(mIds[particle]);
+      ++seededByOrigin[static_cast<std::size_t>(found == mTruth->particles.end() ? study::ParticleOrigin::kMaterial : found->second.origin)];
+    }
+    std::uint64_t seededFindable = 0U;
+    std::uint64_t firstFindable = 0U;
+    std::vector<std::uint64_t> covered(mSteps.size(), 0U);
+    std::vector<std::uint64_t> findable(mSteps.size(), 0U);
+    std::array<std::uint64_t, kClasses> classFindable{};
+    std::array<std::uint64_t, kClasses> classCovered{};
+    std::array<std::uint64_t, kClasses> classGained{};
+    std::map<std::uint64_t, std::uint64_t> unseeded;
+    const auto& seededIn = mShadow ? mShadowIn : mSeededIn;
+    // The two settings' differences on identical rows: this pass against the
+    // shadow pass just before it, each difference by the other's mechanism.
+    const bool versus = !mShadow && mShadowPass != kUnseeded && mShadowPass + 1U == mPassIndex;
+    std::array<std::uint64_t, kMechanisms> mainOnly{};
+    std::array<std::uint64_t, kMechanisms> shadowOnly{};
+    std::uint64_t bothSeeded = 0U;
+    // With the fit: the findable with a pure road and no pure record, by the
+    // length of their longest pure road.
+    std::vector<std::uint64_t> lostByLength(maxChainLayers<Det> + 1U, 0U);
+    std::array<std::uint64_t, kClasses> lostByClass{};
+    std::array<std::uint64_t, kFitRefusals> lostBy{};
+    std::uint64_t roadFindable = 0U;
+    std::array<std::uint64_t, kMechanisms> unseededBy{};
+    for (const auto& particle : mFindable) {
+      const auto number = particle.particle;
+      if (!mShadow && mSeededIn[number] != mPassIndex) {
+        const auto mechanism = mechanismOf(mPureLength[number], mBest[number], settings.minClusters);
+        mEver[number] = rank(mechanism) < rank(mEver[number]) ? mechanism : mEver[number];
+      }
+      if (versus) {
+        const bool main = mSeededIn[number] == mPassIndex;
+        const bool shadow = mShadowIn[number] == mShadowPass;
+        bothSeeded += main && shadow ? 1U : 0U;
+        if (main && !shadow) {
+          ++mainOnly[static_cast<std::size_t>(mechanismOf(mShadowPure[number], mShadowBest[number], mShadowMinClusters))];
+        } else if (shadow && !main) {
+          ++shadowOnly[static_cast<std::size_t>(mechanismOf(mPureLength[number], mBest[number], settings.minClusters))];
+        }
+      }
+      if (mFit && !mShadow && mRoadIn[number] == mPassIndex) {
+        ++roadFindable;
+        if (mSeededIn[number] != mPassIndex) {
+          ++lostByLength[mPureLength[number]];
+          ++lostByClass[static_cast<std::size_t>(particle.kind)];
+          if (refit) {
+            const auto why = refit(mPureRows.at(number));
+            ++lostBy[static_cast<std::size_t>(why)];
+            mRefusal[number] = static_cast<std::int8_t>(why);
+            ++mRefusals[number];
+          }
+        }
+      }
+    }
+    for (const auto& particle : mFindable) {
+      const bool seeded = mSeededBy[particle.particle] != kUnseeded;
+      const bool first = mSeededBy[particle.particle] == mPassIndex;
+      seededFindable += seededIn[particle.particle] == mPassIndex ? 1U : 0U;
+      firstFindable += first ? 1U : 0U;
+      for (std::size_t step = 0; step < mSteps.size(); ++step) {
+        if (static_cast<double>(particle.pt) >= mSteps[step]) {
+          ++findable[step];
+          covered[step] += seeded ? 1U : 0U;
+        }
+      }
+      if (static_cast<double>(particle.pt) >= floor) {
+        ++classFindable[static_cast<std::size_t>(particle.kind)];
+        classCovered[static_cast<std::size_t>(particle.kind)] += seeded ? 1U : 0U;
+        classGained[static_cast<std::size_t>(particle.kind)] += first ? 1U : 0U;
+        if (!seeded) {
+          ++unseeded[particle.layers];
+          ++unseededBy[static_cast<std::size_t>(mEver[particle.particle])];
+        }
+      }
+    }
+    const double multiplicity = mSeeded.empty() ? 0. : static_cast<double>(mPass.owners) / static_cast<double>(mSeeded.size());
+    out << std::format(
+             "pass {}{}: floor {} GeV, layers {} (mask {}), starts {}, {} clusters, kink sigma {}; {} tracklets, {} triplets{}, {} neighbours{}, {} roads "
+             "({:.2f} % impure, {:.2f} owners per seeded particle); {:.3f} s, pool peak {:.2f} GB\n",
+             mPassIndex, mShadow ? " (shadow: holds nothing)" : "", floor, layerList(settings.layerMask), settings.layerMask, settings.roadStartLayers == 0U ? "any" : layerList(settings.roadStartLayers), settings.minClusters, settings.graphKinkSigma > 0. ? std::format("{} (graph {})", settings.kinkSigma, settings.graphKinkSigma) : std::format("{}", settings.kinkSigma), mPass.tracklets, mPass.triplets, cost.counted ? std::format(" ({} fits)", cost.tripletFits) : std::string{}, mPass.neighbours, cost.counted ? std::format(" ({} fits)", cost.neighbourFits) : std::string{}, mPass.roads, study::percent(mPass.impureRoads, mPass.roads), multiplicity, cost.seconds, static_cast<double>(cost.poolPeakBytes) / 1.e9)
+        << std::format("  seeded {} particles: {} findable {} ({} first seeded here); by origin {} primaries, {} decay daughters, {} material; {} rows held\n", mSeeded.size(), seededFindable, mPopulation, firstFindable, seededByOrigin[static_cast<std::size_t>(study::ParticleOrigin::kPhysicalPrimary)], seededByOrigin[static_cast<std::size_t>(study::ParticleOrigin::kDecay)], seededByOrigin[static_cast<std::size_t>(study::ParticleOrigin::kMaterial)], hold.size());
+    std::uint64_t lost = 0U;
+    for (const auto count : lostByLength) {
+      lost += count;
+    }
+    if (mFit) {
+      std::string line = std::format("  road fit: {} records ({} pure) in {:.3f} s; findable {} with a pure road {}, without a pure record {} ({:.2f} %), by pure road length:", mPass.records, mPass.pureRecords, cost.fitSeconds, mPopulation, roadFindable, lost, study::percent(lost, roadFindable));
+      for (std::size_t length = 0; length < lostByLength.size(); ++length) {
+        line += lostByLength[length] == 0U ? std::string{} : std::format(" {}: {}", length, lostByLength[length]);
+      }
+      line += "; refused by";
+      for (std::size_t why = 0; why < kFitRefusals; ++why) {
+        line += std::format(" {} {}", kFitRefusalNames[why], lostBy[why]);
+      }
+      out << line << '\n';
+    }
+    if (mReal) {
+      out << std::format(
+        "  real run: {} tracks, {} good, {} fake; held rows {}, of them {} carry no found particle; the found particles' rows {}, {} of them "
+        "free ({:.2f} %), on {} particles ({} findable {})\n",
+        mReal->tracks, mReal->tracks - mReal->fakes, mReal->fakes, mReal->heldRows, mReal->wrongHeld, mReal->foundRows, mReal->foundRowsFree, study::percent(mReal->foundRowsFree, mReal->foundRows), mReal->foundWithFree, mReal->findableWithFree, mPopulation);
+    }
+    if (versus) {
+      out << std::format("  against shadow pass {}: both seed {} findable {}; only this pass {} (in the shadow: {}), only the shadow {} (here: {})\n", mShadowPass, bothSeeded, mPopulation, mainOnly[0] + mainOnly[1] + mainOnly[2] + mainOnly[3], mechanismLine(mainOnly), shadowOnly[0] + shadowOnly[1] + shadowOnly[2] + shadowOnly[3], mechanismLine(shadowOnly));
+    }
+    std::string line = std::format("  coverage of the findable {} at or above:", mPopulation);
+    for (std::size_t step = 0; step < mSteps.size(); ++step) {
+      line += std::format(" {} {:.2f}", mSteps[step], study::percent(covered[step], findable[step]));
+    }
+    out << line << '\n';
+    line = std::format("  at the floor, by class, covered % (this pass's gain %) of the findable:");
+    for (std::size_t kind = 0; kind < kClasses; ++kind) {
+      line += std::format(" {} {:.2f} ({:+.2f}) of {}", kClassNames[kind], study::percent(classCovered[kind], classFindable[kind]), study::percent(classGained[kind], classFindable[kind]), classFindable[kind]);
+    }
+    out << line << '\n';
+    // The rows left free: noise, a findable particle's (unseeded), another
+    // particle's at or above the lowest step, or only particles below it.
+    const double lowest = *std::ranges::min_element(mSteps);
+    std::array<std::uint64_t, kFreeKinds> free{};
+    for (std::size_t row = 0; row < mHeld.size(); ++row) {
+      if (mHeld[row] != 0U) {
+        continue;
+      }
+      const auto& truthRow = mTruth->rows[row];
+      bool findableRow = false;
+      bool above = false;
+      for (std::uint8_t at = 0U; at < truthRow.count; ++at) {
+        const auto particle = mIndex.at(truthRow.particles[at]);
+        findableRow = findableRow || mIsFindable[particle] != 0U;
+        above = above || static_cast<double>(mPt[particle]) >= lowest;
+      }
+      ++free[truthRow.count == 0U ? 0U : (findableRow ? 1U : (above ? 2U : 3U))];
+    }
+    std::uint64_t freeTotal = 0U;
+    for (const auto count : free) {
+      freeTotal += count;
+    }
+    out << std::format(
+      "  rows free after the pass: {:.2f} % of all; of them noise {:.2f} %, findable {} {:.2f} %, other particles >= {} GeV {:.2f} %, "
+      "only particles below {:.2f} %\n",
+      study::percent(freeTotal, mHeld.size()), study::percent(free[0], freeTotal), mPopulation, study::percent(free[1], freeTotal), lowest, study::percent(free[2], freeTotal), study::percent(free[3], freeTotal));
+    std::vector<std::pair<std::uint64_t, std::uint64_t>> patterns(unseeded.begin(), unseeded.end());
+    std::ranges::sort(patterns, [](const auto& a, const auto& b) { return a.second != b.second ? a.second > b.second : a.first < b.first; });
+    std::uint64_t unseededTotal = 0U;
+    for (const auto& [mask, count] : patterns) {
+      unseededTotal += count;
+    }
+    out << std::format("  unseeded at the floor: {} (over the passes so far: {}); the most common layer patterns:\n", unseededTotal, mechanismLine(unseededBy));
+    for (std::size_t at = 0; at < std::min<std::size_t>(patterns.size(), kPatterns); ++at) {
+      out << std::format("    {:7d} ({:5.2f} %)  {} (mask {})\n", patterns[at].second, study::percent(patterns[at].second, unseededTotal), layerList(patterns[at].first), patterns[at].first);
+    }
+    if (json != nullptr) {
+      std::string coverage;
+      for (std::size_t step = 0; step < mSteps.size(); ++step) {
+        coverage += std::format("{}[{},{},{}]", step == 0U ? "" : ",", mSteps[step], covered[step], findable[step]);
+      }
+      std::string classes;
+      for (std::size_t kind = 0; kind < kClasses; ++kind) {
+        classes += std::format(R"({}"{}":[{},{},{}])", kind == 0U ? "" : ",", kClassNames[kind], classCovered[kind], classGained[kind], classFindable[kind]);
+      }
+      std::string top;
+      for (std::size_t at = 0; at < std::min<std::size_t>(patterns.size(), kPatterns); ++at) {
+        top += std::format("{}[{},{}]", at == 0U ? "" : ",", patterns[at].first, patterns[at].second);
+      }
+      std::string origins;
+      for (std::size_t origin = 0; origin < study::kParticleOrigins; ++origin) {
+        origins += std::format("{}{}", origin == 0U ? "" : ",", seededByOrigin[origin]);
+      }
+      const auto fits = [&](std::uint64_t count) { return cost.counted ? std::to_string(count) : std::string{"null"}; };
+      const auto byMechanism = [](const std::array<std::uint64_t, kMechanisms>& counts) { return std::format("[{},{},{},{}]", counts[0], counts[1], counts[2], counts[3]); };
+      std::string lostLengths;
+      for (std::size_t length = 0; length < lostByLength.size(); ++length) {
+        if (lostByLength[length] != 0U) {
+          lostLengths += std::format("{}[{},{}]", lostLengths.empty() ? "" : ",", length, lostByLength[length]);
+        }
+      }
+      const std::string fitJson = mFit && !mShadow ? std::format(R"({{"records":{},"pureRecords":{},"seconds":{:.6f},"roadFindable":{},"lost":{},"lostByLength":[{}],"lostByClass":[{},{},{},{}],)"
+                                                                 R"("lostBy":[{},{},{},{},{},{}]}})",
+                                                                 mPass.records, mPass.pureRecords, cost.fitSeconds, roadFindable, lost, lostLengths, lostByClass[0], lostByClass[1], lostByClass[2], lostByClass[3], lostBy[0], lostBy[1], lostBy[2], lostBy[3], lostBy[4], lostBy[5])
+                                                   : std::string{"null"};
+      const std::string realJson = mReal ? std::format(R"({{"tracks":{},"fakes":{},"heldRows":{},"wrongHeld":{},"foundRows":{},"foundRowsFree":{},"foundWithFree":{},"findableWithFree":{}}})", mReal->tracks, mReal->fakes, mReal->heldRows, mReal->wrongHeld, mReal->foundRows, mReal->foundRowsFree, mReal->foundWithFree, mReal->findableWithFree) : std::string{"null"};
+      const std::string versusJson = versus ? std::format(R"({{"shadowPass":{},"both":{},"mainOnly":{},"shadowOnly":{}}})", mShadowPass, bothSeeded, byMechanism(mainOnly), byMechanism(shadowOnly)) : std::string{"null"};
+      *json << std::format(R"({{"pass":{},"floor":{},"layerMask":{},"startLayers":{},"minClusters":{},"remove":{},"tracklets":{},"triplets":{},"neighbours":{},)"
+                           R"("tripletFits":{},"neighbourFits":{},"roads":{},"impureRoads":{},"pureRoads":{},"owners":{},"seeded":{},"seededByOrigin":[{}],)"
+                           R"("seededFindable":{},"firstFindable":{},"rowsHeld":{},"seconds":{:.6f},"poolPeakBytes":{},)"
+                           R"("coverage":[{}],"classes":{{{}}},"unseeded":{},"unseededBy":{},"patterns":[{}],"free":[{},{},{},{},{}],)"
+                           R"("shadow":{},"kinkSigma":{},"graphKinkSigma":{},"fit":{},"versus":{},"real":{}}})",
+                           mPassIndex, floor, settings.layerMask, settings.roadStartLayers, settings.minClusters, mRemove, mPass.tracklets, mPass.triplets, mPass.neighbours, fits(cost.tripletFits), fits(cost.neighbourFits), mPass.roads, mPass.impureRoads, mPass.pureRoads, mPass.owners, mSeeded.size(), origins, seededFindable, firstFindable, hold.size(), cost.seconds, cost.poolPeakBytes, coverage, classes, unseededTotal, byMechanism(unseededBy), top, freeTotal, free[0], free[1], free[2], free[3], mShadow, settings.kinkSigma, settings.graphKinkSigma, fitJson, versusJson, realJson)
+            << '\n';
+    }
+    if (mShadow) {
+      mShadowPass = mPassIndex;
+      mShadowBest = mBest;
+      mShadowPure = mPureLength;
+      mShadowMinClusters = settings.minClusters;
+    }
+    ++mPassIndex;
+    return hold;
+  }
+
+  /// Per findable, one CSV line: its id, pT, class and layers, the
+  /// first pass that seeded it, the first that gave it a pure road, the first
+  /// shadow pass that seeded it, and its best mechanism over the passes
+  /// (0 inside a road, 1 partly, 2 in none, 3 a pure road the fit refused,
+  /// -1 seeded); -1 for never, -2 for found by the real run before the
+  /// passes (`startAfter`); its PDG
+  /// code, eta and production vertex (radius, z [cm]); with the fit, the passes whose fit refused its pure road
+  /// and the last refusal (`FitRefusal`, -1 none); its mother's PDG code (0 none).
+  void writeParticles(std::ostream& out) const
+  {
+    const auto pass = [](std::uint32_t at) { return at == kUnseeded ? std::string{"-1"} : (at == kByRun ? std::string{"-2"} : std::to_string(at)); };
+    out << "id,pt,class,layers,seededBy,roadBy,shadowBy,mechanism,pdg,eta,vr,vz,refusals,refusal,motherPdg\n";
+    for (const auto& particle : mFindable) {
+      const auto number = particle.particle;
+      const auto found = mTruth->particles.find(mIds[number]);
+      const auto truth = found == mTruth->particles.end() ? study::ParticleTruth{} : found->second;
+      out << std::format("{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}\n", mIds[number], particle.pt, static_cast<int>(particle.kind), particle.layers, pass(mSeededBy[number]), pass(mRoadBy[number]), pass(mShadowBy[number]), mSeededBy[number] == kUnseeded ? static_cast<int>(mEver[number]) : -1, truth.pdg, truth.eta, std::hypot(truth.vx, truth.vy), truth.vz, mRefusals[number], mRefusal[number], truth.motherPdg);
+    }
+  }
+
+ private:
+  static constexpr std::uint32_t kUnseeded = ~0U;
+  static constexpr std::uint32_t kByRun = kUnseeded - 1U; ///< found by the real run before the passes (`startAfter`)
+  /// A real run's iteration (`observeReal`).
+  struct RealCounts {
+    std::uint64_t tracks = 0U;
+    std::uint64_t fakes = 0U;
+    std::uint64_t heldRows = 0U;         ///< held exclusively after the iteration
+    std::uint64_t wrongHeld = 0U;        ///< of them, carrying no particle found so far
+    std::uint64_t foundRows = 0U;        ///< the rows of every particle found so far
+    std::uint64_t foundRowsFree = 0U;    ///< of them, not held
+    std::uint64_t foundWithFree = 0U;    ///< the found particles with a row not held
+    std::uint64_t findableWithFree = 0U; ///< of them, findable
+  };
+  std::optional<RealCounts> mReal;
+  static constexpr std::size_t kPatterns = 12U;
+  enum class Class : std::uint8_t { kBarrel,
+                                    kDiscPositive,
+                                    kDiscNegative,
+                                    kDiscBoth };
+  /// Where an unseeded particle's rows were in a pass: inside a road with
+  /// foreign rows (at least the pass's minimum of its own), only partly in a
+  /// road, in no road, or -- with the fit -- in a pure road the fit refused
+  /// (the codes are the CSV's; `rank` orders them).
+  enum class Mechanism : std::uint8_t { kInside,
+                                        kPartly,
+                                        kNone,
+                                        kRefused };
+  static constexpr std::size_t kMechanisms = 4U;
+  static constexpr std::size_t kClasses = 4U;
+  static constexpr std::array<std::string_view, kClasses> kClassNames{"barrel", "discs z>0", "discs z<0", "discs both"};
+
+  struct Findable {
+    std::uint32_t particle = 0U;
+    float pt = 0.F;
+    std::uint64_t layers = 0U;
+    Class kind = Class::kBarrel;
+  };
+  struct PassCounts {
+    std::uint64_t tracklets = 0U;
+    std::uint64_t triplets = 0U;
+    std::uint64_t neighbours = 0U;
+    std::uint64_t roads = 0U;
+    std::uint64_t impureRoads = 0U;
+    std::uint64_t pureRoads = 0U;   ///< roads some particle owns
+    std::uint64_t owners = 0U;      ///< the owners of the pure roads, a road of two particles twice
+    std::uint64_t records = 0U;     ///< with the fit: the accepted roads' records
+    std::uint64_t pureRecords = 0U; ///< of them, those some particle owns
+  };
+
+  /// The mechanism of a particle not seeded in a pass where its longest pure
+  /// road had \a pure rows (0: none) and its most rows in one road were \a best.
+  [[nodiscard]] static Mechanism mechanismOf(std::uint8_t pure, std::uint8_t best, int minClusters)
+  {
+    if (pure > 0U) {
+      return Mechanism::kRefused;
+    }
+    return std::cmp_greater_equal(best, minClusters) ? Mechanism::kInside : (best > 0U ? Mechanism::kPartly : Mechanism::kNone);
+  }
+
+  /// Mechanisms best first: refused, inside, partly, none.
+  [[nodiscard]] static int rank(Mechanism mechanism) { return mechanism == Mechanism::kRefused ? -1 : static_cast<int>(mechanism); }
+
+  [[nodiscard]] static std::string mechanismLine(const std::array<std::uint64_t, kMechanisms>& counts) { return std::format("{} inside an impure road, {} partly in one, {} in none, {} in a pure road the fit refused", counts[0], counts[1], counts[2], counts[3]); }
+
+  /// \a particle seeded by this pass: a shadow pass's own record, else
+  /// the study's, and held after the pass.
+  void seed(std::uint32_t particle)
+  {
+    auto& in = mShadow ? mShadowIn : mSeededIn;
+    if (in[particle] == mPassIndex) {
+      return;
+    }
+    in[particle] = mPassIndex;
+    mSeeded.push_back(particle);
+    auto& by = mShadow ? mShadowBy : mSeededBy;
+    by[particle] = by[particle] == kUnseeded ? mPassIndex : by[particle];
+  }
+
+  /// Call \a body with the number of every particle all of \a held carries
+  /// (each of the first row's particles the others carry too: the one truth
+  /// rule); whether there was one.
+  template <typename Body>
+  bool forEachOwner(std::span<const std::uint32_t> held, const Body& body)
+  {
+    return forEachCommonParticle(mTruth->rows, held, [&](std::uint64_t id) { body(mIndex.at(id)); });
+  }
+
+  /// Each particle's most rows in one road, over the pass: \a rows' labels
+  /// counted.
+  void noteOwnRows(std::span<const std::uint32_t> rows)
+  {
+    std::array<std::uint32_t, maxChainLayers<Det> * study::TruthRow::kMaxParticles> labels{};
+    std::size_t count = 0U;
+    for (const auto row : rows) {
+      for (auto at = mRowOffsets[row]; at < mRowOffsets[row + 1U]; ++at) {
+        labels[count++] = mRowParticles[at];
+      }
+    }
+    std::sort(labels.begin(), labels.begin() + static_cast<std::ptrdiff_t>(count));
+    for (std::size_t at = 0; at < count;) {
+      std::size_t end = at + 1U;
+      while (end < count && labels[end] == labels[at]) {
+        ++end;
+      }
+      mBest[labels[at]] = std::max(mBest[labels[at]], static_cast<std::uint8_t>(end - at));
+      at = end;
+    }
+  }
+
+  /// A layer mask as its layers, the barrel's before a bar and the discs'.
+  [[nodiscard]] std::string layerList(std::uint64_t mask) const
+  {
+    std::string barrel;
+    std::string discs;
+    for (int layer = 0; layer < Detector<Det>::nLayers; ++layer) {
+      if (((mask >> layer) & 1U) == 0U) {
+        continue;
+      }
+      auto& part = ((mComparison->barrelLayers >> layer) & 1U) != 0U ? barrel : discs;
+      part += std::format("{}{}", part.empty() ? "" : " ", layer);
+    }
+    return discs.empty() ? barrel : std::format("{} | {}", barrel, discs);
+  }
+
+  const study::TrackingTruth* mTruth;
+  const study::ComparisonSettings* mComparison;
+  std::vector<double> mSteps;
+  bool mRemove = true;
+  bool mFit = false;
+  std::string_view mPopulation;          ///< the scored particles' name
+  bool mShadow = false;                  ///< the pass is a shadow pass
+  std::uint32_t mShadowPass = kUnseeded; ///< the last shadow pass
+  int mShadowMinClusters = 0;
+  std::vector<std::uint8_t> mBest;                                         ///< per number, its most rows in one road of the pass
+  std::vector<std::uint8_t> mShadowBest;                                   ///< `mBest` of the last shadow pass
+  std::vector<std::uint8_t> mPureLength;                                   ///< per number, its longest pure road in the pass
+  std::vector<std::uint8_t> mShadowPure;                                   ///< `mPureLength` of the last shadow pass
+  std::unordered_map<std::uint32_t, std::vector<std::uint32_t>> mPureRows; ///< with the fit: per findable, that road's rows
+  std::vector<std::uint32_t> mShadowIn;                                    ///< per number, the last shadow pass that seeded it
+  std::vector<std::uint32_t> mShadowBy;                                    ///< per number, the first shadow pass that seeded it
+  std::vector<std::uint32_t> mRoadIn;                                      ///< per number, the last pass a pure road of which it owned
+  std::vector<std::uint32_t> mRoadBy;                                      ///< per number, the first such pass
+  std::vector<Mechanism> mEver;                                            ///< per number, its best mechanism over the passes that did not seed it
+  std::vector<std::int8_t> mRefusal;                                       ///< with the fit: per number, the last refusal of its pure road, -1 none
+  std::vector<std::uint8_t> mRefusals;                                     ///< with the fit: per number, the passes that refused it
+  std::vector<std::size_t> mRowOffsets;                                    ///< per row, its first number in `mRowParticles`
+  std::vector<std::uint32_t> mRowParticles;                                ///< the rows' particles, as numbers
+  std::unordered_map<std::uint64_t, std::uint32_t> mIndex;                 ///< particle id -> number
+  std::vector<std::uint64_t> mIds;                                         ///< number -> particle id
+  std::vector<std::size_t> mParticleOffsets;                               ///< per number, its first row in `mParticleRows`
+  std::vector<std::uint32_t> mParticleRows;
+  std::vector<std::uint32_t> mSeededBy; ///< per number, the pass that first seeded it
+  std::vector<std::uint32_t> mSeededIn; ///< per number, the last pass that seeded it
+  std::uint64_t mPositiveDiscs = 0U;    ///< the disc layers at z > 0, a bit per layer
+  std::uint64_t mNegativeDiscs = 0U;
+  static constexpr std::size_t kFreeKinds = 4U;
+  std::vector<std::uint8_t> mHeld; ///< per row, held by a seeded particle
+  std::vector<float> mPt;          ///< per number, the particle's pT [GeV]; 0 without its truth
+  std::vector<std::uint8_t> mIsFindable;
+  std::vector<Findable> mFindable;
+  std::vector<std::uint32_t> mSeeded; ///< the particles the pass seeded
+  std::uint32_t mPassIndex = 0U;
+  PassCounts mPass;
+};
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_SEEDINGSTRATEGY_H_
diff --git a/Detectors/GenericTracking/study/tools/StudyWorkflow.h b/Detectors/GenericTracking/study/tools/StudyWorkflow.h
new file mode 100644
index 0000000000000..3d870b820f4c5
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/StudyWorkflow.h
@@ -0,0 +1,103 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file StudyWorkflow.h
+/// \brief What the detectors' study workflows share (o2-gtrk-its-, -mft- and
+///        -trk-study-workflow): their options and the chain with the study's sink.
+///
+/// The detector's devices and messages are its own (gtrk-<det>-...,
+/// GTRK/<DET>...), each device pipelined on its own (`--pipeline
+/// gtrk-its-measurement-producer:2`) and configured on its own
+/// (`--gtrk-mft-measurement-sink "--qa-output ..."`). With
+/// `--clusters-from-upstream` the clusters come from an O2 workflow before it
+/// in the pipe (`o2-its-reco-workflow --disable-tracking`), without it from
+/// O2's cluster readers; run it in the timeframe's directory of an O2DPG
+/// production. With `--mc-vertices` the MC vertices
+/// go to the sink too, for the iterations that GTRKReco<DET>.iterationVertexSource
+/// seeds from them; with GTRKReco<DET>.vertexer the sink finds its own, and
+/// takes one or the other.
+///
+/// With `--compare-tracks` the chain also runs the tracking device
+/// (gtrk-<det>-tracker, workflow/TrackerSpec.h) on the same measurements and
+/// seeds, and the sink compares the device's tracks and vertices with its own
+/// tracker's, every timeframe; with `--tracker-digests` the sink logs the
+/// device's digests instead.
+
+#ifndef GTRK_STUDY_STUDYWORKFLOW_H_
+#define GTRK_STUDY_STUDYWORKFLOW_H_
+
+#include "GenericTracking/Study/MCVertexReaderSpec.h"
+#include "GenericTracking/Study/MeasurementSinkSpec.h"
+#include "GenericTracking/Workflow/ClusterConverterSpec.h"
+#include "GenericTracking/Workflow/MeasurementProducerSpec.h"
+#include "GenericTracking/Workflow/TrackerSpec.h"
+
+#include "DetectorsRaw/HBFUtilsInitializer.h"
+#include "Framework/ConfigContext.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/WorkflowSpec.h"
+
+#include <stdexcept>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+/// Every study workflow's options.
+inline void addStudyOptions(std::vector<o2::framework::ConfigParamSpec>& options)
+{
+  using o2::framework::ConfigParamSpec;
+  using o2::framework::VariantType;
+  options.push_back(ConfigParamSpec{"disable-mc", VariantType::Bool, false, {"do not propagate MC labels"}});
+  options.push_back(ConfigParamSpec{"configKeyValues", VariantType::String, "", {"semicolon separated key=value strings"}});
+  options.push_back(ConfigParamSpec{"clusters-from-upstream", VariantType::Bool, false, {"the clusters from the workflow before this one in the pipe, not O2's readers"}});
+  options.push_back(ConfigParamSpec{"mc-vertices", VariantType::Bool, false, {"the MC vertices as the vertex list (any detector with an MC collision context)"}});
+  options.push_back(ConfigParamSpec{"compare-tracks", VariantType::Bool, false, {"also run the tracking device; the sink compares its tracks and vertices with its own tracker's"}});
+  options.push_back(ConfigParamSpec{"tracker-digests", VariantType::Bool, false, {"also run the tracking device; the sink logs its tracks' and vertices' digests, as the bench prints a device's"}});
+  // Use the HBFUtils instance updated by --configKeyValues. This also makes
+  // the timer advance TimingInfo::firstTForbit by nHBFPerTF for every entry.
+  o2::raw::HBFUtilsInitializer::addConfigOption(options, o2::raw::HBFUtilsInitializer::HBFUSrc);
+}
+
+/// Detector \a Det's study: its \a readers (unless `--clusters-from-upstream`),
+/// the converter, the producer and the sink, with the tracking device and the
+/// MC vertex reader when asked for.
+template <DetectorLayout Det>
+[[nodiscard]] o2::framework::WorkflowSpec studyChain(const o2::framework::ConfigContext& context, const o2::framework::WorkflowSpec& readers)
+{
+  namespace gw = o2::gtrk::workflow;
+  const bool useMC = !context.options().get<bool>("disable-mc");
+  const bool mcVertices = context.options().get<bool>("mc-vertices");
+  const bool compareTracks = context.options().get<bool>("compare-tracks");
+  const bool trackerDigests = context.options().get<bool>("tracker-digests");
+  if (compareTracks && trackerDigests) {
+    throw std::invalid_argument("--compare-tracks and --tracker-digests: one or the other");
+  }
+  const auto products = compareTracks ? TrackerProducts::kCompare : (trackerDigests ? TrackerProducts::kDigests : TrackerProducts::kNone);
+  o2::framework::WorkflowSpec specs;
+  if (!context.options().get<bool>("clusters-from-upstream")) {
+    specs.insert(specs.end(), readers.begin(), readers.end());
+  }
+  specs.push_back(gw::getClusterConverterSpec<Det>(useMC));
+  specs.push_back(gw::getMeasurementProducerSpec<Det>());
+  specs.push_back(getMeasurementSinkSpec<Det>(useMC, mcVertices, products));
+  if (products != TrackerProducts::kNone) {
+    specs.push_back(gw::getTrackerSpec<Det>(mcVertices));
+  }
+  if (mcVertices) {
+    specs.push_back(getMCVertexReaderSpec<Det>());
+  }
+  return specs;
+}
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_STUDYWORKFLOW_H_
diff --git a/Detectors/GenericTracking/study/tools/TrackBench.h b/Detectors/GenericTracking/study/tools/TrackBench.h
new file mode 100644
index 0000000000000..46bc3abc5bf73
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/TrackBench.h
@@ -0,0 +1,2206 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackBench.h
+/// \brief o2-gtrk-track-bench's run of one detector, `track<Det>`, and what it
+///        uses: one translation unit per detector instantiates it
+///        (trackBench<Det>.cxx); trackBench.cxx parses the options and dispatches.
+
+#ifndef GTRK_STUDY_TRACKBENCH_H_
+#define GTRK_STUDY_TRACKBENCH_H_
+
+#include "GenericTracking/Study/Alice/Hits.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Study/Digest.h"
+#include "GenericTracking/Study/ProfileReport.h"
+#include "GenericTracking/Study/Statistics.h"
+#include "GenericTracking/Tracking/MeasurementGrid.h"
+#include "GenericTracking/Tracking/MeasurementGridBuilder.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/Profile.h"
+#include "GenericTracking/Study/StageComparison.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/Tracker.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tracking/WorkCounters.h"
+#include "GenericTracking/Study/Validation.h"
+#include "GenericTracking/Workflow/GeometryProvider.h"
+#include "GenericTracking/Workflow/GridConfig.h"
+#include "GenericTracking/Workflow/MaterialLUT.h"
+#include "GenericTracking/Workflow/RecoParam.h"
+#include "GenericTracking/Workflow/TrackingInterface.h"
+#include "GenericTracking/Study/TrackingInput.h"
+
+#include "CCDB/BasicCCDBManager.h"
+#include "DataFormatsParameters/GRPECSObject.h"
+#include "DetectorsRaw/HBFUtils.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/NameConf.h"
+#include "DetectorsBase/MatLayerCylSet.h"
+
+#include <TGeoManager.h>
+
+#include "FitInputs.h"
+#include <boost/program_options.hpp>
+#include "GenericTracking/Study/StageFunnel.h"
+#include "CompleteAnatomy.h"
+#include "FollowAnatomy.h"
+#include "SeedingStrategy.h"
+#include "TrackBreakdown.h"
+#include "VertexStudy.h"
+
+#include <sys/resource.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <type_traits>
+#include <chrono>
+#include <cmath>
+#include <cstdint>
+#include <exception>
+#include <filesystem>
+#include <format>
+#include <fstream>
+#include <iostream>
+#include <limits>
+#include <memory>
+#include <numbers>
+#include <numeric>
+#include <optional>
+#include <ranges>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+namespace bpo = boost::program_options;
+template <DetectorLayout Det>
+using Controller = Tracker<Det, o2::base::MatLayerCylSet>;
+
+// Read once per run: its order follows the command line, not the padding.
+struct Options { // NOLINT(clang-analyzer-optin.performance.Padding)
+  std::string detector;
+  std::string input;
+  std::string truth;
+  std::string config;
+  std::string keyValues;
+  std::string ccdbUrl; ///< --ccdb-url: the conditions' CCDB (a sample's snapshots: file://<run dir>/ccdb)
+  int threads = -1;
+  unsigned repeat = 3U;
+  bool tree = true;
+  bool iterationTrees = false;
+  bool digestStages = false;
+  bool funnel = false;
+  int vertexStudy = -1;
+  bool verticesOnly = false;     ///< --vertices-only: the vertexing pass alone, its vertices against the truth
+  std::vector<int> scoreSources; ///< --score-sources: the score again over these MC sources' particles only; empty for none
+  double beamWidthCM = 0.;       ///< --beam-width: the beam's transverse width the windows take, instead of the dump's
+  std::string vertexList;        ///< --vertex-list: the vertexer's vertices against the truth, as CSV; empty for none
+  std::string vertexReplay;      ///< --vertex-replay: the replay's vertices and collisions, as CSV with this prefix; empty for none
+  std::string vertexPrior;       ///< --vertex-prior: an earlier pass's replay vertices the prior-* variants start from
+  double findableMinPtGeV = 0.1;
+  std::uint64_t findableAllLayers = 0U; ///< the score's "on every layer" mask; 0, every layer
+  std::string seedCoverage;             ///< --seed-coverage: layer masks, comma separated
+  std::string seedingStrategy;          ///< --seeding-strategy: the truth-removal study's JSON lines, one per pass
+  std::string seedingSteps;             ///< --seeding-steps: its pT steps [GeV], comma separated
+  bool seedingNoRemoval = false;        ///< --seeding-no-removal: every pass on the whole frame
+  std::string seedingShadow;            ///< --seeding-shadow: the shadow passes, comma separated
+  bool seedingFit = false;              ///< --seeding-fit: seeded by the road fit's pure records
+  std::string seedingParticles;         ///< --seeding-particles: per findable primary, a CSV line
+  std::string seedingPopulation;        ///< --seeding-population: the particles the study scores
+  std::string seedingReal;              ///< --seeding-real: the real run's iterations scored as the study's passes, JSON lines
+  std::string saveState;                ///< --save-state: the checkpoint after --state-iterations iterations
+  std::size_t stateIterations = 0U;     ///< --state-iterations: how many iterations --save-state runs
+  std::string resumeState;              ///< --resume-state: the run goes on from this checkpoint
+  std::string holdClusters;             ///< --hold-clusters: clusters, one per line, taken before the first iteration
+  std::string fitInputs;
+  bool noProfile = false;
+  bool dram = false;
+  std::string trace;
+  std::string json;
+  std::string tracksOut;
+  std::string clonesOut;   ///< --clones-out
+  std::string rowsOut;     ///< --rows-out
+  std::string fakesOut;    ///< --fakes-out
+  std::string followSteps; ///< --follow-steps
+  std::string cloneJoins;  ///< --clone-joins
+  std::string backend;
+  int gpuDevice = 0;
+  std::size_t gpuArenaMB = 0U;
+  bool hostReference = false;
+  bool rebin = false;
+  bool followStops = false;        ///< --follow-stops
+  bool completeAnatomy = false;    ///< --complete-anatomy
+  std::string stepAnatomy;         ///< --step-anatomy: the CSV of the replayed steps
+  std::string truthWalk;           ///< --truth-walk: the CSV of the truth walks' steps
+  std::string fateOut;             ///< --fate-out: the CSV of every class particle's fate
+  std::string breakdown;           ///< --breakdown: where the last run's tracks sit, a JSON line
+  std::string breakdownParticles;  ///< --breakdown-particles: the same per particle of the class, a CSV
+  std::string breakdownPopulation; ///< --breakdown-population: the class's particles, primary, decay or v0
+  std::string inwardHistory;       ///< --inward-history: the CSV of the inward refit's states
+  std::string endDecisions;        ///< --end-decisions: the CSV of every follow walk's end
+  std::string endEdits;            ///< --end-edits: with it, the CSV of each track's truth-free end edits
+  int anatomyPdg = 0;              ///< --anatomy-pdg
+  bool anatomyFindable = false;    ///< --anatomy-findable
+  std::string anatomyBeamLine;     ///< --anatomy-beam-line
+  std::string anatomyFollowLoss;   ///< --anatomy-follow-loss
+  int truthWalkIteration = -1;     ///< --truth-walk-iteration: the iteration of the truth walk (-1: the first holding the class's mask)
+  std::string hits;                ///< --hits: the MC hits (sgn_Hits<det>.root) the steps are held to
+  std::string ft3Hits;             ///< --ft3-hits: FT3's MC hits beside TRK's
+  std::string kine;                ///< --kine: the MC kinematics (sgn_Kine.root), the anatomy's clutter test
+};
+
+/// The lines of one section of an INI file, `[name]` excluded.
+inline std::vector<std::string> iniSection(const std::string& path, const std::string& name)
+{
+  std::ifstream in{path};
+  std::vector<std::string> lines;
+  bool inside = false;
+  for (std::string line; std::getline(in, line);) {
+    if (!line.empty() && line.front() == '[') {
+      inside = line == "[" + name + "]";
+      continue;
+    }
+    if (inside && !line.empty()) {
+      lines.push_back(line);
+    }
+  }
+  return lines;
+}
+
+/// Load the sink's parameters and check that every line of them reads back as
+/// written: a value that does not survive the round trip would make this a
+/// different configuration from the sink's. A key the file lacks -- added to
+/// RecoSettings after the dump -- is at its default, as the sink ran it;
+/// a key RecoSettings does not have is an
+/// error. \a section is the detector's parameter, GTRKReco<DET>.
+inline void loadConfiguration(const std::string& path, const std::string& section)
+{
+  if (!std::filesystem::exists(path)) {
+    throw std::runtime_error("no configuration " + path + "; the sink writes it beside the input");
+  }
+  if (iniSection(path, section).empty()) {
+    throw std::runtime_error(std::format("{} has no [{}]: written before each detector had its own parameter; re-dump it", path, section));
+  }
+  o2::conf::ConfigurableParam::updateFromFile(path, section + ",HBFUtils");
+  const auto echo = (std::filesystem::temp_directory_path() / std::format("gtrk-track-bench-{}.ini", getpid())).string();
+  study::writeParameters(echo);
+  for (const std::string& name : {section, std::string{"HBFUtils"}}) {
+    const auto read = iniSection(echo, name);
+    for (const auto& line : iniSection(path, name)) {
+      if (std::ranges::find(read, line) == read.end()) {
+        std::filesystem::remove(echo);
+        throw std::runtime_error(std::format("[{}] of {} does not read back as written: {}", name, path, line));
+      }
+    }
+  }
+  std::filesystem::remove(echo);
+}
+
+/// One slice's stage outputs as digests: where two runs first part, when
+/// their track digests differ.
+template <DetectorLayout Det>
+void printStageDigests(const typename Controller<Det>::SliceObservation& slice)
+{
+  const auto stage = [](const auto& output) {
+    Digest digest;
+    digest.column(output.offsets());
+    digest.columns(output.view(), output.size());
+    return digest.result();
+  };
+  const auto& result = *slice.result;
+  Digest roads;
+  roads.column(slice.roads->roads());
+  roads.column(slice.roads->starts());
+  roads.column(slice.roads->roadOffsets());
+  std::cout << std::format("  stage digests, iteration {} slice [{}, {}): tracklets {:016x} triplets {:016x} neighbours {:016x} roads {:016x} records {:016x}\n", slice.iteration, slice.slice->coreBlocks.begin, slice.slice->coreBlocks.end, stage(*result.tracklets), stage(*result.triplets), stage(*result.neighbours), roads.result(), stage(*slice.records));
+}
+
+/// Every accepted triplet's and neighbour's fit inputs of one slice, with the
+/// scattering variances the stages fitted them with: the iteration's table,
+/// a kinked triplet's middle layer scaled by the kink allowance
+/// (`graphKinkScale2`) in its own fit and in its neighbours'.
+template <DetectorLayout Det>
+void collectFitInputs(const typename Controller<Det>::SliceObservation& slice, const IterationParameters<Det>& parameters, study::FitInputs& inputs)
+{
+  const auto& frame = *slice.frame;
+  const auto& result = *slice.result;
+  const auto tracklets = result.tracklets->view();
+  const auto triplets = result.triplets->view();
+  const auto neighbours = result.neighbours->view();
+  const auto neighbourOffsets = result.neighbours->offsets();
+  const auto point = [&](auto row) { return pairPoint(frame.measurement(row)); };
+  const auto iteration = static_cast<std::uint32_t>(slice.iteration);
+  const Scalar tripletChi2Max = parameters.pairCut.nSigma * parameters.pairCut.nSigma;
+  const auto kinkScale = [&](std::size_t triplet) { return triplets.kinked[triplet] != 0U ? parameters.graphKinkScale2 : 1.F; };
+  for (std::size_t triplet = 0; triplet < result.triplets->size(); ++triplet) {
+    const auto first = triplets.first[triplet];
+    const auto second = triplets.second[triplet];
+    const LayerID middleLayer = parameters.linkTargets[tracklets.link[first]];
+    const auto a = point(tracklets.source[first]);
+    const auto b = point(tracklets.target[first]);
+    const auto c = point(tracklets.target[second]);
+    inputs.triplets.push_back({
+      .first = a,
+      .middle = b,
+      .third = c,
+      .variance = tripletScattering(parameters.scattering, parameters.pairCut, middleLayer, a, b, c, detail::referenceSinTheta(a, c), kinkScale(triplet)),
+      .chi2Max = tripletChi2Max,
+      .curvature = triplets.curvature[triplet],
+      .varCurvature = triplets.varCurvature[triplet],
+      .iteration = iteration,
+    });
+  }
+  for (std::size_t element = 0; element + 1U < neighbourOffsets.size(); ++element) {
+    const auto shared = triplets.first[element];
+    const auto last = triplets.second[element];
+    const std::size_t link = tracklets.link[shared];
+    const auto b = point(tracklets.source[shared]);
+    const auto c = point(tracklets.target[shared]);
+    const auto d = point(tracklets.target[last]);
+    for (auto neighbour = neighbourOffsets[element]; neighbour < neighbourOffsets[element + 1U]; ++neighbour) {
+      const auto from = neighbours.from[neighbour];
+      const auto a = point(tracklets.source[triplets.first[from]]);
+      const auto scattering = adjacentScattering(parameters.scattering, parameters.pairCut, parameters.linkSources[link], parameters.linkTargets[link], a, b, c, d, detail::referenceSinTheta(a, c), detail::referenceSinTheta(b, d), kinkScale(from), kinkScale(element));
+      inputs.neighbours.push_back({
+        .a = a,
+        .b = b,
+        .c = c,
+        .d = d,
+        .varianceSecond = scattering.second,
+        .varianceThird = scattering.third,
+        .covariance = scattering.covariance,
+        .chi2Max = parameters.neighbourChi2Max,
+        .iteration = iteration,
+      });
+    }
+  }
+}
+
+/// One iteration's work counts, where the build counts (GTRK_WORK_COUNTERS).
+inline void printWork(const WorkCounts& work, std::size_t iteration)
+{
+  using enum WorkCounter;
+  const auto at = [&](WorkCounter counter) { return work[static_cast<std::size_t>(counter)]; };
+  const auto perFit = [&](WorkCounter nanoseconds, WorkCounter fits) { return at(fits) == 0U ? 0. : static_cast<double>(at(nanoseconds)) / static_cast<double>(at(fits)); };
+  std::cout << std::format(
+    "  work, iteration {}, triplets: {} first tracklets ({} without a middle), {} in the dip-angle window; rejected {} by time, {} by "
+    "curvature; {} fits, {} failed, {} over chi2, {} over chi2 at their own momentum; {} accepted ({} with the kink allowance); {:.1f} ns/fit\n",
+    iteration, at(kTripletFirsts), at(kTripletNoMiddle), at(kTripletWindow), at(kTripletTime), at(kTripletCurvature), at(kTripletFits), at(kTripletFitFailed), at(kTripletChi2), at(kTripletOwnMomentum), at(kTripletFits) - at(kTripletFitFailed) - at(kTripletChi2) - at(kTripletOwnMomentum), at(kTripletKinked), perFit(kTripletFitNS, kTripletFits));
+  std::cout << std::format(
+    "  work, iteration {}, neighbours: {} triplets, {} candidates ({} both kinked); rejected {} by curvature, {} by time; {} fits, {} failed, {} over "
+    "chi2; {} accepted; {:.1f} ns/fit\n",
+    iteration, at(kNeighbourTriplets), at(kNeighbourCandidates), at(kNeighbourBothKinked), at(kNeighbourCurvature), at(kNeighbourTime), at(kNeighbourFits), at(kNeighbourFitFailed), at(kNeighbourChi2), at(kNeighbourFits) - at(kNeighbourFitFailed) - at(kNeighbourChi2), perFit(kNeighbourFitNS, kNeighbourFits));
+  std::cout << std::format(
+    "  work, iteration {}, roads: {} without a common time, {} fitted, {} of {} filter steps taken; rejected {} by chi2, {} by propagation, {} "
+    "below the pT floor, {} by the beam line; {} accepted ({} of them without their innermost clusters, of {} such fits)\n",
+    iteration, at(kRoadTime), at(kRoadFits), at(kRoadSteps), at(kRoadStepsPossible), at(kRoadChi2), at(kRoadPropagation), at(kRoadFloor), at(kRoadBeam), at(kRoadAccepted), at(kRoadTrimAccepted), at(kRoadTrimFits));
+  std::cout << std::format(
+    "  work, iteration {}, tracklets: {} sources, {} queries, {} not made as every pair would cross another layer; {} candidates held by earlier "
+    "tracks, {} crossing another layer, {} refused at the bound on a kink between the layers, {} pair tests, {} past the transverse test, {} past "
+    "the longitudinal one, {} accepted; inside their query's window: {} candidates, {} refused at the bound, {} pair tests, {} longitudinal tests; {} accepted "
+    "outside it\n",
+    iteration, at(kTrackletSources), at(kTrackletQueries), at(kTrackletHoleQueries), at(kTrackletUsed), at(kTrackletHoles), at(kPairBetweenBound), at(kPairTests), at(kPairTransverse), at(kPairLongitudinal), at(kTrackletAccepted), at(kTrackletInWindow), at(kPairBetweenBoundIn), at(kPairTestsIn), at(kPairLongitudinalTestsIn), at(kTrackletAcceptedOutside));
+  std::cout << std::format(
+    "  work, iteration {}, grid (tracklets): {} queries over {} blocks; {} ranges over {} cells, {} of them searched; {} "
+    "rows, {} in the time bound, {} past the time cut\n",
+    iteration, at(kGridQueries), at(kGridBlocks), at(kGridRanges), at(kGridCells), at(kGridSearchedCells), at(kGridRows), at(kGridInBound), at(kGridVisits));
+  std::cout << std::format(
+    "  work, iteration {}, grid (follow): {} queries over {} blocks; {} ranges over {} cells, {} of them searched; {} "
+    "rows, {} in the time bound, {} past the time cut; {} updates; {} rows proposed, {} outbid, {} with a failed refit\n",
+    iteration, at(kFollowGridQueries), at(kFollowGridBlocks), at(kFollowGridRanges), at(kFollowGridCells), at(kFollowGridSearchedCells), at(kFollowGridRows), at(kFollowGridInBound), at(kFollowGridVisits), at(kFollowUpdates), at(kFollowProposed), at(kFollowOutbid), at(kFollowRefitRejected));
+  std::cout << std::format(
+    "  work, iteration {}, follow: {} layers without a row tested, {} of them holes; {} lookaheads; {} kink passes, {} taken, {} "
+    "updates, {} witness updates, {} rows dropped with a witness; {} last rows unconfirmed, {} kept on their density, {} refused at "
+    "the layout's end, {} against the beam line; {} road ends fitted again, {} replaced\n",
+    iteration, at(kFollowHoleTests), at(kFollowHoles), at(kFollowLookaheads), at(kFollowKinkSteps), at(kFollowKinksTaken), at(kFollowKinkUpdates), at(kFollowWitnessUpdates), at(kFollowWitnessTrimmed), at(kFollowUnconfirmed), at(kFollowDensityKept), at(kFollowEndRefused), at(kFollowBeamEndRefused), at(kFollowEndFits), at(kFollowEndReplaced));
+  if (at(kTrackletShape) != 0U || at(kTripletShape) != 0U) {
+    std::cout << std::format("  work, iteration {}, shapes: {} tracklet candidates and {} thirds refused\n", iteration, at(kTrackletShape), at(kTripletShape));
+  }
+  if (at(kFollowTrimFits) != 0U) {
+    std::cout << std::format("  work, iteration {}, follow trim: {} tracks refitted without their last outward row, {} trimmed, {} updates\n", iteration, at(kFollowTrimFits), at(kFollowTrimmed), at(kFollowTrimUpdates));
+  }
+  if (at(kFollowEarlierProposed) != 0U) {
+    std::cout << std::format("  work, iteration {}, earlier iterations' follow: {} rows proposed, {} outbid, {} with a failed refit\n", iteration, at(kFollowEarlierProposed), at(kFollowEarlierOutbid), at(kFollowEarlierRefitRejected));
+  }
+  std::cout << std::format("  work, iteration {}, propagations: {} plane crossings, {} at |n . d| <= 0.1\n", iteration, at(kPropagations), at(kPropagationsGrazing));
+  std::cout << std::format(
+    "  work, iteration {}, tracklet sort: {} sources with 2+ tracklets ({} tracklets, {:.1f} each); {} with more than 8, {} more than 32 ({} "
+    "tracklets), {} more than 128, {} more than 512\n",
+    iteration, at(kSortSegments), at(kSortTracklets), at(kSortSegments) == 0U ? 0. : static_cast<double>(at(kSortTracklets)) / static_cast<double>(at(kSortSegments)), at(kSortSegmentsOver8), at(kSortSegmentsOver32), at(kSortTrackletsOver32), at(kSortSegmentsOver128), at(kSortSegmentsOver512));
+}
+
+/// One iteration's tracklet counts per link, the links with a query.
+template <DetectorLayout Det>
+void printLinkWork(const LinkWorkCounts& work, std::size_t iteration)
+{
+  for (std::size_t link = 0; link < work.size(); ++link) {
+    const auto& counts = work[link];
+    if (counts[static_cast<std::size_t>(LinkCounter::kQueries)] == 0U) {
+      continue;
+    }
+    std::cout << std::format("  work, iteration {}, link {} ({} -> {}): {} queries, {} pair candidates, {} tracklets\n", iteration, link, Det::layerLinks[link].from, Det::layerLinks[link].to, counts[static_cast<std::size_t>(LinkCounter::kQueries)], counts[static_cast<std::size_t>(LinkCounter::kCandidates)], counts[static_cast<std::size_t>(LinkCounter::kTracklets)]);
+  }
+}
+
+/// \a values as a JSON array.
+template <std::size_t N>
+std::string jsonArray(const std::array<std::uint64_t, N>& values)
+{
+  std::string out = "[";
+  for (std::size_t index = 0; index < N; ++index) {
+    out += std::format("{}{}", index == 0U ? "" : ",", values[index]);
+  }
+  return out + "]";
+}
+
+template <std::size_t N>
+std::string jsonArray(const std::array<double, N>& values)
+{
+  std::string out = "[";
+  for (std::size_t index = 0; index < N; ++index) {
+    out += std::format("{}{:.6g}", index == 0U ? "" : ",", values[index]);
+  }
+  return out + "]";
+}
+
+inline std::string jsonScore(const study::FindableScore& r)
+{
+  std::string species;
+  for (const auto& [pdg, counts] : r.bySpecies) {
+    species += std::format(R"({}"{}":{})", species.empty() ? "" : ",", pdg, jsonArray(counts));
+  }
+  return std::format(R"({{"findable":{},"found":{},"fakeOnly":{},"cloned":{},"cloneTracks":{},"withFake":{},"findableByPt":{},"foundByPt":{},)"
+                     R"("findableByEta":{},"foundByEta":{},"findableByPhi":{},"foundByPhi":{},"complete":{},"completeByPt":{},"layersFound":{},)"
+                     R"("layersOf":{},"layerFraction":{:.6g},"layerFractionByPt":{},"bySpecies":{{{}}}}})",
+                     r.findable, r.found, r.fakeOnly, r.cloned, r.cloneTracks, r.withFake, jsonArray(r.findableByPt), jsonArray(r.foundByPt), jsonArray(r.findableByEta), jsonArray(r.foundByEta), jsonArray(r.findableByPhi), jsonArray(r.foundByPhi), r.complete, jsonArray(r.completeByPt), r.layersFound, r.layersOf, r.layerFraction, jsonArray(r.layerFractionByPt), species);
+}
+
+/// One score per particle origin, in ParticleOrigin's order.
+template <std::size_t N>
+std::string jsonScores(const std::array<study::FindableScore, N>& scores)
+{
+  std::string out = "[";
+  for (std::size_t origin = 0; origin < scores.size(); ++origin) {
+    out += (origin == 0U ? "" : ",") + jsonScore(scores[origin]);
+  }
+  return out + "]";
+}
+
+/// The decay daughters: per DecayFamily, per production bin, [on minLayers
+/// or more, found of them, findable, found of them].
+inline std::string jsonDecays(const study::TrackScore& score, const study::ComparisonSettings& settings)
+{
+  std::string edges = "[";
+  for (std::size_t index = 0; index < settings.productionEdges.size(); ++index) {
+    edges += std::format("{}{}", index == 0U ? "" : ",", settings.productionEdges[index]);
+  }
+  std::string families = "[";
+  for (std::size_t family = 0; family < score.decays.size(); ++family) {
+    families += family == 0U ? "[" : ",[";
+    for (std::size_t bin = 0; bin < score.decays[family].size(); ++bin) {
+      const auto& counts = score.decays[family][bin];
+      families += std::format("{}[{},{},{},{}]", bin == 0U ? "" : ",", counts.onMinLayers, counts.foundOnMinLayers, counts.findable, counts.found);
+    }
+    families += "]";
+  }
+  return std::format(R"({{"productionEdges":{}],"alongZ":{},"byFamily":{}]}})", edges, settings.productionAlongZ, families);
+}
+
+/// \a score as JSON: counts only; the bins are TrackComparison.h's, the
+/// species |PDG codes|.
+inline std::string jsonScore(const study::TrackScore& score, const study::ComparisonSettings& settings, double seconds)
+{
+  return std::format(R"({{"seconds":{:.6f},"tracks":{},"fakes":{},"tracksByLength":{},"fakesByLength":{},"allLayers":{},"minLayers":{},"o2":{},)"
+                     R"("originAllLayers":{},"originMinLayers":{},"originFindable":{},"primaryRegion":{},"decays":{}}})",
+                     seconds, score.tracks, score.fakes, jsonArray(score.tracksByLength), jsonArray(score.fakesByLength), jsonScore(score.allLayers), jsonScore(score.minLayers), jsonScore(score.o2), jsonScores(score.originAllLayers), jsonScores(score.originMinLayers), jsonScores(score.originFindable), jsonScores(score.primaryRegion), jsonDecays(score, settings));
+}
+
+/// The seed sets' coverage of the findable: by class, the fraction with a measurement on every layer of a set,
+/// and on all but one, for each set of \a masks and for any of them.
+inline void printSeedCoverage(const study::TrackingTruth& truth, const study::ComparisonSettings& comparison, std::span<const std::uint64_t> masks)
+{
+  using study::ParticleOrigin;
+  constexpr std::size_t kClasses = 5U;
+  constexpr std::array<std::string_view, kClasses> kNames{"primaries", "barrel", "disc", "pT 0.1-0.2", "decays"};
+  // Layer counts up to this many, the last slot holding the longer ones.
+  constexpr std::size_t kLengthSlots = 12U;
+  struct Counts {
+    std::uint64_t findable = 0U;
+    std::vector<std::uint64_t> all;
+    std::vector<std::uint64_t> allButOne;
+    std::array<std::uint64_t, kLengthSlots + 1U> layers{};
+  };
+  std::array<Counts, kClasses> counts;
+  for (auto& count : counts) {
+    count.all.assign(masks.size() + 1U, 0U);
+    count.allButOne.assign(masks.size() + 1U, 0U);
+  }
+  for (const auto& [id, layers] : study::particleLayers(truth.rows, comparison)) {
+    const auto found = truth.particles.find(id);
+    if (found == truth.particles.end() || !study::isFindable(found->second.pt, layers, comparison)) {
+      continue;
+    }
+    const auto& particle = found->second;
+    std::array<bool, kClasses> in{};
+    if (particle.origin == ParticleOrigin::kPhysicalPrimary) {
+      const bool disc = (layers.layers & ~comparison.barrelLayers) != 0U;
+      in = {true, !disc, disc, particle.pt < 0.2F, false};
+    } else if (particle.origin == ParticleOrigin::kDecay) {
+      in[4] = true;
+    }
+    bool anyAll = false;
+    bool anyAllButOne = false;
+    std::vector<bool> all(masks.size());
+    std::vector<bool> allButOne(masks.size());
+    for (std::size_t set = 0; set < masks.size(); ++set) {
+      const int missing = std::popcount(masks[set] & ~layers.layers);
+      all[set] = missing == 0;
+      allButOne[set] = missing <= 1;
+      anyAll = anyAll || all[set];
+      anyAllButOne = anyAllButOne || allButOne[set];
+    }
+    for (std::size_t c = 0; c < kClasses; ++c) {
+      if (!in[c]) {
+        continue;
+      }
+      ++counts[c].findable;
+      ++counts[c].layers[std::min<std::size_t>(static_cast<std::size_t>(std::popcount(layers.layers)), kLengthSlots)];
+      for (std::size_t set = 0; set < masks.size(); ++set) {
+        counts[c].all[set] += all[set] ? 1U : 0U;
+        counts[c].allButOne[set] += allButOne[set] ? 1U : 0U;
+      }
+      counts[c].all.back() += anyAll ? 1U : 0U;
+      counts[c].allButOne.back() += anyAllButOne ? 1U : 0U;
+    }
+  }
+  using study::percent;
+  std::cout << "seed coverage of the findable, % on every layer of a set (on all but one):\n";
+  for (std::size_t c = 0; c < kClasses; ++c) {
+    std::string line = std::format("  {:<11} {:8d}:", kNames[c], counts[c].findable);
+    for (std::size_t set = 0; set <= masks.size(); ++set) {
+      line += std::format(" {} {:.2f} ({:.2f})", set < masks.size() ? std::format("set {}", masks[set]) : std::string{"any"}, percent(counts[c].all[set], counts[c].findable), percent(counts[c].allButOne[set], counts[c].findable));
+    }
+    std::cout << line << '\n';
+  }
+  std::cout << "  the same by the layers they have a measurement on, % with at least n:\n";
+  for (std::size_t c = 0; c < kClasses; ++c) {
+    std::string line = std::format("  {:<11}", kNames[c]);
+    std::uint64_t atLeast = counts[c].findable;
+    for (std::size_t n = 0; n <= kLengthSlots; ++n) {
+      if (n >= 4U) {
+        line += std::format(" {}{}: {:.2f}", n, n == kLengthSlots ? "+" : "", percent(atLeast, counts[c].findable));
+      }
+      atLeast -= counts[c].layers[n];
+    }
+    std::cout << line << '\n';
+  }
+}
+
+/// The process's peak resident memory so far [bytes].
+inline std::uint64_t maxRssBytes()
+{
+  rusage usage{};
+  getrusage(RUSAGE_SELF, &usage);
+  constexpr std::uint64_t kBytesPerKiB = 1024U;
+  return static_cast<std::uint64_t>(usage.ru_maxrss) * kBytesPerKiB; // NOLINT(cppcoreguidelines-pro-type-union-access): glibc's rusage
+}
+
+/// \a tracks into \a path as text, one per line: the iteration, the clusters
+/// as cluster numbers, the chi2 -- to diff two runs' tracks.
+template <DetectorLayout Det>
+void writeTracks(const std::string& path, const typename TrackRefit<Det>::Tracks& tracks, const TimeFrame<Det>& frame)
+{
+  std::ofstream out(path);
+  if (!out) {
+    throw std::runtime_error("cannot write " + path);
+  }
+  const auto columns = frame.measurements();
+  const auto view = tracks.view();
+  for (std::size_t track = 0; track < tracks.size(); ++track) {
+    out << static_cast<int>(view.iteration[track]);
+    for (std::size_t at = 0; at < view.count[track]; ++at) {
+      out << ' ' << columns.clusterIndex[view.clusters[track].index[at]];
+    }
+    out << std::format(" chi2 {:.6g}\n", static_cast<double>(view.chi2[track]));
+  }
+}
+
+/// The checkpoint file of --save-state and --resume-state: a header, then
+/// each part raw -- the first iterations' settings, which --resume-state checks against its own, their summaries, the used mask and
+/// the tracks. The header's fingerprints hold what else the iterations read:
+/// the frame (every measurement column, so also the grid's row order, which
+/// the configuration's every iteration sizes) and the conditions (the beam
+/// line, the dump's vertices, the slicing). Read back by the same build only
+/// (the header's sizes; the caller's file names carry the build).
+struct CheckpointHeader {
+  std::array<char, 8> magic{'G', 'T', 'R', 'K', 'C', 'K', 'P', '2'};
+  std::uint64_t frame = 0U;
+  std::uint64_t conditions = 0U;
+  std::uint64_t iterations = 0U;
+  std::uint64_t rows = 0U;
+  std::uint64_t tracks = 0U;
+  std::uint64_t settingsBytes = 0U;
+  std::uint64_t summaryBytes = 0U;
+  std::uint64_t trackBytes = 0U;
+};
+
+/// The checkpoint's frame fingerprint: every measurement column of \a frame.
+template <DetectorLayout Det>
+std::uint64_t checkpointFrame(const TimeFrame<Det>& frame)
+{
+  Digest digest;
+  digest.columns(frame.measurements(), frame.size());
+  return digest.result();
+}
+
+/// Its conditions' fingerprint: \a beamLine, \a vertices, \a blocksPerSlice and \a haloPS.
+inline std::uint64_t checkpointConditions(const workflow::BeamLine& beamLine, std::span<const VertexSeed> vertices, std::int32_t blocksPerSlice, std::int64_t haloPS)
+{
+  Digest digest;
+  for (const double value : {beamLine.x, beamLine.y, beamLine.z, beamLine.sigmaX, beamLine.sigmaY, beamLine.sigmaZ}) {
+    digest.add(value);
+  }
+  digest.add(vertices.size());
+  for (const auto& vertex : vertices) {
+    digest.add(vertex.timePS);
+    digest.add(vertex.widthPS);
+    digest.add(vertex.z);
+    digest.add(vertex.varZ);
+    digest.add(vertex.varTransverse);
+  }
+  digest.add(blocksPerSlice);
+  digest.add(haloPS);
+  return digest.result();
+}
+
+template <typename Checkpoint>
+void writeCheckpoint(const std::string& path, const Checkpoint& state, std::span<const IterationSettings> settings, std::uint64_t frame, std::uint64_t conditions)
+{
+  using Summary = typename decltype(state.summaries)::value_type;
+  using Record = typename decltype(state.tracks)::value_type;
+  static_assert(std::is_trivially_copyable_v<IterationSettings> && std::is_trivially_copyable_v<Summary> && std::is_trivially_copyable_v<Record>);
+  std::ofstream out(path, std::ios::binary);
+  if (!out) {
+    throw std::runtime_error("cannot write " + path);
+  }
+  const CheckpointHeader header{
+    .frame = frame,
+    .conditions = conditions,
+    .iterations = state.summaries.size(),
+    .rows = state.used.size(),
+    .tracks = state.tracks.size(),
+    .settingsBytes = sizeof(IterationSettings),
+    .summaryBytes = sizeof(Summary),
+    .trackBytes = sizeof(Record),
+  };
+  const auto write = [&](const auto* data, std::size_t count) {
+    out.write(reinterpret_cast<const char*>(data), static_cast<std::streamsize>(count * sizeof(*data))); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+  };
+  write(&header, 1U);
+  write(settings.data(), state.summaries.size());
+  write(state.summaries.data(), state.summaries.size());
+  write(state.used.data(), state.used.size());
+  write(state.tracks.data(), state.tracks.size());
+  if (!out) {
+    throw std::runtime_error("cannot write " + path);
+  }
+}
+
+/// The checkpoint in \a path, whose iterations must be the first of \a settings,
+/// on the frame and conditions of the fingerprints \a frame and \a conditions.
+template <typename Checkpoint>
+Checkpoint readCheckpoint(const std::string& path, std::span<const IterationSettings> settings, std::uint64_t frame, std::uint64_t conditions)
+{
+  using Summary = typename decltype(Checkpoint::summaries)::value_type;
+  using Record = typename decltype(Checkpoint::tracks)::value_type;
+  std::ifstream in(path, std::ios::binary);
+  if (!in) {
+    throw std::runtime_error("cannot read " + path);
+  }
+  const auto read = [&](auto* data, std::size_t count) {
+    in.read(reinterpret_cast<char*>(data), static_cast<std::streamsize>(count * sizeof(*data))); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+    if (!in) {
+      throw std::runtime_error(path + " is cut short");
+    }
+  };
+  CheckpointHeader header;
+  const auto magic = header.magic;
+  read(&header, 1U);
+  if (header.magic != magic || header.settingsBytes != sizeof(IterationSettings) || header.summaryBytes != sizeof(Summary) || header.trackBytes != sizeof(Record)) {
+    throw std::runtime_error(path + " is not a checkpoint of this build");
+  }
+  const auto bytes = sizeof(header) + (header.iterations * (header.settingsBytes + header.summaryBytes)) + header.rows + (header.tracks * header.trackBytes);
+  if (std::filesystem::file_size(path) != bytes) {
+    throw std::runtime_error(std::format("{} has {} bytes, its header promises {}", path, std::filesystem::file_size(path), bytes));
+  }
+  if (header.frame != frame || header.conditions != conditions) {
+    throw std::runtime_error(path + " was saved on another frame or with other conditions (beam line, vertices, slicing)");
+  }
+  if (header.iterations > settings.size()) {
+    throw std::runtime_error(std::format("{} holds {} iterations, the configuration has {}", path, header.iterations, settings.size()));
+  }
+  std::vector<IterationSettings> saved(header.iterations);
+  read(saved.data(), saved.size());
+  for (std::size_t iteration = 0; iteration < saved.size(); ++iteration) {
+    if (!(saved[iteration] == settings[iteration])) {
+      throw std::runtime_error(std::format("{}: iteration {} was run with other settings than the configuration's", path, iteration));
+    }
+  }
+  Checkpoint state;
+  state.summaries.resize(header.iterations);
+  state.used.resize(header.rows);
+  state.tracks.resize(header.tracks);
+  read(state.summaries.data(), state.summaries.size());
+  read(state.used.data(), state.used.size());
+  read(state.tracks.data(), state.tracks.size());
+  return state;
+}
+
+/// The follow's rows of \a iteration's own tracks, inward and outward, into
+/// \a followed by track (for --fakes-out).
+template <typename Observation>
+void recordFollowed(const Observation& iteration, std::vector<std::array<std::uint8_t, 2>>& followed)
+{
+  if (iteration.iteration == 0U) {
+    followed.clear();
+  }
+  followed.resize(iteration.tracks->size());
+  for (std::size_t i = 0; i < iteration.proposals.size(); ++i) {
+    followed[iteration.trackOffset + i] = {iteration.proposals[i].inwardCount, iteration.proposals[i].outwardCount};
+  }
+}
+
+/// Every track of the last run against \a truth, for the study of the
+/// follow's fakes: one `T` line per
+/// track -- iteration, clusters, its own iteration's follow's rows inward and
+/// outward (\a followed, from the iteration observer) and the earlier
+/// iterations' follows' (`followEarlier`: what the track added beyond its
+/// own follow's), good (1) or not, its majority particle's rows on it, then
+/// of the rows not carrying that particle those in the road, its follow's
+/// inward, outward and the earlier follows', and how many of them carry no
+/// particle at all;
+/// then the majority particle (0 for noise only), its origin (0 primary, 1
+/// decay, 2 material, 3 none), pT, whether it is a findable physical
+/// primary, its rows in the frame, of them held by a good track of its own,
+/// held by another track, and the layer of the track's first wrong row;
+/// then the track's chi2 and, from \a stagesOf (the funnel, with --funnel),
+/// that particle's longest chain of its own in the track's iteration at each
+/// stage, tracklets to the road fit, its road loss, its fit loss and its
+/// adjacent pairs not kept by each PairLoss, then the best chi2 of its
+/// longest records and the chi2 of the track's own record (\a recordChi2 of
+/// its road's rows) (-1 each without), then the track's eta at its fit's
+/// state, its majority particle's (-99 for noise only) and the bits of the
+/// layers its rows sit on.
+/// A fake has a `W` line per wrong row: the track, the row's position on it
+/// and the road's first and end positions, its layer, its part (0 road, 1
+/// follow inward, 2 outward, 3 earlier follows), whether it carries no
+/// particle, its first particle, that one's origin and pT and whether it has
+/// a good track, then the majority particle's rows on that layer: how many,
+/// free, held by a good track of its own, held by another track; then the
+/// wrong row's errors in r-phi and z [cm], and for the nearest of those own
+/// rows its errors and its distance to the wrong row, transverse and in z
+/// [cm] (-1 each without one); then the PDG codes of the majority particle,
+/// of the wrong row's particle and of that one's mother, and the wrong row's
+/// particle's production radius [cm] (for the road fakes).
+template <DetectorLayout Det, typename StagesOf, typename RecordChi2>
+void writeFakes(const std::string& path, const typename TrackRefit<Det>::Tracks& tracks, const study::TrackingTruth& truth, const study::ComparisonSettings& settings, const TimeFrame<Det>& frame, const std::vector<std::array<std::uint8_t, 2>>& followed, StagesOf stagesOf, RecordChi2 recordChi2)
+{
+  std::ofstream out(path);
+  if (!out) {
+    throw std::runtime_error("cannot write " + path);
+  }
+  const auto view = tracks.view();
+  const auto rows = trackRows(tracks);
+  std::vector<std::uint64_t> goodOf(rows.size(), study::kNoTrackParticle);
+  // Per row, the track holding it.
+  std::vector<std::uint32_t> holder;
+  holder.assign(truth.rows.size(), std::numeric_limits<std::uint32_t>::max());
+  for (std::size_t track = 0; track < rows.size(); ++track) {
+    goodOf[track] = study::goodParticle(truth.rows, rows[track]);
+    for (const auto row : rows[track]) {
+      holder[row] = static_cast<std::uint32_t>(track);
+    }
+  }
+  auto rowsOf = study::rowsOfParticles(truth.rows);
+  const auto layers = study::particleLayers(truth.rows, settings);
+  const std::unordered_set<std::uint64_t> withGood(goodOf.begin(), goodOf.end());
+  for (std::size_t track = 0; track < rows.size(); ++track) {
+    const auto& own = rows[track];
+    const auto count = static_cast<std::uint32_t>(own.size());
+    // The rows in order: the earlier follows' inward, the own follow's
+    // inward, the road, the own follow's outward, the earlier follows'
+    // outward.
+    const std::uint32_t followIn = track < followed.size() ? followed[track][0] : 0U;
+    const std::uint32_t followOut = track < followed.size() ? followed[track][1] : 0U;
+    const std::uint32_t earlierIn = view.addedInward[track] >= followIn ? view.addedInward[track] - followIn : 0U;
+    const std::uint32_t earlierOut = view.addedOutward[track] >= followOut ? view.addedOutward[track] - followOut : 0U;
+    const auto majority = study::majorityParticle(truth.rows, own);
+    std::array<std::uint32_t, 4> wrong{};
+    std::uint32_t noise = 0U;
+    int firstWrongLayer = -1;
+    std::vector<std::pair<std::uint32_t, std::size_t>> wrongRows; // position, part
+    for (std::uint32_t i = 0; i < count; ++i) {
+      const auto& at = truth.rows[own[i]];
+      if (majority.particle != study::kNoTrackParticle && at.carries(majority.particle)) {
+        continue;
+      }
+      std::size_t part = 0U; // the road
+      if (i < earlierIn || i >= count - earlierOut) {
+        part = 3U;
+      } else if (i < earlierIn + followIn) {
+        part = 1U;
+      } else if (i >= count - earlierOut - followOut) {
+        part = 2U;
+      }
+      ++wrong[part];
+      wrongRows.emplace_back(i, part);
+      noise += at.count == 0U ? 1U : 0U;
+      if (firstWrongLayer < 0) {
+        firstWrongLayer = at.layer;
+      }
+    }
+    int origin = 3;
+    float pt = 0.F;
+    int findable = 0;
+    std::uint32_t total = 0U;
+    std::uint32_t heldGood = 0U;
+    std::uint32_t heldOther = 0U;
+    if (majority.particle != study::kNoTrackParticle) {
+      const auto found = truth.particles.find(majority.particle);
+      if (found != truth.particles.end()) {
+        origin = static_cast<int>(found->second.origin);
+        pt = found->second.pt;
+        const auto chain = layers.find(majority.particle);
+        findable = found->second.origin == study::ParticleOrigin::kPhysicalPrimary && chain != layers.end() && study::isFindable(found->second.pt, chain->second, settings) ? 1 : 0;
+      }
+      for (const auto row : rowsOf[majority.particle]) {
+        ++total;
+        const auto by = holder[row];
+        if (by == std::numeric_limits<std::uint32_t>::max() || by == track) {
+          continue;
+        }
+        (goodOf[by] == majority.particle ? heldGood : heldOther) += 1U;
+      }
+    }
+    out << std::format("T {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {:.4f} {} {} {} {} {}", static_cast<int>(view.iteration[track]), count, followIn, followOut, earlierIn + earlierOut, goodOf[track] != study::kNoTrackParticle ? 1 : 0, majority.carried, wrong[0], wrong[1], wrong[2], wrong[3], noise, majority.particle == study::kNoTrackParticle ? 0U : majority.particle, origin, findable, static_cast<double>(pt), total, heldGood, heldOther, firstWrongLayer, track);
+    out << std::format(" {:.6g}", static_cast<double>(view.chi2[track]));
+    const auto stages = majority.particle == study::kNoTrackParticle ? std::nullopt : stagesOf(majority.particle, view.iteration[track]);
+    for (std::size_t stage = 0; stage < 5U; ++stage) {
+      out << ' ' << (stages ? static_cast<int>(stages->longest[stage]) : -1);
+    }
+    out << ' ' << (stages ? static_cast<int>(stages->roadLoss) : -1) << ' ' << (stages ? static_cast<int>(stages->fitLoss) : -1);
+    for (std::size_t reason = 0; reason < study::kPairLosses; ++reason) {
+      out << ' ' << (stages ? static_cast<std::int64_t>(stages->lostPairs[reason]) : -1);
+    }
+    const std::uint32_t roadBegin = earlierIn + followIn;
+    const std::uint32_t roadEnd = count - earlierOut - followOut;
+    const auto ownRecord = recordChi2(view.iteration[track], std::span<const std::uint32_t>{own}.subspan(roadBegin, roadEnd - roadBegin));
+    out << std::format(" {:.6g} {:.6g}", stages ? static_cast<double>(stages->recordChi2) : -1., ownRecord ? static_cast<double>(*ownRecord) : -1.);
+    const auto majorityFound = truth.particles.find(majority.particle);
+    std::uint64_t layerBits = 0U;
+    for (const auto row : own) {
+      layerBits |= std::uint64_t{1} << truth.rows[row].layer;
+    }
+    out << std::format(" {:.4f} {:.4f} {}\n", -std::log(std::tan(static_cast<double>(view.state[track].theta()) / 2.)), majorityFound != truth.particles.end() ? static_cast<double>(majorityFound->second.eta) : -99., layerBits);
+    if (goodOf[track] != study::kNoTrackParticle) {
+      continue;
+    }
+    for (const auto& [position, part] : wrongRows) {
+      const auto& at = truth.rows[own[position]];
+      const std::uint64_t particle = at.count == 0U ? 0U : at.particles[0];
+      int wrongOrigin = 3;
+      float wrongPt = 0.F;
+      std::array<std::int32_t, 3> pdgs{}; // the majority's, the wrong particle's, its mother's
+      float wrongRadius = -1.F;
+      if (const auto found = truth.particles.find(particle); at.count != 0U && found != truth.particles.end()) {
+        wrongOrigin = static_cast<int>(found->second.origin);
+        wrongPt = found->second.pt;
+        pdgs[1] = found->second.pdg;
+        pdgs[2] = found->second.motherPdg;
+        wrongRadius = std::hypot(found->second.vx, found->second.vy);
+      }
+      if (const auto found = truth.particles.find(majority.particle); found != truth.particles.end()) {
+        pdgs[0] = found->second.pdg;
+      }
+      std::array<std::uint32_t, 4> onLayer{}; // all, free, held by a good track of its own, held by another
+      const auto wrongAt = frame.measurement(own[position]);
+      std::array<double, 4> nearest{-1., -1., -1., -1.}; // its sigma r-phi and z, distance transverse and in z
+      double nearestDistance = std::numeric_limits<double>::max();
+      if (majority.particle != study::kNoTrackParticle) {
+        for (const auto row : rowsOf[majority.particle]) {
+          if (truth.rows[row].layer != at.layer) {
+            continue;
+          }
+          const auto ownAt = frame.measurement(row);
+          const double transverse = std::hypot(static_cast<double>(ownAt.x) - static_cast<double>(wrongAt.x), static_cast<double>(ownAt.y) - static_cast<double>(wrongAt.y));
+          const double dz = std::abs(static_cast<double>(ownAt.z) - static_cast<double>(wrongAt.z));
+          if (std::hypot(transverse, dz) < nearestDistance) {
+            nearestDistance = std::hypot(transverse, dz);
+            nearest = {std::sqrt(static_cast<double>(ownAt.varRPhi)), std::sqrt(static_cast<double>(ownAt.varZ)), transverse, dz};
+          }
+          ++onLayer[0];
+          const auto by = holder[row];
+          if (by == std::numeric_limits<std::uint32_t>::max()) {
+            ++onLayer[1];
+          } else {
+            ++onLayer[goodOf[by] == majority.particle ? 2 : 3];
+          }
+        }
+      }
+      out << std::format("W {} {} {} {} {} {} {} {} {} {:.4f} {} {} {} {} {} {:.5g} {:.5g} {:.5g} {:.5g} {:.5g} {:.5g} {} {} {} {:.4g}\n", track, position, roadBegin, roadEnd, static_cast<int>(at.layer), part, at.count == 0U ? 1 : 0, particle, wrongOrigin, static_cast<double>(wrongPt), at.count != 0U && withGood.contains(particle) ? 1 : 0, onLayer[0], onLayer[1], onLayer[2], onLayer[3], std::sqrt(static_cast<double>(wrongAt.varRPhi)), std::sqrt(static_cast<double>(wrongAt.varZ)), nearest[0], nearest[1], nearest[2], nearest[3], pdgs[0], pdgs[1], pdgs[2], static_cast<double>(wrongRadius));
+    }
+  }
+}
+
+/// The findable physical primaries and their good tracks against \a truth,
+/// for the clone study: one `P` line per
+/// particle (id, pT, eta, phi, PDG, vz, layer bits, chain, on a disc, good
+/// tracks), a `T` line per good track (iteration, rows) and, for a particle
+/// with two good tracks or more, an `R` line per row carrying it (row,
+/// layer, r, z, labels).
+template <DetectorLayout Det>
+void writeClones(const std::string& path, const typename TrackRefit<Det>::Tracks& tracks, const study::TrackingTruth& truth, const study::ComparisonSettings& settings)
+{
+  std::ofstream out(path);
+  if (!out) {
+    throw std::runtime_error("cannot write " + path);
+  }
+  const auto rows = trackRows(tracks);
+  const auto iterations = tracks.view().iteration;
+  std::unordered_map<std::uint64_t, std::vector<std::size_t>> goodTracks;
+  for (std::size_t track = 0; track < rows.size(); ++track) {
+    const auto particle = study::goodParticle(truth.rows, rows[track]);
+    if (particle != study::kNoTrackParticle) {
+      goodTracks[particle].push_back(track);
+    }
+  }
+  auto rowsOf = study::rowsOfParticles(truth.rows);
+  for (const auto& [id, layers] : study::particleLayers(truth.rows, settings)) {
+    const auto found = truth.particles.find(id);
+    if (found == truth.particles.end()) {
+      continue;
+    }
+    const auto& particle = found->second;
+    if (particle.origin != study::ParticleOrigin::kPhysicalPrimary || !study::isFindable(particle.pt, layers, settings)) {
+      continue;
+    }
+    const auto& good = goodTracks[id];
+    const bool disc = (layers.layers & ~settings.barrelLayers) != 0U;
+    out << std::format("P {} {:.5g} {:.5g} {:.5g} {} {:.5g} {} {} {} {}\n", id, particle.pt, particle.eta, particle.phi, particle.pdg, particle.vz, layers.layers, layers.chain, disc ? 1 : 0, good.size());
+    for (const auto track : good) {
+      out << "T " << static_cast<int>(iterations[track]);
+      for (const auto row : rows[track]) {
+        out << ' ' << row;
+      }
+      out << '\n';
+    }
+    if (good.size() < 2U) {
+      continue;
+    }
+    for (const auto row : rowsOf[id]) {
+      const auto& r = truth.rows[row];
+      out << std::format("R {} {} {:.4f} {:.4f} {}\n", row, static_cast<int>(r.layer), r.r, r.z, static_cast<int>(r.count));
+    }
+  }
+}
+
+/// Every row of the frame against \a truth, for occupancy studies:
+/// one line per row -- its layer, global x, y and z [cm], its
+/// particles' count, then its first particle's origin (0 primary, 1 decay,
+/// 2 material; 3 for noise), pT [GeV], eta, PDG code and production vertex
+/// x, y, z [cm] (zeros for noise), whether a good track of that particle
+/// exists in \a tracks, and whether a track of \a tracks holds the row.
+template <DetectorLayout Det>
+void writeRowsOut(const std::string& path, const typename TrackRefit<Det>::Tracks& tracks, const study::TrackingTruth& truth, const TimeFrame<Det>& frame)
+{
+  std::ofstream out(path);
+  if (!out) {
+    throw std::runtime_error("cannot write " + path);
+  }
+  std::unordered_set<std::uint64_t> withGood;
+  std::vector<bool> held(truth.rows.size());
+  for (const auto& rows : trackRows(tracks)) {
+    withGood.insert(study::goodParticle(truth.rows, rows));
+    for (const auto row : rows) {
+      held[row] = true;
+    }
+  }
+  for (std::uint32_t row = 0; row < truth.rows.size(); ++row) {
+    const auto& at = truth.rows[row];
+    const auto measurement = frame.measurement(row);
+    const auto cluster = static_cast<std::uint64_t>(frame.measurements().clusterIndex[row]);
+    out << std::format("{} {:.4f} {:.4f} {:.4f} {}", static_cast<int>(at.layer), static_cast<double>(measurement.x), static_cast<double>(measurement.y), static_cast<double>(measurement.z), static_cast<int>(at.count));
+    const auto found = at.count == 0U ? truth.particles.end() : truth.particles.find(at.particles[0]);
+    if (found == truth.particles.end()) {
+      out << std::format(" 3 0 0 0 0 0 0 0 {} {}\n", held[row] ? 1 : 0, cluster);
+      continue;
+    }
+    const auto& particle = found->second;
+    out << std::format(" {} {:.4f} {:.4f} {} {:.4g} {:.4g} {:.4g} {} {} {}\n", static_cast<int>(particle.origin), static_cast<double>(particle.pt), static_cast<double>(particle.eta), particle.pdg, static_cast<double>(particle.vx), static_cast<double>(particle.vy), static_cast<double>(particle.vz), withGood.contains(at.particles[0]) ? 1 : 0, held[row] ? 1 : 0, cluster);
+  }
+}
+
+/// The clone join: each findable physical primary with two good
+/// tracks or more, its tracks in the order of their outermost rows' distance
+/// from the origin; each one's outward state updated with the next one's rows
+/// in order, along the truth. At each step the true row's chi2, and the
+/// competition: every other row on that layer that the step's own predicted
+/// window and the inner track's time box admit, whose update passes the gate.
+/// One `J` line per join (particle, pT, eta, the two tracks' iterations,
+/// their counts) and an `S` line per step (layer, the true row's chi2, 1 if
+/// the window holds it, the wrong rows passing, the smallest wrong chi2, the
+/// gate) into \a path; every row a track holds at the end is counted, free
+/// or not.
+template <DetectorLayout Det, typename Material, typename ParametersOf>
+void writeCloneJoins(const std::string& path, const typename TrackRefit<Det>::Tracks& tracks, const study::TrackingTruth& truth, const study::ComparisonSettings& settings, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator, ParametersOf parametersOf)
+{
+  std::ofstream out(path);
+  if (!out) {
+    throw std::runtime_error("cannot write " + path);
+  }
+  const auto& measurements = frame.measurements();
+  // The widest row's box per layer, which bounds the time query.
+  std::array<std::uint32_t, static_cast<std::size_t>(Detector<Det>::nLayers)> widest{};
+  for (std::uint32_t row = 0; row < truth.rows.size(); ++row) {
+    const auto box = timeBoxAt(measurements, row);
+    auto& width = widest[truth.rows[row].layer];
+    width = std::max(width, box.upper() - box.lower());
+  }
+  const auto view = tracks.view();
+  const auto rows = trackRows(tracks);
+  std::unordered_map<std::uint64_t, std::vector<std::size_t>> goodTracks;
+  for (std::size_t track = 0; track < rows.size(); ++track) {
+    const auto particle = study::goodParticle(truth.rows, rows[track]);
+    if (particle != study::kNoTrackParticle && view.status[track] == PropagationStatus::kOk) {
+      goodTracks[particle].push_back(track);
+    }
+  }
+  const auto distance = [&](std::uint32_t row) {
+    const auto& at = truth.rows[row];
+    return (at.r * at.r) + (at.z * at.z);
+  };
+  for (const auto& [id, layers] : study::particleLayers(truth.rows, settings)) {
+    const auto found = truth.particles.find(id);
+    const auto good = goodTracks.find(id);
+    if (found == truth.particles.end() || good == goodTracks.end() || good->second.size() < 2U) {
+      continue;
+    }
+    const auto& particle = found->second;
+    if (particle.origin != study::ParticleOrigin::kPhysicalPrimary || !study::isFindable(particle.pt, layers, settings)) {
+      continue;
+    }
+    auto ordered = good->second;
+    const auto outermost = [&](std::size_t track) {
+      float most = 0.F;
+      for (const auto row : rows[track]) {
+        most = std::max(most, distance(row));
+      }
+      return most;
+    };
+    std::ranges::sort(ordered, [&](std::size_t a, std::size_t b) { return outermost(a) < outermost(b); });
+    for (std::size_t at = 0; at + 1U < ordered.size(); ++at) {
+      const auto inner = ordered[at];
+      const auto outer = ordered[at + 1U];
+      std::vector<std::uint32_t> next(rows[outer].begin(), rows[outer].end());
+      if (next.empty()) {
+        continue;
+      }
+      std::ranges::sort(next, [&](std::uint32_t a, std::uint32_t b) { return distance(a) < distance(b); });
+      out << std::format("J {} {:.5g} {:.5g} {} {} {} {} {}\n", id, particle.pt, particle.eta, static_cast<int>(view.iteration[inner]), static_cast<int>(view.iteration[outer]), rows[inner].size(), rows[outer].size(), distance(next.front()) > outermost(inner) ? 1 : 0);
+      const auto& parameters = parametersOf(view.iteration[inner]);
+      BoundTrackState state = view.outwardState[inner];
+      CovarianceFactors factors = factorCovariance(state.cov);
+      auto box = trackTimeBox(measurements, view.clusters[inner], view.count[inner]);
+      for (const auto row : next) {
+        const LayerID target = truth.rows[row].layer;
+        const auto prediction = predictLayerCrossing(propagator, parameters, geometry.planeOf(state), state, target, PropagationDirection::kForward);
+        if (prediction.status != PropagationStatus::kOk) {
+          out << std::format("S {} nopred\n", static_cast<int>(target));
+          break;
+        }
+        Scalar phiCentre = 0.F;
+        Scalar secondCentre = 0.F;
+        follow::windowCentre(parameters, target, prediction, phiCentre, secondCentre);
+        CandidateWindow window{
+          .earliestPS = static_cast<std::int64_t>(box.lower()) - static_cast<std::int64_t>(widest[target]) + 1,
+          .latestPS = static_cast<std::int64_t>(box.upper()) - 1,
+          .afterPS = box.lower(),
+          .phiCentre = phiCentre,
+          .phiHalfWidth = std::numbers::pi_v<Scalar>,
+          .secondCentre = secondCentre,
+          .secondHalfWidth = 1.e4F,
+        };
+        follow::predictedWindow<false>(propagator, parameters, geometry, material, state, factors, target, PropagationDirection::kForward, prediction, window, 1.F);
+        bool inWindow = false;
+        std::uint32_t wrongPassing = 0U;
+        Scalar wrongBest = std::numeric_limits<Scalar>::infinity();
+        frame.grid().visitCandidates(target, window, frame.grid().geometry().allBlocks(), [&](std::uint32_t candidate) {
+          const auto point = frame.measurement(candidate);
+          if (!spatiallyCompatible(window, point.phi, secondCoordinate<Det>(target, point.r, point.z))) {
+            return;
+          }
+          if (candidate == row) {
+            inWindow = true;
+            return;
+          }
+          BoundTrackState updated;
+          CovarianceFactors updatedFactors;
+          Scalar chi2 = 0.F;
+          if (follow::updateCandidate<false>(propagator, geometry, material, measurementAt(frame, candidate), PropagationDirection::kForward, state, factors, updated, updatedFactors, chi2, 1.F) && chi2 <= parameters.clusterChi2Max) {
+            ++wrongPassing;
+            wrongBest = std::min(wrongBest, chi2);
+          }
+        });
+        BoundTrackState updated;
+        CovarianceFactors updatedFactors;
+        Scalar chi2 = 0.F;
+        if (!follow::updateCandidate<false>(propagator, geometry, material, measurementAt(frame, row), PropagationDirection::kForward, state, factors, updated, updatedFactors, chi2, 1.F)) {
+          out << std::format("S {} noupdate {} {}\n", static_cast<int>(target), inWindow ? 1 : 0, wrongPassing);
+          break;
+        }
+        out << std::format("S {} {:.4g} {} {} {:.4g} {:.4g}\n", static_cast<int>(target), chi2, inWindow ? 1 : 0, wrongPassing, wrongBest, parameters.clusterChi2Max);
+        state = updated;
+        factors = updatedFactors;
+        box += timeBoxAt(measurements, row);
+      }
+    }
+  }
+}
+
+/// A block's width [ps], for printing.
+template <DetectorLayout Det>
+double blockWidthPS(const GridGeometry<Det>& geometry)
+{
+  return static_cast<double>(geometry.blockWidth()) / static_cast<double>(geometry.partsPerPS());
+}
+
+/// Each row's layer, from its sensor in \a detector.
+template <DetectorLayout Det>
+std::vector<LayerID> rowLayers(const study::TrackingInput& input, const Geometry<Det>& detector)
+{
+  std::vector<LayerID> layers(input.columns.surface.size());
+  for (std::size_t row = 0; row < layers.size(); ++row) {
+    layers[row] = detector.sensor(input.columns.surface[row]).layer;
+  }
+  return layers;
+}
+
+/// Whether \a input's rows are binned by \a grid: as many buckets, and every
+/// row in the bucket \a grid puts it in. A dump does not say which grid it
+/// was binned with; its rows do.
+template <DetectorLayout Det>
+bool binnedBy(const study::TrackingInput& input, std::span<const LayerID> layers, const GridGeometry<Det>& grid)
+{
+  const auto& columns = input.columns;
+  if (input.offsets.size() != std::size_t{grid.bucketCount()} + 1U || input.offsets.back() != layers.size()) {
+    return false;
+  }
+  for (std::uint32_t bucket = 0; bucket < grid.bucketCount(); ++bucket) {
+    for (auto row = input.offsets[bucket]; row < input.offsets[bucket + 1U]; ++row) {
+      if (grid.bucketAt(layers[row], columns.timePS[row], columns.phi[row], secondCoordinate<Det>(layers[row], columns.r[row], columns.z[row])) != bucket) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+/// \a input's rows, with their \a layers, as the producer would have binned
+/// them by \a to: in cluster order, each into its bucket of \a to by its
+/// layer, time, azimuth and second coordinate, by the producer's counting
+/// sort, which keeps cluster order within a bucket. \a truth's rows follow theirs. Returns the seconds the binning
+/// took.
+template <DetectorLayout Det>
+double rebin(study::TrackingInput& input, study::TrackingTruth* truth, std::span<const LayerID> layers, const GridGeometry<Det>& to)
+{
+  const auto start = std::chrono::steady_clock::now();
+  auto& columns = input.columns;
+  const std::size_t rows = columns.clusterIndex.size();
+  std::vector<std::uint32_t> order(rows);
+  std::iota(order.begin(), order.end(), 0U);
+  std::ranges::sort(order, [&](std::uint32_t a, std::uint32_t b) { return columns.clusterIndex[a] < columns.clusterIndex[b]; });
+
+  std::vector<std::uint32_t> offsets(std::size_t{to.bucketCount()} + 1U);
+  MeasurementGridBuilder builder{std::span<std::uint32_t>{offsets}};
+  std::vector<std::uint32_t> buckets(rows);
+  for (const auto row : order) {
+    const auto layer = layers[row];
+    buckets[row] = to.bucketAt(layer, columns.timePS[row], columns.phi[row], secondCoordinate<Det>(layer, columns.r[row], columns.z[row]));
+    builder.count(buckets[row]);
+  }
+  builder.prefixSum();
+  std::vector<std::uint32_t> source(rows); // the old row of each new one
+  for (const auto row : order) {
+    source[builder.place(buckets[row])] = row;
+  }
+  builder.finish();
+
+  const auto permute = [&](auto& column) {
+    auto old = column;
+    for (std::size_t row = 0; row < rows; ++row) {
+      column[row] = old[source[row]];
+    }
+  };
+  columns.apply([&](auto&... column) { (permute(column), ...); });
+  if (truth != nullptr) {
+    permute(truth->rows);
+  }
+  input.offsets = std::move(offsets);
+  return std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+}
+
+/// The device's vertex list against the host's on the same frame:
+/// both sorted by time and each frame's by
+/// z, so paired by place -- how many bit for bit, how many with the same box
+/// and contributors, and the largest z difference. A list of another length
+/// pairs as far as both go, and says so.
+inline std::string describeVertexAgreement(const VertexerResult& device, const VertexerResult& host)
+{
+  const std::size_t paired = std::min(device.vertices.size(), host.vertices.size());
+  std::size_t identical = 0U;
+  std::size_t sameClaim = 0U;
+  double maxDzUM = 0.;
+  const auto bits = [](Scalar value) { return std::bit_cast<std::uint32_t>(value); };
+  for (std::size_t v = 0; v < paired; ++v) {
+    const auto& d = device.vertices[v];
+    const auto& h = host.vertices[v];
+    const bool claim = d.timePS == h.timePS && d.widthPS == h.widthPS && device.contributors[v] == host.contributors[v];
+    sameClaim += claim ? 1U : 0U;
+    identical += claim && bits(d.z) == bits(h.z) && bits(d.varZ) == bits(h.varZ) && bits(d.varTransverse) == bits(h.varTransverse) ? 1U : 0U;
+    maxDzUM = std::max(maxDzUM, std::abs(static_cast<double>(d.z) - static_cast<double>(h.z)) * 1.e4);
+  }
+  return std::format(
+    "vertexer, device against host: {} vertices against {}{}; of {} paired, {} bit for bit, {} with the same box and contributors, |dz| "
+    "at most {:.2f} um; candidates {} against {}",
+    device.vertices.size(), host.vertices.size(), device.vertices.size() == host.vertices.size() ? "" : " (NOT the same count)", paired, identical, sameClaim, maxDzUM, device.candidates, host.candidates);
+}
+
+/// --seeding-steps \a text's pT steps [GeV]: one or more, comma separated,
+/// each a whole number token and a positive momentum.
+[[nodiscard]] inline std::vector<double> seedingSteps(const std::string& text)
+{
+  std::vector<double> steps;
+  for (const auto part : text | std::views::split(',')) {
+    const std::string token{part.begin(), part.end()};
+    std::size_t parsed = 0U;
+    double step = 0.;
+    try {
+      step = std::stod(token, &parsed);
+    } catch (const std::logic_error&) {
+      parsed = 0U;
+    }
+    if (parsed == 0U || parsed != token.size() || !std::isfinite(step) || step <= 0.) {
+      throw std::runtime_error("--seeding-steps " + text + ": one or more steps, each a positive momentum [GeV]");
+    }
+    steps.push_back(step);
+  }
+  if (steps.empty()) {
+    throw std::runtime_error("--seeding-steps " + text + ": one or more steps, each a positive momentum [GeV]");
+  }
+  return steps;
+}
+
+/// The truth-removal study: every
+/// configured iteration's graph alone, in order, each on the rows the earlier
+/// passes' seeded particles left; the report on stdout, a JSON line per pass
+/// to --seeding-strategy. Each pass starts from a released pool -- the
+/// timeframe ended and begun again, the held rows held again -- so that its
+/// peak is its own. With --resume-state the checkpoint's iterations are the
+/// real run's: its good tracks seed before
+/// the first pass, every pass starts from its used mask, and the passes are
+/// the configured iterations after it. 0 when every pass completed, 2 when
+/// one failed (a pass over the pool's limit), which ends the study.
+template <DetectorLayout Det>
+int seedingStrategy(const Options& options, Controller<Det>& tracker, const TimeFrame<Det>& frame, const study::TrackingTruth& truth, const study::ComparisonSettings& comparison, std::span<const IterationSettings> settings, const workflow::BeamLine& beamLine, std::span<const VertexSeed> vertices, std::int32_t blocksPerSlice, BoundedMemoryResource& pool, const TrackingGeometry<Det>& tracking, const o2::base::MatLayerCylSet& material, const Propagator& propagator)
+{
+  using Clock = std::chrono::steady_clock;
+  const auto& param = recoParam<Det>();
+  if (options.backend != "cpu" || param.vertexer) {
+    throw std::runtime_error("--seeding-strategy runs the host tracker on the dump's vertices: not with a GPU backend or GTRKReco<DET>.vertexer");
+  }
+  auto steps = seedingSteps(options.seedingSteps);
+  std::vector<std::uint8_t> shadow(settings.size(), std::uint8_t{0});
+  for (const auto part : options.seedingShadow | std::views::split(',')) {
+    if (part.empty()) {
+      continue;
+    }
+    const auto pass = std::stoul(std::string{part.begin(), part.end()});
+    if (pass + 1U >= settings.size()) {
+      throw std::runtime_error("--seeding-shadow " + options.seedingShadow + ": a shadow pass needs a pass after it");
+    }
+    shadow[pass] = 1U;
+  }
+  const auto population = study::populationOf(options.seedingPopulation);
+  if (!population) {
+    throw std::runtime_error("--seeding-population " + options.seedingPopulation + ": primary, decay or v0");
+  }
+  std::optional<typename Controller<Det>::Checkpoint> resumeFrom;
+  if (!options.resumeState.empty()) {
+    resumeFrom = readCheckpoint<typename Controller<Det>::Checkpoint>(options.resumeState, settings, checkpointFrame(frame), checkpointConditions(beamLine, vertices, blocksPerSlice, param.sliceHaloPS));
+  }
+  const std::size_t first = resumeFrom ? resumeFrom->summaries.size() : 0U;
+  std::ofstream json(options.seedingStrategy);
+  if (!json) {
+    throw std::runtime_error("cannot write " + options.seedingStrategy);
+  }
+  tracker.setProfiling(false);
+  const auto plan = tracker.planTimeframe(frame, vertices, blocksPerSlice, param.sliceHaloPS);
+  if (tracker.beginTimeframe(frame) != StageStatus::kComplete) {
+    throw std::runtime_error("--seeding-strategy: the timeframe's used mask does not fit the pool");
+  }
+  study::SeedingStrategy<Det> study(truth, comparison, std::move(steps), !options.seedingNoRemoval, options.seedingFit, *population);
+  std::cout << std::format("seeding strategy: {} passes, {}, scoring the findable {}\n", settings.size() - first, options.seedingNoRemoval ? "each on the whole frame" : "each on the rows the earlier passes' seeded particles left", study::kPopulationNames[static_cast<std::size_t>(*population)]);
+  if (resumeFrom) {
+    tracker.restoreUsed(resumeFrom->used);
+    study.startAfter(first, resumeFrom->tracks, resumeFrom->used, std::cout);
+  }
+  int status = 0;
+  std::vector<std::uint32_t> held;
+  for (std::size_t pass = first; pass < settings.size(); ++pass) {
+    if (pass != first) {
+      tracker.endTimeframe();
+      if (tracker.beginTimeframe(frame) != StageStatus::kComplete) {
+        throw std::runtime_error("--seeding-strategy: the timeframe's used mask does not fit the pool");
+      }
+      if (resumeFrom) {
+        tracker.restoreUsed(resumeFrom->used);
+      }
+      tracker.holdRows(held);
+    }
+    study.beginPass(shadow[pass] != 0U);
+    pool.resetPeakMemory();
+    const auto workBefore = workCounts();
+    double seconds = 0.;
+    double fitSeconds = 0.;
+    auto start = Clock::now();
+    const auto ran = tracker.runGraph(pass, frame, plan, options.seedingFit, [&](const auto& result, const auto& roads, const auto* records, double fitted) {
+      seconds += std::chrono::duration<double>(Clock::now() - start).count();
+      fitSeconds += fitted;
+      study.observe(result, roads, records);
+      start = Clock::now();
+    });
+    if (ran != StageStatus::kComplete) {
+      std::cout << std::format("pass {}: the graph failed with status {} (infeasible); the study ends here\n", pass, static_cast<int>(ran));
+      status = 2;
+      break;
+    }
+    const auto workAfter = workCounts();
+    const auto counted = [&](WorkCounter counter) {
+      const auto at = static_cast<std::size_t>(counter);
+      return workAfter[at] - workBefore[at];
+    };
+    // The road fit stage's tests on one road (`roadFitRefusal`).
+    const auto& parameters = tracker.iteration(pass);
+    const typename study::SeedingStrategy<Det>::Refit refit = [&](std::span<const std::uint32_t> road) { return roadFitRefusal(parameters, propagator, tracking, material, frame, road); };
+    const auto rows = study.endPass(settings[pass],
+                                    {
+                                      .seconds = seconds,
+                                      .poolPeakBytes = pool.getPeakMemory(),
+                                      .counted = kWorkCounters,
+                                      .tripletFits = counted(WorkCounter::kTripletFits),
+                                      .neighbourFits = counted(WorkCounter::kNeighbourFits),
+                                      .fitSeconds = fitSeconds,
+                                    },
+                                    std::cout, &json, options.seedingFit ? refit : typename study::SeedingStrategy<Det>::Refit{});
+    if (!json) {
+      throw std::runtime_error("cannot write " + options.seedingStrategy);
+    }
+    tracker.holdRows(rows);
+    held.insert(held.end(), rows.begin(), rows.end());
+  }
+  tracker.endTimeframe();
+  json.close();
+  if (!json) {
+    throw std::runtime_error("cannot write " + options.seedingStrategy);
+  }
+  if (!options.seedingParticles.empty()) {
+    std::ofstream particles(options.seedingParticles);
+    study.writeParticles(particles);
+    particles.close();
+    if (!particles) {
+      throw std::runtime_error("cannot write " + options.seedingParticles);
+    }
+  }
+  return status;
+}
+
+/// The truth studies that watch every iteration: the follow's rows per track for --fakes-out and the follow's
+/// replay for --follow-steps and --follow-stops.
+template <DetectorLayout Det>
+struct IterationStudies {
+  std::vector<std::array<std::uint8_t, 2>> followed;
+  std::optional<FollowAnatomy<Det, o2::base::MatLayerCylSet>> follow;
+  bool fakes = false;
+
+  IterationStudies(const Options& options, const study::TrackingTruth* truth) : fakes(!options.fakesOut.empty())
+  {
+    if ((fakes || !options.followSteps.empty() || options.followStops) && truth == nullptr) {
+      throw std::runtime_error("--fakes-out, --follow-steps and --follow-stops need the MC truth");
+    }
+    if (!options.followSteps.empty() || options.followStops) {
+      follow.emplace(options.followSteps, *truth);
+    }
+  }
+  [[nodiscard]] bool active() const { return fakes || follow.has_value(); }
+
+  template <typename Observation>
+  void observe(const Observation& iteration, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const o2::base::MatLayerCylSet& material, const Propagator& propagator)
+  {
+    if (follow) {
+      follow->observe(iteration, parameters, frame, geometry, material, propagator);
+    }
+    if (fakes) {
+      recordFollowed(iteration, followed);
+    }
+  }
+};
+
+/// The last run's truth studies the options ask for: the fakes,
+/// the clones, the rows and the clone joins.
+template <DetectorLayout Det, typename Material, typename ParametersOf, typename StagesOf, typename RecordChi2>
+void writeTruthStudies(const Options& options, const typename TrackRefit<Det>::Tracks& tracks, const study::TrackingTruth& truth, const study::ComparisonSettings& comparison, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& tracking, const Material& material, const Propagator& propagator, const std::vector<std::array<std::uint8_t, 2>>& followed, ParametersOf parametersOf, StagesOf stagesOf, RecordChi2 recordChi2)
+{
+  if (!options.fakesOut.empty()) {
+    writeFakes<Det>(options.fakesOut, tracks, truth, comparison, frame, followed, stagesOf, recordChi2);
+  }
+  if (!options.clonesOut.empty()) {
+    writeClones<Det>(options.clonesOut, tracks, truth, comparison);
+  }
+  if (!options.rowsOut.empty()) {
+    writeRowsOut<Det>(options.rowsOut, tracks, truth, frame);
+  }
+  if (!options.cloneJoins.empty()) {
+    writeCloneJoins<Det>(options.cloneJoins, tracks, truth, comparison, frame, tracking, material, propagator, parametersOf);
+  }
+}
+
+/// Track the dumped input \a options.repeat times with the parameters already
+/// loaded; 0 if every run gave the same digest.
+template <DetectorLayout Det>
+int track(const Options& options) // NOLINT(readability-function-size): the bench's driver, one mode per option
+{
+  using Frame = TimeFrame<Det>;
+  using Controller = study::Controller<Det>;
+  const auto& param = recoParam<Det>();
+
+  const auto start = std::chrono::steady_clock::now();
+  auto input = study::readTrackingInput(options.input);
+  const auto readSeconds = std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+  std::cout << std::format("{} measurements, {} buckets, {} vertices read from {} in {:.3f} s\n", input.columns.clusterIndex.size(), input.offsets.size() - 1U, input.vertices.size(), options.input, readSeconds) << std::format("the beam line the rows are about: {}\n", workflow::describe(input.beamLine));
+  if (options.beamWidthCM > 0.) {
+    input.beamLine.sigmaX = input.beamLine.sigmaY = options.beamWidthCM;
+    std::cout << std::format("the beam's transverse width taken as {} cm (--beam-width)\n", options.beamWidthCM);
+  }
+  // The MC truth to score the tracks by.
+  const auto truthPath = options.truth.empty() ? options.input + ".truth" : options.truth;
+  std::optional<study::TrackingTruth> truth;
+  if (!options.truth.empty() || std::filesystem::exists(truthPath)) {
+    truth = study::readTrackingTruth(truthPath, input);
+    std::cout << std::format("{} truth rows, {} particles read from {}\n", truth->rows.size(), truth->particles.size(), truthPath);
+  }
+  // The geometry first: a placed layout's extents, which the grid and the
+  // windows below are sized from, are the loaded geometry's (Base/LayerEnvelopes.h);
+  // its measurement depths the dump's, where its rows were placed.
+  // The conditions, as a standalone O2 program reads them: from the CCDB at
+  // --ccdb-url (trackBench.cxx), at the paths the sink takes them from.
+  auto& ccdb = o2::ccdb::BasicCCDBManager::instance();
+  if (ccdb.get<TGeoManager>("GLO/Config/GeometryAligned") == nullptr) {
+    throw std::runtime_error("no GLO/Config/GeometryAligned at " + options.ccdbUrl);
+  }
+  // The run's orbits per timeframe, as the measurement producer takes them
+  // (Conditions::orbitsPerTimeframe): its GRPECS's; ALICE 3's simulation
+  // writes none, and the dump's HBFUtils is its.
+  int orbitsPerTimeframe = 0;
+  if constexpr (std::same_as<Det, detectors::TRKFT3>) {
+    orbitsPerTimeframe = o2::raw::HBFUtils::Instance().getNOrbitsPerTF();
+  } else {
+    const auto* ecs = ccdb.get<o2::parameters::GRPECSObject>("GLO/Config/GRPECS");
+    if (ecs == nullptr) {
+      throw std::runtime_error("no GLO/Config/GRPECS at " + options.ccdbUrl);
+    }
+    orbitsPerTimeframe = static_cast<int>(ecs->getNHBFPerTF());
+  }
+  // The grid this build derives from the dump's parameters and the trial's
+  // keys below; the rows are rebinned into it unless they already are.
+  // Each row's layer is its sensor's, so
+  // a dump binned by a build with another link table reads all the same.
+  const auto frames = study::layerFrames<Det>(input);
+  // A tuning trial's configuration.
+  if (!options.keyValues.empty()) {
+    o2::conf::ConfigurableParam::updateFromString(options.keyValues);
+  }
+  if (options.threads >= 0) {
+    o2::conf::ConfigurableParam::setValue(std::string{RecoParamOf<Det>::type::Instance().getName()} + ".threads", std::to_string(options.threads));
+  }
+  workflow::checkRecoParam<Det>(param);
+  workflow::TrackingInterface<Det> interface{!param.vertexer};
+  interface.initGeometry(input.depths);
+  const auto geometry = workflow::makeGridGeometry<Det>(param, input.beamLine, frames, orbitsPerTimeframe);
+  const auto* material = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb.get<o2::base::MatLayerCylSet>(workflow::materialLutPath<Det>()));
+  const bool device = options.backend != "cpu";
+  if (device) {
+    interface.initDevice({.backend = options.backend, .device = options.gpuDevice, .arenaMB = options.gpuArenaMB});
+  }
+  interface.configure({workflow::nominalBzKiloGauss(), input.depths, material}, {input.beamLine, geometry});
+  auto& tracker = interface.tracker();
+  const auto& pool = interface.pool();
+  auto* vertexing = interface.vertexing();
+  const auto& tracking = interface.tracking();
+  const auto& scattering = interface.scattering();
+  const auto propagator = interface.propagator();
+  double rebinSeconds = 0.;
+  const auto layers = rowLayers<Det>(input, interface.geometry());
+  const bool rebinned = options.rebin || !binnedBy<Det>(input, layers, geometry);
+  if (rebinned) {
+    rebinSeconds = rebin<Det>(input, truth ? &*truth : nullptr, layers, geometry);
+  }
+  std::cout << std::format("grid{}: {} blocks of {:.0f} ps; phi x second cells by layer:", rebinned ? std::format(", rebinned in {:.3f} s", rebinSeconds) : "", geometry.blockCount(), blockWidthPS(geometry));
+  for (std::size_t layer = 0; layer < GridGeometry<Det>::kLayerCount; ++layer) {
+    const auto& axes = geometry.axes(static_cast<LayerID>(layer));
+    std::cout << std::format(" {}x{}", axes.nPhi, axes.nSecond);
+  }
+  std::cout << std::format("; {} buckets, offsets {:.1f} MB\n", geometry.bucketCount(), static_cast<double>(input.offsets.size() * sizeof(std::uint32_t)) / 1.e6);
+  const Frame frame{measurementView(input.columns), geometry, std::span<const typename Frame::Index>{input.offsets}};
+  if (const auto* why = interface.checkInput(input.columns, input.offsets, geometry.bucketCount(), input.vertices)) {
+    throw std::runtime_error(why);
+  }
+  std::string phiCells;
+  std::string secondCells;
+  for (std::size_t layer = 0; layer < GridGeometry<Det>::kLayerCount; ++layer) {
+    const auto& axes = geometry.axes(static_cast<LayerID>(layer));
+    phiCells += std::format("{}{}", layer == 0U ? "" : ",", axes.nPhi);
+    secondCells += std::format("{}{}", layer == 0U ? "" : ",", axes.nSecond);
+  }
+  const auto gridJson = std::format(R"("grid":{{"blocks":{},"blockWidthPS":{:.3f},"phi":[{}],"second":[{}],"buckets":{},"offsetBytes":{},"rebinSeconds":{:.6f}}},)", geometry.blockCount(), blockWidthPS(geometry), phiCells, secondCells, geometry.bucketCount(), input.offsets.size() * sizeof(std::uint32_t), rebinSeconds);
+  auto comparison = study::comparisonSettings<Det>(4, options.findableMinPtGeV);
+  comparison.allLayersMask = options.findableAllLayers;
+  if (!options.seedCoverage.empty()) {
+    if (!truth) {
+      throw std::runtime_error("--seed-coverage needs the MC truth");
+    }
+    std::vector<std::uint64_t> masks;
+    for (const auto part : options.seedCoverage | std::views::split(',')) {
+      masks.push_back(std::stoull(std::string{part.begin(), part.end()}));
+    }
+    printSeedCoverage(*truth, comparison, masks);
+  }
+
+  std::vector<IterationSettings> settings;
+  for (int iteration = 0; iteration < workflow::iterationCount(param); ++iteration) {
+    settings.push_back(workflow::iterationSettings(param, iteration));
+    if (settings.back().vertexSource == VertexSource::kVertexList && input.vertices.empty() && !param.vertexer) {
+      throw std::runtime_error(std::format("iteration {} seeds from the vertex list, and {} holds none", iteration, options.input));
+    }
+  }
+  const auto chunkSize = static_cast<typename Controller::Index>(std::max(param.trackletChunkSize, 1));
+  tracker.setProfiling(!options.noProfile);
+  if (options.dram && !profile::countDram()) {
+    throw std::runtime_error("--dram: the memory controllers' counters (amd_umc) cannot be opened");
+  }
+  if (device) {
+    if (options.funnel || options.digestStages || !options.fitInputs.empty() || !options.trace.empty()) {
+      throw std::runtime_error("--funnel, --digest-stages, --fit-inputs and --trace observe the host tracker: not with a GPU backend");
+    }
+  } else if (options.hostReference) {
+    throw std::runtime_error("--host-reference compares a GPU backend's tracks with the host's: it needs --backend cuda or hip");
+  }
+  // --fit-inputs: the last run's, with each iteration's parameters the
+  // tracker's own.
+  study::FitInputs fitInputs;
+  bool captureFits = false;
+  // --funnel: the last run's stage funnel of the findable.
+  if (options.funnel && !truth) {
+    throw std::runtime_error("--funnel needs the MC truth");
+  }
+  std::optional<study::StageFunnel<Det, Controller>> funnel;
+  // --vertex-study: the vertexer on one iteration's triplets against the
+  // truth, and its replay (VertexStudy.h).
+  if (options.vertexStudy >= 0 && (!truth || device || std::cmp_greater_equal(options.vertexStudy, settings.size()))) {
+    throw std::runtime_error("--vertex-study needs the MC truth, the host tracker and one of the configured iterations");
+  }
+  std::optional<study::VertexStudy<Det, Controller>> vertexStudy;
+  if (options.verticesOnly && (!truth || device || !param.vertexer)) {
+    throw std::runtime_error("--vertices-only needs the MC truth, the host and GTRKReco<DET>.vertexer");
+  }
+  if (options.digestStages || !options.fitInputs.empty() || options.funnel || options.vertexStudy >= 0) {
+    tracker.setSliceObserver([&](const Controller& observed, const typename Controller::SliceObservation& slice) {
+      if (options.digestStages) {
+        printStageDigests<Det>(slice);
+      }
+      if (captureFits) {
+        collectFitInputs<Det>(slice, observed.iteration(slice.iteration), fitInputs);
+      }
+      if (funnel) {
+        funnel->observeSlice(observed, slice);
+      }
+      if (vertexStudy) {
+        vertexStudy->observeSlice(observed, slice);
+      }
+    });
+  }
+  // Each iteration's work counts: the counts at its end less those at the
+  // previous one's.
+  std::vector<WorkCounts> work;
+  WorkCounts workBefore{};
+  std::vector<LinkWorkCounts> linkWork;
+  LinkWorkCounts linkWorkBefore;
+  if ((options.completeAnatomy && !truth) || (options.completeAnatomy && options.findableAllLayers == 0U)) {
+    throw std::runtime_error("--complete-anatomy needs the MC truth and --findable-all-layers");
+  }
+  if (!options.endEdits.empty() && options.endDecisions.empty()) {
+    throw std::runtime_error("--end-edits needs --end-decisions");
+  }
+  std::optional<study::CompleteAnatomy<Det>> completeAnatomy;
+  if (options.completeAnatomy) {
+    std::vector<std::uint64_t> roadLayers;
+    roadLayers.reserve(settings.size());
+    for (const auto& iteration : settings) {
+      roadLayers.push_back(iteration.layerMask);
+    }
+    completeAnatomy.emplace(*truth, options.findableAllLayers, options.findableMinPtGeV, std::move(roadLayers),
+                            typename study::CompleteAnatomy<Det>::ClassCuts{
+                              .pdg = options.anatomyPdg,
+                              .findable = options.anatomyFindable ? &comparison : nullptr,
+                            });
+    std::vector<double> floors;
+    floors.reserve(settings.size());
+    for (const auto& iteration : settings) {
+      floors.push_back(iteration.windows.minPtGeV);
+    }
+    completeAnatomy->setIterationFloors(std::move(floors));
+    completeAnatomy->setBeamLine(vertexSeed(workflow::beamSpotConstraint(input.beamLine, param)));
+    if (!options.anatomyBeamLine.empty()) {
+      completeAnatomy->keepBeamLine();
+    }
+    if (!options.anatomyFollowLoss.empty()) {
+      completeAnatomy->keepFollowLoss();
+    }
+    if (!options.stepAnatomy.empty() || !options.hits.empty()) {
+      completeAnatomy->open(options.stepAnatomy, options.hits, options.hits.empty() ? std::string{} : options.ft3Hits);
+    }
+    if (!options.truthWalk.empty()) {
+      if (options.hits.empty()) {
+        throw std::runtime_error("--truth-walk needs --hits");
+      }
+      completeAnatomy->openTruthWalk(options.truthWalk);
+    }
+    if (options.truthWalkIteration >= 0) {
+      completeAnatomy->setWalkIteration(static_cast<std::size_t>(options.truthWalkIteration));
+    }
+    if (!options.inwardHistory.empty()) {
+      if (options.hits.empty()) {
+        throw std::runtime_error("--inward-history needs --hits");
+      }
+      completeAnatomy->openInwardHistory(options.inwardHistory);
+    }
+    if (!options.endDecisions.empty()) {
+      completeAnatomy->openEndDecisions(options.endDecisions);
+    }
+    if (!options.endEdits.empty()) {
+      completeAnatomy->openEndEdits(options.endEdits);
+    }
+    if (!options.kine.empty()) {
+      if (options.hits.empty()) {
+        throw std::runtime_error("--kine needs --hits");
+      }
+      completeAnatomy->openKine(options.kine);
+    }
+  }
+  IterationStudies<Det> studies(options, truth ? &*truth : nullptr);
+  // The real run's iterations as the truth-removal
+  // study's passes, scored by their good tracks and the used mask.
+  // One study per run: a repetition scores its own iterations from the start,
+  // its JSON written anew, not on from the previous run's study; the last
+  // run's is the one left.
+  std::optional<study::SeedingStrategy<Det>> seedingReal;
+  std::ofstream seedingRealJson;
+  std::size_t seedingRealNext = 0U; ///< the iteration after the last one scored
+  const auto beginSeedingReal = [&]() {
+    seedingReal.emplace(*truth, comparison, seedingSteps(options.seedingSteps), false, false);
+    seedingRealJson.close();
+    seedingRealJson.open(options.seedingReal);
+    if (!seedingRealJson) {
+      throw std::runtime_error("cannot write " + options.seedingReal);
+    }
+  };
+  if (!options.seedingReal.empty()) {
+    if (!truth) {
+      throw std::runtime_error("--seeding-real needs the MC truth");
+    }
+    beginSeedingReal();
+  }
+  if (kWorkCounters || options.funnel || completeAnatomy || studies.active() || seedingReal) {
+    tracker.setIterationObserver([&](const Controller& observed, const typename Controller::IterationObservation& iteration) {
+      if (seedingReal) {
+        // A run's iterations come in order: an earlier one begins the next run.
+        if (iteration.iteration < seedingRealNext) {
+          beginSeedingReal();
+        }
+        seedingRealNext = iteration.iteration + 1U;
+        const auto& summary = *iteration.summary;
+        seedingReal->observeReal(iteration.tracks->view(), iteration.trackOffset, iteration.tracks->size(), iteration.used, summary.roads);
+        double seconds = 0.;
+        for (const auto phase : {profile::Phase::kSlices, profile::Phase::kRoads, profile::Phase::kSelection, profile::Phase::kRefit, profile::Phase::kFollow}) {
+          seconds += summary.seconds(phase);
+        }
+        static_cast<void>(seedingReal->endPass(settings[iteration.iteration], {.seconds = seconds}, std::cout, &seedingRealJson));
+      }
+      studies.observe(iteration, observed.iteration(iteration.iteration), frame, tracking, *material, propagator);
+      if (completeAnatomy) {
+        completeAnatomy->observe(iteration, observed.iteration(iteration.iteration), frame, tracking, *material, propagator);
+      }
+      if constexpr (kWorkCounters) {
+        const auto now = workCounts();
+        WorkCounts& counts = work.emplace_back();
+        for (std::size_t counter = 0; counter < kWorkCounterCount; ++counter) {
+          counts[counter] = now[counter] - workBefore[counter];
+        }
+        workBefore = now;
+        auto links = linkWorkCounts();
+        LinkWorkCounts& linkCounts = linkWork.emplace_back(links);
+        for (std::size_t link = 0; link < std::min(links.size(), linkWorkBefore.size()); ++link) {
+          for (std::size_t counter = 0; counter < kLinkCounterCount; ++counter) {
+            linkCounts[link][counter] -= linkWorkBefore[link][counter];
+          }
+        }
+        linkWorkBefore = std::move(links);
+      }
+      if (funnel) {
+        funnel->observeIteration(observed, iteration);
+      }
+    });
+  }
+  const int threads = detail::TaskArena{std::max(param.threads, 0)}.maxConcurrency();
+  const auto label = workflow::sourceLabel(settings);
+  std::cout << std::format("{}, {} iterations, {} arena threads, chunks of {}{}\n", label, workflow::iterationCount(param), threads, chunkSize, kWorkCounters ? "; work counters on: the times are not the default build's" : "");
+
+  std::ofstream json;
+  if (!options.json.empty()) {
+    json.open(options.json, std::ios::app);
+    if (!json) {
+      throw std::runtime_error("cannot append to " + options.json);
+    }
+  }
+  profile::Trace trace{static_cast<std::size_t>(threads)};
+  // Against the truth, under the sink's rules and in its lines;
+  // outside the time.
+  // The score of \a rows over \a particles (every particle of the truth by
+  // default), printed under \a label.
+  const auto scoreAndPrint = [&](const study::TrackRows& rows, const study::ParticleTable* particles = nullptr, std::string_view label = "GTRK") -> std::optional<std::pair<study::TrackScore, double>> {
+    if (!truth) {
+      return std::nullopt;
+    }
+    const auto scoreStart = std::chrono::steady_clock::now();
+    auto score = study::scoreTracks(truth->rows, particles ? *particles : truth->particles, rows, comparison);
+    const double scoreSeconds = std::chrono::duration<double>(std::chrono::steady_clock::now() - scoreStart).count();
+    std::cout << std::format("score against the truth, in {:.3f} s:\n", scoreSeconds);
+    for (const auto& line : study::describeScore(score, comparison, std::string{label})) {
+      std::cout << line << '\n';
+    }
+    return std::pair{std::move(score), scoreSeconds};
+  };
+  // --score-sources: the particles of those MC sources alone (a mixed
+  // timeframe's added collisions), against every track.
+  std::optional<study::ParticleTable> sourceParticles;
+  if (truth && !options.scoreSources.empty()) {
+    sourceParticles.emplace();
+    for (const auto& [id, particle] : truth->particles) {
+      const int source = workflow::labelOfParticle(id).getSourceID();
+      if (std::ranges::find(options.scoreSources, source) != options.scoreSources.end()) {
+        sourceParticles->emplace(id, particle);
+      }
+    }
+    std::cout << std::format("--score-sources: {} of {} particles\n", sourceParticles->size(), truth->particles.size());
+  }
+  const auto scoreSources = [&](const study::TrackRows& rows) -> std::optional<std::pair<study::TrackScore, double>> { return sourceParticles ? scoreAndPrint(rows, &*sourceParticles, "GTRK, the --score-sources particles") : std::nullopt; };
+
+  std::vector<double> walls;
+  std::vector<std::uint64_t> digests;
+  std::vector<VertexSeed> foundVertices;
+  const auto blocksPerSlice = geometry.blocksPerSlice(param.sliceWidthPS);
+  if (!options.seedingStrategy.empty()) {
+    if (!truth) {
+      throw std::runtime_error("--seeding-strategy needs the MC truth");
+    }
+    return seedingStrategy<Det>(options, tracker, frame, *truth, comparison, settings, input.beamLine, input.vertices, blocksPerSlice, *pool, tracking, *material, propagator);
+  }
+  const bool deviceVertexing = vertexing && device;
+  bool referenceSame = true;
+  // A checkpoint: saved after the first iterations, or
+  // the run going on from one -- on the host, and from one without the
+  // observers, which would miss its iterations. Its conditions hold the run's
+  // vertices, the dump's or the own vertexer's (the same on the host every
+  // run), so a resumed run reads it after its vertexing.
+  if (!options.saveState.empty() && (options.stateIterations == 0U || options.stateIterations > settings.size() || !options.resumeState.empty())) {
+    throw std::runtime_error("--save-state needs --state-iterations between 1 and the configuration's iterations, and no --resume-state");
+  }
+  const auto checkpointConditionsOf = [&](std::span<const VertexSeed> vertices) { return checkpointConditions(input.beamLine, vertices, blocksPerSlice, param.sliceHaloPS); };
+  std::optional<typename Controller::Checkpoint> resumeFrom;
+  if (!options.resumeState.empty() && (device || kWorkCounters || options.funnel || completeAnatomy || studies.active() || seedingReal || options.digestStages || !options.fitInputs.empty() || options.vertexStudy >= 0 || options.verticesOnly)) {
+    throw std::runtime_error("--resume-state runs the host tracker without observers");
+  }
+  // Clusters taken before the run, by their cluster
+  // number -- rows move with the grid -- as a checkpoint of no iterations
+  // whose used mask holds their rows, so the observers miss nothing.
+  if (!options.holdClusters.empty()) {
+    if (device || param.vertexer || !options.resumeState.empty()) {
+      throw std::runtime_error("--hold-clusters runs the host tracker, without GTRKReco<DET>.vertexer or --resume-state");
+    }
+    std::ifstream in(options.holdClusters);
+    if (!in) {
+      throw std::runtime_error("cannot read " + options.holdClusters);
+    }
+    const auto columns = frame.measurements();
+    std::unordered_map<std::uint64_t, std::uint32_t> rowOf;
+    rowOf.reserve(frame.size());
+    for (std::uint32_t row = 0; row < frame.size(); ++row) {
+      if (!rowOf.emplace(columns.clusterIndex[row], row).second) {
+        throw std::runtime_error(std::format("--hold-clusters: cluster {} on two rows", static_cast<std::uint64_t>(columns.clusterIndex[row])));
+      }
+    }
+    resumeFrom.emplace();
+    resumeFrom->used.assign(frame.size(), std::uint8_t{kFree});
+    std::size_t held = 0U;
+    for (std::uint64_t cluster = 0; in >> cluster;) {
+      const auto found = rowOf.find(cluster);
+      if (found == rowOf.end()) {
+        throw std::runtime_error(std::format("--hold-clusters: no cluster {} in the frame", cluster));
+      }
+      held += resumeFrom->used[found->second] == kFree ? 1U : 0U;
+      resumeFrom->used[found->second] = kExclusive;
+    }
+    std::cout << std::format("holding {} clusters of {} from {}\n", held, frame.size(), options.holdClusters);
+  }
+  if (!options.saveState.empty() && (device || options.verticesOnly)) {
+    throw std::runtime_error("--save-state runs the host tracker, not --vertices-only");
+  }
+  for (unsigned repetition = 0; repetition < std::max(options.repeat, 1U); ++repetition) {
+    const bool last = repetition + 1U == std::max(options.repeat, 1U);
+    const auto timeframe = interface.endTimeframeOnExit();
+    trace.clear();
+    tracker.setTrace(!options.trace.empty() && last ? &trace : nullptr);
+    captureFits = !options.fitInputs.empty() && last;
+    funnel.reset();
+    vertexStudy.reset();
+    if (options.vertexStudy >= 0 && last) {
+      const auto iteration = static_cast<std::size_t>(options.vertexStudy);
+      vertexStudy.emplace(frame, truth->rows, truth->particles, iteration, settings[iteration].windows.minPtGeV, comparison, workflow::vertexerSettings(param),
+                          typename study::VertexStudy<Det, Controller>::Settings{
+                            .windowUM = param.vertexerWindowUM,
+                            .claimUM = param.vertexerClaimUM,
+                            .minContributors = static_cast<std::uint32_t>(param.vertexerMinContributors),
+                            .significance = param.vertexerSignificance,
+                            .maxChi2RZ = param.vertexerMaxChi2RZ,
+                            .maxDcaUM = param.vertexerMaxDcaCM * 1.e4,
+                          },
+                          threads);
+      vertexStudy->setBeamLine(input.beamLine.x, input.beamLine.y);
+      if (!options.vertexPrior.empty()) {
+        vertexStudy->setPriorVertices(options.vertexPrior);
+      }
+    }
+    if (options.funnel && last) {
+      std::vector<double> minPtGeV;
+      minPtGeV.reserve(settings.size());
+      for (const auto& iteration : settings) {
+        minPtGeV.push_back(iteration.windows.minPtGeV);
+      }
+      funnel.emplace(frame, truth->rows, truth->particles, comparison, vertexSeed(workflow::beamSpotConstraint(input.beamLine, param)), std::move(minPtGeV));
+      funnel->setRoadFit(tracking, *material, propagator);
+      funnel->keepReportInputs(!options.fakesOut.empty());
+    }
+    // --vertices-only keeps the first run's claims, which its score takes.
+    // The pool's peak over the vertexing, which shares the tracker's pool
+    // (TrackingInterface): with the run's peak, what the timeframe takes.
+    pool->resetPeakMemory();
+    const auto vertexed = interface.vertices(frame, input.vertices, options.verticesOnly && repetition == 0U);
+    const std::size_t vertexerPoolPeak = pool->getPeakMemory();
+    if (vertexed.dropped) {
+      throw std::runtime_error("the vertexing pass ran out of memory");
+    }
+    const auto vertices = vertexed.seeds;
+    if (!options.resumeState.empty() && !resumeFrom) {
+      resumeFrom = readCheckpoint<typename Controller::Checkpoint>(options.resumeState, settings, checkpointFrame(frame), checkpointConditionsOf(vertices));
+      std::cout << std::format("resuming from {}: {} iterations, {} tracks\n", options.resumeState, resumeFrom->summaries.size(), resumeFrom->tracks.size());
+    }
+    const double vertexSeconds = !device ? vertexed.seconds : 0.;
+    if (vertexing && !device) {
+      const auto& found = *vertexed.found;
+      std::cout << std::format("vertexer: {} vertices from {} candidates of {} triplets in {:.4f} s, pool peak {:.1f} MB\n", found.vertices.size(), found.candidates, found.triplets, vertexSeconds, static_cast<double>(vertexerPoolPeak) / 1.e6);
+      std::cout << std::format("digest, vertices: {:016x}\n", vertexDigest(found.vertices, found.contributors));
+    }
+    if (options.verticesOnly) {
+      // The pass alone: every run timed, the first scored against the MC
+      // collisions (VertexQA.h), as the sink's vertex QA line.
+      const auto& found = *vertexed.found;
+      const auto vertexListDigest = vertexDigest(found.vertices, found.contributors);
+      walls.push_back(vertexSeconds);
+      digests.push_back(vertexListDigest);
+      std::optional<VertexScore> score;
+      if (repetition == 0U) {
+        score = scoreVertices<Det>(truth->rows, truth->particles, vertexed.pass->claims, found);
+        std::cout << describe(*score) << '\n'
+                  << describeMissed(*score) << '\n';
+        for (const auto& miss : score->missed) {
+          if (miss.findable > 0U) {
+            std::cout << std::format("  missed: z {:+.3f} cm, {} findable, {} triplets: {} none, {} free, {} another's\n", miss.z, miss.findable, miss.triplets, miss.cut, miss.free, miss.other);
+          }
+        }
+      }
+      if (json.is_open()) {
+        json << std::format(R"({{"input":"{}","run":{},"threads":{},"planSeconds":0,"runSeconds":{:.9f},"maxRssBytes":{},"digest":"{:016x}","vertices":{})", options.input, repetition, threads, vertexSeconds, maxRssBytes(), vertexListDigest, found.vertices.size());
+        if (score) {
+          json << std::format(R"(,"score":{{"vertices":{{"vertices":{},"collisions":{},"found":{},"findable":{},"covered":{},"fakes":{},"splits":{},"merged":{}}}}})", score->vertices, score->collisions, score->found, score->findable, score->covered, score->fakes, score->splits, score->merged);
+        }
+        json << "}\n";
+        json.flush();
+      }
+      tracker.endTimeframe();
+      continue;
+    }
+    profile::Profile planProfile;
+    std::optional<TimeframePlan<Det>> plan;
+    double planSeconds = 0.;
+    if (!device) {
+      const profile::Activation activation{planProfile, pool.get()};
+      const profile::Zone zone{profile::Phase::kPlan};
+      plan.emplace(tracker.planTimeframe(frame, vertices, blocksPerSlice, param.sliceHaloPS));
+    }
+    planSeconds = planProfile[profile::Phase::kPlan].seconds + vertexSeconds;
+    if (device) {
+      const auto run = interface.track(frame, vertices);
+      if (run.dropped) {
+        throw std::runtime_error("the tracking ran out of device memory");
+      }
+      const auto& deviceTracks = *run.result.tracks;
+      const auto& deviceRun = interface.deviceReport();
+      planSeconds = deviceVertexing ? vertexed.planSeconds : run.planSeconds;
+      const double deviceSeconds = vertexed.seconds + run.seconds - planSeconds;
+      const double deviceVertexSeconds = deviceRun.vertexSeconds + run.planSeconds + deviceRun.planUploadSeconds;
+      if (deviceVertexing) {
+        std::cout << std::format("vertexer on {}: {} vertices from {} candidates of {} triplets in {:.4f} s, the plan with them uploaded\n", options.backend, vertexed.found->vertices.size(), vertexed.found->candidates, vertexed.found->triplets, deviceVertexSeconds);
+        std::cout << std::format("digest, vertices: {:016x}\n", vertexDigest(vertexed.found->vertices, vertexed.found->contributors));
+        if (last) {
+          // The host's list on the same frame, against the device's.
+          auto host = vertexing->find(frame, blocksPerSlice, param.sliceHaloPS);
+          if (host.status != StageStatus::kComplete) {
+            throw std::runtime_error(std::format("the host's vertexing pass failed with status {}", static_cast<int>(host.status)));
+          }
+          foundVertices = host.found.vertices;
+          std::cout << describeVertexAgreement(*vertexed.found, host.found) << '\n';
+        }
+      }
+      const auto deviceDigest = tracksDigest(deviceTracks);
+      walls.push_back(planSeconds + deviceSeconds);
+      digests.push_back(deviceDigest);
+      // The tracks in cluster numbers, as the host's lines carry them: equal
+      // across layouts, and to the host's in the deterministic build.
+      const auto deviceClusterDigest = tracksClusterDigest<Det>(deviceTracks, frame);
+      if (!options.tracksOut.empty() && last) {
+        writeTracks<Det>(options.tracksOut, deviceTracks, frame);
+      }
+      std::cout << std::format("\n=== run {}{}: tracks, {}, {}: {} in {:.4f} s (plan {:.4f} s, upload {:.4f} s, iterations", repetition, repetition == 0U ? " (cold)" : "", label, options.backend, deviceTracks.size(), planSeconds + deviceSeconds, planSeconds, deviceRun.uploadSeconds);
+      for (const double seconds : deviceRun.iterationSeconds) {
+        std::cout << std::format(" {:.4f}", seconds);
+      }
+      std::cout << std::format(" s, download {:.4f} s); arena peak {:.1f} MB\n", deviceRun.downloadSeconds, static_cast<double>(interface.deviceArenaPeakBytes()) / 1.e6);
+      std::cout << std::format("digest, tracks: {:016x}\n", deviceDigest);
+      std::cout << std::format("digest, tracks in clusters: {:016x}\n", deviceClusterDigest);
+      for (std::size_t iteration = 0; iteration < deviceRun.iterations.size(); ++iteration) {
+        const auto& report = deviceRun.iterations[iteration];
+        std::cout << std::format("  iteration {}: {} records, {} duplicates, {} mismatches, {} rounds, {} tracks, {} readbacks; arena peak {:.1f} MB\n", iteration, report.records, report.duplicates, report.mismatches, report.rounds, report.tracks, report.readbacks, static_cast<double>(report.arenaPeakBytes) / 1.e6);
+      }
+      const auto deviceRows = trackRows(deviceTracks);
+      const auto score = scoreAndPrint(deviceRows);
+      const auto sourceScore = scoreSources(deviceRows);
+      if (json.is_open()) {
+        json << std::format(R"({{"input":"{}",{}"run":{},"backend":"{}","device":"{}","planSeconds":{:.9f},"runSeconds":{:.9f},"uploadSeconds":{:.9f},)"
+                            R"("downloadSeconds":{:.9f},"arenaPeakBytes":{},"maxRssBytes":{},"digest":"{:016x}","tracksClusterDigest":"{:016x}","tracks":{},)"
+                            R"("iterations":[)",
+                            options.input, gridJson, repetition, options.backend, interface.deviceProperties().name, planSeconds, deviceSeconds, deviceRun.uploadSeconds, deviceRun.downloadSeconds, interface.deviceArenaPeakBytes(), maxRssBytes(), deviceDigest, deviceClusterDigest, deviceTracks.size());
+        for (std::size_t iteration = 0; iteration < deviceRun.iterations.size(); ++iteration) {
+          const auto& report = deviceRun.iterations[iteration];
+          json << (iteration == 0U ? "" : ",")
+               << std::format(R"({{"seconds":{:.9f},"records":{},"rounds":{},"tracks":{},)"
+                              R"("arenaPeakBytes":{},"roads":{},"slices":[)",
+                              deviceRun.iterationSeconds[iteration], report.records, report.rounds, report.tracks, report.arenaPeakBytes, std::accumulate(deviceRun.slices[iteration].begin(), deviceRun.slices[iteration].end(), std::uint64_t{0U}, [](auto total, const auto& slice) { return total + slice.roads; }));
+          for (std::size_t index = 0U; index < deviceRun.slices[iteration].size(); ++index) {
+            const auto& slice = deviceRun.slices[iteration][index];
+            json << (index == 0U ? "" : ",")
+                 << std::format(R"({{"tracklets":{},"permutation":{},"triplets":{},"neighbours":{},"roads":{},"records":{},)"
+                                R"("chained":{},"readbacks":{},)"
+                                R"("candidatePairs":{},"candidateSources":{},"candidateMax":{},"candidateChunks":{},)"
+                                R"("freeBytesAtTracklets":{},"tripletCandidates":{},"tripletCandidateMax":{},"tripletChunks":{},)"
+                                R"("freeBytesAtTriplets":{}}})",
+                                slice.tracklets, slice.permutation, slice.triplets, slice.neighbours, slice.roads, slice.records, slice.chained, slice.readbacks, slice.trackletRun.candidates, slice.trackletSources, slice.trackletRun.largest, slice.trackletRun.chunks, slice.trackletRun.freeBytes, slice.tripletRun.candidates, slice.tripletRun.largest, slice.tripletRun.chunks, slice.tripletRun.freeBytes);
+          }
+          json << "]}";
+        }
+        json << ']';
+        if (score) {
+          json << R"(,"score":)" << jsonScore(score->first, comparison, score->second);
+        }
+        if (sourceScore) {
+          json << R"(,"scoreSources":)" << jsonScore(sourceScore->first, comparison, sourceScore->second);
+        }
+        json << "}\n";
+        json.flush();
+      }
+      if (options.hostReference && last) {
+        const std::span<const VertexSeed> vertices = vertexing ? std::span<const VertexSeed>{foundVertices} : std::span<const VertexSeed>{input.vertices};
+        const auto plan = tracker.planTimeframe(frame, vertices, blocksPerSlice, param.sliceHaloPS);
+        const auto result = tracker.run(frame, plan);
+        if (result.status != StageStatus::kComplete) {
+          throw std::runtime_error(std::format("the host reference failed with status {}", static_cast<int>(result.status)));
+        }
+        Digest hostDigest;
+        hostDigest.columns(result.tracks->view(), result.tracks->size());
+        const auto compared = compareColumns<TrackOf<maxChainLayers<Det>>::template RecordT>(result.tracks->view(), result.tracks->size(), std::as_const(deviceTracks).view(), deviceTracks.size());
+        referenceSame = compared.sameElements && compared.recordsDiffering == 0U;
+        std::cout << std::format("\nhost reference: {} tracks, digest, tracks: {:016x}; device {} tracks: ", result.tracks->size(), hostDigest.result(), deviceTracks.size());
+        if (!compared.sameElements) {
+          std::cout << "the track counts differ\n";
+        } else if (referenceSame) {
+          std::cout << "identical\n";
+        } else {
+          std::cout << std::format("{} tracks differ; by column (memlayout order):", compared.recordsDiffering);
+          for (std::size_t column = 0; column < compared.differingByColumn.size(); ++column) {
+            if (compared.differingByColumn[column] != 0U) {
+              std::cout << std::format(" {}: {} (max |diff| {:.3g})", column, compared.differingByColumn[column], compared.maxAbsDifference[column]);
+            }
+          }
+          std::cout << '\n';
+        }
+        const auto hostScore = scoreAndPrint(trackRows(*result.tracks));
+        static_cast<void>(hostScore);
+        tracker.endTimeframe();
+      }
+      continue;
+    }
+    work.clear();
+    workBefore = workCounts();
+    linkWork.clear();
+    linkWorkBefore = linkWorkCounts();
+    const auto runStart = std::chrono::steady_clock::now();
+    const auto result = [&] {
+      if (resumeFrom) {
+        return tracker.resume(frame, *plan, *resumeFrom);
+      }
+      if (!options.saveState.empty()) {
+        return tracker.run(frame, *plan, options.stateIterations);
+      }
+      return tracker.run(frame, *plan);
+    }();
+    const double runSeconds = std::chrono::duration<double>(std::chrono::steady_clock::now() - runStart).count();
+    if (result.status != StageStatus::kComplete) {
+      throw std::runtime_error(std::format("run {} failed with status {}", repetition, static_cast<int>(result.status)));
+    }
+    if (!options.saveState.empty() && last) {
+      writeCheckpoint(options.saveState, tracker.checkpoint(result), settings, checkpointFrame(frame), checkpointConditionsOf(vertices));
+      std::cout << std::format("checkpoint after {} iterations into {}\n", options.stateIterations, options.saveState);
+    }
+    const auto digest = trackingDigest(result, tracker.used());
+    walls.push_back(planSeconds + runSeconds);
+    digests.push_back(digest);
+
+    std::cout << std::format("\n=== run {}{}: tracks, {}: {} in {:.3f} s (plan {:.3f} s, run {:.3f} s); pool peak {:.1f} MB\n", repetition, repetition == 0U ? " (cold)" : "", label, result.tracks->size(), planSeconds + runSeconds, planSeconds, runSeconds, static_cast<double>(result.profile[profile::Phase::kRun].peakBytes) / 1.e6);
+    std::cout << std::format("digest, {}: {:016x}\n", label, digest);
+    // The stages' largest outputs of any slice:
+    // what the pool's peak is made of.
+    std::cout << std::format("largest slice: {} tracklets, {} triplets, {} neighbours; staging {} records\n", tracker.trackletHighWater(), tracker.tripletHighWater(), tracker.neighbourHighWater(), tracker.stagingHighWater());
+    // The tracks alone: the digest also counts the selection records' bytes,
+    // which a record's layout changes without changing a track.
+    std::cout << std::format("digest, tracks: {:016x}\n", tracksDigest(*result.tracks));
+    // In cluster numbers: unchanged by another grid layout, which renumbers
+    // the rows.
+    std::cout << std::format("digest, clusters: {:016x}\n", clusterDigest(result, frame, tracker.used()));
+    // The tracks alone in cluster numbers, sorted by their clusters: unchanged
+    // by the slicing too, which changes the summaries' counts and the tracks'
+    // order.
+    std::cout << std::format("digest, tracks in clusters: {:016x}\n", tracksClusterDigest<Det>(*result.tracks, frame));
+    if (!options.tracksOut.empty() && last) {
+      writeTracks<Det>(options.tracksOut, *result.tracks, frame);
+    }
+    if (truth && last) {
+      writeTruthStudies<Det>(options, *result.tracks, *truth, comparison, frame, tracking, *material, propagator, studies.followed, [&](std::size_t iteration) -> const IterationParameters<Det>& { return tracker.iteration(iteration); }, [&](std::uint64_t id, std::size_t iteration) { return funnel ? funnel->stages(id, iteration) : std::nullopt; }, [&](std::size_t iteration, std::span<const std::uint32_t> rows) { return funnel ? funnel->recordChi2(iteration, rows) : std::nullopt; });
+    }
+    for (std::size_t iteration = 0; iteration < result.iterations.size(); ++iteration) {
+      for (const auto& line : study::describeIteration(result.iterations[iteration], iteration)) {
+        std::cout << line << '\n';
+      }
+      if (iteration < work.size()) {
+        printWork(work[iteration], iteration);
+      }
+      if (iteration < linkWork.size()) {
+        printLinkWork<Det>(linkWork[iteration], iteration);
+      }
+    }
+    const auto hostRows = trackRows(*result.tracks);
+    const auto score = scoreAndPrint(hostRows);
+    const auto sourceScore = scoreSources(hostRows);
+    if (truth && last && (!options.breakdown.empty() || !options.breakdownParticles.empty())) {
+      const auto view = result.tracks->view();
+      const auto population = study::populationOf(options.breakdownPopulation);
+      if (!population) {
+        throw std::runtime_error("--breakdown-population " + options.breakdownPopulation + ": primary, decay or v0");
+      }
+      const study::TrackBreakdown breakdown(truth->rows, truth->particles, hostRows, comparison, *population, std::span<const std::uint8_t>{view.iteration, result.tracks->size()});
+      if (!options.breakdown.empty()) {
+        breakdown.write(options.breakdown);
+      }
+      if (!options.breakdownParticles.empty()) {
+        breakdown.writeParticles(options.breakdownParticles);
+      }
+    }
+    if (studies.follow && options.followStops) {
+      studies.follow->printStops();
+    }
+    if (completeAnatomy) {
+      completeAnatomy->print();
+      if (!options.fateOut.empty()) {
+        completeAnatomy->writeFates(options.fateOut);
+      }
+      // The seeding funnel: a pure road from the stage
+      // funnel where it ran.
+      completeAnatomy->printSeeding([&](std::uint64_t id, std::size_t iteration) -> std::optional<std::pair<std::uint32_t, int>> {
+        if (!funnel) {
+          return std::nullopt;
+        }
+        const auto stages = funnel->stages(id, iteration);
+        if (!stages) {
+          return std::nullopt;
+        }
+        return std::pair{stages->longest[static_cast<std::size_t>(study::FunnelStage::kRoads)], static_cast<int>(stages->fitLoss)};
+      });
+      completeAnatomy->printRecordLosses();
+      if (!options.anatomyBeamLine.empty()) {
+        completeAnatomy->writeBeamLine(options.anatomyBeamLine);
+      }
+      if (!options.anatomyFollowLoss.empty()) {
+        completeAnatomy->writeFollowLoss(options.anatomyFollowLoss);
+      }
+    }
+    if (funnel) {
+      for (const auto& line : funnel->report(trackRows(*result.tracks))) {
+        std::cout << line << '\n';
+      }
+      std::vector<std::size_t> trackIterations(result.tracks->size());
+      for (std::size_t track = 0; track < trackIterations.size(); ++track) {
+        trackIterations[track] = result.tracks->view().iteration[track];
+      }
+      for (const auto& line : funnel->lengthReport(trackRows(*result.tracks), trackIterations, tracker)) {
+        std::cout << line << '\n';
+      }
+    }
+    if (vertexStudy) {
+      for (const auto& line : vertexStudy->report()) {
+        std::cout << line << '\n';
+      }
+      if (!options.vertexList.empty()) {
+        vertexStudy->writeStageVertices(options.vertexList);
+        std::cout << std::format("the vertexer's vertices written to {}\n", options.vertexList);
+      }
+      if (!options.vertexReplay.empty()) {
+        vertexStudy->writeReplay(options.vertexReplay);
+        std::cout << std::format("the replay's lists written to {}-{{vertices,collisions,dropped}}.csv and {}-owned.txt\n", options.vertexReplay, options.vertexReplay);
+      }
+      std::cout << std::format("peak RSS {:.2f} GB\n", static_cast<double>(maxRssBytes()) / 1.e9);
+    }
+    if (options.tree) {
+      study::report(std::cout, result.profile, profile::Phase::kRun, threads);
+    }
+    if (options.iterationTrees) {
+      for (std::size_t iteration = 0; iteration < result.iterations.size(); ++iteration) {
+        std::cout << std::format("--- iteration {}\n", iteration);
+        study::report(std::cout, result.iterations[iteration].profile, profile::Phase::kIteration, threads);
+      }
+    }
+    if (json.is_open()) {
+      json << std::format(R"({{"input":"{}",{}"run":{},"threads":{},"chunkSize":{},"planSeconds":{:.9f},"runSeconds":{:.9f},"maxRssBytes":{},"poolPeakBytes":{},"vertexerPoolPeakBytes":{},)"
+                          R"("digest":"{:016x}","clusterDigest":"{:016x}","tracksClusterDigest":"{:016x}","tracks":{},)",
+                          options.input, gridJson, repetition, threads, chunkSize, planSeconds, runSeconds, maxRssBytes(), result.profile[profile::Phase::kRun].peakBytes, vertexerPoolPeak, digest, clusterDigest(result, frame, tracker.used()), tracksClusterDigest<Det>(*result.tracks, frame), result.tracks->size());
+      json << R"("iterations":[)";
+      for (std::size_t iteration = 0; iteration < result.iterations.size(); ++iteration) {
+        const auto& summary = result.iterations[iteration];
+        json << (iteration == 0U ? "" : ",")
+             << std::format(R"({{"roads":{},"records":{},"rounds":{},"tracks":{},"followed":{},"followedOutward":{},"followedInward":{},"dropped":{},)"
+                            R"("followedEarlier":{},"followedEarlierOutward":{},"followedEarlierInward":{},)",
+                            summary.roads, summary.records, summary.rounds, summary.tracks, summary.tracksFollowed, summary.clustersFollowedOutward, summary.clustersFollowedInward, summary.tracksDropped, summary.tracksFollowedEarlier, summary.clustersFollowedEarlierOutward, summary.clustersFollowedEarlierInward);
+        // The counters build's work counts, in WorkCounter's order.
+        if (iteration < work.size()) {
+          json << R"("work":)" << jsonArray(work[iteration]) << ',';
+        }
+        json << R"("profile":)";
+        study::writeJson(json, summary.profile);
+        json << '}';
+      }
+      json << R"(],"profile":)";
+      auto profiled = result.profile;
+      profiled += planProfile;
+      study::writeJson(json, profiled);
+      if (score) {
+        json << R"(,"score":)" << jsonScore(score->first, comparison, score->second);
+      }
+      if (sourceScore) {
+        json << R"(,"scoreSources":)" << jsonScore(sourceScore->first, comparison, sourceScore->second);
+      }
+      json << "}\n";
+      json.flush();
+    }
+    if (last && !options.trace.empty()) {
+      std::ofstream out{options.trace};
+      trace.write(out);
+      std::cout << std::format("trace written to {}\n", options.trace);
+    }
+    // The timeframe's memory back to the pool: the next
+    // run pays first touch again, as a real run's timeframes do.
+    tracker.endTimeframe();
+  }
+  if (!options.fitInputs.empty()) {
+    study::writeFitInputs(options.fitInputs, fitInputs);
+    std::cout << std::format("fit inputs of {} triplets and {} neighbours written to {}\n", fitInputs.triplets.size(), fitInputs.neighbours.size(), options.fitInputs);
+  }
+
+  if (seedingReal && !options.seedingParticles.empty()) {
+    std::ofstream particles(options.seedingParticles);
+    seedingReal->writeParticles(particles);
+    particles.close();
+    if (!particles) {
+      throw std::runtime_error("cannot write " + options.seedingParticles);
+    }
+  }
+  const bool same = std::ranges::all_of(digests, [&](std::uint64_t digest) { return digest == digests.front(); });
+  std::vector<double> warm{walls.begin() + (walls.size() > 1U ? 1 : 0), walls.end()};
+  std::ranges::sort(warm);
+  std::cout << std::format("\n{} runs {}: cold {:.4f} s; warm min {:.4f} s, median {:.4f} s, max {:.4f} s; digests {}\n", walls.size(), device ? std::format("on {}", options.backend) : std::format("at {} threads", threads), walls.front(), warm.front(), warm[warm.size() / 2U], warm.back(), same ? "all equal" : "DIFFER");
+  return same && referenceSame ? 0 : 2;
+}
+
+extern template int track<detectors::ITS>(const Options& options);
+extern template int track<detectors::MFT>(const Options& options);
+extern template int track<detectors::TRKFT3>(const Options& options);
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_TRACKBENCH_H_
diff --git a/Detectors/GenericTracking/study/tools/TrackBreakdown.h b/Detectors/GenericTracking/study/tools/TrackBreakdown.h
new file mode 100644
index 0000000000000..9e577d3a7d0ad
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/TrackBreakdown.h
@@ -0,0 +1,321 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackBreakdown.h
+/// \brief Where a run's tracks sit: the tracks by
+///        their number of measurements, and the findable particles of one
+///        origin found complete, incomplete or not, with where an incomplete
+///        one's missing measurements went.
+///
+/// Under the score's rules (TrackComparison.h): a track is good when every
+/// row carries one particle, a fake otherwise; a particle's good track with
+/// the most layers is its best, the others are clones; a particle is found
+/// complete when its best track has a row on every layer the particle has
+/// one on. Per track length: the tracks, the fakes, the clones, and the
+/// best tracks of a complete particle.
+///
+/// The class is the score's findable particles of one population (the
+/// physical primaries, the decay daughters or the V0s'; a chain of
+/// `minLayers`, the score's pT floor). An incomplete particle's missing
+/// layers are the layers it has a row on that its best track has none on.
+/// Each missing layer's rows are looked up in the tracks: in another good
+/// track of the same particle (a split), in a fake labelled with the
+/// particle (its majority), in another fake, in another particle's good
+/// track (the row carries both), or in none -- free after the run. With
+/// several rows on the layer the first of that order holds. The layer is
+/// also placed against the best track: before its first row, after its last
+/// or between them, by the distance from the beam axis at the particle's
+/// production z, hypot(r, z - vz) (no MC hits: the order of a first outward
+/// pass; for a primary from the beam spot the distance from its vertex but
+/// for the transverse offset).
+///
+/// Per particle of the class (`writeParticles`, a CSV): its truth, its layers,
+/// its status, its best track's layers and iteration, and its missing layers
+/// by fate and place, a bit per layer -- for splits by layer pattern, pT or
+/// the pass that found it (tools/incompleteParticles.py). A particle not
+/// found has every layer's fate, no place: whether a later pass could still
+/// take its rows. Its inbound layers:
+/// those whose rows all lie past the turning point -- each nearer the axis
+/// than a row before it along the path, the rows ordered by |z - vz| (a
+/// primary's longitudinal distance grows along its helix). Rows within the
+/// margin in |z - vz| are not ordered against each other (pz near 0, rows
+/// of one plane). A heuristic: a hard scatter can turn a track too.
+
+#ifndef GTRK_STUDY_TRACKBREAKDOWN_H_
+#define GTRK_STUDY_TRACKBREAKDOWN_H_
+
+#include "GenericTracking/Study/TrackComparison.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cmath>
+#include <cstdint>
+#include <format>
+#include <fstream>
+#include <limits>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+class TrackBreakdown
+{
+ public:
+  /// Where a missing layer's row is after the run.
+  enum Fate : std::uint8_t { kSplit,
+                             kOwnFake,
+                             kFake,
+                             kOtherGood,
+                             kFree,
+                             kFates };
+  /// Where a missing layer sits against the best track's rows.
+  enum Place : std::uint8_t { kBefore,
+                              kBetween,
+                              kAfter,
+                              kPlaces };
+  static constexpr std::size_t kLengths = study::kScoreLengthSlots;
+  static constexpr std::size_t kMaxLayers = 64;
+
+  /// A particle's status.
+  enum Status : std::uint8_t { kComplete,
+                               kIncomplete,
+                               kFakeOnly,
+                               kNotFound };
+  /// One particle of the class: missing = layers & ~best; the missing layers'
+  /// fates and places a bit per layer (between: missing & ~before & ~after).
+  struct Particle {
+    std::uint64_t id = 0U;
+    study::ParticleTruth truth;
+    std::uint64_t layers = 0U;
+    Status status = kNotFound;
+    std::uint64_t best = 0U;         ///< the best track's layers
+    std::uint8_t bestIteration = 0U; ///< the iteration that made it
+    std::uint32_t goodTracks = 0U;
+    std::array<std::uint64_t, kFates> fates{};
+    std::uint64_t before = 0U;
+    std::uint64_t after = 0U;
+    std::uint64_t inbound = 0U;
+  };
+
+  /// \a tracks of one run scored against \a rows and \a truth under \a comparison,
+  /// the class's particles those of \a population; \a iterations, the
+  /// iteration of each track, for the particles' records.
+  TrackBreakdown(std::span<const study::TruthRow> rows, const study::ParticleTable& truth, const study::TrackRows& tracks, const study::ComparisonSettings& comparison, study::Population population, std::span<const std::uint8_t> iterations)
+  {
+    const auto length = [](std::size_t size) { return std::min(size, kLengths - 1U); };
+    std::vector<std::uint64_t> good(tracks.size(), study::kNoTrackParticle);
+    std::vector<std::uint64_t> majority(tracks.size(), study::kNoTrackParticle); // a fake's majority particle
+    std::vector<std::uint64_t> layersOf(tracks.size(), 0U);
+    std::unordered_map<std::uint64_t, std::vector<std::uint32_t>> tracksOf;
+    std::vector<std::vector<std::uint32_t>> tracksOfRow(rows.size());
+    for (std::uint32_t t = 0; t < tracks.size(); ++t) {
+      const auto& track = tracks[t];
+      for (const auto row : track) {
+        layersOf[t] |= std::uint64_t{1} << rows[row].layer;
+        tracksOfRow[row].push_back(t);
+      }
+      good[t] = study::goodParticle(rows, track);
+      ++mTracks[length(track.size())];
+      if (good[t] == study::kNoTrackParticle) {
+        ++mFakes[length(track.size())];
+        majority[t] = study::majorityParticle(rows, track).particle;
+      } else {
+        tracksOf[good[t]].push_back(t);
+      }
+    }
+    // Each particle's best track: the most layers, the first such.
+    std::unordered_map<std::uint64_t, std::uint32_t> best;
+    for (const auto& [particle, owned] : tracksOf) {
+      const auto top = *std::ranges::max_element(owned, {}, [&](std::uint32_t t) { return std::popcount(layersOf[t]); });
+      best[particle] = top;
+      for (const auto t : owned) {
+        if (t != top) {
+          ++mClones[length(tracks[t].size())];
+        }
+      }
+    }
+    // Every particle's rows, for the missing layers.
+    auto rowsOf = study::rowsOfParticles(rows);
+    const auto layers = study::particleLayers(rows, comparison);
+    for (const auto& [particle, top] : best) {
+      if (layersOf[top] == layers.at(particle).layers) {
+        ++mCompleteTracks[length(tracks[top].size())];
+      }
+    }
+    for (const auto& [id, mine] : layers) {
+      const auto found = truth.find(id);
+      if (found == truth.end() || !study::inPopulation(found->second, population) || !study::isFindable(found->second.pt, mine, comparison)) {
+        continue;
+      }
+      ++mFindable;
+      const auto layerCount = static_cast<std::size_t>(std::popcount(mine.layers));
+      const auto at = best.find(id);
+      auto& record = mParticles.emplace_back(Particle{.id = id, .truth = found->second, .layers = mine.layers, .inbound = inbound(rows, rowsOf[id], found->second)});
+      if (at == best.end()) {
+        const bool withFake = std::ranges::any_of(rowsOf[id], [&](std::uint32_t row) { return std::ranges::any_of(tracksOfRow[row], [&](std::uint32_t t) { return good[t] == study::kNoTrackParticle && majority[t] == id; }); });
+        ++(withFake ? mFakeOnly : mNotFound);
+        record.status = withFake ? kFakeOnly : kNotFound;
+      } else {
+        record.best = layersOf[at->second];
+        record.bestIteration = iterations[at->second];
+        record.goodTracks = static_cast<std::uint32_t>(tracksOf[id].size());
+        if ((mine.layers & ~record.best) == 0U) {
+          ++mComplete[std::min(layerCount, kMaxLayers - 1U)];
+          record.status = kComplete;
+          continue;
+        }
+        record.status = kIncomplete;
+        ++mIncomplete[std::min(layerCount, kMaxLayers - 1U)];
+        ++mMissingCount[std::min(static_cast<std::size_t>(std::popcount(mine.layers & ~record.best)), kLengths - 1U)];
+      }
+      // The missing layers -- every layer of a particle not found -- and,
+      // against a best track, their place along the particle's path, by the
+      // distance from the beam axis at its production z.
+      const auto missing = mine.layers & ~record.best;
+      const bool placed = at != best.end();
+      const auto distance = [&](std::uint32_t row) { return std::hypot(static_cast<double>(rows[row].r), static_cast<double>(rows[row].z) - static_cast<double>(found->second.vz)); };
+      double first = std::numeric_limits<double>::infinity();
+      double last = 0.;
+      if (placed) {
+        for (const auto row : tracks[at->second]) {
+          first = std::min(first, distance(row));
+          last = std::max(last, distance(row));
+        }
+      }
+      std::array<std::uint8_t, kMaxLayers> fate{};
+      std::array<double, kMaxLayers> where{};
+      fate.fill(kFree);
+      where.fill(std::numeric_limits<double>::infinity());
+      for (const auto row : rowsOf[id]) {
+        const auto layer = rows[row].layer;
+        if (((missing >> layer) & 1U) == 0U) {
+          continue;
+        }
+        where[layer] = std::min(where[layer], distance(row));
+        for (const auto t : tracksOfRow[row]) {
+          const auto kind = good[t] == id ? kSplit : good[t] != study::kNoTrackParticle ? kOtherGood
+                                                   : majority[t] == id                  ? kOwnFake
+                                                                                        : kFake;
+          fate[layer] = std::min<std::uint8_t>(fate[layer], kind);
+        }
+      }
+      for (std::size_t layer = 0; layer < kMaxLayers; ++layer) {
+        if (((missing >> layer) & 1U) == 0U) {
+          continue;
+        }
+        const auto bit = std::uint64_t{1} << layer;
+        record.fates[fate[layer]] |= bit;
+        if (placed) {
+          const auto place = where[layer] < first ? kBefore : (where[layer] > last ? kAfter : kBetween);
+          ++mMissing[layer][fate[layer]][place];
+          record.before |= place == kBefore ? bit : 0U;
+          record.after |= place == kAfter ? bit : 0U;
+        }
+      }
+    }
+  }
+
+  /// The breakdown as one JSON line appended to \a path.
+  void write(const std::string& path) const
+  {
+    std::ofstream out(path, std::ios::app);
+    if (!out) {
+      throw std::runtime_error("cannot append to " + path);
+    }
+    const auto list = [](const auto& values) {
+      std::string text = "[";
+      for (std::size_t i = 0; i < values.size(); ++i) {
+        text += std::format("{}{}", i == 0U ? "" : ",", values[i]);
+      }
+      return text + "]";
+    };
+    std::string missing = "[";
+    for (std::size_t layer = 0; layer < kMaxLayers; ++layer) {
+      missing += layer == 0U ? "[" : ",[";
+      for (std::size_t fate = 0; fate < kFates; ++fate) {
+        missing += std::format("{}{}", fate == 0U ? "" : ",", list(mMissing[layer][fate]));
+      }
+      missing += "]";
+    }
+    missing += "]";
+    out << std::format(R"({{"tracks":{},"fakes":{},"clones":{},"completeTracks":{},"findable":{},"notFound":{},"fakeOnly":{},"complete":{},"incomplete":{},)"
+                       R"("missingCount":{},"missing":{}}})",
+                       list(mTracks), list(mFakes), list(mClones), list(mCompleteTracks), mFindable, mNotFound, mFakeOnly, list(mComplete), list(mIncomplete), list(mMissingCount), missing)
+        << '\n';
+  }
+
+  /// The layers of \a mine (rows of \a truth's particle) whose rows are all
+  /// past its turning point: nearer the axis than a row at least
+  /// kTurnMarginCm before it in |z - vz|, by kTurnMarginCm.
+  static std::uint64_t inbound(std::span<const study::TruthRow> rows, std::vector<std::uint32_t> mine, const study::ParticleTruth& truth)
+  {
+    constexpr float kTurnMarginCm = 0.5F;
+    const auto along = [&](std::uint32_t row) { return std::abs(rows[row].z - truth.vz); };
+    std::ranges::sort(mine, {}, along);
+    std::uint64_t in = 0U;
+    std::uint64_t out = 0U;
+    float reached = 0.F;
+    std::size_t earlier = 0U;
+    for (const auto row : mine) {
+      for (; earlier < mine.size() && along(mine[earlier]) < along(row) - kTurnMarginCm; ++earlier) {
+        reached = std::max(reached, rows[mine[earlier]].r);
+      }
+      (rows[row].r < reached - kTurnMarginCm ? in : out) |= std::uint64_t{1} << rows[row].layer;
+    }
+    return in & ~out;
+  }
+
+  /// The class's particles as CSV rows appended to \a path, the header first
+  /// when the file is new or empty (masks in hex).
+  void writeParticles(const std::string& path) const
+  {
+    std::ifstream before(path);
+    const bool fresh = !before.good() || before.peek() == std::ifstream::traits_type::eof();
+    std::ofstream out(path, std::ios::app);
+    if (!out) {
+      throw std::runtime_error("cannot append to " + path);
+    }
+    if (fresh) {
+      out << "id,pdg,pt,eta,phi,vx,vy,vz,layers,status,best,iteration,goodTracks,split,ownFake,fake,otherGood,free,before,after,inbound\n";
+    }
+    for (const auto& p : mParticles) {
+      out << std::format("{},{},{:.9g},{:.9g},{:.9g},{:.9g},{:.9g},{:.9g},{:x},{},{:x},{},{},{:x},{:x},{:x},{:x},{:x},{:x},{:x},{:x}\n", p.id, p.truth.pdg, p.truth.pt, p.truth.eta, p.truth.phi, p.truth.vx, p.truth.vy, p.truth.vz, p.layers, static_cast<int>(p.status), p.best, static_cast<int>(p.bestIteration), p.goodTracks, p.fates[kSplit], p.fates[kOwnFake], p.fates[kFake], p.fates[kOtherGood], p.fates[kFree], p.before, p.after, p.inbound);
+    }
+  }
+
+ private:
+  std::vector<Particle> mParticles;
+  /// By track length (the last slot the longer ones too).
+  std::array<std::uint64_t, kLengths> mTracks{};
+  std::array<std::uint64_t, kLengths> mFakes{};
+  std::array<std::uint64_t, kLengths> mClones{};
+  std::array<std::uint64_t, kLengths> mCompleteTracks{};
+  /// The class: not found, found only with a fake, and found complete or
+  /// incomplete by the particle's layer count.
+  std::uint64_t mFindable = 0U;
+  std::uint64_t mNotFound = 0U;
+  std::uint64_t mFakeOnly = 0U;
+  std::array<std::uint64_t, kMaxLayers> mComplete{};
+  std::array<std::uint64_t, kMaxLayers> mIncomplete{};
+  /// The incomplete by their number of missing layers.
+  std::array<std::uint64_t, kLengths> mMissingCount{};
+  /// The missing layers by layer, fate and place.
+  std::array<std::array<std::array<std::uint64_t, kPlaces>, kFates>, kMaxLayers> mMissing{};
+};
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_TRACKBREAKDOWN_H_
diff --git a/Detectors/GenericTracking/study/tools/VertexStudy.h b/Detectors/GenericTracking/study/tools/VertexStudy.h
new file mode 100644
index 0000000000000..0030e575111b7
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/VertexStudy.h
@@ -0,0 +1,2139 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file VertexStudy.h
+/// \brief The vertexer on one iteration's triplets against the MC
+///        collisions, and its replay.
+///
+/// The study observes one iteration -- the vertexing pass, links within the
+/// innermost layers -- and keeps each distinct triplet: its rows, its z0 from
+/// a straight line in r-z weighted by the points' z variances, and its frame,
+/// the middle measurement's time. It runs the vertexer (`Vertexer`,
+/// VertexStage.h) on every slice's triplets and measures each triplet as the
+/// vertexer does, without its cuts; it replays the vertexer's rounds on them
+/// (`replayAll`), checked to be the vertexer bit for bit at its settings,
+/// with the variants the vertexer does not run (the cuts in sigmas of the
+/// triplet's own errors, an earlier pass's vertices first).
+/// It prints the triplets' pulls in units of their own errors
+/// (`describePulls`) and the beam point the claimed triplets agree on
+/// (`estimateBeamPoint`), and writes the vertexer's vertices with their
+/// makeup (`writeStageVertices`) and the replay's lists (`writeReplay`).
+///
+/// A triplet is true when one particle carries all three measurements; it
+/// then belongs to that particle's collision when the particle is a primary.
+/// A vertex belongs to the collision most of its candidates belong to;
+/// background (fake or secondary triplets) as the majority makes it a fake. A
+/// collision is found when a vertex belongs to it; a second vertex of the
+/// same collision is a split; a collision whose own candidates went mostly to
+/// another collision's vertex is merged. What the tracking loses with a
+/// missed collision is counted as its findable primaries, the tracking QA's
+/// (`isFindable`: physical primaries on a chain of four layers).
+
+#ifndef GTRK_STUDY_VERTEXSTUDY_H_
+#define GTRK_STUDY_VERTEXSTUDY_H_
+
+#include "GenericTracking/Tracking/ShapeCut.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Study/Validation.h"
+#include "GenericTracking/Tracking/VertexStage.h"
+#include "GenericTracking/Study/MCTruth.h"
+#include "GenericTracking/Study/VertexQA.h"
+#include "GenericTracking/Study/Statistics.h"
+#include "GenericTracking/Study/TrackComparison.h"
+
+#include <algorithm>
+#include <bit>
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <format>
+#include <fstream>
+#include <iostream>
+#include <chrono>
+#include <map>
+#include <memory>
+#include <limits>
+#include <numbers>
+#include <optional>
+#include <ranges>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+
+/// The beam point a timeframe's triplets agree on: the least-squares solution of their BeamTerms, in the frame the
+/// measurements are in, so that it is the offset of the true beam line from
+/// the one the rows were placed about. Online, with no calibrated MeanVertex
+/// for the run yet, it is the beam position; offline it is the check on the
+/// object, and the watch on a drift.
+struct BeamEstimate {
+  Scalar x = 0.F;      ///< [cm]
+  Scalar y = 0.F;      ///< [cm]
+  Scalar sigmaX = 0.F; ///< the solution's error from the residuals' spread [cm]
+  Scalar sigmaY = 0.F;
+  Scalar rmsCM = 0.F;     ///< the residuals' spread of the terms used [cm]
+  std::size_t used = 0U;  ///< the terms the last pass kept
+  std::size_t terms = 0U; ///< the terms offered
+  bool valid = false;     ///< enough terms in enough directions
+};
+
+/// The beam point from \a terms, each counted once: a 2x2 least squares of
+/// n . p = d, made robust by three passes -- every term within
+/// \a maxDistanceCM of the axis (the rest debris, `kMaxBeamDistanceCM`), then
+/// the residuals within 1 mm of the first solution, then within three times
+/// their spread (at least 50 um) of the second -- so that the fake triplets,
+/// whose distances are broad, and a beam line off by a real offset of a
+/// millimetre both leave the answer alone. Invalid with fewer than 10 terms
+/// or directions that do not span the plane.
+[[nodiscard]] inline BeamEstimate estimateBeamPoint(std::span<const BeamTerm> terms, Scalar maxDistanceCM)
+{
+  BeamEstimate estimate;
+  estimate.terms = terms.size();
+  std::vector<std::uint8_t> keep(terms.size(), 0U);
+  for (std::size_t i = 0; i < terms.size(); ++i) {
+    keep[i] = terms[i].valid && std::abs(terms[i].d) < maxDistanceCM ? 1U : 0U;
+  }
+  Scalar x = 0.F;
+  Scalar y = 0.F;
+  Scalar rms = 0.F;
+  std::size_t used = 0U;
+  Scalar sxx = 0.F;
+  Scalar sxy = 0.F;
+  Scalar syy = 0.F;
+  Scalar det = 0.F;
+  for (int pass = 0; pass < 3; ++pass) {
+    sxx = sxy = syy = 0.F;
+    Scalar vx = 0.F;
+    Scalar vy = 0.F;
+    Scalar sw = 0.F;
+    used = 0U;
+    for (std::size_t i = 0; i < terms.size(); ++i) {
+      if (keep[i] == 0U) {
+        continue;
+      }
+      const auto& term = terms[i];
+      sxx += term.nx * term.nx;
+      sxy += term.nx * term.ny;
+      syy += term.ny * term.ny;
+      vx += term.nx * term.d;
+      vy += term.ny * term.d;
+      sw += 1.F;
+      ++used;
+    }
+    det = (sxx * syy) - (sxy * sxy);
+    // The directions must span the plane: the normal matrix's determinant at
+    // least a tenth of its value for directions spread evenly, (trace/2)^2.
+    const Scalar trace = sxx + syy;
+    if (used < 10U || !(det > 0.F) || det < 0.1F * trace * trace / 4.F) {
+      estimate.used = used;
+      return estimate;
+    }
+    x = ((syy * vx) - (sxy * vy)) / det;
+    y = ((sxx * vy) - (sxy * vx)) / det;
+    Scalar sumSquares = 0.F;
+    for (std::size_t i = 0; i < terms.size(); ++i) {
+      if (keep[i] == 0U) {
+        continue;
+      }
+      const Scalar residual = terms[i].d - (terms[i].nx * x) - (terms[i].ny * y);
+      sumSquares += residual * residual;
+    }
+    rms = sw > 0.F ? std::sqrt(sumSquares / sw) : 0.F;
+    if (pass == 2) {
+      break;
+    }
+    const Scalar cut = pass == 0 ? 0.1F : std::max(3.F * rms, 0.005F);
+    for (std::size_t i = 0; i < terms.size(); ++i) {
+      if (keep[i] == 0U) {
+        continue;
+      }
+      const Scalar residual = terms[i].d - (terms[i].nx * x) - (terms[i].ny * y);
+      keep[i] = std::abs(residual) < cut ? 1U : 0U;
+    }
+  }
+  estimate.x = x;
+  estimate.y = y;
+  estimate.rmsCM = rms;
+  estimate.used = used;
+  // The covariance of the solution: rms^2 times the inverse normal matrix.
+  estimate.sigmaX = rms * std::sqrt(syy / det);
+  estimate.sigmaY = rms * std::sqrt(sxx / det);
+  estimate.valid = true;
+  return estimate;
+}
+
+/// The beam estimate ignores a triplet whose circle passes farther than
+/// this from the axis [cm]: debris, no track from a collision.
+inline constexpr Scalar kMaxBeamDistanceCM = 0.5F;
+
+template <DetectorLayout Det, typename Controller>
+class VertexStudy
+{
+ public:
+  /// The vertexer's settings as the study's tables print them and its own
+  /// candidates are cut with (the makeup's reuse shares), from the configuration, in double and integer micrometres; the vertexer's
+  /// (`VertexerSettings`) narrow them to `Scalar` and `int32_t`.
+  struct Settings {
+    std::int64_t windowUM = 1000; ///< w: the window a peak is counted in
+    std::int64_t claimUM = 1000;  ///< the half-width around the peak's centre whose free candidates the vertex takes
+    std::uint32_t minContributors = 3U;
+    double significance = 0.; ///< k: the peak must exceed the sidebands' mean b by k sqrt(b)
+    double maxChi2RZ = 0.;    ///< candidates above it do not count; 0 for no cut
+    double maxDcaUM = 0.;     ///< the same for the transverse distance to the axis [um]
+  };
+
+  /// The study of \a iteration's triplets, its pass's pT floor \a
+  /// passMinPtGeV, against \a rows and \a particles, the collisions' findable
+  /// primaries by the tracking QA's \a comparison; the vertexer run on them
+  /// with \a stage on \a threads, the tables at \a table (the same settings
+  /// from the configuration).
+  VertexStudy(const TimeFrame<Det>& frame, std::span<const study::TruthRow> rows, const study::ParticleTable& particles, std::size_t iteration, double passMinPtGeV, study::ComparisonSettings comparison, const VertexerSettings& stage, const Settings& table, int threads)
+    : mFrame(&frame),
+      mRows(rows),
+      mParticles(&particles),
+      mIteration(iteration),
+      mPassMinPtGeV(passMinPtGeV),
+      mComparison(std::move(comparison)),
+      mStage(stage, VertexConstraint{}),
+      mTable(table),
+      mStagePool(std::make_unique<BoundedMemoryResource>()),
+      mArena(std::make_unique<o2::gtrk::detail::TaskArena>(threads))
+  {
+  }
+
+  void observeSlice(const Controller& tracker, const typename Controller::SliceObservation& slice)
+  {
+    if (slice.iteration != mIteration) {
+      return;
+    }
+    mPass = tracker.iteration(slice.iteration);
+    mBeamVarTransverse = tracker.beamLine().varTransverse;
+    const auto& result = *slice.result;
+    const auto tracklets = result.tracklets->view();
+    const auto triplets = result.triplets->view();
+    ++mSlices;
+    const auto columns = slice.frame->measurements();
+    for (std::size_t t = 0; t < result.tracklets->size(); ++t) {
+      ++mTrackletsByLink[tracklets.link[t]];
+      mTrackletsShaped[tracklets.link[t]] += pairShaped(columns, tracklets.source[t], tracklets.target[t]) ? 1U : 0U;
+    }
+    // The vertexer itself on this slice's triplets.
+    const auto start = std::chrono::steady_clock::now();
+    const ScatteringErrors<Det> errors{.table = &mPass->scattering, .cut = mPass->pairCut, .varTransverse = mBeamVarTransverse};
+    // Its work arrays on a pool of their own, for their peak.
+    mStagePool->resetPeakMemory();
+    const auto found = mStage.find(slice.frame->measurements(), tracklets, triplets, result.triplets->size(), mArena.get(), true, errors, mStagePool.get(), ownedFrames(slice.frame->grid().geometry(), slice.slice->coreBlocks));
+    mStageSeconds += std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+    mStagePoolPeak = std::max(mStagePoolPeak, mStagePool->getPeakMemory());
+    // Each triplet as the vertexer measures it, without its cuts, for the
+    // replay (`replay`): its status, chi2, z, dca, weight and box.
+    VertexerSettings open = mStage.settings();
+    open.maxChi2RZ = 0.F;
+    open.maxDcaCM = 0.F;
+    const auto measurements = slice.frame->measurements();
+    // The slice's triplets in its order and the frames it owns: the
+    // vertexer deduplicates per slice, ties in triplet order.
+    auto& sliceTriplets = mSliceTriplets.emplace_back(ownedFrames(slice.frame->grid().geometry(), slice.slice->coreBlocks), std::vector<Triple>{});
+    sliceTriplets.second.reserve(result.triplets->size());
+    // Each triplet's key and beam term, for the beam point of its claimed
+    // candidates in the vertexer's order: by key, ties in triplet order.
+    std::vector<std::uint64_t> keys(result.triplets->size(), 0U);
+    std::vector<BeamTerm> terms(result.triplets->size());
+    for (std::size_t t = 0; t < result.triplets->size(); ++t) {
+      VertexCandidateFit fit;
+      StageFit stageFit;
+      BeamTerm term;
+      stageFit.status = measureCandidate(measurements, tracklets, triplets, static_cast<std::uint32_t>(t), open, errors, fit, stageFit.weight, stageFit.box, &term);
+      stageFit.chi2RZ = fit.chi2RZ;
+      stageFit.zUM = stageFit.status == VertexCandidateStatus::kAccepted ? vertexKeyZUM(fit.key) : 0;
+      stageFit.dcaCM = term.d;
+      keys[t] = fit.key;
+      terms[t] = term;
+      const auto first = triplets.first[t];
+      mStageFits.emplace_back(Triple{tracklets.source[first], tracklets.target[first], tracklets.target[triplets.second[t]]}, stageFit);
+      sliceTriplets.second.push_back(mStageFits.back().first);
+    }
+    mStageCandidates += found.candidates;
+    for (std::size_t t = 0; t < result.triplets->size(); ++t) {
+      const auto first = triplets.first[t];
+      const auto second = triplets.second[t];
+      const auto vertex = found.tripletVertex[t];
+      if (vertex == VertexerResult::kNotOwned) {
+        continue; // another slice's frame
+      }
+      // A slice can hold one triple twice (two triplets on the same
+      // rows); the vertexer keeps one of them, the other deduplicated
+      // (-2): the claim is the kept one's.
+      const auto claim = vertex < 0 ? std::int64_t{vertex} : vertex + static_cast<std::int64_t>(mStageVertices.size());
+      const auto [at, inserted] = mStageClaims.try_emplace({tracklets.source[first], tracklets.target[first], tracklets.target[second]}, claim);
+      if (!inserted) {
+        ++mStageRepeats;
+        at->second = std::max(at->second, claim);
+      }
+    }
+    for (std::size_t v = 0; v < found.vertices.size(); ++v) {
+      mStageVertices.push_back(found.vertices[v]);
+      mStageContributors.push_back(found.contributors[v]);
+    }
+    mStageRounds = std::max(mStageRounds, found.rounds);
+    std::vector<std::uint32_t> claimed;
+    for (std::size_t t = 0; t < result.triplets->size(); ++t) {
+      if (found.tripletVertex[t] >= 0) {
+        claimed.push_back(static_cast<std::uint32_t>(t));
+      }
+    }
+    std::ranges::stable_sort(claimed, {}, [&](std::uint32_t t) { return keys[t]; });
+    std::vector<BeamTerm> claimedTerms;
+    claimedTerms.reserve(claimed.size());
+    for (const auto t : claimed) {
+      claimedTerms.push_back(terms[t]);
+    }
+    const auto beam = estimateBeamPoint(claimedTerms, kMaxBeamDistanceCM);
+    if (beam.terms > mStageBeam.terms) {
+      mStageBeam = beam; // the slice with the most to say; one slice in the usual run
+    }
+  }
+
+  /// The beam line the rows are about, for the estimate's absolute position.
+  void setBeamLine(double x, double y)
+  {
+    mBeamX = x;
+    mBeamY = y;
+  }
+
+  /// An earlier pass's vertices: the `stage` rows of a
+  /// replay's <prefix>-vertices.csv, listed ones, by their frame's time.
+  /// With them the replay adds the variants `prior-*`, which start each
+  /// frame from them: their claims taken, their triplets within the claim
+  /// owning their rows, before the first round.
+  void setPriorVertices(const std::string& path)
+  {
+    std::ifstream in(path);
+    if (!in) {
+      throw std::runtime_error("cannot read " + path);
+    }
+    std::string line;
+    std::getline(in, line);
+    while (std::getline(in, line)) {
+      std::vector<std::string> fields;
+      for (const auto part : line | std::views::split(',')) {
+        fields.emplace_back(part.begin(), part.end());
+      }
+      // variant, id, listed, framePS, round, windowStartUM, centreUM, zUM, ...
+      if (fields.size() < 8U || fields[0] != "stage" || std::stoll(fields[2]) < 0) {
+        continue;
+      }
+      mPriorVertices[static_cast<std::uint32_t>(std::stoul(fields[3]))].push_back(static_cast<Scalar>(std::stod(fields[7])));
+    }
+  }
+
+  /// Everything, as lines: the pass's counts, the candidates against the
+  /// truth, the triplets' pulls, the vertexer's vertices against the
+  /// collisions, the replay, and the vertexer's fakes and missed collisions.
+  [[nodiscard]] std::vector<std::string> report()
+  {
+    std::vector<std::string> lines;
+    // Every slice's triplets, then the distinct ones: a triple twice in a
+    // slice or in two slices' halos is one candidate.
+    const auto observed = mStageFits.size();
+    std::ranges::sort(mStageFits, {}, [](const auto& entry) { return entry.first; });
+    const auto repeated = std::ranges::unique(mStageFits, {}, [](const auto& entry) { return entry.first; });
+    mStageFits.erase(repeated.begin(), repeated.end());
+    std::string links;
+    for (const auto& [link, count] : mTrackletsByLink) {
+      links += std::format(" {}->{} {}", Det::layerLinks[link].from, Det::layerLinks[link].to, count);
+      links += std::format(" (shape {})", mTrackletsShaped[link]);
+    }
+    lines.push_back(std::format("vertex study: iteration {}, {} slices; tracklets by link:{}; triplets {} ({} distinct)", mIteration, mSlices, links, observed, mStageFits.size()));
+    buildCollisions();
+    buildCandidates();
+    describeCandidates(lines);
+    describePulls(lines);
+    const auto stage = stageScore();
+    lines.emplace_back("the vertexer (VertexStage.h) at the table's settings:");
+    lines.push_back(describe(stage, mTable) + std::format(" | rounds {}", mStageRounds));
+    lines.push_back(std::format("the vertexer took {:.4f} s for {} candidates, {} threads; its work arrays' peak {:.1f} MB", mStageSeconds, mStageCandidates, mArena->maxConcurrency(), static_cast<double>(mStagePoolPeak) * 1.e-6));
+    const auto& beam = mStageBeam;
+    lines.push_back(beam.valid ? std::format("the beam point from the triplets' circles: ({:+.1f}, {:+.1f}) um off the rows' beam line, +- ({:.1f}, "
+                                             "{:.1f}) um, residuals' rms {:.0f} um, {} of {} terms; the rows about ({:.4f}, {:.4f}) cm, so the beam at ({:.4f}, "
+                                             "{:.4f}) cm",
+                                             static_cast<double>(beam.x) * 1.e4, static_cast<double>(beam.y) * 1.e4, static_cast<double>(beam.sigmaX) * 1.e4, static_cast<double>(beam.sigmaY) * 1.e4, static_cast<double>(beam.rmsCM) * 1.e4, beam.used, beam.terms, mBeamX, mBeamY, mBeamX + static_cast<double>(beam.x), mBeamY + static_cast<double>(beam.y))
+                               : std::format("the beam point from the triplets' circles: no estimate ({} of {} terms usable)", beam.used, beam.terms));
+    // The vertexer's list (its debris rule included) by multiplicity; its
+    // diagnostics after the replay.
+    const auto efficiency = efficiencyByMultiplicity(mTable, stage, "the vertexer's ");
+    lines.push_back(efficiency.table);
+    replayAll(lines);
+    lines.emplace_back("the vertexer's fakes and missed collisions:");
+    lines.insert(lines.end(), efficiency.diagnostics.begin(), efficiency.diagnostics.end());
+    return lines;
+  }
+
+  /// The replay's vertices, collisions and drops, one CSV
+  /// each, \a prefix-vertices.csv, -collisions.csv and -dropped.csv, every
+  /// variant's rows with its name, for tools/vertexReplay.py, and the first
+  /// variant's owned rows as their clusters, \a prefix-owned.txt. The drops
+  /// are the true triplets an ownership dropped whose collision is not the
+  /// owner's majority: what a real neighbour loses.
+  void writeReplay(const std::string& prefix) const
+  {
+    std::ofstream vertices(prefix + "-vertices.csv");
+    std::ofstream collisions(prefix + "-collisions.csv");
+    std::ofstream drops(prefix + "-dropped.csv");
+    if (!vertices || !collisions || !drops) {
+      throw std::runtime_error(std::format("cannot write the replay's lists {}-*.csv", prefix));
+    }
+    vertices << "variant,id,listed,framePS,round,windowStartUM,centreUM,zUM,window,sidebands,hidden,contributors,selected,dropped,reuse,"
+                "collision,trueZUM,findable,reference,startPS,widthPS,denseShare,softShare,noParticleShare\n";
+    collisions << "variant,collision,trueZUM,framePS,inner,findable,found,vertexZUM,contributors,round,accepted,kept,core,chi2,dca,"
+                  "degenerate,deduplicated,free,own,other,fake,dropped,dense,denseFindable,denseDzUM,denseContributors,vetoedWindow,vetoedSidebands\n";
+    // The vertexer's owned rows (the first run's) as their clusters, one per
+    // line -- rows move with the grid, which a pass's floor rebins -- for a
+    // later pass to hold (trackBench --hold-clusters).
+    std::ofstream owned(prefix + "-owned.txt");
+    if (!owned) {
+      throw std::runtime_error(std::format("cannot write {}-owned.txt", prefix));
+    }
+    const auto columns = mFrame->measurements();
+    for (const auto row : mReplays.front().owned) {
+      owned << columns.clusterIndex[row] << '\n';
+    }
+    drops << "variant,collision,findable,zUM,owner,ownerCollision,ownerZUM,source,sourceCollision,sourceState,sourceZUM,row,rowCollision\n";
+    constexpr std::array<std::string_view, kReplayStates> kStateNames{"chi2", "dca", "degenerate", "deduplicated", "kept", "own", "other", "fake", "dropped"};
+    for (const auto& run : mReplays) {
+      for (std::size_t v = 0; v < run.vertices.size(); ++v) {
+        const auto& r = run.vertices[v];
+        const auto* collision = r.collision < 0 ? nullptr : &mCollisions[static_cast<std::size_t>(r.collision)];
+        vertices << std::format("{},{},{},{},{},{},{:.1f},{:.1f},{},{},{},{},{},{},{:.4f},{},{:.1f},{},{},{},{},{:.3f},{:.3f},{:.3f}\n", run.name, v, r.listed, mFrameTimes[static_cast<std::size_t>(r.frame)], r.round, r.windowStartUM, r.centreUM, r.zUM, r.window, r.sidebands, r.hidden, r.contributors, r.selected, r.dropped, r.reuse, r.collision, collision == nullptr ? 0. : collision->z * 1.e4, collision == nullptr ? 0U : collision->findable, r.reference, r.startPS, r.widthPS, r.denseShare, r.softShare, r.noParticleShare);
+      }
+      for (std::size_t c = 0; c < mCollisions.size(); ++c) {
+        const auto& collision = mCollisions[c];
+        const auto& s = run.collisions[c];
+        const auto best = run.score.best[c];
+        const auto* vertex = best < 0 ? nullptr : &run.vertices[static_cast<std::size_t>(run.listedToId[static_cast<std::size_t>(best)])];
+        const auto* dense = s.dense < 0 ? nullptr : &mCollisions[static_cast<std::size_t>(s.dense)];
+        collisions << std::format("{},{},{:.1f},{},{},{},{:d},{:.1f},{},{},{},{},{}", run.name, c, collision.z * 1.e4, collision.frame < 0 ? 0U : mFrameTimes[static_cast<std::size_t>(collision.frame)], collision.inner, collision.findable, vertex != nullptr, vertex == nullptr ? 0. : vertex->zUM, vertex == nullptr ? 0U : vertex->contributors, vertex == nullptr ? 0U : vertex->round, s.accepted, s.kept, s.core);
+        for (const auto count : s.states) {
+          collisions << ',' << count;
+        }
+        collisions << std::format(",{},{},{:.1f},{},{},{}\n", s.dense, dense == nullptr ? 0U : dense->findable, dense == nullptr ? 0. : std::abs(collision.z - dense->z) * 1.e4, s.denseContributors, s.vetoedWindow, s.vetoedSidebands);
+      }
+      for (const auto& drop : run.drops) {
+        const auto& candidate = mCandidates[drop.candidate];
+        const auto& owner = run.vertices[static_cast<std::size_t>(drop.owner)];
+        if (owner.collision == candidate.collision) {
+          continue;
+        }
+        const auto& source = mCandidates[drop.source];
+        drops << std::format("{},{},{},{},{},{},{:.1f},{},{},{},{},{},{}\n", run.name, candidate.collision, mCollisions[static_cast<std::size_t>(candidate.collision)].findable, candidate.fit.zUM, drop.owner, owner.collision, owner.zUM, drop.source, source.collision, kStateNames[static_cast<std::size_t>(run.base[drop.source])], source.fit.zUM, drop.row, rowCollision(drop.row));
+      }
+    }
+  }
+
+  /// The vertexer's vertices into \a path, one CSV line each with its
+  /// majority collision (-1 a fake) and that collision's true z and frame,
+  /// for the cuts on the list (tools/vertexMakeup.py).
+  void writeStageVertices(const std::string& path) const
+  {
+    std::ofstream out(path);
+    if (!out) {
+      throw std::runtime_error(std::format("cannot write the vertex list {}", path));
+    }
+    const auto score = stageScore();
+    const auto made = makeup(score.vertices, score.claimedBy);
+    out << "frame,timePS,widthPS,zUM,contributors,collision,trueZUM,collisionFrame,findable,inner,strongest,trueShare,pairShare,noParticle,dense,own,"
+           "other,dcaUM,chi2RZ,radiusM,shared,reuseClaim,reuseWindow\n";
+    for (std::size_t v = 0; v < score.vertices.size(); ++v) {
+      const auto& vertex = score.vertices[v];
+      const auto& seed = mStageVertices[v];
+      const auto* collision = vertex.collision < 0 ? nullptr : &mCollisions[static_cast<std::size_t>(vertex.collision)];
+      const auto& m = made[v];
+      out << std::format("{},{},{},{:.1f},{},{},{:.1f},{},{},{},{:d},{:.4f},{:.4f},{:.4f},{:.4f},{:.4f},{:.4f},{:.2f},{:.3f},{:.3f},{:.1f},{:.4f},{:.4f}\n", vertex.frame, seed.timePS, seed.widthPS, vertex.zUM, vertex.contributors, vertex.collision, collision == nullptr ? 0. : collision->z * 1.e4, collision == nullptr ? -1 : collision->frame, collision == nullptr ? 0U : collision->findable, collision == nullptr ? 0U : collision->inner, m.strongest, m.shares[0], m.shares[1], m.shares[2], m.shares[3], m.shares[4], m.shares[5], m.dcaUM, m.chi2RZ, m.radiusM, m.shared, m.reuseClaim, m.reuseWindow);
+    }
+  }
+
+ private:
+  using Triple = std::array<std::uint32_t, 3>;
+
+  struct Collision {
+    double z = 0.;                ///< the median of its measured primaries' production z [cm]
+    std::int64_t frame = -1;      ///< the frame most of its layer-1 primary measurements are in
+    std::uint32_t inner = 0U;     ///< primaries above the pass's pT floor on layers 0-2, the vertexing pass's
+    std::uint32_t primaries = 0U; ///< primaries with any measurement
+    /// Physical primaries findable as the tracking QA has them (`isFindable`:
+    /// a chain of four layers at its floor).
+    std::uint32_t findable = 0U;
+  };
+
+  /// A triplet as the vertexer's map measures it (`measureCandidate`)
+  /// without its cuts: kAccepted or kDegenerate, the r-z chi2, z at the beam
+  /// line [um], the circle's signed distance to the axis [cm], the weight in
+  /// a vertex's mean and the time box.
+  struct StageFit {
+    VertexCandidateStatus status = VertexCandidateStatus::kDegenerate;
+    Scalar chi2RZ = 0.F;
+    std::int64_t zUM = 0;
+    Scalar dcaCM = 0.F;
+    std::uint64_t weight = 0U;
+    TimeEstPS box;
+  };
+
+  struct Candidate {
+    Triple triple{};
+    std::int64_t frame = 0;
+    std::int64_t zUM = 0;
+    double z0 = 0.;
+    double sigmaZ0 = 0.;
+    std::int64_t collision = -1;     ///< index into mCollisions, -1 for background
+    bool trueTriplet = false;        ///< one particle on all three measurements
+    bool straddles = false;          ///< not all three measurements in one frame
+    std::uint8_t sector = 0U;        ///< the middle measurement's azimuth in sixteenths
+    std::uint32_t sharedFirst = 1U;  ///< triplets with this one's first tracklet, itself included
+    std::uint32_t sharedSecond = 1U; ///< the same for its second tracklet
+    std::uint64_t particle = 0U;     ///< the particle on all three, 0 for none
+    double chi2RZ = 0.;              ///< the straight line's chi2 in r-z on the points' z errors (1 dof)
+    double dcaXY = 0.;               ///< the circle through the three points: its distance of closest approach to the beam axis [cm]
+    double radius = 0.;              ///< and its radius [cm], infinite for a straight line: the transverse momentum's order
+    StageFit fit{};                  ///< the vertexer's measure of it, for the replay
+  };
+
+  void buildCollisions()
+  {
+    // Per particle: the layers its measurements are on, and its layer-1 frames.
+    std::unordered_map<std::uint64_t, std::uint64_t> layers;
+    std::unordered_map<std::uint64_t, std::map<std::uint32_t, std::uint32_t>> frames; // by box start
+    const auto columns = mFrame->measurements();
+    for (std::size_t row = 0; row < mRows.size(); ++row) {
+      const auto& truth = mRows[row];
+      for (std::size_t i = 0; i < truth.count; ++i) {
+        layers[truth.particles[i]] |= std::uint64_t{1} << truth.layer;
+        if (truth.layer == 1U) {
+          ++frames[truth.particles[i]][columns.timePS[row]];
+        }
+      }
+    }
+    std::unordered_map<std::uint64_t, std::map<std::uint32_t, std::uint32_t>> collisionFrames;
+    // The collision's z: the median of its measured primaries' production z.
+    // The generator's primaries include the daughters of the decays it made,
+    // some of them displaced, so no single primary will do.
+    std::vector<std::vector<double>> productionZ;
+    // Every generator primary's collision, measured or not (`VertexQA.h`'s
+    // index takes those with a measured primary).
+    for (const auto& [particle, info] : *mParticles) {
+      if (!info.primary) {
+        continue;
+      }
+      const auto key = collisionOf(particle);
+      auto [at, inserted] = mCollisionIndex.try_emplace(key, mCollisions.size());
+      if (inserted) {
+        mCollisions.emplace_back();
+        productionZ.emplace_back();
+      }
+      auto& collision = mCollisions[at->second];
+      const auto found = layers.find(particle);
+      if (found == layers.end()) {
+        continue;
+      }
+      ++collision.primaries;
+      productionZ[at->second].push_back(static_cast<double>(info.vz));
+      const auto mask = found->second;
+      if (static_cast<double>(info.pt) >= mPassMinPtGeV && (mask & 7U) == 7U) {
+        ++collision.inner;
+      }
+      if (const auto f = frames.find(particle); f != frames.end()) {
+        for (const auto& [time, count] : f->second) {
+          collisionFrames[key][time] += count;
+        }
+      }
+    }
+    for (std::size_t c = 0; c < mCollisions.size(); ++c) {
+      auto& zs = productionZ[c];
+      if (!zs.empty()) {
+        mCollisions[c].z = study::median(zs);
+      }
+    }
+    for (const auto& [key, histogram] : collisionFrames) {
+      const auto best = std::ranges::max_element(histogram, {}, [](const auto& entry) { return entry.second; });
+      mCollisions[mCollisionIndex[key]].frame = frameIndex(best->first);
+    }
+    for (const auto& [particle, chain] : study::particleLayers(mRows, mComparison)) {
+      const auto info = mParticles->find(particle);
+      if (info == mParticles->end() || info->second.origin != study::ParticleOrigin::kPhysicalPrimary || !study::isFindable(info->second.pt, chain, mComparison)) {
+        continue;
+      }
+      if (const auto at = mCollisionIndex.find(collisionOf(particle)); at != mCollisionIndex.end()) {
+        ++mCollisions[at->second].findable;
+      }
+    }
+  }
+
+  std::int64_t frameIndex(std::uint32_t timePS)
+  {
+    const auto [at, inserted] = mFrameIndex.try_emplace(timePS, static_cast<std::int64_t>(mFrameIndex.size()));
+    return at->second;
+  }
+
+  void buildCandidates()
+  {
+    mCandidates.clear();
+    const auto columns = mFrame->measurements();
+    std::map<std::pair<std::uint32_t, std::uint32_t>, std::uint32_t> firstShared;
+    std::map<std::pair<std::uint32_t, std::uint32_t>, std::uint32_t> secondShared;
+    for (const auto& [triple, fit] : mStageFits) {
+      ++firstShared[{triple[0], triple[1]}];
+      ++secondShared[{triple[1], triple[2]}];
+    }
+    for (const auto& [triple, fit] : mStageFits) {
+      // The weighted straight line z = z0 + slope r.
+      double sw = 0.;
+      double swr = 0.;
+      double swr2 = 0.;
+      double swz = 0.;
+      double swrz = 0.;
+      for (const auto row : triple) {
+        const double w = 1. / std::max(static_cast<double>(columns.varZ[row]), 1.e-12);
+        const double r = columns.r[row];
+        const double z = columns.z[row];
+        sw += w;
+        swr += w * r;
+        swr2 += w * r * r;
+        swz += w * z;
+        swrz += w * r * z;
+      }
+      const double det = (sw * swr2) - (swr * swr);
+      const double z0 = ((swr2 * swz) - (swr * swrz)) / det;
+      const double slope = ((sw * swrz) - (swr * swz)) / det;
+      double chi2 = 0.;
+      for (const auto row : triple) {
+        const double residual = static_cast<double>(columns.z[row]) - z0 - (slope * static_cast<double>(columns.r[row]));
+        chi2 += residual * residual / std::max(static_cast<double>(columns.varZ[row]), 1.e-12);
+      }
+      // The circle through the three points in x-y, and its distance to the axis.
+      const double ax = columns.x[triple[0]];
+      const double ay = columns.y[triple[0]];
+      const double bx = columns.x[triple[1]];
+      const double by = columns.y[triple[1]];
+      const double cx = columns.x[triple[2]];
+      const double cy = columns.y[triple[2]];
+      const double d = 2. * ((ax * (by - cy)) + (bx * (cy - ay)) + (cx * (ay - by)));
+      double dca = 0.;
+      double radius = std::numeric_limits<double>::infinity();
+      if (std::abs(d) > 1.e-12) {
+        const double a2 = (ax * ax) + (ay * ay);
+        const double b2 = (bx * bx) + (by * by);
+        const double c2 = (cx * cx) + (cy * cy);
+        const double ux = ((a2 * (by - cy)) + (b2 * (cy - ay)) + (c2 * (ay - by))) / d;
+        const double uy = ((a2 * (cx - bx)) + (b2 * (ax - cx)) + (c2 * (bx - ax))) / d;
+        dca = std::abs(std::hypot(ux, uy) - std::hypot(ax - ux, ay - uy));
+        radius = std::hypot(ax - ux, ay - uy);
+      } else {
+        dca = std::abs((ax * cy) - (ay * cx)) / std::hypot(cx - ax, cy - ay);
+      }
+      const auto frame = frameIndex(columns.timePS[triple[1]]);
+      Candidate candidate{
+        .frame = frame,
+        .zUM = std::llround(z0 * 1.e4),
+        .z0 = z0,
+        .sigmaZ0 = std::sqrt(swr2 / det),
+        .straddles = frameIndex(columns.timePS[triple[0]]) != frame || frameIndex(columns.timePS[triple[2]]) != frame,
+      };
+      candidate.chi2RZ = chi2;
+      candidate.dcaXY = dca;
+      candidate.radius = radius;
+      candidate.sharedFirst = firstShared.at({triple[0], triple[1]});
+      candidate.sharedSecond = secondShared.at({triple[1], triple[2]});
+      candidate.sector = static_cast<std::uint8_t>(std::min(15., std::floor(static_cast<double>(columns.phi[triple[1]]) * 16. / (2. * std::numbers::pi))));
+      if (const auto particle = commonParticle(mRows, triple)) {
+        candidate.trueTriplet = true;
+        candidate.particle = *particle;
+        const auto info = mParticles->find(*particle);
+        if (info != mParticles->end() && info->second.primary) {
+          candidate.collision = static_cast<std::int64_t>(mCollisionIndex.at(collisionOf(*particle)));
+        }
+      }
+      candidate.triple = triple;
+      candidate.fit = fit;
+      mCandidates.push_back(candidate);
+    }
+    std::ranges::sort(mCandidates, {}, [](const Candidate& c) { return std::pair{c.frame, c.zUM}; });
+    // Every frame is indexed by now: their times by index, and the
+    // candidates by their triple, for the replay.
+    mFrameTimes.assign(mFrameIndex.size(), 0U);
+    for (const auto& [time, frame] : mFrameIndex) {
+      mFrameTimes[static_cast<std::size_t>(frame)] = time;
+    }
+    mByTriple.resize(mCandidates.size());
+    for (std::size_t i = 0; i < mByTriple.size(); ++i) {
+      mByTriple[i] = i;
+    }
+    std::ranges::sort(mByTriple, {}, [&](std::size_t i) { return mCandidates[i].triple; });
+  }
+
+  /// The candidate on \a triple (`mByTriple`).
+  [[nodiscard]] std::size_t candidateOf(const Triple& triple) const
+  {
+    return *std::ranges::lower_bound(mByTriple, triple, {}, [&](std::size_t i) { return mCandidates[i].triple; });
+  }
+
+  /// The collision of \a row's first label: -2 for no particle, -1 for one
+  /// whose collision is not in the index.
+  [[nodiscard]] std::int64_t rowCollision(std::uint32_t row) const
+  {
+    const auto& truth = mRows[row];
+    if (truth.count == 0U) {
+      return -2;
+    }
+    const auto at = mCollisionIndex.find(collisionOf(truth.particles[0]));
+    return at == mCollisionIndex.end() ? -1 : static_cast<std::int64_t>(at->second);
+  }
+
+  /// The element at quantile \a q of \a sorted, the one at min(n - 1, q n):
+  /// every quantile the study prints. \a sorted must not be empty.
+  [[nodiscard]] static double quantileAt(const std::vector<double>& sorted, double q) { return sorted[std::min(sorted.size() - 1U, static_cast<std::size_t>(q * static_cast<double>(sorted.size())))]; }
+
+  /// 68/95/99 % and the largest of \a values times \a scale, "n/a" for none.
+  static std::string quantiles(std::vector<double> values, double scale)
+  {
+    if (values.empty()) {
+      return "n/a";
+    }
+    std::ranges::sort(values);
+    return std::format("{:.0f} {:.0f} {:.0f} {:.0f}", quantileAt(values, 0.68) * scale, quantileAt(values, 0.95) * scale, quantileAt(values, 0.99) * scale, values.back() * scale);
+  }
+
+  void describeCandidates(std::vector<std::string>& lines) const
+  {
+    std::size_t primary = 0;
+    std::size_t secondary = 0;
+    std::size_t straddling = 0;
+    std::size_t primaryStraddling = 0;
+    std::vector<double> residuals;
+    std::vector<double> pulls;
+    for (const auto& c : mCandidates) {
+      straddling += c.straddles ? 1U : 0U;
+      if (c.collision >= 0) {
+        ++primary;
+        primaryStraddling += c.straddles ? 1U : 0U;
+        const double dz = c.z0 - mCollisions[static_cast<std::size_t>(c.collision)].z;
+        residuals.push_back(std::abs(dz));
+        pulls.push_back(std::abs(dz) / c.sigmaZ0);
+      } else if (c.trueTriplet) {
+        ++secondary;
+      }
+    }
+    const auto n = static_cast<double>(std::max<std::size_t>(mCandidates.size(), 1U));
+    lines.push_back(std::format("candidates {}: primary {} ({:.1f} %), secondary {} ({:.1f} %), fake {} ({:.1f} %); straddling frames {} ({} primary)", mCandidates.size(), primary, 100. * static_cast<double>(primary) / n, secondary, 100. * static_cast<double>(secondary) / n, mCandidates.size() - primary - secondary, 100. * static_cast<double>(mCandidates.size() - primary - secondary) / n, straddling, primaryStraddling));
+    lines.push_back(std::format("primary candidates' |z0 - z_true| 68/95/99/max [um]: {}; |pull| on the points' errors: {}", quantiles(residuals, 1.e4), quantiles(pulls, 1.)));
+    {
+      std::vector<double> chi2Primary;
+      std::vector<double> chi2Fake;
+      std::vector<double> dcaPrimary;
+      std::vector<double> dcaFake;
+      for (const auto& c : mCandidates) {
+        if (c.collision >= 0) {
+          chi2Primary.push_back(c.chi2RZ);
+          dcaPrimary.push_back(c.dcaXY);
+        } else if (!c.trueTriplet) {
+          chi2Fake.push_back(c.chi2RZ);
+          dcaFake.push_back(c.dcaXY);
+        }
+      }
+      const auto spread = [](std::vector<double> values, double scale) {
+        if (values.empty()) {
+          return std::string{"n/a"};
+        }
+        std::ranges::sort(values);
+        const auto at = [&](double q) { return quantileAt(values, q) * scale; };
+        return std::format("10% {:.3g} 50% {:.3g} 90% {:.3g} 99% {:.3g}", at(0.1), at(0.5), at(0.9), at(0.99));
+      };
+      lines.push_back(std::format("r-z chi2: primary {} | fake {}", spread(chi2Primary, 1.), spread(chi2Fake, 1.)));
+      lines.push_back(std::format("dca xy [um]: primary {} | fake {}", spread(dcaPrimary, 1.e4), spread(dcaFake, 1.e4)));
+    }
+    std::size_t frames = 0;
+    std::size_t busiest = 0;
+    for (std::size_t begin = 0; begin < mCandidates.size();) {
+      auto end = begin;
+      while (end < mCandidates.size() && mCandidates[end].frame == mCandidates[begin].frame) {
+        ++end;
+      }
+      ++frames;
+      busiest = std::max(busiest, end - begin);
+      begin = end;
+    }
+    std::uint32_t withInner = 0;
+    std::uint32_t findable = 0;
+    std::uint32_t findableWithoutInner = 0;
+    std::map<std::int64_t, std::uint32_t> perFrame; // NOLINT(misc-const-correctness): written in a dependent call the check does not see
+    for (const auto& collision : mCollisions) {
+      withInner += collision.inner > 0U ? 1U : 0U;
+      findable += collision.findable;
+      findableWithoutInner += collision.inner == 0U ? collision.findable : 0U;
+      if (collision.primaries > 0U) {
+        ++perFrame[collision.frame];
+      }
+    }
+    std::array<std::uint32_t, 5> sharing{};
+    for (const auto& [frame, count] : perFrame) {
+      ++sharing[std::min<std::size_t>(count, sharing.size() - 1U)];
+    }
+    lines.push_back(
+      std::format("frames with candidates {}, the busiest {} candidates; collisions {} ({} with an inner primary above {:.2f} GeV), "
+                  "findable primaries {} ({} in collisions without one); frames by collisions 1/2/3/4+: {} {} {} {}",
+                  frames, busiest, mCollisions.size(), withInner, mPassMinPtGeV, findable, findableWithoutInner, sharing[1], sharing[2], sharing[3], sharing[4]));
+  }
+
+  /// Each triplet's two tests in units of its own error, at
+  /// its own momentum -- pT from the circle's radius (|B2C Bz| R), 1/(beta p)^2
+  /// for the pion hypothesis of the pass (the triplet's own beta, not the
+  /// floor's), none for a straight line.
+  /// The transverse one: the circle's signed distance to the axis over the
+  /// variance its own Jacobian gives -- by finite differences, the points'
+  /// r-phi errors, and each barrel scatterer inside the third point (the
+  /// layers and the passives the line crosses) as an azimuthal kick that
+  /// moves the points beyond it by kick (r_i - r_s) across the track -- and
+  /// the beam's transverse spread.
+  /// The r-z one: the dip angle's kink at the middle point over the points'
+  /// z errors, each chord with its own derivative, and the kink's scattering
+  /// (`tripletScattering`: the middle point's layer and the passives
+  /// between) rescaled from the floor's 1/(beta p)^2 to the triplet's.
+  struct TripletPulls {
+    double dca = 0.;
+    double rz = 0.;
+    double ptGeV = 0.; ///< from the radius, infinite for a straight line
+  };
+
+  /// The signed distance of the circle through three transverse points to
+  /// the axis [cm], as the vertexer's map has it; a line's for collinear ones.
+  static double circleDca(double ax, double ay, double bx, double by, double cx, double cy)
+  {
+    const double ux0 = ax - bx;
+    const double uy0 = ay - by;
+    const double vx0 = cx - bx;
+    const double vy0 = cy - by;
+    const double twiceArea = 2. * ((ux0 * vy0) - (uy0 * vx0));
+    if (std::abs(twiceArea) > 1.e-18) {
+      const double a2 = (ux0 * ux0) + (uy0 * uy0);
+      const double c2 = (vx0 * vx0) + (vy0 * vy0);
+      const double ux = ((vy0 * a2) - (uy0 * c2)) / twiceArea;
+      const double uy = ((ux0 * c2) - (vx0 * a2)) / twiceArea;
+      const double radius = std::hypot(ux, uy);
+      const double centre = std::hypot(bx + ux, by + uy);
+      const double power = (bx * bx) + (by * by) + (2. * ((bx * ux) + (by * uy)));
+      return power / (centre + radius);
+    }
+    const double dx = cx - ax;
+    const double dy = cy - ay;
+    return ((ax * cy) - (ay * cx)) / std::hypot(dx, dy);
+  }
+
+  [[nodiscard]] TripletPulls tripletPulls(const Candidate& c) const
+  {
+    if (!mPass) {
+      throw std::logic_error("VertexStudy: triplet pulls before a pass was observed");
+    }
+    const auto columns = mFrame->measurements();
+    const auto a = pairPointAt(columns, c.triple[0]);
+    const auto b = pairPointAt(columns, c.triple[1]);
+    const auto d = pairPointAt(columns, c.triple[2]);
+    const auto& table = mPass->scattering;
+    const auto& cut = mPass->pairCut;
+    TripletPulls out;
+    const bool curved = std::isfinite(c.radius) && c.radius > 0.;
+    out.ptGeV = curved ? static_cast<double>(cut.momentumCurvature) * c.radius : std::numeric_limits<double>::infinity();
+    const double slope = static_cast<double>(d.z - a.z) / static_cast<double>(d.r - a.r);
+    const double g = std::sqrt(1. + (slope * slope));
+    const auto mass2 = static_cast<double>(cut.mass2);
+    // 1/(beta p)^2 at the triplet's pT, and the floor's, as the pair cut has it.
+    const double ownInvPt2 = curved ? (1. + (mass2 / (out.ptGeV * out.ptGeV))) / (out.ptGeV * out.ptGeV) : 0.;
+    const double scale = cut.invBetaMomentum2 > 0.F ? ownInvPt2 / static_cast<double>(cut.invBetaMomentum2) : 0.;
+    // Transverse.
+    const std::array<std::array<double, 2>, 3> points{{{a.x, a.y}, {b.x, b.y}, {d.x, d.y}}};
+    const std::array<double, 3> radii{a.r, b.r, d.r};
+    const auto dcaOf = [&](const std::array<std::array<double, 2>, 3>& p) { return circleDca(p[0][0], p[0][1], p[1][0], p[1][1], p[2][0], p[2][1]); };
+    const double dca0 = dcaOf(points);
+    constexpr double kStep = 1.e-5; // [cm]
+    double varPoints = 0.;
+    const std::array<double, 3> varRPhi{a.varRPhi, b.varRPhi, d.varRPhi};
+    for (std::size_t i = 0; i < 3U; ++i) {
+      auto moved = points;
+      moved[i][0] += -kStep * points[i][1] / radii[i];
+      moved[i][1] += kStep * points[i][0] / radii[i];
+      const double derivative = (dcaOf(moved) - dca0) / kStep;
+      varPoints += derivative * derivative * varRPhi[i];
+    }
+    // Across the track: perpendicular to the chord from the first point to the third.
+    const double chordX = points[2][0] - points[0][0];
+    const double chordY = points[2][1] - points[0][1];
+    const double chord = std::hypot(chordX, chordY);
+    const double nx = -chordY / chord;
+    const double ny = chordX / chord;
+    double varScattering = 0.;
+    const auto kick = [&](double rs, double k) {
+      if (!(rs < radii[2]) || !(k > 0.)) {
+        return;
+      }
+      auto moved = points;
+      for (std::size_t i = 0; i < 3U; ++i) {
+        if (radii[i] > rs) {
+          moved[i][0] += kStep * (radii[i] - rs) * nx;
+          moved[i][1] += kStep * (radii[i] - rs) * ny;
+        }
+      }
+      const double derivative = (dcaOf(moved) - dca0) / kStep;
+      // theta0^2 = k g / (beta p)^2 at p = pT g; the azimuthal kick theta0 g.
+      const double theta2 = k * g * (1. + (mass2 / (out.ptGeV * out.ptGeV * g * g))) / (out.ptGeV * out.ptGeV * g * g);
+      varScattering += derivative * derivative * theta2 * g * g;
+    };
+    if (curved) {
+      const double z0 = c.z0;
+      const auto crosses = [&](const ScatteringLayer& layer) {
+        const double zAt = z0 + (slope * static_cast<double>(layer.position));
+        return zAt >= static_cast<double>(layer.low) && zAt <= static_cast<double>(layer.high);
+      };
+      for (std::size_t layer = 0; layer < ScatteringTable<Det>::kLayerCount; ++layer) {
+        if (Detector<Det>::isBarrelLayer(static_cast<LayerID>(layer)) && crosses(table.layers[layer])) {
+          kick(static_cast<double>(table.layers[layer].position), static_cast<double>(table.layers[layer].k));
+        }
+      }
+      if constexpr (ScatteringTable<Det>::kPassiveCount > 0) {
+        for (std::size_t i = 0; i < ScatteringTable<Det>::kPassiveCount; ++i) {
+          const auto& passive = table.passives[i];
+          if (passive.barrel && crosses(passive.at)) {
+            kick(static_cast<double>(passive.at.position), static_cast<double>(passive.at.k));
+          }
+        }
+      }
+    }
+    out.dca = static_cast<double>(c.fit.dcaCM) / std::sqrt(varPoints + varScattering + static_cast<double>(mBeamVarTransverse));
+    // r-z: the kink of the dip angle at the middle point, each chord with its own derivative.
+    const auto d1 = static_cast<double>(b.r - a.r);
+    const auto d2 = static_cast<double>(d.r - b.r);
+    const double t1 = static_cast<double>(b.z - a.z) / d1;
+    const double t2 = static_cast<double>(d.z - b.z) / d2;
+    const double a1 = 1. / (1. + (t1 * t1));
+    const double a2 = 1. / (1. + (t2 * t2));
+    const double varKink = (a1 * a1 * static_cast<double>(a.varZ) / (d1 * d1)) + ((a1 / d1) + (a2 / d2)) * ((a1 / d1) + (a2 / d2)) * static_cast<double>(b.varZ) + (a2 * a2 * static_cast<double>(d.varZ) / (d2 * d2));
+    const double varKinkScattering = static_cast<double>(tripletScattering<Det>(table, cut, mRows[c.triple[1]].layer, a, b, d)) * scale;
+    out.rz = (std::atan(t2) - std::atan(t1)) / std::sqrt(varKink + varKinkScattering);
+    return out;
+  }
+
+  /// The pulls of the true primary triplets by their true pT and |eta|, the
+  /// true secondaries' and the combinatorial ones' (|pull| at 50/68/95/99 %,
+  /// the transverse one's mean), the radius's pT against the truth, and how
+  /// many of each class cuts in sigmas keep against the absolute cuts.
+  void describePulls(std::vector<std::string>& lines) const
+  {
+    if (!mPass) {
+      return; // no slice of the iteration
+    }
+    struct Class {
+      std::string name;
+      std::vector<double> dca;
+      std::vector<double> rz;
+      std::vector<double> ptRatio;
+      double dcaSum = 0.;
+      std::array<std::uint64_t, 5> both{}, onlyDca{}, onlyRz{};
+      std::uint64_t absolute = 0U;
+      std::uint64_t absoluteChi2 = 0U;
+      std::uint64_t absoluteDca = 0U;
+    };
+    constexpr std::array<double, 5> kSigmas{2., 3., 4., 5., 6.};
+    constexpr std::array<double, 6> kPtEdges{0., 0.3, 0.5, 1., 2., 1.e30};
+    std::vector<Class> classes;
+    for (std::size_t bin = 0; bin + 1U < kPtEdges.size(); ++bin) {
+      classes.push_back({
+        .name = bin + 2U < kPtEdges.size() ? std::format("true primary, pT {}-{} GeV", kPtEdges[bin], kPtEdges[bin + 1U]) : std::format("true primary, pT > {} GeV", kPtEdges[bin]),
+      });
+    }
+    classes.push_back({.name = "true primary, |eta| < 1"});
+    classes.push_back({.name = "true primary, |eta| > 1"});
+    classes.push_back({.name = "true primary, all"});
+    classes.push_back({.name = "true secondary"});
+    classes.push_back({.name = "combinatorial"});
+    const auto& settings = mStage.settings();
+    for (const auto& c : mCandidates) {
+      if (c.fit.status != VertexCandidateStatus::kAccepted) {
+        continue;
+      }
+      const auto pulls = tripletPulls(c);
+      std::vector<std::size_t> into;
+      double ptTrue = 0.;
+      if (c.trueTriplet && c.collision >= 0) {
+        const auto& info = mParticles->at(c.particle);
+        ptTrue = static_cast<double>(info.pt);
+        std::size_t bin = 0;
+        while (bin + 2U < kPtEdges.size() && ptTrue >= kPtEdges[bin + 1U]) {
+          ++bin;
+        }
+        into = {bin, std::abs(info.eta) < 1.F ? kPtEdges.size() - 1U : kPtEdges.size(), kPtEdges.size() + 1U};
+      } else {
+        into = {c.trueTriplet ? kPtEdges.size() + 2U : kPtEdges.size() + 3U};
+      }
+      const bool chi2In = !(settings.maxChi2RZ > 0.F && c.fit.chi2RZ > settings.maxChi2RZ);
+      const bool dcaAbsolute = !(settings.maxDcaCM > 0.F && std::abs(c.fit.dcaCM) > settings.maxDcaCM);
+      const bool absolute = chi2In && dcaAbsolute;
+      for (const auto k : into) {
+        auto& out = classes[k];
+        out.dca.push_back(std::abs(pulls.dca));
+        out.rz.push_back(std::abs(pulls.rz));
+        out.dcaSum += pulls.dca;
+        if (ptTrue > 0.) {
+          out.ptRatio.push_back(pulls.ptGeV / ptTrue);
+        }
+        out.absolute += absolute ? 1U : 0U;
+        out.absoluteChi2 += chi2In ? 1U : 0U;
+        out.absoluteDca += dcaAbsolute ? 1U : 0U;
+        for (std::size_t s = 0; s < kSigmas.size(); ++s) {
+          const bool dcaIn = std::abs(pulls.dca) < kSigmas[s];
+          const bool rzIn = std::abs(pulls.rz) < kSigmas[s];
+          out.both[s] += dcaIn && rzIn ? 1U : 0U;
+          out.onlyDca[s] += dcaIn ? 1U : 0U;
+          out.onlyRz[s] += rzIn ? 1U : 0U;
+        }
+      }
+    }
+    for (auto& out : classes) {
+      std::ranges::sort(out.dca);
+      std::ranges::sort(out.rz);
+      std::ranges::sort(out.ptRatio);
+    }
+    const auto at = [](const std::vector<double>& sorted, double q) { return sorted.empty() ? std::numeric_limits<double>::quiet_NaN() : quantileAt(sorted, q); };
+    lines.push_back(
+      std::format("triplet pulls: the triplets past the pass's cuts; |pull| 50/68/95/99 %, transverse and r-z; the transverse "
+                  "pull's mean; the radius's pT over the true one 16/50/84 %; kept by both pulls < 2/3/4/5/6 sigma; by the absolute cuts "
+                  "(chi2 {}, dca {} um)",
+                  settings.maxChi2RZ, settings.maxDcaCM * 1.e4F));
+    for (auto& out : classes) {
+      const auto n = out.dca.size();
+      if (n == 0U) {
+        continue;
+      }
+      const auto share = [&](std::uint64_t kept) { return std::format("{:.3f}", static_cast<double>(kept) / static_cast<double>(n)); };
+      std::string kept;
+      for (std::size_t s = 0; s < kSigmas.size(); ++s) {
+        kept += std::format(" {}", share(out.both[s]));
+      }
+      std::string dcaOnly;
+      std::string rzOnly;
+      for (std::size_t s = 0; s < kSigmas.size(); ++s) {
+        dcaOnly += std::format(" {}", share(out.onlyDca[s]));
+        rzOnly += std::format(" {}", share(out.onlyRz[s]));
+      }
+      const double mean = out.dcaSum / static_cast<double>(n);
+      lines.push_back(
+        std::format("  {}: {} | dca {:.2f} {:.2f} {:.2f} {:.2f} mean {:+.2f} | rz {:.2f} {:.2f} {:.2f} {:.2f} | pT ratio {:.2f} {:.2f} {:.2f} | "
+                    "kept both{} | dca only{} | rz only{} | absolute {} (chi2 {}, dca {})",
+                    out.name, n, at(out.dca, 0.5), at(out.dca, 0.68), at(out.dca, 0.95), at(out.dca, 0.99), mean, at(out.rz, 0.5), at(out.rz, 0.68), at(out.rz, 0.95), at(out.rz, 0.99), at(out.ptRatio, 0.16), at(out.ptRatio, 0.5), at(out.ptRatio, 0.84), kept, dcaOnly, rzOnly, share(out.absolute), share(out.absoluteChi2), share(out.absoluteDca)));
+    }
+  }
+
+  struct Vertex {
+    std::int64_t frame = 0;
+    double zUM = 0.;
+    std::uint32_t contributors = 0U;
+    std::int64_t collision = -1; ///< the majority; -1 background
+  };
+
+  struct Score {
+    std::vector<Vertex> vertices;
+    std::vector<std::int64_t> claimedBy; ///< per candidate, its vertex, -1 free, -2 cut or not kept
+    std::vector<std::int64_t> best;      ///< per collision, its vertex with the most contributors, or -1
+    std::uint32_t fakes = 0U;
+    std::uint32_t splits = 0U;
+    std::uint32_t merged = 0U;
+  };
+
+  /// The vertexer's vertices and claims scored: each vertex's frame and
+  /// majority from the candidates it claimed.
+  [[nodiscard]] Score stageScore() const
+  {
+    std::vector<std::int64_t> claimedBy;
+    auto vertices = stageVertices(claimedBy);
+    return scoreClaims(std::move(vertices), std::move(claimedBy));
+  }
+
+  /// The vertexer's vertices as `stageScore` scores them, and which vertex
+  /// claimed each candidate.
+  std::vector<Vertex> stageVertices(std::vector<std::int64_t>& claimedBy) const
+  {
+    claimedBy.assign(mCandidates.size(), -2);
+    std::vector<Vertex> vertices(mStageVertices.size());
+    for (std::size_t i = 0; i < mCandidates.size(); ++i) {
+      const auto found = mStageClaims.find(mCandidates[i].triple);
+      claimedBy[i] = found == mStageClaims.end() ? -2 : found->second;
+      if (claimedBy[i] >= 0) {
+        auto& vertex = vertices[static_cast<std::size_t>(claimedBy[i])];
+        vertex.frame = mCandidates[i].frame;
+        ++vertex.contributors;
+      }
+    }
+    for (std::size_t v = 0; v < vertices.size(); ++v) {
+      vertices[v].zUM = static_cast<double>(mStageVertices[v].z) * 1.e4;
+    }
+    return vertices;
+  }
+
+  [[nodiscard]] Score scoreClaims(std::vector<Vertex> vertices, std::vector<std::int64_t> claimedBy) const
+  {
+    Score result;
+    result.vertices = std::move(vertices);
+    result.claimedBy = std::move(claimedBy);
+    std::vector<std::map<std::int64_t, std::uint32_t>> labels(result.vertices.size());
+    std::vector<std::map<std::int64_t, std::uint32_t>> wentTo(mCollisions.size());
+    std::vector<std::uint32_t> contributors;
+    contributors.reserve(result.vertices.size());
+    for (const auto& vertex : result.vertices) {
+      contributors.push_back(vertex.contributors);
+    }
+    for (std::size_t i = 0; i < mCandidates.size(); ++i) {
+      const auto collision = mCandidates[i].collision;
+      const auto vertex = result.claimedBy[i];
+      if (vertex >= 0) {
+        ++labels[static_cast<std::size_t>(vertex)][collision];
+      }
+      if (collision >= 0) {
+        ++wentTo[static_cast<std::size_t>(collision)][vertex];
+      }
+    }
+    auto assigned = scoreVertexClaims(labels, contributors, wentTo);
+    for (std::size_t v = 0; v < result.vertices.size(); ++v) {
+      result.vertices[v].collision = assigned.collision[v];
+    }
+    result.best = std::move(assigned.best);
+    result.fakes = assigned.fakes;
+    result.splits = assigned.splits;
+    result.merged = assigned.merged;
+    return result;
+  }
+
+  /// \a result as one row at \a settings: the settings; the vertices, the
+  /// collisions found, the efficiency for those with an inner primary, the
+  /// findable primaries covered; fakes, splits, merged; the most vertices in
+  /// one frame, in three consecutive frames with candidates, frames over 8;
+  /// the found vertices' |dz| 68/95/99 % and largest [um]; the median
+  /// contributors.
+  [[nodiscard]] std::string describe(const Score& result, const Settings& settings) const
+  {
+    std::uint32_t found = 0U;
+    std::uint32_t withInner = 0U;
+    std::uint32_t foundWithInner = 0U;
+    std::uint64_t covered = 0U;
+    std::uint64_t findable = 0U;
+    std::vector<double> residuals;
+    std::vector<double> contributors;
+    for (std::size_t c = 0; c < mCollisions.size(); ++c) {
+      const auto& collision = mCollisions[c];
+      findable += collision.findable;
+      withInner += collision.inner > 0U ? 1U : 0U;
+      if (result.best[c] < 0) {
+        continue;
+      }
+      const auto& vertex = result.vertices[static_cast<std::size_t>(result.best[c])];
+      ++found;
+      foundWithInner += collision.inner > 0U ? 1U : 0U;
+      covered += collision.findable;
+      residuals.push_back(std::abs(vertex.zUM - (collision.z * 1.e4)));
+      contributors.push_back(vertex.contributors);
+    }
+    std::ranges::sort(contributors);
+    // Vertices per frame, the frames in time order.
+    std::map<std::uint32_t, std::uint32_t> perFrame;
+    for (const auto& [time, frame] : mFrameIndex) {
+      perFrame[time] = 0U;
+    }
+    for (const auto& vertex : result.vertices) {
+      ++perFrame[mFrameTimes[static_cast<std::size_t>(vertex.frame)]];
+    }
+    std::vector<std::uint32_t> counts;
+    for (const auto& [time, count] : perFrame) {
+      if (count > 0U) {
+        counts.push_back(count);
+      }
+    }
+    std::uint32_t most = 0U;
+    std::uint32_t mostThree = 0U;
+    std::uint32_t over = 0U;
+    for (std::size_t f = 0; f < counts.size(); ++f) {
+      most = std::max(most, counts[f]);
+      over += counts[f] > 8U ? 1U : 0U;
+      mostThree = std::max(mostThree, counts[f] + (f > 0U ? counts[f - 1U] : 0U) + (f + 1U < counts.size() ? counts[f + 1U] : 0U));
+    }
+    return std::format("{:4.0f} {:4.0f} {:5d} {:5d} {:4d} {:2.0f} | {:8d} {:6d}/{:<5d} {:6.1f} % {:8d}/{:<8d} | {:5d} {:6d} {:6d} | {:4d} {:4d} {:4d} | {:>24} | {:.0f}", settings.maxChi2RZ, settings.maxDcaUM, settings.windowUM, settings.claimUM, settings.minContributors, settings.significance, result.vertices.size(), found, mCollisions.size(), 100. * static_cast<double>(foundWithInner) / std::max(1., static_cast<double>(withInner)), covered, findable, result.fakes, result.splits, result.merged, most, mostThree, over, quantiles(residuals, 1.), contributors.empty() ? 0. : contributors[contributors.size() / 2U]);
+  }
+
+  /// The efficiency table, its lines, and the diagnostics of the fakes and
+  /// the missed collisions.
+  struct Efficiency {
+    std::string table;
+    std::vector<std::string> diagnostics;
+  };
+
+  /// Each frame's strongest of \a vertices: the first of the most
+  /// contributors.
+  [[nodiscard]] static std::map<std::int64_t, std::size_t> strongestByFrame(const std::vector<Vertex>& vertices)
+  {
+    std::map<std::int64_t, std::size_t> strongest;
+    for (std::size_t v = 0; v < vertices.size(); ++v) {
+      const auto [at, inserted] = strongest.try_emplace(vertices[v].frame, v);
+      if (!inserted && vertices[at->second].contributors < vertices[v].contributors) {
+        at->second = v;
+      }
+    }
+    return strongest;
+  }
+
+  /// \a result's efficiency by the collisions' inner primaries and by their
+  /// findable ones at \a settings, \a who naming whose list it is, and the
+  /// diagnostics of its fakes and missed collisions.
+  [[nodiscard]] Efficiency efficiencyByMultiplicity(const Settings& settings, const Score& result, std::string_view who) const
+  {
+    Efficiency out;
+    constexpr std::array<std::uint32_t, 8> kEdges{0U, 1U, 3U, 5U, 10U, 20U, 50U, 100U};
+    std::array<std::uint32_t, kEdges.size()> all{};
+    std::array<std::uint32_t, kEdges.size()> found{};
+    std::array<std::uint64_t, kEdges.size()> findable{};
+    std::array<std::uint64_t, kEdges.size()> covered{};
+    for (std::size_t c = 0; c < mCollisions.size(); ++c) {
+      const auto& collision = mCollisions[c];
+      std::size_t bin = 0;
+      while (bin + 1U < kEdges.size() && collision.inner >= kEdges[bin + 1U]) {
+        ++bin;
+      }
+      ++all[bin];
+      findable[bin] += collision.findable;
+      if (result.best[c] >= 0) {
+        ++found[bin];
+        covered[bin] += collision.findable;
+      }
+    }
+    {
+      // Where the fakes are: their contributors and their distance to their
+      // frame's strongest vertex; the same for the real vertices that are not
+      // their frame's strongest (pile-up).
+      const auto strongest = strongestByFrame(result.vertices);
+      std::vector<double> fakeContributors;
+      std::vector<double> fakeDistance;
+      std::vector<double> fakeRatio;
+      std::vector<double> pileContributors;
+      std::vector<double> pileDistance;
+      std::vector<double> pileRatio;
+      for (std::size_t v = 0; v < result.vertices.size(); ++v) {
+        const auto& vertex = result.vertices[v];
+        const auto& top = result.vertices[strongest.at(vertex.frame)];
+        if (strongest.at(vertex.frame) == v) {
+          continue;
+        }
+        const double distance = std::abs(vertex.zUM - top.zUM);
+        const double ratio = static_cast<double>(vertex.contributors) / static_cast<double>(top.contributors);
+        if (vertex.collision < 0) {
+          fakeContributors.push_back(vertex.contributors);
+          fakeDistance.push_back(distance);
+          fakeRatio.push_back(ratio);
+        } else if (result.best[static_cast<std::size_t>(vertex.collision)] == static_cast<std::int64_t>(v)) {
+          pileContributors.push_back(vertex.contributors);
+          pileDistance.push_back(distance);
+          pileRatio.push_back(ratio);
+        }
+      }
+      const auto lowQuantiles = [](std::vector<double> values, double scale) {
+        if (values.empty()) {
+          return std::string{"n/a"};
+        }
+        std::ranges::sort(values);
+        const auto at = [&](double q) { return quantileAt(values, q) * scale; };
+        return std::format("min {:.3g} 5% {:.3g} 50% {:.3g} 95% {:.3g} max {:.3g}", values.front() * scale, at(0.05), at(0.5), at(0.95), values.back() * scale);
+      };
+      {
+        std::vector<std::uint16_t> sectors(result.vertices.size(), 0U);
+        std::vector<std::uint32_t> trueCount(result.vertices.size(), 0U);
+        std::vector<std::map<std::uint64_t, std::uint32_t>> byParticle(result.vertices.size());
+        for (std::size_t i = 0; i < mCandidates.size(); ++i) {
+          const auto v = result.claimedBy[i];
+          if (v < 0) {
+            continue;
+          }
+          const auto& c = mCandidates[i];
+          sectors[static_cast<std::size_t>(v)] |= static_cast<std::uint16_t>(1U << c.sector);
+          if (c.trueTriplet) {
+            ++trueCount[static_cast<std::size_t>(v)];
+            ++byParticle[static_cast<std::size_t>(v)][c.particle];
+          }
+        }
+        std::vector<double> fakeSectors;
+        std::vector<double> realSectors;
+        std::vector<double> fakeTrue;
+        std::vector<double> fakeTop;
+        std::vector<double> realTop;
+        for (std::size_t v = 0; v < result.vertices.size(); ++v) {
+          const auto& vertex = result.vertices[v];
+          const double n = vertex.contributors;
+          std::uint32_t top = 0U;
+          for (const auto& [particle, count] : byParticle[v]) {
+            top = std::max(top, count);
+          }
+          if (vertex.collision < 0) {
+            fakeSectors.push_back(std::popcount(sectors[v]));
+            fakeTrue.push_back(trueCount[v] / n);
+            fakeTop.push_back(top / n);
+          } else if (result.best[static_cast<std::size_t>(vertex.collision)] == static_cast<std::int64_t>(v)) {
+            realSectors.push_back(std::popcount(sectors[v]));
+            realTop.push_back(top / n);
+          }
+        }
+        out.diagnostics.push_back(std::format("  fakes: azimuth sectors of 16 hit {}; true-triplet share {}; one particle's share {}", lowQuantiles(fakeSectors, 1.), lowQuantiles(fakeTrue, 1.), lowQuantiles(fakeTop, 1.)));
+        out.diagnostics.push_back(std::format("  real: azimuth sectors of 16 hit {}; one particle's share {}", lowQuantiles(realSectors, 1.), lowQuantiles(realTop, 1.)));
+      }
+      out.diagnostics.push_back(std::format("  fakes not their frame's strongest ({}): contributors {}; |dz| to the strongest [mm] {}; contributors / strongest's {}", fakeContributors.size(), lowQuantiles(fakeContributors, 1.), lowQuantiles(fakeDistance, 1.e-3), lowQuantiles(fakeRatio, 1.)));
+      out.diagnostics.push_back(std::format("  real pile-up vertices ({}): contributors {}; |dz| to the strongest [mm] {}; contributors / strongest's {}", pileContributors.size(), lowQuantiles(pileContributors, 1.), lowQuantiles(pileDistance, 1.e-3), lowQuantiles(pileRatio, 1.)));
+    }
+    // The missed collisions with 20 inner primaries or more, and why.
+    for (std::size_t c = 0; c < mCollisions.size(); ++c) {
+      const auto& collision = mCollisions[c];
+      if (result.best[c] >= 0 || collision.inner < 20U) {
+        continue;
+      }
+      std::map<std::int64_t, std::uint32_t> claims; // NOLINT(misc-const-correctness): written in a dependent call the check does not see
+      std::uint32_t own = 0U;
+      for (std::size_t i = 0; i < mCandidates.size(); ++i) {
+        if (mCandidates[i].collision == static_cast<std::int64_t>(c)) {
+          ++own;
+          ++claims[result.claimedBy[i]];
+        }
+      }
+      std::string where;
+      for (const auto& [claim, count] : claims) {
+        where += claim >= 0 ? std::format(" vertex of collision {} at {:.4f} cm: {}", result.vertices[static_cast<std::size_t>(claim)].collision, result.vertices[static_cast<std::size_t>(claim)].zUM * 1.e-4, count) : std::format(" {}: {}", claim == -1 ? "free" : "cut", count);
+      }
+      out.diagnostics.push_back(std::format("  missed collision {}: z {:.4f} cm, inner {}, findable {}, candidates {};{}", c, collision.z, collision.inner, collision.findable, own, where));
+    }
+    std::string& line = out.table;
+    line = std::format("{}efficiency by inner primaries (chi2 {}, dca {} um, w {} um, claim {} um, minC {}, k {}): bin found/all (findable primaries covered/all):", who, settings.maxChi2RZ, settings.maxDcaUM, settings.windowUM, settings.claimUM, settings.minContributors, settings.significance);
+    for (std::size_t bin = 0; bin < kEdges.size(); ++bin) {
+      line += std::format(" [{}{}] {}/{} ({}/{})", kEdges[bin], bin + 1U < kEdges.size() ? std::format("-{}", kEdges[bin + 1U] - 1U) : std::string{"+"}, found[bin], all[bin], covered[bin], findable[bin]);
+    }
+    // The same by the collision's findable primaries, which do not depend on
+    // the pass's pT floor: passes at different floors compare bin by bin.
+    constexpr std::array<std::uint32_t, 10> kFindableEdges{0U, 10U, 20U, 50U, 100U, 200U, 500U, 1000U, 2500U, 5000U};
+    std::array<std::uint32_t, kFindableEdges.size()> allByFindable{};
+    std::array<std::uint32_t, kFindableEdges.size()> foundByFindable{};
+    for (std::size_t c = 0; c < mCollisions.size(); ++c) {
+      std::size_t bin = 0;
+      while (bin + 1U < kFindableEdges.size() && mCollisions[c].findable >= kFindableEdges[bin + 1U]) {
+        ++bin;
+      }
+      ++allByFindable[bin];
+      foundByFindable[bin] += result.best[c] >= 0 ? 1U : 0U;
+    }
+    line += std::format("\n{}efficiency by findable primaries: bin found/all:", who);
+    for (std::size_t bin = 0; bin < kFindableEdges.size(); ++bin) {
+      line += std::format(" [{}{}] {}/{}", kFindableEdges[bin], bin + 1U < kFindableEdges.size() ? std::format("-{}", kFindableEdges[bin + 1U] - 1U) : std::string{"+"}, foundByFindable[bin], allByFindable[bin]);
+    }
+    return out;
+  }
+
+  /// What a vertex is made of, over its claimed candidates:
+  /// whether it is its frame's strongest, the share of true triplets, of
+  /// triplets with two measurements of one particle, and of the measurements
+  /// by origin -- no particle (QED, noise), the frame's strongest vertex's
+  /// collision (dense; 0 for the strongest itself), the vertex's own, another
+  /// -- and the medians of the candidates' transverse dca [um], r-z chi2,
+  /// circle radius [m] and most shared tracklet.
+  struct Makeup {
+    bool strongest = false;
+    /// Of its candidates, the share with a measurement that a candidate past
+    /// the table's cuts within the frame's strongest vertex's claim (window)
+    /// of its z also has: what that vertex would own if it owned its
+    /// candidates' measurements; 0 for the strongest itself.
+    double reuseClaim = 0.;
+    double reuseWindow = 0.;
+    std::array<double, 6> shares{}; ///< true, pair, no particle, dense, own, other
+    double dcaUM = 0.;
+    double chi2RZ = 0.;
+    double radiusM = 0.;
+    double shared = 0.;
+  };
+
+  [[nodiscard]] std::vector<Makeup> makeup(const std::vector<Vertex>& vertices, const std::vector<std::int64_t>& claims) const
+  {
+    const auto strongest = strongestByFrame(vertices);
+    std::vector<std::vector<std::size_t>> claimed(vertices.size());
+    for (std::size_t i = 0; i < mCandidates.size(); ++i) {
+      if (claims[i] >= 0) {
+        claimed[static_cast<std::size_t>(claims[i])].push_back(i);
+      }
+    }
+    // Per frame, the measurements of the candidates past the table's cuts
+    // within the strongest vertex's claim and window.
+    const auto& cuts = mTable;
+    std::map<std::int64_t, std::pair<std::unordered_set<std::uint32_t>, std::unordered_set<std::uint32_t>>> owned;
+    for (const auto& [frame, top] : strongest) {
+      owned[frame];
+    }
+    for (const auto& c : mCandidates) {
+      const auto frame = strongest.find(c.frame);
+      if (frame == strongest.end() || (cuts.maxChi2RZ > 0. && c.chi2RZ > cuts.maxChi2RZ) || (cuts.maxDcaUM > 0. && c.dcaXY * 1.e4 > cuts.maxDcaUM)) {
+        continue;
+      }
+      const double distance = std::abs(static_cast<double>(c.zUM) - vertices[frame->second].zUM);
+      auto& [inClaim, inWindow] = owned[c.frame];
+      if (distance <= static_cast<double>(cuts.claimUM)) {
+        inClaim.insert(c.triple.begin(), c.triple.end());
+      }
+      if (distance <= static_cast<double>(cuts.windowUM)) {
+        inWindow.insert(c.triple.begin(), c.triple.end());
+      }
+    }
+    std::vector<Makeup> out(vertices.size());
+    for (std::size_t v = 0; v < vertices.size(); ++v) {
+      const auto& vertex = vertices[v];
+      const auto top = strongest.at(vertex.frame);
+      const auto dense = top == v ? std::int64_t{-3} : vertices[top].collision;
+      auto& m = out[v];
+      m.strongest = top == v;
+      std::vector<double> dca;
+      std::vector<double> chi2;
+      std::vector<double> radius;
+      std::vector<double> shared;
+      for (const auto i : claimed[v]) {
+        const auto& c = mCandidates[i];
+        m.shares[0] += c.trueTriplet ? 1. : 0.;
+        bool pair = false;
+        for (const auto& [first, second] : {std::pair{0U, 1U}, std::pair{1U, 2U}, std::pair{0U, 2U}}) {
+          const auto& row = mRows[c.triple[first]];
+          for (std::size_t k = 0; k < row.count && !pair; ++k) {
+            pair = mRows[c.triple[second]].carries(row.particles[k]);
+          }
+        }
+        m.shares[1] += pair ? 1. : 0.;
+        if (!m.strongest) {
+          const auto& [inClaim, inWindow] = owned.at(vertex.frame);
+          m.reuseClaim += std::ranges::any_of(c.triple, [&](std::uint32_t row) { return inClaim.contains(row); }) ? 1. : 0.;
+          m.reuseWindow += std::ranges::any_of(c.triple, [&](std::uint32_t row) { return inWindow.contains(row); }) ? 1. : 0.;
+        }
+        for (const auto row : c.triple) {
+          const auto origin = rowCollision(row);
+          m.shares[origin == -2 ? 2U : (origin >= 0 && origin == dense)            ? 3U
+                                     : (origin >= 0 && origin == vertex.collision) ? 4U
+                                                                                   : 5U] += 1. / 3.;
+        }
+        dca.push_back(c.dcaXY * 1.e4);
+        chi2.push_back(c.chi2RZ);
+        radius.push_back(std::isfinite(c.radius) ? c.radius * 1.e-2 : 1.e3);
+        shared.push_back(std::max(c.sharedFirst, c.sharedSecond));
+      }
+      const auto n = std::max<double>(1., static_cast<double>(claimed[v].size()));
+      for (auto& share : m.shares) {
+        share /= n;
+      }
+      m.reuseClaim /= n;
+      m.reuseWindow /= n;
+      m.dcaUM = study::median(dca);
+      m.chi2RZ = study::median(chi2);
+      m.radiusM = study::median(radius);
+      m.shared = study::median(shared);
+    }
+    return out;
+  }
+
+  // ---- The replay ----
+  //
+  // The vertexer's rounds (`Vertexer::find`, `findInFrame`) on the
+  // timeframe's distinct triplets as it measures them (`StageFit`): its cuts,
+  // the deduplication per slice, per frame the rounds -- the peak test, the
+  // centre, the claim, the weighted selection, the ownership -- and the list
+  // in the vertexer's order. Every variant owns, as the vertexer does, every
+  // measured triplet within the claim; at the vertexer's cuts
+  // the replay is the vertexer (checked in `replayAll`).
+
+  /// Where a candidate ended, per collision in `ReplayCollision::states`.
+  enum class ReplayState : std::uint8_t { kChi2,
+                                          kDca,
+                                          kDegenerate,
+                                          kDeduplicated,
+                                          kFree,
+                                          kOwn,
+                                          kOther,
+                                          kFake,
+                                          kDropped,
+                                          kCount };
+  static constexpr std::size_t kReplayStates = static_cast<std::size_t>(ReplayState::kCount);
+
+  /// The candidates' cuts: the vertexer's absolute ones, the r-z pull in
+  /// place of the chi2 (the dca absolute), both pulls, or both pulls with
+  /// the absolute dca as a cap (`tripletPulls`).
+  enum class CutMode : std::uint8_t { kAbsolute,
+                                      kRzPull,
+                                      kPulls,
+                                      kPullsCapped };
+
+  struct ReplayVariant {
+    std::string name;
+    CutMode cuts = CutMode::kAbsolute;
+    double sigma = 0.;  ///< the pulls' cut
+    bool prior = false; ///< starting from `setPriorVertices`'
+  };
+
+  struct ReplayVertex {
+    std::int64_t frame = 0;
+    std::uint32_t round = 0U;
+    std::int64_t windowStartUM = 0; ///< the winning window's first candidate
+    double centreUM = 0.;           ///< the window's free candidates' mean, the claim's centre
+    double zUM = 0.;                ///< the fitted z, the selection's weighted mean
+    std::uint32_t window = 0U;      ///< W: the window's free candidates
+    std::uint32_t sidebands = 0U;   ///< S: the two sidebands' free candidates
+    std::uint32_t hidden = 0U;      ///< kept candidates in the sidebands not free: claimed or dropped before
+    std::uint32_t contributors = 0U;
+    std::uint32_t selected = 0U; ///< of them, in the fit
+    std::uint32_t dropped = 0U;  ///< free candidates its ownership dropped
+    /// Of its claimed candidates, the share with a measurement of a triplet
+    /// past the cuts within an earlier vertex's claim in its frame.
+    double reuse = 0.;
+    std::int64_t listed = -1;    ///< its index in the list
+    std::int64_t collision = -1; ///< its claimed candidates' majority, -1 background
+    std::int64_t reference = -1; ///< the list index of its frame's strongest listed vertex, the first of the most contributors
+    std::uint32_t startPS = 0U;
+    std::uint32_t widthPS = 0U;
+    VertexSeed seed{}; ///< as the vertexer lists it
+    /// Of its claimed candidates' measurements, the shares whose first label
+    /// is the frame's strongest other vertex's collision, a particle below the
+    /// pass's pT floor, and no particle.
+    double denseShare = 0.;
+    double softShare = 0.;
+    double noParticleShare = 0.;
+  };
+
+  /// A true triplet of a collision dropped by a vertex's ownership: the row
+  /// it shared with an owned triplet, that triplet (the source), the owner.
+  struct ReplayDrop {
+    std::size_t candidate = 0U;
+    std::int64_t owner = 0; ///< the replay vertex
+    std::size_t source = 0U;
+    std::uint32_t row = 0U;
+  };
+
+  /// A window that held the contributor floor when its frame's rounds ended:
+  /// the sideband test refused it.
+  struct ReplayVeto {
+    std::int64_t frame = 0;
+    std::int64_t zUM = 0; ///< its start
+    std::uint32_t window = 0U;
+    std::uint32_t sidebands = 0U;
+  };
+
+  struct ReplayCollision {
+    std::uint32_t accepted = 0U; ///< its true triplets past the cuts
+    std::uint32_t kept = 0U;     ///< of them, kept by the deduplication
+    std::uint32_t core = 0U;     ///< of those, within the window of its true z
+    std::array<std::uint32_t, kReplayStates> states{};
+    std::int64_t dense = -1; ///< the collision of its frame's strongest listed vertex, -1 a fake or none
+    std::uint32_t denseContributors = 0U;
+    /// The refused window over its true z in its frame with the most
+    /// candidates, its count and its sidebands'; 0 for none.
+    std::uint32_t vetoedWindow = 0U;
+    std::uint32_t vetoedSidebands = 0U;
+  };
+
+  struct ReplayRun {
+    std::string name;
+    std::vector<ReplayVertex> vertices{}; ///< every vertex found, in the order found
+    std::vector<std::int64_t> listedToId;
+    Score score{};                   ///< its claims per candidate: the listed vertex that claimed it, -1 free, -2 not kept
+    std::vector<ReplayState> base{}; ///< per candidate: its state after the cuts and the deduplication
+    std::vector<ReplayCollision> collisions{};
+    std::uint64_t dropped = 0U;
+    std::vector<ReplayDrop> drops{};
+    std::vector<ReplayVeto> vetoes{};
+    std::vector<std::uint32_t> owned; ///< every row a vertex owned, in the order owned
+  };
+
+  /// The candidates' states after the cuts and the deduplication: kChi2,
+  /// kDca, kDegenerate, kDeduplicated, or kFree for the kept. The
+  /// deduplication as the vertexer's: per slice, over the slice's accepted
+  /// triplets in increasing chi2, ties in the slice's triplet order; a
+  /// candidate's state the one of the slice that owns its frame.
+  [[nodiscard]] std::vector<ReplayState> replayCandidates(const ReplayVariant& variant) const
+  {
+    const auto& s = mStage.settings();
+    std::vector<ReplayState> state(mCandidates.size(), ReplayState::kFree);
+    std::vector<std::uint8_t> passes(mCandidates.size(), 0U);
+    for (std::size_t i = 0; i < mCandidates.size(); ++i) {
+      const auto& c = mCandidates[i];
+      const bool chi2Out = variant.cuts == CutMode::kAbsolute ? s.maxChi2RZ > 0.F && c.fit.chi2RZ > s.maxChi2RZ : !(std::abs(mPulls[i].rz) < variant.sigma);
+      const bool dcaAbsoluteOut = s.maxDcaCM > 0.F && std::abs(c.fit.dcaCM) > s.maxDcaCM;
+      const bool dcaPullOut = !(std::abs(mPulls[i].dca) < variant.sigma);
+      const bool dcaOut = variant.cuts == CutMode::kPulls ? dcaPullOut : variant.cuts == CutMode::kPullsCapped ? dcaPullOut || dcaAbsoluteOut
+                                                                                                               : dcaAbsoluteOut;
+      if (c.fit.status != VertexCandidateStatus::kAccepted) {
+        state[i] = ReplayState::kDegenerate;
+      } else if (chi2Out) {
+        state[i] = ReplayState::kChi2;
+      } else if (dcaOut) {
+        state[i] = ReplayState::kDca;
+      } else {
+        passes[i] = 1U;
+      }
+    }
+    const auto columns = mFrame->measurements();
+    std::vector<std::uint8_t> taken(mFrame->size(), 0U);
+    std::vector<std::size_t> accepted;
+    std::vector<std::uint8_t> inSlice(mCandidates.size(), 0U);
+    std::vector<std::uint8_t> inOwner(mCandidates.size(), 0U);
+    for (const auto& [owned, triples] : mSliceTriplets) {
+      accepted.clear();
+      for (const auto& triple : triples) {
+        if (owned.owns(columns.timePS[triple[1]])) {
+          inOwner[candidateOf(triple)] = 1U; // the ownership's sources are the owning slice's
+        }
+        // A triple twice in the slice: its second triplet is the
+        // deduplication's, the candidate's state the first's.
+        if (const auto i = candidateOf(triple); passes[i] != 0U && inSlice[i] == 0U) {
+          inSlice[i] = 1U;
+          accepted.push_back(i);
+        }
+      }
+      std::ranges::stable_sort(accepted, {}, [&](std::size_t i) { return mCandidates[i].fit.chi2RZ; });
+      for (const auto i : accepted) {
+        const auto& rows = mCandidates[i].triple;
+        const bool kept = std::ranges::none_of(rows, [&](std::uint32_t row) { return taken[row] != 0U; });
+        if (kept) {
+          for (const auto row : rows) {
+            taken[row] = 1U;
+          }
+        }
+        if (owned.owns(columns.timePS[rows[1]])) {
+          state[i] = kept ? ReplayState::kFree : ReplayState::kDeduplicated;
+          passes[i] = 2U;
+        }
+      }
+      for (const auto i : accepted) {
+        inSlice[i] = 0U;
+        for (const auto row : mCandidates[i].triple) {
+          taken[row] = 0U;
+        }
+      }
+    }
+    if (std::ranges::count(passes, std::uint8_t{1U}) != 0) {
+      throw std::logic_error("the replay: a candidate past the cuts in no slice's frames");
+    }
+    if (std::ranges::count(inOwner, std::uint8_t{0U}) != 0) {
+      throw std::logic_error("the replay: a triplet not in the slice that owns its frame");
+    }
+    return state;
+  }
+
+  [[nodiscard]] ReplayRun replay(const ReplayVariant& variant, const std::vector<ReplayState>& base) const
+  {
+    const auto& s = mStage.settings();
+    const std::int64_t window = s.windowUM;
+    const std::int64_t claim = s.claimUM;
+    const Scalar k2 = 2.F * s.significance * s.significance;
+    ReplayRun run{.name = variant.name};
+    const auto n = mCandidates.size();
+    std::vector<std::int64_t> claimedBy(n, -1); // the replay vertex
+    std::vector<std::uint8_t> dropped(n, 0U);
+    std::vector<std::int64_t> rowOwner(mFrame->size(), -1);
+    std::vector<std::size_t> rowSource(mFrame->size(), 0U);
+    std::vector<std::uint8_t> rowSeen(mFrame->size(), 0U);  // for the reuse share
+    std::vector<std::uint8_t> rowPrior(mFrame->size(), 0U); // owned by an earlier pass's vertex
+    std::vector<std::uint32_t> touched;
+    const auto zOf = [&](std::size_t i) { return mCandidates[i].fit.zUM; };
+    for (std::size_t begin = 0; begin < n;) {
+      auto end = begin;
+      while (end < n && mCandidates[end].frame == mCandidates[begin].frame) {
+        ++end;
+      }
+      std::vector<std::size_t> kept;
+      std::vector<std::size_t> sources;  // the ownership's triplets, by z
+      std::vector<std::size_t> accepted; // the reuse share's, by z
+      for (auto i = begin; i < end; ++i) {
+        const bool pastCuts = base[i] == ReplayState::kFree || base[i] == ReplayState::kDeduplicated;
+        if (base[i] == ReplayState::kFree) {
+          kept.push_back(i);
+        }
+        if (pastCuts) {
+          accepted.push_back(i);
+        }
+        if (base[i] != ReplayState::kDegenerate) {
+          sources.push_back(i);
+        }
+      }
+      std::ranges::stable_sort(kept, {}, zOf);
+      std::ranges::stable_sort(sources, {}, zOf);
+      std::ranges::stable_sort(accepted, {}, zOf);
+      const auto m = kept.size();
+      std::vector<std::int64_t> z(m);
+      for (std::size_t k = 0; k < m; ++k) {
+        z[k] = zOf(kept[k]);
+      }
+      const auto at = [&](std::int64_t value) { return static_cast<std::size_t>(std::ranges::lower_bound(z, value) - z.begin()); };
+      const auto isFree = [&](std::size_t k) { return claimedBy[kept[k]] < 0 && dropped[kept[k]] == 0U; };
+      // The triplets of \a list within \a half of \a centre.
+      // As the vertexer's ownership (`withinZ`).
+      const auto within = [&](const std::vector<std::size_t>& list, Scalar centre, std::int64_t half, const auto& body) {
+        const auto reach = static_cast<std::int64_t>(centre);
+        for (auto it = std::ranges::lower_bound(list, reach - half - 1, {}, zOf); it != list.end() && zOf(*it) <= reach + half + 1; ++it) {
+          if (withinZ(zOf(*it), centre, static_cast<Scalar>(half))) {
+            body(*it);
+          }
+        }
+      };
+      // The earlier pass's vertices first -- their claims
+      // taken, their sources' rows owned, the free candidates on those rows
+      // dropped -- as rounds before the first.
+      if (variant.prior) {
+        if (const auto found = mPriorVertices.find(mFrameTimes[static_cast<std::size_t>(mCandidates[begin].frame)]); found != mPriorVertices.end()) {
+          for (const auto prior : found->second) {
+            for (auto k = at(static_cast<std::int64_t>(prior) - claim - 1); k < m && static_cast<Scalar>(z[k]) <= prior + static_cast<Scalar>(claim); ++k) {
+              if (isFree(k) && withinZ(z[k], prior, static_cast<Scalar>(claim))) {
+                dropped[kept[k]] = 1U;
+              }
+            }
+            within(sources, prior, claim, [&](std::size_t i) {
+              for (const auto row : mCandidates[i].triple) {
+                if (rowPrior[row] == 0U) {
+                  rowPrior[row] = 1U;
+                  touched.push_back(row);
+                }
+              }
+            });
+          }
+          for (std::size_t k = 0; k < m; ++k) {
+            if (isFree(k) && std::ranges::any_of(mCandidates[kept[k]].triple, [&](std::uint32_t row) { return rowPrior[row] != 0U; })) {
+              dropped[kept[k]] = 1U;
+              ++run.dropped;
+            }
+          }
+        }
+      }
+      std::vector<std::uint32_t> count(m + 1U, 0U);
+      std::uint32_t rounds = 0U;
+      while (true) {
+        ++rounds;
+        for (std::size_t k = 0; k < m; ++k) {
+          count[k + 1U] = count[k] + (isFree(k) ? 1U : 0U);
+        }
+        const auto countIn = [&](std::int64_t low, std::int64_t high) { return count[at(high)] - count[at(low)]; };
+        std::int64_t bestExcess = 0;
+        std::size_t best = m;
+        for (std::size_t k = 0; k < m; ++k) {
+          if (!isFree(k)) {
+            continue;
+          }
+          const auto excess = peakExcess(z[k], window, claim, s.minContributors, k2, countIn);
+          if (excess > bestExcess) {
+            bestExcess = excess;
+            best = k;
+          }
+        }
+        if (best == m) {
+          for (std::size_t k = 0; k < m; ++k) {
+            if (isFree(k) && countIn(z[k], z[k] + window) >= s.minContributors) {
+              run.vetoes.push_back({
+                .frame = mCandidates[begin].frame,
+                .zUM = z[k],
+                .window = countIn(z[k], z[k] + window),
+                .sidebands = countIn(z[k] - claim - window, z[k] - claim) + countIn(z[k] + window + claim, z[k] + (2 * window) + claim),
+              });
+            }
+          }
+          break;
+        }
+        const auto id = static_cast<std::int64_t>(run.vertices.size());
+        ReplayVertex vertex{.frame = mCandidates[begin].frame, .round = rounds, .windowStartUM = z[best]};
+        const auto windowEnd = at(z[best] + window);
+        std::int64_t sum = 0;
+        for (auto k = best; k < windowEnd; ++k) {
+          sum += isFree(k) ? z[k] : 0;
+        }
+        const auto members = static_cast<std::int64_t>(count[windowEnd] - count[best]);
+        const Scalar centre = static_cast<Scalar>(sum) / static_cast<Scalar>(members);
+        vertex.centreUM = centre;
+        vertex.window = countIn(z[best], z[best] + window);
+        const std::array<std::pair<std::int64_t, std::int64_t>, 2> sides{{{z[best] - claim - window, z[best] - claim}, {z[best] + window + claim, z[best] + (2 * window) + claim}}};
+        for (const auto& [low, high] : sides) {
+          vertex.sidebands += countIn(low, high);
+          vertex.hidden += static_cast<std::uint32_t>(at(high) - at(low)) - countIn(low, high);
+        }
+        // The claim and the weighted selection, as `findInFrame`.
+        std::vector<std::int64_t> claimedZ;
+        std::vector<std::uint64_t> claimedWeight;
+        std::vector<std::size_t> claimedIndex;
+        std::uint32_t earliest = std::numeric_limits<std::uint32_t>::max();
+        std::uint32_t latest = 0U;
+        for (auto k = at(static_cast<std::int64_t>(centre) - claim - 1); k < m && static_cast<Scalar>(z[k]) <= centre + static_cast<Scalar>(claim); ++k) {
+          const Scalar distance = static_cast<Scalar>(z[k]) > centre ? static_cast<Scalar>(z[k]) - centre : centre - static_cast<Scalar>(z[k]);
+          if (!isFree(k) || distance > static_cast<Scalar>(claim)) {
+            continue;
+          }
+          const auto& fit = mCandidates[kept[k]].fit;
+          claimedBy[kept[k]] = id;
+          ++vertex.contributors;
+          earliest = std::min(earliest, fit.box.lower());
+          latest = std::max(latest, fit.box.upper());
+          claimedZ.push_back(z[k]);
+          claimedWeight.push_back(fit.weight);
+          claimedIndex.push_back(kept[k]);
+        }
+        std::vector<std::uint8_t> selected(claimedZ.size(), 0U);
+        std::uint64_t weightSum = 0U;
+        std::int64_t weightedZSum = 0;
+        std::int64_t selectedCount = 0;
+        const auto select = [&](std::size_t k) {
+          selected[k] = 1U;
+          weightSum += claimedWeight[k];
+          weightedZSum += static_cast<std::int64_t>(claimedWeight[k]) * claimedZ[k];
+          ++selectedCount;
+        };
+        for (std::size_t k = 0; k < claimedZ.size(); ++k) {
+          if (withinZ(claimedZ[k], centre, static_cast<Scalar>(window))) {
+            select(k);
+          }
+        }
+        for (bool grew = true; grew;) {
+          grew = false;
+          const auto moments = zMoments(weightSum, weightedZSum);
+          for (std::size_t k = 0; k < claimedZ.size(); ++k) {
+            if (selected[k] == 0U && withinError(claimedZ[k], claimedWeight[k], moments, s.clipNSigma)) {
+              select(k);
+              grew = true;
+            }
+          }
+        }
+        const auto settled = zMoments(weightSum, weightedZSum);
+        std::uint64_t scatterSum = 0U;
+        for (std::size_t k = 0; k < claimedZ.size(); ++k) {
+          if (selected[k] != 0U) {
+            scatterSum += candidateScatter(claimedZ[k], claimedWeight[k], settled.mean);
+          }
+        }
+        const auto seed = vertexSeedOf({.weightSum = weightSum, .weightedZSum = weightedZSum, .scatterSum = scatterSum, .count = selectedCount, .earliestPS = earliest, .latestPS = latest}, VertexConstraint{});
+        vertex.zUM = static_cast<double>(seed.z) * 1.e4;
+        vertex.selected = static_cast<std::uint32_t>(selectedCount);
+        vertex.startPS = seed.timePS;
+        vertex.widthPS = seed.widthPS;
+        vertex.seed = seed;
+        // The reuse share against the earlier vertices of the frame, then
+        // this one's triplets past the cuts within its claim.
+        std::uint32_t reused = 0U;
+        for (const auto i : claimedIndex) {
+          reused += std::ranges::any_of(mCandidates[i].triple, [&](std::uint32_t row) { return rowSeen[row] != 0U; }) ? 1U : 0U;
+        }
+        vertex.reuse = vertex.contributors == 0U ? 0. : static_cast<double>(reused) / static_cast<double>(vertex.contributors);
+        within(accepted, centre, claim, [&](std::size_t i) {
+          for (const auto row : mCandidates[i].triple) {
+            rowSeen[row] = 1U;
+            touched.push_back(row);
+          }
+        });
+        // The ownership, and the free candidates it drops.
+        within(sources, centre, claim, [&](std::size_t i) {
+          for (const auto row : mCandidates[i].triple) {
+            if (rowOwner[row] < 0) {
+              rowOwner[row] = id;
+              rowSource[row] = i;
+              touched.push_back(row);
+              run.owned.push_back(row);
+            }
+          }
+        });
+        for (std::size_t k = 0; k < m; ++k) {
+          const auto& rows = mCandidates[kept[k]].triple;
+          const auto owned = std::ranges::find_if(rows, [&](std::uint32_t row) { return rowOwner[row] >= 0; });
+          if (isFree(k) && owned != rows.end()) {
+            dropped[kept[k]] = 1U;
+            ++vertex.dropped;
+            if (mCandidates[kept[k]].collision >= 0) {
+              run.drops.push_back({.candidate = kept[k], .owner = id, .source = rowSource[*owned], .row = *owned});
+            }
+          }
+        }
+        run.dropped += vertex.dropped;
+        run.vertices.push_back(vertex);
+      }
+      for (const auto row : touched) {
+        rowOwner[row] = -1;
+        rowSeen[row] = 0U;
+        rowPrior[row] = 0U;
+      }
+      touched.clear();
+      begin = end;
+    }
+    // Each vertex's majority collision.
+    std::vector<std::map<std::int64_t, std::uint32_t>> labels(run.vertices.size());
+    for (std::size_t i = 0; i < n; ++i) {
+      if (claimedBy[i] >= 0) {
+        ++labels[static_cast<std::size_t>(claimedBy[i])][mCandidates[i].collision];
+      }
+    }
+    for (std::size_t v = 0; v < run.vertices.size(); ++v) {
+      run.vertices[v].collision = std::ranges::max_element(labels[v], {}, [](const auto& entry) { return entry.second; })->first;
+    }
+    // The list in the vertexer's order -- frames in time, a frame's vertices
+    // by z, ties in the order found.
+    std::vector<std::size_t> order(run.vertices.size());
+    for (std::size_t v = 0; v < order.size(); ++v) {
+      order[v] = v;
+    }
+    std::ranges::stable_sort(order, {}, [&](std::size_t v) { return std::pair{mFrameTimes[static_cast<std::size_t>(run.vertices[v].frame)], run.vertices[v].seed.z}; });
+    for (std::size_t l = 0; l < order.size(); ++l) {
+      run.vertices[order[l]].listed = static_cast<std::int64_t>(l);
+    }
+    std::vector<Vertex> vertices;
+    std::map<std::int64_t, std::int64_t> strongest; // per frame, its first listed vertex of the most contributors
+    for (const auto v : order) {
+      const auto& vertex = run.vertices[v];
+      if (vertex.listed < 0) {
+        continue;
+      }
+      run.listedToId.push_back(static_cast<std::int64_t>(v));
+      vertices.push_back({.frame = vertex.frame, .zUM = vertex.zUM, .contributors = vertex.contributors, .collision = vertex.collision});
+      const auto [top, inserted] = strongest.try_emplace(vertex.frame, vertex.listed);
+      if (!inserted && vertices[static_cast<std::size_t>(top->second)].contributors < vertex.contributors) {
+        top->second = vertex.listed;
+      }
+    }
+    for (auto& vertex : run.vertices) {
+      const auto top = strongest.find(vertex.frame);
+      vertex.reference = top == strongest.end() ? -1 : top->second;
+    }
+    for (std::size_t i = 0; i < n; ++i) {
+      if (claimedBy[i] < 0) {
+        continue;
+      }
+      auto& vertex = run.vertices[static_cast<std::size_t>(claimedBy[i])];
+      const auto dense = vertex.reference < 0 || vertex.reference == vertex.listed ? std::int64_t{-3} : run.vertices[static_cast<std::size_t>(run.listedToId[static_cast<std::size_t>(vertex.reference)])].collision;
+      for (const auto row : mCandidates[i].triple) {
+        const auto& truth = mRows[row];
+        if (truth.count == 0U) {
+          vertex.noParticleShare += 1.;
+          continue;
+        }
+        const auto particle = truth.particles[0];
+        const auto at = mCollisionIndex.find(collisionOf(particle));
+        vertex.denseShare += at != mCollisionIndex.end() && static_cast<std::int64_t>(at->second) == dense ? 1. : 0.;
+        const auto info = mParticles->find(particle);
+        vertex.softShare += info != mParticles->end() && static_cast<double>(info->second.pt) < mPassMinPtGeV ? 1. : 0.;
+      }
+    }
+    for (auto& vertex : run.vertices) {
+      const double rows = 3. * std::max(1., static_cast<double>(vertex.contributors));
+      vertex.denseShare /= rows;
+      vertex.softShare /= rows;
+      vertex.noParticleShare /= rows;
+    }
+    std::vector<std::int64_t> claims(n, -2);
+    for (std::size_t i = 0; i < n; ++i) {
+      if (base[i] == ReplayState::kFree) {
+        claims[i] = claimedBy[i] < 0 ? -1 : run.vertices[static_cast<std::size_t>(claimedBy[i])].listed;
+      }
+    }
+    run.score = scoreClaims(std::move(vertices), std::move(claims));
+    // Per collision: its true triplets' states, and its frame's strongest.
+    run.collisions.assign(mCollisions.size(), {});
+    for (std::size_t i = 0; i < n; ++i) {
+      const auto& c = mCandidates[i];
+      if (c.collision < 0) {
+        continue;
+      }
+      auto& out = run.collisions[static_cast<std::size_t>(c.collision)];
+      auto state = base[i];
+      if (state == ReplayState::kFree || state == ReplayState::kDeduplicated) {
+        ++out.accepted;
+      }
+      if (state == ReplayState::kFree) {
+        ++out.kept;
+        out.core += std::abs(static_cast<double>(c.fit.zUM) - (mCollisions[static_cast<std::size_t>(c.collision)].z * 1.e4)) <= static_cast<double>(window) ? 1U : 0U;
+        if (dropped[i] != 0U) {
+          state = ReplayState::kDropped;
+        } else if (claimedBy[i] >= 0) {
+          const auto& vertex = run.vertices[static_cast<std::size_t>(claimedBy[i])];
+          state = vertex.collision == c.collision ? ReplayState::kOwn : vertex.collision >= 0 ? ReplayState::kOther
+                                                                                              : ReplayState::kFake;
+        }
+      }
+      ++out.states[static_cast<std::size_t>(state)];
+    }
+    for (std::size_t c = 0; c < mCollisions.size(); ++c) {
+      const auto top = strongest.find(mCollisions[c].frame);
+      if (top != strongest.end()) {
+        const auto& vertex = run.vertices[static_cast<std::size_t>(run.listedToId[static_cast<std::size_t>(top->second)])];
+        run.collisions[c].dense = vertex.collision;
+        run.collisions[c].denseContributors = vertex.contributors;
+      }
+    }
+    for (const auto& veto : run.vetoes) {
+      for (std::size_t c = 0; c < mCollisions.size(); ++c) {
+        const auto trueZ = mCollisions[c].z * 1.e4;
+        auto& out = run.collisions[c];
+        if (mCollisions[c].frame == veto.frame && static_cast<double>(veto.zUM) <= trueZ && trueZ < static_cast<double>(veto.zUM + window) && veto.window > out.vetoedWindow) {
+          out.vetoedWindow = veto.window;
+          out.vetoedSidebands = veto.sidebands;
+        }
+      }
+    }
+    return run;
+  }
+
+  /// Whether the slope intervals of \a from and \a to admit their line: a
+  /// tracklet's line, for each observed tracklet in the
+  /// per-link shape counts (`observeSlice`).
+  template <typename Columns>
+  [[nodiscard]] static bool pairShaped(const Columns& columns, std::uint32_t from, std::uint32_t to)
+  {
+    const auto admits = [&](std::uint32_t at) { return shapeAdmits(columns, at, columns.x[from], columns.y[from], columns.z[from], columns.x[to], columns.y[to], columns.z[to]); };
+    return admits(from) && admits(to);
+  }
+
+  /// The replay's variants, its check against the vertexer, and a line each.
+  void replayAll(std::vector<std::string>& lines)
+  {
+    mPulls.clear();
+    mPulls.reserve(mCandidates.size());
+    for (const auto& c : mCandidates) {
+      mPulls.push_back(c.fit.status == VertexCandidateStatus::kAccepted ? tripletPulls(c) : TripletPulls{});
+    }
+    mReplays.clear();
+    // The vertexer (first, the gate's), and its cuts in sigmas of the
+    // candidate's own errors.
+    std::vector<ReplayVariant> variants{
+      {.name = "stage"},
+      {.name = "rz3", .cuts = CutMode::kRzPull, .sigma = 3.},
+      {.name = "pulls3", .cuts = CutMode::kPulls, .sigma = 3.},
+      {.name = "pulls3-cap", .cuts = CutMode::kPullsCapped, .sigma = 3.},
+    };
+    if (!mPriorVertices.empty()) {
+      variants.push_back({.name = "prior-stage", .prior = true});
+      variants.push_back({.name = "prior-rz3", .cuts = CutMode::kRzPull, .sigma = 3., .prior = true});
+      variants.push_back({.name = "prior-pulls3", .cuts = CutMode::kPulls, .sigma = 3., .prior = true});
+    }
+    for (const auto& variant : variants) {
+      auto base = replayCandidates(variant);
+      mReplays.push_back(replay(variant, base));
+      mReplays.back().base = std::move(base);
+    }
+    // The gate: the replay at the vertexer's settings is the vertexer --
+    // its list in order (box, z and variance bitwise, contributors) and
+    // every candidate's claim, free (-1) and not kept (-2) included.
+    std::vector<std::int64_t> stageClaims;
+    static_cast<void>(stageVertices(stageClaims));
+    const auto& first = mReplays.front();
+    const auto& firstClaims = first.score.claimedBy;
+    std::size_t sameVertices = 0U;
+    const auto bits = [](Scalar value) { return std::bit_cast<std::uint32_t>(value); };
+    for (std::size_t l = 0; l < std::min(first.listedToId.size(), mStageVertices.size()); ++l) {
+      const auto& replayed = first.vertices[static_cast<std::size_t>(first.listedToId[l])];
+      const auto& staged = mStageVertices[l];
+      sameVertices += replayed.seed.timePS == staged.timePS && replayed.seed.widthPS == staged.widthPS && bits(replayed.seed.z) == bits(staged.z) && bits(replayed.seed.varZ) == bits(staged.varZ) && replayed.contributors == mStageContributors[l] ? 1U : 0U;
+    }
+    std::size_t sameClaims = 0U;
+    for (std::size_t i = 0; i < mCandidates.size(); ++i) {
+      sameClaims += firstClaims[i] == stageClaims[i] ? 1U : 0U;
+    }
+    const bool identical = sameVertices == first.listedToId.size() && sameVertices == mStageVertices.size() && sameClaims == mCandidates.size();
+    const auto check = std::format(
+      "replay of the vertexer: {}; vertices identical in order (box, z, variance, contributors) {} of the replay's {} and "
+      "the vertexer's {}; candidates with the same claim {} of {}; triples twice in a slice {}",
+      identical ? "IDENTICAL" : "DIFFERENT", sameVertices, first.listedToId.size(), mStageVertices.size(), sameClaims, mCandidates.size(), mStageRepeats);
+    if (!identical) {
+      std::cerr << check << '\n';
+      throw std::runtime_error("the replay differs from the vertexer");
+    }
+    lines.push_back(check);
+    constexpr std::array<std::uint32_t, 13> kEdges{0U, 1U, 2U, 3U, 4U, 10U, 20U, 50U, 100U, 200U, 500U, 1000U, 2500U};
+    for (const auto& run : mReplays) {
+      std::uint32_t found = 0U;
+      std::array<std::uint32_t, kEdges.size()> all{};
+      std::array<std::uint32_t, kEdges.size()> foundIn{};
+      for (std::size_t c = 0; c < mCollisions.size(); ++c) {
+        std::size_t bin = 0;
+        while (bin + 1U < kEdges.size() && mCollisions[c].findable >= kEdges[bin + 1U]) {
+          ++bin;
+        }
+        ++all[bin];
+        const bool hit = run.score.best[c] >= 0;
+        found += hit ? 1U : 0U;
+        foundIn[bin] += hit ? 1U : 0U;
+      }
+      // The triplets the pass made (not refused by their shapes), those past
+      // the cuts, and of those the share with one collision's particle on
+      // all three measurements.
+      std::size_t made = 0U;
+      std::size_t pastCuts = 0U;
+      std::size_t pastCutsTrue = 0U;
+      for (std::size_t i = 0; i < mCandidates.size(); ++i) {
+        const auto state = run.base[i];
+        ++made;
+        if (state == ReplayState::kFree || state == ReplayState::kDeduplicated) {
+          ++pastCuts;
+          pastCutsTrue += mCandidates[i].trueTriplet && mCandidates[i].collision >= 0 ? 1U : 0U;
+        }
+      }
+      std::string line = std::format(
+        "replay {}: vertices {} of {} found, collisions {}/{}, fakes {} splits {} merged {}, candidates dropped {}; triplets {}, past the cuts {}, "
+        "true {}; by findable (QA):",
+        run.name, run.listedToId.size(), run.vertices.size(), found, mCollisions.size(), run.score.fakes, run.score.splits, run.score.merged, run.dropped, made, pastCuts, pastCutsTrue);
+      for (std::size_t bin = 0; bin < kEdges.size(); ++bin) {
+        line += std::format(" [{}{}] {}/{}", kEdges[bin], bin + 1U < kEdges.size() ? std::format("-{}", kEdges[bin + 1U] - 1U) : std::string{"+"}, foundIn[bin], all[bin]);
+      }
+      lines.push_back(line);
+    }
+  }
+
+  const TimeFrame<Det>* mFrame;
+  std::span<const study::TruthRow> mRows;
+  const study::ParticleTable* mParticles;
+  std::size_t mIteration;
+  double mPassMinPtGeV;
+  study::ComparisonSettings mComparison; ///< the tracking QA's findability, the collisions' findable primaries (`isFindable`)
+  Vertexer mStage;
+  Settings mTable; ///< the vertexer's settings from the configuration, for the tables and the makeup
+  std::unique_ptr<BoundedMemoryResource> mStagePool;
+  std::unique_ptr<o2::gtrk::detail::TaskArena> mArena;
+  std::size_t mSlices = 0;
+  std::map<std::uint16_t, std::size_t> mTrackletsByLink;
+  std::map<std::uint16_t, std::size_t> mTrackletsShaped; ///< of them, those whose slope intervals admit their line
+  std::vector<Collision> mCollisions;
+  std::unordered_map<std::uint64_t, std::size_t> mCollisionIndex;
+  std::map<std::uint32_t, std::int64_t> mFrameIndex; ///< by box start
+  std::vector<Candidate> mCandidates;
+  std::vector<std::size_t> mByTriple;            ///< the candidates' indices by their triple
+  std::optional<IterationParameters<Det>> mPass; ///< the observed pass's, for the triplets' pulls
+  Scalar mBeamVarTransverse = 0.F;               ///< the beam's transverse spread squared, the same
+  std::map<Triple, std::int64_t> mStageClaims;
+  std::vector<VertexSeed> mStageVertices;
+  std::vector<std::uint32_t> mStageContributors;
+  std::size_t mStageRepeats = 0U;  ///< triplets whose triple the slice already had
+  std::size_t mStagePoolPeak = 0U; ///< the vertexer's work arrays' peak over the slices [bytes]
+  std::vector<std::pair<Triple, StageFit>> mStageFits;
+  std::vector<std::pair<OwnedFrames, std::vector<Triple>>> mSliceTriplets; ///< per slice, its triplets and the frames it owns
+  std::map<std::uint32_t, std::vector<Scalar>> mPriorVertices;             ///< an earlier pass's vertices' z [um] by frame time
+  std::vector<std::uint32_t> mFrameTimes;                                  ///< by frame index, its box start
+  std::vector<ReplayRun> mReplays;
+  std::vector<TripletPulls> mPulls; ///< per candidate, its pulls (`tripletPulls`)
+  std::uint32_t mStageRounds = 0U;
+  double mStageSeconds = 0.;
+  std::size_t mStageCandidates = 0U;
+  BeamEstimate mStageBeam;
+  double mBeamX = 0.; ///< the rows' beam line, from the dump
+  double mBeamY = 0.;
+};
+
+} // namespace o2::gtrk::study
+
+#endif // GTRK_STUDY_VERTEXSTUDY_H_
diff --git a/Detectors/GenericTracking/study/tools/checkHits.cxx b/Detectors/GenericTracking/study/tools/checkHits.cxx
new file mode 100644
index 0000000000000..ba500fdf0aed6
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/checkHits.cxx
@@ -0,0 +1,172 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file checkHits.cxx
+/// \brief Check that the MC hits of the ITS, MFT or ALICE 3 TRK lie on the
+///        silicon of their chips as the tracking places them.
+///
+/// Loads the geometry, places every chip as GenericTracking/Alice/Placement.h
+/// does and takes each MC hit into its chip's frame: both ends of every hit
+/// must be on its chip's silicon. It also reports how far into the bounds the
+/// hits reach, whether the bounds hold silicon no hit uses. Exits 1 if an end
+/// lies off its chip's silicon by more than its float precision; the reach
+/// only informs.
+
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Study/Alice/Hits.h"
+#include "GenericTracking/Study/Statistics.h"
+#include <boost/program_options.hpp>
+#include "GenericTracking/Tools/SensorFrame.h"
+
+#include "DetectorsBase/GeometryManager.h"
+
+#include <algorithm>
+#include <cmath>
+#include <exception>
+#include <format>
+#include <iostream>
+#include <limits>
+#include <span>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace bpo = boost::program_options;
+
+namespace o2::gtrk::study
+{
+
+namespace
+{
+
+/// Both ends of every MC hit in its chip's frame -- where Geant4 entered and
+/// left the silicon -- how many are off it by more than their own precision,
+/// and by how much at most [cm], per layer. O2 stores a hit's ends as floats,
+/// so an end on the silicon's surface can come out beyond it by the float step
+/// of its largest coordinate. (Not the hit's middle: on a curved sensor the
+/// chord of a grazing track sags inside the inner surface.) And per layer the
+/// ends' reach into the bounds, |loc0| over the half width and |loc1| over
+/// the half length in the unrolled frame: the 99.9th percentile and the
+/// largest.
+template <DetectorLayout Det>
+int checkHits(const Geometry<Det>& geometry, study::Chips chips, const std::string& file, const std::string& discFile)
+{
+  study::HitFile hits(file, chips, discFile);
+  std::vector<long> total(Detector<Det>::nLayers, 0);
+  std::vector<long> off(Detector<Det>::nLayers, 0);
+  std::vector<double> worst(Detector<Det>::nLayers, 0.);
+  std::vector<std::vector<float>> across(Detector<Det>::nLayers);
+  std::vector<std::vector<float>> along(Detector<Det>::nLayers);
+  for (int event = 0; event < hits.nEvents(); ++event) {
+    for (const auto& segment : hits.event(event)) {
+      const auto& sensor = geometry.sensor(segment.chip);
+      const auto& spec = geometry.specOf(segment.chip);
+      for (const auto& end : {segment.start, segment.end}) {
+        double frame[3];
+        tools::toLocal(sensor, end.data(), frame);
+        double unrolled[3];
+        tools::frameToUnrolled(spec, frame, unrolled);
+        const double beyond = std::max({std::abs(unrolled[0]) - spec.halfX, std::abs(unrolled[1]) - spec.halfY, spec.surfaceMin() - unrolled[2], unrolled[2] - spec.surfaceMax(), 0.});
+        const double precision = static_cast<double>(std::numeric_limits<float>::epsilon()) * std::max({std::abs(end[0]), std::abs(end[1]), std::abs(end[2])});
+        ++total[sensor.layer];
+        across[sensor.layer].push_back(static_cast<float>(std::abs(unrolled[0]) / spec.halfX));
+        along[sensor.layer].push_back(static_cast<float>(std::abs(unrolled[1]) / spec.halfY));
+        if (beyond > precision) {
+          ++off[sensor.layer];
+          worst[sensor.layer] = std::max(worst[sensor.layer], beyond);
+        }
+      }
+    }
+  }
+  std::cout << std::format("\nMC hits of {}{}, both ends of each in its chip's frame:\n", file, discFile.empty() ? "" : " and " + discFile);
+  const auto reach = [](std::vector<float>& values) -> std::pair<float, float> {
+    if (values.empty()) {
+      return {0.F, 0.F};
+    }
+    return {study::quantile(std::span{values}, 0.999), *std::ranges::max_element(values)};
+  };
+  int status = 0;
+  for (std::size_t layer = 0; layer < total.size(); ++layer) {
+    const auto [acrossQ, acrossMax] = reach(across[layer]);
+    const auto [alongQ, alongMax] = reach(along[layer]);
+    std::cout << std::format(
+      "layer {}: {} hit ends, {} off the silicon beyond their float precision, by at most {:.3f} um; reach into the bounds, "
+      "99.9 % / largest: |loc0| / half width {:.4f} / {:.4f}, |loc1| / half length {:.4f} / {:.4f}\n",
+      layer, total[layer], off[layer], worst[layer] * 1e4, acrossQ, acrossMax, alongQ, alongMax);
+    status = off[layer] > 0 ? 1 : status;
+  }
+  return status;
+}
+
+template <DetectorLayout Det>
+int runFor(study::Chips chips, const std::string& file, const std::string& discFile)
+{
+  const Geometry<Det> geometry(alice::placeChecked<Det>());
+  return checkHits(geometry, chips, file, discFile);
+}
+
+int run(int argc, char** argv)
+{
+  std::string geometry;
+  std::string detector;
+  std::string hits;
+  std::string ft3Hits;
+  bpo::options_description description("Check that the MC hits of the ITS, MFT or ALICE 3 TRK lie on their chips' silicon");
+  description.add_options()                                                                                    //
+    ("help,h", "this message")                                                                                 //
+    ("geometry,g", bpo::value(&geometry)->default_value("o2sim_geometry-aligned.root"), "o2sim geometry file") //
+    ("detector,d", bpo::value(&detector)->default_value("ITS"), "ITS, MFT or TRKFT3")                          //
+    ("hits", bpo::value(&hits)->required(), "the detector's MC hits, e.g. sgn_HitsTRK.root")                   //
+    ("ft3-hits", bpo::value(&ft3Hits)->default_value("sgn_HitsFT3.root"), "TRKFT3: FT3's MC hits, checked too");
+  bpo::variables_map vm;
+  try {
+    bpo::store(bpo::parse_command_line(argc, argv, description), vm);
+    if (vm.contains("help")) {
+      std::cout << description << '\n';
+      return 0;
+    }
+    bpo::notify(vm);
+  } catch (const bpo::error& error) {
+    std::cerr << error.what() << "\n\n"
+              << description << '\n';
+    return 1;
+  }
+  o2::base::GeometryManager::loadGeometry(geometry);
+  if (detector == "ITS") {
+    return runFor<detectors::ITS>(study::Chips::kITS, hits, "");
+  }
+  if (detector == "MFT") {
+    return runFor<detectors::MFT>(study::Chips::kMFT, hits, "");
+  }
+  if (detector == "TRKFT3") {
+    return runFor<detectors::TRKFT3>(study::Chips::kTRK, hits, ft3Hits);
+  }
+  std::cerr << "unknown detector '" << detector << "'\n";
+  return 1;
+}
+
+} // namespace
+
+} // namespace o2::gtrk::study
+
+int main(int argc, char** argv)
+{
+  try {
+    return o2::gtrk::study::run(argc, argv);
+  } catch (const std::exception& error) {
+    std::cerr << "error: " << error.what() << '\n';
+    return 1;
+  }
+}
diff --git a/Detectors/GenericTracking/study/tools/checkMatLUT.cxx b/Detectors/GenericTracking/study/tools/checkMatLUT.cxx
new file mode 100644
index 0000000000000..ae63215338ee3
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/checkMatLUT.cxx
@@ -0,0 +1,635 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file checkMatLUT.cxx
+/// \brief Hold a material LUT to the geometry it was built from, along the
+///        paths simulated particles take.
+///
+///     o2-gtrk-check-matlut --detector TRKFT3 --sim <dir> --lut gtrk_matlut_trk.root [--events 200]
+///
+/// A LUT holds each cell's material evenly, so a thin dense object -- a
+/// layer's metal stack, a petal's side wall, a disc's support -- lands on
+/// every track through its cell, crossing it or not. The radial total cannot
+/// see that; the fit can. This tool measures what the fit
+/// is given against what the particles crossed.
+///
+/// Each MC particle's crossings of the layers, in time order, collapsed to the
+/// first crossing of each layer and cut where a layer comes back (a looper's
+/// second leg), give the steps the fit takes: from the production vertex to
+/// the first crossing, then from one crossing to the next, each from the
+/// crossing's entry point to the next one's. The path between is the true
+/// helix, without a field: the transverse circle tangent to the momentum at
+/// the first point through the second, z linear in the arc. A step whose
+/// circle turns the momentum more than --max-turn away from the true one at
+/// its end is left out: more than half a turn, or a hard scatter. Along the
+/// path, in --pieces straight pieces, the material from the loaded geometry
+/// (`GeometryManager::meanMaterialBudget`, as the LUT builder fills its cells)
+/// and from the LUT (`MatLayerCylSet::getMatBudget`, as the fit reads it).
+///
+/// The tables:
+///
+/// - **nodes**: per layer, the material the fit applies at the crossing --
+///   the far half of the step in and the near half of the step out (its two
+///   halves). The material of a layer's own band then counts in full, however
+///   the band splits it between the two steps. The ratio of the means, and of
+///   the particles' own ratios the median and the 5 % and 95 % quantiles: a
+///   cell smeared over its neighbours widens these, a wrong total moves them.
+/// - **steps**: per pair of layers, the material, the share of it in the
+///   step's near half (where it sits), and the true change of the polar angle
+///   (which the solenoid leaves alone) in Highland's theta0 of the geometry
+///   and of the LUT: its core, 1.4826 MAD, near 1 for the geometry's says
+///   the comparison holds; the LUT's is what the fit's angle pulls see.
+///   Electrons are left out of this one (bremsstrahlung).
+/// - **worst cells**: the nodes binned by layer and azimuth and by layer and
+///   z (barrel) or r (disc), the cells with at least --min-cell nodes whose
+///   ratio of the means is furthest from 1. A wall, a support or a stave
+///   overlap shows up here without being looked for.
+///
+/// --output writes the steps as a tree for plots.
+
+#include "GenericTracking/Study/Alice/Hits.h"
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Study/Statistics.h"
+
+#include "DetectorsBase/GeometryManager.h"
+#include "DetectorsBase/MatLayerCylSet.h"
+#include "SimulationDataFormat/MCTrack.h"
+#include "Steer/MCKinematicsReader.h"
+
+#include <TFile.h>
+#include <TGeoManager.h>
+#include <TTree.h>
+
+#include <boost/program_options.hpp>
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <exception>
+#include <filesystem>
+#include <format>
+#include <iostream>
+#include <limits>
+#include <map>
+#include <memory>
+#include <numbers>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+namespace bpo = boost::program_options;
+
+namespace
+{
+
+using o2::gtrk::LayerID;
+
+constexpr double kNaN = std::numeric_limits<double>::quiet_NaN();
+
+struct Options {
+  std::string detector = "TRKFT3";
+  std::string sim;
+  std::string lut;
+  std::string geometry;
+  std::string output;
+  int events = 200;
+  double minPt = 0.1;
+  bool secondaries = false;
+  int pieces = 8;
+  double maxTurn = 0.2;
+  int minSteps = 200;
+  int minCell = 30;
+  int worst = 25;
+  double phiBinDeg = 1.;
+  double coordinateBin = 2.;
+  int threads = -1;
+};
+
+/// A point on the path [cm] with the momentum there [GeV].
+struct Point {
+  std::array<double, 3> x{};
+  std::array<double, 3> p{};
+};
+
+/// One step: from a crossing's entry (or the vertex) to the next one's.
+struct Step {
+  int event = 0;
+  int track = 0;
+  int pdg = 0;
+  double pt = 0.;
+  double eta = 0.;
+  double mass = 0.;
+  int from = -1; ///< layer, -1 the vertex
+  int to = -1;
+  Point a;
+  Point b;
+  double turn = 0.;            ///< the circle's direction at b against the true one [rad]
+  std::array<double, 2> geo{}; ///< x/X0, near and far half
+  std::array<double, 2> lut{};
+  bool lastOfLeg = false;
+};
+
+/// The step's path, \a pieces + 1 points: the transverse circle tangent to a's
+/// momentum through b, z linear in the arc. Also the circle's direction at b.
+std::vector<std::array<double, 3>> path(const Step& step, int pieces, double& directionAtB)
+{
+  const auto& [ax, ap] = step.a;
+  const auto& bx = step.b.x;
+  const double tNorm = std::hypot(ap[0], ap[1]);
+  const std::array<double, 2> t{ap[0] / tNorm, ap[1] / tNorm};
+  const std::array<double, 2> n{-t[1], t[0]};
+  const std::array<double, 2> d{bx[0] - ax[0], bx[1] - ax[1]};
+  const double dd = (d[0] * d[0]) + (d[1] * d[1]);
+  const double dn = (d[0] * n[0]) + (d[1] * n[1]);
+  std::vector<std::array<double, 3>> points;
+  points.reserve(static_cast<std::size_t>(pieces) + 1U);
+  if (std::abs(dn) < 1e-9 * dd) {
+    for (int i = 0; i <= pieces; ++i) {
+      const double f = static_cast<double>(i) / pieces;
+      points.push_back({ax[0] + (f * d[0]), ax[1] + (f * d[1]), ax[2] + (f * (bx[2] - ax[2]))});
+    }
+    directionAtB = std::atan2(t[1], t[0]);
+    return points;
+  }
+  const double radius = dd / (2. * dn); // signed, along n
+  const std::array<double, 2> centre{ax[0] + (radius * n[0]), ax[1] + (radius * n[1])};
+  const double start = std::atan2(ax[1] - centre[1], ax[0] - centre[0]);
+  double sweep = std::atan2(bx[1] - centre[1], bx[0] - centre[0]) - start;
+  // the direction of travel: counter-clockwise for a positive radius
+  if (radius > 0.) {
+    while (sweep < 0.) {
+      sweep += 2. * std::numbers::pi;
+    }
+  } else {
+    while (sweep > 0.) {
+      sweep -= 2. * std::numbers::pi;
+    }
+  }
+  const double r = std::abs(radius);
+  for (int i = 0; i <= pieces; ++i) {
+    const double f = static_cast<double>(i) / pieces;
+    const double angle = start + (f * sweep);
+    points.push_back({centre[0] + (r * std::cos(angle)), centre[1] + (r * std::sin(angle)), ax[2] + (f * (bx[2] - ax[2]))});
+  }
+  directionAtB = std::atan2(t[1], t[0]) + sweep;
+  return points;
+}
+
+double wrapped(double angle) { return std::remainder(angle, 2. * std::numbers::pi); }
+
+/// The step's material along its path, near and far half, from the geometry
+/// (on \a navigator) and from \a lut.
+void measure(Step& step, int pieces, const o2::base::MatLayerCylSet& lut, TGeoNavigator* navigator)
+{
+  double direction = 0.;
+  const auto points = path(step, pieces, direction);
+  step.turn = std::abs(wrapped(direction - std::atan2(step.b.p[1], step.b.p[0])));
+  for (int i = 0; i < pieces; ++i) {
+    const auto& p = points[static_cast<std::size_t>(i)];
+    const auto& q = points[static_cast<std::size_t>(i) + 1U];
+    const std::size_t half = 2 * i < pieces ? 0U : 1U;
+    const auto geo = o2::base::GeometryManager::meanMaterialBudget(static_cast<float>(p[0]), static_cast<float>(p[1]), static_cast<float>(p[2]), static_cast<float>(q[0]), static_cast<float>(q[1]), static_cast<float>(q[2]), navigator);
+    if (geo.length > 0.F) {
+      step.geo[half] += static_cast<double>(geo.meanX2X0);
+    }
+    const auto fromLut = lut.getMatBudget(static_cast<float>(p[0]), static_cast<float>(p[1]), static_cast<float>(p[2]), static_cast<float>(q[0]), static_cast<float>(q[1]), static_cast<float>(q[2]));
+    step.lut[half] += static_cast<double>(fromLut.meanX2X0);
+  }
+}
+
+/// Highland's theta0, the tracking's formula (`Tracking/Material.h`,
+/// `highlandTheta0`) in double; x/X0 <= 0 gives 0.
+double highland(double x2X0, double betaP) { return x2X0 > 0. ? 0.0136 / betaP * std::sqrt(x2X0) * (1. + (0.038 * std::log(x2X0))) : 0.; }
+
+/// beta p of momentum \a p and \a mass [GeV], the tracking's `betaMomentum` in double.
+double betaMomentum(const std::array<double, 3>& momentum, double mass)
+{
+  const double p = std::sqrt((momentum[0] * momentum[0]) + (momentum[1] * momentum[1]) + (momentum[2] * momentum[2]));
+  return p * p / std::sqrt((p * p) + (mass * mass));
+}
+
+double polar(const std::array<double, 3>& p) { return std::atan2(std::hypot(p[0], p[1]), p[2]); }
+
+double quantile(std::vector<double> v, double q)
+{
+  if (v.empty()) {
+    return kNaN;
+  }
+  return o2::gtrk::study::quantile(std::span{v}, q);
+}
+
+/// 1.4826 MAD.
+double core(std::vector<double> v)
+{
+  if (v.size() < 20U) {
+    return kNaN;
+  }
+  const double median = quantile(v, 0.5);
+  for (auto& x : v) {
+    x = std::abs(x - median);
+  }
+  return 1.4826 * quantile(v, 0.5);
+}
+
+double beyond(const std::vector<double>& v, double width, double k)
+{
+  if (v.empty() || !std::isfinite(width)) {
+    return kNaN;
+  }
+  const auto n = std::ranges::count_if(v, [&](double x) { return std::abs(x) > k * width; });
+  return 100. * static_cast<double>(n) / static_cast<double>(v.size());
+}
+
+template <o2::gtrk::DetectorLayout Det>
+std::string layerName(int layer)
+{
+  if (layer < 0) {
+    return "vertex";
+  }
+  return std::format("{}{}", o2::gtrk::Detector<Det>::isBarrelLayer(static_cast<LayerID>(layer)) ? "B" : "D", layer);
+}
+
+/// The steps of every particle above --min-pt in the first --events events;
+/// \a events, the events read.
+template <o2::gtrk::DetectorLayout Det>
+std::vector<Step> collect(const Options& options, const o2::gtrk::Geometry<Det>& geometry, int& events)
+{
+  constexpr auto kChips = o2::gtrk::study::chipsOf<Det>();
+  const std::string hitName = [] {
+    if constexpr (kChips == o2::gtrk::study::Chips::kITS) {
+      return "ITS";
+    } else if constexpr (kChips == o2::gtrk::study::Chips::kMFT) {
+      return "MFT";
+    } else {
+      return "TRK";
+    }
+  }();
+  const std::string discPath = kChips == o2::gtrk::study::Chips::kTRK ? options.sim + "/sgn_HitsFT3.root" : std::string{};
+  o2::gtrk::study::HitFile hits(options.sim + "/sgn_Hits" + hitName + ".root", kChips, discPath);
+  // The kinematics through O2's reader, each event released once its steps are taken.
+  if (!std::filesystem::exists(options.sim + "/sgn_Kine.root")) {
+    throw std::runtime_error("no " + options.sim + "/sgn_Kine.root");
+  }
+  o2::steer::MCKinematicsReader kine(options.sim + "/sgn", o2::steer::MCKinematicsReader::Mode::kMCKine);
+  std::vector<Step> steps;
+  events = std::min({options.events, hits.nEvents(), static_cast<int>(kine.getNEvents(0))});
+  for (int event = 0; event < events; ++event) {
+    const auto& tracks = kine.getTracks(0, event);
+    std::map<int, std::vector<const o2::gtrk::study::HitSegment*>> byTrack;
+    for (const auto& segment : hits.event(event)) {
+      byTrack[segment.track].push_back(&segment);
+    }
+    for (auto& [id, segments] : byTrack) {
+      if (id < 0 || std::cmp_greater_equal(id, tracks.size())) {
+        continue;
+      }
+      const auto& mc = tracks[static_cast<std::size_t>(id)];
+      if ((!options.secondaries && !mc.isPrimary()) || mc.GetPt() < options.minPt) {
+        continue;
+      }
+      std::ranges::sort(segments, {}, &o2::gtrk::study::HitSegment::time);
+      Point previous{.x = {mc.Vx(), mc.Vy(), mc.Vz()}, .p = {mc.Px(), mc.Py(), mc.Pz()}};
+      int previousLayer = -1;
+      std::vector<bool> seen(static_cast<std::size_t>(o2::gtrk::Detector<Det>::nLayers), false);
+      const auto first = steps.size();
+      for (const auto* segment : segments) {
+        const int layer = geometry.sensor(segment->chip).layer;
+        if (layer == previousLayer) {
+          continue; // a second chip of the same layer: an overlap
+        }
+        if (seen[static_cast<std::size_t>(layer)]) {
+          break; // the layer again: a looper's next leg
+        }
+        seen[static_cast<std::size_t>(layer)] = true;
+        const Point entry{.x = segment->start, .p = segment->momentum};
+        steps.push_back({
+          .event = event,
+          .track = id,
+          .pdg = mc.GetPdgCode(),
+          .pt = mc.GetPt(),
+          .eta = mc.GetEta(),
+          .mass = mc.GetMass(),
+          .from = previousLayer,
+          .to = layer,
+          .a = previous,
+          .b = entry,
+        });
+        previous = entry;
+        previousLayer = layer;
+      }
+      if (steps.size() > first) {
+        steps.back().lastOfLeg = true;
+      }
+    }
+    kine.releaseTracksForSourceAndEvent(0, event);
+  }
+  return steps;
+}
+
+struct Sums {
+  std::vector<double> geo;
+  std::vector<double> lut;
+  double geoSum = 0.;
+  double lutSum = 0.;
+  void add(double g, double l)
+  {
+    geo.push_back(g);
+    lut.push_back(l);
+    geoSum += g;
+    lutSum += l;
+  }
+  [[nodiscard]] std::size_t size() const { return geo.size(); }
+  [[nodiscard]] double ratio() const { return geoSum > 0. ? lutSum / geoSum : kNaN; }
+  [[nodiscard]] std::vector<double> ratios() const
+  {
+    std::vector<double> r;
+    r.reserve(geo.size());
+    for (std::size_t i = 0; i < geo.size(); ++i) {
+      if (geo[i] > 1e-6) {
+        r.push_back(lut[i] / geo[i]);
+      }
+    }
+    return r;
+  }
+};
+
+template <o2::gtrk::DetectorLayout Det>
+void report(const Options& options, const std::vector<Step>& steps)
+{
+  // nodes: the far half in and the near half out
+  std::map<int, Sums> nodes;
+  std::map<std::tuple<int, int, bool>, Sums> cells;
+  for (std::size_t i = 0; i + 1 < steps.size(); ++i) {
+    const auto& in = steps[i];
+    const auto& out = steps[i + 1];
+    if (in.lastOfLeg || in.event != out.event || in.track != out.track || in.turn > options.maxTurn || out.turn > options.maxTurn) {
+      continue;
+    }
+    const double g = in.geo[1] + out.geo[0];
+    const double l = in.lut[1] + out.lut[0];
+    nodes[in.to].add(g, l);
+    const auto& x = in.b.x;
+    double phi = std::atan2(x[1], x[0]) * 180. / std::numbers::pi;
+    phi = phi < 0. ? phi + 360. : phi;
+    const bool barrel = o2::gtrk::Detector<Det>::isBarrelLayer(static_cast<LayerID>(in.to));
+    const double coordinate = barrel ? x[2] : std::hypot(x[0], x[1]);
+    cells[{in.to, static_cast<int>(std::floor(phi / options.phiBinDeg)), true}].add(g, l);
+    cells[{in.to, static_cast<int>(std::floor(coordinate / options.coordinateBin)), false}].add(g, l);
+  }
+  std::cout << std::format("\n== nodes: the material the fit applies at each layer's crossing, x/X0 [%]\n");
+  std::cout << std::format("{:>6} {:>8} | {:>8} {:>8} {:>7} | LUT/geometry per node: {:>6} {:>6} {:>6} | {:>9}\n", "layer", "n", "geometry", "LUT", "ratio", "5 %", "median", "95 %", "off 25 %");
+  for (const auto& [layer, sums] : nodes) {
+    if (std::cmp_less(sums.size(), options.minSteps)) {
+      continue;
+    }
+    const auto r = sums.ratios();
+    const auto off = std::ranges::count_if(r, [](double x) { return x < 0.8 || x > 1.25; });
+    std::cout << std::format("{:>6} {:>8} | {:8.4f} {:8.4f} {:7.3f} | {:>22} {:6.3f} {:6.3f} {:6.3f} | {:8.1f}%\n", layerName<Det>(layer), sums.size(), 100. * sums.geoSum / static_cast<double>(sums.size()), 100. * sums.lutSum / static_cast<double>(sums.size()), sums.ratio(), "", quantile(r, 0.05), quantile(r, 0.5), quantile(r, 0.95), r.empty() ? kNaN : 100. * static_cast<double>(off) / static_cast<double>(r.size()));
+  }
+
+  struct StepStats {
+    Sums material;
+    double geoNear = 0.;
+    double lutNear = 0.;
+    std::vector<double> pullGeo;
+    std::vector<double> pullLut;
+  };
+  std::map<std::pair<int, int>, StepStats> pairs;
+  std::size_t turned = 0U;
+  for (const auto& step : steps) {
+    if (step.turn > options.maxTurn) {
+      ++turned;
+      continue;
+    }
+    auto& s = pairs[{step.from, step.to}];
+    s.material.add(step.geo[0] + step.geo[1], step.lut[0] + step.lut[1]);
+    s.geoNear += step.geo[0];
+    s.lutNear += step.lut[0];
+    if (std::abs(step.pdg) == 11) {
+      continue;
+    }
+    const double betaP = betaMomentum(step.a.p, step.mass);
+    const double dTheta = polar(step.b.p) - polar(step.a.p);
+    // the fit's two halves
+    const double geoTheta = std::hypot(highland(step.geo[0], betaP), highland(step.geo[1], betaP));
+    const double lutTheta = std::hypot(highland(step.lut[0], betaP), highland(step.lut[1], betaP));
+    if (geoTheta > 0. && lutTheta > 0.) {
+      s.pullGeo.push_back(dTheta / geoTheta);
+      s.pullLut.push_back(dTheta / lutTheta);
+    }
+  }
+  std::cout << std::format("\n== steps ({} of {} left out: the circle turned more than {} rad from the truth), x/X0 [%]\n", turned, steps.size(), options.maxTurn);
+  std::cout << std::format("{:>13} {:>8} | {:>8} {:>8} {:>7} | near half: {:>5} {:>5} | dtheta/theta0 core, >3: geometry {:>5} {:>5}  LUT {:>5} {:>5}\n", "step", "n", "geometry", "LUT", "ratio", "geo", "LUT", "", "", "", "");
+  for (const auto& [key, s] : pairs) {
+    if (std::cmp_less(s.material.size(), options.minSteps)) {
+      continue;
+    }
+    const double cg = core(s.pullGeo);
+    const double cl = core(s.pullLut);
+    const auto n = static_cast<double>(s.material.size());
+    std::cout << std::format("{:>13} {:>8} | {:8.4f} {:8.4f} {:7.3f} | {:>11} {:5.2f} {:5.2f} | {:>32} {:5.3f} {:5.2f}  {:>3} {:5.3f} {:5.2f}\n", layerName<Det>(key.first) + "->" + layerName<Det>(key.second), s.material.size(), 100. * s.material.geoSum / n, 100. * s.material.lutSum / n, s.material.ratio(), "", s.material.geoSum > 0. ? s.geoNear / s.material.geoSum : kNaN, s.material.lutSum > 0. ? s.lutNear / s.material.lutSum : kNaN, "", cg, beyond(s.pullGeo, cg, 3.), "", cl, beyond(s.pullLut, cl, 3.));
+  }
+
+  std::vector<std::pair<double, std::tuple<int, int, bool>>> ranked;
+  for (const auto& [key, sums] : cells) {
+    if (std::cmp_less(sums.size(), options.minCell) || !(sums.geoSum > 0.)) {
+      continue;
+    }
+    ranked.emplace_back(std::abs(std::log(sums.ratio())), key);
+  }
+  std::ranges::sort(ranked, [](const auto& a, const auto& b) { return a.first > b.first; });
+  std::cout << std::format("\n== worst cells: nodes by layer and azimuth ({} deg) or z / r ({} cm), at least {} nodes, x/X0 [%]\n", options.phiBinDeg, options.coordinateBin, options.minCell);
+  std::cout << std::format("{:>6} {:>24} {:>6} | {:>8} {:>8} {:>7} | LUT/geometry per node {:>6} {:>6} {:>6}\n", "layer", "cell", "n", "geometry", "LUT", "ratio", "5 %", "median", "95 %");
+  for (std::size_t i = 0; i < ranked.size() && std::cmp_less(i, options.worst); ++i) {
+    const auto& [layer, bin, azimuth] = ranked[i].second;
+    const auto& sums = cells.at(ranked[i].second);
+    const bool barrel = o2::gtrk::Detector<Det>::isBarrelLayer(static_cast<LayerID>(layer));
+    const double width = azimuth ? options.phiBinDeg : options.coordinateBin;
+    const char* axis = barrel ? "z" : "r";
+    if (azimuth) {
+      axis = "phi";
+    }
+    const std::string cell = std::format("{} {:.1f} .. {:.1f} {}", axis, bin * width, (bin + 1) * width, azimuth ? "deg" : "cm");
+    const auto r = sums.ratios();
+    const auto n = static_cast<double>(sums.size());
+    std::cout << std::format("{:>6} {:>24} {:>6} | {:8.4f} {:8.4f} {:7.3f} | {:>21} {:6.3f} {:6.3f} {:6.3f}\n", layerName<Det>(layer), cell, sums.size(), 100. * sums.geoSum / n, 100. * sums.lutSum / n, sums.ratio(), "", quantile(r, 0.05), quantile(r, 0.5), quantile(r, 0.95));
+  }
+}
+
+void write(const std::string& path, const std::vector<Step>& steps)
+{
+  const TFile file(path.c_str(), "RECREATE");
+  TTree tree("steps", "o2-gtrk-check-matlut steps");
+  Step s;
+  float ax = 0.F;
+  float ay = 0.F;
+  float az = 0.F;
+  float bx = 0.F;
+  float by = 0.F;
+  float bz = 0.F;
+  float pt = 0.F;
+  float eta = 0.F;
+  float turn = 0.F;
+  float dTheta = 0.F;
+  float betaP = 0.F;
+  std::array<float, 2> geo{};
+  std::array<float, 2> lut{};
+  tree.Branch("event", &s.event);
+  tree.Branch("track", &s.track);
+  tree.Branch("pdg", &s.pdg);
+  tree.Branch("from", &s.from);
+  tree.Branch("to", &s.to);
+  tree.Branch("pt", &pt);
+  tree.Branch("eta", &eta);
+  tree.Branch("ax", &ax);
+  tree.Branch("ay", &ay);
+  tree.Branch("az", &az);
+  tree.Branch("bx", &bx);
+  tree.Branch("by", &by);
+  tree.Branch("bz", &bz);
+  tree.Branch("turn", &turn);
+  tree.Branch("dTheta", &dTheta);
+  tree.Branch("betaP", &betaP);
+  tree.Branch("geo", geo.data(), "geo[2]/F");
+  tree.Branch("lut", lut.data(), "lut[2]/F");
+  for (const auto& step : steps) {
+    s = step;
+    ax = static_cast<float>(step.a.x[0]);
+    ay = static_cast<float>(step.a.x[1]);
+    az = static_cast<float>(step.a.x[2]);
+    bx = static_cast<float>(step.b.x[0]);
+    by = static_cast<float>(step.b.x[1]);
+    bz = static_cast<float>(step.b.x[2]);
+    pt = static_cast<float>(step.pt);
+    eta = static_cast<float>(step.eta);
+    turn = static_cast<float>(step.turn);
+    dTheta = static_cast<float>(polar(step.b.p) - polar(step.a.p));
+    betaP = static_cast<float>(betaMomentum(step.a.p, step.mass));
+    geo = {static_cast<float>(step.geo[0]), static_cast<float>(step.geo[1])};
+    lut = {static_cast<float>(step.lut[0]), static_cast<float>(step.lut[1])};
+    tree.Fill();
+  }
+  tree.Write();
+}
+
+template <o2::gtrk::DetectorLayout Det>
+int runFor(const Options& options)
+{
+  o2::base::GeometryManager::loadGeometry(options.geometry.empty() ? options.sim + "/sgn_geometry.root" : options.geometry);
+  const auto geometry = std::make_unique<const o2::gtrk::Geometry<Det>>(o2::gtrk::alice::placeChecked<Det>());
+  const std::unique_ptr<o2::base::MatLayerCylSet> lut{o2::base::MatLayerCylSet::loadFromFile(options.lut)};
+  if (!lut) {
+    throw std::runtime_error("cannot load the LUT " + options.lut);
+  }
+  int events = 0;
+  auto steps = collect<Det>(options, *geometry, events);
+  std::cout << std::format("{} steps of the particles above {} GeV{} in {} events\n", steps.size(), options.minPt, options.secondaries ? "" : " (primaries)", events);
+
+  int threads = options.threads < 0 ? static_cast<int>(std::thread::hardware_concurrency()) : options.threads;
+  threads = std::max(threads, 1);
+  gGeoManager->SetMaxThreads(threads);
+  std::atomic<std::size_t> next{0};
+  std::vector<std::thread> workers;
+  workers.reserve(static_cast<std::size_t>(threads));
+  for (int thread = 0; thread < threads; ++thread) {
+    workers.emplace_back([&] {
+      TGeoNavigator* navigator = gGeoManager->AddNavigator();
+      for (std::size_t i = next++; i < steps.size(); i = next++) {
+        measure(steps[i], options.pieces, *lut, navigator);
+      }
+      gGeoManager->RemoveNavigator(navigator);
+    });
+  }
+  for (auto& worker : workers) {
+    worker.join();
+  }
+  report<Det>(options, steps);
+  if (!options.output.empty()) {
+    write(options.output, steps);
+  }
+  return 0;
+}
+
+/// The body of main, so that clang-tidy can see that nothing escapes it.
+int run(int argc, char** argv)
+{
+  Options options;
+  bpo::options_description description("Hold a material LUT to the geometry along simulated particles' paths");
+  description.add_options()                                                                                                                            //
+    ("help,h", "this message")                                                                                                                         //
+    ("detector,d", bpo::value(&options.detector)->default_value(options.detector), "ITS, MFT or TRKFT3")                                               //
+    ("sim", bpo::value(&options.sim), "the simulation's directory: sgn_Hits*.root, sgn_Kine.root, sgn_geometry.root")                                  //
+    ("lut", bpo::value(&options.lut), "the material LUT")                                                                                              //
+    ("geometry", bpo::value(&options.geometry), "the geometry, if not <sim>/sgn_geometry.root (the hits' own transport geometry)")                     //
+    ("output,o", bpo::value(&options.output), "write the steps to this ROOT file")                                                                     //
+    ("events,n", bpo::value(&options.events)->default_value(options.events), "the first MC events")                                                    //
+    ("min-pt", bpo::value(&options.minPt)->default_value(options.minPt), "the particles' pT floor [GeV]")                                              //
+    ("secondaries", bpo::bool_switch(&options.secondaries), "every particle, not only primaries")                                                      //
+    ("pieces", bpo::value(&options.pieces)->default_value(options.pieces), "straight pieces per step (even)")                                          //
+    ("max-turn", bpo::value(&options.maxTurn)->default_value(options.maxTurn), "leave out steps whose circle misses the true direction by more [rad]") //
+    ("min-steps", bpo::value(&options.minSteps)->default_value(options.minSteps), "the fewest steps or nodes a table row shows")                       //
+    ("min-cell", bpo::value(&options.minCell)->default_value(options.minCell), "the fewest nodes a worst cell holds")                                  //
+    ("worst", bpo::value(&options.worst)->default_value(options.worst), "how many worst cells")                                                        //
+    ("phi-bin", bpo::value(&options.phiBinDeg)->default_value(options.phiBinDeg), "the worst cells' azimuth bin [deg]")                                //
+    ("coordinate-bin", bpo::value(&options.coordinateBin)->default_value(options.coordinateBin), "the worst cells' z (barrel) or r (disc) bin [cm]")   //
+    ("threads,j", bpo::value(&options.threads)->default_value(options.threads), "threads; negative: all");
+  bpo::variables_map vm;
+  bpo::store(bpo::parse_command_line(argc, argv, description), vm);
+  bpo::notify(vm);
+  if (vm.contains("help")) {
+    std::cout << description << '\n';
+    return 0;
+  }
+  const char* missing = options.sim.empty() ? "--sim is required" : options.lut.empty() ? "--lut is required"
+                                                                                        : nullptr;
+  if (missing == nullptr && (options.pieces < 2 || options.pieces % 2 != 0)) {
+    missing = "--pieces must be even and at least 2";
+  }
+  if (missing != nullptr) {
+    std::cerr << missing << "\n\n"
+              << description << '\n';
+    return 1;
+  }
+  if (options.detector == "TRKFT3") {
+    return runFor<o2::gtrk::detectors::TRKFT3>(options);
+  }
+  if (options.detector == "ITS") {
+    return runFor<o2::gtrk::detectors::ITS>(options);
+  }
+  if (options.detector == "MFT") {
+    return runFor<o2::gtrk::detectors::MFT>(options);
+  }
+  std::cerr << "unknown detector " << options.detector << '\n';
+  return 1;
+}
+
+} // namespace
+
+int main(int argc, char** argv)
+{
+  try {
+    return run(argc, argv);
+  } catch (const std::exception& error) {
+    std::cerr << "error: " << error.what() << '\n';
+    return 1;
+  }
+}
diff --git a/Detectors/GenericTracking/study/tools/clusterClosure.cxx b/Detectors/GenericTracking/study/tools/clusterClosure.cxx
new file mode 100644
index 0000000000000..fd6952ad6da56
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/clusterClosure.cxx
@@ -0,0 +1,706 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file clusterClosure.cxx
+/// \brief Convert one timeframe of O2's ITS or MFT clusters and hold the
+///        result to O2.
+///
+/// Reads a cluster file, the topology dictionary, the geometry and the
+/// digitiser's configuration (for HBFUtils; the readout frames' length is read
+/// off the frames themselves), converts the clusters as the converter device
+/// will (GenericTracking/Alice/Clusters.h), and checks, cluster by cluster:
+///
+/// - the global position through our double geometry against O2's L2G matrix
+///   applied to the same local position in double, and through our float
+///   tracking surfaces against the float position O2's trackers load
+///   (`getMatrixL2G(chip) * locXYZ`);
+/// - the layer against `GeometryTGeo::getLayer`;
+/// - that the position is inside the active matrix, which is what the
+///   in-plane origin shift is for;
+/// - that the time is inside the timeframe, and the labels as many as the
+///   clusters;
+/// - that the pattern's spans hold its pixels: n pixels over r rows and c
+///   columns, r and c at least 1 and n <= r c (not max(r, c) <= n: O2's
+///   clusterer makes a few clusters with rows between their pixels).
+///
+/// It prints the counts per layer, the readout frames and the error spread,
+/// and exits non-zero if a check fails.
+///
+/// For TRKFT3 (-d TRKFT3, --cluster-dictionaries) every barrel layer's and
+/// disc's stream is converted at the dictionaries' measurement depths and held
+/// to O2 the same way, with the frames against the digitiser's configuration;
+/// then each signal cluster against its particle's MC hit on the chip: the
+/// residuals at its layer's measurement depth by sub-detector, axis and span,
+/// with their tails (the clusters without such a hit are counted, not failed).
+///
+/// The closure of GTRK's converter and geometry against O2 on real files:
+/// run it whenever the geometry, the placement or the converter changes.
+
+#include "GenericTracking/Alice/Clusters.h"
+#include "GenericTracking/Study/Alice/Hits.h"
+#include "GenericTracking/Study/Statistics.h"
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Alice/TRK.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Tracking/MeasurementGridBuilder.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tools/SensorFrame.h"
+
+#include "CommonConstants/LHCConstants.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "DataFormatsITSMFT/CompCluster.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "DataFormatsITSMFT/TopologyDictionary.h"
+#include "DataFormatsTRKFT3/Cluster.h"
+#include "DataFormatsTRKFT3/ROFRecord.h"
+#include "DetectorsBase/GeometryManager.h"
+#include "DetectorsRaw/HBFUtils.h"
+#include "ITSBase/GeometryTGeo.h"
+#include "MFTBase/GeometryTGeo.h"
+#include "FT3Base/GeometryTGeo.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "TRKBase/SegmentationChip.h"
+#include "TRKReconstruction/TopologyDictionary.h"
+#include "MathUtils/Cartesian.h"
+#include "MathUtils/Utils.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+
+#include <TFile.h>
+#include <TTree.h>
+
+#include <boost/program_options.hpp>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <exception>
+#include <format>
+#include <functional>
+#include <map>
+#include <iostream>
+#include <limits>
+#include <memory>
+#include <optional>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace bpo = boost::program_options;
+
+namespace o2::gtrk::study
+{
+namespace
+{
+
+constexpr double kDoubleTolerance = 1e-6; // [cm]
+constexpr double kFloatTolerance = 1e-4;  // [cm]
+
+/// The centre of \a cluster's time box [ns from the timeframe's start]: its
+/// readout frame's middle, which the timeframe must hold.
+[[nodiscard]] double boxCentreNS(const Cluster& cluster) { return 1e-3 * (static_cast<double>(cluster.timePS) + (0.5 * static_cast<double>(cluster.widthPS))); }
+
+struct Options {
+  std::string detector;
+  std::string clusters;
+  std::string dictionary;
+  std::string geometry;
+  std::string config;
+  std::string hits;
+  std::string ft3Clusters;
+  std::string ft3Hits;
+  std::string clusterDictionaries;
+};
+
+/// One layer's stream of an ALICE 3 cluster file (TRK's or FT3's).
+template <typename ClusterType>
+struct Alice3Stream {
+  std::vector<ClusterType> compact;
+  std::vector<unsigned char> patterns;
+  std::vector<o2::trkft3::ROFRecord> rofs;
+  o2::dataformats::MCTruthContainer<o2::MCCompLabel> labels;
+};
+
+/// Stream \a stream of \a tree, whose branches start with \a prefix (TRK, FT3).
+template <typename ClusterType>
+Alice3Stream<ClusterType> readStream(TTree& tree, const std::string& prefix, int stream)
+{
+  Alice3Stream<ClusterType> result;
+  auto* compactPtr = &result.compact;
+  auto* patternsPtr = &result.patterns;
+  auto* rofsPtr = &result.rofs;
+  auto* labelsPtr = &result.labels;
+  tree.SetBranchAddress(std::format("{}ClusterComp_{}", prefix, stream).c_str(), &compactPtr);
+  tree.SetBranchAddress(std::format("{}ClusterPatt_{}", prefix, stream).c_str(), &patternsPtr);
+  tree.SetBranchAddress(std::format("{}ClustersROF_{}", prefix, stream).c_str(), &rofsPtr);
+  tree.SetBranchAddress(std::format("{}ClusterMCTruth_{}", prefix, stream).c_str(), &labelsPtr);
+  tree.GetEntry(0);
+  tree.ResetBranchAddresses();
+  return result;
+}
+
+/// The o2sim tree of the cluster file \a path, held open by \a file.
+TTree& clusterTree(const std::string& path, std::unique_ptr<TFile>& file)
+{
+  file.reset(TFile::Open(path.c_str()));
+  if (!file || file->IsZombie()) {
+    throw std::runtime_error("cannot open " + path);
+  }
+  auto* tree = file->Get<TTree>("o2sim");
+  if (tree == nullptr || tree->GetEntries() < 1) {
+    throw std::runtime_error(path + ": no o2sim tree, or an empty one");
+  }
+  return *tree;
+}
+
+/// One timeframe of one detector's cluster file.
+struct ClusterFile {
+  std::vector<o2::itsmft::CompClusterExt> clusters;
+  std::vector<unsigned char> patterns;
+  std::vector<o2::itsmft::ROFRecord> rofs;
+  o2::dataformats::MCTruthContainer<o2::MCCompLabel> labels;
+  bool hasLabels = false;
+};
+
+ClusterFile readClusters(const std::string& path, const std::string& prefix)
+{
+  std::unique_ptr<TFile> file;
+  auto* tree = &clusterTree(path, file);
+  ClusterFile result;
+  auto* clusters = &result.clusters;
+  auto* patterns = &result.patterns;
+  auto* rofs = &result.rofs;
+  auto* labels = &result.labels;
+  tree->SetBranchAddress((prefix + "ClusterComp").c_str(), &clusters);
+  tree->SetBranchAddress((prefix + "ClusterPatt").c_str(), &patterns);
+  tree->SetBranchAddress((prefix + "ClustersROF").c_str(), &rofs);
+  result.hasLabels = tree->GetBranch((prefix + "ClusterMCTruth").c_str()) != nullptr;
+  if (result.hasLabels) {
+    tree->SetBranchAddress((prefix + "ClusterMCTruth").c_str(), &labels);
+  }
+  tree->GetEntry(0);
+  return result;
+}
+
+struct Deviation {
+  double worst = 0.;
+  std::size_t at = 0;
+
+  void add(double value, std::size_t index)
+  {
+    if (value > worst) {
+      worst = value;
+      at = index;
+    }
+  }
+};
+
+template <DetectorLayout Det, typename GeometryTGeo>
+int runFor(const Options& options, GeometryTGeo& o2Geometry, const std::string& prefix)
+{
+  const auto sensors = alice::placeChecked<Det>();
+  const auto geometry = std::make_unique<const Geometry<Det>>(sensors);
+  const auto tracking = std::make_unique<const TrackingGeometry<Det>>(*geometry);
+  o2Geometry.fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+
+  const std::unique_ptr<o2::itsmft::TopologyDictionary> dictionary{o2::itsmft::TopologyDictionary::loadFrom(options.dictionary)};
+  if (!dictionary) {
+    throw std::runtime_error("cannot read the topology dictionary " + options.dictionary);
+  }
+  const auto file = readClusters(options.clusters, prefix);
+  const auto local = alice::localClusters(file.clusters, file.patterns, *dictionary);
+  const auto frames = alice::readoutFrames(file.rofs);
+  const auto& hbf = o2::raw::HBFUtils::Instance();
+  const auto tfFirstOrbit = hbf.getFirstSampledTFIR().orbit;
+  const auto clusters = alice::toClusters(local, file.rofs, frames, tfFirstOrbit);
+  const double durationNS = static_cast<double>(hbf.getNOrbitsPerTF()) * o2::constants::lhc::LHCOrbitNS;
+
+  Deviation exact;
+  Deviation narrow;
+  std::size_t wrongLayer = 0;
+  std::size_t outside = 0;
+  std::size_t outsideTime = 0;
+  std::size_t badSpans = 0;
+  std::vector<std::size_t> perLayer(static_cast<std::size_t>(Detector<Det>::nLayers), 0U);
+  std::vector<float> rowSpans;
+  std::vector<float> colSpans;
+  rowSpans.reserve(clusters.size());
+  colSpans.reserve(clusters.size());
+  std::vector<float> sigmaX;
+  std::vector<float> sigmaY;
+  sigmaX.reserve(clusters.size());
+  sigmaY.reserve(clusters.size());
+  for (std::size_t i = 0; i < clusters.size(); ++i) {
+    const auto& cluster = clusters[i];
+    const auto chip = static_cast<int>(cluster.chipID);
+    const auto& l2g = o2Geometry.getMatrixL2G(chip);
+
+    // Double: O2's matrix and our sensor, on the same local position.
+    const auto o2Double = l2g(o2::math_utils::Point3D<double>{local[i].x, 0., local[i].z});
+    const double ours[3] = {static_cast<double>(cluster.xLocal), static_cast<double>(cluster.yLocal), 0.};
+    double global[3];
+    geometry->toGlobal(cluster.chipID, ours, global);
+    exact.add(std::max({std::abs(global[0] - o2Double.X()), std::abs(global[1] - o2Double.Y()), std::abs(global[2] - o2Double.Z())}), i);
+
+    // Float: what O2's trackers load, and what our tracking surfaces give.
+    const auto o2Float = l2g * o2::math_utils::Point3D<float>{local[i].x, 0.F, local[i].z};
+    const auto& surface = tracking->surface(cluster.chipID);
+    Scalar point[3];
+    surfaceToGlobal(surface, cluster.xLocal, cluster.yLocal, point);
+    narrow.add(std::max({std::abs(static_cast<double>(point[0] - o2Float.X())), std::abs(static_cast<double>(point[1] - o2Float.Y())), std::abs(static_cast<double>(point[2] - o2Float.Z()))}), i);
+
+    const auto layer = geometry->sensor(cluster.chipID).layer;
+    wrongLayer += static_cast<int>(layer) != o2Geometry.getLayer(chip) ? 1U : 0U;
+    // The active area: the float tracking surface's rectangular bounds on
+    // the unrolled coordinates, the ones the tracking reads.
+    outside += surface.bounds.isInside(cluster.xLocal, cluster.yLocal) ? 0U : 1U;
+    outsideTime += boxCentreNS(cluster) < durationNS ? 0U : 1U;
+    const auto rows = static_cast<std::uint32_t>(cluster.rowSpan);
+    const auto columns = static_cast<std::uint32_t>(cluster.colSpan);
+    if (rows == 0U || columns == 0U || local[i].nPixels > rows * columns) {
+      if (badSpans < 10U) {
+        const auto id = file.clusters[i].getPatternID();
+        std::cout << std::format("  spans {} x {} for {} pixels: cluster {}, pattern ID {}{}\n", rows, columns, local[i].nPixels, i, id, id != o2::itsmft::CompCluster::InvalidPatternID && dictionary->isGroup(id) ? ", a group" : "");
+      }
+      ++badSpans;
+    }
+    rowSpans.push_back(static_cast<float>(rows));
+    colSpans.push_back(static_cast<float>(columns));
+    ++perLayer[layer];
+    sigmaX.push_back(cluster.sigmaXLocal);
+    sigmaY.push_back(cluster.sigmaYLocal);
+  }
+
+  std::size_t filled = 0;
+  for (const auto& rof : file.rofs) {
+    filled += rof.getNEntries() > 0 ? 1U : 0U;
+  }
+  // The error spread as quantiles: a few huge clusters own the mean.
+  const auto quantiles = [](std::vector<float> values) {
+    const auto at = [&values](double q) { return values.empty() ? 0. : 1e4 * static_cast<double>(study::quantile(std::span{values}, q)); };
+    return std::format("{:.2f} / {:.2f} / {:.2f} / {:.2f}", at(0.5), at(0.9), at(0.99), at(1.));
+  };
+  const auto spanQuantiles = [](std::vector<float> values) {
+    const auto at = [&values](double q) { return values.empty() ? 0.F : study::quantile(std::span{values}, q); };
+    return std::format("{} / {} / {} / {}", at(0.5), at(0.9), at(0.99), at(1.));
+  };
+  std::cout << std::format("{}: {} clusters in {} readout frames of {} BC ({} with clusters), first TF orbit {}\n", Det::name, clusters.size(), file.rofs.size(), frames.lengthBC, filled, tfFirstOrbit) << std::format("  per layer:");
+  for (std::size_t layer = 0; layer < perLayer.size(); ++layer) {
+    std::cout << std::format(" {}:{}", layer, perLayer[layer]);
+  }
+  std::cout << std::format("\n  sigma across, median / 90 % / 99 % / max: {} um\n", quantiles(sigmaX)) << std::format("  sigma along,  median / 90 % / 99 % / max: {} um\n", quantiles(sigmaY)) << std::format("  double position: worst {:.3g} cm (cluster {}), tolerance {:.0e}\n", exact.worst, exact.at, kDoubleTolerance) << std::format("  float position:  worst {:.3g} cm (cluster {}), tolerance {:.0e}\n", narrow.worst, narrow.at, kFloatTolerance) << std::format("  wrong layer {}, outside the active matrix {}, outside the timeframe {}\n", wrongLayer, outside, outsideTime) << std::format("  rows, median / 90 % / 99 % / max: {}; columns: {}; spans that cannot hold their pixels {}\n", spanQuantiles(rowSpans), spanQuantiles(colSpans), badSpans);
+
+  // Which topologies the errors come from: the most used, with the
+  // dictionary's errors and whether each is a group.
+  std::map<int, std::size_t> use;
+  std::size_t invalid = 0;
+  std::size_t groups = 0;
+  for (const auto& cluster : file.clusters) {
+    const auto id = cluster.getPatternID();
+    if (id == o2::itsmft::CompCluster::InvalidPatternID) {
+      ++invalid;
+      continue;
+    }
+    groups += dictionary->isGroup(id) ? 1U : 0U;
+    ++use[id];
+  }
+  std::vector<std::pair<std::size_t, int>> top;
+  top.reserve(use.size());
+  for (const auto& [id, count] : use) {
+    top.emplace_back(count, id);
+  }
+  std::ranges::sort(top, std::greater{});
+  std::cout << std::format("  topologies: {} used, {} clusters in groups, {} with an invalid ID; the most used:\n", use.size(), groups, invalid);
+  for (std::size_t i = 0; i < std::min<std::size_t>(top.size(), 6U); ++i) {
+    const auto id = top[i].second;
+    std::cout << std::format("    id {:5} x{:7}: {:2} pixels, error {:6.2f} x {:6.2f} um{}\n", id, top[i].first, dictionary->getNpixels(id), 1e4 * static_cast<double>(dictionary->getErrX(id)), 1e4 * static_cast<double>(dictionary->getErrZ(id)), dictionary->isGroup(id) ? ", group" : "");
+  }
+
+  bool ok = exact.worst <= kDoubleTolerance && narrow.worst <= kFloatTolerance && wrongLayer == 0U && outside == 0U && outsideTime == 0U && badSpans == 0U;
+  if (file.hasLabels) {
+    const bool labelled = file.labels.getIndexedSize() == clusters.size();
+    std::cout << std::format("  MC labels for {} of {} clusters\n", file.labels.getIndexedSize(), clusters.size());
+    ok = ok && labelled;
+  }
+  std::cout << (ok ? "closure: pass\n" : "closure: FAIL\n");
+  return ok ? 0 : 1;
+}
+
+/// The spread of residuals [cm]: their count, mean, rms, the core's width,
+/// half the 15.9 - 84.1 % range, which a few delta electrons do not move, and
+/// the fractions further than 3 and 5 core widths from the median: the tails
+/// a fit taking the core as its error meets.
+struct Spread {
+  std::vector<double> values;
+
+  [[nodiscard]] std::string describe() const
+  {
+    if (values.empty()) {
+      return "      -";
+    }
+    auto sorted = values;
+    std::ranges::sort(sorted);
+    double sum = 0.;
+    double sum2 = 0.;
+    for (const double value : sorted) {
+      sum += value;
+      sum2 += value * value;
+    }
+    const auto n = static_cast<double>(sorted.size());
+    const double mean = sum / n;
+    const auto at = [&sorted](double q) { return study::quantile(std::span{sorted}, q); };
+    const double median = at(0.5);
+    const double width = 0.5 * (at(0.841) - at(0.159));
+    const auto beyond = [&](double k) { return 100. * static_cast<double>(std::ranges::count_if(sorted, [&](double value) { return std::abs(value - median) > k * width; })) / n; };
+    // The normalised median absolute deviation beside it: the width the pulls measure (TrackPulls).
+    std::vector<double> deviations(sorted.size());
+    std::ranges::transform(sorted, deviations.begin(), [&](double value) { return std::abs(value - median); });
+    const double mad = 1.4826 * study::median(deviations);
+    return std::format("{:8} {:6.2f} {:6.2f} {:6.2f} {:6.2f} | >3 {:5.2f} % >5 {:5.2f} %", sorted.size(), 1e4 * mean, 1e4 * std::sqrt(std::max(sum2 / n - (mean * mean), 0.)), 1e4 * width, 1e4 * mad, beyond(3.), beyond(5.));
+  }
+};
+
+/// The TRK and FT3: the stream of
+/// every barrel layer and every disc converted on its own, held to O2's centre
+/// of gravity and L2G matrix, to O2's layer, the active area, the digitiser's
+/// frames and the labels; then each signal cluster against its MC hit, the
+/// residuals of its centre of gravity per sub-detector (VD, ML/OT, FT3), axis
+/// and span, at its layer's measurement depth. Every cluster is converted as
+/// the converter device does, by its topology dictionary's entry
+/// (--cluster-dictionaries),
+/// and held to O2's position of the same entry at the layer's depth, our
+/// geometry placed at the dictionaries' depths; the residuals are the
+/// dictionary's, taken at those depths.
+int runTRK(const Options& options)
+{
+  if (options.clusterDictionaries.empty()) {
+    throw std::runtime_error("TRKFT3 needs --cluster-dictionaries");
+  }
+  using Det = detectors::TRKFT3;
+  using Segmentation = o2::trk::SegmentationChip;
+  constexpr int kLayers = Detector<Det>::nLayers;
+  constexpr int kBarrelLayers = Detector<Det>::nBarrelLayers;
+  constexpr auto kFirstDisc = static_cast<std::uint32_t>(Det::kFirstDiscSensor);
+  auto& o2Geometry = *o2::trk::GeometryTGeo::Instance();
+  o2Geometry.fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+  auto& ft3Geometry = *o2::ft3::GeometryTGeo::Instance();
+  ft3Geometry.fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+  // The dictionaries' CCDB snapshots below the directory, as the devices take them.
+  const auto load = [&]<typename Dictionary>(std::unique_ptr<Dictionary>& dictionary, const char* path) { dictionary.reset(Dictionary::loadFrom(options.clusterDictionaries + "/" + path + "/snapshot.root")); };
+  std::unique_ptr<alice::TrkDictionary> trkDictionary;
+  std::unique_ptr<alice::Ft3Dictionary> ft3Dictionary;
+  load(trkDictionary, "TRK/Calib/ClusterDictionary");
+  load(ft3Dictionary, "FT3/Calib/ClusterDictionary");
+  const auto depths = alice::measurementDepthsCM(*trkDictionary, *ft3Dictionary);
+  const auto geometry = std::make_unique<const Geometry<Det>>(alice::placeChecked<Det>(), depths);
+  // The digitiser's frames, from its configuration.
+  o2::conf::ConfigurableParam::updateFromFile(options.config, "TRKAlmiraParam");
+  const auto frames = alice::trkFrameTiming();
+  const auto& hbf = o2::raw::HBFUtils::Instance();
+  const auto tfFirstOrbit = hbf.getFirstSampledTFIR().orbit;
+  const double durationNS = static_cast<double>(hbf.getNOrbitsPerTF()) * o2::constants::lhc::LHCOrbitNS;
+
+  std::unique_ptr<TFile> trkFile;
+  std::unique_ptr<TFile> ft3File;
+  auto& trkTree = clusterTree(options.clusters, trkFile);
+  auto& ft3Tree = clusterTree(options.ft3Clusters, ft3File);
+  study::HitFile hits(options.hits, study::Chips::kTRK, options.ft3Hits);
+  // Each event's hits by (track, chip), in file order, built on first use:
+  // a signal cluster looks up its particle's crossings of its chip without
+  // scanning its event (Pb-Pb events are large).
+  using HitIndex = std::unordered_map<std::uint64_t, std::vector<const study::HitSegment*>>;
+  const auto hitKey = [](int track, std::uint32_t chip) { return (static_cast<std::uint64_t>(static_cast<std::uint32_t>(track)) << 32U) | chip; };
+  std::vector<std::optional<HitIndex>> hitIndex(static_cast<std::size_t>(hits.nEvents()));
+  const auto segmentsOf = [&](int event, int track, std::uint32_t chip) -> const std::vector<const study::HitSegment*>* {
+    if (event < 0 || event >= hits.nEvents()) {
+      return nullptr;
+    }
+    auto& index = hitIndex[static_cast<std::size_t>(event)];
+    if (!index) {
+      index.emplace();
+      for (const auto& segment : hits.event(event)) {
+        (*index)[hitKey(segment.track, segment.chip)].push_back(&segment);
+      }
+    }
+    const auto found = index->find(hitKey(track, chip));
+    return found == index->end() ? nullptr : &found->second;
+  };
+
+  Deviation exact;
+  Deviation narrow;
+  std::size_t total = 0;
+  std::size_t wrongLayer = 0;
+  std::size_t outside = 0;
+  std::size_t outsideTime = 0;
+  std::size_t badFrames = 0;
+  std::size_t unlabelled = 0;
+  std::size_t signal = 0;
+  std::size_t noHit = 0;
+  // Every signal cluster with its particle's hit on its chip: the cluster's
+  // unrolled position, the hit's two ends unrolled (across, along, depth),
+  // its sub-detector and its spans.
+  struct Match {
+    int layer = 0;
+    int subDet = 0;
+    int rowSpan = 0;
+    int colSpan = 0;
+    std::array<double, 2> cluster{};
+    std::array<std::array<double, 3>, 2> ends{};
+  };
+  std::vector<Match> matches;
+  std::cout << "TRKFT3 layer | clusters | frames: records' length, configured length@first start\n";
+  // One layer's stream: TRK's barrel layer, or FT3's disc after them.
+  const auto checkLayer = [&]<typename ClusterType>(int layer, const Alice3Stream<ClusterType>& stream) {
+    constexpr bool kDisc = std::is_same_v<ClusterType, o2::trkft3::FT3Cluster>;
+    const auto& [compact, patterns, rofs, labels] = stream;
+    const auto local = [&]() {
+      if constexpr (kDisc) {
+        return alice::ft3LocalClusters(compact, patterns, *ft3Dictionary);
+      } else {
+        return alice::trkLocalClusters(compact, patterns, *trkDictionary);
+      }
+    }();
+    const auto spacing = alice::readoutFrames(std::span<const o2::trkft3::ROFRecord>{rofs});
+    badFrames += spacing.lengthBC != frames[static_cast<std::size_t>(layer)].lengthBC ? 1U : 0U;
+    const auto clusters = alice::toClusters(local, std::span<const o2::trkft3::ROFRecord>{rofs}, spacing, tfFirstOrbit);
+    unlabelled += labels.getIndexedSize() == clusters.size() ? 0U : 1U;
+    std::cout << std::format("{:9} | {:8} | {:3} BC, {}@{}\n", layer, clusters.size(), spacing.lengthBC, frames[static_cast<std::size_t>(layer)].lengthBC, frames[static_cast<std::size_t>(layer)].firstStartBC);
+
+    std::size_t offset = 0;
+    for (std::size_t i = 0; i < clusters.size(); ++i, ++total) {
+      const auto& cluster = clusters[i];
+      const auto& o2Cluster = compact[i];
+      const auto* pattern = patterns.data() + offset;
+      const std::size_t bytes = 2U + ((static_cast<std::size_t>(pattern[0]) * pattern[1] + 7U) / 8U);
+      offset += bytes;
+      const auto chip = static_cast<int>(kDisc ? cluster.chipID - kFirstDisc : cluster.chipID); // O2's
+      const auto& l2g = kDisc ? ft3Geometry.getMatrixL2G(chip) : o2Geometry.getMatrixL2G(chip);
+
+      // O2's position: its dictionary entry's at the layer's depth, curved on
+      // the VD, through its matrix.
+      const auto o2Local = [&]() {
+        if constexpr (kDisc) {
+          return ft3Dictionary->getClusterCoordinates(o2Cluster, pattern);
+        } else {
+          return trkDictionary->getClusterCoordinates(o2Cluster, pattern);
+        }
+      }();
+      const auto o2Double = l2g(o2::math_utils::Point3D<double>{o2Local.X(), o2Local.Y(), o2Local.Z()});
+      const auto& spec = geometry->specOf(cluster.chipID);
+      double frame[3];
+      spec.unrolledToFrame(static_cast<double>(cluster.xLocal), static_cast<double>(cluster.yLocal), geometry->measurementDepth(geometry->sensor(cluster.chipID).layer), frame);
+      double global[3];
+      geometry->toGlobal(cluster.chipID, frame, global);
+      exact.add(std::max({std::abs(global[0] - o2Double.X()), std::abs(global[1] - o2Double.Y()), std::abs(global[2] - o2Double.Z())}), total);
+      // Float: what O2's tracker loads, and what our producer ships.
+      const auto o2Float = l2g * o2Local;
+      const auto point = gridPoint<Det>(*geometry, cluster.chipID, static_cast<double>(cluster.xLocal), static_cast<double>(cluster.yLocal));
+      narrow.add(std::max({std::abs(static_cast<double>(point.x - o2Float.X())), std::abs(static_cast<double>(point.y - o2Float.Y())), std::abs(static_cast<double>(point.z - o2Float.Z()))}), total);
+
+      const auto ourLayer = static_cast<int>(geometry->sensor(cluster.chipID).layer);
+      const int o2Layer = kDisc ? kBarrelLayers + ft3Geometry.getLayer(chip) : o2Geometry.getLayerTRK(chip);
+      wrongLayer += ourLayer != layer || ourLayer != o2Layer ? 1U : 0U;
+      // The active area: the double sensor spec's rectangular bounds on the
+      // unrolled coordinates (a curved VD sensor's too).
+      outside += tools::contains(spec, static_cast<double>(cluster.xLocal), static_cast<double>(cluster.yLocal)) ? 0U : 1U;
+      outsideTime += boxCentreNS(cluster) < durationNS ? 0U : 1U;
+
+      // The residual to the MC hit of its first signal label, at the middle
+      // of the hit's path through the silicon, in the unrolled frame.
+      const o2::MCCompLabel* label = nullptr;
+      if (i < labels.getIndexedSize()) {
+        for (const auto& candidate : labels.getLabels(static_cast<std::uint32_t>(i))) {
+          if (candidate.isValid() && !candidate.isNoise() && candidate.getSourceID() == 0) {
+            label = &candidate;
+            break;
+          }
+        }
+      }
+      if (label == nullptr) {
+        continue;
+      }
+      ++signal;
+      // The particle's crossing of the chip: the segment whose middle is
+      // nearest the cluster, where several (a looper's).
+      double best = std::numeric_limits<double>::max();
+      bool found = false;
+      Match match{
+        .layer = layer,
+        .subDet = o2Cluster.subDetID,
+        .rowSpan = pattern[0],
+        .colSpan = pattern[1],
+        .cluster = {static_cast<double>(cluster.xLocal), static_cast<double>(cluster.yLocal)},
+      };
+      static const std::vector<const study::HitSegment*> kNone;
+      const auto* crossings = segmentsOf(label->getEventID(), label->getTrackID(), cluster.chipID);
+      for (const auto* segment : crossings != nullptr ? *crossings : kNone) {
+        std::array<std::array<double, 3>, 2> ends{};
+        for (std::size_t end = 0; end < 2; ++end) {
+          double hitFrame[3];
+          tools::toLocal(geometry->sensor(cluster.chipID), end == 0 ? segment->start.data() : segment->end.data(), hitFrame);
+          tools::frameToUnrolled(spec, hitFrame, ends[end].data());
+        }
+        const double distance = std::hypot(match.cluster[0] - (0.5 * (ends[0][0] + ends[1][0])), match.cluster[1] - (0.5 * (ends[0][1] + ends[1][1])));
+        if (distance < best) {
+          best = distance;
+          match.ends = ends;
+          found = true;
+        }
+      }
+      if (!found) {
+        ++noHit;
+        continue;
+      }
+      matches.push_back(match);
+    }
+  };
+  for (int layer = 0; layer < kLayers; ++layer) {
+    if (layer < kBarrelLayers) {
+      checkLayer(layer, readStream<o2::trkft3::TRKCluster>(trkTree, "TRK", layer));
+    } else {
+      checkLayer(layer, readStream<o2::trkft3::FT3Cluster>(ft3Tree, "FT3", layer - kBarrelLayers));
+    }
+  }
+
+  std::cout << std::format(
+                 "TRKFT3: {} clusters; double position: worst {:.3g} cm (cluster {}), tolerance {:.0e}; float position: worst {:.3g} cm "
+                 "(cluster {}), tolerance {:.0e}\n",
+                 total, exact.worst, exact.at, kDoubleTolerance, narrow.worst, narrow.at, kFloatTolerance)
+            << std::format(
+                 "  wrong layer {}, outside the active area {}, outside the timeframe {}, layers with other frames than configured {}, "
+                 "layers whose labels do not match {}\n",
+                 wrongLayer, outside, outsideTime, badFrames, unlabelled)
+            << std::format("  signal clusters {}, without their particle's hit on the chip {}\n", signal, noHit);
+
+  // The residuals, cluster minus the particle's crossing of the plane at
+  // its layer's measurement depth -- the dictionaries', the converter's
+  // (the hit's ends interpolated) [um], by sub-detector, axis and span, with
+  // the tails a fit taking the core as its error meets. Every signal cluster
+  // counts, at the matrix's edge and the pieces of a split crossing too
+  // (where O2's CheckTopologyDictionary.C leaves them out).
+  constexpr std::size_t kSubDets = 3;
+  const std::array<const char*, kSubDets> subDets{"VD", "ML/OT", "FT3"};
+  const std::array<std::array<double, 2>, kSubDets> pitches{{{static_cast<double>(Segmentation::PitchRowVD), static_cast<double>(Segmentation::PitchColVD)}, {static_cast<double>(Segmentation::PitchRowMLOT), static_cast<double>(Segmentation::PitchColMLOT)}, {static_cast<double>(Segmentation::PitchRowMLOT), static_cast<double>(Segmentation::PitchColMLOT)}}};
+  const auto residualAt = [](const Match& match, double depth) {
+    const auto& [a, b] = match.ends;
+    // On the segment: a particle that starts or stops in the silicon
+    // crosses no deeper plane than its own end.
+    const double t = std::abs(b[2] - a[2]) > 1e-9 ? std::clamp((depth - a[2]) / (b[2] - a[2]), 0., 1.) : 0.5;
+    return std::array<double, 2>{match.cluster[0] - (a[0] + (t * (b[0] - a[0]))), match.cluster[1] - (a[1] + (t * (b[1] - a[1])))};
+  };
+  std::cout << "  each layer's measurement depth, the dictionaries' (our unrolled z) [um]:";
+  for (int layer = 0; layer < kLayers; ++layer) {
+    std::cout << std::format(" {}:{:.1f}", layer, 1e4 * geometry->measurementDepth(static_cast<LayerID>(layer)));
+  }
+  std::cout << '\n';
+
+  const std::array<const char*, 2> axes{"across (rows)", "along (columns)"};
+  constexpr std::size_t kSpans = 7; // 1-5, 6+; 0 every span
+  std::array<std::array<std::array<Spread, kSpans>, 2>, kSubDets> residuals{};
+  for (const auto& match : matches) {
+    const auto subDet = static_cast<std::size_t>(match.subDet);
+    const auto residual = residualAt(match, geometry->measurementDepth(static_cast<LayerID>(match.layer)));
+    const std::array<int, 2> spans{match.rowSpan, match.colSpan};
+    for (std::size_t axis = 0; axis < 2; ++axis) {
+      residuals[subDet][axis][0].values.push_back(residual[axis]);
+      residuals[subDet][axis][static_cast<std::size_t>(std::min(spans[axis], 6))].values.push_back(residual[axis]);
+    }
+  }
+  std::cout << "  residuals at each layer's measurement depth [um]: clusters, mean, rms, core (half the 68 % range), 1.4826 MAD\n";
+  for (std::size_t subDet = 0; subDet < kSubDets; ++subDet) {
+    for (std::size_t axis = 0; axis < 2; ++axis) {
+      const double pitch = 1e4 * pitches[subDet][axis];
+      std::cout << std::format("  {} {}: pitch {:.1f}, pitch/sqrt(12) {:.2f}, pitch/2 {:.2f}\n", subDets[subDet], axes[axis], pitch, pitch / std::sqrt(12.), 0.5 * pitch) << std::format("    every span {}\n", residuals[subDet][axis][0].describe());
+      for (std::size_t span = 1; span < kSpans; ++span) {
+        std::cout << std::format("    span {}{} {}\n", span, span + 1 == kSpans ? "+" : " ", residuals[subDet][axis][span].describe());
+      }
+    }
+  }
+
+  const bool ok = exact.worst <= kDoubleTolerance && narrow.worst <= kFloatTolerance && wrongLayer == 0U && outside == 0U && outsideTime == 0U && badFrames == 0U && unlabelled == 0U;
+  std::cout << (ok ? "closure: pass\n" : "closure: FAIL\n");
+  return ok ? 0 : 1;
+}
+
+int run(int argc, char** argv)
+{
+  Options options;
+  bpo::options_description description("Convert one timeframe of O2's ITS, MFT or TRKFT3 clusters and hold the result to O2");
+  description.add_options()                                                                                                                                   //
+    ("help,h", "this message")                                                                                                                                //
+    ("detector,d", bpo::value(&options.detector)->default_value("ITS"), "ITS, MFT or TRKFT3")                                                                 //
+    ("clusters,c", bpo::value(&options.clusters)->default_value(""), "cluster file; o2clus_its.root, mftclusters.root or o2clus_trk.root if empty")           //
+    ("dictionary", bpo::value(&options.dictionary)->default_value(""), "ITS, MFT: topology dictionary (a CCDB snapshot)")                                     //
+    ("hits", bpo::value(&options.hits)->default_value("sgn_HitsTRK.root"), "TRKFT3: the MC hits the residuals are taken to")                                  //
+    ("ft3-clusters", bpo::value(&options.ft3Clusters)->default_value("o2clus_ft3.root"), "TRKFT3: FT3's cluster file, the discs'")                            //
+    ("ft3-hits", bpo::value(&options.ft3Hits)->default_value("sgn_HitsFT3.root"), "TRKFT3: FT3's MC hits")                                                    //
+    ("cluster-dictionaries", bpo::value(&options.clusterDictionaries)->default_value(""), "TRKFT3: the topology dictionaries' snapshot directory (required)") //
+    ("geometry,g", bpo::value(&options.geometry)->default_value("o2sim_geometry-aligned.root"), "o2sim geometry")                                             //
+    ("config", bpo::value(&options.config)->default_value("o2simdigitizerworkflow_configuration.ini"), "the digitiser's configuration, for HBFUtils (and the TRK's frames)");
+  bpo::variables_map vm;
+  try {
+    bpo::store(bpo::parse_command_line(argc, argv, description), vm);
+    if (vm.contains("help")) {
+      std::cout << description << '\n';
+      return 0;
+    }
+    bpo::notify(vm);
+  } catch (const bpo::error& error) {
+    std::cerr << error.what() << "\n\n"
+              << description << '\n';
+    return 1;
+  }
+
+  o2::conf::ConfigurableParam::updateFromFile(options.config, "HBFUtils");
+  o2::base::GeometryManager::loadGeometry(options.geometry);
+  if (options.detector == "TRKFT3") {
+    if (options.clusters.empty()) {
+      options.clusters = "o2clus_trk.root";
+    }
+    return runTRK(options);
+  }
+  if (options.dictionary.empty()) {
+    throw std::runtime_error("the ITS and the MFT need --dictionary");
+  }
+  if (options.detector == "ITS") {
+    if (options.clusters.empty()) {
+      options.clusters = "o2clus_its.root";
+    }
+    return runFor<detectors::ITS>(options, *o2::its::GeometryTGeo::Instance(), "ITS");
+  }
+  if (options.detector == "MFT") {
+    if (options.clusters.empty()) {
+      options.clusters = "mftclusters.root";
+    }
+    return runFor<detectors::MFT>(options, *o2::mft::GeometryTGeo::Instance(), "MFT");
+  }
+  std::cerr << "unknown detector '" << options.detector << "'\n";
+  return 1;
+}
+
+} // namespace
+} // namespace o2::gtrk::study
+
+int main(int argc, char** argv)
+{
+  try {
+    return o2::gtrk::study::run(argc, argv);
+  } catch (const std::exception& error) {
+    std::cerr << "error: " << error.what() << '\n';
+    return 1;
+  }
+}
diff --git a/Detectors/GenericTracking/study/tools/fitBench.cxx b/Detectors/GenericTracking/study/tools/fitBench.cxx
new file mode 100644
index 0000000000000..2d5292eb37630
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/fitBench.cxx
@@ -0,0 +1,241 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file fitBench.cxx
+/// \brief o2-gtrk-fit-bench: the triplet and the adjacent-triplet fit alone.
+///
+/// Reads what `o2-gtrk-track-bench
+/// --fit-inputs` wrote -- every accepted triplet and neighbour of a run -- and
+/// runs the two fits over all of them, again and again, on one thread: the
+/// time per call, and for the triplet fit the part in the kinks and their
+/// gradient. It checks that every triplet's curvature and
+/// variance are the stage's, bit for bit, and that every record passes its
+/// chi2 bound, and prints a digest of every result: a faster fit must leave
+/// the digests alone.
+
+#include "FitInputs.h"
+#include <boost/program_options.hpp>
+
+#include "GenericTracking/Study/Digest.h"
+#include "GenericTracking/Tracking/TripletFit.h"
+#include "GenericTracking/Study/Validation.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <exception>
+#include <format>
+#include <iostream>
+#include <limits>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk::study
+{
+namespace
+{
+
+namespace bpo = boost::program_options;
+using study::NeighbourFitInput;
+using study::TripletFitInput;
+
+/// Where the timed loops' results go, so that none of their work is left out.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+volatile Scalar gSink = 0.F;
+
+/// The shortest of \a repeat runs of \a body, in seconds; \a body returns a
+/// value that depends on all its work.
+template <typename Body>
+double shortest(unsigned repeat, const Body& body)
+{
+  double best = std::numeric_limits<double>::infinity();
+  Scalar sink = 0.F;
+  for (unsigned run = 0; run < repeat; ++run) {
+    const auto start = std::chrono::steady_clock::now();
+    sink += body();
+    best = std::min(best, std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count());
+  }
+  gSink = sink;
+  return best;
+}
+
+[[nodiscard]] bool fitTripletInput(const TripletFitInput& input, TripletFitResult& result)
+{
+  TripletFitFactor factor;
+  return makeTripletFitFactor(input.first, input.middle, input.third, input.variance, factor) && fitTriplet(factor, result);
+}
+
+[[nodiscard]] bool fitNeighbourInput(const NeighbourFitInput& input, TripletFitResult& result)
+{
+  KinkTerms first;
+  KinkTerms second;
+  return makeKinkTerms(input.a, input.b, input.c, first) && makeKinkTerms(input.b, input.c, input.d, second) && fitAdjacentTriplets(first, second, input.a, input.b, input.c, input.d, input.varianceSecond, input.varianceThird, result, input.covariance);
+}
+
+void addResult(Digest& digest, bool fitted, const TripletFitResult& result)
+{
+  digest.add(static_cast<std::uint32_t>(fitted));
+  digest.add(result.curvature);
+  digest.add(result.varCurvature);
+  digest.add(result.chi2);
+}
+
+double perCall(double seconds, std::size_t calls) { return calls == 0U ? 0. : seconds * 1.e9 / static_cast<double>(calls); }
+
+void benchTriplets(const std::vector<TripletFitInput>& inputs, unsigned repeat)
+{
+  Digest digest;
+  std::size_t same = 0U;
+  std::size_t passed = 0U;
+  for (const auto& input : inputs) {
+    TripletFitResult result;
+    const bool fitted = fitTripletInput(input, result);
+    addResult(digest, fitted, result);
+    same += static_cast<std::size_t>(fitted && std::bit_cast<std::uint32_t>(result.curvature) == std::bit_cast<std::uint32_t>(input.curvature) && std::bit_cast<std::uint32_t>(result.varCurvature) == std::bit_cast<std::uint32_t>(input.varCurvature));
+    passed += static_cast<std::size_t>(fitted && result.chi2 <= input.chi2Max);
+  }
+
+  const double fit = shortest(repeat, [&] {
+    Scalar sum = 0.F;
+    for (const auto& input : inputs) {
+      TripletFitResult result;
+      if (fitTripletInput(input, result)) {
+        sum += result.curvature;
+      }
+    }
+    return sum;
+  });
+  const double gradient = shortest(repeat, [&] {
+    Scalar sum = 0.F;
+    for (const auto& input : inputs) {
+      sum += kinkGradient(input.first, input.middle, input.third).theta[0];
+    }
+    return sum;
+  });
+
+  const double fitNS = perCall(fit, inputs.size());
+  const double gradientNS = perCall(gradient, inputs.size());
+  std::cout << std::format("triplets: {} records; fit {:.1f} ns/call: the kinks and their gradient {:.1f} ns ({:.0f} %), the rest {:.1f} ns\n", inputs.size(), fitNS, gradientNS, fitNS > 0. ? 100. * gradientNS / fitNS : 0., fitNS - gradientNS);
+  std::cout << std::format("  digest {:016x}; the stage's curvature and variance {}/{}, within the chi2 bound {}/{}\n", digest.result(), same, inputs.size(), passed, inputs.size());
+}
+
+void benchNeighbours(const std::vector<NeighbourFitInput>& inputs, unsigned repeat)
+{
+  Digest digest;
+  std::size_t passed = 0U;
+  for (const auto& input : inputs) {
+    TripletFitResult result;
+    const bool fitted = fitNeighbourInput(input, result);
+    addResult(digest, fitted, result);
+    passed += static_cast<std::size_t>(fitted && result.chi2 <= input.chi2Max);
+  }
+
+  const double fit = shortest(repeat, [&] {
+    Scalar sum = 0.F;
+    for (const auto& input : inputs) {
+      TripletFitResult result;
+      if (fitNeighbourInput(input, result)) {
+        sum += result.chi2;
+      }
+    }
+    return sum;
+  });
+
+  // From the two triplets' kink terms, computed here beforehand: the fit's
+  // time alone, without making them (the stage makes them from the points).
+  // A record whose terms cannot be made fails here as in the fit from the
+  // points.
+  std::vector<std::array<KinkTerms, 2>> terms(inputs.size());
+  std::vector<std::uint8_t> made(inputs.size(), 0U);
+  for (std::size_t record = 0; record < inputs.size(); ++record) {
+    const auto& input = inputs[record];
+    made[record] = makeKinkTerms(input.a, input.b, input.c, terms[record][0]) && makeKinkTerms(input.b, input.c, input.d, terms[record][1]) ? 1U : 0U;
+  }
+  const auto fromTerms = [&](std::size_t record, TripletFitResult& result) {
+    const auto& input = inputs[record];
+    return made[record] != 0U && fitAdjacentTriplets(terms[record][0], terms[record][1], input.a, input.b, input.c, input.d, input.varianceSecond, input.varianceThird, result, input.covariance);
+  };
+  Digest storedDigest;
+  for (std::size_t record = 0; record < inputs.size(); ++record) {
+    TripletFitResult result;
+    const bool fitted = fromTerms(record, result);
+    addResult(storedDigest, fitted, result);
+  }
+  const double stored = shortest(repeat, [&] {
+    Scalar sum = 0.F;
+    for (std::size_t record = 0; record < inputs.size(); ++record) {
+      TripletFitResult result;
+      if (fromTerms(record, result)) {
+        sum += result.chi2;
+      }
+    }
+    return sum;
+  });
+  std::cout << std::format("neighbours: {} records; fit {:.1f} ns/call, from the triplets' stored terms {:.1f} ns/call\n", inputs.size(), perCall(fit, inputs.size()), perCall(stored, inputs.size()));
+  std::cout << std::format("  digest {:016x}, from the stored terms {:016x}; within the chi2 bound {}/{}\n", digest.result(), storedDigest.result(), passed, inputs.size());
+}
+
+int run(int argc, char** argv)
+{
+  std::string input;
+  unsigned repeat = 5U;
+  std::string which;
+  bpo::options_description description("Run the triplet and the adjacent-triplet fit alone");
+  description.add_options()                                                                                     //
+    ("help,h", "this message")                                                                                  //
+    ("input,i", bpo::value(&input)->default_value("fit-inputs.bin"), "o2-gtrk-track-bench --fit-inputs's file") //
+    ("repeat,n", bpo::value(&repeat)->default_value(5U), "runs of each loop; the shortest counts")              //
+    ("fits", bpo::value(&which)->default_value("all"), "triplets, neighbours or all");
+
+  bpo::variables_map vm;
+  try {
+    bpo::store(bpo::parse_command_line(argc, argv, description), vm);
+    bpo::notify(vm);
+  } catch (const bpo::error& error) {
+    std::cerr << error.what() << "\n\n"
+              << description << '\n';
+    return 1;
+  }
+  if (vm.contains("help")) {
+    std::cout << description << '\n';
+    return 0;
+  }
+  if (which != "all" && which != "triplets" && which != "neighbours") {
+    std::cerr << "--fits: triplets, neighbours or all, not " << which << "\n\n"
+              << description << '\n';
+    return 1;
+  }
+
+  const auto inputs = study::readFitInputs(input);
+  if (which == "all" || which == "triplets") {
+    benchTriplets(inputs.triplets, std::max(repeat, 1U));
+  }
+  if (which == "all" || which == "neighbours") {
+    benchNeighbours(inputs.neighbours, std::max(repeat, 1U));
+  }
+  return 0;
+}
+
+} // namespace
+} // namespace o2::gtrk::study
+
+int main(int argc, char** argv)
+{
+  try {
+    return o2::gtrk::study::run(argc, argv);
+  } catch (const std::exception& error) {
+    std::cerr << "error: " << error.what() << '\n';
+    return 1;
+  }
+}
diff --git a/Detectors/GenericTracking/study/tools/gtrk-its-study-workflow.cxx b/Detectors/GenericTracking/study/tools/gtrk-its-study-workflow.cxx
new file mode 100644
index 0000000000000..b249b9d84feb0
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/gtrk-its-study-workflow.cxx
@@ -0,0 +1,48 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file gtrk-its-study-workflow.cxx
+/// \brief The ITS's clusters from O2's reader or upstream, with the study's sink (StudyWorkflow.h).
+
+#include "StudyWorkflow.h"
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/CallbacksPolicy.h"
+
+using namespace o2::framework;
+
+// DPL looks both of these up by symbol before runDataProcessing.h is included,
+// so they have to keep external linkage.
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::CallbacksPolicy>& policies) { o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies); }
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions) { o2::gtrk::study::addStudyOptions(workflowOptions); }
+
+#include "GenericTracking/Detectors/ITS.h"
+
+#include "ITSMFTWorkflow/ClusterReaderSpec.h"
+
+#include <string>
+
+#include "Framework/runDataProcessing.h" // IWYU pragma: keep
+
+WorkflowSpec defineDataProcessing(const ConfigContext& context)
+{
+  o2::conf::ConfigurableParam::updateFromString(context.options().get<std::string>("configKeyValues"));
+
+  const bool useMC = !context.options().get<bool>("disable-mc");
+  auto specs = o2::gtrk::study::studyChain<o2::gtrk::detectors::ITS>(context, {o2::itsmft::getITSClusterReaderSpec(useMC, false, true, false)});
+
+  const o2::raw::HBFUtilsInitializer hbfIni(context, specs);
+
+  return specs;
+}
diff --git a/Detectors/GenericTracking/study/tools/gtrk-mft-study-workflow.cxx b/Detectors/GenericTracking/study/tools/gtrk-mft-study-workflow.cxx
new file mode 100644
index 0000000000000..2a5e060e598d8
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/gtrk-mft-study-workflow.cxx
@@ -0,0 +1,48 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file gtrk-mft-study-workflow.cxx
+/// \brief The MFT's clusters from O2's reader or upstream, with the study's sink (StudyWorkflow.h).
+
+#include "StudyWorkflow.h"
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/CallbacksPolicy.h"
+
+using namespace o2::framework;
+
+// DPL looks both of these up by symbol before runDataProcessing.h is included,
+// so they have to keep external linkage.
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::CallbacksPolicy>& policies) { o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies); }
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions) { o2::gtrk::study::addStudyOptions(workflowOptions); }
+
+#include "GenericTracking/Detectors/MFT.h"
+
+#include "ITSMFTWorkflow/ClusterReaderSpec.h"
+
+#include <string>
+
+#include "Framework/runDataProcessing.h" // IWYU pragma: keep
+
+WorkflowSpec defineDataProcessing(const ConfigContext& context)
+{
+  o2::conf::ConfigurableParam::updateFromString(context.options().get<std::string>("configKeyValues"));
+
+  const bool useMC = !context.options().get<bool>("disable-mc");
+  auto specs = o2::gtrk::study::studyChain<o2::gtrk::detectors::MFT>(context, {o2::itsmft::getMFTClusterReaderSpec(useMC, false, true, false)});
+
+  const o2::raw::HBFUtilsInitializer hbfIni(context, specs);
+
+  return specs;
+}
diff --git a/Detectors/GenericTracking/study/tools/gtrk-trk-study-workflow.cxx b/Detectors/GenericTracking/study/tools/gtrk-trk-study-workflow.cxx
new file mode 100644
index 0000000000000..21843806b135a
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/gtrk-trk-study-workflow.cxx
@@ -0,0 +1,48 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file gtrk-trk-study-workflow.cxx
+/// \brief ALICE 3's TRK and FT3 clusters from O2's readers or upstream, with the study's sink (StudyWorkflow.h).
+
+#include "StudyWorkflow.h"
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/CallbacksPolicy.h"
+
+using namespace o2::framework;
+
+// DPL looks both of these up by symbol before runDataProcessing.h is included,
+// so they have to keep external linkage.
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::CallbacksPolicy>& policies) { o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies); }
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions) { o2::gtrk::study::addStudyOptions(workflowOptions); }
+
+#include "GenericTracking/Detectors/TRKFT3.h"
+
+#include "TRKWorkflow/ClusterReaderSpec.h"
+
+#include <string>
+
+#include "Framework/runDataProcessing.h" // IWYU pragma: keep
+
+WorkflowSpec defineDataProcessing(const ConfigContext& context)
+{
+  o2::conf::ConfigurableParam::updateFromString(context.options().get<std::string>("configKeyValues"));
+
+  const bool useMC = !context.options().get<bool>("disable-mc");
+  auto specs = o2::gtrk::study::studyChain<o2::gtrk::detectors::TRKFT3>(context, {o2::trk::getTRKClusterReaderSpec(useMC), o2::trk::getFT3ClusterReaderSpec(useMC)});
+
+  const o2::raw::HBFUtilsInitializer hbfIni(context, specs);
+
+  return specs;
+}
diff --git a/Detectors/GenericTracking/study/tools/trackBench.cxx b/Detectors/GenericTracking/study/tools/trackBench.cxx
new file mode 100644
index 0000000000000..399304e0c0e79
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/trackBench.cxx
@@ -0,0 +1,241 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file trackBench.cxx
+/// \brief o2-gtrk-track-bench: the tracker on a tracking input the sink
+///        dumped, without DPL.
+///
+/// Reads what the sink wrote with `--dump-tracking-input`, builds the tracker
+/// as the sink builds it, and runs it --repeat times on the host or, with
+/// `--backend cuda|hip`, on a GPU through the backend's device tracker
+/// (`--host-reference` then compares the last run's tracks with the host's).
+/// Each run prints its digests, its score against the MC truth and the profile
+/// of every phase; `--json` appends one line per run for the scripts, and the
+/// studies the options ask for watch the last run.
+
+#include "TrackBench.h"
+
+#include "GenericTracking/Alice/TRK.h"
+
+#include "CCDB/BasicCCDBManager.h"
+#include "CommonUtils/NameConf.h"
+#include "DataFormatsParameters/GRPMagField.h"
+
+#include <algorithm>
+#include <cctype>
+#include <format>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+
+namespace o2::gtrk::study
+{
+
+/// Load the field of the run's GRPMagField (`GLO/Config/GRPMagField` from the
+/// CCDB) into o2::base::Propagator, as a workflow's GRPGeomHelper would.
+/// Returns the nominal Bz.
+static double loadField(const std::string& url)
+{
+  const auto* grp = o2::ccdb::BasicCCDBManager::instance().get<o2::parameters::GRPMagField>("GLO/Config/GRPMagField");
+  if (grp == nullptr) {
+    throw std::runtime_error("no GLO/Config/GRPMagField at " + url);
+  }
+  o2::base::Propagator::initFieldFromGRP(grp);
+  return workflow::nominalBzKiloGauss();
+}
+
+static int run(int argc, char** argv)
+{
+  Options options;
+  bpo::options_description description("Track a dumped tracking input");
+  description.add_options()                                                                                                             //
+    ("help,h", "this message")                                                                                                          //
+    ("detector,d", bpo::value(&options.detector)->required(), "its, mft or trk: the ITS, the MFT or ALICE 3's barrel on O2's clusters") //
+    ("ccdb-url", bpo::value(&options.ccdbUrl)->default_value(o2::base::NameConf::getCCDBServer()),
+     "the conditions' CCDB, e.g. file://<sample>/ccdb for its snapshots: the aligned geometry (GLO/Config/GeometryAligned), the field (GLO/Config/GRPMagField, not "
+     "for trk) and the material LUT (GLO/Param/MatLUT, MFT/Param/MatLUT, TRK/Param/MatLUT), the sink's conditions") //
+    ("input,i", bpo::value(&options.input)->default_value("tracking-input.bin"),
+     "the sink's --dump-tracking-input file")                                                                                                          //
+    ("truth", bpo::value(&options.truth)->default_value(""), "its MC truth; <input>.truth if empty and that exists")                                   //
+    ("configKeyValues", bpo::value(&options.keyValues)->default_value(""), "GTRKReco<DET> keys to change on top of the parameters, as the workflow's") //
+    ("config", bpo::value(&options.config)->default_value(""), "the parameters it ran with; <input>.ini if empty")                                     //
+    ("threads,t", bpo::value(&options.threads)->default_value(-1), "the task arena's threads; the configuration's GTRKReco<DET>.threads if negative")  //
+    ("repeat,n", bpo::value(&options.repeat)->default_value(3U), "runs; the first is cold, the others warm")                                           //
+    ("tree", bpo::value(&options.tree)->default_value(true), "print each run's phase tree")                                                            //
+    ("iteration-trees", bpo::bool_switch(&options.iterationTrees), "print each iteration's phase tree too")                                            //
+    ("no-profile", bpo::bool_switch(&options.noProfile), "run without the profile, to measure what it costs")                                          //
+    ("dram", bpo::bool_switch(&options.dram), "count each phase's DRAM traffic (AMD memory-controller counters, system-wide: a quiet machine)")        //
+    ("digest-stages", bpo::bool_switch(&options.digestStages), "print every slice's stage-output digests (an observer; it adds to the time)")          //
+    ("findable-min-pt", bpo::value(&options.findableMinPtGeV)->default_value(0.1), "the score's findable floor [GeV]")                                 //
+    ("findable-all-layers", bpo::value(&options.findableAllLayers)->default_value(0U),
+     "the layers the score's \"on every layer\" classes ask, a bit per layer; 0 for all") //
+    ("seed-coverage", bpo::value(&options.seedCoverage)->default_value(""),
+     "layer masks, comma separated: the findable with a measurement on every layer of each, and on all but one") //
+    ("seeding-strategy", bpo::value(&options.seedingStrategy)->default_value(""),
+     "instead of the runs: each iteration's graph alone, on the rows the earlier ones' seeded particles left, its coverage and cost; one JSON line per pass "
+     "here") //
+    ("seeding-steps", bpo::value(&options.seedingSteps)->default_value("1.0,0.7,0.5,0.4,0.3,0.25,0.2,0.15,0.13,0.12,0.11,0.1"),
+     "with --seeding-strategy: the pT steps its coverage is counted at [GeV]")                                                                  //
+    ("seeding-no-removal", bpo::bool_switch(&options.seedingNoRemoval), "with --seeding-strategy: hold no rows, every pass on the whole frame") //
+    ("seeding-shadow", bpo::value(&options.seedingShadow)->default_value(""),
+     "with --seeding-strategy: these passes (comma separated) hold nothing, and the pass after each is compared with it on the same rows") //
+    ("seeding-fit", bpo::bool_switch(&options.seedingFit),
+     "with --seeding-strategy: a particle is seeded by a pure record of the road fit, not by a pure road") //
+    ("seeding-real", bpo::value(&options.seedingReal)->default_value(""),
+     "the real run's iterations scored as --seeding-strategy's passes (good tracks seed, the used mask holds), one JSON line per iteration here") //
+    ("save-state", bpo::value(&options.saveState)->default_value(""),
+     "run only the first --state-iterations iterations and write what they leave (tracks, used mask, summaries) here, for --resume-state") //
+    ("state-iterations", bpo::value(&options.stateIterations)->default_value(0U), "with --save-state: the iterations it runs")             //
+    ("hold-clusters", bpo::value(&options.holdClusters)->default_value(""),
+     "a file of cluster numbers, one per line, whose rows the run takes before its first iteration: the host tracker, the observers on "
+     "(the vertex study's --vertex-replay <prefix>-owned.txt)") //
+    ("resume-state", bpo::value(&options.resumeState)->default_value(""),
+     "go on from this --save-state checkpoint: its iterations must be the configuration's first; the host tracker, no observers; with "
+     "--seeding-strategy the real run before the study's passes") //
+    ("seeding-particles", bpo::value(&options.seedingParticles)->default_value(""),
+     "with --seeding-strategy or --seeding-real: per findable particle (--seeding-population), the passes that seeded it, as CSV here") //
+    ("seeding-population", bpo::value(&options.seedingPopulation)->default_value("primary"),
+     "with --seeding-strategy: the findable particles it scores: primary (physical primaries), decay (decay daughters), v0 (those of a K0S or a "
+     "hyperon)") //
+    ("step-anatomy", bpo::value(&options.stepAnatomy)->default_value(""),
+     "with --complete-anatomy: a CSV of every short track's refused step and of the complete tracks' inner steps, replayed") //
+    ("hits", bpo::value(&options.hits)->default_value(""),
+     "with --complete-anatomy: the MC hits (sgn_HitsTRK.root): the anatomy's path order, true kinks and every study against the MC")          //
+    ("ft3-hits", bpo::value(&options.ft3Hits)->default_value("sgn_HitsFT3.root"), "TRKFT3: FT3's MC hits beside --hits (the disc crossings)") //
+    ("kine", bpo::value(&options.kine)->default_value(""),
+     "--complete-anatomy with --hits: the MC kinematics, a <prefix>_Kine.root (sgn_Kine.root), for the clutter test of the follow's steps") //
+    ("truth-walk", bpo::value(&options.truthWalk)->default_value(""),
+     "with --complete-anatomy and --hits: a CSV of every step of the truth walks, the step's prediction at the particle's own next row against the cluster and "
+     "the MC crossing") //
+    ("truth-walk-iteration", bpo::value(&options.truthWalkIteration)->default_value(-1),
+     "with --complete-anatomy and --hits: the iteration the truth walk runs on (-1: the first whose layers hold the class's mask)") //
+    ("inward-history", bpo::value(&options.inwardHistory)->default_value(""),
+     "with --complete-anatomy and --hits: a CSV of the inward refit's states, the failing passes' and a control's, against the MC truth") //
+    ("end-decisions", bpo::value(&options.endDecisions)->default_value(""),
+     "with --complete-anatomy: a CSV of every follow walk's end -- how it ended, the unconfirmed drop's verdict, its last and dropped rows against the truth, "
+     "whether the last row stayed on the track") //
+    ("end-edits", bpo::value(&options.endEdits)->default_value(""),
+     "with --end-decisions: a CSV of each track as it is and its truth-free end edits -- the last row refused, the unconfirmed drop's row put back -- "
+     "refitted and floored") //
+    ("anatomy-findable", bpo::bool_switch(&options.anatomyFindable),
+     "with --complete-anatomy: only the particles findable by the QA's rule (a chain of 4 layers, --findable-min-pt)") //
+    ("anatomy-beam-line", bpo::value(&options.anatomyBeamLine)->default_value(""),
+     "with --complete-anatomy: a CSV of the beam-line test on the class's own roads, every iteration with the beam constraint, against the MC") //
+    ("anatomy-follow-loss", bpo::value(&options.anatomyFollowLoss)->default_value(""),
+     "with --complete-anatomy and --hits: a CSV of the class's selected records dropped or kept as a fake, against the MC momentum along the leg") //
+    ("anatomy-pdg", bpo::value(&options.anatomyPdg)->default_value(0),
+     "with --complete-anatomy: the class's species, |PDG code|; 0, every species") //
+    ("breakdown", bpo::value(&options.breakdown)->default_value(""),
+     "a JSON line appended: the last run's tracks by length (fakes, clones, complete), the findable particles of --breakdown-population complete, incomplete "
+     "and where the missing layers' rows went") //
+    ("breakdown-particles", bpo::value(&options.breakdownParticles)->default_value(""),
+     "a CSV appended: --breakdown's findable particles one by one, their layers, status, best track (layers, iteration) and missing layers by fate and "
+     "place; a particle not found, every layer's fate") //
+    ("breakdown-population", bpo::value(&options.breakdownPopulation)->default_value("primary"),
+     "--breakdown's class: primary (physical primaries), decay (decay daughters), v0 (those of a K0S or a hyperon)") //
+    ("fate-out", bpo::value(&options.fateOut)->default_value(""),
+     "with --complete-anatomy: a CSV of every class particle's fate after the last iteration, for a comparison between runs") //
+    ("complete-anatomy", bpo::bool_switch(&options.completeAnatomy),
+     "the findable on every layer of --findable-all-layers: found whole, short and why, not found and why") //
+    ("follow-stops", bpo::bool_switch(&options.followStops),
+     "the last run's follow ends of the correct roads against the truth, by direction and why")                                                      //
+    ("funnel", bpo::bool_switch(&options.funnel), "the last run's stage funnel of the findable against the truth (observers; they add to the time)") //
+    ("beam-width", bpo::value(&options.beamWidthCM)->default_value(0.),
+     "the beam's transverse width the windows and the vertexer take [cm], instead of the dump's beam line's; 0 for the dump's") //
+    ("vertex-study", bpo::value(&options.vertexStudy)->default_value(-1),
+     "the last run's iteration whose triplets the vertex study takes, its vertexer against the truth and its replay; -1 for none") //
+    ("vertices-only", bpo::bool_switch(&options.verticesOnly),
+     "the vertexing pass alone (GTRKReco<DET>.vertexer), no tracking: every run timed, the first's vertices against the MC collisions") //
+    ("score-sources", bpo::value(&options.scoreSources)->multitoken(),
+     "the score again over the particles of these MC sources alone (the collisions added to a mixed timeframe), against every track") //
+    ("vertex-list", bpo::value(&options.vertexList)->default_value(""),
+     "the vertex study's vertexer vertices here, one CSV line each with its collision and makeup, for tools/vertexMakeup.py") //
+    ("vertex-prior", bpo::value(&options.vertexPrior)->default_value(""),
+     "an earlier pass's --vertex-replay <prefix>-vertices.csv: the replay's prior-* variants start each frame from its stage vertices") //
+    ("vertex-replay", bpo::value(&options.vertexReplay)->default_value(""),
+     "the vertex study's replay of the vertexer and its ownership variants: <prefix>-vertices.csv, <prefix>-collisions.csv, "
+     "<prefix>-dropped.csv and <prefix>-owned.txt, for tools/vertexReplay.py")                                                                             //
+    ("fit-inputs", bpo::value(&options.fitInputs)->default_value(""), "write the last run's triplet and neighbour fit inputs here, for o2-gtrk-fit-bench") //
+    ("trace", bpo::value(&options.trace)->default_value(""), "write the last run's zones and chunks here, as a Chrome trace")                              //
+    ("json", bpo::value(&options.json)->default_value(""), "append one JSON line per run here")                                                            //
+    ("tracks-out", bpo::value(&options.tracksOut)->default_value(""), "write the last run's tracks here, one line each: iteration, clusters, chi2")        //
+    ("follow-steps", bpo::value(&options.followSteps)->default_value(""),
+     "write the follow's steps on correct roads against the truth here, replayed after each iteration") //
+    ("fakes-out", bpo::value(&options.fakesOut)->default_value(""),
+     "write the last run's tracks against the truth here: where each one's wrong rows are, road, follow or the earlier iterations' follow") //
+    ("clones-out", bpo::value(&options.clonesOut)->default_value(""),
+     "write the last run's findable physical primaries, their good tracks and the cloned ones' rows here") //
+    ("rows-out", bpo::value(&options.rowsOut)->default_value(""),
+     "write every row of the last run's frame here with its first particle's origin, kinematics and production point") //
+    ("clone-joins", bpo::value(&options.cloneJoins)->default_value(""),
+     "write the last run's clones joined along the truth here: each inner good track's outward state stepped through the next good track's rows, the true "
+     "row's chi2 and the rows competing with it")                                                                                               //
+    ("backend", bpo::value(&options.backend)->default_value("cpu"), "cpu, or cuda or hip: run each planned timeframe on that GPU backend")      //
+    ("gpu-device", bpo::value(&options.gpuDevice)->default_value(0), "the GPU backend's device index")                                          //
+    ("gpu-arena-mb", bpo::value(&options.gpuArenaMB)->default_value(0U), "the device arena [MB], in O2's GPU pool; a GPU backend needs a size") //
+    ("host-reference", bpo::bool_switch(&options.hostReference), "after the GPU runs, track on the host once and compare the tracks")           //
+    ("rebin", bpo::bool_switch(&options.rebin), "rebin the rows even when they are binned by this grid already, which must change nothing");
+
+  bpo::variables_map vm;
+  try {
+    bpo::store(bpo::parse_command_line(argc, argv, description), vm);
+    bpo::notify(vm);
+  } catch (const bpo::error& error) {
+    std::cerr << error.what() << "\n\n"
+              << description << '\n';
+    return 1;
+  }
+  if (vm.contains("help")) {
+    std::cout << description << '\n';
+    return 0;
+  }
+
+  // The trial's keys and --threads go on in track, after the dump's own grid
+  // is known.
+  // The detector's parameter: GTRKRecoITS, GTRKRecoMFT, GTRKRecoTRK.
+  std::string detector = options.detector;
+  std::ranges::transform(detector, detector.begin(), [](unsigned char c) { return static_cast<char>(std::toupper(c)); });
+  loadConfiguration(options.config.empty() ? options.input + ".ini" : options.config, "GTRKReco" + detector);
+  // The conditions' CCDB: TrackBench.h reads the geometry and the material LUT from it too.
+  o2::ccdb::BasicCCDBManager::instance().setURL(options.ccdbUrl);
+  double bz = 0.;
+  if (options.detector == "trk") {
+    // ALICE 3's field is not in its GRP: O2's ALICE 3 field, as the workflow's conditions take it.
+    bz = alice::alice3BzKiloGauss();
+    o2::base::Propagator::Instance(true)->setNominalBz(static_cast<float>(bz));
+    std::cout << std::format("the field: nominal Bz {} kG, O2's ALICE 3 field\n", bz);
+  } else {
+    bz = loadField(options.ccdbUrl);
+    std::cout << std::format("the field: nominal Bz {} kG, from {}\n", bz, options.ccdbUrl);
+  }
+  if (options.detector == "its") {
+    return track<detectors::ITS>(options);
+  }
+  if (options.detector == "mft") {
+    return track<detectors::MFT>(options);
+  }
+  if (options.detector == "trk") {
+    return track<detectors::TRKFT3>(options);
+  }
+  throw std::runtime_error("no detector called '" + options.detector + "'; its, mft or trk");
+}
+
+} // namespace o2::gtrk::study
+
+int main(int argc, char** argv)
+{
+  try {
+    return o2::gtrk::study::run(argc, argv);
+  } catch (const std::exception& error) {
+    std::cerr << "error: " << error.what() << '\n';
+    return 1;
+  }
+}
diff --git a/Detectors/GenericTracking/study/tools/trackBenchITS.cxx b/Detectors/GenericTracking/study/tools/trackBenchITS.cxx
new file mode 100644
index 0000000000000..09f0b23e58db8
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/trackBenchITS.cxx
@@ -0,0 +1,20 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file trackBenchITS.cxx
+/// \brief The bench's run of the ITS, in a unit of its own.
+
+#include "TrackBench.h"
+
+namespace o2::gtrk::study
+{
+template int track<detectors::ITS>(const Options& options);
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/tools/trackBenchMFT.cxx b/Detectors/GenericTracking/study/tools/trackBenchMFT.cxx
new file mode 100644
index 0000000000000..ffe2f90351d44
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/trackBenchMFT.cxx
@@ -0,0 +1,20 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file trackBenchMFT.cxx
+/// \brief The bench's run of the MFT, in a unit of its own.
+
+#include "TrackBench.h"
+
+namespace o2::gtrk::study
+{
+template int track<detectors::MFT>(const Options& options);
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/study/tools/trackBenchTRKFT3.cxx b/Detectors/GenericTracking/study/tools/trackBenchTRKFT3.cxx
new file mode 100644
index 0000000000000..d4bf6c5291872
--- /dev/null
+++ b/Detectors/GenericTracking/study/tools/trackBenchTRKFT3.cxx
@@ -0,0 +1,20 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file trackBenchTRKFT3.cxx
+/// \brief The bench's run of the TRKFT3, in a unit of its own.
+
+#include "TrackBench.h"
+
+namespace o2::gtrk::study
+{
+template int track<detectors::TRKFT3>(const Options& options);
+} // namespace o2::gtrk::study
diff --git a/Detectors/GenericTracking/tools/CMakeLists.txt b/Detectors/GenericTracking/tools/CMakeLists.txt
new file mode 100644
index 0000000000000..cb96922339fcc
--- /dev/null
+++ b/Detectors/GenericTracking/tools/CMakeLists.txt
@@ -0,0 +1,40 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+# What makes an input the tracking reads: the layer link tables, the layouts'
+# layer tables, the material LUT, and the sensor-frame and material helpers
+# they need. The ALICE 3 parts name the TRK, so all of it is built with the
+# upgrades, the ITS's and the MFT's tables too, until a build without the
+# upgrades splits them off.
+o2_add_library(GTrkTools
+               SOURCES src/Material.cxx
+               PUBLIC_LINK_LIBRARIES O2::GTrkBase
+               PRIVATE_LINK_LIBRARIES O2::TRKBase O2::DetectorsBase ROOT::Geom
+               TARGETVARNAME targetName)
+
+# o2_add_library installs the headers of include/<library name> only.
+target_include_directories(${targetName} PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+install(DIRECTORY include/GenericTracking DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+o2_add_executable(layer-links
+                  SOURCES src/layerLinks.cxx
+                  COMPONENT_NAME gtrk
+                  PUBLIC_LINK_LIBRARIES O2::GTrkTools O2::GTrkWorkflow O2::DetectorsBase Boost::program_options)
+
+o2_add_executable(import-geometry
+                  SOURCES src/importGeometry.cxx
+                  COMPONENT_NAME gtrk
+                  PUBLIC_LINK_LIBRARIES O2::GTrkTools O2::GTrkWorkflow O2::TRKBase O2::FT3Base O2::MathUtils Boost::program_options)
+
+o2_add_executable(build-matlut
+                  SOURCES src/buildMatLUT.cxx
+                  COMPONENT_NAME gtrk
+                  PUBLIC_LINK_LIBRARIES O2::GTrkTools O2::GTrkWorkflow O2::DetectorsBase ROOT::Geom Boost::program_options)
diff --git a/Detectors/GenericTracking/tools/include/GenericTracking/Tools/Material.h b/Detectors/GenericTracking/tools/include/GenericTracking/Tools/Material.h
new file mode 100644
index 0000000000000..50c7f6bdb3541
--- /dev/null
+++ b/Detectors/GenericTracking/tools/include/GenericTracking/Tools/Material.h
@@ -0,0 +1,104 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Material.h
+/// \brief The ALICE 3 TRK's material as placed in gGeoManager, for the
+///        material LUT (o2-gtrk-build-matlut) and the imported layouts
+///        (o2-gtrk-import-geometry): the chips' metal stacks, the VD's side
+///        walls and the cylinders around the beam line.
+
+#ifndef GTRK_TOOLS_MATERIAL_H_
+#define GTRK_TOOLS_MATERIAL_H_
+
+#include "GenericTracking/Base/LayerEnvelopes.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Base/Sensor.h"
+
+#include <cstddef>
+#include <functional>
+#include <span>
+#include <vector>
+
+class TGeoNavigator;
+
+namespace o2::gtrk::tools
+{
+
+/// The threads of a fill from the geometry: \a threads, or where it is
+/// negative NTHREADS_MATBUD as O2's own fill reads it
+/// (`MatLayerCylSet::getNThreadsFromEnv`); at least one.
+[[nodiscard]] int fillThreads(int threads);
+
+/// \a work(i, navigator) for every i below \a count, shared out over
+/// \a threads threads (at least one), each taking the next item with a TGeo
+/// navigator of its own; on one thread in order, on gGeoManager's current
+/// navigator. Each item writes its own result, so the split does not move
+/// it.
+void forEachOnNavigators(std::size_t count, int threads, const std::function<void(std::size_t, TGeoNavigator*)>& work);
+
+/// The metal stack O2 builds on a chip's sensor, by face [cm].
+struct ChipStack {
+  double inner = 0.; ///< on the face towards the beam
+  double outer = 0.; ///< on the face away from it
+};
+
+/// The TRK's material on each barrel sensor's silicon, per barrel layer: the
+/// metal stack O2 builds on one face of a sensor
+/// (`GeometryTGeo::getTRKMetalStackPattern`) -- the outer on the VD and most
+/// staves, the inner on the OT's first layer -- as thick as the simulation
+/// made it (a VD chip is its configured x/X0 of silicon), so read from the
+/// geometry in gGeoManager: along each of \a sensors' normals from its
+/// centre, both ways, through the stack's volumes, the layer's thickest.
+/// Throws std::runtime_error without a geometry or where a sensor's centre is
+/// not in a sensor volume.
+[[nodiscard]] std::vector<ChipStack> trkStackThickness(std::span<const Sensor> sensors, std::span<const SensorSpec> specs, int nBarrelLayers);
+
+/// \a envelopes, the silicon's, with each barrel layer's \a stack: the hull
+/// of its sensors taken that much thicker on each face, measured as
+/// `measureEnvelopes` measures (at kEnvelopeResolution); a layer's z extent
+/// and position stay its silicon's, a disc layer whole. The material bands of
+/// the LUT and of the passive scatterers end there, so that a chip's stack is
+/// its layer's material.
+[[nodiscard]] std::vector<LayerEnvelope> withStacks(std::span<const LayerEnvelope> envelopes, std::span<const Sensor> sensors, std::span<const SensorSpec> specs, std::span<const ChipStack> stack);
+
+/// The VD petals' side walls: O2's `VD_SideWall`s, flat plates between the
+/// petals, along r and z [cm].
+struct SideWalls {
+  double thickness = 0.; ///< across the plate, in r-phi; 0 without walls
+  double rMin = 0.;      ///< the radii the plates span
+  double rMax = 0.;
+};
+
+/// The TRK's VD side walls as placed in gGeoManager: the thinnest plate and
+/// the radii all of them span, from each plate's box (its local y across,
+/// its local x along r) and its global matrix. A plate thinner than a
+/// material LUT's cell lands on every track through the cell. Throws
+/// std::runtime_error without a geometry.
+[[nodiscard]] SideWalls trkSideWalls();
+
+/// The radii where solid material begins or ends on cylinders around the beam
+/// line, as placed in gGeoManager, below \a rMax [cm]: the beam pipe, the
+/// iris, the VD's walls and cold plates, the service and support shells.
+/// Along radial lines from the beam line at every \a dz in |z| < \a zMax and
+/// at 256 azimuths a golden angle apart, the radii where a line enters or
+/// leaves solid material (a gas, below 0.01 g/cm^3 -- air is 0.0012 -- does not
+/// count; touching solids are one), to 1 um. A radius is a face where more
+/// than half of the azimuths at one z meet it: a cylinder, or an arc around
+/// most of it, meets every line at its radius; a flat face's radius changes
+/// with the azimuth and a radial wall has none. Sorted. A material LUT band
+/// ending there keeps the cylinder's material at its radius. The z positions
+/// are shared out over \a threads, each with its
+/// own TGeo navigator. Throws std::runtime_error without a geometry.
+[[nodiscard]] std::vector<double> beamLineCylinderFaces(double rMax, double zMax, double dz, int threads = 1);
+
+} // namespace o2::gtrk::tools
+
+#endif // GTRK_TOOLS_MATERIAL_H_
diff --git a/Detectors/GenericTracking/tools/include/GenericTracking/Tools/SensorFrame.h b/Detectors/GenericTracking/tools/include/GenericTracking/Tools/SensorFrame.h
new file mode 100644
index 0000000000000..0ed72e21d756f
--- /dev/null
+++ b/Detectors/GenericTracking/tools/include/GenericTracking/Tools/SensorFrame.h
@@ -0,0 +1,60 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file SensorFrame.h
+/// \brief A point of the global frame in a sensor's own, and whether it is on
+///        the sensor's silicon: the inverses the tracking does not need, for
+///        the truth crossings and the geometry tools.
+
+#ifndef GTRK_TOOLS_SENSORFRAME_H_
+#define GTRK_TOOLS_SENSORFRAME_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Base/Sensor.h"
+
+#include <cmath>
+
+namespace o2::gtrk::tools
+{
+
+/// local = rot^T * (global - trans): a rotation's inverse is its transpose.
+inline void toLocal(const Sensor& sensor, const double g[3], double l[3])
+{
+  const double d0 = g[0] - sensor.trans[0];
+  const double d1 = g[1] - sensor.trans[1];
+  const double d2 = g[2] - sensor.trans[2];
+  l[0] = sensor.rot[0] * d0 + sensor.rot[3] * d1 + sensor.rot[6] * d2;
+  l[1] = sensor.rot[1] * d0 + sensor.rot[4] * d1 + sensor.rot[7] * d2;
+  l[2] = sensor.rot[2] * d0 + sensor.rot[5] * d1 + sensor.rot[8] * d2;
+}
+
+/// The inverse of SensorSpec::unrolledToFrame: a point of the sensor's frame
+/// as its unrolled coordinates.
+inline void frameToUnrolled(const SensorSpec& spec, const double frame[3], double unrolled[3])
+{
+  if (!spec.curved()) {
+    unrolled[0] = frame[0];
+    unrolled[1] = frame[1];
+    unrolled[2] = frame[2];
+    return;
+  }
+  unrolled[0] = spec.radius * std::atan2(frame[1], frame[0]);
+  unrolled[1] = frame[2];
+  unrolled[2] = std::hypot(frame[0], frame[1]) - spec.radius;
+}
+
+/// Whether a point's unrolled \a x, \a y (a flat sensor's frame; a curved
+/// sensor's frame point goes through `frameToUnrolled` first) are on silicon.
+[[nodiscard]] constexpr bool contains(const SensorSpec& spec, double x, double y) { return y >= -spec.halfY && y <= spec.halfY && x >= -spec.halfX && x <= spec.halfX; }
+
+} // namespace o2::gtrk::tools
+
+#endif // GTRK_TOOLS_SENSORFRAME_H_
diff --git a/Detectors/GenericTracking/tools/src/Material.cxx b/Detectors/GenericTracking/tools/src/Material.cxx
new file mode 100644
index 0000000000000..b12a4b1e68924
--- /dev/null
+++ b/Detectors/GenericTracking/tools/src/Material.cxx
@@ -0,0 +1,255 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Tools/Material.h"
+
+#include "DetectorsBase/MatLayerCylSet.h"
+#include "TRKBase/GeometryTGeo.h"
+
+#include <TGeoBBox.h>
+#include <TGeoManager.h>
+#include <TGeoMaterial.h>
+#include <TGeoMatrix.h>
+#include <TGeoNavigator.h>
+#include <TGeoNode.h>
+#include <TGeoVolume.h>
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <cmath>
+#include <cstddef>
+#include <format>
+#include <functional>
+#include <map>
+#include <numbers>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <thread>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::tools
+{
+
+int fillThreads(int threads) { return std::max(threads < 0 ? o2::base::MatLayerCylSet::getNThreadsFromEnv() : threads, 1); }
+
+void forEachOnNavigators(std::size_t count, int threads, const std::function<void(std::size_t, TGeoNavigator*)>& work)
+{
+  threads = std::max(threads, 1);
+  if (threads == 1) {
+    TGeoNavigator* navigator = gGeoManager->GetCurrentNavigator();
+    for (std::size_t i = 0; i < count; ++i) {
+      work(i, navigator);
+    }
+    return;
+  }
+  gGeoManager->SetMaxThreads(threads);
+  std::atomic<std::size_t> next{0};
+  std::vector<std::thread> workers;
+  workers.reserve(static_cast<std::size_t>(threads));
+  for (int thread = 0; thread < threads; ++thread) {
+    workers.emplace_back([&] {
+      TGeoNavigator* navigator = gGeoManager->AddNavigator();
+      for (std::size_t i = next++; i < count; i = next++) {
+        work(i, navigator);
+      }
+      gGeoManager->RemoveNavigator(navigator);
+    });
+  }
+  for (auto& worker : workers) {
+    worker.join();
+  }
+}
+
+SideWalls trkSideWalls()
+{
+  if (gGeoManager == nullptr || gGeoManager->GetTopVolume() == nullptr) {
+    throw std::runtime_error("trkSideWalls: no geometry loaded");
+  }
+  SideWalls walls;
+  TGeoIterator next(gGeoManager->GetTopVolume());
+  while (const TGeoNode* node = next()) {
+    if (std::string_view{node->GetVolume()->GetName()} != "VD_SideWall") {
+      continue;
+    }
+    const auto* box = dynamic_cast<const TGeoBBox*>(node->GetVolume()->GetShape());
+    if (box == nullptr) {
+      throw std::runtime_error("trkSideWalls: a VD_SideWall is not a box");
+    }
+    const TGeoMatrix* matrix = next.GetCurrentMatrix();
+    const auto radius = [&](double x) {
+      const std::array<double, 3> local{x, 0., 0.};
+      std::array<double, 3> global{};
+      matrix->LocalToMaster(local.data(), global.data());
+      return std::hypot(global[0], global[1]);
+    };
+    const double inner = std::min(radius(-box->GetDX()), radius(box->GetDX()));
+    const double outer = std::max(radius(-box->GetDX()), radius(box->GetDX()));
+    const double thickness = 2. * box->GetDY();
+    walls.thickness = walls.thickness > 0. ? std::min(walls.thickness, thickness) : thickness;
+    walls.rMin = walls.rMax > 0. ? std::min(walls.rMin, inner) : inner;
+    walls.rMax = std::max(walls.rMax, outer);
+  }
+  return walls;
+}
+
+std::vector<double> beamLineCylinderFaces(double rMax, double zMax, double dz, int threads)
+{
+  if (gGeoManager == nullptr || gGeoManager->GetTopVolume() == nullptr) {
+    throw std::runtime_error("beamLineCylinderFaces: no geometry loaded");
+  }
+  constexpr int kAzimuths = 256;
+  constexpr double kResolution = 1e-4; // cm
+  constexpr double kGasDensity = 0.01; // g/cm^3
+  const double golden = std::numbers::pi * (3. - std::sqrt(5.));
+  const auto nz = static_cast<int>(std::floor(2. * zMax / dz)) + 1;
+  const auto facesAt = [&](double z, TGeoNavigator* navigator) {
+    std::map<long, int> seen; // per radius, the azimuths meeting it
+    for (int ia = 0; ia < kAzimuths; ++ia) {
+      const double phi = ia * golden;
+      const std::array<double, 3> direction{std::cos(phi), std::sin(phi), 0.};
+      std::array<double, 3> start{0., 0., z};
+      navigator->InitTrack(start.data(), direction.data());
+      std::set<long> mine;
+      double r = 0.;
+      bool solid = false;
+      while (r < rMax && !navigator->IsOutside()) {
+        const bool inSolid = navigator->GetCurrentVolume()->GetMaterial()->GetDensity() >= kGasDensity;
+        if (inSolid != solid) {
+          mine.insert(std::lround(r / kResolution));
+          solid = inSolid;
+        }
+        navigator->FindNextBoundaryAndStep(rMax - r);
+        const double step = navigator->GetStep();
+        if (step <= 0.) {
+          break;
+        }
+        r += step;
+      }
+      for (const long face : mine) {
+        ++seen[face];
+      }
+    }
+    std::vector<long> found;
+    for (const auto& [face, count] : seen) {
+      if (2 * count > kAzimuths && face > 0) {
+        found.push_back(face);
+      }
+    }
+    return found;
+  };
+  std::vector<std::vector<long>> byZ(static_cast<std::size_t>(nz));
+  forEachOnNavigators(byZ.size(), threads, [&](std::size_t iz, TGeoNavigator* navigator) { byZ[iz] = facesAt(-zMax + (static_cast<double>(iz) * dz), navigator); });
+  std::set<long> faces;
+  for (const auto& found : byZ) {
+    faces.insert(found.begin(), found.end());
+  }
+  std::vector<double> result;
+  result.reserve(faces.size());
+  for (const long face : faces) {
+    result.push_back(static_cast<double>(face) * kResolution);
+  }
+  return result;
+}
+
+std::vector<ChipStack> trkStackThickness(std::span<const Sensor> sensors, std::span<const SensorSpec> specs, int nBarrelLayers)
+{
+  if (gGeoManager == nullptr) {
+    throw std::runtime_error("trkStackThickness: no geometry loaded");
+  }
+  const std::string sensorPattern = o2::trk::GeometryTGeo::getTRKSensorPattern();
+  const std::string stackPattern = o2::trk::GeometryTGeo::getTRKMetalStackPattern();
+  const auto named = [](const std::string& pattern) { return std::string{gGeoManager->GetCurrentVolume()->GetName()}.find(pattern) != std::string::npos; };
+  std::vector<ChipStack> thickness(static_cast<std::size_t>(nBarrelLayers));
+  for (const auto& sensor : sensors) {
+    if (std::cmp_greater_equal(sensor.layer, nBarrelLayers)) {
+      continue;
+    }
+    // The centre of the silicon, and the normal away from the beam: a flat
+    // sensor's local z, a curved one's radius from its axis.
+    const auto& spec = specs[sensor.layer];
+    double local[3];
+    spec.unrolledToFrame(0., 0., 0.5 * (spec.surfaceMin() + spec.surfaceMax()), local);
+    double centre[3];
+    sensor.toGlobal(local, centre);
+    double normal[3];
+    if (spec.curved()) {
+      const double dx = centre[0] - sensor.trans[0];
+      const double dy = centre[1] - sensor.trans[1];
+      const double norm = std::hypot(dx, dy);
+      normal[0] = dx / norm;
+      normal[1] = dy / norm;
+      normal[2] = 0.;
+    } else {
+      normal[0] = sensor.rot[2];
+      normal[1] = sensor.rot[5];
+      normal[2] = sensor.rot[8];
+      if ((normal[0] * centre[0]) + (normal[1] * centre[1]) < 0.) {
+        for (double& n : normal) {
+          n = -n;
+        }
+      }
+    }
+    // Out of the sensor along the normal, then through the stack's volumes.
+    const auto stackAlong = [&](double sign) {
+      const double direction[3] = {sign * normal[0], sign * normal[1], sign * normal[2]};
+      gGeoManager->InitTrack(centre, direction);
+      if (!named(sensorPattern)) {
+        throw std::runtime_error(std::format("trkStackThickness: the centre of a sensor of layer {} is in {}, not a sensor", sensor.layer, gGeoManager->GetCurrentVolume()->GetName()));
+      }
+      gGeoManager->FindNextBoundaryAndStep();
+      double stack = 0.;
+      while (named(stackPattern)) {
+        gGeoManager->FindNextBoundaryAndStep();
+        stack += gGeoManager->GetStep();
+      }
+      return stack;
+    };
+    auto& layer = thickness[sensor.layer];
+    layer.inner = std::max(layer.inner, stackAlong(-1.));
+    layer.outer = std::max(layer.outer, stackAlong(1.));
+  }
+  return thickness;
+}
+
+std::vector<LayerEnvelope> withStacks(std::span<const LayerEnvelope> envelopes, std::span<const Sensor> sensors, std::span<const SensorSpec> specs, std::span<const ChipStack> stack)
+{
+  // A flat sensor's silicon is centred on its frame: a face moves by its
+  // stack with the half-thickness grown by all of it, and each face is
+  // measured on its own. A curved one's starts at its radius, which the inner
+  // stack moves in.
+  const auto thicker = [&](bool outer) {
+    std::vector<SensorSpec> result(specs.begin(), specs.end());
+    for (std::size_t layer = 0; layer < stack.size(); ++layer) {
+      auto& spec = result[layer];
+      if (spec.curved()) {
+        spec.radius -= stack[layer].inner;
+        spec.halfThickness += 0.5 * (stack[layer].inner + stack[layer].outer);
+      } else {
+        spec.halfThickness += outer ? stack[layer].outer : stack[layer].inner;
+      }
+    }
+    return measureEnvelopes(sensors, result, static_cast<int>(stack.size()), kEnvelopeResolution);
+  };
+  const auto inward = thicker(false);
+  const auto outward = thicker(true);
+  std::vector<LayerEnvelope> result(envelopes.begin(), envelopes.end());
+  for (std::size_t layer = 0; layer < stack.size(); ++layer) {
+    result[layer].rMin = inward[layer].rMin;
+    result[layer].rMax = outward[layer].rMax;
+  }
+  return result;
+}
+
+} // namespace o2::gtrk::tools
diff --git a/Detectors/GenericTracking/tools/src/buildMatLUT.cxx b/Detectors/GenericTracking/tools/src/buildMatLUT.cxx
new file mode 100644
index 0000000000000..7d9be13b9a130
--- /dev/null
+++ b/Detectors/GenericTracking/tools/src/buildMatLUT.cxx
@@ -0,0 +1,387 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file buildMatLUT.cxx
+/// \brief Build the tracking material LUT from an o2sim geometry for the MFT
+///        or the ALICE 3 barrel tracker.
+
+#include "GenericTracking/Tools/Material.h"
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+
+#include "DetectorsBase/GeometryManager.h"
+#include "DetectorsBase/MatLayerCylSet.h"
+
+#include <TGeoNavigator.h>
+
+#include <boost/program_options.hpp>
+
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <exception>
+#include <iomanip>
+#include <iostream>
+#include <memory>
+#include <span>
+#include <string>
+#include <vector>
+
+namespace bpo = boost::program_options;
+
+namespace
+{
+
+struct LUTLayer {
+  float rMin;
+  float rMax;
+  float zMax;
+  float dz;
+  float drPhi;
+};
+
+/// The MFT's region, which O2's MatLUT leaves out: its layers below r = 5 cm
+/// end at |z| = 20 cm, the beam pipe's at 50 cm,
+/// and the MFT's faces lie at z -45 to -78 cm, r 2.3 to 17.3 cm. An O2 layer
+/// spans z symmetrically, so these also cover the ITS and whatever a track
+/// crosses from the vertex. The pipe's wall gets its own band; from 2.2 cm
+/// out, bands of 1 cm with 0.25 cm along z keep each disc's material between
+/// its two faces (1.42 cm apart) and out of the gaps between discs, and
+/// 0.5 cm in r-phi resolves the half-discs' ladders, which cover each face
+/// only in part.
+inline constexpr float kMftZMax = 82.F;
+inline constexpr auto kMftLayers = [] {
+  std::array<LUTLayer, 20> layers{};
+  layers[0] = {.rMin = 0.F, .rMax = 1.8F, .zMax = kMftZMax, .dz = 2.F, .drPhi = 2.F};
+  layers[1] = {.rMin = 1.8F, .rMax = 1.95F, .zMax = kMftZMax, .dz = 0.5F, .drPhi = 0.5F};
+  layers[2] = {.rMin = 1.95F, .rMax = 2.2F, .zMax = kMftZMax, .dz = 0.5F, .drPhi = 1.F};
+  for (std::size_t i = 0; i < 16; ++i) {
+    const float r = i == 0 ? 2.2F : 2.F + static_cast<float>(i);
+    layers[3 + i] = {.rMin = r, .rMax = 3.F + static_cast<float>(i), .zMax = kMftZMax, .dz = 0.25F, .drPhi = 0.5F};
+  }
+  layers[19] = {.rMin = 18.F, .rMax = 20.F, .zMax = kMftZMax, .dz = 0.5F, .drPhi = 1.F};
+  return layers;
+}();
+
+/// The ALICE 3 barrel tracker's region.
+///
+/// Its radial bands are the layout's own: one over each layer's chips -- its
+/// silicon envelope and the metal stack on one face of its sensors
+/// (`tools::withStacks`) -- and one over each gap between layers, as measured
+/// from the loaded geometry. A LUT layer holds its material evenly across its
+/// radial span, so only bands that end where the layers end keep a layer's
+/// material apart from the gap's -- which is how the layout splits it, the
+/// gap's going to its passive scatterer (TRKFT3.h). A band over the silicon
+/// alone would spread a VD layer's stack, most of its x/X0, across the gap to
+/// the next layer, and the fit would take only part of its kink at that layer.
+/// A band over a layer of flat staves is as deep as their hull (0.5-1.4 cm: a
+/// flat stave's edges lie further out than its middle), so it is cut into
+/// equal parts no thinner than a chip (its silicon and stack,
+/// \a chipThickness): at one azimuth a stave is a chip's thickness deep (and
+/// the parts' cells narrow enough in r-phi that a tilted stave stays within
+/// two parts), and a track at a small angle to it (|eta| 2.6, 8 deg) turns a
+/// radial spread into ten times that along z. Along z, 1 cm, to |z| = 225 cm,
+/// which holds the barrel (OT to 128.4 cm) and FT3's discs (to 220.6 cm): a
+/// disc lies across the radial bands its radii span, its silicon and supports
+/// in the 1 cm cells of its z. In r-phi, 0.05 cm for the VD's layers and the
+/// gaps between them, 0.2 cm in the gap from the VD to the ML, 0.3 cm for a
+/// stave layer, which resolves the staves' overlaps, and 0.5 cm in the other
+/// gaps; but every band the petals' radial side walls cross (\a walls,
+/// measured from the geometry) has cells half as wide as a wall is thick. A
+/// wider cell spreads the wall over every track through it, and the tracks
+/// through the petal gaps read a multiple of the geometry's x/X0. A wall lies
+/// across two or three cells whatever their phase (bins start at phi 0); at
+/// half its thickness the spread beyond its faces is at most half of it.
+///
+/// A gap is first cut at the faces of the cylinders around the beam line in it
+/// (\a faces, measured from the geometry: the iris, the cold plates, the VD's
+/// outer wall, the beam pipe, the service and support shells), so that each
+/// keeps its material at its own radius: a band from the beam line would put
+/// half of the iris wall at the vertex end of the step to VD L0, a band across
+/// the middle of the step from L2 to the ML half of the VD's outer wall at L2.
+/// Each part is then cut into equal bands of at most 1 cm in r. Beyond the
+/// barrel's length the gaps hold FT3's supports, thin cylinders along z at
+/// r 39.4, 71, 74.5 and 78-80 cm; a band as wide as its gap would spread each
+/// over the gap in r, onto forward tracks that never reach it. A track
+/// crossing the whole gap, as a barrel track does, reads the same either way.
+inline constexpr float kTrkZMax = 225.F;
+inline constexpr float kTrkRMax = 83.F; ///< beyond the OT's carbon support, and FT3's discs (69.2 cm)
+inline constexpr float kTrkGapDr = 1.F; ///< the widest band in a gap
+
+/// The bands of the barrel's layers, \a envelopes with their stacks; the discs' follow none.
+std::vector<LUTLayer> trkLayers(std::span<const o2::gtrk::LayerEnvelope> envelopes, const o2::gtrk::tools::SideWalls& walls, std::span<const double> faces, std::span<const double> chipThickness)
+{
+  std::vector<LUTLayer> layers;
+  const auto cell = [&](float inner, float outer, float drPhi) {
+    const auto low = static_cast<double>(inner);
+    const auto high = static_cast<double>(outer);
+    const bool crossed = walls.thickness > 0. && low < walls.rMax && high > walls.rMin;
+    return crossed ? std::min(drPhi, static_cast<float>(0.5 * walls.thickness)) : drPhi;
+  };
+  const auto addPart = [&](float inner, float outer, float drPhi) {
+    const auto bands = static_cast<int>(std::ceil((outer - inner) / kTrkGapDr));
+    for (int band = 0; band < bands; ++band) {
+      const float low = band == 0 ? inner : inner + ((outer - inner) * static_cast<float>(band) / static_cast<float>(bands));
+      const float high = band + 1 == bands ? outer : inner + ((outer - inner) * static_cast<float>(band + 1) / static_cast<float>(bands));
+      layers.push_back({.rMin = low, .rMax = high, .zMax = kTrkZMax, .dz = 1.F, .drPhi = cell(low, high, drPhi)});
+    }
+  };
+  // a face closer than this to a band's edge makes no band of its own
+  constexpr float kFaceResolution = 1e-4F;
+  const auto addGap = [&](float inner, float outer, float drPhi) {
+    float low = inner;
+    for (const double face : faces) {
+      const auto f = static_cast<float>(face);
+      if (f > low + kFaceResolution && f < outer - kFaceResolution) {
+        addPart(low, f, drPhi);
+        low = f;
+      }
+    }
+    addPart(low, outer, drPhi);
+  };
+  // the VD's layers, the layout's first barrel layers
+  constexpr std::size_t kVDLayers = o2::gtrk::detectors::trkft3::kVDRadius.size();
+  float previous = 0.F;
+  for (std::size_t layer = 0; layer < envelopes.size(); ++layer) {
+    const bool vd = layer < kVDLayers;
+    const auto rMin = static_cast<float>(envelopes[layer].rMin);
+    const auto rMax = static_cast<float>(envelopes[layer].rMax);
+    float gapPhi = 0.5F; // the gaps between the ML's and the OT's layers
+    if (vd) {
+      gapPhi = 0.05F; // to and between the VD's layers
+    } else if (layer == kVDLayers) {
+      gapPhi = 0.2F; // from the VD to the ML
+    }
+    addGap(previous, rMin, gapPhi);
+    // equal parts no thinner than a chip; a flat stave meets the radial
+    // direction at up to alpha (cos alpha = rMin / rMax), so over a cell of
+    // width w its radius changes by w tan(alpha): cells no wider than half a
+    // chip's thickness over tan(alpha) keep it within a part and a half, as
+    // the side walls' cells are half a wall
+    const auto thickness = static_cast<float>(chipThickness[layer]);
+    const int parts = std::max(1, static_cast<int>(std::floor((rMax - rMin) / thickness)));
+    float drPhi = vd ? 0.05F : 0.3F;
+    if (parts > 1) {
+      const float tanAlpha = std::sqrt((rMax * rMax) - (rMin * rMin)) / rMin;
+      drPhi = std::min(drPhi, 0.5F * thickness / tanAlpha);
+    }
+    for (int part = 0; part < parts; ++part) {
+      const float low = part == 0 ? rMin : rMin + ((rMax - rMin) * static_cast<float>(part) / static_cast<float>(parts));
+      const float high = part + 1 == parts ? rMax : rMin + ((rMax - rMin) * static_cast<float>(part + 1) / static_cast<float>(parts));
+      layers.push_back({.rMin = low, .rMax = high, .zMax = kTrkZMax, .dz = 1.F, .drPhi = cell(low, high, drPhi)});
+    }
+    previous = rMax;
+  }
+  addGap(previous, kTrkRMax, 0.5F);
+  return layers;
+}
+
+/// One cell's material from the loaded geometry: \a trials x \a trials lines
+/// across it, \a trials azimuths times \a trials offsets along z. Each line
+/// runs along the cell's r-z diagonal, from (rMin, zLow + s) to
+/// (rMax, zHigh + s), and wraps at the cell's upper z face back to its lower
+/// one, so it stays inside the cell. A plane at one z and a cylinder at one r
+/// inside the cell are each crossed exactly once by every line, at the share
+/// of its length their thickness takes of the cell's dz or dr: the cell gets
+/// their volume average whatever the plane's z. O2's fill
+/// (MatLayerCyl::populateFromTGeo) samples along nearly radial lines at
+/// \a trials fixed z, which a thin plane such as a disc either lies along or
+/// misses. The offsets s are the
+/// centres of \a trials equal parts of dz; the cell keeps O2's mean density
+/// and mean 1/X0 along the lines.
+void populateCell(o2::base::MatLayerCyl& layer, int ip, int iz, int trials, TGeoNavigator* nav)
+{
+  const double rMin = layer.getRMin();
+  const double rMax = layer.getRMax();
+  const double dr = rMax - rMin;
+  const double zLow = layer.getZBinMin(iz);
+  const double dz = layer.getDZ();
+  const double phiLow = layer.getPhiBinMin(ip);
+  const double dPhi = layer.getDPhi();
+  double rhoLength = 0.;
+  double x2X0 = 0.;
+  double length = 0.;
+  const auto add = [&](double cs, double sn, double r0, double z0, double r1, double z1) {
+    const auto bud = o2::base::GeometryManager::meanMaterialBudget(static_cast<float>(r0 * cs), static_cast<float>(r0 * sn), static_cast<float>(z0), static_cast<float>(r1 * cs), static_cast<float>(r1 * sn), static_cast<float>(z1), nav);
+    const double segment = bud.length;
+    if (segment > 0.) {
+      rhoLength += segment * static_cast<double>(bud.meanRho);
+      x2X0 += static_cast<double>(bud.meanX2X0); // the segment's x/X0
+      length += segment;
+    }
+  };
+  for (int iPhi = 0; iPhi < trials; ++iPhi) {
+    const double phi = phiLow + ((iPhi + 0.5) * dPhi / trials);
+    const double cs = std::cos(phi);
+    const double sn = std::sin(phi);
+    for (int iShift = 0; iShift < trials; ++iShift) {
+      const double shift = (iShift + 0.5) / trials;
+      // The line reaches the upper z face at this radius, and goes on from the lower one.
+      const double rWrap = rMin + ((1. - shift) * dr);
+      add(cs, sn, rMin, zLow + (shift * dz), rWrap, zLow + dz);
+      add(cs, sn, rWrap, zLow, rMax, zLow + (shift * dz));
+    }
+  }
+  if (length > 0.) {
+    auto& cell = layer.getCellPhiBin(ip, iz);
+    cell.meanRho = static_cast<float>(rhoLength / length);
+    cell.meanX2X0 = static_cast<float>(x2X0 / length); // the mean 1/X0, as O2 stores it
+  }
+}
+
+/// Every cell of \a lut by populateCell, on \a threads threads, each with its
+/// own TGeo navigator (`tools::forEachOnNavigators`).
+void populate(o2::base::MatLayerCylSet& lut, int trials, int threads)
+{
+  struct Cell {
+    int layer;
+    int ip;
+    int iz;
+  };
+  std::vector<Cell> cells;
+  for (int layer = 0; layer < lut.getNLayers(); ++layer) {
+    const auto& cyl = lut.getLayer(layer);
+    for (int iz = 0; iz < cyl.getNZBins(); ++iz) {
+      for (int ip = 0; ip < cyl.getNPhiBins(); ++ip) {
+        cells.push_back({.layer = layer, .ip = ip, .iz = iz});
+      }
+    }
+  }
+  o2::gtrk::tools::forEachOnNavigators(cells.size(), threads, [&](std::size_t i, TGeoNavigator* nav) { populateCell(lut.getLayer(cells[i].layer), cells[i].ip, cells[i].iz, trials, nav); });
+  lut.finalizeStructures();
+}
+
+/// The TRK's bands from the loaded geometry, its stacks, side walls and
+/// cylinder faces printed (the LUT's provenance in its log).
+std::vector<LUTLayer> trkBands(int threads)
+{
+  using TRKFT3 = o2::gtrk::detectors::TRKFT3;
+  const o2::gtrk::Geometry<TRKFT3> geometry(o2::gtrk::alice::placeChecked<TRKFT3>());
+  constexpr int kBarrel = o2::gtrk::Detector<TRKFT3>::nBarrelLayers;
+  const auto specs = o2::gtrk::Geometry<TRKFT3>::layerSpecs();
+  const auto stack = o2::gtrk::tools::trkStackThickness(geometry.sensors(), specs, kBarrel);
+  const auto chips = o2::gtrk::tools::withStacks(o2::gtrk::PlacedEnvelopes<TRKFT3>::all(), geometry.sensors(), specs, stack);
+  std::cout << "metal stacks on the silicon, inner/outer face [um]:";
+  for (const auto& t : stack) {
+    std::cout << ' ' << t.inner * 1e4 << '/' << t.outer * 1e4;
+  }
+  std::cout << '\n';
+  const auto walls = o2::gtrk::tools::trkSideWalls();
+  std::cout << "VD side walls: " << walls.thickness * 1e4 << " um thick, r " << walls.rMin << " .. " << walls.rMax << " cm\n";
+  const auto faces = o2::gtrk::tools::beamLineCylinderFaces(kTrkRMax, kTrkZMax, 1., threads);
+  std::cout << "cylinder faces around the beam line [cm]:";
+  for (const double face : faces) {
+    std::cout << ' ' << face;
+  }
+  std::cout << '\n';
+  std::vector<double> chipThickness;
+  for (int layer = 0; layer < kBarrel; ++layer) {
+    const auto l = static_cast<std::size_t>(layer);
+    chipThickness.push_back((2. * specs[l].halfThickness) + stack[l].inner + stack[l].outer);
+  }
+  return trkLayers(std::span{chips}.first(static_cast<std::size_t>(kBarrel)), walls, faces, chipThickness);
+}
+
+int run(int argc, char** argv)
+{
+  std::string output;
+  std::string geometryFile;
+  std::string detector;
+  int trials = 10;
+  int threads = -1;
+  float maxRelativeDifference = 0.05F;
+
+  bpo::options_description opts("Build the GTRK material-budget LUT");
+  opts.add_options()                                                                                           //
+    ("help,h", "print this help")                                                                              //
+    ("output,o", bpo::value(&output)->default_value("gtrk_matlut.root"), "output LUT file")                    //
+    ("trials,n", bpo::value(&trials)->default_value(10), "lines per cell axis")                                //
+    ("detector,d", bpo::value(&detector)->required(),                                                          //
+     "MFT: the MFT's region; TRKFT3: the ALICE 3 tracker's, from --geometry (the ITS takes O2's CCDB MatLUT)") //
+    ("geometry,g", bpo::value(&geometryFile)->required(),                                                      //
+     "an o2sim geometry file (o2sim_geometry-aligned.root)")                                                   //
+    ("threads,j", bpo::value(&threads)->default_value(-1),                                                     //
+     "fill threads; negative uses NTHREADS_MATBUD")                                                            //
+    ("max-relative-difference", bpo::value(&maxRelativeDifference)->default_value(0.05F),                      //
+     "maximum relative difference when merging adjacent phi slices");
+
+  bpo::variables_map vm;
+  try {
+    bpo::store(bpo::parse_command_line(argc, argv, opts), vm);
+    if (vm.contains("help")) {
+      std::cout << opts << '\n';
+      return 0;
+    }
+    bpo::notify(vm);
+  } catch (const bpo::error& e) {
+    std::cerr << "error: " << e.what() << "\n\n"
+              << opts << '\n';
+    return 1;
+  }
+  if (detector != "MFT" && detector != "TRKFT3") {
+    std::cerr << "error: --detector is MFT or TRKFT3" << (detector == "ITS" ? " (the ITS takes O2's CCDB MatLUT)" : "") << "\n\n"
+              << opts << '\n';
+    return 1;
+  }
+  threads = o2::gtrk::tools::fillThreads(threads);
+
+  o2::base::GeometryManager::loadGeometry(geometryFile);
+  std::span<const LUTLayer> layers;
+  std::vector<LUTLayer> trk;
+  float radialCheck = 0.F;
+  if (detector == "MFT") {
+    layers = kMftLayers;
+    radialCheck = 20.F;
+  } else {
+    trk = trkBands(threads);
+    layers = trk;
+    radialCheck = kTrkRMax;
+  }
+
+  o2::base::MatLayerCylSet lut;
+  std::cout << "material LUT layers:\n";
+  for (std::size_t i = 0; i < layers.size(); ++i) {
+    const auto& layer = layers[i];
+    std::cout << "  " << std::setw(2) << i << ": r " << std::setw(4) << layer.rMin << " .. " << std::setw(4) << layer.rMax << " cm, |z| < " << layer.zMax << " cm, dz " << layer.dz << " cm, drphi " << layer.drPhi << " cm\n";
+    lut.addLayer(layer.rMin, layer.rMax, layer.zMax, layer.dz, layer.drPhi);
+  }
+
+  std::cout << "\npopulating from TGeo with " << trials << " x " << trials << " diagonals per cell\n";
+  populate(lut, trials, threads);
+  lut.optimizePhiSlices(maxRelativeDifference);
+  lut.flatten();
+  lut.writeToFile(output);
+
+  const std::unique_ptr<o2::base::MatLayerCylSet> loaded{o2::base::MatLayerCylSet::loadFromFile(output)};
+  if (!loaded) {
+    std::cerr << "failed to load the written LUT " << output << '\n';
+    return 1;
+  }
+  const auto radial = loaded->getMatBudget(0.F, 0.F, 0.F, radialCheck, 0.F, 0.F);
+
+  std::cout << "\nwrote " << output << '\n'
+            << "  flattened size  " << static_cast<double>(lut.getFlatBufferSize()) / (1024. * 1024.) << " MiB\n"
+            << "  radial check    x/X0 = " << radial.meanX2X0 << ", rho*L = " << radial.getXRho() << " g/cm^2 over " << radial.length << " cm\n";
+  return 0;
+}
+
+} // namespace
+
+int main(int argc, char** argv)
+{
+  try {
+    return run(argc, argv);
+  } catch (const std::exception& error) {
+    std::cerr << "error: " << error.what() << '\n';
+    return 1;
+  }
+}
diff --git a/Detectors/GenericTracking/tools/src/importGeometry.cxx b/Detectors/GenericTracking/tools/src/importGeometry.cxx
new file mode 100644
index 0000000000000..e7323dcbda0dc
--- /dev/null
+++ b/Detectors/GenericTracking/tools/src/importGeometry.cxx
@@ -0,0 +1,674 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file importGeometry.cxx
+/// \brief Measure the ITS, MFT or ALICE 3 TRK layer table from an o2sim
+///        geometry, check the compiled one against it, and check our sensors
+///        against O2's.
+///
+/// Loads the geometry, places every chip as GenericTracking/Alice/Placement.h does and
+/// prints each layer's chip count as the layout's `barrelLayers` and
+/// `discLayers` members, then the layer envelopes the tracking would
+/// measure from these placements (Base/LayerEnvelopes.h), for information:
+/// where the chips sit is run-time data and nothing compiled holds it.
+/// Then it checks the compiled counts against the
+/// placements, which is what fails after an O2 geometry change until the table
+/// is pasted again.
+///
+/// For the TRK it also holds our sensors to O2's: every chip's four corner
+/// pixels and its middle one, placed by O2's
+/// segmentation and L2G matrix and by our sensor, must coincide. (The MC hits
+/// on their chips: o2-gtrk-check-hits.)
+
+#include "GenericTracking/Tools/Material.h"
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Base/LayerEnvelopes.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+
+#include "DetectorsBase/GeometryManager.h"
+#include "MathUtils/Cartesian.h"
+#include "FT3Base/GeometryTGeo.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "TRKBase/SegmentationChip.h"
+
+#include <boost/program_options.hpp>
+
+#include <algorithm>
+#include <chrono>
+#include <array>
+#include <cmath>
+#include <concepts>
+#include <cstddef>
+#include <exception>
+#include <format>
+#include <iostream>
+#include <limits>
+#include <numbers>
+#include <optional>
+#include <random>
+#include <string>
+#include <vector>
+
+namespace bpo = boost::program_options;
+
+namespace o2::gtrk::tools
+{
+
+namespace
+{
+
+/// How a layer's sensor is named in the layout header.
+template <DetectorLayout Det>
+std::string sensorName(std::size_t layer)
+{
+  if constexpr (std::same_as<Det, detectors::TRKFT3>) {
+    return layer < detectors::trkft3::kVDRadius.size() ? std::format("trkft3::vdSensor({})", layer) : std::string{"trkft3::kChip"};
+  } else {
+    return "alpide::kSensor";
+  }
+}
+
+/// Our sensors against O2's TRK and FT3: pixel centres placed by O2's
+/// segmentation and L2G matrix -- through `flatToCurved` on the VD -- and by
+/// our sensor. Returns the largest distance [cm].
+double checkTRKPixels(std::span<const Sensor> sensors)
+{
+  using Segmentation = o2::trk::SegmentationChip;
+  auto& geometry = *o2::trk::GeometryTGeo::Instance();
+  auto& ft3 = *o2::ft3::GeometryTGeo::Instance();
+  constexpr auto kFirstDisc = static_cast<std::size_t>(detectors::TRKFT3::kFirstDiscSensor);
+  double worst = 0.;
+  for (std::size_t chip = 0; chip < sensors.size(); ++chip) {
+    const bool disc = chip >= kFirstDisc;
+    const int id = static_cast<int>(disc ? chip - kFirstDisc : chip); // O2's chip ID
+    const int subDet = disc ? ft3.getSubDetID(id) : geometry.getSubDetID(id);
+    const int layer = disc ? ft3.getLayer(id) : geometry.getLayer(id); // within the sub-detector
+    const auto& spec = Geometry<detectors::TRKFT3>::layerSpec(sensors[chip].layer);
+    const int nRows = subDet == 0 ? o2::trk::constants::VD::petal::layer::nRows[static_cast<std::size_t>(layer)] : o2::trk::constants::moduleMLOT::chip::nRows;
+    const int nCols = subDet == 0 ? o2::trk::constants::VD::petal::layer::nCols : o2::trk::constants::moduleMLOT::chip::nCols;
+    for (const auto [row, col] : std::array<std::array<int, 2>, 5>{{{0, 0}, {nRows - 1, 0}, {0, nCols - 1}, {nRows - 1, nCols - 1}, {nRows / 2, nCols / 2}}}) {
+      float xRow = 0.F;
+      float zCol = 0.F;
+      Segmentation::detectorToLocalUnchecked(row, col, xRow, zCol, subDet, layer, -1);
+      o2::math_utils::Point3D<double> o2Local{static_cast<double>(xRow), 0., static_cast<double>(zCol)};
+      if (subDet == 0) {
+        const auto curved = Segmentation::flatToCurved(layer, xRow, 0.F);
+        o2Local.SetCoordinates(static_cast<double>(curved.X()), static_cast<double>(curved.Y()), static_cast<double>(zCol));
+      }
+      const auto expected = disc ? ft3.getMatrixL2G(id)(o2Local) : geometry.getMatrixL2G(id)(o2Local);
+      double frame[3];
+      spec.unrolledToFrame(static_cast<double>(xRow), static_cast<double>(zCol), 0., frame);
+      double ours[3];
+      sensors[chip].toGlobal(frame, ours);
+      worst = std::max(worst, std::hypot(ours[0] - expected.X(), ours[1] - expected.Y(), ours[2] - expected.Z()));
+    }
+  }
+  return worst;
+}
+
+/// One passive scatterer per gap between consecutive barrel layers, and one
+/// between the beam line and the first,
+/// measured from the loaded geometry: its band the gap between the layers'
+/// chips, their sensors' metal stacks included (`tools::withStacks`), its
+/// extent along z the outer layer's, its x/X0 the
+/// gap's material at normal incidence, averaged over azimuth and z, and its
+/// radius that material's x/X0-weighted mean radius. Read along radial
+/// segments at random azimuths and z (a fixed seed): some of the material is
+/// thin radial walls and structures that end along z, which a regular grid
+/// hits by aliasing. The x/X0 across the whole gap at kSamples points, the
+/// radius in steps of kStep at kStepSamples. Printed as the `passives` table
+/// of the layout.
+template <DetectorLayout Det>
+void printPassives(const Geometry<Det>& geometry)
+{
+  constexpr int kSamples = 65536;
+  constexpr double kStep = 0.01; // [cm]
+  constexpr int kStepSamples = 2048;
+  const auto budget = [](double r0, double r1, double phi, double z) { return static_cast<double>(o2::base::GeometryManager::meanMaterialBudget(o2::math_utils::Point3D<double>{r0 * std::cos(phi), r0 * std::sin(phi), z}, o2::math_utils::Point3D<double>{r1 * std::cos(phi), r1 * std::sin(phi), z}).meanX2X0); };
+  std::mt19937 rng(20261007);
+  std::uniform_real_distribution<double> uniformPhi(0., 2. * std::numbers::pi);
+  const auto envelopes = PlacedEnvelopes<Det>::all();
+  // The TRK's chips carry a metal stack beyond the silicon; the others' layers end at it.
+  std::vector<LayerEnvelope> chips(envelopes.begin(), envelopes.end());
+  if constexpr (std::same_as<Det, detectors::TRKFT3>) {
+    const auto specs = Geometry<Det>::layerSpecs();
+    chips = tools::withStacks(envelopes, geometry.sensors(), specs, tools::trkStackThickness(geometry.sensors(), specs, Detector<Det>::nBarrelLayers));
+  }
+  std::cout << std::format(
+                 "\n// Measured by o2-gtrk-import-geometry --passives: one below each barrel layer, the first from the beam line, its\n"
+                 "// x/X0 across the gap at {} random azimuths and z, its radius the x/X0-weighted mean of {} cm steps at {}.\n",
+                 kSamples, kStep, kStepSamples)
+            << std::format("  static constexpr std::array<PassiveSpec, {}> passives{{{{\n", Detector<Det>::nBarrelLayers);
+  for (int layer = 0; layer < Detector<Det>::nBarrelLayers; ++layer) {
+    const auto& outer = envelopes[static_cast<std::size_t>(layer)];
+    const double low = layer == 0 ? 0. : chips[static_cast<std::size_t>(layer - 1)].rMax;
+    const double high = chips[static_cast<std::size_t>(layer)].rMin;
+    const double zMax = std::max(std::abs(outer.zMin), std::abs(outer.zMax));
+    std::uniform_real_distribution<double> uniformZ(-zMax, zMax);
+    double total = 0.;
+    for (int sample = 0; sample < kSamples; ++sample) {
+      total += budget(low, high, uniformPhi(rng), uniformZ(rng));
+    }
+    double sum = 0.;
+    double weighted = 0.;
+    const auto steps = static_cast<int>(std::ceil((high - low) / kStep));
+    for (int sample = 0; sample < kStepSamples; ++sample) {
+      const double phi = uniformPhi(rng);
+      const double z = uniformZ(rng);
+      for (int step = 0; step < steps; ++step) {
+        const double r = low + (step * kStep);
+        const double r1 = std::min(r + kStep, high);
+        const double x = budget(r, r1, phi, z);
+        sum += x;
+        weighted += x * 0.5 * (r + r1);
+      }
+    }
+    const double position = sum > 0. ? weighted / sum : 0.5 * (low + high);
+    std::cout << std::format(
+      "    {{.kind = PassiveSpec::Kind::kBarrel, .position = {:.4f}, .bandLow = {:.4f}, .bandHigh = {:.4f}, .low = {:.2f}, .high = {:.2f}, "
+      ".x2X0 = {:.3e}}},\n",
+      position, low, high, -zMax, zMax, total / kSamples);
+  }
+  std::cout << "  }};\n";
+}
+
+/// The material forward of the barrel, where the barrel's passive cylinders
+/// do not reach (the material the disc passes' seeds cross): between consecutive z
+/// boundaries of the layout on one side -- the barrel layers' ends and the
+/// discs' faces -- and in radial bands between the barrel layers' radii, the
+/// x/X0 along z at random (r, phi) in the band, its mean and its x/X0-weighted
+/// mean z. Printed as a table, from which disc-kind passives are drawn.
+template <DetectorLayout Det>
+void printForwardMaterial(int side)
+{
+  constexpr int kSamples = 1024;
+  constexpr double kStep = 0.05; // [cm]
+  const auto budget = [](double r, double phi, double z0, double z1) { return static_cast<double>(o2::base::GeometryManager::meanMaterialBudget(o2::math_utils::Point3D<double>{r * std::cos(phi), r * std::sin(phi), z0}, o2::math_utils::Point3D<double>{r * std::cos(phi), r * std::sin(phi), z1}).meanX2X0); };
+  std::mt19937 rng(20261022);
+  std::uniform_real_distribution<double> uniformPhi(0., 2. * std::numbers::pi);
+  const auto envelopes = PlacedEnvelopes<Det>::all();
+  std::vector<double> boundaries;
+  std::vector<double> radii{0.};
+  for (int layer = 0; layer < Detector<Det>::nLayers; ++layer) {
+    const auto& envelope = envelopes[static_cast<std::size_t>(layer)];
+    if (layer < Detector<Det>::nBarrelLayers) {
+      boundaries.push_back(std::max(std::abs(envelope.zMin), std::abs(envelope.zMax)));
+      radii.push_back(envelope.rMin);
+      radii.push_back(envelope.rMax);
+    } else if ((side > 0 && envelope.zMin > 0.) || (side < 0 && envelope.zMax < 0.)) {
+      boundaries.push_back(std::abs(envelope.zMin));
+      boundaries.push_back(std::abs(envelope.zMax));
+    }
+  }
+  std::ranges::sort(boundaries);
+  std::ranges::sort(radii);
+  boundaries.erase(std::ranges::unique(boundaries).begin(), boundaries.end());
+  radii.erase(std::ranges::unique(radii).begin(), radii.end());
+  std::cout << std::format(
+    "\nforward material on the {} side, x/X0 along z across each gap between the layout's z boundaries, in radial bands [cm]: "
+    "mean x/X0 [%], its x/X0-weighted mean |z| ({} rays a cell)\n",
+    side > 0 ? "+z" : "-z", kSamples);
+  std::string header = "  |z| gap        ";
+  for (std::size_t band = 0; band + 1U < radii.size(); ++band) {
+    header += std::format(" | r {:5.1f}-{:5.1f}", radii[band], radii[band + 1U]);
+  }
+  std::cout << header << '\n';
+  for (std::size_t gap = 0; gap + 1U < boundaries.size(); ++gap) {
+    const double z0 = boundaries[gap];
+    const double z1 = boundaries[gap + 1U];
+    if (z1 - z0 < 0.2) {
+      continue; // a layer's own thickness
+    }
+    std::string line = std::format("  {:6.1f}-{:6.1f}", z0, z1);
+    for (std::size_t band = 0; band + 1U < radii.size(); ++band) {
+      std::uniform_real_distribution<double> uniformR(radii[band], radii[band + 1U]);
+      double total = 0.;
+      double sum = 0.;
+      double weighted = 0.;
+      const auto steps = static_cast<int>(std::ceil((z1 - z0) / kStep));
+      for (int sample = 0; sample < kSamples; ++sample) {
+        const double r = uniformR(rng);
+        const double phi = uniformPhi(rng);
+        total += budget(r, phi, side * z0, side * z1);
+        if (sample < kSamples / 8) {
+          for (int step = 0; step < steps; ++step) {
+            const double a = z0 + (step * kStep);
+            const double b = std::min(a + kStep, z1);
+            const double x = budget(r, phi, side * a, side * b);
+            sum += x;
+            weighted += x * 0.5 * (a + b);
+          }
+        }
+      }
+      const double mean = 100. * total / kSamples;
+      line += mean > 0.005 ? std::format(" | {:5.2f} @ {:6.1f}", mean, sum > 0. ? weighted / sum : 0.5 * (z0 + z1)) : " |      -       ";
+    }
+    std::cout << line << '\n';
+  }
+}
+
+/// The azimuth a sensor covers at one value of its layer's second
+/// coordinate, an arc: from `start` [0, 2 pi) counter-clockwise over `length`.
+struct Arc {
+  double start = 0.;
+  double length = 0.;
+};
+
+constexpr double kTwoPi = 2. * std::numbers::pi;
+
+double wrap(double angle)
+{
+  const double wrapped = std::fmod(angle, kTwoPi);
+  return wrapped < 0. ? wrapped + kTwoPi : wrapped;
+}
+
+/// The shorter arc between the azimuths of two points.
+Arc arcBetween(const std::array<double, 2>& a, const std::array<double, 2>& b)
+{
+  const double from = std::atan2(a[1], a[0]);
+  double delta = std::atan2(b[1], b[0]) - from;
+  delta = std::remainder(delta, kTwoPi);
+  return delta >= 0. ? Arc{.start = wrap(from), .length = delta} : Arc{.start = wrap(from + delta), .length = -delta};
+}
+
+/// A flat sensor's active area in its mid-plane, its corners in order around it, global.
+std::array<std::array<double, 3>, 4> midPlane(const Sensor& sensor, const SensorSpec& spec)
+{
+  const std::array<std::array<double, 2>, 4> local{{{-spec.halfX, -spec.halfY}, {spec.halfX, -spec.halfY}, {spec.halfX, spec.halfY}, {-spec.halfX, spec.halfY}}};
+  std::array<std::array<double, 3>, 4> result{};
+  for (std::size_t i = 0; i < local.size(); ++i) {
+    const double point[3] = {local[i][0], local[i][1], 0.};
+    sensor.toGlobal(point, result[i].data());
+  }
+  return result;
+}
+
+/// The angular gap a union of arcs may leave and still count as closed: the
+/// rounding of the azimuths of abutting sensors.
+constexpr double kAzimuthRounding = 1e-9;
+
+/// Whether \a arcs cover every azimuth.
+bool coversCircle(std::vector<Arc>& arcs)
+{
+  std::vector<std::array<double, 2>> pieces;
+  for (const auto& arc : arcs) {
+    if (arc.length >= kTwoPi) {
+      return true;
+    }
+    const double end = arc.start + arc.length;
+    if (end > kTwoPi) {
+      pieces.push_back({arc.start, kTwoPi});
+      pieces.push_back({0., end - kTwoPi});
+    } else {
+      pieces.push_back({arc.start, end});
+    }
+  }
+  std::ranges::sort(pieces);
+  double reach = 0.;
+  for (const auto& [low, high] : pieces) {
+    if (low > reach + kAzimuthRounding) {
+      return false;
+    }
+    reach = std::max(reach, high);
+  }
+  return reach >= kTwoPi - kAzimuthRounding;
+}
+
+/// A disc sensor's arcs on the circle of radius \a r about the beam line,
+/// from its mid-plane projected along the beam: a convex quadrilateral.
+void discArcs(const std::array<std::array<double, 3>, 4>& quad, double r, std::vector<Arc>& arcs)
+{
+  const auto inside = [&](double x, double y) {
+    bool positive = false;
+    bool negative = false;
+    for (std::size_t i = 0; i < quad.size(); ++i) {
+      const auto& a = quad[i];
+      const auto& b = quad[(i + 1) % quad.size()];
+      const double cross = ((b[0] - a[0]) * (y - a[1])) - ((b[1] - a[1]) * (x - a[0]));
+      positive = positive || cross > 0.;
+      negative = negative || cross < 0.;
+    }
+    return !(positive && negative);
+  };
+  std::vector<double> angles;
+  for (std::size_t i = 0; i < quad.size(); ++i) {
+    const auto& p = quad[i];
+    const auto& q = quad[(i + 1) % quad.size()];
+    const double dx = q[0] - p[0];
+    const double dy = q[1] - p[1];
+    const double a = (dx * dx) + (dy * dy);
+    const double b = 2. * ((p[0] * dx) + (p[1] * dy));
+    const double c = (p[0] * p[0]) + (p[1] * p[1]) - (r * r);
+    const double discriminant = (b * b) - (4. * a * c);
+    if (a <= 0. || discriminant < 0.) {
+      continue;
+    }
+    for (const double sign : {-1., 1.}) {
+      const double t = (-b + (sign * std::sqrt(discriminant))) / (2. * a);
+      if (t >= 0. && t <= 1.) {
+        angles.push_back(wrap(std::atan2(p[1] + (t * dy), p[0] + (t * dx))));
+      }
+    }
+  }
+  if (angles.empty()) {
+    if (inside(r, 0.)) {
+      arcs.push_back({.start = 0., .length = kTwoPi});
+    }
+    return;
+  }
+  std::ranges::sort(angles);
+  for (std::size_t i = 0; i < angles.size(); ++i) {
+    const double from = angles[i];
+    const double length = i + 1 < angles.size() ? angles[i + 1] - from : angles[0] + kTwoPi - from;
+    const double middle = from + (0.5 * length);
+    if (length > 0. && inside(r * std::cos(middle), r * std::sin(middle))) {
+      arcs.push_back({.start = from, .length = length});
+    }
+  }
+}
+
+/// Where segments p0-p1 and q0-q1 of the transverse plane cross, if they do.
+std::optional<std::array<double, 2>> crossing(const std::array<double, 3>& p0, const std::array<double, 3>& p1, const std::array<double, 3>& q0, const std::array<double, 3>& q1)
+{
+  const double rx = p1[0] - p0[0];
+  const double ry = p1[1] - p0[1];
+  const double sx = q1[0] - q0[0];
+  const double sy = q1[1] - q0[1];
+  const double denominator = (rx * sy) - (ry * sx);
+  if (exactlyEqual(denominator, 0.)) {
+    return std::nullopt;
+  }
+  const double t = (((q0[0] - p0[0]) * sy) - ((q0[1] - p0[1]) * sx)) / denominator;
+  const double u = (((q0[0] - p0[0]) * ry) - ((q0[1] - p0[1]) * rx)) / denominator;
+  if (t < 0. || t > 1. || u < 0. || u > 1.) {
+    return std::nullopt;
+  }
+  return std::array<double, 2>{p0[0] + (t * rx), p0[1] + (t * ry)};
+}
+
+/// A barrel sensor's arc at \a z: a flat one's cut with the plane at z, seen
+/// from the beam line; a curved one's whole arc when z is on it.
+void barrelArcs(const Sensor& sensor, const SensorSpec& spec, double z, std::vector<Arc>& arcs)
+{
+  if (spec.curved()) {
+    std::array<std::array<double, 2>, 2> ends{};
+    for (std::size_t i = 0; i < 2; ++i) {
+      double frame[3];
+      spec.unrolledToFrame(i == 0 ? -spec.halfX : spec.halfX, 0., spec.halfThickness, frame);
+      double global[3];
+      sensor.toGlobal(frame, global);
+      ends[i] = {global[0], global[1]};
+    }
+    arcs.push_back(arcBetween(ends[0], ends[1]));
+    return;
+  }
+  const auto quad = midPlane(sensor, spec);
+  std::vector<std::array<double, 2>> cut;
+  for (std::size_t i = 0; i < quad.size(); ++i) {
+    const auto& p = quad[i];
+    const auto& q = quad[(i + 1) % quad.size()];
+    if ((p[2] - z) * (q[2] - z) > 0. || exactlyEqual(p[2], q[2])) {
+      continue;
+    }
+    const double t = (z - p[2]) / (q[2] - p[2]);
+    cut.push_back({p[0] + (t * (q[0] - p[0])), p[1] + (t * (q[1] - p[1]))});
+  }
+  if (cut.size() >= 2U) {
+    arcs.push_back(arcBetween(cut.front(), cut.back()));
+  }
+}
+
+/// Where each layer covers every azimuth: the intervals of its
+/// second coordinate -- z on a barrel layer, r on a disc -- at which some
+/// sensor's active silicon lies at every azimuth, in increasing order. A
+/// barrel sensor counts with its cut by the plane at that z, seen from the
+/// beam line; a disc sensor with its mid-plane projected along the beam.
+/// Layers numbered barrel first, as for `measureEnvelopes`.
+std::vector<std::vector<std::array<double, 2>>> measureCoverage(std::span<const Sensor> sensors, std::span<const SensorSpec> specs, int nBarrelLayers)
+{
+  const auto nLayers = specs.size();
+  std::vector<std::vector<std::size_t>> byLayer(nLayers);
+  for (std::size_t i = 0; i < sensors.size(); ++i) {
+    byLayer[sensors[i].layer].push_back(i);
+  }
+  std::vector<std::vector<std::array<double, 2>>> result(nLayers);
+  for (std::size_t layer = 0; layer < nLayers; ++layer) {
+    const bool barrel = std::cmp_less(layer, nBarrelLayers);
+    const auto& spec = specs[layer];
+    // Each sensor's range of the second coordinate, and the values where the
+    // coverage can change: a barrel sensor's ends in z; a disc sensor's
+    // corners, its edges' nearest points and the crossings of its edges with
+    // its neighbours'.
+    struct Span {
+      double low;
+      double high;
+      std::size_t sensor;
+    };
+    std::vector<Span> spans;
+    std::vector<double> critical;
+    std::vector<std::array<std::array<double, 3>, 4>> quads;
+    for (const auto index : byLayer[layer]) {
+      const auto extent = extentOf(sensors[index], spec);
+      spans.push_back({.low = barrel ? extent.zMin : extent.rMin, .high = barrel ? extent.zMax : extent.rMax, .sensor = quads.size()});
+      if (barrel) {
+        critical.push_back(extent.zMin);
+        critical.push_back(extent.zMax);
+        if (!spec.curved()) {
+          for (const auto& corner : midPlane(sensors[index], spec)) {
+            critical.push_back(corner[2]);
+          }
+        }
+        quads.push_back({});
+        continue;
+      }
+      const auto quad = midPlane(sensors[index], spec);
+      quads.push_back(quad);
+      for (std::size_t i = 0; i < quad.size(); ++i) {
+        const auto& p = quad[i];
+        const auto& q = quad[(i + 1) % quad.size()];
+        critical.push_back(std::hypot(p[0], p[1]));
+        const double dx = q[0] - p[0];
+        const double dy = q[1] - p[1];
+        const double length2 = (dx * dx) + (dy * dy);
+        const double t = length2 > 0. ? -((p[0] * dx) + (p[1] * dy)) / length2 : 0.;
+        if (t > 0. && t < 1.) {
+          critical.push_back(std::hypot(p[0] + (t * dx), p[1] + (t * dy)));
+        }
+      }
+    }
+    if (!barrel) {
+      const auto box = [&](std::size_t i) {
+        std::array<double, 4> b{std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()};
+        for (const auto& corner : quads[i]) {
+          b[0] = std::min(b[0], corner[0]);
+          b[1] = std::max(b[1], corner[0]);
+          b[2] = std::min(b[2], corner[1]);
+          b[3] = std::max(b[3], corner[1]);
+        }
+        return b;
+      };
+      std::vector<std::array<double, 4>> boxes(quads.size());
+      for (std::size_t i = 0; i < quads.size(); ++i) {
+        boxes[i] = box(i);
+      }
+      for (std::size_t i = 0; i < quads.size(); ++i) {
+        for (std::size_t j = i + 1; j < quads.size(); ++j) {
+          if (boxes[i][0] > boxes[j][1] || boxes[j][0] > boxes[i][1] || boxes[i][2] > boxes[j][3] || boxes[j][2] > boxes[i][3]) {
+            continue;
+          }
+          for (std::size_t a = 0; a < 4; ++a) {
+            for (std::size_t b = 0; b < 4; ++b) {
+              if (const auto point = crossing(quads[i][a], quads[i][(a + 1) % 4], quads[j][b], quads[j][(b + 1) % 4])) {
+                critical.push_back(std::hypot((*point)[0], (*point)[1]));
+              }
+            }
+          }
+        }
+      }
+    }
+    std::ranges::sort(critical);
+    const auto duplicates = std::ranges::unique(critical);
+    critical.erase(duplicates.begin(), duplicates.end());
+    std::ranges::sort(spans, {}, &Span::low);
+    // Between two neighbouring critical values the coverage is the same:
+    // tested at the middle, swept in order with the sensors whose range
+    // holds it.
+    std::vector<Span> active;
+    std::size_t next = 0;
+    std::vector<Arc> arcs;
+    auto& covered = result[layer];
+    for (std::size_t i = 0; i + 1 < critical.size(); ++i) {
+      const double value = 0.5 * (critical[i] + critical[i + 1]);
+      while (next < spans.size() && spans[next].low <= value) {
+        active.push_back(spans[next++]);
+      }
+      std::erase_if(active, [&](const Span& span) { return span.high < value; });
+      arcs.clear();
+      for (const auto& span : active) {
+        if (barrel) {
+          barrelArcs(sensors[byLayer[layer][span.sensor]], spec, value, arcs);
+        } else {
+          discArcs(quads[span.sensor], value, arcs);
+        }
+      }
+      if (!coversCircle(arcs)) {
+        continue;
+      }
+      if (!covered.empty() && exactlyEqual(covered.back()[1], critical[i])) {
+        covered.back()[1] = critical[i + 1];
+      } else {
+        covered.push_back({critical[i], critical[i + 1]});
+      }
+    }
+  }
+  return result;
+}
+
+template <DetectorLayout Det>
+int runFor(const std::string& file, bool passives)
+{
+  const auto sensors = alice::placeChips<Det>();
+  constexpr auto specs = Geometry<Det>::layerSpecs();
+  const auto measured = measureEnvelopes(sensors, specs, Detector<Det>::nBarrelLayers, kEnvelopeResolution);
+  std::vector<int> counts(measured.size(), 0);
+  for (const auto& sensor : sensors) {
+    ++counts[sensor.layer];
+  }
+  std::cout << std::format("  // Chip counts measured by o2-gtrk-import-geometry from {}: {} chips.\n", file, sensors.size());
+  const auto printLayers = [&](const char* member, std::size_t first, std::size_t end) {
+    if (first == end) {
+      return;
+    }
+    std::cout << std::format("  static constexpr std::array<PlacedLayerSpec, {}> {}{{{{\n", end - first, member);
+    for (std::size_t layer = first; layer < end; ++layer) {
+      std::cout << std::format("    {{.sensorCount = {}, .sensor = {}}},\n", counts[layer], sensorName<Det>(layer));
+    }
+    std::cout << "  }};\n";
+  };
+  constexpr auto kBarrel = static_cast<std::size_t>(Detector<Det>::nBarrelLayers);
+  printLayers("barrelLayers", 0, kBarrel);
+  printLayers("discLayers", kBarrel, measured.size());
+  std::cout << "\n"
+            << std::format("Envelopes of the active silicon, rounded outwards to {} um, which the tracking measures at load and nothing compiled holds:\n", kEnvelopeResolution * 1e4) << describeEnvelopes(measured, Detector<Det>::nBarrelLayers);
+  // Where each layer covers every azimuth: z on a barrel layer, r on a disc.
+  const auto start = std::chrono::steady_clock::now();
+  const auto coverage = measureCoverage(sensors, specs, Detector<Det>::nBarrelLayers);
+  std::cout << std::format("\nevery azimuth covered, measured in {:.3f} s:\n", std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count());
+  for (std::size_t layer = 0; layer < coverage.size(); ++layer) {
+    std::string line = std::format("layer {}:", layer);
+    for (const auto& [low, high] : coverage[layer]) {
+      line += std::format(" [{:.4f}, {:.4f}]", low, high);
+    }
+    std::cout << line << '\n';
+  }
+  int status = 0;
+  for (std::size_t layer = 0; layer < measured.size(); ++layer) {
+    const int stated = Detector<Det>::sensorCount(static_cast<LayerID>(layer));
+    if (stated != counts[layer]) {
+      std::cout << std::format("\ncompiled {} layer {}: {} chips, the geometry has {}", Det::name, layer, stated, counts[layer]);
+      status = 1;
+    }
+  }
+  std::cout << std::format("\ncompiled {} table {}\n", Det::name, status == 0 ? "has every chip" : "is stale: paste the table above");
+  if (status != 0) {
+    return status;
+  }
+  if constexpr (std::same_as<Det, detectors::TRKFT3>) {
+    const double worst = checkTRKPixels(sensors);
+    std::cout << std::format("\npixel centres, ours against O2's segmentation and L2G: at most {:.3e} um apart\n", worst * 1e4);
+    // O2's segmentation works in float: a few nm at these radii.
+    status = worst < 1e-5 ? 0 : 1;
+  }
+  if (passives) {
+    const Geometry<Det> geometry(sensors);
+    printPassives(geometry);
+    if constexpr (Detector<Det>::hasDiscs) {
+      printForwardMaterial<Det>(+1);
+      printForwardMaterial<Det>(-1);
+    }
+  }
+  return status;
+}
+
+int run(int argc, char** argv)
+{
+  std::string file;
+  std::string detector;
+  bool passives = false;
+  bpo::options_description description("Measure the ITS, MFT or ALICE 3 TRK layer table from an o2sim geometry");
+  description.add_options()                                                                                //
+    ("help,h", "this message")                                                                             //
+    ("geometry,g", bpo::value(&file)->default_value("o2sim_geometry-aligned.root"), "o2sim geometry file") //
+    ("detector,d", bpo::value(&detector)->default_value("ITS"), "ITS, MFT or TRKFT3")                      //
+    ("passives", bpo::bool_switch(&passives), "measure and print the barrel's passive scatterers, one per gap between its layers");
+  bpo::variables_map vm;
+  try {
+    bpo::store(bpo::parse_command_line(argc, argv, description), vm);
+    bpo::notify(vm);
+  } catch (const bpo::error& error) {
+    std::cerr << error.what() << "\n\n"
+              << description << '\n';
+    return 1;
+  }
+  if (vm.contains("help")) {
+    std::cout << description << '\n';
+    return 0;
+  }
+  o2::base::GeometryManager::loadGeometry(file);
+  if (detector == "ITS") {
+    return runFor<detectors::ITS>(file, passives);
+  }
+  if (detector == "MFT") {
+    return runFor<detectors::MFT>(file, passives);
+  }
+  if (detector == "TRKFT3") {
+    return runFor<detectors::TRKFT3>(file, passives);
+  }
+  std::cerr << "unknown detector '" << detector << "'\n";
+  return 1;
+}
+
+} // namespace
+
+} // namespace o2::gtrk::tools
+
+int main(int argc, char** argv)
+{
+  try {
+    return o2::gtrk::tools::run(argc, argv);
+  } catch (const std::exception& error) {
+    std::cerr << "error: " << error.what() << '\n';
+    return 1;
+  }
+}
diff --git a/Detectors/GenericTracking/tools/src/layerLinks.cxx b/Detectors/GenericTracking/tools/src/layerLinks.cxx
new file mode 100644
index 0000000000000..ba28842a38d88
--- /dev/null
+++ b/Detectors/GenericTracking/tools/src/layerLinks.cxx
@@ -0,0 +1,516 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file layerLinks.cxx
+/// \brief Trace a detector's layer links from its layout.
+///
+/// **Trace.** A barrel layer is phi-symmetric, the segment `r = R,
+/// z in [-L, L]` of its stated envelope in (r, z). A helix is a straight line
+/// in (s, z) with `r(s) = 2 R_c sin(s / 2 R_c)`, so its barrel crossings are
+/// closed form. Trajectories run over z0 in the given beam-spot
+/// range, eta over the given acceptance and curvature from zero to the floor
+/// pT's, each followed over its outgoing half-turn only. Consecutive crossings
+/// form links; a link's source interval is the hull of the source coordinate
+/// over its crossings, padded by the margin. A link skips a layer when every
+/// trajectory on it crosses another layer's envelope -- a barrel layer's
+/// cylinder over its length, a disc's plane over its radii -- between its two
+/// crossings: through a gap in that layer's silicon. One trajectory that
+/// crosses nothing between makes it direct; whether a pair on it leaves a
+/// hole is then the pair's own (Tracking/LinkHoles.h).
+///
+/// The printed table is pasted into the detector's header. Nothing checks the
+/// two against each other afterwards; regenerating the table is part of
+/// changing a layout.
+///
+/// **Discs.** Every layout is placed from the loaded geometry (ITS, MFT,
+/// TRKFT3), and a disc layer need not be a ring: an MFT face covers only part
+/// of its disc, so a track crosses one face of a disc or the other. The discs'
+/// crossings are therefore found in three dimensions, over azimuth and both
+/// charges, against a raster of the sensors' active silicon placed from the
+/// geometry.
+
+#include "GenericTracking/Alice/TRK.h"
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Tracking/SearchWindow.h"
+#include "GenericTracking/Tools/SensorFrame.h"
+
+#include "DataFormatsParameters/GRPMagField.h"
+#include "DetectorsBase/GeometryManager.h"
+#include "DetectorsBase/Propagator.h"
+
+#include <boost/program_options.hpp>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <exception>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <map>
+#include <memory>
+#include <numbers>
+#include <span>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+namespace bpo = boost::program_options;
+
+namespace o2::gtrk::tools
+{
+namespace
+{
+
+/// The trace's settings, all but the field's Bz the options' (their defaults in `run`).
+struct Options {
+  std::string detector;
+  double beamSpotZ;
+  double beamSpotHalfRange;
+  double minPtGeV;
+  std::string field;       ///< the run's GRPMagField file
+  double bzKiloGauss = 0.; ///< its nominal Bz, set once the field is loaded
+  double etaMax;
+  int etaSteps;
+  int z0Steps;
+  int curvatureSteps;
+  double margin;
+  /// Links carrying less than this fraction of their source layer's crossings
+  /// are left out of the printed table (the shares are those of the full trace).
+  double minShare;
+  std::string geometry;
+  int phiSteps;
+};
+
+/// One barrel layer's surface in (r, z): its stated envelope; the discs are
+/// traced against their placed silicon (`discCoverage`).
+struct Surface {
+  LayerID layer = 0;
+  double position = 0.; ///< R [cm]
+  double low = 0.;      ///< extent along z [cm]
+  double high = 0.;
+};
+
+template <DetectorLayout Det>
+std::vector<Surface> surfaces()
+{
+  std::vector<Surface> result;
+  for (int layer = 0; layer < Detector<Det>::nLayers; ++layer) {
+    const auto id = static_cast<LayerID>(layer);
+    if (Detector<Det>::isBarrelLayer(id)) {
+      result.push_back({.layer = id, .position = layerDistance<Det>(id), .low = secondMin<Det>(id), .high = secondMax<Det>(id)});
+    }
+  }
+  return result;
+}
+
+/// A crossing of one layer by one trajectory.
+struct Crossing {
+  double path = 0.; ///< transverse path length from the origin
+  LayerID layer = 0;
+  double second = 0.; ///< z on a barrel layer, r on a disc [cm]
+};
+
+/// What is known about one link from either source.
+struct LinkStats {
+  std::size_t count = 0;
+  std::size_t direct = 0; ///< of them, crossing no other layer's envelope between its two layers
+  double low = std::numeric_limits<double>::infinity();
+  double high = -std::numeric_limits<double>::infinity();
+
+  void add(double second)
+  {
+    ++count;
+    low = std::min(low, second);
+    high = std::max(high, second);
+  }
+};
+
+using LinkMap = std::map<std::pair<LayerID, LayerID>, LinkStats>;
+
+/// Visit the consecutive transitions of one list of crossings, taking each
+/// layer's first crossing only: the link, and its two crossings.
+template <typename Visitor>
+void forEachTransition(std::vector<Crossing>& crossings, std::vector<bool>& seen, Visitor visit)
+{
+  std::ranges::sort(crossings, {}, &Crossing::path);
+  seen.assign(seen.size(), false);
+  const Crossing* previous = nullptr;
+  for (const auto& crossing : crossings) {
+    if (seen[crossing.layer]) {
+      continue; // a second ring of the same disc, or a sensor overlap
+    }
+    seen[crossing.layer] = true;
+    if (previous != nullptr) {
+      visit(std::pair{previous->layer, crossing.layer}, *previous, crossing);
+    }
+    previous = &crossing;
+  }
+}
+
+/// Whether a trajectory crossing \a envelopes passes over a layer other than
+/// \a from's and \a to's between them.
+bool overAnotherLayer(std::span<const Crossing> envelopes, const Crossing& from, const Crossing& to)
+{
+  return std::ranges::any_of(envelopes, [&](const Crossing& envelope) { return envelope.layer != from.layer && envelope.layer != to.layer && envelope.path > from.path && envelope.path < to.path; });
+}
+
+/// Which points of a placed disc layer's plane are on active silicon, as a
+/// raster of kCell squares centred on the beam line.
+struct DiscCoverage {
+  static constexpr double kCell = 0.01; // [cm]
+
+  LayerID layer = 0;
+  double z = 0.;    ///< [cm]
+  double rMin = 0.; ///< [cm]
+  double rMax = 0.;
+  int cells = 0; ///< per side
+  std::vector<bool> covered;
+
+  [[nodiscard]] double half() const { return 0.5 * kCell * cells; }
+
+  [[nodiscard]] bool contains(double x, double y) const
+  {
+    const double ix = std::floor((x + half()) / kCell);
+    const double iy = std::floor((y + half()) / kCell);
+    if (ix < 0. || iy < 0. || ix >= cells || iy >= cells) {
+      return false;
+    }
+    return covered[(static_cast<std::size_t>(iy) * static_cast<std::size_t>(cells)) + static_cast<std::size_t>(ix)];
+  }
+};
+
+/// The coverage of every disc layer of a placed geometry. A cell is covered
+/// when its centre, on the sensor's plane, is inside the sensor's bounds.
+template <DetectorLayout Det>
+std::vector<DiscCoverage> discCoverage(const Geometry<Det>& geometry)
+{
+  std::vector<DiscCoverage> result;
+  for (int layer = Detector<Det>::nBarrelLayers; layer < Detector<Det>::nLayers; ++layer) {
+    const auto id = static_cast<LayerID>(layer);
+    DiscCoverage coverage{.layer = id, .z = discZ<Det>(id), .rMin = secondMin<Det>(id), .rMax = secondMax<Det>(id), .cells = 0, .covered = {}};
+    coverage.cells = 2 * static_cast<int>(std::ceil(coverage.rMax / DiscCoverage::kCell)) + 2;
+    coverage.covered.assign(static_cast<std::size_t>(coverage.cells) * static_cast<std::size_t>(coverage.cells), false);
+    const double half = coverage.half();
+    for (const auto& sensor : geometry.sensors()) {
+      if (sensor.layer != id) {
+        continue;
+      }
+      const auto& spec = Geometry<Det>::layerSpec(id);
+      // The sensor's bounding box in the raster, from its corners.
+      double low[2] = {std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()};
+      double high[2] = {-std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()};
+      for (const double u : {-spec.halfX, spec.halfX}) {
+        for (const double v : {-spec.halfY, spec.halfY}) {
+          const double local[3] = {u, v, 0.};
+          double global[3];
+          sensor.toGlobal(local, global);
+          for (int i = 0; i < 2; ++i) {
+            low[i] = std::min(low[i], global[i]);
+            high[i] = std::max(high[i], global[i]);
+          }
+        }
+      }
+      const auto cell = [half](double value) { return static_cast<int>(std::floor((value + half) / DiscCoverage::kCell)); };
+      for (int iy = std::max(cell(low[1]), 0); iy <= std::min(cell(high[1]), coverage.cells - 1); ++iy) {
+        for (int ix = std::max(cell(low[0]), 0); ix <= std::min(cell(high[0]), coverage.cells - 1); ++ix) {
+          const double global[3] = {((ix + 0.5) * DiscCoverage::kCell) - half, ((iy + 0.5) * DiscCoverage::kCell) - half, sensor.trans[2]};
+          double local[3];
+          toLocal(sensor, global, local);
+          if (contains(spec, local[0], local[1])) {
+            coverage.covered[(static_cast<std::size_t>(iy) * static_cast<std::size_t>(coverage.cells)) + static_cast<std::size_t>(ix)] = true;
+          }
+        }
+      }
+    }
+    result.push_back(std::move(coverage));
+  }
+  return result;
+}
+
+template <DetectorLayout Det>
+LinkMap trace(const Options& options, std::span<const DiscCoverage> placedDiscs)
+{
+  const auto layout = surfaces<Det>();
+  const double maxCurvature = 1. / curvatureRadius(options.minPtGeV, options.bzKiloGauss);
+
+  LinkMap links;
+  std::vector<Crossing> crossings;
+  std::vector<Crossing> envelopes;
+  std::vector<Crossing> all;
+  std::vector<std::pair<const DiscCoverage*, double>> reached; // a placed disc and the transverse path to it
+  std::vector<bool> seen(static_cast<std::size_t>(Detector<Det>::nLayers));
+  const auto step = [](double low, double high, int steps, int i) { return steps > 1 ? low + ((high - low) * i / (steps - 1)) : 0.5 * (low + high); };
+  for (int ie = 0; ie < options.etaSteps; ++ie) {
+    const double cotTheta = std::sinh(step(-options.etaMax, options.etaMax, options.etaSteps, ie));
+    for (int iz = 0; iz < options.z0Steps; ++iz) {
+      const double z0 = step(options.beamSpotZ - options.beamSpotHalfRange, options.beamSpotZ + options.beamSpotHalfRange, options.z0Steps, iz);
+      for (int ik = 0; ik < options.curvatureSteps; ++ik) {
+        const double k = options.curvatureSteps > 1 ? maxCurvature * ik / (options.curvatureSteps - 1) : 0.;
+        const double halfTurn = k > 0. ? std::numbers::pi_v<double> / k : std::numeric_limits<double>::infinity();
+        crossings.clear();
+        for (const auto& surface : layout) {
+          if (k * surface.position > 2.) {
+            continue; // turns back before it gets there
+          }
+          const double s = k > 0. ? 2. / k * std::asin(0.5 * k * surface.position) : surface.position;
+          const double z = z0 + (s * cotTheta);
+          if (z >= surface.low && z <= surface.high) {
+            crossings.push_back({.path = s, .layer = surface.layer, .second = z});
+          }
+        }
+        // Every layer's envelope the trajectory crosses: a barrel layer's
+        // surface is its envelope; a disc's is its plane over its radii,
+        // between its rings and wherever its silicon is.
+        envelopes.clear();
+        for (const auto& crossing : crossings) {
+          if (Detector<Det>::isBarrelLayer(crossing.layer)) {
+            envelopes.push_back(crossing);
+          }
+        }
+        if (!exactlyEqual(cotTheta, 0.)) {
+          for (int layer = Detector<Det>::nBarrelLayers; layer < Detector<Det>::nLayers; ++layer) {
+            const auto id = static_cast<LayerID>(layer);
+            const double s = (discZ<Det>(id) - z0) / cotTheta;
+            const double r = k > 0. ? 2. / k * std::sin(0.5 * k * s) : s;
+            if (s > 0. && s <= halfTurn && r >= secondMin<Det>(id) && r <= secondMax<Det>(id)) {
+              envelopes.push_back({.path = s, .layer = id, .second = r});
+            }
+          }
+        }
+        const auto count = [&links, &envelopes](auto link, const Crossing& from, const Crossing& to) {
+          auto& stats = links[link];
+          stats.add(from.second);
+          stats.direct += overAnotherLayer(envelopes, from, to) ? 0U : 1U;
+        };
+
+        // Where a placed disc's plane is reached does not depend on azimuth
+        // or charge; whether it is on silicon there does.
+        reached.clear();
+        if (!exactlyEqual(cotTheta, 0.)) {
+          for (const auto& disc : placedDiscs) {
+            const double s = (disc.z - z0) / cotTheta;
+            const double r = k > 0. ? 2. / k * std::sin(0.5 * k * s) : s;
+            if (s > 0. && s <= halfTurn && r >= disc.rMin && r <= disc.rMax) {
+              reached.emplace_back(&disc, s);
+            }
+          }
+        }
+        if (reached.empty()) {
+          forEachTransition(crossings, seen, count);
+          continue;
+        }
+        for (const double charge : {-1., 1.}) {
+          for (int ip = 0; ip < options.phiSteps; ++ip) {
+            const double phi0 = 2. * std::numbers::pi_v<double> * ip / options.phiSteps;
+            all = crossings;
+            for (const auto& [disc, s] : reached) {
+              const double turn = charge * k;
+              const double x = k > 0. ? (std::sin(phi0 + (turn * s)) - std::sin(phi0)) / turn : s * std::cos(phi0);
+              const double y = k > 0. ? (std::cos(phi0) - std::cos(phi0 + (turn * s))) / turn : s * std::sin(phi0);
+              if (disc->contains(x, y)) {
+                all.push_back({.path = s, .layer = disc->layer, .second = std::hypot(x, y)});
+              }
+            }
+            forEachTransition(all, seen, count);
+          }
+          if (!(k > 0.)) {
+            break; // a straight line has no charge
+          }
+        }
+      }
+    }
+  }
+  return links;
+}
+
+template <DetectorLayout Det>
+std::string layerName(LayerID layer)
+{
+  std::ostringstream name;
+  if (Detector<Det>::isBarrelLayer(layer)) {
+    name << layer << " (barrel r " << std::defaultfloat << std::setprecision(4) << layerDistance<Det>(layer) << ")";
+  } else {
+    name << layer << " (disc z " << std::showpos << std::defaultfloat << std::setprecision(4) << discZ<Det>(layer) << std::noshowpos << ")";
+  }
+  return name.str();
+}
+
+/// The fraction of each link's source layer's transitions that take it.
+std::map<std::pair<LayerID, LayerID>, double> weights(const LinkMap& links)
+{
+  std::map<LayerID, std::size_t> leaving;
+  for (const auto& [link, stats] : links) {
+    leaving[link.first] += stats.count;
+  }
+  std::map<std::pair<LayerID, LayerID>, double> result;
+  for (const auto& [link, stats] : links) {
+    result[link] = static_cast<double>(stats.count) / static_cast<double>(leaving[link.first]);
+  }
+  return result;
+}
+
+/// The links at or above \a minShare of their source layer's crossings, the
+/// shares those of the full map.
+LinkMap pruned(const LinkMap& links, double minShare)
+{
+  const auto weight = weights(links);
+  LinkMap result;
+  for (const auto& [link, stats] : links) {
+    if (weight.at(link) >= minShare) {
+      result.emplace(link, stats);
+    }
+  }
+  return result;
+}
+
+template <DetectorLayout Det>
+void printTable(const LinkMap& links, const Options& options)
+{
+  const auto weight = weights(links);
+  const auto kept = pruned(links, options.minShare);
+  std::cout << std::defaultfloat << "  // Traced by o2-gtrk-layer-links for " << Det::name << ": pT >= " << options.minPtGeV << " GeV at Bz = " << options.bzKiloGauss << " kG,\n"
+            << "  // beam spot z in [" << options.beamSpotZ - options.beamSpotHalfRange << ", " << options.beamSpotZ + options.beamSpotHalfRange << "] cm, |eta| <= " << options.etaMax << ", source intervals padded by " << options.margin << " cm.\n"
+            << "  // The comment on each link is the fraction of its source layer's crossings that take it.\n";
+  if (options.minShare > 0.) {
+    std::cout << "  // Links below " << options.minShare << " of their source layer's crossings are left out (" << links.size() - kept.size() << " of " << links.size() << ").\n";
+  }
+  std::cout << "  static constexpr std::array<LayerLink, " << kept.size() << "> layerLinks{{\n";
+  for (const auto& [link, stats] : kept) {
+    const double low = std::floor((stats.low - options.margin) * 100.) / 100.;
+    const double high = std::ceil((stats.high + options.margin) * 100.) / 100.;
+    const bool skips = stats.direct == 0U;
+    std::cout << "    {.from = " << link.first << ", .to = " << link.second << std::fixed << std::setprecision(2) << ", .sourceMin = " << low << ", .sourceMax = " << high << ", .skipsLayer = " << (skips ? "true" : "false") << "}, // " << std::setprecision(4) << weight.at(link) << '\n';
+  }
+  std::cout << "  }};\n";
+}
+
+template <DetectorLayout Det>
+void printSummary(const LinkMap& links)
+{
+  std::size_t twoLinkPaths = 0;
+  std::map<LayerID, std::size_t> outDegree;
+  for (const auto& [link, stats] : links) {
+    ++outDegree[link.first];
+  }
+  std::size_t maxOut = 0;
+  for (const auto& [link, stats] : links) {
+    twoLinkPaths += outDegree.contains(link.second) ? outDegree[link.second] : 0U;
+    maxOut = std::max(maxOut, outDegree[link.first]);
+  }
+  std::cerr << Det::name << ": " << Detector<Det>::nLayers << " layers, " << links.size() << " links, " << twoLinkPaths << " two-link paths, at most " << maxOut << " links leaving a layer\n";
+}
+
+template <DetectorLayout Det>
+int runFor(const Options& options)
+{
+  // A layout's extents are its loaded geometry's, on the ITS as well as on the MFT.
+  o2::base::GeometryManager::loadGeometry(options.geometry);
+  const auto geometry = std::make_unique<const Geometry<Det>>(alice::placeChecked<Det>());
+  std::vector<DiscCoverage> coverage;
+  if constexpr (Detector<Det>::hasDiscs) {
+    coverage = discCoverage<Det>(*geometry);
+  }
+  const auto traced = trace<Det>(options, coverage);
+  printSummary<Det>(traced);
+  printTable<Det>(traced, options);
+  return 0;
+}
+
+int run(int argc, char** argv)
+{
+  Options options;
+  bpo::options_description description("Trace a detector's layer links");
+  description.add_options()                                                                                      //
+    ("help,h", "this message")                                                                                   //
+    ("detector,d", bpo::value(&options.detector)->required(), "ITS, MFT or TRKFT3")                              //
+    ("beam-spot-z", bpo::value(&options.beamSpotZ)->default_value(0.), "centre of the traced vertex range [cm]") //
+    ("beam-spot-range", bpo::value(&options.beamSpotHalfRange)->default_value(18.),
+     "half-width of the traced vertex range [cm]; 3 sigma of a 6 cm spot by default") //
+    ("min-pt", bpo::value(&options.minPtGeV)->default_value(0.1),
+     "floor pT [GeV]: the lowest any iteration will ask for") //
+    ("grp-mag-field", bpo::value(&options.field)->default_value(""),
+     "the run's GRPMagField, e.g. <sample>/ccdb/GLO/Config/GRPMagField/snapshot.root; the trace takes its nominal Bz. Not for TRKFT3, whose field is "
+     "ALICE3_MAGFIELD_MACRO's")                                                       //
+    ("eta-max", bpo::value(&options.etaMax)->default_value(6.), "traced |eta| range") //
+    ("eta-steps", bpo::value(&options.etaSteps)->default_value(6001), "eta samples")  //
+    ("z0-steps", bpo::value(&options.z0Steps)->default_value(13), "vertex samples")   //
+    ("curvature-steps", bpo::value(&options.curvatureSteps)->default_value(201),
+     "curvature samples, from a straight line to the floor pT") //
+    ("min-share", bpo::value(&options.minShare)->default_value(0.),
+     "leave links carrying less than this fraction of their source layer's crossings out of the printed table") //
+    ("margin", bpo::value(&options.margin)->default_value(0.5),
+     "padding on each end of a source interval [cm]") //
+    ("geometry,g", bpo::value(&options.geometry)->default_value("o2sim_geometry-aligned.root"),
+     "o2sim geometry a placed layout's discs are traced against") //
+    ("phi-steps", bpo::value(&options.phiSteps)->default_value(180), "azimuth samples, per charge, where a placed disc is reached");
+
+  bpo::variables_map vm;
+  try {
+    bpo::store(bpo::parse_command_line(argc, argv, description), vm);
+    if (vm.contains("help")) {
+      std::cout << description << '\n';
+      return 0;
+    }
+    bpo::notify(vm);
+  } catch (const bpo::error& error) {
+    std::cerr << error.what() << "\n\n"
+              << description << '\n';
+    return 1;
+  }
+  // The field as the tracking takes it: O2's nominal Bz of the run's map;
+  // for ALICE 3, whose GRP records none, its field object's Bz at the origin.
+  if (options.detector == "TRKFT3") {
+    options.bzKiloGauss = alice::alice3BzKiloGauss();
+  } else {
+    if (options.field.empty()) {
+      std::cerr << "no field: --grp-mag-field names the run's GRPMagField\n";
+      return 1;
+    }
+    const std::unique_ptr<o2::parameters::GRPMagField> grp{o2::parameters::GRPMagField::loadFrom(options.field)};
+    o2::base::Propagator::initFieldFromGRP(grp.get());
+    options.bzKiloGauss = static_cast<double>(o2::base::Propagator::Instance()->getNominalBz());
+  }
+
+  using namespace detectors;
+  if (options.detector == "ITS") {
+    return runFor<ITS>(options);
+  }
+  if (options.detector == "MFT") {
+    return runFor<MFT>(options);
+  }
+  if (options.detector == "TRKFT3") {
+    return runFor<TRKFT3>(options);
+  }
+  std::cerr << "unknown detector '" << options.detector << "'\n";
+  return 1;
+}
+
+} // namespace
+} // namespace o2::gtrk::tools
+
+int main(int argc, char** argv)
+{
+  try {
+    return o2::gtrk::tools::run(argc, argv);
+  } catch (const std::exception& error) {
+    std::cerr << "error: " << error.what() << '\n';
+    return 1;
+  }
+}
diff --git a/Detectors/GenericTracking/tracking/CMakeLists.txt b/Detectors/GenericTracking/tracking/CMakeLists.txt
new file mode 100644
index 0000000000000..e63d3c6955037
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/CMakeLists.txt
@@ -0,0 +1,42 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+# The tracking: the track model, the stages, the tracker and the vertexer,
+# header code compiled into whichever target includes it. The compiled part is
+# host only; TBB stays private behind Parallel.h.
+o2_add_library(GTrkTracking
+               SOURCES src/Parallel.cxx
+                       src/Profile.cxx
+                       src/WorkCounters.cxx
+                       src/GPU/DeviceArena.cxx
+                       src/GPU/DeviceContext.cxx
+                       src/GPU/GPUChainGenericTracking.cxx
+                       src/GPU/RuntimeFactory.cxx
+                       src/GPU/DeviceStream.cxx
+                       src/GPU/MaterialPort.cxx
+               PUBLIC_LINK_LIBRARIES O2::GTrkBase O2::GPUCommon O2::CommonConstants O2::MathUtils O2::DetectorsBase
+               PRIVATE_LINK_LIBRARIES TBB::tbb O2::GPUTracking
+               TARGETVARNAME targetName)
+
+# The work counters (Tracking/WorkCounters.h) count only where this is on: a
+# tree of its own for the studies, since a count touches the hot loops. Public,
+# so that every unit that instantiates the tracking counts alike.
+option(GTRK_WORK_COUNTERS "Count the work inside the generic tracking's stages" OFF)
+if(GTRK_WORK_COUNTERS)
+  target_compile_definitions(${targetName} PUBLIC GTRK_WORK_COUNTERS)
+endif()
+
+# o2_add_library installs the headers of include/<library name> only.
+target_include_directories(${targetName} PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+install(DIRECTORY include/GenericTracking DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+add_subdirectory(GPU)
+add_subdirectory(test)
diff --git a/Detectors/GenericTracking/tracking/GPU/CMakeLists.txt b/Detectors/GenericTracking/tracking/GPU/CMakeLists.txt
new file mode 100644
index 0000000000000..b236425f35e7d
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/CMakeLists.txt
@@ -0,0 +1,120 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+# The device tracker for CUDA and, hipified from the same sources, for HIP:
+# relocatable device code, device-linked with O2's out-of-line device
+# functions (MatLayerCylSet's LUT query and what it calls, from O2's GPU
+# external provider) into one shared library per backend, which O2's GPU
+# backend links; loaded with it, the library registers its runtime
+# (RuntimeFactory.h).
+
+if(NOT CUDA_ENABLED AND NOT HIP_ENABLED)
+  return()
+endif()
+
+# gtrk_hipify(<output-variable> <source.cu>...): one .hip in the build tree
+# per .cu source; only the .cu files are translated, so the headers they
+# include stay vendor-neutral.
+function(gtrk_hipify output)
+  set(generated)
+  foreach(source IN LISTS ARGN)
+    get_filename_component(absolute "${source}" ABSOLUTE)
+    get_filename_component(name "${source}" NAME_WE)
+    set(hip "${CMAKE_CURRENT_BINARY_DIR}/hipified/${name}.hip")
+    add_custom_command(OUTPUT "${hip}"
+                       COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/hipified"
+                       COMMAND ${hip_HIPIFY_PERL_EXECUTABLE} -quiet-warnings "-o=${hip}" "${absolute}"
+                       DEPENDS "${absolute}"
+                       COMMENT "Hipifying ${source}"
+                       VERBATIM)
+    list(APPEND generated "${hip}")
+  endforeach()
+  set(${output} ${generated} PARENT_SCOPE)
+endfunction()
+
+# gtrk_device_sources(<output-variable> <CUDA|HIP> <source.cu>...): the
+# sources as written for CUDA, hipified for HIP.
+function(gtrk_device_sources output backend)
+  set(sources ${ARGN})
+  if(backend STREQUAL "HIP")
+    gtrk_hipify(sources ${ARGN})
+    set_source_files_properties(${sources} PROPERTIES LANGUAGE HIP)
+  endif()
+  set(${output} ${sources} PARENT_SCOPE)
+endfunction()
+
+# gtrk_device_target(<target> <CUDA|HIP> <SHARED|OBJECT> [<exported symbol pattern>...]):
+# a library of device code for one backend, device-linked with O2's external
+# provider as ITS's is, but without device LTO, which moves results in their
+# last bits. The CUDA runtime is the
+# shared one, so every library of a process talks to the same runtime state;
+# cross-execution-space calls are errors. A shared library exports only its
+# entries: ITS's GPU library carries the provider too, and its relocatable
+# device code's registration symbols would otherwise bind to one copy in a
+# process that loads both.
+set(GTRK_DEVICE_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/cuda" CACHE INTERNAL "")
+function(gtrk_device_target target backend type)
+  # The device headers next to the CUDA sources: a hipified .hip lives in the
+  # build tree, so a quoted include does not find them beside it.
+  target_include_directories(${target} PRIVATE "${CMAKE_SOURCE_DIR}" "${GTRK_DEVICE_HEADERS}")
+  string(TOLOWER "${backend}" backend_namespace)
+  target_compile_definitions(${target} PRIVATE GTRK_BACKEND_NAMESPACE=${backend_namespace} GTRK_BACKEND_${backend})
+  set_target_gpu_arch("${backend}" ${target})
+  # The architecture's parameters (GPUCA_WARP_SIZE): GPUDefParametersWrapper.h.
+  target_link_libraries(${target} PRIVATE O2::GPUTracking)
+  set_target_properties(${target} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+  if(type STREQUAL "SHARED")
+    target_link_libraries(${target} PRIVATE O2::GPUTracking${backend}ExternalProvider)
+    set(version_script "${CMAKE_CURRENT_BINARY_DIR}/${target}.exports")
+    list(JOIN ARGN "; " exported)
+    if(exported)
+      file(GENERATE OUTPUT "${version_script}" CONTENT "{ global: ${exported}; local: *; };\n")
+    else()
+      file(GENERATE OUTPUT "${version_script}" CONTENT "{ local: *; };\n")
+    endif()
+    target_link_options(${target} PRIVATE "LINKER:--version-script=${version_script}")
+    set_property(TARGET ${target} APPEND PROPERTY LINK_DEPENDS "${version_script}")
+  endif()
+  if(backend STREQUAL "CUDA")
+    set_target_properties(${target} PROPERTIES CUDA_SEPARABLE_COMPILATION ON CUDA_RUNTIME_LIBRARY Shared)
+    if(type STREQUAL "SHARED")
+      set_target_properties(${target} PROPERTIES CUDA_RESOLVE_DEVICE_SYMBOLS ON)
+    endif()
+    target_compile_options(${target} PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:-Werror=cross-execution-space-call>)
+  else()
+    # FindO2GPU compiles HIP with -ffast-math outside the deterministic mode,
+    # and that includes -ffinite-math-only: comparisons with an infinite
+    # start value or a NaN guard become undefined. Only the finite-math
+    # assumption is taken out (CUDA's -use_fast_math makes none).
+    target_compile_options(${target} PRIVATE $<$<COMPILE_LANGUAGE:HIP>:-fgpu-rdc -fno-finite-math-only>)
+    # hipCUB, CUB's interface on rocPRIM, for the scans.
+    target_link_libraries(${target} PRIVATE hip::hipcub)
+    if(type STREQUAL "SHARED")
+      target_link_options(${target} PRIVATE -fgpu-rdc --hip-link)
+      target_link_libraries(${target} PRIVATE hip::host)
+    endif()
+  endif()
+endfunction()
+
+foreach(backend IN ITEMS CUDA HIP)
+  if(NOT ${backend}_ENABLED)
+    continue()
+  endif()
+  string(TOLOWER ${backend} lower)
+
+  # One device tracker per layout and unit, compiled in parallel.
+  gtrk_device_sources(sources ${backend} cuda/DeviceRuntime.cu cuda/DeviceTrackerITS.cu cuda/DeviceTrackerMFT.cu cuda/DeviceTrackerTRKFT3.cu)
+  o2_add_library(GTrkTracking${backend}
+                 SOURCES ${sources}
+                 PUBLIC_LINK_LIBRARIES O2::GTrkTracking
+                 TARGETVARNAME targetName)
+  gtrk_device_target(${targetName} ${backend} SHARED)
+endforeach()
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/DeviceAlgorithms.cuh b/Detectors/GenericTracking/tracking/GPU/cuda/DeviceAlgorithms.cuh
new file mode 100644
index 0000000000000..cb2a759859689
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/DeviceAlgorithms.cuh
@@ -0,0 +1,309 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceAlgorithms.cuh
+/// \brief Device algorithms the tracking's passes share.
+///
+///   forEach            a device functor for every element, one thread each
+///   forEachGroup       a device functor for every item, a group of lanes each
+///   Gather             one array gathered through an index array
+///   keyBits            the bits a radix sort needs for keys up to a largest
+///   selectIndices      the indices a predicate holds for, in order
+///   exclusiveScan      an exclusive sum with its storage on the scratch end
+///   inclusiveScan      an inclusive scan by any operator, the same
+///   sortPairs          a stable radix sort of key-value pairs, the same
+///   sortKeys           a stable radix sort of keys alone, the same
+///   segmentedStableSortPairs  key-value pairs sorted within each segment
+///   sweepToFixedPoint  a pass repeated until it changes nothing, its flags
+///                      read back once per pass
+///
+/// Each takes the runtime, arena and stream; temporaries go to the scratch
+/// end and are released on return. Released scratch is only reused by work
+/// queued after it on the same stream, as in GpuStage. Included by the .cu
+/// sources of a backend library or its test library, in the backend's
+/// namespace.
+
+#ifndef GTRK_TRACKING_GPU_DEVICEALGORITHMS_CUH_
+#define GTRK_TRACKING_GPU_DEVICEALGORITHMS_CUH_
+
+#include "LaneGroup.cuh"
+#include "Platform.cuh"
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <stdexcept>
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::algorithms
+{
+
+namespace detail
+{
+
+/// \a body(element) for every element in [0, \a count): the launch covers
+/// them all, one thread each (launchFor).
+template <typename Body>
+GPUg() void GTRK_KERNEL_BOUNDS forEachKernel(Body body, std::uint32_t count)
+{
+  const std::uint32_t element = (blockIdx.x * blockDim.x) + threadIdx.x;
+  if (element < count) {
+    body(element);
+  }
+}
+
+/// \a body.together(item, group) for every item in [0, \a count), each by a
+/// group of `L` consecutive threads (`WarpGroup`).
+/// No grid-stride loop: the launch covers every item, and a group past the
+/// last does nothing as a whole.
+template <std::uint32_t L, typename Body>
+GPUg() void GTRK_KERNEL_BOUNDS forEachGroupKernel(Body body, std::uint32_t count)
+{
+  const std::uint64_t item = ((std::uint64_t{blockIdx.x} * blockDim.x) + threadIdx.x) / L;
+  if (item < count) {
+    body.together(static_cast<std::uint32_t>(item), WarpGroup<L>{});
+  }
+}
+
+template <typename Predicate>
+GPUg() void GTRK_KERNEL_BOUNDS flagIndicesKernel(Predicate predicate, std::uint32_t count, std::uint32_t* indices, std::uint8_t* flags)
+{
+  const std::uint32_t index = (blockIdx.x * blockDim.x) + threadIdx.x;
+  if (index < count) {
+    indices[index] = index;
+    flags[index] = predicate(index) ? 1U : 0U;
+  }
+}
+
+/// CUB's and hipCUB's item counts are ints.
+inline void requireItems(std::size_t items)
+{
+  if (items > static_cast<std::size_t>(std::numeric_limits<int>::max())) {
+    throw std::length_error("a device algorithm's item count exceeds INT_MAX");
+  }
+}
+
+} // namespace detail
+
+/// \a body(element) -- a device functor -- for every element in [0, \a count),
+/// one thread each; queued on \a stream.
+template <typename Body>
+void forEach(DeviceRuntime& runtime, DeviceStream& stream, std::uint32_t count, const Body& body)
+{
+  if (count == 0U) {
+    return;
+  }
+  const auto shape = launchFor(count);
+  detail::forEachKernel<<<shape.blocks, shape.threads, 0U, nativeStream(runtime, stream)>>>(body, count);
+  checkLaunch();
+}
+
+/// \a body.together(item, group) -- a device functor -- for every item in
+/// [0, \a count), `L` lanes each walking it in step (`WarpGroup`); queued on
+/// \a stream.
+template <std::uint32_t L, typename Body>
+void forEachGroup(DeviceRuntime& runtime, DeviceStream& stream, std::uint32_t count, const Body& body)
+{
+  if (count == 0U) {
+    return;
+  }
+  if (std::uint64_t{count} * L > std::numeric_limits<std::uint32_t>::max()) {
+    throw std::length_error("forEachGroup: more threads than a launch counts");
+  }
+  const auto shape = launchFor(count * L);
+  detail::forEachGroupKernel<L><<<shape.blocks, shape.threads, 0U, nativeStream(runtime, stream)>>>(body, count);
+  checkLaunch();
+}
+
+/// to[i] = from[indices[i]]: one array gathered through an index array.
+template <typename T>
+struct Gather {
+  const T* from = nullptr;
+  const std::uint32_t* indices = nullptr;
+  T* to = nullptr;
+  GPUdi() void operator()(std::uint32_t i) const { to[i] = from[indices[i]]; }
+};
+
+/// The bits a radix sort needs for keys up to and including \a largest.
+[[nodiscard]] inline int keyBits(std::uint32_t largest) { return std::max(1, static_cast<int>(std::bit_width(largest))); }
+
+namespace detail
+{
+/// A library call with its temporary storage: \a call(temporary, bytes) once
+/// with no storage, which sets the bytes it needs, then with that much of
+/// the arena's scratch. kOutOfMemory if the scratch has not got it.
+template <typename Call>
+[[nodiscard]] StageStatus withTemporary(DeviceArena& arena, const Call& call)
+{
+  std::size_t temporaryBytes = 0U;
+  GPUChkErrS(call(nullptr, temporaryBytes));
+  DeviceSpan<std::byte> temporary;
+  if (!temporary.allocate(arena, temporaryBytes, ArenaEnd::kScratch)) {
+    return StageStatus::kOutOfMemory;
+  }
+  GPUChkErrS(call(temporary.data(), temporaryBytes));
+  return StageStatus::kComplete;
+}
+} // namespace detail
+
+/// The indices in [0, \a count) for which \a predicate -- a device functor
+/// `bool(std::uint32_t)` -- holds, in increasing order, into \a output
+/// (\a count entries on \a outputEnd); \a selected is how many, read back.
+template <typename Predicate>
+[[nodiscard]] StageStatus selectIndices(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, std::uint32_t count, const Predicate& predicate, DeviceSpan<std::uint32_t>& output, std::uint32_t& selected, ArenaEnd outputEnd = ArenaEnd::kBase)
+{
+  selected = 0U;
+  detail::requireItems(count);
+  if (!output.allocate(arena, count, outputEnd)) {
+    return StageStatus::kOutOfMemory;
+  }
+  if (count == 0U) {
+    return StageStatus::kComplete;
+  }
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  DeviceSpan<std::uint32_t> indices;
+  DeviceSpan<std::uint8_t> flags;
+  DeviceSpan<std::uint32_t> selectedCount;
+  if (!indices.allocate(arena, count, ArenaEnd::kScratch) || !flags.allocate(arena, count, ArenaEnd::kScratch) || !selectedCount.allocate(arena, 1U, ArenaEnd::kScratch)) {
+    return StageStatus::kOutOfMemory;
+  }
+  const auto native = nativeStream(runtime, stream);
+  const auto shape = launchFor(count);
+  detail::flagIndicesKernel<<<shape.blocks, shape.threads, 0U, native>>>(predicate, count, indices.data(), flags.data());
+  checkLaunch();
+  const auto flagged = detail::withTemporary(arena, [&](void* temporary, std::size_t& bytes) { return cubapi::DeviceSelect::Flagged(temporary, bytes, indices.data(), flags.data(), output.data(), selectedCount.data(), static_cast<int>(count), native); });
+  if (flagged != StageStatus::kComplete) {
+    return flagged;
+  }
+  download(selectedCount, &selected, 1U, stream);
+  stream.synchronize();
+  return StageStatus::kComplete;
+}
+
+/// `output[i]` = the sum of `input[0..i)`, over \a items entries of any
+/// integer type; queued on \a stream, nothing read back.
+template <typename T>
+[[nodiscard]] StageStatus exclusiveScan(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, const T* input, T* output, std::size_t items)
+{
+  detail::requireItems(items);
+  if (items == 0U) {
+    return StageStatus::kComplete;
+  }
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  const auto native = nativeStream(runtime, stream);
+  return detail::withTemporary(arena, [&](void* temporary, std::size_t& bytes) { return cubapi::DeviceScan::ExclusiveSum(temporary, bytes, input, output, static_cast<int>(items), native); });
+}
+
+/// `output[i]` = \a op over `input[0..i]`, over \a items entries; queued on
+/// \a stream, nothing read back.
+template <typename T, typename Op>
+[[nodiscard]] StageStatus inclusiveScan(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, const T* input, T* output, std::size_t items, const Op& op)
+{
+  detail::requireItems(items);
+  if (items == 0U) {
+    return StageStatus::kComplete;
+  }
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  const auto native = nativeStream(runtime, stream);
+  return detail::withTemporary(arena, [&](void* temporary, std::size_t& bytes) { return cubapi::DeviceScan::InclusiveScan(temporary, bytes, input, output, op, static_cast<int>(items), native); });
+}
+
+/// Sort \a count pairs by \a keys' low \a endBit bits, stably: \a keys into
+/// \a sortedKeys, \a values into \a sortedValues. Queued on \a stream.
+template <typename Key, typename Value>
+[[nodiscard]] StageStatus sortPairs(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, const Key* keys, Key* sortedKeys, const Value* values, Value* sortedValues, std::uint32_t count, int endBit)
+{
+  detail::requireItems(count);
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  const auto native = nativeStream(runtime, stream);
+  return detail::withTemporary(arena, [&](void* temporary, std::size_t& bytes) { return cubapi::DeviceRadixSort::SortPairs(temporary, bytes, keys, sortedKeys, values, sortedValues, static_cast<int>(count), 0, endBit, native); });
+}
+
+/// Sort \a count keys by their low \a endBit bits, stably, \a keys into
+/// \a sortedKeys. Queued on \a stream.
+template <typename Key>
+[[nodiscard]] StageStatus sortKeys(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, const Key* keys, Key* sortedKeys, std::uint32_t count, int endBit)
+{
+  detail::requireItems(count);
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  const auto native = nativeStream(runtime, stream);
+  return detail::withTemporary(arena, [&](void* temporary, std::size_t& bytes) { return cubapi::DeviceRadixSort::SortKeys(temporary, bytes, keys, sortedKeys, static_cast<int>(count), 0, endBit, native); });
+}
+
+/// Sort the items of every segment [\a begin[s], \a end[s]) by key, stably,
+/// keys and values together, through the double buffers: afterwards each
+/// buffer's `Current()` holds the sorted items. The library chooses how by
+/// the segments' lengths. Queued on \a stream.
+template <typename Key, typename Value, typename Offsets>
+[[nodiscard]] StageStatus segmentedStableSortPairs(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, cubapi::DoubleBuffer<Key>& keys, cubapi::DoubleBuffer<Value>& values, std::uint32_t items, std::uint32_t segments, Offsets begin, Offsets end)
+{
+  detail::requireItems(items);
+  detail::requireItems(segments);
+  if (items == 0U) {
+    return StageStatus::kComplete;
+  }
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  const auto native = nativeStream(runtime, stream);
+  return detail::withTemporary(arena, [&](void* temporary, std::size_t& bytes) { return cubapi::DeviceSegmentedSort::StableSortPairs(temporary, bytes, keys, values, static_cast<int>(items), static_cast<int>(segments), begin, end, native); });
+}
+
+/// What a sweep to a fixed point ended with.
+template <std::size_t Flags>
+struct SweepResult {
+  StageStatus status = StageStatus::kComplete; ///< kOutOfMemory if the flags could not be had
+  std::array<std::uint32_t, Flags> flags{};    ///< [0] is the change flag, 0 at the end; the others are sticky
+  std::uint32_t changingSweeps = 0U;           ///< passes that raised the change flag; one readback per pass, the last unchanged
+};
+
+/// Repeat \a sweep until a pass leaves the change flag down. \a sweep is a
+/// host callable `void(std::uint32_t* flags)` that queues one pass on
+/// \a stream, the pass raising `flags[0]` when it changed anything and the
+/// others as it needs. `flags[0]` is cleared before every pass, the others
+/// only before the first, so they tell whether any pass raised them. All of
+/// them come back in one copy per pass. More than \a maxChangingSweeps
+/// changing passes is a broken invariant of the caller's -- its fixed point
+/// is known to be that close -- and throws std::logic_error.
+template <std::size_t Flags, typename Sweep>
+[[nodiscard]] SweepResult<Flags> sweepToFixedPoint(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, std::uint32_t maxChangingSweeps, const Sweep& sweep)
+{
+  static_assert(Flags >= 1U, "a sweep needs its change flag");
+  SweepResult<Flags> result;
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  DeviceSpan<std::uint32_t> flags;
+  if (!flags.allocate(arena, Flags, ArenaEnd::kScratch)) {
+    result.status = StageStatus::kOutOfMemory;
+    return result;
+  }
+  runtime.fill(flags.data(), 0U, Flags * sizeof(std::uint32_t), stream);
+  while (true) {
+    runtime.fill(flags.data(), 0U, sizeof(std::uint32_t), stream);
+    sweep(flags.data());
+    download(flags, result.flags.data(), Flags, stream);
+    stream.synchronize();
+    if (result.flags[0] == 0U) {
+      return result;
+    }
+    if (++result.changingSweeps > maxChangingSweeps) {
+      throw std::logic_error("a sweep did not reach its fixed point within its bound: a broken invariant");
+    }
+  }
+}
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::algorithms
+
+#endif // GTRK_TRACKING_GPU_DEVICEALGORITHMS_CUH_
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/DeviceRuntime.cu b/Detectors/GenericTracking/tracking/GPU/cuda/DeviceRuntime.cu
new file mode 100644
index 0000000000000..a5419bc7a5081
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/DeviceRuntime.cu
@@ -0,0 +1,212 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceRuntime.cu
+/// \brief CUDA runtime implementation, hipified verbatim for HIP.
+
+#include <cuda_runtime.h>
+
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/DeviceTracker.h"
+
+#include "Platform.cuh"
+
+#include "GPUCommonHelpers.h"
+
+#include <algorithm>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+
+#ifndef GTRK_BACKEND_NAMESPACE
+#error "GTRK_BACKEND_NAMESPACE must name this backend's private namespace"
+#endif
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+{
+
+/// In DeviceTracker<Layout>.cu, one translation unit per layout.
+std::unique_ptr<DeviceTracker<detectors::ITS, o2::base::MatLayerCylSet>> makeITSTracker(DeviceRuntime& runtime, DeviceBlock block);
+std::unique_ptr<DeviceTracker<detectors::MFT, o2::base::MatLayerCylSet>> makeMFTTracker(DeviceRuntime& runtime, DeviceBlock block);
+std::unique_ptr<DeviceTracker<detectors::TRKFT3, o2::base::MatLayerCylSet>> makeTRKFT3Tracker(DeviceRuntime& runtime, DeviceBlock block);
+
+namespace
+{
+
+#ifdef GTRK_BACKEND_HIP
+constexpr std::string_view kBackend = "HIP";
+#else
+constexpr std::string_view kBackend = "CUDA";
+#endif
+
+/// The copies of one copyEachOnDevice launch, each in units of 2^unitShift
+/// bytes, the widest of 16, 8, 4 or 1 dividing both addresses, and the
+/// `tail` bytes after the last whole unit.
+struct CopyBatch {
+  static constexpr std::size_t kCopies = 32U;
+  struct Copy {
+    std::byte* to;
+    const std::byte* from;
+    std::size_t units;
+    unsigned unitShift;
+    unsigned tail;
+  };
+  Copy copies[kCopies];
+};
+
+template <std::size_t Bytes>
+struct alignas(Bytes) CopyUnit {
+  std::byte bytes[Bytes];
+};
+
+template <std::size_t Bytes>
+GPUdi() void copyUnit(const CopyBatch::Copy& copy, std::size_t unit)
+{
+  reinterpret_cast<CopyUnit<Bytes>*>(copy.to)[unit] = reinterpret_cast<const CopyUnit<Bytes>*>(copy.from)[unit];
+}
+
+/// Copy blockIdx.y of \a batch, one unit a thread, the first `tail` threads
+/// also a byte of the tail.
+GPUg() void GTRK_KERNEL_BOUNDS copyEachKernel(CopyBatch batch)
+{
+  const CopyBatch::Copy& copy = batch.copies[blockIdx.y];
+  const std::size_t unit = (std::size_t{blockIdx.x} * blockDim.x) + threadIdx.x;
+  if (unit < copy.tail) {
+    const std::size_t at = (copy.units << copy.unitShift) + unit;
+    copy.to[at] = copy.from[at];
+  }
+  if (unit >= copy.units) {
+    return;
+  }
+  switch (copy.unitShift) {
+    case 4U:
+      copyUnit<16U>(copy, unit);
+      break;
+    case 3U:
+      copyUnit<8U>(copy, unit);
+      break;
+    case 2U:
+      copyUnit<4U>(copy, unit);
+      break;
+    default:
+      copyUnit<1U>(copy, unit);
+      break;
+  }
+}
+
+class Runtime final : public DeviceRuntime
+{
+ public:
+  explicit Runtime(int device)
+  {
+    cudaDeviceProp properties{};
+    GPUChkErrS(cudaGetDeviceProperties(&properties, device));
+    mProperties.name = properties.name;
+#ifdef GTRK_BACKEND_HIP
+    mProperties.architecture = properties.gcnArchName;
+#else
+    mProperties.architecture = "sm_" + std::to_string((properties.major * 10) + properties.minor);
+#endif
+    mProperties.warpSize = properties.warpSize;
+  }
+
+  ~Runtime() final = default;
+
+  [[nodiscard]] const char* backend() const noexcept final { return kBackend.data(); }
+  [[nodiscard]] const DeviceProperties& properties() const noexcept final { return mProperties; }
+
+  void copyToDevice(void* to, const void* from, std::size_t bytes, DeviceStream& stream) final { copy(to, from, bytes, cudaMemcpyHostToDevice, stream); }
+  void copyToHost(void* to, const void* from, std::size_t bytes, DeviceStream& stream) final { copy(to, from, bytes, cudaMemcpyDeviceToHost, stream); }
+  void copyOnDevice(void* to, const void* from, std::size_t bytes, DeviceStream& stream) final { copy(to, from, bytes, cudaMemcpyDeviceToDevice, stream); }
+
+  void copyEachOnDevice(std::span<const DeviceCopy> copies, DeviceStream& stream) final
+  {
+    // Zero-byte copies take no slot: a launch has at least one unit.
+    while (!copies.empty()) {
+      CopyBatch batch{};
+      std::size_t taken = 0U;
+      std::size_t largest = 0U;
+      for (; !copies.empty() && taken < CopyBatch::kCopies; copies = copies.subspan(1U)) {
+        const DeviceCopy& copy = copies.front();
+        if (copy.bytes == 0U) {
+          continue;
+        }
+        const auto bits = reinterpret_cast<std::uintptr_t>(copy.to) | reinterpret_cast<std::uintptr_t>(copy.from) | (std::uintptr_t{1} << 4U);
+        const int zeros = std::countr_zero(bits);
+        const unsigned shift = zeros >= 2 ? static_cast<unsigned>(zeros) : 0U; // no 2-byte unit
+        const std::size_t units = copy.bytes >> shift;
+        const auto tail = static_cast<unsigned>(copy.bytes - (units << shift));
+        batch.copies[taken] = {
+          .to = static_cast<std::byte*>(copy.to),
+          .from = static_cast<const std::byte*>(copy.from),
+          .units = units,
+          .unitShift = shift,
+          .tail = tail,
+        };
+        largest = std::max({largest, units, std::size_t{tail}});
+        ++taken;
+      }
+      if (taken == 0U) {
+        return;
+      }
+      const auto threads = static_cast<std::size_t>(kBlockSize);
+      if (largest > std::size_t{std::numeric_limits<std::int32_t>::max()} * threads) {
+        throw std::length_error("copyEachOnDevice: a copy of more units than a launch counts");
+      }
+      const dim3 grid{static_cast<unsigned>((largest + threads - 1U) / threads), static_cast<unsigned>(taken)};
+      copyEachKernel<<<grid, threads, 0U, nativeStreamOf(stream)>>>(batch);
+      checkLaunch();
+    }
+  }
+
+  void fill(void* to, std::uint8_t value, std::size_t bytes, DeviceStream& stream) final { GPUChkErrS(cudaMemsetAsync(to, static_cast<int>(value), bytes, nativeStreamOf(stream))); }
+
+  void registerHost(void* host, std::size_t bytes) final { GPUChkErrS(cudaHostRegister(host, bytes, cudaHostRegisterDefault)); }
+  void unregisterHost(void* host) noexcept final { GPUChkErrSI(cudaHostUnregister(host)); }
+
+ protected:
+  [[nodiscard]] void* createStreamHandle() final
+  {
+    cudaStream_t stream = nullptr;
+    GPUChkErrS(cudaStreamCreateWithFlags(&stream, cudaStreamNonBlocking));
+    return stream;
+  }
+
+ private:
+  [[nodiscard]] static cudaStream_t nativeStreamOf(DeviceStream& stream) { return static_cast<cudaStream_t>(nativeStream(stream)); }
+
+  static void copy(void* to, const void* from, std::size_t bytes, cudaMemcpyKind kind, DeviceStream& stream) { GPUChkErrS(cudaMemcpyAsync(to, from, bytes, kind, nativeStreamOf(stream))); }
+
+  void destroyStreamHandle(void* handle) noexcept final { GPUChkErrSI(cudaStreamDestroy(static_cast<cudaStream_t>(handle))); }
+
+  void synchronizeStreamHandle(void* handle) final { GPUChkErrS(cudaStreamSynchronize(static_cast<cudaStream_t>(handle))); }
+
+  [[nodiscard]] std::unique_ptr<DeviceTracker<detectors::ITS, o2::base::MatLayerCylSet>> makeITSTracker(DeviceBlock block) final { return GTRK_BACKEND_NAMESPACE::makeITSTracker(*this, block); }
+  [[nodiscard]] std::unique_ptr<DeviceTracker<detectors::MFT, o2::base::MatLayerCylSet>> makeMFTTracker(DeviceBlock block) final { return GTRK_BACKEND_NAMESPACE::makeMFTTracker(*this, block); }
+  [[nodiscard]] std::unique_ptr<DeviceTracker<detectors::TRKFT3, o2::base::MatLayerCylSet>> makeTRKFT3Tracker(DeviceBlock block) final { return GTRK_BACKEND_NAMESPACE::makeTRKFT3Tracker(*this, block); }
+
+  DeviceProperties mProperties;
+};
+
+std::unique_ptr<DeviceRuntime> makeRuntime(int device) { return std::make_unique<Runtime>(device); }
+
+/// When the library is loaded: O2's GPU backend of the same name links it.
+[[maybe_unused]] const bool registered = (registerRuntimeFactory(kBackend, &makeRuntime), true);
+
+} // namespace
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/DeviceTracker.cuh b/Detectors/GenericTracking/tracking/GPU/cuda/DeviceTracker.cuh
new file mode 100644
index 0000000000000..0af400d69b538
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/DeviceTracker.cuh
@@ -0,0 +1,1402 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceTracker.cuh
+/// \brief DeviceTracker<Det, Material> on one backend: a timeframe's slices,
+///        iterations and tracks.
+///
+/// What lives where in the arena:
+///
+///   run        the iterations' parameters, the geometry, the material, until
+///              configureRun again or detach; the arena itself, over the
+///              attached block
+///   timeframe  base end: the measurement columns, the grid offsets, the used
+///              mask, the TimeFrame over them and the plan's device part,
+///              until the next beginTimeframe
+///   tracks     scratch end, at its bottom: every iteration's tracks, one
+///              chunk per iteration, until the next beginTimeframe
+///   chunks     scratch end: the open iteration's records, one chunk per
+///              slice, until endIteration has gathered them
+///   slice      base end: the slice's outputs, until the next runSlice or
+///              endIteration
+///   iteration  base end, inside endIteration: the gathered records, the
+///              selection's arrays, the working mask, the iteration's tracks
+///              and proposals
+///
+/// Staging, scan and sort storage are on the scratch end, released when the
+/// pass that took them returns. Included by the .cu that instantiates it for
+/// a detector, in the backend's namespace, like GpuStage.cuh.
+
+#ifndef GTRK_TRACKING_GPU_DEVICETRACKER_CUH_
+#define GTRK_TRACKING_GPU_DEVICETRACKER_CUH_
+
+#include "DeviceAlgorithms.cuh"
+#include "GpuStage.cuh"
+#include "RoadGlue.cuh"
+#include "Platform.cuh"
+#include "PathGlue.cuh"
+#include "SelectionGlue.cuh"
+#include "SliceGlue.cuh"
+#include "VertexGlue.cuh"
+
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/DeviceStageOutput.h"
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+#include "GenericTracking/Tracking/GPU/DeviceTracker.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/NeighbourStage.h"
+#include "GenericTracking/Tracking/Follow.h"
+#include "GenericTracking/Tracking/RoadCount.h"
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Tracking/SensorCells.h"
+#include "GenericTracking/Tracking/SlicePlan.h"
+#include "GenericTracking/Tracking/TrackRefit.h"
+#include "GenericTracking/Tracking/TrackletStage.h"
+#include "FlatStage.cuh"
+#include "GenericTracking/Tracking/TripletStage.h"
+
+#include "FlatObject.h"
+
+#include <algorithm>
+#include <array>
+#include <string>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <optional>
+#include <type_traits>
+#include <utility>
+#include <span>
+#include <stdexcept>
+#include <vector>
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+{
+
+namespace tracker_detail
+{
+
+/// The lanes that follow one track together, on every iteration: a step's
+/// window holds many
+/// candidates, each an update, and the kink step confirms every row it admits
+/// by the next step's search -- long windows a group shares. 16 on both
+/// backends, for warps of 32 and waves of 64 alike.
+inline constexpr std::uint32_t kFollowLanes = 16U;
+
+/// \a stage's follow of \a count tracks: `kFollowLanes` lanes in step a
+/// track (`FollowStage::together`). An iteration that decides the end again
+/// (`followEnd`) has no kink allowance (the settings refuse both) and is
+/// followed one thread a track: its stage has no group kernel.
+template <typename Stage>
+void follow(DeviceRuntime& runtime, DeviceStream& stream, std::uint32_t count, const Stage& stage)
+{
+  if constexpr (Stage::kDecidesEnd) {
+    algorithms::forEach(runtime, stream, count, stage);
+  } else {
+    algorithms::forEachGroup<kFollowLanes>(runtime, stream, count, stage);
+  }
+}
+
+/// The device's launches of the follow's passes (`follow::runSequence`) on
+/// \a stream: a pass one thread a track, the proposals by `follow`, the bids
+/// zeroed by a fill.
+struct FollowLaunch {
+  DeviceRuntime& runtime;
+  DeviceStream& stream;
+
+  template <typename Body>
+  void pass(profile::Phase /*phase*/, std::uint32_t count, const Body& body) const
+  {
+    algorithms::forEach(runtime, stream, count, body);
+  }
+
+  template <typename Stage>
+  void propose(profile::Phase /*phase*/, std::uint32_t count, const Stage& stage) const
+  {
+    tracker_detail::follow(runtime, stream, count, stage);
+  }
+
+  void clearBids(std::uint32_t* bids, std::size_t rows) const { runtime.fill(bids, 0U, rows * sizeof(std::uint32_t), stream); }
+};
+
+/// Whether a source has a query (`TrackletStage::hasQuery`), for the
+/// tracklet launch's list.
+template <typename Stage>
+struct HasQuery {
+  Stage stage;
+  GPUdi() bool operator()(std::uint32_t source) const { return stage.hasQuery(source); }
+};
+
+/// The tracks holding at least \a minimum clusters: the length after the
+/// follow.
+template <DetectorLayout Det>
+struct KeptAfterFollow {
+  const IterationParameters<Det>* parameters = nullptr;
+  const std::uint8_t* count = nullptr;
+  const BoundTrackState* state = nullptr;
+  GPUdi() bool operator()(std::uint32_t track) const { return keptAfterFollow(*parameters, count[track], state[track]); }
+};
+
+/// The kept tracks' rows in \a mask as \a after has them: the mask before the
+/// selection plus what the kept tracks hold, as the host's `dropShortTracks`
+/// rebuilds it. Two kept tracks sharing a row store the same byte.
+template <std::size_t K>
+struct RestoreRows {
+  const ClusterList<K>* clusters = nullptr;
+  const std::uint8_t* count = nullptr;
+  const std::uint8_t* after = nullptr;
+  std::uint8_t* mask = nullptr;
+  GPUdi() void operator()(std::uint32_t track) const
+  {
+    for (std::uint32_t position = 0; position < count[track]; ++position) {
+      const auto row = clusters[track].index[position];
+      mask[row] = after[row];
+    }
+  }
+};
+
+/// The tracklet stage as a flat run:
+/// the walk per source is `TrackletStage::forEachCandidate`, the contexts
+/// its source's (`SourceContext`, the vertex cache, `BetweenSource`) and each
+/// query's (`QueryContext`, the vertex intervals), the test `testCandidate`,
+/// the record `record`. A pair's key is the source's slot in its chunk (24
+/// bits) and its query's position among the source's out-links (8).
+template <typename Stage>
+struct FlatTracklets {
+  using SourceContext = typename Stage::SourceContext;
+  using QueryContext = typename Stage::QueryContext;
+  using CompatibleVertex = typename Stage::CompatibleVertex;
+  using Between = typename Stage::Between;
+  static constexpr std::uint32_t kVertexCapacity = Stage::kVertexCapacity;
+  static constexpr std::uint32_t kQueryBits = 8U;
+  /// The lanes that walk one source together in the fill: one thread a
+  /// source, or a group of lanes (`WarpGroup`).
+  static constexpr std::uint32_t kFillLanes = gpu::kFillLanes;
+  struct Source {
+    SourceContext context;
+    CompatibleVertex vertices[kVertexCapacity];
+    Between between;
+  };
+  struct Query {
+    QueryContext context;
+    SecondRange intervals[kVertexCapacity];
+    bool hasIntervals = false;
+  };
+  /// A fill's bookkeeping over one source's walk (`note`).
+  struct FillState {
+    bool stored = false;
+    std::uint32_t query = 0U;
+    std::size_t lastLink = 0U;
+  };
+  Stage stage;
+  std::uint32_t queriesPerSource = 1U; ///< the most out-links of a layer
+  Source* sources = nullptr;           ///< per chunk element
+  Query* queries = nullptr;            ///< per chunk element, `queriesPerSource` each
+  std::uint32_t sourceBegin = 0U;
+
+  [[nodiscard]] GPUdi() std::uint32_t count(std::uint32_t element) const { return stage.candidateCount(element); }
+  template <typename Sink>
+  GPUdi() void fill(std::uint32_t element, std::uint32_t position, Sink& sink) const
+  {
+    const std::uint32_t slot = position - sourceBegin;
+    FillState state;
+    const auto one = [&](const SourceContext& source, const CompatibleVertex* cachedVertices, const Between& between, const QueryContext& context, const SecondRange* intervals, const MeasurementView&, std::uint32_t targetRow) { sink.put(targetRow, note(state, slot, true, source, cachedVertices, between, context, intervals)); };
+    stage.forEachCandidate(element, one);
+  }
+  /// `fill` by the lanes of \a group in step (`forEachCandidate`): a step's
+  /// candidates in lane order at the sink's next positions, so the list is
+  /// the serial walk's. The bookkeeping on the step's ballot, alike on every
+  /// lane; lane 0 stores.
+  template <typename Sink, typename Group>
+  GPUdi() void fill(std::uint32_t element, std::uint32_t position, Sink& sink, const Group& group) const
+  {
+    const std::uint32_t slot = position - sourceBegin;
+    const std::uint32_t lane = group.lane();
+    FillState state;
+    const auto step = [&](const SourceContext& source, const CompatibleVertex* cachedVertices, const Between& between, const QueryContext& context, const SecondRange* intervals, const MeasurementView&, std::uint32_t targetRow, bool has) {
+      const std::uint64_t mask = group.ballot(has);
+      if (mask == 0U) {
+        return;
+      }
+      sink.putStep(mask, lane, has, targetRow, note(state, slot, lane == 0U, source, cachedVertices, between, context, intervals));
+    };
+    stage.forEachCandidate(element, step, group);
+  }
+  /// A candidate's key, its source and query noted in \a state: the source's
+  /// context stored at its first candidate, a query's at its first; a
+  /// query's number counts the queries with candidates before it. \a store
+  /// whether this thread writes the contexts.
+  [[nodiscard]] GPUdi() std::uint32_t note(FillState& state, std::uint32_t slot, bool store, const SourceContext& source, const CompatibleVertex* cachedVertices, const Between& between, const QueryContext& context, const SecondRange* intervals) const
+  {
+    if (!state.stored) {
+      if (store) {
+        sources[slot].context = source;
+        for (std::uint32_t i = 0; i < source.cachedCount; ++i) {
+          sources[slot].vertices[i] = cachedVertices[i];
+        }
+        sources[slot].between = between;
+        keep(slot, 0U, context, intervals);
+      }
+      state.stored = true;
+      state.lastLink = context.linkIndex;
+      state.query = 0U;
+    } else if (context.linkIndex != state.lastLink) {
+      state.lastLink = context.linkIndex;
+      ++state.query;
+      if (store) {
+        keep(slot, state.query, context, intervals);
+      }
+    }
+    return (slot << kQueryBits) | state.query;
+  }
+  GPUdi() void keep(std::uint32_t slot, std::uint32_t query, const QueryContext& context, const SecondRange* intervals) const
+  {
+    Query& out = queries[(std::size_t{slot} * queriesPerSource) + query];
+    out.context = context;
+    out.hasIntervals = intervals != nullptr;
+    if (intervals != nullptr) {
+      for (std::uint32_t i = 0; i < kVertexCapacity; ++i) {
+        out.intervals[i] = intervals[i];
+      }
+    }
+  }
+  [[nodiscard]] GPUdi() std::uint32_t sourceOf(const flat::CandidatePair& pair) const { return (pair.key >> kQueryBits) + sourceBegin; }
+  [[nodiscard]] GPUdi() bool test(std::uint32_t, const flat::CandidatePair& pair) const
+  {
+    const Source& source = sources[pair.key >> kQueryBits];
+    const Query& query = queries[(std::size_t{pair.key >> kQueryBits} * queriesPerSource) + (pair.key & ((1U << kQueryBits) - 1U))];
+    const MeasurementView columns = stage.columns();
+    const PairPoint target = pairPointAt(columns, pair.row);
+    return stage.testCandidate(source.context, source.vertices, source.between, query.context, query.hasIntervals ? query.intervals : nullptr, columns, pair.row, target);
+  }
+  [[nodiscard]] GPUdi() Tracklet emit(std::uint32_t, const flat::CandidatePair& pair, std::uint32_t) const
+  {
+    const Source& source = sources[pair.key >> kQueryBits];
+    const Query& query = queries[(std::size_t{pair.key >> kQueryBits} * queriesPerSource) + (pair.key & ((1U << kQueryBits) - 1U))];
+    const PairPoint target = pairPointAt(stage.columns(), pair.row);
+    return stage.record(source.context.at.row, pair.row, query.context.linkIndex, source.context.point, target);
+  }
+  [[nodiscard]] bool beginChunk(DeviceArena& arena, std::uint32_t begin, std::uint32_t count, std::uint32_t)
+  {
+    if (count > (std::uint32_t{1U} << (32U - kQueryBits))) {
+      return false; // more sources in the chunk than the key numbers: the run fails for memory, which halves the chunk
+    }
+    sourceBegin = begin;
+    DeviceSpan<Source> sourceStorage;
+    DeviceSpan<Query> queryStorage;
+    if (!sourceStorage.allocate(arena, std::max<std::size_t>(count, 1U), ArenaEnd::kScratch) || !queryStorage.allocate(arena, std::max<std::size_t>(std::size_t{count} * queriesPerSource, 1U), ArenaEnd::kScratch)) {
+      return false;
+    }
+    sources = sourceStorage.data();
+    queries = queryStorage.data();
+    return true;
+  }
+  [[nodiscard]] std::size_t contextBytes(std::uint32_t count) const { return std::size_t{count} * (sizeof(Source) + (std::size_t{queriesPerSource} * sizeof(Query))); }
+  [[nodiscard]] std::size_t pairBytes() const { return 0U; }
+};
+
+/// The triplet stage as a flat run:
+/// the walk per first tracklet is `TripletStage::prepareFirst` and
+/// `forEachWindowCandidate`, the context its `FirstContext`, the test
+/// `testCandidate` with its fit kept per pair for `record`; with \a Shape,
+/// the shape-testing stage.
+template <DetectorLayout Det, bool Shape = false>
+struct FlatTriplets {
+  using Stage = TripletStage<Det, Shape>;
+  using Context = typename Stage::FirstContext;
+  Stage stage;
+  Context* contexts = nullptr;      ///< per chunk element
+  TripletFitResult* fits = nullptr; ///< per chunk pair, where the test passed
+  std::uint8_t* kinked = nullptr;
+  std::uint32_t sourceBegin = 0U;
+
+  [[nodiscard]] GPUdi() std::uint32_t count(std::uint32_t element) const { return stage.candidateCount(element); }
+  template <typename Sink>
+  GPUdi() void fill(std::uint32_t element, std::uint32_t position, Sink& sink) const
+  {
+    Context context;
+    if (!stage.prepareFirst(element, context)) {
+      return; // no candidates: the context is never read
+    }
+    contexts[position - sourceBegin] = context;
+    const auto one = [&](std::uint32_t candidateIndex) { sink.put(candidateIndex, position); };
+    stage.forEachWindowCandidate(context, one);
+  }
+  [[nodiscard]] GPUdi() std::uint32_t sourceOf(const flat::CandidatePair& pair) const { return pair.key; }
+  [[nodiscard]] GPUdi() bool test(std::uint32_t k, const flat::CandidatePair& pair) const
+  {
+    TripletFitResult fit;
+    bool isKinked = false;
+    if (!stage.testCandidate(contexts[pair.key - sourceBegin], pair.row, fit, isKinked)) {
+      return false;
+    }
+    fits[k] = fit;
+    kinked[k] = isKinked ? std::uint8_t{1} : std::uint8_t{0};
+    return true;
+  }
+  [[nodiscard]] GPUdi() Triplet emit(std::uint32_t k, const flat::CandidatePair& pair, std::uint32_t) const { return stage.record(contexts[pair.key - sourceBegin], pair.row, fits[k], kinked[k] != 0U); }
+  [[nodiscard]] bool beginChunk(DeviceArena& arena, std::uint32_t begin, std::uint32_t sources, std::uint32_t pairs)
+  {
+    sourceBegin = begin;
+    DeviceSpan<Context> contextStorage;
+    DeviceSpan<TripletFitResult> fitStorage;
+    DeviceSpan<std::uint8_t> kinkedStorage;
+    if (!contextStorage.allocate(arena, std::max<std::size_t>(sources, 1U), ArenaEnd::kScratch) || !fitStorage.allocate(arena, std::max<std::size_t>(pairs, 1U), ArenaEnd::kScratch) || !kinkedStorage.allocate(arena, std::max<std::size_t>(pairs, 1U), ArenaEnd::kScratch)) {
+      return false;
+    }
+    contexts = contextStorage.data();
+    fits = fitStorage.data();
+    kinked = kinkedStorage.data();
+    return true;
+  }
+  [[nodiscard]] std::size_t contextBytes(std::uint32_t sources) const { return std::size_t{sources} * sizeof(Context); }
+  [[nodiscard]] std::size_t pairBytes() const { return sizeof(TripletFitResult) + 1U; }
+};
+
+} // namespace tracker_detail
+
+/// Where a material lives on the device: an O2 FlatObject -- the
+/// MatLayerCylSet -- with its buffer, anything else as a value. Decided by
+/// the base class, not by trivial copyability: O2 compiles a FlatObject's
+/// copy constructor and destructor only outside GPU translation units, so in
+/// this one a MatLayerCylSet looks trivially copyable, and copied as bytes it
+/// keeps its host buffer pointers.
+template <typename Material, bool Plain = !std::is_base_of_v<o2::gpu::FlatObject, Material>>
+struct DeviceMaterial {
+  static_assert(std::is_trivially_copyable_v<Material>, "a material that is not a FlatObject uploads as bytes");
+  DeviceObject<Material> storage;
+  [[nodiscard]] bool upload(DeviceArena& arena, const Material& material, DeviceStream& stream)
+  {
+    if (!storage.allocate(arena)) {
+      return false;
+    }
+    uploadObject(material, storage, stream);
+    return true;
+  }
+  void release() noexcept { storage = {}; }
+  [[nodiscard]] const Material* data() const { return storage.data(); }
+};
+
+template <typename Material>
+struct DeviceMaterial<Material, false> {
+  DeviceFlatObject<Material> storage;
+  [[nodiscard]] bool upload(DeviceArena& arena, const Material& material, DeviceStream& stream) { return storage.upload(arena, material, stream); }
+  /// The device copy let go, the host image kept for the next run's upload.
+  void release() noexcept { storage.release(); }
+  [[nodiscard]] const Material* data() const { return storage.data(); }
+};
+
+template <DetectorLayout Det, typename Material>
+class DeviceTrackerImpl final : public DeviceTracker<Det, Material>
+{
+ public:
+  using Report = typename DeviceTracker<Det, Material>::SliceReport;
+  using Frame = TimeFrame<Det>;
+  using Index = std::uint32_t;
+  static constexpr std::size_t kLayerCount = LayerRowMap<Det>::kLayerCount;
+  static constexpr std::size_t kInitialStaging = std::size_t{1} << 20U;
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  using Records = DeviceStageOutput<SelectionRecordOf<kMaxClusters>::template RecordT>;
+  using IterationReport = typename DeviceTracker<Det, Material>::IterationReport;
+  using Tracks = typename DeviceTracker<Det, Material>::Tracks;
+  using TrackRecord = TrackOf<kMaxClusters>;
+  using Proposal = FollowProposal<kMaxClusters>;
+  static_assert(std::is_trivially_copyable_v<TrackingGeometry<Det>>, "the geometry uploads as bytes");
+
+  /// The arena on \a block.
+  DeviceTrackerImpl(DeviceRuntime& runtime, DeviceBlock block)
+    : mRuntime(&runtime),
+      mArena(runtime, block),
+      mStream(runtime.createStream()),
+      mTrackletStage(runtime, mArena, mStream),
+      mNeighbourStage(runtime, mArena, mStream),
+      mRecordStage(runtime, mArena, mStream)
+  {
+    setStagingCapacity(kInitialStaging);
+  }
+
+  ~DeviceTrackerImpl() final
+  {
+    // Work still queued reads the arena: finish it before the arena goes.
+    mStream.synchronize();
+    closeFrom(Scope::kRun);
+  }
+
+  void attach(DeviceBlock block) final
+  {
+    detach();
+    mArena.rebind(block);
+  }
+
+  void detach() noexcept final
+  {
+    // Work still queued reads the block: finish it before the block goes.
+    mStream.synchronize();
+    closeFrom(Scope::kRun);
+    mArena.rebind({});
+  }
+  DeviceTrackerImpl(const DeviceTrackerImpl&) = delete;
+  DeviceTrackerImpl& operator=(const DeviceTrackerImpl&) = delete;
+  DeviceTrackerImpl(DeviceTrackerImpl&&) = delete;
+  DeviceTrackerImpl& operator=(DeviceTrackerImpl&&) = delete;
+
+  [[nodiscard]] StageStatus configureRun(std::span<const IterationParameters<Det>> iterations, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator) final
+  {
+    mStream.synchronize();
+    closeFrom(Scope::kRun);
+    if (!mParameters.allocate(mArena, iterations.size()) || !mGeometry.allocate(mArena) || !mMaterial.upload(mArena, material, mStream)) {
+      closeFrom(Scope::kRun);
+      return StageStatus::kOutOfMemory;
+    }
+    upload(iterations.data(), mParameters, iterations.size(), mStream);
+    uploadObject(geometry, mGeometry, mStream);
+    // The sensors by place, once, where an iteration follows.
+    mSensorCells = {};
+    if (std::ranges::any_of(iterations, [](const auto& parameters) { return parameters.follow || parameters.followEnd; })) {
+      // Built on the host once per geometry: configureRun runs every timeframe.
+      if (!mHostCells || std::memcmp(mHostCellsGeometry.data(), static_cast<const void*>(&geometry), sizeof(geometry)) != 0) {
+        mHostCells.emplace(geometry);
+        std::memcpy(mHostCellsGeometry.data(), static_cast<const void*>(&geometry), sizeof(geometry));
+      }
+      const SensorCells<Det>& cells = *mHostCells;
+      if (!mCellLayers.allocate(mArena, cells.layers().size()) || !mCellOffsets.allocate(mArena, cells.offsets().size()) || !mCellSensors.allocate(mArena, std::max<std::size_t>(cells.sensors().size(), 1U))) {
+        closeFrom(Scope::kRun);
+        return StageStatus::kOutOfMemory;
+      }
+      upload(cells.layers().data(), mCellLayers, cells.layers().size(), mStream);
+      upload(cells.offsets().data(), mCellOffsets, cells.offsets().size(), mStream);
+      upload(cells.sensors().data(), mCellSensors, cells.sensors().size(), mStream);
+      mSensorCells = {.layers = mCellLayers.data(), .offsets = mCellOffsets.data(), .sensors = mCellSensors.data()};
+    }
+    mStream.synchronize(); // the host objects may go once this returns
+    mHostParameters.assign(iterations.begin(), iterations.end());
+    mPropagator = propagator;
+    mIterationCount = iterations.size();
+    mConfigured = true;
+    return StageStatus::kComplete;
+  }
+
+  [[nodiscard]] StageStatus beginTimeframe(const Frame& frame, const TimeframePlan<Det>& plan) final
+  {
+    if (!mConfigured) {
+      throw std::logic_error("beginTimeframe before configureRun");
+    }
+    plan.check(frame, mHostParameters); // before anything changes
+    mStream.synchronize();
+    closeFrom(Scope::kTimeframe);
+    mTimeframeScope.emplace(mArena.scope());
+    const std::size_t rows = frame.size();
+    const auto offsets = frame.grid().offsets();
+    if (!mColumns.allocate(mArena, rows) || !mOffsets.allocate(mArena, offsets.size()) || !mUsed.allocate(mArena, rows) || !mFrame.allocate(mArena) || !uploadPlan(plan)) {
+      closeFrom(Scope::kTimeframe);
+      return StageStatus::kOutOfMemory;
+    }
+    upload<MeasurementT>(frame.measurements(), rows, mColumns, mStream);
+    upload(offsets.data(), mOffsets, offsets.size(), mStream);
+    mRuntime->fill(mUsed.data(), std::uint8_t{kFree}, rows, mStream);
+    // The frame is a view: built on the host over the device columns, and
+    // copied as the value it is.
+    const Frame device{std::as_const(mColumns).view(), frame.grid().geometry(), std::span<const Index>{mOffsets.data(), offsets.size()}, static_cast<Index>(rows)};
+    uploadObject(device, mFrame, mStream);
+    mStream.synchronize();
+    // The tracks' chunks, at the bottom of the scratch end for the timeframe.
+    mTracksScope.emplace(mArena.scope(ArenaEnd::kScratch));
+    mRows = rows;
+    mHostFrame = &frame;
+    mPlan = &plan;
+    return StageStatus::kComplete;
+  }
+
+  void setFlatChunkPairs(std::size_t pairs) final { mFlatOptions.maxChunkPairs = pairs; }
+
+  void setStagingCapacity(std::size_t records) final
+  {
+    mTrackletStage.prepareStaging(records);
+    mNeighbourStage.prepareStaging(records);
+    mRecordStage.prepareStaging(records);
+  }
+
+  void beginIteration(std::size_t iteration) final
+  {
+    requireTimeframe();
+    if (mIterationOpen) {
+      throw std::logic_error("beginIteration with an iteration open");
+    }
+    if (iteration >= mIterationCount) {
+      throw std::invalid_argument("beginIteration of an iteration the run does not have");
+    }
+    // Every call before returns with the stream drained.
+    // The iteration's own arena peak, in a window endIteration closes.
+    mOuterArenaPeak = mArena.peak();
+    mArena.resetPeak();
+    mChunksScope.emplace(mArena.scope(ArenaEnd::kScratch));
+    mIteration = iteration;
+    mIterationStatus = StageStatus::kComplete;
+    mIterationOpen = true;
+  }
+
+  [[nodiscard]] StageStatus runSlice(std::size_t slice, DeviceSliceDownload<Det>* download) final
+  {
+    if (!mIterationOpen) {
+      throw std::logic_error("runSlice outside an open iteration");
+    }
+    if (mIterationStatus != StageStatus::kComplete) {
+      throw std::logic_error("runSlice in an iteration a slice has failed");
+    }
+    if (slice >= mPlan->slices.size()) {
+      throw std::logic_error("runSlice of a slice the plan does not have");
+    }
+    openSlice();
+    // An iteration that takes the previous one's graph has its records from
+    // that one's second fit (one graph for both rounds): no slice of its own,
+    // as on the host.
+    if (mHostParameters[mIteration].sharedGraph) {
+      return StageStatus::kComplete;
+    }
+    const StageStatus status = runStages(mIteration, slice, download);
+    mStream.synchronize(); // the host objects the slice reads are read until here
+    if (status != StageStatus::kComplete) {
+      mIterationStatus = status;
+      closeFrom(Scope::kSlice);
+    }
+    return status;
+  }
+
+  [[nodiscard]] StageStatus endIteration(DeviceIterationDownload<Det>* download) final
+  {
+    if (!mIterationOpen) {
+      throw std::logic_error("endIteration without an open iteration");
+    }
+    closeFrom(Scope::kSlice); // runSlice returns with the stream drained
+    StageStatus status = mIterationStatus;
+    const bool shared = mHostParameters[mIteration].sharedGraph;
+    const bool sharesNext = mIteration + 1U < mIterationCount && mHostParameters[mIteration + 1U].sharedGraph;
+    mIterationReport = {.records = mChunks.rows()};
+    if (status == StageStatus::kComplete) {
+      // The records of every slice, in slice order, into one array on the
+      // base end: the selection's input. A
+      // shared iteration's are its predecessor's second fit, kept for it in a
+      // scope of their own below the iteration's (`mSharedScope`).
+      if (sharesNext) {
+        mSharedScope.emplace(mArena.scope());
+        mSharedGathered = {};
+        if (!mSharedGathered.allocate(mArena, mSharedChunks.rows())) {
+          status = StageStatus::kOutOfMemory;
+        } else {
+          mSharedChunks.gather(mSharedGathered, 0U, mStream);
+        }
+      }
+      mIterationScope.emplace(mArena.scope());
+      mGathered = {};
+      const std::size_t recordRows = shared ? mSharedGathered.size() : mChunks.rows();
+      mIterationReport.records = recordRows;
+      if (status == StageStatus::kComplete && !mGathered.allocate(mArena, recordRows)) {
+        status = StageStatus::kOutOfMemory;
+      }
+      if (status == StageStatus::kComplete) {
+        if (shared) {
+          copyColumns(mSharedGathered, 0U, mGathered, 0U, recordRows, mStream);
+        } else {
+          mChunks.gather(mGathered, 0U, mStream);
+        }
+        if (download != nullptr) {
+          gtrk::download(mGathered, download->records, recordRows, mStream);
+        }
+      }
+      // The gather is queued before anything that reuses the chunks' space.
+      closeFrom(Scope::kChunks);
+      if (status == StageStatus::kComplete) {
+        status = endStages(download);
+      }
+      mStream.synchronize(); // the downloads land, and nothing queued reads the iteration scope
+    }
+    closeFrom(Scope::kChunks);
+    closeFrom(Scope::kIteration);
+    // The shared records go with the iteration that took them, or with a
+    // failure of the one that made them.
+    if (shared || status != StageStatus::kComplete) {
+      mSharedGathered = {};
+      mSharedScope.reset();
+    }
+    mIterationReport.arenaPeakBytes = mArena.peak();
+    mArena.raisePeak(mOuterArenaPeak);
+    return status;
+  }
+
+  void downloadTracks(Tracks& tracks) final
+  {
+    requireNoIteration("downloadTracks");
+    tracks.resize(mTrackChunks.rows());
+    mTrackChunks.download(tracks, 0U, mStream);
+    mStream.synchronize();
+  }
+
+  [[nodiscard]] StageStatus findVertices(std::size_t pass, const VertexerSettings& settings, const VertexConstraint& beamSpot, VertexerResult& result) final
+  {
+    requireNoIteration("findVertices");
+    if (pass >= mIterationCount) {
+      throw std::invalid_argument("findVertices of an iteration the run does not have");
+    }
+    // Slice by slice, each its own frames' vertices; the lists in time order.
+    result = {};
+    const auto& slices = mPlan->slices;
+    StageStatus status = StageStatus::kComplete;
+    for (std::size_t slice = 0; slice < slices.size() && status == StageStatus::kComplete; ++slice) {
+      openSlice();
+      DeviceStageOutput<TrackletT> tracklets;
+      DeviceSpan<Index> permutation;
+      DeviceStageOutput<TripletT> triplets;
+      status = tripletStages(pass, pass, slice, tracklets, permutation, triplets);
+      VertexerResult found;
+      if (status == StageStatus::kComplete) {
+        status = vertex_glue::findVertices<Det>(*mRuntime, mArena, mStream, std::as_const(mColumns).view(), static_cast<Index>(mRows), constView(tracklets), constView(triplets), triplets.size(), mParameters.data() + pass, settings, beamSpot, ownedFrames(mHostFrame->grid().geometry(), slices[slice].slice.coreBlocks), found);
+      }
+      // A complete vertexer has synchronised after its last readback.
+      if (status != StageStatus::kComplete) {
+        mStream.synchronize();
+      }
+      closeFrom(Scope::kSlice);
+      appendVertices(result, found);
+    }
+    return status;
+  }
+
+  [[nodiscard]] StageStatus replacePlan(const TimeframePlan<Det>& plan) final
+  {
+    requireNoIteration("replacePlan");
+    plan.check(*mHostFrame, mHostParameters); // before anything changes
+    mStream.synchronize();
+    closeFrom(Scope::kSlice);
+    // The new device part goes on top of the timeframe's base end, the old
+    // one's few kB staying until the timeframe ends.
+    if (!uploadPlan(plan)) {
+      return StageStatus::kOutOfMemory;
+    }
+    mPlan = &plan;
+    return StageStatus::kComplete;
+  }
+
+  void endTimeframe() noexcept final
+  {
+    // Work still queued reads the timeframe's storage.
+    mStream.synchronize();
+    closeFrom(Scope::kTimeframe);
+  }
+
+  [[nodiscard]] const IterationReport& lastIteration() const final { return mIterationReport; }
+
+  [[nodiscard]] const Report& lastSlice() const final { return mReport; }
+  [[nodiscard]] std::size_t arenaBytes() const final { return mArena.capacity(); }
+  [[nodiscard]] std::size_t arenaUsedBytes(ArenaEnd end) const final { return mArena.used(end); }
+  [[nodiscard]] std::size_t arenaPeakBytes() const final { return mArena.peak(); }
+
+ private:
+  struct LayeredNeighbours {
+    NeighbourStage<Det> body;
+    const Index* layerBoundaries;
+    std::array<LayerID, kLayerCount> layerOrder = ::o2::gtrk::layerDepthGroups<Det>.order;
+  };
+
+  /// The plan's device part, in the timeframe scope: every slice's source map and core ranges, once for every
+  /// iteration -- the core ranges with an iteration's start-layer mask per
+  /// iteration, where one has a mask --, each iteration's vertex windows, the
+  /// beam line and then the vertices, the follow's bound.
+  /// False, with the scope to be closed by the caller, if the arena refuses.
+  [[nodiscard]] bool uploadPlan(const TimeframePlan<Det>& plan)
+  {
+    std::vector<LayerRowMap<Det>> sources;
+    std::vector<MeasurementRange> cores;
+    std::vector<MeasurementRange> maskedCores; // per iteration, with its start-layer mask (RoadCount.h, `roadCores`)
+    const std::vector<VertexWindowParameters<Det>>& windows = plan.vertexWindows;
+    for (const auto& slice : plan.slices) {
+      sources.push_back(slice.sources);
+      cores.insert(cores.end(), slice.slice.core.begin(), slice.slice.core.end());
+    }
+    const bool startMasks = std::ranges::any_of(mHostParameters, [](const IterationParameters<Det>& one) { return one.roadStartLayers != 0U; });
+    if (startMasks) {
+      for (std::size_t iteration = 0U; iteration < plan.parameters.size(); ++iteration) {
+        for (const auto& slice : plan.slices) {
+          // A graph shared with the next iteration has its start layers too (Tracker.h).
+          const auto masked = roadCores(std::span<const MeasurementRange, kLayerCount>{slice.slice.core}, mHostParameters[iteration].roadStartLayers);
+          maskedCores.insert(maskedCores.end(), masked.begin(), masked.end());
+        }
+      }
+    }
+    std::vector<VertexSeed> seeds{plan.beamLine};
+    seeds.insert(seeds.end(), plan.vertices.begin(), plan.vertices.end());
+    if (!mSliceSources.allocate(mArena, sources.size()) || !mSliceCores.allocate(mArena, cores.size()) || (startMasks && !mSliceRoadCores.allocate(mArena, maskedCores.size())) || !mVertexWindows.allocate(mArena, windows.size()) || !mSeeds.allocate(mArena, seeds.size()) || !mLayerMaxWidthPS.allocate(mArena, kLayerCount) || !mTargetBounds.allocate(mArena, kLayerCount)) {
+      return false;
+    }
+    upload(sources.data(), mSliceSources, sources.size(), mStream);
+    upload(cores.data(), mSliceCores, cores.size(), mStream);
+    if (startMasks) {
+      upload(maskedCores.data(), mSliceRoadCores, maskedCores.size(), mStream);
+    }
+    mRoadCoresMasked = startMasks;
+    upload(windows.data(), mVertexWindows, windows.size(), mStream);
+    upload(seeds.data(), mSeeds, seeds.size(), mStream);
+    upload(plan.layerMaxWidthPS.data(), mLayerMaxWidthPS, kLayerCount, mStream);
+    upload(plan.layerTargetBounds.data(), mTargetBounds, kLayerCount, mStream);
+    mStream.synchronize(); // the host vectors go when this returns
+    return true;
+  }
+
+  template <template <template <class> class> class S>
+  [[nodiscard]] static typename DeviceColumns<S>::ConstView constView(const DeviceStageOutput<S>& output)
+  {
+    return output.view();
+  }
+
+  /// A stage's run over a flat candidate list
+  /// into \a output, its report into \a run, its readbacks counted.
+  template <template <template <class> class> class S, typename Adapter>
+  StageStatus runFlat(const Index* listed, Index listedCount, const Adapter& adapter, DeviceStageOutput<S>& output, FlatRunReport& run)
+  {
+    const StageStatus status = flat::runFlat(*mRuntime, mArena, mStream, listed, listedCount, adapter, output, run, mFlatOptions);
+    mReport.readbacks += run.readbacks;
+    return status;
+  }
+
+  /// A stage's run, counted: its readback, and a second one after a missed
+  /// prediction.
+  template <template <template <class> class> class S, typename Generate>
+  StageStatus runStage(GpuStage<S>& gpuStage, DeviceStageOutput<S>& output, const Generate& generate)
+  {
+    return counted(gpuStage, gpuStage.run(output, generate));
+  }
+
+  /// The same over the \a listedCount elements \a listed names only, when set
+  /// (`GpuStage::run`).
+  template <template <template <class> class> class S, typename Generate>
+  StageStatus runStage(GpuStage<S>& gpuStage, DeviceStageOutput<S>& output, const Generate& generate, const Index* listed, Index listedCount)
+  {
+    return counted(gpuStage, gpuStage.run(output, generate, listed, listedCount));
+  }
+
+  /// \a status of \a gpuStage's last run, its readbacks counted.
+  template <template <template <class> class> class S>
+  StageStatus counted(const GpuStage<S>& gpuStage, StageStatus status)
+  {
+    const bool missed = gpuStage.stagingPredictionMissed();
+    mReport.readbacks += missed ? 2U : 1U;
+    mReport.stagingPredictionMissed = mReport.stagingPredictionMissed || missed;
+    return status;
+  }
+
+  /// A slice's tracklets and triplets, the first stages every slice runs
+  /// and all the vertexing pass runs, into \a tracklets and \a triplets in
+  /// the slice scope, with the triplet stage's first-tracklet order in
+  /// \a permutation. The slice is \a iteration's; the parameters are
+  /// \a graph's -- the successor's where it takes this iteration's graph,
+  /// this iteration's otherwise.
+  StageStatus tripletStages(std::size_t iteration, std::size_t graph, std::size_t sliceIndex, DeviceStageOutput<TrackletT>& tracklets, DeviceSpan<Index>& permutation, DeviceStageOutput<TripletT>& triplets)
+  {
+    const IterationParameters<Det>* parameters = mParameters.data() + graph;
+    const IterationParameters<Det>& hostParameters = mHostParameters[graph];
+    const auto& slicePlan = mPlan->slices[sliceIndex];
+    // The slices' sources and cores, uploaded once for every iteration.
+    const LayerRowMap<Det>* sources = mSliceSources.data() + sliceIndex;
+    const MeasurementRange* core = mSliceCores.data() + (sliceIndex * kLayerCount);
+    const Index sourceCount = slicePlan.sources.size();
+
+    // The tracklet stage as the host tracker builds it from the plan, bound to
+    // the device copies.
+    const auto inputs = slicePlan.inputs(hostParameters, mPlan->layerMaxWidthPS);
+    const bool beamLine = hostParameters.vertexSource == VertexSource::kBeamLine;
+    if (!tracklets.prepare(mArena, sourceCount)) {
+      return StageStatus::kOutOfMemory;
+    }
+    // The beam-line stage for a beam-line iteration, its displaced one for a
+    // displaced iteration;
+    // each testing the shapes where the iteration does.
+    StageStatus status = withTrackletVertices(hostParameters.vertexSource, hostParameters.impactMax > 0.F, [&](auto beamLineOnly, auto displaced) {
+      return withShapeTest(hostParameters.shapeTest, [&](auto shape) {
+        const TrackletStageFor<Det, decltype(beamLineOnly)::value, decltype(displaced)::value, decltype(shape)::value> stage{hostParameters, slicePlan.sources, *mHostFrame, inputs.targetBlocks, mPlan->beamLine, mPlan->vertices, inputs.maxCandidateWidthPS, mPlan->vertexWindows[iteration], nullptr, inputs.gate};
+        const auto bound = stage.bind({
+          .parameters = parameters,
+          .sources = sources,
+          .frame = mFrame.data(),
+          .used = mUsed.data(),
+          .vertexWindows = mVertexWindows.data() + iteration,
+          .vertices = beamLine ? mSeeds.data() : mSeeds.data() + 1,
+          .gateCore = core,
+        });
+        // A thread for the sources with a query only: a dead source's thread holds its warp's lanes idle while the
+        // others walk; it emits nothing, so its count is the 0 the stage sets.
+        auto scratch = mArena.scope(ArenaEnd::kScratch);
+        DeviceSpan<Index> listed;
+        Index listedCount = 0U;
+        const StageStatus selected = algorithms::selectIndices(*mRuntime, mArena, mStream, sourceCount, tracker_detail::HasQuery<decltype(bound)>{bound}, listed, listedCount, ArenaEnd::kScratch);
+        ++mReport.readbacks; // the list's length
+        if (selected != StageStatus::kComplete) {
+          return selected;
+        }
+        // The flat run: the sources' candidates listed, tested one a thread.
+        std::uint32_t queriesPerSource = 1U;
+        for (std::size_t layer = 0; layer < kLayerCount; ++layer) {
+          queriesPerSource = std::max(queriesPerSource, hostParameters.outLinkOffsets[layer + 1U] - hostParameters.outLinkOffsets[layer]);
+        }
+        if (queriesPerSource > (1U << tracker_detail::FlatTracklets<decltype(bound)>::kQueryBits)) {
+          throw std::logic_error("a layer has more out-links than a flat pair's key numbers");
+        }
+        mReport.trackletSources = listedCount;
+        return runFlat(listedCount > 0U ? listed.data() : nullptr, listedCount, tracker_detail::FlatTracklets<decltype(bound)>{.stage = bound, .queriesPerSource = queriesPerSource}, tracklets, mReport.trackletRun);
+      });
+    });
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    // Each source's tracklets in (link, lambda, target) order, which the
+    // triplet stage searches.
+    status = glue::sortTracklets(*mRuntime, mArena, mStream, tracklets);
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    mReport.tracklets = tracklets.size();
+
+    // The longest tracklet paths through each measurement, which the
+    // permutation and the triplet stage read.
+    glue::DevicePathBounds trackletPaths;
+    status = glue::trackletPaths<Det>(*mRuntime, mArena, mStream, parameters, slicePlan.sources, constView(tracklets), tracklets.offsets().data(), trackletPaths);
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    const auto paths = trackletPaths.view(hostParameters.minClusters);
+
+    // The triplet stage's inputs: the first-tracklet order; the targets'
+    // variance bounds are the plan's, over the whole frame, uploaded with it.
+    Index firstTracklets = 0U;
+    status = glue::permutation<Det>(*mRuntime, mArena, mStream, constView(tracklets), tracklets.size(), parameters, sources, permutation, firstTracklets, tracklets.offsets().data(), paths);
+    ++mReport.readbacks;
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    mReport.permutation = firstTracklets;
+
+    if (!triplets.prepare(mArena, firstTracklets)) {
+      return StageStatus::kOutOfMemory;
+    }
+    // The flat run: the windows'
+    // candidates listed per first tracklet, tested one a thread; the
+    // shape-testing stage where the iteration tests the shapes.
+    status = withShapeTest(hostParameters.shapeTest, [&](auto shape) {
+      const TripletStage<Det, decltype(shape)::value> tripletStage{parameters, sources, mFrame.data(), constView(tracklets), tracklets.offsets().data(), mTargetBounds.data(), permutation.data(), paths};
+      return runFlat(nullptr, firstTracklets, tracker_detail::FlatTriplets<Det, decltype(shape)::value>{.stage = tripletStage}, triplets, mReport.tripletRun);
+    });
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    mReport.triplets = triplets.size();
+    return StageStatus::kComplete;
+  }
+
+  StageStatus runStages(std::size_t iteration, std::size_t sliceIndex, DeviceSliceDownload<Det>* download)
+  {
+    // The graph of a slice whose successor takes it is built with the
+    // successor's parameters (its kink allowance), as on the host; only the
+    // nominal round's fit below takes this iteration's.
+    const bool sharesNext = iteration + 1U < mIterationCount && mHostParameters[iteration + 1U].sharedGraph;
+    const std::size_t graph = sharesNext ? iteration + 1U : iteration;
+    const IterationParameters<Det>* parameters = mParameters.data() + graph;
+    const IterationParameters<Det>& hostParameters = mHostParameters[graph];
+    // The unmasked cores by slice; the masked ones by iteration and slice (`uploadPlan`).
+    const MeasurementRange* core = mRoadCoresMasked ? mSliceRoadCores.data() + (((iteration * mPlan->slices.size()) + sliceIndex) * kLayerCount) : mSliceCores.data() + (sliceIndex * kLayerCount);
+    DeviceStageOutput<TrackletT> tracklets;
+    DeviceSpan<Index> permutation;
+    DeviceStageOutput<TripletT> triplets;
+    StageStatus status = tripletStages(iteration, graph, sliceIndex, tracklets, permutation, triplets);
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+
+    // The longest triplet paths through each tracklet, from the triplets
+    // alone, and the triplets kept only where they are on one:
+    // what the neighbour stage reads.
+    glue::DevicePathBounds tripletPaths;
+    status = glue::tripletPaths<Det>(*mRuntime, mArena, mStream, parameters, mPlan->slices[sliceIndex].sources, constView(tracklets), tracklets.size(), tracklets.offsets().data(), constView(triplets), triplets.offsets().data(), permutation.data(), mReport.permutation, tripletPaths);
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    const auto paths = tripletPaths.view(hostParameters.minClusters);
+    {
+      DeviceStageOutput<TripletT> kept;
+      status = glue::onPathTriplets(*mRuntime, mArena, mStream, paths, triplets, kept, tripletPaths);
+      ++mReport.readbacks;
+      if (status != StageStatus::kComplete) {
+        return status;
+      }
+      triplets = kept;
+    }
+    mReport.triplets = triplets.size();
+
+    DeviceSpan<Index> endOffsets;
+    DeviceSpan<Index> endTriplets;
+    status = glue::endIndex(*mRuntime, mArena, mStream, constView(triplets), triplets.size(), tracklets.size(), endOffsets, endTriplets);
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+
+    DeviceStageOutput<NeighbourT> neighbours;
+    if (!neighbours.prepare(mArena, triplets.size())) {
+      return StageStatus::kOutOfMemory;
+    }
+    road_glue::OrderedCounts counts;
+    status = counts.prepare(*mRuntime, mArena, mStream, triplets.size());
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    const NeighbourStage<Det> neighbourStage{parameters, mFrame.data(), constView(tracklets), constView(triplets), endOffsets.data(), endTriplets.data(), paths, triplets.view().level, counts.view(road_glue::linkSourcesOf(parameters), core)};
+    status = runStage(mNeighbourStage, neighbours, LayeredNeighbours{neighbourStage, tripletPaths.layerTriplets.data()});
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    mReport.neighbours = neighbours.size();
+
+    // The chained count and the overflow flag in one readback; with a
+    // download, also the chained triplets' list, which the tests compare
+    // with the host's.
+    Index chainedCount = 0U;
+    status = counts.summarize(*mRuntime, mStream, constView(triplets), triplets.size(), chainedCount);
+    mReport.readbacks += triplets.size() != 0U ? 1U : 0U;
+    DeviceSpan<Index> chained;
+    Index chainedListed = 0U;
+    if (status == StageStatus::kComplete && download != nullptr) {
+      status = glue::chained(*mRuntime, mArena, mStream, neighbours.offsets().data(), triplets.size(), chained, chainedListed);
+      ++mReport.readbacks;
+    }
+    mReport.chained = chainedCount;
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+
+    // Counts and successor flags were finalized with the neighbours; overflow
+    // was checked together with the chained summary above.
+    const auto& successorAbove = counts.successorAbove;
+    const auto& roads = counts.roads;
+    DeviceSpan<Index> starts;
+    Index startCount = 0U;
+    status = road_glue::roadStarts(*mRuntime, mArena, mStream, constView(tracklets), constView(triplets), triplets.size(), successorAbove.data(), roads.data(), road_glue::roadStartRuleOf(parameters, hostParameters), starts, startCount);
+    ++mReport.readbacks;
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    DeviceSpan<Index> roadOffsets;
+    Index roadCount = 0U;
+    status = road_glue::roadOffsets(*mRuntime, mArena, mStream, starts.data(), startCount, roads.data(), roadOffsets, roadCount);
+    ++mReport.readbacks;
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    mReport.roads = roadCount;
+
+    // The road fit, and its records kept for the iteration.
+    Records records;
+    if (!records.prepare(mArena, roadCount)) {
+      return StageStatus::kOutOfMemory;
+    }
+    const RoadWalk walk{starts.data(), roadOffsets.data(), startCount, neighbours.offsets().data(), neighbours.view().from, triplets.view().level, roads.data()};
+    // An iteration with a kink allowance takes it on the fit's last step
+    // (against the road-end fakes): its own instantiation.
+    // An iteration with the beam constraint fits on the stage that also
+    // tests the beam line, as the host.
+    // With a successor that takes this graph (one graph for both rounds; the
+    // host: Tracker::runRoads), the nominal round's
+    // roads are fitted with this iteration's settings into its records and
+    // every road with the successor's into the successor's (`mSharedChunks`),
+    // which its endIteration takes as its records.
+    const auto fitRoads = [&]<bool NominalOnly>(std::size_t owner, Records& into) {
+      const IterationParameters<Det>* ownerParameters = mParameters.data() + owner;
+      const IterationParameters<Det>& ownerHost = mHostParameters[owner];
+      const auto run = [&]<bool BeamLine, bool LastStepAllowance, bool InnerTrim>() {
+        const RoadFitStage<Det, Material, BeamLine, NominalOnly, LastStepAllowance, InnerTrim> fit{ownerParameters, mFrame.data(), mGeometry.data(), mMaterial.data(), mPropagator, constView(tracklets), constView(triplets), walk};
+        return runStage(mRecordStage, into, fit);
+      };
+      // An iteration with innerTrim fits a refused road again without its
+      // innermost clusters, as the host.
+      return withBools([&]<bool BeamLine, bool LastStepAllowance, bool InnerTrim>(std::bool_constant<BeamLine>, std::bool_constant<LastStepAllowance>, std::bool_constant<InnerTrim>) { return run.template operator()<BeamLine, LastStepAllowance, InnerTrim>(); }, ownerHost.beamConstraint, takesLastStepAllowance(ownerHost), ownerHost.innerTrim != 0U);
+    };
+    status = sharesNext ? fitRoads.template operator()<true>(iteration, records) : fitRoads.template operator()<false>(iteration, records);
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    mReport.records = records.size();
+    if (!mChunks.append(mArena, ArenaEnd::kScratch, records.output(), 0U, records.size(), mStream)) {
+      return StageStatus::kOutOfMemory;
+    }
+    if (sharesNext) {
+      Records shared;
+      if (!shared.prepare(mArena, roadCount)) {
+        return StageStatus::kOutOfMemory;
+      }
+      status = fitRoads.template operator()<false>(iteration + 1U, shared);
+      if (status != StageStatus::kComplete) {
+        return status;
+      }
+      if (!mSharedChunks.append(mArena, ArenaEnd::kScratch, shared.output(), 0U, shared.size(), mStream)) {
+        return StageStatus::kOutOfMemory;
+      }
+    }
+
+    if (download != nullptr) {
+      gtrk::download(successorAbove, download->successorAbove, triplets.size(), mStream);
+      gtrk::download(roads, download->roads, triplets.size(), mStream);
+      gtrk::download(starts, download->starts, startCount, mStream);
+      gtrk::download(roadOffsets, download->roadOffsets, std::size_t{startCount} + 1U, mStream);
+      gtrk::download(records, download->records, mStream);
+      gtrk::download(tracklets, download->tracklets, mStream);
+      gtrk::download(triplets, download->triplets, mStream);
+      gtrk::download(neighbours, download->neighbours, mStream);
+      gtrk::download(chained, download->chained, chainedListed, mStream);
+    }
+    return StageStatus::kComplete; // runSlice synchronises
+  }
+
+  /// The end of an iteration after its gather, in the iteration scope: the
+  /// selection, the refit and the
+  /// follow on a working copy of the used mask, the tracks appended to
+  /// the timeframe's, and only then the working mask committed. A failure
+  /// before the commit leaves the used mask and the tracks as they were.
+  [[nodiscard]] StageStatus endStages(DeviceIterationDownload<Det>* download)
+  {
+    const Index rows = static_cast<Index>(mRows);
+    const auto records = std::as_const(mGathered).view();
+    const auto recordCount = static_cast<Index>(mGathered.size());
+    const IterationParameters<Det>& hostParameters = mHostParameters[mIteration];
+    const IterationParameters<Det>* parameters = mParameters.data() + mIteration;
+    auto& report = mIterationReport;
+
+    DeviceSpan<std::uint8_t> working;
+    if (!working.allocate(mArena, rows)) {
+      return StageStatus::kOutOfMemory;
+    }
+    mRuntime->copyOnDevice(working.data(), std::as_const(mUsed).data(), rows, mStream);
+
+    selection_glue::Selected selected;
+    StageStatus status = selection_glue::select<kMaxClusters>(*mRuntime, mArena, mStream, records, recordCount, working.data(), rows, hostParameters.sharedInnermost, selected);
+    report.readbacks = selected.readbacks;
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    report.duplicates = selected.duplicates;
+    report.mismatches = selected.mismatches;
+    report.rounds = selected.rounds;
+    report.tracks = selected.tracks;
+
+    // The refit, one element per selected record, into the iteration's tracks.
+    const Index trackCount = selected.tracks;
+    DeviceColumns<TrackRecord::template RecordT> tracks;
+    DeviceSpan<Proposal> proposals;
+    DeviceSpan<follow::KinkSteps> kinkSteps;
+    DeviceSpan<ClusterList<kMaxClusters>> followRows;
+    DeviceSpan<std::uint8_t> followCounts;
+    DeviceSpan<BoundTrackState> endStarts;
+    const Index followCount = hostParameters.follow || hostParameters.followEnd ? trackCount : 0U;
+    const Index kinkStepCount = Follow<Det>::takesKinkSteps(hostParameters) ? followCount : 0U;
+    if (!tracks.allocate(mArena, trackCount) || !proposals.allocate(mArena, followCount) || !kinkSteps.allocate(mArena, kinkStepCount) || !followRows.allocate(mArena, followCount) || !followCounts.allocate(mArena, followCount) || !endStarts.allocate(mArena, hostParameters.followEnd ? trackCount : 0U)) {
+      return StageStatus::kOutOfMemory;
+    }
+    const TrackRefitElement<Det, Material> refit{mFrame.data(), mGeometry.data(), mMaterial.data(), mPropagator, records.clusters, records.count, records.outwardState, records.chi2, std::as_const(selected.selected).data(), tracks.view(), 0U, static_cast<std::uint8_t>(mIteration), kinkBudget(hostParameters)};
+    algorithms::forEach(*mRuntime, mStream, trackCount, refit);
+
+    // The follow, the host's sequence
+    // (`follow::runSequence`), its bids in the rounds' slots. The host's
+    // priority, trackCount - (trackOffset + track), is the iteration's count
+    // less the track.
+    if ((hostParameters.follow || hostParameters.followEnd) && trackCount != 0U) {
+      runFollow(mIteration, tracks, trackCount, false, proposals.data(), kinkStepCount != 0U ? kinkSteps.data() : nullptr, followRows, followCounts, selected.slots, rows, working, hostParameters.followEnd ? endStarts.data() : nullptr);
+    }
+
+    // A length or a pT floor after the follow (the host:
+    // Tracker::dropShortTracks): the
+    // iteration's tracks below them dropped, the kept ones and their proposals compacted, and the mask
+    // rebuilt as the one before the selection plus the kept tracks' rows as
+    // the follow left them.
+    Index keptCount = trackCount;
+    if (dropsAfterFollow(hostParameters) && trackCount != 0U) {
+      auto scratch = mArena.scope(ArenaEnd::kScratch);
+      DeviceSpan<Index> kept;
+      status = algorithms::selectIndices(*mRuntime, mArena, mStream, trackCount, tracker_detail::KeptAfterFollow<Det>{parameters, std::as_const(tracks).view().count, std::as_const(tracks).view().state}, kept, keptCount, ArenaEnd::kScratch);
+      ++report.readbacks;
+      if (status != StageStatus::kComplete) {
+        return status;
+      }
+      if (keptCount != trackCount) {
+        DeviceColumns<TrackRecord::template RecordT> keptTracks;
+        DeviceSpan<Proposal> keptProposals;
+        DeviceSpan<std::uint8_t> cut;
+        if (!keptTracks.allocate(mArena, keptCount) || !keptProposals.allocate(mArena, followCount != 0U ? keptCount : 0U) || !cut.allocate(mArena, rows)) {
+          return StageStatus::kOutOfMemory;
+        }
+        device_storage_detail::forEachColumnPair(std::as_const(tracks).view(), keptTracks.view(), [&](auto* to, const auto* from) { algorithms::forEach(*mRuntime, mStream, keptCount, algorithms::Gather<std::remove_pointer_t<decltype(to)>>{from, kept.data(), to}); });
+        if (followCount != 0U) {
+          algorithms::forEach(*mRuntime, mStream, keptCount, algorithms::Gather<Proposal>{std::as_const(proposals).data(), kept.data(), keptProposals.data()});
+        }
+        mRuntime->copyOnDevice(cut.data(), std::as_const(mUsed).data(), rows, mStream);
+        algorithms::forEach(*mRuntime, mStream, keptCount, tracker_detail::RestoreRows<kMaxClusters>{std::as_const(keptTracks).view().clusters, std::as_const(keptTracks).view().count, std::as_const(working).data(), cut.data()});
+        tracks = keptTracks;
+        proposals = keptProposals;
+        working = cut;
+      }
+    }
+
+    // The successor's recovery pass (the host: Tracker::runIteration's
+    // followEarlier): every track so far followed
+    // again with the successor's settings before it makes its seeds, the rows
+    // it takes its own. Here, with this iteration's tracks final and before
+    // the commit, nothing runs in between: the tracks so far gathered with
+    // this iteration's, followed, and put back as one chunk; the old chunks'
+    // storage stays until the timeframe ends.
+    bool committed = false;
+    if (mIteration + 1U < mIterationCount && mHostParameters[mIteration + 1U].followEarlier && mHostParameters[mIteration + 1U].follow && mTrackChunks.rows() + keptCount != 0U) {
+      status = followEarlier(mIteration + 1U, tracks, keptCount, working, selected.slots, rows);
+      if (status != StageStatus::kComplete) {
+        return status;
+      }
+      committed = true;
+    }
+
+    if (download != nullptr) {
+      gtrk::download(selected.ranked, download->ranked, selected.unique, mStream);
+      gtrk::download(selected.selected, download->selected, trackCount, mStream);
+      gtrk::download(proposals, download->proposals, proposals.size(), mStream);
+      gtrk::download(tracks, download->tracks, keptCount, mStream);
+      gtrk::download(working, download->used, rows, mStream);
+    }
+
+    // The last fallible step, then the commit.
+    if (!committed && !mTrackChunks.append(mArena, ArenaEnd::kScratch, tracks, 0U, keptCount, mStream)) {
+      return StageStatus::kOutOfMemory;
+    }
+    mRuntime->copyOnDevice(mUsed.data(), std::as_const(working).data(), rows, mStream);
+    return StageStatus::kComplete; // endIteration synchronises
+  }
+
+  /// The recovery pass of iteration \a successor over every track so far --
+  /// the chunks' and this iteration's \a tracks (\a trackCount of them) --
+  /// with \a working as the used mask, its bids in \a slots (one per row,
+  /// \a rows): the host's `Follow::run` with `earlier`. The tracks, updated,
+  /// replace the chunks as one.
+  [[nodiscard]] StageStatus followEarlier(std::size_t successor, const DeviceColumns<TrackRecord::template RecordT>& tracks, Index trackCount, DeviceSpan<std::uint8_t>& working, DeviceSpan<Index>& slots, Index rows)
+  {
+    const IterationParameters<Det>& host = mHostParameters[successor];
+    const auto earlier = static_cast<Index>(mTrackChunks.rows());
+    const Index total = earlier + trackCount;
+    DeviceColumns<TrackRecord::template RecordT> all;
+    DeviceSpan<Proposal> proposals;
+    DeviceSpan<follow::KinkSteps> kinkSteps;
+    DeviceSpan<ClusterList<kMaxClusters>> followRows;
+    DeviceSpan<std::uint8_t> followCounts;
+    const Index kinkStepCount = Follow<Det>::takesKinkSteps(host) ? total : 0U;
+    if (!all.allocate(mArena, total) || !proposals.allocate(mArena, total) || !kinkSteps.allocate(mArena, kinkStepCount) || !followRows.allocate(mArena, total) || !followCounts.allocate(mArena, total)) {
+      return StageStatus::kOutOfMemory;
+    }
+    mTrackChunks.gather(all, 0U, mStream);
+    copyColumns(tracks, 0U, all, earlier, trackCount, mStream);
+    runFollow(successor, all, total, true, proposals.data(), kinkStepCount != 0U ? kinkSteps.data() : nullptr, followRows, followCounts, slots, rows, working, nullptr);
+    mTrackChunks.clear();
+    if (!mTrackChunks.append(mArena, ArenaEnd::kScratch, all, 0U, total, mStream)) {
+      return StageStatus::kOutOfMemory;
+    }
+    return StageStatus::kComplete;
+  }
+
+  /// The follow of iteration \a iteration over \a count tracks of \a tracks
+  /// (`follow::runSequence`, as the host's `Follow::run`): \a earlier the
+  /// earlier iterations' tracks (`followEarlier`), the proposals into
+  /// \a settled, the kink steps into \a steps where the iteration keeps
+  /// them, the combined rows into \a followRows and \a followCounts, the
+  /// bids in \a slots (one per row, \a rows of them), the marks in
+  /// \a working, the end starts in \a endStarts where the iteration decides
+  /// the end again.
+  void runFollow(std::size_t iteration, DeviceColumns<TrackRecord::template RecordT>& tracks, Index count, bool earlier, Proposal* settled, follow::KinkSteps* steps, DeviceSpan<ClusterList<kMaxClusters>>& followRows, DeviceSpan<std::uint8_t>& followCounts, DeviceSpan<Index>& slots, Index rows, DeviceSpan<std::uint8_t>& working, BoundTrackState* endStarts)
+  {
+    const IterationParameters<Det>& host = mHostParameters[iteration];
+    follow::runSequence(tracker_detail::FollowLaunch{.runtime = *mRuntime, .stream = mStream}, follow::Inputs<Det, Material>{
+                                                                                                 .parameters = mParameters.data() + iteration,
+                                                                                                 .choices = &host,
+                                                                                                 .frame = mFrame.data(),
+                                                                                                 .geometry = mGeometry.data(),
+                                                                                                 .material = mMaterial.data(),
+                                                                                                 .propagator = mPropagator,
+                                                                                                 .tracks = tracks.view(),
+                                                                                                 .constTracks = std::as_const(tracks).view(),
+                                                                                                 .trackOffset = 0U,
+                                                                                                 .trackCount = count,
+                                                                                                 .inward = host.sharedInnermost == 0U,
+                                                                                                 .earlier = earlier,
+                                                                                                 .used = working.data(),
+                                                                                                 .rowCount = rows,
+                                                                                                 .maxCandidateWidthPS = std::as_const(mLayerMaxWidthPS).data(),
+                                                                                                 .cells = mSensorCells,
+                                                                                                 .proposals = settled,
+                                                                                                 .bids = slots.data(),
+                                                                                                 .rows = followRows.data(),
+                                                                                                 .counts = followCounts.data(),
+                                                                                                 .steps = steps,
+                                                                                                 .endStarts = endStarts,
+                                                                                               });
+  }
+
+  /// `requireTimeframe`, and no iteration open: \a call names the caller.
+  void requireNoIteration(const char* call) const
+  {
+    requireTimeframe();
+    if (mIterationOpen) {
+      throw std::logic_error(std::string{call} + " with an iteration open");
+    }
+  }
+
+  /// A slice's scope on the arena, the previous one closed and the report
+  /// cleared.
+  void openSlice()
+  {
+    // Every call before returns with the stream drained.
+    closeFrom(Scope::kSlice);
+    mSliceScope.emplace(mArena.scope());
+    mReport = {};
+  }
+
+  void requireTimeframe() const
+  {
+    if (!mTimeframeScope) {
+      throw std::logic_error("no timeframe has been uploaded to the device");
+    }
+  }
+
+  /// The tracker's scopes: the run is the
+  /// arena itself; the timeframe holds, on the base end, the slice or the
+  /// iteration's -- never both at once -- and, on the scratch end, the
+  /// tracks and above them the open iteration's record chunks.
+  enum class Scope : std::uint8_t { kRun,
+                                    kTimeframe,
+                                    kChunks,
+                                    kIteration,
+                                    kSlice };
+
+  /// Close \a scope and every scope inside it, innermost first: the only
+  /// place scopes are closed. The slice goes with each; the chunks and the
+  /// iteration's scope go with their own call or with the timeframe, the
+  /// tracks with the timeframe.
+  void closeFrom(Scope scope) noexcept
+  {
+    mSliceScope.reset();
+    switch (scope) {
+      case Scope::kSlice:
+        return;
+      case Scope::kChunks:
+        closeChunks();
+        return;
+      case Scope::kIteration:
+        mIterationScope.reset();
+        mGathered = {};
+        return;
+      case Scope::kTimeframe:
+      case Scope::kRun:
+        break;
+    }
+    mIterationScope.reset();
+    mGathered = {};
+    mSharedGathered = {};
+    mSharedScope.reset();
+    closeChunks();
+    mTrackChunks.clear();
+    mTracksScope.reset();
+    mTimeframeScope.reset();
+    mRows = 0U;
+    mHostFrame = nullptr;
+    mPlan = nullptr;
+    if (scope == Scope::kTimeframe) {
+      return;
+    }
+    mArena.reset();
+    mConfigured = false;
+    mIterationCount = 0U;
+    mParameters = {};
+    mHostParameters.clear();
+    mGeometry = {};
+    mMaterial.release();
+    mCellLayers = {};
+    mCellOffsets = {};
+    mCellSensors = {};
+    mSensorCells = {};
+  }
+
+  void closeChunks() noexcept
+  {
+    mChunks.clear();
+    mSharedChunks.clear();
+    mChunksScope.reset();
+    mIterationOpen = false;
+  }
+
+  DeviceRuntime* mRuntime = nullptr;
+  DeviceArena mArena;
+  DeviceStream mStream;
+  GpuStage<TrackletT> mTrackletStage;
+  GpuStage<NeighbourT> mNeighbourStage;
+  GpuStage<SelectionRecordOf<kMaxClusters>::template RecordT> mRecordStage;
+  DeviceColumnChunks<SelectionRecordOf<kMaxClusters>::template RecordT> mChunks;
+  DeviceColumnChunks<SelectionRecordOf<kMaxClusters>::template RecordT> mSharedChunks; ///< the successor's records, where it takes this graph
+  DeviceColumns<SelectionRecordOf<kMaxClusters>::template RecordT> mGathered;
+  DeviceColumns<SelectionRecordOf<kMaxClusters>::template RecordT> mSharedGathered; ///< `mSharedChunks` gathered, in `mSharedScope`
+  DeviceColumnChunks<TrackRecord::template RecordT> mTrackChunks;
+  IterationReport mIterationReport;
+  std::size_t mOuterArenaPeak = 0U; ///< the arena's peak before the open iteration's window
+  flat::FlatOptions mFlatOptions;   ///< the flat runs' test hook (`setFlatChunkPairs`)
+  Report mReport;
+
+  DeviceSpan<IterationParameters<Det>> mParameters;
+  std::vector<IterationParameters<Det>> mHostParameters; ///< the same, for the values the host reads
+  DeviceObject<TrackingGeometry<Det>> mGeometry;
+  DeviceMaterial<Material> mMaterial;
+  DeviceSpan<SensorCellLayer> mCellLayers; ///< the sensors by place, for the outward follow
+  DeviceSpan<std::uint32_t> mCellOffsets;
+  DeviceSpan<std::uint32_t> mCellSensors;
+  SensorCellsView mSensorCells;
+  /// The sensor cells on the host and the geometry they were built from.
+  std::optional<SensorCells<Det>> mHostCells;
+  std::array<std::byte, sizeof(TrackingGeometry<Det>)> mHostCellsGeometry{};
+  Propagator mPropagator;
+  std::size_t mIterationCount = 0U;
+  bool mConfigured = false;
+
+  std::optional<ArenaScope> mTimeframeScope;
+  DeviceColumns<MeasurementT> mColumns;
+  DeviceSpan<Index> mOffsets;
+  DeviceSpan<std::uint8_t> mUsed;
+  DeviceObject<Frame> mFrame;
+  std::size_t mRows = 0U;
+  const Frame* mHostFrame = nullptr;
+  const TimeframePlan<Det>* mPlan = nullptr;
+  DeviceSpan<LayerRowMap<Det>> mSliceSources;
+  DeviceSpan<MeasurementRange> mSliceCores;
+  DeviceSpan<MeasurementRange> mSliceRoadCores; ///< mSliceCores with each iteration's start-layer mask, where one has a mask
+  bool mRoadCoresMasked = false;
+  DeviceSpan<VertexWindowParameters<Det>> mVertexWindows;
+  DeviceSpan<VertexSeed> mSeeds; ///< the beam line, then the vertices
+  DeviceSpan<std::uint32_t> mLayerMaxWidthPS;
+  DeviceSpan<TripletTargetBounds> mTargetBounds; ///< the plan's, over the whole frame
+  std::optional<ArenaScope> mTracksScope;
+
+  std::optional<ArenaScope> mChunksScope;
+  std::optional<ArenaScope> mIterationScope;
+  std::optional<ArenaScope> mSharedScope; ///< the shared records', below the iteration's that takes them
+  std::optional<ArenaScope> mSliceScope;
+  std::size_t mIteration = 0U;
+  StageStatus mIterationStatus = StageStatus::kComplete;
+  bool mIterationOpen = false;
+};
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+
+#endif // GTRK_TRACKING_GPU_DEVICETRACKER_CUH_
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/DeviceTrackerITS.cu b/Detectors/GenericTracking/tracking/GPU/cuda/DeviceTrackerITS.cu
new file mode 100644
index 0000000000000..e24d915d0e9a2
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/DeviceTrackerITS.cu
@@ -0,0 +1,32 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceTrackerITS.cu
+/// \brief The backend's device tracker for the ITS.
+///        One translation unit per layout,
+///        so that the layouts compile in parallel.
+
+#include "DeviceTracker.cuh"
+
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Tracking/GPU/MaterialPort.h"
+
+#include "DetectorsBase/MatLayerCylSet.h"
+
+#include <cstddef>
+#include <memory>
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+{
+
+std::unique_ptr<DeviceTracker<detectors::ITS, o2::base::MatLayerCylSet>> makeITSTracker(DeviceRuntime& runtime, DeviceBlock block) { return std::make_unique<DeviceTrackerImpl<detectors::ITS, o2::base::MatLayerCylSet>>(runtime, block); }
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/DeviceTrackerMFT.cu b/Detectors/GenericTracking/tracking/GPU/cuda/DeviceTrackerMFT.cu
new file mode 100644
index 0000000000000..ae5a6dac479e0
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/DeviceTrackerMFT.cu
@@ -0,0 +1,31 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceTrackerMFT.cu
+/// \brief The backend's device tracker for the MFT. One
+///        translation unit per layout, so that the layouts compile in parallel.
+
+#include "DeviceTracker.cuh"
+
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Tracking/GPU/MaterialPort.h"
+
+#include "DetectorsBase/MatLayerCylSet.h"
+
+#include <cstddef>
+#include <memory>
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+{
+
+std::unique_ptr<DeviceTracker<detectors::MFT, o2::base::MatLayerCylSet>> makeMFTTracker(DeviceRuntime& runtime, DeviceBlock block) { return std::make_unique<DeviceTrackerImpl<detectors::MFT, o2::base::MatLayerCylSet>>(runtime, block); }
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/DeviceTrackerTRKFT3.cu b/Detectors/GenericTracking/tracking/GPU/cuda/DeviceTrackerTRKFT3.cu
new file mode 100644
index 0000000000000..12e608adfe1be
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/DeviceTrackerTRKFT3.cu
@@ -0,0 +1,32 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceTrackerTRKFT3.cu
+/// \brief The backend's device tracker for ALICE 3's TRKFT3.
+///        One translation unit per layout, so
+///        that the layouts compile in parallel.
+
+#include "DeviceTracker.cuh"
+
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Tracking/GPU/MaterialPort.h"
+
+#include "DetectorsBase/MatLayerCylSet.h"
+
+#include <cstddef>
+#include <memory>
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+{
+
+std::unique_ptr<DeviceTracker<detectors::TRKFT3, o2::base::MatLayerCylSet>> makeTRKFT3Tracker(DeviceRuntime& runtime, DeviceBlock block) { return std::make_unique<DeviceTrackerImpl<detectors::TRKFT3, o2::base::MatLayerCylSet>>(runtime, block); }
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/FlatStage.cuh b/Detectors/GenericTracking/tracking/GPU/cuda/FlatStage.cuh
new file mode 100644
index 0000000000000..e7bd38631f2c0
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/FlatStage.cuh
@@ -0,0 +1,462 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file FlatStage.cuh
+/// \brief A stage run over a flat candidate list: the walk per element, the
+///        test per candidate.
+///
+/// An element's candidates are what its walk admits, in the walk's order; a
+/// stage's records are the candidates its test accepts, in that order, with
+/// the element's count. `runFlat` runs them apart:
+///
+/// count     one thread an element: the walk, counting; the exclusive scan
+///           of the counts is each element's pair offset in the list.
+/// chunk     a range [a, b) of the list sized to the arena's free bytes;
+///           the elements whose candidates lie in it are [sourceBegin,
+///           sourceEnd) of the listed elements (one may straddle both ends).
+/// fill      one thread an element of the chunk (a group of the adapter's
+///           `kFillLanes` where it has more than one): the walk again, writing the
+///           candidates in [a, b) as pairs at their offsets, and the
+///           element's context the test reads.
+/// test      `selectIndices` over the pairs with the adapter's test: the
+///           accepted pairs' indices, stable, so in list order.
+/// emit      one thread an accepted pair: its record into the chunk's
+///           accepted columns; the elements' counts from the runs of equal
+///           sources in the selected list.
+/// assemble  the counts' scan is the offsets; one chunk's columns are the
+///           output, several are gathered in chunk order.
+///
+/// The records and their order are the serial stage's: the walk is the
+/// stage's own traversal, the test its own test, the stable select keeps the
+/// walk's order, and chunks are consecutive ranges of it. No ordinal limit
+/// on the candidates: a source may hold more than the output admits of
+/// records (the output's limit per element, `kMaxPerElement`, is checked on
+/// the accepted counts as the staging checks it).
+///
+/// The adapter (one per stage, copied to the kernels by value):
+///   std::uint32_t count(element) const                       -- the walk, counting
+///   void fill(element, position, Sink& sink) const           -- the walk, `sink.put(row, key)` per candidate; the
+///                                                               element's context at `position - sourceBegin`
+///   and, with `kFillLanes` above 1, fill(element, position, Sink&, group) -- the walk by the group's lanes in step,
+///                                                               a step's candidates by `sink.putStep` in lane order
+///   std::uint32_t sourceOf(const CandidatePair&) const       -- the listed position the pair's key holds
+///   bool test(k, const CandidatePair&) const                 -- k the pair's index in the chunk, for what the test keeps for emit
+///   Record emit(k, const CandidatePair&, element) const
+///   bool beginChunk(DeviceArena&, sourceBegin, sourceCount, pairs) -- host: the chunk's contexts and per-pair storage, in the
+///                                                               current scratch scope
+///   std::size_t contextBytes(sources) const                  -- host: what beginChunk takes for that many sources
+///   std::size_t pairBytes() const                            -- host: and per pair
+///
+/// \a listed may be nullptr: the elements are then 0 to listedCount - 1.
+///
+/// Included only by the .cu sources of a backend library or its test library,
+/// as GpuStage.cuh.
+
+#ifndef GTRK_TRACKING_GPU_FLATSTAGE_CUH_
+#define GTRK_TRACKING_GPU_FLATSTAGE_CUH_
+
+#include "DeviceAlgorithms.cuh"
+#include "Platform.cuh"
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/DeviceStageOutput.h"
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+
+#include "GPUCommonAlgorithm.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::flat
+{
+
+/// One candidate: its row and the adapter's key (the listed position of its
+/// element, with whatever the adapter packs beside it).
+struct CandidatePair {
+  std::uint32_t row = 0U;
+  std::uint32_t key = 0U;
+};
+
+/// What the fill hands an element's walk: `put` every candidate in the walk's
+/// order; those in the chunk are written, the others only counted past.
+struct Sink {
+  CandidatePair* pairs = nullptr;
+  std::uint32_t next = 0U;       ///< the candidate's position in the list
+  std::uint32_t chunkBegin = 0U; ///< the chunk [chunkBegin, chunkEnd)
+  std::uint32_t chunkEnd = 0U;
+  GPUdi() void put(std::uint32_t row, std::uint32_t key)
+  {
+    const std::uint32_t at = next++;
+    if (at >= chunkBegin && at < chunkEnd) {
+      pairs[at - chunkBegin] = CandidatePair{.row = row, .key = key};
+    }
+  }
+  /// A group's step: \a mask the lanes with a candidate;
+  /// this lane's, if \a has, after those of the lanes before it, and `next`
+  /// past them all.
+  GPUdi() void putStep(std::uint64_t mask, std::uint32_t lane, bool has, std::uint32_t row, std::uint32_t key)
+  {
+    if (has) {
+      const std::uint32_t at = next + static_cast<std::uint32_t>(__popcll(mask & ((std::uint64_t{1} << lane) - 1U)));
+      if (at >= chunkBegin && at < chunkEnd) {
+        pairs[at - chunkBegin] = CandidatePair{.row = row, .key = key};
+      }
+    }
+    next += static_cast<std::uint32_t>(__popcll(mask));
+  }
+};
+
+/// A test hook: chunks of at most this many pairs (0: the arena's free bytes
+/// decide); set only by the tests, directly or through
+/// `DeviceTracker::setFlatChunkPairs`.
+struct FlatOptions {
+  std::size_t maxChunkPairs = 0U;
+};
+
+namespace detail
+{
+
+/// The element at a listed position: the list's, or the position itself.
+GPUdi() std::uint32_t elementAt(const std::uint32_t* listed, std::uint32_t position) { return listed != nullptr ? listed[position] : position; }
+
+/// The lanes an adapter's fill walks an element with: its `kFillLanes`, or one.
+template <typename Adapter>
+constexpr std::uint32_t fillLanes()
+{
+  if constexpr (requires { Adapter::kFillLanes; }) {
+    return Adapter::kFillLanes;
+  } else {
+    return 1U;
+  }
+}
+
+/// The candidates of each listed element, and the 0 after the last that
+/// makes the scan's last offset the total.
+template <typename Adapter>
+struct CountElements {
+  Adapter adapter;
+  const std::uint32_t* listed;
+  std::uint32_t listedCount;
+  std::uint32_t* counts;
+  GPUdi() void operator()(std::uint32_t i) const { counts[i] = i < listedCount ? adapter.count(elementAt(listed, i)) : 0U; }
+};
+
+/// A run's words on the device, one block: zeroed by one fill, the sum and
+/// the largest read back by one copy.
+struct FlatWords {
+  Counter sum;            ///< the list's length in 64 bits (ReduceCounts)
+  std::uint32_t largest;  ///< its longest element (ReduceCounts)
+  std::uint32_t range[2]; ///< a chunk's elements (chunkRangeKernel)
+  std::uint32_t overflow; ///< an element past the output's limit (AddCounts)
+};
+
+/// The chunk's elements: [0] the first listed position whose candidates reach
+/// past \a a, [1] the first whose candidates start at or past \a b. A
+/// template, as every kernel of a header: one instance a library.
+template <typename = void>
+GPUg() void chunkRangeKernel(const std::uint32_t* offsets, std::uint32_t listedCount, std::uint32_t a, std::uint32_t b, std::uint32_t* range)
+{
+  if (blockIdx.x != 0U || threadIdx.x != 0U) {
+    return;
+  }
+  range[0] = o2::gpu::CAAlgo::partitionPoint(0U, listedCount, [&](std::uint32_t i) { return offsets[i + 1U] <= a; });
+  range[1] = o2::gpu::CAAlgo::partitionPoint(0U, listedCount, [&](std::uint32_t i) { return offsets[i] < b; });
+}
+
+template <typename Adapter>
+struct FillElements {
+  Adapter adapter;
+  const std::uint32_t* listed;
+  const std::uint32_t* offsets;
+  std::uint32_t sourceBegin;
+  CandidatePair* pairs;
+  std::uint32_t chunkBegin;
+  std::uint32_t chunkEnd;
+  GPUdi() void operator()(std::uint32_t j) const
+  {
+    const std::uint32_t position = sourceBegin + j;
+    // A source without candidates: no pair of it, so no test or record reads its context.
+    if (offsets[position] == offsets[position + 1U]) {
+      return;
+    }
+    Sink sink{.pairs = pairs, .next = offsets[position], .chunkBegin = chunkBegin, .chunkEnd = chunkEnd};
+    adapter.fill(elementAt(listed, position), position, sink);
+  }
+  /// The same by a group of the adapter's `kFillLanes` lanes.
+  template <typename Group>
+  GPUdi() void together(std::uint32_t j, const Group& group) const
+  {
+    const std::uint32_t position = sourceBegin + j;
+    if (offsets[position] == offsets[position + 1U]) {
+      return;
+    }
+    Sink sink{.pairs = pairs, .next = offsets[position], .chunkBegin = chunkBegin, .chunkEnd = chunkEnd};
+    adapter.fill(elementAt(listed, position), position, sink, group);
+  }
+};
+
+template <typename Adapter>
+struct TestPairs {
+  Adapter adapter;
+  const CandidatePair* pairs;
+  GPUdi() bool operator()(std::uint32_t k) const { return adapter.test(k, pairs[k]); }
+};
+
+/// One accepted pair's record into the chunk's columns, and the runs of equal
+/// sources: where a source's run starts and ends in the selected list.
+template <template <template <class> class> class S, typename Adapter>
+struct EmitPairs {
+  Adapter adapter;
+  const std::uint32_t* listed;
+  const CandidatePair* pairs;
+  const std::uint32_t* selected;
+  std::uint32_t selectedCount;
+  std::uint32_t sourceBegin;
+  typename DeviceColumns<S>::View accepted;
+  std::uint32_t* runStart; ///< per chunk element, the first selected index of its run
+  std::uint32_t* runEnd;   ///< one past the last
+  GPUdi() void operator()(std::uint32_t k) const
+  {
+    const CandidatePair pair = pairs[selected[k]];
+    const std::uint32_t source = adapter.sourceOf(pair);
+    const auto record = adapter.emit(selected[k], pair, elementAt(listed, source));
+    accepted.apply([&](auto*... column) { record.apply([&](const auto&... value) { ((column[k] = value), ...); }); });
+    if (k == 0U || adapter.sourceOf(pairs[selected[k - 1U]]) != source) {
+      runStart[source - sourceBegin] = k;
+    }
+    if (k + 1U == selectedCount || adapter.sourceOf(pairs[selected[k + 1U]]) != source) {
+      runEnd[source - sourceBegin] = k + 1U;
+    }
+  }
+};
+
+/// The counts summed in 64 bits and their largest, into \a sum and
+/// \a largest: whether the 32-bit offsets hold, and the list's longest element.
+struct ReduceCounts {
+  const std::uint32_t* counts;
+  std::uint32_t count;
+  Counter* sum;
+  std::uint32_t* largest;
+  GPUdi() void operator()(std::uint32_t i) const
+  {
+    // One thread of the grid-stride loop adds every `stride`-th count.
+    const std::uint32_t stride = blockDim.x * gridDim.x;
+    Counter mine = 0U;
+    std::uint32_t top = 0U;
+    for (std::uint32_t k = i; k < count; k += stride) {
+      mine += counts[k];
+      top = top > counts[k] ? top : counts[k];
+    }
+    if (mine != 0U) {
+      atomicAdd(sum, mine);
+    }
+    if (top != 0U) {
+      atomicMax(largest, top);
+    }
+  }
+};
+
+/// The chunk's elements' accepted counts added to the output's, and the
+/// largest seen (a flag past the output's limit per element).
+struct AddCounts {
+  const std::uint32_t* listed;
+  std::uint32_t sourceBegin;
+  const std::uint32_t* runStart;
+  const std::uint32_t* runEnd;
+  std::uint32_t* counts;
+  std::uint32_t* overflow;
+  std::uint32_t limit;
+  GPUdi() void operator()(std::uint32_t j) const
+  {
+    const std::uint32_t added = runEnd[j] - runStart[j];
+    const std::uint32_t element = elementAt(listed, sourceBegin + j);
+    const std::uint32_t total = counts[element] + added;
+    counts[element] = total;
+    if (total > limit) {
+      *overflow = 1U;
+    }
+  }
+};
+
+} // namespace detail
+
+/// The stage \a adapter describes over the \a listedCount listed elements,
+/// into \a output (prepared for its element count by the caller; the others'
+/// counts 0): the records of the serial stage in its order. The list and
+/// the chunks' working storage on the scratch end within this call; the
+/// output and the chunks' accepted records on the base end, in the caller's
+/// scope: a run of several chunks holds its records twice until that scope
+/// closes. Statuses as a `GpuStage` run's.
+template <template <template <class> class> class S, typename Adapter>
+[[nodiscard]] StageStatus runFlat(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, const std::uint32_t* listed, std::uint32_t listedCount, Adapter adapter, DeviceStageOutput<S>& output, FlatRunReport& report, const FlatOptions& options = {})
+{
+  using Index = typename DeviceStageOutput<S>::Index;
+  using Record = typename DeviceStageOutput<S>::Record;
+  report = {.freeBytes = arena.capacity() - arena.used()};
+  const Index elements = output.elementCount();
+  // CUB's item counts are ints: past them the run ends with kIndexOverflow,
+  // as a `GpuStage` run's.
+  if (std::size_t{elements} + 1U > static_cast<std::size_t>(std::numeric_limits<int>::max()) || std::size_t{listedCount} + 1U > static_cast<std::size_t>(std::numeric_limits<int>::max())) {
+    return StageStatus::kIndexOverflow;
+  }
+  auto* counts = output.counts().data();
+  runtime.fill(counts, 0U, (std::size_t{elements} + 1U) * sizeof(Index), stream);
+
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  // The list's offsets: the candidates of each listed element, counted and scanned.
+  DeviceSpan<std::uint32_t> candidateCounts;
+  DeviceSpan<std::uint32_t> offsets;
+  DeviceSpan<detail::FlatWords> words;
+  if (!candidateCounts.allocate(arena, std::size_t{listedCount} + 1U, ArenaEnd::kScratch) || !offsets.allocate(arena, std::size_t{listedCount} + 1U, ArenaEnd::kScratch) || !words.allocate(arena, 1U, ArenaEnd::kScratch)) {
+    return StageStatus::kOutOfMemory;
+  }
+  detail::FlatWords* const device = words.data();
+  runtime.fill(device, 0U, sizeof(detail::FlatWords), stream);
+  algorithms::forEach(runtime, stream, listedCount + 1U, detail::CountElements<Adapter>{adapter, listed, listedCount, candidateCounts.data()});
+  StageStatus status = algorithms::exclusiveScan(runtime, arena, stream, candidateCounts.data(), offsets.data(), std::size_t{listedCount} + 1U);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  // The list's length in 64 bits -- the 32-bit offsets must hold it -- and
+  // its longest element; one readback.
+  // A few thousand threads, each over its stride of the counts: two atomics each.
+  algorithms::forEach(runtime, stream, std::min<std::uint32_t>(listedCount, 2048U), detail::ReduceCounts{candidateCounts.data(), listedCount, &device->sum, &device->largest});
+  detail::FlatWords host{};
+  download(words, &host, 1U, stream);
+  stream.synchronize();
+  ++report.readbacks;
+  report.largest = host.largest;
+  if (host.sum > std::numeric_limits<std::uint32_t>::max()) {
+    return StageStatus::kIndexOverflow;
+  }
+  const auto total = static_cast<std::uint32_t>(host.sum);
+  report.candidates = total;
+
+  // The chunks: a pair, the select's index, flag and output for it (9 bytes),
+  // the library's temporary storage (~8), the adapter's per-pair storage, and
+  // at most one accepted record a pair on the base end; the contexts of the
+  // chunk's elements and their run bounds beside.
+  const std::size_t perPair = sizeof(CandidatePair) + 4U + 1U + 4U + 8U + adapter.pairBytes() + sizeof(Record);
+  DeviceColumnChunks<S> chunks;
+  DeviceColumns<S> accepted;
+  std::uint32_t a = 0U;
+  while (a < total || (total == 0U && report.chunks == 0U)) {
+    auto chunkScope = arena.scope(ArenaEnd::kScratch);
+    ++report.chunks;
+    // The chunk: the rest of the list, halved until what it needs -- with the
+    // contexts of the elements it reaches -- fits the arena's free bytes;
+    // one pair at least, so the run progresses or fails for memory.
+    const std::size_t free = arena.capacity() - arena.used();
+    std::size_t chunkPairs = std::size_t{total} - a;
+    if (options.maxChunkPairs > 0U) {
+      chunkPairs = std::min(chunkPairs, options.maxChunkPairs);
+    }
+    chunkPairs = std::min<std::size_t>(chunkPairs, static_cast<std::size_t>(std::numeric_limits<int>::max()) - 1U);
+    std::uint32_t b = a;
+    std::uint32_t range[2]{0U, listedCount};
+    for (;;) {
+      b = static_cast<std::uint32_t>(std::size_t{a} + chunkPairs);
+      // The chunk's elements: every listed one when the chunk is the whole list.
+      range[0] = 0U;
+      range[1] = listedCount;
+      if (listedCount > 0U && !(a == 0U && b == total)) {
+        detail::chunkRangeKernel<><<<1, 1, 0U, nativeStream(runtime, stream)>>>(offsets.data(), listedCount, a, b, device->range);
+        checkLaunch();
+        runtime.copyToHost(range, device->range, sizeof(range), stream);
+        stream.synchronize();
+        ++report.readbacks;
+      }
+      const std::uint32_t reached = range[1] > range[0] ? range[1] - range[0] : 0U;
+      const std::size_t need = (perPair * std::max<std::size_t>(chunkPairs, 1U)) + adapter.contextBytes(reached) + (2U * sizeof(std::uint32_t) * reached);
+      if (need <= free || total == 0U) {
+        break;
+      }
+      if (chunkPairs <= 1U) {
+        return StageStatus::kOutOfMemory;
+      }
+      chunkPairs /= 2U;
+    }
+    const std::uint32_t sourceBegin = range[0];
+    const std::uint32_t sourceCount = range[1] > range[0] ? range[1] - range[0] : 0U;
+
+    // The run bounds of the chunk's elements, starts then ends, in one block.
+    DeviceSpan<CandidatePair> pairs;
+    DeviceSpan<std::uint32_t> runBounds;
+    const std::size_t boundCount = std::max<std::size_t>(sourceCount, 1U);
+    if (!pairs.allocate(arena, std::max<std::size_t>(b - a, 1U), ArenaEnd::kScratch) || !runBounds.allocate(arena, 2U * boundCount, ArenaEnd::kScratch) || !adapter.beginChunk(arena, sourceBegin, sourceCount, b - a)) {
+      return StageStatus::kOutOfMemory;
+    }
+    std::uint32_t* const runStart = runBounds.data();
+    std::uint32_t* const runEnd = runBounds.data() + boundCount;
+    runtime.fill(runBounds.data(), 0U, 2U * boundCount * sizeof(std::uint32_t), stream);
+    const detail::FillElements<Adapter> fill{adapter, listed, offsets.data(), sourceBegin, pairs.data(), a, b};
+    if constexpr (detail::fillLanes<Adapter>() > 1U) {
+      algorithms::forEachGroup<detail::fillLanes<Adapter>()>(runtime, stream, sourceCount, fill);
+    } else {
+      algorithms::forEach(runtime, stream, sourceCount, fill);
+    }
+
+    DeviceSpan<std::uint32_t> selected;
+    std::uint32_t selectedCount = 0U;
+    if (b > a) {
+      status = algorithms::selectIndices(runtime, arena, stream, b - a, detail::TestPairs<Adapter>{adapter, pairs.data()}, selected, selectedCount, ArenaEnd::kScratch);
+      if (status != StageStatus::kComplete) {
+        return status;
+      }
+      ++report.readbacks;
+    }
+
+    if (!accepted.allocate(arena, selectedCount, ArenaEnd::kBase)) {
+      return StageStatus::kOutOfMemory;
+    }
+    algorithms::forEach(runtime, stream, selectedCount, detail::EmitPairs<S, Adapter>{adapter, listed, pairs.data(), selectedCount > 0U ? selected.data() : nullptr, selectedCount, sourceBegin, accepted.view(), runStart, runEnd});
+    algorithms::forEach(runtime, stream, sourceCount, detail::AddCounts{listed, sourceBegin, runStart, runEnd, counts, &device->overflow, static_cast<std::uint32_t>(DeviceStageOutput<S>::kMaxPerElement)});
+    chunks.adopt(accepted);
+    a = b;
+    if (total == 0U) {
+      break;
+    }
+  }
+
+  // The offsets; the limit flag; the records from the chunks' rows.
+  status = algorithms::exclusiveScan(runtime, arena, stream, counts, output.offsets().data(), std::size_t{elements} + 1U);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  std::uint32_t overflow = 0U;
+  runtime.copyToHost(&overflow, &device->overflow, sizeof(overflow), stream);
+  stream.synchronize();
+  ++report.readbacks;
+  if (overflow != 0U) {
+    return StageStatus::kOrdinalOverflow;
+  }
+  if (chunks.rows() > std::numeric_limits<Index>::max()) {
+    return StageStatus::kIndexOverflow;
+  }
+  const auto records = static_cast<Index>(chunks.rows());
+  if (report.chunks == 1U) {
+    output.adoptOutput(accepted, records);
+    return StageStatus::kComplete;
+  }
+  if (!output.allocateOutput(arena, std::max<Index>(records, 1U))) {
+    return StageStatus::kOutOfMemory;
+  }
+  output.setSize(records);
+  chunks.gather(output.output(), 0U, stream);
+  return StageStatus::kComplete;
+}
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::flat
+
+#endif // GTRK_TRACKING_GPU_FLATSTAGE_CUH_
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/GpuStage.cuh b/Detectors/GenericTracking/tracking/GPU/cuda/GpuStage.cuh
new file mode 100644
index 0000000000000..746d614d9c7de
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/GpuStage.cuh
@@ -0,0 +1,355 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GpuStage.cuh
+/// \brief One stage's generate, scan and place on a device.
+///
+/// generate  one thread per element runs the stage's per-element function
+///           with a DeviceEmitter: every emission takes a staging slot from a
+///           64-bit atomic counter and records its element and its ordinal
+///           within the element; the element's count goes to count[e].
+/// scan      an exclusive scan of count over n + 1 entries, count[n] = 0, so
+///           that offset[n] is the total.
+/// place     one thread per staged record: record k of element e goes to
+///           offset[e] + k.
+///
+/// The atomic decides where a record waits, never where it is placed, so the
+/// output is the serial reference's (the tests' test/SerialReferences.h) whatever the
+/// device's schedule.
+///
+/// Included only by the .cu sources of a backend library or its test library,
+/// in the backend's namespace, so its instantiations stay private to that
+/// library.
+
+#ifndef GTRK_TRACKING_GPU_GPUSTAGE_CUH_
+#define GTRK_TRACKING_GPU_GPUSTAGE_CUH_
+
+#include "DeviceAlgorithms.cuh"
+#include "Platform.cuh"
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/DeviceStageOutput.h"
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <utility>
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+{
+
+namespace stage_detail
+{
+
+/// A run's words on the device, one block: zeroed by one fill, read back by
+/// one copy.
+struct StageWords {
+  Counter counter;               ///< the records emitted, past capacity too
+  std::uint32_t ordinalOverflow; ///< an element past its ordinal limit
+};
+
+/// Where a generator's records wait for placement, as a kernel sees it.
+template <template <template <class> class> class S>
+struct StagingState {
+  typename DeviceColumns<S>::View records;
+  typename DeviceStageOutput<S>::Index* element = nullptr;
+  typename DeviceStageOutput<S>::Ordinal* ordinal = nullptr;
+  Counter* counter = nullptr;
+  std::uint32_t* ordinalOverflow = nullptr;
+  Counter capacity = 0U;
+};
+
+/// Record \a ordinal of \a element into the staging: counted before any
+/// check, as the serial reference does, so that past capacity the counter is
+/// the exact size a retry needs.
+template <template <template <class> class> class S>
+GPUdi() void stageRecord(const StagingState<S>& staging, typename DeviceStageOutput<S>::Index element, typename DeviceStageOutput<S>::Index ordinal, const typename DeviceStageOutput<S>::Record& record)
+{
+  const Counter slot = atomicAdd(staging.counter, Counter{1U});
+  if (ordinal >= DeviceStageOutput<S>::kMaxPerElement) {
+    *staging.ordinalOverflow = 1U; // every writer writes the same value
+    return;
+  }
+  if (slot >= staging.capacity) {
+    return;
+  }
+  staging.records.apply([&](auto*... column) { record.apply([&](const auto&... value) { ((column[slot] = value), ...); }); });
+  staging.element[slot] = element;
+  staging.ordinal[slot] = static_cast<typename DeviceStageOutput<S>::Ordinal>(ordinal);
+}
+
+/// What an element's generator emits into on a device: the counterpart of
+/// the serial reference's and CpuStage's Emitter.
+template <template <template <class> class> class S>
+class DeviceEmitter
+{
+ public:
+  using Index = typename DeviceStageOutput<S>::Index;
+  using Ordinal = typename DeviceStageOutput<S>::Ordinal;
+  using Record = typename DeviceStageOutput<S>::Record;
+
+  GPUdi() DeviceEmitter(const StagingState<S>& staging, Index element) : mStaging(staging), mElement(element) {}
+
+  GPUdi() void emit(const Record& record) { stageRecord(mStaging, mElement, mCount++, record); }
+
+  [[nodiscard]] GPUdi() Index count() const { return mCount; }
+
+ private:
+  StagingState<S> mStaging;
+  Index mElement = 0U;
+  Index mCount = 0U;
+};
+
+/// One element generated by one thread: its records staged, its count written.
+template <template <template <class> class> class S, typename Generate>
+GPUdi() void generateOne(const Generate& generate, const StagingState<S>& staging, typename DeviceStageOutput<S>::Index element, typename DeviceStageOutput<S>::Index* counts)
+{
+  DeviceEmitter<S> emitter{staging, element};
+  generate(element, emitter);
+  counts[element] = emitter.count();
+}
+
+template <template <template <class> class> class S, typename Generate>
+GPUg() void GTRK_KERNEL_BOUNDS generateKernel(Generate generate, StagingState<S> staging, typename DeviceStageOutput<S>::Index elements, typename DeviceStageOutput<S>::Index* counts)
+{
+  using Index = typename DeviceStageOutput<S>::Index;
+  const Index element = (blockIdx.x * blockDim.x) + threadIdx.x;
+  if (element < elements) {
+    generateOne(generate, staging, element, counts);
+  }
+}
+
+/// `generateKernel` over the \a listedCount elements \a listed names only,
+/// one thread each; every other element's
+/// count is set to 0 before.
+template <template <template <class> class> class S, typename Generate>
+GPUg() void GTRK_KERNEL_BOUNDS generateListedKernel(Generate generate, StagingState<S> staging, const typename DeviceStageOutput<S>::Index* listed, typename DeviceStageOutput<S>::Index listedCount, typename DeviceStageOutput<S>::Index* counts)
+{
+  using Index = typename DeviceStageOutput<S>::Index;
+  const Index i = (blockIdx.x * blockDim.x) + threadIdx.x;
+  if (i >= listedCount) {
+    return;
+  }
+  generateOne(generate, staging, listed[i], counts);
+}
+
+template <template <template <class> class> class S>
+GPUg() void GTRK_KERNEL_BOUNDS placeKernel(typename DeviceColumns<S>::ConstView staged, const typename DeviceStageOutput<S>::Index* element, const typename DeviceStageOutput<S>::Ordinal* ordinal, const typename DeviceStageOutput<S>::Index* offsets, typename DeviceColumns<S>::View placed, typename DeviceStageOutput<S>::Index records)
+{
+  using Index = typename DeviceStageOutput<S>::Index;
+  const Index slot = (blockIdx.x * blockDim.x) + threadIdx.x;
+  if (slot < records) {
+    const Index to = offsets[element[slot]] + static_cast<Index>(ordinal[slot]);
+    staged.apply([&](const auto*... from) { placed.apply([&](auto*... into) { ((into[to] = from[slot]), ...); }); });
+  }
+}
+
+// Layer-dependent generation appends to one staging arena across launches;
+// one count readback, scan and canonical placement follow all layers.
+template <template <template <class> class> class S, typename Generate>
+GPUg() void GTRK_KERNEL_BOUNDS generateLayerKernel(Generate generate, StagingState<S> staging, const std::uint32_t* boundaries, std::uint32_t layer, typename DeviceStageOutput<S>::Index* counts)
+{
+  using Index = typename DeviceStageOutput<S>::Index;
+  const Index begin = boundaries[layer];
+  const Index end = boundaries[layer + 1U];
+  const Index element = begin + (blockIdx.x * blockDim.x) + threadIdx.x;
+  if (element < end) {
+    generateOne(generate, staging, element, counts);
+  }
+}
+
+/// A generator run layer by layer: its `body` over the elements between each
+/// of `layerOrder`'s `layerBoundaries` (`Tracker::LayeredNeighbours`).
+template <typename Generate>
+concept LayeredGenerate = requires(const Generate& generate) {
+  generate.layerBoundaries;
+  generate.layerOrder;
+  generate.body;
+};
+
+} // namespace stage_detail
+
+/// The device backend's counterpart of CpuStage<S>: the same run and
+/// statuses, on one stream and one arena.
+template <template <template <class> class> class S>
+class GpuStage
+{
+ public:
+  using Output = DeviceStageOutput<S>;
+  using Index = typename Output::Index;
+  using Ordinal = typename Output::Ordinal;
+
+  GpuStage(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream) : mRuntime(&runtime), mArena(&arena), mStream(&stream) {}
+
+  /// The staging the next run starts with: the estimator's prediction.
+  void prepareStaging(std::size_t records) { mCapacity = records; }
+  [[nodiscard]] std::size_t stagingCapacity() const noexcept { return mCapacity; }
+  /// Whether the last run's staging overflowed and was retried at the exact size.
+  [[nodiscard]] bool stagingPredictionMissed() const noexcept { return mMissed; }
+
+  /// Run \a generate(element, emitter) for every element of \a output and place
+  /// the result canonically.
+  template <typename Generate>
+  StageStatus run(Output& output, const Generate& generate)
+  {
+    return runOver<false>(output, generate, nullptr, 0U);
+  }
+
+  /// `run` with only the \a listedCount elements \a listed names generated,
+  /// every other element's count 0: the
+  /// same records, placed the same, where the others emit nothing. \a listed
+  /// is device memory that outlives the call.
+  template <typename Generate>
+  StageStatus run(Output& output, const Generate& generate, const Index* listed, Index listedCount)
+  {
+    return runOver<true>(output, generate, listed, listedCount);
+  }
+
+ private:
+  /// `run` over every element, or over the \a Listed ones: chosen at compile
+  /// time, so that a stage never run over a list has no listed kernel and one
+  /// run over a list no unlisted one.
+  template <bool Listed, typename Generate>
+  StageStatus runOver(Output& output, const Generate& generate, const Index* listed, Index listedCount)
+  {
+    mMissed = false;
+    mStaged = 0U;
+    const Index elements = output.elementCount();
+    if (elements >= static_cast<Index>(std::numeric_limits<int>::max())) {
+      return StageStatus::kIndexOverflow; // the scan's item count is an int on CUB and hipCUB
+    }
+    if (elements == 0U) {
+      if (!output.allocateOutput(*mArena, 0U)) {
+        return StageStatus::kOutOfMemory;
+      }
+      mRuntime->fill(output.offsets().data(), 0U, sizeof(Index), *mStream);
+      output.setSize(0U);
+      return StageStatus::kComplete;
+    }
+    for (int attempt = 0; attempt < 2; ++attempt) {
+      const StageStatus status = attemptRun<Listed>(output, generate, listed, listedCount);
+      if (status != StageStatus::kStagingOverflow) {
+        return status;
+      }
+      // Rung 2 of the overflow ladder: grow once to the exact size and keep it.
+      mMissed = true;
+      mCapacity = static_cast<std::size_t>(mStaged);
+    }
+    return StageStatus::kStagingOverflow;
+  }
+
+  /// One generate, and on success the scan and the placement. Staging and scan
+  /// storage are on the scratch end and released on return; the work already
+  /// queued on the stream keeps using them, and the next allocation there is
+  /// only used by work queued after it on the same stream.
+  template <bool Listed, typename Generate>
+  StageStatus attemptRun(Output& output, const Generate& generate, const Index* listed, Index listedCount)
+  {
+    const Index elements = output.elementCount();
+    auto scratch = mArena->scope(ArenaEnd::kScratch);
+    DeviceSpan<stage_detail::StageWords> words;
+    DeviceColumns<S> staged;
+    DeviceSpan<Index> element;
+    DeviceSpan<Ordinal> ordinal;
+    if (!words.allocate(*mArena, 1U, ArenaEnd::kScratch) || !staged.allocate(*mArena, mCapacity, ArenaEnd::kScratch) || !element.allocate(*mArena, mCapacity, ArenaEnd::kScratch) || !ordinal.allocate(*mArena, mCapacity, ArenaEnd::kScratch)) {
+      return StageStatus::kOutOfMemory;
+    }
+    auto* counts = output.counts().data();
+    stage_detail::StageWords* const device = words.data();
+    mRuntime->fill(device, 0U, sizeof(stage_detail::StageWords), *mStream);
+    // The count after the last element, 0: the scan's last offset is the total.
+    if constexpr (!Listed) {
+      mRuntime->fill(counts + elements, 0U, sizeof(Index), *mStream);
+    }
+
+    const stage_detail::StagingState<S> state{
+      .records = staged.view(),
+      .element = element.data(),
+      .ordinal = ordinal.data(),
+      .counter = &device->counter,
+      .ordinalOverflow = &device->ordinalOverflow,
+      .capacity = static_cast<Counter>(mCapacity),
+    };
+    const NativeStream stream = nativeStream(*mRuntime, *mStream);
+    constexpr bool kLayered = stage_detail::LayeredGenerate<Generate>;
+    if constexpr (Listed) {
+      static_assert(!kLayered, "a layered generate runs over every element");
+      mRuntime->fill(counts, 0U, (std::size_t{elements} + 1U) * sizeof(Index), *mStream);
+      if (listedCount != 0U) {
+        const auto generateShape = launchFor(listedCount);
+        stage_detail::generateListedKernel<S><<<generateShape.blocks, generateShape.threads, 0U, stream>>>(generate, state, listed, listedCount, counts);
+        checkLaunch();
+      }
+    } else if constexpr (kLayered) {
+      // One thread per possible element (launchFor): capped grids make lanes
+      // process later elements alone after divergence.
+      const auto generateShape = launchFor(elements);
+      for (const auto layer : generate.layerOrder) {
+        stage_detail::generateLayerKernel<S><<<generateShape.blocks, generateShape.threads, 0U, stream>>>(generate.body, state, generate.layerBoundaries, static_cast<Index>(layer), counts);
+        checkLaunch();
+      }
+    } else {
+      const auto generateShape = launchFor(elements);
+      stage_detail::generateKernel<S><<<generateShape.blocks, generateShape.threads, 0U, stream>>>(generate, state, elements, counts);
+      checkLaunch();
+    }
+
+    // The one read-back of a stage: the counter is the total, since every
+    // emission counted in both its element and here.
+    stage_detail::StageWords host{};
+    download(words, &host, 1U, *mStream);
+    mStream->synchronize();
+    const Counter emitted = host.counter;
+    const std::uint32_t overflowed = host.ordinalOverflow;
+    mStaged = emitted;
+
+    // Failures in the serial reference's order.
+    if (overflowed != 0U) {
+      return StageStatus::kOrdinalOverflow;
+    }
+    if (emitted > std::numeric_limits<Index>::max()) {
+      return StageStatus::kIndexOverflow;
+    }
+    if (emitted > mCapacity) {
+      return StageStatus::kStagingOverflow;
+    }
+    // The scan before the output: a refusal of either leaves the base end as
+    // the run found it, counts and offsets only. run() keeps elements below
+    // INT_MAX, the scan's item count.
+    const auto total = static_cast<Index>(emitted);
+    const StageStatus scanned = algorithms::exclusiveScan(*mRuntime, *mArena, *mStream, std::as_const(output.counts()).data(), output.offsets().data(), std::size_t{elements} + 1U);
+    if (scanned != StageStatus::kComplete || !output.allocateOutput(*mArena, total)) {
+      return StageStatus::kOutOfMemory;
+    }
+
+    if (total != 0U) {
+      const auto placeShape = launchFor(total);
+      stage_detail::placeKernel<S><<<placeShape.blocks, placeShape.threads, 0U, stream>>>(std::as_const(staged).view(), element.data(), ordinal.data(), output.offsets().data(), output.view(), total);
+      checkLaunch();
+    }
+    output.setSize(total);
+    return StageStatus::kComplete;
+  }
+
+  DeviceRuntime* mRuntime = nullptr;
+  DeviceArena* mArena = nullptr;
+  DeviceStream* mStream = nullptr;
+  std::size_t mCapacity = 1024U;
+  std::uint64_t mStaged = 0U;
+  bool mMissed = false;
+};
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+
+#endif // GTRK_TRACKING_GPU_GPUSTAGE_CUH_
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/LaneGroup.cuh b/Detectors/GenericTracking/tracking/GPU/cuda/LaneGroup.cuh
new file mode 100644
index 0000000000000..4c2d51d7a92d0
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/LaneGroup.cuh
@@ -0,0 +1,96 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file LaneGroup.cuh
+/// \brief Lanes of one warp that walk in step: the
+///        devices' group of Lanes.h's contract.
+
+#ifndef GTRK_TRACKING_GPU_LANEGROUP_CUH_
+#define GTRK_TRACKING_GPU_LANEGROUP_CUH_
+
+#include "Platform.cuh"
+
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+{
+
+/// `L` consecutive threads of a block, aligned to `L` inside one warp: lane
+/// `i` is the thread `i` places after the group's first. Its collectives
+/// (`SoloGroup`'s contract, Lanes.h) are the warp's cross-lane operations on
+/// the group's lanes alone, so the other groups of the warp may be anywhere
+/// else meanwhile: CUDA's `_sync` forms with the group's mask and width `L`,
+/// HIP's with width `L` and its ballot masked to the group. Every lane of the
+/// group must reach each call.
+template <std::uint32_t L>
+struct WarpGroup {
+  static_assert(L >= 2U && (L & (L - 1U)) == 0U && static_cast<std::uint32_t>(kWarpSize) % L == 0U, "a group is a power-of-two share of one warp");
+  static constexpr std::uint32_t kLanes = L;
+
+  [[nodiscard]] GPUdii() std::uint32_t lane() const { return threadIdx.x % L; }
+
+  /// Bit `i` for lane `i` of the group where \a set holds.
+  [[nodiscard]] GPUdii() std::uint64_t ballot(bool set) const
+  {
+#ifdef __HIPCC__
+    const std::uint64_t all = __ballot(set);
+    if constexpr (L == 64U) {
+      return all;
+    } else {
+      return (all >> first()) & ((std::uint64_t{1} << L) - 1U);
+    }
+#else
+    return (__ballot_sync(mask(), set) & mask()) >> first();
+#endif
+  }
+
+  /// Lane \a from's \a value on every lane of the group, word by word.
+  template <typename T>
+  [[nodiscard]] GPUdii() T broadcast(const T& value, std::uint32_t from) const
+  {
+    static_assert(std::is_trivially_copyable_v<T> && sizeof(T) % sizeof(std::uint32_t) == 0U, "a broadcast value is whole 32-bit words");
+    constexpr std::size_t kWords = sizeof(T) / sizeof(std::uint32_t);
+    std::uint32_t words[kWords];
+    __builtin_memcpy(words, &value, sizeof(T));
+    for (std::size_t i = 0; i < kWords; ++i) {
+#ifdef __HIPCC__
+      words[i] = __shfl(words[i], static_cast<int>(from), static_cast<int>(L));
+#else
+      words[i] = __shfl_sync(mask(), words[i], static_cast<int>(from), static_cast<int>(L));
+#endif
+    }
+    T out;
+    __builtin_memcpy(&out, words, sizeof(T));
+    return out;
+  }
+
+ private:
+  /// The group's first lane in its warp.
+  [[nodiscard]] GPUdii() std::uint32_t first() const { return (threadIdx.x % static_cast<std::uint32_t>(kWarpSize)) - lane(); }
+
+#ifndef __HIPCC__
+  /// The group's lanes in the warp's mask.
+  [[nodiscard]] GPUdii() std::uint32_t mask() const
+  {
+    if constexpr (L == 32U) {
+      return 0xFFFFFFFFU;
+    } else {
+      return ((1U << L) - 1U) << first();
+    }
+  }
+#endif
+};
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+
+#endif // GTRK_TRACKING_GPU_LANEGROUP_CUH_
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/PathGlue.cuh b/Detectors/GenericTracking/tracking/GPU/cuda/PathGlue.cuh
new file mode 100644
index 0000000000000..aec22bba0838b
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/PathGlue.cuh
@@ -0,0 +1,306 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file PathGlue.cuh
+/// \brief TrackletPaths and TripletPaths on a device: layer sweeps in stream
+///        order.
+
+#ifndef GTRK_TRACKING_GPU_PATHGLUE_CUH_
+#define GTRK_TRACKING_GPU_PATHGLUE_CUH_
+
+#include "DeviceAlgorithms.cuh"
+#include "GenericTracking/Tracking/GPU/DeviceStageOutput.h"
+#include "GenericTracking/Tracking/TrackletPaths.h"
+#include "GenericTracking/Tracking/Triplet.h"
+
+#include "GPUCommonAlgorithm.h"
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::glue
+{
+
+/// The path bounds of a slice on the device, in the caller's scope: per
+/// element its prefix and suffix, and each layer's first permuted element and
+/// first kept triplet.
+struct DevicePathBounds {
+  DeviceSpan<std::uint8_t> prefix;
+  DeviceSpan<std::uint8_t> suffix;
+  DeviceSpan<std::uint32_t> layerElements; ///< per layer, the first permuted element whose tracklet starts on it or after
+  DeviceSpan<std::uint32_t> layerTriplets; ///< canonical triplet ranges for ordered neighbour generation
+  [[nodiscard]] TrackletPathBounds view(std::uint32_t minClusters) const { return {prefix.data(), suffix.data(), minClusters}; }
+  [[nodiscard]] bool allocate(DeviceArena& arena, std::uint32_t count) { return prefix.allocate(arena, count) && suffix.allocate(arena, count); }
+};
+
+namespace path_detail
+{
+using Index = std::uint32_t;
+
+struct InitializePrefix {
+  Index* prefix;
+  GPUdi() void operator()(Index element) const { prefix[element] = 1U; }
+};
+
+struct PackPrefix {
+  const Index* prefix;
+  std::uint8_t* packed;
+  GPUdi() void operator()(Index element) const { packed[element] = static_cast<std::uint8_t>(prefix[element]); }
+};
+
+/// One step of TrackletPaths::build's forward (prefix) and reverse (suffix)
+/// sweeps together, which share no array: the first `forwardSize` threads the
+/// source elements of \a forward, the rest those of \a reverse.
+template <DetectorLayout Det>
+struct MeasurementPaths {
+  TrackletConstView tracklets;
+  const Index* offsets = nullptr;
+  LayerRowMap<Det> sources;
+  const IterationParameters<Det>* parameters = nullptr;
+  LayerID forward = 0;
+  Index forwardSize = 0U;
+  LayerID reverse = 0;
+  Index* prefix = nullptr;
+  std::uint8_t* suffix = nullptr;
+  GPUdi() void operator()(Index local) const
+  {
+    if (local < forwardSize) {
+      raiseTargetPrefixes(*parameters, sources, tracklets, offsets, sources.offsets[forward] + local, prefix);
+    } else {
+      const Index element = sources.offsets[reverse] + (local - forwardSize);
+      const TrackletPathBounds partial{.prefix = nullptr, .suffix = suffix, .minClusters = 0U};
+      suffix[element] = static_cast<std::uint8_t>(measurementPathSuffix(partial, *parameters, sources, tracklets, offsets, reverse, element));
+    }
+  }
+};
+
+template <DetectorLayout Det>
+struct InitializeTriplets {
+  TrackletConstView tracklets;
+  const IterationParameters<Det>* parameters;
+  Index* prefix; ///< the scratch's wide prefix, for the forward sweep's atomic maxima
+  std::uint8_t* suffix;
+  Index trackletCount;
+  const Index* trackletOffsets;
+  const Index* permutation;
+  Index firstCount;
+  std::array<Index, LayerRowMap<Det>::kLayerCount + 1U> sourceOffsets;
+  Index* firstRanges;
+  GPUdi() void operator()(Index edge) const
+  {
+    if (edge < sourceOffsets.size()) {
+      const Index first = trackletOffsets[sourceOffsets[edge]];
+      firstRanges[edge] = o2::gpu::CAAlgo::partitionPoint(Index{0U}, firstCount, [&](Index index) { return permutation[index] < first; });
+    }
+    if (edge >= trackletCount) {
+      return;
+    }
+    prefix[edge] = 2U;
+    suffix[edge] = parameters->roadEndLayers == 0U || ((parameters->roadEndLayers >> parameters->linkTargets[tracklets.link[edge]]) & 1U) != 0U ? 1U : 0U;
+  }
+};
+
+// Dynamic ranges are read on the device, without downloading layer counts.
+// One step of both sweeps, which share no array, over a layer's permuted
+// elements, one thread each: blockIdx.y 0 the forward sweep on \a forward,
+// each triplet raising its second tracklet's prefix (wide atomics; every
+// triplet ending on the element's tracklet starts on an earlier layer of the
+// order); 1 the reverse sweep on \a reverse, one writer per element (the end
+// index is not built yet). A template, as every kernel of a header.
+template <typename = void>
+GPUg() void GTRK_KERNEL_BOUNDS tripletPathsKernel(TripletConstView triplets, const Index* permutation, const Index* tripletOffsets, const Index* firstRanges, LayerID forward, LayerID reverse, Index* prefix, std::uint8_t* suffix)
+{
+  const bool isForward = blockIdx.y == 0U;
+  const LayerID layer = isForward ? forward : reverse;
+  const Index begin = firstRanges[layer];
+  const Index end = firstRanges[static_cast<std::size_t>(layer) + 1U];
+  const Index stride = blockDim.x * gridDim.x;
+  for (Index local = blockIdx.x * blockDim.x + threadIdx.x; local < end - begin; local += stride) {
+    const Index element = begin + local;
+    const Index first = permutation[element];
+    if (isForward) {
+      const Index length = prefix[first] + 1U;
+      for (Index edge = tripletOffsets[element]; edge < tripletOffsets[element + 1U]; ++edge) {
+        atomicMax(prefix + triplets.second[edge], length);
+      }
+    } else {
+      unsigned int length = suffix[first];
+      for (Index edge = tripletOffsets[element]; edge < tripletOffsets[element + 1U]; ++edge) {
+        const unsigned int after = suffix[triplets.second[edge]];
+        if (after != 0U && length < after + 1U) {
+          length = after + 1U;
+        }
+      }
+      suffix[first] = static_cast<std::uint8_t>(length);
+    }
+  }
+}
+
+/// The triplets of each permuted element on a triplet path
+/// (`TripletPaths::onPath`).
+struct CountOnPath {
+  TripletConstView triplets;
+  const Index* offsets;
+  TrackletPathBounds paths;
+  Index elements;
+  Index* counts;
+  GPUdi() void operator()(Index element) const
+  {
+    Index kept = 0U;
+    if (element < elements) {
+      for (Index edge = offsets[element]; edge < offsets[element + 1U]; ++edge) {
+        kept += paths.onPath(triplets.first[edge], triplets.second[edge]) ? 1U : 0U;
+      }
+    }
+    counts[element] = kept;
+  }
+};
+
+struct OnPath {
+  TripletConstView triplets;
+  TrackletPathBounds paths;
+  GPUdi() bool operator()(Index edge) const { return paths.onPath(triplets.first[edge], triplets.second[edge]); }
+};
+
+/// to[i] = from[indices[i]], every triplet column.
+struct GatherTriplets {
+  TripletConstView from;
+  const Index* indices;
+  DeviceColumns<TripletT>::View to;
+  GPUdi() void operator()(Index i) const
+  {
+    const Index edge = indices[i];
+    to.first[i] = from.first[edge];
+    to.second[i] = from.second[edge];
+    to.curvature[i] = from.curvature[edge];
+    to.varCurvature[i] = from.varCurvature[edge];
+    to.level[i] = from.level[edge];
+    to.kinked[i] = from.kinked[edge];
+  }
+};
+
+struct LayerTriplets {
+  const Index* layerElements;
+  const Index* offsets;
+  Index* layerTriplets;
+  GPUdi() void operator()(Index layer) const { layerTriplets[layer] = offsets[layerElements[layer]]; }
+};
+} // namespace path_detail
+
+/// TrackletPaths::build on the device: per source element of the slice,
+/// stream-ordered layer sweeps, no host synchronisation or transfer between
+/// layers. The prefix's maxima are 32-bit atomics on the scratch end, packed
+/// to bytes at the end.
+template <DetectorLayout Det>
+[[nodiscard]] StageStatus trackletPaths(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, const IterationParameters<Det>* parameters, const LayerRowMap<Det>& sources, TrackletConstView tracklets, const std::uint32_t* offsets, DevicePathBounds& bounds)
+{
+  static_assert(maxChainLayers<Det> <= 255U);
+  const auto count = sources.size();
+  if (!bounds.allocate(arena, count)) {
+    return StageStatus::kOutOfMemory;
+  }
+  if (count == 0U) {
+    return StageStatus::kComplete;
+  }
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  DeviceSpan<std::uint32_t> prefix;
+  if (!prefix.allocate(arena, count, ArenaEnd::kScratch)) {
+    return StageStatus::kOutOfMemory;
+  }
+  algorithms::forEach(runtime, stream, count, path_detail::InitializePrefix{prefix.data()});
+  // Step i of the forward sweep (order[i]) and of the reverse sweep
+  // (order[n - 1 - i]) in one launch; each sees its own earlier steps done.
+  const auto& order = layerDepthGroups<Det>.order;
+  for (std::size_t step = 0; step < order.size(); ++step) {
+    const LayerID forward = order[step];
+    const LayerID reverse = order[order.size() - 1U - step];
+    const auto forwardSize = static_cast<std::uint32_t>(sources.ranges[forward].size());
+    const auto size = forwardSize + static_cast<std::uint32_t>(sources.ranges[reverse].size());
+    algorithms::forEach(runtime, stream, size, path_detail::MeasurementPaths<Det>{tracklets, offsets, sources, parameters, forward, forwardSize, reverse, prefix.data(), bounds.suffix.data()});
+  }
+  algorithms::forEach(runtime, stream, count, path_detail::PackPrefix{prefix.data(), bounds.prefix.data()});
+  return StageStatus::kComplete;
+}
+
+/// TripletPaths::build on the device, from the triplets alone, before their
+/// end index: per tracklet its prefix and suffix, and each layer's range of
+/// \a permutation (the triplet stage's first tracklets, in tracklet order) in
+/// `layerElements`.
+template <DetectorLayout Det>
+[[nodiscard]] StageStatus tripletPaths(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, const IterationParameters<Det>* parameters, const LayerRowMap<Det>& sources, TrackletConstView tracklets, std::uint32_t trackletCount, const std::uint32_t* trackletOffsets, TripletConstView triplets, const std::uint32_t* tripletOffsets, const std::uint32_t* permutation, std::uint32_t firstCount, DevicePathBounds& bounds)
+{
+  static_assert(maxChainLayers<Det> <= 255U);
+  constexpr auto kBoundaries = static_cast<std::uint32_t>(LayerRowMap<Det>::kLayerCount + 1U);
+  if (!bounds.allocate(arena, trackletCount) || !bounds.layerElements.allocate(arena, kBoundaries) || !bounds.layerTriplets.allocate(arena, kBoundaries)) {
+    return StageStatus::kOutOfMemory;
+  }
+  if (trackletCount == 0U) {
+    return StageStatus::kComplete;
+  }
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  DeviceSpan<std::uint32_t> prefix;
+  if (!prefix.allocate(arena, trackletCount, ArenaEnd::kScratch)) {
+    return StageStatus::kOutOfMemory;
+  }
+  // Each layer's range of the permutation, worked out in the initialisation's
+  // launch, once per boundary.
+  algorithms::forEach(runtime, stream, std::max(trackletCount, kBoundaries), path_detail::InitializeTriplets<Det>{tracklets, parameters, prefix.data(), bounds.suffix.data(), trackletCount, trackletOffsets, permutation, firstCount, sources.offsets, bounds.layerElements.data()});
+  // Grid-stride loops cover skewed layer populations without a count readback.
+  const auto shape = launchFor(std::max(1U, firstCount / static_cast<std::uint32_t>(LayerRowMap<Det>::kLayerCount)));
+  // Step i of the forward sweep (order[i]) and of the reverse sweep
+  // (order[n - 1 - i]) in one launch, a direction per grid row; a layer
+  // without sources has an empty range of the permutation.
+  const auto empty = [&](LayerID layer) { return sources.offsets[layer] == sources.offsets[static_cast<std::size_t>(layer) + 1U]; };
+  const auto& order = layerDepthGroups<Det>.order;
+  for (std::size_t step = 0; step < order.size(); ++step) {
+    const LayerID forward = order[step];
+    const LayerID reverse = order[order.size() - 1U - step];
+    if (empty(forward) && empty(reverse)) {
+      continue;
+    }
+    path_detail::tripletPathsKernel<><<<dim3{shape.blocks, 2U}, shape.threads, 0U, nativeStream(runtime, stream)>>>(triplets, permutation, tripletOffsets, bounds.layerElements.data(), forward, reverse, prefix.data(), bounds.suffix.data());
+    checkLaunch();
+  }
+  algorithms::forEach(runtime, stream, trackletCount, path_detail::PackPrefix{prefix.data(), bounds.prefix.data()});
+  return StageStatus::kComplete;
+}
+
+/// \a triplets kept where they are on a triplet path of \a paths, in arena
+/// order, into \a kept with their elements' counts and offsets, and the
+/// bounds' layer ranges of triplets moved to them: the host's filter before
+/// the place (`Tracker::OnPathTriplets`). One readback, the kept count.
+[[nodiscard]] inline StageStatus onPathTriplets(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, TrackletPathBounds paths, const DeviceStageOutput<TripletT>& triplets, DeviceStageOutput<TripletT>& kept, DevicePathBounds& bounds)
+{
+  const auto elements = triplets.elementCount();
+  if (!kept.prepare(arena, elements)) {
+    return StageStatus::kOutOfMemory;
+  }
+  const TripletConstView view = triplets.view();
+  algorithms::forEach(runtime, stream, elements + 1U, path_detail::CountOnPath{view, triplets.offsets().data(), paths, elements, kept.counts().data()});
+  auto status = algorithms::exclusiveScan(runtime, arena, stream, std::as_const(kept.counts()).data(), kept.offsets().data(), std::size_t{elements} + 1U);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  DeviceSpan<std::uint32_t> indices;
+  std::uint32_t total = 0U;
+  status = algorithms::selectIndices(runtime, arena, stream, triplets.size(), path_detail::OnPath{view, paths}, indices, total, ArenaEnd::kScratch);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  if (!kept.allocateOutput(arena, total)) {
+    return StageStatus::kOutOfMemory;
+  }
+  algorithms::forEach(runtime, stream, total, path_detail::GatherTriplets{view, indices.data(), kept.view()});
+  kept.setSize(total);
+  algorithms::forEach(runtime, stream, static_cast<std::uint32_t>(bounds.layerElements.size()), path_detail::LayerTriplets{bounds.layerElements.data(), kept.offsets().data(), bounds.layerTriplets.data()});
+  return StageStatus::kComplete;
+}
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::glue
+
+#endif // GTRK_TRACKING_GPU_PATHGLUE_CUH_
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/Platform.cuh b/Detectors/GenericTracking/tracking/GPU/cuda/Platform.cuh
new file mode 100644
index 0000000000000..456650aaaa76b
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/Platform.cuh
@@ -0,0 +1,147 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Platform.cuh
+/// \brief The few spellings that differ between CUDA and HIP, and the wave
+///        width and launch shape, for device headers included by the
+///        backends' .cu sources.
+///
+/// hipify-perl translates the .cu files it is given, not the headers they
+/// include, so a header with vendor code writes
+/// both branches, as ITS's Utils.h does.
+/// Triple-chevron launches and the atomic intrinsics are spelled the same on
+/// both and need nothing here.
+
+#ifndef GTRK_TRACKING_GPU_PLATFORM_CUH_
+#define GTRK_TRACKING_GPU_PLATFORM_CUH_
+
+#ifdef __HIPCC__
+#include <hip/hip_runtime.h>
+#include <hipcub/hipcub.hpp>
+#else
+#include <cuda_runtime.h>
+#include <cub/cub.cuh>
+#endif
+
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+
+#include "GPUCommonHelpers.h"
+#include "GPUDefParametersWrapper.h"
+
+#include <cstddef>
+#include <cstdint>
+
+namespace o2::gtrk::gpu
+{
+
+inline constexpr int kWarpSize = GPUCA_WARP_SIZE;
+static_assert(kWarpSize > 0, "no GPUCA_GPUTYPE_* with a warp size");
+
+/// Every kernel launches blocks of this size (launchFor); on HIP it is also
+/// their launch bounds (GTRK_KERNEL_BOUNDS). Two warps of 32, one wavefront of
+/// 64: a block of the divergent generate kernels and fits leaves its
+/// multiprocessor when its own warps are done, not with the slowest of a larger
+/// block.
+inline constexpr int kBlockSize = 64;
+static_assert(kBlockSize % kWarpSize == 0);
+
+/// The lanes that walk one source together in a flat run's fill
+/// (`FlatTracklets`, FlatStage.cuh), per architecture: more lanes spread a
+/// source's rows and write its candidates side by side, and each repeats the
+/// source's preparation, so the best count depends on the architecture's
+/// memory and its per-thread scratch. An architecture without its own value
+/// takes its backend's. A power of two up to the warp size; 1 is one thread
+/// a source.
+#if defined(GPUCA_GPUTYPE_BLACKWELL)
+inline constexpr std::uint32_t kFillLanes = 4U;
+#elif defined(GPUCA_GPUTYPE_VEGA)
+inline constexpr std::uint32_t kFillLanes = 1U;
+#elif defined(__HIPCC__)
+inline constexpr std::uint32_t kFillLanes = 1U;
+#else
+inline constexpr std::uint32_t kFillLanes = 4U;
+#endif
+
+struct LaunchShape {
+  std::uint32_t blocks = 0;
+  std::uint32_t threads = static_cast<std::uint32_t>(kBlockSize);
+};
+
+/// One thread per element: a capped grid would make a thread loop over
+/// several elements, and a warp's lanes drift apart on the divergent bodies
+/// (the triplet path sweep's grid is smaller on purpose, PathGlue.cuh).
+[[nodiscard]] constexpr LaunchShape launchFor(std::uint32_t elements)
+{
+  constexpr auto threads = static_cast<std::uint32_t>(kBlockSize);
+  return {.blocks = (elements / threads) + static_cast<std::uint32_t>(elements % threads != 0U), .threads = threads};
+}
+
+#if defined(__CUDA_ARCH__)
+static_assert(kWarpSize == 32);
+#elif defined(__HIP_DEVICE_COMPILE__)
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-pragma"
+#endif
+#if defined(__AMDGCN_WAVEFRONT_SIZE)
+static_assert(__AMDGCN_WAVEFRONT_SIZE == kWarpSize);
+#endif
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+#endif
+
+} // namespace o2::gtrk::gpu
+
+// A kernel's launch bounds: on HIP the block size every launch uses
+// (launchFor). Without it hipcc compiles a kernel for 1024 threads, 64 VGPRs
+// on gfx906, and with ROCm 7.1.1 the refit's spills come back wrong. Not on
+// CUDA, where the same bound makes nvcc's register allocation slower.
+#ifdef __HIPCC__
+#define GTRK_KERNEL_BOUNDS __launch_bounds__(o2::gtrk::gpu::kBlockSize)
+#else
+#define GTRK_KERNEL_BOUNDS
+#endif
+
+#ifndef GTRK_BACKEND_NAMESPACE
+#error "GTRK_BACKEND_NAMESPACE must name this backend's private namespace"
+#endif
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+{
+
+#ifdef __HIPCC__
+namespace cubapi = ::hipcub;
+using NativeStream = hipStream_t;
+#else
+namespace cubapi = ::cub;
+using NativeStream = cudaStream_t;
+#endif
+
+/// The native stream behind \a stream, made current on its runtime's device.
+inline NativeStream nativeStream(DeviceRuntime& runtime, DeviceStream& stream) { return static_cast<NativeStream>(runtime.nativeStream(stream)); }
+
+/// What the 64-bit atomics take on both vendors.
+using Counter = unsigned long long;
+
+/// A failed launch is a runtime error, not a rung of the overflow ladder.
+inline void checkLaunch()
+{
+#ifdef __HIPCC__
+  GPUChkErrS(hipGetLastError());
+#else
+  GPUChkErrS(cudaGetLastError());
+#endif
+}
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+
+#endif // GTRK_TRACKING_GPU_PLATFORM_CUH_
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/RoadGlue.cuh b/Detectors/GenericTracking/tracking/GPU/cuda/RoadGlue.cuh
new file mode 100644
index 0000000000000..72687429a5408
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/RoadGlue.cuh
@@ -0,0 +1,207 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file RoadGlue.cuh
+/// \brief A slice's road counts, starts and numbering on a device.
+///
+/// RoadCount's passes, with its functors as they are:
+///
+///   OrderedCounts  the counts and successor flags the ordered neighbour
+///                  generation finalises (OrderedRoadCounts), their flags'
+///                  fill and the overflow and chained-count read-back: the
+///                  tracker's path
+///   roadStarts     the triplets RoadStartRule admits, in order
+///   roadOffsets    each start's first road, a 64-bit scan whose total past
+///                  32 bits is kIndexOverflow, narrowed for RoadWalk
+///
+/// The shared machinery is DeviceAlgorithms.cuh's; what is here is the
+/// road-specific predicate, the widening and the narrowing. Outputs go to the
+/// base end in the caller's scope. Included by the .cu that instantiates a
+/// tracker, in the backend's namespace.
+
+#ifndef GTRK_TRACKING_GPU_ROADGLUE_CUH_
+#define GTRK_TRACKING_GPU_ROADGLUE_CUH_
+
+#include "DeviceAlgorithms.cuh"
+#include "Platform.cuh"
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/MeasurementRange.h"
+#include "GenericTracking/Tracking/RoadCount.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/Triplet.h"
+
+#include "GPUCommonAlgorithm.h"
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::road_glue
+{
+
+using Index = std::uint32_t;
+
+namespace detail
+{
+namespace
+{
+
+/// RoadStartRule over device arrays.
+struct IsStart {
+  TrackletConstView tracklets;
+  TripletConstView triplets;
+  const std::uint32_t* successorAbove = nullptr;
+  const std::uint32_t* roads = nullptr;
+  RoadStartRule rule;
+  GPUdi() bool operator()(Index triplet) const { return rule(tracklets, triplets, successorAbove, roads, triplet); }
+};
+
+/// Each start's road count in 64 bits, and a zero after the last, so the
+/// scan's last entry is the total.
+struct WidenStartCounts {
+  const Index* starts = nullptr;
+  Index startCount = 0U;
+  const std::uint32_t* roads = nullptr;
+  std::uint64_t* counts = nullptr;
+  GPUdi() void operator()(Index start) const { counts[start] = start < startCount ? std::uint64_t{roads[starts[start]]} : std::uint64_t{0U}; }
+};
+
+struct NarrowOffsets {
+  const std::uint64_t* wide = nullptr;
+  Index* offsets = nullptr;
+  GPUdi() void operator()(Index at) const { offsets[at] = static_cast<Index>(wide[at]); }
+};
+
+/// The chained count -- the triplets above level 1, those with predecessors --
+/// without their indices: one sum per block, one atomic add each.
+GPUg() void GTRK_KERNEL_BOUNDS summarizeLevelsKernel(const std::uint32_t* levels, Index count, std::uint32_t* chainedCount)
+{
+  const auto element = blockIdx.x * blockDim.x + threadIdx.x;
+  const std::uint32_t sum = work_group_count(element < count && levels[element] > 1U);
+  if (threadIdx.x == 0U) {
+    atomicAdd(chainedCount, sum);
+  }
+}
+
+} // namespace
+} // namespace detail
+
+/// The address of \a parameters' link-to-source-layer table, from a device
+/// pointer to them, without reading device memory on the host.
+template <DetectorLayout Det>
+[[nodiscard]] const LayerID* linkSourcesOf(const IterationParameters<Det>* parameters)
+{
+  static_assert(std::is_standard_layout_v<IterationParameters<Det>>, "offsetof needs a standard-layout type");
+  return reinterpret_cast<const LayerID*>(reinterpret_cast<const std::byte*>(parameters) + offsetof(IterationParameters<Det>, linkSources));
+}
+
+/// The address of \a parameters' link-to-target-layer table, from a device
+/// pointer to them, without reading device memory on the host.
+template <DetectorLayout Det>
+[[nodiscard]] const LayerID* linkTargetsOf(const IterationParameters<Det>* parameters)
+{
+  static_assert(std::is_standard_layout_v<IterationParameters<Det>>, "offsetof needs a standard-layout type");
+  return reinterpret_cast<const LayerID*>(reinterpret_cast<const std::byte*>(parameters) + offsetof(IterationParameters<Det>, linkTargets));
+}
+
+/// The start rule of the iteration \a parameters point to on the device,
+/// \a host the same parameters on the host: its link targets read in place.
+template <DetectorLayout Det>
+[[nodiscard]] RoadStartRule roadStartRuleOf(const IterationParameters<Det>* parameters, const IterationParameters<Det>& host)
+{
+  RoadStartRule rule = roadStartRule(host);
+  rule.linkTargets = linkTargetsOf(parameters);
+  return rule;
+}
+
+/// The road counts and successor flags the ordered neighbour generation
+/// finalises (OrderedRoadCounts.h): only the flags and the two status words
+/// are zeroed first; every element writes its count.
+struct OrderedCounts {
+  DeviceSpan<std::uint32_t> successorAbove;
+  DeviceSpan<std::uint32_t> roads;
+  DeviceSpan<std::uint32_t> overflow;
+
+  [[nodiscard]] StageStatus prepare(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, Index count)
+  {
+    if (!successorAbove.allocate(arena, count) || !roads.allocate(arena, count) || !overflow.allocate(arena, 2U)) {
+      return StageStatus::kOutOfMemory;
+    }
+    runtime.fill(successorAbove.data(), 0U, std::size_t{count} * sizeof(std::uint32_t), stream);
+    runtime.fill(overflow.data(), 0U, 2U * sizeof(std::uint32_t), stream);
+    return StageStatus::kComplete;
+  }
+
+  [[nodiscard]] OrderedRoadCounts view(const LayerID* linkSources, const MeasurementRange* core) { return {.roads = roads.data(), .successorAbove = successorAbove.data(), .overflow = overflow.data(), .linkSources = linkSources, .core = core}; }
+
+  /// After the neighbour generation, its staging retries included, on its
+  /// stream: the chained count and the sticky overflow flag in one read-back.
+  [[nodiscard]] StageStatus summarize(DeviceRuntime& runtime, DeviceStream& stream, TripletConstView triplets, Index count, Index& chainedCount)
+  {
+    chainedCount = 0U;
+    if (count == 0U) {
+      return StageStatus::kComplete;
+    }
+    const auto shape = launchFor(count);
+    detail::summarizeLevelsKernel<<<shape.blocks, shape.threads, 0U, nativeStream(runtime, stream)>>>(triplets.level, count, overflow.data() + 1U);
+    checkLaunch();
+    std::array<std::uint32_t, 2U> flags{};
+    runtime.copyToHost(flags.data(), overflow.data(), sizeof(flags), stream);
+    stream.synchronize();
+    chainedCount = flags[1];
+    return flags[0] != 0U ? StageStatus::kIndexOverflow : StageStatus::kComplete;
+  }
+};
+
+/// The triplets roads start at, in arena order; \a startCount read back.
+[[nodiscard]] inline StageStatus roadStarts(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, TrackletConstView tracklets, TripletConstView triplets, Index tripletCount, const std::uint32_t* successorAbove, const std::uint32_t* roads, const RoadStartRule& rule, DeviceSpan<Index>& starts, Index& startCount) { return algorithms::selectIndices(runtime, arena, stream, tripletCount, detail::IsStart{.tracklets = tracklets, .triplets = triplets, .successorAbove = successorAbove, .roads = roads, .rule = rule}, starts, startCount); }
+
+/// Per start, the index of its first road, and the total after the last
+/// (`startCount + 1` offsets); \a total read back. A total past 32 bits is
+/// kIndexOverflow, as on the host.
+[[nodiscard]] inline StageStatus roadOffsets(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, const Index* starts, Index startCount, const std::uint32_t* roads, DeviceSpan<Index>& offsets, Index& total)
+{
+  total = 0U;
+  const std::size_t items = std::size_t{startCount} + 1U;
+  if (!offsets.allocate(arena, items)) {
+    return StageStatus::kOutOfMemory;
+  }
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  DeviceSpan<std::uint64_t> counts;
+  DeviceSpan<std::uint64_t> wide;
+  if (!counts.allocate(arena, items, ArenaEnd::kScratch) || !wide.allocate(arena, items, ArenaEnd::kScratch)) {
+    return StageStatus::kOutOfMemory;
+  }
+  algorithms::forEach(runtime, stream, static_cast<Index>(items), detail::WidenStartCounts{.starts = starts, .startCount = startCount, .roads = roads, .counts = counts.data()});
+  const StageStatus scanned = algorithms::exclusiveScan(runtime, arena, stream, std::as_const(counts).data(), wide.data(), items);
+  if (scanned != StageStatus::kComplete) {
+    return scanned;
+  }
+  std::uint64_t wideTotal = 0U;
+  runtime.copyToHost(&wideTotal, wide.data() + startCount, sizeof(std::uint64_t), stream);
+  stream.synchronize();
+  if (wideTotal > std::numeric_limits<Index>::max()) {
+    return StageStatus::kIndexOverflow;
+  }
+  algorithms::forEach(runtime, stream, static_cast<Index>(items), detail::NarrowOffsets{.wide = std::as_const(wide).data(), .offsets = offsets.data()});
+  total = static_cast<Index>(wideTotal);
+  return StageStatus::kComplete;
+}
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::road_glue
+
+#endif // GTRK_TRACKING_GPU_ROADGLUE_CUH_
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/SelectionGlue.cuh b/Detectors/GenericTracking/tracking/GPU/cuda/SelectionGlue.cuh
new file mode 100644
index 0000000000000..c072b9f75afae
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/SelectionGlue.cuh
@@ -0,0 +1,379 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file SelectionGlue.cuh
+/// \brief An iteration's global selection on a device: GlobalSelection::select
+///        over device storage.
+///
+/// Only storage, sorts, scans, key packing and orchestration are here; the
+/// selection's logic is Selection.h's -- sortedKey, compareKeys, sameRecord,
+/// BidReset, Bid, Decide, Prune -- called as it is:
+///
+///   keys        each record's sorted cluster set, word-major, kNoCluster
+///               remapped to the row count so a word fits bit_width(rows)
+///   dedup order K stable radix passes from the last word to the first,
+///               starting from the identity: (key, record index) order
+///   runs        heads where the key changes; each position's head by an
+///               inclusive max-scan; duplicates and mismatches counted
+///   quality     one stable radix pass on `selection::qualityKey` over the
+///               unique records, in key order: ranked()
+///   rounds      Prune, then BidReset, Bid, Decide, Prune while any record
+///               is live, one flag read per pass
+///   selected    the accepted ranks, as record indices, best first
+///
+/// Outputs go to the base end in the caller's scope, temporaries to the
+/// scratch end. Included by the .cu that instantiates a tracker, and by the
+/// test kernels, in the backend's namespace.
+
+#ifndef GTRK_TRACKING_GPU_SELECTIONGLUE_CUH_
+#define GTRK_TRACKING_GPU_SELECTIONGLUE_CUH_
+
+#include "DeviceAlgorithms.cuh"
+#include "Platform.cuh"
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Tracking/Selection.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <utility>
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::selection_glue
+{
+
+using Index = std::uint32_t;
+
+/// What the selection read back and where it left its result.
+struct Selected {
+  DeviceSpan<Index> ranked;   ///< the unique records, best first, as record indices
+  DeviceSpan<Index> selected; ///< the accepted records, best first, as record indices
+  Index unique = 0U;
+  Index duplicates = 0U;
+  Index mismatches = 0U;
+  Index rounds = 0U;
+  Index tracks = 0U; ///< entries of `selected`
+  std::uint32_t readbacks = 0U;
+  DeviceSpan<Index> slots; ///< the rounds' `slotAll`, one per row, for the extension's bids to reuse
+};
+
+// Unnamed, so that two sources of one library may include this header.
+namespace detail
+{
+namespace
+{
+
+/// Word j of record r's sorted cluster set at keys[j * records + r].
+template <std::size_t K>
+struct WriteKeys {
+  const ClusterList<K>* clusters = nullptr;
+  const std::uint8_t* count = nullptr;
+  Index records = 0U;
+  Index noCluster = 0U; ///< the row count: above every row
+  Index* keys = nullptr;
+
+  GPUdi() void operator()(Index record) const
+  {
+    const auto key = selection::sortedKey(clusters[record], count[record]);
+    for (std::size_t word = 0; word < K; ++word) {
+      const Index value = key.index[word];
+      keys[(word * records) + record] = value == ClusterList<K>::kNoCluster ? noCluster : value;
+    }
+  }
+};
+
+struct Iota {
+  Index* out = nullptr;
+  GPUdi() void operator()(Index i) const { out[i] = i; }
+};
+
+/// A run's head where the key differs from the previous position's; the
+/// position itself there, 0 elsewhere, for the max-scan.
+template <std::size_t K>
+struct MarkHeads {
+  const Index* keys = nullptr; ///< word-major
+  const Index* permutation = nullptr;
+  Index records = 0U;
+  std::uint8_t* head = nullptr;
+  Index* headPosition = nullptr;
+
+  GPUdi() void operator()(Index position) const
+  {
+    bool differs = position == 0U;
+    if (!differs) {
+      const Index record = permutation[position];
+      const Index previous = permutation[position - 1U];
+      for (std::size_t word = 0; word < K && !differs; ++word) {
+        differs = keys[(word * records) + record] != keys[(word * records) + previous];
+      }
+    }
+    head[position] = differs ? 1U : 0U;
+    headPosition[position] = differs ? position : 0U;
+  }
+};
+
+struct MaxOf {
+  GPUdi() Index operator()(Index lhs, Index rhs) const { return lhs < rhs ? rhs : lhs; }
+};
+
+/// counts[0] += 1 for every duplicate, counts[1] += 1 for every one that is
+/// not the record it duplicates: GlobalSelection::select's counts.
+template <std::size_t K>
+struct CountDuplicates {
+  const ClusterList<K>* clusters = nullptr;
+  const std::uint8_t* count = nullptr;
+  const std::uint8_t* kinks = nullptr;
+  const Scalar* chi2 = nullptr;
+  const Index* permutation = nullptr;
+  const std::uint8_t* head = nullptr;
+  const Index* runHead = nullptr;
+  Index* counts = nullptr;
+
+  GPUdi() void operator()(Index position) const
+  {
+    if (head[position] != 0U) {
+      return;
+    }
+    const Index record = permutation[position];
+    const Index kept = permutation[runHead[position]];
+    o2::gpu::CAMath::AtomicAdd(counts, Index{1U});
+    if (!selection::sameRecord(clusters[record], count[record], kinks[record], chi2[record], clusters[kept], count[kept], kinks[kept], chi2[kept])) {
+      o2::gpu::CAMath::AtomicAdd(counts + 1, Index{1U});
+    }
+  }
+};
+
+struct IsHead {
+  const std::uint8_t* head = nullptr;
+  GPUdi() bool operator()(Index position) const { return head[position] != 0U; }
+};
+
+/// The quality order's keys (`selection::qualityKey`); the order among
+/// equal keys, the cluster set's, comes from the sort's stability.
+struct QualityKeys {
+  const std::uint8_t* count = nullptr;
+  const std::uint8_t* kinks = nullptr;
+  const Scalar* chi2 = nullptr;
+  const Index* unique = nullptr;
+  std::uint64_t* keys = nullptr;
+
+  GPUdi() void operator()(Index i) const
+  {
+    const Index record = unique[i];
+    keys[i] = selection::qualityKey(count[record], kinks[record], chi2[record]);
+  }
+};
+
+struct IsAccepted {
+  const std::uint8_t* accepted = nullptr;
+  GPUdi() bool operator()(Index rank) const { return accepted[rank] != 0U; }
+};
+
+} // namespace
+} // namespace detail
+
+/// GlobalSelection::select over \a records (\a recordCount of them) into \a
+/// mask (\a rows entries): the same ranked and selected records, duplicates,
+/// mismatches and rounds. A record's \a sharedInnermost innermost clusters
+/// are shareable.
+template <std::size_t K, typename RecordView>
+[[nodiscard]] StageStatus select(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, const RecordView& records, Index recordCount, std::uint8_t* mask, Index rows, std::uint32_t sharedInnermost, Selected& result)
+{
+  result = {};
+  algorithms::detail::requireItems(recordCount);
+  if (recordCount == 0U) {
+    if (!result.ranked.allocate(arena, 0U) || !result.selected.allocate(arena, 0U)) {
+      return StageStatus::kOutOfMemory;
+    }
+    return StageStatus::kComplete;
+  }
+  const int keyEndBit = algorithms::keyBits(rows);
+
+  // The unique records in key order, their duplicates counted.
+  DeviceSpan<Index> unique;
+  {
+    auto scratch = arena.scope(ArenaEnd::kScratch);
+    DeviceSpan<Index> keys;
+    DeviceSpan<Index> word;
+    DeviceSpan<Index> sortedWord;
+    DeviceSpan<Index> permutation;
+    DeviceSpan<Index> nextPermutation;
+    if (!keys.allocate(arena, K * std::size_t{recordCount}, ArenaEnd::kScratch) || !word.allocate(arena, recordCount, ArenaEnd::kScratch) || !sortedWord.allocate(arena, recordCount, ArenaEnd::kScratch) || !permutation.allocate(arena, recordCount, ArenaEnd::kScratch) || !nextPermutation.allocate(arena, recordCount, ArenaEnd::kScratch)) {
+      return StageStatus::kOutOfMemory;
+    }
+    algorithms::forEach(runtime, stream, recordCount, detail::WriteKeys<K>{.clusters = records.clusters, .count = records.count, .records = recordCount, .noCluster = rows, .keys = keys.data()});
+    algorithms::forEach(runtime, stream, recordCount, detail::Iota{.out = permutation.data()});
+    Index* current = permutation.data();
+    Index* next = nextPermutation.data();
+    for (std::size_t w = K; w-- > 0U;) {
+      algorithms::forEach(runtime, stream, recordCount, algorithms::Gather<Index>{.from = std::as_const(keys).data() + (w * recordCount), .indices = current, .to = word.data()});
+      const StageStatus sorted = algorithms::sortPairs(runtime, arena, stream, std::as_const(word).data(), sortedWord.data(), current, next, recordCount, keyEndBit);
+      if (sorted != StageStatus::kComplete) {
+        return sorted;
+      }
+      std::swap(current, next);
+    }
+
+    DeviceSpan<std::uint8_t> head;
+    DeviceSpan<Index> headPosition;
+    DeviceSpan<Index> runHead;
+    DeviceSpan<Index> counts;
+    if (!head.allocate(arena, recordCount, ArenaEnd::kScratch) || !headPosition.allocate(arena, recordCount, ArenaEnd::kScratch) || !runHead.allocate(arena, recordCount, ArenaEnd::kScratch) || !counts.allocate(arena, 2U, ArenaEnd::kScratch)) {
+      return StageStatus::kOutOfMemory;
+    }
+    algorithms::forEach(runtime, stream, recordCount,
+                        detail::MarkHeads<K>{
+                          .keys = std::as_const(keys).data(),
+                          .permutation = current,
+                          .records = recordCount,
+                          .head = head.data(),
+                          .headPosition = headPosition.data(),
+                        });
+    const StageStatus scanned = algorithms::inclusiveScan(runtime, arena, stream, std::as_const(headPosition).data(), runHead.data(), recordCount, detail::MaxOf{});
+    if (scanned != StageStatus::kComplete) {
+      return scanned;
+    }
+    runtime.fill(counts.data(), 0U, 2U * sizeof(Index), stream);
+    algorithms::forEach(runtime, stream, recordCount,
+                        detail::CountDuplicates<K>{
+                          .clusters = records.clusters,
+                          .count = records.count,
+                          .kinks = records.kinks,
+                          .chi2 = records.chi2,
+                          .permutation = current,
+                          .head = std::as_const(head).data(),
+                          .runHead = std::as_const(runHead).data(),
+                          .counts = counts.data(),
+                        });
+    // Read back with the heads' count: selectIndices synchronises.
+    std::array<Index, 2> counted{};
+    download(counts, counted.data(), 2U, stream);
+    ++result.readbacks;
+
+    // The heads' positions on the scratch end, then their records: `unique`
+    // on the base end.
+    DeviceSpan<Index> positions;
+    Index heads = 0U;
+    const StageStatus selected = algorithms::selectIndices(runtime, arena, stream, recordCount, detail::IsHead{.head = std::as_const(head).data()}, positions, heads, ArenaEnd::kScratch);
+    ++result.readbacks;
+    if (selected != StageStatus::kComplete) {
+      return selected;
+    }
+    result.duplicates = counted[0];
+    result.mismatches = counted[1];
+    result.unique = heads;
+    if (!unique.allocate(arena, heads)) {
+      return StageStatus::kOutOfMemory;
+    }
+    algorithms::forEach(runtime, stream, heads, algorithms::Gather<Index>{.from = current, .indices = std::as_const(positions).data(), .to = unique.data()});
+  }
+
+  // The quality order.
+  const Index uniqueCount = result.unique;
+  if (!result.ranked.allocate(arena, uniqueCount)) {
+    return StageStatus::kOutOfMemory;
+  }
+  {
+    auto scratch = arena.scope(ArenaEnd::kScratch);
+    DeviceSpan<std::uint64_t> keys;
+    DeviceSpan<std::uint64_t> sortedKeys;
+    if (!keys.allocate(arena, uniqueCount, ArenaEnd::kScratch) || !sortedKeys.allocate(arena, uniqueCount, ArenaEnd::kScratch)) {
+      return StageStatus::kOutOfMemory;
+    }
+    algorithms::forEach(runtime, stream, uniqueCount,
+                        detail::QualityKeys{
+                          .count = records.count,
+                          .kinks = records.kinks,
+                          .chi2 = records.chi2,
+                          .unique = std::as_const(unique).data(),
+                          .keys = keys.data(),
+                        });
+    const StageStatus sorted = algorithms::sortPairs(runtime, arena, stream, std::as_const(keys).data(), sortedKeys.data(), std::as_const(unique).data(), result.ranked.data(), uniqueCount, selection::kQualityKeyBits);
+    if (sorted != StageStatus::kComplete) {
+      return sorted;
+    }
+  }
+
+  // The rank arrays and the rounds.
+  DeviceSpan<ClusterList<K>> rankClusters;
+  DeviceSpan<std::uint8_t> rankCount;
+  DeviceSpan<Index> priority;
+  DeviceSpan<std::uint8_t> live;
+  DeviceSpan<std::uint8_t> accepted;
+  DeviceSpan<Index> slotAll;
+  DeviceSpan<Index> slotExclusive;
+  if (!rankClusters.allocate(arena, uniqueCount) || !rankCount.allocate(arena, uniqueCount) || !priority.allocate(arena, uniqueCount) || !live.allocate(arena, uniqueCount) || !accepted.allocate(arena, uniqueCount) || !slotAll.allocate(arena, rows) || !slotExclusive.allocate(arena, rows)) {
+    return StageStatus::kOutOfMemory;
+  }
+  algorithms::forEach(runtime, stream, uniqueCount,
+                      selection::RankFill<K>{
+                        .clusters = records.clusters,
+                        .count = records.count,
+                        .ranked = std::as_const(result.ranked).data(),
+                        .unique = uniqueCount,
+                        .rankClusters = rankClusters.data(),
+                        .rankCount = rankCount.data(),
+                        .priority = priority.data(),
+                        .live = live.data(),
+                        .accepted = accepted.data(),
+                      });
+  runtime.fill(slotAll.data(), 0U, std::size_t{rows} * sizeof(Index), stream);
+  runtime.fill(slotExclusive.data(), 0U, std::size_t{rows} * sizeof(Index), stream);
+  const selection::BidReset<K> reset{rankClusters.data(), rankCount.data(), live.data(), slotAll.data(), slotExclusive.data()};
+  const selection::Bid<K> bid{rankClusters.data(), rankCount.data(), live.data(), priority.data(), slotAll.data(), slotExclusive.data(), sharedInnermost};
+  const selection::Decide<K> decide{rankClusters.data(), rankCount.data(), live.data(), accepted.data(), priority.data(), slotAll.data(), slotExclusive.data(), mask, sharedInnermost};
+  // The first pass prunes the records an earlier iteration's tracks exclude;
+  // each later one is a round. A pass that leaves a record live raises the
+  // flag, so the raising passes are the host's rounds; each round accepts at
+  // least the best live record, so there are at most `uniqueCount`.
+  bool first = true;
+  const auto rounds = algorithms::sweepToFixedPoint<1U>(runtime, arena, stream, uniqueCount, [&](Index* flags) {
+    if (!first) {
+      algorithms::forEach(runtime, stream, uniqueCount, reset);
+      algorithms::forEach(runtime, stream, uniqueCount, bid);
+      algorithms::forEach(runtime, stream, uniqueCount, decide);
+    }
+    first = false;
+    algorithms::forEach(runtime, stream, uniqueCount, selection::Prune<K>{rankClusters.data(), rankCount.data(), live.data(), mask, sharedInnermost, flags});
+  });
+  if (rounds.status != StageStatus::kComplete) {
+    return rounds.status;
+  }
+  result.rounds = rounds.changingSweeps;
+  result.slots = slotAll;
+  result.readbacks += rounds.changingSweeps + 1U;
+
+  // The accepted ranks, best first, on the scratch end, then as record
+  // indices.
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  DeviceSpan<Index> acceptedRanks;
+  Index tracks = 0U;
+  const StageStatus compacted = algorithms::selectIndices(runtime, arena, stream, uniqueCount, detail::IsAccepted{.accepted = std::as_const(accepted).data()}, acceptedRanks, tracks, ArenaEnd::kScratch);
+  ++result.readbacks;
+  if (compacted != StageStatus::kComplete) {
+    return compacted;
+  }
+  if (!result.selected.allocate(arena, tracks)) {
+    return StageStatus::kOutOfMemory;
+  }
+  algorithms::forEach(runtime, stream, tracks, algorithms::Gather<Index>{.from = std::as_const(result.ranked).data(), .indices = std::as_const(acceptedRanks).data(), .to = result.selected.data()});
+  result.tracks = tracks;
+  return StageStatus::kComplete;
+}
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::selection_glue
+
+#endif // GTRK_TRACKING_GPU_SELECTIONGLUE_CUH_
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/SliceGlue.cuh b/Detectors/GenericTracking/tracking/GPU/cuda/SliceGlue.cuh
new file mode 100644
index 0000000000000..f0b86e6936b08
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/SliceGlue.cuh
@@ -0,0 +1,263 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file SliceGlue.cuh
+/// \brief The passes between a slice's stages on a device.
+///
+/// Each gives exactly the host class's result:
+///
+///   permutation   TripletPermutation: the eligible first tracklets, by their
+///                 middle measurement's source element or in arena order
+///   endIndex      TripletEndIndex: the triplets by their second tracklet
+///   chained       the triplets with predecessors, in arena order: the slice
+///                 download's, which the tests compare with `chainedTriplets`
+///
+/// Outputs go to the base end in the caller's scope, temporaries to the
+/// scratch end, released on return. A pass that needs a count reads it back
+/// and synchronises; the others are only queued. The shared parts are
+/// DeviceAlgorithms.cuh's. Included by the .cu that
+/// instantiates a tracker, in the backend's namespace.
+
+#ifndef GTRK_TRACKING_GPU_SLICEGLUE_CUH_
+#define GTRK_TRACKING_GPU_SLICEGLUE_CUH_
+
+#include "DeviceAlgorithms.cuh"
+#include "GenericTracking/Tracking/TrackletPaths.h"
+#include "Platform.cuh"
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/DeviceStageOutput.h"
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/LayerRowMap.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/TrackletSort.h"
+#include "GenericTracking/Tracking/Triplet.h"
+#include "GenericTracking/Tracking/TripletPermutation.h"
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+#include <utility>
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::glue
+{
+
+using Index = std::uint32_t;
+
+// Unnamed, so that two sources of one library may include this header.
+namespace detail
+{
+namespace
+{
+
+/// Whether a tracklet's middle measurement is a source of the slice with
+/// tracklets of its own, on a tracklet path of the iteration's minClusters:
+/// the triplet stage's first tracklets, as TripletPermutation::build.
+template <DetectorLayout Det>
+struct EligibleFirst {
+  TrackletConstView tracklets;
+  const IterationParameters<Det>* parameters = nullptr;
+  const LayerRowMap<Det>* sources = nullptr;
+  const Index* offsets = nullptr;
+  TrackletPathBounds paths;
+  GPUdi() bool operator()(Index first) const { return firstTrackletEligible(*parameters, *sources, tracklets, offsets, paths, first); }
+};
+
+/// The end index's sort keys: each triplet's second tracklet, the triplet as
+/// its value, and the tracklet's count of them.
+struct EndIndexKeys {
+  TripletConstView triplets;
+  Index* keys = nullptr;
+  Index* values = nullptr;
+  Index* perTracklet = nullptr;
+  GPUdi() void operator()(Index triplet) const
+  {
+    const Index second = triplets.second[triplet];
+    keys[triplet] = second;
+    values[triplet] = triplet;
+    atomicAdd(perTracklet + second, 1U);
+  }
+};
+
+/// Whether a triplet has predecessors: its neighbour range is not empty.
+struct HasPredecessors {
+  const Index* neighbourOffsets = nullptr;
+  GPUdi() bool operator()(Index triplet) const { return neighbourOffsets[triplet + 1U] != neighbourOffsets[triplet]; }
+};
+
+/// The tracklet sort's first pass: each tracklet's target as its key, its
+/// row as its value.
+struct TrackletTargetKeys {
+  const Index* target = nullptr;
+  Index* keys = nullptr;
+  Index* slots = nullptr;
+  GPUdi() void operator()(Index i) const
+  {
+    keys[i] = target[i];
+    slots[i] = i;
+  }
+};
+
+/// Its second: the link and lambda of the row each position holds after the
+/// first pass.
+struct TrackletLinkLambdaKeys {
+  const std::uint16_t* link = nullptr;
+  const Scalar* lambda = nullptr;
+  const Index* slots = nullptr;
+  std::uint64_t* keys = nullptr;
+  GPUdi() void operator()(Index i) const
+  {
+    const Index row = slots[i];
+    keys[i] = trackletLinkLambdaKey(link[row], lambda[row]);
+  }
+};
+
+/// to[i] = from[indices[i]], every tracklet column.
+struct GatherTracklets {
+  TrackletConstView from;
+  const Index* indices;
+  DeviceColumns<TrackletT>::View to;
+  GPUdi() void operator()(Index i) const
+  {
+    const Index row = indices[i];
+    to.source[i] = from.source[row];
+    to.target[i] = from.target[row];
+    to.link[i] = from.link[row];
+    to.lambda[i] = from.lambda[row];
+    to.phi[i] = from.phi[row];
+  }
+};
+
+} // namespace
+} // namespace detail
+
+/// Each source's tracklets in (link, lambda, target) order, in place:
+/// every source a segment of the library's
+/// segmented sort, stable, first by target, then by link and lambda, so that
+/// equal links and lambdas keep the targets' order -- `trackletBefore`'s order
+/// for any segment length and any ties. Then every column gathered in that
+/// order by one kernel into the sort's buffers, dead by then, and copied back
+/// by one. Every buffer lives on the arena's scratch end for this call; a
+/// refusal is kOutOfMemory, with nothing written to the tracklets (the copy
+/// back is the last step). Queued on \a stream.
+[[nodiscard]] inline StageStatus sortTracklets(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, DeviceStageOutput<TrackletT>& tracklets)
+{
+  const Index count = tracklets.size();
+  if (count == 0U) {
+    return StageStatus::kComplete;
+  }
+  const Index segments = tracklets.elementCount();
+  const Index* offsets = std::as_const(tracklets).offsets().data();
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  std::array<DeviceSpan<Index>, 2> slots;
+  std::array<DeviceSpan<Index>, 2> targetKeys;
+  std::array<DeviceSpan<std::uint64_t>, 2> linkLambdaKeys;
+  DeviceSpan<Index> column;
+  for (auto* span : {&slots[0], &slots[1], &targetKeys[0], &targetKeys[1], &column}) {
+    if (!span->allocate(arena, count, ArenaEnd::kScratch)) {
+      return StageStatus::kOutOfMemory;
+    }
+  }
+  for (auto& span : linkLambdaKeys) {
+    if (!span.allocate(arena, count, ArenaEnd::kScratch)) {
+      return StageStatus::kOutOfMemory;
+    }
+  }
+  const auto view = tracklets.view();
+
+  algorithms::forEach(runtime, stream, count, detail::TrackletTargetKeys{.target = view.target, .keys = targetKeys[0].data(), .slots = slots[0].data()});
+  cubapi::DoubleBuffer<Index> firstKeys{targetKeys[0].data(), targetKeys[1].data()};
+  cubapi::DoubleBuffer<Index> values{slots[0].data(), slots[1].data()};
+  StageStatus status = algorithms::segmentedStableSortPairs(runtime, arena, stream, firstKeys, values, count, segments, offsets, offsets + 1);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+
+  algorithms::forEach(runtime, stream, count, detail::TrackletLinkLambdaKeys{.link = view.link, .lambda = view.lambda, .slots = values.Current(), .keys = linkLambdaKeys[0].data()});
+  cubapi::DoubleBuffer<std::uint64_t> secondKeys{linkLambdaKeys[0].data(), linkLambdaKeys[1].data()};
+  status = algorithms::segmentedStableSortPairs(runtime, arena, stream, secondKeys, values, count, segments, offsets, offsets + 1);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+
+  // After the sorts only the sorted slots are live: five of the other
+  // buffers, each at least 4 bytes a row, take a column each.
+  constexpr std::size_t kColumns = 5U;
+  const std::array<void*, kColumns> buffers{column.data(), targetKeys[0].data(), targetKeys[1].data(), linkLambdaKeys[0].data(), linkLambdaKeys[1].data()};
+  DeviceColumns<TrackletT>::Pointers gathered{};
+  gathered.apply([&](auto&... to) {
+    static_assert(sizeof...(to) == kColumns);
+    std::size_t next = 0U;
+    ((to = static_cast<std::remove_reference_t<decltype(to)>>(buffers[next++])), ...);
+  });
+  algorithms::forEach(runtime, stream, count, detail::GatherTracklets{.from = std::as_const(tracklets).view(), .indices = values.Current(), .to = DeviceColumns<TrackletT>::View{gathered}});
+  std::array<DeviceCopy, kColumns> copies{};
+  std::size_t next = 0U;
+  device_storage_detail::forEachColumnPair(DeviceColumns<TrackletT>::ConstView{gathered}, view, [&](auto* to, const auto* from) {
+    static_assert(sizeof(*to) <= sizeof(Index));
+    copies[next++] = {.to = to, .from = from, .bytes = std::size_t{count} * sizeof(*to)};
+  });
+  runtime.copyEachOnDevice(copies, stream);
+  return StageStatus::kComplete;
+}
+
+/// The triplet stage's first tracklets, as TripletPermutation::build: of the
+/// \a count tracklets, the indices of those whose middle measurement is a
+/// source with tracklets (\a offsets) and that are on a path of \a paths'
+/// length, in arena order. \a permutation gets \a count entries, of which the
+/// first \a size are the order.
+template <DetectorLayout Det>
+[[nodiscard]] StageStatus permutation(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, TrackletConstView tracklets, Index count, const IterationParameters<Det>* parameters, const LayerRowMap<Det>* sources, DeviceSpan<Index>& permutation, Index& size, const Index* offsets, TrackletPathBounds paths)
+{
+  return algorithms::selectIndices(runtime, arena, stream, count, detail::EligibleFirst<Det>{.tracklets = tracklets, .parameters = parameters, .sources = sources, .offsets = offsets, .paths = paths}, permutation, size);
+}
+
+/// The triplets by their second tracklet: \a offsets, `trackletCount + 1`
+/// of them, delimit the triplet indices in \a indices, in arena order within
+/// each tracklet.
+[[nodiscard]] inline StageStatus endIndex(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, TripletConstView triplets, Index tripletCount, Index trackletCount, DeviceSpan<Index>& offsets, DeviceSpan<Index>& indices)
+{
+  const std::size_t offsetCount = std::size_t{trackletCount} + 1U;
+  if (!offsets.allocate(arena, offsetCount) || !indices.allocate(arena, tripletCount)) {
+    return StageStatus::kOutOfMemory;
+  }
+  if (tripletCount == 0U) {
+    runtime.fill(offsets.data(), 0U, offsetCount * sizeof(Index), stream);
+    return StageStatus::kComplete;
+  }
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  DeviceSpan<Index> keys;
+  DeviceSpan<Index> sortedKeys;
+  DeviceSpan<Index> values;
+  DeviceSpan<Index> perTracklet;
+  if (!keys.allocate(arena, tripletCount, ArenaEnd::kScratch) || !sortedKeys.allocate(arena, tripletCount, ArenaEnd::kScratch) || !values.allocate(arena, tripletCount, ArenaEnd::kScratch) || !perTracklet.allocate(arena, offsetCount, ArenaEnd::kScratch)) {
+    return StageStatus::kOutOfMemory;
+  }
+  runtime.fill(perTracklet.data(), 0U, offsetCount * sizeof(Index), stream);
+  algorithms::forEach(runtime, stream, tripletCount, detail::EndIndexKeys{triplets, keys.data(), values.data(), perTracklet.data()});
+  const StageStatus sorted = algorithms::sortPairs(runtime, arena, stream, std::as_const(keys).data(), sortedKeys.data(), std::as_const(values).data(), indices.data(), tripletCount, algorithms::keyBits(trackletCount));
+  if (sorted != StageStatus::kComplete) {
+    return sorted;
+  }
+  // The last count is zero, so the scan's last offset is the total.
+  return algorithms::exclusiveScan(runtime, arena, stream, std::as_const(perTracklet).data(), offsets.data(), offsetCount);
+}
+
+/// The triplets whose predecessor range is not empty, in arena order, from
+/// the neighbour stage's `tripletCount + 1` offsets.
+[[nodiscard]] inline StageStatus chained(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, const Index* neighbourOffsets, Index tripletCount, DeviceSpan<Index>& chained, Index& size) { return algorithms::selectIndices(runtime, arena, stream, tripletCount, detail::HasPredecessors{.neighbourOffsets = neighbourOffsets}, chained, size); }
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::glue
+
+#endif // GTRK_TRACKING_GPU_SLICEGLUE_CUH_
diff --git a/Detectors/GenericTracking/tracking/GPU/cuda/VertexGlue.cuh b/Detectors/GenericTracking/tracking/GPU/cuda/VertexGlue.cuh
new file mode 100644
index 0000000000000..42482ebf39af3
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/GPU/cuda/VertexGlue.cuh
@@ -0,0 +1,1098 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file VertexGlue.cuh
+/// \brief The vertexer on the device: the
+///        vertexing pass's triplets to the timeframe's vertex list, as
+///        `Vertexer::find` makes it on the host.
+///
+///   Candidates: one candidate per triplet: `vertexCandidate`, its r-z chi2,
+///       its box; the accepted ones made cluster-disjoint in rounds of bids -- each
+///       live one bids (chi2, place) for its rows, the lowest everywhere is
+///       kept, those on its rows dropped -- the host's greedy pass in chi2
+///       order
+///   Order: the kept ones in triplet order, sorted stably by (frame, z)
+///   Rounds: under `sweepToFixedPoint`, every frame at once: scans of the
+///       free candidates' counts and z; each candidate's window and
+///       sidebands by binary search in its frame; the frame's peak in two
+///       stages -- the largest excess, then the lowest index with it -- over
+///       the whole 64-bit excess; the centre from the scans; the claims, their
+///       z's sums and the box by integer atomics, one set per frame and round;
+///       then the round's vertices own the measurements of their frames'
+///       triplets within the claim -- the cut ones too -- and the free
+///       candidates with an owned one are dropped, each
+///       measurement a slot per frame, (frame << 32) | row, sorted and unique;
+///       with `aloneMinContributors` the lower minimum, a second sweep at it
+///       over the frames the first left without a vertex, the others skipped
+///       (the host's rerun of such a frame)
+///   Seeds: the sums read back; the host makes the seeds (`vertexSeedOf`) and
+///       orders each frame's vertices by z, ties by round, as the host does
+///
+/// Everything after the map is integer, or float on integers, so the list
+/// does not depend on the schedule; the map itself is float, and a device's
+/// candidates can differ from the host's where its contractions round
+/// otherwise. Included by DeviceTracker.cuh, in the backend's namespace.
+
+#ifndef GTRK_TRACKING_GPU_VERTEXGLUE_CUH_
+#define GTRK_TRACKING_GPU_VERTEXGLUE_CUH_
+
+#include "DeviceAlgorithms.cuh"
+#include "Platform.cuh"
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/Triplet.h"
+#include "GenericTracking/Tracking/VertexStage.h"
+
+#include "GPUCommonAlgorithm.h"
+
+#include <algorithm>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <vector>
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::vertex_glue
+{
+
+using Index = std::uint32_t;
+
+namespace detail
+{
+namespace
+{
+
+constexpr Index kNoIndex = std::numeric_limits<Index>::max();
+constexpr std::uint64_t kNoBid = std::numeric_limits<std::uint64_t>::max();
+
+/// Candidates: each triplet's candidate key (0 for none), its key as an ownership
+/// source (0 for a degenerate one), its r-z chi2, its weight
+/// from its z0 error -- the pass's material and the beam's transverse spread,
+/// `ScatteringErrors` -- and its box.
+template <DetectorLayout Det>
+struct CandidateMap {
+  MeasurementView measurements;
+  TrackletConstView tracklets;
+  TripletConstView triplets;
+  VertexerSettings settings;
+  const IterationParameters<Det>* pass = nullptr;
+  float varTransverse = 0.F;
+  std::uint64_t* keys = nullptr;
+  std::uint64_t* sourceKeys = nullptr;
+  float* chi2 = nullptr;
+  std::uint64_t* weights = nullptr;
+  Index* lower = nullptr;
+  Index* upper = nullptr;
+  GPUdi() void operator()(Index triplet) const
+  {
+    const ScatteringErrors<Det> errors{.table = &pass->scattering, .cut = pass->pairCut, .varTransverse = varTransverse};
+    VertexCandidateFit fit;
+    TimeEstPS box;
+    const auto status = measureCandidate(measurements, tracklets, triplets, triplet, settings, errors, fit, weights[triplet], box, nullptr);
+    keys[triplet] = status == VertexCandidateStatus::kAccepted ? fit.key : 0U;
+    sourceKeys[triplet] = status != VertexCandidateStatus::kDegenerate ? fit.key : 0U;
+    chi2[triplet] = fit.chi2RZ;
+    lower[triplet] = box.lower();
+    upper[triplet] = box.upper();
+  }
+};
+
+struct Accepted {
+  const std::uint64_t* keys = nullptr;
+  GPUdi() bool operator()(Index triplet) const { return keys[triplet] != 0U; }
+};
+
+/// The deduplication's state of an accepted candidate.
+enum : std::uint8_t { kLive = 0U,
+                      kKept = 1U,
+                      kDropped = 2U };
+
+/// What the deduplication's rounds read and write: the accepted candidates
+/// in triplet order, their rows and bids, and per row its lowest bid and
+/// whether a kept candidate holds it.
+struct Deduplication {
+  const Index* accepted = nullptr;
+  TrackletConstView tracklets;
+  TripletConstView triplets;
+  const float* chi2 = nullptr;
+  std::uint8_t* state = nullptr;
+  std::uint64_t* slots = nullptr;
+  std::uint8_t* taken = nullptr;
+  GPUdi() std::array<Index, 3> rows(Index candidate) const { return tripletRows(tracklets, triplets, accepted[candidate]); }
+  /// The bid: the chi2's bits -- non-negative, so they order as the values
+  /// -- then the candidate's place, the lower triplet first on ties.
+  GPUdi() std::uint64_t bid(Index candidate) const { return (static_cast<std::uint64_t>(std::bit_cast<std::uint32_t>(chi2[accepted[candidate]])) << 32U) | candidate; }
+};
+
+/// Every live candidate's rows open for this round's bids.
+struct Reopen {
+  Deduplication d;
+  GPUdi() void operator()(Index candidate) const
+  {
+    if (d.state[candidate] != kLive) {
+      return;
+    }
+    const auto rows = d.rows(candidate);
+    for (const Index row : rows) {
+      d.slots[row] = kNoBid;
+    }
+  }
+};
+
+/// Every live candidate bids for its rows.
+struct Bid {
+  Deduplication d;
+  GPUdi() void operator()(Index candidate) const
+  {
+    if (d.state[candidate] != kLive) {
+      return;
+    }
+    const auto rows = d.rows(candidate);
+    const auto bid = static_cast<unsigned long long>(d.bid(candidate));
+    for (const Index row : rows) {
+      atomicMin(reinterpret_cast<unsigned long long*>(d.slots) + row, bid);
+    }
+  }
+};
+
+/// A live candidate holding the lowest bid on all its rows is kept: nothing
+/// before it in the order is left on any of them. The round's change flag
+/// goes up.
+struct Decide {
+  Deduplication d;
+  Index* changed = nullptr;
+  GPUdi() void operator()(Index candidate) const
+  {
+    if (d.state[candidate] != kLive) {
+      return;
+    }
+    const auto rows = d.rows(candidate);
+    const std::uint64_t bid = d.bid(candidate);
+    for (const Index row : rows) {
+      if (d.slots[row] != bid) {
+        return;
+      }
+    }
+    d.state[candidate] = kKept;
+    for (const Index row : rows) {
+      d.taken[row] = 1U;
+    }
+    *changed = 1U;
+  }
+};
+
+/// A live candidate on a row a kept one holds is dropped.
+struct Drop {
+  Deduplication d;
+  GPUdi() void operator()(Index candidate) const
+  {
+    if (d.state[candidate] != kLive) {
+      return;
+    }
+    const auto rows = d.rows(candidate);
+    for (const Index row : rows) {
+      if (d.taken[row] != 0U) {
+        d.state[candidate] = kDropped;
+        return;
+      }
+    }
+  }
+};
+
+/// The kept candidates of the owned frames (`OwnedFrames`).
+struct KeptOnes {
+  const std::uint8_t* state = nullptr;
+  const Index* accepted = nullptr;
+  const std::uint64_t* keys = nullptr;
+  OwnedFrames owned;
+  GPUdi() bool operator()(Index candidate) const { return state[candidate] == kKept && owned.owns(vertexKeyFrame(keys[accepted[candidate]])); }
+};
+
+/// The kept candidates' keys and triplets, in triplet order, for the sort.
+struct GatherKept {
+  const Index* kept = nullptr;
+  const Index* accepted = nullptr;
+  const std::uint64_t* keys = nullptr;
+  std::uint64_t* candidateKeys = nullptr;
+  Index* candidateTriplets = nullptr;
+  GPUdi() void operator()(Index candidate) const
+  {
+    const Index triplet = accepted[kept[candidate]];
+    candidateKeys[candidate] = keys[triplet];
+    candidateTriplets[candidate] = triplet;
+  }
+};
+
+/// The sorted candidates' z [um] and box, and whether each begins a frame.
+struct SortedColumns {
+  const std::uint64_t* sortedKeys = nullptr;
+  const Index* sortedTriplets = nullptr;
+  const Index* lower = nullptr;
+  const Index* upper = nullptr;
+  const std::uint64_t* weights = nullptr;
+  long long* z = nullptr;
+  std::uint64_t* weight = nullptr;
+  Index* boxLower = nullptr;
+  Index* boxUpper = nullptr;
+  Index* frameStart = nullptr;
+  GPUdi() void operator()(Index candidate) const
+  {
+    const std::uint64_t key = sortedKeys[candidate];
+    z[candidate] = vertexKeyZUM(key);
+    const Index triplet = sortedTriplets[candidate];
+    weight[candidate] = weights[triplet];
+    boxLower[candidate] = lower[triplet];
+    boxUpper[candidate] = upper[triplet];
+    frameStart[candidate] = candidate == 0U || vertexKeyFrame(key) != vertexKeyFrame(sortedKeys[candidate - 1U]) ? 1U : 0U;
+  }
+};
+
+struct FrameStarts {
+  const Index* frameStart = nullptr;
+  GPUdi() bool operator()(Index candidate) const { return frameStart[candidate] != 0U; }
+};
+
+/// Each candidate's frame, from the starts' exclusive scan.
+struct FrameOf {
+  const Index* frameStart = nullptr;
+  const Index* startsBefore = nullptr;
+  Index* frame = nullptr;
+  GPUdi() void operator()(Index candidate) const { frame[candidate] = startsBefore[candidate] + frameStart[candidate] - 1U; }
+};
+
+/// The ownership's sources: every triplet of the owned
+/// frames but the degenerate.
+struct Sources {
+  const std::uint64_t* sourceKeys = nullptr;
+  OwnedFrames owned;
+  GPUdi() bool operator()(Index triplet) const { return sourceKeys[triplet] != 0U && owned.owns(vertexKeyFrame(sourceKeys[triplet])); }
+};
+
+/// Each source's three slot keys, (frame << 32) | row (`ownedSlotKey`).
+struct SlotKeys {
+  const Index* sources = nullptr;
+  const std::uint64_t* sourceKeys = nullptr;
+  TrackletConstView tracklets;
+  TripletConstView triplets;
+  std::uint64_t* slotKeys = nullptr;
+  GPUdi() void operator()(Index source) const
+  {
+    const Index triplet = sources[source];
+    const auto rows = tripletRows(tracklets, triplets, triplet);
+    for (Index k = 0; k < 3U; ++k) {
+      slotKeys[(3U * source) + k] = ownedSlotKey(sourceKeys[triplet], rows[k]);
+    }
+  }
+};
+
+/// The first of each run of equal sorted slot keys.
+struct SlotStarts {
+  const std::uint64_t* sorted = nullptr;
+  GPUdi() bool operator()(Index i) const { return i == 0U || sorted[i] != sorted[i - 1U]; }
+};
+
+struct GatherSlots {
+  const Index* starts = nullptr;
+  const std::uint64_t* sorted = nullptr;
+  std::uint64_t* unique = nullptr;
+  GPUdi() void operator()(Index slot) const { unique[slot] = sorted[starts[slot]]; }
+};
+
+/// The slots of a triplet's measurements: their keys' places among the
+/// unique ones.
+struct SlotsOf {
+  const std::uint64_t* unique = nullptr;
+  Index slots = 0U;
+  TrackletConstView tracklets;
+  TripletConstView triplets;
+  GPUdi() void operator()(std::uint64_t key, Index triplet, Index* out) const
+  {
+    const auto rows = tripletRows(tracklets, triplets, triplet);
+    for (Index k = 0; k < 3U; ++k) {
+      const std::uint64_t slotKey = ownedSlotKey(key, rows[k]);
+      out[k] = o2::gpu::CAAlgo::partitionPoint(Index{0}, slots, [&](Index i) { return unique[i] < slotKey; });
+    }
+  }
+};
+
+/// Each source's slots, z [um] and frame among the candidates' frames
+/// (kNoIndex if its frame has no candidate).
+struct SourceColumns {
+  const Index* sources = nullptr;
+  const std::uint64_t* sourceKeys = nullptr;
+  SlotsOf slotsOf;
+  const std::uint64_t* sortedKeys = nullptr;
+  const Index* frameBegin = nullptr;
+  Index frames = 0U;
+  Index* sourceSlots = nullptr;
+  long long* sourceZ = nullptr;
+  Index* sourceFrame = nullptr;
+  GPUdi() void operator()(Index source) const
+  {
+    const Index triplet = sources[source];
+    const std::uint64_t key = sourceKeys[triplet];
+    slotsOf(key, triplet, sourceSlots + (3U * source));
+    sourceZ[source] = vertexKeyZUM(key);
+    const std::int64_t frame = vertexKeyFrame(key);
+    const Index f = o2::gpu::CAAlgo::partitionPoint(Index{0}, frames, [&](Index g) { return vertexKeyFrame(sortedKeys[frameBegin[g]]) < frame; });
+    sourceFrame[source] = f < frames && vertexKeyFrame(sortedKeys[frameBegin[f]]) == frame ? f : kNoIndex;
+  }
+};
+
+/// Each sorted candidate's slots.
+struct CandidateSlots {
+  const std::uint64_t* sortedKeys = nullptr;
+  const Index* sortedTriplets = nullptr;
+  SlotsOf slotsOf;
+  Index* candidateSlots = nullptr;
+  GPUdi() void operator()(Index candidate) const { slotsOf(sortedKeys[candidate], sortedTriplets[candidate], candidateSlots + (3U * candidate)); }
+};
+
+/// What the rounds read of the candidates and their frames.
+struct Candidates {
+  const long long* z = nullptr;
+  const std::uint64_t* weight = nullptr;
+  const Index* boxLower = nullptr;
+  const Index* boxUpper = nullptr;
+  const Index* frame = nullptr;
+  const Index* frameBegin = nullptr;
+  Index frames = 0U;
+  Index count = 0U;
+  GPUdi() Index frameEnd(Index f) const { return f + 1U < frames ? frameBegin[f + 1U] : count; }
+  /// The first candidate of [\a begin, \a end) whose z is at least \a value:
+  /// the host's `std::ranges::lower_bound` in the frame.
+  GPUdi() Index at(Index begin, Index end, long long value) const
+  {
+    return o2::gpu::CAAlgo::partitionPoint(begin, end - begin, [&](Index i) { return z[i] < value; });
+  }
+};
+
+/// One round's per-frame state: the peak and the vertex it makes.
+struct Round {
+  Counter* bestExcess = nullptr;
+  Index* bestIndex = nullptr;
+  float* centre = nullptr;
+  Index* contributors = nullptr;
+  Index* earliest = nullptr;
+  Index* latest = nullptr;
+};
+
+/// The free candidates' count and z, for the round's scans; the entry past
+/// the last is zero, so the scans' last entry is the total.
+struct FreeColumns {
+  Candidates candidates;
+  const std::int32_t* claims = nullptr;
+  Index* freeCount = nullptr;
+  long long* freeZ = nullptr;
+  GPUdi() void operator()(Index candidate) const
+  {
+    const bool free = candidate < candidates.count && claims[candidate] == kClaimFree;
+    freeCount[candidate] = free ? 1U : 0U;
+    freeZ[candidate] = free ? candidates.z[candidate] : 0;
+  }
+};
+
+/// The frames with a vertex: those with a claimed candidate.
+struct FramesWithVertex {
+  Candidates candidates;
+  const std::int32_t* claims = nullptr;
+  std::uint8_t* withVertex = nullptr;
+  GPUdi() void operator()(Index i) const
+  {
+    if (claims[i] >= 0) {
+      withVertex[candidates.frame[i]] = 1U;
+    }
+  }
+};
+
+/// Each free candidate's window, its sidebands and its excess 2W - S if it
+/// may be a peak (0 otherwise); the frame's largest excess by atomic max.
+/// The frames \a skipped marks (if given) score nothing.
+struct Score {
+  Candidates candidates;
+  const std::int32_t* claims = nullptr;
+  const Index* countBefore = nullptr;
+  long long window = 0;
+  long long claim = 0;
+  Index minContributors = 0U;
+  float k2 = 0.F;
+  const std::uint8_t* skipped = nullptr;
+  long long* excess = nullptr;
+  Round round;
+  GPUdi() void operator()(Index i) const
+  {
+    excess[i] = 0;
+    if (claims[i] != kClaimFree) {
+      return;
+    }
+    const Index f = candidates.frame[i];
+    if (skipped != nullptr && skipped[f] != 0U) {
+      return;
+    }
+    const Index begin = candidates.frameBegin[f];
+    const Index end = candidates.frameEnd(f);
+    const long long z = candidates.z[i];
+    const auto countIn = [&](std::int64_t low, std::int64_t high) { return countBefore[candidates.at(begin, end, high)] - countBefore[candidates.at(begin, end, low)]; };
+    const std::int64_t score = peakExcess(z, window, claim, minContributors, k2, countIn);
+    if (score <= 0) {
+      return;
+    }
+    excess[i] = score;
+    atomicMax(round.bestExcess + f, static_cast<Counter>(score));
+  }
+};
+
+/// The lowest index among the frame's candidates with its largest excess.
+struct Pick {
+  Candidates candidates;
+  const long long* excess = nullptr;
+  Round round;
+  GPUdi() void operator()(Index i) const
+  {
+    const Index f = candidates.frame[i];
+    if (excess[i] > 0 && static_cast<Counter>(excess[i]) == round.bestExcess[f]) {
+      atomicMin(round.bestIndex + f, i);
+    }
+  }
+};
+
+/// Each frame with a peak: the centre, the mean of the window's free
+/// candidates' z, and the round's change flag raised.
+struct Centre {
+  Candidates candidates;
+  const Index* countBefore = nullptr;
+  const long long* zBefore = nullptr;
+  long long window = 0;
+  Round round;
+  Index* changed = nullptr;
+  GPUdi() void operator()(Index f) const
+  {
+    const Index best = round.bestIndex[f];
+    if (best == kNoIndex) {
+      return;
+    }
+    const Index windowEnd = candidates.at(candidates.frameBegin[f], candidates.frameEnd(f), candidates.z[best] + window);
+    const long long sum = zBefore[windowEnd] - zBefore[best];
+    const Index members = countBefore[windowEnd] - countBefore[best];
+    round.centre[f] = static_cast<float>(sum) / static_cast<float>(members);
+    *changed = 1U;
+  }
+};
+
+/// Each free candidate of a frame with a peak, within the claim of its
+/// centre: claimed for the round's vertex, counted, its box taken.
+struct Claim {
+  Candidates candidates;
+  std::int32_t* claims = nullptr;
+  float claim = 0.F;
+  std::int32_t vertexBase = 0; ///< the round's first vertex number: round * frames
+  Round round;
+  GPUdi() void operator()(Index i) const
+  {
+    if (claims[i] != kClaimFree) {
+      return;
+    }
+    const Index f = candidates.frame[i];
+    if (round.bestIndex[f] == kNoIndex) {
+      return;
+    }
+    if (!withinZ(candidates.z[i], round.centre[f], claim)) {
+      return;
+    }
+    claims[i] = vertexBase + static_cast<std::int32_t>(f);
+    atomicAdd(round.contributors + f, 1U);
+    atomicMin(round.earliest + f, candidates.boxLower[i]);
+    atomicMax(round.latest + f, candidates.boxUpper[i]);
+  }
+};
+
+/// Each source of a frame with a vertex this round, within its claim: its
+/// measurements owned.
+struct Own {
+  const Index* sourceSlots = nullptr;
+  const long long* sourceZ = nullptr;
+  const Index* sourceFrame = nullptr;
+  std::uint8_t* ownedSlots = nullptr;
+  float claim = 0.F;
+  Round round;
+  GPUdi() void operator()(Index source) const
+  {
+    const Index f = sourceFrame[source];
+    if (f == kNoIndex || round.bestIndex[f] == kNoIndex || !withinZ(sourceZ[source], round.centre[f], claim)) {
+      return;
+    }
+    for (Index k = 0; k < 3U; ++k) {
+      ownedSlots[sourceSlots[(3U * source) + k]] = 1U;
+    }
+  }
+};
+
+/// Each free candidate with an owned measurement is dropped.
+struct DropOwned {
+  const Index* candidateSlots = nullptr;
+  const std::uint8_t* ownedSlots = nullptr;
+  std::int32_t* claims = nullptr;
+  GPUdi() void operator()(Index i) const
+  {
+    if (claims[i] != kClaimFree) {
+      return;
+    }
+    for (Index k = 0; k < 3U; ++k) {
+      if (ownedSlots[candidateSlots[(3U * i) + k]] != 0U) {
+        claims[i] = kClaimDropped;
+        return;
+      }
+    }
+  }
+};
+
+/// What a vertex's z and error come from (`VertexClaim`): its selected
+/// candidates, grown from the core, one slot
+/// per vertex number -- round * frames + frame, as the claims hold them.
+struct Selection {
+  Candidates candidates;
+  const std::int32_t* claims = nullptr;
+  std::uint8_t* selected = nullptr;
+  Counter* weightSum = nullptr;
+  Counter* weightedZSum = nullptr;
+  Counter* scatterSum = nullptr;
+  Counter* count = nullptr;
+  float* mean = nullptr;
+  float* varMean = nullptr;
+  GPUdi() void select(Index i, Index v) const
+  {
+    selected[i] = 1U;
+    const std::uint64_t w = candidates.weight[i];
+    atomicAdd(weightSum + v, static_cast<Counter>(w));
+    atomicAdd(weightedZSum + v, static_cast<Counter>(static_cast<long long>(w) * candidates.z[i]));
+    atomicAdd(count + v, Counter{1U});
+  }
+};
+
+/// The core: each claimed candidate within the window of its vertex's
+/// centre starts the selection.
+struct CoreStart {
+  Selection selection;
+  const float* centre = nullptr;
+  float window = 0.F;
+  GPUdi() void operator()(Index i) const
+  {
+    const std::int32_t v = selection.claims[i];
+    if (v >= 0 && withinZ(selection.candidates.z[i], centre[v], window)) {
+      selection.select(i, static_cast<Index>(v));
+    }
+  }
+};
+
+/// Each vertex's weighted mean and its variance from its selection.
+struct Moments {
+  Selection selection;
+  GPUdi() void operator()(Index v) const
+  {
+    if (selection.count[v] == 0U) {
+      return;
+    }
+    const auto moments = zMoments(static_cast<std::uint64_t>(selection.weightSum[v]), static_cast<std::int64_t>(selection.weightedZSum[v]));
+    selection.mean[v] = moments.mean;
+    selection.varMean[v] = moments.varMean;
+  }
+};
+
+/// Each claimed candidate not yet selected joins if it lies within nSigma of
+/// its own and the mean's errors of its vertex's mean; the change flag goes up.
+struct Grow {
+  Selection selection;
+  float nSigma = 0.F;
+  Index* changed = nullptr;
+  GPUdi() void operator()(Index i) const
+  {
+    const std::int32_t v = selection.claims[i];
+    if (v < 0 || selection.selected[i] != 0U) {
+      return;
+    }
+    const auto at = static_cast<Index>(v);
+    if (withinError(selection.candidates.z[i], selection.candidates.weight[i], ZMoments{.mean = selection.mean[at], .varMean = selection.varMean[at]}, nSigma)) {
+      selection.select(i, at);
+      *changed = 1U;
+    }
+  }
+};
+
+/// Each selected candidate's share of its vertex's scatter about the settled
+/// weighted mean (`candidateScatter`), for the sandwich error.
+struct Scatter {
+  Selection selection;
+  GPUdi() void operator()(Index i) const
+  {
+    const std::int32_t v = selection.claims[i];
+    if (v < 0 || selection.selected[i] == 0U) {
+      return;
+    }
+    atomicAdd(selection.scatterSum + v, static_cast<Counter>(candidateScatter(selection.candidates.z[i], selection.candidates.weight[i], selection.mean[v])));
+  }
+};
+
+/// A round's per-frame arrays on the base end.
+struct RoundStorage {
+  DeviceSpan<Counter> bestExcess;
+  DeviceSpan<Index> bestIndex;
+  DeviceSpan<float> centre;
+  DeviceSpan<Index> contributors;
+  DeviceSpan<Index> earliest;
+  DeviceSpan<Index> latest;
+
+  [[nodiscard]] bool allocate(DeviceArena& arena, Index frames) { return bestExcess.allocate(arena, frames) && bestIndex.allocate(arena, frames) && centre.allocate(arena, frames) && contributors.allocate(arena, frames) && earliest.allocate(arena, frames) && latest.allocate(arena, frames); }
+  void reset(DeviceRuntime& runtime, DeviceStream& stream, Index frames)
+  {
+    runtime.fill(bestExcess.data(), 0U, frames * sizeof(Counter), stream);
+    runtime.fill(bestIndex.data(), 0xFFU, frames * sizeof(Index), stream);
+    runtime.fill(contributors.data(), 0U, frames * sizeof(Index), stream);
+    runtime.fill(earliest.data(), 0xFFU, frames * sizeof(Index), stream);
+    runtime.fill(latest.data(), 0U, frames * sizeof(Index), stream);
+  }
+  [[nodiscard]] Round view()
+  {
+    return {
+      .bestExcess = bestExcess.data(),
+      .bestIndex = bestIndex.data(),
+      .centre = centre.data(),
+      .contributors = contributors.data(),
+      .earliest = earliest.data(),
+      .latest = latest.data(),
+    };
+  }
+};
+
+} // namespace
+} // namespace detail
+
+/// The vertices of the pass's \a tripletCount triplets on \a measurements,
+/// \a rows of them, into \a result (`DeviceTracker::findVertices`); \a pass
+/// the pass's parameters on the device, for the candidates' errors; the
+/// vertices of \a owned's frames, a slice's, as `Vertexer::find` finds them.
+/// Its arrays on the base end, in the caller's scope; kOutOfMemory if the
+/// arena refuses.
+template <DetectorLayout Det>
+[[nodiscard]] StageStatus findVertices(DeviceRuntime& runtime, DeviceArena& arena, DeviceStream& stream, MeasurementView measurements, Index rows, TrackletConstView tracklets, TripletConstView triplets, Index tripletCount, const IterationParameters<Det>* pass, const VertexerSettings& settings, const VertexConstraint& beamSpot, const OwnedFrames& owned, VertexerResult& result)
+{
+  using namespace detail;
+  result = {};
+  result.triplets = tripletCount;
+  if (tripletCount == 0U) {
+    return StageStatus::kComplete;
+  }
+  // Candidates.
+  DeviceSpan<std::uint64_t> keys;
+  DeviceSpan<std::uint64_t> sourceKeys;
+  DeviceSpan<float> chi2;
+  DeviceSpan<std::uint64_t> weights;
+  DeviceSpan<Index> lower;
+  DeviceSpan<Index> upper;
+  if (!keys.allocate(arena, tripletCount) || !sourceKeys.allocate(arena, tripletCount) || !chi2.allocate(arena, tripletCount) || !weights.allocate(arena, tripletCount) || !lower.allocate(arena, tripletCount) || !upper.allocate(arena, tripletCount)) {
+    return StageStatus::kOutOfMemory;
+  }
+  algorithms::forEach(runtime, stream, tripletCount,
+                      CandidateMap<Det>{
+                        .measurements = measurements,
+                        .tracklets = tracklets,
+                        .triplets = triplets,
+                        .settings = settings,
+                        .pass = pass,
+                        .varTransverse = static_cast<float>(beamSpot.sigmaTransverse * beamSpot.sigmaTransverse),
+                        .keys = keys.data(),
+                        .sourceKeys = sourceKeys.data(),
+                        .chi2 = chi2.data(),
+                        .weights = weights.data(),
+                        .lower = lower.data(),
+                        .upper = upper.data(),
+                      });
+  DeviceSpan<Index> accepted;
+  Index acceptedCount = 0U;
+  StageStatus status = algorithms::selectIndices(runtime, arena, stream, tripletCount, Accepted{keys.data()}, accepted, acceptedCount);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  result.accepted = acceptedCount;
+  if (acceptedCount == 0U) {
+    return StageStatus::kComplete;
+  }
+
+  // The deduplication: rounds of bids until
+  // every accepted candidate is kept or dropped -- the host's greedy pass in
+  // chi2 order, since a candidate is kept only when nothing before it is left
+  // on any of its rows.
+  DeviceSpan<std::uint8_t> state;
+  DeviceSpan<std::uint64_t> slots;
+  DeviceSpan<std::uint8_t> taken;
+  if (!state.allocate(arena, acceptedCount) || !slots.allocate(arena, rows) || !taken.allocate(arena, rows)) {
+    return StageStatus::kOutOfMemory;
+  }
+  runtime.fill(state.data(), kLive, acceptedCount, stream);
+  runtime.fill(taken.data(), 0U, rows, stream);
+  const Deduplication deduplication{
+    .accepted = accepted.data(),
+    .tracklets = tracklets,
+    .triplets = triplets,
+    .chi2 = chi2.data(),
+    .state = state.data(),
+    .slots = slots.data(),
+    .taken = taken.data(),
+  };
+  const auto deduplicated = algorithms::sweepToFixedPoint<1U>(runtime, arena, stream, acceptedCount + 1U, [&](Index* changed) {
+    algorithms::forEach(runtime, stream, acceptedCount, Reopen{deduplication});
+    algorithms::forEach(runtime, stream, acceptedCount, Bid{deduplication});
+    algorithms::forEach(runtime, stream, acceptedCount, Decide{deduplication, changed});
+    algorithms::forEach(runtime, stream, acceptedCount, Drop{deduplication});
+  });
+  if (deduplicated.status != StageStatus::kComplete) {
+    return deduplicated.status;
+  }
+  DeviceSpan<Index> kept;
+  Index count = 0U;
+  status = algorithms::selectIndices(runtime, arena, stream, acceptedCount, KeptOnes{state.data(), accepted.data(), keys.data(), owned}, kept, count);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  result.candidates = count;
+  if (count == 0U) {
+    return StageStatus::kComplete;
+  }
+
+  // Order: the kept ones in triplet order, then stably by key.
+  DeviceSpan<std::uint64_t> candidateKeys;
+  DeviceSpan<Index> candidateTriplets;
+  DeviceSpan<std::uint64_t> sortedKeys;
+  DeviceSpan<Index> sortedTriplets;
+  if (!candidateKeys.allocate(arena, count) || !candidateTriplets.allocate(arena, count) || !sortedKeys.allocate(arena, count) || !sortedTriplets.allocate(arena, count)) {
+    return StageStatus::kOutOfMemory;
+  }
+  algorithms::forEach(runtime, stream, count, GatherKept{kept.data(), accepted.data(), keys.data(), candidateKeys.data(), candidateTriplets.data()});
+  status = algorithms::sortPairs(runtime, arena, stream, std::as_const(candidateKeys).data(), sortedKeys.data(), std::as_const(candidateTriplets).data(), sortedTriplets.data(), count, 64);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  DeviceSpan<long long> z;
+  DeviceSpan<Index> boxLower;
+  DeviceSpan<Index> boxUpper;
+  DeviceSpan<Index> frameStart;
+  DeviceSpan<Index> startsBefore;
+  DeviceSpan<Index> frameOf;
+  DeviceSpan<std::uint64_t> weight;
+  if (!weight.allocate(arena, count) || !z.allocate(arena, count) || !boxLower.allocate(arena, count) || !boxUpper.allocate(arena, count) || !frameStart.allocate(arena, count) || !startsBefore.allocate(arena, count) || !frameOf.allocate(arena, count)) {
+    return StageStatus::kOutOfMemory;
+  }
+  algorithms::forEach(runtime, stream, count,
+                      SortedColumns{
+                        .sortedKeys = sortedKeys.data(),
+                        .sortedTriplets = sortedTriplets.data(),
+                        .lower = lower.data(),
+                        .upper = upper.data(),
+                        .weights = weights.data(),
+                        .z = z.data(),
+                        .weight = weight.data(),
+                        .boxLower = boxLower.data(),
+                        .boxUpper = boxUpper.data(),
+                        .frameStart = frameStart.data(),
+                      });
+  DeviceSpan<Index> frameBegin;
+  Index frames = 0U;
+  status = algorithms::selectIndices(runtime, arena, stream, count, FrameStarts{frameStart.data()}, frameBegin, frames);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  status = algorithms::exclusiveScan(runtime, arena, stream, std::as_const(frameStart).data(), startsBefore.data(), count);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  algorithms::forEach(runtime, stream, count, FrameOf{frameStart.data(), startsBefore.data(), frameOf.data()});
+  const Candidates candidates{
+    .z = z.data(),
+    .weight = weight.data(),
+    .boxLower = boxLower.data(),
+    .boxUpper = boxUpper.data(),
+    .frame = frameOf.data(),
+    .frameBegin = frameBegin.data(),
+    .frames = frames,
+    .count = count,
+  };
+
+  // The ownership's sources and slots.
+  DeviceSpan<Index> sources;
+  Index sourceCount = 0U;
+  status = algorithms::selectIndices(runtime, arena, stream, tripletCount, Sources{std::as_const(sourceKeys).data(), owned}, sources, sourceCount);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  const Index slotEntries = 3U * sourceCount;
+  DeviceSpan<std::uint64_t> slotKeys;
+  DeviceSpan<std::uint64_t> sortedSlotKeys;
+  if (!slotKeys.allocate(arena, slotEntries) || !sortedSlotKeys.allocate(arena, slotEntries)) {
+    return StageStatus::kOutOfMemory;
+  }
+  algorithms::forEach(runtime, stream, sourceCount,
+                      SlotKeys{
+                        .sources = std::as_const(sources).data(),
+                        .sourceKeys = std::as_const(sourceKeys).data(),
+                        .tracklets = tracklets,
+                        .triplets = triplets,
+                        .slotKeys = slotKeys.data(),
+                      });
+  status = algorithms::sortKeys(runtime, arena, stream, std::as_const(slotKeys).data(), sortedSlotKeys.data(), slotEntries, 64);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  DeviceSpan<Index> slotStarts;
+  Index slotCount = 0U;
+  status = algorithms::selectIndices(runtime, arena, stream, slotEntries, SlotStarts{std::as_const(sortedSlotKeys).data()}, slotStarts, slotCount);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  DeviceSpan<std::uint64_t> uniqueSlots;
+  DeviceSpan<std::uint8_t> ownedSlots;
+  DeviceSpan<Index> sourceSlots;
+  DeviceSpan<long long> sourceZ;
+  DeviceSpan<Index> sourceFrame;
+  DeviceSpan<Index> candidateSlots;
+  if (!uniqueSlots.allocate(arena, slotCount) || !ownedSlots.allocate(arena, slotCount) || !sourceSlots.allocate(arena, slotEntries) || !sourceZ.allocate(arena, sourceCount) || !sourceFrame.allocate(arena, sourceCount) || !candidateSlots.allocate(arena, 3U * count)) {
+    return StageStatus::kOutOfMemory;
+  }
+  algorithms::forEach(runtime, stream, slotCount, GatherSlots{std::as_const(slotStarts).data(), std::as_const(sortedSlotKeys).data(), uniqueSlots.data()});
+  runtime.fill(ownedSlots.data(), 0U, slotCount, stream);
+  const SlotsOf slotsOf{.unique = std::as_const(uniqueSlots).data(), .slots = slotCount, .tracklets = tracklets, .triplets = triplets};
+  algorithms::forEach(runtime, stream, sourceCount,
+                      SourceColumns{
+                        .sources = std::as_const(sources).data(),
+                        .sourceKeys = std::as_const(sourceKeys).data(),
+                        .slotsOf = slotsOf,
+                        .sortedKeys = std::as_const(sortedKeys).data(),
+                        .frameBegin = std::as_const(frameBegin).data(),
+                        .frames = frames,
+                        .sourceSlots = sourceSlots.data(),
+                        .sourceZ = sourceZ.data(),
+                        .sourceFrame = sourceFrame.data(),
+                      });
+  algorithms::forEach(runtime, stream, count,
+                      CandidateSlots{
+                        .sortedKeys = std::as_const(sortedKeys).data(),
+                        .sortedTriplets = std::as_const(sortedTriplets).data(),
+                        .slotsOf = slotsOf,
+                        .candidateSlots = candidateSlots.data(),
+                      });
+
+  // Rounds: every frame at once.
+  DeviceSpan<std::int32_t> claims;
+  DeviceSpan<Index> freeCount;
+  DeviceSpan<long long> freeZ;
+  DeviceSpan<Index> countBefore;
+  DeviceSpan<long long> zBefore;
+  DeviceSpan<long long> excess;
+  const Index scanned = count + 1U;
+  if (!claims.allocate(arena, count) || !freeCount.allocate(arena, scanned) || !freeZ.allocate(arena, scanned) || !countBefore.allocate(arena, scanned) || !zBefore.allocate(arena, scanned) || !excess.allocate(arena, count)) {
+    return StageStatus::kOutOfMemory;
+  }
+  runtime.fill(claims.data(), 0xFFU, std::size_t{count} * sizeof(std::int32_t), stream);
+  const auto window = static_cast<long long>(settings.windowUM);
+  const auto claim = static_cast<long long>(settings.claimUM);
+  const Scalar k2 = 2.F * settings.significance * settings.significance;
+  std::vector<RoundStorage> rounds;
+  bool outOfMemory = false;
+  // One sweep of rounds to the fixed point at \a minContributors, the frames
+  // \a skipped marks (if given) left alone.
+  const auto sweep = [&](Index minContributors, const std::uint8_t* skipped) {
+    return algorithms::sweepToFixedPoint<1U>(runtime, arena, stream, count + 1U, [&](Index* changed) {
+      if (outOfMemory) {
+        return;
+      }
+      auto& round = rounds.emplace_back();
+      if (!round.allocate(arena, frames)) {
+        outOfMemory = true;
+        return;
+      }
+      round.reset(runtime, stream, frames);
+      const auto roundView = round.view();
+      algorithms::forEach(runtime, stream, scanned, FreeColumns{candidates, std::as_const(claims).data(), freeCount.data(), freeZ.data()});
+      if (algorithms::exclusiveScan(runtime, arena, stream, std::as_const(freeCount).data(), countBefore.data(), scanned) != StageStatus::kComplete || algorithms::exclusiveScan(runtime, arena, stream, std::as_const(freeZ).data(), zBefore.data(), scanned) != StageStatus::kComplete) {
+        outOfMemory = true;
+        return;
+      }
+      algorithms::forEach(runtime, stream, count,
+                          Score{
+                            .candidates = candidates,
+                            .claims = std::as_const(claims).data(),
+                            .countBefore = std::as_const(countBefore).data(),
+                            .window = window,
+                            .claim = claim,
+                            .minContributors = minContributors,
+                            .k2 = k2,
+                            .skipped = skipped,
+                            .excess = excess.data(),
+                            .round = roundView,
+                          });
+      algorithms::forEach(runtime, stream, count, Pick{candidates, std::as_const(excess).data(), roundView});
+      algorithms::forEach(runtime, stream, frames, Centre{candidates, std::as_const(countBefore).data(), std::as_const(zBefore).data(), window, roundView, changed});
+      algorithms::forEach(runtime, stream, count,
+                          Claim{
+                            .candidates = candidates,
+                            .claims = claims.data(),
+                            .claim = static_cast<float>(claim),
+                            .vertexBase = static_cast<std::int32_t>((rounds.size() - 1U) * frames),
+                            .round = roundView,
+                          });
+      algorithms::forEach(runtime, stream, sourceCount,
+                          Own{
+                            .sourceSlots = std::as_const(sourceSlots).data(),
+                            .sourceZ = std::as_const(sourceZ).data(),
+                            .sourceFrame = std::as_const(sourceFrame).data(),
+                            .ownedSlots = ownedSlots.data(),
+                            .claim = static_cast<float>(claim),
+                            .round = roundView,
+                          });
+      algorithms::forEach(runtime, stream, count, DropOwned{std::as_const(candidateSlots).data(), std::as_const(ownedSlots).data(), claims.data()});
+    });
+  };
+  const auto swept = sweep(settings.minContributors, nullptr);
+  if (swept.status != StageStatus::kComplete) {
+    return swept.status;
+  }
+  if (outOfMemory) {
+    return StageStatus::kOutOfMemory;
+  }
+  // The frames left without a vertex, again at the lower minimum; the others
+  // skipped. The rounds go on numbering the vertices after the first sweep's.
+  if (settings.aloneMinContributors != 0U && settings.aloneMinContributors < settings.minContributors) {
+    DeviceSpan<std::uint8_t> withVertex;
+    if (!withVertex.allocate(arena, frames)) {
+      return StageStatus::kOutOfMemory;
+    }
+    runtime.fill(withVertex.data(), 0U, frames, stream);
+    algorithms::forEach(runtime, stream, count, FramesWithVertex{candidates, std::as_const(claims).data(), withVertex.data()});
+    const auto rerun = sweep(settings.aloneMinContributors, std::as_const(withVertex).data());
+    if (rerun.status != StageStatus::kComplete) {
+      return rerun.status;
+    }
+    if (outOfMemory) {
+      return StageStatus::kOutOfMemory;
+    }
+  }
+
+  // Each vertex's selection, grown from its core: one slot per vertex number,
+  // round * frames + frame.
+  const std::size_t found = rounds.size() - 1U; // the last round found nothing (a rerun's: the first sweep's last too)
+  const auto vertexSlots = static_cast<Index>(found * frames);
+  DeviceSpan<float> centres;
+  DeviceSpan<std::uint8_t> selected;
+  DeviceSpan<Counter> selectedWeightSum;
+  DeviceSpan<Counter> selectedWeightedZSum;
+  DeviceSpan<Counter> selectedScatterSum;
+  DeviceSpan<Counter> selectedCount;
+  DeviceSpan<float> mean;
+  DeviceSpan<float> varMean;
+  if (vertexSlots != 0U) {
+    if (!centres.allocate(arena, vertexSlots) || !selected.allocate(arena, count) || !selectedWeightSum.allocate(arena, vertexSlots) || !selectedWeightedZSum.allocate(arena, vertexSlots) || !selectedScatterSum.allocate(arena, vertexSlots) || !selectedCount.allocate(arena, vertexSlots) || !mean.allocate(arena, vertexSlots) || !varMean.allocate(arena, vertexSlots)) {
+      return StageStatus::kOutOfMemory;
+    }
+    for (std::size_t r = 0; r < found; ++r) {
+      runtime.copyOnDevice(centres.data() + (r * frames), std::as_const(rounds[r].centre).data(), frames * sizeof(float), stream);
+    }
+    runtime.fill(selected.data(), 0U, count, stream);
+    runtime.fill(selectedWeightSum.data(), 0U, vertexSlots * sizeof(Counter), stream);
+    runtime.fill(selectedWeightedZSum.data(), 0U, vertexSlots * sizeof(Counter), stream);
+    runtime.fill(selectedScatterSum.data(), 0U, vertexSlots * sizeof(Counter), stream);
+    runtime.fill(selectedCount.data(), 0U, vertexSlots * sizeof(Counter), stream);
+    const Selection selection{
+      .candidates = candidates,
+      .claims = std::as_const(claims).data(),
+      .selected = selected.data(),
+      .weightSum = selectedWeightSum.data(),
+      .weightedZSum = selectedWeightedZSum.data(),
+      .scatterSum = selectedScatterSum.data(),
+      .count = selectedCount.data(),
+      .mean = mean.data(),
+      .varMean = varMean.data(),
+    };
+    algorithms::forEach(runtime, stream, count, CoreStart{selection, std::as_const(centres).data(), static_cast<float>(window)});
+    algorithms::forEach(runtime, stream, vertexSlots, Moments{selection});
+    const auto grown = algorithms::sweepToFixedPoint<1U>(runtime, arena, stream, count + 1U, [&](Index* changed) {
+      algorithms::forEach(runtime, stream, count, Grow{selection, settings.clipNSigma, changed});
+      algorithms::forEach(runtime, stream, vertexSlots, Moments{selection});
+    });
+    if (grown.status != StageStatus::kComplete) {
+      return grown.status;
+    }
+    // The sweep ends on Moments, so the means are the settled selection's.
+    algorithms::forEach(runtime, stream, count, Scatter{selection});
+  }
+
+  // Seeds: the sums back, the seeds and each frame's order on the host.
+  std::vector<Index> bestIndex(found * frames);
+  std::vector<Index> contributors(found * frames);
+  std::vector<Counter> weightSum(found * frames);
+  std::vector<Counter> weightedZSum(found * frames);
+  std::vector<Counter> scatterSum(found * frames);
+  std::vector<Counter> members(found * frames);
+  std::vector<Index> earliest(found * frames);
+  std::vector<Index> latest(found * frames);
+  for (std::size_t r = 0; r < found; ++r) {
+    const std::size_t at = r * frames;
+    download(rounds[r].bestIndex, bestIndex.data() + at, frames, stream);
+    download(rounds[r].contributors, contributors.data() + at, frames, stream);
+    download(rounds[r].earliest, earliest.data() + at, frames, stream);
+    download(rounds[r].latest, latest.data() + at, frames, stream);
+  }
+  if (vertexSlots != 0U) {
+    download(selectedWeightSum, weightSum.data(), vertexSlots, stream);
+    download(selectedWeightedZSum, weightedZSum.data(), vertexSlots, stream);
+    download(selectedScatterSum, scatterSum.data(), vertexSlots, stream);
+    download(selectedCount, members.data(), vertexSlots, stream);
+  }
+  stream.synchronize();
+  std::uint32_t mostInFrame = 0U;
+  for (Index f = 0; f < frames; ++f) {
+    struct Found {
+      VertexSeed seed;
+      Index contributors = 0U;
+    };
+    std::vector<Found> inFrame;
+    for (std::size_t r = 0; r < found; ++r) {
+      const std::size_t at = (r * frames) + f;
+      if (bestIndex[at] == kNoIndex) {
+        continue;
+      }
+      const VertexClaim sums{
+        .weightSum = static_cast<std::uint64_t>(weightSum[at]),
+        .weightedZSum = static_cast<std::int64_t>(weightedZSum[at]),
+        .scatterSum = static_cast<std::uint64_t>(scatterSum[at]),
+        .count = static_cast<std::int64_t>(members[at]),
+        .earliestPS = earliest[at],
+        .latestPS = latest[at],
+      };
+      inFrame.push_back({.seed = vertexSeedOf(sums, beamSpot), .contributors = contributors[at]});
+    }
+    mostInFrame = std::max(mostInFrame, static_cast<std::uint32_t>(inFrame.size()));
+    std::ranges::stable_sort(inFrame, {}, [](const Found& vertex) { return vertex.seed.z; });
+    for (const auto& vertex : inFrame) {
+      result.vertices.push_back(vertex.seed);
+      result.contributors.push_back(vertex.contributors);
+    }
+  }
+  result.rounds = mostInFrame + 1U;
+  return StageStatus::kComplete;
+}
+
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE::vertex_glue
+
+#endif // GTRK_TRACKING_GPU_VERTEXGLUE_CUH_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/BeamConstraint.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/BeamConstraint.h
new file mode 100644
index 0000000000000..41440f07c7c2b
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/BeamConstraint.h
@@ -0,0 +1,179 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file BeamConstraint.h
+/// \brief The beam line as a measurement of a state inside the tracker.
+///
+/// A road on the outer layers measures the curvature over a short lever arm;
+/// the beam line, for a primary, adds the longest one. The beam point is
+/// taken as a measurement of the state on the road's innermost surface, of
+/// one coordinate: the transverse distance of closest approach, d0. Its
+/// prediction is the state carried to the plane through the beam line normal
+/// to the track's direction there (loc0 along the transverse normal: d0;
+/// loc1 along the beam: z0), and its variance is the beam's width squared
+/// plus the scattering between: a kink theta_k at distance s_k from the beam
+/// moves the d0 the state predicts by theta_k s_k, so the sum
+/// `sum_k theta_k^2 s_k^2` over the layers and the passive scatterers inside,
+/// and the surface's own layer, as the pair windows take it
+/// (`sourceScattering`), at the track's own momentum. The update is the
+/// Kalman update of that one coordinate, made on the surface: the scattering
+/// between is in the measurement's variance, not in the state's.
+///
+/// z0 is left out: the beam spot's length, centimetres, constrains nothing
+/// the road does not.
+
+#ifndef GTRK_TRACKING_BEAMCONSTRAINT_H_
+#define GTRK_TRACKING_BEAMCONSTRAINT_H_
+
+#include "GenericTracking/Tracking/BoundTrackState.h"
+#include "GenericTracking/Tracking/CovarianceTransport.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/Material.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tracking/Trig.h"
+
+#include "GPUCommonMath.h"
+#include "MathUtils/detail/trigonometric.h"
+
+namespace o2::gtrk
+{
+
+/// What the beam-line update gave: whether it could be made, and its chi2,
+/// one degree of freedom.
+struct BeamLineUpdate {
+  bool ok = false;
+  Scalar chi2 = 0.F;
+  Scalar residual = 0.F;   ///< the beam's d0 less the prediction's [cm]
+  Scalar variance = 0.F;   ///< the residual's [cm^2]
+  Scalar scattering = 0.F; ///< of which the scattering between [cm^2]
+};
+
+/// The direction [rad] of a bound state's helix at its transverse closest
+/// approach to the z axis, without a virtual beam-line surface.
+///
+/// With A = r.dot(direction) and B = r.dot(leftNormal), closest approach obeys
+///
+///   kappa A cos(psi) + (1 + kappa B) sin(psi) = 0,
+///
+/// solved for the turn psi; at zero curvature it is 0.
+template <typename Prop>
+[[nodiscard]] GPUdi() Scalar perigeePhi(const Prop& prop, const BoundTrackState& state, const TrackingSurface& surface)
+{
+  ExactScalar position[3]{};
+  detail::boundToGlobal(surface, static_cast<ExactScalar>(state.loc0()), static_cast<ExactScalar>(state.loc1()), position);
+
+  const auto phi = static_cast<ExactScalar>(state.phi());
+  const auto theta = static_cast<ExactScalar>(state.theta());
+  ExactScalar sinPhi = 0.;
+  ExactScalar cosPhi = 0.;
+  ExactScalar sinTheta = 0.;
+  ExactScalar cosTheta = 0.;
+  sincosOf(phi, sinPhi, cosPhi);
+  sincosOf(theta, sinTheta, cosTheta);
+
+  const ExactScalar curvature = pointPropagator(prop, surface, state).curvature(static_cast<ExactScalar>(state.qOverP()), sinTheta);
+  const ExactScalar along = position[0] * cosPhi + position[1] * sinPhi;
+  const ExactScalar across = -position[0] * sinPhi + position[1] * cosPhi;
+  const ExactScalar numerator = -curvature * along;
+  const ExactScalar denominator = 1. + curvature * across;
+  const ExactScalar turn = atan2Of(numerator, denominator);
+  ExactScalar phi0 = phi + turn;
+  math_utils::detail::bringToPMPi<ExactScalar>(phi0);
+  return static_cast<Scalar>(phi0);
+}
+
+/// The plane through the beam line at (\a x, \a y) normal to the transverse
+/// direction \a phi: loc0 the signed transverse distance along
+/// (-sin phi, cos phi), at closest approach the track's d0, loc1 z. It is no
+/// sensor: its
+/// bounds are empty, and the update takes the propagation's out-of-bounds
+/// status as a crossing.
+GPUhdi() GPUAlwaysInline() TrackingSurface beamLinePlane(Scalar x, Scalar y, Scalar phi)
+{
+  Scalar sinPhi = 0.F;
+  Scalar cosPhi = 0.F;
+  sincosOf(phi, sinPhi, cosPhi);
+  TrackingSurface plane;
+  plane.origin[0] = x;
+  plane.origin[1] = y;
+  plane.axis0[0] = -sinPhi;
+  plane.axis0[1] = cosPhi;
+  plane.axis1[2] = 1.F;
+  plane.normal[0] = cosPhi;
+  plane.normal[1] = sinPhi;
+  return plane;
+}
+
+/// \a state, on \a surface of layer \a layer, updated with the iteration's
+/// beam line; \a innermost is the state's measurement as the pair cut reads
+/// it (the corrected beam frame), whose line from the track's z0 sets the
+/// scattering's path. The state is left as it was if the update cannot be
+/// made: the propagation to the plane failed, or the residual's variance is
+/// not positive. \a scatteringScale multiplies the scattering term: 1 but
+/// for the kink allowance.
+template <DetectorLayout Det>
+GPUdi() BeamLineUpdate updateWithBeamLine(const Propagator& prop, const IterationParameters<Det>& parameters, const TrackingSurface& surface, LayerID layer, const PairPoint& innermost, BoundTrackState& state, Scalar scatteringScale = 1.F)
+{
+  using Math = o2::gpu::GPUCommonMath;
+  BeamLineUpdate result;
+  const auto plane = beamLinePlane(parameters.beamX, parameters.beamY, perigeePhi(prop, state, surface));
+  SolenoidJacobian jacobian;
+  BoundTrackState predicted;
+  const auto status = jacobianAnalytic(prop, state, surface, plane, PropagationDirection::kBackward, jacobian, &predicted);
+  if (status != PropagationStatus::kOk && status != PropagationStatus::kOutOfBounds) {
+    return result;
+  }
+
+  Scalar sinTheta = 0.F;
+  Scalar cosTheta = 0.F;
+  sincosOf(state.theta(), sinTheta, cosTheta);
+  const Scalar betaPT = betaMomentum(1.F / Math::Abs(state.qOverP()), prop.massGeV) * Math::Abs(sinTheta);
+  PairCut ownMomentum;
+  ownMomentum.invBetaMomentum2 = 1.F / (betaPT * betaPT);
+  const VertexSeed origin{.z = predicted.loc1()};
+  const Scalar scattering = scatteringScale * sourceScattering<Det>(parameters.scattering, ownMomentum, origin, layer, innermost);
+
+  // H is the Jacobian's loc0 row; u = C H^T, s = H C H^T + V. In double: the
+  // update subtracts u u^T / s from a covariance whose entries span orders of
+  // magnitude.
+  ExactScalar u[kNBoundParams]{};
+  for (int i = 0; i < kNBoundParams; ++i) {
+    for (int j = 0; j < kNBoundParams; ++j) {
+      u[i] += static_cast<ExactScalar>(state.covAt(i, j)) * static_cast<ExactScalar>(jacobian.loc0[j]);
+    }
+  }
+  ExactScalar variance = static_cast<ExactScalar>(parameters.beamVarTransverse) + static_cast<ExactScalar>(scattering);
+  for (int j = 0; j < kNBoundParams; ++j) {
+    variance += static_cast<ExactScalar>(jacobian.loc0[j]) * u[j];
+  }
+  if (!(variance > 0.)) {
+    return result;
+  }
+  const auto residual = -static_cast<ExactScalar>(predicted.loc0());
+  for (int i = 0; i < kNBoundParams; ++i) {
+    state.par[i] = static_cast<Scalar>(static_cast<ExactScalar>(state.par[i]) + (u[i] * residual / variance));
+    for (int j = 0; j <= i; ++j) {
+      state.covAt(i, j) = static_cast<Scalar>(static_cast<ExactScalar>(state.covAt(i, j)) - (u[i] * u[j] / variance));
+    }
+  }
+  result.ok = true;
+  result.chi2 = static_cast<Scalar>(residual * residual / variance);
+  result.residual = static_cast<Scalar>(residual);
+  result.variance = static_cast<Scalar>(variance);
+  result.scattering = scattering;
+  return result;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_BEAMCONSTRAINT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/BoundTrackState.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/BoundTrackState.h
new file mode 100644
index 0000000000000..dcb97a509b895
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/BoundTrackState.h
@@ -0,0 +1,102 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file BoundTrackState.h
+/// \brief Five parameters and their covariance, bound to one sensor plane.
+///
+/// This is data and nothing else.  It has no opinion about how it moves; that
+/// belongs to the propagator, a separate type.  Free functions propagate and update it; its
+/// members are accessors and `decorrelate`, so the record can be copied into
+/// device memory.
+
+#ifndef GTRK_TRACKING_BOUNDTRACKSTATE_H_
+#define GTRK_TRACKING_BOUNDTRACKSTATE_H_
+
+#include "GenericTracking/Base/Definitions.h"
+#include "GenericTracking/Tracking/Definitions.h"
+
+namespace o2::gtrk
+{
+
+/// A track state on a sensor plane: the five geometric parameters. A track's
+/// time is its rows' box, kept beside it.
+///
+/// The plane is the sensor `surface` names; on a curved sensor it is the
+/// sensor's tangent plane at the sensor-local angle `surfacePhi`
+/// (TrackingGeometry::planeOf). That angle
+/// names the frame, it is not a parameter: an update leaves it alone, and it
+/// has no covariance. On a flat sensor it is 0.
+struct BoundTrackState {
+  Scalar par[kNBoundParams]{};         ///< loc0, loc1, phi, theta, q/p
+  Scalar cov[kBoundCovSize]{};         ///< packed lower triangle; see covIndex()
+  SensorID surface = kInvalidSensorID; ///< the sensor these parameters are bound to
+  Scalar surfacePhi = 0.F;             ///< a curved sensor's tangent plane: its angle in the sensor [rad]
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar loc0() const { return par[kLoc0]; }
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar loc1() const { return par[kLoc1]; }
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar phi() const { return par[kPhi]; }
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar theta() const { return par[kTheta]; }
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar qOverP() const { return par[kQOverP]; }
+
+  /// Covariance element (i, j).  Symmetric, so the caller never has to order
+  /// the indices.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar covAt(int i, int j) const { return cov[covIndex(i, j)]; }
+  GPUhdi() GPUAlwaysInline() Scalar& covAt(int i, int j) { return cov[covIndex(i, j)]; }
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar variance(int i) const { return cov[varIndex(i)]; }
+  GPUhdi() GPUAlwaysInline() Scalar& variance(int i) { return cov[varIndex(i)]; }
+
+  /// Drop the covariances of parameters \a a and \a b with every other
+  /// parameter; their variances and the rest stay.
+  GPUhdi() GPUAlwaysInline() void decorrelate(int a, int b)
+  {
+    for (int i = 0; i < kNBoundParams; ++i) {
+      if (i != a) {
+        covAt(i, a) = 0.F;
+      }
+      if (i != b) {
+        covAt(i, b) = 0.F;
+      }
+    }
+  }
+};
+
+// Its bytes are its value: a record copies and compares it as bytes
+// (Study/StageComparison.h).
+static_assert(sizeof(BoundTrackState) == (sizeof(Scalar) * (kNBoundParams + kBoundCovSize + 1)) + sizeof(SensorID), "a state has no padding");
+
+/// A state's covariance as P = U D U^T: U unit upper triangular, of which the
+/// strict upper triangle is stored (MathUtils.h, strictUpperIndex), and D
+/// diagonal. A filter pass carries its covariance in this form from one
+/// update to the next: the step's prediction is formed on the factors
+/// (transportFactors) and the update updates them (updateWithMeasurement), so
+/// no predicted P is ever rounded to float. Rounding it loses the variance a
+/// precise measurement leaves once a diffuse direction is carried over a long
+/// lever arm.
+struct CovarianceFactors {
+  Scalar upper[kBoundUpperSize]{};
+  Scalar diagonal[kNBoundParams]{};
+};
+
+/// Whether every factor in D is positive; written so that NaN fails, without
+/// an algorithm device code lacks.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool positiveDiagonal(const CovarianceFactors& factors)
+{
+  bool positive = true;
+  for (const Scalar d : factors.diagonal) {
+    positive = positive && d > 0.F;
+  }
+  return positive;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_BOUNDTRACKSTATE_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/CovarianceTransport.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/CovarianceTransport.h
new file mode 100644
index 0000000000000..30a4ebcc86ee9
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/CovarianceTransport.h
@@ -0,0 +1,339 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CovarianceTransport.h
+/// \brief The analytic Jacobian of a uniform-solenoid step, and the predicted
+///        covariance F (P + Q) F^T + Q on the covariance's U D U^T factors.
+
+#ifndef GTRK_TRACKING_COVARIANCETRANSPORT_H_
+#define GTRK_TRACKING_COVARIANCETRANSPORT_H_
+
+#include "GenericTracking/Base/Definitions.h"
+#include "GenericTracking/Tracking/BoundTrackState.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/MathUtils.h"
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Tracking/Trig.h"
+
+#include "CommonConstants/MathConstants.h"
+
+#include <type_traits>
+
+namespace o2::gtrk
+{
+
+/// The non-trivial part of a uniform-solenoid Jacobian: fifteen numbers, not
+/// twenty-five.
+///
+/// In a purely longitudinal field theta and q/p are conserved, so their rows
+/// are unit vectors. Those ten entries are constants.
+///
+/// They are omitted as a *type*, not as a convention. A field with transverse
+/// components turns theta, so a field-map propagator's Jacobian is dense --
+/// and handing one to a transport that assumes these zeros would be silently
+/// wrong in the covariance while looking perfectly healthy. Making it
+/// unrepresentable is the cheapest enforcement available.
+struct SolenoidJacobian {
+  Scalar loc0[kNBoundParams]{}; ///< d(loc0') / d(loc0, loc1, phi, theta, q/p)
+  Scalar loc1[kNBoundParams]{};
+  Scalar phi[kNBoundParams]{};
+};
+
+/// A step's process noise, as variances, in the order a filter step adds it:
+/// the multiple scattering of the material nearer the surface left, before
+/// the transport, and that of the rest after it (TrackFitter.h,
+/// StepMaterial); then the energy-loss straggling on q/p.
+struct StepNoise {
+  Scalar phiBefore = 0.F;   ///< theta0^2 / sin^2(theta) of the nearer half
+  Scalar thetaBefore = 0.F; ///< theta0^2 of the nearer half
+  Scalar phiAfter = 0.F;    ///< the same, the farther half
+  Scalar thetaAfter = 0.F;
+  Scalar qOverPAfter = 0.F; ///< the straggling's q/p variance
+};
+
+/// The predicted covariance F (P + Q_before) F^T + Q_after of a step, on
+/// \a factors in place: P's factors in, the prediction's out, P never formed
+/// (Thornton's half of the Bierman-Thornton filter). False if \a factors are
+/// not those of a positive-definite covariance, or a pivot of the result is
+/// not positive (NaN included).
+///
+/// The prediction is a sum of weighted outer products, P' = sum_k w_k y_k
+/// y_k^T. Each y_k, a *column*, is a five-vector with its variance w_k:
+///
+///   - 0-4, the transported factors: F u_k, u_k U's k-th column, with D_k;
+///   - 5, 6, the nearer half's noise on phi and theta, transported: F e_phi
+///     and F e_theta, F's phi and theta columns;
+///   - 7, 8, the farther half's: e_phi and e_theta;
+///   - the straggling, e_q/p.
+///
+/// Modified weighted Gram-Schmidt turns them into the five of P' = U' D' U'^T,
+/// from q/p, the last row, to loc0: each row's D' is its weighted norm, and
+/// the rows before it are made orthogonal to it (U' the projections). Every
+/// D' is a sum of positive terms, so a small conditional variance -- loc1
+/// given theta, once a precise measurement has fixed loc1 and a diffuse
+/// theta is carried over a long lever arm -- comes out to float's relative
+/// precision on itself, where forming P' would round it against the
+/// variance of loc1 alone.
+///
+/// The structure is used: theta and q/p are conserved, so their rows of F U
+/// are U's own, almost empty, and the two are reduced in closed form. q/p's
+/// straggling column and the transported factor column 4 are both
+/// proportional to that column after the q/p row, so they merge into one
+/// column of weight D_4 s / (D_4 + s); without straggling it drops out.
+GPUhdi() bool transportFactors(const SolenoidJacobian& jac, const StepNoise& noise, CovarianceFactors& factors)
+{
+  using detail::strictUpperIndex;
+  if (!positiveDiagonal(factors)) {
+    return false;
+  }
+  const Scalar* rows[3] = {jac.loc0, jac.loc1, jac.phi};
+  // The three dense rows (loc0, loc1, phi) of the columns; column 7 is e_phi,
+  // nonzero in phi's row only until the phi row fills the others.
+  constexpr int kColumns = 9;
+  Scalar y[3][kColumns]{};
+  Scalar w[kColumns]{};
+  for (int r = 0; r < 3; ++r) {
+    for (int k = 0; k < kNBoundParams; ++k) {
+      Scalar value = rows[r][k];
+      for (int l = 0; l < k; ++l) {
+        value += rows[r][l] * factors.upper[strictUpperIndex(l, k)];
+      }
+      y[r][k] = value;
+    }
+    y[r][5] = rows[r][kPhi];
+    y[r][6] = rows[r][kTheta];
+  }
+  y[kPhi][7] = 1.F;
+  for (int k = 0; k < kNBoundParams; ++k) {
+    w[k] = factors.diagonal[k];
+  }
+  w[5] = noise.phiBefore;
+  w[6] = noise.thetaBefore;
+  w[7] = noise.phiAfter;
+  w[8] = noise.thetaAfter;
+
+  // q/p: its row is e_q/p in column 4 and the straggling's. Its rows above
+  // project by D_4 / D_4', and column 4 keeps the merged weight.
+  const Scalar thetaQOverP = factors.upper[strictUpperIndex(kTheta, kQOverP)];
+  const Scalar dQOverP = factors.diagonal[kQOverP] + noise.qOverPAfter;
+  const Scalar kept = factors.diagonal[kQOverP] / dQOverP;
+  w[kQOverP] = noise.qOverPAfter * kept;
+  factors.diagonal[kQOverP] = dQOverP;
+  for (int r = 0; r < 3; ++r) {
+    factors.upper[strictUpperIndex(r, kQOverP)] = y[r][kQOverP] * kept;
+  }
+  factors.upper[strictUpperIndex(kTheta, kQOverP)] = thetaQOverP * kept;
+
+  // theta: its row is 1 in columns 3, 6 and 8 and U's theta-q/p entry in 4.
+  const Scalar weighted4 = thetaQOverP * w[kQOverP];
+  const Scalar dTheta = w[kTheta] + (thetaQOverP * weighted4) + w[6] + w[8];
+  if (!(dTheta > 0.F)) {
+    return false;
+  }
+  factors.diagonal[kTheta] = dTheta;
+  const Scalar inverseTheta = 1.F / dTheta;
+  for (int r = 0; r < 3; ++r) {
+    const Scalar u = ((y[r][kTheta] * w[kTheta]) + (y[r][kQOverP] * weighted4) + (y[r][6] * w[6])) * inverseTheta;
+    factors.upper[strictUpperIndex(r, kTheta)] = u;
+    y[r][kTheta] -= u;
+    y[r][kQOverP] -= u * thetaQOverP;
+    y[r][6] -= u;
+    y[r][8] = -u;
+  }
+
+  // phi, loc1, loc0: dense rows.
+  for (int j = 2; j >= 0; --j) {
+    Scalar weighted[kColumns];
+    Scalar dj = 0.F;
+    for (int k = 0; k < kColumns; ++k) {
+      weighted[k] = w[k] * y[j][k];
+      dj += y[j][k] * weighted[k];
+    }
+    if (!(dj > 0.F)) {
+      return false;
+    }
+    factors.diagonal[j] = dj;
+    const Scalar inverse = 1.F / dj;
+    for (int i = 0; i < j; ++i) {
+      Scalar dot = 0.F;
+      for (int k = 0; k < kColumns; ++k) {
+        dot += y[i][k] * weighted[k];
+      }
+      const Scalar u = dot * inverse;
+      factors.upper[strictUpperIndex(i, j)] = u;
+      for (int k = 0; k < kColumns; ++k) {
+        y[i][k] -= u * y[j][k];
+      }
+    }
+  }
+  return true;
+}
+
+/// Analytic Jacobian of a propagation, evaluated at a **reference** state.
+///
+/// The reference, not the filtered state. A Kalman filter that linearises
+/// about its own estimate is an *extended* filter, and its linearisation point
+/// carries whatever error the filter currently has; linearising about a
+/// reference trajectory - O2 does this with the `linRef` overload of
+/// `PropagatorImpl::PropagateToXBxByBz` - keeps F and Q independent of the
+/// measurements. For a two-pass fit that is a correctness property rather than
+/// a refinement: the outward and inward passes then see *identical* F and Q
+/// for the same physical step, which is what lets them be combined.
+///
+/// Unlike O2 we do not also transport the state through the reference. O2
+/// writes `state = ref + F (state - ref)` because its exact propagation is a
+/// stepped field integration and doing it once for the reference is a real
+/// saving. Ours is a closed form, so linearising the state would trade
+/// accuracy for a speed-up we do not need.
+///
+/// The derivation, for a uniform Bz. With `b = Bz * B2C` and `kp = (q/p) b`,
+/// the turn angle is `psi = kp * s` - **independent of theta**, because the
+/// 1/sin(theta) in the curvature cancels the sin(theta) in the transverse path.
+/// That is what keeps this tractable. Writing `u = (cos phi, sin phi, 0)`,
+/// `w = (-sin phi, cos phi, 0)`, `Sh = s sinc(psi)` and `Ch = s versine(psi)`,
+/// the displacement at fixed path length is
+///
+///     dr = sin(theta) (Sh u + Ch w) + s cos(theta) zhat
+///
+/// and the five geometric derivatives at fixed s follow by inspection. The
+/// path length itself moves with the source parameters, because the target is
+/// a surface rather than a fixed s; differentiating `n . (r(s) - O) = 0` gives
+/// `ds/dx = -(n . dr/dx) / (n . D)`, which is the term that couples every row.
+///
+/// \a T controls the transient derivative arithmetic. The propagated path,
+/// input state and stored Jacobian are Scalar; ExactScalar is retained as a
+/// host-side validation oracle while the device path uses the Scalar default.
+template <typename T = Scalar, CrossingRule Rule = CrossingRule::kFirstAhead>
+GPUdi() PropagationStatus jacobianAnalytic(const Propagator& prop, const BoundTrackState& reference, const TrackingSurface& from, const TrackingSurface& to, PropagationDirection dir, SolenoidJacobian& jac, BoundTrackState* propagatedState = nullptr, PropagationResult* propagatedResult = nullptr)
+{
+  using Math = o2::gpu::GPUCommonMath;
+
+  // The reference is propagated exactly; its path length and arrival
+  // direction are what everything below is evaluated at.
+  BoundTrackState at = reference;
+  detail::PropagationTrig direction;
+  const auto res = propagate<Rule>(prop, at, from, to, dir, &direction);
+  if (res.status != PropagationStatus::kOk && res.status != PropagationStatus::kOutOfBounds) {
+    return res.status;
+  }
+
+  const auto s = static_cast<T>(res.pathLength);
+  const auto phi = static_cast<T>(reference.phi());
+  const auto qOverP = static_cast<T>(reference.qOverP());
+
+  // The solve's own FP64 direction, narrowed: the Jacobian is evaluated where
+  // the propagation went.
+  const T sinPhi = static_cast<T>(direction.sinPhi);
+  const T cosPhi = static_cast<T>(direction.cosPhi);
+  const T sinTheta = static_cast<T>(direction.sinTheta);
+  const T cosTheta = static_cast<T>(direction.cosTheta);
+
+  const T bField = static_cast<T>(prop.bzKiloGauss) * static_cast<T>(constants::math::B2C);
+  const T kp = qOverP * bField;
+  const T psi = kp * s;
+
+  const T u[3] = {cosPhi, sinPhi, T(0)};
+  const T w[3] = {-sinPhi, cosPhi, T(0)};
+  const T sh = s * sinc<T>(psi);
+  const T ch = s * versine<T>(psi);
+
+  T sinPhi1 = T(0);
+  T cosPhi1 = T(0);
+  if constexpr (std::is_same_v<T, Scalar>) {
+    // Propagation already rotated this direction for its incidence test.
+    // Reuse it rather than reevaluating the rounded arrival angle, on the
+    // host and on the devices alike, so that the deterministic build's
+    // backends agree. The higher-precision derivative oracle evaluates the
+    // angle itself.
+    sinPhi1 = direction.sinPhiArrival;
+    cosPhi1 = direction.cosPhiArrival;
+  } else {
+    sincosOf(phi + psi, sinPhi1, cosPhi1);
+  }
+  const T dvec[3] = {sinTheta * cosPhi1, sinTheta * sinPhi1, cosTheta};
+
+  T n1[3] = {};
+  T u1[3] = {};
+  T v1[3] = {};
+  for (int i = 0; i < 3; ++i) {
+    n1[i] = static_cast<T>(to.normal[i]);
+    u1[i] = static_cast<T>(to.axis0[i]);
+    v1[i] = static_cast<T>(to.axis1[i]);
+  }
+
+  T nD = T(0);
+  T uD = T(0);
+  T vD = T(0);
+  for (int i = 0; i < 3; ++i) {
+    nD += n1[i] * dvec[i];
+    uD += u1[i] * dvec[i];
+    vD += v1[i] * dvec[i];
+  }
+  if (Math::Abs(nD) < static_cast<T>(prop.minAbsCosIncidence)) {
+    return PropagationStatus::kGrazing;
+  }
+
+  // Derivatives of the arrival point with respect to each source parameter,
+  // taken at fixed path length.
+  T dr[kNBoundParams][3] = {};
+  for (int i = 0; i < 3; ++i) {
+    dr[kLoc0][i] = static_cast<T>(from.axis0[i]);
+    dr[kLoc1][i] = static_cast<T>(from.axis1[i]);
+    dr[kPhi][i] = sinTheta * (sh * w[i] - ch * u[i]);
+    dr[kTheta][i] = cosTheta * (sh * u[i] + ch * w[i]);
+  }
+  dr[kTheta][2] -= s * sinTheta;
+
+  // d/d(q/p) enters only through kp, so it is dSh/dkp and dCh/dkp times b.
+  const T scale = sinTheta * bField * s * s;
+  for (int i = 0; i < 3; ++i) {
+    dr[kQOverP][i] = scale * (dSinc<T>(psi) * u[i] + dVersine<T>(psi) * w[i]);
+  }
+
+  for (int x = 0; x < kNBoundParams; ++x) {
+    T ndr = T(0);
+    T udr = T(0);
+    T vdr = T(0);
+    for (int i = 0; i < 3; ++i) {
+      ndr += n1[i] * dr[x][i];
+      udr += u1[i] * dr[x][i];
+      vdr += v1[i] * dr[x][i];
+    }
+    const T dsdx = -ndr / nD;
+
+    jac.loc0[x] = static_cast<Scalar>(udr + uD * dsdx);
+    jac.loc1[x] = static_cast<Scalar>(vdr + vD * dsdx);
+
+    T dphi = kp * dsdx;
+    if (x == kPhi) {
+      dphi += T(1);
+    }
+    if (x == kQOverP) {
+      dphi += s * bField;
+    }
+    jac.phi[x] = static_cast<Scalar>(dphi);
+    // The theta and q/p rows are not stored: see SolenoidJacobian for why
+    // they are absent from the type rather than filled with constants.
+  }
+  // The fit needs this exact crossing as well. Publish it only after the
+  // Jacobian succeeds; propagatedState may alias reference, now fully read.
+  if (propagatedState != nullptr) {
+    *propagatedState = at;
+  }
+  if (propagatedResult != nullptr) {
+    *propagatedResult = res;
+  }
+  return PropagationStatus::kOk;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_COVARIANCETRANSPORT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/CpuBackend.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/CpuBackend.h
new file mode 100644
index 0000000000000..176743b229ea2
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/CpuBackend.h
@@ -0,0 +1,502 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CpuBackend.h
+/// \brief Running one stage's generate, scan and place on the host threads.
+///
+/// Elements are cut into chunks of contiguous ordinals. Chunks run in
+/// parallel; inside a chunk the elements run in order, appending their records
+/// to the running arena slot's buffer, so a chunk's records sit contiguous in
+/// whichever buffer took them. After a two-level scan --
+/// chunk totals, then elements inside each chunk -- each chunk is one
+/// contiguous copy to `offset[first element]`. The output is the serial
+/// reference's, whatever the thread count, chunk size or scheduling.
+///
+/// The tracker gives every slot's buffer the staging per thread
+/// CapacityEstimator predicts; a miss grows that buffer for the run and tells
+/// the estimator. The one hard limit is the bounded pool: kOutOfMemory, which
+/// ends the run.
+
+#ifndef GTRK_TRACKING_CPUBACKEND_H_
+#define GTRK_TRACKING_CPUBACKEND_H_
+
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Base/Columns.h"
+#include "GenericTracking/Base/HostAlgorithms.h"
+#include "GenericTracking/Tracking/Parallel.h"
+#include "GenericTracking/Tracking/Profile.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <span>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+template <template <template <class> class> class S>
+class CpuStage
+{
+ public:
+  using Output = StageOutput<S>;
+  using Index = typename Output::Index;
+  using Record = typename Output::Record;
+  using Columns = BoundedColumns<S>;
+
+  /// One task-arena slot's staging: its columns and rows in use.
+  struct ThreadBuffer {
+    Columns columns;
+    std::size_t used = 0;
+    bool grew = false;
+
+    void append(const Record& record)
+    {
+      if (used == columns.size()) {
+        grew = true;
+        columns.resize(std::max<std::size_t>(kInitialRows, 2U * columns.size()));
+      }
+      columns.write(used++, record);
+    }
+  };
+
+  /// What an element's generator emits into: the running arena slot's buffer.
+  class Emitter
+  {
+   public:
+    void emit(const Record& record)
+    {
+      mBuffer->append(record);
+      ++mCount;
+    }
+    [[nodiscard]] Index count() const { return mCount; }
+
+   private:
+    friend class CpuStage;
+    explicit Emitter(ThreadBuffer& buffer) : mBuffer(&buffer) {}
+
+    ThreadBuffer* mBuffer = nullptr;
+    Index mCount = 0;
+  };
+
+  /// On \a arena, which outlives the stage: the tracker's one arena, shared
+  /// by its stages and loops so that TBB's workers stay with it from one loop
+  /// to the next.
+  explicit CpuStage(detail::TaskArena& arena) : mArena{arena}, mSlots{arena.maxConcurrency()} {}
+  ~CpuStage() = default;
+  CpuStage(const CpuStage&) = delete;
+  CpuStage& operator=(const CpuStage&) = delete;
+  CpuStage(CpuStage&&) = delete;
+  CpuStage& operator=(CpuStage&&) = delete;
+
+  /// Bind one buffer per task-arena slot and the chunk records to \a pool.
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
+  {
+    mMemoryPool = std::move(pool);
+    mBuffers.clear();
+    mBuffers.reserve(static_cast<std::size_t>(mArena.maxConcurrency()));
+    for (int slot = 0; slot < mArena.maxConcurrency(); ++slot) {
+      mBuffers.push_back(std::make_unique<ThreadBuffer>());
+    }
+    releaseStorage();
+  }
+
+  /// Each thread's buffer at \a perThread records from its next run on, kept
+  /// where it is larger: the timeframe's staging.
+  /// The run allocates it,
+  /// inside the stage's guard, so a pool too small is the stage's status.
+  void prepareStagingPerThread(std::size_t perThread) { mPreparedRows = perThread; }
+
+  /// The most records one buffer held at the end of a run since
+  /// `resetLargestUse`, and whether a buffer grew in a run since.
+  [[nodiscard]] std::size_t largestUse() const noexcept { return mLargestUse; }
+  [[nodiscard]] bool grewSinceReset() const noexcept { return mGrew; }
+  void resetLargestUse() noexcept
+  {
+    mLargestUse = 0U;
+    mGrew = false;
+  }
+
+  /// The staging and the chunk lists back to the pool;
+  /// the buffer objects stay,
+  /// and the prepared size, which the next run allocates again
+  /// (the tracker releases every iteration).
+  void releaseStorage() noexcept
+  {
+    for (const auto& value : mBuffers) {
+      value->columns.setMemoryResource(mMemoryPool.get());
+      value->used = 0U;
+      value->grew = false;
+    }
+    deepVectorClear(mMemoryPool.get(), mChunks, mLayerChunks, mGroupChunks);
+  }
+
+  [[nodiscard]] int maxConcurrency() const noexcept { return mArena.maxConcurrency(); }
+
+  /// The profile phases `run` reports its reset, generate, scan and place
+  /// as; none by default.
+  void setPhases(const profile::StagePhases& phases) { mPhases = phases; }
+
+  /// Allocated records across the reusable task-arena staging buffers.
+  [[nodiscard]] std::size_t stagingCapacity() const
+  {
+    std::size_t result = 0U;
+    for (const auto& buffer : mBuffers) {
+      result += buffer->columns.size();
+    }
+    return result;
+  }
+
+  class Staged;
+
+  /// Run \a generate(element, emitter) for every element of \a output, in
+  /// chunks of \a elementsPerChunk, and place the result canonically. A
+  /// generator with `filterStaged(staged)` sees every record staged before
+  /// the place and drops some (`Staged`):
+  /// the output holds the kept ones in canonical order, each element's count
+  /// the kept count; the overflow checks and the staging's use are the
+  /// generator's raw records'.
+  template <typename Generate>
+  StageStatus run(Output& output, Index elementsPerChunk, Generate generate)
+  {
+    {
+      // Generate writes every element's count and the scan every offset:
+      // only the logical state needs clearing.
+      const profile::Zone zone{mPhases.reset};
+      output.clearResult();
+    }
+    const Index elements = output.elementCount();
+    const host_algorithms::Chunking chunking{elements, elementsPerChunk};
+    const Index chunkSize = chunking.size;
+    std::size_t chunkCount = chunking.count();
+    // A layered generator (`Tracker::LayeredNeighbours`): its elements by
+    // layer, each layer's own chunks.
+    constexpr bool layered = requires {
+      generate.layerBoundaries;
+      generate.layerGroups;
+    };
+    return guardOutOfMemory([&] {
+      auto counts = output.counts();
+      if constexpr (layered) {
+        mLayerChunks.resize(generate.layerBoundaries.size());
+        chunkCount = 0U;
+        for (std::size_t layer = 0U; layer < generate.layerGroups.order.size(); ++layer) {
+          mLayerChunks[layer] = static_cast<Index>(chunkCount);
+          const Index count = generate.layerBoundaries[layer + 1U] - generate.layerBoundaries[layer];
+          chunkCount += count == 0U ? 0U : 1U + ((count - 1U) / chunkSize);
+        }
+        mLayerChunks.back() = static_cast<Index>(chunkCount);
+      }
+
+      // generate
+      {
+        const profile::Zone zone{mPhases.generate};
+        // Each slot's staging in its own task: a buffer the iteration's
+        // release emptied is allocated and filled here.
+        detail::parallelFor(mArena, 0, mBuffers.size(), 1, [&](std::size_t first, std::size_t last) {
+          for (std::size_t at = first; at < last; ++at) {
+            auto& columns = mBuffers[at]->columns;
+            columns.resizeRewritten(std::max(columns.size(), mPreparedRows));
+          }
+        });
+        mChunks.resize(chunkCount);
+        if constexpr (layered) {
+          for (std::size_t layer = 0U; layer < generate.layerGroups.order.size(); ++layer) {
+            for (auto chunk = mLayerChunks[layer]; chunk < mLayerChunks[layer + 1U]; ++chunk) {
+              const auto first = generate.layerBoundaries[layer] + (chunk - mLayerChunks[layer]) * chunkSize;
+              mChunks[chunk].firstElement = first;
+              mChunks[chunk].endElement = static_cast<Index>(std::min<std::size_t>(generate.layerBoundaries[layer + 1U], std::size_t{first} + chunkSize));
+            }
+          }
+        }
+        for (const auto& buffer : mBuffers) {
+          auto& local = *buffer;
+          local.used = 0;
+          local.grew = false;
+        }
+        const profile::Region region{mSlots, mArena.maxConcurrency(), elements};
+        const auto generateChunk = [&](std::size_t chunk) {
+          const auto chunkBegin = region.begin();
+          const int slot = detail::currentArenaThreadIndex();
+          assert(slot >= 0 && slot < mArena.maxConcurrency());
+          auto& buffer = *mBuffers[static_cast<std::size_t>(slot)];
+          auto& record = mChunks[chunk];
+          if constexpr (!layered) {
+            record.firstElement = chunking.begin(static_cast<Index>(chunk));
+            record.endElement = chunking.end(static_cast<Index>(chunk));
+          }
+          record = {.firstElement = record.firstElement, .endElement = record.endElement, .buffer = &buffer, .begin = buffer.used};
+          for (Index element = record.firstElement; element < record.endElement; ++element) {
+            Emitter emitter{buffer};
+            generate(element, emitter);
+            counts[element] = emitter.count();
+          }
+          record.count = buffer.used - record.begin;
+          region.end(slot, chunkBegin);
+        };
+        if constexpr (layered) {
+          // The layers of one depth of the link DAG have no link between them
+          // and every predecessor at a smaller depth (LayerLinks.h): one pass
+          // per depth over its layers' chunks, listed depth by depth, with
+          // every predecessor level final before the pass that reads it. The
+          // chunk records keep arena order for the one scan/place below.
+          const auto& groups = generate.layerGroups;
+          mGroupChunks.resize(chunkCount);
+          std::size_t listed = 0U;
+          for (std::size_t group = 0U; group < groups.count; ++group) {
+            const auto begin = listed;
+            for (auto at = groups.groups[group]; at < groups.groups[group + 1U]; ++at) {
+              const auto layer = groups.order[at];
+              for (auto chunk = mLayerChunks[layer]; chunk < mLayerChunks[static_cast<std::size_t>(layer) + 1U]; ++chunk) {
+                mGroupChunks[listed++] = chunk;
+              }
+            }
+            if (listed != begin) {
+              detail::parallelFor(mArena, begin, listed, 1U, [&](std::size_t first, std::size_t last) {
+                for (std::size_t at = first; at < last; ++at) {
+                  generateChunk(mGroupChunks[at]);
+                }
+              });
+            }
+          }
+        } else {
+          detail::parallelFor(mArena, 0, chunkCount, 1, [&](std::size_t first, std::size_t last) {
+            for (std::size_t chunk = first; chunk < last; ++chunk) {
+              generateChunk(chunk);
+            }
+          });
+        }
+      }
+
+      // What the buffers held, for the staging the next timeframe is given
+      // (`largestUse`).
+      for (const auto& buffer : mBuffers) {
+        mLargestUse = std::max(mLargestUse, buffer->used);
+        mGrew = mGrew || buffer->grew;
+      }
+
+      // scan: chunk totals serially, then the elements inside each chunk, the
+      // chunks in parallel
+      std::uint64_t total = 0;
+      bool ordinalOverflow = false;
+      const auto scan = [&] {
+        const profile::Zone zone{mPhases.scan};
+        total = 0;
+        for (auto& record : mChunks) {
+          record.offset = total;
+          total += record.count;
+        }
+        if (total > std::numeric_limits<Index>::max()) {
+          return StageStatus::kIndexOverflow;
+        }
+        auto offsets = output.offsets();
+        // A region, so the tree reads the loop as the parallel work it is.
+        const profile::Region region{mSlots, mArena.maxConcurrency(), elements};
+        detail::parallelFor(mArena, 0, chunkCount, 1, [&](std::size_t first, std::size_t last) {
+          for (std::size_t chunk = first; chunk < last; ++chunk) {
+            const auto chunkBegin = region.begin();
+            auto& record = mChunks[chunk];
+            auto running = static_cast<Index>(record.offset);
+            bool overflow = false;
+            for (Index element = record.firstElement; element < record.endElement; ++element) {
+              offsets[element] = running;
+              running += counts[element];
+              overflow = overflow || counts[element] > Output::kMaxPerElement;
+            }
+            record.ordinalOverflow = overflow;
+            region.end(detail::currentArenaThreadIndex(), chunkBegin);
+          }
+        });
+        ordinalOverflow = std::ranges::any_of(mChunks, [](const Chunk& record) { return record.ordinalOverflow; });
+        offsets[elements] = static_cast<Index>(total);
+        return StageStatus::kComplete;
+      };
+      if (const auto scanned = scan(); scanned != StageStatus::kComplete) {
+        return scanned;
+      }
+      profile::count(mPhases.generate, 0U, total);
+      if (ordinalOverflow) {
+        return StageStatus::kOrdinalOverflow;
+      }
+      if constexpr (requires(const Staged& staged) { generate.filterStaged(staged); }) {
+        generate.filterStaged(Staged{*this, counts});
+        static_cast<void>(scan());
+      }
+
+      // place: one contiguous copy per chunk
+      {
+        const profile::Zone zone{mPhases.place};
+        output.resizeOutput(static_cast<Index>(total));
+        const profile::Region region{mSlots, mArena.maxConcurrency(), total};
+        detail::parallelFor(mArena, 0, chunkCount, 1, [&](std::size_t first, std::size_t last) {
+          for (std::size_t chunk = first; chunk < last; ++chunk) {
+            const auto chunkBegin = region.begin();
+            const auto& record = mChunks[chunk];
+            record.buffer->columns.copyTo(record.begin, output.output(), record.offset, record.count);
+            region.end(detail::currentArenaThreadIndex(), chunkBegin);
+          }
+        });
+      }
+      return StageStatus::kComplete;
+    });
+  }
+
+  /// Run \a body(element) for every element in [0, \a elements), in chunks of
+  /// \a elementsPerChunk. For work on disjoint parts of an output, such as
+  /// sorting each element's range, which a device runs one thread per element.
+  template <typename Body>
+  void forEachElement(Index elements, Index elementsPerChunk, Body body)
+  {
+    const host_algorithms::Chunking chunking{elements, elementsPerChunk};
+    const profile::Region region{mSlots, mArena.maxConcurrency(), elements};
+    detail::parallelFor(mArena, 0, chunking.count(), 1, [&](std::size_t first, std::size_t last) {
+      for (std::size_t chunk = first; chunk < last; ++chunk) {
+        const auto chunkBegin = region.begin();
+        const auto end = chunking.end(static_cast<Index>(chunk));
+        for (auto element = chunking.begin(static_cast<Index>(chunk)); element < end; ++element) {
+          body(element);
+        }
+        region.end(detail::currentArenaThreadIndex(), chunkBegin);
+      }
+    });
+  }
+
+  /// Sort \a indices by \a less, a strict total order on them, on this
+  /// stage's task arena (`detail::parallelSort`): the serial sort's result,
+  /// on the threads the arena allows and no others.
+  template <typename Less>
+  void sortIndices(std::span<std::uint32_t> indices, Less less)
+  {
+    detail::parallelSort(mArena, indices, less);
+  }
+
+  /// A filtering generator's view of the records staged by its run
+  /// (`run`, `filterStaged`), after the raw scan: each element's records, and
+  /// their compaction.
+  class Staged
+  {
+   public:
+    /// body(element, columns, at) for each record the elements in
+    /// [\a begin, \a end) staged: row \a at of the staging's \a columns (a
+    /// const view), so that a body reads only the columns it needs. The
+    /// chunks in parallel, each element's records in order on one thread.
+    template <typename Body>
+    void forEach(Index begin, Index end, const Body& body) const
+    {
+      if (begin >= end) {
+        return;
+      }
+      auto& stage = *mStage;
+      const auto& chunks = stage.mChunks;
+      // The chunks holding the elements: from the last that starts at or before begin.
+      const auto first = static_cast<std::size_t>((std::ranges::upper_bound(chunks, begin, {}, &Chunk::firstElement) - chunks.begin()) - 1);
+      const auto last = static_cast<std::size_t>(std::ranges::lower_bound(chunks, end, {}, &Chunk::firstElement) - chunks.begin());
+      // A region, so the tree reads the loop as the parallel work it is.
+      const profile::Region region{stage.mSlots, stage.mArena.maxConcurrency(), end - begin};
+      detail::parallelFor(stage.mArena, first, last, 1, [&](std::size_t from, std::size_t to) {
+        for (std::size_t at = from; at < to; ++at) {
+          const auto chunkBegin = region.begin();
+          const auto& chunk = chunks[at];
+          const auto columns = std::as_const(chunk.buffer->columns).view();
+          std::size_t record = chunk.begin;
+          for (Index element = chunk.firstElement; element < chunk.endElement; ++element) {
+            const std::size_t next = record + mCounts[element];
+            if (element >= begin && element < end) {
+              for (; record < next; ++record) {
+                body(element, columns, record);
+              }
+            }
+            record = next;
+          }
+          region.end(detail::currentArenaThreadIndex(), chunkBegin);
+        }
+      });
+    }
+
+    /// The staged records kept where \a keep(element, columns, at) holds
+    /// (as `forEach`), in order, every chunk compacted in place in parallel,
+    /// the elements' counts lowered to their kept records'.
+    template <typename Keep>
+    void compact(const Keep& keep) const
+    {
+      auto& stage = *mStage;
+      const profile::Region region{stage.mSlots, stage.mArena.maxConcurrency(), mCounts.size()};
+      detail::parallelFor(stage.mArena, 0, stage.mChunks.size(), 1, [&](std::size_t first, std::size_t last) {
+        for (std::size_t at = first; at < last; ++at) {
+          const auto chunkBegin = region.begin();
+          auto& chunk = stage.mChunks[at];
+          auto& columns = chunk.buffer->columns;
+          const auto view = std::as_const(columns).view();
+          std::size_t read = chunk.begin;
+          std::size_t write = chunk.begin;
+          for (Index element = chunk.firstElement; element < chunk.endElement; ++element) {
+            Index kept = 0U;
+            for (Index i = 0U; i < mCounts[element]; ++i, ++read) {
+              if (keep(element, view, read)) {
+                if (write != read) {
+                  columns.write(write, columns.read(read));
+                }
+                ++write;
+                ++kept;
+              }
+            }
+            mCounts[element] = kept;
+          }
+          chunk.count = write - chunk.begin;
+          region.end(detail::currentArenaThreadIndex(), chunkBegin);
+        }
+      });
+    }
+
+   private:
+    friend class CpuStage;
+    Staged(CpuStage& stage, std::span<Index> counts) : mStage(&stage), mCounts(counts) {}
+
+    CpuStage* mStage = nullptr;
+    std::span<Index> mCounts;
+  };
+
+ private:
+  static constexpr std::size_t kInitialRows = 1024;
+
+  /// Where one chunk's records sit before placement.
+  struct Chunk {
+    Index firstElement = 0;
+    Index endElement = 0;
+    ThreadBuffer* buffer = nullptr;
+    std::size_t begin = 0;
+    std::size_t count = 0;
+    std::uint64_t offset = 0;
+    bool ordinalOverflow = false; ///< an element of the chunk emitted more than an ordinal numbers
+  };
+
+  // Pool must outlive allocator-backed members, the thread buffers included.
+  detail::TaskArena& mArena;
+  profile::RegionSlots mSlots; ///< one per arena slot, for the chunk timings
+  profile::StagePhases mPhases;
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  std::vector<std::unique_ptr<ThreadBuffer>> mBuffers;
+  BoundedVector<Chunk> mChunks;
+  BoundedVector<Index> mLayerChunks;
+  BoundedVector<Index> mGroupChunks; ///< the layered generation's chunks, depth by depth
+  std::size_t mPreparedRows = kInitialRows;
+  std::size_t mLargestUse = 0U; ///< `largestUse`
+  bool mGrew = false;           ///< `grewSinceReset`
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_CPUBACKEND_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Definitions.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Definitions.h
new file mode 100644
index 0000000000000..cfe5bf31a3479
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Definitions.h
@@ -0,0 +1,263 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Definitions.h
+/// \brief Scalars, parameter indices and packed-covariance indexing for the
+///        track model, the tracking's statuses and kinds, and the dispatch
+///        and sort helpers the stages share.
+///
+/// Nothing here may depend on ROOT or on anything a device compiler cannot
+/// see.
+///
+/// The enums the tracking's algorithms share. A status is compared where it
+/// is read, never wrapped in a predicate. Enums of one piece of machinery stay
+/// with it.
+
+#ifndef GTRK_TRACKING_DEFINITIONS_H_
+#define GTRK_TRACKING_DEFINITIONS_H_
+
+#include "GenericTracking/Base/Definitions.h"
+
+#include <cfloat>
+#include <cstdint>
+#include <type_traits>
+
+namespace o2::gtrk
+{
+
+/// The scalar used for the track parameters, covariance and their arithmetic.
+/// Time is not a track parameter: a measurement's and a track's time is a
+/// box in integer picoseconds (`TimeEstPS`).
+using Scalar = float;
+
+/// The scalar used where the geometry's dynamic range must survive: surface
+/// intersection and the path-length solve, which run at |z| up to 300 cm and
+/// have to land inside a 1 um budget.  Results narrow to Scalar on return, so
+/// this type never appears in a stored record.
+using ExactScalar = double;
+
+/// Indices into the bound parameter vector.
+///
+///   loc0, loc1  sensor-local coordinates on the reference plane   [cm]
+///   phi, theta  global momentum direction                         [rad]
+///   qOverP      signed charge over momentum                       [(GeV/c)^-1]
+///
+/// The order is part of the record layout and of every Jacobian written
+/// against it; changing it is not a refactor.
+enum BoundIndex : std::uint8_t { kLoc0 = 0,
+                                 kLoc1 = 1,
+                                 kPhi = 2,
+                                 kTheta = 3,
+                                 kQOverP = 4,
+                                 kNBoundParams = 5 };
+
+/// A symmetric 5x5 needs 15 numbers, not 25.
+inline constexpr int kBoundCovSize = kNBoundParams * (kNBoundParams + 1) / 2;
+
+/// The strict upper triangle of a 5x5, the U of a U D U^T factorisation.
+inline constexpr int kBoundUpperSize = kBoundCovSize - kNBoundParams;
+
+/// Index of element (row, col) in the packed lower triangle, row-major:
+///
+///     0
+///     1  2
+///     3  4  5
+///     6  7  8  9
+///    10 11 12 13 14
+///
+/// This is the layout O2 uses for its 5x5: o2::track::CovarMap is
+/// {{0,1,3,6,10},...} with DiagMap {0,2,5,9,14}, which is what this formula
+/// produces.  O2 tabulates it and we compute it.
+///
+/// Symmetric in its arguments, so a caller never has to know which of the two
+/// indices is the larger one -- which is exactly the mistake that makes a
+/// packed covariance silently wrong rather than loudly broken.
+GPUhdi() GPUAlwaysInline() constexpr int covIndex(int row, int col)
+{
+  const int hi = row > col ? row : col;
+  const int lo = row > col ? col : row;
+  return (hi * (hi + 1)) / 2 + lo;
+}
+
+/// Index of the variance of parameter \a i.
+GPUhdi() GPUAlwaysInline() constexpr int varIndex(int i) { return covIndex(i, i); }
+
+// Propagation and fits.
+
+/// What propagation did, in place of an exception, which device code cannot
+/// throw.  A caller has to look at this: several of these are ordinary
+/// physics, not faults.
+enum class PropagationStatus : std::uint8_t {
+  kOk = 0,
+  /// The trajectory never reaches the target plane.  A track whose transverse
+  /// circle closes inside the target radius is the common case, and it is a
+  /// fact about the track rather than an error.
+  kNoIntersection,
+  /// The plane is only reachable against the requested direction of travel.
+  kWrongDirection,
+  /// The intersection lies outside the sensor's active area.  Reported, not
+  /// enforced -- a fit may want the point anyway, a search will not.
+  kOutOfBounds,
+  /// The track grazes the plane: |normal . direction| is below threshold, so
+  /// the bound representation is singular and the covariance would be
+  /// meaningless.  Real at large |eta| on the outer barrel.
+  kGrazing,
+  /// A non-finite parameter arrived or was produced.
+  kNotFinite,
+  /// The crossing lies more than half a turn of the helix along the track: a
+  /// looper coming round again, not the next layer of the same arc.
+  kTooManyTurns,
+  /// The mass hypothesis's energy loss stopped the particle in the step's
+  /// material, or left it below 10 MeV (`energyLoss`).
+  kStopped
+};
+
+/// Which way along the trajectory the target is expected to lie.
+enum class PropagationDirection : std::int8_t {
+  kForward = 1,  ///< along the momentum
+  kBackward = -1 ///< against it, as the inward refit needs
+};
+
+/// Which of a barrel plane's two crossings a propagation takes
+/// (`propagate`). A compile-time choice
+/// (`withCrossingRule`); `kFirstAhead` is the default.
+enum class CrossingRule : std::uint8_t {
+  /// The crossing of smaller offset along the plane's line whenever it lies
+  /// ahead; the other only where it does not, and only nearer the centre.
+  kFirstAhead = 0,
+  /// Of the crossings ahead, the one nearer the plane's centre; a tie to the
+  /// first. With the first behind, as the default.
+  kNearerCentre,
+  /// Of the crossings ahead, one inside the sensor's bounds, the first if
+  /// both are; where neither is, the one nearer the plane's centre, a tie to
+  /// the first. With the first behind, as the default.
+  kInsideFirst
+};
+
+/// Where a failed fit stopped: the outward filter or the inward one.
+enum class FitPass : std::uint8_t { kNone = 0,
+                                    kOutward,
+                                    kInward };
+
+/// The road fit's outcome (TrackFitter.h, `fitOutward`): accepted, refused by
+/// its cuts, or a propagation failed on the way.
+enum class RoadFitStatus : std::uint8_t { kAccepted = 0,
+                                          kRejected,
+                                          kPropagationFailed };
+
+// The stages.
+
+/// Free; shared, taken by tracks only at positions among their `k` innermost;
+/// exclusive, taken at any other. Written by the selection alone, between
+/// iterations; read by the next iteration's tracklet stage, which skips the
+/// exclusive rows.
+enum UsedState : std::uint8_t { kFree = 0U,
+                                kShared = 1U,
+                                kExclusive = 2U };
+
+/// Where an iteration's vertex seeds come from.
+enum class VertexSource : std::uint8_t {
+  kBeamLine,   ///< one seed, the beam spot, compatible with every time
+  kVertexList, ///< the timeframe's vertex seeds, sorted by time
+};
+
+/// How a pair's second-coordinate window follows from a seed.
+enum class PairKind : std::uint8_t {
+  kBarrel,       ///< barrel -> barrel: linear in the seed's z
+  kDisc,         ///< disc -> disc: linear in the seed's r
+  kBarrelToDisc, ///< evaluated per seed, see `crossingPairWindow`
+  kDiscToBarrel  ///< evaluated per seed, see `crossingPairWindow`
+};
+
+/// What a step did with a row it visited, in the order its tests run: held
+/// by a track, outside the step's window, crossing another layer
+/// (LinkHoles.h), no usable update, above the chi2 gate, or passing.
+enum class StepOutcome : std::uint8_t { kUsed,
+                                        kOutsideWindow,
+                                        kHole,
+                                        kNoUpdate,
+                                        kChi2,
+                                        kPasses };
+
+/// Why a direction of a follow ended: no layer to search from where it
+/// stands; a sensor crossed without a row past the iteration's holes; every
+/// layer searched without a row within the holes (crossed in gaps, or not
+/// reached); or the track as long as a chain can be.
+enum class FollowEnd : std::uint8_t { kNoTarget,
+                                      kHoles,
+                                      kNoRow,
+                                      kCapacity };
+
+/// What the map makes of one triplet, and why it is not a candidate.
+enum class VertexCandidateStatus : std::uint8_t { kAccepted,
+                                                  kChi2RZ,
+                                                  kDca,
+                                                  kDegenerate };
+
+/// Whether a value is finite, in every build: O2's `GPUCommonMath::Finite`
+/// and `IsNaN` are constants outside the deterministic mode, on the host as
+/// on the device. NaN fails both comparisons, an
+/// infinity one of them. The bounds are the C macros, which a device compiler
+/// accepts where a `std::numeric_limits` call may not.
+GPUhdi() GPUAlwaysInline() constexpr bool isFiniteScalar(float x) { return x >= -FLT_MAX && x <= FLT_MAX; }
+
+/// `body(std::bool_constant<b>{}...)` for the run-time flags: an
+/// iteration's choices, each a compile-time variant of a stage, dispatched
+/// once per combination; the host's and a device's one switch.
+template <typename Body>
+decltype(auto) withBools(const Body& body)
+{
+  return body();
+}
+template <typename Body, typename... Rest>
+decltype(auto) withBools(const Body& body, bool first, Rest... rest)
+{
+  if (first) {
+    return withBools([&](auto... fixed) { return body(std::true_type{}, fixed...); }, rest...);
+  }
+  return withBools([&](auto... fixed) { return body(std::false_type{}, fixed...); }, rest...);
+}
+
+/// `body(std::integral_constant<CrossingRule, rule>{})` for the run-time \a rule.
+template <typename Body>
+decltype(auto) withCrossingRule(CrossingRule rule, const Body& body)
+{
+  switch (rule) {
+    case CrossingRule::kNearerCentre:
+      return body(std::integral_constant<CrossingRule, CrossingRule::kNearerCentre>{});
+    case CrossingRule::kInsideFirst:
+      return body(std::integral_constant<CrossingRule, CrossingRule::kInsideFirst>{});
+    case CrossingRule::kFirstAhead:
+      break;
+  }
+  return body(std::integral_constant<CrossingRule, CrossingRule::kFirstAhead>{});
+}
+
+/// \a count values sorted in place by \a less, stable: an insertion sort,
+/// for the few entries one thread holds. Stable, and the same order on host
+/// and device; O2's `sort` is neither.
+template <typename T, typename Less>
+GPUhdi() GPUAlwaysInline() void insertionSort(T* values, std::uint32_t count, const Less& less)
+{
+  for (std::uint32_t i = 1; i < count; ++i) {
+    const T value = values[i];
+    std::uint32_t slot = i;
+    while (slot > 0U && less(value, values[slot - 1U])) {
+      values[slot] = values[slot - 1U];
+      --slot;
+    }
+    values[slot] = value;
+  }
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_DEFINITIONS_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/DisplacedPair.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/DisplacedPair.h
new file mode 100644
index 0000000000000..c1d89370abc9f
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/DisplacedPair.h
@@ -0,0 +1,425 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DisplacedPair.h
+/// \brief Whether a pair of measurements can belong to a track that passes
+///        within a distance of the beam line: the pair test of a displaced track, its geometry
+///        alone, without the measurements' errors.
+///
+/// The circles through two points in the transverse plane are one family,
+/// by their signed curvature `k` -- positive turning counterclockwise on the
+/// way from the source to the target, the straight line at 0, the circle on
+/// the chord as diameter at `+-1/h`, `h` the half chord. A track above pT_min
+/// is one with `|k| <= k_max`; travelling outward, one whose distance to the
+/// beam line grows from the source to the target. On that interval, the
+/// signed distance of the circle's closest approach to the beam line (its
+/// impact, `circleImpact`) is monotone in `k` (its stationary points are the
+/// outward boundaries), the outward set is one interval, and the closest
+/// approach's z, from the line through both measurements in arc length and z
+/// (`closestApproachZ`), has at most one extremum, a numerical property,
+/// not a proven one. So the transverse test is exact at the interval's two
+/// ends, and the longitudinal one at the ends of the part within the impact
+/// bound and at the one extremum, found by a fixed number of steps. One case
+/// apart: a point on the line through the beam line and the chord's midpoint
+/// moves outward only on the two diameter circles, tested one by one.
+///
+/// The beam line is the frame's origin, as for the pair cut (PairCut.h). At
+/// an impact bound of 0 and in a field the transverse test is the pair cut's: the
+/// circle through the beam point, its curvature at most k_max, no turning
+/// point between the two (`transverseCompatible` without its errors). With no
+/// field (`maxCurvature` 0) it is the straight line's, which the pair cut does
+/// not test.
+
+#ifndef GTRK_TRACKING_DISPLACEDPAIR_H_
+#define GTRK_TRACKING_DISPLACEDPAIR_H_
+
+#include "GenericTracking/Base/Definitions.h"
+#include "GenericTracking/Tracking/MathUtils.h"
+#include "GenericTracking/Tracking/Trig.h"
+
+#include "GPUCommonMath.h"
+
+namespace o2::gtrk::displaced
+{
+
+/// atan(x) / x, without the singularity at 0.
+template <typename T>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() T atanOverArgument(T x)
+{
+  if (o2::gpu::CAMath::Abs(x) < T(0.05)) {
+    const T x2 = x * x;
+    return T(1) - (x2 * ((T(1) / T(3)) - (x2 * T(0.2))));
+  }
+  return atanOf(x) / x;
+}
+
+/// The circles through a source and a target: the chord's midpoint `M`, its
+/// unit direction `u` from the source, its left normal `n`, the half chord.
+template <typename T>
+struct CircleFamily {
+  T sourceX, sourceY, targetX, targetY;
+  T midX, midY;
+  T ux, uy;
+  T nx, ny;
+  T half;
+  T midSquare; ///< |M|^2
+  T midAlong;  ///< M . u
+  T midNormal; ///< M . n
+};
+
+/// The family through (\a x1, \a y1) and (\a x2, \a y2); a half chord of 0
+/// for coincident points, which no test admits.
+template <typename T>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() CircleFamily<T> circleFamily(T x1, T y1, T x2, T y2)
+{
+  const T dx = x2 - x1;
+  const T dy = y2 - y1;
+  const T chord = o2::math_utils::detail::sqrt<T>((dx * dx) + (dy * dy));
+  const T inverse = chord > T(0) ? T(1) / chord : T(0);
+  const T ux = dx * inverse;
+  const T uy = dy * inverse;
+  const T midX = T(0.5) * (x1 + x2);
+  const T midY = T(0.5) * (y1 + y2);
+  return {
+    .sourceX = x1,
+    .sourceY = y1,
+    .targetX = x2,
+    .targetY = y2,
+    .midX = midX,
+    .midY = midY,
+    .ux = ux,
+    .uy = uy,
+    .nx = -uy,
+    .ny = ux,
+    .half = T(0.5) * chord,
+    .midSquare = (midX * midX) + (midY * midY),
+    .midAlong = (ux * midX) + (uy * midY),
+    .midNormal = (-uy * midX) + (ux * midY),
+  };
+}
+
+/// `sqrt(1 - (k h)^2)`: the cosine of half the turn between the two.
+template <typename T>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() T halfTurnCosine(const CircleFamily<T>& family, T k)
+{
+  const T kh = k * family.half;
+  const T square = T(1) - (kh * kh);
+  return square > T(0) ? o2::math_utils::detail::sqrt<T>(square) : T(0);
+}
+
+/// The signed distance from the beam line to the circle of curvature \a k:
+/// `|C| - R` for a counterclockwise one, its negative for a clockwise one,
+/// the line's signed distance `M . n` at 0, in one smooth expression.
+template <typename T>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() T circleImpact(const CircleFamily<T>& family, T k)
+{
+  const T s = halfTurnCosine(family, k);
+  const T numerator = (k * (family.midSquare - (family.half * family.half))) + (T(2) * s * family.midNormal);
+  const T centre2 = (k * k * family.midSquare) + (T(2) * k * s * family.midNormal) + (s * s);
+  return numerator / (T(1) + o2::math_utils::detail::sqrt<T>(centre2 > T(0) ? centre2 : T(0)));
+}
+
+/// A closed interval of curvatures; empty if `low > high`.
+template <typename T>
+struct CurvatureInterval {
+  T low;
+  T high;
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool empty() const { return !(low <= high); }
+};
+
+/// The curvatures for which a pair moves outward at its point \a x, \a y,
+/// going from the source to the target: `P . T(k) >= 0`, the tangent `T(k)`,
+/// `P . T = k (P x M) + s (P . u)`, one root at most. With `P x M` zero and
+/// `P . u` negative only the diameter circles, `s` = 0, move outward there:
+/// \a diameterOnly, and the interval is all of [-1/h, 1/h].
+template <typename T>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() CurvatureInterval<T> outwardAt(const CircleFamily<T>& family, T x, T y, bool& diameterOnly)
+{
+  const T a = (x * family.midY) - (y * family.midX);
+  const T b = (x * family.ux) + (y * family.uy);
+  const T edge = family.half > T(0) ? T(1) / family.half : T(0);
+  diameterOnly = false;
+  if (exactlyEqual(a, T(0))) {
+    diameterOnly = b < T(0);
+    return {-edge, edge};
+  }
+  const T root = (a > T(0) ? -b : b) / o2::math_utils::detail::sqrt<T>((a * a) + (b * b * family.half * family.half));
+  return a > T(0) ? CurvatureInterval<T>{root, edge} : CurvatureInterval<T>{-edge, root};
+}
+
+/// The curvatures at most \a maxCurvature in size on which the pair moves
+/// outward at both its points; \a diameterOnly as `outwardAt`'s, for either.
+template <typename T>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() CurvatureInterval<T> outwardCurvatures(const CircleFamily<T>& family, T maxCurvature, bool& diameterOnly)
+{
+  diameterOnly = false;
+  if (!(family.half > T(0))) {
+    return {T(1), T(0)};
+  }
+  const T edge = T(1) / family.half;
+  const T bound = maxCurvature < edge ? maxCurvature : edge;
+  bool sourceDiameter = false;
+  bool targetDiameter = false;
+  const auto source = outwardAt(family, family.sourceX, family.sourceY, sourceDiameter);
+  const auto target = outwardAt(family, family.targetX, family.targetY, targetDiameter);
+  diameterOnly = sourceDiameter || targetDiameter;
+  const T low = o2::gpu::CAMath::Max(-bound, o2::gpu::CAMath::Max(source.low, target.low));
+  const T high = o2::gpu::CAMath::Min(bound, o2::gpu::CAMath::Min(source.high, target.high));
+  return {low, high};
+}
+
+/// The z of the closest approach to the beam line of the helix of
+/// curvature \a k through the two measurements, at \a z1 and \a z2: the
+/// line through both in arc length and z, there. In the chord's frame, `M`
+/// at `(m, v)` and `alpha = asin(k h)` half the turn between them, the
+/// closest approach lies `atan2(m sin(alpha), h cos(alpha) + v sin(alpha))`
+/// before the arc's middle, in turn: the branch from the geometry, not from
+/// the sign of a vanishing product. \a valid false for the circle centred on
+/// the beam line, which has no closest approach.
+template <typename T>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() T closestApproachZ(const CircleFamily<T>& family, T k, T z1, T z2, bool& valid)
+{
+  T sine = k * family.half;
+  if (sine > T(1)) {
+    sine = T(1);
+  } else if (sine < T(-1)) {
+    sine = T(-1);
+  }
+  const T cosine = halfTurnCosine(family, k);
+  const T across = family.midAlong * sine;
+  const T along = (family.half * cosine) + (family.midNormal * sine);
+  valid = !(exactlyEqual(across, T(0)) && exactlyEqual(along, T(0)));
+  if (!valid) {
+    return T(0);
+  }
+  // atan2(across, along) / alpha, smooth through k = 0, where along is h.
+  T ratio = T(0);
+  if (along > T(0)) {
+    // sin(alpha) / alpha = 1 / asinOverArgument(k h).
+    ratio = atanOverArgument(across / along) * family.midAlong / (along * o2::gtrk::detail::asinOverArgument(sine));
+  } else {
+    ratio = atan2Of(across, along) / asinOf(sine);
+  }
+  return (T(0.5) * (z1 + z2)) - (T(0.5) * (z2 - z1) * ratio);
+}
+
+/// What the displaced pair test found.
+struct DisplacedPairResult {
+  bool transverse = false;   ///< a circle above pT_min, outward, within the impact bound
+  bool longitudinal = false; ///< of those, a helix whose closest approach is within the z bound
+};
+
+/// Bisection steps of the impact's end points and golden-section steps of
+/// the closest approach's z extremum: fixed, so every backend takes the same.
+inline constexpr int kBisectionSteps = 40;
+inline constexpr int kGoldenSteps = 40;
+
+/// The two diameter circles one by one (`outwardAt`'s \a diameterOnly).
+template <typename T>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() DisplacedPairResult diameterCircles(const CircleFamily<T>& family, const CurvatureInterval<T>& outward, T z1, T z2, T maxImpact, T zLow, T zHigh)
+{
+  DisplacedPairResult result;
+  const T edge = T(1) / family.half;
+  for (int side = 0; side < 2; ++side) {
+    const T k = side == 0 ? -edge : edge;
+    if (k < outward.low || k > outward.high || o2::gpu::CAMath::Abs(circleImpact(family, k)) > maxImpact) {
+      continue;
+    }
+    result.transverse = true;
+    bool valid = false;
+    const T z = closestApproachZ(family, k, z1, z2, valid);
+    result.longitudinal = result.longitudinal || (valid && z >= zLow && z <= zHigh);
+  }
+  return result;
+}
+
+/// Whether some helix through the two measurements -- (\a x1, \a y1, \a z1)
+/// the source, (\a x2, \a y2, \a z2) the target, in the beam line's frame --
+/// has a curvature of at most \a maxCurvature, moves outward from the one to
+/// the other, passes within \a maxImpact of the beam line, and does so at a z
+/// within [\a zLow, \a zHigh].
+template <typename T>
+[[nodiscard]] GPUhdi() DisplacedPairResult displacedPair(T x1, T y1, T z1, T x2, T y2, T z2, T maxCurvature, T maxImpact, T zLow, T zHigh)
+{
+  DisplacedPairResult result;
+  const auto family = circleFamily(x1, y1, x2, y2);
+  bool diameterOnly = false;
+  const auto outward = outwardCurvatures(family, maxCurvature, diameterOnly);
+  if (outward.empty()) {
+    return result;
+  }
+  if (diameterOnly) {
+    return diameterCircles(family, outward, z1, z2, maxImpact, zLow, zHigh);
+  }
+  const T lowImpact = circleImpact(family, outward.low);
+  const T highImpact = circleImpact(family, outward.high);
+  const bool rising = lowImpact <= highImpact;
+  const T least = rising ? lowImpact : highImpact;
+  const T most = rising ? highImpact : lowImpact;
+  result.transverse = least <= maxImpact && most >= -maxImpact;
+  if (!result.transverse) {
+    return result;
+  }
+  // The part of the interval within the impact bound: the impact is monotone,
+  // so the curvature where it crosses each bound, by bisection.
+  const auto crossing = [&](T target) {
+    T low = outward.low;
+    T high = outward.high;
+    for (int step = 0; step < kBisectionSteps; ++step) {
+      const T middle = T(0.5) * (low + high);
+      const bool below = (circleImpact(family, middle) < target) == rising;
+      (below ? low : high) = middle;
+    }
+    return T(0.5) * (low + high);
+  };
+  T first = outward.low;
+  T last = outward.high;
+  if (least < -maxImpact) {
+    (rising ? first : last) = crossing(-maxImpact);
+  }
+  if (most > maxImpact) {
+    (rising ? last : first) = crossing(maxImpact);
+  }
+  if (first > last) {
+    const T swap = first;
+    first = last;
+    last = swap;
+  }
+  bool firstValid = false;
+  bool lastValid = false;
+  const T firstZ = closestApproachZ(family, first, z1, z2, firstValid);
+  const T lastZ = closestApproachZ(family, last, z1, z2, lastValid);
+  if (!firstValid || !lastValid) {
+    // A circle centred on the beam line at an end has no closest approach,
+    // so no z to test: refused, as there is none to admit.
+    return result;
+  }
+  const auto inside = [&](T z) { return z >= zLow && z <= zHigh; };
+  if (inside(firstZ) || inside(lastZ) || ((firstZ < zLow) != (lastZ < zLow))) {
+    result.longitudinal = true;
+    return result;
+  }
+  // Both ends on one side of the bound: the one extremum between them, a
+  // minimum if they are above it, a maximum if below, by golden section.
+  const T sign = firstZ > zHigh ? T(1) : T(-1);
+  const T ratio = T(0.6180339887498949);
+  T low = first;
+  T high = last;
+  T left = high - (ratio * (high - low));
+  T right = low + (ratio * (high - low));
+  bool valid = false;
+  T leftZ = sign * closestApproachZ(family, left, z1, z2, valid);
+  T rightZ = sign * closestApproachZ(family, right, z1, z2, valid);
+  for (int step = 0; step < kGoldenSteps; ++step) {
+    if (leftZ < rightZ) {
+      high = right;
+      right = left;
+      rightZ = leftZ;
+      left = high - (ratio * (high - low));
+      leftZ = sign * closestApproachZ(family, left, z1, z2, valid);
+    } else {
+      low = left;
+      left = right;
+      leftZ = rightZ;
+      right = low + (ratio * (high - low));
+      rightZ = sign * closestApproachZ(family, right, z1, z2, valid);
+    }
+  }
+  // Both ends above the bound: the least z must reach it; both below, the most.
+  const T extremum = sign * (leftZ < rightZ ? leftZ : rightZ);
+  result.longitudinal = sign > T(0) ? extremum <= zHigh : extremum >= zLow;
+  return result;
+}
+
+/// The errors a displaced pair test takes: each measurement's, the
+/// scattering, the beam's width [cm^2].
+template <typename T>
+struct PairErrors {
+  T sourceVarR = T(0);
+  T sourceVarRPhi = T(0);
+  T sourceVarZ = T(0);
+  T targetVarR = T(0);
+  T targetVarRPhi = T(0);
+  T targetVarZ = T(0);
+  /// `sum theta_k^2 s_k^2` over the layers up to and including the source's,
+  /// at pT_min (`sourceScattering`): the closest approach's displacement by a
+  /// kink inside the source, its lever arm taken from the vertex.
+  T sourceScatter = T(0);
+  /// The target's displacement by the passives between the two
+  /// (`betweenScattering`).
+  T betweenScatter = T(0);
+  T beamVarTransverse = T(0);
+};
+
+/// One sigma each of the impact and of the closest approach's z.
+template <typename T>
+struct PairSigmas {
+  T impact;
+  T z;
+};
+
+/// One sigma each of the impact and of the closest approach's z, bounds that
+/// hold for every circle the test may take, so that widening the impact and
+/// z bounds by them keeps the test's monotone and one-extremum structure
+/// (a sigma per curvature would not). At a fixed
+/// curvature the closest approach is the two points' extrapolation, with
+/// `s_i` their arcs from it: `delta d0 = (s_2 delta_1 - s_1 delta_2) / (s_2 -
+/// s_1)`, `delta` across the track, and z the same in z. The arc between them
+/// is at least the chord `c`; an arc from the closest approach at most its
+/// chord, `r_i + D`, times the largest arc-to-chord ratio at k_max,
+/// `asin(x) / x` at `x = k_max (r_i + D) / 2` (pi / 2 at half a turn). Across
+/// the track a point's error is at most `varR + varRPhi`. The transverse
+/// errors move the arcs, which the dip `|z_2 - z_1| / c` turns into z; a
+/// kink inside the source moves the closest approach by `sourceScatter`'s
+/// lever, along the track's 3D path in z.
+template <typename T>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() PairSigmas<T> displacedPairSigmas(T x1, T y1, T z1, T x2, T y2, T z2, const PairErrors<T>& errors, T maxCurvature, T maxImpact)
+{
+  const T dx = x2 - x1;
+  const T dy = y2 - y1;
+  const T chord2 = (dx * dx) + (dy * dy);
+  if (!(chord2 > T(0))) {
+    return {T(0), T(0)};
+  }
+  const T r1 = o2::math_utils::detail::sqrt<T>((x1 * x1) + (y1 * y1)) + maxImpact;
+  const T r2 = o2::math_utils::detail::sqrt<T>((x2 * x2) + (y2 * y2)) + maxImpact;
+  const auto ratio = [&](T reach) {
+    const T x = T(0.5) * maxCurvature * reach;
+    return o2::gtrk::detail::asinOverArgument(x < T(1) ? x : T(1));
+  };
+  const T lever1 = ratio(r2) * r2; // the source's error's lever: the target's arc
+  const T lever2 = ratio(r1) * r1;
+  const T across1 = errors.sourceVarR + errors.sourceVarRPhi;
+  const T across2 = errors.targetVarR + errors.targetVarRPhi + errors.betweenScatter;
+  const T position = ((lever1 * lever1 * across1) + (lever2 * lever2 * across2)) / chord2;
+  const T dz = z2 - z1;
+  const T dip2 = dz * dz / chord2;
+  const T longitudinal = ((lever1 * lever1 * errors.sourceVarZ) + (lever2 * lever2 * errors.targetVarZ)) / chord2;
+  return {
+    .impact = o2::math_utils::detail::sqrt<T>(position + errors.sourceScatter + errors.beamVarTransverse),
+    .z = o2::math_utils::detail::sqrt<T>(longitudinal + (dip2 * position) + ((T(1) + dip2) * errors.sourceScatter)),
+  };
+}
+
+/// `displacedPair` with its impact and z bounds widened by \a nSigma of
+/// `displacedPairSigmas`.
+template <typename T>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() DisplacedPairResult displacedPairWithin(T x1, T y1, T z1, T x2, T y2, T z2, const PairErrors<T>& errors, T nSigma, T maxCurvature, T maxImpact, T zLow, T zHigh)
+{
+  const auto sigmas = displacedPairSigmas(x1, y1, z1, x2, y2, z2, errors, maxCurvature, maxImpact);
+  const T impact = maxImpact + (nSigma * sigmas.impact);
+  const T z = nSigma * sigmas.z;
+  return displacedPair(x1, y1, z1, x2, y2, z2, maxCurvature, impact, zLow - z, zHigh + z);
+}
+
+} // namespace o2::gtrk::displaced
+
+#endif // GTRK_TRACKING_DISPLACEDPAIR_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Follow.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Follow.h
new file mode 100644
index 0000000000000..7e562f5b7ce62
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Follow.h
@@ -0,0 +1,2342 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Follow.h
+/// \brief A track followed beyond its rows, outward and then inward, as a CKF
+///        follows it: the crossing and the update,
+///        one step's search, the observer, the stage (`FollowStage`), the
+///        passes after it, and the host's orchestration (`Follow`).
+///
+/// After an iteration's refit each of its tracks is followed, and, with
+/// `followEarlier`, every earlier iteration's track first. The rows proposed
+/// then pass the bidding between the tracks followed in their order, the
+/// kink steps' witnesses, the combination, the refit under the road fit's
+/// chi2 cut, and the marks: the bid is over one iteration's tracks, and the
+/// marks freeze the rows kept, so that later iterations do not build on them.
+
+#ifndef GTRK_TRACKING_FOLLOW_H_
+#define GTRK_TRACKING_FOLLOW_H_
+
+#include "GenericTracking/Base/LayerLinks.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/BoundTrackState.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Tracking/CovarianceTransport.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/Material.h"
+#include "GenericTracking/Tracking/MeasurementGrid.h"
+#include "GenericTracking/Tracking/MeasurementUpdate.h"
+#include "GenericTracking/Tracking/Profile.h"
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Tracking/SensorCells.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/TrackFitter.h"
+#include "GenericTracking/Tracking/TrackRefit.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tracking/Trig.h"
+#include "GenericTracking/Tracking/WorkCounters.h"
+
+#include "GPUCommonMath.h"
+#include "MathUtils/detail/trigonometric.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <numbers>
+#include <span>
+#include <type_traits>
+
+namespace o2::gtrk
+{
+
+/// A track's intersection with a layer's nominal cylinder or disc plane, in
+/// the two coordinates the measurement grid indexes. The search is wider
+/// than the difference between that nominal surface and an individual sensor;
+/// the candidate is propagated to its actual sensor before it is chosen.
+struct LayerCrossingPrediction {
+  Scalar phi = 0.F;
+  Scalar second = 0.F;
+  PropagationStatus status = PropagationStatus::kNotFinite;
+};
+
+namespace follow
+{
+
+GPUhdi() GPUAlwaysInline() ExactScalar directedTurn(ExactScalar turn, ExactScalar curvature, PropagationDirection direction)
+{
+  const auto wanted = static_cast<ExactScalar>(static_cast<int>(direction));
+  if ((turn / curvature) * wanted < 0.) {
+    turn += wanted * (curvature > 0. ? 2 * std::numbers::pi_v<ExactScalar> : -(2 * std::numbers::pi_v<ExactScalar>));
+  }
+  return turn;
+}
+
+/// Whether a crossing \a turn radians along the helix is past half a turn.
+/// Such a crossing is a looper coming round again -- a track at eta ~ 0 reaches
+/// a forward disc after about ten turns -- and not the next layer of the same
+/// arc; its transported covariance is also past what float can factorise.
+GPUhdi() GPUAlwaysInline() bool beyondHalfTurn(ExactScalar turn) { return o2::gpu::CAMath::Abs(turn) > std::numbers::pi_v<ExactScalar>; }
+
+GPUhdi() GPUAlwaysInline() bool nearerPath(ExactScalar candidate, ExactScalar chosen) { return exactlyEqual(chosen, ExactScalar{0}) || o2::gpu::CAMath::Abs(candidate) < o2::gpu::CAMath::Abs(chosen); }
+
+} // namespace follow
+
+/// Predict where \a state crosses \a layer, without choosing a sensor. The
+/// nominal radius or z is copied into IterationParameters on the host, so the
+/// runtime-indexed path reads no detector constexpr table on a device.
+template <typename Prop, DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() LayerCrossingPrediction predictLayerCrossing(const Prop& prop, const IterationParameters<Det>& parameters, const TrackingSurface& from, const BoundTrackState& state, LayerID layer, PropagationDirection direction)
+{
+  using Math = o2::gpu::CAMath;
+  LayerCrossingPrediction result;
+  const auto& propagator = pointPropagator(prop, from, state);
+
+  Scalar startScalar[3]{};
+  surfaceToGlobal(from, state.loc0(), state.loc1(), startScalar);
+  const ExactScalar start[3] = {static_cast<ExactScalar>(startScalar[0]), static_cast<ExactScalar>(startScalar[1]), static_cast<ExactScalar>(startScalar[2])};
+  const auto phi0 = static_cast<ExactScalar>(state.phi());
+  const auto theta = static_cast<ExactScalar>(state.theta());
+  ExactScalar sinPhi = 0.;
+  ExactScalar cosPhi = 0.;
+  ExactScalar sinTheta = 0.;
+  ExactScalar cosTheta = 0.;
+  sincosOf(phi0, sinPhi, cosPhi);
+  sincosOf(theta, sinTheta, cosTheta);
+  if (Math::Abs(sinTheta) < 1.e-9) {
+    result.status = PropagationStatus::kNotFinite;
+    return result;
+  }
+
+  const ExactScalar curvature = propagator.curvature(static_cast<ExactScalar>(state.qOverP()), sinTheta);
+  const auto directionValue = static_cast<ExactScalar>(static_cast<int>(direction));
+  ExactScalar path = 0.;
+  ExactScalar x = start[0];
+  ExactScalar y = start[1];
+  ExactScalar z = start[2];
+
+  if (Detector<Det>::hasDiscs && !Detector<Det>::isBarrelLayer(layer)) {
+    if (Math::Abs(cosTheta) < static_cast<ExactScalar>(propagator.minAbsCosIncidence)) {
+      result.status = PropagationStatus::kGrazing;
+      return result;
+    }
+    path = (static_cast<ExactScalar>(parameters.layerSpans[layer].position) - start[2]) / cosTheta;
+    if (path * directionValue < 0.) {
+      result.status = PropagationStatus::kWrongDirection;
+      return result;
+    }
+    const ExactScalar turn = curvature * path * sinTheta;
+    if (follow::beyondHalfTurn(turn)) {
+      result.status = PropagationStatus::kTooManyTurns;
+      return result;
+    }
+    const ExactScalar transverse = path * sinTheta;
+    x += transverse * ((cosPhi * sinc<ExactScalar>(turn)) - (sinPhi * versine<ExactScalar>(turn)));
+    y += transverse * ((sinPhi * sinc<ExactScalar>(turn)) + (cosPhi * versine<ExactScalar>(turn)));
+    z = static_cast<ExactScalar>(parameters.layerSpans[layer].position);
+  } else {
+    const auto radius = static_cast<ExactScalar>(parameters.layerSpans[layer].position);
+    const ExactScalar dot = (start[0] * cosPhi) + (start[1] * sinPhi);
+    const ExactScalar radial = (start[0] * start[0]) + (start[1] * start[1]) - (radius * radius);
+    if (Math::Abs(curvature) < 1.e-12) {
+      const ExactScalar discriminant = (dot * dot) - radial;
+      if (discriminant < 0.) {
+        result.status = PropagationStatus::kNoIntersection;
+        return result;
+      }
+      const auto root = static_cast<ExactScalar>(Math::Sqrt(static_cast<Scalar>(discriminant)));
+      const ExactScalar first = -dot - root;
+      const ExactScalar second = -dot + root;
+      ExactScalar transverse = 0.;
+      if (first * directionValue >= 0.) {
+        transverse = first;
+      }
+      if (second * directionValue >= 0. && follow::nearerPath(second, transverse)) {
+        transverse = second;
+      }
+      if (exactlyEqual(transverse, ExactScalar{0})) {
+        result.status = PropagationStatus::kWrongDirection;
+        return result;
+      }
+      path = transverse / sinTheta;
+      x += transverse * cosPhi;
+      y += transverse * sinPhi;
+      z += path * cosTheta;
+    } else {
+      const ExactScalar inverse = 1. / curvature;
+      const ExactScalar centreX = start[0] - (sinPhi * inverse);
+      const ExactScalar centreY = start[1] + (cosPhi * inverse);
+      const auto centreDistance = static_cast<ExactScalar>(Math::Sqrt(static_cast<Scalar>((centreX * centreX) + (centreY * centreY))));
+      const ExactScalar circleRadius = Math::Abs(inverse);
+      if (centreDistance > radius + circleRadius || centreDistance < Math::Abs(radius - circleRadius) || !(centreDistance > 0.)) {
+        result.status = PropagationStatus::kNoIntersection;
+        return result;
+      }
+      const ExactScalar along = ((radius * radius) - (circleRadius * circleRadius) + (centreDistance * centreDistance)) / (2. * centreDistance);
+      const ExactScalar heightSquared = (radius * radius) - (along * along);
+      if (heightSquared < 0.) {
+        result.status = PropagationStatus::kNoIntersection;
+        return result;
+      }
+      const auto height = static_cast<ExactScalar>(Math::Sqrt(static_cast<Scalar>(heightSquared)));
+      const ExactScalar unitX = centreX / centreDistance;
+      const ExactScalar unitY = centreY / centreDistance;
+      ExactScalar chosenPath = 0.;
+      ExactScalar chosenX = 0.;
+      ExactScalar chosenY = 0.;
+      for (int side = -1; side <= 1; side += 2) {
+        const auto sideValue = static_cast<ExactScalar>(side);
+        const ExactScalar candidateX = (along * unitX) - (sideValue * height * unitY);
+        const ExactScalar candidateY = (along * unitY) + (sideValue * height * unitX);
+        const ExactScalar deltaX = candidateX - start[0];
+        const ExactScalar deltaY = candidateY - start[1];
+        const ExactScalar alongDirection = (deltaX * cosPhi) + (deltaY * sinPhi);
+        const ExactScalar alongNormal = (-deltaX * sinPhi) + (deltaY * cosPhi);
+        ExactScalar turn = atan2Of(curvature * alongDirection, 1. - (curvature * alongNormal));
+        turn = follow::directedTurn(turn, curvature, direction);
+        const ExactScalar candidatePath = turn / (curvature * sinTheta);
+        if (candidatePath * directionValue >= 0. && follow::nearerPath(candidatePath, chosenPath)) {
+          chosenPath = candidatePath;
+          chosenX = candidateX;
+          chosenY = candidateY;
+        }
+      }
+      if (exactlyEqual(chosenPath, ExactScalar{0})) {
+        result.status = PropagationStatus::kWrongDirection;
+        return result;
+      }
+      // The nearer of the two circle crossings: if it is past half a turn, so
+      // is the other.
+      if (follow::beyondHalfTurn(curvature * chosenPath * sinTheta)) {
+        result.status = PropagationStatus::kTooManyTurns;
+        return result;
+      }
+      path = chosenPath;
+      x = chosenX;
+      y = chosenY;
+      z += path * cosTheta;
+    }
+  }
+
+  result.phi = o2::math_utils::detail::to02Pi<Scalar>(Math::ATan2(static_cast<Scalar>(y), static_cast<Scalar>(x)));
+  result.second = Detector<Det>::isBarrelLayer(layer) ? static_cast<Scalar>(z) : Math::Sqrt(static_cast<Scalar>((x * x) + (y * y)));
+  result.status = isFiniteScalar(result.phi) && isFiniteScalar(result.second) ? PropagationStatus::kOk : PropagationStatus::kNotFinite;
+  return result;
+}
+
+/// Rows a track's follow would add in each direction. Outward rows are in
+/// increasing road order; inward rows are in the order they are found,
+/// outermost to innermost, and are reversed only when the combined RowChain
+/// is read. With the end decided again (`followEnd`), \a replacedEnd is the
+/// track's outermost row where the outward rows take its place; it goes only
+/// with them, if outward rows are kept after the passes.
+template <std::size_t K>
+struct FollowProposal {
+  std::uint32_t outward[K]{};
+  std::uint32_t inward[K]{};
+  std::uint32_t replacedEnd = std::numeric_limits<std::uint32_t>::max();
+  std::uint8_t outwardCount = 0U;
+  std::uint8_t inwardCount = 0U;
+};
+
+namespace follow
+{
+
+/// A track's kink steps in one follow: how many each direction took -- the budget, `maxKinks`, is the
+/// follow's, outward and inward together -- and, per
+/// direction, the rows that stand on the next one, the witness that
+/// confirmed them (bit i for row i). A row the beam line confirmed stands on
+/// none.
+struct KinkSteps {
+  std::uint64_t outwardWitnessed = 0U;
+  std::uint64_t inwardWitnessed = 0U;
+  std::uint8_t outward = 0U;
+  std::uint8_t inward = 0U;
+};
+
+/// How many of a direction's first \a count rows to keep so that every kept
+/// kink step keeps its witness: the rows from the last one standing on a row
+/// not kept are dropped with it.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() constexpr std::uint8_t keptWithWitnesses(std::uint8_t count, std::uint64_t witnessed)
+{
+  while (count != 0U && ((witnessed >> (count - 1U)) & 1U) != 0U) {
+    --count;
+  }
+  return count;
+}
+
+/// \a input, its covariance \a inputFactors (CovarianceFactors), carried to
+/// the plane \a to with the material's noise and energy loss between, as
+/// `detail::filterStep` carries a fit's state (`detail::transportStep`):
+/// \a output and \a outputFactors. Unlike the fit, it takes the field at
+/// \a input (`pointPropagator`) and refuses a step beyond half a turn.
+/// `cov` of neither state is read or written. False if the step is not usable.
+/// The follow's window carries the state to a layer's nominal surface with
+/// it (`predictedWindow`), and `updateCandidate` is this plus the update.
+/// With \a Scaled, \a noiseScale multiplies the step's theta0: the kink
+/// allowance's step; without, the nominal step,
+/// which never multiplies (`detail::scaledTheta0`). The body, inlined where
+/// it is called; the follow calls `transportCandidate`.
+template <bool Scaled, typename Prop, DetectorLayout Det, typename Material>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool transportCandidateInline(const Prop& prop, const TrackingGeometry<Det>& geometry, const Material& material, const TrackingSurface& to, PropagationDirection direction, const BoundTrackState& input, const CovarianceFactors& inputFactors, BoundTrackState& output, CovarianceFactors& outputFactors, Scalar noiseScale)
+{
+  const auto& from = geometry.planeOf(input);
+  const auto& propagator = pointPropagator(prop, from, input);
+  Scalar start[3]{};
+  surfaceToGlobal(from, input.loc0(), input.loc1(), start);
+  SolenoidJacobian jacobian;
+  PropagationResult propagated;
+  if (jacobianAnalytic(propagator, input, from, to, direction, jacobian, &output, &propagated) != PropagationStatus::kOk) {
+    return false;
+  }
+  // The turn is kappa times the transverse path, (q/p) Bz B2C times the 3D
+  // path: curvature() at sin(theta) = 1 against the 3D length.
+  if (beyondHalfTurn(propagator.curvature(static_cast<ExactScalar>(input.qOverP()), 1.) * static_cast<ExactScalar>(propagated.pathLength))) {
+    return false;
+  }
+  Scalar end[3]{};
+  surfaceToGlobal(to, output.loc0(), output.loc1(), end);
+  const auto step = detail::stepMaterial(material, start, end);
+  const Scalar momentum = 1.F / o2::gpu::CAMath::Abs(input.qOverP());
+  const Scalar betaP = betaMomentum(momentum, propagator.massGeV);
+  // As filterStep: the nearer half's noise before the transport, at the
+  // direction the step leaves with.
+  const auto before = scatteringNoise(detail::scaledTheta0<Scaled>(highlandTheta0(step.nearerX2X0, betaP), noiseScale), input.theta());
+  outputFactors = inputFactors;
+  return detail::transportStep<Scaled>(propagator, step, betaP, before, direction, jacobian, output, outputFactors, noiseScale) == PropagationStatus::kOk;
+}
+
+/// `transportCandidateInline`, never inlined on the device: the one copy
+/// every search shares. Only
+/// `FollowStage::passingOn` takes the body inline (`updateCandidate`'s
+/// \a Inlined).
+template <bool Scaled, typename Prop, DetectorLayout Det, typename Material>
+[[nodiscard]] GPUhdnii() bool transportCandidate(const Prop& prop, const TrackingGeometry<Det>& geometry, const Material& material, const TrackingSurface& to, PropagationDirection direction, const BoundTrackState& input, const CovarianceFactors& inputFactors, BoundTrackState& output, CovarianceFactors& outputFactors, Scalar noiseScale)
+{
+  return transportCandidateInline<Scaled>(prop, geometry, material, to, direction, input, inputFactors, output, outputFactors, noiseScale);
+}
+
+/// \a input, its covariance \a inputFactors (CovarianceFactors), carried to
+/// \a measurement (`transportCandidate`; with \a Scaled the step's scattering
+/// scaled by \a noiseScale, its theta0, so the variances by its square: the
+/// kink allowance's step) and updated with it:
+/// \a output and \a outputFactors, and the update's \a chi2 -- and, with
+/// \a Determinant, its innovation covariance's determinant into
+/// \a determinant (the follow's EndDensity). `cov` of neither state is read
+/// or written. False if the step or the update is not usable. With
+/// \a Inlined the transport is inlined (`transportCandidateInline`), else
+/// called.
+template <bool Scaled, bool Determinant = false, bool Inlined = false, typename Prop, DetectorLayout Det, typename Material>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool updateCandidate(const Prop& prop, const TrackingGeometry<Det>& geometry, const Material& material, const Measurement& measurement, PropagationDirection direction, const BoundTrackState& input, const CovarianceFactors& inputFactors, BoundTrackState& output, CovarianceFactors& outputFactors, Scalar& chi2, Scalar noiseScale, [[maybe_unused]] Scalar* determinant = nullptr)
+{
+  bool carried = false;
+  if constexpr (Inlined) {
+    carried = transportCandidateInline<Scaled>(prop, geometry, material, geometry.planeOf(measurement), direction, input, inputFactors, output, outputFactors, noiseScale);
+  } else {
+    carried = transportCandidate<Scaled>(prop, geometry, material, geometry.planeOf(measurement), direction, input, inputFactors, output, outputFactors, noiseScale);
+  }
+  if (!carried) {
+    return false;
+  }
+  const auto update = updateWithMeasurement<Determinant>(output, outputFactors, measurement, determinant);
+  chi2 = update.chi2;
+  // A negative chi2 would otherwise win the best-candidate comparison: the
+  // same test the fit passes make (`updateUsable`).
+  return updateUsable(update, outputFactors);
+}
+
+/// The half-widths of the planes `predictedWindow` builds: no bound [cm].
+inline constexpr Scalar kOpenBound = 1.e4F;
+
+/// The window of one step of a follow, narrowing \a window about the nominal crossing \a nominal. The
+/// state is
+/// carried to the plane touching the layer there, with the material's noise
+/// (`transportCandidate`, with \a Scaled the step's scattering scaled by
+/// \a noiseScale), and the window's half-widths are:
+///  - the gate's sigma of the prediction's spread, its covariance plus the
+///    pair windows' resolution term, projected onto phi and the second
+///    coordinate;
+///  - plus the layer's envelope about its nominal position, its
+///    measurements' radii on a barrel layer or z on a disc, times the track's
+///    slope there: a sensor anywhere in it, tilted, overlapping or curved, is
+///    crossed within that;
+///  - at most \a window's as given.
+/// Where the transport fails, \a window stands, and it returns false.
+/// Which candidate is taken is still the update's chi2 on its own sensor.
+/// \a reach, where given, gets the envelope's term alone, azimuth then the
+/// second coordinate: how far from the nominal crossing the track itself
+/// may cross a sensor of the layer (the follow's hole test).
+template <bool Scaled, typename Prop, DetectorLayout Det, typename Material>
+GPUhdi() bool predictedWindow(const Prop& prop, const IterationParameters<Det>& parameters, const TrackingGeometry<Det>& geometry, const Material& material, const BoundTrackState& state, const CovarianceFactors& factors, LayerID target, PropagationDirection direction, const LayerCrossingPrediction& nominal, CandidateWindow& window, Scalar noiseScale, Scalar* reach = nullptr)
+{
+  using Math = o2::gpu::CAMath;
+  const bool barrel = ((parameters.barrelLayers >> target) & 1U) != 0U;
+  // The plane touching the layer at the nominal crossing: on a barrel layer
+  // loc0 along r phi and loc1 along z, on a disc loc0 along r and loc1
+  // along r phi.
+  const Scalar position = parameters.layerSpans[target].position;
+  const Scalar radius = barrel ? position : nominal.second;
+  if (!(radius > 0.F)) {
+    return false;
+  }
+  Scalar sinPhi = 0.F;
+  Scalar cosPhi = 0.F;
+  sincosOf(nominal.phi, sinPhi, cosPhi);
+  TrackingSurface plane;
+  plane.origin[0] = radius * cosPhi;
+  plane.origin[1] = radius * sinPhi;
+  plane.origin[2] = barrel ? nominal.second : position;
+  const Scalar radial[3] = {cosPhi, sinPhi, 0.F};
+  const Scalar azimuthal[3] = {-sinPhi, cosPhi, 0.F};
+  const Scalar along[3] = {0.F, 0.F, 1.F};
+  for (int i = 0; i < 3; ++i) {
+    plane.axis0[i] = barrel ? azimuthal[i] : radial[i];
+    plane.axis1[i] = barrel ? along[i] : azimuthal[i];
+    plane.normal[i] = barrel ? radial[i] : along[i];
+  }
+  plane.bounds = {.halfX = kOpenBound, .halfY = kOpenBound};
+  plane.layer = target;
+  BoundTrackState predicted;
+  CovarianceFactors predictedFactors;
+  if (!transportCandidate<Scaled>(prop, geometry, material, plane, direction, state, factors, predicted, predictedFactors, noiseScale)) {
+    return false;
+  }
+  covarianceFromFactors(predictedFactors, predicted.cov);
+  const Scalar variance0 = predicted.variance(kLoc0) + parameters.followPositionVariance;
+  const Scalar variance1 = predicted.variance(kLoc1) + parameters.followPositionVariance;
+  if (!(variance0 > 0.F) || !(variance1 > 0.F)) {
+    return false;
+  }
+  // The window spans what the update's gate admits on one axis,
+  // sqrt(clusterChi2Max), not the pair cut's nSigma: a row the gate takes is
+  // never outside the window.
+  const Scalar nSigma = Math::Sqrt(parameters.clusterChi2Max);
+  const Scalar phiSpread = nSigma * Math::Sqrt(barrel ? variance0 : variance1) / radius;
+  const Scalar secondSpread = nSigma * Math::Sqrt(barrel ? variance1 : variance0);
+  // How far the crossing moves per unit of the layer's position, along the
+  // track there: alpha is its transverse direction from the radial one. The
+  // transverse path is 1 / cos(alpha) per unit of radius on a barrel layer,
+  // tan(theta) per unit of z on a disc.
+  Scalar sinAlpha = 0.F;
+  Scalar cosAlpha = 0.F;
+  sincosOf(predicted.phi() - nominal.phi, sinAlpha, cosAlpha);
+  Scalar sinTheta = 0.F;
+  Scalar cosTheta = 0.F;
+  sincosOf(predicted.theta(), sinTheta, cosTheta);
+  const Scalar transverse = barrel ? 1.F / Math::Abs(cosAlpha) : Math::Abs(sinTheta / cosTheta);
+  const Scalar phiSlope = transverse * Math::Abs(sinAlpha) / radius;
+  const Scalar secondSlope = transverse * (barrel ? Math::Abs(cosTheta / sinTheta) : Math::Abs(cosAlpha));
+  const auto& span = parameters.layerSpans[target];
+  const Scalar envelope = Math::Max(span.positionMax - position, position - span.positionMin);
+  // The window given first: a NaN or infinite slope leaves it.
+  window.phiHalfWidth = Math::Min(window.phiHalfWidth, phiSpread + (envelope * phiSlope));
+  window.secondHalfWidth = Math::Min(window.secondHalfWidth, secondSpread + (envelope * secondSlope));
+  if (reach != nullptr) {
+    reach[0] = envelope * phiSlope;
+    reach[1] = envelope * secondSlope;
+  }
+  return true;
+}
+
+/// The nominal crossing \a prediction of \a layer as a point [cm], into
+/// \a point: on a barrel layer its nominal radius at the crossing's azimuth
+/// and z, on a disc its radius and azimuth at the disc's z.
+template <DetectorLayout Det>
+GPUhdi() GPUAlwaysInline() void crossingPoint(const IterationParameters<Det>& parameters, LayerID layer, const LayerCrossingPrediction& prediction, Scalar* point)
+{
+  const bool barrel = ((parameters.barrelLayers >> layer) & 1U) != 0U;
+  const Scalar position = parameters.layerSpans[layer].position;
+  const Scalar r = barrel ? position : prediction.second;
+  Scalar sinPhi = 0.F;
+  Scalar cosPhi = 0.F;
+  sincosOf(prediction.phi, sinPhi, cosPhi);
+  point[0] = r * cosPhi;
+  point[1] = r * sinPhi;
+  point[2] = barrel ? prediction.second : position;
+}
+
+/// The centre of a step's window on \a layer, in the rows' coordinates: the
+/// nominal crossing \a prediction, which is the detector frame's, as its
+/// point's azimuth and second coordinate about the beam line, as the
+/// measurements have theirs (`gridPoint`).
+template <DetectorLayout Det>
+GPUhdi() GPUAlwaysInline() void windowCentre(const IterationParameters<Det>& parameters, LayerID layer, const LayerCrossingPrediction& prediction, Scalar& phi, Scalar& second)
+{
+  Scalar point[3]{};
+  crossingPoint(parameters, layer, prediction, point);
+  const Scalar x = point[0] - parameters.beamX;
+  const Scalar y = point[1] - parameters.beamY;
+  phi = azimuth(x, y);
+  second = secondCoordinate<Det>(layer, o2::gpu::CAMath::Hypot(x, y), point[2]);
+}
+
+/// What a follow's observer sees (`FollowStage::follow`); the default sees
+/// nothing and compiles to nothing:
+///  - each direction's start, and each step: the layer it leaves, its state,
+///    its covariance's factors (the state's own `cov` is not kept up to
+///    date) and the rows the direction has taken;
+///  - each target the step searches, with its window;
+///  - each row the search visits, with its outcome (`visit`) and the update's
+///    chi2 (0 where the update was not made);
+///  - a ranking by confirmation (the lookahead), with the rows passing;
+///  - each hole test, with whether the track crosses a sensor;
+///  - the kink pass, with the kinks left; each row it visits, with its
+///    outcome under the scaled step; each row passing it, with what confirms
+///    it: the next step's row (`ClusterList::kNoCluster` for the beam line)
+///    and its chi2, or nothing;
+///  - the row a step takes, its chi2 and whether a kink step took it;
+///  - the last row dropped as nothing confirms it (the unconfirmed drop), refused at the
+///    layout's end (EndDensity) or against the beam line (BeamEnd), and the
+///    end.
+struct NoObserver {
+  GPUhdi() GPUAlwaysInline() void begin(PropagationDirection /*direction*/) const {}
+  GPUhdi() GPUAlwaysInline() void step(LayerID /*layer*/, const BoundTrackState& /*state*/, const CovarianceFactors& /*factors*/, std::uint32_t /*rows*/) const {}
+  GPUhdi() GPUAlwaysInline() void target(LayerID /*layer*/, const CandidateWindow& /*window*/) const {}
+  GPUhdi() GPUAlwaysInline() void candidate(LayerID /*layer*/, std::uint32_t /*row*/, StepOutcome /*outcome*/, Scalar /*chi2*/) const {}
+  GPUhdi() GPUAlwaysInline() void lookahead(std::uint32_t /*passing*/) const {}
+  GPUhdi() GPUAlwaysInline() void hole(LayerID /*layer*/, bool /*crossed*/) const {}
+  GPUhdi() GPUAlwaysInline() void kink(std::uint32_t /*kinksLeft*/) const {}
+  GPUhdi() GPUAlwaysInline() void scaled(LayerID /*layer*/, std::uint32_t /*row*/, StepOutcome /*outcome*/, Scalar /*chi2*/) const {}
+  GPUhdi() GPUAlwaysInline() void confirmation(std::uint32_t /*row*/, bool /*confirmed*/, std::uint32_t /*next*/, Scalar /*chi2*/) const {}
+  /// the lookahead's confirmation of a nominal row (`confirm`): the row, its chi2, and
+  /// the next step's row confirming it and that row's chi2 (kNoCluster: none).
+  GPUhdi() GPUAlwaysInline() void lookaheadConfirmation(std::uint32_t /*row*/, Scalar /*chi2*/, std::uint32_t /*next*/, Scalar /*nextChi2*/) const {}
+  GPUhdi() GPUAlwaysInline() void taken(std::uint32_t /*row*/, Scalar /*chi2*/, bool /*kinked*/) const {}
+  GPUhdi() GPUAlwaysInline() void unconfirmed(std::uint32_t /*row*/) const {}
+  /// The last row refused at the layout's end (EndDensity's layout-end refusal).
+  GPUhdi() GPUAlwaysInline() void refusedEnd(std::uint32_t /*row*/) const {}
+  /// The inward last row refused against the beam line (BeamEnd).
+  GPUhdi() GPUAlwaysInline() void refusedBeamEnd(std::uint32_t /*row*/) const {}
+  GPUhdi() GPUAlwaysInline() void end(FollowEnd /*why*/) const {}
+};
+
+/// What a step's search reads: the iteration, the frame and its grid, the
+/// sensors, the material, the field and the used mask.
+template <DetectorLayout Det, typename Material>
+struct StepContext {
+  const IterationParameters<Det>* parameters = nullptr;
+  const TimeFrame<Det>* frame = nullptr;
+  const TrackingGeometry<Det>* geometry = nullptr;
+  const Material* material = nullptr;
+  const Propagator* propagator = nullptr;
+  const std::uint8_t* used = nullptr;
+};
+
+/// A step's row: the row, its update's chi2, and the state updated with it.
+struct Child {
+  std::uint32_t row = std::numeric_limits<std::uint32_t>::max();
+  Scalar chi2 = 0.F;
+  BoundTrackState state;
+  CovarianceFactors factors;
+};
+
+/// A step's row as EndDensity reads it: with its update's innovation covariance's determinant
+/// [cm^4]. A type of its own, so that the follow without it keeps `Child`.
+struct DensityChild : Child {
+  Scalar determinant = 0.F;
+};
+
+/// The follow's row type with or without \a EndDensity.
+template <bool EndDensity>
+using ChildOf = std::conditional_t<EndDensity, DensityChild, Child>;
+
+/// Where \a child's update writes its determinant (`updateCandidate`):
+/// nowhere for a `Child`.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar* determinantOf(Child& /*child*/) { return nullptr; }
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar* determinantOf(DensityChild& child) { return &child.determinant; }
+
+/// One search of a step: each row of \a layer the grid holds in \a window, in
+/// the grid's order, through the step's tests in the order `StepOutcome`
+/// names them: free (with \a Own, \a own counts as free: the track's own end
+/// decided again), inside the window's spatial bounds, its segment from
+/// (\a r, \a z) -- where the track stands -- crossing none of \a holes (0: no
+/// test, LinkHoles.h), and the update of \a state (its covariance \a factors)
+/// with it under the gate: the nominal update, or with \a Scaled the step's
+/// scattering scaled by \a noiseScale (`updateCandidate`). With
+/// \a EndDensity a candidate holds its update's determinant.
+/// \a report(row, outcome, chi2) sees every row; \a counter counts the
+/// updates made.
+///
+/// The lanes of \a group walk the window in step
+/// (`MeasurementGrid::visitCandidates`), each its share of the rows, and
+/// every lane calls \a step(candidate) at every step of the walk:
+/// \a candidate its row passing the gate, with the state updated with it and
+/// its factors, or none there (its row `kNoCluster`). So \a step may call
+/// the group's collectives. One lane has nothing to keep in step: it calls
+/// \a step for each row passing the gate alone, right after its report, in
+/// the grid's order. \a Inlined: the transport of each row inlined
+/// (`updateCandidate`). The body, inlined where it is called; the follow
+/// calls `visit`.
+template <bool Scaled, bool Own = false, bool EndDensity = false, bool Inlined = false, DetectorLayout Det, typename Material, typename Group, typename Report, typename Step>
+GPUhdi() GPUAlwaysInline() void visitInline(const StepContext<Det, Material>& context, const BoundTrackState& state, const CovarianceFactors& factors, Scalar r, Scalar z, LayerID layer, PropagationDirection direction, const CandidateWindow& window, std::uint64_t holes, Scalar noiseScale, WorkCounter counter, const Group& group, const Report& report, const Step& step, [[maybe_unused]] std::uint32_t own = std::numeric_limits<std::uint32_t>::max())
+{
+  const auto& parameters = *context.parameters;
+  const auto& frame = *context.frame;
+  const FollowGridScope followCounts;
+  // The tests before the update, each reported where it refuses the row.
+  const auto reaches = [&](std::uint32_t row) {
+    if (context.used[row] != kFree && (!Own || row != own)) {
+      report(row, StepOutcome::kUsed, 0.F);
+      return false;
+    }
+    const auto measurement = frame.measurement(row);
+    if (!spatiallyCompatible(window, measurement.phi, secondCoordinate<Det>(layer, measurement.r, measurement.z))) {
+      report(row, StepOutcome::kOutsideWindow, 0.F);
+      return false;
+    }
+    if (holes != 0U && segmentLeavesHole(holes, parameters.barrelLayers, parameters.layerSpans, r, z, measurement.r, measurement.z)) {
+      report(row, StepOutcome::kHole, 0.F);
+      return false;
+    }
+    return true;
+  };
+  // The update into \a candidate, its row set where it passes the gate.
+  const auto update = [&](std::uint32_t row, ChildOf<EndDensity>& candidate) {
+    countWork(counter);
+    Scalar chi2 = 0.F;
+    const bool usable = updateCandidate<Scaled, EndDensity, Inlined>(*context.propagator, *context.geometry, *context.material, measurementAt(frame, row), direction, state, factors, candidate.state, candidate.factors, chi2, noiseScale, determinantOf(candidate));
+    if (!usable) {
+      report(row, StepOutcome::kNoUpdate, 0.F);
+      return;
+    }
+    const bool passes = chi2 <= parameters.clusterChi2Max;
+    report(row, passes ? StepOutcome::kPasses : StepOutcome::kChi2, chi2);
+    if (passes) {
+      candidate.row = row;
+      candidate.chi2 = chi2;
+    }
+  };
+  if constexpr (Group::kLanes == 1U) {
+    // One lane: the grid's walk of one thread, the candidate of the row
+    // alone, made where it is updated.
+    frame.grid().visitCandidates(layer, window, frame.grid().geometry().allBlocks(), [&](std::uint32_t row) {
+      if (!reaches(row)) {
+        return;
+      }
+      ChildOf<EndDensity> candidate;
+      update(row, candidate);
+      if (candidate.row != std::numeric_limits<std::uint32_t>::max()) {
+        step(candidate);
+      }
+    });
+  } else {
+    // A group: one candidate a lane for the window, its row reset at every
+    // step; the state and its factors are written by the update before they
+    // are read.
+    ChildOf<EndDensity> candidate;
+    frame.grid().visitCandidates(
+      layer, window, frame.grid().geometry().allBlocks(),
+      [&](std::uint32_t row, bool has) {
+        candidate.row = std::numeric_limits<std::uint32_t>::max();
+        if (has && reaches(row)) {
+          update(row, candidate);
+        }
+        step(candidate);
+      },
+      group);
+  }
+}
+
+/// `visitInline`, never inlined on the device: one copy for each call site,
+/// which the kernels then do not absorb.
+template <bool Scaled, bool Own = false, bool EndDensity = false, DetectorLayout Det, typename Material, typename Group, typename Report, typename Step>
+GPUhdnii() void visit(const StepContext<Det, Material>& context, const BoundTrackState& state, const CovarianceFactors& factors, Scalar r, Scalar z, LayerID layer, PropagationDirection direction, const CandidateWindow& window, std::uint64_t holes, Scalar noiseScale, WorkCounter counter, const Group& group, const Report& report, const Step& step, [[maybe_unused]] std::uint32_t own = std::numeric_limits<std::uint32_t>::max())
+{
+  visitInline<Scaled, Own, EndDensity>(context, state, factors, r, z, layer, direction, window, holes, noiseScale, counter, group, report, step, own);
+}
+
+/// \a candidate of lane \a from of \a group, on every lane: its row, chi2,
+/// parameters, surface and factors (and with \a EndDensity its determinant).
+/// Its covariance is \a origin's -- the state
+/// the step's updates started from: `transportCandidate` and the update carry
+/// the input's `cov` unchanged (the factors are the covariance), so every
+/// candidate of a step holds the same one and it is not sent.
+template <typename Group, typename Row>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() decltype(auto) shared(const Group& group, const Row& candidate, std::uint32_t from, const BoundTrackState& origin)
+{
+  if constexpr (Group::kLanes == 1U) {
+    // The candidate itself: one lane has it already.
+    static_cast<void>(group);
+    static_cast<void>(from);
+    static_cast<void>(origin);
+    return (candidate);
+  } else {
+    struct Wire {
+      std::uint32_t row;
+      Scalar chi2;
+      Scalar par[kNBoundParams];
+      SensorID surface;
+      Scalar surfacePhi;
+      CovarianceFactors factors;
+    };
+    Wire wire{
+      .row = candidate.row,
+      .chi2 = candidate.chi2,
+      .par = {},
+      .surface = candidate.state.surface,
+      .surfacePhi = candidate.state.surfacePhi,
+      .factors = candidate.factors,
+    };
+    for (int i = 0; i < kNBoundParams; ++i) {
+      wire.par[i] = candidate.state.par[i];
+    }
+    wire = group.broadcast(wire, from);
+    Row out;
+    if constexpr (std::is_same_v<Row, DensityChild>) {
+      out.determinant = group.broadcast(candidate.determinant, from);
+    }
+    out.row = wire.row;
+    out.chi2 = wire.chi2;
+    for (int i = 0; i < kNBoundParams; ++i) {
+      out.state.par[i] = wire.par[i];
+    }
+    for (int i = 0; i < kBoundCovSize; ++i) {
+      out.state.cov[i] = origin.cov[i];
+    }
+    out.state.surface = wire.surface;
+    out.state.surfacePhi = wire.surfacePhi;
+    out.factors = wire.factors;
+    return out;
+  }
+}
+
+/// What `FollowStage::passingOn` sees on a layer: the rows passing the nominal gate, whether the row asked
+/// about is among them and its chi2, and the smallest chi2 of the others.
+struct Passing {
+  std::uint32_t count = 0U;
+  bool own = false;
+  Scalar ownChi2 = 0.F;
+  Scalar otherChi2 = std::numeric_limits<Scalar>::max();
+};
+
+/// The witness of a confirmation: the row the next step takes, by the
+/// nominal pass's choice -- the smallest chi2, the row breaking ties -- or
+/// none (`kNoCluster`).
+struct Witness {
+  std::uint32_t row = std::numeric_limits<std::uint32_t>::max();
+  Scalar chi2 = 0.F;
+};
+
+/// Whether \a row with \a chi2 beats \a best: the nominal pass's choice, as
+/// the one-lane walk makes it row by row. Over the usable, gated chi2 (no
+/// NaN) a strict total order on the rows, so the choice does not depend on
+/// the order the rows come in.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool beats(std::uint32_t row, Scalar chi2, const Witness& best) { return best.row == std::numeric_limits<std::uint32_t>::max() || chi2 < best.chi2 || (!(best.chi2 < chi2) && row < best.row); }
+
+/// The best of the lanes' \a own witnesses (`beats`), on every lane of
+/// \a group.
+template <typename Group>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Witness bestOf(const Group& group, const Witness& own)
+{
+  if constexpr (Group::kLanes == 1U) {
+    return own;
+  } else {
+    Witness best;
+    for (auto lanes = group.ballot(own.row != std::numeric_limits<std::uint32_t>::max()); lanes != 0U; lanes &= lanes - 1U) {
+      const auto other = group.broadcast(own, o2::gpu::CAMath::Ctz64(lanes));
+      if (beats(other.row, other.chi2, best)) {
+        best = other;
+      }
+    }
+    return best;
+  }
+}
+
+/// The most links leaving or entering one layer of \a Det: the targets a
+/// step orders.
+template <DetectorLayout Det>
+inline constexpr std::size_t maxDegree = [] {
+  std::size_t most = 1U;
+  for (std::size_t layer = 0; layer < static_cast<std::size_t>(Detector<Det>::nLayers); ++layer) {
+    most = std::max(most, outLinks<Det>.count(static_cast<LayerID>(layer)));
+    most = std::max(most, inLinks<Det>.count(static_cast<LayerID>(layer)));
+  }
+  return most;
+}();
+
+/// One direction of a track's follow: where it stands, its covariance's
+/// factors, the rows it took, the last one's chi2 (the unconfirmed drop removes it), the holes it
+/// crossed, whether its latest step, one that took no row, crossed a
+/// sensor without a row, and the track's own row its searches take as free
+/// (the end decided again, `followEnd`; none otherwise).
+template <std::size_t K>
+struct Branch {
+  BoundTrackState state;
+  CovarianceFactors factors;
+  std::uint32_t rows[K]{};
+  Scalar lastChi2 = 0.F;
+  std::uint32_t count = 0U;
+  std::uint32_t holes = 0U;
+  std::uint32_t own = std::numeric_limits<std::uint32_t>::max();
+  bool crossed = false;
+};
+
+/// A direction as EndDensity reads it: with its last row's update's
+/// determinant [cm^4], and whether a kink step took it -- its update's V the
+/// scaled one, its confirmation the witness. A type of its own, so that the
+/// follow without it keeps `Branch`.
+template <std::size_t K>
+struct DensityBranch : Branch<K> {
+  Scalar lastDeterminant = 0.F;
+  bool lastKink = false;
+};
+
+/// The follow's direction type with or without \a EndDensity.
+template <std::size_t K, bool EndDensity>
+using BranchOf = std::conditional_t<EndDensity, DensityBranch<K>, Branch<K>>;
+
+/// What BeamEnd reads of an inward walk: the states its last two steps started from -- entry 0 the
+/// latest -- their factors, whether a kink step took the row, and how many
+/// rows the walk took. A row the unconfirmed drop or the layout's end removes makes the one
+/// before the last: entry 1.
+struct BeamEndHistory {
+  BoundTrackState state[2];
+  CovarianceFactors factors[2];
+  bool kink[2] = {true, true};
+  std::uint32_t taken = 0U;
+
+  /// A step from \a from (its factors \a fromFactors) taking a row, by a
+  /// kink step where \a kinked.
+  GPUhdi() GPUAlwaysInline() void remember(const BoundTrackState& from, const CovarianceFactors& fromFactors, bool kinked)
+  {
+    state[1] = state[0];
+    factors[1] = factors[0];
+    kink[1] = kink[0];
+    state[0] = from;
+    factors[0] = fromFactors;
+    kink[0] = kinked;
+    ++taken;
+  }
+};
+
+/// The follow without BeamEnd keeps nothing.
+struct NoBeamEndHistory {
+};
+
+/// The inward walk's history with or without \a BeamEnd.
+template <bool BeamEnd>
+using BeamEndHistoryOf = std::conditional_t<BeamEnd, BeamEndHistory, NoBeamEndHistory>;
+
+/// A layer a step may reach: its nominal crossing and its distance from the
+/// track, squared.
+struct Target {
+  Scalar distance2 = 0.F;
+  LayerID layer = 0;
+  LayerCrossingPrediction prediction;
+};
+
+} // namespace follow
+
+/// One track's follow: outward from its outward
+/// state, then inward from its inner state, into its proposal. It reads the
+/// grid and the used mask, and writes only its own proposal and kink steps.
+///
+/// A step, in either direction:
+///  - **Navigation.** The layers every link of the layout reaches from the
+///    one the track stands on (enters it, inward), skip links included, in
+///    the order the track crosses them: by the distance of the nominal
+///    crossing from the track. The first with a free row within the gate
+///    gives the step's row. A layer the state cannot be carried to is
+///    passed.
+///  - **The window.** The prediction's own (`predictedWindow`) and the
+///    track's time box, which every row taken narrows, outward then inward.
+///  - **Holes.** A layer without a row is a hole only where the track crosses
+///    one of its sensors within its bounds (SensorCells.h); a gap costs
+///    nothing. Past the iteration's `followHoles` the direction ends; each
+///    direction has its own count.
+///  - **The lookahead.** Where more than one row passes, each is taken and the next step
+///    made from there: the rows it confirms rank first, by their chi2 plus
+///    the confirming row's; the others by their chi2; then the row.
+///  - **Kinks.** Only where the nominal pass ends the step, the same walk
+///    again with each target's scattering scaled by the iteration's kink
+///    allowance, its own hole count, under the kink budget the directions
+///    share. A row it admits is taken only if the next step, nominal, has a
+///    row from it -- or, past the innermost layer inward with the beam
+///    constraint, the beam line -- by its chi2 plus that row's; its witness
+///    bit says the next row stands on it (`KeepWitnesses`).
+///  - **The unconfirmed drop.** A direction whose last step crossed a sensor without a row
+///    drops its last row, which nothing confirms -- unless its chi2 is below
+///    the iteration's `followKeepChi2` (0: never), or, inward, unless that step
+///    saw a row near: one within its window the update refused above the
+///    gate, or one the kink pass admitted and could not confirm (inward the
+///    sensor usually held the particle's row, refused; outward the row near
+///    is a noise row too often). The row
+///    seen is not taken.
+///
+/// Inward starts from the inner state updated with the beam line where the
+/// iteration has the beam constraint (\a BeamLine, its own instantiation),
+/// and does not run where the iteration shares innermost rows (\a inward).
+/// The directions share one capacity, the longest chain less the track's
+/// rows.
+///
+/// With \a DecidesEnd, the iteration's `followEnd`, the track's outermost row is decided again (`decideEnd`): from
+/// the road fit's outward pass without it (`follow::EndFit`, a pass of its
+/// own before the stage, \a endStarts), the walk outward, that row free to
+/// it. Its first row the end: the walk's rows beyond it are the
+/// outward follow. Another: the walk's rows replace the end. None: the end
+/// stays and the follow is as without. An iteration without `follow` walks
+/// one row, the end alone, and nothing inward.
+///
+/// With \a Greedy, the iteration's `followGreedy`, a step more than one row passes takes the smallest chi2, the
+/// row breaking ties (`follow::beats`), instead of the lookahead's confirmation.
+///
+/// With \a EndDensity, where the iteration has `followEndMaxSqrtDet` or
+/// `followKeepDensity`, a
+/// direction's end is decided on its last row's own update, V = H P H^T + R
+/// and the chi2, where a nominal step took it:
+///  - **inward at the layout's end** -- the layer it stands on has no
+///    inward link -- the last row goes where sqrt|V| is above
+///    `followEndMaxSqrtDet`: a prediction carried that far admits strangers;
+///  - **outward, where the unconfirmed drop would remove it**, the last row stays where its
+///    Gaussian density g = exp(-chi2 / 2) / (2 pi sqrt|V|) is above
+///    `followKeepDensity`: the keep's chi2 with a penalty for a wide
+///    prediction.
+///
+/// With \a BeamEnd, the iteration's `followBeamEnd` (only with \a BeamLine), the inward walk's last
+/// row, where a nominal step took it, is tested against that step's
+/// prediction updated with the beam line (`refusesBeamEnd`): refused above
+/// the gate. Its own step saw only the rows outside; the beam line is the
+/// evidence beyond the last row inward, where the strangers of the vertex
+/// detector -- QED pairs in Pb-Pb -- pass the step alone.
+template <DetectorLayout Det, typename Material, bool BeamLine = false, bool DecidesEnd = false, bool Greedy = false, bool EndDensity = false, bool BeamEnd = false>
+class FollowStage
+{
+ public:
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  static_assert(kMaxClusters <= 64U, "a kink step's witness is a bit of a 64-bit mask");
+  static_assert(BeamLine || !BeamEnd, "the beam-line end needs the iteration's beam constraint");
+  /// Whether it decides the track's end again (`DecidesEnd`).
+  static constexpr bool kDecidesEnd = DecidesEnd;
+  using TrackView = typename BoundedColumns<TrackOf<kMaxClusters>::template RecordT>::ConstView;
+  using Proposal = FollowProposal<kMaxClusters>;
+  using Branch = follow::BranchOf<kMaxClusters, EndDensity>;
+  using Child = follow::ChildOf<EndDensity>;
+
+  FollowStage(const IterationParameters<Det>* parameters, const TimeFrame<Det>* frame, const TrackingGeometry<Det>* geometry, const Material* material, const Propagator& propagator, TrackView tracks, const std::uint8_t* used, const std::uint32_t* maxCandidateWidthPS, SensorCellsView cells, Proposal* proposals, follow::KinkSteps* kinkSteps, bool inward, std::uint32_t trackOffset, const BoundTrackState* endStarts = nullptr)
+    : mParameters(parameters),
+      mFrame(frame),
+      mGeometry(geometry),
+      mMaterial(material),
+      mPropagator(propagator),
+      mTracks(tracks),
+      mUsed(used),
+      mMaxCandidateWidthPS(maxCandidateWidthPS),
+      mCells(cells),
+      mProposals(proposals),
+      mKinkSteps(kinkSteps),
+      mInward(inward),
+      mTrackOffset(trackOffset),
+      mEndStarts(endStarts)
+  {
+  }
+
+  GPUhdi() void operator()(std::uint32_t track) const { together(track, SoloGroup{}); }
+
+  /// `operator()` for the lanes of \a group, which follow \a track together:
+  /// every lane makes the same decisions, the
+  /// first writes the proposal.
+  template <typename Group>
+  GPUhdi() void together(std::uint32_t track, const Group& group) const
+  {
+    const std::uint32_t input = mTrackOffset + track;
+    Proposal proposal;
+    for (std::size_t i = 0; i < kMaxClusters; ++i) {
+      proposal.outward[i] = ClusterList<kMaxClusters>::kNoCluster;
+      proposal.inward[i] = ClusterList<kMaxClusters>::kNoCluster;
+    }
+    follow::KinkSteps steps;
+    if (mTracks.status[input] == PropagationStatus::kOk) {
+      follow(mTracks.state[input], mTracks.outwardState[input], mTracks.clusters[input], mTracks.count[input], proposal, steps, follow::NoObserver{}, mEndStarts != nullptr ? mEndStarts + track : nullptr, group);
+    }
+    if (group.lane() == 0U) {
+      mProposals[track] = proposal;
+      if (mKinkSteps != nullptr) {
+        mKinkSteps[track] = steps;
+      }
+    }
+  }
+
+  /// A track's follow from \a inner and \a outer, its inner and outward
+  /// states, its \a count rows \a rows giving the time box, into
+  /// \a proposal's rows and \a steps' kink steps (both empty before),
+  /// \a observe seeing every decision: what `operator()` does for a track,
+  /// for the bench's replay too. With \a DecidesEnd, \a endStart is the
+  /// track's state without its outermost row (`follow::EndFit`). The lanes of
+  /// \a group follow it together.
+  template <typename Observer, typename Group = SoloGroup>
+  GPUhdi() void follow(const BoundTrackState& inner, const BoundTrackState& outer, const ClusterList<kMaxClusters>& rows, std::uint32_t count, Proposal& proposal, follow::KinkSteps& steps, const Observer& observe, [[maybe_unused]] const BoundTrackState* endStart = nullptr, const Group& group = {}) const
+  {
+    // A track as long as a chain can be is not followed.
+    if (count >= kMaxClusters) {
+      return;
+    }
+    if constexpr (DecidesEnd) {
+      if (endStart != nullptr && endStart->surface != kInvalidSensorID && decideEnd(inner, *endStart, rows, count, proposal, steps, observe, group)) {
+        return;
+      }
+      if (!mParameters->follow) {
+        return;
+      }
+    }
+    const std::uint32_t capacity = static_cast<std::uint32_t>(kMaxClusters) - count;
+    auto box = trackTimeBox(mFrame->measurements(), rows, static_cast<std::uint8_t>(count));
+    std::uint32_t kinks = 0U;
+    proposal.outwardCount = walk(outer, PropagationDirection::kForward, proposal.outward, capacity, box, kinks, steps.outwardWitnessed, observe, std::numeric_limits<std::uint32_t>::max(), group);
+    walkInward(inner, rows.index[0], capacity - proposal.outwardCount, box, kinks, proposal, steps, observe, group);
+  }
+
+  /// The free rows of \a layer passing the nominal gate from \a state, its
+  /// covariance \a factors, in \a direction within the time \a box: what a
+  /// nominal step from there would see on that layer, \a own among them or
+  /// not (`follow::TrimAmbiguous`). None where no link of the layout leads from
+  /// the state's layer to \a layer, or the window cannot be made.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() follow::Passing passingOn(const BoundTrackState& state, const CovarianceFactors& factors, LayerID layer, std::uint32_t own, const TimeEstPS& box, PropagationDirection direction) const
+  {
+    follow::Target targets[follow::maxDegree<Det>];
+    const std::uint32_t nTargets = targetsOf(state, direction, targets);
+    for (std::uint32_t t = 0; t < nTargets; ++t) {
+      const auto& target = targets[t];
+      if (target.layer != layer) {
+        continue;
+      }
+      CandidateWindow window;
+      Scalar reach[2]{};
+      if (!targetWindow<false>(state, factors, box, target, direction, 1.F, window, reach)) {
+        return {};
+      }
+      follow::Passing passing;
+      // The search inlined with its transports: called, it slows
+      // `TrimAmbiguous`'s kernel on a device.
+      follow::visitInline<false, false, false, true>(
+        context(), state, factors, 0.F, 0.F, target.layer, direction, window, 0U, 1.F, WorkCounter::kFollowTrimUpdates, SoloGroup{}, [](std::uint32_t /*row*/, StepOutcome /*outcome*/, Scalar /*chi2*/) {},
+        [&](const follow::Child& candidate) {
+          ++passing.count;
+          if (candidate.row == own) {
+            passing.own = true;
+            passing.ownChi2 = candidate.chi2;
+          } else {
+            passing.otherChi2 = o2::gpu::CAMath::Min(passing.otherChi2, candidate.chi2);
+          }
+        });
+      return passing;
+    }
+    return {};
+  }
+
+  /// The walk inward after the outward one, from \a inner (`inwardStart`)
+  /// over \a capacity rows at most, where the stage follows inward and rows
+  /// are left: \a kinks the outward walk's so far, then both counts into
+  /// \a steps.
+  template <typename Observer, typename Group>
+  GPUhdi() GPUAlwaysInline() void walkInward(const BoundTrackState& inner, std::uint32_t innermostRow, std::uint32_t capacity, TimeEstPS& box, std::uint32_t& kinks, Proposal& proposal, follow::KinkSteps& steps, const Observer& observe, const Group& group) const
+  {
+    steps.outward = static_cast<std::uint8_t>(kinks);
+    if (mInward && capacity != 0U) {
+      proposal.inwardCount = walk(inwardStart(inner, innermostRow), PropagationDirection::kBackward, proposal.inward, capacity, box, kinks, steps.inwardWitnessed, observe, std::numeric_limits<std::uint32_t>::max(), group);
+    }
+    steps.inward = static_cast<std::uint8_t>(kinks - steps.outward);
+  }
+
+  /// The track's outermost row decided again (\a DecidesEnd): from \a start,
+  /// \a rows' first \a count - 1 fitted outward (`follow::EndFit`), the
+  /// walk outward with the end free to it -- the follow's capacity, or one
+  /// row without `follow`. Whether the walk took a row: then \a proposal and
+  /// \a steps hold the follow, inward too with `follow`; else they are
+  /// untouched.
+  template <typename Observer, typename Group>
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool decideEnd(const BoundTrackState& inner, const BoundTrackState& start, const ClusterList<kMaxClusters>& rows, std::uint32_t count, Proposal& proposal, follow::KinkSteps& steps, const Observer& observe, const Group& group) const
+  {
+    const std::uint32_t end = rows.index[count - 1U];
+    const std::uint32_t capacity = mParameters->follow ? static_cast<std::uint32_t>(kMaxClusters) - (count - 1U) : 1U;
+    auto box = trackTimeBox(mFrame->measurements(), rows, static_cast<std::uint8_t>(count - 1U));
+    std::uint32_t kinks = 0U;
+    std::uint64_t witnessed = 0U;
+    std::uint32_t walked[kMaxClusters];
+    const std::uint8_t taken = walk(start, PropagationDirection::kForward, walked, capacity, box, kinks, witnessed, observe, end, group);
+    if (taken == 0U) {
+      return false;
+    }
+    // The end taken again: the rows beyond it, and their witnesses, are the
+    // follow outward; another row: the walk's rows replace the end.
+    const bool replaced = walked[0] != end;
+    const std::uint32_t first = replaced ? 0U : 1U;
+    if (replaced) {
+      countWork(WorkCounter::kFollowEndReplaced);
+      proposal.replacedEnd = end;
+    }
+    for (std::uint32_t i = first; i < taken; ++i) {
+      proposal.outward[i - first] = walked[i];
+    }
+    proposal.outwardCount = static_cast<std::uint8_t>(taken - first);
+    steps.outwardWitnessed = witnessed >> first;
+    const std::uint32_t held = count - (replaced ? 1U : 0U) + proposal.outwardCount;
+    walkInward(inner, rows.index[0], mParameters->follow && held < kMaxClusters ? static_cast<std::uint32_t>(kMaxClusters) - held : 0U, box, kinks, proposal, steps, observe, group);
+    return true;
+  }
+
+  /// Where the inward follow starts: \a inner, with \a BeamLine updated with
+  /// the beam line, \a innermost the track's innermost row -- the nominal
+  /// update, or, where the iteration has a kink allowance and the nominal
+  /// update is above the gate, the update with the scattering inside scaled
+  /// by it, as `clearsBeamLine` admitted the road.
+  [[nodiscard]] GPUhdi() BoundTrackState inwardStart(const BoundTrackState& inner, std::uint32_t innermost) const
+  {
+    if constexpr (BeamLine) {
+      BoundTrackState constrained = inner;
+      const auto& plane = mGeometry->planeOf(inner);
+      const LayerID layer = mGeometry->surface(inner.surface).layer;
+      const auto point = pairPointAt(mFrame->measurements(), innermost);
+      const auto update = updateWithBeamLine(mPropagator, *mParameters, plane, layer, point, constrained);
+      if (update.ok && !(update.chi2 <= mParameters->beamChi2Max) && mParameters->kinkScale2 > 1.F) {
+        constrained = inner;
+        static_cast<void>(updateWithBeamLine(mPropagator, *mParameters, plane, layer, point, constrained, mParameters->kinkScale2));
+      }
+      return constrained;
+    } else {
+      static_cast<void>(innermost);
+      return inner;
+    }
+  }
+
+  /// One direction of a follow from \a start: at most \a capacity rows into
+  /// \a rows, \a box the track's time box, \a kinks the kink steps the
+  /// follow took so far, \a witnessed a bit per row standing on the next
+  /// one, \a own a row of the track its searches take as free (with
+  /// \a DecidesEnd); how many rows. The lanes of \a group walk it together.
+  template <typename Observer, typename Group = SoloGroup>
+  GPUhdi() GPUAlwaysInline() std::uint8_t walk(const BoundTrackState& start, PropagationDirection direction, std::uint32_t* rows, std::uint32_t capacity, TimeEstPS& box, std::uint32_t& kinks, std::uint64_t& witnessed, const Observer& observe, std::uint32_t own = std::numeric_limits<std::uint32_t>::max(), const Group& group = {}) const
+  {
+    observe.begin(direction);
+    Branch branch;
+    branch.own = own;
+    branch.state = start;
+    branch.factors = factorCovariance(start.cov);
+    auto end = FollowEnd::kCapacity;
+    // Whether the latest step saw a row near where it took none (the unconfirmed drop, below).
+    bool nearMiss = false;
+    [[maybe_unused]] follow::BeamEndHistoryOf<BeamEnd> history; // NOLINT(misc-const-correctness): written in a dependent call the check does not see
+    while (branch.count < capacity) {
+      const LayerID current = mGeometry->surface(branch.state.surface).layer;
+      observe.step(current, branch.state, branch.factors, branch.count);
+      follow::Target targets[follow::maxDegree<Det>];
+      const std::uint32_t nTargets = targetsOf(branch.state, direction, targets);
+      if (nTargets == 0U) {
+        end = FollowEnd::kNoTarget;
+        break;
+      }
+      const std::uint32_t holesBefore = branch.holes;
+      branch.crossed = false;
+      nearMiss = false;
+      Child child;
+      if (nominal(branch, box, direction, targets, nTargets, child, nearMiss, observe, group)) {
+        observe.taken(child.row, child.chi2, false);
+        if constexpr (BeamEnd) {
+          if (direction == PropagationDirection::kBackward) {
+            history.remember(branch.state, branch.factors, false);
+          }
+        }
+        take(branch, box, child);
+        continue;
+      }
+      end = branch.holes > mParameters->followHoles ? FollowEnd::kHoles : FollowEnd::kNoRow;
+      // The kink pass: no target had a row within the holes.
+      if (mParameters->kinkScale2 > 1.F && kinks < mParameters->maxKinks) {
+        observe.kink(mParameters->maxKinks - kinks);
+        countWork(WorkCounter::kFollowKinkSteps);
+        std::uint32_t kinkHoles = holesBefore;
+        bool onNext = false;
+        if (kinkStep(branch, box, direction, targets, nTargets, child, kinkHoles, onNext, nearMiss, observe, group)) {
+          ++kinks;
+          countWork(WorkCounter::kFollowKinksTaken);
+          witnessed |= onNext ? std::uint64_t{1} << branch.count : std::uint64_t{0};
+          observe.taken(child.row, child.chi2, true);
+          if constexpr (BeamEnd) {
+            if (direction == PropagationDirection::kBackward) {
+              history.remember(branch.state, branch.factors, true);
+            }
+          }
+          take(branch, box, child);
+          if constexpr (EndDensity) {
+            branch.lastKink = true;
+          }
+          branch.holes = kinkHoles;
+          continue;
+        }
+      }
+      break;
+    }
+    // The unconfirmed drop: the last step crossed a sensor
+    // without a row; the last row, which nothing confirms, goes -- unless,
+    // inward, the step saw a row near (inward that row is almost always the
+    // particle's own, outward a noise row often enough to add fakes, so
+    // the outward unconfirmed drop stands).
+    // A last row under the iteration's followKeepChi2 stays (the outward unconfirmed drop
+    // drops mostly the particle's own rows, the wrong ones at the higher
+    // chi2).
+    const bool evidence = (direction == PropagationDirection::kBackward && nearMiss) || branch.lastChi2 < mParameters->followKeepChi2;
+    // With EndDensity also an
+    // outward last row of a high density stays (`densityKept`).
+    if (branch.crossed && !evidence && branch.count != 0U && !densityKept(branch, direction)) {
+      --branch.count;
+      countWork(WorkCounter::kFollowUnconfirmed);
+      observe.unconfirmed(branch.rows[branch.count]);
+    }
+    if constexpr (EndDensity) {
+      // At every exit: a row taken as the last the capacity allows leaves
+      // the loop before the search for targets. Never where the unconfirmed drop removed a
+      // row: a layer without an inward link has no targets, so the walk
+      // crossed nothing there. A refused row a kink row stood on takes that
+      // row with it (`KeepWitnesses`).
+      if (refusesLayoutEnd(branch, direction)) {
+        --branch.count;
+        countWork(WorkCounter::kFollowEndRefused);
+        observe.refusedEnd(branch.rows[branch.count]);
+      }
+    }
+    if constexpr (BeamEnd) {
+      // After the unconfirmed drop and the layout's end, on the row that stands last; a
+      // refused row a kink row stood on takes that row with it
+      // (`KeepWitnesses`).
+      if (refusesBeamEnd(branch, direction, history)) {
+        --branch.count;
+        countWork(WorkCounter::kFollowBeamEndRefused);
+        observe.refusedBeamEnd(branch.rows[branch.count]);
+      }
+    }
+    observe.end(end);
+    for (std::uint32_t i = 0; i < branch.count; ++i) {
+      rows[i] = branch.rows[i];
+    }
+    return static_cast<std::uint8_t>(branch.count);
+  }
+
+ private:
+  /// EndDensity's density keep, asked where the unconfirmed drop would remove \a branch's last row:
+  /// whether, outward and taken by a nominal step, it has its density g
+  /// above the iteration's `followKeepDensity` -- in logs, chi2 + log|V|
+  /// below -2 log(2 pi key). A determinant that is not positive never keeps.
+  /// Without EndDensity, false.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool densityKept(const Branch& branch, PropagationDirection direction) const
+  {
+    if constexpr (EndDensity) {
+      using Math = o2::gpu::CAMath;
+      const Scalar key = mParameters->followKeepDensity;
+      const bool kept = direction == PropagationDirection::kForward && key > 0.F && !branch.lastKink && branch.lastDeterminant > 0.F && branch.lastChi2 + Math::Log(branch.lastDeterminant) < -2.F * Math::Log(2.F * std::numbers::pi_v<Scalar> * key);
+      countWork(WorkCounter::kFollowDensityKept, kept ? 1U : 0U);
+      return kept;
+    } else {
+      static_cast<void>(branch);
+      static_cast<void>(direction);
+      return false;
+    }
+  }
+
+  /// EndDensity's layout-end refusal: whether \a branch, inward, stands at the layout's
+  /// end -- no inward link from its layer, not a search whose every
+  /// prediction failed -- on a row a nominal step took with sqrt|V| above the
+  /// iteration's `followEndMaxSqrtDet`.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool refusesLayoutEnd(const Branch& branch, PropagationDirection direction) const
+  {
+    const Scalar key = mParameters->followEndMaxSqrtDet;
+    if (direction != PropagationDirection::kBackward || !(key > 0.F) || branch.count == 0U || branch.lastKink) {
+      return false;
+    }
+    const LayerID current = mGeometry->surface(branch.state.surface).layer;
+    return mParameters->allInLinkOffsets[current] == mParameters->allInLinkOffsets[current + 1U] && branch.lastDeterminant > key * key;
+  }
+
+  /// BeamEnd's rule: whether \a branch, inward, ends on a row a nominal step
+  /// took (from \a history's state) whose chi2 against that step's
+  /// prediction updated with the beam line is above the gate. The
+  /// prediction carried as the step carried it, the update at the row's
+  /// sensor from the row's pair point (`updateWithBeamLine`), the residual's
+  /// covariance in double as the update's. A prediction or an update that
+  /// fails, or a determinant that is not positive, refuses nothing.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool refusesBeamEnd(const Branch& branch, PropagationDirection direction, const follow::BeamEndHistory& history) const
+  {
+    if (direction != PropagationDirection::kBackward || branch.count == 0U) {
+      return false;
+    }
+    // The rows the unconfirmed drop and the layout's end dropped: at most one of the two acts.
+    const std::uint32_t dropped = history.taken - branch.count;
+    if (dropped > 1U || history.kink[dropped]) {
+      return false;
+    }
+    const std::uint32_t row = branch.rows[branch.count - 1U];
+    const auto measurement = measurementAt(*mFrame, row);
+    const auto& plane = mGeometry->planeOf(measurement);
+    BoundTrackState predicted;
+    CovarianceFactors carried;
+    if (!follow::transportCandidate<false>(mPropagator, *mGeometry, *mMaterial, plane, direction, history.state[dropped], history.factors[dropped], predicted, carried, 1.F)) {
+      return false;
+    }
+    covarianceFromFactors(carried, predicted.cov);
+    const LayerID layer = mGeometry->surface(measurement.surface).layer;
+    if (!updateWithBeamLine(mPropagator, *mParameters, plane, layer, pairPointAt(mFrame->measurements(), row), predicted).ok) {
+      return false;
+    }
+    const auto v00 = static_cast<ExactScalar>(predicted.variance(kLoc0)) + static_cast<ExactScalar>(measurement.varLoc0);
+    const auto v11 = static_cast<ExactScalar>(predicted.variance(kLoc1)) + static_cast<ExactScalar>(measurement.varLoc1);
+    const auto v01 = static_cast<ExactScalar>(predicted.covAt(kLoc0, kLoc1)) + static_cast<ExactScalar>(measurement.covLoc01);
+    const ExactScalar det = (v00 * v11) - (v01 * v01);
+    const auto r0 = static_cast<ExactScalar>(measurement.loc0) - static_cast<ExactScalar>(predicted.loc0());
+    const auto r1 = static_cast<ExactScalar>(measurement.loc1) - static_cast<ExactScalar>(predicted.loc1());
+    return det > 0. && ((r0 * r0 * v11) - (2. * r0 * r1 * v01) + (r1 * r1 * v00)) / det > static_cast<ExactScalar>(mParameters->clusterChi2Max);
+  }
+
+  /// What a step's search reads (`follow::visit`).
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() follow::StepContext<Det, Material> context() const { return {.parameters = mParameters, .frame = mFrame, .geometry = mGeometry, .material = mMaterial, .propagator = &mPropagator, .used = mUsed}; }
+
+  /// The window of a step from \a state (its covariance \a factors) to
+  /// \a target: the track's time \a box, narrowed to the prediction
+  /// (`follow::predictedWindow`, with \a Scaled the step's scattering scaled
+  /// by \a scale), its \a reach beside. False where the prediction fails.
+  template <bool Scaled>
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool targetWindow(const BoundTrackState& state, const CovarianceFactors& factors, const TimeEstPS& box, const follow::Target& target, PropagationDirection direction, Scalar scale, CandidateWindow& window, Scalar (&reach)[2]) const
+  {
+    Scalar phiCentre = 0.F;
+    Scalar secondCentre = 0.F;
+    follow::windowCentre(*mParameters, target.layer, target.prediction, phiCentre, secondCentre);
+    window = {
+      .earliestPS = static_cast<std::int64_t>(box.lower()) - static_cast<std::int64_t>(mMaxCandidateWidthPS[target.layer]) + 1,
+      .latestPS = static_cast<std::int64_t>(box.upper()) - 1,
+      .afterPS = box.lower(),
+      .phiCentre = phiCentre,
+      .phiHalfWidth = std::numbers::pi_v<Scalar>,
+      .secondCentre = secondCentre,
+      .secondHalfWidth = follow::kOpenBound,
+    };
+    return follow::predictedWindow<Scaled>(mPropagator, *mParameters, *mGeometry, *mMaterial, state, factors, target.layer, direction, target.prediction, window, scale, reach);
+  }
+
+  /// The layers a step from \a state may reach in \a direction, into
+  /// \a targets, nearest crossing first; how many.
+  [[nodiscard]] GPUhdi() std::uint32_t targetsOf(const BoundTrackState& state, PropagationDirection direction, follow::Target* targets) const
+  {
+    const bool forward = direction == PropagationDirection::kForward;
+    const LayerID current = mGeometry->surface(state.surface).layer;
+    const auto& from = mGeometry->planeOf(state);
+    Scalar here[3]{};
+    surfaceToGlobal(from, state.loc0(), state.loc1(), here);
+    const auto* offsets = forward ? mParameters->allOutLinkOffsets : mParameters->allInLinkOffsets;
+    const auto* indices = forward ? mParameters->allOutLinkIndices : mParameters->allInLinkIndices;
+    std::uint32_t nTargets = 0U;
+    for (auto at = offsets[current]; at < offsets[current + 1U]; ++at) {
+      const auto link = indices[at];
+      const LayerID layer = forward ? mParameters->linkTargets[link] : mParameters->linkSources[link];
+      const auto prediction = predictLayerCrossing(mPropagator, *mParameters, from, state, layer, direction);
+      if (prediction.status != PropagationStatus::kOk) {
+        continue;
+      }
+      Scalar point[3]{};
+      follow::crossingPoint(*mParameters, layer, prediction, point);
+      const Scalar dx = point[0] - here[0];
+      const Scalar dy = point[1] - here[1];
+      const Scalar dz = point[2] - here[2];
+      const follow::Target target{.distance2 = (dx * dx) + (dy * dy) + (dz * dz), .layer = layer, .prediction = prediction};
+      // With one link there is nothing to sort; compiling the loop out also
+      // spares GCC's -Warray-bounds a subscript it cannot prove unreachable.
+      // The link tables are `outLinks<Det>`/`inLinks<Det>`'s (Iteration.h), so
+      // a layer's links never outnumber `maxDegree<Det>`, the targets' size;
+      // the analyzer, not seeing the tables' origin, takes them as any.
+      // NOLINTBEGIN(clang-analyzer-security.ArrayBound)
+      if constexpr (follow::maxDegree<Det> > 1U) {
+        std::uint32_t slot = nTargets++;
+        while (slot > 0U && (target.distance2 < targets[slot - 1U].distance2 || (!(targets[slot - 1U].distance2 < target.distance2) && target.layer < targets[slot - 1U].layer))) {
+          targets[slot] = targets[slot - 1U];
+          --slot;
+        }
+        targets[slot] = target;
+      } else {
+        targets[nTargets++] = target;
+      }
+      // NOLINTEND(clang-analyzer-security.ArrayBound)
+    }
+    return nTargets;
+  }
+
+  /// The nominal pass's walk over \a branch's \a nTargets \a targets: per
+  /// target its window (`predictedWindow`; a target the state cannot be
+  /// carried to is passed, the track taken not to cross it), and
+  /// \a search(target, window), whether it found a row there; a target
+  /// without one crossed in a sensor is a hole, counted on the branch, past
+  /// the iteration's holes the pass ends. Whether a search found a row.
+  template <typename Observer, typename Search>
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool overTargets(Branch& branch, const TimeEstPS& box, PropagationDirection direction, const follow::Target* targets, std::uint32_t nTargets, const Observer& observe, const Search& search) const
+  {
+    for (std::uint32_t t = 0; t < nTargets; ++t) {
+      const auto& target = targets[t]; // NOLINT(clang-analyzer-security.ArrayBound): nTargets <= maxDegree<Det> (`targetsOf`)
+      CandidateWindow window;
+      Scalar reach[2]{};
+      if (!targetWindow<false>(branch.state, branch.factors, box, target, direction, 1.F, window, reach)) {
+        continue;
+      }
+      observe.target(target.layer, window);
+      if (search(target, window)) {
+        return true;
+      }
+      const bool crossed = crossesSensor(branch.state, target, reach, direction);
+      observe.hole(target.layer, crossed);
+      branch.crossed = branch.crossed || crossed;
+      if (crossed && ++branch.holes > mParameters->followHoles) {
+        return false;
+      }
+    }
+    return false;
+  }
+
+  /// The nominal pass of a step of \a branch over its \a nTargets
+  /// \a targets (`overTargets`): the first target with a row in the gate
+  /// gives \a child -- the row, or, with more than one, the lookahead's best confirmed
+  /// (`confirm`). Whether it found a row; its updates count as the follow's.
+  /// \a nearMiss is set where a target held a row within its window that
+  /// the update refused above the gate (the unconfirmed drop reads it).
+  ///
+  /// The lanes of \a group search a window in step: after each step of the
+  /// walk the rows that passed, in lane order -- the grid's order -- are
+  /// counted for the whole window; the first stays on its lane until a second
+  /// comes, then both are confirmed, and every later one as it comes, each
+  /// confirmation by the whole group from the row's state on every lane.
+  template <typename Observer, typename Group>
+  [[nodiscard]] GPUhdi() bool nominal(Branch& branch, const TimeEstPS& box, PropagationDirection direction, const follow::Target* targets, std::uint32_t nTargets, Child& child, bool& nearMiss, const Observer& observe, const Group& group) const
+  {
+    return overTargets(branch, box, direction, targets, nTargets, observe, [&](const follow::Target& target, const CandidateWindow& window) {
+      std::uint32_t passing = 0U;
+      std::uint32_t firstLane = 0U; // \a child holds the first passing row on this lane
+      Confirmed confirmed;
+      bool gated = false; // this lane saw a row refused above the gate
+      follow::visit<false, DecidesEnd, EndDensity>(
+        context(), branch.state, branch.factors, 0.F, 0.F, target.layer, direction, window, 0U, 1.F, WorkCounter::kFollowUpdates, group,
+        [&](std::uint32_t row, StepOutcome outcome, Scalar chi2) {
+          gated = gated || outcome == StepOutcome::kChi2;
+          observe.candidate(target.layer, row, outcome, chi2);
+        },
+        [&](const Child& candidate) {
+          for (auto lanes = group.ballot(candidate.row != ClusterList<kMaxClusters>::kNoCluster); lanes != 0U; lanes &= lanes - 1U) {
+            const auto from = static_cast<std::uint32_t>(o2::gpu::CAMath::Ctz64(lanes));
+            if constexpr (Greedy) {
+              // Every lane holds the best so far, each passing row shared as
+              // it comes.
+              const auto one = follow::shared(group, candidate, from, branch.state);
+              if (++passing == 1U || follow::beats(one.row, one.chi2, {.row = child.row, .chi2 = child.chi2})) {
+                child = one;
+              }
+              continue;
+            }
+            if (++passing == 1U) {
+              firstLane = from;
+              if (group.lane() == from) {
+                child = candidate;
+              }
+              continue;
+            }
+            if (passing == 2U) {
+              confirm(branch, box, direction, follow::shared(group, child, firstLane, branch.state), confirmed, observe, group);
+            }
+            confirm(branch, box, direction, follow::shared(group, candidate, from, branch.state), confirmed, observe, group);
+          }
+        },
+        branch.own);
+      // Any lane's: a collective, every lane calls it.
+      nearMiss = nearMiss || group.ballot(gated) != 0U;
+      if (passing == 0U) {
+        return false;
+      }
+      if constexpr (Greedy) {
+        return true;
+      }
+      if (passing == 1U) {
+        if constexpr (Group::kLanes > 1U) {
+          child = follow::shared(group, child, firstLane, branch.state);
+        }
+      } else {
+        countWork(WorkCounter::kFollowLookaheads);
+        observe.lookahead(passing);
+        child = confirmed.child;
+      }
+      return true;
+    });
+  }
+
+  /// The nominal pass of a step of \a branch as a confirmation sees it
+  /// (`overTargets`): the first target with a row in the gate gives
+  /// \a witness, its smallest chi2, the row breaking ties. Whether it found
+  /// one; its updates count on \a counter. The lanes of \a group search a
+  /// window each its own rows, and agree on the best after it.
+  template <typename Group>
+  [[nodiscard]] GPUhdi() bool witnessOf(Branch& branch, const TimeEstPS& box, PropagationDirection direction, const follow::Target* targets, std::uint32_t nTargets, follow::Witness& witness, WorkCounter counter, const Group& group) const
+  {
+    return overTargets(branch, box, direction, targets, nTargets, follow::NoObserver{}, [&](const follow::Target& target, const CandidateWindow& window) {
+      follow::Witness own;
+      follow::visit<false, DecidesEnd>(
+        context(), branch.state, branch.factors, 0.F, 0.F, target.layer, direction, window, 0U, 1.F, counter, group, [](std::uint32_t /*row*/, StepOutcome /*outcome*/, Scalar /*chi2*/) {},
+        [&](const follow::Child& candidate) {
+          if (candidate.row != ClusterList<kMaxClusters>::kNoCluster && follow::beats(candidate.row, candidate.chi2, own)) {
+            own = {.row = candidate.row, .chi2 = candidate.chi2};
+          }
+        },
+        branch.own);
+      witness = follow::bestOf(group, own);
+      return witness.row != ClusterList<kMaxClusters>::kNoCluster;
+    });
+  }
+
+  /// The lookahead: of the rows of a window passing
+  /// the gate, where more than one does, the one the next step confirms, by
+  /// its chi2 plus the confirming row's; where none is confirmed, the
+  /// smallest chi2; the row breaks ties. `nominal` hands it each passing row
+  /// in the window's order from the second on, the first with it.
+  struct Confirmed {
+    Child child; // its row kNoCluster
+    bool confirmed = false;
+    Scalar key = 0.F;
+  };
+
+  /// \a taken, a row passing the gate from \a branch, against \a best; the
+  /// lanes of \a group together. \a observe sees the confirmation.
+  template <typename Observer, typename Group>
+  GPUhdi() void confirm(const Branch& branch, const TimeEstPS& box, PropagationDirection direction, const Child& taken, Confirmed& best, const Observer& observe, const Group& group) const
+  {
+    std::uint32_t next = ClusterList<kMaxClusters>::kNoCluster;
+    Scalar witness = 0.F;
+    const bool confirmed = confirmation<false>(branch, box, direction, taken, next, witness, WorkCounter::kFollowUpdates, group);
+    const Scalar key = confirmed ? taken.chi2 + witness : taken.chi2;
+    observe.lookaheadConfirmation(taken.row, taken.chi2, next, witness);
+    const bool better = best.child.row == ClusterList<kMaxClusters>::kNoCluster || (confirmed != best.confirmed ? confirmed : follow::beats(taken.row, key, {.row = best.child.row, .chi2 = best.key}));
+    if (better) {
+      best.child = taken;
+      best.confirmed = confirmed;
+      best.key = key;
+    }
+  }
+
+  /// The kink pass of a step of \a branch over its \a nTargets \a targets:
+  /// the nominal pass's walk with each target's scattering scaled by the
+  /// kink allowance, its holes counted on \a holes; the first target with a
+  /// confirmed row gives \a child, the smallest chi2 plus its confirmation's,
+  /// and \a onNext whether a row of the next step confirmed it (else the
+  /// beam line). Whether it found one; \a nearMiss is set where a row passed
+  /// the scaled gate, confirmed or not (the unconfirmed drop reads it). The lanes of \a group
+  /// search a window in step and confirm its passing rows together, in the
+  /// grid's order.
+  template <typename Observer, typename Group>
+  [[nodiscard]] GPUhdi() bool kinkStep(const Branch& branch, const TimeEstPS& box, PropagationDirection direction, const follow::Target* targets, std::uint32_t nTargets, Child& child, std::uint32_t& holes, bool& onNext, bool& nearMiss, const Observer& observe, const Group& group) const
+  {
+    const Scalar scale = o2::gpu::CAMath::Sqrt(mParameters->kinkScale2);
+    for (std::uint32_t t = 0; t < nTargets; ++t) {
+      const auto& target = targets[t];
+      CandidateWindow window;
+      Scalar reach[2]{};
+      if (!targetWindow<true>(branch.state, branch.factors, box, target, direction, scale, window, reach)) {
+        continue;
+      }
+      Scalar bestScore = 0.F;
+      child.row = ClusterList<kMaxClusters>::kNoCluster;
+      follow::visit<true, DecidesEnd, EndDensity>(
+        context(), branch.state, branch.factors, 0.F, 0.F, target.layer, direction, window, 0U, scale, WorkCounter::kFollowKinkUpdates, group, [&](std::uint32_t row, StepOutcome outcome, Scalar chi2) { observe.scaled(target.layer, row, outcome, chi2); },
+        [&](const Child& candidate) {
+          for (auto lanes = group.ballot(candidate.row != ClusterList<kMaxClusters>::kNoCluster); lanes != 0U; lanes &= lanes - 1U) {
+            nearMiss = true;
+            const Child taken = follow::shared(group, candidate, static_cast<std::uint32_t>(o2::gpu::CAMath::Ctz64(lanes)), branch.state);
+            std::uint32_t next = ClusterList<kMaxClusters>::kNoCluster;
+            Scalar witness = 0.F;
+            const bool confirmed = confirmation<true>(branch, box, direction, taken, next, witness, WorkCounter::kFollowWitnessUpdates, group);
+            observe.confirmation(taken.row, confirmed, next, witness);
+            if (!confirmed) {
+              continue;
+            }
+            const Scalar score = taken.chi2 + witness;
+            if (follow::beats(taken.row, score, {.row = child.row, .chi2 = bestScore})) {
+              child = taken;
+              bestScore = score;
+              onNext = next != ClusterList<kMaxClusters>::kNoCluster;
+            }
+          }
+        },
+        branch.own);
+      if (child.row != ClusterList<kMaxClusters>::kNoCluster) {
+        return true;
+      }
+      if (crossesSensor(branch.state, target, reach, direction) && ++holes > mParameters->followHoles) {
+        return false;
+      }
+    }
+    return false;
+  }
+
+  /// What confirms \a taken, a row passing the gate from \a branch: the
+  /// next step's row by the nominal pass from past it, into \a next and
+  /// \a chi2, its updates counted on \a counter; with \a BeamLineConfirms (a
+  /// kink step's row), where no link leads on inward and the iteration has
+  /// the beam constraint, the beam line's update under its gate (\a next
+  /// none). Whether anything does: a second kink step does not confirm the
+  /// first. The lanes of \a group together.
+  template <bool BeamLineConfirms, typename Group>
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool confirmation(const Branch& branch, const TimeEstPS& box, PropagationDirection direction, const Child& taken, std::uint32_t& next, Scalar& chi2, WorkCounter counter, const Group& group) const
+  {
+    Branch probe = branch;
+    auto probeBox = box;
+    take(probe, probeBox, taken);
+    follow::Target targets[follow::maxDegree<Det>];
+    const std::uint32_t nTargets = targetsOf(probe.state, direction, targets);
+    if (nTargets == 0U) {
+      if constexpr (BeamLine && BeamLineConfirms) {
+        if (direction == PropagationDirection::kBackward) {
+          BoundTrackState constrained = probe.state;
+          covarianceFromFactors(probe.factors, constrained.cov);
+          const LayerID layer = mGeometry->surface(constrained.surface).layer;
+          const auto beam = updateWithBeamLine(mPropagator, *mParameters, mGeometry->planeOf(constrained), layer, pairPointAt(mFrame->measurements(), probe.rows[probe.count - 1U]), constrained);
+          chi2 = beam.chi2;
+          return beam.ok && beam.chi2 <= mParameters->beamChi2Max;
+        }
+      }
+      return false;
+    }
+    follow::Witness witness;
+    if (!witnessOf(probe, probeBox, direction, targets, nTargets, witness, counter, group)) {
+      return false;
+    }
+    next = witness.row;
+    chi2 = witness.chi2;
+    return true;
+  }
+
+  /// \a branch past \a child's row; \a box narrowed by it.
+  GPUhdi() GPUAlwaysInline() void take(Branch& branch, TimeEstPS& box, const Child& child) const
+  {
+    branch.rows[branch.count++] = child.row;
+    branch.state = child.state;
+    branch.factors = child.factors;
+    branch.lastChi2 = child.chi2;
+    if constexpr (EndDensity) {
+      branch.lastDeterminant = child.determinant;
+      branch.lastKink = false;
+    }
+    branch.crossed = false;
+    box += timeBoxAt(mFrame->measurements(), child.row);
+  }
+
+  /// Whether \a state crosses a sensor of \a target's layer within its
+  /// bounds in \a direction: carried to each sensor listed near its nominal
+  /// crossing, as far from it as the layer's envelope \a reach lets the
+  /// crossing move; a curved sensor is tested on its tangent plane at the
+  /// crossing's angle.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool crossesSensor(const BoundTrackState& state, const follow::Target& target, const Scalar* reach, PropagationDirection direction) const
+  {
+    countWork(WorkCounter::kFollowHoleTests);
+    const auto& from = mGeometry->planeOf(state);
+    Scalar point[3]{};
+    follow::crossingPoint(*mParameters, target.layer, target.prediction, point);
+    const auto& propagator = pointPropagator(mPropagator, from, state);
+    const ExactScalar curvature = propagator.curvature(static_cast<ExactScalar>(state.qOverP()), 1.);
+    const bool crossed = mCells.anySensor(target.layer, target.prediction.phi, reach[0], target.prediction.second, reach[1], [&](std::uint32_t id) {
+      const TrackingSurface& surface = mGeometry->surface(static_cast<SensorID>(id));
+      TrackingSurface plane = surface;
+      if (surface.radius > 0.F) {
+        Scalar along0 = 0.F;
+        Scalar along1 = 0.F;
+        for (int i = 0; i < 3; ++i) {
+          along0 += (point[i] - surface.origin[i]) * surface.axis0[i];
+          along1 += (point[i] - surface.origin[i]) * surface.axis1[i];
+        }
+        plane = tangentPlane(surface, o2::gpu::CAMath::ATan2(along1, along0));
+      }
+      BoundTrackState at = state;
+      const auto result = propagate(propagator, at, from, plane, direction);
+      return result.status == PropagationStatus::kOk && !follow::beyondHalfTurn(curvature * static_cast<ExactScalar>(result.pathLength));
+    });
+    countWork(WorkCounter::kFollowHoles, crossed ? 1U : 0U);
+    return crossed;
+  }
+
+  const IterationParameters<Det>* mParameters = nullptr;
+  const TimeFrame<Det>* mFrame = nullptr;
+  const TrackingGeometry<Det>* mGeometry = nullptr;
+  const Material* mMaterial = nullptr;
+  Propagator mPropagator;
+  TrackView mTracks;
+  const std::uint8_t* mUsed = nullptr;
+  const std::uint32_t* mMaxCandidateWidthPS = nullptr;
+  SensorCellsView mCells;
+  Proposal* mProposals = nullptr;
+  follow::KinkSteps* mKinkSteps = nullptr;
+  bool mInward = true;
+  std::uint32_t mTrackOffset = 0U;
+  const BoundTrackState* mEndStarts = nullptr;
+};
+
+/// Whether the iteration drops tracks after the follow: it has a length
+/// after the follow, or it follows and has a pT floor.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool dropsAfterFollow(const IterationParameters<Det>& parameters)
+{
+  bool floors = false;
+  for (const auto floor : parameters.minPtByClusters) {
+    floors = floors || floor > 0.F;
+  }
+  return parameters.minClustersAfterFollow != 0U || (parameters.follow && floors);
+}
+
+/// Whether a track of \a count clusters, \a state its refit as the follow
+/// left it, stays after the follow: at least the iteration's length after
+/// it, and, where the iteration follows, at or above its pT floor for that
+/// count.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool keptAfterFollow(const IterationParameters<Det>& parameters, std::uint32_t count, const BoundTrackState& state)
+{
+  return count >= parameters.minClustersAfterFollow && (!parameters.follow || clearsPtFloor(parameters, count, state));
+}
+
+namespace follow
+{
+
+/// The road fit's outward pass of each track's rows less its outermost,
+/// a pass of its own before the follow
+/// decides the end again (`FollowStage`'s DecidesEnd): \a starts gets the
+/// state, or one on no surface where the track has fewer than four rows --
+/// three left, a degree of freedom -- or is as long as a chain can be, or the
+/// fit refuses them. Not with a kink allowance: the road fit takes its last
+/// step with it (`fitOutward`'s LastStepAllowance), this one does not.
+template <DetectorLayout Det, typename Material>
+struct EndFit {
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  using TrackView = typename BoundedColumns<TrackOf<kMaxClusters>::template RecordT>::ConstView;
+
+  const IterationParameters<Det>* parameters = nullptr;
+  const TimeFrame<Det>* frame = nullptr;
+  const TrackingGeometry<Det>* geometry = nullptr;
+  const Material* material = nullptr;
+  Propagator propagator;
+  TrackView tracks;
+  BoundTrackState* starts = nullptr;
+  std::uint32_t trackOffset = 0U;
+
+  GPUhdi() void operator()(std::uint32_t element) const
+  {
+    const std::uint32_t track = trackOffset + element;
+    starts[element].surface = kInvalidSensorID;
+    const std::uint32_t count = tracks.count[track];
+    if (tracks.status[track] != PropagationStatus::kOk || count < 4U || count >= kMaxClusters) {
+      return;
+    }
+    countWork(WorkCounter::kFollowEndFits);
+    const auto fit = fitOutward(propagator, *geometry, *material, RowChain<Det>{.frame = frame, .rows = tracks.clusters[track].index}, static_cast<int>(count - 1U), parameters->roadChi2MaxByNdf, kinkBudget(*parameters));
+    if (fit.status == RoadFitStatus::kAccepted) {
+      starts[element] = fit.state;
+    }
+  }
+};
+
+/// Each direction cut back so that every kink step kept keeps the row that
+/// witnessed it (`keptWithWitnesses`): after the bidding, before the refit.
+template <std::size_t K>
+struct KeepWitnesses {
+  FollowProposal<K>* proposals = nullptr;
+  const KinkSteps* steps = nullptr;
+
+  GPUhdi() void operator()(std::uint32_t track) const
+  {
+    auto& proposal = proposals[track];
+    const std::uint32_t before = static_cast<std::uint32_t>(proposal.outwardCount) + proposal.inwardCount;
+    proposal.outwardCount = keptWithWitnesses(proposal.outwardCount, steps[track].outwardWitnessed);
+    proposal.inwardCount = keptWithWitnesses(proposal.inwardCount, steps[track].inwardWitnessed);
+    countWork(WorkCounter::kFollowWitnessTrimmed, before - proposal.outwardCount - proposal.inwardCount);
+  }
+};
+
+template <std::size_t K>
+struct Bid {
+  const FollowProposal<K>* proposals = nullptr;
+  std::uint32_t* slots = nullptr;
+  std::uint32_t trackOffset = 0U;
+  std::uint32_t trackCount = 0U;
+
+  GPUhdi() void operator()(std::uint32_t track) const
+  {
+    const std::uint32_t priority = trackCount - (trackOffset + track);
+    const auto& proposal = proposals[track];
+    for (std::uint32_t i = 0; i < proposal.outwardCount; ++i) {
+      o2::gpu::CAMath::AtomicMax(slots + proposal.outward[i], priority);
+    }
+    for (std::uint32_t i = 0; i < proposal.inwardCount; ++i) {
+      o2::gpu::CAMath::AtomicMax(slots + proposal.inward[i], priority);
+    }
+  }
+};
+
+/// Keep each direction only through the first row on which another track has
+/// the higher output-order priority. A later row won by this track is still
+/// dropped: one bidding round does not retry a truncated continuation.
+/// \a earlier counts the earlier iterations' follow apart.
+template <std::size_t K>
+struct Resolve {
+  FollowProposal<K>* proposals = nullptr;
+  const std::uint32_t* slots = nullptr;
+  std::uint32_t trackOffset = 0U;
+  std::uint32_t trackCount = 0U;
+  bool earlier = false;
+
+  GPUhdi() void operator()(std::uint32_t track) const
+  {
+    const std::uint32_t priority = trackCount - (trackOffset + track);
+    auto& proposal = proposals[track];
+    const std::uint32_t proposed = static_cast<std::uint32_t>(proposal.outwardCount) + proposal.inwardCount;
+    proposal.outwardCount = kept(proposal.outward, proposal.outwardCount, priority);
+    proposal.inwardCount = kept(proposal.inward, proposal.inwardCount, priority);
+    countWork(earlier ? WorkCounter::kFollowEarlierProposed : WorkCounter::kFollowProposed, proposed);
+    countWork(earlier ? WorkCounter::kFollowEarlierOutbid : WorkCounter::kFollowOutbid, proposed - proposal.outwardCount - proposal.inwardCount);
+  }
+
+ private:
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint8_t kept(const std::uint32_t* rows, std::uint8_t count, std::uint32_t priority) const
+  {
+    for (std::uint8_t i = 0U; i < count; ++i) {
+      if (slots[rows[i]] != priority) {
+        return i;
+      }
+    }
+    return count;
+  }
+};
+
+template <std::size_t K>
+struct Combine {
+  const ClusterList<K>* original = nullptr;
+  const std::uint8_t* originalCount = nullptr;
+  const FollowProposal<K>* proposals = nullptr;
+  ClusterList<K>* rows = nullptr;
+  std::uint8_t* counts = nullptr;
+  std::uint32_t trackOffset = 0U;
+
+  GPUhdi() void operator()(std::uint32_t element) const
+  {
+    const std::uint32_t track = trackOffset + element;
+    const auto& proposal = proposals[element];
+    ClusterList<K> combined;
+    for (std::size_t i = 0; i < K; ++i) {
+      combined.index[i] = ClusterList<K>::kNoCluster;
+    }
+    for (std::uint32_t i = 0; i < proposal.inwardCount; ++i) {
+      combined.index[i] = proposal.inward[proposal.inwardCount - i - 1U];
+    }
+    // A replaced end goes with the outward rows that replace it.
+    const bool replaced = proposal.replacedEnd != ClusterList<K>::kNoCluster && proposal.outwardCount != 0U;
+    const std::uint32_t kept = originalCount[track] - (replaced ? 1U : 0U);
+    for (std::uint32_t i = 0; i < kept; ++i) {
+      combined.index[static_cast<std::uint32_t>(proposal.inwardCount) + i] = original[track].index[i];
+    }
+    for (std::uint32_t i = 0; i < proposal.outwardCount; ++i) {
+      combined.index[static_cast<std::uint32_t>(proposal.inwardCount) + kept + i] = proposal.outward[i];
+    }
+    rows[element] = combined;
+    counts[element] = static_cast<std::uint8_t>(kept + proposal.inwardCount + proposal.outwardCount);
+  }
+};
+
+/// Whether \a fit, a track refitted after its follow, passes the road's
+/// chi2 cut (`Refit`, `TrimAmbiguous`).
+template <DetectorLayout Det, typename Fit>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool passesRoadChi2(const IterationParameters<Det>& parameters, const Fit& fit)
+{
+  return fit.status == PropagationStatus::kOk && fit.chi2 <= parameters.roadChi2MaxByNdf[fit.ndf];
+}
+
+/// The extended refit of each followed track, all or nothing. \a Rule is
+/// the fit's choice of crossing (`CrossingRule`), the iteration's
+/// `crossingRule`. With \a Prefix, the iteration's `followPrefix`, a refit the cut
+/// refuses or that fails is tried again on the follow's rows' prefixes in
+/// the walks' order -- the outward rows first, then the inward ones --
+/// the longest first, and the first the refit accepts is kept; a prefix
+/// that would keep a kink step without its witness (`keptWithWitnesses`)
+/// is not tried.
+template <DetectorLayout Det, typename Material, CrossingRule Rule = CrossingRule::kFirstAhead, bool Prefix = false>
+struct Refit {
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  using TrackView = typename BoundedColumns<TrackOf<kMaxClusters>::template RecordT>::View;
+
+  const IterationParameters<Det>* parameters = nullptr;
+  const TimeFrame<Det>* frame = nullptr;
+  const TrackingGeometry<Det>* geometry = nullptr;
+  const Material* material = nullptr;
+  Propagator propagator;
+  TrackView tracks;
+  FollowProposal<kMaxClusters>* proposals = nullptr;
+  const ClusterList<kMaxClusters>* rows = nullptr;
+  const std::uint8_t* counts = nullptr;
+  std::uint32_t trackOffset = 0U;
+  bool earlier = false;
+  /// Each proposal's kink steps, where the iteration takes them; a prefix
+  /// keeps them with their witnesses.
+  const KinkSteps* steps = nullptr;
+
+  GPUhdi() void operator()(std::uint32_t element) const
+  {
+    const std::uint32_t track = trackOffset + element;
+    auto& proposal = proposals[element];
+    const std::uint32_t added = static_cast<std::uint32_t>(proposal.outwardCount) + proposal.inwardCount;
+    if (added == 0U) {
+      return;
+    }
+    const std::uint8_t count = counts[element];
+    if (!accept(track, rows[element], count, proposal.outwardCount, proposal.inwardCount)) {
+      if constexpr (Prefix) {
+        if (keepPrefix(element, track, proposal, count)) {
+          return;
+        }
+      }
+      countWork(earlier ? WorkCounter::kFollowEarlierRefitRejected : WorkCounter::kFollowRefitRejected, added);
+      proposal.outwardCount = 0U;
+      proposal.inwardCount = 0U;
+    }
+  }
+
+ private:
+  /// The track with \a list's rows (\a n of them, \a outward and \a inward
+  /// of them the follow's) refitted: whether the fit passes the road's chi2
+  /// cut; then it is written as the track, its added counts grown -- added
+  /// to what an earlier follow added: an earlier iteration's track is
+  /// followed again with `followEarlier`.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool accept(std::uint32_t track, const ClusterList<kMaxClusters>& list, std::uint8_t n, std::uint8_t outward, std::uint8_t inward) const
+  {
+    const auto fit = fitMeasurements<Rule>(propagator, *geometry, *material, RowChain<Det>{.frame = frame, .rows = list.index}, static_cast<int>(n), kinkBudget(*parameters));
+    if (!passesRoadChi2(*parameters, fit)) {
+      return false;
+    }
+    writeFit(tracks, track, fit, list, n, trackTimeBox(frame->measurements(), list, n));
+    tracks.addedOutward[track] = static_cast<std::uint8_t>(tracks.addedOutward[track] + outward);
+    tracks.addedInward[track] = static_cast<std::uint8_t>(tracks.addedInward[track] + inward);
+    return true;
+  }
+
+  /// `Prefix`'s second chance: the combined rows are the inward ones
+  /// innermost first, the track's, the outward ones; a prefix of \a outward
+  /// outward and \a inward inward rows is the track's rows with the first
+  /// of each. Whether one was kept, its counts then the proposal's.
+  GPUhdi() GPUAlwaysInline() bool keepPrefix(std::uint32_t element, std::uint32_t track, FollowProposal<kMaxClusters>& proposal, std::uint8_t count) const
+  {
+    const auto outwardAdded = static_cast<std::uint32_t>(proposal.outwardCount);
+    const auto inwardAdded = static_cast<std::uint32_t>(proposal.inwardCount);
+    const std::uint32_t kept = count - outwardAdded - inwardAdded;
+    const auto& combined = rows[element];
+    for (std::uint32_t length = outwardAdded + inwardAdded; length-- > 1U;) {
+      const auto outward = length < outwardAdded ? length : outwardAdded;
+      const auto inward = length - outward;
+      if (steps != nullptr && (keptWithWitnesses(static_cast<std::uint8_t>(outward), steps[element].outwardWitnessed) != outward || keptWithWitnesses(static_cast<std::uint8_t>(inward), steps[element].inwardWitnessed) != inward)) {
+        continue;
+      }
+      ClusterList<kMaxClusters> prefix{};
+      std::uint32_t n = 0U;
+      for (std::uint32_t i = inward; i-- > 0U;) {
+        prefix.index[n++] = proposal.inward[i];
+      }
+      for (std::uint32_t i = 0; i < kept; ++i) {
+        prefix.index[n++] = combined.index[inwardAdded + i];
+      }
+      for (std::uint32_t i = 0; i < outward; ++i) {
+        prefix.index[n++] = proposal.outward[i];
+      }
+      if (!accept(track, prefix, static_cast<std::uint8_t>(n), static_cast<std::uint8_t>(outward), static_cast<std::uint8_t>(inward))) {
+        continue;
+      }
+      countWork(earlier ? WorkCounter::kFollowEarlierRefitRejected : WorkCounter::kFollowRefitRejected, outwardAdded + inwardAdded - length);
+      proposal.outwardCount = static_cast<std::uint8_t>(outward);
+      proposal.inwardCount = static_cast<std::uint8_t>(inward);
+      return true;
+    }
+    return false;
+  }
+};
+
+/// The trim of an ambiguous last row, after the refit, where the iteration has a `followTrimMargin`: a
+/// track whose last row is one its follow added outward, neither a kink
+/// step's row nor a kink row's witness, is refitted without it. Where that
+/// fit passes the road's chi2 cut, the track one row shorter keeps the cuts
+/// after the follow (`keptAfterFollow`), and from the fit's outward state two
+/// rows or more of that row's layer pass the nominal gate (`passingOn`: free
+/// rows, the row itself among them -- nothing is marked before `Mark`) with
+/// the row itself not among them, or the smallest other chi2 less the row's
+/// below the margin (a margin above the gate takes every such
+/// row), the row is dropped and the track written with that fit; else the
+/// track stays as the refit left it. The row dropped is not marked: it is free for the
+/// iterations after. Not with `followEnd`, whose replaced end goes with the
+/// outward rows.
+template <DetectorLayout Det, typename Material, CrossingRule Rule = CrossingRule::kFirstAhead>
+struct TrimAmbiguous {
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  using TrackView = typename BoundedColumns<TrackOf<kMaxClusters>::template RecordT>::View;
+
+  /// The search of the step's rows, as a nominal step makes it.
+  FollowStage<Det, Material> search;
+  const IterationParameters<Det>* parameters = nullptr;
+  const TimeFrame<Det>* frame = nullptr;
+  const TrackingGeometry<Det>* geometry = nullptr;
+  const Material* material = nullptr;
+  Propagator propagator;
+  TrackView tracks;
+  FollowProposal<kMaxClusters>* proposals = nullptr;
+  /// Each proposal's kink steps, where the iteration takes them.
+  const KinkSteps* steps = nullptr;
+  std::uint32_t trackOffset = 0U;
+
+  GPUhdi() void operator()(std::uint32_t element) const
+  {
+    const std::uint32_t track = trackOffset + element;
+    auto& proposal = proposals[element];
+    const std::uint32_t outward = proposal.outwardCount;
+    const std::uint32_t count = tracks.count[track];
+    if (outward == 0U || tracks.status[track] != PropagationStatus::kOk) {
+      return;
+    }
+    // A kink row stands on the row after it (bit i for row i): the last row
+    // is that row's witness where the row before it is one.
+    if (steps != nullptr) {
+      const std::uint64_t witnessed = steps[element].outwardWitnessed;
+      const std::uint32_t last = outward - 1U;
+      if (((witnessed >> last) & 1U) != 0U || (last != 0U && ((witnessed >> (last - 1U)) & 1U) != 0U)) {
+        return;
+      }
+    }
+    // The outward rows are the track's last (`Combine`).
+    ClusterList<kMaxClusters> rows = tracks.clusters[track];
+    const std::uint32_t row = rows.index[count - 1U];
+    rows.index[count - 1U] = ClusterList<kMaxClusters>::kNoCluster;
+    const auto shorter = static_cast<std::uint8_t>(count - 1U);
+    countWork(WorkCounter::kFollowTrimFits);
+    const auto fit = fitMeasurements<Rule>(propagator, *geometry, *material, RowChain<Det>{.frame = frame, .rows = rows.index}, static_cast<int>(shorter), kinkBudget(*parameters));
+    if (!passesRoadChi2(*parameters, fit) || !keptAfterFollow(*parameters, shorter, fit.state)) {
+      return;
+    }
+    const auto box = trackTimeBox(frame->measurements(), rows, shorter);
+    const LayerID layer = geometry->surface(frame->measurements().surface[row]).layer;
+    const auto passing = search.passingOn(fit.outwardState, factorCovariance(fit.outwardState.cov), layer, row, box, PropagationDirection::kForward);
+    if (passing.count < 2U || (passing.own && !(passing.otherChi2 - passing.ownChi2 < parameters->followTrimMargin))) {
+      return;
+    }
+    writeFit(tracks, track, fit, rows, shorter, box);
+    tracks.addedOutward[track] = static_cast<std::uint8_t>(tracks.addedOutward[track] - 1U);
+    proposal.outwardCount = static_cast<std::uint8_t>(outward - 1U);
+    countWork(WorkCounter::kFollowTrimmed);
+  }
+};
+
+template <std::size_t K>
+struct Mark {
+  const FollowProposal<K>* proposals = nullptr;
+  std::uint8_t* used = nullptr;
+
+  GPUhdi() void operator()(std::uint32_t track) const
+  {
+    const auto& proposal = proposals[track];
+    // A replaced end, its replacement kept through the refit, is free again:
+    // no other track proposed it, so no other one marks it.
+    if (proposal.replacedEnd != ClusterList<K>::kNoCluster && proposal.outwardCount != 0U) {
+      used[proposal.replacedEnd] = kFree;
+    }
+    for (std::uint32_t i = 0; i < proposal.outwardCount; ++i) {
+      used[proposal.outward[i]] = kExclusive;
+    }
+    for (std::uint32_t i = 0; i < proposal.inwardCount; ++i) {
+      used[proposal.inward[i]] = kExclusive;
+    }
+  }
+};
+
+} // namespace follow
+
+template <DetectorLayout Det>
+class Follow;
+
+namespace follow
+{
+
+/// What the follow's passes read and write (`runSequence`): the iteration's
+/// parameters as the passes read them and as the host decides on them (one
+/// object on the host, the device's copy and the host's on a device), the
+/// track model, the tracks from \a trackOffset to \a trackCount, the used
+/// mask (\a rowCount rows) and the passes' storage, one element per track
+/// followed -- the kink steps only where the iteration takes them, the end
+/// starts only where it decides the end again.
+template <DetectorLayout Det, typename Material>
+struct Inputs {
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  using TrackView = typename BoundedColumns<TrackOf<kMaxClusters>::template RecordT>::View;
+  using ConstTrackView = typename BoundedColumns<TrackOf<kMaxClusters>::template RecordT>::ConstView;
+
+  const IterationParameters<Det>* parameters = nullptr;
+  const IterationParameters<Det>* choices = nullptr;
+  const TimeFrame<Det>* frame = nullptr;
+  const TrackingGeometry<Det>* geometry = nullptr;
+  const Material* material = nullptr;
+  Propagator propagator;
+  TrackView tracks;
+  ConstTrackView constTracks;
+  std::uint32_t trackOffset = 0U;
+  std::uint32_t trackCount = 0U;
+  bool inward = false;
+  bool earlier = false;
+  std::uint8_t* used = nullptr;
+  std::size_t rowCount = 0U;
+  const std::uint32_t* maxCandidateWidthPS = nullptr;
+  SensorCellsView cells;
+  FollowProposal<kMaxClusters>* proposals = nullptr;
+  std::uint32_t* bids = nullptr;
+  ClusterList<kMaxClusters>* rows = nullptr;
+  std::uint8_t* counts = nullptr;
+  KinkSteps* steps = nullptr;
+  BoundTrackState* endStarts = nullptr;
+};
+
+/// The host's launches of the follow's passes: each in its profile zone,
+/// none of its own for the earlier iterations' tracks (`Follow::run`).
+template <typename ForEach>
+struct HostLaunch {
+  ForEach* forEach;
+  bool earlier = false;
+
+  [[nodiscard]] profile::Phase phase(profile::Phase own) const { return earlier ? profile::Phase::kNone : own; }
+
+  template <typename Body>
+  void pass(profile::Phase own, std::uint32_t count, const Body& body) const
+  {
+    const profile::Zone zone{phase(own)};
+    (*forEach)(count, body);
+  }
+
+  template <typename Stage>
+  void propose(profile::Phase own, std::uint32_t count, const Stage& stage) const
+  {
+    pass(own, count, stage);
+  }
+
+  /// The bids zeroed in parallel, as the selection's slots are.
+  void clearBids(std::uint32_t* bids, std::size_t rows) const
+  {
+    const profile::Zone zone{phase(profile::Phase::kFollowPropose)};
+    (*forEach)(static_cast<std::uint32_t>(rows), [bids](std::uint32_t row) { bids[row] = 0U; });
+  }
+};
+
+/// The follow over \a in's tracks, the host's and a device's alike: the bids
+/// cleared, the end fit where the iteration decides the end again (on its
+/// own tracks only), the proposals, then bid, resolve, the kink steps'
+/// witnesses, combine, the refit, the trim of the ambiguous last rows
+/// (`followTrimMargin`, not with the end decided again, on the iteration's
+/// own tracks) and the mark. Each choice of the iteration is its own
+/// instantiation. \a launch runs a pass (`pass(phase, count, body)`), the
+/// proposals (`propose(phase, count, stage)`: a device's lanes) and
+/// `clearBids(bids, rows)`.
+template <DetectorLayout Det, typename Material, typename Launch>
+void runSequence(const Launch& launch, const Inputs<Det, Material>& in)
+{
+  using profile::Phase;
+  constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  const IterationParameters<Det>& choices = *in.choices;
+  const std::uint32_t elements = in.trackCount - in.trackOffset;
+  launch.clearBids(in.bids, in.rowCount);
+  // The beam line starts the inward follow where the iteration has the
+  // constraint, and the end is decided
+  // again where it has followEnd, on its own tracks
+  // only.
+  const bool end = choices.followEnd && !in.earlier;
+  if (end) {
+    launch.pass(Phase::kFollowPropose, elements,
+                EndFit<Det, Material>{
+                  .parameters = in.parameters,
+                  .frame = in.frame,
+                  .geometry = in.geometry,
+                  .material = in.material,
+                  .propagator = in.propagator,
+                  .tracks = in.constTracks,
+                  .starts = in.endStarts,
+                  .trackOffset = in.trackOffset,
+                });
+  }
+  // The iteration's choice among the passing rows, its end decisions on the
+  // last row's density and against the beam line (with the beam line only).
+  withBools(
+    [&]<bool BeamLine, bool DecidesEnd, bool Greedy, bool EndDensity, bool BeamEnd>(std::bool_constant<BeamLine>, std::bool_constant<DecidesEnd>, std::bool_constant<Greedy>, std::bool_constant<EndDensity>, std::bool_constant<BeamEnd>) {
+      if constexpr (BeamLine || !BeamEnd) {
+        const FollowStage<Det, Material, BeamLine, DecidesEnd, Greedy, EndDensity, BeamEnd> stage{in.parameters, in.frame, in.geometry, in.material, in.propagator, in.constTracks, in.used, in.maxCandidateWidthPS, in.cells, in.proposals, in.steps, in.inward, in.trackOffset, DecidesEnd ? in.endStarts : nullptr};
+        launch.propose(Phase::kFollowPropose, elements, stage);
+      }
+    },
+    choices.beamConstraint, end, choices.followGreedy, Follow<Det>::endDensity(choices), choices.followBeamEnd);
+  launch.pass(Phase::kFollowResolve, elements, Bid<kMaxClusters>{in.proposals, in.bids, in.trackOffset, in.trackCount});
+  launch.pass(Phase::kFollowResolve, elements, Resolve<kMaxClusters>{in.proposals, in.bids, in.trackOffset, in.trackCount, in.earlier});
+  if (in.steps != nullptr) {
+    launch.pass(Phase::kFollowResolve, elements, KeepWitnesses<kMaxClusters>{.proposals = in.proposals, .steps = in.steps});
+  }
+  launch.pass(Phase::kFollowResolve, elements, Combine<kMaxClusters>{in.constTracks.clusters, in.constTracks.count, in.proposals, in.rows, in.counts, in.trackOffset});
+  // The iteration's choice of crossing and of
+  // the prefix.
+  withCrossingRule(choices.crossingRule, [&]<CrossingRule Rule>(std::integral_constant<CrossingRule, Rule>) { withBools([&]<bool Prefix>(std::bool_constant<Prefix>) { launch.pass(Phase::kFollowRefit, elements, Refit<Det, Material, Rule, Prefix>{in.parameters, in.frame, in.geometry, in.material, in.propagator, in.tracks, in.proposals, in.rows, in.counts, in.trackOffset, in.earlier, in.steps}); }, choices.followPrefix); });
+  // The ambiguous last rows trimmed, on the iteration's own
+  // tracks, before the marks.
+  if (choices.followTrimMargin > 0.F && !end && !in.earlier) {
+    const FollowStage<Det, Material> search{in.parameters, in.frame, in.geometry, in.material, in.propagator, in.constTracks, in.used, in.maxCandidateWidthPS, in.cells, nullptr, nullptr, false, in.trackOffset};
+    withCrossingRule(choices.crossingRule, [&]<CrossingRule Rule>(std::integral_constant<CrossingRule, Rule>) {
+      launch.pass(Phase::kFollowRefit, elements,
+                  TrimAmbiguous<Det, Material, Rule>{
+                    .search = search,
+                    .parameters = in.parameters,
+                    .frame = in.frame,
+                    .geometry = in.geometry,
+                    .material = in.material,
+                    .propagator = in.propagator,
+                    .tracks = in.tracks,
+                    .proposals = in.proposals,
+                    .steps = in.steps,
+                    .trackOffset = in.trackOffset,
+                  });
+    });
+  }
+  launch.pass(Phase::kFollowMark, elements, Mark<kMaxClusters>{in.proposals, in.used});
+}
+
+} // namespace follow
+
+/// Host orchestration and bounded storage of the follow: propose, then bid,
+/// resolve, keep the kink steps' witnesses, combine, refit, trim the
+/// ambiguous last rows (`followTrimMargin`) and mark. The
+/// tracker runs it on an iteration's own tracks and, with `followEarlier`,
+/// on the earlier iterations' tracks first; a device runs the same sequence
+/// (`follow::runSequence`) with its own launches.
+template <DetectorLayout Det>
+class Follow
+{
+ public:
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  static constexpr std::size_t kLayerCount = static_cast<std::size_t>(Detector<Det>::nLayers);
+  using Proposal = FollowProposal<kMaxClusters>;
+  using Tracks = typename TrackRefit<Det>::Tracks;
+
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
+  {
+    mMemoryPool = std::move(pool);
+    clearStorage();
+  }
+
+  /// The arrays back to the pool.
+  void clearStorage() noexcept { deepVectorClear(mMemoryPool.get(), mProposals, mBids, mRows, mCounts, mKinkSteps, mEndStarts); }
+
+  /// Follow the tracks from \a trackOffset on, inward too with \a inward,
+  /// each layer's candidates bound by \a maxCandidateWidthPS, the frame's
+  /// widest time box there, the sensors
+  /// near a crossing from \a cells. \a earlier: the earlier iterations'
+  /// tracks (`followEarlier`), counted and timed apart -- within the
+  /// caller's `kFollowEarlier` zone, no phase of its own.
+  template <typename Material, typename ForEach>
+  [[nodiscard]] StageStatus run(ForEach forEach, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator, Tracks& tracks, std::uint32_t trackOffset, bool inward, bool earlier, std::span<std::uint8_t> used, std::span<const std::uint32_t, kLayerCount> maxCandidateWidthPS, SensorCellsView cells)
+  {
+    using profile::Phase;
+    return guardOutOfMemory([&] {
+      const auto trackCount = static_cast<std::uint32_t>(tracks.size());
+      const auto elements = trackCount - trackOffset;
+      const bool end = parameters.followEnd && !earlier;
+      {
+        const profile::Zone zone{earlier ? Phase::kNone : Phase::kFollowPropose};
+        // Kept from iteration to iteration and filled by the passes, not
+        // reallocated.
+        resizeBoundedVector(mProposals, elements, mMemoryPool.get());
+        resizeBoundedVector(mBids, used.size(), mMemoryPool.get());
+        resizeBoundedVector(mRows, elements, mMemoryPool.get());
+        resizeBoundedVector(mCounts, elements, mMemoryPool.get());
+        resizeBoundedVector(mKinkSteps, takesKinkSteps(parameters) ? elements : 0U, mMemoryPool.get());
+        if (end) {
+          resizeBoundedVector(mEndStarts, elements, mMemoryPool.get());
+        }
+      }
+      follow::runSequence(follow::HostLaunch<ForEach>{.forEach = &forEach, .earlier = earlier}, follow::Inputs<Det, Material>{
+                                                                                                  .parameters = &parameters,
+                                                                                                  .choices = &parameters,
+                                                                                                  .frame = &frame,
+                                                                                                  .geometry = &geometry,
+                                                                                                  .material = &material,
+                                                                                                  .propagator = propagator,
+                                                                                                  .tracks = tracks.view(),
+                                                                                                  .constTracks = static_cast<const Tracks&>(tracks).view(),
+                                                                                                  .trackOffset = trackOffset,
+                                                                                                  .trackCount = trackCount,
+                                                                                                  .inward = inward,
+                                                                                                  .earlier = earlier,
+                                                                                                  .used = used.data(),
+                                                                                                  .rowCount = used.size(),
+                                                                                                  .maxCandidateWidthPS = maxCandidateWidthPS.data(),
+                                                                                                  .cells = cells,
+                                                                                                  .proposals = mProposals.data(),
+                                                                                                  .bids = mBids.data(),
+                                                                                                  .rows = mRows.data(),
+                                                                                                  .counts = mCounts.data(),
+                                                                                                  .steps = mKinkSteps.empty() ? nullptr : mKinkSteps.data(),
+                                                                                                  .endStarts = end ? mEndStarts.data() : nullptr,
+                                                                                                });
+      return StageStatus::kComplete;
+    });
+  }
+
+  /// Each track's proposal after the passes: the rows it took.
+  [[nodiscard]] std::span<const Proposal> proposals() const { return mProposals; }
+
+  /// Each proposal's kink steps, as proposed (before the bidding); empty
+  /// without them (`takesKinkSteps`).
+  [[nodiscard]] std::span<const follow::KinkSteps> kinkSteps() const { return mKinkSteps; }
+
+  /// Whether an iteration's follow takes kink steps: it has a kink allowance.
+  [[nodiscard]] static bool takesKinkSteps(const IterationParameters<Det>& parameters) { return parameters.kinkScale2 > 1.F && parameters.maxKinks != 0U; }
+
+  /// Whether an iteration's follow decides its ends on the last row's
+  /// density (`FollowStage`'s EndDensity): either of its keys is set.
+  [[nodiscard]] static bool endDensity(const IterationParameters<Det>& parameters) { return parameters.followEndMaxSqrtDet > 0.F || parameters.followKeepDensity > 0.F; }
+
+  /// Proposal \a first + i taken from proposal kept[i], for every i, as the
+  /// tracker drops short tracks in parallel: \a kept ascends
+  /// and kept[i] >= first + i, so the moves go through a scratch.
+  /// \a forEach(count, body) runs body(i) for i in [0, count).
+  template <typename Index, typename ForEach>
+  void keepProposals(std::span<const Index> kept, std::size_t first, const ForEach& forEach)
+  {
+    const auto count = static_cast<Index>(kept.size());
+    const auto move = [&](auto& values) {
+      using Value = typename std::remove_reference_t<decltype(values)>::value_type;
+      BoundedVector<Value> scratch(std::pmr::polymorphic_allocator<Value>{mMemoryPool.get()});
+      resizeBoundedVector(scratch, count);
+      forEach(count, [&](Index at) { scratch[at] = values[kept[at]]; });
+      forEach(count, [&](Index at) { values[first + at] = scratch[at]; });
+    };
+    move(mProposals);
+    if (!mKinkSteps.empty()) {
+      move(mKinkSteps);
+    }
+  }
+  void truncateProposals(std::size_t count)
+  {
+    mProposals.resize(count);
+    if (!mKinkSteps.empty()) {
+      mKinkSteps.resize(count);
+    }
+  }
+
+ private:
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  BoundedVector<Proposal> mProposals;
+  BoundedVector<std::uint32_t> mBids;
+  BoundedVector<ClusterList<kMaxClusters>> mRows;
+  BoundedVector<std::uint8_t> mCounts;
+  BoundedVector<follow::KinkSteps> mKinkSteps;
+  BoundedVector<BoundTrackState> mEndStarts; ///< with followEnd: each track's state without its outermost row
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_FOLLOW_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceArena.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceArena.h
new file mode 100644
index 0000000000000..b7b75c9933fed
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceArena.h
@@ -0,0 +1,148 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceArena.h
+/// \brief A bounded, scoped bump allocator over one block of device memory.
+///
+/// Two ends: what lives as long as a scope of
+/// the run, the timeframe, the iteration or the slice - parameters, the
+/// timeframe's columns, a stage's output - grows up from the base; what must
+/// outlive a base-end scope closed before it - the timeframe's track chunks,
+/// the iteration's record chunks - or is needed only while a stage runs -
+/// staging, scan storage - grows down from the top. Each end has its own
+/// nested scopes; the two ends meet and never cross.
+
+#ifndef GTRK_TRACKING_GPU_DEVICEARENA_H_
+#define GTRK_TRACKING_GPU_DEVICEARENA_H_
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+class DeviceRuntime;
+class DeviceArena;
+template <template <template <class> class> class S>
+class DeviceColumns;
+
+/// Which end of the arena an allocation or a scope belongs to.
+enum class ArenaEnd : std::uint8_t {
+  kBase = 0,    ///< grows up: storage of the scopes the run nests
+  kScratch = 1, ///< grows down: chunks that outlive a base scope, and a stage's staging
+};
+
+/// Device memory an arena works in, owned by whoever hands it out (O2's
+/// GPU reconstruction's pool, through GPUChainGenericTracking).
+struct DeviceBlock {
+  void* data = nullptr;
+  std::size_t bytes = 0;
+};
+
+struct ArenaTag {
+  const DeviceArena* arena = nullptr;
+  ArenaEnd end = ArenaEnd::kBase;
+  std::size_t depth = 0;
+  std::uint64_t serial = 0;
+};
+
+struct DeviceAllocation {
+  void* data = nullptr;
+  std::size_t bytes = 0;
+  ArenaTag tag;
+
+  [[nodiscard]] explicit operator bool() const noexcept { return data != nullptr || bytes == 0U; }
+};
+
+class ArenaScope
+{
+ public:
+  ArenaScope() = default;
+  ~ArenaScope();
+  ArenaScope(const ArenaScope&) = delete;
+  ArenaScope& operator=(const ArenaScope&) = delete;
+  ArenaScope(ArenaScope&& other) noexcept;
+  ArenaScope& operator=(ArenaScope&& other) noexcept;
+
+ private:
+  friend class DeviceArena;
+  template <template <template <class> class> class S>
+  friend class DeviceColumns;
+  ArenaScope(DeviceArena& arena, ArenaEnd end, std::size_t depth, std::uint64_t serial) noexcept : mArena(&arena), mEnd(end), mDepth(depth), mSerial(serial) {}
+  /// Keep a transactional allocation and let its descriptor take the parent
+  /// scope's tag. Ordinary arena scopes always rewind on destruction.
+  void commit();
+  void close() noexcept;
+
+  DeviceArena* mArena = nullptr;
+  ArenaEnd mEnd = ArenaEnd::kBase;
+  std::size_t mDepth = 0;
+  std::uint64_t mSerial = 0;
+};
+
+class DeviceArena
+{
+ public:
+  DeviceArena(DeviceRuntime& runtime, DeviceBlock block);
+  ~DeviceArena() = default;
+  DeviceArena(const DeviceArena&) = delete;
+  DeviceArena& operator=(const DeviceArena&) = delete;
+  DeviceArena(DeviceArena&&) = delete;
+  DeviceArena& operator=(DeviceArena&&) = delete;
+
+  [[nodiscard]] DeviceAllocation allocate(std::size_t bytes, std::size_t alignment = 256U, ArenaEnd end = ArenaEnd::kBase);
+  [[nodiscard]] ArenaScope scope(ArenaEnd end = ArenaEnd::kBase);
+  /// Rewind both ends and close every scope; the block stays.
+  void reset() noexcept;
+  /// Work in \a block from now on: both ends rewound, every scope closed and
+  /// every allocation's tag dead, the peak zero. The arena object stays where
+  /// it is, for those that hold it.
+  void rebind(DeviceBlock block) noexcept;
+  void resetPeak() noexcept { mPeak = used(); }
+  /// The peak becomes at least \a peak: closes a window `resetPeak` opened.
+  void raisePeak(std::size_t peak) noexcept { mPeak = std::max(mPeak, peak); }
+
+  /// Both ends together, and each end on its own.
+  [[nodiscard]] std::size_t used() const noexcept { return mUsed[0] + mUsed[1]; }
+  [[nodiscard]] std::size_t used(ArenaEnd end) const noexcept { return mUsed[static_cast<std::size_t>(end)]; }
+  [[nodiscard]] std::size_t peak() const noexcept { return mPeak; }
+  [[nodiscard]] std::size_t capacity() const noexcept { return mCapacity; }
+  [[nodiscard]] DeviceRuntime& runtime() const noexcept { return *mRuntime; }
+  [[nodiscard]] ArenaTag currentTag(ArenaEnd end = ArenaEnd::kBase) const noexcept;
+  void requireLive(const ArenaTag& tag) const;
+
+ private:
+  friend class ArenaScope;
+  [[nodiscard]] bool live(const ArenaTag& tag) const noexcept;
+  struct ScopeState {
+    std::size_t offset = 0;
+    std::uint64_t serial = 0;
+  };
+
+  [[nodiscard]] DeviceAllocation refuse(std::size_t bytes, ArenaEnd end) const;
+  void closeScope(ArenaEnd end, std::size_t depth, std::uint64_t serial, bool commit) noexcept;
+
+  DeviceRuntime* mRuntime = nullptr;
+  void* mBase = nullptr;
+  std::size_t mCapacity = 0;
+  /// Bytes in use at each end: from the base up, and from the top down.
+  std::array<std::size_t, 2> mUsed{};
+  std::size_t mPeak = 0;
+  std::uint64_t mNextSerial = 1;
+  std::array<std::vector<ScopeState>, 2> mScopes;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_GPU_DEVICEARENA_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceContext.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceContext.h
new file mode 100644
index 0000000000000..64170ce778401
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceContext.h
@@ -0,0 +1,107 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceContext.h
+/// \brief A GPU device on O2's GPU route: the reconstruction that owns it,
+///        the blocks of its pool the device trackers work in, and the
+///        backend's runtime.
+///
+/// The reconstruction (`o2::gpu::GPUReconstruction`) initialises the device
+/// and allocates the pool; `GPUChainGenericTracking` sets aside one block of
+/// it per tracker; the backend library loaded with the reconstruction's
+/// backend makes the runtime (RuntimeFactory.h). A tracker made on the
+/// context is destroyed before it.
+///
+/// Or on the GPU reconstruction of a workflow that owns it (the TPC's), not
+/// owned: no blocks of its own; each timeframe borrows the pool's free memory
+/// after the TPC (`borrow`). The reconstruction's own processing and the
+/// borrow are one timeframe at a time on its thread, as its pool requires.
+
+#ifndef GTRK_TRACKING_GPU_DEVICECONTEXT_H_
+#define GTRK_TRACKING_GPU_DEVICECONTEXT_H_
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <string_view>
+
+namespace o2::gpu
+{
+class GPUReconstruction;
+} // namespace o2::gpu
+
+namespace o2::gtrk
+{
+
+class DeviceRuntime;
+class GPUChainGenericTracking;
+
+class DeviceContext
+{
+ public:
+  /// \a backend ("cuda" or "hip", in any case) on \a device, with one block
+  /// of each of \a blockBytes; std::runtime_error if it cannot be had.
+  DeviceContext(std::string_view backend, int device, std::span<const std::size_t> blockBytes);
+  /// On \a reconstruction, initialised by its owner: its backend, the device
+  /// it selected. std::runtime_error if it cannot lend its pool: not a GPU, or
+  /// its memory settings do not give back what is borrowed (individual
+  /// allocations, keepDisplayMemory, disableMemoryReuse).
+  explicit DeviceContext(o2::gpu::GPUReconstruction& reconstruction);
+  ~DeviceContext();
+  DeviceContext(const DeviceContext&) = delete;
+  DeviceContext& operator=(const DeviceContext&) = delete;
+  DeviceContext(DeviceContext&&) = delete;
+  DeviceContext& operator=(DeviceContext&&) = delete;
+
+  [[nodiscard]] DeviceRuntime& runtime() const noexcept { return *mRuntime; }
+  /// Block \a index, in the order of the constructor's sizes; not on a
+  /// borrowed reconstruction (std::logic_error).
+  [[nodiscard]] DeviceBlock block(std::size_t index) const;
+
+  /// The pool's free memory, borrowed from the reconstruction until the
+  /// borrow goes: a stack allocation of all of it between the pool's push and
+  /// pop of \a tag. Empty (no data, no bytes) if nothing is free.
+  class Borrowed
+  {
+   public:
+    ~Borrowed();
+    Borrowed(const Borrowed&) = delete;
+    Borrowed& operator=(const Borrowed&) = delete;
+    Borrowed(Borrowed&&) = delete;
+    Borrowed& operator=(Borrowed&&) = delete;
+    [[nodiscard]] DeviceBlock block() const noexcept { return mBlock; }
+
+   private:
+    friend class DeviceContext;
+    Borrowed(o2::gpu::GPUReconstruction& reconstruction, std::uint64_t tag);
+    o2::gpu::GPUReconstruction* mReconstruction;
+    std::uint64_t mTag;
+    DeviceBlock mBlock;
+  };
+  /// The timeframe's device memory on a borrowed reconstruction: give it
+  /// back (destroy the borrow) only once nothing reads it any more.
+  [[nodiscard]] std::unique_ptr<Borrowed> borrow(std::uint64_t tag) const;
+
+ private:
+  /// Declared first, destroyed last: the runtime's streams and the blocks
+  /// are the reconstruction's device's. Empty on a borrowed one.
+  std::unique_ptr<o2::gpu::GPUReconstruction> mOwned;
+  o2::gpu::GPUReconstruction* mReconstruction = nullptr;
+  GPUChainGenericTracking* mChain = nullptr;
+  std::unique_ptr<DeviceRuntime> mRuntime;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_GPU_DEVICECONTEXT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceRuntime.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceRuntime.h
new file mode 100644
index 0000000000000..4669be5007248
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceRuntime.h
@@ -0,0 +1,130 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceRuntime.h
+/// \brief A GPU backend's runtime: streams, copies, fills and the device
+///        trackers, vendor-neutral.
+///
+/// Made for the device O2's GPU reconstruction initialised, by the factory
+/// its backend library registered (RuntimeFactory.h); the device memory is
+/// the reconstruction's pool, of which each tracker gets a block.
+
+#ifndef GTRK_TRACKING_GPU_DEVICERUNTIME_H_
+#define GTRK_TRACKING_GPU_DEVICERUNTIME_H_
+
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceStream.h"
+#include "GenericTracking/Tracking/GPU/RuntimeFactory.h"
+
+namespace o2::base
+{
+class MatLayerCylSet;
+}
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+
+namespace o2::gtrk
+{
+
+/// Declared only: the runtime names the trackers it makes, their users
+/// include DeviceTracker.h.
+template <DetectorLayout Det, typename Material>
+class DeviceTracker;
+
+/// One device-to-device copy of copyEachOnDevice.
+struct DeviceCopy {
+  void* to = nullptr;
+  const void* from = nullptr;
+  std::size_t bytes = 0U;
+};
+
+struct DeviceProperties {
+  std::string name;
+  std::string architecture;
+  int warpSize = 0;
+};
+
+/// Every call runs on the device current on the calling thread: the one
+/// the reconstruction initialised.
+class DeviceRuntime
+{
+ public:
+  DeviceRuntime() = default;
+  virtual ~DeviceRuntime() = default;
+  DeviceRuntime(const DeviceRuntime&) = delete;
+  DeviceRuntime& operator=(const DeviceRuntime&) = delete;
+  DeviceRuntime(DeviceRuntime&&) = delete;
+  DeviceRuntime& operator=(DeviceRuntime&&) = delete;
+
+  [[nodiscard]] virtual const char* backend() const noexcept = 0;
+  [[nodiscard]] virtual const DeviceProperties& properties() const noexcept = 0;
+
+  [[nodiscard]] DeviceStream createStream();
+
+  virtual void copyToDevice(void* to, const void* from, std::size_t bytes, DeviceStream& stream) = 0;
+  virtual void copyToHost(void* to, const void* from, std::size_t bytes, DeviceStream& stream) = 0;
+  virtual void copyOnDevice(void* to, const void* from, std::size_t bytes, DeviceStream& stream) = 0;
+  /// Every copy of \a copies, none overlapping another's destination or
+  /// source, by one kernel (a few for many copies) instead of a copy each.
+  virtual void copyEachOnDevice(std::span<const DeviceCopy> copies, DeviceStream& stream) = 0;
+  virtual void fill(void* to, std::uint8_t value, std::size_t bytes, DeviceStream& stream) = 0;
+  /// Page-lock the \a bytes of host memory at \a host for this device's
+  /// copies, which then run without staging: whole pages no other
+  /// registration shares (`PageAllocator`), until unregisterHost.
+  virtual void registerHost(void* host, std::size_t bytes) = 0;
+  virtual void unregisterHost(void* host) noexcept = 0;
+
+  /// Backend launchers use this to recover cudaStream_t/hipStream_t without
+  /// exposing either type in a public header.
+  [[nodiscard]] static void* nativeStream(DeviceStream& stream);
+
+  /// The device tracker for \a D, its arena on \a block; std::runtime_error
+  /// for a layout the backends are not built for.
+  template <DetectorLayout D>
+  [[nodiscard]] std::unique_ptr<DeviceTracker<D, o2::base::MatLayerCylSet>> makeTracker(DeviceBlock block)
+  {
+    if constexpr (std::is_same_v<D, detectors::ITS>) {
+      return makeITSTracker(block);
+    } else if constexpr (std::is_same_v<D, detectors::MFT>) {
+      return makeMFTTracker(block);
+    } else if constexpr (std::is_same_v<D, detectors::TRKFT3>) {
+      return makeTRKFT3Tracker(block);
+    } else {
+      throw std::runtime_error(std::string{"GPU backend "} + backend() + ": no device tracker is built for " + D::name);
+    }
+  }
+
+ protected:
+  [[nodiscard]] virtual void* createStreamHandle() = 0;
+
+ private:
+  friend class DeviceStream;
+
+  virtual void destroyStreamHandle(void* handle) noexcept = 0;
+  virtual void synchronizeStreamHandle(void* handle) = 0;
+
+  [[nodiscard]] virtual std::unique_ptr<DeviceTracker<detectors::ITS, o2::base::MatLayerCylSet>> makeITSTracker(DeviceBlock block) = 0;
+  [[nodiscard]] virtual std::unique_ptr<DeviceTracker<detectors::MFT, o2::base::MatLayerCylSet>> makeMFTTracker(DeviceBlock block) = 0;
+  [[nodiscard]] virtual std::unique_ptr<DeviceTracker<detectors::TRKFT3, o2::base::MatLayerCylSet>> makeTRKFT3Tracker(DeviceBlock block) = 0;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_GPU_DEVICERUNTIME_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceStageOutput.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceStageOutput.h
new file mode 100644
index 0000000000000..1cf74e16dc558
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceStageOutput.h
@@ -0,0 +1,137 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceStageOutput.h
+/// \brief One stage's canonical output in device memory: the device side of
+///        StageOutput<S>.
+///
+/// `count` and `offset` have `n + 1` entries each - the last count is zero so
+/// that one exclusive scan gives `offset[n]`, the total - and the placed
+/// columns hold the stage's records in serial order. Everything lives on the
+/// base end of the arena, in the caller's scope; the working storage of a run
+/// is its stage's (GpuStage.cuh, FlatStage.cuh), on the scratch end; a flat run
+/// of several chunks also leaves its chunks' records on the base end
+/// (FlatStage.cuh).
+
+#ifndef GTRK_TRACKING_GPU_DEVICESTAGEOUTPUT_H_
+#define GTRK_TRACKING_GPU_DEVICESTAGEOUTPUT_H_
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <stdexcept>
+
+namespace o2::gtrk
+{
+
+/// What a stage's run over a flat candidate list reports (`flat::runFlat`).
+struct FlatRunReport {
+  std::uint64_t candidates = 0U; ///< the list's candidates, every element's
+  std::uint32_t largest = 0U;    ///< the most candidates of one element
+  std::uint32_t chunks = 0U;     ///< the chunks the list was run in
+  std::uint32_t readbacks = 0U;
+  std::size_t freeBytes = 0U; ///< the arena's free bytes when the run starts
+};
+
+template <template <template <class> class> class S>
+class DeviceStageOutput
+{
+ public:
+  using Host = StageOutput<S>;
+  using Index = typename Host::Index;
+  using Ordinal = typename Host::Ordinal;
+  using Record = typename Host::Record;
+  using Columns = DeviceColumns<S>;
+  static constexpr std::size_t kMaxPerElement = Host::kMaxPerElement;
+
+  /// Counts and offsets for \a elements elements. False if the arena refuses.
+  [[nodiscard]] bool prepare(DeviceArena& arena, Index elements)
+  {
+    mElements = elements;
+    mSize = 0U;
+    mOutputReady = false;
+    return mCounts.allocate(arena, std::size_t{elements} + 1U) && mOffsets.allocate(arena, std::size_t{elements} + 1U);
+  }
+
+  /// The placed columns, once a run knows the total. False if the arena refuses.
+  [[nodiscard]] bool allocateOutput(DeviceArena& arena, Index total)
+  {
+    mOutputReady = mOutput.allocate(arena, total);
+    return mOutputReady;
+  }
+
+  /// A completed run's record count.
+  void setSize(Index total) noexcept { mSize = total; }
+
+  /// \a columns, already holding the \a total placed records, as the output
+  /// (a flat run's one chunk is its output).
+  void adoptOutput(const Columns& columns, Index total) noexcept
+  {
+    mOutput = columns;
+    mOutputReady = true;
+    mSize = total;
+  }
+
+  [[nodiscard]] Index elementCount() const noexcept { return mElements; }
+  [[nodiscard]] Index size() const noexcept { return mSize; }
+  [[nodiscard]] DeviceSpan<Index>& counts() noexcept { return mCounts; }
+  [[nodiscard]] const DeviceSpan<Index>& counts() const noexcept { return mCounts; }
+  [[nodiscard]] DeviceSpan<Index>& offsets() noexcept { return mOffsets; }
+  [[nodiscard]] const DeviceSpan<Index>& offsets() const noexcept { return mOffsets; }
+  [[nodiscard]] Columns& output()
+  {
+    requireOutput();
+    return mOutput;
+  }
+  [[nodiscard]] const Columns& output() const
+  {
+    requireOutput();
+    return mOutput;
+  }
+  [[nodiscard]] typename Columns::View view() { return output().view(); }
+  [[nodiscard]] typename Columns::ConstView view() const { return output().view(); }
+
+ private:
+  void requireOutput() const
+  {
+    if (!mOutputReady) {
+      throw std::logic_error("the device stage output has no placed records: no run has completed");
+    }
+  }
+
+  Index mElements = 0U;
+  Index mSize = 0U;
+  bool mOutputReady = false;
+  DeviceSpan<Index> mCounts;
+  DeviceSpan<Index> mOffsets;
+  Columns mOutput;
+};
+
+/// Copy a completed device stage into \a host - counts, offsets and the placed
+/// columns - so that it compares with a host StageOutput byte for byte. The
+/// copies are ordered on \a stream; the caller synchronises before reading.
+template <template <template <class> class> class S>
+void download(const DeviceStageOutput<S>& device, StageOutput<S>& host, DeviceStream& stream)
+{
+  const auto elements = device.elementCount();
+  host.prepare(elements);
+  download(device.counts(), host.counts().data(), elements, stream);
+  download(device.offsets(), host.offsets().data(), std::size_t{elements} + 1U, stream);
+  host.resizeOutput(device.size());
+  download(device.output(), host.output(), device.size(), stream);
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_GPU_DEVICESTAGEOUTPUT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceStorage.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceStorage.h
new file mode 100644
index 0000000000000..07cf6e16efcc2
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceStorage.h
@@ -0,0 +1,556 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceStorage.h
+/// \brief Typed, non-owning descriptors over DeviceArena storage.
+
+#ifndef GTRK_TRACKING_GPU_DEVICESTORAGE_H_
+#define GTRK_TRACKING_GPU_DEVICESTORAGE_H_
+
+#include "GenericTracking/Base/Columns.h"
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+
+#include <memlayout/wrapper.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <new>
+#include <vector>
+#include <memory>
+#include <limits>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+
+#include <unistd.h>
+
+namespace o2::gtrk
+{
+
+namespace device_storage_detail
+{
+template <typename T>
+[[nodiscard]] DeviceAllocation allocateArray(DeviceArena& arena, std::size_t count, ArenaEnd end)
+{
+  static_assert(std::is_trivially_copyable_v<T>);
+  if (count > std::numeric_limits<std::size_t>::max() / sizeof(T)) {
+    return arena.allocate(std::numeric_limits<std::size_t>::max(), 256U, end);
+  }
+  return arena.allocate(count * sizeof(T), 256U, end);
+}
+
+/// \a copy(to, from) for each column of \a from and the same column of \a to,
+/// both column views of one record type.
+template <typename From, typename To, typename Copy>
+void forEachColumnPair(const From& from, const To& to, const Copy& copy)
+{
+  from.apply([&](const auto&... source) { to.apply([&](auto... target) { (copy(target, source), ...); }); });
+}
+
+/// The arena of a descriptor, \a what naming it in the error; with \a tag,
+/// also checked live (std::logic_error for storage of a rewound scope).
+[[nodiscard]] inline DeviceArena& requireAllocated(DeviceArena* arena, const char* what, const ArenaTag* tag = nullptr)
+{
+  if (arena == nullptr) {
+    throw std::logic_error(std::string{what} + " has not been allocated");
+  }
+  if (tag != nullptr) {
+    arena->requireLive(*tag);
+  }
+  return *arena;
+}
+} // namespace device_storage_detail
+
+template <typename T>
+class DeviceSpan
+{
+ public:
+  static_assert(std::is_trivially_copyable_v<T>);
+
+  [[nodiscard]] bool allocate(DeviceArena& arena, std::size_t count, ArenaEnd end = ArenaEnd::kBase)
+  {
+    const DeviceAllocation allocation = device_storage_detail::allocateArray<T>(arena, count, end);
+    if (!allocation) {
+      return false;
+    }
+    mArena = &arena;
+    mData = static_cast<T*>(allocation.data);
+    mSize = count;
+    mTag = allocation.tag;
+    return true;
+  }
+
+  [[nodiscard]] T* data()
+  {
+    requireLive();
+    return mData;
+  }
+  [[nodiscard]] const T* data() const
+  {
+    requireLive();
+    return mData;
+  }
+  [[nodiscard]] std::size_t size() const
+  {
+    requireLive();
+    return mSize;
+  }
+  [[nodiscard]] DeviceArena& arena() const { return device_storage_detail::requireAllocated(mArena, "device span"); }
+
+ private:
+  void requireLive() const { static_cast<void>(device_storage_detail::requireAllocated(mArena, "device span", &mTag)); }
+
+  DeviceArena* mArena = nullptr;
+  T* mData = nullptr;
+  std::size_t mSize = 0;
+  ArenaTag mTag;
+};
+
+template <typename T>
+class DeviceObject
+{
+ public:
+  static_assert(std::is_trivially_copyable_v<T>);
+
+  [[nodiscard]] bool allocate(DeviceArena& arena, ArenaEnd end = ArenaEnd::kBase) { return mStorage.allocate(arena, 1U, end); }
+  [[nodiscard]] T* data() { return mStorage.data(); }
+  [[nodiscard]] const T* data() const { return mStorage.data(); }
+  [[nodiscard]] DeviceArena& arena() const { return mStorage.arena(); }
+
+ private:
+  DeviceSpan<T> mStorage;
+};
+
+template <template <template <class> class> class S>
+class DeviceColumns
+{
+ public:
+  using View = memlayout::Wrapper<S, memlayout::pointer, memlayout::Layout::soa>;
+  using ConstView = memlayout::Wrapper<S, memlayout::const_pointer, memlayout::Layout::soa>;
+  using Pointers = S<memlayout::pointer>;
+
+  /// Allocate all columns or none. Successful allocations inherit the parent
+  /// scope's lifetime; a failure rewinds the temporary scope.
+  [[nodiscard]] bool allocate(DeviceArena& arena, std::size_t rows, ArenaEnd end = ArenaEnd::kBase)
+  {
+    auto transaction = arena.scope(end);
+    Pointers pointers{};
+    bool complete = true;
+    pointers.apply([&](auto&... pointer) {
+      const auto allocateOne = [&](auto& out) {
+        if (!complete) {
+          return;
+        }
+        using Element = std::remove_pointer_t<std::remove_reference_t<decltype(out)>>;
+        const DeviceAllocation allocation = device_storage_detail::allocateArray<Element>(arena, rows, end);
+        if (!allocation) {
+          complete = false;
+          return;
+        }
+        out = static_cast<Element*>(allocation.data);
+      };
+      (allocateOne(pointer), ...);
+    });
+    if (!complete) {
+      return false;
+    }
+    transaction.commit();
+    mArena = &arena;
+    mPointers = pointers;
+    mRows = rows;
+    mTag = arena.currentTag(end);
+    return true;
+  }
+
+  [[nodiscard]] std::size_t size() const
+  {
+    requireLive();
+    return mRows;
+  }
+  [[nodiscard]] View view()
+  {
+    requireLive();
+    return View{mPointers};
+  }
+  [[nodiscard]] ConstView view() const
+  {
+    requireLive();
+    return ConstView{mPointers};
+  }
+  [[nodiscard]] DeviceArena& arena() const { return device_storage_detail::requireAllocated(mArena, "device columns"); }
+
+ private:
+  void requireLive() const { static_cast<void>(device_storage_detail::requireAllocated(mArena, "device columns", &mTag)); }
+
+  DeviceArena* mArena = nullptr;
+  Pointers mPointers{};
+  std::size_t mRows = 0;
+  ArenaTag mTag;
+};
+
+template <typename T>
+void upload(const T* source, DeviceSpan<T>& destination, std::size_t count, DeviceStream& stream)
+{
+  if (count > destination.size()) {
+    throw std::out_of_range("device span upload exceeds its destination");
+  }
+  if (count == 0U) {
+    return;
+  }
+  destination.arena().runtime().copyToDevice(destination.data(), source, count * sizeof(T), stream);
+}
+
+template <typename T>
+void download(const DeviceSpan<T>& source, T* destination, std::size_t count, DeviceStream& stream)
+{
+  if (count > source.size()) {
+    throw std::out_of_range("device span download exceeds its source");
+  }
+  if (count == 0U) {
+    return;
+  }
+  source.arena().runtime().copyToHost(destination, source.data(), count * sizeof(T), stream);
+}
+
+/// The same into \a destination, sized to \a count.
+template <typename T>
+void download(const DeviceSpan<T>& source, std::vector<T>& destination, std::size_t count, DeviceStream& stream)
+{
+  destination.resize(count);
+  download(source, destination.data(), count, stream);
+}
+
+template <typename T>
+void uploadObject(const T& source, DeviceObject<T>& destination, DeviceStream& stream)
+{
+  destination.arena().runtime().copyToDevice(destination.data(), &source, sizeof(T), stream);
+}
+
+/// Upload \a rows rows of any host column view -- a DPL message's columns
+/// included, which are not a BoundedColumns. The record type cannot be deduced
+/// through the nested ConstView, so callers name it: `upload<MeasurementT>(...)`.
+template <template <template <class> class> class S>
+void upload(typename DeviceColumns<S>::ConstView source, std::size_t rows, DeviceColumns<S>& destination, DeviceStream& stream)
+{
+  if (rows > destination.size()) {
+    throw std::out_of_range("device column upload exceeds its destination");
+  }
+  if (rows == 0U) {
+    return;
+  }
+  auto& runtime = destination.arena().runtime();
+  device_storage_detail::forEachColumnPair(source, destination.view(), [&](auto* to, const auto* from) { runtime.copyToDevice(to, from, rows * sizeof(*to), stream); });
+}
+
+/// Download \a rows rows of \a source into \a destination from row \a
+/// destinationOffset, which must hold them.
+template <template <template <class> class> class S>
+void download(const DeviceColumns<S>& source, BoundedColumns<S>& destination, std::size_t destinationOffset, std::size_t rows, DeviceStream& stream)
+{
+  if (rows > source.size() || destinationOffset > destination.size() || rows > destination.size() - destinationOffset) {
+    throw std::out_of_range("device column download exceeds its source or its destination");
+  }
+  if (rows == 0U) {
+    return;
+  }
+  auto& runtime = source.arena().runtime();
+  device_storage_detail::forEachColumnPair(source.view(), destination.view(), [&](auto* to, const auto* from) { runtime.copyToHost(to + destinationOffset, from, rows * sizeof(*to), stream); });
+}
+
+template <template <template <class> class> class S>
+void download(const DeviceColumns<S>& source, BoundedColumns<S>& destination, std::size_t rows, DeviceStream& stream)
+{
+  if (rows > source.size()) {
+    throw std::out_of_range("device column download exceeds its source");
+  }
+  destination.resize(rows);
+  download(source, destination, 0U, rows, stream);
+}
+
+namespace device_storage_detail
+{
+/// The copies of \a rows rows of \a source, from row \a sourceOffset, into
+/// \a destination at row \a destinationOffset, a copy per column, appended to
+/// \a copies.
+template <template <template <class> class> class S>
+void columnCopies(const DeviceColumns<S>& source, std::size_t sourceOffset, DeviceColumns<S>& destination, std::size_t destinationOffset, std::size_t rows, std::vector<DeviceCopy>& copies)
+{
+  if (sourceOffset > source.size() || rows > source.size() - sourceOffset || destinationOffset > destination.size() || rows > destination.size() - destinationOffset) {
+    throw std::out_of_range("device column copy exceeds its source or its destination");
+  }
+  if (rows == 0U) {
+    return;
+  }
+  forEachColumnPair(source.view(), destination.view(), [&](auto* to, const auto* from) { copies.push_back({.to = to + destinationOffset, .from = from + sourceOffset, .bytes = rows * sizeof(*to)}); });
+}
+} // namespace device_storage_detail
+
+/// Copy \a rows rows of \a source, from row \a sourceOffset, into
+/// \a destination at row \a destinationOffset, on the device: all columns
+/// by one kernel, queued on \a stream.
+template <template <template <class> class> class S>
+void copyColumns(const DeviceColumns<S>& source, std::size_t sourceOffset, DeviceColumns<S>& destination, std::size_t destinationOffset, std::size_t rows, DeviceStream& stream)
+{
+  std::vector<DeviceCopy> copies;
+  device_storage_detail::columnCopies(source, sourceOffset, destination, destinationOffset, rows, copies);
+  if (!copies.empty()) {
+    destination.arena().runtime().copyEachOnDevice(copies, stream);
+  }
+}
+
+/// Records of a column set kept as chunks, each exactly sized, in the order
+/// they came, and gathered into one column set when they are all there.
+/// The chunks live in the arena scope that was
+/// current on their end when they were appended; gathering them after it
+/// closed throws, as any use of stale device storage does.
+template <template <template <class> class> class S>
+class DeviceColumnChunks
+{
+ public:
+  /// Copy \a rows rows of \a source, from row \a sourceOffset, into a new
+  /// chunk on \a end of \a arena. False, and nothing kept, if the arena refuses.
+  [[nodiscard]] bool append(DeviceArena& arena, ArenaEnd end, const DeviceColumns<S>& source, std::size_t sourceOffset, std::size_t rows, DeviceStream& stream)
+  {
+    if (rows == 0U) {
+      return true;
+    }
+    DeviceColumns<S> chunk;
+    if (!chunk.allocate(arena, rows, end)) {
+      return false;
+    }
+    copyColumns(source, sourceOffset, chunk, 0U, rows, stream);
+    mChunks.push_back(chunk);
+    mRows += rows;
+    return true;
+  }
+
+  /// \a columns, all their rows, as the next chunk, where they were allocated.
+  void adopt(const DeviceColumns<S>& columns)
+  {
+    mChunks.push_back(columns);
+    mRows += columns.size();
+  }
+
+  /// Copy every chunk, in the order appended, into \a destination from row
+  /// \a destinationOffset: all chunks' columns by one kernel.
+  void gather(DeviceColumns<S>& destination, std::size_t destinationOffset, DeviceStream& stream) const
+  {
+    std::vector<DeviceCopy> copies;
+    std::size_t at = destinationOffset;
+    for (const auto& chunk : mChunks) {
+      device_storage_detail::columnCopies(chunk, 0U, destination, at, chunk.size(), copies);
+      at += chunk.size();
+    }
+    if (!copies.empty()) {
+      destination.arena().runtime().copyEachOnDevice(copies, stream);
+    }
+  }
+
+  /// Download every chunk, in the order appended, into \a destination from
+  /// row \a destinationOffset, which must hold them: no gather on the device.
+  void download(BoundedColumns<S>& destination, std::size_t destinationOffset, DeviceStream& stream) const
+  {
+    std::size_t at = destinationOffset;
+    for (const auto& chunk : mChunks) {
+      gtrk::download(chunk, destination, at, chunk.size(), stream);
+      at += chunk.size();
+    }
+  }
+
+  /// Forget the chunks; their storage goes with its scope.
+  void clear() noexcept
+  {
+    mChunks.clear();
+    mRows = 0U;
+  }
+
+  [[nodiscard]] std::size_t rows() const noexcept { return mRows; }
+
+ private:
+  std::vector<DeviceColumns<S>> mChunks;
+  std::size_t mRows = 0U;
+};
+
+/// Host memory in whole pages of its own, page-aligned: a block a device can
+/// page-lock (DeviceRuntime::registerHost) without touching a page that
+/// anything else uses.
+template <typename T>
+struct PageAllocator {
+  using value_type = T; // NOLINT(readability-identifier-naming): the allocator requirements' name
+  PageAllocator() = default;
+  template <typename U>
+  explicit PageAllocator(const PageAllocator<U>& /*other*/) noexcept
+  {
+  }
+  [[nodiscard]] T* allocate(std::size_t count)
+  {
+    const std::size_t page = pageBytes();
+    const std::size_t bytes = ((count * sizeof(T)) + page - 1U) / page * page;
+    void* memory = std::aligned_alloc(page, std::max(bytes, page));
+    if (memory == nullptr) {
+      throw std::bad_alloc();
+    }
+    return static_cast<T*>(memory);
+  }
+  void deallocate(T* memory, std::size_t /*count*/) noexcept { std::free(memory); } // NOLINT(cppcoreguidelines-no-malloc): aligned_alloc's
+  [[nodiscard]] static std::size_t pageBytes() { return static_cast<std::size_t>(sysconf(_SC_PAGESIZE)); }
+  friend bool operator==(const PageAllocator& /*a*/, const PageAllocator& /*b*/) noexcept { return true; }
+};
+
+/// A FlatObject's bytes as they must land on the device: the object, whose
+/// internal pointers already point into the device buffer, and its buffer.
+/// Kept between ports of the same source: the clone behind the bytes is
+/// re-targeted when the device buffer moves, not made again.
+struct FlatObjectImage {
+  std::vector<std::byte> object;
+  std::vector<std::byte, PageAllocator<std::byte>> buffer; ///< whole pages: DeviceFlatObject page-locks it
+
+  const void* source = nullptr; ///< the object the image is of
+  char* future = nullptr;       ///< the device buffer its pointers name
+  std::shared_ptr<void> clone;  ///< the source's clone over `buffer`, the object's bytes taken from it
+};
+
+/// How a FlatObject type is prepared for a device: a specialisation provides
+/// `static std::size_t bufferBytes(const T& source)` and
+/// `static void image(const T& source, char* futureBuffer, FlatObjectImage& image)`,
+/// which makes \a image of \a source for \a futureBuffer or re-targets the
+/// one it holds of the same source.
+/// O2 compiles a FlatObject's host methods -- cloning, relocation, even its
+/// constructor -- only outside GPU translation units, so a specialisation is
+/// declared in a header and defined in a host .cxx, usually as
+/// flatObjectBufferBytes<T> and flatObjectImage<T> below; DeviceFlatObject
+/// then works in any translation unit.
+template <typename T>
+struct FlatObjectPort;
+
+/// The size of \a source's flat buffer, for host translation units.
+template <typename T>
+[[nodiscard]] std::size_t flatObjectBufferBytes(const T& source)
+{
+  return static_cast<std::size_t>(source.getFlatBufferSize());
+}
+
+/// FlatObject.h's recipe for a GPU, for host translation units: \a source
+/// cloned into \a image's buffer and the clone's pointers relocated to
+/// \a futureBuffer with setFutureBufferAddress, the object's bytes taken.
+/// An image of the same source is re-targeted instead: its clone's pointers
+/// back to the buffer it lives in (setActualBufferAddress), then to the new
+/// address; an image already for \a futureBuffer is left as it is. The same
+/// source object is taken to hold the same content: one changed in place
+/// needs a new image (a fresh FlatObjectImage).
+template <typename T>
+void flatObjectImage(const T& source, char* futureBuffer, FlatObjectImage& image)
+{
+  // FlatObject speaks char*; the image holds std::byte.
+  auto* const buffer = reinterpret_cast<char*>(image.buffer.data()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+  auto* clone = static_cast<T*>(image.clone.get());
+  if (clone == nullptr || image.source != &source) {
+    image.buffer.resize(static_cast<std::size_t>(source.getFlatBufferSize()));
+    auto made = std::make_shared<T>();
+    made->cloneFromObject(source, reinterpret_cast<char*>(image.buffer.data())); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+    clone = made.get();
+    image.clone = std::move(made);
+    image.source = &source;
+  } else if (image.future == futureBuffer) {
+    return;
+  } else {
+    clone->setActualBufferAddress(buffer);
+  }
+  clone->setFutureBufferAddress(futureBuffer);
+  image.future = futureBuffer;
+  image.object.resize(sizeof(T));
+  std::memcpy(image.object.data(), static_cast<const void*>(clone), sizeof(T));
+}
+
+/// An O2 FlatObject -- a MatLayerCylSet, a calibration object -- ported to the
+/// device: its image, made by FlatObjectPort<T>
+/// for the device buffer's address, copied as bytes, the buffer first. The
+/// object and its buffer are one allocation, so the upload is all or nothing,
+/// and the object is usable on the device as it lands. The image stays on the
+/// host for the next upload of the same source, only re-targeted where the
+/// device buffer moved, its buffer page-locked for the copies while it stays.
+template <typename T>
+class DeviceFlatObject
+{
+ public:
+  DeviceFlatObject() = default;
+  DeviceFlatObject(const DeviceFlatObject&) = delete;
+  DeviceFlatObject& operator=(const DeviceFlatObject&) = delete;
+  DeviceFlatObject(DeviceFlatObject&&) = delete;
+  DeviceFlatObject& operator=(DeviceFlatObject&&) = delete;
+  ~DeviceFlatObject() { unlock(); }
+
+  /// Port \a source to \a end of \a arena. False, and the arena as it was, if
+  /// the arena refuses. Returns once the copies are done.
+  [[nodiscard]] bool upload(DeviceArena& arena, const T& source, DeviceStream& stream, ArenaEnd end = ArenaEnd::kBase)
+  {
+    constexpr std::size_t kAlignment = 256U;
+    const std::size_t objectBytes = (sizeof(T) + kAlignment - 1U) / kAlignment * kAlignment;
+    const std::size_t bufferBytes = FlatObjectPort<T>::bufferBytes(source);
+    DeviceSpan<std::byte> storage;
+    if (!storage.allocate(arena, objectBytes + bufferBytes, end)) {
+      return false;
+    }
+    std::byte* const object = storage.data();
+    std::byte* const buffer = object + objectBytes;
+    auto& runtime = arena.runtime();
+    if (mImage.source != &source) {
+      unlock(); // the image is made again: its buffer may go
+    }
+    FlatObjectPort<T>::image(source, reinterpret_cast<char*>(buffer), mImage); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+    if (mImage.object.size() != sizeof(T) || mImage.buffer.size() != bufferBytes) {
+      throw std::logic_error("a flat object's image does not match its type and buffer size");
+    }
+    if (mLocked == nullptr && bufferBytes != 0U) {
+      runtime.registerHost(mImage.buffer.data(), bufferBytes);
+      mLocked = mImage.buffer.data();
+      mRuntime = &runtime;
+    } else if (mLocked != nullptr && mLocked != mImage.buffer.data()) {
+      throw std::logic_error("a flat object's page-locked image buffer moved");
+    }
+    if (bufferBytes != 0U) {
+      runtime.copyToDevice(buffer, mImage.buffer.data(), bufferBytes, stream);
+    }
+    runtime.copyToDevice(object, mImage.object.data(), sizeof(T), stream);
+    stream.synchronize(); // the image may be re-targeted once this returns
+    mStorage = storage;
+    return true;
+  }
+
+  /// The device copy let go (its arena reset), the host image kept for the
+  /// next upload.
+  void release() noexcept { mStorage = {}; }
+
+  /// The object on the device.
+  [[nodiscard]] const T* data() const { return reinterpret_cast<const T*>(mStorage.data()); } // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+
+ private:
+  /// The image's buffer released from its page lock.
+  void unlock() noexcept
+  {
+    if (mLocked != nullptr) {
+      mRuntime->unregisterHost(mLocked);
+      mLocked = nullptr;
+    }
+  }
+
+  DeviceSpan<std::byte> mStorage;
+  FlatObjectImage mImage;
+  std::byte* mLocked = nullptr; ///< the image's buffer as page-locked
+  DeviceRuntime* mRuntime = nullptr;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_GPU_DEVICESTORAGE_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceStream.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceStream.h
new file mode 100644
index 0000000000000..306ef76e20234
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceStream.h
@@ -0,0 +1,46 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceStream.h
+/// \brief A vendor-neutral, move-only stream handle.
+
+#ifndef GTRK_TRACKING_GPU_DEVICESTREAM_H_
+#define GTRK_TRACKING_GPU_DEVICESTREAM_H_
+
+namespace o2::gtrk
+{
+
+class DeviceRuntime;
+
+class DeviceStream
+{
+ public:
+  DeviceStream() = default;
+  ~DeviceStream();
+  DeviceStream(const DeviceStream&) = delete;
+  DeviceStream& operator=(const DeviceStream&) = delete;
+  DeviceStream(DeviceStream&& other) noexcept;
+  DeviceStream& operator=(DeviceStream&& other) noexcept;
+
+  void synchronize();
+
+ private:
+  friend class DeviceRuntime;
+  DeviceStream(DeviceRuntime& runtime, void* handle) noexcept : mRuntime(&runtime), mHandle(handle) {}
+  void reset() noexcept;
+
+  DeviceRuntime* mRuntime = nullptr;
+  void* mHandle = nullptr;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_GPU_DEVICESTREAM_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceTracker.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceTracker.h
new file mode 100644
index 0000000000000..d2d13a614fa31
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/DeviceTracker.h
@@ -0,0 +1,345 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceTracker.h
+/// \brief A timeframe's tracking on a device: every slice of every
+///        iteration, each iteration's selection, refit and follow, and
+///        the tracks.
+///
+/// A host interface without a vendor type, implemented once per backend
+/// library and detector (GPU/cuda/DeviceTracker.cuh). It owns a
+/// device arena, a stream, the iterations' parameters, the device copy of
+/// the current timeframe with its plan and used mask, and the tracks. It
+/// runs a TimeframePlan, the host tracker's own (SlicePlan.h), so both run
+/// on the same numbers; `run` drives it alone, a comparison call by call.
+
+#ifndef GTRK_TRACKING_GPU_DEVICETRACKER_H_
+#define GTRK_TRACKING_GPU_DEVICETRACKER_H_
+
+#include "GenericTracking/Base/Columns.h"
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceStageOutput.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Tracking/SlicePlan.h"
+#include "GenericTracking/Tracking/Follow.h"
+#include "GenericTracking/Tracking/TrackRefit.h"
+#include "GenericTracking/Tracking/VertexStage.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/Neighbour.h"
+#include "GenericTracking/Tracking/Triplet.h"
+
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <new>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+/// What a slice leaves on the device, downloaded for a comparison with the
+/// host tracker's. The stage outputs are the
+/// host types, so the existing comparisons apply.
+template <DetectorLayout Det>
+struct DeviceSliceDownload {
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+
+  explicit DeviceSliceDownload(const std::shared_ptr<BoundedMemoryResource>& pool)
+  {
+    tracklets.setMemoryPool(pool);
+    triplets.setMemoryPool(pool);
+    neighbours.setMemoryPool(pool);
+    records.setMemoryPool(pool);
+  }
+
+  StageOutput<TrackletT> tracklets;
+  StageOutput<TripletT> triplets; ///< with their final levels
+  StageOutput<NeighbourT> neighbours;
+  std::vector<std::uint32_t> chained;
+  std::vector<std::uint32_t> successorAbove;
+  std::vector<std::uint32_t> roads;
+  std::vector<std::uint32_t> starts;
+  std::vector<std::uint32_t> roadOffsets;
+  StageOutput<SelectionRecordOf<kMaxClusters>::template RecordT> records;
+};
+
+/// What an iteration leaves on the device, downloaded for a comparison: the
+/// records of every slice, gathered in slice order;
+/// the selection's order and choice, the follow's proposals, the
+/// iteration's tracks and the used mask after it.
+template <DetectorLayout Det>
+struct DeviceIterationDownload {
+ private:
+  // Own the allocator until after the columns have been destroyed.
+  std::shared_ptr<BoundedMemoryResource> mPool;
+
+ public:
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  using Records = BoundedColumns<SelectionRecordOf<kMaxClusters>::template RecordT>;
+  using Tracks = typename TrackRefit<Det>::Tracks;
+  using Proposal = typename Follow<Det>::Proposal;
+
+  explicit DeviceIterationDownload(const std::shared_ptr<BoundedMemoryResource>& pool) : mPool(pool)
+  {
+    records.setMemoryResource(mPool.get());
+    tracks.setMemoryResource(mPool.get());
+  }
+
+  Records records;
+  std::vector<std::uint32_t> ranked;   ///< the unique records, best first, as indices into `records`
+  std::vector<std::uint32_t> selected; ///< the accepted ones, best first
+  std::vector<Proposal> proposals;     ///< one per track after the follow's refit; none without the follow
+  Tracks tracks;                       ///< the iteration's, refitted and extended
+  std::vector<std::uint8_t> used;      ///< the mask after the iteration
+};
+
+/// The tracker on a device, for a detector and its material (the tests' UniformMaterial,
+/// o2::base::MatLayerCylSet). Its calls follow a lifecycle of nested scopes:
+///
+///   attach            the device memory to work in, the tracker's only one
+///                     until detach: nothing of an earlier block stays
+///   configureRun      the run: parameters, geometry, material, propagator
+///   beginTimeframe    a timeframe: measurements, offsets, the plan, used mask
+///   beginIteration    an iteration: its slices' records kept as they come
+///   runSlice          a slice of the plan, as many as the iteration has
+///   endIteration      the iteration's records gathered and selected, the
+///                     tracks refitted, extended and kept; the next may begin
+///   downloadTracks    every iteration's tracks so far
+///   endTimeframe      the timeframe closed: the host frame and plan no
+///                     longer read
+///   detach            the queued work finished and the block let go: the
+///                     run and the timeframe gone with it
+///
+/// The tracking device attaches and configures every timeframe: its block may
+/// be another one each time (the GPU reconstruction's pool after the TPC).
+///
+/// A timeframe as the tracking device runs it, the vertexer's pass first if
+/// the run has one: `findTimeframeVertices`, then `trackTimeframe`.
+///
+/// A call out of order throws std::logic_error. A failure inside a call
+/// closes what that call opened; a failed slice fails its iteration, whose
+/// later slices are refused and whose endIteration returns the failure.
+template <DetectorLayout Det, typename Material>
+class DeviceTracker
+{
+ public:
+  /// What the last slice did.
+  struct SliceReport {
+    std::uint32_t tracklets = 0U;
+    std::uint32_t permutation = 0U; ///< first tracklets the triplet stage worked
+    std::uint32_t triplets = 0U;
+    std::uint32_t neighbours = 0U;
+    std::uint32_t chained = 0U;
+    std::uint32_t roads = 0U;
+    std::uint32_t records = 0U;
+    std::uint32_t readbacks = 0U;
+    bool stagingPredictionMissed = false; ///< by any of the stages
+    /// The flat runs: the tracklet stage's
+    /// where the backend runs it flat (its candidates past `cheap`), the
+    /// triplet stage's (its window candidates over the first tracklets).
+    std::uint32_t trackletSources = 0U; ///< the sources with a query the flat tracklet run listed
+    FlatRunReport trackletRun;
+    FlatRunReport tripletRun;
+  };
+
+  /// What the last iteration's end did: its records, its selection, refit
+  /// and follow.
+  struct IterationReport {
+    std::size_t records = 0U;
+    std::uint32_t duplicates = 0U;
+    std::uint32_t mismatches = 0U; ///< duplicates that differ: must be none -- a record found by more than one slice is the same record in each
+    std::uint32_t rounds = 0U;
+    std::uint32_t tracks = 0U;
+    std::uint32_t readbacks = 0U;    ///< of the selection and the length cut
+    std::size_t arenaPeakBytes = 0U; ///< the whole arena, both ends, at its largest from beginIteration to endIteration
+  };
+  using Tracks = typename TrackRefit<Det>::Tracks;
+
+  DeviceTracker() = default;
+  virtual ~DeviceTracker() = default;
+  DeviceTracker(const DeviceTracker&) = delete;
+  DeviceTracker& operator=(const DeviceTracker&) = delete;
+  DeviceTracker(DeviceTracker&&) = delete;
+  DeviceTracker& operator=(DeviceTracker&&) = delete;
+
+  /// Work in \a block: what the tracker held goes (detach), configureRun is
+  /// due before the next timeframe.
+  virtual void attach(DeviceBlock block) = 0;
+  /// Finish the queued work, then close the run and every scope inside it and
+  /// let go of the block: it may be reused once this returns.
+  virtual void detach() noexcept = 0;
+
+  /// Rebuild the run: every open scope closed, the arena reset, then every
+  /// iteration's parameters, the geometry and the material uploaded and the
+  /// propagator kept. kOutOfMemory, and no run configured, if the arena
+  /// refuses. A FlatObject material's host image is kept from one call to
+  /// the next and made again only for another object: the same object is
+  /// taken to be the same material.
+  [[nodiscard]] virtual StageStatus configureRun(std::span<const IterationParameters<Det>> iterations, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator) = 0;
+
+  /// Upload \a frame -- its measurement columns and grid offsets -- the
+  /// device part of \a plan and a used mask with every row free, replacing
+  /// the previous timeframe, its tracks and any open iteration. \a plan must
+  /// be of \a frame and of the configured run, std::invalid_argument before
+  /// anything changes otherwise; both must outlive the timeframe.
+  [[nodiscard]] virtual StageStatus beginTimeframe(const TimeFrame<Det>& frame, const TimeframePlan<Det>& plan) = 0;
+
+  /// The staging every staged stage starts its next run with (the flat runs
+  /// have none); each then keeps what its runs needed. 2^20
+  /// records by default.
+  virtual void setStagingCapacity(std::size_t records) = 0;
+  /// The flat runs' chunks held to \a pairs at most (0: the arena's free
+  /// bytes decide): a test hook, so that chunks
+  /// cut inside sources and first tracklets on a fixture; never a tracker's.
+  virtual void setFlatChunkPairs(std::size_t pairs) = 0;
+
+  /// Open iteration \a iteration of the configured ones; the previous
+  /// iteration's gathered records go.
+  virtual void beginIteration(std::size_t iteration) = 0;
+
+  /// Run slice \a slice of the open iteration's plan, tracklets to records,
+  /// as the host tracker runs it. With \a download, the slice's outputs come
+  /// down into it.
+  [[nodiscard]] virtual StageStatus runSlice(std::size_t slice, DeviceSliceDownload<Det>* download) = 0;
+
+  /// Close the open iteration: its records gathered, selected, the selected
+  /// ones refitted and extended, the tracks kept for the timeframe and the
+  /// used mask committed; with \a download brought down. The first failure
+  /// of its slices or of its end, if any: a failed iteration leaves the used
+  /// mask and the tracks as they were before it.
+  [[nodiscard]] virtual StageStatus endIteration(DeviceIterationDownload<Det>* download) = 0;
+
+  /// Every iteration's tracks so far, in iteration order, each iteration's
+  /// best first, into \a tracks; not with an iteration open.
+  virtual void downloadTracks(Tracks& tracks) = 0;
+
+  /// The vertexing pass: iteration \a pass
+  /// of the configured run -- the pass, configured after the tracking's --
+  /// slice by slice as its plan has them, tracklets and triplets, then the
+  /// vertexer on them with \a settings for the frames the slice's core owns
+  /// (`OwnedFrames`), \a beamSpot giving the vertices' transverse spread.
+  /// The vertices, sorted by
+  /// time and each frame's by z, and their contributors into \a result, as
+  /// `VertexingPass::find` gives them; its counts too, but no per-triplet
+  /// claims and no beam estimate. Not with an
+  /// iteration open; the used mask and the tracks stay as they are.
+  [[nodiscard]] virtual StageStatus findVertices(std::size_t pass, const VertexerSettings& settings, const VertexConstraint& beamSpot, VertexerResult& result) = 0;
+
+  /// Replace the open timeframe's plan with \a plan, of the same frame and
+  /// the same run (std::invalid_argument before anything changes
+  /// otherwise): its device part uploaded -- the slices, the vertex windows,
+  /// the seeds -- the measurements, the used mask and the tracks kept. The
+  /// tracking's plan with the vertexer's list, after `findVertices`. Not with
+  /// an iteration open; \a plan must outlive the timeframe.
+  [[nodiscard]] virtual StageStatus replacePlan(const TimeframePlan<Det>& plan) = 0;
+
+  /// Close the open timeframe, and any iteration in it: from here until the
+  /// next beginTimeframe no call reads its host frame or plan. The stages
+  /// keep the staging they learnt.
+  virtual void endTimeframe() noexcept = 0;
+
+  /// What a timeframe's calls did, each part on the host's clock.
+  struct TimeframeReport {
+    double uploadSeconds = 0.;     ///< the frame and its first plan (beginTimeframe)
+    double vertexSeconds = 0.;     ///< the vertexer's pass (findVertices)
+    double planUploadSeconds = 0.; ///< the tracking's plan with the vertexer's list (replacePlan)
+    std::vector<double> iterationSeconds;
+    std::vector<IterationReport> iterations;
+    std::vector<std::vector<SliceReport>> slices; ///< per iteration, per slice run
+    double downloadSeconds = 0.;
+  };
+
+  /// A timeframe's vertices: \a frame and \a plan -- the run's every
+  /// iteration, the pass last, with an empty vertex list -- uploaded, then
+  /// the pass, iteration \a pass, into \a result (findVertices). The
+  /// timeframe stays open for trackTimeframe; \a frame and \a plan must
+  /// outlive it.
+  [[nodiscard]] StageStatus findTimeframeVertices(const TimeFrame<Det>& frame, const TimeframePlan<Det>& plan, std::size_t pass, const VertexerSettings& settings, const VertexConstraint& beamSpot, VertexerResult& result, TimeframeReport& report)
+  {
+    report = {};
+    auto start = Clock::now();
+    StageStatus status = beginTimeframe(frame, plan);
+    report.uploadSeconds = since(start);
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    start = Clock::now();
+    status = findVertices(pass, settings, beamSpot, result);
+    report.vertexSeconds = since(start);
+    return status;
+  }
+
+  /// A timeframe's tracks: its iterations [0, \a iterations) as \a plan
+  /// has them, then every track into \a tracks. With \a replaced, \a plan
+  /// -- the tracking's, with the vertexer's list -- replaces the open
+  /// timeframe's (findTimeframeVertices'); else \a frame and \a plan begin
+  /// the timeframe. Stops at the first failure and returns it, as
+  /// Tracker::run does; tracks the host cannot hold are kOutOfMemory. \a
+  /// frame and \a plan must outlive the timeframe.
+  [[nodiscard]] StageStatus trackTimeframe(const TimeFrame<Det>& frame, const TimeframePlan<Det>& plan, std::size_t iterations, bool replaced, Tracks& tracks, TimeframeReport& report)
+  {
+    if (!replaced) {
+      report = {};
+    }
+    auto start = Clock::now();
+    StageStatus status = replaced ? replacePlan(plan) : beginTimeframe(frame, plan);
+    (replaced ? report.planUploadSeconds : report.uploadSeconds) = since(start);
+    for (std::size_t iteration = 0; iteration < iterations && status == StageStatus::kComplete; ++iteration) {
+      start = Clock::now();
+      beginIteration(iteration);
+      report.slices.emplace_back();
+      StageStatus slices = StageStatus::kComplete;
+      for (std::size_t slice = 0; slice < plan.slices.size() && slices == StageStatus::kComplete; ++slice) {
+        slices = runSlice(slice, nullptr);
+        if (slices == StageStatus::kComplete) {
+          report.slices.back().push_back(lastSlice());
+        }
+      }
+      status = endIteration(nullptr);
+      report.iterationSeconds.push_back(since(start));
+      report.iterations.push_back(lastIteration());
+    }
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    start = Clock::now();
+    try {
+      downloadTracks(tracks);
+    } catch (const std::bad_alloc&) {
+      return StageStatus::kOutOfMemory;
+    }
+    report.downloadSeconds = since(start);
+    return StageStatus::kComplete;
+  }
+
+  [[nodiscard]] virtual const SliceReport& lastSlice() const = 0;
+  [[nodiscard]] virtual const IterationReport& lastIteration() const = 0;
+  /// The arena's size, what each end holds now, and the largest part of it
+  /// used so far.
+  [[nodiscard]] virtual std::size_t arenaBytes() const = 0;
+  [[nodiscard]] virtual std::size_t arenaUsedBytes(ArenaEnd end) const = 0;
+  [[nodiscard]] virtual std::size_t arenaPeakBytes() const = 0;
+
+ private:
+  using Clock = std::chrono::steady_clock;
+  [[nodiscard]] static double since(Clock::time_point from) { return std::chrono::duration<double>(Clock::now() - from).count(); }
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_GPU_DEVICETRACKER_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/MaterialPort.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/MaterialPort.h
new file mode 100644
index 0000000000000..21a37aa8cac67
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/MaterialPort.h
@@ -0,0 +1,41 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MaterialPort.h
+/// \brief O2's material LUT ported to a device as a FlatObject.
+///
+/// Declared here, defined in host code (src/GPU/MaterialPort.cxx):
+/// O2 compiles a FlatObject's host methods only outside GPU translation units.
+
+#ifndef GTRK_TRACKING_GPU_MATERIALPORT_H_
+#define GTRK_TRACKING_GPU_MATERIALPORT_H_
+
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+
+#include <cstddef>
+
+namespace o2::base
+{
+class MatLayerCylSet;
+}
+
+namespace o2::gtrk
+{
+
+template <>
+struct FlatObjectPort<o2::base::MatLayerCylSet> {
+  static std::size_t bufferBytes(const o2::base::MatLayerCylSet& source);
+  static void image(const o2::base::MatLayerCylSet& source, char* futureBuffer, FlatObjectImage& image);
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_GPU_MATERIALPORT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/RuntimeFactory.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/RuntimeFactory.h
new file mode 100644
index 0000000000000..5085d4e2d8bef
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GPU/RuntimeFactory.h
@@ -0,0 +1,40 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file RuntimeFactory.h
+/// \brief The GPU backends' runtime factories: each backend library
+///        registers its own when it is loaded -- O2's GPU backend of the same
+///        name links it -- and DeviceContext takes it for the device the
+///        reconstruction initialised.
+
+#ifndef GTRK_TRACKING_GPU_RUNTIMEFACTORY_H_
+#define GTRK_TRACKING_GPU_RUNTIMEFACTORY_H_
+
+#include <memory>
+#include <string_view>
+
+namespace o2::gtrk
+{
+
+class DeviceRuntime;
+
+/// A backend's runtime on \a device.
+using RuntimeFactory = std::unique_ptr<DeviceRuntime> (*)(int device);
+
+/// At a backend library's load: \a backend ("CUDA", "HIP") is made by \a factory.
+void registerRuntimeFactory(std::string_view backend, RuntimeFactory factory);
+
+/// The factory \a backend registered; nullptr if its library is not loaded.
+[[nodiscard]] RuntimeFactory runtimeFactory(std::string_view backend);
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_GPU_RUNTIMEFACTORY_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GridSizing.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GridSizing.h
new file mode 100644
index 0000000000000..c4614bb188e06
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/GridSizing.h
@@ -0,0 +1,142 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GridSizing.h
+/// \brief The grid's cells sized by the queries the configured iterations make.
+///
+/// A layer's cells follow from
+/// the windows of the queries that search it, and only those. Two kinds of
+/// query search a layer: the tracklet stage's, along a link the iteration
+/// takes and with that link's pair window at the iteration's minimum pT,
+/// into the link's target layer; and in an iteration that follows its tracks,
+/// the follow's, along every link of the layout, outward into the target
+/// layer and inward into the source layer, sized by the link's pair window.
+/// A layer's windows are the widest and the narrowest of them per axis;
+/// a layer no query enters is not searched and
+/// has one cell per axis.
+
+#ifndef GTRK_TRACKING_GRIDSIZING_H_
+#define GTRK_TRACKING_GRIDSIZING_H_
+
+#include "GenericTracking/Base/LayerLinks.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/LinkHoles.h"
+#include "GenericTracking/Tracking/MeasurementGrid.h"
+#include "GenericTracking/Tracking/SearchWindow.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <iterator>
+#include <optional>
+#include <span>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+/// Per layer, the widest and the narrowest window of the queries \a iterations
+/// make into it.
+///
+/// The window is the material-uniform pair window (`layerPairWindow` without a
+/// scattering table): the producer, which bins the rows, has no material map,
+/// and only the cells' sizes follow from it, never which rows a query
+/// accepts. Barrel <-> disc links do not size a layer: their window is per
+/// seed, from a few percent of the target to
+/// all of it, so no cell width follows from it.
+template <DetectorLayout Det>
+[[nodiscard]] std::array<GridLayerWindow, static_cast<std::size_t>(Detector<Det>::nLayers)> gridLayerWindows(std::span<const IterationSettings> iterations, const VertexConstraint& beamSpot)
+{
+  std::array<GridLayerWindow, static_cast<std::size_t>(Detector<Det>::nLayers)> result{};
+  const auto widen = [&](LayerID layer, const LayerPairWindow& window) {
+    auto& entry = result[layer];
+    const auto phi = static_cast<double>(window.phiHalfWidth);
+    const auto second = static_cast<double>(window.secondHalfWidth);
+    entry.narrowPhiHalfWidth = entry.queried ? std::min(entry.narrowPhiHalfWidth, phi) : phi;
+    entry.narrowSecondHalfWidth = entry.queried ? std::min(entry.narrowSecondHalfWidth, second) : second;
+    entry.phiHalfWidth = std::max(entry.phiHalfWidth, phi);
+    entry.secondHalfWidth = std::max(entry.secondHalfWidth, second);
+    entry.queried = true;
+  };
+  constexpr auto kLayers = static_cast<std::size_t>(Detector<Det>::nLayers);
+  // A link's window once per distinct window setting: the iterations with
+  // equal settings share it, as do an iteration's tracklet and follow sizing.
+  std::vector<std::pair<SearchWindowParams, std::array<std::optional<LayerPairWindow>, nLinks<Det>>>> derived;
+  const auto windowOf = [&](const SearchWindowParams& params, std::size_t link) {
+    auto entry = std::ranges::find_if(derived, [&](const auto& candidate) { return candidate.first == params; });
+    if (entry == derived.end()) {
+      derived.emplace_back(params, std::array<std::optional<LayerPairWindow>, nLinks<Det>>{});
+      entry = std::prev(derived.end());
+    }
+    auto& window = entry->second[link];
+    if (!window.has_value()) {
+      const auto& pair = Det::layerLinks[link];
+      window = layerPairWindow<Det>(pair.from, pair.to, params, beamSpot);
+    }
+    return *window;
+  };
+  for (const auto& settings : iterations) {
+    // A displaced iteration's windows hold what its pair test admits, up to
+    // half a turn and a target's whole length: sized by them the cells would be the prompt iterations' loss. Its
+    // queries visit more cells instead; the cells never decide a pair.
+    if (settings.windows.impactMax > 0.) {
+      continue;
+    }
+    const auto taken = takenLinks<Det>(settings);
+    const auto sizing = [&](std::size_t link) {
+      const auto& pair = Det::layerLinks[link];
+      return taken[link] && Detector<Det>::isBarrelLayer(pair.from) == Detector<Det>::isBarrelLayer(pair.to);
+    };
+    // Without skips, a link whose pairs can cross another layer is queried
+    // only from the sources whose pairs can avoid it, at that layer's ends
+    // (LinkHoles.h): it sizes a layer only where no link without holes
+    // queries it into the target.
+    std::array<bool, nLinks<Det>> edgeOnly{};
+    std::array<bool, kLayers> holeFreeInto{};
+    for (std::size_t link = 0; link < nLinks<Det>; ++link) {
+      const auto& pair = Det::layerLinks[link];
+      edgeOnly[link] = !settings.skipLinks && linkHoleLayers<Det>(pair.from, pair.to) != 0U;
+      if (sizing(link) && !edgeOnly[link]) {
+        holeFreeInto[pair.to] = true;
+      }
+    }
+    for (std::size_t link = 0; link < nLinks<Det>; ++link) {
+      if (!sizing(link)) {
+        continue;
+      }
+      const auto& pair = Det::layerLinks[link];
+      const auto window = windowOf(settings.windows, link);
+      if (!(edgeOnly[link] && holeFreeInto[pair.to])) {
+        widen(pair.to, window);
+      }
+    }
+    // The follow searches both layers of every link of the layout, from
+    // either end; its window is its prediction's, the pair window its size.
+    if (settings.follow || settings.followEnd) {
+      for (std::size_t link = 0; link < nLinks<Det>; ++link) {
+        const auto& pair = Det::layerLinks[link];
+        if (Detector<Det>::isBarrelLayer(pair.from) != Detector<Det>::isBarrelLayer(pair.to)) {
+          continue;
+        }
+        const auto window = windowOf(settings.windows, link);
+        widen(pair.from, window);
+        widen(pair.to, window);
+      }
+    }
+  }
+  return result;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_GRIDSIZING_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Iteration.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Iteration.h
new file mode 100644
index 0000000000000..e2d8d711b4f5f
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Iteration.h
@@ -0,0 +1,594 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Iteration.h
+/// \brief What one tracking iteration is configured with, and everything its
+///        kernels read that follows from it.
+///
+/// Iterations run one after another over the same timeframe, each with looser
+/// cuts over what the previous ones left unclaimed. Three lifetimes are kept
+/// apart (settings, parameters, timeframe context):
+///
+///  - `IterationSettings`, what a person configures, per run;
+///  - `IterationParameters<Det>`, what follows from the settings, the geometry
+///    and the material, built once at initialisation for every iteration;
+///  - the timeframe context -- measurements, vertex seeds, used mask -- which
+///    is not here.
+///
+/// Nothing in `IterationParameters` depends on the timeframe, so a device
+/// backend uploads the whole array once. It holds C arrays rather than
+/// pointers for the same reason.
+
+#ifndef GTRK_TRACKING_ITERATION_H_
+#define GTRK_TRACKING_ITERATION_H_
+
+#include "GenericTracking/Base/LayerLinks.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/LinkHoles.h"
+#include "GenericTracking/Tracking/MathUtils.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/SearchWindow.h"
+
+#include "GPUCommonMath.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <numbers>
+#include <span>
+#include <stdexcept>
+
+namespace o2::gtrk
+{
+
+/// What a person configures for one iteration. Host-side.
+struct IterationSettings {
+  /// The window physics. The minimum pT, nSigma and a displaced iteration's
+  /// bounds are what an iteration sets; the field, the mass, the uniform
+  /// material that sizes the grid (`materialX2X0`) and the resolution are the
+  /// run's.
+  SearchWindowParams windows;
+  VertexSource vertexSource = VertexSource::kBeamLine;
+  /// The shortest road this iteration fits, in clusters: at least 4 for a
+  /// road, two triplets (`minRoadStartLevel`);
+  /// 3 for a pass that stops at triplets, the vertexing pass. It also names
+  /// the links the iteration takes: only those on a path of this many layers
+  /// (`takenLinks`).
+  int minClusters = 4;
+  /// The kinks a fit pass may take; 0 for none.
+  int maxKinks = 1;
+  /// The triplet and neighbour cuts' kink allowance: the factor on theta0 at pT_min a triplet's middle
+  /// point may have scattered by, beyond the nominal cuts, to be kept as a
+  /// kinked triplet; 1 for none.
+  double kinkSigma = 1.;
+  /// The graph's own kink allowance, the triplet and neighbour cuts' alone:
+  /// above 0 it replaces `kinkSigma`
+  /// there, which then sets only the road fit's and the follow's; 0, the
+  /// default, `kinkSigma` everywhere.
+  double graphKinkSigma = 0.;
+  /// Whether this iteration makes tracklets that leave a hole: whose
+  /// segment crosses another layer's envelope (LinkHoles.h). Off, it takes
+  /// no link that skips a layer (`LayerLink::skipsLayer`) and on the others no pair
+  /// that crosses one, so a track beyond a shorter layer's end is still made.
+  bool skipLinks = true;
+  /// The layers this iteration's links join, a bit per layer; 0 for every
+  /// layer. A link is taken only when both its layers are in the mask: the
+  /// vertexing pass takes the three innermost.
+  std::uint64_t layerMask = 0U;
+  /// The layers a road may end on, a bit per layer; 0 for any. With a mask a
+  /// road starts at every triplet ending on one of them, so a road's prefix
+  /// is a road of its own when it ends there (O2's ITS `StartLayerMask`, whose
+  /// roads grow inward from their outermost cell); without one only at the
+  /// triplets nothing extends.
+  std::uint64_t roadEndLayers = 0U;
+  /// The layers a road may start on, its innermost measurement's, a bit per
+  /// layer; 0 for any. The roads counted are the
+  /// same chains; one whose innermost measurement lies on another layer is
+  /// none, as one starting outside the slice's core.
+  std::uint64_t roadStartLayers = 0U;
+  /// The lowest pT a track of each cluster count may have [GeV], by the
+  /// count; 0 for none. O2's ITS `TrackingParameters::MinPt`, by track
+  /// length. The final track's: where the iteration
+  /// follows, after the follow, on the track's count then; else on the road.
+  static constexpr std::size_t kClusterSlots = 16U;
+  std::array<double, kClusterSlots> minPtGeVByClusters{};
+  /// How many of a track's innermost clusters this iteration's selection and
+  /// follow let it share; 0, strict: the
+  /// follow does not go inward otherwise.
+  std::uint32_t sharedInnermost = 0U;
+  /// Whether this iteration follows its tracks after their refit, outward
+  /// and then inward, as a CKF does (`FollowStage`):
+  /// the layers every link of the layout reaches, in the order the track
+  /// crosses them, the first with a row within the gate taken; a layer
+  /// without one is a hole where the track crosses one of its sensors.
+  bool follow = true;
+  /// The holes a followed track may cross in each direction; past them the
+  /// direction ends.
+  int followHoles = 0;
+  /// Whether the road's outermost row is decided again by the follow:
+  /// the road fitted without it, the follow's
+  /// first row takes its place where it is another; where the follow takes
+  /// none, the end stays. Without `follow`, the end alone.
+  bool followEnd = false;
+  /// The innermost clusters a road the road fit refuses may be fitted again
+  /// without, one more each time, down to `minClusters`; 0 for none.
+  int innerTrim = 0;
+  /// Which of a barrel plane's two crossings the follow's refit takes
+  /// (`CrossingRule`).
+  CrossingRule crossingRule = CrossingRule::kFirstAhead;
+  /// Whether the follow's refit keeps the longest accepted prefix of the
+  /// rows it would refuse (`follow::Refit`'s Prefix).
+  bool followPrefix = false;
+  /// Whether the follow takes the smallest chi2 where more than one row
+  /// passes a step, instead of the lookahead's confirmed row (`FollowStage`'s Greedy).
+  bool followGreedy = false;
+  /// The unconfirmed drop's chi2 below which a direction's unconfirmed last row stays:
+  /// the unconfirmed drop removes it only at or
+  /// above; 0, the default, none stays.
+  double followKeepChi2 = 0.;
+  /// The end decisions on the last row's own update (`FollowStage`'s
+  /// EndDensity), each 0, the
+  /// default, off: inward, the sqrt|V| [cm^2] above which a nominal last row
+  /// at the layout's end -- no inward link -- is refused; outward, the
+  /// Gaussian density g [cm^-2] above which the unconfirmed drop keeps a nominal last row.
+  double followEndMaxSqrtDet = 0.;
+  double followKeepDensity = 0.;
+  /// Whether the inward walk's last row, where a nominal step took it, is
+  /// refused above the gate against that step's prediction updated with the
+  /// beam line (`FollowStage`'s BeamEnd); requires the follow and the beam constraint. False, the
+  /// default, off.
+  bool followBeamEnd = false;
+  /// The Delta chi2 below which the follow trims a track's last outward row
+  /// where it is one of two rows or more passing the gate: the other's
+  /// chi2 less its own (`follow::TrimAmbiguous`); 0, the default, off.
+  double followTrimMargin = 0.;
+  /// The clusters a track of this iteration must hold after its follow; 0
+  /// for none. A shorter one is
+  /// dropped and its rows given back.
+  int minClustersAfterFollow = 0;
+  /// Whether each road is updated with the beam line on its innermost surface
+  /// and refused above the update's gate;
+  /// the constrained state starts the follow inward, and the refits leave
+  /// the beam line out.
+  bool beamConstraint = false;
+  /// Whether every earlier iteration's track is followed again with this
+  /// iteration's settings, before this iteration makes its seeds, the rows
+  /// it takes its own;
+  /// requires the follow. A length after the follow applies to this
+  /// iteration's own tracks only.
+  bool followEarlier = false;
+  /// Whether this iteration takes the previous one's graph instead of
+  /// building its own (one graph for both rounds):
+  /// the previous iteration's slices build the graph once with this
+  /// iteration's kink allowance; the roads of nominal triplets the nominal
+  /// fit accepts are the previous iteration's, every other road is fitted
+  /// with this iteration's settings and is this iteration's. Requires the
+  /// previous iteration's graph settings (the windows, the vertex source,
+  /// minClusters, skipLinks, layerMask, roadEndLayers, roadStartLayers and the pT floors by
+  /// cluster count), and no kink allowance there and one here.
+  bool sharedGraph = false;
+  /// Whether the iteration tests its pairs and triplets against their
+  /// measurements' cluster shapes: each measurement's slope interval
+  /// (`MeasurementT::slopeLow`, `slopeHigh`) must hold the candidate's local
+  /// slope there (ShapeCut.h).
+  /// False, the default, off.
+  bool shapeTest = false;
+
+  [[nodiscard]] bool operator==(const IterationSettings&) const = default;
+};
+
+/// One link's geometry as the triplet stage bounds it:
+/// the shortest 3D distance between measurements on its two layers, and the
+/// longest transverse chord a tracklet on it can have.
+struct TripletLinkBounds {
+  Scalar lengthMin = 0.F; ///< [cm], rounded down
+  Scalar chordMax = 0.F;  ///< [cm], rounded up
+};
+
+/// The bounds of the link \a from -> \a to, whose tracklets lie within
+/// \a phiHalfWidth of their source's azimuth.
+///
+/// Two points at radii `r_1`, `r_2` and heights `z_1`, `z_2` are at least
+/// `hypot(r_2 - r_1, z_2 - z_1)` apart, so the gaps between the layers' radial
+/// and z extents bound the length from below. Their transverse chord is
+/// `d^2 = (r_2 - r_1)^2 + 2 r_1 r_2 (1 - cos(dphi))`, bounded above by the
+/// largest radial difference and the window's azimuth.
+template <DetectorLayout Det>
+[[nodiscard]] inline TripletLinkBounds tripletLinkBounds(LayerID from, LayerID to, double phiHalfWidth)
+{
+  const double fromLow = radiusMin<Det>(from);
+  const double fromHigh = radiusMax<Det>(from);
+  const double toLow = radiusMin<Det>(to);
+  const double toHigh = radiusMax<Det>(to);
+  const double gapR = std::max({toLow - fromHigh, fromLow - toHigh, 0.});
+  const double gapZ = std::max({zMin<Det>(to) - zMax<Det>(from), zMin<Det>(from) - zMax<Det>(to), 0.});
+  const double lengthMin = std::hypot(gapR, gapZ);
+  auto narrowedLength = static_cast<Scalar>(lengthMin);
+  if (static_cast<double>(narrowedLength) > lengthMin) {
+    narrowedLength = std::nextafter(narrowedLength, 0.F);
+  }
+  const double radialMax = std::max(std::abs(toHigh - fromLow), std::abs(fromHigh - toLow));
+  // Half a turn at most: a prompt window stays within a quarter, a displaced
+  // one may not.
+  const double azimuth = std::min(phiHalfWidth, std::numbers::pi_v<double>);
+  const double chordMax = std::sqrt((radialMax * radialMax) + (2. * fromHigh * toHigh * (1. - std::cos(azimuth))));
+  return {.lengthMin = narrowedLength, .chordMax = conservativeScalarBound(chordMax)};
+}
+
+/// Everything one iteration's kernels read.
+template <DetectorLayout Det>
+// NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding): the fields follow the configuration; their order is the designated initialisers'
+struct IterationParameters {
+  static constexpr std::size_t kLinkCount = nLinks<Det>;
+  static constexpr std::size_t kLayerCount = static_cast<std::size_t>(Detector<Det>::nLayers);
+  static_assert(kLinkCount <= std::size_t{std::numeric_limits<std::uint16_t>::max()} + 1U);
+
+  PairCut pairCut;
+  VertexSource vertexSource = VertexSource::kBeamLine;
+  ScatteringTable<Det> scattering;
+  /// One per entry of `Det::layerLinks`, in its order. They choose the grid
+  /// cells a source's query visits and are derived about the beam spot; the
+  /// exact pair cut is then evaluated against each vertex seed.
+  LayerPairWindow windows[kLinkCount]{};
+  /// Float copies of the host geometry's source intervals, narrowed once when
+  /// the parameters cross into tracking code.
+  Scalar sourceMin[kLinkCount]{};
+  Scalar sourceMax[kLinkCount]{};
+  TripletLinkBounds tripletBounds[kLinkCount]{};
+  /// Whether a passive scatterer can lie between the link's layers: the pair
+  /// test then takes `betweenScattering`.
+  bool passiveBetween[kLinkCount]{};
+  /// The largest `betweenScattering` a pair on the link can take: the link's
+  /// `betweenKinkBound` squared, rounded up; 0 without a passive between. The
+  /// tracklet stage tests a pair at it first and computes the pair's own term
+  /// only for the pairs it keeps: the test only widens with the term, so the
+  /// same pairs pass.
+  Scalar betweenBound[kLinkCount]{};
+  /// Device-facing copy of the detector's link topology. Runtime indexing of
+  /// the detector's constexpr host tables is not valid in device code.
+  std::uint32_t outLinkOffsets[kLayerCount + 1U]{};
+  std::uint16_t outLinkIndices[kLinkCount]{};
+  std::uint32_t inLinkOffsets[kLayerCount + 1U]{};
+  std::uint16_t inLinkIndices[kLinkCount]{};
+  LayerID linkSources[kLinkCount]{};
+  LayerID linkTargets[kLinkCount]{};
+  /// Per link, the layers a pair on it can cross (`linkHoleLayers`): in an
+  /// iteration that takes no skips a tracklet crossing one is not made;
+  /// 0 in one that takes them.
+  std::uint64_t holeLayers[kLinkCount]{};
+  /// The passives a pair on the link can cross, a bit each (`passivesBetween`):
+  /// the ones `betweenScattering` tries.
+  std::uint64_t betweenPassives[kLinkCount]{};
+  /// The barrel layers, a bit per layer, and every layer's span, for that test.
+  std::uint64_t barrelLayers = 0U;
+  LayerSpan layerSpans[kLayerCount]{};
+  /// The beam spot's z and its n-sigma reach [cm]: the range the tracking is
+  /// to be efficient in, and the only one a vertex-list iteration uses.
+  Scalar vertexZCentre = 0.F;
+  Scalar vertexZReach = 0.F;
+  /// A displaced iteration's impact bound and its closest approach's z bound
+  /// about `vertexZCentre` [cm] (`SearchWindowParams::impactMax`); 0 for a prompt one.
+  Scalar impactMax = 0.F;
+  Scalar impactZMax = 0.F;
+  /// The adjacent-triplet fit's chi2 bound: three degrees of freedom at the
+  /// confidence of `nSigma`, from `chiSquareQuantile`.
+  Scalar neighbourChi2Max = 0.F;
+  /// A proposed cluster's update chi2 bound, two coordinates.
+  Scalar clusterChi2Max = 0.F;
+  /// The road fit's chi2 bound by degrees of freedom: `2 N - 5` for `N`
+  /// clusters, two fewer per kink, at the confidence of `nSigma`
+  /// (`roadChi2Cut`); a box gives the time none.
+  Scalar roadChi2MaxByNdf[(2 * maxChainLayers<Det>)-4]{};
+  /// The kinks a fit pass may take.
+  std::uint8_t maxKinks = 0U;
+  /// `IterationSettings::followEnd`, `innerTrim`
+  /// and `crossingRule`.
+  bool followEnd = false;
+  std::uint8_t innerTrim = 0U;
+  CrossingRule crossingRule = CrossingRule::kFirstAhead;
+  /// The update chi2 beyond which a step is a kink: two degrees of freedom at
+  /// `nSigma`.
+  Scalar kinkChi2Min = 0.F;
+  /// The kink allowance's square, the factor on the middle layer's scattering
+  /// variance a kinked triplet is tested with; 1 for none (`IterationSettings`).
+  Scalar kinkScale2 = 1.F;
+  /// The triplet and neighbour cuts' kink allowance's square
+  /// (`IterationSettings::graphKinkSigma`); `kinkScale2` without one of its own.
+  Scalar graphKinkScale2 = 1.F;
+  /// The lowest level a road can start at: a road from level `L` has `L + 2`
+  /// clusters, so `minClusters - 2`, and at least 2.
+  std::uint32_t minRoadStartLevel = 2U;
+  /// `IterationSettings::minClusters`: the clusters a chain must reach to be
+  /// used, a road's or the vertexing pass's triplet's. The stages drop the
+  /// tracklets and triplets on no path that long (TrackletPaths.h).
+  std::uint32_t minClusters = 4U;
+  /// The layers a road may end on; 0 for any (`IterationSettings`).
+  std::uint64_t roadEndLayers = 0U;
+  /// The layers a road may start on; 0 for any (`IterationSettings`).
+  std::uint64_t roadStartLayers = 0U;
+  /// The lowest pT of a track by its cluster count [GeV]; 0 for none
+  /// (`IterationSettings::minPtGeVByClusters`).
+  Scalar minPtByClusters[maxChainLayers<Det> + 1U]{};
+  /// `IterationSettings`' shareable innermost clusters and follow switch.
+  std::uint32_t sharedInnermost = 0U;
+  bool follow = true;
+  /// `IterationSettings::sharedGraph`.
+  bool sharedGraph = false;
+  /// `IterationSettings::beamConstraint`,
+  /// with its terms below.
+  bool beamConstraint = false;
+  /// `IterationSettings::followEarlier`.
+  bool followEarlier = false;
+  /// `IterationSettings::followPrefix` and `followGreedy`.
+  bool followPrefix = false;
+  bool followGreedy = false;
+  /// `IterationSettings::followKeepChi2`.
+  Scalar followKeepChi2 = 0.F;
+  /// The resolution term of the follow's window, `positionSigma` squared,
+  /// as the pair windows take it [cm^2].
+  Scalar followPositionVariance = 0.F;
+  /// `IterationSettings::minClustersAfterFollow`; 0 for none.
+  std::uint32_t minClustersAfterFollow = 0U;
+  /// The beam-line update's terms (`beamConstraint`): the beam line's
+  /// position in the fit's frame [cm] and its transverse width squared
+  /// [cm^2], and the update's gate, `chiSquareQuantile(1, nSigma)`.
+  Scalar beamX = 0.F;
+  Scalar beamY = 0.F;
+  Scalar beamVarTransverse = 0.F;
+  Scalar beamChi2Max = 0.F;
+  /// `IterationSettings::followHoles`, and the layout's every link out of
+  /// each layer and into it, which the follow walks outward and inward.
+  std::uint32_t followHoles = 0U;
+  std::uint32_t allOutLinkOffsets[kLayerCount + 1U]{};
+  std::uint16_t allOutLinkIndices[kLinkCount]{};
+  std::uint32_t allInLinkOffsets[kLayerCount + 1U]{};
+  std::uint16_t allInLinkIndices[kLinkCount]{};
+  /// `IterationSettings::followEndMaxSqrtDet` and `followKeepDensity`.
+  Scalar followEndMaxSqrtDet = 0.F;
+  Scalar followKeepDensity = 0.F;
+  /// `IterationSettings::followTrimMargin`.
+  Scalar followTrimMargin = 0.F;
+  /// `IterationSettings::followBeamEnd`, set only with the follow and the beam
+  /// constraint; read on the host only to choose the follow's instantiation
+  /// (`FollowStage`'s BeamEnd).
+  bool followBeamEnd = false;
+  /// `IterationSettings::shapeTest`, read on the host only to choose the
+  /// tracklet and triplet stages' instantiations.
+  bool shapeTest = false;
+};
+
+/// Whether an iteration uses \a vertex for a source with time box \a source:
+/// compatible in time, and -- from a vertex list -- lying
+/// with its own n sigma inside the beam spot's reach. Every window the query
+/// can take is derived over that reach, so the tracklets do not depend on
+/// which window a source takes; a vertex beyond it is outside the range the
+/// tracking is to be efficient in.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool vertexUsable(const IterationParameters<Det>& parameters, const TimeEstPS& source, const VertexSeed& vertex)
+{
+  if (parameters.vertexSource == VertexSource::kVertexList && o2::gpu::CAMath::Abs(vertex.z - parameters.vertexZCentre) + (parameters.pairCut.nSigma * o2::gpu::CAMath::Sqrt(vertex.varZ)) > parameters.vertexZReach) {
+    return false;
+  }
+  return vertexTimeCompatible(source, TimeEstPS{.start = vertex.timePS, .width = vertex.widthPS});
+}
+
+/// Per-link host bounds for the intervals centred on individual vertices.
+/// They depend on one timeframe's vertex list and are kept separate from the
+/// iteration parameters uploaded once per run.
+template <DetectorLayout Det>
+struct VertexWindowParameters {
+  static constexpr std::size_t kLinkCount = nLinks<Det>;
+  VertexPairWindow windows[kLinkCount]{};
+};
+
+/// The bounds for one timeframe's vertex list, over the reach `vertexUsable`
+/// admits and with the pair cut's scattering table. \a settings are the ones
+/// \a parameters were derived from.
+template <DetectorLayout Det>
+[[nodiscard]] inline VertexWindowParameters<Det> vertexWindowParameters(const IterationParameters<Det>& parameters, const SearchWindowParams& settings, std::span<const VertexSeed> vertices)
+{
+  double maxSigmaZ = 0.;
+  double maxSigmaTransverse = 0.;
+  for (const auto& vertex : vertices) {
+    maxSigmaZ = std::max(maxSigmaZ, std::sqrt(static_cast<double>(vertex.varZ)));
+    maxSigmaTransverse = std::max(maxSigmaTransverse, std::sqrt(static_cast<double>(vertex.varTransverse)));
+  }
+  const auto centre = static_cast<double>(parameters.vertexZCentre);
+  const auto reach = static_cast<double>(parameters.vertexZReach);
+  const Interval vertexZ{.low = centre - reach, .high = centre + reach};
+  const VertexConstraint envelope{.z = centre, .sigmaZ = settings.nSigma > 0. ? reach / settings.nSigma : 0., .sigmaTransverse = maxSigmaTransverse};
+
+  VertexWindowParameters<Det> result;
+  for (std::size_t link = 0; link < VertexWindowParameters<Det>::kLinkCount; ++link) {
+    const auto& pair = Det::layerLinks[link];
+    const double kink = sourceKinkBound<Det>(parameters.scattering, settings, pair.from, envelope);
+    const double between = betweenKinkBound<Det>(parameters.scattering, settings, pair.from, pair.to, envelope);
+    result.windows[link] = vertexPairWindow<Det>(pair.from, pair.to, settings, vertexZ, maxSigmaZ, kink, between);
+  }
+  return result;
+}
+
+/// The links an iteration with \a settings takes: those its skip rule and
+/// its mask allow, and of them only the ones on a path of `minClusters`
+/// layers or more through the allowed links. No road through any other link
+/// reaches `minClusters`, so no tracklet, triplet or neighbour is made on it.
+/// The one predicate for the stages' link lists and for the grid's
+/// sizing (GridSizing.h), so that the two cannot disagree.
+template <DetectorLayout Det>
+[[nodiscard]] inline std::array<bool, nLinks<Det>> takenLinks(const IterationSettings& settings)
+{
+  const auto inMask = [&](LayerID layer) { return settings.layerMask == 0U || ((settings.layerMask >> layer) & 1U) != 0U; };
+  std::array<bool, nLinks<Det>> allowed{};
+  for (std::size_t link = 0; link < nLinks<Det>; ++link) {
+    const auto& pair = Det::layerLinks[link];
+    allowed[link] = (settings.skipLinks || !pair.skipsLayer) && inMask(pair.from) && inMask(pair.to);
+  }
+  // The most layers a path of allowed links visits ending at each layer, and
+  // leaving it, the layer itself counted in both.
+  constexpr auto kLayers = static_cast<std::size_t>(Detector<Det>::nLayers);
+  std::array<int, kLayers> ending{};
+  std::array<int, kLayers> leaving{};
+  ending.fill(1);
+  leaving.fill(1);
+  for (const auto layer : layerOrder<Det>) {
+    for (auto i = outLinks<Det>.begin(layer); i < outLinks<Det>.end(layer); ++i) {
+      const auto link = outLinks<Det>.links[i];
+      if (allowed[link]) {
+        auto& to = ending[Det::layerLinks[link].to];
+        to = std::max(to, ending[layer] + 1);
+      }
+    }
+  }
+  for (auto order = kLayers; order-- > 0;) {
+    const auto layer = layerOrder<Det>[order];
+    for (auto i = outLinks<Det>.begin(layer); i < outLinks<Det>.end(layer); ++i) {
+      const auto link = outLinks<Det>.links[i];
+      if (allowed[link]) {
+        leaving[layer] = std::max(leaving[layer], leaving[Det::layerLinks[link].to] + 1);
+      }
+    }
+  }
+  std::array<bool, nLinks<Det>> taken{};
+  for (std::size_t link = 0; link < nLinks<Det>; ++link) {
+    const auto& pair = Det::layerLinks[link];
+    taken[link] = allowed[link] && ending[pair.from] + leaving[pair.to] >= settings.minClusters;
+  }
+  return taken;
+}
+
+/// Derive one iteration's parameters. \a scattering is built once per run
+/// from the per-layer material and is the same for every iteration. \a alike,
+/// where given, is an earlier iteration's parameters from the same beam spot
+/// and table with equal `settings.windows`: the links' windows and bounds
+/// depend on those alone and are taken from it instead of derived again.
+template <DetectorLayout Det>
+[[nodiscard]] inline IterationParameters<Det> iterationParameters(const IterationSettings& settings, const VertexConstraint& beamSpot, const ScatteringTable<Det>& scattering, const IterationParameters<Det>* alike = nullptr)
+{
+  if (settings.windows.impactMax > 0. && (settings.vertexSource != VertexSource::kBeamLine || !(settings.windows.impactZMax > 0.))) {
+    throw std::invalid_argument("a displaced iteration (impactMax > 0) needs the beam line as its vertex and a z bound (impactZMax > 0)");
+  }
+  IterationParameters<Det> parameters;
+  parameters.pairCut = pairCut(settings.windows);
+  parameters.vertexSource = settings.vertexSource;
+  parameters.scattering = scattering;
+  // The link lists the stages walk, without the links this iteration does
+  // not take: no tracklet is made on them, and no triplet crosses them.
+  const auto keep = [&](const std::array<bool, nLinks<Det>>& taken, const LinksByLayer<Det>& all, std::uint32_t* offsets, std::uint16_t* indices) {
+    std::uint32_t kept = 0U;
+    for (std::size_t layer = 0; layer < IterationParameters<Det>::kLayerCount; ++layer) {
+      offsets[layer] = kept;
+      for (auto i = all.begin(static_cast<LayerID>(layer)); i < all.end(static_cast<LayerID>(layer)); ++i) {
+        if (taken[all.links[i]]) {
+          indices[kept++] = static_cast<std::uint16_t>(all.links[i]);
+        }
+      }
+    }
+    offsets[IterationParameters<Det>::kLayerCount] = kept;
+  };
+  const auto taken = takenLinks<Det>(settings);
+  keep(taken, outLinks<Det>, parameters.outLinkOffsets, parameters.outLinkIndices);
+  keep(taken, inLinks<Det>, parameters.inLinkOffsets, parameters.inLinkIndices);
+  // The follow walks every link of the layout, with the window of its own
+  // prediction.
+  parameters.follow = settings.follow;
+  parameters.followEarlier = settings.follow && settings.followEarlier;
+  parameters.followPrefix = settings.follow && settings.followPrefix;
+  parameters.followGreedy = settings.follow && settings.followGreedy;
+  parameters.followKeepChi2 = static_cast<Scalar>(std::max(settings.followKeepChi2, 0.));
+  parameters.followEndMaxSqrtDet = static_cast<Scalar>(std::max(settings.followEndMaxSqrtDet, 0.));
+  parameters.followKeepDensity = static_cast<Scalar>(std::max(settings.followKeepDensity, 0.));
+  parameters.followTrimMargin = settings.follow ? static_cast<Scalar>(std::max(settings.followTrimMargin, 0.)) : 0.F;
+  parameters.followBeamEnd = settings.follow && settings.beamConstraint && settings.followBeamEnd;
+  parameters.shapeTest = settings.shapeTest;
+  parameters.followHoles = static_cast<std::uint32_t>(std::max(settings.followHoles, 0));
+  parameters.followEnd = settings.followEnd;
+  if (settings.follow || settings.followEnd) {
+    std::array<bool, nLinks<Det>> every{};
+    every.fill(true);
+    keep(every, outLinks<Det>, parameters.allOutLinkOffsets, parameters.allOutLinkIndices);
+    keep(every, inLinks<Det>, parameters.allInLinkOffsets, parameters.allInLinkIndices);
+    parameters.followPositionVariance = static_cast<Scalar>(settings.windows.positionSigma * settings.windows.positionSigma);
+  }
+  parameters.minClustersAfterFollow = static_cast<std::uint32_t>(std::max(settings.minClustersAfterFollow, 0));
+  for (std::size_t layer = 0; layer < IterationParameters<Det>::kLayerCount; ++layer) {
+    const auto id = static_cast<LayerID>(layer);
+    parameters.layerSpans[layer] = layerSpan<Det>(id);
+  }
+  parameters.barrelLayers = barrelLayerBits<Det>();
+  // A displaced iteration's tracks need not come from the beam spot the
+  // links' intervals were traced from: the whole layer.
+  const bool displaced = settings.windows.impactMax > 0.;
+  for (std::size_t link = 0; link < IterationParameters<Det>::kLinkCount; ++link) {
+    const auto& pair = Det::layerLinks[link];
+    parameters.linkSources[link] = pair.from;
+    parameters.linkTargets[link] = pair.to;
+    if (alike != nullptr) {
+      parameters.windows[link] = alike->windows[link];
+      parameters.passiveBetween[link] = alike->passiveBetween[link];
+      parameters.betweenBound[link] = alike->betweenBound[link];
+      parameters.tripletBounds[link] = alike->tripletBounds[link];
+    } else {
+      parameters.windows[link] = layerPairWindow<Det>(pair.from, pair.to, settings.windows, beamSpot, scattering);
+      const double between = betweenKinkBound<Det>(scattering, settings.windows, pair.from, pair.to, beamSpot);
+      parameters.passiveBetween[link] = between > 0.;
+      parameters.betweenBound[link] = conservativeScalarBound(between * between);
+      parameters.tripletBounds[link] = tripletLinkBounds<Det>(pair.from, pair.to, static_cast<double>(parameters.windows[link].phiHalfWidth));
+    }
+    parameters.betweenPassives[link] = passivesBetween<Det>(scattering, pair.from, pair.to);
+    parameters.holeLayers[link] = settings.skipLinks ? 0U : linkHoleLayers<Det>(pair.from, pair.to);
+    parameters.sourceMin[link] = displaced ? -std::numeric_limits<Scalar>::infinity() : static_cast<Scalar>(pair.sourceMin);
+    parameters.sourceMax[link] = displaced ? std::numeric_limits<Scalar>::infinity() : static_cast<Scalar>(pair.sourceMax);
+  }
+  parameters.vertexZCentre = static_cast<Scalar>(beamSpot.z);
+  parameters.vertexZReach = static_cast<Scalar>(settings.windows.nSigma * beamSpot.sigmaZ);
+  parameters.impactMax = static_cast<Scalar>(settings.windows.impactMax);
+  parameters.impactZMax = static_cast<Scalar>(settings.windows.impactZMax);
+  parameters.neighbourChi2Max = static_cast<Scalar>(chiSquareQuantile(3, settings.windows.nSigma));
+  parameters.clusterChi2Max = static_cast<Scalar>(chiSquareQuantile(2, settings.windows.nSigma));
+  parameters.beamConstraint = settings.beamConstraint;
+  parameters.sharedGraph = settings.sharedGraph;
+  parameters.beamX = static_cast<Scalar>(beamSpot.x);
+  parameters.beamY = static_cast<Scalar>(beamSpot.y);
+  parameters.beamVarTransverse = static_cast<Scalar>(beamSpot.sigmaTransverse * beamSpot.sigmaTransverse);
+  parameters.beamChi2Max = static_cast<Scalar>(chiSquareQuantile(1, settings.windows.nSigma));
+  for (int ndf = 1; ndf <= (2 * static_cast<int>(maxChainLayers<Det>)) - kNBoundParams; ++ndf) {
+    parameters.roadChi2MaxByNdf[ndf] = static_cast<Scalar>(chiSquareQuantile(ndf, settings.windows.nSigma));
+  }
+  parameters.maxKinks = static_cast<std::uint8_t>(std::max(settings.maxKinks, 0));
+  parameters.innerTrim = static_cast<std::uint8_t>(std::clamp(settings.innerTrim, 0, static_cast<int>(maxChainLayers<Det>)));
+  parameters.crossingRule = settings.crossingRule;
+  parameters.kinkChi2Min = static_cast<Scalar>(chiSquareQuantile(2, settings.windows.nSigma));
+  {
+    const double sigma = std::max(settings.kinkSigma, 1.);
+    parameters.kinkScale2 = static_cast<Scalar>(sigma * sigma);
+    const double graphSigma = settings.graphKinkSigma > 0. ? std::max(settings.graphKinkSigma, 1.) : sigma;
+    parameters.graphKinkScale2 = static_cast<Scalar>(graphSigma * graphSigma);
+  }
+  parameters.minRoadStartLevel = static_cast<std::uint32_t>(std::max(settings.minClusters, 4) - 2);
+  parameters.minClusters = static_cast<std::uint32_t>(std::max(settings.minClusters, 0));
+  parameters.roadEndLayers = settings.roadEndLayers;
+  parameters.roadStartLayers = settings.roadStartLayers;
+  constexpr std::size_t kCounts = std::min(maxChainLayers<Det> + 1U, IterationSettings::kClusterSlots);
+  for (std::size_t count = 0; count < kCounts; ++count) {
+    parameters.minPtByClusters[count] = static_cast<Scalar>(settings.minPtGeVByClusters[count]);
+  }
+  parameters.sharedInnermost = settings.sharedInnermost;
+  return parameters;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_ITERATION_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/LayerMaterial.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/LayerMaterial.h
new file mode 100644
index 0000000000000..9ddd9a9470967
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/LayerMaterial.h
@@ -0,0 +1,291 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file LayerMaterial.h
+/// \brief Each layer's average material budget, queried from the LUT once.
+///
+/// Host-side setup, once per run: the averages the pair cuts and search
+/// windows are set up from; the fit and the follow query the LUT itself
+/// (TrackFitter.h, Follow.h). A layer's budget is the
+/// average `x/X0` of segments crossing it at normal incidence, from half-way
+/// to the layer inside it to half-way to the layer outside, so that all
+/// material between layers is attributed to the nearer one -- except a
+/// passive scatterer's band, which is its own (`passiveMaterial`).
+
+#ifndef GTRK_TRACKING_LAYERMATERIAL_H_
+#define GTRK_TRACKING_LAYERMATERIAL_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/SearchWindow.h"
+
+#include "DetectorsBase/MatLayerCylSet.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <numbers>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+template <DetectorLayout Det>
+using LayerBudget = std::array<double, static_cast<std::size_t>(Detector<Det>::nLayers)>;
+
+/// The LUT's `x/X0` across a band [\a low, \a high], averaged over azimuth
+/// and over [\a axisMin, \a axisMax] of the other coordinate: radial segments
+/// at each z for a cylinder; for a disc at \a position, segments from \a low
+/// to \a high in z along the ray from the nominal vertex through each radius
+/// at \a position, scaled to normal incidence by the cosine of their angle to
+/// z. A segment parallel to z would do, but the LUT is a stack of cylindrical
+/// layers traced by radius, and a segment that never changes radius reads as
+/// empty.
+///
+/// On a cylinder the band is cut at the LUT's own layer boundaries, and each
+/// piece is read once per cell of its LUT layer -- at each azimuth cell's
+/// centre, and along z at each z cell's, weighted by how much of the cell the
+/// range covers -- so that this is the LUT's own average. A fixed grid is not:
+/// thin radial walls, as between the ALICE 3 VD's petals, are each averaged
+/// into one cell, and a grid with the walls' symmetry hits every such cell or
+/// none; a grid finer than a layer's cells weighs some of them twice.
+///
+/// A disc's average is the LUT's own as well, in closed form. A ray through
+/// radius rho at the disc is at r = rho t, t = z / position, and at normal
+/// incidence its x/X0 is the integral of the LUT's 1/X0 over z. At one t the
+/// rays of [axisMin, axisMax] cover [axisMin t, axisMax t], which overlaps a
+/// LUT layer [rMin, rMax] over a length linear in t between the points where
+/// the ends cross. In a cell the LUT is constant, its azimuths' mean taken,
+/// so the cell adds that mean times the integral of overlap(t) / t, a
+/// logarithm and a line: a fixed grid misreads the supports' sharp radial
+/// edges.
+[[nodiscard]] inline double sampledBudget(const o2::base::MatLayerCylSet& lut, bool barrel, double low, double high, double axisMin, double axisMax, double position)
+{
+  if (barrel) {
+    const double from = std::min(low, high);
+    const double to = std::max(low, high);
+    double total = 0.;
+    for (int i = 0; i < lut.getNLayers(); ++i) {
+      const auto& layer = lut.getLayer(i);
+      const double pieceLow = std::max(from, static_cast<double>(layer.getRMin()));
+      const double pieceHigh = std::min(to, static_cast<double>(layer.getRMax()));
+      if (!(pieceHigh > pieceLow)) {
+        continue;
+      }
+      // Along z: the layer's cells within [axisMin, axisMax], and what lies
+      // outside its extent as one piece each side, by length.
+      const auto zMin = static_cast<double>(layer.getZMin());
+      const auto zMax = static_cast<double>(layer.getZMax());
+      const auto dz = static_cast<double>(layer.getDZ());
+      std::vector<std::pair<double, double>> along;
+      for (double at = axisMin; at < axisMax;) {
+        double next = axisMax;
+        if (at < zMin) {
+          next = std::min(axisMax, zMin);
+        } else if (at < zMax) {
+          next = std::min(axisMax, zMin + (dz * (std::floor((at - zMin) / dz) + 1.)));
+        }
+        along.emplace_back(0.5 * (at + next), next - at);
+        at = next;
+      }
+      const int phiCells = layer.getNPhiBins();
+      double sum = 0.;
+      for (int iPhi = 0; iPhi < phiCells; ++iPhi) {
+        const double phi = (2 * std::numbers::pi_v<double>)*(static_cast<double>(iPhi) + 0.5) / phiCells;
+        const double c = std::cos(phi);
+        const double s = std::sin(phi);
+        for (const auto& [z, weight] : along) {
+          const auto segment = lut.getMatBudget(static_cast<float>(pieceLow * c), static_cast<float>(pieceLow * s), static_cast<float>(z), static_cast<float>(pieceHigh * c), static_cast<float>(pieceHigh * s), static_cast<float>(z));
+          sum += weight * static_cast<double>(segment.meanX2X0);
+        }
+      }
+      total += sum / (static_cast<double>(phiCells) * (axisMax - axisMin));
+    }
+    return total;
+  }
+  const double tA = low / position;
+  const double tB = high / position;
+  const double tFrom = std::min(tA, tB);
+  const double tTo = std::max(tA, tB);
+  double total = 0.;
+  for (int i = 0; i < lut.getNLayers(); ++i) {
+    const auto& layer = lut.getLayer(i);
+    const auto rMin = static_cast<double>(layer.getRMin());
+    const auto rMax = static_cast<double>(layer.getRMax());
+    // Where the ends of [axisMin t, axisMax t] cross the layer's radii.
+    std::vector<double> crossings{rMin / axisMax, rMax / axisMax};
+    if (axisMin > 0.) {
+      crossings.push_back(rMin / axisMin);
+      crossings.push_back(rMax / axisMin);
+    }
+    for (int iz = 0; iz < layer.getNZBins(); ++iz) {
+      const double zA = static_cast<double>(layer.getZBinMin(iz)) / position;
+      const double zB = static_cast<double>(layer.getZBinMax(iz)) / position;
+      const double from = std::max(tFrom, std::min(zA, zB));
+      const double to = std::min(tTo, std::max(zA, zB));
+      if (!(to > from) || axisMax * to <= rMin || axisMin * from >= rMax) {
+        continue;
+      }
+      std::vector<double> edges{from, to};
+      for (const double t : crossings) {
+        if (t > from && t < to) {
+          edges.push_back(t);
+        }
+      }
+      std::ranges::sort(edges);
+      double integral = 0.;
+      for (std::size_t k = 0; k + 1 < edges.size(); ++k) {
+        const double u = edges[k];
+        const double v = edges[k + 1];
+        const double mid = 0.5 * (u + v);
+        // overlap(t) = upper - lower = alpha + beta t on [u, v]
+        const bool upperIsLayer = rMax < axisMax * mid;
+        const bool lowerIsLayer = rMin > axisMin * mid;
+        const double alpha = (upperIsLayer ? rMax : 0.) - (lowerIsLayer ? rMin : 0.);
+        const double beta = (upperIsLayer ? 0. : axisMax) - (lowerIsLayer ? 0. : axisMin);
+        if (alpha + (beta * mid) <= 0.) {
+          continue;
+        }
+        integral += beta * (v - u);
+        if (!exactlyEqual(alpha, 0.)) {
+          integral += alpha * std::log(v / u);
+        }
+      }
+      if (!(integral > 0.)) {
+        continue;
+      }
+      double meanX2X0 = 0.;
+      for (int iPhi = 0; iPhi < layer.getNPhiBins(); ++iPhi) {
+        meanX2X0 += static_cast<double>(layer.getCellPhiBin(iPhi, iz).meanX2X0);
+      }
+      total += integral * meanX2X0 / layer.getNPhiBins();
+    }
+  }
+  return std::abs(position) * total / (axisMax - axisMin);
+}
+
+/// Each layer's average normal-incidence `x/X0` from the LUT.
+///
+/// Sampled as `sampledBudget` does, over the stave length or the disc's radii.
+/// A disc's neighbours are the discs of the same endcap; the innermost takes
+/// the same half-gap on both sides.
+template <DetectorLayout Det>
+[[nodiscard]] inline LayerBudget<Det> layerMaterial(const o2::base::MatLayerCylSet& lut)
+{
+  constexpr auto kLayers = static_cast<std::size_t>(Detector<Det>::nLayers);
+
+  LayerBudget<Det> budget{};
+  for (std::size_t layer = 0; layer < kLayers; ++layer) {
+    const auto id = static_cast<LayerID>(layer);
+    const bool barrel = Detector<Det>::isBarrelLayer(id);
+
+    // The half-gaps to the neighbours of the same kind and, for discs, side.
+    const auto neighbour = [&](int step) -> double {
+      const auto other = static_cast<int>(layer) + step;
+      if (other < 0 || std::cmp_greater_equal(other, kLayers)) {
+        return 0.;
+      }
+      const auto otherId = static_cast<LayerID>(other);
+      if (Detector<Det>::isBarrelLayer(otherId) != barrel) {
+        return 0.;
+      }
+      if (!barrel && discZ<Det>(otherId) * discZ<Det>(id) < 0.) {
+        return 0.;
+      }
+      return barrel ? layerDistance<Det>(otherId) : discZ<Det>(otherId);
+    };
+    const double here = barrel ? layerDistance<Det>(id) : discZ<Det>(id);
+    const double below = neighbour(-1);
+    const double above = neighbour(+1);
+    double low = !exactlyEqual(below, 0.) ? 0.5 * (below + here) : 0.;
+    double high = !exactlyEqual(above, 0.) ? 0.5 * (above + here) : 0.;
+    if (barrel) {
+      low = !exactlyEqual(below, 0.) ? low : 0.5 * here;
+      high = !exactlyEqual(above, 0.) ? high : here + (here - low);
+    } else {
+      // Discs are numbered by increasing z, so "below" is the smaller z.
+      if (exactlyEqual(below, 0.)) {
+        low = here - (high - here);
+      }
+      if (exactlyEqual(above, 0.)) {
+        high = here + (here - low);
+      }
+    }
+
+    // A passive scatterer's band is its own (PassiveSpec): the slab stops at
+    // it, so its material is counted once, at its own lever arm.
+    if constexpr (Detector<Det>::nPassives > 0) {
+      for (std::size_t i = 0; i < static_cast<std::size_t>(Detector<Det>::nPassives); ++i) {
+        const auto& passive = Detector<Det>::passive(i);
+        if ((passive.kind == PassiveSpec::Kind::kBarrel) != barrel) {
+          continue;
+        }
+        const double slabLow = std::min(low, high);
+        const double slabHigh = std::max(low, high);
+        if (passive.bandHigh <= here && passive.bandHigh > slabLow) {
+          low = passive.bandHigh;
+          high = slabHigh;
+        } else if (passive.bandLow >= here && passive.bandLow < slabHigh) {
+          low = slabLow;
+          high = passive.bandLow;
+        }
+      }
+      // The outermost barrel layer's open side mirrors its inner side as the
+      // passives left it: where its gap inward is a passive's, its slab is its
+      // own silicon, and does not reach material beyond the last layer.
+      if (barrel && exactlyEqual(above, 0.)) {
+        high = here + (here - low);
+      }
+    }
+    budget[layer] = sampledBudget(lut, barrel, low, high, secondMin<Det>(id), secondMax<Det>(id), here);
+  }
+  return budget;
+}
+
+template <DetectorLayout Det>
+using PassiveBudget = std::array<double, static_cast<std::size_t>(Detector<Det>::nPassives)>;
+
+/// Each passive scatterer's nominal `x/X0` (PassiveSpec::x2X0), for a run
+/// without a material LUT.
+template <DetectorLayout Det>
+[[nodiscard]] inline PassiveBudget<Det> nominalPassiveMaterial()
+{
+  PassiveBudget<Det> budget{};
+  if constexpr (Detector<Det>::nPassives > 0) {
+    for (std::size_t i = 0; i < budget.size(); ++i) {
+      budget[i] = Detector<Det>::passive(i).x2X0;
+    }
+  }
+  return budget;
+}
+
+/// Each passive scatterer's average normal-incidence `x/X0` from the LUT:
+/// segments across its band, sampled over
+/// azimuth and its extent -- radial for a cylinder; for a disc along the ray
+/// from the nominal vertex, scaled to normal incidence, as `layerMaterial`
+/// reads a disc layer.
+template <DetectorLayout Det>
+[[nodiscard]] inline PassiveBudget<Det> passiveMaterial(const o2::base::MatLayerCylSet& lut)
+{
+  PassiveBudget<Det> budget{};
+  if constexpr (Detector<Det>::nPassives > 0) {
+    for (std::size_t i = 0; i < budget.size(); ++i) {
+      const auto& passive = Detector<Det>::passive(i);
+      budget[i] = sampledBudget(lut, passive.kind == PassiveSpec::Kind::kBarrel, passive.bandLow, passive.bandHigh, passive.low, passive.high, passive.position);
+    }
+  }
+  return budget;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_LAYERMATERIAL_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/LayerRowMap.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/LayerRowMap.h
new file mode 100644
index 0000000000000..a853304e59cbd
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/LayerRowMap.h
@@ -0,0 +1,85 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file LayerRowMap.h
+/// \brief A dense numbering of the rows of chosen layers in a slice.
+///
+/// A stage that runs one element per measurement -- the tracklet stage, one
+/// per source -- sees a slice as one contiguous row range per layer
+/// (`TimeFrame<Det>::TimeSlice`), and presents only some layers. This numbers
+/// the presented rows `0 .. size()-1`, layer after layer in row order, which
+/// is the stage's element order and so its canonical output order. The
+/// mapping is arithmetic both ways: a row to its element through the layer's
+/// offset, an element to its layer by a binary search over the layer offsets.
+
+#ifndef GTRK_TRACKING_LAYERROWMAP_H_
+#define GTRK_TRACKING_LAYERROWMAP_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/MeasurementRange.h"
+
+#include "GPUCommonAlgorithm.h"
+#include "GPUCommonDef.h"
+
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <span>
+
+namespace o2::gtrk
+{
+
+template <DetectorLayout Det>
+struct LayerRowMap {
+  using Index = std::uint32_t;
+  static constexpr std::size_t kLayerCount = static_cast<std::size_t>(Detector<Det>::nLayers);
+
+  struct Row {
+    LayerID layer = kInvalidLayerID;
+    Index row = 0;
+  };
+
+  LayerRowMap() = default;
+
+  /// \a rows per layer; only the layers \a presented marks contribute.
+  LayerRowMap(std::span<const MeasurementRange, kLayerCount> rows, const std::array<bool, kLayerCount>& presented)
+  {
+    for (std::size_t layer = 0; layer < kLayerCount; ++layer) {
+      ranges[layer] = presented[layer] ? rows[layer] : MeasurementRange{rows[layer].begin, rows[layer].begin};
+      offsets[layer + 1U] = offsets[layer] + ranges[layer].size();
+    }
+  }
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Index size() const { return offsets[kLayerCount]; }
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool contains(LayerID layer, Index row) const { return static_cast<std::size_t>(layer) < kLayerCount && row >= ranges[layer].begin && row < ranges[layer].end; }
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Index element(LayerID layer, Index row) const
+  {
+    assert(contains(layer, row));
+    return offsets[layer] + (row - ranges[layer].begin);
+  }
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Row row(Index element) const
+  {
+    assert(element < size());
+    const std::size_t low = o2::gpu::CAAlgo::partitionPoint(std::size_t{1}, kLayerCount - 1U, [&](std::size_t layer) { return offsets[layer] <= element; }) - 1U;
+    return {.layer = static_cast<LayerID>(low), .row = ranges[low].begin + (element - offsets[low])};
+  }
+
+  std::array<MeasurementRange, kLayerCount> ranges{};
+  std::array<Index, kLayerCount + 1U> offsets{};
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_LAYERROWMAP_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/LinkHoles.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/LinkHoles.h
new file mode 100644
index 0000000000000..cf7759a214bec
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/LinkHoles.h
@@ -0,0 +1,228 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file LinkHoles.h
+/// \brief Whether a pair of measurements leaves a hole: the segment between
+///        them crosses another layer's envelope.
+///
+/// A link joins two layers some trajectory crosses in a row, and one link
+/// carries both kinds of pairs: ITS 0 -> 3 holds the steep tracks past the
+/// ends of layers 1 and 2, and the central ones that lost their hits there.
+/// Only the pair's own measurements tell which. The segment between them in
+/// the (r, z) plane stands for the helix: the transverse arc outgrows r by
+/// about r^3 / (24 R^2), below a millimetre over ITS 0 -> 5 at 0.1 GeV.
+///
+/// An iteration that takes no skips makes no tracklet that crosses a layer,
+/// and the findable counts a step of a particle's chain only when it crosses
+/// none: one test for both.
+
+#ifndef GTRK_TRACKING_LINKHOLES_H_
+#define GTRK_TRACKING_LINKHOLES_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/SearchWindow.h"
+
+#include "GPUCommonMath.h"
+
+#include <cstdint>
+#include <limits>
+
+namespace o2::gtrk
+{
+
+/// A layer's envelope as the hole test reads it: a barrel layer's radius and
+/// z range, or a disc's signed z and r range [cm]; and the range of the
+/// position its measurements take, radii on a barrel layer, z on a disc.
+struct LayerSpan {
+  Scalar position = 0.F;
+  Scalar low = 0.F;
+  Scalar high = 0.F;
+  Scalar positionMin = 0.F;
+  Scalar positionMax = 0.F;
+};
+
+/// Layer \a layer's span, from the extents the windows and the scattering
+/// table read (SearchWindow.h).
+template <DetectorLayout Det>
+[[nodiscard]] inline LayerSpan layerSpan(LayerID layer)
+{
+  const bool barrel = Detector<Det>::isBarrelLayer(layer);
+  return {
+    .position = static_cast<Scalar>(barrel ? layerDistance<Det>(layer) : discZ<Det>(layer)),
+    .low = static_cast<Scalar>(secondMin<Det>(layer)),
+    .high = static_cast<Scalar>(secondMax<Det>(layer)),
+    .positionMin = static_cast<Scalar>(barrel ? radiusMin<Det>(layer) : zMin<Det>(layer)),
+    .positionMax = static_cast<Scalar>(barrel ? radiusMax<Det>(layer) : zMax<Det>(layer)),
+  };
+}
+
+/// Whether the segment from (\a ra, \a za) to (\a rb, \a zb) crosses
+/// \a span, a barrel layer's when \a barrel, a disc's otherwise: it passes
+/// the layer's position strictly between its ends, inside its range there.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool segmentCrosses(bool barrel, const LayerSpan& span, Scalar ra, Scalar za, Scalar rb, Scalar zb)
+{
+  const Scalar a = barrel ? ra : za;
+  const Scalar b = barrel ? rb : zb;
+  const bool between = (a < span.position && span.position < b) || (b < span.position && span.position < a);
+  if (!between) {
+    return false;
+  }
+  const Scalar t = (span.position - a) / (b - a);
+  const Scalar along = barrel ? za + (t * (zb - za)) : ra + (t * (rb - ra));
+  return along >= span.low && along <= span.high;
+}
+
+/// Whether the segment crosses any layer of \a holes, a bit per layer, with
+/// \a barrels the barrel layers' bits and \a spans each layer's span.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool segmentLeavesHole(std::uint64_t holes, std::uint64_t barrels, const LayerSpan* spans, Scalar ra, Scalar za, Scalar rb, Scalar zb)
+{
+  for (; holes != 0U; holes &= holes - 1U) {
+    const std::uint32_t layer = o2::gpu::CAMath::Ctz64(holes);
+    if (segmentCrosses(((barrels >> layer) & 1U) != 0U, spans[layer], ra, za, rb, zb)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+namespace detail
+{
+
+/// A range of target second coordinates; empty if low > high.
+struct Shadow {
+  Scalar low;
+  Scalar high;
+};
+
+/// The target second coordinates a segment from \a a, in the target's frame
+/// (P its position axis, Q its second), to a target point at position \a w
+/// crosses \a span with: \a span's shadow seen from \a a, an interval,
+/// empty (low > high) when there is none. \a sameAxis: the span lies across
+/// P, as a barrel layer before a barrel target; otherwise across Q.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Shadow shadow(bool sameAxis, const LayerSpan& span, Scalar aP, Scalar aQ, Scalar w)
+{
+  constexpr Shadow kNone{.low = 1.F, .high = 0.F};
+  constexpr Scalar kInfinity = std::numeric_limits<Scalar>::infinity();
+  const Scalar toTarget = w - aP;
+  if (sameAxis) {
+    // The span at P = position over Q in [low, high], crossed when it lies
+    // strictly between the source and the target: projected from the source.
+    const Scalar toSpan = span.position - aP;
+    const bool between = (toSpan > 0.F && toSpan < toTarget) || (toSpan < 0.F && toSpan > toTarget);
+    if (!between) {
+      return kNone;
+    }
+    const Scalar scale = toTarget / toSpan;
+    return {.low = aQ + (scale * (span.low - aQ)), .high = aQ + (scale * (span.high - aQ))};
+  }
+  // The span at Q = position over P in [low, high]: a segment reaching the
+  // target at Q = u crosses it at fraction s = (position - aQ) / (u - aQ) of
+  // the way, at P = aP + s (w - aP), which has to lie in the range.
+  const Scalar toSpan = span.position - aQ;
+  if (exactlyEqual(toTarget, 0.F) || exactlyEqual(toSpan, 0.F)) {
+    return kNone;
+  }
+  const Scalar s1 = (span.low - aP) / toTarget;
+  const Scalar s2 = (span.high - aP) / toTarget;
+  const Scalar sMin = s1 < s2 ? s1 : s2;
+  const Scalar sWide = s1 < s2 ? s2 : s1;
+  const Scalar sMax = sWide < 1.F ? sWide : 1.F;
+  if (!(sMax > 0.F) || sMin > sMax) {
+    return kNone;
+  }
+  const Scalar near = aQ + (toSpan / sMax);
+  const Scalar unbounded = toSpan > 0.F ? kInfinity : -kInfinity;
+  const Scalar far = sMin > 0.F ? aQ + (toSpan / sMin) : unbounded;
+  return near < far ? Shadow{.low = near, .high = far} : Shadow{.low = far, .high = near};
+}
+
+} // namespace detail
+
+/// The range of the second coordinate on layer \a target, within [\a low,
+/// \a high] -- the target's extent --, where a pair from source (\a ra,
+/// \a za) can leave no hole: the range with every shadow of a layer of
+/// \a holes that covers one of its ends, at every position the target's
+/// measurements take, cut off; empty (low > high) when nothing is left. A
+/// hull: a shadow inside it stays, and `segmentLeavesHole` decides per pair.
+/// It spares the query of a source no direct pair can leave, and the cells
+/// of the others beyond it, and changes no tracklet.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() LayerSpan directPairRange(std::uint64_t holes, std::uint64_t barrels, const LayerSpan* spans, LayerID target, Scalar ra, Scalar za, Scalar low, Scalar high)
+{
+  const bool targetBarrel = ((barrels >> target) & 1U) != 0U;
+  const Scalar aP = targetBarrel ? ra : za;
+  const Scalar aQ = targetBarrel ? za : ra;
+  const Scalar wLow = spans[target].positionMin;
+  const Scalar wHigh = spans[target].positionMax;
+  // Each layer's shadow over every target position: the shadows at the two
+  // ends of the position range intersected, the shadow's ends being
+  // monotonic in the position. The range's ends are cut back while a shadow
+  // covers one.
+  for (bool changed = true; changed && low <= high;) {
+    changed = false;
+    for (std::uint64_t left = holes; left != 0U; left &= left - 1U) {
+      const std::uint32_t layer = o2::gpu::CAMath::Ctz64(left);
+      const bool sameAxis = (((barrels >> layer) & 1U) != 0U) == targetBarrel;
+      const auto atLow = detail::shadow(sameAxis, spans[layer], aP, aQ, wLow);
+      const auto atHigh = detail::shadow(sameAxis, spans[layer], aP, aQ, wHigh);
+      const Scalar shadowLow = atLow.low > atHigh.low ? atLow.low : atHigh.low;
+      const Scalar shadowHigh = atLow.high < atHigh.high ? atLow.high : atHigh.high;
+      if (atLow.low > atLow.high || atHigh.low > atHigh.high || shadowLow > shadowHigh) {
+        continue;
+      }
+      if (shadowLow <= low && shadowHigh > low) {
+        low = shadowHigh;
+        changed = true;
+      }
+      if (shadowHigh >= high && shadowLow < high) {
+        high = shadowLow;
+        changed = true;
+      }
+    }
+  }
+  return {.position = spans[target].position, .low = low, .high = high, .positionMin = wLow, .positionMax = wHigh};
+}
+
+/// The layers a pair on link \a from -> \a to can cross, a bit per layer: a
+/// barrel layer whose radius lies inside the radii the two layers' measurements
+/// span, a disc whose z lies inside their z. A superset: `segmentCrosses`
+/// decides per pair. 0 for a link with none, as l -> l + 1 on a barrel.
+template <DetectorLayout Det>
+[[nodiscard]] inline std::uint64_t linkHoleLayers(LayerID from, LayerID to)
+{
+  static_assert(Detector<Det>::nLayers <= std::numeric_limits<std::uint64_t>::digits);
+  std::uint64_t holes = 0U;
+  for (int layer = 0; layer < Detector<Det>::nLayers; ++layer) {
+    const auto id = static_cast<LayerID>(layer);
+    if (id == from || id == to) {
+      continue;
+    }
+    const bool barrel = Detector<Det>::isBarrelLayer(id);
+    const double position = barrel ? layerDistance<Det>(id) : discZ<Det>(id);
+    holes |= positionBetweenLayers<Det>(barrel, position, from, to) ? std::uint64_t{1} << layer : 0U;
+  }
+  return holes;
+}
+
+/// The barrel layers of \a Det, a bit per layer.
+template <DetectorLayout Det>
+[[nodiscard]] constexpr std::uint64_t barrelLayerBits()
+{
+  std::uint64_t bits = 0U;
+  for (int layer = 0; layer < Detector<Det>::nLayers; ++layer) {
+    bits |= Detector<Det>::isBarrelLayer(static_cast<LayerID>(layer)) ? std::uint64_t{1} << layer : 0U;
+  }
+  return bits;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_LINKHOLES_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Material.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Material.h
new file mode 100644
index 0000000000000..de47b932e3702
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Material.h
@@ -0,0 +1,157 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Material.h
+/// \brief What a propagation step crossed, and the scattering it causes.
+
+#ifndef GTRK_TRACKING_MATERIAL_H_
+#define GTRK_TRACKING_MATERIAL_H_
+
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/Trig.h"
+
+#include "GPUCommonMath.h"
+
+namespace o2::gtrk
+{
+
+/// beta p [GeV] at momentum \a momentumGeV for the mass hypothesis
+/// \a massGeV (`Propagator::massGeV`, positive): what Highland's formula
+/// divides by.
+GPUhdi() GPUAlwaysInline() Scalar betaMomentum(Scalar momentumGeV, Scalar massGeV) { return momentumGeV * momentumGeV / o2::gpu::GPUCommonMath::Sqrt((momentumGeV * momentumGeV) + (massGeV * massGeV)); }
+
+/// Highland's scattering angle for a step, in radians.
+///
+/// theta0 = (13.6 MeV / beta c p) z sqrt(x/X0) [1 + 0.038 ln(x/X0)], with z = 1
+/// and \a betaMomentumGeV = beta p from the mass hypothesis (`betaMomentum`).
+/// 13.6 MeV is 0.0136 in the GeV this state is parameterised in. O2's
+/// `correctForMaterial` leaves out the logarithmic term.
+///
+/// The logarithmic correction turns negative below x/X0 = exp(-1/0.038), about
+/// 4e-12, which is far outside anything a detector produces but is guarded
+/// because a negative sigma is worse than a zero one.
+GPUhdi() GPUAlwaysInline() Scalar highlandTheta0(Scalar x2X0, Scalar betaMomentumGeV)
+{
+  if (x2X0 <= 0.F || betaMomentumGeV <= 0.F) {
+    return 0.F;
+  }
+  const Scalar corr = 1.F + 0.038F * logOf(x2X0);
+  if (corr <= 0.F) {
+    return 0.F;
+  }
+  return (0.0136F / betaMomentumGeV) * o2::gpu::GPUCommonMath::Sqrt(x2X0) * corr;
+}
+
+/// O2's mean Bethe-Bloch for silicon, `o2::track::BetheBlochSolidOpt`, at
+/// \a betaGamma, in GeV / (g/cm^2): its constants and its arithmetic, for
+/// host and device alike, where O2's is device-only in a GPU translation
+/// unit. testTrackFitter.cxx's `TheEnergyLossIsO2s` holds it to O2's.
+GPUhdi() GPUAlwaysInline() Scalar betheBlochSolid(Scalar betaGamma)
+{
+  constexpr Scalar kK = 0.307075e-3F; // [GeV cm^2 / g]
+  // O2's 2.303, not ln 10: the same numbers as O2.
+  constexpr Scalar kP1 = 0.20F * 2.303F; // NOLINT(modernize-use-std-numbers)
+  constexpr Scalar kP2 = 3.00F * 2.303F; // NOLINT(modernize-use-std-numbers)
+  constexpr Scalar kMeanZA = 0.49848F;
+  constexpr Scalar kLhwI = -1.7175226F;         // log(28.816e-9 sqrt(rho Z/A) / I)
+  constexpr Scalar kLog2MeToMeanI = 8.6839805F; // log(2 m_e / I)
+  const Scalar bg2 = betaGamma * betaGamma;
+  const Scalar beta2 = bg2 / (1.F + bg2);
+  Scalar d2 = 0.F;
+  const Scalar x = o2::gpu::GPUCommonMath::Log(betaGamma);
+  if (x > kP2) {
+    d2 = kLhwI - 0.5F + x;
+  } else if (x > kP1) {
+    const Scalar r = (kP2 - x) / (kP2 - kP1);
+    d2 = kLhwI - 0.5F + x + ((0.5F - kLhwI - kP1) * r * r * r);
+  }
+  const Scalar dedx = kK * kMeanZA / beta2 * (kLog2MeToMeanI + x + x - beta2 - d2);
+  return dedx > 0.F ? dedx : 0.F;
+}
+
+/// One step's energy loss, as O2 corrects for it
+/// (`TrackParametrizationWithError::correctForMaterial`, with a linearisation
+/// reference).
+struct EnergyLoss {
+  Scalar momentumScale = 1.F; ///< p before over p after: the factor on q/p
+  Scalar varQOverP = 0.F;     ///< the straggling, added to q/p's variance
+  bool ok = true;             ///< false: stopped, or below 10 MeV after it
+};
+
+/// The mean energy lost -- or, against the momentum, regained -- over
+/// \a xRho [g/cm^2] by a particle of mass \a massGeV at \a qOverP: O2's
+/// Bethe-Bloch for silicon (`betheBlochSolid`) [GeV / (g/cm^2)], in sub-steps of at most 2.5 % of the kinetic energy, and
+/// O2's straggling, 0.0007 sqrt(|dE|) [GeV] on the energy. \a xRho is negative
+/// along the momentum. A MatLUT carries no material's I or Z/A, which is why
+/// silicon's stand in for all of it, as in O2.
+GPUhdi() EnergyLoss energyLoss(Scalar qOverP, Scalar massGeV, Scalar xRho)
+{
+  EnergyLoss result;
+  if (!(o2::gpu::GPUCommonMath::Abs(xRho) > 0.F)) {
+    return result;
+  }
+  constexpr Scalar kMinMomentum = 0.01F;          // O2's kMinP
+  constexpr Scalar kStepsPerKineticEnergy = 40.F; // O2's ELoss2EKinThreshInv
+  constexpr int kMaxSteps = 50;                   // O2's MaxELossIter
+  const Scalar mass2 = massGeV * massGeV;
+  const Scalar massInv = 1.F / massGeV;
+  const Scalar p0 = 1.F / o2::gpu::GPUCommonMath::Abs(qOverP);
+  const Scalar e0 = o2::gpu::GPUCommonMath::Sqrt((p0 * p0) + mass2);
+  Scalar p = p0;
+  Scalar e = e0;
+  Scalar dE = betheBlochSolid(p * massInv) * xRho;
+  int steps = 1 + static_cast<int>(o2::gpu::GPUCommonMath::Abs(dE) / (e - massGeV) * kStepsPerKineticEnergy);
+  steps = steps > kMaxSteps ? kMaxSteps : steps;
+  if (steps > 1) {
+    dE /= static_cast<Scalar>(steps);
+    xRho /= static_cast<Scalar>(steps);
+  }
+  while (steps-- > 0) {
+    e += dE;
+    if (!(e > massGeV)) {
+      result.ok = false;
+      return result;
+    }
+    p = o2::gpu::GPUCommonMath::Sqrt((e * e) - mass2);
+    if (steps > 0) {
+      dE = betheBlochSolid(p * massInv) * xRho;
+    }
+  }
+  if (p < kMinMomentum) {
+    result.ok = false;
+    return result;
+  }
+  result.momentumScale = p0 / p;
+  const Scalar sigmaQOverP = 0.0007F * o2::gpu::GPUCommonMath::Sqrt(o2::gpu::GPUCommonMath::Abs(e - e0)) * e0 / (p0 * p0) * o2::gpu::GPUCommonMath::Abs(qOverP);
+  result.varQOverP = sigmaQOverP * sigmaQOverP;
+  return result;
+}
+
+/// The variances a step's scattering adds to phi and theta, for a covariance
+/// kept as factors (StepNoise): zero for no material.
+struct ScatteringNoise {
+  Scalar phi = 0.F;
+  Scalar theta = 0.F;
+};
+
+GPUhdi() GPUAlwaysInline() ScatteringNoise scatteringNoise(Scalar theta0, Scalar theta)
+{
+  if (theta0 <= 0.F) {
+    return {};
+  }
+  const Scalar t2 = theta0 * theta0;
+  const auto sinTheta = sinOf(theta);
+  return {.phi = t2 / (sinTheta * sinTheta), .theta = t2};
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_MATERIAL_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MathUtils.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MathUtils.h
new file mode 100644
index 0000000000000..311ee36b7a4e0
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MathUtils.h
@@ -0,0 +1,293 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MathUtils.h
+/// \brief The tracking's numeric helpers: stable sinc, versine and asin(x)/x
+///        forms, the U-D covariance factorisation, the chi2 quantile, the
+///        curvature radius.
+
+#ifndef GTRK_TRACKING_MATHUTILS_H_
+#define GTRK_TRACKING_MATHUTILS_H_
+
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/Trig.h"
+
+#include "GPUCommonMath.h"
+#include "CommonConstants/MathConstants.h"
+#include "MathUtils/detail/basicMath.h"
+
+#include <cmath>
+#include <numbers>
+
+namespace o2::gtrk
+{
+
+/// sin(x)/x, with its value at zero.
+///
+/// The series and quotient agree within the scalar precision at the branch.
+/// The quotient itself does not cancel, but needs the series at its removable
+/// singularity.
+template <typename T>
+GPUhdi() GPUAlwaysInline() T sinc(T x)
+{
+  if (o2::gpu::GPUCommonMath::Abs(x) < T(1e-4)) {
+    return T(1) - x * x / T(6);
+  }
+  return sinOf(x) / x;
+}
+
+/// (1 - cos(x)) / x without forming the cancelling subtraction.
+template <typename T>
+GPUhdi() GPUAlwaysInline() T versine(T x)
+{
+  const T h = sinc<T>(x / T(2));
+  return T(0.5) * x * h * h;
+}
+
+/// d/dx of sinc, with a series where cos(x) - sinc(x) cancels.
+template <typename T>
+GPUhdi() GPUAlwaysInline() T dSinc(T x)
+{
+  if (o2::gpu::GPUCommonMath::Abs(x) < T(0.05)) {
+    const T x2 = x * x;
+    return -x / T(3) + x * x2 / T(30) - x * x2 * x2 / T(840);
+  }
+  return (cosOf(x) - sinc<T>(x)) / x;
+}
+
+/// d/dx of versine, with a series around zero.
+template <typename T>
+GPUhdi() GPUAlwaysInline() T dVersine(T x)
+{
+  if (o2::gpu::GPUCommonMath::Abs(x) < T(0.05)) {
+    const T x2 = x * x;
+    return T(0.5) - x2 / T(8) + x2 * x2 / T(144) - x2 * x2 * x2 / T(5760);
+  }
+  return (sinOf(x) - versine<T>(x)) / x;
+}
+
+namespace detail
+{
+
+/// Column-major strict-upper index. The caller supplies first < second.
+GPUhdi() GPUAlwaysInline() constexpr int strictUpperIndex(int first, int second) { return (second * (second - 1)) / 2 + first; }
+
+/// Factor a packed symmetric positive-definite matrix as U D U^T. U is unit
+/// upper triangular, so only its strict upper triangle is stored. Working
+/// from the last column towards the first keeps differently scaled state
+/// coordinates in D instead of mixing their scales in a square root.
+template <typename T>
+GPUhdi() GPUAlwaysInline() void factorUD(const T (&matrix)[kBoundCovSize], T (&upper)[kBoundUpperSize], T (&diagonal)[kNBoundParams])
+{
+  for (int column = kNBoundParams - 1; column >= 0; --column) {
+    T pivot = matrix[covIndex(column, column)];
+    for (int k = column + 1; k < kNBoundParams; ++k) {
+      const T value = upper[strictUpperIndex(column, k)];
+      pivot -= value * value * diagonal[k];
+    }
+    diagonal[column] = pivot;
+
+    for (int row = 0; row < column; ++row) {
+      T value = matrix[covIndex(row, column)];
+      for (int k = column + 1; k < kNBoundParams; ++k) {
+        value -= upper[strictUpperIndex(row, k)] * upper[strictUpperIndex(column, k)] * diagonal[k];
+      }
+      upper[strictUpperIndex(row, column)] = value / pivot;
+    }
+  }
+}
+
+/// Bierman's scalar measurement update of a U D U^T covariance.
+///
+/// The posterior is formed by updating its factors rather than subtracting
+/// K H P from P. This is the important numerical property when a precise
+/// cluster follows a diffuse track prior: the small posterior variance is
+/// produced by multiplication and division, never as the difference of two
+/// nearly equal floats. The gain updates the state mean; the return value
+/// is the innovation variance, `H P H^T + variance`, for the chi2.
+template <typename T>
+GPUhdi() GPUAlwaysInline() T updateUD(T (&upper)[kBoundUpperSize], T (&diagonal)[kNBoundParams], const T (&measurement)[kNBoundParams], T variance, T (&gain)[kNBoundParams])
+{
+  T projected[kNBoundParams]{};
+  T weighted[kNBoundParams]{};
+  for (int column = 0; column < kNBoundParams; ++column) {
+    projected[column] = measurement[column];
+    for (int row = 0; row < column; ++row) {
+      projected[column] += upper[strictUpperIndex(row, column)] * measurement[row];
+    }
+    weighted[column] = diagonal[column] * projected[column];
+  }
+
+  T numerator[kNBoundParams]{};
+  T innovation = variance;
+  for (int column = 0; column < kNBoundParams; ++column) {
+    const T previousInnovation = innovation;
+    innovation += projected[column] * weighted[column];
+    const T factor = projected[column] / previousInnovation;
+    diagonal[column] *= previousInnovation / innovation;
+
+    for (int row = 0; row < column; ++row) {
+      const int index = strictUpperIndex(row, column);
+      const T value = upper[index];
+      upper[index] = value - factor * numerator[row];
+      numerator[row] += weighted[column] * value;
+    }
+    numerator[column] += weighted[column];
+  }
+
+  for (int row = 0; row < kNBoundParams; ++row) {
+    gain[row] = numerator[row] / innovation;
+  }
+  return innovation;
+}
+
+/// Reconstruct a packed symmetric covariance from its U D U^T factors.
+template <typename T>
+GPUhdi() GPUAlwaysInline() void covarianceFromUD(const T (&upper)[kBoundUpperSize], const T (&diagonal)[kNBoundParams], T (&matrix)[kBoundCovSize])
+{
+  for (int row = 0; row < kNBoundParams; ++row) {
+    for (int col = 0; col <= row; ++col) {
+      T value = diagonal[row];
+      if (col < row) {
+        value *= upper[strictUpperIndex(col, row)];
+      }
+      for (int k = row + 1; k < kNBoundParams; ++k) {
+        value += upper[strictUpperIndex(row, k)] * diagonal[k] * upper[strictUpperIndex(col, k)];
+      }
+      matrix[covIndex(row, col)] = value;
+    }
+  }
+}
+
+/// asin(x) / x, evaluated without a singularity or an unnecessary asin near zero.
+template <typename T>
+GPUhdi() GPUAlwaysInline() T asinOverArgument(T x)
+{
+  if (o2::gpu::GPUCommonMath::Abs(x) < T(0.05)) {
+    const T x2 = x * x;
+    return T(1) + x2 * (T(1) / T(6) + x2 * T(3) / T(40));
+  }
+  return asinOf(x) / x;
+}
+
+template <typename T>
+struct AsinOverArgument {
+  T value;
+  T derivative;
+};
+
+/// `asinOverArgument(x)` and its derivative with one asin; the value is
+/// `asinOverArgument(x)` to the bit.
+template <typename T>
+GPUhdi() GPUAlwaysInline() AsinOverArgument<T> asinOverArgumentWithDerivative(T x)
+{
+  if (o2::gpu::GPUCommonMath::Abs(x) < T(0.05)) {
+    const T x2 = x * x;
+    return {.value = T(1) + x2 * (T(1) / T(6) + x2 * T(3) / T(40)), .derivative = x * (T(1) / T(3) + x2 * (T(3) / T(10) + x2 * T(15) / T(56)))};
+  }
+  const T arcsine = asinOf(x);
+  return {.value = arcsine / x, .derivative = ((x / o2::math_utils::detail::sqrt(T(1) - (x * x))) - arcsine) / (x * x)};
+}
+
+/// Signed-curvature chord length converted to positive transverse arc length.
+template <typename T>
+GPUhdi() GPUAlwaysInline() T transverseArc(T curvature, T dx, T dy)
+{
+  const T chord = o2::math_utils::detail::sqrt(dx * dx + dy * dy);
+  // A chord of one diameter is half a turn; rounding must not push past it.
+  const T halfTurnSine = o2::gpu::GPUCommonMath::Clamp(T(0.5) * curvature * chord, T(-1), T(1));
+  return chord * asinOverArgument(halfTurnSine);
+}
+
+/// The regularised lower incomplete gamma function P(a, x): its series below
+/// x = a + 1, and its continued fraction above (Numerical Recipes, 6.2).
+[[nodiscard]] inline double regularizedGammaP(double a, double x)
+{
+  if (!(x > 0.)) {
+    return 0.;
+  }
+  const double logPrefactor = (a * std::log(x)) - x - std::lgamma(a);
+  if (x < a + 1.) {
+    double term = 1. / a;
+    double sum = term;
+    for (int n = 1; n < 1000 && std::abs(term) > std::abs(sum) * 1.e-16; ++n) {
+      term *= x / (a + n);
+      sum += term;
+    }
+    return sum * std::exp(logPrefactor);
+  }
+  constexpr double kTiny = 1.e-300;
+  double b = x + 1. - a;
+  double c = 1. / kTiny;
+  double d = 1. / b;
+  double h = d;
+  for (int n = 1; n < 1000; ++n) {
+    const double an = -n * (n - a);
+    b += 2.;
+    d = (an * d) + b;
+    d = std::abs(d) < kTiny ? kTiny : d;
+    c = b + (an / c);
+    c = std::abs(c) < kTiny ? kTiny : c;
+    d = 1. / d;
+    const double step = d * c;
+    h *= step;
+    if (std::abs(step - 1.) < 1.e-16) {
+      break;
+    }
+  }
+  return 1. - (std::exp(logPrefactor) * h);
+}
+
+} // namespace detail
+
+/// The chi2 with ndf degrees of freedom that a fit passes at the confidence
+/// of nSigma of a Gaussian, two-sided. The distribution P(ndf/2, x/2) is
+/// inverted by bisection. ROOT's `chisquared_quantile` has this contract; not
+/// in a header the device units read.
+[[nodiscard]] inline double chiSquareQuantile(int ndf, double nSigma)
+{
+  const double confidence = std::erf(nSigma / std::numbers::sqrt2);
+  const double half = 0.5 * static_cast<double>(ndf);
+  const auto distribution = [half](double x) { return detail::regularizedGammaP(half, 0.5 * x); };
+  double low = 0.;
+  double high = 1.;
+  while (distribution(high) < confidence) {
+    low = high;
+    high *= 2.;
+  }
+  for (int i = 0; i < 100; ++i) {
+    const double middle = 0.5 * (low + high);
+    (distribution(middle) < confidence ? low : high) = middle;
+  }
+  return 0.5 * (low + high);
+}
+
+/// Transverse radius of curvature [cm] for a particle with the supplied
+/// transverse momentum in a solenoid field.
+///
+/// B2C is negative by convention, so only the magnitude enters the radius.
+template <typename T>
+GPUhdi() GPUAlwaysInline() T curvatureRadius(T minPtGeV, T bzKiloGauss)
+{
+  const T perPt = o2::gpu::GPUCommonMath::Abs(static_cast<T>(o2::constants::math::B2C) * bzKiloGauss);
+  return perPt > T(0) ? minPtGeV / perPt : T(0);
+}
+
+/// Transverse arc from the origin to a point at the supplied radius.
+template <typename T>
+GPUhdi() GPUAlwaysInline() T transverseArcAtRadius(T curvature, T radius)
+{
+  return curvature > T(0) ? detail::transverseArc(curvature, radius, T(0)) : radius;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_MATHUTILS_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Measurement.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Measurement.h
new file mode 100644
index 0000000000000..daa5d60f324c8
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Measurement.h
@@ -0,0 +1,186 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Measurement.h
+/// \brief What a cluster looks like once the fit can consume it, as one
+///        record and as the SoA columns the tracker reads.
+///
+/// The record is here; filling one is the workflow's (MeasurementProducer.h):
+/// the cluster record carries ClassDefNV and Rtypes.h, which nothing here may
+/// include.
+///
+/// Record and columns are one declaration, `MeasurementT`. A producer
+/// allocates one message part per column and one for the grid offsets; a
+/// consumer binds a pointer per column and reads `view[i].timePS`. Nothing
+/// here serialises or knows about a transport; only the owned columns of the
+/// tests and the replay format allocate.
+#ifndef GTRK_TRACKING_MEASUREMENT_H_
+#define GTRK_TRACKING_MEASUREMENT_H_
+
+#include "GenericTracking/Base/Definitions.h"
+#include "GenericTracking/Base/TimeEstPS.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/ShapeCut.h"
+
+#include <memlayout/wrapper.h>
+
+#include <cstdint>
+#include <cstddef>
+#include <type_traits>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+/// One cluster, in the frame the update works in, declared once for every
+/// storage: `Measurement` below is the record, `MeasurementStore` and
+/// `MeasurementView` are its columns. The defaults apply to the record only;
+/// in any other storage a field defaults to an empty column.
+///
+/// The spatial part is the sensor-local position and its 2x2 covariance. The
+/// cross term is part of the update's contract, as in O2's cluster update;
+/// the producer writes 0.
+///
+/// Instantiated with C = const_reference, every member *is* a reference --
+/// that is what an SoA element proxy is -- and `apply` is upstream's macro,
+/// which takes a forwarding reference it does not forward.  Neither is a
+/// defect here.  The macro also uses these camelBack member names as enum
+/// constants.
+// NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members,cppcoreguidelines-missing-std-forward,readability-identifier-naming)
+template <template <class> class C>
+struct MeasurementT {
+  MEMLAYOUT_APPLY(MeasurementT, loc0, loc1, timePS, widthPS, varLoc0, covLoc01, varLoc1, clusterIndex, surface, x, y, z, r, phi, varZ, varR, varRPhi, slopeLow, slopeHigh)
+  C<Scalar> loc0 = memlayout::default_value<C>(0.F); ///< sensor-local position [cm]
+  C<Scalar> loc1 = memlayout::default_value<C>(0.F);
+  /// The time box `[timePS, timePS + widthPS)` [ps from the timeframe's
+  /// start]: the readout frame or tick, widened by its margin
+  /// (TimeEstPS.h).
+  C<std::uint32_t> timePS = memlayout::default_value<C>(std::uint32_t{0});
+  C<std::uint32_t> widthPS = memlayout::default_value<C>(std::uint32_t{0});
+
+  C<Scalar> varLoc0 = memlayout::default_value<C>(0.F);
+  C<Scalar> covLoc01 = memlayout::default_value<C>(0.F);
+  C<Scalar> varLoc1 = memlayout::default_value<C>(0.F);
+
+  C<std::uint32_t> clusterIndex = memlayout::default_value<C>(std::uint32_t{0});
+  C<SensorID> surface = memlayout::default_value<C>(kInvalidSensorID);
+
+  /// Global position [cm], computed once by the producer from the sensor and
+  /// the double geometry. Everything that compares positions across layers --
+  /// the exact spatial cuts, tracklets, triplets -- reads these; the fit works
+  /// in the local frame above.
+  C<Scalar> x = memlayout::default_value<C>(0.F);
+  C<Scalar> y = memlayout::default_value<C>(0.F);
+  C<Scalar> z = memlayout::default_value<C>(0.F);
+  /// The same position's transverse radius [cm] and azimuth in [0, 2pi),
+  /// cached by the producer so that no consumer takes a square root or an
+  /// arctangent per candidate.
+  C<Scalar> r = memlayout::default_value<C>(0.F);
+  C<Scalar> phi = memlayout::default_value<C>(0.F);
+  /// The local covariance projected through the sensor's rotation onto z, r
+  /// and r-phi of the corrected beam line [cm^2]: what the pair cuts read,
+  /// computed once by the producer. The r-z
+  /// covariance is zero for sensors whose plane contains z or lies across it.
+  C<Scalar> varZ = memlayout::default_value<C>(0.F);
+  C<Scalar> varR = memlayout::default_value<C>(0.F);
+  C<Scalar> varRPhi = memlayout::default_value<C>(0.F);
+  /// The local slopes [slopeLow, slopeHigh) at which a particle above its
+  /// detector's calibration floor leaves this cluster's shape: its line's
+  /// slope along the sensor's columns over its length along the normal
+  /// (ShapeCut.h), made by the producer from its detector's calibrated band
+  /// (ClusterShapeBand.h);
+  /// empty (infinite, 0) where none does, [0, kSlopeUnbounded) without a
+  /// shape to go by. An iteration with `shapeTest` reads them.
+  C<Scalar> slopeLow = memlayout::default_value<C>(0.F);
+  C<Scalar> slopeHigh = memlayout::default_value<C>(kSlopeUnbounded);
+};
+// NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members,cppcoreguidelines-missing-std-forward,readability-identifier-naming)
+
+/// The record: one measurement, as the fit and the QA hold it.
+using Measurement = MeasurementT<memlayout::value>;
+
+/// The columns, owned. Useful on the host; not what goes on the wire.
+using MeasurementStore = memlayout::Wrapper<MeasurementT, std::vector, memlayout::Layout::soa>;
+
+/// The columns, borrowed and read-only. `const_pointer` is the contract: a
+/// consumer cannot write through this view, whatever the message is backed by.
+using MeasurementView = memlayout::Wrapper<MeasurementT, memlayout::const_pointer, memlayout::Layout::soa>;
+
+/// One message part per field in the MEMLAYOUT_APPLY order. The wrapper
+/// generates these IDs from that same field list.
+using MeasurementColumn = Measurement::Column;
+
+inline constexpr std::uint32_t kNMeasurementColumns = static_cast<std::uint32_t>(MeasurementColumn::ColumnCount);
+/// Prefix offsets for every `(layer, time block, phi cell, second cell)`
+/// bucket, followed by the total measurement count.
+inline constexpr std::uint32_t kColGridOffsets = kNMeasurementColumns;
+inline constexpr std::uint32_t kNMeasurementParts = kNMeasurementColumns + 1;
+
+/// Build one container per schema field. The factory receives the field type
+/// and its wire-column ID, so producers and consumers cannot silently omit a
+/// field when MeasurementT grows.
+template <template <class> class Container, class Factory>
+[[nodiscard]] auto makeMeasurementColumns(Factory factory)
+{
+  std::size_t column = 0U;
+  return Measurement{}.apply([&]<class... T>(const T&...) { return memlayout::Wrapper<MeasurementT, Container, memlayout::Layout::soa>{MeasurementT<Container>{factory(std::type_identity<T>{}, static_cast<MeasurementColumn>(column++))...}}; });
+}
+
+/// Resize every owned column together.
+template <class Columns>
+void resizeMeasurementColumns(Columns& columns, std::size_t rows)
+{
+  columns.apply([rows](auto&... column) { (column.resize(rows), ...); });
+}
+
+/// Bind any contiguous measurement columns as the tracker's read-only view.
+template <class Columns>
+[[nodiscard]] MeasurementView measurementView(const Columns& columns)
+{
+  return MeasurementView{columns.apply([](const auto&... column) { return MeasurementT<memlayout::const_pointer>{column.data()...}; })};
+}
+
+template <class Columns>
+void writeMeasurement(Columns& columns, std::size_t row, const Measurement& measurement)
+{
+  auto target = columns[row];
+  target.apply(measurement, [](auto& destination, const auto& source) -> auto& {
+    destination = source;
+    return destination;
+  });
+}
+
+/// Bytes occupied by one row across all measurement columns, excluding grid
+/// offsets and transport metadata.
+inline constexpr std::size_t kMeasurementRowBytes = Measurement{}.apply([](const auto&... field) { return (sizeof(field) + ... + 0U); });
+
+/// A row's time box.
+template <typename Row>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() TimeEstPS timeBox(const Row& row)
+{
+  return {.start = row.timePS, .width = row.widthPS};
+}
+
+/// The same for row \a row of \a columns, reading only the two columns it holds.
+template <typename Columns>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() TimeEstPS timeBoxAt(const Columns& columns, std::uint32_t row)
+{
+  return {.start = columns.timePS[row], .width = columns.widthPS[row]};
+}
+
+/// Whether a measurement with time box \a row can come from a collision in
+/// \a vertex's box: the rule of ITSMFT's `isVertexCompatible`, the vertex's end inclusive so
+/// that a vertex of width 0 -- a point -- at the box's start belongs to it.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool vertexTimeCompatible(const TimeEstPS& row, const TimeEstPS& vertex) { return vertex.upper() >= row.lower() && vertex.lower() < row.upper(); }
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_MEASUREMENT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MeasurementGrid.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MeasurementGrid.h
new file mode 100644
index 0000000000000..63c334b62eba9
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MeasurementGrid.h
@@ -0,0 +1,958 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MeasurementGrid.h
+/// \brief The adjacent-layer candidate index.
+///
+/// Each layer's SoA rows are ordered by `(time block, phi cell, second cell,
+/// box start)` and a prefix-sum offset table over `(block, cell)` travels with
+/// them.  The second coordinate is z on a barrel layer and r on a disc, by
+/// `if constexpr`.  Three keys, each doing the job it is good at:
+///
+///  - **the block key keeps slicing contiguous.**  A slice is a union of whole
+///    blocks, so its core is one row range per layer and its halo is more
+///    blocks on each side -- still one range.  That is what makes a slice's
+///    bounded working set affordable, and it is why the block is the *outer* key: one
+///    linear order cannot be contiguous in both time and space, and the slice
+///    is the thing that needs it.
+///  - **the cell key makes the spatial cut a lookup.**  A cell's rows are a
+///    contiguous range found by offset, so a phi or second-coordinate window
+///    selects cells instead of scanning rows.
+///  - **the box start orders rows within a cell,** so the exact pairwise time
+///    cut -- the boxes overlap -- is a binary search over the rows' own boxes.
+///    The index is never keyed on a readout frame:
+///    a frame is a property of a detector's readout, and an index that
+///    assumed one would be wrong the moment two layers are staggered.
+///
+/// Cells are a conservative pre-filter and nothing more.  The query applies
+/// the exact time cut; the exact phi and second-coordinate cuts are applied to
+/// what it returns, from the azimuth, radius and z the producer ships with
+/// every row (`spatiallyCompatible`).  That separation is what makes the cell
+/// size a tuning parameter with no effect on the result, and it is why a
+/// densely populated cell means the cells are too coarse for speed rather
+/// than that the window is wrong.
+///
+/// The layout is built once per timeframe, by the producer, and reused across
+/// slices and iterations.  An iteration with a looser minimum pT does not
+/// rebuild it: a wider window simply touches more cells.
+
+#ifndef GTRK_TRACKING_MEASUREMENTGRID_H_
+#define GTRK_TRACKING_MEASUREMENTGRID_H_
+
+#include "GenericTracking/Base/FrameTiming.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Base/Lanes.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/MeasurementRange.h"
+#include "GenericTracking/Tracking/SearchWindow.h"
+#include "GenericTracking/Tracking/Trig.h"
+#include "GenericTracking/Tracking/WorkCounters.h"
+
+#include "GPUCommonAlgorithm.h"
+#include "GPUCommonMath.h"
+#include "MathUtils/detail/trigonometric.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <numbers>
+#include <span>
+#include <stdexcept>
+#include <utility>
+
+namespace o2::gtrk
+{
+
+/// How many cells one query window spans, per axis: the derivation's
+/// constants.
+///
+/// A window W lands anywhere on cells W / c wide: it touches about c + 1 cells
+/// and reads rows over (1 + 1/c) W. The best c balances the cost of a cell
+/// against the cost of a row read, which depends on the rows per window -- the
+/// occupancy the grid is never sized from -- and on the backend; so c is a
+/// constant, not derived: ACTS's convention, 2 in phi (one cell per one-sided
+/// deflection), 1 along the second coordinate, which the 6 cm beam spot makes
+/// coarse.
+inline constexpr double kPhiCellsPerWindow = 2.;
+inline constexpr double kSecondCellsPerWindow = 1.;
+
+/// What a layer's cells are sized from: the widest and the narrowest window,
+/// per axis, of the queries the configured iterations make into it
+/// (GridSizing.h); a layer no query enters has one cell per axis. A narrowest
+/// width of 0 is the widest.
+struct GridLayerWindow {
+  double phiHalfWidth = 0.;    ///< [rad]
+  double secondHalfWidth = 0.; ///< [cm]
+  bool queried = false;
+  double narrowPhiHalfWidth = 0.;    ///< [rad]
+  double narrowSecondHalfWidth = 0.; ///< [cm]
+};
+
+/// The grid's parameters beside the layer windows.
+struct GridParams {
+  /// The block edges' clock: `partsPerPS` parts make a picosecond, and the
+  /// two quantities below are in parts. A bunch crossing is not a whole
+  /// number of picoseconds; with 400789 parts per ps it is 10^10 parts, so
+  /// edges on readout frames are exact in integers.
+  std::int64_t partsPerPS = 1;
+
+  /// Width of one time block [parts], and so the quantum of a slice; 0 for
+  /// one block over the timeframe.
+  ///
+  /// The one parameter here that is *budgeted* rather than derived: it follows
+  /// from the scratch a worker may hold, not from the detector. It is bounded
+  /// above by that scratch and below by the offset table, which scales
+  /// linearly in the block count. Bisection cannot go below one block, so
+  /// this also sets how often the overflow ladder reaches the spill rung, and a halo rounded up to whole blocks
+  /// reads more rows than the time cut needs.
+  std::int64_t blockWidth = 10'000'000;
+
+  /// Where block 0 starts [parts from the timeframe's start]; it may lie
+  /// before it. A detector with readout frames puts it a picosecond before
+  /// its first frame -- a box's start is its frame's rounded down -- and
+  /// takes whole frames per block, so that a frame's rows are binned in one
+  /// block and a zero-margin query from a block's second frame reads that
+  /// block alone.
+  std::int64_t blockOrigin = 0;
+
+  /// Each layer's own cell counts, 0 for the derived count: a grid of a given
+  /// shape, for the tests; no configuration
+  /// key sets them.
+  static constexpr std::size_t kMaxLayers = 64;
+  std::int32_t phiBins[kMaxLayers]{};
+  std::int32_t secondBins[kMaxLayers]{};
+
+  /// Each layer's readout frames, of a positive length: what the slices'
+  /// reach reads to tell which links cannot drift in time (SlicePlan.h's
+  /// `sliceReach`).
+  FrameTiming frames[kMaxLayers]{};
+};
+
+/// A run of whole time blocks, half-open.
+struct BlockRange {
+  std::int32_t begin = 0;
+  std::int32_t end = 0;
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::int32_t size() const { return end - begin; }
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool empty() const { return end <= begin; }
+};
+
+/// A time slice as the grid expresses it: whole blocks, core and halo.
+///
+/// This is the tracker's slice with its width quantised to the block grid.
+/// The *result* must be invariant under slice width, not the width
+/// continuous, and the halo covers cross-boundary candidates either way -- but
+/// it does mean the block width is chosen when the payload is written rather
+/// than when the tracker runs.
+struct GridSlice {
+  BlockRange core;
+  BlockRange halo;
+};
+
+/// Azimuth of a global position, in [0, 2pi).
+///
+/// This and the transverse radius are computed once per measurement, by the
+/// producer from the float position it ships, and shipped beside it: the
+/// producer bins by them and the tracker cuts on them, so a row's bucket and
+/// the exact cut applied to it read the same numbers, and no row lands on the
+/// far side of a cell edge from where its query looks. Nothing downstream
+/// evaluates either again.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar azimuth(Scalar x, Scalar y)
+{
+  const Scalar phi = atan2Of(y, x);
+  return o2::math_utils::detail::to02Pi<Scalar>(phi);
+}
+
+/// The second binning coordinate, picked from the cached ones: z on a barrel
+/// layer, r on a disc.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar secondCoordinate(LayerID layer, Scalar r, Scalar z)
+{
+  return Detector<Det>::isBarrelLayer(layer) ? z : r;
+}
+
+/// The bin counts one layer's axes carry, and the affine maps onto them.
+///
+/// Public aggregate and trivially copyable on purpose: this is uploaded to a
+/// device as-is.
+struct LayerAxes {
+  std::int32_t nPhi = 1;
+  std::int32_t nSecond = 1;
+  Scalar secondMin = 0.F;      ///< lower edge of the second-coordinate axis [cm]
+  Scalar secondInvWidth = 0.F; ///< cells per cm along it
+  Scalar phiInvWidth = 0.F;    ///< cells per radian
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::int32_t cellCount() const { return nPhi * nSecond; }
+};
+
+/// Bin count for an axis: as many cells as it takes to cover \a extent with
+/// cells \a windowWidth / \a cellsPerWindow wide, or 0 when that is more
+/// than an int32 holds -- checked before the conversion, so it never wraps;
+/// the geometry then refuses the layout.
+///
+/// A window wider than the axis, or an axis that a detector does not resolve
+/// at all, collapses to one cell rather than to none -- the axis always
+/// exists, and a weak constraint yields few cells rather than no binning.
+[[nodiscard]] inline std::int32_t derivedBinCount(double extent, double windowWidth, double cellsPerWindow)
+{
+  if (!(extent > 0.) || !(windowWidth > 0.) || !(cellsPerWindow > 0.)) {
+    return 1;
+  }
+  const double count = std::ceil(extent * cellsPerWindow / windowWidth);
+  if (!(count > 1.)) {
+    return 1;
+  }
+  return count <= static_cast<double>(INT32_MAX) ? static_cast<std::int32_t>(count) : 0;
+}
+
+/// Bin count for an axis searched by windows from \a narrowWidth to
+/// \a wideWidth: one cell width for both
+/// ends, each held to the `cellsPerWindow` convention. The narrowest window
+/// reads rows over its width plus a cell, (1 + w / a) against the
+/// convention's (1 + 1 / c); the widest spans b / w + 1 cells against c + 1.
+/// The width at which both exceed the convention by the same factor solves
+/// (c / a) w^2 + (c - 1) w - b = 0; with one width, a = b, it is a / c, the
+/// convention itself. Every window between exceeds it by less.
+[[nodiscard]] inline std::int32_t balancedBinCount(double extent, double narrowWidth, double wideWidth, double cellsPerWindow)
+{
+  if (!(narrowWidth > 0.) || !(narrowWidth < wideWidth) || !(cellsPerWindow > 0.)) {
+    return derivedBinCount(extent, wideWidth, cellsPerWindow);
+  }
+  const double c = cellsPerWindow;
+  const double a = narrowWidth;
+  const double b = wideWidth;
+  const double width = a * (std::sqrt(((c - 1.) * (c - 1.)) + (4. * c * b / a)) - (c - 1.)) / (2. * c);
+  return derivedBinCount(extent, width * c, c);
+}
+
+/// The bin of \a scaled -- a coordinate already divided by the bin width -- on
+/// an axis of \a count bins: the first bin for NaN or anything not above zero,
+/// the last for anything at or past the end. The range is checked before the
+/// conversion because converting a float outside int32's range is undefined:
+/// arm64 and the GPUs saturate, while x86 returns INT_MIN, which passes a
+/// `bin < count` clamp and indexes far outside the grid.
+template <typename T>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() constexpr std::int32_t clampedBin(T scaled, std::int32_t count)
+{
+  if (!(scaled > T{0})) {
+    return 0;
+  }
+  if (!(scaled < static_cast<T>(count))) {
+    return count - 1;
+  }
+  return static_cast<std::int32_t>(scaled);
+}
+
+/// Where every cell of every layer sits, and how a `(time, phi, second)`
+/// triple becomes a bucket number.
+///
+/// Built on the host from `Det`, the timeframe duration and the parameters
+/// above; a plain array of PODs afterwards, so it copies to a device with the
+/// rest of the tracker's configuration.
+///
+/// Bucket numbering is layer-major, then block, then phi, then the second
+/// coordinate. That order is the whole point:
+///
+///  - layer-major means the grid's prefix offsets also provide each whole
+///    layer's extent;
+///  - block before cell means a slice's rows are one contiguous range;
+///  - the second coordinate innermost means a query's `(block, phi)` pair
+///    contributes one contiguous run of cells rather than a stride.
+template <DetectorLayout Det>
+class GridGeometry
+{
+ public:
+  static constexpr std::size_t kLayerCount = static_cast<std::size_t>(Detector<Det>::nLayers);
+
+  GridGeometry() = default;
+
+  /// \param durationPS  the timeframe's span; the block grid covers exactly it
+  /// \param params      the block clock, and explicit counts for tests
+  /// \param windows     per layer, the widest and the narrowest window of the
+  ///                    queries into it (GridSizing.h's `gridLayerWindows`)
+  GridGeometry(std::int64_t durationPS, const GridParams& params, std::span<const GridLayerWindow> windows)
+    : mPartsPerPS(params.partsPerPS),
+      mBlockOrigin(params.blockOrigin),
+      mBlockWidth(chosenBlockWidth((durationPS * params.partsPerPS) - params.blockOrigin, params)),
+      mBlockCount(blocksCovering((durationPS * params.partsPerPS) - params.blockOrigin, mBlockWidth))
+  {
+    static_assert(kLayerCount <= GridParams::kMaxLayers);
+    assert(windows.size() == kLayerCount);
+    // The boxes are 32-bit picoseconds from the timeframe's start (TimeEstPS):
+    // a longer timeframe would wrap them silently.
+    if (std::cmp_greater(durationPS, std::numeric_limits<std::uint32_t>::max())) {
+      throw std::invalid_argument("the timeframe is longer than the 32-bit picosecond time box holds (4.29 ms)");
+    }
+    std::uint64_t base = 0;
+    for (std::size_t layer = 0; layer < kLayerCount; ++layer) {
+      if (params.frames[layer].lengthBC <= 0) {
+        throw std::invalid_argument("every layer of the grid has readout frames of a positive length");
+      }
+      mFrames[layer] = params.frames[layer];
+      const auto id = static_cast<LayerID>(layer);
+      const auto& window = windows[layer];
+      const double secondMinValue = secondMin<Det>(id);
+      const double extent = secondMax<Det>(id) - secondMinValue;
+      // A layer no query enters needs no cells: one per axis.
+      const auto derived = [&](std::int32_t set, double axisExtent, double halfWidth, double cellsPerWindow) {
+        if (set > 0) {
+          return set;
+        }
+        return window.queried ? derivedBinCount(axisExtent, 2. * halfWidth, cellsPerWindow) : 1;
+      };
+
+      // Phi: balanced between the narrowest and the widest query, whose phi
+      // cells are a range each. The second coordinate: by the narrowest, as
+      // its cells are the innermost key -- a wider query spans more of them in
+      // the same range per phi cell.
+      const double narrowPhi = window.narrowPhiHalfWidth > 0. ? window.narrowPhiHalfWidth : window.phiHalfWidth;
+      const double narrowSecond = window.narrowSecondHalfWidth > 0. ? window.narrowSecondHalfWidth : window.secondHalfWidth;
+      auto& axes = mAxes[layer];
+      axes.nPhi = params.phiBins[layer];
+      if (axes.nPhi <= 0) {
+        axes.nPhi = window.queried ? balancedBinCount(2 * std::numbers::pi_v<double>, 2. * narrowPhi, 2. * window.phiHalfWidth, kPhiCellsPerWindow) : 1;
+      }
+      axes.nSecond = derived(params.secondBins[layer], extent, narrowSecond, kSecondCellsPerWindow);
+      // A count past int32 comes back as 0: the layout is refused, and the
+      // axis kept at one cell so nothing below divides by or wraps it.
+      if (axes.nPhi <= 0 || axes.nSecond <= 0) {
+        mOverflow = true;
+        axes.nPhi = std::max(axes.nPhi, 1);
+        axes.nSecond = std::max(axes.nSecond, 1);
+      }
+      axes.phiInvWidth = static_cast<Scalar>(static_cast<double>(axes.nPhi) / (2 * std::numbers::pi_v<double>));
+      axes.secondMin = static_cast<Scalar>(secondMinValue);
+      axes.secondInvWidth = extent > 0. ? static_cast<Scalar>(static_cast<double>(axes.nSecond) / extent) : 0.F;
+
+      mLayerBase[layer] = static_cast<std::uint32_t>(base);
+      // A layer's buckets, checked before they are formed: each count is at
+      // most 2^31, so the cells of a block fit 64 bits, and if they fit a
+      // signed 32-bit offset so do the blocks' times them; bucket() computes
+      // block * cells + cell in 32-bit signed arithmetic.
+      const std::uint64_t cells = static_cast<std::uint64_t>(axes.nPhi) * static_cast<std::uint64_t>(axes.nSecond);
+      const std::uint64_t layerBuckets = cells <= std::uint64_t{INT32_MAX} ? static_cast<std::uint64_t>(mBlockCount) * cells : std::uint64_t{INT32_MAX} + 1U;
+      mOverflow = mOverflow || layerBuckets > std::uint64_t{INT32_MAX};
+      base = std::min(base + layerBuckets, std::uint64_t{UINT32_MAX} + 1U);
+    }
+    mLayerBase[kLayerCount] = static_cast<std::uint32_t>(std::min(base, std::uint64_t{UINT32_MAX}));
+    mOverflow = mOverflow || base > std::uint64_t{UINT32_MAX};
+  }
+
+  /// Whether a layer's buckets outnumber a 32-bit signed bucket offset, or all
+  /// of them a 32-bit bucket number: the layout is then unusable, and
+  /// makeGridGeometry refuses it.
+  [[nodiscard]] bool overflows() const { return mOverflow; }
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::int32_t blockCount() const { return mBlockCount; }
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::int64_t partsPerPS() const { return mPartsPerPS; }
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::int64_t blockWidth() const { return mBlockWidth; }
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::int64_t blockOrigin() const { return mBlockOrigin; }
+  /// Layer \a layer's readout frames; none without.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() const FrameTiming& frames(LayerID layer) const { return mFrames[layer]; }
+  /// Where block \a block starts [parts from the timeframe's start].
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::int64_t blockStart(std::int32_t block) const { return mBlockOrigin + (static_cast<std::int64_t>(block) * mBlockWidth); }
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() const LayerAxes& axes(LayerID layer) const { return mAxes[layer]; }
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() BlockRange allBlocks() const { return {.begin = 0, .end = mBlockCount}; }
+
+  /// Number of `(block, cell)` buckets over the whole detector. The offset
+  /// table has one more entry than this.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint32_t bucketCount() const { return mLayerBase[kLayerCount]; }
+
+  /// First bucket of a layer. `offsets[layerBucketBase(l)]` is that layer's
+  /// first row, which is how a whole-layer range is recovered.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint32_t layerBucketBase(LayerID layer) const { return mLayerBase[layer]; }
+
+  /// The block of a time box's start [ps from the timeframe's start], exact;
+  /// a query's bound before the first block lands in it, one past the last
+  /// in the last.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::int32_t blockOfPS(std::int64_t timePS) const
+  {
+    const std::int64_t parts = (timePS * mPartsPerPS) - mBlockOrigin;
+    if (parts < 0) {
+      return 0;
+    }
+    const std::int64_t block = parts / mBlockWidth;
+    return block < mBlockCount ? static_cast<std::int32_t>(block) : mBlockCount - 1;
+  }
+
+  /// \a phi must already be in [0, 2pi).
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::int32_t phiBinOf(LayerID layer, Scalar phi) const
+  {
+    const auto& axes = mAxes[layer]; // NOLINT(clang-analyzer-security.ArrayBound): layer < kLayerCount, the geometry's
+    return clampedBin(phi * axes.phiInvWidth, axes.nPhi);
+  }
+
+  /// Clamped, so a coordinate off the end of a layer lands in its edge cell.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::int32_t secondBinOf(LayerID layer, Scalar second) const
+  {
+    const auto& axes = mAxes[layer];
+    return clampedBin((second - axes.secondMin) * axes.secondInvWidth, axes.nSecond);
+  }
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint32_t bucket(LayerID layer, std::int32_t block, std::int32_t phiBin, std::int32_t secondBin) const
+  {
+    const auto& axes = mAxes[layer];
+    const auto cell = phiBin * axes.nSecond + secondBin;
+    return mLayerBase[layer] + static_cast<std::uint32_t>(block * axes.cellCount() + cell);
+  }
+
+  /// The bucket a measurement belongs to, from its own coordinates: the
+  /// block of its time box's start.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint32_t bucketAt(LayerID layer, std::uint32_t timePS, Scalar phi, Scalar second) const { return bucket(layer, blockOfPS(timePS), phiBinOf(layer, phi), secondBinOf(layer, second)); }
+
+  /// Blocks a slice of \a widthPS covers, 0 for one slice over the
+  /// timeframe; at least one block.
+  [[nodiscard]] std::int32_t blocksPerSlice(std::int64_t widthPS) const
+  {
+    if (widthPS <= 0) {
+      return mBlockCount;
+    }
+    return static_cast<std::int32_t>(std::clamp<std::int64_t>(ceilDiv(widthPS * mPartsPerPS, mBlockWidth), 1, mBlockCount));
+  }
+
+  /// Widen a core block range by a halo of \a haloPS, in whole blocks,
+  /// clipped at the ends of the timeframe -- the hard input boundary of the
+  /// slicing.
+  [[nodiscard]] GridSlice slice(BlockRange core, std::int64_t haloPS) const
+  {
+    const auto pad = static_cast<std::int32_t>(std::clamp<std::int64_t>(ceilDiv(std::max<std::int64_t>(haloPS, 0) * mPartsPerPS, mBlockWidth), 0, mBlockCount));
+    const auto clamp = [this](std::int32_t block) {
+      if (block < 0) {
+        return 0;
+      }
+      return block > mBlockCount ? mBlockCount : block;
+    };
+    return {.core = {clamp(core.begin), clamp(core.end)}, .halo = {clamp(core.begin - pad), clamp(core.end + pad)}};
+  }
+
+ private:
+  /// \a a / \a b rounded up, \a a >= 0, \a b > 0.
+  [[nodiscard]] static constexpr std::int64_t ceilDiv(std::int64_t a, std::int64_t b) { return (a + b - 1) / b; }
+
+  /// A block width of zero means one block over the whole timeframe, which is
+  /// what a tracker that does not want to slice at all asks for.
+  [[nodiscard]] static std::int64_t chosenBlockWidth(std::int64_t span, const GridParams& params)
+  {
+    const std::int64_t width = params.blockWidth > 0 ? params.blockWidth : span;
+    return width > 0 ? width : 1;
+  }
+
+  [[nodiscard]] static std::int32_t blocksCovering(std::int64_t span, std::int64_t width) { return span > width ? static_cast<std::int32_t>(ceilDiv(span, width)) : 1; }
+
+  // Declaration order is initialisation order, and the block count is derived
+  // from the width -- so the width comes first here, not for tidiness.
+  std::int64_t mPartsPerPS = 1;
+  std::int64_t mBlockOrigin = 0;
+  std::int64_t mBlockWidth = 1;
+  std::int32_t mBlockCount = 1;
+  LayerAxes mAxes[kLayerCount]{};
+  std::uint32_t mLayerBase[kLayerCount + 1]{};
+  FrameTiming mFrames[kLayerCount]{};
+  bool mOverflow = false;
+};
+
+/// One seed's question, in the coordinates the grid bins.
+///
+/// Everything here is arithmetic on a `LayerPairWindow` the host computed once
+/// for this layer pair and this iteration: the seed contributes its time box,
+/// an azimuth and its r and z, and nothing transcendental happens per seed.
+///
+/// The time is a closed range of the candidates' box starts, `timePS`, and a
+/// time the candidates' boxes must end after: the rows a box overlaps.
+/// The range is signed and may begin before
+/// the timeframe.
+struct CandidateWindow {
+  std::int64_t earliestPS = 0;
+  std::int64_t latestPS = 0;
+  std::uint32_t afterPS = 0U; ///< a candidate's box must end after this
+  Scalar phiCentre = 0.F;     ///< in [0, 2pi)
+  Scalar phiHalfWidth = 0.F;
+  Scalar secondCentre = 0.F;
+  Scalar secondHalfWidth = 0.F;
+};
+
+/// A range of the target's second coordinate, as the grid queries it.
+struct SecondRange {
+  Scalar centre = 0.F;
+  Scalar halfWidth = 0.F;
+};
+
+struct SecondRun {
+  Scalar low = 0.F;
+  Scalar high = 0.F;
+};
+
+/// The target's second coordinate a seed can reach across a barrel <-> disc
+/// pair, from the fields `crossingPairWindow`
+/// stored.
+///
+/// The landing point is monotonic in the vertex z, in the target's position
+/// and in the seed's own coordinate separately, so its extremes lie at the
+/// corners of those three ranges. Barrel -> disc divides by `z_i - z_v`: a
+/// vertex level with the seed, or beyond it as seen from the disc, sends no
+/// track through the seed to the disc, and the landing radius grows without
+/// bound as the vertex approaches the seed. Such a corner opens the window to
+/// the disc's outer edge. With no corner valid, the whole extent is returned,
+/// which the seed's source interval normally prevents from being asked.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() SecondRange crossingRange(const LayerPairWindow& pair, Scalar seedR, Scalar seedZ, Scalar vertexLow, Scalar vertexHigh, Scalar padding)
+{
+  const Scalar vertices[2] = {vertexLow, vertexHigh};
+  const Scalar targets[2] = {pair.targetLow, pair.targetHigh};
+  const Scalar spreads[2] = {-pair.seedSpread, pair.seedSpread};
+  const bool toDisc = pair.kind == PairKind::kBarrelToDisc;
+  Scalar low = pair.targetSecondMax;
+  Scalar high = pair.targetSecondMin;
+  bool open = false;
+  for (const Scalar spread : spreads) {
+    for (const Scalar vertex : vertices) {
+      for (const Scalar target : targets) {
+        Scalar landing = 0.F;
+        if (toDisc) {
+          const Scalar z = seedZ + spread;
+          const Scalar lever = z - vertex;
+          if (!(lever * (target - z) > 0.F)) {
+            open = true;
+            continue;
+          }
+          landing = seedR * (target - vertex) / lever;
+        } else {
+          landing = vertex + ((seedZ - vertex) * target / (seedR + spread));
+        }
+        low = landing < low ? landing : low;
+        high = landing > high ? landing : high;
+      }
+    }
+  }
+  if (open) {
+    high = pair.targetSecondMax;
+  }
+  if (high < low) {
+    low = pair.targetSecondMin;
+    high = pair.targetSecondMax;
+  }
+  return {.centre = 0.5F * (low + high), .halfWidth = (0.5F * (high - low)) + padding};
+}
+
+[[nodiscard]] GPUhdi() GPUAlwaysInline() SecondRange crossingRange(const LayerPairWindow& pair, Scalar seedR, Scalar seedZ) { return crossingRange(pair, seedR, seedZ, pair.vertexLow, pair.vertexHigh, pair.secondHalfWidth); }
+
+/// One source/link/vertex interval. Its host-derived half-width is shared by
+/// the timeframe's vertices; only the centre and the vertex's own z reach are
+/// evaluated here.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() SecondRange vertexSecondRange(const LayerPairWindow& pair, const VertexPairWindow& bounds, Scalar seedR, Scalar seedZ, Scalar vertexZ, Scalar vertexVarZ, Scalar nSigma)
+{
+  if (pair.kind != PairKind::kBarrel && pair.kind != PairKind::kDisc) {
+    const Scalar reach = nSigma * o2::gpu::CAMath::Sqrt(vertexVarZ);
+    return crossingRange(pair, seedR, seedZ, vertexZ - reach, vertexZ + reach, bounds.secondPadding);
+  }
+  const Scalar vertexTerm = bounds.vertexLever * bounds.vertexLever * vertexVarZ;
+  const Scalar halfWidth = (nSigma * o2::gpu::CAMath::Sqrt(vertexTerm + bounds.secondVariance)) + bounds.secondPadding;
+  if (pair.kind == PairKind::kBarrel) {
+    return {.centre = vertexZ + ((seedZ - vertexZ) * bounds.secondScale), .halfWidth = halfWidth};
+  }
+  const Scalar centre = seedR * (bounds.targetPosition - vertexZ) / (bounds.sourcePosition - vertexZ);
+  return {.centre = centre, .halfWidth = halfWidth};
+}
+
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool secondRangeContains(const SecondRange& range, Scalar second) { return o2::gpu::CAMath::Abs(second - range.centre) <= range.halfWidth; }
+
+/// Assemble one from a precomputed pair window and a seed.
+///
+/// \a seedR and \a seedZ are the seed's shipped radius and z: a same-kind pair
+/// reads the seed's second coordinate from them, a crossing pair both.
+/// \a maxCandidateWidthPS must bound the boxes' widths over the searched rows:
+/// a box overlapping the seed's starts less than its own width before it.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() CandidateWindow candidateWindow(const LayerPairWindow& pair, const TimeEstPS& seed, Scalar seedPhi, Scalar seedR, Scalar seedZ, std::uint32_t maxCandidateWidthPS)
+{
+  SecondRange second;
+  if (pair.kind == PairKind::kBarrel || pair.kind == PairKind::kDisc) {
+    const Scalar seedSecond = pair.kind == PairKind::kBarrel ? seedZ : seedR;
+    second = {.centre = (pair.secondScale * seedSecond) + pair.secondOffset, .halfWidth = pair.secondHalfWidth};
+  } else {
+    second = crossingRange(pair, seedR, seedZ);
+  }
+  return {
+    .earliestPS = static_cast<std::int64_t>(seed.lower()) - static_cast<std::int64_t>(maxCandidateWidthPS) + 1,
+    .latestPS = static_cast<std::int64_t>(seed.upper()) - 1,
+    .afterPS = seed.lower(),
+    .phiCentre = seedPhi,
+    .phiHalfWidth = pair.phiHalfWidth,
+    .secondCentre = second.centre,
+    .secondHalfWidth = second.halfWidth,
+  };
+}
+
+/// Apply the exact spatial cuts after the grid cells have supplied a
+/// conservative candidate set. Both azimuths must be in [0, 2pi).
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool spatiallyCompatible(const CandidateWindow& window, Scalar phi, Scalar second)
+{
+  const Scalar deltaPhi = o2::gpu::GPUCommonMath::Abs(o2::math_utils::detail::toPMPi<Scalar>(phi - window.phiCentre));
+  const Scalar deltaSecond = o2::gpu::GPUCommonMath::Abs(second - window.secondCentre);
+  return deltaPhi <= window.phiHalfWidth && deltaSecond <= window.secondHalfWidth;
+}
+
+/// The cells one query visits: a run of whole blocks, at most two runs of phi
+/// cells split where the window crosses zero, and one run of second-coordinate
+/// cells, plus the box-start bracket searched inside each.
+struct CellSpan {
+  std::int64_t earliestPS = 0;
+  std::int64_t latestPS = 0;
+  std::uint32_t afterPS = 0U;
+  BlockRange blocks;
+  std::int32_t firstPhi = 0; ///< first run: [firstPhi, phiEnd)
+  std::int32_t phiEnd = 0;
+  std::int32_t wrapEnd = 0; ///< second run, after the wrap: [0, wrapEnd)
+  std::int32_t firstSecond = 0;
+  std::int32_t lastSecond = -1; ///< inclusive
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::int32_t cellCount() const { return blocks.empty() ? 0 : blocks.size() * (phiEnd - firstPhi + wrapEnd) * (lastSecond - firstSecond + 1); }
+};
+
+/// The index, bound to the columns whose order it describes.
+///
+/// It borrows both: the measurement columns and the offset table belong to the
+/// incoming message, exactly as `TimeFrame<Det>` borrows its view.
+template <DetectorLayout Det>
+class MeasurementGrid
+{
+ public:
+  using Index = std::uint32_t;
+
+  MeasurementGrid(MeasurementView measurements, const GridGeometry<Det>& grid, std::span<const Index> offsets)
+    : mMeasurements(measurements),
+      mGrid(grid),
+      mOffsets(offsets.data())
+  {
+    assert(offsets.size() == static_cast<std::size_t>(grid.bucketCount()) + 1U);
+  }
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() const GridGeometry<Det>& geometry() const { return mGrid; }
+  /// The prefix offsets the grid borrows, `bucketCount() + 1` of them.
+  [[nodiscard]] std::span<const Index> offsets() const { return {mOffsets, static_cast<std::size_t>(mGrid.bucketCount()) + 1U}; }
+
+  /// The rows of a run of whole blocks: one range, which is the property that
+  /// makes the block the outer key.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() MeasurementRange rows(LayerID layer, BlockRange blocks) const
+  {
+    if (blocks.empty()) {
+      const auto at = mGrid.bucket(layer, blocks.begin, 0, 0);
+      return {mOffsets[at], mOffsets[at]};
+    }
+    const auto first = mGrid.bucket(layer, blocks.begin, 0, 0);
+    const auto lastBucket = mGrid.layerBucketBase(layer) + static_cast<std::uint32_t>(blocks.end) * static_cast<std::uint32_t>(mGrid.axes(layer).cellCount());
+    return {mOffsets[first], mOffsets[lastBucket]};
+  }
+
+  /// The whole layer, recovered from the grid prefix offsets.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() MeasurementRange layerRows(LayerID layer) const { return rows(layer, mGrid.allBlocks()); }
+  /// The measurement columns the grid orders.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() MeasurementView measurements() const { return mMeasurements; }
+
+  /// Visit every row of \a target that could continue the seed \a window
+  /// describes, restricted to \a blocks -- a slice's halo range.
+  ///
+  /// What the visitor gets is a global row index, which is the tracking's
+  /// internal measurement ID; `Measurement::clusterIndex` remains the
+  /// back-reference to the input cluster.
+  ///
+  /// The exact time cut -- the boxes overlap -- is applied here. The exact phi and
+  /// second-coordinate cuts are the caller's, on the row's shipped azimuth and
+  /// second coordinate: what the cells did is narrow the rows it has to
+  /// evaluate.
+  ///
+  /// Rows are stored in the order this visits them -- block, phi cell,
+  /// second-coordinate cell, box start -- so a run of consecutive cells is one
+  /// range of rows. Where the window spans the whole second axis, a block's
+  /// phi run is one range; otherwise each phi cell's run of second cells is.
+  /// Either way the rows and their order are those of a cell-by-cell walk.
+  /// With \a lanes (`Lanes`), this lane's share of them, in the same order,
+  /// for a visitor without collectives.
+  ///
+  /// With a group (`WarpGroup`) the lanes walk in
+  /// step: lane `i` of `L` gets the rows `Lanes{i, L}` would, in the same
+  /// order, and every lane calls \a visit(row, has) at every step of the
+  /// group -- \a has whether the lane has a row there, \a row meaningful only
+  /// then -- the same number of times in every range and cell, so that
+  /// \a visit may call the group's collectives.
+  template <typename Visitor, typename Share = Lanes>
+  GPUhdi() void visitCandidates(LayerID target, const CandidateWindow& window, BlockRange blocks, Visitor visit, Share lanes = {}) const
+  {
+    const auto span = querySpan(target, window, blocks);
+    const auto lastSecondBin = mGrid.axes(target).nSecond - 1;
+    const bool wholeSecond = span.firstSecond == 0 && span.lastSecond == lastSecondBin;
+    for (auto block = span.blocks.begin; block < span.blocks.end; ++block) {
+      if (wholeSecond) {
+        if (span.firstPhi < span.phiEnd) {
+          visitBuckets(mGrid.bucket(target, block, span.firstPhi, 0), mGrid.bucket(target, block, span.phiEnd - 1, lastSecondBin) + 1U, span, visit, lanes);
+        }
+        if (span.wrapEnd > 0) {
+          visitBuckets(mGrid.bucket(target, block, 0, 0), mGrid.bucket(target, block, span.wrapEnd - 1, lastSecondBin) + 1U, span, visit, lanes);
+        }
+        continue;
+      }
+      forEachPhiBin(span, [&](std::int32_t phiBin) { visitSecondRun(target, block, phiBin, span.firstSecond, span.lastSecond, span, visit, lanes); });
+    }
+  }
+
+  /// Visit ordered, disjoint second-coordinate runs without visiting a row
+  /// twice when different runs clamp to or overlap the same grid cell; with
+  /// \a lanes a share or a group, as the overload above.
+  template <typename Visitor, typename Share = Lanes>
+  GPUhdi() void visitCandidates(LayerID target, const CandidateWindow& window, const SecondRun* secondRuns, std::uint32_t secondRunCount, BlockRange blocks, Visitor visit, Share lanes = {}) const
+  {
+    const auto span = querySpan(target, window, blocks);
+    for (auto block = span.blocks.begin; block < span.blocks.end; ++block) {
+      forEachPhiBin(span, [&](std::int32_t phiBin) { visitRuns(target, block, phiBin, span, secondRuns, secondRunCount, visit, lanes); });
+    }
+  }
+
+  /// The cells `visitCandidates` walks for this window.
+  ///
+  /// Public so that the study can count a query's cost (`CompleteAnatomy.h`);
+  /// the result never depends on the cells.
+  [[nodiscard]] GPUhdi() CellSpan cellSpan(LayerID target, const CandidateWindow& window, BlockRange blocks) const
+  {
+    const auto& axes = mGrid.axes(target);
+
+    CellSpan span;
+    span.earliestPS = window.earliestPS;
+    span.latestPS = window.latestPS;
+    span.afterPS = window.afterPS;
+
+    const auto firstBlock = mGrid.blockOfPS(span.earliestPS);
+    const auto lastBlock = mGrid.blockOfPS(span.latestPS);
+    span.blocks.begin = firstBlock > blocks.begin ? firstBlock : blocks.begin;
+    span.blocks.end = lastBlock < blocks.end - 1 ? lastBlock + 1 : blocks.end;
+    if (span.blocks.empty()) {
+      return span;
+    }
+
+    // No early return for a window past either end of the axis: the edge
+    // cells are clamped, not bounded. A disc's outer cell holds clusters out
+    // to its sensors' corners, and a window lying wholly beyond the nominal
+    // edge can still contain them. The exact cut rejects what does not fit.
+    span.firstSecond = mGrid.secondBinOf(target, window.secondCentre - window.secondHalfWidth);
+    span.lastSecond = mGrid.secondBinOf(target, window.secondCentre + window.secondHalfWidth);
+
+    // The phi cells as at most two runs, split where the window crosses zero:
+    // [firstPhi, phiEnd) and then [0, wrapEnd). Where the wrap falls is known
+    // before the loop, so the walk needs neither a modulo nor a per-cell
+    // wrap test.
+    span.phiEnd = axes.nPhi;
+    if (2.F * window.phiHalfWidth < (2 * std::numbers::pi_v<Scalar>)) {
+      Scalar low = window.phiCentre - window.phiHalfWidth;
+      Scalar high = window.phiCentre + window.phiHalfWidth;
+      if (low < 0.F) {
+        low += 2 * std::numbers::pi_v<Scalar>;
+      }
+      if (high >= 2 * std::numbers::pi_v<Scalar>) {
+        high -= 2 * std::numbers::pi_v<Scalar>;
+      }
+      const auto firstPhi = mGrid.phiBinOf(target, low);
+      const auto lastPhi = mGrid.phiBinOf(target, high);
+      if (!(high < low)) {
+        span.firstPhi = firstPhi;
+        span.phiEnd = lastPhi + 1;
+      } else if (lastPhi < firstPhi) {
+        span.firstPhi = firstPhi;
+        span.wrapEnd = lastPhi + 1;
+      }
+      // Otherwise the window crosses zero with both ends in one cell: the gap
+      // it leaves lies inside that cell, so every cell is visited.
+    }
+    return span;
+  }
+
+ private:
+  /// A range scanned row by row costs what it holds, a binary search per cell
+  /// what the cell's time bound selects. Up to this many rows per cell the scan
+  /// is the cheaper; denser cells -- many collisions in a block and a narrow
+  /// time bound -- keep the searches. The rows and their order are the same
+  /// either way, so this changes the cost and never the result.
+  static constexpr Index kScanRowsPerCell = 8U;
+
+  /// A query's cells, counted.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() CellSpan querySpan(LayerID target, const CandidateWindow& window, BlockRange blocks) const
+  {
+    const auto span = cellSpan(target, window, blocks);
+    countGridWork(WorkCounter::kGridQueries);
+    countGridWork(WorkCounter::kGridBlocks, static_cast<std::uint64_t>(span.blocks.empty() ? 0 : span.blocks.size()));
+    return span;
+  }
+
+  /// \a body(phiBin) over the span's phi cells: the run up to the axis's end,
+  /// then the one after the wrap.
+  template <typename Body>
+  GPUhdi() GPUAlwaysInline() static void forEachPhiBin(const CellSpan& span, const Body& body)
+  {
+    for (auto phiBin = span.firstPhi; phiBin < span.phiEnd; ++phiBin) {
+      body(phiBin);
+    }
+    for (std::int32_t phiBin = 0; phiBin < span.wrapEnd; ++phiBin) {
+      body(phiBin);
+    }
+  }
+
+  template <typename Visitor, typename Share>
+  GPUhdi() GPUAlwaysInline() void visitRuns(LayerID target, std::int32_t block, std::int32_t phiBin, const CellSpan& span, const SecondRun* secondRuns, std::uint32_t secondRunCount, Visitor& visit, Share lanes) const
+  {
+    std::int32_t previousLast = -1;
+    for (std::uint32_t i = 0; i < secondRunCount; ++i) {
+      const auto& run = secondRuns[i];
+      auto first = mGrid.secondBinOf(target, run.low);
+      const auto last = mGrid.secondBinOf(target, run.high);
+      first = first > previousLast ? first : previousLast + 1;
+      if (first <= last) {
+        visitSecondRun(target, block, phiBin, first, last, span, visit, lanes);
+      }
+      previousLast = last > previousLast ? last : previousLast;
+    }
+  }
+
+  /// One `(block, phi)` pair's second cells `[firstSecond, lastSecond]`:
+  /// consecutive buckets, because the second coordinate is the innermost key.
+  template <typename Visitor, typename Share>
+  GPUhdi() GPUAlwaysInline() void visitSecondRun(LayerID target, std::int32_t block, std::int32_t phiBin, std::int32_t firstSecond, std::int32_t lastSecond, const CellSpan& span, Visitor& visit, Share lanes) const
+  {
+    visitBuckets(mGrid.bucket(target, block, phiBin, firstSecond), mGrid.bucket(target, block, phiBin, lastSecond) + 1U, span, visit, lanes);
+  }
+
+  /// The rows of the consecutive buckets `[firstBucket, endBucket)` whose box
+  /// starts lie in the span's time bound and whose boxes end after its
+  /// `afterPS`, in storage order.
+  ///
+  /// Only a cell's rows are ordered by box start -- a run of cells is
+  /// contiguous in memory but not in time -- so the bound is either tested row
+  /// by row over the whole range, or cell by cell: a binary search for the
+  /// first row at or after `earliestPS`, and a walk from there to the first
+  /// row after `latestPS`. Either way a row is kept exactly when it lies at or
+  /// after the one and not after the other. The walk rather than a second
+  /// search, because a dense cell's time bound holds a fraction of a row on
+  /// average.
+  ///
+  /// With several \a lanes each takes every `count`-th row of the range, or
+  /// of each cell's run after its search, from its own `lane` on; a lane
+  /// past the time bound stops, as every row after it in the cell is too.
+  template <typename Visitor>
+  GPUhdi() void visitBuckets(std::uint32_t firstBucket, std::uint32_t endBucket, const CellSpan& span, Visitor& visit, Lanes lanes) const
+  {
+    const Index begin = mOffsets[firstBucket];
+    const Index end = mOffsets[endBucket];
+    countGridWork(WorkCounter::kGridRanges);
+    countGridWork(WorkCounter::kGridCells, endBucket - firstBucket);
+    countGridWork(WorkCounter::kGridRows, end - begin);
+    if (end - begin <= kScanRowsPerCell * (endBucket - firstBucket)) {
+      for (auto row = begin + lanes.lane; row < end; row += lanes.count) {
+        const std::int64_t timePS = mMeasurements.timePS[row];
+        if (timePS < span.earliestPS || span.latestPS < timePS) {
+          continue;
+        }
+        countGridWork(WorkCounter::kGridInBound);
+        visitIfCompatible(row, span, visit);
+      }
+      return;
+    }
+    countGridWork(WorkCounter::kGridSearchedCells, endBucket - firstBucket);
+    for (auto bucket = firstBucket; bucket < endBucket; ++bucket) {
+      const MeasurementRange range{.begin = mOffsets[bucket], .end = mOffsets[bucket + 1]};
+      for (auto row = lowerBound(range, span.earliestPS) + lanes.lane; row < range.end; row += lanes.count) {
+        if (span.latestPS < static_cast<std::int64_t>(mMeasurements.timePS[row])) {
+          break;
+        }
+        countGridWork(WorkCounter::kGridInBound);
+        visitIfCompatible(row, span, visit);
+      }
+    }
+  }
+
+  /// `visitBuckets` for a \a group in step: the group's lanes take the rows
+  /// `Lanes{lane, kLanes}` would, `kLanes` at a time from the range's first
+  /// row (scanned) or from each cell's first row in the bound (searched), and
+  /// every lane calls \a visit(row, has) at every step. A searched cell ends
+  /// at the first step whose first row -- the same row for every lane -- is
+  /// past the time bound: the cell's rows are ordered by box start, so the
+  /// lanes past the bound within a step are its last ones. A scanned range
+  /// spans cells, whose times start again at each, so it goes to its end.
+  template <typename Visitor, typename Group>
+  GPUhdi() void visitBuckets(std::uint32_t firstBucket, std::uint32_t endBucket, const CellSpan& span, Visitor& visit, const Group& group) const
+  {
+    constexpr Index kLanes = Group::kLanes;
+    const Index lane = group.lane();
+    const Index begin = mOffsets[firstBucket];
+    const Index end = mOffsets[endBucket];
+    countGridWork(WorkCounter::kGridRanges);
+    countGridWork(WorkCounter::kGridCells, endBucket - firstBucket);
+    countGridWork(WorkCounter::kGridRows, end - begin);
+    if (end - begin <= kScanRowsPerCell * (endBucket - firstBucket)) {
+      for (Index first = begin; first < end; first += kLanes) {
+        const Index row = first + lane;
+        bool has = false;
+        if (row < end) {
+          const std::int64_t timePS = mMeasurements.timePS[row];
+          has = span.earliestPS <= timePS && timePS <= span.latestPS && compatibleInBound(row, span);
+        }
+        visit(row, has);
+      }
+      return;
+    }
+    countGridWork(WorkCounter::kGridSearchedCells, endBucket - firstBucket);
+    for (auto bucket = firstBucket; bucket < endBucket; ++bucket) {
+      const MeasurementRange range{.begin = mOffsets[bucket], .end = mOffsets[bucket + 1]};
+      for (Index first = lowerBound(range, span.earliestPS); first < range.end && !(span.latestPS < std::int64_t{mMeasurements.timePS[first]}); first += kLanes) {
+        const Index row = first + lane;
+        const bool has = row < range.end && !(span.latestPS < std::int64_t{mMeasurements.timePS[row]}) && compatibleInBound(row, span);
+        visit(row, has);
+      }
+    }
+  }
+
+  /// A row in the time bound, counted, and whether its box ends after the
+  /// span's `afterPS` (`visitIfCompatible`'s test), counted where it does.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool compatibleInBound(Index row, const CellSpan& span) const
+  {
+    countGridWork(WorkCounter::kGridInBound);
+    if (timeBoxAt(mMeasurements, row).upper() > span.afterPS) {
+      countGridWork(WorkCounter::kGridVisits);
+      return true;
+    }
+    return false;
+  }
+
+  /// A row in the bound whose box ends after the span's `afterPS`: with the
+  /// bound's end, the boxes overlap.
+  template <typename Visitor>
+  GPUhdi() void visitIfCompatible(Index row, const CellSpan& span, Visitor& visit) const
+  {
+    if (timeBoxAt(mMeasurements, row).upper() > span.afterPS) {
+      countGridWork(WorkCounter::kGridVisits);
+      visit(row);
+    }
+  }
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Index lowerBound(MeasurementRange range, std::int64_t timePS) const
+  {
+    return o2::gpu::CAAlgo::partitionPoint(range.begin, range.size(), [&](Index row) {
+      const std::int64_t start = mMeasurements.timePS[row];
+      return start < timePS;
+    });
+  }
+
+  MeasurementView mMeasurements;
+  GridGeometry<Det> mGrid;
+  const Index* mOffsets = nullptr;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_MEASUREMENTGRID_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MeasurementGridBuilder.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MeasurementGridBuilder.h
new file mode 100644
index 0000000000000..3812387fe0f66
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MeasurementGridBuilder.h
@@ -0,0 +1,202 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MeasurementGridBuilder.h
+/// \brief Writing the grid of MeasurementGrid.h: bucket assignment and the
+///        counting sort that realises the row order.
+///
+/// This is the producer's half of the index and it is host-side by nature:
+/// turning `(surface, loc0, loc1)` into a global position needs `Geometry<Det>`,
+/// which is double and lives on the host. The tracker never does it -- it
+/// receives rows already in grid order with that position shipped beside
+/// them, which is the whole point of the producer's boundary.
+///
+/// It allocates nothing. The producer asks the grid geometry how many buckets
+/// there are, allocates the prefix offsets directly in the outgoing message,
+/// and hands them here as a span. A caller can either recompute each bucket in
+/// the scatter pass or retain one bucket number per input row.
+
+#ifndef GTRK_TRACKING_MEASUREMENTGRIDBUILDER_H_
+#define GTRK_TRACKING_MEASUREMENTGRIDBUILDER_H_
+
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/MeasurementGrid.h"
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <span>
+
+namespace o2::gtrk
+{
+
+/// A measurement's global position as shipped -- Cartesian, with transverse
+/// radius and azimuth cached -- and the layer and second coordinate the grid
+/// bins it by.
+struct GridPoint {
+  LayerID layer = kInvalidLayerID;
+  Scalar x = 0.F; ///< global position [cm]
+  Scalar y = 0.F;
+  Scalar z = 0.F;
+  Scalar r = 0.F;      ///< transverse radius [cm]
+  Scalar phi = 0.F;    ///< in [0, 2pi)
+  Scalar second = 0.F; ///< z on a barrel layer, r on a disc [cm]
+};
+
+/// Where a cluster sits.
+///
+/// The sensor-local position goes through the sensor's own transform, so a
+/// tilted stave and a staggered disc ring are handled by the placement rather
+/// than by a nominal-radius approximation -- which matters here: on a tilted
+/// stave a nominal-phi binning would put rows in the wrong cell near its edge.
+///
+/// The transform is double, as all geometry is; the position narrows to float
+/// once, and radius and azimuth are derived from those floats, never from the
+/// double values. They are shipped as they are computed here, so a row's
+/// bucket and the exact cut applied to it read the same numbers.
+///
+/// \a loc0 and \a loc1 are the sensor's unrolled coordinates: on a curved
+/// sensor (the ALICE 3 VD) the point is on the cylinder at the angle loc0 /
+/// radius (`SensorSpec::unrolledToFrame`), on a flat one the local point;
+/// either at the layer's measurement depth (`Geometry::measurementDepth`).
+///
+/// The beam line's \a beamX and \a beamY are subtracted in double before the
+/// narrowing: x, y, r and phi are about the corrected beam line, as the pair
+/// cuts expect them, while
+/// z and the local position stay the detector's.
+template <DetectorLayout Det>
+[[nodiscard]] inline GridPoint gridPoint(const Geometry<Det>& geometry, SensorID chip, double loc0, double loc1, double beamX = 0., double beamY = 0.)
+{
+  double local[3] = {0., 0., 0.};
+  geometry.specOf(chip).unrolledToFrame(loc0, loc1, geometry.measurementDepth(geometry.sensor(chip).layer), local);
+  double global[3] = {0., 0., 0.};
+  geometry.toGlobal(chip, local, global);
+
+  const auto layer = geometry.sensor(chip).layer;
+  const auto x = static_cast<Scalar>(global[0] - beamX);
+  const auto y = static_cast<Scalar>(global[1] - beamY);
+  const auto z = static_cast<Scalar>(global[2]);
+  const auto r = o2::gpu::CAMath::Hypot(x, y);
+  return {.layer = layer, .x = x, .y = y, .z = z, .r = r, .phi = azimuth(x, y), .second = secondCoordinate<Det>(layer, r, z)};
+}
+
+/// A measurement's variances along z, r and r-phi.
+struct PointVariances {
+  Scalar z = 0.F;
+  Scalar r = 0.F;
+  Scalar rPhi = 0.F;
+};
+
+/// The local covariance `(varLoc0, covLoc01, varLoc1)` projected through the
+/// sensor's rotation onto the global z axis and the radial and azimuthal
+/// directions at \a point, in double as all geometry is. The local axes are
+/// the sensor's; on a curved sensor the first turns with the point, at the
+/// angle \a loc0 / radius, the second is the cylinder's axis.
+///
+/// The directions are those of the corrected beam line: r and r-phi are
+/// calibrated quantities, like the radius and azimuth they accompany.
+template <DetectorLayout Det>
+[[nodiscard]] inline PointVariances pointVariances(const Geometry<Det>& geometry, SensorID chip, double loc0, const GridPoint& point, Scalar varLoc0, Scalar covLoc01, Scalar varLoc1)
+{
+  const auto& rot = geometry.sensor(chip).rot;
+  double u[3] = {rot[0], rot[3], rot[6]}; // local axis 0, in global coordinates
+  double v[3] = {rot[1], rot[4], rot[7]}; // local axis 1
+  if (const auto& spec = geometry.specOf(chip); spec.curved()) {
+    // In the cylinder's frame: across (-sin a, cos a, 0), along (0, 0, 1).
+    const double angle = loc0 / spec.radius;
+    const double across[3] = {-std::sin(angle), std::cos(angle), 0.};
+    for (int axis = 0; axis < 3; ++axis) {
+      u[axis] = (rot[(3 * axis) + 0] * across[0]) + (rot[(3 * axis) + 1] * across[1]);
+      v[axis] = rot[(3 * axis) + 2];
+    }
+  }
+  const auto x = static_cast<double>(point.x);
+  const auto y = static_cast<double>(point.y);
+  const double r = std::hypot(x, y);
+  const double radial[3] = {r > 0. ? x / r : 1., r > 0. ? y / r : 0., 0.};
+  const double azimuthal[3] = {-radial[1], radial[0], 0.};
+  const double axial[3] = {0., 0., 1.};
+  const auto project = [&](const double (&n)[3]) {
+    const double a = (u[0] * n[0]) + (u[1] * n[1]) + (u[2] * n[2]);
+    const double b = (v[0] * n[0]) + (v[1] * n[1]) + (v[2] * n[2]);
+    return static_cast<Scalar>((static_cast<double>(varLoc0) * a * a) + (2. * static_cast<double>(covLoc01) * a * b) + (static_cast<double>(varLoc1) * b * b));
+  };
+  return {.z = project(axial), .r = project(radial), .rPhi = project(azimuthal)};
+}
+
+/// The counting sort that puts rows in `(layer, block, phi, second, time)`
+/// order, in place in the offset array itself.
+///
+/// The offsets hold the per-bucket counts, then the prefix sum turns them into
+/// starts, then `place` consumes them so that each entry ends up holding its
+/// bucket's *end*, and `finish` rotates the array one step right to turn ends
+/// back into starts. That last step is what makes the array a prefix sum again,
+/// and it is exact rather than approximately right: after it, `offsets[b]` is
+/// the first row of bucket b and `offsets[bucketCount]` is the row count.
+///
+/// The box-start key needs no work of its own: a caller that counts and
+/// places each bucket's rows in box-start order gets each bucket out in that
+/// order, a counting sort being stable.
+class MeasurementGridBuilder
+{
+ public:
+  /// \a offsets must be `GridGeometry::bucketCount() + 1` long.
+  explicit MeasurementGridBuilder(std::span<std::uint32_t> offsets) : mOffsets(offsets)
+  {
+    assert(!offsets.empty());
+    for (auto& entry : mOffsets) {
+      entry = 0;
+    }
+  }
+
+  /// Pass one, once per measurement.
+  void count(std::uint32_t bucket)
+  {
+    assert(bucket + 1 < mOffsets.size());
+    ++mOffsets[bucket];
+  }
+
+  /// Between the passes: counts become starts.
+  void prefixSum()
+  {
+    std::uint32_t running = 0;
+    for (auto& entry : mOffsets) {
+      const auto here = entry;
+      entry = running;
+      running += here;
+    }
+  }
+
+  /// Pass two, once per measurement and in the input's own order: the row this
+  /// measurement occupies in the reordered columns.
+  [[nodiscard]] std::uint32_t place(std::uint32_t bucket)
+  {
+    assert(bucket + 1 < mOffsets.size());
+    return mOffsets[bucket]++;
+  }
+
+  /// After the second pass: ends become starts again.
+  void finish()
+  {
+    for (std::size_t bucket = mOffsets.size() - 1; bucket > 0; --bucket) {
+      mOffsets[bucket] = mOffsets[bucket - 1];
+    }
+    mOffsets[0] = 0;
+  }
+
+ private:
+  std::span<std::uint32_t> mOffsets;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_MEASUREMENTGRIDBUILDER_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MeasurementRange.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MeasurementRange.h
new file mode 100644
index 0000000000000..3d52aaee76b3b
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MeasurementRange.h
@@ -0,0 +1,35 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MeasurementRange.h
+/// \brief A half-open range of measurement rows.
+
+#ifndef GTRK_TRACKING_MEASUREMENTRANGE_H_
+#define GTRK_TRACKING_MEASUREMENTRANGE_H_
+
+#include "GenericTracking/Base/Definitions.h"
+
+#include <cstdint>
+
+namespace o2::gtrk
+{
+
+struct MeasurementRange {
+  std::uint32_t begin = 0;
+  std::uint32_t end = 0;
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() constexpr std::uint32_t size() const { return end - begin; }
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() constexpr bool empty() const { return begin == end; }
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_MEASUREMENTRANGE_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MeasurementUpdate.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MeasurementUpdate.h
new file mode 100644
index 0000000000000..0c3e236febba1
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/MeasurementUpdate.h
@@ -0,0 +1,162 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MeasurementUpdate.h
+/// \brief Kalman update of a bound track state with one cluster measurement.
+
+#ifndef GTRK_TRACKING_MEASUREMENTUPDATE_H_
+#define GTRK_TRACKING_MEASUREMENTUPDATE_H_
+
+#include "GenericTracking/Tracking/BoundTrackState.h"
+#include "GenericTracking/Tracking/MathUtils.h"
+#include "GenericTracking/Tracking/Measurement.h"
+
+#include "MathUtils/detail/trigonometric.h"
+
+#include <numbers>
+
+namespace o2::gtrk
+{
+
+/// Innovations and the fit-quality increment produced by one measurement.
+///
+/// A measurement's time is its readout frame's box, which carries no
+/// information about where in the frame the particle passed: the update takes
+/// the two local coordinates alone.
+struct MeasurementUpdateResult {
+  Scalar residualLoc0 = 0.F;
+  Scalar residualLoc1 = 0.F;
+  Scalar chi2 = 0.F; ///< of (loc0, loc1), two degrees of freedom
+  /// Whether the innovation covariance was positive definite. False, and the
+  /// chi2 above is meaningless, when the predicted covariance was not
+  /// positive definite in float (`updateUsable`).
+  bool positiveDefinite = false;
+};
+
+namespace detail
+{
+
+/// Put the direction back in phi in [-pi, pi] and theta in [0, pi], the
+/// covariance as factors: reflecting theta is S P S with S = diag(1, 1, 1,
+/// -1, 1), whose factors are S U S and D -- U's entries in theta's row and
+/// column change sign. Phi wrapping and the accompanying half-turn are
+/// constant shifts and leave the covariance alone.
+GPUhdi() GPUAlwaysInline() void canonicalizeDirection(BoundTrackState& state, CovarianceFactors& factors)
+{
+  math_utils::detail::bringToPMPi<Scalar>(state.par[kTheta]);
+  if (state.theta() < 0.F) {
+    state.par[kTheta] = -state.theta();
+    state.par[kPhi] += std::numbers::pi_v<Scalar>;
+    for (int i = 0; i < kTheta; ++i) {
+      factors.upper[strictUpperIndex(i, kTheta)] = -factors.upper[strictUpperIndex(i, kTheta)];
+    }
+    for (int j = kTheta + 1; j < kNBoundParams; ++j) {
+      factors.upper[strictUpperIndex(kTheta, j)] = -factors.upper[strictUpperIndex(kTheta, j)];
+    }
+  }
+  math_utils::detail::bringToPMPi<Scalar>(state.par[kPhi]);
+}
+
+GPUhdi() GPUAlwaysInline() void applySpatialGain(BoundTrackState& state, const Scalar (&gain)[kNBoundParams], Scalar residual)
+{
+  for (int i = 0; i < kNBoundParams; ++i) {
+    state.par[i] += gain[i] * residual;
+  }
+}
+
+} // namespace detail
+
+/// A covariance's factors, and the covariance from them (CovarianceFactors).
+[[nodiscard]] GPUhdi() GPUAlwaysInline() CovarianceFactors factorCovariance(const Scalar (&cov)[kBoundCovSize])
+{
+  CovarianceFactors factors;
+  detail::factorUD(cov, factors.upper, factors.diagonal);
+  return factors;
+}
+
+GPUhdi() GPUAlwaysInline() void covarianceFromFactors(const CovarianceFactors& factors, Scalar (&cov)[kBoundCovSize]) { detail::covarianceFromUD(factors.upper, factors.diagonal, cov); }
+
+/// Update of a bound state with (loc0, loc1), its covariance as factors: the
+/// factors themselves are updated (Bierman), and `state.cov` is not touched.
+///
+/// The spatial measurement covariance is first whitened into two independent
+/// scalar observations: R = L D L^T, and applying L^-1 to measurement and
+/// model removes covLoc01 without rotating the track state. Sequential scalar
+/// updates are then algebraically the joint update, and the joint chi2 is the
+/// sum of the two scalar ones, each residual squared over its innovation
+/// variance. A precise measurement produces its small posterior variance by
+/// multiplication and division instead of subtracting `K H P` from `P`.
+///
+/// With \a Determinant, \a determinant gets the innovation covariance's
+/// determinant over (loc0, loc1), det(H P H^T + R) [cm^4]: the product of the
+/// two innovations.
+template <bool Determinant = false>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() MeasurementUpdateResult updateWithMeasurement(BoundTrackState& state, CovarianceFactors& factors, const Measurement& measurement, [[maybe_unused]] Scalar* determinant = nullptr)
+{
+  MeasurementUpdateResult result;
+  result.residualLoc0 = measurement.loc0 - state.loc0();
+  result.residualLoc1 = measurement.loc1 - state.loc1();
+
+  Scalar observation[kNBoundParams]{};
+  Scalar gain[kNBoundParams]{};
+  observation[kLoc0] = 1.F;
+  const Scalar residual0 = result.residualLoc0;
+  const Scalar innovation0 = detail::updateUD(factors.upper, factors.diagonal, observation, measurement.varLoc0, gain);
+  detail::applySpatialGain(state, gain, residual0);
+
+  const Scalar correlation = measurement.covLoc01 / measurement.varLoc0;
+  const Scalar conditionalLoc1Variance = measurement.varLoc1 - correlation * measurement.covLoc01;
+  observation[kLoc0] = -correlation;
+  observation[kLoc1] = 1.F;
+  const Scalar residual1 = (measurement.loc1 - correlation * measurement.loc0) - (state.loc1() - correlation * state.loc0());
+  const Scalar innovation1 = detail::updateUD(factors.upper, factors.diagonal, observation, conditionalLoc1Variance, gain);
+  detail::applySpatialGain(state, gain, residual1);
+
+  result.chi2 = (residual0 * residual0 / innovation0) + (residual1 * residual1 / innovation1);
+  // The whitening has determinant one and the second observation is
+  // conditioned on the first: their innovations multiply to det V.
+  if constexpr (Determinant) {
+    *determinant = innovation0 * innovation1;
+  }
+  // The comparisons fail for NaN. The chi2's own sign is not the test: a
+  // near-zero residual's quadratic form can round to a tiny negative number
+  // under a sound covariance, and that is a perfect update, not a broken one.
+  result.positiveDefinite = innovation0 > 0.F && innovation1 > 0.F;
+  detail::canonicalizeDirection(state, factors);
+  return result;
+}
+
+/// Whether \a update was a measurement of the track the posterior \a factors
+/// describe.
+///
+/// A predicted covariance that is not positive definite -- a prior's float P
+/// can be, factors that start from one carry it -- gives an innovation that is
+/// not positive, a chi2 that is negative or NaN, or a posterior with a
+/// variance that is not positive (NaN included). Either way the update is not
+/// a measurement of this track: a filter pass fails on it, and a road fit
+/// that let a negative chi2 through its cut would rank it first. Positive D is a positive-definite posterior, every
+/// variance a sum of positive terms. The comparisons are written so that NaN
+/// fails them.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool updateUsable(const MeasurementUpdateResult& update, const CovarianceFactors& factors)
+{
+  // NaN, spelled without a self-comparison or a `Finite` that is device-only
+  // (and a constant under fast math). An infinite chi2 passes here and fails
+  // every cut it meets; a tiny negative one from rounding is a perfect update.
+  const bool chi2IsNaN = !(update.chi2 >= 0.F) && !(update.chi2 < 0.F);
+  if (!update.positiveDefinite || chi2IsNaN) {
+    return false;
+  }
+  return positiveDiagonal(factors);
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_MEASUREMENTUPDATE_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Neighbour.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Neighbour.h
new file mode 100644
index 0000000000000..a07fe15094e65
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Neighbour.h
@@ -0,0 +1,45 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Neighbour.h
+/// \brief A neighbour as SoA columns: the predecessor of the triplet that
+///        emitted it.
+///
+/// The neighbour stage runs one element per triplet `T2` and emits the
+/// triplets `T1` it continues, so the target is the element and only the
+/// predecessor is stored. The road walk
+/// (`RoadCount.h`) reads exactly this: each triplet's stored predecessors.
+
+#ifndef GTRK_TRACKING_NEIGHBOUR_H_
+#define GTRK_TRACKING_NEIGHBOUR_H_
+
+#include <memlayout/wrapper.h>
+
+#include <cstdint>
+
+namespace o2::gtrk
+{
+
+// As for TrackletT: upstream's `apply` macro also uses the member names as
+// enum constants.
+// NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members,cppcoreguidelines-missing-std-forward,readability-identifier-naming)
+template <template <class> class C>
+struct NeighbourT {
+  MEMLAYOUT_APPLY(NeighbourT, from)
+  C<std::uint32_t> from; ///< index of the predecessor triplet `T1`, whose second tracklet is this triplet's first
+};
+// NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members,cppcoreguidelines-missing-std-forward,readability-identifier-naming)
+
+using Neighbour = NeighbourT<memlayout::value>;
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_NEIGHBOUR_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/NeighbourCut.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/NeighbourCut.h
new file mode 100644
index 0000000000000..76b6759149b00
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/NeighbourCut.h
@@ -0,0 +1,115 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file NeighbourCut.h
+/// \brief The cuts two neighbouring triplets pass.
+///
+/// Triplets `a b c` and `b c d`, on links `a -> b`, `b -> c` and `c -> d`,
+/// are neighbours when they pass, cheapest first:
+///
+/// 1. the agreement of the two stored curvatures;
+/// 2. the boxes of `a` and `d` overlap;
+/// 3. the adjacent-triplet fit's chi2, three degrees of freedom.
+///
+/// The curvature agreement is the caller's (`neighbourCurvatureCompatible`),
+/// the others are `neighbourCompatible`'s.
+///
+/// Every tolerance follows from the scattering, the measurements' errors and
+/// pT_min, with the iteration's `nSigma`.
+
+#ifndef GTRK_TRACKING_NEIGHBOURCUT_H_
+#define GTRK_TRACKING_NEIGHBOURCUT_H_
+
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/TripletCut.h"
+#include "GenericTracking/Tracking/TripletFit.h"
+#include "GenericTracking/Tracking/WorkCounters.h"
+
+#include "GPUCommonMath.h"
+
+namespace o2::gtrk
+{
+
+/// Both triplets fit the 3D curvature of one helix, so the two agree within
+/// `n` sigma of their difference. The shared `b` and `c` correlate them
+/// negatively -- `c` ends the first triplet and bends the second, `b` the
+/// reverse -- so the variances' sum is not a bound; `(sigma_1 + sigma_2)^2`,
+/// correlation -1, is. The adjacent fit then takes the correlation exactly.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool neighbourCurvatureCompatible(const IterationParameters<Det>& parameters, Scalar firstCurvature, Scalar firstVariance, Scalar secondCurvature, Scalar secondVariance)
+{
+  const Scalar difference = firstCurvature - secondCurvature;
+  const Scalar nSigma = parameters.pairCut.nSigma;
+  const Scalar bound = firstVariance + secondVariance + (2.F * o2::gpu::CAMath::Sqrt(firstVariance * secondVariance));
+  return difference * difference <= nSigma * nSigma * bound;
+}
+
+/// The first and the fourth measurement's boxes overlap: with the triplets'
+/// pairs, the four boxes share a time.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool neighbourTimeCompatible(const TimedPoint& first, const TimedPoint& fourth) { return first.time.isCompatible(fourth.time); }
+
+namespace detail
+{
+
+/// The adjacent fit's outcome against its chi2 cut; \a fit receives it when it
+/// passes.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool neighbourChi2Compatible(const IterationParameters<Det>& parameters, bool fitted, const TripletFitResult& result, TripletFitResult& fit)
+{
+  if (!fitted) {
+    countWork(WorkCounter::kNeighbourFitFailed);
+    return false;
+  }
+  if (!(result.chi2 <= parameters.neighbourChi2Max)) {
+    countWork(WorkCounter::kNeighbourChi2);
+    return false;
+  }
+  fit = result;
+  return true;
+}
+
+} // namespace detail
+
+/// Every cut after the curvature agreement; \a fit receives the adjacent fit
+/// when all pass. `b` and `c` lie on \a secondLayer and \a thirdLayer. \a
+/// secondScale and \a thirdScale multiply the scattering at `b` and `c`: the
+/// iteration's kink allowance where the triplet with that middle point is
+/// kinked, 1 otherwise. Both triplets' kink terms are made from the points,
+/// past the time cut: `a b c`'s for this
+/// candidate, `b c d`'s into \a bcd at the first candidate that needs them
+/// (\a made, and \a valid with `makeKinkTerms`' result), which the caller
+/// keeps for the others of the same triplet. The terms are the triplet fit's
+/// own: the same function of the same points.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool neighbourCompatible(const IterationParameters<Det>& parameters, LayerID secondLayer, LayerID thirdLayer, const TimedPoint& a, const TimedPoint& b, const TimedPoint& c, const TimedPoint& d, KinkTerms& bcd, bool& made, bool& valid, TripletFitResult& fit, Scalar secondScale, Scalar thirdScale)
+{
+  if (!neighbourTimeCompatible(a, d)) {
+    countWork(WorkCounter::kNeighbourTime);
+    return false;
+  }
+  countWork(WorkCounter::kNeighbourFits);
+  TripletFitResult result;
+  bool fitted = false;
+  {
+    const WorkTimer timer{WorkCounter::kNeighbourFitNS};
+    if (!made) {
+      valid = makeKinkTerms(b.point, c.point, d.point, bcd);
+      made = true;
+    }
+    KinkTerms abc;
+    fitted = valid && makeKinkTerms(a.point, b.point, c.point, abc) && fitAdjacentTriplets(abc, bcd, a.point, b.point, c.point, d.point, secondLayer, thirdLayer, parameters.scattering, parameters.pairCut, result, secondScale, thirdScale);
+  }
+  return detail::neighbourChi2Compatible(parameters, fitted, result, fit);
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_NEIGHBOURCUT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/NeighbourStage.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/NeighbourStage.h
new file mode 100644
index 0000000000000..b2bb3399d107b
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/NeighbourStage.h
@@ -0,0 +1,191 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file NeighbourStage.h
+/// \brief The neighbour stage's per-triplet function.
+
+#ifndef GTRK_TRACKING_NEIGHBOURSTAGE_H_
+#define GTRK_TRACKING_NEIGHBOURSTAGE_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/Neighbour.h"
+#include "GenericTracking/Tracking/NeighbourCut.h"
+#include "GenericTracking/Tracking/OrderedRoadCounts.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/TrackletPaths.h"
+#include "GenericTracking/Tracking/Triplet.h"
+#include "GenericTracking/Tracking/TripletEndIndex.h"
+#include "GenericTracking/Tracking/WorkCounters.h"
+
+#include <cstddef>
+
+namespace o2::gtrk
+{
+
+/// Emit every predecessor of one triplet `T2 = (b -> c, c -> d)`: the
+/// triplets `T1 = (a -> b, b -> c)` ending with `T2.first` that pass the
+/// neighbour cut, in the end index's order, which is the arena's.
+///
+/// The stage is a pure function of its inputs: a backend may run an element
+/// twice, once to count and once to emit. The measurements `b`, `c` and `d`
+/// are read once per element; each candidate adds `a`.
+/// With \a readyLevels (always, in the trackers) generation follows the
+/// layers' order: predecessor levels are final, only the highest accepted
+/// stratum is emitted, and this element's level is written; without (the
+/// tests' all-edges graph) every predecessor that passes is. \a roadCounts
+/// needs \a readyLevels; its flags are initialized once before generation.
+/// A repeated element gives the same result: counts are overwritten and marks
+/// are idempotent.
+template <DetectorLayout Det>
+class NeighbourStage
+{
+ public:
+  using Index = typename StageOutput<NeighbourT>::Index;
+
+  // The delegating constructor retains this output for later level writes.
+  // NOLINTBEGIN(readability-non-const-parameter)
+  NeighbourStage(const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const StageOutput<TrackletT>& tracklets, const StageOutput<TripletT>& triplets, const TripletEndIndex& ending, TrackletPathBounds paths, std::uint32_t* readyLevels = nullptr, OrderedRoadCounts roadCounts = {})
+    : NeighbourStage(&parameters, &frame, tracklets.view(), triplets.view(), ending.offsets(), ending.triplets(), paths, readyLevels, roadCounts)
+  {
+  }
+  // NOLINTEND(readability-non-const-parameter)
+
+  /// The same stage over inputs wherever they are -- a device's copies:
+  /// every argument is only stored. The end
+  /// index is `trackletCount + 1` offsets and the triplet indices they delimit.
+  NeighbourStage(const IterationParameters<Det>* parameters, const TimeFrame<Det>* frame, TrackletConstView tracklets, TripletConstView triplets, const Index* endOffsets, const Index* endTriplets, TrackletPathBounds paths, std::uint32_t* readyLevels = nullptr, OrderedRoadCounts roadCounts = {})
+    : mParameters(parameters),
+      mFrame(frame),
+      mTracklets(tracklets),
+      mTriplets(triplets),
+      mEndOffsets(endOffsets),
+      mEndTriplets(endTriplets),
+      mPaths(paths),
+      mReadyLevels(readyLevels),
+      mRoadCounts(roadCounts)
+  {
+  }
+
+  template <typename Emitter>
+  GPUdi() void operator()(Index element, Emitter& emitter) const
+  {
+    if (mReadyLevels != nullptr) {
+      mReadyLevels[element] = 1U;
+    }
+    if (mRoadCounts.roads != nullptr) {
+      mRoadCounts.base(element, mTracklets, mTriplets);
+    }
+    const Index shared = mTriplets.first[element];
+    const Index begin = mEndOffsets[shared];
+    const Index end = mEndOffsets[shared + 1U];
+    countWork(WorkCounter::kNeighbourTriplets);
+    countWork(WorkCounter::kNeighbourCandidates, end - begin);
+    if (begin == end) {
+      return;
+    }
+    const Index last = mTriplets.second[element];
+    // Only triplets on a triplet path of minClusters, and only their
+    // neighbours on one too.
+    if (!mPaths.onPath(shared, last)) {
+      return;
+    }
+    const std::size_t secondLink = mTracklets.link[shared];
+    const LayerID secondLayer = mParameters->linkSources[secondLink];
+    const LayerID thirdLayer = mParameters->linkTargets[secondLink];
+    const Scalar curvature = mTriplets.curvature[element];
+    const Scalar varCurvature = mTriplets.varCurvature[element];
+    // A kinked triplet's middle point takes the kink allowance in the adjacent
+    // fit; two kinked triplets never neighbour.
+    const bool kinked = mTriplets.kinked[element] != 0U;
+    const Scalar thirdScale = kinked ? mParameters->graphKinkScale2 : 1.F;
+    const auto columns = mFrame->measurements();
+    const auto b = timedPointAt(columns, mTracklets.source[shared]);
+    const auto c = timedPointAt(columns, mTracklets.target[shared]);
+    const auto d = timedPointAt(columns, mTracklets.target[last]);
+
+    // This triplet's kink terms, made at its first candidate to need them.
+    KinkTerms terms;
+    bool termsMade = false;
+    bool termsValid = false;
+
+    std::uint32_t highest = 0U;
+    if (mReadyLevels != nullptr) {
+      for (Index candidate = begin; candidate < end; ++candidate) {
+        const auto level = mReadyLevels[mEndTriplets[candidate]];
+        highest = level > highest ? level : highest;
+      }
+    }
+    for (auto stratum = highest;; --stratum) {
+      bool accepted = false;
+      std::uint64_t roads = 0U;
+      for (Index candidate = begin; candidate < end; ++candidate) {
+        const Index from = mEndTriplets[candidate];
+        if (mReadyLevels != nullptr && mReadyLevels[from] != stratum) {
+          continue;
+        }
+        if (std::uint32_t{mPaths.prefix[mTriplets.first[from]]} + 1U + mPaths.suffix[last] < mPaths.minClusters) {
+          continue;
+        }
+        const bool fromKinked = mTriplets.kinked[from] != 0U;
+        if (kinked && fromKinked) {
+          countWork(WorkCounter::kNeighbourBothKinked);
+          continue;
+        }
+        if (!neighbourCurvatureCompatible(*mParameters, mTriplets.curvature[from], mTriplets.varCurvature[from], curvature, varCurvature)) {
+          countWork(WorkCounter::kNeighbourCurvature);
+          continue;
+        }
+        const Index first = mTriplets.first[from];
+        const auto a = timedPointAt(columns, mTracklets.source[first]);
+        TripletFitResult fit;
+        if (!neighbourCompatible(*mParameters, secondLayer, thirdLayer, a, b, c, d, terms, termsMade, termsValid, fit, fromKinked ? mParameters->graphKinkScale2 : 1.F, thirdScale)) {
+          continue;
+        }
+        emitter.emit(Neighbour{.from = from});
+        if (mRoadCounts.roads != nullptr) {
+          mRoadCounts.add(from, roads);
+        }
+        accepted = true;
+      }
+      if (mReadyLevels == nullptr) {
+        break;
+      }
+      if (accepted) {
+        mReadyLevels[element] = stratum + 1U;
+        if (mRoadCounts.roads != nullptr) {
+          mRoadCounts.finish(element, roads);
+        }
+        break;
+      }
+      if (stratum <= 1U) {
+        break;
+      }
+    }
+  }
+
+ private:
+  const IterationParameters<Det>* mParameters = nullptr;
+  const TimeFrame<Det>* mFrame = nullptr;
+  TrackletConstView mTracklets;
+  TripletConstView mTriplets;
+  const Index* mEndOffsets = nullptr;
+  const Index* mEndTriplets = nullptr;
+  TrackletPathBounds mPaths;
+  std::uint32_t* mReadyLevels = nullptr; ///< only with topologically ordered generation
+  OrderedRoadCounts mRoadCounts;         ///< optional, only with readyLevels
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_NEIGHBOURSTAGE_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/OrderedRoadCounts.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/OrderedRoadCounts.h
new file mode 100644
index 0000000000000..c835a9ab85239
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/OrderedRoadCounts.h
@@ -0,0 +1,76 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file OrderedRoadCounts.h
+/// \brief The road counts the neighbour stage writes in layer order.
+
+#ifndef GTRK_TRACKING_ORDEREDROADCOUNTS_H_
+#define GTRK_TRACKING_ORDEREDROADCOUNTS_H_
+
+#include "GenericTracking/Tracking/MeasurementRange.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/Triplet.h"
+
+#include "GPUCommonMath.h"
+
+#include <cstdint>
+#include <limits>
+
+namespace o2::gtrk
+{
+
+/// Whether \a triplet's innermost row is the slice's own: in the core of its
+/// first tracklet's source layer.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool roadOwned(TrackletConstView tracklets, TripletConstView triplets, const LayerID* linkSources, const MeasurementRange* core, std::uint32_t triplet)
+{
+  const auto first = triplets.first[triplet];
+  const auto row = tracklets.source[first];
+  const auto range = core[linkSources[tracklets.link[first]]];
+  return row >= range.begin && row < range.end;
+}
+
+/// A road \a sum as a 32-bit count: saturated, and \a overflow raised,
+/// beyond it -- roads are never truncated silently.
+[[nodiscard]] GPUdi() std::uint32_t saturatedRoads(std::uint64_t sum, std::uint32_t* overflow)
+{
+  constexpr std::uint64_t kLargest = std::numeric_limits<std::uint32_t>::max();
+  if (sum > kLargest) {
+    o2::gpu::CAMath::AtomicMax(overflow, std::uint32_t{1U});
+    return static_cast<std::uint32_t>(kLargest);
+  }
+  return static_cast<std::uint32_t>(sum);
+}
+
+/// Count roads while generating neighbours in layer order. Predecessor counts
+/// are final before this element runs. Flags and overflow are initialized once
+/// before the pass; replaying it overwrites counts and repeats idempotent marks.
+/// A default instance (no `roads`) counts nothing.
+struct OrderedRoadCounts {
+  std::uint32_t* roads = nullptr;
+  std::uint32_t* successorAbove = nullptr;
+  std::uint32_t* overflow = nullptr;
+  const LayerID* linkSources = nullptr;
+  const MeasurementRange* core = nullptr;
+
+  GPUdi() void base(std::uint32_t element, TrackletConstView tracklets, TripletConstView triplets) const { roads[element] = roadOwned(tracklets, triplets, linkSources, core, element) ? 1U : 0U; }
+
+  GPUdi() void add(std::uint32_t predecessor, std::uint64_t& sum) const
+  {
+    sum += roads[predecessor];
+    o2::gpu::CAMath::AtomicMax(successorAbove + predecessor, std::uint32_t{1U});
+  }
+
+  GPUdi() void finish(std::uint32_t element, std::uint64_t sum) const { roads[element] = saturatedRoads(sum, overflow); }
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_ORDEREDROADCOUNTS_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/PairCut.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/PairCut.h
new file mode 100644
index 0000000000000..2ba54644deb75
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/PairCut.h
@@ -0,0 +1,855 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file PairCut.h
+/// \brief The exact spatial cuts a tracklet passes.
+///
+/// Two tests on the measured positions, in the frame of the corrected beam
+/// line: a common helix pitch from the vertex to both measurements, and the
+/// curvature of the circle through the beam point and both measurements. One
+/// expression serves every kind of layer pair, and each measurement's own
+/// position and errors enter rather than a layer's nominal ones.
+///
+/// The cheap transverse test runs first. Only its survivors pay for the
+/// division and arcsines of the helix-pitch test. The loop over layers that
+/// multiple scattering needs happens once per source and vertex, in
+/// `sourceScattering`.
+///
+/// The iteration's cut and the vertex are separate arguments: one source is
+/// tested against every vertex seed compatible with it in time, so the vertex
+/// changes within one source's work while the cut stays the iteration's.
+
+#ifndef GTRK_TRACKING_PAIRCUT_H_
+#define GTRK_TRACKING_PAIRCUT_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/MathUtils.h"
+#include "GenericTracking/Tracking/SearchWindow.h"
+#include "GenericTracking/Tracking/WorkCounters.h"
+
+#include "GPUCommonMath.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <span>
+#include <stdexcept>
+
+namespace o2::gtrk
+{
+
+/// A layer as multiple scattering sees it: where it is, how far it extends,
+/// and how much it scatters.
+///
+/// `k` is the Highland factor at normal incidence, `(0.0136 GeV)^2 x (1 +
+/// 0.038 ln x)^2` for the layer's average `x = x/X0`, so that a crossing's
+/// `theta0^2` is `k` times the path factor over `p^2`.
+struct ScatteringLayer {
+  Scalar position = 0.F; ///< barrel radius, or disc z [cm]
+  Scalar low = 0.F;      ///< extent along the other axis: stave z, or disc r [cm]
+  Scalar high = 0.F;
+  Scalar k = 0.F; ///< [GeV^2]
+};
+
+/// A passive scatterer as multiple scattering sees it (`PassiveSpec`): a
+/// layer's fields, and its kind, which device code cannot read off the
+/// layout's constexpr array with a run-time index.
+struct PassiveScatterer {
+  ScatteringLayer at;
+  bool barrel = true;
+};
+
+/// Every layer and passive scatterer of `Det`, built once at initialisation
+/// from their material budgets; the stages read only this.
+template <DetectorLayout Det>
+struct ScatteringTable {
+  static constexpr std::size_t kLayerCount = static_cast<std::size_t>(Detector<Det>::nLayers);
+  static constexpr std::size_t kPassiveCount = static_cast<std::size_t>(Detector<Det>::nPassives);
+  ScatteringLayer layers[kLayerCount]{};
+  /// One slot even without passives: a C array cannot be empty.
+  PassiveScatterer passives[kPassiveCount > 0 ? kPassiveCount : 1]{};
+  static_assert(kPassiveCount <= 64U, "a set of passives is a bit each of a 64-bit mask");
+  /// Every passive, a bit each: the set `betweenScattering` takes by default.
+  static constexpr std::uint64_t kAllPassives = kPassiveCount == 64U ? ~std::uint64_t{0U} : (std::uint64_t{1U} << kPassiveCount) - 1U;
+  /// Per layer, the passives no segment of a layout link into it, or out of
+  /// it, can cross, a bit each (`passiveCanLieAcross`):
+  /// the ones `visitPassivesBetween` need not try for a triplet's or a pair of
+  /// triplets' segments. None, so every passive tried, unless
+  /// `scatteringTable` found them.
+  std::uint64_t notInto[kLayerCount]{};
+  std::uint64_t notOutOf[kLayerCount]{};
+  /// The passives a segment of a link into \a layer can cross.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint64_t into(LayerID layer) const { return kAllPassives & ~notInto[layer]; }
+  /// The passives a segment of a link out of \a layer can cross.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint64_t outOf(LayerID layer) const
+  {
+    return kAllPassives & ~notOutOf[layer]; // NOLINT(clang-analyzer-security.ArrayBound): layer < kLayerCount, the geometry's
+  }
+};
+
+namespace detail
+{
+
+/// `(0.0136 GeV)^2 x (1 + 0.038 ln x)^2`: Highland's theta0^2 p^2 at normal
+/// incidence for \a x = x/X0, 0 where the logarithm turns it negative.
+[[nodiscard]] inline double highlandFactor(double x)
+{
+  if (!(x > 0.)) {
+    return 0.;
+  }
+  const double highland = 1. + (0.038 * std::log(x));
+  return highland > 0. ? 0.0136 * 0.0136 * x * highland * highland : 0.;
+}
+
+} // namespace detail
+
+/// Whether a straight segment between a point of layer \a a and one of layer
+/// \a b can cross \a passive: a cylinder strictly between the layers' least
+/// and largest radius, a disc strictly between their least and largest z --
+/// what `visitPassivesBetween` asks of the points' own radius or z.
+template <DetectorLayout Det>
+[[nodiscard]] inline bool passiveCanLieAcross(const PassiveScatterer& passive, LayerID a, LayerID b)
+{
+  return positionBetweenLayers<Det>(passive.barrel, static_cast<double>(passive.at.position), a, b);
+}
+
+/// The table for per-layer average normal-incidence `x/X0` values and, for the
+/// layout's passive scatterers, \a passiveX2X0 (`passiveMaterial`) or, if
+/// empty, their nominal values (`nominalPassiveMaterial`).
+template <DetectorLayout Det>
+[[nodiscard]] inline ScatteringTable<Det> scatteringTable(std::span<const double> x2X0, std::span<const double> passiveX2X0 = {})
+{
+  ScatteringTable<Det> table;
+  for (std::size_t layer = 0; layer < ScatteringTable<Det>::kLayerCount; ++layer) {
+    const auto id = static_cast<LayerID>(layer);
+    table.layers[layer] = {
+      .position = static_cast<Scalar>(Detector<Det>::isBarrelLayer(id) ? layerDistance<Det>(id) : discZ<Det>(id)),
+      .low = static_cast<Scalar>(secondMin<Det>(id)),
+      .high = static_cast<Scalar>(secondMax<Det>(id)),
+      .k = static_cast<Scalar>(detail::highlandFactor(x2X0[layer])),
+    };
+  }
+  if constexpr (Detector<Det>::nPassives > 0) {
+    if (!passiveX2X0.empty() && passiveX2X0.size() != ScatteringTable<Det>::kPassiveCount) {
+      throw std::invalid_argument("scatteringTable: one x/X0 per passive scatterer");
+    }
+    for (std::size_t i = 0; i < ScatteringTable<Det>::kPassiveCount; ++i) {
+      const auto& spec = Detector<Det>::passive(i);
+      table.passives[i] = {
+        .at =
+          {
+            .position = static_cast<Scalar>(spec.position),
+            .low = static_cast<Scalar>(spec.low),
+            .high = static_cast<Scalar>(spec.high),
+            .k = static_cast<Scalar>(detail::highlandFactor(passiveX2X0.empty() ? spec.x2X0 : passiveX2X0[i])),
+          },
+        .barrel = spec.kind == PassiveSpec::Kind::kBarrel,
+      };
+    }
+    // The passives no segment of a layout link into, or out of, a layer can cross.
+    for (std::size_t i = 0; i < ScatteringTable<Det>::kPassiveCount; ++i) {
+      std::array<bool, ScatteringTable<Det>::kLayerCount> into{};
+      std::array<bool, ScatteringTable<Det>::kLayerCount> outOf{};
+      for (const auto& link : Det::layerLinks) {
+        if (passiveCanLieAcross<Det>(table.passives[i], link.from, link.to)) {
+          into[link.to] = true;
+          outOf[link.from] = true;
+        }
+      }
+      for (std::size_t layer = 0; layer < ScatteringTable<Det>::kLayerCount; ++layer) {
+        table.notInto[layer] |= into[layer] ? 0U : std::uint64_t{1U} << i;
+        table.notOutOf[layer] |= outOf[layer] ? 0U : std::uint64_t{1U} << i;
+      }
+    }
+  }
+  return table;
+}
+
+/// The cut parameters of one iteration, the same for every layer pair and
+/// every vertex.
+struct PairCut {
+  Scalar twoRMin = 0.F;          ///< twice the softest track's transverse radius [cm]; 0 with no field
+  Scalar nSigma = 3.F;           ///< how many sigma of the Gaussian terms are admitted
+  Scalar invBetaMomentum2 = 0.F; ///< 1 / (beta pT)^2 at pT_min [GeV^-2], for the scattering sum (`invBetaMomentumMin2`)
+  /// The largest transverse curvature above pT_min [1/cm]: zero with no field,
+  /// unbounded with no pT cut.
+  Scalar maxCurvature = std::numeric_limits<Scalar>::infinity();
+  /// A track's momentum times its 3D curvature, |B2C Bz| [GeV/cm]: what turns
+  /// a fitted curvature into the momentum its scattering is taken at; 0 with
+  /// no field.
+  Scalar momentumCurvature = 0.F;
+  Scalar mass2 = 0.F; ///< the mass hypothesis squared [GeV^2], for beta
+};
+
+[[nodiscard]] inline PairCut pairCut(const SearchWindowParams& params)
+{
+  const double radius = curvatureRadius(params.minPtGeV, params.bzKiloGauss);
+  return {
+    .twoRMin = static_cast<Scalar>(2. * radius),
+    .nSigma = static_cast<Scalar>(params.nSigma),
+    .invBetaMomentum2 = params.minPtGeV > 0. ? static_cast<Scalar>(invBetaMomentumMin2(params)) : 0.F,
+    .maxCurvature = static_cast<Scalar>(maxCurvature(params)),
+    .momentumCurvature = static_cast<Scalar>(std::abs(static_cast<double>(o2::constants::math::B2C) * params.bzKiloGauss)),
+    .mass2 = static_cast<Scalar>(params.massGeV * params.massGeV),
+  };
+}
+
+/// A candidate origin of the tracks in one collision: the beam line, one
+/// entry for the whole timeframe, or a vertex from a list sorted by time.
+///
+/// Transverse positions are in the frame of the corrected beam line, so a
+/// vertex contributes only its transverse spread there.
+struct VertexSeed {
+  /// The time box `[timePS, timePS + widthPS)` [ps from the timeframe's start]:
+  /// a point for an MC vertex, the span of
+  /// its contributors' boxes for a found one, every time for the beam line.
+  std::uint32_t timePS = 0U;
+  std::uint32_t widthPS = 0U;
+  Scalar z = 0.F;             ///< [cm]
+  Scalar varZ = 0.F;          ///< [cm^2]
+  Scalar varTransverse = 0.F; ///< transverse spread squared [cm^2]
+};
+
+/// A seed from a spatial constraint alone, compatible with every time: the
+/// beam line, from the beam spot's z and widths.
+[[nodiscard]] inline VertexSeed vertexSeed(const VertexConstraint& constraint)
+{
+  return {
+    .timePS = 0U,
+    .widthPS = std::numeric_limits<std::uint32_t>::max(),
+    .z = static_cast<Scalar>(constraint.z),
+    .varZ = static_cast<Scalar>(constraint.sigmaZ * constraint.sigmaZ),
+    .varTransverse = static_cast<Scalar>(constraint.sigmaTransverse * constraint.sigmaTransverse),
+  };
+}
+
+/// What the tests read of one measurement: its shipped position and its
+/// variances along z, r and r-phi.
+struct PairPoint {
+  Scalar x = 0.F;
+  Scalar y = 0.F;
+  Scalar z = 0.F;
+  Scalar r = 0.F;
+  Scalar varZ = 0.F;
+  Scalar varR = 0.F;
+  Scalar varRPhi = 0.F;
+};
+
+template <typename Row>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() PairPoint pairPoint(const Row& row)
+{
+  return {.x = row.x, .y = row.y, .z = row.z, .r = row.r, .varZ = row.varZ, .varR = row.varR, .varRPhi = row.varRPhi};
+}
+
+/// The same for row \a row of \a columns, reading only these seven columns: a
+/// whole row through a view's `operator[]` is a call that reads all of them.
+template <typename Columns>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() PairPoint pairPointAt(const Columns& columns, std::uint32_t row)
+{
+  return {
+    .x = columns.x[row],
+    .y = columns.y[row],
+    .z = columns.z[row],
+    .r = columns.r[row],
+    .varZ = columns.varZ[row],
+    .varR = columns.varR[row],
+    .varRPhi = columns.varRPhi[row],
+  };
+}
+
+namespace detail
+{
+
+/// Whether the line from \a vertex through \a source, of slope \a slope in
+/// r and \a dz from the vertex to the source, crosses \a scatterer before
+/// the source -- the source's own layer, \a own, always -- and if so its
+/// term of `sourceScattering`'s sum in \a term.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool crossedBeforeSource(const ScatteringLayer& scatterer, bool barrel, bool own, const VertexSeed& vertex, const PairPoint& source, Scalar dz, Scalar slope, Scalar absDz, Scalar discFactor, Scalar& term)
+{
+  if (barrel) {
+    if (!own) {
+      const Scalar zAt = vertex.z + (slope * scatterer.position);
+      if (!(scatterer.position < source.r) || zAt < scatterer.low || zAt > scatterer.high) {
+        return false;
+      }
+    }
+    term = scatterer.k * scatterer.position * scatterer.position;
+    return true;
+  }
+  const Scalar dzLayer = scatterer.position - vertex.z;
+  if (!own) {
+    if (!(dzLayer * dz > 0.F) || !(o2::gpu::GPUCommonMath::Abs(dzLayer) < absDz)) {
+      return false;
+    }
+    const Scalar rAt = source.r * dzLayer / dz;
+    if (rAt < scatterer.low || rAt > scatterer.high) {
+      return false;
+    }
+  }
+  term = scatterer.k * dzLayer * dzLayer * discFactor;
+  return true;
+}
+
+} // namespace detail
+
+/// `S = sum_k theta_k^2 s_k^2` over the layers the source's line from the
+/// vertex crosses up to and including the source's own, for the iteration's
+/// minimum pT.
+///
+/// A kink at distance `s_k` from the vertex moves the collinearity by
+/// `theta_k s_k (s_j - s_i)` and the curvature cross product by
+/// `theta_k s_k d`, so this one sum serves both tests. The source's direction
+/// from the vertex sets the path through each layer, the lever arm and the
+/// momentum `p = pT g`; the Highland logarithm stays at normal incidence.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar sourceScattering(const ScatteringTable<Det>& table, const PairCut& cut, const VertexSeed& vertex, LayerID sourceLayer, const PairPoint& source)
+{
+  if (!(source.r > 0.F)) {
+    return 0.F;
+  }
+  const Scalar dz = source.z - vertex.z;
+  const Scalar slope = dz / source.r;
+  const Scalar g = o2::gpu::GPUCommonMath::Sqrt(1.F + (slope * slope));
+  const Scalar absDz = o2::gpu::GPUCommonMath::Abs(dz);
+  const Scalar invAbsDz = absDz > 0.F ? 1.F / absDz : 0.F;
+  const Scalar discFactor = source.r * source.r * source.r * invAbsDz * invAbsDz * invAbsDz;
+
+  // The layers in order, then the passive scatterers inside the source, as
+  // layers that are not the source's own: the sum's order is the output's.
+  Scalar sum = 0.F;
+  Scalar term = 0.F;
+  for (std::size_t layer = 0; layer < ScatteringTable<Det>::kLayerCount; ++layer) {
+    const auto id = static_cast<LayerID>(layer);
+    if (detail::crossedBeforeSource(table.layers[layer], Detector<Det>::isBarrelLayer(id), id == sourceLayer, vertex, source, dz, slope, absDz, discFactor, term)) {
+      sum += term;
+    }
+  }
+  if constexpr (ScatteringTable<Det>::kPassiveCount > 0) {
+    for (std::size_t i = 0; i < ScatteringTable<Det>::kPassiveCount; ++i) {
+      const auto& passive = table.passives[i];
+      if (detail::crossedBeforeSource(passive.at, passive.barrel, false, vertex, source, dz, slope, absDz, discFactor, term)) {
+        sum += term;
+      }
+    }
+  }
+  return sum * g * cut.invBetaMomentum2;
+}
+
+/// `T = sum_p theta_p^2 (s_j - s_p)^2` over the passive scatterers the line
+/// from the vertex through the source crosses between the source and the
+/// target, for the iteration's minimum pT:
+/// a kink there moves the target alone, by `theta_p (s_j - s_p)`.
+///
+/// As in `sourceScattering`, the source's direction from the vertex sets the
+/// path through the scatterer, its distance `s_p` and the momentum `p = pT
+/// g`; `s_j` is the target's own distance from the vertex. A layout's layers
+/// never enter: their material is the target's, which does not matter, or
+/// the source's, which `sourceScattering` has.
+///
+/// \a passives: the ones to try, a bit each, in index order; every passive
+/// by default. A link's `passivesBetween` holds every passive any of its pairs
+/// can cross, so the terms and their order, and
+/// the sum, are the same as with all of them.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() Scalar betweenScattering(const ScatteringTable<Det>& table, const PairCut& cut, const VertexSeed& vertex, const PairPoint& source, const PairPoint& target, std::uint64_t passives = ScatteringTable<Det>::kAllPassives)
+{
+  if constexpr (ScatteringTable<Det>::kPassiveCount == 0) {
+    return 0.F;
+  } else {
+    if (!(source.r > 0.F)) {
+      return 0.F;
+    }
+    const Scalar dz = source.z - vertex.z;
+    const Scalar slope = dz / source.r;
+    const Scalar g = o2::gpu::GPUCommonMath::Sqrt(1.F + (slope * slope));
+    const Scalar absDz = o2::gpu::GPUCommonMath::Abs(dz);
+    const Scalar dzTarget = target.z - vertex.z;
+    const Scalar sTarget = o2::gpu::GPUCommonMath::Sqrt((target.r * target.r) + (dzTarget * dzTarget));
+    Scalar sum = 0.F;
+    for (std::uint64_t left = passives & ScatteringTable<Det>::kAllPassives; left != 0U; left &= left - 1U) {
+      const auto& passive = table.passives[o2::gpu::CAMath::Ctz64(left)];
+      const auto& scatterer = passive.at;
+      Scalar pathFactor = 0.F;
+      Scalar sPassive = 0.F;
+      if (passive.barrel) {
+        const Scalar zAt = vertex.z + (slope * scatterer.position);
+        if (scatterer.position <= source.r || scatterer.position >= target.r || zAt < scatterer.low || zAt > scatterer.high) {
+          continue;
+        }
+        pathFactor = g;
+        sPassive = scatterer.position * g;
+      } else {
+        const Scalar dzPassive = scatterer.position - vertex.z;
+        if (!(dzPassive * dz > 0.F) || !(o2::gpu::GPUCommonMath::Abs(dzPassive) > absDz) || !(o2::gpu::GPUCommonMath::Abs(dzPassive) < o2::gpu::GPUCommonMath::Abs(dzTarget)) || !(absDz > 0.F)) {
+          continue;
+        }
+        const Scalar rAt = source.r * dzPassive / dz;
+        if (rAt < scatterer.low || rAt > scatterer.high) {
+          continue;
+        }
+        pathFactor = source.r * g / absDz;
+        sPassive = o2::gpu::GPUCommonMath::Abs(dzPassive) * pathFactor;
+      }
+      // theta_p^2 pT^2 = k (path factor) / g^2, with p = pT g.
+      const Scalar lever = sTarget - sPassive;
+      sum += scatterer.k * pathFactor / (g * g) * lever * lever;
+    }
+    return sum * cut.invBetaMomentum2;
+  }
+}
+
+/// One standard deviation of a source's transverse direction on \a from
+/// [rad], at its largest over the layer and the vertex range: `sqrt(S)/r_i`,
+/// with `S` the `sourceScattering` sum at pT_min, and the beam width over the
+/// radius. The transverse test takes both times the pair's chord.
+///
+/// Each term of the sum is bounded where the source can give it its largest
+/// value. A barrel layer inside the source contributes `k (r_l/r_i)^2 g` and
+/// takes the steepest path factor `g`. A disc crossed on the way contributes
+/// `k dz_l^2 sqrt(r_i^2 + dz^2) / |dz|^3`, which falls with the source's
+/// distance `|dz| > |dz_l|` from the vertex and is largest just beyond the
+/// disc; the source's own disc takes its nearest and farthest offsets.
+template <DetectorLayout Det>
+[[nodiscard]] inline double sourceKinkBound(const ScatteringTable<Det>& table, const SearchWindowParams& params, LayerID from, const VertexConstraint& vertex)
+{
+  const double rMin = radiusMin<Det>(from);
+  const double rMax = radiusMax<Det>(from);
+  if (!(rMin > 0.) || !(params.minPtGeV > 0.)) {
+    return std::numeric_limits<double>::infinity();
+  }
+  const Interval vertexZ = vertexReach(params, vertex);
+  const Interval sourceZ = zRange<Det>(from);
+  // The distance from the vertex range to a position: the nearest, zero inside it.
+  const auto nearest = [&](double z) { return nearestApart(vertexZ, {.low = z, .high = z}); };
+  const double sourceFar = farthestApart(vertexZ, sourceZ);
+  const double g = std::sqrt(1. + (sourceFar * sourceFar / (rMin * rMin)));
+
+  double sum = 0.;
+  // A scatterer that is not the source's own layer, at its largest: false
+  // where that is unbounded.
+  const auto addOther = [&](double k, double position, bool barrel) {
+    if (barrel) {
+      if (position < rMax) {
+        const double ratio = std::min(position / rMin, 1.);
+        sum += k * ratio * ratio * g;
+      }
+      return true;
+    }
+    // Crossed only between the vertex and the source.
+    const bool crossed = (position > vertexZ.low && position < sourceZ.high) || (position < vertexZ.high && position > sourceZ.low);
+    if (!crossed) {
+      return true;
+    }
+    const double near = nearest(position);
+    if (!(near > 0.)) {
+      return false;
+    }
+    sum += k * std::sqrt((rMax * rMax) + (near * near)) / near;
+    return true;
+  };
+  for (std::size_t layer = 0; layer < ScatteringTable<Det>::kLayerCount; ++layer) {
+    const auto id = static_cast<LayerID>(layer);
+    const auto k = static_cast<double>(table.layers[layer].k);
+    const auto position = static_cast<double>(table.layers[layer].position);
+    const bool barrel = Detector<Det>::isBarrelLayer(id);
+    if (id != from) {
+      if (!addOther(k, position, barrel)) {
+        return std::numeric_limits<double>::infinity();
+      }
+      continue;
+    }
+    if (barrel) {
+      const double ratio = position / rMin;
+      sum += k * ratio * ratio * g;
+      continue;
+    }
+    const double sourceNear = nearestApart(vertexZ, sourceZ);
+    if (!(sourceNear > 0.)) {
+      return std::numeric_limits<double>::infinity();
+    }
+    const double offset = farthestApart(vertexZ, {.low = position, .high = position});
+    sum += k * offset * offset * std::sqrt((rMax * rMax) + (sourceNear * sourceNear)) / (sourceNear * sourceNear * sourceNear);
+  }
+  // Passive scatterers that can lie inside a source on this layer, bounded as
+  // a layer that is not the source's own.
+  if constexpr (ScatteringTable<Det>::kPassiveCount > 0) {
+    for (std::size_t i = 0; i < ScatteringTable<Det>::kPassiveCount; ++i) {
+      const auto& passive = table.passives[i];
+      if (!addOther(static_cast<double>(passive.at.k), static_cast<double>(passive.at.position), passive.barrel)) {
+        return std::numeric_limits<double>::infinity();
+      }
+    }
+  }
+  const double beam = vertex.sigmaTransverse / rMin;
+  return std::sqrt((sum / (params.minPtGeV * params.minPtGeV) * betaMomentumFactor(params)) + (beam * beam));
+}
+
+/// Whether \a passive can lie between a pair on the link \a from -> \a to:
+/// a cylinder between the source layer's least and the target's largest
+/// radius, a disc between the layers' z on the target's side.
+template <DetectorLayout Det>
+[[nodiscard]] inline bool passiveCanLieBetween(const PassiveScatterer& passive, LayerID from, LayerID to)
+{
+  const auto position = static_cast<double>(passive.at.position);
+  if (passive.barrel) {
+    return position > radiusMin<Det>(from) && position < radiusMax<Det>(to);
+  }
+  // Beyond some of the source layer's z and short of some of the target's, on one side.
+  const double fromNear = std::min(std::abs(zMin<Det>(from)), std::abs(zMax<Det>(from)));
+  const double toFar = std::max(std::abs(zMin<Det>(to)), std::abs(zMax<Det>(to)));
+  return std::abs(position) > fromNear && std::abs(position) < toFar && !(position * zMax<Det>(to) < 0.);
+}
+
+/// The passives a pair on the link \a from -> \a to can cross, a bit each:
+/// those `passiveCanLieBetween` the layers, the test `betweenKinkBound` bounds
+/// over. `betweenScattering` on them adds the terms it adds on all.
+template <DetectorLayout Det>
+[[nodiscard]] inline std::uint64_t passivesBetween(const ScatteringTable<Det>& table, LayerID from, LayerID to)
+{
+  std::uint64_t bits = 0U;
+  for (std::size_t i = 0; i < ScatteringTable<Det>::kPassiveCount; ++i) {
+    if (passiveCanLieBetween<Det>(table.passives[i], from, to)) {
+      bits |= std::uint64_t{1U} << i;
+    }
+  }
+  return bits;
+}
+
+/// A bound on `sqrt(T)` [cm] (`betweenScattering`) for every pair on the link
+/// \a from -> \a to: the passive scatterers that can lie between the two
+/// layers, each at its largest -- `theta_p^2 pT^2 <= k_p` for both kinds, the
+/// path factor over `g^2` never exceeding one -- over the longest lever from
+/// the scatterer to the target. Zero if none can, which is how an iteration
+/// knows to skip the term (`IterationParameters::passiveBetween`).
+template <DetectorLayout Det>
+[[nodiscard]] inline double betweenKinkBound(const ScatteringTable<Det>& table, const SearchWindowParams& params, LayerID from, LayerID to, const VertexConstraint& vertex)
+{
+  if constexpr (ScatteringTable<Det>::kPassiveCount == 0) {
+    return 0.;
+  } else {
+    if (!(params.minPtGeV > 0.)) {
+      return 0.;
+    }
+    const Interval vertexZ = vertexReach(params, vertex);
+    const auto nearest = [&](double z) { return nearestApart(vertexZ, {.low = z, .high = z}); };
+    const double targetFar = std::hypot(radiusMax<Det>(to), farthestApart(vertexZ, zRange<Det>(to)));
+    double sum = 0.;
+    for (std::size_t i = 0; i < ScatteringTable<Det>::kPassiveCount; ++i) {
+      const auto& passive = table.passives[i];
+      if (!passiveCanLieBetween<Det>(passive, from, to)) {
+        continue;
+      }
+      const auto position = static_cast<double>(passive.at.position);
+      const double sPassive = passive.barrel ? position : nearest(position);
+      const double lever = std::max(targetFar - sPassive, 0.);
+      sum += static_cast<double>(passive.at.k) * lever * lever;
+    }
+    return std::sqrt(sum * betaMomentumFactor(params)) / params.minPtGeV;
+  }
+}
+
+/// What `betweenScattering` computes of one source and vertex alone: the
+/// passives the source's side admits, each one's weight `k pathFactor / g^2`
+/// and `sPassive`, and the bound a target has to pass (a barrel's radius, a
+/// disc's |z - z_v|). A pair then adds only its own side, the same terms in
+/// the same order with the same arithmetic.
+template <DetectorLayout Det>
+struct BetweenSource {
+  static constexpr std::size_t kCount = ScatteringTable<Det>::kPassiveCount > 0 ? ScatteringTable<Det>::kPassiveCount : 1;
+  std::uint64_t admitted = 0U;
+  std::uint64_t barrels = 0U;
+  Scalar weight[kCount]{};
+  Scalar sPassive[kCount]{};
+  Scalar bound[kCount]{};
+};
+
+/// The source's part of `betweenScattering` through \a vertex.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() BetweenSource<Det> betweenSource(const ScatteringTable<Det>& table, const VertexSeed& vertex, const PairPoint& source)
+{
+  BetweenSource<Det> result;
+  if constexpr (ScatteringTable<Det>::kPassiveCount > 0) {
+    if (!(source.r > 0.F)) {
+      return result;
+    }
+    const Scalar dz = source.z - vertex.z;
+    const Scalar slope = dz / source.r;
+    const Scalar g = o2::gpu::GPUCommonMath::Sqrt(1.F + (slope * slope));
+    const Scalar absDz = o2::gpu::GPUCommonMath::Abs(dz);
+    for (std::size_t i = 0; i < ScatteringTable<Det>::kPassiveCount; ++i) {
+      const auto& passive = table.passives[i];
+      const auto& scatterer = passive.at;
+      Scalar pathFactor = 0.F;
+      Scalar sPassive = 0.F;
+      if (passive.barrel) {
+        const Scalar zAt = vertex.z + (slope * scatterer.position);
+        if (scatterer.position <= source.r || zAt < scatterer.low || zAt > scatterer.high) {
+          continue;
+        }
+        pathFactor = g;
+        sPassive = scatterer.position * g;
+        result.bound[i] = scatterer.position;
+        result.barrels |= std::uint64_t{1U} << i;
+      } else {
+        const Scalar dzPassive = scatterer.position - vertex.z;
+        if (!(dzPassive * dz > 0.F) || !(o2::gpu::GPUCommonMath::Abs(dzPassive) > absDz) || !(absDz > 0.F)) {
+          continue;
+        }
+        const Scalar rAt = source.r * dzPassive / dz;
+        if (rAt < scatterer.low || rAt > scatterer.high) {
+          continue;
+        }
+        pathFactor = source.r * g / absDz;
+        sPassive = o2::gpu::GPUCommonMath::Abs(dzPassive) * pathFactor;
+        result.bound[i] = o2::gpu::GPUCommonMath::Abs(dzPassive);
+      }
+      result.admitted |= std::uint64_t{1U} << i;
+      result.weight[i] = scatterer.k * pathFactor / (g * g);
+      result.sPassive[i] = sPassive;
+    }
+  }
+  return result;
+}
+
+/// `betweenScattering` of the pair from \a from, its source's part, to
+/// \a target, over \a passives (`IterationParameters::betweenPassives`).
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar betweenScattering(const BetweenSource<Det>& from, const PairCut& cut, const VertexSeed& vertex, const PairPoint& target, std::uint64_t passives)
+{
+  if constexpr (ScatteringTable<Det>::kPassiveCount == 0) {
+    return 0.F;
+  } else {
+    const Scalar dzTarget = target.z - vertex.z;
+    const Scalar absDzTarget = o2::gpu::GPUCommonMath::Abs(dzTarget);
+    const Scalar sTarget = o2::gpu::GPUCommonMath::Sqrt((target.r * target.r) + (dzTarget * dzTarget));
+    Scalar sum = 0.F;
+    for (std::uint64_t left = passives & from.admitted; left != 0U; left &= left - 1U) {
+      const std::uint32_t i = o2::gpu::CAMath::Ctz64(left);
+      // A barrel's radius below the target's, a disc's |z - z_v| below the target's.
+      if (((from.barrels >> i) & 1U) != 0U ? from.bound[i] >= target.r : !(from.bound[i] < absDzTarget)) {
+        continue;
+      }
+      const Scalar lever = sTarget - from.sPassive[i];
+      sum += from.weight[i] * lever * lever;
+    }
+    return sum * cut.invBetaMomentum2;
+  }
+}
+
+/// The window a pair query uses: its phi and second-coordinate half-widths
+/// hold what the pair tests accept with \a table's scattering, not only the
+/// uniform material the grid's cells are sized with.
+template <DetectorLayout Det>
+[[nodiscard]] inline LayerPairWindow layerPairWindow(LayerID from, LayerID to, const SearchWindowParams& params, const VertexConstraint& vertex, const ScatteringTable<Det>& table)
+{
+  return layerPairWindow<Det>(from, to, secondMax<Det>(from), params, vertex, sourceKinkBound<Det>(table, params, from, vertex), betweenKinkBound<Det>(table, params, from, to, vertex));
+}
+
+/// The two tests' ingredients for one source, vertex and candidate.
+struct PairTerms {
+  bool beforeTurn = false;      ///< the circle's turning point is not between the two
+  Scalar curvature = 0.F;       ///< 2 R_min |P_i x P_j|
+  Scalar bound = 0.F;           ///< r_i r_j d: the curvature bound, in the same units
+  Scalar varCurvature = 0.F;    ///< (2 R_min sigma_X)^2
+  Scalar collinearity2 = 0.F;   ///< D^2
+  Scalar varCollinearity = 0.F; ///< sigma_D^2
+};
+
+namespace detail
+{
+
+struct ArcLengthDerivatives {
+  Scalar value;
+  Scalar chord;
+  Scalar curvature;
+};
+
+/// Arc length and its derivatives with respect to chord and signed curvature.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() ArcLengthDerivatives arcLengthDerivatives(Scalar curvature, Scalar chord)
+{
+  const Scalar halfTurnSine = o2::gpu::GPUCommonMath::Clamp(0.5F * curvature * chord, -1.F, 1.F);
+  const auto quotient = asinOverArgumentWithDerivative(halfTurnSine);
+  const Scalar ratio = quotient.value;
+  const Scalar derivative = quotient.derivative;
+  return {.value = chord * ratio, .chord = ratio + (halfTurnSine * derivative), .curvature = 0.5F * chord * chord * derivative};
+}
+
+struct ArcPairGeometry {
+  Scalar curvature;
+  Scalar curvatureScale;
+  Scalar chord;
+  bool bounded; ///< the curvature is the cut's bound, which the positions do not move
+  ArcLengthDerivatives source;
+  ArcLengthDerivatives target;
+};
+
+/// The circle through the beam point and the pair, with its curvature held to
+/// what a track above pT_min can have. The positions can put it further out
+/// -- up to 2/r when the chord is unresolved -- and the arc length there, and
+/// its derivatives, would describe a track the cut does not admit. The bound
+/// never exceeds a curvature the measured one already reached, so the arcsine
+/// argument stays within [-1, 1]. Arc length is even in the curvature, so the
+/// bound's sign does not matter.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() ArcPairGeometry arcPairGeometry(const PairPoint& source, const PairPoint& target, Scalar cross, Scalar chord, Scalar maxCurvature)
+{
+  const Scalar curvatureScale = 2.F / (source.r * target.r * chord);
+  const Scalar measured = curvatureScale * cross;
+  // Also false for the NaN of a zero chord.
+  const bool bounded = !(o2::gpu::GPUCommonMath::Abs(measured) <= maxCurvature);
+  const Scalar curvature = bounded ? maxCurvature : measured;
+  return {
+    .curvature = curvature,
+    .curvatureScale = curvatureScale,
+    .chord = chord,
+    .bounded = bounded,
+    .source = arcLengthDerivatives(curvature, source.r),
+    .target = arcLengthDerivatives(curvature, target.r),
+  };
+}
+
+} // namespace detail
+
+/// What the pair tests compute of the two positions alone: the transverse
+/// chord and the cross product, once a pair for all of them.
+struct PairChord {
+  Scalar dx;
+  Scalar dy;
+  Scalar chord2;
+  Scalar chord;
+  Scalar cross;
+};
+
+[[nodiscard]] GPUhdi() GPUAlwaysInline() PairChord pairChord(const PairPoint& source, const PairPoint& target)
+{
+  const Scalar dx = target.x - source.x;
+  const Scalar dy = target.y - source.y;
+  const Scalar chord2 = (dx * dx) + (dy * dy);
+  return {.dx = dx, .dy = dy, .chord2 = chord2, .chord = o2::gpu::GPUCommonMath::Sqrt(chord2), .cross = (source.x * target.y) - (target.x * source.y)};
+}
+
+/// \a betweenScatter is `betweenScattering` for the pair, where a passive
+/// scatterer can lie between its layers, and zero otherwise.
+///
+/// Always inlined, as `pairCompatible`: the tracklet stage's grid walk runs
+/// the transverse test on every candidate, and GCC keeps the two out of
+/// line once the walk grows past its inlining limits -- a call each per
+/// candidate.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() PairTerms transversePairTerms(const PairCut& cut, const VertexSeed& vertex, const PairPoint& source, Scalar sourceScatter, const PairPoint& target, const PairChord& pair, Scalar betweenScatter = 0.F)
+{
+  const Scalar chord2 = pair.chord2;
+  const Scalar chord = pair.chord;
+  const Scalar cross = pair.cross;
+  // A kink between the two moves P_j against the side of length r_i.
+  const Scalar varCross = (source.r * source.r * (target.varRPhi + betweenScatter)) + (target.r * target.r * source.varRPhi) + (chord2 * (vertex.varTransverse + sourceScatter));
+
+  // The circle through the beam point turns where it is farthest from it,
+  // opposite the beam point across its centre. The pair lies on one side of
+  // that diameter -- no turning point between them -- exactly when
+  // `P_i . P_j` lies between `r_i^2` and `r_j^2`: the step from one to the
+  // other leads outwards at both ends. That also keeps them in one hemisphere.
+  const Scalar dot = (source.x * target.x) + (source.y * target.y);
+  const Scalar sourceR2 = source.r * source.r;
+  const Scalar targetR2 = target.r * target.r;
+  const Scalar lowR2 = sourceR2 < targetR2 ? sourceR2 : targetR2;
+  const Scalar highR2 = sourceR2 < targetR2 ? targetR2 : sourceR2;
+
+  return {
+    .beforeTurn = dot >= lowR2 && dot <= highR2,
+    .curvature = cut.twoRMin * o2::gpu::GPUCommonMath::Abs(cross),
+    .bound = source.r * target.r * chord,
+    .varCurvature = cut.twoRMin * cut.twoRMin * varCross,
+  };
+}
+
+GPUhdi() void addLongitudinalPairTerms(PairTerms& terms, const PairCut& cut, const VertexSeed& vertex, const PairPoint& source, Scalar sourceScatter, const PairPoint& target, const PairChord& pair, Scalar betweenScatter = 0.F)
+{
+  const Scalar dx = pair.dx;
+  const Scalar dy = pair.dy;
+  const Scalar chord = pair.chord;
+  const Scalar cross = pair.cross;
+  const auto geometry = detail::arcPairGeometry(source, target, cross, chord, cut.maxCurvature);
+  const Scalar dzSource = source.z - vertex.z;
+  const Scalar dzTarget = target.z - vertex.z;
+  const Scalar collinearity = (geometry.source.value * dzTarget) - (geometry.target.value * dzSource);
+
+  const Scalar invSourceR = 1.F / source.r;
+  const Scalar invTargetR = 1.F / target.r;
+  // A bounded curvature does not follow the positions: its terms drop out.
+  const Scalar curvatureD = geometry.bounded ? 0.F : (dzTarget * geometry.source.curvature) - (dzSource * geometry.target.curvature);
+  const Scalar sourceRadiusD = (dzTarget * geometry.source.chord) - (curvatureD * geometry.curvature * invSourceR);
+  const Scalar targetRadiusD = (-dzSource * geometry.target.chord) - (curvatureD * geometry.curvature * invTargetR);
+  const Scalar crossD = geometry.bounded ? 0.F : curvatureD * geometry.curvatureScale;
+  const Scalar chordD = geometry.bounded ? 0.F : curvatureD * geometry.curvature / (geometry.chord * geometry.chord);
+
+  const Scalar sourceX = (sourceRadiusD * source.x * invSourceR) + (crossD * target.y) + (chordD * dx);
+  const Scalar sourceY = (sourceRadiusD * source.y * invSourceR) - (crossD * target.x) + (chordD * dy);
+  const Scalar targetX = (targetRadiusD * target.x * invTargetR) - (crossD * source.y) - (chordD * dx);
+  const Scalar targetY = (targetRadiusD * target.y * invTargetR) + (crossD * source.x) - (chordD * dy);
+  const Scalar sourceRadialD = (sourceX * source.x + sourceY * source.y) * invSourceR;
+  const Scalar sourceTangentD = (-sourceX * source.y + sourceY * source.x) * invSourceR;
+  const Scalar targetRadialD = (targetX * target.x + targetY * target.y) * invTargetR;
+  const Scalar targetTangentD = (-targetX * target.y + targetY * target.x) * invTargetR;
+  const Scalar vertexXD = -(sourceX + targetX);
+  const Scalar vertexYD = -(sourceY + targetY);
+  const Scalar arcGap = geometry.target.value - geometry.source.value;
+  const Scalar dz = target.z - source.z;
+
+  terms.collinearity2 = collinearity * collinearity;
+  terms.varCollinearity = (source.varR * o2::gpu::CAMath::Square(sourceRadialD)) + (o2::gpu::CAMath::Square(sourceTangentD) * source.varRPhi) + (o2::gpu::CAMath::Square(targetRadialD) * target.varR) + (o2::gpu::CAMath::Square(targetTangentD) * target.varRPhi) + ((o2::gpu::CAMath::Square(vertexXD) + o2::gpu::CAMath::Square(vertexYD)) * vertex.varTransverse) + (o2::gpu::CAMath::Square(geometry.target.value) * source.varZ) + (o2::gpu::CAMath::Square(geometry.source.value) * target.varZ) + (o2::gpu::CAMath::Square(arcGap) * vertex.varZ) + ((o2::gpu::CAMath::Square(arcGap) + o2::gpu::CAMath::Square(dz)) * sourceScatter) +
+                          // A kink between the two moves the target's (s, z) corner against (s_i, z_i - z_v).
+                          ((o2::gpu::CAMath::Square(geometry.source.value) + o2::gpu::CAMath::Square(dzSource)) * betweenScatter);
+}
+
+/// Curvature at most the iteration's bound plus n sigma, with no turning point
+/// between the two: a looper's legs are found separately. With no field
+/// `twoRMin` is zero and every such pair passes.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool transverseCompatible(const PairCut& cut, const PairTerms& terms)
+{
+  const Scalar excess = terms.curvature - terms.bound;
+  return terms.beforeTurn && (!(excess > 0.F) || excess * excess <= cut.nSigma * cut.nSigma * terms.varCurvature);
+}
+
+/// Collinear with the vertex within n sigma.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool longitudinalCompatible(const PairCut& cut, const PairTerms& terms) { return terms.collinearity2 <= cut.nSigma * cut.nSigma * terms.varCollinearity; }
+
+/// Always inlined (see `transversePairTerms`); the longitudinal half stays a
+/// call.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool pairCompatible(const PairCut& cut, const VertexSeed& vertex, const PairPoint& source, Scalar sourceScatter, const PairPoint& target, const PairChord& pair, Scalar betweenScatter = 0.F)
+{
+  countWork(WorkCounter::kPairTests);
+  auto terms = transversePairTerms(cut, vertex, source, sourceScatter, target, pair, betweenScatter);
+  if (!transverseCompatible(cut, terms)) {
+    return false;
+  }
+  countWork(WorkCounter::kPairTransverse);
+  addLongitudinalPairTerms(terms, cut, vertex, source, sourceScatter, target, pair, betweenScatter);
+  const bool compatible = longitudinalCompatible(cut, terms);
+  if (compatible) {
+    countWork(WorkCounter::kPairLongitudinal);
+  }
+  return compatible;
+}
+
+/// The same three without a computed chord, one pair each: the harness's and
+/// the tests' (StageFunnel, the sink).
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool pairCompatible(const PairCut& cut, const VertexSeed& vertex, const PairPoint& source, Scalar sourceScatter, const PairPoint& target, Scalar betweenScatter = 0.F) { return pairCompatible(cut, vertex, source, sourceScatter, target, pairChord(source, target), betweenScatter); }
+
+[[nodiscard]] GPUhdi() GPUAlwaysInline() PairTerms transversePairTerms(const PairCut& cut, const VertexSeed& vertex, const PairPoint& source, Scalar sourceScatter, const PairPoint& target, Scalar betweenScatter = 0.F) { return transversePairTerms(cut, vertex, source, sourceScatter, target, pairChord(source, target), betweenScatter); }
+
+GPUhdi() GPUAlwaysInline() void addLongitudinalPairTerms(PairTerms& terms, const PairCut& cut, const VertexSeed& vertex, const PairPoint& source, Scalar sourceScatter, const PairPoint& target, Scalar betweenScatter = 0.F) { addLongitudinalPairTerms(terms, cut, vertex, source, sourceScatter, target, pairChord(source, target), betweenScatter); }
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_PAIRCUT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Parallel.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Parallel.h
new file mode 100644
index 0000000000000..3c0c4967e679e
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Parallel.h
@@ -0,0 +1,81 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Parallel.h
+/// \brief Host parallelism without TBB in any header.
+///
+/// A parallel loop and a parallel sort, both in a task arena, implemented with
+/// TBB in Parallel.cxx. VertexStage.h includes this header and is compiled
+/// into the CUDA and HIP units, so TBB here would reach nvcc and hipcc.
+
+#ifndef GTRK_TRACKING_PARALLEL_H_
+#define GTRK_TRACKING_PARALLEL_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <span>
+
+namespace o2::gtrk::detail
+{
+
+using ParallelForBody = void (*)(void*, size_t, size_t);
+using ParallelSortLess = bool (*)(void*, size_t, size_t);
+
+/// A TBB task arena kept behind the tracking library boundary.
+class TaskArena
+{
+ public:
+  explicit TaskArena(int maxConcurrency = 0);
+  ~TaskArena();
+  TaskArena(const TaskArena&) = delete;
+  TaskArena& operator=(const TaskArena&) = delete;
+  TaskArena(TaskArena&&) = delete;
+  TaskArena& operator=(TaskArena&&) = delete;
+
+  [[nodiscard]] int maxConcurrency() const noexcept;
+
+ private:
+  struct Impl;
+  std::unique_ptr<Impl> mImpl;
+
+  friend void parallelFor(TaskArena& arena, size_t begin, size_t end, size_t grainSize, void* context, ParallelForBody body);
+  friend void parallelSortIndices(TaskArena& arena, size_t count, void* context, ParallelSortLess less, uint32_t* first);
+};
+
+/// The type-erased body of `parallelSort`.
+void parallelSortIndices(TaskArena& arena, size_t count, void* context, ParallelSortLess less, uint32_t* first);
+
+void parallelFor(TaskArena& arena, size_t begin, size_t end, size_t grainSize, void* context, ParallelForBody body);
+[[nodiscard]] int currentArenaThreadIndex() noexcept;
+
+/// Sort \a indices in place by \a less on \a arena's threads (a sort outside
+/// it would take every core TBB has, not the tracker's threads). The sort is
+/// unstable, so \a less has to be a strict total order -- no two distinct
+/// indices equivalent -- for the result to be a serial sort's; every caller
+/// ends its comparison in an index tie-break.
+template <typename Less>
+void parallelSort(TaskArena& arena, std::span<std::uint32_t> indices, Less less)
+{
+  parallelSortIndices(arena, indices.size(), static_cast<void*>(&less), [](void* context, std::size_t lhs, std::size_t rhs) { return (*static_cast<Less*>(context))(static_cast<std::uint32_t>(lhs), static_cast<std::uint32_t>(rhs)); }, indices.data());
+}
+
+/// Run the loop inside an arena, which limits its concurrency independently
+/// of the process-wide TBB scheduler setting; \a grainSize > 0.
+template <typename Function>
+void parallelFor(TaskArena& arena, std::size_t begin, std::size_t end, std::size_t grainSize, Function function)
+{
+  parallelFor(arena, begin, end, grainSize, static_cast<void*>(&function), [](void* context, std::size_t first, std::size_t last) { (*static_cast<Function*>(context))(first, last); });
+}
+
+} // namespace o2::gtrk::detail
+
+#endif // GTRK_TRACKING_PARALLEL_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Profile.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Profile.h
new file mode 100644
index 0000000000000..d48eb4b20aa02
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Profile.h
@@ -0,0 +1,325 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Profile.h
+/// \brief Where the host tracking loop spends its time, phase by phase.
+///
+/// A `Profile` holds one
+/// `PhaseStats` per `Phase`; the phases form a tree, and a phase's time
+/// includes its children's, so a report can show what each child leaves
+/// unattributed. Three things fill it:
+///
+/// - a `Zone` times the phase it names on the calling thread, with the minor
+///   page faults, the pool allocations inside it and the pool's peak;
+/// - a `Region` wraps one parallel loop over chunks: each chunk's duration on
+///   its arena slot, folded when the loop ends into the phase open around it
+///   as busy time, slot imbalance and tail;
+/// - `count` adds elements or emitted records to a phase.
+///
+/// All three act only while an `Activation` is open on the calling thread, and
+/// cost one thread-local read otherwise. Nothing here reads or writes what the
+/// tracking computes: a profile changes timings, never output.
+
+#ifndef GTRK_TRACKING_PROFILE_H_
+#define GTRK_TRACKING_PROFILE_H_
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <iosfwd>
+#include <string_view>
+#include <vector>
+
+namespace o2::gtrk
+{
+class BoundedMemoryResource;
+} // namespace o2::gtrk
+
+namespace o2::gtrk::profile
+{
+
+/// Every timed phase of `Tracker::run`, in report order. `kNone` names no
+/// phase: a `Zone` of it does nothing.
+enum class Phase : std::uint8_t { kRun,
+                                  kPlan,
+                                  kBegin,
+                                  kIteration,
+                                  kSlices,
+                                  kTracklets,
+                                  kTrackletSetup,
+                                  kTrackletReset,
+                                  kTrackletGenerate,
+                                  kTrackletScan,
+                                  kTrackletPlace,
+                                  kTrackletSort,
+                                  kTriplets,
+                                  kPermutation,
+                                  kTripletSetup,
+                                  kTripletReset,
+                                  kTripletGenerate,
+                                  kTripletScan,
+                                  kTripletPlace,
+                                  kNeighbours,
+                                  kEndIndex,
+                                  kNeighbourSetup,
+                                  kNeighbourReset,
+                                  kNeighbourGenerate,
+                                  kNeighbourScan,
+                                  kNeighbourPlace,
+                                  kRoads,
+                                  kRoadCount,
+                                  kRoadFills,
+                                  kRoadStarts,
+                                  kRoadFitSetup,
+                                  kRoadFitReset,
+                                  kRoadFitGenerate,
+                                  kRoadFitScan,
+                                  kRoadFitPlace,
+                                  kSelectionAppend,
+                                  kSelection,
+                                  kSelectionKeys,
+                                  kSelectionOrder,
+                                  kSelectionDeduplicate,
+                                  kSelectionRank,
+                                  kSelectionFill,
+                                  kSelectionSlots,
+                                  kSelectionRounds,
+                                  kSelectionCompact,
+                                  kRefit,
+                                  kFollowEarlier,
+                                  kFollow,
+                                  kFollowPropose,
+                                  kFollowResolve,
+                                  kFollowRefit,
+                                  kFollowMark,
+                                  kObservers,
+                                  kTrackletPaths,
+                                  kTripletPaths,
+                                  kLengthCut,
+                                  kCount,
+                                  kNone };
+
+inline constexpr std::size_t kPhaseCount = static_cast<std::size_t>(Phase::kCount);
+
+/// A phase's name in reports and traces, and the phase that contains it;
+/// kNone for a root.
+struct PhaseInfo {
+  std::string_view name;
+  Phase parent = Phase::kNone;
+};
+
+[[nodiscard]] const PhaseInfo& info(Phase phase);
+
+/// Chunk durations in powers of two of nanoseconds: bin b holds [2^b, 2^(b+1)).
+inline constexpr std::size_t kChunkBins = 40U;
+
+/// What one phase did, summed over every time it was entered.
+struct PhaseStats {
+  double seconds = 0.;        ///< wall time on the calling thread, children included
+  std::uint64_t calls = 0;    ///< times entered
+  std::uint64_t elements = 0; ///< elements the parallel loops directly in it visited
+  std::uint64_t outputs = 0;  ///< records it emitted, where it emits any
+  // The parallel loops opened directly in the phase, not in a child.
+  std::uint64_t regions = 0;
+  std::uint64_t chunks = 0;
+  double regionSeconds = 0.;   ///< their wall time
+  double capacitySeconds = 0.; ///< their wall time times the arena's concurrency
+  double busySeconds = 0.;     ///< the sum of their chunks' durations
+  double maxSlotSeconds = 0.;  ///< per loop, the busiest slot's busy time, summed
+  double tailSeconds = 0.;     ///< per loop and working slot, its last chunk's end to the loop's end
+  double maxChunkSeconds = 0.;
+  std::array<std::uint64_t, kChunkBins> chunkHistogram{};
+  /// Parallel work inside a library call that is not cut into our chunks --
+  /// the TBB sort. Neither serial nor chunk-attributed.
+  double opaqueSeconds = 0.;
+  std::uint64_t minorFaults = 0; ///< the process's, while the phase ran
+  /// The memory controllers' DRAM traffic while the phase ran, reads and
+  /// writes, children included: system-wide, so on a quiet machine
+  /// (`countDram`); 0 without.
+  std::uint64_t dramBytes = 0;
+  std::uint64_t allocations = 0;    ///< from the tracker's pool
+  std::uint64_t allocatedBytes = 0; ///< from the tracker's pool
+  /// The most of the tracker's pool in use while the phase ran, over its
+  /// calls: everything the pool holds, the phase's inputs and what outlives
+  /// it included (O2's `stagepeak`). Zones on several threads at once share
+  /// the pool's peak, so there a phase's may come out low; the run's is exact.
+  std::uint64_t peakBytes = 0;
+  /// The most that peak rose above what the pool held when the phase began,
+  /// over its calls: what the phase itself added (O2's `stagealloc`).
+  std::uint64_t peakGrowthBytes = 0;
+
+  PhaseStats& operator+=(const PhaseStats& other);
+};
+
+/// One `PhaseStats` per phase.
+struct Profile {
+  std::array<PhaseStats, kPhaseCount> phases{};
+
+  [[nodiscard]] PhaseStats& operator[](Phase phase) { return phases[static_cast<std::size_t>(phase)]; }
+  [[nodiscard]] const PhaseStats& operator[](Phase phase) const { return phases[static_cast<std::size_t>(phase)]; }
+  Profile& operator+=(const Profile& other);
+};
+
+/// Nanoseconds on the steady clock.
+[[nodiscard]] std::int64_t now() noexcept;
+
+/// Count each phase's DRAM traffic (`PhaseStats::dramBytes`) from now on:
+/// the CAS commands of every memory controller, 64 bytes each, from the
+/// kernel's AMD UMC counters (Zen 4 and later), read where a zone opens and
+/// closes. False, and nothing counted, where they cannot be opened.
+[[nodiscard]] bool countDram();
+
+/// A timeline of a run, for Chrome's trace format: the zones on the
+/// calling thread and every chunk on its arena slot.
+class Trace
+{
+ public:
+  struct Event {
+    std::int64_t begin = 0;
+    std::int64_t end = 0;
+    Phase phase = Phase::kNone;
+  };
+
+  /// Room for arena slots [0, \a slots); a chunk on another slot is dropped.
+  explicit Trace(std::size_t slots = 1024U);
+
+  /// Events of slot \a slot; each slot is written by one thread at a time.
+  void chunk(int slot, const Event& event);
+  void zone(const Event& event) { mZones.push_back(event); }
+  void clear();
+
+  /// Write the events as a Chrome trace (chrome://tracing, ui.perfetto.dev).
+  void write(std::ostream& out) const;
+
+ private:
+  std::vector<Event> mZones;
+  std::vector<std::vector<Event>> mSlots;
+};
+
+/// What a profiled thread is filling.
+struct Context {
+  Profile* profile = nullptr;
+  BoundedMemoryResource* pool = nullptr;
+  Trace* trace = nullptr;
+  Phase phase = Phase::kNone; ///< the innermost open zone's
+};
+
+/// The calling thread's context, or nullptr when it is not profiled.
+[[nodiscard]] Context* current() noexcept;
+
+/// Profile the calling thread into \a profile until destroyed; allocations
+/// are read from \a pool, events go to \a trace. Nests: the outer activation
+/// is restored at the end.
+class Activation
+{
+ public:
+  Activation(Profile& profile, BoundedMemoryResource* pool, Trace* trace = nullptr);
+  ~Activation();
+  Activation(const Activation&) = delete;
+  Activation& operator=(const Activation&) = delete;
+  Activation(Activation&&) = delete;
+  Activation& operator=(Activation&&) = delete;
+
+ private:
+  Context mContext;
+  Context* mOuter = nullptr;
+};
+
+/// Time \a phase from construction to destruction on the calling thread.
+class Zone
+{
+ public:
+  explicit Zone(Phase phase);
+  ~Zone();
+  Zone(const Zone&) = delete;
+  Zone& operator=(const Zone&) = delete;
+  Zone(Zone&&) = delete;
+  Zone& operator=(Zone&&) = delete;
+
+ private:
+  Context* mContext = nullptr;
+  Phase mPhase = Phase::kNone;
+  Phase mOuter = Phase::kNone;
+  std::int64_t mBegin = 0;
+  std::uint64_t mFaults = 0;
+  std::uint64_t mDram = 0;
+  std::uint64_t mAllocations = 0;
+  std::uint64_t mAllocatedBytes = 0;
+  std::uint64_t mOuterPeak = 0;  ///< the pool's peak before the zone opened its window
+  std::uint64_t mEntryBytes = 0; ///< the pool's use when it opened it
+};
+
+/// Add \a elements and \a outputs to \a phase of the calling thread's profile.
+void count(Phase phase, std::uint64_t elements, std::uint64_t outputs);
+
+/// Add \a seconds of opaque parallel work to the open phase.
+void addOpaque(double seconds);
+
+/// Per arena slot, what the chunks of one parallel loop did. Owned by
+/// whoever runs the loops, sized once to its arena.
+class RegionSlots
+{
+ public:
+  struct alignas(64) Slot {
+    std::int64_t busy = 0;
+    std::int64_t lastEnd = 0;
+    std::int64_t maxChunk = 0;
+    std::uint64_t chunks = 0;
+    std::array<std::uint32_t, kChunkBins> histogram{};
+  };
+
+  explicit RegionSlots(int slots = 0) { resize(slots); }
+  void resize(int slots);
+  [[nodiscard]] std::size_t size() const { return mSlots.size(); }
+  [[nodiscard]] Slot* data() { return mSlots.data(); }
+
+ private:
+  std::vector<Slot> mSlots;
+};
+
+/// One parallel loop of \a elements elements on \a concurrency slots of
+/// \a slots. Workers call `begin()` before a chunk and `end(slot, begin)`
+/// after it; both do nothing when the loop is not profiled.
+class Region
+{
+ public:
+  Region(RegionSlots& slots, int concurrency, std::uint64_t elements);
+  ~Region();
+  Region(const Region&) = delete;
+  Region& operator=(const Region&) = delete;
+  Region(Region&&) = delete;
+  Region& operator=(Region&&) = delete;
+
+  [[nodiscard]] std::int64_t begin() const noexcept { return mContext != nullptr ? now() : 0; }
+  void end(int slot, std::int64_t begin) const noexcept;
+
+ private:
+  Context* mContext = nullptr;
+  Trace* mTrace = nullptr;
+  Phase mPhase = Phase::kNone;
+  RegionSlots::Slot* mSlots = nullptr;
+  std::size_t mSlotCount = 0U;
+  int mConcurrency = 1;
+  std::uint64_t mElements = 0U;
+  std::int64_t mBegin = 0;
+};
+
+/// Which phases a stage's reset, generate, scan and place are.
+struct StagePhases {
+  Phase reset = Phase::kNone;
+  Phase generate = Phase::kNone;
+  Phase scan = Phase::kNone;
+  Phase place = Phase::kNone;
+};
+
+} // namespace o2::gtrk::profile
+
+#endif // GTRK_TRACKING_PROFILE_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Propagator.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Propagator.h
new file mode 100644
index 0000000000000..26de4297dbb26
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Propagator.h
@@ -0,0 +1,505 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Propagator.h
+/// \brief Exact helix propagation between sensor planes in a uniform Bz.
+///
+/// A Propagator is configuration and nothing else: field, tolerances and the
+/// mass hypothesis.  It is a plain struct so it copies into device constant memory as
+/// one object, and every operation on it is a free function.  There are no
+/// virtual calls: a field-map propagator later is a different type with the
+/// same operations, chosen at compile time.
+
+#ifndef GTRK_TRACKING_PROPAGATOR_H_
+#define GTRK_TRACKING_PROPAGATOR_H_
+
+#include "GenericTracking/Base/Definitions.h"
+#include "GenericTracking/Tracking/BoundTrackState.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/MathUtils.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tracking/Trig.h"
+#include "GenericTracking/Tracking/WorkCounters.h"
+
+#include "CommonConstants/MathConstants.h"
+#include "CommonConstants/PhysicsConstants.h"
+#include "GPUCommonMath.h"
+#include "MathUtils/detail/trigonometric.h"
+
+#include <cstdint>
+
+namespace o2::gtrk
+{
+
+/// Field, tolerances and the mass hypothesis. Copied by value into kernels.
+struct Propagator {
+  /// Longitudinal field in kGauss, O2's unit: 20 is 2 T.
+  Scalar bzKiloGauss = 20.F;
+
+  /// Smallest |normal . direction| at which the bound representation is still
+  /// meaningful: at 0.01, about 89.4 degrees, a track crosses a 125 um barrel
+  /// sensor over 1.25 cm, still through it; primaries from the diamond's tail
+  /// reach 0.04 at the far end of barrel layer 0.
+  Scalar minAbsCosIncidence = 0.01F;
+
+  /// The mass hypothesis [GeV], positive: beta for the scattering, and the
+  /// energy loss of the fitting stages.
+  Scalar massGeV = static_cast<Scalar>(o2::constants::physics::MassPionCharged);
+
+  /// Transverse curvature in 1/cm.
+  ///
+  /// kappa = (q/pT) * Bz * B2C, with q/pT = (q/p) / sin(theta). B2C carries
+  /// its own sign, which is how the charge convention arrives without being
+  /// restated here.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() ExactScalar curvature(ExactScalar qOverP, ExactScalar sinTheta) const { return (qOverP / sinTheta) * static_cast<ExactScalar>(bzKiloGauss) * static_cast<ExactScalar>(constants::math::B2C); }
+};
+
+/// What a propagation did and how far it went.
+struct PropagationResult {
+  PropagationStatus status = PropagationStatus::kNotFinite;
+  Scalar pathLength = 0.F; ///< signed 3D path length [cm]
+};
+
+/// The uniform propagator a step is taken with.
+///
+/// `propagate`, `jacobianAnalytic` and `curvature` only ever see a uniform
+/// field. Code above them asks for each step's propagator through these two
+/// and hands on what they return. For a `Propagator` that is the propagator
+/// itself: both return their argument by reference and look at nothing else,
+/// so the default model pays nothing for them. A
+/// field-map propagator is a different type and returns a `Propagator` by
+/// value, with the step's own Bz.
+///
+/// The reference they return is the argument's, so a temporary propagator
+/// would leave it dangling; the rvalue overloads are deleted for that.
+///
+/// The step from the chain's measurement \a from to its measurement \a to.
+/// It takes indices rather than measurements so that a chain which reads its
+/// rows from columns (`RowChain`) is not read for a field that does not look.
+template <typename Geometry, typename Chain>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() const Propagator& stepPropagator(const Propagator& prop, const Geometry& /*geometry*/, const Chain& /*measurements*/, int /*from*/, int /*to*/)
+{
+  // The deleted rvalue overload below covers it; clang-tidy does not see that
+  // for a template.
+  return prop; // NOLINT(bugprone-return-const-ref-from-parameter)
+}
+template <typename Geometry, typename Chain>
+const Propagator& stepPropagator(const Propagator&& prop, const Geometry& geometry, const Chain& measurements, int from, int to) = delete;
+
+/// A step from \a point -- a bound state or a measurement -- on \a surface
+/// towards a point not known yet: a layer crossing to predict, a candidate
+/// cluster to try, the perigee. The point is passed whole, not its
+/// coordinates, so the default model reads nothing for it either.
+template <typename Point>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() const Propagator& pointPropagator(const Propagator& prop, const TrackingSurface& /*surface*/, const Point& /*point*/)
+{
+  // As for stepPropagator.
+  return prop; // NOLINT(bugprone-return-const-ref-from-parameter)
+}
+template <typename Point>
+const Propagator& pointPropagator(const Propagator&& prop, const TrackingSurface& surface, const Point& point) = delete;
+
+namespace detail
+{
+
+/// The reference direction already evaluated by the FP64 plane solve.
+/// Shared with the Jacobian to avoid evaluating it a second time.
+struct PropagationTrig {
+  ExactScalar sinPhi = 0.;
+  ExactScalar cosPhi = 0.;
+  ExactScalar sinTheta = 0.;
+  ExactScalar cosTheta = 0.;
+  /// The direction rotated to the arrival, as the incidence test had it: the
+  /// covariance transport reuses it on every backend alike.
+  Scalar sinPhiArrival = 0.F;
+  Scalar cosPhiArrival = 0.F;
+};
+
+/// Global position of a bound state on its own surface.
+GPUhdi() GPUAlwaysInline() void boundToGlobal(const TrackingSurface& surface, ExactScalar loc0, ExactScalar loc1, ExactScalar global[3])
+{
+  for (int i = 0; i < 3; ++i) {
+    global[i] = static_cast<ExactScalar>(surface.origin[i]) + loc0 * static_cast<ExactScalar>(surface.axis0[i]) + loc1 * static_cast<ExactScalar>(surface.axis1[i]);
+  }
+}
+
+/// Displacement of a bound state from the target surface origin.
+///
+/// Keeping the origin difference separate avoids forming a large global point
+/// only to subtract another large global point in the intersection and final
+/// projection. Both origins are floats, so their difference is exact, and what
+/// the solve then carries is a distance between two sensors rather than a
+/// distance from the interaction point.
+GPUhdi() GPUAlwaysInline() void boundDisplacement(const TrackingSurface& from, const TrackingSurface& to, ExactScalar loc0, ExactScalar loc1, ExactScalar delta[3])
+{
+  for (int i = 0; i < 3; ++i) {
+    delta[i] = (static_cast<ExactScalar>(from.origin[i]) - static_cast<ExactScalar>(to.origin[i])) + loc0 * static_cast<ExactScalar>(from.axis0[i]) + loc1 * static_cast<ExactScalar>(from.axis1[i]);
+  }
+}
+
+/// Where a crossing displaced from the target by \a fromTarget + (dxy, dz)
+/// lands in the target plane, as local coordinates.
+GPUhdi() GPUAlwaysInline() void crossingLocal(const TrackingSurface& to, const ExactScalar fromTarget[3], const ExactScalar dxy[2], ExactScalar dz, ExactScalar loc[2])
+{
+  const ExactScalar d[3] = {fromTarget[0] + dxy[0], fromTarget[1] + dxy[1], fromTarget[2] + dz};
+  loc[0] = 0.;
+  loc[1] = 0.;
+  for (int i = 0; i < 3; ++i) {
+    loc[0] += d[i] * static_cast<ExactScalar>(to.axis0[i]);
+    loc[1] += d[i] * static_cast<ExactScalar>(to.axis1[i]);
+  }
+}
+
+GPUhdi() GPUAlwaysInline() ExactScalar offCentreSquared(const TrackingSurface& to, const ExactScalar fromTarget[3], const ExactScalar dxy[2], ExactScalar dz)
+{
+  ExactScalar loc[2];
+  crossingLocal(to, fromTarget, dxy, dz, loc);
+  return (loc[0] * loc[0]) + (loc[1] * loc[1]);
+}
+
+/// A crossing as the other crossing rules see it (`CrossingRule`): its
+/// squared distance from the target's centre, as `offCentreSquared`, and
+/// whether it lies inside the sensor's bounds.
+struct CrossingPlace {
+  ExactScalar offCentre2 = 0.;
+  bool inside = false;
+};
+GPUhdi() GPUAlwaysInline() CrossingPlace crossingPlace(const TrackingSurface& to, const ExactScalar fromTarget[3], const ExactScalar dxy[2], ExactScalar dz)
+{
+  ExactScalar loc[2];
+  crossingLocal(to, fromTarget, dxy, dz, loc);
+  return {.offCentre2 = (loc[0] * loc[0]) + (loc[1] * loc[1]), .inside = to.bounds.isInside(static_cast<Scalar>(loc[0]), static_cast<Scalar>(loc[1]))};
+}
+
+} // namespace detail
+
+/// Advance \a state from the plane it is bound to onto \a to.
+///
+/// The intersection and the path-length solve run in ExactScalar and narrow on
+/// return. The budget is 1 um across a detector reaching |z| = 300 cm, where a
+/// float ulp is already 3.05e-5 cm, and the incidence cut admits crossings at
+/// |n . d| = 0.01, which turns an error in the distance to the target plane
+/// into a hundred times that along it. Ten nanometres of headroom in the solve,
+/// 1e-6 cm, is below a float's resolution at this range, with or without an
+/// error-free transform, so the solve is where the FP64 goes.
+///
+/// Everything outside the solve is Scalar, because it either ends up in a float
+/// record or only has to clear a tolerance: the final direction, the incidence
+/// test, the bounds test. Inputs are taken as finite -- they come from the fit,
+/// not from a file -- so only results that can legitimately run away, the
+/// second root of a straight track above all, are tested.
+///
+/// On kOk and kOutOfBounds the state is updated; on every other status it is
+/// left untouched, so a caller that ignores the return value cannot silently
+/// continue with a meaningless state. kOutOfBounds updates because the bound
+/// is reported rather than enforced: a fit may want the intersection, a
+/// search will not.
+///
+/// \a Rule is which of a barrel plane's two crossings is taken
+/// (`CrossingRule`); the default takes the first root ahead, and the others
+/// are their own instantiations.
+template <CrossingRule Rule = CrossingRule::kFirstAhead>
+GPUdi() PropagationResult propagate(const Propagator& prop, BoundTrackState& state, const TrackingSurface& from, const TrackingSurface& to, PropagationDirection dir, detail::PropagationTrig* referenceTrig = nullptr)
+{
+  using Math = o2::gpu::GPUCommonMath;
+  PropagationResult res;
+
+  const auto phi0 = static_cast<ExactScalar>(state.phi());
+  const auto theta0 = static_cast<ExactScalar>(state.theta());
+
+  // Evaluate the stored direction in Scalar, then retain FP64 throughout the
+  // plane solve. The independent helix-closure sweep bounds the direction
+  // rounding together with the solve/storage error.
+  ExactScalar sinPhi = 0.;
+  ExactScalar cosPhi = 0.;
+  ExactScalar sinTheta = 0.;
+  ExactScalar cosTheta = 0.;
+  directionSincosOf(static_cast<Scalar>(phi0), sinPhi, cosPhi);
+  directionSincosOf(static_cast<Scalar>(theta0), sinTheta, cosTheta);
+
+  // A track exactly along the beam has no transverse motion and no bound
+  // representation on any plane here.
+  if (Math::Abs(sinTheta) < ExactScalar{1e-9}) {
+    res.status = PropagationStatus::kNotFinite;
+    return res;
+  }
+
+  const ExactScalar kappa = prop.curvature(static_cast<ExactScalar>(state.qOverP()), sinTheta);
+
+  ExactScalar fromTarget[3] = {};
+  detail::boundDisplacement(from, to, static_cast<ExactScalar>(state.loc0()), static_cast<ExactScalar>(state.loc1()), fromTarget);
+
+  // Transverse direction and its left normal; the pair spans the plane the
+  // circle lives in.
+  const ExactScalar dT[2] = {cosPhi, sinPhi};
+  const ExactScalar perp[2] = {-sinPhi, cosPhi};
+
+  const auto nx = static_cast<ExactScalar>(to.normal[0]);
+  const auto ny = static_cast<ExactScalar>(to.normal[1]);
+  const auto nz = static_cast<ExactScalar>(to.normal[2]);
+
+  ExactScalar path = 0.;   // 3D path length
+  ExactScalar psi = 0.;    // turn angle
+  ExactScalar dxy[2] = {}; // transverse displacement from r0
+  // The turn's sine and cosine, kept because the chord already contains them.
+  ExactScalar turnSin = 0.;
+  ExactScalar turnCos = 1.;
+
+  if (Math::Abs(nz) > ExactScalar{0.5}) {
+    // A disc: the normal is along z, so z is linear in path length and the
+    // solve is a division. Nothing about the helix enters it.
+    if (Math::Abs(cosTheta) < static_cast<ExactScalar>(prop.minAbsCosIncidence)) {
+      res.status = PropagationStatus::kGrazing;
+      return res;
+    }
+    path = -fromTarget[2] / cosTheta;
+    const ExactScalar ell = path * sinTheta;
+    psi = kappa * ell;
+    const auto sA = sinc<ExactScalar>(psi);
+    const auto sB = versine<ExactScalar>(psi);
+    dxy[0] = ell * (dT[0] * sA + perp[0] * sB);
+    dxy[1] = ell * (dT[1] * sA + perp[1] * sB);
+    // sin(psi) = psi sinc(psi) and cos(psi) = 1 - psi versine(psi), from the
+    // series that is already evaluated rather than from a second sincos.
+    turnSin = psi * sA;
+    turnCos = 1. - psi * sB;
+  } else {
+    // A barrel sensor: the normal has no z component, so the plane projects to
+    // a *line* in the transverse plane while the trajectory projects to a
+    // circle. Circle-line intersection is a quadratic, and the whole solve is
+    // closed form.
+    //
+    // Writing the circle as |delta|^2 = 2 delta . e about the start point --
+    // rather than about its centre, which runs away as the curvature vanishes
+    // -- gives
+    //
+    //     A mu^2 - 2 B mu + C = 0,   B = dT . n,  C = a (A a - 2 dT . t)
+    //
+    // in the offset mu along the line, with a the signed distance to the plane
+    // and A = kappa |n|^2. Both coefficients stay finite as kappa -> 0, and
+    // taking the root in the form C / (B + sign(B) sqrt(D)) removes the
+    // cancellation *and* the straight-line special case: at kappa = 0 it
+    // collapses exactly to mu = -a (dT.t) / (dT.n).
+    const ExactScalar tx = -ny;
+    const ExactScalar ty = nx;
+
+    // The stored normal is a float triplet, so its norm is one only to within
+    // a float's last bit. Carrying |n|^2 costs one divide and makes the solve
+    // exact for the plane as stored, instead of scaling that last bit by the
+    // hundredfold a grazing crossing applies to the distance to the plane.
+    const ExactScalar normal2 = nx * nx + ny * ny;
+    const ExactScalar a = (nx * fromTarget[0] + ny * fromTarget[1]) / normal2;
+    const ExactScalar quadratic = kappa * normal2;
+
+    const ExactScalar bCoef = dT[0] * nx + dT[1] * ny;
+    const ExactScalar tangent = dT[0] * tx + dT[1] * ty;
+    const ExactScalar cCoef = a * (quadratic * a - ExactScalar{2} * tangent);
+
+    // sqrt(D) is the transverse incidence at the crossing, so D cancels only
+    // where the circle is tangent to the line -- and there the crossing does
+    // not clear minAbsCosIncidence anyway. Inside the accepted band the
+    // cancellation is bounded by that cut, 1e-4 of the terms, which leaves a
+    // double twelve digits.
+    const ExactScalar disc = bCoef * bCoef - quadratic * cCoef;
+    if (disc < ExactScalar{0}) {
+      // The circle never reaches the line: the track curls before the target
+      // radius. A fact about the track, not a failure.
+      res.status = PropagationStatus::kNoIntersection;
+      return res;
+    }
+    const ExactScalar den = bCoef + (bCoef >= ExactScalar{0} ? ExactScalar{1} : ExactScalar{-1}) * o2::math_utils::detail::sqrt(disc);
+    if (Math::Abs(den) < ExactScalar{1e-30}) {
+      res.status = PropagationStatus::kNoIntersection;
+      return res;
+    }
+
+    // A line cuts the circle twice, and which crossing is the sensor's is a
+    // question about the geometry, not about the arithmetic. C / den is the
+    // root of smaller magnitude: the stable form, and the right crossing
+    // whenever the turn is small. Once the target's normal is far enough from
+    // radial at the crossing -- a tilted stave, a cluster away from the module
+    // centre -- the two swap, and at a 30 to 100 degree turn between adjacent
+    // layers, which is what a 0.3 GeV track makes, the small root becomes a
+    // crossing of the plane's infinite extension tens of cm from the sensor.
+    //
+    // So the small root is tried first and kept whenever it is usable; the
+    // second root, den / A, is reached only where the first is not usable at
+    // all. As kappa -> 0 the second runs away and stops being finite, which is how
+    // the straight line keeps having one solution without a special case; it
+    // is also why it is not divided out before it is needed.
+    //
+    // The second root is taken only when it lands *nearer the target's centre*
+    // than the first, which is the diagnosis stated as a condition: the first
+    // root is the extension and the second is the sensor. Without that guard
+    // it also answers a question the wrong-direction status was right to
+    // decline -- a track pointing away from the target reaches it after
+    // sweeping most of a circle, 20 to 60 m of path, and no linearisation of
+    // that is worth anything.
+    //
+    // Not addressed by the default: the small root can also be the wrong
+    // crossing while still running the right way, in which case nothing is
+    // reported and the update simply sees a large residual. A looper's inward
+    // refit from its way back onto an outer barrel layer of its way out does
+    // exactly that, and fails a step or two later. The other rules (`CrossingRule`) look at the second root even when
+    // the first lies ahead: kNearerCentre takes it where it lies ahead and
+    // nearer the centre, kInsideFirst only where the first is outside the
+    // sensor and the second inside or, neither inside, nearer the centre.
+    // Selecting on the bounds moves the chosen root at the sensor edge, where
+    // testCovarianceTransport takes a derivative by finite differences; the
+    // ties go to the first root.
+    // The default: the first root, unless it is not usable and the second
+    // lands nearer the centre. The other rules, each its own instantiation:
+    // the second where the rule moves off the first.
+    [[maybe_unused]] ExactScalar firstOffCentre = 0.; // NOLINT(misc-const-correctness): written in a dependent call the check does not see
+    [[maybe_unused]] detail::CrossingPlace first;     // NOLINT(misc-const-correctness): written in a dependent call the check does not see
+    [[maybe_unused]] bool firstAhead = false;         // NOLINT(misc-const-correctness): written in a dependent call the check does not see
+    for (int root = 0; root < 2; ++root) {
+      const ExactScalar mu = root == 0 ? cCoef / den : den / quadratic;
+      const ExactScalar tryDxy[2] = {-a * nx + mu * tx, -a * ny + mu * ty};
+
+      // Recover the turn from the chord: sin(psi) = kappa (delta . dT) and
+      // cos(psi) = 1 - kappa (delta . perp), both exact and both bounded. It
+      // is the principal turn, so this holds for |turn| <= pi over one step,
+      // well above a turn between adjacent layers.
+      const ExactScalar alongD = (tryDxy[0] * dT[0]) + (tryDxy[1] * dT[1]);
+      const ExactScalar alongP = (tryDxy[0] * perp[0]) + (tryDxy[1] * perp[1]);
+      const ExactScalar trySin = kappa * alongD;
+      const ExactScalar tryCos = ExactScalar{1} - kappa * alongP;
+      const auto tryPsi = atan2Of(trySin, tryCos);
+
+      // ell = psi / kappa is 0/0 for a straight track; ell = (delta.dT)/sinc(psi)
+      // is the same number and is regular there. The quotient is the one to
+      // take near zero only: sinc vanishes at a half turn, where psi / kappa
+      // is the well-conditioned form.
+      const ExactScalar ell = Math::Abs(tryPsi) < ExactScalar{0.01} ? alongD / sinc<ExactScalar>(tryPsi) : tryPsi / kappa;
+      const ExactScalar tryPath = ell / sinTheta;
+
+      const bool usable = isFiniteScalar(static_cast<Scalar>(tryPath)) && tryPath * static_cast<ExactScalar>(static_cast<int>(dir)) >= ExactScalar{0};
+      bool take = root == 0;
+      if constexpr (Rule == CrossingRule::kFirstAhead) {
+        if (root != 0) {
+          take = usable && detail::offCentreSquared(to, fromTarget, tryDxy, tryPath * cosTheta) < firstOffCentre;
+        }
+      } else {
+        const auto place = detail::crossingPlace(to, fromTarget, tryDxy, tryPath * cosTheta);
+        if (root == 0) {
+          first = place;
+          firstAhead = usable;
+        } else if constexpr (Rule == CrossingRule::kInsideFirst) {
+          // The first, if ahead, is outside: the second if it is inside or,
+          // neither inside, nearer the centre; with the first behind, as the
+          // default.
+          take = usable && (place.offCentre2 < first.offCentre2 || (firstAhead && place.inside));
+        } else {
+          take = usable && place.offCentre2 < first.offCentre2;
+        }
+      }
+      if (take) {
+        dxy[0] = tryDxy[0];
+        dxy[1] = tryDxy[1];
+        psi = tryPsi;
+        path = tryPath;
+        turnSin = trySin;
+        turnCos = tryCos;
+      }
+      if constexpr (Rule == CrossingRule::kFirstAhead) {
+        if (root == 0) {
+          if (usable) {
+            break; // the overwhelming majority: nothing below is reached or paid for
+          }
+          firstOffCentre = detail::offCentreSquared(to, fromTarget, tryDxy, tryPath * cosTheta);
+        }
+      } else if constexpr (Rule == CrossingRule::kInsideFirst) {
+        if (root == 0 && usable && first.inside) {
+          break;
+        }
+      }
+    }
+  }
+
+  // Asked as a float, because a float is what gets stored: a double too large
+  // to narrow is exactly the case this has to reject.
+  if (!isFiniteScalar(static_cast<Scalar>(path))) {
+    res.status = PropagationStatus::kNotFinite;
+    return res;
+  }
+
+  const auto wanted = static_cast<ExactScalar>(static_cast<int>(dir));
+  if (path * wanted < ExactScalar{0}) {
+    res.status = PropagationStatus::kWrongDirection;
+    res.pathLength = static_cast<Scalar>(path);
+    return res;
+  }
+
+  // The direction only rotates in azimuth; theta and |p| are invariant in a
+  // uniform longitudinal field, which is why neither is recomputed. The turn's
+  // sine and cosine came out of the chord, so this is a rotation rather than a
+  // second sincos -- and it is asked in Scalar, because the azimuth is stored
+  // as one and the incidence only has to clear a tolerance.
+  ExactScalar phi1 = phi0 + psi;
+  math_utils::detail::bringToPMPi<ExactScalar>(phi1);
+
+  const auto sinTurn = static_cast<Scalar>(turnSin);
+  const auto cosTurn = static_cast<Scalar>(turnCos);
+  const Scalar sinPhi1 = static_cast<Scalar>(sinPhi) * cosTurn + static_cast<Scalar>(cosPhi) * sinTurn;
+  const Scalar cosPhi1 = static_cast<Scalar>(cosPhi) * cosTurn - static_cast<Scalar>(sinPhi) * sinTurn;
+  const auto sinThetaF = static_cast<Scalar>(sinTheta);
+  const Scalar dir1[3] = {sinThetaF * cosPhi1, sinThetaF * sinPhi1, static_cast<Scalar>(cosTheta)};
+
+  const Scalar cosInc = cosIncidence(to, dir1);
+  countWork(WorkCounter::kPropagations);
+  if (Math::Abs(cosInc) <= 0.1F) {
+    countWork(WorkCounter::kPropagationsGrazing);
+  }
+  if (Math::Abs(cosInc) < prop.minAbsCosIncidence) {
+    res.status = PropagationStatus::kGrazing;
+    res.pathLength = static_cast<Scalar>(path);
+    return res;
+  }
+
+  // Bind to the target plane.  The out-of-plane component is not computed: it
+  // is zero by construction, and checking it at run time would be checking the
+  // algebra rather than the data.  testPropagator.cxx checks it instead.
+  const ExactScalar d0 = fromTarget[0] + dxy[0];
+  const ExactScalar d1 = fromTarget[1] + dxy[1];
+  const ExactScalar d2 = fromTarget[2] + path * cosTheta;
+  const ExactScalar loc0 = d0 * static_cast<ExactScalar>(to.axis0[0]) + d1 * static_cast<ExactScalar>(to.axis0[1]) + d2 * static_cast<ExactScalar>(to.axis0[2]);
+  const ExactScalar loc1 = d0 * static_cast<ExactScalar>(to.axis1[0]) + d1 * static_cast<ExactScalar>(to.axis1[1]) + d2 * static_cast<ExactScalar>(to.axis1[2]);
+
+  // What is about to be stored, asked as floats like the path. A disc's path
+  // is finite whatever the azimuth or the curvature, so a NaN in either shows
+  // up here first: in the displacement, and so in the bound coordinates, and
+  // the incidence test above does not reject a NaN. Every comparison on the
+  // way down evaluates false for one, so without this test a NaN state would
+  // come back as kOutOfBounds with the NaNs written.
+  if (!isFiniteScalar(static_cast<Scalar>(loc0)) || !isFiniteScalar(static_cast<Scalar>(loc1)) || !isFiniteScalar(static_cast<Scalar>(phi1))) {
+    res.status = PropagationStatus::kNotFinite;
+    return res;
+  }
+
+  state.par[kLoc0] = static_cast<Scalar>(loc0);
+  state.par[kLoc1] = static_cast<Scalar>(loc1);
+  state.par[kPhi] = static_cast<Scalar>(phi1);
+  // theta and q/p are untouched on purpose.
+  state.surface = to.id;
+  state.surfacePhi = to.surfacePhi;
+
+  res.pathLength = static_cast<Scalar>(path);
+  res.status = to.bounds.isInside(state.par[kLoc0], state.par[kLoc1]) ? PropagationStatus::kOk : PropagationStatus::kOutOfBounds;
+  if (referenceTrig != nullptr) {
+    *referenceTrig = {.sinPhi = sinPhi, .cosPhi = cosPhi, .sinTheta = sinTheta, .cosTheta = cosTheta, .sinPhiArrival = sinPhi1, .cosPhiArrival = cosPhi1};
+  }
+  return res;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_PROPAGATOR_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/RoadCount.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/RoadCount.h
new file mode 100644
index 0000000000000..572149196e78c
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/RoadCount.h
@@ -0,0 +1,244 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file RoadCount.h
+/// \brief Where roads start and how many leave each triplet.
+///
+/// A road is a chain of triplets `T_1, ..., T_L`, `T_i` a predecessor of
+/// `T_{i+1}` and at level `i`. It starts at a triplet without a successor
+/// exactly one level above, and descends through predecessors exactly one
+/// level below, so every triplet lies on one; an iteration with an end-layer
+/// mask starts them instead at every triplet ending on one of its layers
+/// (`RoadStartRule`). The number of roads through a
+/// triplet down to level 1 is the sum over those predecessors; the base case
+/// counts only a level-1 triplet whose first measurement -- the road's
+/// innermost -- is in the slice's core, so only the roads the core owns are
+/// counted.
+
+#ifndef GTRK_TRACKING_ROADCOUNT_H_
+#define GTRK_TRACKING_ROADCOUNT_H_
+
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Base/HostAlgorithms.h"
+#include "GenericTracking/Tracking/MeasurementRange.h"
+#include "GenericTracking/Tracking/Neighbour.h"
+#include "GenericTracking/Tracking/OrderedRoadCounts.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/Profile.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/Triplet.h"
+
+#include "GPUCommonAlgorithm.h"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+#include <span>
+
+namespace o2::gtrk
+{
+
+/// The core ranges the road counting reads (`OrderedRoadCounts::base`):
+/// \a core with the layers a road may not start on emptied
+/// (`IterationParameters::roadStartLayers`, 0 for any), so a road whose
+/// innermost measurement lies there is none, as one starting outside the core.
+template <std::size_t N>
+[[nodiscard]] inline std::array<MeasurementRange, N> roadCores(std::span<const MeasurementRange, N> core, std::uint64_t startLayers)
+{
+  std::array<MeasurementRange, N> cores{};
+  for (std::size_t layer = 0U; layer < N; ++layer) {
+    cores[layer] = startLayers == 0U || ((startLayers >> layer) & 1U) != 0U ? core[layer] : MeasurementRange{core[layer].begin, core[layer].begin};
+  }
+  return cores;
+}
+
+/// Which triplets roads start at: at level `minLevel` or higher, with a road,
+/// and -- without an end-layer mask -- without a successor exactly one level
+/// above, or -- with one -- with their last measurement on a layer of the
+/// mask, whatever extends them (`IterationSettings::roadEndLayers`).
+struct RoadStartRule {
+  std::uint32_t minLevel = 2U;
+  std::uint64_t endLayers = 0U;         ///< a bit per layer; 0 for any
+  const LayerID* linkTargets = nullptr; ///< per link; read only with a mask
+
+  GPUhdi() GPUAlwaysInline() bool operator()(TrackletConstView tracklets, TripletConstView triplets, const std::uint32_t* successorAbove, const std::uint32_t* roads, StageOutput<TripletT>::Index triplet) const
+  {
+    if (triplets.level[triplet] < minLevel || roads[triplet] == 0U) {
+      return false;
+    }
+    if (endLayers == 0U) {
+      return successorAbove[triplet] == 0U;
+    }
+    const LayerID end = linkTargets[tracklets.link[triplets.second[triplet]]];
+    return ((endLayers >> end) & 1U) != 0U;
+  }
+};
+
+/// An iteration's rule, reading its link targets on the host.
+template <DetectorLayout Det>
+[[nodiscard]] inline RoadStartRule roadStartRule(const IterationParameters<Det>& parameters)
+{
+  return {.minLevel = parameters.minRoadStartLevel, .endLayers = parameters.roadEndLayers, .linkTargets = parameters.linkTargets};
+}
+
+/// One road by its index: the start by a binary search in the starts' road
+/// offsets, then down level by level through the predecessors exactly one
+/// level below, in the neighbour stage's order, subtracting the roads of each
+/// one passed over until the index falls inside one (as GBTS's
+/// `gbts_fill_path_store`). The walk's steps are the road's levels, each a
+/// scan of one triplet's predecessors; road `r` is the same road on every
+/// backend.
+class RoadWalk
+{
+ public:
+  using Index = StageOutput<TripletT>::Index;
+
+  RoadWalk(const Index* starts, const Index* roadOffsets, Index startCount, const Index* neighbourOffsets, const Index* from, const std::uint32_t* level, const std::uint32_t* roads)
+    : mStarts(starts),
+      mRoadOffsets(roadOffsets),
+      mStartCount(startCount),
+      mNeighbourOffsets(neighbourOffsets),
+      mFrom(from),
+      mLevel(level),
+      mRoads(roads)
+  {
+  }
+
+  /// Write road \a road's triplets to \a triplets, innermost first:
+  /// `triplets[i]` is the one at level `i + 1`. \a triplets holds the start's
+  /// level, at most `maxChainLayers - 2`. Returns that level.
+  GPUhdi() std::uint32_t operator()(Index road, Index* triplets) const
+  {
+    const Index first = o2::gpu::CAAlgo::partitionPoint(Index{0U}, mStartCount, [&](Index start) { return mRoadOffsets[start + 1U] <= road; });
+    Index current = mStarts[first];
+    std::uint32_t remainder = road - mRoadOffsets[first];
+    const std::uint32_t length = mLevel[current];
+    triplets[length - 1U] = current;
+    for (std::uint32_t level = length; level > 1U; --level) {
+      for (Index edge = mNeighbourOffsets[current]; edge < mNeighbourOffsets[current + 1U]; ++edge) {
+        const Index predecessor = mFrom[edge];
+        if (mLevel[predecessor] + 1U != level) {
+          continue;
+        }
+        if (remainder < mRoads[predecessor]) {
+          current = predecessor;
+          break;
+        }
+        remainder -= mRoads[predecessor];
+      }
+      triplets[level - 2U] = current;
+    }
+    return length;
+  }
+
+ private:
+  const Index* mStarts = nullptr;
+  const Index* mRoadOffsets = nullptr;
+  Index mStartCount = 0U;
+  const Index* mNeighbourOffsets = nullptr;
+  const Index* mFrom = nullptr;
+  const std::uint32_t* mLevel = nullptr;
+  const std::uint32_t* mRoads = nullptr;
+};
+
+/// The successor flags, the road counts, the start triplets of one slice's
+/// roads and their numbering.
+class RoadCount
+{
+ public:
+  using Index = StageOutput<TripletT>::Index;
+
+  RoadCount() = default;
+  ~RoadCount() = default;
+  RoadCount(const RoadCount&) = delete;
+  RoadCount& operator=(const RoadCount&) = delete;
+  RoadCount(RoadCount&&) = delete;
+  RoadCount& operator=(RoadCount&&) = delete;
+
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
+  {
+    mMemoryPool.swap(pool);
+    clearStorage();
+  }
+
+  /// Storage for counts finalized by ordered neighbour generation. Every
+  /// triplet writes its count before a successor can read it; only the shared
+  /// flags need an initial fill. Failures are handled by the caller's guard.
+  template <typename ForEach>
+  void prepareOrdered(ForEach forEach, Index count)
+  {
+    const profile::Zone zone{profile::Phase::kRoadFills};
+    resizeBoundedVector(mSuccessorAbove, count);
+    resizeBoundedVector(mRoads, count);
+    mOrderedOverflow = 0U;
+    forEach(count, [&](Index triplet) { mSuccessorAbove[triplet] = 0U; });
+  }
+
+  [[nodiscard]] OrderedRoadCounts ordered(const LayerID* linkSources, const MeasurementRange* core) { return {.roads = mRoads.data(), .successorAbove = mSuccessorAbove.data(), .overflow = &mOrderedOverflow, .linkSources = linkSources, .core = core}; }
+
+  /// Counts and successor flags were finalized during neighbour generation.
+  /// Select and number the starts from the counts the neighbour generation
+  /// finalized.
+  template <typename ForEach>
+  [[nodiscard]] StageStatus runPrepared(ForEach forEach, const RoadStartRule& startRule, const StageOutput<TrackletT>& tracklets, const StageOutput<TripletT>& triplets, Index chunkSize)
+  {
+    return guardOutOfMemory([&] {
+      if (mOrderedOverflow != 0U) {
+        return StageStatus::kIndexOverflow;
+      }
+      return number(forEach, startRule, tracklets, triplets, chunkSize);
+    });
+  }
+
+  void clearStorage() noexcept { deepVectorClear(mMemoryPool.get(), mSuccessorAbove, mRoads, mStarts, mRoadOffsets); }
+
+  /// Per triplet: 1 if a successor sits exactly one level above it.
+  [[nodiscard]] std::span<const std::uint32_t> successorAbove() const { return mSuccessorAbove; }
+  /// Per triplet: the roads the core owns from it down to level 1.
+  [[nodiscard]] std::span<const std::uint32_t> roads() const { return mRoads; }
+  /// The triplets roads start at, in arena order.
+  [[nodiscard]] std::span<const Index> starts() const { return mStarts; }
+  /// Per start, the index of its first road, and the total at the end.
+  [[nodiscard]] std::span<const Index> roadOffsets() const { return mRoadOffsets; }
+  /// The number of roads the slice owns.
+  [[nodiscard]] Index roadCount() const { return mRoadOffsets.empty() ? 0U : mRoadOffsets.back(); }
+
+  /// The walk to any of them, over the triplets and neighbours counted.
+  [[nodiscard]] RoadWalk walk(const StageOutput<TripletT>& triplets, const StageOutput<NeighbourT>& neighbours) const { return {mStarts.data(), mRoadOffsets.data(), static_cast<Index>(mStarts.size()), neighbours.offsets().data(), neighbours.view().from, triplets.view().level, mRoads.data()}; }
+
+ private:
+  template <typename ForEach>
+  [[nodiscard]] StageStatus number(ForEach forEach, const RoadStartRule& startRule, const StageOutput<TrackletT>& tracklets, const StageOutput<TripletT>& triplets, Index chunkSize)
+  {
+    const profile::Zone zone{profile::Phase::kRoadStarts};
+    const auto view = triplets.view();
+    const auto trackletView = tracklets.view();
+    host_algorithms::compactIndices(forEach, triplets.size(), chunkSize, [&](Index triplet) { return startRule(trackletView, view, mSuccessorAbove.data(), mRoads.data(), triplet); }, mStarts);
+    const auto starts = static_cast<Index>(mStarts.size());
+    resizeBoundedVector(mRoadOffsets, std::size_t{starts} + 1U);
+    if (!host_algorithms::exclusiveScan(forEach, starts, chunkSize, [&](Index start) { return mRoads[mStarts[start]]; }, mRoadOffsets, mMemoryPool.get())) {
+      return StageStatus::kIndexOverflow;
+    }
+    return StageStatus::kComplete;
+  }
+
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  BoundedVector<std::uint32_t> mSuccessorAbove;
+  BoundedVector<std::uint32_t> mRoads;
+  BoundedVector<Index> mStarts;
+  BoundedVector<Index> mRoadOffsets;
+  Index mOrderedOverflow = 0U;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_ROADCOUNT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/RoadFit.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/RoadFit.h
new file mode 100644
index 0000000000000..fda09b03fb760
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/RoadFit.h
@@ -0,0 +1,308 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file RoadFit.h
+/// \brief The road fit's per-road function and the selection record it
+///        emits.
+
+#ifndef GTRK_TRACKING_ROADFIT_H_
+#define GTRK_TRACKING_ROADFIT_H_
+
+#include "GenericTracking/Base/LayerLinks.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/BeamConstraint.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Tracking/RoadCount.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/TrackFitter.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/Triplet.h"
+#include "GenericTracking/Tracking/WorkCounters.h"
+
+#include "GPUCommonMath.h"
+
+#include <memlayout/wrapper.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+
+namespace o2::gtrk
+{
+
+/// A road's measurement rows, innermost first; the slots past its count hold
+/// `kNoCluster`. \a K is the detector's longest chain. Rows are
+/// timeframe-global and unique like cluster indices, and what the used mask
+/// indexes; cluster indices are read only for the accepted tracks' output.
+template <std::size_t K>
+struct ClusterList {
+  static constexpr std::uint32_t kNoCluster = std::numeric_limits<std::uint32_t>::max();
+  std::uint32_t index[K];
+};
+
+/// What the global selection needs of a road: its clusters' rows, in
+/// road order -- a function of the set, the link table being acyclic -- and
+/// its chi2; and the outward pass's end state, which the refit of a selected
+/// road takes instead of running that pass again, and runs only the inward one.
+template <std::size_t K>
+struct SelectionRecordOf {
+  // As for TrackletT: upstream's `apply` macro also uses the member names as
+  // enum constants.
+  // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members,cppcoreguidelines-missing-std-forward,readability-identifier-naming)
+  template <template <class> class C>
+  struct RecordT {
+    MEMLAYOUT_APPLY(RecordT, clusters, count, chi2, kinks, outwardState)
+    C<ClusterList<K>> clusters;
+    C<std::uint8_t> count;           ///< clusters on the road
+    C<Scalar> chi2;                  ///< the outward pass's, over all of them
+    C<std::uint8_t> kinks;           ///< the outward pass's
+    C<BoundTrackState> outwardState; ///< the outward pass's, on the outermost surface
+  };
+  // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members,cppcoreguidelines-missing-std-forward,readability-identifier-naming)
+};
+
+/// Row \a row of \a frame as a fit reads it: only the nine columns it uses
+/// -- a whole row through the view's `operator[]` is a call that reads all
+/// nineteen.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Measurement measurementAt(const TimeFrame<Det>& frame, std::uint32_t row)
+{
+  const auto columns = frame.measurements();
+  return Measurement{
+    .loc0 = columns.loc0[row],
+    .loc1 = columns.loc1[row],
+    .timePS = columns.timePS[row],
+    .widthPS = columns.widthPS[row],
+    .varLoc0 = columns.varLoc0[row],
+    .covLoc01 = columns.covLoc01[row],
+    .varLoc1 = columns.varLoc1[row],
+    .clusterIndex = columns.clusterIndex[row],
+    .surface = columns.surface[row],
+  };
+}
+
+/// A road's measurements by their rows in the frame's columns: the fit reads
+/// one when it needs it instead of copying the road's worth into the element.
+template <DetectorLayout Det>
+struct RowChain {
+  const TimeFrame<Det>* frame = nullptr;
+  const std::uint32_t* rows = nullptr;
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Measurement operator[](int i) const { return measurementAt(*frame, rows[i]); }
+};
+
+/// Whether \a state, a fit of \a count clusters, is at or above the
+/// iteration's pT floor for that count.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool clearsPtFloor(const IterationParameters<Det>& parameters, std::uint32_t count, const BoundTrackState& state)
+{
+  const Scalar floor = parameters.minPtByClusters[count];
+  return !(floor > 0.F) || o2::gpu::CAMath::Abs(o2::gpu::CAMath::Sin(state.theta())) >= floor * o2::gpu::CAMath::Abs(state.qOverP());
+}
+
+/// Whether a road of \a count clusters the fit accepted clears the
+/// iteration's pT floor, at its outermost measurement. The floors are the
+/// final track's: a road is one only where the
+/// iteration does not follow; where it does, they act after the follow
+/// (`keptAfterFollow`, Follow.h) and every road clears them here. O2 applies its
+/// floor at the innermost, after the inward pass; between the two only the
+/// energy lost in the road's own layers differs.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool clearsPtFloor(const IterationParameters<Det>& parameters, std::uint32_t count, const RoadFitResult& fit)
+{
+  return parameters.follow || clearsPtFloor(parameters, count, fit.state);
+}
+
+/// The beam-line test of a road the fit accepted: its inward pass, as the refit runs it from \a outwardState, and
+/// the update of the inward state with the beam line (`updateWithBeamLine`);
+/// with a kink allowance, again with the scattering inside scaled by it if
+/// the nominal update is above the gate. False if either fails or the update
+/// is above the iteration's gate; \a chi2 is the update's.
+template <DetectorLayout Det, typename Material>
+[[nodiscard]] GPUdi() bool clearsBeamLine(const Propagator& propagator, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const std::uint32_t* rows, std::uint32_t count, const BoundTrackState& outwardState, Scalar& chi2)
+{
+  const auto inward = fitInward(propagator, geometry, material, RowChain<Det>{.frame = &frame, .rows = rows}, static_cast<int>(count), outwardState, kinkBudget(parameters));
+  if (inward.status != PropagationStatus::kOk) {
+    return false;
+  }
+  BoundTrackState state = inward.state;
+  const auto& plane = geometry.planeOf(state);
+  const LayerID layer = geometry.surface(state.surface).layer;
+  const auto point = pairPointAt(frame.measurements(), rows[0]);
+  auto update = updateWithBeamLine(propagator, parameters, plane, layer, point, state);
+  if (update.ok && !(update.chi2 <= parameters.beamChi2Max) && parameters.kinkScale2 > 1.F) {
+    // The kink allowance: the scattering inside scaled by it.
+    state = inward.state;
+    update = updateWithBeamLine(propagator, parameters, plane, layer, point, state, parameters.kinkScale2);
+  }
+  chi2 = update.chi2;
+  return update.ok && update.chi2 <= parameters.beamChi2Max;
+}
+
+/// One element per road, by its index: walk to it, drop it if its boxes share
+/// no time (with widened boxes a road can drift a frame per neighbour), fit its measurements with
+/// the outward pass, and emit its selection record if the chi2 is within the
+/// iteration's bound for its cluster count and its pT at or above its floor. Everything in the element has a
+/// size fixed by `maxChainLayers<Det>`. With \a BeamLine, for an iteration
+/// with `beamConstraint`, a road must also clear the beam line
+/// (`clearsBeamLine`), and its record's chi2 takes the update's. With
+/// \a NominalOnly the stage takes the roads of nominal
+/// triplets only: of a graph built with the next iteration's kink allowance,
+/// the roads its own iteration would have made (one graph for both rounds;
+/// the next iteration fits every road). With
+/// \a LastStepAllowance, for an iteration with a kink allowance, the fit's
+/// last step takes it (`fitOutward`, against the road-end fakes): the host and the device trackers instantiate it for such an
+/// iteration. With \a InnerTrim, for
+/// an iteration with `innerTrim`, a road the stage refuses -- no common
+/// time, the fit, the floor, the beam line -- is tried again without its
+/// innermost cluster, then without two, down to `innerTrim` of them and the
+/// iteration's `minClusters`, and the first the stage takes is the road's
+/// record (a decay daughter's chain walked on below it into a triplet of
+/// another's cluster).
+template <DetectorLayout Det, typename Material, bool BeamLine, bool NominalOnly, bool LastStepAllowance, bool InnerTrim>
+class RoadFitStage
+{
+ public:
+  using Index = StageOutput<TripletT>::Index;
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  using Record = memlayout::Wrapper<SelectionRecordOf<kMaxClusters>::template RecordT, memlayout::value>;
+
+  RoadFitStage(const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator, const StageOutput<TrackletT>& tracklets, const StageOutput<TripletT>& triplets, const RoadWalk& walk)
+    : RoadFitStage(&parameters, &frame, &geometry, &material, propagator, tracklets.view(), triplets.view(), walk)
+  {
+  }
+
+  /// The same stage over inputs wherever they are -- a device's copies:
+  /// every argument is only stored.
+  RoadFitStage(const IterationParameters<Det>* parameters, const TimeFrame<Det>* frame, const TrackingGeometry<Det>* geometry, const Material* material, const Propagator& propagator, TrackletConstView tracklets, TripletConstView triplets, const RoadWalk& walk)
+    : mParameters(parameters),
+      mFrame(frame),
+      mGeometry(geometry),
+      mMaterial(material),
+      mPropagator(propagator),
+      mTracklets(tracklets),
+      mTriplets(triplets),
+      mWalk(walk)
+  {
+  }
+
+  template <typename Emitter>
+  GPUhdi() void operator()(Index road, Emitter& emitter) const
+  {
+    Index triplets[kMaxClusters - 2U];
+    const std::uint32_t length = mWalk(road, triplets);
+    if constexpr (NominalOnly) {
+      for (std::uint32_t i = 0; i < length; ++i) {
+        if (mTriplets.kinked[triplets[i]] != 0U) {
+          return;
+        }
+      }
+    }
+    std::uint32_t rows[kMaxClusters];
+    const Index first = mTriplets.first[triplets[0]];
+    rows[0] = mTracklets.source[first];
+    rows[1] = mTracklets.target[first];
+    for (std::uint32_t i = 0; i < length; ++i) {
+      rows[i + 2U] = mTracklets.target[mTriplets.second[triplets[i]]];
+    }
+    const std::uint32_t count = length + 2U;
+    if constexpr (InnerTrim) {
+      const std::uint32_t shortest = mParameters->minClusters;
+      const std::uint32_t trims = count > shortest ? o2::gpu::CAMath::Min(std::uint32_t{mParameters->innerTrim}, count - shortest) : 0U;
+      for (std::uint32_t dropped = 0; dropped <= trims; ++dropped) {
+        if (dropped != 0U) {
+          countWork(WorkCounter::kRoadTrimFits);
+        }
+        if (fitRows(rows + dropped, count - dropped, emitter)) {
+          if (dropped != 0U) {
+            countWork(WorkCounter::kRoadTrimAccepted);
+          }
+          return;
+        }
+      }
+    } else {
+      fitRows(rows, count, emitter);
+    }
+  }
+
+ private:
+  /// The road of \a count rows \a rows, innermost first: dropped if its
+  /// boxes share no time, else fitted with the outward pass, tested against
+  /// its floor and, with \a BeamLine, the beam line, and its record emitted.
+  /// Whether it was.
+  template <typename Emitter>
+  GPUhdi() GPUAlwaysInline() bool fitRows(const std::uint32_t* rows, std::uint32_t count, Emitter& emitter) const
+  {
+    const auto columns = mFrame->measurements();
+    auto common = timeBoxAt(columns, rows[0]);
+    for (std::uint32_t i = 1; i < count; ++i) {
+      const auto box = timeBoxAt(columns, rows[i]);
+      if (!common.isCompatible(box)) {
+        countWork(WorkCounter::kRoadTime);
+        return false;
+      }
+      common += box;
+    }
+    const auto fit = fitRoad<LastStepAllowance>(*mParameters, mPropagator, *mGeometry, *mMaterial, RowChain<Det>{.frame = mFrame, .rows = rows}, static_cast<int>(count));
+    countWork(WorkCounter::kRoadFits);
+    if (fit.status != RoadFitStatus::kAccepted) {
+      return false;
+    }
+    if (!clearsPtFloor(*mParameters, count, fit)) {
+      countWork(WorkCounter::kRoadFloor);
+      return false;
+    }
+    if constexpr (BeamLine) {
+      Scalar beamChi2 = 0.F;
+      if (!clearsBeamLine(mPropagator, *mParameters, *mFrame, *mGeometry, *mMaterial, rows, count, fit.state, beamChi2)) {
+        countWork(WorkCounter::kRoadBeam);
+        return false;
+      }
+      emitRecord(emitter, rows, count, fit, fit.chi2 + beamChi2);
+    } else {
+      emitRecord(emitter, rows, count, fit, fit.chi2);
+    }
+    return true;
+  }
+
+  /// The accepted road's record, of chi2 \a chi2.
+  template <typename Emitter>
+  GPUhdi() GPUAlwaysInline() static void emitRecord(Emitter& emitter, const std::uint32_t* rows, std::uint32_t count, const RoadFitResult& fit, Scalar chi2)
+  {
+    countWork(WorkCounter::kRoadAccepted);
+    Record record;
+    for (std::uint32_t i = 0; i < kMaxClusters; ++i) {
+      record.clusters.index[i] = i < count ? rows[i] : ClusterList<kMaxClusters>::kNoCluster;
+    }
+    record.count = static_cast<std::uint8_t>(count);
+    record.chi2 = chi2;
+    record.kinks = fit.kinks;
+    record.outwardState = fit.state;
+    emitter.emit(record);
+  }
+
+  const IterationParameters<Det>* mParameters = nullptr;
+  const TimeFrame<Det>* mFrame = nullptr;
+  const TrackingGeometry<Det>* mGeometry = nullptr;
+  const Material* mMaterial = nullptr;
+  Propagator mPropagator;
+  TrackletConstView mTracklets;
+  TripletConstView mTriplets;
+  RoadWalk mWalk;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_ROADFIT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/SearchWindow.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/SearchWindow.h
new file mode 100644
index 0000000000000..30a57beef7200
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/SearchWindow.h
@@ -0,0 +1,842 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file SearchWindow.h
+/// \brief How wide a candidate window is, derived rather than tuned.
+///
+/// Every number here follows from the minimum pT of the current iteration, the
+/// layers' envelopes measured from the loaded geometry (Base/LayerEnvelopes.h),
+/// the longitudinal vertex constraint and
+/// the Highland term the track model already carries. Nothing is measured off
+/// truth chains, which is what lets a grid granularity be derived at all.
+///
+/// The split that makes this usable on a device: a window depends only on the
+/// layer pair, iteration and collision vertex, never on the seed. Only its
+/// centre depends on the seed, and that is one multiply. The transcendental
+/// work -- asin, the Highland logarithm -- happens once per pair, iteration
+/// and vertex on the host, into a `LayerPairWindow` small enough to upload.
+/// The per-seed query is arithmetic.
+
+#ifndef GTRK_TRACKING_SEARCHWINDOW_H_
+#define GTRK_TRACKING_SEARCHWINDOW_H_
+
+#include "GenericTracking/Base/LayerEnvelopes.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/DisplacedPair.h"
+#include "GenericTracking/Tracking/Material.h"
+#include "GenericTracking/Tracking/MathUtils.h"
+
+#include "CommonConstants/PhysicsConstants.h"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <numbers>
+
+namespace o2::gtrk
+{
+
+/// The iteration-wide physics inputs. A collision's longitudinal constraint
+/// is separate because one timeframe can contain many vertices at different z.
+struct SearchWindowParams {
+  // This is host-side configuration. Window derivation evaluates in double
+  // and narrows once when it creates the device-facing LayerPairWindow.
+  /// Minimum transverse momentum of the current CA iteration [GeV/c].  The
+  /// curvature term and the Highland term both scale as 1/p, so an early
+  /// high-pT pass has a window an order of magnitude narrower on both counts.
+  double minPtGeV = 0.1;
+
+  /// Solenoid field along z [kG], the unit `o2::constants::math::B2C` and the
+  /// rest of O2 are written in.  2 T is 20 kG.
+  double bzKiloGauss = 20.;
+
+  /// The mass hypothesis [GeV] (`Propagator::massGeV`, positive): the softest
+  /// momentum the windows admit scatters as 1 / (beta p).
+  double massGeV = o2::constants::physics::MassPionCharged;
+
+  /// Radiation lengths crossed between two layers: the uniform material that
+  /// sizes the grid's cells (`uniformSourceKink`); the pair queries take the
+  /// scattering table's per-layer values (`layerPairWindow` in PairCut.h).
+  /// 1 % X0 is the order of a pixel layer with its support.
+  double materialX2X0 = 0.01;
+
+  /// Cluster position resolution entering the window [cm]. One number for
+  /// every layer.
+  double positionSigma = 0.005;
+
+  /// How many sigma of the Gaussian terms -- vertex, scattering, resolution --
+  /// the window admits.  The curvature term is a bound, not a sigma, and is
+  /// not scaled by this.
+  double nSigma = 3.;
+
+  /// A displaced iteration's bounds: the
+  /// largest distance its tracks' circles may pass from the beam line, and
+  /// how far the z of that closest approach may lie from the beam spot's
+  /// centre [cm]. 0, the default, is a prompt iteration, whose pair test and
+  /// windows are the beam point's; a displaced one tests a pair with
+  /// `displacedPairWithin` and its windows hold what that admits.
+  double impactMax = 0.;
+  double impactZMax = 0.;
+
+  [[nodiscard]] bool operator==(const SearchWindowParams&) const = default;
+};
+
+/// The origin shared by tracks from one collision.
+///
+/// Before vertexing this is the broad beam-spot constraint. Afterwards there
+/// is one of these per reconstructed collision, with that collision's z and
+/// uncertainty. It is deliberately not part of SearchWindowParams.
+///
+/// Transverse positions are in the frame of the corrected beam line, whose
+/// position and width come from the MeanVertex calibration of the run. The producer subtracts the transverse position from
+/// every measurement (Workflow/BeamLine.h); the constraint carries the widths
+/// and the longitudinal position.
+struct VertexConstraint {
+  double z = 0.;                  ///< [cm]
+  double sigmaZ = 6.;             ///< [cm]
+  double sigmaTransverse = 0.002; ///< beam width across the beam line [cm]
+  /// The beam line's transverse position in the fit's frame, the detector's
+  /// [cm]: the finding works about it, in the corrected frame, and reads
+  /// neither (BeamLine.h); the beam-line update does (BeamConstraint.h).
+  double x = 0.;
+  double y = 0.;
+};
+
+/// Where a layer is [cm], read off the envelopes measured from the geometry
+/// loaded in this process (Base/LayerEnvelopes.h). Before a Geometry<Det>
+/// exists they throw std::logic_error.
+///
+/// `layerDistance`: the layer's position (`LayerEnvelope::position`, the mean
+/// of its sensors' radii or z), unsigned: the radius of a barrel layer, the |z|
+/// of a disc. `discZ`: a disc's signed z,
+/// which the lever arm needs; 0 on a barrel layer. `secondMin`/`secondMax`:
+/// the range of the second binning coordinate, z on a barrel layer, r on a
+/// disc. `radiusMin`/`radiusMax`, `zMin`/`zMax`: the ranges of r and z the
+/// layer's measurements span.
+template <DetectorLayout Det>
+[[nodiscard]] inline double layerDistance(LayerID layer)
+{
+  return std::abs(PlacedEnvelopes<Det>::get(layer).position);
+}
+
+template <DetectorLayout Det>
+[[nodiscard]] inline double discZ(LayerID layer)
+{
+  return Detector<Det>::isBarrelLayer(layer) ? 0. : PlacedEnvelopes<Det>::get(layer).position;
+}
+
+template <DetectorLayout Det>
+[[nodiscard]] inline double secondMin(LayerID layer)
+{
+  return Detector<Det>::isBarrelLayer(layer) ? PlacedEnvelopes<Det>::get(layer).zMin : PlacedEnvelopes<Det>::get(layer).rMin;
+}
+
+template <DetectorLayout Det>
+[[nodiscard]] inline double secondMax(LayerID layer)
+{
+  return Detector<Det>::isBarrelLayer(layer) ? PlacedEnvelopes<Det>::get(layer).zMax : PlacedEnvelopes<Det>::get(layer).rMax;
+}
+
+template <DetectorLayout Det>
+[[nodiscard]] inline double radiusMin(LayerID layer)
+{
+  return PlacedEnvelopes<Det>::get(layer).rMin;
+}
+
+template <DetectorLayout Det>
+[[nodiscard]] inline double radiusMax(LayerID layer)
+{
+  return PlacedEnvelopes<Det>::get(layer).rMax;
+}
+
+template <DetectorLayout Det>
+[[nodiscard]] inline double zMin(LayerID layer)
+{
+  return PlacedEnvelopes<Det>::get(layer).zMin;
+}
+
+template <DetectorLayout Det>
+[[nodiscard]] inline double zMax(LayerID layer)
+{
+  return PlacedEnvelopes<Det>::get(layer).zMax;
+}
+
+/// A range of values, and the ratio of two positions spanning ranges.
+struct Interval {
+  double low = 0.;
+  double high = 0.;
+};
+
+/// The range of `(to - origin) / (from - origin)` for `to` and `from` within
+/// their intervals. Neither interval may contain `origin`.
+[[nodiscard]] inline Interval ratioRange(Interval to, Interval from, double origin)
+{
+  const double corners[4] = {(to.low - origin) / (from.low - origin), (to.low - origin) / (from.high - origin), (to.high - origin) / (from.low - origin), (to.high - origin) / (from.high - origin)};
+  return {.low = *std::min_element(corners, corners + 4), .high = *std::max_element(corners, corners + 4)};
+}
+
+/// `ratioRange` over every origin in \a origin: the union of its ends'.
+[[nodiscard]] inline Interval ratioRange(Interval to, Interval from, Interval origin)
+{
+  const auto low = ratioRange(to, from, origin.low);
+  const auto high = ratioRange(to, from, origin.high);
+  return {.low = std::min(low.low, high.low), .high = std::max(low.high, high.high)};
+}
+
+/// The largest magnitude in \a range.
+[[nodiscard]] inline double largestAbs(Interval range) { return std::max(std::abs(range.low), std::abs(range.high)); }
+
+/// The distances between \a a and \a b: the nearest, zero where they
+/// overlap, and the farthest, between their ends.
+[[nodiscard]] inline double nearestApart(Interval a, Interval b) { return std::max({a.low - b.high, b.low - a.high, 0.}); }
+[[nodiscard]] inline double farthestApart(Interval a, Interval b) { return std::max({std::abs(b.low - a.low), std::abs(b.low - a.high), std::abs(b.high - a.low), std::abs(b.high - a.high)}); }
+
+/// The z the vertex constraint reaches: `nSigma` of its width either side.
+[[nodiscard]] inline Interval vertexReach(const SearchWindowParams& params, const VertexConstraint& vertex)
+{
+  const double reach = params.nSigma * vertex.sigmaZ;
+  return {.low = vertex.z - reach, .high = vertex.z + reach};
+}
+
+/// A layer's extents as intervals: its transverse radii, its z, its second
+/// coordinate (`radiusMin`, `zMin`, `secondMin` and their maxima).
+template <DetectorLayout Det>
+[[nodiscard]] inline Interval radiusRange(LayerID layer)
+{
+  return {.low = radiusMin<Det>(layer), .high = radiusMax<Det>(layer)};
+}
+template <DetectorLayout Det>
+[[nodiscard]] inline Interval zRange(LayerID layer)
+{
+  return {.low = zMin<Det>(layer), .high = zMax<Det>(layer)};
+}
+template <DetectorLayout Det>
+[[nodiscard]] inline Interval secondRange(LayerID layer)
+{
+  return {.low = secondMin<Det>(layer), .high = secondMax<Det>(layer)};
+}
+
+/// Whether a position lies strictly inside what layers \a a and \a b span
+/// together: a radius (\a barrel) between their least and largest radius, a
+/// z between their least and largest z.
+template <DetectorLayout Det>
+[[nodiscard]] inline bool positionBetweenLayers(bool barrel, double position, LayerID a, LayerID b)
+{
+  const Interval spanA = barrel ? radiusRange<Det>(a) : zRange<Det>(a);
+  const Interval spanB = barrel ? radiusRange<Det>(b) : zRange<Det>(b);
+  return position > std::min(spanA.low, spanB.low) && position < std::max(spanA.high, spanB.high);
+}
+
+/// The largest transverse curvature the windows admit [1/cm]: `1/R` at
+/// pT_min; zero without a field, unbounded without a pT cut.
+[[nodiscard]] inline double maxCurvature(const SearchWindowParams& params)
+{
+  if (exactlyEqual(params.bzKiloGauss, 0.)) {
+    return 0.;
+  }
+  const double radius = curvatureRadius(params.minPtGeV, params.bzKiloGauss);
+  return radius > 0. ? 1. / radius : std::numeric_limits<double>::infinity();
+}
+
+/// 1 / (beta p)^2 [GeV^-2] at the softest momentum the windows admit, pT_min:
+/// what their scattering scales as, and an upper bound over every momentum
+/// above it.
+[[nodiscard]] inline double invBetaMomentumMin2(const SearchWindowParams& params)
+{
+  const double pt2 = params.minPtGeV * params.minPtGeV;
+  return (1. + (params.massGeV * params.massGeV / pt2)) / pt2;
+}
+
+/// `1 / (beta pT_min)^2` over `1 / pT_min^2`: what the mass hypothesis
+/// multiplies the scattering at pT_min by.
+[[nodiscard]] inline double betaMomentumFactor(const SearchWindowParams& params) { return invBetaMomentumMin2(params) * params.minPtGeV * params.minPtGeV; }
+
+/// The uniform stand-in for a source's transverse kink [rad]: `materialX2X0`
+/// at normal incidence in the seed's layer alone. It sizes the grid's cells;
+/// the pair queries take the pair cut's own table (`sourceKinkBound` in
+/// `PairCut.h`).
+[[nodiscard]] inline double uniformSourceKink(const SearchWindowParams& params) { return static_cast<double>(highlandTheta0(static_cast<Scalar>(params.materialX2X0), betaMomentum(static_cast<Scalar>(params.minPtGeV), static_cast<Scalar>(params.massGeV)))); }
+
+/// How far the scattering before the seed moves the target's second
+/// coordinate, in one standard deviation [cm], for vertices in \a vertexZ and
+/// \a sourceKink bounding `sqrt(S)/r_i` over the seed's layer.
+///
+/// The longitudinal pair test carries the scattering as `(ds^2 + dz^2) S` in
+/// the variance of `D = s_i (z_j - z_v) - s_j (z_i - z_v)`, with `S` the
+/// source's scattering sum. Moving the target by `delta` changes `D` by
+/// `s_i delta` on a barrel, in z, and by `|z_i - z_v| delta` on a disc, in r.
+/// One standard deviation is therefore `hypot(ds, dz) sqrt(S)` over that
+/// factor. The step `ds` along the transverse arc is at most the target's arc
+/// less the seed's radius, with the pair cut's curvature bound; `dz` is at
+/// most the pair's z extent and `ds` times the steepest slope from the vertex.
+/// On a barrel `sqrt(S)/s_i <= sqrt(S)/r_i`. On a disc the factor is `r_i/|z_i -
+/// z_v|` from a disc seed; from a barrel seed, `s_i/|z_i - z_v| = s_j/|z_j -
+/// z_v|` for a pair the pitch test can pass, bounded at the target.
+///
+/// \a betweenKink bounds `sqrt(T)`, the target's displacement by the passive
+/// scatterers between the two layers (`betweenKinkBound` in `PairCut.h`). It enters the variance of `D` as
+/// `(s_i^2 + (z_i - z_v)^2) T`, which moves the target's second coordinate by
+/// `sqrt(T) hypot(s_i, z_i - z_v)` over the same factor `s_i` or `|z_i - z_v|`.
+template <DetectorLayout Det>
+[[nodiscard]] inline double secondScattering(LayerID from, LayerID to, const SearchWindowParams& params, Interval vertexZ, double sourceKink, double betweenKink = 0.)
+{
+  const double rFromLow = radiusMin<Det>(from);
+  const double rToHigh = radiusMax<Det>(to);
+  if (!(rFromLow > 0.) || !(rToHigh > 0.)) {
+    return std::numeric_limits<double>::infinity();
+  }
+  const double curvature = std::min(maxCurvature(params), 2. / rToHigh);
+  const double targetArc = transverseArcAtRadius(curvature, rToHigh);
+  const double arcStep = std::max(targetArc - rFromLow, 0.);
+  const Interval zFrom = zRange<Det>(from);
+  const Interval zTo = zRange<Det>(to);
+  const double zStep = std::max(std::abs(zTo.high - zFrom.low), std::abs(zTo.low - zFrom.high));
+  const double sourceFar = farthestApart(vertexZ, zFrom);
+  const double step = std::hypot(arcStep, std::min(zStep, arcStep * sourceFar / rFromLow));
+  if (Detector<Det>::isBarrelLayer(to)) {
+    return std::hypot(sourceKink * step, betweenKink * std::hypot(1., sourceFar / rFromLow));
+  }
+  const double near = nearestApart(vertexZ, Detector<Det>::isBarrelLayer(from) ? zTo : zFrom);
+  if (!(near > 0.)) {
+    return std::numeric_limits<double>::infinity();
+  }
+  const double lever = Detector<Det>::isBarrelLayer(from) ? targetArc : radiusMax<Det>(from);
+  return std::hypot(sourceKink * step * lever / near, betweenKink * std::hypot(1., lever / near));
+}
+
+/// Everything a query needs about one ordered layer pair, computed once per
+/// pair, CA iteration and vertex constraint.
+///
+/// For a same-kind pair, `secondScale` and `secondOffset` are the
+/// straight-line extrapolation from the collision vertex, and
+/// `secondHalfWidth` is what its z uncertainty, scattering and the cluster
+/// resolution do to that estimate.
+///
+/// A barrel <-> disc pair has no such line: the target's coordinate goes as
+/// the reciprocal of the seed's. Its window is evaluated per seed from the
+/// fields after `kind`, and `secondHalfWidth` is the padding added to it.
+struct LayerPairWindow {
+  Scalar phiHalfWidth = 0.F;    ///< [rad], symmetric about the seed's phi
+  Scalar secondScale = 0.F;     ///< d(second on target) / d(second on seed)
+  Scalar secondOffset = 0.F;    ///< [cm], the constant term of that extrapolation
+  Scalar secondHalfWidth = 0.F; ///< [cm], about secondScale * seed + secondOffset
+
+  PairKind kind = PairKind::kBarrel;
+  Scalar targetLow = 0.F; ///< [cm] the target disc's z, or the target barrel layer's radii
+  Scalar targetHigh = 0.F;
+  Scalar vertexLow = 0.F; ///< [cm] the vertex's z, n sigma either side
+  Scalar vertexHigh = 0.F;
+  Scalar seedSpread = 0.F;      ///< [cm] n sigma of the seed's own second coordinate
+  Scalar targetSecondMin = 0.F; ///< [cm] the target's extent in its second coordinate
+  Scalar targetSecondMax = 0.F;
+};
+
+/// Host-derived terms shared by every per-vertex second-coordinate interval
+/// of one layer pair. The interval centre still follows the individual vertex
+/// on the device.
+struct VertexPairWindow {
+  Scalar secondScale = 0.F;    ///< barrel radius ratio
+  Scalar sourcePosition = 0.F; ///< source disc z for a disc pair
+  Scalar targetPosition = 0.F; ///< target disc z for a disc pair
+  Scalar vertexLever = 0.F;    ///< second-coordinate shift per vertex-z shift
+  Scalar secondVariance = 0.F; ///< scattering and measurement variance [cm^2]
+  Scalar secondPadding = 0.F;  ///< centre, helix and rounding reach [cm]
+};
+
+/// Narrow a nonnegative host-derived bound without making it smaller.
+[[nodiscard]] inline Scalar conservativeScalarBound(double value)
+{
+  auto narrowed = static_cast<Scalar>(value);
+  if (static_cast<double>(narrowed) < value) {
+    narrowed = std::nextafter(narrowed, std::numeric_limits<Scalar>::infinity());
+  }
+  return narrowed;
+}
+
+/// The half-width in phi: the widest azimuth the transverse pair test accepts.
+///
+/// The test admits a pair when
+///
+/// ```
+/// sin(dphi) <= d / (2 R_min) + n sqrt(res^2 + (d/r_j)^2 kink^2)
+/// d^2 = r_i^2 + r_j^2 - 2 r_i r_j cos(dphi),    res^2 = sigma^2 (1/r_i^2 + 1/r_j^2)
+/// cos(dphi) >= min(r_i, r_j) / max(r_i, r_j)
+/// ```
+///
+/// with \a sourceKink one standard deviation of the track's transverse
+/// direction at the seed [rad] and the cluster resolution `positionSigma`.
+/// The last line is the test's no-turning-point condition. The chord grows
+/// with dphi, so no closed form bounds the accepted set; it is scanned from
+/// the quarter turn down over the pair's radius ranges. Between two discs the target radius follows the
+/// seed's through the z ratio `rho`, pulled in by the helix to
+/// `r_i sin(rho a)/sin(a)` for the seed's half-turn `a`.
+///
+/// \a betweenKink bounds `sqrt(T)` as for `secondScattering`: the transverse
+/// test's variance gains `r_i^2 T`, which in the accepted `sin(dphi)` is
+/// `T / r_j^2`.
+template <DetectorLayout Det>
+[[nodiscard]] inline double phiWindow(LayerID from, LayerID to, const SearchWindowParams& params, const VertexConstraint& vertex, double sourceKink, double betweenKink = 0.)
+{
+  constexpr double kQuarter = 0.5 * std::numbers::pi_v<double>;
+  constexpr double kStep = 1.e-3;
+  constexpr int kSteps = static_cast<int>(kQuarter / kStep) + 1;
+  constexpr int kSamples = 5;
+  const double radius = curvatureRadius(params.minPtGeV, params.bzKiloGauss);
+  const double fromLow = radiusMin<Det>(from);
+  const double fromHigh = radiusMax<Det>(from);
+  if (!(radius > 0.) || !(fromLow > 0.)) {
+    return kQuarter;
+  }
+  const double twoR = 2. * radius;
+
+  const bool discs = !Detector<Det>::isBarrelLayer(from) && !Detector<Det>::isBarrelLayer(to);
+  const auto rho = ratioRange(zRange<Det>(to), zRange<Det>(from), vertexReach(params, vertex));
+  const double rhoLow = rho.low;
+  const double rhoHigh = std::max(rho.high, 0.);
+
+  const double variance = params.positionSigma * params.positionSigma;
+  const auto accepted = [&](double rFrom, double rTo, double phi) {
+    if (std::cos(phi) * std::max(rFrom, rTo) < std::min(rFrom, rTo)) {
+      return false;
+    }
+    const double chord = std::sqrt(std::max((rFrom * rFrom) + (rTo * rTo) - (2. * rFrom * rTo * std::cos(phi)), 0.));
+    const double lever = chord / rTo;
+    const double gaussian = std::sqrt((variance * ((1. / (rFrom * rFrom)) + (1. / (rTo * rTo)))) + (lever * lever * sourceKink * sourceKink) + (betweenKink * betweenKink / (rTo * rTo)));
+    return std::sin(phi) <= (chord / twoR) + (params.nSigma * gaussian);
+  };
+
+  double widest = 0.;
+  for (int i = 0; i < kSamples; ++i) {
+    const double rFrom = fromLow + ((fromHigh - fromLow) * i / (kSamples - 1));
+    double toLow = radiusMin<Det>(to);
+    double toHigh = radiusMax<Det>(to);
+    if (discs) {
+      const double turn = std::min(std::asin(std::min(rFrom / twoR, 1.)), 0.5 * std::numbers::pi_v<double> / std::max(rhoLow, 1.));
+      toLow = std::max(toLow, turn > 0. ? rFrom * std::sin(rhoLow * turn) / std::sin(turn) : rhoLow * rFrom);
+      toHigh = std::min(toHigh, rhoHigh * rFrom);
+      if (toHigh < toLow) {
+        continue;
+      }
+    }
+    for (int j = 0; j < kSamples; ++j) {
+      const double rTo = toLow + ((toHigh - toLow) * j / (kSamples - 1));
+      if (!(rTo > 0.)) {
+        continue;
+      }
+      for (int step = kSteps; step >= 0 && kStep * (step + 1) > widest; --step) {
+        if (accepted(rFrom, rTo, kStep * step)) {
+          widest = kStep * (step + 1);
+          break;
+        }
+      }
+    }
+  }
+  return std::min(widest, kQuarter);
+}
+
+/// The lever arm of the beam-line constraint on the target layer's second
+/// coordinate, and the window it implies around a straight extrapolation.
+///
+/// ```
+/// barrel -> barrel   z_j = z_v + (z_i - z_v) * r_j/r_i      dz_j/dz_v = r_j/r_i - 1
+/// disc   -> disc     r_j = r_i * (z_j - z_v)/(z_i - z_v)    dr_j/dz_v = r_i (z_j - z_i)/(z_i - z_v)^2
+/// ```
+///
+/// The two behave oppositely: `r_j/r_i - 1` is about 1 on an inner barrel
+/// pair, so the spot's spread passes on nearly whole and the constraint is
+/// nearly worthless there; between two discs the lever arm in z is long and
+/// the same spot costs under a millimetre.
+///
+/// For a same-kind pair (a crossing pair takes `crossingPairWindow`).
+/// \a seedSecond is the seed's own second coordinate.  Barrel-to-barrel does
+/// not use it -- the derivative is independent of z_i -- but disc-to-disc does,
+/// and passing the target-side extreme radius there is the conservative choice
+/// a precomputed per-pair window has to make. \a sourceKink is as for
+/// `secondScattering`.
+template <DetectorLayout Det>
+[[nodiscard]] inline double secondWindow(LayerID from, LayerID to, double seedSecond, const SearchWindowParams& params, const VertexConstraint& vertexConstraint, double sourceKink, double betweenKink = 0.)
+{
+  const double fullExtent = secondMax<Det>(to) - secondMin<Det>(to);
+  const Interval vertexZ = vertexReach(params, vertexConstraint);
+
+  // Taken over the layers' measured ranges, where each term is largest.
+  if (Detector<Det>::isBarrelLayer(from) && Detector<Det>::isBarrelLayer(to)) {
+    const auto ratio = ratioRange(radiusRange<Det>(to), radiusRange<Det>(from), 0.);
+    const double vertexUncertainty = std::max(std::abs(ratio.high - 1.), std::abs(ratio.low - 1.)) * vertexConstraint.sigmaZ;
+    const double scattering = secondScattering<Det>(from, to, params, vertexZ, sourceKink, betweenKink);
+    const double resolution = params.positionSigma * ratio.high;
+    return params.nSigma * std::hypot(vertexUncertainty, scattering, resolution);
+  }
+
+  // A disc pair.
+  const Interval zFrom = zRange<Det>(from);
+  const Interval zTo = zRange<Det>(to);
+  const double fromVertex = std::min(std::abs(zFrom.low - vertexConstraint.z), std::abs(zFrom.high - vertexConstraint.z));
+  if (!(fromVertex > 0.)) {
+    return fullExtent;
+  }
+  const double gap = std::max(std::abs(zTo.high - zFrom.low), std::abs(zTo.low - zFrom.high));
+  const auto ratio = ratioRange(zTo, zFrom, vertexConstraint.z);
+  const double vertexUncertainty = std::abs(seedSecond) * gap / (fromVertex * fromVertex) * vertexConstraint.sigmaZ;
+  const double scattering = secondScattering<Det>(from, to, params, vertexZ, sourceKink, betweenKink);
+  const double resolution = params.positionSigma * std::max(std::abs(ratio.low), std::abs(ratio.high));
+  return params.nSigma * std::hypot(vertexUncertainty, scattering, resolution);
+}
+
+/// Extra second-coordinate reach when z is linear in transverse arc rather
+/// than radius. The query remains centred on its cheap straight extrapolation.
+///
+/// With the arc `s = r f(k r/2)`, `f(x) = asin(x)/x`, a helix from the vertex
+/// through the seed at `r_i` lands off the straight line through the two by
+///
+/// ```
+/// target on a barrel, in z    |z_i - z_v| (r_j/r_i) (f_j/f_i - 1)
+/// target on a disc, in r      r_j (f_j/f_i - 1)
+/// ```
+///
+/// Every link leads outwards in radius, and both grow with `r_j` and with the
+/// curvature and shrink with `r_i`: the smallest seed radius and the largest
+/// target radius bound them. The pair cut holds the curvature to pT_min's, and
+/// a circle through the beam point does not reach past its diameter, so the
+/// curvature is at most `min(1/R_min, 2/r_j)`.
+///
+/// Between two discs the seed radius is not free either: the arc to it is the
+/// target's over `rho = (z_j - z_v)/(z_i - z_v)`. The offset `rho r_i - r_j`
+/// grows with `rho`, so it is bounded at the largest target radius and `rho`.
+template <DetectorLayout Det>
+[[nodiscard]] inline double helixSecondSpread(LayerID from, LayerID to, const SearchWindowParams& params, const VertexConstraint& vertex)
+{
+  if (exactlyEqual(params.bzKiloGauss, 0.)) {
+    return 0.;
+  }
+  const double curvatureMax = maxCurvature(params);
+  const Interval vertexZ = vertexReach(params, vertex);
+
+  if (!Detector<Det>::isBarrelLayer(from) && !Detector<Det>::isBarrelLayer(to)) {
+    const double rho = std::max(0., ratioRange(zRange<Det>(to), zRange<Det>(from), vertexZ).high);
+    const double targetRadius = radiusMax<Det>(to);
+    if (!(rho > 1.) || !(targetRadius > 0.)) {
+      return 0.;
+    }
+    const double curvature = std::min(curvatureMax, 2. / targetRadius);
+    const double sourceArc = transverseArcAtRadius(curvature, targetRadius) / rho;
+    const double sourceRadius = 2. * std::sin(0.5 * curvature * sourceArc) / curvature;
+    return (rho * sourceRadius) - targetRadius;
+  }
+
+  const double sourceRadius = radiusMin<Det>(from);
+  const double targetRadius = radiusMax<Det>(to);
+  if (!(sourceRadius > 0.) || !(targetRadius > sourceRadius)) {
+    return 0.;
+  }
+  const double curvature = std::min(curvatureMax, 2. / targetRadius);
+  const double arcExcess = (transverseArcAtRadius(curvature, targetRadius) / targetRadius) / (transverseArcAtRadius(curvature, sourceRadius) / sourceRadius) - 1.;
+  if (!Detector<Det>::isBarrelLayer(to)) {
+    return targetRadius * arcExcess;
+  }
+  const double lever = farthestApart(vertexZ, zRange<Det>(from));
+  return lever * (targetRadius / sourceRadius) * arcExcess;
+}
+
+/// The straight-line extrapolation factor for the second coordinate about the
+/// supplied vertex, for a same-kind pair (a crossing pair's centre is the
+/// target layer's midpoint instead -- see `secondOffset`).
+template <DetectorLayout Det>
+[[nodiscard]] inline double secondScale(LayerID from, LayerID to, double vertexZ)
+{
+  if (Detector<Det>::isBarrelLayer(from) && Detector<Det>::isBarrelLayer(to)) {
+    const double rFrom = layerDistance<Det>(from);
+    return rFrom > 0. ? layerDistance<Det>(to) / rFrom : 0.;
+  }
+  const double fromVertex = discZ<Det>(from) - vertexZ;
+  return std::abs(fromVertex) > 0. ? (discZ<Det>(to) - vertexZ) / fromVertex : 0.;
+}
+
+/// The constant term of the same extrapolation.
+///
+/// A barrel pair uses `(1 - scale) * vertexZ`; a disc pair needs no offset
+/// because its vertex dependence is already in the scale. It carries the
+/// target layer's midpoint for the undetermined barrel-to-disc case, where
+/// the window is the layer's whole extent and a disc's r extent is not centred
+/// on zero the way a barrel's z extent is.
+template <DetectorLayout Det>
+[[nodiscard]] inline double secondOffset(LayerID from, LayerID to, double vertexZ)
+{
+  if (Detector<Det>::isBarrelLayer(from) && Detector<Det>::isBarrelLayer(to)) {
+    return (1. - secondScale<Det>(from, to, vertexZ)) * vertexZ;
+  }
+  if (!Detector<Det>::isBarrelLayer(from) && !Detector<Det>::isBarrelLayer(to)) {
+    return 0.;
+  }
+  return 0.5 * (secondMin<Det>(to) + secondMax<Det>(to));
+}
+
+/// How far the straight line from the vertex through an actual seed lands
+/// from the window's centre, which uses the layers' nominal positions [cm].
+///
+/// Barrel: the line reaches the target at `z_v + (z_i - z_v) r_j/r_i` with the
+/// measured radii, against `scale` from the nominal ones. Discs: at
+/// `r_i (z_j - z_v)/(z_i - z_v)` with the measured z. The spread is added to
+/// the half-width, so the cells picked still contain every row the exact pair
+/// cuts can accept. For a same-kind pair.
+template <DetectorLayout Det>
+[[nodiscard]] inline double secondCentreSpread(LayerID from, LayerID to, double vertexZ)
+{
+  const double scale = secondScale<Det>(from, to, vertexZ);
+  if (Detector<Det>::isBarrelLayer(from) && Detector<Det>::isBarrelLayer(to)) {
+    const auto ratio = ratioRange(radiusRange<Det>(to), radiusRange<Det>(from), 0.);
+    const double lever = std::max(std::abs(secondMin<Det>(from) - vertexZ), std::abs(secondMax<Det>(from) - vertexZ));
+    return lever * std::max(ratio.high - scale, scale - ratio.low);
+  }
+  const auto ratio = ratioRange(zRange<Det>(to), zRange<Det>(from), vertexZ);
+  return secondMax<Det>(from) * std::max(ratio.high - scale, scale - ratio.low);
+}
+
+struct VertexSecondWindow {
+  double vertexLever = 0.;
+  double variance = 0.;
+  double padding = 0.;
+};
+
+/// The same-kind second-coordinate uncertainty terms, bounded over the z
+/// range the vertices an iteration uses can take.
+template <DetectorLayout Det>
+[[nodiscard]] inline VertexSecondWindow vertexSecondWindow(LayerID from, LayerID to, double seedSecond, const SearchWindowParams& params, Interval vertexZ, double sourceKink, double betweenKink = 0.)
+{
+  const double scattering = secondScattering<Det>(from, to, params, vertexZ, sourceKink, betweenKink);
+  if (Detector<Det>::isBarrelLayer(from) && Detector<Det>::isBarrelLayer(to)) {
+    const auto ratio = ratioRange(radiusRange<Det>(to), radiusRange<Det>(from), 0.);
+    const double vertexLever = std::max(std::abs(ratio.high - 1.), std::abs(ratio.low - 1.));
+    const double resolution = params.positionSigma * ratio.high;
+    return {.vertexLever = vertexLever, .variance = (scattering * scattering) + (resolution * resolution)};
+  }
+  const Interval zFrom = zRange<Det>(from);
+  if (vertexZ.high >= zFrom.low && vertexZ.low <= zFrom.high) {
+    return {.padding = secondMax<Det>(to) - secondMin<Det>(to)};
+  }
+  const double fromVertex = nearestApart(vertexZ, zFrom);
+  const Interval zTo = zRange<Det>(to);
+  const double gap = std::max(std::abs(zTo.high - zFrom.low), std::abs(zTo.low - zFrom.high));
+  const double ratio = largestAbs(ratioRange(zTo, zFrom, vertexZ));
+  const double vertexLever = std::abs(seedSecond) * gap / (fromVertex * fromVertex);
+  const double resolution = params.positionSigma * ratio;
+  return {.vertexLever = vertexLever, .variance = (scattering * scattering) + (resolution * resolution)};
+}
+
+/// Terms shared by the per-vertex interval of one source and layer pair.
+/// Vertex-dependent terms are bounded once on the host over \a vertexZ, the
+/// range the vertices an iteration uses can take; the device computes only the
+/// centre and, for disc pairs, one division. \a sourceKink is as for
+/// `secondScattering`.
+template <DetectorLayout Det>
+[[nodiscard]] inline VertexPairWindow vertexPairWindow(LayerID from, LayerID to, const SearchWindowParams& params, Interval vertexZ, double maxSigmaZ, double sourceKink, double betweenKink = 0.)
+{
+  const double centre = 0.5 * (vertexZ.low + vertexZ.high);
+  const double reach = (0.5 * (vertexZ.high - vertexZ.low)) + (params.nSigma * maxSigmaZ);
+  const VertexConstraint envelope{.z = centre, .sigmaZ = params.nSigma > 0. ? reach / params.nSigma : 0.};
+  const double helix = helixSecondSpread<Det>(from, to, params, envelope);
+  const double boundaryRounding = 4. * static_cast<double>(std::numeric_limits<Scalar>::epsilon()) * std::max(std::abs(secondMin<Det>(to)), std::abs(secondMax<Det>(to)));
+
+  if (Detector<Det>::isBarrelLayer(from) != Detector<Det>::isBarrelLayer(to)) {
+    const double scattering = secondScattering<Det>(from, to, params, vertexZ, sourceKink, betweenKink);
+    const double padding = (params.nSigma * std::hypot(scattering, params.positionSigma)) + helix + boundaryRounding;
+    return {.secondPadding = conservativeScalarBound(padding)};
+  }
+
+  const double seedSecond = secondMax<Det>(from);
+  const auto uncertainty = vertexSecondWindow<Det>(from, to, seedSecond, params, vertexZ, sourceKink, betweenKink);
+  const double centreSpread = std::max(secondCentreSpread<Det>(from, to, vertexZ.low), secondCentreSpread<Det>(from, to, vertexZ.high));
+  double rounding = 0.;
+  VertexPairWindow result;
+  if (Detector<Det>::isBarrelLayer(from)) {
+    const double scale = secondScale<Det>(from, to, 0.);
+    result.secondScale = static_cast<Scalar>(scale);
+    const double lever = farthestApart(vertexZ, secondRange<Det>(from));
+    rounding = lever * std::abs(scale - static_cast<double>(result.secondScale));
+    const double vertexLimit = largestAbs(vertexZ);
+    rounding += 4. * static_cast<double>(std::numeric_limits<Scalar>::epsilon()) * (vertexLimit + (lever * std::abs(scale)));
+  } else {
+    const double source = discZ<Det>(from);
+    const double target = discZ<Det>(to);
+    result.sourcePosition = static_cast<Scalar>(source);
+    result.targetPosition = static_cast<Scalar>(target);
+    for (const double z : {vertexZ.low, vertexZ.high}) {
+      for (const double seed : {secondMin<Det>(from), secondMax<Det>(from)}) {
+        const auto deviceZ = static_cast<Scalar>(z);
+        const auto deviceSeed = static_cast<Scalar>(seed);
+        const Scalar device = deviceSeed * (result.targetPosition - deviceZ) / (result.sourcePosition - deviceZ);
+        const double exact = static_cast<double>(deviceSeed) * (target - static_cast<double>(deviceZ)) / (source - static_cast<double>(deviceZ));
+        rounding = std::max(rounding, std::abs(static_cast<double>(device) - exact));
+      }
+    }
+    const double ratioLimit = largestAbs(ratioRange({.low = target, .high = target}, {.low = source, .high = source}, vertexZ));
+    rounding += 8. * static_cast<double>(std::numeric_limits<Scalar>::epsilon()) * secondMax<Det>(from) * ratioLimit;
+  }
+  result.vertexLever = conservativeScalarBound(uncertainty.vertexLever);
+  result.secondVariance = conservativeScalarBound(uncertainty.variance);
+  result.secondPadding = conservativeScalarBound(uncertainty.padding + centreSpread + helix + rounding + boundaryRounding);
+  return result;
+}
+
+/// The per-pair part of a barrel <-> disc window.
+///
+/// The exact longitudinal test puts the vertex `(0, z_v)` and both
+/// measurements on one line in (r, z). Across kinds the target's coordinate
+/// is the reciprocal of the seed's:
+///
+/// ```
+/// barrel -> disc (at Z)    r_j = r_i (Z - z_v) / (z_i - z_v)
+/// disc -> barrel (at R)    z_j = z_v + (z_i - z_v) R / r_i
+/// ```
+///
+/// so no line in the seed's coordinate bounds it. Each is monotonic in `z_v`,
+/// in the target's position and in the seed's coordinate separately, and the
+/// query takes the extremes over the corners of those ranges for each seed.
+/// What is fixed per pair is stored here: the target's z or radius range, the
+/// vertex range, the seed's resolution, and a padding for scattering over the
+/// longest lever arm between the two layers and for the target's resolution.
+template <DetectorLayout Det>
+[[nodiscard]] inline LayerPairWindow crossingPairWindow(LayerID from, LayerID to, const SearchWindowParams& params, const VertexConstraint& vertex, double sourceKink, double betweenKink = 0.)
+{
+  const bool toDisc = !Detector<Det>::isBarrelLayer(to);
+  const Interval vertexZ = vertexReach(params, vertex);
+  const double scattering = secondScattering<Det>(from, to, params, vertexZ, sourceKink, betweenKink);
+  const double padding = (params.nSigma * std::hypot(scattering, params.positionSigma)) + helixSecondSpread<Det>(from, to, params, vertex);
+
+  return {
+    .phiHalfWidth = conservativeScalarBound(phiWindow<Det>(from, to, params, vertex, sourceKink, betweenKink)),
+    .secondScale = 0.F,
+    .secondOffset = static_cast<Scalar>(secondOffset<Det>(from, to, vertex.z)),
+    .secondHalfWidth = conservativeScalarBound(padding),
+    .kind = toDisc ? PairKind::kBarrelToDisc : PairKind::kDiscToBarrel,
+    .targetLow = static_cast<Scalar>(toDisc ? zMin<Det>(to) : radiusMin<Det>(to)),
+    .targetHigh = static_cast<Scalar>(toDisc ? zMax<Det>(to) : radiusMax<Det>(to)),
+    .vertexLow = static_cast<Scalar>(vertexZ.low),
+    .vertexHigh = static_cast<Scalar>(vertexZ.high),
+    .seedSpread = conservativeScalarBound(params.nSigma * params.positionSigma),
+    .targetSecondMin = static_cast<Scalar>(secondMin<Det>(to)),
+    .targetSecondMax = static_cast<Scalar>(secondMax<Det>(to)),
+  };
+}
+
+/// The half-width in phi of a displaced iteration (`SearchWindowParams::
+/// impactMax`): the widest azimuth between
+/// the two points that the displaced pair test's transverse part admits
+/// (`displacedPairWithin`), scanned as `phiWindow` scans -- from half a turn
+/// down, over the layers' radius ranges -- with the window's uniform errors:
+/// `positionSigma` at both points, \a sourceKink and \a betweenKink as for
+/// `phiWindow` (a source kink of `theta` is `S = (theta r_i)^2`), the beam
+/// spot's width. The test is symmetric in the sign of the turn.
+template <DetectorLayout Det>
+[[nodiscard]] inline double displacedPhiWindow(LayerID from, LayerID to, const SearchWindowParams& params, const VertexConstraint& vertex, double sourceKink, double betweenKink = 0.)
+{
+  constexpr double kHalf = std::numbers::pi_v<double>;
+  constexpr double kStep = 1.e-3;
+  constexpr int kSteps = static_cast<int>(kHalf / kStep) + 1;
+  constexpr int kSamples = 5;
+  const double curvatureMax = maxCurvature(params);
+  const double fromLow = radiusMin<Det>(from);
+  const double fromHigh = radiusMax<Det>(from);
+  const double toLow = radiusMin<Det>(to);
+  const double toHigh = radiusMax<Det>(to);
+  if (!(fromLow > 0.) || !(toLow > 0.)) {
+    return kHalf;
+  }
+  displaced::PairErrors<double> errors;
+  errors.sourceVarRPhi = errors.targetVarRPhi = params.positionSigma * params.positionSigma;
+  errors.betweenScatter = betweenKink * betweenKink;
+  errors.beamVarTransverse = vertex.sigmaTransverse * vertex.sigmaTransverse;
+  constexpr double kInfinity = std::numeric_limits<double>::infinity();
+  double widest = 0.;
+  for (int i = 0; i < kSamples; ++i) {
+    const double rFrom = fromLow + ((fromHigh - fromLow) * i / (kSamples - 1));
+    errors.sourceScatter = (sourceKink * rFrom) * (sourceKink * rFrom);
+    for (int j = 0; j < kSamples; ++j) {
+      const double rTo = toLow + ((toHigh - toLow) * j / (kSamples - 1));
+      for (int step = kSteps; step >= 0 && kStep * (step + 1) > widest; --step) {
+        const double phi = kStep * step;
+        const auto result = displaced::displacedPairWithin(rFrom, 0., 0., rTo * std::cos(phi), rTo * std::sin(phi), 0., errors, params.nSigma, curvatureMax, params.impactMax, -kInfinity, kInfinity);
+        if (result.transverse) {
+          widest = kStep * (step + 1);
+          break;
+        }
+      }
+    }
+  }
+  return std::min(widest, kHalf);
+}
+
+/// A displaced iteration's window (`displacedPhiWindow`): in the second
+/// coordinate the target's whole extent, about its middle, as the closest
+/// approach's z bound is the pair test's to apply, not a line's from the
+/// beam spot.
+template <DetectorLayout Det>
+[[nodiscard]] inline LayerPairWindow displacedPairWindow(LayerID from, LayerID to, const SearchWindowParams& params, const VertexConstraint& vertex, double sourceKink, double betweenKink = 0.)
+{
+  const double low = secondMin<Det>(to);
+  const double high = secondMax<Det>(to);
+  const auto middle = static_cast<Scalar>(0.5 * (low + high));
+  const double reach = std::max(std::abs(high - static_cast<double>(middle)), std::abs(static_cast<double>(middle) - low));
+  return {
+    .phiHalfWidth = conservativeScalarBound(displacedPhiWindow<Det>(from, to, params, vertex, sourceKink, betweenKink)),
+    .secondScale = 0.F,
+    .secondOffset = middle,
+    .secondHalfWidth = conservativeScalarBound(reach + params.positionSigma),
+    .kind = Detector<Det>::isBarrelLayer(to) ? PairKind::kBarrel : PairKind::kDisc,
+  };
+}
+
+/// Assemble the per-pair window an iteration queries with.
+///
+/// \a seedSecond is only read for a disc-to-disc pair; the caller passes the
+/// widest radius the seeding disc carries so that the stored half-width bounds
+/// every seed on it. \a sourceKink and \a betweenKink are as for
+/// `secondScattering`; the pair queries pass the pair cut's
+/// (`layerPairWindow(..., table)` in `PairCut.h`).
+template <DetectorLayout Det>
+[[nodiscard]] inline LayerPairWindow layerPairWindow(LayerID from, LayerID to, double seedSecond, const SearchWindowParams& params, const VertexConstraint& vertex, double sourceKink, double betweenKink = 0.)
+{
+  if (params.impactMax > 0.) {
+    return displacedPairWindow<Det>(from, to, params, vertex, sourceKink, betweenKink);
+  }
+  if (Detector<Det>::isBarrelLayer(from) != Detector<Det>::isBarrelLayer(to)) {
+    return crossingPairWindow<Det>(from, to, params, vertex, sourceKink, betweenKink);
+  }
+  const double scale = secondScale<Det>(from, to, vertex.z);
+  const double offset = secondOffset<Det>(from, to, vertex.z);
+  const auto deviceScale = static_cast<Scalar>(scale);
+  const auto deviceOffset = static_cast<Scalar>(offset);
+
+  const double seedLimit = std::max(std::abs(secondMin<Det>(from)), std::abs(secondMax<Det>(from)));
+  const double centreRounding = (seedLimit * std::abs(scale - static_cast<double>(deviceScale))) + std::abs(offset - static_cast<double>(deviceOffset));
+
+  return {
+    .phiHalfWidth = conservativeScalarBound(phiWindow<Det>(from, to, params, vertex, sourceKink, betweenKink)),
+    .secondScale = deviceScale,
+    .secondOffset = deviceOffset,
+    .secondHalfWidth = conservativeScalarBound(secondWindow<Det>(from, to, seedSecond, params, vertex, sourceKink, betweenKink) + secondCentreSpread<Det>(from, to, vertex.z) + helixSecondSpread<Det>(from, to, params, vertex) + centreRounding),
+    .kind = Detector<Det>::isBarrelLayer(from) ? PairKind::kBarrel : PairKind::kDisc,
+  };
+}
+
+/// The same with the uniform kink, taking the seeding layer's own outer edge
+/// as the conservative seed radius: what sizes the grid's cells, and a
+/// whole-layer query.
+template <DetectorLayout Det>
+[[nodiscard]] inline LayerPairWindow layerPairWindow(LayerID from, LayerID to, const SearchWindowParams& params, const VertexConstraint& vertex)
+{
+  return layerPairWindow<Det>(from, to, secondMax<Det>(from), params, vertex, uniformSourceKink(params));
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_SEARCHWINDOW_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Seed.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Seed.h
new file mode 100644
index 0000000000000..3e5571ec0d1e7
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Seed.h
@@ -0,0 +1,347 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Seed.h
+/// \brief Whole-chain seed helices and the diffuse priors for the uniform-solenoid track model.
+
+#ifndef GTRK_TRACKING_SEED_H_
+#define GTRK_TRACKING_SEED_H_
+
+#include "GenericTracking/Tracking/BoundTrackState.h"
+#include "GenericTracking/Tracking/MathUtils.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tracking/Trig.h"
+
+#include "GPUCommonMath.h"
+
+#include <cstddef>
+#include <numbers>
+#include <utility>
+
+namespace o2::gtrk
+{
+
+namespace detail
+{
+
+/// Global position of \a m relative to \a origin, in the requested arithmetic type.
+template <typename T>
+GPUdi() void relativePosition(const TrackingSurface& surface, const Measurement& m, const T origin[3], T out[3])
+{
+  Scalar global[3]{};
+  surfaceToGlobal(surface, m.loc0, m.loc1, global);
+  for (int i = 0; i < 3; ++i) {
+    out[i] = static_cast<T>(global[i]) - origin[i];
+  }
+}
+
+} // namespace detail
+
+/// The q/p prior on a whole-chain seed: the wider of kChainQOverPSpread
+/// times |q/p| and kChainPriorOverResolution times the resolution the chain's
+/// measurements alone give.
+///
+/// Diffuse has to mean wide against what the chain determines, and a chain
+/// determines q/p very differently with its length. Three points fix it to
+/// tens of percent, and there a factor of a few is what diffuse means. Ten
+/// layers over a metre fix it to a few percent where scattering limits it,
+/// under one at high pT -- and a factor of three is then not diffuse but out
+/// of range: an inward pass opens with a 20 cm step, the q/p uncertainty
+/// becomes a position variance of hundreds of cm^2 against a 2.5e-6 cm^2
+/// cluster, and the float covariance cannot come back from it. 0.3 keeps the
+/// prior ten or more times wider than a scattering-limited resolution; the
+/// second term keeps short chains as diffuse as a three-point seed. Without
+/// any material ten points fix q/p to 1e-4, which no prior both
+/// non-informative and representable in float reaches, but no track crosses
+/// no material.
+inline constexpr Scalar kChainQOverPSpread = 0.3F;
+inline constexpr Scalar kChainPriorOverResolution = 30.F;
+
+/// A direction's diffuse prior: a three-point seed fixes the direction to
+/// milliradians; 0.1 rad is two orders looser.
+inline constexpr Scalar kDiffuseAngleVariance = 1e-2F;
+
+/// Set the deliberately diffuse diagonal covariance used by both fit passes.
+///
+/// The seed parameters come from the chain's own measurements, but their
+/// covariance is not estimated from those same points. The measurements are
+/// consumed by the filter with this broad prior instead.
+///
+/// **Diffuse means a hundred times the measurement, not a million**: a q/p
+/// variance of 1e4 cannot be reduced to 2e-2 in float -- P - K H P returns
+/// negative variances. So each prior is sized against what the measurements
+/// determine, and q/p relative to the seed's own estimate: a fixed large width
+/// stops being representable, a fixed small one stops being diffuse for a
+/// 50 MeV track.
+///
+/// \a qOverPSigma is that width, and it belongs to where the estimate came
+/// from: see kChainQOverPSpread.
+GPUhdi() GPUAlwaysInline() void setDiffuseCovariance(BoundTrackState& seed, Scalar qOverPSigma)
+{
+  for (auto& value : seed.cov) {
+    value = 0.F;
+  }
+  // A sensor is about a centimetre, so 1 mm is generous against a cluster
+  // resolution of tens of microns.
+  seed.variance(kLoc0) = 1e-2F;
+  seed.variance(kLoc1) = 1e-2F;
+  seed.variance(kPhi) = kDiffuseAngleVariance;
+  seed.variance(kTheta) = kDiffuseAngleVariance;
+  seed.variance(kQOverP) = o2::gpu::GPUCommonMath::Max(qOverPSigma * qOverPSigma, 1e-2F);
+}
+
+/// Free a state's direction, as a kink in the fit does:
+/// `phi` and `theta` get the diffuse prior and lose their covariances with
+/// every other parameter; position and q/p keep theirs.
+GPUhdi() GPUAlwaysInline() void freeDirection(BoundTrackState& state)
+{
+  state.decorrelate(kPhi, kTheta);
+  state.variance(kPhi) = kDiffuseAngleVariance;
+  state.variance(kTheta) = kDiffuseAngleVariance;
+}
+
+/// A whole-chain seed and the q/p width of its prior, which both fit passes
+/// need.
+struct ChainSeed {
+  BoundTrackState state;
+  Scalar qOverPSigma = 0.F;
+};
+
+/// Construct a state on the first surface of an ordered chain from a helix
+/// fitted through all \a n of its measurements.
+///
+/// This is the fit's outward seed, and its q/p width that of both passes'
+/// priors. The filter linearises each step about its own filtered state
+/// (TrackFitter.h, `filterStep`), so the seed only has to start it on the
+/// right helix: a three-point seed's curvature, fixed over the first few
+/// centimetres, is not that once the chain is long.
+///
+/// Transverse: Karimaki's circle fit (NIM A 305 (1991) 187) about the first
+/// measurement. It is closed form -- sums over the points and one atan2 -- and
+/// stays regular as the curvature vanishes, so a straight track needs no
+/// branch. Its phi is defined modulo pi and is resolved towards the second
+/// measurement; its curvature is positive clockwise, ours counter-clockwise.
+/// Longitudinal: z against transverse arc length from the closest approach to
+/// the first measurement, least squares in intercept and slope.
+///
+/// Both fits are unweighted: cluster-level accuracy is all a starting point
+/// needs.
+///
+/// \a T controls the transient fit arithmetic. The returned state remains
+/// Scalar, and the device path uses the Scalar default.
+///
+/// \a measurements is anything indexed by `[i]` giving a `Measurement`: an
+/// array, or rows read from the frame's columns.
+template <typename T = Scalar, typename Prop, DetectorLayout Det, typename Chain>
+GPUdi() ChainSeed makeChainSeed(const Prop& prop, const TrackingGeometry<Det>& geometry, const Chain& measurements, int n)
+{
+  // Everything is relative to the first measurement: the circle is fitted
+  // about it, and sums of large absolute coordinates would cancel.
+  const auto& firstSurface = geometry.planeOf(measurements[0]);
+  T origin[3]{};
+  {
+    Scalar global[3]{};
+    surfaceToGlobal(firstSurface, measurements[0].loc0, measurements[0].loc1, global);
+    for (int i = 0; i < 3; ++i) {
+      origin[i] = static_cast<T>(global[i]);
+    }
+  }
+
+  // Online centred moments avoid the cancellation in E[x^2] - E[x]^2.
+  // The r2 covariances are rescaled after the pass so all quantities entering
+  // q1 and q2 are of comparable size even for a metre-long chain.
+  T meanX = T(0);
+  T meanY = T(0);
+  T meanR2 = T(0);
+  T cXX = T(0);
+  T cXY = T(0);
+  T cYY = T(0);
+  T cXR = T(0);
+  T cYR = T(0);
+  T cRR = T(0);
+  T transverseScale = T(0);
+  T second[3]{};
+#ifndef GPUCA_GPUCODE
+  // The longitudinal pass reads these same immutable points again. Cache
+  // their first transform on the CPU; avoid a larger device register frame.
+  constexpr auto kCachePoints = static_cast<std::size_t>(Detector<Det>::nLayers);
+  T cachedPositions[kCachePoints][3];
+  T cachedVarLoc0[kCachePoints];
+  const bool cachePoints = n >= 0 && std::cmp_less_equal(n, kCachePoints);
+#endif
+  for (int i = 0; i < n; ++i) {
+    T p[3]{};
+#ifdef GPUCA_GPUCODE
+    detail::relativePosition<T>(geometry.planeOf(measurements[i]), measurements[i], origin, p);
+#else
+    const auto measurement = measurements[i];
+    detail::relativePosition<T>(geometry.planeOf(measurement), measurement, origin, p);
+    if (cachePoints) {
+      for (int axis = 0; axis < 3; ++axis) {
+        cachedPositions[i][axis] = p[axis];
+      }
+      cachedVarLoc0[i] = static_cast<T>(measurement.varLoc0);
+    }
+#endif
+    if (i == 1) {
+      second[0] = p[0];
+      second[1] = p[1];
+    }
+    const T r2 = p[0] * p[0] + p[1] * p[1];
+    transverseScale = o2::gpu::GPUCommonMath::Max(transverseScale, o2::math_utils::detail::sqrt(r2));
+
+    const T count = static_cast<T>(i + 1);
+    const T dx = p[0] - meanX;
+    const T dy = p[1] - meanY;
+    const T dr = r2 - meanR2;
+    meanX += dx / count;
+    meanY += dy / count;
+    meanR2 += dr / count;
+    cXX += dx * (p[0] - meanX);
+    cXY += dx * (p[1] - meanY);
+    cYY += dy * (p[1] - meanY);
+    cXR += dx * (r2 - meanR2);
+    cYR += dy * (r2 - meanR2);
+    cRR += dr * (r2 - meanR2);
+  }
+
+  const T invScale = T(1) / transverseScale;
+  const T invScale2 = invScale * invScale;
+  const T scaledMeanX = meanX * invScale;
+  const T scaledMeanY = meanY * invScale;
+  const T scaledMeanR2 = meanR2 * invScale2;
+  const T scaledCXX = cXX * invScale2;
+  const T scaledCXY = cXY * invScale2;
+  const T scaledCYY = cYY * invScale2;
+  const T scaledCXR = cXR * invScale2 * invScale;
+  const T scaledCYR = cYR * invScale2 * invScale;
+  const T scaledCRR = cRR * invScale2 * invScale2;
+
+  const T q1 = scaledCRR * scaledCXY - scaledCXR * scaledCYR;
+  const T q2 = scaledCRR * (scaledCXX - scaledCYY) - scaledCXR * scaledCXR + scaledCYR * scaledCYR;
+  T phi = T(0.5) * atan2Of(T(2) * q1, q2);
+  T sinPhi = T(0);
+  T cosPhi = T(0);
+  sincosOf(phi, sinPhi, cosPhi);
+  const T scaledKappa = (sinPhi * scaledCXR - cosPhi * scaledCYR) / scaledCRR;
+  const T delta = -scaledKappa * scaledMeanR2 + sinPhi * scaledMeanX - cosPhi * scaledMeanY;
+  const T root = o2::math_utils::detail::sqrt(o2::gpu::GPUCommonMath::Max(T(0), T(1) - T(4) * delta * scaledKappa));
+  T rho = T(2) * scaledKappa * invScale / root;
+  T dca = T(2) * delta * transverseScale / (T(1) + root);
+  if (cosPhi * second[0] + sinPhi * second[1] < T(0)) {
+    sinPhi = -sinPhi;
+    cosPhi = -cosPhi;
+    phi += phi > T(0) ? -std::numbers::pi_v<T> : std::numbers::pi_v<T>;
+    rho = -rho;
+    dca = -dca;
+  }
+  const T curvature = -rho;
+
+  // The closest approach to the first measurement, where the arc starts.
+  const T start[2] = {dca * sinPhi, -dca * cosPhi};
+
+  // Arc lengths accumulate point to point, so a chain that turns through more
+  // than half a circle still unwinds monotonically.
+  T arc = T(0);
+  T previous[2] = {start[0], start[1]};
+  T meanS = T(0);
+  T meanZ = T(0);
+  T cSS = T(0);
+  T cSZ = T(0);
+  T sumVarLoc0 = T(0);
+  for (int i = 0; i < n; ++i) {
+    T p[3]{};
+#ifndef GPUCA_GPUCODE
+    if (cachePoints) {
+      sumVarLoc0 += cachedVarLoc0[i];
+      for (int axis = 0; axis < 3; ++axis) {
+        p[axis] = cachedPositions[i][axis];
+      }
+    } else
+#endif
+    {
+      sumVarLoc0 += static_cast<T>(measurements[i].varLoc0);
+      detail::relativePosition<T>(geometry.planeOf(measurements[i]), measurements[i], origin, p);
+    }
+    arc += detail::transverseArc<T>(curvature, p[0] - previous[0], p[1] - previous[1]);
+    previous[0] = p[0];
+    previous[1] = p[1];
+
+    const T count = static_cast<T>(i + 1);
+    const T ds = arc - meanS;
+    const T dz = p[2] - meanZ;
+    meanS += ds / count;
+    meanZ += dz / count;
+    cSS += ds * (arc - meanS);
+    cSZ += ds * (p[2] - meanZ);
+  }
+  const T cotTheta = cSZ / cSS;
+  const T zStart = meanZ - cotTheta * meanS;
+
+  const T theta = atan2Of(T(1), cotTheta);
+  const T thetaNorm = o2::math_utils::detail::sqrt(T(1) + cotTheta * cotTheta);
+  const T sinTheta = T(1) / thetaNorm;
+  const T cosTheta = cotTheta / thetaNorm;
+  // The chain's propagator is asked at each use, not held in a local.
+  const T field = static_cast<T>(stepPropagator(prop, geometry, measurements, 0, n - 1).bzKiloGauss) * static_cast<T>(constants::math::B2C);
+
+  // The closest approach lies within a cluster residual of the first surface
+  // but not on it. Step along the track onto the plane; over microns the
+  // straight line and the helix agree to far below float precision.
+  const T direction[3] = {sinTheta * cosPhi, sinTheta * sinPhi, cosTheta};
+  T pointFromSurface[3]{};
+  T height = T(0);
+  T towards = T(0);
+  for (int i = 0; i < 3; ++i) {
+    pointFromSurface[i] = static_cast<T>(measurements[0].loc0) * static_cast<T>(firstSurface.axis0[i]) + static_cast<T>(measurements[0].loc1) * static_cast<T>(firstSurface.axis1[i]);
+    if (i < 2) {
+      pointFromSurface[i] += start[i];
+    } else {
+      pointFromSurface[i] += zStart;
+    }
+    height += pointFromSurface[i] * static_cast<T>(firstSurface.normal[i]);
+    towards += direction[i] * static_cast<T>(firstSurface.normal[i]);
+  }
+  if (o2::gpu::GPUCommonMath::Abs(towards) > static_cast<T>(stepPropagator(prop, geometry, measurements, 0, n - 1).minAbsCosIncidence)) {
+    for (int i = 0; i < 3; ++i) {
+      pointFromSurface[i] -= height / towards * direction[i];
+    }
+  }
+  T local[2]{};
+  for (int i = 0; i < 3; ++i) {
+    local[0] += pointFromSurface[i] * static_cast<T>(firstSurface.axis0[i]);
+    local[1] += pointFromSurface[i] * static_cast<T>(firstSurface.axis1[i]);
+  }
+
+  ChainSeed seed;
+  auto& state = seed.state;
+  state.par[kLoc0] = static_cast<Scalar>(local[0]);
+  state.par[kLoc1] = static_cast<Scalar>(local[1]);
+  state.par[kPhi] = static_cast<Scalar>(phi);
+  state.par[kTheta] = static_cast<Scalar>(theta);
+  state.par[kQOverP] = static_cast<Scalar>(curvature * sinTheta / field);
+  state.surface = measurements[0].surface;
+  state.surfacePhi = firstSurface.surfacePhi;
+
+  // The measurement-limited curvature resolution over the chain's own arc,
+  // Gluckstern's equal-spacing form; scattering only widens it.
+  const T inv = T(1) / static_cast<T>(n);
+  const T curvatureSigma = o2::math_utils::detail::sqrt(sumVarLoc0 * inv) * o2::math_utils::detail::sqrt(T(720) / (static_cast<T>(n) + T(4))) / (arc * arc);
+  seed.qOverPSigma = static_cast<Scalar>(o2::gpu::GPUCommonMath::Max(static_cast<T>(kChainQOverPSpread) * o2::gpu::GPUCommonMath::Abs(curvature), static_cast<T>(kChainPriorOverResolution) * curvatureSigma) * sinTheta / field);
+  setDiffuseCovariance(state, seed.qOverPSigma);
+  return seed;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_SEED_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Selection.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Selection.h
new file mode 100644
index 0000000000000..db0e98534189c
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Selection.h
@@ -0,0 +1,491 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Selection.h
+/// \brief An iteration's global greedy selection, in a form the host and a
+///        device run alike.
+///
+/// The records of every slice are concatenated, deduplicated by their
+/// cluster set and ranked by the quality order -- sorts of fixed-width keys,
+/// radix sorts on a device -- and selected by rounds of bidding, which end
+/// with exactly the result of the sequential greedy walk. The records and the
+/// used mask stay where they are; only the flag "is any record still live"
+/// crosses to the controller per round.
+///
+/// The used mask holds, per measurement row, free, shared (taken only at
+/// positions among a track's `k` innermost) or exclusive. Two records
+/// conflict when they have a common row at a position beyond the first `k` in
+/// either of them.
+
+#ifndef GTRK_TRACKING_SELECTION_H_
+#define GTRK_TRACKING_SELECTION_H_
+
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Base/Columns.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Base/HostAlgorithms.h"
+#include "GenericTracking/Tracking/Profile.h"
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+
+#include "GPUCommonMath.h"
+
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <span>
+
+namespace o2::gtrk
+{
+
+namespace selection
+{
+
+/// Whether a record's cluster at \a position is shareable.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool shareable(std::uint32_t position, std::uint32_t sharedInnermost) { return position < sharedInnermost; }
+
+/// Whether a record conflicts with the tracks already in \a mask.
+template <std::size_t K>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool conflicts(const ClusterList<K>& clusters, std::uint32_t count, const std::uint8_t* mask, std::uint32_t sharedInnermost)
+{
+  for (std::uint32_t position = 0; position < count; ++position) {
+    const std::uint8_t state = mask[clusters.index[position]];
+    if (state == kExclusive || (state == kShared && !shareable(position, sharedInnermost))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/// The cluster set, sorted: the deduplication key.
+template <std::size_t K>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() ClusterList<K> sortedKey(const ClusterList<K>& clusters, std::uint32_t count)
+{
+  ClusterList<K> key = clusters;
+  insertionSort(key.index, count, [](std::uint32_t a, std::uint32_t b) { return a < b; });
+  return key;
+}
+
+template <std::size_t K>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() int compareKeys(const ClusterList<K>& lhs, const ClusterList<K>& rhs)
+{
+  for (std::size_t i = 0; i < K; ++i) {
+    if (lhs.index[i] != rhs.index[i]) {
+      return lhs.index[i] < rhs.index[i] ? -1 : 1;
+    }
+  }
+  return 0;
+}
+
+/// The width of `qualityKey` in bits.
+inline constexpr int kQualityKeyBits = 48;
+
+/// The quality order's key: clusters descending, kinks ascending, chi2
+/// ascending, over `kQualityKeyBits` bits; the cluster set breaks ties. The fits refuse a
+/// negative or NaN chi2 (`updateUsable`); clamped here as well, so that a
+/// record that slipped through orders first rather than by its sign bit.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint64_t qualityKey(std::uint8_t count, std::uint8_t kinks, Scalar chi2)
+{
+  const Scalar quality = chi2 > 0.F ? chi2 : 0.F;
+  return (std::uint64_t{255U - count} << 40U) | (std::uint64_t{kinks} << 32U) | std::uint64_t{std::bit_cast<std::uint32_t>(quality)};
+}
+
+/// Whether a duplicate is the record it duplicates -- the same count, kinks,
+/// chi2 bits and clusters in their order: a record found by more than one
+/// slice is the same record in each.
+template <std::size_t K>
+[[nodiscard]] GPUdi() bool sameRecord(const ClusterList<K>& clusters, std::uint8_t count, std::uint8_t kinks, Scalar chi2, const ClusterList<K>& otherClusters, std::uint8_t otherCount, std::uint8_t otherKinks, Scalar otherChi2)
+{
+  return count == otherCount && kinks == otherKinks && std::bit_cast<std::uint32_t>(chi2) == std::bit_cast<std::uint32_t>(otherChi2) && compareKeys(clusters, otherClusters) == 0;
+}
+
+/// One element per rank: the rank arrays the rounds read -- the ranked
+/// record's clusters and count, its priority (the best the highest), live and
+/// not accepted.
+template <std::size_t K>
+struct RankFill {
+  const ClusterList<K>* clusters = nullptr;
+  const std::uint8_t* count = nullptr;
+  const std::uint32_t* ranked = nullptr;
+  std::uint32_t unique = 0U;
+  ClusterList<K>* rankClusters = nullptr;
+  std::uint8_t* rankCount = nullptr;
+  std::uint32_t* priority = nullptr;
+  std::uint8_t* live = nullptr;
+  std::uint8_t* accepted = nullptr;
+
+  GPUhdi() void operator()(std::uint32_t rank) const
+  {
+    const std::uint32_t record = ranked[rank];
+    rankClusters[rank] = clusters[record];
+    rankCount[rank] = count[record];
+    priority[rank] = unique - rank;
+    live[rank] = 1U;
+    accepted[rank] = 0U;
+  }
+};
+
+/// One element per live record: clear its clusters' bid slots.
+template <std::size_t K>
+struct BidReset {
+  const ClusterList<K>* clusters = nullptr;
+  const std::uint8_t* count = nullptr;
+  const std::uint8_t* live = nullptr;
+  std::uint32_t* slotAll = nullptr;
+  std::uint32_t* slotExclusive = nullptr;
+
+  GPUhdi() void operator()(std::uint32_t record) const
+  {
+    if (live[record] == 0U) {
+      return;
+    }
+    for (std::uint32_t position = 0; position < count[record]; ++position) {
+      slotAll[clusters[record].index[position]] = 0U;
+      slotExclusive[clusters[record].index[position]] = 0U;
+    }
+  }
+};
+
+/// One element per live record: bid its priority on every cluster, and at an
+/// exclusive position also on the exclusive users' slot.
+template <std::size_t K>
+struct Bid {
+  const ClusterList<K>* clusters = nullptr;
+  const std::uint8_t* count = nullptr;
+  const std::uint8_t* live = nullptr;
+  const std::uint32_t* priority = nullptr;
+  std::uint32_t* slotAll = nullptr;
+  std::uint32_t* slotExclusive = nullptr;
+  std::uint32_t sharedInnermost = 0U;
+
+  GPUdi() void operator()(std::uint32_t record) const
+  {
+    if (live[record] == 0U) {
+      return;
+    }
+    for (std::uint32_t position = 0; position < count[record]; ++position) {
+      const std::uint32_t row = clusters[record].index[position];
+      o2::gpu::CAMath::AtomicMax(slotAll + row, priority[record]);
+      if (!shareable(position, sharedInnermost)) {
+        o2::gpu::CAMath::AtomicMax(slotExclusive + row, priority[record]);
+      }
+    }
+  }
+};
+
+/// One element per live record: accepted if it wins every cluster -- holds
+/// the maximum at an exclusive position, outbids every exclusive user at a
+/// shareable one -- and then writes the mask. Two records accepted in one
+/// round never conflict, so their writes never disagree.
+template <std::size_t K>
+struct Decide {
+  const ClusterList<K>* clusters = nullptr;
+  const std::uint8_t* count = nullptr;
+  std::uint8_t* live = nullptr;
+  std::uint8_t* accepted = nullptr;
+  const std::uint32_t* priority = nullptr;
+  const std::uint32_t* slotAll = nullptr;
+  const std::uint32_t* slotExclusive = nullptr;
+  std::uint8_t* mask = nullptr;
+  std::uint32_t sharedInnermost = 0U;
+
+  GPUhdi() void operator()(std::uint32_t record) const
+  {
+    if (live[record] == 0U) {
+      return;
+    }
+    const std::uint32_t own = priority[record];
+    for (std::uint32_t position = 0; position < count[record]; ++position) {
+      const std::uint32_t row = clusters[record].index[position];
+      const bool wins = shareable(position, sharedInnermost) ? slotExclusive[row] < own : slotAll[row] == own;
+      if (!wins) {
+        return;
+      }
+    }
+    accepted[record] = 1U;
+    live[record] = 0U;
+    // Two accepted records sharing an innermost row store the same byte.
+    for (std::uint32_t position = 0; position < count[record]; ++position) {
+      o2::gpu::CAMath::AtomicStore(mask + clusters[record].index[position], static_cast<std::uint8_t>(shareable(position, sharedInnermost) ? kShared : kExclusive));
+    }
+  }
+};
+
+/// One element per live record: out if it conflicts with the mask; \a stillLive
+/// raised otherwise.
+template <std::size_t K>
+struct Prune {
+  const ClusterList<K>* clusters = nullptr;
+  const std::uint8_t* count = nullptr;
+  std::uint8_t* live = nullptr;
+  const std::uint8_t* mask = nullptr;
+  std::uint32_t sharedInnermost = 0U;
+  std::uint32_t* stillLive = nullptr;
+
+  GPUdi() void operator()(std::uint32_t record) const
+  {
+    if (live[record] == 0U) {
+      return;
+    }
+    if (conflicts(clusters[record], count[record], mask, sharedInnermost)) {
+      live[record] = 0U;
+      return;
+    }
+    o2::gpu::CAMath::AtomicMax(stillLive, std::uint32_t{1U});
+  }
+};
+
+} // namespace selection
+
+/// One iteration's global selection over the records of every slice.
+template <std::size_t K>
+class GlobalSelection
+{
+ public:
+  using Records = StageOutput<SelectionRecordOf<K>::template RecordT>;
+  using Index = std::uint32_t;
+
+  GlobalSelection() = default;
+  ~GlobalSelection() = default;
+  GlobalSelection(const GlobalSelection&) = delete;
+  GlobalSelection& operator=(const GlobalSelection&) = delete;
+  GlobalSelection(GlobalSelection&&) = delete;
+  GlobalSelection& operator=(GlobalSelection&&) = delete;
+
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
+  {
+    mMemoryPool.swap(pool);
+    clearStorage();
+  }
+
+  /// Start an iteration: no records.
+  void clear() { mRecords.resize(0U); }
+
+  /// Append one slice's records; \a forEach(count, body) runs body(i) for i
+  /// in [0, count), serially or in parallel (the copy).
+  template <typename ForEach>
+  [[nodiscard]] StageStatus append(const Records& records, const ForEach& forEach)
+  {
+    return guardOutOfMemory([&] {
+      const std::size_t begin = mRecords.size();
+      const std::size_t count = records.size();
+      mRecords.resize(begin + count);
+      copyRows(records.view(), begin, count, forEach);
+      return StageStatus::kComplete;
+    });
+  }
+
+  /// Append every record of \a other: an iteration's records made by the
+  /// previous iteration's slices (one graph for both rounds). Records whose rows an earlier track holds are out before the
+  /// selection's first round, as any.
+  template <typename ForEach>
+  [[nodiscard]] StageStatus append(const GlobalSelection& other, const ForEach& forEach)
+  {
+    return guardOutOfMemory([&] {
+      const std::size_t begin = mRecords.size();
+      const std::size_t count = other.mRecords.size();
+      mRecords.resize(begin + count);
+      copyRows(other.mRecords.view(), begin, count, forEach);
+      return StageStatus::kComplete;
+    });
+  }
+
+  /// Select into \a mask, one entry per measurement row, which holds the
+  /// earlier iterations' tracks. A record's `k` innermost clusters are
+  /// shareable, \a sharedInnermost. \a forEach(elements, body) runs
+  /// body(element) for every element, serially or in parallel, and
+  /// \a sort(indices, less) sorts a span of indices by a strict total order,
+  /// on the same threads (`CpuStage::sortIndices`).
+  template <typename ForEach, typename Sort>
+  [[nodiscard]] StageStatus select(ForEach forEach, Sort sort, std::uint32_t sharedInnermost, std::span<std::uint8_t> mask)
+  {
+    using profile::Phase;
+    return guardOutOfMemory([&] {
+      const auto records = mRecords.view();
+      const auto total = static_cast<Index>(mRecords.size());
+      mDuplicates = 0U;
+      mMismatches = 0U;
+
+      // Deduplication: the records sorted by their cluster set, the first of
+      // each run kept; a record found by more than one slice is the same
+      // record in each.
+      {
+        const profile::Zone zone{Phase::kSelectionKeys};
+        // The arrays are kept from iteration to iteration and filled in
+        // parallel, not reallocated.
+        resizeBoundedVector(mKeys, total, mMemoryPool.get());
+        forEach(total, [&](Index record) { mKeys[record] = selection::sortedKey(records.clusters[record], records.count[record]); });
+      }
+      {
+        const profile::Zone zone{Phase::kSelectionOrder};
+        resizeBoundedVector(mOrder, total, mMemoryPool.get());
+        forEach(total, [&](Index record) { mOrder[record] = record; });
+        // A total order -- the tie-break is the record index -- so the sorted
+        // result is unique and a parallel unstable sort gives the serial one's.
+        sort(std::span<Index>{mOrder}, [&](Index lhs, Index rhs) {
+          const int order = selection::compareKeys(mKeys[lhs], mKeys[rhs]);
+          if (order != 0) {
+            return order < 0;
+          }
+          return lhs < rhs;
+        });
+      }
+      std::optional<profile::Zone> zone{std::in_place, Phase::kSelectionDeduplicate};
+      mUnique.resize(0U);
+      for (Index i = 0; i < total; ++i) {
+        const Index record = mOrder[i];
+        if (i != 0U && selection::compareKeys(mKeys[record], mKeys[mOrder[i - 1U]]) == 0) {
+          const Index kept = mUnique.back();
+          ++mDuplicates;
+          const bool same = selection::sameRecord(records.clusters[record], records.count[record], records.kinks[record], records.chi2[record], records.clusters[kept], records.count[kept], records.kinks[kept], records.chi2[kept]);
+          mMismatches += same ? 0U : 1U;
+          continue;
+        }
+        mUnique.push_back(record);
+      }
+
+      // The quality order: clusters descending, kinks ascending, chi2
+      // ascending (`selection::qualityKey`, the device's sort key), the
+      // cluster set ascending; the rank gives each record its unique priority.
+      // Also a total order: the deduplication above left one record per
+      // cluster set, so the final key comparison never returns 0.
+      zone.reset();
+      zone.emplace(Phase::kSelectionRank);
+      sort(std::span<Index>{mUnique}, [&](Index lhs, Index rhs) {
+        const auto lhsKey = selection::qualityKey(records.count[lhs], records.kinks[lhs], records.chi2[lhs]);
+        const auto rhsKey = selection::qualityKey(records.count[rhs], records.kinks[rhs], records.chi2[rhs]);
+        if (lhsKey != rhsKey) {
+          return lhsKey < rhsKey;
+        }
+        return selection::compareKeys(mKeys[lhs], mKeys[rhs]) < 0;
+      });
+      const auto unique = static_cast<Index>(mUnique.size());
+      zone.reset();
+      zone.emplace(Phase::kSelectionFill);
+      resizeBoundedVector(mClusters, unique, mMemoryPool.get());
+      resizeBoundedVector(mCount, unique, mMemoryPool.get());
+      resizeBoundedVector(mPriority, unique, mMemoryPool.get());
+      resizeBoundedVector(mLive, unique, mMemoryPool.get());
+      resizeBoundedVector(mAccepted, unique, mMemoryPool.get());
+      forEach(unique, selection::RankFill<K>{
+                        .clusters = records.clusters,
+                        .count = records.count,
+                        .ranked = mUnique.data(),
+                        .unique = unique,
+                        .rankClusters = mClusters.data(),
+                        .rankCount = mCount.data(),
+                        .priority = mPriority.data(),
+                        .live = mLive.data(),
+                        .accepted = mAccepted.data(),
+                      });
+
+      // The rounds; a record conflicting with an earlier iteration's track is
+      // out before the first.
+      zone.reset();
+      zone.emplace(Phase::kSelectionSlots);
+      // Kept from call to call and zeroed in parallel, not reallocated.
+      mSlotAll.resize(mask.size());
+      mSlotExclusive.resize(mask.size());
+      forEach(static_cast<Index>(mask.size()), [&](Index row) {
+        mSlotAll[row] = 0U;
+        mSlotExclusive[row] = 0U;
+      });
+      zone.reset();
+      zone.emplace(Phase::kSelectionRounds);
+      Index stillLive = 0U;
+      const selection::Prune<K> prune{mClusters.data(), mCount.data(), mLive.data(), mask.data(), sharedInnermost, &stillLive};
+      const selection::BidReset<K> reset{mClusters.data(), mCount.data(), mLive.data(), mSlotAll.data(), mSlotExclusive.data()};
+      const selection::Bid<K> bid{mClusters.data(), mCount.data(), mLive.data(), mPriority.data(), mSlotAll.data(), mSlotExclusive.data(), sharedInnermost};
+      const selection::Decide<K> decide{mClusters.data(), mCount.data(), mLive.data(), mAccepted.data(), mPriority.data(), mSlotAll.data(), mSlotExclusive.data(), mask.data(), sharedInnermost};
+      forEach(unique, prune);
+      mRounds = 0U;
+      while (stillLive != 0U) {
+        forEach(unique, reset);
+        forEach(unique, bid);
+        forEach(unique, decide);
+        stillLive = 0U;
+        forEach(unique, prune);
+        ++mRounds;
+      }
+
+      zone.reset();
+      zone.emplace(Phase::kSelectionCompact);
+      mSelected.resize(0U);
+      for (Index rank = 0; rank < unique; ++rank) {
+        if (mAccepted[rank] != 0U) {
+          mSelected.push_back(mUnique[rank]);
+        }
+      }
+      return StageStatus::kComplete;
+    });
+  }
+
+  void clearStorage() noexcept
+  {
+    clearRecordStorage();
+    deepVectorClear(mMemoryPool.get(), mSlotAll, mSlotExclusive);
+  }
+
+  /// What grows with an iteration's records back to the pool; the slots, one
+  /// per row of the timeframe whatever the iteration, stay.
+  void clearRecordStorage() noexcept
+  {
+    mRecords.setMemoryResource(mMemoryPool.get());
+    deepVectorClear(mMemoryPool.get(), mKeys, mOrder, mUnique, mClusters, mCount, mPriority, mLive, mAccepted, mSelected);
+  }
+
+  /// The records appended this iteration.
+  [[nodiscard]] typename BoundedColumns<SelectionRecordOf<K>::template RecordT>::ConstView records() const { return mRecords.view(); }
+  [[nodiscard]] Index recordCount() const { return static_cast<Index>(mRecords.size()); }
+  /// The accepted records, as indices into records(), best first.
+  [[nodiscard]] std::span<const Index> selected() const { return mSelected; }
+  /// The deduplicated records, best first: the order the selection follows.
+  [[nodiscard]] std::span<const Index> ranked() const { return mUnique; }
+  [[nodiscard]] Index duplicates() const { return mDuplicates; }
+  /// Duplicates that differ from the record they duplicate: a record found by
+  /// more than one slice is the same record in each, so this is zero, or the
+  /// output is wrong.
+  [[nodiscard]] Index mismatches() const { return mMismatches; }
+  [[nodiscard]] Index rounds() const { return mRounds; }
+
+ private:
+  /// The \a count rows of \a from to rows \a begin on, every column of the
+  /// record, whatever it holds, the rows in \a forEach's chunks.
+  template <typename View, typename ForEach>
+  void copyRows(const View& from, std::size_t begin, std::size_t count, const ForEach& forEach)
+  {
+    const auto to = mRecords.view();
+    forEach(static_cast<Index>(count), [&](Index row) { from.apply([&](const auto*... source) { to.apply([&](auto*... target) { ((target[begin + row] = source[row]), ...); }); }); });
+  }
+
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  BoundedColumns<SelectionRecordOf<K>::template RecordT> mRecords;
+  BoundedVector<ClusterList<K>> mKeys;
+  BoundedVector<Index> mOrder;
+  BoundedVector<Index> mUnique;
+  BoundedVector<ClusterList<K>> mClusters;
+  BoundedVector<std::uint8_t> mCount;
+  BoundedVector<Index> mPriority;
+  BoundedVector<std::uint8_t> mLive;
+  BoundedVector<std::uint8_t> mAccepted;
+  BoundedVector<Index> mSlotAll;
+  BoundedVector<Index> mSlotExclusive;
+  BoundedVector<Index> mSelected;
+  Index mDuplicates = 0U;
+  Index mMismatches = 0U;
+  Index mRounds = 0U;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_SELECTION_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/SensorCells.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/SensorCells.h
new file mode 100644
index 0000000000000..22d6bef2c90c8
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/SensorCells.h
@@ -0,0 +1,276 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file SensorCells.h
+/// \brief The sensors of each layer by where they are, for the follow's hole
+///        test: which of a layer's sensors
+///        a track may cross near a predicted crossing.
+///
+/// Each layer is cut into cells of azimuth and its second coordinate (z on
+/// a barrel layer, r on a disc), and each sensor is listed in every cell its
+/// active area's footprint reaches: the bounding box of its outline, which a
+/// flat sensor's corners and the points of its edges nearest the beam axis
+/// bound, and a curved one's corners. A query over a range of both
+/// coordinates visits the sensors of the cells it covers, a superset of
+/// those whose footprint it meets (each sensor is listed one cell beyond its
+/// footprint too, against the query's rounding). The cells are as wide as the layer's
+/// narrowest footprint in either coordinate, so a cell holds a few sensors.
+///
+/// Built from the tracking geometry when the track model is set; the view is
+/// what a device reads.
+
+#ifndef GTRK_TRACKING_SENSORCELLS_H_
+#define GTRK_TRACKING_SENSORCELLS_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+
+#include "GPUCommonMath.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <numbers>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+/// One layer's cells: \a nPhi azimuth cells of `kTwoPi / nPhi` from 0, and
+/// \a nSecond cells of \a secondBin from \a secondLow; its cells are the
+/// CSR's from \a cellOffset on, the second coordinate's index major.
+struct SensorCellLayer {
+  Scalar phiBin = 0.F;
+  Scalar secondLow = 0.F;
+  Scalar secondBin = 0.F;
+  std::uint32_t nPhi = 0U;
+  std::uint32_t nSecond = 0U;
+  std::uint32_t cellOffset = 0U;
+};
+
+/// What a stage reads: per layer its cells, then per cell its sensors.
+struct SensorCellsView {
+  const SensorCellLayer* layers = nullptr;
+  const std::uint32_t* offsets = nullptr;
+  const std::uint32_t* sensors = nullptr;
+
+  /// Every sensor of \a layer listed in a cell that the range \a phi +-
+  /// \a phiReach, \a second +- \a secondReach covers, until \a visit returns
+  /// true; whether one did. A sensor listed in several of those cells is
+  /// visited once per cell.
+  template <typename Visit>
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool anySensor(LayerID layer, Scalar phi, Scalar phiReach, Scalar second, Scalar secondReach, const Visit& visit) const
+  {
+    using Math = o2::gpu::CAMath;
+    const auto& cells = layers[layer];
+    if (cells.nPhi == 0U || cells.nSecond == 0U) {
+      return false;
+    }
+    const auto nPhi = static_cast<int>(cells.nPhi);
+    const auto nSecond = static_cast<int>(cells.nSecond);
+    const int phiFirst = static_cast<int>(Math::Floor((phi - phiReach) / cells.phiBin));
+    // At most every azimuth cell once.
+    const int phiCount = Math::Min(static_cast<int>(Math::Floor((phi + phiReach) / cells.phiBin)) - phiFirst + 1, nPhi);
+    // A range beyond every sensor's footprint meets none; one touching the
+    // outermost footprints' edges, at either end, reads the outermost cells,
+    // which list them.
+    const Scalar secondHigh = cells.secondLow + (static_cast<Scalar>(nSecond) * cells.secondBin);
+    if (second + secondReach < cells.secondLow || second - secondReach > secondHigh) {
+      return false;
+    }
+    const int secondFirst = Math::Min(Math::Max(static_cast<int>(Math::Floor((second - secondReach - cells.secondLow) / cells.secondBin)), 0), nSecond - 1);
+    const int secondLast = Math::Min(Math::Max(static_cast<int>(Math::Floor((second + secondReach - cells.secondLow) / cells.secondBin)), 0), nSecond - 1);
+    for (int s = secondFirst; s <= secondLast; ++s) {
+      for (int i = 0; i < phiCount; ++i) {
+        const int p = (((phiFirst + i) % nPhi) + nPhi) % nPhi;
+        const auto cell = cells.cellOffset + static_cast<std::uint32_t>((s * nPhi) + p);
+        for (auto at = offsets[cell]; at < offsets[cell + 1U]; ++at) {
+          if (visit(sensors[at])) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+};
+
+/// The host's cells of every layer of \a Det, from \a geometry.
+template <DetectorLayout Det>
+class SensorCells
+{
+ public:
+  static constexpr auto kLayers = static_cast<std::size_t>(Detector<Det>::nLayers);
+
+  SensorCells() = default;
+  explicit SensorCells(const TrackingGeometry<Det>& geometry) { build(geometry); }
+
+  [[nodiscard]] SensorCellsView view() const { return {.layers = mLayers.data(), .offsets = mOffsets.data(), .sensors = mSensors.data()}; }
+  [[nodiscard]] const std::vector<SensorCellLayer>& layers() const { return mLayers; }
+  [[nodiscard]] const std::vector<std::uint32_t>& offsets() const { return mOffsets; }
+  [[nodiscard]] const std::vector<std::uint32_t>& sensors() const { return mSensors; }
+  [[nodiscard]] bool empty() const { return mLayers.empty(); }
+
+  /// A surface's footprint: its azimuth range about \a phiCentre, and its
+  /// second coordinate's range.
+  struct Footprint {
+    double phiCentre = 0.;
+    double phiLow = 0.;
+    double phiHigh = 0.;
+    double secondLow = 0.;
+    double secondHigh = 0.;
+  };
+
+  /// The footprint of \a surface, a sensor of a barrel layer when \a barrel.
+  [[nodiscard]] static Footprint footprint(const TrackingSurface& surface, bool barrel)
+  {
+    std::vector<std::array<double, 3>> points;
+    const auto add = [&](const std::array<double, 3>& point) { points.push_back(point); };
+    if (surface.radius > 0.F) {
+      // A curved sensor: its unrolled corners on the cylinder at its
+      // measurement depth, and the middle of each long edge.
+      const auto halfX = static_cast<double>(surface.bounds.halfX);
+      for (const double u : {-halfX, 0., halfX}) {
+        const double angle = u / static_cast<double>(surface.radius);
+        for (const double v : {-static_cast<double>(surface.bounds.halfY), static_cast<double>(surface.bounds.halfY)}) {
+          std::array<double, 3> point{};
+          for (std::size_t i = 0; i < 3; ++i) {
+            const double radial = (std::cos(angle) * static_cast<double>(surface.axis0[i])) + (std::sin(angle) * static_cast<double>(surface.axis1[i]));
+            point[i] = static_cast<double>(surface.origin[i]) + (static_cast<double>(surface.radius + surface.depth) * radial) + (v * static_cast<double>(surface.normal[i]));
+          }
+          add(point);
+        }
+      }
+    } else {
+      const auto at = [&](double u, double v) {
+        std::array<double, 3> point{};
+        for (std::size_t i = 0; i < 3; ++i) {
+          point[i] = static_cast<double>(surface.origin[i]) + (u * static_cast<double>(surface.axis0[i])) + (v * static_cast<double>(surface.axis1[i]));
+        }
+        return point;
+      };
+      const auto halfY = static_cast<double>(surface.bounds.halfY);
+      const std::array<std::array<double, 3>, 4> corners = {at(-static_cast<double>(surface.bounds.halfX), -halfY), at(static_cast<double>(surface.bounds.halfX), -halfY), at(static_cast<double>(surface.bounds.halfX), halfY), at(-static_cast<double>(surface.bounds.halfX), halfY)};
+      for (std::size_t i = 0; i < corners.size(); ++i) {
+        const auto& a = corners[i];
+        const auto& b = corners[(i + 1U) % corners.size()];
+        add(a);
+        // The edge's point nearest the beam axis: the least radius on it.
+        const double dx = b[0] - a[0];
+        const double dy = b[1] - a[1];
+        const double length2 = (dx * dx) + (dy * dy);
+        if (length2 > 0.) {
+          const double t = std::clamp(-((a[0] * dx) + (a[1] * dy)) / length2, 0., 1.);
+          add({a[0] + (t * dx), a[1] + (t * dy), a[2] + (t * (b[2] - a[2]))});
+        }
+      }
+    }
+    std::array<double, 3> centre{};
+    for (const auto& point : points) {
+      for (std::size_t i = 0; i < 3; ++i) {
+        centre[i] += point[i] / static_cast<double>(points.size());
+      }
+    }
+    Footprint result;
+    result.phiCentre = std::atan2(centre[1], centre[0]);
+    result.phiLow = std::numeric_limits<double>::infinity();
+    result.phiHigh = -std::numeric_limits<double>::infinity();
+    result.secondLow = std::numeric_limits<double>::infinity();
+    result.secondHigh = -std::numeric_limits<double>::infinity();
+    for (const auto& point : points) {
+      const double phi = std::remainder(std::atan2(point[1], point[0]) - result.phiCentre, 2 * std::numbers::pi_v<double>);
+      const double second = barrel ? point[2] : std::hypot(point[0], point[1]);
+      result.phiLow = std::min(result.phiLow, phi);
+      result.phiHigh = std::max(result.phiHigh, phi);
+      result.secondLow = std::min(result.secondLow, second);
+      result.secondHigh = std::max(result.secondHigh, second);
+    }
+    return result;
+  }
+
+ private:
+  void build(const TrackingGeometry<Det>& geometry)
+  {
+    const auto& surfaces = geometry.surfaces();
+    std::vector<Footprint> footprints(surfaces.size());
+    for (std::size_t id = 0; id < surfaces.size(); ++id) {
+      footprints[id] = footprint(surfaces[id], Detector<Det>::isBarrelLayer(surfaces[id].layer));
+    }
+    mLayers.assign(kLayers, SensorCellLayer{});
+    std::vector<std::vector<std::uint32_t>> lists;
+    for (std::size_t layer = 0; layer < kLayers; ++layer) {
+      double phiWidth = 2 * std::numbers::pi_v<double>;
+      double secondWidth = std::numeric_limits<double>::infinity();
+      double low = std::numeric_limits<double>::infinity();
+      double high = -std::numeric_limits<double>::infinity();
+      for (std::size_t id = 0; id < surfaces.size(); ++id) {
+        if (surfaces[id].layer != layer) {
+          continue;
+        }
+        const auto& at = footprints[id];
+        phiWidth = std::min(phiWidth, at.phiHigh - at.phiLow);
+        secondWidth = std::min(secondWidth, at.secondHigh - at.secondLow);
+        low = std::min(low, at.secondLow);
+        high = std::max(high, at.secondHigh);
+      }
+      auto& cells = mLayers[layer];
+      cells.cellOffset = static_cast<std::uint32_t>(lists.size());
+      if (!(low <= high) || !(phiWidth > 0.) || !(secondWidth > 0.)) {
+        continue;
+      }
+      cells.nPhi = static_cast<std::uint32_t>(std::max(1., std::floor((2 * std::numbers::pi_v<double>) / phiWidth)));
+      cells.phiBin = static_cast<Scalar>((2 * std::numbers::pi_v<double>) / cells.nPhi);
+      cells.nSecond = static_cast<std::uint32_t>(std::max(1., std::ceil((high - low) / secondWidth)));
+      cells.secondLow = static_cast<Scalar>(low);
+      cells.secondBin = static_cast<Scalar>((high - low) / cells.nSecond);
+      lists.resize(lists.size() + (static_cast<std::size_t>(cells.nPhi) * cells.nSecond));
+      const auto nPhi = static_cast<long>(cells.nPhi);
+      for (std::size_t id = 0; id < surfaces.size(); ++id) {
+        if (surfaces[id].layer != layer) {
+          continue;
+        }
+        const auto& at = footprints[id];
+        // The cells the footprint reaches and one more on each side, so that
+        // a query's float rounding at a cell's edge cannot miss it.
+        const auto phiFirst = static_cast<long>(std::floor((at.phiCentre + at.phiLow) / static_cast<double>(cells.phiBin))) - 1L;
+        const auto phiLast = static_cast<long>(std::floor((at.phiCentre + at.phiHigh) / static_cast<double>(cells.phiBin))) + 1L;
+        const auto bin = [&](double second) { return std::clamp(static_cast<long>(std::floor((second - static_cast<double>(cells.secondLow)) / static_cast<double>(cells.secondBin))), 0L, static_cast<long>(cells.nSecond) - 1L); };
+        for (auto s = std::max(bin(at.secondLow) - 1L, 0L); s <= std::min(bin(at.secondHigh) + 1L, static_cast<long>(cells.nSecond) - 1L); ++s) {
+          for (auto p = phiFirst; p <= std::min(phiLast, phiFirst + nPhi - 1L); ++p) {
+            const auto cell = static_cast<std::size_t>(cells.cellOffset) + static_cast<std::size_t>((s * nPhi) + (((p % nPhi) + nPhi) % nPhi));
+            lists[cell].push_back(static_cast<std::uint32_t>(id));
+          }
+        }
+      }
+    }
+    mOffsets.assign(lists.size() + 1U, 0U);
+    for (std::size_t cell = 0; cell < lists.size(); ++cell) {
+      mOffsets[cell + 1U] = mOffsets[cell] + static_cast<std::uint32_t>(lists[cell].size());
+    }
+    mSensors.clear();
+    mSensors.reserve(mOffsets.back());
+    for (const auto& list : lists) {
+      mSensors.insert(mSensors.end(), list.begin(), list.end());
+    }
+  }
+
+  std::vector<SensorCellLayer> mLayers;
+  std::vector<std::uint32_t> mOffsets;
+  std::vector<std::uint32_t> mSensors;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_SENSORCELLS_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/ShapeCut.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/ShapeCut.h
new file mode 100644
index 0000000000000..e09f1d784568b
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/ShapeCut.h
@@ -0,0 +1,68 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ShapeCut.h
+/// \brief A candidate's line against its measurements' cluster shapes.
+///
+/// A particle crossing a sensor leaves a cluster as long along the columns as
+/// the sensor's depth times its local slope there: the slope of its line
+/// along the columns over its length along the sensor's normal. The
+/// measurement producer turns each cluster's spans into the interval of local
+/// slopes a particle above its detector's calibration floor leaves such a
+/// cluster at (`MeasurementT::slopeLow`, `slopeHigh`; ClusterShapeBand.h):
+/// empty where none does (low infinite, high 0), [0, `kSlopeUnbounded`)
+/// without a shape to go by. An iteration
+/// with `shapeTest` holds every pair and triplet to it at each of its
+/// measurements.
+///
+/// The slope is the barrel's: the normal radial at the measurement, the
+/// columns along z. A calibrated layer is a barrel layer (the producer refuses
+/// others); every other measurement's interval is [0, `kSlopeUnbounded`): no
+/// upper limit short of the largest float.
+
+#ifndef GTRK_TRACKING_SHAPECUT_H_
+#define GTRK_TRACKING_SHAPECUT_H_
+
+#include "GenericTracking/Tracking/Definitions.h"
+
+#include "GPUCommonDef.h"
+#include "GPUCommonMath.h"
+
+namespace o2::gtrk
+{
+
+/// The upper end of a measurement's slope interval without a shape: the
+/// largest float, the sentinel for an interval without an upper limit.
+inline constexpr Scalar kSlopeUnbounded = FLT_MAX;
+
+/// Whether the line along (\a dx, \a dy, \a dz) crosses the measurement at
+/// (\a x, \a y), transverse radius \a r, at a local slope in [\a low,
+/// \a high): |dz| over the line's length along the radial normal there,
+/// compared without the division (a line along the sensor, of no length
+/// along the normal, passes none).
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool slopeAdmits(Scalar low, Scalar high, Scalar x, Scalar y, Scalar r, Scalar dx, Scalar dy, Scalar dz)
+{
+  const Scalar across = o2::gpu::CAMath::Abs((dx * x) + (dy * y)); // the length along the normal, times r
+  const Scalar along = o2::gpu::CAMath::Abs(dz) * r;
+  return along >= low * across && along < high * across;
+}
+
+/// \a slopeAdmits for measurement \a row of \a columns, the line from
+/// (\a fromX, \a fromY, \a fromZ) to (\a toX, \a toY, \a toZ).
+template <typename Columns, typename Row>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool shapeAdmits(const Columns& columns, Row row, Scalar fromX, Scalar fromY, Scalar fromZ, Scalar toX, Scalar toY, Scalar toZ)
+{
+  return slopeAdmits(columns.slopeLow[row], columns.slopeHigh[row], columns.x[row], columns.y[row], columns.r[row], toX - fromX, toY - fromY, toZ - fromZ);
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_SHAPECUT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/SlicePlan.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/SlicePlan.h
new file mode 100644
index 0000000000000..21f3700f95baa
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/SlicePlan.h
@@ -0,0 +1,290 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file SlicePlan.h
+/// \brief A timeframe's slices, planned once on the host from the frame and
+///        the iterations, and run by the host and the device trackers alike.
+///
+/// A slice's gate window and the halo width depend on the measurements'
+/// time variances, not only on the grid offsets; the tracklet stage keeps
+/// them as values. The plan computes them once, with the source maps, the
+/// vertex windows and the extension's per-layer bound, and records what it
+/// was planned from, so that a tracker can refuse a plan of another frame or
+/// configuration.
+
+#ifndef GTRK_TRACKING_SLICEPLAN_H_
+#define GTRK_TRACKING_SLICEPLAN_H_
+
+#include "GenericTracking/Base/LayerLinks.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/LayerRowMap.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/TimeFrameScratch.h"
+#include "GenericTracking/Tracking/TrackletStage.h"
+#include "GenericTracking/Tracking/TripletCut.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <span>
+#include <stdexcept>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+/// Every layer's largest values over a range of rows: the time box's width
+/// the tracklet stage's and the extension's windows and the slices' reach are
+/// bounded with, and the z, r and r-phi variances the triplet stage's
+/// dip-angle window is; and whether every row's box is exactly one of the
+/// layer's readout frames (`FrameTiming::isFrame`), which the slices' reach
+/// reads (`sliceReach`).
+template <DetectorLayout Det>
+struct HaloBounds {
+  static constexpr std::size_t kLayerCount = static_cast<std::size_t>(Detector<Det>::nLayers);
+  std::array<std::uint32_t, kLayerCount> widthPS{};
+  std::array<TripletTargetBounds, kLayerCount> target{};
+  std::array<bool, kLayerCount> rowsAreFrames{};
+};
+
+template <DetectorLayout Det>
+[[nodiscard]] HaloBounds<Det> boundsOver(const TimeFrame<Det>& frame, std::span<const MeasurementRange, HaloBounds<Det>::kLayerCount> rows)
+{
+  HaloBounds<Det> result;
+  const auto columns = frame.measurements();
+  const auto& geometry = frame.grid().geometry();
+  for (std::size_t layer = 0; layer < HaloBounds<Det>::kLayerCount; ++layer) {
+    auto& target = result.target[layer];
+    const auto& frames = geometry.frames(static_cast<LayerID>(layer));
+    result.rowsAreFrames[layer] = true;
+    for (auto row = rows[layer].begin; row < rows[layer].end; ++row) {
+      result.widthPS[layer] = std::max(result.widthPS[layer], columns.widthPS[row]);
+      result.rowsAreFrames[layer] = result.rowsAreFrames[layer] && frames.isFrame({.start = columns.timePS[row], .width = columns.widthPS[row]});
+      target.varZ = std::max(target.varZ, columns.varZ[row]);
+      target.varR = std::max(target.varR, columns.varR[row]);
+      target.varRPhi = std::max(target.varRPhi, columns.varRPhi[row]);
+    }
+  }
+  return result;
+}
+
+/// The bounds over the whole frame: what every slice's stages take, so that
+/// no window depends on the slicing. The dip-angle window is a cut at its
+/// margin, not only a pre-filter, so a bound taken over a slice's halo would
+/// make the candidates depend on which rows the halo held.
+template <DetectorLayout Det>
+[[nodiscard]] HaloBounds<Det> frameBounds(const TimeFrame<Det>& frame)
+{
+  std::array<MeasurementRange, HaloBounds<Det>::kLayerCount> layers{};
+  for (std::size_t layer = 0; layer < layers.size(); ++layer) {
+    layers[layer] = frame.grid().layerRows(static_cast<LayerID>(layer));
+  }
+  return boundsOver(frame, std::span<const MeasurementRange, HaloBounds<Det>::kLayerCount>{layers});
+}
+
+/// How far in time a slice's stages reach past its core, in ps, from each
+/// link's pair reaches: how much later and
+/// how much earlier the box of a pair's target can start than its source's.
+///
+/// Two overlapping boxes `a` (the source) and `b` (the target) have
+/// `b.start - a.start` in `(-width_b, width_a)`: a link reaches its source
+/// layer's widest box forward and its target layer's backward. When the two
+/// layers have readout frames, the same ones, and the rows of both are exactly
+/// those frames, two boxes are equal or disjoint, so a pair lies in one frame
+/// and the link reaches 0 both ways. Pairwise overlap is not transitive once
+/// boxes differ, so a chain drifts by its links' reaches: `R+` and `R-` are
+/// the largest sums of the forward and of the backward reaches along a path
+/// through the links.
+struct SliceReach {
+  std::int64_t pairForwardPS = 0;  ///< the largest link's forward reach
+  std::int64_t pairBackwardPS = 0; ///< the largest link's backward reach
+  std::int64_t forwardPS = 0;      ///< `R+`
+  std::int64_t backwardPS = 0;     ///< `R-`
+
+  /// How far from the core every stage works: `R+ + R-` on both sides. A road
+  /// the core owns starts in it and its measurements start within `R-` before
+  /// and `R+` after its first; the levels on it depend on the chains into its
+  /// measurements, which start within `R+` before and `R-` after them. Within
+  /// the gate everything is built, so the output does not depend on the
+  /// slicing. With the same widths on every link, `2R`.
+  [[nodiscard]] std::int64_t gatePS() const { return forwardPS + backwardPS; }
+
+  /// The time halo a slice needs: the gate, plus one link's reach for the
+  /// targets of the tracklets starting at its edges (the backward one before
+  /// it, the forward one after; the halo is whole blocks, so the larger).
+  [[nodiscard]] std::int64_t haloPS() const { return gatePS() + std::max(pairForwardPS, pairBackwardPS); }
+};
+
+/// The reach of a frame whose rows have \a bounds, on \a geometry's frames.
+template <DetectorLayout Det>
+[[nodiscard]] SliceReach sliceReach(const HaloBounds<Det>& bounds, const GridGeometry<Det>& geometry)
+{
+  const auto sameFrames = [&](const LayerLink& link) {
+    const auto& frames = geometry.frames(link.from);
+    return frames == geometry.frames(link.to) && bounds.rowsAreFrames[link.from] && bounds.rowsAreFrames[link.to];
+  };
+  SliceReach result;
+  std::array<std::int64_t, HaloBounds<Det>::kLayerCount> forwardTo{};
+  std::array<std::int64_t, HaloBounds<Det>::kLayerCount> backwardTo{};
+  for (const auto layer : layerOrder<Det>) {
+    result.forwardPS = std::max(result.forwardPS, forwardTo[layer]);
+    result.backwardPS = std::max(result.backwardPS, backwardTo[layer]);
+    for (auto i = outLinks<Det>.begin(layer); i < outLinks<Det>.end(layer); ++i) {
+      const auto& link = Det::layerLinks[outLinks<Det>.links[i]];
+      const bool zero = sameFrames(link);
+      const std::int64_t forward = zero ? 0 : bounds.widthPS[link.from];
+      const std::int64_t backward = zero ? 0 : bounds.widthPS[link.to];
+      result.pairForwardPS = std::max(result.pairForwardPS, forward);
+      result.pairBackwardPS = std::max(result.pairBackwardPS, backward);
+      forwardTo[link.to] = std::max(forwardTo[link.to], forwardTo[layer] + forward);
+      backwardTo[link.to] = std::max(backwardTo[link.to], backwardTo[layer] + backward);
+    }
+  }
+  return result;
+}
+
+/// One slice of a timeframe: its blocks and rows, its tracklet sources, and
+/// the gate's window of box starts around its core.
+template <DetectorLayout Det>
+struct SlicePlan {
+  static constexpr std::size_t kLayerCount = static_cast<std::size_t>(Detector<Det>::nLayers);
+  using Slice = typename TimeFrame<Det>::TimeSlice;
+
+  Slice slice;
+  LayerRowMap<Det> sources;
+  std::int64_t gateEarliestPS = 0;
+  std::int64_t gateLatestPS = 0;
+
+  /// The tracklet stage's inputs, with the frame's widest candidate boxes per
+  /// layer \a maxCandidateWidthPS (`TimeframePlan::layerMaxWidthPS`) and the
+  /// gate's core ranges pointing into this plan, which must outlive them.
+  [[nodiscard]] TrackletInputs<Det> inputs(const IterationParameters<Det>& parameters, const std::array<std::uint32_t, kLayerCount>& maxCandidateWidthPS) const
+  {
+    return {
+      .parameters = &parameters,
+      .sources = &sources,
+      .targetBlocks = slice.haloBlocks,
+      .maxCandidateWidthPS = maxCandidateWidthPS,
+      .gate = {.core = slice.core.data(), .earliestPS = gateEarliestPS, .latestPS = gateLatestPS},
+      .halo = slice.halo,
+    };
+  }
+};
+
+/// The plan of \a slice, its gate reaching \a gatePS past the core
+/// (`SliceReach::gatePS` of the frame's bounds).
+template <DetectorLayout Det>
+[[nodiscard]] SlicePlan<Det> planSlice(const TimeFrame<Det>& frame, const typename TimeFrame<Det>::TimeSlice& slice, std::int64_t gatePS)
+{
+  SlicePlan<Det> plan{.slice = slice, .sources = TimeFrameScratch<Det>::makeSources(slice.halo)};
+  // The core's box starts, widened by the gate: a halo source beyond it lies
+  // on no chain the core's output depends on. The reach is the frame's rows',
+  // as the halo's; the core's edges are rounded outward to picoseconds.
+  const auto& geometry = frame.grid().geometry();
+  const std::int64_t parts = geometry.partsPerPS();
+  const auto floorDiv = [](std::int64_t a, std::int64_t b) { return (a / b) - ((a % b) < 0 ? 1 : 0); };
+  plan.gateEarliestPS = floorDiv(geometry.blockStart(slice.coreBlocks.begin), parts) - gatePS;
+  plan.gateLatestPS = -floorDiv(-geometry.blockStart(slice.coreBlocks.end), parts) + gatePS;
+  return plan;
+}
+
+/// A timeframe's plan for every iteration of a run -- its slices, the same
+/// for every iteration, and each iteration's vertex windows -- with what it
+/// was planned from.
+template <DetectorLayout Det>
+struct TimeframePlan {
+  static constexpr std::size_t kLayerCount = static_cast<std::size_t>(Detector<Det>::nLayers);
+
+  // What it was planned from.
+  std::uint32_t rows = 0U;
+  std::int32_t blockCount = 0;
+  std::int64_t blockWidth = 0; ///< [parts of a ps]
+  std::vector<IterationParameters<Det>> parameters;
+
+  VertexSeed beamLine;
+  std::vector<VertexSeed> vertices; ///< the timeframe's vertex list, sorted by time
+  /// The widest candidate box per layer, over the whole frame (`frameBounds`).
+  std::array<std::uint32_t, kLayerCount> layerMaxWidthPS{};
+  /// The triplet stage's target bounds, over the whole frame (`frameBounds`).
+  std::array<TripletTargetBounds, kLayerCount> layerTargetBounds{};
+  std::int64_t haloPS = 0;
+  std::vector<SlicePlan<Det>> slices;                     ///< in order
+  std::vector<VertexWindowParameters<Det>> vertexWindows; ///< per iteration
+
+  /// Throw std::invalid_argument unless this plan was planned from \a frame
+  /// -- its rows and grid -- and from \a configured. The parameters compare
+  /// as bytes: every copy of them comes from the same objects by trivial
+  /// copies, padding included.
+  void check(const TimeFrame<Det>& frame, std::span<const IterationParameters<Det>> configured) const
+  {
+    const auto& geometry = frame.grid().geometry();
+    if (rows != frame.size() || blockCount != geometry.blockCount() || blockWidth != geometry.blockWidth()) {
+      throw std::invalid_argument("a timeframe plan of another frame");
+    }
+    if (configured.size() != parameters.size() || vertexWindows.size() != parameters.size()) {
+      throw std::invalid_argument("a timeframe plan of another number of iterations");
+    }
+    for (std::size_t i = 0; i < parameters.size(); ++i) {
+      // Padding included, deliberately: both sides are copies of the same
+      // objects, made by std::copy or assign, which move their bytes as they are.
+      // NOLINTNEXTLINE(bugprone-suspicious-memory-comparison)
+      if (std::memcmp(&configured[i], &parameters[i], sizeof(IterationParameters<Det>)) != 0) {
+        throw std::invalid_argument("a timeframe plan of other iteration parameters");
+      }
+    }
+  }
+};
+
+/// Plan every iteration of \a iterations over \a frame in slices of
+/// \a sliceWidthBlocks grid blocks (`GridGeometry::blocksPerSlice` of the
+/// configured width) with at least \a configuredHaloPS of halo, more when
+/// the frame's reach needs it -- the vertexing pass too, each
+/// slice finding its core's frames' vertices (`OwnedFrames`). \a
+/// windowSettings are the settings each iteration's parameters were derived
+/// from; \a beamLine the seed a beam-line iteration reads; \a vertices the
+/// timeframe's vertex list, sorted by time.
+template <DetectorLayout Det>
+[[nodiscard]] TimeframePlan<Det> planTimeframe(const TimeFrame<Det>& frame, std::span<const IterationParameters<Det>> iterations, std::span<const SearchWindowParams> windowSettings, const VertexSeed& beamLine, std::span<const VertexSeed> vertices, std::int32_t sliceWidthBlocks, std::int64_t configuredHaloPS)
+{
+  if (windowSettings.size() != iterations.size()) {
+    throw std::invalid_argument("planTimeframe needs one window setting per iteration");
+  }
+  TimeframePlan<Det> plan;
+  plan.rows = frame.size();
+  plan.blockCount = frame.grid().geometry().blockCount();
+  plan.blockWidth = frame.grid().geometry().blockWidth();
+  plan.parameters.assign(iterations.begin(), iterations.end());
+  plan.beamLine = beamLine;
+  plan.vertices.assign(vertices.begin(), vertices.end());
+  const auto bounds = frameBounds(frame);
+  plan.layerMaxWidthPS = bounds.widthPS;
+  plan.layerTargetBounds = bounds.target;
+  const auto reach = sliceReach(bounds, frame.grid().geometry());
+  plan.haloPS = std::max(configuredHaloPS, reach.haloPS());
+  const auto width = std::max<std::int32_t>(1, sliceWidthBlocks);
+  for (std::int32_t begin = 0; begin < plan.blockCount; begin += width) {
+    const typename TimeFrame<Det>::TimeSlice slice{frame, {.begin = begin, .end = std::min(plan.blockCount, begin + width)}, plan.haloPS};
+    plan.slices.push_back(planSlice(frame, slice, reach.gatePS()));
+  }
+  plan.vertexWindows.reserve(iterations.size());
+  for (std::size_t iteration = 0; iteration < iterations.size(); ++iteration) {
+    plan.vertexWindows.push_back(vertexWindowParameters<Det>(iterations[iteration], windowSettings[iteration], vertices));
+  }
+  return plan;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_SLICEPLAN_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/StageOutput.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/StageOutput.h
new file mode 100644
index 0000000000000..fcc331a0d4e55
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/StageOutput.h
@@ -0,0 +1,164 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file StageOutput.h
+/// \brief One stage's output in canonical order: generate, scan, place.
+///
+/// A stage runs one element after another in the serial reference; each
+/// element emits a variable number of records of `S`. The canonical output is
+/// what that serial loop produces, in that order: element 0's records, then element 1's, and so
+/// on. Any backend reproduces it with three steps:
+///
+///  - generate: every element emits its records and its count;
+///  - scan: an exclusive scan of the counts gives `offset`, and element `e`
+///    owns `[offset[e], offset[e+1])` of the output;
+///  - place: record `k` of element `e` goes to `offset[e] + k`.
+///
+/// This owns the counts, the offsets and the placed output; each backend
+/// stages its records itself (CpuBackend.h per thread, GpuStage.cuh by
+/// element and ordinal, the tests' serial reference test/SerialReferences.h as a
+/// device does). Nothing here knows what an element is; a stage maps element
+/// ordinals to its own inputs.
+
+#ifndef GTRK_TRACKING_STAGEOUTPUT_H_
+#define GTRK_TRACKING_STAGEOUTPUT_H_
+
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Base/Columns.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <new>
+#include <span>
+#include <utility>
+
+namespace o2::gtrk
+{
+
+/// How a stage run ended. Only kComplete leaves a usable output; everything
+/// else is discarded whole and tells the controller which rung of the overflow
+/// ladder to take.
+enum class StageStatus : std::uint8_t {
+  kComplete,
+  kStagingOverflow, ///< staging was too small; the backend's staged count is the exact size a retry needs
+  kOrdinalOverflow, ///< an element emitted more records than an ordinal can number
+  kIndexOverflow,   ///< the total does not fit the output index type
+  kOutOfMemory,     ///< the bounded pool refused an allocation: the run ends with this status
+};
+
+/// Run \a body, turning a refusal of the bounded pool into kOutOfMemory.
+template <typename Body>
+StageStatus guardOutOfMemory(Body body)
+{
+  try {
+    return body();
+  } catch (const std::bad_alloc&) {
+    return StageStatus::kOutOfMemory;
+  }
+}
+
+template <template <template <class> class> class S>
+class StageOutput
+{
+ public:
+  using Index = std::uint32_t;
+  using Ordinal = std::uint16_t;
+  using Record = S<memlayout::value>;
+  using Columns = BoundedColumns<S>;
+
+  /// The most records one element may emit. The limit is the staged ordinal's
+  /// width and holds on every backend, so that they fail alike.
+  static constexpr std::size_t kMaxPerElement = std::size_t{std::numeric_limits<Ordinal>::max()} + 1U;
+
+  StageOutput() = default;
+  ~StageOutput() = default;
+  StageOutput(const StageOutput&) = delete;
+  StageOutput& operator=(const StageOutput&) = delete;
+  StageOutput(StageOutput&&) = delete;
+  StageOutput& operator=(StageOutput&&) = delete;
+
+  /// Reseat every allocation on \a pool. Call before the first prepare().
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
+  {
+    mMemoryPool = std::move(pool);
+    releaseStorage();
+  }
+
+  /// Size the counts and offsets for \a elements, and clear the result. The
+  /// counts and offsets keep whatever they held: every run writes them whole
+  /// before reading them.
+  void prepare(Index elements)
+  {
+    resizeBoundedVector(mCount, elements);
+    resizeBoundedVector(mOffset, std::size_t{elements} + 1U);
+    clearResult();
+  }
+
+  /// No records; the counts and offsets left as they are, for a run that
+  /// writes them all.
+  void clearResult() noexcept { mSize = 0; }
+
+  /// Release every allocation back to the pool.
+  void clearStorage() noexcept
+  {
+    releaseStorage();
+    mSize = 0;
+  }
+
+  // ---- building blocks for the backends ----
+
+  /// Size the placed output to \a total records, which completes it once
+  /// every record is placed. The columns only grow: rows past \a total are
+  /// kept, so that a run no smaller than an earlier one zeroes nothing it then
+  /// overwrites; grown, they are rebuilt at
+  /// \a total, as the place writes them all. The output is `size()` rows.
+  void resizeOutput(Index total)
+  {
+    if (mOutput.size() < total) {
+      mOutput.resizeRewritten(total);
+    }
+    mSize = total;
+  }
+
+  [[nodiscard]] std::span<Index> counts() { return mCount; }
+  [[nodiscard]] std::span<Index> offsets() { return mOffset; }
+  [[nodiscard]] Columns& output() { return mOutput; }
+
+  // ---- the result ----
+
+  [[nodiscard]] Index elementCount() const { return static_cast<Index>(mCount.size()); }
+  [[nodiscard]] std::span<const Index> counts() const { return mCount; }
+  [[nodiscard]] std::span<const Index> offsets() const { return mOffset; }
+  [[nodiscard]] Index size() const { return mSize; }
+  [[nodiscard]] typename Columns::View view() { return mOutput.view(); }
+  [[nodiscard]] typename Columns::ConstView view() const { return mOutput.view(); }
+
+ private:
+  void releaseStorage() noexcept
+  {
+    auto* resource = mMemoryPool.get();
+    mOutput.setMemoryResource(resource);
+    deepVectorClear(resource, mCount, mOffset);
+  }
+
+  // Pool must outlive allocator-backed members.
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  Columns mOutput;
+  BoundedVector<Index> mCount;
+  BoundedVector<Index> mOffset;
+  Index mSize = 0;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_STAGEOUTPUT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TimeFrame.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TimeFrame.h
new file mode 100644
index 0000000000000..c2af88533334c
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TimeFrame.h
@@ -0,0 +1,103 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TimeFrame.h
+/// \brief Read-only grid-ordered measurements and block-aligned slices.
+
+#ifndef GTRK_TRACKING_TIMEFRAME_H_
+#define GTRK_TRACKING_TIMEFRAME_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/MeasurementGrid.h"
+#include "GenericTracking/Tracking/MeasurementRange.h"
+
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <span>
+
+namespace o2::gtrk
+{
+
+/// The measurement columns and grid offsets belong to the caller -- the DPL
+/// input, a replay's storage or the device tracker's allocations
+/// (DeviceTracker.cuh): the frame borrows both, with the geometry that
+/// interprets their order.
+template <DetectorLayout Det>
+class TimeFrame
+{
+ public:
+  using Index = std::uint32_t;
+  static constexpr std::size_t kLayerCount = static_cast<std::size_t>(Detector<Det>::nLayers);
+
+  /// Core blocks partition the timeframe. Halo blocks may overlap any number
+  /// of slices. The row ranges use global indices into the shared SoA columns.
+  class TimeSlice
+  {
+   public:
+    TimeSlice(const TimeFrame& frame, BlockRange coreRange, std::int64_t haloPS)
+    {
+      assert(coreRange.begin >= 0 && coreRange.begin <= coreRange.end && coreRange.end <= frame.grid().geometry().blockCount() && haloPS >= 0);
+      const auto blocks = frame.grid().geometry().slice(coreRange, haloPS);
+      coreBlocks = blocks.core;
+      haloBlocks = blocks.halo;
+      for (std::size_t layer = 0; layer < kLayerCount; ++layer) {
+        const auto id = static_cast<LayerID>(layer);
+        core[layer] = frame.grid().rows(id, coreBlocks);
+        halo[layer] = frame.grid().rows(id, haloBlocks);
+      }
+    }
+
+    BlockRange coreBlocks{};
+    BlockRange haloBlocks{};
+    std::array<MeasurementRange, kLayerCount> core{};
+    std::array<MeasurementRange, kLayerCount> halo{};
+  };
+
+  /// Requires equal column lengths, `bucketCount() + 1` offsets, monotonic
+  /// offsets and nondecreasing box starts within every bucket, as the
+  /// producer writes them.
+  TimeFrame(MeasurementView measurements, const GridGeometry<Det>& geometry, std::span<const Index> offsets)
+    : TimeFrame(measurements, geometry, offsets, offsets.empty() ? 0U : offsets.back())
+  {
+  }
+
+  /// The same frame over columns and offsets the host cannot read -- a
+  /// device copy -- given the row count, which the other constructor reads
+  /// from the last offset. Nothing here dereferences them; slices are cut
+  /// from the host frame.
+  TimeFrame(MeasurementView measurements, const GridGeometry<Det>& geometry, std::span<const Index> offsets, Index rows)
+    : mGrid(measurements, geometry, offsets),
+      mSize(rows)
+  {
+  }
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Index size() const { return mSize; }
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() auto measurement(Index index) const
+  {
+    assert(index < size());
+    return measurements()[index];
+  }
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() const MeasurementGrid<Det>& grid() const { return mGrid; }
+  /// The columns the frame borrows.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() MeasurementView measurements() const { return mGrid.measurements(); }
+
+ private:
+  MeasurementGrid<Det> mGrid;
+  Index mSize = 0;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TIMEFRAME_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TimeFrameScratch.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TimeFrameScratch.h
new file mode 100644
index 0000000000000..1c83062438153
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TimeFrameScratch.h
@@ -0,0 +1,141 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TimeFrameScratch.h
+/// \brief The host tracker's stage storage, reused across its slices and iterations.
+///
+/// Storage only: the host stages run on CpuBackend.h; the device tracker
+/// keeps its own (DeviceTracker.cuh). For the tracklet stage it
+/// holds the numbering of the slice's source rows and the stage's canonical
+/// output; then the triplets and their neighbours.
+/// The used-cluster mask lives for the timeframe and is deliberately not here.
+
+#ifndef GTRK_TRACKING_TIMEFRAMESCRATCH_H_
+#define GTRK_TRACKING_TIMEFRAMESCRATCH_H_
+
+#include "GenericTracking/Base/LayerLinks.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Tracking/LayerRowMap.h"
+#include "GenericTracking/Tracking/MeasurementRange.h"
+#include "GenericTracking/Tracking/Neighbour.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/Triplet.h"
+#include "GenericTracking/Tracking/TrackletPaths.h"
+#include "GenericTracking/Tracking/TripletEndIndex.h"
+#include "GenericTracking/Tracking/TripletPaths.h"
+#include "GenericTracking/Tracking/TripletPermutation.h"
+
+#include <array>
+#include <cstddef>
+#include <memory>
+#include <span>
+
+namespace o2::gtrk
+{
+
+template <DetectorLayout Det>
+class TimeFrameScratch
+{
+ public:
+  using Sources = LayerRowMap<Det>;
+  using Tracklets = StageOutput<TrackletT>;
+  using Triplets = StageOutput<TripletT>;
+  using Neighbours = StageOutput<NeighbourT>;
+  using Permutation = TripletPermutation<Det>;
+  static constexpr std::size_t kLayerCount = Sources::kLayerCount;
+
+  /// The layers a tracklet can start on: those with an outgoing link.
+  static constexpr std::array<bool, kLayerCount> kSourceLayers = [] {
+    std::array<bool, kLayerCount> presented{};
+    for (std::size_t layer = 0; layer < kLayerCount; ++layer) {
+      presented[layer] = outLinks<Det>.count(static_cast<LayerID>(layer)) != 0U;
+    }
+    return presented;
+  }();
+
+  TimeFrameScratch() = default;
+  ~TimeFrameScratch() = default;
+  TimeFrameScratch(const TimeFrameScratch&) = delete;
+  TimeFrameScratch& operator=(const TimeFrameScratch&) = delete;
+  TimeFrameScratch(TimeFrameScratch&&) = delete;
+  TimeFrameScratch& operator=(TimeFrameScratch&&) = delete;
+
+  void setMemoryPool(const std::shared_ptr<BoundedMemoryResource>& pool)
+  {
+    mTracklets.setMemoryPool(pool);
+    mTriplets.setMemoryPool(pool);
+    mTrackletPaths.setMemoryPool(pool);
+    mPermutation.setMemoryPool(pool);
+    mEnding.setMemoryPool(pool);
+    mTripletPaths.setMemoryPool(pool);
+    mNeighbours.setMemoryPool(pool);
+  }
+
+  /// Build the tracklet source map: every source layer's halo rows. Chains
+  /// the output depends on reach into the halo on every layer; the tracklet
+  /// stage's gate skips the rows beyond them.
+  [[nodiscard]] static Sources makeSources(std::span<const MeasurementRange, kLayerCount> halo) { return Sources{halo, kSourceLayers}; }
+
+  /// Take the slice's numbered source rows, `makeSources` of its halo, and
+  /// size the tracklet output for them.
+  void beginSlice(const Sources& sources)
+  {
+    mSources = sources;
+    mTracklets.prepare(mSources.size());
+  }
+
+  /// Release every allocation back to the pool.
+  void clearStorage() noexcept
+  {
+    mTracklets.clearStorage();
+    mTriplets.clearStorage();
+    mTrackletPaths.clearStorage();
+    mPermutation.clearStorage();
+    mEnding.clearStorage();
+    mTripletPaths.clearStorage();
+    mNeighbours.clearStorage();
+    mSources = Sources{};
+  }
+
+  [[nodiscard]] const Sources& sources() const { return mSources; }
+  [[nodiscard]] Tracklets& tracklets() { return mTracklets; }
+  [[nodiscard]] const Tracklets& tracklets() const { return mTracklets; }
+  /// The longest tracklet paths through each measurement, which the
+  /// permutation and the triplet stage read.
+  [[nodiscard]] TrackletPaths<Det>& trackletPaths() { return mTrackletPaths; }
+  /// The first tracklets the triplet stage works on, in its order.
+  [[nodiscard]] Permutation& permutation() { return mPermutation; }
+  [[nodiscard]] Triplets& triplets() { return mTriplets; }
+  [[nodiscard]] const Triplets& triplets() const { return mTriplets; }
+  /// The triplets ending with each tracklet: the neighbour stage's candidates.
+  [[nodiscard]] TripletEndIndex& ending() { return mEnding; }
+  /// The longest triplet paths through each tracklet, which the neighbour
+  /// stage reads.
+  [[nodiscard]] TripletPaths<Det>& tripletPaths() { return mTripletPaths; }
+  [[nodiscard]] Neighbours& neighbours() { return mNeighbours; }
+  [[nodiscard]] const Neighbours& neighbours() const { return mNeighbours; }
+
+ private:
+  Sources mSources;
+  Tracklets mTracklets;
+  TrackletPaths<Det> mTrackletPaths;
+  Permutation mPermutation;
+  Triplets mTriplets;
+  TripletEndIndex mEnding;
+  TripletPaths<Det> mTripletPaths;
+  Neighbours mNeighbours;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TIMEFRAMESCRATCH_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackFitter.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackFitter.h
new file mode 100644
index 0000000000000..d9e5446e389d5
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackFitter.h
@@ -0,0 +1,571 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackFitter.h
+/// \brief Independent outward and inward Kalman filters over a chain, each step linearised about its filtered state.
+
+#ifndef GTRK_TRACKING_TRACKFITTER_H_
+#define GTRK_TRACKING_TRACKFITTER_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/CovarianceTransport.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/Material.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/MeasurementUpdate.h"
+#include "GenericTracking/Tracking/Seed.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tracking/WorkCounters.h"
+
+#include "GPUCommonMath.h"
+
+#include <cstdint>
+
+namespace o2::gtrk
+{
+
+/// How many steps of a filter pass may be kinks: a
+/// step whose spatial increment is beyond \a gate, with a measurement after
+/// it in the pass, is taken again from the surface before with the track's
+/// direction freed -- a break point, two degrees of freedom. None by default.
+/// The last step, with nothing after it to check a freed direction, never
+/// is; the road fit's takes the kink allowance there instead
+/// (`fitOutward`'s LastStepAllowance).
+struct KinkBudget {
+  int max = 0;
+  Scalar gate = 0.F; ///< `chiSquareQuantile(2, nSigma)`
+};
+
+/// An iteration's kink budget, from its parameters' `maxKinks` and
+/// `kinkChi2Min`: the refit's and the extension's.
+template <typename Parameters>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() KinkBudget kinkBudget(const Parameters& parameters)
+{
+  return KinkBudget{.max = static_cast<int>(parameters.maxKinks), .gate = parameters.kinkChi2Min};
+}
+
+/// Whether an iteration's road fit takes its kink allowance on the last step
+/// (`fitOutward`'s LastStepAllowance, against the road-end fakes): every iteration with an allowance. The one rule the host's and the
+/// device's road-fit stages are instantiated by and `fitRoad` follows.
+template <typename Parameters>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool takesLastStepAllowance(const Parameters& parameters)
+{
+  return parameters.kinkScale2 > 1.F;
+}
+
+/// Result of the two independent filter passes.
+///
+/// `state` is the inward result on the innermost measurement surface. The
+/// outward state is the starting point for extension; its chi2 remains
+/// available for QA.
+struct TrackFitResult {
+  BoundTrackState state{};
+  BoundTrackState outwardState{};
+  Scalar chi2 = 0.F;
+  Scalar outwardChi2 = 0.F;
+  /// Two coordinates per measurement against the five parameters, two fewer
+  /// per kink.
+  std::int16_t ndf = 0;
+  /// kOk, or what the failed step's propagation gave (`failedPass`,
+  /// `failedMeasurement` say where).
+  PropagationStatus status = PropagationStatus::kOk;
+  FitPass failedPass = FitPass::kNone;
+  /// The measurement the failed step was propagating to.
+  std::int16_t failedMeasurement = -1;
+  /// The kinks each pass took. `ndf` is the inward pass's, two fewer per
+  /// kink; the outward pass has `2 N - 5 - 2 outwardKinks`.
+  std::uint8_t kinks = 0;
+  std::uint8_t outwardKinks = 0;
+  /// The measurement the inward pass's last kink updated with; -1 without.
+  std::int16_t kinkMeasurement = -1;
+};
+
+/// A fit's per-measurement chi2 increments, for QA: called once per update
+/// with the pass's direction, the measurement's index in the chain and its
+/// increment (two dof). The default does nothing.
+struct NoFitObserver {
+  GPUhdi() GPUAlwaysInline() void operator()(PropagationDirection /*direction*/, int /*index*/, Scalar /*chi2*/) const {}
+};
+
+/// The mass a fit step's energy loss takes: the propagator's hypothesis,
+/// the one its scattering takes. A QA oracle's propagator type overloads it
+/// to set the two apart (SpeciesOracle.h).
+GPUhdi() GPUAlwaysInline() Scalar lossMassGeV(const Propagator& prop) { return prop.massGeV; }
+
+namespace detail
+{
+
+/// A step's material in two halves about its midpoint, and its `rho * length`
+/// for the energy loss.
+///
+/// The Highland noise of the half nearer the surface the step leaves goes into
+/// the covariance *before* the transport, so that its kink becomes position
+/// spread at the next surface through `F Q F^T`; the other half's goes in
+/// after it, before the update. Added after the transport, all of it, every
+/// prediction would miss `theta0^2 L^2` of the material near the start and the
+/// outward state would carry one step's unconsumed `theta0^2` in its direction.
+/// With a layer's material
+/// attributed from half-gap to half-gap, the two halves are the stave just
+/// left and the stave about to be reached.
+struct StepMaterial {
+  Scalar nearerX2X0 = 0.F;  ///< x/X0 from the start to the midpoint
+  Scalar fartherX2X0 = 0.F; ///< x/X0 from the midpoint to the end
+  Scalar xRho = 0.F;        ///< [g/cm^2] over the whole step
+};
+
+template <typename Material>
+GPUdi() StepMaterial stepMaterial(const Material& material, const Scalar start[3], const Scalar end[3])
+{
+  const Scalar mid[3] = {0.5F * (start[0] + end[0]), 0.5F * (start[1] + end[1]), 0.5F * (start[2] + end[2])};
+  const auto nearer = material.getMatBudget(start[0], start[1], start[2], mid[0], mid[1], mid[2]);
+  const auto farther = material.getMatBudget(mid[0], mid[1], mid[2], end[0], end[1], end[2]);
+  return {.nearerX2X0 = nearer.meanX2X0, .fartherX2X0 = farther.meanX2X0, .xRho = (nearer.meanRho * nearer.length) + (farther.meanRho * farther.length)};
+}
+
+/// The mass hypothesis's energy loss over a step's \a xRho [g/cm^2], O2's
+/// way: taken at \a state's momentum and applied to it, the straggling's q/p
+/// variance returned in \a varQOverP for the step's noise (StepNoise). Lost
+/// along the momentum, regained against it. False if the particle stopped.
+/// The mass is `lossMassGeV(prop)`, the propagator's hypothesis.
+template <typename Prop>
+GPUhdi() GPUAlwaysInline() bool applyEnergyLoss(const Prop& prop, Scalar xRho, PropagationDirection direction, BoundTrackState& state, Scalar& varQOverP)
+{
+  varQOverP = 0.F;
+  const auto loss = energyLoss(state.qOverP(), lossMassGeV(prop), direction == PropagationDirection::kForward ? -xRho : xRho);
+  if (!loss.ok) {
+    return false;
+  }
+  state.par[kQOverP] *= loss.momentumScale;
+  varQOverP = loss.varQOverP;
+  return true;
+}
+
+/// \a theta0 times \a scale with \a Scaled, \a theta0 alone without: the
+/// nominal step never multiplies.
+template <bool Scaled>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar scaledTheta0(Scalar theta0, [[maybe_unused]] Scalar scale)
+{
+  if constexpr (Scaled) {
+    return scale * theta0;
+  } else {
+    return theta0;
+  }
+}
+
+/// A step's second half, once \a state is on the plane the step reaches and
+/// \a jacobian carries the covariance there: the farther half's scattering
+/// of \a step at the direction \a state arrives with, the energy loss over
+/// \a step at its momentum, and the covariance \a factors transported
+/// with \a before, the nearer half's noise, and the farther half's
+/// (StepMaterial). With \a Scaled, \a noiseScale multiplies the farther
+/// half's theta0 (`scaledTheta0`). The fit's step (`filterStep`) and the
+/// follow's (`transportCandidate`) both end so; each takes the nearer half's
+/// noise before its propagation.
+template <bool Scaled, typename Prop>
+GPUdi() PropagationStatus transportStep(const Prop& prop, const StepMaterial& step, Scalar betaP, const ScatteringNoise& before, PropagationDirection direction, const SolenoidJacobian& jacobian, BoundTrackState& state, CovarianceFactors& factors, Scalar noiseScale)
+{
+  const auto after = scatteringNoise(scaledTheta0<Scaled>(highlandTheta0(step.fartherX2X0, betaP), noiseScale), state.theta());
+  StepNoise noise{.phiBefore = before.phi, .thetaBefore = before.theta, .phiAfter = after.phi, .thetaAfter = after.theta};
+  if (!applyEnergyLoss(prop, step.xRho, direction, state, noise.qOverPAfter)) {
+    return PropagationStatus::kStopped;
+  }
+  if (!transportFactors(jacobian, noise, factors)) {
+    return PropagationStatus::kNotFinite;
+  }
+  return PropagationStatus::kOk;
+}
+
+/// One step of a filter pass: \a state carried to \a measurement's plane
+/// and updated with it, linearised about itself -- the filtered state the step
+/// starts from, as ACTS's Kalman filter (a fixed whole-chain reference, never
+/// corrected by the measurements, falls short of the outer planes of a low-momentum track near
+/// its turning point). The covariance is \a factors, the pass's
+/// (CovarianceFactors): `state.cov` is neither read nor written. \a Scaled,
+/// the step's scattering theta0 is multiplied by \a noiseScale, both halves:
+/// the kink allowance's last step (`allowanceStep`); the nominal step is its
+/// own instantiation. \a Rule is the propagation's choice of crossing
+/// (`CrossingRule`), and with it every pass below. Never inlined on the
+/// device: one copy for each instantiation, not one in every fit of every
+/// stage variant.
+template <bool Scaled = false, CrossingRule Rule = CrossingRule::kFirstAhead, DetectorLayout Det, typename Material, typename Prop>
+GPUdnii() PropagationStatus filterStep(const Prop& prop, const TrackingGeometry<Det>& geometry, const Material& material, const Measurement& measurement, PropagationDirection direction, BoundTrackState& state, CovarianceFactors& factors, Scalar& chi2, [[maybe_unused]] Scalar noiseScale = 1.F)
+{
+  const auto& from = geometry.planeOf(state);
+  const auto& to = geometry.planeOf(measurement);
+
+  Scalar start[3]{};
+  surfaceToGlobal(from, state.loc0(), state.loc1(), start);
+  const Scalar leaving = state.theta();
+  // An intersection just outside the sensor's active area is still the point
+  // to update at: the cluster is there, so the track was. Bounds are for
+  // searches, not fits (`jacobianAnalytic` takes kOutOfBounds).
+  SolenoidJacobian jacobian;
+  const auto jacobianStatus = jacobianAnalytic<Scalar, Rule>(prop, state, from, to, direction, jacobian, &state);
+  if (jacobianStatus != PropagationStatus::kOk) {
+    return jacobianStatus;
+  }
+
+  Scalar end[3]{};
+  surfaceToGlobal(to, state.loc0(), state.loc1(), end);
+
+  const auto step = stepMaterial(material, start, end);
+  const Scalar momentum = 1.F / o2::gpu::GPUCommonMath::Abs(state.qOverP());
+  const Scalar betaP = betaMomentum(momentum, prop.massGeV);
+  // The nearer half before the transport (StepMaterial), at the direction on
+  // the surface the step leaves; the farther half after it.
+  const auto before = scatteringNoise(scaledTheta0<Scaled>(highlandTheta0(step.nearerX2X0, betaP), noiseScale), leaving);
+  const auto transported = transportStep<Scaled>(prop, step, betaP, before, direction, jacobian, state, factors, noiseScale);
+  if (transported != PropagationStatus::kOk) {
+    return transported;
+  }
+
+  const auto update = updateWithMeasurement(state, factors, measurement);
+  if (!updateUsable(update, factors)) {
+    return PropagationStatus::kNotFinite;
+  }
+  chi2 += update.chi2;
+  return PropagationStatus::kOk;
+}
+
+/// \a budget for a pass over \a n measurements: no more kinks than leave the
+/// fit a degree of freedom, `2 n - 5 - 2 k >= 1`, so `n - 3` -- one for four
+/// measurements, two for five. Each kink frees the direction, two parameters;
+/// beyond that the chain no longer constrains the track, and the chi2 cut by
+/// degrees of freedom has no entry for it.
+GPUhdi() GPUAlwaysInline() KinkBudget kinkBudgetFor(KinkBudget budget, int n)
+{
+  const int allowed = ((2 * n) - kNBoundParams - 1) / 2;
+  if (budget.max > allowed) {
+    budget.max = allowed > 0 ? allowed : 0;
+  }
+  return budget;
+}
+
+/// `freeDirection` on a pass's factors: the covariance formed, its direction
+/// freed, factored again. A kink takes it once; the direction it frees is
+/// what made the covariance hard to hold, so the factoring loses nothing.
+GPUhdi() GPUAlwaysInline() void freeDirection(BoundTrackState& state, CovarianceFactors& factors)
+{
+  covarianceFromFactors(factors, state.cov);
+  o2::gtrk::freeDirection(state);
+  factors = factorCovariance(state.cov);
+}
+
+/// A filter step that may be a kink: taken as `filterStep`; if kinks are left,
+/// \a followed -- a measurement comes after this one in the pass -- and its
+/// increment is beyond the gate, taken again from the surface before with the
+/// direction freed, and counted in \a kinks.
+template <CrossingRule Rule = CrossingRule::kFirstAhead, DetectorLayout Det, typename Material, typename Prop>
+GPUdi() PropagationStatus kinkStep(const Prop& prop, const TrackingGeometry<Det>& geometry, const Material& material, const Measurement& measurement, PropagationDirection direction, BoundTrackState& state, CovarianceFactors& factors, Scalar& chi2, const KinkBudget& budget, bool followed, int& kinks)
+{
+  if (kinks >= budget.max || !followed) {
+    return filterStep<false, Rule>(prop, geometry, material, measurement, direction, state, factors, chi2);
+  }
+  const BoundTrackState keptState = state;
+  const CovarianceFactors keptFactors = factors;
+  const Scalar keptChi2 = chi2;
+  auto status = filterStep<false, Rule>(prop, geometry, material, measurement, direction, state, factors, chi2);
+  if (status != PropagationStatus::kOk || !(chi2 - keptChi2 > budget.gate)) {
+    return status;
+  }
+  state = keptState;
+  factors = keptFactors;
+  chi2 = keptChi2;
+  freeDirection(state, factors);
+  status = filterStep<false, Rule>(prop, geometry, material, measurement, direction, state, factors, chi2);
+  kinks += status == PropagationStatus::kOk ? 1 : 0;
+  return status;
+}
+
+/// The road fit's last step with the kink allowance (`fitOutward`'s
+/// LastStepAllowance, against the road-end fakes): taken as
+/// `filterStep`; if kinks are left and its increment is beyond the gate,
+/// taken again from the surface before with its scattering's theta0 scaled by
+/// \a noiseScale, as the extension's kink step, and counted in \a kinks;
+/// \a refused if the increment is still beyond the gate. It frees no
+/// parameter.
+template <CrossingRule Rule = CrossingRule::kFirstAhead, DetectorLayout Det, typename Material>
+GPUdi() PropagationStatus allowanceStep(const Propagator& prop, const TrackingGeometry<Det>& geometry, const Material& material, const Measurement& measurement, PropagationDirection direction, BoundTrackState& state, CovarianceFactors& factors, Scalar& chi2, const KinkBudget& budget, Scalar noiseScale, int& kinks, bool& refused)
+{
+  refused = false;
+  if (kinks >= budget.max) {
+    return filterStep<false, Rule>(prop, geometry, material, measurement, direction, state, factors, chi2);
+  }
+  const BoundTrackState keptState = state;
+  const CovarianceFactors keptFactors = factors;
+  const Scalar keptChi2 = chi2;
+  auto status = filterStep<false, Rule>(prop, geometry, material, measurement, direction, state, factors, chi2);
+  if (status != PropagationStatus::kOk || !(chi2 - keptChi2 > budget.gate)) {
+    return status;
+  }
+  state = keptState;
+  factors = keptFactors;
+  chi2 = keptChi2;
+  status = filterStep<true, Rule>(prop, geometry, material, measurement, direction, state, factors, chi2, noiseScale);
+  if (status == PropagationStatus::kOk) {
+    ++kinks;
+    refused = !(chi2 - keptChi2 <= budget.gate);
+  }
+  return status;
+}
+
+/// A pass's start on its first measurement: the
+/// limit of its update under a position prior infinitely wide. The position
+/// becomes the measurement's, with the measurement's covariance and none with
+/// the other parameters, which keep the seed's prior. The seed's position is
+/// not a prior the measurement could be tested against: the measurement
+/// determines the position, its chi2 is zero, and the pass's `2 N - 5`
+/// degrees of freedom already count it. As
+/// `updateWithMeasurement`, with the factors of \a state's covariance.
+GPUhdi() GPUAlwaysInline() MeasurementUpdateResult startOnMeasurement(BoundTrackState& state, CovarianceFactors& factors, const Measurement& measurement)
+{
+  MeasurementUpdateResult result;
+  state.decorrelate(kLoc0, kLoc1);
+  state.par[kLoc0] = measurement.loc0;
+  state.par[kLoc1] = measurement.loc1;
+  state.variance(kLoc0) = measurement.varLoc0;
+  state.variance(kLoc1) = measurement.varLoc1;
+  state.covAt(kLoc0, kLoc1) = measurement.covLoc01;
+  factors = factorCovariance(state.cov);
+  // Positive definite as the update's innovations would be: the measurement's
+  // two whitened variances (`updateWithMeasurement`).
+  result.positiveDefinite = measurement.varLoc0 > 0.F && measurement.varLoc1 - (measurement.covLoc01 * measurement.covLoc01 / measurement.varLoc0) > 0.F;
+  return result;
+}
+
+/// A filter pass from \a seed over the chain. Its covariance is carried as
+/// factors from the first update to the last (CovarianceFactors) and written
+/// to \a result's `cov` once, at the end.
+template <CrossingRule Rule = CrossingRule::kFirstAhead, typename Prop, DetectorLayout Det, typename Material, typename Chain, typename Observer>
+GPUdi() PropagationStatus runPass(const Prop& prop, const TrackingGeometry<Det>& geometry, const Material& material, const Chain& measurements, int n, PropagationDirection direction, BoundTrackState seed, BoundTrackState& result, Scalar& chi2, std::int16_t& failedMeasurement, const KinkBudget& passBudget, int& kinks, std::int16_t& kinkMeasurement, const Observer& observe)
+{
+  const auto budget = kinkBudgetFor(passBudget, n);
+  const int first = direction == PropagationDirection::kForward ? 0 : n - 1;
+  const int increment = direction == PropagationDirection::kForward ? 1 : -1;
+
+  BoundTrackState state = seed;
+  CovarianceFactors factors;
+  const auto firstUpdate = startOnMeasurement(state, factors, measurements[first]);
+  if (!updateUsable(firstUpdate, factors)) {
+    failedMeasurement = static_cast<std::int16_t>(first);
+    return PropagationStatus::kNotFinite;
+  }
+  chi2 = firstUpdate.chi2;
+  observe(direction, first, chi2);
+  for (int step = 1; step < n; ++step) {
+    const int index = first + step * increment;
+    const Scalar before = chi2;
+    const int kinksBefore = kinks;
+    const auto& stepProp = stepPropagator(prop, geometry, measurements, index - increment, index);
+    const auto status = kinkStep<Rule>(stepProp, geometry, material, measurements[index], direction, state, factors, chi2, budget, step < n - 1, kinks);
+    if (status != PropagationStatus::kOk) {
+      failedMeasurement = static_cast<std::int16_t>(index);
+      return status;
+    }
+    if (kinks != kinksBefore) {
+      kinkMeasurement = static_cast<std::int16_t>(index);
+    }
+    observe(direction, index, chi2 - before);
+  }
+  covarianceFromFactors(factors, state.cov);
+  result = state;
+  return PropagationStatus::kOk;
+}
+
+/// The inward pass of `fitMeasurements`: its seed, the outward pass's end
+/// state with a diffuse covariance, then the filter from there in.
+template <CrossingRule Rule = CrossingRule::kFirstAhead, typename Prop, DetectorLayout Det, typename Material, typename Chain, typename Observer>
+GPUdi() void inwardPass(const Prop& prop, const TrackingGeometry<Det>& geometry, const Material& material, const Chain& measurements, int n, Scalar qOverPSigma, const KinkBudget& kinkBudget, const Observer& observe, TrackFitResult& fit)
+{
+  // From the outward pass's end state, its covariance made diffuse with the
+  // chain's q/p width, as ACTS's reverse filter starts from the forward
+  // one's: the whole-chain helix carried there unfitted misses
+  // the outermost rows at low momentum.
+  BoundTrackState outerSeed = fit.outwardState;
+  setDiffuseCovariance(outerSeed, qOverPSigma);
+
+  int kinks = 0;
+  const auto status = runPass<Rule>(prop, geometry, material, measurements, n, PropagationDirection::kBackward, outerSeed, fit.state, fit.chi2, fit.failedMeasurement, kinkBudget, kinks, fit.kinkMeasurement, observe);
+  if (status != PropagationStatus::kOk) {
+    fit.status = status;
+    fit.failedPass = FitPass::kInward;
+    return;
+  }
+  fit.kinks = static_cast<std::uint8_t>(kinks);
+  fit.ndf = static_cast<std::int16_t>(fit.ndf - (2 * kinks));
+}
+
+} // namespace detail
+
+/// Fit an ordered chain containing one measurement per logical layer.
+///
+/// The outward filter starts on the first surface from a helix fitted
+/// through every measurement of the chain (`makeChainSeed`) with a
+/// diffuse covariance; the inward one on the last from the outward filter's
+/// end state, its covariance made diffuse again, as ACTS's reverse filter.
+/// Each step linearises about the filtered state it starts from
+/// (`filterStep`). The inward filter does not inherit the outward
+/// covariance, so no measurement's weight is counted twice in the returned
+/// state.
+///
+/// The measurements' times are boxes, which the fit does not take: the
+/// track's time is their intersection, set by the refit (TrackRefit.h).
+///
+/// \a measurements is anything indexed by `[i]` giving a `Measurement`, as
+/// for `makeChainSeed`. Each pass may take \a kinkBudget's kinks. \a observe
+/// sees every update's chi2 increments (`NoFitObserver`).
+template <CrossingRule Rule = CrossingRule::kFirstAhead, typename Prop, DetectorLayout Det, typename Material, typename Chain, typename Observer = NoFitObserver>
+GPUdi() TrackFitResult fitMeasurements(const Prop& prop, const TrackingGeometry<Det>& geometry, const Material& material, const Chain& measurements, int n, const KinkBudget& kinkBudget = {}, const Observer& observe = {})
+{
+  TrackFitResult fit{.ndf = static_cast<std::int16_t>((2 * n) - kNBoundParams)};
+  const auto seed = makeChainSeed(prop, geometry, measurements, n);
+
+  int outwardKinks = 0;
+  std::int16_t outwardKinkMeasurement = -1;
+  auto status = detail::runPass<Rule>(prop, geometry, material, measurements, n, PropagationDirection::kForward, seed.state, fit.outwardState, fit.outwardChi2, fit.failedMeasurement, kinkBudget, outwardKinks, outwardKinkMeasurement, observe);
+  fit.outwardKinks = static_cast<std::uint8_t>(outwardKinks);
+  if (status != PropagationStatus::kOk) {
+    fit.status = status;
+    fit.failedPass = FitPass::kOutward;
+    return fit;
+  }
+  detail::inwardPass<Rule>(prop, geometry, material, measurements, n, seed.qOverPSigma, kinkBudget, observe, fit);
+  return fit;
+}
+
+/// `fitMeasurements` given its outward pass's end state, \a outwardState
+/// -- as the road fit keeps it for an accepted
+/// road (`RoadFitResult::state`): only the inward pass runs. The outward
+/// pass's chi2 and kinks are not known here and stay zero.
+template <CrossingRule Rule = CrossingRule::kFirstAhead, typename Prop, DetectorLayout Det, typename Material, typename Chain, typename Observer = NoFitObserver>
+GPUdi() TrackFitResult fitInward(const Prop& prop, const TrackingGeometry<Det>& geometry, const Material& material, const Chain& measurements, int n, const BoundTrackState& outwardState, const KinkBudget& kinkBudget = {}, const Observer& observe = {})
+{
+  TrackFitResult fit{.ndf = static_cast<std::int16_t>((2 * n) - kNBoundParams)};
+  const auto seed = makeChainSeed(prop, geometry, measurements, n);
+  fit.outwardState = outwardState;
+  detail::inwardPass<Rule>(prop, geometry, material, measurements, n, seed.qOverPSigma, kinkBudget, observe, fit);
+  return fit;
+}
+
+/// The road fit's candidate pass: the outward filter
+/// alone, as in `fitMeasurements`.
+struct RoadFitResult {
+  Scalar chi2 = 0.F;
+  RoadFitStatus status = RoadFitStatus::kAccepted;
+  std::uint8_t kinks = 0;
+  /// The outward pass's state at the outermost measurement: the pT floor
+  /// reads it, and `fitMeasurements`' outward pass ends on it, so the refit
+  /// of the road takes it instead of running that pass again.
+  BoundTrackState state;
+};
+
+/// Its chi2 is the whole road's; the inward pass only gives the state on the
+/// innermost surface, which the refit of an accepted track provides. The cut
+/// is \a chi2MaxByNdf read at the road's degrees of freedom, `2 N - 5` less
+/// two per kink. A filter's chi2 only grows as measurements are added, and the
+/// cut only falls as kinks are taken, so the pass stops as soon as the chi2
+/// exceeds the cut so far: the decision the complete pass would reach.
+///
+/// With \a LastStepAllowance, for an iteration with a kink allowance, the
+/// last step is `allowanceStep` with the allowance's theta0 factor
+/// \a lastStepScale (against the road-end fakes): refused
+/// beyond the gate, it frees no degree of freedom, and the result's kinks
+/// count it. A compile-time choice: without it the last step is a `kinkStep`
+/// like the others.
+template <bool LastStepAllowance = false, CrossingRule Rule = CrossingRule::kFirstAhead, typename Prop, DetectorLayout Det, typename Material, typename Chain>
+GPUdi() RoadFitResult fitOutward(const Prop& prop, const TrackingGeometry<Det>& geometry, const Material& material, const Chain& measurements, int n, const Scalar* chi2MaxByNdf, const KinkBudget& kinkBudget = {}, [[maybe_unused]] Scalar lastStepScale = 1.F)
+{
+  const auto budget = detail::kinkBudgetFor(kinkBudget, n);
+  BoundTrackState state = makeChainSeed(prop, geometry, measurements, n).state;
+  CovarianceFactors factors;
+  RoadFitResult result;
+  // The start and the sum as `runPass` keeps them, so that the kink gate,
+  // which reads its increments, rounds as in the refit's outward pass.
+  const auto firstUpdate = detail::startOnMeasurement(state, factors, measurements[0]);
+  if (!updateUsable(firstUpdate, factors)) {
+    // Not a measurement of this road (a negative or NaN chi2 would pass the
+    // cut below and rank first): counted with the propagation failures.
+    countWork(WorkCounter::kRoadPropagation);
+    result.status = RoadFitStatus::kPropagationFailed;
+    return result;
+  }
+  result.chi2 = firstUpdate.chi2;
+  const int ndf = (2 * n) - kNBoundParams;
+  int kinks = 0;
+  // The allowance's last step, which frees no degree of freedom; counted by its
+  // instantiation alone.
+  [[maybe_unused]] int allowed = 0; // NOLINT(misc-const-correctness)
+  countWork(WorkCounter::kRoadStepsPossible, static_cast<std::uint64_t>(n - 1));
+  // A road is at least a triplet, so `ndf` >= 1, and `kinkBudgetFor` keeps
+  // `ndf - 2 kinks` there; the analyzer, not knowing n >= 3, takes n = 2.
+  // NOLINTBEGIN(clang-analyzer-security.ArrayBound)
+  for (int index = 1; index < n; ++index) {
+    if (!(result.chi2 <= chi2MaxByNdf[ndf - (2 * kinks)])) {
+      countWork(WorkCounter::kRoadChi2);
+      result.status = RoadFitStatus::kRejected;
+      return result;
+    }
+    countWork(WorkCounter::kRoadSteps);
+    const auto& stepProp = stepPropagator(prop, geometry, measurements, index - 1, index);
+    if constexpr (LastStepAllowance) {
+      if (index == n - 1) {
+        int taken = kinks;
+        bool refused = false;
+        const auto status = detail::allowanceStep<Rule>(stepProp, geometry, material, measurements[index], PropagationDirection::kForward, state, factors, result.chi2, budget, lastStepScale, taken, refused);
+        if (status != PropagationStatus::kOk) {
+          countWork(WorkCounter::kRoadPropagation);
+          result.status = RoadFitStatus::kPropagationFailed;
+          return result;
+        }
+        if (refused) {
+          countWork(WorkCounter::kRoadChi2);
+          result.status = RoadFitStatus::kRejected;
+          return result;
+        }
+        allowed = taken - kinks;
+        continue;
+      }
+    }
+    const auto status = detail::kinkStep<Rule>(stepProp, geometry, material, measurements[index], PropagationDirection::kForward, state, factors, result.chi2, budget, index < n - 1, kinks);
+    if (status != PropagationStatus::kOk) {
+      countWork(WorkCounter::kRoadPropagation);
+      result.status = RoadFitStatus::kPropagationFailed;
+      return result;
+    }
+  }
+  result.kinks = static_cast<std::uint8_t>(kinks + allowed);
+  covarianceFromFactors(factors, state.cov);
+  result.state = state;
+  if (!(result.chi2 <= chi2MaxByNdf[ndf - (2 * kinks)])) {
+    // NOLINTEND(clang-analyzer-security.ArrayBound)
+    countWork(WorkCounter::kRoadChi2);
+    result.status = RoadFitStatus::kRejected;
+  }
+  return result;
+}
+
+/// The outward road fit as an iteration of \a parameters takes it: its kink
+/// budget, and with \a LastStepAllowance its kink allowance on the last step
+/// (`fitOutward`'s), with the allowance's theta0 factor. The stages make the
+/// choice at compile time (`RoadFitStage`).
+template <bool LastStepAllowance, CrossingRule Rule = CrossingRule::kFirstAhead, typename Parameters, typename Prop, DetectorLayout Det, typename Material, typename Chain>
+[[nodiscard]] GPUdi() RoadFitResult fitRoad(const Parameters& parameters, const Prop& prop, const TrackingGeometry<Det>& geometry, const Material& material, const Chain& measurements, int n)
+{
+  if constexpr (LastStepAllowance) {
+    return fitOutward<true, Rule>(prop, geometry, material, measurements, n, parameters.roadChi2MaxByNdf, kinkBudget(parameters), o2::gpu::CAMath::Sqrt(parameters.kinkScale2));
+  } else {
+    return fitOutward<false, Rule>(prop, geometry, material, measurements, n, parameters.roadChi2MaxByNdf, kinkBudget(parameters));
+  }
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRACKFITTER_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackRefit.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackRefit.h
new file mode 100644
index 0000000000000..32853986a3a14
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackRefit.h
@@ -0,0 +1,220 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackRefit.h
+/// \brief The refit of the selected tracks into the output record.
+///
+/// The candidate fit kept a road's chi2 and its outward pass's end state; a
+/// selected track gets the fit's inward pass (`fitInward`) on its rows, and with it
+/// its state and covariance on its innermost surface, the outward state taken
+/// from the record. One element per
+/// selected track, the output one record per element: nothing to scan.
+
+#ifndef GTRK_TRACKING_TRACKREFIT_H_
+#define GTRK_TRACKING_TRACKREFIT_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/BoundTrackState.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Base/Columns.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Tracking/Selection.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/TrackFitter.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+
+#include <memlayout/wrapper.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+namespace o2::gtrk
+{
+
+/// A track as the iteration outputs it: the inward pass's state on its
+/// innermost surface, the outward pass's state on its outermost surface, its
+/// time box `[timePS, timePS + widthPS)`, its
+/// fit quality, and its measurement rows, innermost first. \a K is the
+/// detector's longest chain.
+template <std::size_t K>
+struct TrackOf {
+  // As for TrackletT: upstream's `apply` macro also uses the member names as
+  // enum constants.
+  // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members,cppcoreguidelines-missing-std-forward,readability-identifier-naming)
+  template <template <class> class C>
+  struct RecordT {
+    MEMLAYOUT_APPLY(RecordT, state, outwardState, timePS, widthPS, chi2, outwardChi2, ndf, status, clusters, count, iteration, addedOutward, addedInward, kinks, kinkCluster)
+    C<BoundTrackState> state;
+    C<BoundTrackState> outwardState;
+    C<std::uint32_t> timePS;
+    C<std::uint32_t> widthPS;
+    C<Scalar> chi2;        ///< the inward pass's
+    C<Scalar> outwardChi2; ///< the outward pass's, which `outwardState` ends
+    C<std::int16_t> ndf;
+    C<PropagationStatus> status; ///< the refit's: kOk, or why it failed
+    C<ClusterList<K>> clusters;
+    C<std::uint8_t> count;
+    C<std::uint8_t> iteration; ///< the iteration that found it
+    C<std::uint8_t> addedOutward;
+    C<std::uint8_t> addedInward;
+    C<std::uint8_t> kinks;       ///< the inward pass's
+    C<std::uint8_t> kinkCluster; ///< its last kink's position in `clusters`; kNoKink without
+  };
+  static constexpr std::uint8_t kNoKink = 0xFFU;
+  // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members,cppcoreguidelines-missing-std-forward,readability-identifier-naming)
+};
+
+/// A track's time box: the intersection of its \a count rows' boxes, not
+/// empty -- the roads' time test and the extension keep it so.
+template <typename Columns, std::size_t K>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() TimeEstPS trackTimeBox(const Columns& columns, const ClusterList<K>& clusters, std::uint8_t count)
+{
+  auto box = timeBoxAt(columns, clusters.index[0]);
+  for (std::uint8_t i = 1; i < count; ++i) {
+    box += timeBoxAt(columns, clusters.index[i]);
+  }
+  return box;
+}
+
+/// Write \a fit of the rows \a clusters, \a count of them, as track \a track
+/// of \a tracks with the time box \a box (`trackTimeBox`): every column but
+/// the iteration and the clusters an extension added, which the caller knows
+/// (and the outward chi2 after `fitInward`, which has none).
+template <typename Tracks, std::size_t K>
+GPUhdi() GPUAlwaysInline() void writeFit(const Tracks& tracks, std::uint32_t track, const TrackFitResult& fit, const ClusterList<K>& clusters, std::uint8_t count, const TimeEstPS& box)
+{
+  tracks.state[track] = fit.state;
+  tracks.outwardState[track] = fit.outwardState;
+  tracks.timePS[track] = box.start;
+  tracks.widthPS[track] = box.width;
+  tracks.chi2[track] = fit.chi2;
+  tracks.outwardChi2[track] = fit.outwardChi2;
+  tracks.ndf[track] = fit.ndf;
+  tracks.status[track] = fit.status;
+  tracks.clusters[track] = clusters;
+  tracks.count[track] = count;
+  tracks.kinks[track] = fit.kinks;
+  tracks.kinkCluster[track] = fit.kinkMeasurement < 0 ? TrackOf<K>::kNoKink : static_cast<std::uint8_t>(fit.kinkMeasurement);
+}
+
+/// One element per selected record: the inward pass on its rows from the road
+/// fit's outward state (`fitInward`), and the track's time from their boxes;
+/// the pass may take the iteration's kinks. Its frame, geometry and material
+/// are pointers, which may be a device's.
+template <DetectorLayout Det, typename Material>
+class TrackRefitElement
+{
+ public:
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  using View = typename BoundedColumns<TrackOf<kMaxClusters>::template RecordT>::View;
+
+  TrackRefitElement(const TimeFrame<Det>* frame, const TrackingGeometry<Det>* geometry, const Material* material, const Propagator& propagator, const ClusterList<kMaxClusters>* clusters, const std::uint8_t* count, const BoundTrackState* outward, const Scalar* outwardChi2, const std::uint32_t* selected, View tracks, std::uint32_t offset, std::uint8_t iteration, KinkBudget kinks)
+    : mFrame(frame),
+      mGeometry(geometry),
+      mMaterial(material),
+      mPropagator(propagator),
+      mClusters(clusters),
+      mCount(count),
+      mOutward(outward),
+      mOutwardChi2(outwardChi2),
+      mSelected(selected),
+      mTracks(tracks),
+      mOffset(offset),
+      mIteration(iteration),
+      mKinks(kinks)
+  {
+  }
+
+  GPUhdi() void operator()(std::uint32_t element) const
+  {
+    const std::uint32_t record = mSelected[element];
+    const std::uint32_t track = mOffset + element;
+    const auto& rows = mClusters[record];
+    const std::uint8_t count = mCount[record];
+    // The road fit ran the outward pass already and kept its end state.
+    const auto fit = fitInward(mPropagator, *mGeometry, *mMaterial, RowChain<Det>{.frame = mFrame, .rows = rows.index}, static_cast<int>(count), mOutward[record], mKinks);
+    writeFit(mTracks, track, fit, rows, count, trackTimeBox(mFrame->measurements(), rows, count));
+    mTracks.outwardChi2[track] = mOutwardChi2[record];
+    mTracks.iteration[track] = mIteration;
+    mTracks.addedOutward[track] = 0U;
+    mTracks.addedInward[track] = 0U;
+  }
+
+ private:
+  const TimeFrame<Det>* mFrame = nullptr;
+  const TrackingGeometry<Det>* mGeometry = nullptr;
+  const Material* mMaterial = nullptr;
+  Propagator mPropagator;
+  const ClusterList<kMaxClusters>* mClusters = nullptr;
+  const std::uint8_t* mCount = nullptr;
+  const BoundTrackState* mOutward = nullptr;
+  const Scalar* mOutwardChi2 = nullptr; ///< the road fit's, whose end state `mOutward` is
+  const std::uint32_t* mSelected = nullptr;
+  View mTracks;
+  std::uint32_t mOffset = 0U;
+  std::uint8_t mIteration = 0U;
+  KinkBudget mKinks;
+};
+
+/// The timeframe's tracks: each iteration's appended after the ones before,
+/// one per selected record, in the selection's order, best first.
+template <DetectorLayout Det>
+class TrackRefit
+{
+ public:
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  using Tracks = BoundedColumns<TrackOf<kMaxClusters>::template RecordT>;
+
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
+  {
+    mMemoryPool.swap(pool);
+    clearStorage();
+  }
+
+  /// Start a timeframe: no tracks.
+  void clear() { mTracks.resize(0U); }
+
+  /// The tracks' storage back to the pool.
+  void clearStorage() noexcept { mTracks.setMemoryResource(mMemoryPool.get()); }
+
+  /// Refit \a selection's selected records, iteration \a iteration's, after
+  /// the tracks already held. \a forEach(elements, body) runs body(element)
+  /// for every element, serially or in parallel.
+  template <typename Material, typename ForEach>
+  [[nodiscard]] StageStatus run(ForEach forEach, const GlobalSelection<kMaxClusters>& selection, const IterationParameters<Det>& parameters, const TimeFrame<Det>& frame, const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator, std::uint8_t iteration)
+  {
+    return guardOutOfMemory([&] {
+      const auto selected = selection.selected();
+      const auto offset = static_cast<std::uint32_t>(mTracks.size());
+      mTracks.resize(offset + selected.size());
+      const auto records = selection.records();
+      const TrackRefitElement<Det, Material> element{&frame, &geometry, &material, propagator, records.clusters, records.count, records.outwardState, records.chi2, selected.data(), mTracks.view(), offset, iteration, kinkBudget(parameters)};
+      forEach(static_cast<std::uint32_t>(selected.size()), element);
+      return StageStatus::kComplete;
+    });
+  }
+
+  [[nodiscard]] const Tracks& tracks() const { return mTracks; }
+  [[nodiscard]] Tracks& tracks() { return mTracks; }
+  [[nodiscard]] std::size_t size() const { return mTracks.size(); }
+
+ private:
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  Tracks mTracks;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRACKREFIT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Tracker.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Tracker.h
new file mode 100644
index 0000000000000..eaab97797973f
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Tracker.h
@@ -0,0 +1,1221 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Tracker.h
+/// \brief The timeframe's tracking: every iteration over every slice, the
+///        global selection between them, and the refit of the tracks.
+
+#ifndef GTRK_TRACKING_TRACKER_H_
+#define GTRK_TRACKING_TRACKER_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Base/CapacityEstimator.h"
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/Follow.h"
+#include "GenericTracking/Base/HostAlgorithms.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/NeighbourStage.h"
+#include "GenericTracking/Tracking/Parallel.h"
+#include "GenericTracking/Tracking/Profile.h"
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Tracking/RoadCount.h"
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Tracking/Selection.h"
+#include "GenericTracking/Tracking/SensorCells.h"
+#include "GenericTracking/Tracking/SlicePlan.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/TimeFrameScratch.h"
+#include "GenericTracking/Tracking/TrackRefit.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tracking/TrackletSort.h"
+#include "GenericTracking/Tracking/TrackletStage.h"
+#include "GenericTracking/Tracking/TripletStage.h"
+
+#include "GPUCommonAlgorithm.h"
+
+#include <algorithm>
+#include <cassert>
+#include <array>
+#include <atomic>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <span>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+/// The stages whose per-thread staging the `CapacityEstimator` predicts, its
+/// site indices.
+enum class StagingSite : std::uint8_t {
+  kTracklets = 0,
+  kTriplets,
+  kNeighbours,
+  kRecords,
+};
+static_assert(static_cast<std::size_t>(StagingSite::kRecords) + 1U == CapacityEstimator::kSites);
+
+/// The tracking of a timeframe:
+/// every iteration, one after another, over every slice, the global
+/// selection between them into the used mask, and the refit of the
+/// selected tracks.
+///
+/// One slice of one iteration runs tracklets, triplets, neighbours and
+/// levels (`runSlice`), then the roads and their fit. Every stage works the
+/// core and whatever in the halo lies within the gate (`SliceReach::gatePS`)
+/// of it, so the output the core owns does not depend on the slicing.
+/// Sources and targets, and the
+/// targets' variance bounds, come from the halo. The scratch and
+/// backend retain their allocations across calls; a failed run returns its
+/// StageStatus and no usable output.
+template <DetectorLayout Det, typename Material>
+class Tracker
+{
+ public:
+  using Frame = TimeFrame<Det>;
+  using Scratch = TimeFrameScratch<Det>;
+  using Tracklets = typename Scratch::Tracklets;
+  using Triplets = typename Scratch::Triplets;
+  using Neighbours = typename Scratch::Neighbours;
+  using VertexWindows = VertexWindowParameters<Det>;
+  using Index = typename Tracklets::Index;
+  static constexpr std::size_t kLayerCount = Scratch::kLayerCount;
+  static constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+  using Records = StageOutput<SelectionRecordOf<kMaxClusters>::template RecordT>;
+
+  /// A slice's tracklets, the triplets built from them with their levels and
+  /// each triplet's predecessors, all valid until the next run.
+  struct Result {
+    StageStatus status = StageStatus::kComplete;
+    const Tracklets* tracklets = nullptr;
+    const Triplets* triplets = nullptr;
+    const Neighbours* neighbours = nullptr;
+  };
+
+  using Phase = profile::Phase;
+
+  /// What one iteration of a timeframe did.
+  struct IterationSummary {
+    StageStatus status = StageStatus::kComplete;
+    std::size_t slices = 0U;
+    std::size_t roads = 0U;      ///< fitted, over the slices
+    std::size_t records = 0U;    ///< passing the fit, over the slices
+    std::size_t duplicates = 0U; ///< records found by more than one slice
+    std::size_t mismatches = 0U; ///< duplicates that differ: must be none
+    std::size_t rounds = 0U;
+    std::size_t tracks = 0U;
+    std::size_t refitFailures = 0U; ///< selected tracks whose two-pass refit failed
+    /// The iteration's tracks its follow grew, and the rows it added outward
+    /// and inward.
+    std::size_t tracksFollowed = 0U;
+    std::size_t clustersFollowedOutward = 0U;
+    std::size_t clustersFollowedInward = 0U;
+    /// With followEarlier, the earlier iterations' tracks its follow grew,
+    /// and their rows.
+    std::size_t tracksFollowedEarlier = 0U;
+    std::size_t clustersFollowedEarlierOutward = 0U;
+    std::size_t clustersFollowedEarlierInward = 0U;
+    /// Tracks below the iteration's length after the follow, dropped;
+    /// `tracks` counts them.
+    std::size_t tracksDropped = 0U;
+    std::size_t recordBytes = 0U; ///< the selection records held for the iteration
+    std::int64_t haloPS = 0;
+    /// Every phase of the iteration, from `iteration` down; empty with
+    /// profiling off.
+    profile::Profile profile;
+
+    /// The wall time of \a phase in the iteration, over all its slices.
+    [[nodiscard]] double seconds(Phase phase) const { return profile[phase].seconds; }
+  };
+
+  /// The timeframe's tracks, all iterations' in iteration order, each
+  /// iteration's best first, with each iteration's summary.
+  struct TimeframeResult {
+    StageStatus status = StageStatus::kComplete;
+    const typename TrackRefit<Det>::Tracks* tracks = nullptr;
+    std::vector<IterationSummary> iterations;
+    /// The run's phases: `run`, `begin timeframe`, and the iterations' summed.
+    profile::Profile profile;
+  };
+
+  /// What a run left after its first iterations, all that a later iteration
+  /// reads: the tracks, the used
+  /// mask and the iterations' summaries, their profiles empty (`resume`
+  /// does not run them).
+  struct Checkpoint {
+    std::vector<typename TrackRefit<Det>::Tracks::Record> tracks;
+    std::vector<std::uint8_t> used;
+    std::vector<IterationSummary> summaries;
+  };
+
+  /// One tracker for every iteration of \a iterations, their parameters built
+  /// once here.
+  Tracker(std::span<const IterationSettings> iterations, const VertexConstraint& beamSpot, const ScatteringTable<Det>& scattering, std::shared_ptr<BoundedMemoryResource> memoryPool, Index chunkSize, int maxConcurrency = 0)
+    : mBeamLine(vertexSeed(beamSpot)),
+      mMemoryPool(std::move(memoryPool)),
+      mArena(maxConcurrency),
+      mTrackletStage(mArena),
+      mTripletStage(mArena),
+      mNeighbourStage(mArena),
+      mRecordStage(mArena),
+      mChunkSize(chunkSize)
+  {
+    for (std::size_t iteration = 0; iteration < iterations.size(); ++iteration) {
+      const auto& settings = iterations[iteration];
+      checkSharedGraph(iterations, iteration);
+      // An earlier iteration with the same windows has the same links'
+      // windows and bounds: derived once (`iterationParameters`).
+      const IterationParameters<Det>* alike = nullptr;
+      for (std::size_t earlier = 0; earlier < iteration && alike == nullptr; ++earlier) {
+        if (mWindowSettings[earlier] == settings.windows) {
+          alike = &mIterations[earlier];
+        }
+      }
+      mWindowSettings.push_back(settings.windows);
+      mIterations.push_back(iterationParameters<Det>(settings, beamSpot, scattering, alike));
+    }
+    mScratch.setMemoryPool(mMemoryPool);
+    mTrackletStage.setMemoryPool(mMemoryPool);
+    mTripletStage.setMemoryPool(mMemoryPool);
+    mNeighbourStage.setMemoryPool(mMemoryPool);
+    mRecordStage.setMemoryPool(mMemoryPool);
+    mRoads.setMemoryPool(mMemoryPool);
+    mRecords.setMemoryPool(mMemoryPool);
+    mSharedRecords.setMemoryPool(mMemoryPool);
+    mTrackletStage.setPhases({.reset = Phase::kTrackletReset, .generate = Phase::kTrackletGenerate, .scan = Phase::kTrackletScan, .place = Phase::kTrackletPlace});
+    mTripletStage.setPhases({.reset = Phase::kTripletReset, .generate = Phase::kTripletGenerate, .scan = Phase::kTripletScan, .place = Phase::kTripletPlace});
+    mNeighbourStage.setPhases({.reset = Phase::kNeighbourReset, .generate = Phase::kNeighbourGenerate, .scan = Phase::kNeighbourScan, .place = Phase::kNeighbourPlace});
+    mRecordStage.setPhases({.reset = Phase::kRoadFitReset, .generate = Phase::kRoadFitGenerate, .scan = Phase::kRoadFitScan, .place = Phase::kRoadFitPlace});
+    mSelection.setMemoryPool(mMemoryPool);
+    mShared.setMemoryPool(mMemoryPool);
+    mRefit.setMemoryPool(mMemoryPool);
+    mFollow.setMemoryPool(mMemoryPool);
+    mFollowEarlier.setMemoryPool(mMemoryPool);
+    deepVectorClear(mMemoryPool.get(), mUsed, mUsedBeforeSelection, mKeptTracks);
+    mDropScratch.setMemoryResource(mMemoryPool.get());
+  }
+
+  /// A tracker of one iteration.
+  Tracker(const IterationSettings& settings, const VertexConstraint& beamSpot, const ScatteringTable<Det>& scattering, std::shared_ptr<BoundedMemoryResource> memoryPool, Index chunkSize, int maxConcurrency = 0)
+    : Tracker(std::span<const IterationSettings>{&settings, 1U}, beamSpot, scattering, std::move(memoryPool), chunkSize, maxConcurrency)
+  {
+  }
+
+  /// What the road fit and the refit need: the sensors, the material and the
+  /// field. Required by `run(frame, ...)`, not by `runSlice`.
+  void setTrackModel(const TrackingGeometry<Det>& geometry, const Material& material, const Propagator& propagator)
+  {
+    mGeometry = &geometry;
+    mMaterial = &material;
+    mPropagator = propagator;
+    // The sensors by place, once, where an iteration follows.
+    if (std::ranges::any_of(mIterations, [](const auto& parameters) { return parameters.follow || parameters.followEnd; })) {
+      mSensorCells = SensorCells<Det>(geometry);
+    }
+  }
+
+  [[nodiscard]] std::size_t iterationCount() const { return mIterations.size(); }
+  [[nodiscard]] const IterationParameters<Det>& iteration(std::size_t index) const { return mIterations[index]; }
+
+  /// Start a timeframe: every row free, and each stage's staging at what the
+  /// estimator learned (`stageStaging`).
+  [[nodiscard]] StageStatus beginTimeframe(const Frame& frame)
+  {
+    return guardOutOfMemory([&] {
+      clearResizeBoundedVector(mUsed, frame.size(), mMemoryPool.get(), std::uint8_t{kFree});
+      mRows = frame.size();
+      stageStaging(StagingSite::kTracklets, mTrackletStage);
+      stageStaging(StagingSite::kTriplets, mTripletStage);
+      stageStaging(StagingSite::kNeighbours, mNeighbourStage);
+      stageStaging(StagingSite::kRecords, mRecordStage);
+      return StageStatus::kComplete;
+    });
+  }
+
+  /// The end of a timeframe, after its caller has read `run`'s result:
+  /// the estimator learns each
+  /// stage's largest staging use, and everything that grew with the timeframe
+  /// goes back to the pool -- what each iteration releases
+  /// (`releaseIterationStorage`), the shared records, the tracks and the used
+  /// masks. The result, its tracks included, is invalid after.
+  void endTimeframe() noexcept
+  {
+    learnStaging(StagingSite::kTracklets, mTrackletStage);
+    learnStaging(StagingSite::kTriplets, mTripletStage);
+    learnStaging(StagingSite::kNeighbours, mNeighbourStage);
+    learnStaging(StagingSite::kRecords, mRecordStage);
+    releaseIterationStorage();
+    mSelection.clearStorage();
+    mShared.clearStorage();
+    mRefit.clearStorage();
+    deepVectorClear(mMemoryPool.get(), mUsed, mUsedBeforeSelection);
+    mFollowStartInner = {};
+    mFollowStart = {};
+    mFollowStartCount = {};
+    mFollowUsed = {};
+  }
+
+  /// The used mask, per row: what the selection has taken so far.
+  [[nodiscard]] std::span<const std::uint8_t> used() const { return mUsed; }
+
+  /// Iteration \a iteration's graph on the used mask as it stands, without
+  /// the selection, the refit or the follow (for the truth-removal study):
+  /// every slice of \a plan, tracklets to the
+  /// numbered roads -- with \a fit, also the road fit's records -- and \a
+  /// visit(result, roads, records, fitSeconds) after each slice while its
+  /// graph lives, records null and fitSeconds 0 without \a fit. After `beginTimeframe`. An iteration that
+  /// shares a graph or follows the earlier tracks has no graph of its own:
+  /// std::invalid_argument. Returns the first status short of complete.
+  template <typename Visit>
+  [[nodiscard]] StageStatus runGraph(std::size_t iteration, const Frame& frame, const TimeframePlan<Det>& plan, bool fit, const Visit& visit)
+  {
+    plan.check(frame, mIterations);
+    if (mIterations[iteration].sharedGraph || mIterations[iteration].followEarlier || (iteration + 1U < mIterations.size() && mIterations[iteration + 1U].sharedGraph)) {
+      throw std::invalid_argument("iteration " + std::to_string(iteration) + " shares a graph or follows the earlier tracks: no graph of its own");
+    }
+    for (const auto& slicePlan : plan.slices) {
+      const auto sliced = runPlannedSlice(iteration, frame, plan, slicePlan, slicePlan.slice, plan.beamLine, plan.vertices, plan.vertexWindows[iteration], true);
+      if (sliced.status != StageStatus::kComplete) {
+        return sliced.status;
+      }
+      const auto counted = countRoads();
+      if (counted != StageStatus::kComplete) {
+        return counted;
+      }
+      double fitSeconds = 0.;
+      if (fit) {
+        const auto start = std::chrono::steady_clock::now();
+        const auto fitted = guardOutOfMemory([&] { return fitRoads<false>(frame, iteration, mRecords); });
+        if (fitted != StageStatus::kComplete) {
+          return fitted;
+        }
+        fitSeconds = std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+      }
+      visit(sliced, std::as_const(mRoads), fit ? &std::as_const(mRecords) : nullptr, fitSeconds);
+    }
+    return StageStatus::kComplete;
+  }
+
+  /// Hold \a rows exclusively, as a selection takes them: the next
+  /// iteration's tracklet stage skips them.
+  void holdRows(std::span<const std::uint32_t> rows)
+  {
+    for (const auto row : rows) {
+      mUsed[row] = kExclusive;
+    }
+  }
+
+  /// The used mask \a used, a checkpoint's: the rows as a run's first
+  /// iterations left them, after `beginTimeframe`.
+  void restoreUsed(std::span<const std::uint8_t> used)
+  {
+    if (used.size() != mUsed.size()) {
+      throw std::invalid_argument("a used mask of " + std::to_string(used.size()) + " rows for a frame of " + std::to_string(mUsed.size()));
+    }
+    std::ranges::copy(used, mUsed.begin());
+  }
+
+  /// The plan of a timeframe for this tracker's iterations: every slice of
+  /// \a sliceWidthBlocks blocks with at least \a configuredHaloPS of halo --
+  /// more when the frame's reach needs it (`SliceReach::haloPS`). \a vertices
+  /// are the timeframe's vertex list, sorted by time, for the iterations that
+  /// use it.
+  [[nodiscard]] TimeframePlan<Det> planTimeframe(const Frame& frame, std::span<const VertexSeed> vertices, std::int32_t sliceWidthBlocks, std::int64_t configuredHaloPS) const { return o2::gtrk::planTimeframe<Det>(frame, mIterations, mWindowSettings, mBeamLine, vertices, sliceWidthBlocks, configuredHaloPS); }
+
+  /// The whole timeframe as \a plan has it: for every iteration, every slice,
+  /// then the selection, the refit and the follow. \a plan must be this
+  /// tracker's plan of \a frame -- std::invalid_argument otherwise -- and
+  /// outlive the run.
+  [[nodiscard]] TimeframeResult run(const Frame& frame, const TimeframePlan<Det>& plan) { return runIterations(frame, plan, nullptr, mIterations.size()); }
+
+  /// The first \a iterations iterations of `run(frame, plan)`, the same as
+  /// far as they go: what `checkpoint` keeps.
+  [[nodiscard]] TimeframeResult run(const Frame& frame, const TimeframePlan<Det>& plan, std::size_t iterations)
+  {
+    if (iterations > mIterations.size()) {
+      throw std::invalid_argument(std::to_string(iterations) + " iterations of a tracker of " + std::to_string(mIterations.size()));
+    }
+    return runIterations(frame, plan, nullptr, iterations);
+  }
+
+  /// What \a result, this tracker's last `run` and complete, left: its
+  /// tracks, the used mask and its iterations' summaries. Before
+  /// `endTimeframe`, which releases them.
+  [[nodiscard]] Checkpoint checkpoint(const TimeframeResult& result) const
+  {
+    if (result.status != StageStatus::kComplete || result.tracks == nullptr) {
+      throw std::invalid_argument("a checkpoint of an incomplete run");
+    }
+    Checkpoint state;
+    state.tracks.reserve(result.tracks->size());
+    for (std::size_t track = 0; track < result.tracks->size(); ++track) {
+      state.tracks.push_back(result.tracks->read(track));
+    }
+    state.used.assign(mUsed.begin(), mUsed.end());
+    state.summaries = result.iterations;
+    for (auto& summary : state.summaries) {
+      summary.profile = {};
+    }
+    return state;
+  }
+
+  /// `run(frame, plan)` from \a from: its tracks, used mask and summaries as
+  /// its iterations left them, then this tracker's iterations after those.
+  /// The whole run's result where those iterations were this tracker's first
+  /// ones on the same frame and plan: the caller checks the settings. Not
+  /// from before an iteration that takes the previous one's graph
+  /// (std::invalid_argument), which no checkpoint holds.
+  [[nodiscard]] TimeframeResult resume(const Frame& frame, const TimeframePlan<Det>& plan, const Checkpoint& from)
+  {
+    const std::size_t first = from.summaries.size();
+    if (first > mIterations.size() || from.used.size() != frame.size()) {
+      throw std::invalid_argument("a checkpoint of " + std::to_string(first) + " iterations on " + std::to_string(from.used.size()) + " rows for a tracker of " + std::to_string(mIterations.size()) + " on " + std::to_string(frame.size()));
+    }
+    if (first < mIterations.size() && mIterations[first].sharedGraph) {
+      throw std::invalid_argument("iteration " + std::to_string(first) + " takes the previous iteration's graph: no checkpoint before it");
+    }
+    return runIterations(frame, plan, &from, mIterations.size());
+  }
+
+  /// Profile every `run`, or leave the profiles empty (the default).
+  void setProfiling(bool enabled) { mProfiling = enabled; }
+
+  /// The tracker's arena, its stages' and loops' threads: for a pass that
+  /// shares them (VertexingPass).
+  [[nodiscard]] detail::TaskArena& arena() noexcept { return mArena; }
+
+  /// Record every zone and parallel chunk of the next runs into \a trace, or
+  /// nothing with nullptr, the default. The trace must outlive the runs.
+  void setTrace(profile::Trace* trace) { mTrace = trace; }
+
+  /// One slice of iteration \a iteration, tracklets to levels, reading the used
+  /// mask as `beginTimeframe` and the selections since left it: \a slicePlan,
+  /// one of \a plan's slices (or planned alike), with \a plan's frame-wide
+  /// bounds. \a vertexWindows are \a plan's for the iteration (`planTimeframe`);
+  /// a beam-line iteration does not read them.
+  [[nodiscard]] Result runSlice(std::size_t iteration, const Frame& frame, const TimeframePlan<Det>& plan, const SlicePlan<Det>& slicePlan, std::span<const VertexSeed> vertices, const VertexWindows& vertexWindows)
+  {
+    assert(iteration < mIterations.size());
+    return runPlannedSlice(iteration, frame, plan, slicePlan, slicePlan.slice, mBeamLine, vertices, vertexWindows, false);
+  }
+
+  /// A completed slice of `run`, as an observer sees it: after its roads and
+  /// before the selection, with the used mask it read still in place. Every
+  /// pointer is valid while the observer runs.
+  struct SliceObservation {
+    std::size_t iteration = 0U;
+    const Frame* frame = nullptr;
+    const typename Frame::TimeSlice* slice = nullptr;
+    const Result* result = nullptr;
+    const RoadCount* roads = nullptr; ///< the slice's road counts, starts and offsets
+    const Records* records = nullptr; ///< the slice's selection records
+  };
+  using SliceObserver = std::function<void(const Tracker&, const SliceObservation&)>;
+
+  /// A completed iteration of `run`: its selection, refit and follow
+  /// done. The selection's records() are every slice's, appended in order.
+  struct IterationObservation {
+    std::size_t iteration = 0U;
+    const GlobalSelection<kMaxClusters>* selection = nullptr;
+    const IterationSummary* summary = nullptr;
+    std::span<const std::uint8_t> used;                        ///< the mask after the iteration
+    const typename TrackRefit<Det>::Tracks* tracks = nullptr;  ///< every iteration's so far
+    std::uint32_t trackOffset = 0U;                            ///< this iteration's first in `tracks`
+    std::span<const typename Follow<Det>::Proposal> proposals; ///< one per track of it; empty without the follow
+    /// With followEarlier, one per earlier track: their follow before this
+    /// iteration's seeds.
+    std::span<const typename Follow<Det>::Proposal> earlierProposals;
+    /// The kink steps of `proposals` and of `earlierProposals`, where the
+    /// iteration takes them (`Follow::kinkSteps`).
+    std::span<const follow::KinkSteps> kinkSteps;
+    std::span<const follow::KinkSteps> earlierKinkSteps;
+    /// With the follow, each of the iteration's tracks as the follow started
+    /// from it: its inner and outward states and its rows then (the first
+    /// `followStartCount` of its clusters), for a replay;
+    /// empty without the follow.
+    std::span<const BoundTrackState> followStartInner;
+    std::span<const BoundTrackState> followStart;
+    std::span<const std::uint8_t> followStartCount;
+    /// With the follow, the used mask as the follow read it, before its
+    /// rows and the length cut; empty without.
+    std::span<const std::uint8_t> followUsed;
+  };
+  using IterationObserver = std::function<void(const Tracker&, const IterationObservation&)>;
+
+  /// Called by `run` after every completed slice -- QA that repeats a slice's
+  /// work elsewhere, such as on a device. Nothing it does changes the tracking.
+  void setSliceObserver(SliceObserver observer) { mSliceObserver = std::move(observer); }
+  /// Called by `run` after every completed iteration, as the slice observer.
+  void setIterationObserver(IterationObserver observer) { mIterationObserver = std::move(observer); }
+
+  /// The source map of the last slice: its halo rows.
+  [[nodiscard]] const typename Scratch::Sources& sources() const { return mScratch.sources(); }
+  /// The beam line as a vertex seed, which a beam-line iteration reads.
+  [[nodiscard]] const VertexSeed& beamLine() const { return mBeamLine; }
+  /// The most tracklets, triplets and neighbours one slice placed.
+  [[nodiscard]] std::size_t trackletHighWater() const { return mTrackletHighWater; }
+  [[nodiscard]] std::size_t tripletHighWater() const { return mTripletHighWater; }
+  [[nodiscard]] std::size_t neighbourHighWater() const { return mNeighbourHighWater; }
+  [[nodiscard]] std::size_t stagingHighWater() const { return mStagingHighWater; }
+  [[nodiscard]] std::size_t stagingPredictionMisses() const { return mStagingPredictionMisses; }
+  [[nodiscard]] std::size_t memoryHighWater() const { return mMemoryPool->getPeakMemory(); }
+
+ private:
+  /// Throws std::invalid_argument for iteration \a iteration of \a iterations
+  /// taking its predecessor's graph (`IterationSettings::sharedGraph`) where
+  /// that graph is not its own but for the kink allowance: no predecessor,
+  /// one that takes its own predecessor's, a kink allowance in the
+  /// predecessor or none here, or a graph setting that differs.
+  static void checkSharedGraph(std::span<const IterationSettings> iterations, std::size_t iteration)
+  {
+    const auto& settings = iterations[iteration];
+    if (!settings.sharedGraph) {
+      return;
+    }
+    const auto fail = [&](const char* why) { throw std::invalid_argument("iteration " + std::to_string(iteration) + " takes the previous iteration's graph (iterationSharedGraph): " + why); };
+    if (iteration == 0U) {
+      fail("it is the first");
+    }
+    const auto& previous = iterations[iteration - 1U];
+    if (previous.sharedGraph) {
+      fail("the previous one builds none");
+    }
+    const auto graphSigma = [](const IterationSettings& one) { return one.graphKinkSigma > 0. ? one.graphKinkSigma : one.kinkSigma; };
+    if (!(graphSigma(previous) <= 1.) || !(graphSigma(settings) > 1.)) {
+      fail("it needs a kink allowance, and the previous one none");
+    }
+    const auto graph = [](const IterationSettings& one) { return std::tie(one.windows, one.vertexSource, one.minClusters, one.skipLinks, one.layerMask, one.roadEndLayers, one.roadStartLayers, one.minPtGeVByClusters, one.shapeTest); };
+    if (graph(settings) != graph(previous)) {
+      fail("its graph settings differ from the previous one's");
+    }
+  }
+
+  [[nodiscard]] const IterationParameters<Det>& parameters() const { return mIterations[mIteration]; }
+
+  /// \a site's staging for the timeframe, in \a backend: what the estimator
+  /// learned from the timeframes before.
+  template <typename StageBackend>
+  void stageStaging(StagingSite site, StageBackend& backend)
+  {
+    auto& granted = mGranted[static_cast<std::size_t>(site)];
+    granted = mEstimator.perThread(static_cast<std::size_t>(site), mRows);
+    backend.prepareStagingPerThread(granted);
+    backend.resetLargestUse();
+  }
+
+  /// Teach the estimator what \a backend's buffers held over the timeframe.
+  template <typename StageBackend>
+  void learnStaging(StagingSite site, const StageBackend& backend)
+  {
+    mEstimator.learn(static_cast<std::size_t>(site), backend.largestUse(), mGranted[static_cast<std::size_t>(site)], mRows, backend.grewSinceReset());
+    mStagingPredictionMisses += backend.grewSinceReset() ? 1U : 0U;
+  }
+
+  /// `run` from \a from (none: the start) to iteration \a last.
+  [[nodiscard]] TimeframeResult runIterations(const Frame& frame, const TimeframePlan<Det>& plan, const Checkpoint* from, std::size_t last)
+  {
+    plan.check(frame, mIterations);
+    TimeframeResult result;
+    profiled(result.profile, Phase::kRun, [&] { runTimeframe(frame, plan, result, from, last); });
+    return result;
+  }
+
+  /// `runIterations` without its profile's activation: the iterations after
+  /// \a from's (from the first without one) to \a last into \a result.
+  void runTimeframe(const Frame& frame, const TimeframePlan<Det>& plan, TimeframeResult& result, const Checkpoint* from, std::size_t last)
+  {
+    {
+      const profile::Zone zone{Phase::kBegin};
+      result.status = beginTimeframe(frame);
+    }
+    if (result.status != StageStatus::kComplete) {
+      return;
+    }
+    mRefit.clear();
+    std::size_t first = 0U;
+    if (from != nullptr) {
+      first = from->summaries.size();
+      std::ranges::copy(from->used, mUsed.begin());
+      // The tracks into the pool: a limit ends the run with a status, as anywhere.
+      result.status = guardOutOfMemory([&] {
+        auto& tracks = mRefit.tracks();
+        tracks.resize(from->tracks.size());
+        for (std::size_t track = 0; track < from->tracks.size(); ++track) {
+          tracks.write(track, from->tracks[track]);
+        }
+        return StageStatus::kComplete;
+      });
+      if (result.status != StageStatus::kComplete) {
+        return;
+      }
+      result.iterations = from->summaries;
+    }
+    for (std::size_t iteration = first; iteration < last; ++iteration) {
+      IterationSummary summary;
+      profiled(summary.profile, Phase::kIteration, [&] { runIteration(iteration, frame, plan, summary); });
+      result.profile += summary.profile;
+      result.iterations.push_back(summary);
+      if (summary.status != StageStatus::kComplete) {
+        result.status = summary.status;
+        return;
+      }
+    }
+    result.tracks = &mRefit.tracks();
+  }
+
+  /// What one iteration grew, back to the pool at its end, after its
+  /// observers: the slices' storage -- the
+  /// scratch, the stages' staging and chunk lists, the road counts, the
+  /// records -- and the selection's records' and the follows'. Kept from one iteration
+  /// to the next, each buffer would hold the largest size any iteration gave
+  /// it, whichever shape the next one has. The staging sizes the estimator
+  /// granted stay; the next iteration allocates its own.
+  void releaseIterationStorage() noexcept
+  {
+    mScratch.clearStorage();
+    mTrackletStage.releaseStorage();
+    mTripletStage.releaseStorage();
+    mNeighbourStage.releaseStorage();
+    mRecordStage.releaseStorage();
+    mRoads.clearStorage();
+    mRecords.clearStorage();
+    mSharedRecords.clearStorage();
+    mSelection.clearRecordStorage();
+    mFollow.clearStorage();
+    mFollowEarlier.clearStorage();
+    deepVectorClear(mMemoryPool.get(), mKeptTracks);
+    mDropScratch.setMemoryResource(mMemoryPool.get());
+  }
+
+  /// Iteration \a iteration of `run`: its slices, the selection, the refit
+  /// and the follow, into \a summary, whose status says how far it got.
+  void runIteration(std::size_t iteration, const Frame& frame, const TimeframePlan<Det>& plan, IterationSummary& summary)
+  {
+    const auto forEach = hostForEach();
+    const auto fits = fitForEach();
+    // The selection's sorts on the tracker's threads, as its loops.
+    const auto sort = [&](std::span<std::uint32_t> indices, const auto& less) { mNeighbourStage.sortIndices(indices, less); };
+    summary.haloPS = plan.haloPS;
+    mSelection.clear();
+    // One graph for two iterations: an iteration
+    // whose successor takes its graph builds it with the successor's kink
+    // allowance and fits the roads for both; the successor builds none.
+    const bool shared = mIterations[iteration].sharedGraph;
+    const bool sharesNext = iteration + 1U < mIterations.size() && mIterations[iteration + 1U].sharedGraph;
+    if (sharesNext) {
+      mShared.clear();
+    }
+    // With followEarlier the earlier iterations' tracks are followed first,
+    // with this iteration's settings: the rows they take are theirs before
+    // this iteration's seeds are made.
+    const bool earlier = mIterations[iteration].followEarlier && mRefit.size() != 0U;
+    if (earlier) {
+      const profile::Zone zone{Phase::kFollowEarlier};
+      summary.status = runFollow(mFollowEarlier, mIterations[iteration], frame, plan, 0U, true, summary.tracksFollowedEarlier, summary.clustersFollowedEarlierOutward, summary.clustersFollowedEarlierInward);
+      if (summary.status != StageStatus::kComplete) {
+        return;
+      }
+    }
+    if (shared) {
+      const profile::Zone zone{Phase::kSelectionAppend};
+      summary.status = mSelection.append(mShared, spreadForEach());
+    }
+    for (const auto& slicePlan : shared ? std::span<const SlicePlan<Det>>{} : std::span<const SlicePlan<Det>>{plan.slices}) {
+      if (summary.status != StageStatus::kComplete) {
+        break;
+      }
+      const auto graph = sharesNext ? iteration + 1U : iteration;
+      const auto sliced = runPlannedSlice(graph, frame, plan, slicePlan, slicePlan.slice, plan.beamLine, plan.vertices, plan.vertexWindows[iteration], true);
+      summary.status = sliced.status;
+      if (summary.status == StageStatus::kComplete) {
+        {
+          const profile::Zone zone{Phase::kRoads};
+          // Guarded whole: the fit's setup allocates before its stage's own
+          // guard.
+          summary.status = guardOutOfMemory([&] { return runRoads(frame, summary, iteration, sharesNext); });
+        }
+        if (mSliceObserver && summary.status == StageStatus::kComplete) {
+          const profile::Zone zone{Phase::kObservers};
+          mSliceObserver(*this, {
+                                  .iteration = iteration,
+                                  .frame = &frame,
+                                  .slice = &slicePlan.slice,
+                                  .result = &sliced,
+                                  .roads = &mRoads,
+                                  .records = &mRecords,
+                                });
+        }
+      }
+      ++summary.slices;
+    }
+    if (summary.status != StageStatus::kComplete) {
+      return;
+    }
+
+    // With a length or a pT floor after the follow, the mask as the
+    // selection finds it.
+    const bool lengthCut = dropsAfterFollow(mIterations[iteration]);
+    if (lengthCut) {
+      const profile::Zone zone{Phase::kLengthCut};
+      summary.status = guardOutOfMemory([&] {
+        // Overwritten whole: kept from iteration to iteration, copied in parallel.
+        resizeBoundedVector(mUsedBeforeSelection, mUsed.size(), mMemoryPool.get());
+        copyInParallel(std::span<const std::uint8_t>{mUsed}, std::span<std::uint8_t>{mUsedBeforeSelection});
+        return StageStatus::kComplete;
+      });
+      if (summary.status != StageStatus::kComplete) {
+        return;
+      }
+    }
+    {
+      const profile::Zone zone{Phase::kSelection};
+      summary.status = mSelection.select(forEach, sort, mIterations[iteration].sharedInnermost, mUsed);
+    }
+    summary.records = mSelection.recordCount();
+    summary.recordBytes = summary.records * sizeof(typename BoundedColumns<SelectionRecordOf<kMaxClusters>::template RecordT>::Record);
+    summary.duplicates = mSelection.duplicates();
+    summary.mismatches = mSelection.mismatches();
+    summary.rounds = mSelection.rounds();
+    summary.tracks = mSelection.selected().size();
+    const auto trackOffset = static_cast<std::uint32_t>(mRefit.size());
+    bool followed = false;
+    bool started = false;
+    if (summary.status == StageStatus::kComplete) {
+      {
+        const profile::Zone zone{Phase::kRefit};
+        summary.status = mRefit.run(fits, mSelection, mIterations[iteration], frame, *mGeometry, *mMaterial, mPropagator, static_cast<std::uint8_t>(iteration));
+      }
+      const auto status = mRefit.tracks().view().status;
+      for (auto track = static_cast<std::size_t>(trackOffset); track < mRefit.size(); ++track) {
+        summary.refitFailures += static_cast<std::size_t>(status[track] != PropagationStatus::kOk);
+      }
+      if (summary.status == StageStatus::kComplete && (mIterations[iteration].follow || mIterations[iteration].followEnd)) {
+        // What the follow starts from, kept only for an observer's replay.
+        started = static_cast<bool>(mIterationObserver);
+        if (started) {
+          const auto view = std::as_const(mRefit.tracks()).view();
+          mFollowStartInner.assign(view.state + trackOffset, view.state + mRefit.size());
+          mFollowStart.assign(view.outwardState + trackOffset, view.outwardState + mRefit.size());
+          mFollowStartCount.assign(view.count + trackOffset, view.count + mRefit.size());
+          mFollowUsed.assign(mUsed.begin(), mUsed.end());
+        }
+        {
+          const profile::Zone zone{Phase::kFollow};
+          summary.status = runFollow(mFollow, mIterations[iteration], frame, plan, trackOffset, false, summary.tracksFollowed, summary.clustersFollowedOutward, summary.clustersFollowedInward);
+        }
+        followed = summary.status == StageStatus::kComplete;
+      }
+    }
+    if (lengthCut && summary.status == StageStatus::kComplete) {
+      const profile::Zone zone{Phase::kLengthCut};
+      summary.status = guardOutOfMemory([&] {
+        summary.tracksDropped = dropShortTracks(mIterations[iteration], trackOffset, followed, started);
+        return StageStatus::kComplete;
+      });
+    }
+    if (mIterationObserver && summary.status == StageStatus::kComplete) {
+      const profile::Zone zone{Phase::kObservers};
+      mIterationObserver(*this, {
+                                  .iteration = iteration,
+                                  .selection = &mSelection,
+                                  .summary = &summary,
+                                  .used = mUsed,
+                                  .tracks = &mRefit.tracks(),
+                                  .trackOffset = trackOffset,
+                                  .proposals = followed ? mFollow.proposals() : std::span<const typename Follow<Det>::Proposal>{},
+                                  .earlierProposals = earlier ? mFollowEarlier.proposals() : std::span<const typename Follow<Det>::Proposal>{},
+                                  .kinkSteps = followed ? mFollow.kinkSteps() : std::span<const follow::KinkSteps>{},
+                                  .earlierKinkSteps = earlier ? mFollowEarlier.kinkSteps() : std::span<const follow::KinkSteps>{},
+                                  .followStartInner = started ? std::span<const BoundTrackState>{mFollowStartInner} : std::span<const BoundTrackState>{},
+                                  .followStart = started ? std::span<const BoundTrackState>{mFollowStart} : std::span<const BoundTrackState>{},
+                                  .followStartCount = started ? std::span<const std::uint8_t>{mFollowStartCount} : std::span<const std::uint8_t>{},
+                                  .followUsed = started ? std::span<const std::uint8_t>{mFollowUsed} : std::span<const std::uint8_t>{},
+                                });
+    }
+    releaseIterationStorage();
+  }
+
+  /// \a follow run on the tracks from \a trackOffset with \a parameters
+  /// (`Follow::run`), \a earlier for the earlier iterations' tracks; its
+  /// proposals tallied into \a tracks, \a outward and \a inward.
+  [[nodiscard]] StageStatus runFollow(Follow<Det>& follow, const IterationParameters<Det>& parameters, const Frame& frame, const TimeframePlan<Det>& plan, std::uint32_t trackOffset, bool earlier, std::size_t& tracks, std::size_t& outward, std::size_t& inward)
+  {
+    const auto status = follow.run(fitForEach(), parameters, frame, *mGeometry, *mMaterial, mPropagator, mRefit.tracks(), trackOffset, parameters.sharedInnermost == 0U, earlier, mUsed, plan.layerMaxWidthPS, mSensorCells.view());
+    if (status != StageStatus::kComplete) {
+      return status;
+    }
+    for (const auto& proposal : follow.proposals()) {
+      tracks += static_cast<std::size_t>(proposal.outwardCount + proposal.inwardCount != 0U);
+      outward += proposal.outwardCount;
+      inward += proposal.inwardCount;
+    }
+    return status;
+  }
+
+  /// \a body() with its profile \a into open and \a phase's zone, where
+  /// profiling is on; plain otherwise.
+  template <typename Body>
+  void profiled(profile::Profile& into, Phase phase, const Body& body)
+  {
+    if (!mProfiling) {
+      body();
+      return;
+    }
+    const profile::Activation activation{into, mMemoryPool.get(), mTrace};
+    const profile::Zone zone{phase};
+    body();
+  }
+
+  /// The tracks from \a trackOffset on that \a parameters do not keep after
+  /// the follow (`keptAfterFollow`: fewer clusters than its length after
+  /// it, or below its pT floor), dropped: the others keep their order, and their proposals with them when
+  /// \a followed, and the follow's starting states when \a started kept
+  /// them for an observer. The used mask becomes the one before the
+  /// selection plus the rows of every kept track, marked as they are now: a dropped track's rows
+  /// no kept one holds are free again, an earlier iteration's are untouched.
+  /// Returns how many were dropped.
+  std::size_t dropShortTracks(const IterationParameters<Det>& parameters, std::uint32_t trackOffset, bool followed, bool started)
+  {
+    auto& tracks = mRefit.tracks();
+    const auto view = std::as_const(tracks).view();
+    const auto count = static_cast<Index>(tracks.size() - trackOffset);
+    const auto chunk = spreadChunk(count);
+    const auto forEach = forEachIn(chunk);
+    // The kept tracks, as offsets from trackOffset, in order (the serial
+    // loop's result, in parallel).
+    host_algorithms::compactIndices(forEach, count, chunk, [&](Index track) { return keptAfterFollow(parameters, view.count[trackOffset + track], view.state[trackOffset + track]); }, mKeptTracks);
+    const auto kept = static_cast<Index>(mKeptTracks.size());
+    // Their rows as they are now; two kept tracks sharing a row write the same value.
+    forEachIn(spreadChunk(kept))(kept, [&](Index at) {
+      const auto track = trackOffset + mKeptTracks[at];
+      for (std::uint8_t i = 0U; i < view.count[track]; ++i) {
+        const auto row = view.clusters[track].index[i];
+        std::atomic_ref<std::uint8_t>{mUsedBeforeSelection[row]}.store(mUsed[row], std::memory_order_relaxed);
+      }
+    });
+    // Up to the first dropped track every kept one stays where it is; from it
+    // on each moves down, through a scratch: in place, a parallel move would
+    // overwrite tracks still to be read.
+    const auto first = o2::gpu::CAAlgo::partitionPoint(Index{0U}, kept, [&](Index at) { return mKeptTracks[at] == at; });
+    const auto moved = kept - first;
+    if (moved != 0U) {
+      const auto forEachMoved = forEachIn(spreadChunk(moved));
+      mDropScratch.resizeRewritten(moved);
+      forEachMoved(moved, [&](Index at) { mDropScratch.write(at, tracks.read(trackOffset + mKeptTracks[first + at])); });
+      forEachMoved(moved, [&](Index at) { tracks.write(trackOffset + first + at, mDropScratch.read(at)); });
+      if (followed) {
+        mFollow.keepProposals(std::span<const Index>{mKeptTracks}.subspan(first), first, forEachMoved);
+      }
+      if (started) {
+        for (Index at = first; at < kept; ++at) {
+          mFollowStartInner[at] = mFollowStartInner[mKeptTracks[at]];
+          mFollowStart[at] = mFollowStart[mKeptTracks[at]];
+          mFollowStartCount[at] = mFollowStartCount[mKeptTracks[at]];
+        }
+      }
+    }
+    const std::size_t dropped = count - kept;
+    tracks.resize(trackOffset + kept);
+    if (followed) {
+      mFollow.truncateProposals(kept);
+    }
+    if (started) {
+      mFollowStartInner.resize(kept);
+      mFollowStart.resize(kept);
+      mFollowStartCount.resize(kept);
+    }
+    copyInParallel(std::span<const std::uint8_t>{mUsedBeforeSelection}, std::span<std::uint8_t>{mUsed});
+    return dropped;
+  }
+
+  /// \a from copied into \a to (as long), on the host threads.
+  template <typename T>
+  void copyInParallel(std::span<const T> from, std::span<T> to)
+  {
+    const auto count = static_cast<Index>(from.size());
+    forEachIn(spreadChunk(count))(count, [&](Index at) { to[at] = from[at]; });
+  }
+
+  /// The tracklet stage over host memory of \a inputs, as `runPlannedSlice`
+  /// runs it, reading \a beamLine for a beam-line iteration (the general
+  /// one; the beam-line one for a beam-line iteration, which makes the same
+  /// tracklets, and the displaced one for a displaced iteration, which no
+  /// other makes).
+  template <bool BeamLine, bool Displaced, bool Shape>
+  [[nodiscard]] TrackletStageFor<Det, BeamLine, Displaced, Shape> trackletStage(const TrackletInputs<Det>& inputs, const Frame& frame, const VertexSeed& beamLine, std::span<const VertexSeed> vertices, const VertexWindows& vertexWindows) const
+  {
+    return {*inputs.parameters, *inputs.sources, frame, inputs.targetBlocks, beamLine, vertices, inputs.maxCandidateWidthPS, vertexWindows, mUsed.data(), inputs.gate};
+  }
+
+  struct LayeredNeighbours {
+    NeighbourStage<Det> body;
+    std::array<Index, kLayerCount + 1U> layerBoundaries;
+    LayerDepthGroups<Det> layerGroups = ::o2::gtrk::layerDepthGroups<Det>;
+    template <typename Emitter>
+    void operator()(Index element, Emitter& emitter) const
+    {
+      body(element, emitter);
+    }
+  };
+
+  /// One planned slice of iteration \a iteration, tracklets to levels, with
+  /// \a plan's frame-wide bounds; the stage reads \a beamLine or \a
+  /// vertices, as the iteration chose, and its gate the core ranges of \a
+  /// owner, the slice the caller keeps.
+  [[nodiscard]] Result runPlannedSlice(std::size_t iteration, const Frame& frame, const TimeframePlan<Det>& plan, const SlicePlan<Det>& slicePlan, const typename Frame::TimeSlice& owner, const VertexSeed& beamLine, std::span<const VertexSeed> vertices, const VertexWindows& vertexWindows, bool countRoads)
+  {
+    assert(iteration < mIterations.size() && mUsed.size() == frame.size());
+    const profile::Zone zone{Phase::kSlices};
+    mIteration = iteration;
+    const StageStatus status = guardOutOfMemory([&] {
+      auto result = StageStatus::kComplete;
+      {
+        const profile::Zone trackletZone{Phase::kTracklets};
+        std::optional<profile::Zone> setup{std::in_place, Phase::kTrackletSetup};
+        beginTrackletSlice(plan, slicePlan, owner);
+        const auto& parameters = *mTrackletInputs.parameters;
+        result = withTrackletVertices(parameters.vertexSource, parameters.impactMax > 0.F, [&](auto beamLineOnly, auto displaced) {
+          return withShapeTest(parameters.shapeTest, [&](auto shape) {
+            const auto stage = trackletStage<decltype(beamLineOnly)::value, decltype(displaced)::value, decltype(shape)::value>(mTrackletInputs, frame, beamLine, vertices, vertexWindows);
+            setup.reset();
+            return mTrackletStage.run(mScratch.tracklets(), mChunkSize, stage);
+          });
+        });
+        if (result == StageStatus::kComplete) {
+          // Each source's tracklets in (link, lambda, target) order, which the
+          // triplet stage searches.
+          {
+            const profile::Zone sortZone{Phase::kTrackletSort};
+            auto& tracklets = mScratch.tracklets();
+            const auto view = tracklets.view();
+            const auto offsets = tracklets.offsets();
+            mTrackletStage.forEachElement(tracklets.elementCount(), mChunkSize, [&](Index element) { sortTrackletSegmentOnHost(view, offsets[element], offsets[element + 1U]); });
+          }
+        }
+      }
+      if (result != StageStatus::kComplete) {
+        return result;
+      }
+      const auto triplets = runTriplets(frame, plan);
+      if (triplets != StageStatus::kComplete) {
+        return triplets;
+      }
+      return runNeighbours(frame, owner, countRoads);
+    });
+    if (status == StageStatus::kComplete) {
+      mTrackletHighWater = std::max<std::size_t>(mTrackletHighWater, mScratch.tracklets().size());
+      mStagingHighWater = std::max(mStagingHighWater, mTrackletStage.stagingCapacity());
+    }
+    const bool complete = status == StageStatus::kComplete;
+    return {
+      .status = status,
+      .tracklets = complete ? &mScratch.tracklets() : nullptr,
+      .triplets = complete ? &mScratch.triplets() : nullptr,
+      .neighbours = complete ? &mScratch.neighbours() : nullptr,
+    };
+  }
+
+  /// The triplet stage, its staged triplets kept only where they are on a
+  /// triplet path of the iteration's minClusters: the bounds built from the staged triplets, then each chunk's
+  /// compacted before the place. The others make no neighbour, as element or
+  /// as predecessor (NeighbourStage.h), and in a low-pT pass they are most of
+  /// the triplets.
+  template <typename Stage>
+  struct OnPathTriplets {
+    Tracker* tracker = nullptr;
+    const Stage* stage = nullptr;
+
+    template <typename Emitter>
+    void operator()(Index element, Emitter& emitter) const
+    {
+      (*stage)(element, emitter);
+    }
+
+    template <typename Staged>
+    void filterStaged(const Staged& staged) const
+    {
+      const profile::Zone zone{Phase::kTripletPaths};
+      auto& scratch = tracker->mScratch;
+      auto& paths = scratch.tripletPaths();
+      paths.build(tracker->parameters(), scratch.sources(), scratch.tracklets(), scratch.permutation(), [&](Index begin, Index end, const auto& body) { staged.forEach(begin, end, [&](Index element, const auto& triplets, std::size_t at) { body(element, triplets.first[at], triplets.second[at]); }); }, tracker->hostForEach());
+      staged.compact([&](Index /*element*/, const auto& triplets, std::size_t at) { return paths.onPath(triplets.first[at], triplets.second[at]); });
+    }
+  };
+
+  /// The fit of the counted roads (with \a NominalOnly, those of nominal
+  /// triplets) with iteration \a owner's settings into \a records, whose
+  /// staging is that iteration's. An iteration with the beam constraint fits
+  /// on the stage that also tests the beam line; the host alone makes it.
+  template <bool NominalOnly>
+  [[nodiscard]] StageStatus fitRoads(const Frame& frame, std::size_t owner, Records& records)
+  {
+    const auto roads = mRoads.roadCount();
+    mIteration = owner;
+    const auto& fitted = mIterations[owner];
+    std::optional<profile::Zone> setup{std::in_place, Phase::kRoadFitSetup};
+    records.prepare(roads);
+    const auto run = [&]<bool BeamLine, bool LastStepAllowance, bool InnerTrim>() {
+      const RoadFitStage<Det, Material, BeamLine, NominalOnly, LastStepAllowance, InnerTrim> stage{fitted, frame, *mGeometry, *mMaterial, mPropagator, mScratch.tracklets(), mScratch.triplets(), mRoads.walk(mScratch.triplets(), mScratch.neighbours())};
+      setup.reset();
+      return mRecordStage.run(records, fitChunk(static_cast<Index>(roads)), stage);
+    };
+    // An iteration with a kink allowance takes it on the fit's last step
+    // (against the road-end fakes); one with innerTrim fits a refused road
+    // again without its innermost clusters.
+    return withBools([&]<bool BeamLine, bool LastStepAllowance, bool InnerTrim>(std::bool_constant<BeamLine>, std::bool_constant<LastStepAllowance>, std::bool_constant<InnerTrim>) { return run.template operator()<BeamLine, LastStepAllowance, InnerTrim>(); }, fitted.beamConstraint, takesLastStepAllowance(fitted), fitted.innerTrim != 0U);
+  }
+
+  /// The slice's roads, fitted, into the selection. With \a sharesNext, the graph
+  /// is iteration \a iteration + 1's: the nominal round's roads, fitted with
+  /// \a iteration's settings, go to its selection, and every other road,
+  /// fitted with the next one's, to the next one's (`mShared`).
+  [[nodiscard]] StageStatus runRoads(const Frame& frame, IterationSummary& summary, std::size_t iteration, bool sharesNext)
+  {
+    const auto counted = countRoads();
+    if (counted != StageStatus::kComplete) {
+      return counted;
+    }
+    summary.roads += mRoads.roadCount();
+    // With sharesNext this iteration's roads are the nominal triplets'; the
+    // next one fits every road with its own settings, as its own graph would
+    // give them: the selection then drops what conflicts with the tracks
+    // held before it.
+    auto fitted = sharesNext ? fitRoads<true>(frame, iteration, mRecords) : fitRoads<false>(frame, iteration, mRecords);
+    if (fitted == StageStatus::kComplete && sharesNext) {
+      fitted = fitRoads<false>(frame, iteration + 1U, mSharedRecords);
+    }
+    if (fitted != StageStatus::kComplete) {
+      return fitted;
+    }
+    const profile::Zone zone{Phase::kSelectionAppend};
+    if (sharesNext) {
+      const auto appended = mShared.append(mSharedRecords, spreadForEach());
+      if (appended != StageStatus::kComplete) {
+        return appended;
+      }
+    }
+    return mSelection.append(mRecords, spreadForEach());
+  }
+
+  /// The slice's roads numbered from the counts that came with the
+  /// neighbours (`runNeighbours`, countRoads): `RoadCount::runPrepared`.
+  [[nodiscard]] StageStatus countRoads()
+  {
+    return guardOutOfMemory([&] {
+      const profile::Zone zone{Phase::kRoadCount};
+      return mRoads.runPrepared(hostForEach(), roadStartRule(parameters()), mScratch.tracklets(), mScratch.triplets(), mChunkSize);
+    });
+  }
+
+  /// The slice's source map in the scratch, and the other inputs of its
+  /// tracklet stage, from its plan and \a plan's widths, in mTrackletInputs.
+  void beginTrackletSlice(const TimeframePlan<Det>& plan, const SlicePlan<Det>& slicePlan, const typename Frame::TimeSlice& owner)
+  {
+    mScratch.beginSlice(slicePlan.sources);
+    mTrackletInputs = slicePlan.inputs(parameters(), plan.layerMaxWidthPS);
+    mTrackletInputs.sources = &mScratch.sources();
+    mTrackletInputs.gate.core = owner.core.data();
+  }
+
+  /// The triplet stage over the slice's sorted tracklets: the first-tracklet
+  /// order, then generate/scan/place with \a plan's target bounds.
+  [[nodiscard]] StageStatus runTriplets(const Frame& frame, const TimeframePlan<Det>& plan)
+  {
+    const profile::Zone zone{Phase::kTriplets};
+    auto& permutation = mScratch.permutation();
+    const auto& tracklets = mScratch.tracklets();
+    auto& trackletPaths = mScratch.trackletPaths();
+    {
+      const profile::Zone pathsZone{Phase::kTrackletPaths};
+      trackletPaths.build(parameters(), mScratch.sources(), tracklets, hostForEach());
+    }
+    const auto paths = trackletPaths.bounds();
+    auto ordered = StageStatus::kComplete;
+    {
+      const profile::Zone permutationZone{Phase::kPermutation};
+      ordered = permutation.build(parameters(), mScratch.sources(), tracklets, paths, hostForEach(), mChunkSize);
+    }
+    if (ordered != StageStatus::kComplete) {
+      return ordered;
+    }
+    auto& triplets = mScratch.triplets();
+    std::optional<profile::Zone> setup{std::in_place, Phase::kTripletSetup};
+    triplets.prepare(permutation.size());
+    const auto result = withShapeTest(parameters().shapeTest, [&](auto shape) {
+      const TripletStage<Det, decltype(shape)::value> stage{parameters(), mScratch.sources(), frame, tracklets, plan.layerTargetBounds.data(), permutation.data(), paths};
+      setup.reset();
+      return mTripletStage.run(triplets, mChunkSize, OnPathTriplets<TripletStage<Det, decltype(shape)::value>>{this, &stage});
+    });
+    if (result == StageStatus::kComplete) {
+      mTripletHighWater = std::max<std::size_t>(mTripletHighWater, triplets.size());
+    }
+    return result;
+  }
+
+  /// The neighbour stage over every triplet, pulling its predecessors from
+  /// the triplets ending with its first tracklet.
+  [[nodiscard]] StageStatus runNeighbours(const Frame& frame, const typename Frame::TimeSlice& owner, bool countRoads)
+  {
+    const profile::Zone zone{Phase::kNeighbours};
+    auto& triplets = mScratch.triplets();
+    auto& ending = mScratch.ending();
+    auto indexed = StageStatus::kComplete;
+    {
+      const profile::Zone indexZone{Phase::kEndIndex};
+      // One task per chunk or bucket of the index's two-level sort.
+      indexed = ending.build(mScratch.tracklets().size(), triplets, forEachIn(1U), fitChunkCount());
+    }
+    if (indexed != StageStatus::kComplete) {
+      return indexed;
+    }
+    const auto& tripletPaths = mScratch.tripletPaths();
+    const auto paths = tripletPaths.bounds();
+    auto& neighbours = mScratch.neighbours();
+    std::optional<profile::Zone> setup{std::in_place, Phase::kNeighbourSetup};
+    neighbours.prepare(triplets.size());
+    // Layer by layer, each triplet's level final when it is generated, and
+    // with \a countRoads the road counts with it (`OrderedRoadCounts`).
+    OrderedRoadCounts counts;
+    if (countRoads) {
+      mRoads.prepareOrdered(hostForEach(), triplets.size());
+      // A start-layer mask empties the core of the layers roads may not start on.
+      const auto startLayers = parameters().roadStartLayers;
+      if (startLayers != 0U) {
+        mRoadCores = roadCores(std::span<const MeasurementRange, kLayerCount>{owner.core}, startLayers);
+      }
+      counts = mRoads.ordered(parameters().linkSources, startLayers != 0U ? mRoadCores.data() : owner.core.data());
+    }
+    // Each layer's first triplet: its first permuted tracklet's (`TripletPaths::layerElements`).
+    std::array<Index, kLayerCount + 1U> boundaries{};
+    for (std::size_t layer = 0U; layer <= kLayerCount; ++layer) {
+      boundaries[layer] = triplets.offsets()[tripletPaths.layerElements()[layer]];
+    }
+    const NeighbourStage<Det> stage{parameters(), frame, mScratch.tracklets(), triplets, ending, paths, triplets.view().level, counts};
+    setup.reset();
+    const auto result = mNeighbourStage.run(neighbours, mChunkSize, LayeredNeighbours{stage, boundaries});
+    if (result == StageStatus::kComplete) {
+      mNeighbourHighWater = std::max<std::size_t>(mNeighbourHighWater, neighbours.size());
+    }
+    return result;
+  }
+
+  /// body(i) for every i in [0, count) on the host threads, in chunks of the
+  /// stages' size: the host algorithms' `forEach` (HostAlgorithms.h).
+  [[nodiscard]] auto hostForEach() { return forEachIn(mChunkSize); }
+
+  /// `hostForEach` in chunks of \a chunk elements.
+  [[nodiscard]] auto forEachIn(Index chunk)
+  {
+    return [this, chunk](Index count, const auto& body) { mNeighbourStage.forEachElement(count, chunk, body); };
+  }
+
+  /// `kFitChunksPerThread` chunks per thread of the tracker's arena.
+  [[nodiscard]] Index fitChunkCount() const { return kFitChunksPerThread * static_cast<Index>(std::max(mNeighbourStage.maxConcurrency(), 1)); }
+
+  /// The chunk of a loop over \a elements fits -- the road
+  /// fit, the refit, the follow's passes: about
+  /// `kFitChunksPerThread` chunks per thread, so that the threads end
+  /// together, and never above the stages' chunk. The output does not depend
+  /// on the chunking (StageOutput.h).
+  [[nodiscard]] Index fitChunk(Index elements) const
+  {
+    const auto chunks = fitChunkCount();
+    return std::clamp<Index>((elements + chunks - 1U) / chunks, 1U, mChunkSize);
+  }
+
+  /// `hostForEach` in fit chunks (`fitChunk`).
+  [[nodiscard]] auto fitForEach()
+  {
+    return [this](Index count, const auto& body) { mNeighbourStage.forEachElement(count, fitChunk(count), body); };
+  }
+
+  /// The chunk of a loop over \a elements that are cheap, as copies: the
+  /// elements spread over `kFitChunksPerThread` chunks per thread, however
+  /// many.
+  [[nodiscard]] Index spreadChunk(Index elements) const
+  {
+    const auto chunks = fitChunkCount();
+    return std::max<Index>((elements + chunks - 1U) / chunks, 1U);
+  }
+
+  /// `hostForEach` in spread chunks (`spreadChunk`).
+  [[nodiscard]] auto spreadForEach()
+  {
+    return [this](Index count, const auto& body) { mNeighbourStage.forEachElement(count, spreadChunk(count), body); };
+  }
+
+  std::vector<SearchWindowParams> mWindowSettings;
+  std::vector<IterationParameters<Det>> mIterations;
+  std::size_t mIteration = 0U;
+  VertexSeed mBeamLine;
+  TrackletInputs<Det> mTrackletInputs;
+  SliceObserver mSliceObserver;
+  IterationObserver mIterationObserver;
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  Scratch mScratch;
+  /// The one arena of the tracker's stages and loops, and of a vertexing
+  /// pass's: TBB's workers
+  /// stay with it from one loop to the next.
+  detail::TaskArena mArena;
+  CpuStage<TrackletT> mTrackletStage;
+  CpuStage<TripletT> mTripletStage;
+  CpuStage<NeighbourT> mNeighbourStage;
+  CpuStage<SelectionRecordOf<kMaxClusters>::template RecordT> mRecordStage;
+  RoadCount mRoads;
+  std::array<MeasurementRange, kLayerCount> mRoadCores{}; ///< the slice's core as the road counting reads it, with a start-layer mask
+  Records mRecords;
+  Records mSharedRecords;                ///< a slice's records for the next iteration, which takes this one's graph
+  GlobalSelection<kMaxClusters> mShared; ///< the next iteration's records, over the slices
+  GlobalSelection<kMaxClusters> mSelection;
+  TrackRefit<Det> mRefit;
+  Follow<Det> mFollow;        ///< the iteration's own tracks'
+  Follow<Det> mFollowEarlier; ///< the earlier iterations' tracks', with followEarlier
+  /// What the follow started from, for an iteration observer only.
+  std::vector<BoundTrackState> mFollowStartInner;
+  std::vector<BoundTrackState> mFollowStart;
+  std::vector<std::uint8_t> mFollowStartCount;
+  std::vector<std::uint8_t> mFollowUsed;
+  SensorCells<Det> mSensorCells;
+  BoundedVector<std::uint8_t> mUsed;
+  BoundedVector<std::uint8_t> mUsedBeforeSelection; ///< with a length after the follow (`dropShortTracks`)
+  BoundedVector<Index> mKeptTracks;                 ///< `dropShortTracks`' kept tracks
+  typename TrackRefit<Det>::Tracks mDropScratch;    ///< `dropShortTracks`' moved tracks
+  const TrackingGeometry<Det>* mGeometry = nullptr;
+  const Material* mMaterial = nullptr;
+  Propagator mPropagator;
+  profile::Trace* mTrace = nullptr;
+  bool mProfiling = false;
+  CapacityEstimator mEstimator;
+  std::size_t mRows = 0U;                                        ///< the timeframe's measurement rows
+  std::array<std::size_t, CapacityEstimator::kSites> mGranted{}; ///< per stage, the staging granted per thread
+  Index mChunkSize = 1U;
+  static constexpr Index kFitChunksPerThread = 8U; ///< `fitChunk`
+  std::size_t mTrackletHighWater = 0U;
+  std::size_t mStagingHighWater = 0U;
+  std::size_t mStagingPredictionMisses = 0U;
+  std::size_t mTripletHighWater = 0U;
+  std::size_t mNeighbourHighWater = 0U;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRACKER_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackingSurface.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackingSurface.h
new file mode 100644
index 0000000000000..8ae8c533722a8
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackingSurface.h
@@ -0,0 +1,232 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackingSurface.h
+/// \brief The sensor planes as the tracking sees them, and the conversion
+///        between a bound position and the global frame.
+///
+/// This is the device side of the host-to-tracking boundary: the double
+/// Geometry<Det> narrows here, once, into fixed-size float records;
+/// Geometry<Det> is the host side.
+///
+/// A surface's three axes are the **columns** of Sensor::rot, which is stored
+/// row-major and maps local to global.  Writing the rows instead is a
+/// transpose that a same-surface round trip cannot see, because it would use
+/// the same wrong matrix in both directions.  testTrackingSurface.cxx
+/// therefore checks against Geometry<Det>::toGlobal, an independent
+/// implementation, and not against this file's own inverse.
+
+#ifndef GTRK_TRACKING_TRACKINGSURFACE_H_
+#define GTRK_TRACKING_TRACKINGSURFACE_H_
+
+#include "GenericTracking/Base/Definitions.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/BoundTrackState.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/Trig.h"
+
+#include "GPUCommonMath.h"
+
+#include <array>
+#include <cstdint>
+#include <type_traits>
+
+namespace o2::gtrk
+{
+
+/// The active area of a sensor, a rectangle in its own local frame.
+struct SurfaceBounds {
+  Scalar halfX = 0.F; ///< half width along loc0
+  Scalar halfY = 0.F; ///< half length along loc1
+
+  /// Written so that a NaN coordinate is outside.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool isInside(Scalar loc0, Scalar loc1) const { return loc1 >= -halfY && loc1 <= halfY && loc0 >= -halfX && loc0 <= halfX; }
+};
+
+/// One sensor plane.
+///
+/// Held as a record rather than as columns of a struct-of-arrays because a
+/// propagation reads a whole surface at once -- origin, both in-plane axes and
+/// the normal -- so the fifteen floats travel together.
+struct TrackingSurface {
+  Scalar origin[3]{}; ///< sensor centre in the global frame [cm]
+  Scalar axis0[3]{};  ///< global direction of local loc0
+  Scalar axis1[3]{};  ///< global direction of local loc1
+  Scalar normal[3]{}; ///< global plane normal, axis0 x axis1
+
+  SurfaceBounds bounds{};
+
+  /// The surface's own chip id.  A propagation is handed the surface and not a
+  /// geometry to look it up in, so without this the resulting state could not
+  /// say which plane it is bound to.
+  SensorID id = kInvalidSensorID;
+
+  LayerID layer = kInvalidLayerID;
+
+  /// A curved sensor's own entry is its cylinder, not a plane: the origin a
+  /// point of its axis, axis0 and axis1 the sensor's local x and y, the normal
+  /// its axis, the bounds unrolled, and this the radius its unrolled x is
+  /// measured at (SensorSpec::radius). 0 on a flat sensor, and on the planes
+  /// tangentPlane() makes. [cm]
+  Scalar radius = 0.F;
+  /// On a plane tangentPlane() made: its angle in the sensor, which a state
+  /// bound to it carries (BoundTrackState::surfacePhi). 0 otherwise. [rad]
+  Scalar surfacePhi = 0.F;
+  /// A curved sensor's measurement depth (Geometry::measurementDepth): its
+  /// tangent planes touch at radius + depth, while its unrolled x stays
+  /// measured at the radius. 0 on a flat sensor, whose origin already lies at
+  /// its depth, and on the planes tangentPlane() makes. [cm]
+  Scalar depth = 0.F;
+};
+
+/// The plane touching the curved sensor \a cylinder at its local angle
+/// \a angle, at radius + depth: normal
+/// radial, axis1 along the cylinder's axis, axis0 = axis1 x normal along
+/// increasing angle. Its origin is placed so that the touching point is at
+/// loc0 = radius * angle, loc1 = 0 at the axis point: a point of the sensor near there has its unrolled
+/// coordinates as its plane coordinates, and a measurement keeps its own. The
+/// bounds are the sensor's unrolled ones.
+GPUhdi() GPUAlwaysInline() TrackingSurface tangentPlane(const TrackingSurface& cylinder, Scalar angle)
+{
+  Scalar sinAngle = 0.F;
+  Scalar cosAngle = 0.F;
+  sincosOf(angle, sinAngle, cosAngle);
+  TrackingSurface plane = cylinder;
+  const Scalar arc = cylinder.radius * angle;
+  for (int i = 0; i < 3; ++i) {
+    const Scalar radial = cosAngle * cylinder.axis0[i] + sinAngle * cylinder.axis1[i];
+    const Scalar along = -sinAngle * cylinder.axis0[i] + cosAngle * cylinder.axis1[i];
+    plane.origin[i] = cylinder.origin[i] + (cylinder.radius + cylinder.depth) * radial - arc * along;
+    plane.axis0[i] = along;
+    plane.axis1[i] = cylinder.normal[i];
+    plane.normal[i] = radial;
+  }
+  plane.radius = 0.F;
+  plane.depth = 0.F;
+  plane.surfacePhi = angle;
+  return plane;
+}
+
+/// global = origin + loc0 * axis0 + loc1 * axis1
+GPUhdi() GPUAlwaysInline() void surfaceToGlobal(const TrackingSurface& s, Scalar loc0, Scalar loc1, Scalar g[3])
+{
+  for (int i = 0; i < 3; ++i) {
+    g[i] = s.origin[i] + loc0 * s.axis0[i] + loc1 * s.axis1[i];
+  }
+}
+
+/// The inverse, including the out-of-plane component.
+///
+/// l[2] is returned rather than discarded so that a caller can check that a
+/// point it believes is on the surface actually is, instead of assuming it.
+GPUhdi() GPUAlwaysInline() void surfaceToLocal(const TrackingSurface& s, const Scalar g[3], Scalar l[3])
+{
+  const Scalar d0 = g[0] - s.origin[0];
+  const Scalar d1 = g[1] - s.origin[1];
+  const Scalar d2 = g[2] - s.origin[2];
+  l[0] = d0 * s.axis0[0] + d1 * s.axis0[1] + d2 * s.axis0[2];
+  l[1] = d0 * s.axis1[0] + d1 * s.axis1[1] + d2 * s.axis1[2];
+  l[2] = d0 * s.normal[0] + d1 * s.normal[1] + d2 * s.normal[2];
+}
+
+/// \a n dot \a d, the cosine of incidence on a surface.  Its magnitude is what
+/// the grazing check thresholds on.
+GPUhdi() GPUAlwaysInline() Scalar cosIncidence(const TrackingSurface& s, const Scalar d[3]) { return s.normal[0] * d[0] + s.normal[1] * d[1] + s.normal[2] * d[2]; }
+
+/// Every sensor plane of one detector, as the tracking sees them.
+///
+/// Fixed extent, so the whole thing is one contiguous block sized at compile
+/// time and uploads as a single buffer.  Built from Geometry<Det>, which is
+/// double and stays on the host; this is where that narrows.
+template <DetectorLayout Det>
+class TrackingGeometry
+{
+ public:
+  explicit TrackingGeometry(const Geometry<Det>& geo) { build(geo); }
+
+  /// A sensor's own entry: its plane, or a curved sensor's cylinder
+  /// (TrackingSurface::radius). Its layer is the sensor's either way.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() const TrackingSurface& surface(SensorID id) const { return mSurfaces[id]; }
+
+  /// What planeOf returns: the table entry itself where every sensor is flat,
+  /// a plane built on the spot where some are curved.
+  using Plane = std::conditional_t<Detector<Det>::hasCurvedSensors, TrackingSurface, const TrackingSurface&>;
+
+  /// The plane a state is bound to: its sensor's, or on a curved sensor the
+  /// tangent plane at the state's angle.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Plane planeOf(const BoundTrackState& state) const { return plane(state.surface, state.surfacePhi); }
+
+  /// The plane a measurement is on: its sensor's, or on a curved sensor the
+  /// tangent plane where it sits, at the angle its unrolled loc0 gives.
+  template <typename M>
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Plane planeOf(const M& measurement) const
+  {
+    if constexpr (Detector<Det>::hasCurvedSensors) {
+      const TrackingSurface& s = mSurfaces[measurement.surface];
+      return s.radius > 0.F ? tangentPlane(s, measurement.loc0 / s.radius) : s;
+    } else {
+      return mSurfaces[measurement.surface];
+    }
+  }
+
+  /// Sensor \a id's plane, or a curved sensor's tangent plane at \a angle.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Plane plane(SensorID id, [[maybe_unused]] Scalar angle) const
+  {
+    if constexpr (Detector<Det>::hasCurvedSensors) {
+      const TrackingSurface& s = mSurfaces[id];
+      return s.radius > 0.F ? tangentPlane(s, angle) : s;
+    } else {
+      return mSurfaces[id];
+    }
+  }
+
+  [[nodiscard]] const std::array<TrackingSurface, Det::nSensors>& surfaces() const { return mSurfaces; }
+
+ private:
+  void build(const Geometry<Det>& geo);
+
+  std::array<TrackingSurface, Det::nSensors> mSurfaces{};
+};
+
+template <DetectorLayout Det>
+void TrackingGeometry<Det>::build(const Geometry<Det>& geo)
+{
+  for (SensorID id = 0; id < static_cast<SensorID>(Det::nSensors); ++id) {
+    const Sensor& src = geo.sensor(id);
+    const SensorSpec& spec = geo.specOf(id);
+    TrackingSurface& dst = mSurfaces[id];
+    // A flat sensor's plane at its layer's measurement depth, along its normal.
+    const double depth = geo.measurementDepth(src.layer);
+    const double shift = spec.curved() ? 0. : depth;
+
+    for (int i = 0; i < 3; ++i) {
+      dst.origin[i] = static_cast<Scalar>(src.trans[i] + (shift * src.rot[3 * i + 2]));
+      // Columns, not rows: rot is row-major local -> global, so column j is
+      // the global direction of local axis j.
+      dst.axis0[i] = static_cast<Scalar>(src.rot[3 * i + 0]);
+      dst.axis1[i] = static_cast<Scalar>(src.rot[3 * i + 1]);
+      dst.normal[i] = static_cast<Scalar>(src.rot[3 * i + 2]);
+    }
+
+    dst.bounds.halfX = static_cast<Scalar>(spec.halfX);
+    dst.bounds.halfY = static_cast<Scalar>(spec.halfY);
+    dst.radius = spec.curved() ? static_cast<Scalar>(spec.radius) : 0.F;
+    dst.depth = spec.curved() ? static_cast<Scalar>(depth) : 0.F;
+
+    dst.id = id;
+    dst.layer = src.layer;
+  }
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRACKINGSURFACE_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Tracklet.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Tracklet.h
new file mode 100644
index 0000000000000..6a8fc74009651
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Tracklet.h
@@ -0,0 +1,77 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Tracklet.h
+/// \brief A tracklet as SoA columns: two measurement rows, their link and the
+///        chord's direction.
+///
+/// A tracklet joins a *source* -- the inner measurement whose position and
+/// time open the grid query -- to a *target*, the outer measurement the query
+/// found and the pair cut accepted. Both are global measurement rows of the
+/// timeframe; `Measurement::clusterIndex` leads from a row back to its cluster.
+///
+/// `link` indexes `Det::layerLinks`. The rows imply it, but only through a
+/// search over the layer boundaries; the triplet stage needs it for every
+/// combination it forms, because one source's range mixes all of its layer's
+/// outgoing links and the tolerances and scattering terms are per link.
+///
+/// `lambda` and `phi` are the direction of the chord from source to target.
+/// They are computed once per accepted tracklet and cached for the triplet
+/// stage's pre-cut: a middle row's outgoing tracklets are contiguous, so
+/// comparing cached directions is a contiguous read where each outer position
+/// would be a gather from the measurement columns.
+///
+/// The dip angle is stored rather than tan(lambda). Between two discs a
+/// forward track's transverse chord is short while dz is the disc spacing, so
+/// dz over the chord grows without bound and is dominated by the position
+/// resolution; atan2(dz, chord) stays in [-pi/2, pi/2] and well conditioned
+/// for every kind of link. The chord's azimuth has no such cure: its error
+/// grows as the r-phi resolution over the chord, which the triplet stage's
+/// tolerance has to carry.
+
+#ifndef GTRK_TRACKING_TRACKLET_H_
+#define GTRK_TRACKING_TRACKLET_H_
+
+#include "GenericTracking/Tracking/Definitions.h"
+
+#include <memlayout/wrapper.h>
+
+#include <cstdint>
+
+namespace o2::gtrk
+{
+
+// As for MeasurementT: an SoA element proxy holds references, and `apply` is
+// upstream's macro, which also uses the camelBack member names as enum
+// constants.
+// NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members,cppcoreguidelines-missing-std-forward,readability-identifier-naming)
+template <template <class> class C>
+struct TrackletT {
+  MEMLAYOUT_APPLY(TrackletT, source, target, link, lambda, phi)
+  C<std::uint32_t> source, target; ///< global measurement rows
+  C<std::uint16_t> link;           ///< index into Det::layerLinks
+  C<Scalar> lambda;                ///< atan2(dz, transverse chord), source to target, in [-pi/2, pi/2]
+  C<Scalar> phi;                   ///< atan2(dy, dx) of the chord, source to target, in [-pi, pi]
+};
+// NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members,cppcoreguidelines-missing-std-forward,readability-identifier-naming)
+
+/// One tracklet record, used by emitters and host-side validation.
+using Tracklet = TrackletT<memlayout::value>;
+
+/// The columns in a stage's arena, as the tracklet stage writes them.
+using TrackletView = memlayout::Wrapper<TrackletT, memlayout::pointer, memlayout::Layout::soa>;
+
+/// The same columns, as every later stage reads them.
+using TrackletConstView = memlayout::Wrapper<TrackletT, memlayout::const_pointer, memlayout::Layout::soa>;
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRACKLET_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackletPaths.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackletPaths.h
new file mode 100644
index 0000000000000..62a082c9d0d1a
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackletPaths.h
@@ -0,0 +1,184 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackletPaths.h
+/// \brief The longest tracklet paths through and from each measurement, which
+///        bound the chains a triplet can be on.
+
+#ifndef GTRK_TRACKING_TRACKLETPATHS_H_
+#define GTRK_TRACKING_TRACKLETPATHS_H_
+
+#include "GenericTracking/Base/LayerLinks.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/LayerRowMap.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+
+#include "GPUCommonMath.h"
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace o2::gtrk
+{
+
+/// Upper bounds from the actual tracklet DAG, ignoring triplet/neighbour cuts.
+/// A triplet a -> b -> c can be on a chain the
+/// iteration uses only when a longest prefix ending at a, these two links, and
+/// a suffix from c to an allowed road end together contain at least the
+/// iteration's minClusters measurements. TrackletPaths indexes its bounds by
+/// the slice's source element (LayerRowMap::element), TripletPaths by tracklet.
+struct TrackletPathBounds {
+  const std::uint8_t* prefix = nullptr;
+  const std::uint8_t* suffix = nullptr;
+  std::uint32_t minClusters = 0U;
+
+  /// Whether a chain through \a before's prefix and \a after's suffix can
+  /// reach minClusters.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool onPath(std::uint32_t before, std::uint32_t after) const { return suffix[after] != 0U && std::uint32_t{prefix[before]} + suffix[after] >= minClusters; }
+};
+
+/// Whether a road may end on \a layer (`IterationParameters::roadEndLayers`, 0 for any).
+GPUhdi() GPUAlwaysInline() bool roadMayEnd(std::uint64_t endLayers, LayerID layer) { return endLayers == 0U || ((endLayers >> layer) & 1U) != 0U; }
+
+/// The measurement suffix of \a row on \a layer: its source element's, or,
+/// for a row that is no source of the slice and so has no tracklets, one
+/// cluster where a road may end and none elsewhere.
+template <DetectorLayout Det>
+GPUhdi() GPUAlwaysInline() std::uint32_t measurementSuffix(const TrackletPathBounds& paths, const LayerRowMap<Det>& sources, std::uint64_t endLayers, LayerID layer, std::uint32_t row)
+{
+  if (sources.contains(layer, row)) {
+    return paths.suffix[sources.element(layer, row)];
+  }
+  return roadMayEnd(endLayers, layer) ? 1U : 0U;
+}
+
+/// The forward sweep's step from source element \a element: each of its
+/// tracklets raises its target's prefix to the element's plus one, by an
+/// atomic maximum (the sweep runs in parallel). \a Prefix is a byte on the
+/// host and a 32-bit word on a device, which has no byte atomics.
+template <DetectorLayout Det, typename Prefix>
+GPUdi() GPUAlwaysInline() void raiseTargetPrefixes(const IterationParameters<Det>& parameters, const LayerRowMap<Det>& sources, TrackletConstView tracklets, const std::uint32_t* offsets, std::uint32_t element, Prefix* prefix)
+{
+  const auto length = static_cast<Prefix>(prefix[element] + 1U);
+  for (std::uint32_t edge = offsets[element]; edge < offsets[element + 1U]; ++edge) {
+    const LayerID targetLayer = parameters.linkTargets[tracklets.link[edge]];
+    if (sources.contains(targetLayer, tracklets.target[edge])) {
+      o2::gpu::CAMath::AtomicMax(prefix + sources.element(targetLayer, tracklets.target[edge]), length);
+    }
+  }
+}
+
+/// The reverse sweep's suffix of source element \a element on \a layer: one
+/// cluster where a road may end, or one more than the longest suffix of its
+/// tracklets' targets, which \a partial holds final.
+template <DetectorLayout Det>
+GPUhdi() GPUAlwaysInline() std::uint32_t measurementPathSuffix(const TrackletPathBounds& partial, const IterationParameters<Det>& parameters, const LayerRowMap<Det>& sources, TrackletConstView tracklets, const std::uint32_t* offsets, LayerID layer, std::uint32_t element)
+{
+  std::uint32_t length = roadMayEnd(parameters.roadEndLayers, layer) ? 1U : 0U;
+  for (std::uint32_t edge = offsets[element]; edge < offsets[element + 1U]; ++edge) {
+    const std::uint32_t after = measurementSuffix(partial, sources, parameters.roadEndLayers, parameters.linkTargets[tracklets.link[edge]], tracklets.target[edge]);
+    if (after != 0U && length < after + 1U) {
+      length = after + 1U;
+    }
+  }
+  return length;
+}
+
+/// `body(layer, index)` for every index of the layers of depth group \a group
+/// of the link DAG (LayerLinks.h, `layerDepthGroups`), each layer's indices in
+/// [rangeBegin(layer), rangeEnd(layer)), in one \a forEach over all of them.
+/// No link joins two layers of one depth and every link into them comes from
+/// a smaller depth, so a sweep's invariant -- a layer's predecessors final
+/// before it -- holds depth by depth, forward or back.
+template <DetectorLayout Det, typename ForEach, typename Begin, typename End, typename Body>
+void forEachOfDepth(const ForEach& forEach, std::size_t group, const Begin& rangeBegin, const End& rangeEnd, const Body& body)
+{
+  using Index = StageOutput<TrackletT>::Index;
+  constexpr auto groups = layerDepthGroups<Det>;
+  std::array<LayerID, LayerDepthGroups<Det>::kLayers> layers{};
+  std::array<Index, LayerDepthGroups<Det>::kLayers> bases{};
+  std::array<Index, LayerDepthGroups<Det>::kLayers + 1U> starts{};
+  std::size_t count = 0U;
+  for (auto at = groups.groups[group]; at < groups.groups[group + 1U]; ++at) {
+    layers[count] = groups.order[at];
+    bases[count] = rangeBegin(layers[count]);
+    starts[count + 1U] = starts[count] + (rangeEnd(layers[count]) - bases[count]);
+    ++count;
+  }
+  forEach(starts[count], [&](Index index) {
+    std::size_t i = 0U;
+    while (index >= starts[i + 1U]) {
+      ++i;
+    }
+    body(layers[i], static_cast<Index>(bases[i] + (index - starts[i])));
+  });
+}
+
+/// The bounds of a slice, built by two topological sweeps over its sources;
+/// no fits and no new physics threshold. Removing a path that fails this
+/// necessary condition cannot remove an accepted road. Bounds deliberately
+/// ignore time-box intersections and core ownership.
+template <DetectorLayout Det>
+class TrackletPaths
+{
+ public:
+  using Index = StageOutput<TrackletT>::Index;
+  static_assert(maxChainLayers<Det> <= 255U);
+
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
+  {
+    mPool = std::move(pool);
+    clearStorage();
+  }
+
+  void clearStorage() noexcept { deepVectorClear(mPool.get(), mPrefix, mSuffix); }
+
+  /// \a forEach may run in parallel: the prefix's maxima are atomic.
+  template <typename ForEach>
+  void build(const IterationParameters<Det>& parameters, const LayerRowMap<Det>& sources, const StageOutput<TrackletT>& tracklets, const ForEach& forEach)
+  {
+    // Kept from slice to slice and filled in parallel, not reallocated:
+    // the prefix's floor of one measurement.
+    resizeBoundedVector(mPrefix, sources.size());
+    resizeBoundedVector(mSuffix, sources.size());
+    forEach(static_cast<Index>(sources.size()), [&](Index element) { mPrefix[element] = std::uint8_t{1U}; });
+    mMinClusters = parameters.minClusters;
+    const auto view = tracklets.view();
+    const auto offsets = tracklets.offsets();
+    // The layers of one depth of the link DAG in one pass (`forEachOfDepth`).
+    constexpr auto groups = layerDepthGroups<Det>;
+    const auto elementBegin = [&](LayerID layer) { return static_cast<Index>(sources.offsets[layer]); };
+    const auto elementEnd = [&](LayerID layer) { return static_cast<Index>(sources.offsets[layer] + sources.ranges[layer].size()); };
+    for (std::size_t group = 0U; group < groups.count; ++group) {
+      forEachOfDepth<Det>(forEach, group, elementBegin, elementEnd, [&](LayerID /*layer*/, Index element) { raiseTargetPrefixes(parameters, sources, view, offsets.data(), element, mPrefix.data()); });
+    }
+    const TrackletPathBounds partial{.prefix = mPrefix.data(), .suffix = mSuffix.data(), .minClusters = mMinClusters};
+    for (auto group = groups.count; group-- > 0U;) {
+      forEachOfDepth<Det>(forEach, group, elementBegin, elementEnd, [&](LayerID layer, Index element) { mSuffix[element] = static_cast<std::uint8_t>(measurementPathSuffix(partial, parameters, sources, view, offsets.data(), layer, element)); });
+    }
+  }
+
+  [[nodiscard]] TrackletPathBounds bounds() const { return {.prefix = mPrefix.data(), .suffix = mSuffix.data(), .minClusters = mMinClusters}; }
+
+ private:
+  std::shared_ptr<BoundedMemoryResource> mPool;
+  BoundedVector<std::uint8_t> mPrefix;
+  BoundedVector<std::uint8_t> mSuffix;
+  std::uint32_t mMinClusters = 0U;
+};
+
+} // namespace o2::gtrk
+#endif // GTRK_TRACKING_TRACKLETPATHS_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackletSort.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackletSort.h
new file mode 100644
index 0000000000000..fa988e30e4433
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackletSort.h
@@ -0,0 +1,154 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackletSort.h
+/// \brief Each source's tracklets in (link, lambda, target) order.
+///
+/// The triplet stage searches the tracklets leaving a
+/// middle cluster by link and then by lambda: a binary search for the start of
+/// its lambda window and a scan to its end. This puts every source's range of
+/// the tracklet arena in that order, in place: on the host by
+/// `std::ranges::sort` over a copy of the range's records
+/// (`sortTrackletSegmentOnHost`), on a device by the library's segmented sort
+/// on a stable pass by target, then by (link, lambda) (`trackletLinkLambdaKey`,
+/// SliceGlue.cuh).
+
+#ifndef GTRK_TRACKING_TRACKLETSORT_H_
+#define GTRK_TRACKING_TRACKLETSORT_H_
+
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/WorkCounters.h"
+
+#include "GPUCommonDef.h"
+#include "GPUCommonMath.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+/// Whether a tracklet with key (\a link, \a lambda, \a target) sorts before one
+/// with the other key.
+///
+/// Within one source the target fixes the target layer and so the link, and a
+/// query visits each row once, so no two tracklets of a source share a target.
+/// The key is therefore unique within a range: the sorted order does not
+/// depend on the algorithm or the backend, and equal lambdas -- -0 and +0
+/// among them -- are ordered by the target.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool trackletBefore(std::uint16_t link, Scalar lambda, std::uint32_t target, std::uint16_t otherLink, Scalar otherLambda, std::uint32_t otherTarget)
+{
+  if (link != otherLink) {
+    return link < otherLink;
+  }
+  if (lambda < otherLambda) {
+    return true;
+  }
+  if (otherLambda < lambda) {
+    return false;
+  }
+  return target < otherTarget;
+}
+
+/// The counters build's tally of one source's range of \a length tracklets.
+GPUhdi() GPUAlwaysInline() void countSortSegment(std::uint32_t length)
+{
+  if (length < 2U) {
+    return;
+  }
+  countWork(WorkCounter::kSortSegments);
+  countWork(WorkCounter::kSortTracklets, length);
+  if (length > 8U) {
+    countWork(WorkCounter::kSortSegmentsOver8);
+  }
+  if (length > 32U) {
+    countWork(WorkCounter::kSortSegmentsOver32);
+    countWork(WorkCounter::kSortTrackletsOver32, length);
+  }
+  if (length > 128U) {
+    countWork(WorkCounter::kSortSegmentsOver128);
+  }
+  if (length > 512U) {
+    countWork(WorkCounter::kSortSegmentsOver512);
+  }
+}
+
+/// \a lambda as an unsigned key in `trackletBefore`'s order of lambdas: the
+/// float's bits made monotonic (every bit flipped for a negative, the sign bit
+/// set otherwise). Zero and the denormals of both signs are first made +0: `<`
+/// does not tell -0 from +0, and the trackers compare with denormals as zero --
+/// the host's processes start with MXCSR's DAZ and FTZ set, the devices compile
+/// with -ftz=true (CUDA) and -fgpu-flush-denormals-to-zero (HIP). A lambda is
+/// never NaN (an atan2 of finite chords).
+[[nodiscard]] GPUdi() std::uint32_t trackletLambdaKey(Scalar lambda)
+{
+  std::uint32_t bits = o2::gpu::CAMath::Float2UIntReint(lambda);
+  constexpr std::uint32_t kSign = 0x80000000U;
+  constexpr std::uint32_t kSmallestNormal = 0x00800000U;
+  if ((bits & ~kSign) < kSmallestNormal) {
+    bits = 0U;
+  }
+  return (bits & kSign) != 0U ? ~bits : (bits | kSign);
+}
+
+/// The link and lambda of a tracklet as one key in `trackletBefore`'s order,
+/// the target aside: the device sorts on it after a stable pass by target.
+[[nodiscard]] GPUdi() std::uint64_t trackletLinkLambdaKey(std::uint16_t link, Scalar lambda) { return (std::uint64_t{link} << 32U) | std::uint64_t{trackletLambdaKey(lambda)}; }
+
+/// Sort the tracklets in [\a begin, \a end) of \a tracklets in place, on the
+/// host: `std::ranges::sort` over the
+/// segment's records, copied into a buffer of the thread and written back.
+/// Sorting the rows in place across the five columns is slower, by how much
+/// depending on where the columns lie relative to each other;
+/// the buffer holds the largest segment.
+///
+/// The key is unique within a source, so this is the order of
+/// `trackletBefore`, for any length and any ties, in O(n log n); the library
+/// picks its own way for short ranges and long ones.
+inline void sortTrackletSegmentOnHost(const TrackletView& tracklets, std::uint32_t begin, std::uint32_t end)
+{
+  if constexpr (kWorkCounters) {
+    countSortSegment(end - begin);
+  }
+  // Fewer than two rows are in order: no call into the library for them, the
+  // most common case.
+  if (end - begin < 2U) {
+    return;
+  }
+  thread_local std::vector<Tracklet> records;
+  const std::uint32_t count = end - begin;
+  records.resize(count);
+  for (std::uint32_t i = 0; i < count; ++i) {
+    const auto at = begin + i;
+    records[i] = Tracklet{
+      .source = tracklets.source[at],
+      .target = tracklets.target[at],
+      .link = tracklets.link[at],
+      .lambda = tracklets.lambda[at],
+      .phi = tracklets.phi[at],
+    };
+  }
+  std::ranges::sort(records, [](const Tracklet& a, const Tracklet& b) { return trackletBefore(a.link, a.lambda, a.target, b.link, b.lambda, b.target); });
+  for (std::uint32_t i = 0; i < count; ++i) {
+    const auto at = begin + i;
+    tracklets.source[at] = records[i].source;
+    tracklets.target[at] = records[i].target;
+    tracklets.link[at] = records[i].link;
+    tracklets.lambda[at] = records[i].lambda;
+    tracklets.phi[at] = records[i].phi;
+  }
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRACKLETSORT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackletStage.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackletStage.h
new file mode 100644
index 0000000000000..f4fee277740f5
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TrackletStage.h
@@ -0,0 +1,720 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackletStage.h
+/// \brief The tracklet stage's per-source function.
+
+#ifndef GTRK_TRACKING_TRACKLETSTAGE_H_
+#define GTRK_TRACKING_TRACKLETSTAGE_H_
+
+#include "GenericTracking/Base/LayerLinks.h"
+#include "GenericTracking/Base/Lanes.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/DisplacedPair.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/LayerRowMap.h"
+#include "GenericTracking/Tracking/MeasurementGrid.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/ShapeCut.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/Trig.h"
+#include "GenericTracking/Tracking/WorkCounters.h"
+
+#include "GPUCommonAlgorithm.h"
+#include "GPUCommonMath.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <span>
+#include <stdexcept>
+#include <type_traits>
+
+namespace o2::gtrk
+{
+
+/// Which of a slice's source rows the tracklet stage works on: every core
+/// row, and a halo row only if its box starts within the gate
+/// (`SliceReach::gatePS`) of the core's: everything a chain the output
+/// depends on can reach. The halo itself is whole time blocks,
+/// far wider. With no core ranges every source is worked.
+struct SourceGate {
+  const MeasurementRange* core = nullptr; ///< per layer
+  std::int64_t earliestPS = 0;
+  std::int64_t latestPS = 0;
+};
+
+/// What one slice's tracklet stage is built from besides the timeframe, the
+/// vertices and the used mask. The tracker derives it once per slice, so that
+/// a device run of a slice uses exactly what the host run did.
+/// Host memory throughout; the gate's core
+/// ranges point into the slice, which must outlive it.
+template <DetectorLayout Det>
+struct TrackletInputs {
+  const IterationParameters<Det>* parameters = nullptr;
+  const LayerRowMap<Det>* sources = nullptr;
+  BlockRange targetBlocks{};
+  std::array<std::uint32_t, LayerRowMap<Det>::kLayerCount> maxCandidateWidthPS{};
+  SourceGate gate{};
+  /// The slice's halo rows on every layer, source or not: what the later
+  /// stages' variance bounds cover.
+  std::array<MeasurementRange, LayerRowMap<Det>::kLayerCount> halo{};
+};
+
+/// Where a tracklet stage's inputs are for a run somewhere else: the same
+/// objects copied to a device, each address in that device's memory.
+/// `TrackletStage::bind` swaps them in.
+template <DetectorLayout Det>
+struct TrackletBindings {
+  const IterationParameters<Det>* parameters = nullptr;
+  const LayerRowMap<Det>* sources = nullptr;
+  const TimeFrame<Det>* frame = nullptr;
+  const std::uint8_t* used = nullptr;
+  const VertexWindowParameters<Det>* vertexWindows = nullptr;
+  const VertexSeed* vertices = nullptr;       ///< a copy of the vertices the stage reads: the beam line or the list
+  const MeasurementRange* gateCore = nullptr; ///< per layer, if the stage is gated
+};
+
+/// A displaced iteration's pair test:
+/// `displacedPairWithin` with the two points' errors, \a scattering the
+/// source's (`sourceScattering`), \a between the passives' between the two
+/// (`betweenScattering`), the beam line's width (\a vertex, the beam line),
+/// the pair cut's curvature bound and sigma, and the iteration's impact bound
+/// and z bound about the beam spot's centre. The tracklet stage's, the stage
+/// funnel's and the sink's brute force's, one test.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() displaced::DisplacedPairResult displacedPairOf(const IterationParameters<Det>& parameters, const VertexSeed& vertex, const PairPoint& source, Scalar scattering, const PairPoint& target, Scalar between)
+{
+  const displaced::PairErrors<Scalar> errors{
+    .sourceVarR = source.varR,
+    .sourceVarRPhi = source.varRPhi,
+    .sourceVarZ = source.varZ,
+    .targetVarR = target.varR,
+    .targetVarRPhi = target.varRPhi,
+    .targetVarZ = target.varZ,
+    .sourceScatter = scattering,
+    .betweenScatter = between,
+    .beamVarTransverse = vertex.varTransverse,
+  };
+  const Scalar centre = parameters.vertexZCentre;
+  return displaced::displacedPairWithin<Scalar>(source.x, source.y, source.z, target.x, target.y, target.z, errors, parameters.pairCut.nSigma, parameters.pairCut.maxCurvature, parameters.impactMax, centre - parameters.impactZMax, centre + parameters.impactZMax);
+}
+
+/// Generate every accepted outgoing tracklet of one source measurement.
+///
+/// The call operator has the common StageOutput/CpuStage generator shape.
+/// Sources, outgoing links and grid candidates are visited in their canonical
+/// order; the first compatible vertex whose pair cut passes accepts a target.
+///
+/// With \a BeamLine the stage serves only a beam-line iteration: one vertex,
+/// no per-vertex intervals and no fallback past the cache, so neither is
+/// compiled. A beam-line iteration makes the same tracklets with either; the
+/// trackers take this one for it.
+/// With \a Displaced, on the beam line only, the stage serves a displaced
+/// iteration (`IterationParameters::impactMax`): its pair test is `displacedPairWithin`, a circle above pT_min
+/// passing within the impact bound of the beam line at a z within the z
+/// bound of the beam spot's centre, in place of the beam point's.
+///
+/// With \a Shape, the iteration's `shapeTest`: a candidate's line must cross
+/// both its measurements at a local slope in their slope intervals
+/// (ShapeCut.h), tested first.
+template <DetectorLayout Det, std::uint32_t VertexCapacity = 8U, bool BeamLine = false, bool Displaced = false, bool Shape = false>
+class TrackletStage
+{
+ public:
+  using Index = typename LayerRowMap<Det>::Index;
+  static constexpr std::size_t kLayerCount = LayerRowMap<Det>::kLayerCount;
+  static_assert(!BeamLine || VertexCapacity == 1U, "the beam line is one vertex");
+  static_assert(!Displaced || BeamLine, "a displaced iteration pairs through the beam line");
+  // How many compatible vertices get their own interval. A source with more
+  // takes the beam-spot window with every one of them tested; both windows
+  // hold every vertex `vertexUsable` admits, so the tracklets do not depend on
+  // it.
+  static constexpr std::uint32_t kVertexCapacity = VertexCapacity;
+  static_assert(kVertexCapacity > 0U);
+  static_assert(nLinks<Det> <= std::size_t{std::numeric_limits<std::uint16_t>::max()} + 1U);
+
+  TrackletStage(const IterationParameters<Det>& parameters, const LayerRowMap<Det>& sources, const TimeFrame<Det>& frame, BlockRange targetBlocks, const VertexSeed& beamLine, std::span<const VertexSeed> vertices, const std::array<std::uint32_t, kLayerCount>& maxCandidateWidthPS, const VertexWindowParameters<Det>& vertexWindows, const std::uint8_t* used, const SourceGate& gate = {})
+    : mParameters(&parameters),
+      mSources(&sources),
+      mFrame(&frame),
+      mTargetBlocks(targetBlocks),
+      mGate(gate),
+      mUsed(used),
+      mVertexWindows(&vertexWindows),
+      mMaxCandidateWidthPS(maxCandidateWidthPS)
+  {
+    if (BeamLine && parameters.vertexSource != VertexSource::kBeamLine) {
+      throw std::invalid_argument("the beam-line tracklet stage serves only a beam-line iteration");
+    }
+    if (Displaced != (parameters.impactMax > 0.F)) {
+      throw std::invalid_argument("the displaced tracklet stage serves exactly the displaced iterations");
+    }
+    if (Shape != parameters.shapeTest) {
+      throw std::invalid_argument("the shape-testing tracklet stage serves exactly the iterations with shapeTest");
+    }
+    if (parameters.vertexSource == VertexSource::kBeamLine) {
+      mVertices = &beamLine;
+      mVertexCount = 1U;
+    } else {
+      mVertices = vertices.data();
+      mVertexCount = static_cast<std::uint32_t>(vertices.size());
+    }
+    for (std::uint32_t i = 0; i < mVertexCount; ++i) {
+      mMaxVertexWidthPS = std::max(mMaxVertexWidthPS, mVertices[i].widthPS);
+    }
+  }
+
+  /// This stage reading its inputs at \a bindings instead: every pointer
+  /// swapped, every value the constructor derived on the host -- the vertex
+  /// choice and count, the variance bounds, the gate's window -- kept, so
+  /// that the bound stage runs on exactly the numbers this one does. Host
+  /// code; the result is what a kernel receives.
+  [[nodiscard]] TrackletStage bind(const TrackletBindings<Det>& bindings) const
+  {
+    const bool complete = bindings.parameters != nullptr && bindings.sources != nullptr && bindings.frame != nullptr && bindings.used != nullptr && bindings.vertexWindows != nullptr && (bindings.vertices != nullptr || mVertexCount == 0U) && (bindings.gateCore != nullptr || mGate.core == nullptr);
+    if (!complete) {
+      throw std::invalid_argument("a tracklet stage binding is missing an input the stage reads");
+    }
+    TrackletStage bound = *this;
+    bound.mParameters = bindings.parameters;
+    bound.mSources = bindings.sources;
+    bound.mFrame = bindings.frame;
+    bound.mUsed = bindings.used;
+    bound.mVertexWindows = bindings.vertexWindows;
+    bound.mVertices = bindings.vertices;
+    bound.mGate.core = mGate.core == nullptr ? nullptr : bindings.gateCore;
+    return bound;
+  }
+
+  using Between = BetweenSource<Det>;
+  /// The measurement columns, which a device's candidate tests read
+  /// (`testCandidate`, `record`).
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() MeasurementView columns() const { return mFrame->measurements(); }
+
+  /// The vertices a source can pair through, cached with their scattering at
+  /// the source.
+  struct CompatibleVertex {
+    std::uint32_t vertexIndex;
+    Scalar scattering;
+  };
+
+  struct VertexRange {
+    std::uint32_t begin = 0U;
+    std::uint32_t end = 0U;
+  };
+
+  /// What one source brings to each of its queries (`prepare`), besides its
+  /// cached vertices: an array apart, so that a compiler can keep the
+  /// context's scalars in registers while the array is indexed at run time.
+  struct SourceContext {
+    typename LayerRowMap<Det>::Row at{};
+    TimeEstPS box{};
+    PairPoint point{}; ///< its position as the tests read it
+    Scalar phi = 0.F;
+    Scalar second = 0.F;
+    VertexRange vertexRange{};
+    VertexRange uncachedRange{};
+    std::uint32_t cachedCount = 0U;
+  };
+
+  /// One query of a source: a link and the window it searches (`query`).
+  struct QueryContext {
+    std::size_t linkIndex = 0U;
+    LayerID targetLayer = kInvalidLayerID;
+    std::uint64_t holes = 0U;
+    CandidateWindow window{};
+    Scalar directLow = -std::numeric_limits<Scalar>::infinity();
+    Scalar directHigh = std::numeric_limits<Scalar>::infinity();
+  };
+
+  /// The source's work: `prepare` once, a query per out-link, and per
+  /// candidate `cheap`, then `expensive`; a device runs the candidates apart
+  /// (`forEachCandidate`, `testCandidate`, `record`).
+  template <typename Emitter>
+  GPUhdi() void operator()(Index sourceElement, Emitter& emitter) const
+  {
+    const auto test = [&](const SourceContext& source, const CompatibleVertex* cachedVertices, const BetweenSource<Det>& between, const QueryContext& query, const SecondRange* intervals, const MeasurementView& columns, Index targetRow) { expensive(source, cachedVertices, between, query, intervals, columns, targetRow, emitter); };
+    forEachCandidate(sourceElement, test);
+  }
+
+  /// The candidates of \a sourceElement that pass `cheap`, counted without
+  /// the pair tests: what a flat candidate list holds for the source.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint32_t candidateCount(Index sourceElement) const
+  {
+    std::uint32_t count = 0U;
+    const auto one = [&](const SourceContext&, const CompatibleVertex*, const BetweenSource<Det>&, const QueryContext&, const SecondRange*, const MeasurementView&, Index) { ++count; };
+    forEachCandidate(sourceElement, one);
+    return count;
+  }
+
+  /// \a body(source, cachedVertices, between, query, intervals, columns,
+  /// targetRow) for every candidate of \a sourceElement that passes `cheap`,
+  /// in the serial order -- the out-links in order, each query's rows in the
+  /// grid walk's order: the one traversal the stage's forms share.
+  ///
+  /// With a \a group of lanes (`WarpGroup`) instead, every lane runs the
+  /// source's and the queries' preparation alike and the group walks each
+  /// query's rows in step (`MeasurementGrid::visitCandidates`): \a body(...,
+  /// targetRow, has) on every lane at every step, \a has whether the lane's
+  /// row is a candidate. A step's lanes hold consecutive rows of the walk, so
+  /// the candidates in step order, and lane order within a step, are the
+  /// serial order.
+  template <typename Body, typename Share = Lanes>
+  GPUhdi() void forEachCandidate(Index sourceElement, Body& body, Share share = {}) const
+  {
+    SourceContext source;
+    CompatibleVertex cachedVertices[kVertexCapacity];
+    if (!prepare(sourceElement, source, cachedVertices)) {
+      return;
+    }
+    // Apart from the context, as the vertex cache (its passives are indexed at run time).
+    BetweenSource<Det> between;
+    if constexpr (BeamLine) {
+      between = betweenSource<Det>(mParameters->scattering, mVertices[cachedVertices[0].vertexIndex], source.point);
+    }
+    const MeasurementView columns = mFrame->measurements();
+    forEachQuery(source, [&](const QueryContext& query) {
+      // One candidate of the query, against the vertices' second-coordinate
+      // \a intervals, or nullptr when the query took the whole window.
+      const auto visitTarget = [&](const SecondRange* intervals) {
+        if constexpr (std::is_same_v<Share, Lanes>) {
+          return [&, intervals](Index targetRow) {
+            if (cheap(targetRow)) {
+              body(source, cachedVertices, between, query, intervals, columns, targetRow);
+            }
+          };
+        } else {
+          return [&, intervals](Index targetRow, bool has) { body(source, cachedVertices, between, query, intervals, columns, targetRow, has && cheap(targetRow)); };
+        }
+      };
+      if constexpr (BeamLine) {
+        mFrame->grid().visitCandidates(query.targetLayer, query.window, mTargetBlocks, visitTarget(nullptr), share);
+      } else {
+        const bool fallback = source.uncachedRange.begin != source.vertexRange.end;
+        if (mParameters->vertexSource == VertexSource::kBeamLine || fallback) {
+          mFrame->grid().visitCandidates(query.targetLayer, query.window, mTargetBlocks, visitTarget(nullptr), share);
+          return false;
+        }
+
+        SecondRange intervals[kVertexCapacity];
+        SecondRun runs[kVertexCapacity];
+        const std::uint32_t runCount = vertexRuns(source, cachedVertices, query, intervals, runs);
+        mFrame->grid().visitCandidates(query.targetLayer, query.window, runs, runCount, mTargetBlocks, visitTarget(intervals), share);
+      }
+      return false;
+    });
+  }
+
+  /// Whether \a sourceElement has a query: `prepare` and some out-link's
+  /// `prepareQuery`, as `operator()` decides them, without reading a target
+  /// row. A source without one emits nothing, so a device launches the
+  /// stage over the sources with one only.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool hasQuery(Index sourceElement) const
+  {
+    SourceContext source;
+    CompatibleVertex cachedVertices[kVertexCapacity];
+    return prepare(sourceElement, source, cachedVertices) && forEachQuery(source, [](const QueryContext& /*query*/) { return true; });
+  }
+
+ private:
+  /// \a body(query) for each out-link of \a source that makes a query
+  /// (`prepareQuery`), in the links' order, until it returns true; whether
+  /// it did.
+  template <typename Body>
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool forEachQuery(const SourceContext& source, const Body& body) const
+  {
+    for (auto at = mParameters->outLinkOffsets[source.at.layer]; at < mParameters->outLinkOffsets[static_cast<std::size_t>(source.at.layer) + 1U]; ++at) {
+      QueryContext query;
+      if (prepareQuery(source, mParameters->outLinkIndices[at], query) && body(query)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /// The source of \a sourceElement in \a source and its vertices in
+  /// \a cachedVertices (`kVertexCapacity` of them): false when it has no
+  /// query -- held exclusively by an earlier track, outside the slice's gate,
+  /// or with no vertex to pair through.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool prepare(Index sourceElement, SourceContext& source, CompatibleVertex* cachedVertices) const
+  {
+    source.at = mSources->row(sourceElement);
+    // A row an earlier iteration's track holds exclusively is on no road of
+    // this one; a shared one may still be.
+    if (mUsed[source.at.row] == kExclusive) {
+      return false;
+    }
+    countWork(WorkCounter::kTrackletSources);
+    const auto measurement = mFrame->measurement(source.at.row);
+    source.box = timeBox(measurement);
+    if (mGate.core != nullptr) {
+      const auto& core = mGate.core[source.at.layer];
+      const bool inCore = source.at.row >= core.begin && source.at.row < core.end;
+      const std::int64_t start = source.box.lower();
+      if (!inCore && (start < mGate.earliestPS || start > mGate.latestPS)) {
+        return false;
+      }
+    }
+    source.point = pairPoint(measurement);
+    source.phi = measurement.phi;
+    source.vertexRange = compatibleVertexRange(source.box);
+    source.cachedCount = 0U;
+    source.uncachedRange = {.begin = source.vertexRange.end, .end = source.vertexRange.end};
+    for (std::uint32_t i = source.vertexRange.begin; i < source.vertexRange.end; ++i) {
+      const auto& vertex = mVertices[i];
+      if (!vertexUsable(*mParameters, source.box, vertex)) {
+        continue;
+      }
+      if (source.cachedCount == kVertexCapacity) {
+        source.uncachedRange.begin = i;
+        source.uncachedRange.end = source.vertexRange.end;
+        break;
+      }
+      cachedVertices[source.cachedCount] = {
+        .vertexIndex = i,
+        .scattering = sourceScattering<Det>(mParameters->scattering, mParameters->pairCut, vertex, source.at.layer, source.point),
+      };
+      ++source.cachedCount;
+    }
+    if (source.cachedCount == 0U) {
+      return false;
+    }
+    source.second = secondCoordinate<Det>(source.at.layer, source.point.r, source.point.z);
+    return true;
+  }
+
+  /// The query of \a source on link \a linkIndex in \a query: false when it
+  /// makes none -- the source outside the link's reach, or no direct pair.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool prepareQuery(const SourceContext& source, std::size_t linkIndex, QueryContext& query) const
+  {
+    query.linkIndex = linkIndex;
+    query.targetLayer = mParameters->linkTargets[linkIndex];
+    if (source.second < mParameters->sourceMin[linkIndex] || source.second > mParameters->sourceMax[linkIndex]) {
+      return false;
+    }
+    query.holes = mParameters->holeLayers[linkIndex];
+    const auto& at = source.point;
+    query.window = candidateWindow(mParameters->windows[linkIndex], source.box, source.phi, at.r, at.z, mMaxCandidateWidthPS[query.targetLayer]);
+    // In an iteration without skips, a source queries only the part of its
+    // window a pair of it can reach without crossing another layer, and
+    // nothing when there is none (LinkHoles.h); every pair is still tested.
+    query.directLow = -std::numeric_limits<Scalar>::infinity();
+    query.directHigh = std::numeric_limits<Scalar>::infinity();
+    if (query.holes != 0U) {
+      const auto& target = mParameters->layerSpans[query.targetLayer];
+      const auto direct = directPairRange(query.holes, mParameters->barrelLayers, mParameters->layerSpans, query.targetLayer, at.r, at.z, target.low, target.high);
+      const Scalar low = o2::gpu::CAMath::Max(direct.low, query.window.secondCentre - query.window.secondHalfWidth);
+      const Scalar high = o2::gpu::CAMath::Min(direct.high, query.window.secondCentre + query.window.secondHalfWidth);
+      if (!(low <= high)) {
+        countWork(WorkCounter::kTrackletHoleQueries);
+        return false;
+      }
+      query.directLow = direct.low;
+      query.directHigh = direct.high;
+      query.window.secondCentre = 0.5F * (low + high);
+      query.window.secondHalfWidth = 0.5F * (high - low);
+    }
+    countWork(WorkCounter::kTrackletQueries);
+    countLinkWork(linkIndex, LinkCounter::kQueries);
+    return true;
+  }
+
+  /// A candidate's first test: false when an earlier track holds the row
+  /// exclusively.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool cheap(Index targetRow) const
+  {
+    if (mUsed[targetRow] == kExclusive) {
+      countWork(WorkCounter::kTrackletUsed);
+      return false;
+    }
+    return true;
+  }
+
+  /// The rest of a candidate's tests -- the pair cut through every vertex the
+  /// source can pair with, then the hole -- and its tracklet if they pass.
+  /// \a between: the source's part of `betweenScattering` on the beam line
+  /// (`betweenSource`), unread on a vertex list. \a intervals: the vertices'
+  /// second-coordinate intervals of the query, or nullptr when it took the
+  /// whole window.
+  ///
+  /// The hole test last: both tests have to pass and neither has a side
+  /// effect, and the pair test refuses most rows.
+  template <typename Columns, typename Emitter>
+  GPUhdi() void expensive(const SourceContext& source, const CompatibleVertex* cachedVertices, const BetweenSource<Det>& between, const QueryContext& query, const SecondRange* intervals, const Columns& columns, Index targetRow, Emitter& emitter) const
+  {
+    const auto target = pairPointAt(columns, targetRow);
+    if (!testCandidate(source, cachedVertices, between, query, intervals, columns, targetRow, target)) {
+      return;
+    }
+    emit(source.at.row, targetRow, query.linkIndex, source.point, target, emitter);
+  }
+
+ public:
+  /// `expensive`'s tests on \a target, the candidate's point: true where the
+  /// candidate is a tracklet (the test apart from the record).
+  template <typename Columns>
+  [[nodiscard]] GPUhdi() bool testCandidate(const SourceContext& source, const CompatibleVertex* cachedVertices, const BetweenSource<Det>& between, const QueryContext& query, const SecondRange* intervals, const Columns& columns, Index targetRow, const PairPoint& target) const
+  {
+    countLinkWork(query.linkIndex, LinkCounter::kCandidates);
+    if constexpr (Shape) {
+      if (!shapeAdmits(columns, source.at.row, source.point.x, source.point.y, source.point.z, target.x, target.y, target.z) || !shapeAdmits(columns, targetRow, source.point.x, source.point.y, source.point.z, target.x, target.y, target.z)) {
+        countWork(WorkCounter::kTrackletShape);
+        return false;
+      }
+    }
+    // Counting only: the candidate against the query's own window.
+    [[maybe_unused]] bool inWindow = true; // NOLINT(misc-const-correctness): written with the work counters
+    if constexpr (kWorkCounters) {
+      inWindow = spatiallyCompatible(query.window, columns.phi[targetRow], secondCoordinate<Det>(query.targetLayer, target.r, target.z));
+      if (inWindow) {
+        countWork(WorkCounter::kTrackletInWindow);
+      }
+    }
+    if (!accepted(source.at.layer, source.box, source.point, target, cachedVertices, source.cachedCount, source.uncachedRange, intervals, secondCoordinate<Det>(query.targetLayer, target.r, target.z), mParameters->betweenBound[query.linkIndex], mParameters->betweenPassives[query.linkIndex], between, inWindow)) {
+      return false;
+    }
+    if (query.holes != 0U && segmentLeavesHole(query.holes, mParameters->barrelLayers, mParameters->layerSpans, source.point.r, source.point.z, target.r, target.z)) {
+      countWork(WorkCounter::kTrackletHoles);
+      return false;
+    }
+    if (!inWindow) {
+      countWork(WorkCounter::kTrackletAcceptedOutside);
+    }
+    return true;
+  }
+
+  /// The tracklet of an accepted candidate (`emit`'s record).
+  template <typename Source, typename Target>
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Tracklet record(Index sourceRow, Index targetRow, std::size_t linkIndex, const Source& source, const Target& target) const
+  {
+    const Scalar dx = target.x - source.x;
+    const Scalar dy = target.y - source.y;
+    const Scalar dz = target.z - source.z;
+    const Scalar transverse = o2::gpu::CAMath::Hypot(dx, dy);
+    return Tracklet{
+      .source = sourceRow,
+      .target = targetRow,
+      .link = static_cast<std::uint16_t>(linkIndex),
+      .lambda = atan2Of(dz, transverse),
+      .phi = atan2Of(dy, dx),
+    };
+  }
+
+ private:
+  /// A vertex-list query's second-coordinate runs: the cached vertices'
+  /// intervals (\a intervals), sorted, merged and clipped to the direct part
+  /// of the target; their count.
+  GPUhdi() GPUAlwaysInline() std::uint32_t vertexRuns(const SourceContext& source, const CompatibleVertex* cachedVertices, const QueryContext& query, SecondRange* intervals, SecondRun* runs) const
+  {
+    for (std::uint32_t i = 0; i < source.cachedCount; ++i) {
+      const auto& vertex = mVertices[cachedVertices[i].vertexIndex];
+      intervals[i] = vertexSecondRange(mParameters->windows[query.linkIndex], mVertexWindows->windows[query.linkIndex], source.point.r, source.point.z, vertex.z, vertex.varZ, mParameters->pairCut.nSigma);
+      runs[i] = {.low = intervals[i].centre - intervals[i].halfWidth, .high = intervals[i].centre + intervals[i].halfWidth};
+    }
+    // With one slot there is nothing to sort; compiling the loop out also
+    // spares GCC's -Warray-bounds a subscript it cannot prove unreachable.
+    if constexpr (kVertexCapacity > 1U) {
+      insertionSort(runs, source.cachedCount, [](const SecondRun& a, const SecondRun& b) { return a.low < b.low; });
+    }
+    std::uint32_t runCount = 0U;
+    for (std::uint32_t i = 0; i < source.cachedCount; ++i) {
+      if (runCount == 0U || runs[i].low > runs[runCount - 1U].high) {
+        runs[runCount++] = runs[i];
+      } else if (runs[i].high > runs[runCount - 1U].high) {
+        runs[runCount - 1U].high = runs[i].high;
+      }
+    }
+    // The direct part of the target, as for the window (`prepareQuery`).
+    if (query.holes != 0U) {
+      std::uint32_t kept = 0U;
+      for (std::uint32_t i = 0; i < runCount; ++i) {
+        const SecondRun clipped{.low = o2::gpu::CAMath::Max(runs[i].low, query.directLow), .high = o2::gpu::CAMath::Min(runs[i].high, query.directHigh)};
+        if (clipped.low <= clipped.high) {
+          runs[kept++] = clipped;
+        }
+      }
+      runCount = kept;
+    }
+    return runCount;
+  }
+
+  /// \a betweenBound: the link's bound on the kink of a passive scatterer
+  /// between its layers (`IterationParameters::betweenBound`), 0 if none can
+  /// lie there. With one, the pair's transverse test runs at the bound first,
+  /// and the pair's own kink (`betweenScattering`, a loop over the passives)
+  /// is computed only if it passes: the test only widens with the kink, so
+  /// the same pairs pass.
+  /// \a betweenPassives: the passives a pair on the link can cross.
+  [[nodiscard]] GPUhdi() bool accepted(LayerID sourceLayer, const TimeEstPS& sourceBox, const PairPoint& source, const PairPoint& target, const CompatibleVertex* cachedVertices, std::uint32_t cachedCount, VertexRange uncachedRange, const SecondRange* intervals, Scalar targetSecond, Scalar betweenBound, std::uint64_t betweenPassives, const BetweenSource<Det>& between, [[maybe_unused]] bool inWindow) const
+  {
+    // The pair's own kink: on the beam line from the source's part, computed
+    // once per source; else from the pair, per vertex.
+    const auto betweenOf = [&](const VertexSeed& vertex) {
+      if constexpr (BeamLine) {
+        return betweenScattering<Det>(between, mParameters->pairCut, vertex, target, betweenPassives);
+      } else {
+        return betweenScattering<Det>(mParameters->scattering, mParameters->pairCut, vertex, source, target, betweenPassives);
+      }
+    };
+    // What the pair tests compute of the two positions alone, once.
+    const auto chord = pairChord(source, target);
+    const auto compatible = [&](const VertexSeed& vertex, Scalar scattering) {
+      const auto& cut = mParameters->pairCut;
+      if constexpr (Displaced) {
+        return displacedCompatible(vertex, source, scattering, target, betweenBound > 0.F ? betweenOf(vertex) : 0.F);
+      }
+      // Counting only: the cascade's stages split by the window.
+      const auto countStages = [&](Scalar betweenScatter) {
+        if constexpr (kWorkCounters) {
+          if (inWindow) {
+            countWork(WorkCounter::kPairTestsIn);
+            if (transverseCompatible(cut, transversePairTerms(cut, vertex, source, scattering, target, chord, betweenScatter))) {
+              countWork(WorkCounter::kPairLongitudinalTestsIn);
+            }
+          }
+        }
+      };
+      if (!(betweenBound > 0.F)) {
+        countStages(0.F);
+        return pairCompatible(cut, vertex, source, scattering, target, chord);
+      }
+      if (!transverseCompatible(cut, transversePairTerms(cut, vertex, source, scattering, target, chord, betweenBound))) {
+        countWork(WorkCounter::kPairBetweenBound);
+        if constexpr (kWorkCounters) {
+          if (inWindow) {
+            countWork(WorkCounter::kPairBetweenBoundIn);
+          }
+        }
+        return false;
+      }
+      const Scalar own = betweenOf(vertex);
+      countStages(own);
+      return pairCompatible(cut, vertex, source, scattering, target, chord, own);
+    };
+    for (std::uint32_t i = 0; i < cachedCount; ++i) {
+      if constexpr (!BeamLine) {
+        if (intervals != nullptr && !secondRangeContains(intervals[i], targetSecond)) {
+          continue;
+        }
+      }
+      const auto& cached = cachedVertices[i];
+      const auto& vertex = mVertices[cached.vertexIndex];
+      if (compatible(vertex, cached.scattering)) {
+        return true;
+      }
+    }
+    if constexpr (!BeamLine) {
+      for (std::uint32_t i = uncachedRange.begin; i < uncachedRange.end; ++i) {
+        const auto& vertex = mVertices[i];
+        if (!vertexUsable(*mParameters, sourceBox, vertex)) {
+          continue;
+        }
+        const Scalar scattering = sourceScattering<Det>(mParameters->scattering, mParameters->pairCut, vertex, sourceLayer, source);
+        if (compatible(vertex, scattering)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /// A displaced iteration's pair test (`displacedPairOf`), counted.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool displacedCompatible(const VertexSeed& vertex, const PairPoint& source, Scalar scattering, const PairPoint& target, Scalar between) const
+  {
+    countWork(WorkCounter::kPairTests);
+    const auto result = displacedPairOf(*mParameters, vertex, source, scattering, target, between);
+    if (!result.transverse) {
+      return false;
+    }
+    countWork(WorkCounter::kPairTransverse);
+    if (!result.longitudinal) {
+      return false;
+    }
+    countWork(WorkCounter::kPairLongitudinal);
+    return true;
+  }
+
+  template <typename Source, typename Target, typename Emitter>
+  GPUhdi() GPUAlwaysInline() void emit(Index sourceRow, Index targetRow, std::size_t linkIndex, const Source& source, const Target& target, Emitter& emitter) const
+  {
+    countWork(WorkCounter::kTrackletAccepted);
+    countLinkWork(linkIndex, LinkCounter::kTracklets);
+    emitter.emit(record(sourceRow, targetRow, linkIndex, source, target));
+  }
+
+  /// The vertices, sorted by their boxes' starts, that can overlap \a box:
+  /// starting before its end, and no earlier than the widest vertex box
+  /// before its start.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() VertexRange compatibleVertexRange(const TimeEstPS& box) const
+  {
+    if (mVertexCount == 0U) {
+      return {};
+    }
+    const std::int64_t low = static_cast<std::int64_t>(box.lower()) - static_cast<std::int64_t>(mMaxVertexWidthPS);
+    return {.begin = startingBefore(low), .end = startingBefore(box.upper())};
+  }
+
+  /// The first vertex whose box starts at or after \a timePS.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint32_t startingBefore(std::int64_t timePS) const
+  {
+    return o2::gpu::CAAlgo::partitionPoint(0U, mVertexCount, [&](std::uint32_t vertex) {
+      const std::int64_t start = mVertices[vertex].timePS;
+      return start < timePS;
+    });
+  }
+
+  const IterationParameters<Det>* mParameters = nullptr;
+  const LayerRowMap<Det>* mSources = nullptr;
+  const TimeFrame<Det>* mFrame = nullptr;
+  BlockRange mTargetBlocks{};
+  SourceGate mGate{};
+  const std::uint8_t* mUsed = nullptr; ///< the used mask, per row
+  const VertexWindowParameters<Det>* mVertexWindows = nullptr;
+  const VertexSeed* mVertices = nullptr;
+  std::uint32_t mVertexCount = 0U;
+  std::uint32_t mMaxVertexWidthPS = 0U;
+  std::array<std::uint32_t, kLayerCount> mMaxCandidateWidthPS{};
+};
+
+/// The tracklet stage a tracker runs for an iteration: the beam-line one
+/// for a beam-line iteration, its displaced one for a displaced iteration,
+/// the general one otherwise; each testing the shapes with \a Shape.
+template <DetectorLayout Det, bool BeamLine, bool Displaced = false, bool Shape = false>
+using TrackletStageFor = std::conditional_t<BeamLine, TrackletStage<Det, 1U, true, Displaced, Shape>, TrackletStage<Det, 8U, false, false, Shape>>;
+
+/// \a body called with two `std::bool_constant`s: whether the iteration is a
+/// beam-line one (\a source), and whether it is displaced (\a displaced, on
+/// the beam line only): the choice of `TrackletStageFor`, host code.
+template <typename Body>
+decltype(auto) withTrackletVertices(VertexSource source, bool displaced, const Body& body)
+{
+  if (source == VertexSource::kBeamLine) {
+    return displaced ? body(std::true_type{}, std::true_type{}) : body(std::true_type{}, std::false_type{});
+  }
+  return body(std::false_type{}, std::false_type{});
+}
+
+/// \a body called with a `std::bool_constant`: whether the iteration tests
+/// the shapes (\a shapeTest), the choice of the stages' Shape, host code.
+template <typename Body>
+decltype(auto) withShapeTest(bool shapeTest, const Body& body)
+{
+  return shapeTest ? body(std::true_type{}) : body(std::false_type{});
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRACKLETSTAGE_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Trig.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Trig.h
new file mode 100644
index 0000000000000..7f6024d6f262e
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Trig.h
@@ -0,0 +1,154 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Trig.h
+/// \brief The transcendental functions of shared tracking code, overloaded for
+///        float and double, for host and device alike.
+///
+/// Outside O2's deterministic mode they are `CAMath`'s: `Sin`, `ATan2`, ... in
+/// float and `Sind`, `ATan2d`, ... in double. `sincosOf` is
+/// `o2::math_utils::detail::sincos`, one call on hosts and devices, and the
+/// spelling O2's own track code uses.
+///
+/// O2's deterministic mode is different. It computes the float functions in
+/// double and rounds, which almost always hides the host's and the device's
+/// libraries disagreeing in the last place of the double; the double
+/// functions it leaves native, and there nothing hides it (PortableMath.h). So in that
+/// mode every function here is PortableMath's,
+/// in both precisions: the same arithmetic on the host and on every device,
+/// the float ones in double and rounded, as O2 does.
+
+#ifndef GTRK_TRACKING_TRIG_H_
+#define GTRK_TRACKING_TRIG_H_
+
+#include "GenericTracking/Base/Definitions.h"
+
+#include "GenericTracking/Base/PortableMath.h"
+
+#include "GPUCommonMath.h"
+#include "MathUtils/detail/trigonometric.h"
+
+// The documented libdevice float implementation, called directly so CUDA's
+// --use-fast-math does not substitute the lower-accuracy intrinsic.
+#if defined(__CUDACC__) && !defined(__HIPCC__)
+extern "C" __device__ void __nv_sincosf(float, float*, float*);
+#endif
+
+namespace o2::gtrk
+{
+
+GPUhdi() GPUAlwaysInline() float sinOf(float x)
+{
+#ifdef GPUCA_DETERMINISTIC_MODE
+  return static_cast<float>(portable::sin(static_cast<double>(x)));
+#else
+  return o2::gpu::CAMath::Sin(x);
+#endif
+}
+
+GPUhdi() GPUAlwaysInline() float cosOf(float x)
+{
+#ifdef GPUCA_DETERMINISTIC_MODE
+  return static_cast<float>(portable::cos(static_cast<double>(x)));
+#else
+  return o2::gpu::CAMath::Cos(x);
+#endif
+}
+
+GPUhdi() GPUAlwaysInline() float asinOf(float x)
+{
+#ifdef GPUCA_DETERMINISTIC_MODE
+  return static_cast<float>(portable::asin(static_cast<double>(x)));
+#else
+  return o2::gpu::CAMath::ASin(x);
+#endif
+}
+
+GPUhdi() GPUAlwaysInline() float atanOf(float x)
+{
+#ifdef GPUCA_DETERMINISTIC_MODE
+  return static_cast<float>(portable::atan(static_cast<double>(x)));
+#else
+  return o2::gpu::CAMath::ATan(x);
+#endif
+}
+
+GPUhdi() GPUAlwaysInline() float logOf(float x)
+{
+#ifdef GPUCA_DETERMINISTIC_MODE
+  return static_cast<float>(portable::log(static_cast<double>(x)));
+#else
+  return o2::gpu::CAMath::Log(x);
+#endif
+}
+
+GPUhdi() GPUAlwaysInline() float atan2Of(float y, float x)
+{
+#ifdef GPUCA_DETERMINISTIC_MODE
+  return static_cast<float>(portable::atan2(static_cast<double>(y), static_cast<double>(x)));
+#else
+  return o2::gpu::CAMath::ATan2(y, x);
+#endif
+}
+
+GPUhdi() GPUAlwaysInline() void sincosOf(float x, float& s, float& c)
+{
+#ifdef GPUCA_DETERMINISTIC_MODE
+  s = sinOf(x);
+  c = cosOf(x);
+#else
+  math_utils::detail::sincos<float>(x, s, c);
+#endif
+}
+
+#ifdef GPUCA_DETERMINISTIC_MODE
+GPUhdi() GPUAlwaysInline() double sinOf(double x) { return portable::sin(x); }
+GPUhdi() GPUAlwaysInline() double cosOf(double x) { return portable::cos(x); }
+GPUhdi() GPUAlwaysInline() double asinOf(double x) { return portable::asin(x); }
+GPUhdi() GPUAlwaysInline() double atanOf(double x) { return portable::atan(x); }
+GPUhdi() GPUAlwaysInline() double atan2Of(double y, double x) { return portable::atan2(y, x); }
+#else
+GPUhdi() GPUAlwaysInline() double sinOf(double x) { return o2::gpu::CAMath::Sind(x); }
+GPUhdi() GPUAlwaysInline() double cosOf(double x) { return o2::gpu::CAMath::Cosd(x); }
+GPUhdi() GPUAlwaysInline() double asinOf(double x) { return o2::gpu::CAMath::ASind(x); }
+GPUhdi() GPUAlwaysInline() double atanOf(double x) { return o2::gpu::CAMath::ATand(x); }
+GPUhdi() GPUAlwaysInline() double atan2Of(double y, double x) { return o2::gpu::CAMath::ATan2d(y, x); }
+#endif
+
+GPUhdi() GPUAlwaysInline() void sincosOf(double x, double& s, double& c)
+{
+#ifdef GPUCA_DETERMINISTIC_MODE
+  s = portable::sin(x);
+  c = portable::cos(x);
+#else
+  math_utils::detail::sincos<double>(x, s, c);
+#endif
+}
+
+/// sin and cos of a direction for the double plane solve. Under CUDA's
+/// -use_fast_math (outside the deterministic mode) `sincosf` becomes the
+/// intrinsic, too coarse here; libdevice's precise one is called instead.
+GPUhdi() GPUAlwaysInline() void directionSincosOf(float angle, double& sine, double& cosine)
+{
+  float s = 0.F;
+  float c = 0.F;
+#if defined(__CUDA_ARCH__) && !defined(GPUCA_DETERMINISTIC_MODE)
+  __nv_sincosf(angle, &s, &c);
+#else
+  sincosOf(angle, s, c);
+#endif
+  sine = s;
+  cosine = c;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRIG_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Triplet.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Triplet.h
new file mode 100644
index 0000000000000..33c49209729dc
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/Triplet.h
@@ -0,0 +1,48 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Triplet.h
+/// \brief A triplet as SoA columns: two tracklets, their local curvature, and
+///        what the neighbour fit reads of them.
+///
+/// Adapted from O2 ITSMFTTracking/Triplet.h. GTRK stores only the fields read
+/// by later CA stages; measurement rows and layers follow from the tracklets.
+
+#ifndef GTRK_TRACKING_TRIPLET_H_
+#define GTRK_TRACKING_TRIPLET_H_
+
+#include "GenericTracking/Tracking/Definitions.h"
+
+#include <memlayout/wrapper.h>
+
+#include <cstdint>
+
+namespace o2::gtrk
+{
+
+// NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members,cppcoreguidelines-missing-std-forward,readability-identifier-naming)
+template <template <class> class C>
+struct TripletT {
+  MEMLAYOUT_APPLY(TripletT, first, second, curvature, varCurvature, level, kinked)
+  C<std::uint32_t> first, second; ///< indices of tracklets a -> b and b -> c
+  C<Scalar> curvature;            ///< fitted signed 3D curvature, prop. to q/p [1/cm]; transverse is curvature / sin(theta)
+  C<Scalar> varCurvature;         ///< curvature variance [1/cm^2]
+  C<std::uint32_t> level;         ///< CA level: 1 from the triplet stage, set by the neighbour stage stratum by stratum; 32 bits for the tests' fixed-point sweep, an atomic max
+  C<std::uint8_t> kinked;         ///< 1 if it passed only with the iteration's kink allowance
+};
+// NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members,cppcoreguidelines-missing-std-forward,readability-identifier-naming)
+
+using Triplet = TripletT<memlayout::value>;
+using TripletConstView = memlayout::Wrapper<TripletT, memlayout::const_pointer, memlayout::Layout::soa>;
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRIPLET_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletCut.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletCut.h
new file mode 100644
index 0000000000000..00c33edae19fd
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletCut.h
@@ -0,0 +1,398 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TripletCut.h
+/// \brief The cuts a triplet passes.
+///
+/// A triplet is a tracklet a -> b on one link and b -> c on the next. It
+/// passes, cheapest first:
+///
+/// 1. the dip-angle cut, `|lambda_bc - lambda_ab|` within a half-width that
+///    depends on `a -> b` alone, so the triplet stage finds its candidates
+///    by a binary search in `b`'s lambda-sorted tracklets;
+/// 2. the boxes of `a` and `c` overlap;
+/// 3. the circle's curvature against pT_min;
+/// 4. the triplet fit's chi2;
+/// 5. the fit again with the scattering at the triplet's own momentum
+///    (`tripletOwnMomentumCompatible`).
+///
+/// A triplet failing 3-5 is tried once more with the iteration's kink
+/// allowance on the middle layer (`tripletCompatible`).
+///
+/// Every tolerance follows from the scattering, the measurements' errors and
+/// pT_min, with the iteration's `nSigma`.
+
+#ifndef GTRK_TRACKING_TRIPLETCUT_H_
+#define GTRK_TRACKING_TRIPLETCUT_H_
+
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/MathUtils.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/Trig.h"
+#include "GenericTracking/Tracking/TripletFit.h"
+#include "GenericTracking/Tracking/WorkCounters.h"
+
+#include "GPUCommonMath.h"
+
+#include <cstddef>
+#include <numbers>
+
+namespace o2::gtrk
+{
+
+/// A measurement as the triplet cuts read it.
+struct TimedPoint {
+  PairPoint point;
+  TimeEstPS time; ///< the time box
+};
+
+/// Row \a row of \a columns as a `TimedPoint`, reading only the columns it holds.
+template <typename Columns>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() TimedPoint timedPointAt(const Columns& columns, std::uint32_t row)
+{
+  return {.point = pairPointAt(columns, row), .time = timeBoxAt(columns, row)};
+}
+
+/// Bounds on the third measurement's variances over the rows a triplet can
+/// read on its layer: the dip-angle half-width is fixed before they are seen.
+struct TripletTargetBounds {
+  Scalar varZ = 0.F;
+  Scalar varR = 0.F;
+  Scalar varRPhi = 0.F;
+};
+
+namespace detail
+{
+
+/// How far a chord's dip angle can lie from the helix's, at most, for the
+/// chord's half-turn sine \a halfTurnSine and a chord slope \a slope.
+///
+/// `tan(lambda_chord) = tan(lambda) f(x)`, `f(x) = asin(x)/x`, so the chord
+/// is steeper by `atan(t f) - atan(t)`. That grows with the true slope `t` up
+/// to `t = 1/sqrt(f)`, where it is `atan((f - 1)/(2 sqrt(f)))`, and falls
+/// beyond. The chord's slope bounds the true one from above.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar chordDipExcess(Scalar halfTurnSine, Scalar slope, Scalar atanSlope)
+{
+  const Scalar f = asinOverArgument(o2::gpu::CAMath::Min(halfTurnSine, 1.F));
+  const Scalar peak = 1.F / o2::gpu::CAMath::Sqrt(f);
+  if (slope < peak) {
+    return atanOf(slope * f) - atanSlope;
+  }
+  return atanOf((f - 1.F) / (2.F * o2::gpu::CAMath::Sqrt(f)));
+}
+
+/// A measurement's variance across the chord with direction (\a ux, \a uy):
+/// its r and r-phi errors projected on the chord's normal.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar varianceAcross(const PairPoint& point, Scalar ux, Scalar uy)
+{
+  const Scalar invR = point.r > 0.F ? 1.F / point.r : 0.F;
+  const Scalar radialAcross = ((point.x * uy) - (point.y * ux)) * invR;
+  const Scalar tangentialAcross = ((point.x * ux) + (point.y * uy)) * invR;
+  return (point.varR * radialAcross * radialAcross) + (point.varRPhi * tangentialAcross * tangentialAcross);
+}
+
+} // namespace detail
+
+/// What `tripletLambdaHalfWidth` takes from the first tracklet `a -> b` alone,
+/// made once per first tracklet (`tripletFirstTerms`) and shared by the
+/// out-links of `b`: the chord's dip, the scattering up to `b` and each
+/// passive scatterer's full term at this dip, and the first two measurements'
+/// error terms.
+template <DetectorLayout Det>
+struct TripletFirstTerms {
+  static constexpr std::size_t kPassives = ScatteringTable<Det>::kPassiveCount > 0 ? ScatteringTable<Det>::kPassiveCount : 1U;
+  bool valid = false;        ///< the tracklet has a length
+  Scalar chord = 0.F;        ///< its transverse chord
+  Scalar sine = 0.F;         ///< |sin(lambda)|
+  Scalar cosine = 0.F;       ///< cos(lambda)
+  Scalar slope = 0.F;        ///< tan(lambda), 0 where cos(lambda) is 0
+  Scalar atanSlope = 0.F;    ///< atan(slope)
+  Scalar scattering = 0.F;   ///< `b`'s layer with the kink allowance, then the passives between `a` and `b` by their fraction
+  Scalar passive[kPassives]; ///< each passive scatterer's full term at this dip, for a second link that can cross it
+  Scalar inFirst = 0.F;      ///< 1 / L_ab
+  Scalar zFirst = 0.F;       ///< varZ_a / L_ab^2
+  Scalar chordFirst = 0.F;   ///< (varR_a + varRPhi_a) / L_ab^2
+  Scalar varZMiddle = 0.F;   ///< varZ_b
+  Scalar alongMiddle = 0.F;  ///< varR_b + varRPhi_b
+};
+
+/// \a scattering with each passive scatterer's full term (`TripletFirstTerms::passive`)
+/// added in order when the second link \a crossesPassives.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar withLinkPassives(const TripletFirstTerms<Det>& first, [[maybe_unused]] bool crossesPassives, Scalar scattering)
+{
+  if constexpr (ScatteringTable<Det>::kPassiveCount > 0) {
+    if (crossesPassives) {
+      for (std::size_t i = 0; i < ScatteringTable<Det>::kPassiveCount; ++i) {
+        scattering += first.passive[i];
+      }
+    }
+  }
+  return scattering;
+}
+
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() TripletFirstTerms<Det> tripletFirstTerms(const IterationParameters<Det>& parameters, LayerID middleLayer, const PairPoint& first, const PairPoint& middle)
+{
+  TripletFirstTerms<Det> terms;
+  terms.chord = pairChord(first, middle).chord;
+  const Scalar dz = middle.z - first.z;
+  const Scalar length = o2::gpu::CAMath::Hypot(terms.chord, dz);
+  if (!(length > 0.F)) {
+    return terms;
+  }
+  terms.valid = true;
+  terms.sine = o2::gpu::CAMath::Abs(dz) / length; // |sin(lambda)|
+  terms.cosine = terms.chord / length;            // cos(lambda)
+  terms.slope = terms.cosine > 0.F ? terms.sine / terms.cosine : 0.F;
+  terms.atanSlope = atanOf(terms.slope);
+  // The third measurement is not known yet: a passive scatterer between `a`
+  // and `b` enters with its fraction, one the second link can cross in full.
+  // The middle layer's own term takes the iteration's kink allowance, so the
+  // window holds the kinked triplets too (1 without one).
+  Scalar scattering = middleScattering(parameters.scattering, parameters.pairCut, middleLayer, terms.cosine) * parameters.graphKinkScale2;
+  visitPassivesBetween(parameters.scattering, parameters.pairCut, first, middle, terms.cosine, [&](Scalar passive, Scalar t) { scattering += passive * t * t; }, parameters.scattering.into(middleLayer));
+  terms.scattering = scattering;
+  if constexpr (ScatteringTable<Det>::kPassiveCount > 0) {
+    for (std::size_t i = 0; i < ScatteringTable<Det>::kPassiveCount; ++i) {
+      terms.passive[i] = passiveScattering(parameters.scattering.passives[i], parameters.pairCut, terms.cosine);
+    }
+  }
+  terms.inFirst = 1.F / length;
+  terms.zFirst = first.varZ * terms.inFirst * terms.inFirst;
+  const Scalar alongFirst = first.varR + first.varRPhi;
+  terms.chordFirst = alongFirst * terms.inFirst * terms.inFirst;
+  terms.varZMiddle = middle.varZ;
+  terms.alongMiddle = middle.varR + middle.varRPhi;
+  return terms;
+}
+
+/// The half-width of the dip-angle cut for the first tracklet `a -> b` and a
+/// second tracklet on \a secondLink, whose target's variances are bounded by
+/// \a target.
+///
+/// The sum of
+/// - the chords' excess over the helix's dip angle at the curvature bound,
+///   for the longer of `a -> b` and the second link's longest chord;
+/// - `n` sigma of the scattering at `b`, at pT_min, and of the three
+///   measurements' z and along-chord errors, with the second link's
+///   shortest length and the target's largest variances:
+///
+/// ```
+/// var = theta_0^2 + cos^2(lambda) [varZ_a/L_ab^2 + varZ_b (1/L_ab + 1/L_bc)^2 + varZ_c/L_bc^2]
+///                 + sin^2(lambda) [the same along the chord]
+/// ```
+///
+/// with `theta_0^2` the middle layer's scattering and the passive scatterers'
+/// (`tripletScattering`): those between `a` and `b` by their fraction, and on a
+/// second link that can cross one, each in full.
+///
+/// The along-chord error of a measurement is bounded by its r plus r-phi
+/// variance. Everything the target does not fix is taken where it is largest,
+/// so the half-width holds for every candidate on the link.
+///
+/// \a first is the first tracklet's part (`tripletFirstTerms`), the same for
+/// every out-link of `b`; this adds the link's.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar tripletLambdaHalfWidth(const IterationParameters<Det>& parameters, std::size_t secondLink, const TripletFirstTerms<Det>& first, const TripletTargetBounds& target)
+{
+  const auto& bounds = parameters.tripletBounds[secondLink];
+  if (!first.valid || !(bounds.lengthMin > 0.F)) {
+    return std::numbers::pi_v<Scalar>;
+  }
+  const Scalar longest = o2::gpu::CAMath::Max(first.chord, bounds.chordMax);
+  const Scalar excess = detail::chordDipExcess(0.5F * parameters.pairCut.maxCurvature * longest, first.slope, first.atanSlope);
+  const Scalar scattering = withLinkPassives(first, parameters.passiveBetween[secondLink], first.scattering);
+  const Scalar inSecond = 1.F / bounds.lengthMin;
+  const Scalar inMiddle = first.inFirst + inSecond;
+  const Scalar alongTarget = target.varR + target.varRPhi;
+  const Scalar zTerm = first.zFirst + (first.varZMiddle * inMiddle * inMiddle) + (target.varZ * inSecond * inSecond);
+  const Scalar chordTerm = first.chordFirst + (first.alongMiddle * inMiddle * inMiddle) + (alongTarget * inSecond * inSecond);
+  const Scalar variance = scattering + (first.cosine * first.cosine * zTerm) + (first.sine * first.sine * chordTerm);
+  return excess + (parameters.pairCut.nSigma * o2::gpu::CAMath::Sqrt(variance));
+}
+
+/// The same for one link from the points, the first tracklet's part made here.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar tripletLambdaHalfWidth(const IterationParameters<Det>& parameters, std::size_t secondLink, LayerID middleLayer, const PairPoint& first, const PairPoint& middle, const TripletTargetBounds& target)
+{
+  return tripletLambdaHalfWidth(parameters, secondLink, tripletFirstTerms(parameters, middleLayer, first, middle), target);
+}
+
+/// The first and the third measurement's boxes overlap: with the links' two
+/// pairs, the three boxes share a time.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool tripletTimeCompatible(const TimedPoint& first, const TimedPoint& third) { return first.time.isCompatible(third.time); }
+
+/// The circle through the three measurements curves at most as the softest
+/// track of the iteration, within `n` sigma.
+///
+/// Its curvature `2 (P_ab x P_bc) / (d_ab d_bc d_ac)` changes by `2/d_ac` times
+/// any change of the angle between the two chords, which moves `a` by its
+/// displacement over `d_ab`, `c` over `d_bc`, and `b` over both. The
+/// displacements are the measurements' errors across the chord `a -> c`, and
+/// the scattering at `b` turns the second chord by `theta_0 / cos(lambda)`.
+/// This is ACTS's circle, without the conformal map. \a middleScale multiplies
+/// the middle layer's scattering: the kink allowance (1 for the nominal cut).
+/// \a chords are the points' (`tripletChords`).
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool tripletCurvatureCompatible(const IterationParameters<Det>& parameters, LayerID middleLayer, const TripletChords& chords, const PairPoint& first, const PairPoint& middle, const PairPoint& third, Scalar middleScale = 1.F)
+{
+  const Scalar dxFirst = middle.x - first.x;
+  const Scalar dyFirst = middle.y - first.y;
+  const Scalar dxSecond = third.x - middle.x;
+  const Scalar dySecond = third.y - middle.y;
+  const Scalar dxWhole = third.x - first.x;
+  const Scalar dyWhole = third.y - first.y;
+  const Scalar chordFirst = chords.length01;
+  const Scalar chordSecond = chords.length12;
+  const Scalar chordWhole = chords.length02;
+  if (!(chordFirst > 0.F) || !(chordSecond > 0.F) || !(chordWhole > 0.F)) {
+    return false;
+  }
+  const Scalar cross = (dxFirst * dySecond) - (dyFirst * dxSecond);
+  const Scalar curvature = 2.F * o2::gpu::CAMath::Abs(cross) / (chordFirst * chordSecond * chordWhole);
+  const Scalar excess = curvature - parameters.pairCut.maxCurvature;
+  if (!(excess > 0.F)) {
+    return true;
+  }
+
+  const Scalar dz = third.z - first.z;
+  const Scalar cosine2 = (chordWhole * chordWhole) / ((chordWhole * chordWhole) + (dz * dz)); // cos^2(lambda)
+  const Scalar scattering = tripletScattering(parameters.scattering, parameters.pairCut, middleLayer, first, middle, third, o2::gpu::CAMath::Sqrt(cosine2), middleScale) / cosine2;
+  const Scalar ux = dxWhole / chordWhole;
+  const Scalar uy = dyWhole / chordWhole;
+  const Scalar inFirst = 1.F / chordFirst;
+  const Scalar inSecond = 1.F / chordSecond;
+  const Scalar inMiddle = inFirst + inSecond;
+  const Scalar angleVariance = scattering + (detail::varianceAcross(first, ux, uy) * inFirst * inFirst) + (detail::varianceAcross(middle, ux, uy) * inMiddle * inMiddle) + (detail::varianceAcross(third, ux, uy) * inSecond * inSecond);
+  const Scalar scale = 2.F / chordWhole;
+  const Scalar nSigma = parameters.pairCut.nSigma;
+  return excess * excess <= nSigma * nSigma * scale * scale * angleVariance;
+}
+
+/// The same, the chords made here.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool tripletCurvatureCompatible(const IterationParameters<Det>& parameters, LayerID middleLayer, const PairPoint& first, const PairPoint& middle, const PairPoint& third, Scalar middleScale = 1.F)
+{
+  return tripletCurvatureCompatible(parameters, middleLayer, tripletChords(first, middle, third), first, middle, third, middleScale);
+}
+
+namespace detail
+{
+
+/// The fit's chi2 cut again, every scatterer's variance taken at the
+/// triplet's own momentum instead of pT_min's:
+/// the momentum of the fitted curvature raised by `nSigma` of its sigmas, the
+/// variance never above pT_min's. A triplet as soft as pT_min keeps the fit
+/// just made; a stiffer one is refitted from its kink terms. The window and
+/// the first fit take pT_min's variance, as a track at pT_min needs; this
+/// takes from a stiff-looking triplet the allowance only a soft track needs.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool tripletOwnMomentumCompatible(const IterationParameters<Det>& parameters, LayerID middleLayer, const PairPoint& first, const PairPoint& middle, const PairPoint& third, Scalar middleScale, const TripletFitResult& fit, const KinkTerms& terms)
+{
+  const PairCut& nominal = parameters.pairCut;
+  const Scalar raised = o2::gpu::CAMath::Abs(fit.curvature) + (nominal.nSigma * o2::gpu::CAMath::Sqrt(fit.varCurvature));
+  if (!(nominal.momentumCurvature > 0.F) || !(raised > 0.F) || !(terms.sineTheta > 0.F)) {
+    return true;
+  }
+  const Scalar momentum = nominal.momentumCurvature / raised;
+  const Scalar pt = momentum * terms.sineTheta;
+  const Scalar own = (1.F + (nominal.mass2 / (momentum * momentum))) / (pt * pt);
+  if (!(own < nominal.invBetaMomentum2)) {
+    return true;
+  }
+  PairCut cut = nominal;
+  cut.invBetaMomentum2 = own;
+  TripletFitFactor factor;
+  TripletFitResult refit;
+  return makeTripletFitFactor(terms, first, middle, third, tripletScattering(parameters.scattering, cut, middleLayer, first, middle, third, terms.sineTheta, middleScale), factor) && fitTriplet(factor, refit) && refit.chi2 <= nominal.nSigma * nominal.nSigma;
+}
+
+/// The curvature test and the fit with the middle layer's scattering times
+/// \a middleScale: the nominal cuts at 1, the kink allowance at the
+/// iteration's `graphKinkScale2`. The kink terms depend on the three points alone:
+/// the first try to fit makes them into \a terms (\a made, and \a valid with
+/// `makeKinkTerms`' result) and the other reuses them. Both read the points'
+/// \a chords.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool tripletSpatiallyCompatible(const IterationParameters<Det>& parameters, LayerID middleLayer, const TimedPoint& first, const TimedPoint& middle, const TimedPoint& third, const TripletChords& chords, Scalar middleScale, TripletFitResult& fit, KinkTerms& terms, bool& made, bool& valid)
+{
+  if (!tripletCurvatureCompatible(parameters, middleLayer, chords, first.point, middle.point, third.point, middleScale)) {
+    countWork(WorkCounter::kTripletCurvature);
+    return false;
+  }
+  countWork(WorkCounter::kTripletFits);
+  TripletFitResult result;
+  bool fitted = false;
+  {
+    const WorkTimer timer{WorkCounter::kTripletFitNS};
+    if (!made) {
+      valid = makeKinkTerms(chords, first.point, middle.point, third.point, terms);
+      made = true;
+    }
+    fitted = valid && fitTriplet(terms, first.point, middle.point, third.point, middleLayer, parameters.scattering, parameters.pairCut, result, middleScale);
+  }
+  if (!fitted) {
+    countWork(WorkCounter::kTripletFitFailed);
+    return false;
+  }
+  const Scalar nSigma = parameters.pairCut.nSigma;
+  if (!(result.chi2 <= nSigma * nSigma)) {
+    countWork(WorkCounter::kTripletChi2);
+    return false;
+  }
+  if (!tripletOwnMomentumCompatible(parameters, middleLayer, first.point, middle.point, third.point, middleScale, result, terms)) {
+    countWork(WorkCounter::kTripletOwnMomentum);
+    return false;
+  }
+  fit = result;
+  return true;
+}
+
+} // namespace detail
+
+/// Every cut after the dip angle; \a fit receives the triplet fit and \a
+/// terms the triplet's kink terms when all pass. A triplet that fails the
+/// curvature test, the fit or its refit at its own momentum -- not the time
+/// cut -- is tried once more with the iteration's kink allowance on the middle
+/// layer's scattering (`graphKinkScale2`), its kink
+/// terms made once for both; if it passes then, \a kinked is set and \a fit is
+/// the kinked fit, its variance enlarged. Without an allowance there is no
+/// second try.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool tripletCompatible(const IterationParameters<Det>& parameters, LayerID middleLayer, const TimedPoint& first, const TimedPoint& middle, const TimedPoint& third, TripletFitResult& fit, KinkTerms& terms, bool& kinked)
+{
+  kinked = false;
+  if (!tripletTimeCompatible(first, third)) {
+    countWork(WorkCounter::kTripletTime);
+    return false;
+  }
+  const auto chords = tripletChords(first.point, middle.point, third.point);
+  bool made = false;
+  bool valid = false;
+  if (detail::tripletSpatiallyCompatible(parameters, middleLayer, first, middle, third, chords, 1.F, fit, terms, made, valid)) {
+    return true;
+  }
+  if (!(parameters.graphKinkScale2 > 1.F)) {
+    return false;
+  }
+  if (!detail::tripletSpatiallyCompatible(parameters, middleLayer, first, middle, third, chords, parameters.graphKinkScale2, fit, terms, made, valid)) {
+    return false;
+  }
+  countWork(WorkCounter::kTripletKinked);
+  kinked = true;
+  return true;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRIPLETCUT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletEndIndex.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletEndIndex.h
new file mode 100644
index 0000000000000..8cb868d17b9d2
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletEndIndex.h
@@ -0,0 +1,171 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TripletEndIndex.h
+/// \brief The triplets ending with each tracklet: the neighbour stage's
+///        candidates.
+
+#ifndef GTRK_TRACKING_TRIPLETENDINDEX_H_
+#define GTRK_TRACKING_TRIPLETENDINDEX_H_
+
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Base/HostAlgorithms.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/Triplet.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <span>
+
+namespace o2::gtrk
+{
+
+/// Triplets `T1 = (a, b, c)` and `T2 = (b, c, d)` are neighbours when
+/// `T1.second == T2.first`, so the neighbour stage looks up, for each `T2`,
+/// the triplets whose second tracklet is `T2.first`.
+///
+/// A counting sort of the triplet indices by their second tracklet: offsets
+/// per tracklet, and within each tracklet the triplet indices in arena order.
+/// The key (second tracklet, triplet index) is unique, so any sort -- a
+/// device radix sort included -- gives the same index.
+///
+/// On the host the sort runs in two levels without atomics:
+/// the arena in chunks of
+/// `kChunkTriplets`, the tracklets in buckets of `kBucketTracklets`. Each chunk
+/// counts its triplets per bucket; a serial scan of the chunk x bucket table,
+/// small, gives each bucket its start and each chunk its cursor in each
+/// bucket (the table is chunks x buckets, so the chunks are at most
+/// \a maxChunks, the caller's tasks, and at least `kChunkTriplets` long, so the
+/// table stays small); each chunk places its triplets at its cursors, so a bucket holds
+/// its triplets in chunk order, which is arena order; then each bucket sorts
+/// its own by their second tracklet, a counting sort over its tracklets alone,
+/// into the offsets and the index.
+class TripletEndIndex
+{
+ public:
+  using Index = typename StageOutput<TripletT>::Index;
+  static_assert(sizeof(Index) == 4U);
+  static constexpr Index kChunkTriplets = 4096U;   ///< triplets per chunk of the first level
+  static constexpr Index kBucketTracklets = 4096U; ///< tracklets per bucket: a bucket's counts fit a thread's cache
+
+  TripletEndIndex() = default;
+  ~TripletEndIndex() = default;
+  TripletEndIndex(const TripletEndIndex&) = delete;
+  TripletEndIndex& operator=(const TripletEndIndex&) = delete;
+  TripletEndIndex(TripletEndIndex&&) = delete;
+  TripletEndIndex& operator=(TripletEndIndex&&) = delete;
+
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
+  {
+    mMemoryPool.swap(pool);
+    clearStorage();
+  }
+
+  /// Index \a triplets, whose tracklet indices are below \a trackletCount, the
+  /// chunks and the buckets through \a forEach(count, body): body(i) once for
+  /// every i in [0, count), one task per i; at most \a maxChunks chunks,
+  /// \a maxChunks > 0. The index is the same for any chunking.
+  template <typename ForEach>
+  [[nodiscard]] StageStatus build(Index trackletCount, const StageOutput<TripletT>& triplets, const ForEach& forEach, Index maxChunks)
+  {
+    return guardOutOfMemory([&] {
+      const auto view = triplets.view();
+      const Index count = triplets.size();
+      const Index buckets = 1U + (trackletCount / kBucketTracklets);
+      const Index perChunk = std::max(kChunkTriplets, count / maxChunks + 1U);
+      const host_algorithms::Chunking chunking{count, perChunk};
+      const Index chunks = chunking.count();
+      // Kept from slice to slice and written whole before they are read.
+      resizeBoundedVector(mOffsets, static_cast<std::size_t>(trackletCount) + 1U, mMemoryPool.get());
+      resizeBoundedVector(mTriplets, count, mMemoryPool.get());
+      resizeBoundedVector(mByBucket, count, mMemoryPool.get());
+      resizeBoundedVector(mCursors, static_cast<std::size_t>(chunks) * buckets, mMemoryPool.get());
+      resizeBoundedVector(mBucketStarts, static_cast<std::size_t>(buckets) + 1U, mMemoryPool.get());
+      // 1. Each chunk's triplets per bucket.
+      forEach(chunks, [&](Index chunk) {
+        Index* row = mCursors.data() + (static_cast<std::size_t>(chunk) * buckets);
+        std::fill_n(row, buckets, Index{0U});
+        const Index end = chunking.end(chunk);
+        for (Index triplet = chunking.begin(chunk); triplet < end; ++triplet) {
+          ++row[view.second[triplet] / kBucketTracklets];
+        }
+      });
+      // 2. Where each bucket begins, and each chunk's cursor in it: the
+      // exclusive sums in (bucket, chunk) order.
+      Index total = 0U;
+      for (Index bucket = 0U; bucket < buckets; ++bucket) {
+        mBucketStarts[bucket] = total;
+        for (Index chunk = 0U; chunk < chunks; ++chunk) {
+          Index& cell = mCursors[(static_cast<std::size_t>(chunk) * buckets) + bucket];
+          const Index counted = cell;
+          cell = total;
+          total += counted;
+        }
+      }
+      mBucketStarts[buckets] = total;
+      // 3. Each chunk places its triplets at its cursors, in arena order: a
+      // bucket's triplets end in chunk order, so in arena order.
+      forEach(chunks, [&](Index chunk) {
+        Index* cursor = mCursors.data() + (static_cast<std::size_t>(chunk) * buckets);
+        const Index end = chunking.end(chunk);
+        for (Index triplet = chunking.begin(chunk); triplet < end; ++triplet) {
+          mByBucket[cursor[view.second[triplet] / kBucketTracklets]++] = triplet;
+        }
+      });
+      // 4. Each bucket by second tracklet: the counts, then each tracklet's
+      // offset from the bucket's start, then the placement behind a cursor per
+      // tracklet, the bucket's triplets taken in arena order.
+      forEach(buckets, [&](Index bucket) {
+        const Index firstTracklet = bucket * kBucketTracklets;
+        const Index endTracklet = std::min(trackletCount, firstTracklet + kBucketTracklets);
+        const Index begin = mBucketStarts[bucket];
+        const Index end = mBucketStarts[bucket + 1U];
+        std::array<Index, kBucketTracklets + 1U> local{};
+        for (Index at = begin; at < end; ++at) {
+          ++local[(view.second[mByBucket[at]] - firstTracklet) + 1U];
+        }
+        local[0] = begin;
+        for (Index tracklet = firstTracklet; tracklet < endTracklet; ++tracklet) {
+          local[(tracklet - firstTracklet) + 1U] += local[tracklet - firstTracklet];
+          mOffsets[tracklet] = local[tracklet - firstTracklet];
+        }
+        for (Index at = begin; at < end; ++at) {
+          const Index triplet = mByBucket[at];
+          mTriplets[local[view.second[triplet] - firstTracklet]++] = triplet;
+        }
+      });
+      mOffsets[trackletCount] = count;
+      return StageStatus::kComplete;
+    });
+  }
+
+  void clearStorage() noexcept { deepVectorClear(mMemoryPool.get(), mOffsets, mTriplets, mByBucket, mCursors, mBucketStarts); }
+
+  /// The raw columns the device stage reads: `trackletCount + 1` offsets and
+  /// the triplet indices they delimit.
+  [[nodiscard]] const Index* offsets() const { return mOffsets.data(); }
+  [[nodiscard]] const Index* triplets() const { return mTriplets.data(); }
+
+ private:
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  BoundedVector<Index> mOffsets;
+  BoundedVector<Index> mTriplets;
+  BoundedVector<Index> mByBucket;     ///< the triplets by bucket, in arena order within one (the first level)
+  BoundedVector<Index> mCursors;      ///< chunks x buckets: the counts, then the cursors
+  BoundedVector<Index> mBucketStarts; ///< buckets + 1
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRIPLETENDINDEX_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletFit.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletFit.h
new file mode 100644
index 0000000000000..6e085a0960eb1
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletFit.h
@@ -0,0 +1,807 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TripletFit.h
+/// \brief The General Triplet Track Fit factor for one GTRK triplet.
+///
+/// Adapted from O2 ITSMFTTracking/TripletFitting.h and TripletFitting.cxx.
+/// The measurement covariance of the kinks needs their gradient along the
+/// nine measurement axes of the three points; `kinkGradient` differentiates
+/// the kinks by hand, in reverse through the few intermediates they are made
+/// of, where ITS stores a nine-coordinate Jacobian.
+
+#ifndef GTRK_TRACKING_TRIPLETFIT_H_
+#define GTRK_TRACKING_TRIPLETFIT_H_
+
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/Trig.h"
+#include "GenericTracking/Tracking/Triplet.h"
+
+#include "GPUCommonMath.h"
+
+#include <cstddef>
+#include <limits>
+
+namespace o2::gtrk
+{
+
+struct TripletKinkVector {
+  Scalar theta = 0.F;
+  Scalar phi = 0.F;
+};
+
+/// The measurement axes of a triplet: radial, r-phi and z of each of its
+/// three points, direction `3 slot + axis`.
+inline constexpr std::size_t kTripletAxes = 9;
+
+/// What the fits read of a triplet `a b c` beyond its points' errors: the
+/// kinks `psi` at `b` and their slopes `rho` in the curvature, sin(theta) from
+/// `a` to `c`, and the gradient of `psi + kappa rho` along the measurement
+/// axes, kappa the triplet's reference curvature. The triplet fit and the
+/// neighbour fit of two adjacent triplets each make them from the points
+/// where a fit needs them, not stored (92 bytes per triplet).
+struct KinkTerms {
+  TripletKinkVector psi{};
+  TripletKinkVector rho{};
+  Scalar sineTheta = 0.F;
+  Scalar theta[kTripletAxes]{};
+  Scalar phi[kTripletAxes]{};
+};
+
+/// The kinks `psi` at the middle point, theta and phi, and their slopes `rho`
+/// in the curvature.
+struct TripletKinks {
+  TripletKinkVector psi{};
+  TripletKinkVector rho{};
+  bool valid = false;
+};
+
+struct TripletKinkCovariance {
+  Scalar thetaTheta = 0.F;
+  Scalar thetaPhi = 0.F;
+  Scalar phiPhi = 0.F;
+};
+
+struct TripletFitFactor {
+  TripletKinkVector psi{};
+  TripletKinkVector rho{};
+  TripletKinkCovariance covariance{};
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() bool isValid() const { return o2::gpu::GPUCommonMath::Abs(rho.phi) > 0.F; }
+};
+
+/// The triplet fit's curvature is its own parameter, the 3D curvature: it is
+/// proportional to q/p, and the transverse curvature is it over sin(theta).
+/// Adjacent triplets share it, which is why it is the one stored.
+struct TripletFitResult {
+  Scalar curvature = 0.F;
+  Scalar varCurvature = 0.F;
+  Scalar chi2 = 0.F;
+};
+
+/// A triplet's transverse chords, a -> b, b -> c and a -> c: made once per
+/// candidate for the curvature test, the kinks and the reference dip,
+/// the same expressions each made.
+struct TripletChords {
+  Scalar length01 = 0.F;
+  Scalar length12 = 0.F;
+  Scalar length02 = 0.F;
+};
+
+[[nodiscard]] GPUhdi() GPUAlwaysInline() TripletChords tripletChords(const PairPoint& first, const PairPoint& middle, const PairPoint& third)
+{
+  const Scalar dx01 = middle.x - first.x;
+  const Scalar dy01 = middle.y - first.y;
+  const Scalar dx12 = third.x - middle.x;
+  const Scalar dy12 = third.y - middle.y;
+  const Scalar dx02 = third.x - first.x;
+  const Scalar dy02 = third.y - first.y;
+  return {.length01 = o2::gpu::CAMath::Hypot(dx01, dy01), .length12 = o2::gpu::CAMath::Hypot(dx12, dy12), .length02 = o2::gpu::CAMath::Hypot(dx02, dy02)};
+}
+
+/// The kinks, the reference curvature `kappa = -psi.phi / rho.phi`, and the
+/// gradient of `psi.theta + kappa rho.theta` and `psi.phi + kappa rho.phi`
+/// along the measurement axes: what the covariance of the kinks is made of.
+struct KinkGradient {
+  TripletKinks kinks;
+  Scalar kappa = 0.F;
+  Scalar theta[kTripletAxes]{};
+  Scalar phi[kTripletAxes]{};
+};
+
+namespace detail
+{
+
+/// An adjoint of the two combinations at once.
+struct KinkAdjoint {
+  Scalar theta = 0.F;
+  Scalar phi = 0.F;
+};
+
+[[nodiscard]] GPUhdi() GPUAlwaysInline() KinkAdjoint operator*(const KinkAdjoint& adjoint, Scalar factor) { return {.theta = adjoint.theta * factor, .phi = adjoint.phi * factor}; }
+
+GPUhdi() GPUAlwaysInline() KinkAdjoint& operator+=(KinkAdjoint& adjoint, const KinkAdjoint& other)
+{
+  adjoint.theta += other.theta;
+  adjoint.phi += other.phi;
+  return adjoint;
+}
+
+GPUhdi() GPUAlwaysInline() KinkAdjoint& operator-=(KinkAdjoint& adjoint, const KinkAdjoint& other)
+{
+  adjoint.theta -= other.theta;
+  adjoint.phi -= other.phi;
+  return adjoint;
+}
+
+/// One segment of the helix between two points: its chord, delta z and the
+/// values the kinks read, and the slopes of its half angle, arc factor and
+/// angle cotangent in the half sine, for the reverse pass.
+struct SegmentForward {
+  Scalar chord = 0.F;
+  Scalar deltaZ = 0.F;
+  Scalar halfAngle = 0.F;
+  Scalar asinOverArgument = 0.F;
+  Scalar angleCotangent = 0.F;
+  Scalar bendingAngle = 0.F;
+  Scalar arc = 0.F;
+  Scalar cotangent = 0.F;
+  Scalar sine = 0.F;
+  Scalar cosine = 0.F;
+  Scalar index = 0.F;
+  Scalar theta = 0.F;
+  Scalar halfAngleSlope = 0.F;        ///< d halfAngle / d halfSine
+  Scalar asinOverArgumentSlope = 0.F; ///< d asinOverArgument / d halfSine
+  Scalar angleCotangentSlope = 0.F;   ///< d angleCotangent / d halfSine
+  bool valid = false;
+};
+
+[[nodiscard]] GPUhdi() SegmentForward segmentForward(Scalar curvature, Scalar chord, Scalar deltaZ)
+{
+  SegmentForward segment{.chord = chord, .deltaZ = deltaZ};
+  const Scalar halfSine = 0.5F * curvature * chord;
+  if (o2::gpu::GPUCommonMath::Abs(halfSine) >= 1.F) {
+    return segment;
+  }
+  const Scalar halfSine2 = halfSine * halfSine;
+  const Scalar halfSine4 = halfSine2 * halfSine2;
+  const Scalar halfAngle = asinOf(halfSine);
+  const Scalar root = o2::gpu::GPUCommonMath::Sqrt(1.F - halfSine2);
+  if (o2::gpu::GPUCommonMath::Abs(halfSine) < 1.e-4F) {
+    segment.asinOverArgument = 1.F + halfSine2 * (1.F / 6.F) + halfSine4 * (3.F / 40.F);
+    segment.angleCotangent = 1.F - halfSine2 * (1.F / 3.F) - halfSine4 * (2.F / 15.F);
+    segment.asinOverArgumentSlope = halfSine * (1.F / 3.F) + halfSine2 * halfSine * (3.F / 10.F);
+    segment.angleCotangentSlope = -(halfSine * (2.F / 3.F)) - halfSine2 * halfSine * (8.F / 15.F);
+  } else {
+    segment.asinOverArgument = halfAngle / halfSine;
+    segment.angleCotangent = halfAngle * root / halfSine;
+    segment.asinOverArgumentSlope = (1.F / root - segment.asinOverArgument) / halfSine;
+    segment.angleCotangentSlope = (1.F - segment.angleCotangent) / halfSine - halfAngle / root;
+  }
+  segment.halfAngle = halfAngle;
+  segment.halfAngleSlope = 1.F / root;
+  segment.bendingAngle = 2.F * halfAngle;
+  segment.arc = chord * segment.asinOverArgument;
+  segment.cotangent = deltaZ / segment.arc;
+  segment.sine = 1.F / o2::gpu::GPUCommonMath::Sqrt(1.F + segment.cotangent * segment.cotangent);
+  segment.cosine = segment.cotangent * segment.sine;
+  segment.index = 1.F / (segment.angleCotangent * segment.sine * segment.sine + segment.cosine * segment.cosine);
+  segment.theta = atan2Of(segment.arc, deltaZ);
+  segment.valid = segment.arc > 0.F && segment.sine > 0.F && segment.index > 0.F;
+  return segment;
+}
+
+/// The adjoints a segment's outputs received.
+struct SegmentAdjoint {
+  KinkAdjoint bendingAngle;
+  KinkAdjoint arc;
+  KinkAdjoint cotangent;
+  KinkAdjoint sine;
+  KinkAdjoint cosine;
+  KinkAdjoint index;
+  KinkAdjoint theta;
+};
+
+/// A segment's adjoints carried back to its curvature, chord and delta z.
+GPUhdi() void segmentBackward(const SegmentForward& s, SegmentAdjoint adjoint, Scalar curvature, KinkAdjoint& curvatureAdjoint, KinkAdjoint& chordAdjoint, KinkAdjoint& deltaZAdjoint)
+{
+  // theta = atan2(arc, deltaZ)
+  const Scalar radius2 = s.arc * s.arc + s.deltaZ * s.deltaZ;
+  adjoint.arc += adjoint.theta * (s.deltaZ / radius2);
+  deltaZAdjoint -= adjoint.theta * (s.arc / radius2);
+  // index = 1 / (angleCotangent sine^2 + cosine^2)
+  const KinkAdjoint denominator = adjoint.index * (-(s.index * s.index));
+  const KinkAdjoint angleCotangent = denominator * (s.sine * s.sine);
+  adjoint.sine += denominator * (2.F * s.angleCotangent * s.sine);
+  adjoint.cosine += denominator * (2.F * s.cosine);
+  // cosine = cotangent sine
+  adjoint.cotangent += adjoint.cosine * s.sine;
+  adjoint.sine += adjoint.cosine * s.cotangent;
+  // sine = (1 + cotangent^2)^(-1/2)
+  adjoint.cotangent -= adjoint.sine * (s.cotangent * s.sine * s.sine * s.sine);
+  // cotangent = deltaZ / arc
+  deltaZAdjoint += adjoint.cotangent * (1.F / s.arc);
+  adjoint.arc -= adjoint.cotangent * (s.cotangent / s.arc);
+  // arc = chord asinOverArgument
+  chordAdjoint += adjoint.arc * s.asinOverArgument;
+  const KinkAdjoint asinOverArgument = adjoint.arc * s.chord;
+  // bendingAngle = 2 halfAngle, and the three functions of the half sine
+  KinkAdjoint halfSine = adjoint.bendingAngle * (2.F * s.halfAngleSlope);
+  halfSine += asinOverArgument * s.asinOverArgumentSlope;
+  halfSine += angleCotangent * s.angleCotangentSlope;
+  // halfSine = curvature chord / 2
+  curvatureAdjoint += halfSine * (0.5F * s.chord);
+  chordAdjoint += halfSine * (0.5F * curvature);
+}
+
+/// A chord's adjoint carried to its two coordinate differences.
+GPUhdi() GPUAlwaysInline() void chordBackward(const KinkAdjoint& chordAdjoint, Scalar dx, Scalar dy, Scalar chord, KinkAdjoint& dxAdjoint, KinkAdjoint& dyAdjoint)
+{
+  dxAdjoint += chordAdjoint * (dx / chord);
+  dyAdjoint += chordAdjoint * (dy / chord);
+}
+
+} // namespace detail
+
+/// The kinks and their gradient: the forward pass computes the kinks, the
+/// reverse pass carries the adjoints of `psi + kappa rho` back through the
+/// chords, the curvature and each segment's half sine, arc, cotangent, sine,
+/// cosine and index to the three points, and projects them on each point's
+/// radial, r-phi and z axes. Invalid where the kinks are not defined.
+/// \a chords are the points' (`tripletChords`).
+[[nodiscard]] GPUhdi() GPUAlwaysInline() KinkGradient kinkGradient(const TripletChords& chords, const PairPoint& first, const PairPoint& middle, const PairPoint& third)
+{
+  KinkGradient result;
+  const Scalar dx01 = middle.x - first.x;
+  const Scalar dy01 = middle.y - first.y;
+  const Scalar dz01 = middle.z - first.z;
+  const Scalar dx12 = third.x - middle.x;
+  const Scalar dy12 = third.y - middle.y;
+  const Scalar dz12 = third.z - middle.z;
+  const Scalar dx02 = third.x - first.x;
+  const Scalar dy02 = third.y - first.y;
+  const Scalar length01 = chords.length01;
+  const Scalar length12 = chords.length12;
+  const Scalar length02 = chords.length02;
+  if (!(length01 > 0.F) || !(length12 > 0.F) || !(length02 > 0.F)) {
+    return result;
+  }
+  const Scalar cross = dx01 * dy12 - dy01 * dx12;
+  const Scalar lengths = length01 * length12 * length02;
+  const Scalar curvature = 2.F * cross / lengths;
+  const auto s1 = detail::segmentForward(curvature, length01, dz01);
+  const auto s2 = detail::segmentForward(curvature, length12, dz12);
+  if (!s1.valid || !s2.valid) {
+    return result;
+  }
+
+  const Scalar psiPhi = 0.5F * (s1.bendingAngle * s1.index + s2.bendingAngle * s2.index);
+  const Scalar psiTheta = s2.theta - s1.theta + (1.F - s2.index) * s2.cotangent - (1.F - s1.index) * s1.cotangent;
+  const Scalar rhoPhi = -0.5F * (s1.arc * s1.index / s1.sine + s2.arc * s2.index / s2.sine);
+  const Scalar maximumLength = length01 > length12 ? length01 : length12;
+  // Below this the slope's closed form cancels; its expansion to first order.
+  const bool straight = 0.5F * o2::gpu::GPUCommonMath::Abs(curvature) * maximumLength < 1.e-4F;
+  Scalar rhoTheta = 0.F;
+  if (straight) {
+    rhoTheta = curvature * (length12 * length12 * s2.cosine - length01 * length01 * s1.cosine) / 12.F;
+  } else {
+    rhoTheta = ((1.F - s1.index) * s1.cotangent / s1.sine - (1.F - s2.index) * s2.cotangent / s2.sine) / curvature;
+  }
+  if (!(o2::gpu::GPUCommonMath::Abs(rhoPhi) > 0.F)) {
+    return result;
+  }
+  result.kinks = {.psi = {.theta = psiTheta, .phi = psiPhi}, .rho = {.theta = rhoTheta, .phi = rhoPhi}, .valid = true};
+  const Scalar kappa = -psiPhi / rhoPhi;
+  result.kappa = kappa;
+
+  // The adjoints of psi.theta + kappa rho.theta and psi.phi + kappa rho.phi.
+  using Adjoint = detail::KinkAdjoint;
+  const Adjoint psiThetaAdjoint{.theta = 1.F, .phi = 0.F};
+  const Adjoint psiPhiAdjoint{.theta = 0.F, .phi = 1.F};
+  const Adjoint rhoThetaAdjoint{.theta = kappa, .phi = 0.F};
+  const Adjoint rhoPhiAdjoint{.theta = 0.F, .phi = kappa};
+  detail::SegmentAdjoint a1;
+  detail::SegmentAdjoint a2;
+  Adjoint curvatureAdjoint;
+  Adjoint length01Adjoint;
+  Adjoint length12Adjoint;
+
+  // rhoPhi = -(arc index / sine)_1 / 2 - (arc index / sine)_2 / 2
+  const Adjoint half = rhoPhiAdjoint * -0.5F;
+  a1.arc += half * (s1.index / s1.sine);
+  a1.index += half * (s1.arc / s1.sine);
+  a1.sine -= half * (s1.arc * s1.index / (s1.sine * s1.sine));
+  a2.arc += half * (s2.index / s2.sine);
+  a2.index += half * (s2.arc / s2.sine);
+  a2.sine -= half * (s2.arc * s2.index / (s2.sine * s2.sine));
+  // psiPhi = (bendingAngle index)_1 / 2 + (bendingAngle index)_2 / 2
+  a1.bendingAngle += psiPhiAdjoint * (0.5F * s1.index);
+  a1.index += psiPhiAdjoint * (0.5F * s1.bendingAngle);
+  a2.bendingAngle += psiPhiAdjoint * (0.5F * s2.index);
+  a2.index += psiPhiAdjoint * (0.5F * s2.bendingAngle);
+  // psiTheta = theta_2 - theta_1 + (1 - index_2) cotangent_2 - (1 - index_1) cotangent_1
+  a2.theta += psiThetaAdjoint;
+  a1.theta -= psiThetaAdjoint;
+  a2.index -= psiThetaAdjoint * s2.cotangent;
+  a2.cotangent += psiThetaAdjoint * (1.F - s2.index);
+  a1.index += psiThetaAdjoint * s1.cotangent;
+  a1.cotangent -= psiThetaAdjoint * (1.F - s1.index);
+  if (straight) {
+    // rhoTheta = curvature (length12^2 cosine_2 - length01^2 cosine_1) / 12
+    const Scalar difference = length12 * length12 * s2.cosine - length01 * length01 * s1.cosine;
+    curvatureAdjoint += rhoThetaAdjoint * (difference / 12.F);
+    const Adjoint differenceAdjoint = rhoThetaAdjoint * (curvature / 12.F);
+    length12Adjoint += differenceAdjoint * (2.F * length12 * s2.cosine);
+    a2.cosine += differenceAdjoint * (length12 * length12);
+    length01Adjoint -= differenceAdjoint * (2.F * length01 * s1.cosine);
+    a1.cosine -= differenceAdjoint * (length01 * length01);
+  } else {
+    // rhoTheta = ((1 - index_1) cotangent_1 / sine_1 - (1 - index_2) cotangent_2 / sine_2) / curvature
+    const Adjoint numerator = rhoThetaAdjoint * (1.F / curvature);
+    curvatureAdjoint -= rhoThetaAdjoint * (rhoTheta / curvature);
+    a1.index -= numerator * (s1.cotangent / s1.sine);
+    a1.cotangent += numerator * ((1.F - s1.index) / s1.sine);
+    a1.sine -= numerator * ((1.F - s1.index) * s1.cotangent / (s1.sine * s1.sine));
+    a2.index += numerator * (s2.cotangent / s2.sine);
+    a2.cotangent -= numerator * ((1.F - s2.index) / s2.sine);
+    a2.sine += numerator * ((1.F - s2.index) * s2.cotangent / (s2.sine * s2.sine));
+  }
+
+  Adjoint dz01Adjoint;
+  Adjoint dz12Adjoint;
+  detail::segmentBackward(s1, a1, curvature, curvatureAdjoint, length01Adjoint, dz01Adjoint);
+  detail::segmentBackward(s2, a2, curvature, curvatureAdjoint, length12Adjoint, dz12Adjoint);
+
+  // curvature = 2 cross / (length01 length12 length02)
+  const Adjoint crossAdjoint = curvatureAdjoint * (2.F / lengths);
+  const Adjoint lengthsAdjoint = curvatureAdjoint * (-curvature / lengths);
+  length01Adjoint += lengthsAdjoint * (length12 * length02);
+  length12Adjoint += lengthsAdjoint * (length01 * length02);
+  const Adjoint length02Adjoint = lengthsAdjoint * (length01 * length12);
+  // cross = dx01 dy12 - dy01 dx12
+  Adjoint dx01Adjoint = crossAdjoint * dy12;
+  Adjoint dy12Adjoint = crossAdjoint * dx01;
+  Adjoint dy01Adjoint = crossAdjoint * (-dx12);
+  Adjoint dx12Adjoint = crossAdjoint * (-dy01);
+  Adjoint dx02Adjoint;
+  Adjoint dy02Adjoint;
+  detail::chordBackward(length01Adjoint, dx01, dy01, length01, dx01Adjoint, dy01Adjoint);
+  detail::chordBackward(length12Adjoint, dx12, dy12, length12, dx12Adjoint, dy12Adjoint);
+  detail::chordBackward(length02Adjoint, dx02, dy02, length02, dx02Adjoint, dy02Adjoint);
+
+  // The differences to the points, the points to their measurement axes.
+  Adjoint xAdjoint[3];
+  Adjoint yAdjoint[3];
+  Adjoint zAdjoint[3];
+  xAdjoint[0] -= dx01Adjoint;
+  xAdjoint[0] -= dx02Adjoint;
+  xAdjoint[1] += dx01Adjoint;
+  xAdjoint[1] -= dx12Adjoint;
+  xAdjoint[2] += dx12Adjoint;
+  xAdjoint[2] += dx02Adjoint;
+  yAdjoint[0] -= dy01Adjoint;
+  yAdjoint[0] -= dy02Adjoint;
+  yAdjoint[1] += dy01Adjoint;
+  yAdjoint[1] -= dy12Adjoint;
+  yAdjoint[2] += dy12Adjoint;
+  yAdjoint[2] += dy02Adjoint;
+  zAdjoint[0] -= dz01Adjoint;
+  zAdjoint[1] += dz01Adjoint;
+  zAdjoint[1] -= dz12Adjoint;
+  zAdjoint[2] += dz12Adjoint;
+  const PairPoint* points[3]{&first, &middle, &third};
+  for (int slot = 0; slot < 3; ++slot) {
+    const Scalar inverseR = 1.F / points[slot]->r;
+    const Scalar radialX = points[slot]->x * inverseR;
+    const Scalar radialY = points[slot]->y * inverseR;
+    const int radial = 3 * slot;
+    result.theta[radial] = xAdjoint[slot].theta * radialX + yAdjoint[slot].theta * radialY;
+    result.phi[radial] = xAdjoint[slot].phi * radialX + yAdjoint[slot].phi * radialY;
+    result.theta[radial + 1] = yAdjoint[slot].theta * radialX - xAdjoint[slot].theta * radialY;
+    result.phi[radial + 1] = yAdjoint[slot].phi * radialX - xAdjoint[slot].phi * radialY;
+    result.theta[radial + 2] = zAdjoint[slot].theta;
+    result.phi[radial + 2] = zAdjoint[slot].phi;
+  }
+  return result;
+}
+
+/// The same, the chords made here.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() KinkGradient kinkGradient(const PairPoint& first, const PairPoint& middle, const PairPoint& third) { return kinkGradient(tripletChords(first, middle, third), first, middle, third); }
+
+namespace detail
+{
+
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar axisVariance(const PairPoint& point, int axis)
+{
+  if (axis == 0) {
+    return point.varR;
+  }
+  if (axis == 1) {
+    return point.varRPhi;
+  }
+  return point.varZ;
+}
+
+/// The chord a -> c's sin(theta), its transverse length \a transverse.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar referenceSinTheta(Scalar transverse, const PairPoint& first, const PairPoint& third)
+{
+  const Scalar dz = third.z - first.z;
+  return transverse / o2::gpu::CAMath::Hypot(transverse, dz);
+}
+
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar referenceSinTheta(const PairPoint& first, const PairPoint& third)
+{
+  const Scalar dx = third.x - first.x;
+  const Scalar dy = third.y - first.y;
+  return referenceSinTheta(o2::gpu::CAMath::Hypot(dx, dy), first, third);
+}
+
+GPUhdi() GPUAlwaysInline() void addCovariance(TripletKinkCovariance& covariance, Scalar variance, Scalar thetaDerivative, Scalar phiDerivative)
+{
+  covariance.thetaTheta += variance * thetaDerivative * thetaDerivative;
+  covariance.thetaPhi += variance * thetaDerivative * phiDerivative;
+  covariance.phiPhi += variance * phiDerivative * phiDerivative;
+}
+
+/// The curvature that minimises `(psi + kappa rho)' V^-1 (psi + kappa rho)`,
+/// its variance and the chi2 left, from the three contractions with `V^-1`.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool curvatureFit(Scalar psiPrecisionPsi, Scalar rhoPrecisionPsi, Scalar rhoPrecisionRho, TripletFitResult& result)
+{
+  if (!(rhoPrecisionRho > 0.F)) {
+    return false;
+  }
+  const Scalar curvature = -rhoPrecisionPsi / rhoPrecisionRho;
+  const Scalar varCurvature = 1.F / rhoPrecisionRho;
+  const Scalar removedCurvatureTerm = rhoPrecisionPsi * rhoPrecisionPsi / rhoPrecisionRho;
+  Scalar chi2 = psiPrecisionPsi - removedCurvatureTerm;
+  const Scalar scale = o2::gpu::GPUCommonMath::Max(o2::gpu::GPUCommonMath::Abs(psiPrecisionPsi), o2::gpu::GPUCommonMath::Abs(removedCurvatureTerm));
+  const Scalar tolerance = 128.F * std::numeric_limits<Scalar>::epsilon() * scale;
+  if (chi2 < 0.F && chi2 >= -tolerance) {
+    chi2 = 0.F;
+  }
+  if (!(varCurvature > 0.F) || chi2 < 0.F) {
+    return false;
+  }
+  result = {.curvature = curvature, .varCurvature = varCurvature, .chi2 = chi2};
+  return true;
+}
+
+} // namespace detail
+
+/// The space-angle scattering variance at the middle layer, at pT_min and for
+/// a track at polar angle theta: `k` times the path factor over `p^2`.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar middleScattering(const ScatteringTable<Det>& table, const PairCut& cut, LayerID middleLayer, Scalar sineTheta)
+{
+  if (!(sineTheta > 0.F)) {
+    return 0.F;
+  }
+  const Scalar material = table.layers[static_cast<std::size_t>(middleLayer)].k;
+  if (Detector<Det>::isBarrelLayer(middleLayer)) {
+    return material * sineTheta * cut.invBetaMomentum2;
+  }
+  const Scalar cosineTheta = o2::gpu::GPUCommonMath::Sqrt(o2::gpu::GPUCommonMath::Max(0.F, 1.F - sineTheta * sineTheta));
+  return cosineTheta > 0.F ? material * sineTheta * sineTheta * cut.invBetaMomentum2 / cosineTheta : 0.F;
+}
+
+/// A passive scatterer's space-angle variance at pT_min, for a track at polar
+/// angle theta: as `middleScattering` takes a layer's.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar passiveScattering(const PassiveScatterer& passive, const PairCut& cut, Scalar sineTheta)
+{
+  if (!(sineTheta > 0.F)) {
+    return 0.F;
+  }
+  if (passive.barrel) {
+    return passive.at.k * sineTheta * cut.invBetaMomentum2;
+  }
+  const Scalar cosineTheta = o2::gpu::GPUCommonMath::Sqrt(o2::gpu::GPUCommonMath::Max(0.F, 1.F - sineTheta * sineTheta));
+  return cosineTheta > 0.F ? passive.at.k * sineTheta * sineTheta * cut.invBetaMomentum2 / cosineTheta : 0.F;
+}
+
+/// Calls \a visit(variance, t) for each passive scatterer the straight segment
+/// from \a from to \a to crosses, with its `passiveScattering` and the
+/// fraction `t` of the way it is crossed at: in radius for a cylinder, in z
+/// for a disc.
+///
+/// \a passives: the ones to try, a bit each, in index order; every passive by
+/// default. The table's `into` and `outOf` of the segment's layers hold every
+/// passive it can cross: the same visits.
+template <DetectorLayout Det, typename Visit>
+GPUhdi() GPUAlwaysInline() void visitPassivesBetween(const ScatteringTable<Det>& table, const PairCut& cut, const PairPoint& from, const PairPoint& to, Scalar sineTheta, Visit visit, std::uint64_t passives = ScatteringTable<Det>::kAllPassives)
+{
+  if constexpr (ScatteringTable<Det>::kPassiveCount > 0) {
+    for (std::uint64_t left = passives & ScatteringTable<Det>::kAllPassives; left != 0U; left &= left - 1U) {
+      const auto& passive = table.passives[o2::gpu::CAMath::Ctz64(left)];
+      const Scalar begin = passive.barrel ? from.r : from.z;
+      const Scalar end = passive.barrel ? to.r : to.z;
+      const Scalar span = end - begin;
+      if (!(o2::gpu::GPUCommonMath::Abs(span) > 0.F)) {
+        continue;
+      }
+      const Scalar t = (passive.at.position - begin) / span;
+      if (t <= 0.F || t >= 1.F) {
+        continue;
+      }
+      const Scalar along = passive.barrel ? from.z + (t * (to.z - from.z)) : from.r + (t * (to.r - from.r));
+      if (along < passive.at.low || along > passive.at.high) {
+        continue;
+      }
+      visit(passiveScattering(passive, cut, sineTheta), t);
+    }
+  }
+}
+
+/// The variance of the kink at a triplet's middle point: the middle layer's
+/// scattering and, as ALICE 3's pipe between its layers needs, every passive
+/// scatterer between the points. A kink `theta_p` a fraction `t` of the way
+/// from `a` to `b` turns the angle between the chords at `b` by `theta_p t`;
+/// one from `b` to `c` by `theta_p (1 - t)`. \a middleScale multiplies the
+/// middle layer's variance alone: the kink allowance of a kinked triplet.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar tripletScattering(const ScatteringTable<Det>& table, const PairCut& cut, LayerID middleLayer, const PairPoint& first, const PairPoint& middle, const PairPoint& third, Scalar sineTheta, Scalar middleScale = 1.F)
+{
+  Scalar variance = middleScattering(table, cut, middleLayer, sineTheta) * middleScale;
+  visitPassivesBetween(table, cut, first, middle, sineTheta, [&](Scalar passive, Scalar t) { variance += passive * t * t; }, table.into(middleLayer));
+  visitPassivesBetween(table, cut, middle, third, sineTheta, [&](Scalar passive, Scalar t) { variance += passive * (1.F - t) * (1.F - t); }, table.outOf(middleLayer));
+  return variance;
+}
+
+/// A triplet's kink terms from its \a chords (`tripletChords`); false where
+/// its kinks are not defined.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool makeKinkTerms(const TripletChords& chords, const PairPoint& first, const PairPoint& middle, const PairPoint& third, KinkTerms& terms)
+{
+  const auto gradient = kinkGradient(chords, first, middle, third);
+  const Scalar sineTheta = detail::referenceSinTheta(chords.length02, first, third);
+  if (!gradient.kinks.valid || !(sineTheta > 0.F)) {
+    return false;
+  }
+  terms.psi = gradient.kinks.psi;
+  terms.rho = gradient.kinks.rho;
+  terms.sineTheta = sineTheta;
+  for (std::size_t direction = 0; direction < kTripletAxes; ++direction) {
+    terms.theta[direction] = gradient.theta[direction];
+    terms.phi[direction] = gradient.phi[direction];
+  }
+  return true;
+}
+
+/// The same, the chords made here.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool makeKinkTerms(const PairPoint& first, const PairPoint& middle, const PairPoint& third, KinkTerms& terms) { return makeKinkTerms(tripletChords(first, middle, third), first, middle, third, terms); }
+
+/// The fit factor of a triplet from its kink terms and its points' errors.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool makeTripletFitFactor(const KinkTerms& terms, const PairPoint& first, const PairPoint& middle, const PairPoint& third, Scalar angularVariance, TripletFitFactor& result)
+{
+  const Scalar sineTheta = terms.sineTheta;
+  TripletFitFactor scratch{
+    .psi = terms.psi,
+    .rho = terms.rho,
+    .covariance = {.thetaTheta = angularVariance, .thetaPhi = 0.F, .phiPhi = angularVariance / (sineTheta * sineTheta)},
+  };
+  for (int hit = 0; hit < 3; ++hit) {
+    const PairPoint* point = &third;
+    if (hit == 0) {
+      point = &first;
+    } else if (hit == 1) {
+      point = &middle;
+    }
+    for (int axis = 0; axis < 3; ++axis) {
+      const int direction = (3 * hit) + axis;
+      detail::addCovariance(scratch.covariance, detail::axisVariance(*point, axis), terms.theta[direction], terms.phi[direction]);
+    }
+  }
+  if (!scratch.isValid()) {
+    return false;
+  }
+  result = scratch;
+  return true;
+}
+
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool fitTriplet(const TripletFitFactor& factor, TripletFitResult& result)
+{
+  const Scalar determinant = factor.covariance.thetaTheta * factor.covariance.phiPhi - factor.covariance.thetaPhi * factor.covariance.thetaPhi;
+  if (!(determinant > 0.F)) {
+    return false;
+  }
+  const Scalar inverseThetaTheta = factor.covariance.phiPhi / determinant;
+  const Scalar inverseThetaPhi = -factor.covariance.thetaPhi / determinant;
+  const Scalar inversePhiPhi = factor.covariance.thetaTheta / determinant;
+  const Scalar precisionPsiTheta = inverseThetaTheta * factor.psi.theta + inverseThetaPhi * factor.psi.phi;
+  const Scalar precisionPsiPhi = inverseThetaPhi * factor.psi.theta + inversePhiPhi * factor.psi.phi;
+  const Scalar precisionRhoTheta = inverseThetaTheta * factor.rho.theta + inverseThetaPhi * factor.rho.phi;
+  const Scalar precisionRhoPhi = inverseThetaPhi * factor.rho.theta + inversePhiPhi * factor.rho.phi;
+  const Scalar rhoPrecisionPsi = factor.rho.theta * precisionPsiTheta + factor.rho.phi * precisionPsiPhi;
+  const Scalar rhoPrecisionRho = factor.rho.theta * precisionRhoTheta + factor.rho.phi * precisionRhoPhi;
+  const Scalar psiPrecisionPsi = factor.psi.theta * precisionPsiTheta + factor.psi.phi * precisionPsiPhi;
+  return detail::curvatureFit(psiPrecisionPsi, rhoPrecisionPsi, rhoPrecisionRho, result);
+}
+
+/// The triplet fit from its kink \a terms (`makeKinkTerms`), with the
+/// scattering at the middle layer at pT_min from the pair cut's table, times
+/// \a middleScale.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool fitTriplet(const KinkTerms& terms, const PairPoint& first, const PairPoint& middle, const PairPoint& third, LayerID middleLayer, const ScatteringTable<Det>& table, const PairCut& cut, TripletFitResult& result, Scalar middleScale = 1.F)
+{
+  TripletFitFactor factor;
+  return makeTripletFitFactor(terms, first, middle, third, tripletScattering(table, cut, middleLayer, first, middle, third, terms.sineTheta, middleScale), factor) && fitTriplet(factor, result);
+}
+
+/// The same with the kink terms made here; \a terms receives them.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool fitTriplet(const PairPoint& first, const PairPoint& middle, const PairPoint& third, LayerID middleLayer, const ScatteringTable<Det>& table, const PairCut& cut, TripletFitResult& result, KinkTerms& terms, Scalar middleScale = 1.F)
+{
+  return makeKinkTerms(first, middle, third, terms) && fitTriplet(terms, first, middle, third, middleLayer, table, cut, result, middleScale);
+}
+
+namespace detail
+{
+
+constexpr int kAdjacentKinks = 4;
+
+/// Factor the symmetric positive definite \a covariance, given by its lower
+/// triangle, in place: the lower triangle becomes the Cholesky factor.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool choleskyDecompose(Scalar (&covariance)[kAdjacentKinks][kAdjacentKinks])
+{
+  for (int row = 0; row < kAdjacentKinks; ++row) {
+    for (int column = 0; column <= row; ++column) {
+      Scalar value = covariance[row][column];
+      for (int k = 0; k < column; ++k) {
+        value -= covariance[row][k] * covariance[column][k];
+      }
+      if (row == column) {
+        if (!(value > 0.F)) {
+          return false;
+        }
+        covariance[row][row] = o2::gpu::GPUCommonMath::Sqrt(value);
+      } else {
+        covariance[row][column] = value / covariance[column][column];
+      }
+    }
+  }
+  return true;
+}
+
+/// Whiten a vector with L^-1. The curvature fit needs only contractions with
+/// C^-1 = L^-T L^-1, so backward substitution is unnecessary.
+GPUhdi() GPUAlwaysInline() void choleskyWhiten(const Scalar (&lower)[kAdjacentKinks][kAdjacentKinks], const Scalar (&right)[kAdjacentKinks], Scalar (&whitened)[kAdjacentKinks])
+{
+  for (int row = 0; row < kAdjacentKinks; ++row) {
+    Scalar value = right[row];
+    for (int column = 0; column < row; ++column) {
+      value -= lower[row][column] * whitened[column];
+    }
+    whitened[row] = value / lower[row][row];
+  }
+}
+
+[[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar dot(const Scalar (&left)[kAdjacentKinks], const Scalar (&right)[kAdjacentKinks])
+{
+  Scalar result = 0.F;
+  for (int i = 0; i < kAdjacentKinks; ++i) {
+    result += left[i] * right[i];
+  }
+  return result;
+}
+
+} // namespace detail
+
+/// Adjacent triplets `a b c` and `b c d` fitted with one curvature:
+/// ITSMFTTracking's `fitAdjacentTripletFactors`. The four kinks -- theta and phi at `b` and at
+/// `c` -- are correlated through the shared measurements `b` and `c`; their
+/// covariance is the scattering at `b` and `c`, \a varianceSecond and \a
+/// varianceThird as space-angle variances, plus the four measurements' errors
+/// carried by each triplet's kink gradient, its slope taken at its own
+/// reference curvature as in makeTripletFitFactor. The chi2 has three
+/// degrees of freedom. \a first and \a second are the kink terms of `a b c`
+/// and `b c d`. \a covarianceSecondThird is the space-angle covariance of
+/// the kinks at `b` and `c` that one scattering between them gives both
+/// (`adjacentScattering`).
+[[nodiscard]] GPUhdi() bool fitAdjacentTriplets(const KinkTerms& first, const KinkTerms& second, const PairPoint& a, const PairPoint& b, const PairPoint& c, const PairPoint& d, Scalar varianceSecond, Scalar varianceThird, TripletFitResult& result, Scalar covarianceSecondThird = 0.F)
+{
+  const Scalar sineFirst = first.sineTheta;
+  const Scalar sineSecond = second.sineTheta;
+  const Scalar psi[detail::kAdjacentKinks]{first.psi.theta, first.psi.phi, second.psi.theta, second.psi.phi};
+  const Scalar rho[detail::kAdjacentKinks]{first.rho.theta, first.rho.phi, second.rho.theta, second.rho.phi};
+
+  Scalar covariance[detail::kAdjacentKinks][detail::kAdjacentKinks]{};
+  covariance[0][0] = varianceSecond;
+  covariance[1][1] = varianceSecond / (sineFirst * sineFirst);
+  covariance[2][2] = varianceThird;
+  covariance[3][3] = varianceThird / (sineSecond * sineSecond);
+  covariance[2][0] = covarianceSecondThird;
+  covariance[3][1] = covarianceSecondThird / (sineFirst * sineSecond);
+  for (int hit = 0; hit < 4; ++hit) {
+    const PairPoint* point = &d;
+    if (hit == 0) {
+      point = &a;
+    } else if (hit == 1) {
+      point = &b;
+    } else if (hit == 2) {
+      point = &c;
+    }
+    for (int axis = 0; axis < 3; ++axis) {
+      Scalar gradient[detail::kAdjacentKinks]{};
+      if (hit < 3) {
+        const int direction = (3 * hit) + axis;
+        gradient[0] = first.theta[direction];
+        gradient[1] = first.phi[direction];
+      }
+      if (hit > 0) {
+        const int direction = (3 * (hit - 1)) + axis;
+        gradient[2] = second.theta[direction];
+        gradient[3] = second.phi[direction];
+      }
+      const Scalar variance = detail::axisVariance(*point, axis);
+      for (int row = 0; row < detail::kAdjacentKinks; ++row) {
+        for (int column = 0; column <= row; ++column) {
+          covariance[row][column] += variance * gradient[row] * gradient[column];
+        }
+      }
+    }
+  }
+
+  if (!detail::choleskyDecompose(covariance)) {
+    return false;
+  }
+  Scalar whitenedPsi[detail::kAdjacentKinks]{};
+  Scalar whitenedRho[detail::kAdjacentKinks]{};
+  detail::choleskyWhiten(covariance, psi, whitenedPsi);
+  detail::choleskyWhiten(covariance, rho, whitenedRho);
+  return detail::curvatureFit(detail::dot(whitenedPsi, whitenedPsi), detail::dot(whitenedRho, whitenedPsi), detail::dot(whitenedRho, whitenedRho), result);
+}
+
+/// The kink variances at `b` and `c` of adjacent triplets `a b c` and `b c d`
+/// and their covariance: each middle layer's scattering, at the polar angle
+/// of its own triplet, and the passive scatterers between the points. One
+/// between `b` and `c`, a fraction `t` of the way, turns the kink at `b` by
+/// `theta_p (1 - t)` and the one at `c` by `theta_p t`: both, together.
+struct AdjacentScattering {
+  Scalar second = 0.F;
+  Scalar third = 0.F;
+  Scalar covariance = 0.F;
+};
+
+/// \a secondScale and \a thirdScale multiply the layers' own scattering at `b`
+/// and `c`: the kink allowance of a kinked triplet (1 otherwise).
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() AdjacentScattering adjacentScattering(const ScatteringTable<Det>& table, const PairCut& cut, LayerID secondLayer, LayerID thirdLayer, const PairPoint& a, const PairPoint& b, const PairPoint& c, const PairPoint& d, Scalar sineFirst, Scalar sineSecond, Scalar secondScale = 1.F, Scalar thirdScale = 1.F)
+{
+  AdjacentScattering result{
+    .second = middleScattering(table, cut, secondLayer, sineFirst) * secondScale,
+    .third = middleScattering(table, cut, thirdLayer, sineSecond) * thirdScale,
+  };
+  visitPassivesBetween(table, cut, a, b, sineFirst, [&](Scalar passive, Scalar t) { result.second += passive * t * t; }, table.into(secondLayer));
+  visitPassivesBetween(
+    table, cut, b, c, sineFirst,
+    [&](Scalar passive, Scalar t) {
+      const Scalar atSecond = passive * (1.F - t) * (1.F - t);
+      result.second += atSecond;
+      // The same kink seen at the second triplet's polar angle.
+      const Scalar scale = sineFirst > 0.F ? sineSecond / sineFirst : 1.F;
+      result.third += passive * scale * t * t;
+      result.covariance += passive * o2::gpu::GPUCommonMath::Sqrt(scale) * t * (1.F - t);
+    },
+    table.outOf(secondLayer) & table.into(thirdLayer));
+  visitPassivesBetween(table, cut, c, d, sineSecond, [&](Scalar passive, Scalar t) { result.third += passive * (1.F - t) * (1.F - t); }, table.outOf(thirdLayer));
+  return result;
+}
+
+/// The same, with the scattering at `b` and `c` at pT_min from the pair
+/// cut's table, each at the polar angle of its own triplet.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool fitAdjacentTriplets(const KinkTerms& first, const KinkTerms& second, const PairPoint& a, const PairPoint& b, const PairPoint& c, const PairPoint& d, LayerID secondLayer, LayerID thirdLayer, const ScatteringTable<Det>& table, const PairCut& cut, TripletFitResult& result, Scalar secondScale = 1.F, Scalar thirdScale = 1.F)
+{
+  const auto scattering = adjacentScattering(table, cut, secondLayer, thirdLayer, a, b, c, d, first.sineTheta, second.sineTheta, secondScale, thirdScale);
+  return fitAdjacentTriplets(first, second, a, b, c, d, scattering.second, scattering.third, result, scattering.covariance);
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRIPLETFIT_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletPaths.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletPaths.h
new file mode 100644
index 0000000000000..fe49b490d09b3
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletPaths.h
@@ -0,0 +1,141 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TripletPaths.h
+/// \brief The longest triplet paths through and from each tracklet, which bound
+///        the chains a neighbour can be on.
+
+#ifndef GTRK_TRACKING_TRIPLETPATHS_H_
+#define GTRK_TRACKING_TRIPLETPATHS_H_
+
+#include "GenericTracking/Tracking/TrackletPaths.h"
+#include "GenericTracking/Tracking/Triplet.h"
+#include "GenericTracking/Tracking/TripletPermutation.h"
+
+#include "GPUCommonAlgorithm.h"
+
+#include <array>
+#include <atomic>
+#include <span>
+
+namespace o2::gtrk
+{
+/// A necessary condition on the triplets, as `TrackletPaths` is on the
+/// tracklets: the DAG whose vertices are tracklets
+/// and whose edges are accepted triplets, before the expensive neighbour fit.
+/// Prefix counts measurements up to a tracklet's target; suffix counts from
+/// that target to an allowed road end, including that target. Built from the
+/// triplets the triplet stage staged, before they are placed: the stage keeps
+/// only those on a path (`onPath`).
+template <DetectorLayout Det>
+class TripletPaths
+{
+ public:
+  using Index = StageOutput<TrackletT>::Index;
+  static constexpr std::size_t kLayers = LayerRowMap<Det>::kLayerCount;
+  static_assert(maxChainLayers<Det> <= 255U);
+
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
+  {
+    mPool = std::move(pool);
+    clearStorage();
+  }
+
+  void clearStorage() noexcept { deepVectorClear(mPool.get(), mPrefix, mSuffix); }
+
+  /// \a forEachTriplet(begin, end, body) calls body(element, first, second)
+  /// for every triplet of the permuted elements in [begin, end), each
+  /// element's on one thread. The prefix by the link DAG's depth groups of
+  /// the first tracklets' source layers, each triplet raising its second
+  /// tracklet's (an atomic maximum): every triplet ending on a tracklet starts
+  /// at a smaller depth, as every link raises the depth, so the prefix of an
+  /// element's tracklet is final when its group runs; the suffix in reverse,
+  /// one writer per element.
+  template <typename ForEachTriplet, typename ForEach>
+  void build(const IterationParameters<Det>& parameters, const LayerRowMap<Det>& sources, const StageOutput<TrackletT>& tracklets, const TripletPermutation<Det>& permutation, const ForEachTriplet& forEachTriplet, const ForEach& forEach)
+  {
+    mMinClusters = parameters.minClusters;
+    // Kept from slice to slice and filled in parallel, not reallocated:
+    // the prefix's floor of two measurements
+    // and the suffix's of one, which with road-end layers is whether the
+    // tracklet's own target may end a road.
+    resizeBoundedVector(mPrefix, tracklets.size());
+    resizeBoundedVector(mSuffix, tracklets.size());
+    if (parameters.roadEndLayers != 0U) {
+      const auto view = tracklets.view();
+      std::array<std::uint8_t, nLinks<Det>> allowed{};
+      for (std::size_t link = 0U; link < nLinks<Det>; ++link) {
+        allowed[link] = ((parameters.roadEndLayers >> parameters.linkTargets[link]) & 1U) != 0U ? 1U : 0U;
+      }
+      forEach(tracklets.size(), [&](Index edge) {
+        mPrefix[edge] = std::uint8_t{2U};
+        mSuffix[edge] = allowed[view.link[edge]];
+      });
+    } else {
+      forEach(tracklets.size(), [&](Index edge) {
+        mPrefix[edge] = std::uint8_t{2U};
+        mSuffix[edge] = std::uint8_t{1U};
+      });
+    }
+    const auto indices = permutation.indices();
+    for (std::size_t layer = 0U; layer <= kLayers; ++layer) {
+      const auto first = tracklets.offsets()[sources.offsets[layer]];
+      mElements[layer] = o2::gpu::CAAlgo::partitionPoint(Index{0U}, permutation.size(), [&](Index element) { return indices[element] < first; });
+    }
+    constexpr auto groups = layerDepthGroups<Det>;
+    const auto forEachOfGroup = [&](std::size_t group, const auto& body) {
+      for (auto at = groups.groups[group]; at < groups.groups[group + 1U]; ++at) {
+        const auto layer = static_cast<std::size_t>(groups.order[at]);
+        forEachTriplet(mElements[layer], mElements[layer + 1U], body);
+      }
+    };
+    for (std::size_t group = 0U; group < groups.count; ++group) {
+      forEachOfGroup(group, [&](Index /*element*/, Index first, Index second) {
+        // A host loop: O2's AtomicMax is device code in a GPU unit.
+        const auto length = static_cast<std::uint8_t>(mPrefix[first] + 1U);
+        const std::atomic_ref<std::uint8_t> prefix{mPrefix[second]};
+        auto current = prefix.load(std::memory_order_relaxed);
+        while (current < length && !prefix.compare_exchange_weak(current, length, std::memory_order_relaxed)) {
+        }
+      });
+    }
+    for (auto group = groups.count; group-- > 0U;) {
+      forEachOfGroup(group, [&](Index /*element*/, Index first, Index second) {
+        const auto after = mSuffix[second];
+        if (after != 0U && mSuffix[first] < after + 1U) {
+          mSuffix[first] = static_cast<std::uint8_t>(after + 1U);
+        }
+      });
+    }
+  }
+
+  /// Whether triplet (\a first, \a second) is on a triplet path of the
+  /// iteration's minClusters: the neighbour stage's test of its element
+  /// (NeighbourStage.h), which refuses every other triplet as element and as
+  /// predecessor.
+  [[nodiscard]] bool onPath(Index first, Index second) const { return bounds().onPath(first, second); }
+
+  [[nodiscard]] TrackletPathBounds bounds() const { return {.prefix = mPrefix.data(), .suffix = mSuffix.data(), .minClusters = mMinClusters}; }
+
+  /// Per layer, the first permuted element whose tracklet starts on it or
+  /// after, and the total at the end: the layers' ranges of the permutation,
+  /// as the last `build` found them.
+  [[nodiscard]] std::span<const Index, kLayers + 1U> layerElements() const { return mElements; }
+
+ private:
+  std::shared_ptr<BoundedMemoryResource> mPool;
+  BoundedVector<std::uint8_t> mPrefix;
+  BoundedVector<std::uint8_t> mSuffix;
+  std::array<Index, kLayers + 1U> mElements{};
+  std::uint32_t mMinClusters = 0U;
+};
+} // namespace o2::gtrk
+#endif // GTRK_TRACKING_TRIPLETPATHS_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletPermutation.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletPermutation.h
new file mode 100644
index 0000000000000..b2866ed544ba0
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletPermutation.h
@@ -0,0 +1,110 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TripletPermutation.h
+/// \brief The first tracklets of the triplet stage.
+
+#ifndef GTRK_TRACKING_TRIPLETPERMUTATION_H_
+#define GTRK_TRACKING_TRIPLETPERMUTATION_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Base/HostAlgorithms.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/LayerRowMap.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/TrackletPaths.h"
+
+#include <memory>
+#include <span>
+
+namespace o2::gtrk
+{
+
+/// Whether tracklet \a first is one of the triplet stage's first tracklets:
+/// its target a source of the slice with tracklets of its own (\a offsets,
+/// the tracklets' per source), on a tracklet path of the iteration's
+/// minClusters (\a paths). The one predicate of
+/// TripletPermutation::build and of the device's permutation (SliceGlue.cuh).
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool firstTrackletEligible(const IterationParameters<Det>& parameters, const LayerRowMap<Det>& sources, TrackletConstView tracklets, const std::uint32_t* offsets, TrackletPathBounds paths, std::uint32_t first)
+{
+  const auto link = tracklets.link[first];
+  const auto layer = parameters.linkTargets[link];
+  if (!sources.contains(layer, tracklets.target[first])) {
+    return false;
+  }
+  const auto middle = sources.element(layer, tracklets.target[first]);
+  const auto source = sources.element(parameters.linkSources[link], tracklets.source[first]);
+  return offsets[middle] != offsets[middle + 1U] && paths.onPath(source, middle);
+}
+
+/// The first tracklets consumed by TripletStage, in arena order: the
+/// tracklets whose target is a source of the slice with tracklets of its own,
+/// on a tracklet path of the iteration's minClusters (\a paths). Every tracklet's own source already passed the
+/// tracklet stage's gate, so this is a compaction, and the order is a pure
+/// function of the inputs.
+template <DetectorLayout Det>
+class TripletPermutation
+{
+ public:
+  using Index = typename StageOutput<TrackletT>::Index;
+  using Sources = LayerRowMap<Det>;
+  using Tracklets = StageOutput<TrackletT>;
+  static_assert(sizeof(Index) == 4U);
+
+  TripletPermutation() = default;
+  ~TripletPermutation() = default;
+  TripletPermutation(const TripletPermutation&) = delete;
+  TripletPermutation& operator=(const TripletPermutation&) = delete;
+  TripletPermutation(TripletPermutation&&) = delete;
+  TripletPermutation& operator=(TripletPermutation&&) = delete;
+
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
+  {
+    mMemoryPool.swap(pool);
+    clearStorage();
+  }
+
+  /// \a forEach(count, body) runs body(i) for i in [0, count), serially or
+  /// in parallel, over chunks of \a chunkSize tracklets (HostAlgorithms.h):
+  /// the same order either way.
+  template <typename ForEach>
+  [[nodiscard]] StageStatus build(const IterationParameters<Det>& parameters, const Sources& sources, const Tracklets& tracklets, TrackletPathBounds paths, const ForEach& forEach, Index chunkSize)
+  {
+    return guardOutOfMemory([&] {
+      const auto view = tracklets.view();
+      const auto offsets = tracklets.offsets();
+      // The compaction reads its predicate twice (count, place): one byte per
+      // tracklet, evaluated once, instead of the gathers twice.
+      resizeBoundedVector(mEligible, tracklets.size());
+      forEach(tracklets.size(), [&](Index first) { mEligible[first] = firstTrackletEligible(parameters, sources, view, offsets.data(), paths, first) ? 1U : 0U; });
+      host_algorithms::compactIndices(forEach, tracklets.size(), chunkSize, [&](Index first) { return mEligible[first] != 0U; }, mIndices);
+      return StageStatus::kComplete;
+    });
+  }
+
+  void clearStorage() noexcept { deepVectorClear(mMemoryPool.get(), mIndices, mEligible); }
+
+  [[nodiscard]] std::span<const Index> indices() const { return mIndices; }
+  [[nodiscard]] const Index* data() const { return mIndices.data(); }
+  [[nodiscard]] Index size() const { return static_cast<Index>(mIndices.size()); }
+
+ private:
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  BoundedVector<Index> mIndices;
+  BoundedVector<std::uint8_t> mEligible;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRIPLETPERMUTATION_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletStage.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletStage.h
new file mode 100644
index 0000000000000..5fda12cb69f3f
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/TripletStage.h
@@ -0,0 +1,254 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TripletStage.h
+/// \brief The triplet stage's per-first-tracklet function.
+
+#ifndef GTRK_TRACKING_TRIPLETSTAGE_H_
+#define GTRK_TRACKING_TRIPLETSTAGE_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/LayerRowMap.h"
+#include "GenericTracking/Tracking/ShapeCut.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/TrackletPaths.h"
+#include "GenericTracking/Tracking/Triplet.h"
+#include "GenericTracking/Tracking/TripletCut.h"
+#include "GenericTracking/Tracking/WorkCounters.h"
+
+#include "GPUCommonAlgorithm.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <stdexcept>
+
+namespace o2::gtrk
+{
+
+/// Generate every accepted continuation of one first tracklet.
+///
+/// The device path reads the iteration's plain link-topology inputs, not host
+/// constexpr storage. Within each continuing link, the middle measurement's
+/// tracklets are searched by their sorted (link, lambda, target) key. Elements
+/// index a permutation of the first-tracklet arena in arena order
+/// (TripletPermutation.h).
+///
+/// The work in the pieces a flat run keeps apart:
+/// `prepareFirst` once per first tracklet, `forEachCandidate` its dip-angle
+/// windows' candidates in the serial order, `testCandidate` one candidate's
+/// cuts and fit, `record` its triplet. `operator()` runs them in sequence.
+///
+/// With \a Shape, the iteration's `shapeTest`: the line from the first
+/// measurement to the third must cross all three at a local slope in their
+/// slope intervals (ShapeCut.h), before the fit; the tracklet stage held each pair to its own line.
+template <DetectorLayout Det, bool Shape = false>
+class TripletStage
+{
+ public:
+  using Index = typename StageOutput<TripletT>::Index;
+  using Sources = LayerRowMap<Det>;
+  using Tracklets = StageOutput<TrackletT>;
+
+  TripletStage(const IterationParameters<Det>& parameters, const Sources& sources, const TimeFrame<Det>& frame, const Tracklets& tracklets, const TripletTargetBounds* targetBounds, const Index* permutation, TrackletPathBounds paths)
+    : TripletStage(&parameters, &sources, &frame, tracklets.view(), tracklets.offsets().data(), targetBounds, permutation, paths)
+  {
+    if (Shape != parameters.shapeTest) {
+      throw std::invalid_argument("the shape-testing triplet stage serves exactly the iterations with shapeTest");
+    }
+  }
+
+  /// The same stage over inputs wherever they are -- a device's copies:
+  /// every argument is only stored.
+  TripletStage(const IterationParameters<Det>* parameters, const Sources* sources, const TimeFrame<Det>* frame, TrackletConstView tracklets, const Index* trackletOffsets, const TripletTargetBounds* targetBounds, const Index* permutation, TrackletPathBounds paths)
+    : mParameters(parameters),
+      mSources(sources),
+      mFrame(frame),
+      mTracklets(tracklets),
+      mOffsets(trackletOffsets),
+      mTargetBounds(targetBounds),
+      mPermutation(permutation),
+      mPaths(paths)
+  {
+  }
+
+  /// What a first tracklet's tests read: the first and middle points, the
+  /// middle's layer and the path prefix; and what its windows need: the
+  /// middle's tracklet range and the first's lambda.
+  struct FirstContext {
+    TimedPoint first{};
+    TimedPoint middle{};
+    Index firstIndex = 0U;
+    Index begin = 0U; ///< the middle's tracklets [begin, end)
+    Index end = 0U;
+    Scalar lambda = 0.F;
+    std::uint32_t prefix = 0U;
+    LayerID middleLayer = kInvalidLayerID;
+  };
+
+  template <typename Emitter>
+  GPUhdi() void operator()(Index element, Emitter& emitter) const
+  {
+    FirstContext context;
+    if (!prepareFirst(element, context)) {
+      return;
+    }
+    const auto one = [&](Index candidateIndex) {
+      TripletFitResult fit;
+      bool kinked = false;
+      if (testCandidate(context, candidateIndex, fit, kinked)) {
+        emitter.emit(record(context, candidateIndex, fit, kinked));
+      }
+    };
+    forEachWindowCandidate(context, one);
+  }
+
+  /// \a element's context: false when it has no continuation -- its middle
+  /// outside the slice, or without a tracklet.
+  [[nodiscard]] GPUhdi() bool prepareFirst(Index element, FirstContext& context) const
+  {
+    context.firstIndex = mPermutation[element];
+    const std::size_t firstLink = mTracklets.link[context.firstIndex];
+    context.middleLayer = mParameters->linkTargets[firstLink];
+    const Index middleRow = mTracklets.target[context.firstIndex];
+    countWork(WorkCounter::kTripletFirsts);
+    if (!mSources->contains(context.middleLayer, middleRow)) {
+      countWork(WorkCounter::kTripletNoMiddle);
+      return false;
+    }
+    const Index middleElement = mSources->element(context.middleLayer, middleRow);
+    context.begin = mOffsets[middleElement];
+    context.end = mOffsets[middleElement + 1U];
+    if (context.begin == context.end) {
+      return false;
+    }
+    // The first tracklet is on a path of minClusters (TripletPermutation);
+    // each third must be too.
+    const Index sourceRow = mTracklets.source[context.firstIndex];
+    context.prefix = mPaths.prefix[mSources->element(mParameters->linkSources[firstLink], sourceRow)];
+    const auto columns = mFrame->measurements();
+    context.first = timedPointAt(columns, sourceRow);
+    context.middle = timedPointAt(columns, middleRow);
+    context.lambda = mTracklets.lambda[context.firstIndex];
+    return true;
+  }
+
+  /// \a body(candidateIndex) for every tracklet of the middle in the first
+  /// tracklet's dip-angle window on each of the middle's out-links, in the
+  /// serial order: the links in `outLinkIndices` order, each window's
+  /// indices ascending from the lower bound of `lambda - halfWidth` while
+  /// `lambda <= high` (a scan: cheaper than a search for the end on the host,
+  /// the same on a device).
+  template <typename Body>
+  GPUhdi() void forEachWindowCandidate(const FirstContext& context, Body& body) const
+  {
+    // The dip-angle window's first-tracklet part, once for every out-link.
+    const auto firstTerms = tripletFirstTerms(*mParameters, context.middleLayer, context.first.point, context.middle.point);
+    for (auto out = mParameters->outLinkOffsets[context.middleLayer]; out < mParameters->outLinkOffsets[static_cast<std::size_t>(context.middleLayer) + 1U]; ++out) {
+      const std::size_t secondLink = mParameters->outLinkIndices[out];
+      const Index linkBegin = lowerBoundLink(context.begin, context.end, secondLink);
+      const Index linkEnd = upperBoundLink(linkBegin, context.end, secondLink);
+      if (linkBegin == linkEnd) {
+        continue;
+      }
+      const LayerID targetLayer = mParameters->linkTargets[secondLink];
+      const Scalar halfWidth = tripletLambdaHalfWidth(*mParameters, secondLink, firstTerms, mTargetBounds[targetLayer]);
+      const Scalar high = context.lambda + halfWidth;
+      for (Index candidateIndex = lowerBoundLambda(linkBegin, linkEnd, context.lambda - halfWidth); candidateIndex < linkEnd && mTracklets.lambda[candidateIndex] <= high; ++candidateIndex) {
+        body(candidateIndex);
+      }
+    }
+  }
+
+  /// The candidates of \a element's windows, counted without the tests: what
+  /// a flat candidate list holds for the first tracklet.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint32_t candidateCount(Index element) const
+  {
+    FirstContext context;
+    if (!prepareFirst(element, context)) {
+      return 0U;
+    }
+    std::uint32_t count = 0U;
+    const auto one = [&](Index) { ++count; };
+    forEachWindowCandidate(context, one);
+    return count;
+  }
+
+  /// One candidate's cuts: the path, the time, the curvature and the fit
+  /// (`tripletCompatible`, with the kinked retry); \a fit and \a kinked where
+  /// it passes.
+  [[nodiscard]] GPUhdi() bool testCandidate(const FirstContext& context, Index candidateIndex, TripletFitResult& fit, bool& kinked) const
+  {
+    countWork(WorkCounter::kTripletWindow);
+    const LayerID targetLayer = mParameters->linkTargets[mTracklets.link[candidateIndex]];
+    const auto suffix = measurementSuffix(mPaths, *mSources, mParameters->roadEndLayers, targetLayer, mTracklets.target[candidateIndex]);
+    if (suffix == 0U || context.prefix + 1U + suffix < mPaths.minClusters) {
+      return false;
+    }
+    const auto third = timedPointAt(mFrame->measurements(), mTracklets.target[candidateIndex]);
+    if constexpr (Shape) {
+      const auto columns = mFrame->measurements();
+      const auto& from = context.first.point;
+      const auto& to = third.point;
+      if (!shapeAdmits(columns, mTracklets.source[context.firstIndex], from.x, from.y, from.z, to.x, to.y, to.z) || !shapeAdmits(columns, mTracklets.target[context.firstIndex], from.x, from.y, from.z, to.x, to.y, to.z) || !shapeAdmits(columns, mTracklets.target[candidateIndex], from.x, from.y, from.z, to.x, to.y, to.z)) {
+        countWork(WorkCounter::kTripletShape);
+        return false;
+      }
+    }
+    KinkTerms terms;
+    kinked = false;
+    return tripletCompatible(*mParameters, context.middleLayer, context.first, context.middle, third, fit, terms, kinked);
+  }
+
+  /// The triplet of an accepted candidate.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Triplet record(const FirstContext& context, Index candidateIndex, const TripletFitResult& fit, bool kinked) const
+  {
+    return Triplet{
+      .first = context.firstIndex,
+      .second = candidateIndex,
+      .curvature = fit.curvature,
+      .varCurvature = fit.varCurvature,
+      .level = 1U,
+      .kinked = kinked ? std::uint8_t{1} : std::uint8_t{0},
+    };
+  }
+
+ private:
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Index lowerBoundLink(Index searchBegin, Index searchEnd, std::size_t value) const
+  {
+    return o2::gpu::CAAlgo::partitionPoint(searchBegin, searchEnd - searchBegin, [&](Index tracklet) { return mTracklets.link[tracklet] < value; });
+  }
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Index upperBoundLink(Index searchBegin, Index searchEnd, std::size_t value) const
+  {
+    return o2::gpu::CAAlgo::partitionPoint(searchBegin, searchEnd - searchBegin, [&](Index tracklet) { return mTracklets.link[tracklet] <= value; });
+  }
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Index lowerBoundLambda(Index first, Index last, Scalar lambda) const
+  {
+    return o2::gpu::CAAlgo::partitionPoint(first, last - first, [&](Index tracklet) { return mTracklets.lambda[tracklet] < lambda; });
+  }
+
+  const IterationParameters<Det>* mParameters = nullptr;
+  const Sources* mSources = nullptr;
+  const TimeFrame<Det>* mFrame = nullptr;
+  TrackletConstView mTracklets;
+  const Index* mOffsets = nullptr;
+  const TripletTargetBounds* mTargetBounds = nullptr;
+  const Index* mPermutation = nullptr;
+  TrackletPathBounds mPaths;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_TRIPLETSTAGE_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/VertexStage.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/VertexStage.h
new file mode 100644
index 0000000000000..f25523686950e
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/VertexStage.h
@@ -0,0 +1,884 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file VertexStage.h
+/// \brief The vertexer: the vertexing pass's triplets to the timeframe's
+///        vertex list -- the candidate map and the peak, mean and error
+///        arithmetic shared with the device (VertexGlue.cuh), and the host's
+///        rounds (`Vertexer`).
+///
+/// The vertexing pass is an iteration at the beam line whose links stay
+/// within the innermost layers (`IterationSettings::layerMask`); it stops at
+/// its triplets. Each triplet becomes a candidate: the z at the beam
+/// line of the straight line through its points in r-z, if that line's chi2
+/// and the transverse distance of the circle through its points to the beam
+/// axis pass their cuts. The candidates are made cluster-disjoint:
+/// greedily by their r-z chi2, the lower
+/// triplet first on ties, a candidate is kept only if none of its clusters
+/// is already kept's -- one measurement counts once, so a particle's second
+/// triplet where sensors overlap, and the many triplets one fake tracklet
+/// makes, do not pile into a peak or shrink a vertex's error. The kept
+/// ones are sorted by (frame, z), a frame being the box start of the
+/// middle measurement. Each frame then finds its vertices in rounds: the
+/// free window [z_i, z_i + w) of the most candidates over its sidebands, beyond
+/// the claim's reach on both sides, wins if it holds `minContributors` (a
+/// frame where none does: `aloneMinContributors`, its rounds rerun) and
+/// stands out of the sidebands by `significance` of their Poisson spread;
+/// it claims every free candidate within the claim of its centre, and its z
+/// is their mean. A found vertex owns the measurements of every triplet of
+/// its frame within the claim of its centre -- those the cuts rejected too --
+/// and the frame's later rounds drop the free candidates with an owned
+/// measurement before they count anything: a dense
+/// collision's measurements, recombined into triplets of several of its
+/// particles that point elsewhere, make no second peak. Rounds repeat until
+/// no window qualifies.
+///
+/// Everything after the candidate map is integer arithmetic -- z in
+/// micrometres, counts -- or one IEEE operation on integers, so
+/// the list does not depend on the order in which the work is done: not on
+/// the threads here, nor on a device's schedule (VertexGlue.cuh). The map
+/// itself is GPUhdi and float: the r-z line
+/// fitted about its weighted mean radius, the circle's distance to the axis
+/// from the axis's power with respect to it, so that neither subtracts two
+/// numbers of the circle's size.
+
+#ifndef GTRK_TRACKING_VERTEXSTAGE_H_
+#define GTRK_TRACKING_VERTEXSTAGE_H_
+
+#include "GenericTracking/Base/Definitions.h"
+#include "GenericTracking/Base/TimeEstPS.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/PairCut.h"
+
+#ifndef GPUCA_GPUCODE_DEVICE
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Tracking/Parallel.h"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <memory_resource>
+#endif
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+/// The vertexer's knobs.
+struct VertexerSettings {
+  /// The r-z straight line's chi2 on the points' z errors (1 dof) above
+  /// which a triplet is no candidate; 0 for no cut.
+  Scalar maxChi2RZ = 5.F;
+  /// The transverse distance of the circle through a triplet's points to
+  /// the beam axis above which it is no candidate [cm]; 0 for no cut.
+  Scalar maxDcaCM = 0.02F;
+  std::int32_t windowUM = 150;       ///< w: a peak's window [um]
+  std::int32_t claimUM = 2000;       ///< the half-width around a peak's centre its vertex claims [um]
+  std::uint32_t minContributors = 4; ///< the least candidates a peak's window must hold
+  /// The least candidates a peak's window must hold in a frame whose rounds
+  /// at `minContributors` found no vertex: such a frame runs its rounds again
+  /// at this minimum, from its untouched candidates. A frame with a vertex is
+  /// never rerun, so a collision's debris makes no vertex at the lower
+  /// minimum. 0, or `minContributors` and above: no rerun.
+  std::uint32_t aloneMinContributors = 0;
+  Scalar significance = 5.F; ///< k: a peak's excess over the sidebands' mean b must reach k sqrt(b)
+  /// A vertex's z and its error from its claimed candidates within this many
+  /// of their own and the mean's errors of their weighted mean, grown from the
+  /// core within the window: its own tails
+  /// in, a neighbouring collision's candidates in the claim out. The run's
+  /// `windowNSigma`.
+  Scalar clipNSigma = 3.F;
+};
+
+/// z in micrometres is stored offset by this, so that the key sorts as an
+/// unsigned integer.
+inline constexpr std::int64_t kVertexZOffsetUM = std::int64_t{1} << 31U;
+
+/// What the map measures of one triplet: its sort key (accepted ones), its
+/// r-z line's chi2 -- the deduplication's order -- and z at the beam line
+/// [cm], that z's variance from the points' z errors alone, the weighted
+/// least squares' intercept [cm^2], and its circle's radius [cm], infinite
+/// (1e30) for a straight line: the error model's momentum.
+struct VertexCandidateFit {
+  std::uint64_t key = 0U;
+  Scalar chi2RZ = 0.F;
+  Scalar z0 = 0.F;
+  Scalar varZ0Line = 0.F;
+  Scalar radius = 1.e30F;
+};
+
+/// One triplet's constraint on the beam point: the circle through its points comes closest to the beam axis at a
+/// signed distance \a d along the unit direction (\a nx, \a ny), so a beam
+/// point p moves that distance to d - n . p, and the point where every
+/// triplet's distance vanishes obeys n . p = d. The linear term is exact for
+/// a straight line and good to (|p| / R)^2 for a circle of radius R.
+struct BeamTerm {
+  Scalar nx = 0.F;
+  Scalar ny = 0.F;
+  Scalar d = 0.F;
+  bool valid = false; ///< the geometry was computed: the triplet passed the r-z cut and is not degenerate
+};
+
+/// The candidate of the triplet \a a, \a b, \a c (the middle \a b's box
+/// starting at \a middlePS): its sort key, (middlePS << 32) | (z in um +
+/// offset), into \a key unless degenerate -- the candidates of one readout frame
+/// share the frame's start -- with what else it
+/// measures (`VertexCandidateFit`) into \a fit.
+/// \a term, if given, receives the triplet's BeamTerm whenever its circle
+/// is computed, before the transverse cut decides: a beam line off by more
+/// than the cut still needs every triplet's say.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() VertexCandidateStatus vertexCandidate(const PairPoint& a, const PairPoint& b, const PairPoint& c, std::uint32_t middlePS, const VertexerSettings& settings, VertexCandidateFit& fit, BeamTerm* term = nullptr)
+{
+  using o2::gpu::GPUCommonMath;
+  const PairPoint points[3] = {a, b, c};
+  // The straight line z = z0 + slope r, each point weighted by 1 / its z
+  // variance, fitted about the weighted means.
+  Scalar weights[3] = {};
+  Scalar sw = 0.F;
+  Scalar swr = 0.F;
+  Scalar swz = 0.F;
+  for (int i = 0; i < 3; ++i) {
+    weights[i] = 1.F / (points[i].varZ > 1.e-12F ? points[i].varZ : 1.e-12F);
+    sw += weights[i];
+    swr += weights[i] * points[i].r;
+    swz += weights[i] * points[i].z;
+  }
+  const Scalar rMean = swr / sw;
+  const Scalar zMean = swz / sw;
+  Scalar srr = 0.F;
+  Scalar srz = 0.F;
+  for (int i = 0; i < 3; ++i) {
+    const Scalar dr = points[i].r - rMean;
+    srr += weights[i] * dr * dr;
+    srz += weights[i] * dr * (points[i].z - zMean);
+  }
+  if (!(srr > 0.F)) {
+    return VertexCandidateStatus::kDegenerate;
+  }
+  fit.varZ0Line = (1.F / sw) + (rMean * rMean / srr);
+  const Scalar slope = srz / srr;
+  const Scalar z0 = zMean - (slope * rMean);
+  // The key, also for a candidate the cuts reject: its z owns measurements.
+  // Rounded by adding one half away from zero and
+  // truncating, the same on host and device (not `llround`: a value just
+  // under a half can round up).
+  const Scalar zUM = z0 * 1.e4F;
+  const auto zIndex = static_cast<std::int64_t>(zUM < 0.F ? zUM - 0.5F : zUM + 0.5F);
+  const std::int64_t zKey = zIndex + kVertexZOffsetUM;
+  if (zKey < 0 || zKey >= (std::int64_t{1} << 32U)) {
+    return VertexCandidateStatus::kDegenerate;
+  }
+  fit.key = (static_cast<std::uint64_t>(middlePS) << 32U) | static_cast<std::uint64_t>(zKey);
+  Scalar chi2 = 0.F;
+  for (int i = 0; i < 3; ++i) {
+    const Scalar residual = points[i].z - zMean - (slope * (points[i].r - rMean));
+    chi2 += weights[i] * residual * residual;
+  }
+  fit.chi2RZ = chi2;
+  fit.z0 = z0;
+  if (settings.maxChi2RZ > 0.F && chi2 > settings.maxChi2RZ) {
+    return VertexCandidateStatus::kChi2RZ;
+  }
+  {
+    // The circle through the three points in x-y, about the middle one: A and
+    // C the outer points from it, U the centre from it; a straight line when
+    // they are collinear.
+    const Scalar ax = a.x - b.x;
+    const Scalar ay = a.y - b.y;
+    const Scalar cx = c.x - b.x;
+    const Scalar cy = c.y - b.y;
+    const Scalar twiceArea = 2.F * ((ax * cy) - (ay * cx));
+    Scalar dca = 0.F;
+    Scalar nx = 0.F;
+    Scalar ny = 0.F;
+    if (twiceArea > 1.e-12F || twiceArea < -1.e-12F) {
+      const Scalar a2 = (ax * ax) + (ay * ay);
+      const Scalar c2 = (cx * cx) + (cy * cy);
+      const Scalar ux = ((cy * a2) - (ay * c2)) / twiceArea;
+      const Scalar uy = ((ax * c2) - (cx * a2)) / twiceArea;
+      const Scalar radius = GPUCommonMath::Sqrt((ux * ux) + (uy * uy));
+      fit.radius = radius;
+      // The centre from the axis, b + U; the axis's distance to the circle
+      // |b + U| - R as its power |b + U|^2 - R^2 = |b|^2 + 2 b . U over
+      // |b + U| + R.
+      const Scalar centreX = b.x + ux;
+      const Scalar centreY = b.y + uy;
+      const Scalar centre = GPUCommonMath::Sqrt((centreX * centreX) + (centreY * centreY));
+      const Scalar power = (b.x * b.x) + (b.y * b.y) + (2.F * ((b.x * ux) + (b.y * uy)));
+      dca = power / (centre + radius);
+      // The circle comes closest to the axis along the centre's direction.
+      nx = centre > 0.F ? centreX / centre : 0.F;
+      ny = centre > 0.F ? centreY / centre : 0.F;
+    } else {
+      const Scalar dx = c.x - a.x;
+      const Scalar dy = c.y - a.y;
+      const Scalar length = GPUCommonMath::Sqrt((dx * dx) + (dy * dy));
+      dca = ((a.x * c.y) - (a.y * c.x)) / length;
+      // A line's signed distance from a point p is d - (p x t): along (t_y, -t_x).
+      nx = length > 0.F ? dy / length : 0.F;
+      ny = length > 0.F ? -dx / length : 0.F;
+    }
+    if (term != nullptr) {
+      term->nx = nx;
+      term->ny = ny;
+      term->d = dca;
+      term->valid = ((nx * nx) + (ny * ny)) > 0.5F; // a unit direction, or none
+    }
+    if (settings.maxDcaCM > 0.F && (dca > settings.maxDcaCM || dca < -settings.maxDcaCM)) {
+      return VertexCandidateStatus::kDca;
+    }
+  }
+  return VertexCandidateStatus::kAccepted;
+}
+
+/// The excess of a peak starting at the free candidate at \a z [um] -- its
+/// window [z, z + \a window) and the two sidebands \a claim beyond it, their
+/// free candidates counted by \a countIn(low, high) -- or 0 where it is no
+/// peak: fewer than \a minContributors in the window, or the excess 2W - S
+/// over the sidebands' mean not positive or short of \a k2 (= 2 k^2) in
+/// (2W - S)^2 >= k2 S. The host's and the device's search
+/// (`Vertexer::find`, `vertex_glue::Score`).
+template <typename CountIn>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() std::int64_t peakExcess(std::int64_t z, std::int64_t window, std::int64_t claim, std::uint32_t minContributors, Scalar k2, const CountIn& countIn)
+{
+  const auto inWindow = countIn(z, z + window);
+  if (inWindow < minContributors) {
+    return 0;
+  }
+  const auto sidebands = countIn(z - claim - window, z - claim) + countIn(z + window + claim, z + (2 * window) + claim);
+  const auto excess = (2 * static_cast<std::int64_t>(inWindow)) - static_cast<std::int64_t>(sidebands);
+  if (excess <= 0) {
+    return 0;
+  }
+  const auto excessF = static_cast<Scalar>(excess);
+  return excessF * excessF < k2 * static_cast<Scalar>(sidebands) ? 0 : excess;
+}
+
+/// The vertexer's candidate errors with the scattering of the pass's
+/// material and the beam's transverse spread.
+template <DetectorLayout Det>
+struct ScatteringErrors {
+  const ScatteringTable<Det>* table = nullptr;
+  PairCut cut;
+  Scalar varTransverse = 0.F;
+  /// A candidate's z0 variance [cm^2]: its r-z line's (\a fit's
+  /// `varZ0Line`), the scattering before and at its first point \a a at its
+  /// own momentum -- the pair cut's `sourceScattering` from the fit's z0 at
+  /// the pass's pT floor, scaled by the curvature: the transverse momentum
+  /// goes as the circle's radius, so (R_min / R)^2 of the floor's, none for a
+  /// straight line; without a field the momentum is unknown and the floor's
+  /// is taken -- and the beam's transverse spread: the collision lies off the
+  /// axis the line is extrapolated to, which moves z0 by the slope times
+  /// that. The scattering's displacement across the track becomes one along
+  /// z at the beam line by g = sqrt(1 + slope^2).
+  ///
+  /// \a a is taken on layer 0: the vertexing pass's links join the three
+  /// innermost layers, so every triplet starts there. A pass on other layers
+  /// has to take its first layer here, or its own layer's scattering is left
+  /// out.
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() Scalar operator()(const PairPoint& a, const VertexCandidateFit& fit) const
+  {
+    const VertexSeed from{.z = fit.z0};
+    const Scalar atFloor = sourceScattering<Det>(*table, cut, from, LayerID{0}, a);
+    const Scalar halfRMin = 0.5F * cut.twoRMin;
+    const Scalar scale = halfRMin > 0.F && fit.radius > 0.F ? (halfRMin / fit.radius) * (halfRMin / fit.radius) : 1.F;
+    const Scalar slope = a.r > 0.F ? (a.z - fit.z0) / a.r : 0.F;
+    return fit.varZ0Line + (atFloor * scale * (1.F + (slope * slope))) + (slope * slope * varTransverse);
+  }
+};
+
+/// A candidate's weight in its vertex's mean: 2^32 / its z0 variance in um^2,
+/// truncated to an integer, so that the mean's sums are exact in any order.
+inline constexpr Scalar kVertexWeightScale = 4294967296.F;
+
+[[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint64_t candidateWeight(Scalar varZ0CM2)
+{
+  const Scalar varUM2 = varZ0CM2 * 1.e8F;
+  const Scalar weight = kVertexWeightScale / (varUM2 > 1.F ? varUM2 : 1.F);
+  return static_cast<std::uint64_t>(weight);
+}
+
+/// A candidate's frame and z from its key.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() std::int64_t vertexKeyFrame(std::uint64_t key) { return static_cast<std::int64_t>(key >> 32U); }
+[[nodiscard]] GPUhdi() GPUAlwaysInline() std::int64_t vertexKeyZUM(std::uint64_t key) { return static_cast<std::int64_t>(key & 0xFFFFFFFFULL) - kVertexZOffsetUM; }
+
+/// The ownership slot's key of measurement \a row of a triplet with
+/// candidate key \a key: its frame and the row, so that a measurement in
+/// triplets of two frames is owned in each apart.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint64_t ownedSlotKey(std::uint64_t key, std::uint32_t row) { return (key & ~0xFFFFFFFFULL) | row; }
+
+/// Whether a candidate at \a z [um] lies within \a halfWidth [um] of
+/// \a centre: a vertex's claim, or its core.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool withinZ(std::int64_t z, Scalar centre, Scalar halfWidth)
+{
+  const auto zf = static_cast<Scalar>(z);
+  const Scalar distance = zf > centre ? zf - centre : centre - zf;
+  return distance <= halfWidth;
+}
+
+/// The weighted mean [um] of a vertex's selected candidates and its variance
+/// [um^2], 1 / the sum of their weights, from their integer sums: one float
+/// form for the host's rounds and the device's.
+struct ZMoments {
+  Scalar mean = 0.F;
+  Scalar varMean = 0.F;
+};
+
+[[nodiscard]] GPUhdi() GPUAlwaysInline() ZMoments zMoments(std::uint64_t weightSum, std::int64_t weightedZSum)
+{
+  ZMoments moments;
+  if (weightSum != 0U) {
+    moments.mean = static_cast<Scalar>(weightedZSum) / static_cast<Scalar>(weightSum);
+    moments.varMean = kVertexWeightScale / static_cast<Scalar>(weightSum);
+  }
+  return moments;
+}
+
+/// Whether a candidate at \a z [um] with \a weight lies within \a nSigma of
+/// its own and the mean's errors of the mean.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool withinError(std::int64_t z, std::uint64_t weight, const ZMoments& moments, Scalar nSigma)
+{
+  const auto zf = static_cast<Scalar>(z);
+  const Scalar distance = zf > moments.mean ? zf - moments.mean : moments.mean - zf;
+  const Scalar var = (kVertexWeightScale / static_cast<Scalar>(weight > 0U ? weight : 1U)) + moments.varMean;
+  return distance <= nSigma * o2::gpu::GPUCommonMath::Sqrt(var);
+}
+
+/// A selected candidate's share of its vertex's scatter about the weighted
+/// \a mean [um]: w^2 (z - mean)^2 / 2^32, its weight times its chi2, as an
+/// integer, so that the sum is exact in any order.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() std::uint64_t candidateScatter(std::int64_t z, std::uint64_t weight, Scalar mean)
+{
+  const Scalar residual = static_cast<Scalar>(z) - mean;
+  const auto w = static_cast<Scalar>(weight);
+  return static_cast<std::uint64_t>(w * (w / kVertexWeightScale) * residual * residual);
+}
+
+/// What a candidate's claim holds besides its vertex: free, or dropped -- a
+/// measurement of it owned by a vertex of its frame.
+inline constexpr std::int32_t kClaimFree = -1;
+inline constexpr std::int32_t kClaimDropped = -2;
+
+/// What a vertex's z and error come from: its selected candidates' weights
+/// and weighted z [um] as integer sums, their scatter about the weighted mean
+/// (`candidateScatter`), their count; and its claimed candidates' boxes'
+/// extent.
+struct VertexClaim {
+  std::uint64_t weightSum = 0U;
+  std::int64_t weightedZSum = 0;
+  std::uint64_t scatterSum = 0U;
+  std::int64_t count = 0;
+  std::uint32_t earliestPS = 0U;
+  std::uint32_t latestPS = 0U;
+};
+
+/// The seed of a vertex from its \a claim: z the selected candidates'
+/// weighted mean, each weight the inverse of the candidate's own z0 variance,
+/// and its variance the sandwich one, sum w^2 (z - mean)^2 / (sum w)^2 times
+/// n / (n - 1): the error from the candidates' scatter, honest whatever the
+/// model's tails -- its box the claimed
+/// ones' extent, its transverse spread \a beamSpot's. The host's rounds and
+/// the device's read-back sums both end here.
+[[nodiscard]] inline VertexSeed vertexSeedOf(const VertexClaim& claim, const VertexConstraint& beamSpot)
+{
+  const auto moments = zMoments(claim.weightSum, claim.weightedZSum);
+  Scalar varMeanUM2 = moments.varMean;
+  if (claim.count > 1 && claim.weightSum != 0U) {
+    const auto weightSum = static_cast<Scalar>(claim.weightSum);
+    const auto n = static_cast<Scalar>(claim.count);
+    varMeanUM2 = (kVertexWeightScale / weightSum) * (static_cast<Scalar>(claim.scatterSum) / weightSum) * (n / (n - 1.F));
+  }
+  return {
+    .timePS = claim.earliestPS,
+    .widthPS = claim.latestPS - claim.earliestPS,
+    .z = moments.mean * 1.e-4F,
+    .varZ = varMeanUM2 * 1.e-8F,
+    .varTransverse = static_cast<Scalar>(beamSpot.sigmaTransverse * beamSpot.sigmaTransverse),
+  };
+}
+
+/// Triplet \a triplet's three rows, innermost first; the column sets are
+/// anything with the tracklets' `source`/`target` and the triplets'
+/// `first`/`second`, as `Vertexer::find` takes them.
+template <typename Tracklets, typename Triplets>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() std::array<std::uint32_t, 3> tripletRows(const Tracklets& tracklets, const Triplets& triplets, std::uint32_t triplet)
+{
+  const auto first = triplets.first[triplet];
+  return {tracklets.source[first], tracklets.target[first], tracklets.target[triplets.second[triplet]]};
+}
+
+/// One triplet as a vertex candidate: its fit (`vertexCandidate`) into
+/// \a fit, its weight from \a errors (`candidateWeight` of `errors(a, fit)`,
+/// \a a its first point) into \a weight and
+/// its rows' time box into \a box; \a term as `vertexCandidate` takes it.
+/// The host's map and a device's are this.
+template <typename Measurements, typename Tracklets, typename Triplets, typename Errors>
+GPUhdi() GPUAlwaysInline() VertexCandidateStatus measureCandidate(const Measurements& measurements, const Tracklets& tracklets, const Triplets& triplets, std::uint32_t triplet, const VertexerSettings& settings, const Errors& errors, VertexCandidateFit& fit, std::uint64_t& weight, TimeEstPS& box, BeamTerm* term)
+{
+  const auto rows = tripletRows(tracklets, triplets, triplet);
+  const auto pa = pairPointAt(measurements, rows[0]);
+  const auto pb = pairPointAt(measurements, rows[1]);
+  const auto pc = pairPointAt(measurements, rows[2]);
+  const auto status = vertexCandidate(pa, pb, pc, measurements.timePS[rows[1]], settings, fit, term);
+  weight = candidateWeight(errors(pa, fit));
+  box = timeBoxAt(measurements, rows[0]);
+  box += timeBoxAt(measurements, rows[1]);
+  box += timeBoxAt(measurements, rows[2]);
+  return status;
+}
+
+/// The frames a slice's vertexer finds vertices in: those whose start -- a
+/// candidate's middle measurement's box start, its key's frame -- lies in
+/// `[beginPS, endPS)`, the frames whose block is in the slice's core
+/// (`ownedFrames`). Every frame starts in one core, so the slices' lists
+/// add up to the timeframe's, each vertex once; the frame's triplets are all
+/// in the slice that owns it, its gate reaching past every link.
+struct OwnedFrames {
+  std::int64_t beginPS = 0;
+  std::int64_t endPS = std::int64_t{1} << 32U; ///< past every box start
+
+  [[nodiscard]] GPUhdi() GPUAlwaysInline() constexpr bool owns(std::int64_t framePS) const { return framePS >= beginPS && framePS < endPS; }
+};
+
+/// The frames whose start's block (`blockOfPS`) lies in \a core of
+/// \a geometry: from the first time in its first block to the first in the
+/// block after it, to the end with the timeframe's last block.
+template <typename Geometry, typename Blocks>
+[[nodiscard]] constexpr OwnedFrames ownedFrames(const Geometry& geometry, const Blocks& core)
+{
+  const auto firstPS = [&](std::int32_t block) -> std::int64_t {
+    if (block >= geometry.blockCount()) {
+      return OwnedFrames{}.endPS;
+    }
+    const std::int64_t start = geometry.blockStart(block);
+    return block <= 0 || start <= 0 ? 0 : (start + geometry.partsPerPS() - 1) / geometry.partsPerPS();
+  };
+  return {.beginPS = firstPS(core.begin), .endPS = firstPS(core.end)};
+}
+
+/// What the vertexer found in one timeframe, or in one slice's frames.
+struct VertexerResult {
+  std::vector<VertexSeed> vertices;        ///< sorted by time, then z
+  std::vector<std::uint32_t> contributors; ///< per vertex: the candidates it claimed
+  /// `tripletVertex`'s codes other than a vertex's index: a free candidate;
+  /// none (cut, degenerate or deduplicated); another slice's (its frame not
+  /// owned).
+  static constexpr std::int32_t kFree = -1;
+  static constexpr std::int32_t kNone = -2;
+  static constexpr std::int32_t kNotOwned = -3;
+  /// Per triplet: the vertex that claimed it, else kFree, kNone or
+  /// kNotOwned. Filled when asked for.
+  std::vector<std::int32_t> tripletVertex;
+  /// The triplets given and the accepted ones count every triplet of a
+  /// slice, its halo's too: over slices they add up the slices' work.
+  std::size_t triplets = 0U;
+  std::size_t accepted = 0U;   ///< the candidates past the cuts
+  std::size_t candidates = 0U; ///< those kept, cluster-disjoint, of the frames owned
+  std::uint32_t rounds = 0U;   ///< the most rounds any frame took, the last finding nothing included
+};
+
+/// A triplet's rows -- its first, middle and last measurement -- and the
+/// vertex that claimed it, else `VertexerResult::kFree` or `kNone`: the
+/// vertexing pass's claims over all its slices.
+struct TripletClaim {
+  std::array<std::uint32_t, 3> rows{};
+  std::int32_t vertex = VertexerResult::kNone;
+};
+
+/// A slice's vertices and counts after \a into's, as the pass gathers the
+/// timeframe's slice by slice (the slices in time order, so the list stays in
+/// it); the per-triplet claims are each slice's own and stay out.
+inline void appendVertices(VertexerResult& into, const VertexerResult& slice)
+{
+  into.vertices.insert(into.vertices.end(), slice.vertices.begin(), slice.vertices.end());
+  into.contributors.insert(into.contributors.end(), slice.contributors.begin(), slice.contributors.end());
+  into.triplets += slice.triplets;
+  into.accepted += slice.accepted;
+  into.candidates += slice.candidates;
+  into.rounds = into.rounds > slice.rounds ? into.rounds : slice.rounds;
+}
+
+#ifndef GPUCA_GPUCODE_DEVICE
+
+/// The vertexer on the host. Its whole work is the candidate map, one sort
+/// and the rounds of each frame, the frames in parallel in \a arena if given.
+class Vertexer
+{
+ public:
+  explicit Vertexer(const VertexerSettings& settings, const VertexConstraint& beamSpot) : mSettings(settings), mBeamSpot(beamSpot) {}
+
+  [[nodiscard]] const VertexerSettings& settings() const { return mSettings; }
+
+  /// The vertices of one timeframe from the vertexing pass's triplets:
+  /// \a measurements the frame's columns, \a tracklets and \a triplets the
+  /// pass's stage outputs (a slice's, or one over the timeframe), each with its
+  /// element count. A frame is the middle measurements' box start; a vertex's
+  /// box spans its claimed triplets'.
+  /// \a errors gives a candidate's z0 variance from its first point and its
+  /// fit (`ScatteringErrors`), its weight in its vertex's mean. The work arrays,
+  /// as long as the triplets, live on \a pool (the pass's; the default
+  /// resource without one), so that its limit and its peak see them;
+  /// the result is the
+  /// caller's. The vertices are \a owned's frames' only: a slice's, whose
+  /// deduplication still sees every candidate it has, so that a frame's
+  /// comes out as in one slice over the timeframe.
+  template <typename Measurements, typename Tracklets, typename Triplets, typename Errors>
+  [[nodiscard]] VertexerResult find(const Measurements& measurements, const Tracklets& tracklets, const Triplets& triplets, std::size_t tripletCount, detail::TaskArena* arena, bool keepTripletVertex, const Errors& errors, std::pmr::memory_resource* pool = nullptr, const OwnedFrames& owned = {}) const
+  {
+    std::pmr::memory_resource* const resource = pool != nullptr ? pool : std::pmr::get_default_resource();
+    VertexerResult result;
+    result.triplets = tripletCount;
+    // Candidates: in triplet order; the key 0 marks a degenerate
+    // triplet (no frame 0 candidate has z at -2^31 um), a cut one has its
+    // key too. A triplet's box is its three boxes' intersection, not empty by
+    // the triplet cut.
+    BoundedVector<std::uint64_t> keys(tripletCount, 0U, resource);
+    BoundedVector<Scalar> chi2(tripletCount, 0.F, resource);
+    BoundedVector<std::uint64_t> weights(tripletCount, 0U, resource);
+    BoundedVector<TimeEstPS> boxes(tripletCount, resource);
+    BoundedVector<VertexCandidateStatus> status(tripletCount, VertexCandidateStatus::kDegenerate, resource);
+    // body(begin, end) over [0, n) in \a arena, in pieces of \a grain, or at once.
+    const auto parallel = [&](std::size_t n, std::size_t grain, const auto& body) {
+      if (arena != nullptr) {
+        detail::parallelFor(*arena, 0U, n, grain, body);
+      } else {
+        body(0U, n);
+      }
+    };
+    const auto map = [&](std::size_t begin, std::size_t end) {
+      for (auto t = begin; t < end; ++t) {
+        VertexCandidateFit fit;
+        status[t] = measureCandidate(measurements, tracklets, triplets, static_cast<std::uint32_t>(t), mSettings, errors, fit, weights[t], boxes[t], nullptr);
+        keys[t] = fit.key;
+        chi2[t] = fit.chi2RZ;
+      }
+    };
+    parallel(tripletCount, 4096U, map);
+    BoundedVector<std::uint32_t> accepted(resource);
+    accepted.reserve(tripletCount);
+    for (std::size_t t = 0; t < tripletCount; ++t) {
+      if (status[t] == VertexCandidateStatus::kAccepted) {
+        accepted.push_back(static_cast<std::uint32_t>(t));
+      }
+    }
+    result.accepted = accepted.size();
+    // The deduplication: in increasing chi2, the lower triplet first on
+    // ties, each accepted candidate kept if none of its clusters is a kept
+    // one's; kept ones in triplet order.
+    BoundedVector<std::uint32_t> byChi2(accepted, resource);
+    std::ranges::stable_sort(byChi2, {}, [&](std::uint32_t t) { return chi2[t]; });
+    std::uint32_t rowEnd = 0U;
+    for (const auto t : accepted) {
+      rowEnd = std::max(rowEnd, std::ranges::max(tripletRows(tracklets, triplets, t)) + 1U);
+    }
+    BoundedVector<std::uint8_t> kept(tripletCount, 0U, resource);
+    BoundedVector<std::uint8_t> taken(rowEnd, 0U, resource);
+    for (const auto t : byChi2) {
+      const auto rows = tripletRows(tracklets, triplets, t);
+      if (std::ranges::none_of(rows, [&](std::uint32_t row) { return taken[row] != 0U; })) {
+        kept[t] = 1U;
+        for (const auto row : rows) {
+          taken[row] = 1U;
+        }
+      }
+    }
+    // The ownership's sources: every triplet of the owned
+    // frames but the degenerate, by key, and each measurement of a frame's
+    // triplets one slot, (frame << 32) | row, so that frames own apart.
+    BoundedVector<Source> sources(resource);
+    for (std::size_t t = 0; t < tripletCount; ++t) {
+      if (status[t] != VertexCandidateStatus::kDegenerate && owned.owns(vertexKeyFrame(keys[t]))) {
+        sources.push_back({.key = keys[t], .triplet = static_cast<std::uint32_t>(t)});
+      }
+    }
+    std::ranges::stable_sort(sources, {}, &Source::key);
+    BoundedVector<std::uint64_t> slotKeys(resource);
+    slotKeys.reserve(3U * sources.size());
+    for (const auto& source : sources) {
+      for (const auto row : tripletRows(tracklets, triplets, source.triplet)) {
+        slotKeys.push_back(ownedSlotKey(source.key, row));
+      }
+    }
+    std::ranges::sort(slotKeys);
+    const auto repeated = std::ranges::unique(slotKeys);
+    slotKeys.erase(repeated.begin(), repeated.end());
+    const auto slotsOf = [&](std::uint64_t key, std::uint32_t triplet) {
+      std::array<std::uint32_t, 3> slots{};
+      const auto rows = tripletRows(tracklets, triplets, triplet);
+      for (std::size_t k = 0; k < 3U; ++k) {
+        slots[k] = static_cast<std::uint32_t>(std::ranges::lower_bound(slotKeys, ownedSlotKey(key, rows[k])) - slotKeys.begin());
+      }
+      return slots;
+    };
+    parallel(sources.size(), 4096U, [&](std::size_t begin, std::size_t end) {
+      for (auto i = begin; i < end; ++i) {
+        sources[i].slots = slotsOf(sources[i].key, sources[i].triplet);
+      }
+    });
+    BoundedVector<std::uint8_t> ownedSlots(slotKeys.size(), 0U, resource);
+    BoundedVector<Candidate> candidates(resource);
+    candidates.reserve(accepted.size());
+    for (const auto t : accepted) {
+      if (kept[t] != 0U && owned.owns(vertexKeyFrame(keys[t]))) {
+        candidates.push_back({.key = keys[t], .triplet = t, .box = boxes[t], .weight = weights[t], .slots = slotsOf(keys[t], t)});
+      }
+    }
+    result.candidates = candidates.size();
+    // Order: one stable sort, so that equal keys keep the triplets' order.
+    std::ranges::stable_sort(candidates, {}, &Candidate::key);
+    // Rounds: the frames' segments, and each frame's rounds.
+    BoundedVector<std::size_t> frameBegin(resource);
+    for (std::size_t i = 0; i < candidates.size(); ++i) {
+      if (i == 0U || vertexKeyFrame(candidates[i].key) != vertexKeyFrame(candidates[i - 1U].key)) {
+        frameBegin.push_back(i);
+      }
+    }
+    frameBegin.push_back(candidates.size());
+    const std::size_t frames = frameBegin.size() - 1U;
+    BoundedVector<BoundedVector<Found>> found(frames, BoundedVector<Found>(resource), resource);
+    BoundedVector<std::int32_t> claimedBy(candidates.size(), kClaimFree, resource);
+    BoundedVector<std::uint32_t> rounds(frames, 0U, resource);
+    const auto rounder = [&](std::size_t begin, std::size_t end) {
+      for (auto f = begin; f < end; ++f) {
+        const std::span<const Candidate> segment{candidates.data() + frameBegin[f], frameBegin[f + 1U] - frameBegin[f]};
+        const std::span<std::int32_t> claims{claimedBy.data() + frameBegin[f], segment.size()};
+        const auto frame = vertexKeyFrame(segment.front().key);
+        const auto first = std::ranges::lower_bound(sources, frame, {}, [](const Source& source) { return vertexKeyFrame(source.key); });
+        const auto last = std::ranges::upper_bound(sources, frame, {}, [](const Source& source) { return vertexKeyFrame(source.key); });
+        rounds[f] = findInFrame(segment, claims, found[f], {first, last}, ownedSlots);
+      }
+    };
+    parallel(frames, 1U, rounder);
+    // Seeds: the list, in frame order and each frame's in z; the claims renumbered.
+    BoundedVector<std::int32_t> firstOfFrame(frames, 0, resource);
+    for (std::size_t f = 0; f < frames; ++f) {
+      firstOfFrame[f] = static_cast<std::int32_t>(result.vertices.size());
+      result.rounds = std::max(result.rounds, rounds[f]);
+      for (const auto& vertex : found[f]) {
+        result.vertices.push_back(vertex.seed);
+        result.contributors.push_back(vertex.contributors);
+      }
+    }
+    // Each candidate's vertex in the list: free, a dropped one too.
+    BoundedVector<std::int32_t> vertexOf(candidates.size(), VertexerResult::kFree, resource);
+    for (std::size_t f = 0; f < frames; ++f) {
+      for (auto i = frameBegin[f]; i < frameBegin[f + 1U]; ++i) {
+        if (claimedBy[i] >= 0) {
+          vertexOf[i] = firstOfFrame[f] + claimedBy[i];
+        }
+      }
+    }
+    if (keepTripletVertex) {
+      result.tripletVertex.assign(tripletCount, VertexerResult::kNone);
+      for (std::size_t t = 0; t < tripletCount; ++t) {
+        if (!owned.owns(measurements.timePS[tracklets.target[triplets.first[t]]])) {
+          result.tripletVertex[t] = VertexerResult::kNotOwned;
+        }
+      }
+      for (std::size_t i = 0; i < candidates.size(); ++i) {
+        result.tripletVertex[candidates[i].triplet] = vertexOf[i];
+      }
+    }
+    return result;
+  }
+
+ private:
+  struct Candidate {
+    std::uint64_t key = 0U;
+    std::uint32_t triplet = 0U;
+    TimeEstPS box;                        ///< the triplet's, its boxes' intersection
+    std::uint64_t weight = 0U;            ///< in its vertex's mean (`candidateWeight`)
+    std::array<std::uint32_t, 3> slots{}; ///< its measurements' ownership slots
+  };
+
+  /// A triplet whose measurements a vertex can own: every one of the owned
+  /// frames but the degenerate, the cut ones too.
+  struct Source {
+    std::uint64_t key = 0U;
+    std::uint32_t triplet = 0U;
+    std::array<std::uint32_t, 3> slots{};
+  };
+
+  struct Found {
+    VertexSeed seed;
+    std::uint32_t contributors = 0U;
+  };
+
+  /// The rounds of one frame's \a segment, sorted by z, claiming into
+  /// \a claims (kClaimFree, kClaimDropped, else the vertex's index in \a found);
+  /// \a found sorted by z at the end. After each vertex, the measurements of
+  /// the frame's \a sources (sorted by z) within its claim become owned in
+  /// \a ownedSlots, and the free candidates with an owned one are dropped.
+  /// A frame whose rounds find no vertex runs them again at
+  /// `aloneMinContributors` when that is the lower minimum; nothing was
+  /// claimed, owned or dropped, so it starts from the same state. The rounds
+  /// taken, the last included -- of the rerun alone where it ran.
+  std::uint32_t findInFrame(std::span<const Candidate> segment, std::span<std::int32_t> claims, BoundedVector<Found>& found, std::span<const Source> sources, std::span<std::uint8_t> ownedSlots) const
+  {
+    const std::size_t n = segment.size();
+    std::pmr::memory_resource* const resource = found.get_allocator().resource();
+    BoundedVector<std::int64_t> z(n, resource);
+    for (std::size_t i = 0; i < n; ++i) {
+      z[i] = vertexKeyZUM(segment[i].key);
+    }
+    const auto at = [&](std::int64_t value) { return static_cast<std::size_t>(std::ranges::lower_bound(z, value) - z.begin()); };
+    const std::int64_t window = mSettings.windowUM;
+    const std::int64_t claim = mSettings.claimUM;
+    // The test (2W - S)^2 >= 2 k^2 S, with W the window's count and S the
+    // two sidebands': the excess over the sidebands' mean against k times its
+    // root, squared.
+    const Scalar k2 = 2.F * mSettings.significance * mSettings.significance;
+    BoundedVector<std::uint32_t> count(n + 1U, 0U, resource);
+    std::uint32_t minContributors = mSettings.minContributors;
+    std::uint32_t rounds = 0U;
+    while (true) {
+      ++rounds;
+      for (std::size_t i = 0; i < n; ++i) {
+        count[i + 1U] = count[i] + (claims[i] == kClaimFree ? 1U : 0U);
+      }
+      const auto countIn = [&](std::int64_t low, std::int64_t high) { return count[at(high)] - count[at(low)]; };
+      std::int64_t bestExcess = 0;
+      std::size_t best = n;
+      for (std::size_t i = 0; i < n; ++i) {
+        if (claims[i] != kClaimFree) {
+          continue;
+        }
+        const auto excess = peakExcess(z[i], window, claim, minContributors, k2, countIn);
+        if (excess <= bestExcess) {
+          continue;
+        }
+        bestExcess = excess;
+        best = i;
+      }
+      if (best == n) {
+        if (found.empty() && mSettings.aloneMinContributors != 0U && mSettings.aloneMinContributors < minContributors) {
+          minContributors = mSettings.aloneMinContributors;
+          rounds = 0U;
+          continue;
+        }
+        break;
+      }
+      // The centre: the mean of the window's free candidates.
+      const auto windowEnd = at(z[best] + window);
+      std::int64_t sum = 0;
+      for (auto i = best; i < windowEnd; ++i) {
+        sum += claims[i] == kClaimFree ? z[i] : 0;
+      }
+      const auto members = static_cast<std::int64_t>(count[windowEnd] - count[best]);
+      const Scalar centre = static_cast<Scalar>(sum) / static_cast<Scalar>(members);
+      // Claim within the claim's reach.
+      const auto id = static_cast<std::int32_t>(found.size());
+      Found vertex;
+      BoundedVector<std::int64_t> claimed(resource);
+      BoundedVector<std::uint64_t> claimedWeight(resource);
+      std::uint32_t earliest = std::numeric_limits<std::uint32_t>::max();
+      std::uint32_t latest = 0U;
+      for (auto i = at(static_cast<std::int64_t>(centre) - claim - 1); i < n && static_cast<Scalar>(z[i]) <= centre + static_cast<Scalar>(claim); ++i) {
+        if (claims[i] != kClaimFree || !withinZ(z[i], centre, static_cast<Scalar>(claim))) {
+          continue;
+        }
+        claims[i] = id;
+        ++vertex.contributors;
+        earliest = std::min(earliest, segment[i].box.lower());
+        latest = std::max(latest, segment[i].box.upper());
+        claimed.push_back(z[i]);
+        claimedWeight.push_back(segment[i].weight);
+      }
+      // The vertex's z and error: the weighted mean of a selection grown from
+      // the core within the window, by the claimed candidates within
+      // clipNSigma of their own and the mean's errors of it, until none joins.
+      BoundedVector<std::uint8_t> selected(claimed.size(), 0U, resource);
+      std::uint64_t weightSum = 0U;
+      std::int64_t weightedZSum = 0;
+      std::int64_t selectedCount = 0;
+      const auto select = [&](std::size_t k) {
+        selected[k] = 1U;
+        weightSum += claimedWeight[k];
+        weightedZSum += static_cast<std::int64_t>(claimedWeight[k]) * claimed[k];
+        ++selectedCount;
+      };
+      for (std::size_t k = 0; k < claimed.size(); ++k) {
+        if (withinZ(claimed[k], centre, static_cast<Scalar>(window))) {
+          select(k);
+        }
+      }
+      for (bool grew = true; grew;) {
+        grew = false;
+        const auto moments = zMoments(weightSum, weightedZSum);
+        for (std::size_t k = 0; k < claimed.size(); ++k) {
+          if (selected[k] == 0U && withinError(claimed[k], claimedWeight[k], moments, mSettings.clipNSigma)) {
+            select(k);
+            grew = true;
+          }
+        }
+      }
+      const auto settled = zMoments(weightSum, weightedZSum);
+      std::uint64_t scatterSum = 0U;
+      for (std::size_t k = 0; k < claimed.size(); ++k) {
+        if (selected[k] != 0U) {
+          scatterSum += candidateScatter(claimed[k], claimedWeight[k], settled.mean);
+        }
+      }
+      vertex.seed = vertexSeedOf({.weightSum = weightSum, .weightedZSum = weightedZSum, .scatterSum = scatterSum, .count = selectedCount, .earliestPS = earliest, .latestPS = latest}, mBeamSpot);
+      found.push_back(vertex);
+      // The vertex owns the measurements of the frame's triplets within
+      // its claim; the free candidates with an owned one are dropped before
+      // the next round counts.
+      const auto sourceZ = [](const Source& source) { return vertexKeyZUM(source.key); };
+      const auto reach = static_cast<std::int64_t>(centre);
+      for (auto it = std::ranges::lower_bound(sources, reach - claim - 1, {}, sourceZ); it != sources.end() && sourceZ(*it) <= reach + claim + 1; ++it) {
+        if (withinZ(sourceZ(*it), centre, static_cast<Scalar>(claim))) {
+          for (const auto slot : it->slots) {
+            ownedSlots[slot] = 1U;
+          }
+        }
+      }
+      for (std::size_t i = 0; i < n; ++i) {
+        if (claims[i] == kClaimFree && std::ranges::any_of(segment[i].slots, [&](std::uint32_t slot) { return ownedSlots[slot] != 0U; })) {
+          claims[i] = kClaimDropped;
+        }
+      }
+    }
+    // The frame's vertices by z, ties by the order found, and the claims
+    // renumbered to match.
+    BoundedVector<std::uint32_t> order(found.size(), resource);
+    for (std::size_t v = 0; v < order.size(); ++v) {
+      order[v] = static_cast<std::uint32_t>(v);
+    }
+    std::ranges::stable_sort(order, {}, [&](std::uint32_t v) { return found[v].seed.z; });
+    BoundedVector<std::int32_t> placeOf(found.size(), resource);
+    BoundedVector<Found> sorted(resource);
+    sorted.reserve(found.size());
+    for (std::size_t place = 0; place < order.size(); ++place) {
+      placeOf[order[place]] = static_cast<std::int32_t>(place);
+      sorted.push_back(found[order[place]]);
+    }
+    for (auto& owner : claims) {
+      owner = owner < 0 ? owner : placeOf[static_cast<std::size_t>(owner)];
+    }
+    found.swap(sorted);
+    return rounds;
+  }
+
+  VertexerSettings mSettings;
+  VertexConstraint mBeamSpot;
+};
+
+#endif
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_VERTEXSTAGE_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/VertexingPass.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/VertexingPass.h
new file mode 100644
index 0000000000000..726556d56124b
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/VertexingPass.h
@@ -0,0 +1,120 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file VertexingPass.h
+/// \brief The own vertexer before the tracking, on the host.
+///
+/// The vertexing pass is a tracker of one iteration at the beam line whose
+/// links join the innermost layers: it runs over the timeframe in the
+/// tracking's slices and stops at their triplets; the vertexer turns each
+/// slice's into the vertices of the frames its core owns (`Vertexer::find`,
+/// `OwnedFrames`), so that the slices' lists make the timeframe's, each
+/// vertex once, and the pass's memory is a slice's. The list
+/// takes the place of the MC's for the iterations that seed from it. The
+/// pass keeps its own used mask, all free: it takes no clusters from the
+/// tracking.
+
+#ifndef GTRK_TRACKING_VERTEXINGPASS_H_
+#define GTRK_TRACKING_VERTEXINGPASS_H_
+
+#include "GenericTracking/Tracking/Tracker.h"
+#include "GenericTracking/Tracking/VertexStage.h"
+
+#include <memory>
+#include <utility>
+
+namespace o2::gtrk
+{
+
+template <DetectorLayout Det, typename Material>
+class VertexingPass
+{
+ public:
+  using Pass = Tracker<Det, Material>;
+  using Frame = typename Pass::Frame;
+
+  /// What `find` gives: the vertexer's result, or the status the pass
+  /// failed with -- out of memory, as any stage can. The pass's tracklets and
+  /// triplets stay valid until the next `find`, for the QA.
+  struct Result {
+    StageStatus status = StageStatus::kComplete;
+    VertexerResult found;
+    /// With claims asked for, every triplet of the frames owned, its rows and
+    /// the vertex in `found` it went to (`VertexerResult::kFree`, `kNone`),
+    /// for the QA; the not-owned triplets are left out.
+    std::vector<TripletClaim> claims;
+  };
+
+  /// \a pass the pass's iteration (GridConfig.h, `vertexingPassSettings`),
+  /// \a vertexer the vertexer's settings; the rest as for a Tracker.
+  VertexingPass(const IterationSettings& pass, const VertexerSettings& vertexer, const VertexConstraint& beamSpot, const ScatteringTable<Det>& scattering, std::shared_ptr<BoundedMemoryResource> memoryPool, typename Pass::Index chunkSize, int maxConcurrency = 0)
+    : mPass(pass, beamSpot, scattering, memoryPool, chunkSize, maxConcurrency),
+      mVertexer(vertexer, beamSpot),
+      mMemoryPool(std::move(memoryPool))
+  {
+  }
+
+  /// The pass's memory back to the pool, after the caller has read `find`'s
+  /// result.
+  void endTimeframe() noexcept { mPass.endTimeframe(); }
+
+  /// The pass's iteration parameters, as a device run configures the pass
+  /// after the tracking's iterations.
+  [[nodiscard]] const IterationParameters<Det>& passParameters() const { return mPass.iteration(0U); }
+  [[nodiscard]] const VertexerSettings& settings() const { return mVertexer.settings(); }
+
+  /// The vertices of \a frame, sorted by time, the pass in slices of
+  /// \a sliceWidthBlocks blocks with at least \a haloPS of halo, as
+  /// `planTimeframe` plans the tracking's; with \a keepClaims the claims too.
+  [[nodiscard]] Result find(const Frame& frame, std::int32_t sliceWidthBlocks, std::int64_t haloPS, bool keepClaims = false)
+  {
+    Result result;
+    result.status = mPass.beginTimeframe(frame);
+    if (result.status != StageStatus::kComplete) {
+      return result;
+    }
+    const auto plan = mPass.planTimeframe(frame, {}, sliceWidthBlocks, haloPS);
+    // Each candidate's z0 error from the pass's material at its own momentum
+    // and the beam's transverse spread.
+    const ScatteringErrors<Det> errors{
+      .table = &mPass.iteration(0U).scattering,
+      .cut = mPass.iteration(0U).pairCut,
+      .varTransverse = mPass.beamLine().varTransverse,
+    };
+    for (const auto& planned : plan.slices) {
+      const auto slice = mPass.runSlice(0U, frame, plan, planned, {}, plan.vertexWindows[0]);
+      result.status = slice.status;
+      if (result.status != StageStatus::kComplete) {
+        return result;
+      }
+      const auto tracklets = slice.tracklets->view();
+      const auto triplets = slice.triplets->view();
+      const auto found = mVertexer.find(frame.measurements(), tracklets, triplets, slice.triplets->size(), &mPass.arena(), keepClaims, errors, mMemoryPool.get(), ownedFrames(frame.grid().geometry(), planned.slice.coreBlocks));
+      const auto offset = static_cast<std::int32_t>(result.found.vertices.size());
+      for (std::size_t t = 0; t < found.tripletVertex.size(); ++t) {
+        if (const auto vertex = found.tripletVertex[t]; vertex != VertexerResult::kNotOwned) {
+          result.claims.push_back({.rows = tripletRows(tracklets, triplets, static_cast<std::uint32_t>(t)), .vertex = vertex < 0 ? vertex : offset + vertex});
+        }
+      }
+      appendVertices(result.found, found);
+    }
+    return result;
+  }
+
+ private:
+  Pass mPass;
+  Vertexer mVertexer;
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool; ///< the pass's, for the vertexer's work arrays
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_VERTEXINGPASS_H_
diff --git a/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/WorkCounters.h b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/WorkCounters.h
new file mode 100644
index 0000000000000..108bbbb20eec7
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/include/GenericTracking/Tracking/WorkCounters.h
@@ -0,0 +1,271 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file WorkCounters.h
+/// \brief Counts of the work inside the stages' per-element loops.
+///
+/// The candidates a stage looks at, what each cut
+/// rejects, the fits it reaches and the time they take.
+/// A count touches a hot loop, so only a build with `GTRK_WORK_COUNTERS`
+/// counts (O2's CMake option of that name, which defines it for every unit
+/// that links the tracking), and only on the host: elsewhere `countWork` and
+/// `WorkTimer` are empty. Each thread counts into its own block; `workCounts` sums them, and
+/// is read between parallel loops, whose join orders the counts before it.
+/// Nothing here reads or writes what the tracking computes.
+
+#ifndef GTRK_TRACKING_WORKCOUNTERS_H_
+#define GTRK_TRACKING_WORKCOUNTERS_H_
+
+#include "GenericTracking/Base/Definitions.h"
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+#if defined(GTRK_WORK_COUNTERS) && !defined(__CUDACC__) && !defined(__HIPCC__)
+#include <chrono>
+#endif
+
+namespace o2::gtrk
+{
+
+/// Every count, in report order.
+enum class WorkCounter : std::uint8_t {
+  kTripletFirsts,       ///< first tracklets visited
+  kTripletNoMiddle,     ///< of them, whose middle is not a source of the slice
+  kTripletWindow,       ///< second tracklets inside the dip-angle window
+  kTripletTime,         ///< of them, rejected by the time cut
+  kTripletCurvature,    ///< rejected by the curvature cut
+  kTripletFits,         ///< reaching the fit
+  kTripletFitFailed,    ///< the fit failed
+  kTripletChi2,         ///< rejected by the fit's chi2
+  kTripletOwnMomentum,  ///< rejected by the fit's chi2 with the scattering at the triplet's own momentum
+  kTripletKinked,       ///< kept only with the kink allowance (counted in the rejections above as well, once each)
+  kTripletFitNS,        ///< time inside the fit
+  kNeighbourTriplets,   ///< triplets visited
+  kNeighbourCandidates, ///< triplets ending on their first tracklet
+  kNeighbourBothKinked, ///< of them, both triplets kinked: never neighbours
+  kNeighbourCurvature,  ///< rejected by the curvature agreement
+  kNeighbourTime,       ///< rejected by the time cut
+  kNeighbourFits,       ///< reaching the fit
+  kNeighbourFitFailed,  ///< the fit failed
+  kNeighbourChi2,       ///< rejected by the fit's chi2
+  kNeighbourFitNS,      ///< time inside the fit
+  kRoadTime,            ///< rejected before the fit: their boxes share no time
+  kRoadFits,            ///< roads fitted
+  kRoadStepsPossible,   ///< the filter steps their complete outward passes would take
+  kRoadSteps,           ///< the steps taken, the chi2 cut stopping a pass early
+  kRoadChi2,            ///< rejected by the chi2 cut, early or at the end
+  kRoadPropagation,     ///< the propagation failed
+  kRoadFloor,           ///< below the pT floor for their cluster count
+  kRoadBeam,            ///< refused by the beam line
+  kRoadAccepted,        ///< selection records emitted
+  kRoadTrimFits,        ///< roads fitted again without their innermost clusters (innerTrim)
+  kRoadTrimAccepted,    ///< of the roads, the ones a fit without their innermost clusters took
+  kTrackletSources,     ///< sources visited that no earlier track holds exclusively
+  kTrackletQueries,     ///< their out-links whose window they reach: one grid query each
+  kTrackletUsed,        ///< candidates an earlier track holds exclusively
+  kTrackletAccepted,    ///< tracklets emitted
+  kPairTests,           ///< candidates reaching the pair cut's transverse test
+  kPairTransverse,      ///< of them, passing it
+  kGridQueries,         ///< the tracklet stage's grid queries (the follow's are kFollowGridQueries)
+  kGridBlocks,          ///< time blocks they span
+  kGridRanges,          ///< row ranges they read, each a run of consecutive cells
+  kGridCells,           ///< cells those runs cover
+  kGridSearchedCells,   ///< of them, in runs dense enough for the per-cell binary searches
+  kGridRows,            ///< rows in the runs
+  kGridInBound,         ///< of them, inside the query's time bound
+  kGridVisits,          ///< of those, passing the exact time cut: handed to the caller
+  kPropagations,        ///< plane crossings solved (the fits' and the follow's)
+  kPropagationsGrazing, ///< of them, at |n . d| <= 0.1: the ones a float solve would not serve
+  kSortSegments,        ///< tracklet sort: sources with two tracklets or more
+  kSortSegmentsOver8,   ///< of them, with more than 8
+  kSortSegmentsOver32,  ///< with more than 32
+  kSortSegmentsOver128, ///< with more than 128
+  kSortSegmentsOver512, ///< with more than 512
+  kSortTracklets,       ///< the tracklets of the sources counted in kSortSegments
+  kSortTrackletsOver32, ///< of them, in sources with more than 32
+  kPairLongitudinal,    ///< pair tests passing the longitudinal (second-coordinate) test, after the transverse one
+  // The grid's counts of the follow's queries, in kGridQueries..kGridVisits's
+  // order: the grid counts there while a FollowGridScope is open.
+  kFollowGridQueries,
+  kFollowGridBlocks,
+  kFollowGridRanges,
+  kFollowGridCells,
+  kFollowGridSearchedCells,
+  kFollowGridRows,
+  kFollowGridInBound,
+  kFollowGridVisits,
+  kTrackletHoles,       ///< candidates whose segment crosses another layer's envelope, in an iteration taking no skips
+  kTrackletHoleQueries, ///< queries not made: every pair of the source on the link would cross one
+  kPairBetweenBound,    ///< candidates the transverse test refuses at the link's bound on the kink between the layers, before their own
+  // The follow: its searches, its passes, and the
+  // passes of the earlier iterations' follow apart.
+  kFollowUpdates,              ///< its candidates reaching the update's chi2: free and in the step's window
+  kFollowProposed,             ///< rows the follow proposes, before the bidding
+  kFollowOutbid,               ///< of them, cut by the bidding: on or after a row another track won
+  kFollowRefitRejected,        ///< of the rest, dropped with their track's failed refit
+  kFollowKinkSteps,            ///< steps no row passed that tried the kink allowance
+  kFollowKinksTaken,           ///< of them, taking a confirmed row
+  kFollowLookaheads,           ///< steps more than one row passed that ranked them by their confirmation
+  kFollowKinkUpdates,          ///< the kink passes' candidates reaching the update's chi2
+  kFollowWitnessUpdates,       ///< the kink rows' confirmations' candidates reaching the update's chi2
+  kFollowWitnessTrimmed,       ///< rows the bidding left that are dropped with the witness of a kink step
+  kFollowHoleTests,            ///< layers without a passing row tested for the track crossing a sensor
+  kFollowHoles,                ///< of them, holes: a sensor crossed within its bounds
+  kFollowUnconfirmed,          ///< last rows dropped, no row confirming them where a sensor was crossed
+  kFollowDensityKept,          ///< of the unconfirmed last rows, kept on their density (followKeepDensity)
+  kFollowEndRefused,           ///< inward last rows refused at the layout's end on sqrt|V| (followEndMaxSqrtDet)
+  kFollowTrimFits,             ///< tracks refitted without their last outward row (followTrimMargin)
+  kFollowTrimmed,              ///< of them, the row trimmed: two or more passed its gate, the track kept the cuts
+  kFollowTrimUpdates,          ///< the updates counting the rows that pass the trimmed row's gate
+  kFollowEndFits,              ///< roads fitted again without their outermost row (followEnd)
+  kFollowEndReplaced,          ///< of them, the follow's first row another than that row
+  kFollowEarlierProposed,      ///< rows the earlier iterations' follow proposes (`followEarlier`)
+  kFollowEarlierOutbid,        ///< of them, cut by the bidding
+  kFollowEarlierRefitRejected, ///< of the rest, dropped with their track's failed refit
+  kTrackletInWindow,           ///< candidates inside their query's own phi and second-coordinate window
+  kTrackletAcceptedOutside,    ///< tracklets emitted whose target lies outside that window
+  kPairBetweenBoundIn,         ///< of kPairBetweenBound, candidates inside the window
+  kPairTestsIn,                ///< of kPairTests, inside the window
+  kPairLongitudinalTestsIn,    ///< candidates reaching the longitudinal test (kPairTransverse) that are inside the window
+  kFollowBeamEndRefused,       ///< follow: inward last rows refused against the beam line (followBeamEnd)
+  kTrackletShape,              ///< candidates whose line crosses a measurement outside its slope interval (shapeTest)
+  kTripletShape,               ///< thirds whose triplet's line crosses a measurement outside its slope interval
+  kCount
+};
+
+inline constexpr std::size_t kWorkCounterCount = static_cast<std::size_t>(WorkCounter::kCount);
+using WorkCounts = std::array<std::uint64_t, kWorkCounterCount>;
+
+/// The tracklet stage's counts per link, indexed by the layout's link.
+enum class LinkCounter : std::uint8_t {
+  kQueries,    ///< grid queries, as kTrackletQueries
+  kCandidates, ///< candidates reaching the pair cut: not held by an earlier track, not crossing another layer
+  kTracklets,  ///< tracklets emitted
+  kCount
+};
+inline constexpr std::size_t kLinkCounterCount = static_cast<std::size_t>(LinkCounter::kCount);
+using LinkWorkCounts = std::vector<std::array<std::uint64_t, kLinkCounterCount>>;
+
+#if defined(GTRK_WORK_COUNTERS) && !defined(__CUDACC__) && !defined(__HIPCC__)
+
+/// Whether this build counts.
+inline constexpr bool kWorkCounters = true;
+
+namespace detail
+{
+/// The calling thread's block, registered on first use.
+[[nodiscard]] WorkCounts& threadWorkCounts();
+/// The calling thread's per-link counts, in the same block.
+[[nodiscard]] LinkWorkCounts& threadLinkWorkCounts();
+} // namespace detail
+
+/// Every thread's counts since the process began, summed.
+[[nodiscard]] WorkCounts workCounts();
+/// The same per link.
+[[nodiscard]] LinkWorkCounts linkWorkCounts();
+
+inline void countWork(WorkCounter counter, std::uint64_t amount = 1U) { detail::threadWorkCounts()[static_cast<std::size_t>(counter)] += amount; }
+
+inline void countLinkWork(std::size_t link, LinkCounter counter, std::uint64_t amount = 1U)
+{
+  auto& counts = detail::threadLinkWorkCounts();
+  if (link >= counts.size()) {
+    counts.resize(link + 1U);
+  }
+  counts[link][static_cast<std::size_t>(counter)] += amount;
+}
+
+namespace detail
+{
+/// Whether the calling thread's grid queries are the follow's.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+inline thread_local bool tFollowGrid = false;
+} // namespace detail
+
+/// A grid counter, kGridQueries to kGridVisits: the follow's own while a
+/// FollowGridScope is open on the calling thread.
+inline void countGridWork(WorkCounter counter, std::uint64_t amount = 1U)
+{
+  if (detail::tFollowGrid) {
+    counter = static_cast<WorkCounter>(static_cast<std::size_t>(WorkCounter::kFollowGridQueries) + static_cast<std::size_t>(counter) - static_cast<std::size_t>(WorkCounter::kGridQueries));
+  }
+  countWork(counter, amount);
+}
+
+/// The grid's counts on the calling thread go to the follow's counters
+/// until destroyed.
+class FollowGridScope
+{
+ public:
+  FollowGridScope() : mOuter{detail::tFollowGrid} { detail::tFollowGrid = true; }
+  FollowGridScope(const FollowGridScope&) = delete;
+  FollowGridScope& operator=(const FollowGridScope&) = delete;
+  FollowGridScope(FollowGridScope&&) = delete;
+  FollowGridScope& operator=(FollowGridScope&&) = delete;
+  ~FollowGridScope() { detail::tFollowGrid = mOuter; }
+
+ private:
+  bool mOuter;
+};
+
+/// Adds the nanoseconds of its lifetime to a counter.
+class WorkTimer
+{
+ public:
+  explicit WorkTimer(WorkCounter counter) : mCounter{counter}, mStart{std::chrono::steady_clock::now()} {}
+  WorkTimer(const WorkTimer&) = delete;
+  WorkTimer& operator=(const WorkTimer&) = delete;
+  WorkTimer(WorkTimer&&) = delete;
+  WorkTimer& operator=(WorkTimer&&) = delete;
+  ~WorkTimer()
+  {
+    const auto nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now() - mStart).count();
+    countWork(mCounter, static_cast<std::uint64_t>(nanoseconds));
+  }
+
+ private:
+  WorkCounter mCounter;
+  std::chrono::steady_clock::time_point mStart;
+};
+
+#else
+
+inline constexpr bool kWorkCounters = false;
+
+[[nodiscard]] inline WorkCounts workCounts() { return {}; }
+[[nodiscard]] inline LinkWorkCounts linkWorkCounts() { return {}; }
+
+GPUhdi() GPUAlwaysInline() void countWork(WorkCounter /*counter*/, std::uint64_t /*amount*/ = 1U) {}
+GPUhdi() GPUAlwaysInline() void countLinkWork(std::size_t /*link*/, LinkCounter /*counter*/, std::uint64_t /*amount*/ = 1U) {}
+GPUhdi() GPUAlwaysInline() void countGridWork(WorkCounter /*counter*/, std::uint64_t /*amount*/ = 1U) {}
+
+class FollowGridScope
+{
+ public:
+  // User-provided, so that a const scope -- the form its users declare -- is
+  // well-formed without members to initialise.
+  GPUhdi() GPUAlwaysInline() FollowGridScope() {} // NOLINT(modernize-use-equals-default)
+};
+
+class WorkTimer
+{
+ public:
+  GPUhdi() GPUAlwaysInline() explicit WorkTimer(WorkCounter /*counter*/) {}
+};
+
+#endif
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_WORKCOUNTERS_H_
diff --git a/Detectors/GenericTracking/tracking/src/GPU/DeviceArena.cxx b/Detectors/GenericTracking/tracking/src/GPU/DeviceArena.cxx
new file mode 100644
index 0000000000000..9b01b38b59a01
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/src/GPU/DeviceArena.cxx
@@ -0,0 +1,175 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+
+#include <algorithm>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <exception>
+#include <stdexcept>
+#include <utility>
+
+namespace o2::gtrk
+{
+
+DeviceArena::DeviceArena(DeviceRuntime& runtime, DeviceBlock block) : mRuntime(&runtime), mBase(block.data), mCapacity(block.bytes)
+{
+  for (auto& scopes : mScopes) {
+    scopes.push_back({.offset = 0U, .serial = mNextSerial++});
+  }
+}
+
+DeviceAllocation DeviceArena::refuse(std::size_t bytes, ArenaEnd end) const { return {.data = nullptr, .bytes = bytes, .tag = currentTag(end)}; }
+
+DeviceAllocation DeviceArena::allocate(std::size_t bytes, std::size_t alignment, ArenaEnd end)
+{
+  if (!std::has_single_bit(alignment)) {
+    throw std::invalid_argument("device arena alignment must be a non-zero power of two");
+  }
+  auto* const origin = static_cast<std::byte*>(mBase);
+  const std::size_t free = mCapacity - mUsed[0] - mUsed[1];
+  if (bytes == 0U) {
+    std::byte* at = nullptr;
+    if (origin != nullptr) {
+      at = end == ArenaEnd::kBase ? origin + mUsed[0] : origin + (mCapacity - mUsed[1]);
+    }
+    return {.data = at, .bytes = 0U, .tag = currentTag(end)};
+  }
+  if (origin == nullptr || bytes > free) {
+    return refuse(bytes, end);
+  }
+
+  // Addresses, not offsets, are aligned.
+  const std::size_t mask = alignment - 1U;
+  if (end == ArenaEnd::kBase) {
+    std::byte* const low = origin + mUsed[0];
+    const std::size_t padding = (alignment - (std::bit_cast<std::uintptr_t>(low) & mask)) & mask;
+    if (padding > free - bytes) {
+      return refuse(bytes, end);
+    }
+    mUsed[0] += padding + bytes;
+    mPeak = std::max(mPeak, used());
+    return {.data = low + padding, .bytes = bytes, .tag = currentTag(end)};
+  }
+  std::byte* const unaligned = origin + (mCapacity - mUsed[1] - bytes);
+  const std::size_t padding = std::bit_cast<std::uintptr_t>(unaligned) & mask;
+  if (padding > free - bytes) {
+    return refuse(bytes, end);
+  }
+  mUsed[1] += bytes + padding;
+  mPeak = std::max(mPeak, used());
+  return {.data = unaligned - padding, .bytes = bytes, .tag = currentTag(end)};
+}
+
+ArenaScope DeviceArena::scope(ArenaEnd end)
+{
+  auto& scopes = mScopes[static_cast<std::size_t>(end)];
+  scopes.push_back({.offset = mUsed[static_cast<std::size_t>(end)], .serial = mNextSerial++});
+  return ArenaScope{*this, end, scopes.size() - 1U, scopes.back().serial};
+}
+
+void DeviceArena::reset() noexcept
+{
+  mUsed = {};
+  for (auto& scopes : mScopes) {
+    scopes.clear();
+    scopes.push_back({.offset = 0U, .serial = mNextSerial++});
+  }
+}
+
+void DeviceArena::rebind(DeviceBlock block) noexcept
+{
+  reset();
+  mBase = block.data;
+  mCapacity = block.bytes;
+  mPeak = 0U;
+}
+
+ArenaTag DeviceArena::currentTag(ArenaEnd end) const noexcept
+{
+  const auto& scopes = mScopes[static_cast<std::size_t>(end)];
+  return {.arena = this, .end = end, .depth = scopes.size() - 1U, .serial = scopes.back().serial};
+}
+
+bool DeviceArena::live(const ArenaTag& tag) const noexcept
+{
+  if (tag.arena != this) {
+    return false;
+  }
+  const auto& scopes = mScopes[static_cast<std::size_t>(tag.end)];
+  return tag.depth < scopes.size() && scopes[tag.depth].serial == tag.serial;
+}
+
+void DeviceArena::requireLive(const ArenaTag& tag) const
+{
+  if (!live(tag)) {
+    throw std::logic_error("device storage belongs to a rewound arena scope");
+  }
+}
+
+void DeviceArena::closeScope(ArenaEnd end, std::size_t depth, std::uint64_t serial, bool commit) noexcept
+{
+  auto& scopes = mScopes[static_cast<std::size_t>(end)];
+  // reset() deliberately makes outstanding ArenaScope objects inert.
+  if (depth >= scopes.size() || scopes[depth].serial != serial) {
+    return;
+  }
+  if (depth + 1U != scopes.size() || depth == 0U) {
+    std::terminate();
+  }
+  if (!commit) {
+    mUsed[static_cast<std::size_t>(end)] = scopes.back().offset;
+  }
+  scopes.pop_back();
+}
+
+ArenaScope::~ArenaScope() { close(); }
+
+ArenaScope::ArenaScope(ArenaScope&& other) noexcept
+  : mArena(std::exchange(other.mArena, nullptr)),
+    mEnd(other.mEnd),
+    mDepth(other.mDepth),
+    mSerial(other.mSerial)
+{
+}
+
+ArenaScope& ArenaScope::operator=(ArenaScope&& other) noexcept
+{
+  if (this != &other) {
+    close();
+    mArena = std::exchange(other.mArena, nullptr);
+    mEnd = other.mEnd;
+    mDepth = other.mDepth;
+    mSerial = other.mSerial;
+  }
+  return *this;
+}
+
+void ArenaScope::commit()
+{
+  if (mArena == nullptr) {
+    throw std::logic_error("cannot commit an empty device arena scope");
+  }
+  mArena->closeScope(mEnd, mDepth, mSerial, true);
+  mArena = nullptr;
+}
+
+void ArenaScope::close() noexcept
+{
+  if (mArena != nullptr) {
+    mArena->closeScope(mEnd, mDepth, mSerial, false);
+    mArena = nullptr;
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/src/GPU/DeviceContext.cxx b/Detectors/GenericTracking/tracking/src/GPU/DeviceContext.cxx
new file mode 100644
index 0000000000000..4147a2f100b82
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/src/GPU/DeviceContext.cxx
@@ -0,0 +1,130 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Tracking/GPU/DeviceContext.h"
+
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/RuntimeFactory.h"
+
+#include "GPUO2ExternalUser.h" // first of O2's GPU headers outside GPU/
+#include "GPUChainGenericTracking.h"
+#include "GPUMemoryResource.h"
+#include "GPUReconstruction.h"
+#include "GPUSettings.h"
+
+#include <algorithm>
+#include <cctype>
+#include <format>
+#include <stdexcept>
+#include <string>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+/// The backend's name as GPUReconstruction::CreateInstance spells it.
+std::string upperCase(std::string_view backend)
+{
+  std::string type{backend};
+  std::ranges::transform(type, type.begin(), [](unsigned char c) { return static_cast<char>(std::toupper(c)); });
+  return type;
+}
+} // namespace
+
+DeviceContext::DeviceContext(std::string_view backend, int device, std::span<const std::size_t> blockBytes)
+  : mOwned(o2::gpu::GPUReconstruction::CreateInstance(upperCase(backend).c_str(), true)),
+    mReconstruction(mOwned.get())
+{
+  const std::string type = upperCase(backend);
+  if (mReconstruction == nullptr) {
+    throw std::runtime_error(std::format("GPU backend {}: no GPU reconstruction", type));
+  }
+  mChain = mReconstruction->AddChain<GPUChainGenericTracking>();
+  for (const auto bytes : blockBytes) {
+    static_cast<void>(mChain->AddBlock(bytes));
+  }
+  const o2::gpu::GPUSettingsGRP grp;
+  o2::gpu::GPUSettingsProcessing processing;
+  processing.deviceNum = device;
+  // The pool is the blocks the chain reports, and the pinned host pool what
+  // the reconstruction keeps there itself.
+  processing.forceMemoryPoolSize = 0;
+  processing.forceHostMemoryPoolSize = GPUChainGenericTracking::HostMemoryBytes();
+  mReconstruction->SetSettings(&grp, nullptr, &processing);
+  if (mReconstruction->Init() != 0) {
+    throw std::runtime_error(std::format("GPU backend {}: device {} does not initialise", type, device));
+  }
+  // The backend library registered its runtime when O2's GPU backend, which
+  // links it, was loaded.
+  const auto factory = runtimeFactory(type);
+  if (factory == nullptr) {
+    throw std::runtime_error(std::format("GPU backend {}: no GenericTracking runtime (O2's GPUTracking{} does not link GTrkTracking{})", type, type, type));
+  }
+  mRuntime = factory(device);
+}
+
+DeviceContext::DeviceContext(o2::gpu::GPUReconstruction& reconstruction) : mReconstruction(&reconstruction)
+{
+  if (!reconstruction.IsGPU()) {
+    throw std::runtime_error("GenericTracking: the GPU reconstruction to borrow from runs on no GPU");
+  }
+  const auto& processing = reconstruction.GetProcessingSettings();
+  if (processing.memoryAllocationStrategy != o2::gpu::GPUMemoryResource::ALLOCATION_GLOBAL || processing.keepDisplayMemory || processing.disableMemoryReuse) {
+    throw std::runtime_error("GenericTracking: the GPU reconstruction's pool cannot lend its memory (it needs the global allocation, without keepDisplayMemory or disableMemoryReuse)");
+  }
+  const std::string type = o2::gpu::gpudatatypes::DEVICE_TYPE_NAMES[reconstruction.GetDeviceType()];
+  const auto factory = runtimeFactory(type);
+  if (factory == nullptr) {
+    throw std::runtime_error(std::format("GPU backend {}: no GenericTracking runtime (O2's GPUTracking{} does not link GTrkTracking{})", type, type, type));
+  }
+  mRuntime = factory(reconstruction.GetDeviceId());
+}
+
+DeviceContext::~DeviceContext() = default;
+
+DeviceContext::Borrowed::Borrowed(o2::gpu::GPUReconstruction& reconstruction, std::uint64_t tag) : mReconstruction(&reconstruction), mTag(tag)
+{
+  mReconstruction->PushNonPersistentMemory(mTag);
+  // All of the free memory, measured first: the allocation cannot fail. None
+  // if nothing is free (a zero-size one still moves the pool's end).
+  const std::size_t bytes = mReconstruction->DeviceMemoryGap();
+  if (bytes == 0U) {
+    return;
+  }
+  try {
+    mBlock = {.data = mReconstruction->AllocateDirectMemory(bytes, o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK), .bytes = bytes};
+  } catch (...) {
+    mReconstruction->PopNonPersistentMemory(o2::gpu::gpudatatypes::RecoStep::GenericTracking, mTag);
+    throw;
+  }
+}
+
+DeviceContext::Borrowed::~Borrowed() { mReconstruction->PopNonPersistentMemory(o2::gpu::gpudatatypes::RecoStep::GenericTracking, mTag); }
+
+std::unique_ptr<DeviceContext::Borrowed> DeviceContext::borrow(std::uint64_t tag) const
+{
+  if (mOwned != nullptr) {
+    throw std::logic_error("GenericTracking: borrow on a GPU reconstruction of its own");
+  }
+  return std::unique_ptr<Borrowed>{new Borrowed(*mReconstruction, tag)};
+}
+
+DeviceBlock DeviceContext::block(std::size_t index) const
+{
+  if (mChain == nullptr) {
+    throw std::logic_error("GenericTracking: no blocks on a borrowed GPU reconstruction");
+  }
+  const auto block = mChain->GetBlock(index);
+  return {.data = block.data, .bytes = block.bytes};
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/src/GPU/DeviceStream.cxx b/Detectors/GenericTracking/tracking/src/GPU/DeviceStream.cxx
new file mode 100644
index 0000000000000..b1fece7ec1235
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/src/GPU/DeviceStream.cxx
@@ -0,0 +1,55 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+
+#include <stdexcept>
+#include <utility>
+
+namespace o2::gtrk
+{
+
+DeviceStream DeviceRuntime::createStream() { return DeviceStream{*this, createStreamHandle()}; }
+
+void* DeviceRuntime::nativeStream(DeviceStream& stream) { return stream.mHandle; }
+
+DeviceStream::~DeviceStream() { reset(); }
+
+DeviceStream::DeviceStream(DeviceStream&& other) noexcept : mRuntime(std::exchange(other.mRuntime, nullptr)), mHandle(std::exchange(other.mHandle, nullptr)) {}
+
+DeviceStream& DeviceStream::operator=(DeviceStream&& other) noexcept
+{
+  if (this != &other) {
+    reset();
+    mRuntime = std::exchange(other.mRuntime, nullptr);
+    mHandle = std::exchange(other.mHandle, nullptr);
+  }
+  return *this;
+}
+
+void DeviceStream::reset() noexcept
+{
+  if (mHandle != nullptr) {
+    mRuntime->destroyStreamHandle(mHandle);
+  }
+  mRuntime = nullptr;
+  mHandle = nullptr;
+}
+
+void DeviceStream::synchronize()
+{
+  if (mRuntime == nullptr) {
+    throw std::logic_error("cannot synchronize an empty device stream");
+  }
+  mRuntime->synchronizeStreamHandle(mHandle);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/src/GPU/GPUChainGenericTracking.cxx b/Detectors/GenericTracking/tracking/src/GPU/GPUChainGenericTracking.cxx
new file mode 100644
index 0000000000000..0aee7e0f64373
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/src/GPU/GPUChainGenericTracking.cxx
@@ -0,0 +1,80 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUChainGenericTracking.cxx
+
+#include "GPUO2ExternalUser.h" // first of O2's GPU headers outside GPU/
+
+#include "GPUChainGenericTracking.h"
+
+#include "GPUConstantMem.h"
+#include "GPUReconstruction.h"
+
+#include <stdexcept>
+
+namespace o2::gtrk
+{
+
+using o2::gpu::GPUMemoryResource;
+using o2::gpu::GPUProcessor;
+
+GPUChainGenericTracking::GPUChainGenericTracking(o2::gpu::GPUReconstruction* rec) : GPUChain(rec) {}
+
+GPUChainGenericTracking::~GPUChainGenericTracking() = default;
+
+void* GPUChainGenericTracking::BlockProcessor::SetPointersBlock(void* mem) // NOLINT(readability-make-member-function-const): GPUReconstruction's SetPointers callback type
+{
+  return static_cast<char*>(mem) + mBytes;
+}
+
+size_t GPUChainGenericTracking::AddBlock(size_t bytes)
+{
+  auto& pair = mBlocks.emplace_back(std::make_unique<BlockPair>());
+  pair->host.mBytes = bytes;
+  pair->device.mBytes = bytes;
+  return mBlocks.size() - 1;
+}
+
+void GPUChainGenericTracking::RegisterPermanentMemoryAndProcessors()
+{
+  if (!mRec->IsGPU()) {
+    return;
+  }
+  for (auto& pair : mBlocks) {
+    pair->host.InitGPUProcessor(mRec, GPUProcessor::PROCESSOR_TYPE_SLAVE);
+    pair->device.InitGPUProcessor(mRec, GPUProcessor::PROCESSOR_TYPE_DEVICE, &pair->host);
+    // Device only. Custom: the per-event allocation pass, which knows a
+    // permanent resource as allocated by its host pointer, leaves it alone.
+    pair->resource = mRec->RegisterMemoryAllocation(&pair->host, &BlockProcessor::SetPointersBlock, GPUMemoryResource::MEMORY_GPU | GPUMemoryResource::MEMORY_PERMANENT | GPUMemoryResource::MEMORY_CUSTOM, "GenericTrackingBlock");
+  }
+}
+
+void GPUChainGenericTracking::MemorySize(size_t& gpuMem, size_t& pageLockedHostMem)
+{
+  gpuMem = 0;
+  for (const auto& pair : mBlocks) {
+    gpuMem += GPUProcessor::nextMultipleOf<o2::gpu::constants::GPU_MEMALIGN>(pair->host.mBytes);
+  }
+  pageLockedHostMem = HostMemoryBytes();
+}
+
+size_t GPUChainGenericTracking::HostMemoryBytes() { return GPUProcessor::nextMultipleOf<o2::gpu::constants::GPU_MEMALIGN>(sizeof(o2::gpu::GPUConstantMem)) + o2::gpu::constants::GPU_MEMALIGN; }
+
+GPUChainGenericTracking::Block GPUChainGenericTracking::GetBlock(size_t index) const
+{
+  if (index >= mBlocks.size() || mBlocks[index]->resource < 0) {
+    throw std::out_of_range("GenericTracking: no such device block");
+  }
+  const auto& resource = mRec->Res(mBlocks[index]->resource);
+  return {.data = resource.PtrDevice(), .bytes = mBlocks[index]->host.mBytes};
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/src/GPU/GPUChainGenericTracking.h b/Detectors/GenericTracking/tracking/src/GPU/GPUChainGenericTracking.h
new file mode 100644
index 0000000000000..cff48e577e7ce
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/src/GPU/GPUChainGenericTracking.h
@@ -0,0 +1,87 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUChainGenericTracking.h
+/// \brief The device memory of GenericTracking's device trackers.
+///
+/// A holder, as O2's GPUChainITS: the trackers run outside the chain, on
+/// their backend's runtime (RuntimeFactory.h). The chain sets aside one
+/// permanent block of the reconstruction's device pool per tracker, of the
+/// size its creator asks for before Init, and hands it out after Init.
+/// DeviceContext's alone: include GPUO2ExternalUser.h before it.
+
+#ifndef GTRK_TRACKING_GPU_GPUCHAINGENERICTRACKING_H_
+#define GTRK_TRACKING_GPU_GPUCHAINGENERICTRACKING_H_
+
+#include "GPUChain.h"
+#include "GPUProcessor.h"
+
+#include <cstddef>
+#include <memory>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+class GPUChainGenericTracking final : public o2::gpu::GPUChain
+{
+ public:
+  /// As GPUReconstruction::AddChain makes it.
+  explicit GPUChainGenericTracking(o2::gpu::GPUReconstruction* rec);
+
+  /// One tracker's block: device memory of the pool, permanent.
+  struct Block {
+    void* data = nullptr;
+    size_t bytes = 0;
+  };
+
+  GPUChainGenericTracking(const GPUChainGenericTracking&) = delete;
+  GPUChainGenericTracking(GPUChainGenericTracking&&) = delete;
+  GPUChainGenericTracking& operator=(const GPUChainGenericTracking&) = delete;
+  GPUChainGenericTracking& operator=(GPUChainGenericTracking&&) = delete;
+  ~GPUChainGenericTracking() final;
+  int32_t Init() final { return 0; }
+  int32_t PrepareEvent() final { return 0; }
+  int32_t Finalize() final { return 0; }
+  int32_t RunChain() final { return 0; }
+
+  void RegisterPermanentMemoryAndProcessors() final;
+  void RegisterGPUProcessors() final {}
+  /// The blocks on the device; on the host the processors' shadow, which the
+  /// device reconstruction keeps in its pinned pool.
+  void MemorySize(size_t& gpuMem, size_t& pageLockedHostMem) final;
+  /// What MemorySize reports on the host: the pinned pool a reconstruction
+  /// holding only this chain needs (forceHostMemoryPoolSize).
+  static size_t HostMemoryBytes();
+
+  /// A block of \a bytes, before Init; its index for GetBlock.
+  size_t AddBlock(size_t bytes);
+  /// Block \a index, after Init.
+  [[nodiscard]] Block GetBlock(size_t index) const;
+
+ private:
+  /// A block's processor: the host-side one registers the resource, its
+  /// device mirror places it (a device allocation needs the linked pair).
+  struct BlockProcessor : public o2::gpu::GPUProcessor {
+    size_t mBytes = 0;
+    void* SetPointersBlock(void* mem);
+  };
+  struct BlockPair {
+    BlockProcessor host;
+    BlockProcessor device;
+    int16_t resource = -1;
+  };
+  std::vector<std::unique_ptr<BlockPair>> mBlocks;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TRACKING_GPU_GPUCHAINGENERICTRACKING_H_
diff --git a/Detectors/GenericTracking/tracking/src/GPU/MaterialPort.cxx b/Detectors/GenericTracking/tracking/src/GPU/MaterialPort.cxx
new file mode 100644
index 0000000000000..13d7bce609fa9
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/src/GPU/MaterialPort.cxx
@@ -0,0 +1,25 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Tracking/GPU/MaterialPort.h"
+
+#include "DetectorsBase/MatLayerCylSet.h"
+
+#include <cstddef>
+
+namespace o2::gtrk
+{
+
+std::size_t FlatObjectPort<o2::base::MatLayerCylSet>::bufferBytes(const o2::base::MatLayerCylSet& source) { return flatObjectBufferBytes(source); }
+
+void FlatObjectPort<o2::base::MatLayerCylSet>::image(const o2::base::MatLayerCylSet& source, char* futureBuffer, FlatObjectImage& image) { flatObjectImage(source, futureBuffer, image); }
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/src/GPU/RuntimeFactory.cxx b/Detectors/GenericTracking/tracking/src/GPU/RuntimeFactory.cxx
new file mode 100644
index 0000000000000..f035b165a7a4c
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/src/GPU/RuntimeFactory.cxx
@@ -0,0 +1,57 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Tracking/GPU/RuntimeFactory.h"
+
+#include <mutex>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+struct Registry {
+  std::mutex mutex;
+  std::vector<std::pair<std::string, RuntimeFactory>> factories;
+};
+
+Registry& registry()
+{
+  static Registry instance;
+  return instance;
+}
+
+} // namespace
+
+void registerRuntimeFactory(std::string_view backend, RuntimeFactory factory)
+{
+  auto& known = registry();
+  const std::lock_guard lock{known.mutex};
+  known.factories.emplace_back(std::string{backend}, factory);
+}
+
+RuntimeFactory runtimeFactory(std::string_view backend)
+{
+  auto& known = registry();
+  const std::lock_guard lock{known.mutex};
+  for (const auto& [name, factory] : known.factories) {
+    if (name == backend) {
+      return factory;
+    }
+  }
+  return nullptr;
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/src/Parallel.cxx b/Detectors/GenericTracking/tracking/src/Parallel.cxx
new file mode 100644
index 0000000000000..baf1dd5c059df
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/src/Parallel.cxx
@@ -0,0 +1,178 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Tracking/Parallel.h"
+
+#include "GenericTracking/Tracking/Profile.h"
+
+#include <oneapi/tbb/parallel_for.h>
+#include <oneapi/tbb/parallel_sort.h>
+#include <oneapi/tbb/task_arena.h>
+#include <oneapi/tbb/task_scheduler_observer.h>
+
+#if defined(__linux__)
+#include <pthread.h>
+#include <sched.h>
+#endif
+
+#include <algorithm>
+#include <atomic>
+#include <cstddef>
+#include <memory>
+#include <vector>
+
+namespace o2::gtrk::detail
+{
+
+namespace
+{
+
+#if defined(__linux__)
+/// One thread per CPU: every thread entering the arena is bound
+/// to the CPU of its arena slot, slot i to the i-th CPU of the process's
+/// affinity mask, so no two of the arena's threads share a CPU. Left to the
+/// kernel, a thread woken for a parallel loop is placed on a busy CPU of its
+/// cache domain often enough to stall a chunk for tens of milliseconds. Only
+/// when the arena has as many threads as the mask has CPUs,
+/// i.e. the job owns its CPUs; with a wider mask other jobs share them, and
+/// fixed CPUs would collide with theirs. A thread that is not the arena's
+/// worker -- the caller of `parallelFor` -- gets its own mask back when it
+/// leaves; a worker stays bound until it enters again, maybe on another slot.
+class OneThreadPerCpu final : public tbb::task_scheduler_observer
+{
+ public:
+  OneThreadPerCpu(tbb::task_arena& arena, std::vector<int> cpus) : tbb::task_scheduler_observer{arena}, mCpus{std::move(cpus)} { observe(true); }
+  ~OneThreadPerCpu() override { observe(false); }
+  OneThreadPerCpu(const OneThreadPerCpu&) = delete;
+  OneThreadPerCpu& operator=(const OneThreadPerCpu&) = delete;
+  OneThreadPerCpu(OneThreadPerCpu&&) = delete;
+  OneThreadPerCpu& operator=(OneThreadPerCpu&&) = delete;
+
+  /// The CPUs of the calling thread's affinity mask, in order.
+  [[nodiscard]] static std::vector<int> allowedCpus()
+  {
+    cpu_set_t mask;
+    CPU_ZERO(&mask);
+    std::vector<int> cpus;
+    if (sched_getaffinity(0, sizeof(mask), &mask) == 0) {
+      for (int cpu = 0; cpu < CPU_SETSIZE; ++cpu) {
+        if (CPU_ISSET(static_cast<std::size_t>(cpu), &mask)) {
+          cpus.push_back(cpu);
+        }
+      }
+    }
+    return cpus;
+  }
+
+  void on_scheduler_entry(bool worker) override
+  {
+    const int slot = tbb::this_task_arena::current_thread_index();
+    if (slot < 0 || static_cast<std::size_t>(slot) >= mCpus.size()) {
+      return;
+    }
+    if (!worker && tCaller.depth++ == 0) {
+      tCaller.saved = pthread_getaffinity_np(pthread_self(), sizeof(tCaller.mask), &tCaller.mask) == 0;
+    }
+    cpu_set_t one;
+    CPU_ZERO(&one);
+    CPU_SET(static_cast<std::size_t>(mCpus[static_cast<std::size_t>(slot)]), &one);
+    pthread_setaffinity_np(pthread_self(), sizeof(one), &one);
+  }
+
+  void on_scheduler_exit(bool worker) override
+  {
+    if (worker || tCaller.depth == 0) {
+      return;
+    }
+    if (--tCaller.depth == 0 && tCaller.saved) {
+      pthread_setaffinity_np(pthread_self(), sizeof(tCaller.mask), &tCaller.mask);
+    }
+  }
+
+ private:
+  /// A calling thread's mask before it entered the first of its arenas.
+  struct Caller {
+    int depth = 0;
+    bool saved = false;
+    cpu_set_t mask{};
+  };
+  static thread_local Caller tCaller;
+
+  std::vector<int> mCpus;
+};
+
+thread_local OneThreadPerCpu::Caller OneThreadPerCpu::tCaller;
+#endif
+
+} // namespace
+
+struct TaskArena::Impl {
+  explicit Impl(int maxConcurrency) : arena{maxConcurrency > 0 ? maxConcurrency : tbb::task_arena::automatic}
+  {
+#if defined(__linux__)
+    auto cpus = OneThreadPerCpu::allowedCpus();
+    arena.initialize();
+    if (!cpus.empty() && static_cast<std::size_t>(arena.max_concurrency()) == cpus.size()) {
+      pinning = std::make_unique<OneThreadPerCpu>(arena, std::move(cpus));
+    }
+#endif
+  }
+
+  tbb::task_arena arena;
+#if defined(__linux__)
+  std::unique_ptr<OneThreadPerCpu> pinning; ///< with as many threads as CPUs
+#endif
+};
+
+TaskArena::TaskArena(int maxConcurrency) : mImpl{std::make_unique<Impl>(maxConcurrency)} {}
+
+TaskArena::~TaskArena() = default;
+
+int TaskArena::maxConcurrency() const noexcept { return mImpl->arena.max_concurrency(); }
+
+void parallelSortIndices(TaskArena& arena, size_t count, void* context, ParallelSortLess less, uint32_t* first)
+{
+  const auto begin = profile::now();
+  arena.mImpl->arena.execute([=] { tbb::parallel_sort(first, first + count, [context, less](uint32_t lhs, uint32_t rhs) { return less(context, lhs, rhs); }); });
+  // Parallel, but not in chunks a profile can see.
+  profile::addOpaque(static_cast<double>(profile::now() - begin) * 1.e-9);
+}
+
+void parallelFor(TaskArena& arena, size_t begin, size_t end, size_t grainSize, void* context, ParallelForBody body)
+{
+  if (begin >= end) {
+    return;
+  }
+  // One task per arena slot, each claiming the next grain of [begin, end) from one counter until
+  // none is left. The calling thread runs one of the tasks, so it works to the end. Not
+  // tbb::parallel_for over a blocked_range: there the calling thread, an external waiter, stops
+  // taking chunks after its first failed steal and sleeps.
+  arena.mImpl->arena.execute([=, &arena] {
+    std::atomic<size_t> next{begin};
+    const int slots = arena.mImpl->arena.max_concurrency();
+    tbb::parallel_for(
+      0, slots, 1,
+      [&](int /*slot*/) {
+        for (;;) {
+          const size_t first = next.fetch_add(grainSize, std::memory_order_relaxed);
+          if (first >= end) {
+            return;
+          }
+          body(context, first, std::min(first + grainSize, end));
+        }
+      },
+      tbb::simple_partitioner{});
+  });
+}
+
+int currentArenaThreadIndex() noexcept { return tbb::this_task_arena::current_thread_index(); }
+
+} // namespace o2::gtrk::detail
diff --git a/Detectors/GenericTracking/tracking/src/Profile.cxx b/Detectors/GenericTracking/tracking/src/Profile.cxx
new file mode 100644
index 0000000000000..4f22f27ecc4eb
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/src/Profile.cxx
@@ -0,0 +1,437 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Tracking/Profile.h"
+
+#include "GenericTracking/Base/BoundedAllocator.h"
+
+#if defined(__linux__)
+#include <linux/perf_event.h>
+#include <sys/syscall.h>
+#endif
+#include <sys/resource.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <bit>
+#include <chrono>
+#include <cmath>
+#include <filesystem>
+#include <format>
+#include <fstream>
+#include <limits>
+#include <ostream>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::profile
+{
+
+namespace
+{
+
+using enum Phase;
+
+constexpr std::array<PhaseInfo, kPhaseCount> kInfo{{
+  {.name = "run"},
+  {.name = "plan"},
+  {.name = "begin timeframe", .parent = kRun},
+  {.name = "iteration", .parent = kRun},
+  {.name = "slices", .parent = kIteration},
+  {.name = "tracklets", .parent = kSlices},
+  {.name = "tracklet setup", .parent = kTracklets},
+  {.name = "tracklet reset", .parent = kTracklets},
+  {.name = "tracklet generate", .parent = kTracklets},
+  {.name = "tracklet scan", .parent = kTracklets},
+  {.name = "tracklet place", .parent = kTracklets},
+  {.name = "tracklet sort", .parent = kTracklets},
+  {.name = "triplets", .parent = kSlices},
+  {.name = "permutation", .parent = kTriplets},
+  {.name = "triplet setup", .parent = kTriplets},
+  {.name = "triplet reset", .parent = kTriplets},
+  {.name = "triplet generate", .parent = kTriplets},
+  {.name = "triplet scan", .parent = kTriplets},
+  {.name = "triplet place", .parent = kTriplets},
+  {.name = "neighbours", .parent = kSlices},
+  {.name = "end index", .parent = kNeighbours},
+  {.name = "neighbour setup", .parent = kNeighbours},
+  {.name = "neighbour reset", .parent = kNeighbours},
+  {.name = "neighbour generate", .parent = kNeighbours},
+  {.name = "neighbour scan", .parent = kNeighbours},
+  {.name = "neighbour place", .parent = kNeighbours},
+  {.name = "roads", .parent = kIteration},
+  {.name = "road count", .parent = kRoads},
+  {.name = "road fills", .parent = kNeighbourSetup},
+  {.name = "road starts", .parent = kRoadCount},
+  {.name = "road fit setup", .parent = kRoads},
+  {.name = "road fit reset", .parent = kRoads},
+  {.name = "road fit generate", .parent = kRoads},
+  {.name = "road fit scan", .parent = kRoads},
+  {.name = "road fit place", .parent = kRoads},
+  {.name = "selection append", .parent = kRoads},
+  {.name = "selection", .parent = kIteration},
+  {.name = "selection keys", .parent = kSelection},
+  {.name = "selection order", .parent = kSelection},
+  {.name = "selection deduplicate", .parent = kSelection},
+  {.name = "selection rank", .parent = kSelection},
+  {.name = "selection fill", .parent = kSelection},
+  {.name = "selection slots", .parent = kSelection},
+  {.name = "selection rounds", .parent = kSelection},
+  {.name = "selection compact", .parent = kSelection},
+  {.name = "refit", .parent = kIteration},
+  {.name = "follow earlier", .parent = kIteration},
+  {.name = "follow", .parent = kIteration},
+  {.name = "follow propose", .parent = kFollow},
+  {.name = "follow resolve", .parent = kFollow},
+  {.name = "follow refit", .parent = kFollow},
+  {.name = "follow mark", .parent = kFollow},
+  {.name = "observers", .parent = kIteration},
+  {.name = "tracklet paths", .parent = kTriplets},
+  {.name = "triplet paths", .parent = kTriplets},
+  {.name = "length cut", .parent = kIteration},
+}};
+
+/// Every parent precedes its children, so one pass in enum order is a
+/// depth-first walk once children are grouped under their parent.
+constexpr bool parentsFirst()
+{
+  for (std::size_t phase = 0; phase < kPhaseCount; ++phase) {
+    if (kInfo[phase].parent != kNone && static_cast<std::size_t>(kInfo[phase].parent) >= phase) {
+      return false;
+    }
+  }
+  return true;
+}
+static_assert(parentsFirst());
+
+// The profiled thread's context: what a zone deep inside a stage fills without
+// every call in between carrying a profile.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+thread_local Context* tCurrent = nullptr;
+
+// The memory controllers' counters, once `countDram` opened them.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+std::vector<int> gDramCounters;
+
+[[nodiscard]] std::uint64_t dramBytes()
+{
+  std::uint64_t commands = 0U;
+  for (const int counter : gDramCounters) {
+    std::uint64_t value = 0U;
+    if (read(counter, &value, sizeof(value)) == static_cast<ssize_t>(sizeof(value))) {
+      commands += value;
+    }
+  }
+  return 64U * commands;
+}
+
+[[nodiscard]] std::uint64_t minorFaults()
+{
+  rusage usage{};
+  getrusage(RUSAGE_SELF, &usage);
+  // glibc declares the field inside an anonymous union.
+  return static_cast<std::uint64_t>(usage.ru_minflt); // NOLINT(cppcoreguidelines-pro-type-union-access)
+}
+
+[[nodiscard]] std::size_t chunkBin(std::int64_t nanoseconds)
+{
+  const auto value = static_cast<std::uint64_t>(std::max<std::int64_t>(nanoseconds, 1));
+  return std::min<std::size_t>(static_cast<std::size_t>(std::bit_width(value)) - 1U, kChunkBins - 1U);
+}
+
+[[nodiscard]] double seconds(std::int64_t nanoseconds) { return static_cast<double>(nanoseconds) * 1.e-9; }
+
+} // namespace
+
+const PhaseInfo& info(Phase phase)
+{
+  static const PhaseInfo kNoPhase{.name = "none"};
+  return phase < kCount ? kInfo[static_cast<std::size_t>(phase)] : kNoPhase;
+}
+
+PhaseStats& PhaseStats::operator+=(const PhaseStats& other)
+{
+  seconds += other.seconds;
+  calls += other.calls;
+  elements += other.elements;
+  outputs += other.outputs;
+  regions += other.regions;
+  chunks += other.chunks;
+  regionSeconds += other.regionSeconds;
+  capacitySeconds += other.capacitySeconds;
+  busySeconds += other.busySeconds;
+  maxSlotSeconds += other.maxSlotSeconds;
+  tailSeconds += other.tailSeconds;
+  maxChunkSeconds = std::max(maxChunkSeconds, other.maxChunkSeconds);
+  for (std::size_t bin = 0; bin < kChunkBins; ++bin) {
+    chunkHistogram[bin] += other.chunkHistogram[bin];
+  }
+  opaqueSeconds += other.opaqueSeconds;
+  minorFaults += other.minorFaults;
+  dramBytes += other.dramBytes;
+  allocations += other.allocations;
+  allocatedBytes += other.allocatedBytes;
+  peakBytes = std::max(peakBytes, other.peakBytes);
+  peakGrowthBytes = std::max(peakGrowthBytes, other.peakGrowthBytes);
+  return *this;
+}
+
+Profile& Profile::operator+=(const Profile& other)
+{
+  for (std::size_t phase = 0; phase < kPhaseCount; ++phase) {
+    phases[phase] += other.phases[phase];
+  }
+  return *this;
+}
+
+bool countDram()
+{
+  if (!gDramCounters.empty()) {
+    return true;
+  }
+  // One PMU per memory controller; its event 0x0a counts CAS commands, read
+  // (mask 1) and write (mask 2) ones apart. System-wide, on the CPU the PMU names.
+  for (int umc = 0;; ++umc) {
+    const std::filesystem::path pmu{std::format("/sys/bus/event_source/devices/amd_umc_{}", umc)};
+    if (!std::filesystem::exists(pmu)) {
+      break;
+    }
+    std::uint32_t type = 0U;
+    int cpu = 0;
+    std::ifstream{pmu / "type"} >> type;
+    std::ifstream{pmu / "cpumask"} >> cpu;
+#if defined(__linux__)
+    for (const std::uint64_t mask : {1U, 2U}) {
+      perf_event_attr attr{};
+      attr.size = sizeof(attr);
+      attr.type = type;
+      attr.config = 0x0aU | (mask << 8U);
+      const auto counter = static_cast<int>(syscall(SYS_perf_event_open, &attr, -1, cpu, -1, 0UL)); // NOLINT(cppcoreguidelines-pro-type-vararg): perf_event_open has no libc wrapper
+      if (counter < 0) {
+        for (const int open : gDramCounters) {
+          close(open);
+        }
+        gDramCounters.clear();
+        return false;
+      }
+      gDramCounters.push_back(counter);
+    }
+#else
+    // perf_event_open is Linux-only: no DRAM counters elsewhere.
+    static_cast<void>(type);
+    static_cast<void>(cpu);
+    return false;
+#endif
+  }
+  return !gDramCounters.empty();
+}
+
+std::int64_t now() noexcept { return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count(); }
+
+Trace::Trace(std::size_t slots) : mSlots(slots) {}
+
+void Trace::chunk(int slot, const Event& event)
+{
+  if (std::cmp_greater_equal(slot, 0) && std::cmp_less(slot, mSlots.size())) {
+    mSlots[static_cast<std::size_t>(slot)].push_back(event);
+  }
+}
+
+void Trace::clear()
+{
+  mZones.clear();
+  for (auto& slot : mSlots) {
+    slot.clear();
+  }
+}
+
+void Trace::write(std::ostream& out) const
+{
+  std::int64_t origin = std::numeric_limits<std::int64_t>::max();
+  for (const auto& event : mZones) {
+    origin = std::min(origin, event.begin);
+  }
+  for (const auto& slot : mSlots) {
+    for (const auto& event : slot) {
+      origin = std::min(origin, event.begin);
+    }
+  }
+  // Chrome's format is microseconds; tid 0 is the calling thread's zones,
+  // tid s + 1 arena slot s.
+  bool first = true;
+  const auto emit = [&](const Event& event, std::size_t tid, std::string_view category) {
+    out << (first ? "\n" : ",\n") << std::format(R"({{"name":"{}","cat":"{}","ph":"X","pid":1,"tid":{},"ts":{:.3f},"dur":{:.3f}}})", info(event.phase).name, category, tid, static_cast<double>(event.begin - origin) * 1.e-3, static_cast<double>(event.end - event.begin) * 1.e-3);
+    first = false;
+  };
+  const auto name = [&](std::size_t tid, std::string_view label) {
+    out << (first ? "\n" : ",\n") << std::format(R"({{"name":"thread_name","ph":"M","pid":1,"tid":{},"args":{{"name":"{}"}}}})", tid, label);
+    first = false;
+  };
+  out << R"({"displayTimeUnit":"ms","traceEvents":[)";
+  name(0U, "tracker");
+  for (const auto& event : mZones) {
+    emit(event, 0U, "zone");
+  }
+  for (std::size_t slot = 0; slot < mSlots.size(); ++slot) {
+    if (mSlots[slot].empty()) {
+      continue;
+    }
+    name(slot + 1U, std::format("slot {}", slot));
+    for (const auto& event : mSlots[slot]) {
+      emit(event, slot + 1U, "chunk");
+    }
+  }
+  out << "\n]}\n";
+}
+
+Context* current() noexcept { return tCurrent; }
+
+Activation::Activation(Profile& profile, BoundedMemoryResource* pool, Trace* trace)
+  : mContext{.profile = &profile, .pool = pool, .trace = trace},
+    mOuter{tCurrent}
+{
+  tCurrent = &mContext;
+}
+
+Activation::~Activation() { tCurrent = mOuter; }
+
+Zone::Zone(Phase phase)
+{
+  if (phase >= kCount || tCurrent == nullptr) {
+    return;
+  }
+  mContext = tCurrent;
+  mPhase = phase;
+  mOuter = mContext->phase;
+  mContext->phase = phase;
+  mFaults = minorFaults();
+  mDram = dramBytes();
+  if (mContext->pool != nullptr) {
+    mAllocations = mContext->pool->getAllocationCount();
+    mAllocatedBytes = mContext->pool->getAllocatedBytes();
+    mOuterPeak = mContext->pool->resetPeakMemory();
+    mEntryBytes = mContext->pool->getPeakMemory();
+  }
+  mBegin = now();
+}
+
+Zone::~Zone()
+{
+  if (mContext == nullptr) {
+    return;
+  }
+  const auto end = now();
+  auto& stats = (*mContext->profile)[mPhase];
+  stats.seconds += seconds(end - mBegin);
+  ++stats.calls;
+  stats.minorFaults += minorFaults() - mFaults;
+  stats.dramBytes += dramBytes() - mDram;
+  if (mContext->pool != nullptr) {
+    stats.allocations += mContext->pool->getAllocationCount() - mAllocations;
+    stats.allocatedBytes += mContext->pool->getAllocatedBytes() - mAllocatedBytes;
+    // The window's peak, then the outer window's back: the larger of the two.
+    const std::uint64_t peak = mContext->pool->getPeakMemory();
+    stats.peakBytes = std::max(stats.peakBytes, peak);
+    stats.peakGrowthBytes = std::max(stats.peakGrowthBytes, peak - std::min(peak, mEntryBytes));
+    mContext->pool->raisePeakMemory(mOuterPeak);
+  }
+  if (mContext->trace != nullptr) {
+    mContext->trace->zone({.begin = mBegin, .end = end, .phase = mPhase});
+  }
+  mContext->phase = mOuter;
+}
+
+void count(Phase phase, std::uint64_t elements, std::uint64_t outputs)
+{
+  if (phase >= kCount || tCurrent == nullptr) {
+    return;
+  }
+  auto& stats = (*tCurrent->profile)[phase];
+  stats.elements += elements;
+  stats.outputs += outputs;
+}
+
+void addOpaque(double seconds)
+{
+  if (tCurrent == nullptr || tCurrent->phase >= kCount) {
+    return;
+  }
+  (*tCurrent->profile)[tCurrent->phase].opaqueSeconds += seconds;
+}
+
+void RegionSlots::resize(int slots) { mSlots.assign(static_cast<std::size_t>(std::max(slots, 0)), Slot{}); }
+
+Region::Region(RegionSlots& slots, int concurrency, std::uint64_t elements)
+{
+  if (tCurrent == nullptr || tCurrent->phase >= kCount) {
+    return;
+  }
+  mContext = tCurrent;
+  mTrace = mContext->trace;
+  mPhase = mContext->phase;
+  mSlots = slots.data();
+  mSlotCount = slots.size();
+  mConcurrency = std::max(concurrency, 1);
+  mElements = elements;
+  mBegin = now();
+}
+
+void Region::end(int slot, std::int64_t begin) const noexcept
+{
+  if (mContext == nullptr || std::cmp_less(slot, 0) || std::cmp_greater_equal(slot, mSlotCount)) {
+    return;
+  }
+  const auto end = now();
+  const auto duration = end - begin;
+  auto& record = mSlots[static_cast<std::size_t>(slot)];
+  record.busy += duration;
+  record.lastEnd = end;
+  record.maxChunk = std::max(record.maxChunk, duration);
+  ++record.chunks;
+  ++record.histogram[chunkBin(duration)];
+  if (mTrace != nullptr) {
+    mTrace->chunk(slot, {.begin = begin, .end = end, .phase = mPhase});
+  }
+}
+
+Region::~Region()
+{
+  if (mContext == nullptr) {
+    return;
+  }
+  const auto end = now();
+  auto& stats = (*mContext->profile)[mPhase];
+  const double wall = seconds(end - mBegin);
+  ++stats.regions;
+  stats.elements += mElements;
+  stats.regionSeconds += wall;
+  stats.capacitySeconds += wall * mConcurrency;
+  std::int64_t busiest = 0;
+  for (std::size_t slot = 0; slot < mSlotCount; ++slot) {
+    auto& record = mSlots[slot];
+    if (record.chunks == 0U) {
+      continue;
+    }
+    stats.chunks += record.chunks;
+    stats.busySeconds += seconds(record.busy);
+    stats.tailSeconds += seconds(end - record.lastEnd);
+    stats.maxChunkSeconds = std::max(stats.maxChunkSeconds, seconds(record.maxChunk));
+    for (std::size_t bin = 0; bin < kChunkBins; ++bin) {
+      stats.chunkHistogram[bin] += record.histogram[bin];
+    }
+    busiest = std::max(busiest, record.busy);
+    record = RegionSlots::Slot{};
+  }
+  stats.maxSlotSeconds += seconds(busiest);
+}
+
+} // namespace o2::gtrk::profile
diff --git a/Detectors/GenericTracking/tracking/src/WorkCounters.cxx b/Detectors/GenericTracking/tracking/src/WorkCounters.cxx
new file mode 100644
index 0000000000000..44ceda13777a4
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/src/WorkCounters.cxx
@@ -0,0 +1,115 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Tracking/WorkCounters.h"
+
+#ifdef GTRK_WORK_COUNTERS
+
+#include <algorithm>
+#include <mutex>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+/// Every live thread's block, and what the threads that ended had counted.
+struct ThreadBlock;
+struct Registry {
+  std::mutex mutex;
+  std::vector<const ThreadBlock*> live;
+  WorkCounts ended{};
+  LinkWorkCounts endedLinks;
+};
+
+/// Never destroyed: a worker thread may end, and add its counts, after the
+/// statics are gone.
+Registry& registry()
+{
+  static auto* instance = new Registry; // NOLINT(cppcoreguidelines-owning-memory)
+  return *instance;
+}
+
+void add(WorkCounts& sum, const WorkCounts& counts)
+{
+  for (std::size_t counter = 0; counter < kWorkCounterCount; ++counter) {
+    sum[counter] += counts[counter];
+  }
+}
+
+void add(LinkWorkCounts& sum, const LinkWorkCounts& counts)
+{
+  if (sum.size() < counts.size()) {
+    sum.resize(counts.size());
+  }
+  for (std::size_t link = 0; link < counts.size(); ++link) {
+    for (std::size_t counter = 0; counter < kLinkCounterCount; ++counter) {
+      sum[link][counter] += counts[link][counter];
+    }
+  }
+}
+
+/// One thread's block, in the registry for as long as the thread lives.
+struct ThreadBlock {
+  WorkCounts counts{};
+  LinkWorkCounts links;
+
+  ThreadBlock()
+  {
+    const std::lock_guard lock{registry().mutex};
+    registry().live.push_back(this);
+  }
+  ThreadBlock(const ThreadBlock&) = delete;
+  ThreadBlock& operator=(const ThreadBlock&) = delete;
+  ThreadBlock(ThreadBlock&&) = delete;
+  ThreadBlock& operator=(ThreadBlock&&) = delete;
+  ~ThreadBlock()
+  {
+    const std::lock_guard lock{registry().mutex};
+    add(registry().ended, counts);
+    add(registry().endedLinks, links);
+    std::erase(registry().live, this);
+  }
+};
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+thread_local ThreadBlock tBlock;
+
+} // namespace
+
+WorkCounts& detail::threadWorkCounts() { return tBlock.counts; }
+LinkWorkCounts& detail::threadLinkWorkCounts() { return tBlock.links; }
+
+WorkCounts workCounts()
+{
+  const std::lock_guard lock{registry().mutex};
+  WorkCounts sum = registry().ended;
+  for (const auto* block : registry().live) {
+    add(sum, block->counts);
+  }
+  return sum;
+}
+
+LinkWorkCounts linkWorkCounts()
+{
+  const std::lock_guard lock{registry().mutex};
+  LinkWorkCounts sum = registry().endedLinks;
+  for (const auto* block : registry().live) {
+    add(sum, block->links);
+  }
+  return sum;
+}
+
+} // namespace o2::gtrk
+
+#endif
diff --git a/Detectors/GenericTracking/tracking/test/AnalyticLayout.h b/Detectors/GenericTracking/tracking/test/AnalyticLayout.h
new file mode 100644
index 0000000000000..872e931edf272
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/AnalyticLayout.h
@@ -0,0 +1,202 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file AnalyticLayout.h
+/// \brief The toy layouts' geometry: staves and disc rings described by a few
+///        numbers, their sensors computed here and handed to Geometry as an
+///        experiment's are.
+///
+/// A toy declares its analytic layers as `barrelSpecs` and `discSpecs`, and
+/// derives the layout's `barrelLayers`/`discLayers` from them with
+/// `placedLayers`. Chip IDs run barrel layers inner to outer, stave by
+/// increasing azimuth, module by increasing z; then disc layers by increasing
+/// z, ring inner to outer, module by increasing azimuth.
+
+#ifndef GTRK_TEST_ANALYTICLAYOUT_H_
+#define GTRK_TEST_ANALYTICLAYOUT_H_
+
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Base/Sensor.h"
+
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <numbers>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+/// A ring of sensors at one radius within a disc. The sensors of a ring
+/// overlap in azimuth, so alternate modules are displaced by +-gap/2 along the
+/// beam, front and back; nModules is even for that alternation to close.
+struct RingSpec {
+  double r;       ///< radius of the sensor centres
+  int nModules;   ///< sensors around the ring
+  double phi0;    ///< azimuth of the first sensor
+  double zOffset; ///< displacement of the whole ring from the disc's own z
+  double gap;     ///< front-to-back separation of alternate modules
+};
+
+/// A barrel layer: nStaves staves around the beam, each carrying
+/// nModulesPerStave sensors along it.
+struct BarrelLayerSpec {
+  double r;             ///< radius of the stave centres
+  int nStaves;          ///< staves in azimuth
+  int nModulesPerStave; ///< sensors along one stave
+  double phi0;          ///< azimuth of the first stave
+  double tilt;          ///< stave rotation about its own long axis
+  double moduleGap;     ///< gap between consecutive sensors along a stave
+  SensorSpec sensor;
+
+  [[nodiscard]] constexpr int nSensors() const { return nStaves * nModulesPerStave; }
+
+  /// Half the length spanned by the sensors of one stave.
+  [[nodiscard]] constexpr double halfLength() const { return 0.5 * (static_cast<double>(nModulesPerStave) * (2. * sensor.halfY + moduleGap) - moduleGap); }
+};
+
+inline constexpr int kMaxRings = 5;
+
+/// A disc layer: one or more concentric rings of one sensor shape at a fixed z.
+struct DiscLayerSpec {
+  double z; ///< position along the beam
+  int nRings;
+  RingSpec rings[kMaxRings];
+  SensorSpec sensor;
+
+  [[nodiscard]] constexpr int nSensors() const
+  {
+    int n = 0;
+    for (int i = 0; i < nRings; ++i) {
+      n += rings[i].nModules;
+    }
+    return n;
+  }
+};
+
+/// The layout's layers of \a specs: each one's sensor count and shape.
+template <typename Spec, std::size_t N>
+[[nodiscard]] constexpr std::array<PlacedLayerSpec, N> placedLayers(const std::array<Spec, N>& specs)
+{
+  std::array<PlacedLayerSpec, N> layers{};
+  for (std::size_t i = 0; i < N; ++i) {
+    layers[i] = {.sensorCount = specs[i].nSensors(), .sensor = specs[i].sensor};
+  }
+  return layers;
+}
+
+template <typename Toy>
+concept AnalyticToy = requires {
+  Toy::barrelSpecs;
+  Toy::discSpecs;
+};
+
+/// First chip ID of a layer.
+template <AnalyticToy Toy>
+[[nodiscard]] constexpr SensorID firstSensorOfLayer(LayerID layer)
+{
+  SensorID first = 0;
+  LayerID seen = 0;
+  for (const auto& spec : Toy::barrelSpecs) {
+    if (seen++ == layer) {
+      return first;
+    }
+    first += static_cast<SensorID>(spec.nSensors());
+  }
+  for (const auto& spec : Toy::discSpecs) {
+    if (seen++ == layer) {
+      return first;
+    }
+    first += static_cast<SensorID>(spec.nSensors());
+  }
+  return first;
+}
+
+/// The toy's sensors, indexed by chip ID.
+///
+/// A barrel sensor's local frame has y along the beam and z along the outward
+/// normal, turned by the stave tilt:
+///   z_global = ( cos a,  sin a, 0),  a = phi + tilt
+///   y_global = (     0,      0, 1)
+///   x_global = y x z = (-sin a, cos a, 0)
+/// A disc sensor faces along the beam, its long axis pointing outwards:
+///   z_global = (    0,     0, 1)
+///   y_global = (cos p, sin p, 0)
+///   x_global = y x z = (sin p, -cos p, 0)
+template <AnalyticToy Toy>
+[[nodiscard]] std::vector<Sensor> placeSensors()
+{
+  std::vector<Sensor> sensors;
+  sensors.reserve(static_cast<std::size_t>(Toy::nSensors));
+  LayerID layer = 0;
+  for (const auto& spec : Toy::barrelSpecs) {
+    const double dPhi = 2. * std::numbers::pi / static_cast<double>(spec.nStaves);
+    const double pitchZ = 2. * spec.sensor.halfY + spec.moduleGap;
+    const double z0 = -0.5 * static_cast<double>(spec.nModulesPerStave - 1) * pitchZ;
+    for (int iStave = 0; iStave < spec.nStaves; ++iStave) {
+      const double phi = spec.phi0 + dPhi * static_cast<double>(iStave);
+      const double cosA = std::cos(phi + spec.tilt);
+      const double sinA = std::sin(phi + spec.tilt);
+      for (int iMod = 0; iMod < spec.nModulesPerStave; ++iMod) {
+        sensors.push_back({
+          .rot = {-sinA, 0., cosA, cosA, 0., sinA, 0., 1., 0.},
+          .trans = {spec.r * std::cos(phi), spec.r * std::sin(phi), z0 + pitchZ * static_cast<double>(iMod)},
+          .layer = layer,
+        });
+      }
+    }
+    ++layer;
+  }
+  for (const auto& spec : Toy::discSpecs) {
+    for (int iRing = 0; iRing < spec.nRings; ++iRing) {
+      const RingSpec& ring = spec.rings[iRing];
+      const double dPhi = 2. * std::numbers::pi / static_cast<double>(ring.nModules);
+      for (int iMod = 0; iMod < ring.nModules; ++iMod) {
+        const double phi = ring.phi0 + dPhi * static_cast<double>(iMod);
+        const double cosP = std::cos(phi);
+        const double sinP = std::sin(phi);
+        sensors.push_back({
+          .rot = {sinP, cosP, 0., -cosP, sinP, 0., 0., 0., 1.},
+          .trans = {ring.r * cosP, ring.r * sinP, spec.z + ring.zOffset + (iMod % 2 == 0 ? 0.5 * ring.gap : -0.5 * ring.gap)},
+          .layer = layer,
+        });
+      }
+    }
+    ++layer;
+  }
+  return sensors;
+}
+
+/// The toy's geometry: its sensors placed, its envelopes measured and
+/// published for the extent functions.
+template <AnalyticToy Toy>
+[[nodiscard]] Geometry<Toy> toyGeometry()
+{
+  const auto sensors = placeSensors<Toy>();
+  return Geometry<Toy>{sensors};
+}
+
+/// Builds the toy's geometry once, which publishes its envelopes; a toy's
+/// header calls it in a namespace-scope initialiser, so that the extent
+/// functions answer from start-up on, as after an experiment's geometry is
+/// loaded.
+template <AnalyticToy Toy>
+bool publishToy()
+{
+  static_cast<void>(toyGeometry<Toy>());
+  return true;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TEST_ANALYTICLAYOUT_H_
diff --git a/Detectors/GenericTracking/tracking/test/BetweenBoundCheck.h b/Detectors/GenericTracking/tracking/test/BetweenBoundCheck.h
new file mode 100644
index 0000000000000..34497b56044f1
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/BetweenBoundCheck.h
@@ -0,0 +1,145 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file BetweenBoundCheck.h
+/// \brief The kink between a link's layers against the link's bound.
+///
+/// The tracklet stage tests a pair at its link's bound on the kink of a
+/// passive scatterer between the layers (`IterationParameters::betweenBound`)
+/// before computing the pair's own (`betweenScattering`), and refuses it if
+/// that test fails. That refuses only pairs the own kink would refuse too as
+/// long as no pair's kink exceeds the bound, which this checks.
+
+#ifndef GTRK_TEST_BETWEENBOUNDCHECK_H_
+#define GTRK_TEST_BETWEENBOUNDCHECK_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/SearchWindow.h"
+#include "GenericTracking/Tracking/TripletFit.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <random>
+#include <vector>
+
+namespace o2::gtrk::test
+{
+
+/// One link with a passive between its layers: the largest of its pairs'
+/// kinks over its bound.
+struct BetweenBoundRatio {
+  LayerID from = 0;
+  LayerID to = 0;
+  double worst = 0.;
+  /// Pairs whose kink over the link's `betweenPassives` is not, bit for bit,
+  /// the one over every passive: none.
+  int maskMismatches = 0;
+  /// Pairs whose kink from the source's part (`betweenSource`, the beam-line
+  /// tracklet stage) is not, bit for bit, the
+  /// masked one: none.
+  int sourcePartMismatches = 0;
+};
+
+/// Per link with a passive between, `betweenScattering` at points over both
+/// layers' extents -- every corner, then uniform draws -- and vertices over
+/// the beam spot's reach, over the link's `betweenBound`: at most one where
+/// the bound holds.
+template <DetectorLayout Det>
+std::vector<BetweenBoundRatio> betweenOverBound(const ScatteringTable<Det>& scattering, const SearchWindowParams& windows, const VertexConstraint& beamSpot)
+{
+  constexpr int kCorners = 32;
+  constexpr int kDraws = 4096;
+  IterationSettings settings;
+  settings.windows = windows;
+  const auto parameters = iterationParameters<Det>(settings, beamSpot, scattering);
+  const double reach = windows.nSigma * beamSpot.sigmaZ;
+  std::mt19937 rng(20261010);
+  std::uniform_real_distribution<double> uniform(0., 1.);
+  const auto at = [](double low, double high, double u) { return low + (u * (high - low)); };
+  std::vector<BetweenBoundRatio> ratios;
+  for (std::size_t link = 0; link < Det::layerLinks.size(); ++link) {
+    if (!parameters.passiveBetween[link]) {
+      continue;
+    }
+    const auto& pair = Det::layerLinks[link];
+    const auto point = [&](LayerID layer, double u, double v) {
+      const auto r = static_cast<Scalar>(at(radiusMin<Det>(layer), radiusMax<Det>(layer), u));
+      return PairPoint{.x = r, .z = static_cast<Scalar>(at(zMin<Det>(layer), zMax<Det>(layer), v)), .r = r};
+    };
+    BetweenBoundRatio ratio{.from = pair.from, .to = pair.to};
+    for (int draw = 0; draw < kCorners + kDraws; ++draw) {
+      std::array<double, 5> u{};
+      for (std::size_t i = 0; i < u.size(); ++i) {
+        u[i] = draw < kCorners ? static_cast<double>((draw >> i) & 1) : uniform(rng);
+      }
+      auto vertex = vertexSeed(beamSpot);
+      vertex.z = static_cast<Scalar>(at(beamSpot.z - reach, beamSpot.z + reach, u[4]));
+      const auto source = point(pair.from, u[0], u[1]);
+      const auto target = point(pair.to, u[2], u[3]);
+      const Scalar kink = betweenScattering<Det>(parameters.scattering, parameters.pairCut, vertex, source, target);
+      const Scalar masked = betweenScattering<Det>(parameters.scattering, parameters.pairCut, vertex, source, target, parameters.betweenPassives[link]);
+      ratio.maskMismatches += std::bit_cast<std::uint32_t>(masked) != std::bit_cast<std::uint32_t>(kink) ? 1 : 0;
+      const Scalar fromSource = betweenScattering<Det>(betweenSource<Det>(parameters.scattering, vertex, source), parameters.pairCut, vertex, target, parameters.betweenPassives[link]);
+      ratio.sourcePartMismatches += std::bit_cast<std::uint32_t>(fromSource) != std::bit_cast<std::uint32_t>(masked) ? 1 : 0;
+      ratio.worst = std::max(ratio.worst, static_cast<double>(kink) / static_cast<double>(parameters.betweenBound[link]));
+    }
+    ratios.push_back(ratio);
+  }
+  return ratios;
+}
+
+/// Per layout link, segments between points over both layers' extents --
+/// every corner, then uniform draws -- whose passive visits (`visitPassivesBetween`)
+/// differ between every passive and the table's `outOf` the source layer or
+/// `into` the target: none.
+template <DetectorLayout Det>
+int segmentMaskMismatches(const ScatteringTable<Det>& table)
+{
+  constexpr int kCorners = 16;
+  constexpr int kDraws = 4096;
+  std::mt19937 rng(20261015);
+  std::uniform_real_distribution<double> uniform(0., 1.);
+  const auto at = [](double low, double high, double u) { return low + (u * (high - low)); };
+  const PairCut cut{.invBetaMomentum2 = 1.F};
+  int mismatches = 0;
+  for (const auto& link : Det::layerLinks) {
+    const auto point = [&](LayerID layer, double u, double v) {
+      const auto r = static_cast<Scalar>(at(radiusMin<Det>(layer), radiusMax<Det>(layer), u));
+      return PairPoint{.x = r, .z = static_cast<Scalar>(at(zMin<Det>(layer), zMax<Det>(layer), v)), .r = r};
+    };
+    for (int draw = 0; draw < kCorners + kDraws; ++draw) {
+      std::array<double, 4> u{};
+      for (std::size_t i = 0; i < u.size(); ++i) {
+        u[i] = draw < kCorners ? static_cast<double>((draw >> i) & 1) : uniform(rng);
+      }
+      const auto from = point(link.from, u[0], u[1]);
+      const auto to = point(link.to, u[2], u[3]);
+      const auto visits = [&](std::uint64_t passives) {
+        std::vector<std::uint32_t> seen;
+        visitPassivesBetween(table, cut, from, to, 1.F, [&](Scalar variance, Scalar t) { seen.push_back(std::bit_cast<std::uint32_t>(variance * t)); }, passives);
+        return seen;
+      };
+      const auto all = visits(ScatteringTable<Det>::kAllPassives);
+      mismatches += visits(table.outOf(link.from)) != all ? 1 : 0;
+      mismatches += visits(table.into(link.to)) != all ? 1 : 0;
+    }
+  }
+  return mismatches;
+}
+
+} // namespace o2::gtrk::test
+
+#endif // GTRK_TEST_BETWEENBOUNDCHECK_H_
diff --git a/Detectors/GenericTracking/tracking/test/CMakeLists.txt b/Detectors/GenericTracking/tracking/test/CMakeLists.txt
new file mode 100644
index 0000000000000..30db67bd44003
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/CMakeLists.txt
@@ -0,0 +1,60 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+# The toy layouts, the oracles and the fixtures live beside the tests.
+function(gtrk_tracking_test name source)
+  o2_add_test(${name} SOURCES ${source} COMPONENT_NAME generic-tracking
+              PUBLIC_LINK_LIBRARIES O2::GTrkTracking ${ARGN}
+              LABELS generic-tracking TARGETVARNAME target)
+  if(target)
+    # the study's header-only helpers (digests, the point-only stage functions):
+    # these tests build without the upgrades too
+    target_include_directories(${target} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/../../study/include)
+  endif()
+endfunction()
+
+gtrk_tracking_test(math-utils testMathUtils.cxx)
+gtrk_tracking_test(placed-layouts testPlacedLayouts.cxx)
+gtrk_tracking_test(tracking-surface testTrackingSurface.cxx)
+gtrk_tracking_test(timeframe testTimeFrame.cxx)
+gtrk_tracking_test(timeframe-scratch testTimeFrameScratch.cxx)
+gtrk_tracking_test(stage-output testStageOutput.cxx)
+gtrk_tracking_test(device-arena testDeviceArena.cxx)
+gtrk_tracking_test(profile testProfile.cxx)
+gtrk_tracking_test(tracklet-stage testTrackletStage.cxx)
+gtrk_tracking_test(tracklet-sort testTrackletSort.cxx)
+gtrk_tracking_test(triplet-fit testTripletFit.cxx)
+gtrk_tracking_test(seed-cuts testSeedCuts.cxx)
+gtrk_tracking_test(triplet-stage testTripletStage.cxx)
+gtrk_tracking_test(tracklet-paths testTrackletPaths.cxx)
+gtrk_tracking_test(triplet-end-index testTripletEndIndex.cxx)
+gtrk_tracking_test(host-algorithms testHostAlgorithms.cxx)
+gtrk_tracking_test(neighbour-stage testNeighbourStage.cxx)
+gtrk_tracking_test(roads testRoads.cxx)
+gtrk_tracking_test(road-fit testRoadFit.cxx)
+gtrk_tracking_test(selection testSelection.cxx)
+gtrk_tracking_test(iterations testIterations.cxx)
+gtrk_tracking_test(tracker testTracker.cxx)
+gtrk_tracking_test(vertex-stage testVertexStage.cxx)
+gtrk_tracking_test(vertexing-pass testVertexingPass.cxx)
+gtrk_tracking_test(measurement-grid testMeasurementGrid.cxx)
+gtrk_tracking_test(layer-links testLayerLinks.cxx)
+gtrk_tracking_test(iteration testIteration.cxx)
+gtrk_tracking_test(measurement-update testMeasurementUpdate.cxx)
+gtrk_tracking_test(propagator testPropagator.cxx)
+gtrk_tracking_test(propagation-precision testPropagationPrecision.cxx)
+gtrk_tracking_test(covariance-transport testCovarianceTransport.cxx)
+gtrk_tracking_test(track-fitter testTrackFitter.cxx O2::ReconstructionDataFormats)
+gtrk_tracking_test(passive-scattering testPassiveScattering.cxx)
+gtrk_tracking_test(displaced-pair testDisplacedPair.cxx)
+gtrk_tracking_test(follow testFollow.cxx)
+
+add_subdirectory(device)
diff --git a/Detectors/GenericTracking/tracking/test/FixedPointReferences.h b/Detectors/GenericTracking/tracking/test/FixedPointReferences.h
new file mode 100644
index 0000000000000..43e6f9a7b3e15
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/FixedPointReferences.h
@@ -0,0 +1,286 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file FixedPointReferences.h
+/// \brief The levels and the road counts by sweeps to their fixed point, the
+///        independent path the tests hold the ordered one to.
+///
+/// The tracker writes both during the neighbour stage, a stratum at a time
+/// (`NeighbourStage` with its ready levels and `OrderedRoadCounts`). Here
+/// they come from the whole neighbour graph instead: every triplet's level
+/// from its predecessors' until nothing rises, and
+/// the roads through it from those exactly one level below, the same way.
+/// The sweep functors are the device's as well
+/// (DeviceTestKernels.cu).
+
+#ifndef GTRK_TEST_FIXEDPOINTREFERENCES_H_
+#define GTRK_TEST_FIXEDPOINTREFERENCES_H_
+
+#include "GenericTracking/Tracking/Neighbour.h"
+#include "GenericTracking/Tracking/RoadCount.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/Triplet.h"
+
+#include "GPUCommonMath.h"
+
+#include <cstdint>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+/// One element per triplet: the base case, one road at level 1 if the
+/// triplet's first measurement is in the core, none otherwise, and none yet
+/// above level 1.
+class RoadBase
+{
+ public:
+  using Index = StageOutput<TripletT>::Index;
+
+  RoadBase(TrackletConstView tracklets, TripletConstView triplets, const LayerID* linkSources, const MeasurementRange* core, std::uint32_t* roads)
+    : mTracklets(tracklets),
+      mTriplets(triplets),
+      mLinkSources(linkSources),
+      mCore(core),
+      mRoads(roads)
+  {
+  }
+
+  GPUhdi() void operator()(Index triplet) const { mRoads[triplet] = mTriplets.level[triplet] == 1U && roadOwned(mTracklets, mTriplets, mLinkSources, mCore, triplet) ? 1U : 0U; }
+
+ private:
+  TrackletConstView mTracklets;
+  TripletConstView mTriplets;
+  const LayerID* mLinkSources = nullptr;
+  const MeasurementRange* mCore = nullptr;
+  std::uint32_t* mRoads = nullptr;
+};
+
+/// The triplets with predecessors, in arena order: the elements the sweeps
+/// visit.
+inline std::vector<StageOutput<TripletT>::Index> chainedTriplets(const StageOutput<NeighbourT>& neighbours)
+{
+  const auto offsets = neighbours.offsets();
+  std::vector<StageOutput<TripletT>::Index> chained;
+  for (StageOutput<TripletT>::Index triplet = 0U; triplet + 1U < offsets.size(); ++triplet) {
+    if (offsets[triplet + 1U] != offsets[triplet]) {
+      chained.push_back(triplet);
+    }
+  }
+  return chained;
+}
+
+/// One element of a level sweep: a triplet with predecessors pulls their
+/// highest level and raises its own to one above it.
+///
+/// Levels are updated in place, one buffer, with an atomic max: a sweep may
+/// read a predecessor already raised in the same sweep, so how many sweeps
+/// the levels take depends on the schedule, but the fixed point -- a longest
+/// path, a maximum -- does not. Only the triplet itself raises its level;
+/// the atomic makes the store safe against the concurrent reads.
+class LevelUpdate
+{
+ public:
+  using Index = StageOutput<TripletT>::Index;
+  using Level = std::uint32_t;
+
+  LevelUpdate(const Index* chained, const Index* neighbourOffsets, const Index* from, Level* level, Index* changed)
+    : mChained(chained),
+      mNeighbourOffsets(neighbourOffsets),
+      mFrom(from),
+      mLevel(level),
+      mChanged(changed)
+  {
+  }
+
+  GPUdi() void operator()(Index element) const
+  {
+    const Index self = mChained[element];
+    const Index begin = mNeighbourOffsets[self];
+    const Index end = mNeighbourOffsets[self + 1U];
+    Level highest = 0U;
+    for (Index neighbour = begin; neighbour < end; ++neighbour) {
+      const Level level = load(mFrom[neighbour]);
+      highest = level > highest ? level : highest;
+    }
+    const Level raised = highest + 1U;
+    if (raised > load(self)) {
+      o2::gpu::CAMath::AtomicMax(mLevel + self, raised);
+      o2::gpu::CAMath::AtomicMax(mChanged, Index{1U});
+    }
+  }
+
+ private:
+  /// A level another element may be raising (`CAMath::AtomicLoad`).
+  [[nodiscard]] GPUdi() Level load(Index triplet) const { return o2::gpu::CAMath::AtomicLoad(mLevel + triplet); }
+
+  const Index* mChained = nullptr;
+  const Index* mNeighbourOffsets = nullptr;
+  const Index* mFrom = nullptr;
+  Level* mLevel = nullptr;
+  Index* mChanged = nullptr;
+};
+
+/// One element per triplet `S`: every predecessor exactly one level below
+/// gets its flag. Many successors may set one flag; the atomic max makes the
+/// concurrent stores of one value safe.
+class SuccessorMark
+{
+ public:
+  using Index = StageOutput<TripletT>::Index;
+
+  SuccessorMark(const Index* neighbourOffsets, const Index* from, const std::uint32_t* level, std::uint32_t* successorAbove)
+    : mNeighbourOffsets(neighbourOffsets),
+      mFrom(from),
+      mLevel(level),
+      mSuccessorAbove(successorAbove)
+  {
+  }
+
+  GPUdi() void operator()(Index successor) const
+  {
+    const std::uint32_t level = mLevel[successor];
+    for (Index edge = mNeighbourOffsets[successor]; edge < mNeighbourOffsets[successor + 1U]; ++edge) {
+      const Index predecessor = mFrom[edge];
+      if (mLevel[predecessor] + 1U == level) {
+        o2::gpu::CAMath::AtomicMax(mSuccessorAbove + predecessor, std::uint32_t{1U});
+      }
+    }
+  }
+
+ private:
+  const Index* mNeighbourOffsets = nullptr;
+  const Index* mFrom = nullptr;
+  const std::uint32_t* mLevel = nullptr;
+  std::uint32_t* mSuccessorAbove = nullptr;
+};
+
+/// One element of a count sweep, over the triplets with predecessors: the
+/// sum of the roads of the predecessors exactly one level below.
+///
+/// As the level sweep, in place: a sweep may read a predecessor already
+/// raised in the same sweep. Every count starts at or below its final value
+/// and a sum of such counts is too, so counts only rise, and the atomic max
+/// stores them safely against the concurrent reads; the fixed point is
+/// unique. A sum beyond 32 bits saturates and raises \a overflow: roads are
+/// never truncated silently.
+class RoadCountUpdate
+{
+ public:
+  using Index = StageOutput<TripletT>::Index;
+
+  RoadCountUpdate(const Index* chained, const Index* neighbourOffsets, const Index* from, const std::uint32_t* level, std::uint32_t* roads, Index* changed, Index* overflow)
+    : mChained(chained),
+      mNeighbourOffsets(neighbourOffsets),
+      mFrom(from),
+      mLevel(level),
+      mRoads(roads),
+      mChanged(changed),
+      mOverflow(overflow)
+  {
+  }
+
+  GPUdi() void operator()(Index element) const
+  {
+    const Index self = mChained[element];
+    const std::uint32_t below = mLevel[self] - 1U;
+    std::uint64_t sum = 0U;
+    for (Index edge = mNeighbourOffsets[self]; edge < mNeighbourOffsets[self + 1U]; ++edge) {
+      const Index predecessor = mFrom[edge];
+      if (mLevel[predecessor] == below) {
+        sum += load(predecessor);
+      }
+    }
+    const auto count = saturatedRoads(sum, mOverflow);
+    if (count > load(self)) {
+      o2::gpu::CAMath::AtomicMax(mRoads + self, count);
+      o2::gpu::CAMath::AtomicMax(mChanged, Index{1U});
+    }
+  }
+
+ private:
+  /// A count another element may be raising (`CAMath::AtomicLoad`).
+  [[nodiscard]] GPUdi() std::uint32_t load(Index triplet) const { return o2::gpu::CAMath::AtomicLoad(mRoads + triplet); }
+
+  const Index* mChained = nullptr;
+  const Index* mNeighbourOffsets = nullptr;
+  const Index* mFrom = nullptr;
+  const std::uint32_t* mLevel = nullptr;
+  std::uint32_t* mRoads = nullptr;
+  Index* mChanged = nullptr;
+  Index* mOverflow = nullptr;
+};
+
+/// The levels of \a triplets from the whole graph of \a neighbours, swept
+/// over the triplets with predecessors until one changes nothing;
+/// \a forEach(elements, update) runs update(element) for every element,
+/// serially or in parallel. The sweeps that changed a level.
+template <typename ForEach>
+StageOutput<TripletT>::Index fixedPointLevels(ForEach forEach, const StageOutput<NeighbourT>& neighbours, StageOutput<TripletT>& triplets)
+{
+  using Index = StageOutput<TripletT>::Index;
+  const auto chained = chainedTriplets(neighbours);
+  Index changed = 0U;
+  const LevelUpdate update{chained.data(), neighbours.offsets().data(), neighbours.view().from, triplets.view().level, &changed};
+  Index sweeps = 0U;
+  while (true) {
+    changed = 0U;
+    forEach(static_cast<Index>(chained.size()), update);
+    if (changed == 0U) {
+      return sweeps;
+    }
+    ++sweeps;
+  }
+}
+
+/// \a count's successor flags and road counts by sweeps to their fixed point
+/// over the whole graph of \a neighbours (its triplets with predecessors),
+/// then its starts by \a startRule and their numbering as the
+/// tracker's (`RoadCount::runPrepared`). \a linkSources maps a link to its
+/// source layer, \a core the slice's rows per layer. \a forEach as
+/// `fixedPointLevels`'s.
+template <typename ForEach>
+[[nodiscard]] StageStatus fixedPointRoads(RoadCount& count, ForEach forEach, const LayerID* linkSources, const MeasurementRange* core, const RoadStartRule& startRule, const StageOutput<TrackletT>& tracklets, const StageOutput<TripletT>& triplets, const StageOutput<NeighbourT>& neighbours, RoadCount::Index chunkSize = 256U)
+{
+  using Index = RoadCount::Index;
+  const auto status = guardOutOfMemory([&] {
+    const Index triplet = triplets.size();
+    count.prepareOrdered(forEach, triplet);
+    const auto counts = count.ordered(linkSources, core);
+    forEach(triplet, [&](Index t) { counts.roads[t] = 0U; });
+    const auto view = triplets.view();
+    const Index* const offsets = neighbours.offsets().data();
+    const Index* const from = neighbours.view().from;
+    forEach(triplet, SuccessorMark{offsets, from, view.level, counts.successorAbove});
+    forEach(triplet, RoadBase{tracklets.view(), view, linkSources, core, counts.roads});
+    Index changed = 0U;
+    Index overflow = 0U;
+    const auto chained = chainedTriplets(neighbours);
+    const RoadCountUpdate update{chained.data(), offsets, from, view.level, counts.roads, &changed, &overflow};
+    while (true) {
+      changed = 0U;
+      forEach(static_cast<Index>(chained.size()), update);
+      if (changed == 0U) {
+        break;
+      }
+    }
+    return overflow != 0U ? StageStatus::kIndexOverflow : StageStatus::kComplete;
+  });
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  return count.runPrepared(forEach, startRule, tracklets, triplets, chunkSize);
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TEST_FIXEDPOINTREFERENCES_H_
diff --git a/Detectors/GenericTracking/tracking/test/GeneratedHelixFixture.h b/Detectors/GenericTracking/tracking/test/GeneratedHelixFixture.h
new file mode 100644
index 0000000000000..ec68522c6a587
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/GeneratedHelixFixture.h
@@ -0,0 +1,137 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GeneratedHelixFixture.h
+/// \brief Shared generated-helix support for tracking-cut tests.
+
+#ifndef GTRK_TEST_GENERATEDHELIXFIXTURE_H_
+#define GTRK_TEST_GENERATEDHELIXFIXTURE_H_
+
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/TripletCut.h"
+
+#include "GridTestSupport.h"
+#include "UniformMaterial.h"
+
+#include <cmath>
+#include <cstddef>
+#include <numbers>
+#include <random>
+#include <stdexcept>
+
+namespace o2::gtrk
+{
+
+template <DetectorLayout Det>
+struct GeneratedHelixFixture {
+  static constexpr double kMaterialX2X0 = 0.02;
+
+  /// A position on the helix and its direction there.
+  struct State {
+    double x = 0.;
+    double y = 0.;
+    double z = 0.;
+    double phi = 0.;   ///< transverse direction
+    double slope = 0.; ///< tan(lambda)
+  };
+
+  struct Errors {
+    double varZ = 0.;
+    double varR = 0.;
+    double varRPhi = 0.;
+  };
+
+  static constexpr Errors kPixelErrors{.varZ = 2.25e-6, .varR = 1.e-6, .varRPhi = 2.25e-6};
+  static constexpr Errors kLongZErrors{.varZ = 1.e-2, .varR = 1.e-6, .varRPhi = 4.e-6};
+  static constexpr Errors kDiscErrors{.varZ = 1.e-6, .varR = 2.25e-6, .varRPhi = 2.25e-6};
+
+  /// \a kinkSigma is the iteration's kink allowance, 1 for none.
+  [[nodiscard]] static IterationParameters<Det> parametersAt(double minPtGeV, double kinkSigma = 1.)
+  {
+    IterationSettings settings;
+    settings.windows.minPtGeV = minPtGeV;
+    settings.kinkSigma = kinkSigma;
+    return iterationParameters<Det>(settings, VertexConstraint{}, scatteringTable<Det>(uniformLayerMaterial<Det>(kMaterialX2X0)));
+  }
+
+  [[nodiscard]] static State propagate(const State& start, double curvature, double arc)
+  {
+    return {
+      .x = start.x + ((std::sin(start.phi + (curvature * arc)) - std::sin(start.phi)) / curvature),
+      .y = start.y + ((std::cos(start.phi) - std::cos(start.phi + (curvature * arc))) / curvature),
+      .z = start.z + (start.slope * arc),
+      .phi = start.phi + (curvature * arc),
+      .slope = start.slope,
+    };
+  }
+
+  /// To the layer: a barrel's radius by bisection on the outgoing half-turn,
+  /// or a disc's z directly.
+  [[nodiscard]] static State toLayer(const State& start, double curvature, LayerID layer)
+  {
+    if (!Detector<Det>::isBarrelLayer(layer)) {
+      return propagate(start, curvature, (discZ<Det>(layer) - start.z) / start.slope);
+    }
+    const double radius = layerDistance<Det>(layer);
+    double low = 0.;
+    double high = std::numbers::pi_v<double> / curvature;
+    for (int i = 0; i < 100; ++i) {
+      const double middle = 0.5 * (low + high);
+      const State at = propagate(start, curvature, middle);
+      (std::hypot(at.x, at.y) < radius ? low : high) = middle;
+    }
+    return propagate(start, curvature, 0.5 * (low + high));
+  }
+
+  /// Scatter at the layer at the true momentum: Highland with
+  /// p = pT sqrt(1 + slope^2) and the layer's path.
+  [[nodiscard]] static State scatter(const State& at, LayerID layer, double ptGeV, const IterationParameters<Det>& parameters, std::mt19937_64& generator)
+  {
+    std::normal_distribution<double> normal;
+    const double cosine = 1. / std::sqrt(1. + (at.slope * at.slope));
+    const double sine = std::abs(at.slope) * cosine;
+    const double path = Detector<Det>::isBarrelLayer(layer) ? 1. / cosine : 1. / sine;
+    const auto k = static_cast<double>(parameters.scattering.layers[layer].k);
+    const double theta0 = std::sqrt(k * path) * cosine / ptGeV;
+    State kinked = at;
+    kinked.slope = std::tan(std::atan(at.slope) + (normal(generator) * theta0));
+    kinked.phi += normal(generator) * theta0 / cosine;
+    return kinked;
+  }
+
+  [[nodiscard]] static TimedPoint measure(const State& state, const Errors& errors, double timeNS, std::mt19937_64& generator)
+  {
+    std::normal_distribution<double> normal;
+    const double r = std::hypot(state.x, state.y);
+    const double radial = normal(generator) * std::sqrt(errors.varR);
+    const double tangential = normal(generator) * std::sqrt(errors.varRPhi);
+    const double x = state.x + (((radial * state.x) - (tangential * state.y)) / r);
+    const double y = state.y + (((radial * state.y) + (tangential * state.x)) / r);
+    const double z = state.z + (normal(generator) * std::sqrt(errors.varZ));
+    return {
+      .point =
+        {
+          .x = static_cast<Scalar>(x),
+          .y = static_cast<Scalar>(y),
+          .z = static_cast<Scalar>(z),
+          .r = static_cast<Scalar>(std::hypot(x, y)),
+          .varZ = static_cast<Scalar>(errors.varZ),
+          .varR = static_cast<Scalar>(errors.varR),
+          .varRPhi = static_cast<Scalar>(errors.varRPhi),
+        },
+      .time = test::toyTimeBox(timeNS),
+    };
+  }
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TEST_GENERATEDHELIXFIXTURE_H_
diff --git a/Detectors/GenericTracking/tracking/test/GridTestSupport.h b/Detectors/GenericTracking/tracking/test/GridTestSupport.h
new file mode 100644
index 0000000000000..b8696da7a47f1
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/GridTestSupport.h
@@ -0,0 +1,187 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GridTestSupport.h
+/// \brief Test grids of a known shape, and the toys' time boxes and frames.
+///
+/// The grid has no caps; tests that need a small grid set its counts
+/// explicitly. `cappedGrid` gives
+/// the layout one iteration with the given windows derives, each count held
+/// to a ceiling.
+
+#ifndef GTRK_TEST_GRIDTESTSUPPORT_H_
+#define GTRK_TEST_GRIDTESTSUPPORT_H_
+
+#include "GenericTracking/Base/FrameTiming.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Base/TimeEstPS.h"
+#include "GenericTracking/Tracking/GridSizing.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/MeasurementGrid.h"
+#include "GenericTracking/Tracking/MeasurementGridBuilder.h"
+#include "GenericTracking/Tracking/SearchWindow.h"
+#include "GenericTracking/Tracking/SlicePlan.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <span>
+#include <memory>
+#include <vector>
+
+namespace o2::gtrk::test
+{
+
+/// The toys' clock: 25 ns ticks, a tick's box widened by 8 ns at both ends,
+/// so that two hits one tick apart are compatible
+/// and two ticks apart are not.
+inline constexpr double kToyTickNS = 25.;
+inline constexpr double kToyMarginNS = 8.;
+/// The width of every toy box not clamped at the timeframe's start [ps].
+inline constexpr std::uint32_t kToyBoxWidthPS = 41'000U;
+/// The time of a toy track whose hits share one tick [ns].
+inline constexpr double kToyTrackTimeNS = 10.;
+
+/// The box of the toy tick holding \a timeNS, clamped at the timeframe's start.
+[[nodiscard]] inline TimeEstPS toyTimeBox(double timeNS)
+{
+  constexpr double kPSPerNS = 1000.;
+  const double tick = std::floor(timeNS / kToyTickNS);
+  const double lower = std::max((tick * kToyTickNS) - kToyMarginNS, 0.);
+  const double upper = ((tick + 1.) * kToyTickNS) + kToyMarginNS;
+  const auto start = std::llround(lower * kPSPerNS);
+  return {.start = static_cast<std::uint32_t>(start), .width = static_cast<std::uint32_t>(std::llround(upper * kPSPerNS) - start)};
+}
+
+/// The toys' readout frames: one BC on every layer. Their boxes, widened
+/// ticks, are not frames.
+inline constexpr FrameTiming kToyFrames{.lengthBC = 1, .firstStartBC = 0};
+
+/// \a params with the toys' frames on every layer.
+[[nodiscard]] inline GridParams withToyFrames(GridParams params)
+{
+  std::ranges::fill(params.frames, kToyFrames);
+  return params;
+}
+
+/// The windows of one iteration with \a windows, taking every link (chains
+/// of two clusters, `takenLinks`) and extending: every layer a link touches
+/// is sized.
+template <DetectorLayout Det>
+[[nodiscard]] auto oneIterationWindows(const SearchWindowParams& windows, const VertexConstraint& beamSpot)
+{
+  const IterationSettings settings{.windows = windows, .minClusters = 2};
+  return gridLayerWindows<Det>(std::span<const IterationSettings>{&settings, 1U}, beamSpot);
+}
+
+/// The derived layout of one iteration with \a windows, each layer's counts
+/// at most \a maxPhi and \a maxSecond.
+template <DetectorLayout Det>
+[[nodiscard]] GridGeometry<Det> cappedGrid(double durationNS, GridParams params, const SearchWindowParams& windows, const VertexConstraint& beamSpot, std::int32_t maxPhi, std::int32_t maxSecond)
+{
+  const auto layers = oneIterationWindows<Det>(windows, beamSpot);
+  // The toys' times are in ns; the grid's in ps.
+  const auto durationPS = static_cast<std::int64_t>(std::llround(durationNS * 1.e3));
+  const GridGeometry<Det> derived{durationPS, params, layers};
+  for (std::size_t layer = 0; layer < GridGeometry<Det>::kLayerCount; ++layer) {
+    const auto& axes = derived.axes(static_cast<LayerID>(layer));
+    params.phiBins[layer] = std::min(axes.nPhi, maxPhi);
+    params.secondBins[layer] = std::min(axes.nSecond, maxSecond);
+  }
+  return GridGeometry<Det>{durationPS, params, layers};
+}
+
+/// Stable grid placement shared by frame fixtures and grid-only queries.
+/// Callers supply the bucket of each input and fill its placed row.
+template <typename BucketOf, typename Fill>
+void buildGridRows(std::size_t count, std::span<std::uint32_t> offsets, const BucketOf& bucketOf, const Fill& fill)
+{
+  MeasurementGridBuilder builder{offsets};
+  std::vector<std::uint32_t> buckets(count);
+  for (std::size_t i = 0; i < count; ++i) {
+    buckets[i] = bucketOf(i);
+    builder.count(buckets[i]);
+  }
+  builder.prefixSum();
+  for (std::size_t i = 0; i < count; ++i) {
+    fill(i, builder.place(buckets[i]));
+  }
+  builder.finish();
+}
+
+struct FramePoint {
+  LayerID layer = kInvalidLayerID;
+  Scalar x = 0.F;
+  Scalar y = 0.F;
+  Scalar z = 0.F;
+  Scalar r = 0.F;
+  Scalar phi = 0.F;
+};
+
+struct PointVariances {
+  Scalar z = 0.F;
+  Scalar r = 0.F;
+  Scalar rPhi = 0.F;
+};
+
+struct NoLocalMeasurement {
+  void operator()(std::size_t /*input*/, std::uint32_t /*row*/) const {}
+};
+
+/// Build a frame in caller-owned columns and offsets. Logical input indices
+/// become cluster indices; optional local measurements follow the same placement.
+template <DetectorLayout Det, typename PointOf, typename BoxOf, typename VarianceOf, typename FillLocal = NoLocalMeasurement>
+std::unique_ptr<TimeFrame<Det>> frameOf(const GridGeometry<Det>& geometry, std::size_t size, const PointOf& pointOf, const BoxOf& boxOf, const VarianceOf& varianceOf, MeasurementStore& columns, std::vector<std::uint32_t>& offsets, const FillLocal& fillLocal = {})
+{
+  resizeMeasurementColumns(columns, size);
+  offsets.resize(static_cast<std::size_t>(geometry.bucketCount()) + 1U);
+  buildGridRows(
+    size, offsets,
+    [&](std::size_t i) {
+      const auto p = pointOf(i);
+      return geometry.bucketAt(p.layer, boxOf(i).start, p.phi, secondCoordinate<Det>(p.layer, p.r, p.z));
+    },
+    [&](std::size_t i, std::uint32_t row) {
+      const auto p = pointOf(i);
+      const auto box = boxOf(i);
+      const auto variance = varianceOf(i);
+      columns.timePS[row] = box.start;
+      columns.widthPS[row] = box.width;
+      columns.clusterIndex[row] = static_cast<std::uint32_t>(i);
+      columns.x[row] = p.x;
+      columns.y[row] = p.y;
+      columns.z[row] = p.z;
+      columns.r[row] = p.r;
+      columns.phi[row] = p.phi;
+      columns.varZ[row] = variance.z;
+      columns.varR[row] = variance.r;
+      columns.varRPhi[row] = variance.rPhi;
+      fillLocal(i, row);
+    });
+  return std::make_unique<TimeFrame<Det>>(measurementView(columns), geometry, std::span<const std::uint32_t>{offsets});
+}
+
+/// Iteration \a iteration of \a tracker over \a slice alone
+/// (`Tracker::runSlice`), with the frame's bounds and the windows of
+/// \a vertices as `planTimeframe` plans them, the slice planned as it plans
+/// its slices.
+template <typename Tracker, DetectorLayout Det>
+[[nodiscard]] auto runSlice(Tracker& tracker, std::size_t iteration, const TimeFrame<Det>& frame, const typename TimeFrame<Det>::TimeSlice& slice, std::span<const VertexSeed> vertices)
+{
+  const auto plan = tracker.planTimeframe(frame, vertices, frame.grid().geometry().blockCount(), 0);
+  const auto slicePlan = planSlice(frame, slice, sliceReach(frameBounds(frame), frame.grid().geometry()).gatePS());
+  return tracker.runSlice(iteration, frame, plan, slicePlan, vertices, plan.vertexWindows[iteration]);
+}
+
+} // namespace o2::gtrk::test
+
+#endif // GTRK_TEST_GRIDTESTSUPPORT_H_
diff --git a/Detectors/GenericTracking/tracking/test/Oracles.h b/Detectors/GenericTracking/tracking/test/Oracles.h
new file mode 100644
index 0000000000000..4093a9ef417f0
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/Oracles.h
@@ -0,0 +1,484 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Oracles.h
+/// \brief What the tests hold the production path to and nothing else calls.
+///
+///  - the covariance transport's oracles: the dense transport, the step's
+///    prediction in double, the finite-difference Jacobian, which
+///    `testCovarianceTransport` and `testPropagator` hold the structured,
+///    factored and analytic versions to;
+///  - the joint double-precision measurement update, `testMeasurementUpdate`'s
+///    reference for the factorised float one;
+///  - the three-point seed, `testTrackFitter`'s;
+///  - the point-only triplet and neighbour overloads only the tests call
+///    (Validation.h holds those the studies call).
+
+#ifndef GTRK_TEST_ORACLES_H_
+#define GTRK_TEST_ORACLES_H_
+
+#include "GenericTracking/Base/Definitions.h"
+#include "GenericTracking/Tracking/BoundTrackState.h"
+#include "GenericTracking/Tracking/CovarianceTransport.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/Material.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/MeasurementUpdate.h"
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Tracking/Seed.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tracking/NeighbourCut.h"
+#include "GenericTracking/Tracking/TripletCut.h"
+#include "GenericTracking/Tracking/TripletFit.h"
+#include "GenericTracking/Tracking/PairCut.h"
+
+#include "MathUtils/detail/trigonometric.h"
+
+#include <cmath>
+#include <cstddef>
+#include <numbers>
+
+namespace o2::gtrk
+{
+
+// ---- the covariance transport's oracles ----
+
+/// Row-major 5x5: jac[i * kNBoundParams + j] is d(out_i) / d(in_j).
+inline constexpr int kJacobianSize = kNBoundParams * kNBoundParams;
+
+/// Write a SolenoidJacobian out as a dense 5x5, filling in the constants.
+/// For comparison against the finite-difference reference and for QA; the
+/// transport never needs it.
+GPUhdi() GPUAlwaysInline() void expandJacobian(const SolenoidJacobian& jac, Scalar dense[kJacobianSize])
+{
+  for (int i = 0; i < kJacobianSize; ++i) {
+    dense[i] = 0.F;
+  }
+  for (int j = 0; j < kNBoundParams; ++j) {
+    dense[kLoc0 * kNBoundParams + j] = jac.loc0[j];
+    dense[kLoc1 * kNBoundParams + j] = jac.loc1[j];
+    dense[kPhi * kNBoundParams + j] = jac.phi[j];
+  }
+  dense[kTheta * kNBoundParams + kTheta] = 1.F;
+  dense[kQOverP * kNBoundParams + kQOverP] = 1.F;
+}
+
+/// Transport a packed covariance through a general dense Jacobian, in place.
+///
+/// Assuming nothing about the field.
+/// This is the reference the factored transport is checked
+/// against, and it is what a field-map propagator will need.
+GPUhdi() GPUAlwaysInline() void transportCovarianceDense(const Scalar jac[kJacobianSize], Scalar cov[kBoundCovSize])
+{
+  Scalar m[kJacobianSize] = {}; // m = F P
+  for (int i = 0; i < kNBoundParams; ++i) {
+    for (int j = 0; j < kNBoundParams; ++j) {
+      Scalar sum = 0.F;
+      for (int k = 0; k < kNBoundParams; ++k) {
+        sum += jac[i * kNBoundParams + k] * cov[covIndex(k, j)];
+      }
+      m[i * kNBoundParams + j] = sum;
+    }
+  }
+
+  Scalar out[kBoundCovSize] = {}; // out = m F^T, lower triangle only
+  for (int i = 0; i < kNBoundParams; ++i) {
+    for (int j = 0; j <= i; ++j) {
+      Scalar sum = 0.F;
+      for (int k = 0; k < kNBoundParams; ++k) {
+        sum += m[i * kNBoundParams + k] * jac[j * kNBoundParams + k];
+      }
+      out[covIndex(i, j)] = sum;
+    }
+  }
+
+  for (int i = 0; i < kBoundCovSize; ++i) {
+    cov[i] = out[i];
+  }
+}
+
+/// A step's predicted covariance, F (P + Q_before) F^T + Q_after, formed in
+/// double from the float inputs: the oracle `transportFactors` is held to.
+/// \a predicted is packed as `cov`.
+GPUhdi() GPUAlwaysInline() void predictCovarianceExact(const SolenoidJacobian& jac, const StepNoise& noise, const Scalar (&cov)[kBoundCovSize], ExactScalar (&predicted)[kBoundCovSize])
+{
+  Scalar dense[kJacobianSize];
+  expandJacobian(jac, dense);
+  ExactScalar p[kNBoundParams][kNBoundParams];
+  for (int i = 0; i < kNBoundParams; ++i) {
+    for (int j = 0; j < kNBoundParams; ++j) {
+      p[i][j] = static_cast<ExactScalar>(cov[covIndex(i, j)]);
+    }
+  }
+  p[kPhi][kPhi] += static_cast<ExactScalar>(noise.phiBefore);
+  p[kTheta][kTheta] += static_cast<ExactScalar>(noise.thetaBefore);
+  for (int i = 0; i < kNBoundParams; ++i) {
+    for (int j = 0; j <= i; ++j) {
+      ExactScalar sum = 0.;
+      for (int k = 0; k < kNBoundParams; ++k) {
+        for (int l = 0; l < kNBoundParams; ++l) {
+          sum += static_cast<ExactScalar>(dense[(i * kNBoundParams) + k]) * p[k][l] * static_cast<ExactScalar>(dense[(j * kNBoundParams) + l]);
+        }
+      }
+      predicted[covIndex(i, j)] = sum;
+    }
+  }
+  predicted[covIndex(kPhi, kPhi)] += static_cast<ExactScalar>(noise.phiAfter);
+  predicted[covIndex(kTheta, kTheta)] += static_cast<ExactScalar>(noise.thetaAfter);
+  predicted[covIndex(kQOverP, kQOverP)] += static_cast<ExactScalar>(noise.qOverPAfter);
+}
+
+/// Finite-difference step sizes.
+///
+/// They depend on nothing: the position and angle steps are set by the float
+/// noise floor of the output, and the q/p step by the geometry rather than by
+/// the track, for the reason below.
+///
+/// Not round numbers: with a float state the propagated output carries about
+/// 1e-6 cm of rounding, so a central difference has noise 1e-6 / 2h and
+/// truncation of order h^2. The two cross near h ~ 1e-2 in a length, which is
+/// where these sit. The resulting Jacobian is good to roughly 1e-4 relative --
+/// ample to catch a wrong sign, a missing term or a transposed index in an
+/// analytic replacement, and nowhere near good enough to *be* one.
+GPUhdi() GPUAlwaysInline() void defaultDifferenceSteps(Scalar step[kNBoundParams])
+{
+  step[kLoc0] = 1e-2F;  // cm
+  step[kLoc1] = 1e-2F;  // cm
+  step[kPhi] = 1e-3F;   // rad
+  step[kTheta] = 1e-3F; // rad
+
+  // Absolute, not a fraction of q/p. The turn angle psi = (q/p) * Bz * B2C * s
+  // is *linear* in q/p, so a relative step shrinks with momentum until the
+  // perturbation moves the arrival point by less than a float can represent,
+  // and the q/p column is noise.
+  //
+  // A fixed 1e-2 gives d(psi) between 2e-4 rad on the shortest barrel step and
+  // 9e-3 rad on the longest disc one -- linear enough for a central difference
+  // everywhere, and a few hundred times above the float noise floor at both
+  // ends.
+  step[kQOverP] = 1e-2F;
+}
+
+/// Central-difference Jacobian of a propagation, d(target state)/d(source state).
+///
+/// The *reference*, not the production path: it costs ten extra
+/// propagations per step. Returns kOk only if all ten perturbed
+/// propagations reached the plane. Out-of-bounds is accepted throughout: a
+/// derivative does not care whether the intersection landed on active silicon,
+/// and insisting it did would make the reference unusable near a sensor edge.
+/// \a Rule as `propagate`'s.
+template <CrossingRule Rule = CrossingRule::kFirstAhead>
+GPUdi() PropagationStatus jacobianFiniteDifference(const Propagator& prop, const BoundTrackState& state, const TrackingSurface& from, const TrackingSurface& to, PropagationDirection dir, const Scalar step[kNBoundParams], Scalar jac[kJacobianSize])
+{
+  for (int j = 0; j < kNBoundParams; ++j) {
+    BoundTrackState plus = state;
+    BoundTrackState minus = state;
+    plus.par[j] += step[j];
+    minus.par[j] -= step[j];
+
+    const auto rp = propagate<Rule>(prop, plus, from, to, dir);
+    const auto rm = propagate<Rule>(prop, minus, from, to, dir);
+    if (rp.status != PropagationStatus::kOk && rp.status != PropagationStatus::kOutOfBounds) {
+      return rp.status;
+    }
+    if (rm.status != PropagationStatus::kOk && rm.status != PropagationStatus::kOutOfBounds) {
+      return rm.status;
+    }
+
+    const Scalar inv = 1.F / (2.F * step[j]);
+    for (int i = 0; i < kNBoundParams; ++i) {
+      ExactScalar diff = static_cast<ExactScalar>(plus.par[i]) - static_cast<ExactScalar>(minus.par[i]);
+      if (i == kPhi) {
+        // phi lives on a circle: the difference of two normalised angles is
+        // not the angle between them until it is unwrapped, and getting this
+        // wrong shows up only for tracks that happen to straddle +-pi.
+        math_utils::detail::bringToPMPi<ExactScalar>(diff);
+      }
+      jac[i * kNBoundParams + j] = static_cast<Scalar>(diff * static_cast<ExactScalar>(inv));
+    }
+  }
+  return PropagationStatus::kOk;
+}
+
+// ---- the measurement update's oracle ----
+
+namespace detail
+{
+
+/// Put the direction back in phi in [-pi, pi] and theta in [0, pi], on the
+/// covariance itself: the factored update's `canonicalizeDirection` for the
+/// oracle. Reflecting theta changes the sign of its local coordinate, so its
+/// covariance row and column change sign with it.
+GPUhdi() GPUAlwaysInline() void canonicalizeDirection(BoundTrackState& state)
+{
+  math_utils::detail::bringToPMPi<Scalar>(state.par[kTheta]);
+  if (state.theta() < 0.F) {
+    state.par[kTheta] = -state.theta();
+    state.par[kPhi] += std::numbers::pi_v<Scalar>;
+    for (int i = 0; i < kNBoundParams; ++i) {
+      if (i != kTheta) {
+        state.covAt(kTheta, i) = -state.covAt(kTheta, i);
+      }
+    }
+  }
+  math_utils::detail::bringToPMPi<Scalar>(state.par[kPhi]);
+}
+
+/// The chi2 of one update, from its innovation covariance `[[a b] [b d]]`
+/// over (loc0, loc1) and its residuals. In \a T, the update's arithmetic.
+template <typename T>
+GPUhdi() GPUAlwaysInline() void spatialChi2(T a, T b, T d, T residualLoc0, T residualLoc1, MeasurementUpdateResult& result)
+{
+  const T det = a * d - b * b;
+  result.chi2 = static_cast<Scalar>((d * residualLoc0 * residualLoc0 - T(2) * b * residualLoc0 * residualLoc1 + a * residualLoc1 * residualLoc1) / det);
+  // The comparison fails for NaN. The chi2's own sign is not the test: a
+  // near-zero residual's quadratic form can round to a tiny negative number
+  // under a sound covariance, and that is a perfect update, not a broken one.
+  result.positiveDefinite = det > T(0);
+}
+
+} // namespace detail
+
+/// The factored update on the covariance itself: factored, updated, written
+/// back. `updateWithMeasurementExact` below is the oracle the tests hold it to.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() MeasurementUpdateResult updateWithMeasurement(BoundTrackState& state, const Measurement& measurement)
+{
+  auto factors = factorCovariance(state.cov);
+  const auto result = updateWithMeasurement(state, factors, measurement);
+  covarianceFromFactors(factors, state.cov);
+  return result;
+}
+
+/// Joint update of a bound state with (loc0, loc1), in double: the oracle the
+/// factorised float `updateWithMeasurement` is held to.
+///
+/// The measurement covariance has one spatial cross term, so the two
+/// components are updated together. Positive measurement variances and a
+/// positive-definite covariance are construction invariants.
+///
+/// **The arithmetic is double; only the stored covariance is float.** The
+/// update has to produce a posterior far smaller than its prior, and a direct
+/// covariance subtraction cannot do that in float: the first step of an
+/// inward pass over a ten-layer barrel
+/// runs 20 cm from a diffuse 0.1 rad in phi, arrives with a 9 cm^2 position
+/// variance against a 2.5e-6 cm^2 cluster, and a float update loses much of
+/// the result to rounding. The stored float values are each accurate to
+/// their own magnitude, which is all the next transport and update need.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() MeasurementUpdateResult updateWithMeasurementExact(BoundTrackState& state, const Measurement& measurement)
+{
+  MeasurementUpdateResult result;
+  const ExactScalar residual[2] = {
+    static_cast<ExactScalar>(measurement.loc0 - state.loc0()),
+    static_cast<ExactScalar>(measurement.loc1 - state.loc1()),
+  };
+  result.residualLoc0 = static_cast<Scalar>(residual[0]);
+  result.residualLoc1 = static_cast<Scalar>(residual[1]);
+
+  const auto cov = [&state](int i, int j) { return static_cast<ExactScalar>(state.covAt(i, j)); };
+  const ExactScalar innovation[2][2] = {
+    {cov(kLoc0, kLoc0) + static_cast<ExactScalar>(measurement.varLoc0), cov(kLoc0, kLoc1) + static_cast<ExactScalar>(measurement.covLoc01)},
+    {cov(kLoc1, kLoc0) + static_cast<ExactScalar>(measurement.covLoc01), cov(kLoc1, kLoc1) + static_cast<ExactScalar>(measurement.varLoc1)},
+  };
+  const ExactScalar a = innovation[0][0];
+  const ExactScalar b = innovation[0][1];
+  const ExactScalar d = innovation[1][1];
+  const ExactScalar invDet = 1. / (a * d - b * b);
+  const ExactScalar inverse[2][2] = {
+    {d * invDet, -b * invDet},
+    {-b * invDet, a * invDet},
+  };
+
+  constexpr int measured[2] = {kLoc0, kLoc1};
+  ExactScalar gain[kNBoundParams][2]{};
+  for (int i = 0; i < kNBoundParams; ++i) {
+    for (int column = 0; column < 2; ++column) {
+      for (int row = 0; row < 2; ++row) {
+        gain[i][column] += cov(i, measured[row]) * inverse[row][column];
+      }
+    }
+  }
+
+  for (int i = 0; i < kNBoundParams; ++i) {
+    ExactScalar correction = 0.;
+    for (int column = 0; column < 2; ++column) {
+      correction += gain[i][column] * residual[column];
+    }
+    state.par[i] += static_cast<Scalar>(correction);
+  }
+
+  // Joseph form, written with the innovation covariance S:
+  //
+  // P' = (I - KH) P (I - KH)^T + K R K^T
+  //    = P - KHP - PH^T K^T + K S K^T.
+  //
+  // This is algebraically the same update as P - KHP, but it does not obtain
+  // a small posterior by subtracting one nearly equal float matrix: the
+  // shorter form can leave the covariance indefinite, which shows as negative
+  // chi2 in low-pT fits.
+  ExactScalar updated[kBoundCovSize]{};
+  for (int i = 0; i < kNBoundParams; ++i) {
+    for (int j = 0; j <= i; ++j) {
+      ExactScalar value = cov(i, j);
+      for (int measuredIndex = 0; measuredIndex < 2; ++measuredIndex) {
+        value -= gain[i][measuredIndex] * cov(measured[measuredIndex], j);
+        value -= cov(i, measured[measuredIndex]) * gain[j][measuredIndex];
+      }
+      for (int row = 0; row < 2; ++row) {
+        for (int column = 0; column < 2; ++column) {
+          value += gain[i][row] * innovation[row][column] * gain[j][column];
+        }
+      }
+      updated[covIndex(i, j)] = value;
+    }
+  }
+  for (int i = 0; i < kBoundCovSize; ++i) {
+    state.cov[i] = static_cast<Scalar>(updated[i]);
+  }
+
+  detail::spatialChi2(a, b, d, residual[0], residual[1], result);
+
+  detail::canonicalizeDirection(state);
+  return result;
+}
+
+// ---- the three-point seed ----
+
+/// The prior on a three-point seed, whose q/p is known to a factor of a few.
+GPUhdi() GPUAlwaysInline() void setDiffuseSeedCovariance(BoundTrackState& seed) { setDiffuseCovariance(seed, 3.F * o2::gpu::GPUCommonMath::Abs(seed.qOverP())); }
+
+/// Construct a state on the first of three ordered measurement surfaces.
+///
+/// The signed transverse curvature is twice the oriented triangle area over
+/// the product of its side lengths. This remains zero for a straight track;
+/// no straight-line seed branch is needed. The z slope is fitted against the
+/// two transverse arc lengths from the first point.
+///
+/// \a T controls only the arithmetic used to construct the seed. The stored
+/// state remains Scalar; ExactScalar is useful as a host-side validation
+/// oracle while the default keeps the device path in Scalar.
+template <typename T = Scalar, typename Prop>
+GPUdi() BoundTrackState makeThreePointSeed(const Prop& prop, const Measurement& first, const Measurement& second, const Measurement& third, const TrackingSurface& firstSurface, const TrackingSurface& secondSurface, const TrackingSurface& thirdSurface)
+{
+  Scalar firstGlobalScalar[3]{};
+  Scalar secondGlobalScalar[3]{};
+  Scalar thirdGlobalScalar[3]{};
+  surfaceToGlobal(firstSurface, first.loc0, first.loc1, firstGlobalScalar);
+  surfaceToGlobal(secondSurface, second.loc0, second.loc1, secondGlobalScalar);
+  surfaceToGlobal(thirdSurface, third.loc0, third.loc1, thirdGlobalScalar);
+
+  T firstGlobal[3]{};
+  T secondGlobal[3]{};
+  T thirdGlobal[3]{};
+  for (int i = 0; i < 3; ++i) {
+    firstGlobal[i] = static_cast<T>(firstGlobalScalar[i]);
+    secondGlobal[i] = static_cast<T>(secondGlobalScalar[i]);
+    thirdGlobal[i] = static_cast<T>(thirdGlobalScalar[i]);
+  }
+
+  const T dx12 = secondGlobal[0] - firstGlobal[0];
+  const T dy12 = secondGlobal[1] - firstGlobal[1];
+  const T dx13 = thirdGlobal[0] - firstGlobal[0];
+  const T dy13 = thirdGlobal[1] - firstGlobal[1];
+  const T dx23 = thirdGlobal[0] - secondGlobal[0];
+  const T dy23 = thirdGlobal[1] - secondGlobal[1];
+  const T chord12 = std::sqrt(dx12 * dx12 + dy12 * dy12);
+  const T chord13 = std::sqrt(dx13 * dx13 + dy13 * dy13);
+  const T chord23 = std::sqrt(dx23 * dx23 + dy23 * dy23);
+  const T cross = dx12 * dy13 - dy12 * dx13;
+  const T curvature = T(2) * cross / (chord12 * chord13 * chord23);
+
+  const T halfTurnSine12 = o2::gpu::GPUCommonMath::Clamp(T(0.5) * curvature * chord12, T(-1), T(1));
+  T phi = atan2Of(dy12, dx12) - asinOf(halfTurnSine12);
+  math_utils::detail::bringToPMPi<T>(phi);
+
+  const T arc12 = chord12 * detail::asinOverArgument(halfTurnSine12);
+  const T arc13 = detail::transverseArc(curvature, dx13, dy13);
+  const T dz12 = secondGlobal[2] - firstGlobal[2];
+  const T dz13 = thirdGlobal[2] - firstGlobal[2];
+  const T cotTheta = (arc12 * dz12 + arc13 * dz13) / (arc12 * arc12 + arc13 * arc13);
+  const T theta = atan2Of(T(1), cotTheta);
+  const T sinTheta = T(1) / std::sqrt(T(1) + cotTheta * cotTheta);
+  const auto& seedProp = pointPropagator(prop, secondSurface, second);
+  const T field = static_cast<T>(seedProp.bzKiloGauss) * static_cast<T>(constants::math::B2C);
+
+  BoundTrackState seed;
+  seed.par[kLoc0] = first.loc0;
+  seed.par[kLoc1] = first.loc1;
+  seed.par[kPhi] = static_cast<Scalar>(phi);
+  seed.par[kTheta] = static_cast<Scalar>(theta);
+  seed.par[kQOverP] = static_cast<Scalar>(curvature * sinTheta / field);
+  seed.surface = first.surface;
+  seed.surfacePhi = firstSurface.surfacePhi;
+  setDiffuseSeedCovariance(seed);
+  return seed;
+}
+
+// ---- the triplet and neighbour fits from the points alone ----
+
+/// The triplet fit from the points, the kink terms discarded.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool fitTriplet(const PairPoint& first, const PairPoint& middle, const PairPoint& third, LayerID middleLayer, const ScatteringTable<Det>& table, const PairCut& cut, TripletFitResult& result)
+{
+  KinkTerms terms;
+  return fitTriplet(first, middle, third, middleLayer, table, cut, result, terms);
+}
+
+/// The adjacent fit from the four points and given variances at `b` and `c`,
+/// the kink terms computed here.
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool fitAdjacentTriplets(const PairPoint& a, const PairPoint& b, const PairPoint& c, const PairPoint& d, Scalar varianceSecond, Scalar varianceThird, TripletFitResult& result)
+{
+  KinkTerms first;
+  KinkTerms second;
+  if (!makeKinkTerms(a, b, c, first) || !makeKinkTerms(b, c, d, second)) {
+    return false;
+  }
+  return fitAdjacentTriplets(first, second, a, b, c, d, varianceSecond, varianceThird, result);
+}
+
+/// The adjacent fit from the four points, with the scattering at `b` and `c`
+/// at pT_min from the pair cut's table, each at the polar angle of its own
+/// triplet; the kink terms computed here.
+template <DetectorLayout Det>
+[[nodiscard]] inline bool fitAdjacentTriplets(const PairPoint& a, const PairPoint& b, const PairPoint& c, const PairPoint& d, LayerID secondLayer, LayerID thirdLayer, const ScatteringTable<Det>& table, const PairCut& cut, TripletFitResult& result)
+{
+  KinkTerms first;
+  KinkTerms second;
+  if (!makeKinkTerms(a, b, c, first) || !makeKinkTerms(b, c, d, second)) {
+    return false;
+  }
+  return fitAdjacentTriplets(first, second, a, b, c, d, secondLayer, thirdLayer, table, cut, result);
+}
+
+/// The triplet cuts after the dip angle, the kink terms and the kink flag
+/// discarded.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool tripletCompatible(const IterationParameters<Det>& parameters, LayerID middleLayer, const TimedPoint& first, const TimedPoint& middle, const TimedPoint& third, TripletFitResult& fit)
+{
+  KinkTerms terms;
+  bool kinked = false;
+  return tripletCompatible(parameters, middleLayer, first, middle, third, fit, terms, kinked);
+}
+
+/// The neighbour cuts after the curvature agreement, the stage's own
+/// (NeighbourCut.h), the two triplets' kink terms made there from the points,
+/// no kink allowance.
+template <DetectorLayout Det>
+[[nodiscard]] GPUhdi() GPUAlwaysInline() bool neighbourCompatible(const IterationParameters<Det>& parameters, LayerID secondLayer, LayerID thirdLayer, const TimedPoint& a, const TimedPoint& b, const TimedPoint& c, const TimedPoint& d, TripletFitResult& fit)
+{
+  KinkTerms bcd;
+  bool made = false;
+  bool valid = false;
+  return neighbourCompatible(parameters, secondLayer, thirdLayer, a, b, c, d, bcd, made, valid, fit, 1.F, 1.F);
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TEST_ORACLES_H_
diff --git a/Detectors/GenericTracking/tracking/test/PropagationPrecisionFixture.h b/Detectors/GenericTracking/tracking/test/PropagationPrecisionFixture.h
new file mode 100644
index 0000000000000..03f8c3006f558
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/PropagationPrecisionFixture.h
@@ -0,0 +1,101 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#ifndef GTRK_TEST_PROPAGATIONPRECISIONFIXTURE_H_
+#define GTRK_TEST_PROPAGATIONPRECISIONFIXTURE_H_
+#include "GenericTracking/Tracking/Propagator.h"
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+#include <numbers>
+namespace o2::gtrk::propagation_precision
+{
+
+constexpr double kMicron = 1.e-4; ///< [cm]
+
+inline TrackingSurface plane(double x, double y, double z, double angle, bool disc, SensorID id)
+{
+  TrackingSurface result;
+  result.id = id;
+  result.origin[0] = static_cast<float>(x);
+  result.origin[1] = static_cast<float>(y);
+  result.origin[2] = static_cast<float>(z);
+  if (disc) {
+    result.normal[2] = 1.F;
+    result.axis0[0] = static_cast<float>(std::cos(angle));
+    result.axis0[1] = static_cast<float>(std::sin(angle));
+    result.axis1[0] = -result.axis0[1];
+    result.axis1[1] = result.axis0[0];
+  } else {
+    result.normal[0] = static_cast<float>(std::cos(angle));
+    result.normal[1] = static_cast<float>(std::sin(angle));
+    result.axis0[0] = -result.normal[1];
+    result.axis0[1] = result.normal[0];
+    result.axis1[2] = 1.F;
+  }
+  result.bounds = {.halfX = 1.e5F, .halfY = 1.e5F};
+  return result;
+}
+
+/// How far the stored answer is from the helix it claims to be on.
+struct Closure {
+  double position = 0.; ///< stored local position against the helix point [cm]
+  double plane = 0.;    ///< that point's distance from the target plane [cm]
+  double azimuth = 0.;  ///< stored azimuth against the accumulated turn [rad]
+};
+
+/// Re-evaluate the helix in double at the path length the propagation
+/// reported; its float rounding is 1e-7 relative, 30 nm over 3 m.
+inline Closure closure(const Propagator& prop, const BoundTrackState& before, const BoundTrackState& after, const TrackingSurface& from, const TrackingSurface& to, Scalar reportedPath)
+{
+  const auto path = static_cast<double>(reportedPath);
+  const auto phi = static_cast<double>(before.phi());
+  const auto theta = static_cast<double>(before.theta());
+  // The turn per unit path carries no theta: q/pT's sin(theta) cancels against
+  // the transverse part of the step.
+  const double turn = static_cast<double>(before.qOverP()) * static_cast<double>(prop.bzKiloGauss) * static_cast<double>(constants::math::B2C) * path;
+  const double transverse = path * std::sin(theta);
+  const double along = transverse * sinc(turn);
+  const double across = transverse * versine(turn);
+  const double step[3] = {along * std::cos(phi) - across * std::sin(phi), along * std::sin(phi) + across * std::cos(phi), path * std::cos(theta)};
+
+  double local[2] = {0., 0.};
+  double residual = 0.;
+  for (int i = 0; i < 3; ++i) {
+    const double delta = (static_cast<double>(from.origin[i]) - static_cast<double>(to.origin[i])) + static_cast<double>(before.loc0()) * static_cast<double>(from.axis0[i]) + static_cast<double>(before.loc1()) * static_cast<double>(from.axis1[i]) + step[i];
+    local[0] += delta * static_cast<double>(to.axis0[i]);
+    local[1] += delta * static_cast<double>(to.axis1[i]);
+    residual += delta * static_cast<double>(to.normal[i]);
+  }
+
+  Closure out;
+  out.position = std::hypot(local[0] - static_cast<double>(after.loc0()), local[1] - static_cast<double>(after.loc1()));
+  out.plane = std::abs(residual);
+  out.azimuth = std::abs(std::remainder(phi + turn - static_cast<double>(after.phi()), 2. * std::numbers::pi));
+  return out;
+}
+
+struct Worst {
+  Closure value;
+  int checked = 0;
+
+  void add(const Closure& next)
+  {
+    value.position = std::max(value.position, next.position);
+    value.plane = std::max(value.plane, next.plane);
+    value.azimuth = std::max(value.azimuth, next.azimuth);
+    ++checked;
+  }
+
+  void report(const char* label) const { std::cout << label << ": checked=" << checked << " position um=" << value.position / kMicron << " plane um=" << value.plane / kMicron << " azimuth urad=" << value.azimuth * 1.e6 << '\n'; }
+};
+
+} // namespace o2::gtrk::propagation_precision
+#endif
diff --git a/Detectors/GenericTracking/tracking/test/PullStatistics.h b/Detectors/GenericTracking/tracking/test/PullStatistics.h
new file mode 100644
index 0000000000000..7f1231ebcf95e
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/PullStatistics.h
@@ -0,0 +1,150 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file PullStatistics.h
+/// \brief Pull collection, widths, reports and closure checks for sensor chains.
+#ifndef GTRK_TEST_PULLSTATISTICS_H_
+#define GTRK_TEST_PULLSTATISTICS_H_
+#include <boost/test/unit_test.hpp>
+#include "GenericTracking/Tracking/TrackFitter.h"
+#include "MathUtils/detail/trigonometric.h"
+#include <fmt/format.h>
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <span>
+#include <string>
+#include <vector>
+namespace o2::gtrk::test::pulls
+{
+/// One pull distribution: its plain width (the sample standard deviation),
+/// its robust width (1.4826 times the median absolute deviation), and the
+/// fraction beyond 5 -- a tail shows in the first and the last, not the second.
+struct PullWidth {
+  double plain = 0.;
+  double robust = 0.;
+  double beyond5 = 0.;
+};
+
+inline PullWidth widthOf(std::vector<double> pulls)
+{
+  PullWidth w;
+  const auto n = static_cast<double>(pulls.size());
+  double mean = 0.;
+  for (const double p : pulls) {
+    mean += p / n;
+  }
+  double var = 0.;
+  for (const double p : pulls) {
+    var += (p - mean) * (p - mean);
+    w.beyond5 += std::abs(p) > 5. ? 1. / n : 0.;
+  }
+  w.plain = std::sqrt(var / (n - 1.));
+  const auto middle = pulls.begin() + static_cast<std::ptrdiff_t>(pulls.size() / 2);
+  std::ranges::nth_element(pulls, middle);
+  const double median = *middle;
+  for (double& p : pulls) {
+    p = std::abs(p - median);
+  }
+  std::ranges::nth_element(pulls, middle);
+  w.robust = 1.4826 * *middle;
+  return w;
+}
+
+/// The pulls of the fitted state against truth[0] for loc0, loc1, phi, theta
+/// and q/p.
+struct PullPoint {
+  double ptGeV = 0.;
+  double eta = 0.;
+  int fits = 0;
+  int failed = 0;
+  int lostVariance = 0; ///< fits with a variance that is not positive
+  std::array<PullWidth, 5> width{};
+};
+
+constexpr std::array<const char*, 5> kNames{"loc0", "loc1", "phi", "theta", "q/p"};
+/// Collect fitted-state pulls; detector-specific generation and smearing
+/// live in the trial callback so that each scan keeps its random sequence.
+template <typename Chain, typename Trial>
+PullPoint collectPulls(const Chain& chain, double ptGeV, double eta, int trials, const Trial& trialFit)
+{
+  std::array<std::vector<double>, 5> pulls;
+  PullPoint point{.ptGeV = ptGeV, .eta = eta};
+  for (int trial = 0; trial < trials; ++trial) {
+    const auto fit = trialFit(trial);
+    if (fit.status != PropagationStatus::kOk) {
+      ++point.failed;
+      continue;
+    }
+    ++point.fits;
+    bool positive = true;
+    for (int i = 0; i < kNBoundParams; ++i) {
+      positive = positive && fit.state.variance(i) > 0.F;
+    }
+    if (!positive) {
+      ++point.lostVariance;
+      continue;
+    }
+    for (int i = 0; i < kNBoundParams; ++i) {
+      double diff = static_cast<double>(fit.state.par[i]) - static_cast<double>(chain.truth[0].par[i]);
+      if (i == kPhi) {
+        math_utils::detail::bringToPMPi<double>(diff);
+      }
+      pulls[static_cast<std::size_t>(i)].push_back(diff / std::sqrt(static_cast<double>(fit.state.variance(i))));
+    }
+  }
+  for (std::size_t i = 0; i < pulls.size(); ++i) {
+    point.width[i] = widthOf(pulls[i]);
+  }
+  return point;
+}
+
+inline std::string report(const std::string& title, std::span<const PullPoint> points, bool tails = true)
+{
+  std::string out = fmt::format("{}: plain / robust pull width{}\n", title, tails ? ", % beyond 5" : "");
+  out += fmt::format("{:>5} {:>5} {:>5} {:>4}", "pT", "eta", "fits", "lost");
+  for (const auto* name : kNames) {
+    out += fmt::format(" {:>{}}", name, tails ? 19 : 13);
+  }
+  out += '\n';
+  for (const auto& p : points) {
+    out += fmt::format("{:5.2f} {:5.1f} {:5d} {:4d}", p.ptGeV, p.eta, p.fits, p.lostVariance);
+    for (const auto& w : p.width) {
+      out += fmt::format("   {:5.2f} / {:4.2f}", w.plain, w.robust);
+      if (tails) {
+        out += fmt::format(" {:4.1f}", 100. * w.beyond5);
+      }
+    }
+    out += '\n';
+  }
+  return out;
+}
+
+inline void checkUnit(std::span<const PullPoint> points, double tolerance)
+{
+  for (const auto& p : points) {
+    BOOST_TEST_CONTEXT("pT " << p.ptGeV << " eta " << p.eta)
+    {
+      BOOST_TEST(p.failed == 0);
+      BOOST_TEST(p.lostVariance == 0);
+      for (std::size_t i = 0; i < kNames.size(); ++i) {
+        BOOST_TEST_CONTEXT(kNames[i] << " plain " << p.width[i].plain << " robust " << p.width[i].robust)
+        {
+          BOOST_TEST(std::abs(p.width[i].plain - 1.) < tolerance);
+          BOOST_TEST(std::abs(p.width[i].robust - 1.) < tolerance);
+        }
+      }
+    }
+  }
+}
+} // namespace o2::gtrk::test::pulls
+#endif // GTRK_TEST_PULLSTATISTICS_H_
diff --git a/Detectors/GenericTracking/tracking/test/SerialReferences.h b/Detectors/GenericTracking/tracking/test/SerialReferences.h
new file mode 100644
index 0000000000000..87e1ebb119491
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/SerialReferences.h
@@ -0,0 +1,261 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file SerialReferences.h
+/// \brief The serial references the tests hold the backends to: a stage run,
+///        the tracklet sort, the selection's greedy walk.
+///
+/// A stage run (`SerialStage`, `runSerial`): elements in order, each one's records staged by (element, ordinal) as a
+/// device backend stages them, then the counts scanned and the records placed
+/// -- the backends' steps, one at a time, with StageOutput's building blocks.
+/// Its failures come in the order the backends report them: an element past
+/// `kMaxPerElement` records, then staging too small for the run (the staged
+/// count is then the exact size a retry needs), then the scan's.
+
+#ifndef GTRK_TEST_SERIALREFERENCES_H_
+#define GTRK_TEST_SERIALREFERENCES_H_
+
+#include "GenericTracking/Tracking/Selection.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/TrackletSort.h"
+#include "GenericTracking/Tracking/Triplet.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+/// Clear \a output's counts, offsets and result, keeping every allocation.
+template <typename Output>
+void resetOutput(Output& output) noexcept
+{
+  std::ranges::fill(output.counts(), typename Output::Index{0});
+  std::ranges::fill(output.offsets(), typename Output::Index{0});
+  output.clearResult();
+}
+
+/// Exclusive scan of \a output's counts into its offsets, and the output
+/// sized to the total, on the calling thread: the backends' scan, serially.
+template <typename Output>
+StageStatus serialScan(Output& output)
+{
+  using Index = typename Output::Index;
+  const auto counts = output.counts();
+  const auto offsets = output.offsets();
+  std::uint64_t total = 0;
+  for (std::size_t element = 0; element < counts.size(); ++element) {
+    if (counts[element] > Output::kMaxPerElement) {
+      return StageStatus::kOrdinalOverflow;
+    }
+    offsets[element] = static_cast<Index>(total);
+    total += counts[element];
+    if (total > std::numeric_limits<Index>::max()) {
+      return StageStatus::kIndexOverflow;
+    }
+  }
+  offsets[counts.size()] = static_cast<Index>(total);
+  output.resizeOutput(static_cast<Index>(total));
+  return StageStatus::kComplete;
+}
+
+/// Every element in order, on the calling thread: the `forEach` of the host
+/// algorithms and the stages' builds, serially.
+struct SerialForEach {
+  template <typename Body>
+  void operator()(std::uint32_t count, const Body& body) const
+  {
+    for (std::uint32_t i = 0; i < count; ++i) {
+      body(i);
+    }
+  }
+};
+
+template <template <template <class> class> class S>
+class SerialStage
+{
+ public:
+  using Output = StageOutput<S>;
+  using Index = typename Output::Index;
+  using Record = typename Output::Record;
+
+  /// What each element's generation hands its records to.
+  class Emitter
+  {
+   public:
+    void emit(const Record& record)
+    {
+      mStage->stage(mElement, mCount, record);
+      ++mCount;
+    }
+    [[nodiscard]] Index count() const { return mCount; }
+
+   private:
+    friend class SerialStage;
+    Emitter(SerialStage& stage, Index element) : mStage(&stage), mElement(element) {}
+
+    SerialStage* mStage = nullptr;
+    Index mElement = 0;
+    Index mCount = 0;
+  };
+
+  /// Staging for \a capacity records; by default for any run.
+  explicit SerialStage(std::size_t capacity = std::numeric_limits<std::size_t>::max()) : mCapacity(capacity) {}
+
+  /// \a generate(element, emitter) for every element of \a output, in order,
+  /// into \a output.
+  template <typename Generate>
+  StageStatus run(Output& output, Generate generate)
+  {
+    resetOutput(output);
+    mStaged.clear();
+    mStagedCount = 0;
+    mOrdinalOverflow = false;
+    const auto counts = output.counts();
+    for (Index element = 0; element < output.elementCount(); ++element) {
+      Emitter emitter{*this, element};
+      generate(element, emitter);
+      counts[element] = emitter.count();
+    }
+    if (mOrdinalOverflow) {
+      return StageStatus::kOrdinalOverflow;
+    }
+    if (mStagedCount > mCapacity) {
+      return StageStatus::kStagingOverflow;
+    }
+    return guardOutOfMemory([&] {
+      const auto status = serialScan(output);
+      if (status != StageStatus::kComplete) {
+        return status;
+      }
+      const auto offsets = output.offsets();
+      for (const auto& staged : mStaged) {
+        output.output().write(std::size_t{offsets[staged.element]} + staged.ordinal, staged.record);
+      }
+      return StageStatus::kComplete;
+    });
+  }
+
+  /// The records the last run emitted, past the capacity too.
+  [[nodiscard]] std::uint64_t stagedCount() const { return mStagedCount; }
+
+ private:
+  struct Staged {
+    Record record;
+    Index element = 0;
+    Index ordinal = 0;
+  };
+
+  void stage(Index element, Index ordinal, const Record& record)
+  {
+    const std::uint64_t slot = mStagedCount++;
+    if (ordinal >= Output::kMaxPerElement) {
+      mOrdinalOverflow = true;
+      return;
+    }
+    if (slot >= mCapacity) {
+      return;
+    }
+    mStaged.push_back({.record = record, .element = element, .ordinal = ordinal});
+  }
+
+  std::size_t mCapacity;
+  std::vector<Staged> mStaged;
+  std::uint64_t mStagedCount = 0;
+  bool mOrdinalOverflow = false;
+};
+
+/// One serial run of \a generate into \a output, with staging for any count.
+template <template <template <class> class> class S, typename Generate>
+StageStatus runSerial(StageOutput<S>& output, Generate generate)
+{
+  return SerialStage<S>{}.run(output, generate);
+}
+
+/// The tracklet sort's serial reference for one range: an insertion sort over
+/// the columns, quadratic in the range's length.
+template <typename View>
+void sortTrackletSegment(const View& tracklets, std::uint32_t begin, std::uint32_t end)
+{
+  for (auto at = begin + 1U; at < end; ++at) {
+    const auto source = tracklets.source[at];
+    const auto target = tracklets.target[at];
+    const auto link = tracklets.link[at];
+    const auto lambda = tracklets.lambda[at];
+    const auto phi = tracklets.phi[at];
+    auto slot = at;
+    while (slot > begin && trackletBefore(link, lambda, target, tracklets.link[slot - 1U], tracklets.lambda[slot - 1U], tracklets.target[slot - 1U])) {
+      tracklets.source[slot] = tracklets.source[slot - 1U];
+      tracklets.target[slot] = tracklets.target[slot - 1U];
+      tracklets.link[slot] = tracklets.link[slot - 1U];
+      tracklets.lambda[slot] = tracklets.lambda[slot - 1U];
+      tracklets.phi[slot] = tracklets.phi[slot - 1U];
+      --slot;
+    }
+    tracklets.source[slot] = source;
+    tracklets.target[slot] = target;
+    tracklets.link[slot] = link;
+    tracklets.lambda[slot] = lambda;
+    tracklets.phi[slot] = phi;
+  }
+}
+
+/// The tracklet sort's serial reference: every element's range of
+/// \a output, in turn.
+inline void sortTrackletSegments(StageOutput<TrackletT>& output)
+{
+  const auto view = output.view();
+  const auto offsets = output.offsets();
+  for (StageOutput<TrackletT>::Index element = 0; element < output.elementCount(); ++element) {
+    sortTrackletSegment(view, offsets[element], offsets[element + 1U]);
+  }
+}
+
+/// The triplets of each permuted element of placed \a triplets, as
+/// `TripletPaths::build` reads them (the tracker hands it the staged ones).
+inline auto placedTriplets(const StageOutput<TripletT>& triplets)
+{
+  return [&triplets](StageOutput<TripletT>::Index begin, StageOutput<TripletT>::Index end, const auto& body) {
+    const auto view = triplets.view();
+    for (auto element = begin; element < end; ++element) {
+      for (auto triplet = triplets.offsets()[element]; triplet < triplets.offsets()[element + 1U]; ++triplet) {
+        body(element, view.first[triplet], view.second[triplet]);
+      }
+    }
+  };
+}
+
+/// The sequential greedy walk the rounds must match, over the
+/// records in the order \a ranked gives, best first: accept each that does
+/// not conflict with \a mask, and mark it.
+template <std::size_t K, typename View>
+[[nodiscard]] std::vector<std::uint32_t> selectSequentially(const View& records, std::span<const std::uint32_t> ranked, std::uint32_t sharedInnermost, std::span<std::uint8_t> mask)
+{
+  std::vector<std::uint32_t> selected;
+  for (const auto record : ranked) {
+    if (selection::conflicts(records.clusters[record], records.count[record], mask.data(), sharedInnermost)) {
+      continue;
+    }
+    selected.push_back(record);
+    for (std::uint32_t position = 0; position < records.count[record]; ++position) {
+      mask[records.clusters[record].index[position]] = selection::shareable(position, sharedInnermost) ? kShared : kExclusive;
+    }
+  }
+  return selected;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TEST_SERIALREFERENCES_H_
diff --git a/Detectors/GenericTracking/tracking/test/StageOutputComparison.h b/Detectors/GenericTracking/tracking/test/StageOutputComparison.h
new file mode 100644
index 0000000000000..d5713969edc86
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/StageOutputComparison.h
@@ -0,0 +1,50 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef GTRK_TEST_STAGEOUTPUTCOMPARISON_H_
+#define GTRK_TEST_STAGEOUTPUTCOMPARISON_H_
+
+#include <cstddef>
+#include <cstring>
+
+namespace o2::gtrk
+{
+
+/// Compare the element-to-output mapping shared by every StageOutput.
+template <typename Output>
+[[nodiscard]] bool sameStageShape(const Output& lhs, const Output& rhs)
+{
+  return lhs.size() == rhs.size() && lhs.counts().size() == rhs.counts().size() && lhs.offsets().size() == rhs.offsets().size() && std::memcmp(lhs.counts().data(), rhs.counts().data(), lhs.counts().size_bytes()) == 0 && std::memcmp(lhs.offsets().data(), rhs.offsets().data(), lhs.offsets().size_bytes()) == 0;
+}
+
+/// Compare counts, offsets and every schema column byte for byte.
+template <typename Output>
+[[nodiscard]] bool sameStageOutput(const Output& lhs, const Output& rhs)
+{
+  if (!sameStageShape(lhs, rhs)) {
+    return false;
+  }
+
+  const auto left = lhs.view();
+  const auto right = rhs.view();
+  bool same = true;
+  left.apply([&](const auto&... leftColumn) {
+    right.apply([&](const auto&... rightColumn) {
+      static_assert(sizeof...(leftColumn) == sizeof...(rightColumn));
+      same = ((std::memcmp(leftColumn, rightColumn, static_cast<std::size_t>(lhs.size()) * sizeof(*leftColumn)) == 0) && ...);
+    });
+  });
+  return same;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TEST_STAGEOUTPUTCOMPARISON_H_
diff --git a/Detectors/GenericTracking/tracking/test/SyntheticStage.h b/Detectors/GenericTracking/tracking/test/SyntheticStage.h
new file mode 100644
index 0000000000000..9440cc16eaafd
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/SyntheticStage.h
@@ -0,0 +1,115 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file SyntheticStage.h
+/// \brief The synthetic stage of testStageOutput as a host-device functor, so
+///        the serial reference on the host and GpuStage on a device run one
+///        and the same per-element function.
+
+#ifndef GTRK_TEST_SYNTHETICSTAGE_H_
+#define GTRK_TEST_SYNTHETICSTAGE_H_
+
+#include "GenericTracking/Base/Definitions.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+
+#include <cstdint>
+
+namespace o2::gtrk::synthetic
+{
+
+/// How many records each element emits.
+enum class Kind : std::uint8_t {
+  kSample,    ///< 1 2 0 2 0: the canonical-output example of testStageOutput
+  kUneven,    ///< six for the first 40 elements, then none: dense then empty
+  kIrregular, ///< (7 e) mod 11
+  kOverflow,  ///< one element emits one record more than an ordinal can number
+};
+
+struct Count {
+  Kind kind = Kind::kIrregular;
+
+  [[nodiscard]] GPUhdi() std::uint32_t operator()(std::uint32_t element) const
+  {
+    switch (kind) {
+      case Kind::kSample:
+        if (element == 0U) {
+          return 1U;
+        }
+        return element == 1U || element == 3U ? 2U : 0U;
+      case Kind::kUneven:
+        return element < 40U ? 6U : 0U;
+      case Kind::kIrregular:
+        return (element * 7U) % 11U;
+      case Kind::kOverflow:
+        return element == 1U ? static_cast<std::uint32_t>(StageOutput<TrackletT>::kMaxPerElement) + 1U : 1U;
+    }
+    return 0U;
+  }
+};
+
+/// Record k of element e: both in every column, so a record placed anywhere
+/// but offset[e] + k is caught.
+[[nodiscard]] GPUhdi() Tracklet syntheticRecord(std::uint32_t element, std::uint32_t k)
+{
+  return Tracklet{
+    .source = element,
+    .target = (element * 1000U) + k,
+    .link = static_cast<std::uint16_t>(element % 5U),
+    .lambda = static_cast<Scalar>(element) + (static_cast<Scalar>(k) * 0.125F),
+    .phi = -static_cast<Scalar>(element) - (static_cast<Scalar>(k) * 0.25F),
+  };
+}
+
+/// testStageOutput's Generator.
+template <typename Counts>
+struct CountGenerator {
+  Counts count;
+  template <typename Emitter>
+  GPUhdi() void operator()(std::uint32_t element, Emitter& emitter) const
+  {
+    const std::uint32_t records = count(element);
+    for (std::uint32_t k = 0; k < records; ++k) {
+      emitter.emit(syntheticRecord(element, k));
+    }
+  }
+};
+
+using Generator = CountGenerator<Count>;
+
+/// The flat form's synthetic test: a
+/// candidate row is accepted unless it is 1 modulo \a divisor; 0 accepts all.
+struct Accept {
+  std::uint32_t divisor = 3U;
+  [[nodiscard]] GPUhdi() bool operator()(std::uint32_t row) const { return divisor == 0U || row % divisor != 1U; }
+};
+
+/// The serial reference of the flat form: element e's candidates are the
+/// rows e * 1000 + k, k below `count(e)`, in that order; the accepted ones
+/// are emitted as `syntheticRecord(e, k)`.
+struct FlatGenerator {
+  Count count;
+  Accept accept;
+  template <typename Emitter>
+  GPUhdi() void operator()(std::uint32_t element, Emitter& emitter) const
+  {
+    const std::uint32_t candidates = count(element);
+    for (std::uint32_t k = 0; k < candidates; ++k) {
+      if (accept((element * 1000U) + k)) {
+        emitter.emit(syntheticRecord(element, k));
+      }
+    }
+  }
+};
+
+} // namespace o2::gtrk::synthetic
+
+#endif // GTRK_TEST_SYNTHETICSTAGE_H_
diff --git a/Detectors/GenericTracking/tracking/test/ToyBarrel3.h b/Detectors/GenericTracking/tracking/test/ToyBarrel3.h
new file mode 100644
index 0000000000000..8df3cf2786e87
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/ToyBarrel3.h
@@ -0,0 +1,66 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ToyBarrel3.h
+/// \brief Three barrel layers, small enough to check by hand.
+///
+/// Not a stand-in for a real detector: a test fixture.  Twelve sensors in
+/// total, so an exhaustive test over every chip is cheap, and the numbers are
+/// round enough that a placement can be verified with a pencil.
+
+#ifndef GTRK_DETECTORS_TOYBARREL3_H_
+#define GTRK_DETECTORS_TOYBARREL3_H_
+
+#include "AnalyticLayout.h"
+
+#include <array>
+
+namespace o2::gtrk::detectors
+{
+
+struct ToyBarrel3 {
+  static constexpr const char* name = "ToyBarrel3";
+
+  static constexpr SensorSpec sensor{
+    .shape = ShapeType::kRectangle,
+    .halfX = 0.5,
+    .halfY = 1.0,
+    .halfThickness = 0.005,
+    .pitchX = 0.0025, // 25 um -> 400 rows
+    .pitchY = 0.0025, //          800 columns
+  };
+
+  static constexpr std::array<BarrelLayerSpec, 3> barrelSpecs{{
+    {.r = 2., .nStaves = 4, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 4., .nStaves = 4, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 8., .nStaves = 4, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+  }};
+
+  static constexpr std::array<DiscLayerSpec, 0> discSpecs{};
+
+  // Traced as o2-gtrk-layer-links traces a layout, kept by hand:
+  // pT >= 0.1 GeV at Bz = 20 kG, beam spot z in [-1, 1] cm, |eta| <= 6, source intervals padded by 0.5 cm.
+  // The comment on each link is the fraction of its source layer's crossings that take it.
+  static constexpr std::array<LayerLink, 2> layerLinks{{
+    {.from = 0, .to = 1, .sourceMin = -1.50, .sourceMax = 1.50, .skipsLayer = false}, // 1.0000
+    {.from = 1, .to = 2, .sourceMin = -1.50, .sourceMax = 1.50, .skipsLayer = false}, // 1.0000
+  }};
+
+  static constexpr auto barrelLayers = placedLayers(barrelSpecs);
+  static constexpr auto discLayers = placedLayers(discSpecs);
+  static constexpr int nSensors = countSensors(barrelLayers, discLayers);
+};
+
+inline const bool kToyBarrel3Published = publishToy<ToyBarrel3>();
+
+} // namespace o2::gtrk::detectors
+
+#endif // GTRK_DETECTORS_TOYBARREL3_H_
diff --git a/Detectors/GenericTracking/tracking/test/ToyBarrel4Disc8.h b/Detectors/GenericTracking/tracking/test/ToyBarrel4Disc8.h
new file mode 100644
index 0000000000000..8d4f602eb95d0
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/ToyBarrel4Disc8.h
@@ -0,0 +1,124 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ToyBarrel4Disc8.h
+/// \brief Four barrel layers and four discs on each side: the analytic layout
+///        with both, for the tests.
+///
+/// The barrel's staves are tilted and carry several modules with gaps between
+/// them, so some links skip a layer through the gaps; the inner three layers
+/// end before the discs and the fourth reaches beyond them, so tracks run from
+/// the barrel into the discs and from the discs back into the barrel. The discs
+/// lie beyond the 3 sigma of the default 6 cm vertex spread, as the window
+/// bounds require (a disc inside the vertex range bounds no kink). Each disc
+/// has two rings, displaced front and back along the beam, reaching out to
+/// just inside the fourth layer. Discs are ordered along the beam, from -z to
+/// +z.
+
+#ifndef GTRK_DETECTORS_TOYBARREL4DISC8_H_
+#define GTRK_DETECTORS_TOYBARREL4DISC8_H_
+
+#include "AnalyticLayout.h"
+
+#include <array>
+
+namespace o2::gtrk::detectors
+{
+
+namespace toy_barrel4_disc8
+{
+
+inline constexpr SensorSpec kBarrelSensor{
+  .shape = ShapeType::kRectangle,
+  .halfX = 0.5,
+  .halfY = 2.0,
+  .halfThickness = 0.005,
+  .pitchX = 0.0025,
+  .pitchY = 0.0025,
+};
+
+/// One sensor shape for both rings of a disc: a layout's layer has one.
+inline constexpr SensorSpec kDiscSensor{.shape = ShapeType::kRectangle, .halfX = 1.8, .halfY = 4.1, .halfThickness = 0.005, .pitchX = 0.0025, .pitchY = 0.0025};
+
+constexpr DiscLayerSpec disc(double z)
+{
+  return DiscLayerSpec{
+    .z = z,
+    .nRings = 2,
+    .rings = {{.r = 6.6, .nModules = 24, .phi0 = 0., .zOffset = 0.2, .gap = 0.1}, {.r = 14.4, .nModules = 48, .phi0 = 0., .zOffset = -0.2, .gap = 0.1}},
+    .sensor = kDiscSensor,
+  };
+}
+
+} // namespace toy_barrel4_disc8
+
+struct ToyBarrel4Disc8 {
+  static constexpr const char* name = "ToyBarrel4Disc8";
+
+  static constexpr std::array<BarrelLayerSpec, 4> barrelSpecs{{
+    {.r = 3., .nStaves = 22, .nModulesPerStave = 5, .phi0 = 0., .tilt = 0.1, .moduleGap = 0.05, .sensor = toy_barrel4_disc8::kBarrelSensor},
+    {.r = 6., .nStaves = 42, .nModulesPerStave = 5, .phi0 = 0., .tilt = 0.1, .moduleGap = 0.05, .sensor = toy_barrel4_disc8::kBarrelSensor},
+    {.r = 10., .nStaves = 68, .nModulesPerStave = 7, .phi0 = 0., .tilt = 0.1, .moduleGap = 0.05, .sensor = toy_barrel4_disc8::kBarrelSensor},
+    {.r = 20., .nStaves = 132, .nModulesPerStave = 19, .phi0 = 0., .tilt = 0.1, .moduleGap = 0.05, .sensor = toy_barrel4_disc8::kBarrelSensor},
+  }};
+
+  static constexpr std::array<DiscLayerSpec, 8> discSpecs{{
+    toy_barrel4_disc8::disc(-34.),
+    toy_barrel4_disc8::disc(-30.),
+    toy_barrel4_disc8::disc(-26.),
+    toy_barrel4_disc8::disc(-22.),
+    toy_barrel4_disc8::disc(22.),
+    toy_barrel4_disc8::disc(26.),
+    toy_barrel4_disc8::disc(30.),
+    toy_barrel4_disc8::disc(34.),
+  }};
+
+  // Traced as o2-gtrk-layer-links traces a layout, kept by hand:
+  // pT >= 0.1 GeV at Bz = 20 kG, beam spot z in [-5, 5] cm, |eta| <= 6, source intervals padded by 0.5 cm.
+  // The comment on each link is the fraction of its source layer's crossings that take it.
+  static constexpr std::array<LayerLink, 25> layerLinks{{
+    {.from = 0, .to = 1, .sourceMin = -8.05, .sourceMax = 8.05, .skipsLayer = false},   // 0.6690
+    {.from = 0, .to = 2, .sourceMin = -8.24, .sourceMax = 8.24, .skipsLayer = false},   // 0.0021
+    {.from = 0, .to = 3, .sourceMin = -8.27, .sourceMax = -7.23, .skipsLayer = true},   // 0.0001
+    {.from = 0, .to = 7, .sourceMin = -10.60, .sourceMax = -2.02, .skipsLayer = false}, // 0.1644
+    {.from = 0, .to = 8, .sourceMin = 2.02, .sourceMax = 10.60, .skipsLayer = false},   // 0.1645
+    {.from = 1, .to = 2, .sourceMin = -10.60, .sourceMax = 10.60, .skipsLayer = false}, // 0.8932
+    {.from = 1, .to = 7, .sourceMin = -10.60, .sourceMax = -5.88, .skipsLayer = false}, // 0.0534
+    {.from = 1, .to = 8, .sourceMin = 5.88, .sourceMax = 10.60, .skipsLayer = false},   // 0.0534
+    {.from = 2, .to = 3, .sourceMin = -14.65, .sourceMax = 14.53, .skipsLayer = false}, // 0.8738
+    {.from = 2, .to = 7, .sourceMin = -14.65, .sourceMax = -8.53, .skipsLayer = false}, // 0.0601
+    {.from = 2, .to = 8, .sourceMin = 8.33, .sourceMax = 14.65, .skipsLayer = false},   // 0.0661
+    {.from = 4, .to = 3, .sourceMin = 16.96, .sourceMax = 19.09, .skipsLayer = false},  // 1.0000
+    {.from = 5, .to = 3, .sourceMin = 15.54, .sourceMax = 19.09, .skipsLayer = false},  // 0.0559
+    {.from = 5, .to = 4, .sourceMin = 2.00, .sourceMax = 17.38, .skipsLayer = false},   // 0.9441
+    {.from = 6, .to = 3, .sourceMin = 15.14, .sourceMax = 19.09, .skipsLayer = false},  // 0.0624
+    {.from = 6, .to = 5, .sourceMin = 2.00, .sourceMax = 17.19, .skipsLayer = false},   // 0.9376
+    {.from = 7, .to = 3, .sourceMin = 14.58, .sourceMax = 19.09, .skipsLayer = false},  // 0.0704
+    {.from = 7, .to = 6, .sourceMin = 2.00, .sourceMax = 16.94, .skipsLayer = false},   // 0.9296
+    {.from = 8, .to = 3, .sourceMin = 14.52, .sourceMax = 19.09, .skipsLayer = false},  // 0.0699
+    {.from = 8, .to = 9, .sourceMin = 2.00, .sourceMax = 16.91, .skipsLayer = false},   // 0.9301
+    {.from = 9, .to = 3, .sourceMin = 15.09, .sourceMax = 19.09, .skipsLayer = false},  // 0.0621
+    {.from = 9, .to = 10, .sourceMin = 2.00, .sourceMax = 17.17, .skipsLayer = false},  // 0.9379
+    {.from = 10, .to = 3, .sourceMin = 15.51, .sourceMax = 19.09, .skipsLayer = false}, // 0.0557
+    {.from = 10, .to = 11, .sourceMin = 2.00, .sourceMax = 17.37, .skipsLayer = false}, // 0.9443
+    {.from = 11, .to = 3, .sourceMin = 16.72, .sourceMax = 19.09, .skipsLayer = false}, // 1.0000
+  }};
+
+  static constexpr auto barrelLayers = placedLayers(barrelSpecs);
+  static constexpr auto discLayers = placedLayers(discSpecs);
+  static constexpr int nSensors = countSensors(barrelLayers, discLayers);
+};
+
+inline const bool kToyBarrel4Disc8Published = publishToy<ToyBarrel4Disc8>();
+
+} // namespace o2::gtrk::detectors
+
+#endif // GTRK_DETECTORS_TOYBARREL4DISC8_H_
diff --git a/Detectors/GenericTracking/tracking/test/ToyBarrel8.h b/Detectors/GenericTracking/tracking/test/ToyBarrel8.h
new file mode 100644
index 0000000000000..58276936ba4a6
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/ToyBarrel8.h
@@ -0,0 +1,81 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ToyBarrel8.h
+/// \brief Eight evenly spaced barrel layers: a chain deep enough for the CA
+///        levels, small enough to check by hand.
+///
+/// Not a stand-in for a real detector: a test fixture. The layers sit every
+/// 2 cm and link only to the next one, so a
+/// track crossing all eight makes six triplets in a row whose levels are 1 to
+/// 6, and a branch can be placed by hand. Sensors as in ToyBarrel3, with
+/// enough staves -- one more than `pi / atan(halfX / r)` -- that each layer's
+/// ring of flat sensors closes, so a track leaves a measurement on every
+/// layer and the road fit sees real sensor-local measurements.
+
+#ifndef GTRK_DETECTORS_TOYBARREL8_H_
+#define GTRK_DETECTORS_TOYBARREL8_H_
+
+#include "AnalyticLayout.h"
+
+#include <array>
+
+namespace o2::gtrk::detectors
+{
+
+struct ToyBarrel8 {
+  static constexpr const char* name = "ToyBarrel8";
+
+  static constexpr SensorSpec sensor{
+    .shape = ShapeType::kRectangle,
+    .halfX = 0.5,
+    .halfY = 1.0,
+    .halfThickness = 0.005,
+    .pitchX = 0.0025, // 25 um -> 400 rows
+    .pitchY = 0.0025, //          800 columns
+  };
+
+  static constexpr std::array<BarrelLayerSpec, 8> barrelSpecs{{
+    {.r = 2., .nStaves = 14, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 4., .nStaves = 27, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 6., .nStaves = 39, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 8., .nStaves = 52, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 10., .nStaves = 64, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 12., .nStaves = 77, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 14., .nStaves = 90, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 16., .nStaves = 102, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+  }};
+
+  static constexpr std::array<DiscLayerSpec, 0> discSpecs{};
+
+  // Traced as o2-gtrk-layer-links traces a layout, kept by hand:
+  // pT >= 0.1 GeV at Bz = 20 kG, beam spot z in [-1, 1] cm, |eta| <= 6, source intervals padded by 0.5 cm.
+  // The comment on each link is the fraction of its source layer's crossings that take it.
+  static constexpr std::array<LayerLink, 7> layerLinks{{
+    {.from = 0, .to = 1, .sourceMin = -1.50, .sourceMax = 1.50, .skipsLayer = false}, // 1.0000
+    {.from = 1, .to = 2, .sourceMin = -1.50, .sourceMax = 1.50, .skipsLayer = false}, // 1.0000
+    {.from = 2, .to = 3, .sourceMin = -1.50, .sourceMax = 1.50, .skipsLayer = false}, // 1.0000
+    {.from = 3, .to = 4, .sourceMin = -1.50, .sourceMax = 1.50, .skipsLayer = false}, // 1.0000
+    {.from = 4, .to = 5, .sourceMin = -1.50, .sourceMax = 1.50, .skipsLayer = false}, // 1.0000
+    {.from = 5, .to = 6, .sourceMin = -1.50, .sourceMax = 1.50, .skipsLayer = false}, // 1.0000
+    {.from = 6, .to = 7, .sourceMin = -1.50, .sourceMax = 1.50, .skipsLayer = false}, // 1.0000
+  }};
+
+  static constexpr auto barrelLayers = placedLayers(barrelSpecs);
+  static constexpr auto discLayers = placedLayers(discSpecs);
+  static constexpr int nSensors = countSensors(barrelLayers, discLayers);
+};
+
+inline const bool kToyBarrel8Published = publishToy<ToyBarrel8>();
+
+} // namespace o2::gtrk::detectors
+
+#endif // GTRK_DETECTORS_TOYBARREL8_H_
diff --git a/Detectors/GenericTracking/tracking/test/ToyBarrel8Fixture.h b/Detectors/GenericTracking/tracking/test/ToyBarrel8Fixture.h
new file mode 100644
index 0000000000000..00a0c50a043cb
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/ToyBarrel8Fixture.h
@@ -0,0 +1,338 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ToyBarrel8Fixture.h
+/// \brief Timeframes of helices on the deep ToyBarrel8, for the tests of the
+///        neighbour stage, the level sweep and the roads.
+
+#ifndef GTRK_TEST_TOYBARREL8FIXTURE_H_
+#define GTRK_TEST_TOYBARREL8FIXTURE_H_
+
+#include "ToyBarrel8.h"
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Tracking/MeasurementGridBuilder.h"
+#include "GenericTracking/Tracking/Tracker.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Base/Geometry.h"
+
+#include "GridTestSupport.h"
+#include "UniformMaterial.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <numbers>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk::toybarrel8
+{
+
+using Det = detectors::ToyBarrel8;
+using Frame = TimeFrame<Det>;
+using TrackletOutput = StageOutput<TrackletT>;
+using Triplets = StageOutput<TripletT>;
+using Controller = Tracker<Det, UniformMaterial>;
+constexpr std::size_t kLayers = 8U;
+/// The helices of the fixtures by index: direction, dip slope and pT.
+constexpr std::size_t kHelixTracks = 5U;
+
+struct InputPoint {
+  LayerID layer = kInvalidLayerID;
+  Scalar x = 0.F;
+  Scalar y = 0.F;
+  Scalar z = 0.F;
+  Scalar r = 0.F;
+  Scalar phi = 0.F;
+};
+
+inline SearchWindowParams windowParameters()
+{
+  SearchWindowParams result;
+  result.minPtGeV = 1.;
+  result.bzKiloGauss = 20.;
+  result.materialX2X0 = 0.;
+  result.positionSigma = 0.003;
+  result.nSigma = 3.;
+  return result;
+}
+
+inline GridParams gridParameters()
+{
+  GridParams result;
+  result.blockWidth = 20'000;
+  return test::withToyFrames(result);
+}
+
+inline IterationSettings iterationSettings() { return {.windows = windowParameters(), .vertexSource = VertexSource::kBeamLine}; }
+
+/// Where a track from the origin with direction \a phi0, dip slope \a slope
+/// and \a ptGeV crosses \a layer.
+inline InputPoint helixAt(double phi0, double slope, double ptGeV, LayerID layer)
+{
+  const double radius = layerDistance<Det>(layer);
+  const double curvature = 1. / curvatureRadius(ptGeV, 20.);
+  const double arc = 2. * std::asin(0.5 * curvature * radius) / curvature;
+  const double direction = phi0 + (curvature * arc);
+  const double x = (std::sin(direction) - std::sin(phi0)) / curvature;
+  const double y = (std::cos(phi0) - std::cos(direction)) / curvature;
+  double phi = std::atan2(y, x);
+  if (phi < 0.) {
+    phi += 2 * std::numbers::pi_v<double>;
+  }
+  return {
+    .layer = layer,
+    .x = static_cast<Scalar>(x),
+    .y = static_cast<Scalar>(y),
+    .z = static_cast<Scalar>(slope * arc),
+    .r = static_cast<Scalar>(radius),
+    .phi = static_cast<Scalar>(phi),
+  };
+}
+
+inline InputPoint helixPoint(std::size_t track, LayerID layer)
+{
+  constexpr std::array<double, kHelixTracks> kPhi{{0.10, 1.35, 3.05, 4.75, 5.80}};
+  constexpr std::array<double, kHelixTracks> kSlope{{0.04, -0.05, 0.03, -0.02, 0.01}};
+  constexpr std::array<double, kHelixTracks> kPt{{1.2, 1.8, 3.0, 1.4, 2.0}};
+  return helixAt(kPhi[track], kSlope[track], kPt[track], layer);
+}
+
+/// One measurement of a fixture; its index in the list is its cluster index.
+struct Hit {
+  InputPoint point;
+  double timeNS = 10.;
+  /// The sensor and local position, for hits made by sensorHelixHits; the
+  /// other fixtures leave them unset, as the stages before the fit read only
+  /// the global position.
+  SensorID surface = kInvalidSensorID;
+  Scalar loc0 = 0.F;
+  Scalar loc1 = 0.F;
+};
+
+/// The detector's sensors, built once.
+inline const TrackingGeometry<Det>& trackingGeometry()
+{
+  static const auto detector = toyGeometry<Det>();
+  static const TrackingGeometry<Det> tracking{detector};
+  return tracking;
+}
+
+/// The hits of a helix from the origin on the sensors it crosses, one per
+/// layer: on each layer the first sensor whose plane the helix meets inside
+/// the sensor's bounds, near where it crosses the layer's radius. The global
+/// position and the local one are the same point, and the time is the flight
+/// time from the origin at \a startNS, at the speed of light.
+inline std::vector<Hit> sensorHelixHits(double phi0, double slope, double ptGeV, double startNS = 10.)
+{
+  const auto& tracking = trackingGeometry();
+  const double curvature = 1. / curvatureRadius(ptGeV, 20.);
+  const auto at = [&](double arc, double position[3]) {
+    const double direction = phi0 + (curvature * arc);
+    position[0] = (std::sin(direction) - std::sin(phi0)) / curvature;
+    position[1] = (std::cos(phi0) - std::cos(direction)) / curvature;
+    position[2] = slope * arc;
+  };
+  std::vector<Hit> hits;
+  for (std::size_t layer = 0; layer < kLayers; ++layer) {
+    const auto id = static_cast<LayerID>(layer);
+    const double radius = layerDistance<Det>(id);
+    const double crossing = 2. * std::asin(0.5 * curvature * radius) / curvature;
+    const SensorID begin = firstSensorOfLayer<Det>(id);
+    const SensorID end = firstSensorOfLayer<Det>(static_cast<LayerID>(layer + 1));
+    for (SensorID sensor = begin; sensor < end; ++sensor) {
+      const auto& surface = tracking.surface(sensor);
+      const auto height = [&](double arc) {
+        double position[3]{};
+        at(arc, position);
+        double result = 0.;
+        for (int i = 0; i < 3; ++i) {
+          result += (position[i] - static_cast<double>(surface.origin[i])) * static_cast<double>(surface.normal[i]);
+        }
+        return result;
+      };
+      double low = 0.8 * crossing;
+      double high = 1.3 * crossing;
+      if ((height(low) < 0.) == (height(high) < 0.)) {
+        continue;
+      }
+      for (int i = 0; i < 100; ++i) {
+        const double middle = 0.5 * (low + high);
+        ((height(middle) < 0.) == (height(low) < 0.) ? low : high) = middle;
+      }
+      const double arc = 0.5 * (low + high);
+      double position[3]{};
+      at(arc, position);
+      const Scalar global[3]{static_cast<Scalar>(position[0]), static_cast<Scalar>(position[1]), static_cast<Scalar>(position[2])};
+      Scalar local[3]{};
+      surfaceToLocal(surface, global, local);
+      if (!surface.bounds.isInside(local[0], local[1])) {
+        continue;
+      }
+      double phi = std::atan2(position[1], position[0]);
+      if (phi < 0.) {
+        phi += 2 * std::numbers::pi_v<double>;
+      }
+      hits.push_back({
+        .point =
+          {
+            .layer = id,
+            .x = global[0],
+            .y = global[1],
+            .z = global[2],
+            .r = static_cast<Scalar>(std::hypot(position[0], position[1])),
+            .phi = static_cast<Scalar>(phi),
+          },
+        .timeNS = startNS + (arc * std::hypot(1., slope) / static_cast<double>(constants::physics::LightSpeedCm2NS)),
+        .surface = sensor,
+        .loc0 = local[0],
+        .loc1 = local[1],
+      });
+      break;
+    }
+  }
+  return hits;
+}
+
+/// \a point moved along z and r-phi [cm].
+inline InputPoint moved(InputPoint point, double dz, double dRPhi)
+{
+  const double phi = static_cast<double>(point.phi) + (dRPhi / static_cast<double>(point.r));
+  point.x = static_cast<Scalar>(static_cast<double>(point.r) * std::cos(phi));
+  point.y = static_cast<Scalar>(static_cast<double>(point.r) * std::sin(phi));
+  point.phi = static_cast<Scalar>(phi);
+  point.z += static_cast<Scalar>(dz);
+  return point;
+}
+
+class Fixture
+{
+ public:
+  static constexpr VertexConstraint kBeamConstraint{.z = 0., .sigmaZ = 0.02, .sigmaTransverse = 0.001};
+
+  explicit Fixture(const std::vector<Hit>& hits, double durationNS = 20.)
+    : Fixture(hits, durationNS, gridParameters(), [](const Hit& hit) { return test::toyTimeBox(hit.timeNS); })
+  {
+  }
+
+  /// With the grid's \a params and each hit's box from \a boxOf.
+  template <typename BoxOf>
+  Fixture(const std::vector<Hit>& hits, double durationNS, const GridParams& params, const BoxOf& boxOf)
+    : geometry(test::cappedGrid<Det>(durationNS, params, windowParameters(), kBeamConstraint, 16, 8)),
+      offsets(static_cast<std::size_t>(geometry.bucketCount()) + 1U),
+      frame(test::frameOf(
+        geometry, hits.size(), [&](std::size_t i) { return hits[i].point; }, [&](std::size_t i) { return boxOf(hits[i]); },
+        [&](std::size_t i) {
+          const auto scale = static_cast<Scalar>(1U + (i % 3U));
+          return test::PointVariances{.z = scale * 1.e-6F, .r = scale * 2.e-6F, .rPhi = scale * 3.e-6F};
+        },
+        columns, offsets,
+        [&](std::size_t i, std::uint32_t row) {
+          columns.surface[row] = hits[i].surface;
+          columns.loc0[row] = hits[i].loc0;
+          columns.loc1[row] = hits[i].loc1;
+          columns.varLoc0[row] = columns.varRPhi[row];
+          columns.varLoc1[row] = columns.varZ[row];
+        }))
+  {
+  }
+
+  [[nodiscard]] static constexpr std::size_t logicalIndex(std::size_t track, std::size_t layer) { return (kLayers * track) + layer; }
+
+  [[nodiscard]] std::uint32_t row(std::size_t logical) const { return static_cast<std::uint32_t>(std::ranges::find(columns.clusterIndex, static_cast<std::uint32_t>(logical)) - columns.clusterIndex.begin()); }
+
+  GridGeometry<Det> geometry;
+  std::vector<std::uint32_t> offsets;
+  MeasurementStore columns;
+  std::unique_ptr<Frame> frame;
+};
+
+/// The triplet whose measurements are the rows \a a, \a b, \a c.
+inline std::uint32_t findTriplet(const TrackletOutput& tracklets, const Triplets& triplets, std::uint32_t a, std::uint32_t b, std::uint32_t c)
+{
+  const auto trackletView = tracklets.view();
+  const auto view = triplets.view();
+  for (std::uint32_t index = 0; index < triplets.size(); ++index) {
+    const auto first = view.first[index];
+    const auto second = view.second[index];
+    if (trackletView.source[first] == a && trackletView.target[first] == b && trackletView.target[second] == c) {
+      return index;
+    }
+  }
+  return triplets.size();
+}
+
+namespace levels
+{
+
+/// The level fixture's cluster indices: track 0 through all eight layers,
+/// a second hit next to it on layer 3, track 1 without its layer-3 hit, and
+/// track 2 with hits on layers 5-7 only.
+constexpr std::uint32_t kSecondOnLayer3 = 8U;
+constexpr std::array<std::uint32_t, kLayers> kTrack1{{9U, 10U, 11U, 0U, 12U, 13U, 14U, 15U}}; // [3] unused: no hit
+constexpr std::array<std::uint32_t, 3> kTrack2{{16U, 17U, 18U}};
+
+inline std::vector<Hit> levelHits()
+{
+  std::vector<Hit> hits;
+  hits.reserve(kTrack2.back() + 1U);
+  for (std::size_t layer = 0; layer < kLayers; ++layer) {
+    hits.push_back({.point = helixPoint(0U, static_cast<LayerID>(layer))});
+  }
+  hits.push_back({.point = moved(helixPoint(0U, 3), 0.0005, 0.)});
+  for (std::size_t layer = 0; layer < kLayers; ++layer) {
+    if (layer != 3U) {
+      hits.push_back({.point = helixPoint(1U, static_cast<LayerID>(layer))});
+    }
+  }
+  for (std::size_t layer = 5; layer < kLayers; ++layer) {
+    hits.push_back({.point = helixPoint(2U, static_cast<LayerID>(layer))});
+  }
+  return hits;
+}
+
+} // namespace levels
+
+/// The slicing fixture: tracks through all eight layers, spread over the
+/// timeframe. Every other track's timestamps step one clock period after
+/// layers 2 and 5 -- each pair, triplet and `a-d` span stays within the time
+/// cut, and the chain crosses several 20 ns blocks. Every third track has a
+/// second hit on layer 3, so some triplets have two predecessors.
+constexpr double kSliceDurationNS = 1100.;
+constexpr std::size_t kSliceTracks = 12U;
+
+inline std::vector<Hit> sliceHits()
+{
+  constexpr std::array<double, kLayers> kSteps{{0., 0., 0., 25., 25., 25., 50., 50.}};
+  std::vector<Hit> hits;
+  for (std::size_t track = 0; track < kSliceTracks; ++track) {
+    const double phi0 = std::fmod(0.3 + (0.9 * static_cast<double>(track)), 2 * std::numbers::pi_v<double>);
+    const double slope = (track % 2U == 0U ? 0.03 : -0.02) + (0.002 * static_cast<double>(track));
+    const double pt = 1.2 + (0.3 * static_cast<double>(track % 4U));
+    const double start = 37. + (83. * static_cast<double>(track));
+    for (std::size_t layer = 0; layer < kLayers; ++layer) {
+      const double step = track % 2U == 0U ? kSteps[layer] : 0.;
+      hits.push_back({.point = helixAt(phi0, slope, pt, static_cast<LayerID>(layer)), .timeNS = start + step});
+    }
+    if (track % 3U == 0U) {
+      const double step = track % 2U == 0U ? kSteps[3] : 0.;
+      hits.push_back({.point = moved(helixAt(phi0, slope, pt, 3), 0.0005, 0.), .timeNS = start + step});
+    }
+  }
+  return hits;
+}
+
+} // namespace o2::gtrk::toybarrel8
+
+#endif // GTRK_TEST_TOYBARREL8FIXTURE_H_
diff --git a/Detectors/GenericTracking/tracking/test/UniformMaterial.h b/Detectors/GenericTracking/tracking/test/UniformMaterial.h
new file mode 100644
index 0000000000000..b4f28efa6bc5d
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/UniformMaterial.h
@@ -0,0 +1,66 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file UniformMaterial.h
+/// \brief The same material everywhere: the tests' material model.
+///
+/// The fixture the Jacobian and the covariance transport are validated
+/// against: finite differences and a Monte Carlo perturbation both need a
+/// budget that can be computed by hand, which a binary LUT cannot give.
+
+#ifndef GTRK_TEST_UNIFORMMATERIAL_H_
+#define GTRK_TEST_UNIFORMMATERIAL_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/Definitions.h"
+
+#include "DetectorsBase/MatCell.h"
+#include "GPUCommonMath.h"
+
+#include <array>
+#include <cstddef>
+
+namespace o2::gtrk
+{
+
+struct UniformMaterial {
+  Scalar x2X0PerCm = 0.F; ///< radiation lengths per cm
+  Scalar rho = 0.F;       ///< density [g/cm^3]
+
+  /// GPUdi like MatLayerCylSet::getMatBudget, whose interface this mirrors:
+  /// MatBudget's constructor is device-only in a GPU translation unit.
+  [[nodiscard]] GPUdi() o2::base::MatBudget getMatBudget(float x0, float y0, float z0, float x1, float y1, float z1) const
+  {
+    const float dx = x1 - x0;
+    const float dy = y1 - y0;
+    const float dz = z1 - z0;
+    const float len = o2::gpu::GPUCommonMath::Sqrt(dx * dx + dy * dy + dz * dz);
+    o2::base::MatBudget budget;
+    budget.meanX2X0 = x2X0PerCm * len;
+    budget.meanRho = rho;
+    budget.length = len;
+    return budget;
+  }
+};
+
+/// The same `x/X0` for every layer, as `layerMaterial` gives a `LayerBudget`
+/// from a LUT.
+template <DetectorLayout Det>
+[[nodiscard]] inline std::array<double, static_cast<std::size_t>(Detector<Det>::nLayers)> uniformLayerMaterial(double x2X0)
+{
+  std::array<double, static_cast<std::size_t>(Detector<Det>::nLayers)> budget;
+  budget.fill(x2X0);
+  return budget;
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TEST_UNIFORMMATERIAL_H_
diff --git a/Detectors/GenericTracking/tracking/test/device/CMakeLists.txt b/Detectors/GenericTracking/tracking/test/device/CMakeLists.txt
new file mode 100644
index 0000000000000..dcbe4eba44cbb
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/CMakeLists.txt
@@ -0,0 +1,63 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+# The device tests on each backend, labelled gpu because they need one.
+
+if(NOT CUDA_ENABLED AND NOT HIP_ENABLED)
+  return()
+endif()
+
+set(fixtures "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/.." "${CMAKE_CURRENT_SOURCE_DIR}/../../../study/include")
+
+# The test kernels' host code: what O2 compiles only outside GPU translation
+# units (a FlatObject's cloning and relocation). An object library of its own,
+# since the HIP libraries compile every source they hold as HIP.
+add_library(gtrk_device_test_host OBJECT DeviceTestHost.cxx)
+target_include_directories(gtrk_device_test_host PRIVATE ${fixtures})
+target_link_libraries(gtrk_device_test_host PRIVATE O2::GTrkTracking)
+set_target_properties(gtrk_device_test_host PROPERTIES POSITION_INDEPENDENT_CODE ON CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN YES)
+
+function(gtrk_device_test name source backend)
+  string(TOLOWER ${backend} lower)
+  o2_add_test(${name}-${lower} SOURCES ${source} COMPONENT_NAME generic-tracking NAME generic-tracking-${name}-${lower}
+              PUBLIC_LINK_LIBRARIES O2::GTrkTracking${backend} gtrk::device_test_${lower} O2::GTrkTracking O2::GPUTracking
+              LABELS generic-tracking gpu ${ARGN} TARGETVARNAME target)
+  if(target)
+    target_include_directories(${target} PRIVATE ${fixtures})
+    target_compile_definitions(${target} PRIVATE GTRK_TEST_${backend})
+  endif()
+endfunction()
+
+foreach(backend IN ITEMS CUDA HIP)
+  if(NOT ${backend}_ENABLED)
+    continue()
+  endif()
+  string(TOLOWER ${backend} lower)
+
+  gtrk_device_sources(sources ${backend} DeviceTestKernels.cu)
+  add_library(gtrk_device_test_${lower} SHARED ${sources})
+  add_library(gtrk::device_test_${lower} ALIAS gtrk_device_test_${lower})
+  target_sources(gtrk_device_test_${lower} PRIVATE $<TARGET_OBJECTS:gtrk_device_test_host>)
+  target_include_directories(gtrk_device_test_${lower} PRIVATE ${fixtures})
+  target_link_libraries(gtrk_device_test_${lower} PRIVATE O2::GTrkTracking)
+  gtrk_device_target(gtrk_device_test_${lower} ${backend} SHARED "_ZN2o24gtrk*testKernels${backend}E*")
+
+  gtrk_device_test(device-runtime testDeviceRuntime.cxx ${backend})
+  gtrk_device_test(gpu-stage testGpuStage.cxx ${backend})
+  gtrk_device_test(flat-stage testFlatStage.cxx ${backend})
+  gtrk_device_test(device-tracker testDeviceTracker.cxx ${backend})
+  gtrk_device_test(slice-glue testSliceGlue.cxx ${backend})
+  gtrk_device_test(device-storage testDeviceStorage.cxx ${backend})
+  gtrk_device_test(road-glue testRoadGlue.cxx ${backend})
+  gtrk_device_test(selection-glue testSelectionGlue.cxx ${backend})
+  # O2's material LUT on the device, if GTRK_TEST_MATLUT names one.
+  gtrk_device_test(device-material testDeviceMaterial.cxx ${backend})
+endforeach()
diff --git a/Detectors/GenericTracking/tracking/test/device/DeviceTestFixture.h b/Detectors/GenericTracking/tracking/test/device/DeviceTestFixture.h
new file mode 100644
index 0000000000000..6ee202ef89047
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/DeviceTestFixture.h
@@ -0,0 +1,159 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceTestFixture.h
+/// \brief What every device test needs: the backend it is built for, its
+///        test kernels, the device on O2's GPU route with arenas on it and a
+///        stream, and host stage outputs made from record lists.
+///
+/// A device test is built once per backend with GTRK_TEST_HIP or without it,
+/// for CUDA. Include it after <boost/test/unit_test.hpp>, with the test's
+/// BOOST_TEST_MODULE defined, in the test's one source: it holds the test
+/// process's device, a global fixture.
+
+#ifndef GTRK_TEST_DEVICE_DEVICETESTFIXTURE_H_
+#define GTRK_TEST_DEVICE_DEVICETESTFIXTURE_H_
+
+#include "DeviceTestKernels.h"
+
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceContext.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/DeviceStream.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "SerialReferences.h"
+
+#include <boost/test/unit_test.hpp>
+#include <boost/test/tree/observer.hpp>
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk::device_test
+{
+
+/// That backend's test kernels.
+inline const DeviceTestEntry& kernels()
+{
+#ifdef GTRK_TEST_HIP
+  return *testKernelsHIP();
+#else
+  return *testKernelsCUDA();
+#endif
+}
+
+inline constexpr std::size_t kArenaBytes = std::size_t{256} * 1024U * 1024U;
+/// The test process's one block, of which every arena of a test case takes
+/// a slice: what a case holds at once.
+inline constexpr std::size_t kBlockBytes = std::size_t{1} << 30U;
+
+/// The test process's device: the backend's first, on O2's GPU route.
+struct Process final : public boost::unit_test::test_observer {
+  Process()
+  {
+#ifdef GTRK_TEST_HIP
+    constexpr const char* kBackend = "HIP";
+#else
+    constexpr const char* kBackend = "CUDA";
+#endif
+    context = std::make_unique<DeviceContext>(kBackend, 0, std::array{kBlockBytes});
+    instance() = this;
+    boost::unit_test::framework::register_observer(*this);
+  }
+  ~Process() override
+  {
+    boost::unit_test::framework::deregister_observer(*this);
+    instance() = nullptr;
+  }
+  Process(const Process&) = delete;
+  Process& operator=(const Process&) = delete;
+  Process(Process&&) = delete;
+  Process& operator=(Process&&) = delete;
+
+  /// Every test case starts with the whole block.
+  void test_unit_start(const boost::unit_test::test_unit& /*unit*/) override { used = 0U; }
+
+  static Process*& instance()
+  {
+    static Process* process = nullptr;
+    return process;
+  }
+
+  std::unique_ptr<DeviceContext> context;
+  std::size_t used = 0U;
+};
+BOOST_TEST_GLOBAL_FIXTURE(Process);
+
+/// The device's runtime.
+inline DeviceRuntime* runtime() { return &Process::instance()->context->runtime(); }
+
+/// The next \a bytes of the test case's block, 4 kB aligned.
+inline DeviceBlock block(std::size_t bytes)
+{
+  constexpr std::size_t kAlignment = 4096U;
+  auto& process = *Process::instance();
+  const auto whole = process.context->block(0U);
+  const std::size_t at = (process.used + kAlignment - 1U) / kAlignment * kAlignment;
+  BOOST_REQUIRE_MESSAGE(at + bytes <= whole.bytes, "the test case's arenas exceed the test block");
+  process.used = at + bytes;
+  return {.data = static_cast<std::byte*>(whole.data) + at, .bytes = bytes};
+}
+
+/// Gives the slices taken inside it back when it closes.
+class SliceScope
+{
+ public:
+  SliceScope() : mUsed(Process::instance()->used) {}
+  ~SliceScope() { Process::instance()->used = mUsed; }
+  SliceScope(const SliceScope&) = delete;
+  SliceScope& operator=(const SliceScope&) = delete;
+  SliceScope(SliceScope&&) = delete;
+  SliceScope& operator=(SliceScope&&) = delete;
+
+ private:
+  std::size_t mUsed;
+};
+
+/// An arena on the device and a stream.
+struct Device {
+  explicit Device(std::size_t arenaBytes = kArenaBytes)
+    : runtime(device_test::runtime()),
+      arena(std::make_unique<DeviceArena>(*runtime, block(arenaBytes))),
+      stream(runtime->createStream())
+  {
+  }
+
+  SliceScope slices;
+  DeviceRuntime* runtime;
+  std::unique_ptr<DeviceArena> arena;
+  DeviceStream stream;
+};
+
+/// A host stage output of one record per element, made by the serial
+/// reference.
+template <template <template <class> class> class S, typename Record>
+std::unique_ptr<StageOutput<S>> recordsOf(const std::vector<Record>& records)
+{
+  auto output = std::make_unique<StageOutput<S>>();
+  output->setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  output->prepare(static_cast<std::uint32_t>(records.size()));
+  BOOST_REQUIRE(runSerial(*output, [&](std::uint32_t element, auto& emitter) { emitter.emit(records[element]); }) == StageStatus::kComplete);
+  return output;
+}
+
+} // namespace o2::gtrk::device_test
+
+#endif // GTRK_TEST_DEVICE_DEVICETESTFIXTURE_H_
diff --git a/Detectors/GenericTracking/tracking/test/device/DeviceTestHost.cxx b/Detectors/GenericTracking/tracking/test/device/DeviceTestHost.cxx
new file mode 100644
index 0000000000000..043d0241ce5a3
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/DeviceTestHost.cxx
@@ -0,0 +1,27 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DeviceTestHost.cxx
+/// \brief The host code of the test-kernel library: what O2 compiles only
+///        outside GPU translation units.
+
+#include "DeviceTestKernels.h"
+
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+
+namespace o2::gtrk
+{
+
+std::size_t FlatObjectPort<ToyFlatObject>::bufferBytes(const ToyFlatObject& source) { return flatObjectBufferBytes(source); }
+
+void FlatObjectPort<ToyFlatObject>::image(const ToyFlatObject& source, char* futureBuffer, FlatObjectImage& image) { flatObjectImage(source, futureBuffer, image); }
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/device/DeviceTestKernels.cu b/Detectors/GenericTracking/tracking/test/device/DeviceTestKernels.cu
new file mode 100644
index 0000000000000..434ba64e9f878
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/DeviceTestKernels.cu
@@ -0,0 +1,800 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+// Test-only CUDA kernels, hipified verbatim for HIP.
+
+#include <cuda_runtime.h>
+
+#include "DeviceTestKernels.h"
+#include "DeviceAlgorithms.cuh"
+#include "DeviceTracker.cuh"
+#include "FlatStage.cuh"
+#include "GpuStage.cuh"
+#include "RoadGlue.cuh"
+#include "SelectionGlue.cuh"
+#include "SliceGlue.cuh"
+
+#include "GenericTracking/Tracking/GPU/MaterialPort.h"
+#include "GenericTracking/Tracking/Trig.h"
+
+#include "DetectorsBase/MatLayerCylSet.h"
+#include "UniformMaterial.h"
+
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+
+#ifndef GTRK_BACKEND_NAMESPACE
+#error "GTRK_BACKEND_NAMESPACE must name this test kernel's private namespace"
+#endif
+
+namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+{
+namespace
+{
+
+GPUg() void trigKernel(const double* ys, const double* xs, TrigRow* rows, std::uint32_t count)
+{
+  for (std::uint32_t i = (blockIdx.x * blockDim.x) + threadIdx.x; i < count; i += blockDim.x * gridDim.x) {
+    rows[i] = trigRow(ys[i], xs[i]);
+  }
+}
+
+cudaStream_t streamOf(DeviceRuntime& runtime, DeviceStream& stream) { return static_cast<cudaStream_t>(runtime.nativeStream(stream)); }
+
+void runTrig(DeviceRuntime& runtime, DeviceStream& stream, const double* ys, const double* xs, TrigRow* rows, std::uint32_t count)
+{
+  if (count == 0U) {
+    return;
+  }
+  const auto shape = gpu::launchFor(count);
+  trigKernel<<<shape.blocks, shape.threads, 0U, streamOf(runtime, stream)>>>(ys, xs, rows, count);
+  checkLaunch();
+}
+
+StageStatus runSynthetic(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, synthetic::Kind kind, std::uint32_t elements, std::size_t stagingCapacity, StageOutput<TrackletT>& result, SyntheticRunInfo& info)
+{
+  GpuStage<TrackletT> stage{runtime, arena, stream};
+  DeviceStageOutput<TrackletT> output;
+  if (!output.prepare(arena, elements)) {
+    return StageStatus::kOutOfMemory;
+  }
+  stage.prepareStaging(stagingCapacity);
+  const StageStatus status = stage.run(output, synthetic::Generator{.count = {.kind = kind}});
+  info.predictionMissed = stage.stagingPredictionMissed();
+  info.capacityAfter = stage.stagingCapacity();
+  info.scratchAfter = arena.used(ArenaEnd::kScratch);
+  if (status == StageStatus::kComplete) {
+    download(output, result, stream);
+    stream.synchronize();
+  }
+  return status;
+}
+
+/// The elements a listed run generates: every one that emits, and every
+/// third of the rest.
+struct ListedSynthetic {
+  synthetic::Count count;
+  GPUdi() bool operator()(std::uint32_t element) const { return count(element) != 0U || element % 3U == 0U; }
+};
+
+StageStatus runSyntheticListed(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, synthetic::Kind kind, std::uint32_t elements, std::size_t stagingCapacity, StageOutput<TrackletT>& result, SyntheticRunInfo& info)
+{
+  GpuStage<TrackletT> stage{runtime, arena, stream};
+  DeviceStageOutput<TrackletT> output;
+  if (!output.prepare(arena, elements)) {
+    return StageStatus::kOutOfMemory;
+  }
+  stage.prepareStaging(stagingCapacity);
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  DeviceSpan<std::uint32_t> listed;
+  std::uint32_t listedCount = 0U;
+  StageStatus status = algorithms::selectIndices(runtime, arena, stream, elements, ListedSynthetic{.count = {.kind = kind}}, listed, listedCount, ArenaEnd::kScratch);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  info.listed = listedCount;
+  status = stage.run(output, synthetic::Generator{.count = {.kind = kind}}, listed.data(), listedCount);
+  info.predictionMissed = stage.stagingPredictionMissed();
+  if (status == StageStatus::kComplete) {
+    download(output, result, stream);
+    stream.synchronize();
+  }
+  return status;
+}
+
+/// The flat form's synthetic stage:
+/// element e's candidates are the rows e * 1000 + k, its context the element
+/// itself, which the test checks against the row, so a pair tested with
+/// another element's context is caught.
+struct FlatSynthetic {
+  synthetic::Count counter;
+  synthetic::Accept accept;
+  std::uint32_t* contexts = nullptr;
+  std::uint32_t sourceBegin = 0U;
+  [[nodiscard]] GPUdi() std::uint32_t count(std::uint32_t element) const { return counter(element); }
+  template <typename Sink>
+  GPUdi() void fill(std::uint32_t element, std::uint32_t position, Sink& sink) const
+  {
+    contexts[position - sourceBegin] = element;
+    const std::uint32_t candidates = counter(element);
+    for (std::uint32_t k = 0; k < candidates; ++k) {
+      sink.put((element * 1000U) + k, position);
+    }
+  }
+  [[nodiscard]] GPUdi() std::uint32_t sourceOf(const flat::CandidatePair& pair) const { return pair.key; }
+  [[nodiscard]] GPUdi() bool test(std::uint32_t, const flat::CandidatePair& pair) const
+  {
+    // The pair's candidate index from its element's context: a pair tested
+    // with another element's context lands outside that element's count.
+    const std::uint32_t element = contexts[pair.key - sourceBegin];
+    const std::uint32_t k = pair.row - (element * 1000U);
+    return k < counter(element) && accept(pair.row);
+  }
+  [[nodiscard]] GPUdi() Tracklet emit(std::uint32_t, const flat::CandidatePair& pair, std::uint32_t element) const { return synthetic::syntheticRecord(element, pair.row - (element * 1000U)); }
+  [[nodiscard]] bool beginChunk(DeviceArena& arena, std::uint32_t begin, std::uint32_t sources, std::uint32_t)
+  {
+    sourceBegin = begin;
+    DeviceSpan<std::uint32_t> storage;
+    if (!storage.allocate(arena, std::max<std::size_t>(sources, 1U), ArenaEnd::kScratch)) {
+      return false;
+    }
+    contexts = storage.data();
+    return true;
+  }
+  [[nodiscard]] std::size_t contextBytes(std::uint32_t sources) const { return std::size_t{sources} * sizeof(std::uint32_t); }
+  [[nodiscard]] std::size_t pairBytes() const { return 0U; }
+};
+
+/// Every element: the flat run over all of them, as a list.
+struct AllElements {
+  GPUdi() bool operator()(std::uint32_t) const { return true; }
+};
+
+StageStatus runFlatSynthetic(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, synthetic::Kind kind, std::uint32_t divisor, std::uint32_t elements, bool listedRun, std::size_t maxChunkPairs, StageOutput<TrackletT>& result, FlatRunInfo& info)
+{
+  DeviceStageOutput<TrackletT> output;
+  if (!output.prepare(arena, elements)) {
+    return StageStatus::kOutOfMemory;
+  }
+  auto scratch = arena.scope(ArenaEnd::kScratch);
+  DeviceSpan<std::uint32_t> listed;
+  std::uint32_t listedCount = 0U;
+  StageStatus status = listedRun ? algorithms::selectIndices(runtime, arena, stream, elements, ListedSynthetic{.count = {.kind = kind}}, listed, listedCount, ArenaEnd::kScratch) : algorithms::selectIndices(runtime, arena, stream, elements, AllElements{}, listed, listedCount, ArenaEnd::kScratch);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  info.listed = listedCount;
+  status = flat::runFlat(runtime, arena, stream, listedCount > 0U ? listed.data() : nullptr, listedCount, FlatSynthetic{.counter = {.kind = kind}, .accept = {.divisor = divisor}}, output, info.report, flat::FlatOptions{.maxChunkPairs = maxChunkPairs});
+  if (status == StageStatus::kComplete) {
+    download(output, result, stream);
+    stream.synchronize();
+  }
+  return status;
+}
+
+struct PropagateProbe {
+  const PropagationProbe* probes;
+  PropagationAnswer* answers;
+  GPUdi() void operator()(std::uint32_t row) const
+  {
+    const auto& probe = probes[row];
+    auto state = probe.before;
+    const auto result = propagate(probe.prop, state, probe.from, probe.to, probe.direction);
+    answers[row] = {.after = state, .result = result};
+  }
+};
+StageStatus runPropagation(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, std::span<const PropagationProbe> probes, std::vector<PropagationAnswer>& answers)
+{
+  auto scope = arena.scope();
+  DeviceSpan<PropagationProbe> inputs;
+  DeviceSpan<PropagationAnswer> outputs;
+  if (!inputs.allocate(arena, probes.size()) || !outputs.allocate(arena, probes.size())) {
+    return StageStatus::kOutOfMemory;
+  }
+  upload(probes.data(), inputs, probes.size(), stream);
+  algorithms::forEach(runtime, stream, static_cast<std::uint32_t>(probes.size()), PropagateProbe{inputs.data(), outputs.data()});
+  answers.resize(probes.size());
+  download(outputs, answers.data(), probes.size(), stream);
+  stream.synchronize();
+  return StageStatus::kComplete;
+}
+
+std::unique_ptr<DeviceTracker<detectors::ToyBarrel8, UniformMaterial>> makeToyBarrel8Tracker(DeviceRuntime& runtime, DeviceBlock arena) { return std::make_unique<DeviceTrackerImpl<detectors::ToyBarrel8, UniformMaterial>>(runtime, arena); }
+
+using Toy = detectors::ToyBarrel8;
+constexpr std::size_t kToyLayers = static_cast<std::size_t>(Detector<Toy>::nLayers);
+
+StageStatus runPermutation(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, const IterationParameters<Toy>& parameters, const LayerRowMap<Toy>& sources, const StageOutput<TrackletT>& tracklets, std::span<const std::uint8_t> prefix, std::span<const std::uint8_t> suffix, std::vector<std::uint32_t>& result)
+{
+  auto scope = arena.scope();
+  DeviceObject<IterationParameters<Toy>> deviceParameters;
+  DeviceObject<LayerRowMap<Toy>> deviceSources;
+  DeviceColumns<TrackletT> deviceTracklets;
+  DeviceSpan<std::uint32_t> offsets;
+  glue::DevicePathBounds paths;
+  const auto rows = static_cast<std::uint32_t>(prefix.size());
+  if (!deviceParameters.allocate(arena) || !deviceSources.allocate(arena) || !deviceTracklets.allocate(arena, tracklets.size()) || !offsets.allocate(arena, tracklets.elementCount() + 1U) || !paths.allocate(arena, rows)) {
+    return StageStatus::kOutOfMemory;
+  }
+  uploadObject(parameters, deviceParameters, stream);
+  uploadObject(sources, deviceSources, stream);
+  upload<TrackletT>(tracklets.view(), tracklets.size(), deviceTracklets, stream);
+  upload(tracklets.offsets().data(), offsets, tracklets.elementCount() + 1U, stream);
+  upload(prefix.data(), paths.prefix, rows, stream);
+  upload(suffix.data(), paths.suffix, rows, stream);
+  DeviceSpan<std::uint32_t> permutation;
+  std::uint32_t size = 0U;
+  const auto status = glue::permutation<Toy>(runtime, arena, stream, std::as_const(deviceTracklets).view(), tracklets.size(), deviceParameters.data(), deviceSources.data(), permutation, size, offsets.data(), paths.view(parameters.minClusters));
+  if (status == StageStatus::kComplete) {
+    result.resize(size);
+    download(permutation, result.data(), size, stream);
+  }
+  stream.synchronize();
+  return status;
+}
+
+StageStatus runPathBounds(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, const IterationParameters<Toy>& parameters, const LayerRowMap<Toy>& sources, const StageOutput<TrackletT>& tracklets, const StageOutput<TripletT>& triplets, std::span<const std::uint32_t> permutation, PathBoundsResult& result)
+{
+  auto scope = arena.scope();
+  DeviceObject<IterationParameters<Toy>> deviceParameters;
+  DeviceObject<LayerRowMap<Toy>> deviceSources;
+  DeviceColumns<TrackletT> deviceTracklets;
+  DeviceColumns<TripletT> deviceTriplets;
+  DeviceSpan<std::uint32_t> trackletOffsets;
+  DeviceSpan<std::uint32_t> tripletOffsets;
+  DeviceSpan<std::uint32_t> firsts;
+  if (!deviceParameters.allocate(arena) || !deviceSources.allocate(arena) || !deviceTracklets.allocate(arena, tracklets.size()) || !deviceTriplets.allocate(arena, triplets.size()) || !trackletOffsets.allocate(arena, tracklets.elementCount() + 1U) || !tripletOffsets.allocate(arena, triplets.elementCount() + 1U) || !firsts.allocate(arena, permutation.size())) {
+    return StageStatus::kOutOfMemory;
+  }
+  uploadObject(parameters, deviceParameters, stream);
+  uploadObject(sources, deviceSources, stream);
+  upload<TrackletT>(tracklets.view(), tracklets.size(), deviceTracklets, stream);
+  upload<TripletT>(triplets.view(), triplets.size(), deviceTriplets, stream);
+  upload(tracklets.offsets().data(), trackletOffsets, tracklets.elementCount() + 1U, stream);
+  upload(triplets.offsets().data(), tripletOffsets, triplets.elementCount() + 1U, stream);
+  upload(permutation.data(), firsts, permutation.size(), stream);
+  glue::DevicePathBounds measurements;
+  glue::DevicePathBounds accepted;
+  auto status = glue::trackletPaths<Toy>(runtime, arena, stream, deviceParameters.data(), sources, std::as_const(deviceTracklets).view(), trackletOffsets.data(), measurements);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  DeviceSpan<std::uint32_t> pruned;
+  std::uint32_t size = 0U;
+  status = glue::permutation<Toy>(runtime, arena, stream, std::as_const(deviceTracklets).view(), tracklets.size(), deviceParameters.data(), deviceSources.data(), pruned, size, trackletOffsets.data(), measurements.view(parameters.minClusters));
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  status = glue::tripletPaths<Toy>(runtime, arena, stream, deviceParameters.data(), sources, std::as_const(deviceTracklets).view(), tracklets.size(), trackletOffsets.data(), std::as_const(deviceTriplets).view(), tripletOffsets.data(), firsts.data(), permutation.size(), accepted);
+  if (status == StageStatus::kComplete) {
+    result.measurementPrefix.resize(sources.size());
+    result.measurementSuffix.resize(sources.size());
+    result.tripletPrefix.resize(tracklets.size());
+    result.tripletSuffix.resize(tracklets.size());
+    result.permutation.resize(size);
+    download(measurements.prefix, result.measurementPrefix.data(), sources.size(), stream);
+    download(measurements.suffix, result.measurementSuffix.data(), sources.size(), stream);
+    download(accepted.prefix, result.tripletPrefix.data(), tracklets.size(), stream);
+    download(accepted.suffix, result.tripletSuffix.data(), tracklets.size(), stream);
+    download(pruned, result.permutation.data(), size, stream);
+  }
+  stream.synchronize();
+  return status;
+}
+
+StageStatus runEndIndex(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, const StageOutput<TripletT>& triplets, std::uint32_t trackletCount, std::vector<std::uint32_t>& offsets, std::vector<std::uint32_t>& indices)
+{
+  auto scope = arena.scope();
+  DeviceColumns<TripletT> deviceTriplets;
+  if (!deviceTriplets.allocate(arena, triplets.size())) {
+    return StageStatus::kOutOfMemory;
+  }
+  upload<TripletT>(triplets.view(), triplets.size(), deviceTriplets, stream);
+  DeviceSpan<std::uint32_t> deviceOffsets;
+  DeviceSpan<std::uint32_t> deviceIndices;
+  const auto status = glue::endIndex(runtime, arena, stream, std::as_const(deviceTriplets).view(), triplets.size(), trackletCount, deviceOffsets, deviceIndices);
+  if (status == StageStatus::kComplete) {
+    offsets.resize(std::size_t{trackletCount} + 1U);
+    indices.resize(triplets.size());
+    download(deviceOffsets, offsets.data(), offsets.size(), stream);
+    download(deviceIndices, indices.data(), indices.size(), stream);
+  }
+  stream.synchronize();
+  return status;
+}
+
+StageStatus runChained(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, std::span<const std::uint32_t> neighbourOffsets, std::vector<std::uint32_t>& result)
+{
+  auto scope = arena.scope();
+  DeviceSpan<std::uint32_t> deviceOffsets;
+  if (neighbourOffsets.empty()) {
+    throw std::invalid_argument("neighbour offsets have one entry more than the triplets");
+  }
+  if (!deviceOffsets.allocate(arena, neighbourOffsets.size())) {
+    return StageStatus::kOutOfMemory;
+  }
+  upload(neighbourOffsets.data(), deviceOffsets, neighbourOffsets.size(), stream);
+  DeviceSpan<std::uint32_t> chained;
+  std::uint32_t size = 0U;
+  const auto triplets = static_cast<std::uint32_t>(neighbourOffsets.size() - 1U);
+  const auto status = glue::chained(runtime, arena, stream, deviceOffsets.data(), triplets, chained, size);
+  if (status == StageStatus::kComplete) {
+    result.resize(size);
+    download(chained, result.data(), size, stream);
+  }
+  stream.synchronize();
+  return status;
+}
+
+struct SelectByMask {
+  const std::uint8_t* mask = nullptr;
+  GPUdi() bool operator()(std::uint32_t index) const { return mask[index] != 0U; }
+};
+
+StageStatus runSelectIndices(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, std::span<const std::uint8_t> mask, std::vector<std::uint32_t>& result)
+{
+  auto scope = arena.scope();
+  DeviceSpan<std::uint8_t> deviceMask;
+  if (!deviceMask.allocate(arena, mask.size())) {
+    return StageStatus::kOutOfMemory;
+  }
+  upload(mask.data(), deviceMask, mask.size(), stream);
+  DeviceSpan<std::uint32_t> selected;
+  std::uint32_t count = 0U;
+  const auto status = algorithms::selectIndices(runtime, arena, stream, static_cast<std::uint32_t>(mask.size()), SelectByMask{.mask = deviceMask.data()}, selected, count);
+  if (status == StageStatus::kComplete) {
+    result.resize(count);
+    download(selected, result.data(), count, stream);
+  }
+  stream.synchronize();
+  return status;
+}
+
+template <typename T>
+StageStatus runScan(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, std::span<const T> input, std::vector<T>& result)
+{
+  auto scope = arena.scope();
+  DeviceSpan<T> deviceInput;
+  DeviceSpan<T> deviceOutput;
+  if (!deviceInput.allocate(arena, input.size()) || !deviceOutput.allocate(arena, input.size())) {
+    return StageStatus::kOutOfMemory;
+  }
+  upload(input.data(), deviceInput, input.size(), stream);
+  const auto status = algorithms::exclusiveScan(runtime, arena, stream, std::as_const(deviceInput).data(), deviceOutput.data(), input.size());
+  if (status == StageStatus::kComplete) {
+    result.resize(input.size());
+    download(deviceOutput, result.data(), input.size(), stream);
+  }
+  stream.synchronize();
+  return status;
+}
+
+StageStatus runScan32(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, std::span<const std::uint32_t> input, std::vector<std::uint32_t>& result) { return runScan(runtime, stream, arena, input, result); }
+
+StageStatus runScan64(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, std::span<const std::uint64_t> input, std::vector<std::uint64_t>& result) { return runScan(runtime, stream, arena, input, result); }
+
+/// One pass of the chain: value i rises to value i-1 plus one.
+struct ChainStep {
+  std::uint32_t* values = nullptr;
+  std::uint32_t threshold = 0U;
+  std::uint32_t* flags = nullptr;
+  GPUdi() void operator()(std::uint32_t element) const
+  {
+    const std::uint32_t index = element + 1U;
+    const std::uint32_t previous = *static_cast<const volatile std::uint32_t*>(values + index - 1U);
+    if (previous == 0U) {
+      return; // not reached yet
+    }
+    const std::uint32_t raised = previous + 1U;
+    if (*static_cast<const volatile std::uint32_t*>(values + index) < raised) {
+      o2::gpu::CAMath::AtomicMax(values + index, raised);
+      o2::gpu::CAMath::AtomicMax(flags, 1U);
+    }
+    if (raised > threshold) {
+      o2::gpu::CAMath::AtomicMax(flags + 1, 1U);
+    }
+  }
+};
+
+StageStatus runSweepChain(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, std::uint32_t length, std::uint32_t threshold, std::uint32_t maxChangingSweeps, std::vector<std::uint32_t>& values, std::array<std::uint32_t, 2>& flags, std::uint32_t& changingSweeps)
+{
+  if (length == 0U) {
+    throw std::invalid_argument("a chain has at least one value");
+  }
+  auto scope = arena.scope();
+  DeviceSpan<std::uint32_t> deviceValues;
+  if (!deviceValues.allocate(arena, length)) {
+    return StageStatus::kOutOfMemory;
+  }
+  runtime.fill(deviceValues.data(), 0U, std::size_t{length} * sizeof(std::uint32_t), stream);
+  const std::uint32_t one = 1U;
+  upload(&one, deviceValues, 1U, stream);
+  const auto swept = algorithms::sweepToFixedPoint<2U>(runtime, arena, stream, maxChangingSweeps, [&](std::uint32_t* deviceFlags) { algorithms::forEach(runtime, stream, length - 1U, ChainStep{.values = deviceValues.data(), .threshold = threshold, .flags = deviceFlags}); });
+  flags = swept.flags;
+  changingSweeps = swept.changingSweeps;
+  values.resize(length);
+  download(deviceValues, values.data(), length, stream);
+  stream.synchronize();
+  return swept.status;
+}
+
+StageStatus runCopyColumns(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, const StageOutput<TrackletT>& source, std::size_t sourceOffset, std::size_t destinationRows, std::size_t destinationOffset, std::size_t rows, std::vector<Tracklet>& destination)
+{
+  auto scope = arena.scope();
+  DeviceColumns<TrackletT> from;
+  DeviceColumns<TrackletT> to;
+  if (!from.allocate(arena, source.size()) || !to.allocate(arena, destinationRows)) {
+    return StageStatus::kOutOfMemory;
+  }
+  upload<TrackletT>(source.view(), source.size(), from, stream);
+  to.view().apply([&](auto*... column) { (runtime.fill(column, 0xFFU, destinationRows * sizeof(*column), stream), ...); });
+  copyColumns(from, sourceOffset, to, destinationOffset, rows, stream);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  BoundedColumns<TrackletT> host;
+  host.setMemoryResource(pool.get());
+  download(to, host, destinationRows, stream);
+  stream.synchronize();
+  destination.resize(destinationRows);
+  const auto view = host.view();
+  for (std::size_t row = 0; row < destinationRows; ++row) {
+    destination[row] = Tracklet{.source = view.source[row], .target = view.target[row], .link = view.link[row], .lambda = view.lambda[row], .phi = view.phi[row]};
+  }
+  return StageStatus::kComplete;
+}
+
+bool runGatherChunks(DeviceRuntime& /*runtime*/, DeviceStream& stream, DeviceArena& arena, const StageOutput<TrackletT>& source, std::span<const std::size_t> chunkRows, std::vector<Tracklet>& gathered)
+{
+  auto base = arena.scope();
+  DeviceColumns<TrackletT> from;
+  if (!from.allocate(arena, source.size())) {
+    return false;
+  }
+  upload<TrackletT>(source.view(), source.size(), from, stream);
+  auto chunksScope = arena.scope(ArenaEnd::kScratch);
+  DeviceColumnChunks<TrackletT> chunks;
+  std::size_t at = 0U;
+  for (const std::size_t rows : chunkRows) {
+    if (!chunks.append(arena, ArenaEnd::kScratch, from, at, rows, stream)) {
+      return false;
+    }
+    at += rows;
+  }
+  DeviceColumns<TrackletT> to;
+  if (!to.allocate(arena, chunks.rows())) {
+    return false;
+  }
+  chunks.gather(to, 0U, stream);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  BoundedColumns<TrackletT> host;
+  host.setMemoryResource(pool.get());
+  download(to, host, chunks.rows(), stream);
+  stream.synchronize();
+  gathered.resize(chunks.rows());
+  const auto view = host.view();
+  for (std::size_t row = 0; row < gathered.size(); ++row) {
+    gathered[row] = Tracklet{.source = view.source[row], .target = view.target[row], .link = view.link[row], .lambda = view.lambda[row], .phi = view.phi[row]};
+  }
+  return true;
+}
+
+GPUg() void readToyFlatObject(const ToyFlatObject* object, std::int32_t* values)
+{
+  for (std::int32_t index = (blockIdx.x * blockDim.x) + threadIdx.x; index < object->count(); index += blockDim.x * gridDim.x) {
+    values[index] = object->value(index);
+  }
+}
+
+bool runFlatObject(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, const ToyFlatObject& host, std::vector<std::int32_t>& readBack, std::vector<std::int32_t>& moved)
+{
+  DeviceFlatObject<ToyFlatObject> object;
+  const auto count = static_cast<std::size_t>(host.count());
+  // \a pad bytes before the object: the second upload lands elsewhere, its image re-targeted.
+  const auto read = [&](std::size_t pad, std::vector<std::int32_t>& values) {
+    auto scope = arena.scope();
+    DeviceSpan<std::byte> before;
+    if ((pad > 0U && !before.allocate(arena, pad)) || !object.upload(arena, host, stream)) {
+      return false;
+    }
+    DeviceSpan<std::int32_t> out;
+    if (!out.allocate(arena, count)) {
+      return false;
+    }
+    readToyFlatObject<<<4U, 64U, 0U, nativeStream(runtime, stream)>>>(object.data(), out.data());
+    checkLaunch();
+    values.resize(count);
+    download(out, values.data(), count, stream);
+    stream.synchronize();
+    object.release();
+    return true;
+  };
+  return read(0U, readBack) && read(1024U, moved);
+}
+
+struct CountAtLevel {
+  TrackletConstView tracklets;
+  TripletConstView triplets;
+  const std::uint32_t* offsets = nullptr;
+  const std::uint32_t* from = nullptr;
+  OrderedRoadCounts counts;
+  std::uint32_t level = 0U;
+
+  GPUdi() void operator()(std::uint32_t element) const
+  {
+    if (triplets.level[element] != level) {
+      return;
+    }
+    counts.base(element, tracklets, triplets);
+    if (level > 1U) {
+      std::uint64_t sum = 0U;
+      for (auto edge = offsets[element]; edge < offsets[element + 1U]; ++edge) {
+        if (triplets.level[from[edge]] + 1U == level) {
+          counts.add(from[edge], sum);
+        }
+      }
+      counts.finish(element, sum);
+    }
+  }
+};
+
+StageStatus runOrderedRoadGlue(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, const IterationParameters<Toy>& parameters, const StageOutput<TrackletT>& tracklets, const StageOutput<TripletT>& triplets, const StageOutput<NeighbourT>& neighbours, const std::array<MeasurementRange, kToyLayers>& core, RoadGlueResult& result)
+{
+  auto scope = arena.scope();
+  const auto tripletCount = triplets.size();
+  DeviceObject<IterationParameters<Toy>> deviceParameters;
+  DeviceColumns<TrackletT> deviceTracklets;
+  DeviceColumns<TripletT> deviceTriplets;
+  DeviceSpan<std::uint32_t> offsets;
+  DeviceColumns<NeighbourT> from;
+  DeviceSpan<MeasurementRange> deviceCore;
+  if (!deviceParameters.allocate(arena) || !deviceTracklets.allocate(arena, tracklets.size()) || !deviceTriplets.allocate(arena, tripletCount) || !offsets.allocate(arena, neighbours.offsets().size()) || !from.allocate(arena, neighbours.size()) || !deviceCore.allocate(arena, kToyLayers)) {
+    return StageStatus::kOutOfMemory;
+  }
+  uploadObject(parameters, deviceParameters, stream);
+  upload<TrackletT>(tracklets.view(), tracklets.size(), deviceTracklets, stream);
+  upload<TripletT>(triplets.view(), tripletCount, deviceTriplets, stream);
+  upload(neighbours.offsets().data(), offsets, neighbours.offsets().size(), stream);
+  upload<NeighbourT>(neighbours.view(), neighbours.size(), from, stream);
+  upload(core.data(), deviceCore, kToyLayers, stream);
+
+  road_glue::OrderedCounts counts;
+  auto status = counts.prepare(runtime, arena, stream, tripletCount);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  // Deliberately use supplied final levels, not neighbour fitting or the
+  // production layer boundaries. Replay models a complete staging retry.
+  std::uint32_t highest = 0U;
+  for (std::uint32_t element = 0U; element < tripletCount; ++element) {
+    highest = std::max(highest, triplets.view().level[element]);
+  }
+  for (int attempt = 0; attempt < 2; ++attempt) {
+    for (std::uint32_t level = 1U; level <= highest; ++level) {
+      algorithms::forEach(runtime, stream, tripletCount, CountAtLevel{std::as_const(deviceTracklets).view(), std::as_const(deviceTriplets).view(), offsets.data(), std::as_const(from).view().from, counts.view(road_glue::linkSourcesOf(deviceParameters.data()), deviceCore.data()), level});
+    }
+  }
+  status = counts.summarize(runtime, stream, std::as_const(deviceTriplets).view(), tripletCount, result.chained);
+  const DeviceSpan<std::uint32_t>& successorAbove = counts.successorAbove;
+  const DeviceSpan<std::uint32_t>& roads = counts.roads;
+  if (status != StageStatus::kComplete) {
+    stream.synchronize();
+    return status;
+  }
+  DeviceSpan<std::uint32_t> starts;
+  std::uint32_t startCount = 0U;
+  status = road_glue::roadStarts(runtime, arena, stream, std::as_const(deviceTracklets).view(), std::as_const(deviceTriplets).view(), tripletCount, successorAbove.data(), roads.data(), road_glue::roadStartRuleOf(deviceParameters.data(), parameters), starts, startCount);
+  if (status != StageStatus::kComplete) {
+    stream.synchronize();
+    return status;
+  }
+  DeviceSpan<std::uint32_t> roadOffsets;
+  std::uint32_t total = 0U;
+  status = road_glue::roadOffsets(runtime, arena, stream, starts.data(), startCount, roads.data(), roadOffsets, total);
+  if (status != StageStatus::kComplete) {
+    stream.synchronize();
+    return status;
+  }
+  result.successorAbove.resize(tripletCount);
+  result.roads.resize(tripletCount);
+  result.starts.resize(startCount);
+  result.offsets.resize(std::size_t{startCount} + 1U);
+  download(successorAbove, result.successorAbove.data(), tripletCount, stream);
+  download(roads, result.roads.data(), tripletCount, stream);
+  download(starts, result.starts.data(), startCount, stream);
+  download(roadOffsets, result.offsets.data(), result.offsets.size(), stream);
+  stream.synchronize();
+  return StageStatus::kComplete;
+}
+
+StageStatus runSelectionGlue(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, const ToyBarrel8Records& records, std::span<const std::uint8_t> mask, std::uint32_t sharedInnermost, SelectionGlueResult& result)
+{
+  result = {};
+  auto scope = arena.scope();
+  DeviceColumns<SelectionRecordOf<kToyBarrel8Clusters>::RecordT> deviceRecords;
+  DeviceSpan<std::uint8_t> deviceMask;
+  const auto count = static_cast<std::uint32_t>(records.size());
+  if (!deviceRecords.allocate(arena, count) || !deviceMask.allocate(arena, mask.size())) {
+    return StageStatus::kOutOfMemory;
+  }
+  upload<SelectionRecordOf<kToyBarrel8Clusters>::RecordT>(records.view(), count, deviceRecords, stream);
+  upload(mask.data(), deviceMask, mask.size(), stream);
+  selection_glue::Selected selected;
+  const StageStatus status = selection_glue::select<kToyBarrel8Clusters>(runtime, arena, stream, std::as_const(deviceRecords).view(), count, deviceMask.data(), static_cast<std::uint32_t>(mask.size()), sharedInnermost, selected);
+  stream.synchronize();
+  result.scratchAfter = arena.used(ArenaEnd::kScratch);
+  if (status != StageStatus::kComplete) {
+    return status;
+  }
+  result.ranked.resize(selected.unique);
+  result.selected.resize(selected.tracks);
+  result.mask.resize(mask.size());
+  if (selected.unique != 0U) {
+    download(selected.ranked, result.ranked.data(), selected.unique, stream);
+  }
+  if (selected.tracks != 0U) {
+    download(selected.selected, result.selected.data(), selected.tracks, stream);
+  }
+  download(deviceMask, result.mask.data(), mask.size(), stream);
+  stream.synchronize();
+  result.duplicates = selected.duplicates;
+  result.mismatches = selected.mismatches;
+  result.rounds = selected.rounds;
+  result.readbacks = selected.readbacks;
+  return StageStatus::kComplete;
+}
+
+GPUg() void matBudgetKernel(const o2::base::MatLayerCylSet* lut, const float* segments, std::uint32_t count, float* result)
+{
+  for (std::uint32_t i = (blockIdx.x * blockDim.x) + threadIdx.x; i < count; i += blockDim.x * gridDim.x) {
+    const float* s = segments + (6U * i);
+    const auto budget = lut->getMatBudget(s[0], s[1], s[2], s[3], s[4], s[5]);
+    result[(3U * i) + 0U] = budget.meanRho;
+    result[(3U * i) + 1U] = budget.meanX2X0;
+    result[(3U * i) + 2U] = budget.length;
+  }
+}
+
+StageStatus runMatBudgets(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, const o2::base::MatLayerCylSet& lut, std::span<const std::array<float, 6>> segments, std::vector<std::array<float, 3>>& result)
+{
+  auto scope = arena.scope();
+  DeviceFlatObject<o2::base::MatLayerCylSet> device;
+  DeviceSpan<float> deviceSegments;
+  DeviceSpan<float> deviceResult;
+  const auto count = static_cast<std::uint32_t>(segments.size());
+  if (!device.upload(arena, lut, stream) || !deviceSegments.allocate(arena, 6U * std::size_t{count}) || !deviceResult.allocate(arena, 3U * std::size_t{count})) {
+    return StageStatus::kOutOfMemory;
+  }
+  upload(segments.data()->data(), deviceSegments, 6U * std::size_t{count}, stream);
+  const auto shape = launchFor(count);
+  matBudgetKernel<<<shape.blocks, shape.threads, 0U, nativeStream(runtime, stream)>>>(device.data(), deviceSegments.data(), count, deviceResult.data());
+  checkLaunch();
+  result.resize(count);
+  download(deviceResult, result.data()->data(), 3U * std::size_t{count}, stream);
+  stream.synchronize();
+  return StageStatus::kComplete;
+}
+
+/// `lane_group_script::run` for one item, its group's lanes in step.
+struct LaneGroupBody {
+  std::uint64_t* folded = nullptr;
+  template <typename Group>
+  GPUdi() void together(std::uint32_t item, const Group& group) const
+  {
+    const auto words = lane_group_script::run(group, item);
+    const std::size_t at = 2U * ((std::size_t{item} * Group::kLanes) + group.lane());
+    folded[at] = words[0];
+    folded[at + 1U] = words[1];
+  }
+};
+
+StageStatus runLaneGroups(DeviceRuntime& runtime, DeviceStream& stream, DeviceArena& arena, std::uint32_t lanes, std::uint32_t items, std::vector<std::uint64_t>& result)
+{
+  auto scope = arena.scope();
+  DeviceSpan<std::uint64_t> folded;
+  const std::size_t words = 2U * std::size_t{items} * lanes;
+  if (!folded.allocate(arena, words)) {
+    return StageStatus::kOutOfMemory;
+  }
+  const LaneGroupBody body{.folded = folded.data()};
+  switch (lanes) {
+    case 2U:
+      algorithms::forEachGroup<2U>(runtime, stream, items, body);
+      break;
+    case 4U:
+      algorithms::forEachGroup<4U>(runtime, stream, items, body);
+      break;
+    case 8U:
+      algorithms::forEachGroup<8U>(runtime, stream, items, body);
+      break;
+    case 16U:
+      algorithms::forEachGroup<16U>(runtime, stream, items, body);
+      break;
+    case 32U:
+      algorithms::forEachGroup<32U>(runtime, stream, items, body);
+      break;
+    case 64U:
+      if constexpr (kWarpSize == 64) {
+        algorithms::forEachGroup<64U>(runtime, stream, items, body);
+        break;
+      }
+      [[fallthrough]];
+    default:
+      throw std::invalid_argument("runLaneGroups: no group of " + std::to_string(lanes) + " lanes in a warp of " + std::to_string(kWarpSize));
+  }
+  result.resize(words);
+  download(folded, result.data(), words, stream);
+  stream.synchronize();
+  return StageStatus::kComplete;
+}
+
+} // namespace
+} // namespace o2::gtrk::gpu::GTRK_BACKEND_NAMESPACE
+
+namespace o2::gtrk
+{
+#ifdef GTRK_BACKEND_HIP
+const DeviceTestEntry* testKernelsHIP()
+{
+  static const DeviceTestEntry entry{
+    .trig = &gpu::hip::runTrig,
+    .runSynthetic = &gpu::hip::runSynthetic,
+    .runSyntheticListed = &gpu::hip::runSyntheticListed,
+    .runFlatSynthetic = &gpu::hip::runFlatSynthetic,
+    .makeToyBarrel8Tracker = &gpu::hip::makeToyBarrel8Tracker,
+    .permutation = &gpu::hip::runPermutation,
+    .pathBounds = &gpu::hip::runPathBounds,
+    .endIndex = &gpu::hip::runEndIndex,
+    .chained = &gpu::hip::runChained,
+    .selectIndices = &gpu::hip::runSelectIndices,
+    .scan32 = &gpu::hip::runScan32,
+    .scan64 = &gpu::hip::runScan64,
+    .sweepChain = &gpu::hip::runSweepChain,
+    .copyColumns = &gpu::hip::runCopyColumns,
+    .gatherChunks = &gpu::hip::runGatherChunks,
+    .flatObject = &gpu::hip::runFlatObject,
+    .matBudgets = &gpu::hip::runMatBudgets,
+    .selectionGlue = &gpu::hip::runSelectionGlue,
+    .propagation = &gpu::hip::runPropagation,
+    .laneGroups = &gpu::hip::runLaneGroups,
+    .orderedRoadGlue = &gpu::hip::runOrderedRoadGlue,
+  };
+  return &entry;
+}
+#else
+const DeviceTestEntry* testKernelsCUDA()
+{
+  static const DeviceTestEntry entry{
+    .trig = &gpu::cuda::runTrig,
+    .runSynthetic = &gpu::cuda::runSynthetic,
+    .runSyntheticListed = &gpu::cuda::runSyntheticListed,
+    .runFlatSynthetic = &gpu::cuda::runFlatSynthetic,
+    .makeToyBarrel8Tracker = &gpu::cuda::makeToyBarrel8Tracker,
+    .permutation = &gpu::cuda::runPermutation,
+    .pathBounds = &gpu::cuda::runPathBounds,
+    .endIndex = &gpu::cuda::runEndIndex,
+    .chained = &gpu::cuda::runChained,
+    .selectIndices = &gpu::cuda::runSelectIndices,
+    .scan32 = &gpu::cuda::runScan32,
+    .scan64 = &gpu::cuda::runScan64,
+    .sweepChain = &gpu::cuda::runSweepChain,
+    .copyColumns = &gpu::cuda::runCopyColumns,
+    .gatherChunks = &gpu::cuda::runGatherChunks,
+    .flatObject = &gpu::cuda::runFlatObject,
+    .matBudgets = &gpu::cuda::runMatBudgets,
+    .selectionGlue = &gpu::cuda::runSelectionGlue,
+    .propagation = &gpu::cuda::runPropagation,
+    .laneGroups = &gpu::cuda::runLaneGroups,
+    .orderedRoadGlue = &gpu::cuda::runOrderedRoadGlue,
+  };
+  return &entry;
+}
+#endif
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/device/DeviceTestKernels.h b/Detectors/GenericTracking/tracking/test/device/DeviceTestKernels.h
new file mode 100644
index 0000000000000..663ae05e7e6a5
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/DeviceTestKernels.h
@@ -0,0 +1,315 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+// The device kernels the device tests run, one entry per backend.
+
+#ifndef GTRK_TEST_DEVICE_DEVICETESTKERNELS_H_
+#define GTRK_TEST_DEVICE_DEVICETESTKERNELS_H_
+
+#include "ToyBarrel8.h"
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/Material.h"
+#include "GenericTracking/Tracking/Neighbour.h"
+#include "GenericTracking/Tracking/LayerRowMap.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/Triplet.h"
+#include "GenericTracking/Tracking/TripletCut.h"
+#include "GenericTracking/Tracking/Trig.h"
+#include "GenericTracking/Tracking/GPU/DeviceTracker.h"
+
+#include "SyntheticStage.h"
+
+#include "FlatObject.h"
+#include "UniformMaterial.h"
+
+#include <cstddef>
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+/// Every function of Trig.h at one argument pair, in both precisions: in
+/// the deterministic build the host's bits (PortableMath.h).
+struct TrigRow {
+  double sinD = 0.;
+  double cosD = 0.;
+  double sincosSinD = 0.;
+  double sincosCosD = 0.;
+  double asinD = 0.;
+  double atanD = 0.;
+  double atan2D = 0.;
+  float sinF = 0.F;
+  float cosF = 0.F;
+  float sincosSinF = 0.F;
+  float sincosCosF = 0.F;
+  float asinF = 0.F;
+  float atanF = 0.F;
+  float atan2F = 0.F;
+  float logF = 0.F;
+};
+
+/// TrigRow of (y, x), on the host or, in a kernel, on the device.
+GPUhdi() TrigRow trigRow(double y, double x)
+{
+  TrigRow row;
+  row.sinD = sinOf(y);
+  row.cosD = cosOf(y);
+  sincosOf(y, row.sincosSinD, row.sincosCosD);
+  row.asinD = asinOf(y);
+  row.atanD = atanOf(y);
+  row.atan2D = atan2Of(y, x);
+  const auto yF = static_cast<float>(y);
+  const auto xF = static_cast<float>(x);
+  row.sinF = sinOf(yF);
+  row.cosF = cosOf(yF);
+  sincosOf(yF, row.sincosSinF, row.sincosCosF);
+  row.asinF = asinOf(yF);
+  row.atanF = atanOf(yF);
+  row.atan2F = atan2Of(yF, xF);
+  row.logF = logOf(xF);
+  return row;
+}
+
+/// What a flat synthetic run reports:
+/// the run's report and the elements it listed.
+struct FlatRunInfo {
+  FlatRunReport report;
+  std::uint32_t listed = 0U;
+};
+
+/// What a synthetic GpuStage run reports besides its output.
+struct SyntheticRunInfo {
+  bool predictionMissed = false;
+  std::size_t capacityAfter = 0U; ///< the staging capacity the stage keeps
+  std::size_t scratchAfter = 0U;  ///< the arena's scratch end once run returned
+  std::uint32_t listed = 0U;      ///< the elements a listed run generated
+};
+
+/// A small O2 FlatObject for the tests of DeviceFlatObject: \a count values
+/// in its flat buffer, reached through a pointer the relocation must fix. ITS
+/// host methods exist outside GPU translation units only, as FlatObject's do.
+class ToyFlatObject : public o2::gpu::FlatObject
+{
+ public:
+#ifndef GPUCA_GPUCODE
+  void construct(std::span<const std::int32_t> values)
+  {
+    startConstruction();
+    mCount = static_cast<std::int32_t>(values.size());
+    finishConstruction(static_cast<std::int32_t>(values.size_bytes()));
+    mValues = reinterpret_cast<std::int32_t*>(mFlatBufferPtr); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast): the flat buffer holds them
+    std::ranges::copy(values, mValues);
+  }
+  void cloneFromObject(const ToyFlatObject& object, char* newFlatBufferPtr)
+  {
+    o2::gpu::FlatObject::cloneFromObject(object, newFlatBufferPtr);
+    mCount = object.mCount;
+    mValues = reinterpret_cast<std::int32_t*>(mFlatBufferPtr); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+  }
+  void setFutureBufferAddress(char* futureFlatBufferPtr)
+  {
+    mValues = reinterpret_cast<std::int32_t*>(futureFlatBufferPtr); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+    o2::gpu::FlatObject::setFutureBufferAddress(futureFlatBufferPtr);
+  }
+  void setActualBufferAddress(char* actualFlatBufferPtr)
+  {
+    mValues = reinterpret_cast<std::int32_t*>(actualFlatBufferPtr); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+    o2::gpu::FlatObject::setActualBufferAddress(actualFlatBufferPtr);
+  }
+#endif
+  [[nodiscard]] GPUhdi() std::int32_t count() const { return mCount; }
+  [[nodiscard]] GPUhdi() std::int32_t value(std::int32_t index) const { return mValues[index]; }
+
+ private:
+  std::int32_t* mValues = nullptr;
+  std::int32_t mCount = 0;
+};
+
+/// Defined in DeviceTestHost.cxx, a host translation unit.
+template <>
+struct FlatObjectPort<ToyFlatObject> {
+  static std::size_t bufferBytes(const ToyFlatObject& source);
+  static void image(const ToyFlatObject& source, char* futureBuffer, FlatObjectImage& image);
+};
+
+using ToyBarrel8Det = detectors::ToyBarrel8;
+inline constexpr std::size_t kToyBarrel8Layers = static_cast<std::size_t>(Detector<ToyBarrel8Det>::nLayers);
+
+/// What the road glue left, read back.
+struct RoadGlueResult {
+  std::vector<std::uint32_t> successorAbove;
+  std::vector<std::uint32_t> roads;
+  std::vector<std::uint32_t> starts;
+  std::vector<std::uint32_t> offsets;
+  std::uint32_t chained = 0U;
+};
+
+inline constexpr std::size_t kToyBarrel8Clusters = maxChainLayers<ToyBarrel8Det>;
+using ToyBarrel8Records = BoundedColumns<SelectionRecordOf<kToyBarrel8Clusters>::RecordT>;
+
+/// What the selection glue left, read back.
+struct SelectionGlueResult {
+  std::vector<std::uint32_t> ranked;
+  std::vector<std::uint32_t> selected;
+  std::vector<std::uint8_t> mask;
+  std::uint32_t duplicates = 0U;
+  std::uint32_t mismatches = 0U;
+  std::uint32_t rounds = 0U;
+  std::uint32_t readbacks = 0U;
+  std::size_t scratchAfter = 0U; ///< the arena's scratch end once the selection returned
+};
+
+} // namespace o2::gtrk
+namespace o2::base
+{
+class MatLayerCylSet;
+}
+namespace o2::gtrk
+{
+
+struct PathBoundsResult {
+  std::vector<std::uint8_t> measurementPrefix;
+  std::vector<std::uint8_t> measurementSuffix;
+  std::vector<std::uint8_t> tripletPrefix;
+  std::vector<std::uint8_t> tripletSuffix;
+  std::vector<std::uint32_t> permutation;
+};
+
+struct PropagationProbe {
+  Propagator prop;
+  BoundTrackState before;
+  TrackingSurface from;
+  TrackingSurface to;
+  PropagationDirection direction = PropagationDirection::kForward;
+};
+struct PropagationAnswer {
+  BoundTrackState after;
+  PropagationResult result;
+};
+
+/// The lane groups' script: per item, a group of
+/// lanes takes `trips` votes and broadcasts, and on odd items nested ones
+/// inside each, so that the groups of one warp take different paths and
+/// some none at all. Each lane folds what the collectives give it into two
+/// words; the host knows what every lane must get.
+namespace lane_group_script
+{
+struct Payload {
+  std::uint32_t a = 0U;
+  std::uint32_t b = 0U;
+  std::uint32_t c = 0U;
+};
+GPUhdi() std::uint32_t trips(std::uint32_t item) { return item % 5U; }
+GPUhdi() bool vote(std::uint32_t lane, std::uint32_t trip, std::uint32_t item) { return ((lane * 7U) + (trip * 13U) + item) % 3U == 0U; }
+GPUhdi() std::uint32_t source(std::uint32_t trip, std::uint32_t item, std::uint32_t lanes) { return (trip + item) % lanes; }
+GPUhdi() Payload payload(std::uint32_t lane, std::uint32_t trip, std::uint32_t item) { return {.a = (lane * 1000U) + trip, .b = item, .c = (trip * 3U) + lane}; }
+GPUhdi() std::uint32_t innerTrips(std::uint32_t trip, std::uint32_t item) { return item % 2U == 1U ? (item + trip) % 3U : 0U; }
+GPUhdi() bool innerVote(std::uint32_t lane, std::uint32_t inner) { return lane % (inner + 2U) == 0U; }
+GPUhdi() std::uint32_t innerValue(std::uint32_t lane, std::uint32_t inner) { return (lane * 31U) + inner; }
+GPUhdi() std::uint32_t innerSource(std::uint32_t inner, std::uint32_t trip, std::uint32_t lanes) { return (inner + trip) % lanes; }
+
+/// The script on \a group's lane for \a item: the folded ballots and the
+/// folded broadcasts.
+template <typename Group>
+GPUhdi() std::array<std::uint64_t, 2> run(const Group& group, std::uint32_t item)
+{
+  const std::uint32_t lane = group.lane();
+  std::array<std::uint64_t, 2> folded{};
+  for (std::uint32_t trip = 0U; trip < trips(item); ++trip) {
+    folded[0] ^= group.ballot(vote(lane, trip, item)) * (trip + 1U);
+    const auto got = group.broadcast(payload(lane, trip, item), source(trip, item, Group::kLanes));
+    folded[1] += got.a + (7U * got.b) + (13U * got.c);
+    for (std::uint32_t inner = 0U; inner < innerTrips(trip, item); ++inner) {
+      folded[0] ^= group.ballot(innerVote(lane, inner)) << (inner + 1U);
+      folded[1] += group.broadcast(innerValue(lane, inner), innerSource(inner, trip, Group::kLanes));
+    }
+  }
+  return folded;
+}
+} // namespace lane_group_script
+
+struct DeviceTestEntry {
+  /// trigRow of every (ys[i], xs[i]) on the device.
+  void (*trig)(DeviceRuntime&, DeviceStream&, const double* ys, const double* xs, TrigRow* rows, std::uint32_t count) = nullptr;
+  /// GpuStage<TrackletT> over the synthetic generator, its output prepared in
+  /// the caller's scope of \a arena and, if complete, downloaded to \a result.
+  StageStatus (*runSynthetic)(DeviceRuntime&, DeviceStream&, DeviceArena&, synthetic::Kind, std::uint32_t elements, std::size_t stagingCapacity, StageOutput<TrackletT>& result, SyntheticRunInfo& info) = nullptr;
+  /// The same over a list: every element that emits and every third of the
+  /// rest (`GpuStage::run` with a list).
+  StageStatus (*runSyntheticListed)(DeviceRuntime&, DeviceStream&, DeviceArena&, synthetic::Kind, std::uint32_t elements, std::size_t stagingCapacity, StageOutput<TrackletT>& result, SyntheticRunInfo& info) = nullptr;
+  /// The flat form (`flat::runFlat`) over the
+  /// synthetic candidates of \a kind with `synthetic::Accept{divisor}`: all
+  /// the elements, or the listed ones (as `runSyntheticListed` lists them);
+  /// chunks of at most \a maxChunkPairs pairs (0: the arena decides).
+  StageStatus (*runFlatSynthetic)(DeviceRuntime&, DeviceStream&, DeviceArena&, synthetic::Kind, std::uint32_t divisor, std::uint32_t elements, bool listedRun, std::size_t maxChunkPairs, StageOutput<TrackletT>& result, FlatRunInfo& info) = nullptr;
+  /// The device tracker for the ToyBarrel8 fixtures.
+  std::unique_ptr<DeviceTracker<detectors::ToyBarrel8, UniformMaterial>> (*makeToyBarrel8Tracker)(DeviceRuntime&, DeviceBlock arena) = nullptr;
+  /// The slice's glue passes on host inputs copied to the device, their
+  /// results copied back.
+  StageStatus (*permutation)(DeviceRuntime&, DeviceStream&, DeviceArena&, const IterationParameters<ToyBarrel8Det>&, const LayerRowMap<ToyBarrel8Det>&, const StageOutput<TrackletT>& tracklets, std::span<const std::uint8_t> prefix, std::span<const std::uint8_t> suffix, std::vector<std::uint32_t>& result) = nullptr;
+  StageStatus (*pathBounds)(DeviceRuntime&, DeviceStream&, DeviceArena&, const IterationParameters<ToyBarrel8Det>&, const LayerRowMap<ToyBarrel8Det>&, const StageOutput<TrackletT>&, const StageOutput<TripletT>&, std::span<const std::uint32_t>, PathBoundsResult&) = nullptr;
+  StageStatus (*endIndex)(DeviceRuntime&, DeviceStream&, DeviceArena&, const StageOutput<TripletT>& triplets, std::uint32_t trackletCount, std::vector<std::uint32_t>& offsets, std::vector<std::uint32_t>& indices) = nullptr;
+  StageStatus (*chained)(DeviceRuntime&, DeviceStream&, DeviceArena&, std::span<const std::uint32_t> neighbourOffsets, std::vector<std::uint32_t>& result) = nullptr;
+  /// The shared device algorithms and storage on host inputs copied to the
+  /// device.
+  StageStatus (*selectIndices)(DeviceRuntime&, DeviceStream&, DeviceArena&, std::span<const std::uint8_t> mask, std::vector<std::uint32_t>& result) = nullptr;
+  StageStatus (*scan32)(DeviceRuntime&, DeviceStream&, DeviceArena&, std::span<const std::uint32_t> input, std::vector<std::uint32_t>& result) = nullptr;
+  StageStatus (*scan64)(DeviceRuntime&, DeviceStream&, DeviceArena&, std::span<const std::uint64_t> input, std::vector<std::uint64_t>& result) = nullptr;
+  /// A chain of \a length values, the first 1: each pass raises value i to
+  /// value i-1 plus one, raising the change flag; a value above \a threshold
+  /// raises the second, sticky flag.
+  StageStatus (*sweepChain)(DeviceRuntime&, DeviceStream&, DeviceArena&, std::uint32_t length, std::uint32_t threshold, std::uint32_t maxChangingSweeps, std::vector<std::uint32_t>& values, std::array<std::uint32_t, 2>& flags, std::uint32_t& changingSweeps) = nullptr;
+  /// \a rows tracklets of \a source from \a sourceOffset copied into a device
+  /// destination of \a destinationRows rows, all bits set, at
+  /// \a destinationOffset; the destination read back.
+  StageStatus (*copyColumns)(DeviceRuntime&, DeviceStream&, DeviceArena&, const StageOutput<TrackletT>& source, std::size_t sourceOffset, std::size_t destinationRows, std::size_t destinationOffset, std::size_t rows, std::vector<Tracklet>& destination) = nullptr;
+  /// \a source cut into chunks of \a chunkRows rows, appended on the scratch
+  /// end in one scope, gathered on the base end and read back; false if the
+  /// arena refused a chunk or the gather.
+  bool (*gatherChunks)(DeviceRuntime&, DeviceStream&, DeviceArena&, const StageOutput<TrackletT>& source, std::span<const std::size_t> chunkRows, std::vector<Tracklet>& gathered) = nullptr;
+  /// \a object ported to the device and its values read there; false if the
+  /// arena refused it.
+  /// \a object uploaded, read back; uploaded again elsewhere from the kept image, read back into \a moved.
+  bool (*flatObject)(DeviceRuntime&, DeviceStream&, DeviceArena&, const ToyFlatObject& object, std::vector<std::int32_t>& readBack, std::vector<std::int32_t>& moved) = nullptr;
+  /// O2's material LUT ported with DeviceFlatObject, and getMatBudget of each
+  /// segment (x0, y0, z0, x1, y1, z1) evaluated on the device: its mean
+  /// density, mean X/X0 and length.
+  StageStatus (*matBudgets)(DeviceRuntime&, DeviceStream&, DeviceArena&, const o2::base::MatLayerCylSet& lut, std::span<const std::array<float, 6>> segments, std::vector<std::array<float, 3>>& result) = nullptr;
+  /// The selection glue over \a records into a copy of \a mask, in an arena
+  /// scope closed on return.
+  StageStatus (*selectionGlue)(DeviceRuntime&, DeviceStream&, DeviceArena&, const ToyBarrel8Records& records, std::span<const std::uint8_t> mask, std::uint32_t sharedInnermost, SelectionGlueResult& result) = nullptr;
+  /// Exact helix propagation on the device for independent closure validation.
+  StageStatus (*propagation)(DeviceRuntime&, DeviceStream&, DeviceArena&, std::span<const PropagationProbe>, std::vector<PropagationAnswer>&) = nullptr;
+  /// `lane_group_script::run` for \a items items in groups of \a lanes lanes
+  /// (`forEachGroup`, `WarpGroup`): two words per lane, item by item.
+  StageStatus (*laneGroups)(DeviceRuntime&, DeviceStream&, DeviceArena&, std::uint32_t lanes, std::uint32_t items, std::vector<std::uint64_t>&) = nullptr;
+  /// A slice's road counts, independently scheduled ordered counts, then its
+  /// starts and offsets, on host inputs copied to the device: the triplets
+  /// with their final levels, the neighbours and the core rows per layer.
+  StageStatus (*orderedRoadGlue)(DeviceRuntime&, DeviceStream&, DeviceArena&, const IterationParameters<ToyBarrel8Det>&, const StageOutput<TrackletT>& tracklets, const StageOutput<TripletT>& triplets, const StageOutput<NeighbourT>& neighbours, const std::array<MeasurementRange, kToyBarrel8Layers>& core, RoadGlueResult& result) = nullptr;
+};
+
+const DeviceTestEntry* testKernelsCUDA();
+const DeviceTestEntry* testKernelsHIP();
+
+} // namespace o2::gtrk
+
+#endif // GTRK_TEST_DEVICE_DEVICETESTKERNELS_H_
diff --git a/Detectors/GenericTracking/tracking/test/device/testDeviceMaterial.cxx b/Detectors/GenericTracking/tracking/test/device/testDeviceMaterial.cxx
new file mode 100644
index 0000000000000..385f8a277c17a
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/testDeviceMaterial.cxx
@@ -0,0 +1,92 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testDeviceMaterial.cxx
+/// \brief O2's material LUT ported to the device with DeviceFlatObject, its
+///        lookups against the host's.
+///
+/// Reads the LUT GTRK_TEST_MATLUT names and passes without
+/// checking anything if there is none. Built once per backend. Needs the
+/// device.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK device material
+#include <boost/test/unit_test.hpp>
+
+#include "DeviceTestFixture.h"
+#include "DeviceTestKernels.h"
+
+#include "DetectorsBase/MatLayerCylSet.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <filesystem>
+#include <memory>
+#include <random>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+using namespace device_test;
+
+BOOST_AUTO_TEST_CASE(TheLutGivesTheHostsBudgetsOnTheDevice)
+{
+  const char* path = std::getenv("GTRK_TEST_MATLUT");
+  if (path == nullptr || !std::filesystem::exists(path)) {
+    BOOST_TEST_MESSAGE("no material LUT: nothing to compare");
+    return;
+  }
+  const std::unique_ptr<o2::base::MatLayerCylSet> lut{o2::base::MatLayerCylSet::loadFromFile(path)};
+  BOOST_REQUIRE(lut != nullptr);
+  std::mt19937 random{13U};
+  std::uniform_real_distribution<float> transverse{-60.F, 60.F};
+  std::uniform_real_distribution<float> longitudinal{-150.F, 150.F};
+  std::uniform_real_distribution<float> step{-3.F, 3.F};
+  std::vector<std::array<float, 6>> segments(20000U);
+  for (auto& segment : segments) {
+    const float x = transverse(random);
+    const float y = transverse(random);
+    const float z = longitudinal(random);
+    segment = {x, y, z, x + step(random), y + step(random), z + step(random)};
+  }
+  Device device;
+  std::vector<std::array<float, 3>> onDevice;
+  BOOST_REQUIRE((kernels().matBudgets(*device.runtime, device.stream, *device.arena, *lut, segments, onDevice) == StageStatus::kComplete));
+  std::size_t differing = 0U;
+  std::size_t nonZero = 0U;
+  double worst = 0.;
+  const auto relative = [](float host, float device) { return host == device ? 0. : std::abs(static_cast<double>(device) - static_cast<double>(host)) / std::abs(static_cast<double>(host)); };
+  for (std::size_t i = 0; i < segments.size(); ++i) {
+    const auto& s = segments[i];
+    const auto host = lut->getMatBudget(s[0], s[1], s[2], s[3], s[4], s[5]);
+    nonZero += host.meanX2X0 > 0.F ? 1U : 0U;
+    const bool same = std::bit_cast<std::uint32_t>(host.meanRho) == std::bit_cast<std::uint32_t>(onDevice[i][0]) && std::bit_cast<std::uint32_t>(host.meanX2X0) == std::bit_cast<std::uint32_t>(onDevice[i][1]) && std::bit_cast<std::uint32_t>(host.length) == std::bit_cast<std::uint32_t>(onDevice[i][2]);
+    differing += same ? 0U : 1U;
+    worst = std::max({worst, relative(host.meanX2X0, onDevice[i][1]), relative(host.length, onDevice[i][2])});
+  }
+  BOOST_TEST_MESSAGE(runtime()->backend() << ": " << segments.size() << " segments, " << nonZero << " through material, " << differing << " differing, worst relative difference " << worst);
+  BOOST_TEST(nonZero > 0U);
+#ifdef GPUCA_DETERMINISTIC_MODE
+  BOOST_TEST(differing == 0U);
+#else
+  // Fast math moves where a segment crosses a cell of the LUT, by a small
+  // fraction of a budget; a port that is wrong is off by far more.
+  BOOST_TEST(worst < 1.e-2);
+#endif
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/device/testDeviceRuntime.cxx b/Detectors/GenericTracking/tracking/test/device/testDeviceRuntime.cxx
new file mode 100644
index 0000000000000..6a20669ee452e
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/testDeviceRuntime.cxx
@@ -0,0 +1,261 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+// The device's shared functions, lane groups and propagation against the
+// host; built once for CUDA and once for HIP.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Device Runtime
+#include <boost/test/unit_test.hpp>
+
+#include "DeviceTestFixture.h"
+#include "DeviceTestKernels.h"
+#include "PropagationPrecisionFixture.h"
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <numbers>
+#include <random>
+#include <span>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+using namespace device_test;
+
+/// Every function of Trig.h, in both precisions, over the propagator's turns,
+/// wide arguments, the reduction's hard cases and the special values: in the
+/// deterministic build the host's bits, all of them (PortableMath.h).
+BOOST_AUTO_TEST_CASE(TrigGivesTheHostsBitsInTheDeterministicBuild)
+{
+  std::vector<double> ys;
+  std::vector<double> xs;
+  std::mt19937_64 generator{42U};
+  std::uniform_real_distribution<double> unit{-1., 1.};
+  std::uniform_real_distribution<double> turnCosine{-0.2, 1.};
+  std::uniform_real_distribution<double> wide{-60., 60.};
+  for (int i = 0; i < 400'000; ++i) {
+    ys.push_back(unit(generator));
+    xs.push_back(turnCosine(generator));
+  }
+  for (int i = 0; i < 400'000; ++i) {
+    ys.push_back(wide(generator));
+    xs.push_back(wide(generator));
+  }
+  // Multiples of pi/2 and the next two doubles above each, where sin and cos
+  // reduce with most cancellation; not above zero, where they are subnormal.
+  for (int n = -200; n <= 200; ++n) {
+    double y = n * (std::numbers::pi / 2.);
+    for (int step = 0; step < (n == 0 ? 1 : 3); ++step) {
+      ys.push_back(y);
+      xs.push_back(-y);
+      y = std::nextafter(y, std::numeric_limits<double>::infinity());
+    }
+  }
+  // No subnormals: a process that loads O2's libO2GPUDataTypes.so runs with
+  // the host's FTZ and DAZ set (it is linked with crtfastmath.o), and the
+  // devices keep them, so a subnormal argument differs before any function
+  // sees it. 1.5e6 is below 2^20 pi/2, where sin and cos stop being portable.
+  constexpr double kInf = std::numeric_limits<double>::infinity();
+  const std::array special{0., -0., 1., -1., 0.5, -0.5, 0.975, 1.e-30, 1.e30, 1.5e6, kInf, -kInf, std::numeric_limits<double>::quiet_NaN()};
+  for (const double y : special) {
+    for (const double x : special) {
+      ys.push_back(y);
+      xs.push_back(x);
+    }
+  }
+  const auto count = static_cast<std::uint32_t>(ys.size());
+
+  auto* device = runtime();
+  auto stream = device->createStream();
+  DeviceArena arena{*device, block((std::size_t{count} * ((2U * sizeof(double)) + sizeof(TrigRow))) + 4096U)};
+  DeviceSpan<double> deviceYs;
+  DeviceSpan<double> deviceXs;
+  DeviceSpan<TrigRow> deviceRows;
+  BOOST_REQUIRE(deviceYs.allocate(arena, count));
+  BOOST_REQUIRE(deviceXs.allocate(arena, count));
+  BOOST_REQUIRE(deviceRows.allocate(arena, count));
+  upload(ys.data(), deviceYs, count, stream);
+  upload(xs.data(), deviceXs, count, stream);
+  kernels().trig(*device, stream, deviceYs.data(), deviceXs.data(), deviceRows.data(), count);
+  std::vector<TrigRow> rows(count);
+  download(deviceRows, rows.data(), count, stream);
+  stream.synchronize();
+
+  constexpr std::size_t kFunctions = 15U;
+  constexpr std::array<const char*, kFunctions> kNames{"sin", "cos", "sincos.sin", "sincos.cos", "asin", "atan", "atan2", "sinf", "cosf", "sincosf.sin", "sincosf.cos", "asinf", "atanf", "atan2f", "logf"};
+  std::array<std::size_t, kFunctions> differ{};
+  const auto compare = [&](std::size_t function, auto host, auto onDevice) {
+    using Bits = std::conditional_t<sizeof(host) == sizeof(std::uint64_t), std::uint64_t, std::uint32_t>;
+    differ[function] += std::bit_cast<Bits>(host) == std::bit_cast<Bits>(onDevice) ? 0U : 1U;
+  };
+  for (std::uint32_t i = 0; i < count; ++i) {
+    const TrigRow host = trigRow(ys[i], xs[i]);
+    const TrigRow& onDevice = rows[i];
+    compare(0U, host.sinD, onDevice.sinD);
+    compare(1U, host.cosD, onDevice.cosD);
+    compare(2U, host.sincosSinD, onDevice.sincosSinD);
+    compare(3U, host.sincosCosD, onDevice.sincosCosD);
+    compare(4U, host.asinD, onDevice.asinD);
+    compare(5U, host.atanD, onDevice.atanD);
+    compare(6U, host.atan2D, onDevice.atan2D);
+    compare(7U, host.sinF, onDevice.sinF);
+    compare(8U, host.cosF, onDevice.cosF);
+    compare(9U, host.sincosSinF, onDevice.sincosSinF);
+    compare(10U, host.sincosCosF, onDevice.sincosCosF);
+    compare(11U, host.asinF, onDevice.asinF);
+    compare(12U, host.atanF, onDevice.atanF);
+    compare(13U, host.atan2F, onDevice.atan2F);
+    compare(14U, host.logF, onDevice.logF);
+  }
+  for (std::size_t function = 0; function < kFunctions; ++function) {
+    BOOST_TEST_MESSAGE(kNames[function] << ": " << differ[function] << " of " << count << " differ from the host");
+#ifdef GPUCA_DETERMINISTIC_MODE
+    BOOST_TEST(differ[function] == 0U, kNames[function] << " differs from the host in " << differ[function] << " of " << count);
+#endif
+  }
+}
+
+// The lane groups: groups of 2 lanes up to a whole warp, 37 items --
+// a last block not full, groups with no trip, groups of one warp on different
+// trip counts and nested collectives -- each lane's ballots and broadcasts
+// against what the script gives it on the host, every lane of the group
+// evaluated.
+BOOST_AUTO_TEST_CASE(LaneGroupsAgreeWhateverTheOtherGroupsOfTheWarpDo)
+{
+  using namespace lane_group_script;
+  Device device;
+  constexpr std::uint32_t kItems = 37U;
+  for (std::uint32_t lanes = 2U; std::cmp_less_equal(lanes, device.runtime->properties().warpSize); lanes *= 2U) {
+    std::vector<std::uint64_t> folded;
+    BOOST_REQUIRE(kernels().laneGroups(*device.runtime, device.stream, *device.arena, lanes, kItems, folded) == StageStatus::kComplete);
+    BOOST_REQUIRE(folded.size() == std::size_t{2U} * kItems * lanes);
+    std::size_t mismatches = 0U;
+    for (std::uint32_t item = 0U; item < kItems; ++item) {
+      for (std::uint32_t lane = 0U; lane < lanes; ++lane) {
+        std::array<std::uint64_t, 2> expected{};
+        for (std::uint32_t trip = 0U; trip < trips(item); ++trip) {
+          std::uint64_t ballot = 0U;
+          for (std::uint32_t other = 0U; other < lanes; ++other) {
+            ballot |= vote(other, trip, item) ? std::uint64_t{1} << other : 0U;
+          }
+          expected[0] ^= ballot * (trip + 1U);
+          const auto got = payload(source(trip, item, lanes), trip, item);
+          expected[1] += got.a + (7U * got.b) + (13U * got.c);
+          for (std::uint32_t inner = 0U; inner < innerTrips(trip, item); ++inner) {
+            std::uint64_t innerBallot = 0U;
+            for (std::uint32_t other = 0U; other < lanes; ++other) {
+              innerBallot |= innerVote(other, inner) ? std::uint64_t{1} << other : 0U;
+            }
+            expected[0] ^= innerBallot << (inner + 1U);
+            expected[1] += innerValue(innerSource(inner, trip, lanes), inner);
+          }
+        }
+        const std::size_t at = 2U * ((std::size_t{item} * lanes) + lane);
+        mismatches += folded[at] != expected[0] || folded[at + 1U] != expected[1] ? 1U : 0U;
+      }
+    }
+    BOOST_TEST_CONTEXT("groups of " << lanes << " lanes") { BOOST_TEST(mismatches == 0U); }
+  }
+}
+
+// Independent double helix evaluation at each device-reported flight length,
+// over the same geometry distribution as the CPU precision sweep. No plane
+// inversion is used by the oracle; both charges/fields, straight trajectories,
+// grazing planes, off-centre targets and forward/backward steps are covered.
+BOOST_AUTO_TEST_CASE(DevicePropagationClosesWithinOneMicron)
+{
+  Device device;
+  using namespace propagation_precision;
+  std::mt19937_64 random{20260928U};
+  std::uniform_real_distribution<double> unit{0., 1.};
+  const auto sample = [&](double low, double high) { return low + (high - low) * unit(random); };
+  std::vector<PropagationProbe> probes;
+  constexpr int kTrials = 1000000;
+  probes.reserve(kTrials);
+  for (int trial = 0; trial < kTrials; ++trial) {
+    const double phi = sample(-std::numbers::pi, std::numbers::pi);
+    const double theta = sample(0.01, std::numbers::pi - 0.01);
+    const double pt = std::exp(sample(std::log(0.03), std::log(10000.)));
+    const double charge = trial % 2 == 0 ? 1. : -1.;
+    const double radius = sample(0., 90.);
+    const double azimuth = sample(-std::numbers::pi, std::numbers::pi);
+    PropagationProbe probe;
+    probe.from = plane(radius * std::cos(azimuth), radius * std::sin(azimuth), sample(-300., 300.), sample(-std::numbers::pi, std::numbers::pi), trial % 3 == 0, 1);
+    auto& state = probe.before;
+    state.surface = probe.from.id;
+    state.par[kLoc0] = static_cast<Scalar>(sample(-1.5, 1.5));
+    state.par[kLoc1] = static_cast<Scalar>(sample(-3.5, 3.5));
+    state.par[kPhi] = static_cast<Scalar>(phi);
+    state.par[kTheta] = static_cast<Scalar>(theta);
+    state.par[kQOverP] = static_cast<Scalar>(charge * std::sin(theta) / pt);
+    probe.prop.bzKiloGauss = trial % 5 == 0 ? -20.F : 20.F;
+    if (trial % 17 == 0) {
+      probe.prop.bzKiloGauss = 0.F;
+    }
+    const double path = sample(0.001, 300.) * (trial % 7 == 0 ? -1. : 1.);
+    probe.direction = path > 0. ? PropagationDirection::kForward : PropagationDirection::kBackward;
+    const double turn = static_cast<double>(state.qOverP()) * static_cast<double>(probe.prop.bzKiloGauss) * static_cast<double>(constants::math::B2C) * path;
+    if (std::abs(turn) > 3.1) {
+      continue;
+    }
+    ExactScalar origin[3]{};
+    detail::boundToGlobal(probe.from, state.loc0(), state.loc1(), origin);
+    const double transverse = path * std::sin(static_cast<double>(state.theta()));
+    const double along = transverse * sinc(turn);
+    const double across = transverse * versine(turn);
+    const double endX = origin[0] + along * std::cos(static_cast<double>(state.phi())) - across * std::sin(static_cast<double>(state.phi()));
+    const double endY = origin[1] + along * std::sin(static_cast<double>(state.phi())) + across * std::cos(static_cast<double>(state.phi()));
+    const double endZ = origin[2] + path * std::cos(static_cast<double>(state.theta()));
+    probe.to = plane(endX, endY, endZ, sample(-std::numbers::pi, std::numbers::pi), trial % 3 == 1, 2);
+    const double offsets[2]{sample(-5., 5.), sample(-5., 5.)};
+    for (int axis = 0; axis < 3; ++axis) {
+      probe.to.origin[axis] += static_cast<Scalar>(offsets[0] * static_cast<double>(probe.to.axis0[axis]) + offsets[1] * static_cast<double>(probe.to.axis1[axis]));
+    }
+    probes.push_back(probe);
+  }
+  // Match the CPU's million-trial coverage without enlarging the device
+  // arena: each callback closes its temporary scope before the next batch.
+  constexpr std::size_t kBatch = 100000U;
+  std::vector<PropagationAnswer> answers;
+  Worst worst;
+  for (std::size_t base = 0U; base < probes.size(); base += kBatch) {
+    const auto count = std::min(kBatch, probes.size() - base);
+    const auto batch = std::span<const PropagationProbe>{probes}.subspan(base, count);
+    BOOST_REQUIRE(kernels().propagation(*device.runtime, device.stream, *device.arena, batch, answers) == StageStatus::kComplete);
+    BOOST_REQUIRE(answers.size() == count);
+    for (std::size_t row = 0U; row < count; ++row) {
+      const auto& probe = batch[row];
+      const auto& answer = answers[row];
+      if (answer.result.status == PropagationStatus::kOk || answer.result.status == PropagationStatus::kOutOfBounds) {
+        worst.add(closure(probe.prop, probe.before, answer.after, probe.from, probe.to, answer.result.pathLength));
+      }
+    }
+  }
+  worst.report(device.runtime->backend());
+  BOOST_TEST(worst.checked > kTrials / 2);
+  BOOST_TEST(worst.value.position < kMicron);
+  BOOST_TEST(worst.value.plane < kMicron);
+  BOOST_TEST(worst.value.azimuth < 1.e-6);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/device/testDeviceStorage.cxx b/Detectors/GenericTracking/tracking/test/device/testDeviceStorage.cxx
new file mode 100644
index 0000000000000..2e357eb6b5110
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/testDeviceStorage.cxx
@@ -0,0 +1,199 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testDeviceStorage.cxx
+/// \brief The device algorithms and storage every pass shares, against the
+///        obvious host loops.
+///
+/// Built once per backend. Needs the device.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK device storage
+#include <boost/test/unit_test.hpp>
+
+#include "DeviceTestFixture.h"
+#include "DeviceTestKernels.h"
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+namespace o2::gtrk
+{
+namespace
+{
+
+using namespace device_test;
+
+bool sameTracklet(const Tracklet& lhs, const Tracklet& rhs) { return lhs.source == rhs.source && lhs.target == rhs.target && lhs.link == rhs.link && std::bit_cast<std::uint32_t>(lhs.lambda) == std::bit_cast<std::uint32_t>(rhs.lambda) && std::bit_cast<std::uint32_t>(lhs.phi) == std::bit_cast<std::uint32_t>(rhs.phi); }
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(SelectIndicesKeepsTheOrder)
+{
+  Device device;
+  std::mt19937 random{5U};
+  for (const std::size_t count : {std::size_t{0}, std::size_t{1}, std::size_t{1000}, std::size_t{300000}}) {
+    std::vector<std::uint8_t> mask(count);
+    std::ranges::generate(mask, [&] { return static_cast<std::uint8_t>(random() % 3U == 0U ? 1U : 0U); });
+    std::vector<std::uint32_t> expected;
+    for (std::uint32_t index = 0; index < count; ++index) {
+      if (mask[index] != 0U) {
+        expected.push_back(index);
+      }
+    }
+    std::vector<std::uint32_t> selected;
+    BOOST_REQUIRE((kernels().selectIndices(*device.runtime, device.stream, *device.arena, mask, selected) == StageStatus::kComplete));
+    BOOST_TEST(selected == expected, boost::test_tools::per_element());
+  }
+  BOOST_TEST(device.arena->used(ArenaEnd::kScratch) == 0U);
+}
+
+BOOST_AUTO_TEST_CASE(ExclusiveScanIn32And64Bits)
+{
+  Device device;
+  std::mt19937 random{6U};
+  std::vector<std::uint32_t> narrow(100001U);
+  std::ranges::generate(narrow, [&] { return static_cast<std::uint32_t>(random() % 50U); });
+  std::vector<std::uint32_t> narrowExpected(narrow.size());
+  std::exclusive_scan(narrow.begin(), narrow.end(), narrowExpected.begin(), std::uint32_t{0U});
+  std::vector<std::uint32_t> narrowResult;
+  BOOST_REQUIRE((kernels().scan32(*device.runtime, device.stream, *device.arena, narrow, narrowResult) == StageStatus::kComplete));
+  BOOST_TEST(narrowResult == narrowExpected, boost::test_tools::per_element());
+
+  // Counts whose total passes 32 bits: the wide scan keeps it.
+  std::vector<std::uint64_t> wide(4097U, std::uint64_t{std::numeric_limits<std::uint32_t>::max()} / 1000U);
+  std::vector<std::uint64_t> wideExpected(wide.size());
+  std::exclusive_scan(wide.begin(), wide.end(), wideExpected.begin(), std::uint64_t{0U});
+  BOOST_REQUIRE(wideExpected.back() > std::numeric_limits<std::uint32_t>::max());
+  std::vector<std::uint64_t> wideResult;
+  BOOST_REQUIRE((kernels().scan64(*device.runtime, device.stream, *device.arena, wide, wideResult) == StageStatus::kComplete));
+  BOOST_TEST(wideResult == wideExpected, boost::test_tools::per_element());
+  BOOST_TEST(device.arena->used(ArenaEnd::kScratch) == 0U);
+}
+
+/// A chain reaches its fixed point in at most its length's passes, whatever
+/// the schedule; the second flag is sticky; a bound too tight throws.
+BOOST_AUTO_TEST_CASE(SweepToFixedPointStopsAndChecksItsBound)
+{
+  Device device;
+  constexpr std::uint32_t kLength = 17U;
+  std::vector<std::uint32_t> values;
+  std::array<std::uint32_t, 2> flags{};
+  std::uint32_t changing = 0U;
+  BOOST_REQUIRE((kernels().sweepChain(*device.runtime, device.stream, *device.arena, kLength, kLength + 5U, kLength - 1U, values, flags, changing) == StageStatus::kComplete));
+  for (std::uint32_t index = 0; index < kLength; ++index) {
+    BOOST_TEST(values[index] == index + 1U);
+  }
+  BOOST_TEST(flags[0] == 0U);
+  BOOST_TEST(flags[1] == 0U);
+  BOOST_TEST(changing >= 1U);
+  BOOST_TEST(changing <= kLength - 1U);
+
+  // A value above the threshold, early in the chain: the second flag stays up.
+  BOOST_REQUIRE((kernels().sweepChain(*device.runtime, device.stream, *device.arena, kLength, 3U, kLength - 1U, values, flags, changing) == StageStatus::kComplete));
+  BOOST_TEST(flags[0] == 0U);
+  BOOST_TEST(flags[1] == 1U);
+
+  // No changing pass allowed: a chain that needs one throws.
+  BOOST_CHECK_THROW(static_cast<void>(kernels().sweepChain(*device.runtime, device.stream, *device.arena, kLength, kLength + 5U, 0U, values, flags, changing)), std::logic_error);
+  // A chain of one value never changes: no changing pass needed.
+  BOOST_REQUIRE((kernels().sweepChain(*device.runtime, device.stream, *device.arena, 1U, 5U, 0U, values, flags, changing) == StageStatus::kComplete));
+  BOOST_TEST(changing == 0U);
+}
+
+BOOST_AUTO_TEST_CASE(CopyColumnsAtOffsets)
+{
+  Device device;
+  std::vector<Tracklet> records(1000U);
+  for (std::uint32_t i = 0; i < records.size(); ++i) {
+    records[i] = Tracklet{.source = i, .target = 2U * i, .link = static_cast<std::uint16_t>(i % 7U), .lambda = 0.001F * static_cast<float>(i), .phi = -0.5F};
+  }
+  const auto source = recordsOf<TrackletT>(records);
+  std::vector<Tracklet> destination;
+  BOOST_REQUIRE((kernels().copyColumns(*device.runtime, device.stream, *device.arena, *source, 250U, 600U, 100U, 400U, destination) == StageStatus::kComplete));
+  BOOST_REQUIRE(destination.size() == 600U);
+  const Tracklet untouched{.source = ~0U, .target = ~0U, .link = 0xFFFFU, .lambda = std::bit_cast<float>(~0U), .phi = std::bit_cast<float>(~0U)};
+  for (std::size_t row = 0; row < destination.size(); ++row) {
+    const bool copied = row >= 100U && row < 500U;
+    BOOST_TEST(sameTracklet(destination[row], copied ? records[row - 100U + 250U] : untouched), "row " << row);
+  }
+  // Past either end is refused.
+  BOOST_CHECK_THROW(static_cast<void>(kernels().copyColumns(*device.runtime, device.stream, *device.arena, *source, 900U, 600U, 0U, 200U, destination)), std::out_of_range);
+  BOOST_CHECK_THROW(static_cast<void>(kernels().copyColumns(*device.runtime, device.stream, *device.arena, *source, 0U, 600U, 500U, 200U, destination)), std::out_of_range);
+}
+
+/// Chunks of several sizes, one empty, gathered back in order; an arena too
+/// small refuses a chunk and is left as it was.
+BOOST_AUTO_TEST_CASE(ColumnChunksGatherInOrder)
+{
+  std::vector<Tracklet> records(1000U);
+  for (std::uint32_t i = 0; i < records.size(); ++i) {
+    records[i] = Tracklet{.source = i, .target = 3U * i, .link = static_cast<std::uint16_t>(i % 11U), .lambda = 0.01F * static_cast<float>(i), .phi = 1.F};
+  }
+  const auto source = recordsOf<TrackletT>(records);
+  const std::vector<std::size_t> chunkRows{100U, 0U, 350U, 1U, 549U};
+  {
+    Device device;
+    std::vector<Tracklet> gathered;
+    BOOST_REQUIRE(kernels().gatherChunks(*device.runtime, device.stream, *device.arena, *source, chunkRows, gathered));
+    BOOST_REQUIRE(gathered.size() == records.size());
+    for (std::size_t row = 0; row < records.size(); ++row) {
+      BOOST_TEST(sameTracklet(gathered[row], records[row]), "row " << row);
+    }
+    BOOST_TEST(device.arena->used() == 0U);
+  }
+  {
+    Device small{std::size_t{40} * 1024U};
+    std::vector<Tracklet> gathered;
+    BOOST_TEST(!kernels().gatherChunks(*small.runtime, small.stream, *small.arena, *source, chunkRows, gathered));
+    BOOST_TEST(small.arena->used() == 0U);
+  }
+}
+
+/// A flat object lands usable: the device reads its values through the
+/// pointer relocated for the device buffer, also where a second upload of
+/// the kept image lands elsewhere. An arena too small refuses it.
+BOOST_AUTO_TEST_CASE(AFlatObjectIsUsableOnTheDevice)
+{
+  std::mt19937 random{9U};
+  std::vector<std::int32_t> values(10000U);
+  std::ranges::generate(values, [&] { return static_cast<std::int32_t>(random()); });
+  ToyFlatObject object;
+  object.construct(values);
+  {
+    Device device;
+    std::vector<std::int32_t> readBack;
+    std::vector<std::int32_t> moved;
+    BOOST_REQUIRE(kernels().flatObject(*device.runtime, device.stream, *device.arena, object, readBack, moved));
+    BOOST_TEST(readBack == values, boost::test_tools::per_element());
+    BOOST_TEST(moved == values, boost::test_tools::per_element());
+    BOOST_TEST(device.arena->used() == 0U);
+  }
+  {
+    Device small{std::size_t{4} * 1024U};
+    std::vector<std::int32_t> readBack;
+    std::vector<std::int32_t> moved;
+    BOOST_TEST(!kernels().flatObject(*small.runtime, small.stream, *small.arena, object, readBack, moved));
+    BOOST_TEST(small.arena->used() == 0U);
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/device/testDeviceTracker.cxx b/Detectors/GenericTracking/tracking/test/device/testDeviceTracker.cxx
new file mode 100644
index 0000000000000..f67c63d8544b1
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/testDeviceTracker.cxx
@@ -0,0 +1,929 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testDeviceTracker.cxx
+/// \brief A timeframe on a device against the host tracker's, pass by pass
+///        and iteration by iteration.
+///
+/// Built once per backend. The host tracker and the device run one plan in
+/// lockstep: the host's slice observer runs the same slice on the device,
+/// its iteration observer the device's iteration end, each with its own used
+/// mask; every pass's output, every iteration's selection, proposals, tracks
+/// and mask, and the timeframe's tracks are compared: byte for byte in the
+/// deterministic build, up to the last bits of the float columns with fast
+/// math. The device also runs a timeframe
+/// alone, and its lifecycle and failures are checked. Needs the device.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK device tracker
+#include <boost/test/unit_test.hpp>
+#include <numbers>
+
+#include "DeviceTestFixture.h"
+#include "DeviceTestKernels.h"
+#include "FixedPointReferences.h"
+#include "ToyBarrel8Fixture.h"
+
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/DeviceTracker.h"
+#include "GenericTracking/Tracking/Material.h"
+#include "GenericTracking/Study/StageComparison.h"
+#include "GenericTracking/Tracking/Tracker.h"
+#include "GenericTracking/Tracking/VertexingPass.h"
+#include "UniformMaterial.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+namespace
+{
+
+using namespace device_test;
+
+using namespace toybarrel8;
+using Host = Tracker<Det, UniformMaterial>;
+
+/// Twelve tracks on the sensors over 1.1 us, the even ones stiff (2 to 3
+/// GeV), the odd ones soft (0.4 to 0.7 GeV): the first iteration takes the
+/// stiff ones, and the second, down to 0.3 GeV, works around their rows.
+constexpr std::size_t kTracks = 12U;
+constexpr double kDurationNS = 1100.;
+
+/// The layers from which the soft tracks get twins (`hits`).
+constexpr LayerID kFirstTwinLayer = 5;
+
+/// With \a twins, a second hit 5 um beside each soft track's on the layers
+/// from `kFirstTwinLayer` out, on the same sensor and at the same time: two
+/// rows for the follow to choose between (its lookahead), where an iteration
+/// whose links stop below those layers leaves them to it.
+std::vector<Hit> hits(bool twins = false)
+{
+  std::vector<Hit> result;
+  for (std::size_t track = 0; track < kTracks; ++track) {
+    const auto k = static_cast<double>(track);
+    const bool stiff = track % 2U == 0U;
+    const double pt = stiff ? 2. + (0.2 * static_cast<double>(track % 5U)) : 0.4 + (0.06 * static_cast<double>(track % 5U));
+    const auto one = sensorHelixHits(std::fmod(0.3 + (0.9 * k), 2 * std::numbers::pi_v<double>), 0.03 * std::cos(1.3 * k), pt, 37. + (83. * k));
+    result.insert(result.end(), one.begin(), one.end());
+    if (!twins || stiff) {
+      continue;
+    }
+    for (const auto& hit : one) {
+      if (hit.point.layer < kFirstTwinLayer) {
+        continue;
+      }
+      Hit twin = hit;
+      twin.point = moved(hit.point, 5.e-4, 5.e-4);
+      const Scalar global[3]{twin.point.x, twin.point.y, twin.point.z};
+      Scalar local[3]{};
+      surfaceToLocal(trackingGeometry().surface(hit.surface), global, local);
+      twin.loc0 = local[0];
+      twin.loc1 = local[1];
+      result.push_back(twin);
+    }
+  }
+  return result;
+}
+
+std::vector<IterationSettings> iterations(VertexSource source)
+{
+  auto first = iterationSettings();
+  auto second = iterationSettings();
+  second.windows.minPtGeV = 0.3;
+  first.vertexSource = source;
+  second.vertexSource = source;
+  return {first, second};
+}
+
+/// One vertex per track, at its start time on the beam axis: a point box.
+std::vector<VertexSeed> trackVertices()
+{
+  std::vector<VertexSeed> vertices;
+  vertices.reserve(kTracks);
+  for (std::size_t track = 0; track < kTracks; ++track) {
+    const auto timePS = static_cast<std::uint32_t>(37'000U + (83'000U * track));
+    vertices.push_back({.timePS = timePS, .widthPS = 0U, .z = 0.F, .varZ = 4.e-4F, .varTransverse = 1.e-6F});
+  }
+  return vertices;
+}
+
+/// The device's output is the host's whatever its schedule, in the
+/// deterministic build byte for byte. With fast math, the same
+/// records, whose float columns may differ in their last bits.
+template <template <template <class> class> class S>
+bool matchesHost(const StageOutput<S>& host, const StageOutput<S>& device)
+{
+  const auto comparison = study::compareStageOutputs(host, device);
+#ifdef GPUCA_DETERMINISTIC_MODE
+  return comparison.identical();
+#else
+  constexpr double kTolerance = 1.e-4;
+  return comparison.sameElements && comparison.elementsWithOtherCount == 0U && comparison.elementsReordered == 0U && std::ranges::all_of(comparison.maxAbsDifference, [&](double difference) { return difference <= kTolerance; });
+#endif
+}
+
+struct Totals {
+  std::size_t iterations = 0U;
+  std::size_t slices = 0U;
+  std::size_t tracklets = 0U;
+  std::size_t triplets = 0U;
+  std::size_t neighbours = 0U;
+  std::size_t chained = 0U;
+  std::size_t roads = 0U;
+  std::size_t records = 0U;
+  std::size_t gathered = 0U;
+  std::size_t tracks = 0U;
+  std::size_t rounds = 0U;
+  std::size_t extended = 0U;     ///< tracks the follow added clusters to, on the device
+  std::size_t maskedSlices = 0U; ///< slices that read a used mask with exclusive rows
+  bool missed = false;
+};
+
+/// A configuration of both trackers.
+struct Options {
+  VertexSource source = VertexSource::kBeamLine;
+  std::int32_t width = 13;
+  std::uint32_t sharedInnermost = 0U;
+  bool extension = true;
+  /// The second iteration's kink allowance, whose follow runs in lane groups
+  /// on the device, its links below
+  /// `kFirstTwinLayer` and the soft tracks' twins there for the follow
+  /// (`hits`), and the first's end decided again:
+  /// never both in one iteration.
+  double kinkSigma = 1.;
+  bool followEnd = false;
+};
+
+std::string describe(const Options& options) { return std::string{options.source == VertexSource::kBeamLine ? "beam line" : "vertex list"} + ", width " + std::to_string(options.width) + ", shared " + std::to_string(options.sharedInnermost) + (options.extension ? ", follow" : ", no follow") + (options.kinkSigma > 1. ? ", kink allowance " + std::to_string(options.kinkSigma) + " sigma" : "") + (options.followEnd ? ", end again" : ""); }
+
+std::unique_ptr<Host> makeHost(const Options& options)
+{
+  const std::array<double, kLayers> material{};
+  static const UniformMaterial none{};
+  auto settings = iterations(options.source);
+  for (auto& iteration : settings) {
+    iteration.sharedInnermost = options.sharedInnermost;
+    iteration.follow = options.extension;
+  }
+  settings.front().followEnd = options.followEnd;
+  settings.back().kinkSigma = options.kinkSigma;
+  if (options.kinkSigma > 1.) {
+    settings.back().layerMask = (std::uint64_t{1} << kFirstTwinLayer) - 1U;
+  }
+  auto tracker = std::make_unique<Host>(settings, Fixture::kBeamConstraint, scatteringTable<Det>(material), std::make_shared<BoundedMemoryResource>(), 2U, 2);
+  tracker->setTrackModel(trackingGeometry(), none, Propagator{});
+  return tracker;
+}
+
+std::vector<IterationParameters<Det>> parametersOf(const Host& host)
+{
+  std::vector<IterationParameters<Det>> parameters;
+  parameters.reserve(host.iterationCount());
+  for (std::size_t iteration = 0; iteration < host.iterationCount(); ++iteration) {
+    parameters.push_back(host.iteration(iteration));
+  }
+  return parameters;
+}
+
+void configure(DeviceTracker<Det, UniformMaterial>& device, const Host& host) { BOOST_REQUIRE((device.configureRun(parametersOf(host), trackingGeometry(), UniformMaterial{}, Propagator{}) == StageStatus::kComplete)); }
+
+[[maybe_unused]] bool sameProposal(const FollowProposal<maxChainLayers<Det>>& lhs, const FollowProposal<maxChainLayers<Det>>& rhs) { return lhs.outwardCount == rhs.outwardCount && lhs.inwardCount == rhs.inwardCount && std::ranges::equal(lhs.outward, rhs.outward) && std::ranges::equal(lhs.inward, rhs.inward) && lhs.replacedEnd == rhs.replacedEnd; }
+
+/// The same for tracks: byte for byte in the deterministic build, the states field
+/// by field. With fast math a chi2's last bits may reorder ties, so the same
+/// tracks -- rows, count, iteration -- in any order, each with the same time
+/// box: its rows', not the fit's.
+template <typename View>
+bool sameTracks(const View& host, std::size_t hostRows, const View& device, std::size_t deviceRows)
+{
+#ifdef GPUCA_DETERMINISTIC_MODE
+  return study::compareColumns<TrackOf<maxChainLayers<Det>>::RecordT>(host, hostRows, device, deviceRows).identical();
+#else
+  const auto rowsOf = [](const View& view, std::size_t rows) {
+    std::vector<std::vector<std::uint64_t>> result;
+    result.reserve(rows);
+    for (std::size_t i = 0; i < rows; ++i) {
+      std::vector<std::uint64_t> track{view.clusters[i].index, view.clusters[i].index + view.count[i]};
+      track.push_back(view.iteration[i]);
+      track.push_back(view.timePS[i]);
+      track.push_back(view.widthPS[i]);
+      result.push_back(std::move(track));
+    }
+    std::ranges::sort(result);
+    return result;
+  };
+  return hostRows == deviceRows && rowsOf(host, hostRows) == rowsOf(device, deviceRows);
+#endif
+}
+
+/// The same indices, in the same order in the deterministic build, in any
+/// order with fast math.
+bool sameIndices(std::span<const std::uint32_t> host, std::span<const std::uint32_t> device)
+{
+#ifdef GPUCA_DETERMINISTIC_MODE
+  return std::ranges::equal(host, device);
+#else
+  std::vector<std::uint32_t> lhs{host.begin(), host.end()};
+  std::vector<std::uint32_t> rhs{device.begin(), device.end()};
+  std::ranges::sort(lhs);
+  std::ranges::sort(rhs);
+  return lhs == rhs;
+#endif
+}
+
+/// The proposals, one per track: equal in the deterministic build; with fast
+/// math, in the tracks' order, which may differ, so the clusters they add.
+template <typename Proposals>
+bool sameProposals(const Proposals& host, const std::vector<FollowProposal<maxChainLayers<Det>>>& device)
+{
+#ifdef GPUCA_DETERMINISTIC_MODE
+  return std::ranges::equal(host, device, sameProposal);
+#else
+  const auto added = [](const auto& proposals) {
+    std::size_t sum = 0U;
+    for (const auto& proposal : proposals) {
+      sum += std::size_t{proposal.outwardCount} + proposal.inwardCount;
+    }
+    return sum;
+  };
+  return host.size() == device.size() && added(host) == added(device);
+#endif
+}
+
+/// The host tracker's whole timeframe and the device's, in lockstep over one
+/// plan: every slice compared pass by pass, every iteration's selection,
+/// proposals, tracks and used mask, then the timeframe's tracks.
+Totals compare(DeviceTracker<Det, UniformMaterial>& device, const Options& options)
+{
+  const Fixture fixture{hits(options.kinkSigma > 1.), kDurationNS};
+  const auto vertexList = trackVertices();
+  const std::span<const VertexSeed> vertices = options.source == VertexSource::kVertexList ? std::span<const VertexSeed>{vertexList} : std::span<const VertexSeed>{};
+  const auto tracker = makeHost(options);
+  configure(device, *tracker);
+  const auto plan = tracker->planTimeframe(*fixture.frame, vertices, options.width, 0.);
+  BOOST_REQUIRE((device.beginTimeframe(*fixture.frame, plan) == StageStatus::kComplete));
+
+  Totals totals;
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  bool open = false;
+  std::size_t openIteration = 0U;
+  std::size_t nextSlice = 0U;
+  tracker->setIterationObserver([&](const Host&, const Host::IterationObservation& iteration) {
+    BOOST_REQUIRE(open);
+    BOOST_TEST(openIteration == iteration.iteration);
+    DeviceIterationDownload<Det> onDevice{pool};
+    BOOST_REQUIRE((device.endIteration(&onDevice) == StageStatus::kComplete));
+    open = false;
+    const auto& selection = *iteration.selection;
+    const auto& report = device.lastIteration();
+    BOOST_TEST_CONTEXT("iteration " << iteration.iteration)
+    {
+      // The records of every slice, gathered in slice order: the host's appended ones.
+      const auto records = study::compareColumns<SelectionRecordOf<maxChainLayers<Det>>::RecordT>(selection.records(), selection.recordCount(), std::as_const(onDevice.records).view(), onDevice.records.size());
+#ifdef GPUCA_DETERMINISTIC_MODE
+      BOOST_TEST(records.identical());
+      BOOST_TEST(std::ranges::equal(selection.ranked(), onDevice.ranked));
+      BOOST_TEST(report.rounds == selection.rounds());
+#else
+      BOOST_TEST(records.sameElements);
+#endif
+      BOOST_TEST(report.records == selection.recordCount());
+      BOOST_TEST(report.duplicates == selection.duplicates());
+      BOOST_TEST(report.mismatches == 0U);
+      BOOST_TEST(sameIndices(selection.selected(), onDevice.selected));
+      BOOST_TEST(report.tracks == selection.selected().size());
+      BOOST_TEST(std::ranges::equal(iteration.used, onDevice.used));
+      BOOST_TEST(sameProposals(iteration.proposals, onDevice.proposals));
+      BOOST_TEST(onDevice.proposals.size() == (options.extension ? onDevice.selected.size() : 0U));
+      const auto hostTracks = std::as_const(*iteration.tracks).view() + static_cast<std::ptrdiff_t>(iteration.trackOffset);
+      BOOST_TEST(sameTracks(hostTracks, iteration.tracks->size() - iteration.trackOffset, std::as_const(onDevice.tracks).view(), onDevice.tracks.size()));
+    }
+    totals.gathered += onDevice.records.size();
+    totals.tracks += onDevice.tracks.size();
+    totals.rounds += report.rounds;
+    totals.extended += static_cast<std::size_t>(std::ranges::count_if(onDevice.proposals, [](const auto& proposal) { return proposal.outwardCount + proposal.inwardCount != 0U; }));
+    ++totals.iterations;
+  });
+  tracker->setSliceObserver([&](const Host& host, const Host::SliceObservation& slice) {
+    if (!open || openIteration != slice.iteration) {
+      device.beginIteration(slice.iteration);
+      open = true;
+      openIteration = slice.iteration;
+      nextSlice = 0U;
+    }
+    BOOST_REQUIRE(nextSlice < plan.slices.size());
+    BOOST_TEST(slice.slice == &plan.slices[nextSlice].slice);
+    DeviceSliceDownload<Det> onDevice{pool};
+    BOOST_REQUIRE((device.runSlice(nextSlice, &onDevice) == StageStatus::kComplete));
+    ++nextSlice;
+    const auto& result = *slice.result;
+    BOOST_TEST_CONTEXT("iteration " << slice.iteration << ", slice from block " << slice.slice->coreBlocks.begin)
+    {
+      BOOST_TEST(matchesHost(*result.tracklets, onDevice.tracklets));
+      BOOST_TEST(matchesHost(*result.triplets, onDevice.triplets));
+      BOOST_TEST(matchesHost(*result.neighbours, onDevice.neighbours));
+      BOOST_TEST(std::ranges::equal(chainedTriplets(*result.neighbours), onDevice.chained));
+      BOOST_TEST(std::ranges::equal(slice.roads->successorAbove(), onDevice.successorAbove));
+      BOOST_TEST(std::ranges::equal(slice.roads->roads(), onDevice.roads));
+      BOOST_TEST(std::ranges::equal(slice.roads->starts(), onDevice.starts));
+      BOOST_TEST(std::ranges::equal(slice.roads->roadOffsets(), onDevice.roadOffsets));
+      BOOST_TEST(matchesHost(*slice.records, onDevice.records));
+    }
+    const auto& report = device.lastSlice();
+    BOOST_TEST(report.tracklets == result.tracklets->size());
+    BOOST_TEST(report.triplets == result.triplets->size());
+    BOOST_TEST(report.neighbours == result.neighbours->size());
+    BOOST_TEST(report.readbacks >= 6U);
+    ++totals.slices;
+    totals.tracklets += report.tracklets;
+    totals.triplets += report.triplets;
+    totals.neighbours += report.neighbours;
+    totals.chained += report.chained;
+    totals.roads += report.roads;
+    totals.records += report.records;
+    totals.missed = totals.missed || report.stagingPredictionMissed;
+    totals.maskedSlices += std::ranges::any_of(host.used(), [](std::uint8_t state) { return state == kExclusive; }) ? 1U : 0U;
+  });
+  const auto result = tracker->run(*fixture.frame, plan);
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  BOOST_TEST(result.tracks->size() > 0U);
+  BOOST_TEST(totals.iterations == tracker->iterationCount());
+  // The timeframe's tracks: every iteration's, in order.
+  typename TrackRefit<Det>::Tracks tracks;
+  tracks.setMemoryResource(pool.get());
+  device.downloadTracks(tracks);
+  BOOST_TEST(sameTracks(std::as_const(*result.tracks).view(), result.tracks->size(), std::as_const(tracks).view(), tracks.size()));
+  return totals;
+}
+
+std::vector<Options> configurations()
+{
+  std::vector<Options> result;
+  for (const auto source : {VertexSource::kBeamLine, VertexSource::kVertexList}) {
+    for (const std::int32_t width : {5, 13, 1000}) {
+      result.push_back({.source = source, .width = width});
+    }
+    result.push_back({.source = source, .width = 13, .sharedInnermost = 2U});
+    result.push_back({.source = source, .width = 13, .extension = false});
+    result.push_back({.source = source, .width = 13, .kinkSigma = 5., .followEnd = true});
+  }
+  return result;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(EverySliceAndIterationMatchesTheHostTracker)
+{
+  auto* device = runtime();
+  const auto tracker = kernels().makeToyBarrel8Tracker(*device, block(kArenaBytes));
+  BOOST_TEST(tracker->arenaBytes() == kArenaBytes);
+  for (const auto& options : configurations()) {
+    BOOST_TEST_CONTEXT(describe(options))
+    {
+      const auto totals = compare(*tracker, options);
+      BOOST_TEST(totals.triplets > 0U);
+      BOOST_TEST(totals.neighbours > 0U);
+      BOOST_TEST(totals.chained > 0U);
+      BOOST_TEST(totals.roads > 0U);
+      BOOST_TEST(totals.records > 0U);
+      BOOST_TEST(totals.gathered == totals.records);
+      BOOST_TEST(totals.tracks == kTracks);
+      BOOST_TEST(totals.maskedSlices > 0U);
+      if (options.kinkSigma > 1.) {
+        BOOST_TEST(totals.extended > 0U);
+      }
+      BOOST_TEST_MESSAGE(device->backend() << " " << describe(options) << ": " << totals.slices << " slices, " << totals.tracklets << " tracklets, " << totals.triplets << " triplets, " << totals.neighbours << " neighbours, " << totals.roads << " roads, " << totals.records << " records, " << totals.rounds << " rounds, " << totals.tracks << " tracks, " << totals.extended << " extended");
+    }
+  }
+}
+
+/// The flat runs in chunks of 16 pairs: sources and first tracklets split
+/// across chunks, every chunk's elements re-walked past the others', the
+/// chunks' outputs assembled; the slices are the host's as before.
+BOOST_AUTO_TEST_CASE(ChunkedFlatRunsMatchTheHostTracker)
+{
+  auto* device = runtime();
+  const auto tracker = kernels().makeToyBarrel8Tracker(*device, block(kArenaBytes));
+  tracker->setFlatChunkPairs(16U);
+  for (const auto& options : configurations()) {
+    BOOST_TEST_CONTEXT(describe(options))
+    {
+      const auto totals = compare(*tracker, options);
+      BOOST_TEST(totals.triplets > 0U);
+      BOOST_TEST(totals.tracks == kTracks);
+    }
+  }
+}
+
+/// The staged stages' staging at one record -- the neighbours, the road
+/// fit's records and, where a wave is 64 lanes wide, the tracklet stage's
+/// lane groups; the flat runs (the triplet stage, CUDA's tracklet stage) list
+/// their candidates exactly and stage nothing: each overflows, retries at the
+/// exact size and keeps it; the outputs do not change.
+BOOST_AUTO_TEST_CASE(MispredictedStagingGivesTheSameSlices)
+{
+  auto* device = runtime();
+  const auto tracker = kernels().makeToyBarrel8Tracker(*device, block(kArenaBytes));
+  tracker->setStagingCapacity(1U);
+  const auto totals = compare(*tracker, {.width = 1000});
+  BOOST_TEST(totals.missed);
+  BOOST_TEST(totals.neighbours > 0U);
+  BOOST_TEST(totals.records > 0U);
+}
+
+BOOST_AUTO_TEST_CASE(AnEdgelessTripletGraphNeedsNoOverflowReadback)
+{
+  auto rows = sensorHelixHits(0.3, 0.03, 2., 37.);
+  rows.resize(3U);
+  const Fixture fixture{rows, kDurationNS};
+  auto settings = iterationSettings();
+  settings.minClusters = 3;
+  settings.follow = false;
+  const std::array<double, kLayers> material{};
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  Host host{settings, Fixture::kBeamConstraint, scatteringTable<Det>(material), pool, 2U, 2};
+  const UniformMaterial none{};
+  host.setTrackModel(trackingGeometry(), none, Propagator{});
+  const auto plan = host.planTimeframe(*fixture.frame, {}, 1000, 0.);
+  auto* device = runtime();
+  const auto tracker = kernels().makeToyBarrel8Tracker(*device, block(kArenaBytes));
+  configure(*tracker, host);
+  tracker->setStagingCapacity(16U);
+  BOOST_REQUIRE((tracker->beginTimeframe(*fixture.frame, plan) == StageStatus::kComplete));
+  tracker->beginIteration(0U);
+  DeviceSliceDownload<Det> output{pool};
+  BOOST_REQUIRE((tracker->runSlice(0U, &output) == StageStatus::kComplete));
+  const auto& report = tracker->lastSlice();
+  BOOST_REQUIRE(report.triplets == 1U);
+  BOOST_TEST(report.chained == 0U);
+  // Four stages, the tracklet launch's list, permutation, the chained count and (with a download)
+  // the chained list, starts, offsets: 10; a flat run
+  // reads back three -- the list's length, the selected count, the
+  // limit flag -- for the staging's one: the tracklets' and the triplets'; and the
+  // count of the triplets kept on a path.
+  BOOST_TEST(report.readbacks == 15U);
+  BOOST_REQUIRE(output.roads.size() == 1U);
+  BOOST_TEST(output.roads[0] == 1U);
+  BOOST_TEST(output.successorAbove[0] == 0U);
+  BOOST_TEST((tracker->endIteration(nullptr) == StageStatus::kComplete));
+}
+
+/// trackTimeframe alone, with no observer driving it: the host's tracks.
+BOOST_AUTO_TEST_CASE(ARunAloneGivesTheHostsTracks)
+{
+  auto* device = runtime();
+  const auto tracker = kernels().makeToyBarrel8Tracker(*device, block(kArenaBytes));
+  const auto vertexList = trackVertices();
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  for (const auto& options : configurations()) {
+    BOOST_TEST_CONTEXT(describe(options))
+    {
+      const Fixture fixture{hits(options.kinkSigma > 1.), kDurationNS};
+      const std::span<const VertexSeed> vertices = options.source == VertexSource::kVertexList ? std::span<const VertexSeed>{vertexList} : std::span<const VertexSeed>{};
+      const auto host = makeHost(options);
+      configure(*tracker, *host);
+      const auto plan = host->planTimeframe(*fixture.frame, vertices, options.width, 0.);
+      const auto expected = host->run(*fixture.frame, plan);
+      BOOST_REQUIRE(expected.status == StageStatus::kComplete);
+      typename TrackRefit<Det>::Tracks tracks;
+      tracks.setMemoryResource(pool.get());
+      typename DeviceTracker<Det, UniformMaterial>::TimeframeReport report;
+      BOOST_REQUIRE((tracker->trackTimeframe(*fixture.frame, plan, plan.parameters.size(), false, tracks, report) == StageStatus::kComplete));
+      tracker->endTimeframe();
+      BOOST_TEST(tracks.size() == kTracks);
+      BOOST_TEST(sameTracks(std::as_const(*expected.tracks).view(), expected.tracks->size(), std::as_const(tracks).view(), tracks.size()));
+    }
+  }
+}
+
+namespace
+{
+
+/// A configured tracker, the fixture's timeframe and its plan, for the
+/// lifecycle tests.
+struct Configured {
+  explicit Configured(std::size_t arenaBytes = kArenaBytes)
+    : runtime(device_test::runtime()),
+      tracker(kernels().makeToyBarrel8Tracker(*runtime, block(arenaBytes))),
+      fixture(hits(), kDurationNS),
+      host(makeHost({}))
+  {
+    parameters = parametersOf(*host);
+    plan = host->planTimeframe(*fixture.frame, {}, 13, 0.);
+  }
+
+  [[nodiscard]] StageStatus configure() { return tracker->configureRun(parameters, trackingGeometry(), UniformMaterial{}, Propagator{}); }
+
+  SliceScope slices;
+  DeviceRuntime* runtime;
+  std::unique_ptr<DeviceTracker<Det, UniformMaterial>> tracker;
+  Fixture fixture;
+  std::unique_ptr<Host> host;
+  std::vector<IterationParameters<Det>> parameters;
+  TimeframePlan<Det> plan;
+};
+
+} // namespace
+
+/// Every call out of order throws.
+BOOST_AUTO_TEST_CASE(CallsOutOfOrderAreRefused)
+{
+  Configured configured;
+  auto& tracker = *configured.tracker;
+  const auto& frame = *configured.fixture.frame;
+  BOOST_CHECK_THROW(static_cast<void>(tracker.beginTimeframe(frame, configured.plan)), std::logic_error);
+  BOOST_REQUIRE((configured.configure() == StageStatus::kComplete));
+  BOOST_CHECK_THROW(tracker.beginIteration(0U), std::logic_error);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  typename TrackRefit<Det>::Tracks tracks;
+  tracks.setMemoryResource(pool.get());
+  BOOST_CHECK_THROW(tracker.downloadTracks(tracks), std::logic_error);
+  BOOST_REQUIRE((tracker.beginTimeframe(frame, configured.plan) == StageStatus::kComplete));
+  BOOST_CHECK_THROW(static_cast<void>(tracker.runSlice(0U, nullptr)), std::logic_error);
+  BOOST_CHECK_THROW(static_cast<void>(tracker.endIteration(nullptr)), std::logic_error);
+  BOOST_CHECK_THROW(tracker.beginIteration(configured.parameters.size()), std::invalid_argument);
+  tracker.beginIteration(0U);
+  BOOST_CHECK_THROW(tracker.beginIteration(1U), std::logic_error);
+  BOOST_CHECK_THROW(static_cast<void>(tracker.runSlice(configured.plan.slices.size(), nullptr)), std::logic_error);
+  BOOST_CHECK_THROW(tracker.downloadTracks(tracks), std::logic_error);
+  BOOST_TEST((tracker.runSlice(0U, nullptr) == StageStatus::kComplete));
+  BOOST_TEST((tracker.endIteration(nullptr) == StageStatus::kComplete));
+  BOOST_CHECK_THROW(static_cast<void>(tracker.endIteration(nullptr)), std::logic_error);
+  tracker.downloadTracks(tracks);
+  // A new timeframe closes an open iteration, and the tracks.
+  tracker.beginIteration(1U);
+  BOOST_REQUIRE((tracker.beginTimeframe(frame, configured.plan) == StageStatus::kComplete));
+  BOOST_CHECK_THROW(static_cast<void>(tracker.endIteration(nullptr)), std::logic_error);
+  BOOST_TEST(tracker.arenaUsedBytes(ArenaEnd::kScratch) == 0U);
+  tracker.downloadTracks(tracks);
+  BOOST_TEST(tracks.size() == 0U);
+}
+
+/// A plan of another frame or another run is refused before anything
+/// changes.
+BOOST_AUTO_TEST_CASE(APlanOfAnotherFrameOrRunIsRefused)
+{
+  Configured configured;
+  auto& tracker = *configured.tracker;
+  BOOST_REQUIRE((configured.configure() == StageStatus::kComplete));
+  BOOST_REQUIRE((tracker.beginTimeframe(*configured.fixture.frame, configured.plan) == StageStatus::kComplete));
+  const auto base = tracker.arenaUsedBytes(ArenaEnd::kBase);
+  const Fixture longer{hits(), 2. * kDurationNS};
+  BOOST_CHECK_THROW(static_cast<void>(tracker.beginTimeframe(*longer.frame, configured.plan)), std::invalid_argument);
+  const auto other = makeHost({.source = VertexSource::kVertexList});
+  const auto otherPlan = other->planTimeframe(*configured.fixture.frame, {}, 13, 0.);
+  BOOST_CHECK_THROW(static_cast<void>(tracker.beginTimeframe(*configured.fixture.frame, otherPlan)), std::invalid_argument);
+  BOOST_TEST(tracker.arenaUsedBytes(ArenaEnd::kBase) == base);
+  // The timeframe is still there.
+  tracker.beginIteration(0U);
+  BOOST_TEST((tracker.runSlice(0U, nullptr) == StageStatus::kComplete));
+  BOOST_TEST((tracker.endIteration(nullptr) == StageStatus::kComplete));
+}
+
+/// A slice refused for memory fails its iteration: the next slice is
+/// refused, endIteration returns the failure and leaves the scratch empty,
+/// and the next iteration begins.
+BOOST_AUTO_TEST_CASE(AFailedSliceFailsItsIteration)
+{
+  std::size_t timeframeBytes = 0U;
+  {
+    Configured probe;
+    BOOST_REQUIRE((probe.configure() == StageStatus::kComplete));
+    BOOST_REQUIRE((probe.tracker->beginTimeframe(*probe.fixture.frame, probe.plan) == StageStatus::kComplete));
+    timeframeBytes = probe.tracker->arenaUsedBytes(ArenaEnd::kBase);
+  }
+  // Room for the run and the timeframe, and not for a slice's staging.
+  Configured configured{timeframeBytes + std::size_t{64} * 1024U};
+  auto& tracker = *configured.tracker;
+  BOOST_REQUIRE((configured.configure() == StageStatus::kComplete));
+  BOOST_REQUIRE((tracker.beginTimeframe(*configured.fixture.frame, configured.plan) == StageStatus::kComplete));
+  const auto base = tracker.arenaUsedBytes(ArenaEnd::kBase);
+  tracker.beginIteration(0U);
+  BOOST_TEST((tracker.runSlice(0U, nullptr) == StageStatus::kOutOfMemory));
+  BOOST_TEST(tracker.arenaUsedBytes(ArenaEnd::kBase) == base);
+  BOOST_CHECK_THROW(static_cast<void>(tracker.runSlice(1U, nullptr)), std::logic_error);
+  BOOST_TEST((tracker.endIteration(nullptr) == StageStatus::kOutOfMemory));
+  BOOST_TEST(tracker.arenaUsedBytes(ArenaEnd::kScratch) == 0U);
+  BOOST_TEST(tracker.arenaUsedBytes(ArenaEnd::kBase) == base);
+  tracker.beginIteration(1U);
+  BOOST_TEST((tracker.endIteration(nullptr) == StageStatus::kComplete));
+
+  // A run the arena cannot hold is refused, and leaves no run configured.
+  Configured tiny{4096U};
+  BOOST_TEST((tiny.configure() == StageStatus::kOutOfMemory));
+  BOOST_CHECK_THROW(static_cast<void>(tiny.tracker->beginTimeframe(*tiny.fixture.frame, tiny.plan)), std::logic_error);
+}
+
+namespace
+{
+
+/// The tracks, and 30,000 hits on the outermost layer after them in time:
+/// no layer's tracklets start there, and nothing reaches them in time, so
+/// they only make the timeframe's rows -- the used mask, the rounds' slots
+/// -- larger than anything a slice needs.
+std::vector<Hit> hitsWithLonelyRows()
+{
+  constexpr std::size_t kLonely = 30000U;
+  auto result = hits();
+  result.reserve(result.size() + kLonely);
+  for (std::size_t i = 0; i < kLonely; ++i) {
+    const auto k = static_cast<double>(i);
+    result.push_back({
+      .point = helixAt(std::fmod(0.37 * k, 2 * std::numbers::pi_v<double>), 0.02 * std::sin(k), 5., static_cast<LayerID>(kLayers - 1U)),
+      .timeNS = 1000. + (99. * k / static_cast<double>(kLonely)),
+    });
+  }
+  return result;
+}
+
+} // namespace
+
+/// An iteration whose end the arena refuses -- in the gather, the
+/// selection, the refit's or the extension's storage, the track chunk --
+/// fails and leaves the used mask and the tracks as they were:
+/// nothing kept, and the next iteration
+/// runs on a free mask, as a host run of that iteration alone does.
+namespace
+{
+
+/// Two collisions of eight tracks each, 500 ns apart: one vertex each for
+/// the vertexing pass.
+constexpr std::size_t kTracksPerCollision = 8U;
+constexpr std::array<double, 2> kCollisionsNS{37., 537.};
+constexpr double kCollisionDurationNS = 600.;
+
+std::vector<Hit> collisionHits()
+{
+  std::vector<Hit> result;
+  for (std::size_t track = 0; track < kTracksPerCollision * kCollisionsNS.size(); ++track) {
+    const auto k = static_cast<double>(track);
+    const double pt = 0.5 + (0.3 * static_cast<double>(track % kTracksPerCollision));
+    const auto one = sensorHelixHits(std::fmod(0.3 + (2.1 * k), 2 * std::numbers::pi_v<double>), 0.03 * std::cos(1.3 * k), pt, kCollisionsNS[track / kTracksPerCollision]);
+    result.insert(result.end(), one.begin(), one.end());
+  }
+  return result;
+}
+
+/// The pass: the beam line, the three innermost layers, no holes, 0.3 GeV.
+IterationSettings passSettings()
+{
+  auto settings = iterationSettings();
+  settings.windows.minPtGeV = 0.3;
+  settings.minClusters = 3;
+  settings.maxKinks = 0;
+  settings.skipLinks = false;
+  settings.layerMask = 0b111U;
+  settings.follow = false;
+  return settings;
+}
+
+} // namespace
+
+/// The device's rerun of the frames without a vertex: the two collisions
+/// and, in a frame of its own, two tracks, a vertex only at the lower floor;
+/// the device's list the host's.
+BOOST_AUTO_TEST_CASE(TheVertexerRerunsAFrameWithoutAVertexAsTheHost)
+{
+  auto* device = runtime();
+  const auto tracker = kernels().makeToyBarrel8Tracker(*device, block(kArenaBytes));
+  auto hits = collisionHits();
+  for (const double pt : {0.8, 1.1}) {
+    const auto one = sensorHelixHits(pt, 0.02 * pt, pt, 287.);
+    hits.insert(hits.end(), one.begin(), one.end());
+  }
+  const Fixture fixture{hits, kCollisionDurationNS};
+  const std::array<double, kLayers> material{};
+  const auto scattering = scatteringTable<Det>(material);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const VertexerSettings settings{.aloneMinContributors = 2U};
+
+  VertexingPass<Det, UniformMaterial> pass{passSettings(), settings, Fixture::kBeamConstraint, scattering, pool, 2U, 2};
+  const auto expected = pass.find(*fixture.frame, 13, 0);
+  BOOST_REQUIRE(expected.status == StageStatus::kComplete);
+  BOOST_REQUIRE(expected.found.vertices.size() == kCollisionsNS.size() + 1U);
+
+  const auto host = makeHost({.source = VertexSource::kVertexList});
+  auto parameters = parametersOf(*host);
+  parameters.push_back(pass.passParameters());
+  std::vector<SearchWindowParams> windows;
+  windows.reserve(parameters.size());
+  for (std::size_t iteration = 0; iteration < host->iterationCount(); ++iteration) {
+    windows.push_back(iterations(VertexSource::kVertexList)[iteration].windows);
+  }
+  windows.push_back(passSettings().windows);
+  BOOST_REQUIRE((tracker->configureRun(parameters, trackingGeometry(), UniformMaterial{}, Propagator{}) == StageStatus::kComplete));
+  const auto empty = planTimeframe<Det>(*fixture.frame, parameters, windows, host->beamLine(), {}, 13, 0);
+  BOOST_REQUIRE((tracker->beginTimeframe(*fixture.frame, empty) == StageStatus::kComplete));
+  VertexerResult found;
+  BOOST_REQUIRE((tracker->findVertices(host->iterationCount(), settings, Fixture::kBeamConstraint, found) == StageStatus::kComplete));
+  BOOST_REQUIRE(found.vertices.size() == expected.found.vertices.size());
+  BOOST_TEST(found.rounds == expected.found.rounds);
+  for (std::size_t v = 0; v < found.vertices.size(); ++v) {
+    BOOST_TEST_CONTEXT("vertex " << v)
+    {
+      BOOST_TEST(found.vertices[v].timePS == expected.found.vertices[v].timePS);
+      BOOST_TEST(found.vertices[v].widthPS == expected.found.vertices[v].widthPS);
+      BOOST_TEST(found.contributors[v] == expected.found.contributors[v]);
+      BOOST_TEST(std::abs(found.vertices[v].z - expected.found.vertices[v].z) < 1.e-5F);
+    }
+  }
+}
+
+/// The vertexing pass on the device, configured after the tracking's
+/// iterations: the host's vertex list from it, and with the list -- the plan
+/// replaced, the measurements kept -- the host's tracks; out of order it is
+/// refused.
+BOOST_AUTO_TEST_CASE(TheVertexingPassGivesTheHostsListAndTracks)
+{
+  auto* device = runtime();
+  const auto tracker = kernels().makeToyBarrel8Tracker(*device, block(kArenaBytes));
+  const Fixture fixture{collisionHits(), kCollisionDurationNS};
+  const std::array<double, kLayers> material{};
+  const auto scattering = scatteringTable<Det>(material);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+
+  // The host: the pass's list, and the tracking from it.
+  VertexingPass<Det, UniformMaterial> pass{passSettings(), VertexerSettings{}, Fixture::kBeamConstraint, scattering, pool, 2U, 2};
+  const auto expected = pass.find(*fixture.frame, 13, 0);
+  BOOST_REQUIRE(expected.status == StageStatus::kComplete);
+  BOOST_REQUIRE(expected.found.vertices.size() == kCollisionsNS.size());
+  const auto host = makeHost({.source = VertexSource::kVertexList});
+  const auto hostPlan = host->planTimeframe(*fixture.frame, expected.found.vertices, 13, 0.);
+  const auto hostRun = host->run(*fixture.frame, hostPlan);
+  BOOST_REQUIRE(hostRun.status == StageStatus::kComplete);
+  BOOST_REQUIRE(hostRun.tracks->size() == kTracksPerCollision * kCollisionsNS.size());
+
+  // The device: the tracking's iterations, then the pass.
+  auto parameters = parametersOf(*host);
+  parameters.push_back(pass.passParameters());
+  std::vector<SearchWindowParams> windows;
+  windows.reserve(parameters.size());
+  for (std::size_t iteration = 0; iteration < host->iterationCount(); ++iteration) {
+    windows.push_back(iterations(VertexSource::kVertexList)[iteration].windows);
+  }
+  windows.push_back(passSettings().windows);
+  BOOST_REQUIRE((tracker->configureRun(parameters, trackingGeometry(), UniformMaterial{}, Propagator{}) == StageStatus::kComplete));
+  const auto empty = planTimeframe<Det>(*fixture.frame, parameters, windows, host->beamLine(), {}, 13, 0);
+  BOOST_REQUIRE((tracker->beginTimeframe(*fixture.frame, empty) == StageStatus::kComplete));
+  VertexerResult found;
+  BOOST_REQUIRE((tracker->findVertices(host->iterationCount(), VertexerSettings{}, Fixture::kBeamConstraint, found) == StageStatus::kComplete));
+  BOOST_REQUIRE(found.vertices.size() == expected.found.vertices.size());
+  BOOST_TEST(found.candidates == expected.found.candidates);
+  for (std::size_t v = 0; v < found.vertices.size(); ++v) {
+    BOOST_TEST_CONTEXT("vertex " << v)
+    {
+      BOOST_TEST(found.vertices[v].timePS == expected.found.vertices[v].timePS);
+      BOOST_TEST(found.vertices[v].widthPS == expected.found.vertices[v].widthPS);
+      BOOST_TEST(found.contributors[v] == expected.found.contributors[v]);
+      BOOST_TEST(std::abs(found.vertices[v].z - expected.found.vertices[v].z) < 1.e-5F);
+    }
+  }
+
+  // The tracking's plan with the device's list replaces the empty one.
+  const auto trackingPlan = planTimeframe<Det>(*fixture.frame, parameters, windows, host->beamLine(), found.vertices, 13, 0);
+  BOOST_REQUIRE((tracker->replacePlan(trackingPlan) == StageStatus::kComplete));
+  for (std::size_t iteration = 0; iteration < host->iterationCount(); ++iteration) {
+    tracker->beginIteration(iteration);
+    for (std::size_t slice = 0; slice < trackingPlan.slices.size(); ++slice) {
+      BOOST_REQUIRE((tracker->runSlice(slice, nullptr) == StageStatus::kComplete));
+    }
+    BOOST_REQUIRE((tracker->endIteration(nullptr) == StageStatus::kComplete));
+  }
+  typename TrackRefit<Det>::Tracks tracks;
+  tracks.setMemoryResource(pool.get());
+  tracker->downloadTracks(tracks);
+  BOOST_TEST(tracks.size() == hostRun.tracks->size());
+  BOOST_TEST(sameTracks(std::as_const(*hostRun.tracks).view(), hostRun.tracks->size(), std::as_const(tracks).view(), tracks.size()));
+
+  // Out of order, or with another run's plan: refused.
+  tracker->beginIteration(0U);
+  BOOST_CHECK_THROW(static_cast<void>(tracker->findVertices(host->iterationCount(), VertexerSettings{}, Fixture::kBeamConstraint, found)), std::logic_error);
+  BOOST_CHECK_THROW(static_cast<void>(tracker->replacePlan(trackingPlan)), std::logic_error);
+  static_cast<void>(tracker->endIteration(nullptr));
+  BOOST_CHECK_THROW(static_cast<void>(tracker->replacePlan(hostPlan)), std::invalid_argument);
+  BOOST_CHECK_THROW(static_cast<void>(tracker->findVertices(host->iterationCount() + 1U, VertexerSettings{}, Fixture::kBeamConstraint, found)), std::invalid_argument);
+}
+
+BOOST_AUTO_TEST_CASE(AFailedEndLeavesTheMaskAndTheTracks)
+{
+  auto* device = runtime();
+  const Fixture fixture{hitsWithLonelyRows(), kDurationNS};
+  const auto host = makeHost({});
+  const auto parameters = parametersOf(*host);
+  const auto plan = host->planTimeframe(*fixture.frame, {}, 13, 0.);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+
+  // The second iteration alone on the host: its mask from a free one.
+  auto alone = std::make_unique<Host>(std::vector<IterationSettings>{iterations(VertexSource::kBeamLine)[1]}, Fixture::kBeamConstraint, scatteringTable<Det>(std::array<double, kLayers>{}), std::make_shared<BoundedMemoryResource>(), 2U, 2);
+  static const UniformMaterial none{};
+  alone->setTrackModel(trackingGeometry(), none, Propagator{});
+  std::vector<std::size_t> aloneTracklets;
+  alone->setSliceObserver([&](const Host&, const Host::SliceObservation& slice) { aloneTracklets.push_back(slice.result->tracklets->size()); });
+  const auto aloneResult = alone->run(*fixture.frame, alone->planTimeframe(*fixture.frame, {}, 13, 0.));
+  BOOST_REQUIRE(aloneResult.status == StageStatus::kComplete);
+  const std::vector<std::uint8_t> aloneMask{alone->used().begin(), alone->used().end()};
+
+  // What the first iteration's slices need, and what its end needs besides.
+  std::vector<std::size_t> tracklets;
+  const auto runSlices = [&](DeviceTracker<Det, UniformMaterial>& tracker, std::size_t iteration) {
+    tracklets.clear();
+    tracker.beginIteration(iteration);
+    for (std::size_t slice = 0; slice < plan.slices.size(); ++slice) {
+      if (tracker.runSlice(slice, nullptr) != StageStatus::kComplete) {
+        return false;
+      }
+      tracklets.push_back(tracker.lastSlice().tracklets);
+    }
+    return true;
+  };
+  std::size_t slicePeak = 0U;
+  std::size_t endPeak = 0U;
+  {
+    const auto probe = kernels().makeToyBarrel8Tracker(*device, block(kArenaBytes));
+    probe->setStagingCapacity(1U);
+    BOOST_REQUIRE((probe->configureRun(parameters, trackingGeometry(), UniformMaterial{}, Propagator{}) == StageStatus::kComplete));
+    BOOST_REQUIRE((probe->beginTimeframe(*fixture.frame, plan) == StageStatus::kComplete));
+    BOOST_REQUIRE(runSlices(*probe, 0U));
+    slicePeak = probe->arenaPeakBytes();
+    BOOST_REQUIRE((probe->endIteration(nullptr) == StageStatus::kComplete));
+    endPeak = probe->arenaPeakBytes();
+    // After a committed first iteration the second's tracklets are fewer:
+    // the check below tells a free mask from a committed one.
+    BOOST_REQUIRE(runSlices(*probe, 1U));
+    BOOST_TEST(tracklets != aloneTracklets);
+    BOOST_REQUIRE((probe->endIteration(nullptr) == StageStatus::kComplete));
+  }
+  BOOST_REQUIRE(endPeak > slicePeak);
+  constexpr std::size_t kAlignment = 256U;
+  const std::size_t step = std::max(kAlignment, ((endPeak - slicePeak) / 48U) / kAlignment * kAlignment);
+  std::size_t failedEnds = 0U;
+  std::size_t checkedAfter = 0U;
+  for (std::size_t bytes = slicePeak; bytes < endPeak; bytes += step) {
+    const SliceScope slices;
+    const auto tracker = kernels().makeToyBarrel8Tracker(*device, block(bytes));
+    tracker->setStagingCapacity(1U);
+    BOOST_REQUIRE((tracker->configureRun(parameters, trackingGeometry(), UniformMaterial{}, Propagator{}) == StageStatus::kComplete));
+    BOOST_REQUIRE((tracker->beginTimeframe(*fixture.frame, plan) == StageStatus::kComplete));
+    const auto scratchBefore = tracker->arenaUsedBytes(ArenaEnd::kScratch);
+    const auto baseBefore = tracker->arenaUsedBytes(ArenaEnd::kBase);
+    if (!runSlices(*tracker, 0U)) {
+      static_cast<void>(tracker->endIteration(nullptr));
+      continue;
+    }
+    const auto status = tracker->endIteration(nullptr);
+    if (status == StageStatus::kComplete) {
+      continue;
+    }
+    BOOST_TEST_CONTEXT("arena of " << bytes << " bytes")
+    {
+      BOOST_TEST((status == StageStatus::kOutOfMemory));
+      ++failedEnds;
+      BOOST_TEST(tracker->arenaUsedBytes(ArenaEnd::kScratch) == scratchBefore);
+      BOOST_TEST(tracker->arenaUsedBytes(ArenaEnd::kBase) == baseBefore);
+      typename TrackRefit<Det>::Tracks tracks;
+      tracks.setMemoryResource(pool.get());
+      tracker->downloadTracks(tracks);
+      BOOST_TEST(tracks.size() == 0U);
+      // The next iteration reads a free mask: its tracklets are those of the
+      // iteration alone, which would lose the first iteration's rows to a
+      // committed mask. Its end, if the arena has room, leaves the mask the
+      // iteration alone does.
+      if (runSlices(*tracker, 1U)) {
+        BOOST_TEST(tracklets == aloneTracklets, boost::test_tools::per_element());
+        ++checkedAfter;
+        DeviceIterationDownload<Det> onDevice{pool};
+        if (tracker->endIteration(&onDevice) == StageStatus::kComplete) {
+          BOOST_TEST(onDevice.used == aloneMask, boost::test_tools::per_element());
+          BOOST_TEST(onDevice.tracks.size() == aloneResult.tracks->size());
+        }
+      } else {
+        static_cast<void>(tracker->endIteration(nullptr));
+      }
+    }
+  }
+  BOOST_TEST(failedEnds > 0U);
+  BOOST_TEST(checkedAfter > 0U);
+  BOOST_TEST_MESSAGE(device->backend() << ": ends need " << slicePeak << " to " << endPeak << " bytes; " << failedEnds << " arenas failed the end, " << checkedAfter << " then ran the next iteration");
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/device/testFlatStage.cxx b/Detectors/GenericTracking/tracking/test/device/testFlatStage.cxx
new file mode 100644
index 0000000000000..0f1942e9daec9
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/testFlatStage.cxx
@@ -0,0 +1,198 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testFlatStage.cxx
+/// \brief The flat candidate list against the serial reference:
+///        `flat::runFlat` over the
+///        synthetic candidates, its output downloaded and compared byte for
+///        byte with `StageOutput::runSerial` of the same walk and test --
+///        counts, offsets and every column -- over whole runs, listed runs,
+///        forced chunks, a source past the ordinal's reach and empty runs.
+///        Built once per backend; needs the device.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK FlatStage
+#include <boost/test/unit_test.hpp>
+
+#include "DeviceTestFixture.h"
+#include "DeviceTestKernels.h"
+#include "StageOutputComparison.h"
+#include "SyntheticStage.h"
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "SerialReferences.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace o2::gtrk
+{
+namespace
+{
+
+using namespace device_test;
+using Output = StageOutput<TrackletT>;
+using synthetic::Kind;
+
+/// The host's serial reference: the same candidates, the same test.
+std::unique_ptr<Output> serial(Kind kind, std::uint32_t divisor, std::uint32_t elements, StageStatus expected = StageStatus::kComplete)
+{
+  auto output = std::make_unique<Output>();
+  output->setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  output->prepare(elements);
+  BOOST_REQUIRE((runSerial(*output, synthetic::FlatGenerator{.count = {.kind = kind}, .accept = {.divisor = divisor}}) == expected));
+  return output;
+}
+
+struct DeviceRun {
+  StageStatus status = StageStatus::kComplete;
+  FlatRunInfo info;
+  Output output;
+};
+
+std::unique_ptr<DeviceRun> onDevice(DeviceRuntime& device, DeviceArena& arena, Kind kind, std::uint32_t divisor, std::uint32_t elements, bool listed = false, std::size_t maxChunkPairs = 0U)
+{
+  auto stream = device.createStream();
+  auto run = std::make_unique<DeviceRun>();
+  run->output.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  run->status = kernels().runFlatSynthetic(device, stream, arena, kind, divisor, elements, listed, maxChunkPairs, run->output, run->info);
+  stream.synchronize();
+  return run;
+}
+
+} // namespace
+
+/// With every candidate accepted the flat run is the staged run: the
+/// canonical sample output, record for record.
+BOOST_AUTO_TEST_CASE(TheSampleGivesTheCanonicalOutput)
+{
+  auto* device = runtime();
+  DeviceArena arena{*device, block(kArenaBytes)};
+  const auto run = onDevice(*device, arena, Kind::kSample, 0U, 5U);
+  BOOST_REQUIRE((run->status == StageStatus::kComplete));
+  const std::array<std::uint32_t, 6> offsets{0, 1, 3, 3, 5, 5};
+  BOOST_TEST(std::ranges::equal(run->output.offsets(), offsets));
+  BOOST_TEST(run->output.size() == 5U);
+  BOOST_TEST(run->info.report.candidates == 5U);
+  BOOST_TEST(run->info.report.chunks == 1U);
+  BOOST_TEST(run->info.report.largest == 2U);
+  BOOST_TEST(sameStageOutput(run->output, *serial(Kind::kSample, 0U, 5U)));
+}
+
+/// The test refuses a third of the candidates: the records, their order and
+/// the counts are the serial loop's, for each kind of element count.
+BOOST_AUTO_TEST_CASE(TheDeviceMatchesTheSerialReference)
+{
+  auto* device = runtime();
+  DeviceArena arena{*device, block(kArenaBytes)};
+  for (const Kind kind : {Kind::kSample, Kind::kUneven, Kind::kIrregular}) {
+    for (const std::uint32_t divisor : {0U, 2U, 3U}) {
+      const auto reference = serial(kind, divisor, 97U);
+      const auto run = onDevice(*device, arena, kind, divisor, 97U);
+      BOOST_REQUIRE((run->status == StageStatus::kComplete));
+      BOOST_TEST(sameStageOutput(run->output, *reference), "kind " << static_cast<int>(kind) << " divisor " << divisor);
+    }
+  }
+  constexpr std::uint32_t kLarge = 200000U;
+  const auto reference = serial(Kind::kIrregular, 3U, kLarge);
+  const auto run = onDevice(*device, arena, Kind::kIrregular, 3U, kLarge);
+  BOOST_REQUIRE((run->status == StageStatus::kComplete));
+  BOOST_TEST(run->output.size() == reference->size());
+  BOOST_TEST(sameStageOutput(run->output, *reference));
+  BOOST_TEST_MESSAGE(device->backend() << ": " << kLarge << " elements, " << run->info.report.candidates << " candidates, " << run->output.size() << " records, " << run->info.report.chunks << " chunk(s), " << run->info.report.readbacks << " readbacks");
+}
+
+/// Chunks of one, seven and a thousand pairs cut the list inside elements;
+/// the chunks' outputs concatenate into the one-chunk run's.
+BOOST_AUTO_TEST_CASE(ChunksConcatenate)
+{
+  auto* device = runtime();
+  DeviceArena arena{*device, block(kArenaBytes)};
+  constexpr std::uint32_t kElements = 2000U;
+  const auto reference = serial(Kind::kIrregular, 3U, kElements);
+  const auto whole = onDevice(*device, arena, Kind::kIrregular, 3U, kElements);
+  BOOST_REQUIRE((whole->status == StageStatus::kComplete));
+  BOOST_TEST(whole->info.report.chunks == 1U);
+  for (const std::size_t chunk : {std::size_t{1U}, std::size_t{7U}, std::size_t{1000U}}) {
+    const auto run = onDevice(*device, arena, Kind::kIrregular, 3U, kElements, false, chunk);
+    BOOST_REQUIRE((run->status == StageStatus::kComplete));
+    BOOST_TEST(run->info.report.chunks > 1U);
+    BOOST_TEST(run->info.report.candidates == whole->info.report.candidates);
+    BOOST_TEST(sameStageOutput(run->output, *reference), "chunks of " << chunk);
+    BOOST_TEST(sameStageOutput(run->output, whole->output), "chunks of " << chunk);
+  }
+}
+
+/// Over a list -- every element that emits and every third of the rest --
+/// the output is the full run's: the rest's counts are 0.
+BOOST_AUTO_TEST_CASE(AListedRunGivesTheFullOutput)
+{
+  auto* device = runtime();
+  DeviceArena arena{*device, block(kArenaBytes)};
+  constexpr std::uint32_t kElements = 2000U;
+  for (const Kind kind : {Kind::kUneven, Kind::kIrregular}) {
+    const auto reference = serial(kind, 3U, kElements);
+    const auto run = onDevice(*device, arena, kind, 3U, kElements, true);
+    BOOST_REQUIRE((run->status == StageStatus::kComplete));
+    BOOST_TEST(run->info.listed < kElements);
+    BOOST_TEST(sameStageOutput(run->output, *reference), "kind " << static_cast<int>(kind));
+    const auto chunked = onDevice(*device, arena, kind, 3U, kElements, true, 5U);
+    BOOST_REQUIRE((chunked->status == StageStatus::kComplete));
+    BOOST_TEST(sameStageOutput(chunked->output, *reference), "kind " << static_cast<int>(kind) << " in chunks");
+  }
+}
+
+/// An element with more candidates than an ordinal numbers is no concern of
+/// the list; its accepted records are, as the staging's limit: past it the
+/// run reports the overflow the serial reference reports.
+BOOST_AUTO_TEST_CASE(AnOversizedElementIsCountedNotNumbered)
+{
+  auto* device = runtime();
+  DeviceArena arena{*device, block(kArenaBytes)};
+  constexpr std::uint32_t kElements = 4U;
+  const auto reference = serial(Kind::kOverflow, 3U, kElements);
+  const auto run = onDevice(*device, arena, Kind::kOverflow, 3U, kElements);
+  BOOST_REQUIRE((run->status == StageStatus::kComplete));
+  BOOST_TEST(run->info.report.largest == Output::kMaxPerElement + 1U);
+  BOOST_TEST(sameStageOutput(run->output, *reference));
+  const auto chunked = onDevice(*device, arena, Kind::kOverflow, 3U, kElements, false, 4096U);
+  BOOST_REQUIRE((chunked->status == StageStatus::kComplete));
+  BOOST_TEST(chunked->info.report.chunks > 1U);
+  BOOST_TEST(sameStageOutput(chunked->output, *reference));
+
+  serial(Kind::kOverflow, 0U, kElements, StageStatus::kOrdinalOverflow);
+  const auto overflow = onDevice(*device, arena, Kind::kOverflow, 0U, kElements);
+  BOOST_TEST((overflow->status == StageStatus::kOrdinalOverflow));
+}
+
+/// No elements, and elements with no candidates: a complete, empty output.
+BOOST_AUTO_TEST_CASE(EmptyRunsComplete)
+{
+  auto* device = runtime();
+  DeviceArena arena{*device, block(kArenaBytes)};
+  const auto none = onDevice(*device, arena, Kind::kIrregular, 3U, 0U);
+  BOOST_REQUIRE((none->status == StageStatus::kComplete));
+  BOOST_TEST(none->output.size() == 0U);
+  BOOST_TEST(none->info.report.candidates == 0U);
+  // kUneven's elements past the 40th have no candidates: from the 50th on, none at all.
+  const auto reference = serial(Kind::kIrregular, 3U, 11U);
+  const auto run = onDevice(*device, arena, Kind::kIrregular, 3U, 11U);
+  BOOST_REQUIRE((run->status == StageStatus::kComplete));
+  BOOST_TEST(sameStageOutput(run->output, *reference));
+  BOOST_TEST(run->output.counts()[0] == 0U); // element 0 has (0 * 7) mod 11 = 0 candidates
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/device/testGpuStage.cxx b/Detectors/GenericTracking/tracking/test/device/testGpuStage.cxx
new file mode 100644
index 0000000000000..6d088feb088f3
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/testGpuStage.cxx
@@ -0,0 +1,214 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testGpuStage.cxx
+/// \brief GpuStage against the serial reference: the device half of the
+///        stages' output equality test.
+///
+/// Built once per backend. Every device result is downloaded into a host
+/// StageOutput and compared with runSerial byte for byte: counts, offsets and
+/// every column. Needs the device.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK GpuStage
+#include <boost/test/unit_test.hpp>
+
+#include "DeviceTestFixture.h"
+#include "DeviceTestKernels.h"
+#include "StageOutputComparison.h"
+#include "SyntheticStage.h"
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "SerialReferences.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+namespace
+{
+
+using namespace device_test;
+
+using Output = StageOutput<TrackletT>;
+using synthetic::Kind;
+
+/// The host's serial reference for \a kind over \a elements elements.
+std::unique_ptr<Output> serial(Kind kind, std::uint32_t elements, StageStatus expected = StageStatus::kComplete)
+{
+  auto output = std::make_unique<Output>();
+  output->setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  output->prepare(elements);
+  BOOST_REQUIRE((runSerial(*output, synthetic::Generator{.count = {.kind = kind}}) == expected));
+  return output;
+}
+
+/// A device run of \a kind, downloaded into a host StageOutput.
+struct DeviceRun {
+  StageStatus status = StageStatus::kComplete;
+  SyntheticRunInfo info;
+  Output output;
+};
+
+std::unique_ptr<DeviceRun> onDevice(DeviceRuntime& device, DeviceArena& arena, Kind kind, std::uint32_t elements, std::size_t capacity)
+{
+  auto stream = device.createStream();
+  auto run = std::make_unique<DeviceRun>();
+  run->output.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  run->status = kernels().runSynthetic(device, stream, arena, kind, elements, capacity, run->output, run->info);
+  stream.synchronize();
+  return run;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(TheSampleGivesTheCanonicalOutput)
+{
+  auto* device = runtime();
+  DeviceArena arena{*device, block(kArenaBytes)};
+  const auto run = onDevice(*device, arena, Kind::kSample, 5U, 16U);
+  BOOST_REQUIRE((run->status == StageStatus::kComplete));
+  const std::array<std::uint32_t, 6> offsets{0, 1, 3, 3, 5, 5};
+  BOOST_TEST(std::ranges::equal(run->output.offsets(), offsets));
+  BOOST_TEST(run->output.size() == 5U);
+  const std::array<std::uint32_t, 5> targets{0, 1000, 1001, 3000, 3001};
+  const auto view = std::as_const(run->output).view();
+  for (std::size_t i = 0; i < targets.size(); ++i) {
+    BOOST_TEST(view[i].target == targets[i]);
+  }
+  BOOST_TEST(std::bit_cast<std::uint32_t>(static_cast<Scalar>(view[2].lambda)) == std::bit_cast<std::uint32_t>(1.125F));
+  BOOST_TEST(sameStageOutput(run->output, *serial(Kind::kSample, 5U)));
+}
+
+/// Thousands of threads race for staging slots; the placement is still the
+/// serial loop's, record for record.
+BOOST_AUTO_TEST_CASE(TheDeviceMatchesTheSerialReference)
+{
+  auto* device = runtime();
+  DeviceArena arena{*device, block(kArenaBytes)};
+  for (const Kind kind : {Kind::kUneven, Kind::kIrregular}) {
+    const auto reference = serial(kind, 97U);
+    const auto run = onDevice(*device, arena, kind, 97U, 4096U);
+    BOOST_REQUIRE((run->status == StageStatus::kComplete));
+    BOOST_TEST(!run->info.predictionMissed);
+    BOOST_TEST(sameStageOutput(run->output, *reference), "kind " << static_cast<int>(kind));
+  }
+
+  constexpr std::uint32_t kLarge = 200000U;
+  const auto reference = serial(Kind::kIrregular, kLarge);
+  const auto run = onDevice(*device, arena, Kind::kIrregular, kLarge, std::size_t{kLarge} * 6U);
+  BOOST_REQUIRE((run->status == StageStatus::kComplete));
+  BOOST_TEST(run->output.size() == reference->size());
+  BOOST_TEST(sameStageOutput(run->output, *reference));
+}
+
+/// Over a list -- every element that emits, and every third of the rest --
+/// the stage gives the full run's output: the rest's counts are 0.
+BOOST_AUTO_TEST_CASE(AListedRunGivesTheFullOutput)
+{
+  auto* device = runtime();
+  DeviceArena arena{*device, block(kArenaBytes)};
+  for (const Kind kind : {Kind::kUneven, Kind::kIrregular}) {
+    constexpr std::uint32_t kElements = 2000U;
+    const auto reference = serial(kind, kElements);
+    auto stream = device->createStream();
+    DeviceRun run;
+    run.output.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    run.status = kernels().runSyntheticListed(*device, stream, arena, kind, kElements, std::size_t{kElements} * 12U, run.output, run.info);
+    stream.synchronize();
+    BOOST_REQUIRE((run.status == StageStatus::kComplete));
+    BOOST_TEST(run.info.listed < kElements);
+    BOOST_TEST(sameStageOutput(run.output, *reference), "kind " << static_cast<int>(kind));
+  }
+}
+
+/// A staging capacity of one overflows, the retry runs at the exact
+/// size and keeps it, and the output does not depend on the mispredict.
+BOOST_AUTO_TEST_CASE(AMispredictRetriesOnceAtTheExactSize)
+{
+  auto* device = runtime();
+  DeviceArena arena{*device, block(kArenaBytes)};
+  const auto reference = serial(Kind::kUneven, 60U);
+  const auto run = onDevice(*device, arena, Kind::kUneven, 60U, 1U);
+  BOOST_REQUIRE((run->status == StageStatus::kComplete));
+  BOOST_TEST(run->info.predictionMissed);
+  BOOST_TEST(run->info.capacityAfter == reference->size());
+  BOOST_TEST(sameStageOutput(run->output, *reference));
+}
+
+BOOST_AUTO_TEST_CASE(TooManyRecordsForOneElementFailAsOnTheHost)
+{
+  auto* device = runtime();
+  DeviceArena arena{*device, block(kArenaBytes)};
+  static_cast<void>(serial(Kind::kOverflow, 3U, StageStatus::kOrdinalOverflow));
+  const auto run = onDevice(*device, arena, Kind::kOverflow, 3U, Output::kMaxPerElement + 8U);
+  BOOST_TEST((run->status == StageStatus::kOrdinalOverflow));
+}
+
+/// An arena too small is a refusal, not a throw, and leaves the arena as the
+/// run found it: counts and offsets on the base end, nothing on the scratch
+/// end. Once the staging is refused, once the output after a staging that fit.
+BOOST_AUTO_TEST_CASE(AnExhaustedArenaIsOutOfMemory)
+{
+  auto* device = runtime();
+  // 1001 counts and 1001 offsets, 4004 bytes each, the second 256-aligned.
+  constexpr std::size_t kCountsAndOffsets = 4096U + 4004U;
+  for (const std::size_t bytes : {std::size_t{16} * 1024U, std::size_t{150} * 1024U}) {
+    const SliceScope slices;
+    DeviceArena arena{*device, block(bytes)};
+    const auto run = onDevice(*device, arena, Kind::kIrregular, 1000U, 5000U);
+    BOOST_TEST((run->status == StageStatus::kOutOfMemory), "arena " << bytes);
+    BOOST_TEST(arena.used(ArenaEnd::kScratch) == 0U);
+    BOOST_TEST(arena.used(ArenaEnd::kBase) == kCountsAndOffsets, "arena " << bytes);
+    if (bytes > std::size_t{100} * 1024U) {
+      BOOST_TEST(arena.peak() > std::size_t{100} * 1024U); // the staging did fit: the output was refused
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(AnEmptyStageIsAValidEmptyOutput)
+{
+  auto* device = runtime();
+  DeviceArena arena{*device, block(kArenaBytes)};
+  const auto run = onDevice(*device, arena, Kind::kIrregular, 0U, 16U);
+  BOOST_REQUIRE((run->status == StageStatus::kComplete));
+  BOOST_TEST(run->output.size() == 0U);
+  BOOST_TEST(run->output.offsets().size() == 1U);
+  BOOST_TEST(run->output.offsets().front() == 0U);
+}
+
+/// Staging and scan storage are gone when run returns; counts, offsets and
+/// the placed output stay on the base end, in the caller's scope.
+BOOST_AUTO_TEST_CASE(TheScratchIsReleasedAndTheOutputStays)
+{
+  auto* device = runtime();
+  DeviceArena arena{*device, block(kArenaBytes)};
+  const auto run = onDevice(*device, arena, Kind::kIrregular, 5000U, 40000U);
+  BOOST_REQUIRE((run->status == StageStatus::kComplete));
+  BOOST_TEST(run->info.scratchAfter == 0U);
+  const std::size_t kept = arena.used(ArenaEnd::kBase);
+  constexpr std::size_t kTrackletBytes = 4U + 4U + 2U + 4U + 4U;
+  const std::size_t minimum = (std::size_t{2} * (std::size_t{5000} + 1U) * sizeof(std::uint32_t)) + (std::size_t{run->output.size()} * kTrackletBytes);
+  BOOST_TEST(kept >= minimum);
+  BOOST_TEST(arena.peak() > kept); // the staging was there, on the other end
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/device/testRoadGlue.cxx b/Detectors/GenericTracking/tracking/test/device/testRoadGlue.cxx
new file mode 100644
index 0000000000000..38da08e3fcd5f
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/testRoadGlue.cxx
@@ -0,0 +1,211 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testRoadGlue.cxx
+/// \brief A slice's road counts, starts and offsets on a device against
+///        RoadCount on generated triplet graphs.
+///
+/// Built once per backend. Needs the device.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK road glue
+#include <boost/test/unit_test.hpp>
+
+#include "DeviceTestFixture.h"
+#include "DeviceTestKernels.h"
+#include "ToyBarrel8Fixture.h"
+
+#include "GenericTracking/Tracking/RoadCount.h"
+#include "SerialReferences.h"
+#include "FixedPointReferences.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <random>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk
+{
+namespace
+{
+
+using namespace device_test;
+using namespace toybarrel8;
+constexpr std::size_t kLayerCount = static_cast<std::size_t>(Detector<Det>::nLayers);
+constexpr std::uint32_t kRowsPerLayer = 1000U;
+
+const auto kSerial = [](std::uint32_t elements, const auto& body) {
+  for (std::uint32_t element = 0; element < elements; ++element) {
+    body(element);
+  }
+};
+
+IterationParameters<Det> parameters()
+{
+  const std::array<double, kLayers> material{};
+  return iterationParameters<Det>(iterationSettings(), Fixture::kBeamConstraint, scatteringTable<Det>(material));
+}
+
+/// The first half of every layer's rows is the slice's core.
+std::array<MeasurementRange, kLayerCount> core()
+{
+  std::array<MeasurementRange, kLayerCount> result{};
+  for (std::size_t layer = 0; layer < kLayerCount; ++layer) {
+    const auto begin = static_cast<std::uint32_t>(layer) * kRowsPerLayer;
+    result[layer] = {.begin = begin, .end = begin + (kRowsPerLayer / 2U)};
+  }
+  return result;
+}
+
+/// A triplet graph: the tracklets, the triplets on them, each triplet's
+/// predecessors -- all earlier in the arena, so the graph is acyclic -- and
+/// the levels the host's sweep gives them.
+struct Graph {
+  std::unique_ptr<StageOutput<TrackletT>> tracklets;
+  std::unique_ptr<StageOutput<TripletT>> triplets;
+  std::unique_ptr<StageOutput<NeighbourT>> neighbours;
+  std::vector<std::uint32_t> chained;
+};
+
+Graph graph(const IterationParameters<Det>& iteration, const std::vector<Tracklet>& tracklets, const std::vector<std::uint32_t>& firstTracklet, const std::vector<std::vector<std::uint32_t>>& predecessors)
+{
+  Graph result;
+  result.tracklets = recordsOf<TrackletT>(tracklets);
+  std::vector<Triplet> triplets(firstTracklet.size());
+  for (std::size_t i = 0; i < triplets.size(); ++i) {
+    triplets[i] = Triplet{.first = firstTracklet[i], .second = firstTracklet[i], .curvature = 0.F, .varCurvature = 0.F, .level = 1U, .kinked = 0U};
+  }
+  result.triplets = recordsOf<TripletT>(triplets);
+  result.neighbours = std::make_unique<StageOutput<NeighbourT>>();
+  result.neighbours->setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  result.neighbours->prepare(static_cast<std::uint32_t>(predecessors.size()));
+  BOOST_REQUIRE(runSerial(*result.neighbours, [&](std::uint32_t element, auto& emitter) {
+                  for (const auto from : predecessors[element]) {
+                    emitter.emit(Neighbour{.from = from});
+                  }
+                }) == StageStatus::kComplete);
+  result.chained = chainedTriplets(*result.neighbours);
+  static_cast<void>(fixedPointLevels(kSerial, *result.neighbours, *result.triplets));
+  static_cast<void>(iteration);
+  return result;
+}
+
+/// The host's RoadCount and the device's glue on \a graph: the same status,
+/// and on success the same flags, counts, starts and offsets.
+StageStatus compare(const IterationParameters<Det>& iteration, const Graph& input)
+{
+  const auto cores = core();
+  RoadCount host;
+  host.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  const auto hostStatus = fixedPointRoads(host, kSerial, iteration.linkSources, cores.data(), roadStartRule(iteration), *input.tracklets, *input.triplets, *input.neighbours);
+  BOOST_TEST_MESSAGE("host: " << host.starts().size() << " starts, " << host.roadCount() << " roads, status " << static_cast<int>(hostStatus));
+  Device device;
+  RoadGlueResult ordered;
+  const auto orderedStatus = kernels().orderedRoadGlue(*device.runtime, device.stream, *device.arena, iteration, *input.tracklets, *input.triplets, *input.neighbours, cores, ordered);
+  BOOST_TEST((orderedStatus == hostStatus));
+  BOOST_TEST(ordered.chained == input.chained.size());
+  if (hostStatus == StageStatus::kComplete && orderedStatus == StageStatus::kComplete) {
+    BOOST_TEST(std::ranges::equal(ordered.successorAbove, host.successorAbove()));
+    BOOST_TEST(std::ranges::equal(ordered.roads, host.roads()));
+    BOOST_TEST(std::ranges::equal(ordered.starts, host.starts()));
+    BOOST_TEST(std::ranges::equal(ordered.offsets, host.roadOffsets()));
+  }
+  BOOST_TEST(device.arena->used() == 0U);
+  return hostStatus;
+}
+
+/// A ladder of \a levels levels, two triplets each, every one a predecessor of
+/// both above it: the level-k triplets have 2^(k-1) roads each.
+Graph ladder(const IterationParameters<Det>& iteration, std::uint32_t levels)
+{
+  const auto coreRow = static_cast<std::uint32_t>(iteration.linkSources[0]) * kRowsPerLayer;
+  const std::size_t tripletCount = std::size_t{2U} * levels;
+  std::vector<Tracklet> tracklets(tripletCount);
+  std::vector<std::uint32_t> first(tripletCount);
+  std::vector<std::vector<std::uint32_t>> predecessors(tripletCount);
+  for (std::uint32_t triplet = 0; triplet < 2U * levels; ++triplet) {
+    tracklets[triplet] = Tracklet{.source = coreRow, .target = coreRow, .link = 0U, .lambda = 0.F, .phi = 0.F};
+    first[triplet] = triplet;
+    if (triplet >= 2U) {
+      const std::uint32_t below = ((triplet / 2U) - 1U) * 2U;
+      predecessors[triplet] = {below, below + 1U};
+    }
+  }
+  return graph(iteration, tracklets, first, predecessors);
+}
+
+} // namespace
+
+/// Random acyclic graphs: tracklets inside and outside the core, triplets
+/// with up to three predecessors.
+BOOST_AUTO_TEST_CASE(RandomGraphsGiveTheHostsRoads)
+{
+  const auto iteration = parameters();
+  std::mt19937 random{21U};
+  for (const std::uint32_t tripletCount : {0U, 1U, 50U, 3000U, 40000U}) {
+    constexpr std::uint32_t kTracklets = 5000U;
+    std::vector<Tracklet> tracklets(kTracklets);
+    for (auto& tracklet : tracklets) {
+      const auto link = static_cast<std::uint16_t>(static_cast<std::uint32_t>(random()) % static_cast<std::uint32_t>(nLinks<Det>));
+      const auto layer = static_cast<std::uint32_t>(iteration.linkSources[link]);
+      const auto source = (layer * kRowsPerLayer) + (static_cast<std::uint32_t>(random()) % kRowsPerLayer);
+      tracklet = Tracklet{.source = source, .target = source, .link = link, .lambda = 0.F, .phi = 0.F};
+    }
+    std::vector<std::uint32_t> first(tripletCount);
+    std::vector<std::vector<std::uint32_t>> predecessors(tripletCount);
+    for (std::uint32_t triplet = 0; triplet < tripletCount; ++triplet) {
+      first[triplet] = static_cast<std::uint32_t>(random()) % kTracklets;
+      const auto count = triplet == 0U ? 0U : static_cast<std::uint32_t>(random()) % 4U;
+      for (std::uint32_t i = 0; i < count; ++i) {
+        predecessors[triplet].push_back(static_cast<std::uint32_t>(random()) % triplet);
+      }
+    }
+    const auto input = graph(iteration, tracklets, first, predecessors);
+    BOOST_TEST_CONTEXT("triplets " << tripletCount) { BOOST_TEST((compare(iteration, input) == StageStatus::kComplete)); }
+  }
+}
+
+/// Counts past 32 bits: a triplet's is kIndexOverflow, and so is a total of
+/// the starts' that is, each count still fitting.
+BOOST_AUTO_TEST_CASE(OverflowsAreStatusesAsOnTheHost)
+{
+  const auto iteration = parameters();
+  BOOST_TEST((compare(iteration, ladder(iteration, 31U)) == StageStatus::kComplete));      // two starts of 2^30
+  BOOST_TEST((compare(iteration, ladder(iteration, 32U)) == StageStatus::kIndexOverflow)); // two of 2^31: the total
+  BOOST_TEST((compare(iteration, ladder(iteration, 33U)) == StageStatus::kIndexOverflow)); // 2^32 each
+  auto masked = iteration;
+  masked.roadEndLayers = std::uint64_t{1U} << 7U;
+  BOOST_TEST((compare(masked, ladder(masked, 32U)) == StageStatus::kComplete));      // excluded starts: no total overflow
+  BOOST_TEST((compare(masked, ladder(masked, 33U)) == StageStatus::kIndexOverflow)); // individual overflow remains sticky
+}
+
+/// Only level-1 triplets, below the start level: no roads, one offset.
+BOOST_AUTO_TEST_CASE(NoStartsGiveOneOffset)
+{
+  const auto iteration = parameters();
+  BOOST_REQUIRE(iteration.minRoadStartLevel > 1U);
+  const auto coreRow = static_cast<std::uint32_t>(iteration.linkSources[0]) * kRowsPerLayer;
+  const std::vector<Tracklet> tracklets(4U, Tracklet{.source = coreRow, .target = coreRow, .link = 0U, .lambda = 0.F, .phi = 0.F});
+  const auto input = graph(iteration, tracklets, {0U, 1U, 2U, 3U}, std::vector<std::vector<std::uint32_t>>(4U));
+  BOOST_TEST((compare(iteration, input) == StageStatus::kComplete));
+  RoadCount host;
+  host.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  const auto cores = core();
+  BOOST_REQUIRE(fixedPointRoads(host, kSerial, iteration.linkSources, cores.data(), roadStartRule(iteration), *input.tracklets, *input.triplets, *input.neighbours) == StageStatus::kComplete);
+  BOOST_TEST(host.starts().empty());
+  BOOST_TEST(host.roadOffsets().size() == 1U);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/device/testSelectionGlue.cxx b/Detectors/GenericTracking/tracking/test/device/testSelectionGlue.cxx
new file mode 100644
index 0000000000000..9e654d27e5a8a
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/testSelectionGlue.cxx
@@ -0,0 +1,233 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testSelectionGlue.cxx
+/// \brief An iteration's global selection on the device against
+///        GlobalSelection::select on the host: the ranked and selected
+///        records, the duplicates and
+///        mismatches, the rounds and the mask, all equal.
+///
+/// Generated records with ties in every part of the quality order,
+/// duplicates the same and differing, sharing on and off, and a mask that
+/// arrives with an earlier iteration's tracks. Built once per backend. Needs
+/// the device.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK selection glue
+#include <boost/test/unit_test.hpp>
+
+#include "DeviceTestFixture.h"
+#include "DeviceTestKernels.h"
+
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/Selection.h"
+#include "SerialReferences.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <random>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk
+{
+namespace
+{
+
+using namespace device_test;
+constexpr std::size_t kK = kToyBarrel8Clusters;
+using Record = ToyBarrel8Records::Record;
+using Selection = GlobalSelection<kK>;
+
+const auto kSerial = [](std::uint32_t elements, const auto& body) {
+  for (std::uint32_t element = 0; element < elements; ++element) {
+    body(element);
+  }
+};
+
+/// \a count random records over \a rows rows: 3 to K clusters, the chi2 from
+/// four values and the kinks from two, so that every tie of the quality
+/// order occurs; every seventh an exact duplicate of an earlier record, and
+/// with \a differing every thirteenth one with the same clusters in another
+/// order, which the host counts as a mismatch.
+std::vector<Record> generate(std::uint32_t count, std::uint32_t rows, bool differing, std::uint32_t seed)
+{
+  std::mt19937 random{seed};
+  std::uniform_int_distribution<std::uint32_t> row{0U, rows - 1U};
+  std::uniform_int_distribution<std::uint32_t> length{3U, static_cast<std::uint32_t>(kK)};
+  std::uniform_int_distribution<std::uint32_t> pick{0U, 3U};
+  constexpr std::array<Scalar, 4> kChi2{0.F, 1.5F, 1.5F, 7.25F};
+  std::vector<Record> records;
+  records.reserve(count);
+  for (std::uint32_t i = 0; i < count; ++i) {
+    if (i > 0U && i % 7U == 0U) {
+      std::uniform_int_distribution<std::uint32_t> earlier{0U, i - 1U};
+      records.push_back(records[earlier(random)]);
+      continue;
+    }
+    if (differing && i > 0U && i % 13U == 0U) {
+      auto copy = records[i - 1U];
+      std::reverse(copy.clusters.index, copy.clusters.index + copy.count);
+      records.push_back(copy);
+      continue;
+    }
+    Record record;
+    const auto clusters = length(random);
+    std::vector<std::uint32_t> chosen;
+    while (chosen.size() < clusters) {
+      const auto candidate = row(random);
+      if (std::ranges::find(chosen, candidate) == chosen.end()) {
+        chosen.push_back(candidate);
+      }
+    }
+    for (std::size_t k = 0; k < kK; ++k) {
+      record.clusters.index[k] = k < chosen.size() ? chosen[k] : ClusterList<kK>::kNoCluster;
+    }
+    record.count = static_cast<std::uint8_t>(clusters);
+    record.chi2 = kChi2[pick(random)];
+    record.kinks = static_cast<std::uint8_t>(pick(random) % 2U);
+    records.push_back(record);
+  }
+  return records;
+}
+
+std::unique_ptr<ToyBarrel8Records> columnsOf(const std::vector<Record>& records, const std::shared_ptr<BoundedMemoryResource>& pool)
+{
+  auto columns = std::make_unique<ToyBarrel8Records>();
+  columns->setMemoryResource(pool.get());
+  columns->resize(records.size());
+  const auto view = columns->view();
+  for (std::size_t i = 0; i < records.size(); ++i) {
+    view.clusters[i] = records[i].clusters;
+    view.count[i] = records[i].count;
+    view.chi2[i] = records[i].chi2;
+    view.kinks[i] = records[i].kinks;
+  }
+  return columns;
+}
+
+/// The host's selection of the same records, into its own copy of the mask.
+struct HostOutcome {
+  std::vector<std::uint32_t> ranked;
+  std::vector<std::uint32_t> selected;
+  std::vector<std::uint8_t> mask;
+  std::uint32_t duplicates = 0U;
+  std::uint32_t mismatches = 0U;
+  std::uint32_t rounds = 0U;
+};
+
+HostOutcome host(const std::vector<Record>& records, std::vector<std::uint8_t> mask, std::uint32_t sharedInnermost)
+{
+  Selection selection;
+  selection.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  selection.clear();
+  Selection::Records output;
+  output.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  output.prepare(static_cast<std::uint32_t>(records.size()));
+  BOOST_REQUIRE(runSerial(output, [&](std::uint32_t element, auto& emitter) { emitter.emit(records[element]); }) == StageStatus::kComplete);
+  BOOST_REQUIRE(selection.append(output, SerialForEach{}) == StageStatus::kComplete);
+  BOOST_REQUIRE(selection.select(kSerial, [](std::span<std::uint32_t> indices, const auto& less) { std::ranges::sort(indices, less); }, sharedInnermost, mask) == StageStatus::kComplete);
+  return {
+    .ranked = {selection.ranked().begin(), selection.ranked().end()},
+    .selected = {selection.selected().begin(), selection.selected().end()},
+    .mask = mask,
+    .duplicates = selection.duplicates(),
+    .mismatches = selection.mismatches(),
+    .rounds = selection.rounds(),
+  };
+}
+
+/// \a rows rows, every eleventh shared and every seventeenth exclusive: an
+/// earlier iteration's tracks.
+std::vector<std::uint8_t> earlierMask(std::uint32_t rows)
+{
+  std::vector<std::uint8_t> mask(rows, kFree);
+  for (std::uint32_t row = 0; row < rows; ++row) {
+    if (row % 17U == 0U) {
+      mask[row] = kExclusive;
+    } else if (row % 11U == 0U) {
+      mask[row] = kShared;
+    }
+  }
+  return mask;
+}
+
+void compare(const std::vector<Record>& records, const std::vector<std::uint8_t>& mask, std::uint32_t sharedInnermost)
+{
+  const auto expected = host(records, mask, sharedInnermost);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto columns = columnsOf(records, pool);
+  Device device;
+  SelectionGlueResult result;
+  BOOST_REQUIRE((kernels().selectionGlue(*device.runtime, device.stream, *device.arena, *columns, mask, sharedInnermost, result) == StageStatus::kComplete));
+  BOOST_TEST(result.ranked == expected.ranked, boost::test_tools::per_element());
+  BOOST_TEST(result.selected == expected.selected, boost::test_tools::per_element());
+  BOOST_TEST(result.mask == expected.mask, boost::test_tools::per_element());
+  BOOST_TEST(result.duplicates == expected.duplicates);
+  BOOST_TEST(result.mismatches == expected.mismatches);
+  BOOST_TEST(result.rounds == expected.rounds);
+  BOOST_TEST(result.scratchAfter == 0U);
+  // The rounds end in the sequential walk's result.
+  std::vector<std::uint8_t> walked = mask;
+  const auto sequential = selectSequentially<kK>(std::as_const(*columns).view(), expected.ranked, sharedInnermost, walked);
+  BOOST_TEST(result.selected == sequential, boost::test_tools::per_element());
+  BOOST_TEST_MESSAGE(runtime()->backend() << ": " << records.size() << " records, " << result.ranked.size() << " unique, " << result.duplicates << " duplicates, " << result.mismatches << " mismatches, " << result.rounds << " rounds, " << result.selected.size() << " selected, " << result.readbacks << " readbacks");
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(TheDeviceSelectsAsTheHost)
+{
+  constexpr std::uint32_t kRows = 3000U;
+  for (const std::uint32_t shared : {0U, 2U}) {
+    for (const bool earlier : {false, true}) {
+      BOOST_TEST_CONTEXT("sharedInnermost " << shared << (earlier ? ", with an earlier iteration's mask" : ", free mask"))
+      {
+        const auto mask = earlier ? earlierMask(kRows) : std::vector<std::uint8_t>(kRows, kFree);
+        compare(generate(5000U, kRows, false, 7U + shared), mask, shared);
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(DuplicatesThatDifferAreCountedAsTheHostCountsThem)
+{
+  constexpr std::uint32_t kRows = 500U;
+  const auto records = generate(2000U, kRows, true, 23U);
+  const auto expected = host(records, std::vector<std::uint8_t>(kRows, kFree), 0U);
+  BOOST_TEST(expected.mismatches > 0U);
+  compare(records, std::vector<std::uint8_t>(kRows, kFree), 0U);
+}
+
+BOOST_AUTO_TEST_CASE(NoRecordsSelectNothing) { compare({}, std::vector<std::uint8_t>(10U, kFree), 0U); }
+
+/// A refusal of the arena returns kOutOfMemory and leaves its scratch end as
+/// it was.
+BOOST_AUTO_TEST_CASE(ARefusalLeavesTheArena)
+{
+  constexpr std::uint32_t kRows = 3000U;
+  const auto records = generate(5000U, kRows, false, 3U);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto columns = columnsOf(records, pool);
+  // Room for the records and the mask, not for the keys: K words a record.
+  const std::size_t recordBytes = records.size() * (sizeof(ClusterList<kK>) + sizeof(std::uint8_t) + sizeof(Scalar) + sizeof(std::uint8_t));
+  Device device{recordBytes + kRows + (std::size_t{64} * 1024U)};
+  SelectionGlueResult result;
+  const std::vector<std::uint8_t> mask(kRows, kFree);
+  BOOST_TEST((kernels().selectionGlue(*device.runtime, device.stream, *device.arena, *columns, mask, 0U, result) == StageStatus::kOutOfMemory));
+  BOOST_TEST(result.scratchAfter == 0U);
+  BOOST_TEST(device.arena->used(ArenaEnd::kBase) == 0U);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/device/testSliceGlue.cxx b/Detectors/GenericTracking/tracking/test/device/testSliceGlue.cxx
new file mode 100644
index 0000000000000..26f1fde616398
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/device/testSliceGlue.cxx
@@ -0,0 +1,287 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testSliceGlue.cxx
+/// \brief The passes between a slice's stages on a device against the host
+///        classes, on generated inputs.
+///
+/// Built once per backend. Needs the device.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK slice glue
+#include <boost/test/unit_test.hpp>
+
+#include "DeviceTestFixture.h"
+#include "DeviceTestKernels.h"
+#include "ToyBarrel8Fixture.h"
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/TrackletPaths.h"
+#include "GenericTracking/Tracking/TripletEndIndex.h"
+#include "GenericTracking/Tracking/TripletPaths.h"
+#include "GenericTracking/Tracking/TripletPermutation.h"
+#include "FixedPointReferences.h"
+#include "SerialReferences.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <random>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk
+{
+namespace
+{
+
+using namespace device_test;
+
+using namespace toybarrel8;
+using Sources = LayerRowMap<Det>;
+constexpr std::size_t kLayerCount = Sources::kLayerCount;
+
+constexpr std::uint32_t kLayerStride = 100000U; ///< rows of layer l start at l * kLayerStride
+
+/// A source map of \a total rows spread over every layer, the first layers
+/// taking the remainder.
+Sources sourceMap(std::uint32_t total)
+{
+  std::array<MeasurementRange, kLayerCount> ranges{};
+  std::array<bool, kLayerCount> presented{};
+  for (std::size_t layer = 0; layer < kLayerCount; ++layer) {
+    const auto rows = static_cast<std::uint32_t>((total / kLayerCount) + (layer < total % kLayerCount ? 1U : 0U));
+    const auto begin = static_cast<std::uint32_t>(layer) * kLayerStride;
+    ranges[layer] = {.begin = begin, .end = begin + rows};
+    presented[layer] = true;
+  }
+  return Sources{ranges, presented};
+}
+
+IterationParameters<Det> parameters()
+{
+  const std::array<double, kLayers> material{};
+  return iterationParameters<Det>(iterationSettings(), Fixture::kBeamConstraint, scatteringTable<Det>(material));
+}
+
+} // namespace
+
+/// Tracklets from every source to rows inside the target layer's source range
+/// or just past it, interleaved, over several source counts and lengths: the
+/// device's compaction with the host's path bounds is the host's permutation
+/// (the path bounds included).
+BOOST_AUTO_TEST_CASE(ThePermutationIsTheHostOrder)
+{
+  Device device;
+  auto iteration = parameters();
+  std::mt19937 random{2024U};
+  for (const std::uint32_t sourceCount : {37U, 256U, 1000U, 1024U}) {
+    const auto sources = sourceMap(sourceCount);
+    constexpr std::uint32_t kTracklets = 100000U;
+    const std::uint32_t perSource = kTracklets / sources.size();
+    auto pool = std::make_shared<BoundedMemoryResource>();
+    StageOutput<TrackletT> tracklets;
+    tracklets.setMemoryPool(pool);
+    tracklets.prepare(sources.size());
+    const auto generate = [&](std::uint32_t element, auto& emitter) {
+      const auto row = sources.row(element);
+      const auto outBegin = iteration.outLinkOffsets[row.layer];
+      const auto outCount = iteration.outLinkOffsets[static_cast<std::size_t>(row.layer) + 1U] - outBegin;
+      if (outCount == 0U) {
+        return;
+      }
+      for (std::uint32_t i = 0; i < perSource; ++i) {
+        const auto link = static_cast<std::uint16_t>(iteration.outLinkIndices[outBegin + (static_cast<std::uint32_t>(random()) % outCount)]);
+        const auto range = sources.ranges[iteration.linkTargets[link]];
+        // Every other tracklet one row past its range: ineligible.
+        const std::uint32_t span = std::max(range.size(), 1U);
+        const std::uint32_t target = (i % 2U == 0U) ? range.begin + (static_cast<std::uint32_t>(random()) % span) : range.end + (static_cast<std::uint32_t>(random()) % 7U);
+        emitter.emit(Tracklet{.source = row.row, .target = target, .link = link, .lambda = 0.F, .phi = 0.F});
+      }
+    };
+    BOOST_REQUIRE(runSerial(tracklets, generate) == StageStatus::kComplete);
+    for (const std::uint32_t length : {3U, 5U, 8U}) {
+      iteration.minClusters = length;
+      TrackletPaths<Det> paths;
+      paths.setMemoryPool(pool);
+      paths.build(iteration, sources, tracklets, SerialForEach{});
+      TripletPermutation<Det> host;
+      host.setMemoryPool(pool);
+      BOOST_REQUIRE(host.build(iteration, sources, tracklets, paths.bounds(), SerialForEach{}, 256U) == StageStatus::kComplete);
+      std::vector<std::uint32_t> onDevice;
+      BOOST_REQUIRE((kernels().permutation(*device.runtime, device.stream, *device.arena, iteration, sources, tracklets, std::span{paths.bounds().prefix, sources.size()}, std::span{paths.bounds().suffix, sources.size()}, onDevice) == StageStatus::kComplete));
+      BOOST_TEST_CONTEXT("sources " << sourceCount << " length " << length)
+      {
+        BOOST_TEST(host.size() < tracklets.size());
+        BOOST_TEST(std::ranges::equal(onDevice, host.indices()));
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(TheEndIndexIsTheHostIndex)
+{
+  Device device;
+  std::mt19937 random{7U};
+  for (const std::uint32_t trackletCount : {1U, 64U, 1000U, 65536U}) {
+    constexpr std::uint32_t kTriplets = 50000U;
+    std::vector<Triplet> records(kTriplets);
+    for (std::uint32_t i = 0; i < kTriplets; ++i) {
+      records[i] = Triplet{
+        .first = static_cast<std::uint32_t>(random()) % trackletCount,
+        .second = static_cast<std::uint32_t>(random()) % trackletCount,
+        .curvature = 0.F,
+        .varCurvature = 0.F,
+        .level = 1U,
+        .kinked = 0U,
+      };
+    }
+    const auto triplets = recordsOf<TripletT>(records);
+    TripletEndIndex host;
+    host.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    BOOST_REQUIRE(host.build(trackletCount, *triplets, SerialForEach{}, std::numeric_limits<std::uint32_t>::max()) == StageStatus::kComplete);
+    std::vector<std::uint32_t> offsets;
+    std::vector<std::uint32_t> indices;
+    BOOST_REQUIRE((kernels().endIndex(*device.runtime, device.stream, *device.arena, *triplets, trackletCount, offsets, indices) == StageStatus::kComplete));
+    BOOST_TEST_CONTEXT("tracklets " << trackletCount)
+    {
+      BOOST_TEST(std::ranges::equal(offsets, std::span<const std::uint32_t>{host.offsets(), std::size_t{trackletCount} + 1U}));
+      BOOST_TEST(std::ranges::equal(indices, std::span<const std::uint32_t>{host.triplets(), host.offsets()[trackletCount]}));
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(TheChainedTripletsAreTheHostOnes)
+{
+  Device device;
+  std::mt19937 random{11U};
+  constexpr std::uint32_t kTriplets = 70000U;
+  std::vector<std::vector<Neighbour>> perTriplet(kTriplets);
+  for (auto& predecessors : perTriplet) {
+    const auto count = static_cast<std::uint32_t>(random()) % 4U == 0U ? static_cast<std::uint32_t>(random()) % 3U + 1U : 0U;
+    for (std::uint32_t i = 0; i < count; ++i) {
+      predecessors.push_back(Neighbour{.from = static_cast<std::uint32_t>(random()) % kTriplets});
+    }
+  }
+  StageOutput<NeighbourT> neighbours;
+  neighbours.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  neighbours.prepare(kTriplets);
+  BOOST_REQUIRE(runSerial(neighbours, [&](std::uint32_t element, auto& emitter) {
+                  for (const auto& neighbour : perTriplet[element]) {
+                    emitter.emit(neighbour);
+                  }
+                }) == StageStatus::kComplete);
+  const auto host = chainedTriplets(neighbours);
+  std::vector<std::uint32_t> onDevice;
+  BOOST_REQUIRE((kernels().chained(*device.runtime, device.stream, *device.arena, neighbours.offsets(), onDevice) == StageStatus::kComplete));
+  BOOST_TEST(host.size() > 0U);
+  BOOST_TEST(std::ranges::equal(onDevice, host));
+}
+
+// Actual layered DAGs, including empty graphs, terminal rows absent from the
+// source map, and irregular source ranges. Compare every bound byte with the
+// independently checked CPU implementation, plus stable early compaction.
+BOOST_AUTO_TEST_CASE(ThePathBoundsAndPrunedPermutationMatchTheHost)
+{
+  Device device;
+  auto pool = std::make_shared<BoundedMemoryResource>();
+  std::mt19937 random{9102026U};
+  for (std::uint32_t graph = 0U; graph < 12U; ++graph) {
+    auto iteration = parameters();
+    std::array<MeasurementRange, kLayerCount> ranges{};
+    std::array<bool, kLayerCount> presented{};
+    for (std::size_t layer = 0U; layer < kLayerCount; ++layer) {
+      const auto begin = static_cast<std::uint32_t>(layer) * 3U;
+      ranges[layer] = {.begin = begin, .end = begin + static_cast<std::uint32_t>(random() % 4U)};
+      presented[layer] = layer + 1U < kLayerCount;
+    }
+    const Sources sources{ranges, presented};
+    StageOutput<TrackletT> tracklets;
+    tracklets.setMemoryPool(pool);
+    tracklets.prepare(sources.size());
+    std::vector<std::vector<Tracklet>> outgoing(sources.size());
+    for (std::uint32_t element = 0U; element < sources.size(); ++element) {
+      const auto row = sources.row(element);
+      for (std::uint32_t target = (row.layer + 1U) * 3U; target < (row.layer + 2U) * 3U; ++target) {
+        if (graph != 0U && random() % 3U != 0U) {
+          outgoing[element].push_back(Tracklet{.source = row.row, .target = target, .link = static_cast<std::uint16_t>(row.layer), .lambda = 0.F, .phi = 0.F});
+        }
+      }
+    }
+    BOOST_REQUIRE(runSerial(tracklets, [&](std::uint32_t element, auto& emitter) {
+                    for (const auto& edge : outgoing[element]) {
+                      emitter.emit(edge);
+                    }
+                  }) == StageStatus::kComplete);
+    // The first tracklets whose middle has tracklets: at 3 clusters and any
+    // end, no path is too short.
+    iteration.minClusters = 3U;
+    iteration.roadEndLayers = 0U;
+    TrackletPaths<Det> firsts;
+    firsts.setMemoryPool(pool);
+    firsts.build(iteration, sources, tracklets, SerialForEach{});
+    TripletPermutation<Det> permutation;
+    permutation.setMemoryPool(pool);
+    BOOST_REQUIRE(permutation.build(iteration, sources, tracklets, firsts.bounds(), SerialForEach{}, 256U) == StageStatus::kComplete);
+    StageOutput<TripletT> triplets;
+    triplets.setMemoryPool(pool);
+    triplets.prepare(permutation.size());
+    std::vector<std::vector<Triplet>> accepted(permutation.size());
+    const auto view = tracklets.view();
+    for (std::uint32_t element = 0U; element < permutation.size(); ++element) {
+      const auto first = permutation.indices()[element];
+      const auto middle = sources.element(iteration.linkTargets[view.link[first]], view.target[first]);
+      for (auto second = tracklets.offsets()[middle]; second < tracklets.offsets()[middle + 1U]; ++second) {
+        if (random() % 3U != 0U) {
+          accepted[element].push_back(Triplet{.first = first, .second = second, .curvature = 0.F, .varCurvature = 0.F, .level = 1U, .kinked = 0U});
+        }
+      }
+    }
+    BOOST_REQUIRE(runSerial(triplets, [&](std::uint32_t element, auto& emitter) {
+                    for (const auto& edge : accepted[element]) {
+                      emitter.emit(edge);
+                    }
+                  }) == StageStatus::kComplete);
+    TrackletPaths<Det> measurements;
+    TripletPaths<Det> acceptedPaths;
+    TripletPermutation<Det> pruned;
+    measurements.setMemoryPool(pool);
+    acceptedPaths.setMemoryPool(pool);
+    pruned.setMemoryPool(pool);
+    for (const std::uint64_t mask : {0ULL, 1ULL << 3U, 1ULL << 7U, (1ULL << 4U) | (1ULL << 6U)}) {
+      for (const auto length : {4U, 7U, 9U}) {
+        iteration.roadEndLayers = mask;
+        iteration.minClusters = length;
+        measurements.build(iteration, sources, tracklets, SerialForEach{});
+        acceptedPaths.build(iteration, sources, tracklets, permutation, placedTriplets(triplets), SerialForEach{});
+        BOOST_REQUIRE(pruned.build(iteration, sources, tracklets, measurements.bounds(), SerialForEach{}, 256U) == StageStatus::kComplete);
+        PathBoundsResult result;
+        BOOST_REQUIRE(kernels().pathBounds(*device.runtime, device.stream, *device.arena, iteration, sources, tracklets, triplets, permutation.indices(), result) == StageStatus::kComplete);
+        BOOST_TEST_CONTEXT("graph " << graph << " mask " << mask << " length " << length)
+        {
+          BOOST_TEST(std::ranges::equal(result.measurementPrefix, std::span{measurements.bounds().prefix, sources.size()}));
+          BOOST_TEST(std::ranges::equal(result.measurementSuffix, std::span{measurements.bounds().suffix, sources.size()}));
+          BOOST_TEST(std::ranges::equal(result.tripletPrefix, std::span{acceptedPaths.bounds().prefix, tracklets.size()}));
+          BOOST_TEST(std::ranges::equal(result.tripletSuffix, std::span{acceptedPaths.bounds().suffix, tracklets.size()}));
+          BOOST_TEST(std::ranges::equal(result.permutation, pruned.indices()));
+        }
+      }
+    }
+  }
+  BOOST_TEST(device.arena->used(ArenaEnd::kScratch) == 0U);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testCovarianceTransport.cxx b/Detectors/GenericTracking/tracking/test/testCovarianceTransport.cxx
new file mode 100644
index 0000000000000..7530d657e205a
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testCovarianceTransport.cxx
@@ -0,0 +1,471 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testCovarianceTransport.cxx
+/// \brief The Jacobian, the covariance transport and the scattering term.
+///
+/// The Monte Carlo case is the one that matters: a Jacobian can be
+/// self-consistently wrong, but a sample covariance built by actually
+/// propagating twenty thousand perturbed states cannot agree with it by
+/// accident.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK CovarianceTransport
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/CovarianceTransport.h"
+#include "GenericTracking/Tracking/Material.h"
+#include "Oracles.h"
+
+#include <array>
+#include <cmath>
+#include <cstring>
+#include <random>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+static TrackingSurface barrelPlane(double x, SensorID id)
+{
+  TrackingSurface s{};
+  s.origin[0] = static_cast<Scalar>(x);
+  s.normal[0] = 1.F;
+  s.axis0[1] = 1.F; // loc0 around the beam
+  s.axis1[2] = 1.F; // loc1 along it
+  s.bounds = SurfaceBounds{.halfX = 1e6F, .halfY = 1e6F};
+  s.id = id;
+  return s;
+}
+
+static TrackingSurface discPlane(double z, SensorID id)
+{
+  TrackingSurface s{};
+  s.origin[2] = static_cast<Scalar>(z);
+  s.normal[2] = 1.F;
+  s.axis0[0] = 1.F;
+  s.axis1[1] = 1.F;
+  s.bounds = SurfaceBounds{.halfX = 1e6F, .halfY = 1e6F};
+  s.id = id;
+  return s;
+}
+
+static BoundTrackState makeState(SensorID id, double phi, double theta, double qOverP)
+{
+  BoundTrackState st;
+  st.par[kPhi] = static_cast<Scalar>(phi);
+  st.par[kTheta] = static_cast<Scalar>(theta);
+  st.par[kQOverP] = static_cast<Scalar>(qOverP);
+  st.surface = id;
+  return st;
+}
+
+BOOST_AUTO_TEST_CASE(JacobianPublishesItsCrossingWithoutChangingTheResult)
+{
+  const Propagator prop;
+  const auto from = barrelPlane(3.4, 1);
+  std::mt19937 random{4703U};
+  std::uniform_real_distribution<double> phi{-1.2, 1.2};
+  std::uniform_real_distribution<double> theta{0.15, 2.99};
+  std::uniform_real_distribution<double> qOverP{-20., 20.};
+  unsigned successful = 0U;
+  unsigned failed = 0U;
+  for (unsigned trial = 0U; trial < 1000U; ++trial) {
+    const auto to = trial % 2U == 0U ? barrelPlane(17.2, 2) : discPlane(trial % 4U == 1U ? 29. : -29., 2);
+    const auto seed = makeState(1, phi(random), theta(random), qOverP(random));
+    SolenoidJacobian expectedJacobian;
+    const auto expectedStatus = jacobianAnalytic(prop, seed, from, to, PropagationDirection::kForward, expectedJacobian);
+    auto expectedState = seed;
+    const auto expectedResult = propagate(prop, expectedState, from, to, PropagationDirection::kForward);
+    auto actualState = seed; // In-place aliasing is used by filterStep.
+    SolenoidJacobian actualJacobian;
+    PropagationResult actualResult;
+    const auto actualStatus = jacobianAnalytic(prop, actualState, from, to, PropagationDirection::kForward, actualJacobian, &actualState, &actualResult);
+    BOOST_TEST(static_cast<unsigned>(actualStatus) == static_cast<unsigned>(expectedStatus));
+    if (actualStatus == PropagationStatus::kOk) {
+      // Bit identity is intentional, including floating-point encodings; these records have no padding.
+      // NOLINTNEXTLINE(bugprone-suspicious-memory-comparison)
+      BOOST_TEST(std::memcmp(&actualState, &expectedState, sizeof(BoundTrackState)) == 0);
+      // Bit identity is intentional, including floating-point encodings; these records have no padding.
+      // NOLINTNEXTLINE(bugprone-suspicious-memory-comparison)
+      BOOST_TEST(std::memcmp(&actualJacobian, &expectedJacobian, sizeof(SolenoidJacobian)) == 0);
+      BOOST_TEST(static_cast<unsigned>(actualResult.status) == static_cast<unsigned>(expectedResult.status));
+      BOOST_TEST(exactlyEqual(actualResult.pathLength, expectedResult.pathLength));
+      ++successful;
+    } else {
+      // Bit identity is intentional, including floating-point encodings; these records have no padding.
+      // NOLINTNEXTLINE(bugprone-suspicious-memory-comparison)
+      BOOST_TEST(std::memcmp(&actualState, &seed, sizeof(BoundTrackState)) == 0);
+      BOOST_TEST(static_cast<unsigned>(actualResult.status) == static_cast<unsigned>(PropagationStatus::kNotFinite));
+      ++failed;
+    }
+  }
+  BOOST_TEST(successful > 100U);
+  BOOST_TEST(failed > 10U);
+}
+
+/// Propagate many samples drawn from a diagonal source covariance and compare
+/// the sample covariance at the target with F P F^T.
+static void checkMonteCarloClosure(const TrackingSurface& from, const TrackingSurface& to, const BoundTrackState& seed, double tolerance, bool analytic = false)
+{
+  const Propagator prop;
+  constexpr int kSamples = 20000;
+
+  const Scalar sigma[kNBoundParams] = {5e-3F, 5e-3F, 1e-3F, 1e-3F, 1e-3F};
+
+  BoundTrackState st = seed;
+  for (int i = 0; i < kNBoundParams; ++i) {
+    st.variance(i) = sigma[i] * sigma[i];
+  }
+
+  Scalar step[kNBoundParams] = {};
+  defaultDifferenceSteps(step);
+  BoundTrackState transported = st;
+  if (analytic) {
+    SolenoidJacobian jac;
+    BOOST_TEST((jacobianAnalytic(prop, st, from, to, PropagationDirection::kForward, jac) == PropagationStatus::kOk));
+    auto factors = factorCovariance(st.cov);
+    BOOST_REQUIRE(transportFactors(jac, StepNoise{}, factors));
+    covarianceFromFactors(factors, transported.cov);
+  } else {
+    Scalar jac[kJacobianSize] = {};
+    BOOST_TEST((jacobianFiniteDifference(prop, st, from, to, PropagationDirection::kForward, step, jac) == PropagationStatus::kOk));
+    transportCovarianceDense(jac, transported.cov);
+  }
+  BOOST_TEST((propagate(prop, transported, from, to, PropagationDirection::kForward).status == PropagationStatus::kOk));
+
+  std::mt19937 rng(20260919);
+  std::normal_distribution<double> gauss(0., 1.);
+
+  std::vector<std::array<double, kNBoundParams>> out;
+  out.reserve(kSamples);
+  for (int n = 0; n < kSamples; ++n) {
+    BoundTrackState s = seed;
+    for (int i = 0; i < kNBoundParams; ++i) {
+      s.par[i] += static_cast<Scalar>(gauss(rng) * static_cast<double>(sigma[i]));
+    }
+    if (propagate(prop, s, from, to, PropagationDirection::kForward).status != PropagationStatus::kOk) {
+      continue;
+    }
+    std::array<double, kNBoundParams> row{};
+    for (int i = 0; i < kNBoundParams; ++i) {
+      row[static_cast<std::size_t>(i)] = static_cast<double>(s.par[i]);
+    }
+    out.push_back(row);
+  }
+  BOOST_TEST(out.size() > kSamples / 2);
+
+  const auto n = static_cast<double>(out.size());
+  std::array<double, kNBoundParams> mean{};
+  for (const auto& row : out) {
+    for (int i = 0; i < kNBoundParams; ++i) {
+      mean[static_cast<std::size_t>(i)] += row[static_cast<std::size_t>(i)] / n;
+    }
+  }
+
+  for (int i = 0; i < kNBoundParams; ++i) {
+    for (int j = 0; j <= i; ++j) {
+      double acc = 0.;
+      for (const auto& row : out) {
+        acc += (row[static_cast<std::size_t>(i)] - mean[static_cast<std::size_t>(i)]) * (row[static_cast<std::size_t>(j)] - mean[static_cast<std::size_t>(j)]);
+      }
+      const double sample = acc / (n - 1.);
+      const auto predicted = static_cast<double>(transported.covAt(i, j));
+      const double scale = std::sqrt(static_cast<double>(transported.variance(i)) * static_cast<double>(transported.variance(j)));
+      // Compared against the geometric mean of the two variances, so an
+      // off-diagonal element is judged on the same footing as a diagonal one.
+      BOOST_TEST(std::abs(sample - predicted) < tolerance * scale);
+      // With a correct Jacobian the residual is a per cent or two: the Monte
+      // Carlo's own 1/sqrt(2N), about 0.5 %, and the second-order terms a
+      // linearised transport does not carry and the sample covariance does.
+      // A 10 % error in a dominant Jacobian entry shows up well above 5 %, so
+      // the window is comfortably above the floor and well below a real fault.
+      // Do not "fix" a residual of a per cent or two here.
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(TransportedCovarianceMatchesAMonteCarloInTheBarrel) { checkMonteCarloClosure(barrelPlane(3.4, 1), barrelPlane(17.2, 2), makeState(1, 0.1, 1.2, 1. / 2.), 0.05); }
+
+BOOST_AUTO_TEST_CASE(TransportedCovarianceMatchesAMonteCarloAtHighEta)
+{
+  // sin(theta) = 0.05 puts the track on the outermost disc at r = 7.6 cm, the
+  // inner ring. This case matters because the curvature carries a
+  // 1/sin(theta), so theta and q/p are amplified twentyfold and strongly
+  // correlated exactly here -- and nowhere near mid-rapidity, where a
+  // barrel-only test would never see it.
+  checkMonteCarloClosure(discPlane(0., 1), discPlane(152., 2), makeState(1, 0.3, 0.05, 1. / 5.), 0.05);
+}
+
+BOOST_AUTO_TEST_CASE(AnalyticJacobianAgreesWithTheReferenceAcrossTheAcceptance)
+{
+  // 50 MeV to 100 GeV, both charges, theta from 0.05 (the outermost disc's
+  // inner ring) to 2.4, barrel-to-barrel and through the endcap.
+  //
+  // The tolerance is two-sided on purpose. A pure relative test is meaningless
+  // on entries near zero, where the reference is noise: a central difference
+  // of a float output carries about 1e-6 cm / 2h, which is 5e-4 at the phi
+  // step at normal incidence, and 1 / |n . d| times that at the target -- the
+  // float rounding of the start moves the intersection that much more along a
+  // plane the track crosses shallowly (0.012 at theta = 0.05 on a barrel
+  // plane). A pure absolute test is meaningless on the large entries, which
+  // reach 150 at high eta. So: an absolute floor for what the reference cannot
+  // resolve, and a relative term for what it can.
+  const Propagator prop;
+  const TrackingSurface pairs[3][2] = {{barrelPlane(3.4, 1), barrelPlane(7.0, 2)}, {barrelPlane(3.4, 1), barrelPlane(17.2, 2)}, {discPlane(0., 1), discPlane(152., 2)}};
+
+  int checked = 0;
+  for (const auto& pair : pairs) {
+    for (const double pT : {0.05, 0.1, 0.5, 1.0, 10.0, 100.0}) {
+      for (const double theta : {0.05, 0.3, 0.9, 1.5708, 2.4}) {
+        for (const double charge : {1., -1.}) {
+          for (const double phi : {0.0, 0.7, -2.1}) {
+            const BoundTrackState st = makeState(1, phi, theta, charge * std::sin(theta) / pT);
+            Scalar step[kNBoundParams] = {};
+            defaultDifferenceSteps(step);
+
+            Scalar ref[kJacobianSize] = {};
+            SolenoidJacobian sol;
+            SolenoidJacobian exactSol;
+            Scalar ana[kJacobianSize] = {};
+            Scalar exact[kJacobianSize] = {};
+            if (jacobianFiniteDifference(prop, st, pair[0], pair[1], PropagationDirection::kForward, step, ref) != PropagationStatus::kOk) {
+              continue; // unreachable target: a fact about the track
+            }
+            BoundTrackState arrived = st;
+            BOOST_REQUIRE(propagate(prop, arrived, pair[0], pair[1], PropagationDirection::kForward).status == PropagationStatus::kOk);
+            const auto arrivedTheta = static_cast<double>(arrived.theta());
+            const auto arrivedPhi = static_cast<double>(arrived.phi());
+            const double incidence = std::abs((std::sin(arrivedTheta) * ((std::cos(arrivedPhi) * static_cast<double>(pair[1].normal[0])) + (std::sin(arrivedPhi) * static_cast<double>(pair[1].normal[1])))) + (std::cos(arrivedTheta) * static_cast<double>(pair[1].normal[2])));
+            const double floor = 1e-3 / incidence;
+            BOOST_TEST((jacobianAnalytic<Scalar>(prop, st, pair[0], pair[1], PropagationDirection::kForward, sol) == PropagationStatus::kOk));
+            BOOST_TEST((jacobianAnalytic<ExactScalar>(prop, st, pair[0], pair[1], PropagationDirection::kForward, exactSol) == PropagationStatus::kOk));
+            expandJacobian(sol, ana);
+            expandJacobian(exactSol, exact);
+
+            for (int i = 0; i < kJacobianSize; ++i) {
+              const double diff = std::abs(static_cast<double>(ana[i]) - static_cast<double>(ref[i]));
+              const double precisionDiff = std::abs(static_cast<double>(ana[i]) - static_cast<double>(exact[i]));
+              BOOST_TEST_CONTEXT("pT " << pT << ", theta " << theta << ", charge " << charge << ", phi " << phi << ", element " << i)
+              {
+                BOOST_TEST(diff < floor + 5e-3 * std::abs(static_cast<double>(ref[i])));
+                BOOST_TEST(precisionDiff < 2e-5 + 5e-5 * std::abs(static_cast<double>(exact[i])));
+              }
+            }
+            ++checked;
+          }
+        }
+      }
+    }
+  }
+  // If a change makes most targets unreachable the loop above would pass
+  // vacuously, so pin how much of it actually ran.
+  BOOST_TEST(checked > 250);
+}
+
+BOOST_AUTO_TEST_CASE(ScalarJacobianMatchesExactNearTheGrazingLimit)
+{
+  const Propagator prop;
+  const auto from = barrelPlane(0., 1);
+  const auto to = barrelPlane(1., 2);
+
+  for (const double incidence : {0.0101, 0.011, 0.02, 0.05, 0.06}) {
+    const auto phi = std::acos(incidence);
+    const BoundTrackState st = makeState(1, phi, 0.5 * std::acos(-1.), 0.);
+    SolenoidJacobian scalarSol;
+    SolenoidJacobian exactSol;
+    const auto scalarStatus = jacobianAnalytic<Scalar>(prop, st, from, to, PropagationDirection::kForward, scalarSol);
+    const auto exactStatus = jacobianAnalytic<ExactScalar>(prop, st, from, to, PropagationDirection::kForward, exactSol);
+
+    BOOST_TEST_CONTEXT("incidence " << incidence)
+    {
+      BOOST_REQUIRE(scalarStatus == PropagationStatus::kOk);
+      BOOST_REQUIRE(exactStatus == scalarStatus);
+      Scalar scalar[kJacobianSize] = {};
+      Scalar exact[kJacobianSize] = {};
+      expandJacobian(scalarSol, scalar);
+      expandJacobian(exactSol, exact);
+      for (int i = 0; i < kJacobianSize; ++i) {
+        const auto expected = static_cast<double>(exact[i]);
+        const double diff = std::abs(static_cast<double>(scalar[i]) - expected);
+        BOOST_TEST(diff < 2e-4 + 1e-4 * std::abs(expected));
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(TheAnalyticJacobianAlsoClosesAgainstTheMonteCarlo)
+{
+  // The reference and the analytic form can only agree with each other by
+  // accident if they share a mistake; agreeing with propagated samples as well
+  // rules that out.
+  checkMonteCarloClosure(barrelPlane(3.4, 1), barrelPlane(17.2, 2), makeState(1, 0.1, 1.2, 1. / 2.), 0.05, true);
+  checkMonteCarloClosure(discPlane(0., 1), discPlane(152., 2), makeState(1, 0.3, 0.05, 1. / 5.), 0.05, true);
+}
+
+BOOST_AUTO_TEST_CASE(HighlandReproducesASensorByHand)
+{
+  // 125 um of silicon, X0 = 9.37 cm, so x/X0 = 1.334e-3 and Highland gives
+  // 0.372 mrad at 1 GeV. The whole material model rests on this number, so it
+  // is checked rather than remembered.
+  const Scalar x2X0 = 0.0125F / 9.37F;
+  BOOST_TEST(std::abs(static_cast<double>(x2X0) - 1.334e-3) < 1e-5);
+
+  const Scalar t0 = highlandTheta0(x2X0, 1.F);
+  BOOST_TEST(std::abs(static_cast<double>(t0) - 3.718e-4) < 1e-6);
+
+  // 1/p scaling, and two sensors -- the overlap case -- 46 % wider.
+  BOOST_TEST(std::abs(static_cast<double>(highlandTheta0(x2X0, 10.F)) - 3.718e-5) < 1e-7);
+  const auto ratio = static_cast<double>(highlandTheta0(2.F * x2X0, 1.F)) / static_cast<double>(t0);
+  BOOST_TEST(std::abs(ratio - 1.46) < 0.01);
+
+  BOOST_TEST(std::abs(static_cast<double>(highlandTheta0(0.F, 1.F))) < 1e-12);
+}
+
+BOOST_AUTO_TEST_CASE(ScatteringProjectsOntoTheTwoAngles)
+{
+  const auto noise = scatteringNoise(1e-3F, 0.5F);
+  const double sine = std::sin(0.5);
+  BOOST_TEST(std::abs(static_cast<double>(noise.theta) - 1e-6) < 1e-12);
+  BOOST_TEST(std::abs(static_cast<double>(noise.phi) - 1e-6 / (sine * sine)) < 1e-12);
+}
+
+/// The factored prediction is the double one, F (P + Q_before) F^T +
+/// Q_after, to float precision on every element, over the planes and momenta
+/// of the structured transport's test, for full covariances and every kind of
+/// noise, straggling included.
+BOOST_AUTO_TEST_CASE(FactoredPredictionMatchesTheDoubleOne)
+{
+  const Propagator prop;
+  const TrackingSurface pairs[3][2] = {{barrelPlane(3.4, 1), barrelPlane(7.0, 2)}, {barrelPlane(3.4, 1), barrelPlane(17.2, 2)}, {discPlane(0., 1), discPlane(152., 2)}};
+  std::mt19937 rng(11);
+  std::uniform_real_distribution<double> unit(-1., 1.);
+  std::uniform_real_distribution<double> positive(0.1, 1.);
+  int checked = 0;
+  double worst = 0.;
+  for (const auto& pair : pairs) {
+    for (const double pT : {0.1, 1.0, 50.0}) {
+      for (const double theta : {0.05, 0.9}) {
+        const BoundTrackState seed = makeState(1, 0.4, theta, std::sin(theta) / pT);
+        SolenoidJacobian jac;
+        BOOST_REQUIRE(jacobianAnalytic(prop, seed, pair[0], pair[1], PropagationDirection::kForward, jac) == PropagationStatus::kOk);
+        for (int trial = 0; trial < 20; ++trial) {
+          // P = L L^T with L lower triangular: positive definite, every
+          // element correlated, the scales of a fit's (cm, rad, 1/GeV).
+          constexpr std::array<double, kNBoundParams> kScale{1e-2, 1e-2, 1e-3, 1e-3, 1e-2};
+          double l[kNBoundParams][kNBoundParams]{};
+          for (int i = 0; i < kNBoundParams; ++i) {
+            for (int j = 0; j < i; ++j) {
+              l[i][j] = 0.7 * unit(rng) * kScale[static_cast<std::size_t>(i)];
+            }
+            l[i][i] = positive(rng) * kScale[static_cast<std::size_t>(i)];
+          }
+          Scalar cov[kBoundCovSize]{};
+          for (int i = 0; i < kNBoundParams; ++i) {
+            for (int j = 0; j <= i; ++j) {
+              double sum = 0.;
+              for (int k = 0; k <= j; ++k) {
+                sum += l[i][k] * l[j][k];
+              }
+              cov[covIndex(i, j)] = static_cast<Scalar>(sum);
+            }
+          }
+          // A third of the trials without noise, the rest with every kind.
+          const auto pick = [&](double scale) { return trial % 3 == 0 ? 0.F : static_cast<Scalar>(positive(rng) * scale); };
+          const StepNoise noise{
+            .phiBefore = pick(1e-6),
+            .thetaBefore = pick(1e-6),
+            .phiAfter = pick(1e-6),
+            .thetaAfter = pick(1e-6),
+            .qOverPAfter = pick(1e-5),
+          };
+
+          auto factors = factorCovariance(cov);
+          BOOST_REQUIRE(transportFactors(jac, noise, factors));
+          Scalar fromFactors[kBoundCovSize]{};
+          covarianceFromFactors(factors, fromFactors);
+          ExactScalar exact[kBoundCovSize]{};
+          predictCovarianceExact(jac, noise, cov, exact);
+          for (int i = 0; i < kNBoundParams; ++i) {
+            for (int j = 0; j <= i; ++j) {
+              const double scale = std::sqrt(exact[covIndex(i, i)] * exact[covIndex(j, j)]);
+              const double error = std::abs(static_cast<double>(fromFactors[covIndex(i, j)]) - exact[covIndex(i, j)]) / scale;
+              worst = std::max(worst, error);
+              BOOST_TEST_CONTEXT("pT " << pT << " theta " << theta << " trial " << trial << " element " << i << j) { BOOST_TEST(error < 1e-5); }
+            }
+          }
+          ++checked;
+        }
+      }
+    }
+  }
+  BOOST_TEST_MESSAGE("factored prediction against double: " << checked << " predictions, worst element " << worst << " of its sigmas' product");
+  BOOST_TEST(checked == 360);
+}
+
+/// Why the fit carries factors:
+/// a state fixed by one measurement to a 2.9 um pixel, its direction still
+/// the diffuse 0.1 rad, carried from one VD layer to the next at eta 3, where
+/// loc1 (z) moves by r / sin^2(theta) = 71 cm per radian of theta. The
+/// predicted loc1 variance is 50 cm^2; what the next update needs is loc1's
+/// variance given the direction and q/p -- the pixel's and the scattering's,
+/// about 1e-8 of it at 50 GeV. As factors it is D_1, and it comes out to
+/// float's precision on itself. The float P of the same step, factored, has
+/// lost it: rounding 50 cm^2 to float costs more than the whole of it.
+BOOST_AUTO_TEST_CASE(FactoredPredictionKeepsWhatAFloatCovarianceLoses)
+{
+  SolenoidJacobian jac;
+  jac.loc0[kLoc0] = 1.F;
+  jac.loc1[kLoc1] = 1.F;
+  jac.loc1[kTheta] = -71.F;
+  jac.phi[kPhi] = 1.F;
+  Scalar cov[kBoundCovSize]{};
+  cov[covIndex(kLoc0, kLoc0)] = 8.33e-8F; // (10 um)^2 / 12
+  cov[covIndex(kLoc1, kLoc1)] = 8.33e-8F;
+  cov[covIndex(kPhi, kPhi)] = 1e-2F;
+  cov[covIndex(kTheta, kTheta)] = 1e-2F;
+  cov[covIndex(kQOverP, kQOverP)] = 1e-2F;
+  // theta0 = 1.2e-5 each half, 50 GeV through 1e-3 X0/cm over 7 cm.
+  const Scalar t2 = 1.2e-5F * 1.2e-5F;
+  const Scalar s2 = 0.0993F * 0.0993F; // sin^2 theta at eta 3
+  const StepNoise noise{.phiBefore = t2 / s2, .thetaBefore = t2, .phiAfter = t2 / s2, .thetaAfter = t2};
+
+  ExactScalar exact[kBoundCovSize]{};
+  predictCovarianceExact(jac, noise, cov, exact);
+  ExactScalar exactUpper[kBoundUpperSize]{};
+  ExactScalar exactDiagonal[kNBoundParams]{};
+  detail::factorUD(exact, exactUpper, exactDiagonal);
+  const double conditional = exactDiagonal[kLoc1];
+  BOOST_TEST(conditional > 0.);
+  BOOST_TEST(conditional / exact[covIndex(kLoc1, kLoc1)] < 1e-7); // beyond a float's 6e-8 of P_11 only by a little
+
+  auto factors = factorCovariance(cov);
+  BOOST_REQUIRE(transportFactors(jac, noise, factors));
+  BOOST_TEST(std::abs(static_cast<double>(factors.diagonal[kLoc1]) / conditional - 1.) < 1e-5);
+
+  BoundTrackState asState;
+  for (int i = 0; i < kBoundCovSize; ++i) {
+    asState.cov[i] = cov[i];
+  }
+  asState.par[kTheta] = 0.0995F;
+  asState.variance(kPhi) += noise.phiBefore;
+  asState.variance(kTheta) += noise.thetaBefore;
+  Scalar dense[kJacobianSize];
+  expandJacobian(jac, dense);
+  transportCovarianceDense(dense, asState.cov);
+  asState.variance(kPhi) += noise.phiAfter;
+  asState.variance(kTheta) += noise.thetaAfter;
+  const auto rounded = factorCovariance(asState.cov);
+  BOOST_TEST_MESSAGE("loc1 given the rest: double " << conditional << ", factors " << factors.diagonal[kLoc1] << ", factored float P " << rounded.diagonal[kLoc1]);
+  BOOST_TEST(std::abs(static_cast<double>(rounded.diagonal[kLoc1]) / conditional - 1.) > 0.5);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testDeviceArena.cxx b/Detectors/GenericTracking/tracking/test/testDeviceArena.cxx
new file mode 100644
index 0000000000000..824f97af143c6
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testDeviceArena.cxx
@@ -0,0 +1,215 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testDeviceArena.cxx
+/// \brief The device arena and the device storage's allocation and liveness:
+///        host code, run here on a host buffer as the block.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Device Arena
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/GPU/DeviceArena.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/DeviceStorage.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+
+#include <array>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <stdexcept>
+
+namespace o2::gtrk
+{
+namespace
+{
+
+/// The arena only keeps its runtime: this one throws if it is ever called.
+class NoRuntime final : public DeviceRuntime
+{
+ public:
+  [[nodiscard]] const char* backend() const noexcept final { return "none"; }
+  [[nodiscard]] const DeviceProperties& properties() const noexcept final { return mProperties; }
+  void copyToDevice(void* /*to*/, const void* /*from*/, std::size_t /*bytes*/, DeviceStream& /*stream*/) final { fail(); }
+  void copyToHost(void* /*to*/, const void* /*from*/, std::size_t /*bytes*/, DeviceStream& /*stream*/) final { fail(); }
+  void copyOnDevice(void* /*to*/, const void* /*from*/, std::size_t /*bytes*/, DeviceStream& /*stream*/) final { fail(); }
+  void copyEachOnDevice(std::span<const DeviceCopy> /*copies*/, DeviceStream& /*stream*/) final { fail(); }
+  void fill(void* /*to*/, std::uint8_t /*value*/, std::size_t /*bytes*/, DeviceStream& /*stream*/) final { fail(); }
+  void registerHost(void* /*host*/, std::size_t /*bytes*/) final { fail(); }
+  void unregisterHost(void* /*host*/) noexcept final {}
+
+ protected:
+  [[nodiscard]] void* createStreamHandle() final { fail(); }
+
+ private:
+  [[noreturn]] static void fail() { throw std::logic_error("the arena called its runtime"); }
+  void destroyStreamHandle(void* /*handle*/) noexcept final {}
+  void synchronizeStreamHandle(void* /*handle*/) final { fail(); }
+  [[nodiscard]] std::unique_ptr<DeviceTracker<detectors::ITS, o2::base::MatLayerCylSet>> makeITSTracker(DeviceBlock /*block*/) final { fail(); }
+  [[nodiscard]] std::unique_ptr<DeviceTracker<detectors::MFT, o2::base::MatLayerCylSet>> makeMFTTracker(DeviceBlock /*block*/) final { fail(); }
+  [[nodiscard]] std::unique_ptr<DeviceTracker<detectors::TRKFT3, o2::base::MatLayerCylSet>> makeTRKFT3Tracker(DeviceBlock /*block*/) final { fail(); }
+
+  DeviceProperties mProperties;
+};
+
+/// The runtime and host memory as the arena's block, aligned as the device's
+/// blocks are.
+struct Host {
+  NoRuntime runtime;
+  alignas(4096) std::array<std::byte, std::size_t{16} * 1024U> memory{};
+
+  DeviceBlock block(std::size_t bytes)
+  {
+    BOOST_REQUIRE(bytes <= memory.size());
+    return {.data = memory.data(), .bytes = bytes};
+  }
+};
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(ArenaAlignmentMetricsResetAndRefusal)
+{
+  Host host;
+  DeviceArena arena{host.runtime, host.block(2048U)};
+  const auto first = arena.allocate(7U, 16U);
+  const auto second = arena.allocate(19U, 256U);
+  BOOST_REQUIRE(first);
+  BOOST_REQUIRE(second);
+  BOOST_TEST(static_cast<std::byte*>(second.data) - static_cast<std::byte*>(first.data) == 256);
+  BOOST_TEST(arena.used() == 275U);
+  BOOST_TEST(arena.peak() == 275U);
+
+  const auto used = arena.used();
+  const auto peak = arena.peak();
+  const auto refused = arena.allocate(arena.capacity());
+  BOOST_TEST(!static_cast<bool>(refused));
+  BOOST_TEST(arena.used() == used);
+  BOOST_TEST(arena.peak() == peak);
+  arena.reset();
+  const auto again = arena.allocate(7U, 16U);
+  BOOST_TEST(again.data == first.data);
+  arena.resetPeak();
+  BOOST_TEST(arena.peak() == arena.used());
+}
+
+BOOST_AUTO_TEST_CASE(ScopesInvalidateOnlyWhatTheyRewind)
+{
+  Host host;
+  DeviceArena arena{host.runtime, host.block(4096U)};
+  DeviceSpan<std::uint32_t> timeframe;
+  BOOST_REQUIRE(timeframe.allocate(arena, 8U));
+  DeviceSpan<std::uint32_t> slice;
+  {
+    auto scope = arena.scope();
+    BOOST_REQUIRE(slice.allocate(arena, 8U));
+    BOOST_CHECK_NO_THROW(static_cast<void>(slice.data()));
+  }
+  BOOST_CHECK_THROW(static_cast<void>(slice.data()), std::logic_error);
+  BOOST_CHECK_NO_THROW(static_cast<void>(timeframe.data()));
+
+  arena.reset();
+  BOOST_CHECK_THROW(static_cast<void>(timeframe.data()), std::logic_error);
+}
+
+BOOST_AUTO_TEST_CASE(ColumnAllocationIsTransactional)
+{
+  Host host;
+  DeviceArena arena{host.runtime, host.block(800U)};
+  const auto used = arena.used();
+  DeviceColumns<TrackletT> columns;
+  BOOST_TEST(!columns.allocate(arena, 1U));
+  BOOST_TEST(arena.used() == used);
+}
+
+/// A transactional allocation opens its own scope and, on success, hands its
+/// columns to the scope around it: they outlive an inner scope opened later and
+/// die with the one they were allocated in.
+BOOST_AUTO_TEST_CASE(CommittedColumnsLiveAndDieWithTheirScope)
+{
+  Host host;
+  DeviceArena arena{host.runtime, host.block(std::size_t{16} * 1024U)};
+  DeviceColumns<TrackletT> columns;
+  {
+    auto slice = arena.scope();
+    const auto before = arena.used();
+    BOOST_REQUIRE(columns.allocate(arena, 4U));
+    BOOST_TEST(arena.used() > before);
+    BOOST_CHECK_NO_THROW(static_cast<void>(columns.view()));
+    {
+      auto inner = arena.scope();
+      DeviceSpan<std::uint32_t> scratch;
+      BOOST_REQUIRE(scratch.allocate(arena, 16U));
+    }
+    BOOST_CHECK_NO_THROW(static_cast<void>(columns.view()));
+    BOOST_TEST(columns.size() == 4U);
+  }
+  BOOST_CHECK_THROW(static_cast<void>(columns.view()), std::logic_error);
+}
+
+/// The scratch end grows down from the top: both ends allocate without
+/// touching each other, meet but never cross, and each end's scopes rewind
+/// only that end.
+BOOST_AUTO_TEST_CASE(TheScratchEndIsIndependentOfTheBase)
+{
+  Host host;
+  constexpr std::size_t kCapacity = 4096U;
+  DeviceArena arena{host.runtime, host.block(kCapacity)};
+  DeviceSpan<std::byte> kept;
+  BOOST_REQUIRE(kept.allocate(arena, 1000U));
+  // The first allocation sits at the arena's base (the block is 256-aligned).
+  const std::byte* origin = kept.data();
+  BOOST_TEST(arena.used(ArenaEnd::kBase) == 1000U);
+  BOOST_TEST(arena.used(ArenaEnd::kScratch) == 0U);
+
+  DeviceSpan<std::byte> staging;
+  {
+    auto scratch = arena.scope(ArenaEnd::kScratch);
+    BOOST_REQUIRE(staging.allocate(arena, 1000U, ArenaEnd::kScratch));
+    const std::byte* at = staging.data();
+    BOOST_TEST(at >= origin + arena.used(ArenaEnd::kBase));
+    BOOST_TEST(at + 1000 <= origin + kCapacity);
+    BOOST_TEST(std::bit_cast<std::uintptr_t>(at) % 256U == 0U);
+    BOOST_TEST(arena.used() == arena.used(ArenaEnd::kBase) + arena.used(ArenaEnd::kScratch));
+
+    // The ends meet: what does not fit between them is refused and changes nothing.
+    const auto base = arena.used(ArenaEnd::kBase);
+    const auto top = arena.used(ArenaEnd::kScratch);
+    BOOST_TEST(!static_cast<bool>(arena.allocate(kCapacity - base - top + 1U, 1U, ArenaEnd::kScratch)));
+    BOOST_TEST(!static_cast<bool>(arena.allocate(kCapacity - base - top + 1U, 1U, ArenaEnd::kBase)));
+    BOOST_TEST(arena.used(ArenaEnd::kBase) == base);
+    BOOST_TEST(arena.used(ArenaEnd::kScratch) == top);
+
+    // A base-end scope opened and closed meanwhile leaves the scratch alone.
+    {
+      auto slice = arena.scope();
+      BOOST_REQUIRE(arena.allocate(16U));
+    }
+    BOOST_TEST(arena.used(ArenaEnd::kScratch) == top);
+    BOOST_CHECK_NO_THROW(static_cast<void>(staging.data()));
+  }
+  BOOST_TEST(arena.used(ArenaEnd::kScratch) == 0U);
+  BOOST_CHECK_THROW(static_cast<void>(staging.data()), std::logic_error);
+  BOOST_CHECK_NO_THROW(static_cast<void>(kept.data()));
+  BOOST_TEST(arena.peak() >= 2000U);
+
+  // Transactional columns on the scratch end, and a reset that clears both ends.
+  DeviceColumns<TrackletT> columns;
+  BOOST_REQUIRE(columns.allocate(arena, 8U, ArenaEnd::kScratch));
+  BOOST_TEST(arena.used(ArenaEnd::kScratch) > 0U);
+  BOOST_CHECK_NO_THROW(static_cast<void>(columns.view()));
+  arena.reset();
+  BOOST_TEST(arena.used() == 0U);
+  BOOST_CHECK_THROW(static_cast<void>(columns.view()), std::logic_error);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testDisplacedPair.cxx b/Detectors/GenericTracking/tracking/test/testDisplacedPair.cxx
new file mode 100644
index 0000000000000..f91386326f1f4
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testDisplacedPair.cxx
@@ -0,0 +1,465 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testDisplacedPair.cxx
+/// \brief The displaced pair test's geometry (DisplacedPair.h): displaced
+///        helices' pairs on the ITS's radii pass at their own impact and z,
+///        the test agrees with a scan of explicitly built circles, at an
+///        impact bound of 0 it is the pair cut's transverse test, and the
+///        degenerate cases are their own.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK displaced pair
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/DisplacedPair.h"
+#include "GenericTracking/Tracking/PairCut.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <limits>
+#include <numbers>
+#include <optional>
+#include <random>
+#include <utility>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using displaced::displacedPair;
+
+constexpr std::array<double, 7> kRadii{2.3, 3.1, 3.9, 19.6, 24.5, 34.4, 39.3};
+constexpr double kPi = std::numbers::pi;
+constexpr double kInfinity = std::numeric_limits<double>::infinity();
+
+/// The curvature of a track of \a ptGeV in 0.5 T [1/cm].
+double curvatureAt(double ptGeV) { return 0.3 * 0.5 / (100. * ptGeV); }
+
+/// A helix from (x0, y0, z0) in direction phi with signed curvature k
+/// (positive counterclockwise) and dip slope tanLambda.
+struct Helix {
+  double x0, y0, z0, phi, k, tanLambda;
+};
+
+struct Crossing {
+  double x, y, z;
+};
+
+/// The helix's first crossing of the radius \a r, if any.
+std::optional<Crossing> crossing(const Helix& h, double r)
+{
+  const double radius = 1. / std::abs(h.k);
+  const double sense = h.k > 0. ? 1. : -1.;
+  // The centre to the left of the direction for a counterclockwise one.
+  const double cx = h.x0 - (sense * radius * std::sin(h.phi));
+  const double cy = h.y0 + (sense * radius * std::cos(h.phi));
+  const double centre = std::hypot(cx, cy);
+  const double cosine = ((r * r) - (centre * centre) - (radius * radius)) / (2. * radius * centre);
+  if (std::abs(cosine) > 1.) {
+    return std::nullopt;
+  }
+  const double start = std::atan2(h.y0 - cy, h.x0 - cx);
+  const double toward = std::atan2(cy, cx);
+  double best = kInfinity;
+  for (const double side : {1., -1.}) {
+    const double theta = toward + (side * std::acos(cosine));
+    const double turn = std::fmod((sense * (theta - start)) + (4. * kPi), 2. * kPi);
+    best = std::min(best, turn);
+  }
+  const double theta = start + (sense * best);
+  return Crossing{.x = cx + (radius * std::cos(theta)), .y = cy + (radius * std::sin(theta)), .z = h.z0 + (h.tanLambda * radius * best)};
+}
+
+/// One circle through the pair, built explicitly: whether its arc from the
+/// source to the target moves outward all along (sampled), its signed impact
+/// (`|C| - R` counterclockwise, its negative clockwise, the line's distance
+/// on its left), and the z of its closest approach, by the turn from the
+/// arc's middle in (-pi, pi]; none for a circle centred on the beam line.
+struct Circle {
+  bool outward = false;
+  double impact = 0.;
+  std::optional<double> z;
+};
+
+Circle circleThrough(double x1, double y1, double z1, double x2, double y2, double z2, double k)
+{
+  const double mx = 0.5 * (x1 + x2);
+  const double my = 0.5 * (y1 + y2);
+  const double chord = std::hypot(x2 - x1, y2 - y1);
+  const double ux = (x2 - x1) / chord;
+  const double uy = (y2 - y1) / chord;
+  const double h = 0.5 * chord;
+  Circle circle;
+  constexpr int kSamples = 32;
+  auto outward = true;
+  double previous = std::hypot(x1, y1);
+  if (exactlyEqual(k, 0.)) {
+    for (int i = 1; i <= kSamples; ++i) {
+      const double t = chord * i / kSamples;
+      const double r = std::hypot(x1 + (t * ux), y1 + (t * uy));
+      outward = outward && r >= previous - 1.e-12;
+      previous = r;
+    }
+    circle.outward = outward;
+    circle.impact = (-uy * mx) + (ux * my);
+    const double foot = -((x1 * ux) + (y1 * uy));
+    circle.z = z1 + (foot * (z2 - z1) / chord);
+    return circle;
+  }
+  const double radius = 1. / std::abs(k);
+  const double sense = k > 0. ? 1. : -1.;
+  const double offset = std::sqrt(std::max(0., (radius * radius) - (h * h)));
+  const double cx = mx + (sense * offset * -uy);
+  const double cy = my + (sense * offset * ux);
+  const double theta1 = std::atan2(y1 - cy, x1 - cx);
+  const double turn = std::remainder(sense * (std::atan2(y2 - cy, x2 - cx) - theta1), 2. * kPi);
+  for (int i = 1; i <= kSamples; ++i) {
+    const double theta = theta1 + (sense * turn * i / kSamples);
+    const double r = std::hypot(cx + (radius * std::cos(theta)), cy + (radius * std::sin(theta)));
+    outward = outward && r >= previous - 1.e-12;
+    previous = r;
+  }
+  circle.outward = outward && turn > 0.;
+  const double centre = std::hypot(cx, cy);
+  circle.impact = sense * (centre - radius);
+  if (centre > 0.) {
+    const double middle = theta1 + (0.5 * sense * turn);
+    const double phi = std::remainder(sense * (std::atan2(-cy, -cx) - middle), 2. * kPi);
+    circle.z = (0.5 * (z1 + z2)) + (phi * (z2 - z1) / turn);
+  }
+  return circle;
+}
+
+/// The scan's verdict: whether some curvature on a fine grid of [-k_max,
+/// k_max] gives an outward circle within the impact and z bounds; the z
+/// range of the circles within the impact bound into \a range.
+bool scanned(double x1, double y1, double z1, double x2, double y2, double z2, double maxCurvature, double maxImpact, double zLow, double zHigh, std::pair<double, double>* range = nullptr)
+{
+  const double h = 0.5 * std::hypot(x2 - x1, y2 - y1);
+  const double bound = std::min(maxCurvature, 0.999999 / h);
+  constexpr int kSteps = 4000;
+  bool found = false;
+  std::pair<double, double> zs{kInfinity, -kInfinity};
+  for (int step = 0; step <= kSteps; ++step) {
+    const double k = (step == kSteps / 2) ? 0. : -bound + (2. * bound * step / kSteps);
+    const auto circle = circleThrough(x1, y1, z1, x2, y2, z2, k);
+    if (!circle.outward || std::abs(circle.impact) > maxImpact || !circle.z) {
+      continue;
+    }
+    zs = {std::min(zs.first, *circle.z), std::max(zs.second, *circle.z)};
+    found = found || (*circle.z >= zLow && *circle.z <= zHigh);
+  }
+  if (range != nullptr) {
+    *range = zs;
+  }
+  return found;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(ADisplacedHelixsPairsPassAtTheirOwnImpactAndZ)
+{
+  // Displaced helices from 0.05 to 3 GeV, both charges, born anywhere inside
+  // 18 cm; their pairs on adjacent layers and across one, tested at exactly
+  // their own curvature as the bound, their own impact and z. Taken the other
+  // way round -- target first -- no pair moves outward.
+  std::mt19937_64 rng{29};
+  std::uniform_real_distribution<double> unit{0., 1.};
+  int pairs = 0;
+  for (int trial = 0; trial < 20000; ++trial) {
+    const double pt = 0.05 * std::exp(unit(rng) * std::log(60.));
+    const double production = 18. * unit(rng);
+    const double azimuth = 2. * kPi * unit(rng);
+    const Helix h{
+      .x0 = production * std::cos(azimuth),
+      .y0 = production * std::sin(azimuth),
+      .z0 = -10. + (20. * unit(rng)),
+      .phi = 2. * kPi * unit(rng),
+      .k = (unit(rng) < 0.5 ? -1. : 1.) * curvatureAt(pt),
+      .tanLambda = -1. + (2. * unit(rng)),
+    };
+    std::size_t first = 0;
+    while (first < kRadii.size() && kRadii[first] <= production) {
+      ++first;
+    }
+    for (std::size_t layer = first; layer + 1U < kRadii.size(); ++layer) {
+      for (std::size_t skip = 1; skip <= 2 && layer + skip < kRadii.size(); ++skip) {
+        const auto a = crossing(h, kRadii[layer]);
+        const auto b = crossing(h, kRadii[layer + skip]);
+        if (!a || !b) {
+          continue;
+        }
+        const auto own = circleThrough(a->x, a->y, a->z, b->x, b->y, b->z, h.k);
+        if (!own.outward || !own.z) {
+          continue; // a looper's arc past its turn: not an outward pair
+        }
+        ++pairs;
+        const auto exact = displacedPair(a->x, a->y, a->z, b->x, b->y, b->z, std::abs(h.k), std::abs(own.impact) + 1.e-9, *own.z - 1.e-6, *own.z + 1.e-6);
+        BOOST_TEST((exact.transverse && exact.longitudinal));
+        const auto single = displacedPair<float>(static_cast<float>(a->x), static_cast<float>(a->y), static_cast<float>(a->z), static_cast<float>(b->x), static_cast<float>(b->y), static_cast<float>(b->z), static_cast<float>(std::abs(h.k) * 1.001), static_cast<float>(std::abs(own.impact) + 1.e-3), static_cast<float>(*own.z - 1.e-2), static_cast<float>(*own.z + 1.e-2));
+        BOOST_TEST((single.transverse && single.longitudinal));
+        BOOST_TEST(!displacedPair(b->x, b->y, b->z, a->x, a->y, a->z, std::abs(h.k), 100., -kInfinity, kInfinity).transverse);
+      }
+    }
+  }
+  BOOST_TEST(pairs > 30000);
+}
+
+BOOST_AUTO_TEST_CASE(TheTestAgreesWithAScanOfExplicitCircles)
+{
+  // Random pairs on the ITS's radii, random bounds, every third z bound put
+  // just past or just short of the scan's z range: wherever the scan finds a
+  // circle with a margin to spare the test passes, and wherever the test
+  // passes the scan finds one with a margin's tolerance -- the scan's grid
+  // (an impact step of at most ~0.01 cm) and the bisection's apart.
+  std::mt19937_64 rng{70};
+  std::uniform_real_distribution<double> unit{0., 1.};
+  constexpr double kImpactMargin = 0.02; // [cm]
+  constexpr double kZMargin = 0.1;       // [cm]
+  int passed = 0;
+  int failed = 0;
+  int excludingZero = 0;
+  for (int trial = 0; trial < 1500; ++trial) {
+    const auto inner = static_cast<std::size_t>(unit(rng) * 6.);
+    const std::size_t outer = std::min<std::size_t>(inner + 1U + static_cast<std::size_t>(unit(rng) * 2.), kRadii.size() - 1U);
+    const double phi1 = 2. * kPi * unit(rng);
+    const double phi2 = phi1 + std::normal_distribution<double>{0., 0.3}(rng);
+    const double x1 = kRadii[inner] * std::cos(phi1);
+    const double y1 = kRadii[inner] * std::sin(phi1);
+    const double x2 = kRadii[outer] * std::cos(phi2);
+    const double y2 = kRadii[outer] * std::sin(phi2);
+    const double z1 = -10. + (20. * unit(rng));
+    const double z2 = -15. + (30. * unit(rng));
+    const double maxCurvature = curvatureAt(0.05 + unit(rng));
+    const double maxImpact = 5. * unit(rng) * unit(rng);
+    double zLow = -10. + (20. * unit(rng));
+    double zHigh = zLow + (15. * unit(rng));
+    std::pair<double, double> range;
+    scanned(x1, y1, z1, x2, y2, z2, maxCurvature, maxImpact, -kInfinity, kInfinity, &range);
+    if (trial % 3 == 0 && range.first <= range.second) {
+      // A z bound ending just short of the range's least z or starting just past its most.
+      const double gap = (unit(rng) - 0.5) * 4. * kZMargin;
+      if (trial % 2 == 0) {
+        zHigh = range.first + gap;
+        zLow = zHigh - 5.;
+      } else {
+        zLow = range.second + gap;
+        zHigh = zLow + 5.;
+      }
+    }
+    if (!circleThrough(x1, y1, z1, x2, y2, z2, 0.).outward) {
+      ++excludingZero;
+    }
+    const auto result = displacedPair(x1, y1, z1, x2, y2, z2, maxCurvature, maxImpact, zLow, zHigh);
+    const bool both = result.transverse && result.longitudinal;
+    if (scanned(x1, y1, z1, x2, y2, z2, maxCurvature, std::max(0., maxImpact - kImpactMargin), zLow + kZMargin, zHigh - kZMargin)) {
+      BOOST_TEST(both);
+    }
+    if (both) {
+      BOOST_TEST(scanned(x1, y1, z1, x2, y2, z2, maxCurvature, maxImpact + kImpactMargin, zLow - kZMargin, zHigh + kZMargin));
+    }
+    (both ? passed : failed) += 1;
+  }
+  // Both verdicts are exercised, and pairs whose outward curvatures leave out the line.
+  BOOST_TEST(passed > 100);
+  BOOST_TEST(failed > 100);
+  BOOST_TEST(excludingZero > 10);
+}
+
+BOOST_AUTO_TEST_CASE(AtZeroImpactItIsThePairCutsTransverseTest)
+{
+  // The pair cut's transverse test without its errors, in a field: the
+  // circle through the beam point at most k_max, no turning point between
+  // the two. Pairs within a hair of either edge are left out: the two
+  // compute them apart.
+  std::mt19937_64 rng{6};
+  std::uniform_real_distribution<double> unit{0., 1.};
+  int compared = 0;
+  int admitted = 0;
+  for (int trial = 0; trial < 20000; ++trial) {
+    const auto inner = static_cast<std::size_t>(unit(rng) * 6.);
+    const std::size_t outer = inner + 1U;
+    const double phi1 = 2. * kPi * unit(rng);
+    const double phi2 = phi1 + std::normal_distribution<double>{0., 0.2}(rng);
+    const PairPoint source{
+      .x = static_cast<Scalar>(kRadii[inner] * std::cos(phi1)),
+      .y = static_cast<Scalar>(kRadii[inner] * std::sin(phi1)),
+      .z = 0.F,
+      .r = static_cast<Scalar>(kRadii[inner]),
+    };
+    const PairPoint target{
+      .x = static_cast<Scalar>(kRadii[outer] * std::cos(phi2)),
+      .y = static_cast<Scalar>(kRadii[outer] * std::sin(phi2)),
+      .z = 0.F,
+      .r = static_cast<Scalar>(kRadii[outer]),
+    };
+    const double maxCurvature = curvatureAt(0.05 + unit(rng));
+    PairCut cut{};
+    cut.twoRMin = static_cast<Scalar>(2. / maxCurvature);
+    cut.nSigma = 0.F;
+    const auto terms = transversePairTerms(cut, VertexSeed{}, source, 0.F, target);
+    const double sx = source.x;
+    const double sy = source.y;
+    const double sr = source.r;
+    const double tx = target.x;
+    const double ty = target.y;
+    const double tr = target.r;
+    const double cross = (sx * ty) - (tx * sy);
+    const double chord = std::hypot(tx - sx, ty - sy);
+    const double k0 = 2. * std::abs(cross) / (sr * tr * chord);
+    const double dot = (sx * tx) + (sy * ty);
+    const double low = sr * sr;
+    const double high = tr * tr;
+    if (std::abs(k0 - maxCurvature) < 1.e-4 * maxCurvature || std::abs(dot - low) < 1.e-4 * low || std::abs(dot - high) < 1.e-4 * high) {
+      continue;
+    }
+    ++compared;
+    const bool today = transverseCompatible(cut, terms);
+    const auto result = displacedPair<double>(sx, sy, 0., tx, ty, 0., maxCurvature, 0., -kInfinity, kInfinity);
+    BOOST_TEST(result.transverse == today);
+    admitted += today ? 1 : 0;
+  }
+  BOOST_TEST(compared > 19000);
+  BOOST_TEST(admitted > 1000);
+  BOOST_TEST(admitted < compared - 1000);
+}
+
+BOOST_AUTO_TEST_CASE(TheDegenerateCasesAreTheirOwn)
+{
+  // Coincident points define no circle.
+  BOOST_TEST(!displacedPair(3., 0., 0., 3., 0., 1., 0.1, 10., -kInfinity, kInfinity).transverse);
+  // No field: the line alone, here 1 cm from the beam line, going outward.
+  const auto line = displacedPair(2., 1., 0., 30., 1., 0., 0., 1.001, -kInfinity, kInfinity);
+  BOOST_TEST((line.transverse && line.longitudinal));
+  BOOST_TEST(!displacedPair(2., 1., 0., 30., 1., 0., 0., 0.999, -kInfinity, kInfinity).transverse);
+  // The same line travelled inward does not go out from the source.
+  BOOST_TEST(!displacedPair(30., 1., 0., 2., 1., 0., 0., 2., -kInfinity, kInfinity).transverse);
+  // The line's closest approach at x = 0: z there from the two points' slope, 1 + 2 * (0 - 2) / 28.
+  const double z = 1. + (2. * (0. - 2.) / 28.);
+  BOOST_TEST(displacedPair(2., 1., 1., 30., 1., 3., 0., 2., z - 1.e-6, z + 1.e-6).longitudinal);
+  BOOST_TEST(!displacedPair(2., 1., 1., 30., 1., 3., 0., 2., z + 1.e-3, z + 1.).longitudinal);
+  // A line passing the beam line between the two: inward, then outward.
+  BOOST_TEST(!displacedPair(-3., 0.5, 0., 3.9, 0.5, 0., 0.001, 10., -kInfinity, kInfinity).transverse);
+}
+
+BOOST_AUTO_TEST_CASE(SmearedPairsPassAtThreeSigmaOfTheirOwnImpactAndZ)
+{
+  // The displaced helices' pairs again, their measurements smeared by 5 um
+  // across and along the beam: at 3 sigma of `displacedPairSigmas` they pass
+  // at their own impact and z (a bound of zero width there) all but rarely,
+  // and the sigmas bound the spread of the impact and z at the true
+  // curvature -- pulls of an rms at most 1, not far below it.
+  std::mt19937_64 rng{91};
+  std::uniform_real_distribution<double> unit{0., 1.};
+  std::normal_distribution<double> gauss{0., 1.};
+  constexpr double kSigma = 5.e-4; // [cm]
+  int pairs = 0;
+  int passing = 0;
+  double impactPull2 = 0.;
+  double zPull2 = 0.;
+  for (int trial = 0; trial < 20000; ++trial) {
+    const double pt = 0.05 * std::exp(unit(rng) * std::log(60.));
+    const double production = 18. * unit(rng);
+    const double azimuth = 2. * kPi * unit(rng);
+    const Helix h{
+      .x0 = production * std::cos(azimuth),
+      .y0 = production * std::sin(azimuth),
+      .z0 = -10. + (20. * unit(rng)),
+      .phi = 2. * kPi * unit(rng),
+      .k = (unit(rng) < 0.5 ? -1. : 1.) * curvatureAt(pt),
+      .tanLambda = -1. + (2. * unit(rng)),
+    };
+    std::size_t layer = 0;
+    while (layer < kRadii.size() && kRadii[layer] <= production) {
+      ++layer;
+    }
+    if (layer + 1U >= kRadii.size()) {
+      continue;
+    }
+    const auto a = crossing(h, kRadii[layer]);
+    const auto b = crossing(h, kRadii[layer + 1U]);
+    if (!a || !b) {
+      continue;
+    }
+    const auto own = circleThrough(a->x, a->y, a->z, b->x, b->y, b->z, h.k);
+    if (!own.outward || !own.z) {
+      continue;
+    }
+    ++pairs;
+    // Smeared across the radius (r phi) and in z.
+    const auto smear = [&](const Crossing& c) {
+      const double r = std::hypot(c.x, c.y);
+      const double d = kSigma * gauss(rng);
+      return Crossing{.x = c.x - (d * c.y / r), .y = c.y + (d * c.x / r), .z = c.z + (kSigma * gauss(rng))};
+    };
+    const auto sa = smear(*a);
+    const auto sb = smear(*b);
+    displaced::PairErrors<double> errors;
+    errors.sourceVarRPhi = errors.targetVarRPhi = errors.sourceVarZ = errors.targetVarZ = kSigma * kSigma;
+    const auto result = displaced::displacedPairWithin(sa.x, sa.y, sa.z, sb.x, sb.y, sb.z, errors, 3., std::abs(h.k), std::abs(own.impact), *own.z, *own.z);
+    passing += (result.transverse && result.longitudinal) ? 1 : 0;
+    const auto sigmas = displaced::displacedPairSigmas(sa.x, sa.y, sa.z, sb.x, sb.y, sb.z, errors, std::abs(h.k), std::abs(own.impact));
+    const auto measured = circleThrough(sa.x, sa.y, sa.z, sb.x, sb.y, sb.z, h.k);
+    if (measured.z) {
+      impactPull2 += std::pow((measured.impact - own.impact) / sigmas.impact, 2);
+      zPull2 += std::pow((*measured.z - *own.z) / sigmas.z, 2);
+    }
+  }
+  BOOST_REQUIRE(pairs > 10000);
+  BOOST_TEST(passing >= static_cast<int>(0.997 * pairs));
+  const double impactRms = std::sqrt(impactPull2 / pairs);
+  const double zRms = std::sqrt(zPull2 / pairs);
+  BOOST_TEST(impactRms <= 1.);
+  BOOST_TEST(impactRms >= 0.2);
+  BOOST_TEST(zRms <= 1.);
+  BOOST_TEST(zRms >= 0.2);
+  BOOST_TEST_MESSAGE("pull rms: impact " << impactRms << ", z " << zRms << "; passing " << passing << " of " << pairs);
+}
+
+BOOST_AUTO_TEST_CASE(TheScatteringAndTheBeamWidenTheImpactAsTheirVariances)
+{
+  displaced::PairErrors<double> errors;
+  const auto none = displaced::displacedPairSigmas(2.3, 0.1, 0., 3.1, 0.2, 1., errors, 0.02, 0.5);
+  BOOST_TEST(none.impact == 0.);
+  BOOST_TEST(none.z == 0.);
+  errors.sourceScatter = 4.e-6;
+  errors.beamVarTransverse = 9.e-6;
+  const auto both = displaced::displacedPairSigmas(2.3, 0.1, 0., 3.1, 0.2, 1., errors, 0.02, 0.5);
+  BOOST_TEST(both.impact * both.impact == 13.e-6, boost::test_tools::tolerance(1.e-12));
+  // The kink along the 3D path, the dip (1 / 0.806) squared over the chord's.
+  const double chord2 = (0.8 * 0.8) + (0.1 * 0.1);
+  BOOST_TEST(both.z * both.z == (1. + (1. / chord2)) * 4.e-6, boost::test_tools::tolerance(1.e-12));
+}
+
+BOOST_AUTO_TEST_CASE(TheReviewsCounterexamplesAreRight)
+{
+  // Counterexamples. (1) Near the circle's farthest point the arc's branch
+  // must not hang on a vanishing product's sign:
+  // every outward arc here has its closest approach before the source, at
+  // z <= 0, so a bound of [1, 4] admits none -- in double and in float.
+  BOOST_TEST(!displacedPair(34.4, 0., 0., 0., 39.3, 10., 0.03, 35., 1., 4.).longitudinal);
+  BOOST_TEST(!displacedPair<float>(8.6197029F, 33.3025633F, 0.F, 39.296894F, 0.4940891F, 10.F, 0.03F, 30.F, 1.F, 4.F).longitudinal);
+  // (2) On a line through the beam line, opposite sides: only the two
+  // diameter circles move outward, each at impact 34.4 and closest-approach z 0.
+  const auto diameter = displacedPair(-34.4, 0., 0., 39.3, 0., 10., 0.03, 35., -1., 1.);
+  BOOST_TEST((diameter.transverse && diameter.longitudinal));
+  BOOST_TEST(!displacedPair(-34.4, 0., 0., 39.3, 0., 10., 0.03, 34., -1., 1.).transverse);
+  // (3) The circle centred on the beam line has no closest approach: no z
+  // within a bound to admit.
+  BOOST_TEST(!displacedPair(20.64, 27.52, 0., -20.64, 27.52, 0., 0.03, 35., 1., 2.).longitudinal);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testFollow.cxx b/Detectors/GenericTracking/tracking/test/testFollow.cxx
new file mode 100644
index 0000000000000..3e03ce9a1c430
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testFollow.cxx
@@ -0,0 +1,1355 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testFollow.cxx
+/// \brief The follow: prediction, proposal and
+///        resolution of clusters beyond a track, the outward follow
+///        and the sensors by place its hole
+///        test reads.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Follow
+#include <boost/test/unit_test.hpp>
+#include <numbers>
+
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Base/LayerLinks.h"
+#include "ToyBarrel4Disc8.h"
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Tracking/Follow.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/SensorCells.h"
+#include "GenericTracking/Tracking/SlicePlan.h"
+
+#include "ToyBarrel8Fixture.h"
+#include "SerialReferences.h"
+#include "UniformMaterial.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <span>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+template <DetectorLayout Det>
+IterationParameters<Det> parameters()
+{
+  auto settings = toybarrel8::iterationSettings();
+  return iterationParameters<Det>(settings, VertexConstraint{}, scatteringTable<Det>(uniformLayerMaterial<Det>(0.)));
+}
+
+Scalar phiDifference(Scalar a, Scalar b) { return o2::gpu::CAMath::Abs(o2::math_utils::detail::toPMPi<Scalar>(a - b)); }
+
+constexpr std::size_t kMaxClusters = maxChainLayers<toybarrel8::Det>;
+using ToyTracks = BoundedColumns<TrackOf<kMaxClusters>::template RecordT>;
+using ToyProposal = FollowProposal<kMaxClusters>;
+
+/// One track of \a fixture's rows \a ordered, innermost first, fitted.
+ToyTracks fittedRows(const toybarrel8::Fixture& fixture, const std::vector<std::uint32_t>& ordered, const std::shared_ptr<BoundedMemoryResource>& pool)
+{
+  ClusterList<kMaxClusters> rows;
+  std::ranges::fill(rows.index, ClusterList<kMaxClusters>::kNoCluster);
+  std::ranges::copy(ordered, rows.index);
+  const auto count = ordered.size();
+  const UniformMaterial material;
+  const auto fit = fitMeasurements(Propagator{}, toybarrel8::trackingGeometry(), material, RowChain<toybarrel8::Det>{.frame = fixture.frame.get(), .rows = rows.index}, static_cast<int>(count));
+  BOOST_REQUIRE(fit.status == PropagationStatus::kOk);
+  ToyTracks tracks;
+  tracks.setMemoryResource(pool.get());
+  tracks.resize(1U);
+  auto view = tracks.view();
+  view.state[0] = fit.state;
+  view.outwardState[0] = fit.outwardState;
+  view.chi2[0] = fit.chi2;
+  view.ndf[0] = fit.ndf;
+  view.status[0] = fit.status;
+  view.clusters[0] = rows;
+  view.count[0] = static_cast<std::uint8_t>(count);
+  view.iteration[0] = 0U;
+  view.addedOutward[0] = 0U;
+  view.addedInward[0] = 0U;
+  return tracks;
+}
+
+ToyTracks fittedTrack(const toybarrel8::Fixture& fixture, std::size_t firstLayer, std::size_t lastLayer, const std::shared_ptr<BoundedMemoryResource>& pool)
+{
+  std::vector<std::uint32_t> rows;
+  for (std::size_t layer = firstLayer; layer <= lastLayer; ++layer) {
+    rows.push_back(fixture.row(layer));
+  }
+  return fittedRows(fixture, rows, pool);
+}
+
+std::array<std::uint32_t, toybarrel8::kLayers> widthBounds(const toybarrel8::Fixture& fixture) { return frameBounds(*fixture.frame).widthPS; }
+
+/// The toy's sensors by place, built once.
+const SensorCells<toybarrel8::Det>& toyCells()
+{
+  static const SensorCells<toybarrel8::Det> cells(toybarrel8::trackingGeometry());
+  return cells;
+}
+
+/// The material the kink tests step through: enough that the kink
+/// allowance's scaled scattering opens the step.
+constexpr UniformMaterial kKinkMaterial{.x2X0PerCm = 0.002F, .rho = 0.F};
+
+/// The kinks the budget test turns the track by beyond layer 5 and inside
+/// layer 2 [rad]: each in the middle of the range the nominal step refuses
+/// and the allowance admits.
+constexpr double kKinkOut = 0.0175;
+constexpr double kKinkIn = 0.0225;
+/// The kink allowance of the budget test [sigma]: both kinks fit well
+/// inside it, neither in the nominal step.
+constexpr double kBudgetKinkSigma = 30.;
+
+/// An iteration that follows, \a holes allowed, a kink allowance of
+/// \a kinkSigma with \a maxKinks, the beam constraint with \a beamLine, the
+/// end decided again with \a followEnd.
+IterationParameters<toybarrel8::Det> followParameters(int holes = 0, double kinkSigma = 1., int maxKinks = 1, bool beamLine = false, bool followEnd = false)
+{
+  auto settings = toybarrel8::iterationSettings();
+  settings.follow = true;
+  settings.followEnd = followEnd;
+  settings.followHoles = holes;
+  settings.kinkSigma = kinkSigma;
+  settings.maxKinks = maxKinks;
+  settings.beamConstraint = beamLine;
+  return iterationParameters<toybarrel8::Det>(settings, VertexConstraint{}, scatteringTable<toybarrel8::Det>(uniformLayerMaterial<toybarrel8::Det>(0.)));
+}
+
+/// Track \a track of \a tracks followed (`FollowStage`, the end decided
+/// again with \a DecidesEnd), its kink steps into \a steps where given,
+/// inward too with \a inward; serially, or on \a threads in chunks of
+/// \a chunkSize; with \a Greedy, the smallest chi2 instead of the lookahead; with
+/// \a EndDensity, the ends decided on the last row's density; with
+/// \a BeamEnd, the inward end against the beam line.
+template <bool BeamLine = false, bool DecidesEnd = false, bool Greedy = false, bool EndDensity = false, bool BeamEnd = false>
+ToyProposal followTrack(const toybarrel8::Fixture& fixture, const ToyTracks& tracks, const std::vector<std::uint8_t>& used, const IterationParameters<toybarrel8::Det>& parameters, const UniformMaterial& material = UniformMaterial{}, follow::KinkSteps* steps = nullptr, bool inward = true, int threads = 0, std::uint32_t chunkSize = 1U)
+{
+  const auto widths = widthBounds(fixture);
+  std::vector<ToyProposal> proposals(tracks.size());
+  std::vector<follow::KinkSteps> kinks(tracks.size());
+  // The end decided again starts from the fit without it, a pass of its own.
+  std::vector<BoundTrackState> starts(tracks.size());
+  if constexpr (DecidesEnd) {
+    const follow::EndFit<toybarrel8::Det, UniformMaterial> fit{
+      .parameters = &parameters,
+      .frame = fixture.frame.get(),
+      .geometry = &toybarrel8::trackingGeometry(),
+      .material = &material,
+      .propagator = Propagator{},
+      .tracks = tracks.view(),
+      .starts = starts.data(),
+      .trackOffset = 0U,
+    };
+    for (std::uint32_t track = 0; track < tracks.size(); ++track) {
+      fit(track);
+    }
+  }
+  const FollowStage<toybarrel8::Det, UniformMaterial, BeamLine, DecidesEnd, Greedy, EndDensity, BeamEnd> stage{&parameters, fixture.frame.get(), &toybarrel8::trackingGeometry(), &material, Propagator{}, tracks.view(), used.data(), widths.data(), toyCells().view(), proposals.data(), kinks.data(), inward, 0U, DecidesEnd ? starts.data() : nullptr};
+  if (threads == 0) {
+    for (std::uint32_t track = 0; track < tracks.size(); ++track) {
+      stage(track);
+    }
+  } else {
+    detail::TaskArena cpuArena{threads};
+    CpuStage<TrackletT> cpu{cpuArena};
+    cpu.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    cpu.forEachElement(static_cast<std::uint32_t>(tracks.size()), chunkSize, stage);
+  }
+  if (steps != nullptr) {
+    *steps = kinks.front();
+  }
+  return proposals.front();
+}
+
+bool sameProposal(const ToyProposal& a, const ToyProposal& b) { return a.outwardCount == b.outwardCount && a.inwardCount == b.inwardCount && a.replacedEnd == b.replacedEnd && std::ranges::equal(a.outward, b.outward) && std::ranges::equal(a.inward, b.inward); }
+
+/// The follow's passes over \a tracks (`Follow::run`), serially.
+StageStatus followAll(const toybarrel8::Fixture& fixture, const IterationParameters<toybarrel8::Det>& parameters, ToyTracks& tracks, std::vector<std::uint8_t>& used, Follow<toybarrel8::Det>& follow, const UniformMaterial& material = UniformMaterial{}) { return follow.run(SerialForEach{}, parameters, *fixture.frame, toybarrel8::trackingGeometry(), material, Propagator{}, tracks, 0U, true, false, used, widthBounds(fixture), toyCells().view()); }
+
+template <DetectorLayout Det>
+SensorID crossedSensor(const TrackingGeometry<Det>& geometry, const Propagator& propagator, const BoundTrackState& state, LayerID target, PropagationDirection direction)
+{
+  const auto& from = geometry.surface(state.surface);
+  const SensorID begin = firstSensorOfLayer<Det>(target);
+  const SensorID end = firstSensorOfLayer<Det>(static_cast<LayerID>(target + 1U));
+  for (SensorID sensor = begin; sensor < end; ++sensor) {
+    BoundTrackState probe = state;
+    if (propagate(propagator, probe, from, geometry.surface(sensor), direction).status == PropagationStatus::kOk) {
+      return sensor;
+    }
+  }
+  return kInvalidSensorID;
+}
+
+template <DetectorLayout Det>
+void checkAgainstSensor(const TrackingGeometry<Det>& geometry, const IterationParameters<Det>& iteration, const Propagator& propagator, BoundTrackState state, LayerID target, PropagationDirection direction)
+{
+  const auto source = geometry.surface(state.surface).layer;
+  const auto link = direction == PropagationDirection::kForward ? linkOf<Det>(source, target) : linkOf<Det>(target, source);
+  BOOST_REQUIRE(link < nLinks<Det>);
+  const auto prediction = predictLayerCrossing(propagator, iteration, geometry.surface(state.surface), state, target, direction);
+  BOOST_REQUIRE(prediction.status == PropagationStatus::kOk);
+  const auto sensor = crossedSensor(geometry, propagator, state, target, direction);
+  BOOST_REQUIRE(sensor != kInvalidSensorID);
+  const auto propagated = propagate(propagator, state, geometry.surface(state.surface), geometry.surface(sensor), direction);
+  BOOST_REQUIRE(propagated.status == PropagationStatus::kOk);
+  Scalar global[3]{};
+  surfaceToGlobal(geometry.surface(sensor), state.loc0(), state.loc1(), global);
+  const auto phi = azimuth(global[0], global[1]);
+  const auto second = secondCoordinate<Det>(target, o2::gpu::CAMath::Hypot(global[0], global[1]), global[2]);
+  BOOST_TEST(phiDifference(prediction.phi, phi) <= iteration.windows[link].phiHalfWidth);
+  BOOST_TEST(o2::gpu::CAMath::Abs(prediction.second - second) <= iteration.windows[link].secondHalfWidth);
+}
+
+/// \a hits with the ones inside layer \a layer turned there by \a angle in
+/// the transverse plane: a kink at that layer.
+std::vector<toybarrel8::Hit> kinkedAt(std::vector<toybarrel8::Hit> hits, LayerID layer, double angle)
+{
+  const double at = layerDistance<toybarrel8::Det>(layer);
+  for (auto& hit : hits) {
+    if (hit.point.layer < layer) {
+      const double shift = angle * (at - static_cast<double>(hit.point.r));
+      hit.point = toybarrel8::moved(hit.point, 0., shift);
+      hit.loc0 += static_cast<Scalar>(shift);
+    }
+  }
+  return hits;
+}
+
+/// \a hits with the ones outside layer \a layer turned there by \a angle.
+std::vector<toybarrel8::Hit> kinkedBeyond(std::vector<toybarrel8::Hit> hits, LayerID layer, double angle)
+{
+  const double at = layerDistance<toybarrel8::Det>(layer);
+  for (auto& hit : hits) {
+    if (hit.point.layer > layer) {
+      const double shift = angle * (static_cast<double>(hit.point.r) - at);
+      hit.point = toybarrel8::moved(hit.point, 0., shift);
+      hit.loc0 += static_cast<Scalar>(shift);
+    }
+  }
+  return hits;
+}
+
+/// The first step of a follow from \a state toward \a row, as the walk
+/// makes it (`updateCandidate`, nominal): its chi2 and sqrt|V| [cm^2].
+std::pair<double, double> firstStep(const toybarrel8::Fixture& fixture, const BoundTrackState& state, std::uint32_t row, PropagationDirection direction, const UniformMaterial& material = UniformMaterial{})
+{
+  BoundTrackState updated;
+  CovarianceFactors factors;
+  Scalar chi2 = 0.F;
+  Scalar determinant = 0.F;
+  BOOST_REQUIRE((follow::updateCandidate<false, true>(Propagator{}, toybarrel8::trackingGeometry(), material, measurementAt(*fixture.frame, row), direction, state, factorCovariance(state.cov), updated, factors, chi2, 1.F, &determinant)));
+  return {static_cast<double>(chi2), std::sqrt(static_cast<double>(determinant))};
+}
+
+/// Whether a query at \a surface's centre, with no reach, visits it.
+template <DetectorLayout Det>
+bool visitedAtItsCentre(const SensorCells<Det>& cells, const TrackingSurface& surface)
+{
+  const bool barrel = Detector<Det>::isBarrelLayer(surface.layer);
+  Scalar centre[3]{};
+  surfaceToGlobal(surface, 0.F, 0.F, centre);
+  const auto phi = o2::math_utils::detail::to02Pi<Scalar>(std::atan2(centre[1], centre[0]));
+  const Scalar second = barrel ? centre[2] : std::hypot(centre[0], centre[1]);
+  return cells.view().anySensor(surface.layer, phi, 0.F, second, 0.F, [&](std::uint32_t id) { return id == surface.id; });
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(ToyBarrelPredictionMatchesTheHelixAndTheCrossedSensor)
+{
+  using namespace toybarrel8;
+  constexpr double kStartPhi = 0.37;
+  constexpr double kSlope = 0.04;
+  constexpr double kPt = 1.7;
+  const auto hits = sensorHelixHits(kStartPhi, kSlope, kPt);
+  BOOST_REQUIRE(hits.size() == kLayers);
+  const auto& geometry = trackingGeometry();
+  const auto iteration = parameters<Det>();
+  const Propagator propagator;
+  const auto theta = static_cast<Scalar>(std::atan2(1., kSlope));
+  const Scalar sinTheta = std::sin(theta);
+  const double curvature = 1. / curvatureRadius(kPt, 20.);
+  const double arc = static_cast<double>(hits[0].point.z) / kSlope;
+
+  BoundTrackState state;
+  state.par[kLoc0] = hits[0].loc0;
+  state.par[kLoc1] = hits[0].loc1;
+  state.par[kPhi] = static_cast<Scalar>(kStartPhi + (curvature * arc));
+  state.par[kTheta] = theta;
+  state.par[kQOverP] = -sinTheta / static_cast<Scalar>(kPt);
+  state.surface = hits[0].surface;
+  const auto prediction = predictLayerCrossing(propagator, iteration, geometry.surface(state.surface), state, 1, PropagationDirection::kForward);
+  BOOST_REQUIRE(prediction.status == PropagationStatus::kOk);
+  const auto nominal = helixAt(kStartPhi, kSlope, kPt, 1);
+  BOOST_TEST(phiDifference(prediction.phi, nominal.phi) < 2.e-6F);
+  BOOST_TEST(o2::gpu::CAMath::Abs(prediction.second - nominal.z) < 2.e-5F);
+  checkAgainstSensor(geometry, iteration, propagator, state, 1, PropagationDirection::kForward);
+}
+
+BOOST_AUTO_TEST_CASE(BarrelAndDiscPredictionsMatchCrossedSensors)
+{
+  using Mixed = detectors::ToyBarrel4Disc8;
+  const auto detector = toyGeometry<Mixed>();
+  const TrackingGeometry<Mixed> geometry{detector};
+  const auto iteration = parameters<Mixed>();
+  const Propagator propagator;
+
+  BoundTrackState barrel;
+  barrel.surface = firstSensorOfLayer<Mixed>(0);
+  const auto& barrelSurface = geometry.surface(barrel.surface);
+  barrel.par[kPhi] = o2::gpu::CAMath::ATan2(barrelSurface.origin[1], barrelSurface.origin[0]);
+  barrel.par[kTheta] = 1.4F;
+  barrel.par[kQOverP] = 0.2F;
+  checkAgainstSensor(geometry, iteration, propagator, barrel, 1, PropagationDirection::kForward);
+
+  constexpr LayerID kDisc = 8;
+  constexpr LayerID kNextDisc = 9;
+  BoundTrackState disc;
+  disc.surface = firstSensorOfLayer<Mixed>(kDisc);
+  const auto& discSurface = geometry.surface(disc.surface);
+  const Scalar radius = o2::gpu::CAMath::Hypot(discSurface.origin[0], discSurface.origin[1]);
+  disc.par[kPhi] = o2::gpu::CAMath::ATan2(discSurface.origin[1], discSurface.origin[0]);
+  disc.par[kTheta] = o2::gpu::CAMath::ATan2(radius, discSurface.origin[2]);
+  disc.par[kQOverP] = 0.2F;
+  checkAgainstSensor(geometry, iteration, propagator, disc, kNextDisc, PropagationDirection::kForward);
+}
+
+/// A track at eta ~ 0 reaches a forward disc only after looping round many
+/// times. That crossing is not the next layer of its arc, and its covariance
+/// is past what float can factorise, so the prediction refuses it; a track
+/// that reaches the same disc within half a turn is predicted.
+BOOST_AUTO_TEST_CASE(PredictionRefusesACrossingPastHalfATurn)
+{
+  using Mixed = detectors::ToyBarrel4Disc8;
+  const auto detector = toyGeometry<Mixed>();
+  const TrackingGeometry<Mixed> geometry{detector};
+  const auto iteration = parameters<Mixed>();
+  const Propagator propagator;
+
+  constexpr LayerID kBarrel = 0;
+  LayerID disc = kInvalidLayerID;
+  for (std::size_t link = 0; link < nLinks<Mixed> && disc == kInvalidLayerID; ++link) {
+    if (Mixed::layerLinks[link].from == kBarrel && !Detector<Mixed>::isBarrelLayer(Mixed::layerLinks[link].to)) {
+      disc = Mixed::layerLinks[link].to;
+    }
+  }
+  BOOST_REQUIRE(disc != kInvalidLayerID);
+  const auto& discSurface = geometry.surface(firstSensorOfLayer<Mixed>(disc));
+  const bool forwardZ = discSurface.origin[2] > 0.F;
+
+  BoundTrackState state;
+  state.surface = firstSensorOfLayer<Mixed>(kBarrel);
+  const auto& start = geometry.surface(state.surface);
+  state.par[kPhi] = o2::gpu::CAMath::ATan2(start.origin[1], start.origin[0]);
+  // cot(theta) = 0.0103 and p = 0.5 GeV: a track that loops many times
+  // before it reaches the disc.
+  constexpr Scalar kNearlyTransverse = 1.5605F;
+  state.par[kTheta] = forwardZ ? kNearlyTransverse : std::numbers::pi_v<Scalar> - kNearlyTransverse;
+  state.par[kQOverP] = 2.F;
+  const auto looper = predictLayerCrossing(propagator, iteration, start, state, disc, PropagationDirection::kForward);
+  BOOST_TEST((looper.status == PropagationStatus::kTooManyTurns));
+
+  state.par[kTheta] = o2::gpu::CAMath::ATan2(o2::gpu::CAMath::Hypot(discSurface.origin[0], discSurface.origin[1]), discSurface.origin[2]);
+  const auto direct = predictLayerCrossing(propagator, iteration, start, state, disc, PropagationDirection::kForward);
+  BOOST_TEST((direct.status == PropagationStatus::kOk));
+}
+
+/// A predicted covariance that is not positive definite can give a negative
+/// or NaN chi2, or a NaN posterior. The update is refused rather than handed
+/// back with a chi2 that can pass the cut, or win it when negative.
+BOOST_AUTO_TEST_CASE(UpdateRefusesAnIndefiniteCovariance)
+{
+  using Mixed = detectors::ToyBarrel4Disc8;
+  const auto detector = toyGeometry<Mixed>();
+  const TrackingGeometry<Mixed> geometry{detector};
+  const Propagator propagator;
+  const UniformMaterial material;
+
+  BoundTrackState state;
+  state.surface = firstSensorOfLayer<Mixed>(0);
+  const auto& start = geometry.surface(state.surface);
+  state.par[kPhi] = o2::gpu::CAMath::ATan2(start.origin[1], start.origin[0]);
+  state.par[kTheta] = 1.4F;
+  state.par[kQOverP] = 0.2F;
+  for (int i = 0; i < kNBoundParams; ++i) {
+    state.variance(i) = 1.e-4F;
+  }
+  const auto sensor = crossedSensor(geometry, propagator, state, 1, PropagationDirection::kForward);
+  BOOST_REQUIRE(sensor != kInvalidSensorID);
+  BoundTrackState atTarget = state;
+  BOOST_REQUIRE(propagate(propagator, atTarget, start, geometry.surface(sensor), PropagationDirection::kForward).status == PropagationStatus::kOk);
+  const Measurement measurement{
+    .loc0 = atTarget.loc0(),
+    .loc1 = atTarget.loc1(),
+    .timePS = test::toyTimeBox(test::kToyTrackTimeNS).start,
+    .widthPS = test::toyTimeBox(test::kToyTrackTimeNS).width,
+    .varLoc0 = 1.e-6F,
+    .covLoc01 = 0.F,
+    .varLoc1 = 1.e-6F,
+    .clusterIndex = 0U,
+    .surface = sensor,
+  };
+
+  BoundTrackState output;
+  CovarianceFactors outputFactors;
+  Scalar chi2 = 0.F;
+  BOOST_REQUIRE(follow::updateCandidate<false>(propagator, geometry, material, measurement, PropagationDirection::kForward, state, factorCovariance(state.cov), output, outputFactors, chi2, 1.F));
+  BOOST_TEST(chi2 >= 0.F);
+
+  // The source may also be the destination buffer. Material must still
+  // start at the original source point, before publishing the crossing.
+  const UniformMaterial filled{.x2X0PerCm = 1.e-3F, .rho = 0.1F};
+  Propagator massive = propagator;
+  massive.massGeV = 0.13957F;
+  BoundTrackState separate;
+  CovarianceFactors separateFactors;
+  Scalar separateChi2 = 0.F;
+  BOOST_REQUIRE(follow::updateCandidate<false>(massive, geometry, filled, measurement, PropagationDirection::kForward, state, factorCovariance(state.cov), separate, separateFactors, separateChi2, 1.F));
+  auto aliased = state;
+  auto aliasedFactors = factorCovariance(state.cov);
+  Scalar aliasedChi2 = 0.F;
+  BOOST_REQUIRE(follow::updateCandidate<false>(massive, geometry, filled, measurement, PropagationDirection::kForward, aliased, aliasedFactors, aliased, aliasedFactors, aliasedChi2, 1.F));
+  // Bit identity is intentional, including floating-point encodings; these records have no padding.
+  // NOLINTNEXTLINE(bugprone-suspicious-memory-comparison)
+  BOOST_TEST(std::memcmp(&aliased, &separate, sizeof(BoundTrackState)) == 0);
+  // Bit identity is intentional, including floating-point encodings; these records have no padding.
+  // NOLINTNEXTLINE(bugprone-suspicious-memory-comparison)
+  BOOST_TEST(std::memcmp(&aliasedFactors, &separateFactors, sizeof(CovarianceFactors)) == 0);
+  BOOST_TEST(exactlyEqual(aliasedChi2, separateChi2));
+
+  // A negative loc0 variance, as a covariance past what float can hold ends
+  // up with: its factors are not those of a covariance, and the step refuses
+  // them before a negative chi2 could win the comparison.
+  state.variance(kLoc0) = -1.e-2F;
+  Measurement displaced = measurement;
+  displaced.loc0 += 0.01F;
+  BOOST_TEST(!follow::updateCandidate<false>(propagator, geometry, material, displaced, PropagationDirection::kForward, state, factorCovariance(state.cov), output, outputFactors, chi2, 1.F));
+}
+
+/// Navigation, both ways: a track on layers 0-4 takes 5-7 outward, one on
+/// 3-7 takes 2-0 inward, one on 2-5 both; the same on any threads; a track
+/// on every layer is not followed.
+BOOST_AUTO_TEST_CASE(AFollowTakesTheRowsBeyondTheTrackBothWays)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(0.42, 0.025, 1.8);
+  BOOST_REQUIRE(hits.size() == kLayers);
+  const Fixture fixture{hits};
+  const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto parameters = followParameters();
+
+  const auto outerTracks = fittedTrack(fixture, 0U, 4U, pool);
+  const auto outward = followTrack(fixture, outerTracks, used, parameters);
+  BOOST_REQUIRE(outward.outwardCount == 3U);
+  BOOST_TEST(outward.inwardCount == 0U);
+  for (std::size_t i = 0; i < 3U; ++i) {
+    BOOST_TEST(outward.outward[i] == fixture.row(5U + i));
+  }
+  const auto innerTracks = fittedTrack(fixture, 3U, 7U, pool);
+  const auto inward = followTrack(fixture, innerTracks, used, parameters);
+  BOOST_TEST(inward.outwardCount == 0U);
+  BOOST_REQUIRE(inward.inwardCount == 3U);
+  for (std::size_t i = 0; i < 3U; ++i) {
+    BOOST_TEST(inward.inward[i] == fixture.row(2U - i));
+  }
+  const auto middleTracks = fittedTrack(fixture, 2U, 5U, pool);
+  const auto both = followTrack(fixture, middleTracks, used, parameters);
+  BOOST_REQUIRE(both.outwardCount == 2U);
+  BOOST_REQUIRE(both.inwardCount == 2U);
+  BOOST_TEST(both.outward[0] == fixture.row(6U));
+  BOOST_TEST(both.outward[1] == fixture.row(7U));
+  BOOST_TEST(both.inward[0] == fixture.row(1U));
+  BOOST_TEST(both.inward[1] == fixture.row(0U));
+
+  for (const int threads : {1, 2, 4}) {
+    for (const std::uint32_t chunk : {1U, 2U, 7U}) {
+      BOOST_TEST(sameProposal(followTrack(fixture, middleTracks, used, parameters, UniformMaterial{}, nullptr, true, threads, chunk), both));
+    }
+  }
+  const auto whole = fittedTrack(fixture, 0U, kLayers - 1U, pool);
+  const auto none = followTrack(fixture, whole, used, parameters);
+  BOOST_TEST(none.outwardCount + none.inwardCount == 0U);
+}
+
+/// Inward stays off where the iteration shares innermost rows.
+BOOST_AUTO_TEST_CASE(InwardStaysOffWithSharedInnermostRows)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(0.42, 0.025, 1.8);
+  const Fixture fixture{hits};
+  const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto tracks = fittedTrack(fixture, 2U, 5U, pool);
+  const auto proposal = followTrack(fixture, tracks, used, followParameters(), UniformMaterial{}, nullptr, false);
+  BOOST_TEST(proposal.outwardCount == 2U);
+  BOOST_TEST(proposal.inwardCount == 0U);
+}
+
+/// Inward from the beam line's update: the
+/// same rows on a track from the origin.
+BOOST_AUTO_TEST_CASE(InwardFromTheBeamLineTakesTheSameRows)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(1.1, -0.02, 2.2);
+  const Fixture fixture{hits};
+  const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto tracks = fittedTrack(fixture, 3U, 7U, pool);
+  const auto plain = followTrack(fixture, tracks, used, followParameters());
+  const auto beam = followTrack<true>(fixture, tracks, used, followParameters(0, 1., 1, true));
+  BOOST_REQUIRE(plain.inwardCount == 3U);
+  BOOST_TEST(sameProposal(beam, plain));
+}
+
+/// BeamEnd: a track on
+/// layers 3-7 from the origin walks inward to rows 2, 1 and 0 with the
+/// variant as without. Its row on layer 0 moved along r-phi: where the walk
+/// without the variant still takes it, the variant keeps it while the step's
+/// prediction updated with the beam line holds it under the gate and refuses
+/// it beyond, the walk's other rows as before; the refusal comes before the
+/// step's own.
+BOOST_AUTO_TEST_CASE(AnInwardLastRowOffTheBeamLineIsRefused)
+{
+  using namespace toybarrel8;
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto parameters = followParameters(0, 1., 1, true);
+  const auto clean = sensorHelixHits(1.1, -0.02, 2.2);
+  const auto follow = [&](const std::vector<Hit>& hits) {
+    const Fixture fixture{hits};
+    const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+    const auto tracks = fittedTrack(fixture, 3U, 7U, pool);
+    return std::pair{followTrack<true>(fixture, tracks, used, parameters), followTrack<true, false, false, false, true>(fixture, tracks, used, parameters)};
+  };
+  const auto [plain, beamEnd] = follow(clean);
+  BOOST_REQUIRE(plain.inwardCount == 3U);
+  BOOST_TEST(sameProposal(beamEnd, plain));
+  bool keptSeen = false;
+  bool refusedSeen = false;
+  bool keptAfterRefusal = false;
+  for (int step = 1; step <= 40; ++step) {
+    const double offset = 0.0005 * step;
+    auto hits = clean;
+    hits[0].point = moved(hits[0].point, 0., offset);
+    hits[0].loc0 += static_cast<Scalar>(offset);
+    const auto [without, with] = follow(hits);
+    if (without.inwardCount != 3U) {
+      continue;
+    }
+    if (with.inwardCount == 2U) {
+      refusedSeen = true;
+      BOOST_TEST(with.inward[0] == without.inward[0]);
+      BOOST_TEST(with.inward[1] == without.inward[1]);
+    } else {
+      BOOST_TEST(sameProposal(with, without));
+      keptSeen = true;
+      keptAfterRefusal = keptAfterRefusal || refusedSeen;
+    }
+  }
+  BOOST_TEST(keptSeen);
+  BOOST_TEST(refusedSeen);
+  BOOST_TEST(!keptAfterRefusal);
+}
+
+BOOST_AUTO_TEST_CASE(AFollowRejectsUsedNoiseAndDisplacedRows)
+{
+  using namespace toybarrel8;
+  const auto clean = sensorHelixHits(1.1, -0.02, 2.2);
+  BOOST_REQUIRE(clean.size() == kLayers);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto parameters = followParameters();
+
+  // Row 5 taken: a hole on layer 5 ends the follow.
+  const Fixture fixture{clean};
+  const auto tracks = fittedTrack(fixture, 0U, 4U, pool);
+  std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  used[fixture.row(5U)] = kExclusive;
+  BOOST_TEST(followTrack(fixture, tracks, used, parameters).outwardCount == 0U);
+
+  auto withNoise = clean;
+  Hit noise = clean[5];
+  noise.point = moved(noise.point, 0.02, 0.02);
+  noise.loc0 += 0.02F;
+  noise.loc1 += 0.02F;
+  withNoise.push_back(noise);
+  const Fixture noiseFixture{withNoise};
+  const auto noiseTracks = fittedTrack(noiseFixture, 0U, 4U, pool);
+  const std::vector<std::uint8_t> noiseUsed(noiseFixture.frame->size(), kFree);
+  const auto noiseProposal = followTrack(noiseFixture, noiseTracks, noiseUsed, parameters);
+  BOOST_REQUIRE(noiseProposal.outwardCount == 3U);
+  BOOST_TEST(noiseProposal.outward[0] == noiseFixture.row(5U));
+
+  // Row 5 displaced: no row on layer 5 within the gate, a hole.
+  auto displaced = clean;
+  displaced[5].point = moved(displaced[5].point, 0.02, 0.02);
+  displaced[5].loc0 += 0.02F;
+  displaced[5].loc1 += 0.02F;
+  const Fixture displacedFixture{displaced};
+  const auto displacedTracks = fittedTrack(displacedFixture, 0U, 4U, pool);
+  const std::vector<std::uint8_t> displacedUsed(displacedFixture.frame->size(), kFree);
+  BOOST_TEST(followTrack(displacedFixture, displacedTracks, displacedUsed, parameters).outwardCount == 0U);
+}
+
+BOOST_AUTO_TEST_CASE(AFollowSkipsATrackWithoutFittedEndStates)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(1.1, -0.02, 2.2);
+  const Fixture fixture{hits};
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  auto tracks = fittedTrack(fixture, 2U, 5U, pool);
+  tracks.view().status[0] = PropagationStatus::kNoIntersection;
+  tracks.view().state[0].surface = kInvalidSensorID;
+  tracks.view().outwardState[0].surface = kInvalidSensorID;
+  const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  const auto proposal = followTrack(fixture, tracks, used, followParameters());
+  BOOST_TEST(proposal.outwardCount == 0U);
+  BOOST_TEST(proposal.inwardCount == 0U);
+}
+
+/// A hole: a layer whose sensor the track crosses without a free row. Past
+/// the budget the direction ends; within it, it goes on -- in the toy no
+/// link leads past a layer, so it ends there all the same, its holes spent.
+BOOST_AUTO_TEST_CASE(AHoleEndsTheDirectionPastItsBudget)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(1.1, -0.02, 2.2);
+  const Fixture fixture{hits};
+  std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  used[fixture.row(5U)] = kExclusive;
+  used[fixture.row(1U)] = kExclusive;
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto tracks = fittedTrack(fixture, 2U, 4U, pool);
+  for (const int holes : {0, 1}) {
+    const auto proposal = followTrack(fixture, tracks, used, followParameters(holes));
+    BOOST_TEST(proposal.outwardCount == 0U);
+    BOOST_TEST(proposal.inwardCount == 0U);
+  }
+}
+
+/// The unconfirmed drop: row 6 taken, the follow takes row 5,
+/// then crosses layer 6's sensor without a row, and drops row 5, which
+/// nothing confirms; with every row free it reaches the last layer, beyond
+/// which nothing is crossed, and keeps all three.
+BOOST_AUTO_TEST_CASE(AnUnconfirmedLastRowIsDroppedAndOneWithNothingBeyondKept)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(0.42, 0.025, 1.8);
+  const Fixture fixture{hits};
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto tracks = fittedTrack(fixture, 0U, 4U, pool);
+  std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  used[fixture.row(6U)] = kExclusive;
+  BOOST_TEST(followTrack(fixture, tracks, used, followParameters()).outwardCount == 0U);
+  const std::vector<std::uint8_t> free(fixture.frame->size(), kFree);
+  BOOST_TEST(followTrack(fixture, tracks, free, followParameters()).outwardCount == 3U);
+}
+
+/// The unconfirmed drop inward where the step that found nothing saw a row near: row 0 moved so that it lies within the step's
+/// window but above the gate. The inward walk takes row 1, refuses the moved
+/// row 0 and crosses layer 0's sensor without a row, and keeps row 1 all the
+/// same; the moved row is not taken. Moved out of the window, nothing is
+/// near and row 1 goes as before. Outward the same evidence does not keep a
+/// row: a track on layers 0-4 with row 6 moved loses row 5 either way. The
+/// offsets are found by the step's own outcomes.
+BOOST_AUTO_TEST_CASE(ARowRefusedAboveTheGateKeepsTheRowBeforeInwardOnly)
+{
+  using namespace toybarrel8;
+  struct Seen : follow::NoObserver {
+    std::vector<std::tuple<LayerID, std::uint32_t, StepOutcome>>* rows = nullptr;
+    void candidate(LayerID layer, std::uint32_t row, StepOutcome outcome, Scalar /*chi2*/) const { rows->emplace_back(layer, row, outcome); }
+  };
+  const auto hits = sensorHelixHits(0.42, 0.025, 1.8);
+  const auto parameters = followParameters();
+  const UniformMaterial material;
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto outcomeOf = [](const std::vector<std::tuple<LayerID, std::uint32_t, StepOutcome>>& seen, std::uint32_t row) {
+    for (const auto& [layer, at, outcome] : seen) {
+      if (at == row) {
+        return std::optional{outcome};
+      }
+    }
+    return std::optional<StepOutcome>{};
+  };
+  for (const bool inwardCase : {true, false}) {
+    bool gatedSeen = false;
+    bool outsideSeen = false;
+    for (int step = 0; step < 38; ++step) {
+      const double offset = 0.001 + (0.0005 * step);
+      auto movedHits = hits;
+      const std::size_t movedLayer = inwardCase ? 0U : 6U;
+      movedHits[movedLayer].point = moved(movedHits[movedLayer].point, offset, offset);
+      movedHits[movedLayer].loc0 += static_cast<Scalar>(offset);
+      movedHits[movedLayer].loc1 += static_cast<Scalar>(offset);
+      const Fixture fixture{movedHits};
+      const auto tracks = inwardCase ? fittedTrack(fixture, 2U, 6U, pool) : fittedTrack(fixture, 0U, 4U, pool);
+      std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+      if (inwardCase) {
+        used[fixture.row(7U)] = kExclusive; // nothing outward
+      }
+      const auto widths = widthBounds(fixture);
+      std::vector<ToyProposal> proposals(1U);
+      std::vector<follow::KinkSteps> kinks(1U);
+      const FollowStage<Det, UniformMaterial> stage{&parameters, fixture.frame.get(), &trackingGeometry(), &material, Propagator{}, tracks.view(), used.data(), widths.data(), toyCells().view(), proposals.data(), kinks.data(), true, 0U, nullptr};
+      std::vector<std::tuple<LayerID, std::uint32_t, StepOutcome>> seen;
+      const Seen observer{{}, &seen};
+      const auto view = tracks.view();
+      stage.follow(view.state[0], view.outwardState[0], view.clusters[0], view.count[0], proposals[0], kinks[0], observer);
+      const auto outcome = outcomeOf(seen, fixture.row(movedLayer));
+      BOOST_REQUIRE(outcome.has_value());
+      if (*outcome == StepOutcome::kChi2) { // NOLINT(bugprone-unchecked-optional-access): BOOST_REQUIRE checks it
+        gatedSeen = true;
+        if (inwardCase) {
+          BOOST_TEST(proposals[0].inwardCount == 1U);
+          BOOST_TEST(proposals[0].inward[0] == fixture.row(1U));
+        } else {
+          BOOST_TEST(proposals[0].outwardCount == 0U);
+        }
+      } else if (*outcome == StepOutcome::kOutsideWindow) {
+        outsideSeen = true;
+        BOOST_TEST((inwardCase ? proposals[0].inwardCount : proposals[0].outwardCount) == 0U);
+      }
+    }
+    BOOST_TEST(gatedSeen);
+    BOOST_TEST(outsideSeen);
+  }
+}
+
+/// EndDensity's layout-end refusal: a track
+/// on layers 1-7 has room for one row, so its inward walk takes row 0 and
+/// leaves through the capacity, at layer 0, which no link leads inward
+/// from: the row goes where its update's sqrt|V| is above the key, stays
+/// below it, and stays without the variant or with the key 0. Outward, at
+/// the last layer, the key never acts; inward, on a walk that stops at
+/// layer 0 for want of targets, it does.
+BOOST_AUTO_TEST_CASE(AtTheLayoutsEndAWidePredictionLosesItsLastRow)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(0.42, 0.025, 1.8);
+  const Fixture fixture{hits};
+  const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto tracks = fittedTrack(fixture, 1U, 7U, pool);
+  const auto [chi2, sqrtDet] = firstStep(fixture, tracks.view().state[0], fixture.row(0U), PropagationDirection::kBackward);
+  auto parameters = followParameters();
+  BOOST_REQUIRE(followTrack(fixture, tracks, used, parameters).inwardCount == 1U);
+  parameters.followEndMaxSqrtDet = static_cast<Scalar>(0.99 * sqrtDet);
+  BOOST_TEST(followTrack(fixture, tracks, used, parameters).inwardCount == 1U);
+  BOOST_TEST((followTrack<false, false, false, true>(fixture, tracks, used, parameters).inwardCount == 0U));
+  parameters.followEndMaxSqrtDet = static_cast<Scalar>(1.01 * sqrtDet);
+  BOOST_TEST((followTrack<false, false, false, true>(fixture, tracks, used, parameters).inwardCount == 1U));
+  parameters.followEndMaxSqrtDet = 0.F;
+  BOOST_TEST((followTrack<false, false, false, true>(fixture, tracks, used, parameters).inwardCount == 1U));
+
+  parameters.followEndMaxSqrtDet = 1e-12F;
+  const auto outward = followTrack<false, false, false, true>(fixture, fittedTrack(fixture, 0U, 4U, pool), used, parameters);
+  BOOST_TEST(outward.outwardCount == 3U);
+  std::vector<std::uint8_t> outerTaken(fixture.frame->size(), kFree);
+  outerTaken[fixture.row(7U)] = kExclusive;
+  const auto inward = followTrack<false, false, false, true>(fixture, fittedTrack(fixture, 2U, 6U, pool), outerTaken, parameters);
+  BOOST_REQUIRE(inward.inwardCount == 1U);
+  BOOST_TEST(inward.inward[0] == fixture.row(1U));
+}
+
+/// The layout-end refusal and a kink step's witness: a track turned at layer 2 takes row 1
+/// by the kink allowance, standing on row 0; refusing row 0 at the layout's
+/// end leaves the kink step without its witness, and `KeepWitnesses` takes
+/// row 1 with it.
+BOOST_AUTO_TEST_CASE(ARefusedLastRowTakesTheKinkItWitnessed)
+{
+  using namespace toybarrel8;
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto kinked = kinkedAt(sensorHelixHits(0.42, 0.025, 1.8), 2U, 0.012);
+  const Fixture fixture{kinked};
+  const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  const auto tracks = fittedTrack(fixture, 2U, 7U, pool);
+  auto parameters = followParameters(0, 10., 1);
+  follow::KinkSteps steps;
+  const auto kept = followTrack<false, false, false, true>(fixture, tracks, used, parameters, kKinkMaterial, &steps);
+  BOOST_REQUIRE(kept.inwardCount == 2U);
+  BOOST_REQUIRE(steps.inward == 1U);
+  BOOST_REQUIRE(steps.inwardWitnessed == 1U);
+  parameters.followEndMaxSqrtDet = 1e-12F;
+  auto refused = followTrack<false, false, false, true>(fixture, tracks, used, parameters, kKinkMaterial, &steps);
+  BOOST_REQUIRE(refused.inwardCount == 1U);
+  BOOST_TEST(refused.inward[0] == fixture.row(1U));
+  follow::KeepWitnesses<kMaxClusters>{.proposals = &refused, .steps = &steps}(0U);
+  BOOST_TEST(refused.inwardCount == 0U);
+}
+
+/// EndDensity's density keep: row 6 taken, the outward walk takes row 5 and
+/// crosses layer 6's sensor without a row, and the unconfirmed drop removes row 5 -- unless its
+/// density g = exp(-chi2 / 2) / (2 pi sqrt|V|) is above the key: kept just
+/// below g, dropped just above it, without the variant or with the key 0.
+/// Inward the key never keeps: row 0 taken, the walk drops row 1 as before.
+BOOST_AUTO_TEST_CASE(ADenseLastRowStaysOutwardWhereTheUnconfirmedDropWouldRemoveIt)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(0.42, 0.025, 1.8);
+  const Fixture fixture{hits};
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto tracks = fittedTrack(fixture, 0U, 4U, pool);
+  std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  used[fixture.row(6U)] = kExclusive;
+  const auto [chi2, sqrtDet] = firstStep(fixture, tracks.view().outwardState[0], fixture.row(5U), PropagationDirection::kForward);
+  const double density = std::exp(-0.5 * chi2) / (2. * std::numbers::pi * sqrtDet);
+  auto parameters = followParameters();
+  parameters.followKeepDensity = static_cast<Scalar>(0.99 * density);
+  BOOST_TEST(followTrack(fixture, tracks, used, parameters).outwardCount == 0U);
+  const auto kept = followTrack<false, false, false, true>(fixture, tracks, used, parameters);
+  BOOST_REQUIRE(kept.outwardCount == 1U);
+  BOOST_TEST(kept.outward[0] == fixture.row(5U));
+  parameters.followKeepDensity = static_cast<Scalar>(1.01 * density);
+  BOOST_TEST((followTrack<false, false, false, true>(fixture, tracks, used, parameters).outwardCount == 0U));
+  parameters.followKeepDensity = 0.F;
+  BOOST_TEST((followTrack<false, false, false, true>(fixture, tracks, used, parameters).outwardCount == 0U));
+
+  parameters.followKeepDensity = 1e-30F;
+  std::vector<std::uint8_t> innerTaken(fixture.frame->size(), kFree);
+  innerTaken[fixture.row(0U)] = kExclusive;
+  innerTaken[fixture.row(7U)] = kExclusive;
+  BOOST_TEST((followTrack<false, false, false, true>(fixture, fittedTrack(fixture, 2U, 6U, pool), innerTaken, parameters).inwardCount == 0U));
+}
+
+/// The lookahead on a clean track: a noise row beside the true one on layer 5, the
+/// next layer confirms the true one.
+BOOST_AUTO_TEST_CASE(TheConfirmationTakesTheTrueRowsOnACleanTrack)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(1.1, -0.02, 2.2);
+  auto withNoise = hits;
+  Hit noise = hits[5];
+  noise.point = moved(noise.point, 0.002, 0.002);
+  noise.loc0 += 0.002F;
+  noise.loc1 += 0.002F;
+  withNoise.push_back(noise);
+  const Fixture fixture{withNoise};
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto tracks = fittedTrack(fixture, 0U, 4U, pool);
+  const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  const auto proposal = followTrack(fixture, tracks, used, followParameters());
+  BOOST_REQUIRE(proposal.outwardCount == 3U);
+  for (std::size_t i = 0; i < 3U; ++i) {
+    BOOST_TEST(proposal.outward[i] == fixture.row(5U + i));
+  }
+}
+
+/// The lookahead where the greedy choice is wrong: the particle kinks at layer 5, its
+/// rows 5-7 shifted in r phi by 12, 24 and 36 um; a noise row where its row
+/// 5 would have been, nearer the prediction. The next layer confirms the
+/// particle's row and refuses the noise row.
+BOOST_AUTO_TEST_CASE(TheConfirmationTakesTheRowTheNextLayerConfirms)
+{
+  using namespace toybarrel8;
+  auto hits = sensorHelixHits(1.1, -0.02, 2.2);
+  const Hit noise = hits[5];
+  hits = kinkedBeyond(std::move(hits), 4U, 0.006);
+  hits.push_back(noise);
+  const Fixture fixture{hits};
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto tracks = fittedTrack(fixture, 0U, 4U, pool);
+  const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  const auto proposal = followTrack(fixture, tracks, used, followParameters());
+  BOOST_REQUIRE(proposal.outwardCount == 3U);
+  for (std::size_t i = 0; i < 3U; ++i) {
+    BOOST_TEST(proposal.outward[i] == fixture.row(5U + i));
+  }
+  // The greedy choice takes the noise
+  // row, nearer the prediction, where the lookahead takes the confirmed one; the next
+  // layer refuses it, so nothing stands on it and the unconfirmed drop removes it: the
+  // direction ends with no row.
+  const auto greedy = followTrack<false, false, true>(fixture, tracks, used, followParameters());
+  BOOST_TEST(greedy.outwardCount == 0U);
+}
+
+/// The lookahead where nothing can confirm, on the last layer outward: two rows pass the
+/// step, and it takes the smaller chi2, the true row, whichever of them comes
+/// first in the frame.
+BOOST_AUTO_TEST_CASE(UnconfirmedRowsRankByTheirChi2)
+{
+  using namespace toybarrel8;
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto hits = sensorHelixHits(0.42, 0.025, 1.8);
+  bool decoyFirst = false;
+  for (const bool decoyEarlier : {false, true}) {
+    for (const double offset : {-0.0015, 0.0015}) {
+      auto withDecoy = hits;
+      Hit decoy = hits[7];
+      decoy.point = moved(decoy.point, offset, offset);
+      decoy.loc0 += static_cast<Scalar>(offset);
+      decoy.loc1 += static_cast<Scalar>(offset);
+      withDecoy.push_back(decoy);
+      if (decoyEarlier) {
+        std::swap(withDecoy[7], withDecoy[kLayers]);
+      }
+      const std::size_t trueCluster = decoyEarlier ? kLayers : 7U;
+      const std::size_t decoyCluster = decoyEarlier ? 7U : kLayers;
+      const Fixture fixture{withDecoy};
+      decoyFirst = decoyFirst || fixture.row(decoyCluster) < fixture.row(trueCluster);
+      const auto tracks = fittedTrack(fixture, 0U, 6U, pool);
+      const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+      const auto proposal = followTrack(fixture, tracks, used, followParameters());
+      BOOST_REQUIRE(proposal.outwardCount == 1U);
+      BOOST_TEST(proposal.outward[0] == fixture.row(trueCluster));
+    }
+  }
+  BOOST_TEST(decoyFirst);
+}
+
+/// The kink pass (the recovery pass): a track turned
+/// at layer 3 by more than the nominal step admits is followed inward by the
+/// kink allowance, its row on layer 2 standing on layer 1's, which confirms
+/// it; without the allowance, or with the budget spent, no kink step;
+/// without the rows inside, nothing confirms it and it takes nothing.
+BOOST_AUTO_TEST_CASE(AKinkStepNeedsItsWitness)
+{
+  using namespace toybarrel8;
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto kinked = kinkedAt(sensorHelixHits(0.42, 0.025, 1.8), 3U, 0.012);
+  const Fixture fixture{kinked};
+  const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  const auto tracks = fittedTrack(fixture, 3U, 7U, pool);
+  follow::KinkSteps steps;
+  BOOST_TEST(followTrack(fixture, tracks, used, followParameters(0, 1., 1), kKinkMaterial, &steps).inwardCount == 0U);
+  const auto recovered = followTrack(fixture, tracks, used, followParameters(0, 10., 1), kKinkMaterial, &steps);
+  BOOST_REQUIRE(recovered.inwardCount == 3U);
+  for (std::size_t i = 0; i < 3U; ++i) {
+    BOOST_TEST(recovered.inward[i] == fixture.row(2U - i));
+  }
+  BOOST_TEST(steps.inward == 1U);
+  BOOST_TEST(steps.outward == 0U);
+  BOOST_TEST(steps.inwardWitnessed == 1U);
+  BOOST_TEST(followTrack(fixture, tracks, used, followParameters(0, 10., 0), kKinkMaterial, &steps).inwardCount == 0U);
+
+  const std::vector<Hit> outer(kinked.begin() + 2, kinked.end());
+  const Fixture unwitnessed{outer};
+  const std::vector<std::uint8_t> outerUsed(unwitnessed.frame->size(), kFree);
+  const auto outerTracks = fittedTrack(unwitnessed, 1U, 5U, pool);
+  BOOST_TEST(followTrack(unwitnessed, outerTracks, outerUsed, followParameters(0, 10., 1), kKinkMaterial, &steps).inwardCount == 0U);
+  BOOST_TEST(steps.inward == 0U);
+}
+
+/// The nominal pass first: on a clean track with the kink allowance, every
+/// row is taken by the nominal step, and no kink is charged.
+BOOST_AUTO_TEST_CASE(TheNominalPassComesFirst)
+{
+  using namespace toybarrel8;
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const Fixture fixture{sensorHelixHits(0.42, 0.025, 1.8)};
+  const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  const auto tracks = fittedTrack(fixture, 2U, 5U, pool);
+  follow::KinkSteps steps;
+  const auto proposal = followTrack(fixture, tracks, used, followParameters(0, 10., 1), kKinkMaterial, &steps);
+  BOOST_TEST(proposal.outwardCount == 2U);
+  BOOST_TEST(proposal.inwardCount == 2U);
+  BOOST_TEST(steps.outward + steps.inward == 0U);
+  BOOST_TEST(steps.outwardWitnessed + steps.inwardWitnessed == 0U);
+}
+
+/// One kink budget for both directions: a track turned beyond layer 5 and
+/// inside layer 2 takes the outward kink step first; with one kink, the
+/// inward one is not made; with two, both are.
+BOOST_AUTO_TEST_CASE(TheDirectionsShareTheKinkBudget)
+{
+  using namespace toybarrel8;
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto hits = kinkedAt(kinkedBeyond(sensorHelixHits(0.42, 0.025, 1.8), 5U, kKinkOut), 2U, kKinkIn);
+  const Fixture fixture{hits};
+  const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  const auto tracks = fittedTrack(fixture, 2U, 5U, pool);
+  follow::KinkSteps steps;
+  // Without the allowance neither side is reached.
+  const auto none = followTrack(fixture, tracks, used, followParameters(0, 1., 2), kKinkMaterial, &steps);
+  BOOST_TEST(none.outwardCount + none.inwardCount == 0U);
+  const auto one = followTrack(fixture, tracks, used, followParameters(0, kBudgetKinkSigma, 1), kKinkMaterial, &steps);
+  BOOST_TEST(steps.outward == 1U);
+  BOOST_TEST(steps.inward == 0U);
+  BOOST_TEST(one.outwardCount == 2U);
+  BOOST_TEST(one.inwardCount == 0U);
+  const auto two = followTrack(fixture, tracks, used, followParameters(0, kBudgetKinkSigma, 2), kKinkMaterial, &steps);
+  BOOST_TEST(steps.outward == 1U);
+  BOOST_TEST(steps.inward == 1U);
+  BOOST_TEST(two.outwardCount == 2U);
+  BOOST_TEST(two.inwardCount == 2U);
+}
+
+/// One time box for both directions: the road's rows at 30 ns, its outer
+/// rows at 55 ns and its inner ones at 10 ns. Each fits the road's box
+/// alone; once the outer rows have narrowed it, the inner ones no longer do.
+BOOST_AUTO_TEST_CASE(TheDirectionsShareTheTimeBox)
+{
+  using namespace toybarrel8;
+  auto hits = sensorHelixHits(0.42, 0.025, 1.8);
+  for (std::size_t layer = 0; layer < kLayers; ++layer) {
+    hits[layer].timeNS = 30.;
+    if (layer < 3U) {
+      hits[layer].timeNS = 10.;
+    } else if (layer > 5U) {
+      hits[layer].timeNS = 55.;
+    }
+  }
+  const Fixture fixture{hits, 80.};
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto tracks = fittedTrack(fixture, 3U, 5U, pool);
+  const std::vector<std::uint8_t> free(fixture.frame->size(), kFree);
+  const auto both = followTrack(fixture, tracks, free, followParameters());
+  BOOST_TEST(both.outwardCount == 2U);
+  BOOST_TEST(both.inwardCount == 0U);
+  std::vector<std::uint8_t> outerTaken(fixture.frame->size(), kFree);
+  outerTaken[fixture.row(6U)] = kExclusive;
+  outerTaken[fixture.row(7U)] = kExclusive;
+  const auto inward = followTrack(fixture, tracks, outerTaken, followParameters());
+  BOOST_TEST(inward.outwardCount == 0U);
+  BOOST_TEST(inward.inwardCount == 3U);
+}
+
+/// A kink step keeps its witness through the bidding (the recovery pass): a
+/// direction cut by the bidding on the witness drops
+/// the kink step with it, and the rows from it on.
+BOOST_AUTO_TEST_CASE(AKinkStepFallsWithItsWitness)
+{
+  BOOST_TEST(follow::keptWithWitnesses(3U, 0b001U) == 3U);
+  BOOST_TEST(follow::keptWithWitnesses(1U, 0b001U) == 0U);
+  BOOST_TEST(follow::keptWithWitnesses(2U, 0b011U) == 0U);
+  BOOST_TEST(follow::keptWithWitnesses(3U, 0b011U) == 3U);
+  BOOST_TEST(follow::keptWithWitnesses(2U, 0b100U) == 2U);
+  BOOST_TEST(follow::keptWithWitnesses(3U, 0b100U) == 2U);
+  BOOST_TEST(follow::keptWithWitnesses(0U, 0b111U) == 0U);
+
+  ToyProposal proposal;
+  proposal.inward[0] = 7U;
+  proposal.inward[1] = 8U;
+  proposal.inward[2] = 9U;
+  proposal.inwardCount = 1U; // the bidding cut it on its second row
+  proposal.outward[0] = 3U;
+  proposal.outwardCount = 1U;
+  const follow::KinkSteps steps{.outwardWitnessed = 0U, .inwardWitnessed = 0b001U, .outward = 0U, .inward = 1U};
+  follow::KeepWitnesses<kMaxClusters>{.proposals = &proposal, .steps = &steps}(0U);
+  BOOST_TEST(proposal.inwardCount == 0U);
+  BOOST_TEST(proposal.outwardCount == 1U);
+}
+
+BOOST_AUTO_TEST_CASE(BiddingKeepsTheBetterTrackAndTruncatesTheOther)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(2.2, 0.015, 2.4);
+  const Fixture fixture{hits};
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  auto tracks = fittedTrack(fixture, 0U, 4U, pool);
+  tracks.resize(2U);
+  tracks.write(1U, tracks.read(0U));
+  std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  Follow<Det> follow;
+  follow.setMemoryPool(pool);
+  BOOST_REQUIRE(followAll(fixture, followParameters(), tracks, used, follow) == StageStatus::kComplete);
+  const auto proposals = follow.proposals();
+  BOOST_REQUIRE(proposals.size() == 2U);
+  BOOST_TEST(proposals[0].outwardCount == 3U);
+  BOOST_TEST(proposals[1].outwardCount == 0U);
+  const auto view = tracks.view();
+  BOOST_TEST(view.count[0] == kLayers);
+  BOOST_TEST(view.addedOutward[0] == 3U);
+  BOOST_TEST(view.addedInward[0] == 0U);
+  BOOST_TEST(view.count[1] == 5U);
+  BOOST_TEST(view.addedOutward[1] == 0U);
+  for (std::size_t layer = 5U; layer < kLayers; ++layer) {
+    BOOST_TEST(used[fixture.row(layer)] == kExclusive);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(ARejectedRefitLeavesItsRowsFree)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(2.8, -0.01, 1.6);
+  const Fixture fixture{hits};
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  auto tracks = fittedTrack(fixture, 0U, 4U, pool);
+  std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  auto parameters = followParameters();
+  std::ranges::fill(parameters.roadChi2MaxByNdf, -1.F);
+  Follow<Det> follow;
+  follow.setMemoryPool(pool);
+  BOOST_REQUIRE(followAll(fixture, parameters, tracks, used, follow) == StageStatus::kComplete);
+  BOOST_REQUIRE(follow.proposals().size() == 1U);
+  BOOST_TEST(follow.proposals()[0].outwardCount == 0U);
+  BOOST_TEST(tracks.view().count[0] == 5U);
+  for (std::size_t layer = 5U; layer < kLayers; ++layer) {
+    BOOST_TEST(used[fixture.row(layer)] == kFree);
+  }
+}
+
+/// The followed prefix: a refit the cut
+/// refuses for the whole extension keeps its longest accepted prefix with
+/// `followPrefix`, and its rows only are marked; without it, none.
+BOOST_AUTO_TEST_CASE(ARefusedRefitKeepsItsLongestAcceptedPrefix)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(2.8, -0.01, 1.6);
+  const Fixture fixture{hits};
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  for (const bool prefix : {false, true}) {
+    auto tracks = fittedTrack(fixture, 0U, 4U, pool);
+    std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+    auto parameters = followParameters();
+    parameters.followPrefix = prefix;
+    // The track with all three outward rows refused, 2 * 8 - 5 degrees of
+    // freedom; with two of them, and fewer, accepted.
+    parameters.roadChi2MaxByNdf[(2U * kLayers) - static_cast<std::size_t>(kNBoundParams)] = -1.F;
+    Follow<Det> follow;
+    follow.setMemoryPool(pool);
+    BOOST_REQUIRE(followAll(fixture, parameters, tracks, used, follow) == StageStatus::kComplete);
+    BOOST_REQUIRE(follow.proposals().size() == 1U);
+    BOOST_TEST_CONTEXT("followPrefix " << prefix)
+    {
+      const auto view = std::as_const(tracks).view();
+      BOOST_TEST(follow.proposals()[0].outwardCount == (prefix ? 2U : 0U));
+      BOOST_TEST(view.count[0] == (prefix ? 7U : 5U));
+      BOOST_TEST(view.addedOutward[0] == (prefix ? 2U : 0U));
+      for (std::size_t layer = 5U; layer < kLayers; ++layer) {
+        BOOST_TEST(used[fixture.row(layer)] == (prefix && layer < 7U ? kExclusive : kFree));
+      }
+    }
+  }
+}
+
+/// The unconfirmed drop's row is not marked: it stays free after the passes.
+BOOST_AUTO_TEST_CASE(AnUnconfirmedRowStaysFreeAfterThePasses)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(0.42, 0.025, 1.8);
+  const Fixture fixture{hits};
+  std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  for (std::size_t layer = 0; layer <= 4U; ++layer) {
+    used[fixture.row(layer)] = kExclusive;
+  }
+  used[fixture.row(6U)] = kExclusive;
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  auto tracks = fittedTrack(fixture, 0U, 4U, pool);
+  Follow<Det> follow;
+  follow.setMemoryPool(pool);
+  BOOST_REQUIRE(followAll(fixture, followParameters(), tracks, used, follow) == StageStatus::kComplete);
+  BOOST_TEST(std::as_const(tracks).view().count[0] == 5U);
+  BOOST_TEST(used[fixture.row(5U)] == kFree);
+}
+
+/// The trim of an ambiguous last row: a second row within the gate on the outermost layer, 5 um
+/// off the particle's, makes the follow's last row one of two passing. With
+/// a `followTrimMargin` above the gate the row is dropped and left free, the
+/// track refitted one row shorter; it stays with the margin 0 (off), with a
+/// margin below the second row's chi2 less its own, without the second
+/// row, and where the length after the follow would drop the track one row
+/// shorter.
+BOOST_AUTO_TEST_CASE(AnAmbiguousLastRowIsTrimmedWhereTheTrackKeepsItsCuts)
+{
+  using namespace toybarrel8;
+  const auto clean = sensorHelixHits(0.42, 0.025, 1.8);
+  auto ambiguous = clean;
+  Hit other = clean[kLayers - 1U];
+  other.point = moved(other.point, 0.0005, 0.0005);
+  other.loc0 += 0.0005F;
+  other.loc1 += 0.0005F;
+  ambiguous.push_back(other);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto run = [&](const std::vector<Hit>& hits, float margin, std::uint32_t minAfter) {
+    const Fixture fixture{hits};
+    auto tracks = fittedTrack(fixture, 0U, 4U, pool);
+    std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+    auto parameters = followParameters();
+    parameters.followTrimMargin = margin;
+    parameters.minClustersAfterFollow = minAfter;
+    Follow<Det> follow;
+    follow.setMemoryPool(pool);
+    BOOST_REQUIRE(followAll(fixture, parameters, tracks, used, follow) == StageStatus::kComplete);
+    BOOST_REQUIRE(follow.proposals().size() == 1U);
+    const auto view = std::as_const(tracks).view();
+    return std::tuple{static_cast<std::uint32_t>(view.count[0]), static_cast<std::uint32_t>(follow.proposals()[0].outwardCount), static_cast<std::uint32_t>(view.addedOutward[0]), used[fixture.row(kLayers - 1U)]};
+  };
+  const auto [count, outward, added, last] = run(ambiguous, 100.F, 0U);
+  BOOST_TEST(count == kLayers - 1U);
+  BOOST_TEST(outward == 2U);
+  BOOST_TEST(added == 2U);
+  BOOST_TEST(last == kFree);
+  using Case = std::tuple<std::vector<Hit>, float, std::uint32_t>;
+  for (const auto& [hits, margin, minAfter] : {Case{ambiguous, 0.F, 0U}, Case{ambiguous, 1e-6F, 0U}, Case{clean, 100.F, 0U}, Case{ambiguous, 100.F, static_cast<std::uint32_t>(kLayers)}}) {
+    BOOST_TEST_CONTEXT("margin " << margin << ", rows " << hits.size() << ", length after the follow " << minAfter)
+    {
+      const auto [kept, keptOutward, keptAdded, keptLast] = run(hits, margin, minAfter);
+      BOOST_TEST(kept == kLayers);
+      BOOST_TEST(keptOutward == 3U);
+      BOOST_TEST(keptLast == kExclusive);
+    }
+  }
+}
+
+/// The passes add the rows in order -- inward ones first, then the road,
+/// then the outward ones -- count them on the track, after what an earlier
+/// follow added, and mark them.
+BOOST_AUTO_TEST_CASE(TheFollowsPassesAddItsRowsToTheTrackAndMarkThem)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(0.42, 0.025, 1.8);
+  const Fixture fixture{hits};
+  std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  auto tracks = fittedTrack(fixture, 2U, 5U, pool);
+  for (std::size_t layer = 2; layer <= 5U; ++layer) {
+    used[fixture.row(layer)] = kExclusive;
+  }
+  tracks.view().addedOutward[0] = 1U; // an earlier follow's row, kept in the count
+  Follow<Det> follow;
+  follow.setMemoryPool(pool);
+  BOOST_REQUIRE(followAll(fixture, followParameters(), tracks, used, follow) == StageStatus::kComplete);
+  const auto view = std::as_const(tracks).view();
+  BOOST_TEST(view.count[0] == kLayers);
+  BOOST_TEST(view.addedOutward[0] == 3U);
+  BOOST_TEST(view.addedInward[0] == 2U);
+  for (std::size_t layer = 0; layer < kLayers; ++layer) {
+    BOOST_TEST(view.clusters[0].index[layer] == fixture.row(layer));
+    BOOST_TEST(used[fixture.row(layer)] == kExclusive);
+  }
+}
+
+/// The road's end decided again: the particle kinks at
+/// layer 4, its rows 4-7 shifted in r phi by 12, 24, 36 and 48 um; the road
+/// ends on a noise row where its row 4 would have been. Refitted without it,
+/// the follow takes the particle's row 4, which layer 5 confirms, in its
+/// place, and goes on outward.
+BOOST_AUTO_TEST_CASE(TheFollowReplacesARoadEndTheNextLayerRefuses)
+{
+  using namespace toybarrel8;
+  auto hits = sensorHelixHits(1.1, -0.02, 2.2);
+  const Hit noise = hits[4];
+  hits = kinkedBeyond(std::move(hits), 3U, 0.006);
+  hits.push_back(noise);
+  const Fixture fixture{hits};
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto noiseRow = fixture.row(kLayers);
+  auto tracks = fittedRows(fixture, {fixture.row(0U), fixture.row(1U), fixture.row(2U), fixture.row(3U), noiseRow}, pool);
+  std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  for (std::size_t layer = 0; layer <= 3U; ++layer) {
+    used[fixture.row(layer)] = kExclusive;
+  }
+  used[noiseRow] = kExclusive;
+
+  const auto plain = followTrack(fixture, tracks, used, followParameters());
+  BOOST_TEST(plain.replacedEnd == ClusterList<kMaxClusters>::kNoCluster);
+  const auto parameters = followParameters(0, 1., 1, false, true);
+  const auto proposal = followTrack<false, true>(fixture, tracks, used, parameters);
+  BOOST_TEST(proposal.replacedEnd == noiseRow);
+  BOOST_REQUIRE(proposal.outwardCount == 4U);
+  for (std::size_t i = 0; i < 4U; ++i) {
+    BOOST_TEST(proposal.outward[i] == fixture.row(4U + i));
+  }
+
+  Follow<Det> follow;
+  follow.setMemoryPool(pool);
+  BOOST_REQUIRE(followAll(fixture, parameters, tracks, used, follow) == StageStatus::kComplete);
+  const auto view = std::as_const(tracks).view();
+  BOOST_REQUIRE(view.count[0] == kLayers);
+  BOOST_TEST(view.addedOutward[0] == 4U);
+  for (std::size_t layer = 0; layer < kLayers; ++layer) {
+    BOOST_TEST(view.clusters[0].index[layer] == fixture.row(layer));
+    BOOST_TEST(used[fixture.row(layer)] == kExclusive);
+  }
+  BOOST_TEST(used[noiseRow] == kFree);
+}
+
+/// On a clean road the follow takes its end again: the proposal is the
+/// plain follow's, the end kept.
+BOOST_AUTO_TEST_CASE(TheFollowKeepsACleanRoadEnd)
+{
+  using namespace toybarrel8;
+  const auto hits = sensorHelixHits(0.42, 0.025, 1.8);
+  const Fixture fixture{hits};
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto tracks = fittedTrack(fixture, 0U, 4U, pool);
+  std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  for (std::size_t layer = 0; layer <= 4U; ++layer) {
+    used[fixture.row(layer)] = kExclusive;
+  }
+  const auto plain = followTrack(fixture, tracks, used, followParameters());
+  const auto again = followTrack<false, true>(fixture, tracks, used, followParameters(0, 1., 1, false, true));
+  BOOST_TEST(again.replacedEnd == ClusterList<kMaxClusters>::kNoCluster);
+  BOOST_TEST(sameProposal(again, plain));
+}
+
+/// Without the follow, the end alone is decided again: the particle's row
+/// replaces the noise row, nothing beyond it is taken, nothing inward.
+BOOST_AUTO_TEST_CASE(WithoutTheFollowOnlyTheEndIsDecidedAgain)
+{
+  using namespace toybarrel8;
+  auto hits = sensorHelixHits(1.1, -0.02, 2.2);
+  const Hit noise = hits[4];
+  hits = kinkedBeyond(std::move(hits), 3U, 0.006);
+  hits.push_back(noise);
+  const Fixture fixture{hits};
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  const auto noiseRow = fixture.row(kLayers);
+  const auto tracks = fittedRows(fixture, {fixture.row(1U), fixture.row(2U), fixture.row(3U), noiseRow}, pool);
+  const std::vector<std::uint8_t> used(fixture.frame->size(), kFree);
+  auto parameters = followParameters(0, 1., 1, false, true);
+  parameters.follow = false;
+  const auto proposal = followTrack<false, true>(fixture, tracks, used, parameters);
+  BOOST_TEST(proposal.replacedEnd == noiseRow);
+  BOOST_REQUIRE(proposal.outwardCount == 1U);
+  BOOST_TEST(proposal.outward[0] == fixture.row(4U));
+  BOOST_TEST(proposal.inwardCount == 0U);
+}
+
+BOOST_AUTO_TEST_CASE(EverySensorIsListedAtItsCentre)
+{
+  const auto& toy = toybarrel8::trackingGeometry();
+  const SensorCells<toybarrel8::Det> toyCells(toy);
+  for (const auto& surface : toy.surfaces()) {
+    BOOST_TEST(visitedAtItsCentre(toyCells, surface));
+  }
+  using Mixed = detectors::ToyBarrel4Disc8;
+  const auto detector = toyGeometry<Mixed>();
+  const TrackingGeometry<Mixed> mixed{detector};
+  const SensorCells<Mixed> mixedCells(mixed);
+  std::size_t missed = 0U;
+  for (const auto& surface : mixed.surfaces()) {
+    missed += visitedAtItsCentre(mixedCells, surface) ? 0U : 1U;
+  }
+  BOOST_TEST(missed == 0U);
+}
+
+BOOST_AUTO_TEST_CASE(AQueryAtAFootprintsOuterEdgeVisitsItsSensor)
+{
+  // Each layer's outermost footprints in the second coordinate: a query at
+  // their edge, with no reach, visits them; one beyond, none.
+  const auto& toy = toybarrel8::trackingGeometry();
+  const SensorCells<toybarrel8::Det> cells(toy);
+  for (const auto& surface : toy.surfaces()) {
+    const auto footprint = SensorCells<toybarrel8::Det>::footprint(surface, true);
+    const auto phi = static_cast<Scalar>(footprint.phiCentre < 0. ? footprint.phiCentre + (2 * std::numbers::pi_v<double>) : footprint.phiCentre);
+    for (const double edge : {footprint.secondLow, footprint.secondHigh}) {
+      BOOST_TEST(cells.view().anySensor(surface.layer, phi, 0.F, static_cast<Scalar>(edge), 0.F, [&](std::uint32_t id) { return id == surface.id; }));
+    }
+  }
+  const auto& layer = cells.layers()[0];
+  const Scalar beyond = layer.secondLow + (static_cast<Scalar>(layer.nSecond) * layer.secondBin) + 1.F;
+  BOOST_TEST(!cells.view().anySensor(0U, 0.F, std::numbers::pi_v<Scalar>, beyond, 0.F, [](std::uint32_t /*id*/) { return true; }));
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testHostAlgorithms.cxx b/Detectors/GenericTracking/tracking/test/testHostAlgorithms.cxx
new file mode 100644
index 0000000000000..ae2f742b63586
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testHostAlgorithms.cxx
@@ -0,0 +1,159 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testHostAlgorithms.cxx
+/// \brief The host's ordered compaction and exclusive scan against the serial
+///        loops they replace, at one and eight threads and several chunk sizes.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK HostAlgorithms
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Base/HostAlgorithms.h"
+#include "GenericTracking/Tracking/Parallel.h"
+
+#include "SerialReferences.h"
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <cstddef>
+#include <limits>
+#include <memory_resource>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using host_algorithms::Index;
+
+/// body(i) for i in [0, count) on \a arena's threads, one index per task.
+struct ArenaForEach {
+  detail::TaskArena* arena = nullptr;
+  template <typename Body>
+  void operator()(Index count, const Body& body) const
+  {
+    detail::parallelFor(*arena, 0, count, 1, [&](std::size_t first, std::size_t last) {
+      for (std::size_t i = first; i < last; ++i) {
+        body(static_cast<Index>(i));
+      }
+    });
+  }
+};
+
+constexpr std::array<Index, 6> kSizes{0U, 1U, 5U, 256U, 1000U, 100003U};
+constexpr std::array<Index, 4> kChunkSizes{1U, 3U, 256U, 100000U};
+
+/// A pseudo-random bit per index, about one in three set.
+bool scattered(Index i) { return ((i * 2654435761U) >> 7U) % 3U == 0U; }
+
+template <typename ForEach>
+void checkCompaction(const ForEach& forEach)
+{
+  const std::array<bool (*)(Index), 3> predicates{[](Index) { return true; }, [](Index) { return false; }, scattered};
+  for (const Index n : kSizes) {
+    for (const Index chunkSize : kChunkSizes) {
+      for (const auto keep : predicates) {
+        std::vector<Index> expected;
+        for (Index i = 0; i < n; ++i) {
+          if (keep(i)) {
+            expected.push_back(i);
+          }
+        }
+        BoundedVector<Index> out{std::pmr::new_delete_resource()};
+        out.assign(7U, 99U); // stale contents and size are replaced
+        host_algorithms::compactIndices(forEach, n, chunkSize, keep, out);
+        BOOST_TEST_CONTEXT("n " << n << ", chunks of " << chunkSize) { BOOST_TEST(std::vector<Index>(out.begin(), out.end()) == expected, boost::test_tools::per_element()); }
+      }
+    }
+  }
+}
+
+template <typename ForEach>
+void checkScan(const ForEach& forEach)
+{
+  const auto value = [](Index i) { return (i * 7U) % 11U; };
+  for (const Index n : kSizes) {
+    for (const Index chunkSize : kChunkSizes) {
+      std::vector<Index> expected(std::size_t{n} + 1U);
+      Index running = 0U;
+      for (Index i = 0; i < n; ++i) {
+        expected[i] = running;
+        running += value(i);
+      }
+      expected[n] = running;
+      std::vector<Index> offsets(std::size_t{n} + 1U, 12345U);
+      BOOST_TEST_CONTEXT("n " << n << ", chunks of " << chunkSize)
+      {
+        BOOST_TEST(host_algorithms::exclusiveScan(forEach, n, chunkSize, value, offsets, std::pmr::new_delete_resource()));
+        BOOST_TEST(offsets == expected, boost::test_tools::per_element());
+      }
+    }
+  }
+  // A total past the index's range fails, as the serial loop's running check.
+  std::vector<Index> offsets(4U);
+  const auto large = [](Index) { return std::numeric_limits<Index>::max() / 2U; };
+  BOOST_TEST(host_algorithms::exclusiveScan(forEach, 2U, 1U, large, offsets, std::pmr::new_delete_resource()));
+  BOOST_TEST(!host_algorithms::exclusiveScan(forEach, 3U, 1U, large, offsets, std::pmr::new_delete_resource()));
+}
+
+} // namespace
+
+/// Each index of [begin, end) runs exactly once, in grains of at most the
+/// grain size starting at begin plus a multiple of it, with the calling
+/// thread one of the workers.
+BOOST_AUTO_TEST_CASE(ParallelForRunsEachIndexOnce)
+{
+  for (const int threads : {1, 3, 8}) {
+    detail::TaskArena arena{threads};
+    for (const std::size_t begin : {std::size_t{0}, std::size_t{7}}) {
+      for (const std::size_t count : {std::size_t{0}, std::size_t{1}, std::size_t{5}, std::size_t{1000}, std::size_t{100003}}) {
+        for (const std::size_t grain : {std::size_t{1}, std::size_t{3}, std::size_t{64}, std::size_t{200000}}) {
+          std::vector<std::atomic<int>> runs(count);
+          std::atomic<int> badGrains{0};
+          detail::parallelFor(arena, begin, begin + count, grain, [&](std::size_t first, std::size_t last) {
+            if (first >= last || last - first > grain || (first - begin) % grain != 0U) {
+              ++badGrains;
+            }
+            for (std::size_t i = first; i < last; ++i) {
+              ++runs[i - begin];
+            }
+          });
+          BOOST_TEST(badGrains.load() == 0);
+          BOOST_TEST(std::ranges::all_of(runs, [](const std::atomic<int>& run) { return run.load() == 1; }));
+        }
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(CompactionIsTheSerialLoops)
+{
+  checkCompaction(SerialForEach{});
+  detail::TaskArena one{1};
+  checkCompaction(ArenaForEach{&one});
+  detail::TaskArena eight{8};
+  checkCompaction(ArenaForEach{&eight});
+}
+
+BOOST_AUTO_TEST_CASE(ScanIsTheSerialLoops)
+{
+  checkScan(SerialForEach{});
+  detail::TaskArena one{1};
+  checkScan(ArenaForEach{&one});
+  detail::TaskArena eight{8};
+  checkScan(ArenaForEach{&eight});
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testIteration.cxx b/Detectors/GenericTracking/tracking/test/testIteration.cxx
new file mode 100644
index 0000000000000..cad57fddcb244
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testIteration.cxx
@@ -0,0 +1,507 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testIteration.cxx
+/// \brief One iteration's parameters, derived from its settings.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Iteration
+#include <boost/test/unit_test.hpp>
+#include "CommonConstants/LHCConstants.h"
+#include "GridTestSupport.h"
+
+#include "GenericTracking/Study/Validation.h"
+#include "GenericTracking/Base/LayerLinks.h"
+#include "ToyBarrel4Disc8.h"
+#include "ToyBarrel8.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/MeasurementGrid.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/SlicePlan.h"
+
+#include "UniformMaterial.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using detectors::ToyBarrel4Disc8;
+
+/// A pair's transverse and longitudinal terms together, as the tracklet
+/// stage takes them in two halves (`pairCompatible`).
+PairTerms pairTerms(const PairCut& cut, const VertexSeed& vertex, const PairPoint& source, Scalar sourceScatter, const PairPoint& target)
+{
+  const auto pair = pairChord(source, target);
+  auto terms = transversePairTerms(cut, vertex, source, sourceScatter, target, pair, 0.F);
+  addLongitudinalPairTerms(terms, cut, vertex, source, sourceScatter, target, pair, 0.F);
+  return terms;
+}
+
+/// An iteration at \a minPtGeV taking every link: chains of two clusters.
+IterationParameters<ToyBarrel4Disc8> parametersAt(double minPtGeV)
+{
+  IterationSettings settings;
+  settings.minClusters = 2;
+  settings.windows.minPtGeV = minPtGeV;
+  settings.vertexSource = VertexSource::kVertexList;
+  return iterationParameters<ToyBarrel4Disc8>(settings, VertexConstraint{}, scatteringTable<ToyBarrel4Disc8>(uniformLayerMaterial<ToyBarrel4Disc8>(0.01)));
+}
+
+PairPoint helixPoint(double curvature, double arc, double cotTheta, double vertexZ)
+{
+  const double turn = curvature * arc;
+  const double x = std::sin(turn) / curvature;
+  const double y = (1. - std::cos(turn)) / curvature;
+  return {
+    .x = static_cast<Scalar>(x),
+    .y = static_cast<Scalar>(y),
+    .z = static_cast<Scalar>(vertexZ + (cotTheta * arc)),
+    .r = static_cast<Scalar>(std::hypot(x, y)),
+    .varZ = 1.e-4F,
+    .varR = 1.e-6F,
+    .varRPhi = 1.e-6F,
+  };
+}
+
+/// The vertex range the per-vertex intervals are checked over [cm].
+constexpr double kVertexRange = 5.;
+
+/// \a steep puts a barrel source at the end of its stave farthest from the
+/// vertex, where the path factor of the scattering is largest.
+void verifyVertexInterval(double minPtGeV, Scalar vertexZ, LayerID from, LayerID to, bool steep)
+{
+  SearchWindowParams params;
+  params.minPtGeV = minPtGeV;
+  const auto table = scatteringTable<ToyBarrel4Disc8>(uniformLayerMaterial<ToyBarrel4Disc8>(params.materialX2X0));
+  const auto cut = pairCut(params);
+  const VertexSeed vertex{.z = vertexZ, .varZ = 1.e-4F, .varTransverse = 4.e-6F};
+  const auto pair = layerPairWindow<ToyBarrel4Disc8>(from, to, params, VertexConstraint{}, table);
+  const auto bounds = vertexPairWindow<ToyBarrel4Disc8>(from, to, params, {.low = -kVertexRange, .high = kVertexRange}, 0.01, sourceKinkBound<ToyBarrel4Disc8>(table, params, from, VertexConstraint{}));
+
+  const bool sourceBarrel = Detector<ToyBarrel4Disc8>::isBarrelLayer(from);
+  const bool targetBarrel = Detector<ToyBarrel4Disc8>::isBarrelLayer(to);
+  const auto sourceR = static_cast<Scalar>(sourceBarrel ? layerDistance<ToyBarrel4Disc8>(from) : 0.5 * (secondMin<ToyBarrel4Disc8>(from) + secondMax<ToyBarrel4Disc8>(from)));
+  auto sourceZ = static_cast<Scalar>(sourceBarrel ? static_cast<double>(vertexZ) + (0.5 * static_cast<double>(sourceR)) : discZ<ToyBarrel4Disc8>(from));
+  if (sourceBarrel && steep) {
+    sourceZ = static_cast<Scalar>(vertexZ < 0.F ? zMax<ToyBarrel4Disc8>(from) : zMin<ToyBarrel4Disc8>(from));
+  }
+  if (sourceBarrel && !targetBarrel) {
+    const double targetR = 0.5 * (secondMin<ToyBarrel4Disc8>(to) + secondMax<ToyBarrel4Disc8>(to));
+    const auto vertexValue = static_cast<double>(vertexZ);
+    sourceZ = static_cast<Scalar>(vertexValue + (static_cast<double>(sourceR) * (discZ<ToyBarrel4Disc8>(to) - vertexValue) / targetR));
+  }
+  const auto variance = static_cast<Scalar>(params.positionSigma * params.positionSigma);
+  const PairPoint source{.x = sourceR, .z = sourceZ, .r = sourceR, .varZ = variance, .varR = variance, .varRPhi = variance};
+  const Scalar scattering = sourceScattering<ToyBarrel4Disc8>(table, cut, vertex, from, source);
+  const auto interval = vertexSecondRange(pair, bounds, source.r, source.z, vertex.z, vertex.varZ, cut.nSigma);
+
+  std::size_t accepted = 0U;
+  constexpr int kSecondSteps = 400;
+  constexpr int kPhiSteps = 40;
+  const auto sourceRadius = static_cast<double>(sourceR);
+  const auto sourcePositionZ = static_cast<double>(sourceZ);
+  const auto vertexPositionZ = static_cast<double>(vertexZ);
+  const double lineSecond = targetBarrel ? vertexPositionZ + ((sourcePositionZ - vertexPositionZ) * layerDistance<ToyBarrel4Disc8>(to) / sourceRadius) : sourceRadius * (discZ<ToyBarrel4Disc8>(to) - vertexPositionZ) / (sourcePositionZ - vertexPositionZ);
+  for (int secondStep = 0; secondStep <= kSecondSteps + 1; ++secondStep) {
+    const double second = secondStep == kSecondSteps + 1 ? lineSecond : secondMin<ToyBarrel4Disc8>(to) + ((secondMax<ToyBarrel4Disc8>(to) - secondMin<ToyBarrel4Disc8>(to)) * static_cast<double>(secondStep) / kSecondSteps);
+    for (int phiStep = -kPhiSteps; phiStep <= kPhiSteps; ++phiStep) {
+      const auto phi = static_cast<double>(pair.phiHalfWidth) * phiStep / kPhiSteps;
+      const auto targetR = static_cast<Scalar>(targetBarrel ? layerDistance<ToyBarrel4Disc8>(to) : second);
+      const auto targetZ = static_cast<Scalar>(targetBarrel ? second : discZ<ToyBarrel4Disc8>(to));
+      const PairPoint target{
+        .x = targetR * static_cast<Scalar>(std::cos(phi)),
+        .y = targetR * static_cast<Scalar>(std::sin(phi)),
+        .z = targetZ,
+        .r = targetR,
+        .varZ = variance,
+        .varR = variance,
+        .varRPhi = variance,
+      };
+      if (!pairCompatible(cut, vertex, source, scattering, target)) {
+        continue;
+      }
+      ++accepted;
+      BOOST_TEST_CONTEXT("pT " << minPtGeV << " vertex " << vertexZ << " link " << int(from) << " -> " << int(to) << " steep " << steep) { BOOST_TEST(secondRangeContains(interval, static_cast<Scalar>(second))); }
+    }
+  }
+  BOOST_TEST(accepted > 0U, "pT " << minPtGeV << " vertex " << vertexZ << " link " << int(from) << " -> " << int(to));
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(WithoutSkipLinksAnIterationTakesOnlyTheLinksThatSkipNoLayer)
+{
+  IterationSettings settings;
+  settings.minClusters = 2; // every link
+  const auto all = iterationParameters<ToyBarrel4Disc8>(settings, VertexConstraint{}, scatteringTable<ToyBarrel4Disc8>(uniformLayerMaterial<ToyBarrel4Disc8>(0.01)));
+  settings.skipLinks = false;
+  const auto direct = iterationParameters<ToyBarrel4Disc8>(settings, VertexConstraint{}, scatteringTable<ToyBarrel4Disc8>(uniformLayerMaterial<ToyBarrel4Disc8>(0.01)));
+  std::size_t skipping = 0U;
+  for (std::size_t link = 0; link < nLinks<ToyBarrel4Disc8>; ++link) {
+    BOOST_TEST_CONTEXT("link " << link)
+    {
+      BOOST_TEST(study::linkTaken(all, link));
+      BOOST_TEST(study::linkTaken(direct, link) == !ToyBarrel4Disc8::layerLinks[link].skipsLayer);
+      std::size_t in = 0U;
+      const auto target = static_cast<std::size_t>(ToyBarrel4Disc8::layerLinks[link].to);
+      for (auto at = direct.inLinkOffsets[target]; at < direct.inLinkOffsets[target + 1U]; ++at) {
+        in += direct.inLinkIndices[at] == link ? 1U : 0U;
+      }
+      BOOST_TEST(in == (ToyBarrel4Disc8::layerLinks[link].skipsLayer ? 0U : 1U));
+    }
+    skipping += ToyBarrel4Disc8::layerLinks[link].skipsLayer ? 1U : 0U;
+  }
+  BOOST_TEST(skipping > 0U);
+  BOOST_TEST(direct.outLinkOffsets[IterationParameters<ToyBarrel4Disc8>::kLayerCount] == nLinks<ToyBarrel4Disc8> - skipping);
+}
+
+BOOST_AUTO_TEST_CASE(PerVertexIntervalsContainEveryAcceptedPair)
+{
+  struct Case {
+    LayerID from;
+    LayerID to;
+  };
+  constexpr std::array<Case, 3> cases{{{.from = 2, .to = 3}, {.from = 8, .to = 9}, {.from = 0, .to = 8}}};
+  for (const double pt : {0.1, 1.}) {
+    for (const auto vertex : {static_cast<Scalar>(-kVertexRange), static_cast<Scalar>(kVertexRange)}) {
+      for (const auto& pair : cases) {
+        for (const bool steep : {false, true}) {
+          verifyVertexInterval(pt, vertex, pair.from, pair.to, steep);
+        }
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(PerVertexIntervalUsesThatVertexSigma)
+{
+  const SearchWindowParams params;
+  constexpr LayerID kSource = 2;
+  constexpr LayerID kTarget = 3;
+  const auto pair = layerPairWindow<ToyBarrel4Disc8>(kSource, kTarget, params, VertexConstraint{});
+  const auto bounds = vertexPairWindow<ToyBarrel4Disc8>(kSource, kTarget, params, {.low = -kVertexRange, .high = kVertexRange}, 0.1, uniformSourceKink(params));
+  const auto sourceR = static_cast<Scalar>(layerDistance<ToyBarrel4Disc8>(kSource));
+  const auto narrow = vertexSecondRange(pair, bounds, sourceR, 10.F, 0.F, 1.e-4F, static_cast<Scalar>(params.nSigma));
+  const auto wide = vertexSecondRange(pair, bounds, sourceR, 10.F, 0.F, 1.e-2F, static_cast<Scalar>(params.nSigma));
+  BOOST_TEST(wide.halfWidth > narrow.halfWidth);
+}
+
+BOOST_AUTO_TEST_CASE(ALooserIterationOpensEveryWindow)
+{
+  const auto tight = parametersAt(1.);
+  const auto loose = parametersAt(0.1);
+  BOOST_TEST(loose.pairCut.twoRMin < tight.pairCut.twoRMin);
+  BOOST_TEST(loose.pairCut.invBetaMomentum2 > tight.pairCut.invBetaMomentum2);
+  for (std::size_t link = 0; link < nLinks<ToyBarrel4Disc8>; ++link) {
+    BOOST_TEST(loose.windows[link].phiHalfWidth >= tight.windows[link].phiHalfWidth, "link " << link);
+    BOOST_TEST(loose.windows[link].secondHalfWidth >= tight.windows[link].secondHalfWidth, "link " << link);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(TheBeamLineIsCompatibleWithEveryTime)
+{
+  const auto seed = vertexSeed(VertexConstraint{.z = 1.5, .sigmaZ = 6., .sigmaTransverse = 0.002});
+  const TimeEstPS box{.start = seed.timePS, .width = seed.widthPS};
+  BOOST_TEST(vertexTimeCompatible(TimeEstPS{.start = 0U, .width = 1U}, box));
+  BOOST_TEST(vertexTimeCompatible(TimeEstPS{.start = std::numeric_limits<std::uint32_t>::max() - 1U, .width = 1U}, box));
+}
+
+namespace
+{
+
+/// A grid of ToyBarrel8's eight layers in a chain, with \a frames per layer.
+GridGeometry<detectors::ToyBarrel8> chainGrid(const std::array<FrameTiming, 8>& frames)
+{
+  GridParams params;
+  std::ranges::copy(frames, std::begin(params.frames));
+  const std::vector<GridLayerWindow> windows(8U);
+  return {psOfBC(o2::constants::lhc::LHCMaxBunches), params, windows};
+}
+
+/// Bounds with every layer's widest box \a widthPS[layer] and the rows of
+/// every layer exactly its frames.
+HaloBounds<detectors::ToyBarrel8> framedBounds(const std::array<std::uint32_t, 8>& widthPS)
+{
+  HaloBounds<detectors::ToyBarrel8> bounds;
+  bounds.widthPS = widthPS;
+  bounds.rowsAreFrames.fill(true);
+  return bounds;
+}
+
+} // namespace
+
+/// Rows that are not their frames, the same widths on every layer: each link
+/// reaches that width both ways, `R+ = R-` one width per link of the longest
+/// chain, the gate `2R`, and the halo one link more for the targets of the
+/// tracklets starting at the gate's edge.
+BOOST_AUTO_TEST_CASE(RowsNotTheirFramesReachTheWiderBox)
+{
+  constexpr std::uint32_t kWidthPS = test::kToyBoxWidthPS;
+  std::array<std::uint32_t, 8> widths{};
+  widths.fill(kWidthPS);
+  auto bounds = framedBounds(widths);
+  bounds.rowsAreFrames.fill(false);
+  std::array<FrameTiming, 8> frames{};
+  frames.fill(test::kToyFrames);
+  const auto reach = sliceReach(bounds, chainGrid(frames));
+  const std::int64_t chain = static_cast<std::int64_t>(maxChainLayers<detectors::ToyBarrel8> - 1) * kWidthPS;
+  BOOST_TEST(reach.pairForwardPS == kWidthPS);
+  BOOST_TEST(reach.pairBackwardPS == kWidthPS);
+  BOOST_TEST(reach.forwardPS == chain);
+  BOOST_TEST(reach.backwardPS == chain);
+  BOOST_TEST(reach.gatePS() == 2 * chain);
+  BOOST_TEST(reach.haloPS() == (2 * chain) + kWidthPS);
+}
+
+/// Layers whose rows are their frames, and whose frames are the same, hold a
+/// pair in one frame: only the link between the 22-BC and the 81-BC layers
+/// reaches, 22 BC forward and 81 BC
+/// backward.
+BOOST_AUTO_TEST_CASE(LayersSharingFramesDoNotReach)
+{
+  constexpr FrameTiming kShort{.lengthBC = 22, .firstStartBC = 0};
+  constexpr FrameTiming kLong{.lengthBC = 81, .firstStartBC = 0};
+  const auto shortPS = static_cast<std::uint32_t>(psOfBC(22));
+  const auto longPS = static_cast<std::uint32_t>(psOfBC(81));
+  const auto grid = chainGrid({kShort, kShort, kShort, kLong, kLong, kLong, kLong, kLong});
+  const std::array<std::uint32_t, 8> widths{shortPS, shortPS, shortPS, longPS, longPS, longPS, longPS, longPS};
+  const auto reach = sliceReach(framedBounds(widths), grid);
+  BOOST_TEST(reach.pairForwardPS == shortPS);
+  BOOST_TEST(reach.pairBackwardPS == longPS);
+  BOOST_TEST(reach.forwardPS == shortPS);
+  BOOST_TEST(reach.backwardPS == longPS);
+  BOOST_TEST(reach.gatePS() == std::int64_t{shortPS} + longPS);
+  BOOST_TEST(reach.haloPS() == std::int64_t{shortPS} + (2 * std::int64_t{longPS}));
+
+  // The same frames one BC later on layer 5: its two links reach.
+  auto shifted = chainGrid({kShort, kShort, kShort, kLong, kLong, {.lengthBC = 81, .firstStartBC = 1}, kLong, kLong});
+  const auto shiftedReach = sliceReach(framedBounds(widths), shifted);
+  BOOST_TEST(shiftedReach.forwardPS == std::int64_t{shortPS} + (2 * std::int64_t{longPS}));
+  BOOST_TEST(shiftedReach.backwardPS == 3 * std::int64_t{longPS});
+}
+
+/// A layer whose rows are not exactly its frames -- widened by a margin the
+/// producer applied, whatever the configuration says now -- reaches on both
+/// of its links.
+BOOST_AUTO_TEST_CASE(RowsThatAreNotTheirFramesReach)
+{
+  constexpr FrameTiming kLong{.lengthBC = 81, .firstStartBC = 0};
+  const auto widePS = static_cast<std::uint32_t>(psOfBC(81 + 60));
+  std::array<FrameTiming, 8> frames{};
+  frames.fill(kLong);
+  std::array<std::uint32_t, 8> widths{};
+  widths.fill(widePS);
+  auto bounds = framedBounds(widths);
+  BOOST_TEST(sliceReach(bounds, chainGrid(frames)).gatePS() == 0);
+  bounds.rowsAreFrames[5] = false;
+  const auto reach = sliceReach(bounds, chainGrid(frames));
+  BOOST_TEST(reach.pairForwardPS == widePS);
+  BOOST_TEST(reach.pairBackwardPS == widePS);
+  BOOST_TEST(reach.forwardPS == 2 * std::int64_t{widePS});
+  BOOST_TEST(reach.backwardPS == 2 * std::int64_t{widePS});
+}
+
+BOOST_AUTO_TEST_CASE(TheLongitudinalCutFollowsTheHelixArc)
+{
+  constexpr double kVertexZ = 0.7;
+  constexpr double kCotTheta = 0.8;
+  constexpr double kCurvature = 0.006;
+  constexpr Scalar kNSigma = 3.F;
+  const VertexSeed vertex{.z = static_cast<Scalar>(kVertexZ)};
+  const PairCut cut{.twoRMin = 300.F, .nSigma = kNSigma, .maxCurvature = 2.F / 300.F};
+
+  for (const double charge : {-1., 1.}) {
+    const auto source = helixPoint(charge * kCurvature, 50., kCotTheta, kVertexZ);
+    auto target = helixPoint(charge * kCurvature, 105., kCotTheta, kVertexZ);
+    const auto terms = pairTerms(cut, vertex, source, 0.F, target);
+    BOOST_TEST(transverseCompatible(cut, terms));
+    BOOST_TEST(longitudinalCompatible(cut, terms));
+    BOOST_TEST(pairCompatible(cut, vertex, source, 0.F, target));
+
+    const Scalar dzSource = source.z - vertex.z;
+    const Scalar dzTarget = target.z - vertex.z;
+    const Scalar radialResidual = (source.r * dzTarget) - (target.r * dzSource);
+    const Scalar radialVariance = (dzTarget * dzTarget * source.varR) + (target.r * target.r * source.varZ) + (dzSource * dzSource * target.varR) + (source.r * source.r * target.varZ);
+    BOOST_TEST(radialResidual * radialResidual > kNSigma * kNSigma * radialVariance);
+
+    target.z += 0.2F;
+    BOOST_TEST(!pairCompatible(cut, vertex, source, 0.F, target));
+  }
+}
+
+BOOST_AUTO_TEST_CASE(TheSecondCoordinateWindowCoversHelixPitch)
+{
+  SearchWindowParams params;
+  params.minPtGeV = 1.;
+  const VertexConstraint vertex{.sigmaZ = 0.01};
+  constexpr LayerID kSourceLayer = 2;
+  constexpr LayerID kTargetLayer = 3;
+  const double sourceRadius = layerDistance<ToyBarrel4Disc8>(kSourceLayer);
+  const double targetRadius = layerDistance<ToyBarrel4Disc8>(kTargetLayer);
+  const double curvature = 1. / curvatureRadius(params.minPtGeV, params.bzKiloGauss);
+  const double sourceArc = transverseArcAtRadius(curvature, sourceRadius);
+  const double targetArc = transverseArcAtRadius(curvature, targetRadius);
+  constexpr double kSourceZ = 12.;
+  const double targetZ = kSourceZ * targetArc / sourceArc;
+  const double sourcePhi = std::asin(0.5 * curvature * sourceRadius);
+  const double targetPhi = std::asin(0.5 * curvature * targetRadius);
+
+  const auto pair = layerPairWindow<ToyBarrel4Disc8>(kSourceLayer, kTargetLayer, params, vertex);
+  const auto window = candidateWindow(pair, TimeEstPS{.start = 0U, .width = 1U}, static_cast<Scalar>(sourcePhi), static_cast<Scalar>(sourceRadius), static_cast<Scalar>(kSourceZ), 1U);
+  BOOST_TEST(helixSecondSpread<ToyBarrel4Disc8>(kSourceLayer, kTargetLayer, params, vertex) > 0.);
+  BOOST_TEST(spatiallyCompatible(window, static_cast<Scalar>(targetPhi), static_cast<Scalar>(targetZ)));
+}
+
+/// Two disc points at one radius, 30 cm apart in z: no track from the
+/// vertex does that above 1 GeV, but with a radial error of centimetres the
+/// chord is unresolved and the circle through them reaches curvature 2/r. The
+/// cut holds the curvature to pT_min's, where the pitch test still has a
+/// finite error and rejects the pair; a helix between the same discs passes.
+BOOST_AUTO_TEST_CASE(AnUnresolvedDiscChordDoesNotPassTheLongitudinalCut)
+{
+  SearchWindowParams params;
+  params.minPtGeV = 1.;
+  const auto cut = pairCut(params);
+  const VertexSeed vertex{.varZ = 1.e-4F};
+  constexpr Scalar kRadius = 87.F;
+  constexpr Scalar kVarR = 1.F;
+  const PairPoint source{.x = kRadius, .z = 130.F, .r = kRadius, .varZ = 1.e-4F, .varR = kVarR, .varRPhi = 1.e-4F};
+  const PairPoint sameRadius{.x = kRadius, .y = 0.01F, .z = 160.F, .r = kRadius, .varZ = 1.e-4F, .varR = kVarR, .varRPhi = 1.e-4F};
+
+  const auto terms = pairTerms(cut, vertex, source, 0.F, sameRadius);
+  BOOST_TEST(transverseCompatible(cut, terms));
+  BOOST_TEST(std::isfinite(terms.varCollinearity));
+  BOOST_TEST(!longitudinalCompatible(cut, terms));
+
+  const double curvature = 0.5 / curvatureRadius(params.minPtGeV, params.bzKiloGauss);
+  const double sourceArc = 2. * std::asin(0.5 * curvature * static_cast<double>(kRadius)) / curvature;
+  const double cotTheta = 130. / sourceArc;
+  const auto helixSource = helixPoint(curvature, sourceArc, cotTheta, 0.);
+  const auto helixTarget = helixPoint(curvature, 160. / cotTheta, cotTheta, 0.);
+  BOOST_TEST(pairCompatible(cut, vertex, helixSource, 0.F, helixTarget));
+}
+
+/// The phi window holds the widest azimuth the transverse test accepts, for a
+/// steep source at the end of its layer and the vertex at the far end of its
+/// range, where the scattering sum's path factor is largest.
+BOOST_AUTO_TEST_CASE(ThePhiWindowHoldsTheTransverseTest)
+{
+  const auto table = scatteringTable<ToyBarrel4Disc8>(uniformLayerMaterial<ToyBarrel4Disc8>(0.02));
+  const VertexConstraint beamSpot{};
+  struct Case {
+    LayerID from;
+    LayerID to;
+  };
+  for (const double pt : {0.1, 1.}) {
+    SearchWindowParams params;
+    params.minPtGeV = pt;
+    const auto cut = pairCut(params);
+    for (const auto [from, to] : {Case{.from = 0, .to = 1}, Case{.from = 1, .to = 2}, Case{.from = 2, .to = 3}, Case{.from = 6, .to = 5}, Case{.from = 0, .to = 8}}) {
+      const auto window = layerPairWindow<ToyBarrel4Disc8>(from, to, params, beamSpot, table);
+      const double reach = params.nSigma * beamSpot.sigmaZ;
+      const VertexSeed vertex{.z = static_cast<Scalar>(-reach), .varTransverse = 4.e-6F};
+      const bool barrelSource = Detector<ToyBarrel4Disc8>::isBarrelLayer(from);
+      const auto sourceR = static_cast<Scalar>(radiusMin<ToyBarrel4Disc8>(from));
+      const auto sourceZ = static_cast<Scalar>(barrelSource ? zMax<ToyBarrel4Disc8>(from) : zMin<ToyBarrel4Disc8>(from));
+      // Between two discs the target radius follows the seed's through the z ratio.
+      const double rho = (zMin<ToyBarrel4Disc8>(to) + reach) / (static_cast<double>(sourceZ) + reach);
+      const auto targetR = static_cast<Scalar>(Detector<ToyBarrel4Disc8>::isBarrelLayer(from) || Detector<ToyBarrel4Disc8>::isBarrelLayer(to) ? radiusMax<ToyBarrel4Disc8>(to) : rho * static_cast<double>(sourceR));
+      const auto variance = static_cast<Scalar>(params.positionSigma * params.positionSigma);
+      const PairPoint source{.x = sourceR, .z = sourceZ, .r = sourceR, .varRPhi = variance};
+      const Scalar scatter = sourceScattering<ToyBarrel4Disc8>(table, cut, vertex, from, source);
+      double widest = 0.;
+      constexpr int kSteps = 15000;
+      for (int step = 0; step < kSteps; ++step) {
+        const double phi = 1.e-4 * step;
+        const PairPoint target{
+          .x = targetR * static_cast<Scalar>(std::cos(phi)),
+          .y = targetR * static_cast<Scalar>(std::sin(phi)),
+          .r = targetR,
+          .varRPhi = variance,
+        };
+        if (transverseCompatible(cut, transversePairTerms(cut, vertex, source, scatter, target))) {
+          widest = phi;
+        }
+      }
+      BOOST_TEST_CONTEXT("pT " << pt << " link " << int(from) << " -> " << int(to))
+      {
+        BOOST_TEST(widest > 0.);
+        BOOST_TEST(widest <= static_cast<double>(window.phiHalfWidth));
+      }
+    }
+  }
+}
+
+/// A looper's two legs are found separately: a pair with the circle's turning
+/// point between its measurements fails, though its curvature is allowed.
+BOOST_AUTO_TEST_CASE(APairDoesNotSpanATurningPoint)
+{
+  SearchWindowParams params;
+  params.minPtGeV = 0.1;
+  const auto cut = pairCut(params);
+  const VertexSeed vertex{};
+  constexpr double kCurvature = 0.05; // above pT_min, R = 20 cm
+  const auto source = helixPoint(kCurvature, 0.5 / kCurvature, 0., 0.);
+  const auto outgoing = helixPoint(kCurvature, 2.5 / kCurvature, 0., 0.);
+  const auto returning = helixPoint(kCurvature, 4. / kCurvature, 0., 0.);
+  BOOST_TEST(returning.r > source.r);
+  BOOST_TEST(transverseCompatible(cut, transversePairTerms(cut, vertex, source, 0.F, outgoing)));
+  BOOST_TEST(!transverseCompatible(cut, transversePairTerms(cut, vertex, source, 0.F, returning)));
+}
+
+/// A vertex's box meets the measurement's, as in
+/// O2's `isVertexCompatible`, its end inclusive -- a point vertex at a box's
+/// start belongs to the box, one at its end to the next.
+BOOST_AUTO_TEST_CASE(AVertexBelongsToTheBoxItMeets)
+{
+  const TimeEstPS frame{.start = 1000U, .width = 1000U};
+  BOOST_TEST(vertexTimeCompatible(frame, TimeEstPS{.start = 1000U, .width = 0U}));
+  BOOST_TEST(vertexTimeCompatible(frame, TimeEstPS{.start = 1999U, .width = 0U}));
+  BOOST_TEST(!vertexTimeCompatible(frame, TimeEstPS{.start = 2000U, .width = 0U}));
+  BOOST_TEST(!vertexTimeCompatible(frame, TimeEstPS{.start = 999U, .width = 0U}));
+  // A found vertex's box spanning the edge belongs to both frames.
+  BOOST_TEST(vertexTimeCompatible(frame, TimeEstPS{.start = 1900U, .width = 200U}));
+  BOOST_TEST(vertexTimeCompatible(TimeEstPS{.start = 2000U, .width = 1000U}, TimeEstPS{.start = 1900U, .width = 200U}));
+  BOOST_TEST(vertexTimeCompatible(frame, TimeEstPS{.start = 500U, .width = 500U}));
+}
+
+/// A point time -- a vertex -- in the picosecond two touching frames may
+/// leave between them lies in neither: containment is quantised to 1 ps.
+BOOST_AUTO_TEST_CASE(APointInTheGapBetweenFramesLiesInNeither)
+{
+  constexpr std::int64_t kGapFrameBC = 198;
+  std::int64_t gaps = 0;
+  for (std::int64_t k = 0; k < 600; ++k) {
+    const auto box = frameBox(k * kGapFrameBC, (k + 1) * kGapFrameBC, 0);
+    const auto next = frameBox((k + 1) * kGapFrameBC, (k + 2) * kGapFrameBC, 0);
+    if (next.lower() == box.upper()) {
+      continue;
+    }
+    ++gaps;
+    const TimeEstPS point{.start = box.upper(), .width = 0U};
+    BOOST_TEST(!vertexTimeCompatible(box, point));
+    BOOST_TEST(!vertexTimeCompatible(next, point));
+  }
+  BOOST_TEST(gaps > 0);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testIterations.cxx b/Detectors/GenericTracking/tracking/test/testIterations.cxx
new file mode 100644
index 0000000000000..a0f3d969001ba
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testIterations.cxx
@@ -0,0 +1,798 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testIterations.cxx
+/// \brief The timeframe's tracking, iteration after iteration over every
+///        slice, the selection between them and the refit: each track found
+///        once, by the iteration it belongs to, whatever the slicing.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Iterations
+#include <boost/test/unit_test.hpp>
+#include "CommonConstants/LHCConstants.h"
+#include <numbers>
+
+#include "GenericTracking/Study/Digest.h"
+#include "GenericTracking/Tracking/Material.h"
+#include "GenericTracking/Tracking/SlicePlan.h"
+#include "GenericTracking/Tracking/Tracker.h"
+
+#include "ToyBarrel8Fixture.h"
+#include "UniformMaterial.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <stdexcept>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using namespace toybarrel8;
+
+/// Twelve tracks over 1.1 us: the even ones stiff, 2 to 3 GeV, the odd ones
+/// soft, 0.4 to 0.7 GeV -- below the first iteration's 1 GeV, above the
+/// second's 0.3.
+constexpr std::size_t kTracks = 12U;
+constexpr double kDurationNS = 1100.;
+
+bool stiff(std::size_t track) { return track % 2U == 0U; }
+
+std::vector<Hit> hits()
+{
+  std::vector<Hit> result;
+  for (std::size_t track = 0; track < kTracks; ++track) {
+    const auto k = static_cast<double>(track);
+    const double pt = stiff(track) ? 2. + (0.2 * static_cast<double>(track % 5U)) : 0.4 + (0.06 * static_cast<double>(track % 5U));
+    const auto one = sensorHelixHits(std::fmod(0.3 + (0.9 * k), 2 * std::numbers::pi_v<double>), 0.03 * std::cos(1.3 * k), pt, 37. + (83. * k));
+    BOOST_REQUIRE(one.size() == kLayers);
+    result.insert(result.end(), one.begin(), one.end());
+  }
+  return result;
+}
+
+std::vector<IterationSettings> iterations()
+{
+  auto first = iterationSettings();
+  auto second = iterationSettings();
+  second.windows.minPtGeV = 0.3;
+  return {first, second};
+}
+
+/// A track as the test compares it: its iteration, its rows and its chi2's
+/// bits.
+struct Found {
+  std::uint8_t iteration = 0U;
+  std::vector<std::uint32_t> rows;
+  std::uint32_t chi2 = 0U;
+  bool operator==(const Found&) const = default;
+};
+
+struct Outcome {
+  std::vector<Found> tracks;
+  std::vector<std::uint8_t> used;
+  std::vector<std::size_t> records;
+};
+
+auto rows(const std::vector<Found>& tracks)
+{
+  std::vector<std::vector<std::uint32_t>> result;
+  result.reserve(tracks.size());
+  for (const auto& track : tracks) {
+    result.push_back(track.rows);
+  }
+  std::ranges::sort(result);
+  return result;
+}
+
+std::unique_ptr<Tracker<Det, UniformMaterial>> makeTracker(std::vector<IterationSettings> settings, bool follow = true, std::uint32_t shared = 0U, int threads = 1)
+{
+  for (auto& iteration : settings) {
+    iteration.follow = follow;
+    iteration.sharedInnermost = shared;
+  }
+  const std::array<double, kLayers> material{};
+  static const UniformMaterial none{};
+  auto tracker = std::make_unique<Tracker<Det, UniformMaterial>>(settings, Fixture::kBeamConstraint, scatteringTable<Det>(material), std::make_shared<BoundedMemoryResource>(), 2U, threads);
+  tracker->setTrackModel(trackingGeometry(), none, Propagator{});
+  return tracker;
+}
+
+std::vector<Found> found(const Tracker<Det, UniformMaterial>::TimeframeResult& result)
+{
+  std::vector<Found> tracks;
+  tracks.reserve(result.tracks->size());
+  const auto view = result.tracks->view();
+  for (std::size_t i = 0; i < result.tracks->size(); ++i) {
+    tracks.push_back({
+      .iteration = view.iteration[i],
+      .rows = {view.clusters[i].index, view.clusters[i].index + view.count[i]},
+      .chi2 = std::bit_cast<std::uint32_t>(view.chi2[i]),
+    });
+  }
+  return tracks;
+}
+
+Outcome track(const Fixture& fixture, std::int32_t widthBlocks, int threads)
+{
+  auto owned = makeTracker(iterations(), false, 0U, threads);
+  auto& tracker = *owned;
+  const auto result = tracker.run(*fixture.frame, tracker.planTimeframe(*fixture.frame, {}, widthBlocks, 0.));
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  BOOST_REQUIRE(result.tracks != nullptr);
+  Outcome outcome;
+  for (const auto& summary : result.iterations) {
+    BOOST_TEST(summary.mismatches == 0U);
+    BOOST_TEST(summary.tracksFollowed == 0U);
+    BOOST_TEST(summary.clustersFollowedOutward == 0U);
+    BOOST_TEST(summary.clustersFollowedInward == 0U);
+    outcome.records.push_back(summary.records);
+  }
+  outcome.tracks = found(result);
+  outcome.used.assign(tracker.used().begin(), tracker.used().end());
+  return outcome;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(EachIterationFindsItsTracksOnce)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const auto whole = track(fixture, fixture.geometry.blockCount(), 1);
+  BOOST_REQUIRE(whole.tracks.size() == kTracks);
+  std::vector<bool> found(kTracks, false);
+  for (const auto& t : whole.tracks) {
+    BOOST_REQUIRE(t.rows.size() == kLayers);
+    const auto index = fixture.frame->measurement(t.rows.front()).clusterIndex / kLayers;
+    BOOST_TEST_CONTEXT("track " << index)
+    {
+      // The stiff tracks by the first iteration, the soft ones by the second,
+      // each whole and once.
+      BOOST_TEST(t.iteration == (stiff(index) ? 0U : 1U));
+      BOOST_TEST(!found[index]);
+      for (std::size_t layer = 0; layer < kLayers; ++layer) {
+        BOOST_TEST(t.rows[layer] == fixture.row((kLayers * index) + layer));
+      }
+    }
+    found[index] = true;
+  }
+  // The first iteration's rows are exclusive when the second runs: it fits
+  // only the soft tracks' roads.
+  BOOST_TEST(whole.records[0] == kTracks / 2U);
+  BOOST_TEST(whole.records[1] == kTracks / 2U);
+  BOOST_TEST(std::ranges::all_of(whole.used, [](std::uint8_t state) { return state == kExclusive; }));
+}
+
+/// A bounded pool ends a run with kOutOfMemory wherever it runs out -- never
+/// with an exception out of `run` -- and leaves a tracker that runs again and
+/// gives back every byte when it goes. Every
+/// limit from a few bytes to a whole run's peak, in steps finer than the
+/// stages' staging, so that each allocation of a run is the one refused at
+/// some limit: the road fit's and the selection's setup included.
+BOOST_AUTO_TEST_CASE(AnyMemoryLimitEndsARunWithAStatus)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const std::array<double, kLayers> material{};
+  const UniformMaterial none{};
+  constexpr std::int32_t kWidth = 3;
+  const auto runOn = [&](const std::shared_ptr<BoundedMemoryResource>& pool, int threads, std::vector<StageStatus>& statuses) {
+    Tracker<Det, UniformMaterial> tracker{iterations(), Fixture::kBeamConstraint, scatteringTable<Det>(material), pool, 2U, threads};
+    tracker.setTrackModel(trackingGeometry(), none, Propagator{});
+    for (int run = 0; run < 2; ++run) {
+      Tracker<Det, UniformMaterial>::TimeframeResult result;
+      BOOST_CHECK_NO_THROW(result = tracker.run(*fixture.frame, tracker.planTimeframe(*fixture.frame, {}, kWidth, 0.)));
+      statuses.push_back(result.status);
+    }
+  };
+  std::size_t peak = 0U;
+  {
+    const auto unbounded = std::make_shared<BoundedMemoryResource>();
+    std::vector<StageStatus> statuses;
+    runOn(unbounded, 1, statuses);
+    BOOST_REQUIRE((statuses == std::vector<StageStatus>{StageStatus::kComplete, StageStatus::kComplete}));
+    BOOST_TEST(unbounded->getUsedMemory() == 0U);
+    peak = unbounded->getPeakMemory();
+  }
+  BOOST_REQUIRE(peak > 0U);
+  constexpr std::size_t kSteps = 1000U;
+  std::size_t failed = 0U;
+  for (std::size_t step = 0; step <= kSteps; ++step) {
+    const std::size_t limit = 1U + (peak * step / kSteps);
+    for (const int threads : {1, 3}) {
+      const auto bounded = std::make_shared<BoundedMemoryResource>(limit);
+      std::vector<StageStatus> statuses;
+      runOn(bounded, threads, statuses);
+      BOOST_TEST_CONTEXT("limit " << limit << " of " << peak << " bytes, " << threads << " threads")
+      {
+        for (const auto status : statuses) {
+          BOOST_TEST((status == StageStatus::kComplete || status == StageStatus::kOutOfMemory));
+          failed += status == StageStatus::kOutOfMemory ? 1U : 0U;
+        }
+        BOOST_TEST(bounded->getUsedMemory() == 0U);
+      }
+    }
+  }
+  BOOST_TEST(failed != 0U);
+}
+
+BOOST_AUTO_TEST_CASE(TheTracksDoNotDependOnTheSlicingOrTheThreads)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const auto whole = track(fixture, fixture.geometry.blockCount(), 1);
+  for (const std::int32_t width : {1, 2, 3, 7}) {
+    for (const int threads : {1, 4}) {
+      const auto sliced = track(fixture, width, threads);
+      BOOST_TEST_CONTEXT("slices of " << width << " blocks, " << threads << " threads")
+      {
+        BOOST_TEST((sliced.tracks == whole.tracks));
+        BOOST_TEST(sliced.used == whole.used, boost::test_tools::per_element());
+      }
+    }
+  }
+}
+
+/// The observer sees every slice of every iteration once, completed, with the
+/// used mask it read: all free in the first iteration, the first iteration's
+/// tracks exclusive in the second. Observing changes nothing.
+BOOST_AUTO_TEST_CASE(TheSliceObserverSeesEverySliceWithItsUsedMask)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  constexpr std::int32_t kWidth = 3;
+  const auto unobserved = track(fixture, kWidth, 1);
+
+  const std::array<double, kLayers> material{};
+  Tracker<Det, UniformMaterial> tracker{iterations(), Fixture::kBeamConstraint, scatteringTable<Det>(material), std::make_shared<BoundedMemoryResource>(), 2U, 1};
+  const UniformMaterial none{};
+  tracker.setTrackModel(trackingGeometry(), none, Propagator{});
+  std::vector<std::size_t> slicesPerIteration(2U, 0U);
+  std::vector<std::size_t> exclusivePerIteration(2U, 0U);
+  std::vector<std::size_t> recordsPerIteration(2U, 0U);
+  std::int32_t nextBlock = 0;
+  tracker.setSliceObserver([&](const Tracker<Det, UniformMaterial>& observed, const Tracker<Det, UniformMaterial>::SliceObservation& slice) {
+    BOOST_TEST(&observed == &tracker);
+    BOOST_REQUIRE(slice.iteration < 2U);
+    BOOST_TEST(slice.frame == fixture.frame.get());
+    BOOST_TEST((slice.result->status == StageStatus::kComplete));
+    BOOST_TEST(slice.result->tracklets != nullptr);
+    // After the roads: the slice's road counts and records are there.
+    BOOST_REQUIRE(slice.roads != nullptr);
+    BOOST_REQUIRE(slice.records != nullptr);
+    BOOST_TEST(slice.roads->roads().size() == slice.result->triplets->size());
+    BOOST_TEST(slice.records->elementCount() == slice.roads->roadCount());
+    recordsPerIteration[slice.iteration] += slice.records->size();
+    BOOST_TEST(slice.slice->coreBlocks.begin == nextBlock);
+    nextBlock = slice.slice->coreBlocks.end == fixture.geometry.blockCount() ? 0 : slice.slice->coreBlocks.end;
+    ++slicesPerIteration[slice.iteration];
+    exclusivePerIteration[slice.iteration] = static_cast<std::size_t>(std::ranges::count(observed.used(), std::uint8_t{kExclusive}));
+  });
+  const auto result = tracker.run(*fixture.frame, tracker.planTimeframe(*fixture.frame, {}, kWidth, 0.));
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  const auto slices = static_cast<std::size_t>((fixture.geometry.blockCount() + kWidth - 1) / kWidth);
+  BOOST_TEST(slicesPerIteration[0] == slices);
+  BOOST_TEST(slicesPerIteration[1] == slices);
+  BOOST_TEST(exclusivePerIteration[0] == 0U);
+  BOOST_TEST(exclusivePerIteration[1] == (kTracks / 2U) * kLayers);
+  BOOST_TEST((found(result) == unobserved.tracks));
+  BOOST_TEST(recordsPerIteration[0] > 0U);
+  BOOST_TEST(recordsPerIteration[0] == result.iterations[0].records);
+  BOOST_TEST(recordsPerIteration[1] == result.iterations[1].records);
+}
+
+/// The iteration observer sees every iteration once, completed: its
+/// selection holds every slice's records in slice order, and what it
+/// accepted; the used mask is the one the selection and follow left.
+BOOST_AUTO_TEST_CASE(TheIterationObserverSeesEveryIterationsSelection)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const std::array<double, kLayers> material{};
+  Tracker<Det, UniformMaterial> tracker{iterations(), Fixture::kBeamConstraint, scatteringTable<Det>(material), std::make_shared<BoundedMemoryResource>(), 2U, 1};
+  const UniformMaterial none{};
+  tracker.setTrackModel(trackingGeometry(), none, Propagator{});
+  std::vector<std::uint32_t> firstCluster;
+  tracker.setSliceObserver([&](const Tracker<Det, UniformMaterial>&, const Tracker<Det, UniformMaterial>::SliceObservation& slice) {
+    for (std::uint32_t record = 0; record < slice.records->size(); ++record) {
+      firstCluster.push_back(slice.records->view().clusters[record].index[0]);
+    }
+  });
+  std::vector<std::size_t> seen;
+  tracker.setIterationObserver([&](const Tracker<Det, UniformMaterial>& observed, const Tracker<Det, UniformMaterial>::IterationObservation& iteration) {
+    seen.push_back(iteration.iteration);
+    BOOST_REQUIRE(iteration.selection != nullptr && iteration.summary != nullptr);
+    if (iteration.selection == nullptr || iteration.summary == nullptr) {
+      return; // for the static analysis: BOOST_REQUIRE has already failed
+    }
+    BOOST_TEST(iteration.summary->records == iteration.selection->recordCount());
+    BOOST_TEST(iteration.summary->tracks == iteration.selection->selected().size());
+    // The appended records are the slices', in slice order.
+    BOOST_REQUIRE(iteration.selection->recordCount() == firstCluster.size());
+    for (std::uint32_t record = 0; record < iteration.selection->recordCount(); ++record) {
+      BOOST_TEST(iteration.selection->records().clusters[record].index[0] == firstCluster[record]);
+    }
+    firstCluster.clear();
+    const auto exclusive = std::ranges::count(observed.used(), std::uint8_t{kExclusive});
+    BOOST_TEST(static_cast<std::size_t>(exclusive) == (iteration.iteration + 1U) * (kTracks / 2U) * kLayers);
+  });
+  const auto result = tracker.run(*fixture.frame, tracker.planTimeframe(*fixture.frame, {}, 3, 0.));
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  BOOST_TEST((seen == std::vector<std::size_t>{0U, 1U}));
+}
+
+namespace
+{
+
+std::vector<IterationSettings> iterations(VertexSource source)
+{
+  auto settings = iterations();
+  for (auto& one : settings) {
+    one.vertexSource = source;
+  }
+  return settings;
+}
+
+/// One vertex per track, at its start time on the beam axis: a point box.
+std::vector<VertexSeed> trackVertices()
+{
+  std::vector<VertexSeed> vertices;
+  vertices.reserve(kTracks);
+  for (std::size_t track = 0; track < kTracks; ++track) {
+    const auto timePS = static_cast<std::uint32_t>(37'000U + (83'000U * track));
+    vertices.push_back({.timePS = timePS, .widthPS = 0U, .z = 0.F, .varZ = 4.e-4F, .varTransverse = 1.e-6F});
+  }
+  return vertices;
+}
+
+} // namespace
+
+/// A plan run is the run that plans for itself, beam line and vertex list.
+BOOST_AUTO_TEST_CASE(APlannedRunGivesThePlanningRunsTracks)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const auto vertices = trackVertices();
+  for (const auto source : {VertexSource::kBeamLine, VertexSource::kVertexList}) {
+    BOOST_TEST_CONTEXT((source == VertexSource::kBeamLine ? "beam line" : "vertex list"))
+    {
+      const auto settings = iterations(source);
+      auto planning = makeTracker(settings);
+      const auto expected = planning->run(*fixture.frame, planning->planTimeframe(*fixture.frame, vertices, 3, 0.));
+      BOOST_REQUIRE(expected.status == StageStatus::kComplete);
+      auto planned = makeTracker(settings);
+      const auto plan = planned->planTimeframe(*fixture.frame, vertices, 3, 0.);
+      BOOST_TEST(plan.beamLine.varZ == planned->beamLine().varZ);
+      BOOST_TEST(plan.vertices.size() == vertices.size());
+      const auto result = planned->run(*fixture.frame, plan);
+      BOOST_REQUIRE(result.status == StageStatus::kComplete);
+      BOOST_TEST((found(result) == found(expected)));
+      BOOST_TEST(found(result).size() == kTracks);
+    }
+  }
+}
+
+/// A run resumed from the checkpoint of its first iteration, by another tracker
+/// of the same configuration, is the whole run: the same digest -- tracks,
+/// used mask and summaries -- and tracks.
+BOOST_AUTO_TEST_CASE(AResumedRunIsTheWholeRun)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const auto settings = iterations();
+  auto whole = makeTracker(settings);
+  const auto plan = whole->planTimeframe(*fixture.frame, {}, 3, 0.);
+  const auto expected = whole->run(*fixture.frame, plan);
+  BOOST_REQUIRE(expected.status == StageStatus::kComplete);
+  const auto expectedDigest = study::trackingDigest(expected, whole->used());
+  // A plan is its tracker's: each plans its own.
+  auto first = makeTracker(settings);
+  const auto part = first->run(*fixture.frame, first->planTimeframe(*fixture.frame, {}, 3, 0.), 1U);
+  BOOST_REQUIRE(part.status == StageStatus::kComplete);
+  BOOST_TEST(part.iterations.size() == 1U);
+  const auto checkpoint = first->checkpoint(part);
+  BOOST_TEST(checkpoint.tracks.size() == kTracks / 2U);
+  auto resumed = makeTracker(settings);
+  const auto result = resumed->resume(*fixture.frame, resumed->planTimeframe(*fixture.frame, {}, 3, 0.), checkpoint);
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  BOOST_TEST(study::trackingDigest(result, resumed->used()) == expectedDigest);
+  BOOST_TEST((found(result) == found(expected)));
+}
+
+/// The plan holds the frame's bounds and one slice list for every iteration:
+/// the halo, the gate around each core, the source maps; and each
+/// iteration's vertex windows.
+BOOST_AUTO_TEST_CASE(ASlicePlanHoldsTheSlicesBoundsAndGate)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const auto tracker = makeTracker(iterations());
+  const auto plan = tracker->planTimeframe(*fixture.frame, {}, 3, 0.);
+  const auto& frame = *fixture.frame;
+  BOOST_TEST(plan.slices.size() == static_cast<std::size_t>((fixture.geometry.blockCount() + 2) / 3));
+  // The toys' blocks start at 0 and are whole picoseconds.
+  const auto reach = sliceReach(frameBounds(frame), fixture.geometry).gatePS();
+  const auto width = fixture.geometry.blockWidth();
+  BOOST_REQUIRE(fixture.geometry.partsPerPS() == 1);
+  for (const auto& slicePlan : plan.slices) {
+    const auto& slice = slicePlan.slice;
+    BOOST_TEST(slicePlan.gateEarliestPS == (static_cast<std::int64_t>(slice.coreBlocks.begin) * width) - reach);
+    BOOST_TEST(slicePlan.gateLatestPS == (static_cast<std::int64_t>(slice.coreBlocks.end) * width) + reach);
+    BOOST_TEST(slicePlan.sources.size() == TimeFrameScratch<Det>::makeSources(slice.halo).size());
+    const auto inputs = slicePlan.inputs(tracker->iteration(0U), plan.layerMaxWidthPS);
+    BOOST_TEST(inputs.gate.core == slice.core.data());
+    BOOST_TEST(inputs.gate.earliestPS == slicePlan.gateEarliestPS);
+  }
+}
+
+/// A plan of another frame, another number of iterations or other
+/// parameters is refused before anything runs.
+BOOST_AUTO_TEST_CASE(APlanOfAnotherFrameOrConfigurationIsRefused)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const Fixture longer{hits(), 2. * kDurationNS};
+  const auto tracker = makeTracker(iterations());
+  const auto plan = tracker->planTimeframe(*fixture.frame, {}, 3, 0.);
+  BOOST_CHECK_THROW(static_cast<void>(tracker->run(*longer.frame, plan)), std::invalid_argument);
+
+  const auto one = makeTracker({iterations().front()});
+  BOOST_CHECK_THROW(static_cast<void>(one->run(*fixture.frame, plan)), std::invalid_argument);
+
+  auto other = iterations();
+  other[1].windows.minPtGeV = 0.4;
+  const auto otherTracker = makeTracker(other);
+  BOOST_CHECK_THROW(static_cast<void>(otherTracker->run(*fixture.frame, plan)), std::invalid_argument);
+  BOOST_CHECK_THROW(plan.check(*fixture.frame, std::span<const IterationParameters<Det>>{}), std::invalid_argument);
+  BOOST_CHECK_NO_THROW(plan.check(*fixture.frame, plan.parameters));
+}
+
+/// The iteration observation carries the mask after the iteration, the
+/// tracks with the iteration's offset, and the follow's proposals -- none
+/// without the follow, never an earlier iteration's.
+BOOST_AUTO_TEST_CASE(TheIterationObservationCarriesMaskTracksAndProposals)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  for (const bool follow : {true, false}) {
+    BOOST_TEST_CONTEXT("follow " << follow)
+    {
+      auto tracker = makeTracker(iterations(), follow);
+      std::vector<std::uint32_t> offsets;
+      std::vector<std::size_t> proposals;
+      tracker->setIterationObserver([&](const Tracker<Det, UniformMaterial>& observed, const Tracker<Det, UniformMaterial>::IterationObservation& iteration) {
+        BOOST_TEST(iteration.used.data() == observed.used().data());
+        BOOST_REQUIRE(iteration.tracks != nullptr);
+        BOOST_TEST(iteration.tracks->size() == iteration.trackOffset + iteration.summary->tracks);
+        offsets.push_back(iteration.trackOffset);
+        proposals.push_back(iteration.proposals.size());
+      });
+      const auto result = tracker->run(*fixture.frame, tracker->planTimeframe(*fixture.frame, {}, 3, 0.));
+      BOOST_REQUIRE(result.status == StageStatus::kComplete);
+      BOOST_TEST((offsets == std::vector<std::uint32_t>{0U, static_cast<std::uint32_t>(kTracks / 2U)}));
+      const std::vector<std::size_t> expected = follow ? std::vector<std::size_t>{kTracks / 2U, kTracks / 2U} : std::vector<std::size_t>{0U, 0U};
+      BOOST_TEST(proposals == expected, boost::test_tools::per_element());
+    }
+  }
+}
+
+/// Seeds on the inner layers, the follow over every layer:
+/// the iterations' roads join layers
+/// 0-4, their follow every layer, and each track comes out whole. A track
+/// shorter than an iteration's length after the follow is dropped, and its
+/// rows go back to the next iteration.
+BOOST_AUTO_TEST_CASE(InnerSeedsFollowOverEveryLayerAndShortTracksGiveTheirRowsBack)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const auto everyLayerTracker = makeTracker(iterations(), false);
+  const auto everyLayer = everyLayerTracker->run(*fixture.frame, everyLayerTracker->planTimeframe(*fixture.frame, {}, 3, 0.));
+  BOOST_REQUIRE(everyLayer.status == StageStatus::kComplete);
+  const auto expected = found(everyLayer);
+  BOOST_REQUIRE(expected.size() == kTracks);
+
+  constexpr int kWhole = static_cast<int>(kLayers);
+  const auto seeded = [](std::array<int, 2> minClustersAfterFollow) {
+    auto settings = iterations();
+    for (std::size_t i = 0; i < settings.size(); ++i) {
+      settings[i].layerMask = 0b11111U;
+      settings[i].skipLinks = false;
+      settings[i].minClustersAfterFollow = minClustersAfterFollow[i];
+    }
+    return settings;
+  };
+  {
+    auto tracker = makeTracker(seeded({0, 0}));
+    const auto result = tracker->run(*fixture.frame, tracker->planTimeframe(*fixture.frame, {}, 3, 0.));
+    BOOST_REQUIRE(result.status == StageStatus::kComplete);
+    const auto tracks = found(result);
+    BOOST_TEST(tracks.size() == kTracks);
+    BOOST_TEST((rows(tracks) == rows(expected)));
+    BOOST_TEST(result.iterations[0].tracksFollowed == kTracks / 2U);
+    BOOST_TEST(result.iterations[0].clustersFollowedOutward == 3U * kTracks / 2U);
+    BOOST_TEST(result.iterations[0].tracksDropped == 0U);
+    BOOST_TEST(std::ranges::all_of(tracker->used(), [](std::uint8_t state) { return state == kExclusive; }));
+  }
+  {
+    // The first iteration asks more than a track can hold: its six stiff
+    // tracks are dropped, and the second, at 0.3 GeV, finds all twelve.
+    auto tracker = makeTracker(seeded({kWhole + 1, kWhole}));
+    std::vector<std::size_t> observed;
+    tracker->setIterationObserver([&](const Tracker<Det, UniformMaterial>&, const Tracker<Det, UniformMaterial>::IterationObservation& iteration) {
+      BOOST_TEST(iteration.tracks->size() == iteration.trackOffset + iteration.summary->tracks - iteration.summary->tracksDropped);
+      BOOST_TEST(iteration.proposals.size() == iteration.tracks->size() - iteration.trackOffset);
+      observed.push_back(iteration.tracks->size());
+    });
+    const auto result = tracker->run(*fixture.frame, tracker->planTimeframe(*fixture.frame, {}, 3, 0.));
+    BOOST_REQUIRE(result.status == StageStatus::kComplete);
+    BOOST_TEST(result.iterations[0].tracksDropped == kTracks / 2U);
+    BOOST_TEST(result.iterations[1].tracksDropped == 0U);
+    BOOST_TEST((observed == std::vector<std::size_t>{0U, kTracks}));
+    const auto tracks = found(result);
+    BOOST_TEST((rows(tracks) == rows(expected)));
+    BOOST_TEST(std::ranges::all_of(tracks, [](const Found& track) { return track.iteration == 1U; }));
+    BOOST_TEST(std::ranges::all_of(tracker->used(), [](std::uint8_t state) { return state == kExclusive; }));
+  }
+  {
+    // Both ask too much: nothing is kept, and every row is free again.
+    auto tracker = makeTracker(seeded({kWhole + 1, kWhole + 1}));
+    const auto result = tracker->run(*fixture.frame, tracker->planTimeframe(*fixture.frame, {}, 3, 0.));
+    BOOST_REQUIRE(result.status == StageStatus::kComplete);
+    BOOST_TEST(result.tracks->size() == 0U);
+    BOOST_TEST(std::ranges::all_of(tracker->used(), [](std::uint8_t state) { return state == kFree; }));
+  }
+}
+
+/// Seeds on the outer layers, updated with the beam line, the follow over
+/// every layer inward from the constrained state: each track comes out whole, as the iterations over every layer
+/// find it.
+BOOST_AUTO_TEST_CASE(OuterSeedsOnTheBeamLineFollowInwardWhole)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const auto everyLayerTracker = makeTracker(iterations(), false);
+  const auto everyLayer = everyLayerTracker->run(*fixture.frame, everyLayerTracker->planTimeframe(*fixture.frame, {}, 3, 0.));
+  BOOST_REQUIRE(everyLayer.status == StageStatus::kComplete);
+
+  const auto expected = rows(found(everyLayer));
+  BOOST_REQUIRE(expected.size() == kTracks);
+  auto settings = iterations();
+  for (auto& iteration : settings) {
+    iteration.layerMask = ((1U << kLayers) - 1U) & ~0b111U;
+    iteration.skipLinks = false;
+    iteration.beamConstraint = true;
+  }
+  auto tracker = makeTracker(settings);
+  const auto result = tracker->run(*fixture.frame, tracker->planTimeframe(*fixture.frame, {}, 3, 0.));
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  BOOST_TEST((rows(found(result)) == expected));
+  BOOST_TEST(result.iterations[0].clustersFollowedInward == 3U * kTracks / 2U);
+  BOOST_TEST(std::ranges::all_of(tracker->used(), [](std::uint8_t state) { return state == kExclusive; }));
+}
+
+/// The recovery pass: a second iteration with the
+/// kink allowance, following the first's tracks again (followEarlier), and a
+/// length after the follow for its own tracks. On tracks without kinks it
+/// finds what the first iteration did, every row held once: the earlier
+/// tracks' follow takes nothing more and gives nothing back.
+BOOST_AUTO_TEST_CASE(TheRecoveryPassKeepsWholeTracksWhole)
+{
+  const Fixture fixture{hits(), kDurationNS};
+
+  const auto everyLayerTracker = makeTracker(iterations(), false);
+  const auto expected = rows(found(everyLayerTracker->run(*fixture.frame, everyLayerTracker->planTimeframe(*fixture.frame, {}, 3, 0.))));
+  BOOST_REQUIRE(expected.size() == kTracks);
+  auto settings = iterations();
+  for (auto& iteration : settings) {
+    iteration.layerMask = ((1U << kLayers) - 1U) & ~0b111U;
+    iteration.skipLinks = false;
+    iteration.beamConstraint = true;
+  }
+  settings[1].kinkSigma = 5.;
+  settings[1].maxKinks = 2;
+  settings[1].followEarlier = true;
+  settings[1].minClustersAfterFollow = static_cast<int>(kLayers);
+  auto tracker = makeTracker(settings);
+  const auto result = tracker->run(*fixture.frame, tracker->planTimeframe(*fixture.frame, {}, 3, 0.));
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  BOOST_TEST((rows(found(result)) == expected));
+  BOOST_TEST(result.iterations[1].tracksDropped == 0U);
+  BOOST_TEST(std::ranges::all_of(tracker->used(), [](std::uint8_t state) { return state == kExclusive; }));
+}
+
+/// The recovery pass on one graph (one graph for both rounds): the second
+/// iteration takes the first one's graph, built with its
+/// kink allowance, and finds the tracks the two iterations with a graph each
+/// find -- their iterations, rows and chi2s -- building no slice of its own.
+/// A second iteration whose graph settings differ, or without an allowance,
+/// is refused.
+BOOST_AUTO_TEST_CASE(TheRecoveryPassOnOneGraphFindsTheTwoGraphsTracks)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  auto settings = iterations();
+  for (auto& iteration : settings) {
+    iteration.windows = settings[0].windows;
+    iteration.layerMask = ((1U << kLayers) - 1U) & ~0b111U;
+    iteration.skipLinks = false;
+    iteration.beamConstraint = true;
+  }
+  settings[1].kinkSigma = 5.;
+  settings[1].maxKinks = 2;
+  settings[1].followEarlier = true;
+  settings[1].minClustersAfterFollow = static_cast<int>(kLayers);
+  auto separate = makeTracker(settings);
+  const auto twoGraphs = separate->run(*fixture.frame, separate->planTimeframe(*fixture.frame, {}, 3, 0.));
+  BOOST_REQUIRE(twoGraphs.status == StageStatus::kComplete);
+  settings[1].sharedGraph = true;
+  auto tracker = makeTracker(settings);
+  const auto oneGraph = tracker->run(*fixture.frame, tracker->planTimeframe(*fixture.frame, {}, 3, 0.));
+  BOOST_REQUIRE(oneGraph.status == StageStatus::kComplete);
+  // Both at the first iteration's floor: the stiffer half of the tracks.
+  BOOST_TEST(found(oneGraph).size() == kTracks / 2U);
+  BOOST_TEST((found(oneGraph) == found(twoGraphs)));
+  BOOST_TEST((std::vector<std::uint8_t>(tracker->used().begin(), tracker->used().end()) == std::vector<std::uint8_t>(separate->used().begin(), separate->used().end())));
+  BOOST_TEST(oneGraph.iterations[1].slices == 0U);
+  BOOST_TEST(oneGraph.iterations[1].roads == 0U);
+
+  auto otherFloor = settings;
+  otherFloor[1].windows.minPtGeV = 0.3;
+  BOOST_CHECK_THROW(makeTracker(otherFloor), std::invalid_argument);
+  auto noAllowance = settings;
+  noAllowance[1].kinkSigma = 1.;
+  BOOST_CHECK_THROW(makeTracker(noAllowance), std::invalid_argument);
+  auto first = settings;
+  first[0].sharedGraph = true;
+  BOOST_CHECK_THROW(makeTracker(first), std::invalid_argument);
+}
+
+namespace
+{
+
+/// The toy with ALICE 3's two frame lengths:
+/// layers 0-2 read out every 22 BC, layers 3-7 every 81 BC, both from BC 0,
+/// widened by \a marginBC. The blocks are two of the longer frames, as
+/// GridConfig.h's `gridParams` makes them.
+constexpr std::int32_t kInnerFrameBC = 22;
+constexpr std::int32_t kOuterFrameBC = 81;
+constexpr std::int64_t kPartsPerPS = kPSPerBCDenominator;
+constexpr std::int64_t kPartsPerBC = kPSPerBCNumerator;
+/// A BC [ns], O2's LHCBunchSpacingNS.
+constexpr double kBunchNS = o2::constants::lhc::LHCBunchSpacingNS;
+/// The tracks' crossings. The inner frame of those at 160, 170, 326 and 650
+/// BC straddles an outer frame's edge; for the last three the edge is a
+/// block's (162, 324, 648), so their inner and outer rows start in
+/// neighbouring blocks.
+constexpr std::array<std::int64_t, 12> kCrossingBC{5, 40, 100, 160, 170, 250, 326, 400, 480, 520, 650, 700};
+constexpr double kFramedDurationNS = 820. * kBunchNS;
+
+std::int32_t frameLengthBC(LayerID layer) { return layer < 3 ? kInnerFrameBC : kOuterFrameBC; }
+
+GridParams twoLengthGrid()
+{
+  GridParams params;
+  params.partsPerPS = kPartsPerPS;
+  params.blockWidth = kPartsPerBC * 2 * kOuterFrameBC;
+  params.blockOrigin = -kPartsPerPS;
+  for (std::size_t layer = 0; layer < kLayers; ++layer) {
+    params.frames[layer] = {.lengthBC = frameLengthBC(static_cast<LayerID>(layer)), .firstStartBC = 0};
+  }
+  return params;
+}
+
+/// The box of the frame \a hit falls in on its layer, widened by \a marginBC.
+TimeEstPS frameOf(const Hit& hit, std::int64_t marginBC)
+{
+  const auto bc = static_cast<std::int64_t>(std::floor(hit.timeNS / kBunchNS));
+  const auto length = frameLengthBC(hit.point.layer);
+  const auto start = (bc / length) * length;
+  return frameBox(start, start + length, marginBC);
+}
+
+std::vector<Hit> framedHits()
+{
+  std::vector<Hit> result;
+  for (std::size_t track = 0; track < kCrossingBC.size(); ++track) {
+    const auto k = static_cast<double>(track);
+    const double pt = stiff(track) ? 2. + (0.2 * static_cast<double>(track % 5U)) : 0.4 + (0.06 * static_cast<double>(track % 5U));
+    const double startNS = (static_cast<double>(kCrossingBC[track]) * kBunchNS) + 5.;
+    const auto one = sensorHelixHits(std::fmod(0.3 + (0.9 * k), 2 * std::numbers::pi_v<double>), 0.03 * std::cos(1.3 * k), pt, startNS);
+    BOOST_REQUIRE(one.size() == kLayers);
+    result.insert(result.end(), one.begin(), one.end());
+  }
+  return result;
+}
+
+struct FramedRun {
+  std::vector<Found> tracks;
+  std::vector<TimeEstPS> times; ///< by track index, from the clusters
+  std::int64_t haloPS = 0;
+};
+
+FramedRun trackFramed(const Fixture& fixture, std::int32_t widthBlocks)
+{
+  auto tracker = makeTracker(iterations(), false);
+  const auto result = tracker->run(*fixture.frame, tracker->planTimeframe(*fixture.frame, {}, widthBlocks, 0.));
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  FramedRun run{.tracks = found(result), .times = std::vector<TimeEstPS>(kCrossingBC.size()), .haloPS = result.iterations.front().haloPS};
+  const auto view = result.tracks->view();
+  for (std::size_t i = 0; i < result.tracks->size(); ++i) {
+    const auto index = fixture.frame->measurement(view.clusters[i].index[0]).clusterIndex / kLayers;
+    run.times[index] = {.start = view.timePS[i], .width = view.widthPS[i]};
+  }
+  return run;
+}
+
+} // namespace
+
+/// Layers of two frame lengths, no margin: only the inner -> outer link
+/// reaches, an inner frame forward and an outer one backward, so the gate is
+/// one of each and the halo one outer frame more; the slices give the
+/// one-slice tracks,
+/// those whose inner and outer rows start on two sides of a slice's edge
+/// among them; a track's time is its frames' intersection, 8 BC where the
+/// inner frame straddles an outer edge.
+BOOST_AUTO_TEST_CASE(TwoFrameLengthsSliceWithOneOuterFrameOfHalo)
+{
+  const auto hits = framedHits();
+  const Fixture fixture{hits, kFramedDurationNS, twoLengthGrid(), [](const Hit& hit) { return frameOf(hit, 0); }};
+  const auto bounds = frameBounds(*fixture.frame);
+  BOOST_TEST(std::ranges::all_of(bounds.rowsAreFrames, [](bool framed) { return framed; }));
+
+  // The crossing at 170 BC: inner frame [154, 176) in block 0, outer frame
+  // [162, 243) in block 1.
+  const auto& geometry = fixture.geometry;
+  BOOST_TEST(geometry.blockOfPS(frameOf(hits[Fixture::logicalIndex(4U, 2U)], 0).start) == 0);
+  BOOST_TEST(geometry.blockOfPS(frameOf(hits[Fixture::logicalIndex(4U, 3U)], 0).start) == 1);
+
+  const auto whole = trackFramed(fixture, geometry.blockCount());
+  BOOST_REQUIRE(whole.tracks.size() == kCrossingBC.size());
+  for (std::size_t track = 0; track < kCrossingBC.size(); ++track) {
+    BOOST_TEST_CONTEXT("track at " << kCrossingBC[track] << " BC")
+    {
+      const auto bc = kCrossingBC[track];
+      const auto inner = (bc / kInnerFrameBC) * kInnerFrameBC;
+      const auto outer = (bc / kOuterFrameBC) * kOuterFrameBC;
+      const auto lowBC = std::max(inner, outer);
+      const auto highBC = std::min(inner + kInnerFrameBC, outer + kOuterFrameBC);
+      BOOST_TEST(whole.times[track].start == psOfBC(lowBC));
+      // The ends are each rounded down from BC: within a picosecond of the BC interval's.
+      BOOST_TEST(std::abs(static_cast<std::int64_t>(whole.times[track].upper()) - psOfBC(highBC)) <= 1);
+    }
+  }
+  // At 160 BC: inner [154, 176), outer [81, 162), the time [154, 162).
+  BOOST_TEST(std::abs(static_cast<std::int64_t>(whole.times[3].width) - psOfBC(8)) <= 1);
+  for (const std::int32_t width : {1, 2, 3}) {
+    BOOST_TEST_CONTEXT("slices of " << width << " blocks")
+    {
+      const auto sliced = trackFramed(fixture, width);
+      BOOST_TEST((sliced.tracks == whole.tracks));
+    }
+  }
+}
+
+/// The same toy with its boxes widened by a margin while the grid still
+/// declares the frames -- as a dump keeps the boxes its producer widened,
+/// whatever margin the tracking is configured with: the rows are not their
+/// frames, every link
+/// reaches the wider box, and the slices still give the one-slice tracks.
+BOOST_AUTO_TEST_CASE(TwoFrameLengthsWithAMarginReachEveryLink)
+{
+  constexpr std::int64_t kMarginBC = 4;
+  const Fixture fixture{framedHits(), kFramedDurationNS, twoLengthGrid(), [](const Hit& hit) { return frameOf(hit, kMarginBC); }};
+  const auto bounds = frameBounds(*fixture.frame);
+  BOOST_TEST(std::ranges::none_of(bounds.rowsAreFrames, [](bool framed) { return framed; }));
+
+  const auto whole = trackFramed(fixture, fixture.geometry.blockCount());
+  BOOST_REQUIRE(whole.tracks.size() == kCrossingBC.size());
+  for (const std::int32_t width : {1, 2, 3}) {
+    BOOST_TEST_CONTEXT("slices of " << width << " blocks") { BOOST_TEST((trackFramed(fixture, width).tracks == whole.tracks)); }
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testLayerLinks.cxx b/Detectors/GenericTracking/tracking/test/testLayerLinks.cxx
new file mode 100644
index 0000000000000..8d987cafc440e
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testLayerLinks.cxx
@@ -0,0 +1,304 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testLayerLinks.cxx
+/// \brief What follows from a detector's link table, and the grid it sizes.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK LayerLinks
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Base/LayerLinks.h"
+#include "ToyBarrel3.h"
+#include "ToyBarrel4Disc8.h"
+#include "GenericTracking/Tracking/GridSizing.h"
+#include "GenericTracking/Tracking/LinkHoles.h"
+#include "GenericTracking/Tracking/MeasurementGrid.h"
+
+#include "GridTestSupport.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <stdexcept>
+#include <utility>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using detectors::ToyBarrel3;
+using detectors::ToyBarrel4Disc8;
+
+/// Whether `directPairRange` leaves anything.
+bool directPairPossible(std::uint64_t holes, std::uint64_t barrels, const LayerSpan* spans, LayerID target, Scalar ra, Scalar za, Scalar low, Scalar high)
+{
+  const auto range = directPairRange(holes, barrels, spans, target, ra, za, low, high);
+  return range.low <= range.high;
+}
+
+/// ToyBarrel3's layers with links whose order is not the layer numbering:
+/// 0 -> 2 -> 1, and 0 -> 1 directly past 2.
+struct Reordered {
+  static constexpr const char* name = "Reordered";
+  static constexpr auto barrelSpecs = ToyBarrel3::barrelSpecs;
+  static constexpr auto discSpecs = ToyBarrel3::discSpecs;
+  static constexpr auto barrelLayers = ToyBarrel3::barrelLayers;
+  static constexpr auto discLayers = ToyBarrel3::discLayers;
+  static constexpr std::array<LayerLink, 3> layerLinks{{
+    {.from = 2, .to = 1, .sourceMin = -1., .sourceMax = 1., .skipsLayer = false},
+    {.from = 0, .to = 2, .sourceMin = -1., .sourceMax = 1., .skipsLayer = false},
+    {.from = 0, .to = 1, .sourceMin = -0.5, .sourceMax = 0.5, .skipsLayer = true},
+  }};
+  static constexpr int nSensors = ToyBarrel3::nSensors;
+};
+
+/// ToyBarrel3's inner layers with a two-module outer one, |z| 2 cm at r 8:
+/// 0 -> 2 passes beyond layer 1's |z| 1 cm for steep tracks and crosses it
+/// for the others; from |z| below 0.5 on layer 0 every pair crosses it.
+struct PastTheEnd {
+  static constexpr const char* name = "PastTheEnd";
+  static constexpr std::array<BarrelLayerSpec, 3> barrelSpecs{{
+    ToyBarrel3::barrelSpecs[0],
+    ToyBarrel3::barrelSpecs[1],
+    {.r = 8., .nStaves = 4, .nModulesPerStave = 2, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = ToyBarrel3::sensor},
+  }};
+  static constexpr auto discSpecs = ToyBarrel3::discSpecs;
+  static constexpr auto barrelLayers = placedLayers(barrelSpecs);
+  static constexpr auto discLayers = placedLayers(discSpecs);
+  static constexpr std::array<LayerLink, 3> layerLinks{{
+    {.from = 0, .to = 1, .sourceMin = -1.5, .sourceMax = 1.5, .skipsLayer = false},
+    {.from = 0, .to = 2, .sourceMin = -1.5, .sourceMax = 1.5, .skipsLayer = false},
+    {.from = 1, .to = 2, .sourceMin = -1.5, .sourceMax = 1.5, .skipsLayer = false},
+  }};
+  static constexpr int nSensors = countSensors(barrelLayers, discLayers);
+};
+
+[[maybe_unused]] const bool kReorderedPublished = publishToy<Reordered>();
+[[maybe_unused]] const bool kPastTheEndPublished = publishToy<PastTheEnd>();
+
+/// Every layer's span and the barrel bits, as an iteration holds them.
+template <DetectorLayout Det>
+auto spansOf()
+{
+  std::array<LayerSpan, static_cast<std::size_t>(Detector<Det>::nLayers)> spans{};
+  for (std::size_t layer = 0; layer < spans.size(); ++layer) {
+    spans[layer] = layerSpan<Det>(static_cast<LayerID>(layer));
+  }
+  return spans;
+}
+
+/// For every link of \a Det with layers a pair can cross: points over the
+/// source's and the target's extents, the per-source check against every
+/// pair. A direct pair from a source the check refuses fails; returns the
+/// sources refused and the sources checked.
+template <DetectorLayout Det>
+std::pair<std::size_t, std::size_t> checkEveryDirectPairIsPossible()
+{
+  constexpr int kSteps = 25;
+  const auto spans = spansOf<Det>();
+  const auto barrels = barrelLayerBits<Det>();
+  const auto along = [](Scalar low, Scalar high, int i, int steps) { return low + ((high - low) * static_cast<Scalar>(i) / static_cast<Scalar>(steps - 1)); };
+  // A point of a layer's extent, as (r, z).
+  const auto point = [&](LayerID layer, int i, int j, int positionSteps) {
+    const auto& span = spans[layer];
+    const Scalar position = along(span.positionMin, span.positionMax, i, positionSteps);
+    const Scalar second = along(span.low, span.high, j, kSteps);
+    return ((barrels >> layer) & 1U) != 0U ? std::pair{position, second} : std::pair{second, position};
+  };
+  std::size_t refused = 0;
+  std::size_t checked = 0;
+  for (const auto& link : Det::layerLinks) {
+    const auto holes = linkHoleLayers<Det>(link.from, link.to);
+    if (holes == 0U) {
+      continue;
+    }
+    for (int i = 0; i < 3; ++i) {
+      for (int j = 0; j < kSteps; ++j) {
+        const auto [ra, za] = point(link.from, i, j, 3);
+        const bool possible = directPairPossible(holes, barrels, spans.data(), link.to, ra, za, spans[link.to].low, spans[link.to].high);
+        ++checked;
+        refused += possible ? 0U : 1U;
+        for (int k = 0; k < 3 && !possible; ++k) {
+          for (int l = 0; l < kSteps; ++l) {
+            const auto [rb, zb] = point(link.to, k, l, 3);
+            BOOST_TEST_CONTEXT(Det::name << " link " << link.from << " -> " << link.to << " from (" << ra << ", " << za << ") to (" << rb << ", " << zb << ")") { BOOST_TEST(segmentLeavesHole(holes, barrels, spans.data(), ra, za, rb, zb)); }
+          }
+        }
+      }
+    }
+  }
+  return {refused, checked};
+}
+
+/// Where each layer sits in `layerOrder`.
+template <DetectorLayout Det>
+constexpr auto positions()
+{
+  std::array<std::size_t, static_cast<std::size_t>(Detector<Det>::nLayers)> result{};
+  for (std::size_t i = 0; i < result.size(); ++i) {
+    result[layerOrder<Det>[i]] = i;
+  }
+  return result;
+}
+
+template <DetectorLayout Det>
+constexpr bool everyLinkPointsForward()
+{
+  constexpr auto position = positions<Det>();
+  return std::ranges::all_of(Det::layerLinks, [&](const LayerLink& link) { return position[link.from] < position[link.to]; });
+}
+
+/// Every link appears once among the out-links of its source and once among
+/// the in-links of its target.
+template <DetectorLayout Det>
+constexpr bool indexedOnceEachWay()
+{
+  for (std::size_t i = 0; i < nLinks<Det>; ++i) {
+    const auto& link = Det::layerLinks[i];
+    std::size_t out = 0;
+    for (auto k = outLinks<Det>.begin(link.from); k < outLinks<Det>.end(link.from); ++k) {
+      out += outLinks<Det>.links[k] == i ? 1U : 0U;
+    }
+    std::size_t in = 0;
+    for (auto k = inLinks<Det>.begin(link.to); k < inLinks<Det>.end(link.to); ++k) {
+      in += inLinks<Det>.links[k] == i ? 1U : 0U;
+    }
+    if (out != 1 || in != 1) {
+      return false;
+    }
+  }
+  return outLinks<Det>.offsets.back() == nLinks<Det> && inLinks<Det>.offsets.back() == nLinks<Det>;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(TheOrderFollowsTheLinksNotTheNumbering)
+{
+  static_assert(layerOrder<Reordered> == std::array<LayerID, 3>{0, 2, 1});
+  static_assert(everyLinkPointsForward<Reordered>());
+  static_assert(indexedOnceEachWay<Reordered>());
+  // 0 -> 2 -> 1 is the longest chain; 0 -> 1 skips 2 and ends one.
+  static_assert(maxChainLayers<Reordered> == 3);
+
+  // Out-links keep table order within a layer.
+  static_assert(outLinks<Reordered>.count(0) == 2);
+  static_assert(Reordered::layerLinks[outLinks<Reordered>.links[outLinks<Reordered>.begin(0)]].to == 2);
+  static_assert(inLinks<Reordered>.count(1) == 2);
+  static_assert(outLinks<Reordered>.count(1) == 0);
+  BOOST_TEST(true);
+}
+
+BOOST_AUTO_TEST_CASE(TheBarrelAndDiscTableIsAcyclicAndIndexed)
+{
+  // Compiling layerOrder is the acyclicity check; these pin what it gives.
+  static_assert(everyLinkPointsForward<ToyBarrel4Disc8>());
+  static_assert(indexedOnceEachWay<ToyBarrel4Disc8>());
+
+  BOOST_TEST(maxChainLayers<ToyBarrel4Disc8> >= 4U); // at least the whole barrel
+}
+
+/// A crossing link must not size cells: its window is the target's whole
+/// second axis, and taken as a bound it would leave one cell there. With the
+/// tracklet queries alone (no extension), every layer a same-kind link enters
+/// keeps both axes binned, and a layer only crossing links enter is not sized
+/// at all: one cell per axis.
+///
+/// At the 1 GeV of the first iteration, with every other default but a beam
+/// spot narrow against the toy's layers, whose windows it would otherwise
+/// spread over a whole barrel layer.
+BOOST_AUTO_TEST_CASE(CrossingLinksDoNotCollapseTheGrid)
+{
+  SearchWindowParams windows;
+  windows.minPtGeV = 1.;
+  const IterationSettings tracklets{.windows = windows, .follow = false};
+  const auto layers = gridLayerWindows<ToyBarrel4Disc8>(std::span<const IterationSettings>{&tracklets, 1U}, VertexConstraint{.sigmaZ = 1.});
+  const GridGeometry<ToyBarrel4Disc8> grid{100'000, test::withToyFrames(GridParams{.blockWidth = 100'000}), layers};
+  for (int layer = 0; layer < Detector<ToyBarrel4Disc8>::nLayers; ++layer) {
+    const auto id = static_cast<LayerID>(layer);
+    bool sameKindIn = false;
+    for (const auto& link : ToyBarrel4Disc8::layerLinks) {
+      sameKindIn = sameKindIn || (link.to == id && Detector<ToyBarrel4Disc8>::isBarrelLayer(link.from) == Detector<ToyBarrel4Disc8>::isBarrelLayer(id));
+    }
+    const auto& axes = grid.axes(id);
+    BOOST_TEST_CONTEXT("layer " << layer)
+    {
+      if (sameKindIn) {
+        BOOST_TEST(axes.nPhi > 1);
+        BOOST_TEST(axes.nSecond > 1);
+      } else {
+        BOOST_TEST(axes.cellCount() == 1);
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(APairLeavesAHoleWhereItsSegmentCrossesALayer)
+{
+  BOOST_TEST(linkHoleLayers<PastTheEnd>(0, 1) == 0U);
+  BOOST_TEST(linkHoleLayers<PastTheEnd>(0, 2) == 0b010U);
+  BOOST_TEST(linkHoleLayers<PastTheEnd>(1, 2) == 0U);
+  const auto spans = spansOf<PastTheEnd>();
+  const auto barrels = barrelLayerBits<PastTheEnd>();
+  BOOST_TEST(barrels == 0b111U);
+  // Layer 1 at r 4 over |z| 1: from z 0.9 at r 2 to z 1.9 at r 8 the segment
+  // is at z 1.23 there; at z 0 throughout it crosses.
+  BOOST_TEST(!segmentLeavesHole(0b010U, barrels, spans.data(), 2.F, 0.9F, 8.F, 1.9F));
+  BOOST_TEST(segmentLeavesHole(0b010U, barrels, spans.data(), 2.F, 0.F, 8.F, 0.F));
+  // From z 0.9 the segments reaching z beyond 1.2 at r 8 pass; the check
+  // keeps the source. From z 0 layer 1's shadow is |z| 3, past layer 2's 2.
+  BOOST_TEST(directPairPossible(0b010U, barrels, spans.data(), 2, 2.F, 0.9F, spans[2].low, spans[2].high));
+  BOOST_TEST(!directPairPossible(0b010U, barrels, spans.data(), 2, 2.F, 0.F, spans[2].low, spans[2].high));
+}
+
+/// The per-source check refuses only sources with no direct pair, on a
+/// barrel toy and on barrels with discs; and it does refuse some.
+BOOST_AUTO_TEST_CASE(ThePerSourceCheckNeverRefusesADirectPair)
+{
+  const auto [toyRefused, toyChecked] = checkEveryDirectPairIsPossible<PastTheEnd>();
+  BOOST_TEST(toyRefused > 0U);
+  BOOST_TEST(toyRefused < toyChecked);
+  const auto [mixedRefused, mixedChecked] = checkEveryDirectPairIsPossible<ToyBarrel4Disc8>();
+  BOOST_TEST(mixedRefused > 0U);
+  BOOST_TEST(mixedRefused < mixedChecked);
+}
+
+/// Without skips a link whose pairs can cross a layer is queried only at that
+/// layer's ends: it does not size a layer a link without holes enters. With
+/// skips every source queries it, and it does.
+BOOST_AUTO_TEST_CASE(EdgeOnlyLinksDoNotSizeTheGrid)
+{
+  SearchWindowParams windows;
+  windows.minPtGeV = 0.2;
+  windows.bzKiloGauss = 20.;
+  const IterationSettings without{.windows = windows, .minClusters = 2, .skipLinks = false, .follow = false};
+  const IterationSettings with{.windows = windows, .minClusters = 2, .skipLinks = true, .follow = false};
+  const auto noSkips = gridLayerWindows<PastTheEnd>(std::span<const IterationSettings>{&without, 1U}, VertexConstraint{});
+  const auto skips = gridLayerWindows<PastTheEnd>(std::span<const IterationSettings>{&with, 1U}, VertexConstraint{});
+  const auto adjacent = layerPairWindow<PastTheEnd>(1, 2, windows, VertexConstraint{});
+  const auto skipping = layerPairWindow<PastTheEnd>(0, 2, windows, VertexConstraint{});
+  BOOST_REQUIRE(skipping.phiHalfWidth > adjacent.phiHalfWidth);
+  BOOST_TEST(noSkips[2].phiHalfWidth == static_cast<double>(adjacent.phiHalfWidth));
+  BOOST_TEST(skips[2].phiHalfWidth == static_cast<double>(skipping.phiHalfWidth));
+}
+
+BOOST_AUTO_TEST_CASE(SegmentsCrossBarrelsAndDiscsWithinTheirExtent)
+{
+  BOOST_TEST(segmentCrosses(true, {.position = 4.F, .low = -1.F, .high = 1.F}, 2.F, 0.F, 8.F, 0.F));
+  BOOST_TEST(!segmentCrosses(true, {.position = 4.F, .low = -1.F, .high = 1.F}, 2.F, 0.9F, 8.F, 3.9F));
+  BOOST_TEST(segmentCrosses(false, {.position = 10.F, .low = 3.F, .high = 20.F}, 2.F, 5.F, 12.F, 15.F));
+  BOOST_TEST(!segmentCrosses(false, {.position = 10.F, .low = 3.F, .high = 20.F}, 1.F, 5.F, 2.5F, 15.F));
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testMathUtils.cxx b/Detectors/GenericTracking/tracking/test/testMathUtils.cxx
new file mode 100644
index 0000000000000..33f87118d1e0e
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testMathUtils.cxx
@@ -0,0 +1,75 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testMathUtils.cxx
+/// \brief Exercises scalar helpers shared by the tracking code.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK MathUtils
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/MathUtils.h"
+
+#include "CommonConstants/MathConstants.h"
+
+#include <bit>
+#include <cmath>
+#include <cstdint>
+#include <type_traits>
+
+namespace o2::gtrk
+{
+
+BOOST_AUTO_TEST_CASE(TransverseArcHasTheStraightAndCurvedLimits)
+{
+  static_assert(std::is_same_v<decltype(transverseArcAtRadius(1.F, 2.F)), float>);
+  static_assert(std::is_same_v<decltype(transverseArcAtRadius(1., 2.)), double>);
+
+  BOOST_TEST(transverseArcAtRadius(0., 4.) == 4.);
+  BOOST_TEST(transverseArcAtRadius(-1., 4.) == 4.);
+
+  constexpr double curvature = 0.2;
+  constexpr double radius = 4.;
+  const double expected = 2. * std::asin(0.5 * curvature * radius) / curvature;
+  BOOST_TEST(transverseArcAtRadius(curvature, radius) == expected, boost::test_tools::tolerance(1e-14));
+}
+
+/// The quotient from one asin with its derivative is, bit for bit, the
+/// quotient alone, on both sides of the
+/// series' switch and at the ends.
+BOOST_AUTO_TEST_CASE(AsinOverArgumentWithDerivativeIsTheQuotient)
+{
+  int mismatches = 0;
+  for (int i = -20000; i <= 20000; ++i) {
+    const float x = static_cast<float>(i) / 20000.F;
+    const auto both = detail::asinOverArgumentWithDerivative(x);
+    mismatches += std::bit_cast<std::uint32_t>(both.value) != std::bit_cast<std::uint32_t>(detail::asinOverArgument(x)) ? 1 : 0;
+  }
+  for (const float x : {0.05F, -0.05F, std::nextafter(0.05F, 0.F), 1.F, -1.F}) {
+    const auto both = detail::asinOverArgumentWithDerivative(x);
+    mismatches += std::bit_cast<std::uint32_t>(both.value) != std::bit_cast<std::uint32_t>(detail::asinOverArgument(x)) ? 1 : 0;
+  }
+  BOOST_TEST(mismatches == 0);
+}
+
+BOOST_AUTO_TEST_CASE(ChiSquareQuantilesMatchKnownValues)
+{
+  // Three degrees of freedom at the 68.27 percent and 99.73 percent
+  // two-sided Gaussian confidence levels.
+  BOOST_TEST(chiSquareQuantile(3, 1.) == 3.5267, boost::test_tools::tolerance(1.e-4));
+  BOOST_TEST(chiSquareQuantile(3, 3.) == 14.1564, boost::test_tools::tolerance(1.e-4));
+  // One degree of freedom is n^2 exactly; twenty was checked by numerical
+  // integration of the density.
+  BOOST_TEST(chiSquareQuantile(1, 3.) == 9., boost::test_tools::tolerance(1.e-6));
+  BOOST_TEST(chiSquareQuantile(20, 3.) == 42.0802, boost::test_tools::tolerance(1.e-4));
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testMeasurementGrid.cxx b/Detectors/GenericTracking/tracking/test/testMeasurementGrid.cxx
new file mode 100644
index 0000000000000..72b97807bd824
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testMeasurementGrid.cxx
@@ -0,0 +1,784 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testMeasurementGrid.cxx
+/// \brief Grid construction, ordering and candidate lookup contracts.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK MeasurementGrid
+#include <boost/test/unit_test.hpp>
+#include <numbers>
+
+#include "GenericTracking/Base/Geometry.h"
+#include "ToyBarrel4Disc8.h"
+#include "ToyBarrel3.h"
+#include "GenericTracking/Tracking/GridSizing.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/MeasurementGrid.h"
+#include "GenericTracking/Tracking/MeasurementGridBuilder.h"
+
+#include "GridTestSupport.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+#include <limits>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using Toy = detectors::ToyBarrel3;
+using Mixed = detectors::ToyBarrel4Disc8;
+using GeometryGrid = GridGeometry<Toy>;
+using Grid = MeasurementGrid<Toy>;
+
+/// Every layer \a phi x \a second cells, whatever the windows.
+GridParams fixedCellParams(std::int64_t blockWidthPS, std::int32_t phi, std::int32_t second)
+{
+  auto params = test::withToyFrames(GridParams{});
+  params.blockWidth = blockWidthPS;
+  for (std::size_t layer = 0; layer < GridParams::kMaxLayers; ++layer) {
+    params.phiBins[layer] = phi;
+    params.secondBins[layer] = second;
+  }
+  return params;
+}
+
+GridParams oneCellParams(std::int64_t blockWidthPS) { return fixedCellParams(blockWidthPS, 1, 1); }
+
+/// The windows of one iteration with the default window physics.
+auto defaultWindows() { return test::oneIterationWindows<Toy>(SearchWindowParams{}, VertexConstraint{}); }
+
+/// Grid one row per point, all in the box [0, 1 ps), and return the positions in
+/// \a points of the rows a query on \a target visits.
+template <DetectorLayout Det, std::size_t N>
+std::vector<std::uint32_t> visitedPoints(const GridGeometry<Det>& geometry, LayerID target, const std::array<GridPoint, N>& points, const CandidateWindow& window)
+{
+  std::vector<std::uint32_t> offsets(static_cast<std::size_t>(geometry.bucketCount()) + 1U);
+  MeasurementStore columns;
+  resizeMeasurementColumns(columns, N);
+  test::buildGridRows(
+    N, offsets, [&](std::size_t i) { return geometry.bucketAt(points[i].layer, 0U, points[i].phi, points[i].second); },
+    [&](std::size_t i, std::uint32_t row) {
+      columns.widthPS[row] = 1U;
+      columns.clusterIndex[row] = static_cast<std::uint32_t>(i);
+    });
+
+  const MeasurementGrid<Det> grid{measurementView(columns), geometry, std::span<const std::uint32_t>{offsets}};
+  std::vector<std::uint32_t> visited;
+  grid.visitCandidates(target, window, geometry.allBlocks(), [&](std::uint32_t row) { visited.push_back(columns.clusterIndex[row]); });
+  std::ranges::sort(visited);
+  return visited;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(VertexConstraintMovesAndWidensThePairWindow)
+{
+  SearchWindowParams params;
+  params.minPtGeV = 1.;
+  params.materialX2X0 = 0.;
+  params.positionSigma = 0.;
+  params.nSigma = 1.;
+
+  const VertexConstraint pointVertex{.z = 1.5, .sigmaZ = 0.};
+  const auto pointWindow = layerPairWindow<Toy>(0, 1, params, pointVertex);
+
+  BOOST_TEST(pointWindow.secondScale == 2.F, boost::test_tools::tolerance(1e-6F));
+  BOOST_TEST(pointWindow.secondOffset == -1.5F, boost::test_tools::tolerance(1e-6F));
+  // With every Gaussian term zero, the measured-radius spread and the
+  // difference between radial and arc-length extrapolation remain.
+  const auto expectedHalfWidth = conservativeScalarBound(secondCentreSpread<Toy>(0, 1, pointVertex.z) + helixSecondSpread<Toy>(0, 1, params, pointVertex));
+  BOOST_TEST(pointWindow.secondHalfWidth == expectedHalfWidth);
+  BOOST_TEST(secondCentreSpread<Toy>(0, 1, pointVertex.z) > 0.);
+
+  const auto candidate = candidateWindow(pointWindow, test::toyTimeBox(100.), (2 * std::numbers::pi_v<Scalar>)-0.1F, 2.F, 2.F, 41'000U);
+  BOOST_TEST(candidate.phiCentre == (2 * std::numbers::pi_v<Scalar>)-0.1F, boost::test_tools::tolerance(1e-6F));
+  BOOST_TEST(candidate.secondCentre == 2.5F, boost::test_tools::tolerance(1e-6F));
+
+  const VertexConstraint broadVertex{.z = 1.5, .sigmaZ = 1.};
+  const auto broadWindow = layerPairWindow<Toy>(0, 1, params, broadVertex);
+  BOOST_TEST(broadWindow.secondHalfWidth > pointWindow.secondHalfWidth);
+
+  constexpr LayerID kFirstPositiveDisc = 8;
+  constexpr LayerID kSecondPositiveDisc = 9;
+  const auto centralDiscWindow = layerPairWindow<Mixed>(kFirstPositiveDisc, kSecondPositiveDisc, params, VertexConstraint{.z = 0., .sigmaZ = 0.});
+  const auto displacedDiscWindow = layerPairWindow<Mixed>(kFirstPositiveDisc, kSecondPositiveDisc, params, VertexConstraint{.z = 10., .sigmaZ = 0.});
+  // The lever arm between the discs' measured positions (26 / 22 cm nominal,
+  // moved by their rings' offsets), from the vertex.
+  const double first = discZ<Mixed>(kFirstPositiveDisc);
+  const double second = discZ<Mixed>(kSecondPositiveDisc);
+  BOOST_TEST(centralDiscWindow.secondScale == static_cast<Scalar>(second / first), boost::test_tools::tolerance(1e-6F));
+  BOOST_TEST(displacedDiscWindow.secondScale == static_cast<Scalar>((second - 10.) / (first - 10.)), boost::test_tools::tolerance(1e-6F));
+  BOOST_TEST(displacedDiscWindow.secondScale > centralDiscWindow.secondScale);
+}
+
+/// A barrel <-> disc window is the hull of the lines from the ends of the
+/// vertex range through the seed, evaluated per seed.
+BOOST_AUTO_TEST_CASE(CrossingWindowFollowsTheSeed)
+{
+  SearchWindowParams params;
+  params.minPtGeV = 1.;
+  params.materialX2X0 = 0.;
+  params.positionSigma = 0.;
+  params.nSigma = 3.;
+  // A vertex range of +-3 cm.
+  const VertexConstraint beamSpot{.z = 0., .sigmaZ = 1.};
+  const auto seed = test::toyTimeBox(0.);
+  constexpr LayerID kInnermostBarrel = 0;
+  constexpr LayerID kOuterBarrel = 3;
+  constexpr LayerID kFirstPositiveDisc = 8;
+
+  // Barrel 0 -> the +22 cm disc: r_j = r_i (Z - z_v) / (z_i - z_v).
+  const auto toDisc = layerPairWindow<Mixed>(kInnermostBarrel, kFirstPositiveDisc, params, beamSpot);
+  BOOST_TEST((toDisc.kind == PairKind::kBarrelToDisc));
+  const double zLow = zMin<Mixed>(kFirstPositiveDisc);
+  const double zHigh = zMax<Mixed>(kFirstPositiveDisc);
+  // With the Gaussian terms zero, the padding is the helix's reach alone.
+  const double helix = helixSecondSpread<Mixed>(kInnermostBarrel, kFirstPositiveDisc, params, beamSpot);
+  BOOST_TEST(helix > 0.);
+  const auto far = candidateWindow(toDisc, seed, 0.F, 3.F, 10.F, seed.width);
+  const double expectedLow = (3. * (zLow + 3.) / (10. + 3.)) - helix;
+  const double expectedHigh = (3. * (zHigh - 3.) / (10. - 3.)) + helix;
+  BOOST_TEST(static_cast<double>(far.secondCentre - far.secondHalfWidth) == expectedLow, boost::test_tools::tolerance(1e-5));
+  BOOST_TEST(static_cast<double>(far.secondCentre + far.secondHalfWidth) == expectedHigh, boost::test_tools::tolerance(1e-5));
+  // a part of the disc, not all of it
+  BOOST_TEST(static_cast<double>(far.secondHalfWidth) < 0.1 * (secondMax<Mixed>(kFirstPositiveDisc) - secondMin<Mixed>(kFirstPositiveDisc)));
+
+  // A seed level with the vertex range sends tracks at any radius: the window
+  // opens to the disc's outer edge.
+  const auto near = candidateWindow(toDisc, seed, 0.F, 3.F, 2.9F, seed.width);
+  BOOST_TEST(static_cast<double>(near.secondCentre + near.secondHalfWidth) == secondMax<Mixed>(kFirstPositiveDisc) + helix, boost::test_tools::tolerance(1e-5));
+  BOOST_TEST(static_cast<double>(near.secondCentre - near.secondHalfWidth) == (3. * (zLow + 3.) / (static_cast<double>(2.9F) + 3.)) - helix, boost::test_tools::tolerance(1e-5));
+
+  // The +22 cm disc -> barrel layer 3: z_j = z_v + (z_i - z_v) R / r_i.
+  const auto toBarrel = layerPairWindow<Mixed>(kFirstPositiveDisc, kOuterBarrel, params, beamSpot);
+  BOOST_TEST((toBarrel.kind == PairKind::kDiscToBarrel));
+  const auto back = candidateWindow(toBarrel, seed, 0.F, 14.F, 22.F, seed.width);
+  const double rLow = radiusMin<Mixed>(kOuterBarrel);
+  const double rHigh = radiusMax<Mixed>(kOuterBarrel);
+  const double backHelix = helixSecondSpread<Mixed>(kFirstPositiveDisc, kOuterBarrel, params, beamSpot);
+  BOOST_TEST(static_cast<double>(back.secondCentre - back.secondHalfWidth) == 3. + (19. * rLow / 14.) - backHelix, boost::test_tools::tolerance(1e-5));
+  BOOST_TEST(static_cast<double>(back.secondCentre + back.secondHalfWidth) == -3. + (25. * rHigh / 14.) + backHelix, boost::test_tools::tolerance(1e-5));
+}
+
+BOOST_AUTO_TEST_CASE(GridPointUsesThePlacedSensor)
+{
+  const auto geometry = toyGeometry<Toy>();
+  constexpr SensorID kSensor = 5;
+  constexpr double kLoc0 = 0.2;
+  constexpr double kLoc1 = -0.4;
+
+  const auto point = gridPoint<Toy>(geometry, kSensor, kLoc0, kLoc1);
+  const double local[3] = {kLoc0, kLoc1, 0.};
+  double global[3] = {};
+  geometry.toGlobal(kSensor, local, global);
+  double expectedPhi = std::atan2(global[1], global[0]);
+  if (expectedPhi < 0.) {
+    expectedPhi += 2 * std::numbers::pi_v<double>;
+  }
+
+  BOOST_TEST(point.layer == geometry.sensor(kSensor).layer);
+  BOOST_TEST(point.phi == static_cast<Scalar>(expectedPhi), boost::test_tools::tolerance(1e-6F));
+  BOOST_TEST(point.second == static_cast<Scalar>(global[2]), boost::test_tools::tolerance(1e-6F));
+
+  // The shipped position is the double transform narrowed once, and the grid
+  // coordinates come from those floats, exactly as the tracker derives them.
+  BOOST_TEST(std::bit_cast<std::uint32_t>(point.x) == std::bit_cast<std::uint32_t>(static_cast<Scalar>(global[0])));
+  BOOST_TEST(std::bit_cast<std::uint32_t>(point.y) == std::bit_cast<std::uint32_t>(static_cast<Scalar>(global[1])));
+  BOOST_TEST(std::bit_cast<std::uint32_t>(point.z) == std::bit_cast<std::uint32_t>(static_cast<Scalar>(global[2])));
+  BOOST_TEST(std::bit_cast<std::uint32_t>(point.phi) == std::bit_cast<std::uint32_t>(azimuth(point.x, point.y)));
+  BOOST_TEST(std::bit_cast<std::uint32_t>(point.second) == std::bit_cast<std::uint32_t>(secondCoordinate<Toy>(point.layer, point.r, point.z)));
+  BOOST_TEST(std::bit_cast<std::uint32_t>(point.r) == std::bit_cast<std::uint32_t>(o2::gpu::CAMath::Hypot(point.x, point.y)));
+}
+
+/// A bin comes from a range check, then the conversion: a NaN or an infinite
+/// window edge must land in an edge cell on every platform, not wherever an
+/// out-of-range float-to-int conversion happens to go (INT_MIN on x86).
+BOOST_AUTO_TEST_CASE(BinsClampBeforeConverting)
+{
+  constexpr std::int32_t kCount = 10;
+  BOOST_TEST(clampedBin(std::numeric_limits<float>::quiet_NaN(), kCount) == 0);
+  BOOST_TEST(clampedBin(-std::numeric_limits<float>::infinity(), kCount) == 0);
+  BOOST_TEST(clampedBin(-0.5F, kCount) == 0);
+  BOOST_TEST(clampedBin(0.F, kCount) == 0);
+  BOOST_TEST(clampedBin(3.7F, kCount) == 3);
+  BOOST_TEST(clampedBin(9.999F, kCount) == 9);
+  BOOST_TEST(clampedBin(10.F, kCount) == 9);
+  BOOST_TEST(clampedBin(3.e9F, kCount) == 9);
+  BOOST_TEST(clampedBin(std::numeric_limits<float>::infinity(), kCount) == 9);
+  BOOST_TEST(clampedBin(std::numeric_limits<double>::quiet_NaN(), kCount) == 0);
+  BOOST_TEST(clampedBin(1.e300, kCount) == 9);
+}
+
+BOOST_AUTO_TEST_CASE(GridGeometryMapsBlocksBucketsAndSlices)
+{
+  auto params = test::withToyFrames(GridParams{});
+  params.blockWidth = 10'000;
+  const auto geometry = test::cappedGrid<Toy>(25., params, SearchWindowParams{}, VertexConstraint{}, 8, 4);
+
+  BOOST_TEST(geometry.blockCount() == 3);
+  BOOST_TEST(geometry.blockOfPS(-1'000) == 0);
+  BOOST_TEST(geometry.blockOfPS(0) == 0);
+  BOOST_TEST(geometry.blockOfPS(9'999) == 0);
+  BOOST_TEST(geometry.blockOfPS(10'000) == 1);
+  BOOST_TEST(geometry.blockOfPS(25'000) == 2);
+  BOOST_TEST(geometry.blocksPerSlice(0) == geometry.blockCount());
+  BOOST_TEST(geometry.blocksPerSlice(10'010) == 2);
+
+  const auto firstLayerCells = geometry.axes(0).cellCount();
+  BOOST_TEST(geometry.layerBucketBase(0) == 0U);
+  BOOST_TEST(geometry.layerBucketBase(1) == static_cast<std::uint32_t>(geometry.blockCount() * firstLayerCells));
+  BOOST_TEST(geometry.bucket(0, 1, 0, 0) == static_cast<std::uint32_t>(firstLayerCells));
+
+  const auto slice = geometry.slice({.begin = 1, .end = 2}, 10'010);
+  BOOST_TEST(slice.core.begin == 1);
+  BOOST_TEST(slice.core.end == 2);
+  BOOST_TEST(slice.halo.begin == 0);
+  BOOST_TEST(slice.halo.end == 3);
+}
+
+BOOST_AUTO_TEST_CASE(PerLayerCountsOverrideTheDerivedOnes)
+{
+  // A layer's own counts, 0 for the derived.
+  auto params = test::withToyFrames(GridParams{});
+  params.blockWidth = 10'000;
+  const GeometryGrid derived{25'000, params, defaultWindows()};
+  params.phiBins[1] = 3;
+  params.secondBins[1] = 5;
+  params.secondBins[2] = 135;
+  const GeometryGrid overridden{25'000, params, defaultWindows()};
+
+  BOOST_TEST(overridden.axes(0).nPhi == derived.axes(0).nPhi);
+  BOOST_TEST(overridden.axes(0).nSecond == derived.axes(0).nSecond);
+  BOOST_TEST(overridden.axes(1).nPhi == 3);
+  BOOST_TEST(overridden.axes(1).nSecond == 5);
+  BOOST_TEST(overridden.axes(2).nPhi == derived.axes(2).nPhi);
+  BOOST_TEST(overridden.axes(2).nSecond == 135);
+  BOOST_TEST(overridden.layerBucketBase(2) == static_cast<std::uint32_t>(overridden.blockCount() * (overridden.axes(0).cellCount() + 15)));
+  BOOST_TEST(!overridden.overflows());
+
+  // More buckets than a 32-bit bucket number: flagged, never wrapped.
+  params.phiBins[0] = 1 << 16;
+  params.secondBins[0] = 1 << 16;
+  const GeometryGrid huge{25'000, params, defaultWindows()};
+  BOOST_TEST(huge.overflows());
+}
+
+namespace
+{
+/// Per link, the most layers a path through it visits, every path walked
+/// one by one: the predicate's two sweeps checked by brute force.
+template <DetectorLayout Det>
+std::array<int, nLinks<Det>> longestPathsThrough()
+{
+  std::array<int, nLinks<Det>> longest{};
+  std::vector<std::vector<std::size_t>> paths;
+  paths.reserve(nLinks<Det>);
+  for (std::size_t link = 0; link < nLinks<Det>; ++link) {
+    paths.push_back({link});
+  }
+  while (!paths.empty()) {
+    const auto path = std::move(paths.back());
+    paths.pop_back();
+    for (const auto link : path) {
+      longest[link] = std::max(longest[link], static_cast<int>(path.size()) + 1);
+    }
+    for (std::size_t next = 0; next < nLinks<Det>; ++next) {
+      if (Det::layerLinks[next].from == Det::layerLinks[path.back()].to) {
+        auto longer = path;
+        longer.push_back(next);
+        paths.push_back(std::move(longer));
+      }
+    }
+  }
+  return longest;
+}
+} // namespace
+
+BOOST_AUTO_TEST_CASE(TheLinkPredicateFollowsSkipsMaskAndPathLength)
+{
+  // One predicate for the stages' link lists and the grid's sizing.
+  const auto all = takenLinks<Mixed>(IterationSettings{.windows = {}, .minClusters = 2});
+  const auto noSkips = takenLinks<Mixed>(IterationSettings{.windows = {}, .minClusters = 2, .skipLinks = false});
+  const auto inner = takenLinks<Mixed>(IterationSettings{.windows = {}, .minClusters = 2, .layerMask = 0b111U});
+  const auto none = takenLinks<Mixed>(IterationSettings{.windows = {}, .minClusters = 2, .layerMask = 0b1U}); // a single layer: no link has both ends in it
+  for (std::size_t link = 0; link < nLinks<Mixed>; ++link) {
+    const auto& pair = Mixed::layerLinks[link];
+    BOOST_TEST_CONTEXT("link " << link)
+    {
+      BOOST_TEST(all[link]);
+      BOOST_TEST(noSkips[link] == !pair.skipsLayer);
+      BOOST_TEST(inner[link] == (pair.from < 3U && pair.to < 3U));
+      BOOST_TEST(!none[link]);
+    }
+  }
+  // A link is taken only on a path of minClusters layers or more:
+  // every length from 2 to one past the
+  // longest path, which takes none.
+  const auto longest = longestPathsThrough<Mixed>();
+  for (int length = 2; std::cmp_less_equal(length, maxChainLayers<Mixed> + 1U); ++length) {
+    const auto taken = takenLinks<Mixed>(IterationSettings{.windows = {}, .minClusters = length});
+    for (std::size_t link = 0; link < nLinks<Mixed>; ++link) {
+      BOOST_TEST_CONTEXT("length " << length << ", link " << link) { BOOST_TEST(taken[link] == (longest[link] >= length)); }
+    }
+  }
+  // Within a mask, the paths are the mask's: the three innermost layers
+  // hold a triplet's three on the one path 0 -> 1 -> 2, and no more; the
+  // link 0 -> 2 past layer 1's end is on none.
+  const auto triplets = takenLinks<Mixed>(IterationSettings{.windows = {}, .minClusters = 3, .layerMask = 0b111U});
+  for (std::size_t link = 0; link < nLinks<Mixed>; ++link) {
+    const auto& pair = Mixed::layerLinks[link];
+    BOOST_TEST_CONTEXT("link " << link) { BOOST_TEST(triplets[link] == (inner[link] && pair.to == pair.from + 1U)); }
+  }
+  BOOST_TEST(std::ranges::none_of(takenLinks<Mixed>(IterationSettings{.windows = {}, .minClusters = 4, .layerMask = 0b111U}), std::identity{}));
+}
+
+BOOST_AUTO_TEST_CASE(ALayerIsSizedByTheQueriesIntoIt)
+{
+  const VertexConstraint beam{.z = 0., .sigmaZ = 6., .sigmaTransverse = 0.002};
+  const SearchWindowParams low{.minPtGeV = 0.1, .bzKiloGauss = 5.};
+  const SearchWindowParams high{.minPtGeV = 1., .bzKiloGauss = 5.};
+  const auto pair = [&](LayerID from, LayerID to, const SearchWindowParams& windows) { return layerPairWindow<Toy>(from, to, windows, beam); };
+  const auto sizes = [&](std::initializer_list<IterationSettings> iterations) {
+    const std::vector<IterationSettings> list{iterations};
+    return gridLayerWindows<Toy>(list, beam);
+  };
+
+  // Tracklet queries only: into each link's target; layer 0 is not searched
+  // and has one cell per axis.
+  const auto tracklets = sizes({IterationSettings{.windows = low, .minClusters = 3, .follow = false}});
+  BOOST_TEST(!tracklets[0].queried);
+  BOOST_TEST(tracklets[1].queried);
+  BOOST_TEST(tracklets[1].phiHalfWidth == static_cast<double>(pair(0, 1, low).phiHalfWidth));
+  BOOST_TEST(tracklets[2].secondHalfWidth == static_cast<double>(pair(1, 2, low).secondHalfWidth));
+  const GeometryGrid grid{25'000, test::withToyFrames(GridParams{.blockWidth = 10'000}), tracklets};
+  BOOST_TEST(grid.axes(0).nPhi == 1);
+  BOOST_TEST(grid.axes(0).nSecond == 1);
+  BOOST_TEST(grid.axes(1).nPhi == derivedBinCount(2 * std::numbers::pi_v<double>, 2. * tracklets[1].phiHalfWidth, kPhiCellsPerWindow));
+  BOOST_TEST(!grid.overflows());
+
+  // An iteration that follows also searches inward: layer 0 along 0 -> 1,
+  // and layer 1 by the wider of its two queries.
+  const auto extending = sizes({IterationSettings{.windows = low, .minClusters = 3, .follow = true}});
+  BOOST_TEST(extending[0].queried);
+  BOOST_TEST(extending[0].phiHalfWidth == static_cast<double>(pair(0, 1, low).phiHalfWidth));
+  BOOST_TEST(extending[1].phiHalfWidth == std::max(static_cast<double>(pair(0, 1, low).phiHalfWidth), static_cast<double>(pair(1, 2, low).phiHalfWidth)));
+
+  // A link only a high-pT iteration takes is sized at that pT; the low-pT one
+  // takes only 0 -> 1 (its mask), so layer 1 is sized at its pT.
+  const auto mixed = sizes({IterationSettings{.windows = high, .minClusters = 3, .follow = false}, IterationSettings{.windows = low, .minClusters = 2, .layerMask = 0b011U, .follow = false}});
+  BOOST_TEST(mixed[2].phiHalfWidth == static_cast<double>(pair(1, 2, high).phiHalfWidth));
+  BOOST_TEST(mixed[1].phiHalfWidth == static_cast<double>(pair(0, 1, low).phiHalfWidth));
+  BOOST_TEST(mixed[1].phiHalfWidth > static_cast<double>(pair(0, 1, high).phiHalfWidth));
+
+  // A layer the mask excludes from every link: not searched, one cell.
+  const auto masked = sizes({IterationSettings{.windows = low, .minClusters = 2, .layerMask = 0b011U, .follow = false}});
+  BOOST_TEST(!masked[2].queried);
+  const GeometryGrid maskedGrid{25'000, test::withToyFrames(GridParams{.blockWidth = 10'000}), masked};
+  BOOST_TEST(maskedGrid.axes(2).cellCount() == 1);
+
+  // The same roads with the follow, which walks every link of the layout:
+  // layer 2 is searched, in the 1 -> 2 pair window.
+  const auto followed = sizes({IterationSettings{.windows = low, .minClusters = 2, .layerMask = 0b011U, .follow = true}});
+  BOOST_TEST(followed[2].queried);
+  BOOST_TEST(followed[2].phiHalfWidth == static_cast<double>(pair(1, 2, low).phiHalfWidth));
+  BOOST_TEST(followed[0].phiHalfWidth == static_cast<double>(pair(0, 1, low).phiHalfWidth));
+}
+
+/// Queries of several widths: phi cells
+/// balanced between the narrowest and the widest, the convention itself for
+/// one width; the second coordinate's by the narrowest.
+BOOST_AUTO_TEST_CASE(CellsServeTheNarrowestAndTheWidestQuery)
+{
+  // One width: the convention.
+  BOOST_TEST(balancedBinCount(2 * std::numbers::pi_v<double>, 0.2, 0.2, kPhiCellsPerWindow) == derivedBinCount(2 * std::numbers::pi_v<double>, 0.2, kPhiCellsPerWindow));
+  BOOST_TEST(balancedBinCount(2 * std::numbers::pi_v<double>, 0., 0.2, kPhiCellsPerWindow) == derivedBinCount(2 * std::numbers::pi_v<double>, 0.2, kPhiCellsPerWindow));
+  // Two widths: between their conventions, each exceeding it by the same factor.
+  const double a = 0.01;
+  const double b = 0.4;
+  const double c = kPhiCellsPerWindow;
+  const auto count = balancedBinCount(2 * std::numbers::pi_v<double>, a, b, c);
+  BOOST_TEST(count > derivedBinCount(2 * std::numbers::pi_v<double>, b, c));
+  BOOST_TEST(count < derivedBinCount(2 * std::numbers::pi_v<double>, a, c));
+  const double w = (2 * std::numbers::pi_v<double>) / count;
+  const double rows = (1. + (w / a)) / (1. + (1. / c));
+  const double cells = ((b / w) + 1.) / (c + 1.);
+  BOOST_TEST(std::abs(rows - cells) < 0.1 * rows);
+  // With c = 1, the geometric mean.
+  BOOST_TEST(balancedBinCount(1., 0.01, 0.04, 1.) == derivedBinCount(1., 0.02, 1.));
+
+  std::array<GridLayerWindow, 3> windows{};
+  for (auto& window : windows) {
+    window = {.phiHalfWidth = 0.2, .secondHalfWidth = 2., .queried = true, .narrowPhiHalfWidth = 0.005, .narrowSecondHalfWidth = 0.5};
+  }
+  const GeometryGrid grid{25'000, test::withToyFrames(GridParams{.blockWidth = 10'000}), windows};
+  BOOST_TEST(grid.axes(1).nPhi == balancedBinCount(2 * std::numbers::pi_v<double>, 0.01, 0.4, kPhiCellsPerWindow));
+  const double extent = secondMax<Toy>(1) - secondMin<Toy>(1);
+  BOOST_TEST(grid.axes(1).nSecond == derivedBinCount(extent, 1., kSecondCellsPerWindow));
+}
+
+BOOST_AUTO_TEST_CASE(CountsPastTheNumberingAreRefusedNotWrapped)
+{
+  BOOST_TEST(derivedBinCount(1., 0.5, 2.) == 4);
+  BOOST_TEST(derivedBinCount(1., 1.e-12, 1.) == 0); // 10^12 cells: past int32, refused
+  // A derived count past int32: the layout is refused, every axis still one
+  // cell or more.
+  std::array<GridLayerWindow, 3> tiny{};
+  for (auto& window : tiny) {
+    window = {.phiHalfWidth = 1.e-12, .secondHalfWidth = 1., .queried = true};
+  }
+  const GeometryGrid refused{25'000, test::withToyFrames(GridParams{.blockWidth = 10'000}), tiny};
+  BOOST_TEST(refused.overflows());
+  BOOST_TEST(refused.axes(0).nPhi >= 1);
+  // A block's cells past a 32-bit signed offset, from counts that each fit.
+  auto params = test::withToyFrames(GridParams{});
+  params.blockWidth = 10'000;
+  params.phiBins[0] = INT32_MAX;
+  params.secondBins[0] = 2;
+  const GeometryGrid cells{25'000, params, defaultWindows()};
+  BOOST_TEST(cells.overflows());
+}
+
+BOOST_AUTO_TEST_CASE(BuilderProducesPrefixOffsetsAndStablePlacements)
+{
+  std::array<std::uint32_t, 6> offsets{};
+  MeasurementGridBuilder builder{offsets};
+  constexpr std::array<std::uint32_t, 5> buckets{2U, 0U, 2U, 1U, 2U};
+  for (const auto bucket : buckets) {
+    builder.count(bucket);
+  }
+  builder.prefixSum();
+
+  std::array<std::uint32_t, buckets.size()> placements{};
+  for (std::size_t i = 0; i < buckets.size(); ++i) {
+    placements[i] = builder.place(buckets[i]);
+  }
+  builder.finish();
+
+  constexpr std::array<std::uint32_t, buckets.size()> expectedPlacements{2U, 0U, 3U, 1U, 4U};
+  constexpr std::array<std::uint32_t, 6> expectedOffsets{0U, 1U, 2U, 5U, 5U, 5U};
+  for (std::size_t i = 0; i < placements.size(); ++i) {
+    BOOST_TEST(placements[i] == expectedPlacements[i]);
+  }
+  for (std::size_t i = 0; i < offsets.size(); ++i) {
+    BOOST_TEST(offsets[i] == expectedOffsets[i]);
+  }
+  BOOST_TEST(offsets.back() == static_cast<std::uint32_t>(buckets.size()));
+}
+
+BOOST_AUTO_TEST_CASE(QueryWrapsPhiAcrossZero)
+{
+  auto params = test::withToyFrames(GridParams{});
+  params.blockWidth = 100'000;
+  for (std::size_t layer = 0; layer < GridParams::kMaxLayers; ++layer) {
+    params.phiBins[layer] = 8;
+    params.secondBins[layer] = 1;
+  }
+  const GeometryGrid geometry{100'000, params, defaultWindows()};
+  BOOST_REQUIRE(geometry.axes(1).nPhi == 8);
+
+  constexpr std::array<Scalar, 3> phis{0.01F, (2 * std::numbers::pi_v<Scalar>)-0.01F, std::numbers::pi_v<Scalar>};
+  constexpr std::array<std::uint32_t, 3> ids{10U, 11U, 12U};
+  std::vector<std::uint32_t> offsets(static_cast<std::size_t>(geometry.bucketCount()) + 1U);
+  MeasurementStore columns;
+  resizeMeasurementColumns(columns, phis.size());
+  test::buildGridRows(
+    phis.size(), offsets, [&](std::size_t i) { return geometry.bucketAt(1, 0U, phis[i], 0.F); },
+    [&](std::size_t i, std::uint32_t row) {
+      columns.widthPS[row] = 1U;
+      columns.clusterIndex[row] = ids[i];
+    });
+
+  const Grid grid{measurementView(columns), geometry, std::span<const std::uint32_t>{offsets}};
+  const CandidateWindow window{.phiCentre = 0.F, .phiHalfWidth = 0.1F, .secondCentre = 0.F, .secondHalfWidth = 2.F};
+  BOOST_TEST(spatiallyCompatible(window, (2 * std::numbers::pi_v<Scalar>)-0.01F, 0.F));
+  BOOST_TEST(!spatiallyCompatible(window, std::numbers::pi_v<Scalar>, 0.F));
+  BOOST_TEST(!spatiallyCompatible(window, 0.F, 3.F));
+  std::vector<std::uint32_t> visited;
+  grid.visitCandidates(1, window, geometry.allBlocks(), [&](std::uint32_t row) { visited.push_back(columns.clusterIndex[row]); });
+  std::ranges::sort(visited);
+
+  BOOST_REQUIRE(visited.size() == 2U);
+  BOOST_TEST(visited[0] == 10U);
+  BOOST_TEST(visited[1] == 11U);
+}
+
+BOOST_AUTO_TEST_CASE(QueryCoversEveryPhiCellWhenAWrappingWindowEndsInItsStartCell)
+{
+  auto params = test::withToyFrames(GridParams{});
+  params.blockWidth = 100'000;
+  for (std::size_t layer = 0; layer < GridParams::kMaxLayers; ++layer) {
+    params.phiBins[layer] = 3;
+    params.secondBins[layer] = 1;
+  }
+  const GeometryGrid geometry{100'000, params, defaultWindows()};
+  BOOST_REQUIRE(geometry.axes(1).nPhi == 3);
+
+  // Cells are 2pi/3 wide. A window of +-3 rad about 0.5 leaves out only
+  // (3.5, 3.78), so both of its ends fall in cell 1 -- yet it spans all
+  // three cells, including the seed's own direction in cell 0.
+  const CandidateWindow window{.phiCentre = 0.5F, .phiHalfWidth = 3.F, .secondCentre = 0.F, .secondHalfWidth = 100.F};
+  constexpr std::array<GridPoint, 3> points{{{.layer = 1, .phi = 0.5F, .second = 0.F}, {.layer = 1, .phi = 3.F, .second = 0.F}, {.layer = 1, .phi = 5.F, .second = 0.F}}};
+  for (const auto& point : points) {
+    BOOST_TEST(spatiallyCompatible(window, point.phi, point.second));
+  }
+
+  const auto visited = visitedPoints(geometry, 1, points, window);
+  BOOST_TEST(visited == (std::vector<std::uint32_t>{0U, 1U, 2U}), boost::test_tools::per_element());
+}
+
+BOOST_AUTO_TEST_CASE(QueryReachesDiscSensorCornersBeyondTheRingEdge)
+{
+  const auto placement = toyGeometry<Mixed>();
+  constexpr std::size_t kPositiveDisc = 4;
+  constexpr auto kDisc = static_cast<LayerID>(Detector<Mixed>::nBarrelLayers + kPositiveDisc);
+  const auto& ring = Mixed::discSpecs[kPositiveDisc].rings[1];
+  const auto& sensor = Mixed::discSpecs[kPositiveDisc].sensor;
+  const SensorID chip = firstSensorOfLayer<Mixed>(kDisc) + Mixed::discSpecs[kPositiveDisc].rings[0].nModules;
+  BOOST_REQUIRE(placement.sensor(chip).layer == kDisc);
+  BOOST_REQUIRE(std::abs(std::hypot(placement.sensor(chip).trans[0], placement.sensor(chip).trans[1]) - ring.r) < 1e-9);
+
+  // Just inside the outer ring's outer edge, at a corner: further out than the
+  // ring's nominal r + halfY, so the axis must not end there.
+  const double loc1 = sensor.halfY - 0.01;
+  const double loc0 = sensor.halfX - 0.01;
+  const auto point = gridPoint<Mixed>(placement, chip, loc0, loc1);
+  BOOST_REQUIRE(point.layer == kDisc);
+  BOOST_REQUIRE(static_cast<double>(point.second) > ring.r + sensor.halfY + 0.05);
+  BOOST_TEST(static_cast<double>(point.second) <= secondMax<Mixed>(kDisc));
+
+  // A window this narrow lies wholly beyond the nominal edge.
+  const CandidateWindow window{.phiCentre = point.phi, .phiHalfWidth = 0.01F, .secondCentre = point.second, .secondHalfWidth = 0.02F};
+  const GridGeometry<Mixed> geometry{100'000, test::withToyFrames(GridParams{.blockWidth = 100'000}), test::oneIterationWindows<Mixed>(SearchWindowParams{}, VertexConstraint{})};
+  const auto visited = visitedPoints(geometry, kDisc, std::array<GridPoint, 1>{point}, window);
+  BOOST_TEST(visited.size() == 1U);
+}
+
+BOOST_AUTO_TEST_CASE(QueryVisitsTheOverlappingBoxesInsideTheSearchBracket)
+{
+  const auto params = oneCellParams(100'000);
+  const GeometryGrid geometry{100'000, params, defaultWindows()};
+
+  // Boxes of 10 ps starting at 0, 5, 10 and 20; the seed's is [10, 20).
+  constexpr std::array<std::uint32_t, 4> starts{0U, 5U, 10U, 20U};
+  constexpr std::uint32_t kWidth = 10U;
+  std::vector<std::uint32_t> offsets(static_cast<std::size_t>(geometry.bucketCount()) + 1U);
+  const auto bucket = geometry.bucketAt(1, 0U, 0.F, 0.F);
+  MeasurementStore columns;
+  resizeMeasurementColumns(columns, starts.size());
+  test::buildGridRows(
+    starts.size(), offsets, [&](std::size_t) { return bucket; },
+    [&](std::size_t i, std::uint32_t row) {
+      columns.timePS[row] = starts[i];
+      columns.widthPS[row] = kWidth;
+      columns.clusterIndex[row] = static_cast<std::uint32_t>(i);
+    });
+
+  const Grid grid{measurementView(columns), geometry, std::span<const std::uint32_t>{offsets}};
+  const LayerPairWindow pair{.phiHalfWidth = std::numbers::pi_v<Scalar>, .secondHalfWidth = 2.F};
+  const auto window = candidateWindow(pair, TimeEstPS{.start = 10U, .width = kWidth}, 0.F, 0.F, 0.F, kWidth);
+  BOOST_TEST(window.earliestPS == 1);
+  BOOST_TEST(window.latestPS == 19);
+  std::vector<std::uint32_t> visited;
+  grid.visitCandidates(1, window, geometry.allBlocks(), [&](std::uint32_t row) { visited.push_back(columns.clusterIndex[row]); });
+
+  // [0, 10) ends where the seed starts; [20, 30) starts where it ends.
+  BOOST_TEST(visited == (std::vector<std::uint32_t>{1U, 2U}), boost::test_tools::per_element());
+}
+
+BOOST_AUTO_TEST_CASE(LanesShareAQueryAndVisitEachRowOnce)
+{
+  // A cell denser than the scan's limit (its bracket searched) and
+  // one under it (scanned); boxes of 10 ps every 5 ps.
+  const auto params = oneCellParams(100'000);
+  const GeometryGrid geometry{100'000, params, defaultWindows()};
+  for (const std::uint32_t rows : {40U, 5U}) {
+    std::vector<std::uint32_t> offsets(static_cast<std::size_t>(geometry.bucketCount()) + 1U);
+    const auto bucket = geometry.bucketAt(1, 0U, 0.F, 0.F);
+    MeasurementStore columns;
+    resizeMeasurementColumns(columns, rows);
+    test::buildGridRows(
+      rows, offsets, [&](std::size_t) { return bucket; },
+      [&](std::size_t i, std::uint32_t row) {
+        columns.timePS[row] = 5U * i;
+        columns.widthPS[row] = 10U;
+        columns.clusterIndex[row] = i;
+      });
+
+    const Grid grid{measurementView(columns), geometry, std::span<const std::uint32_t>{offsets}};
+    const LayerPairWindow pair{.phiHalfWidth = std::numbers::pi_v<Scalar>, .secondHalfWidth = 2.F};
+    const auto window = candidateWindow(pair, TimeEstPS{.start = 10U, .width = 60U}, 0.F, 0.F, 0.F, 10U);
+    std::vector<std::uint32_t> single;
+    grid.visitCandidates(1, window, geometry.allBlocks(), [&](std::uint32_t row) { single.push_back(columns.clusterIndex[row]); });
+    BOOST_TEST_REQUIRE(single.size() >= 2U);
+    for (const std::uint32_t count : {1U, 2U, 3U, 8U, 32U}) {
+      std::vector<std::uint32_t> shared;
+      for (std::uint32_t lane = 0; lane < count; ++lane) {
+        grid.visitCandidates(1, window, geometry.allBlocks(), [&](std::uint32_t row) { shared.push_back(columns.clusterIndex[row]); }, Lanes{.lane = lane, .count = count});
+      }
+      std::ranges::sort(shared);
+      BOOST_TEST(shared == single, boost::test_tools::per_element());
+    }
+  }
+}
+
+/// One lane of a group walking in step, on the host: the walk itself calls
+/// no collective, so a lane's calls can be recorded alone.
+template <std::uint32_t L>
+struct LaneOf {
+  static constexpr std::uint32_t kLanes = L;
+  std::uint32_t index = 0U;
+  [[nodiscard]] std::uint32_t lane() const { return index; }
+};
+
+template <std::uint32_t L>
+static void checkGroupInStep(const Grid& grid, const MeasurementStore& columns, const CandidateWindow& window, const GeometryGrid& geometry)
+{
+  std::size_t steps = 0U;
+  for (std::uint32_t lane = 0; lane < L; ++lane) {
+    std::vector<std::uint32_t> own;
+    grid.visitCandidates(1, window, geometry.allBlocks(), [&](std::uint32_t row) { own.push_back(columns.clusterIndex[row]); }, Lanes{.lane = lane, .count = L});
+    std::vector<std::uint32_t> inStep;
+    std::size_t calls = 0U;
+    grid.visitCandidates(
+      1, window, geometry.allBlocks(),
+      [&](std::uint32_t row, bool has) {
+        ++calls;
+        if (has) {
+          inStep.push_back(columns.clusterIndex[row]);
+        }
+      },
+      LaneOf<L>{.index = lane});
+    BOOST_TEST_CONTEXT("lanes " << L << ", lane " << lane)
+    {
+      BOOST_TEST(inStep == own, boost::test_tools::per_element());
+      if (lane == 0U) {
+        steps = calls;
+      }
+      BOOST_TEST(calls == steps);
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(AGroupInStepGivesEachLaneItsLanesRowsAtEveryStep)
+{
+  // Phi cells 6, 7 and then 0, 1 after the wrap in the window, cell
+  // 3 outside it, cell 7 empty; rows at the time bound's ends and a box
+  // ending exactly at afterPS. The window: earliest 1, latest 69, after 10.
+  const auto params = fixedCellParams(100'000, 8, 1);
+  const GeometryGrid geometry{100'000, params, defaultWindows()};
+  const Scalar cellWidth = 2.F * std::numbers::pi_v<Scalar> / 8.F;
+  // Per cell its rows' box starts (ascending) and the row count: a sparse
+  // set (the range scanned) and a dense one (each cell searched).
+  struct Row {
+    std::int32_t cell = 0;
+    std::uint32_t start = 0U;
+    std::uint32_t width = 10U;
+  };
+  const auto rowsOf = [](std::uint32_t perCell) {
+    std::vector<Row> rows;
+    for (const std::int32_t cell : {0, 1, 3, 6}) {
+      rows.push_back({.cell = cell, .start = 1U, .width = 9U}); // box ends at afterPS: not a candidate
+      for (std::uint32_t i = 0; i < perCell; ++i) {
+        rows.push_back({.cell = cell, .start = 2U + ((67U * i) / perCell)});
+      }
+      rows.push_back({.cell = cell, .start = 69U}); // the bound's last start
+      rows.push_back({.cell = cell, .start = 70U}); // past it
+    }
+    return rows;
+  };
+  for (const std::uint32_t perCell : {2U, 37U}) {
+    const auto rows = rowsOf(perCell);
+    std::vector<std::uint32_t> offsets(static_cast<std::size_t>(geometry.bucketCount()) + 1U);
+    MeasurementStore columns;
+    resizeMeasurementColumns(columns, rows.size());
+    const auto bucketOf = [&](const Row& row) { return geometry.bucketAt(1, row.start, (static_cast<Scalar>(row.cell) + 0.5F) * cellWidth, 0.F); };
+    test::buildGridRows(
+      rows.size(), offsets, [&](std::size_t i) { return bucketOf(rows[i]); },
+      [&](std::size_t i, std::uint32_t at) {
+        columns.timePS[at] = rows[i].start;
+        columns.widthPS[at] = rows[i].width;
+        columns.clusterIndex[at] = static_cast<std::uint32_t>(i);
+      });
+
+    const Grid grid{measurementView(columns), geometry, std::span<const std::uint32_t>{offsets}};
+    const LayerPairWindow pair{.phiHalfWidth = 1.5F * cellWidth, .secondHalfWidth = 2.F};
+    const auto window = candidateWindow(pair, TimeEstPS{.start = 10U, .width = 60U}, 0.1F, 0.F, 0.F, 10U);
+    BOOST_TEST_REQUIRE(window.earliestPS == 1);
+    BOOST_TEST_REQUIRE(window.latestPS == 69);
+    std::vector<std::uint32_t> single;
+    grid.visitCandidates(1, window, geometry.allBlocks(), [&](std::uint32_t row) { single.push_back(columns.clusterIndex[row]); });
+    BOOST_TEST_REQUIRE(single.size() == 3U * (perCell + 1U));
+    BOOST_TEST_CONTEXT("rows per cell " << perCell)
+    {
+      checkGroupInStep<2>(grid, columns, window, geometry);
+      checkGroupInStep<3>(grid, columns, window, geometry);
+      checkGroupInStep<8>(grid, columns, window, geometry);
+      checkGroupInStep<32>(grid, columns, window, geometry);
+      checkGroupInStep<64>(grid, columns, window, geometry);
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(QueryVisitsOrderedSecondRunsWithoutDuplicates)
+{
+  auto params = test::withToyFrames(GridParams{});
+  params.blockWidth = 100'000;
+  for (std::size_t layer = 0; layer < GridParams::kMaxLayers; ++layer) {
+    params.phiBins[layer] = 1;
+    params.secondBins[layer] = 8;
+  }
+  const GeometryGrid geometry{100'000, params, defaultWindows()};
+  BOOST_REQUIRE(geometry.axes(1).nSecond == 8);
+
+  constexpr std::size_t kBins = 8;
+  const auto& axes = geometry.axes(1);
+  const Scalar width = 1.F / axes.secondInvWidth;
+  std::array<GridPoint, kBins> points{};
+  for (std::size_t i = 0; i < points.size(); ++i) {
+    points[i] = {.layer = 1, .phi = 0.F, .second = axes.secondMin + ((static_cast<Scalar>(i) + 0.5F) * width)};
+  }
+
+  std::vector<std::uint32_t> offsets(static_cast<std::size_t>(geometry.bucketCount()) + 1U);
+  MeasurementStore columns;
+  resizeMeasurementColumns(columns, kBins);
+  test::buildGridRows(
+    points.size(), offsets, [&](std::size_t i) { return geometry.bucketAt(points[i].layer, 0U, points[i].phi, points[i].second); },
+    [&](std::size_t i, std::uint32_t row) {
+      columns.widthPS[row] = 1U;
+      columns.clusterIndex[row] = static_cast<std::uint32_t>(i);
+    });
+
+  const Grid grid{measurementView(columns), geometry, std::span<const std::uint32_t>{offsets}};
+  const Scalar first = points[1].second;
+  const std::array<SecondRun, 3> runs{{
+    {.low = first - (0.2F * width), .high = first - (0.1F * width)},
+    {.low = first + (0.1F * width), .high = first + (0.2F * width)},
+    {.low = points[5].second - (0.1F * width), .high = points[5].second + (0.1F * width)},
+  }};
+  const CandidateWindow window{.phiCentre = 0.F, .phiHalfWidth = std::numbers::pi_v<Scalar>};
+  std::vector<std::uint32_t> visited;
+  grid.visitCandidates(1, window, runs.data(), static_cast<std::uint32_t>(runs.size()), geometry.allBlocks(), [&](std::uint32_t row) { visited.push_back(columns.clusterIndex[row]); });
+
+  BOOST_TEST(visited == (std::vector<std::uint32_t>{1U, 5U}), boost::test_tools::per_element());
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testMeasurementUpdate.cxx b/Detectors/GenericTracking/tracking/test/testMeasurementUpdate.cxx
new file mode 100644
index 0000000000000..cf3aa35e40c63
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testMeasurementUpdate.cxx
@@ -0,0 +1,349 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testMeasurementUpdate.cxx
+/// \brief Closure tests for the spatial Kalman update.
+
+#define BOOST_TEST_MODULE Test GTRK Measurement Update
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+#include <numbers>
+
+#include "GenericTracking/Tracking/MeasurementUpdate.h"
+#include "Oracles.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <random>
+
+namespace o2::gtrk
+{
+namespace
+{
+
+BoundTrackState makePrior()
+{
+  BoundTrackState state;
+  state.par[kPhi] = 0.2F;
+  state.par[kTheta] = 1.1F;
+  state.par[kQOverP] = 0.5F;
+  state.variance(kLoc0) = 4.F;
+  state.variance(kLoc1) = 9.F;
+  state.variance(kPhi) = 0.04F;
+  state.variance(kTheta) = 0.09F;
+  state.variance(kQOverP) = 0.16F;
+  return state;
+}
+
+Measurement makeMeasurement()
+{
+  Measurement measurement;
+  measurement.loc0 = 1.F;
+  measurement.loc1 = -2.F;
+  measurement.varLoc0 = 1.F;
+  measurement.varLoc1 = 4.F;
+  return measurement;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(UpdateMatchesTheScalarDiagonalAnswer)
+{
+  auto state = makePrior();
+  const auto result = updateWithMeasurement(state, makeMeasurement());
+
+  BOOST_TEST(std::abs(static_cast<double>(state.loc0()) - 0.8) < 1e-6);
+  BOOST_TEST(std::abs(static_cast<double>(state.loc1()) + 18. / 13.) < 1e-6);
+  BOOST_TEST(std::abs(static_cast<double>(state.variance(kLoc0)) - 0.8) < 1e-6);
+  BOOST_TEST(std::abs(static_cast<double>(state.variance(kLoc1)) - 36. / 13.) < 1e-6);
+
+  BOOST_TEST(std::abs(static_cast<double>(result.chi2) - (1. / 5. + 4. / 13.)) < 1e-6);
+
+  BOOST_TEST(state.phi() == 0.2F);
+  BOOST_TEST(state.theta() == 1.1F);
+  BOOST_TEST(state.qOverP() == 0.5F);
+}
+
+BOOST_AUTO_TEST_CASE(CorrelationsUpdateAllFiveParameters)
+{
+  auto state = makePrior();
+  state.covAt(kLoc1, kLoc0) = 0.5F;
+  state.covAt(kPhi, kLoc0) = 0.1F;
+  state.covAt(kTheta, kLoc1) = -0.2F;
+  state.covAt(kQOverP, kLoc0) = 0.3F;
+
+  auto measurement = makeMeasurement();
+  measurement.covLoc01 = -0.25F;
+
+  const auto before = state;
+  const auto result = updateWithMeasurement(state, measurement);
+
+  BOOST_TEST(state.phi() != before.phi());
+  BOOST_TEST(state.theta() != before.theta());
+  BOOST_TEST(state.qOverP() != before.qOverP());
+  BOOST_TEST(std::abs(static_cast<double>(state.loc0()) - 0.752646775746) < 1e-6);
+  BOOST_TEST(std::abs(static_cast<double>(state.loc1()) + 1.316650625602) < 1e-6);
+  BOOST_TEST(std::abs(static_cast<double>(result.chi2) - 0.523580365736) < 1e-6);
+
+  for (int i = 0; i < kNBoundParams; ++i) {
+    BOOST_TEST(state.variance(i) > 0.F);
+    for (int j = 0; j < kNBoundParams; ++j) {
+      BOOST_TEST(state.covAt(i, j) == state.covAt(j, i));
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(FactorizedScalarUpdateMatchesExactOracle)
+{
+  // The spatial prior is millions of times wider than the measurement, the
+  // cancellation regime in which a direct float covariance update fails.
+  // Build a correlated positive-definite covariance as L L^T so every
+  // state parameter participates without relying on hand-tuned entries.
+  constexpr Scalar lower[kNBoundParams][kNBoundParams] = {
+    {3.F, 0.F, 0.F, 0.F, 0.F},
+    {0.4F, 2.F, 0.F, 0.F, 0.F},
+    {0.05F, -0.02F, 0.1F, 0.F, 0.F},
+    {-0.03F, 0.04F, 0.01F, 0.12F, 0.F},
+    {0.8F, -0.5F, 0.2F, -0.1F, 4.F},
+  };
+
+  BoundTrackState scalar;
+  scalar.par[kLoc0] = 0.2F;
+  scalar.par[kLoc1] = -0.4F;
+  scalar.par[kPhi] = 0.3F;
+  scalar.par[kTheta] = 1.2F;
+  scalar.par[kQOverP] = 2.5F;
+  for (int row = 0; row < kNBoundParams; ++row) {
+    for (int column = 0; column <= row; ++column) {
+      Scalar value = 0.F;
+      for (int k = 0; k < kNBoundParams; ++k) {
+        value += lower[row][k] * lower[column][k];
+      }
+      scalar.covAt(row, column) = value;
+    }
+  }
+  auto exact = scalar;
+
+  Measurement measurement;
+  measurement.loc0 = 0.202F;
+  measurement.loc1 = -0.397F;
+  measurement.varLoc0 = 2.5e-6F;
+  measurement.varLoc1 = 1.5e-6F;
+  measurement.covLoc01 = 5.e-7F;
+
+  const auto scalarResult = updateWithMeasurement(scalar, measurement);
+  const auto exactResult = updateWithMeasurementExact(exact, measurement);
+
+  for (int i = 0; i < kNBoundParams; ++i) {
+    const Scalar scale = std::max(1.F, std::abs(exact.par[i]));
+    BOOST_TEST_CONTEXT("parameter " << i) { BOOST_TEST(std::abs(scalar.par[i] - exact.par[i]) < 2e-5F * scale); }
+  }
+
+  for (int row = 0; row < kNBoundParams; ++row) {
+    for (int column = 0; column <= row; ++column) {
+      const Scalar expected = exact.covAt(row, column);
+      const Scalar covarianceScale = std::sqrt(exact.variance(row) * exact.variance(column));
+      const Scalar tolerance = row == column ? 2e-5F * std::abs(expected) : 1e-4F * covarianceScale;
+      BOOST_TEST_CONTEXT("covariance (" << row << ", " << column << ")") { BOOST_TEST(std::abs(scalar.covAt(row, column) - expected) < tolerance); }
+    }
+  }
+
+  BOOST_TEST(std::abs(scalarResult.chi2 - exactResult.chi2) < 2e-5F);
+  BOOST_TEST(scalar.variance(kLoc0) > 0.F);
+  BOOST_TEST(scalar.variance(kLoc1) > 0.F);
+  BOOST_TEST(scalar.variance(kQOverP) > 0.F);
+}
+
+/// The innovation covariance's determinant (the follow's EndDensity cuts on
+/// it) from the two sequential
+/// innovations, against the determinant of V = H P H^T + R in double for the
+/// covariance P = U D U^T the factors hold -- the follow carries the factors,
+/// not P. Over the follow's range: position sigmas of 10 um to 1 mm,
+/// correlated with each other up to 0.99 and with the direction and q/p;
+/// measurement sigmas of 5 to 300 um, correlated up to 0.95. The float
+/// product is the determinant algebraically, not exactly: within a relative
+/// 1e-5 of the double one here, so a cut on it decides as the double one
+/// except that close to the cut. Priors far more degenerate lose more, about
+/// float's epsilon over their conditioning.
+BOOST_AUTO_TEST_CASE(TheInnovationsMultiplyToTheJointDeterminant)
+{
+  std::mt19937 random(0x4454524bU);
+  std::uniform_real_distribution<double> unit(0., 1.);
+  std::normal_distribution<double> normal;
+  double worst = 0.;
+  for (int sample = 0; sample < 200000; ++sample) {
+    // The prior as L L^T in double, factored in double, the factors in float.
+    const double sigma0 = std::pow(10., -3. + (2. * unit(random)));
+    const double sigma1 = std::pow(10., -3. + (2. * unit(random)));
+    const double rho = (unit(random) < 0.5 ? -1. : 1.) * (1. - std::pow(10., -2. * unit(random)));
+    double lower[kNBoundParams][kNBoundParams]{};
+    lower[kLoc0][kLoc0] = sigma0;
+    lower[kLoc1][kLoc0] = sigma1 * rho;
+    lower[kLoc1][kLoc1] = sigma1 * std::sqrt(1. - (rho * rho));
+    for (int row = kPhi; row < kNBoundParams; ++row) {
+      const double scale = std::pow(10., -4. + (3. * unit(random)));
+      for (int column = 0; column < row; ++column) {
+        lower[row][column] = 0.5 * scale * normal(random);
+      }
+      lower[row][row] = scale;
+    }
+    double packed[kBoundCovSize]{};
+    for (int row = 0; row < kNBoundParams; ++row) {
+      for (int column = 0; column <= row; ++column) {
+        double value = 0.;
+        for (int k = 0; k < kNBoundParams; ++k) {
+          value += lower[row][k] * lower[column][k];
+        }
+        packed[covIndex(row, column)] = value;
+      }
+    }
+    double upper[kBoundUpperSize]{};
+    double diagonal[kNBoundParams]{};
+    detail::factorUD(packed, upper, diagonal);
+    CovarianceFactors factors;
+    for (std::size_t i = 0; i < std::size(upper); ++i) {
+      factors.upper[i] = static_cast<Scalar>(upper[i]);
+    }
+    for (int i = 0; i < kNBoundParams; ++i) {
+      factors.diagonal[i] = static_cast<Scalar>(diagonal[i]);
+    }
+    // The oracle: P from the float factors, in double.
+    const auto covariance = [&](int i, int j) {
+      double sum = 0.;
+      for (int k = std::max(i, j); k < kNBoundParams; ++k) {
+        const double ui = k == i ? 1. : static_cast<double>(factors.upper[detail::strictUpperIndex(i, k)]);
+        const double uj = k == j ? 1. : static_cast<double>(factors.upper[detail::strictUpperIndex(j, k)]);
+        sum += ui * static_cast<double>(factors.diagonal[k]) * uj;
+      }
+      return sum;
+    };
+    Measurement measurement;
+    const double m0 = std::pow(10., -3.3 + (1.8 * unit(random)));
+    const double m1 = std::pow(10., -3.3 + (1.8 * unit(random)));
+    measurement.varLoc0 = static_cast<Scalar>(m0 * m0);
+    measurement.varLoc1 = static_cast<Scalar>(m1 * m1);
+    measurement.covLoc01 = static_cast<Scalar>(0.95 * ((2. * unit(random)) - 1.) * m0 * m1);
+    const double v00 = covariance(kLoc0, kLoc0) + static_cast<double>(measurement.varLoc0);
+    const double v11 = covariance(kLoc1, kLoc1) + static_cast<double>(measurement.varLoc1);
+    const double v01 = covariance(kLoc0, kLoc1) + static_cast<double>(measurement.covLoc01);
+    const double expected = (v00 * v11) - (v01 * v01);
+    BoundTrackState state;
+    state.par[kTheta] = 1.2F;
+    state.par[kQOverP] = 1.5F;
+    Scalar determinant = 0.F;
+    const auto result = updateWithMeasurement<true>(state, factors, measurement, &determinant);
+    BOOST_REQUIRE(updateUsable(result, factors));
+    worst = std::max(worst, std::abs(static_cast<double>(determinant) - expected) / expected);
+  }
+  BOOST_TEST_MESSAGE("determinant: worst relative difference " << worst);
+  BOOST_TEST(worst < 1e-5);
+}
+
+BOOST_AUTO_TEST_CASE(DirectionIsCanonicalAfterTheUpdate)
+{
+  auto state = makePrior();
+  state.par[kPhi] = std::numbers::pi_v<Scalar> - 0.05F;
+  state.par[kTheta] = 0.02F;
+  state.covAt(kTheta, kLoc0) = 0.2F;
+  state.covAt(kPhi, kLoc0) = 0.2F;
+
+  auto measurement = makeMeasurement();
+  measurement.loc0 = -1.F;
+  measurement.loc1 = 0.F;
+
+  const auto result = updateWithMeasurement(state, measurement);
+
+  BOOST_TEST(result.chi2 > 0.F);
+  BOOST_TEST(state.phi() >= -std::numbers::pi_v<Scalar>);
+  BOOST_TEST(state.phi() <= std::numbers::pi_v<Scalar>);
+  BOOST_TEST(state.theta() >= 0.F);
+  BOOST_TEST(state.theta() <= std::numbers::pi_v<Scalar>);
+  BOOST_TEST(state.covAt(kTheta, kLoc0) < 0.F);
+}
+
+BOOST_AUTO_TEST_CASE(SyntheticResidualsAndPosteriorPullsClose)
+{
+  constexpr int kSamples = 50000;
+  constexpr double kPriorSigmaLoc0 = 2.;
+  constexpr double kPriorSigmaLoc1 = 3.;
+  constexpr double kMeasurementSigmaLoc0 = 1.;
+  constexpr double kMeasurementSigmaLoc1 = 2.;
+
+  std::mt19937 random(0x4754524bU);
+  std::normal_distribution<double> normal;
+
+  std::array<double, 4> sum{};
+  std::array<double, 4> sum2{};
+  for (int sample = 0; sample < kSamples; ++sample) {
+    const double truth0 = kPriorSigmaLoc0 * normal(random);
+    const double truth1 = kPriorSigmaLoc1 * normal(random);
+
+    auto state = makePrior();
+    auto measurement = makeMeasurement();
+    measurement.loc0 = static_cast<Scalar>(truth0 + kMeasurementSigmaLoc0 * normal(random));
+    measurement.loc1 = static_cast<Scalar>(truth1 + kMeasurementSigmaLoc1 * normal(random));
+
+    const auto result = updateWithMeasurement(state, measurement);
+    const std::array<double, 4> values{
+      static_cast<double>(result.residualLoc0) / std::sqrt(kPriorSigmaLoc0 * kPriorSigmaLoc0 + kMeasurementSigmaLoc0 * kMeasurementSigmaLoc0),
+      static_cast<double>(result.residualLoc1) / std::sqrt(kPriorSigmaLoc1 * kPriorSigmaLoc1 + kMeasurementSigmaLoc1 * kMeasurementSigmaLoc1),
+      (static_cast<double>(state.loc0()) - truth0) / std::sqrt(static_cast<double>(state.variance(kLoc0))),
+      (static_cast<double>(state.loc1()) - truth1) / std::sqrt(static_cast<double>(state.variance(kLoc1))),
+    };
+
+    for (std::size_t i = 0; i < values.size(); ++i) {
+      sum[i] += values[i];
+      sum2[i] += values[i] * values[i];
+    }
+  }
+
+  for (std::size_t i = 0; i < sum.size(); ++i) {
+    const double mean = sum[i] / kSamples;
+    const double width = std::sqrt(sum2[i] / kSamples - mean * mean);
+    BOOST_TEST(std::abs(mean) < 0.015);
+    BOOST_TEST(std::abs(width - 1.) < 0.015);
+  }
+}
+
+/// A predicted covariance that is not positive definite gives a negative
+/// spatial chi2, which the road fit's cut would pass and the quality order
+/// would rank first; `updateUsable` refuses it, and accepts a sound update.
+BOOST_AUTO_TEST_CASE(UpdateUsableRefusesAnIndefinitePrior)
+{
+  const auto measurement = makeMeasurement();
+
+  BoundTrackState sound = makePrior();
+  auto soundFactors = factorCovariance(sound.cov);
+  const auto good = updateWithMeasurement(sound, soundFactors, measurement);
+  BOOST_TEST(updateUsable(good, soundFactors));
+
+  BoundTrackState indefinite = makePrior();
+  // The loc0/loc1 block with a correlation beyond one: the innovation's
+  // spatial determinant, (4 + 1)(9 + 4) - 10^2, is negative, so its marginal
+  // chi2 is too.
+  indefinite.covAt(kLoc0, kLoc1) = 10.F;
+  auto indefiniteFactors = factorCovariance(indefinite.cov);
+  const auto bad = updateWithMeasurement(indefinite, indefiniteFactors, measurement);
+  BOOST_TEST(!bad.positiveDefinite);
+  BOOST_TEST(!(bad.chi2 >= 0.F));
+  BOOST_TEST(!updateUsable(bad, indefiniteFactors));
+  BOOST_TEST(good.positiveDefinite);
+
+  // A posterior variance that is not positive is refused on its own.
+  BoundTrackState collapsed = makePrior();
+  auto collapsedFactors = factorCovariance(collapsed.cov);
+  const auto fine = updateWithMeasurement(collapsed, collapsedFactors, measurement);
+  collapsedFactors.diagonal[kQOverP] = 0.F;
+  BOOST_TEST(!updateUsable(fine, collapsedFactors));
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testNeighbourStage.cxx b/Detectors/GenericTracking/tracking/test/testNeighbourStage.cxx
new file mode 100644
index 0000000000000..9be8929bc7d03
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testNeighbourStage.cxx
@@ -0,0 +1,439 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testNeighbourStage.cxx
+/// \brief The pulling neighbour stage against a brute-force scan of every
+///        triplet pair sharing a tracklet, and the level sweep against levels
+///        worked out by hand, on the deep ToyBarrel8.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK NeighbourStage
+#include <boost/test/unit_test.hpp>
+
+#include "ToyBarrel8.h"
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Tracking/MeasurementGridBuilder.h"
+#include "GenericTracking/Tracking/NeighbourStage.h"
+#include "GenericTracking/Tracking/Tracker.h"
+#include "GenericTracking/Tracking/TrackletPaths.h"
+#include "GenericTracking/Tracking/TripletEndIndex.h"
+#include "GenericTracking/Tracking/TripletPaths.h"
+#include "GenericTracking/Tracking/TripletPermutation.h"
+
+#include "Oracles.h"
+#include "StageOutputComparison.h"
+#include "ToyBarrel8Fixture.h"
+#include "SerialReferences.h"
+#include "FixedPointReferences.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using namespace toybarrel8;
+using NeighbourOutput = StageOutput<NeighbourT>;
+constexpr std::size_t kTracks = kHelixTracks;
+/// The last track drifts in time, its layers in the toys' ticks 0, 1, 1, 2, 2,
+/// 3, 3, 4 (GridTestSupport.h): every pair and every triplet of it shares a
+/// time, but every other `a-d` span is two ticks -- equal boxes cannot fail
+/// every `a-d` with every triplet passing.
+constexpr std::size_t kDriftingTrack = 4U;
+constexpr std::array<int, 8> kDriftTicks{0, 1, 1, 2, 2, 3, 3, 4};
+constexpr std::size_t kNoisePerLayer = 3U;
+/// Hits on layer 4 next to a track, moved along z and r-phi [cm]: branches
+/// whose triplets all pass, and whose neighbours pass, fail the curvature
+/// agreement, or fail only the fit -- which sees the theta kinks and one
+/// shared curvature together.
+struct Branch {
+  std::size_t track = 0U;
+  double dz = 0.;
+  double dRPhi = 0.;
+};
+constexpr std::array<Branch, 10> kBranches{{{.track = 0, .dz = 0.008, .dRPhi = 0.003}, {.track = 0, .dz = 0.012, .dRPhi = 0.005}, {.track = 1, .dz = 0.010, .dRPhi = 0.004}, {.track = 1, .dz = 0.016, .dRPhi = 0.002}, {.track = 2, .dz = 0.006, .dRPhi = 0.006}, {.track = 2, .dz = 0.004, .dRPhi = 0.008}, {.track = 3, .dz = 0.012, .dRPhi = 0.004}, {.track = 3, .dz = 0.008, .dRPhi = 0.007}, {.track = 2, .dRPhi = 0.012}, {.track = 3, .dRPhi = 0.016}}};
+constexpr LayerID kBranchLayer = 4;
+
+/// The neighbour fixture: kTracks through all eight layers, the last one
+/// drifting in time, noise, and the branch hits.
+std::vector<Hit> neighbourHits()
+{
+  std::vector<Hit> hits;
+  for (std::size_t track = 0; track < kTracks; ++track) {
+    for (std::size_t layer = 0; layer < kLayers; ++layer) {
+      const double drift = track == kDriftingTrack ? test::kToyTickNS * static_cast<double>(kDriftTicks[layer]) : 0.;
+      hits.push_back({.point = helixPoint(track, static_cast<LayerID>(layer)), .timeNS = 10. + drift});
+    }
+  }
+  for (std::size_t layer = 0; layer < kLayers; ++layer) {
+    const double radius = layerDistance<Det>(static_cast<LayerID>(layer));
+    for (std::size_t noise = 0; noise < kNoisePerLayer; ++noise) {
+      const double phi = 0.55 + (1.85 * static_cast<double>(noise)) + (0.23 * static_cast<double>(layer));
+      hits.push_back({
+        .point =
+          {
+            .layer = static_cast<LayerID>(layer),
+            .x = static_cast<Scalar>(radius * std::cos(phi)),
+            .y = static_cast<Scalar>(radius * std::sin(phi)),
+            .z = static_cast<Scalar>((noise % 2U == 0U ? 0.65 : -0.55) + (0.03 * static_cast<double>(layer))),
+            .r = static_cast<Scalar>(radius),
+            .phi = static_cast<Scalar>(phi),
+          },
+      });
+    }
+  }
+  for (const auto& branch : kBranches) {
+    hits.push_back({.point = moved(helixPoint(branch.track, kBranchLayer), branch.dz, branch.dRPhi)});
+  }
+  return hits;
+}
+
+/// A writable copy of \a triplets, in the same arena order and back at level
+/// 1: the sweep raises levels in place, and the tracker hands its triplets
+/// out const, already swept.
+void copyTriplets(const Triplets& triplets, Triplets& copy)
+{
+  const auto view = triplets.view();
+  copy.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  copy.prepare(triplets.size());
+  const auto status = runSerial(copy, [&](Triplets::Index element, auto& emitter) {
+    emitter.emit(Triplet{
+      .first = view.first[element],
+      .second = view.second[element],
+      .curvature = view.curvature[element],
+      .varCurvature = view.varCurvature[element],
+      .level = 1U,
+      .kinked = view.kinked[element],
+    });
+  });
+  BOOST_REQUIRE(status == StageStatus::kComplete);
+}
+
+struct Levels {
+  std::vector<std::uint32_t> level;
+  std::uint32_t sweeps = 0U;
+};
+
+/// The level sweep over a copy of \a triplets: serial when \a threads is 0,
+/// else on the CPU backend in chunks of \a chunk.
+Levels sweepLevels(const Triplets& triplets, const NeighbourOutput& neighbours, int threads = 0, std::uint32_t chunk = 1U)
+{
+  Triplets copy;
+  copyTriplets(triplets, copy);
+  Levels result;
+  if (threads == 0) {
+    result.sweeps = fixedPointLevels(
+      [](std::uint32_t elements, const LevelUpdate& update) {
+        for (std::uint32_t element = 0; element < elements; ++element) {
+          update(element);
+        }
+      },
+      neighbours, copy);
+  } else {
+    detail::TaskArena cpuArena{threads};
+    CpuStage<NeighbourT> cpu{cpuArena};
+    cpu.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    result.sweeps = fixedPointLevels([&](std::uint32_t elements, const LevelUpdate& update) { cpu.forEachElement(elements, chunk, update); }, neighbours, copy);
+  }
+  const auto view = copy.view();
+  result.level.assign(view.level, view.level + copy.size());
+  return result;
+}
+
+/// Every level is one above its highest predecessor's, or 1 without one.
+void checkFixedPoint(const Levels& levels, const NeighbourOutput& neighbours)
+{
+  const auto* const from = neighbours.view().from;
+  for (std::uint32_t triplet = 0; triplet < levels.level.size(); ++triplet) {
+    std::uint32_t highest = 0U;
+    for (auto edge = neighbours.offsets()[triplet]; edge < neighbours.offsets()[triplet + 1U]; ++edge) {
+      highest = std::max(highest, levels.level[from[edge]]);
+    }
+    BOOST_TEST_CONTEXT("triplet " << triplet) { BOOST_TEST(levels.level[triplet] == highest + 1U); }
+  }
+}
+
+/// The same levels from every schedule: serial, and 1, 2 and 4 threads in
+/// chunks of 1 to 16. The number of sweeps may differ; the levels may not.
+void checkScheduleInvariance(const Triplets& triplets, const NeighbourOutput& neighbours, const Levels& serial)
+{
+  for (const int threads : {1, 2, 4}) {
+    for (const std::uint32_t chunk : {1U, 2U, 3U, 7U, 16U}) {
+      const auto parallel = sweepLevels(triplets, neighbours, threads, chunk);
+      BOOST_TEST_CONTEXT("threads " << threads << ", chunk " << chunk) { BOOST_TEST(parallel.level == serial.level, boost::test_tools::per_element()); }
+    }
+  }
+}
+
+/// The tracker's own neighbours and levels are the ones the stages give run
+/// by hand.
+void checkTrackerOutput(const Triplets& trackerTriplets, const NeighbourOutput& trackerNeighbours, const NeighbourOutput& neighbours, const Levels& levels)
+{
+  // The independent full-fit reference establishes levels first. The fused
+  // tracker keeps precisely the edges that its road walk can use.
+  NeighbourOutput longest;
+  longest.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  longest.prepare(trackerTriplets.size());
+  const auto* const from = neighbours.view().from;
+  const auto offsets = neighbours.offsets();
+  const auto status = runSerial(longest, [&](std::uint32_t self, auto& emitter) {
+    const auto end = offsets[self + 1U];
+    for (auto edge = offsets[self]; edge < end; ++edge) {
+      if (levels.level[from[edge]] + 1U == levels.level[self]) {
+        emitter.emit(Neighbour{.from = from[edge]});
+      }
+    }
+  });
+  BOOST_REQUIRE(status == StageStatus::kComplete);
+  BOOST_TEST(sameStageOutput(trackerNeighbours, longest));
+  const auto view = trackerTriplets.view();
+  BOOST_TEST(std::vector<std::uint32_t>(view.level, view.level + trackerTriplets.size()) == levels.level, boost::test_tools::per_element());
+}
+
+/// The triplet path bounds as the tracker builds them, at \a minClusters and
+/// \a parameters' road ends.
+struct PathBounds {
+  TrackletPaths<Det> trackletPaths;
+  TripletPermutation<Det> permutation;
+  TripletPaths<Det> tripletPaths;
+
+  TrackletPathBounds build(IterationParameters<Det> parameters, std::uint32_t minClusters, const LayerRowMap<Det>& sources, const TrackletOutput& tracklets, const Triplets& triplets)
+  {
+    parameters.minClusters = minClusters;
+    const auto pool = std::make_shared<BoundedMemoryResource>();
+    trackletPaths.setMemoryPool(pool);
+    permutation.setMemoryPool(pool);
+    tripletPaths.setMemoryPool(pool);
+    trackletPaths.build(parameters, sources, tracklets, SerialForEach{});
+    BOOST_REQUIRE(permutation.build(parameters, sources, tracklets, trackletPaths.bounds(), SerialForEach{}, 256U) == StageStatus::kComplete);
+    tripletPaths.build(parameters, sources, tracklets, permutation, placedTriplets(triplets), SerialForEach{});
+    return tripletPaths.bounds();
+  }
+};
+
+/// Tracklets, triplets, the end index and the neighbours of \a fixture's
+/// whole timeframe, with the tracker's path bounds; \a tracker owns the
+/// tracklets and triplets.
+void buildNeighbours(const Fixture& fixture, const IterationParameters<Det>& parameters, Controller& tracker, TripletEndIndex& ending, NeighbourOutput& neighbours, const TrackletOutput*& tracklets, const Triplets*& triplets)
+{
+  const Frame::TimeSlice slice{*fixture.frame, fixture.geometry.allBlocks(), 0};
+  BOOST_REQUIRE(tracker.beginTimeframe(*fixture.frame) == StageStatus::kComplete);
+  const auto result = test::runSlice(tracker, 0U, *fixture.frame, slice, {});
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  tracklets = result.tracklets;
+  triplets = result.triplets;
+  ending.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  BOOST_REQUIRE(ending.build(tracklets->size(), *triplets, SerialForEach{}, std::numeric_limits<std::uint32_t>::max()) == StageStatus::kComplete);
+  PathBounds paths;
+  const auto bounds = paths.build(parameters, parameters.minClusters, tracker.sources(), *tracklets, *triplets);
+  const NeighbourStage<Det> stage{parameters, *fixture.frame, *tracklets, *triplets, ending, bounds};
+  neighbours.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  neighbours.prepare(triplets->size());
+  BOOST_REQUIRE(runSerial(neighbours, stage) == StageStatus::kComplete);
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(NeighboursMatchBruteForceAndEveryTrueChainIsLinked)
+{
+  const Fixture fixture{neighbourHits()};
+  const Frame::TimeSlice slice{*fixture.frame, fixture.geometry.allBlocks(), 0};
+  const std::array<double, kLayers> material{};
+  const auto scattering = scatteringTable<Det>(material);
+  const auto parameters = iterationParameters<Det>(iterationSettings(), Fixture::kBeamConstraint, scattering);
+  Controller tracker{iterationSettings(), Fixture::kBeamConstraint, scattering, std::make_shared<BoundedMemoryResource>(), 2U, 2};
+  BOOST_REQUIRE(tracker.beginTimeframe(*fixture.frame) == StageStatus::kComplete);
+  const auto result = test::runSlice(tracker, 0U, *fixture.frame, slice, {});
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  const auto& tracklets = *result.tracklets;
+  const auto& triplets = *result.triplets;
+  BOOST_REQUIRE(triplets.size() > 0U);
+
+  TripletEndIndex ending;
+  ending.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  BOOST_REQUIRE(ending.build(tracklets.size(), triplets, SerialForEach{}, std::numeric_limits<std::uint32_t>::max()) == StageStatus::kComplete);
+  // At 3 clusters no triplet path is too short: the stage's own cut alone.
+  PathBounds paths;
+  const auto bounds = paths.build(parameters, 3U, tracker.sources(), tracklets, triplets);
+  const NeighbourStage<Det> stage{parameters, *fixture.frame, tracklets, triplets, ending, bounds};
+  NeighbourOutput serial;
+  serial.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  serial.prepare(triplets.size());
+  BOOST_REQUIRE(runSerial(serial, stage) == StageStatus::kComplete);
+
+  // Brute force: every pair T1, T2 with T1.second == T2.first, the whole cut,
+  // predecessors in arena order.
+  const auto trackletView = tracklets.view();
+  const auto tripletView = triplets.view();
+  const auto neighbourView = serial.view();
+  std::size_t candidates = 0U;
+  std::size_t curvatureRejected = 0U;
+  std::size_t timeRejected = 0U;
+  std::size_t fitRejected = 0U;
+  for (std::uint32_t to = 0; to < triplets.size(); ++to) {
+    std::vector<std::uint32_t> expected;
+    const auto shared = tripletView.first[to];
+    const auto last = tripletView.second[to];
+    for (std::uint32_t from = 0; from < triplets.size(); ++from) {
+      if (tripletView.second[from] != shared) {
+        continue;
+      }
+      ++candidates;
+      const auto first = tripletView.first[from];
+      const auto a = timedPointAt(fixture.frame->measurements(), trackletView.source[first]);
+      const auto b = timedPointAt(fixture.frame->measurements(), trackletView.source[shared]);
+      const auto c = timedPointAt(fixture.frame->measurements(), trackletView.target[shared]);
+      const auto d = timedPointAt(fixture.frame->measurements(), trackletView.target[last]);
+      const LayerID secondLayer = parameters.linkSources[trackletView.link[shared]];
+      const LayerID thirdLayer = parameters.linkTargets[trackletView.link[shared]];
+      if (!neighbourCurvatureCompatible(parameters, tripletView.curvature[from], tripletView.varCurvature[from], tripletView.curvature[to], tripletView.varCurvature[to])) {
+        ++curvatureRejected;
+        continue;
+      }
+      if (!neighbourTimeCompatible(a, d)) {
+        ++timeRejected;
+        continue;
+      }
+      TripletFitResult fit;
+      if (!fitAdjacentTriplets(a.point, b.point, c.point, d.point, secondLayer, thirdLayer, parameters.scattering, parameters.pairCut, fit) || !(fit.chi2 <= parameters.neighbourChi2Max)) {
+        ++fitRejected;
+        continue;
+      }
+      BOOST_TEST(neighbourCompatible(parameters, secondLayer, thirdLayer, a, b, c, d, fit));
+      expected.push_back(from);
+    }
+    std::vector<std::uint32_t> emitted(neighbourView.from + serial.offsets()[to], neighbourView.from + serial.offsets()[to + 1U]);
+    BOOST_TEST_CONTEXT("triplet " << to) { BOOST_TEST(emitted == expected, boost::test_tools::per_element()); }
+  }
+  BOOST_TEST_MESSAGE("triplets " << triplets.size() << ", candidates " << candidates << ", neighbours " << serial.size() << ", rejected by curvature " << curvatureRejected << ", time " << timeRejected << ", fit " << fitRejected);
+  BOOST_TEST(curvatureRejected > 0U);
+  BOOST_TEST(timeRejected > 0U);
+  BOOST_TEST(fitRejected > 0U);
+
+  // Each track crosses all eight layers: six true triplets, linked by five
+  // true neighbours -- except the drifting one, whose links 1, 3 and 5 span
+  // two ticks `a-d`.
+  for (std::size_t track = 0; track < kTracks; ++track) {
+    std::array<std::uint32_t, kLayers - 2U> chain{};
+    for (std::size_t layer = 0; layer + 2U < kLayers; ++layer) {
+      chain[layer] = findTriplet(tracklets, triplets, fixture.row(Fixture::logicalIndex(track, layer)), fixture.row(Fixture::logicalIndex(track, layer + 1U)), fixture.row(Fixture::logicalIndex(track, layer + 2U)));
+      BOOST_REQUIRE_MESSAGE(chain[layer] < triplets.size(), "track " << track << " misses the triplet from layer " << layer);
+    }
+    for (std::size_t link = 1; link < chain.size(); ++link) {
+      const auto* begin = neighbourView.from + serial.offsets()[chain[link]];
+      const auto* end = neighbourView.from + serial.offsets()[chain[link] + 1U];
+      const bool linked = std::find(begin, end, chain[link - 1U]) != end;
+      BOOST_TEST(linked == (track != kDriftingTrack || link % 2U == 0U), "track " << track << " link " << link);
+    }
+  }
+
+  for (const int threads : {1, 2, 4}) {
+    for (const NeighbourOutput::Index chunk : {1U, 2U, 3U, 7U, 16U}) {
+      NeighbourOutput parallel;
+      const auto parallelPool = std::make_shared<BoundedMemoryResource>();
+      parallel.setMemoryPool(parallelPool);
+      parallel.prepare(triplets.size());
+      detail::TaskArena cpuArena{threads};
+      CpuStage<NeighbourT> cpu{cpuArena};
+      cpu.setMemoryPool(parallelPool);
+      BOOST_REQUIRE(cpu.run(parallel, chunk, stage) == StageStatus::kComplete);
+      BOOST_TEST(sameStageOutput(parallel, serial), "threads " << threads << ", chunk " << chunk);
+    }
+  }
+
+  // The levels over this graph -- branches, noise, a broken track -- are a
+  // fixed point, and every schedule reaches the same one.
+  const auto levels = sweepLevels(triplets, serial);
+  BOOST_TEST_MESSAGE("chained " << chainedTriplets(serial).size() << ", sweeps " << levels.sweeps);
+  checkFixedPoint(levels, serial);
+  checkScheduleInvariance(triplets, serial, levels);
+
+  // The tracker runs the same stages itself.
+  BOOST_REQUIRE(result.neighbours != nullptr);
+  checkTrackerOutput(triplets, *result.neighbours, serial, levels);
+}
+
+namespace
+{
+
+struct Expected {
+  std::array<std::uint32_t, 3> hits{};
+  std::uint32_t level = 0U;
+};
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(LevelsOnTheDeepBarrelMatchTheirHandCount)
+{
+  using namespace toybarrel8::levels;
+  const Fixture fixture{levelHits()};
+  const std::array<double, kLayers> material{};
+  const auto scattering = scatteringTable<Det>(material);
+  const auto parameters = iterationParameters<Det>(iterationSettings(), Fixture::kBeamConstraint, scattering);
+  Controller tracker{iterationSettings(), Fixture::kBeamConstraint, scattering, std::make_shared<BoundedMemoryResource>(), 2U, 2};
+  TripletEndIndex ending;
+  NeighbourOutput neighbours;
+  const StageOutput<TrackletT>* tracklets = nullptr;
+  const Triplets* triplets = nullptr;
+  buildNeighbours(fixture, parameters, tracker, ending, neighbours, tracklets, triplets);
+
+  // Track 0: six triplets in a row, levels 1 to 6, and a branch through the
+  // second hit on layer 3 that runs alongside from level 2 to 4 and rejoins
+  // at (4, 5, 6), which has two predecessors at level 4. Track 1 lost its
+  // layer-3 hit, and links join only neighbouring layers: its chain breaks
+  // and restarts at level 1. Its first piece, (9, 10, 11), and track 2's
+  // single triplet are on no path of four clusters and not made.
+  const std::array<Expected, 11> expected{{
+    {.hits = {0, 1, 2}, .level = 1},
+    {.hits = {1, 2, 3}, .level = 2},
+    {.hits = {1, 2, kSecondOnLayer3}, .level = 2},
+    {.hits = {2, 3, 4}, .level = 3},
+    {.hits = {2, kSecondOnLayer3, 4}, .level = 3},
+    {.hits = {3, 4, 5}, .level = 4},
+    {.hits = {kSecondOnLayer3, 4, 5}, .level = 4},
+    {.hits = {4, 5, 6}, .level = 5},
+    {.hits = {5, 6, 7}, .level = 6},
+    {.hits = {kTrack1[4], kTrack1[5], kTrack1[6]}, .level = 1},
+    {.hits = {kTrack1[5], kTrack1[6], kTrack1[7]}, .level = 2},
+  }};
+  BOOST_REQUIRE(triplets->size() == expected.size());
+  const auto levels = sweepLevels(*triplets, neighbours);
+  // The tracker's own sweep left the same levels on its triplets.
+  const auto swept = triplets->view();
+  BOOST_TEST(std::vector<std::uint32_t>(swept.level, swept.level + triplets->size()) == levels.level, boost::test_tools::per_element());
+  for (const auto& triplet : expected) {
+    const auto index = findTriplet(*tracklets, *triplets, fixture.row(triplet.hits[0]), fixture.row(triplet.hits[1]), fixture.row(triplet.hits[2]));
+    BOOST_TEST_CONTEXT("triplet " << triplet.hits[0] << " " << triplet.hits[1] << " " << triplet.hits[2])
+    {
+      BOOST_REQUIRE(index < triplets->size());
+      BOOST_TEST(levels.level[index] == triplet.level);
+    }
+  }
+  // Only triplets with predecessors are swept: eight on track 0, one on track
+  // 1. Levels up to 6 need at most five sweeps that change one.
+  BOOST_TEST(chainedTriplets(neighbours).size() == 9U);
+  BOOST_TEST(levels.sweeps >= 1U);
+  BOOST_TEST(levels.sweeps <= static_cast<std::uint32_t>(maxChainLayers<Det>) - 3U);
+  checkFixedPoint(levels, neighbours);
+  checkScheduleInvariance(*triplets, neighbours, levels);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testPassiveScattering.cxx b/Detectors/GenericTracking/tracking/test/testPassiveScattering.cxx
new file mode 100644
index 0000000000000..4370694b0831a
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testPassiveScattering.cxx
@@ -0,0 +1,477 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testPassiveScattering.cxx
+/// \brief A passive scatterer among the layers -- the beam pipe with layers
+///        on both sides of it, as ALICE 3's -- in the pair cut and its
+///        windows.
+///
+/// The layout is a test fixture: three barrel layers inside a pipe and three
+/// outside it. Tracks are followed as helices from the beam line and kinked
+/// at every layer and at the pipe with the scattering the cut models --
+/// Highland's theta0 at normal incidence, the path factor from the track's
+/// dip -- so that the cut's true pairs can be counted against its n sigma.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Passive Scattering
+#include <boost/test/unit_test.hpp>
+
+#include "BetweenBoundCheck.h"
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "ToyBarrel3.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/LayerMaterial.h"
+#include "GenericTracking/Tracking/NeighbourCut.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/SearchWindow.h"
+#include "GenericTracking/Tracking/TripletCut.h"
+#include "UniformMaterial.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <numbers>
+#include <random>
+#include <span>
+#include <stdexcept>
+#include <vector>
+
+namespace o2::gtrk
+{
+namespace
+{
+
+struct ToyPipe {
+  static constexpr const char* name = "ToyPipe";
+
+  static constexpr SensorSpec sensor{.shape = ShapeType::kRectangle, .halfX = 0.5, .halfY = 10., .halfThickness = 0.005, .pitchX = 0.0025, .pitchY = 0.0025};
+
+  // ALICE 3's shape: three layers inside the pipe, three outside it.
+  static constexpr std::array<BarrelLayerSpec, 6> barrelSpecs{{
+    {.r = 0.5, .nStaves = 4, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 1.2, .nStaves = 8, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 2.5, .nStaves = 16, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 7., .nStaves = 45, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 10., .nStaves = 64, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+    {.r = 13., .nStaves = 83, .nModulesPerStave = 1, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = sensor},
+  }};
+
+  static constexpr std::array<DiscLayerSpec, 0> discSpecs{};
+  static constexpr auto barrelLayers = placedLayers(barrelSpecs);
+  static constexpr auto discLayers = placedLayers(discSpecs);
+
+  static constexpr std::array<LayerLink, 5> layerLinks{{
+    {.from = 0, .to = 1, .sourceMin = -10., .sourceMax = 10., .skipsLayer = false},
+    {.from = 1, .to = 2, .sourceMin = -10., .sourceMax = 10., .skipsLayer = false},
+    {.from = 2, .to = 3, .sourceMin = -10., .sourceMax = 10., .skipsLayer = false},
+    {.from = 3, .to = 4, .sourceMin = -10., .sourceMax = 10., .skipsLayer = false},
+    {.from = 4, .to = 5, .sourceMin = -10., .sourceMax = 10., .skipsLayer = false},
+  }};
+
+  /// The pipe between layers 2 and 3, 4 cm short of layer 3.
+  static constexpr std::array<PassiveSpec, 1> passives{{{.kind = PassiveSpec::Kind::kBarrel, .position = 3., .bandLow = 2.95, .bandHigh = 3.05, .low = -20., .high = 20., .x2X0 = 0.01}}};
+
+  static constexpr int nSensors = countSensors(barrelLayers, discLayers);
+};
+
+[[maybe_unused]] const bool kToyPipePublished = publishToy<ToyPipe>();
+
+using Det = ToyPipe;
+static_assert(Detector<Det>::nPassives == 1);
+static_assert(Detector<detectors::ToyBarrel3>::nPassives == 0);
+
+constexpr double kLayerX2X0 = 1.e-3;
+constexpr double kPipeRadius = 3.;
+constexpr double kBzKiloGauss = 20.;
+constexpr double kMinPtGeV = 0.3;
+constexpr std::size_t kCrossingLink = 2; // 2 -> 3
+constexpr std::size_t kBeyondLink = 3;   // 3 -> 4, the pipe inside its source
+
+SearchWindowParams windowParams()
+{
+  SearchWindowParams params;
+  params.minPtGeV = kMinPtGeV;
+  params.bzKiloGauss = kBzKiloGauss;
+  params.positionSigma = 5.e-4;
+  return params;
+}
+
+const VertexConstraint kBeamSpot{.z = 0., .sigmaZ = 1., .sigmaTransverse = 0.002};
+
+ScatteringTable<Det> table(double pipeX2X0)
+{
+  const std::array<double, 1> pipe{pipeX2X0};
+  return scatteringTable<Det>(uniformLayerMaterial<Det>(kLayerX2X0), pipe);
+}
+
+/// One track's crossings of the six layers, kinked on the way.
+struct Crossings {
+  std::array<PairPoint, 6> points{};
+  bool complete = false;
+};
+
+/// Follow a helix of transverse momentum \a pt from the beam line, kinking
+/// it at every radius in \a scatterers with its Highland theta0 at the
+/// crossing, and record where it crosses each layer.
+Crossings follow(double pt, double phi, double cotTheta, double charge, double vertexZ, std::span<const double> scatterers, std::span<const double> scattererX2X0, std::mt19937& rng)
+{
+  std::normal_distribution<double> gauss(0., 1.);
+  const double radius = curvatureRadius(pt, kBzKiloGauss);
+  const auto& layers = Det::barrelSpecs;
+  // Every radius the track has to reach, in order, and what happens there.
+  struct Stop {
+    double r;
+    int layer;   // -1: a scatterer only
+    double x2X0; // scattering at the crossing
+  };
+  std::vector<Stop> stops;
+  stops.reserve(layers.size() + scatterers.size());
+  int layer = 0;
+  for (const auto& spec : layers) {
+    stops.push_back({.r = spec.r, .layer = layer++, .x2X0 = kLayerX2X0});
+  }
+  for (std::size_t i = 0; i < scatterers.size(); ++i) {
+    stops.push_back({.r = scatterers[i], .layer = -1, .x2X0 = scattererX2X0[i]});
+  }
+  std::ranges::sort(stops, {}, &Stop::r);
+
+  Crossings result;
+  double x = 0.;
+  double y = 0.;
+  double z = vertexZ;
+  for (const auto& stop : stops) {
+    // The helix from (x, y) at azimuth phi, by transverse path s:
+    // x + (R/q)(sin(phi + q s/R) - sin phi), y - (R/q)(cos(phi + q s/R) - cos phi).
+    const auto at = [&](double path, double& px, double& py) {
+      const double turned = phi + (charge * path / radius);
+      px = x + (radius / charge * (std::sin(turned) - std::sin(phi)));
+      py = y - (radius / charge * (std::cos(turned) - std::cos(phi)));
+    };
+    double low = 0.;
+    double high = 0.;
+    double px = x;
+    double py = y;
+    // Grow the bracket in quarter-radius steps; turning back before the stop ends the track.
+    double previousR = std::hypot(x, y);
+    while (true) {
+      high += 0.25 * std::min(radius, stop.r);
+      at(high, px, py);
+      const double r = std::hypot(px, py);
+      if (r >= stop.r) {
+        break;
+      }
+      if (r <= previousR) {
+        return result;
+      }
+      previousR = r;
+      low = high;
+    }
+    for (int i = 0; i < 60; ++i) {
+      const double mid = 0.5 * (low + high);
+      at(mid, px, py);
+      (std::hypot(px, py) < stop.r ? low : high) = mid;
+    }
+    const double path = 0.5 * (low + high);
+    at(path, px, py);
+    x = px;
+    y = py;
+    z += cotTheta * path;
+    phi += charge * path / radius;
+    if (stop.layer >= 0) {
+      const auto r = static_cast<Scalar>(std::hypot(x, y));
+      result.points[static_cast<std::size_t>(stop.layer)] = {
+        .x = static_cast<Scalar>(x),
+        .y = static_cast<Scalar>(y),
+        .z = static_cast<Scalar>(z),
+        .r = r,
+        .varZ = 2.5e-7F,
+        .varR = 2.5e-7F,
+        .varRPhi = 2.5e-7F,
+      };
+    }
+    // The kink: Highland at normal incidence times the path factor, at the
+    // track's momentum, in two projections.
+    const double sinTheta = 1. / std::sqrt(1. + (cotTheta * cotTheta));
+    const double pathFactor = 1. / sinTheta;
+    const double p = pt / sinTheta;
+    const double theta0 = std::sqrt(detail::highlandFactor(stop.x2X0) * pathFactor) / p;
+    phi += gauss(rng) * theta0 / sinTheta;
+    const double theta = std::atan2(1., cotTheta) + (gauss(rng) * theta0);
+    cotTheta = std::cos(theta) / std::sin(theta);
+  }
+  result.complete = true;
+  return result;
+}
+
+struct LinkCount {
+  int pairs = 0;
+  int accepted = 0;
+  int inPhiWindow = 0;
+  int inSecondWindow = 0;
+};
+
+/// Pairs of consecutive layers of tracks at pT_min -- where the curvature test
+/// is the n-sigma test it states -- tested with the cut
+/// as the tracklet stage runs it -- \a withBetween false leaves the kink
+/// between source and target out, \a cutTable is the table the cut is built
+/// with.
+std::array<LinkCount, 5> countPairs(const ScatteringTable<Det>& cutTable, bool withBetween, double pipeX2X0, int tracks)
+{
+  IterationSettings settings;
+  settings.windows = windowParams();
+  const auto parameters = iterationParameters<Det>(settings, kBeamSpot, cutTable);
+  const auto beamLine = vertexSeed(kBeamSpot);
+  std::mt19937 rng(20260930);
+  std::uniform_real_distribution<double> uniform(0., 1.);
+  std::normal_distribution<double> gauss(0., 1.);
+  const std::array<double, 1> scatterers{kPipeRadius};
+  const std::array<double, 1> scattererX2X0{pipeX2X0};
+  std::array<LinkCount, 5> counts{};
+  for (int track = 0; track < tracks; ++track) {
+    const double phi = 2. * std::numbers::pi * uniform(rng);
+    const double cotTheta = -0.5 + uniform(rng);
+    const double charge = track % 2 == 0 ? 1. : -1.;
+    const double vertexZ = gauss(rng) * kBeamSpot.sigmaZ;
+    const auto crossings = follow(kMinPtGeV, phi, cotTheta, charge, vertexZ, scatterers, scattererX2X0, rng);
+    if (!crossings.complete) {
+      continue;
+    }
+    for (std::size_t link = 0; link < Det::layerLinks.size(); ++link) {
+      const auto& source = crossings.points[Det::layerLinks[link].from];
+      const auto& target = crossings.points[Det::layerLinks[link].to];
+      const Scalar scatter = sourceScattering<Det>(parameters.scattering, parameters.pairCut, beamLine, Det::layerLinks[link].from, source);
+      const Scalar between = withBetween && parameters.passiveBetween[link] ? betweenScattering<Det>(parameters.scattering, parameters.pairCut, beamLine, source, target) : 0.F;
+      auto& count = counts[link];
+      ++count.pairs;
+      if (!pairCompatible(parameters.pairCut, beamLine, source, scatter, target, between)) {
+        continue;
+      }
+      ++count.accepted;
+      const auto& window = parameters.windows[link];
+      const double dPhi = std::remainder(std::atan2(target.y, target.x) - std::atan2(source.y, source.x), 2. * std::numbers::pi);
+      count.inPhiWindow += std::abs(dPhi) <= static_cast<double>(window.phiHalfWidth) ? 1 : 0;
+      const double centre = (static_cast<double>(window.secondScale) * static_cast<double>(source.z)) + static_cast<double>(window.secondOffset);
+      count.inSecondWindow += std::abs(static_cast<double>(target.z) - centre) <= static_cast<double>(window.secondHalfWidth) ? 1 : 0;
+    }
+  }
+  return counts;
+}
+
+double share(int part, int whole) { return whole == 0 ? 0. : static_cast<double>(part) / static_cast<double>(whole); }
+
+/// Consecutive triplets and neighbours of tracks at pT_min, through the
+/// stages' own cuts with \a cutTable: a triplet counted when both its pairs
+/// pass, a neighbour when both its triplets do -- what the stages see.
+struct ChainCounts {
+  std::array<LinkCount, 4> triplets{}; ///< first link 0..3
+  std::array<LinkCount, 3> neighbours{};
+};
+
+ChainCounts countChains(const ScatteringTable<Det>& cutTable, double pipeX2X0, int tracks)
+{
+  IterationSettings settings;
+  settings.windows = windowParams();
+  const auto parameters = iterationParameters<Det>(settings, kBeamSpot, cutTable);
+  const auto beamLine = vertexSeed(kBeamSpot);
+  std::mt19937 rng(20261001);
+  std::uniform_real_distribution<double> uniform(0., 1.);
+  std::normal_distribution<double> gauss(0., 1.);
+  const std::array<double, 1> scatterers{kPipeRadius};
+  const std::array<double, 1> scattererX2X0{pipeX2X0};
+  const TripletTargetBounds bounds{.varZ = 2.5e-7F, .varR = 2.5e-7F, .varRPhi = 2.5e-7F};
+  ChainCounts counts;
+  for (int track = 0; track < tracks; ++track) {
+    const double phi = 2. * std::numbers::pi * uniform(rng);
+    const double cotTheta = -0.5 + uniform(rng);
+    const double charge = track % 2 == 0 ? 1. : -1.;
+    const double vertexZ = gauss(rng) * kBeamSpot.sigmaZ;
+    const auto crossings = follow(kMinPtGeV, phi, cotTheta, charge, vertexZ, scatterers, scattererX2X0, rng);
+    if (!crossings.complete) {
+      continue;
+    }
+    const auto timed = [&](std::size_t layer) { return TimedPoint{.point = crossings.points[layer], .time = {.start = 0U, .width = 1U}}; };
+    std::array<bool, 5> pairPasses{};
+    for (std::size_t link = 0; link < Det::layerLinks.size(); ++link) {
+      const auto& source = crossings.points[Det::layerLinks[link].from];
+      const auto& target = crossings.points[Det::layerLinks[link].to];
+      const Scalar scatter = sourceScattering<Det>(parameters.scattering, parameters.pairCut, beamLine, Det::layerLinks[link].from, source);
+      const Scalar between = parameters.passiveBetween[link] ? betweenScattering<Det>(parameters.scattering, parameters.pairCut, beamLine, source, target) : 0.F;
+      pairPasses[link] = pairCompatible(parameters.pairCut, beamLine, source, scatter, target, between);
+    }
+    std::array<bool, 4> tripletPasses{};
+    std::array<TripletFitResult, 4> fits{};
+    std::array<KinkTerms, 4> terms{};
+    for (std::size_t first = 0; first + 1U < Det::layerLinks.size(); ++first) {
+      if (!pairPasses[first] || !pairPasses[first + 1U]) {
+        continue;
+      }
+      const auto a = timed(first);
+      const auto b = timed(first + 1U);
+      const auto c = timed(first + 2U);
+      auto& count = counts.triplets[first];
+      ++count.pairs;
+      const auto dip = [](const PairPoint& from, const PairPoint& to) { return std::atan2(static_cast<double>(to.z - from.z), std::hypot(static_cast<double>(to.x - from.x), static_cast<double>(to.y - from.y))); };
+      const auto middleLayer = static_cast<LayerID>(first + 1U);
+      const auto halfWidth = static_cast<double>(tripletLambdaHalfWidth(parameters, first + 1U, middleLayer, a.point, b.point, bounds));
+      if (std::abs(dip(b.point, c.point) - dip(a.point, b.point)) > halfWidth) {
+        continue;
+      }
+      bool kinked = false;
+      if (!tripletCompatible(parameters, middleLayer, a, b, c, fits[first], terms[first], kinked)) {
+        continue;
+      }
+      tripletPasses[first] = true;
+      ++count.accepted;
+    }
+    // GCC 14 addresses `neighbours[first]` as `triplets[4 + first]` once
+    // the cuts are inlined and finds that subscript out of bounds;
+    // `first` stays below `neighbours.size()`.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+    for (std::size_t first = 0; first + 2U < Det::layerLinks.size(); ++first) {
+      if (!tripletPasses[first] || !tripletPasses[first + 1U]) {
+        continue;
+      }
+      auto& count = counts.neighbours[first];
+      ++count.pairs;
+      if (!neighbourCurvatureCompatible(parameters, fits[first].curvature, fits[first].varCurvature, fits[first + 1U].curvature, fits[first + 1U].varCurvature)) {
+        continue;
+      }
+      TripletFitResult fit;
+      KinkTerms bcd;
+      bool made = false;
+      bool valid = false;
+      if (neighbourCompatible(parameters, static_cast<LayerID>(first + 1U), static_cast<LayerID>(first + 2U), timed(first), timed(first + 1U), timed(first + 2U), timed(first + 3U), bcd, made, valid, fit, 1.F, 1.F)) {
+        ++count.accepted;
+      }
+    }
+#pragma GCC diagnostic pop
+  }
+  return counts;
+}
+
+} // namespace
+
+/// The layout's pipe reaches the table with its nominal or the given x/X0;
+/// a layout without one has none, and its table's slot is empty.
+BOOST_AUTO_TEST_CASE(ThePipeIsInTheTable)
+{
+  const auto nominal = scatteringTable<Det>(uniformLayerMaterial<Det>(kLayerX2X0));
+  BOOST_TEST(nominal.passives[0].barrel);
+  BOOST_TEST(nominal.passives[0].at.position == 3.F);
+  BOOST_TEST(nominal.passives[0].at.k == static_cast<Scalar>(detail::highlandFactor(0.01)));
+  BOOST_TEST(table(0.02).passives[0].at.k == static_cast<Scalar>(detail::highlandFactor(0.02)));
+  BOOST_TEST(nominalPassiveMaterial<Det>()[0] == 0.01);
+  BOOST_CHECK_THROW(static_cast<void>(scatteringTable<Det>(uniformLayerMaterial<Det>(kLayerX2X0), std::array<double, 2>{0.01, 0.01})), std::invalid_argument);
+}
+
+/// Only the link across the pipe has it between its layers; a source beyond
+/// the pipe has it inside, a source inside the pipe does not.
+BOOST_AUTO_TEST_CASE(ThePipeIsBetweenOrInsideByRadius)
+{
+  IterationSettings settings;
+  settings.windows = windowParams();
+  const auto withPipe = table(0.01);
+  const auto parameters = iterationParameters<Det>(settings, kBeamSpot, withPipe);
+  for (std::size_t link = 0; link < Det::layerLinks.size(); ++link) {
+    BOOST_TEST_CONTEXT("link " << link) { BOOST_TEST(parameters.passiveBetween[link] == (link == kCrossingLink)); }
+  }
+  BOOST_TEST(betweenKinkBound<Det>(withPipe, settings.windows, 2, 3, kBeamSpot) > 0.);
+  BOOST_TEST(betweenKinkBound<Det>(withPipe, settings.windows, 3, 4, kBeamSpot) == 0.);
+
+  const auto withoutPipe = table(0.);
+  const auto cut = pairCut(settings.windows);
+  const auto beamLine = vertexSeed(kBeamSpot);
+  const PairPoint inside{.x = 2.5F, .z = 0.5F, .r = 2.5F};
+  const PairPoint beyond{.x = 7.F, .z = 1.4F, .r = 7.F};
+  const PairPoint far{.x = 10.F, .z = 2.F, .r = 10.F};
+  BOOST_TEST(sourceScattering<Det>(withPipe, cut, beamLine, 2, inside) == sourceScattering<Det>(withoutPipe, cut, beamLine, 2, inside));
+  BOOST_TEST(sourceScattering<Det>(withPipe, cut, beamLine, 3, beyond) > sourceScattering<Det>(withoutPipe, cut, beamLine, 3, beyond));
+  BOOST_TEST(betweenScattering<Det>(withPipe, cut, beamLine, inside, beyond) > 0.F);
+  BOOST_TEST(betweenScattering<Det>(withoutPipe, cut, beamLine, inside, beyond) == 0.F);
+  BOOST_TEST(betweenScattering<Det>(withPipe, cut, beamLine, beyond, far) == 0.F);
+}
+
+/// Tracks scattered as the cut models them pass it at its n-sigma share on
+/// every link, and the windows hold the pairs the cut accepts. Without the
+/// kink between source and target, the pairs across the pipe fail; without
+/// the pipe inside the source, the pairs beyond it.
+/// No pair's kink between its layers exceeds the link's bound: the tracklet
+/// stage's test at the bound refuses only pairs the pair's own kink would
+/// refuse too (ALICE 3's barrel: testTrkChainPulls).
+BOOST_AUTO_TEST_CASE(NoPairsKinkExceedsItsLinksBound)
+{
+  const auto ratios = test::betweenOverBound<Det>(table(0.01), windowParams(), kBeamSpot);
+  BOOST_TEST(ratios.size() == 1U);
+  for (const auto& ratio : ratios) {
+    BOOST_TEST(ratio.worst <= 1.);
+    BOOST_TEST(ratio.maskMismatches == 0);
+    BOOST_TEST(ratio.sourcePartMismatches == 0);
+  }
+  BOOST_TEST(test::segmentMaskMismatches<Det>(table(0.01)) == 0);
+}
+
+BOOST_AUTO_TEST_CASE(TruePairsPassAcrossAndBeyondThePipe)
+{
+  constexpr int kTracks = 20000;
+  constexpr double kPipeX2X0 = 0.01;
+  const auto full = countPairs(table(kPipeX2X0), true, kPipeX2X0, kTracks);
+  for (std::size_t link = 0; link < full.size(); ++link) {
+    const auto& count = full[link];
+    BOOST_TEST_MESSAGE("link " << link << ": " << count.accepted << "/" << count.pairs << " accepted, " << count.inPhiWindow << " and " << count.inSecondWindow << " of them in the phi and second windows");
+    BOOST_TEST_CONTEXT("link " << link)
+    {
+      BOOST_TEST(count.pairs > kTracks / 2);
+      // 3 sigma: 0.13 % one-sided on the curvature, 0.27 % on the pitch.
+      BOOST_TEST(share(count.accepted, count.pairs) > 0.993);
+      BOOST_TEST(count.inPhiWindow == count.accepted);
+      BOOST_TEST(count.inSecondWindow == count.accepted);
+    }
+  }
+
+  const auto noBetween = countPairs(table(kPipeX2X0), false, kPipeX2X0, kTracks);
+  BOOST_TEST_MESSAGE("without the kink between: link 2 " << noBetween[kCrossingLink].accepted << "/" << noBetween[kCrossingLink].pairs);
+  BOOST_TEST(share(noBetween[kCrossingLink].accepted, noBetween[kCrossingLink].pairs) < 0.98);
+
+  const auto noPipe = countPairs(table(0.), true, kPipeX2X0, kTracks);
+  BOOST_TEST_MESSAGE("without the pipe in the table: link 3 " << noPipe[kBeyondLink].accepted << "/" << noPipe[kBeyondLink].pairs);
+  BOOST_TEST(share(noPipe[kBeyondLink].accepted, noPipe[kBeyondLink].pairs) < 0.98);
+}
+
+/// Triplets and neighbours with the pipe between their points, of every kind
+/// -- between the first two, the middle two, the last two -- pass their cuts
+/// at the n-sigma share when the cuts take its kink where it happens, and
+/// fail without it.
+BOOST_AUTO_TEST_CASE(TripletsAndNeighboursAcrossThePipe)
+{
+  constexpr int kTracks = 20000;
+  constexpr double kPipeX2X0 = 0.01;
+  const auto full = countChains(table(kPipeX2X0), kPipeX2X0, kTracks);
+  const auto without = countChains(table(0.), kPipeX2X0, kTracks);
+  for (std::size_t first = 0; first < full.triplets.size(); ++first) {
+    BOOST_TEST_MESSAGE("triplet " << first << "-" << first + 2U << ": " << full.triplets[first].accepted << "/" << full.triplets[first].pairs << ", without the pipe " << without.triplets[first].accepted << "/" << without.triplets[first].pairs);
+    BOOST_TEST_CONTEXT("triplet from layer " << first) { BOOST_TEST(share(full.triplets[first].accepted, full.triplets[first].pairs) > 0.99); }
+  }
+  for (std::size_t first = 0; first < full.neighbours.size(); ++first) {
+    BOOST_TEST_MESSAGE("neighbour " << first << "-" << first + 3U << ": " << full.neighbours[first].accepted << "/" << full.neighbours[first].pairs << ", without the pipe " << without.neighbours[first].accepted << "/" << without.neighbours[first].pairs);
+    BOOST_TEST_CONTEXT("neighbour from layer " << first) { BOOST_TEST(share(full.neighbours[first].accepted, full.neighbours[first].pairs) > 0.99); }
+  }
+  // The pipe lies 0.5 cm beyond layer 2 of the 4.5 between layers 2 and 3.
+  // Between the middle points it matters: the triplet 1-3 and the neighbour
+  // 1-4 fail without it. Just past the first point, t = 0.11, it turns the
+  // angle at `b` by 0.11 theta_p and hardly shows (triplet 2-4).
+  BOOST_TEST(share(without.triplets[1].accepted, without.triplets[1].pairs) < 0.9);
+  BOOST_TEST(share(without.neighbours[1].accepted, without.neighbours[1].pairs) < 0.95);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testPlacedLayouts.cxx b/Detectors/GenericTracking/tracking/test/testPlacedLayouts.cxx
new file mode 100644
index 0000000000000..382a8a75e4cea
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testPlacedLayouts.cxx
@@ -0,0 +1,379 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testPlacedLayouts.cxx
+/// \brief Placed-layout extents, empty tracking and curved-sensor geometry.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK placed layouts
+#include <boost/test/unit_test.hpp>
+#include "GenericTracking/Base/LayerEnvelopes.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Tracking/MeasurementGridBuilder.h"
+#include "GenericTracking/Tracking/Tracker.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GridTestSupport.h"
+#include "UniformMaterial.h"
+#include "ToyBarrel3.h"
+#include "ToyBarrel4Disc8.h"
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <memory>
+#include <numbers>
+#include <span>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+namespace o2::gtrk
+{
+using detectors::ITS;
+using detectors::MFT;
+using detectors::ToyBarrel3;
+using detectors::ToyBarrel4Disc8;
+constexpr double kPositionTolerance = 1e-9;
+static_assert(DetectorLayout<ToyBarrel3>);
+static_assert(DetectorLayout<ToyBarrel4Disc8>);
+
+// The topology each toy exists to represent.
+static_assert(Detector<ToyBarrel3>::hasBarrel && !Detector<ToyBarrel3>::hasDiscs);
+static_assert(Detector<ToyBarrel4Disc8>::hasBarrel && Detector<ToyBarrel4Disc8>::hasDiscs);
+static_assert(Detector<ToyBarrel3>::nLayers == 3);
+static_assert(Detector<ToyBarrel4Disc8>::nBarrelLayers == 4);
+static_assert(Detector<ToyBarrel4Disc8>::nDiscLayers == 8);
+static_assert(Detector<ToyBarrel4Disc8>::isBarrelLayer(0));
+static_assert(Detector<ToyBarrel4Disc8>::isBarrelLayer(3));
+static_assert(!Detector<ToyBarrel4Disc8>::isBarrelLayer(4));
+static_assert(Detector<ToyBarrel4Disc8>::discIndex(4) == 0U);
+
+// Sensor counts are derived, never typed in twice, so this cannot drift.
+static_assert(ToyBarrel3::nSensors == 12);
+
+namespace
+{
+static_assert(Detector<ITS>::nBarrelLayers == 7 && Detector<ITS>::nDiscLayers == 0);
+static_assert(Detector<MFT>::nBarrelLayers == 0 && Detector<MFT>::nDiscLayers == 10);
+static_assert(ITS::nSensors == 24120 && MFT::nSensors == 936);
+
+/// Every link joins two layers of its detector, and none joins a layer to itself.
+template <DetectorLayout Det>
+void checkLinks()
+{
+  for (const auto& link : Det::layerLinks) {
+    BOOST_TEST(link.from < Detector<Det>::nLayers);
+    BOOST_TEST(link.to < Detector<Det>::nLayers);
+    BOOST_TEST(link.from != link.to);
+    BOOST_TEST(link.sourceMin < link.sourceMax);
+  }
+}
+
+/// Where a stand-in layer sits: the ITS's radii and the MFT's disc z, roughly.
+template <DetectorLayout Det>
+double standInPosition(LayerID layer)
+{
+  return Detector<Det>::isBarrelLayer(layer) ? 2.3 + (6.2 * static_cast<double>(layer)) : -45.3 - (3.6 * static_cast<double>(layer));
+}
+
+/// A stand-in placement: every chip on its layer at the same place, facing
+/// along x on a barrel layer and along z on a disc, with the disc chips 8 cm
+/// from the beam. Enough to build the tracking geometry; not a detector.
+template <DetectorLayout Det>
+std::vector<Sensor> standInPlacements(double shiftZ = 0.)
+{
+  std::vector<Sensor> sensors;
+  for (int layer = 0; layer < Detector<Det>::nLayers; ++layer) {
+    const auto id = static_cast<LayerID>(layer);
+    for (int chip = 0; chip < Detector<Det>::sensorCount(id); ++chip) {
+      Sensor sensor{};
+      if (Detector<Det>::isBarrelLayer(id)) {
+        sensor.rot[3] = sensor.rot[7] = sensor.rot[2] = 1.; // local x, y, z along global y, z, x
+        sensor.trans[0] = standInPosition<Det>(id);
+      } else {
+        sensor.rot[0] = sensor.rot[4] = sensor.rot[8] = 1.; // local axes along the global ones
+        sensor.trans[0] = 8.;
+        sensor.trans[2] = standInPosition<Det>(id);
+      }
+      sensor.trans[2] += shiftZ;
+      sensor.layer = id;
+      sensors.push_back(sensor);
+    }
+  }
+  return sensors;
+}
+
+/// The whole tracker, run on an empty timeframe: that it compiles and runs
+/// for a barrel-only and a disc-only placed layout is the point.
+template <DetectorLayout Det>
+void runEmpty()
+{
+  const auto sensors = standInPlacements<Det>();
+  const auto geometry = std::make_unique<const Geometry<Det>>(sensors);
+  const auto tracking = std::make_unique<const TrackingGeometry<Det>>(*geometry);
+  BOOST_TEST(tracking->surface(0).bounds.halfX == static_cast<Scalar>(detectors::alpide::kSensor.halfX));
+
+  const SearchWindowParams windows{.minPtGeV = 0.3, .bzKiloGauss = 5.};
+  const VertexConstraint beamSpot{.z = 0., .sigmaZ = 6., .sigmaTransverse = 0.002};
+  const GridGeometry<Det> grid{20'000'000, test::withToyFrames(GridParams{}), test::oneIterationWindows<Det>(windows, beamSpot)};
+  std::vector<std::uint32_t> offsets(static_cast<std::size_t>(grid.bucketCount()) + 1U, 0U);
+  const MeasurementStore columns;
+  const TimeFrame<Det> frame{measurementView(columns), grid, std::span<const std::uint32_t>{offsets}};
+
+  const IterationSettings settings{.windows = windows, .vertexSource = VertexSource::kBeamLine};
+  Tracker<Det, UniformMaterial> tracker{settings, beamSpot, scatteringTable<Det>(uniformLayerMaterial<Det>(0.01)), std::make_shared<BoundedMemoryResource>(), 1U};
+  tracker.setTrackModel(*tracking, UniformMaterial{}, Propagator{.bzKiloGauss = 5.F});
+  const auto result = tracker.run(frame, tracker.planTimeframe(frame, {}, 1, 0.));
+  BOOST_TEST((result.status == StageStatus::kComplete));
+  BOOST_REQUIRE(result.tracks != nullptr);
+  BOOST_TEST(result.tracks->size() == 0U);
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(ExtentsNeedAGeometry)
+{
+  BOOST_CHECK_THROW(static_cast<void>(layerDistance<ITS>(0)), std::logic_error);
+  BOOST_CHECK_THROW(static_cast<void>(discZ<MFT>(0)), std::logic_error);
+}
+
+BOOST_AUTO_TEST_CASE(LinkTablesJoinLayersOfTheirDetector)
+{
+  checkLinks<ITS>();
+  checkLinks<MFT>();
+}
+
+BOOST_AUTO_TEST_CASE(ExtentsAreMeasuredFromThePlacements)
+{
+  const auto& half = detectors::alpide::kSensor;
+  {
+    const Geometry<ITS> geometry{standInPlacements<ITS>()};
+    for (LayerID layer = 0; layer < Detector<ITS>::nLayers; ++layer) {
+      const auto& e = PlacedEnvelopes<ITS>::all()[layer];
+      const double radius = standInPosition<ITS>(layer);
+      BOOST_TEST(layerDistance<ITS>(layer) == e.position);
+      BOOST_TEST(e.position == radius, boost::test_tools::tolerance(1e-9));
+      // The chip faces along x: its thickness spans r, its columns z.
+      BOOST_TEST(radiusMin<ITS>(layer) == e.rMin);
+      BOOST_TEST(e.rMin <= radius - half.halfThickness);
+      BOOST_TEST(e.rMin > radius - half.halfThickness - 2. * kEnvelopeResolution);
+      BOOST_TEST(radiusMax<ITS>(layer) == e.rMax);
+      BOOST_TEST(e.rMax >= std::hypot(radius + half.halfThickness, half.halfX));
+      BOOST_TEST(secondMin<ITS>(layer) == e.zMin);
+      BOOST_TEST(e.zMin <= -half.halfY);
+      BOOST_TEST(secondMax<ITS>(layer) == e.zMax);
+      BOOST_TEST(e.zMax >= half.halfY);
+      BOOST_TEST(discZ<ITS>(layer) == 0.);
+    }
+  }
+  {
+    const Geometry<MFT> geometry{standInPlacements<MFT>()};
+    for (LayerID layer = 0; layer < Detector<MFT>::nLayers; ++layer) {
+      const auto& e = PlacedEnvelopes<MFT>::all()[layer];
+      const double z = standInPosition<MFT>(layer);
+      BOOST_TEST(discZ<MFT>(layer) == e.position);
+      BOOST_TEST(e.position == z, boost::test_tools::tolerance(1e-9));
+      BOOST_TEST(layerDistance<MFT>(layer) == -e.position); // the MFT is on the C side
+      BOOST_TEST(secondMin<MFT>(layer) == e.rMin);
+      BOOST_TEST(e.rMin <= 8. - half.halfX);
+      BOOST_TEST(secondMax<MFT>(layer) == e.rMax);
+      BOOST_TEST(e.rMax >= std::hypot(8. + half.halfX, half.halfY));
+      BOOST_TEST(zMin<MFT>(layer) == e.zMin);
+      BOOST_TEST(e.zMin <= z - half.halfThickness);
+      BOOST_TEST(zMax<MFT>(layer) == e.zMax);
+      BOOST_TEST(e.zMax >= z + half.halfThickness);
+    }
+  }
+  // A later geometry of the same layout replaces the table: shifted by 1 cm
+  // along z, every z extent follows to the micron.
+  {
+    const Geometry<MFT> shifted{standInPlacements<MFT>(1.)};
+    for (LayerID layer = 0; layer < Detector<MFT>::nLayers; ++layer) {
+      BOOST_TEST(discZ<MFT>(layer) == standInPosition<MFT>(layer) + 1., boost::test_tools::tolerance(1e-9));
+      BOOST_TEST(zMin<MFT>(layer) == PlacedEnvelopes<MFT>::all()[layer].zMin);
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(GridPointsAreAboutTheBeamLine)
+{
+  constexpr double kBeamX = -0.057;
+  constexpr double kBeamY = -0.0565;
+  auto moved = standInPlacements<ITS>();
+  for (auto& sensor : moved) {
+    sensor.trans[0] += kBeamX;
+    sensor.trans[1] += kBeamY;
+  }
+  const Geometry<ITS> reference{standInPlacements<ITS>()};
+  const Geometry<ITS> shifted{moved};
+  const auto tolerance = boost::test_tools::tolerance(1e-5F);
+  for (const SensorID chip : {SensorID{0}, SensorID{107}, SensorID{24119}}) {
+    for (const auto& [loc0, loc1] : {std::pair{0.3, -1.1}, std::pair{-0.6, 0.9}}) {
+      const auto a = gridPoint<ITS>(reference, chip, loc0, loc1);
+      const auto b = gridPoint<ITS>(shifted, chip, loc0, loc1, kBeamX, kBeamY);
+      BOOST_TEST(b.layer == a.layer);
+      BOOST_TEST(b.x == a.x, tolerance);
+      BOOST_TEST(b.y == a.y, tolerance);
+      BOOST_TEST(b.z == a.z, tolerance);
+      BOOST_TEST(b.r == a.r, tolerance);
+      BOOST_TEST(b.phi == a.phi, tolerance);
+      BOOST_TEST(b.second == a.second, tolerance);
+      const auto va = pointVariances<ITS>(reference, chip, loc0, a, 1e-6F, 0.F, 4e-6F);
+      const auto vb = pointVariances<ITS>(shifted, chip, loc0, b, 1e-6F, 0.F, 4e-6F);
+      BOOST_TEST(vb.z == va.z, tolerance);
+      BOOST_TEST(vb.r == va.r, tolerance);
+      BOOST_TEST(vb.rPhi == va.rPhi, tolerance);
+      // And without the subtraction the moved geometry is off by the beam.
+      const auto c = gridPoint<ITS>(shifted, chip, loc0, loc1);
+      BOOST_TEST(static_cast<double>(c.x - a.x) == kBeamX, boost::test_tools::tolerance(1e-3));
+      BOOST_TEST(static_cast<double>(c.y - a.y) == kBeamY, boost::test_tools::tolerance(1e-3));
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(PlacedGeometryRejectsAWrongCount)
+{
+  auto sensors = standInPlacements<MFT>();
+  sensors.pop_back();
+  BOOST_CHECK_THROW(Geometry<MFT>{sensors}, std::invalid_argument);
+  sensors = standInPlacements<MFT>();
+  sensors.back().layer = static_cast<LayerID>(Detector<MFT>::nLayers);
+  BOOST_CHECK_THROW(Geometry<MFT>{sensors}, std::invalid_argument);
+  // Every chip moved onto layer 0: the count agrees, but a layer is empty.
+  sensors = standInPlacements<MFT>();
+  for (auto& sensor : sensors) {
+    sensor.layer = 0;
+  }
+  BOOST_CHECK_THROW(Geometry<MFT>{sensors}, std::runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(TrackerRunsOnTheIts) { runEmpty<ITS>(); }
+
+BOOST_AUTO_TEST_CASE(TrackerRunsOnTheMft) { runEmpty<MFT>(); }
+namespace
+{
+
+/// A curved sensor like the ALICE 3 VD's: a 71 degree arc of a 0.5 cm cylinder,
+/// 20 um thick and 50 cm long.
+constexpr SensorSpec kCurved{.shape = ShapeType::kCylinder, .halfX = 0.3112, .halfY = 25., .halfThickness = 0.001, .pitchX = 0.001, .pitchY = 0.001, .radius = 0.5};
+
+/// A sensor rotated by \a angle about the beam axis and moved by \a t.
+Sensor rotatedAboutBeam(double angle, std::array<double, 3> t)
+{
+  Sensor sensor{};
+  const double c = std::cos(angle);
+  const double s = std::sin(angle);
+  const double rot[9] = {c, -s, 0., s, c, 0., 0., 0., 1.};
+  std::ranges::copy(rot, std::begin(sensor.rot));
+  std::ranges::copy(t, std::begin(sensor.trans));
+  return sensor;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(CurvedSensorUnrollsOntoItsCylinder)
+{
+  // The middle of the arc is on the local +x axis, the unrolled z outwards.
+  double frame[3];
+  kCurved.unrolledToFrame(0., 3., 0.001, frame);
+  BOOST_TEST(std::abs(frame[0] - 0.501) < kPositionTolerance);
+  BOOST_TEST(std::abs(frame[1]) < kPositionTolerance);
+  BOOST_TEST(std::abs(frame[2] - 3.) < kPositionTolerance);
+  // The unrolled x is the arc length on the inner surface, counter-clockwise.
+  kCurved.unrolledToFrame(0.5 * std::numbers::pi / 4., 0., 0., frame);
+  BOOST_TEST(std::abs(frame[0] - frame[1]) < kPositionTolerance);
+  BOOST_TEST(frame[1] > 0.);
+  static_assert(exactlyEqual(kCurved.surfaceMin(), 0.) && exactlyEqual(kCurved.surfaceMax(), 2. * kCurved.halfThickness));
+}
+
+BOOST_AUTO_TEST_CASE(CurvedEnvelopeIsTheHullOfItsSilicon)
+{
+  // On the beam axis, and moved off it so far that the nearest and farthest
+  // points lie inside the arc rather than at its ends.
+  for (const auto& t : {std::array<double, 3>{0., 0., 0.}, std::array<double, 3>{0.03, -0.02, 1.}, std::array<double, 3>{0.2, 0.25, -2.}}) {
+    const auto sensor = rotatedAboutBeam(std::numbers::pi / 4., t);
+    const std::array<SensorSpec, 1> specs{kCurved};
+    const auto envelope = measureEnvelopes(std::span(&sensor, 1), specs, 1).front();
+    // The silicon sampled densely lies within the hull and reaches it.
+    double rMin = 1e9;
+    double rMax = 0.;
+    for (int i = 0; i <= 2000; ++i) {
+      const double x = -kCurved.halfX + (2. * kCurved.halfX * i / 2000.);
+      for (const double z : {kCurved.surfaceMin(), kCurved.surfaceMax()}) {
+        double frame[3];
+        kCurved.unrolledToFrame(x, 0., z, frame);
+        double global[3];
+        sensor.toGlobal(frame, global);
+        rMin = std::min(rMin, std::hypot(global[0], global[1]));
+        rMax = std::max(rMax, std::hypot(global[0], global[1]));
+      }
+    }
+    BOOST_TEST(envelope.rMin <= rMin + kPositionTolerance);
+    BOOST_TEST(envelope.rMax >= rMax - kPositionTolerance);
+    // 2000 steps over the arc miss an extremum by at most a micron.
+    BOOST_TEST(rMin - envelope.rMin < 1e-4);
+    BOOST_TEST(envelope.rMax - rMax < 1e-4);
+    BOOST_TEST(std::abs(envelope.zMin - (t[2] - 25.)) < kPositionTolerance);
+    BOOST_TEST(std::abs(envelope.zMax - (t[2] + 25.)) < kPositionTolerance);
+  }
+  // On the axis the position is the middle of the silicon.
+  const auto onAxis = rotatedAboutBeam(1., {0., 0., 0.});
+  const std::array<SensorSpec, 1> specs{kCurved};
+  BOOST_TEST(std::abs(measureEnvelopes(std::span(&onAxis, 1), specs, 1).front().position - 0.501) < kPositionTolerance);
+}
+
+BOOST_AUTO_TEST_CASE(CurvedSensorMustBeAboutTheBeam)
+{
+  auto tilted = rotatedAboutBeam(0., {0., 0., 0.});
+  const double c = std::cos(0.01);
+  const double s = std::sin(0.01);
+  const double rot[9] = {1., 0., 0., 0., c, -s, 0., s, c};
+  std::ranges::copy(rot, std::begin(tilted.rot));
+  const std::array<SensorSpec, 1> specs{kCurved};
+  BOOST_CHECK_THROW(static_cast<void>(measureEnvelopes(std::span(&tilted, 1), specs, 1)), std::runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(TangentPlaneTouchesItsCylinder)
+{
+  TrackingSurface cylinder{};
+  // A petal rotated by 135 degrees about a beam moved off the origin.
+  const Scalar c = std::cos(0.75F * std::numbers::pi_v<Scalar>);
+  const Scalar s = std::sin(0.75F * std::numbers::pi_v<Scalar>);
+  cylinder.axis0[0] = c;
+  cylinder.axis0[1] = s;
+  cylinder.axis1[0] = -s;
+  cylinder.axis1[1] = c;
+  cylinder.normal[2] = 1.F;
+  cylinder.origin[0] = 0.01F;
+  cylinder.origin[1] = -0.02F;
+  cylinder.origin[2] = 0.5F;
+  cylinder.radius = 1.2F;
+  for (const Scalar angle : {-0.7F, -0.1F, 0.F, 0.3F, 0.73F}) {
+    const auto plane = tangentPlane(cylinder, angle);
+    BOOST_TEST(plane.surfacePhi == angle);
+    // (axis0, axis1, normal) is right-handed and orthonormal.
+    const Scalar cross[3]{(plane.axis0[1] * plane.axis1[2]) - (plane.axis0[2] * plane.axis1[1]), (plane.axis0[2] * plane.axis1[0]) - (plane.axis0[0] * plane.axis1[2]), (plane.axis0[0] * plane.axis1[1]) - (plane.axis0[1] * plane.axis1[0])};
+    for (int i = 0; i < 3; ++i) {
+      BOOST_TEST(std::abs(cross[i] - plane.normal[i]) < 1e-6F);
+    }
+    // The touching point is on the cylinder at the angle, and its plane
+    // coordinates are its unrolled ones.
+    Scalar touch[3];
+    surfaceToGlobal(plane, cylinder.radius * angle, 0.2F, touch);
+    const Scalar local[3]{touch[0] - cylinder.origin[0], touch[1] - cylinder.origin[1], touch[2] - cylinder.origin[2]};
+    const Scalar x = (local[0] * c) + (local[1] * s);
+    const Scalar y = -(local[0] * s) + (local[1] * c);
+    BOOST_TEST(std::abs(std::hypot(x, y) - cylinder.radius) < 1e-6F);
+    BOOST_TEST(std::abs(std::atan2(y, x) - angle) < 1e-6F);
+    BOOST_TEST(std::abs(local[2] - 0.2F) < 1e-6F);
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testProfile.cxx b/Detectors/GenericTracking/tracking/test/testProfile.cxx
new file mode 100644
index 0000000000000..703c54a57ceaa
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testProfile.cxx
@@ -0,0 +1,159 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testProfile.cxx
+/// \brief Profile activation, nested zones, pool peaks and stage loops.
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK tracking profile
+#include <boost/test/unit_test.hpp>
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Tracking/Profile.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "SyntheticStage.h"
+#include <cstdint>
+#include <memory>
+#include <sstream>
+#include <string>
+namespace o2::gtrk
+{
+using profile::Phase;
+BOOST_AUTO_TEST_CASE(NothingWithoutActivation)
+{
+  BOOST_TEST(profile::current() == nullptr);
+  const profile::Zone zone{Phase::kRun};
+  profile::count(Phase::kRun, 1U, 1U);
+  BOOST_TEST(profile::current() == nullptr);
+}
+
+BOOST_AUTO_TEST_CASE(ZonesNest)
+{
+  profile::Profile result;
+  {
+    const profile::Activation activation{result, nullptr};
+    const profile::Zone run{Phase::kRun};
+    for (int repeat = 0; repeat < 3; ++repeat) {
+      const profile::Zone begin{Phase::kBegin};
+      BOOST_TEST((profile::current()->phase == Phase::kBegin));
+    }
+    BOOST_TEST((profile::current()->phase == Phase::kRun));
+    {
+      // An inner activation profiles into its own profile, and restores.
+      profile::Profile inner;
+      const profile::Activation nested{inner, nullptr};
+      const profile::Zone iteration{Phase::kIteration};
+      BOOST_TEST(profile::current()->profile == &inner);
+    }
+    BOOST_TEST(profile::current()->profile == &result);
+  }
+  BOOST_TEST(profile::current() == nullptr);
+  BOOST_TEST(result[Phase::kRun].calls == 1U);
+  BOOST_TEST(result[Phase::kBegin].calls == 3U);
+  BOOST_TEST(result[Phase::kIteration].calls == 0U);
+  BOOST_TEST(result[Phase::kBegin].seconds <= result[Phase::kRun].seconds);
+  BOOST_TEST((profile::info(Phase::kBegin).parent == Phase::kRun));
+}
+
+BOOST_AUTO_TEST_CASE(ZonesSeeThePoolsPeakInTheirWindow)
+{
+  BoundedMemoryResource pool;
+  void* held = pool.allocate(100U);
+  profile::Profile result;
+  {
+    const profile::Activation activation{result, &pool};
+    const profile::Zone run{Phase::kRun};
+    {
+      // A phase's peak counts what the pool held when it began.
+      const profile::Zone begin{Phase::kBegin};
+      void* bytes = pool.allocate(1000U);
+      pool.deallocate(bytes, 1000U);
+    }
+    BOOST_TEST(pool.getPeakMemory() == 1100U);
+    {
+      // A later, smaller phase sees its own peak, not the earlier one's.
+      const profile::Zone iteration{Phase::kIteration};
+      void* bytes = pool.allocate(10U);
+      pool.deallocate(bytes, 10U);
+    }
+    // Closing a window keeps the larger of the two.
+    BOOST_TEST(pool.getPeakMemory() == 1100U);
+  }
+  pool.deallocate(held, 100U);
+  BOOST_TEST(result[Phase::kBegin].peakBytes == 1100U);
+  BOOST_TEST(result[Phase::kIteration].peakBytes == 110U);
+  BOOST_TEST(result[Phase::kRun].peakBytes == 1100U);
+  BOOST_TEST(result[Phase::kBegin].peakGrowthBytes == 1000U);
+  BOOST_TEST(result[Phase::kIteration].peakGrowthBytes == 10U);
+  BOOST_TEST(result[Phase::kRun].peakGrowthBytes == 1000U);
+  BOOST_TEST(pool.getPeakMemory() == 1100U);
+
+  profile::Profile other;
+  other[Phase::kRun].peakBytes = 2000U;
+  result += other;
+  BOOST_TEST(result[Phase::kRun].peakBytes == 2000U);
+}
+
+BOOST_AUTO_TEST_CASE(StageLoopsFoldIntoTheirZones)
+{
+  using Output = StageOutput<TrackletT>;
+  constexpr std::uint32_t kElements = 1000U;
+  constexpr std::uint32_t kChunk = 64U;
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  Output output;
+  output.setMemoryPool(pool);
+  output.prepare(kElements);
+  detail::TaskArena cpuArena{4};
+  CpuStage<TrackletT> cpu{cpuArena};
+  cpu.setMemoryPool(pool);
+  cpu.setPhases({.reset = Phase::kTrackletReset, .generate = Phase::kTrackletGenerate, .scan = Phase::kTrackletScan, .place = Phase::kTrackletPlace});
+
+  profile::Profile result;
+  profile::Trace trace{4U};
+  {
+    const profile::Activation activation{result, pool.get(), &trace};
+    const profile::Zone zone{Phase::kTracklets};
+    BOOST_REQUIRE(cpu.run(output, kChunk, synthetic::Generator{}) == StageStatus::kComplete);
+    const profile::Zone sort{Phase::kTrackletSort};
+    cpu.forEachElement(kElements, kChunk, [](std::uint32_t) {});
+  }
+
+  const auto chunks = (kElements + kChunk - 1U) / kChunk;
+  const auto& generate = result[Phase::kTrackletGenerate];
+  BOOST_TEST(generate.calls == 1U);
+  BOOST_TEST(generate.regions == 1U);
+  BOOST_TEST(generate.elements == kElements);
+  BOOST_TEST(generate.outputs == output.size());
+  BOOST_TEST(generate.chunks == chunks);
+  BOOST_TEST(generate.busySeconds > 0.);
+  BOOST_TEST(generate.busySeconds <= generate.capacitySeconds);
+  BOOST_TEST(generate.regionSeconds <= generate.seconds);
+  const auto& place = result[Phase::kTrackletPlace];
+  BOOST_TEST(place.elements == output.size());
+  // The scan's loop over the chunks is a region of its phase too.
+  const auto& scan = result[Phase::kTrackletScan];
+  BOOST_TEST(scan.regions == 1U);
+  BOOST_TEST(scan.elements == kElements);
+  BOOST_TEST(scan.chunks == chunks);
+  BOOST_TEST(result[Phase::kTrackletReset].calls == 1U);
+  const auto& sort = result[Phase::kTrackletSort];
+  BOOST_TEST(sort.elements == kElements);
+  BOOST_TEST(sort.chunks == chunks);
+  // The loops were in their phases, not in the zone around them.
+  BOOST_TEST(result[Phase::kTracklets].regions == 0U);
+  const auto& tracklets = result[Phase::kTracklets];
+  BOOST_TEST(tracklets.seconds >= generate.seconds + sort.seconds);
+
+  std::ostringstream timeline;
+  trace.write(timeline);
+  BOOST_TEST(timeline.str().find(R"("name":"tracklet generate","cat":"chunk")") != std::string::npos);
+  BOOST_TEST(timeline.str().find(R"("name":"tracklets","cat":"zone")") != std::string::npos);
+}
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testPropagationPrecision.cxx b/Detectors/GenericTracking/tracking/test/testPropagationPrecision.cxx
new file mode 100644
index 0000000000000..1453bdbf0e5c5
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testPropagationPrecision.cxx
@@ -0,0 +1,182 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testPropagationPrecision.cxx
+/// \brief The 1 um propagation budget, checked against the helix itself.
+///
+/// testPropagator.cxx checks that propagation does the right thing. This checks
+/// how well it does it, over a sweep wide enough to reach the conditioning the
+/// detector can produce: grazing crossings, half turns, straight tracks and
+/// |z| up to 300 cm, where a float's last bit is already 0.3 um.
+///
+/// The check is closure, not agreement with a second implementation of the
+/// same inversion. Propagation reports where it landed and how long it took to
+/// get there; the helix is then evaluated independently at that time of flight,
+/// and the point it gives must lie on the target plane, at the local
+/// coordinates that were stored, with the azimuth that was stored. Nothing is
+/// inverted to check it, so the check itself is well conditioned everywhere the
+/// solve is not. What it deliberately does not police is *which* crossing was
+/// chosen: that is the root policy, and testPropagator.cxx owns it.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Propagation Precision
+#include <boost/test/unit_test.hpp>
+
+#include "PropagationPrecisionFixture.h"
+
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+#include <numbers>
+#include <random>
+
+namespace o2::gtrk
+{
+namespace
+{
+using namespace propagation_precision;
+} // namespace
+
+/// A million steps over the accepted geometry, both charges and both fields.
+BOOST_AUTO_TEST_CASE(PropagationClosesOnItsOwnHelixWithinOneMicron)
+{
+  std::mt19937_64 rng(20260928);
+  std::uniform_real_distribution<double> uniform(0., 1.);
+  const auto sample = [&](double low, double high) { return low + (high - low) * uniform(rng); };
+  constexpr int trials = 1000000;
+  Worst worst;
+
+  for (int trial = 0; trial < trials; ++trial) {
+    const double phi = sample(-std::numbers::pi, std::numbers::pi);
+    const double theta = sample(0.01, std::numbers::pi - 0.01);
+    const double pt = std::exp(sample(std::log(0.03), std::log(10000.)));
+    const double charge = trial % 2 == 0 ? 1. : -1.;
+    const double radius = sample(0., 90.);
+    const double azimuth = sample(-std::numbers::pi, std::numbers::pi);
+    const auto from = plane(radius * std::cos(azimuth), radius * std::sin(azimuth), sample(-300., 300.), sample(-std::numbers::pi, std::numbers::pi), trial % 3 == 0, 1);
+
+    BoundTrackState initial;
+    initial.surface = from.id;
+    initial.par[kLoc0] = static_cast<float>(sample(-1.5, 1.5));
+    initial.par[kLoc1] = static_cast<float>(sample(-3.5, 3.5));
+    initial.par[kPhi] = static_cast<float>(phi);
+    initial.par[kTheta] = static_cast<float>(theta);
+    initial.par[kQOverP] = static_cast<float>(charge * std::sin(theta) / pt);
+
+    Propagator prop;
+    prop.bzKiloGauss = trial % 5 == 0 ? -20.F : 20.F;
+    if (trial % 17 == 0) {
+      prop.bzKiloGauss = 0.F; // a straight track, and the second root at infinity
+    }
+
+    // Put the target on a point of the track, so that the sweep asks for
+    // crossings that exist rather than for mostly misses.
+    const double path = sample(0.001, 300.) * (trial % 7 == 0 ? -1. : 1.);
+    const auto direction = path > 0. ? PropagationDirection::kForward : PropagationDirection::kBackward;
+    const double turn = static_cast<double>(initial.qOverP()) * static_cast<double>(prop.bzKiloGauss) * static_cast<double>(constants::math::B2C) * path;
+    if (std::abs(turn) > 3.1) {
+      continue; // beyond a half turn the root policy, not the arithmetic, decides
+    }
+    ExactScalar origin[3]{};
+    detail::boundToGlobal(from, static_cast<ExactScalar>(initial.loc0()), static_cast<ExactScalar>(initial.loc1()), origin);
+    const double transverse = path * std::sin(static_cast<double>(initial.theta()));
+    const double along = transverse * sinc(turn);
+    const double across = transverse * versine(turn);
+    const double endX = origin[0] + along * std::cos(static_cast<double>(initial.phi())) - across * std::sin(static_cast<double>(initial.phi()));
+    const double endY = origin[1] + along * std::sin(static_cast<double>(initial.phi())) + across * std::cos(static_cast<double>(initial.phi()));
+    const double endZ = origin[2] + path * std::cos(static_cast<double>(initial.theta()));
+    auto to = plane(endX, endY, endZ, sample(-std::numbers::pi, std::numbers::pi), trial % 3 == 1, 2);
+    // Slide the target's origin inside its own plane. The plane is unchanged,
+    // but the crossing is no longer at its centre -- and the offset along the
+    // line is what a grazing crossing amplifies, so a sweep that always lands
+    // on the origin never asks the question.
+    const double offset[2] = {sample(-5., 5.), sample(-5., 5.)};
+    for (int i = 0; i < 3; ++i) {
+      to.origin[i] += static_cast<float>(offset[0] * static_cast<double>(to.axis0[i]) + offset[1] * static_cast<double>(to.axis1[i]));
+    }
+
+    auto state = initial;
+    const auto result = propagate(prop, state, from, to, direction);
+    if (result.status != PropagationStatus::kOk && result.status != PropagationStatus::kOutOfBounds) {
+      continue;
+    }
+    worst.add(closure(prop, initial, state, from, to, result.pathLength));
+  }
+
+  worst.report("sweep");
+  BOOST_TEST(worst.checked > trials / 2);
+  BOOST_TEST(worst.value.position < kMicron);
+  BOOST_TEST(worst.value.plane < kMicron);
+  BOOST_TEST(worst.value.azimuth < 1.e-6);
+}
+
+/// The conditioning the sweep only reaches by accident: either side of the
+/// incidence cut, either side of a half turn, and a vanishing curvature, all
+/// from a far corner of the detector.
+BOOST_AUTO_TEST_CASE(GrazingHalfTurnAndStraightLimitsStayWithinOneMicron)
+{
+  Worst worst;
+  const Propagator prop;
+  const auto from = plane(80., -70., 290., 0.3, false, 1);
+
+  for (const double phi : {-3.1, -1.7, -0.01, 0., 0.6, 2.7, 3.1}) {
+    for (const double theta : {0.05, 0.3, 0.5 * std::numbers::pi, 2.9}) {
+      for (const double turn : {-std::numbers::pi + 1.e-6, -2.8, -0.5, -1.e-6, 0., 1.e-9, 1.e-4, 0.499999, 0.500001, 2.8, std::numbers::pi - 1.e-6}) {
+        for (const double incidence : {0.00999, 0.01001, 0.011, 0.02, 0.1, 0.7}) {
+          if (incidence > std::sin(theta)) {
+            continue;
+          }
+          // The offset of the crossing from the target's centre, which a
+          // grazing crossing multiplies by up to a hundred.
+          for (const double offset : {0., -4., 4.}) {
+            BoundTrackState initial;
+            initial.surface = from.id;
+            initial.par[kPhi] = static_cast<float>(phi);
+            initial.par[kTheta] = static_cast<float>(theta);
+            constexpr double path = 100.;
+            initial.par[kQOverP] = static_cast<float>(turn / (path * static_cast<double>(prop.bzKiloGauss) * static_cast<double>(constants::math::B2C)));
+
+            // Place the target on the track again, now with its normal turned
+            // away from the arrival direction by exactly the wanted incidence.
+            const double actualTurn = static_cast<double>(initial.qOverP()) * static_cast<double>(prop.bzKiloGauss) * static_cast<double>(constants::math::B2C) * path;
+            const double middle = static_cast<double>(initial.phi()) + 0.5 * actualTurn;
+            const double chord = path * std::sin(static_cast<double>(initial.theta())) * sinc(0.5 * actualTurn);
+            const double normal = static_cast<double>(initial.phi()) + actualTurn + std::acos(incidence / std::sin(theta));
+            auto to = plane(80. + chord * std::cos(middle), -70. + chord * std::sin(middle), 290. + path * std::cos(static_cast<double>(initial.theta())), normal, false, 2);
+            for (int i = 0; i < 3; ++i) {
+              to.origin[i] += static_cast<float>(offset * static_cast<double>(to.axis0[i]));
+            }
+
+            auto state = initial;
+            const auto result = propagate(prop, state, from, to, PropagationDirection::kForward);
+            BOOST_TEST_CONTEXT("phi " << phi << ", theta " << theta << ", turn " << turn << ", incidence " << incidence << ", offset " << offset)
+            {
+              // Whether a crossing this shallow is reported at all, and which of
+              // the two it is, is the root policy's business, not this test's.
+              if (result.status == PropagationStatus::kOk || result.status == PropagationStatus::kOutOfBounds) {
+                const auto next = closure(prop, initial, state, from, to, result.pathLength);
+                worst.add(next);
+                BOOST_TEST(next.position < kMicron);
+                BOOST_TEST(next.plane < kMicron);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  worst.report("boundary");
+  BOOST_TEST(worst.checked > 1500);
+  BOOST_TEST(worst.value.azimuth < 1.e-6);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testPropagator.cxx b/Detectors/GenericTracking/tracking/test/testPropagator.cxx
new file mode 100644
index 0000000000000..5d1ffcf844037
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testPropagator.cxx
@@ -0,0 +1,536 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testPropagator.cxx
+/// \brief Closed-form helix propagation between sensor planes.
+///
+/// The budget under test: 1 um in position and 1 urad in
+/// direction, against a 14 um single-pixel cluster RMS, held from 300 MeV to
+/// 100 GeV and out to |z| = 152 cm.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Propagator
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/CovarianceTransport.h"
+#include "GenericTracking/Tracking/Propagator.h"
+#include "Oracles.h"
+
+#include "CommonConstants/PhysicsConstants.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <vector>
+#include <cstring>
+#include <iterator>
+#include <limits>
+
+namespace o2::gtrk
+{
+
+constexpr double kPosTol = 1e-4; // cm -- 1 um
+constexpr double kAngTol = 1e-6; // rad
+
+/// A plane, built by hand so a test does not depend on a layout's numbers.
+static TrackingSurface planeAt(double x, double y, double z, double nxIn, double nyIn, double nzIn, SensorID id = 0)
+{
+  TrackingSurface s{};
+  s.origin[0] = static_cast<Scalar>(x);
+  s.origin[1] = static_cast<Scalar>(y);
+  s.origin[2] = static_cast<Scalar>(z);
+  s.normal[0] = static_cast<Scalar>(nxIn);
+  s.normal[1] = static_cast<Scalar>(nyIn);
+  s.normal[2] = static_cast<Scalar>(nzIn);
+  // Any orthonormal pair spanning the plane will do for these tests.
+  if (std::abs(nzIn) > 0.5) { // a disc
+    s.axis0[0] = 1.F;
+    s.axis1[1] = 1.F;
+  } else { // a barrel-like plane: loc1 along the beam
+    s.axis0[0] = static_cast<Scalar>(-nyIn);
+    s.axis0[1] = static_cast<Scalar>(nxIn);
+    s.axis1[2] = 1.F;
+  }
+  s.bounds = SurfaceBounds{.halfX = 1e6F, .halfY = 1e6F};
+  s.id = id;
+  return s;
+}
+
+/// A state sitting at the origin of \a s, heading at (phi, theta) with a given
+/// signed q/p.
+static BoundTrackState stateOn(const TrackingSurface& s, double phi, double theta, double qOverP)
+{
+  BoundTrackState st;
+  st.par[kPhi] = static_cast<Scalar>(phi);
+  st.par[kTheta] = static_cast<Scalar>(theta);
+  st.par[kQOverP] = static_cast<Scalar>(qOverP);
+  st.surface = s.id;
+  return st;
+}
+
+/// A backward step at low pT, on a target plane rotated off radial.
+///
+/// The transverse solve is a quadratic and both roots are crossings of the
+/// target's *infinite* plane. The root of smaller magnitude is the stable one
+/// and is the sensor's crossing while the turn is small, but a soft track
+/// turning tens of degrees between layers swaps them. Taking the small one then
+/// would point the step *forward* out of a state asked to go back, and the
+/// track would be rejected and lost: a selected track whose refit fails.
+///
+/// What holds: a backward step is never refused for running forwards. What
+/// is not: the small root can also be a backward crossing of the extension
+/// rather than the sensor's, which nothing reports -- the orientations near
+/// -40 deg below are exactly that, and the assertions do not claim otherwise.
+BOOST_AUTO_TEST_CASE(ABackwardStepAtLowMomentumIsNeverRefusedForRunningForwards)
+{
+  // R = 50 cm, so 0.3 GeV at 2 T: the circle through the origin with centre
+  // (0, R) reaches radius r at a turn of 2 asin(r / 2R).
+  constexpr double kR = 50.;
+  const Propagator prop;
+  const double kappa = 1. / kR;
+  const auto qOverP = kappa / (static_cast<double>(o2::constants::math::B2C) * static_cast<double>(prop.bzKiloGauss));
+
+  const auto at = [](double psi) { return std::pair<double, double>{kR * std::sin(psi), kR * (1. - std::cos(psi))}; };
+  const auto turnAt = [](double r) { return 2. * std::asin(r / (2. * kR)); };
+
+  const double psiFrom = turnAt(82.);
+  const double psiTo = turnAt(66.);
+  const auto from = at(psiFrom);
+  const auto to = at(psiTo);
+  const double truePath = (psiTo - psiFrom) / kappa; // negative: it is behind
+
+  int reachedTheSensor = 0;
+  for (int degrees = -80; degrees <= 80; degrees += 5) {
+    // The plane always passes through the true crossing; only its orientation
+    // about that point changes, and with it which root carries the crossing.
+    const double radial = std::atan2(to.second, to.first) + (static_cast<double>(degrees) * M_PI / 180.);
+    const auto source = planeAt(from.first, from.second, 0., std::cos(radial), std::sin(radial), 0., 1);
+    const auto target = planeAt(to.first, to.second, 0., std::cos(radial), std::sin(radial), 0., 2);
+    auto st = stateOn(source, psiFrom, M_PI / 2., qOverP);
+
+    const auto res = propagate(prop, st, source, target, PropagationDirection::kBackward);
+    BOOST_TEST_CONTEXT("plane rotated " << degrees << " deg off radial")
+    {
+      BOOST_REQUIRE(res.status == PropagationStatus::kOk || res.status == PropagationStatus::kOutOfBounds);
+      BOOST_TEST(static_cast<double>(res.pathLength) < 0.); // it went back, as asked
+
+      // Whichever root it is, it is a real crossing: on the target's plane by
+      // construction of loc0/loc1, and on the circle of the state it started
+      // from. loc0 runs around the beam, loc1 along it.
+      const double x = static_cast<double>(target.origin[0]) + (static_cast<double>(st.loc0()) * static_cast<double>(target.axis0[0]));
+      const double y = static_cast<double>(target.origin[1]) + (static_cast<double>(st.loc0()) * static_cast<double>(target.axis0[1]));
+      BOOST_TEST(std::abs(std::hypot(x, y - kR) - kR) < 1e-2);
+
+      reachedTheSensor += std::abs(static_cast<double>(res.pathLength) - truePath) < 1e-3 ? 1 : 0;
+    }
+  }
+  // Most orientations put the sensor's own crossing on the chosen root; the
+  // handful that do not are the open half described above.
+  BOOST_TEST(reachedTheSensor >= 28);
+}
+
+BOOST_AUTO_TEST_CASE(SincAndVersineMatchTheirSeriesAndTheirClosedForm)
+{
+  // sinc never cancels, so the only thing to check is that the guarded branch
+  // and the quotient agree across the crossover.
+  for (const double x : {1e-6, 1e-5, 1e-4, 1.0001e-4, 1e-3, 0.1, 1.0, 3.0}) {
+    const double direct = std::sin(x) / x;
+    BOOST_TEST(std::abs(sinc<double>(x) - direct) < 1e-12);
+    // versine = (1 - cos x)/x, evaluated without ever forming 1 - cos x.
+    const double naive = (1. - std::cos(x)) / x;
+    BOOST_TEST(std::abs(versine<double>(x) - naive) < 1e-9 * std::max(1., naive));
+  }
+  BOOST_TEST(std::abs(static_cast<double>(versine<float>(1e-3F)) - (1. - std::cos(1e-3)) / 1e-3) < 1e-9);
+  BOOST_TEST(std::abs(sinc<double>(0.) - 1.) < 1e-15);
+  BOOST_TEST(std::abs(versine<double>(0.)) < 1e-15);
+}
+
+BOOST_AUTO_TEST_CASE(AStraightTrackCrossesAPlaneWhereGeometrySaysItShould)
+{
+  // Zero field: the straight line, which the closed form reaches without a
+  // separate code path.
+  const Propagator prop{.bzKiloGauss = 0.F};
+
+  const TrackingSurface start = planeAt(2., 0., 0., 1., 0., 0., 7);
+  const TrackingSurface target = planeAt(10., 0., 0., 1., 0., 0., 9);
+
+  // Heading out at 30 degrees in phi and 60 in theta.
+  BoundTrackState st = stateOn(start, 30. * M_PI / 180., 60. * M_PI / 180., 1.);
+  const auto res = propagate(prop, st, start, target, PropagationDirection::kForward);
+
+  BOOST_TEST((res.status == PropagationStatus::kOk));
+  BOOST_TEST(st.surface == 9U);
+
+  // Straight line: the transverse step is 8 cm along x, so the path follows.
+  const double sT = 8. / std::cos(30. * M_PI / 180.);
+  const double path = sT / std::sin(60. * M_PI / 180.);
+  BOOST_TEST(std::abs(static_cast<double>(res.pathLength) - path) < kPosTol);
+
+  // Angles are untouched by a zero field.
+  BOOST_TEST(std::abs(static_cast<double>(st.phi()) - 30. * M_PI / 180.) < kAngTol);
+  BOOST_TEST(std::abs(static_cast<double>(st.theta()) - 60. * M_PI / 180.) < kAngTol);
+}
+
+BOOST_AUTO_TEST_CASE(ADiscIsReachedByADivision)
+{
+  const Propagator prop;
+  const TrackingSurface start = planeAt(0., 0., 0., 0., 0., 1., 1);
+  const TrackingSurface target = planeAt(0., 0., 152., 0., 0., 1., 2); // representative forward plane
+
+  BoundTrackState st = stateOn(start, 0.4, 0.3, 1. / 5.);
+  const auto res = propagate(prop, st, start, target, PropagationDirection::kForward);
+
+  BOOST_TEST((res.status == PropagationStatus::kOk));
+  BOOST_TEST(std::abs(static_cast<double>(res.pathLength) - 152. / std::cos(0.3)) < kPosTol);
+
+  // The intersection lies on the plane: loc[2] is zero by construction, and
+  // this is where that gets checked rather than at run time.
+  Scalar g[3] = {};
+  surfaceToGlobal(target, st.par[kLoc0], st.par[kLoc1], g);
+  Scalar back[3] = {};
+  surfaceToLocal(target, g, back);
+  BOOST_TEST(std::abs(static_cast<double>(back[2])) < kPosTol);
+}
+
+BOOST_AUTO_TEST_CASE(ForwardThenBackwardReturnsTheOriginalState)
+{
+  // The round trip, over the momentum range the budget has to hold across
+  // and for both charges.
+  const Propagator prop;
+
+  const TrackingSurface inner = planeAt(3.4, 0., 0., 1., 0., 0., 11);
+  for (const double radius : {7., 17.2}) {
+    const TrackingSurface outer = planeAt(radius, 0., 0., 1., 0., 0., 12);
+    const std::vector<double> momenta = radius == 7. ? std::vector<double>{0.05, 0.1, 0.5} : std::vector<double>{0.3, 0.5, 1., 10., 100.};
+
+    for (const double pT : momenta) {
+      for (const double charge : {1., -1.}) {
+        for (const double theta : {0.6, 1.2, 1.5708}) {
+          const double qOverP = charge / (pT / std::sin(theta));
+
+          BoundTrackState st = stateOn(inner, radius == 7. ? 0. : 0.05, theta, qOverP);
+          const BoundTrackState original = st;
+
+          const auto out = propagate(prop, st, inner, outer, PropagationDirection::kForward);
+          BOOST_TEST((out.status == PropagationStatus::kOk));
+          BOOST_TEST(out.pathLength > 0.F);
+
+          const auto back = propagate(prop, st, outer, inner, PropagationDirection::kBackward);
+          BOOST_TEST((back.status == PropagationStatus::kOk));
+          BOOST_TEST(back.pathLength < 0.F);
+
+          BOOST_TEST(std::abs(static_cast<double>(st.loc0() - original.loc0())) < kPosTol);
+          BOOST_TEST(std::abs(static_cast<double>(st.loc1() - original.loc1())) < kPosTol);
+          BOOST_TEST(std::abs(static_cast<double>(st.phi() - original.phi())) < kAngTol);
+          BOOST_TEST(std::abs(static_cast<double>(st.theta() - original.theta())) < kAngTol);
+          // The two path lengths cancel.
+          BOOST_TEST(std::abs(static_cast<double>(out.pathLength + back.pathLength)) < kPosTol);
+        }
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(AFiftyMeVTrackReachesLayerOneAndNoFurther)
+{
+  // Not an arbitrary threshold: at 50 MeV the radius is 8.34 cm, so from
+  // r = 3.4 the trajectory turns back at x = 11.74 cm. Layer 1 at 7.0 is
+  // inside that, layer 3 at 17.2 is not -- and the status has to say so
+  // rather than return a nonsense intersection.
+  const Propagator prop;
+
+  const TrackingSurface l0 = planeAt(3.4, 0., 0., 1., 0., 0., 31);
+  const TrackingSurface l1 = planeAt(7.0, 0., 0., 1., 0., 0., 32);
+  const TrackingSurface l3 = planeAt(17.2, 0., 0., 1., 0., 0., 33);
+
+  BoundTrackState reaches = stateOn(l0, 0., 1.5708, 1. / 0.05);
+  BOOST_TEST((propagate(prop, reaches, l0, l1, PropagationDirection::kForward).status == PropagationStatus::kOk));
+
+  BoundTrackState curls = stateOn(l0, 0., 1.5708, 1. / 0.05);
+  const auto res = propagate(prop, curls, l0, l3, PropagationDirection::kForward);
+  BOOST_TEST((res.status == PropagationStatus::kNoIntersection));
+  // The state is untouched when the target is unreachable.
+  BOOST_TEST(std::abs(static_cast<double>(curls.loc0())) < 1e-9);
+}
+
+BOOST_AUTO_TEST_CASE(ChargeSignsBendOppositeWays)
+{
+  const Propagator prop;
+  const TrackingSurface inner = planeAt(3.4, 0., 0., 1., 0., 0., 1);
+  const TrackingSurface outer = planeAt(17.2, 0., 0., 1., 0., 0., 2);
+
+  BoundTrackState pos = stateOn(inner, 0., 1.5708, 1.0);
+  BoundTrackState neg = stateOn(inner, 0., 1.5708, -1.0);
+
+  BOOST_TEST((propagate(prop, pos, inner, outer, PropagationDirection::kForward).status == PropagationStatus::kOk));
+  BOOST_TEST((propagate(prop, neg, inner, outer, PropagationDirection::kForward).status == PropagationStatus::kOk));
+
+  // Equal and opposite deflection, and the sign comes from B2C rather than
+  // from anything written here.
+  BOOST_TEST(std::abs(static_cast<double>(pos.phi() + neg.phi())) < kAngTol);
+  BOOST_TEST(static_cast<double>(pos.phi()) * static_cast<double>(neg.phi()) < 0.);
+}
+
+/// The same backward steps with the other crossing rules (`CrossingRule`),
+/// the target a sensor of finite width: where
+/// the small root is the extension's backward crossing, both rules take the
+/// sensor's, and where the default already reaches the sensor they leave its
+/// state bit for bit. The Jacobian of the step they change agrees with the
+/// finite differences of the same rule.
+BOOST_AUTO_TEST_CASE(TheOtherCrossingRulesTakeTheSensorsCrossing)
+{
+  constexpr double kR = 50.;
+  const Propagator prop;
+  const double kappa = 1. / kR;
+  const auto qOverP = kappa / (static_cast<double>(o2::constants::math::B2C) * static_cast<double>(prop.bzKiloGauss));
+
+  const auto at = [](double psi) { return std::pair<double, double>{kR * std::sin(psi), kR * (1. - std::cos(psi))}; };
+  const auto turnAt = [](double r) { return 2. * std::asin(r / (2. * kR)); };
+
+  const double psiFrom = turnAt(82.);
+  const double psiTo = turnAt(66.);
+  const auto from = at(psiFrom);
+  const auto to = at(psiTo);
+  const double truePath = (psiTo - psiFrom) / kappa;
+
+  int changed = 0;
+  for (int degrees = -80; degrees <= 80; degrees += 5) {
+    const double radial = std::atan2(to.second, to.first) + (static_cast<double>(degrees) * M_PI / 180.);
+    const auto source = planeAt(from.first, from.second, 0., std::cos(radial), std::sin(radial), 0., 1);
+    auto target = planeAt(to.first, to.second, 0., std::cos(radial), std::sin(radial), 0., 2);
+    target.bounds = SurfaceBounds{.halfX = 3.F, .halfY = 10.F};
+    const auto st = stateOn(source, psiFrom, M_PI / 2., qOverP);
+
+    auto first = st;
+    auto nearer = st;
+    auto inside = st;
+    const auto rFirst = propagate(prop, first, source, target, PropagationDirection::kBackward);
+    const auto rNearer = propagate<CrossingRule::kNearerCentre>(prop, nearer, source, target, PropagationDirection::kBackward);
+    const auto rInside = propagate<CrossingRule::kInsideFirst>(prop, inside, source, target, PropagationDirection::kBackward);
+    BOOST_TEST_CONTEXT("plane rotated " << degrees << " deg off radial")
+    {
+      BOOST_TEST((rNearer.status == PropagationStatus::kOk));
+      BOOST_TEST((rInside.status == PropagationStatus::kOk));
+      BOOST_TEST(std::abs(static_cast<double>(rNearer.pathLength) - truePath) < 1e-3);
+      BOOST_TEST(std::abs(static_cast<double>(rInside.pathLength) - truePath) < 1e-3);
+      if (std::abs(static_cast<double>(rFirst.pathLength) - truePath) < 1e-3) {
+        // Bit identity is intentional; these records have no padding.
+        // NOLINTNEXTLINE(bugprone-suspicious-memory-comparison)
+        BOOST_TEST(std::memcmp(&first, &nearer, sizeof(BoundTrackState)) == 0);
+        // NOLINTNEXTLINE(bugprone-suspicious-memory-comparison)
+        BOOST_TEST(std::memcmp(&first, &inside, sizeof(BoundTrackState)) == 0);
+        continue;
+      }
+      ++changed;
+      // The step a rule changes is still a derivative the fit can take.
+      Scalar step[kNBoundParams] = {};
+      defaultDifferenceSteps(step);
+      Scalar reference[kJacobianSize] = {};
+      BOOST_TEST_REQUIRE((jacobianFiniteDifference<CrossingRule::kNearerCentre>(prop, st, source, target, PropagationDirection::kBackward, step, reference) == PropagationStatus::kOk));
+      SolenoidJacobian solenoid;
+      BOOST_TEST_REQUIRE((jacobianAnalytic<Scalar, CrossingRule::kNearerCentre>(prop, st, source, target, PropagationDirection::kBackward, solenoid) == PropagationStatus::kOk));
+      Scalar analytic[kJacobianSize] = {};
+      expandJacobian(solenoid, analytic);
+      for (int i = 0; i < kJacobianSize; ++i) {
+        BOOST_TEST(std::abs(static_cast<double>(analytic[i]) - static_cast<double>(reference[i])) < 1e-2 + 5e-3 * std::abs(static_cast<double>(reference[i])));
+      }
+    }
+  }
+  // The sweep reaches the case the rules are for.
+  BOOST_TEST(changed >= 2);
+}
+
+BOOST_AUTO_TEST_CASE(AskingForTheWrongSideIsRefused)
+{
+  const Propagator prop;
+  const TrackingSurface inner = planeAt(3.4, 0., 0., 1., 0., 0., 1);
+  const TrackingSurface outer = planeAt(17.2, 0., 0., 1., 0., 0., 2);
+
+  BoundTrackState st = stateOn(inner, 0., 1.5708, 1.);
+  const auto res = propagate(prop, st, inner, outer, PropagationDirection::kBackward);
+  BOOST_TEST((res.status == PropagationStatus::kWrongDirection));
+  // ...and the state was not touched.
+  BOOST_TEST(std::abs(static_cast<double>(st.loc0())) < 1e-9);
+}
+
+BOOST_AUTO_TEST_CASE(AGrazingIncidenceIsRejected)
+{
+  // A track running almost parallel to a disc: the bound representation is
+  // singular there, so the covariance would be meaningless.
+  const Propagator prop;
+  const TrackingSurface start = planeAt(0., 0., 0., 0., 0., 1., 1);
+  const TrackingSurface target = planeAt(0., 0., 10., 0., 0., 1., 2);
+
+  BoundTrackState st = stateOn(start, 0., 1.5708 - 0.002, 1. / 10.); // theta ~ 90 deg
+  const auto res = propagate(prop, st, start, target, PropagationDirection::kForward);
+  BOOST_TEST((res.status == PropagationStatus::kGrazing));
+}
+
+BOOST_AUTO_TEST_CASE(LeavingTheActiveAreaIsReportedButStillPropagated)
+{
+  const Propagator prop;
+  const TrackingSurface inner = planeAt(3.4, 0., 0., 1., 0., 0., 1);
+  TrackingSurface outer = planeAt(17.2, 0., 0., 1., 0., 0., 2);
+  outer.bounds = SurfaceBounds{.halfX = 0.84F, .halfY = 3.6F};
+
+  BoundTrackState st = stateOn(inner, 0.5, 1.5708, 1. / 100.); // steep in phi, so it misses
+  const auto res = propagate(prop, st, inner, outer, PropagationDirection::kForward);
+
+  BOOST_TEST((res.status == PropagationStatus::kOutOfBounds));
+  // Reported, not enforced: the intersection is there for a caller that wants it.
+  BOOST_TEST(res.pathLength > 0.F);
+  BOOST_TEST(std::abs(static_cast<double>(st.loc0())) > 0.84);
+}
+
+BOOST_AUTO_TEST_CASE(ThetaAndMomentumAreInvariantInAUniformField)
+{
+  // Not a tautology: it is why neither is recomputed in the propagation, and
+  // a future field-map propagator will have to stop relying on it.
+  const Propagator prop;
+  const TrackingSurface inner = planeAt(3.4, 0., 0., 1., 0., 0., 1);
+  const TrackingSurface outer = planeAt(17.2, 0., 0., 1., 0., 0., 2);
+
+  BoundTrackState st = stateOn(inner, 0.2, 0.7, 1. / 3.);
+  const BoundTrackState before = st;
+  BOOST_TEST((propagate(prop, st, inner, outer, PropagationDirection::kForward).status == PropagationStatus::kOk));
+
+  BOOST_TEST(std::abs(static_cast<double>(st.theta() - before.theta())) < 1e-9);
+  BOOST_TEST(std::abs(static_cast<double>(st.qOverP() - before.qOverP())) < 1e-9);
+}
+
+BOOST_AUTO_TEST_CASE(AFlippedNormalChangesOnlyTheSignOfLoc0)
+{
+  // An analytic layout's discs all face +z and its staves away from the beam.
+  // The MFT's faces alternate: our normal is -y of ALICE's local frame, which is +z on odd
+  // faces and -z on even ones. A
+  // plane with its normal and loc0 axis both reversed is the same plane, still
+  // right-handed, so a track must cross it at the same point, after the same
+  // path and time, with loc0 negated -- and only loc0's covariance terms may
+  // change, by their sign. That holds for the target and for the source.
+  const Propagator prop{.bzKiloGauss = 5.F};
+  const auto flip = [](TrackingSurface s) {
+    for (int i = 0; i < 3; ++i) {
+      s.normal[i] = -s.normal[i];
+      s.axis0[i] = -s.axis0[i];
+    }
+    return s;
+  };
+  struct Case {
+    TrackingSurface from;
+    TrackingSurface to;
+    double theta;
+    PropagationDirection dir;
+  };
+  const TrackingSurface disc0 = planeAt(0., 0., -45.29, 0., 0., 1., 1);
+  const TrackingSurface disc1 = planeAt(0., 0., -53.81, 0., 0., 1., 2);
+  const TrackingSurface stave0 = planeAt(2.33, 0., 0., 1., 0., 0., 3);
+  const TrackingSurface stave1 = planeAt(19.59, 0., 0., 1., 0., 0., 4);
+  const std::array<Case, 4> cases{{
+    {.from = disc0, .to = disc1, .theta = 3.0, .dir = PropagationDirection::kForward},
+    {.from = disc1, .to = disc0, .theta = 3.0, .dir = PropagationDirection::kBackward},
+    {.from = stave0, .to = stave1, .theta = 1.2, .dir = PropagationDirection::kForward},
+    {.from = stave1, .to = stave0, .theta = 1.2, .dir = PropagationDirection::kBackward},
+  }};
+
+  Scalar start[kBoundCovSize] = {};
+  for (int i = 0; i < kNBoundParams; ++i) {
+    start[covIndex(i, i)] = 1e-2F * static_cast<Scalar>(i + 1);
+  }
+  start[covIndex(kLoc0, kPhi)] = 2e-3F;
+  start[covIndex(kLoc1, kTheta)] = 1e-3F;
+
+  for (const auto& c : cases) {
+    for (const double qOverP : {1. / 0.5, -1. / 0.5, 1. / 5.}) {
+      for (const bool flipSource : {false, true}) {
+        BoundTrackState st = stateOn(c.from, 0.3, c.theta, qOverP);
+        st.par[kLoc0] = 0.1F;
+        st.par[kLoc1] = -0.2F;
+        const TrackingSurface from = flipSource ? flip(c.from) : c.from;
+        BoundTrackState seen = st;
+        Scalar seenCov[kBoundCovSize] = {};
+        std::ranges::copy(start, std::begin(seenCov));
+        if (flipSource) {
+          // The same point and covariance, written in the flipped source.
+          seen.par[kLoc0] = -seen.par[kLoc0];
+          for (int j = 0; j < kNBoundParams; ++j) {
+            if (j != kLoc0) {
+              seenCov[covIndex(kLoc0, j)] = -seenCov[covIndex(kLoc0, j)];
+            }
+          }
+        }
+
+        BoundTrackState plain = seen;
+        BoundTrackState flipped = seen;
+        const TrackingSurface to = flip(c.to);
+        const auto a = propagate(prop, plain, from, c.to, c.dir);
+        const auto b = propagate(prop, flipped, from, to, c.dir);
+        BOOST_TEST_REQUIRE((a.status == PropagationStatus::kOk));
+        BOOST_TEST_REQUIRE((b.status == PropagationStatus::kOk));
+        BOOST_TEST(std::abs(static_cast<double>(a.pathLength - b.pathLength)) < kPosTol);
+        BOOST_TEST(std::abs(static_cast<double>(plain.loc0() + flipped.loc0())) < kPosTol);
+        BOOST_TEST(std::abs(static_cast<double>(plain.loc1() - flipped.loc1())) < kPosTol);
+        BOOST_TEST(std::abs(static_cast<double>(plain.phi() - flipped.phi())) < kAngTol);
+        BOOST_TEST(std::abs(static_cast<double>(plain.theta() - flipped.theta())) < kAngTol);
+        BOOST_TEST(std::abs(static_cast<double>(plain.qOverP() - flipped.qOverP())) < kAngTol);
+
+        SolenoidJacobian ja{};
+        SolenoidJacobian jb{};
+        BOOST_TEST_REQUIRE((jacobianAnalytic(prop, seen, from, c.to, c.dir, ja) == PropagationStatus::kOk));
+        BOOST_TEST_REQUIRE((jacobianAnalytic(prop, seen, from, to, c.dir, jb) == PropagationStatus::kOk));
+        Scalar da[kJacobianSize] = {};
+        Scalar db[kJacobianSize] = {};
+        expandJacobian(ja, da);
+        expandJacobian(jb, db);
+        Scalar ca[kBoundCovSize] = {};
+        Scalar cb[kBoundCovSize] = {};
+        std::ranges::copy(seenCov, std::begin(ca));
+        std::ranges::copy(seenCov, std::begin(cb));
+        transportCovarianceDense(da, ca);
+        transportCovarianceDense(db, cb);
+        for (int i = 0; i < kNBoundParams; ++i) {
+          for (int j = 0; j <= i; ++j) {
+            const double sign = (i == kLoc0) != (j == kLoc0) ? -1. : 1.;
+            const double expected = sign * static_cast<double>(ca[covIndex(i, j)]);
+            const auto got = static_cast<double>(cb[covIndex(i, j)]);
+            BOOST_TEST(std::abs(got - expected) <= 1e-4 * (1. + std::abs(expected)));
+          }
+        }
+      }
+    }
+  }
+}
+
+/// A state with a NaN parameter is reported as kNotFinite and left untouched,
+/// in every build: the finiteness test is GTRK's own, where O2's
+/// `GPUCommonMath::Finite` is a constant outside the deterministic mode.
+BOOST_AUTO_TEST_CASE(ANaNParameterIsReportedNotFinite)
+{
+  const Propagator prop;
+  const auto from = planeAt(3., 0., 0., 1., 0., 0., 1);
+  const auto barrel = planeAt(7., 0., 0., 1., 0., 0., 2);
+  const auto disc = planeAt(0., 0., 12., 0., 0., 1., 3);
+  for (const auto* to : {&barrel, &disc}) {
+    for (const int index : {kPhi, kTheta, kQOverP}) {
+      auto state = stateOn(from, 0.1, 1.0, 0.5);
+      state.par[index] = std::numeric_limits<Scalar>::quiet_NaN();
+      const auto before = state;
+      const auto result = propagate(prop, state, from, *to, PropagationDirection::kForward);
+      BOOST_TEST_CONTEXT("target " << to->id << " parameter " << index)
+      {
+        BOOST_TEST((result.status == PropagationStatus::kNotFinite));
+        BOOST_TEST(state.surface == before.surface);
+        BOOST_TEST(state.loc0() == before.loc0());
+      }
+    }
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testRoadFit.cxx b/Detectors/GenericTracking/tracking/test/testRoadFit.cxx
new file mode 100644
index 0000000000000..6631e5776d53b
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testRoadFit.cxx
@@ -0,0 +1,651 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testRoadFit.cxx
+/// \brief The road fit: the outward pass with its early stop against the full
+///        fit, its chi2 against its degrees of freedom, and the stage's
+///        selection records, on ToyBarrel8's sensors.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK RoadFit
+#include <boost/test/unit_test.hpp>
+#include <numbers>
+
+#include "GenericTracking/Study/Validation.h"
+#include "GenericTracking/Tracking/Material.h"
+#include "GenericTracking/Tracking/RoadCount.h"
+#include "GenericTracking/Tracking/RoadFit.h"
+#include "GenericTracking/Tracking/Selection.h"
+#include "GenericTracking/Tracking/TrackRefit.h"
+
+#include "ToyBarrel8Fixture.h"
+#include "SerialReferences.h"
+#include "FixedPointReferences.h"
+#include "UniformMaterial.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <memory>
+#include <random>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using namespace toybarrel8;
+using Stage = RoadFitStage<Det, UniformMaterial, false, false, false, false>;
+using RecordOutput = StageOutput<SelectionRecordOf<maxChainLayers<Det>>::template RecordT>;
+constexpr std::size_t kMaxClusters = maxChainLayers<Det>;
+/// A road cut that passes everything, per degree of freedom.
+const std::array<Scalar, (3U * kMaxClusters) - 5U> kNoCut = [] {
+  std::array<Scalar, (3U * kMaxClusters) - 5U> cut{};
+  cut.fill(std::numeric_limits<Scalar>::infinity());
+  return cut;
+}();
+
+/// A track's direction, dip slope and pT: well separated azimuths.
+struct Helix {
+  double phi0 = 0.;
+  double slope = 0.;
+  double ptGeV = 0.;
+};
+
+Helix helix(std::size_t track)
+{
+  const auto k = static_cast<double>(track);
+  return {
+    .phi0 = std::fmod(0.4 + (2.3 * k), 2 * std::numbers::pi_v<double>),
+    .slope = 0.04 * std::sin(1.7 * k),
+    .ptGeV = 1.5 + (0.25 * static_cast<double>(track % 5U)),
+  };
+}
+
+/// The tracks' hits, one per layer each.
+std::vector<Hit> trackHits(std::size_t tracks)
+{
+  std::vector<Hit> hits;
+  for (std::size_t track = 0; track < tracks; ++track) {
+    const auto h = helix(track);
+    const auto one = sensorHelixHits(h.phi0, h.slope, h.ptGeV);
+    BOOST_REQUIRE(one.size() == kLayers);
+    hits.insert(hits.end(), one.begin(), one.end());
+  }
+  return hits;
+}
+
+/// \a track's rows, innermost first.
+std::array<std::uint32_t, kLayers> trackRows(const Fixture& fixture, std::size_t track)
+{
+  std::array<std::uint32_t, kLayers> rows{};
+  for (std::size_t layer = 0; layer < kLayers; ++layer) {
+    rows[layer] = fixture.row((kLayers * track) + layer);
+  }
+  return rows;
+}
+
+const Propagator kPropagator{};
+const UniformMaterial kNoMaterial{};
+
+IterationParameters<Det> parameters()
+{
+  const std::array<double, kLayers> material{};
+  return iterationParameters<Det>(iterationSettings(), Fixture::kBeamConstraint, scatteringTable<Det>(std::array<double, kLayers>{}));
+}
+
+} // namespace
+
+/// The beam-line update: a primary's road on
+/// the outer four layers, its inward state updated with the beam line, has a
+/// chi2 near zero -- the hits are exact -- and a narrower q/p. The beam line
+/// moved across the track's direction raises the chi2 with the square of the
+/// distance, and 5 mm, about ten of the road's d0 sigma here, refuses it.
+BOOST_AUTO_TEST_CASE(TheBeamLineConstrainsAPrimarysOuterRoad)
+{
+  const Fixture fixture{trackHits(6U)};
+  const auto iteration = parameters();
+  const auto& tracking = trackingGeometry();
+  for (std::size_t track = 0; track < 6U; ++track) {
+    const auto all = trackRows(fixture, track);
+    const std::array<std::uint32_t, 4> rows{all[4], all[5], all[6], all[7]};
+    const auto fit = fitMeasurements(kPropagator, tracking, kNoMaterial, RowChain<Det>{.frame = fixture.frame.get(), .rows = rows.data()}, 4);
+    BOOST_REQUIRE(fit.status == PropagationStatus::kOk);
+    const auto innermost = pairPointAt(fixture.frame->measurements(), rows[0]);
+    const auto layer = tracking.surface(fit.state.surface).layer;
+    const auto& plane = tracking.planeOf(fit.state);
+    auto constrained = fit.state;
+    const auto update = updateWithBeamLine(kPropagator, iteration, plane, layer, innermost, constrained);
+    BOOST_REQUIRE(update.ok);
+    BOOST_TEST(update.chi2 < 0.01F);
+    BOOST_TEST(constrained.variance(kQOverP) < 0.5F * fit.state.variance(kQOverP));
+    BOOST_TEST(std::abs(constrained.qOverP() - fit.state.qOverP()) < 3.F * std::sqrt(constrained.variance(kQOverP)));
+    const auto phi0 = static_cast<Scalar>(helix(track).phi0);
+    const auto movedBy = [&](Scalar distance) {
+      auto moved = iteration;
+      moved.beamX = -distance * std::sin(phi0);
+      moved.beamY = distance * std::cos(phi0);
+      auto state = fit.state;
+      const auto result = updateWithBeamLine(kPropagator, moved, plane, layer, innermost, state);
+      BOOST_REQUIRE(result.ok);
+      return result.chi2;
+    };
+    const Scalar one = movedBy(0.1F);
+    BOOST_TEST(movedBy(0.2F) == 4.F * one, boost::test_tools::tolerance(0.02F));
+    BOOST_TEST(movedBy(0.5F) > iteration.beamChi2Max);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(TheOutwardPassStopsWhereTheFullOneWouldReject)
+{
+  // Track 3's layer-4 hit moved by 10 sigma of loc0 along its sensor.
+  auto hits = trackHits(6U);
+  auto& moved = hits[(kLayers * 3U) + 4U];
+  moved.loc0 += 10.F * std::sqrt(3.e-6F * static_cast<Scalar>(1U + ((kLayers * 3U + 4U) % 3U)));
+  Scalar global[3]{};
+  surfaceToGlobal(trackingGeometry().surface(moved.surface), moved.loc0, moved.loc1, global);
+  moved.point.x = global[0];
+  moved.point.y = global[1];
+  moved.point.z = global[2];
+  const Fixture fixture{hits};
+  const auto iteration = parameters();
+  const auto cut = study::roadChi2Cut(iteration, kLayers);
+  BOOST_TEST(cut > 0.F);
+
+  for (std::size_t track = 0; track < 6U; ++track) {
+    const auto rows = trackRows(fixture, track);
+    const RowChain<Det> chain{.frame = fixture.frame.get(), .rows = rows.data()};
+    std::array<Measurement, kLayers> copied{};
+    for (std::size_t i = 0; i < kLayers; ++i) {
+      copied[i] = chain[static_cast<int>(i)];
+    }
+    const auto full = fitMeasurements(kPropagator, trackingGeometry(), kNoMaterial, copied.data(), static_cast<int>(kLayers));
+    const auto outward = fitOutward(kPropagator, trackingGeometry(), kNoMaterial, chain, static_cast<int>(kLayers), kNoCut.data());
+    const auto cutAt = fitOutward(kPropagator, trackingGeometry(), kNoMaterial, chain, static_cast<int>(kLayers), iteration.roadChi2MaxByNdf);
+    // A kink cannot absorb a displaced cluster: the one after it misses.
+    const auto kinked = fitOutward(kPropagator, trackingGeometry(), kNoMaterial, chain, static_cast<int>(kLayers), iteration.roadChi2MaxByNdf, kinkBudget(iteration));
+    BOOST_TEST_CONTEXT("track " << track)
+    {
+      // Read by row or copied, the same pass, to the bit.
+      BOOST_REQUIRE((full.status == PropagationStatus::kOk));
+      BOOST_TEST((outward.status == RoadFitStatus::kAccepted));
+      BOOST_TEST(outward.chi2 == full.outwardChi2);
+      BOOST_TEST((cutAt.status == RoadFitStatus::kAccepted) == (full.outwardChi2 <= cut));
+      BOOST_TEST((kinked.status == cutAt.status));
+      if (track == 3U) {
+        BOOST_TEST((cutAt.status == RoadFitStatus::kRejected));
+        BOOST_TEST(full.outwardChi2 > 25.F);
+      } else {
+        BOOST_TEST(kinked.kinks == 0U);
+        BOOST_TEST((cutAt.status == RoadFitStatus::kAccepted));
+        BOOST_TEST(outward.chi2 < 1.F);
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(SmearedRoadsHaveTheirDegreesOfFreedom)
+{
+  // Every hit smeared by its own errors in loc0 and loc1: the outward chi2 of
+  // 8 clusters has 2 * 8 - 5 = 11 degrees of freedom.
+  constexpr std::size_t kTracks = 400U;
+  auto hits = trackHits(kTracks);
+  std::mt19937_64 generator(20260926U); // NOLINT(cert-msc32-c,cert-msc51-cpp): the pulls are compared against fixed bounds
+  std::normal_distribution<double> normal;
+  for (std::size_t i = 0; i < hits.size(); ++i) {
+    const auto scale = static_cast<double>(1U + (i % 3U));
+    auto& hit = hits[i];
+    hit.loc0 += static_cast<Scalar>(normal(generator) * std::sqrt(3.e-6 * scale));
+    hit.loc1 += static_cast<Scalar>(normal(generator) * std::sqrt(1.e-6 * scale));
+    Scalar global[3]{};
+    surfaceToGlobal(trackingGeometry().surface(hit.surface), hit.loc0, hit.loc1, global);
+    hit.point.x = global[0];
+    hit.point.y = global[1];
+    hit.point.z = global[2];
+  }
+  const Fixture fixture{hits, 100.};
+  const auto cut = study::roadChi2Cut(parameters(), kLayers);
+  double sum = 0.;
+  std::size_t accepted = 0U;
+  for (std::size_t track = 0; track < kTracks; ++track) {
+    const auto rows = trackRows(fixture, track);
+    const RowChain<Det> chain{.frame = fixture.frame.get(), .rows = rows.data()};
+    const auto fit = fitOutward(kPropagator, trackingGeometry(), kNoMaterial, chain, static_cast<int>(kLayers), kNoCut.data());
+    BOOST_REQUIRE((fit.status == RoadFitStatus::kAccepted));
+    sum += static_cast<double>(fit.chi2);
+    accepted += fit.chi2 <= cut ? 1U : 0U;
+  }
+  const double mean = sum / static_cast<double>(kTracks);
+  BOOST_TEST_MESSAGE("mean chi2 " << mean << " (11), within the cut " << accepted << "/" << kTracks);
+  // The mean's error over 400 fits is sqrt(2 * 11 / 400) = 0.23.
+  BOOST_TEST(mean > 10.F);
+  BOOST_TEST(mean < 12.F);
+  BOOST_TEST(accepted >= 0.99 * kTracks);
+}
+
+/// A helix whose direction turns by \a turn on the sensor of layer \a kink --
+/// a hard scatter there -- as noiseless measurements: layers up to the kink
+/// from the helix, the rest propagated from the kink with the new direction.
+static std::array<Measurement, kLayers> kinkedChain(std::size_t kink, double turn)
+{
+  const auto hits = sensorHelixHits(0.7, 0.03, 1.5);
+  BOOST_REQUIRE(hits.size() == kLayers);
+  std::array<Measurement, kLayers> chain{};
+  const auto measurementOf = [](const BoundTrackState& state, std::size_t index) {
+    return Measurement{
+      .loc0 = state.loc0(),
+      .loc1 = state.loc1(),
+      .timePS = test::toyTimeBox(test::kToyTrackTimeNS).start,
+      .widthPS = test::toyTimeBox(test::kToyTrackTimeNS).width,
+      .varLoc0 = 3.e-6F,
+      .covLoc01 = 0.F,
+      .varLoc1 = 1.e-6F,
+      .clusterIndex = static_cast<std::uint32_t>(index),
+      .surface = state.surface,
+    };
+  };
+  for (std::size_t layer = 0; layer <= kink; ++layer) {
+    chain[layer] = Measurement{
+      .loc0 = hits[layer].loc0,
+      .loc1 = hits[layer].loc1,
+      .timePS = test::toyTimeBox(hits[layer].timeNS).start,
+      .widthPS = test::toyTimeBox(hits[layer].timeNS).width,
+      .varLoc0 = 3.e-6F,
+      .covLoc01 = 0.F,
+      .varLoc1 = 1.e-6F,
+      .clusterIndex = static_cast<std::uint32_t>(layer),
+      .surface = hits[layer].surface,
+    };
+  }
+  // The prefix's own fit gives the helix's state on the kink's sensor.
+  auto state = fitMeasurements(kPropagator, trackingGeometry(), kNoMaterial, chain.data(), static_cast<int>(kink + 1U)).outwardState;
+  state.par[kPhi] += static_cast<Scalar>(turn);
+  for (std::size_t layer = kink + 1U; layer < kLayers; ++layer) {
+    const auto& from = trackingGeometry().surface(state.surface);
+    bool crossed = false;
+    for (SensorID sensor = firstSensorOfLayer<Det>(static_cast<LayerID>(layer)); sensor < firstSensorOfLayer<Det>(static_cast<LayerID>(layer + 1U)) && !crossed; ++sensor) {
+      BoundTrackState probe = state;
+      if (propagate(kPropagator, probe, from, trackingGeometry().surface(sensor), PropagationDirection::kForward).status == PropagationStatus::kOk) {
+        state = probe;
+        crossed = true;
+      }
+    }
+    BOOST_REQUIRE(crossed);
+    chain[layer] = measurementOf(state, layer);
+  }
+  return chain;
+}
+
+BOOST_AUTO_TEST_CASE(AKinkRecoversAScatteredRoadWithTwoDegreesOfFreedom)
+{
+  constexpr std::size_t kKink = 3U;
+  const auto iteration = parameters();
+  const auto budget = kinkBudget(iteration);
+  BOOST_REQUIRE(budget.max == 1);
+  const auto chain = kinkedChain(kKink, 0.05);
+
+  // 50 mrad: the toy's layers are centimetres apart. Without a kink the road
+  // is beyond its cut; with one it passes, at two degrees of freedom fewer.
+  const auto strict = fitOutward(kPropagator, trackingGeometry(), kNoMaterial, chain.data(), static_cast<int>(kLayers), iteration.roadChi2MaxByNdf);
+  BOOST_TEST((strict.status == RoadFitStatus::kRejected));
+  const auto kinked = fitOutward(kPropagator, trackingGeometry(), kNoMaterial, chain.data(), static_cast<int>(kLayers), iteration.roadChi2MaxByNdf, budget);
+  BOOST_TEST((kinked.status == RoadFitStatus::kAccepted));
+  BOOST_TEST(kinked.kinks == 1U);
+  BOOST_TEST(kinked.chi2 <= study::roadChi2Cut(iteration, kLayers, 1U));
+
+  // Each pass takes its own: the outward one at the cluster after the kink,
+  // the inward one at the cluster before it, where the direction it brings
+  // from outside stops fitting.
+  const auto fit = fitMeasurements(kPropagator, trackingGeometry(), kNoMaterial, chain.data(), static_cast<int>(kLayers), budget);
+  BOOST_REQUIRE((fit.status == PropagationStatus::kOk));
+  BOOST_TEST(fit.outwardKinks == 1U);
+  BOOST_TEST(fit.kinks == 1U);
+  BOOST_TEST(fit.kinkMeasurement == static_cast<std::int16_t>(kKink - 1U));
+  BOOST_TEST(fit.ndf == static_cast<std::int16_t>((2 * static_cast<int>(kLayers)) - 5 - 2));
+  BOOST_TEST(fit.outwardChi2 == kinked.chi2);
+  // Not zero: both passes linearise about one helix through every cluster,
+  // which a 50 mrad kink leaves; a scatter of milliradians barely moves it.
+  BOOST_TEST(fit.chi2 <= study::roadChi2Cut(iteration, kLayers, fit.kinks));
+
+  // A straight road uses none.
+  const auto straight = kinkedChain(kKink, 0.);
+  const auto clean = fitMeasurements(kPropagator, trackingGeometry(), kNoMaterial, straight.data(), static_cast<int>(kLayers), budget);
+  BOOST_TEST(clean.outwardKinks == 0U);
+  BOOST_TEST(clean.kinks == 0U);
+}
+
+BOOST_AUTO_TEST_CASE(KinksLeaveTheFitADegreeOfFreedom)
+{
+  // n - 3 kinks at most: 2 n - 5 - 2 k stays at least one.
+  const KinkBudget two{.max = 2};
+  BOOST_TEST(detail::kinkBudgetFor(two, 3).max == 0);
+  BOOST_TEST(detail::kinkBudgetFor(two, 4).max == 1);
+  BOOST_TEST(detail::kinkBudgetFor(two, 5).max == 2);
+  BOOST_TEST(detail::kinkBudgetFor(two, 7).max == 2);
+  BOOST_TEST(detail::kinkBudgetFor(KinkBudget{}, 7).max == 0);
+
+  // The second and third clusters thrown far to either side: each inner step
+  // of the outward pass is a kink while the budget lasts.
+  const auto iteration = parameters();
+  auto chain = kinkedChain(kLayers - 1U, 0.);
+  chain[1].loc0 += 40.F * std::sqrt(chain[1].varLoc0);
+  chain[2].loc0 -= 40.F * std::sqrt(chain[2].varLoc0);
+  const KinkBudget budget{.max = 2, .gate = iteration.kinkChi2Min};
+  const auto five = fitOutward(kPropagator, trackingGeometry(), kNoMaterial, chain.data(), 5, kNoCut.data(), budget);
+  BOOST_TEST(five.kinks == 2U);
+  const auto four = fitOutward(kPropagator, trackingGeometry(), kNoMaterial, chain.data(), 4, kNoCut.data(), budget);
+  BOOST_TEST(four.kinks == 1U);
+  const auto fit = fitMeasurements(kPropagator, trackingGeometry(), kNoMaterial, chain.data(), 4, budget);
+  BOOST_REQUIRE((fit.status == PropagationStatus::kOk));
+  BOOST_TEST(fit.outwardKinks <= 1U);
+  BOOST_TEST(fit.kinks <= 1U);
+  BOOST_TEST(fit.ndf >= 1);
+}
+
+BOOST_AUTO_TEST_CASE(AKinkCannotAbsorbAWrongLastCluster)
+{
+  const auto iteration = parameters();
+  auto chain = kinkedChain(kLayers - 1U, 0.);
+  chain[kLayers - 1U].loc0 += 30.F * std::sqrt(chain[kLayers - 1U].varLoc0);
+  const auto fit = fitOutward(kPropagator, trackingGeometry(), kNoMaterial, chain.data(), static_cast<int>(kLayers), iteration.roadChi2MaxByNdf, kinkBudget(iteration));
+  BOOST_TEST((fit.status == RoadFitStatus::kRejected));
+  BOOST_TEST(fit.kinks == 0U);
+}
+
+BOOST_AUTO_TEST_CASE(TheLastStepTakesTheAllowanceNotAFreeDirection)
+{
+  // A scatter at the second-to-last cluster shows on the last step alone.
+  // The refit's budget never takes it there: rejected. The road fit's takes
+  // the iteration's kink allowance there (against the road-end fakes): the
+  // step again with its scattering scaled, its increment
+  // within the gate. A kink inside the allowance passes and frees no degree of
+  // freedom; one far beyond it -- a wrong last cluster -- does not, where a
+  // freed direction would take any.
+  // The scattering is taken at the filtered state's momentum, the chain's
+  // 1.5 GeV, not the whole-chain circle's 1.29 the kink itself bends
+  // 0.014 rad is inside the allowance there.
+  constexpr UniformMaterial material{.x2X0PerCm = 0.01F, .rho = 0.F};
+  auto iteration = parameters();
+  const auto road = [&](const std::array<Measurement, kLayers>& chain) { return takesLastStepAllowance(iteration) ? fitRoad<true>(iteration, kPropagator, trackingGeometry(), material, chain.data(), static_cast<int>(kLayers)) : fitRoad<false>(iteration, kPropagator, trackingGeometry(), material, chain.data(), static_cast<int>(kLayers)); };
+  const auto inside = kinkedChain(kLayers - 2U, 0.014);
+  const auto beyond = kinkedChain(kLayers - 2U, 0.08);
+  const auto refitBudget = fitOutward(kPropagator, trackingGeometry(), material, inside.data(), static_cast<int>(kLayers), iteration.roadChi2MaxByNdf, kinkBudget(iteration));
+  BOOST_TEST((refitBudget.status == RoadFitStatus::kRejected));
+  BOOST_TEST((road(inside).status == RoadFitStatus::kRejected));
+  iteration.kinkScale2 = 25.F;
+  const auto on = road(inside);
+  BOOST_TEST((on.status == RoadFitStatus::kAccepted));
+  BOOST_TEST(on.kinks == 1U);
+  BOOST_TEST(on.chi2 <= study::roadChi2Cut(iteration, kLayers, 0U));
+  BOOST_TEST((road(beyond).status == RoadFitStatus::kRejected));
+  // The refit's passes keep the rule: a kink at the innermost cluster going
+  // inward would leave the track's direction there unchecked.
+  const auto refit = fitMeasurements(kPropagator, trackingGeometry(), material, inside.data(), static_cast<int>(kLayers), kinkBudget(iteration));
+  BOOST_REQUIRE((refit.status == PropagationStatus::kOk));
+  BOOST_TEST(refit.outwardKinks == 0U);
+}
+
+namespace
+{
+struct RoadsRun {
+  Controller tracker;
+  Frame::TimeSlice slice;
+  Controller::Result result;
+  RoadCount count;
+
+  explicit RoadsRun(const Fixture& fixture)
+    : tracker(iterationSettings(), Fixture::kBeamConstraint, scatteringTable<Det>(std::array<double, kLayers>{}), std::make_shared<BoundedMemoryResource>(), 2U, 2),
+      slice(*fixture.frame, fixture.geometry.allBlocks(), 0)
+  {
+    BOOST_REQUIRE(tracker.beginTimeframe(*fixture.frame) == StageStatus::kComplete);
+    result = test::runSlice(tracker, 0U, *fixture.frame, slice, {});
+    BOOST_REQUIRE(result.status == StageStatus::kComplete);
+    count.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    const auto iteration = parameters();
+    BOOST_REQUIRE(fixedPointRoads(count, SerialForEach{}, iteration.linkSources, slice.core.data(), roadStartRule(iteration), *result.tracklets, *result.triplets, *result.neighbours) == StageStatus::kComplete);
+  }
+};
+} // namespace
+
+BOOST_AUTO_TEST_CASE(TheStageEmitsOneRecordPerRoad)
+{
+  constexpr std::size_t kTracks = 6U;
+  const Fixture fixture{trackHits(kTracks)};
+  const auto iteration = parameters();
+  const RoadsRun roads{fixture};
+  const auto& run = roads.result;
+  const auto& count = roads.count;
+  const SerialForEach serial{};
+  BOOST_REQUIRE(count.roadCount() == kTracks);
+
+  const Stage stage{iteration, *fixture.frame, trackingGeometry(), kNoMaterial, kPropagator, *run.tracklets, *run.triplets, count.walk(*run.triplets, *run.neighbours)};
+  RecordOutput records;
+  records.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  records.prepare(count.roadCount());
+  BOOST_REQUIRE(runSerial(records, stage) == StageStatus::kComplete);
+  BOOST_REQUIRE(records.size() == kTracks);
+
+  // Each road is one track, its clusters' rows in order, innermost first.
+  const auto view = records.view();
+  std::vector<bool> found(kTracks, false);
+  for (std::uint32_t record = 0; record < records.size(); ++record) {
+    const auto& clusters = view.clusters[record];
+    BOOST_TEST(view.count[record] == kLayers);
+    BOOST_TEST(view.chi2[record] < 1.F);
+    const auto track = fixture.frame->measurement(clusters.index[0]).clusterIndex / kLayers;
+    for (std::size_t layer = 0; layer < kMaxClusters; ++layer) {
+      BOOST_TEST(clusters.index[layer] == (layer < kLayers ? fixture.row((kLayers * track) + layer) : ClusterList<kMaxClusters>::kNoCluster));
+    }
+    found[track] = true;
+  }
+  BOOST_TEST(std::ranges::all_of(found, [](bool f) { return f; }));
+
+  for (const int threads : {1, 2, 4}) {
+    RecordOutput parallel;
+    const auto parallelPool = std::make_shared<BoundedMemoryResource>();
+    parallel.setMemoryPool(parallelPool);
+    parallel.prepare(count.roadCount());
+    detail::TaskArena cpuArena{threads};
+    CpuStage<SelectionRecordOf<kMaxClusters>::template RecordT> cpu{cpuArena};
+    cpu.setMemoryPool(parallelPool);
+    BOOST_REQUIRE(cpu.run(parallel, 1U, stage) == StageStatus::kComplete);
+    BOOST_REQUIRE(parallel.size() == records.size());
+    const auto other = parallel.view();
+    BOOST_TEST(std::memcmp(other.clusters, view.clusters, records.size() * sizeof(*view.clusters)) == 0);
+    BOOST_TEST(std::memcmp(other.count, view.count, records.size() * sizeof(*view.count)) == 0);
+    BOOST_TEST(std::memcmp(other.chi2, view.chi2, records.size() * sizeof(*view.chi2)) == 0);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(TheStageDropsRoadsBelowTheFloorOfTheirClusterCount)
+{
+  // The six tracks at 1.5, 1.75, 2, 2.25, 2.5 and 1.5 GeV, all on every
+  // layer: a 2.1 GeV floor for that count keeps the two above it, and a floor
+  // for one cluster fewer keeps them all.
+  constexpr std::size_t kTracks = 6U;
+  const Fixture fixture{trackHits(kTracks)};
+  const RoadsRun roads{fixture};
+  const auto& run = roads.result;
+  const auto& count = roads.count;
+  const SerialForEach serial{};
+  BOOST_REQUIRE(count.roadCount() == kTracks);
+
+  const auto tracksKept = [&](double floorAll, double floorOneShort) {
+    auto settings = iterationSettings();
+    // No follow: the road is the final track, and the floors act on it.
+    settings.follow = false;
+    settings.minPtGeVByClusters[kLayers] = floorAll;
+    settings.minPtGeVByClusters[kLayers - 1U] = floorOneShort;
+    const auto iteration = iterationParameters<Det>(settings, Fixture::kBeamConstraint, scatteringTable<Det>(std::array<double, kLayers>{}));
+    const Stage stage{iteration, *fixture.frame, trackingGeometry(), kNoMaterial, kPropagator, *run.tracklets, *run.triplets, count.walk(*run.triplets, *run.neighbours)};
+    RecordOutput records;
+    records.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    records.prepare(count.roadCount());
+    BOOST_REQUIRE(runSerial(records, stage) == StageStatus::kComplete);
+    std::vector<std::size_t> tracks;
+    tracks.reserve(records.size());
+    for (std::uint32_t record = 0; record < records.size(); ++record) {
+      tracks.push_back(fixture.frame->measurement(records.view().clusters[record].index[0]).clusterIndex / kLayers);
+    }
+    std::ranges::sort(tracks);
+    return tracks;
+  };
+  BOOST_TEST(tracksKept(2.1, 0.) == (std::vector<std::size_t>{3U, 4U}), boost::test_tools::per_element());
+  BOOST_TEST(tracksKept(0., 100.) == (std::vector<std::size_t>{0U, 1U, 2U, 3U, 4U, 5U}), boost::test_tools::per_element());
+}
+
+BOOST_AUTO_TEST_CASE(ARefusedRoadIsFittedAgainWithoutItsInnermostClusters)
+{
+  // The six tracks on every layer, refused at their full length by a floor
+  // no track clears: with innerTrim each
+  // road's record is its longest suffix the floors admit, never shorter
+  // than minClusters; without it, or with it off, there is none.
+  constexpr std::size_t kTracks = 6U;
+  const Fixture fixture{trackHits(kTracks)};
+  const RoadsRun roads{fixture};
+  const auto& run = roads.result;
+  const auto& count = roads.count;
+  const SerialForEach serial{};
+  BOOST_REQUIRE(count.roadCount() == kTracks);
+
+  // The records, each its cluster count times 10 plus its first layer, by
+  // \a Trim's stage.
+  const auto recordsOf = [&]<bool Trim>(int innerTrim, int minClusters, std::size_t refusedBelow) {
+    auto settings = iterationSettings();
+    settings.innerTrim = innerTrim;
+    settings.minClusters = minClusters;
+    settings.follow = false;
+    for (std::size_t clusters = refusedBelow; clusters <= kLayers; ++clusters) {
+      settings.minPtGeVByClusters[clusters] = 100.;
+    }
+    const auto iteration = iterationParameters<Det>(settings, Fixture::kBeamConstraint, scatteringTable<Det>(std::array<double, kLayers>{}));
+    const RoadFitStage<Det, UniformMaterial, false, false, false, Trim> stage{iteration, *fixture.frame, trackingGeometry(), kNoMaterial, kPropagator, *run.tracklets, *run.triplets, count.walk(*run.triplets, *run.neighbours)};
+    RecordOutput records;
+    records.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    records.prepare(count.roadCount());
+    BOOST_REQUIRE(runSerial(records, stage) == StageStatus::kComplete);
+    std::vector<std::uint32_t> kept;
+    for (std::uint32_t record = 0; record < records.size(); ++record) {
+      const auto innermost = fixture.frame->measurement(records.view().clusters[record].index[0]).clusterIndex;
+      kept.push_back((10U * records.view().count[record]) + static_cast<std::uint32_t>(innermost % kLayers));
+      // The clusters are the road's outermost, in order.
+      const auto track = innermost / kLayers;
+      for (std::uint32_t position = 0; position < records.view().count[record]; ++position) {
+        BOOST_TEST(records.view().clusters[record].index[position] == fixture.row((kLayers * track) + (innermost % kLayers) + position));
+      }
+    }
+    return kept;
+  };
+  const std::vector<std::uint32_t> none;
+  const std::vector<std::uint32_t> seven(kTracks, 71U);
+  const std::vector<std::uint32_t> five(kTracks, 53U);
+  BOOST_TEST(recordsOf.template operator()<false>(3, 4, kLayers) == none, boost::test_tools::per_element());
+  BOOST_TEST(recordsOf.template operator()<true>(0, 4, kLayers) == none, boost::test_tools::per_element());
+  BOOST_TEST(recordsOf.template operator()<true>(1, 4, kLayers) == seven, boost::test_tools::per_element());
+  BOOST_TEST(recordsOf.template operator()<true>(3, 4, kLayers - 2U) == five, boost::test_tools::per_element());
+  BOOST_TEST(recordsOf.template operator()<true>(2, 4, kLayers - 2U) == none, boost::test_tools::per_element()); // two dropped are not enough
+  BOOST_TEST(recordsOf.template operator()<true>(3, static_cast<int>(kLayers) - 1, kLayers - 2U) == none,
+             boost::test_tools::per_element()); // nor below minClusters
+  // A road the stage takes whole is taken whole.
+  BOOST_TEST(recordsOf.template operator()<true>(3, 4, kLayers + 1U) == std::vector<std::uint32_t>(kTracks, 80U), boost::test_tools::per_element());
+}
+
+BOOST_AUTO_TEST_CASE(SelectedTracksAreRefittedWithBothPasses)
+{
+  // Hits to tracks: tracklets, triplets, neighbours, levels, roads, their
+  // fit, the selection, the refit.
+  constexpr std::size_t kTracks = 6U;
+  const Fixture fixture{trackHits(kTracks)};
+  const auto iteration = parameters();
+  const RoadsRun roads{fixture};
+  const auto& run = roads.result;
+  const auto& count = roads.count;
+  const SerialForEach serial{};
+  const Stage stage{iteration, *fixture.frame, trackingGeometry(), kNoMaterial, kPropagator, *run.tracklets, *run.triplets, count.walk(*run.triplets, *run.neighbours)};
+  RecordOutput records;
+  records.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  records.prepare(count.roadCount());
+  BOOST_REQUIRE(runSerial(records, stage) == StageStatus::kComplete);
+  GlobalSelection<kMaxClusters> selection;
+  selection.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  BOOST_REQUIRE(selection.append(records, SerialForEach{}) == StageStatus::kComplete);
+  std::vector<std::uint8_t> mask(fixture.frame->size(), kFree);
+  BOOST_REQUIRE(selection.select(serial, [](std::span<std::uint32_t> indices, const auto& less) { std::ranges::sort(indices, less); }, 0U, mask) == StageStatus::kComplete);
+  BOOST_REQUIRE(selection.selected().size() == kTracks);
+
+  TrackRefit<Det> refit;
+  refit.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  BOOST_REQUIRE(refit.run(serial, selection, iteration, *fixture.frame, trackingGeometry(), kNoMaterial, kPropagator, 0U) == StageStatus::kComplete);
+  BOOST_REQUIRE(refit.size() == kTracks);
+  const auto tracks = refit.tracks().view();
+  for (std::uint32_t track = 0; track < kTracks; ++track) {
+    const auto& rows = tracks.clusters[track];
+    const auto index = fixture.frame->measurement(rows.index[0]).clusterIndex / kLayers;
+    const auto h = helix(index);
+    BOOST_TEST_CONTEXT("track " << index)
+    {
+      // Both passes, as fitMeasurements gives them on the same rows.
+      BOOST_REQUIRE(tracks.status[track] == PropagationStatus::kOk);
+      BOOST_TEST(tracks.count[track] == kLayers);
+      std::array<Measurement, kLayers> copied{};
+      const RowChain<Det> chain{.frame = fixture.frame.get(), .rows = rows.index};
+      for (std::size_t i = 0; i < kLayers; ++i) {
+        copied[i] = chain[static_cast<int>(i)];
+      }
+      const auto full = fitMeasurements(kPropagator, trackingGeometry(), kNoMaterial, copied.data(), static_cast<int>(kLayers));
+      BOOST_TEST(tracks.chi2[track] == full.chi2);
+
+      BOOST_TEST(tracks.ndf[track] == (2 * static_cast<int>(kLayers)) - 5);
+      // On the innermost surface, and the generating helix.
+      const auto& state = tracks.state[track];
+      const auto first = fixture.frame->measurement(rows.index[0]);
+      BOOST_TEST(state.surface == first.surface);
+      BOOST_TEST(std::abs(state.loc0() - first.loc0) < 1.e-4F);
+      BOOST_TEST(std::abs(state.loc1() - first.loc1) < 1.e-4F);
+      BOOST_TEST(state.theta() == static_cast<Scalar>(std::atan2(1., h.slope)), boost::test_tools::tolerance(1.e-4F));
+      const double momentum = h.ptGeV * std::hypot(1., h.slope);
+      BOOST_TEST(std::abs(state.qOverP()) == static_cast<Scalar>(1. / momentum), boost::test_tools::tolerance(1.e-3F));
+    }
+  }
+
+  for (const int threads : {1, 2, 4}) {
+    detail::TaskArena cpuArena{threads};
+    CpuStage<TrackOf<kMaxClusters>::template RecordT> cpu{cpuArena};
+    cpu.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    TrackRefit<Det> parallel;
+    parallel.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    BOOST_REQUIRE(parallel.run([&](std::uint32_t elements, const auto& body) { cpu.forEachElement(elements, 1U, body); }, selection, iteration, *fixture.frame, trackingGeometry(), kNoMaterial, kPropagator, 0U) == StageStatus::kComplete);
+    // Bit for bit.
+    const auto other = parallel.tracks().view();
+    const auto bits = [](Scalar value) { return std::bit_cast<std::uint32_t>(value); };
+    for (std::uint32_t track = 0; track < kTracks; ++track) {
+      const auto& a = other.state[track];
+      const auto& b = tracks.state[track];
+      BOOST_TEST(std::ranges::equal(a.par, b.par, {}, bits, bits));
+      BOOST_TEST(std::ranges::equal(a.cov, b.cov, {}, bits, bits));
+      BOOST_TEST(other.timePS[track] == tracks.timePS[track]);
+      BOOST_TEST(other.widthPS[track] == tracks.widthPS[track]);
+      BOOST_TEST(a.surface == b.surface);
+      BOOST_TEST(bits(other.chi2[track]) == bits(tracks.chi2[track]));
+      BOOST_TEST(std::ranges::equal(other.clusters[track].index, tracks.clusters[track].index));
+    }
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testRoads.cxx b/Detectors/GenericTracking/tracking/test/testRoads.cxx
new file mode 100644
index 0000000000000..5192d1b1d7455
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testRoads.cxx
@@ -0,0 +1,588 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testRoads.cxx
+/// \brief Where roads start and how many leave each triplet, against a hand
+///        count and a brute-force walk, on the deep ToyBarrel8.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Roads
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/RoadCount.h"
+
+#include "ToyBarrel8Fixture.h"
+#include "SerialReferences.h"
+#include "FixedPointReferences.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <memory>
+#include <numbers>
+#include <set>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using namespace toybarrel8;
+
+/// A road as its triplets, innermost first.
+using Road = std::vector<std::uint32_t>;
+
+struct Counted {
+  std::vector<std::uint32_t> successorAbove;
+  std::vector<std::uint32_t> roads;
+  std::vector<std::uint32_t> starts;
+  std::vector<std::uint32_t> roadOffsets;
+  std::vector<Road> enumerated; ///< every road by its index
+};
+
+constexpr std::size_t kMaxRoadTriplets = maxChainLayers<Det> - 2;
+
+/// Every road by its index through the walk, one element per road.
+template <typename ForEach>
+std::vector<Road> enumerate(ForEach forEach, const RoadWalk& walk, RoadCount::Index roads)
+{
+  std::vector<std::array<std::uint32_t, kMaxRoadTriplets>> triplets(roads);
+  std::vector<std::uint32_t> lengths(roads);
+  forEach(roads, [&](RoadCount::Index road) { lengths[road] = walk(road, triplets[road].data()); });
+  std::vector<Road> result(roads);
+  for (RoadCount::Index road = 0; road < roads; ++road) {
+    result[road].assign(triplets[road].begin(), triplets[road].begin() + lengths[road]);
+  }
+  return result;
+}
+
+/// The road count of one tracker run, serial when \a threads is 0, else on
+/// the CPU backend in chunks of \a chunk.
+template <typename Result>
+Counted countRoads(const Result& run, const IterationParameters<Det>& parameters, std::span<const MeasurementRange> core, std::uint32_t minStartLevel, int threads = 0, RoadCount::Index chunk = 1U, std::uint64_t endLayers = 0U)
+{
+  const RoadStartRule rule{.minLevel = minStartLevel, .endLayers = endLayers, .linkTargets = parameters.linkTargets};
+  RoadCount count;
+  count.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  const auto serial = [](RoadCount::Index elements, const auto& body) {
+    for (RoadCount::Index element = 0; element < elements; ++element) {
+      body(element);
+    }
+  };
+  detail::TaskArena cpuArena{std::max(threads, 1)};
+  CpuStage<NeighbourT> cpu{cpuArena};
+  cpu.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  const auto parallel = [&](RoadCount::Index elements, const auto& body) { cpu.forEachElement(elements, chunk, body); };
+  const auto status = threads == 0 ? fixedPointRoads(count, serial, parameters.linkSources, core.data(), rule, *run.tracklets, *run.triplets, *run.neighbours) : fixedPointRoads(count, parallel, parameters.linkSources, core.data(), rule, *run.tracklets, *run.triplets, *run.neighbours);
+  BOOST_REQUIRE(status == StageStatus::kComplete);
+  // An independently scheduled ordered pass uses the final graph, rather
+  // than the fitter's generation. It must give the reference's numbering.
+  RoadCount ordered;
+  ordered.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  const auto compareOrdered = [&](const auto& forEach) {
+    ordered.prepareOrdered(forEach, run.triplets->size());
+    const auto state = ordered.ordered(parameters.linkSources, core.data());
+    const auto triplets = run.triplets->view();
+    const auto offsets = run.neighbours->offsets();
+    const auto* const from = run.neighbours->view().from;
+    const auto highest = *std::max_element(triplets.level, triplets.level + run.triplets->size());
+    // Replaying the complete ordered pass models a staging retry. Counts are
+    // overwritten; successor marks and overflow must remain idempotent.
+    for (int attempt = 0; attempt < 2; ++attempt) {
+      for (std::uint32_t level = 1U; level <= highest; ++level) {
+        forEach(run.triplets->size(), [&](std::uint32_t element) {
+          if (triplets.level[element] != level) {
+            return;
+          }
+          state.base(element, run.tracklets->view(), triplets);
+          if (level > 1U) {
+            std::uint64_t sum = 0U;
+            for (auto edge = offsets[element]; edge < offsets[element + 1U]; ++edge) {
+              if (triplets.level[from[edge]] + 1U == level) {
+                state.add(from[edge], sum);
+              }
+            }
+            state.finish(element, sum);
+          }
+        });
+      }
+      const auto orderedStatus = ordered.runPrepared(forEach, rule, *run.tracklets, *run.triplets, chunk);
+      BOOST_REQUIRE(orderedStatus == StageStatus::kComplete);
+      BOOST_TEST(std::ranges::equal(ordered.successorAbove(), count.successorAbove()));
+      BOOST_TEST(std::ranges::equal(ordered.roads(), count.roads()));
+      BOOST_TEST(std::ranges::equal(ordered.starts(), count.starts()));
+      BOOST_TEST(std::ranges::equal(ordered.roadOffsets(), count.roadOffsets()));
+      BOOST_TEST((enumerate(forEach, ordered.walk(*run.triplets, *run.neighbours), ordered.roadCount()) == enumerate(forEach, count.walk(*run.triplets, *run.neighbours), count.roadCount())));
+    }
+  };
+  if (run.triplets->size() != 0U) {
+    if (threads == 0) {
+      compareOrdered(serial);
+    } else {
+      compareOrdered(parallel);
+    }
+  }
+  const auto walk = count.walk(*run.triplets, *run.neighbours);
+  return {
+    .successorAbove = {count.successorAbove().begin(), count.successorAbove().end()},
+    .roads = {count.roads().begin(), count.roads().end()},
+    .starts = {count.starts().begin(), count.starts().end()},
+    .roadOffsets = {count.roadOffsets().begin(), count.roadOffsets().end()},
+    .enumerated = threads == 0 ? enumerate(serial, walk, count.roadCount()) : enumerate(parallel, walk, count.roadCount()),
+  };
+}
+
+/// By brute force: the successor flags from every edge, the roads by a
+/// depth-first walk down through predecessors one level below to owned
+/// level-1 triplets, the starts by their definition; and, with every level
+/// allowed to start, that the walks from the starts cover every triplet with
+/// a road.
+template <typename Result>
+void checkAgainstBruteForce(const Result& run, const IterationParameters<Det>& parameters, std::span<const MeasurementRange> core, std::uint32_t minStartLevel, const Counted& counted)
+{
+  const auto tracklets = run.tracklets->view();
+  const auto triplets = run.triplets->view();
+  const auto& neighbours = *run.neighbours;
+  const auto* const from = neighbours.view().from;
+  const auto count = run.triplets->size();
+  std::vector<std::uint32_t> successorAbove(count, 0U);
+  for (std::uint32_t to = 0; to < count; ++to) {
+    for (auto edge = neighbours.offsets()[to]; edge < neighbours.offsets()[to + 1U]; ++edge) {
+      successorAbove[from[edge]] |= triplets.level[from[edge]] + 1U == triplets.level[to] ? 1U : 0U;
+    }
+  }
+  // Recursive on purpose: the reference walks every road, the stage does not.
+  const auto walk = [&](const auto& self, std::uint32_t triplet, std::vector<bool>* visited) -> std::uint64_t { // NOLINT(misc-no-recursion)
+    if (visited != nullptr) {
+      (*visited)[triplet] = true;
+    }
+    if (triplets.level[triplet] == 1U) {
+      const auto first = triplets.first[triplet];
+      const auto owned = core[parameters.linkSources[tracklets.link[first]]];
+      return tracklets.source[first] >= owned.begin && tracklets.source[first] < owned.end ? 1U : 0U;
+    }
+    std::uint64_t roads = 0U;
+    for (auto edge = neighbours.offsets()[triplet]; edge < neighbours.offsets()[triplet + 1U]; ++edge) {
+      if (triplets.level[from[edge]] + 1U == triplets.level[triplet]) {
+        roads += self(self, from[edge], visited);
+      }
+    }
+    return roads;
+  };
+  std::vector<std::uint32_t> starts;
+  std::vector<bool> onRoad(count, false);
+  for (std::uint32_t triplet = 0; triplet < count; ++triplet) {
+    const auto roads = walk(walk, triplet, nullptr);
+    BOOST_TEST_CONTEXT("triplet " << triplet)
+    {
+      BOOST_TEST(counted.successorAbove[triplet] == successorAbove[triplet]);
+      BOOST_TEST(counted.roads[triplet] == roads);
+    }
+    if (triplets.level[triplet] >= minStartLevel && successorAbove[triplet] == 0U && roads != 0U) {
+      starts.push_back(triplet);
+      walk(walk, triplet, &onRoad);
+    }
+  }
+  BOOST_TEST(counted.starts == starts, boost::test_tools::per_element());
+
+  // The roads by a depth-first walk from each start in turn, predecessors in
+  // the neighbour stage's order: the walk by index must give the same roads
+  // in the same order, each once.
+  std::vector<Road> roads;
+  Road path;
+  const auto descend = [&](const auto& self, std::uint32_t triplet) -> void { // NOLINT(misc-no-recursion)
+    path.push_back(triplet);
+    if (triplets.level[triplet] == 1U) {
+      if (walk(walk, triplet, nullptr) != 0U) {
+        roads.emplace_back(path.rbegin(), path.rend());
+      }
+    } else {
+      for (auto edge = neighbours.offsets()[triplet]; edge < neighbours.offsets()[triplet + 1U]; ++edge) {
+        if (triplets.level[from[edge]] + 1U == triplets.level[triplet]) {
+          self(self, from[edge]);
+        }
+      }
+    }
+    path.pop_back();
+  };
+  for (const auto start : starts) {
+    descend(descend, start);
+  }
+  BOOST_REQUIRE(counted.enumerated.size() == roads.size());
+  BOOST_TEST(counted.roadOffsets.back() == roads.size());
+  for (std::size_t road = 0; road < roads.size(); ++road) {
+    BOOST_TEST_CONTEXT("road " << road) { BOOST_TEST(counted.enumerated[road] == roads[road], boost::test_tools::per_element()); }
+  }
+  if (minStartLevel == 1U) {
+    for (std::uint32_t triplet = 0; triplet < count; ++triplet) {
+      BOOST_TEST((onRoad[triplet] || walk(walk, triplet, nullptr) == 0U), "triplet " << triplet << " lies on no road");
+    }
+  }
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(RoadsOnTheDeepBarrelMatchTheirHandCount)
+{
+  using namespace toybarrel8::levels;
+  const Fixture fixture{levelHits()};
+  const std::array<double, kLayers> material{};
+  const auto scattering = scatteringTable<Det>(material);
+  const auto parameters = iterationParameters<Det>(iterationSettings(), Fixture::kBeamConstraint, scattering);
+  Controller tracker{iterationSettings(), Fixture::kBeamConstraint, scattering, std::make_shared<BoundedMemoryResource>(), 2U, 2};
+  const Frame::TimeSlice slice{*fixture.frame, fixture.geometry.allBlocks(), 0};
+  BOOST_REQUIRE(tracker.beginTimeframe(*fixture.frame) == StageStatus::kComplete);
+  const auto run = test::runSlice(tracker, 0U, *fixture.frame, slice, {});
+  BOOST_REQUIRE(run.status == StageStatus::kComplete);
+  BOOST_REQUIRE(parameters.minRoadStartLevel == 2U);
+  const auto counted = countRoads(run, parameters, slice.core, parameters.minRoadStartLevel);
+
+  // Track 0 runs through all eight layers with a second hit on layer 3: the
+  // branch doubles the roads from (4, 5, 6) up, and (5, 6, 7), level 6, is
+  // its one start. Track 1 lost its layer-3 hit: (12, 13, 14) -> (13, 14, 15)
+  // at level 2; its (9, 10, 11) is on no path of four clusters, and neither is
+  // track 2's lone triplet, so neither is made.
+  struct Expected {
+    std::array<std::uint32_t, 3> hits{};
+    std::uint32_t successorAbove = 0U;
+    std::uint32_t roads = 0U;
+    bool start = false;
+  };
+  const std::array<Expected, 11> expected{{
+    {.hits = {0, 1, 2}, .successorAbove = 1, .roads = 1},
+    {.hits = {1, 2, 3}, .successorAbove = 1, .roads = 1},
+    {.hits = {1, 2, kSecondOnLayer3}, .successorAbove = 1, .roads = 1},
+    {.hits = {2, 3, 4}, .successorAbove = 1, .roads = 1},
+    {.hits = {2, kSecondOnLayer3, 4}, .successorAbove = 1, .roads = 1},
+    {.hits = {3, 4, 5}, .successorAbove = 1, .roads = 1},
+    {.hits = {kSecondOnLayer3, 4, 5}, .successorAbove = 1, .roads = 1},
+    {.hits = {4, 5, 6}, .successorAbove = 1, .roads = 2},
+    {.hits = {5, 6, 7}, .successorAbove = 0, .roads = 2, .start = true},
+    {.hits = {kTrack1[4], kTrack1[5], kTrack1[6]}, .successorAbove = 1, .roads = 1},
+    {.hits = {kTrack1[5], kTrack1[6], kTrack1[7]}, .successorAbove = 0, .roads = 1, .start = true},
+  }};
+  BOOST_REQUIRE(run.triplets->size() == expected.size());
+  std::vector<std::uint32_t> starts;
+  std::uint32_t fullTrackStart = run.triplets->size();
+  for (const auto& triplet : expected) {
+    const auto index = findTriplet(*run.tracklets, *run.triplets, fixture.row(triplet.hits[0]), fixture.row(triplet.hits[1]), fixture.row(triplet.hits[2]));
+    BOOST_TEST_CONTEXT("triplet " << triplet.hits[0] << " " << triplet.hits[1] << " " << triplet.hits[2])
+    {
+      BOOST_REQUIRE(index < run.triplets->size());
+      BOOST_TEST(counted.successorAbove[index] == triplet.successorAbove);
+      BOOST_TEST(counted.roads[index] == triplet.roads);
+    }
+    if (triplet.start) {
+      starts.push_back(index);
+    }
+    if (triplet.hits[0] == 5U) {
+      fullTrackStart = index;
+    }
+  }
+  std::ranges::sort(starts);
+  BOOST_TEST(counted.starts == starts, boost::test_tools::per_element());
+
+  // Seven clusters or more: only track 0's start, level 6, remains; nine is
+  // beyond its eight.
+  auto seven = iterationSettings();
+  seven.minClusters = 7;
+  const auto sevenParameters = iterationParameters<Det>(seven, Fixture::kBeamConstraint, scattering);
+  BOOST_TEST(sevenParameters.minRoadStartLevel == 5U);
+  const auto longOnly = countRoads(run, sevenParameters, slice.core, sevenParameters.minRoadStartLevel);
+  BOOST_TEST(longOnly.starts == std::vector<std::uint32_t>{fullTrackStart}, boost::test_tools::per_element());
+  BOOST_TEST(longOnly.roads == counted.roads, boost::test_tools::per_element());
+  BOOST_TEST(countRoads(run, parameters, slice.core, 7U).starts.empty());
+
+  // Three roads: the two of track 0, which part at levels 2 to 4 -- one
+  // through each hit on layer 3 -- and meet again below and above; then
+  // track 1's.
+  const auto& roads = counted.enumerated;
+  BOOST_REQUIRE(roads.size() == 3U);
+  BOOST_REQUIRE(roads[0].size() == 6U);
+  BOOST_REQUIRE(roads[1].size() == 6U);
+  BOOST_TEST(roads[2].size() == 2U);
+  BOOST_TEST(roads[0][0] == roads[1][0]);
+  for (std::size_t level = 1; level < 4U; ++level) {
+    BOOST_TEST(roads[0][level] != roads[1][level]);
+  }
+  BOOST_TEST(roads[0][4] == roads[1][4]);
+  BOOST_TEST(roads[0][5] == fullTrackStart);
+  BOOST_TEST(roads[1][5] == fullTrackStart);
+  BOOST_TEST(roads[2][1] == starts.back());
+  checkAgainstBruteForce(run, parameters, slice.core, 1U, countRoads(run, parameters, slice.core, 1U));
+
+  // With an end-layer mask a road starts at every triplet ending on one of its
+  // layers, extended or not: on layer 3, track 0's two prefixes (1, 2, 3) and
+  // (1, 2, 3'), a road of four clusters each; with layer 7 as well, the two
+  // starts above and their three roads besides.
+  std::vector<std::uint32_t> onThree;
+  for (const auto third : {3U, kSecondOnLayer3}) {
+    onThree.push_back(findTriplet(*run.tracklets, *run.triplets, fixture.row(1U), fixture.row(2U), fixture.row(third)));
+  }
+  std::ranges::sort(onThree);
+  const auto three = countRoads(run, parameters, slice.core, 2U, 0, 1U, std::uint64_t{1U} << 3U);
+  BOOST_TEST(three.starts == onThree, boost::test_tools::per_element());
+  BOOST_TEST(three.roads == counted.roads, boost::test_tools::per_element());
+  BOOST_REQUIRE(three.enumerated.size() == 2U);
+  BOOST_TEST(three.enumerated[0].size() == 2U);
+  BOOST_TEST(three.enumerated[1].size() == 2U);
+  auto threeAndSeven = onThree;
+  threeAndSeven.insert(threeAndSeven.end(), starts.begin(), starts.end());
+  std::ranges::sort(threeAndSeven);
+  const auto both = countRoads(run, parameters, slice.core, 2U, 0, 1U, (std::uint64_t{1U} << 3U) | (std::uint64_t{1U} << 7U));
+  BOOST_TEST(both.starts == threeAndSeven, boost::test_tools::per_element());
+  BOOST_TEST(both.enumerated.size() == 5U);
+  // A mask of layers no triplet ends on starts nothing.
+  BOOST_TEST(countRoads(run, parameters, slice.core, 2U, 0, 1U, std::uint64_t{1U} << 1U).starts.empty());
+}
+
+BOOST_AUTO_TEST_CASE(RoadsMatchABruteForceWalkAndOnlyTheCoresAreCounted)
+{
+  const Fixture fixture{sliceHits(), kSliceDurationNS};
+  const std::array<double, kLayers> material{};
+  const auto scattering = scatteringTable<Det>(material);
+  const auto parameters = iterationParameters<Det>(iterationSettings(), Fixture::kBeamConstraint, scattering);
+  Controller tracker{iterationSettings(), Fixture::kBeamConstraint, scattering, std::make_shared<BoundedMemoryResource>(), 2U, 2};
+  const std::int64_t haloPS = sliceReach(frameBounds(*fixture.frame), fixture.geometry).haloPS();
+  const auto blockCount = fixture.geometry.blockCount();
+
+  // The whole timeframe, then three slices whose cores own parts of it.
+  std::size_t owned = 0U;
+  std::size_t total = 0U;
+  for (const auto& [begin, end] : std::array<std::array<std::int32_t, 2>, 4>{{{0, blockCount}, {0, 20}, {20, 35}, {35, blockCount}}}) {
+    const Frame::TimeSlice slice{*fixture.frame, {.begin = begin, .end = end}, haloPS};
+    BOOST_REQUIRE(tracker.beginTimeframe(*fixture.frame) == StageStatus::kComplete);
+    const auto run = test::runSlice(tracker, 0U, *fixture.frame, slice, {});
+    BOOST_REQUIRE(run.status == StageStatus::kComplete);
+    BOOST_TEST_CONTEXT("core blocks " << begin << "-" << end)
+    {
+      for (const std::uint32_t minStartLevel : {1U, 2U, 5U}) {
+        const auto counted = countRoads(run, parameters, slice.core, minStartLevel);
+        checkAgainstBruteForce(run, parameters, slice.core, minStartLevel, counted);
+        for (const int threads : {1, 2, 4}) {
+          for (const RoadCount::Index chunk : {1U, 3U, 16U}) {
+            const auto parallel = countRoads(run, parameters, slice.core, minStartLevel, threads, chunk);
+            BOOST_TEST(parallel.successorAbove == counted.successorAbove, boost::test_tools::per_element());
+            BOOST_TEST(parallel.roads == counted.roads, boost::test_tools::per_element());
+            BOOST_TEST(parallel.starts == counted.starts, boost::test_tools::per_element());
+            BOOST_TEST((parallel.enumerated == counted.enumerated));
+          }
+        }
+      }
+      // The roads of the minimum length, summed over the starts.
+      const auto counted = countRoads(run, parameters, slice.core, parameters.minRoadStartLevel);
+      std::size_t roads = 0U;
+      for (const auto start : counted.starts) {
+        roads += counted.roads[start];
+      }
+      (begin == 0 && end == blockCount ? total : owned) += roads;
+    }
+  }
+  // The three cores tile the timeframe, and each road is owned by one.
+  BOOST_TEST(total > 0U);
+  BOOST_TEST(owned == total);
+}
+
+namespace
+{
+
+/// The slicing fixture's tracks, a third of them from layer 1 and a third
+/// from layer 2 on, so their roads start on those layers.
+std::vector<Hit> staggeredHits()
+{
+  std::vector<Hit> hits;
+  for (std::size_t track = 0; track < kSliceTracks; ++track) {
+    const double phi0 = std::fmod(0.3 + (0.9 * static_cast<double>(track)), 2 * std::numbers::pi_v<double>);
+    const double slope = (track % 2U == 0U ? 0.03 : -0.02) + (0.002 * static_cast<double>(track));
+    const double pt = 1.2 + (0.3 * static_cast<double>(track % 4U));
+    const double start = 37. + (83. * static_cast<double>(track));
+    for (std::size_t layer = track % 3U; layer < kLayers; ++layer) {
+      hits.push_back({.point = helixAt(phi0, slope, pt, static_cast<LayerID>(layer)), .timeNS = start});
+    }
+  }
+  return hits;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(AStartLayerMaskKeepsExactlyTheRoadsStartingOnIt)
+{
+  const Fixture fixture{staggeredHits(), kSliceDurationNS};
+  const std::array<double, kLayers> material{};
+  const auto scattering = scatteringTable<Det>(material);
+  const auto parameters = iterationParameters<Det>(iterationSettings(), Fixture::kBeamConstraint, scattering);
+  Controller tracker{iterationSettings(), Fixture::kBeamConstraint, scattering, std::make_shared<BoundedMemoryResource>(), 2U, 2};
+  const std::int64_t haloPS = sliceReach(frameBounds(*fixture.frame), fixture.geometry).haloPS();
+  const Frame::TimeSlice slice{*fixture.frame, {.begin = 0, .end = fixture.geometry.blockCount()}, haloPS};
+  BOOST_REQUIRE(tracker.beginTimeframe(*fixture.frame) == StageStatus::kComplete);
+  const auto run = test::runSlice(tracker, 0U, *fixture.frame, slice, {});
+  BOOST_REQUIRE(run.status == StageStatus::kComplete);
+  const auto all = countRoads(run, parameters, slice.core, parameters.minRoadStartLevel);
+  const auto tracklets = run.tracklets->view();
+  const auto triplets = run.triplets->view();
+  const auto startLayer = [&](const Road& road) { return parameters.linkSources[tracklets.link[triplets.first[road.front()]]]; };
+  std::set<LayerID> starts;
+  for (const auto& road : all.enumerated) {
+    starts.insert(startLayer(road));
+  }
+  BOOST_REQUIRE((starts == std::set<LayerID>{0, 1, 2}));
+  for (const std::uint64_t mask : {std::uint64_t{1U}, std::uint64_t{1U} << 2U, std::uint64_t{6U}}) {
+    const auto cores = roadCores(std::span<const MeasurementRange, kLayers>{slice.core}, mask);
+    const auto masked = countRoads(run, parameters, cores, parameters.minRoadStartLevel);
+    checkAgainstBruteForce(run, parameters, cores, parameters.minRoadStartLevel, masked);
+    std::vector<Road> expected;
+    std::ranges::copy_if(all.enumerated, std::back_inserter(expected), [&](const Road& road) { return ((mask >> startLayer(road)) & 1U) != 0U; });
+    BOOST_TEST_CONTEXT("mask " << mask)
+    {
+      BOOST_TEST(!expected.empty());
+      BOOST_TEST((masked.enumerated == expected));
+    }
+  }
+}
+
+namespace
+{
+
+/// A road as its clusters, innermost first.
+using RoadClusters = std::vector<std::uint32_t>;
+
+/// Every road the slices of \a widthBlocks blocks own, the first
+/// \a firstWidth wide, as clusters, sorted.
+std::vector<RoadClusters> roadsOfSlicing(const Fixture& fixture, std::int32_t widthBlocks, std::int32_t firstWidth)
+{
+  const std::array<double, kLayers> material{};
+  const auto scattering = scatteringTable<Det>(material);
+  const auto parameters = iterationParameters<Det>(iterationSettings(), Fixture::kBeamConstraint, scattering);
+  Controller tracker{iterationSettings(), Fixture::kBeamConstraint, scattering, std::make_shared<BoundedMemoryResource>(), 2U, 2};
+  const std::int64_t haloPS = sliceReach(frameBounds(*fixture.frame), fixture.geometry).haloPS();
+  const auto blockCount = fixture.geometry.blockCount();
+  std::vector<RoadClusters> result;
+  for (std::int32_t begin = 0; begin < blockCount;) {
+    const auto end = std::min(blockCount, begin + (begin == 0 ? firstWidth : widthBlocks));
+    const Frame::TimeSlice slice{*fixture.frame, {.begin = begin, .end = end}, haloPS};
+    BOOST_REQUIRE(tracker.beginTimeframe(*fixture.frame) == StageStatus::kComplete);
+    const auto run = test::runSlice(tracker, 0U, *fixture.frame, slice, {});
+    BOOST_REQUIRE(run.status == StageStatus::kComplete);
+    const auto counted = countRoads(run, parameters, slice.core, parameters.minRoadStartLevel);
+    const auto tracklets = run.tracklets->view();
+    const auto triplets = run.triplets->view();
+    const auto cluster = [&](std::uint32_t row) { return fixture.frame->measurement(row).clusterIndex; };
+    for (const auto& road : counted.enumerated) {
+      const auto first = triplets.first[road.front()];
+      RoadClusters clusters{cluster(tracklets.source[first]), cluster(tracklets.target[first])};
+      for (const auto triplet : road) {
+        clusters.push_back(cluster(tracklets.target[triplets.second[triplet]]));
+      }
+      result.push_back(clusters);
+    }
+    begin = end;
+  }
+  std::ranges::sort(result);
+  return result;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(TheRoadsDoNotDependOnTheSlicing)
+{
+  const Fixture fixture{sliceHits(), kSliceDurationNS};
+  const auto blockCount = fixture.geometry.blockCount();
+  const auto whole = roadsOfSlicing(fixture, blockCount, blockCount);
+  BOOST_TEST((std::ranges::adjacent_find(whole) == whole.end()), "a road owned twice");
+  // Every track: one road through all eight layers, two where it is branched.
+  BOOST_TEST(whole.size() == kSliceTracks + ((kSliceTracks + 2U) / 3U));
+  for (const auto& [width, first] : std::array<std::array<std::int32_t, 2>, 5>{{{1, 1}, {2, 2}, {2, 1}, {3, 2}, {7, 4}}}) {
+    BOOST_TEST_CONTEXT("slices of " << width << " blocks, the first " << first) { BOOST_TEST((roadsOfSlicing(fixture, width, first) == whole)); }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(OrderedCountsSaturateAndKeepOverflowAcrossReplay)
+{
+  constexpr std::uint32_t kNodes = 66U;
+  std::array<std::uint32_t, kNodes> roads{};
+  std::array<std::uint32_t, kNodes> successors{};
+  std::uint32_t overflow = 0U;
+  const OrderedRoadCounts state{.roads = roads.data(), .successorAbove = successors.data(), .overflow = &overflow};
+  for (int attempt = 0; attempt < 2; ++attempt) {
+    roads[0] = roads[1] = 1U;
+    for (std::uint32_t node = 2U; node < kNodes; ++node) {
+      std::uint64_t sum = 0U;
+      const auto below = ((node / 2U) - 1U) * 2U;
+      state.add(below, sum);
+      state.add(below + 1U, sum);
+      state.finish(node, sum);
+      BOOST_TEST(roads[node] == (node < 64U ? std::uint32_t{1U} << (node / 2U) : std::numeric_limits<std::uint32_t>::max()));
+    }
+    BOOST_TEST(overflow == 1U);
+    BOOST_TEST(std::all_of(successors.begin(), successors.end() - 2, [](auto flag) { return flag == 1U; }));
+  }
+  // A subsequent small sum cannot clear an earlier overflowing node's flag.
+  state.finish(64U, 1U);
+  BOOST_TEST(overflow == 1U);
+}
+
+BOOST_AUTO_TEST_CASE(OrderedNumberingChecksEmptyIndividualAndTotalOverflow)
+{
+  const std::array<double, kLayers> material{};
+  const auto parameters = iterationParameters<Det>(iterationSettings(), Fixture::kBeamConstraint, scatteringTable<Det>(material));
+  const auto serial = [](std::uint32_t elements, const auto& body) {
+    for (std::uint32_t element = 0U; element < elements; ++element) {
+      body(element);
+    }
+  };
+  const auto pool = std::make_shared<BoundedMemoryResource>();
+  StageOutput<TrackletT> tracklets;
+  tracklets.setMemoryPool(pool);
+  tracklets.prepare(1U);
+  const auto madeTracklets = runSerial(tracklets, [](auto, auto& emitter) { emitter.emit(Tracklet{.source = 0U, .target = 0U, .link = 0U, .lambda = 0.F, .phi = 0.F}); });
+  BOOST_REQUIRE(madeTracklets == StageStatus::kComplete);
+  std::array<MeasurementRange, kLayers> core{};
+  core[parameters.linkSources[0]] = {.begin = 0U, .end = 1U};
+  for (const std::uint32_t depth : {0U, 31U, 32U, 33U}) {
+    StageOutput<TripletT> triplets;
+    triplets.setMemoryPool(pool);
+    triplets.prepare(2U * depth);
+    const auto madeTriplets = runSerial(triplets, [](auto element, auto& emitter) { emitter.emit(Triplet{.first = 0U, .second = 0U, .curvature = 0.F, .varCurvature = 0.F, .level = element / 2U + 1U, .kinked = 0U}); });
+    BOOST_REQUIRE(madeTriplets == StageStatus::kComplete);
+    RoadCount counter;
+    counter.setMemoryPool(pool);
+    counter.prepareOrdered(serial, triplets.size());
+    const auto state = counter.ordered(parameters.linkSources, core.data());
+    for (std::uint32_t node = 0U; node < triplets.size(); ++node) {
+      state.base(node, tracklets.view(), triplets.view());
+      if (node >= 2U) {
+        std::uint64_t sum = 0U;
+        const auto below = ((node / 2U) - 1U) * 2U;
+        state.add(below, sum);
+        state.add(below + 1U, sum);
+        state.finish(node, sum);
+      }
+    }
+    const auto status = counter.runPrepared(serial, roadStartRule(parameters), tracklets, triplets, 256U);
+    BOOST_TEST((status == (depth >= 32U ? StageStatus::kIndexOverflow : StageStatus::kComplete)));
+    if (depth == 0U) {
+      BOOST_TEST(counter.roadCount() == 0U);
+      BOOST_TEST(counter.roadOffsets().size() == 1U);
+    }
+    // No starts under this mask: individual overflow must still be reported.
+    const RoadStartRule noStarts{.minLevel = 2U, .endLayers = std::uint64_t{1U} << 7U, .linkTargets = parameters.linkTargets};
+    const auto maskedStatus = counter.runPrepared(serial, noStarts, tracklets, triplets, 256U);
+    BOOST_TEST((maskedStatus == (depth == 33U ? StageStatus::kIndexOverflow : StageStatus::kComplete)));
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testSeedCuts.cxx b/Detectors/GenericTracking/tracking/test/testSeedCuts.cxx
new file mode 100644
index 0000000000000..92703bc7716e3
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testSeedCuts.cxx
@@ -0,0 +1,352 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testSeedCuts.cxx
+/// \brief Triplet and neighbour acceptance and rejection on generated helices.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK SeedCuts
+#include <boost/test/unit_test.hpp>
+
+#include "ToyBarrel4Disc8.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/LayerMaterial.h"
+#include "GenericTracking/Tracking/TripletCut.h"
+#include "GenericTracking/Tracking/NeighbourCut.h"
+
+#include "GeneratedHelixFixture.h"
+#include "Oracles.h"
+
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <random>
+
+namespace o2::gtrk
+{
+namespace
+{
+using detectors::ToyBarrel4Disc8;
+using Helix = GeneratedHelixFixture<ToyBarrel4Disc8>;
+using State = Helix::State;
+using Errors = Helix::Errors;
+constexpr int kDraws = 2000;
+constexpr double kKept = 0.99;
+} // namespace
+
+namespace triplets
+{
+namespace
+{
+struct Case {
+  std::array<LayerID, 3> layers{};
+  double slope = 0.;
+  Errors errors;
+};
+
+struct Rates {
+  int lambda = 0;
+  int time = 0;
+  int curvature = 0;
+  int all = 0;
+};
+
+/// Generate kDraws triplets on the case's layers at \a ptGeV, with the
+/// Highland kink at the middle layer at that momentum and Gaussian errors, and
+/// count how many pass each cut of an iteration at \a minPtGeV. \a zShift and
+/// \a timeShift move the third measurement.
+Rates rates(const Case& c, double ptGeV, double minPtGeV, double zShift = 0., double timeShift = 0.)
+{
+  const auto parameters = Helix::parametersAt(minPtGeV);
+  const double curvature = 1. / curvatureRadius(ptGeV, 20.);
+  const auto secondLink = linkOf<ToyBarrel4Disc8>(c.layers[1], c.layers[2]);
+  const TripletTargetBounds target{
+    .varZ = static_cast<Scalar>(c.errors.varZ),
+    .varR = static_cast<Scalar>(c.errors.varR),
+    .varRPhi = static_cast<Scalar>(c.errors.varRPhi),
+  };
+
+  // A fixed seed: the rates are compared against fixed thresholds.
+  std::mt19937_64 generator(20260926U); // NOLINT(cert-msc51-cpp)
+  Rates result;
+  for (int draw = 0; draw < kDraws; ++draw) {
+    const State origin{.phi = 0.3, .slope = c.slope};
+    const State a = Helix::toLayer(origin, curvature, c.layers[0]);
+    const State b = Helix::toLayer(a, curvature, c.layers[1]);
+    State third = Helix::toLayer(Helix::scatter(b, c.layers[1], ptGeV, parameters, generator), curvature, c.layers[2]);
+    third.z += zShift;
+
+    const auto first = Helix::measure(a, c.errors, 0., generator);
+    const auto middle = Helix::measure(b, c.errors, 0., generator);
+    const auto last = Helix::measure(third, c.errors, timeShift, generator);
+    const auto lambdaFirst = std::atan2(middle.point.z - first.point.z, pairChord(first.point, middle.point).chord);
+    const auto lambdaSecond = std::atan2(last.point.z - middle.point.z, pairChord(middle.point, last.point).chord);
+    const Scalar halfWidth = tripletLambdaHalfWidth(parameters, secondLink, c.layers[1], first.point, middle.point, target);
+    const bool lambdaPasses = std::abs(lambdaSecond - lambdaFirst) <= halfWidth;
+    const bool timePasses = tripletTimeCompatible(first, last);
+    const bool curvaturePasses = tripletCurvatureCompatible(parameters, c.layers[1], first.point, middle.point, last.point);
+    TripletFitResult fit;
+    const bool allPass = lambdaPasses && tripletCompatible(parameters, c.layers[1], first, middle, last, fit);
+    result.lambda += lambdaPasses ? 1 : 0;
+    result.time += timePasses ? 1 : 0;
+    result.curvature += curvaturePasses ? 1 : 0;
+    result.all += allPass ? 1 : 0;
+  }
+  return result;
+}
+
+const std::array<Case, 5> kCases{{
+  {.layers = {0, 1, 2}, .slope = 0.3, .errors = Helix::kPixelErrors}, // barrel
+  {.layers = {1, 2, 3}, .slope = 1., .errors = Helix::kPixelErrors},  // steep barrel
+  {.layers = {1, 2, 3}, .slope = 0.6, .errors = Helix::kLongZErrors}, // barrel, poor z
+  {.layers = {8, 9, 10}, .slope = 3., .errors = Helix::kDiscErrors},  // discs
+  {.layers = {0, 8, 9}, .slope = 3., .errors = Helix::kPixelErrors},  // barrel into the discs
+}};
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(TrueTripletsPassEveryCut)
+{
+  for (const auto& c : kCases) {
+    for (const auto& [pt, minPt] : std::array<std::array<double, 2>, 4>{{{1., 1.}, {1.5, 1.}, {5., 1.}, {0.3, 0.3}}}) {
+      const auto kept = rates(c, pt, minPt);
+      BOOST_TEST_CONTEXT("layers " << int(c.layers[0]) << " " << int(c.layers[1]) << " " << int(c.layers[2]) << " pT " << pt << " min " << minPt)
+      {
+        BOOST_TEST(kept.lambda >= kKept * kDraws);
+        BOOST_TEST(kept.time == kDraws);
+        BOOST_TEST(kept.curvature >= kKept * kDraws);
+        BOOST_TEST(kept.all >= kKept * kDraws);
+      }
+    }
+  }
+}
+
+namespace
+{
+
+/// Triplets whose middle point kinked by \a kinkTheta0 times the Highland
+/// theta0 at \a ptGeV (in the dip and in azimuth alike), under an iteration
+/// at \a minPtGeV with the kink allowance \a kinkSigma: how many pass the
+/// nominal cuts, how many only with the allowance.
+struct KinkedRates {
+  int nominal = 0;
+  int kinked = 0;
+};
+
+KinkedRates kinkedRates(const Case& c, double ptGeV, double minPtGeV, double kinkTheta0, double kinkSigma)
+{
+  const auto parameters = Helix::parametersAt(minPtGeV, kinkSigma);
+  const double curvature = 1. / curvatureRadius(ptGeV, 20.);
+  std::mt19937_64 generator(20261004U); // NOLINT(cert-msc51-cpp)
+  KinkedRates result;
+  for (int draw = 0; draw < kDraws; ++draw) {
+    const State origin{.phi = 0.3, .slope = c.slope};
+    const State a = Helix::toLayer(origin, curvature, c.layers[0]);
+    const State b = Helix::toLayer(a, curvature, c.layers[1]);
+    // The hard kink: theta0 of the middle layer at the track's momentum, as
+    // Helix::scatter draws it, times kinkTheta0, on both angles.
+    const double cosine = 1. / std::sqrt(1. + (b.slope * b.slope));
+    const auto k = static_cast<double>(parameters.scattering.layers[c.layers[1]].k);
+    const double theta0 = std::sqrt(k / cosine) * cosine / ptGeV;
+    State kinkedState = b;
+    const double sign = (draw % 2 == 0) ? 1. : -1.;
+    kinkedState.slope = std::tan(std::atan(b.slope) + (sign * kinkTheta0 * theta0));
+    kinkedState.phi += sign * kinkTheta0 * theta0 / cosine;
+    const State third = Helix::toLayer(kinkedState, curvature, c.layers[2]);
+    const auto first = Helix::measure(a, c.errors, 0., generator);
+    const auto middle = Helix::measure(b, c.errors, 0., generator);
+    const auto last = Helix::measure(third, c.errors, 0., generator);
+    TripletFitResult fit;
+    KinkTerms terms;
+    bool kinked = false;
+    if (tripletCompatible(parameters, c.layers[1], first, middle, last, fit, terms, kinked)) {
+      result.nominal += kinked ? 0 : 1;
+      result.kinked += kinked ? 1 : 0;
+    }
+  }
+  return result;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(TheKinkAllowanceKeepsAHardKinkAndNothingElse)
+{
+  // A 4 theta0 kink at the middle point at pT_min, on both angles: the
+  // nominal cuts keep few of them (the curvature test is one-sided, a kink
+  // can straighten the circle), an allowance of 2 keeps the rest; without
+  // one nothing more survives, and the nominal count is the same either way.
+  const auto without = kinkedRates(kCases[0], 1., 1., 4., 1.);
+  BOOST_TEST(without.nominal <= 0.15 * kDraws);
+  BOOST_TEST(without.kinked == 0);
+  const auto with = kinkedRates(kCases[0], 1., 1., 4., 2.);
+  BOOST_TEST(with.nominal == without.nominal);
+  BOOST_TEST(with.nominal + with.kinked >= 0.95 * kDraws);
+  // An 8 theta0 kink is beyond an allowance of 2 as well.
+  const auto beyond = kinkedRates(kCases[0], 1., 1., 8., 2.);
+  BOOST_TEST(beyond.kinked <= 0.02 * kDraws);
+  // True triplets without a kink are never flagged: the nominal cuts come first.
+  const auto straight = kinkedRates(kCases[0], 1., 1., 0., 2.);
+  BOOST_TEST(straight.nominal >= kKept * kDraws);
+  BOOST_TEST(straight.kinked <= 0.01 * kDraws);
+}
+
+BOOST_AUTO_TEST_CASE(ASofterTrackFailsTheCurvatureCut)
+{
+  const auto kept = rates(kCases[0], 0.5, 1.);
+  BOOST_TEST(kept.curvature <= 0.05 * kDraws);
+}
+
+BOOST_AUTO_TEST_CASE(AThirdMeasurementOffTheHelixFailsTheDipAngleCut)
+{
+  const auto kept = rates(kCases[0], 1., 1., 0.1);
+  BOOST_TEST(kept.lambda <= 0.05 * kDraws);
+}
+
+BOOST_AUTO_TEST_CASE(AThirdMeasurementTicksLateFailsTheTimeCut)
+{
+  const auto kept = rates(kCases[0], 1., 1., 0., 75.);
+  BOOST_TEST(kept.time == 0);
+}
+
+} // namespace triplets
+
+namespace neighbours
+{
+namespace
+{
+struct Case {
+  std::array<LayerID, 4> layers{};
+  double slope = 0.;
+  Errors errors;
+};
+
+/// How a draw departs from one helix after `c`.
+struct Departure {
+  double softPtGeV = 0.; ///< `d` from a track of this pT through `c`, if set
+  double zShift = 0.;    ///< `d` moved along z [cm]
+  double timeShift = 0.;
+};
+
+struct Rates {
+  int curvature = 0;
+  int time = 0;
+  int fit = 0;
+  int all = 0;
+  double chi2Sum = 0.; ///< over the draws the adjacent fit converged on
+  int fitted = 0;
+};
+
+/// Generate kDraws four-measurement chains on the case's layers at \a ptGeV,
+/// with the Highland kinks at `b` and `c` and Gaussian errors, and count how
+/// many pass each cut of an iteration at \a minPtGeV.
+Rates rates(const Case& c, double ptGeV, double minPtGeV, const Departure& departure = {})
+{
+  const auto parameters = Helix::parametersAt(minPtGeV);
+  const double curvature = 1. / curvatureRadius(ptGeV, 20.);
+
+  // A fixed seed: the rates are compared against fixed thresholds.
+  std::mt19937_64 generator(20260926U); // NOLINT(cert-msc51-cpp)
+  Rates result;
+  for (int draw = 0; draw < kDraws; ++draw) {
+    const State origin{.phi = 0.3, .slope = c.slope};
+    const State a = Helix::toLayer(origin, curvature, c.layers[0]);
+    const State b = Helix::toLayer(a, curvature, c.layers[1]);
+    const State third = Helix::toLayer(Helix::scatter(b, c.layers[1], ptGeV, parameters, generator), curvature, c.layers[2]);
+    const double lastCurvature = departure.softPtGeV > 0. ? 1. / curvatureRadius(departure.softPtGeV, 20.) : curvature;
+    State fourth = Helix::toLayer(Helix::scatter(third, c.layers[2], ptGeV, parameters, generator), lastCurvature, c.layers[3]);
+    fourth.z += departure.zShift;
+
+    const std::array<TimedPoint, 4> m{Helix::measure(a, c.errors, 0., generator), Helix::measure(b, c.errors, 0., generator), Helix::measure(third, c.errors, 0., generator), Helix::measure(fourth, c.errors, departure.timeShift, generator)};
+    TripletFitResult first;
+    TripletFitResult second;
+    const bool fitted = fitTriplet(m[0].point, m[1].point, m[2].point, c.layers[1], parameters.scattering, parameters.pairCut, first) && fitTriplet(m[1].point, m[2].point, m[3].point, c.layers[2], parameters.scattering, parameters.pairCut, second);
+    const bool curvaturePasses = fitted && neighbourCurvatureCompatible(parameters, first.curvature, first.varCurvature, second.curvature, second.varCurvature);
+    const bool timePasses = neighbourTimeCompatible(m[0], m[3]);
+    TripletFitResult adjacent;
+    const bool adjacentFitted = fitAdjacentTriplets(m[0].point, m[1].point, m[2].point, m[3].point, c.layers[1], c.layers[2], parameters.scattering, parameters.pairCut, adjacent);
+    TripletFitResult fit;
+    const bool allPass = curvaturePasses && neighbourCompatible(parameters, c.layers[1], c.layers[2], m[0], m[1], m[2], m[3], fit);
+    result.curvature += curvaturePasses ? 1 : 0;
+    result.time += timePasses ? 1 : 0;
+    result.fit += adjacentFitted && adjacent.chi2 <= parameters.neighbourChi2Max ? 1 : 0;
+    result.all += allPass ? 1 : 0;
+    if (adjacentFitted) {
+      result.chi2Sum += static_cast<double>(adjacent.chi2);
+      ++result.fitted;
+    }
+  }
+  return result;
+}
+
+const std::array<Case, 5> kCases{{
+  {.layers = {0, 1, 2, 3}, .slope = 0.3, .errors = Helix::kPixelErrors}, // barrel
+  {.layers = {0, 1, 2, 3}, .slope = 1., .errors = Helix::kPixelErrors},  // steep barrel
+  {.layers = {0, 1, 2, 3}, .slope = 0.6, .errors = Helix::kLongZErrors}, // barrel, poor z
+  {.layers = {8, 9, 10, 11}, .slope = 3., .errors = Helix::kDiscErrors}, // discs
+  {.layers = {0, 8, 9, 10}, .slope = 3., .errors = Helix::kPixelErrors}, // barrel into the discs
+}};
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(TrueNeighboursPassEveryCut)
+{
+  for (const auto& c : kCases) {
+    for (const auto& [pt, minPt] : std::array<std::array<double, 2>, 4>{{{1., 1.}, {1.5, 1.}, {5., 1.}, {0.3, 0.3}}}) {
+      const auto kept = rates(c, pt, minPt);
+      BOOST_TEST_CONTEXT("layers " << int(c.layers[0]) << " " << int(c.layers[1]) << " " << int(c.layers[2]) << " " << int(c.layers[3]) << " slope " << c.slope << " pT " << pt << " min " << minPt)
+      {
+        BOOST_TEST(kept.curvature >= kKept * kDraws);
+        BOOST_TEST(kept.time == kDraws);
+        BOOST_TEST(kept.fit >= kKept * kDraws);
+        BOOST_TEST(kept.all >= kKept * kDraws);
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(TheAdjacentChi2HasThreeDegreesOfFreedomAtPtMin)
+{
+  // At pT_min the fit's scattering is the generator's, so its chi2 follows
+  // the 3-dof distribution: mean 3, and that mean's error over kDraws is
+  // sqrt(6 / kDraws) = 0.055.
+  for (const auto& c : kCases) {
+    const auto kept = rates(c, 1., 1.);
+    const double mean = kept.chi2Sum / kept.fitted;
+    BOOST_TEST_CONTEXT("layers " << int(c.layers[0]) << " " << int(c.layers[1]) << " " << int(c.layers[2]) << " " << int(c.layers[3]) << " slope " << c.slope)
+    {
+      BOOST_TEST_MESSAGE("mean chi2 " << mean);
+      BOOST_TEST(kept.fitted == kDraws);
+      BOOST_TEST(mean >= 2.7);
+      BOOST_TEST(mean <= 3.3);
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(ASofterTrackThroughTheSharedPairFailsTheCurvatureCut)
+{
+  const auto kept = rates(kCases[0], 5., 1., {.softPtGeV = 0.5});
+  BOOST_TEST(kept.curvature <= 0.05 * kDraws);
+}
+
+BOOST_AUTO_TEST_CASE(AFourthMeasurementOffTheHelixFailsTheFit)
+{
+  const auto kept = rates(kCases[0], 1., 1., {.zShift = 0.1});
+  BOOST_TEST(kept.fit <= 0.05 * kDraws);
+}
+
+BOOST_AUTO_TEST_CASE(AFourthMeasurementTicksLateFailsTheTimeCut)
+{
+  const auto kept = rates(kCases[0], 1., 1., {.timeShift = 75.});
+  BOOST_TEST(kept.time == 0);
+}
+
+} // namespace neighbours
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testSelection.cxx b/Detectors/GenericTracking/tracking/test/testSelection.cxx
new file mode 100644
index 0000000000000..87c7dfa0f6b2d
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testSelection.cxx
@@ -0,0 +1,257 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testSelection.cxx
+/// \brief The global selection's rounds of bidding against hand-made cases
+///        and the sequential greedy walk, with and without shared clusters.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Selection
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Tracking/Selection.h"
+#include "SerialReferences.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <random>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+constexpr std::size_t kCapacity = 8U;
+using Selection = GlobalSelection<kCapacity>;
+using Records = Selection::Records;
+using Record = BoundedColumns<SelectionRecordOf<kCapacity>::template RecordT>::Record;
+
+struct Road {
+  std::vector<std::uint32_t> rows; ///< innermost first
+  Scalar chi2 = 0.F;
+  std::uint8_t kinks = 0U; ///< the outward pass's
+};
+
+Record record(const Road& road)
+{
+  Record result;
+  for (std::size_t i = 0; i < kCapacity; ++i) {
+    result.clusters.index[i] = i < road.rows.size() ? road.rows[i] : ClusterList<kCapacity>::kNoCluster;
+  }
+  result.count = static_cast<std::uint8_t>(road.rows.size());
+  result.chi2 = road.chi2;
+  result.kinks = road.kinks;
+  return result;
+}
+
+/// One slice's records.
+void append(Selection& selection, const std::vector<Road>& roads)
+{
+  Records records;
+  records.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  records.prepare(static_cast<Records::Index>(roads.size()));
+  BOOST_REQUIRE(runSerial(records, [&](Records::Index element, auto& emitter) { emitter.emit(record(roads[element])); }) == StageStatus::kComplete);
+  BOOST_REQUIRE(selection.append(records, SerialForEach{}) == StageStatus::kComplete);
+}
+
+const auto kSerial = [](std::uint32_t elements, const auto& body) {
+  for (std::uint32_t element = 0; element < elements; ++element) {
+    body(element);
+  }
+};
+
+const auto kSerialSort = [](std::span<std::uint32_t> indices, const auto& less) { std::ranges::sort(indices, less); };
+
+/// The selected roads, each as its rows.
+std::vector<std::vector<std::uint32_t>> selectedRows(const Selection& selection)
+{
+  std::vector<std::vector<std::uint32_t>> result;
+  const auto records = selection.records();
+  for (const auto index : selection.selected()) {
+    result.emplace_back(records.clusters[index].index, records.clusters[index].index + records.count[index]);
+  }
+  return result;
+}
+
+struct Outcome {
+  std::vector<std::vector<std::uint32_t>> selected;
+  std::vector<std::uint8_t> mask;
+  std::uint32_t rounds = 0U;
+};
+
+Outcome run(const std::vector<std::vector<Road>>& slices, std::uint32_t sharedInnermost, std::vector<std::uint8_t> mask)
+{
+  Selection selection;
+  selection.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  for (const auto& slice : slices) {
+    append(selection, slice);
+  }
+  BOOST_REQUIRE(selection.select(kSerial, kSerialSort, sharedInnermost, mask) == StageStatus::kComplete);
+  BOOST_TEST(selection.mismatches() == 0U);
+  return {.selected = selectedRows(selection), .mask = mask, .rounds = selection.rounds()};
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(TheBestRecordWinsAndItsLoserFreesTheNext)
+{
+  // A beats B on row 3; B would beat C on row 6, but B is out, so C is in:
+  // the greedy result, in two rounds.
+  const std::vector<Road> roads{{.rows = {6, 7, 8, 9}, .chi2 = 3.F}, {.rows = {3, 4, 5, 6}, .chi2 = 2.F}, {.rows = {0, 1, 2, 3}, .chi2 = 1.F}};
+  const auto outcome = run({roads}, 0U, std::vector<std::uint8_t>(12U, kFree));
+  BOOST_REQUIRE(outcome.selected.size() == 2U);
+  BOOST_TEST(outcome.selected[0] == roads[2].rows, boost::test_tools::per_element());
+  BOOST_TEST(outcome.selected[1] == roads[0].rows, boost::test_tools::per_element());
+  BOOST_TEST(outcome.rounds == 2U);
+  const std::vector<std::uint8_t> mask{2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 0, 0};
+  BOOST_TEST(outcome.mask == mask, boost::test_tools::per_element());
+}
+
+BOOST_AUTO_TEST_CASE(MoreClustersBeatALowerChi2)
+{
+  const std::vector<Road> roads{{.rows = {0, 1, 2, 3}, .chi2 = 1.F}, {.rows = {3, 4, 5, 6, 7}, .chi2 = 10.F}};
+  const auto outcome = run({roads}, 0U, std::vector<std::uint8_t>(8U, kFree));
+  BOOST_REQUIRE(outcome.selected.size() == 1U);
+  BOOST_TEST(outcome.selected[0] == roads[1].rows, boost::test_tools::per_element());
+}
+
+BOOST_AUTO_TEST_CASE(ARoadFoundByTwoSlicesIsOneRecord)
+{
+  const Road road{.rows = {0, 1, 2, 3}, .chi2 = 1.F};
+  Selection selection;
+  selection.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  append(selection, {road});
+  append(selection, {road});
+  std::vector<std::uint8_t> mask(4U, kFree);
+  BOOST_REQUIRE(selection.select(kSerial, kSerialSort, 0U, mask) == StageStatus::kComplete);
+  BOOST_TEST(selection.duplicates() == 1U);
+  BOOST_TEST(selection.mismatches() == 0U);
+  BOOST_TEST(selection.selected().size() == 1U);
+
+  // The same rows with another chi2: a road that depends on its slice.
+  append(selection, {{.rows = {0, 1, 2, 3}, .chi2 = 2.F}});
+  std::ranges::fill(mask, kFree);
+  BOOST_REQUIRE(selection.select(kSerial, kSerialSort, 0U, mask) == StageStatus::kComplete);
+  BOOST_TEST(selection.mismatches() == 1U);
+}
+
+BOOST_AUTO_TEST_CASE(TheInnermostClustersAreSharedWhenConfigured)
+{
+  // A and B share their first cluster; C has it third.
+  const std::vector<Road> roads{{.rows = {0, 1, 2, 3}, .chi2 = 1.F}, {.rows = {0, 4, 5, 6}, .chi2 = 2.F}, {.rows = {7, 8, 0, 9}, .chi2 = 3.F}};
+  const auto strict = run({roads}, 0U, std::vector<std::uint8_t>(10U, kFree));
+  BOOST_TEST(strict.selected.size() == 1U);
+  const auto shared = run({roads}, 1U, std::vector<std::uint8_t>(10U, kFree));
+  BOOST_REQUIRE(shared.selected.size() == 2U);
+  BOOST_TEST(shared.selected[1] == roads[1].rows, boost::test_tools::per_element());
+  BOOST_TEST(shared.mask[0] == kShared);
+  BOOST_TEST(shared.mask[1] == kExclusive);
+  // With three shareable, C's third cluster may be shared too.
+  BOOST_TEST(run({roads}, 3U, std::vector<std::uint8_t>(10U, kFree)).selected.size() == 3U);
+}
+
+BOOST_AUTO_TEST_CASE(EarlierIterationsTracksAreRespected)
+{
+  const std::vector<Road> roads{{.rows = {0, 1, 2, 3}, .chi2 = 1.F}, {.rows = {4, 5, 6, 7}, .chi2 = 1.F}};
+  std::vector<std::uint8_t> mask(8U, kFree);
+  mask[2] = kExclusive; // the first road's third cluster is taken
+  mask[4] = kShared;    // the second road's first is shared
+  BOOST_TEST(run({roads}, 0U, mask).selected.empty());
+  const auto shared = run({roads}, 1U, mask);
+  BOOST_REQUIRE(shared.selected.size() == 1U);
+  BOOST_TEST(shared.selected[0] == roads[1].rows, boost::test_tools::per_element());
+}
+
+BOOST_AUTO_TEST_CASE(TheRoundsAreTheSequentialGreedyWalk)
+{
+  // Dense conflicts: 3000 roads of 4 to 8 clusters on 1500 rows, duplicates
+  // among them, some rows already taken; for k = 0, 1 and 2, serially and on
+  // 1 to 4 threads, in the given order and shuffled over two slices.
+  // A fixed seed: the outcome is compared, not a rate.
+  std::mt19937_64 generator(20260926U); // NOLINT(cert-msc32-c,cert-msc51-cpp)
+  constexpr std::uint32_t kRows = 1500U;
+  std::vector<Road> roads;
+  std::uniform_int_distribution<std::uint32_t> row(0U, kRows - 1U);
+  std::uniform_int_distribution<std::uint32_t> length(4U, 8U);
+  std::uniform_real_distribution<float> chi2(0.F, 20.F);
+  for (int i = 0; i < 3000; ++i) {
+    Road road{.rows = {}, .chi2 = chi2(generator)};
+    const auto count = length(generator);
+    while (road.rows.size() < count) {
+      const auto candidate = row(generator);
+      if (std::ranges::find(road.rows, candidate) == road.rows.end()) {
+        road.rows.push_back(candidate);
+      }
+    }
+    roads.push_back(road);
+    if (i % 17 == 0) {
+      roads.push_back(road);
+    }
+  }
+  std::vector<std::uint8_t> initial(kRows, kFree);
+  for (std::uint32_t r = 0; r < kRows; r += 23U) {
+    initial[r] = r % 2U == 0U ? kShared : kExclusive;
+  }
+
+  for (const std::uint32_t sharedInnermost : {0U, 1U, 2U}) {
+    BOOST_TEST_CONTEXT("k " << sharedInnermost)
+    {
+      Selection selection;
+      selection.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+      append(selection, roads);
+      auto mask = initial;
+      BOOST_REQUIRE(selection.select(kSerial, kSerialSort, sharedInnermost, mask) == StageStatus::kComplete);
+      BOOST_TEST(selection.duplicates() == 177U);
+      BOOST_TEST(selection.mismatches() == 0U);
+      auto oracleMask = initial;
+      const auto oracle = selectSequentially<kCapacity>(selection.records(), selection.ranked(), sharedInnermost, oracleMask);
+      const std::vector<std::uint32_t> selected(selection.selected().begin(), selection.selected().end());
+      BOOST_TEST(selected == oracle, boost::test_tools::per_element());
+      BOOST_TEST(mask == oracleMask, boost::test_tools::per_element());
+      BOOST_TEST_MESSAGE("k " << sharedInnermost << ": " << selected.size() << " of " << selection.ranked().size() << " in " << selection.rounds() << " rounds");
+      BOOST_TEST(selection.rounds() > 1U);
+
+      for (const int threads : {1, 2, 4}) {
+        for (const std::uint32_t chunk : {1U, 7U, 64U}) {
+          detail::TaskArena cpuArena{threads};
+          CpuStage<SelectionRecordOf<kCapacity>::template RecordT> cpu{cpuArena};
+          cpu.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+          auto parallelMask = initial;
+          BOOST_REQUIRE(selection.select([&](std::uint32_t elements, const auto& body) { cpu.forEachElement(elements, chunk, body); }, [&](std::span<std::uint32_t> indices, const auto& less) { cpu.sortIndices(indices, less); }, sharedInnermost, parallelMask) == StageStatus::kComplete);
+          const std::vector<std::uint32_t> parallel(selection.selected().begin(), selection.selected().end());
+          BOOST_TEST_CONTEXT("threads " << threads << ", chunk " << chunk)
+          {
+            BOOST_TEST(parallel == selected, boost::test_tools::per_element());
+            BOOST_TEST(parallelMask == mask, boost::test_tools::per_element());
+          }
+        }
+      }
+
+      auto shuffled = roads;
+      std::ranges::shuffle(shuffled, generator);
+      const std::vector<Road> first(shuffled.begin(), shuffled.begin() + 1000);
+      const std::vector<Road> second(shuffled.begin() + 1000, shuffled.end());
+      const auto reordered = run({second, first}, sharedInnermost, initial);
+      auto expected = selectedRows(selection);
+      BOOST_TEST((reordered.selected == expected));
+      BOOST_TEST(reordered.mask == mask, boost::test_tools::per_element());
+    }
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testStageOutput.cxx b/Detectors/GenericTracking/tracking/test/testStageOutput.cxx
new file mode 100644
index 0000000000000..9fbb2065aa676
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testStageOutput.cxx
@@ -0,0 +1,415 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testStageOutput.cxx
+/// \brief Generate, scan and place: the serial reference and the CPU backend
+///        produce the same canonical output.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK StageOutput
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "SyntheticStage.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+
+#include "StageOutputComparison.h"
+#include "SerialReferences.h"
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <new>
+#include <numeric>
+#include <random>
+#include <thread>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using Output = StageOutput<TrackletT>;
+using Cpu = CpuStage<TrackletT>;
+using Index = Output::Index;
+
+template <typename Counts>
+auto generator(Counts counts)
+{
+  return synthetic::CountGenerator{counts};
+}
+
+/// Dense then empty, as barrel sources next to disc ones: the case a staging
+/// split by element count gets wrong.
+const auto kUneven = [](Index element) { return element < 40U ? 6U : 0U; };
+/// Irregular, including zero.
+const auto kIrregular = [](Index element) { return (element * 7U) % 11U; };
+
+std::shared_ptr<BoundedMemoryResource> pool() { return std::make_shared<BoundedMemoryResource>(); }
+
+struct LayeredDependencyGenerator {
+  std::array<Index, 5> layerBoundaries{0U, 37U, 1000U, 1000U, 1127U};
+  /// The layers by depth, as `layerDepthGroups` lists a layout's: layer 3
+  /// (read by layer 1) and the empty layer 2 at depth 0, layer 1 (read by
+  /// layer 0) at depth 1, layer 0 at depth 2.
+  struct Groups {
+    std::array<Index, 4> order{3U, 2U, 1U, 0U};
+    std::array<std::size_t, 5> groups{0U, 2U, 3U, 4U, 4U};
+    std::size_t count = 3U;
+  } layerGroups{};
+  std::span<Index> values;
+  template <typename Emitter>
+  void operator()(Index element, Emitter& emitter) const
+  {
+    const auto value = [&] {
+      if (element >= 1000U) {
+        return 1U;
+      }
+      if (element >= 37U) {
+        return values[1000U + element % 127U] + 1U;
+      }
+      return values[37U + element % 963U] + 1U;
+    }();
+    values[element] = value;
+    if (element % 5U != 0U) {
+      for (Index ordinal = 0U; ordinal < 4U; ++ordinal) {
+        emitter.emit(Tracklet{.source = element, .target = value, .link = 0U, .lambda = 0.F, .phi = static_cast<Scalar>(ordinal)});
+      }
+    }
+  }
+};
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(EveryColumnReadsBackThroughItsOwnField)
+{
+  // One sentinel per column, each unlike the others in every byte, so a view
+  // whose pointers were bound in an order other than the declared one reads a
+  // wrong value rather than a plausible one.
+  const Tracklet sentinel{
+    .source = 0xA1A1A1A1U,
+    .target = 0xB2B2B2B2U,
+    .link = 0xC3C3U,
+    .lambda = std::bit_cast<Scalar>(0x3ED4D4D4U),
+    .phi = std::bit_cast<Scalar>(0xBEE5E5E5U),
+  };
+  const auto memory = pool();
+  BoundedColumns<TrackletT> columns;
+  columns.setMemoryResource(memory.get());
+  columns.resize(3U);
+  for (std::size_t i = 0; i < columns.size(); ++i) {
+    Tracklet record = sentinel;
+    record.source += static_cast<std::uint32_t>(i);
+    record.link = static_cast<std::uint16_t>(record.link + i);
+    columns.write(i, record);
+  }
+
+  const TrackletView view = columns.view();
+  const TrackletConstView constView = std::as_const(columns).view();
+  for (std::size_t i = 0; i < columns.size(); ++i) {
+    BOOST_TEST(view.source[i] == sentinel.source + i);
+    BOOST_TEST(view.target[i] == sentinel.target);
+    BOOST_TEST(view.link[i] == sentinel.link + i);
+    BOOST_TEST(std::bit_cast<std::uint32_t>(view.lambda[i]) == std::bit_cast<std::uint32_t>(sentinel.lambda));
+    BOOST_TEST(std::bit_cast<std::uint32_t>(view.phi[i]) == std::bit_cast<std::uint32_t>(sentinel.phi));
+
+    BOOST_TEST(constView.source[i] == view.source[i]);
+    BOOST_TEST(constView.target[i] == view.target[i]);
+    BOOST_TEST(constView.link[i] == view.link[i]);
+    BOOST_TEST(std::bit_cast<std::uint32_t>(constView.lambda[i]) == std::bit_cast<std::uint32_t>(view.lambda[i]));
+    BOOST_TEST(std::bit_cast<std::uint32_t>(constView.phi[i]) == std::bit_cast<std::uint32_t>(view.phi[i]));
+
+    const Tracklet back = columns.read(i);
+    BOOST_TEST(back.source == view.source[i]);
+    BOOST_TEST(back.link == view.link[i]);
+    BOOST_TEST(std::bit_cast<std::uint32_t>(back.phi) == std::bit_cast<std::uint32_t>(sentinel.phi));
+  }
+}
+
+BOOST_AUTO_TEST_CASE(TheSerialReferenceDefinesTheCanonicalOutput)
+{
+  Output output;
+  output.setMemoryPool(pool());
+  output.prepare(5U);
+  const auto counts = [](Index element) { return std::array<Index, 5>{1, 2, 0, 2, 0}[element]; };
+  BOOST_REQUIRE((runSerial(output, generator(counts)) == StageStatus::kComplete));
+
+  const std::array<Index, 6> offsets{0, 1, 3, 3, 5, 5};
+  BOOST_TEST(std::ranges::equal(output.offsets(), offsets));
+  BOOST_TEST(output.size() == 5U);
+  const std::array<std::uint32_t, 5> targets{0, 1000, 1001, 3000, 3001};
+  const auto view = std::as_const(output).view();
+  for (std::size_t i = 0; i < targets.size(); ++i) {
+    BOOST_TEST(view[i].target == targets[i]);
+  }
+  BOOST_TEST(std::bit_cast<std::uint32_t>(static_cast<Scalar>(view[2].lambda)) == std::bit_cast<std::uint32_t>(1.125F));
+}
+
+BOOST_AUTO_TEST_CASE(TheCpuBackendMatchesTheSerialReference)
+{
+  constexpr Index kElements = 97;
+  for (const bool uneven : {true, false}) {
+    Output serial;
+    serial.setMemoryPool(pool());
+    serial.prepare(kElements);
+    const StageStatus serialStatus = uneven ? runSerial(serial, generator(kUneven)) : runSerial(serial, generator(kIrregular));
+    BOOST_REQUIRE((serialStatus == StageStatus::kComplete));
+
+    for (const int threads : {1, 2, 4}) {
+      for (const Index chunk : {1U, 3U, 8U, 64U, 1000U}) {
+        Output parallel;
+        const auto parallelPool = pool();
+        parallel.setMemoryPool(parallelPool);
+        parallel.prepare(kElements);
+        detail::TaskArena cpuArena{threads};
+        Cpu cpu{cpuArena};
+        BOOST_TEST(cpu.maxConcurrency() == threads);
+        cpu.setMemoryPool(parallelPool);
+        const StageStatus status = uneven ? cpu.run(parallel, chunk, generator(kUneven)) : cpu.run(parallel, chunk, generator(kIrregular));
+        BOOST_REQUIRE_MESSAGE(status == StageStatus::kComplete, "threads " << threads << ", chunk " << chunk << ", uneven " << uneven);
+        BOOST_TEST(sameStageOutput(parallel, serial), "threads " << threads << ", chunk " << chunk << ", uneven " << uneven);
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(AStagingOverflowGivesTheExactRetrySize)
+{
+  constexpr Index kElements = 60;
+  const auto generate = generator(kUneven);
+
+  Output generous;
+  generous.setMemoryPool(pool());
+  generous.prepare(kElements);
+  BOOST_REQUIRE((runSerial(generous, generate) == StageStatus::kComplete));
+
+  Output tight;
+  tight.setMemoryPool(pool());
+  tight.prepare(kElements);
+  SerialStage<TrackletT> one{1U};
+  BOOST_TEST((one.run(tight, generate) == StageStatus::kStagingOverflow));
+  BOOST_TEST(one.stagedCount() == generous.size());
+
+  const std::size_t exactCapacity = one.stagedCount();
+  BOOST_REQUIRE((SerialStage<TrackletT>{exactCapacity}.run(tight, generate) == StageStatus::kComplete));
+  BOOST_TEST(sameStageOutput(tight, generous));
+}
+
+BOOST_AUTO_TEST_CASE(TheCpuStagingPredictionAvoidsGrowthAndAMissStaysExact)
+{
+  constexpr Index kElements = 60U;
+  constexpr std::size_t kRecords = 240U;
+
+  Output predicted;
+  const auto predictedPool = pool();
+  predicted.setMemoryPool(predictedPool);
+  predicted.prepare(kElements);
+  detail::TaskArena preparedArena{1};
+  Cpu prepared{preparedArena};
+  prepared.setMemoryPool(predictedPool);
+  prepared.prepareStagingPerThread(kRecords);
+  BOOST_REQUIRE((prepared.run(predicted, 8U, generator(kUneven)) == StageStatus::kComplete));
+  BOOST_TEST(!prepared.grewSinceReset());
+  BOOST_TEST(prepared.stagingCapacity() == kRecords);
+
+  Output missed;
+  const auto missedPool = pool();
+  missed.setMemoryPool(missedPool);
+  missed.prepare(kElements);
+  detail::TaskArena smallArena{1};
+  Cpu small{smallArena};
+  small.setMemoryPool(missedPool);
+  small.prepareStagingPerThread(1U);
+  BOOST_REQUIRE((small.run(missed, 8U, generator(kUneven)) == StageStatus::kComplete));
+  BOOST_TEST(small.grewSinceReset());
+  BOOST_TEST(sameStageOutput(missed, predicted));
+}
+
+BOOST_AUTO_TEST_CASE(ResetKeepsTheStorageAndReleaseReturnsIt)
+{
+  const auto memory = pool();
+  Output output;
+  output.setMemoryPool(memory);
+  output.prepare(50U);
+  BOOST_REQUIRE((runSerial(output, generator(kIrregular)) == StageStatus::kComplete));
+  const auto used = memory->getUsedMemory();
+  BOOST_TEST(used > 0U);
+
+  resetOutput(output);
+  BOOST_TEST(memory->getUsedMemory() == used);
+  BOOST_TEST(output.size() == 0U);
+  BOOST_TEST(std::ranges::all_of(output.counts(), [](Index count) { return count == 0U; }));
+
+  output.clearStorage();
+  BOOST_TEST(memory->getUsedMemory() == 0U);
+}
+
+BOOST_AUTO_TEST_CASE(TooManyRecordsForOneElementFailAlikeOnBothPaths)
+{
+  const auto count = [](Index element) { return element == 1U ? static_cast<Index>(Output::kMaxPerElement) + 1U : 1U; };
+  const auto generate = generator(count);
+
+  Output serial;
+  serial.setMemoryPool(pool());
+  serial.prepare(3U);
+  BOOST_TEST((runSerial(serial, generate) == StageStatus::kOrdinalOverflow));
+
+  Output parallel;
+  const auto parallelPool = pool();
+  parallel.setMemoryPool(parallelPool);
+  parallel.prepare(3U);
+  detail::TaskArena cpuArena;
+  Cpu cpu{cpuArena};
+  cpu.setMemoryPool(parallelPool);
+  BOOST_TEST((cpu.run(parallel, 1U, generate) == StageStatus::kOrdinalOverflow));
+}
+
+BOOST_AUTO_TEST_CASE(AnExhaustedPoolIsReportedNotThrown)
+{
+  const auto small = std::make_shared<BoundedMemoryResource>(std::size_t{256} * 1024U);
+  Output output;
+  output.setMemoryPool(small);
+  output.prepare(1000U);
+  detail::TaskArena cpuArena;
+  Cpu cpu{cpuArena};
+  cpu.setMemoryPool(small);
+  const auto many = [](Index /*element*/) { return 50U; };
+  BOOST_TEST((cpu.run(output, 16U, generator(many)) == StageStatus::kOutOfMemory));
+}
+
+// A failed rebuild leaves the vector empty and valid: its owner reuses it, or
+// destroys it once, and the pool's accounting stays exact.
+// A column set grows all or nothing: when a later column's allocation is
+// refused, the earlier ones go back to the old size, so `size()`, which reads
+// the first, never promises rows another column lacks.
+BOOST_AUTO_TEST_CASE(AColumnSetGrowsAllOrNothing)
+{
+  // 4 + 4 + 2 + 4 + 4 bytes a row: 100 rows of the first two columns fit,
+  // the third does not.
+  BoundedMemoryResource bounded{900U};
+  {
+    BoundedColumns<TrackletT> columns;
+    columns.setMemoryResource(&bounded);
+    BOOST_CHECK_THROW(columns.resize(100U), std::bad_alloc);
+    BOOST_TEST(columns.size() == 0U);
+    columns.resize(10U);
+    BOOST_TEST(columns.size() == 10U);
+    columns.write(9U, Tracklet{.source = 1U, .target = 2U, .link = 3U, .lambda = 0.5F, .phi = 0.25F});
+    BOOST_TEST(columns.read(9U).link == 3U);
+  }
+  BOOST_TEST(bounded.getUsedMemory() == 0U);
+}
+
+// A stage's sort runs on its task arena's threads alone: one thread, the
+// caller's, not the default arena's every core, whatever the tracker's
+// thread count.
+BOOST_AUTO_TEST_CASE(AStagesSortRunsOnItsArenaAlone)
+{
+  detail::TaskArena cpuArena{1};
+  Cpu cpu{cpuArena};
+  std::vector<std::uint32_t> indices(std::size_t{1} << 20U);
+  std::iota(indices.begin(), indices.end(), 0U);
+  std::ranges::shuffle(indices, std::mt19937{44U});
+  const auto caller = std::this_thread::get_id();
+  std::atomic<bool> elsewhere{false};
+  cpu.sortIndices(indices, [&](std::uint32_t lhs, std::uint32_t rhs) {
+    if (std::this_thread::get_id() != caller) {
+      elsewhere.store(true, std::memory_order_relaxed);
+    }
+    return lhs < rhs;
+  });
+  BOOST_TEST(!elsewhere.load());
+  BOOST_TEST(std::ranges::is_sorted(indices));
+
+  // More threads give the same order.
+  detail::TaskArena wideArena{4};
+  Cpu wide{wideArena};
+  std::ranges::shuffle(indices, std::mt19937{45U});
+  wide.sortIndices(indices, [](std::uint32_t lhs, std::uint32_t rhs) { return lhs < rhs; });
+  BOOST_TEST(std::ranges::is_sorted(indices));
+}
+
+BOOST_AUTO_TEST_CASE(AnEmptyStageIsAValidEmptyOutput)
+{
+  Output output;
+  const auto outputPool = pool();
+  output.setMemoryPool(outputPool);
+  output.prepare(0U);
+  bool visited = false;
+  const auto visit = [&visited](Index, auto&) { visited = true; };
+  BOOST_TEST((runSerial(output, visit) == StageStatus::kComplete));
+
+  detail::TaskArena cpuArena;
+  Cpu cpu{cpuArena};
+  cpu.setMemoryPool(outputPool);
+  BOOST_TEST((cpu.run(output, 8U, visit) == StageStatus::kComplete));
+  BOOST_TEST(!visited);
+  BOOST_TEST(output.size() == 0U);
+  BOOST_TEST(output.offsets().size() == 1U);
+  BOOST_TEST(output.offsets().front() == 0U);
+}
+
+} // namespace o2::gtrk
+
+namespace o2::gtrk
+{
+BOOST_AUTO_TEST_CASE(LayeredGenerationHonoursDependenciesAndCanonicalPlacement)
+{
+  constexpr Index kElements = 1127U;
+  for (const auto threads : {1, 8}) {
+    for (const auto chunk : {1U, 7U, 256U, 1000U}) {
+      detail::TaskArena cpuArena{threads};
+      Cpu cpu{cpuArena};
+      cpu.setMemoryPool(pool());
+      cpu.prepareStagingPerThread(1U);
+      Output output;
+      output.setMemoryPool(pool());
+      output.prepare(kElements);
+      std::array<Index, kElements> values{};
+      const LayeredDependencyGenerator generate{.values = values};
+      BOOST_REQUIRE(cpu.run(output, chunk, generate) == StageStatus::kComplete);
+      const auto view = output.view();
+      Index placed = 0U;
+      for (Index element = 0U; element < kElements; ++element) {
+        const auto expected = [&] {
+          if (element >= 1000U) {
+            return 1U;
+          }
+          if (element >= 37U) {
+            return 2U;
+          }
+          return 3U;
+        }();
+        BOOST_TEST(values[element] == expected);
+        BOOST_TEST(output.offsets()[element] == placed);
+        if (element % 5U != 0U) {
+          for (Index ordinal = 0U; ordinal < 4U; ++ordinal) {
+            BOOST_TEST(view.source[placed] == element);
+            BOOST_TEST(view.target[placed] == expected);
+            BOOST_TEST(view.phi[placed] == static_cast<Scalar>(ordinal));
+            ++placed;
+          }
+        }
+      }
+      BOOST_TEST(output.size() == placed);
+      BOOST_TEST(output.offsets().back() == placed);
+    }
+  }
+}
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testTimeFrame.cxx b/Detectors/GenericTracking/tracking/test/testTimeFrame.cxx
new file mode 100644
index 0000000000000..4058dcc7c2c39
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testTimeFrame.cxx
@@ -0,0 +1,161 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTimeFrame.cxx
+/// \brief Block-aligned slices over borrowed, grid-ordered measurements.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK TimeFrame
+#include <boost/test/unit_test.hpp>
+
+#include "ToyBarrel3.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+
+#include "GridTestSupport.h"
+
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using Frame = TimeFrame<detectors::ToyBarrel3>;
+using ToyGridGeometry = GridGeometry<detectors::ToyBarrel3>;
+
+ToyGridGeometry gridGeometry()
+{
+  GridParams params;
+  params.blockWidth = 10'000;
+  return test::cappedGrid<detectors::ToyBarrel3>(30., test::withToyFrames(params), SearchWindowParams{}, VertexConstraint{}, 1, 1);
+}
+
+/// Rows with only their box starts [ns, in ps] and identities set, as a frame
+/// would read them.
+template <std::size_t N>
+MeasurementStore timeColumns(const std::array<double, N>& times)
+{
+  MeasurementStore columns;
+  resizeMeasurementColumns(columns, N);
+  for (std::size_t row = 0; row < N; ++row) {
+    columns.timePS[row] = static_cast<std::uint32_t>(std::llround(times[row] * 1000.));
+    columns.clusterIndex[row] = static_cast<std::uint32_t>(row);
+  }
+  return columns;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(HalfOpenCoresAndWideHalos)
+{
+  const std::array<double, 6> times{0., 10., 5., 10., 10., 20.};
+  const auto columns = timeColumns(times);
+  const auto geometry = gridGeometry();
+  const std::array<Frame::Index, 10> offsets{0, 1, 2, 2, 3, 4, 4, 4, 5, 6};
+  const Frame frame{measurementView(columns), geometry, offsets};
+
+  BOOST_TEST(frame.size() == 6U);
+  BOOST_TEST(frame.grid().layerRows(1).size() == 2U);
+  BOOST_TEST(frame.grid().layerRows(1).begin == 2U);
+  BOOST_TEST(&frame.measurement(3).timePS == &columns.timePS[3]);
+
+  const Frame::TimeSlice slice{frame, {.begin = 1, .end = 2}, 5'000};
+  BOOST_TEST(slice.coreBlocks.begin == 1);
+  BOOST_TEST(slice.coreBlocks.end == 2);
+  BOOST_TEST(slice.haloBlocks.begin == 0);
+  BOOST_TEST(slice.haloBlocks.end == 3);
+  BOOST_TEST(slice.core[0].begin == 1U);
+  BOOST_TEST(slice.core[0].end == 2U);
+  BOOST_TEST(slice.core[1].begin == 3U);
+  BOOST_TEST(slice.core[1].end == 4U);
+  BOOST_TEST(slice.core[2].begin == 4U);
+  BOOST_TEST(slice.core[2].end == 5U);
+  BOOST_TEST(slice.halo[1].begin == 2U);
+  BOOST_TEST(slice.halo[1].end == 4U);
+  BOOST_TEST(slice.halo[2].end == 6U);
+
+  std::array<unsigned, 6> coreVisits{};
+  for (std::int32_t block = 0; block < geometry.blockCount(); ++block) {
+    const Frame::TimeSlice part{frame, {.begin = block, .end = block + 1}, 0};
+    for (const auto range : part.core) {
+      for (auto index = range.begin; index < range.end; ++index) {
+        ++coreVisits[index];
+      }
+    }
+  }
+  for (const auto visits : coreVisits) {
+    BOOST_TEST(visits == 1U);
+  }
+
+  unsigned haloVisits = 0;
+  for (std::int32_t block = 0; block < geometry.blockCount(); ++block) {
+    const Frame::TimeSlice part{frame, {.begin = block, .end = block + 1}, 12'000};
+    if (part.halo[0].begin <= 1U && 1U < part.halo[0].end) {
+      ++haloVisits;
+    }
+  }
+  BOOST_TEST(haloVisits > 2U);
+}
+
+BOOST_AUTO_TEST_CASE(EmptyLayersAndEmptyTimeframe)
+{
+  const std::array<double, 3> times{0., 10., 15.};
+  const auto columns = timeColumns(times);
+  const auto geometry = gridGeometry();
+  const std::array<Frame::Index, 10> offsets{0, 1, 2, 2, 2, 2, 2, 2, 3, 3};
+  const Frame frame{measurementView(columns), geometry, offsets};
+  BOOST_TEST(frame.grid().layerRows(1).empty());
+
+  const Frame::TimeSlice slice{frame, {.begin = 1, .end = 2}, 10'000};
+  BOOST_TEST(slice.core[1].begin == 2U);
+  BOOST_TEST(slice.core[1].end == 2U);
+  BOOST_TEST(slice.halo[1].begin == 2U);
+  BOOST_TEST(slice.halo[1].end == 2U);
+
+  const MeasurementView emptyView{MeasurementT<memlayout::const_pointer>{}};
+  const std::array<Frame::Index, 10> emptyOffsets{};
+  const Frame empty{emptyView, geometry, emptyOffsets};
+  BOOST_TEST(empty.size() == 0U);
+  const Frame::TimeSlice emptySlice{empty, {.begin = 0, .end = 1}, 20'000};
+  for (const auto range : emptySlice.core) {
+    BOOST_TEST(range.empty());
+  }
+  for (const auto range : emptySlice.halo) {
+    BOOST_TEST(range.empty());
+  }
+}
+
+/// A frame given its row count is the frame that reads it from the last
+/// offset: what a frame over device columns relies on.
+BOOST_AUTO_TEST_CASE(TheRowCountCanBeGivenInsteadOfRead)
+{
+  const std::array<double, 6> times{0., 10., 5., 10., 10., 20.};
+  const auto columns = timeColumns(times);
+  const auto geometry = gridGeometry();
+  const std::array<Frame::Index, 10> offsets{0, 1, 2, 2, 3, 4, 4, 4, 5, 6};
+  const Frame read{measurementView(columns), geometry, offsets};
+  const Frame given{measurementView(columns), geometry, offsets, 6U};
+  BOOST_TEST(given.size() == read.size());
+  BOOST_TEST(given.grid().offsets().data() == offsets.data());
+  BOOST_TEST(given.grid().offsets().size() == offsets.size());
+  for (std::size_t layer = 0; layer < Frame::kLayerCount; ++layer) {
+    const auto id = static_cast<LayerID>(layer);
+    BOOST_TEST(given.grid().layerRows(id).begin == read.grid().layerRows(id).begin);
+    BOOST_TEST(given.grid().layerRows(id).end == read.grid().layerRows(id).end);
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testTimeFrameScratch.cxx b/Detectors/GenericTracking/tracking/test/testTimeFrameScratch.cxx
new file mode 100644
index 0000000000000..5be321bf14dd9
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testTimeFrameScratch.cxx
@@ -0,0 +1,90 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTimeFrameScratch.cxx
+/// \brief The slice's source rows, numbered, and the scratch that holds them.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK TimeFrameScratch
+#include <boost/test/unit_test.hpp>
+
+#include "ToyBarrel3.h"
+#include "GenericTracking/Tracking/LayerRowMap.h"
+#include "GenericTracking/Tracking/TimeFrameScratch.h"
+
+#include <array>
+#include <memory>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using Det = detectors::ToyBarrel3;
+using Scratch = TimeFrameScratch<Det>;
+using Map = LayerRowMap<Det>;
+
+constexpr std::array<MeasurementRange, Map::kLayerCount> kRows{{{.begin = 10, .end = 13}, {.begin = 20, .end = 22}, {.begin = 30, .end = 34}}};
+constexpr std::array<MeasurementRange, Map::kLayerCount> kHalo{{{.begin = 8, .end = 15}, {.begin = 18, .end = 24}, {.begin = 28, .end = 36}}};
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(PresentedRowsHaveOneDenseOrder)
+{
+  const Map map{kRows, {true, true, true}};
+  BOOST_TEST(map.size() == 9U);
+  BOOST_TEST(map.offsets[1] == 3U);
+  BOOST_TEST(map.offsets[2] == 5U);
+  BOOST_TEST(map.element(0, 12U) == 2U);
+  BOOST_TEST(map.element(1, 20U) == 3U);
+  BOOST_TEST(map.element(2, 33U) == 8U);
+  for (Map::Index element = 0; element < map.size(); ++element) {
+    const auto at = map.row(element);
+    BOOST_TEST(map.element(at.layer, at.row) == element);
+  }
+  BOOST_TEST(!map.contains(0, 13U));
+  BOOST_TEST(!map.contains(3, 10U));
+}
+
+BOOST_AUTO_TEST_CASE(AnEmptyOrUnpresentedLayerIsSkipped)
+{
+  // The middle layer contributes nothing, so its offset repeats.
+  const Map map{kRows, {true, false, true}};
+  BOOST_TEST(map.size() == 7U);
+  BOOST_TEST(!map.contains(1, 20U));
+  BOOST_TEST(map.row(2U).layer == 0U);
+  BOOST_TEST(map.row(3U).layer == 2U);
+  BOOST_TEST(map.row(3U).row == 30U);
+  BOOST_TEST(map.row(6U).row == 33U);
+}
+
+BOOST_AUTO_TEST_CASE(TrackletSourcesAreTheLayersWithAnOutgoingLink)
+{
+  // ToyBarrel3 links 0 -> 1 -> 2; the outermost layer starts nothing.
+  BOOST_TEST(Scratch::kSourceLayers[0]);
+  BOOST_TEST(Scratch::kSourceLayers[1]);
+  BOOST_TEST(!Scratch::kSourceLayers[2]);
+
+  // Every source layer contributes its halo rows; the tracklet stage's gate
+  // decides which it works.
+  Scratch scratch;
+  scratch.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  scratch.beginSlice(Scratch::makeSources(kHalo));
+  BOOST_TEST(scratch.sources().size() == 13U);
+  BOOST_TEST(scratch.tracklets().elementCount() == 13U);
+  BOOST_TEST(scratch.tracklets().offsets().size() == 14U);
+  BOOST_TEST(scratch.sources().contains(0, 9U));
+  BOOST_TEST(scratch.sources().contains(1, 18U));
+  BOOST_TEST(!scratch.sources().contains(2, 30U));
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testTrackFitter.cxx b/Detectors/GenericTracking/tracking/test/testTrackFitter.cxx
new file mode 100644
index 0000000000000..1d49207d7c256
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testTrackFitter.cxx
@@ -0,0 +1,758 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTrackFitter.cxx
+/// \brief Seeding, the whole-chain seed and bidirectional fitting.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Track Fitter
+#include <boost/test/unit_test.hpp>
+#include <numbers>
+
+#include "GridTestSupport.h"
+#include "Oracles.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "ToyBarrel4Disc8.h"
+#include "ToyBarrel3.h"
+#include "GenericTracking/Tracking/BeamConstraint.h"
+#include "GenericTracking/Tracking/Material.h"
+#include "GenericTracking/Tracking/TrackFitter.h"
+
+#include "ReconstructionDataFormats/PID.h"
+#include "ReconstructionDataFormats/Track.h"
+#include "ReconstructionDataFormats/TrackUtils.h"
+#include "UniformMaterial.h"
+
+#include <array>
+#include <cmath>
+#include <limits>
+#include <random>
+#include <vector>
+
+namespace o2::gtrk
+{
+namespace
+{
+
+struct PullMoments {
+  double mean = 0.;
+  double width = 0.;
+};
+
+PullMoments moments(std::span<const double> values)
+{
+  const auto n = static_cast<double>(values.size());
+  double mean = 0.;
+  for (const double value : values) {
+    mean += value / n;
+  }
+  double variance = 0.;
+  for (const double value : values) {
+    variance += (value - mean) * (value - mean);
+  }
+  return {.mean = mean, .width = std::sqrt(variance / (n - 1.))};
+}
+
+using Toy = detectors::ToyBarrel3;
+
+void collectPulls(int trial, const BoundTrackState& state, const BoundTrackState& truth, std::array<std::vector<double>, kNBoundParams>& pull)
+{
+  for (int i = 0; i < kNBoundParams; ++i) {
+    double diff = static_cast<double>(state.par[i]) - static_cast<double>(truth.par[i]);
+    if (i == kPhi) {
+      math_utils::detail::bringToPMPi<double>(diff);
+    }
+    const auto variance = static_cast<double>(state.variance(i));
+    BOOST_TEST_CONTEXT("trial " << trial << " parameter " << i << " variance " << variance) { BOOST_REQUIRE(variance > 0.); }
+    pull[static_cast<std::size_t>(i)].push_back(diff / std::sqrt(variance));
+  }
+}
+
+Measurement measurementFromState(const BoundTrackState& state, std::uint32_t index)
+{
+  return Measurement{
+    .loc0 = state.loc0(),
+    .loc1 = state.loc1(),
+    .timePS = test::toyTimeBox(test::kToyTrackTimeNS).start,
+    .widthPS = test::toyTimeBox(test::kToyTrackTimeNS).width,
+    .varLoc0 = 2.5e-6F,
+    .covLoc01 = 0.F,
+    .varLoc1 = 2.5e-6F,
+    .clusterIndex = index,
+    .surface = state.surface,
+  };
+}
+
+struct SyntheticChain {
+  Geometry<Toy> geometry = toyGeometry<Toy>();
+  TrackingGeometry<Toy> tracking{geometry};
+  Propagator propagator;
+  std::array<BoundTrackState, 3> truth;
+  std::array<Measurement, 3> measurements;
+
+  SyntheticChain()
+  {
+    truth[0].par[kLoc0] = 0.F;
+    truth[0].par[kLoc1] = -0.2F;
+    truth[0].par[kPhi] = 0.F;
+    truth[0].par[kTheta] = 1.5F;
+    truth[0].par[kQOverP] = 0.5F;
+    truth[0].surface = firstSensorOfLayer<Toy>(0);
+
+    for (std::size_t layer = 1; layer < truth.size(); ++layer) {
+      truth[layer] = truth[layer - 1];
+      const auto& from = tracking.surface(truth[layer - 1].surface);
+      const auto toID = firstSensorOfLayer<Toy>(static_cast<LayerID>(layer));
+      const auto& to = tracking.surface(toID);
+      const auto result = propagate(propagator, truth[layer], from, to, PropagationDirection::kForward);
+      BOOST_REQUIRE(result.status == PropagationStatus::kOk);
+    }
+    for (std::size_t i = 0; i < measurements.size(); ++i) {
+      measurements[i] = measurementFromState(truth[i], static_cast<std::uint32_t>(100 + i));
+    }
+  }
+};
+
+double transverseRadius2At(const Propagator& prop, const BoundTrackState& state, const TrackingSurface& surface, double path)
+{
+  Scalar global[3]{};
+  surfaceToGlobal(surface, state.loc0(), state.loc1(), global);
+  const double sinTheta = std::sin(static_cast<double>(state.theta()));
+  const double transverse = path * sinTheta;
+  const double curvature = prop.curvature(static_cast<double>(state.qOverP()), sinTheta);
+  const double turn = curvature * transverse;
+  const auto phi = static_cast<double>(state.phi());
+  const double dx = transverse * (std::cos(phi) * sinc(turn) - std::sin(phi) * versine(turn));
+  const double dy = transverse * (std::sin(phi) * sinc(turn) + std::cos(phi) * versine(turn));
+  const double x = static_cast<double>(global[0]) + dx;
+  const double y = static_cast<double>(global[1]) + dy;
+  return x * x + y * y;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(ThreePointSeedRecoversTheGeneratingHelix)
+{
+  const SyntheticChain chain;
+  const auto seed = makeThreePointSeed<Scalar>(chain.propagator, chain.measurements[0], chain.measurements[1], chain.measurements[2], chain.tracking.surface(chain.measurements[0].surface), chain.tracking.surface(chain.measurements[1].surface), chain.tracking.surface(chain.measurements[2].surface));
+  const auto exact = makeThreePointSeed<ExactScalar>(chain.propagator, chain.measurements[0], chain.measurements[1], chain.measurements[2], chain.tracking.surface(chain.measurements[0].surface), chain.tracking.surface(chain.measurements[1].surface), chain.tracking.surface(chain.measurements[2].surface));
+
+  BOOST_TEST(std::abs(seed.loc0() - chain.truth[0].loc0()) < 1e-6F);
+  BOOST_TEST(std::abs(seed.loc1() - chain.truth[0].loc1()) < 1e-6F);
+  BOOST_TEST(std::abs(seed.phi() - chain.truth[0].phi()) < 1e-5F);
+  BOOST_TEST(std::abs(seed.theta() - chain.truth[0].theta()) < 1e-5F);
+  BOOST_TEST(std::abs(seed.qOverP() - chain.truth[0].qOverP()) < 1e-3F);
+  BOOST_TEST(seed.surface == chain.truth[0].surface);
+
+  BOOST_TEST(std::abs(seed.loc0() - exact.loc0()) < 1e-6F);
+  BOOST_TEST(std::abs(seed.loc1() - exact.loc1()) < 1e-6F);
+  BOOST_TEST(std::abs(seed.phi() - exact.phi()) < 2e-6F);
+  BOOST_TEST(std::abs(seed.theta() - exact.theta()) < 2e-6F);
+  BOOST_TEST(std::abs(seed.qOverP() - exact.qOverP()) < 2e-4F);
+}
+
+/// At fixed non-zero chord the asin argument saturates as |curvature| tends
+/// to infinity. Both arithmetic types must reach the finite half-turn limit;
+/// this also checks that the clamp handles infinity before asin sees it.
+BOOST_AUTO_TEST_CASE(TransverseArcHasFiniteInfiniteCurvatureLimit)
+{
+  constexpr Scalar kChord = 3.F;
+  const auto scalar = detail::transverseArc<Scalar>(std::numeric_limits<Scalar>::infinity(), kChord, 0.F);
+  const auto exact = detail::transverseArc<ExactScalar>(std::numeric_limits<ExactScalar>::infinity(), static_cast<ExactScalar>(kChord), 0.);
+  const auto negative = detail::transverseArc<Scalar>(-std::numeric_limits<Scalar>::infinity(), kChord, 0.F);
+  const auto expected = 0.5 * std::acos(-1.) * static_cast<double>(kChord);
+
+  BOOST_TEST(std::isfinite(scalar));
+  BOOST_TEST(std::isfinite(exact));
+  BOOST_TEST(std::isfinite(negative));
+  BOOST_TEST(std::abs(static_cast<double>(scalar) - expected) < 1e-6);
+  BOOST_TEST(std::abs(exact - expected) < 1e-12);
+  BOOST_TEST(std::abs(static_cast<double>(negative) - expected) < 1e-6);
+  BOOST_TEST(std::abs(static_cast<double>(scalar) - exact) < 1e-6);
+}
+
+/// Shrinking a similar three-point configuration sends its curvature to
+/// infinity. The calculation must stay finite at every finite scale, and the
+/// Scalar result must follow the ExactScalar oracle rather than losing the
+/// triangle area or overflowing an intermediate chord product.
+BOOST_AUTO_TEST_CASE(ThreePointSeedRemainsFiniteAsCurvatureDiverges)
+{
+  const Propagator prop;
+  Scalar previousMagnitude = 0.F;
+  for (const Scalar scale : {1e-2F, 1e-5F, 1e-8F}) {
+    const TrackingSurface firstSurface;
+    TrackingSurface secondSurface;
+    TrackingSurface thirdSurface;
+    secondSurface.origin[0] = scale;
+    thirdSurface.origin[0] = scale;
+    thirdSurface.origin[1] = scale;
+
+    Measurement first;
+    const Measurement second;
+    const Measurement third;
+    first.widthPS = 1'000U;
+
+    const auto scalar = makeThreePointSeed<Scalar>(prop, first, second, third, firstSurface, secondSurface, thirdSurface);
+    const auto exact = makeThreePointSeed<ExactScalar>(prop, first, second, third, firstSurface, secondSurface, thirdSurface);
+    const Scalar magnitude = std::abs(scalar.qOverP());
+    BOOST_TEST_CONTEXT("scale " << scale)
+    {
+      BOOST_TEST(std::isfinite(scalar.qOverP()));
+      BOOST_TEST(std::isfinite(exact.qOverP()));
+      BOOST_TEST(magnitude > previousMagnitude);
+      BOOST_TEST(std::abs((scalar.qOverP() - exact.qOverP()) / exact.qOverP()) < 2e-5F);
+    }
+    previousMagnitude = magnitude;
+  }
+}
+
+BOOST_AUTO_TEST_CASE(IndependentPassesFitTheSameNoiselessChain)
+{
+  const SyntheticChain chain;
+  const UniformMaterial material;
+  const auto fit = fitMeasurements(chain.propagator, chain.tracking, material, chain.measurements.data(), static_cast<int>(chain.measurements.size()));
+
+  BOOST_TEST(static_cast<int>(fit.status) == static_cast<int>(PropagationStatus::kOk));
+  BOOST_TEST(fit.ndf == 1);
+  BOOST_TEST(fit.outwardState.surface == chain.truth[2].surface);
+  BOOST_TEST(fit.state.surface == chain.truth[0].surface);
+  BOOST_TEST(std::abs(fit.state.phi() - chain.truth[0].phi()) < 1e-5F);
+  BOOST_TEST(std::abs(fit.state.theta() - chain.truth[0].theta()) < 1e-5F);
+  BOOST_TEST(std::abs(fit.state.qOverP() - chain.truth[0].qOverP()) < 1e-3F);
+  BOOST_TEST(std::abs(fit.chi2) < 1e-4F);
+  BOOST_TEST(std::abs(fit.outwardChi2) < 1e-4F);
+}
+
+/// A primary from a vertex in the diamond's tail crosses the far end of barrel
+/// layer 0 at |eta| ~ 3.7, then the forward discs. Its
+/// layer-0 incidence, |n . d| ~ 0.048, is an ordinary track's, and both passes
+/// fit it. A threshold of 0.05 would pass the outward pass, which starts on
+/// layer 0 and so never checks it, and fail the inward pass, arriving there
+/// last.
+BOOST_AUTO_TEST_CASE(LayerZeroAtShallowIncidenceFitsBothWays)
+{
+  using Mixed = detectors::ToyBarrel4Disc8;
+  const auto detector = toyGeometry<Mixed>();
+  const TrackingGeometry<Mixed> tracking{detector};
+  const Propagator propagator;
+  const UniformMaterial material;
+
+  SensorID start = firstSensorOfLayer<Mixed>(0);
+  for (SensorID sensor = start; sensor < firstSensorOfLayer<Mixed>(1); ++sensor) {
+    if (tracking.surface(sensor).origin[2] > tracking.surface(start).origin[2]) {
+      start = sensor;
+    }
+  }
+  const auto& first = tracking.surface(start);
+  std::array<BoundTrackState, 5> truth;
+  truth[0].par[kPhi] = std::atan2(first.origin[1], first.origin[0]);
+  truth[0].par[kTheta] = 0.048F;
+  truth[0].par[kQOverP] = 0.05F;
+  truth[0].surface = start;
+  const double cosIncidence = std::sin(0.048) * (std::cos(static_cast<double>(truth[0].phi())) * static_cast<double>(first.normal[0]) + std::sin(static_cast<double>(truth[0].phi())) * static_cast<double>(first.normal[1]));
+  BOOST_TEST_REQUIRE(std::abs(cosIncidence) < 0.05);
+  BOOST_TEST_REQUIRE(std::abs(cosIncidence) > static_cast<double>(propagator.minAbsCosIncidence));
+
+  constexpr std::array<LayerID, 4> kDiscs{8, 9, 10, 11};
+  for (std::size_t i = 0; i < kDiscs.size(); ++i) {
+    const auto& from = tracking.surface(truth[i].surface);
+    for (SensorID sensor = firstSensorOfLayer<Mixed>(kDiscs[i]); sensor < firstSensorOfLayer<Mixed>(static_cast<LayerID>(kDiscs[i] + 1U)); ++sensor) {
+      BoundTrackState probe = truth[i];
+      if (propagate(propagator, probe, from, tracking.surface(sensor), PropagationDirection::kForward).status == PropagationStatus::kOk) {
+        truth[i + 1U] = probe;
+        break;
+      }
+    }
+    BOOST_TEST_REQUIRE(truth[i + 1U].surface != truth[i].surface);
+  }
+  std::array<Measurement, 5> measurements;
+  for (std::size_t i = 0; i < measurements.size(); ++i) {
+    measurements[i] = measurementFromState(truth[i], static_cast<std::uint32_t>(i));
+  }
+
+  const auto fit = fitMeasurements(propagator, tracking, material, measurements.data(), static_cast<int>(measurements.size()));
+  BOOST_TEST(static_cast<int>(fit.status) == static_cast<int>(PropagationStatus::kOk));
+  BOOST_TEST(fit.state.surface == start);
+  BOOST_TEST(std::abs(fit.state.theta() - truth[0].theta()) < 1e-5F);
+
+  const Propagator former{.minAbsCosIncidence = 0.05F};
+  const auto failed = fitMeasurements(former, tracking, material, measurements.data(), static_cast<int>(measurements.size()));
+  BOOST_TEST(static_cast<int>(failed.status) == static_cast<int>(PropagationStatus::kGrazing));
+  BOOST_TEST(static_cast<int>(failed.failedPass) == static_cast<int>(FitPass::kInward));
+  BOOST_TEST(failed.failedMeasurement == 0);
+}
+
+BOOST_AUTO_TEST_CASE(SmearedChainsGiveUnbiasedParametersAndUnitPulls)
+{
+  // A fit can be self-consistent and still wrong in
+  // exactly one way that matters here: if the inward pass inherited the
+  // outward pass's covariance it would consume every measurement twice, the
+  // estimate would be too confident by root two, and the pull widths would
+  // come out near 0.707 while every other test in this file still passed.
+  // That number is asserted against explicitly.
+  const SyntheticChain chain;
+  const UniformMaterial material;
+
+  constexpr int kTrials = 3000;
+  const Scalar sigmaLoc = 1.5811388e-3F; // sqrt(2.5e-6) cm
+
+  std::mt19937 rng(20260919);
+  std::normal_distribution<double> gauss(0., 1.);
+
+  std::array<std::vector<double>, kNBoundParams> pull;
+
+  for (int trial = 0; trial < kTrials; ++trial) {
+    auto smeared = chain.measurements;
+    for (auto& m : smeared) {
+      m.loc0 += static_cast<Scalar>(gauss(rng) * static_cast<double>(sigmaLoc));
+      m.loc1 += static_cast<Scalar>(gauss(rng) * static_cast<double>(sigmaLoc));
+    }
+
+    const auto fit = fitMeasurements(chain.propagator, chain.tracking, material, smeared.data(), static_cast<int>(smeared.size()));
+    BOOST_REQUIRE(fit.status == PropagationStatus::kOk);
+
+    collectPulls(trial, fit.state, chain.truth[0], pull);
+  }
+
+  const char* names[kNBoundParams] = {"loc0", "loc1", "phi", "theta", "qOverP"};
+  for (int i = 0; i < kNBoundParams; ++i) {
+    const auto& p = pull[static_cast<std::size_t>(i)];
+    const auto n = static_cast<double>(p.size());
+
+    const auto [meanPull, width] = moments(p);
+
+    BOOST_TEST_CONTEXT("parameter " << names[i] << " pull mean " << meanPull << " width " << width)
+    {
+      // The mean of kTrials unit-width pulls has standard error 1/sqrt(N),
+      // which is 0.018 here; four of those is a comfortable band that still
+      // catches any real bias.
+      BOOST_TEST(std::abs(meanPull) < 4. / std::sqrt(n));
+      // The width itself is known to 1/sqrt(2N) = 1.3 %, so 10 % is generous
+      // -- and 0.707 is 29 % low, far outside it.
+      BOOST_TEST(std::abs(width - 1.) < 0.10);
+    }
+  }
+}
+
+/// A chain over the first \a N barrel layers of ToyBarrel4Disc8: tilted,
+/// overlapping sensors and 2N spatial constraints against five parameters, so
+/// the fit has genuine redundancy. ToyBarrel3 cannot show this -- three points
+/// determine a helix exactly, and the accumulated chi2 is zero however badly a
+/// point is moved. With N = 4 the chain runs from 3 to 16 cm.
+template <std::size_t N>
+struct BarrelChain {
+  using Mixed = detectors::ToyBarrel4Disc8;
+  Geometry<Mixed> geometry = toyGeometry<Mixed>();
+  TrackingGeometry<Mixed> tracking{geometry};
+  Propagator propagator;
+  std::array<BoundTrackState, N> truth;
+  std::array<Measurement, N> measurements;
+  bool built = false;
+
+  /// The sensor of \a layer that this track actually crosses. A barrel layer
+  /// overlaps in azimuth by about a fifth, so "the sensor at this phi" is not
+  /// a well-defined question -- the first one whose bounds contain the
+  /// intersection will do.
+  [[nodiscard]] SensorID crossedSensor(const BoundTrackState& state, const TrackingSurface& from, LayerID layer) const
+  {
+    const SensorID begin = firstSensorOfLayer<Mixed>(layer);
+    const SensorID end = firstSensorOfLayer<Mixed>(static_cast<LayerID>(layer + 1));
+    for (SensorID id = begin; id < end; ++id) {
+      BoundTrackState probe = state;
+      const auto result = propagate(propagator, probe, from, tracking.surface(id), PropagationDirection::kForward);
+      if (result.status == PropagationStatus::kOk) {
+        return id;
+      }
+    }
+    return kInvalidSensorID;
+  }
+
+  explicit BarrelChain(Scalar qOverP = 0.5F) { generate(qOverP); }
+
+  /// (Re)build the chain. With \a x2X0PerCm the track scatters as the fit
+  /// models it (`StepMaterial`): each step's material in two thin scatterers,
+  /// the half behind the sensor just left kicked on leaving it, the half in
+  /// front of the sensor reached kicked on arrival, both with the Highland
+  /// theta0 of half the step's chord. truth[k] is the state at the mid-plane
+  /// of sensor k: after the kick in front of it, before the one behind it,
+  /// which is what both passes estimate there. With \a rho [g/cm^3] the
+  /// track loses the fit's mean energy over each step's chord on reaching the
+  /// next sensor, without straggling.
+  void generate(Scalar qOverP, Scalar x2X0PerCm = 0.F, std::mt19937* rng = nullptr, Scalar rho = 0.F)
+  {
+    built = false;
+    truth[0] = BoundTrackState{};
+    truth[0].par[kPhi] = 0.12F; // along the stave tilt, so the track leaves the sensor
+    truth[0].par[kTheta] = 1.4F;
+    truth[0].par[kQOverP] = qOverP;
+    truth[0].surface = firstSensorOfLayer<Mixed>(0);
+
+    std::normal_distribution<double> gauss(0., 1.);
+    const auto kick = [&](BoundTrackState& state, Scalar theta0) {
+      const auto sinTheta = std::sin(state.theta());
+      state.par[kTheta] += static_cast<Scalar>(gauss(*rng)) * theta0;
+      state.par[kPhi] += static_cast<Scalar>(gauss(*rng)) * theta0 / sinTheta;
+    };
+    for (std::size_t layer = 1; layer < truth.size(); ++layer) {
+      const auto& from = tracking.surface(truth[layer - 1].surface);
+      BoundTrackState outgoing = truth[layer - 1];
+      Scalar theta0Half = 0.F;
+      if (x2X0PerCm > 0.F && rng != nullptr) {
+        const auto unkicked = crossedSensor(outgoing, from, static_cast<LayerID>(layer));
+        if (unkicked == kInvalidSensorID) {
+          return;
+        }
+        BoundTrackState probe = outgoing;
+        (void)propagate(propagator, probe, from, tracking.surface(unkicked), PropagationDirection::kForward);
+        Scalar a[3]{};
+        Scalar b[3]{};
+        surfaceToGlobal(from, outgoing.loc0(), outgoing.loc1(), a);
+        surfaceToGlobal(tracking.surface(unkicked), probe.loc0(), probe.loc1(), b);
+        const Scalar chord = std::hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+        theta0Half = highlandTheta0(0.5F * x2X0PerCm * chord, betaMomentum(1.F / std::abs(outgoing.qOverP()), propagator.massGeV));
+        kick(outgoing, theta0Half); // behind the sensor just left
+      }
+      const auto id = crossedSensor(outgoing, from, static_cast<LayerID>(layer));
+      if (id == kInvalidSensorID) {
+        return;
+      }
+      truth[layer] = outgoing;
+      const auto result = propagate(propagator, truth[layer], from, tracking.surface(id), PropagationDirection::kForward);
+      if (result.status != PropagationStatus::kOk) {
+        return;
+      }
+      if (rho > 0.F) {
+        Scalar a[3]{};
+        Scalar b[3]{};
+        surfaceToGlobal(from, truth[layer - 1].loc0(), truth[layer - 1].loc1(), a);
+        surfaceToGlobal(tracking.surface(id), truth[layer].loc0(), truth[layer].loc1(), b);
+        Scalar variance = 0.F;
+        if (!detail::applyEnergyLoss(propagator, rho * std::hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]), PropagationDirection::kForward, truth[layer], variance)) {
+          return;
+        }
+      }
+      if (theta0Half > 0.F) {
+        kick(truth[layer], theta0Half); // in front of the sensor reached: the direction at its mid-plane
+      }
+    }
+    for (std::size_t i = 0; i < measurements.size(); ++i) {
+      measurements[i] = measurementFromState(truth[i], static_cast<std::uint32_t>(200 + i));
+    }
+    built = true;
+  }
+};
+
+/// The chi2 is the positions': two per measurement against the five spatial
+/// parameters, and a measurement's time, its box, does not enter it.
+BOOST_AUTO_TEST_CASE(TheChiSquaredIsSpatialAlone)
+{
+  const BarrelChain<4> chain;
+  BOOST_REQUIRE(chain.built);
+  const UniformMaterial material;
+
+  const auto clean = fitMeasurements(chain.propagator, chain.tracking, material, chain.measurements.data(), static_cast<int>(chain.measurements.size()));
+  BOOST_REQUIRE(clean.status == PropagationStatus::kOk);
+  BOOST_TEST(clean.ndf == 3);
+  BOOST_TEST(std::abs(clean.chi2) < 1e-2F);
+
+  auto spatialOutlier = chain.measurements;
+  spatialOutlier[1].loc0 += 0.02F; // about thirteen sigma
+  const auto spatial = fitMeasurements(chain.propagator, chain.tracking, material, spatialOutlier.data(), static_cast<int>(spatialOutlier.size()));
+  BOOST_REQUIRE(spatial.status == PropagationStatus::kOk);
+  BOOST_TEST(spatial.chi2 > 10.F);
+
+  auto timeOutlier = chain.measurements;
+  timeOutlier[2].timePS += 30'000U;
+  const auto timed = fitMeasurements(chain.propagator, chain.tracking, material, timeOutlier.data(), static_cast<int>(timeOutlier.size()));
+  BOOST_REQUIRE(timed.status == PropagationStatus::kOk);
+  BOOST_TEST(timed.chi2 == clean.chi2);
+}
+
+/// The whole-chain seed recovers the helix that made the chain, over the
+/// whole barrel, at both charges and from 0.4 to 20 GeV/c.
+/// The positions it fits are float, which is what bounds the tolerances.
+BOOST_AUTO_TEST_CASE(ChainSeedRecoversTheGeneratingHelix)
+{
+  for (const Scalar qOverP : {2.5F, -2.5F, 0.5F, -0.1F, 0.05F}) {
+    const BarrelChain<4> chain(qOverP);
+    BOOST_TEST_CONTEXT("q/p " << qOverP)
+    {
+      BOOST_REQUIRE(chain.built);
+      const auto scalarResult = makeChainSeed<Scalar>(chain.propagator, chain.tracking, chain.measurements.data(), static_cast<int>(chain.measurements.size()));
+      const auto exactResult = makeChainSeed<ExactScalar>(chain.propagator, chain.tracking, chain.measurements.data(), static_cast<int>(chain.measurements.size()));
+      const auto& reference = scalarResult.state;
+      const auto& exact = exactResult.state;
+      const auto& truth = chain.truth[0];
+      BOOST_TEST(reference.surface == truth.surface);
+      BOOST_TEST(std::abs(reference.loc0() - truth.loc0()) < 1e-4F);
+      BOOST_TEST(std::abs(reference.loc1() - truth.loc1()) < 1e-4F);
+      BOOST_TEST(std::abs(reference.phi() - truth.phi()) < 1e-5F);
+      BOOST_TEST(std::abs(reference.theta() - truth.theta()) < 1e-5F);
+      BOOST_TEST(std::abs(reference.qOverP() / truth.qOverP() - 1.F) < 1e-3F);
+
+      BOOST_TEST(std::abs(reference.loc0() - exact.loc0()) < 5e-5F);
+      BOOST_TEST(std::abs(reference.loc1() - exact.loc1()) < 5e-5F);
+      BOOST_TEST(std::abs(reference.phi() - exact.phi()) < 5e-6F);
+      BOOST_TEST(std::abs(reference.theta() - exact.theta()) < 5e-6F);
+      BOOST_TEST(std::abs(reference.qOverP() - exact.qOverP()) < 5e-4F);
+      BOOST_TEST(std::abs(scalarResult.qOverPSigma - exactResult.qOverPSigma) < 1e-3F);
+    }
+  }
+}
+
+/// Karimaki's fit stays regular as the curvature vanishes; a straight track is
+/// not a special case, and must not come out as a NaN or a spurious bend.
+BOOST_AUTO_TEST_CASE(ChainSeedOfAStraightTrackHasNoCurvature)
+{
+  const BarrelChain<4> chain(0.F);
+  BOOST_REQUIRE(chain.built);
+  const auto reference = makeChainSeed<Scalar>(chain.propagator, chain.tracking, chain.measurements.data(), static_cast<int>(chain.measurements.size())).state;
+  const auto exact = makeChainSeed<ExactScalar>(chain.propagator, chain.tracking, chain.measurements.data(), static_cast<int>(chain.measurements.size())).state;
+  BOOST_TEST(std::isfinite(reference.qOverP()));
+  BOOST_TEST(std::abs(reference.qOverP()) < 1e-3F);
+  BOOST_TEST(std::abs(reference.phi() - chain.truth[0].phi()) < 1e-5F);
+  BOOST_TEST(std::abs(reference.theta() - chain.truth[0].theta()) < 1e-5F);
+  BOOST_TEST(std::abs(reference.loc0() - exact.loc0()) < 5e-5F);
+  BOOST_TEST(std::abs(reference.loc1() - exact.loc1()) < 5e-5F);
+  BOOST_TEST(std::abs(reference.phi() - exact.phi()) < 5e-6F);
+  BOOST_TEST(std::abs(reference.theta() - exact.theta()) < 5e-6F);
+  BOOST_TEST(std::abs(reference.qOverP() - exact.qOverP()) < 5e-4F);
+}
+
+/// Why the seed takes the whole chain: a 0.4 GeV/c track crosses every barrel
+/// layer; seeded from the first three clusters alone, a 16 um measurement
+/// error becomes a curvature that misses the outer sensors or linearises the
+/// fit about the wrong helix. Every chain must fit, and the pulls must be
+/// unit.
+///
+/// With material, and scattering in the truth to match it. Without material
+/// the points fix q/p to 1e-4, which no prior both non-informative and
+/// representable in a float covariance can reach: see kChainQOverPSpread. A
+/// real track crosses about 1.5e-3 X0 per cm here, what the material LUT
+/// reports for the barrel, and is scattering-limited long before that.
+///
+/// Both passes are checked: the inward state against the mid-plane of the
+/// first sensor and the outward one against the mid-plane of the last, with
+/// unit pulls, and each pass's spatial chi2 per degree of freedom at one.
+/// The outward pass is the road fit's, whose chi2 decides which roads are
+/// kept; its chi2 is one only with the process noise placed as the material
+/// is.
+BOOST_AUTO_TEST_CASE(LowMomentumChainsFitWithUnitPulls)
+{
+  constexpr Scalar kQOverP = 2.5F;
+  constexpr Scalar kX2X0PerCm = 1.5e-3F;
+  constexpr std::size_t kLayers = 4;
+  BarrelChain<kLayers> chain(kQOverP);
+  BOOST_REQUIRE(chain.built);
+  const UniformMaterial material{.x2X0PerCm = kX2X0PerCm};
+
+  constexpr int kTrials = 1000;
+  const Scalar sigmaLoc = 1.5811388e-3F; // sqrt(2.5e-6) cm
+
+  std::mt19937 rng(20260923);
+  std::normal_distribution<double> gauss(0., 1.);
+  std::array<std::vector<double>, kNBoundParams> inwardPull;
+  std::array<std::vector<double>, kNBoundParams> outwardPull;
+  double inwardChi2PerDof = 0.;
+  double outwardChi2PerDof = 0.;
+
+  for (int trial = 0; trial < kTrials; ++trial) {
+    // A kink can send the track through the 0.5 mm gap between two modules;
+    // draw again rather than fit a chain with a missing layer.
+    for (int attempt = 0; attempt < 10; ++attempt) {
+      chain.generate(kQOverP, kX2X0PerCm, &rng);
+      if (chain.built) {
+        break;
+      }
+    }
+    BOOST_REQUIRE(chain.built);
+    auto smeared = chain.measurements;
+    for (auto& m : smeared) {
+      m.loc0 += static_cast<Scalar>(gauss(rng) * static_cast<double>(sigmaLoc));
+      m.loc1 += static_cast<Scalar>(gauss(rng) * static_cast<double>(sigmaLoc));
+    }
+    const auto fit = fitMeasurements(chain.propagator, chain.tracking, material, smeared.data(), static_cast<int>(smeared.size()));
+    BOOST_TEST_CONTEXT("trial " << trial << ", propagation status " << static_cast<int>(fit.status)) { BOOST_REQUIRE(fit.status == PropagationStatus::kOk); }
+    collectPulls(trial, fit.state, chain.truth[0], inwardPull);
+    collectPulls(trial, fit.outwardState, chain.truth[kLayers - 1], outwardPull);
+    inwardChi2PerDof += static_cast<double>(fit.chi2) / fit.ndf / kTrials;
+    outwardChi2PerDof += static_cast<double>(fit.outwardChi2) / fit.ndf / kTrials;
+  }
+
+  const char* names[kNBoundParams] = {"loc0", "loc1", "phi", "theta", "qOverP"};
+  for (const auto* pass : {&inwardPull, &outwardPull}) {
+    for (int i = 0; i < kNBoundParams; ++i) {
+      const auto& p = (*pass)[static_cast<std::size_t>(i)];
+      const auto n = static_cast<double>(p.size());
+      const auto [mean, width] = moments(p);
+      BOOST_TEST_CONTEXT((pass == &inwardPull ? "inward" : "outward") << " parameter " << names[i] << " pull mean " << mean << " width " << width)
+      {
+        BOOST_TEST(std::abs(mean) < 4. / std::sqrt(n));
+        BOOST_TEST(std::abs(width - 1.) < 0.10);
+      }
+    }
+  }
+  BOOST_TEST_CONTEXT("inward chi2 per spatial dof " << inwardChi2PerDof << ", outward " << outwardChi2PerDof)
+  {
+    BOOST_TEST(std::abs(inwardChi2PerDof - 1.) < 0.15);
+    BOOST_TEST(std::abs(outwardChi2PerDof - 1.) < 0.15);
+  }
+}
+
+/// The same chains losing energy: the chain seed is a circle through the
+/// clusters without energy loss, so a pass that carried it, unfitted, to its
+/// first update would charge the seed's miss there against a 1 mm position
+/// prior. Each pass starts on its first measurement, the inward one from the
+/// outward pass's end state, and both chi2 per dof are one. The position and
+/// direction pulls are unit; q/p's is printed, not held: this truth loses
+/// energy without straggling, which the fit's q/p noise includes, and is not
+/// the fit's model of where the loss is taken.
+BOOST_AUTO_TEST_CASE(LowMomentumChainsLosingEnergyFitWithUnitPulls)
+{
+  constexpr Scalar kQOverP = 2.5F;
+  constexpr Scalar kX2X0PerCm = 1.5e-3F;
+  constexpr Scalar kRho = 0.3F; // about 2.5 % of the momentum over the chain
+  constexpr std::size_t kLayers = 4;
+  BarrelChain<kLayers> chain(kQOverP);
+  BOOST_REQUIRE(chain.built);
+  const UniformMaterial material{.x2X0PerCm = kX2X0PerCm, .rho = kRho};
+
+  constexpr int kTrials = 1000;
+  const Scalar sigmaLoc = 1.5811388e-3F;
+  std::mt19937 rng(20261021);
+  std::normal_distribution<double> gauss(0., 1.);
+  std::array<std::vector<double>, kNBoundParams> inwardPull;
+  double inwardChi2PerDof = 0.;
+  double outwardChi2PerDof = 0.;
+  double lostShare = 0.;
+  for (int trial = 0; trial < kTrials; ++trial) {
+    for (int attempt = 0; attempt < 10; ++attempt) {
+      chain.generate(kQOverP, kX2X0PerCm, &rng, kRho);
+      if (chain.built) {
+        break;
+      }
+    }
+    BOOST_REQUIRE(chain.built);
+    lostShare += (1. - static_cast<double>(kQOverP / chain.truth[kLayers - 1].qOverP())) / kTrials;
+    auto smeared = chain.measurements;
+    for (auto& m : smeared) {
+      m.loc0 += static_cast<Scalar>(gauss(rng) * static_cast<double>(sigmaLoc));
+      m.loc1 += static_cast<Scalar>(gauss(rng) * static_cast<double>(sigmaLoc));
+    }
+    const auto fit = fitMeasurements(chain.propagator, chain.tracking, material, smeared.data(), static_cast<int>(smeared.size()));
+    BOOST_TEST_CONTEXT("trial " << trial << ", propagation status " << static_cast<int>(fit.status)) { BOOST_REQUIRE(fit.status == PropagationStatus::kOk); }
+    collectPulls(trial, fit.state, chain.truth[0], inwardPull);
+    inwardChi2PerDof += static_cast<double>(fit.chi2) / fit.ndf / kTrials;
+    outwardChi2PerDof += static_cast<double>(fit.outwardChi2) / fit.ndf / kTrials;
+  }
+  BOOST_TEST_MESSAGE("momentum lost over the chain " << lostShare << ", chi2 per dof inward " << inwardChi2PerDof << " outward " << outwardChi2PerDof);
+  BOOST_TEST(lostShare > 0.01);
+  for (int i = 0; i < kNBoundParams; ++i) {
+    const auto& p = inwardPull[static_cast<std::size_t>(i)];
+    const bool held = i != o2::gtrk::kQOverP;
+    const auto n = static_cast<double>(p.size());
+    const auto [mean, width] = moments(p);
+    BOOST_TEST_MESSAGE("inward parameter " << i << " pull mean " << mean << " width " << width);
+    BOOST_TEST_CONTEXT("inward parameter " << i << " pull mean " << mean << " width " << width)
+    {
+      BOOST_TEST((!held || std::abs(mean) < 4. / std::sqrt(n)));
+      BOOST_TEST((!held || std::abs(width - 1.) < 0.10));
+    }
+  }
+  BOOST_TEST_CONTEXT("inward chi2 per spatial dof " << inwardChi2PerDof << ", outward " << outwardChi2PerDof)
+  {
+    BOOST_TEST(std::abs(inwardChi2PerDof - 1.) < 0.15);
+    BOOST_TEST(std::abs(outwardChi2PerDof - 1.) < 0.15);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(PerigeePhiIsTheDirectionAtTheTransverseClosestApproach)
+{
+  const SyntheticChain chain;
+  const auto& state = chain.truth[0];
+  const auto& surface = chain.tracking.surface(state.surface);
+  // The closest approach by search: the smallest transverse radius on a
+  // coarse scan, refined by ternary search.
+  double best = 0.;
+  for (int step = -1000; step <= 1000; ++step) {
+    const double path = 0.1 * step;
+    if (transverseRadius2At(chain.propagator, state, surface, path) < transverseRadius2At(chain.propagator, state, surface, best)) {
+      best = path;
+    }
+  }
+  double low = best - 0.1;
+  double high = best + 0.1;
+  for (int i = 0; i < 200; ++i) {
+    const double left = low + ((high - low) / 3.);
+    const double right = high - ((high - low) / 3.);
+    if (transverseRadius2At(chain.propagator, state, surface, left) < transverseRadius2At(chain.propagator, state, surface, right)) {
+      high = right;
+    } else {
+      low = left;
+    }
+  }
+  const double path = 0.5 * (low + high);
+  const double sinTheta = std::sin(static_cast<double>(state.theta()));
+  const double turn = chain.propagator.curvature(static_cast<double>(state.qOverP()), sinTheta) * path * sinTheta;
+  const double expected = static_cast<double>(state.phi()) + turn;
+  const double difference = std::remainder(static_cast<double>(perigeePhi(chain.propagator, state, surface)) - expected, 2. * std::numbers::pi);
+  BOOST_TEST(std::abs(difference) < 1e-5);
+}
+
+BOOST_AUTO_TEST_CASE(StraightTrackPerigeeHasNoCurvatureSpecialCase)
+{
+  TrackingSurface surface;
+  surface.origin[0] = 2.F;
+  surface.origin[1] = 1.F;
+  surface.origin[2] = 3.F;
+  BoundTrackState state;
+  state.par[kPhi] = 0.F;
+  state.par[kTheta] = std::numbers::pi_v<Scalar> / 2;
+  state.par[kQOverP] = 0.F;
+
+  const Propagator propagator;
+  BOOST_TEST(std::abs(perigeePhi(propagator, state, surface)) < 1e-6F);
+}
+
+BOOST_AUTO_TEST_CASE(TheEnergyLossIsO2s)
+{
+  // The Bethe-Bloch, from slow protons to ultra-relativistic electrons.
+  for (const float betaGamma : {0.3F, 0.7F, 1.F, 3.5F, 10.F, 100.F, 1000.F, 1e4F}) {
+    BOOST_TEST_CONTEXT("beta gamma " << betaGamma) { BOOST_TEST(betheBlochSolid(betaGamma) == o2::track::BetheBlochSolidOpt<float>(betaGamma), boost::test_tools::tolerance(1e-6F)); }
+  }
+  // A step's loss against O2's own correction of a pion: outward loses
+  // (x rho < 0), inward regains, the thick step in sub-steps; q/p scales by
+  // O2's factor and its variance grows by O2's straggling.
+  constexpr float kMass = 0.13957F;
+  for (const float momentum : {0.12F, 0.3F, 2.F}) {
+    for (const float xRho : {-0.08F, 0.08F, -1.5F}) {
+      BOOST_TEST_CONTEXT("p " << momentum << " GeV, x rho " << xRho)
+      {
+        // At tan(lambda) = 0, O2's q/pT is our q/p.
+        o2::track::TrackParCov o2Track(0.F, 0.F, {0.F, 0.F, 0.F, 0.F, 1.F / momentum}, {1e-4F, 0.F, 1e-4F, 0.F, 0.F, 1e-4F, 0.F, 0.F, 0.F, 1e-4F, 0.F, 0.F, 0.F, 0.F, 1e-4F});
+        o2Track.setPID(o2::track::PID::Pion);
+        const float variance = o2Track.getSigma1Pt2();
+        BOOST_REQUIRE(o2Track.correctForMaterial(0.F, xRho));
+        const auto loss = energyLoss(1.F / momentum, kMass, xRho);
+        BOOST_REQUIRE(loss.ok);
+        BOOST_TEST(loss.momentumScale / momentum == o2Track.getQ2Pt(), boost::test_tools::tolerance(2e-6F));
+        BOOST_TEST(variance + loss.varQOverP == o2Track.getSigma1Pt2(), boost::test_tools::tolerance(2e-6F));
+        BOOST_TEST((xRho < 0.F ? loss.momentumScale > 1.F : loss.momentumScale < 1.F));
+      }
+    }
+  }
+  // No material: nothing; stopped: not ok.
+  BOOST_TEST(energyLoss(10.F, kMass, 0.F).momentumScale == 1.F);
+  BOOST_TEST(!energyLoss(1.F / 0.05F, kMass, -5.F).ok);
+  // beta p: below p.
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testTracker.cxx b/Detectors/GenericTracking/tracking/test/testTracker.cxx
new file mode 100644
index 0000000000000..081bd473cfd05
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testTracker.cxx
@@ -0,0 +1,208 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTracker.cxx
+/// \brief One CPU tracking iteration over a core and its halo.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Tracker
+#include <boost/test/unit_test.hpp>
+
+#include "ToyBarrel3.h"
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Tracking/MeasurementGridBuilder.h"
+#include "GenericTracking/Tracking/Tracker.h"
+
+#include "GridTestSupport.h"
+#include "StageOutputComparison.h"
+#include "SerialReferences.h"
+#include "UniformMaterial.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using Det = detectors::ToyBarrel3;
+using Frame = TimeFrame<Det>;
+using Scratch = TimeFrameScratch<Det>;
+using Sources = LayerRowMap<Det>;
+using Output = StageOutput<TrackletT>;
+using Controller = Tracker<Det, UniformMaterial>;
+constexpr std::size_t kMeasurements = 4U;
+
+struct InputPoint {
+  LayerID layer = kInvalidLayerID;
+  std::uint32_t timePS = 0U; ///< the time box
+  std::uint32_t widthPS = 0U;
+  Scalar r = 0.F;
+};
+
+SearchWindowParams windowParameters()
+{
+  SearchWindowParams result;
+  result.minPtGeV = 1.;
+  result.bzKiloGauss = 20.;
+  result.positionSigma = 0.01;
+  result.nSigma = 3.;
+  return result;
+}
+
+GridParams gridParameters()
+{
+  GridParams result;
+  result.blockWidth = 20'000;
+  return test::withToyFrames(result);
+}
+
+class Fixture
+{
+ public:
+  static constexpr VertexConstraint kBeamConstraint{.z = 0., .sigmaZ = 0.5, .sigmaTransverse = 0.001};
+
+  Fixture()
+    : geometry(test::cappedGrid<Det>(60., gridParameters(), windowParameters(), kBeamConstraint, 1, 1)),
+      offsets(static_cast<std::size_t>(geometry.bucketCount()) + 1U)
+  {
+    // Rows 0 and 1 form a valid halo-only pair before the core and so inside
+    // the slice gate. Row 2 is the only core source; its box ends where row 1's
+    // ends, so they do not pair. Row 3 is a halo target whose wide box reaches
+    // back into row 2's.
+    constexpr std::array<InputPoint, kMeasurements> input{{
+      {.layer = 0, .timePS = 0U, .widthPS = 20'000U, .r = 2.F},
+      {.layer = 1, .timePS = 5'000U, .widthPS = 15'000U, .r = 4.F},
+      {.layer = 0, .timePS = 20'100U, .widthPS = 24'900U, .r = 2.F},
+      {.layer = 1, .timePS = 41'000U, .widthPS = 29'000U, .r = 4.F},
+    }};
+
+    frame = test::frameOf(geometry, input.size(), [&](std::size_t i) { return test::FramePoint{.layer = input[i].layer, .x = input[i].r, .r = input[i].r}; }, [&](std::size_t i) { return TimeEstPS{.start = input[i].timePS, .width = input[i].widthPS}; }, [&](std::size_t /*i*/) { return test::PointVariances{.z = 1e-4F, .r = 1e-4F, .rPhi = 1e-4F}; }, columns, offsets);
+    used.assign(frame->size(), kFree);
+  }
+
+  [[nodiscard]] std::uint32_t row(std::uint32_t cluster) const { return static_cast<std::uint32_t>(std::ranges::find(columns.clusterIndex, cluster) - columns.clusterIndex.begin()); }
+
+  GridGeometry<Det> geometry;
+  std::vector<std::uint32_t> offsets;
+  MeasurementStore columns;
+  std::unique_ptr<Frame> frame;
+  std::vector<std::uint8_t> used; ///< the used mask: every row free
+  VertexSeed beamLine = vertexSeed(kBeamConstraint);
+};
+
+std::array<std::uint32_t, Sources::kLayerCount> candidateWidthBounds(const Fixture& fixture, const Frame::TimeSlice& slice)
+{
+  std::array<std::uint32_t, Sources::kLayerCount> result{};
+  for (std::size_t layer = 0; layer < result.size(); ++layer) {
+    for (auto row = slice.halo[layer].begin; row < slice.halo[layer].end; ++row) {
+      result[layer] = std::max(result[layer], fixture.frame->measurement(row).widthPS);
+    }
+  }
+  return result;
+}
+
+/// The toy's three layers make triplets and no road: its chains are 3
+/// clusters, or no link would be taken (`takenLinks`).
+IterationSettings iterationSettings() { return {.windows = windowParameters(), .vertexSource = VertexSource::kBeamLine, .minClusters = 3}; }
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(OneSliceMatchesSerialWithHaloSourcesInsideTheGate)
+{
+  const Fixture fixture;
+  const Frame::TimeSlice slice{*fixture.frame, {.begin = 1, .end = 2}, 1'000};
+  const auto coreSource = fixture.row(2U);
+  const auto haloSource = fixture.row(0U);
+  const auto haloTarget = fixture.row(3U);
+  BOOST_REQUIRE(slice.core[0].begin <= coreSource && coreSource < slice.core[0].end);
+  BOOST_REQUIRE(haloSource < slice.core[0].begin || haloSource >= slice.core[0].end);
+  BOOST_REQUIRE(slice.halo[1].begin <= haloTarget && haloTarget < slice.halo[1].end);
+
+  const std::array<double, Sources::kLayerCount> material{};
+  const auto scattering = scatteringTable<Det>(material);
+  const auto memory = std::make_shared<BoundedMemoryResource>();
+  Controller tracker{iterationSettings(), Fixture::kBeamConstraint, scattering, memory, 1U};
+  BOOST_REQUIRE(tracker.beginTimeframe(*fixture.frame) == StageStatus::kComplete);
+  const auto result = test::runSlice(tracker, 0U, *fixture.frame, slice, {});
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  BOOST_REQUIRE(result.tracklets != nullptr);
+  BOOST_REQUIRE(result.tracklets->size() > 0U);
+  BOOST_TEST(tracker.trackletHighWater() == result.tracklets->size());
+  BOOST_TEST(tracker.stagingHighWater() > 0U);
+
+  const auto maxCandidateWidthPS = candidateWidthBounds(fixture, slice);
+  BOOST_TEST(maxCandidateWidthPS[1] == 29'000U);
+  const auto parameters = iterationParameters<Det>(iterationSettings(), Fixture::kBeamConstraint, scattering);
+  const std::span<const VertexSeed> noVertices;
+  const auto vertexWindows = vertexWindowParameters<Det>(parameters, iterationSettings().windows, noVertices);
+  const Sources sources = Scratch::makeSources(slice.halo);
+  // Both source layers contribute their halo rows. Layer 1 cannot emit here
+  // because the fixture has no layer-2 rows; every source lies within the
+  // gate, so the ungated serial stage is the reference.
+  BOOST_REQUIRE(sources.size() == 4U);
+  BOOST_TEST(sources.contains(0, haloSource));
+  BOOST_TEST(sources.contains(1, fixture.row(1U)));
+  BOOST_TEST(sources.contains(1, fixture.row(3U)));
+  const TrackletStage<Det> stage{parameters, sources, *fixture.frame, slice.haloBlocks, fixture.beamLine, noVertices, maxCandidateWidthPS, vertexWindows, fixture.used.data()};
+  Output serial;
+  serial.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  serial.prepare(sources.size());
+  BOOST_REQUIRE(runSerial(serial, stage) == StageStatus::kComplete);
+  sortTrackletSegments(serial); // the tracker hands out each source's tracklets sorted
+  BOOST_TEST(sameStageOutput(*result.tracklets, serial));
+
+  BOOST_REQUIRE(result.tracklets->size() == 2U);
+  const auto tracklets = result.tracklets->view();
+  const bool haloFirst = tracklets[0].source == haloSource;
+  const auto& fromHalo = tracklets[haloFirst ? 0 : 1];
+  const auto& fromCore = tracklets[haloFirst ? 1 : 0];
+  BOOST_TEST(fromHalo.source == haloSource);
+  BOOST_TEST(fromHalo.target == fixture.row(1U));
+  BOOST_TEST(fromCore.source == coreSource);
+  BOOST_TEST(fromCore.target == haloTarget);
+}
+
+/// After `endTimeframe` the pool holds what it held before the timeframe
+/// began, at one thread and at several, timeframe after timeframe.
+BOOST_AUTO_TEST_CASE(EndTimeframeGivesTheMemoryBack)
+{
+  const Fixture fixture;
+  const Frame::TimeSlice slice{*fixture.frame, {.begin = 1, .end = 2}, 1'000};
+  const std::array<double, Sources::kLayerCount> material{};
+  const auto scattering = scatteringTable<Det>(material);
+  for (const int threads : {1, 4}) {
+    BOOST_TEST_CONTEXT("threads " << threads)
+    {
+      const auto memory = std::make_shared<BoundedMemoryResource>();
+      Controller tracker{iterationSettings(), Fixture::kBeamConstraint, scattering, memory, 1U, threads};
+      const auto before = memory->getUsedMemory();
+      for (int timeframe = 0; timeframe < 3; ++timeframe) {
+        BOOST_REQUIRE(tracker.beginTimeframe(*fixture.frame) == StageStatus::kComplete);
+        const auto result = test::runSlice(tracker, 0U, *fixture.frame, slice, {});
+        BOOST_REQUIRE(result.status == StageStatus::kComplete);
+        BOOST_TEST(result.tracklets->size() > 0U);
+        BOOST_TEST(memory->getUsedMemory() > before);
+        tracker.endTimeframe();
+        BOOST_TEST(memory->getUsedMemory() == before);
+      }
+    }
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testTrackingSurface.cxx b/Detectors/GenericTracking/tracking/test/testTrackingSurface.cxx
new file mode 100644
index 0000000000000..f803a3e9443e2
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testTrackingSurface.cxx
@@ -0,0 +1,186 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTrackingSurface.cxx
+/// \brief The host-to-tracking boundary: packed covariance indexing, and the
+///        surface records the propagator will be written against.
+///
+/// The load-bearing test here is the one against Geometry<Det>::toGlobal.  A
+/// surface built from the *rows* of Sensor::rot instead of its columns is a
+/// transpose that no round trip through TrackingSurface itself can detect,
+/// because both directions would use the same wrong matrix.  Only an
+/// independent implementation of the same transform sees it.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK TrackingSurface
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Base/Geometry.h"
+#include "ToyBarrel4Disc8.h"
+#include "GenericTracking/Tracking/BoundTrackState.h"
+#include "GenericTracking/Tracking/Definitions.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tracking/ShapeCut.h"
+
+#include <cmath>
+#include <limits>
+#include <set>
+
+namespace o2::gtrk
+{
+
+using Mixed = detectors::ToyBarrel4Disc8;
+
+/// The position budget: 1 um, against a 14 um single-pixel cluster
+/// RMS.  It has to hold at |z| = 152 cm, where a float ulp is already
+/// 1.2e-5 cm, so this is a real constraint on the narrowing and not a
+/// formality.
+constexpr double kMaxPosError = 1e-4; // cm
+
+BOOST_AUTO_TEST_CASE(PackedCovarianceIndexingIsUnambiguous)
+{
+  static_assert(kNBoundParams == 5);
+  static_assert(kBoundCovSize == 15);
+
+  std::set<int> seen;
+  for (int i = 0; i < kNBoundParams; ++i) {
+    for (int j = 0; j <= i; ++j) {
+      const int idx = covIndex(i, j);
+      BOOST_TEST(idx >= 0);
+      BOOST_TEST(idx < kBoundCovSize);
+      // Symmetric in its arguments: this is the property that keeps a caller
+      // from having to order the indices, which is the usual way a packed
+      // covariance goes quietly wrong.
+      BOOST_TEST(covIndex(j, i) == idx);
+      seen.insert(idx);
+    }
+  }
+  // Every slot used exactly once -- no collisions, no gaps.
+  BOOST_TEST(seen.size() == static_cast<std::size_t>(kBoundCovSize));
+
+  BOOST_TEST(varIndex(kLoc0) == 0);
+  BOOST_TEST(varIndex(kQOverP) == kBoundCovSize - 1);
+}
+
+BOOST_AUTO_TEST_CASE(SurfaceAgreesWithTheGeometryItWasBuiltFrom)
+{
+  const auto geo = toyGeometry<Mixed>();
+  const TrackingGeometry<Mixed> tgeo(geo);
+
+  // One barrel sensor and one disc sensor: the two orientations the single
+  // bound model has to serve.
+  const SensorID barrelId = 0;
+  const SensorID discId = firstSensorOfLayer<Mixed>(4); // first disc layer
+
+  for (const SensorID id : {barrelId, discId}) {
+    const TrackingSurface& s = tgeo.surface(id);
+
+    for (const double loc0 : {-0.3, 0.0, 0.5}) {
+      for (const double loc1 : {-1.2, 0.0, 2.0}) {
+        const double local[3] = {loc0, loc1, 0.};
+        double expected[3] = {};
+        geo.toGlobal(id, local, expected);
+
+        Scalar got[3] = {};
+        surfaceToGlobal(s, static_cast<Scalar>(loc0), static_cast<Scalar>(loc1), got);
+
+        for (int k = 0; k < 3; ++k) {
+          BOOST_TEST(std::abs(static_cast<double>(got[k]) - expected[k]) < kMaxPosError);
+        }
+
+        // ...and back, including the out-of-plane component, which must be
+        // zero for a point that was constructed on the plane.
+        Scalar back[3] = {};
+        surfaceToLocal(s, got, back);
+        BOOST_TEST(std::abs(static_cast<double>(back[0]) - loc0) < kMaxPosError);
+        BOOST_TEST(std::abs(static_cast<double>(back[1]) - loc1) < kMaxPosError);
+        BOOST_TEST(std::abs(static_cast<double>(back[2])) < kMaxPosError);
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(AxesAreOrthonormalAndRightHanded)
+{
+  const auto geo = toyGeometry<Mixed>();
+  const TrackingGeometry<Mixed> tgeo(geo);
+
+  for (SensorID id = 0; id < static_cast<SensorID>(Mixed::nSensors); id += 97) {
+    const TrackingSurface& s = tgeo.surface(id);
+    const Scalar* ax[3] = {s.axis0, s.axis1, s.normal};
+
+    for (int i = 0; i < 3; ++i) {
+      for (int j = 0; j < 3; ++j) {
+        const Scalar dot = ax[i][0] * ax[j][0] + ax[i][1] * ax[j][1] + ax[i][2] * ax[j][2];
+        BOOST_TEST(std::abs(dot - (i == j ? 1.F : 0.F)) < 1e-5F);
+      }
+    }
+
+    // normal == axis0 x axis1, so the frame is right-handed and the sign of
+    // the normal is not a free choice.
+    const Scalar cx = s.axis0[1] * s.axis1[2] - s.axis0[2] * s.axis1[1];
+    const Scalar cy = s.axis0[2] * s.axis1[0] - s.axis0[0] * s.axis1[2];
+    const Scalar cz = s.axis0[0] * s.axis1[1] - s.axis0[1] * s.axis1[0];
+    BOOST_TEST(std::abs(cx - s.normal[0]) < 1e-5F);
+    BOOST_TEST(std::abs(cy - s.normal[1]) < 1e-5F);
+    BOOST_TEST(std::abs(cz - s.normal[2]) < 1e-5F);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(NormalsFallIntoTheTwoFamiliesTheClosedFormIntersectionNeeds)
+{
+  // The propagator's two closed forms are only legitimate because every
+  // sensor normal is either purely transverse (barrel: the plane is a line in
+  // the transverse projection, so the intersection is a quadratic) or exactly
+  // along z (disc: z is linear in path length). This pins that precondition.
+  const auto geo = toyGeometry<Mixed>();
+  const TrackingGeometry<Mixed> tgeo(geo);
+
+  int barrel = 0;
+  int disc = 0;
+  for (SensorID id = 0; id < static_cast<SensorID>(Mixed::nSensors); ++id) {
+    const TrackingSurface& s = tgeo.surface(id);
+    if (s.layer < Detector<Mixed>::nBarrelLayers) {
+      BOOST_TEST(std::abs(s.normal[2]) < 1e-6F);
+      ++barrel;
+    } else {
+      BOOST_TEST(std::abs(s.normal[0]) < 1e-6F);
+      BOOST_TEST(std::abs(s.normal[1]) < 1e-6F);
+      BOOST_TEST(std::abs(std::abs(s.normal[2]) - 1.F) < 1e-6F);
+      ++disc;
+    }
+  }
+  BOOST_TEST(barrel > 0);
+  BOOST_TEST(disc > 0);
+  BOOST_TEST(barrel + disc == Mixed::nSensors);
+}
+
+BOOST_AUTO_TEST_CASE(BoundsAreARectangleThatRejectsNaN)
+{
+  const SurfaceBounds b{.halfX = 0.85F, .halfY = 3.4F};
+  BOOST_TEST(b.isInside(0.F, 0.F));
+  BOOST_TEST(b.isInside(0.84F, 3.3F));
+  BOOST_TEST(!b.isInside(0.9F, 0.F));
+  BOOST_TEST(!b.isInside(0.F, 3.5F));
+  BOOST_TEST(!b.isInside(std::numeric_limits<Scalar>::quiet_NaN(), 0.F));
+  BOOST_TEST(!b.isInside(0.F, std::numeric_limits<Scalar>::quiet_NaN()));
+}
+
+BOOST_AUTO_TEST_CASE(ALineIsHeldToTheSlopeAlongTheNormal)
+{
+  BOOST_TEST(slopeAdmits(1.F, 3.F, 2.F, 0.F, 2.F, 1.5F, 0.7F, -3.F));
+  BOOST_TEST(slopeAdmits(2.F, 3.F, 2.F, 0.F, 2.F, 1.5F, 0.7F, 3.F));
+  BOOST_TEST(!slopeAdmits(1.F, 2.F, 2.F, 0.F, 2.F, 1.5F, 0.7F, 3.F));
+  BOOST_TEST(!slopeAdmits(std::numeric_limits<Scalar>::infinity(), 0.F, 2.F, 0.F, 2.F, 1.5F, 0.F, 3.F));
+  BOOST_TEST(slopeAdmits(0.F, kSlopeUnbounded, 2.F, 0.F, 2.F, 1.5F, 0.F, 300.F));
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testTrackletPaths.cxx b/Detectors/GenericTracking/tracking/test/testTrackletPaths.cxx
new file mode 100644
index 0000000000000..6a0e94930c72a
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testTrackletPaths.cxx
@@ -0,0 +1,300 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTrackletPaths.cxx
+/// \brief The path bounds against every path enumerated, serial against
+///        parallel, and the sweeps in the layout's order, not the layers'.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK TrackletPaths
+#include <boost/test/unit_test.hpp>
+
+#include "ToyBarrel8.h"
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Tracking/Neighbour.h"
+#include "GenericTracking/Tracking/TrackletPaths.h"
+#include "GenericTracking/Tracking/TripletPaths.h"
+#include "SerialReferences.h"
+
+#include <array>
+#include <cstdint>
+#include <random>
+#include <vector>
+
+namespace o2::gtrk
+{
+namespace
+{
+using Det = detectors::ToyBarrel8;
+using Index = StageOutput<TrackletT>::Index;
+constexpr Index kRows = 24U;
+constexpr Index kPerLayer = 3U;
+
+// Enumerate every path, without dynamic programming, and mark every triplet
+// on paths of the requested length terminating on an allowed end layer.
+void checkGraph(std::mt19937& random)
+{
+  std::array<MeasurementRange, 8> ranges{};
+  std::array<bool, 8> presented{};
+  for (Index layer = 0U; layer < 8U; ++layer) {
+    ranges[layer] = {.begin = layer * kPerLayer, .end = (layer + 1U) * kPerLayer};
+    presented[layer] = layer < 7U;
+  }
+  LayerRowMap<Det> sources{ranges, presented};
+  std::array<std::vector<Index>, kRows> outgoing;
+  for (Index source = 0U; source < 21U; ++source) {
+    for (Index target = (source / kPerLayer + 1U) * kPerLayer; target < (source / kPerLayer + 2U) * kPerLayer; ++target) {
+      if (random() % 4U == 0U) {
+        outgoing[source].push_back(target);
+      }
+    }
+  }
+  StageOutput<TrackletT> tracklets;
+  tracklets.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  tracklets.prepare(sources.size());
+  BOOST_REQUIRE(runSerial(tracklets, [&](Index element, auto& emit) {
+                  const auto row = sources.row(element);
+                  for (const auto target : outgoing[row.row]) {
+                    emit.emit(Tracklet{.source = row.row, .target = target, .link = static_cast<std::uint16_t>(row.layer), .lambda = 0.F, .phi = 0.F});
+                  }
+                }) == StageStatus::kComplete);
+  TrackletPaths<Det> paths;
+  paths.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  for (std::uint32_t length = 4U; length <= 9U; ++length) {
+    for (const std::uint64_t mask : {std::uint64_t{0U}, std::uint64_t{1U << 3U}, std::uint64_t{1U << 7U}, std::uint64_t{(1U << 4U) | (1U << 6U)}}) {
+      IterationParameters<Det> parameters;
+      parameters.minClusters = length;
+      parameters.roadEndLayers = mask;
+      for (std::size_t link = 0U; link < Det::layerLinks.size(); ++link) {
+        parameters.linkSources[link] = Det::layerLinks[link].from;
+        parameters.linkTargets[link] = Det::layerLinks[link].to;
+      }
+      paths.build(parameters, sources, tracklets, SerialForEach{});
+      const auto bounds = paths.bounds();
+      if (length == 7U) {
+        const std::vector<std::uint8_t> prefix(bounds.prefix, bounds.prefix + sources.size());
+        const std::vector<std::uint8_t> suffix(bounds.suffix, bounds.suffix + sources.size());
+        detail::TaskArena cpuArena{8};
+        CpuStage<NeighbourT> cpu{cpuArena};
+        cpu.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+        const auto parallel = [&](Index count, const auto& body) { cpu.forEachElement(count, 1U, body); };
+        paths.build(parameters, sources, tracklets, parallel);
+        for (Index element = 0U; element < sources.size(); ++element) {
+          BOOST_TEST(paths.bounds().prefix[element] == prefix[element]);
+          BOOST_TEST(paths.bounds().suffix[element] == suffix[element]);
+        }
+      }
+      std::array<bool, std::size_t{kRows} * kRows * kRows> kept{};
+      std::vector<Index> chain;
+      const auto visit = [&](const auto& self, Index row) -> void { // NOLINT(misc-no-recursion)
+        chain.push_back(row);
+        if (chain.size() >= length && (mask == 0U || ((mask >> (row / kPerLayer)) & 1U) != 0U)) {
+          for (std::size_t i = 0U; i + 2U < chain.size(); ++i) {
+            kept[(chain[i] * kRows + chain[i + 1U]) * kRows + chain[i + 2U]] = true;
+          }
+        }
+        for (const auto target : outgoing[row]) {
+          self(self, target);
+        }
+        chain.pop_back();
+      };
+      for (Index row = 0U; row < kRows; ++row) {
+        visit(visit, row);
+      }
+      for (Index a = 0U; a < kRows; ++a) {
+        for (const Index b : outgoing[a]) {
+          for (const Index c : outgoing[b]) {
+            // a has tracklets, so it is a source; c may be on the last layer.
+            const std::uint32_t prefix = bounds.prefix[sources.element(static_cast<LayerID>(a / kPerLayer), a)];
+            const auto suffix = measurementSuffix(bounds, sources, mask, static_cast<LayerID>(c / kPerLayer), c);
+            const bool possible = suffix != 0U && prefix + 1U + suffix >= length;
+            BOOST_TEST(possible == kept[(a * kRows + b) * kRows + c]);
+          }
+        }
+      }
+    }
+  }
+}
+} // namespace
+BOOST_AUTO_TEST_CASE(ActualPathsMatchExhaustiveEnumeration)
+{
+  std::mt19937 random{47U};
+  for (unsigned graph = 0U; graph < 100U; ++graph) {
+    checkGraph(random);
+  }
+}
+} // namespace o2::gtrk
+
+namespace o2::gtrk
+{
+BOOST_AUTO_TEST_CASE(TripletPathsMatchExhaustiveOverlapPaths)
+{
+  std::mt19937 random{4711U};
+  for (unsigned graph = 0U; graph < 50U; ++graph) {
+    std::array<MeasurementRange, 8> ranges{};
+    std::array<bool, 8> presented{};
+    for (Index layer = 0U; layer < 8U; ++layer) {
+      ranges[layer] = {.begin = layer * kPerLayer, .end = (layer + 1U) * kPerLayer};
+      presented[layer] = layer < 7U;
+    }
+    const LayerRowMap<Det> sources{ranges, presented};
+    IterationParameters<Det> parameters;
+    for (std::size_t link = 0U; link < Det::layerLinks.size(); ++link) {
+      parameters.linkSources[link] = Det::layerLinks[link].from;
+      parameters.linkTargets[link] = Det::layerLinks[link].to;
+    }
+    StageOutput<TrackletT> tracklets;
+    tracklets.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    tracklets.prepare(sources.size());
+    const auto generateTracklets = [&](Index element, auto& emit) {
+      const auto row = sources.row(element);
+      for (Index target = (std::uint32_t{row.layer} + 1U) * kPerLayer; target < (std::uint32_t{row.layer} + 2U) * kPerLayer; ++target) {
+        if (random() % 3U != 0U) {
+          emit.emit(Tracklet{.source = row.row, .target = target, .link = static_cast<std::uint16_t>(row.layer), .lambda = 0.F, .phi = 0.F});
+        }
+      }
+    };
+    BOOST_REQUIRE(runSerial(tracklets, generateTracklets) == StageStatus::kComplete);
+    // The first tracklets whose middle has tracklets: at 3 clusters and any
+    // end, no path is too short.
+    parameters.minClusters = 3U;
+    TrackletPaths<Det> firsts;
+    firsts.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    firsts.build(parameters, sources, tracklets, SerialForEach{});
+    TripletPermutation<Det> permutation;
+    permutation.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    BOOST_REQUIRE(permutation.build(parameters, sources, tracklets, firsts.bounds(), SerialForEach{}, 256U) == StageStatus::kComplete);
+    const auto tv = tracklets.view();
+    std::vector<std::vector<Index>> outgoing(tracklets.size());
+    StageOutput<TripletT> triplets;
+    triplets.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    triplets.prepare(permutation.size());
+    const auto generateTriplets = [&](Index element, auto& emit) {
+      const auto first = permutation.indices()[element];
+      for (Index second = 0U; second < tracklets.size(); ++second) {
+        if (tv.target[first] == tv.source[second] && random() % 3U != 0U) {
+          outgoing[first].push_back(second);
+          emit.emit(Triplet{.first = first, .second = second, .curvature = 0.F, .varCurvature = 1.F, .level = 1U, .kinked = 0U});
+        }
+      }
+    };
+    BOOST_REQUIRE(runSerial(triplets, generateTriplets) == StageStatus::kComplete);
+    TripletPaths<Det> paths;
+    paths.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    const std::size_t n = tracklets.size();
+    for (std::uint32_t length = 4U; length <= 9U; ++length) {
+      for (const std::uint64_t mask : {std::uint64_t{0U}, std::uint64_t{1U << 3U}, std::uint64_t{1U << 7U}, std::uint64_t{(1U << 4U) | (1U << 6U)}}) {
+        parameters.minClusters = length;
+        parameters.roadEndLayers = mask;
+        paths.build(parameters, sources, tracklets, permutation, placedTriplets(triplets), SerialForEach{});
+        const auto bounds = paths.bounds();
+        if (length == 7U) {
+          const std::vector<std::uint8_t> prefix(bounds.prefix, bounds.prefix + n);
+          const std::vector<std::uint8_t> suffix(bounds.suffix, bounds.suffix + n);
+          detail::TaskArena cpuArena{8};
+          CpuStage<NeighbourT> cpu{cpuArena};
+          cpu.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+          const auto parallel = [&](Index count, const auto& body) { cpu.forEachElement(count, 1U, body); };
+          paths.build(parameters, sources, tracklets, permutation, placedTriplets(triplets), parallel);
+          for (Index row = 0U; row < tracklets.size(); ++row) {
+            BOOST_TEST(paths.bounds().prefix[row] == prefix[row]);
+            BOOST_TEST(paths.bounds().suffix[row] == suffix[row]);
+          }
+        }
+        std::vector<bool> kept(n * n * n, false);
+        std::vector<Index> chain;
+        const auto visit = [&](const auto& self, Index row) -> void { // NOLINT(misc-no-recursion)
+          chain.push_back(row);
+          const auto endLayer = parameters.linkTargets[tv.link[row]];
+          if (chain.size() + 1U >= length && (mask == 0U || ((mask >> endLayer) & 1U) != 0U)) {
+            for (std::size_t i = 0U; i + 2U < chain.size(); ++i) {
+              kept[(chain[i] * n + chain[i + 1U]) * n + chain[i + 2U]] = true;
+            }
+          }
+          for (const auto target : outgoing[row]) {
+            self(self, target);
+          }
+          chain.pop_back();
+        };
+        for (Index row = 0U; row < tracklets.size(); ++row) {
+          visit(visit, row);
+        }
+        for (Index a = 0U; a < tracklets.size(); ++a) {
+          for (const Index b : outgoing[a]) {
+            for (const Index c : outgoing[b]) {
+              const bool possible = bounds.suffix[c] != 0U && std::uint32_t{bounds.prefix[a]} + 1U + bounds.suffix[c] >= length;
+              BOOST_TEST(possible == kept[(a * n + b) * n + c]);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+} // namespace o2::gtrk
+
+namespace o2::gtrk
+{
+namespace
+{
+// A numeric layer order deliberately opposite to the topological order.
+struct ReverseBarrel8 : detectors::ToyBarrel8 {
+  static constexpr std::array<LayerLink, 7> layerLinks{{{.from = 7, .to = 6, .sourceMin = -1.5, .sourceMax = 1.5, .skipsLayer = false}, {.from = 6, .to = 5, .sourceMin = -1.5, .sourceMax = 1.5, .skipsLayer = false}, {.from = 5, .to = 4, .sourceMin = -1.5, .sourceMax = 1.5, .skipsLayer = false}, {.from = 4, .to = 3, .sourceMin = -1.5, .sourceMax = 1.5, .skipsLayer = false}, {.from = 3, .to = 2, .sourceMin = -1.5, .sourceMax = 1.5, .skipsLayer = false}, {.from = 2, .to = 1, .sourceMin = -1.5, .sourceMax = 1.5, .skipsLayer = false}, {.from = 1, .to = 0, .sourceMin = -1.5, .sourceMax = 1.5, .skipsLayer = false}}};
+};
+} // namespace
+BOOST_AUTO_TEST_CASE(PathSweepsFollowTopologyInsteadOfNumericLayerOrder)
+{
+  std::array<MeasurementRange, 8> ranges{};
+  std::array<bool, 8> presented{};
+  for (Index layer = 0U; layer < 8U; ++layer) {
+    ranges[layer] = {.begin = layer, .end = layer + 1U};
+    presented[layer] = layer != 0U;
+  }
+  const LayerRowMap<ReverseBarrel8> sources{ranges, presented};
+  IterationParameters<ReverseBarrel8> parameters;
+  parameters.roadEndLayers = 1U; // The end of the chain is layer 0.
+  parameters.minClusters = 8U;
+  for (std::size_t link = 0U; link < ReverseBarrel8::layerLinks.size(); ++link) {
+    parameters.linkSources[link] = ReverseBarrel8::layerLinks[link].from;
+    parameters.linkTargets[link] = ReverseBarrel8::layerLinks[link].to;
+  }
+  StageOutput<TrackletT> tracklets;
+  tracklets.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  tracklets.prepare(sources.size());
+  BOOST_REQUIRE(runSerial(tracklets, [&](Index element, auto& emit) {
+                  const auto source = sources.row(element).row;
+                  emit.emit(Tracklet{.source = source, .target = source - 1U, .link = static_cast<std::uint16_t>(7U - source), .lambda = 0.F, .phi = 0.F});
+                }) == StageStatus::kComplete);
+  TrackletPaths<ReverseBarrel8> paths;
+  paths.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  paths.build(parameters, sources, tracklets, SerialForEach{});
+  // Row 0, the chain's end, has no tracklets and is no source.
+  BOOST_TEST(paths.bounds().prefix[sources.element(1, 1U)] == 7U);
+  BOOST_TEST(paths.bounds().suffix[sources.element(7, 7U)] == 8U);
+  BOOST_TEST(measurementSuffix(paths.bounds(), sources, parameters.roadEndLayers, 0, 0U) == 1U);
+  TripletPermutation<ReverseBarrel8> permutation;
+  permutation.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  BOOST_REQUIRE(permutation.build(parameters, sources, tracklets, paths.bounds(), SerialForEach{}, 256U) == StageStatus::kComplete);
+  BOOST_TEST(permutation.size() == 6U);
+  StageOutput<TripletT> triplets;
+  triplets.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  triplets.prepare(permutation.size());
+  BOOST_REQUIRE(runSerial(triplets, [&](Index element, auto& emit) {
+                  const auto first = permutation.indices()[element];
+                  emit.emit(Triplet{.first = first, .second = first - 1U, .curvature = 0.F, .varCurvature = 1.F, .level = 1U, .kinked = 0U});
+                }) == StageStatus::kComplete);
+  TripletPaths<ReverseBarrel8> tripletPaths;
+  tripletPaths.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  tripletPaths.build(parameters, sources, tracklets, permutation, placedTriplets(triplets), SerialForEach{});
+  BOOST_TEST(tripletPaths.bounds().prefix[0] == 8U);
+  BOOST_TEST(tripletPaths.bounds().suffix[6] == 7U);
+}
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testTrackletSort.cxx b/Detectors/GenericTracking/tracking/test/testTrackletSort.cxx
new file mode 100644
index 0000000000000..7eb9d6c41baf0
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testTrackletSort.cxx
@@ -0,0 +1,247 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTrackletSort.cxx
+/// \brief Each source's tracklets in (link, lambda, target) order.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK TrackletSort
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/Tracklet.h"
+#include "GenericTracking/Tracking/TrackletSort.h"
+
+#include "StageOutputComparison.h"
+#include "SerialReferences.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <memory>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using Output = StageOutput<TrackletT>;
+using Cpu = CpuStage<TrackletT>;
+using Index = Output::Index;
+
+constexpr Index kElements = 97;
+
+// Repeated values, and -0 next to +0, so that lambda ties are common and the
+// target has to decide them.
+constexpr std::array<Scalar, 7> kLambdas{0.25F, -0.F, 0.F, 0.25F, -1.5F, 1.25F, 0.F};
+
+/// Element e emits (e * 7) % 11 tracklets, zero and one among them, with
+/// unique targets in scrambled order and keys that tie on link and lambda.
+struct Generator {
+  template <typename Emitter>
+  void operator()(Index element, Emitter& emitter) const
+  {
+    const Index count = (element * 7U) % 11U;
+    for (Index k = 0; k < count; ++k) {
+      // k -> 7k + e is one-to-one modulo the prime 11, and k < count <= 10.
+      const Index scrambled = ((k * 7U) + element) % 11U;
+      emitter.emit(Tracklet{
+        .source = element,
+        .target = (element * 1000U) + scrambled,
+        .link = static_cast<std::uint16_t>((k * 3U + element) % 3U),
+        .lambda = kLambdas[(k + element) % kLambdas.size()],
+        .phi = static_cast<Scalar>(k) - static_cast<Scalar>(element),
+      });
+    }
+  }
+};
+
+std::shared_ptr<BoundedMemoryResource> pool() { return std::make_shared<BoundedMemoryResource>(); }
+
+bool before(const Tracklet& a, const Tracklet& b) { return trackletBefore(a.link, a.lambda, a.target, b.link, b.lambda, b.target); }
+
+bool sameTracklet(const Tracklet& a, const Tracklet& b) { return a.source == b.source && a.target == b.target && a.link == b.link && std::bit_cast<std::uint32_t>(a.lambda) == std::bit_cast<std::uint32_t>(b.lambda) && std::bit_cast<std::uint32_t>(a.phi) == std::bit_cast<std::uint32_t>(b.phi); }
+
+std::vector<Tracklet> segment(const Output& output, Index element)
+{
+  const auto view = output.view();
+  std::vector<Tracklet> result;
+  for (auto i = output.offsets()[element]; i < output.offsets()[element + 1U]; ++i) {
+    result.push_back({.source = view.source[i], .target = view.target[i], .link = view.link[i], .lambda = view.lambda[i], .phi = view.phi[i]});
+  }
+  return result;
+}
+
+void generateSerial(Output& output)
+{
+  output.setMemoryPool(pool());
+  output.prepare(kElements);
+  BOOST_REQUIRE((runSerial(output, Generator{}) == StageStatus::kComplete));
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(EverySegmentIsInKeyOrderAndKeepsItsTracklets)
+{
+  Output unsorted;
+  generateSerial(unsorted);
+  Output sorted;
+  generateSerial(sorted);
+  sortTrackletSegments(sorted);
+  BOOST_REQUIRE(sorted.size() == unsorted.size());
+
+  bool anyTie = false;
+  for (Index element = 0; element < kElements; ++element) {
+    const auto before = segment(unsorted, element);
+    const auto after = segment(sorted, element);
+    BOOST_REQUIRE(after.size() == before.size());
+    for (std::size_t i = 1; i < after.size(); ++i) {
+      BOOST_TEST(o2::gtrk::before(after[i - 1U], after[i]), "element " << element << " position " << i);
+      anyTie = anyTie || (after[i - 1U].link == after[i].link && !(after[i - 1U].lambda < after[i].lambda));
+    }
+    // The same tracklets, in the order std::sort gives with the same key.
+    auto expected = before;
+    std::ranges::sort(expected, o2::gtrk::before);
+    BOOST_TEST(std::ranges::equal(after, expected, sameTracklet), "element " << element);
+  }
+  BOOST_TEST(anyTie); // the target decided at least one equal link and lambda
+}
+
+namespace
+{
+
+constexpr Index kVariedElements = 40;
+
+/// Element e emits a source of a length from 0 to 2000 with one of three
+/// lambda patterns -- one lambda for the whole source, a few repeated values
+/// with -0 and +0, or all distinct -- over 12 links, its targets unique and
+/// scrambled, and the same targets in every source, so that neighbouring
+/// sources share keys.
+struct VariedGenerator {
+  static constexpr std::array<Index, 10> kLengths{0U, 1U, 2U, 3U, 31U, 32U, 33U, 129U, 512U, 2000U};
+
+  template <typename Emitter>
+  void operator()(Index element, Emitter& emitter) const
+  {
+    const Index count = kLengths[element % kLengths.size()];
+    const auto pattern = (element / kLengths.size()) % 3U;
+    for (Index k = 0; k < count; ++k) {
+      Scalar lambda = 0.5F;
+      if (pattern == 1U) {
+        lambda = kLambdas[(std::size_t{k} * 5U) % kLambdas.size()];
+      } else if (pattern == 2U) {
+        lambda = static_cast<Scalar>(static_cast<int>((k * 7919U) % 4001U) - 2000) * 1.e-3F;
+      }
+      emitter.emit(Tracklet{
+        .source = element,
+        .target = (k * 7919U) % 100003U,
+        .link = static_cast<std::uint16_t>((k * 5U + element) % 12U),
+        .lambda = lambda,
+        .phi = static_cast<Scalar>(k),
+      });
+    }
+  }
+};
+
+/// One source as long as a source can be, over 12 links, every lambda the same.
+struct LongGenerator {
+  static constexpr auto kCount = static_cast<Index>(Output::kMaxPerElement);
+
+  template <typename Emitter>
+  void operator()(Index /*element*/, Emitter& emitter) const
+  {
+    for (Index k = 0; k < kCount; ++k) {
+      emitter.emit(Tracklet{.source = 0U, .target = (k * 7919U) % 100003U, .link = static_cast<std::uint16_t>(k % 12U), .lambda = 0.F, .phi = 0.F});
+    }
+  }
+};
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(TheHostSortGivesTheReferenceOrderForAnyLengthAndTies)
+{
+  Output serial;
+  serial.setMemoryPool(pool());
+  serial.prepare(kVariedElements);
+  BOOST_REQUIRE((runSerial(serial, VariedGenerator{}) == StageStatus::kComplete));
+  sortTrackletSegments(serial);
+
+  for (const int threads : {1, 2, 4}) {
+    for (const Index chunk : {1U, 3U, 64U}) {
+      Output parallel;
+      const auto parallelPool = pool();
+      parallel.setMemoryPool(parallelPool);
+      parallel.prepare(kVariedElements);
+      detail::TaskArena cpuArena{threads};
+      Cpu cpu{cpuArena};
+      cpu.setMemoryPool(parallelPool);
+      BOOST_REQUIRE((cpu.run(parallel, chunk, VariedGenerator{}) == StageStatus::kComplete));
+      const auto view = parallel.view();
+      const auto offsets = parallel.offsets();
+      const auto sort = [&] { cpu.forEachElement(parallel.elementCount(), chunk, [&](Index element) { sortTrackletSegmentOnHost(view, offsets[element], offsets[element + 1U]); }); };
+      sort();
+      BOOST_TEST(sameStageOutput(parallel, serial), "threads " << threads << ", chunk " << chunk);
+      // Sorting a sorted output changes nothing.
+      sort();
+      BOOST_TEST(sameStageOutput(parallel, serial), "threads " << threads << ", chunk " << chunk << ", twice");
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(TheHostSortTakesOneLongSourceOfOneLambda)
+{
+  // 65536 tracklets of one source, every lambda equal: the target alone
+  // decides within a link. The serial reference would take ~10^9 moves here,
+  // so the expectation is std::sort's on the same key.
+  Output output;
+  output.setMemoryPool(pool());
+  output.prepare(1U);
+  BOOST_REQUIRE((runSerial(output, LongGenerator{}) == StageStatus::kComplete));
+  auto expected = segment(output, 0U);
+  std::ranges::sort(expected, o2::gtrk::before);
+
+  sortTrackletSegmentOnHost(output.view(), output.offsets()[0], output.offsets()[1]);
+  BOOST_TEST(std::ranges::equal(segment(output, 0U), expected, sameTracklet));
+}
+
+BOOST_AUTO_TEST_CASE(TheDeviceKeysOrderLikeTrackletBefore)
+{
+  // Every pair of lambdas -- both zeros, the denormals, both signs, the
+  // range's ends, ties -- and links: the keys compare as `trackletBefore` does
+  // with the target aside, in a process that compares denormals as zero, as
+  // the trackers' do.
+  const volatile float denormal = -1.e-45F;
+  const volatile float negativeZero = -0.F;
+  BOOST_REQUIRE_MESSAGE(!(denormal < negativeZero), "this process compares denormals as zero (MXCSR DAZ)");
+  const std::array<Scalar, 13> lambdas{-1.5707964F, -1.F, -0.25F, -1.e-30F, -1.e-45F, -0.F, 0.F, 1.e-45F, 1.e-30F, 0.25F, 0.5F, 1.F, 1.5707964F};
+  const std::array<std::uint16_t, 3> links{0U, 1U, 11U};
+  for (const Scalar a : lambdas) {
+    for (const Scalar b : lambdas) {
+      BOOST_TEST((trackletLambdaKey(a) < trackletLambdaKey(b)) == (a < b), a << " " << b);
+      BOOST_TEST((trackletLambdaKey(a) == trackletLambdaKey(b)) == (!(a < b) && !(b < a)), a << " " << b);
+      for (const std::uint16_t la : links) {
+        for (const std::uint16_t lb : links) {
+          const bool keyBefore = trackletLinkLambdaKey(la, a) < trackletLinkLambdaKey(lb, b);
+          // The same target on both sides: only link and lambda decide.
+          BOOST_TEST(keyBefore == trackletBefore(la, a, 0U, lb, b, 0U), la << " " << a << " " << lb << " " << b);
+        }
+      }
+    }
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testTrackletStage.cxx b/Detectors/GenericTracking/tracking/test/testTrackletStage.cxx
new file mode 100644
index 0000000000000..853a5f44d7bdd
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testTrackletStage.cxx
@@ -0,0 +1,674 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTrackletStage.cxx
+/// \brief Tracklet generation against a whole-layer brute-force reference.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK TrackletStage
+#include <boost/test/unit_test.hpp>
+#include <numbers>
+
+#include "GenericTracking/Base/LayerLinks.h"
+#include "ToyBarrel3.h"
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/LayerRowMap.h"
+#include "GenericTracking/Tracking/MeasurementGridBuilder.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/TrackletStage.h"
+
+#include "GPUCommonMath.h"
+#include "GridTestSupport.h"
+#include "StageOutputComparison.h"
+#include "SerialReferences.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+/// Three barrel layers with an extra 0 -> 2 link. The table order makes the
+/// outgoing links of layer 0 non-contiguous and therefore observable. Some
+/// trajectory on 0 -> 2 passes beyond layer 1's ends, so it skips nothing by
+/// the table: whether a pair on it leaves a hole is the pair's.
+///
+/// Layer 2 is five modules long, |z| 5 cm, so the fixture's targets lie on
+/// it: the hole test's per-source check reads the target's extent.
+struct StageToy {
+  static constexpr const char* name = "StageToy";
+  static constexpr std::array<BarrelLayerSpec, 3> barrelSpecs{{
+    detectors::ToyBarrel3::barrelSpecs[0],
+    detectors::ToyBarrel3::barrelSpecs[1],
+    {.r = 8., .nStaves = 4, .nModulesPerStave = 5, .phi0 = 0., .tilt = 0., .moduleGap = 0., .sensor = detectors::ToyBarrel3::sensor},
+  }};
+  static constexpr auto discSpecs = detectors::ToyBarrel3::discSpecs;
+  static constexpr auto barrelLayers = placedLayers(barrelSpecs);
+  static constexpr auto discLayers = placedLayers(discSpecs);
+  static constexpr std::array<LayerLink, 3> layerLinks{{
+    {.from = 0, .to = 2, .sourceMin = -10., .sourceMax = 10., .skipsLayer = false},
+    {.from = 1, .to = 2, .sourceMin = -10., .sourceMax = 10., .skipsLayer = false},
+    {.from = 0, .to = 1, .sourceMin = -2., .sourceMax = 2., .skipsLayer = false},
+  }};
+  static constexpr int nSensors = countSensors(barrelLayers, discLayers);
+};
+
+[[maybe_unused]] const bool kStageToyPublished = publishToy<StageToy>();
+
+using Frame = TimeFrame<StageToy>;
+using Sources = LayerRowMap<StageToy>;
+using Output = StageOutput<TrackletT>;
+using Cpu = CpuStage<TrackletT>;
+/// The tracklet stage alone: chains of two clusters, so the iteration takes
+/// every link (`takenLinks`).
+constexpr int kChainClusters = 2;
+constexpr std::size_t kReferenceMeasurements = 9;
+constexpr std::size_t kExtraSources = 64;
+constexpr std::size_t kMeasurements = kReferenceMeasurements + kExtraSources;
+/// Every row at 110 ns, in its toy tick's box [92, 133) ns.
+constexpr double kRowTimeNS = 110.;
+const TimeEstPS kRowBox = test::toyTimeBox(kRowTimeNS);
+
+struct InputPoint {
+  LayerID layer = kInvalidLayerID;
+  Scalar r = 0.F;
+  Scalar phi = 0.F;
+  Scalar z = 0.F;
+};
+
+SearchWindowParams windowParameters()
+{
+  SearchWindowParams result;
+  result.minPtGeV = 1.;
+  result.bzKiloGauss = 20.;
+  result.materialX2X0 = 0.;
+  result.positionSigma = 0.01;
+  result.nSigma = 3.;
+  return result;
+}
+
+GridParams gridParameters()
+{
+  GridParams result;
+  result.blockWidth = 20'000;
+  return test::withToyFrames(result);
+}
+
+class Fixture
+{
+ public:
+  static constexpr VertexConstraint kBeamConstraint{.z = 0., .sigmaZ = 0.5, .sigmaTransverse = 0.001};
+
+  Fixture()
+    : geometry(test::cappedGrid<StageToy>(20., gridParameters(), windowParameters(), kBeamConstraint, 8, 4)),
+      offsets(static_cast<std::size_t>(geometry.bucketCount()) + 1U)
+  {
+    constexpr std::array<InputPoint, kReferenceMeasurements> reference{{
+      {.layer = 0, .r = 2.F, .phi = 0.F, .z = 1.F},
+      {.layer = 0, .r = 2.F, .phi = 0.4F, .z = -0.5F},
+      {.layer = 0, .r = 2.F, .phi = 1.F, .z = 20.F},
+      {.layer = 1, .r = 4.F, .phi = 0.003F, .z = 2.F},
+      {.layer = 1, .r = 4.F, .phi = (2 * std::numbers::pi_v<Scalar>)-0.003F, .z = 2.F},
+      {.layer = 1, .r = 4.F, .phi = 0.F, .z = 0.2F},
+      {.layer = 2, .r = 8.F, .phi = 0.005F, .z = 4.F},
+      {.layer = 2, .r = 8.F, .phi = (2 * std::numbers::pi_v<Scalar>)-0.005F, .z = 4.F},
+      {.layer = 2, .r = 8.F, .phi = 0.F, .z = 0.F},
+    }};
+    std::array<InputPoint, kMeasurements> input{};
+    std::ranges::copy(reference, input.begin());
+    for (std::size_t i = 0; i < kExtraSources; ++i) {
+      input[kReferenceMeasurements + i] = {
+        .layer = 0,
+        .r = 2.F,
+        .phi = (2 * std::numbers::pi_v<Scalar>)*static_cast<Scalar>(i) / static_cast<Scalar>(kExtraSources),
+        .z = 20.F,
+      };
+    }
+
+    frame = test::frameOf(geometry, input.size(), [&](std::size_t i) { return test::FramePoint{.layer = input[i].layer, .x = input[i].r * std::cos(input[i].phi), .y = input[i].r * std::sin(input[i].phi), .z = input[i].z, .r = input[i].r, .phi = input[i].phi}; }, [&](std::size_t /*i*/) { return kRowBox; }, [&](std::size_t /*i*/) { return test::PointVariances{.z = 1e-4F, .r = 1e-4F, .rPhi = 1e-4F}; }, columns, offsets);
+    used.assign(frame->size(), kFree);
+    std::array<MeasurementRange, Sources::kLayerCount> rows{};
+    for (std::size_t layer = 0; layer < rows.size(); ++layer) {
+      rows[layer] = frame->grid().layerRows(static_cast<LayerID>(layer));
+    }
+    sources = Sources{rows, {true, true, false}};
+  }
+
+  GridGeometry<StageToy> geometry;
+  std::vector<std::uint32_t> offsets;
+  MeasurementStore columns;
+  std::unique_ptr<Frame> frame;
+  std::vector<std::uint8_t> used; ///< the used mask: every row free
+  Sources sources;
+  VertexSeed beamLine = vertexSeed(kBeamConstraint);
+  std::array<VertexSeed, 4> vertices{{
+    {.timePS = 0U, .z = 0.F},
+    {.timePS = 109'500U, .z = 2.F},
+    {.timePS = 110'500U, .z = 0.F},
+    {.timePS = 200'000U, .z = 0.F},
+  }};
+  std::array<std::uint32_t, Sources::kLayerCount> maxCandidateWidthPS{kRowBox.width, kRowBox.width, kRowBox.width};
+};
+
+[[nodiscard]] bool vertexUsed(const IterationParameters<StageToy>& parameters, const auto& source, const VertexSeed& vertex) { return vertexUsable(parameters, timeBox(source), vertex); }
+
+template <typename Stage>
+std::unique_ptr<Output> runStage(const Fixture& fixture, const Stage& stage)
+{
+  auto output = std::make_unique<Output>();
+  output->setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  output->prepare(fixture.sources.size());
+  BOOST_REQUIRE(runSerial(*output, stage) == StageStatus::kComplete);
+  return output;
+}
+
+std::vector<std::uint32_t> bruteForceTargets(const Fixture& fixture, const IterationParameters<StageToy>& parameters, std::span<const VertexSeed> vertices, Sources::Index sourceElement, std::size_t linkIndex)
+{
+  const auto sourceAt = fixture.sources.row(sourceElement);
+  const auto source = fixture.frame->measurement(sourceAt.row);
+  const auto& link = StageToy::layerLinks[linkIndex];
+  std::vector<std::uint32_t> result;
+  const Scalar sourceSecond = secondCoordinate<StageToy>(sourceAt.layer, source.r, source.z);
+  if (link.from != sourceAt.layer || sourceSecond < parameters.sourceMin[linkIndex] || sourceSecond > parameters.sourceMax[linkIndex]) {
+    return result;
+  }
+  const auto sourcePoint = pairPoint(source);
+  const auto targets = fixture.frame->grid().layerRows(link.to);
+  for (auto targetRow = targets.begin; targetRow < targets.end; ++targetRow) {
+    const auto target = fixture.frame->measurement(targetRow);
+    if (!timeBox(source).isCompatible(timeBox(target))) {
+      continue;
+    }
+    // Without skips, no pair whose segment crosses layer 1 (LinkHoles.h).
+    if (segmentLeavesHole(parameters.holeLayers[linkIndex], parameters.barrelLayers, parameters.layerSpans, source.r, source.z, target.r, target.z)) {
+      continue;
+    }
+    for (const auto& vertex : vertices) {
+      if (!vertexUsed(parameters, source, vertex)) {
+        continue;
+      }
+      const Scalar scattering = sourceScattering<StageToy>(parameters.scattering, parameters.pairCut, vertex, sourceAt.layer, sourcePoint);
+      if (pairCompatible(parameters.pairCut, vertex, sourcePoint, scattering, pairPoint(target))) {
+        result.push_back(targetRow);
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+void verify(VertexSource vertexSource, std::span<const VertexSeed> suppliedVertices = {}, bool checkSpecialCases = true, bool skipLinks = true)
+{
+  Fixture fixture;
+  const IterationSettings settings{.windows = windowParameters(), .vertexSource = vertexSource, .minClusters = kChainClusters, .skipLinks = skipLinks};
+  const std::array<double, 3> material{};
+  const auto parameters = iterationParameters<StageToy>(settings, Fixture::kBeamConstraint, scatteringTable<StageToy>(material));
+  const std::span<const VertexSeed> vertexList = suppliedVertices.empty() ? std::span<const VertexSeed>{fixture.vertices} : suppliedVertices;
+  const std::span<const VertexSeed> selected = vertexSource == VertexSource::kBeamLine ? std::span<const VertexSeed>{&fixture.beamLine, 1U} : vertexList;
+  const auto vertexWindows = vertexWindowParameters<StageToy>(parameters, settings.windows, vertexList);
+
+  const TrackletStage<StageToy> stage{parameters, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, vertexList, fixture.maxCandidateWidthPS, vertexWindows, fixture.used.data()};
+  Output output;
+  output.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  output.prepare(fixture.sources.size());
+  BOOST_REQUIRE((runSerial(output, stage) == StageStatus::kComplete));
+
+  const auto view = std::as_const(output).view();
+  std::vector<Tracklet> expectedOrder;
+  for (Sources::Index sourceElement = 0; sourceElement < fixture.sources.size(); ++sourceElement) {
+    const auto sourceAt = fixture.sources.row(sourceElement);
+    const auto source = fixture.frame->measurement(sourceAt.row);
+    std::size_t outputAt = output.offsets()[sourceElement];
+
+    for (auto at = outLinks<StageToy>.begin(sourceAt.layer); at < outLinks<StageToy>.end(sourceAt.layer); ++at) {
+      const std::size_t linkIndex = outLinks<StageToy>.links[at];
+      const auto brute = bruteForceTargets(fixture, parameters, selected, sourceElement, linkIndex);
+      std::vector<std::uint32_t> emitted;
+      while (outputAt < output.offsets()[sourceElement + 1U] && view[outputAt].link == linkIndex) {
+        emitted.push_back(view[outputAt].target);
+        ++outputAt;
+      }
+      auto sortedEmitted = emitted;
+      std::ranges::sort(sortedEmitted);
+      auto sortedBrute = brute;
+      std::ranges::sort(sortedBrute);
+      BOOST_REQUIRE(sortedEmitted.size() == sortedBrute.size());
+      for (std::size_t i = 0; i < sortedBrute.size(); ++i) {
+        BOOST_TEST(sortedEmitted[i] == sortedBrute[i]);
+      }
+
+      const Scalar sourceSecond = secondCoordinate<StageToy>(sourceAt.layer, source.r, source.z);
+      if (sourceSecond < parameters.sourceMin[linkIndex] || sourceSecond > parameters.sourceMax[linkIndex]) {
+        continue;
+      }
+      const auto& link = StageToy::layerLinks[linkIndex];
+      const auto window = candidateWindow(parameters.windows[linkIndex], timeBox(source), source.phi, source.r, source.z, fixture.maxCandidateWidthPS[link.to]);
+      fixture.frame->grid().visitCandidates(link.to, window, fixture.geometry.allBlocks(), [&](std::uint32_t targetRow) {
+        if (std::ranges::find(brute, targetRow) != brute.end()) {
+          const auto target = fixture.frame->measurement(targetRow);
+          const Scalar dx = target.x - source.x;
+          const Scalar dy = target.y - source.y;
+          const Scalar dz = target.z - source.z;
+          expectedOrder.push_back({
+            .source = sourceAt.row,
+            .target = targetRow,
+            .link = static_cast<std::uint16_t>(linkIndex),
+            .lambda = o2::gpu::GPUCommonMath::ATan2(dz, o2::gpu::GPUCommonMath::Sqrt((dx * dx) + (dy * dy))),
+            .phi = o2::gpu::GPUCommonMath::ATan2(dy, dx),
+          });
+        }
+      });
+    }
+    BOOST_TEST(outputAt == output.offsets()[sourceElement + 1U]);
+  }
+
+  BOOST_REQUIRE(output.size() == expectedOrder.size());
+  for (std::size_t i = 0; i < expectedOrder.size(); ++i) {
+    BOOST_TEST(view[i].source == expectedOrder[i].source);
+    BOOST_TEST(view[i].target == expectedOrder[i].target);
+    BOOST_TEST(view[i].link == expectedOrder[i].link);
+    BOOST_TEST(view[i].lambda == expectedOrder[i].lambda);
+    BOOST_TEST(view[i].phi == expectedOrder[i].phi);
+  }
+
+  // This source's window wraps around phi = 0. The high-phi cell is visited
+  // before the low-phi cell, even though its global rows come later.
+  if (checkSpecialCases) {
+    const auto wrappedSource = static_cast<std::uint32_t>(std::ranges::find(fixture.columns.clusterIndex, 0U) - fixture.columns.clusterIndex.begin());
+    const auto lowTarget = static_cast<std::uint32_t>(std::ranges::find(fixture.columns.clusterIndex, 3U) - fixture.columns.clusterIndex.begin());
+    const auto highTarget = static_cast<std::uint32_t>(std::ranges::find(fixture.columns.clusterIndex, 4U) - fixture.columns.clusterIndex.begin());
+    const auto wrappedElement = fixture.sources.element(0, wrappedSource);
+    std::vector<std::uint32_t> wrappedOrder;
+    for (auto i = output.offsets()[wrappedElement]; i < output.offsets()[wrappedElement + 1U]; ++i) {
+      if (view[i].link == 2U) {
+        wrappedOrder.push_back(view[i].target);
+      }
+    }
+    BOOST_REQUIRE(wrappedOrder.size() == 2U);
+    BOOST_TEST(wrappedOrder[0] == highTarget);
+    BOOST_TEST(wrappedOrder[1] == lowTarget);
+
+    constexpr std::size_t kFirstPassingVertex = 2U;
+    if (vertexSource == VertexSource::kVertexList && selected.size() > kFirstPassingVertex) {
+      const auto sourcePoint = pairPoint(fixture.frame->measurement(wrappedSource));
+      const auto targetPoint = pairPoint(fixture.frame->measurement(lowTarget));
+      for (std::size_t i = 0; i < kFirstPassingVertex; ++i) {
+        if (!vertexUsed(parameters, fixture.frame->measurement(wrappedSource), selected[i])) {
+          continue;
+        }
+        const Scalar scattering = sourceScattering<StageToy>(parameters.scattering, parameters.pairCut, selected[i], LayerID{0}, sourcePoint);
+        BOOST_TEST(!pairCompatible(parameters.pairCut, selected[i], sourcePoint, scattering, targetPoint));
+      }
+      BOOST_REQUIRE(vertexUsed(parameters, fixture.frame->measurement(wrappedSource), selected[kFirstPassingVertex]));
+      const Scalar passingScattering = sourceScattering<StageToy>(parameters.scattering, parameters.pairCut, selected[kFirstPassingVertex], LayerID{0}, sourcePoint);
+      BOOST_TEST(pairCompatible(parameters.pairCut, selected[kFirstPassingVertex], sourcePoint, passingScattering, targetPoint));
+      bool found = false;
+      for (std::size_t i = 0; i < output.size(); ++i) {
+        found = found || (view[i].source == wrappedSource && view[i].target == lowTarget && view[i].link == 2U);
+      }
+      BOOST_TEST(found);
+    }
+  }
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(BeamLineMatchesBruteForceAndSerialOrder) { verify(VertexSource::kBeamLine); }
+
+BOOST_AUTO_TEST_CASE(VertexListMatchesBruteForceAndAcceptsAtLeastOneVertex) { verify(VertexSource::kVertexList); }
+
+/// Without skips, 0 -> 2 makes only the pairs past layer 1's ends: from
+/// (2, 1) to (8, 4) the segment is at z 2 at r 4, beyond layer 1's |z| 1;
+/// from (2, -0.5) to (8, 0) it crosses layer 1 at z -1/3.
+BOOST_AUTO_TEST_CASE(WithoutSkipsAPairCrossingALayerIsNotATracklet)
+{
+  verify(VertexSource::kBeamLine, {}, true, false);
+  verify(VertexSource::kVertexList, {}, true, false);
+  const std::array<double, 3> material{};
+  const auto table = scatteringTable<StageToy>(material);
+  const auto withSkips = iterationParameters<StageToy>({.windows = windowParameters(), .minClusters = kChainClusters}, Fixture::kBeamConstraint, table);
+  const auto without = iterationParameters<StageToy>({.windows = windowParameters(), .minClusters = kChainClusters, .skipLinks = false}, Fixture::kBeamConstraint, table);
+  BOOST_TEST(withSkips.holeLayers[0] == 0U);
+  BOOST_TEST(without.holeLayers[0] == 0b010U);
+  BOOST_TEST(without.holeLayers[1] == 0U);
+  BOOST_TEST(without.holeLayers[2] == 0U);
+  const auto& spans = without.layerSpans;
+  BOOST_TEST(!segmentLeavesHole(without.holeLayers[0], without.barrelLayers, spans, 2.F, 1.F, 8.F, 4.F));
+  BOOST_TEST(segmentLeavesHole(without.holeLayers[0], without.barrelLayers, spans, 2.F, -0.5F, 8.F, 0.F));
+}
+
+BOOST_AUTO_TEST_CASE(VertexListWithOverlappingIntervalsMatchesBruteForce)
+{
+  const std::array<VertexSeed, 2> vertices{{
+    {.timePS = 109'500U, .z = 0.F, .varZ = 1.e-4F},
+    {.timePS = 110'500U, .z = 0.01F, .varZ = 1.e-4F},
+  }};
+  verify(VertexSource::kVertexList, vertices, false);
+}
+
+BOOST_AUTO_TEST_CASE(VertexListWithDisjointIntervalsMatchesBruteForce)
+{
+  const std::array<VertexSeed, 2> vertices{{
+    {.timePS = 109'500U, .z = 0.F, .varZ = 1.e-4F},
+    {.timePS = 110'500U, .z = 1.F, .varZ = 1.e-4F},
+  }};
+  verify(VertexSource::kVertexList, vertices, false);
+}
+
+BOOST_AUTO_TEST_CASE(VertexListBeyondCacheMatchesBruteForceAndSerialOrder)
+{
+  const std::array<VertexSeed, 4> vertices{{
+    {.timePS = 109'400U, .z = 1.2F},
+    {.timePS = 109'700U, .z = 1.2F},
+    {.timePS = 110'000U, .z = 0.F},
+    {.timePS = 110'300U, .z = -1.F},
+  }};
+  verify(VertexSource::kVertexList, vertices);
+}
+
+/// A halo source works only within the gate's window of box starts; a core
+/// source always does. Every fixture row's box starts at 92 ns.
+BOOST_AUTO_TEST_CASE(TheSourceGateSkipsHaloSourcesOutsideItsWindow)
+{
+  Fixture fixture;
+  const IterationSettings settings{.windows = windowParameters(), .vertexSource = VertexSource::kBeamLine, .minClusters = kChainClusters};
+  const std::array<double, 3> material{};
+  const auto parameters = iterationParameters<StageToy>(settings, Fixture::kBeamConstraint, scatteringTable<StageToy>(material));
+  const auto vertexWindows = vertexWindowParameters<StageToy>(parameters, settings.windows, {});
+  std::array<MeasurementRange, Sources::kLayerCount> everything{};
+  std::array<MeasurementRange, Sources::kLayerCount> nothing{};
+  for (std::size_t layer = 0; layer < everything.size(); ++layer) {
+    everything[layer] = fixture.frame->grid().layerRows(static_cast<LayerID>(layer));
+  }
+  const auto run = [&](const SourceGate& gate) {
+    const TrackletStage<StageToy> stage{parameters, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, {}, fixture.maxCandidateWidthPS, vertexWindows, fixture.used.data(), gate};
+    return runStage(fixture, stage);
+  };
+
+  const auto ungated = run({});
+  BOOST_REQUIRE(ungated->size() > 0U);
+  BOOST_TEST(sameStageOutput(*run({.core = everything.data(), .earliestPS = 200'000, .latestPS = 300'000}), *ungated));
+  BOOST_TEST(sameStageOutput(*run({.core = nothing.data(), .earliestPS = 0, .latestPS = 120'000}), *ungated));
+  BOOST_TEST(run({.core = nothing.data(), .earliestPS = 200'000, .latestPS = 300'000})->size() == 0U);
+}
+
+/// An earlier iteration's exclusive rows are neither sources nor targets; its
+/// shared ones are both.
+BOOST_AUTO_TEST_CASE(TheUsedMaskRemovesExclusiveRows)
+{
+  Fixture fixture;
+  const IterationSettings settings{.windows = windowParameters(), .vertexSource = VertexSource::kBeamLine, .minClusters = kChainClusters};
+  const std::array<double, 3> material{};
+  const auto parameters = iterationParameters<StageToy>(settings, Fixture::kBeamConstraint, scatteringTable<StageToy>(material));
+  const auto vertexWindows = vertexWindowParameters<StageToy>(parameters, settings.windows, {});
+  const auto run = [&](const std::vector<std::uint8_t>& used) {
+    const TrackletStage<StageToy> stage{parameters, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, {}, fixture.maxCandidateWidthPS, vertexWindows, used.data()};
+    return runStage(fixture, stage);
+  };
+  const auto free = run(fixture.used);
+  BOOST_REQUIRE(free->size() > 0U);
+  const auto view = free->view();
+  const auto source = view.source[0];
+  const auto target = view.target[0];
+  const auto count = [&](const Output& output, auto keep) {
+    std::size_t result = 0U;
+    for (std::uint32_t i = 0; i < output.size(); ++i) {
+      result += keep(output.view().source[i], output.view().target[i]) ? 1U : 0U;
+    }
+    return result;
+  };
+  const auto all = [](std::uint32_t, std::uint32_t) { return true; };
+
+  // Shared: nothing changes.
+  auto used = fixture.used;
+  used[source] = kShared;
+  used[target] = kShared;
+  BOOST_TEST(sameStageOutput(*run(used), *free));
+
+  // An exclusive source: its tracklets go, and only they.
+  used = fixture.used;
+  used[source] = kExclusive;
+  const auto withoutSource = run(used);
+  const auto fromSource = count(*free, [&](std::uint32_t from, std::uint32_t) { return from == source; });
+  BOOST_TEST(fromSource > 0U);
+  BOOST_TEST(count(*withoutSource, [&](std::uint32_t from, std::uint32_t to) { return from == source || to == source; }) == 0U);
+  BOOST_TEST(count(*withoutSource, all) == count(*free, [&](std::uint32_t from, std::uint32_t to) { return from != source && to != source; }));
+
+  // An exclusive target: the tracklets to it go, and only they.
+  used = fixture.used;
+  used[target] = kExclusive;
+  const auto withoutTarget = run(used);
+  BOOST_TEST(count(*withoutTarget, [&](std::uint32_t from, std::uint32_t to) { return from == target || to == target; }) == 0U);
+  BOOST_TEST(count(*withoutTarget, all) == count(*free, [&](std::uint32_t from, std::uint32_t to) { return from != target && to != target; }));
+}
+
+BOOST_AUTO_TEST_CASE(ForcedVertexCapacityOneKeepsTheSameTracklets)
+{
+  Fixture fixture;
+  const IterationSettings settings{.windows = windowParameters(), .vertexSource = VertexSource::kVertexList, .minClusters = kChainClusters};
+  const std::array<double, 3> material{};
+  const auto parameters = iterationParameters<StageToy>(settings, Fixture::kBeamConstraint, scatteringTable<StageToy>(material));
+  // Beyond the beam spot's 1.5 cm reach and compatible in time: not used, so
+  // no window has to hold it and the capacity cannot change the result.
+  std::array<VertexSeed, 5> vertices{};
+  std::ranges::copy(fixture.vertices, vertices.begin());
+  vertices.back() = {.timePS = 110'200U, .z = 5.F};
+  std::ranges::sort(vertices, {}, &VertexSeed::timePS);
+  const auto vertexWindows = vertexWindowParameters<StageToy>(parameters, settings.windows, vertices);
+  const TrackletStage<StageToy> normal{parameters, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, vertices, fixture.maxCandidateWidthPS, vertexWindows, fixture.used.data()};
+  const TrackletStage<StageToy, 1U> forced{parameters, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, vertices, fixture.maxCandidateWidthPS, vertexWindows, fixture.used.data()};
+  BOOST_TEST(!vertexUsable(parameters, kRowBox, vertices[2]));
+
+  const auto normalOutput = runStage(fixture, normal);
+  const auto forcedOutput = runStage(fixture, forced);
+  BOOST_TEST(sameStageOutput(*normalOutput, *forcedOutput));
+}
+
+/// The beam-line stage makes a beam-line iteration's tracklets, and serves no
+/// other iteration.
+BOOST_AUTO_TEST_CASE(TheBeamLineStageKeepsTheSameTracklets)
+{
+  Fixture fixture;
+  const std::array<double, 3> material{};
+  const IterationSettings settings{.windows = windowParameters(), .vertexSource = VertexSource::kBeamLine, .minClusters = kChainClusters};
+  const auto parameters = iterationParameters<StageToy>(settings, Fixture::kBeamConstraint, scatteringTable<StageToy>(material));
+  const auto vertexWindows = vertexWindowParameters<StageToy>(parameters, settings.windows, {});
+  const auto run = [&](const auto& stage) { return runStage(fixture, stage); };
+  const TrackletStage<StageToy> general{parameters, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, {}, fixture.maxCandidateWidthPS, vertexWindows, fixture.used.data()};
+  const TrackletStageFor<StageToy, true> beamLine{parameters, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, {}, fixture.maxCandidateWidthPS, vertexWindows, fixture.used.data()};
+  const auto expected = run(general);
+  BOOST_REQUIRE(expected->size() > 0U);
+  BOOST_TEST(sameStageOutput(*run(beamLine), *expected));
+
+  const IterationSettings listSettings{.windows = windowParameters(), .vertexSource = VertexSource::kVertexList, .minClusters = kChainClusters};
+  const auto listParameters = iterationParameters<StageToy>(listSettings, Fixture::kBeamConstraint, scatteringTable<StageToy>(material));
+  const auto listWindows = vertexWindowParameters<StageToy>(listParameters, listSettings.windows, fixture.vertices);
+  BOOST_CHECK_THROW((TrackletStageFor<StageToy, true>{listParameters, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, fixture.vertices, fixture.maxCandidateWidthPS, listWindows, fixture.used.data()}), std::invalid_argument);
+}
+
+/// A displaced iteration: its stage makes
+/// exactly the pairs its test admits -- against every row of the target, as
+/// the windows must hold them all -- and more than the prompt stage, whose
+/// beam point admits fewer; neither stage serves the other's iteration, and
+/// a displaced iteration needs the beam line and a z bound.
+BOOST_AUTO_TEST_CASE(TheDisplacedStageMakesThePairsItsTestAdmits)
+{
+  Fixture fixture;
+  const std::array<double, 3> material{};
+  const auto table = scatteringTable<StageToy>(material);
+  auto windows = windowParameters();
+  windows.impactMax = 1.;
+  windows.impactZMax = 10.;
+  const IterationSettings settings{.windows = windows, .vertexSource = VertexSource::kBeamLine, .minClusters = kChainClusters};
+  const auto parameters = iterationParameters<StageToy>(settings, Fixture::kBeamConstraint, table);
+  const IterationSettings promptSettings{.windows = windowParameters(), .vertexSource = VertexSource::kBeamLine, .minClusters = kChainClusters};
+  const auto prompt = iterationParameters<StageToy>(promptSettings, Fixture::kBeamConstraint, table);
+  const auto vertexWindows = vertexWindowParameters<StageToy>(parameters, settings.windows, {});
+  for (std::size_t link = 0; link < StageToy::layerLinks.size(); ++link) {
+    BOOST_TEST(parameters.windows[link].phiHalfWidth >= prompt.windows[link].phiHalfWidth);
+    BOOST_TEST(std::isinf(parameters.sourceMax[link]));
+  }
+  const auto run = [&](const auto& stage) { return runStage(fixture, stage); };
+  const TrackletStageFor<StageToy, true, true> stage{parameters, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, {}, fixture.maxCandidateWidthPS, vertexWindows, fixture.used.data()};
+  const auto output = run(stage);
+  const auto view = std::as_const(*output).view();
+  std::size_t admitted = 0U;
+  for (Sources::Index sourceElement = 0; sourceElement < fixture.sources.size(); ++sourceElement) {
+    const auto sourceAt = fixture.sources.row(sourceElement);
+    const auto source = fixture.frame->measurement(sourceAt.row);
+    const auto sourcePoint = pairPoint(source);
+    std::vector<std::pair<std::size_t, std::uint32_t>> expected;
+    for (auto at = outLinks<StageToy>.begin(sourceAt.layer); at < outLinks<StageToy>.end(sourceAt.layer); ++at) {
+      const std::size_t link = outLinks<StageToy>.links[at];
+      const auto targets = fixture.frame->grid().layerRows(StageToy::layerLinks[link].to);
+      const Scalar scattering = sourceScattering<StageToy>(parameters.scattering, parameters.pairCut, fixture.beamLine, sourceAt.layer, sourcePoint);
+      for (auto targetRow = targets.begin; targetRow < targets.end; ++targetRow) {
+        const auto target = fixture.frame->measurement(targetRow);
+        if (!timeBox(source).isCompatible(timeBox(target)) || segmentLeavesHole(parameters.holeLayers[link], parameters.barrelLayers, parameters.layerSpans, source.r, source.z, target.r, target.z)) {
+          continue;
+        }
+        const auto result = displacedPairOf(parameters, fixture.beamLine, sourcePoint, scattering, pairPoint(target), 0.F);
+        if (result.transverse && result.longitudinal) {
+          expected.emplace_back(link, targetRow);
+        }
+      }
+    }
+    std::vector<std::pair<std::size_t, std::uint32_t>> emitted;
+    for (auto at = output->offsets()[sourceElement]; at < output->offsets()[sourceElement + 1U]; ++at) {
+      emitted.emplace_back(view[at].link, view[at].target);
+    }
+    std::ranges::sort(expected);
+    std::ranges::sort(emitted);
+    BOOST_TEST((emitted == expected));
+    admitted += expected.size();
+  }
+  BOOST_TEST(admitted == output->size());
+  const TrackletStageFor<StageToy, true> promptStage{prompt, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, {}, fixture.maxCandidateWidthPS, vertexWindows, fixture.used.data()};
+  BOOST_TEST(output->size() > run(promptStage)->size());
+
+  BOOST_CHECK_THROW((TrackletStageFor<StageToy, true>{parameters, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, {}, fixture.maxCandidateWidthPS, vertexWindows, fixture.used.data()}), std::invalid_argument);
+  BOOST_CHECK_THROW((TrackletStageFor<StageToy, true, true>{prompt, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, {}, fixture.maxCandidateWidthPS, vertexWindows, fixture.used.data()}), std::invalid_argument);
+  auto noZ = settings;
+  noZ.windows.impactZMax = 0.;
+  BOOST_CHECK_THROW(static_cast<void>(iterationParameters<StageToy>(noZ, Fixture::kBeamConstraint, table)), std::invalid_argument);
+  auto list = settings;
+  list.vertexSource = VertexSource::kVertexList;
+  BOOST_CHECK_THROW(static_cast<void>(iterationParameters<StageToy>(list, Fixture::kBeamConstraint, table)), std::invalid_argument);
+}
+
+/// A stage bound to copies of its inputs -- what a device run binds to --
+/// gives the same tracklets, reads the copies and nothing else, and leaves
+/// the stage it was bound from untouched.
+BOOST_AUTO_TEST_CASE(ABoundStageReadsItsBindingsOnly)
+{
+  Fixture fixture;
+  for (const auto vertexSource : {VertexSource::kBeamLine, VertexSource::kVertexList}) {
+    const IterationSettings settings{.windows = windowParameters(), .vertexSource = vertexSource, .minClusters = kChainClusters};
+    const std::array<double, 3> material{};
+    const auto parameters = iterationParameters<StageToy>(settings, Fixture::kBeamConstraint, scatteringTable<StageToy>(material));
+    const auto vertexWindows = vertexWindowParameters<StageToy>(parameters, settings.windows, fixture.vertices);
+    const std::array<MeasurementRange, Sources::kLayerCount> nothing{};
+    const SourceGate gate{.core = nothing.data(), .earliestPS = 0, .latestPS = 120'000};
+    const TrackletStage<StageToy> stage{parameters, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, fixture.vertices, fixture.maxCandidateWidthPS, vertexWindows, fixture.used.data(), gate};
+    const auto run = [&](const auto& generator) {
+      auto output = std::make_unique<Output>();
+      output->setMemoryPool(std::make_shared<BoundedMemoryResource>());
+      output->prepare(fixture.sources.size());
+      BOOST_REQUIRE(runSerial(*output, generator) == StageStatus::kComplete);
+      return output;
+    };
+    const auto reference = run(stage);
+    BOOST_REQUIRE(reference->size() > 0U);
+
+    // Copies of everything the stage reads, at other addresses.
+    const auto parametersCopy = std::make_unique<IterationParameters<StageToy>>(parameters);
+    const auto sourcesCopy = std::make_unique<Sources>(fixture.sources);
+    const auto frameCopy = std::make_unique<Frame>(*fixture.frame);
+    const auto windowsCopy = std::make_unique<VertexWindowParameters<StageToy>>(vertexWindows);
+    // The vertices the stage reads, as its iteration chose: the beam line or the list.
+    const std::vector<VertexSeed> verticesCopy = vertexSource == VertexSource::kBeamLine ? std::vector<VertexSeed>{fixture.beamLine} : std::vector<VertexSeed>(fixture.vertices.begin(), fixture.vertices.end());
+    const auto coreCopy = nothing;
+    auto usedCopy = fixture.used;
+    const TrackletBindings<StageToy> bindings{
+      .parameters = parametersCopy.get(),
+      .sources = sourcesCopy.get(),
+      .frame = frameCopy.get(),
+      .used = usedCopy.data(),
+      .vertexWindows = windowsCopy.get(),
+      .vertices = verticesCopy.data(),
+      .gateCore = coreCopy.data(),
+    };
+    const auto bound = stage.bind(bindings);
+    BOOST_TEST(sameStageOutput(*run(bound), *reference));
+
+    // The bound stage reads the copied mask, the original the fixture's.
+    std::ranges::fill(usedCopy, kExclusive);
+    BOOST_TEST(run(bound)->size() == 0U);
+    BOOST_TEST(sameStageOutput(*run(stage), *reference));
+
+    // A binding without an input the stage reads is refused.
+    auto missing = bindings;
+    missing.gateCore = nullptr;
+    BOOST_CHECK_THROW(static_cast<void>(stage.bind(missing)), std::invalid_argument);
+    missing = bindings;
+    missing.vertices = nullptr;
+    BOOST_CHECK_THROW(static_cast<void>(stage.bind(missing)), std::invalid_argument);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(CpuStageMatchesTheSerialReference)
+{
+  Fixture fixture;
+  BOOST_REQUIRE(fixture.sources.size() > 64U);
+  for (const auto vertexSource : {VertexSource::kBeamLine, VertexSource::kVertexList}) {
+    const IterationSettings settings{.windows = windowParameters(), .vertexSource = vertexSource, .minClusters = kChainClusters};
+    const std::array<double, 3> material{};
+    const auto parameters = iterationParameters<StageToy>(settings, Fixture::kBeamConstraint, scatteringTable<StageToy>(material));
+    const auto vertexWindows = vertexWindowParameters<StageToy>(parameters, settings.windows, fixture.vertices);
+    const TrackletStage<StageToy> stage{parameters, fixture.sources, *fixture.frame, fixture.geometry.allBlocks(), fixture.beamLine, fixture.vertices, fixture.maxCandidateWidthPS, vertexWindows, fixture.used.data()};
+
+    Output serial;
+    serial.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    serial.prepare(fixture.sources.size());
+    BOOST_REQUIRE((runSerial(serial, stage) == StageStatus::kComplete));
+    BOOST_REQUIRE(serial.size() > 0U);
+
+    for (const int threads : {1, 2, 4}) {
+      for (const Output::Index chunk : {1U, 3U, 8U, 17U, 64U}) {
+        Output parallel;
+        const auto parallelPool = std::make_shared<BoundedMemoryResource>();
+        parallel.setMemoryPool(parallelPool);
+        parallel.prepare(fixture.sources.size());
+        detail::TaskArena cpuArena{threads};
+        Cpu cpu{cpuArena};
+        cpu.setMemoryPool(parallelPool);
+        const auto status = cpu.run(parallel, chunk, stage);
+        BOOST_REQUIRE_MESSAGE(status == StageStatus::kComplete, "vertex source " << static_cast<int>(vertexSource) << ", threads " << threads << ", chunk " << chunk);
+        BOOST_TEST(sameStageOutput(parallel, serial), "vertex source " << static_cast<int>(vertexSource) << ", threads " << threads << ", chunk " << chunk);
+      }
+    }
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testTripletEndIndex.cxx b/Detectors/GenericTracking/tracking/test/testTripletEndIndex.cxx
new file mode 100644
index 0000000000000..a96d1afd8da42
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testTripletEndIndex.cxx
@@ -0,0 +1,178 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTripletEndIndex.cxx
+/// \brief The index from a tracklet to the triplets ending with it, against a
+///        brute-force scan of the triplet arena.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK TripletEndIndex
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/TripletEndIndex.h"
+
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Tracking/Neighbour.h"
+#include "SerialReferences.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+#include <limits>
+#include <memory>
+#include <random>
+#include <span>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using Triplets = StageOutput<TripletT>;
+using Index = TripletEndIndex::Index;
+constexpr Index kAnyChunks = std::numeric_limits<Index>::max();
+
+/// The triplets whose second tracklet is \a tracklet, in arena order.
+std::span<const Index> ending(const TripletEndIndex& index, Index tracklet) { return {index.triplets() + index.offsets()[tracklet], index.offsets()[tracklet + 1U] - index.offsets()[tracklet]}; }
+
+/// A triplet arena whose element `e` emits the triplets `(first, second)` of
+/// \a records[e].
+void fill(Triplets& triplets, const std::vector<std::vector<std::pair<Index, Index>>>& records)
+{
+  triplets.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  triplets.prepare(static_cast<Index>(records.size()));
+  const auto status = runSerial(triplets, [&](Index element, auto& emitter) {
+    for (const auto& [first, second] : records[element]) {
+      emitter.emit(Triplet{first, second, 0.F, 0.F, 1U, 0U});
+    }
+  });
+  BOOST_REQUIRE(status == StageStatus::kComplete);
+}
+
+/// Every tracklet's range holds exactly the triplets ending with it, in
+/// arena order.
+void checkAgainstBruteForce(const TripletEndIndex& index, Index trackletCount, const Triplets& triplets)
+{
+  const auto view = triplets.view();
+  BOOST_REQUIRE(index.offsets()[trackletCount] == triplets.size());
+  for (Index tracklet = 0; tracklet < trackletCount; ++tracklet) {
+    std::vector<Index> expected;
+    for (Index triplet = 0; triplet < triplets.size(); ++triplet) {
+      if (view.second[triplet] == tracklet) {
+        expected.push_back(triplet);
+      }
+    }
+    const auto range = ending(index, tracklet);
+    BOOST_TEST_CONTEXT("tracklet " << tracklet)
+    {
+      BOOST_TEST(std::vector<Index>(range.begin(), range.end()) == expected, boost::test_tools::per_element());
+      BOOST_TEST(index.offsets()[tracklet + 1U] - index.offsets()[tracklet] == range.size());
+    }
+  }
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(RangesHoldTheTripletsEndingWithEachTracklet)
+{
+  // Tracklet 4 ends three triplets, from two elements; 0, 2, 5 and 6 end none.
+  Triplets triplets;
+  fill(triplets, {{{0, 4}, {0, 3}}, {}, {{1, 4}, {2, 1}, {3, 4}}, {{5, 3}}});
+  TripletEndIndex index;
+  index.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  BOOST_REQUIRE(index.build(7U, triplets, SerialForEach{}, kAnyChunks) == StageStatus::kComplete);
+  checkAgainstBruteForce(index, 7U, triplets);
+  const auto four = ending(index, 4U);
+  BOOST_TEST(std::vector<Index>(four.begin(), four.end()) == (std::vector<Index>{0U, 2U, 4U}), boost::test_tools::per_element());
+  BOOST_TEST(ending(index, 6U).empty());
+}
+
+BOOST_AUTO_TEST_CASE(ALargerArenaAndARebuild)
+{
+  constexpr Index kTracklets = 97U;
+  std::vector<std::vector<std::pair<Index, Index>>> records(40U);
+  for (Index element = 0; element < records.size(); ++element) {
+    for (Index k = 0; k < element % 7U; ++k) {
+      records[element].emplace_back(element, ((element * 31U) + (k * 17U)) % kTracklets);
+    }
+  }
+  Triplets triplets;
+  fill(triplets, records);
+  TripletEndIndex index;
+  index.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  BOOST_REQUIRE(index.build(kTracklets, triplets, SerialForEach{}, kAnyChunks) == StageStatus::kComplete);
+  checkAgainstBruteForce(index, kTracklets, triplets);
+
+  // A second build over a smaller slice replaces the first.
+  Triplets smaller;
+  fill(smaller, {{{0, 2}}, {{1, 0}, {1, 2}}});
+  BOOST_REQUIRE(index.build(3U, smaller, SerialForEach{}, kAnyChunks) == StageStatus::kComplete);
+  checkAgainstBruteForce(index, 3U, smaller);
+}
+
+BOOST_AUTO_TEST_CASE(NoTriplets)
+{
+  Triplets triplets;
+  fill(triplets, {{}, {}});
+  TripletEndIndex index;
+  index.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  BOOST_REQUIRE(index.build(5U, triplets, SerialForEach{}, kAnyChunks) == StageStatus::kComplete);
+  BOOST_TEST(index.offsets()[5U] == 0U);
+  checkAgainstBruteForce(index, 5U, triplets);
+}
+
+/// The two-level sort on the host threads gives the one-thread build's index
+/// byte for byte, at 1, 3 and 8 threads, over arenas from empty to several
+/// chunks and buckets, each checked against the brute force where that is
+/// quick.
+BOOST_AUTO_TEST_CASE(ParallelBuildEqualsSerialBuild)
+{
+  std::mt19937 engine{12345U};
+  for (const auto& [elements, perElement, tracklets] : std::initializer_list<std::tuple<Index, Index, Index>>{{0U, 0U, 1U}, {1U, 1U, 1U}, {300U, 3U, 50U}, {700U, 4U, TripletEndIndex::kBucketTracklets}, {5000U, 7U, 9000U}, {40000U, 5U, 12345U}}) {
+    std::vector<std::vector<std::pair<Index, Index>>> records(elements);
+    std::uniform_int_distribution<Index> second{0U, tracklets - 1U};
+    for (Index element = 0; element < elements; ++element) {
+      const auto emitted = static_cast<Index>(engine() % (perElement + 1U));
+      for (Index k = 0; k < emitted; ++k) {
+        records[element].emplace_back(element, second(engine));
+      }
+    }
+    Triplets triplets;
+    fill(triplets, records);
+    TripletEndIndex serial;
+    serial.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    BOOST_REQUIRE(serial.build(tracklets, triplets, SerialForEach{}, kAnyChunks) == StageStatus::kComplete);
+    if (static_cast<std::uint64_t>(tracklets) * triplets.size() < 20000000U) {
+      checkAgainstBruteForce(serial, tracklets, triplets);
+    }
+    // The chunks bounded as the tracker bounds them, to one, or not at all.
+    for (const auto& [threads, maxChunks] : std::initializer_list<std::pair<int, Index>>{{1, 0U}, {3, 0U}, {8, 0U}, {3, 1U}, {8, 64U}}) {
+      BOOST_TEST_CONTEXT("elements " << elements << ", tracklets " << tracklets << ", threads " << threads << ", chunks at most " << maxChunks)
+      {
+        detail::TaskArena cpuArena{threads};
+        CpuStage<NeighbourT> cpu{cpuArena};
+        TripletEndIndex parallel;
+        parallel.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+        const auto forEach = [&](Index count, const auto& body) { cpu.forEachElement(count, 1U, body); };
+        BOOST_REQUIRE(parallel.build(tracklets, triplets, forEach, maxChunks == 0U ? kAnyChunks : maxChunks) == StageStatus::kComplete);
+        BOOST_TEST(parallel.offsets()[tracklets] == serial.offsets()[tracklets]);
+        BOOST_TEST(std::vector<Index>(parallel.offsets(), parallel.offsets() + tracklets + 1U) == std::vector<Index>(serial.offsets(), serial.offsets() + tracklets + 1U), boost::test_tools::per_element());
+        BOOST_TEST(std::vector<Index>(parallel.triplets(), parallel.triplets() + parallel.offsets()[tracklets]) == std::vector<Index>(serial.triplets(), serial.triplets() + serial.offsets()[tracklets]), boost::test_tools::per_element());
+      }
+    }
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testTripletFit.cxx b/Detectors/GenericTracking/tracking/test/testTripletFit.cxx
new file mode 100644
index 0000000000000..79bcaa8cf6c4c
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testTripletFit.cxx
@@ -0,0 +1,530 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTripletFit.cxx
+/// \brief The copied ITS triplet geometry, the kinks' gradient by hand, the
+///        covariance and the fit.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Triplet Fit
+#include <boost/test/unit_test.hpp>
+
+#include "ToyBarrel4Disc8.h"
+#include "Oracles.h"
+#include "GenericTracking/Tracking/Triplet.h"
+#include "GenericTracking/Tracking/TripletFit.h"
+#include "GenericTracking/Study/Validation.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <random>
+#include <cstddef>
+#include <cstdint>
+
+namespace o2::gtrk
+{
+namespace
+{
+
+constexpr std::size_t kCoordinates = 9U;
+
+// The reference below is ITS's makeTripletFitFactor geometry, kept in its
+// original nine-derivative form so it is independent of GTRK's gradient,
+// and evaluated in double: the float port is compared with the true value,
+// not with a second float evaluation whose rounding differs.
+struct ReferenceDual {
+  double value = 0.;
+  std::array<double, kCoordinates> derivative{};
+
+  ReferenceDual() = default;
+  explicit ReferenceDual(double valueIn) : value(valueIn) {}
+
+  static ReferenceDual variable(double value, std::size_t coordinate)
+  {
+    ReferenceDual result{value};
+    result.derivative[coordinate] = 1.;
+    return result;
+  }
+};
+
+ReferenceDual operator+(const ReferenceDual& left, const ReferenceDual& right)
+{
+  ReferenceDual result{left.value + right.value};
+  for (std::size_t i = 0; i < kCoordinates; ++i) {
+    result.derivative[i] = left.derivative[i] + right.derivative[i];
+  }
+  return result;
+}
+
+ReferenceDual operator-(const ReferenceDual& left, const ReferenceDual& right)
+{
+  ReferenceDual result{left.value - right.value};
+  for (std::size_t i = 0; i < kCoordinates; ++i) {
+    result.derivative[i] = left.derivative[i] - right.derivative[i];
+  }
+  return result;
+}
+
+ReferenceDual operator*(const ReferenceDual& left, const ReferenceDual& right)
+{
+  ReferenceDual result{left.value * right.value};
+  for (std::size_t i = 0; i < kCoordinates; ++i) {
+    result.derivative[i] = left.derivative[i] * right.value + left.value * right.derivative[i];
+  }
+  return result;
+}
+
+ReferenceDual operator/(const ReferenceDual& left, const ReferenceDual& right)
+{
+  const double inverse = 1. / right.value;
+  ReferenceDual result{left.value * inverse};
+  for (std::size_t i = 0; i < kCoordinates; ++i) {
+    result.derivative[i] = (left.derivative[i] - result.value * right.derivative[i]) * inverse;
+  }
+  return result;
+}
+
+ReferenceDual referenceSqrt(const ReferenceDual& argument)
+{
+  const double root = std::sqrt(argument.value);
+  ReferenceDual result{root};
+  for (std::size_t i = 0; i < kCoordinates; ++i) {
+    result.derivative[i] = 0.5 * argument.derivative[i] / root;
+  }
+  return result;
+}
+
+ReferenceDual referenceAsin(const ReferenceDual& argument)
+{
+  ReferenceDual result{std::asin(argument.value)};
+  const double scale = 1. / std::sqrt(1. - argument.value * argument.value);
+  for (std::size_t i = 0; i < kCoordinates; ++i) {
+    result.derivative[i] = scale * argument.derivative[i];
+  }
+  return result;
+}
+
+ReferenceDual referenceAtan2(const ReferenceDual& y, const ReferenceDual& x)
+{
+  ReferenceDual result{std::atan2(y.value, x.value)};
+  const double denominator = x.value * x.value + y.value * y.value;
+  for (std::size_t i = 0; i < kCoordinates; ++i) {
+    result.derivative[i] = (x.value * y.derivative[i] - y.value * x.derivative[i]) / denominator;
+  }
+  return result;
+}
+
+struct ReferenceSegment {
+  ReferenceDual bendingAngle;
+  ReferenceDual transverseArcLength;
+  ReferenceDual cotangentTheta;
+  ReferenceDual sineTheta;
+  ReferenceDual cosineTheta;
+  ReferenceDual index;
+};
+
+ReferenceSegment referenceSegment(const ReferenceDual& curvature, const ReferenceDual& chord, const ReferenceDual& deltaZ)
+{
+  const ReferenceDual halfSine = ReferenceDual{0.5} * curvature * chord;
+  const ReferenceDual halfSine2 = halfSine * halfSine;
+  const ReferenceDual halfSine4 = halfSine2 * halfSine2;
+  const ReferenceDual halfAngle = referenceAsin(halfSine);
+  ReferenceDual asinOverArgument;
+  ReferenceDual angleCotangent;
+  if (std::abs(halfSine.value) < 1.e-4) {
+    asinOverArgument = ReferenceDual{1.} + halfSine2 * ReferenceDual{1. / 6.} + halfSine4 * ReferenceDual{3. / 40.};
+    angleCotangent = ReferenceDual{1.} - halfSine2 * ReferenceDual{1. / 3.} - halfSine4 * ReferenceDual{2. / 15.};
+  } else {
+    asinOverArgument = halfAngle / halfSine;
+    angleCotangent = halfAngle * referenceSqrt(ReferenceDual{1.} - halfSine2) / halfSine;
+  }
+  const ReferenceDual arc = chord * asinOverArgument;
+  const ReferenceDual cotangent = deltaZ / arc;
+  const ReferenceDual sine = ReferenceDual{1.} / referenceSqrt(ReferenceDual{1.} + cotangent * cotangent);
+  const ReferenceDual cosine = cotangent * sine;
+  const ReferenceDual index = ReferenceDual{1.} / (angleCotangent * sine * sine + cosine * cosine);
+  return {
+    .bendingAngle = ReferenceDual{2.} * halfAngle,
+    .transverseArcLength = arc,
+    .cotangentTheta = cotangent,
+    .sineTheta = sine,
+    .cosineTheta = cosine,
+    .index = index,
+  };
+}
+
+struct ReferenceGeometry {
+  ReferenceDual theta;
+  ReferenceDual phi;
+  ReferenceDual rhoTheta;
+  ReferenceDual rhoPhi;
+};
+
+ReferenceGeometry referenceGeometry(const std::array<PairPoint, 3>& measurements)
+{
+  std::array<std::array<ReferenceDual, 3>, 3> point{};
+  for (std::size_t hit = 0; hit < measurements.size(); ++hit) {
+    const double position[3]{static_cast<double>(measurements[hit].x), static_cast<double>(measurements[hit].y), static_cast<double>(measurements[hit].z)};
+    for (std::size_t coordinate = 0; coordinate < 3U; ++coordinate) {
+      point[hit][coordinate] = ReferenceDual::variable(position[coordinate], 3U * hit + coordinate);
+    }
+  }
+  const ReferenceDual dx01 = point[1][0] - point[0][0];
+  const ReferenceDual dy01 = point[1][1] - point[0][1];
+  const ReferenceDual dz01 = point[1][2] - point[0][2];
+  const ReferenceDual dx12 = point[2][0] - point[1][0];
+  const ReferenceDual dy12 = point[2][1] - point[1][1];
+  const ReferenceDual dz12 = point[2][2] - point[1][2];
+  const ReferenceDual dx02 = point[2][0] - point[0][0];
+  const ReferenceDual dy02 = point[2][1] - point[0][1];
+  const ReferenceDual length01 = referenceSqrt(dx01 * dx01 + dy01 * dy01);
+  const ReferenceDual length12 = referenceSqrt(dx12 * dx12 + dy12 * dy12);
+  const ReferenceDual length02 = referenceSqrt(dx02 * dx02 + dy02 * dy02);
+  const ReferenceDual transverseCurvature = ReferenceDual{2.} * (dx01 * dy12 - dy01 * dx12) / (length01 * length12 * length02);
+  const auto first = referenceSegment(transverseCurvature, length01, dz01);
+  const auto second = referenceSegment(transverseCurvature, length12, dz12);
+  const ReferenceDual theta01 = referenceAtan2(first.transverseArcLength, dz01);
+  const ReferenceDual theta12 = referenceAtan2(second.transverseArcLength, dz12);
+  const ReferenceDual phi = ReferenceDual{0.5} * (first.bendingAngle * first.index + second.bendingAngle * second.index);
+  const ReferenceDual theta = theta12 - theta01 + (ReferenceDual{1.} - second.index) * second.cotangentTheta - (ReferenceDual{1.} - first.index) * first.cotangentTheta;
+  const ReferenceDual rhoPhi = ReferenceDual{-0.5} * (first.transverseArcLength * first.index / first.sineTheta + second.transverseArcLength * second.index / second.sineTheta);
+  ReferenceDual rhoTheta;
+  const double maximumHalfSine = 0.5 * std::abs(transverseCurvature.value) * std::max(length01.value, length12.value);
+  if (maximumHalfSine < 1.e-4) {
+    rhoTheta = transverseCurvature * (length12 * length12 * second.cosineTheta - length01 * length01 * first.cosineTheta) / ReferenceDual{12.};
+  } else {
+    rhoTheta = ((ReferenceDual{1.} - first.index) * first.cotangentTheta / first.sineTheta - (ReferenceDual{1.} - second.index) * second.cotangentTheta / second.sineTheta) / transverseCurvature;
+  }
+  return {.theta = theta, .phi = phi, .rhoTheta = rhoTheta, .rhoPhi = rhoPhi};
+}
+
+struct ReferenceFactor {
+  TripletKinkVector psi;
+  TripletKinkVector rho;
+  TripletKinkCovariance covariance;
+};
+
+ReferenceFactor referenceFactor(const std::array<PairPoint, 3>& points, Scalar angularVariance)
+{
+  const auto geometry = referenceGeometry(points);
+  const Scalar kappaReference = -static_cast<Scalar>(geometry.phi.value) / static_cast<Scalar>(geometry.rhoPhi.value);
+  const Scalar dx = points[2].x - points[0].x;
+  const Scalar dy = points[2].y - points[0].y;
+  const Scalar dz = points[2].z - points[0].z;
+  const Scalar transverse2 = dx * dx + dy * dy;
+  const Scalar sineTheta2 = transverse2 / (transverse2 + dz * dz);
+  ReferenceFactor result{
+    .psi = {.theta = static_cast<Scalar>(geometry.theta.value), .phi = static_cast<Scalar>(geometry.phi.value)},
+    .rho = {.theta = static_cast<Scalar>(geometry.rhoTheta.value), .phi = static_cast<Scalar>(geometry.rhoPhi.value)},
+    .covariance = {.thetaTheta = angularVariance, .thetaPhi = 0.F, .phiPhi = angularVariance / sineTheta2},
+  };
+  for (std::size_t hit = 0; hit < points.size(); ++hit) {
+    const Scalar inverseR = 1.F / points[hit].r;
+    const Scalar radialX = points[hit].x * inverseR;
+    const Scalar radialY = points[hit].y * inverseR;
+    const Scalar tangentX = -points[hit].y * inverseR;
+    const Scalar tangentY = points[hit].x * inverseR;
+    const std::size_t coordinate = 3U * hit;
+    const Scalar thetaX = static_cast<Scalar>(geometry.theta.derivative[coordinate]) + kappaReference * static_cast<Scalar>(geometry.rhoTheta.derivative[coordinate]);
+    const Scalar thetaY = static_cast<Scalar>(geometry.theta.derivative[coordinate + 1U]) + kappaReference * static_cast<Scalar>(geometry.rhoTheta.derivative[coordinate + 1U]);
+    const Scalar thetaZ = static_cast<Scalar>(geometry.theta.derivative[coordinate + 2U]) + kappaReference * static_cast<Scalar>(geometry.rhoTheta.derivative[coordinate + 2U]);
+    const Scalar phiX = static_cast<Scalar>(geometry.phi.derivative[coordinate]) + kappaReference * static_cast<Scalar>(geometry.rhoPhi.derivative[coordinate]);
+    const Scalar phiY = static_cast<Scalar>(geometry.phi.derivative[coordinate + 1U]) + kappaReference * static_cast<Scalar>(geometry.rhoPhi.derivative[coordinate + 1U]);
+    const Scalar phiZ = static_cast<Scalar>(geometry.phi.derivative[coordinate + 2U]) + kappaReference * static_cast<Scalar>(geometry.rhoPhi.derivative[coordinate + 2U]);
+    const Scalar thetaRadial = thetaX * radialX + thetaY * radialY;
+    const Scalar phiRadial = phiX * radialX + phiY * radialY;
+    const Scalar thetaTangent = thetaX * tangentX + thetaY * tangentY;
+    const Scalar phiTangent = phiX * tangentX + phiY * tangentY;
+    const Scalar variance[3]{points[hit].varR, points[hit].varRPhi, points[hit].varZ};
+    const Scalar thetaDerivative[3]{thetaRadial, thetaTangent, thetaZ};
+    const Scalar phiDerivative[3]{phiRadial, phiTangent, phiZ};
+    for (std::size_t axis = 0; axis < 3U; ++axis) {
+      result.covariance.thetaTheta += variance[axis] * thetaDerivative[axis] * thetaDerivative[axis];
+      result.covariance.thetaPhi += variance[axis] * thetaDerivative[axis] * phiDerivative[axis];
+      result.covariance.phiPhi += variance[axis] * phiDerivative[axis] * phiDerivative[axis];
+    }
+  }
+  return result;
+}
+
+struct ReferenceFit {
+  double curvature = 0.;
+  double varCurvature = 0.;
+  double chi2 = 0.;
+};
+
+/// ITS's fitAdjacentTripletFactors, in double: each triplet's nine-coordinate
+/// gradients at its own reference curvature, projected on the measurement
+/// axes and summed into one 4x4 kink covariance over the four hits, then
+/// solved by Gauss-Jordan elimination.
+ReferenceFit referenceAdjacentFit(const std::array<PairPoint, 4>& points, double varianceSecond, double varianceThird)
+{
+  const std::array<ReferenceGeometry, 2> geometry{referenceGeometry({points[0], points[1], points[2]}), referenceGeometry({points[1], points[2], points[3]})};
+  const std::array<double, 4> psi{geometry[0].theta.value, geometry[0].phi.value, geometry[1].theta.value, geometry[1].phi.value};
+  const std::array<double, 4> rho{geometry[0].rhoTheta.value, geometry[0].rhoPhi.value, geometry[1].rhoTheta.value, geometry[1].rhoPhi.value};
+  const auto sine2 = [&](std::size_t from, std::size_t to) {
+    const double dx = static_cast<double>(points[to].x) - static_cast<double>(points[from].x);
+    const double dy = static_cast<double>(points[to].y) - static_cast<double>(points[from].y);
+    const double dz = static_cast<double>(points[to].z) - static_cast<double>(points[from].z);
+    return (dx * dx + dy * dy) / (dx * dx + dy * dy + dz * dz);
+  };
+  std::array<std::array<double, 4>, 4> covariance{};
+  covariance[0][0] = varianceSecond;
+  covariance[1][1] = varianceSecond / sine2(0, 2);
+  covariance[2][2] = varianceThird;
+  covariance[3][3] = varianceThird / sine2(1, 3);
+  for (std::size_t hit = 0; hit < points.size(); ++hit) {
+    const double r = std::hypot(static_cast<double>(points[hit].x), static_cast<double>(points[hit].y));
+    const double radialX = static_cast<double>(points[hit].x) / r;
+    const double radialY = static_cast<double>(points[hit].y) / r;
+    // gradient[kink][axis], axes radial, r-phi, z
+    std::array<std::array<double, 3>, 4> gradient{};
+    for (std::size_t triplet = 0; triplet < 2U; ++triplet) {
+      if (hit < triplet || hit > triplet + 2U) {
+        continue;
+      }
+      const auto& g = geometry[triplet];
+      const double kappa = -g.phi.value / g.rhoPhi.value;
+      const std::size_t coordinate = 3U * (hit - triplet);
+      for (std::size_t angle = 0; angle < 2U; ++angle) {
+        const auto& kink = angle == 0U ? g.theta : g.phi;
+        const auto& slope = angle == 0U ? g.rhoTheta : g.rhoPhi;
+        const double dX = kink.derivative[coordinate] + kappa * slope.derivative[coordinate];
+        const double dY = kink.derivative[coordinate + 1U] + kappa * slope.derivative[coordinate + 1U];
+        const double dZ = kink.derivative[coordinate + 2U] + kappa * slope.derivative[coordinate + 2U];
+        gradient[2U * triplet + angle] = {dX * radialX + dY * radialY, -dX * radialY + dY * radialX, dZ};
+      }
+    }
+    const std::array<double, 3> variance{static_cast<double>(points[hit].varR), static_cast<double>(points[hit].varRPhi), static_cast<double>(points[hit].varZ)};
+    for (std::size_t row = 0; row < 4U; ++row) {
+      for (std::size_t column = 0; column < 4U; ++column) {
+        for (std::size_t axis = 0; axis < 3U; ++axis) {
+          covariance[row][column] += variance[axis] * gradient[row][axis] * gradient[column][axis];
+        }
+      }
+    }
+  }
+  // [V | psi | rho] reduced to [1 | V^-1 psi | V^-1 rho]
+  std::array<std::array<double, 6>, 4> augmented{};
+  for (std::size_t row = 0; row < 4U; ++row) {
+    for (std::size_t column = 0; column < 4U; ++column) {
+      augmented[row][column] = covariance[row][column];
+    }
+    augmented[row][4] = psi[row];
+    augmented[row][5] = rho[row];
+  }
+  for (std::size_t pivot = 0; pivot < 4U; ++pivot) {
+    const double scale = augmented[pivot][pivot];
+    for (auto& entry : augmented[pivot]) {
+      entry /= scale;
+    }
+    for (std::size_t row = 0; row < 4U; ++row) {
+      if (row != pivot) {
+        const double factor = augmented[row][pivot];
+        for (std::size_t column = 0; column < 6U; ++column) {
+          augmented[row][column] -= factor * augmented[pivot][column];
+        }
+      }
+    }
+  }
+  double psiPsi = 0.;
+  double rhoPsi = 0.;
+  double rhoRho = 0.;
+  for (std::size_t row = 0; row < 4U; ++row) {
+    psiPsi += psi[row] * augmented[row][4];
+    rhoPsi += rho[row] * augmented[row][4];
+    rhoRho += rho[row] * augmented[row][5];
+  }
+  return {.curvature = -rhoPsi / rhoRho, .varCurvature = 1. / rhoRho, .chi2 = psiPsi - (rhoPsi * rhoPsi / rhoRho)};
+}
+
+PairPoint helixPoint(double curvature, double arc, double cotangentTheta)
+{
+  const double turn = curvature * arc;
+  const double x = std::sin(turn) / curvature;
+  const double y = (1. - std::cos(turn)) / curvature;
+  return {
+    .x = static_cast<Scalar>(x),
+    .y = static_cast<Scalar>(y),
+    .z = static_cast<Scalar>(cotangentTheta * arc),
+    .r = static_cast<Scalar>(std::hypot(x, y)),
+    .varZ = 4.e-6F,
+    .varR = 2.e-6F,
+    .varRPhi = 3.e-6F,
+  };
+}
+
+std::array<PairPoint, 3> helixPoints(double curvature, double cotangentTheta, const std::array<double, 3>& arcs) { return {helixPoint(curvature, arcs[0], cotangentTheta), helixPoint(curvature, arcs[1], cotangentTheta), helixPoint(curvature, arcs[2], cotangentTheta)}; }
+
+void checkClose(Scalar actual, Scalar expected, Scalar relativeTolerance, Scalar absoluteTolerance = 0.F)
+{
+  const Scalar scale = std::max(std::abs(expected), absoluteTolerance);
+  BOOST_TEST(std::abs(actual - expected) <= relativeTolerance * scale + absoluteTolerance);
+}
+
+// An exact helix gives chi2 = 0 up to the float cancellation of psi' V^-1 psi
+// against the removed curvature term, which are of order 1e4 here; any real
+// cut is of order n^2 = 9.
+constexpr Scalar kExactHelixChi2 = 1.e-2F;
+
+/// The fit's curvature is the triplet fit's own parameter: the 3D curvature,
+/// proportional to q/p, which is the transverse curvature times sin(theta).
+void checkHelix(double ptGeV, const std::array<double, 3>& arcs, double cotangentTheta)
+{
+  constexpr double kBzKiloGauss = 5.;
+  constexpr double kB2C = 0.000299792458;
+  const double curvature = kB2C * kBzKiloGauss / ptGeV;
+  const double sineTheta = 1. / std::sqrt(1. + (cotangentTheta * cotangentTheta));
+  const auto points = helixPoints(curvature, cotangentTheta, arcs);
+  TripletFitFactor factor;
+  BOOST_REQUIRE(study::makeTripletFitFactor(points[0], points[1], points[2], 2.e-6F, factor));
+  TripletFitResult fit;
+  BOOST_REQUIRE(fitTriplet(factor, fit));
+  BOOST_TEST_CONTEXT("pT " << ptGeV << " arcs " << arcs[0] << ',' << arcs[1] << ',' << arcs[2])
+  {
+    checkClose(fit.curvature, static_cast<Scalar>(curvature * sineTheta), 3.e-3F, 2.e-7F);
+    BOOST_TEST(fit.varCurvature > 0.F);
+    BOOST_TEST(fit.chi2 < kExactHelixChi2);
+  }
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(KinkGradientMatchesTheCopiedItsFactor)
+{
+  auto points = helixPoints(0.012, 0.7, {2.1, 5.4, 9.8});
+  points[0].varR = 1.e-6F;
+  points[0].varRPhi = 2.e-6F;
+  points[0].varZ = 3.e-6F;
+  points[1].varR = 4.e-6F;
+  points[1].varRPhi = 5.e-6F;
+  points[1].varZ = 6.e-6F;
+  points[2].varR = 7.e-6F;
+  points[2].varRPhi = 8.e-6F;
+  points[2].varZ = 9.e-6F;
+  constexpr Scalar kAngularVariance = 1.7e-5F;
+  const auto reference = referenceFactor(points, kAngularVariance);
+  const auto geometry = kinkGradient(points[0], points[1], points[2]).kinks;
+  BOOST_REQUIRE(geometry.valid);
+  checkClose(geometry.psi.phi, reference.psi.phi, 2.e-5F, 1.e-7F);
+  checkClose(geometry.rho.phi, reference.rho.phi, 2.e-5F, 1.e-7F);
+  // The theta kink is a difference of two dip angles near one radian, and its
+  // slope a difference of `1 - index`, about (kappa d/2)^2/3 here: both cancel.
+  // Float resolves the kink, psi + kappa rho, to a few ulp of those angles.
+  constexpr Scalar kThetaKinkResolution = 5.e-7F;
+  constexpr Scalar kCurvature = 0.012F;
+  checkClose(geometry.psi.theta, reference.psi.theta, 0.F, kThetaKinkResolution);
+  checkClose(geometry.rho.theta, reference.rho.theta, 0.F, kThetaKinkResolution / kCurvature);
+
+  TripletFitFactor factor;
+  BOOST_REQUIRE(study::makeTripletFitFactor(points[0], points[1], points[2], kAngularVariance, factor));
+  checkClose(factor.covariance.thetaTheta, reference.covariance.thetaTheta, 5.e-5F, 1.e-9F);
+  checkClose(factor.covariance.thetaPhi, reference.covariance.thetaPhi, 5.e-5F, 1.e-9F);
+  checkClose(factor.covariance.phiPhi, reference.covariance.phiPhi, 5.e-5F, 1.e-9F);
+
+  const TripletFitFactor referenceFitFactor{.psi = reference.psi, .rho = reference.rho, .covariance = reference.covariance};
+  TripletFitResult actualFit;
+  TripletFitResult referenceFit;
+  BOOST_REQUIRE(fitTriplet(factor, actualFit));
+  BOOST_REQUIRE(fitTriplet(referenceFitFactor, referenceFit));
+  checkClose(actualFit.curvature, referenceFit.curvature, 5.e-5F, 1.e-8F);
+  checkClose(actualFit.varCurvature, referenceFit.varCurvature, 5.e-5F, 1.e-10F);
+  // Both are an exact helix's chi2: zero up to the same float cancellation.
+  checkClose(actualFit.chi2, referenceFit.chi2, 0.F, kExactHelixChi2);
+}
+
+BOOST_AUTO_TEST_CASE(HelixCurvatureAcrossLayerKindsAndMomenta)
+{
+  const std::array<std::array<double, 3>, 3> geometries{{{{2., 4., 7.}}, {{4., 8., 12.}}, {{2., 6., 11.}}}};
+  const double cotangents[3]{0.25, 1.5, 0.8};
+  const double momenta[3]{0.1, 1., 10.};
+  for (std::size_t geometry = 0; geometry < geometries.size(); ++geometry) {
+    for (const double momentum : momenta) {
+      checkHelix(momentum, geometries[geometry], cotangents[geometry]);
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(Chi2RespondsToAMiddleHitDisplacement)
+{
+  auto points = helixPoints(0.004, 0.6, {2., 5., 9.});
+  TripletFitFactor exactFactor;
+  BOOST_REQUIRE(study::makeTripletFitFactor(points[0], points[1], points[2], 1.e-6F, exactFactor));
+  TripletFitResult exact;
+  BOOST_REQUIRE(fitTriplet(exactFactor, exact));
+  points[1].z += 0.05F;
+  TripletFitFactor displacedFactor;
+  BOOST_REQUIRE(study::makeTripletFitFactor(points[0], points[1], points[2], 1.e-6F, displacedFactor));
+  TripletFitResult displaced;
+  BOOST_REQUIRE(fitTriplet(displacedFactor, displaced));
+  BOOST_TEST(exact.chi2 < kExactHelixChi2);
+  BOOST_TEST(displaced.chi2 > exact.chi2 + 1.F);
+}
+
+// The independent copied ITS geometry and double Gauss-Jordan solve above
+// checks a range of noisy helices, anisotropic errors and scattering scales.
+BOOST_AUTO_TEST_CASE(AdjacentFitMatchesTheDoubleOracleAcrossScales)
+{
+  std::mt19937 random{501010U};
+  std::uniform_real_distribution<double> unit{0., 1.};
+  for (int sample = 0; sample < 300; ++sample) {
+    const double curvature = (sample % 2 == 0 ? 1. : -1.) * (0.002 + 0.013 * unit(random));
+    const double cotangent = 0.1 + 7. * unit(random);
+    double arc = 2. + 5. * unit(random);
+    std::array<PairPoint, 4> points{};
+    for (auto& point : points) {
+      arc += 2. + 6. * unit(random);
+      point = helixPoint(curvature, arc, cotangent);
+      point.x += static_cast<Scalar>(0.01 * (unit(random) - 0.5));
+      point.y += static_cast<Scalar>(0.01 * (unit(random) - 0.5));
+      point.z += static_cast<Scalar>(0.03 * (unit(random) - 0.5));
+      point.r = std::hypot(point.x, point.y);
+      point.varR = static_cast<Scalar>(1.e-7 + 5.e-6 * unit(random));
+      point.varRPhi = static_cast<Scalar>(1.e-7 + 8.e-6 * unit(random));
+      point.varZ = static_cast<Scalar>(1.e-7 + 2.e-5 * unit(random));
+    }
+    const auto second = static_cast<Scalar>(std::pow(10., -8. + 4. * unit(random)));
+    const auto third = static_cast<Scalar>(std::pow(10., -8. + 4. * unit(random)));
+    const auto expected = referenceAdjacentFit(points, second, third);
+    TripletFitResult result;
+    BOOST_TEST_CONTEXT("sample " << sample)
+    {
+      BOOST_REQUIRE(fitAdjacentTriplets(points[0], points[1], points[2], points[3], second, third, result));
+      checkClose(result.curvature, static_cast<Scalar>(expected.curvature), 3.e-3F, 1.e-7F);
+      checkClose(result.varCurvature, static_cast<Scalar>(expected.varCurvature), 3.e-3F);
+      checkClose(result.chi2, static_cast<Scalar>(expected.chi2), 3.e-3F, kExactHelixChi2);
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(AdjacentFitOfAnExactHelix)
+{
+  constexpr double kCurvature = 0.008;
+  constexpr double kCotangent = 1.2;
+  const std::array<PairPoint, 4> points{helixPoint(kCurvature, 3., kCotangent), helixPoint(kCurvature, 7., kCotangent), helixPoint(kCurvature, 12., kCotangent), helixPoint(kCurvature, 18., kCotangent)};
+  TripletFitResult adjacent;
+  BOOST_REQUIRE(fitAdjacentTriplets(points[0], points[1], points[2], points[3], 2.e-6F, 2.e-6F, adjacent));
+  TripletFitResult first;
+  TripletFitResult second;
+  TripletFitFactor factor;
+  BOOST_REQUIRE(study::makeTripletFitFactor(points[0], points[1], points[2], 2.e-6F, factor));
+  BOOST_REQUIRE(fitTriplet(factor, first));
+  BOOST_REQUIRE(study::makeTripletFitFactor(points[1], points[2], points[3], 2.e-6F, factor));
+  BOOST_REQUIRE(fitTriplet(factor, second));
+  const double sineTheta = 1. / std::sqrt(1. + (kCotangent * kCotangent));
+  checkClose(adjacent.curvature, static_cast<Scalar>(kCurvature * sineTheta), 3.e-3F);
+  BOOST_TEST(adjacent.chi2 < kExactHelixChi2);
+  // Two kinks constrain the curvature better than either alone.
+  BOOST_TEST(adjacent.varCurvature < std::min(first.varCurvature, second.varCurvature));
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testTripletStage.cxx b/Detectors/GenericTracking/tracking/test/testTripletStage.cxx
new file mode 100644
index 0000000000000..5c3c5092b49fc
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testTripletStage.cxx
@@ -0,0 +1,839 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTripletStage.cxx
+/// \brief Triplet generation against a brute-force tracklet-pair reference.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK TripletStage
+#include <boost/test/unit_test.hpp>
+#include <numbers>
+
+#include "ToyBarrel4Disc8.h"
+#include "ToyBarrel3.h"
+#include "GenericTracking/Tracking/CpuBackend.h"
+#include "GenericTracking/Tracking/MeasurementGridBuilder.h"
+#include "GenericTracking/Tracking/Tracker.h"
+#include "GenericTracking/Tracking/TrackletPaths.h"
+#include "GenericTracking/Tracking/TripletPermutation.h"
+#include "GenericTracking/Tracking/TripletStage.h"
+
+#include "GridTestSupport.h"
+#include "Oracles.h"
+#include "StageOutputComparison.h"
+#include "SerialReferences.h"
+#include "UniformMaterial.h"
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <span>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using Det = detectors::ToyBarrel3;
+using Frame = TimeFrame<Det>;
+using Scratch = TimeFrameScratch<Det>;
+using Sources = LayerRowMap<Det>;
+using Tracklets = StageOutput<TrackletT>;
+using Triplets = StageOutput<TripletT>;
+using Permutation = TripletPermutation<Det>;
+using Controller = Tracker<Det, UniformMaterial>;
+
+/// The largest variances per layer over \a slice's halo rows.
+template <DetectorLayout Layout>
+std::array<TripletTargetBounds, static_cast<std::size_t>(Detector<Layout>::nLayers)> haloTargetBounds(const TimeFrame<Layout>& frame, const typename TimeFrame<Layout>::TimeSlice& slice)
+{
+  return boundsOver(frame, std::span<const MeasurementRange, HaloBounds<Layout>::kLayerCount>{slice.halo}).target;
+}
+
+constexpr std::size_t kTracks = 4U;
+constexpr std::size_t kNoisePerLayer = 3U;
+constexpr std::size_t kMeasurements = (3U * kTracks) + (3U * kNoisePerLayer);
+
+struct InputPoint {
+  LayerID layer = kInvalidLayerID;
+  Scalar x = 0.F;
+  Scalar y = 0.F;
+  Scalar z = 0.F;
+  Scalar r = 0.F;
+  Scalar phi = 0.F;
+};
+
+SearchWindowParams windowParameters()
+{
+  SearchWindowParams result;
+  result.minPtGeV = 1.;
+  result.bzKiloGauss = 20.;
+  result.materialX2X0 = 0.;
+  result.positionSigma = 0.003;
+  result.nSigma = 3.;
+  return result;
+}
+
+GridParams gridParameters()
+{
+  GridParams result;
+  result.blockWidth = 20'000;
+  return test::withToyFrames(result);
+}
+
+/// The toy's three layers make triplets and no road: its chains are 3
+/// clusters, or no link would be taken (`takenLinks`).
+IterationSettings iterationSettings() { return {.windows = windowParameters(), .vertexSource = VertexSource::kBeamLine, .minClusters = 3}; }
+
+InputPoint helixPoint(std::size_t track, LayerID layer)
+{
+  constexpr std::array<double, kTracks> kPhi{{0.10, 1.35, 3.05, 4.75}};
+  constexpr std::array<double, kTracks> kSlope{{0.04, -0.06, 0.08, -0.03}};
+  constexpr std::array<double, kTracks> kPt{{1.2, 1.8, 3.0, 1.4}};
+  const double radius = layerDistance<Det>(layer);
+  const double curvature = 1. / curvatureRadius(kPt[track], 20.);
+  const double arc = 2. * std::asin(0.5 * curvature * radius) / curvature;
+  const double direction = kPhi[track] + (curvature * arc);
+  const double x = (std::sin(direction) - std::sin(kPhi[track])) / curvature;
+  const double y = (std::cos(kPhi[track]) - std::cos(direction)) / curvature;
+  double phi = std::atan2(y, x);
+  if (phi < 0.) {
+    phi += 2 * std::numbers::pi_v<double>;
+  }
+  return {
+    .layer = layer,
+    .x = static_cast<Scalar>(x),
+    .y = static_cast<Scalar>(y),
+    .z = static_cast<Scalar>(kSlope[track] * arc),
+    .r = static_cast<Scalar>(radius),
+    .phi = static_cast<Scalar>(phi),
+  };
+}
+
+class Fixture
+{
+ public:
+  static constexpr VertexConstraint kBeamConstraint{.z = 0., .sigmaZ = 0.02, .sigmaTransverse = 0.001};
+
+  Fixture()
+    : geometry(test::cappedGrid<Det>(20., gridParameters(), windowParameters(), kBeamConstraint, 16, 8)),
+      offsets(static_cast<std::size_t>(geometry.bucketCount()) + 1U)
+  {
+    std::array<InputPoint, kMeasurements> input{};
+    for (std::size_t track = 0; track < kTracks; ++track) {
+      for (std::size_t layer = 0; layer < 3U; ++layer) {
+        input[logicalIndex(track, layer)] = helixPoint(track, static_cast<LayerID>(layer));
+      }
+    }
+    for (std::size_t layer = 0; layer < 3U; ++layer) {
+      const double radius = layerDistance<Det>(static_cast<LayerID>(layer));
+      for (std::size_t noise = 0; noise < kNoisePerLayer; ++noise) {
+        const double phi = 0.55 + (1.85 * static_cast<double>(noise)) + (0.23 * static_cast<double>(layer));
+        const std::size_t index = (3U * kTracks) + (layer * kNoisePerLayer) + noise;
+        input[index] = {
+          .layer = static_cast<LayerID>(layer),
+          .x = static_cast<Scalar>(radius * std::cos(phi)),
+          .y = static_cast<Scalar>(radius * std::sin(phi)),
+          .z = static_cast<Scalar>((noise % 2U == 0U ? 0.65 : -0.55) + (0.1 * static_cast<double>(layer))),
+          .r = static_cast<Scalar>(radius),
+          .phi = static_cast<Scalar>(phi),
+        };
+      }
+    }
+
+    frame = test::frameOf(
+      geometry, input.size(), [&](std::size_t i) { return input[i]; }, [&](std::size_t /*i*/) { return test::toyTimeBox(10.); },
+      [&](std::size_t i) {
+        const auto scale = static_cast<Scalar>(1U + (i % 3U));
+        return test::PointVariances{.z = scale * 1.e-6F, .r = scale * 2.e-6F, .rPhi = scale * 3.e-6F};
+      },
+      columns, offsets);
+  }
+
+  [[nodiscard]] static constexpr std::size_t logicalIndex(std::size_t track, std::size_t layer) { return (3U * track) + layer; }
+
+  [[nodiscard]] std::uint32_t row(std::size_t logical) const { return static_cast<std::uint32_t>(std::ranges::find(columns.clusterIndex, static_cast<std::uint32_t>(logical)) - columns.clusterIndex.begin()); }
+
+  GridGeometry<Det> geometry;
+  std::vector<std::uint32_t> offsets;
+  MeasurementStore columns;
+  std::unique_ptr<Frame> frame;
+};
+
+using Mixed = detectors::ToyBarrel4Disc8;
+using MixedFrame = TimeFrame<Mixed>;
+using MixedSources = LayerRowMap<Mixed>;
+using MixedScratch = TimeFrameScratch<Mixed>;
+using MixedController = Tracker<Mixed, UniformMaterial>;
+constexpr std::size_t kMixedMeasurements = 10U;
+
+struct MixedInputPoint {
+  LayerID layer = kInvalidLayerID;
+  double timeNS = 0.;
+  Scalar x = 0.F;
+  Scalar y = 0.F;
+  Scalar z = 0.F;
+  Scalar r = 0.F;
+  Scalar phi = 0.F;
+};
+
+IterationSettings mixedIterationSettings() { return {.windows = windowParameters(), .vertexSource = VertexSource::kBeamLine}; }
+
+MixedInputPoint mixedHelixPoint(LayerID layer, double phiAtOrigin, double slope, double ptGeV, double timeNS)
+{
+  const double curvature = 1. / curvatureRadius(ptGeV, 20.);
+  double arc = 0.;
+  if (Detector<Mixed>::isBarrelLayer(layer)) {
+    const double radius = layerDistance<Mixed>(layer);
+    arc = 2. * std::asin(0.5 * curvature * radius) / curvature;
+  } else {
+    arc = discZ<Mixed>(layer) / slope;
+  }
+  const double direction = phiAtOrigin + (curvature * arc);
+  const double x = (std::sin(direction) - std::sin(phiAtOrigin)) / curvature;
+  const double y = (std::cos(phiAtOrigin) - std::cos(direction)) / curvature;
+  double phi = std::atan2(y, x);
+  if (phi < 0.) {
+    phi += 2 * std::numbers::pi_v<double>;
+  }
+  return {
+    .layer = layer,
+    .timeNS = timeNS,
+    .x = static_cast<Scalar>(x),
+    .y = static_cast<Scalar>(y),
+    .z = static_cast<Scalar>(slope * arc),
+    .r = static_cast<Scalar>(std::hypot(x, y)),
+    .phi = static_cast<Scalar>(phi),
+  };
+}
+
+std::uint16_t mixedLink(LayerID from, LayerID to)
+{
+  const auto link = linkOf<Mixed>(from, to);
+  if (link == kNoLink) {
+    BOOST_FAIL("no link " << int(from) << " -> " << int(to));
+  }
+  return static_cast<std::uint16_t>(link);
+}
+
+class MixedFixture
+{
+ public:
+  static constexpr VertexConstraint kBeamConstraint{.z = 0., .sigmaZ = 0.02, .sigmaTransverse = 0.001};
+  static constexpr std::size_t kCentral1 = 0U;
+  static constexpr std::size_t kCentral2 = 1U;
+  static constexpr std::size_t kCentral3 = 2U;
+  static constexpr std::size_t kForward1 = 3U;
+  static constexpr std::size_t kForward2 = 4U;
+  static constexpr std::size_t kForward3 = 5U;
+  static constexpr std::size_t kForwardDisc = 6U;
+  static constexpr std::size_t kLate1 = 7U;
+  static constexpr std::size_t kLate2 = 8U;
+  static constexpr std::size_t kLate3 = 9U;
+
+  MixedFixture()
+    : geometry(test::cappedGrid<Mixed>(80., gridParameters(), windowParameters(), kBeamConstraint, 32, 16)),
+      offsets(static_cast<std::size_t>(geometry.bucketCount()) + 1U)
+  {
+    // Flight times between the layers: a nanosecond or less, one tick for all.
+    // From layer 2 the forward track continues to layer 3 and to the +22 cm
+    // disc, and from the disc to layer 3: its points lie on its helix; that
+    // it would cross the disc first does not matter to the stages.
+    constexpr double time12 = 0.1;
+    constexpr double time23 = 0.1;
+    constexpr double time28 = 0.2;
+    const std::array<MixedInputPoint, kMixedMeasurements> input{{
+      mixedHelixPoint(1, 0.2, 0.15, 2., 10.),
+      mixedHelixPoint(2, 0.2, 0.15, 2., 10. + time12),
+      mixedHelixPoint(3, 0.2, 0.15, 2., 10. + time12 + time23),
+      mixedHelixPoint(1, 2.2, 1.3, 2.5, 10.),
+      mixedHelixPoint(2, 2.2, 1.3, 2.5, 10. + time12),
+      mixedHelixPoint(3, 2.2, 1.3, 2.5, 10. + time12 + time23),
+      mixedHelixPoint(8, 2.2, 1.3, 2.5, 10. + time12 + time28),
+      mixedHelixPoint(1, 4.5, 0.25, 2., 10.),
+      mixedHelixPoint(2, 4.5, 0.25, 2., 35. + time12),
+      mixedHelixPoint(3, 4.5, 0.25, 2., 60. + time12 + time23),
+    }};
+
+    frame = test::frameOf(geometry, input.size(), [&](std::size_t i) { return input[i]; }, [&](std::size_t i) { return test::toyTimeBox(input[i].timeNS); }, [&](std::size_t /*i*/) { return test::PointVariances{.z = 9.e-6F, .r = 9.e-6F, .rPhi = 9.e-6F}; }, columns, offsets);
+  }
+
+  [[nodiscard]] std::uint32_t row(std::size_t logical) const { return static_cast<std::uint32_t>(std::ranges::find(columns.clusterIndex, static_cast<std::uint32_t>(logical)) - columns.clusterIndex.begin()); }
+
+  GridGeometry<Mixed> geometry;
+  std::vector<std::uint32_t> offsets;
+  MeasurementStore columns;
+  std::unique_ptr<MixedFrame> frame;
+};
+
+constexpr std::size_t kSliceTracks = 4U;
+constexpr std::size_t kSliceMeasurements = 3U * kSliceTracks;
+
+class SliceFixture
+{
+ public:
+  static constexpr VertexConstraint kBeamConstraint = Fixture::kBeamConstraint;
+
+  SliceFixture()
+    : geometry(test::cappedGrid<Det>(140., gridParameters(), windowParameters(), kBeamConstraint, 16, 8)),
+      offsets(static_cast<std::size_t>(geometry.bucketCount()) + 1U)
+  {
+    constexpr double flight01 = 0.2; // [ns], a few centimetres at c
+    constexpr double flight12 = 0.2;
+    // Track 1 crosses the 40 ns block edge: its first hit in the 25-50 ns
+    // tick, whose box starts at 17 ns, its others in the next, starting at
+    // 42 ns (the toys' boxes, GridTestSupport.h).
+    const std::array<double, kSliceTracks> start{{10., 50. - (0.5 * flight01), 70., 110.}};
+
+    std::array<InputPoint, kSliceMeasurements> input{};
+    std::array<double, kSliceMeasurements> times{};
+    for (std::size_t track = 0; track < kSliceTracks; ++track) {
+      for (std::size_t layer = 0; layer < 3U; ++layer) {
+        const std::size_t logical = logicalIndex(track, layer);
+        input[logical] = helixPoint(track, static_cast<LayerID>(layer));
+        times[logical] = start[track] + (layer == 0U ? 0. : flight01) + (layer == 2U ? flight12 : 0.);
+      }
+    }
+
+    frame = test::frameOf(geometry, input.size(), [&](std::size_t i) { return input[i]; }, [&](std::size_t i) { return test::toyTimeBox(times[i]); }, [&](std::size_t /*i*/) { return test::PointVariances{.z = 1.e-6F, .r = 2.e-6F, .rPhi = 3.e-6F}; }, columns, offsets);
+  }
+
+  [[nodiscard]] static constexpr std::size_t logicalIndex(std::size_t track, std::size_t layer) { return (3U * track) + layer; }
+
+  [[nodiscard]] std::uint32_t row(std::size_t logical) const { return static_cast<std::uint32_t>(std::ranges::find(columns.clusterIndex, static_cast<std::uint32_t>(logical)) - columns.clusterIndex.begin()); }
+
+  GridGeometry<Det> geometry;
+  std::vector<std::uint32_t> offsets;
+  MeasurementStore columns;
+  std::unique_ptr<Frame> frame;
+};
+
+/// Compare a tracker result with the triplet-stage output that preceded its
+/// level sweep. All stage structure and semantic triplet fields must match;
+/// only the level column is expected to differ.
+bool sameTripletOutputIgnoringLevelSweep(const Triplets& lhs, const Triplets& rhs)
+{
+  if (!sameStageShape(lhs, rhs)) {
+    return false;
+  }
+  const auto a = lhs.view();
+  const auto b = rhs.view();
+  const std::size_t size = lhs.size();
+  return std::memcmp(a.first, b.first, size * sizeof(*a.first)) == 0 && std::memcmp(a.second, b.second, size * sizeof(*a.second)) == 0 && std::memcmp(a.curvature, b.curvature, size * sizeof(*a.curvature)) == 0 && std::memcmp(a.varCurvature, b.varCurvature, size * sizeof(*a.varCurvature)) == 0;
+}
+
+/// The path bounds at 3 clusters and any road end: no path is too short, so
+/// the permutation drops only the first tracklets whose middle has no
+/// tracklets and the stage applies its own cuts alone.
+template <DetectorLayout Layout>
+TrackletPathBounds everyPath(TrackletPaths<Layout>& paths, IterationParameters<Layout> parameters, const LayerRowMap<Layout>& sources, const Tracklets& tracklets)
+{
+  parameters.minClusters = 3U;
+  parameters.roadEndLayers = 0U;
+  paths.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+  paths.build(parameters, sources, tracklets, SerialForEach{});
+  return paths.bounds();
+}
+
+/// The permutation is every tracklet whose middle is a source with tracklets,
+/// in arena order; returns how many tracklets it excludes because their
+/// middle is not a source.
+template <DetectorLayout Layout>
+std::size_t checkPermutation(const IterationParameters<Layout>& parameters, const LayerRowMap<Layout>& sources, const Tracklets& tracklets, const TripletPermutation<Layout>& permutation)
+{
+  const auto view = tracklets.view();
+  const auto offsets = tracklets.offsets();
+  std::vector<std::uint32_t> expected;
+  std::size_t notSources = 0U;
+  for (std::uint32_t first = 0; first < tracklets.size(); ++first) {
+    const LayerID middleLayer = parameters.linkTargets[view.link[first]];
+    if (!sources.contains(middleLayer, view.target[first])) {
+      ++notSources;
+      continue;
+    }
+    const auto element = sources.element(middleLayer, view.target[first]);
+    if (offsets[element] != offsets[element + 1U]) {
+      expected.push_back(first);
+    }
+  }
+  BOOST_REQUIRE(permutation.size() == expected.size());
+  for (std::size_t index = 0; index < expected.size(); ++index) {
+    BOOST_TEST(permutation.indices()[index] == expected[index]);
+  }
+  return notSources;
+}
+
+template <DetectorLayout Layout>
+std::uint32_t permutationElement(const TripletPermutation<Layout>& permutation, std::uint32_t first)
+{
+  const auto found = std::ranges::find(permutation.indices(), first);
+  return static_cast<std::uint32_t>(found - permutation.indices().begin());
+}
+
+/// Each first tracklet's triplets in canonical order: by the second
+/// tracklet's link in the middle layer's out-link order, then by lambda.
+template <DetectorLayout Layout>
+void checkOutputOrder(const IterationParameters<Layout>& parameters, const Tracklets& tracklets, const TripletPermutation<Layout>& permutation, const Triplets& triplets)
+{
+  const auto trackletView = tracklets.view();
+  const auto tripletView = triplets.view();
+  for (std::uint32_t element = 0; element < permutation.size(); ++element) {
+    const std::uint32_t first = permutation.indices()[element];
+    const LayerID middleLayer = parameters.linkTargets[trackletView.link[first]];
+    const auto begin = triplets.offsets()[element];
+    const auto end = triplets.offsets()[element + 1U];
+    std::uint32_t previousLinkOrder = 0U;
+    Scalar previousLambda = 0.F;
+    for (auto index = begin; index < end; ++index) {
+      BOOST_TEST(tripletView.first[index] == first);
+      const std::size_t secondLink = trackletView.link[tripletView.second[index]];
+      const auto linkBegin = parameters.outLinkOffsets[middleLayer];
+      const auto linkEnd = parameters.outLinkOffsets[static_cast<std::size_t>(middleLayer) + 1U];
+      std::uint32_t linkOrder = linkEnd - linkBegin;
+      for (auto out = linkBegin; out < linkEnd; ++out) {
+        if (parameters.outLinkIndices[out] == secondLink) {
+          linkOrder = out - linkBegin;
+          break;
+        }
+      }
+      BOOST_REQUIRE(linkOrder < linkEnd - linkBegin);
+      const Scalar lambda = trackletView.lambda[tripletView.second[index]];
+      if (index != begin) {
+        BOOST_TEST(previousLinkOrder <= linkOrder);
+        if (previousLinkOrder == linkOrder) {
+          BOOST_TEST(previousLambda <= lambda);
+        }
+      }
+      previousLinkOrder = linkOrder;
+      previousLambda = lambda;
+    }
+  }
+}
+
+template <DetectorLayout Layout>
+struct TripletStageChecks {
+  using Parameters = IterationParameters<Layout>;
+  using SourcesT = LayerRowMap<Layout>;
+  using FrameT = TimeFrame<Layout>;
+  using PermutationT = TripletPermutation<Layout>;
+
+  TripletStageChecks(const Parameters& parameters, const SourcesT& sources, const FrameT& frame, const Tracklets& tracklets, const TripletTargetBounds* targetBounds)
+    : mParameters(&parameters),
+      mSources(&sources),
+      mFrame(&frame),
+      mTracklets(&tracklets),
+      mTargetBounds(targetBounds)
+  {
+  }
+
+  TrackletPaths<Layout> paths;
+  TrackletPathBounds bounds;
+  PermutationT permutation;
+  Triplets serial;
+  std::size_t excludedFirstTracklets = 0U;
+
+  void run()
+  {
+    bounds = everyPath(paths, *mParameters, *mSources, *mTracklets);
+    permutation.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    BOOST_REQUIRE(permutation.build(*mParameters, *mSources, *mTracklets, bounds, SerialForEach{}, 256U) == StageStatus::kComplete);
+    excludedFirstTracklets = checkPermutation(*mParameters, *mSources, *mTracklets, permutation);
+
+    serial.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    serial.prepare(permutation.size());
+    BOOST_REQUIRE(runSerial(serial, stage(permutation)) == StageStatus::kComplete);
+    checkOutputOrder(*mParameters, *mTracklets, permutation, serial);
+  }
+
+  void checkBackends() const
+  {
+    const auto theStage = stage(permutation);
+    for (const int threads : {1, 2, 4}) {
+      for (const Triplets::Index chunk : {1U, 2U, 3U, 7U, 16U}) {
+        Triplets parallel;
+        const auto parallelPool = std::make_shared<BoundedMemoryResource>();
+        parallel.setMemoryPool(parallelPool);
+        parallel.prepare(permutation.size());
+        detail::TaskArena cpuArena{threads};
+        CpuStage<TripletT> cpu{cpuArena};
+        cpu.setMemoryPool(parallelPool);
+        BOOST_REQUIRE(cpu.run(parallel, chunk, theStage) == StageStatus::kComplete);
+        BOOST_TEST(sameStageOutput(parallel, serial), "threads " << threads << ", chunk " << chunk);
+      }
+    }
+  }
+
+ private:
+  [[nodiscard]] TripletStage<Layout> stage(const PermutationT& order) const { return {*mParameters, *mSources, *mFrame, *mTracklets, mTargetBounds, order.data(), bounds}; }
+
+  const Parameters* mParameters = nullptr;
+  const SourcesT* mSources = nullptr;
+  const FrameT* mFrame = nullptr;
+  const Tracklets* mTracklets = nullptr;
+  const TripletTargetBounds* mTargetBounds = nullptr;
+};
+
+/// Compare source-ordered stage output with an exhaustive continuation scan.
+/// The return value counts candidates that pass the lambda window but fail a
+/// later triplet cut.
+template <DetectorLayout Layout>
+std::size_t checkAgainstBruteForce(const IterationParameters<Layout>& parameters, const LayerRowMap<Layout>& sources, const TimeFrame<Layout>& frame, const Tracklets& tracklets, const TripletTargetBounds* targetBounds, const TripletPermutation<Layout>& sourceOrder, const Triplets& serial)
+{
+  const auto trackletView = tracklets.view();
+  const auto tripletView = serial.view();
+  std::size_t postLambdaRejected = 0U;
+  for (std::uint32_t firstIndex = 0; firstIndex < tracklets.size(); ++firstIndex) {
+    std::vector<std::pair<std::uint32_t, std::uint32_t>> brute;
+    const std::size_t firstLink = trackletView.link[firstIndex];
+    const LayerID middleLayer = parameters.linkTargets[firstLink];
+    const std::uint32_t middleRow = trackletView.target[firstIndex];
+    if (sources.contains(middleLayer, middleRow)) {
+      const auto first = timedPointAt(frame.measurements(), trackletView.source[firstIndex]);
+      const auto middle = timedPointAt(frame.measurements(), middleRow);
+      const auto middleElement = sources.element(middleLayer, middleRow);
+      for (auto candidateIndex = tracklets.offsets()[middleElement]; candidateIndex < tracklets.offsets()[middleElement + 1U]; ++candidateIndex) {
+        const std::size_t secondLink = trackletView.link[candidateIndex];
+        const LayerID targetLayer = parameters.linkTargets[secondLink];
+        const Scalar halfWidth = tripletLambdaHalfWidth(parameters, secondLink, middleLayer, first.point, middle.point, targetBounds[targetLayer]);
+        if (trackletView.lambda[candidateIndex] < trackletView.lambda[firstIndex] - halfWidth || trackletView.lambda[candidateIndex] > trackletView.lambda[firstIndex] + halfWidth) {
+          continue;
+        }
+        const auto third = timedPointAt(frame.measurements(), trackletView.target[candidateIndex]);
+        TripletFitResult fit;
+        if (tripletCompatible(parameters, middleLayer, first, middle, third, fit)) {
+          brute.emplace_back(firstIndex, candidateIndex);
+        } else {
+          ++postLambdaRejected;
+        }
+      }
+    }
+
+    std::vector<std::pair<std::uint32_t, std::uint32_t>> emitted;
+    const auto sourceElement = permutationElement(sourceOrder, firstIndex);
+    if (sourceElement < sourceOrder.size()) {
+      for (auto index = serial.offsets()[sourceElement]; index < serial.offsets()[sourceElement + 1U]; ++index) {
+        emitted.emplace_back(tripletView.first[index], tripletView.second[index]);
+      }
+    }
+    std::ranges::sort(brute);
+    std::ranges::sort(emitted);
+    BOOST_REQUIRE(emitted.size() == brute.size());
+    for (std::size_t index = 0; index < brute.size(); ++index) {
+      BOOST_TEST(emitted[index].first == brute[index].first);
+      BOOST_TEST(emitted[index].second == brute[index].second);
+    }
+  }
+  return postLambdaRejected;
+}
+
+std::uint32_t findTracklet(const Tracklets& tracklets, std::uint32_t source, std::uint32_t target, std::uint16_t link)
+{
+  const auto view = tracklets.view();
+  for (std::uint32_t index = 0; index < tracklets.size(); ++index) {
+    if (view.source[index] == source && view.target[index] == target && view.link[index] == link) {
+      return index;
+    }
+  }
+  return tracklets.size();
+}
+
+using SliceTriplet = std::array<std::uint32_t, 5U>;
+
+struct SliceRun {
+  std::vector<SliceTriplet> triplets;
+  std::uint64_t tracklets = 0U;
+  std::uint64_t haloSourceTracklets = 0U;
+};
+
+SliceRun runTripletSlices(const SliceFixture& fixture, std::int32_t widthBlocks, std::int32_t firstBoundary)
+{
+  const std::array<double, Sources::kLayerCount> material{};
+  const auto scattering = scatteringTable<Det>(material);
+  const auto parameters = iterationParameters<Det>(iterationSettings(), SliceFixture::kBeamConstraint, scattering);
+  const std::int64_t haloPS = sliceReach(frameBounds(*fixture.frame), fixture.geometry).haloPS();
+
+  Controller tracker{iterationSettings(), SliceFixture::kBeamConstraint, scattering, std::make_shared<BoundedMemoryResource>(), 2U, 2};
+  const auto blockCount = fixture.geometry.blockCount();
+  const auto width = std::max(1, widthBlocks);
+  const auto shift = firstBoundary > 0 ? std::min(firstBoundary, width - 1) : 0;
+  SliceRun result;
+  for (std::int32_t begin = 0; begin < blockCount;) {
+    const auto firstWidth = begin == 0 && shift > 0 ? shift : width;
+    const auto end = std::min(blockCount, begin + firstWidth);
+    const Frame::TimeSlice slice{*fixture.frame, {.begin = begin, .end = end}, haloPS};
+    BOOST_REQUIRE(tracker.beginTimeframe(*fixture.frame) == StageStatus::kComplete);
+    const auto trackletResult = test::runSlice(tracker, 0U, *fixture.frame, slice, {});
+    BOOST_REQUIRE(trackletResult.status == StageStatus::kComplete);
+    BOOST_REQUIRE(trackletResult.tracklets != nullptr);
+    const auto& tracklets = *trackletResult.tracklets;
+    const auto trackletView = tracklets.view();
+    result.tracklets += tracklets.size();
+    for (std::uint32_t index = 0; index < tracklets.size(); ++index) {
+      const LayerID sourceLayer = parameters.linkSources[trackletView.link[index]];
+      const auto core = slice.core[sourceLayer];
+      result.haloSourceTracklets += trackletView.source[index] >= core.begin && trackletView.source[index] < core.end ? 0U : 1U;
+    }
+
+    const Sources sources = Scratch::makeSources(slice.halo);
+    TrackletPaths<Det> paths;
+    const auto bounds = everyPath(paths, parameters, sources, tracklets);
+    Permutation permutation;
+    permutation.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    BOOST_REQUIRE(permutation.build(parameters, sources, tracklets, bounds, SerialForEach{}, 256U) == StageStatus::kComplete);
+    const auto targetBounds = haloTargetBounds(*fixture.frame, slice);
+    const TripletStage<Det> stage{parameters, sources, *fixture.frame, tracklets, targetBounds.data(), permutation.data(), bounds};
+    Triplets triplets;
+    triplets.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    triplets.prepare(permutation.size());
+    BOOST_REQUIRE(runSerial(triplets, stage) == StageStatus::kComplete);
+    // The core-owned triplets, first measurement in the core, partition the
+    // triplets over the slices; halo-owned ones are built for the chains.
+    const auto tripletView = triplets.view();
+    for (std::uint32_t index = 0; index < triplets.size(); ++index) {
+      const std::uint32_t first = tripletView.first[index];
+      const std::uint32_t second = tripletView.second[index];
+      BOOST_REQUIRE(trackletView.target[first] == trackletView.source[second]);
+      const auto firstCore = slice.core[parameters.linkSources[trackletView.link[first]]];
+      if (trackletView.source[first] < firstCore.begin || trackletView.source[first] >= firstCore.end) {
+        continue;
+      }
+      result.triplets.push_back({trackletView.source[first], trackletView.target[first], trackletView.target[second], std::bit_cast<std::uint32_t>(tripletView.curvature[index]), std::bit_cast<std::uint32_t>(tripletView.varCurvature[index])});
+    }
+    begin = end;
+  }
+  std::ranges::sort(result.triplets);
+  return result;
+}
+
+void checkSliceTriplets(const std::vector<SliceTriplet>& actual, const std::vector<SliceTriplet>& expected)
+{
+  BOOST_REQUIRE(actual.size() == expected.size());
+  for (std::size_t triplet = 0; triplet < expected.size(); ++triplet) {
+    for (std::size_t field = 0; field < expected[triplet].size(); ++field) {
+      BOOST_TEST(actual[triplet][field] == expected[triplet][field]);
+    }
+  }
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(TripletsMatchBruteForceAndAllTrueHelicesAreFound)
+{
+  const Fixture fixture;
+  const Frame::TimeSlice slice{*fixture.frame, fixture.geometry.allBlocks(), 0};
+  const std::array<double, Sources::kLayerCount> material{};
+  const auto scattering = scatteringTable<Det>(material);
+  Controller tracker{iterationSettings(), Fixture::kBeamConstraint, scattering, std::make_shared<BoundedMemoryResource>(), 2U, 2};
+  BOOST_REQUIRE(tracker.beginTimeframe(*fixture.frame) == StageStatus::kComplete);
+  const auto trackletResult = test::runSlice(tracker, 0U, *fixture.frame, slice, {});
+  BOOST_REQUIRE(trackletResult.status == StageStatus::kComplete);
+  BOOST_REQUIRE(trackletResult.tracklets != nullptr);
+  const auto& tracklets = *trackletResult.tracklets;
+  BOOST_REQUIRE(tracklets.size() > 0U);
+
+  const Sources sources = Scratch::makeSources(slice.halo);
+  const auto parameters = iterationParameters<Det>(iterationSettings(), Fixture::kBeamConstraint, scattering);
+  const auto targetBounds = haloTargetBounds(*fixture.frame, slice);
+  BOOST_TEST(targetBounds[2].varZ == 3.e-6F);
+  BOOST_TEST(targetBounds[2].varR == 6.e-6F);
+  BOOST_TEST(targetBounds[2].varRPhi == 9.e-6F);
+  TripletStageChecks<Det> checks{parameters, sources, *fixture.frame, tracklets, targetBounds.data()};
+  checks.run();
+  BOOST_TEST(checks.excludedFirstTracklets > 0U);
+  const auto& sourceOrder = checks.permutation;
+  const auto& serial = checks.serial;
+
+  const auto tripletView = serial.view();
+  static_cast<void>(checkAgainstBruteForce(parameters, sources, *fixture.frame, tracklets, targetBounds.data(), sourceOrder, serial));
+
+  std::size_t trueTriplets = 0U;
+  for (std::size_t track = 0; track < kTracks; ++track) {
+    const auto first = findTracklet(tracklets, fixture.row(Fixture::logicalIndex(track, 0U)), fixture.row(Fixture::logicalIndex(track, 1U)), 0U);
+    const auto second = findTracklet(tracklets, fixture.row(Fixture::logicalIndex(track, 1U)), fixture.row(Fixture::logicalIndex(track, 2U)), 1U);
+    BOOST_REQUIRE(first < tracklets.size());
+    BOOST_REQUIRE(second < tracklets.size());
+    bool found = false;
+    for (std::uint32_t index = 0; index < serial.size(); ++index) {
+      found = found || (tripletView.first[index] == first && tripletView.second[index] == second);
+    }
+    BOOST_TEST(found);
+    trueTriplets += found ? 1U : 0U;
+  }
+  BOOST_TEST(trueTriplets == kTracks);
+  BOOST_TEST_MESSAGE("fixture triplets " << serial.size() << ", true triplets " << trueTriplets);
+
+  checks.checkBackends();
+}
+
+BOOST_AUTO_TEST_CASE(MultipleContinuationsDiscPathAndPostLambdaRejection)
+{
+  const MixedFixture fixture;
+  const MixedFrame::TimeSlice slice{*fixture.frame, fixture.geometry.allBlocks(), 0};
+  const std::array<double, MixedSources::kLayerCount> material{};
+  const auto scattering = scatteringTable<Mixed>(material);
+  MixedController tracker{mixedIterationSettings(), MixedFixture::kBeamConstraint, scattering, std::make_shared<BoundedMemoryResource>(), 2U, 2};
+  BOOST_REQUIRE(tracker.beginTimeframe(*fixture.frame) == StageStatus::kComplete);
+  const auto trackletResult = test::runSlice(tracker, 0U, *fixture.frame, slice, {});
+  BOOST_REQUIRE(trackletResult.status == StageStatus::kComplete);
+  BOOST_REQUIRE(trackletResult.tracklets != nullptr);
+  const auto& tracklets = *trackletResult.tracklets;
+
+  const auto link12 = mixedLink(1, 2);
+  const auto link23 = mixedLink(2, 3);
+  const auto link28 = mixedLink(2, 8);
+  const auto link83 = mixedLink(8, 3);
+  const auto centralFirst = findTracklet(tracklets, fixture.row(MixedFixture::kCentral1), fixture.row(MixedFixture::kCentral2), link12);
+  const auto centralSecond = findTracklet(tracklets, fixture.row(MixedFixture::kCentral2), fixture.row(MixedFixture::kCentral3), link23);
+  const auto forwardFirst = findTracklet(tracklets, fixture.row(MixedFixture::kForward1), fixture.row(MixedFixture::kForward2), link12);
+  const auto forwardThird = findTracklet(tracklets, fixture.row(MixedFixture::kForward2), fixture.row(MixedFixture::kForward3), link23);
+  const auto forwardDisc = findTracklet(tracklets, fixture.row(MixedFixture::kForward2), fixture.row(MixedFixture::kForwardDisc), link28);
+  const auto discNext = findTracklet(tracklets, fixture.row(MixedFixture::kForwardDisc), fixture.row(MixedFixture::kForward3), link83);
+  const auto lateFirst = findTracklet(tracklets, fixture.row(MixedFixture::kLate1), fixture.row(MixedFixture::kLate2), link12);
+  const auto lateSecond = findTracklet(tracklets, fixture.row(MixedFixture::kLate2), fixture.row(MixedFixture::kLate3), link23);
+  const std::array<std::pair<const char*, std::uint32_t>, 8> requiredTracklets{{
+    {"central first", centralFirst},
+    {"central second", centralSecond},
+    {"forward first", forwardFirst},
+    {"forward third", forwardThird},
+    {"forward disc", forwardDisc},
+    {"disc next", discNext},
+    {"late first", lateFirst},
+    {"late second", lateSecond},
+  }};
+  for (const auto& [name, index] : requiredTracklets) {
+    BOOST_REQUIRE_MESSAGE(index < tracklets.size(), "missing " << name);
+  }
+
+  const MixedSources sources = MixedScratch::makeSources(slice.halo);
+  const auto parameters = iterationParameters<Mixed>(mixedIterationSettings(), MixedFixture::kBeamConstraint, scattering);
+  const auto targetBounds = haloTargetBounds(*fixture.frame, slice);
+  TripletStageChecks<Mixed> checks{parameters, sources, *fixture.frame, tracklets, targetBounds.data()};
+  checks.run();
+  // No link leaves layer 3: the tracklets ending on it start no triplet.
+  std::size_t endingOnLayer3 = 0U;
+  for (std::uint32_t index = 0; index < tracklets.size(); ++index) {
+    endingOnLayer3 += parameters.linkTargets[tracklets.view().link[index]] == 3U ? 1U : 0U;
+  }
+  BOOST_TEST(endingOnLayer3 > 0U);
+  BOOST_TEST(checks.excludedFirstTracklets == endingOnLayer3);
+  const auto& sourceOrder = checks.permutation;
+  const auto& serial = checks.serial;
+  // The tracker runs the same stage itself, with the path bounds at the
+  // iteration's own length.
+  BOOST_REQUIRE(trackletResult.triplets != nullptr);
+  {
+    TrackletPaths<Mixed> paths;
+    paths.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    paths.build(parameters, sources, tracklets, SerialForEach{});
+    TripletPermutation<Mixed> order;
+    order.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    BOOST_REQUIRE(order.build(parameters, sources, tracklets, paths.bounds(), SerialForEach{}, 256U) == StageStatus::kComplete);
+    const TripletStage<Mixed> stage{parameters, sources, *fixture.frame, tracklets, targetBounds.data(), order.data(), paths.bounds()};
+    Triplets own;
+    own.setMemoryPool(std::make_shared<BoundedMemoryResource>());
+    own.prepare(order.size());
+    BOOST_REQUIRE(runSerial(own, stage) == StageStatus::kComplete);
+    BOOST_TEST(sameTripletOutputIgnoringLevelSweep(*trackletResult.triplets, own));
+  }
+  const auto tripletView = serial.view();
+  const auto trackletView = tracklets.view();
+  const std::size_t postLambdaRejected = checkAgainstBruteForce(parameters, sources, *fixture.frame, tracklets, targetBounds.data(), sourceOrder, serial);
+  BOOST_TEST(postLambdaRejected > 0U);
+
+  const auto hasTriplet = [&](std::uint32_t first, std::uint32_t second) {
+    for (std::uint32_t index = 0; index < serial.size(); ++index) {
+      if (tripletView.first[index] == first && tripletView.second[index] == second) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  BOOST_TEST(hasTriplet(centralFirst, centralSecond));
+  BOOST_TEST(hasTriplet(forwardFirst, forwardThird));
+  BOOST_TEST(hasTriplet(forwardFirst, forwardDisc));
+  BOOST_TEST(hasTriplet(forwardDisc, discNext));
+
+  std::uint32_t forwardThirdAt = serial.size();
+  std::uint32_t forwardDiscAt = serial.size();
+  const auto forwardElement = permutationElement(sourceOrder, forwardFirst);
+  BOOST_REQUIRE(forwardElement < sourceOrder.size());
+  for (auto index = serial.offsets()[forwardElement]; index < serial.offsets()[forwardElement + 1U]; ++index) {
+    if (tripletView.second[index] == forwardThird) {
+      forwardThirdAt = index;
+    }
+    if (tripletView.second[index] == forwardDisc) {
+      forwardDiscAt = index;
+    }
+  }
+  BOOST_TEST(forwardThirdAt < forwardDiscAt);
+
+  const auto first = timedPointAt(fixture.frame->measurements(), trackletView.source[lateFirst]);
+  const auto middle = timedPointAt(fixture.frame->measurements(), trackletView.target[lateFirst]);
+  const auto third = timedPointAt(fixture.frame->measurements(), trackletView.target[lateSecond]);
+  const Scalar halfWidth = tripletLambdaHalfWidth(parameters, link23, LayerID{2}, first.point, middle.point, targetBounds[LayerID{3}]);
+  BOOST_TEST(trackletView.lambda[lateSecond] >= trackletView.lambda[lateFirst] - halfWidth);
+  BOOST_TEST(trackletView.lambda[lateSecond] <= trackletView.lambda[lateFirst] + halfWidth);
+  BOOST_TEST(!tripletTimeCompatible(first, third));
+  BOOST_TEST(!hasTriplet(lateFirst, lateSecond));
+
+  checks.checkBackends();
+}
+
+BOOST_AUTO_TEST_CASE(TripletsAreInvariantUnderSliceWidthAndOrigin)
+{
+  const SliceFixture fixture;
+  const auto whole = runTripletSlices(fixture, fixture.geometry.blockCount(), 0);
+  const auto oneBlock = runTripletSlices(fixture, 1, 0);
+  const auto twoBlocks = runTripletSlices(fixture, 2, 0);
+  const auto shifted = runTripletSlices(fixture, 2, 1);
+
+  BOOST_REQUIRE(whole.triplets.size() == kSliceTracks);
+  checkSliceTriplets(oneBlock.triplets, whole.triplets);
+  checkSliceTriplets(twoBlocks.triplets, whole.triplets);
+  checkSliceTriplets(shifted.triplets, whole.triplets);
+
+  const bool duplicateRows = std::ranges::adjacent_find(whole.triplets, [](const SliceTriplet& lhs, const SliceTriplet& rhs) { return lhs[0] == rhs[0] && lhs[1] == rhs[1] && lhs[2] == rhs[2]; }) != whole.triplets.end();
+  BOOST_TEST(!duplicateRows);
+
+  const std::uint32_t crossingFirst = fixture.row(SliceFixture::logicalIndex(1U, 0U));
+  const std::uint32_t crossingMiddle = fixture.row(SliceFixture::logicalIndex(1U, 1U));
+  const std::uint32_t crossingThird = fixture.row(SliceFixture::logicalIndex(1U, 2U));
+  const bool crossingFound = std::ranges::any_of(whole.triplets, [&](const SliceTriplet& triplet) { return triplet[0] == crossingFirst && triplet[1] == crossingMiddle && triplet[2] == crossingThird; });
+  BOOST_TEST(crossingFound);
+
+  const std::int64_t haloPS = sliceReach(frameBounds(*fixture.frame), fixture.geometry).haloPS();
+  const Frame::TimeSlice left{*fixture.frame, {.begin = 0, .end = 2}, haloPS};
+  const Frame::TimeSlice right{*fixture.frame, {.begin = 2, .end = 4}, haloPS};
+  BOOST_TEST(crossingFirst >= left.core[0].begin);
+  BOOST_TEST(crossingFirst < left.core[0].end);
+  BOOST_TEST(crossingMiddle >= right.core[1].begin);
+  BOOST_TEST(crossingMiddle < right.core[1].end);
+  BOOST_TEST(crossingMiddle >= left.halo[1].begin);
+  BOOST_TEST(crossingMiddle < left.halo[1].end);
+
+  for (const auto* run : {&oneBlock, &twoBlocks, &shifted}) {
+    BOOST_REQUIRE(run->tracklets > 0U);
+    BOOST_TEST(run->haloSourceTracklets > 0U);
+  }
+  const auto fraction = [](const SliceRun& run) { return static_cast<double>(run.haloSourceTracklets) / static_cast<double>(run.tracklets); };
+  BOOST_TEST_MESSAGE("halo-source tracklet fractions: one-block " << fraction(oneBlock) << ", two-block " << fraction(twoBlocks) << ", shifted " << fraction(shifted));
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testVertexStage.cxx b/Detectors/GenericTracking/tracking/test/testVertexStage.cxx
new file mode 100644
index 0000000000000..63c15fee1a255
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testVertexStage.cxx
@@ -0,0 +1,408 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testVertexStage.cxx
+/// \brief The vertexer on synthetic triplets: separated and close vertices,
+///        frames, the contributor floor, the cuts, a fake tracklet shared by
+///        many triplets, and a list that does not depend on the threads or on
+///        the triplets' order.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK VertexStage
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/Parallel.h"
+#include "GenericTracking/Tracking/VertexStage.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <bit>
+#include <numbers>
+#include <random>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+/// The ITS's readout frame [BC].
+constexpr std::int64_t kFrameBC = 198;
+constexpr double kSigmaZ = 5.e-4; // [cm]
+constexpr std::array<double, 3> kRadii{2.34, 3.15, 3.93};
+
+/// The vertexer's candidate errors from the points alone: the r-z line's.
+struct LineErrors {
+  [[nodiscard]] Scalar operator()(const PairPoint& /*first*/, const VertexCandidateFit& fit) const { return fit.varZ0Line; }
+};
+
+/// The columns `pairPointAt` and the vertexer read, as plain vectors.
+struct Measurements {
+  std::vector<Scalar> x, y, z, r, varZ, varR, varRPhi;
+  std::vector<std::uint32_t> timePS, widthPS;
+};
+struct Tracklets {
+  std::vector<std::uint32_t> source, target;
+};
+struct Triplets {
+  std::vector<std::uint32_t> first, second;
+};
+
+/// A timeframe of triplets, built track by track.
+class Event
+{
+ public:
+  explicit Event(std::uint64_t seed = 1U) : mRandom(seed) {}
+
+  std::uint32_t point(double x, double y, double z, const TimeEstPS& box)
+  {
+    const auto row = static_cast<std::uint32_t>(m.x.size());
+    m.x.push_back(static_cast<Scalar>(x));
+    m.y.push_back(static_cast<Scalar>(y));
+    m.z.push_back(static_cast<Scalar>(z));
+    m.r.push_back(static_cast<Scalar>(std::hypot(x, y)));
+    m.varZ.push_back(static_cast<Scalar>(kSigmaZ * kSigmaZ));
+    m.varR.push_back(0.F);
+    m.varRPhi.push_back(static_cast<Scalar>(kSigmaZ * kSigmaZ));
+    m.timePS.push_back(box.start);
+    m.widthPS.push_back(box.width);
+    return row;
+  }
+
+  std::uint32_t tracklet(std::uint32_t source, std::uint32_t target)
+  {
+    t.source.push_back(source);
+    t.target.push_back(target);
+    return static_cast<std::uint32_t>(t.source.size() - 1U);
+  }
+
+  void triplet(std::uint32_t first, std::uint32_t second)
+  {
+    p.first.push_back(first);
+    p.second.push_back(second);
+  }
+
+  /// A track from (0, 0, \a zVertex) at azimuth \a phi, with cot theta
+  /// \a cotTheta and transverse radius of curvature \a radius [cm] (bending
+  /// by \a charge), in frame \a frame; z measured with kSigmaZ. \a offset
+  /// shifts its points sideways [cm], away from the beam axis.
+  void track(double zVertex, double phi, double cotTheta, double radius, int charge, std::int64_t frame, double offset = 0., double kink = 0.)
+  {
+    std::normal_distribution<double> noise{0., kSigmaZ};
+    std::array<std::uint32_t, 3> rows{};
+    for (std::size_t layer = 0; layer < kRadii.size(); ++layer) {
+      const double r = kRadii[layer];
+      const double half = std::asin(r / (2. * radius));
+      const double angle = phi + (charge * half);
+      const double s = 2. * radius * half;
+      const double z = zVertex + (s * cotTheta) + (layer == 2U ? kink : 0.) + noise(mRandom);
+      rows[layer] = point((r * std::cos(angle)) - (offset * std::sin(phi)), (r * std::sin(angle)) + (offset * std::cos(phi)), z, frameTime(frame));
+    }
+    triplet(tracklet(rows[0], rows[1]), tracklet(rows[1], rows[2]));
+  }
+
+  /// \a count tracks from \a zVertex in \a frame, spread in azimuth and dip.
+  void vertex(double zVertex, std::size_t count, std::int64_t frame)
+  {
+    std::uniform_real_distribution<double> phi{0., 2. * std::numbers::pi};
+    std::uniform_real_distribution<double> cot{-1.2, 1.2};
+    std::uniform_real_distribution<double> radius{300., 1500.};
+    for (std::size_t i = 0; i < count; ++i) {
+      track(zVertex, phi(mRandom), cot(mRandom), radius(mRandom), (i % 2U) == 0U ? 1 : -1, frame);
+    }
+  }
+
+  /// \a count triplets of unrelated points in \a frame.
+  void noise(std::size_t count, std::int64_t frame)
+  {
+    std::uniform_real_distribution<double> phi{0., 2. * std::numbers::pi};
+    std::uniform_real_distribution<double> z{-15., 15.};
+    for (std::size_t i = 0; i < count; ++i) {
+      std::array<std::uint32_t, 3> rows{};
+      for (std::size_t layer = 0; layer < kRadii.size(); ++layer) {
+        const double angle = phi(mRandom);
+        rows[layer] = point(kRadii[layer] * std::cos(angle), kRadii[layer] * std::sin(angle), z(mRandom), frameTime(frame));
+      }
+      triplet(tracklet(rows[0], rows[1]), tracklet(rows[1], rows[2]));
+    }
+  }
+
+  /// Move every point by (\a dx, \a dy): the tracks then come from a beam
+  /// point off the axis the columns are about.
+  void shift(double dx, double dy)
+  {
+    for (std::size_t i = 0; i < m.x.size(); ++i) {
+      const double x = static_cast<double>(m.x[i]) + dx;
+      const double y = static_cast<double>(m.y[i]) + dy;
+      m.x[i] = static_cast<Scalar>(x);
+      m.y[i] = static_cast<Scalar>(y);
+      m.r[i] = static_cast<Scalar>(std::hypot(x, y));
+    }
+  }
+
+  static TimeEstPS frameTime(std::int64_t frame) { return frameBox(frame * kFrameBC, (frame + 1) * kFrameBC, 0); }
+
+  [[nodiscard]] VertexerResult find(const VertexerSettings& settings, detail::TaskArena* arena = nullptr) const { return Vertexer{settings, VertexConstraint{}}.find(m, t, p, p.first.size(), arena, true, LineErrors{}); }
+
+  Measurements m;
+  Tracklets t;
+  Triplets p;
+
+ private:
+  std::mt19937_64 mRandom;
+};
+
+bool sameVertices(const VertexerResult& a, const VertexerResult& b)
+{
+  if (a.vertices.size() != b.vertices.size() || a.contributors != b.contributors) {
+    return false;
+  }
+  // Bit for bit: every field widened to double exactly, then its bits.
+  const auto same = [](auto x, auto y) { return std::bit_cast<std::uint64_t>(static_cast<double>(x)) == std::bit_cast<std::uint64_t>(static_cast<double>(y)); };
+  for (std::size_t v = 0; v < a.vertices.size(); ++v) {
+    const auto& x = a.vertices[v];
+    const auto& y = b.vertices[v];
+    if (x.timePS != y.timePS || x.widthPS != y.widthPS || !same(x.z, y.z) || !same(x.varZ, y.varZ) || !same(x.varTransverse, y.varTransverse)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(EmptyTimeframe)
+{
+  const Event event;
+  const auto result = event.find({});
+  BOOST_TEST(result.vertices.empty());
+  BOOST_TEST(result.candidates == 0U);
+}
+
+BOOST_AUTO_TEST_CASE(TwoVerticesFarApartInOneFrame)
+{
+  Event event;
+  event.vertex(-3.2, 60U, 7);
+  event.vertex(1.8, 40U, 7);
+  const auto result = event.find({});
+  BOOST_TEST_REQUIRE(result.vertices.size() == 2U);
+  BOOST_TEST(std::abs(result.vertices[0].z - -3.2F) < 1.e-3F);
+  BOOST_TEST(std::abs(result.vertices[1].z - 1.8F) < 1.e-3F);
+  // The chi2 cut takes the tail of the z noise, a few in a hundred; every
+  // candidate left belongs to one of the two.
+  BOOST_TEST(result.contributors[0] + result.contributors[1] == result.candidates);
+  BOOST_TEST(result.contributors[0] >= 54U);
+  BOOST_TEST(result.contributors[1] >= 36U);
+  // The vertex's box spans its triplets', here all in frame 7.
+  BOOST_TEST(result.vertices[0].timePS == Event::frameTime(7).start);
+  BOOST_TEST(result.vertices[0].widthPS == Event::frameTime(7).width);
+  // Its z error is the mean's from the core's spread, no floor:
+  // a few micrometres for sixty candidates.
+  BOOST_TEST(result.vertices[0].varZ > 0.F);
+  BOOST_TEST(std::sqrt(result.vertices[0].varZ) < 1.e-3F);
+  BOOST_TEST(result.rounds == 3U);
+}
+
+BOOST_AUTO_TEST_CASE(CloseVerticesMergeWithinTheClaim)
+{
+  Event event;
+  event.vertex(0.50, 60U, 3);
+  event.vertex(0.60, 30U, 3);
+  VertexerSettings settings;
+  // 1 mm apart: the 2 mm claim takes both.
+  const auto merged = event.find(settings);
+  BOOST_TEST_REQUIRE(merged.vertices.size() == 1U);
+  BOOST_TEST(merged.contributors[0] == merged.candidates);
+  // A 500 um claim separates them.
+  settings.claimUM = 500;
+  const auto separate = event.find(settings);
+  BOOST_TEST_REQUIRE(separate.vertices.size() == 2U);
+  BOOST_TEST(std::abs(separate.vertices[0].z - 0.50F) < 1.e-3F);
+  BOOST_TEST(std::abs(separate.vertices[1].z - 0.60F) < 1.e-3F);
+}
+
+BOOST_AUTO_TEST_CASE(FramesStaySeparateAndInTimeOrder)
+{
+  Event event;
+  event.vertex(2.0, 20U, 9);
+  event.vertex(2.0, 20U, 5);
+  const auto result = event.find({});
+  BOOST_TEST_REQUIRE(result.vertices.size() == 2U);
+  BOOST_TEST(result.vertices[0].timePS == Event::frameTime(5).start);
+  BOOST_TEST(result.vertices[1].timePS == Event::frameTime(9).start);
+}
+
+BOOST_AUTO_TEST_CASE(TheContributorFloor)
+{
+  const std::uint32_t floor = VertexerSettings{}.minContributors;
+  Event below;
+  below.vertex(1.0, floor - 1U, 1);
+  BOOST_TEST(below.find({}).vertices.empty());
+  Event at;
+  at.vertex(1.0, floor, 1);
+  BOOST_TEST(at.find({}).vertices.size() == 1U);
+}
+
+/// A frame whose rounds find no vertex runs them again at
+/// aloneMinContributors; a frame with a vertex does not, so a small
+/// collision beside a large one stays below the floor.
+BOOST_AUTO_TEST_CASE(AFrameWithoutAVertexRerunsAtTheLowerFloor)
+{
+  Event event;
+  event.vertex(2.0, 20U, 3);
+  event.vertex(-6.0, 2U, 3);
+  event.vertex(1.0, 2U, 6);
+  BOOST_TEST(event.find({}).vertices.size() == 1U);
+  const auto result = event.find({.aloneMinContributors = 2U});
+  BOOST_TEST_REQUIRE(result.vertices.size() == 2U);
+  BOOST_TEST(result.vertices[0].timePS == Event::frameTime(3).start);
+  BOOST_TEST(std::abs(result.vertices[0].z - 2.F) < 0.05F);
+  BOOST_TEST(result.vertices[1].timePS == Event::frameTime(6).start);
+  BOOST_TEST(std::abs(result.vertices[1].z - 1.F) < 0.05F);
+  BOOST_TEST(result.contributors[1] == 2U);
+}
+
+/// A dense collision's measurements recombined into triplets that point
+/// elsewhere make no vertex: the dense vertex owns the measurements of its
+/// frame's triplets within its claim, and the free candidates with one are
+/// dropped. A small collision beside it, on measurements of
+/// its own, keeps its vertex.
+BOOST_AUTO_TEST_CASE(AVertexOwnsItsMeasurements)
+{
+  Event event;
+  event.vertex(-2.0, 80U, 4);
+  // Twelve fakes at z = 3 cm: each a dense track's innermost measurement
+  // with two new points on its transverse path, on a line to z = 3 cm.
+  const auto denseTriplets = event.p.first.size();
+  for (std::size_t i = 0; i < 12U; ++i) {
+    const auto a = event.t.source[event.p.first[i]];
+    const auto b = event.t.target[event.p.first[i]];
+    const auto c = event.t.target[event.p.second[i]];
+    const double slope = (static_cast<double>(event.m.z[a]) - 3.) / static_cast<double>(event.m.r[a]);
+    const auto box = Event::frameTime(4);
+    const auto fakeB = event.point(event.m.x[b], event.m.y[b], 3. + (slope * static_cast<double>(event.m.r[b])), box);
+    const auto fakeC = event.point(event.m.x[c], event.m.y[c], 3. + (slope * static_cast<double>(event.m.r[c])) + 2.e-4, box);
+    event.triplet(event.tracklet(a, fakeB), event.tracklet(fakeB, fakeC));
+  }
+  event.vertex(6.0, 8U, 4);
+  const auto result = event.find({});
+  BOOST_TEST_REQUIRE(result.vertices.size() == 2U);
+  BOOST_TEST(std::abs(result.vertices[0].z - -2.0F) < 1.e-3F);
+  BOOST_TEST(std::abs(result.vertices[1].z - 6.0F) < 1.e-3F);
+  BOOST_TEST(result.contributors[1] == 8U);
+  // Every fake is free: kept by the deduplication or not, none claimed.
+  for (std::size_t t = denseTriplets; t < denseTriplets + 12U; ++t) {
+    BOOST_TEST(result.tripletVertex[t] < 0);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(TheCuts)
+{
+  Event event;
+  event.track(1.0, 0.3, 0.5, 800., 1, 2, 0.1);      // 1 mm from the axis
+  event.track(1.0, 1.3, 0.5, 800., 1, 2, 0., 0.05); // a kink of 500 um in z
+  event.track(1.0, 2.3, 0.5, 800., 1, 2);
+  const auto result = event.find({});
+  BOOST_TEST(result.accepted == 1U);
+  BOOST_TEST(result.candidates == 1U);
+  BOOST_TEST(result.tripletVertex[0] == VertexerResult::kNone);
+  BOOST_TEST(result.tripletVertex[1] == VertexerResult::kNone);
+  BOOST_TEST(result.tripletVertex[2] == VertexerResult::kFree);
+}
+
+BOOST_AUTO_TEST_CASE(OneTrackletSharedByManyTripletsCountsOnce)
+{
+  // One tracklet 0 -> 1 pointing at z = 4, with 12 third points along its
+  // line: 12 triplets, nearly one z -- one candidate once they are made
+  // cluster-disjoint, so no vertex.
+  Event event;
+  const auto a = event.point(2.34, 0., 4. + (2.34 * 0.5), Event::frameTime(4));
+  const auto b = event.point(3.15, 0., 4. + (3.15 * 0.5), Event::frameTime(4));
+  const auto shared = event.tracklet(a, b);
+  for (int i = 0; i < 12; ++i) {
+    const double angle = 1.e-4 * i;
+    const auto c = event.point(3.93 * std::cos(angle), 3.93 * std::sin(angle), 4. + (3.93 * 0.5) + (2.e-4 * i), Event::frameTime(4));
+    event.triplet(shared, event.tracklet(b, c));
+  }
+  VertexerSettings settings;
+  settings.maxChi2RZ = 0.;
+  settings.maxDcaCM = 0.;
+  const auto result = event.find(settings);
+  BOOST_TEST(result.accepted == 12U);
+  BOOST_TEST(result.candidates == 1U);
+  BOOST_TEST(result.vertices.empty());
+}
+
+/// A particle with two clusters on a layer, where sensors overlap, makes two
+/// triplets; it counts once, through the better-fitting one.
+BOOST_AUTO_TEST_CASE(AParticleWithTwoTripletsCountsOnce)
+{
+  Event event;
+  constexpr int kTracks = 8;
+  for (int i = 0; i < kTracks; ++i) {
+    const double phi = 0.7 * i;
+    const auto at = [&](double r, double dz) { return event.point(r * std::cos(phi), r * std::sin(phi), 1. + (0.5 * r) + dz, Event::frameTime(2)); };
+    const auto a = at(2.34, 0.);
+    const auto b = at(3.15, 0.);
+    const auto bOverlap = at(3.16, 4.e-4);
+    const auto c = at(3.93, 0.);
+    event.triplet(event.tracklet(a, b), event.tracklet(b, c));
+    event.triplet(event.tracklet(a, bOverlap), event.tracklet(bOverlap, c));
+  }
+  const auto result = event.find({});
+  BOOST_TEST(result.accepted == 2U * kTracks);
+  BOOST_TEST(result.candidates == static_cast<std::size_t>(kTracks));
+  BOOST_REQUIRE(result.vertices.size() == 1U);
+  BOOST_TEST(result.contributors[0] == static_cast<std::uint32_t>(kTracks));
+  BOOST_TEST(std::abs(result.vertices[0].z - 1.F) < 1.e-4F);
+}
+
+BOOST_AUTO_TEST_CASE(NoiseMakesNoVertex)
+{
+  Event event{7U};
+  event.noise(3000U, 1);
+  event.vertex(-6.0, 200U, 1);
+  const auto result = event.find({});
+  BOOST_TEST_REQUIRE(result.vertices.size() == 1U);
+  BOOST_TEST(std::abs(result.vertices[0].z - -6.0F) < 1.e-3F);
+}
+
+BOOST_AUTO_TEST_CASE(TheListDoesNotDependOnThreadsOrOrder)
+{
+  Event event{11U};
+  for (std::int64_t frame = 1; frame < 40; frame += 2) {
+    event.vertex(-10. + (0.5 * static_cast<double>(frame)), 30U + static_cast<std::size_t>(frame), frame);
+    event.vertex(4. - (0.3 * static_cast<double>(frame)), 12U, frame);
+    event.noise(400U, frame);
+  }
+  const auto serial = event.find({});
+  BOOST_TEST(serial.vertices.size() >= 40U);
+  for (const int threads : {1, 4, 16}) {
+    detail::TaskArena arena{threads};
+    const auto parallel = event.find({}, &arena);
+    BOOST_TEST(sameVertices(serial, parallel));
+    BOOST_TEST(serial.tripletVertex == parallel.tripletVertex);
+  }
+  // The triplets in reverse: the same vertices, the claims carried along.
+  Event reversed = event;
+  std::ranges::reverse(reversed.p.first);
+  std::ranges::reverse(reversed.p.second);
+  const auto backwards = reversed.find({});
+  BOOST_TEST(sameVertices(serial, backwards));
+  auto claims = backwards.tripletVertex;
+  std::ranges::reverse(claims);
+  BOOST_TEST(claims == serial.tripletVertex);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/tracking/test/testVertexingPass.cxx b/Detectors/GenericTracking/tracking/test/testVertexingPass.cxx
new file mode 100644
index 0000000000000..eac97180b7d94
--- /dev/null
+++ b/Detectors/GenericTracking/tracking/test/testVertexingPass.cxx
@@ -0,0 +1,248 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testVertexingPass.cxx
+/// \brief The own vertexer before the tracking: one vertex per collision from the pass over the innermost
+///        layers, the same list at any thread count, and the vertex-list
+///        iterations finding with it the tracks they find with the true
+///        vertices.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK VertexingPass
+#include <boost/test/unit_test.hpp>
+#include <numbers>
+
+#include "GenericTracking/Tracking/Material.h"
+#include "GenericTracking/Tracking/Tracker.h"
+#include "GenericTracking/Tracking/VertexingPass.h"
+
+#include "ToyBarrel8Fixture.h"
+#include "UniformMaterial.h"
+
+#include <array>
+#include <bit>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <algorithm>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using namespace toybarrel8;
+using Pass = VertexingPass<Det, UniformMaterial>;
+
+/// Two collisions of eight tracks each, 500 ns apart, every track 0.5 to 2.6
+/// GeV from the origin.
+constexpr std::size_t kCollisions = 2U;
+constexpr std::size_t kTracksPerCollision = 8U;
+constexpr std::size_t kTracks = kCollisions * kTracksPerCollision;
+constexpr std::array<double, kCollisions> kStartNS{37., 537.};
+constexpr double kDurationNS = 600.;
+
+std::vector<Hit> hits()
+{
+  std::vector<Hit> result;
+  for (std::size_t track = 0; track < kTracks; ++track) {
+    const auto k = static_cast<double>(track);
+    const double pt = 0.5 + (0.3 * static_cast<double>(track % kTracksPerCollision));
+    const auto one = sensorHelixHits(std::fmod(0.3 + (2.1 * k), 2 * std::numbers::pi_v<double>), 0.03 * std::cos(1.3 * k), pt, kStartNS[track / kTracksPerCollision]);
+    BOOST_REQUIRE(one.size() == kLayers);
+    result.insert(result.end(), one.begin(), one.end());
+  }
+  return result;
+}
+
+/// The pass: the beam line, the three innermost layers, no holes, 0.3 GeV.
+IterationSettings passSettings()
+{
+  auto settings = iterationSettings();
+  settings.windows.minPtGeV = 0.3;
+  settings.minClusters = 3;
+  settings.maxKinks = 0;
+  settings.skipLinks = false;
+  settings.layerMask = 0b111U;
+  settings.follow = false;
+  return settings;
+}
+
+ScatteringTable<Det> noScattering()
+{
+  const std::array<double, kLayers> material{};
+  return scatteringTable<Det>(material);
+}
+
+/// The pass's slices: three blocks, as the tracking's in these tests.
+constexpr std::int32_t kSliceBlocks = 3;
+
+Pass::Result findVertices(const Fixture& fixture, int threads, std::int32_t sliceBlocks = kSliceBlocks)
+{
+  Pass pass{passSettings(), VertexerSettings{}, Fixture::kBeamConstraint, noScattering(), std::make_shared<BoundedMemoryResource>(), 2U, threads};
+  auto result = pass.find(*fixture.frame, sliceBlocks, 0);
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  return result;
+}
+
+/// A track as compared: its iteration, its rows and its chi2's bits.
+struct Found {
+  std::uint8_t iteration = 0U;
+  std::vector<std::uint32_t> rows;
+  std::uint32_t chi2 = 0U;
+  bool operator==(const Found&) const = default;
+};
+
+/// The tracks of two vertex-list iterations, at 1 and 0.3 GeV, seeded from
+/// \a vertices.
+std::vector<Found> trackFrom(const Fixture& fixture, std::span<const VertexSeed> vertices)
+{
+  auto first = iterationSettings();
+  first.vertexSource = VertexSource::kVertexList;
+  auto second = first;
+  second.windows.minPtGeV = 0.3;
+  const std::vector<IterationSettings> settings{first, second};
+  Tracker<Det, UniformMaterial> tracker{settings, Fixture::kBeamConstraint, noScattering(), std::make_shared<BoundedMemoryResource>(), 2U, 1};
+  static const UniformMaterial none{};
+  tracker.setTrackModel(trackingGeometry(), none, Propagator{});
+  const auto result = tracker.run(*fixture.frame, tracker.planTimeframe(*fixture.frame, vertices, 3, 0.));
+  BOOST_REQUIRE(result.status == StageStatus::kComplete);
+  std::vector<Found> tracks;
+  tracks.reserve(result.tracks->size());
+  const auto view = result.tracks->view();
+  for (std::size_t i = 0; i < result.tracks->size(); ++i) {
+    tracks.push_back({
+      .iteration = view.iteration[i],
+      .rows = {view.clusters[i].index, view.clusters[i].index + view.count[i]},
+      .chi2 = std::bit_cast<std::uint32_t>(view.chi2[i]),
+    });
+  }
+  return tracks;
+}
+
+} // namespace
+
+/// After `endTimeframe` the pass's pool holds what it held before `find`, the
+/// vertexer's work arrays included; the result is the caller's, off the pool.
+BOOST_AUTO_TEST_CASE(EndTimeframeGivesTheMemoryBack)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  for (const int threads : {1, 4}) {
+    BOOST_TEST_CONTEXT("threads " << threads)
+    {
+      const auto memory = std::make_shared<BoundedMemoryResource>();
+      Pass pass{passSettings(), VertexerSettings{}, Fixture::kBeamConstraint, noScattering(), memory, 2U, threads};
+      const auto before = memory->getUsedMemory();
+      for (int timeframe = 0; timeframe < 2; ++timeframe) {
+        const auto result = pass.find(*fixture.frame, kSliceBlocks, 0);
+        BOOST_REQUIRE(result.status == StageStatus::kComplete);
+        BOOST_TEST(result.found.vertices.size() == kCollisions);
+        BOOST_TEST(memory->getUsedMemory() > before);
+        BOOST_TEST(memory->getPeakMemory() > before);
+        pass.endTimeframe();
+        BOOST_TEST(memory->getUsedMemory() == before);
+      }
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(OneVertexPerCollision)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const auto result = findVertices(fixture, 1);
+  const auto& found = result.found;
+  // Every track's one triplet on layers 0-1-2 is a candidate; a combinatorial
+  // one besides them fails the candidates' cuts.
+  BOOST_TEST(found.triplets > kTracks);
+  BOOST_TEST(found.candidates == kTracks);
+  BOOST_REQUIRE(found.vertices.size() == kCollisions);
+  for (std::size_t collision = 0; collision < kCollisions; ++collision) {
+    BOOST_TEST_CONTEXT("collision " << collision)
+    {
+      const auto& vertex = found.vertices[collision];
+      BOOST_TEST(found.contributors[collision] == kTracksPerCollision);
+      BOOST_TEST(std::abs(vertex.z) < 5.e-4F);
+      // Its box holds the collision's tick: the vertices come in time order.
+      const auto startPS = static_cast<std::uint32_t>(kStartNS[collision] * 1000.);
+      BOOST_TEST(vertex.timePS <= startPS);
+      BOOST_TEST(startPS < vertex.timePS + vertex.widthPS);
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(TheListDoesNotDependOnTheThreads)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const auto one = findVertices(fixture, 1).found;
+  const auto four = findVertices(fixture, 4).found;
+  BOOST_REQUIRE(one.vertices.size() == four.vertices.size());
+  for (std::size_t v = 0; v < one.vertices.size(); ++v) {
+    BOOST_TEST(one.vertices[v].timePS == four.vertices[v].timePS);
+    BOOST_TEST(one.vertices[v].widthPS == four.vertices[v].widthPS);
+    BOOST_TEST(std::bit_cast<std::uint32_t>(one.vertices[v].z) == std::bit_cast<std::uint32_t>(four.vertices[v].z));
+    BOOST_TEST(std::bit_cast<std::uint32_t>(one.vertices[v].varZ) == std::bit_cast<std::uint32_t>(four.vertices[v].varZ));
+    BOOST_TEST(one.contributors[v] == four.contributors[v]);
+  }
+}
+
+/// Each slice finds its core's frames' vertices: the list and the claims
+/// are the timeframe's in one slice, at any width.
+BOOST_AUTO_TEST_CASE(TheListDoesNotDependOnTheSlices)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const auto find = [&](std::int32_t width) {
+    Pass pass{passSettings(), VertexerSettings{}, Fixture::kBeamConstraint, noScattering(), std::make_shared<BoundedMemoryResource>(), 2U, 2};
+    auto result = pass.find(*fixture.frame, width, 0, true);
+    BOOST_REQUIRE(result.status == StageStatus::kComplete);
+    std::ranges::sort(result.claims, {}, [](const TripletClaim& claim) { return std::pair{claim.rows, claim.vertex}; });
+    return result;
+  };
+  const auto whole = find(fixture.geometry.blockCount());
+  BOOST_REQUIRE(whole.found.vertices.size() == kCollisions);
+  for (const std::int32_t width : {1, 2, kSliceBlocks}) {
+    BOOST_TEST_CONTEXT("slices of " << width << " blocks")
+    {
+      const auto sliced = find(width);
+      BOOST_TEST(sliced.found.candidates == whole.found.candidates);
+      BOOST_REQUIRE(sliced.found.vertices.size() == whole.found.vertices.size());
+      for (std::size_t v = 0; v < whole.found.vertices.size(); ++v) {
+        BOOST_TEST(sliced.found.vertices[v].timePS == whole.found.vertices[v].timePS);
+        BOOST_TEST(sliced.found.vertices[v].widthPS == whole.found.vertices[v].widthPS);
+        BOOST_TEST(std::bit_cast<std::uint32_t>(sliced.found.vertices[v].z) == std::bit_cast<std::uint32_t>(whole.found.vertices[v].z));
+        BOOST_TEST(std::bit_cast<std::uint32_t>(sliced.found.vertices[v].varZ) == std::bit_cast<std::uint32_t>(whole.found.vertices[v].varZ));
+        BOOST_TEST(sliced.found.contributors[v] == whole.found.contributors[v]);
+      }
+      BOOST_TEST(std::ranges::equal(sliced.claims, whole.claims, [](const TripletClaim& a, const TripletClaim& b) { return a.rows == b.rows && a.vertex == b.vertex; }));
+    }
+  }
+}
+
+/// The list seeds the vertex-list iterations: they find every track, the
+/// same tracks as from the collisions' true vertices.
+BOOST_AUTO_TEST_CASE(ItsListSeedsTheVertexListIterations)
+{
+  const Fixture fixture{hits(), kDurationNS};
+  const auto found = findVertices(fixture, 1).found;
+  std::vector<VertexSeed> truth;
+  truth.reserve(kCollisions);
+  for (const double startNS : kStartNS) {
+    truth.push_back({.timePS = static_cast<std::uint32_t>(startNS * 1000.), .widthPS = 0U, .z = 0.F, .varZ = 1.e-4F, .varTransverse = 1.e-6F});
+  }
+  const auto fromPass = trackFrom(fixture, found.vertices);
+  BOOST_TEST(fromPass.size() == kTracks);
+  BOOST_TEST((fromPass == trackFrom(fixture, truth)));
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/workflow/CMakeLists.txt b/Detectors/GenericTracking/workflow/CMakeLists.txt
new file mode 100644
index 0000000000000..67af4f0273036
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/CMakeLists.txt
@@ -0,0 +1,69 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+# The ALICE adapters (the chips as our sensors, O2's clusters as ours, the
+# fields and readout frames), the cluster record, the parameters, the DPL
+# devices that make the tracking's measurements, each detector's in its own
+# unit, ALICE 3's (TRK.cxx) with the upgrades, and the tracking device
+# (TrackerDevice.h), one unit per detector, each instantiating the tracker.
+set(sources src/Clusters.cxx src/Placement.cxx src/RecoParam.cxx src/ITS.cxx src/MFT.cxx src/TrackerITS.cxx src/TrackerMFT.cxx src/AdaptorITS.cxx
+            src/AdaptorMFT.cxx src/GPURecoTracking.cxx)
+set(trackerUnits src/TrackerITS.cxx src/TrackerMFT.cxx)
+set(publicLibraries O2::GTrkTracking O2::Framework O2::CommonUtils O2::DataFormatsCalibration O2::DetectorsBase
+                    O2::DataFormatsITSMFT O2::ITSBase O2::MFTBase O2::DetectorsRaw ROOT::Core)
+set(privateLibraries O2::ITSMFTBase O2::ITSMFTTracking O2::DataFormatsITS O2::DataFormatsMFT O2::SimulationDataFormat O2::CommonConstants
+                     O2::MathUtils O2::ReconstructionDataFormats ROOT::Geom ROOT::RIO ROOT::Tree)
+if(ENABLE_UPGRADES)
+  list(APPEND sources src/TRK.cxx src/TrackerTRKFT3.cxx)
+  list(APPEND trackerUnits src/TrackerTRKFT3.cxx)
+  list(APPEND publicLibraries O2::DataFormatsTRKFT3 O2::TRKReconstruction O2::TRKBase)
+  list(APPEND privateLibraries O2::FT3Base O2::Field)
+endif()
+
+o2_add_library(GTrkWorkflow
+               SOURCES ${sources}
+               PUBLIC_LINK_LIBRARIES ${publicLibraries}
+               PRIVATE_LINK_LIBRARIES ${privateLibraries}
+               TARGETVARNAME targetName)
+
+# The tracker's units instantiate the header tracker (GTRK_TRACKER_OPTIMIZATION).
+set_source_files_properties(${trackerUnits} PROPERTIES COMPILE_OPTIONS "${GTRK_TRACKER_OPTIMIZATION}")
+
+# o2_add_library installs the headers of include/<library name> only.
+target_include_directories(${targetName} PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+install(DIRECTORY include/GenericTracking DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+# GTRKReco, a ConfigurableParam, which needs a dictionary for
+# --configKeyValues to reach its fields by name, and the cluster-shape band,
+# a CCDB object.
+o2_target_root_dictionary(GTrkWorkflow
+                          HEADERS include/GenericTracking/Workflow/RecoParam.h
+                                  include/GenericTracking/Workflow/ClusterShapeBand.h
+                          LINKDEF src/GTrkWorkflowLinkDef.h)
+
+# The tracking workflows, one per detector: O2's clusters in, GenericTracking's
+# tracks and vertices out; the ITS's and the MFT's also as O2's formats and files.
+o2_add_executable(its-reco-workflow
+                  SOURCES src/gtrk-its-reco-workflow.cxx
+                  COMPONENT_NAME gtrk
+                  PUBLIC_LINK_LIBRARIES O2::GTrkWorkflow O2::DetectorsRaw O2::ITSMFTWorkflow O2::ITSWorkflow O2::GlobalTrackingWorkflowWriters)
+o2_add_executable(mft-reco-workflow
+                  SOURCES src/gtrk-mft-reco-workflow.cxx
+                  COMPONENT_NAME gtrk
+                  PUBLIC_LINK_LIBRARIES O2::GTrkWorkflow O2::DetectorsRaw O2::ITSMFTWorkflow O2::ITSMFTCAWriter)
+if(ENABLE_UPGRADES)
+  o2_add_executable(trk-reco-workflow
+                    SOURCES src/gtrk-trk-reco-workflow.cxx
+                    COMPONENT_NAME gtrk
+                    PUBLIC_LINK_LIBRARIES O2::GTrkWorkflow O2::DetectorsRaw O2::TRKWorkflow)
+endif()
+
+add_subdirectory(test)
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Alice/Clusters.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Alice/Clusters.h
new file mode 100644
index 0000000000000..8d7f75d849ec4
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Alice/Clusters.h
@@ -0,0 +1,165 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Clusters.h
+/// \brief O2's compact clusters as our clusters: the steps every format takes,
+///        and the ITS's and MFT's format, `o2::itsmft::CompClusterExt`.
+///
+/// Two steps, so that the second can be tested without a dictionary:
+///
+/// - `localClusters` gives each compact cluster the local position, errors
+///   and pixel count of O2's ITS/MFT decode, `itsmft::ioutils::extractClusterData`:
+///   the dictionary's position and `Err2X`/`Err2Z` for a common topology, the
+///   pattern's centre of gravity with the dictionary's errors for a group, and
+///   the pattern's centre of gravity with half-pitch errors for an invalid
+///   pattern ID; and the pattern's row and column spans, the dictionary's or
+///   the stream's. The closure in `o2-gtrk-cluster-closure` holds them to
+///   O2's result.
+/// - `toClusters` maps them into our sensor frame (Placement.h) and gives each
+///   its readout frame as its time box (TimeEstPS.h), in O2's cluster order, so
+///   that a cluster's index here is its index in O2's cluster arrays and the
+///   MC labels carry over by index.
+///
+/// ALICE 3's format, `o2::trkft3::TRKCluster` and `FT3Cluster`, is TRK.h's;
+/// it takes the same two steps.
+
+#ifndef GTRK_ALICE_CLUSTERS_H_
+#define GTRK_ALICE_CLUSTERS_H_
+
+#include "GenericTracking/Base/TimeEstPS.h"
+#include "GenericTracking/Clustering/Cluster.h"
+
+#include "CommonConstants/LHCConstants.h"
+
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <format>
+#include <span>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+namespace o2::itsmft
+{
+class CompClusterExt;
+class ROFRecord;
+class TopologyDictionary;
+} // namespace o2::itsmft
+
+namespace o2::gtrk::alice
+{
+
+/// A compact cluster's position and errors in ALICE's sensor-local frame.
+struct LocalCluster {
+  std::uint32_t chip = 0;
+  float x = 0.F;       ///< ALICE local x, across the rows [cm]
+  float z = 0.F;       ///< ALICE local z, along the columns [cm]
+  float sigma2X = 0.F; ///< [cm^2]
+  float sigma2Z = 0.F;
+  std::uint32_t nPixels = 0;
+  std::uint8_t rowSpan = 0; ///< the pattern's rows
+  std::uint8_t colSpan = 0; ///< the pattern's columns
+};
+
+/// Every compact cluster's local position and errors, in order, reading the
+/// patterns of the group and invalid ones as it goes. Throws
+/// std::runtime_error for a pattern ID beyond \a dictionary; patterns that
+/// run out before a cluster's fail gsl::span's bounds check.
+[[nodiscard]] std::vector<LocalCluster> localClusters(std::span<const o2::itsmft::CompClusterExt> clusters, std::span<const unsigned char> patterns, const o2::itsmft::TopologyDictionary& dictionary);
+
+/// How long a detector's readout frames are.
+struct ReadoutFrames {
+  int lengthBC = 0;
+};
+
+/// Our clusters from the local ones, in the same order. \a tfFirstOrbit is
+/// the timeframe's first orbit, which a cluster's time is measured from.
+/// Throws std::runtime_error if a ROF does not cover its clusters exactly and
+/// in order, or starts before the timeframe.
+[[nodiscard]] std::vector<Cluster> toClusters(std::span<const LocalCluster> local, std::span<const o2::itsmft::ROFRecord> rofs, ReadoutFrames frames, std::uint32_t tfFirstOrbit);
+
+/// The readout frames as \a rofs lay them out: O2 writes one record per frame
+/// of the timeframe, empty or not, so their spacing is the frame length. That
+/// is the length the data were taken with, whatever a configuration dump says:
+/// in the MC the ITS's comes from CCDB (ITS/Config/AlpideParam, 198 BC) while
+/// the workflows' .ini files print the parameter's default, 891. Throws
+/// std::runtime_error unless there are two frames or more, evenly spaced.
+[[nodiscard]] ReadoutFrames readoutFrames(std::span<const o2::itsmft::ROFRecord> rofs);
+
+namespace detail
+{
+
+/// `toClusters` for any format's readout frames, our sensor's origin at
+/// \a xOrigin in ALICE's local x.
+template <typename ROFRecord>
+[[nodiscard]] std::vector<Cluster> toClusters(std::span<const LocalCluster> local, std::span<const ROFRecord> rofs, ReadoutFrames frames, std::uint32_t tfFirstOrbit, double xOrigin)
+{
+  if (frames.lengthBC <= 0) {
+    throw std::runtime_error("readout frame length not set");
+  }
+  std::vector<Cluster> result(local.size());
+  std::size_t next = 0;
+  for (const auto& rof : rofs) {
+    const auto& ir = rof.getBCData();
+    if (ir.orbit < tfFirstOrbit) {
+      throw std::runtime_error(std::format("a readout frame starts in orbit {}, before the timeframe's {}", ir.orbit, tfFirstOrbit));
+    }
+    if (std::cmp_not_equal(rof.getFirstEntry(), next) || rof.getNEntries() < 0 || next + static_cast<std::size_t>(rof.getNEntries()) > local.size()) {
+      throw std::runtime_error(std::format("readout frame at orbit {} bc {} does not continue the clusters at {}", ir.orbit, ir.bc, next));
+    }
+    const auto startBC = (static_cast<std::int64_t>(ir.orbit - tfFirstOrbit) * o2::constants::lhc::LHCMaxBunches) + ir.bc;
+    const auto box = frameBox(startBC, startBC + frames.lengthBC, 0);
+    for (int i = 0; i < rof.getNEntries(); ++i, ++next) {
+      const auto& in = local[next];
+      auto& out = result[next];
+      out.chipID = in.chip;
+      out.xLocal = static_cast<float>(static_cast<double>(in.x) - xOrigin);
+      out.yLocal = in.z;
+      out.sigmaXLocal = std::sqrt(in.sigma2X);
+      out.sigmaYLocal = std::sqrt(in.sigma2Z);
+      out.timePS = box.start;
+      out.widthPS = box.width;
+      out.rowSpan = in.rowSpan;
+      out.colSpan = in.colSpan;
+    }
+  }
+  if (next != local.size()) {
+    throw std::runtime_error(std::format("the readout frames cover {} of {} clusters", next, local.size()));
+  }
+  return result;
+}
+
+/// `readoutFrames` for any format's readout frames.
+template <typename ROFRecord>
+[[nodiscard]] ReadoutFrames readoutFrames(std::span<const ROFRecord> rofs)
+{
+  if (rofs.size() < 2) {
+    throw std::runtime_error("fewer than two readout frames: their length cannot be read off");
+  }
+  const auto spacing = [&rofs](std::size_t i) { return rofs[i + 1].getBCData().differenceInBC(rofs[i].getBCData()); };
+  const auto length = spacing(0);
+  for (std::size_t i = 1; i + 1 < rofs.size(); ++i) {
+    if (spacing(i) != length) {
+      throw std::runtime_error(std::format("readout frames {} and {} are {} BC apart, frames 0 and 1 {}", i, i + 1, spacing(i), length));
+    }
+  }
+  if (length <= 0) {
+    throw std::runtime_error("readout frames out of order");
+  }
+  return {.lengthBC = static_cast<int>(length)};
+}
+
+} // namespace detail
+
+} // namespace o2::gtrk::alice
+
+#endif // GTRK_ALICE_CLUSTERS_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Alice/Placement.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Alice/Placement.h
new file mode 100644
index 0000000000000..92e8f18914256
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Alice/Placement.h
@@ -0,0 +1,120 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Placement.h
+/// \brief A detector's chips as our sensors, from O2's GeometryTGeo: the frame
+///        every detector shares; each detector's `placeChips` is its own unit's.
+///
+/// Host-only, in the workflow library: the tracking library does not depend
+/// on it.
+///
+/// **The frame.** O2's L2G matrix maps a chip's local frame to the global one:
+/// x across the rows, y along the normal, z along the columns, with the
+/// origin already moved from the physical sensor's centre into the effective
+/// sensitive layer (`GeometryTGeo::extractMatrixSensor`). Ours has y along the
+/// columns and z along the normal, so a sensor's axes are ALICE's (x, z, -y),
+/// which is right-handed. On the ITS that normal points away from the beam;
+/// on the MFT it points along +z on odd faces and -z on even ones.
+///
+/// **The origin.** In the plane, the active matrix is not centred on the chip:
+/// the readout edge is wider than the opposite one, which moves the matrix
+/// centre along local x by `(PassiveEdgeReadOut - PassiveEdgeTop) / 2`,
+/// 0.58 mm. A sensor's origin is put there, so that the bounds of
+/// `detectors::alpide::kSensor` are symmetric about it, and a cluster's loc0 is
+/// ALICE's local x less `kActiveCentreX`.
+///
+/// **Chip IDs** are O2's. The ITS numbers its chips layer by layer; the MFT
+/// does not, and Geometry<Det> for a placed layout does not require it.
+
+#ifndef GTRK_ALICE_PLACEMENT_H_
+#define GTRK_ALICE_PLACEMENT_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Base/Sensor.h"
+
+#include "MathUtils/Cartesian.h"
+#include "MathUtils/Utils.h"
+
+#include <cstddef>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk::alice
+{
+
+/// Where the active matrix's centre sits in ALICE's local x [cm].
+extern const double kActiveCentreX;
+
+/// Our flat sensor on layer \a layer from its L2G matrix: axes ALICE's
+/// (x, z, -y), origin moved by \a activeCentreX along ALICE's x onto the
+/// active matrix's centre (0 where the sensor volume is the active matrix).
+[[nodiscard]] Sensor flatSensor(const o2::math_utils::Transform3D& l2g, int layer, double activeCentreX);
+
+/// Our curved sensor on layer \a layer from its L2G matrix: O2's frame whole,
+/// the cylinder's, z along its axis and the sensor's arc centred on +x
+/// (SensorSpec::unrolledToFrame).
+[[nodiscard]] Sensor curvedSensor(const o2::math_utils::Transform3D& l2g, int layer);
+
+/// Every chip of \a geometry as a flat sensor with the ALPIDE's active
+/// matrix (the ITS's and MFT's), indexed by O2's chip ID, `layer`
+/// `GeometryTGeo::getLayer`, `ring` 0.
+template <typename GeometryTGeo>
+[[nodiscard]] std::vector<Sensor> placeAlpides(GeometryTGeo& geometry)
+{
+  geometry.fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+  std::vector<Sensor> sensors;
+  sensors.reserve(static_cast<std::size_t>(geometry.getNumberOfChips()));
+  for (int chip = 0; chip < geometry.getNumberOfChips(); ++chip) {
+    sensors.push_back(flatSensor(geometry.getMatrixL2G(chip), geometry.getLayer(chip), kActiveCentreX));
+  }
+  return sensors;
+}
+
+/// Every chip of \a Det as our Sensor, indexed by our sensor ID, from the
+/// detector's GeometryTGeo: the one adopted from the CCDB, or one built from
+/// the geometry in gGeoManager. Defined in the detector's own unit (ITS.cxx,
+/// MFT.cxx, TRK.cxx).
+template <DetectorLayout Det>
+[[nodiscard]] std::vector<Sensor> placeChips();
+
+/// The placed geometry of \a Det from the geometry in gGeoManager, checked
+/// against the layout's sensor counts, in total and per layer. Throws
+/// std::runtime_error on a disagreement: that is a wrong file, or an O2
+/// geometry whose chip count changed. Where the chips sit is not checked
+/// against anything compiled; the Geometry built from these sensors measures
+/// its own layer envelopes.
+template <DetectorLayout Det>
+[[nodiscard]] std::vector<Sensor> placeChecked()
+{
+  auto sensors = placeChips<Det>();
+  if (sensors.size() != static_cast<std::size_t>(Det::nSensors)) {
+    throw std::runtime_error(std::string{Det::name} + ": " + std::to_string(sensors.size()) + " chips in the geometry, " + std::to_string(Det::nSensors) + " in the layout");
+  }
+  std::vector<int> counts(static_cast<std::size_t>(Detector<Det>::nLayers), 0);
+  for (const auto& sensor : sensors) {
+    if (sensor.layer >= counts.size()) {
+      throw std::runtime_error(std::string{Det::name} + ": a chip on layer " + std::to_string(sensor.layer) + ", beyond the layout's " + std::to_string(Detector<Det>::nLayers) + " layers");
+    }
+    ++counts[sensor.layer];
+  }
+  for (std::size_t layer = 0; layer < counts.size(); ++layer) {
+    const int stated = Detector<Det>::sensorCount(static_cast<LayerID>(layer));
+    if (counts[layer] != stated) {
+      throw std::runtime_error(std::string{Det::name} + ": layer " + std::to_string(layer) + " has " + std::to_string(counts[layer]) + " chips in the geometry, " + std::to_string(stated) + " in the layout");
+    }
+  }
+  return sensors;
+}
+
+} // namespace o2::gtrk::alice
+
+#endif // GTRK_ALICE_PLACEMENT_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Alice/TRK.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Alice/TRK.h
new file mode 100644
index 0000000000000..c487d0ab7cff6
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Alice/TRK.h
@@ -0,0 +1,107 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TRK.h
+/// \brief ALICE 3's tracker, TRK's barrel and FT3's discs, as ours: its
+///        cluster format, its topology dictionaries' depths, its readout
+///        frames and its field.
+///
+/// **Clusters.** `o2::trkft3::TRKCluster` and `FT3Cluster` come one stream per
+/// layer, each with its own frames, and every cluster carries its pattern:
+/// `trkLocalClusters` gives it its entry's position and widths in the layer's
+/// topology dictionary, and
+/// each stream goes through `toClusters` on its own (Clusters.h).
+///
+/// **Topology dictionaries.** O2's `o2::trkft3::TopologyDictionary` per
+/// detector, built by its CheckTopologyDictionary.C, CCDB conditions
+/// (`TRK/Calib/ClusterDictionary`, `FT3/Calib/ClusterDictionary`;
+/// ConditionsTRK.h). A dictionary's layers are O2's: TRK's numbered over the
+/// barrel (VD, then ML/OT), FT3's discs; ours are the same in that order, the
+/// discs after the barrel.
+///
+/// **Readout frames.** `TRKAlmiraParam`, one length, bias and delay per layer,
+/// as the digitiser took it from its configuration: a CCDB condition of the
+/// device (`TRK/Config/AlmiraParam`, ConditionsTRK.h), as the ITS's
+/// `ITS/Config/AlpideParam`.
+///
+/// **Field.** An ALICE 3 run records no field in its GRP (the L3 current is
+/// 0): O2's transport takes it from `o2::field::ALICE3MagneticField`, which
+/// compiles the macro `ALICE3_MAGFIELD_MACRO` names at run time. The
+/// tracking reads the same object, at run time, and never a compiled value.
+
+#ifndef GTRK_ALICE_TRK_H_
+#define GTRK_ALICE_TRK_H_
+
+#include "GenericTracking/Alice/Clusters.h"
+#include "GenericTracking/Base/FrameTiming.h"
+
+#include "DataFormatsTRKFT3/Cluster.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+
+#include <cstdint>
+#include <span>
+#include <vector>
+
+namespace o2::trkft3
+{
+class ROFRecord;
+template <int DetID>
+class TopologyDictionary;
+} // namespace o2::trkft3
+
+namespace o2::gtrk::alice
+{
+
+using TrkDictionary = o2::trkft3::TopologyDictionary<o2::detectors::DetID::TRK>;
+using Ft3Dictionary = o2::trkft3::TopologyDictionary<o2::detectors::DetID::FT3>;
+
+/// Every TRK cluster's local position, in order, reading its pattern as it
+/// goes, in our sensor's frame -- O2's x and z, and on the VD the flat x,
+/// which is our unrolled x, not curved --
+/// with its spans and pixel count: its \a dictionary entry's position (the
+/// centre of gravity, plus the entry's median offsets where the dictionary
+/// applies them) and its widths across and along as its errors. Throws
+/// std::runtime_error if the patterns run out, or a cluster names no TRK
+/// sub-detector or no layer of the dictionary.
+[[nodiscard]] std::vector<LocalCluster> trkLocalClusters(std::span<const o2::trkft3::TRKCluster> clusters, std::span<const unsigned char> patterns, const TrkDictionary& dictionary);
+
+/// The same for FT3's clusters, ML/OT's chip (sub-detector 2), each chip
+/// numbered as our sensor: TRKFT3::kFirstDiscSensor plus FT3's chip ID.
+[[nodiscard]] std::vector<LocalCluster> ft3LocalClusters(std::span<const o2::trkft3::FT3Cluster> clusters, std::span<const unsigned char> patterns, const Ft3Dictionary& dictionary);
+
+/// Clusters.h's `toClusters` for one layer's stream of TRK or FT3 clusters.
+[[nodiscard]] std::vector<Cluster> toClusters(std::span<const LocalCluster> local, std::span<const o2::trkft3::ROFRecord> rofs, ReadoutFrames frames, std::uint32_t tfFirstOrbit);
+
+/// Clusters.h's `readoutFrames` for one layer's stream of TRK or FT3 clusters.
+[[nodiscard]] ReadoutFrames readoutFrames(std::span<const o2::trkft3::ROFRecord> rofs);
+
+/// Our layers' measurement depths [cm] (Geometry::measurementDepth), barrel
+/// then discs: each dictionary layer's response depth, O2's local y, in our
+/// frame, whose normal is O2's -y on a flat sensor and the distance from the
+/// axis minus the radius on a curved one (Placement.cxx, LayerSpec.h): the
+/// opposite sign on every layer.
+[[nodiscard]] std::vector<double> measurementDepthsCM(const TrkDictionary& trk, const Ft3Dictionary& ft3);
+
+/// The TRKFT3 layers' readout frames from O2's `TRKAlmiraParam` as it stands
+/// -- a device's from the CCDB (`TRK/Config/AlmiraParam`, ConditionsTRK.h), a
+/// tool's from the digitiser's configuration --: each layer's length (O2's
+/// default, 18 BC, for an unset one, as the digitiser takes it) and first
+/// start, the bias and the delay together (`TRKDigitizerSpec`).
+[[nodiscard]] std::vector<FrameTiming> trkFrameTiming();
+
+/// Bz at the origin [kG] of O2's ALICE 3 field. Throws std::runtime_error if
+/// `ALICE3_MAGFIELD_MACRO` is unset or names no file: O2 would then fall back
+/// to a toy -10 kG field with only an error in its log.
+[[nodiscard]] double alice3BzKiloGauss();
+
+} // namespace o2::gtrk::alice
+
+#endif // GTRK_ALICE_TRK_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Clustering/Cluster.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Clustering/Cluster.h
new file mode 100644
index 0000000000000..360985fc97652
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Clustering/Cluster.h
@@ -0,0 +1,62 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Cluster.h
+/// \brief A cluster as the converters write it from O2's: the measurement
+///        producer's input (GTRK/<DET>CLUSTERS).
+
+#ifndef GTRK_CLUSTERING_CLUSTER_H_
+#define GTRK_CLUSTERING_CLUSTER_H_
+
+#include "GenericTracking/Base/Definitions.h"
+
+#include <cstdint>
+
+namespace o2::gtrk
+{
+
+/// One reconstructed measurement on a sensor.
+///
+/// A plain record; the measurement producer turns them into the measurement
+/// columns once, with the geometry.
+///
+/// A cluster is a sensor measurement and carries no global position: that is
+/// the sensor ID and the local position through the geometry, and the
+/// measurement producer computes it once, for every consumer downstream.
+struct Cluster {
+  SensorID chipID = kInvalidSensorID;
+
+  float xLocal = 0.F; ///< binary centre of gravity in the sensor frame [cm]
+  float yLocal = 0.F;
+
+  /// The errors in the sensor frame [cm]: the topology dictionary's
+  /// (Clusters.h, TRK.h).
+  float sigmaXLocal = 0.F;
+  float sigmaYLocal = 0.F;
+
+  /// The readout frame's record as a time box `[timePS, timePS + widthPS)` in
+  /// picoseconds from the timeframe's start, its edges rounded from BC
+  /// (TimeEstPS.h). Written by every converter; the
+  /// measurement producer moves it by the layer's frame start (FrameTiming.h:
+  /// the AlpideParam's delay and bias, TRK's `TRKAlmiraParam`).
+  std::uint32_t timePS = 0;
+  std::uint32_t widthPS = 0;
+
+  /// The pattern's rows (across, local x) and columns (along, local z); 0
+  /// where the converter has no pattern. The producer
+  /// turns them into the measurement's slope interval (ClusterShapeBand.h).
+  std::uint8_t rowSpan = 0;
+  std::uint8_t colSpan = 0;
+};
+
+} // namespace o2::gtrk
+
+#endif // GTRK_CLUSTERING_CLUSTER_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/AdaptorSpec.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/AdaptorSpec.h
new file mode 100644
index 0000000000000..e3a0602f8bc90
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/AdaptorSpec.h
@@ -0,0 +1,33 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file AdaptorSpec.h
+/// \brief The O2-format adaptor of the ITS or the MFT, gtrk-<det>-adaptor: the
+///        tracking device's products (TrackerSpec.h) as O2's tracker of the
+///        detector publishes its own, for O2's consumers unchanged.
+
+#ifndef GTRK_WORKFLOW_ADAPTORSPEC_H_
+#define GTRK_WORKFLOW_ADAPTORSPEC_H_
+
+#include "Framework/DataProcessorSpec.h"
+#include "GenericTracking/Base/LayerSpec.h"
+
+namespace o2::gtrk::workflow
+{
+
+/// The adaptor of \a Det (the ITS or the MFT); with \a useMC the track labels
+/// from the clusters' (and, for the ITS, the vertices' outputs, without truth).
+template <DetectorLayout Det>
+o2::framework::DataProcessorSpec getAdaptorSpec(bool useMC);
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_ADAPTORSPEC_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/BeamLine.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/BeamLine.h
new file mode 100644
index 0000000000000..24839a65397c4
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/BeamLine.h
@@ -0,0 +1,78 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file BeamLine.h
+/// \brief The run's beam line, from the MeanVertex calibration object, as
+///        the producer and the trackers read it.
+///
+/// A calibration input, not a reconstruction parameter:
+/// offline it is the run's `GLO/Calib/MeanVertex`. The producer subtracts its
+/// x and y from every measurement's global position, so that r, phi and the
+/// beam-frame variances the finding reads are about the corrected beam line,
+/// as O2's ITS tracker does (TimeFrame.cxx, the index tables); the fit works
+/// in the local frames and the detector frame, untouched. Its z and widths
+/// are the trackers' VertexConstraint. Without an object (the TRK, whose beam
+/// line is the nominal one: ConditionsTRK.h) the beam line is the nominal one:
+/// the axis, 20 um wide, 6 cm long, as the MC's Diamond gives.
+
+#ifndef GTRK_WORKFLOW_BEAMLINE_H_
+#define GTRK_WORKFLOW_BEAMLINE_H_
+
+#include "GenericTracking/Tracking/SearchWindow.h"
+
+#include "DataFormatsCalibration/MeanVertexObject.h"
+
+#include <algorithm>
+#include <format>
+#include <string>
+
+namespace o2::gtrk::workflow
+{
+
+struct BeamLine {
+  double x = 0.;         ///< [cm]
+  double y = 0.;         ///< [cm]
+  double z = 0.;         ///< [cm]
+  double sigmaX = 0.002; ///< [cm]
+  double sigmaY = 0.002; ///< [cm]
+  double sigmaZ = 6.;    ///< [cm]
+
+  bool operator==(const BeamLine&) const = default;
+};
+
+/// The nominal axis, as the MC's Diamond places the beam.
+[[nodiscard]] inline BeamLine nominalBeamLine() { return {}; }
+
+/// The run's, from its MeanVertex. The slopes are left out, as O2 leaves them:
+/// 2e-4 over the ITS's half length is 30 um, below the width.
+[[nodiscard]] inline BeamLine beamLineOf(const o2::dataformats::MeanVertexObject& object) { return {.x = object.getX(), .y = object.getY(), .z = object.getZ(), .sigmaX = object.getSigmaX(), .sigmaY = object.getSigmaY(), .sigmaZ = object.getSigmaZ()}; }
+
+/// The trackers' constraint: z and its width, and across the beam the larger
+/// of the two widths, since the pair test's beam term is a bound. The windows
+/// and cuts admit \a windowNSigma of the constraint's z width; that width is
+/// the beam's taken \a zReachNSigma / \a windowNSigma times, so that they
+/// reach \a zReachNSigma of the beam's.
+[[nodiscard]] inline VertexConstraint beamSpotConstraint(const BeamLine& beam, double zReachNSigma, double windowNSigma)
+{
+  return {
+    .z = beam.z,
+    .sigmaZ = beam.sigmaZ * zReachNSigma / windowNSigma,
+    .sigmaTransverse = std::max(beam.sigmaX, beam.sigmaY),
+    .x = beam.x,
+    .y = beam.y,
+  };
+}
+
+[[nodiscard]] inline std::string describe(const BeamLine& beam) { return std::format("({:.4f}, {:.4f}, {:.4f}) cm, widths ({:.4f}, {:.4f}, {:.3f}) cm", beam.x, beam.y, beam.z, beam.sigmaX, beam.sigmaY, beam.sigmaZ); }
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_BEAMLINE_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/ClusterConverterSpec.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/ClusterConverterSpec.h
new file mode 100644
index 0000000000000..e3d64259b0687
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/ClusterConverterSpec.h
@@ -0,0 +1,34 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ClusterConverterSpec.h
+/// \brief A detector's clusters, as O2's cluster readers publish them, into
+///        GTRK/<DET>CLUSTERS (DataSpecs.h).
+
+#ifndef GTRK_WORKFLOW_CLUSTERCONVERTERSPEC_H_
+#define GTRK_WORKFLOW_CLUSTERCONVERTERSPEC_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+
+#include "Framework/DataProcessorSpec.h"
+
+namespace o2::gtrk::workflow
+{
+
+/// Defined in the detector's own unit (ITS.cxx, MFT.cxx, TRK.cxx). The ITS's
+/// and MFT's readout frames must not be staggered: only subspecification 0 is
+/// read.
+template <DetectorLayout Det>
+o2::framework::DataProcessorSpec getClusterConverterSpec(bool useMC);
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_CLUSTERCONVERTERSPEC_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/ClusterShapeBand.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/ClusterShapeBand.h
new file mode 100644
index 0000000000000..9f0a11e7716b3
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/ClusterShapeBand.h
@@ -0,0 +1,92 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ClusterShapeBand.h
+/// \brief A detector's calibrated cluster-shape band, a CCDB object
+///        (`<DET>/Calib/ClusterShapeBand`): per cluster shape the slope
+///        interval a measurement carries.
+///
+/// Made from the simulation: per
+/// calibrated layer, the most rows a particle above the calibration's floor
+/// leaves, and per column span the hull of the local slopes (ShapeCut.h) at
+/// which such a particle leaves that many columns -- the calibration's band
+/// inverted, one interval per shape. A cluster
+/// without a pattern, or on a layer the band does not calibrate, gets every
+/// slope; one of more rows than its layer's most, or of a span no slope
+/// gives, none. The slope is the barrel's (the normal radial, the columns
+/// along z), so a band calibrates barrel layers only.
+
+#ifndef GTRK_WORKFLOW_CLUSTERSHAPEBAND_H_
+#define GTRK_WORKFLOW_CLUSTERSHAPEBAND_H_
+
+#include "GenericTracking/Tracking/ShapeCut.h"
+
+#include <Rtypes.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <format>
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::workflow
+{
+
+struct ClusterShapeBand {
+  /// A measurement's slope interval [first, second).
+  using Interval = std::pair<Scalar, Scalar>;
+  static constexpr Interval kEvery{0.F, kSlopeUnbounded};
+  static constexpr Interval kNone{std::numeric_limits<Scalar>::infinity(), 0.F};
+  /// The column spans a cluster can have, 0 to 255.
+  static constexpr std::size_t kSpans = 256;
+
+  std::vector<int> maxRows;     ///< per layer from the first, its most rows; 0 on a layer the band does not calibrate, as every one after
+  std::vector<float> slopeLow;  ///< per layer and column span, at layer * kSpans + span: the interval's start
+  std::vector<float> slopeHigh; ///< and its end
+
+  /// Whether it is a band of a layout of \a barrelLayers barrel layers: of
+  /// its first layers at most, every layer's spans there.
+  [[nodiscard]] bool fits(std::size_t barrelLayers) const { return maxRows.size() <= barrelLayers && slopeLow.size() == maxRows.size() * kSpans && slopeHigh.size() == maxRows.size() * kSpans; }
+
+  /// The slope interval of a cluster of \a rowSpan rows and \a colSpan
+  /// columns on layer \a layer.
+  [[nodiscard]] Interval interval(std::size_t layer, std::uint8_t rowSpan, std::uint8_t colSpan) const
+  {
+    if (colSpan == 0U || layer >= maxRows.size() || maxRows[layer] == 0) {
+      return kEvery;
+    }
+    if (std::cmp_greater(rowSpan, maxRows[layer])) {
+      return kNone;
+    }
+    const auto at = (layer * kSpans) + colSpan;
+    return {slopeLow[at], slopeHigh[at]};
+  }
+
+  /// One line: the layers it calibrates, with their most rows.
+  [[nodiscard]] std::string describe() const
+  {
+    std::string layers;
+    for (std::size_t layer = 0; layer < maxRows.size(); ++layer) {
+      if (maxRows[layer] != 0) {
+        layers += std::format("{}layer {} ({} rows)", layers.empty() ? "" : ", ", layer, maxRows[layer]);
+      }
+    }
+    return "cluster-shape band: " + (layers.empty() ? std::string{"no layer"} : layers);
+  }
+
+  ClassDefNV(ClusterShapeBand, 1);
+};
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_CLUSTERSHAPEBAND_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/Conditions.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/Conditions.h
new file mode 100644
index 0000000000000..244febffe34d3
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/Conditions.h
@@ -0,0 +1,205 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Conditions.h
+/// \brief The run's conditions for a GTRK device, per detector:
+///        `Conditions<Det, WithMaterial>`, and the ITS's and MFT's
+///        (ALICE 3's in ConditionsTRK.h).
+///
+/// Every detector's give a device, from the first timeframe on, what it
+/// places its layout from (`alice::placeChips`, which reads the detector's
+/// GeometryTGeo), the field as the propagator's nominal Bz (GridConfig.h's
+/// `nominalBzKiloGauss`), its readout frames per layer and its layers'
+/// measurement depths; they do not change within a run (a device sees one).
+/// The MeanVertex does, and is the measurement producer's own input, per
+/// timeframe, where the detector has one (`kMeanVertex`):
+///
+/// - `Conditions(inputs)` declares its condition inputs at construction;
+/// - `init(ic)` in the device's init, `checkUpdates(pc)` at the top of its
+///   run, `finaliseCCDB(matcher, obj)` forwarded from the device's;
+/// - held by the GPU reconstruction (`ConditionsHolder::kGPUReco`), only the
+///   detector's own: the GRPECS, the field and the ITS's LUT are that
+///   device's (a second GRPGeomHelper request is fatal);
+/// - `frameTiming()`; `measurementDepthsCM()`, empty for 0 on every layer;
+///   `origin()`, the detector's data origin; `kMeanVertex`, whether the
+///   detector's beam line is the run's MeanVertex (`GLO/Calib/MeanVertex`);
+/// - with `WithMaterial`, the material LUT (MaterialLUT.h) as one more
+///   condition, `materialLut()`: the devices that track take it, the
+///   measurement producer and the MC vertex reader (the default) fetch none.
+///
+/// The ITS's and MFT's are what O2's own trackers take by default: not the
+/// full TGeo but the detector's lightweight `GeometryTGeo` object
+/// (`ITS/Config/Geometry`, `MFT/Config/Geometry`), with its chip matrices
+/// filled, which the placement reads like a loaded geometry; the field
+/// (`GLO/Config/GRPMagField`) through GRPGeomHelper; and `<DET>/Config/AlpideParam`
+/// for the frames. Offline, from CCDB snapshots through DPL's
+/// `--condition-remap`.
+
+#ifndef GTRK_WORKFLOWS_CONDITIONS_H_
+#define GTRK_WORKFLOWS_CONDITIONS_H_
+
+#include "GenericTracking/Base/FrameTiming.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Workflow/DataSpecs.h"
+#include "GenericTracking/Workflow/MaterialLUT.h"
+
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
+#include "DetectorsBase/GRPGeomHelper.h"
+#include "Framework/CCDBParamSpec.h"
+#include "Framework/ConcreteDataMatcher.h"
+#include "Framework/InitContext.h"
+#include "Framework/InputRecord.h"
+#include "Framework/InputSpec.h"
+#include "Framework/ProcessingContext.h"
+#include "Headers/DataHeader.h"
+#include "ITSBase/GeometryTGeo.h"
+#include "MFTBase/GeometryTGeo.h"
+
+#include <fairlogger/Logger.h>
+
+#include <concepts>
+#include <cstdint>
+#include <format>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace o2::gtrk::workflow
+{
+
+/// Who holds a `Conditions`: a device of its own, which requests the run's
+/// GRPECS and field itself (GRPGeomHelper), or the GPU reconstruction, whose
+/// device requests them -- and GLO/Param/MatLUT, the ITS's material LUT --
+/// for everything it runs, and fetches and finalises them.
+enum class ConditionsHolder : std::uint8_t { kOwnDevice,
+                                             kGPUReco };
+
+/// The conditions a device of \a Det reads (see above); with \a WithMaterial
+/// also the material LUT; held by \a Holder.
+template <DetectorLayout Det, bool WithMaterial = false, ConditionsHolder Holder = ConditionsHolder::kOwnDevice>
+class Conditions;
+
+/// The material LUT's condition a `Conditions` holds: the LUT's, GRPGeomHelper's
+/// for the ITS inside the GPU reconstruction, or none.
+template <DetectorLayout Det, bool WithMaterial, ConditionsHolder Holder = ConditionsHolder::kOwnDevice>
+using MaterialConditionOf = std::conditional_t<!WithMaterial, NoMaterialCondition, std::conditional_t<Holder == ConditionsHolder::kGPUReco && std::same_as<Det, detectors::ITS>, GRPGeomMaterialCondition, MaterialCondition<Det>>>;
+
+/// The ITS's and the MFT's.
+template <DetectorLayout Det, bool WithMaterial, ConditionsHolder Holder>
+  requires std::same_as<Det, detectors::ITS> || std::same_as<Det, detectors::MFT>
+class Conditions<Det, WithMaterial, Holder>
+{
+  static constexpr bool kITS = std::same_as<Det, detectors::ITS>;
+  static constexpr bool kOwnDevice = Holder == ConditionsHolder::kOwnDevice;
+
+ public:
+  explicit Conditions(std::vector<o2::framework::InputSpec>& inputs)
+  {
+    if constexpr (kOwnDevice) {
+      mRequest = std::make_shared<o2::base::GRPGeomRequest>(false, true, false, true, false, o2::base::GRPGeomRequest::None, inputs);
+    }
+    const auto detector = origin().template as<std::string>();
+    inputs.emplace_back(inputBinding<Det>("geomTGeo"), origin(), "GEOMTGEO", 0, o2::framework::Lifetime::Condition, o2::framework::ccdbParamSpec(detector + "/Config/Geometry"));
+    inputs.emplace_back(inputBinding<Det>("alpideParam"), origin(), "ALPIDEPARAM", 0, o2::framework::Lifetime::Condition, o2::framework::ccdbParamSpec(detector + "/Config/AlpideParam"));
+    MaterialConditionOf<Det, WithMaterial, Holder>::declare(inputs);
+  }
+
+  static constexpr bool kMeanVertex = true;
+
+  [[nodiscard]] static o2::header::DataOrigin origin() { return detectorOrigin<Det>(); }
+
+  void init(o2::framework::InitContext& /*ic*/)
+  {
+    if constexpr (kOwnDevice) {
+      o2::base::GRPGeomHelper::instance().setRequest(mRequest);
+    }
+  }
+
+  void checkUpdates(o2::framework::ProcessingContext& pc) const
+  {
+    if constexpr (kOwnDevice) {
+      o2::base::GRPGeomHelper::instance().checkUpdates(pc);
+    }
+    pc.inputs().get<GeometryTGeoType*>(inputBinding<Det>("geomTGeo").c_str());
+    pc.inputs().get<AlpideParam*>(inputBinding<Det>("alpideParam").c_str()); // the CCDB fetcher updates the singleton
+    MaterialConditionOf<Det, WithMaterial, Holder>::checkUpdates(pc);
+  }
+
+  /// Whether \a matcher was one of these conditions, then taken.
+  bool finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj)
+  {
+    // The material first: the ITS's LUT is GLO/MATLUT, GRPGeomHelper's description.
+    if (mMaterial.finaliseCCDB(matcher, obj)) {
+      return true;
+    }
+    if constexpr (kOwnDevice) {
+      if (o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
+        return true;
+      }
+    }
+    if (matcher == o2::framework::ConcreteDataMatcher(origin(), "GEOMTGEO", 0)) {
+      GeometryTGeoType::adopt(static_cast<GeometryTGeoType*>(obj));
+      LOGP(info, "{} GeometryTGeo from the CCDB adopted", Det::name);
+      return true;
+    }
+    return false;
+  }
+
+  /// The readout frames of the run's `DPLAlpideParam`, as O2's ITS tracker
+  /// takes them (`ITSTrackingInterface::updateTimeDependentParams`): frame `k`
+  /// at `k * length + delay + bias` BC, one per layer, every layer the same.
+  /// Throws std::runtime_error for staggered frames: the converter reads one
+  /// ROF stream.
+  [[nodiscard]] std::vector<FrameTiming> frameTiming() const
+  {
+    const auto& param = AlpideParam::Instance();
+    const FrameTiming result{.lengthBC = param.getROFLengthInBC(0), .firstStartBC = param.getROFDelayInBC(0) + param.getROFBiasInBC(0)};
+    for (int layer = 1; layer < AlpideParam::getNLayers(); ++layer) {
+      if (param.getROFLengthInBC(layer) != result.lengthBC || param.getROFDelayInBC(layer) + param.getROFBiasInBC(layer) != result.firstStartBC) {
+        throw std::runtime_error(std::format("{}'s readout frames are staggered (layer {}): not read yet", Det::name, layer));
+      }
+    }
+    if (result.lengthBC <= 0) {
+      throw std::runtime_error(std::format("{}'s AlpideParam gives readout frames of {} BC", Det::name, result.lengthBC));
+    }
+    return std::vector<FrameTiming>(static_cast<std::size_t>(Detector<Det>::nLayers), result);
+  }
+
+  /// The run's orbits per timeframe, its GRPECS's, as O2's ITS tracking
+  /// takes them.
+  [[nodiscard]] static int orbitsPerTimeframe() { return o2::base::GRPGeomHelper::getNHBFPerTF(); }
+
+  /// None: the ALPIDE's clusters are at the effective sensitive layer's
+  /// centre, 0 on every layer.
+  [[nodiscard]] std::vector<double> measurementDepthsCM() const { return {}; }
+
+  /// The run's material LUT, the CCDB cache's; null before the first timeframe.
+  [[nodiscard]] const o2::base::MatLayerCylSet* materialLut() const
+    requires WithMaterial
+  {
+    return mMaterial.lut();
+  }
+
+ private:
+  using GeometryTGeoType = std::conditional_t<kITS, o2::its::GeometryTGeo, o2::mft::GeometryTGeo>;
+  using AlpideParam = o2::itsmft::DPLAlpideParam<kITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT>;
+
+  std::shared_ptr<o2::base::GRPGeomRequest> mRequest; ///< the run-wide conditions' request, in a device of its own
+  [[no_unique_address]] MaterialConditionOf<Det, WithMaterial, Holder> mMaterial;
+};
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOWS_CONDITIONS_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/ConditionsTRK.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/ConditionsTRK.h
new file mode 100644
index 0000000000000..f8c114f179ade
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/ConditionsTRK.h
@@ -0,0 +1,183 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ConditionsTRK.h
+/// \brief ALICE 3's run conditions for a GTRK device (Conditions.h), and its
+///        topology dictionaries as CCDB conditions.
+///
+/// ALICE 3's conditions are CCDB objects, as the ITS's: the aligned geometry
+/// (`GLO/Config/GeometryAligned`, through GRPGeomHelper), the readout frames'
+/// `TRKAlmiraParam` (`TRK/Config/AlmiraParam`, its singleton updated by the
+/// CCDB fetch, as `ITS/Config/AlpideParam`'s) and the topology dictionaries
+/// (`TRK/Calib/ClusterDictionary`, `FT3/Calib/ClusterDictionary`). The field
+/// is O2's ALICE 3 field (`alice3BzKiloGauss`): O2 builds it from the macro
+/// `ALICE3_MAGFIELD_MACRO` names, not from a GRP; the beam line is the nominal
+/// one (the simulation's diamond). Offline, from CCDB snapshots through DPL's
+/// `--condition-remap`.
+
+#ifndef GTRK_WORKFLOWS_CONDITIONSTRK_H_
+#define GTRK_WORKFLOWS_CONDITIONSTRK_H_
+
+#include "GenericTracking/Alice/TRK.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Workflow/Conditions.h"
+
+#include "DetectorsBase/GRPGeomHelper.h"
+#include "DetectorsRaw/HBFUtils.h"
+#include "DetectorsBase/Propagator.h"
+#include "Framework/CCDBParamSpec.h"
+#include "Framework/ConcreteDataMatcher.h"
+#include "Framework/InitContext.h"
+#include "Framework/InputRecord.h"
+#include "Framework/InputSpec.h"
+#include "Framework/ProcessingContext.h"
+#include "Headers/DataHeader.h"
+#include "TRKBase/AlmiraParam.h"
+#include "TRKReconstruction/TopologyDictionary.h"
+
+#include <fairlogger/Logger.h>
+
+#include <format>
+#include <memory>
+#include <stdexcept>
+#include <vector>
+
+namespace o2::gtrk::workflow
+{
+
+/// The TRK's and FT3's topology dictionaries, condition inputs of the device
+/// that holds them.
+class TrkDictionaryConditions
+{
+ public:
+  explicit TrkDictionaryConditions(std::vector<o2::framework::InputSpec>& inputs)
+  {
+    inputs.emplace_back("trkDictionary", "TRK", "CLUSDICT", 0, o2::framework::Lifetime::Condition, o2::framework::ccdbParamSpec("TRK/Calib/ClusterDictionary"));
+    inputs.emplace_back("ft3Dictionary", "FT3", "CLUSDICT", 0, o2::framework::Lifetime::Condition, o2::framework::ccdbParamSpec("FT3/Calib/ClusterDictionary"));
+  }
+
+  /// At the top of the device's run: delivers a new one through finaliseCCDB.
+  static void checkUpdates(o2::framework::ProcessingContext& pc)
+  {
+    pc.inputs().get<alice::TrkDictionary*>("trkDictionary");
+    pc.inputs().get<alice::Ft3Dictionary*>("ft3Dictionary");
+  }
+
+  /// Whether \a matcher is one of them, which is then taken. Throws
+  /// std::runtime_error if its layers are not the TRKFT3 layout's barrel
+  /// layers or discs.
+  bool finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj)
+  {
+    constexpr int kBarrel = Detector<detectors::TRKFT3>::nBarrelLayers;
+    if (matcher == o2::framework::ConcreteDataMatcher("TRK", "CLUSDICT", 0)) {
+      mTrk = checked(static_cast<const alice::TrkDictionary*>(obj), "TRK", kBarrel);
+      return true;
+    }
+    if (matcher == o2::framework::ConcreteDataMatcher("FT3", "CLUSDICT", 0)) {
+      mFt3 = checked(static_cast<const alice::Ft3Dictionary*>(obj), "FT3", Detector<detectors::TRKFT3>::nLayers - kBarrel);
+      return true;
+    }
+    return false;
+  }
+
+  /// The CCDB cache's; null before the first timeframe.
+  [[nodiscard]] const alice::TrkDictionary* trk() const { return mTrk; }
+  [[nodiscard]] const alice::Ft3Dictionary* ft3() const { return mFt3; }
+
+ private:
+  template <typename Dictionary>
+  static const Dictionary* checked(const Dictionary* dictionary, const char* name, int layers)
+  {
+    if (dictionary->getNumberOfLayers() != layers) {
+      throw std::runtime_error(std::format("{}'s topology dictionary has {} layers, the TRKFT3 layout {}", name, dictionary->getNumberOfLayers(), layers));
+    }
+    LOGP(info, "{}'s topology dictionary from the CCDB, its offsets {}", name, dictionary->getApplyOffsets() ? "applied" : "not applied");
+    return dictionary;
+  }
+
+  const alice::TrkDictionary* mTrk = nullptr;
+  const alice::Ft3Dictionary* mFt3 = nullptr;
+};
+
+/// ALICE 3's (see above).
+template <bool WithMaterial>
+class Conditions<detectors::TRKFT3, WithMaterial>
+{
+ public:
+  explicit Conditions(std::vector<o2::framework::InputSpec>& inputs)
+    : mRequest(std::make_shared<o2::base::GRPGeomRequest>(false, false, false, false, false, o2::base::GRPGeomRequest::Aligned, inputs)),
+      mDictionaries(inputs)
+  {
+    inputs.emplace_back("almiraParam", origin(), "ALMIRAPARAM", 0, o2::framework::Lifetime::Condition, o2::framework::ccdbParamSpec("TRK/Config/AlmiraParam"));
+    MaterialConditionOf<detectors::TRKFT3, WithMaterial>::declare(inputs);
+  }
+
+  /// The orbits per timeframe of the ALICE 3 simulation's HBFUtils: it
+  /// writes no GRPECS.
+  [[nodiscard]] static int orbitsPerTimeframe() { return o2::raw::HBFUtils::Instance().getNOrbitsPerTF(); }
+
+  /// None: the beam line is the nominal one.
+  static constexpr bool kMeanVertex = false;
+
+  [[nodiscard]] static o2::header::DataOrigin origin() { return detectorOrigin<detectors::TRKFT3>(); }
+
+  /// The field as the propagator's nominal Bz, which every single-value use
+  /// reads (GridConfig.h's `nominalBzKiloGauss`).
+  void init(o2::framework::InitContext& /*ic*/)
+  {
+    o2::base::GRPGeomHelper::instance().setRequest(mRequest);
+    o2::base::Propagator::Instance(true)->setNominalBz(static_cast<float>(alice::alice3BzKiloGauss()));
+    LOGP(info, "TRK: the ALICE 3 field's Bz {} kG", o2::base::Propagator::Instance()->getNominalBz());
+  }
+
+  void checkUpdates(o2::framework::ProcessingContext& pc) const
+  {
+    o2::base::GRPGeomHelper::instance().checkUpdates(pc);
+    pc.inputs().get<o2::trk::AlmiraParam*>("almiraParam"); // the CCDB fetcher updates the singleton
+    TrkDictionaryConditions::checkUpdates(pc);
+    MaterialConditionOf<detectors::TRKFT3, WithMaterial>::checkUpdates(pc);
+  }
+
+  void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj)
+  {
+    if (mMaterial.finaliseCCDB(matcher, obj) || o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
+      return;
+    }
+    if (matcher == o2::framework::ConcreteDataMatcher(origin(), "ALMIRAPARAM", 0)) {
+      LOGP(info, "TRK's AlmiraParam from the CCDB");
+      return;
+    }
+    mDictionaries.finaliseCCDB(matcher, obj);
+  }
+
+  /// The readout frames of the run's `TRKAlmiraParam` (TRK.h).
+  [[nodiscard]] std::vector<FrameTiming> frameTiming() const { return alice::trkFrameTiming(); }
+
+  /// The topology dictionaries' (TRK.h).
+  [[nodiscard]] std::vector<double> measurementDepthsCM() const { return alice::measurementDepthsCM(*mDictionaries.trk(), *mDictionaries.ft3()); }
+
+  /// The run's material LUT, the CCDB cache's; null before the first timeframe.
+  [[nodiscard]] const o2::base::MatLayerCylSet* materialLut() const
+    requires WithMaterial
+  {
+    return mMaterial.lut();
+  }
+
+ private:
+  std::shared_ptr<o2::base::GRPGeomRequest> mRequest;
+  TrkDictionaryConditions mDictionaries;
+  [[no_unique_address]] MaterialConditionOf<detectors::TRKFT3, WithMaterial> mMaterial;
+};
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOWS_CONDITIONSTRK_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/DataSpecs.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/DataSpecs.h
new file mode 100644
index 0000000000000..271c8b4b5130b
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/DataSpecs.h
@@ -0,0 +1,196 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DataSpecs.h
+/// \brief The origin and descriptions the GTRK devices exchange, and the
+///        tracking's input as its consumers bind it.
+///
+/// One place, so that a producer and a consumer cannot disagree about a
+/// spelling that the framework only checks at run time.
+///
+/// The timeframe's start is o2::framework::TimingInfo's, its length
+/// o2::raw::HBFUtils'; the rest is the detector's RecoParam.
+
+#ifndef GTRK_WORKFLOW_DATASPECS_H_
+#define GTRK_WORKFLOW_DATASPECS_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Workflow/GridConfig.h"
+#include "GenericTracking/Workflow/RecoParam.h"
+
+#include "DetectorsCommonDataFormats/DetID.h"
+#include "Framework/InputRecord.h"
+#include "Framework/InputSpec.h"
+#include "Framework/Lifetime.h"
+#include "Framework/ProcessingContext.h"
+#include "Headers/DataHeader.h"
+
+#include <gsl/span>
+
+#include <cctype>
+#include <cstdint>
+#include <span>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+namespace o2::gtrk::workflow
+{
+
+inline constexpr o2::header::DataOrigin gDataOrigin{"GTRK"};
+
+/// \a Det's data origin, its O2 detector's: its readers' and its conditions'
+/// (`Conditions<Det>::origin()`).
+template <DetectorLayout Det>
+[[nodiscard]] constexpr o2::header::DataOrigin detectorOrigin()
+{
+  return o2::detectors::DetID::getDataOrigin(DetIDOf<Det>::value);
+}
+
+// A detector's messages are GTRK/<DET><kind>, <DET> its data origin
+// (`detectorOrigin<Det>()`): GTRK/ITSCLUSTERS, GTRK/MFTMEAS, ..., so that
+// the chains of several detectors run in one workflow.
+
+/// A flat array of gtrk::Cluster, one timeframe per message.
+inline constexpr std::string_view kClusters{"CLUSTERS"};
+
+/// The MC labels of that array, as an MCTruthContainer; with MC only.
+inline constexpr std::string_view kClustersMCTruth{"CLUSMCTR"};
+
+/// One SoA column of Measurement per message part, the subspecification being
+/// gtrk::MeasurementColumn, followed by the grid prefix-offset part. DPL
+/// frames the parts, so no additional message header is needed.
+inline constexpr std::string_view kMeasurements{"MEAS"};
+
+/// What the measurements are relative to (GridConfig.h's MeasurementGeometry):
+/// the beam line subtracted from their x and y and the grid they are binned
+/// in, the producer's for this timeframe.
+inline constexpr std::string_view kMeasurementGeometry{"MEASGEO"};
+
+/// The native vertex seeds, an optional input of the tracking: a flat array of
+/// gtrk::VertexSeed sorted by `timePS`, `timePS` and `widthPS` in ps from the
+/// timeframe's start, z in cm, `varZ` and `varTransverse` in cm^2 in the frame
+/// of the shipped beam line. The study's MC vertex reader fills it.
+inline constexpr std::string_view kVertices{"VERTICES"};
+
+// The tracking device's products (TrackerSpec.h), one message each, every
+// timeframe, empty when there is nothing.
+
+/// The tracks: a flat array of the tracker's records (`TrackRecord<Det>`),
+/// in the tracker's order, every record with its refit's status. A record's
+/// clusters are rows of the same timeframe's measurement message.
+inline constexpr std::string_view kTracks{"TRACKS"};
+
+/// The own vertexer's vertices: a flat array of gtrk::VertexSeed, sorted by
+/// time, then z; empty without the vertexer.
+inline constexpr std::string_view kVertexSeeds{"VTX"};
+
+/// Each of those vertices' contributors, a std::uint32_t per vertex.
+inline constexpr std::string_view kVertexContributors{"VTXCONTR"};
+
+/// Detector \a Det's name in lower case: "its", "mft", "trk".
+template <DetectorLayout Det>
+[[nodiscard]] std::string detectorName()
+{
+  auto det = detectorOrigin<Det>().template as<std::string>();
+  for (auto& c : det) {
+    c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+  }
+  return det;
+}
+
+/// Detector \a Det's input binding \a name, "<det>_<name>": two detectors'
+/// tracking inputs in one device (the GPU reconstruction) do not collide.
+template <DetectorLayout Det>
+[[nodiscard]] std::string inputBinding(std::string_view name)
+{
+  return detectorName<Det>() + "_" + std::string{name};
+}
+
+/// The input binding of the measurement message's part \a part: a
+/// gtrk::MeasurementColumn, or the grid's prefix offsets (`kColGridOffsets`).
+template <DetectorLayout Det>
+[[nodiscard]] std::string columnBinding(std::uint32_t part)
+{
+  return inputBinding<Det>("col" + std::to_string(part));
+}
+
+/// Detector \a Det's description of \a kind.
+template <DetectorLayout Det>
+[[nodiscard]] o2::header::DataDescription description(std::string_view kind)
+{
+  o2::header::DataDescription result;
+  result.runtimeInit((detectorOrigin<Det>().template as<std::string>() + std::string{kind}).c_str());
+  return result;
+}
+
+/// The measurement message's inputs: its columns, its grid offsets and what
+/// they are relative to (MEASGEO); \a withVertices, the native seeds too.
+template <DetectorLayout Det>
+[[nodiscard]] std::vector<o2::framework::InputSpec> measurementInputs(bool withVertices)
+{
+  using o2::framework::Lifetime;
+  std::vector<o2::framework::InputSpec> inputs;
+  inputs.reserve(kNMeasurementParts + 2U);
+  for (std::uint32_t part = 0; part < kNMeasurementParts; ++part) {
+    inputs.emplace_back(columnBinding<Det>(part), gDataOrigin, description<Det>(kMeasurements), part, Lifetime::Timeframe);
+  }
+  inputs.emplace_back(inputBinding<Det>("measurementGeometry"), gDataOrigin, description<Det>(kMeasurementGeometry), 0, Lifetime::Timeframe);
+  if (withVertices) {
+    inputs.emplace_back(inputBinding<Det>("vertices"), gDataOrigin, description<Det>(kVertices), 0, Lifetime::Timeframe);
+  }
+  return inputs;
+}
+
+/// A read-only span of a timeframe's message.
+template <class T>
+using MessageSpan = gsl::span<const T>;
+
+/// The timeframe's inputs of `measurementInputs`, valid while its message is.
+template <DetectorLayout Det>
+struct TimeframeInput {
+  MeasurementGeometry<Det> shipped; ///< the producer's beam line and grid
+  memlayout::Wrapper<MeasurementT, MessageSpan, memlayout::Layout::soa> columns;
+  std::span<const std::uint32_t> offsets; ///< the grid's prefix offsets
+  std::span<const VertexSeed> seeds;      ///< the native seeds; empty without them
+};
+
+/// The timeframe's inputs of `measurementInputs` from \a pc.
+template <DetectorLayout Det>
+[[nodiscard]] TimeframeInput<Det> readTimeframe(o2::framework::ProcessingContext& pc, bool withVertices)
+{
+  auto& inputs = pc.inputs();
+  const auto offsets = inputs.get<gsl::span<std::uint32_t>>(columnBinding<Det>(kColGridOffsets).c_str());
+  const auto seeds = withVertices ? inputs.get<gsl::span<VertexSeed>>(inputBinding<Det>("vertices").c_str()) : gsl::span<const VertexSeed>{};
+  return {
+    .shipped = inputs.get<MeasurementGeometry<Det>>(inputBinding<Det>("measurementGeometry").c_str()),
+    .columns = makeMeasurementColumns<MessageSpan>([&]<class T>(std::type_identity<T>, MeasurementColumn column) { return inputs.get<gsl::span<T>>(columnBinding<Det>(static_cast<std::uint32_t>(column)).c_str()); }),
+    .offsets = {offsets.data(), offsets.size()},
+    .seeds = {seeds.data(), seeds.size()},
+  };
+}
+
+/// Detector \a Det's device \a role: gtrk-<det>-<role>.
+template <DetectorLayout Det>
+[[nodiscard]] std::string deviceName(std::string_view role)
+{
+  return "gtrk-" + detectorName<Det>() + "-" + std::string{role};
+}
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_DATASPECS_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/GPURecoTracking.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/GPURecoTracking.h
new file mode 100644
index 0000000000000..507e7d3ab1e2a
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/GPURecoTracking.h
@@ -0,0 +1,80 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPURecoTracking.h
+/// \brief A detector's tracking inside O2's GPU reconstruction workflow
+///        (GPU/Workflow's GPURecoWorkflowSpec): the tracking device's
+///        timeframe, after the TPC's, on the same GPU, in the pool's free
+///        memory, borrowed per timeframe (DeviceContext). Its inputs are the
+///        measurement producer's message, its products the tracking device's
+///        (TrackerSpec.h); the converter, the producer and the adaptor stay
+///        devices of their own.
+
+#ifndef GTRK_WORKFLOW_GPURECOTRACKING_H_
+#define GTRK_WORKFLOW_GPURECOTRACKING_H_
+
+#include "Framework/ConcreteDataMatcher.h"
+#include "Framework/InitContext.h"
+#include "Framework/InputSpec.h"
+#include "Framework/OutputSpec.h"
+#include "Framework/ProcessingContext.h"
+
+#include <memory>
+#include <string_view>
+#include <vector>
+
+namespace o2::gpu
+{
+class GPUReconstruction;
+} // namespace o2::gpu
+
+namespace o2::gtrk::workflow
+{
+
+/// The calls GPURecoWorkflowSpec makes, in its own: the inputs and outputs
+/// when the workflow is defined; init after its reconstruction is
+/// initialised, on the same thread; finaliseCCDB before GRPGeomHelper's;
+/// run after the TPC's tracking and before the pool is cleared, on the
+/// thread that ran it; stop and endOfStream before the reconstruction goes.
+class GPURecoTracking
+{
+ public:
+  GPURecoTracking() = default;
+  GPURecoTracking(const GPURecoTracking&) = delete;
+  GPURecoTracking(GPURecoTracking&&) = delete;
+  GPURecoTracking& operator=(const GPURecoTracking&) = delete;
+  GPURecoTracking& operator=(GPURecoTracking&&) = delete;
+  virtual ~GPURecoTracking() = default;
+
+  /// The detector's inputs, appended to \a inputs: the measurements and the
+  /// detector's own conditions (the run-wide ones are the reconstruction's).
+  virtual void appendInputs(std::vector<o2::framework::InputSpec>& inputs) = 0;
+  /// The detector's products, appended to \a outputs.
+  virtual void appendOutputs(std::vector<o2::framework::OutputSpec>& outputs) = 0;
+  /// On \a reconstruction's GPU, initialised.
+  virtual void init(o2::framework::InitContext& ic, o2::gpu::GPUReconstruction& reconstruction) = 0;
+  /// Whether \a matcher was one of the detector's conditions, then taken.
+  virtual bool finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) = 0;
+  /// The timeframe; \a reconstructed false if the TPC's failed, then its
+  /// products are published empty and nothing is borrowed.
+  virtual void run(o2::framework::ProcessingContext& pc, bool reconstructed) = 0;
+  /// The GPU released.
+  virtual void stop() = 0;
+  virtual void endOfStream() = 0;
+};
+
+/// The tracking of \a detector, "its" or "mft"; std::invalid_argument for
+/// another.
+[[nodiscard]] std::unique_ptr<GPURecoTracking> makeGPURecoTracking(std::string_view detector);
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_GPURECOTRACKING_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/GeometryProvider.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/GeometryProvider.h
new file mode 100644
index 0000000000000..5b5f60d1d7108
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/GeometryProvider.h
@@ -0,0 +1,55 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GeometryProvider.h
+/// \brief A detector's geometry for a workflow device or a tool, placed from
+///        the detector's GeometryTGeo.
+///
+/// The layout is placed from O2's GeometryTGeo, aligned as it is, and
+/// checked against the layout's sensor counts (GenericTracking/Alice/Placement.h); its
+/// layer envelopes are measured from the placements and logged. A workflow
+/// device has the GeometryTGeo from the CCDB (Conditions.h) and places
+/// on its first timeframe; a tool loads an o2sim geometry file first. The
+/// layers' measurement depths are the caller's: the TRK's topology
+/// dictionaries' in a device (Conditions.h), the dump's in the bench.
+/// The holder keeps the result for its lifetime.
+
+#ifndef GTRK_WORKFLOW_GEOMETRYPROVIDER_H_
+#define GTRK_WORKFLOW_GEOMETRYPROVIDER_H_
+
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Base/LayerEnvelopes.h"
+
+#include <fairlogger/Logger.h>
+
+#include <memory>
+#include <span>
+
+namespace o2::gtrk::workflow
+{
+
+/// The geometry from the detector's GeometryTGeo as it is: adopted from the
+/// CCDB, or built from a loaded geometry file; \a depthsCM, each layer's
+/// measurement depth, or none for 0 on every layer.
+template <DetectorLayout Det>
+[[nodiscard]] std::unique_ptr<const Geometry<Det>> makeGeometry(std::span<const double> depthsCM = {})
+{
+  const auto sensors = alice::placeChecked<Det>();
+  auto geometry = std::make_unique<const Geometry<Det>>(sensors, depthsCM);
+  LOG(info) << Det::name << " placed from its GeometryTGeo, layer envelopes measured:\n"
+            << describeEnvelopes(PlacedEnvelopes<Det>::all(), Detector<Det>::nBarrelLayers);
+  return geometry;
+}
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_GEOMETRYPROVIDER_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/GridConfig.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/GridConfig.h
new file mode 100644
index 0000000000000..1132b2e8cbe6d
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/GridConfig.h
@@ -0,0 +1,398 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GridConfig.h
+/// \brief One mapping from workflow configuration to the measurement grid
+///        and the tracking iterations.
+
+#ifndef GTRK_WORKFLOWS_GRIDCONFIG_H_
+#define GTRK_WORKFLOWS_GRIDCONFIG_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Base/TimeEstPS.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Tracking/GridSizing.h"
+#include "GenericTracking/Tracking/Iteration.h"
+#include "GenericTracking/Tracking/MeasurementGrid.h"
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Tracking/VertexStage.h"
+#include "GenericTracking/Workflow/BeamLine.h"
+#include "GenericTracking/Base/FrameTiming.h"
+#include "GenericTracking/Workflow/RecoParam.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <format>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "CommonConstants/LHCConstants.h"
+#include "DetectorsBase/Propagator.h"
+
+namespace o2::gtrk::workflow
+{
+
+/// The grid's parameters: each layer's readout \a frames (one per layer), and
+/// the whole number of the longest frame nearest the configured block width
+/// (one at least), the blocks' edges a
+/// picosecond before that frame's starts (`GridParams::blockOrigin`), in parts
+/// of a picosecond that make a bunch crossing whole. With several layers of
+/// the longest length the first one's starts. The other layers' frames may
+/// straddle a block's edge: correct, only not minimal. A width of 0 stays one
+/// block over the timeframe.
+[[nodiscard]] inline GridParams gridParams(const RecoSettings& param, std::span<const FrameTiming> frames)
+{
+  if (frames.size() > GridParams::kMaxLayers) {
+    throw std::invalid_argument(std::format("{} layers of readout frames, the grid holds {}", frames.size(), GridParams::kMaxLayers));
+  }
+  GridParams params{.blockWidth = std::max<std::int64_t>(param.blockWidthPS, 0)};
+  std::ranges::copy(frames, std::begin(params.frames));
+  const auto longest = std::ranges::max_element(frames, {}, &FrameTiming::lengthBC);
+  if (longest == frames.end() || param.blockWidthPS <= 0) {
+    return params;
+  }
+  // A BC is kPSPerBCNumerator / kPSPerBCDenominator ps (TimeEstPS.h): the
+  // denominator's parts a ps, the numerator's a BC.
+  constexpr std::int64_t kPartsPerPS = kPSPerBCDenominator;
+  constexpr std::int64_t kPartsPerBC = kPSPerBCNumerator;
+  const double framePS = static_cast<double>(longest->lengthBC) * static_cast<double>(kPartsPerBC) / static_cast<double>(kPartsPerPS);
+  const auto perBlock = std::max<std::int64_t>(1, std::llround(static_cast<double>(param.blockWidthPS) / framePS));
+  params.partsPerPS = kPartsPerPS;
+  params.blockWidth = perBlock * longest->lengthBC * kPartsPerBC;
+  // A box's start is its frame's, rounded down by less than a picosecond.
+  params.blockOrigin = (longest->firstStartBC * kPartsPerBC) - kPartsPerPS;
+  return params;
+}
+
+/// The field every single-value use takes -- the windows, the pair cuts, the
+/// grid, the fit's propagator, the MC truth -- in kG: O2's nominal Bz, the run's
+/// map at the origin as o2::base::Propagator gives it, which is what O2's own ITS
+/// tracker uses. The field must have been loaded first:
+/// by GRPGeomHelper in a workflow (`fieldOnlyRequest`), by the tool itself
+/// outside DPL. o2::base::Propagator is fatal otherwise.
+[[nodiscard]] inline double nominalBzKiloGauss() { return static_cast<double>(o2::base::Propagator::Instance()->getNominalBz()); }
+
+/// The window physics every iteration shares; each iteration sets its own
+/// minimum pT (`iterationSettings`).
+[[nodiscard]] inline SearchWindowParams searchWindowPhysics(const RecoSettings& param)
+{
+  return {
+    .bzKiloGauss = nominalBzKiloGauss(),
+    .massGeV = param.massHypothesisGeV,
+    .materialX2X0 = param.materialX2X0,
+    .positionSigma = param.positionSigma,
+    .nSigma = param.windowNSigma,
+  };
+}
+
+/// Refuse a configuration \a Det's tracking cannot run with: margins of
+/// another length than one per layer or none, a negative margin, a mass
+/// hypothesis that is not positive (every charged particle has one). Called
+/// where a configuration is first read: the producer's init and the bench.
+template <DetectorLayout Det>
+inline void checkRecoParam(const RecoSettings& param)
+{
+  const auto margins = param.frameMarginBC.size();
+  if (margins != 0U && margins != static_cast<std::size_t>(Detector<Det>::nLayers)) {
+    throw std::invalid_argument(std::format("{}.frameMarginBC has {} entries for {}'s {} layers", RecoParamOf<Det>::type::Instance().getName(), margins, Det::name, Detector<Det>::nLayers));
+  }
+  if (!std::isfinite(param.massHypothesisGeV) || !(param.massHypothesisGeV > 0.)) {
+    throw std::invalid_argument(std::format("GTRKReco<DET>.massHypothesisGeV is {}: the mass hypothesis must be positive", param.massHypothesisGeV));
+  }
+  for (const auto margin : param.frameMarginBC) {
+    if (margin < 0) {
+      throw std::invalid_argument(std::format("GTRKReco<DET>.frameMarginBC holds {}: a margin widens a frame", margin));
+    }
+  }
+  if (!std::isfinite(param.beamZReachNSigma) || !(param.beamZReachNSigma > 0.) || !(param.windowNSigma > 0.)) {
+    throw std::invalid_argument(std::format("GTRKReco<DET>.beamZReachNSigma is {} and windowNSigma {}: both must be positive", param.beamZReachNSigma, param.windowNSigma));
+  }
+}
+
+/// The trackers' beam spot from \a beam, reaching `beamZReachNSigma` of its z
+/// width (BeamLine.h).
+[[nodiscard]] inline VertexConstraint beamSpotConstraint(const BeamLine& beam, const RecoSettings& param) { return beamSpotConstraint(beam, param.beamZReachNSigma, param.windowNSigma); }
+
+/// The tracker's memory pool: bounded at `memoryLimitGB` if that is positive,
+/// unbounded otherwise.
+[[nodiscard]] inline std::shared_ptr<BoundedMemoryResource> trackerMemoryPool(const RecoSettings& param)
+{
+  if (!(param.memoryLimitGB > 0.)) {
+    return std::make_shared<BoundedMemoryResource>();
+  }
+  constexpr double kBytesPerGB = 1024. * 1024. * 1024.;
+  const double bytes = std::floor(param.memoryLimitGB * kBytesPerGB);
+  constexpr auto kLargest = std::numeric_limits<std::size_t>::max();
+  return std::make_shared<BoundedMemoryResource>(bytes >= static_cast<double>(kLargest) ? kLargest : static_cast<std::size_t>(bytes));
+}
+
+/// The iterations \a param asks for: one per entry of `iterationMinPtGeV`.
+/// Each other per-iteration vector must have one entry per iteration or none
+/// (16 per iteration for `iterationClusterMinPtGeV`); anything else is a
+/// configuration error.
+[[nodiscard]] inline int iterationCount(const RecoSettings& param)
+{
+  const auto count = param.iterationMinPtGeV.size();
+  if (count == 0U) {
+    throw std::invalid_argument("GTRKReco<DET>.iterationMinPtGeV is empty: no iteration to run");
+  }
+  const auto check = [&](const char* name, std::size_t size, std::size_t perIteration) {
+    if (size != 0U && size != count * perIteration) {
+      throw std::invalid_argument(std::format("GTRKReco<DET>.{} has {} entries; {} iterations want {} or none", name, size, count, count * perIteration));
+    }
+  };
+  check("iterationVertexSource", param.iterationVertexSource.size(), 1U);
+  check("iterationMinClusters", param.iterationMinClusters.size(), 1U);
+  check("iterationMaxKinks", param.iterationMaxKinks.size(), 1U);
+  check("iterationKinkSigma", param.iterationKinkSigma.size(), 1U);
+  check("iterationGraphKinkSigma", param.iterationGraphKinkSigma.size(), 1U);
+  check("iterationImpactMaxCm", param.iterationImpactMaxCm.size(), 1U);
+  check("iterationImpactZMaxCm", param.iterationImpactZMaxCm.size(), 1U);
+  check("iterationSkipLinks", param.iterationSkipLinks.size(), 1U);
+  check("iterationLayerMask", param.iterationLayerMask.size(), 1U);
+  check("iterationRoadEndLayers", param.iterationRoadEndLayers.size(), 1U);
+  check("iterationRoadStartLayers", param.iterationRoadStartLayers.size(), 1U);
+  check("iterationSharedInnermost", param.iterationSharedInnermost.size(), 1U);
+  check("iterationFollow", param.iterationFollow.size(), 1U);
+  check("iterationFollowHoles", param.iterationFollowHoles.size(), 1U);
+  check("iterationFollowEnd", param.iterationFollowEnd.size(), 1U);
+  check("iterationInnerTrim", param.iterationInnerTrim.size(), 1U);
+  check("iterationCrossingRule", param.iterationCrossingRule.size(), 1U);
+  check("iterationFollowPrefix", param.iterationFollowPrefix.size(), 1U);
+  check("iterationFollowGreedy", param.iterationFollowGreedy.size(), 1U);
+  check("iterationFollowKeepChi2", param.iterationFollowKeepChi2.size(), 1U);
+  check("iterationFollowBeamEnd", param.iterationFollowBeamEnd.size(), 1U);
+  check("iterationShapeTest", param.iterationShapeTest.size(), 1U);
+  check("iterationFollowEndMaxSqrtDet", param.iterationFollowEndMaxSqrtDet.size(), 1U);
+  check("iterationFollowKeepDensity", param.iterationFollowKeepDensity.size(), 1U);
+  check("iterationFollowTrimMargin", param.iterationFollowTrimMargin.size(), 1U);
+  check("iterationMinClustersAfterFollow", param.iterationMinClustersAfterFollow.size(), 1U);
+  check("iterationBeamConstraint", param.iterationBeamConstraint.size(), 1U);
+  check("iterationFollowEarlier", param.iterationFollowEarlier.size(), 1U);
+  check("iterationSharedGraph", param.iterationSharedGraph.size(), 1U);
+  check("iterationClusterMinPtGeV", param.iterationClusterMinPtGeV.size(), static_cast<std::size_t>(RecoSettings::kClusterSlots));
+  return static_cast<int>(count);
+}
+
+/// Iteration \a iteration's settings: the grid's window physics with the
+/// iteration's minimum pT, and each other knob its vector's entry or default.
+[[nodiscard]] inline IterationSettings iterationSettings(const RecoSettings& param, int iteration)
+{
+  if (iteration < 0 || iteration >= iterationCount(param)) {
+    throw std::out_of_range(std::format("iteration {} of {}", iteration, param.iterationMinPtGeV.size()));
+  }
+  const auto index = static_cast<std::size_t>(iteration);
+  // A key without entries takes IterationSettings' default.
+  const IterationSettings defaults{};
+  const auto entry = [&](const std::vector<int>& values, int fallback) { return values.empty() ? fallback : values[index]; };
+  const auto flag = [&](const std::vector<int>& values, bool fallback) { return values.empty() ? fallback : values[index] != 0; };
+  const auto entryDouble = [&](const std::vector<double>& values, double fallback) { return values.empty() ? fallback : values[index]; };
+  // The layer masks: 64 bits, one per layer of the largest layout.
+  const auto entryMask = [&](const std::vector<long>& values, std::uint64_t fallback) { return values.empty() ? fallback : static_cast<std::uint64_t>(values[index]); };
+  auto windows = searchWindowPhysics(param);
+  windows.minPtGeV = param.iterationMinPtGeV[index];
+  windows.impactMax = entryDouble(param.iterationImpactMaxCm, defaults.windows.impactMax);
+  windows.impactZMax = entryDouble(param.iterationImpactZMaxCm, defaults.windows.impactZMax);
+  if (!(windows.impactMax >= 0.) || !(windows.impactZMax >= 0.)) {
+    throw std::invalid_argument(std::format("GTRKReco<DET>.iterationImpactMaxCm / iterationImpactZMaxCm of iteration {} is negative", iteration));
+  }
+  static_assert(RecoSettings::kClusterSlots == IterationSettings::kClusterSlots);
+  std::array<double, IterationSettings::kClusterSlots> floors{};
+  if (!param.iterationClusterMinPtGeV.empty()) {
+    for (std::size_t count = 0; count < floors.size(); ++count) {
+      floors[count] = param.iterationClusterMinPtGeV[(index * IterationSettings::kClusterSlots) + count];
+    }
+  }
+  const bool follow = flag(param.iterationFollow, defaults.follow);
+  const bool followEarlier = flag(param.iterationFollowEarlier, defaults.followEarlier);
+  if (followEarlier && !follow) {
+    throw std::invalid_argument(std::format("GTRKReco<DET>.iterationFollowEarlier of iteration {} needs its iterationFollow", iteration));
+  }
+  const int followHoles = entry(param.iterationFollowHoles, defaults.followHoles);
+  if (followHoles < 0) {
+    throw std::invalid_argument(std::format("GTRKReco<DET>.iterationFollowHoles of iteration {} is {}", iteration, followHoles));
+  }
+  const bool followEnd = flag(param.iterationFollowEnd, defaults.followEnd);
+  const bool beamConstraint = flag(param.iterationBeamConstraint, defaults.beamConstraint);
+  const bool followBeamEnd = flag(param.iterationFollowBeamEnd, defaults.followBeamEnd);
+  if (followBeamEnd && !(follow && beamConstraint)) {
+    throw std::invalid_argument(std::format("GTRKReco<DET>.iterationFollowBeamEnd of iteration {} needs its iterationFollow and iterationBeamConstraint", iteration));
+  }
+  const int innerTrim = entry(param.iterationInnerTrim, defaults.innerTrim);
+  if (innerTrim < 0) {
+    throw std::invalid_argument(std::format("GTRKReco<DET>.iterationInnerTrim of iteration {} is {}", iteration, innerTrim));
+  }
+  const int crossingRule = entry(param.iterationCrossingRule, static_cast<int>(defaults.crossingRule));
+  if (crossingRule < 0 || crossingRule > static_cast<int>(CrossingRule::kInsideFirst)) {
+    throw std::invalid_argument(std::format("GTRKReco<DET>.iterationCrossingRule of iteration {} is {}", iteration, crossingRule));
+  }
+  const double kinkSigma = entryDouble(param.iterationKinkSigma, defaults.kinkSigma);
+  // The road fit takes its last step with the allowance (fitOutward's
+  // LastStepAllowance); the follow's refit of the road without its end does not.
+  if (followEnd && kinkSigma > 1.) {
+    throw std::invalid_argument(std::format("GTRKReco<DET>.iterationFollowEnd of iteration {} with a kink allowance ({} sigma)", iteration, kinkSigma));
+  }
+  return {
+    .windows = windows,
+    .vertexSource = entry(param.iterationVertexSource, static_cast<int>(defaults.vertexSource)) == 0 ? VertexSource::kBeamLine : VertexSource::kVertexList,
+    .minClusters = entry(param.iterationMinClusters, defaults.minClusters),
+    .maxKinks = entry(param.iterationMaxKinks, defaults.maxKinks),
+    .kinkSigma = kinkSigma,
+    .graphKinkSigma = entryDouble(param.iterationGraphKinkSigma, defaults.graphKinkSigma),
+    .skipLinks = flag(param.iterationSkipLinks, defaults.skipLinks),
+    .layerMask = entryMask(param.iterationLayerMask, defaults.layerMask),
+    .roadEndLayers = entryMask(param.iterationRoadEndLayers, defaults.roadEndLayers),
+    .roadStartLayers = entryMask(param.iterationRoadStartLayers, defaults.roadStartLayers),
+    .minPtGeVByClusters = floors,
+    .sharedInnermost = static_cast<std::uint32_t>(std::max(entry(param.iterationSharedInnermost, static_cast<int>(defaults.sharedInnermost)), 0)),
+    .follow = follow,
+    .followHoles = followHoles,
+    .followEnd = followEnd,
+    .innerTrim = innerTrim,
+    .crossingRule = static_cast<CrossingRule>(crossingRule),
+    .followPrefix = flag(param.iterationFollowPrefix, defaults.followPrefix),
+    .followGreedy = flag(param.iterationFollowGreedy, defaults.followGreedy),
+    .followKeepChi2 = entryDouble(param.iterationFollowKeepChi2, defaults.followKeepChi2),
+    .followEndMaxSqrtDet = entryDouble(param.iterationFollowEndMaxSqrtDet, defaults.followEndMaxSqrtDet),
+    .followKeepDensity = entryDouble(param.iterationFollowKeepDensity, defaults.followKeepDensity),
+    .followBeamEnd = followBeamEnd,
+    .followTrimMargin = entryDouble(param.iterationFollowTrimMargin, defaults.followTrimMargin),
+    .minClustersAfterFollow = std::max(entry(param.iterationMinClustersAfterFollow, defaults.minClustersAfterFollow), 0),
+    .beamConstraint = beamConstraint,
+    .followEarlier = followEarlier,
+    .sharedGraph = flag(param.iterationSharedGraph, defaults.sharedGraph),
+    .shapeTest = flag(param.iterationShapeTest, defaults.shapeTest),
+  };
+}
+
+/// The own vertexer's settings, every member
+/// from the run's settings; VertexerSettings' defaults are the tests'.
+[[nodiscard]] inline VertexerSettings vertexerSettings(const RecoSettings& param)
+{
+  return {
+    .maxChi2RZ = static_cast<Scalar>(param.vertexerMaxChi2RZ),
+    .maxDcaCM = static_cast<Scalar>(param.vertexerMaxDcaCM),
+    .windowUM = param.vertexerWindowUM,
+    .claimUM = param.vertexerClaimUM,
+    .minContributors = static_cast<std::uint32_t>(std::max(param.vertexerMinContributors, 0)),
+    .aloneMinContributors = static_cast<std::uint32_t>(std::max(param.vertexerAloneMinContributors, 0)),
+    .significance = static_cast<Scalar>(param.vertexerSignificance),
+    .clipNSigma = static_cast<Scalar>(param.windowNSigma),
+  };
+}
+
+/// The vertexing pass: an iteration at the beam
+/// line whose links join the three innermost layers and skip none, at
+/// `vertexerMinPtGeV`. It runs its tracklets and triplets only, so the
+/// road, kink and follow knobs are never read; its chains are triplets,
+/// 3 clusters, which keeps its links (`takenLinks`).
+[[nodiscard]] inline IterationSettings vertexingPassSettings(const RecoSettings& param)
+{
+  auto windows = searchWindowPhysics(param);
+  windows.minPtGeV = param.vertexerMinPtGeV;
+  return {
+    .windows = windows,
+    .vertexSource = VertexSource::kBeamLine,
+    .minClusters = 3,
+    .maxKinks = 0,
+    .skipLinks = false,
+    .layerMask = 0b111U,
+    .follow = false,
+    .shapeTest = param.vertexerShapeTest != 0,
+  };
+}
+
+/// The iterations whose queries size the grid: the tracking's, and the
+/// vertexing pass with the vertexer on.
+[[nodiscard]] inline std::vector<IterationSettings> gridIterations(const RecoSettings& param)
+{
+  std::vector<IterationSettings> iterations;
+  iterations.reserve(static_cast<std::size_t>(iterationCount(param)) + 1U);
+  for (int iteration = 0; iteration < iterationCount(param); ++iteration) {
+    iterations.push_back(iterationSettings(param, iteration));
+  }
+  if (param.vertexer) {
+    iterations.push_back(vertexingPassSettings(param));
+  }
+  return iterations;
+}
+
+/// Whether a pass tests the measurements' cluster shapes (`iterationShapeTest`,
+/// `vertexerShapeTest` with the vertexer on): the measurement producer then
+/// takes the detector's cluster-shape band (ClusterShapeBand.h).
+[[nodiscard]] inline bool testsShapes(const RecoSettings& param)
+{
+  return (param.vertexer && param.vertexerShapeTest != 0) || std::ranges::any_of(param.iterationShapeTest, [](int test) { return test != 0; });
+}
+
+/// What a timeframe's measurements are relative to, which the producer ships
+/// beside them (DataSpecs.h's kMeasurementGeometry): the beam line subtracted
+/// from their x and y, and the grid they are binned in, built from the
+/// configuration and the timeframe's conditions. Whoever reads
+/// the measurements takes both from here.
+template <DetectorLayout Det>
+struct MeasurementGeometry {
+  BeamLine beamLine;
+  GridGeometry<Det> grid;
+};
+
+/// A tracker's sources as the log lines name them: "beam line" or "vertex
+/// list" when every iteration takes the one, both when the iterations differ.
+[[nodiscard]] inline std::string sourceLabel(std::span<const IterationSettings> settings)
+{
+  const auto from = [&](VertexSource source) { return std::ranges::any_of(settings, [&](const auto& s) { return s.vertexSource == source; }); };
+  const bool beam = from(VertexSource::kBeamLine);
+  const bool list = from(VertexSource::kVertexList);
+  if (beam && list) {
+    return "beam line and vertex list";
+  }
+  return list ? "vertex list" : "beam line";
+}
+
+/// A timeframe of \a orbits orbits' span [ps], its bunch crossings' rounded down.
+[[nodiscard]] inline std::int64_t timeframeDurationPS(int orbits) { return psOfBC(static_cast<std::int64_t>(orbits) * o2::constants::lhc::LHCMaxBunches); }
+
+/// The grid of the configured iterations: each layer's cells sized by the queries the iterations make
+/// into it (GridSizing.h), the vertexing pass's among them (`gridIterations`). A process derives it once, when it has its
+/// configuration and conditions, and keeps it. \a frames: each layer's
+/// readout frames, which its time blocks follow and the slices' reach reads;
+/// \a orbitsPerTimeframe: the run's (`Conditions::orbitsPerTimeframe`).
+template <DetectorLayout Det>
+[[nodiscard]] GridGeometry<Det> makeGridGeometry(const RecoSettings& param, const BeamLine& beam, std::span<const FrameTiming> frames, int orbitsPerTimeframe)
+{
+  const auto iterations = gridIterations(param);
+  if (frames.size() != static_cast<std::size_t>(Detector<Det>::nLayers)) {
+    throw std::invalid_argument(std::format("{}'s grid follows its {} layers' readout frames, and {} were given", Det::name, Detector<Det>::nLayers, frames.size()));
+  }
+  // A pT floor per cluster count has a slot for every chain the layout can
+  // hold, or none would apply to the longest silently.
+  if (!param.iterationClusterMinPtGeV.empty() && maxChainLayers<Det> + 1U > IterationSettings::kClusterSlots) {
+    throw std::invalid_argument(std::format("GTRKReco<DET>.iterationClusterMinPtGeV has {} slots per iteration, and {}'s chains reach {} clusters", IterationSettings::kClusterSlots, Det::name, maxChainLayers<Det>));
+  }
+  const auto windows = gridLayerWindows<Det>(iterations, beamSpotConstraint(beam, param));
+  GridGeometry<Det> geometry{timeframeDurationPS(orbitsPerTimeframe), gridParams(param, frames), windows};
+  if (geometry.overflows()) {
+    throw std::invalid_argument("GTRKReco<DET>'s grid has more cells or buckets than its 32-bit numbering holds: wider time blocks");
+  }
+  return geometry;
+}
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOWS_GRIDCONFIG_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/MaterialLUT.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/MaterialLUT.h
new file mode 100644
index 0000000000000..802a30a67422a
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/MaterialLUT.h
@@ -0,0 +1,125 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MaterialLUT.h
+/// \brief The tracking's material LUT, a CCDB condition per detector.
+///
+/// | detector | CCDB path |
+/// |---|---|
+/// | ITS | `GLO/Param/MatLUT` (O2's) |
+/// | MFT | `MFT/Param/MatLUT` (`o2-gtrk-build-matlut -d MFT`) |
+/// | TRKFT3 | `TRK/Param/MatLUT` (`o2-gtrk-build-matlut -d TRKFT3`, one LUT for TRK and FT3) |
+///
+/// `MaterialCondition<Det>` is the condition input `Conditions<Det, true>`
+/// holds (Conditions.h): the devices that track fetch it, the measurement
+/// producer and the MC vertex reader (`Conditions<Det>`) hold
+/// `NoMaterialCondition` in its place and fetch nothing. The LUT arrives
+/// through `finaliseCCDB`, rectified as GRPGeomHelper rectifies
+/// `GLO/Param/MatLUT`, and the CCDB cache owns it. Offline, from a CCDB
+/// snapshot through DPL's `--condition-remap`; a program without DPL (the
+/// bench) reads the same path through `o2::ccdb::BasicCCDBManager`.
+
+#ifndef GTRK_WORKFLOWS_MATERIALLUT_H_
+#define GTRK_WORKFLOWS_MATERIALLUT_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Workflow/DataSpecs.h"
+
+#include "DetectorsBase/GRPGeomHelper.h"
+#include "DetectorsBase/MatLayerCylSet.h"
+#include "Framework/CCDBParamSpec.h"
+#include "Framework/ConcreteDataMatcher.h"
+#include "Framework/InputRecord.h"
+#include "Framework/InputSpec.h"
+#include "Framework/ProcessingContext.h"
+#include "Headers/DataHeader.h"
+
+#include <fairlogger/Logger.h>
+
+#include <concepts>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk::workflow
+{
+
+/// The data origin of \a Det's material LUT: the detector's, but the ITS's,
+/// O2's global one, GLO.
+template <DetectorLayout Det>
+[[nodiscard]] o2::header::DataOrigin materialLutOrigin()
+{
+  return std::same_as<Det, detectors::ITS> ? o2::header::DataOrigin{"GLO"} : detectorOrigin<Det>();
+}
+
+/// The CCDB path of \a Det's material LUT.
+template <DetectorLayout Det>
+[[nodiscard]] std::string materialLutPath()
+{
+  return materialLutOrigin<Det>().template as<std::string>() + "/Param/MatLUT";
+}
+
+/// \a Det's material LUT as a condition input (see above).
+template <DetectorLayout Det>
+class MaterialCondition
+{
+ public:
+  /// Declares the input: called last by the holding `Conditions`'
+  /// constructor, so that the LUT's input follows the others.
+  static void declare(std::vector<o2::framework::InputSpec>& inputs) { inputs.emplace_back(inputBinding<Det>(kBinding), materialLutOrigin<Det>(), "MATLUT", 0, o2::framework::Lifetime::Condition, o2::framework::ccdbParamSpec(materialLutPath<Det>())); }
+
+  /// At the top of the device's run: delivers a new one through finaliseCCDB.
+  static void checkUpdates(o2::framework::ProcessingContext& pc) { pc.inputs().get<o2::base::MatLayerCylSet*>(inputBinding<Det>(kBinding).c_str()); }
+
+  /// Whether \a matcher is the LUT, which is then taken.
+  bool finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj)
+  {
+    if (!(matcher == o2::framework::ConcreteDataMatcher(materialLutOrigin<Det>(), "MATLUT", 0))) {
+      return false;
+    }
+    mLut = o2::base::MatLayerCylSet::rectifyPtrFromFile(static_cast<o2::base::MatLayerCylSet*>(obj));
+    LOGP(info, "{}'s material LUT from the CCDB ({})", Det::name, materialLutPath<Det>());
+    return true;
+  }
+
+  /// The CCDB cache's; null before the first timeframe.
+  [[nodiscard]] const o2::base::MatLayerCylSet* lut() const { return mLut; }
+
+ private:
+  static constexpr const char* kBinding = "gtrkMatLUT";
+
+  const o2::base::MatLayerCylSet* mLut = nullptr;
+};
+
+/// The ITS's material LUT inside the GPU reconstruction: GLO/Param/MatLUT,
+/// which the reconstruction's device requests and GRPGeomHelper holds,
+/// rectified. No input of its own.
+struct GRPGeomMaterialCondition {
+  static void declare(std::vector<o2::framework::InputSpec>& /*inputs*/) {}
+  static void checkUpdates(o2::framework::ProcessingContext& /*pc*/) {}
+  static bool finaliseCCDB(o2::framework::ConcreteDataMatcher& /*matcher*/, void* /*obj*/) { return false; }
+  /// Null before the first timeframe.
+  [[nodiscard]] static const o2::base::MatLayerCylSet* lut() { return o2::base::GRPGeomHelper::instance().getMatLUT(); }
+};
+
+/// What a `Conditions` without the material LUT holds in its place: no
+/// input, nothing fetched.
+struct NoMaterialCondition {
+  static void declare(std::vector<o2::framework::InputSpec>& /*inputs*/) {}
+  static void checkUpdates(o2::framework::ProcessingContext& /*pc*/) {}
+  static bool finaliseCCDB(o2::framework::ConcreteDataMatcher& /*matcher*/, void* /*obj*/) { return false; }
+};
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOWS_MATERIALLUT_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/MeasurementProducerSpec.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/MeasurementProducerSpec.h
new file mode 100644
index 0000000000000..a5f69d842da68
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/MeasurementProducerSpec.h
@@ -0,0 +1,33 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MeasurementProducerSpec.h
+/// \brief Clusters in; the grid-ordered measurement columns, their prefix
+///        offsets and the grid's layout with the beam line
+///        (`MeasurementGeometry`) out. One device per detector, its own
+///        instantiation.
+
+#ifndef GTRK_WORKFLOW_MEASUREMENTPRODUCERSPEC_H_
+#define GTRK_WORKFLOW_MEASUREMENTPRODUCERSPEC_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+
+#include "Framework/DataProcessorSpec.h"
+
+namespace o2::gtrk::workflow
+{
+
+template <DetectorLayout Det>
+o2::framework::DataProcessorSpec getMeasurementProducerSpec();
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_MEASUREMENTPRODUCERSPEC_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/O2Parameters.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/O2Parameters.h
new file mode 100644
index 0000000000000..27d9bdbee78c8
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/O2Parameters.h
@@ -0,0 +1,193 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file O2Parameters.h
+/// \brief A bound track state as O2's barrel (TrackParCov) or forward
+///        (TrackParCovFwd) parameters, at the state's own point.
+///
+/// No propagation: the O2 parameters are taken on the plane through the
+/// state's point with O2's orientation -- normal (cos a, sin a, 0) for the
+/// barrel, z for the forward ones. Only the covariance sees the change of
+/// plane: a shift in the source plane moves the point along the track to the
+/// target plane by s = -(e . A) / (e . t), over which the direction turns by
+/// (q/p) Bz B2C s. The terms vanish where the two planes are parallel.
+
+#ifndef GTRK_WORKFLOW_O2PARAMETERS_H_
+#define GTRK_WORKFLOW_O2PARAMETERS_H_
+
+#include "CommonConstants/MathConstants.h"
+#include "GenericTracking/Tracking/BoundTrackState.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "ReconstructionDataFormats/Track.h"
+#include "ReconstructionDataFormats/TrackFwd.h"
+
+#include <array>
+#include <cmath>
+#include <numbers>
+
+namespace o2::gtrk::workflow
+{
+
+namespace detail
+{
+
+using Jacobian = std::array<std::array<double, kNBoundParams>, kNBoundParams>;
+
+/// J C J^T of the state's covariance, as O2's packed lower triangle (row by
+/// row, (i, j) at i (i + 1) / 2 + j): TrackParCov's order, and the order
+/// SMatrix's symmetric representation takes.
+inline std::array<double, kBoundCovSize> transported(const Jacobian& jac, const BoundTrackState& state)
+{
+  std::array<double, kBoundCovSize> result{};
+  for (int i = 0; i < kNBoundParams; ++i) {
+    for (int j = 0; j <= i; ++j) {
+      double sum = 0.;
+      for (int k = 0; k < kNBoundParams; ++k) {
+        for (int l = 0; l < kNBoundParams; ++l) {
+          sum += jac[i][k] * static_cast<double>(state.covAt(k, l)) * jac[j][l];
+        }
+      }
+      result[(i * (i + 1) / 2) + j] = sum;
+    }
+  }
+  return result;
+}
+
+/// What both maps share: the point, the direction, and the derivatives of
+/// the point and the azimuth along a shift of loc0 and loc1 that keeps the
+/// point on the plane of normal \a e.
+struct Shift {
+  double r[3];
+  double t[3];
+  double dr[2][3];
+  double dPhi[2];
+};
+
+inline Shift shiftOnto(const BoundTrackState& state, const TrackingSurface& plane, const double e[3], double bzKiloGauss)
+{
+  Shift s{};
+  const double phi = state.phi();
+  const double theta = state.theta();
+  s.t[0] = std::cos(phi) * std::sin(theta);
+  s.t[1] = std::sin(phi) * std::sin(theta);
+  s.t[2] = std::cos(theta);
+  const double et = (e[0] * s.t[0]) + (e[1] * s.t[1]) + (e[2] * s.t[2]);
+  // d phi / d s of the helix, GenericTracking's (CovarianceTransport.h).
+  const double turn = static_cast<double>(state.qOverP()) * bzKiloGauss * constants::math::B2C;
+  for (int i = 0; i < 3; ++i) {
+    s.r[i] = static_cast<double>(plane.origin[i]) + (static_cast<double>(state.loc0()) * plane.axis0[i]) + (static_cast<double>(state.loc1()) * plane.axis1[i]);
+  }
+  for (int k = 0; k < 2; ++k) {
+    const Scalar* axis = k == 0 ? plane.axis0 : plane.axis1;
+    const double path = -((e[0] * axis[0]) + (e[1] * axis[1]) + (e[2] * axis[2])) / et;
+    for (int i = 0; i < 3; ++i) {
+      s.dr[k][i] = axis[i] + (s.t[i] * path);
+    }
+    s.dPhi[k] = turn * path;
+  }
+  return s;
+}
+
+/// d (y, z, snp, tgl, q/pt) / d (loc0, loc1, phi, theta, q/p) in the frame of
+/// angle \a alpha, \a s the shift onto its plane.
+inline Jacobian barrelJacobian(const BoundTrackState& state, const Shift& s, double alpha)
+{
+  const double ca = std::cos(alpha);
+  const double sa = std::sin(alpha);
+  const double theta = state.theta();
+  const double sinTheta = std::sin(theta);
+  const double cosLocal = std::cos(static_cast<double>(state.phi()) - alpha);
+  Jacobian jac{};
+  for (int k = 0; k < 2; ++k) {
+    jac[0][k] = (-sa * s.dr[k][0]) + (ca * s.dr[k][1]);
+    jac[1][k] = s.dr[k][2];
+    jac[2][k] = cosLocal * s.dPhi[k];
+  }
+  jac[2][kPhi] = cosLocal;
+  jac[3][kTheta] = -1. / (sinTheta * sinTheta);
+  jac[4][kTheta] = -static_cast<double>(state.qOverP()) * std::cos(theta) / (sinTheta * sinTheta);
+  jac[4][kQOverP] = 1. / sinTheta;
+  return jac;
+}
+
+/// d (x, y, phi, tanl, q/pt) / d (loc0, loc1, phi, theta, q/p) at fixed z,
+/// \a s the shift onto that plane.
+inline Jacobian forwardJacobian(const BoundTrackState& state, const Shift& s)
+{
+  const double theta = state.theta();
+  const double sinTheta = std::sin(theta);
+  Jacobian jac{};
+  for (int k = 0; k < 2; ++k) {
+    jac[0][k] = s.dr[k][0];
+    jac[1][k] = s.dr[k][1];
+    jac[2][k] = s.dPhi[k];
+  }
+  jac[2][kPhi] = 1.;
+  jac[3][kTheta] = -1. / (sinTheta * sinTheta);
+  jac[4][kTheta] = -static_cast<double>(state.qOverP()) * std::cos(theta) / (sinTheta * sinTheta);
+  jac[4][kQOverP] = 1. / sinTheta;
+  return jac;
+}
+
+} // namespace detail
+
+/// The barrel frame a state is written in: its sensor's O2 tracking-frame
+/// angle \a sensorAlpha, turned by pi when the state's momentum points against
+/// that frame's x (a state moving inward through its sensor), since O2's
+/// parameters are the branch with momentum along +x. In [-pi, pi).
+[[nodiscard]] inline double frameAlpha(const BoundTrackState& state, double sensorAlpha)
+{
+  const double alpha = std::cos(static_cast<double>(state.phi()) - sensorAlpha) < 0. ? sensorAlpha + std::numbers::pi : sensorAlpha;
+  return alpha - (2. * std::numbers::pi * std::floor((alpha + std::numbers::pi) / (2. * std::numbers::pi)));
+}
+
+/// \a state, bound to \a plane, as O2's barrel parameters in the frame of
+/// angle \a alpha (`frameAlpha`): x and y the point's coordinates in that
+/// frame, z, snp = sin(phi - alpha), tgl = cot(theta), q/pt = (q/p) /
+/// sin(theta). The field \a bzKiloGauss enters the covariance only.
+[[nodiscard]] inline o2::track::TrackParCov toTrackParCov(const BoundTrackState& state, const TrackingSurface& plane, double alpha, double bzKiloGauss)
+{
+  const double ca = std::cos(alpha);
+  const double sa = std::sin(alpha);
+  const double e[3] = {ca, sa, 0.};
+  const auto s = detail::shiftOnto(state, plane, e, bzKiloGauss);
+  const double phi = state.phi();
+  const double theta = state.theta();
+  const double sinTheta = std::sin(theta);
+  const double qOverP = state.qOverP();
+  const auto cov = detail::transported(detail::barrelJacobian(state, s, alpha), state);
+  o2::track::TrackParCov::covMat_t o2Cov{};
+  for (int i = 0; i < kBoundCovSize; ++i) {
+    o2Cov[i] = static_cast<float>(cov[i]);
+  }
+  const o2::track::TrackParCov::params_t par{static_cast<float>((-sa * s.r[0]) + (ca * s.r[1])), static_cast<float>(s.r[2]), static_cast<float>(std::sin(phi - alpha)), static_cast<float>(std::cos(theta) / sinTheta), static_cast<float>(qOverP / sinTheta)};
+  return {static_cast<float>((ca * s.r[0]) + (sa * s.r[1])), static_cast<float>(alpha), par, o2Cov};
+}
+
+/// \a state, bound to \a plane, as O2's forward parameters at the point's z:
+/// x, y, phi, tanl = cot(theta), q/pt = (q/p) / sin(theta), \a chi2 the
+/// track's. The field \a bzKiloGauss enters the covariance only.
+[[nodiscard]] inline o2::track::TrackParCovFwd toTrackParCovFwd(const BoundTrackState& state, const TrackingSurface& plane, double bzKiloGauss, double chi2)
+{
+  const double e[3] = {0., 0., 1.};
+  const auto s = detail::shiftOnto(state, plane, e, bzKiloGauss);
+  const double theta = state.theta();
+  const double sinTheta = std::sin(theta);
+  const double qOverP = state.qOverP();
+  const auto cov = detail::transported(detail::forwardJacobian(state, s), state);
+  const o2::track::SMatrix5 par{s.r[0], s.r[1], static_cast<double>(state.phi()), std::cos(theta) / sinTheta, qOverP / sinTheta};
+  // The lower triangle, row by row.
+  return {s.r[2], par, o2::track::SMatrix55Sym(cov.begin(), cov.end(), true, true), chi2};
+}
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_O2PARAMETERS_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/RecoParam.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/RecoParam.h
new file mode 100644
index 0000000000000..560bc3cd8da32
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/RecoParam.h
@@ -0,0 +1,318 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file RecoParam.h
+/// \brief Each detector's tracking settings as a ConfigurableParam.
+///
+/// A ConfigurableParam, where `--configKeyValues "GTRKReco<DET>.<field>=<value>"`
+/// reaches them and every device of the chain sees the same value.
+///
+/// The fields are one struct, `RecoSettings`; each detector has its own
+/// parameter of them, `RecoParam<DetID>` (as `DPLAlpideParam<N>`):
+/// `GTRKRecoITS`, `GTRKRecoMFT`, `GTRKRecoTRK`, so that one workflow carries
+/// every detector's. A detector layout's is `recoParam<Det>()`.
+
+#ifndef GTRK_WORKFLOW_RECOPARAM_H_
+#define GTRK_WORKFLOW_RECOPARAM_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+#include "CommonConstants/PhysicsConstants.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+
+// ENABLE_UPGRADES comes with DetID.h (UpgradesStatus.h).
+#ifdef ENABLE_UPGRADES
+#include "GenericTracking/Detectors/TRKFT3.h"
+#endif
+
+#include <cstdint>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+struct RecoSettings {
+  /// O2's `addTimeError` for the ITS and the MFT [BC]: every readout frame's
+  /// time box widened by this much at both ends, for a hit recorded in the
+  /// neighbouring frame. One entry per layer, or
+  /// none for 0 on every layer, O2's default.
+  std::vector<int> frameMarginBC;
+
+  /// Width of the outer time block in the measurement grid [ps], 0 for one
+  /// block. This is the minimum slice quantum and is chosen from the worker
+  /// memory budget; a detector with readout frames takes the whole number of
+  /// frames nearest it.
+  std::int64_t blockWidthPS = 10'000'000;
+
+  // The grid's cells are derived from the iterations' queries, with no key of
+  // their own (GridSizing.h).
+  /// The mass hypothesis [GeV], positive (`checkRecoParam`): beta for the
+  /// scattering, in the windows at pT_min and in the fit, and the fit's energy
+  /// loss. The charged pion's by default.
+  double massHypothesisGeV = o2::constants::physics::MassPionCharged;
+  /// The uniform material per layer [X/X0] that sizes the windows and the
+  /// grid, and the scattering when no material LUT is given; with a LUT the
+  /// tracking takes its budgets.
+  double materialX2X0 = 0.01;
+  /// The windows' position resolution [cm].
+  double positionSigma = 0.005;
+  /// Added in quadrature to every cluster's local errors [cm], for what the
+  /// cluster shape does not know: the alignment's residuals on real data. O2
+  /// adds 10 um per layer in its async reconstruction (ITSCATrackerParam.sysErrY2,
+  /// sysErrZ2 = 100e-8 cm^2); 0, the default, is the MC's dictionary error alone.
+  double clusterSystematicSigmaCM = 0.;
+  /// The windows' and the cuts' nSigma, the run's (every iteration's).
+  double windowNSigma = 3.;
+  /// How many sigma of the beam's z width the tracking reaches about the
+  /// beam's z (`beamSpotConstraint`): the z range it is to be efficient in,
+  /// for the beam-line windows and pair cut, the vertexing pass, the grid and
+  /// the vertex-list iterations alike.
+  double beamZReachNSigma = 3.;
+
+  /// The own vertexer: before the tracking, a pass at
+  /// the beam line on the three innermost layers, one slice over the
+  /// timeframe, tracklets and triplets at `vertexerMinPtGeV`; its triplets'
+  /// z at the beam line, frame by frame, give the vertex list the
+  /// vertex-list iterations read (`iterationVertexSource`). Off by default.
+  /// The rest are the vertexer's knobs (VertexStage.h, VertexerSettings).
+  bool vertexer = false;
+  double vertexerMinPtGeV = 0.5;
+  double vertexerMaxChi2RZ = 5.;   ///< a triplet's r-z line chi2 cut, 0 for none
+  double vertexerMaxDcaCM = 0.02;  ///< its circle's transverse distance to the beam axis [cm], 0 for none
+  int vertexerWindowUM = 150;      ///< a peak's window [um]
+  int vertexerClaimUM = 2000;      ///< the half-width a vertex claims around its peak [um]
+  int vertexerMinContributors = 4; ///< the least candidates a peak's window holds
+  /// The least in a frame where none holds vertexerMinContributors: that
+  /// frame's rounds run again at this minimum; 0, none, by default.
+  int vertexerAloneMinContributors = 0;
+  double vertexerSignificance = 5.; ///< a peak's excess over the sidebands, in their Poisson sigmas
+  /// Whether the vertexing pass tests its pairs and triplets against their
+  /// measurements' cluster shapes (`iterationShapeTest`); 0, off, by default.
+  int vertexerShapeTest = 0;
+
+  /// Tracking iterations, run one after another: one per entry of
+  /// `iterationMinPtGeV`. Each other per-iteration vector holds one entry per
+  /// iteration, or none for its default in every iteration (GridConfig.h,
+  /// `iterationCount`). They are set whole, as O2's parameters take vectors:
+  /// `GTRKRecoITS.iterationMinPtGeV=[1,0.5];GTRKRecoITS.iterationMinClusters=[7,4]`.
+  /// What an iteration loosens is its minimum pT; nSigma (`windowNSigma`) is
+  /// the run's, the same in every iteration.
+  ///
+  /// Three iterations at 1.0, 0.5 and 0.3 GeV by default; a schedule sets its
+  /// own.
+  std::vector<double> iterationMinPtGeV{1., 0.5, 0.3};
+  /// Where each iteration's vertex seeds come from: 0 the beam line (the
+  /// default), 1 the timeframe's vertex list.
+  std::vector<int> iterationVertexSource;
+  /// The shortest road each iteration fits, in clusters, 4 by default; a road
+  /// is at least 4 clusters, two triplets, whatever is set. An iteration takes
+  /// only the links on a path of this many layers (Iteration.h, `takenLinks`).
+  /// ITS asks 7 of its first two iterations and 4 of the third.
+  std::vector<int> iterationMinClusters;
+  /// The kinks each iteration's fit may take per pass;
+  /// 0 for none, 1 by default.
+  std::vector<int> iterationMaxKinks;
+  /// The kink allowance of each iteration's triplet and neighbour cuts: a
+  /// triplet failing the nominal cuts is kept, flagged kinked, if it passes with the middle
+  /// layer's scattering at pT_min scaled by this factor; 1 (the default) for
+  /// none.
+  std::vector<double> iterationKinkSigma;
+  /// The triplet and neighbour cuts' own kink allowance, each iteration's:
+  /// above 0 it replaces
+  /// iterationKinkSigma there, which then sets only the road fit's and the
+  /// follow's; 0, the default, iterationKinkSigma everywhere.
+  std::vector<double> iterationGraphKinkSigma;
+  /// A displaced iteration's bounds [cm]:
+  /// how far its tracks' circles may pass from the beam line, and how far
+  /// the z of that closest approach from the beam spot's centre. 0, the
+  /// default, a prompt iteration; above, on the beam line and with both set,
+  /// the displaced pair test and its windows.
+  std::vector<double> iterationImpactMaxCm;
+  std::vector<double> iterationImpactZMaxCm;
+  /// Whether each iteration makes tracklets that leave a hole, whose segment
+  /// crosses another layer's envelope (the default); 0 for none, so the
+  /// tracks past a shorter layer's end are kept and those through a gap
+  /// are not.
+  std::vector<int> iterationSkipLinks;
+  /// The layers each iteration's links join, a bit per layer; 0 for every
+  /// layer (the default). The vertexing pass's 7 takes layers 0-2 alone.
+  std::vector<long> iterationLayerMask;
+  /// The layers each iteration's roads may end on, a bit per layer; 0 for any
+  /// (the default). O2's ITS async asks layer 3 or 6 of its third,
+  /// `(1 << 6) + (1 << 3)` = 72.
+  std::vector<long> iterationRoadEndLayers;
+  /// The layers each iteration's roads may start on, their innermost
+  /// measurement's, a bit per layer; 0 for any (the default).
+  std::vector<long> iterationRoadStartLayers;
+  /// The lowest pT of a track by its cluster count [GeV], 0 for none -- the
+  /// final track's: after the follow where the iteration follows, else the
+  /// road's. Iteration
+  /// `i`'s floor for `n` clusters is entry `16 i + n`, so 16 entries per
+  /// iteration, or none for no floor at all. O2's ITS async asks 1/12 of 7
+  /// clusters in every iteration, and 1/5, 1 and 1/6 of 6, 5 and 4 in its
+  /// third (entries 7, 23, 39, 38, 37, 36).
+  static constexpr int kClusterSlots = 16;
+  std::vector<double> iterationClusterMinPtGeV;
+  /// How many of a track's innermost clusters each iteration lets it share
+  /// with another; 0, strict, by default.
+  std::vector<int> iterationSharedInnermost;
+  /// Whether each iteration follows its selected tracks after their refit,
+  /// outward and then inward, as a CKF does, before the next iteration;
+  /// 1, on, by default.
+  std::vector<int> iterationFollow;
+  /// The holes each iteration's follow lets a track cross in each direction,
+  /// a sensor crossed without a row; 0 by default.
+  std::vector<int> iterationFollowHoles;
+  /// Whether each iteration decides its roads' outermost row again with the
+  /// follow: fitted without it, the follow's first row in its place where it
+  /// takes another; without iterationFollow,
+  /// that row alone. 0, off, by default; not with a kink allowance.
+  std::vector<int> iterationFollowEnd;
+  /// The innermost clusters each iteration's road fit may drop from a road it
+  /// refuses, one more each time, down to the iteration's minimum, the first
+  /// it takes the road's record; 0, off, by
+  /// default.
+  std::vector<int> iterationInnerTrim;
+  /// Which of a barrel plane's two crossings each iteration's follow refit
+  /// takes (`CrossingRule`): 0 the first ahead
+  /// (the default), 1 of those ahead the one nearer the plane's centre, 2 one
+  /// inside the sensor first, else nearer the centre.
+  std::vector<int> iterationCrossingRule;
+  /// Whether each iteration's follow refit, where it refuses the rows the
+  /// follow added, keeps the longest prefix of them it accepts instead of
+  /// none; 0, off, by default.
+  std::vector<int> iterationFollowPrefix;
+  /// Whether each iteration's follow takes, where more than one row passes a
+  /// step, the smallest chi2 instead of the lookahead's confirmed row; 0, off, by
+  /// default.
+  std::vector<int> iterationFollowGreedy;
+  /// The chi2 below which each iteration's follow keeps a direction's
+  /// unconfirmed last row, which the unconfirmed drop removes otherwise; 0, none kept, by
+  /// default.
+  std::vector<double> iterationFollowKeepChi2;
+  /// Whether each iteration refuses its inward walk's last row, where a
+  /// nominal step took it, whose chi2 against that step's prediction updated
+  /// with the beam line is above the gate; needs the iteration's follow and
+  /// beam constraint; 0, off, by default.
+  std::vector<int> iterationFollowBeamEnd;
+  /// Whether each iteration tests its pairs and triplets against their
+  /// measurements' cluster shapes: a candidate's local slope at each of its measurements -- its line's
+  /// |dz| over its length along the sensor's normal -- must lie in the
+  /// measurement's slope interval, which the measurement producer makes from
+  /// its detector's calibrated band (ClusterShapeBand.h); 0, off, by default.
+  std::vector<int> iterationShapeTest;
+  /// Each iteration's follow's end decisions on the last row's own update:
+  /// inward, the sqrt|V| [cm^2]
+  /// above which a last row at the layout's end is refused; outward, the
+  /// density [cm^-2] above which the unconfirmed drop keeps a last row; 0, off, by default.
+  std::vector<double> iterationFollowEndMaxSqrtDet;
+  std::vector<double> iterationFollowKeepDensity;
+  /// The Delta chi2 below which each iteration's follow trims a track's
+  /// last outward row where it is one of two rows or more passing the gate
+  /// and the track keeps the cuts after the follow without it: the other
+  /// row's chi2 less its own; 0, off, by default; above the gate, every such row.
+  std::vector<double> iterationFollowTrimMargin;
+  /// The clusters each iteration's tracks must hold after the follow; 0 for
+  /// none (the default). A shorter track is dropped and its rows given back.
+  std::vector<int> iterationMinClustersAfterFollow;
+  /// Whether each iteration updates its roads with the beam line on their
+  /// innermost surface and refuses them above the update's gate, to start
+  /// the follow inward from the constrained state; 0, off, by default.
+  std::vector<int> iterationBeamConstraint;
+  /// Whether each iteration follows every earlier iteration's tracks too,
+  /// with its own settings, their rows kept, as a recovery pass does; 0, off,
+  /// by default. Needs the iteration's
+  /// iterationFollow; iterationMinClustersAfterFollow applies to the
+  /// iteration's own tracks only.
+  std::vector<int> iterationFollowEarlier;
+  /// Whether each iteration takes the previous one's graph instead of
+  /// building its own, one graph for both rounds; 0, off, by default. Needs
+  /// the previous iteration's graph settings, and its graph kink allowance 1
+  /// and this one's above.
+  std::vector<int> iterationSharedGraph;
+
+  /// Requested width of one time slice [ps]. The actual width is rounded up
+  /// to whole grid blocks, and zero means one slice over the timeframe.
+  std::int64_t sliceWidthPS = 10'000'000;
+
+  /// How far a slice reads beyond its core on each side [ps], rounded up to
+  /// whole blocks. The workflow raises this to `requiredHaloPS` when
+  /// necessary, so the output does not depend on the slicing.
+  std::int64_t sliceHaloPS = 100'000;
+
+  /// Consecutive source elements assigned to one CPU task.
+  int trackletChunkSize = 256;
+
+  /// Maximum CPU workers; zero uses TBB's default.
+  int threads = 0;
+
+  /// The host tracker's memory [GB]: a stage that would hold more fails with
+  /// kOutOfMemory, and the timeframe's tracking with it, instead of growing.
+  /// Zero, the default, for no limit.
+  double memoryLimitGB = 0.;
+
+  /// A timeframe whose tracking runs out of memory (memoryLimitGB) gives
+  /// empty products and is counted, instead of failing the run. Off, the
+  /// default, as ITS's DropTFUponFailure: the run fails.
+  bool dropTFUponFailure = false;
+};
+
+/// Detector \a N's settings (`o2::detectors::DetID`): `GTRKReco<DET>`.
+// O2ParamDef deletes the copy constructor and supplies the rest of the
+// boilerplate, so the rule about declaring all five has nothing to act on here.
+template <int N>
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
+struct RecoParam : public o2::conf::ConfigurableParamPromoter<RecoParam<N>, RecoSettings> {
+  static constexpr std::string_view getParamName() { return N == o2::detectors::DetID::ITS ? "GTRKRecoITS" : (N == o2::detectors::DetID::MFT ? "GTRKRecoMFT" : "GTRKRecoTRK"); }
+  O2ParamDef(RecoParam, getParamName().data());
+};
+
+template <int N>
+RecoParam<N> RecoParam<N>::sInstance;
+
+/// A detector layout's O2 detector: its parameter's, its data origin's
+/// (DataSpecs.h's `detectorOrigin`).
+template <DetectorLayout Det>
+struct DetIDOf;
+template <>
+struct DetIDOf<detectors::ITS> : std::integral_constant<o2::detectors::DetID::ID, o2::detectors::DetID::ITS> {
+};
+template <>
+struct DetIDOf<detectors::MFT> : std::integral_constant<o2::detectors::DetID::ID, o2::detectors::DetID::MFT> {
+};
+#ifdef ENABLE_UPGRADES
+template <>
+struct DetIDOf<detectors::TRKFT3> : std::integral_constant<o2::detectors::DetID::ID, o2::detectors::DetID::TRK> {
+};
+#endif
+
+/// A detector layout's parameter.
+template <DetectorLayout Det>
+struct RecoParamOf {
+  using type = RecoParam<DetIDOf<Det>::value>; // NOLINT(readability-identifier-naming): a type trait's member
+};
+
+/// The settings of \a Det's parameter.
+template <DetectorLayout Det>
+[[nodiscard]] const RecoSettings& recoParam()
+{
+  return RecoParamOf<Det>::type::Instance();
+}
+
+} // namespace o2::gtrk
+
+#endif // GTRK_WORKFLOW_RECOPARAM_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/TrackLabel.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/TrackLabel.h
new file mode 100644
index 0000000000000..549df09ab85b2
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/TrackLabel.h
@@ -0,0 +1,126 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackLabel.h
+/// \brief The one rule that gives a track its MC particle: what a measurement's
+///        labels carry, and which particle a track's measurements carry.
+///
+/// The study scores tracks with it and the O2-format adaptors label them with
+/// it, so the two cannot drift apart.
+
+#ifndef GTRK_WORKFLOW_TRACKLABEL_H_
+#define GTRK_WORKFLOW_TRACKLABEL_H_
+
+#include "SimulationDataFormat/MCCompLabel.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <span>
+
+namespace o2::gtrk::workflow
+{
+
+/// Whether \a label names a particle the truth counts: O2's valid, which is
+/// set and not noise, the QED background counting as noise.
+[[nodiscard]] inline bool carriesParticle(const o2::MCCompLabel& label) { return label.isValid(); }
+
+/// The particles one measurement's cluster carries, each identified by its
+/// source, event and track in one word (`MCCompLabel::getTrackEventSourceID`).
+struct RowParticles {
+  static constexpr std::size_t kMaxParticles = 4;
+  std::array<std::uint64_t, kMaxParticles> particles{}; ///< the first `count` are valid
+  std::uint8_t count = 0;
+  /// Whether `particles[0]` is the cluster's first label and O2's QA counts it
+  /// (`CheckTracksCA.C`: valid, correct, from the signal): O2's findable
+  /// reads only that one.
+  bool firstLabelCounts = false;
+
+  [[nodiscard]] bool carries(std::uint64_t particle) const { return std::find(particles.begin(), particles.begin() + count, particle) != particles.begin() + count; }
+};
+
+/// The particles of a cluster with the labels \a labels, in their order: those
+/// that carry one (`carriesParticle`), each once, the first kMaxParticles.
+[[nodiscard]] inline RowParticles rowParticles(std::span<const o2::MCCompLabel> labels)
+{
+  RowParticles row;
+  row.firstLabelCounts = !labels.empty() && labels[0].isValid() && labels[0].isCorrect() && labels[0].getSourceID() == 0;
+  for (const auto& label : labels) {
+    if (!carriesParticle(label)) {
+      continue;
+    }
+    const auto id = label.getTrackEventSourceID();
+    if (row.carries(id) || row.count == RowParticles::kMaxParticles) {
+      continue;
+    }
+    row.particles[row.count++] = id;
+  }
+  return row;
+}
+
+/// The label of \a particle, a `getTrackEventSourceID()` word, with the
+/// fake flag \a fake: the inverse of the word's packing.
+[[nodiscard]] inline o2::MCCompLabel labelOfParticle(std::uint64_t particle, bool fake = false)
+{
+  using L = o2::MCCompLabel;
+  return {static_cast<int>(particle & L::maskTrackID), static_cast<int>((particle >> L::nbitsTrackID) & L::maskEvID), static_cast<int>((particle >> (L::nbitsTrackID + L::nbitsEvID)) & L::maskSrcID), fake};
+}
+
+/// No particle: a fake's good particle, or noise only.
+inline constexpr std::uint64_t kNoTrackParticle = std::numeric_limits<std::uint64_t>::max();
+
+/// The particle every row of \a track carries, the first such among the
+/// first row's; kNoTrackParticle for a fake. \a rows are indexed by the
+/// track's rows and hold RowParticles' members.
+template <typename Rows>
+[[nodiscard]] std::uint64_t goodParticle(const Rows& rows, std::span<const std::uint32_t> track)
+{
+  if (track.empty()) {
+    return kNoTrackParticle;
+  }
+  const auto& first = rows[track.front()];
+  for (std::uint8_t i = 0; i < first.count; ++i) {
+    const auto candidate = first.particles[i];
+    if (std::ranges::all_of(track, [&](std::uint32_t row) { return rows[row].carries(candidate); })) {
+      return candidate;
+    }
+  }
+  return kNoTrackParticle;
+}
+
+/// The particle most rows of \a track carry, the first such in track order,
+/// and on how many: a fake's label; kNoTrackParticle and 0 on noise only.
+struct MajorityParticle {
+  std::uint64_t particle = kNoTrackParticle;
+  std::uint32_t carried = 0U;
+};
+
+template <typename Rows>
+[[nodiscard]] MajorityParticle majorityParticle(const Rows& rows, std::span<const std::uint32_t> track)
+{
+  MajorityParticle result;
+  for (const auto row : track) {
+    for (std::uint8_t i = 0; i < rows[row].count; ++i) {
+      const auto candidate = rows[row].particles[i];
+      const auto carried = static_cast<std::uint32_t>(std::ranges::count_if(track, [&](std::uint32_t other) { return rows[other].carries(candidate); }));
+      if (carried > result.carried) {
+        result = {.particle = candidate, .carried = carried};
+      }
+    }
+  }
+  return result;
+}
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_TRACKLABEL_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/TrackerSpec.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/TrackerSpec.h
new file mode 100644
index 0000000000000..dd6e3840b9b51
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/TrackerSpec.h
@@ -0,0 +1,51 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackerSpec.h
+/// \brief The tracking device, gtrk-<det>-tracker: the measurements in, the
+///        tracks and the own vertexer's vertices out, in GenericTracking's
+///        own formats (DataSpecs.h's kTracks, kVertexSeeds,
+///        kVertexContributors). One device per detector, its own
+///        instantiation.
+
+#ifndef GTRK_WORKFLOW_TRACKERSPEC_H_
+#define GTRK_WORKFLOW_TRACKERSPEC_H_
+
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/TrackRefit.h"
+
+#include "Framework/DataProcessorSpec.h"
+
+#include <memory>
+
+namespace o2::gtrk::workflow
+{
+
+/// A track as the device publishes it: the tracker's own record, its refit's
+/// `status` with it (kOk, or why the refit failed).
+template <DetectorLayout Det>
+using TrackRecord = typename TrackRefit<Det>::Tracks::Record;
+
+/// The device; with \a withVertices the native vertex seeds (kVertices) are
+/// an input.
+template <DetectorLayout Det>
+o2::framework::DataProcessorSpec getTrackerSpec(bool withVertices);
+
+class GPURecoTracking;
+
+/// \a Det's tracking inside the GPU reconstruction (GPURecoTracking.h), the
+/// same timeframe as the device's.
+template <DetectorLayout Det>
+std::unique_ptr<GPURecoTracking> makeGPURecoTrackingOf();
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_TRACKERSPEC_H_
diff --git a/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/TrackingInterface.h b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/TrackingInterface.h
new file mode 100644
index 0000000000000..fcb9c756acb4b
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/include/GenericTracking/Workflow/TrackingInterface.h
@@ -0,0 +1,569 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackingInterface.h
+/// \brief One detector's tracking on a timeframe of measurements, for the
+///        device that holds the run's conditions.
+///
+/// It owns what the tracking is made of: the geometry, the material's budgets
+/// and scattering table, the tracking geometry, the tracker and the own
+/// vertexer. It borrows the run's conditions (`TrackingConditions`): the
+/// field, the measurement depths and the material LUT stay the enclosing
+/// device's, which requests them; the interface makes no request of its own.
+///
+/// Per timeframe, in this order:
+/// - `configureFor`: `configure` on the first timeframe and for a new shipped
+///   beam line;
+/// - `checkInput`: the columns, the grid offsets, the variances, the seeds;
+/// - `vertices`: the input seeds, or the own vertexer's;
+/// - `track`: plan and run;
+/// - `endTimeframe`, through the guard `endTimeframeOnExit` taken at the
+///   top: on success, on a failure, on an exception. It ends what began, and
+///   the results are invalid after.
+///
+/// A timeframe that does not complete: out of memory (`memoryLimitGB`) is
+/// dropped with `dropTFUponFailure`, the result then reported as dropped;
+/// without it, and for every other status, the run fails.
+
+#ifndef GTRK_WORKFLOW_TRACKINGINTERFACE_H_
+#define GTRK_WORKFLOW_TRACKINGINTERFACE_H_
+
+#include "GenericTracking/Base/FrameTiming.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Tracking/GPU/DeviceContext.h"
+#include "GenericTracking/Tracking/GPU/DeviceRuntime.h"
+#include "GenericTracking/Tracking/GPU/DeviceTracker.h"
+#include "GenericTracking/Tracking/LayerMaterial.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/StageOutput.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Tracking/Tracker.h"
+#include "GenericTracking/Tracking/TrackingSurface.h"
+#include "GenericTracking/Tracking/VertexingPass.h"
+#include "GenericTracking/Workflow/BeamLine.h"
+#include "GenericTracking/Workflow/GeometryProvider.h"
+#include "GenericTracking/Workflow/GridConfig.h"
+#include "GenericTracking/Workflow/MaterialLUT.h"
+#include "GenericTracking/Workflow/RecoParam.h"
+
+#include "DetectorsBase/MatLayerCylSet.h"
+
+#include <fairlogger/Logger.h>
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <optional>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::workflow
+{
+
+/// Whether every one of \a columns has \a rows rows.
+template <class Columns>
+[[nodiscard]] bool measurementColumnsHaveSize(const Columns& columns, std::size_t rows)
+{
+  return columns.apply([rows](const auto&... column) { return ((column.size() == rows) && ...); });
+}
+
+/// Whether a measurement's variances can enter the fit: finite and positive,
+/// the spatial block positive definite. A zero variance divides the update's
+/// whitening and the U-D factorisation by zero, and nothing downstream
+/// reports the NaN that makes.
+[[nodiscard]] inline bool measurementVariancesValid(Scalar varLoc0, Scalar covLoc01, Scalar varLoc1) { return isFiniteScalar(varLoc0) && isFiniteScalar(covLoc01) && isFiniteScalar(varLoc1) && varLoc0 > 0.F && varLoc1 > 0.F && covLoc01 * covLoc01 < varLoc0 * varLoc1; }
+
+/// What the tracking borrows from the device that holds the run's conditions.
+struct TrackingConditions {
+  double bzKiloGauss = 0.;                            ///< the run's nominal field
+  std::vector<double> depthsCM;                       ///< each layer's measurement depth; empty for 0 on every layer
+  const o2::base::MatLayerCylSet* material = nullptr; ///< the run's material LUT (MaterialLUT.h)
+};
+
+/// The view of \a conditions (Conditions.h's, any detector's, with the
+/// material LUT: `Conditions<Det, true>`), once in for the timeframe.
+template <class Conditions>
+  requires requires(const Conditions& conditions) { conditions.materialLut(); }
+[[nodiscard]] TrackingConditions trackingConditions(const Conditions& conditions)
+{
+  return {.bzKiloGauss = nominalBzKiloGauss(), .depthsCM = conditions.measurementDepthsCM(), .material = conditions.materialLut()};
+}
+
+/// Where the tracking runs: the host, or a GPU backend (the tracking
+/// device's options `--gtrk-gpu-backend`, `--gtrk-gpu-device`, `--gtrk-gpu-arena-mb`).
+struct TrackingDevice {
+  std::string backend;     ///< empty: the host; else "cuda" or "hip"
+  int device = 0;          ///< the backend's device index
+  std::size_t arenaMB = 0; ///< the device tracker's arena in O2's GPU pool [MB]
+};
+
+template <DetectorLayout Det>
+class TrackingInterface
+{
+ public:
+  using Material = o2::base::MatLayerCylSet;
+  using Controller = Tracker<Det, Material>;
+  using Vertexing = VertexingPass<Det, Material>;
+  using Frame = TimeFrame<Det>;
+  using TimeframeResult = typename Controller::TimeframeResult;
+  using Device = DeviceTracker<Det, Material>;
+
+  /// \a withVertices: the native seeds (DataSpecs.h's `kVertices`) are an input.
+  explicit TrackingInterface(bool withVertices) : mWithVertices(withVertices) {}
+
+  /// Where the tracking runs, \a device: on a GPU backend, the GPU -- its
+  /// reconstruction and the device tracker's arena (DeviceContext) -- before
+  /// any timeframe; nothing on the host.
+  void initDevice(TrackingDevice device)
+  {
+    mDeviceOptions = std::move(device);
+    if (mDeviceOptions.backend.empty()) {
+      return;
+    }
+    if (mDeviceOptions.arenaMB == 0U) {
+      LOGP(fatal, "--gtrk-gpu-backend {}: --gtrk-gpu-arena-mb, the device tracker's arena, is required", mDeviceOptions.backend);
+      return;
+    }
+    const std::array<std::size_t, 1> arena{mDeviceOptions.arenaMB << 20U};
+    mContext = std::make_unique<DeviceContext>(mDeviceOptions.backend, mDeviceOptions.device, arena);
+    mBlock = mContext->block(0U);
+    const auto& properties = mContext->runtime().properties();
+    LOGP(info, "the tracking on {} device {}: {} ({}), arena {} MB", mContext->runtime().backend(), mDeviceOptions.device, properties.name, properties.architecture, mDeviceOptions.arenaMB);
+  }
+
+  /// The tracking on \a reconstruction's GPU, which its owner initialised
+  /// (the GPU reconstruction workflow's): a borrowing context, and each
+  /// timeframe's device memory from `useBlock`.
+  void initDevice(o2::gpu::GPUReconstruction& reconstruction)
+  {
+    mContext = std::make_unique<DeviceContext>(reconstruction);
+    mDeviceOptions = {.backend = std::string{mContext->runtime().backend()}};
+    const auto& properties = mContext->runtime().properties();
+    LOGP(info, "the tracking on {} inside the GPU reconstruction: {} ({}), in the pool's free memory after the TPC", mContext->runtime().backend(), properties.name, properties.architecture);
+  }
+
+  /// The next timeframe's device memory, on a borrowed reconstruction: set
+  /// before its vertices and tracking, valid until its end.
+  void useBlock(DeviceBlock block) { mBlock = block; }
+
+  /// The GPU's context; a GPU backend's only.
+  [[nodiscard]] const DeviceContext& context() const { return *mContext; }
+
+  /// The GPU released, the device tracker before its context: at the end
+  /// of the processing, not at the process's exit.
+  void releaseDevice() noexcept
+  {
+    mDevice.reset();
+    mContext.reset();
+  }
+
+  [[nodiscard]] bool configured() const { return mTracker != nullptr; }
+
+  /// `configure` from \a conditions (Conditions.h's, with the material LUT)
+  /// if the trackers are not built for \a shipped: on the first timeframe,
+  /// and for a new beam line. Whether it did.
+  template <class Conditions>
+  bool configureFor(const Conditions& conditions, const MeasurementGeometry<Det>& shipped)
+  {
+    if (mTracker && shipped.beamLine == mBeamLine) {
+      return false;
+    }
+    configure(trackingConditions(conditions), shipped);
+    return true;
+  }
+
+  /// Place the geometry before deriving a standalone grid from its layer
+  /// envelopes. A workflow can leave this to configure, using its shipped grid.
+  void initGeometry(std::span<const double> depthsCM)
+  {
+    if (!mGeometry) {
+      mGeometry = makeGeometry<Det>(depthsCM);
+    }
+  }
+
+  /// On the first call the geometry, the material's budgets and scattering
+  /// table and the tracking geometry, from \a conditions; on every call the
+  /// trackers, for \a shipped's beam line and grid.
+  void configure(const TrackingConditions& conditions, const MeasurementGeometry<Det>& shipped)
+  {
+    const auto& param = recoParam<Det>();
+    LOGP(info, "the field: nominal Bz {} kG, from the run's GRPMagField", conditions.bzKiloGauss);
+    mBzKiloGauss = conditions.bzKiloGauss;
+    const bool first = mMaterial == nullptr;
+    initGeometry(conditions.depthsCM);
+    // The beam line and the grid the measurements are relative to, the producer's.
+    mBeamLine = shipped.beamLine;
+    LOGP(info, "the beam line, the trackers' constraint: {}", describe(mBeamLine));
+    mGrid.emplace(shipped.grid);
+    mFrames.clear();
+    for (std::size_t layer = 0; layer < GridGeometry<Det>::kLayerCount; ++layer) {
+      mFrames.push_back(shipped.grid.frames(static_cast<LayerID>(layer)));
+    }
+    if (first) {
+      configureMaterial(conditions.material);
+    }
+    const auto beamSpot = beamSpotConstraint(mBeamLine, param);
+    const auto chunkSize = static_cast<typename Controller::Index>(std::max(param.trackletChunkSize, 1));
+    // The tracker takes each iteration's configured source.
+    std::vector<IterationSettings> settings;
+    for (int iteration = 0; iteration < iterationCount(param); ++iteration) {
+      settings.push_back(iterationSettings(param, iteration));
+      if (settings.back().vertexSource == VertexSource::kVertexList && !mWithVertices && !param.vertexer) {
+        LOGP(fatal, "iteration {} seeds from the vertex list (GTRKReco<DET>.iterationVertexSource), and this device has none: an input of seeds or GTRKReco<DET>.vertexer", iteration);
+        return;
+      }
+    }
+    // GTRKReco<DET>.vertexer: the own vertexer's list, in place of an input one.
+    if (param.vertexer && mWithVertices) {
+      LOGP(fatal, "GTRKReco<DET>.vertexer finds the vertex list, and an input supplies one: take one or the other");
+      return;
+    }
+    mVertexing.reset();
+    // One pool for the vertexer and the tracker: memoryLimitGB bounds what
+    // both hold at once (the vertexer's pass stays while the tracking runs).
+    mPool = trackerMemoryPool(param);
+    if (param.vertexer) {
+      mVertexing = std::make_unique<Vertexing>(vertexingPassSettings(param), vertexerSettings(param), beamSpot, mScattering, mPool, chunkSize, std::max(param.threads, 0));
+      LOGP(info, "the vertexer: a pass at {} GeV on layers 0-2, window {} um, claim {} um, at least {} contributors ({} in a frame without a vertex)", param.vertexerMinPtGeV, param.vertexerWindowUM, param.vertexerClaimUM, param.vertexerMinContributors, param.vertexerAloneMinContributors);
+    }
+    mTrackerSource = iterationSettings(param, 0).vertexSource;
+    mTrackerLabel = sourceLabel(settings);
+    mTracker = std::make_unique<Controller>(settings, beamSpot, mScattering, mPool, chunkSize, std::max(param.threads, 0));
+    if (param.memoryLimitGB > 0.) {
+      LOGP(info, "the tracker's memory, its vertexer's included, limited to {:.3f} GB (GTRKReco<DET>.memoryLimitGB)", param.memoryLimitGB);
+    }
+    // The road fit and the refit: the sensors, the material LUT, the field.
+    if (!mTracking) {
+      mTracking = std::make_unique<TrackingGeometry<Det>>(*mGeometry);
+    }
+    mTracker->setTrackModel(*mTracking, *mMaterial, propagator());
+    if (mContext) {
+      configureDevice(settings);
+    }
+  }
+
+  /// The input's checks: every column \a columns as long as the others, the
+  /// grid's prefix \a offsets over its \a bucketCount buckets ending at the
+  /// row count, every measurement's variances fit for the fit, \a seeds
+  /// time-sorted with finite z. Nullptr if it may be tracked, else why not.
+  template <class Columns>
+  [[nodiscard]] static const char* checkInput(const Columns& columns, std::span<const std::uint32_t> offsets, std::size_t bucketCount, std::span<const VertexSeed> seeds)
+  {
+    if (!std::ranges::is_sorted(seeds, {}, &VertexSeed::timePS) || !std::ranges::all_of(seeds, [](const VertexSeed& seed) { return std::isfinite(seed.z); })) {
+      return "vertex seeds are not time-sorted or finite";
+    }
+    const auto n = columns.loc0.size();
+    const bool validOffsets = n <= std::numeric_limits<std::uint32_t>::max() && offsets.size() == bucketCount + 1U && offsets.front() == 0U && offsets.back() == n && std::ranges::is_sorted(offsets);
+    if (!measurementColumnsHaveSize(columns, n) || !validOffsets) {
+      return "measurement column lengths or grid offsets are invalid";
+    }
+    for (std::size_t row = 0; row < n; ++row) {
+      if (!measurementVariancesValid(columns.varLoc0[row], columns.covLoc01[row], columns.varLoc1[row])) {
+        return "a measurement has a variance the fit cannot take: not finite, not positive, or a singular spatial block";
+      }
+    }
+    return nullptr;
+  }
+
+  /// The timeframe's vertex list: \a input, or the own vertexer's, which
+  /// keeps its triplets' claims with \a keepClaims. Valid until endTimeframe.
+  struct Vertices {
+    std::span<const VertexSeed> seeds;
+    const VertexerResult* found = nullptr;            ///< the own vertexer's list and contributors, host or device; none without it
+    const typename Vertexing::Result* pass = nullptr; ///< the own vertexer's on the host, with its claims; none without it or on a GPU
+    double seconds = 0.;
+    double planSeconds = 0.; ///< the initial device plan, before upload and vertex finding
+    bool dropped = false;    ///< out of memory, dropped (dropTFUponFailure): no tracking
+  };
+  [[nodiscard]] Vertices vertices(const Frame& frame, std::span<const VertexSeed> input, bool keepClaims)
+  {
+    if (!mVertexing) {
+      return {.seeds = input};
+    }
+    const auto& param = recoParam<Det>();
+    const auto start = std::chrono::steady_clock::now();
+    mVertexed = true;
+    if (mDevice) {
+      // The run's every iteration, the pass last, with an empty list.
+      mDevicePlan = planTimeframe<Det>(frame, mDeviceIterations, mDeviceWindows, mTracker->beamLine(), {}, frame.grid().geometry().blocksPerSlice(param.sliceWidthPS), param.sliceHaloPS);
+      const double planSeconds = std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+      if (!beginDeviceTimeframe()) {
+        return {.seconds = std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count(), .planSeconds = planSeconds, .dropped = true};
+      }
+      const auto status = mDevice->findTimeframeVertices(frame, mDevicePlan, mDeviceIterations.size() - 1U, mVertexing->settings(), beamSpotConstraint(mBeamLine, param), mDeviceFound, mDeviceReport);
+      const double seconds = std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+      if (status != StageStatus::kComplete) {
+        return {.seconds = seconds, .planSeconds = planSeconds, .dropped = dropOrFail(status, "the vertexing pass")};
+      }
+      return {.seeds = mDeviceFound.vertices, .found = &mDeviceFound, .seconds = seconds, .planSeconds = planSeconds};
+    }
+    mPass.emplace(mVertexing->find(frame, frame.grid().geometry().blocksPerSlice(param.sliceWidthPS), param.sliceHaloPS, keepClaims));
+    const double seconds = std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+    if (mPass->status != StageStatus::kComplete) {
+      return {.pass = &*mPass, .seconds = seconds, .dropped = dropOrFail(mPass->status, "the vertexing pass")};
+    }
+    return {.seeds = mPass->found.vertices, .found = &mPass->found, .pass = &*mPass, .seconds = seconds};
+  }
+
+  /// The tracker's run on \a frame from \a seeds. Valid until endTimeframe.
+  struct Tracked {
+    TimeframeResult result;
+    double seconds = 0.;
+    double planSeconds = 0.; ///< included in seconds: the tracking plan, before the run
+    bool dropped = false;    ///< out of memory, dropped (dropTFUponFailure): no tracks
+  };
+  [[nodiscard]] Tracked track(const Frame& frame, std::span<const VertexSeed> seeds)
+  {
+    const auto& param = recoParam<Det>();
+    const auto blocksPerSlice = frame.grid().geometry().blocksPerSlice(param.sliceWidthPS);
+    const auto start = std::chrono::steady_clock::now();
+    if (mDevice) {
+      return trackOnDevice(frame, seeds, blocksPerSlice, start);
+    }
+    mTracked = true;
+    const auto plan = mTracker->planTimeframe(frame, seeds, blocksPerSlice, param.sliceHaloPS);
+    const double planSeconds = std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+    Tracked tracked{.result = mTracker->run(frame, plan), .planSeconds = planSeconds};
+    tracked.seconds = std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+    if (tracked.result.status != StageStatus::kComplete) {
+      tracked.dropped = dropOrFail(tracked.result.status, "the tracking");
+    }
+    return tracked;
+  }
+
+  /// The end of the timeframe: what began, the vertexer's and the tracker's
+  /// storage, back to the pool, the staging learnt. Its results are invalid
+  /// after.
+  void endTimeframe() noexcept
+  {
+    mLastArenaPeak = 0U;
+    if (mDeviceTimeframe) {
+      mDevice->endTimeframe();
+      mLastArenaPeak = mDevice->arenaPeakBytes();
+      mDevice->detach();
+      mDeviceTracks.setMemoryResource(mDevicePool.get());
+      mDevicePlan = {};
+      mDeviceTrackingPlan = {};
+      mDeviceFound = {};
+      mDeviceTimeframe = false;
+      mVertexed = false;
+    }
+    if (mTracked) {
+      mTracker->endTimeframe();
+      mTracked = false;
+    }
+    if (mVertexed && !mDevice) {
+      mVertexing->endTimeframe();
+    }
+    mVertexed = false;
+    mPass.reset();
+  }
+
+  /// Calls endTimeframe when it goes out of scope.
+  class TimeframeGuard
+  {
+   public:
+    explicit TimeframeGuard(TrackingInterface& tracking) : mTracking(&tracking) {}
+    TimeframeGuard(const TimeframeGuard&) = delete;
+    TimeframeGuard& operator=(const TimeframeGuard&) = delete;
+    TimeframeGuard(TimeframeGuard&&) = delete;
+    TimeframeGuard& operator=(TimeframeGuard&&) = delete;
+    ~TimeframeGuard() { mTracking->endTimeframe(); }
+
+   private:
+    TrackingInterface* mTracking;
+  };
+
+  /// The guard of one timeframe, taken at its top.
+  [[nodiscard]] TimeframeGuard endTimeframeOnExit() { return TimeframeGuard{*this}; }
+
+  /// The timeframes dropped so far (dropTFUponFailure).
+  [[nodiscard]] std::size_t droppedTimeframes() const { return mDropped; }
+
+  [[nodiscard]] const std::shared_ptr<BoundedMemoryResource>& pool() const { return mPool; }
+  [[nodiscard]] Vertexing* vertexing() { return mVertexing.get(); }
+  [[nodiscard]] const typename Device::TimeframeReport& deviceReport() const { return mDeviceReport; }
+  [[nodiscard]] const DeviceProperties& deviceProperties() const { return mContext->runtime().properties(); }
+  [[nodiscard]] std::size_t deviceArenaPeakBytes() const { return mDevice->arenaPeakBytes(); }
+  /// The device arena's peak in the last timeframe that ended, 0 before one.
+  [[nodiscard]] std::size_t lastArenaPeakBytes() const { return mLastArenaPeak; }
+
+  [[nodiscard]] Controller& tracker() { return *mTracker; }
+  [[nodiscard]] const Controller& tracker() const { return *mTracker; }
+  [[nodiscard]] const Geometry<Det>& geometry() const { return *mGeometry; }
+  [[nodiscard]] const TrackingGeometry<Det>& tracking() const { return *mTracking; }
+  [[nodiscard]] const Material& material() const { return *mMaterial; }
+  [[nodiscard]] const ScatteringTable<Det>& scattering() const { return mScattering; }
+  [[nodiscard]] const BeamLine& beamLine() const { return mBeamLine; }
+  [[nodiscard]] const GridGeometry<Det>& grid() const
+  {
+    if (!mGrid) {
+      throw std::logic_error("GenericTracking: the grid is asked for before the producer shipped it");
+    }
+    return *mGrid;
+  }
+  [[nodiscard]] const std::vector<FrameTiming>& frames() const { return mFrames; }
+  /// The tracker's first iteration's source, and its sources as the log lines name them.
+  [[nodiscard]] VertexSource trackerSource() const { return mTrackerSource; }
+  [[nodiscard]] const std::string& trackerLabel() const { return mTrackerLabel; }
+  /// The track model's propagator: the run's field, the mass hypothesis.
+  [[nodiscard]] Propagator propagator() const { return {.bzKiloGauss = static_cast<Scalar>(mBzKiloGauss), .massGeV = static_cast<Scalar>(recoParam<Det>().massHypothesisGeV)}; }
+
+ private:
+  /// The layers' and the passive scatterers' budgets from \a material and
+  /// the scattering table: once per run.
+  void configureMaterial(const Material* material)
+  {
+    mMaterial = material;
+    if (mMaterial == nullptr) {
+      LOGP(fatal, "no material LUT from the CCDB ({})", materialLutPath<Det>());
+      return;
+    }
+    const auto budget = layerMaterial<Det>(*mMaterial);
+    const auto passiveBudget = passiveMaterial<Det>(*mMaterial);
+    mScattering = scatteringTable<Det>(budget, passiveBudget);
+    std::string layers;
+    for (std::size_t layer = 0; layer < budget.size(); ++layer) {
+      layers += fmt::format(" {}: {:.3f} %", layer, 100. * budget[layer]);
+    }
+    LOGP(info, "layer budgets, x/X0 across each layer's band (LUT):{}", layers);
+    std::size_t passiveIndex = 0U;
+    for (const double x2X0 : passiveBudget) {
+      const auto& passive = mScattering.passives[passiveIndex];
+      LOGP(info, "passive scatterer {}: {} at {:.3f} cm, x/X0 {:.3e} (LUT)", passiveIndex++, passive.barrel ? "cylinder" : "disc", passive.at.position, x2X0);
+    }
+  }
+
+  /// The device tracker, made once, and the run it is configured with every
+  /// timeframe (beginDeviceTimeframe): the host tracker's iterations, \a
+  /// settings their windows, with the pass last if the own vertexer runs. On
+  /// the first timeframe and on every new beam line.
+  void configureDevice(const std::vector<IterationSettings>& settings)
+  {
+    if (!mDevice) {
+      mDevice = mContext->runtime().makeTracker<Det>(DeviceBlock{});
+      mDevicePool = trackerMemoryPool(recoParam<Det>());
+      mDeviceTracks.setMemoryResource(mDevicePool.get());
+    }
+    mDeviceIterations.clear();
+    mDeviceWindows.clear();
+    for (std::size_t iteration = 0; iteration < mTracker->iterationCount(); ++iteration) {
+      mDeviceIterations.push_back(mTracker->iteration(iteration));
+      mDeviceWindows.push_back(settings[iteration].windows);
+    }
+    if (mVertexing) {
+      mDeviceIterations.push_back(mVertexing->passParameters());
+      mDeviceWindows.push_back(vertexingPassSettings(recoParam<Det>()).windows);
+    }
+  }
+
+  /// The timeframe's device work begun, once per timeframe: the block
+  /// attached and the run configured on it. False if the timeframe is dropped:
+  /// the block does not hold the run (dropTFUponFailure).
+  [[nodiscard]] bool beginDeviceTimeframe()
+  {
+    if (mDeviceTimeframe) {
+      return true;
+    }
+    mDeviceTimeframe = true; // endTimeframe detaches
+    mDevice->attach(mBlock);
+    const auto status = mDevice->configureRun(mDeviceIterations, *mTracking, *mMaterial, propagator());
+    return status == StageStatus::kComplete || !dropOrFail(status, "the run's data on the device");
+  }
+
+  /// The tracking on the device: with the own vertexer, the tracking's plan
+  /// with its list replacing the timeframe's; else the timeframe begun with
+  /// the tracking's plan from \a seeds.
+  [[nodiscard]] Tracked trackOnDevice(const Frame& frame, std::span<const VertexSeed> seeds, std::int32_t blocksPerSlice, std::chrono::steady_clock::time_point start)
+  {
+    const auto& param = recoParam<Det>();
+    const bool replaced = mVertexing != nullptr;
+    const std::size_t iterations = mTracker->iterationCount();
+    mDeviceTrackingPlan = replaced ? planTimeframe<Det>(frame, mDeviceIterations, mDeviceWindows, mTracker->beamLine(), seeds, blocksPerSlice, param.sliceHaloPS) : mTracker->planTimeframe(frame, seeds, blocksPerSlice, param.sliceHaloPS);
+    Tracked tracked;
+    tracked.planSeconds = std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+    if (!beginDeviceTimeframe()) {
+      tracked.seconds = std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+      tracked.dropped = true;
+      return tracked;
+    }
+    tracked.result.status = mDevice->trackTimeframe(frame, mDeviceTrackingPlan, iterations, replaced, mDeviceTracks, mDeviceReport);
+    tracked.result.tracks = &mDeviceTracks;
+    tracked.seconds = std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+    if (tracked.result.status != StageStatus::kComplete) {
+      tracked.dropped = dropOrFail(tracked.result.status, "the tracking");
+    }
+    return tracked;
+  }
+
+  /// A timeframe whose \a what ended with \a status: dropped, if it ran out
+  /// of memory and dropTFUponFailure is on; else the run fails.
+  bool dropOrFail(StageStatus status, const char* what)
+  {
+    if (status == StageStatus::kOutOfMemory && recoParam<Det>().dropTFUponFailure) {
+      ++mDropped;
+      LOGP(error, "{} ran out of memory (GTRKReco<DET>.memoryLimitGB, or the device's --gtrk-gpu-arena-mb): the timeframe dropped, {} so far (GTRKReco<DET>.dropTFUponFailure)", what, mDropped);
+      return true;
+    }
+    LOGP(fatal, "{} failed with status {}", what, static_cast<int>(status));
+    return false;
+  }
+
+  bool mWithVertices = false;
+  double mBzKiloGauss = 0.;
+  std::unique_ptr<const Geometry<Det>> mGeometry;
+  const Material* mMaterial = nullptr; ///< the condition's (MaterialLUT.h)
+  ScatteringTable<Det> mScattering;
+  std::unique_ptr<TrackingGeometry<Det>> mTracking;
+  BeamLine mBeamLine;                     ///< the producer's, the trackers were built for
+  std::optional<GridGeometry<Det>> mGrid; ///< the grid's layout, the producer's (MeasurementGeometry)
+  std::vector<FrameTiming> mFrames;       ///< each layer's readout frames, the grid's
+  std::shared_ptr<BoundedMemoryResource> mPool;
+  std::unique_ptr<Controller> mTracker;  ///< each iteration from its configured source (GTRKReco<DET>.iterationVertexSource)
+  std::unique_ptr<Vertexing> mVertexing; ///< the own vertexer before the tracking (GTRKReco<DET>.vertexer); none without
+  std::optional<typename Vertexing::Result> mPass;
+  VertexSource mTrackerSource = VertexSource::kBeamLine;
+  std::string mTrackerLabel;
+  TrackingDevice mDeviceOptions;
+  std::unique_ptr<DeviceContext> mContext;                 ///< the GPU, on a GPU backend: its reconstruction, the arena's block and the runtime
+  DeviceBlock mBlock;                                      ///< the device memory each timeframe attaches
+  std::unique_ptr<Device> mDevice;                         ///< the device tracker, on the context; released before it
+  std::vector<IterationParameters<Det>> mDeviceIterations; ///< as configured on the device: the host tracker's, then the pass
+  std::vector<SearchWindowParams> mDeviceWindows;          ///< the same iterations' windows
+  /// The timeframe's, which the device reads until endTimeframe: the plan
+  /// of the vertexer's pass, the tracking's plan, the vertexer's list, the
+  /// tracks downloaded into the pool, the calls' report.
+  TimeframePlan<Det> mDevicePlan;
+  TimeframePlan<Det> mDeviceTrackingPlan;
+  VertexerResult mDeviceFound;
+  std::shared_ptr<BoundedMemoryResource> mDevicePool;
+  typename TrackRefit<Det>::Tracks mDeviceTracks;
+  typename Device::TimeframeReport mDeviceReport;
+  bool mDeviceTimeframe = false; ///< the device holds a timeframe
+  bool mVertexed = false;        ///< the vertexer ran this timeframe
+  bool mTracked = false;         ///< the tracker ran this timeframe
+  std::size_t mDropped = 0U;
+  std::size_t mLastArenaPeak = 0U;
+};
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_TRACKINGINTERFACE_H_
diff --git a/Detectors/GenericTracking/workflow/src/AdaptorDevice.h b/Detectors/GenericTracking/workflow/src/AdaptorDevice.h
new file mode 100644
index 0000000000000..b0452a5533e2a
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/AdaptorDevice.h
@@ -0,0 +1,560 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file AdaptorDevice.h
+/// \brief The O2-format adaptor of the ITS and the MFT: the tracking device's
+///        products as what O2's own tracker of the detector publishes.
+///
+/// The ITS's: ITS/TRACKS, TRACKCLSID, ITSTrackROF, VERTICES, VERTICESROF,
+/// IRFRAMES, with MC TRACKSMCTR, VERTICESMCTR, VERTICESMCPUR; the MFT's:
+/// MFT/TRACKS, TRACKCLSID, MFTTrackROF, with MC TRACKSMCTR; both META/<DET>TRACKER
+/// once. Records whose refit failed are left out. The parameters are the
+/// states' own (O2Parameters.h), the labels the study's rule (TrackLabel.h),
+/// a track's time and readout frame ITS's rule on its clusters' frames.
+
+#ifndef GTRK_WORKFLOW_ADAPTORDEVICE_H_
+#define GTRK_WORKFLOW_ADAPTORDEVICE_H_
+
+#include "GenericTracking/Alice/Clusters.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Workflow/AdaptorSpec.h"
+#include "GenericTracking/Workflow/Conditions.h"
+#include "GenericTracking/Workflow/DataSpecs.h"
+#include "GenericTracking/Workflow/GeometryProvider.h"
+#include "GenericTracking/Workflow/GridConfig.h"
+#include "GenericTracking/Workflow/O2Parameters.h"
+#include "GenericTracking/Workflow/RecoParam.h"
+#include "GenericTracking/Workflow/TrackLabel.h"
+#include "GenericTracking/Workflow/TrackerSpec.h"
+
+#include "CommonConstants/LHCConstants.h"
+#include "CommonDataFormat/IRFrame.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "DataFormatsITS/TrackITS.h"
+#include "DataFormatsITS/Vertex.h"
+#include "DataFormatsITSMFT/CompCluster.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "DataFormatsITSMFT/TopologyDictionary.h"
+#include "DataFormatsMFT/TrackMFT.h"
+#include "Framework/CCDBParamSpec.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/DeviceSpec.h"
+#include "Framework/Logger.h"
+#include "Framework/Task.h"
+#include "Framework/TimingInfo.h"
+#include "ITSBase/GeometryTGeo.h"
+#include "ITSMFTTracking/ROFViews.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+
+#include <TMap.h>
+#include <TObjString.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <concepts>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <numeric>
+#include <span>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace o2::gtrk::workflow
+{
+
+namespace adaptor
+{
+
+/// A particle's label, the fake flag unless \a good; O2's noise label for no
+/// particle.
+[[nodiscard]] inline o2::MCCompLabel labelOf(std::uint64_t particle, bool good) { return particle == kNoTrackParticle ? o2::MCCompLabel(true) : labelOfParticle(particle, !good); }
+
+/// A timeframe's clusters as the adaptor needs them: each one's readout frame
+/// (its record in CLUSTERSROF) and that frame's start in BC from the
+/// timeframe's start, without the delay and bias.
+struct ClusterFrames {
+  std::vector<std::uint32_t> record;  ///< per cluster
+  std::vector<std::int64_t> recordBC; ///< per record
+};
+
+[[nodiscard]] inline ClusterFrames clusterFrames(std::span<const o2::itsmft::ROFRecord> rofs, std::size_t clusters, std::uint32_t tfFirstOrbit)
+{
+  ClusterFrames result;
+  result.record.assign(clusters, std::numeric_limits<std::uint32_t>::max());
+  result.recordBC.reserve(rofs.size());
+  for (std::size_t r = 0; r < rofs.size(); ++r) {
+    const auto& ir = rofs[r].getBCData();
+    result.recordBC.push_back((static_cast<std::int64_t>(ir.orbit - tfFirstOrbit) * o2::constants::lhc::LHCMaxBunches) + ir.bc);
+    for (int i = 0; i < rofs[r].getNEntries(); ++i) {
+      result.record[static_cast<std::size_t>(rofs[r].getFirstEntry()) + static_cast<std::size_t>(i)] = static_cast<std::uint32_t>(r);
+    }
+  }
+  return result;
+}
+
+/// A track's time as ITS takes it (`TrackerTraits`): the intersection of its
+/// clusters' frames `[start + delay + bias, + length)` in BC from the
+/// timeframe's start; where they do not intersect -- a track across frames,
+/// which only a margin lets the tracker make -- the record's box, the frames
+/// widened by the margin. [lower, upper) in BC.
+struct BCRange {
+  std::int64_t lower = 0;
+  std::int64_t upper = 0;
+};
+
+template <typename Record>
+[[nodiscard]] BCRange trackTime(const Record& record, std::span<const std::uint32_t> clusterIndex, const ClusterFrames& frames, const FrameTiming& timing)
+{
+  BCRange nominal{.lower = std::numeric_limits<std::int64_t>::min(), .upper = std::numeric_limits<std::int64_t>::max()};
+  for (std::uint8_t i = 0; i < record.count; ++i) {
+    const auto start = frames.recordBC[frames.record[clusterIndex[record.clusters.index[i]]]] + timing.firstStartBC;
+    nominal.lower = std::max(nominal.lower, start);
+    nominal.upper = std::min(nominal.upper, start + timing.lengthBC);
+  }
+  if (nominal.lower < nominal.upper) {
+    return nominal;
+  }
+  return {.lower = bcOfPS(record.timePS), .upper = bcOfPS(static_cast<std::int64_t>(record.timePS) + record.widthPS)};
+}
+
+/// The earliest frame (its CLUSTERSROF record) among a track's clusters.
+template <typename Record>
+[[nodiscard]] std::uint32_t earliestRecord(const Record& record, std::span<const std::uint32_t> clusterIndex, const ClusterFrames& frames)
+{
+  std::uint32_t earliest = std::numeric_limits<std::uint32_t>::max();
+  for (std::uint8_t i = 0; i < record.count; ++i) {
+    earliest = std::min(earliest, frames.record[clusterIndex[record.clusters.index[i]]]);
+  }
+  return earliest;
+}
+
+/// Each cluster's pixel count, the converter's decoding (`localClusters`).
+[[nodiscard]] inline std::vector<std::uint32_t> pixelCounts(std::span<const o2::itsmft::CompClusterExt> compact, std::span<const unsigned char> patterns, const o2::itsmft::TopologyDictionary& dictionary)
+{
+  const auto local = alice::localClusters(compact, patterns, dictionary);
+  std::vector<std::uint32_t> result(local.size());
+  std::ranges::transform(local, result.begin(), [](const auto& cluster) { return cluster.nPixels; });
+  return result;
+}
+
+/// The track's particle by the shared rule (TrackLabel.h), its rows'
+/// clusters' labels, innermost first; \a carried gets, per row, whether it
+/// carries that particle.
+template <typename Record>
+[[nodiscard]] o2::MCCompLabel trackLabel(const Record& record, std::span<const std::uint32_t> clusterIndex, const o2::dataformats::MCTruthContainer<o2::MCCompLabel>& labels, std::span<bool> carried)
+{
+  constexpr std::size_t kRows = std::extent_v<std::remove_cvref_t<decltype(record.clusters.index)>>;
+  std::array<RowParticles, kRows> rows{};
+  std::array<std::uint32_t, kRows> track{};
+  for (std::uint8_t i = 0; i < record.count; ++i) {
+    const auto all = labels.getLabels(clusterIndex[record.clusters.index[i]]);
+    rows[i] = rowParticles(std::span<const o2::MCCompLabel>{all.data(), all.size()});
+    track[i] = i;
+  }
+  const std::span<const std::uint32_t> order{track.data(), record.count};
+  const auto majority = majorityParticle(rows, order);
+  const bool good = majority.particle != kNoTrackParticle && majority.carried == record.count;
+  for (std::uint8_t i = 0; i < record.count; ++i) {
+    carried[i] = majority.particle != kNoTrackParticle && rows[i].carries(majority.particle);
+  }
+  return labelOf(majority.particle, good);
+}
+
+/// The description of O2's tracker metadata of \a Det, META/<DET>TRACKER.
+template <DetectorLayout Det>
+[[nodiscard]] o2::header::DataDescription metaDescription()
+{
+  o2::header::DataDescription result;
+  result.runtimeInit((detectorOrigin<Det>().template as<std::string>() + "TRACKER").c_str());
+  return result;
+}
+
+/// META/<DET>TRACKER once, on the first timeslice: the configuration that
+/// made the tracks, `GTRKReco<DET>` as JSON, as O2's trackers publish theirs.
+template <DetectorLayout Det>
+void publishConfiguration(o2::framework::ProcessingContext& pc, bool& published)
+{
+  if (published) {
+    return;
+  }
+  published = true;
+  if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId != 0) {
+    return;
+  }
+  const auto name = RecoParamOf<Det>::type::Instance().getName();
+  TMap md;
+  md.SetOwnerKeyValue();
+  md.Add(new TObjString(name.c_str()), new TObjString(o2::conf::ConfigurableParam::asJSON(name).c_str()));
+  pc.outputs().snapshot(o2::framework::Output{"META", metaDescription<Det>(), 0}, md);
+}
+
+/// The device's own inputs and conditions, both detectors'.
+template <DetectorLayout Det>
+class AdaptorTask : public o2::framework::Task
+{
+ public:
+  using Record = TrackRecord<Det>;
+  using Labels = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
+  static constexpr bool kITS = std::same_as<Det, detectors::ITS>;
+
+  AdaptorTask(bool useMC, std::shared_ptr<Conditions<Det>> conditions) : mUseMC(useMC), mConditions(std::move(conditions)) {}
+
+  void init(o2::framework::InitContext& ic) final { mConditions->init(ic); }
+
+  void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final
+  {
+    if (matcher == o2::framework::ConcreteDataMatcher(detectorOrigin<Det>(), "CLUSDICT", 0)) {
+      mDictionary = static_cast<const o2::itsmft::TopologyDictionary*>(obj);
+      return;
+    }
+    mConditions->finaliseCCDB(matcher, obj);
+  }
+
+  void run(o2::framework::ProcessingContext& pc) final
+  {
+    mConditions->checkUpdates(pc);
+    pc.inputs().get<o2::itsmft::TopologyDictionary*>("dictionary");
+    adaptor::publishConfiguration<Det>(pc, mConfigurationPublished);
+    if (!mGeometry) {
+      // The run's geometry, as the tracker's (TrackingInterface::configure).
+      mGeometry = std::make_unique<TrackingGeometry<Det>>(*makeGeometry<Det>(mConditions->measurementDepthsCM()));
+    }
+    const auto orbit = pc.services().get<o2::framework::TimingInfo>().firstTForbit;
+    const auto records = pc.inputs().get<gsl::span<Record>>("tracks");
+    const auto rows = pc.inputs().get<gsl::span<std::uint32_t>>("clusterIndex");
+    const auto rofs = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>("rofs");
+    const auto compact = pc.inputs().get<gsl::span<o2::itsmft::CompClusterExt>>("compclusters");
+    const auto patterns = pc.inputs().get<gsl::span<unsigned char>>("patterns");
+    std::unique_ptr<const Labels> labels;
+    if (mUseMC) {
+      labels = pc.inputs().get<const Labels*>("labels");
+    }
+    const std::span<const std::uint32_t> clusterIndex{rows.data(), rows.size()};
+    const std::span<const o2::itsmft::ROFRecord> frameRecords{rofs.data(), rofs.size()};
+    const auto frames = adaptor::clusterFrames(frameRecords, compact.size(), orbit);
+    const auto pixels = compact.empty() ? std::vector<std::uint32_t>{} : adaptor::pixelCounts({compact.data(), compact.size()}, {patterns.data(), patterns.size()}, *mDictionary);
+    const auto timing = mConditions->frameTiming().front();
+    const double bz = nominalBzKiloGauss();
+
+    // The fitted tracks, in the tracker's order.
+    std::vector<std::uint32_t> fitted;
+    fitted.reserve(records.size());
+    for (std::uint32_t track = 0; track < records.size(); ++track) {
+      if (records[track].status == PropagationStatus::kOk) {
+        fitted.push_back(track);
+      }
+    }
+    const auto layerOf = [&](std::uint32_t row) { return mGeometry->surface(compact[clusterIndex[row]].getSensorID()).layer; };
+    if constexpr (kITS) {
+      runITS(pc, records, fitted, clusterIndex, frameRecords, frames, pixels, labels.get(), timing, bz, orbit, layerOf);
+    } else {
+      runMFT(pc, records, fitted, clusterIndex, frameRecords, frames, pixels, labels.get(), bz, orbit, layerOf);
+    }
+  }
+
+ private:
+  template <typename LayerOf>
+  void runITS(o2::framework::ProcessingContext& pc, gsl::span<const Record> records, std::span<const std::uint32_t> fitted, std::span<const std::uint32_t> clusterIndex, std::span<const o2::itsmft::ROFRecord> rofs, const adaptor::ClusterFrames& frames, std::span<const std::uint32_t> pixels, const Labels* labels, const FrameTiming& timing, double bz, std::uint32_t orbit, const LayerOf& layerOf)
+  {
+    using o2::framework::Output;
+    using AlpideParam = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>;
+    const auto& origin = detectorOrigin<Det>();
+    auto& irFrames = pc.outputs().make<std::vector<o2::dataformats::IRFrame>>(Output{origin, "IRFRAMES", 0});
+    auto& clusterIds = pc.outputs().make<std::vector<int>>(Output{origin, "TRACKCLSID", 0});
+    auto& tracks = pc.outputs().make<std::vector<o2::its::TrackITS>>(Output{origin, "TRACKS", 0});
+    auto& trackROFs = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{origin, "ITSTrackROF", 0});
+    auto& vertices = pc.outputs().make<std::vector<o2::its::Vertex>>(Output{origin, "VERTICES", 0});
+    auto& vertexROFs = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{origin, "VERTICESROF", 0});
+
+    const auto length = static_cast<std::int64_t>(timing.lengthBC);
+    const auto delay = static_cast<std::int64_t>(AlpideParam::Instance().getROFDelayInBC(0));
+    using BC = o2::itsmft::tracking::ROFTimingLayer::BCType;
+    // ITS's frame of a time: its lower edge's, 0 before the first.
+    const o2::itsmft::tracking::ROFTimingLayer rofTiming{
+      .mROFLength = static_cast<BC>(length),
+      .mROFDelay = static_cast<BC>(delay),
+      .mROFBias = static_cast<BC>(AlpideParam::Instance().getROFBiasInBC(0)),
+    };
+    // A vertex's frame as a track's: the lower edge of its time with the half
+    // width at most half a frame. Its box's own lower edge lies a margin
+    // before its frame starts, in the frame before.
+    const auto vertexFrame = [&](const o2::its::Vertex& vertex) {
+      const auto time = vertex.getTimeStamp().makeSymmetrical();
+      return static_cast<std::int64_t>(rofTiming.getROF(o2::its::TimeStamp(time.getTimeStamp(), std::min(time.getTimeStampError(), static_cast<float>(length) / 2.F))));
+    };
+
+    // A cluster in more than one track's innermost place: ITS's shared flag.
+    std::vector<std::uint8_t> innermost(clusterIndex.empty() ? 0U : *std::ranges::max_element(clusterIndex) + 1U, 0U); // NOLINT(misc-const-correctness): written in a dependent call the check does not see
+    for (const auto track : fitted) {
+      auto& uses = innermost[clusterIndex[records[track].clusters.index[0]]];
+      uses = static_cast<std::uint8_t>(std::min(uses + 1, 2));
+    }
+
+    struct Converted {
+      o2::its::TrackITS track;
+      o2::MCCompLabel label;
+      std::uint32_t record = 0;
+      std::int64_t frame = 0;
+    };
+    std::vector<Converted> converted;
+    converted.reserve(fitted.size());
+    std::size_t turned = 0U;
+    std::array<bool, TrackRefit<Det>::kMaxClusters> carried{};
+    for (const auto track : fitted) {
+      const auto& record = records[track];
+      auto* const geometry = o2::its::GeometryTGeo::Instance();
+      const double sensorAlpha = geometry->getSensorRefAlpha(static_cast<int>(record.state.surface));
+      const double alpha = frameAlpha(record.state, sensorAlpha);
+      turned += std::cos(static_cast<double>(record.state.phi()) - sensorAlpha) < 0. ? 1U : 0U;
+      auto& out = converted.emplace_back();
+      out.record = track;
+      out.track = o2::its::TrackITS{toTrackParCov(record.state, mGeometry->planeOf(record.state), alpha, bz)};
+      const double outerAlpha = frameAlpha(record.outwardState, geometry->getSensorRefAlpha(static_cast<int>(record.outwardState.surface)));
+      out.track.getParamOut() = toTrackParCov(record.outwardState, mGeometry->planeOf(record.outwardState), outerAlpha, bz);
+      out.track.setChi2(record.chi2);
+      out.track.setNumberOfClusters(record.count);
+      if (labels != nullptr) {
+        out.label = adaptor::trackLabel(record, clusterIndex, *labels, std::span<bool>{carried.data(), record.count});
+      }
+      std::uint32_t pattern = 0U;
+      for (std::uint8_t i = 0; i < record.count; ++i) {
+        const auto layer = layerOf(record.clusters.index[i]);
+        pattern |= 1U << layer;
+        pattern |= labels != nullptr && carried[i] ? 1U << (16U + layer) : 0U;
+        out.track.setClusterSize(layer, static_cast<int>(pixels[clusterIndex[record.clusters.index[i]]]));
+      }
+      out.track.setPattern(pattern);
+      out.track.setSharedClusters(innermost[clusterIndex[record.clusters.index[0]]] > 1U);
+      const auto time = adaptor::trackTime(record, clusterIndex, frames, timing);
+      const float half = std::min(static_cast<float>(time.upper - time.lower) / 2.F, static_cast<float>(length) / 2.F);
+      const float centre = static_cast<float>(time.lower + time.upper) / 2.F;
+      out.track.getTimeStamp() = o2::its::TimeStamp(centre, half);
+      out.frame = rofTiming.getROF(out.track.getTimeStamp());
+    }
+    // ITS's order: by the time's lower edge, the tracker's order within.
+    std::ranges::stable_sort(converted, {}, [](const Converted& c) { return c.track.getTimeStamp().getTimeStamp() - c.track.getTimeStamp().getTimeStampError(); });
+
+    // The own vertexer's vertices, at the beam line's x and y.
+    const auto shipped = pc.inputs().get<MeasurementGeometry<Det>>("measurementGeometry");
+    const auto seeds = pc.inputs().get<gsl::span<VertexSeed>>("vertices");
+    const auto contributors = pc.inputs().get<gsl::span<std::uint32_t>>("contributors");
+    for (std::size_t v = 0; v < seeds.size(); ++v) {
+      const auto& seed = seeds[v];
+      const std::array<float, o2::its::Vertex::kNCov> cov{seed.varTransverse, 0.F, seed.varTransverse, 0.F, 0.F, seed.varZ};
+      auto& vertex = vertices.emplace_back(o2::math_utils::Point3D<float>(static_cast<float>(shipped.beamLine.x), static_cast<float>(shipped.beamLine.y), seed.z), cov, static_cast<ushort>(std::min<std::uint32_t>(contributors[v], std::numeric_limits<ushort>::max())), 0.F);
+      const auto lower = bcOfPS(seed.timePS);
+      vertex.setTimeStamp(o2::its::TimeEstBC(static_cast<std::uint32_t>(lower), static_cast<std::uint32_t>(bcOfPS(static_cast<std::int64_t>(seed.timePS) + seed.widthPS) - lower)));
+    }
+    // By frame, as the frame records count them, then by time and contributors.
+    std::ranges::stable_sort(vertices, [&](const o2::its::Vertex& a, const o2::its::Vertex& b) {
+      const auto frameA = vertexFrame(a);
+      const auto frameB = vertexFrame(b);
+      if (frameA != frameB) {
+        return frameA < frameB;
+      }
+      return a.getTimeStamp().lower() != b.getTimeStamp().lower() ? a.getTimeStamp().lower() < b.getTimeStamp().lower() : a.getNContributors() > b.getNContributors();
+    });
+
+    // The clock's frames of the timeframe, as ITS's (`setBCData`), and more
+    // if a track or vertex lies beyond them.
+    std::int64_t frameCount = (o2::constants::lhc::LHCMaxBunches / length) * mConditions->orbitsPerTimeframe();
+    for (const auto& c : converted) {
+      frameCount = std::max(frameCount, c.frame + 1);
+    }
+    for (const auto& vertex : vertices) {
+      frameCount = std::max(frameCount, vertexFrame(vertex) + 1);
+    }
+    for (auto* frameRecords : {&trackROFs, &vertexROFs}) {
+      frameRecords->resize(static_cast<std::size_t>(frameCount));
+      for (std::int64_t i = 0; i < frameCount; ++i) {
+        auto& rof = (*frameRecords)[static_cast<std::size_t>(i)];
+        rof.setBCData(o2::InteractionRecord(static_cast<std::uint16_t>(((i * length) % o2::constants::lhc::LHCMaxBunches) + delay), orbit + static_cast<std::uint32_t>(i * length / o2::constants::lhc::LHCMaxBunches)));
+        rof.setROFrame(static_cast<std::uint32_t>(i));
+        rof.setNEntries(0);
+        rof.setFirstEntry(-1);
+      }
+    }
+    // As ITS: the standard vertexing mode on the input's frames, with the vertexer.
+    if (recoParam<Det>().vertexer) {
+      for (std::size_t i = 0; i < std::min(rofs.size(), vertexROFs.size()); ++i) {
+        vertexROFs[i].setFlag(o2::itsmft::ROFRecord::VtxStdMode);
+      }
+    }
+
+    std::vector<int> entries(static_cast<std::size_t>(frameCount) + 1U, 0);
+    tracks.reserve(converted.size());
+    for (auto& c : converted) {
+      const auto& record = records[c.record];
+      c.track.setFirstClusterEntry(static_cast<int>(clusterIds.size()));
+      for (std::uint8_t i = record.count; i-- > 0;) { // outermost first
+        clusterIds.push_back(static_cast<int>(clusterIndex[record.clusters.index[i]]));
+      }
+      tracks.push_back(c.track);
+      ++entries[static_cast<std::size_t>(c.frame)];
+    }
+    std::exclusive_scan(entries.begin(), entries.end(), entries.begin(), 0);
+    for (std::size_t i = 0; i < trackROFs.size(); ++i) {
+      trackROFs[i].setFirstEntry(entries[i]);
+      trackROFs[i].setNEntries(entries[i + 1] - entries[i]);
+      trackROFs[i].setFlags(vertexROFs[i].getFlags());
+      // Every frame is processed: no multiplicity selection here.
+      auto& irFrame = irFrames.emplace_back(trackROFs[i].getBCData(), trackROFs[i].getBCData() + (length - 1));
+      irFrame.info = static_cast<std::uint64_t>(trackROFs[i].getNEntries());
+    }
+    std::ranges::fill(entries, 0);
+    for (const auto& vertex : vertices) {
+      ++entries[static_cast<std::size_t>(vertexFrame(vertex))];
+    }
+    std::exclusive_scan(entries.begin(), entries.end(), entries.begin(), 0);
+    for (std::size_t i = 0; i < vertexROFs.size(); ++i) {
+      vertexROFs[i].setFirstEntry(entries[i]);
+      vertexROFs[i].setNEntries(entries[i + 1] - entries[i]);
+    }
+
+    if (mUseMC) {
+      auto& trackLabels = pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{origin, "TRACKSMCTR", 0});
+      trackLabels.reserve(converted.size());
+      for (const auto& c : converted) {
+        trackLabels.push_back(c.label);
+      }
+      // No vertex truth: the products do not say which clusters contributed.
+      pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{origin, "VERTICESMCTR", 0}, vertices.size());
+      pc.outputs().make<std::vector<float>>(Output{origin, "VERTICESMCPUR", 0}, vertices.size(), 0.F);
+    }
+    LOGP(info, "{}: the timeframe at orbit {}: {} tracks ({} failed refits left out, {} in a frame turned by pi), {} vertices, {} readout frames", Det::name, orbit, tracks.size(), records.size() - fitted.size(), turned, vertices.size(), trackROFs.size());
+  }
+
+  template <typename LayerOf>
+  void runMFT(o2::framework::ProcessingContext& pc, gsl::span<const Record> records, std::span<const std::uint32_t> fitted, std::span<const std::uint32_t> clusterIndex, std::span<const o2::itsmft::ROFRecord> rofs, const adaptor::ClusterFrames& frames, std::span<const std::uint32_t> pixels, const Labels* labels, double bz, std::uint32_t orbit, const LayerOf& layerOf)
+  {
+    using o2::framework::Output;
+    const auto& origin = detectorOrigin<Det>();
+    auto& trackROFs = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{origin, "MFTTrackROF", 0}, rofs.begin(), rofs.end());
+    auto& clusterIds = pc.outputs().make<std::vector<int>>(Output{origin, "TRACKCLSID", 0});
+    auto& tracks = pc.outputs().make<std::vector<o2::mft::TrackMFT>>(Output{origin, "TRACKS", 0});
+
+    struct Converted {
+      o2::mft::TrackMFT track;
+      o2::MCCompLabel label;
+      std::uint32_t record = 0;
+      std::uint32_t frame = 0;
+    };
+    std::vector<Converted> converted;
+    converted.reserve(fitted.size());
+    std::size_t crossing = 0U;
+    std::array<bool, TrackRefit<Det>::kMaxClusters> carried{};
+    for (const auto track : fitted) {
+      const auto& record = records[track];
+      auto& out = converted.emplace_back();
+      out.record = track;
+      const auto inner = toTrackParCovFwd(record.state, mGeometry->planeOf(record.state), bz, record.chi2);
+      static_cast<o2::track::TrackParCovFwd&>(out.track) = inner;
+      out.track.setOutParam(toTrackParCovFwd(record.outwardState, mGeometry->planeOf(record.outwardState), bz, record.outwardChi2));
+      out.track.setCA(true);
+      out.track.setNumberOfPoints(record.count);
+      if (labels != nullptr) {
+        out.label = adaptor::trackLabel(record, clusterIndex, *labels, std::span<bool>{carried.data(), record.count});
+      }
+      for (std::uint8_t i = 0; i < record.count; ++i) {
+        out.track.setClusterSize(layerOf(record.clusters.index[i]), static_cast<int>(pixels[clusterIndex[record.clusters.index[i]]]));
+      }
+      // TrackMFT has no time: a track across frames is timed by the earlier.
+      out.frame = adaptor::earliestRecord(record, clusterIndex, frames);
+      for (std::uint8_t i = 0; i < record.count; ++i) {
+        if (frames.record[clusterIndex[record.clusters.index[i]]] != out.frame) {
+          ++crossing;
+          break;
+        }
+      }
+    }
+    std::ranges::stable_sort(converted, {}, &Converted::frame);
+
+    std::vector<int> entries(trackROFs.size() + 1U, 0);
+    tracks.reserve(converted.size());
+    for (auto& c : converted) {
+      const auto& record = records[c.record];
+      c.track.setExternalClusterIndexOffset(static_cast<int>(clusterIds.size()));
+      for (std::uint8_t i = 0; i < record.count; ++i) { // innermost first
+        clusterIds.push_back(static_cast<int>(clusterIndex[record.clusters.index[i]]));
+      }
+      tracks.push_back(c.track);
+      ++entries[c.frame];
+    }
+    std::exclusive_scan(entries.begin(), entries.end(), entries.begin(), 0);
+    for (std::size_t i = 0; i < trackROFs.size(); ++i) {
+      trackROFs[i].setFirstEntry(entries[i]);
+      trackROFs[i].setNEntries(entries[i + 1] - entries[i]);
+    }
+    if (mUseMC) {
+      auto& trackLabels = pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{origin, "TRACKSMCTR", 0});
+      trackLabels.reserve(converted.size());
+      for (const auto& c : converted) {
+        trackLabels.push_back(c.label);
+      }
+    }
+    LOGP(info, "{}: the timeframe at orbit {}: {} tracks ({} failed refits left out, {} across readout frames, timed by the earlier), {} readout frames", Det::name, orbit, tracks.size(), records.size() - fitted.size(), crossing, trackROFs.size());
+  }
+
+  bool mUseMC = false;
+  bool mConfigurationPublished = false;
+  std::shared_ptr<Conditions<Det>> mConditions;                ///< the run's geometry, field, frames and orbits per timeframe
+  std::unique_ptr<const TrackingGeometry<Det>> mGeometry;      ///< the planes the tracker's states are bound to
+  const o2::itsmft::TopologyDictionary* mDictionary = nullptr; ///< the CCDB cache's: the clusters' pixel counts
+};
+
+} // namespace adaptor
+
+template <DetectorLayout Det>
+o2::framework::DataProcessorSpec getAdaptorSpec(bool useMC)
+{
+  using namespace o2::framework;
+  constexpr bool kITS = std::same_as<Det, detectors::ITS>;
+  const auto origin = detectorOrigin<Det>();
+  std::vector<InputSpec> inputs{InputSpec{"tracks", gDataOrigin, description<Det>(kTracks), 0, Lifetime::Timeframe}, InputSpec{"clusterIndex", gDataOrigin, description<Det>(kMeasurements), static_cast<std::uint32_t>(MeasurementColumn::clusterIndex), Lifetime::Timeframe}, InputSpec{"rofs", origin, "CLUSTERSROF", 0, Lifetime::Timeframe}, InputSpec{"compclusters", origin, "COMPCLUSTERS", 0, Lifetime::Timeframe}, InputSpec{"patterns", origin, "PATTERNS", 0, Lifetime::Timeframe}, InputSpec{"dictionary", origin, "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec(origin.template as<std::string>() + "/Calib/ClusterDictionary")}};
+  std::vector<OutputSpec> outputs{{origin, "TRACKS", 0, Lifetime::Timeframe}, {origin, "TRACKCLSID", 0, Lifetime::Timeframe}, {"META", adaptor::metaDescription<Det>(), 0, Lifetime::Sporadic}};
+  if constexpr (kITS) {
+    inputs.emplace_back("measurementGeometry", gDataOrigin, description<Det>(kMeasurementGeometry), 0, Lifetime::Timeframe);
+    inputs.emplace_back("vertices", gDataOrigin, description<Det>(kVertexSeeds), 0, Lifetime::Timeframe);
+    inputs.emplace_back("contributors", gDataOrigin, description<Det>(kVertexContributors), 0, Lifetime::Timeframe);
+    outputs.emplace_back(origin, "ITSTrackROF", 0, Lifetime::Timeframe);
+    outputs.emplace_back(origin, "VERTICES", 0, Lifetime::Timeframe);
+    outputs.emplace_back(origin, "VERTICESROF", 0, Lifetime::Timeframe);
+    outputs.emplace_back(origin, "IRFRAMES", 0, Lifetime::Timeframe);
+  } else {
+    outputs.emplace_back(origin, "MFTTrackROF", 0, Lifetime::Timeframe);
+  }
+  if (useMC) {
+    inputs.emplace_back("labels", origin, "CLUSTERSMCTR", 0, Lifetime::Timeframe);
+    outputs.emplace_back(origin, "TRACKSMCTR", 0, Lifetime::Timeframe);
+    if constexpr (kITS) {
+      outputs.emplace_back(origin, "VERTICESMCTR", 0, Lifetime::Timeframe);
+      outputs.emplace_back(origin, "VERTICESMCPUR", 0, Lifetime::Timeframe);
+    }
+  }
+  auto conditions = std::make_shared<Conditions<Det>>(inputs);
+  return DataProcessorSpec{
+    .name = deviceName<Det>("adaptor"),
+    .inputs = inputs,
+    .outputs = outputs,
+    .algorithm = AlgorithmSpec{adaptFromTask<adaptor::AdaptorTask<Det>>(useMC, conditions)},
+  };
+}
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_ADAPTORDEVICE_H_
diff --git a/Detectors/GenericTracking/workflow/src/AdaptorITS.cxx b/Detectors/GenericTracking/workflow/src/AdaptorITS.cxx
new file mode 100644
index 0000000000000..4dd2b5194eace
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/AdaptorITS.cxx
@@ -0,0 +1,19 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "AdaptorDevice.h"
+
+namespace o2::gtrk
+{
+
+template o2::framework::DataProcessorSpec workflow::getAdaptorSpec<detectors::ITS>(bool useMC);
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/workflow/src/AdaptorMFT.cxx b/Detectors/GenericTracking/workflow/src/AdaptorMFT.cxx
new file mode 100644
index 0000000000000..658d1bd9ae11e
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/AdaptorMFT.cxx
@@ -0,0 +1,19 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "AdaptorDevice.h"
+
+namespace o2::gtrk
+{
+
+template o2::framework::DataProcessorSpec workflow::getAdaptorSpec<detectors::MFT>(bool useMC);
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/workflow/src/ClusterConverterITSMFT.h b/Detectors/GenericTracking/workflow/src/ClusterConverterITSMFT.h
new file mode 100644
index 0000000000000..a9604105ec6a9
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/ClusterConverterITSMFT.h
@@ -0,0 +1,119 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ClusterConverterITSMFT.h
+/// \brief The cluster converter of the ITS and the MFT, one format
+///        (`o2::itsmft::CompClusterExt`, Clusters.h): ITS.cxx's and MFT.cxx's.
+
+#ifndef GTRK_WORKFLOW_CLUSTERCONVERTERITSMFT_H_
+#define GTRK_WORKFLOW_CLUSTERCONVERTERITSMFT_H_
+
+#include "GenericTracking/Alice/Clusters.h"
+#include "GenericTracking/Clustering/Cluster.h"
+#include "GenericTracking/Workflow/Conditions.h"
+#include "GenericTracking/Workflow/DataSpecs.h"
+
+#include "DataFormatsITSMFT/CompCluster.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "DataFormatsITSMFT/TopologyDictionary.h"
+#include "Framework/CCDBParamSpec.h"
+#include "Framework/ConcreteDataMatcher.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/Logger.h"
+#include "Framework/Task.h"
+#include "Framework/TimingInfo.h"
+#include "SimulationDataFormat/ConstMCTruthContainer.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+
+#include <gsl/span>
+
+#include <span>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk::workflow
+{
+
+/// O2's compact clusters of the ITS or the MFT, as the O2 cluster reader
+/// publishes them, turned into GTRK/<DET>CLUSTERS for the measurement producer
+/// and GTRK/<DET>CLUSMCTR for the MC truth. The order is O2's, so a
+/// measurement's cluster index is O2's cluster index.
+template <DetectorLayout Det>
+class ClusterConverterTask : public o2::framework::Task
+{
+ public:
+  explicit ClusterConverterTask(bool useMC) : mUseMC(useMC) {}
+
+  void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final
+  {
+    if (matcher == o2::framework::ConcreteDataMatcher(Conditions<Det>::origin(), "CLUSDICT", 0)) {
+      mDictionary = static_cast<const o2::itsmft::TopologyDictionary*>(obj);
+      LOGP(info, "{} topology dictionary from the CCDB: {} patterns", Det::name, mDictionary->getSize());
+    }
+  }
+
+  void run(o2::framework::ProcessingContext& pc) final
+  {
+    pc.inputs().get<o2::itsmft::TopologyDictionary*>("dictionary"); // delivers a new one through finaliseCCDB
+    const auto compact = pc.inputs().get<gsl::span<o2::itsmft::CompClusterExt>>("compclusters");
+    const auto patterns = pc.inputs().get<gsl::span<unsigned char>>("patterns");
+    const auto rofs = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>("rofs");
+    const auto& timing = pc.services().get<o2::framework::TimingInfo>();
+
+    std::vector<Cluster> clusters;
+    if (!rofs.empty()) {
+      const auto local = alice::localClusters(std::span{compact.data(), compact.size()}, std::span{patterns.data(), patterns.size()}, *mDictionary);
+      const std::span<const o2::itsmft::ROFRecord> frames{rofs.data(), rofs.size()};
+      clusters = alice::toClusters(local, frames, alice::readoutFrames(frames), timing.firstTForbit);
+    }
+    LOGP(info, "{}: {} clusters in {} readout frames for the timeframe at orbit {}", Det::name, clusters.size(), rofs.size(), timing.firstTForbit);
+    pc.outputs().snapshot(o2::framework::Output{gDataOrigin, description<Det>(kClusters), 0}, clusters);
+
+    if (mUseMC) {
+      const auto labels = pc.inputs().get<const o2::dataformats::MCTruthContainer<o2::MCCompLabel>*>("labels");
+      if (labels->getIndexedSize() != clusters.size() && !clusters.empty()) {
+        LOGP(fatal, "{}: {} labelled clusters for {} clusters", Det::name, labels->getIndexedSize(), clusters.size());
+      }
+      auto& flat = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(o2::framework::Output{gDataOrigin, description<Det>(kClustersMCTruth), 0});
+      labels->flatten_to(flat);
+    }
+  }
+
+ private:
+  bool mUseMC;
+  const o2::itsmft::TopologyDictionary* mDictionary = nullptr; ///< the CCDB cache's, from the run's ITS/MFT Calib/ClusterDictionary
+};
+
+/// The converter's device for the ITS or the MFT.
+template <DetectorLayout Det>
+o2::framework::DataProcessorSpec getITSMFTClusterConverterSpec(bool useMC)
+{
+  using namespace o2::framework;
+  const auto origin = Conditions<Det>::origin();
+  std::vector<InputSpec> inputs{InputSpec{"compclusters", origin, "COMPCLUSTERS", 0, Lifetime::Timeframe}, InputSpec{"patterns", origin, "PATTERNS", 0, Lifetime::Timeframe}, InputSpec{"rofs", origin, "CLUSTERSROF", 0, Lifetime::Timeframe}, InputSpec{"dictionary", origin, "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec(origin.template as<std::string>() + "/Calib/ClusterDictionary")}};
+  std::vector<OutputSpec> outputs{OutputSpec{gDataOrigin, description<Det>(kClusters), 0, Lifetime::Timeframe}};
+  if (useMC) {
+    inputs.emplace_back("labels", origin, "CLUSTERSMCTR", 0, Lifetime::Timeframe);
+    outputs.emplace_back(gDataOrigin, description<Det>(kClustersMCTruth), 0, Lifetime::Timeframe);
+  }
+  return DataProcessorSpec{
+    .name = deviceName<Det>("cluster-converter"),
+    .inputs = inputs,
+    .outputs = outputs,
+    .algorithm = AlgorithmSpec{adaptFromTask<ClusterConverterTask<Det>>(useMC)},
+    .options = Options{},
+  };
+}
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_CLUSTERCONVERTERITSMFT_H_
diff --git a/Detectors/GenericTracking/workflow/src/Clusters.cxx b/Detectors/GenericTracking/workflow/src/Clusters.cxx
new file mode 100644
index 0000000000000..427d1597afaf7
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/Clusters.cxx
@@ -0,0 +1,67 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Alice/Clusters.h"
+#include "GenericTracking/Alice/Placement.h"
+
+#include "DataFormatsITSMFT/ClusterPattern.h"
+#include "DataFormatsITSMFT/CompCluster.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "DataFormatsITSMFT/TopologyDictionary.h"
+#include "ITSMFTTracking/IOUtils.h"
+
+#include <gsl/span>
+
+#include <cstdint>
+
+namespace o2::gtrk::alice
+{
+
+std::vector<LocalCluster> localClusters(std::span<const o2::itsmft::CompClusterExt> clusters, std::span<const unsigned char> patterns, const o2::itsmft::TopologyDictionary& dictionary)
+{
+  std::vector<LocalCluster> result;
+  result.reserve(clusters.size());
+  const gsl::span<const unsigned char> stream{patterns.data(), patterns.size()};
+  auto pattern = stream.begin();
+  for (const auto& cluster : clusters) {
+    const auto read = pattern;
+    const auto decoded = o2::itsmft::ioutils::extractClusterData<float>(cluster, pattern, &dictionary);
+    LocalCluster local{
+      .chip = cluster.getSensorID(),
+      .x = decoded.coordinates.X(),
+      .z = decoded.coordinates.Z(),
+      .sigma2X = decoded.sig2Row,
+      .sigma2Z = decoded.sig2Col,
+      .nPixels = decoded.nPixels,
+    };
+    const auto spans = [&local](const o2::itsmft::ClusterPattern& patt) {
+      local.rowSpan = static_cast<std::uint8_t>(patt.getRowSpan());
+      local.colSpan = static_cast<std::uint8_t>(patt.getColumnSpan());
+    };
+    // The pattern's spans: a group's and an invalid ID's from the stream,
+    // read again where the decode read it; a common topology's from the
+    // dictionary.
+    if (pattern != read) {
+      auto again = read;
+      spans(o2::itsmft::ClusterPattern{again});
+    } else {
+      spans(dictionary.getPattern(cluster.getPatternID()));
+    }
+    result.push_back(local);
+  }
+  return result;
+}
+
+std::vector<Cluster> toClusters(std::span<const LocalCluster> local, std::span<const o2::itsmft::ROFRecord> rofs, ReadoutFrames frames, std::uint32_t tfFirstOrbit) { return detail::toClusters(local, rofs, frames, tfFirstOrbit, kActiveCentreX); }
+
+ReadoutFrames readoutFrames(std::span<const o2::itsmft::ROFRecord> rofs) { return detail::readoutFrames(rofs); }
+
+} // namespace o2::gtrk::alice
diff --git a/Detectors/GenericTracking/workflow/src/GPURecoTracking.cxx b/Detectors/GenericTracking/workflow/src/GPURecoTracking.cxx
new file mode 100644
index 0000000000000..d52520edb214e
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/GPURecoTracking.cxx
@@ -0,0 +1,37 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPURecoTracking.cxx
+
+#include "GenericTracking/Workflow/GPURecoTracking.h"
+
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Workflow/TrackerSpec.h"
+
+#include <stdexcept>
+#include <string>
+
+namespace o2::gtrk::workflow
+{
+
+std::unique_ptr<GPURecoTracking> makeGPURecoTracking(std::string_view detector)
+{
+  if (detector == "its") {
+    return makeGPURecoTrackingOf<detectors::ITS>();
+  }
+  if (detector == "mft") {
+    return makeGPURecoTrackingOf<detectors::MFT>();
+  }
+  throw std::invalid_argument("GenericTracking: no tracking inside the GPU reconstruction for " + std::string{detector});
+}
+
+} // namespace o2::gtrk::workflow
diff --git a/Detectors/GenericTracking/workflow/src/GTrkWorkflowLinkDef.h b/Detectors/GenericTracking/workflow/src/GTrkWorkflowLinkDef.h
new file mode 100644
index 0000000000000..eb37fffe8fbcd
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/GTrkWorkflowLinkDef.h
@@ -0,0 +1,29 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class o2::gtrk::RecoSettings + ;
+#pragma link C++ class o2::gtrk::RecoParam < o2::detectors::DetID::ITS> + ;
+#pragma link C++ class o2::gtrk::RecoParam < o2::detectors::DetID::MFT> + ;
+#pragma link C++ class o2::conf::ConfigurableParamPromoter < o2::gtrk::RecoParam < o2::detectors::DetID::ITS>, o2::gtrk::RecoSettings> + ;
+#pragma link C++ class o2::conf::ConfigurableParamPromoter < o2::gtrk::RecoParam < o2::detectors::DetID::MFT>, o2::gtrk::RecoSettings> + ;
+#ifdef ENABLE_UPGRADES
+#pragma link C++ class o2::gtrk::RecoParam < o2::detectors::DetID::TRK> + ;
+#pragma link C++ class o2::conf::ConfigurableParamPromoter < o2::gtrk::RecoParam < o2::detectors::DetID::TRK>, o2::gtrk::RecoSettings> + ;
+#endif
+#pragma link C++ class o2::gtrk::workflow::ClusterShapeBand + ;
+
+#endif
diff --git a/Detectors/GenericTracking/workflow/src/ITS.cxx b/Detectors/GenericTracking/workflow/src/ITS.cxx
new file mode 100644
index 0000000000000..46aad4dc52184
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/ITS.cxx
@@ -0,0 +1,46 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ITS.cxx
+/// \brief The ITS's own: its chips placed, its cluster converter and its
+///        measurement producer.
+
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Workflow/ClusterConverterSpec.h"
+#include "GenericTracking/Workflow/Conditions.h"
+#include "GenericTracking/Workflow/MeasurementProducerSpec.h"
+
+#include "ClusterConverterITSMFT.h"
+#include "MeasurementProducer.h"
+
+#include "ITSBase/GeometryTGeo.h"
+
+#include <vector>
+
+namespace o2::gtrk
+{
+
+template <>
+std::vector<Sensor> alice::placeChips<detectors::ITS>()
+{
+  return alice::placeAlpides(*o2::its::GeometryTGeo::Instance());
+}
+
+template <>
+o2::framework::DataProcessorSpec workflow::getClusterConverterSpec<detectors::ITS>(bool useMC)
+{
+  return workflow::getITSMFTClusterConverterSpec<detectors::ITS>(useMC);
+}
+
+template o2::framework::DataProcessorSpec workflow::getMeasurementProducerSpec<detectors::ITS>();
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/workflow/src/MFT.cxx b/Detectors/GenericTracking/workflow/src/MFT.cxx
new file mode 100644
index 0000000000000..70176703632a4
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/MFT.cxx
@@ -0,0 +1,46 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MFT.cxx
+/// \brief The MFT's own: its chips placed, its cluster converter and its
+///        measurement producer.
+
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Workflow/ClusterConverterSpec.h"
+#include "GenericTracking/Workflow/Conditions.h"
+#include "GenericTracking/Workflow/MeasurementProducerSpec.h"
+
+#include "ClusterConverterITSMFT.h"
+#include "MeasurementProducer.h"
+
+#include "MFTBase/GeometryTGeo.h"
+
+#include <vector>
+
+namespace o2::gtrk
+{
+
+template <>
+std::vector<Sensor> alice::placeChips<detectors::MFT>()
+{
+  return alice::placeAlpides(*o2::mft::GeometryTGeo::Instance());
+}
+
+template <>
+o2::framework::DataProcessorSpec workflow::getClusterConverterSpec<detectors::MFT>(bool useMC)
+{
+  return workflow::getITSMFTClusterConverterSpec<detectors::MFT>(useMC);
+}
+
+template o2::framework::DataProcessorSpec workflow::getMeasurementProducerSpec<detectors::MFT>();
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/workflow/src/MeasurementProducer.h b/Detectors/GenericTracking/workflow/src/MeasurementProducer.h
new file mode 100644
index 0000000000000..4984eee37382a
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/MeasurementProducer.h
@@ -0,0 +1,280 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MeasurementProducer.h
+/// \brief The measurement producer, every detector's: instantiated in the
+///        detector's own unit (ITS.cxx, MFT.cxx, TRK.cxx), where its
+///        `Conditions<Det>` is.
+
+#ifndef GTRK_WORKFLOW_MEASUREMENTPRODUCER_H_
+#define GTRK_WORKFLOW_MEASUREMENTPRODUCER_H_
+
+#include "GenericTracking/Workflow/MeasurementProducerSpec.h"
+
+#include "GenericTracking/Base/FrameTiming.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Base/TimeEstPS.h"
+#include "GenericTracking/Clustering/Cluster.h"
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/MeasurementGridBuilder.h"
+#include "GenericTracking/Workflow/DataSpecs.h"
+#include "GenericTracking/Workflow/BeamLine.h"
+#include "GenericTracking/Workflow/ClusterShapeBand.h"
+#include "GenericTracking/Workflow/Conditions.h"
+#include "GenericTracking/Workflow/GeometryProvider.h"
+#include "GenericTracking/Workflow/GridConfig.h"
+#include "GenericTracking/Workflow/RecoParam.h"
+
+#include "DataFormatsCalibration/MeanVertexObject.h"
+#include "Framework/CCDBParamSpec.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/Logger.h"
+#include "Framework/Task.h"
+
+#include <gsl/span>
+
+#include <array>
+#include <chrono>
+#include <optional>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <span>
+#include <format>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::workflow
+{
+
+/// A cluster's time box: the readout frame, as the converter wrote it from the
+/// frame's record, moved to where the frame starts by the delay and bias of
+/// \a frames, the layer's, and widened by the layer's margin, every edge
+/// rounded once from BC.
+[[nodiscard]] inline TimeEstPS measurementTimeBox(const Cluster& cluster, LayerID layer, const RecoSettings& param, const FrameTiming& frames)
+{
+  const auto margin = param.frameMarginBC.empty() ? 0 : param.frameMarginBC[layer];
+  const auto startBC = bcOfPS(cluster.timePS) + frames.firstStartBC;
+  return frameBox(startBC, startBC + bcOfPS(cluster.widthPS), margin);
+}
+
+/// Turns the cluster array into one message part per Measurement column,
+/// ordered by (layer, time block, phi cell, second cell, box start), plus the
+/// prefix offsets for those buckets.
+///
+/// Clusters arrive ordered by their readout frame. The counting sort is
+/// stable, so the box starts inside every bucket remain ordered without
+/// another sort. The
+/// geometry transform runs once per cluster, from its sensor ID and local
+/// position: the float global position, with its transverse radius, azimuth
+/// and projected variances, is kept beside the bucket number until the scatter
+/// pass writes both out. It also ships the grid's layout and the beam line it
+/// was derived from (`MeasurementGeometry`, GTRK/<DET>MEASGEO), and subtracts
+/// the beam line from every measurement's x and y.
+template <DetectorLayout Det>
+class MeasurementProducerTask : public o2::framework::Task
+{
+ public:
+  MeasurementProducerTask(std::shared_ptr<Conditions<Det>> conditions, bool testsShapes) : mConditions(std::move(conditions)), mTestsShapes(testsShapes) {}
+
+  void init(o2::framework::InitContext& ic) final
+  {
+    checkRecoParam<Det>(recoParam<Det>());
+    mConditions->init(ic);
+  }
+
+  void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final
+  {
+    if (matcher == o2::framework::ConcreteDataMatcher(Conditions<Det>::origin(), "SHAPEBAND", 0)) {
+      mShapeBand = static_cast<const ClusterShapeBand*>(obj);
+      if (!mShapeBand->fits(static_cast<std::size_t>(Detector<Det>::nBarrelLayers))) {
+        throw std::runtime_error(std::format("{}'s cluster-shape band from the CCDB is not one of its {} barrel layers", Det::name, Detector<Det>::nBarrelLayers));
+      }
+      LOGP(info, "{}'s {} from the CCDB", Det::name, mShapeBand->describe());
+      return;
+    }
+    mConditions->finaliseCCDB(matcher, obj);
+  }
+
+  void run(o2::framework::ProcessingContext& pc) final
+  {
+    // The run's conditions: the geometry a placed layout is placed from, and
+    // the field the grid's cells come from through the windows.
+    mConditions->checkUpdates(pc);
+    if (mTestsShapes) {
+      pc.inputs().get<ClusterShapeBand*>("shapeBand"); // delivers a new one through finaliseCCDB
+    }
+    if (!mGeometry) {
+      mGeometry = makeGeometry<Det>(mConditions->measurementDepthsCM());
+      mFrames = mConditions->frameTiming();
+    }
+    // The timeframe's beam line, its MeanVertex's where the detector has one,
+    // and the grid's layout, derived from the configuration and it: rebuilt
+    // when it changes, whatever order the timeframes come in.
+    auto beamLine = nominalBeamLine();
+    if constexpr (Conditions<Det>::kMeanVertex) {
+      beamLine = beamLineOf(*pc.inputs().get<o2::dataformats::MeanVertexObject*>("meanVertex"));
+    }
+    if (!mGrid || beamLine != mBeamLine) {
+      mBeamLine = beamLine;
+      LOGP(info, "the beam line, subtracted from every measurement's x and y: {}", describe(mBeamLine));
+      mGrid.emplace(makeGridGeometry<Det>(recoParam<Det>(), mBeamLine, mFrames, mConditions->orbitsPerTimeframe()));
+      std::string cells;
+      std::string frames;
+      for (std::size_t layer = 0; layer < GridGeometry<Det>::kLayerCount; ++layer) {
+        const auto& axes = mGrid->axes(static_cast<LayerID>(layer));
+        cells += std::format("{}{}x{}", layer == 0U ? "" : " ", axes.nPhi, axes.nSecond);
+        frames += std::format("{}{}@{}", layer == 0U ? "" : " ", mFrames[layer].lengthBC, mFrames[layer].firstStartBC);
+      }
+      LOGP(info,
+           "the grid, derived from the iterations: {} blocks of {} from {} in {} parts of a ps (frames of length@first start in BC by layer: {}); "
+           "phi x second cells by layer: {}; {} buckets",
+           mGrid->blockCount(), mGrid->blockWidth(), mGrid->blockOrigin(), mGrid->partsPerPS(), frames, cells, mGrid->bucketCount());
+    }
+    const auto clusters = pc.inputs().get<gsl::span<Cluster>>("clusters");
+    const auto n = clusters.size();
+    if (n > std::numeric_limits<std::uint32_t>::max()) {
+      LOGP(fatal, "{} measurements exceed the uint32 row-index range", n);
+      return;
+    }
+    for (const auto& cluster : clusters) {
+      if (cluster.chipID >= static_cast<SensorID>(Det::nSensors)) {
+        LOGP(fatal, "chip {} is outside {}", cluster.chipID, Det::name);
+        return;
+      }
+    }
+
+    const auto& param = recoParam<Det>();
+    const auto& grid = *mGrid;
+    pc.outputs().snapshot(o2::framework::Output{gDataOrigin, description<Det>(kMeasurementGeometry), 0}, MeasurementGeometry<Det>{mBeamLine, grid});
+    const auto systematic2 = static_cast<Scalar>(param.clusterSystematicSigmaCM * param.clusterSystematicSigmaCM);
+    const auto localVariance = [systematic2](float sigma) { return (sigma * sigma) + systematic2; };
+    const auto start = std::chrono::steady_clock::now();
+
+    auto offsets = pc.outputs().make<std::uint32_t>(o2::framework::Output{gDataOrigin, description<Det>(kMeasurements), kColGridOffsets}, static_cast<std::size_t>(grid.bucketCount()) + 1U);
+    MeasurementGridBuilder builder{std::span<std::uint32_t>{offsets.data(), offsets.size()}};
+
+    std::vector<std::uint32_t> buckets(n);
+    std::vector<TimeEstPS> boxes(n);
+    std::vector<std::array<Scalar, 8>> positions(n); // x, y, z, r, phi, varZ, varR, varRPhi
+    // The slope intervals only with a band: without one every measurement takes kEvery.
+    const auto* band = mShapeBand;
+    std::vector<ClusterShapeBand::Interval> slopes(band != nullptr ? n : 0U);
+    for (std::size_t i = 0; i < n; ++i) {
+      const auto& cluster = clusters[i];
+      const auto point = gridPoint<Det>(*mGeometry, cluster.chipID, static_cast<double>(cluster.xLocal), static_cast<double>(cluster.yLocal), mBeamLine.x, mBeamLine.y);
+      const auto variances = pointVariances<Det>(*mGeometry, cluster.chipID, static_cast<double>(cluster.xLocal), point, localVariance(cluster.sigmaXLocal), 0.F, localVariance(cluster.sigmaYLocal));
+      // Every frame's record where its layer's frames have theirs, every
+      // lengthBC from BC 0: the boxes, the blocks and the slices' reach follow them.
+      const auto& frames = mFrames[point.layer];
+      if (bcOfPS(cluster.timePS) % frames.lengthBC != 0 || bcOfPS(cluster.widthPS) != frames.lengthBC) {
+        LOGP(fatal, "a {} cluster's readout frame record [{}, {}) ps on layer {} is not one of the layer's frames of {} BC", Det::name, cluster.timePS, static_cast<std::int64_t>(cluster.timePS) + cluster.widthPS, point.layer, frames.lengthBC);
+        return;
+      }
+      boxes[i] = measurementTimeBox(cluster, point.layer, param, frames);
+      buckets[i] = grid.bucketAt(point.layer, boxes[i].start, point.phi, point.second);
+      positions[i] = {point.x, point.y, point.z, point.r, point.phi, variances.z, variances.r, variances.rPhi};
+      if (band != nullptr) {
+        slopes[i] = band->interval(static_cast<std::size_t>(point.layer), cluster.rowSpan, cluster.colSpan);
+      }
+      builder.count(buckets[i]);
+    }
+    builder.prefixSum();
+
+    auto columns = makeMeasurementColumns<gsl::span>([&]<class T>(std::type_identity<T>, MeasurementColumn column) { return pc.outputs().make<T>(o2::framework::Output{gDataOrigin, description<Det>(kMeasurements), static_cast<std::uint32_t>(column)}, n); });
+
+    for (std::size_t i = 0; i < n; ++i) {
+      const auto& cluster = clusters[i];
+      const auto at = builder.place(buckets[i]);
+      const auto slope = band != nullptr ? slopes[i] : ClusterShapeBand::kEvery;
+      writeMeasurement(columns, at,
+                       Measurement{
+                         .loc0 = cluster.xLocal,
+                         .loc1 = cluster.yLocal,
+                         .timePS = boxes[i].start,
+                         .widthPS = boxes[i].width,
+                         .varLoc0 = localVariance(cluster.sigmaXLocal),
+                         .covLoc01 = 0.F,
+                         .varLoc1 = localVariance(cluster.sigmaYLocal),
+                         .clusterIndex = static_cast<std::uint32_t>(i),
+                         .surface = cluster.chipID,
+                         .x = positions[i][0],
+                         .y = positions[i][1],
+                         .z = positions[i][2],
+                         .r = positions[i][3],
+                         .phi = positions[i][4],
+                         .varZ = positions[i][5],
+                         .varR = positions[i][6],
+                         .varRPhi = positions[i][7],
+                         .slopeLow = slope.first,
+                         .slopeHigh = slope.second,
+                       });
+    }
+    builder.finish();
+
+    const std::chrono::duration<double> elapsed = std::chrono::steady_clock::now() - start;
+    const auto payloadBytes = n * kMeasurementRowBytes + offsets.size() * sizeof(std::uint32_t);
+    LOGP(info,
+         "{} measurements in {} blocks and {} buckets over {} layers, {} columns, "
+         "{} MB, {:.3f} s, about the beam line {}",
+         n, grid.blockCount(), grid.bucketCount(), Detector<Det>::nLayers, kNMeasurementColumns, payloadBytes / 1000000U, elapsed.count(), describe(mBeamLine));
+  }
+
+ private:
+  std::unique_ptr<const Geometry<Det>> mGeometry; ///< placed on the first timeframe, once the conditions are in
+  BeamLine mBeamLine;                             ///< the last timeframe's
+  std::optional<GridGeometry<Det>> mGrid;         ///< the grid's layout, derived from the configuration and mBeamLine
+  std::vector<FrameTiming> mFrames;               ///< each layer's readout frames, from the conditions
+  std::shared_ptr<Conditions<Det>> mConditions;   ///< the run's field, geometry and frames (Conditions.h)
+  bool mTestsShapes = false;                      ///< whether a pass tests the cluster shapes, which takes the detector's band
+  const ClusterShapeBand* mShapeBand = nullptr;   ///< the CCDB cache's, with a pass that tests the shapes
+};
+
+template <DetectorLayout Det>
+o2::framework::DataProcessorSpec getMeasurementProducerSpec()
+{
+  using namespace o2::framework;
+  std::vector<OutputSpec> outputs;
+  outputs.reserve(kNMeasurementParts);
+  for (std::uint32_t part = 0; part < kNMeasurementParts; ++part) {
+    outputs.emplace_back(gDataOrigin, description<Det>(kMeasurements), part, Lifetime::Timeframe);
+  }
+  outputs.emplace_back(gDataOrigin, description<Det>(kMeasurementGeometry), 0, Lifetime::Timeframe);
+  static_assert(std::is_trivially_copyable_v<MeasurementGeometry<Det>>, "shipped as it is");
+
+  std::vector<InputSpec> inputs{InputSpec{"clusters", gDataOrigin, description<Det>(kClusters), 0, Lifetime::Timeframe}};
+  auto conditions = std::make_shared<Conditions<Det>>(inputs);
+  if constexpr (Conditions<Det>::kMeanVertex) {
+    inputs.emplace_back("meanVertex", "GLO", "MEANVERTEX", 0, Lifetime::Condition, ccdbParamSpec("GLO/Calib/MeanVertex", {}, 1));
+  }
+  // A pass testing the shapes takes the detector's band.
+  const bool shapes = testsShapes(recoParam<Det>());
+  if (shapes) {
+    const auto origin = Conditions<Det>::origin();
+    inputs.emplace_back("shapeBand", origin, "SHAPEBAND", 0, Lifetime::Condition, ccdbParamSpec(origin.template as<std::string>() + "/Calib/ClusterShapeBand"));
+  }
+
+  return DataProcessorSpec{
+    .name = deviceName<Det>("measurement-producer"),
+    .inputs = inputs,
+    .outputs = outputs,
+    .algorithm = AlgorithmSpec{adaptFromTask<MeasurementProducerTask<Det>>(conditions, shapes)},
+    .options = Options{},
+  };
+}
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_MEASUREMENTPRODUCER_H_
diff --git a/Detectors/GenericTracking/workflow/src/Placement.cxx b/Detectors/GenericTracking/workflow/src/Placement.cxx
new file mode 100644
index 0000000000000..514ad91ecaac5
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/Placement.cxx
@@ -0,0 +1,83 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Alice/Placement.h"
+
+#include "GenericTracking/Detectors/Alpide.h"
+
+#include "ITSMFTBase/SegmentationAlpide.h"
+
+namespace o2::gtrk::alice
+{
+
+namespace
+{
+
+using Segmentation = o2::itsmft::SegmentationAlpide;
+
+// Alpide.h restates O2's numbers so that the layouts need no O2 detector
+// library; this is where they are held to them.
+static_assert(detectors::alpide::kRows == Segmentation::NRows);
+static_assert(detectors::alpide::kColumns == Segmentation::NCols);
+static_assert(exactlyEqual(static_cast<float>(detectors::alpide::kPitchRow), Segmentation::PitchRow));
+static_assert(exactlyEqual(static_cast<float>(detectors::alpide::kPitchColumn), Segmentation::PitchCol));
+static_assert(exactlyEqual(static_cast<float>(detectors::alpide::kEffectiveThickness), Segmentation::SensorLayerThicknessEff));
+
+/// The rotation and translation of one L2G matrix.
+struct Matrix {
+  double m[3][3];
+  double t[3];
+};
+
+Matrix componentsOf(const o2::math_utils::Transform3D& l2g)
+{
+  Matrix matrix{};
+  auto& m = matrix.m;
+  auto& t = matrix.t;
+  l2g.GetComponents(m[0][0], m[0][1], m[0][2], t[0], m[1][0], m[1][1], m[1][2], t[1], m[2][0], m[2][1], m[2][2], t[2]);
+  return matrix;
+}
+
+} // namespace
+
+const double kActiveCentreX = 0.5 * (static_cast<double>(Segmentation::PassiveEdgeReadOut) - static_cast<double>(Segmentation::PassiveEdgeTop));
+
+Sensor flatSensor(const o2::math_utils::Transform3D& l2g, int layer, double activeCentreX)
+{
+  const auto [m, t] = componentsOf(l2g);
+  Sensor sensor{};
+  for (int i = 0; i < 3; ++i) {
+    // Row-major local -> global, so column j is the global direction of our
+    // local axis j.
+    sensor.rot[(3 * i) + 0] = m[i][0];
+    sensor.rot[(3 * i) + 1] = m[i][2];
+    sensor.rot[(3 * i) + 2] = -m[i][1];
+    sensor.trans[i] = t[i] + (activeCentreX * m[i][0]);
+  }
+  sensor.layer = static_cast<LayerID>(layer);
+  return sensor;
+}
+
+Sensor curvedSensor(const o2::math_utils::Transform3D& l2g, int layer)
+{
+  const auto [m, t] = componentsOf(l2g);
+  Sensor sensor{};
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      sensor.rot[(3 * i) + j] = m[i][j];
+    }
+    sensor.trans[i] = t[i];
+  }
+  sensor.layer = static_cast<LayerID>(layer);
+  return sensor;
+}
+
+} // namespace o2::gtrk::alice
diff --git a/Detectors/GenericTracking/workflow/src/RecoParam.cxx b/Detectors/GenericTracking/workflow/src/RecoParam.cxx
new file mode 100644
index 0000000000000..c4e9c426c0da5
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/RecoParam.cxx
@@ -0,0 +1,23 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GenericTracking/Workflow/RecoParam.h"
+
+namespace o2::gtrk
+{
+// Each detector's instance, touched here so that it is in the parameter
+// database and --configKeyValues finds its keys.
+static auto& sRecoParamITS = RecoParam<o2::detectors::DetID::ITS>::Instance();
+static auto& sRecoParamMFT = RecoParam<o2::detectors::DetID::MFT>::Instance();
+#ifdef ENABLE_UPGRADES
+static auto& sRecoParamTRK = RecoParam<o2::detectors::DetID::TRK>::Instance();
+#endif
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/workflow/src/RecoWorkflow.h b/Detectors/GenericTracking/workflow/src/RecoWorkflow.h
new file mode 100644
index 0000000000000..78edc26f25a51
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/RecoWorkflow.h
@@ -0,0 +1,96 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file RecoWorkflow.h
+/// \brief What the detectors' reco workflows share (o2-gtrk-its-, -mft- and
+///        -trk-reco-workflow): their options and the tracking chain.
+
+#ifndef GTRK_WORKFLOW_RECOWORKFLOW_H_
+#define GTRK_WORKFLOW_RECOWORKFLOW_H_
+
+#include "GenericTracking/Workflow/ClusterConverterSpec.h"
+#include "GenericTracking/Workflow/MeasurementProducerSpec.h"
+#include "GenericTracking/Workflow/TrackerSpec.h"
+
+#include "DetectorsRaw/HBFUtilsInitializer.h"
+#include "Framework/ConfigContext.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/WorkflowSpec.h"
+
+#include <stdexcept>
+#include <vector>
+
+namespace o2::gtrk::workflow
+{
+
+/// Every reco workflow's options; with \a o2Format the adaptor's too
+/// (`--disable-adaptor`, `--disable-root-output`), for a detector with O2 track formats,
+/// and the two halves of a tracking inside o2-gpu-reco-workflow: `--tracking-in-gpu-reco`
+/// before it in the pipe, `--adaptor-only` after it.
+inline void addRecoOptions(std::vector<o2::framework::ConfigParamSpec>& options, bool o2Format)
+{
+  using o2::framework::ConfigParamSpec;
+  using o2::framework::VariantType;
+  options.push_back(ConfigParamSpec{"disable-mc", VariantType::Bool, false, {"do not propagate MC labels"}});
+  options.push_back(ConfigParamSpec{"configKeyValues", VariantType::String, "", {"semicolon separated key=value strings"}});
+  options.push_back(ConfigParamSpec{"clusters-from-upstream", VariantType::Bool, false, {"the clusters from the workflow before this one in the pipe, not O2's readers"}});
+  options.push_back(ConfigParamSpec{"vertices-from-upstream", VariantType::Bool, false, {"the native vertex seeds (GTRK/<DET>VERTICES) from the workflow before this one in the pipe"}});
+  if (o2Format) {
+    options.push_back(ConfigParamSpec{"disable-adaptor", VariantType::Bool, false, {"only the native tracks and vertices (GTRK/<DET>...), not O2's formats nor their files"}});
+    options.push_back(ConfigParamSpec{"disable-root-output", VariantType::Bool, false, {"O2's formats without O2's writers"}});
+    options.push_back(ConfigParamSpec{"tracking-in-gpu-reco",
+                                      VariantType::Bool,
+                                      false,
+                                      {"the tracking runs inside o2-gpu-reco-workflow (--output-type gtrk-<det>-tracks), on the TPC's GPU: only the converter and "
+                                       "the producer, before it in the pipe; the adaptor after it (--adaptor-only)"}});
+    options.push_back(ConfigParamSpec{"adaptor-only", VariantType::Bool, false, {"only the adaptor (and O2's writers), after o2-gpu-reco-workflow in the pipe: its tracks, the measurements and clusters from upstream"}});
+  }
+  o2::raw::HBFUtilsInitializer::addConfigOption(options, o2::raw::HBFUtilsInitializer::HBFUSrc);
+}
+
+/// Whether the tracking runs inside o2-gpu-reco-workflow, this workflow
+/// before it (`--tracking-in-gpu-reco`), or this is the adaptor after it
+/// (`--adaptor-only`). False for a detector without the options.
+[[nodiscard]] inline bool trackingInGPUReco(const o2::framework::ConfigContext& context) { return context.options().hasOption("tracking-in-gpu-reco") && context.options().get<bool>("tracking-in-gpu-reco"); }
+[[nodiscard]] inline bool adaptorOnly(const o2::framework::ConfigContext& context) { return context.options().hasOption("adaptor-only") && context.options().get<bool>("adaptor-only"); }
+
+/// Detector \a Det's tracking: its \a readers (unless `--clusters-from-upstream`),
+/// the converter into our clusters, the measurement producer and the tracker
+/// (unless `--tracking-in-gpu-reco`); nothing with `--adaptor-only`.
+template <DetectorLayout Det>
+[[nodiscard]] o2::framework::WorkflowSpec trackingChain(const o2::framework::ConfigContext& context, const o2::framework::WorkflowSpec& readers)
+{
+  const bool useMC = !context.options().get<bool>("disable-mc");
+  o2::framework::WorkflowSpec specs;
+  if (adaptorOnly(context)) {
+    if (trackingInGPUReco(context)) {
+      throw std::invalid_argument("--tracking-in-gpu-reco and --adaptor-only are the two halves of one tracking: one per workflow");
+    }
+    return specs;
+  }
+  if (!context.options().get<bool>("clusters-from-upstream")) {
+    specs.insert(specs.end(), readers.begin(), readers.end());
+  }
+  specs.push_back(getClusterConverterSpec<Det>(useMC));
+  specs.push_back(getMeasurementProducerSpec<Det>());
+  const bool inGPUReco = trackingInGPUReco(context);
+  if (inGPUReco && context.options().get<bool>("vertices-from-upstream")) {
+    throw std::invalid_argument("--tracking-in-gpu-reco takes no native vertex seeds (--vertices-from-upstream)");
+  }
+  if (!inGPUReco) {
+    specs.push_back(getTrackerSpec<Det>(context.options().get<bool>("vertices-from-upstream")));
+  }
+  return specs;
+}
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_RECOWORKFLOW_H_
diff --git a/Detectors/GenericTracking/workflow/src/TRK.cxx b/Detectors/GenericTracking/workflow/src/TRK.cxx
new file mode 100644
index 0000000000000..a6aeb78294e95
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/TRK.cxx
@@ -0,0 +1,337 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TRK.cxx
+/// \brief ALICE 3's own, TRK's barrel and FT3's discs: its chips placed, its
+///        cluster format, its dictionaries' depths, frames and field (TRK.h),
+///        its cluster converter and its measurement producer.
+
+#include "GenericTracking/Alice/Clusters.h"
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Alice/TRK.h"
+#include "GenericTracking/Base/LayerSpec.h"
+#include "GenericTracking/Clustering/Cluster.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Workflow/ClusterConverterSpec.h"
+#include "GenericTracking/Workflow/ConditionsTRK.h"
+#include "GenericTracking/Workflow/DataSpecs.h"
+#include "GenericTracking/Workflow/MeasurementProducerSpec.h"
+
+#include "MeasurementProducer.h"
+
+#include "DataFormatsTRKFT3/Cluster.h"
+#include "DataFormatsTRKFT3/ROFRecord.h"
+#include "DetectorsRaw/HBFUtils.h"
+#include "FT3Base/GeometryTGeo.h"
+#include "Field/ALICE3MagneticField.h"
+#include "Framework/ConcreteDataMatcher.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/Logger.h"
+#include "Framework/Task.h"
+#include "Framework/TimingInfo.h"
+#include "MathUtils/Cartesian.h"
+#include "MathUtils/Utils.h"
+#include "SimulationDataFormat/ConstMCTruthContainer.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+#include "TRKBase/AlmiraParam.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "TRKBase/Specs.h"
+#include "TRKReconstruction/TopologyDictionary.h"
+
+#include <gsl/span>
+
+#include <algorithm>
+#include <bit>
+#include <cstdint>
+#include <cstdlib>
+#include <filesystem>
+#include <format>
+#include <initializer_list>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk::alice
+{
+
+namespace
+{
+
+// TRKFT3.h restates O2's TRK sensors; here they are held to O2's, to the bit.
+namespace specs = o2::trk::constants;
+static_assert(detectors::trkft3::kVDRadius == specs::VD::petal::layer::radii);
+static_assert(detectors::trkft3::kVDPetalGap == specs::VD::petal::layer::gaps);
+static_assert(exactlyEqual(detectors::trkft3::vdWidth(0), specs::VD::petal::layer::width[0]));
+static_assert(exactlyEqual(detectors::trkft3::vdWidth(1), specs::VD::petal::layer::width[1]));
+static_assert(exactlyEqual(detectors::trkft3::vdWidth(2), specs::VD::petal::layer::width[2]));
+static_assert(exactlyEqual(detectors::trkft3::kVDLength, specs::VD::petal::layer::length));
+static_assert(exactlyEqual(detectors::trkft3::kVDThickness, specs::VD::silicon::thickness));
+static_assert(exactlyEqual(detectors::trkft3::kVDPitch, specs::VD::petal::layer::pitchX) && exactlyEqual(detectors::trkft3::kVDPitch, specs::VD::petal::layer::pitchZ));
+static_assert(exactlyEqual(detectors::trkft3::kChipWidth, specs::moduleMLOT::chip::width));
+static_assert(exactlyEqual(detectors::trkft3::kChipPassiveEdgeReadOut, specs::moduleMLOT::chip::passiveEdgeReadOut));
+static_assert(exactlyEqual(detectors::trkft3::kChipLength, specs::moduleMLOT::chip::length));
+static_assert(exactlyEqual(detectors::trkft3::kChipThickness, specs::moduleMLOT::silicon::thickness));
+static_assert(exactlyEqual(detectors::trkft3::kChipPitch, specs::moduleMLOT::chip::pitchX) && exactlyEqual(detectors::trkft3::kChipPitch, specs::moduleMLOT::chip::pitchZ));
+
+} // namespace
+
+template <>
+std::vector<Sensor> placeChips<detectors::TRKFT3>()
+{
+  // The VD's curved sensors (sub-detector 0) and the ML/OT chips, whose
+  // sensor volume is the active matrix, so their origin needs no shift; then
+  // FT3's chips, the same chip with the same volume, their layers after the
+  // barrel's.
+  auto& trk = *o2::trk::GeometryTGeo::Instance();
+  auto& ft3 = *o2::ft3::GeometryTGeo::Instance();
+  trk.fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+  ft3.fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+  std::vector<Sensor> sensors;
+  sensors.reserve(static_cast<std::size_t>(trk.getNumberOfChips()) + static_cast<std::size_t>(ft3.getNumberOfChips()));
+  for (int chip = 0; chip < trk.getNumberOfChips(); ++chip) {
+    const auto& l2g = trk.getMatrixL2G(chip);
+    const int layer = trk.getLayerTRK(chip);
+    sensors.push_back(trk.getSubDetID(chip) == 0 ? curvedSensor(l2g, layer) : flatSensor(l2g, layer, 0.));
+  }
+  const int firstDiscLayer = Detector<detectors::TRKFT3>::nBarrelLayers;
+  for (int chip = 0; chip < ft3.getNumberOfChips(); ++chip) {
+    sensors.push_back(flatSensor(ft3.getMatrixL2G(chip), firstDiscLayer + ft3.getLayer(chip), 0.));
+  }
+  return sensors;
+}
+
+namespace
+{
+
+/// The local clusters of TRK's or FT3's \a clusters, each chip numbered
+/// \a firstSensor plus O2's chip ID; \a subDetectors, the sub-detectors their
+/// clusters may name (a cluster naming another is refused).
+template <typename ClusterType, typename Dictionary>
+std::vector<LocalCluster> alice3LocalClusters(std::span<const ClusterType> clusters, std::span<const unsigned char> patterns, const Dictionary& dictionary, std::uint32_t firstSensor, std::initializer_list<int> subDetectors)
+{
+  std::vector<LocalCluster> result;
+  result.reserve(clusters.size());
+  std::size_t offset = 0;
+  for (const auto& cluster : clusters) {
+    if (std::ranges::find(subDetectors, static_cast<int>(cluster.subDetID)) == subDetectors.end()) {
+      throw std::runtime_error(std::format("a cluster on chip {} names sub-detector {}", cluster.chipID, cluster.subDetID));
+    }
+    // The pattern: its row span, its column span, then its pixels' bits row
+    // by row, the first pixel in the highest bit (O2's Clusterer<TRK>).
+    if (offset + 2U > patterns.size()) {
+      throw std::runtime_error("TRK cluster patterns ran out");
+    }
+    const auto* pattern = patterns.data() + offset;
+    const auto rowSpan = pattern[0];
+    const auto colSpan = pattern[1];
+    const auto bytes = 2U + ((static_cast<std::size_t>(rowSpan) * colSpan + 7U) / 8U);
+    if (offset + bytes > patterns.size()) {
+      throw std::runtime_error("TRK cluster patterns ran out");
+    }
+    offset += bytes;
+    int fired = 0;
+    for (std::size_t byte = 2; byte < bytes; ++byte) {
+      fired += std::popcount(pattern[byte]);
+    }
+    LocalCluster local{.chip = firstSensor + cluster.chipID, .nPixels = static_cast<std::uint32_t>(fired), .rowSpan = rowSpan, .colSpan = colSpan};
+    const int layer = Dictionary::layerOf(cluster);
+    if (layer < 0 || layer >= dictionary.getNumberOfLayers()) {
+      throw std::runtime_error(std::format("a cluster on chip {} is on no layer of the topology dictionary", cluster.chipID));
+    }
+    const int id = dictionary.findID(layer, pattern);
+    const auto position = dictionary.getFlatCoordinates(cluster, pattern, id);
+    const auto& entry = dictionary.getEntry(layer, id);
+    local.x = position.X();
+    local.z = position.Z();
+    local.sigma2X = entry.xWidth * entry.xWidth;
+    local.sigma2Z = entry.zWidth * entry.zWidth;
+    result.push_back(local);
+  }
+  if (offset != patterns.size()) {
+    throw std::runtime_error(std::format("{} bytes of TRK cluster patterns left over", patterns.size() - offset));
+  }
+  return result;
+}
+
+} // namespace
+
+std::vector<LocalCluster> trkLocalClusters(std::span<const o2::trkft3::TRKCluster> clusters, std::span<const unsigned char> patterns, const TrkDictionary& dictionary) { return alice3LocalClusters(clusters, patterns, dictionary, 0U, {0, 1}); }
+
+std::vector<LocalCluster> ft3LocalClusters(std::span<const o2::trkft3::FT3Cluster> clusters, std::span<const unsigned char> patterns, const Ft3Dictionary& dictionary) { return alice3LocalClusters(clusters, patterns, dictionary, static_cast<std::uint32_t>(detectors::TRKFT3::kFirstDiscSensor), {2}); }
+
+std::vector<Cluster> toClusters(std::span<const LocalCluster> local, std::span<const o2::trkft3::ROFRecord> rofs, ReadoutFrames frames, std::uint32_t tfFirstOrbit)
+{
+  // The TRK's sensor volume is its active matrix: our origin is O2's (TRK.cxx's placeChips).
+  return detail::toClusters(local, rofs, frames, tfFirstOrbit, 0.);
+}
+
+ReadoutFrames readoutFrames(std::span<const o2::trkft3::ROFRecord> rofs) { return detail::readoutFrames(rofs); }
+
+std::vector<double> measurementDepthsCM(const TrkDictionary& trk, const Ft3Dictionary& ft3)
+{
+  std::vector<double> depths;
+  depths.reserve(static_cast<std::size_t>(trk.getNumberOfLayers()) + static_cast<std::size_t>(ft3.getNumberOfLayers()));
+  for (int layer = 0; layer < trk.getNumberOfLayers(); ++layer) {
+    depths.push_back(-static_cast<double>(trk.getLayer(layer).depth));
+  }
+  for (int layer = 0; layer < ft3.getNumberOfLayers(); ++layer) {
+    depths.push_back(-static_cast<double>(ft3.getLayer(layer).depth));
+  }
+  return depths;
+}
+
+std::vector<FrameTiming> trkFrameTiming()
+{
+  const auto& param = o2::trk::AlmiraParam::Instance();
+  constexpr int kLayers = Detector<detectors::TRKFT3>::nLayers;
+  // Our layers are the parameter's entries: TRK's barrel layers, then FT3's
+  // discs, which take entries 11-22.
+  static_assert(kLayers == static_cast<int>(o2::trk::AlmiraParam::kNLayers));
+  std::vector<FrameTiming> frames;
+  frames.reserve(kLayers);
+  for (int layer = 0; layer < kLayers; ++layer) {
+    frames.push_back({.lengthBC = param.getROFLengthInBC(layer), .firstStartBC = param.getROFBiasInBC(layer) + param.getROFDelayInBC(layer)});
+  }
+  return frames;
+}
+
+double alice3BzKiloGauss()
+{
+  const char* macro = std::getenv("ALICE3_MAGFIELD_MACRO");
+  if (macro == nullptr || !std::filesystem::exists(macro)) {
+    throw std::runtime_error(std::string{"ALICE3_MAGFIELD_MACRO names no file ("} + (macro == nullptr ? "unset" : macro) + "): the ALICE 3 field is unknown, and O2 would take a toy one");
+  }
+  o2::field::ALICE3MagneticField field;
+  const double origin[3] = {0., 0., 0.};
+  double b[3] = {0., 0., 0.};
+  field.Field(origin, b);
+  return b[2];
+}
+
+} // namespace o2::gtrk::alice
+
+namespace o2::gtrk::workflow
+{
+
+using namespace o2::framework;
+
+namespace
+{
+
+/// ALICE 3's TRK and FT3 clusters, one stream per barrel layer and one per
+/// disc as O2's cluster readers publish them (TRK/COMPCLUSTERS/<layer>,
+/// FT3/COMPCLUSTERS/<disc> and the rest), turned into GTRK/TRKCLUSTERS and
+/// GTRK/TRKCLUSMCTR: each layer's
+/// stream converted with its own readout frames, each cluster with its
+/// position and errors from the topology dictionaries, CCDB conditions,
+/// then the layers
+/// concatenated in order, barrel first, so a measurement's cluster index is
+/// its position in that concatenation and the labels follow it.
+class TrkClusterConverterTask : public Task
+{
+ public:
+  static constexpr int kLayers = Detector<detectors::TRKFT3>::nLayers;
+  static constexpr int kBarrelLayers = Detector<detectors::TRKFT3>::nBarrelLayers;
+
+  /// Our layer \a layer's stream: TRK's barrel layer, or FT3's disc after them.
+  [[nodiscard]] static o2::header::DataOrigin originOf(int layer) { return layer < kBarrelLayers ? o2::header::DataOrigin{"TRK"} : o2::header::DataOrigin{"FT3"}; }
+  [[nodiscard]] static o2::header::DataHeader::SubSpecificationType subspecOf(int layer) { return static_cast<o2::header::DataHeader::SubSpecificationType>(layer < kBarrelLayers ? layer : layer - kBarrelLayers); }
+
+  TrkClusterConverterTask(bool useMC, TrkDictionaryConditions dictionaries) : mUseMC(useMC), mDictionaries(dictionaries) {}
+
+  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final { mDictionaries.finaliseCCDB(matcher, obj); }
+
+  void run(ProcessingContext& pc) final
+  {
+    TrkDictionaryConditions::checkUpdates(pc);
+    const auto& timing = pc.services().get<o2::framework::TimingInfo>();
+    std::vector<Cluster> clusters;
+    o2::dataformats::MCTruthContainer<o2::MCCompLabel> labels;
+    for (int layer = 0; layer < kLayers; ++layer) {
+      const auto patterns = pc.inputs().get<gsl::span<unsigned char>>(std::format("patterns_{}", layer));
+      const auto rofs = pc.inputs().get<gsl::span<o2::trkft3::ROFRecord>>(std::format("rofs_{}", layer));
+      if (rofs.empty()) {
+        continue;
+      }
+      // The timeframe's first orbit as DPL announces it, held to the one the
+      // frames imply, as for the ITS.
+      const auto implied = o2::raw::HBFUtils::Instance().getFirstIRofTF(rofs.front().getBCData()).orbit;
+      if (implied != timing.firstTForbit) {
+        LOGP(fatal, "TRKFT3 layer {}: the readout frames belong to the timeframe starting at orbit {}, DPL says {}", layer, implied, timing.firstTForbit);
+      }
+      const std::span<const unsigned char> patternBytes{patterns.data(), patterns.size()};
+      const auto local = [&]() {
+        if (layer < kBarrelLayers) {
+          const auto compact = pc.inputs().get<gsl::span<o2::trkft3::TRKCluster>>(std::format("compclusters_{}", layer));
+          return alice::trkLocalClusters(std::span{compact.data(), compact.size()}, patternBytes, *mDictionaries.trk());
+        }
+        const auto compact = pc.inputs().get<gsl::span<o2::trkft3::FT3Cluster>>(std::format("compclusters_{}", layer));
+        return alice::ft3LocalClusters(std::span{compact.data(), compact.size()}, patternBytes, *mDictionaries.ft3());
+      }();
+      const std::span<const o2::trkft3::ROFRecord> frames{rofs.data(), rofs.size()};
+      const auto converted = alice::toClusters(local, frames, alice::readoutFrames(frames), timing.firstTForbit);
+      clusters.insert(clusters.end(), converted.begin(), converted.end());
+      if (mUseMC) {
+        const auto layerLabels = pc.inputs().get<const o2::dataformats::MCTruthContainer<o2::MCCompLabel>*>(std::format("labels_{}", layer));
+        if (layerLabels->getIndexedSize() != converted.size()) {
+          LOGP(fatal, "TRKFT3 layer {}: {} labelled clusters for {} clusters", layer, layerLabels->getIndexedSize(), converted.size());
+        }
+        labels.mergeAtBack(*layerLabels);
+      }
+    }
+    LOGP(info, "TRKFT3: {} clusters on {} layers for the timeframe at orbit {}", clusters.size(), kLayers, timing.firstTForbit);
+    pc.outputs().snapshot(Output{gDataOrigin, description<detectors::TRKFT3>(kClusters), 0}, clusters);
+    if (mUseMC) {
+      auto& flat = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{gDataOrigin, description<detectors::TRKFT3>(kClustersMCTruth), 0});
+      labels.flatten_to(flat);
+    }
+  }
+
+ private:
+  bool mUseMC;
+  TrkDictionaryConditions mDictionaries;
+};
+
+} // namespace
+
+template <>
+DataProcessorSpec getClusterConverterSpec<detectors::TRKFT3>(bool useMC)
+{
+  std::vector<InputSpec> inputs;
+  std::vector<OutputSpec> outputs{OutputSpec{gDataOrigin, description<detectors::TRKFT3>(kClusters), 0, Lifetime::Timeframe}};
+  for (int layer = 0; layer < TrkClusterConverterTask::kLayers; ++layer) {
+    const auto origin = TrkClusterConverterTask::originOf(layer);
+    const auto subspec = TrkClusterConverterTask::subspecOf(layer);
+    inputs.emplace_back(std::format("compclusters_{}", layer), origin, "COMPCLUSTERS", subspec, Lifetime::Timeframe);
+    inputs.emplace_back(std::format("patterns_{}", layer), origin, "PATTERNS", subspec, Lifetime::Timeframe);
+    inputs.emplace_back(std::format("rofs_{}", layer), origin, "CLUSTERSROF", subspec, Lifetime::Timeframe);
+    if (useMC) {
+      inputs.emplace_back(std::format("labels_{}", layer), origin, "CLUSTERSMCTR", subspec, Lifetime::Timeframe);
+    }
+  }
+  if (useMC) {
+    outputs.emplace_back(gDataOrigin, description<detectors::TRKFT3>(kClustersMCTruth), 0, Lifetime::Timeframe);
+  }
+  const TrkDictionaryConditions dictionaries(inputs);
+  return DataProcessorSpec{
+    .name = deviceName<detectors::TRKFT3>("cluster-converter"),
+    .inputs = inputs,
+    .outputs = outputs,
+    .algorithm = AlgorithmSpec{adaptFromTask<TrkClusterConverterTask>(useMC, dictionaries)},
+    .options = Options{},
+  };
+}
+
+template DataProcessorSpec getMeasurementProducerSpec<detectors::TRKFT3>();
+
+} // namespace o2::gtrk::workflow
diff --git a/Detectors/GenericTracking/workflow/src/TrackerDevice.h b/Detectors/GenericTracking/workflow/src/TrackerDevice.h
new file mode 100644
index 0000000000000..2594ee157889a
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/TrackerDevice.h
@@ -0,0 +1,281 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackerDevice.h
+/// \brief The tracking device's task, instantiated by each detector's unit
+///        (TrackerITS.cxx, TrackerMFT.cxx, TrackerTRKFT3.cxx).
+///
+/// Per timeframe: the conditions; the trackers built on the first timeframe
+/// and when the shipped beam line changes; the input's checks; the vertices
+/// (the input seeds or the own vertexer's); the tracking; the products. The
+/// timeframe ends on every way out (`endTimeframeOnExit`), and every product
+/// is published, empty when there is nothing: an empty input, or a timeframe
+/// dropped out of memory with `dropTFUponFailure` (its vertices too). It computes no truth and
+/// observes no stage.
+
+#ifndef GTRK_WORKFLOW_TRACKERDEVICE_H_
+#define GTRK_WORKFLOW_TRACKERDEVICE_H_
+
+#include "GenericTracking/Tracking/Measurement.h"
+#include "GenericTracking/Tracking/PairCut.h"
+#include "GenericTracking/Tracking/TimeFrame.h"
+#include "GenericTracking/Workflow/Conditions.h"
+#include "GenericTracking/Workflow/DataSpecs.h"
+#include "GenericTracking/Workflow/GPURecoTracking.h"
+#include "GenericTracking/Workflow/GridConfig.h"
+#include "GenericTracking/Workflow/RecoParam.h"
+#include "GenericTracking/Workflow/TrackerSpec.h"
+#include "GenericTracking/Workflow/TrackingInterface.h"
+
+#include "Framework/ConcreteDataMatcher.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/DeviceSpec.h"
+#include "Framework/EndOfStreamContext.h"
+#include "Framework/InitContext.h"
+#include "Framework/Logger.h"
+#include "Framework/ProcessingContext.h"
+#include "Framework/Task.h"
+#include "Framework/TimingInfo.h"
+#include "Framework/TypeTraits.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk::workflow
+{
+
+/// The tracking device's products made in \a pc's outputs, empty, published on
+/// every way out: (tracks, vertices, contributors), DPL's vectors.
+template <DetectorLayout Det>
+[[nodiscard]] auto makeTrackerProducts(o2::framework::ProcessingContext& pc)
+{
+  using o2::framework::Output;
+  static_assert(o2::framework::is_messageable<TrackRecord<Det>>::value, "a track record goes as its bytes: trivially copyable, no pointer");
+  static_assert(o2::framework::is_messageable<VertexSeed>::value, "a vertex seed goes as its bytes");
+  auto& tracks = pc.outputs().make<std::vector<TrackRecord<Det>>>(Output{gDataOrigin, description<Det>(kTracks), 0});
+  auto& vertices = pc.outputs().make<std::vector<VertexSeed>>(Output{gDataOrigin, description<Det>(kVertexSeeds), 0});
+  auto& contributors = pc.outputs().make<std::vector<std::uint32_t>>(Output{gDataOrigin, description<Det>(kVertexContributors), 0});
+  return std::tie(tracks, vertices, contributors);
+}
+
+/// The products' output specs.
+template <DetectorLayout Det>
+[[nodiscard]] std::vector<o2::framework::OutputSpec> trackerOutputs()
+{
+  using o2::framework::Lifetime;
+  return {{gDataOrigin, description<Det>(kTracks), 0, Lifetime::Timeframe}, {gDataOrigin, description<Det>(kVertexSeeds), 0, Lifetime::Timeframe}, {gDataOrigin, description<Det>(kVertexContributors), 0, Lifetime::Timeframe}};
+}
+
+/// One timeframe of \a Det's tracking, on \a interface's host or device
+/// (its block set): the conditions, the input's checks, the vertices, the
+/// tracks, the products. The tracking device's run, and the GPU
+/// reconstruction's (GPURecoTracking.h).
+template <DetectorLayout Det, class RunConditions>
+void trackTimeframe(o2::framework::ProcessingContext& pc, TrackingInterface<Det>& interface, RunConditions& conditions, bool withVertices)
+{
+  conditions.checkUpdates(pc);
+  const auto orbit = pc.services().get<o2::framework::TimingInfo>().firstTForbit;
+  auto [tracks, vertices, contributors] = makeTrackerProducts<Det>(pc);
+  const auto ended = interface.endTimeframeOnExit();
+
+  const auto input = readTimeframe<Det>(pc, withVertices);
+  interface.configureFor(conditions, input.shipped);
+  if (const char* invalid = TrackingInterface<Det>::checkInput(input.columns, input.offsets, static_cast<std::size_t>(interface.grid().bucketCount()), input.seeds)) {
+    LOGP(fatal, "{}", invalid);
+    return;
+  }
+  if (input.columns.loc0.empty()) {
+    LOGP(info, "{}: the timeframe at orbit {}: no measurements, empty products", Det::name, orbit);
+    return;
+  }
+
+  const TimeFrame<Det> frame{measurementView(input.columns), interface.grid(), input.offsets};
+  const auto found = interface.vertices(frame, input.seeds, false);
+  if (found.dropped) {
+    return;
+  }
+  const auto tracked = interface.track(frame, found.seeds);
+  if (tracked.dropped) {
+    return;
+  }
+  // The vertices with the tracks only: a dropped timeframe publishes nothing.
+  if (found.found != nullptr) {
+    vertices.assign(found.found->vertices.begin(), found.found->vertices.end());
+    contributors.assign(found.found->contributors.begin(), found.found->contributors.end());
+  }
+  const auto& result = *tracked.result.tracks;
+  tracks.reserve(result.size());
+  std::size_t failed = 0U;
+  for (std::size_t track = 0; track < result.size(); ++track) {
+    tracks.push_back(result.read(track));
+    failed += tracks.back().status == PropagationStatus::kOk ? 0U : 1U;
+  }
+  LOGP(info, "{}: the timeframe at orbit {}: {} tracks ({} with a failed refit), {} vertices, {:.3f} s tracking, {:.3f} s vertexing", Det::name, orbit, tracks.size(), failed, vertices.size(), tracked.seconds, found.seconds);
+}
+
+/// At the end of the stream: the timeframes dropped, an error line.
+template <DetectorLayout Det>
+void reportDropped(const TrackingInterface<Det>& interface)
+{
+  // A validation run fails on this line: no timeframe may be dropped.
+  if (const auto dropped = interface.droppedTimeframes(); dropped != 0U) {
+    LOGP(error, "{}: {} timeframes dropped out of memory (GTRKReco<DET>.dropTFUponFailure)", Det::name, dropped);
+  }
+}
+
+/// The configuration, once per pipeline, as O2's ITS tracking prints its own.
+template <DetectorLayout Det>
+void printConfiguration(o2::framework::InitContext& ic)
+{
+  if (ic.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) {
+    RecoParamOf<Det>::type::Instance().printKeyValues(true, true);
+  }
+}
+
+template <DetectorLayout Det>
+class TrackerTask : public o2::framework::Task
+{
+ public:
+  using RunConditions = Conditions<Det, true>;
+
+  TrackerTask(bool withVertices, std::shared_ptr<RunConditions> conditions)
+    : mWithVertices(withVertices),
+      mInterface(withVertices),
+      mConditions(std::move(conditions))
+  {
+  }
+
+  void init(o2::framework::InitContext& ic) final
+  {
+    mConditions->init(ic);
+    printConfiguration<Det>(ic);
+    mInterface.initDevice({
+      .backend = ic.options().get<std::string>("gtrk-gpu-backend"),
+      .device = ic.options().get<int>("gtrk-gpu-device"),
+      .arenaMB = static_cast<std::size_t>(ic.options().get<int>("gtrk-gpu-arena-mb")),
+    });
+  }
+
+  /// The GPU released here: the task itself is never destroyed at the exit.
+  void stop() final { mInterface.releaseDevice(); }
+
+  void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final { mConditions->finaliseCCDB(matcher, obj); }
+
+  void run(o2::framework::ProcessingContext& pc) final { trackTimeframe<Det>(pc, mInterface, *mConditions, mWithVertices); }
+
+  void endOfStream(o2::framework::EndOfStreamContext& /*ec*/) final { reportDropped<Det>(mInterface); }
+
+ private:
+  bool mWithVertices = false;
+  TrackingInterface<Det> mInterface;
+  std::shared_ptr<RunConditions> mConditions; ///< the run's field, geometry, MeanVertex and material LUT (Conditions.h)
+};
+
+template <DetectorLayout Det>
+o2::framework::DataProcessorSpec getTrackerSpec(bool withVertices)
+{
+  using namespace o2::framework;
+  auto inputs = measurementInputs<Det>(withVertices);
+  auto conditions = std::make_shared<Conditions<Det, true>>(inputs);
+  return DataProcessorSpec{
+    .name = deviceName<Det>("tracker"),
+    .inputs = inputs,
+    .outputs = trackerOutputs<Det>(),
+    .algorithm = AlgorithmSpec{adaptFromTask<TrackerTask<Det>>(withVertices, conditions)},
+    .options = Options{{"gtrk-gpu-backend", VariantType::String, "", {"the GPU backend to track on, cuda or hip; the host if empty"}}, {"gtrk-gpu-device", VariantType::Int, 0, {"the GPU backend's device index"}}, {"gtrk-gpu-arena-mb", VariantType::Int, 0, {"the device tracker's arena in O2's GPU pool [MB]; required with a GPU backend"}}},
+  };
+}
+
+/// \a Det's tracking inside the GPU reconstruction (GPURecoTracking.h): the
+/// tracking device's timeframe on the reconstruction's GPU, in the pool's
+/// free memory after the TPC, borrowed per timeframe.
+template <DetectorLayout Det>
+class GPURecoTrackingOf final : public GPURecoTracking
+{
+ public:
+  using RunConditions = Conditions<Det, true, ConditionsHolder::kGPUReco>;
+
+  /// No native seeds: the vertex list, where an iteration needs one, is the
+  /// own vertexer's.
+  GPURecoTrackingOf() : mInterface(false) {}
+
+  void appendInputs(std::vector<o2::framework::InputSpec>& inputs) final
+  {
+    auto own = measurementInputs<Det>(false);
+    mConditions = std::make_unique<RunConditions>(own);
+    inputs.insert(inputs.end(), own.begin(), own.end());
+  }
+
+  void appendOutputs(std::vector<o2::framework::OutputSpec>& outputs) final
+  {
+    const auto own = trackerOutputs<Det>();
+    outputs.insert(outputs.end(), own.begin(), own.end());
+  }
+
+  void init(o2::framework::InitContext& ic, o2::gpu::GPUReconstruction& reconstruction) final
+  {
+    mConditions->init(ic);
+    printConfiguration<Det>(ic);
+    mInterface.initDevice(reconstruction);
+  }
+
+  bool finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final { return mConditions->finaliseCCDB(matcher, obj); }
+
+  void run(o2::framework::ProcessingContext& pc, bool reconstructed) final
+  {
+    if (!reconstructed) {
+      static_cast<void>(makeTrackerProducts<Det>(pc));
+      return;
+    }
+    // Given back after the timeframe's end, which detaches the tracker.
+    const auto borrowed = mInterface.context().borrow(tag());
+    mInterface.useBlock(borrowed->block());
+    trackTimeframe<Det>(pc, mInterface, *mConditions, false);
+    LOGP(info, "{}: the GPU reconstruction's pool lent {:.1f} MB, the arena's peak {:.1f} MB", Det::name, static_cast<double>(borrowed->block().bytes) / 1.e6, static_cast<double>(mInterface.lastArenaPeakBytes()) / 1.e6);
+  }
+
+  void stop() final { mInterface.releaseDevice(); }
+
+  void endOfStream() final { reportDropped<Det>(mInterface); }
+
+ private:
+  /// The pool's stack tag of the borrow, "GTRK" and the detector's origin
+  /// as O2's qStr2Tag packs a tag: the first character lowest.
+  [[nodiscard]] static std::uint64_t tag()
+  {
+    const std::string name = "GTRK" + detectorOrigin<Det>().template as<std::string>();
+    std::uint64_t packed = 0U;
+    for (std::size_t i = std::min<std::size_t>(name.size(), 8U); i-- > 0U;) {
+      packed = (packed << 8U) | static_cast<std::uint8_t>(name[i]);
+    }
+    return packed;
+  }
+
+  TrackingInterface<Det> mInterface;
+  std::unique_ptr<RunConditions> mConditions; ///< the detector's own conditions; the run-wide ones are the GPU reconstruction's
+};
+
+template <DetectorLayout Det>
+std::unique_ptr<GPURecoTracking> makeGPURecoTrackingOf()
+{
+  return std::make_unique<GPURecoTrackingOf<Det>>();
+}
+
+} // namespace o2::gtrk::workflow
+
+#endif // GTRK_WORKFLOW_TRACKERDEVICE_H_
diff --git a/Detectors/GenericTracking/workflow/src/TrackerITS.cxx b/Detectors/GenericTracking/workflow/src/TrackerITS.cxx
new file mode 100644
index 0000000000000..ac0802b711b4d
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/TrackerITS.cxx
@@ -0,0 +1,27 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackerITS.cxx
+/// \brief The ITS's tracking device (TrackerDevice.h): one unit per detector,
+///        each instantiating the tracker, and its tracking inside the GPU
+///        reconstruction (GPURecoTracking.h).
+
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Workflow/Conditions.h"
+#include "TrackerDevice.h"
+
+namespace o2::gtrk
+{
+
+template o2::framework::DataProcessorSpec workflow::getTrackerSpec<detectors::ITS>(bool withVertices);
+template std::unique_ptr<workflow::GPURecoTracking> workflow::makeGPURecoTrackingOf<detectors::ITS>();
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/workflow/src/TrackerMFT.cxx b/Detectors/GenericTracking/workflow/src/TrackerMFT.cxx
new file mode 100644
index 0000000000000..6167ddfda6944
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/TrackerMFT.cxx
@@ -0,0 +1,27 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackerMFT.cxx
+/// \brief The MFT's tracking device (TrackerDevice.h): one unit per detector,
+///        each instantiating the tracker, and its tracking inside the GPU
+///        reconstruction (GPURecoTracking.h).
+
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Workflow/Conditions.h"
+#include "TrackerDevice.h"
+
+namespace o2::gtrk
+{
+
+template o2::framework::DataProcessorSpec workflow::getTrackerSpec<detectors::MFT>(bool withVertices);
+template std::unique_ptr<workflow::GPURecoTracking> workflow::makeGPURecoTrackingOf<detectors::MFT>();
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/workflow/src/TrackerTRKFT3.cxx b/Detectors/GenericTracking/workflow/src/TrackerTRKFT3.cxx
new file mode 100644
index 0000000000000..f91794c10d631
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/TrackerTRKFT3.cxx
@@ -0,0 +1,25 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TrackerTRKFT3.cxx
+/// \brief The TRKFT3's tracking device (TrackerDevice.h): one unit per detector,
+///        each instantiating the tracker.
+
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Workflow/ConditionsTRK.h"
+#include "TrackerDevice.h"
+
+namespace o2::gtrk
+{
+
+template o2::framework::DataProcessorSpec workflow::getTrackerSpec<detectors::TRKFT3>(bool withVertices);
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/workflow/src/gtrk-its-reco-workflow.cxx b/Detectors/GenericTracking/workflow/src/gtrk-its-reco-workflow.cxx
new file mode 100644
index 0000000000000..36e47dec18fa9
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/gtrk-its-reco-workflow.cxx
@@ -0,0 +1,81 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file gtrk-its-reco-workflow.cxx
+/// \brief The ITS's tracking: O2's clusters in, O2's ITS tracks, vertices and
+///        IR frames out, as o2-its-reco-workflow --clusters-from-upstream.
+///
+/// O2's cluster reader (unless `--clusters-from-upstream`), the converter into
+/// our clusters, the measurement producer, the tracker (GTRK/ITS...), the
+/// adaptor into O2's formats (unless `--disable-adaptor`) and O2's track and
+/// IR-frame writers (unless `--disable-root-output`, or without the adaptor).
+/// With `--vertices-from-upstream` the tracker takes the native vertex seeds
+/// (GTRK/ITSVERTICES) from the workflow before it in the pipe.
+/// With the tracking inside o2-gpu-reco-workflow (`--output-type
+/// gtrk-its-tracks`), this workflow twice: `--tracking-in-gpu-reco` before it
+/// in the pipe (the converter and the producer), `--adaptor-only` after it.
+
+#include "RecoWorkflow.h"
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/CallbacksPolicy.h"
+#include "Framework/CompletionPolicyHelpers.h"
+
+using namespace o2::framework;
+
+// DPL looks these up by symbol before runDataProcessing.h is included, so
+// they have to keep external linkage.
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::CallbacksPolicy>& policies) { o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies); }
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::CompletionPolicy>& policies)
+{
+  // O2's writers in timeframe order, as o2-its-reco-workflow has them.
+  policies.push_back(CompletionPolicyHelpers::consumeWhenAllOrdered(".*(?:ITS|its).*[W,w]riter.*"));
+  policies.push_back(CompletionPolicyHelpers::consumeWhenAllOrdered(".*irframe-writer.*"));
+}
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions) { o2::gtrk::workflow::addRecoOptions(workflowOptions, true); }
+
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Workflow/AdaptorSpec.h"
+
+#include "GlobalTrackingWorkflowWriters/IRFrameWriterSpec.h"
+#include "ITSMFTWorkflow/ClusterReaderSpec.h"
+#include "ITSWorkflow/TrackWriterSpec.h"
+
+#include <string>
+
+#include "Framework/runDataProcessing.h" // IWYU pragma: keep
+
+WorkflowSpec defineDataProcessing(const ConfigContext& context)
+{
+  o2::conf::ConfigurableParam::updateFromString(context.options().get<std::string>("configKeyValues"));
+
+  namespace gw = o2::gtrk::workflow;
+  using Det = o2::gtrk::detectors::ITS;
+  const bool useMC = !context.options().get<bool>("disable-mc");
+  auto specs = gw::trackingChain<Det>(context, {o2::itsmft::getITSClusterReaderSpec(useMC, false, true, false)});
+  // The adaptor reads the tracks: after the GPU reconstruction when the tracking runs inside it.
+  if (!context.options().get<bool>("disable-adaptor") && !gw::trackingInGPUReco(context)) {
+    specs.push_back(gw::getAdaptorSpec<Det>(useMC));
+    if (!context.options().get<bool>("disable-root-output")) {
+      specs.push_back(o2::its::getTrackWriterSpec(useMC));
+      specs.push_back(o2::globaltracking::getIRFrameWriterSpec("irfr:ITS/IRFRAMES/0", "o2_its_irframe.root", "irframe-writer-its"));
+    }
+  }
+
+  const o2::raw::HBFUtilsInitializer hbfIni(context, specs);
+
+  return specs;
+}
diff --git a/Detectors/GenericTracking/workflow/src/gtrk-mft-reco-workflow.cxx b/Detectors/GenericTracking/workflow/src/gtrk-mft-reco-workflow.cxx
new file mode 100644
index 0000000000000..105754b5fbc30
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/gtrk-mft-reco-workflow.cxx
@@ -0,0 +1,78 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file gtrk-mft-reco-workflow.cxx
+/// \brief The MFT's tracking: O2's clusters in, O2's MFT tracks out, as
+///        o2-mft-reco-workflow --clusters-from-upstream.
+///
+/// O2's cluster reader (unless `--clusters-from-upstream`), the converter into
+/// our clusters, the measurement producer, the tracker (GTRK/MFT...), the
+/// adaptor into O2's formats (unless `--disable-adaptor`) and O2's track
+/// writer (unless `--disable-root-output`, or without the adaptor). With
+/// `--vertices-from-upstream` the tracker takes the native vertex seeds
+/// (GTRK/MFTVERTICES) from the workflow before it in the pipe.
+/// With the tracking inside o2-gpu-reco-workflow (`--output-type
+/// gtrk-mft-tracks`), this workflow twice: `--tracking-in-gpu-reco` before it
+/// in the pipe (the converter and the producer), `--adaptor-only` after it.
+
+#include "RecoWorkflow.h"
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/CallbacksPolicy.h"
+#include "Framework/CompletionPolicyHelpers.h"
+
+using namespace o2::framework;
+
+// DPL looks these up by symbol before runDataProcessing.h is included, so
+// they have to keep external linkage.
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::CallbacksPolicy>& policies) { o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies); }
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::CompletionPolicy>& policies)
+{
+  // O2's writer in timeframe order, as o2-mft-reco-workflow has it.
+  policies.push_back(CompletionPolicyHelpers::consumeWhenAllOrdered(".*(?:MFT|mft).*[W,w]riter.*"));
+}
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions) { o2::gtrk::workflow::addRecoOptions(workflowOptions, true); }
+
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Workflow/AdaptorSpec.h"
+
+#include "ITSMFTCAWriter/MFTCATrackWriterSpec.h"
+#include "ITSMFTWorkflow/ClusterReaderSpec.h"
+
+#include <string>
+
+#include "Framework/runDataProcessing.h" // IWYU pragma: keep
+
+WorkflowSpec defineDataProcessing(const ConfigContext& context)
+{
+  o2::conf::ConfigurableParam::updateFromString(context.options().get<std::string>("configKeyValues"));
+
+  namespace gw = o2::gtrk::workflow;
+  using Det = o2::gtrk::detectors::MFT;
+  const bool useMC = !context.options().get<bool>("disable-mc");
+  auto specs = gw::trackingChain<Det>(context, {o2::itsmft::getMFTClusterReaderSpec(useMC, false, true, false)});
+  // The adaptor reads the tracks: after the GPU reconstruction when the tracking runs inside it.
+  if (!context.options().get<bool>("disable-adaptor") && !gw::trackingInGPUReco(context)) {
+    specs.push_back(gw::getAdaptorSpec<Det>(useMC));
+    if (!context.options().get<bool>("disable-root-output")) {
+      specs.push_back(o2::mft::getTrackWriterSpec(useMC));
+    }
+  }
+
+  const o2::raw::HBFUtilsInitializer hbfIni(context, specs);
+
+  return specs;
+}
diff --git a/Detectors/GenericTracking/workflow/src/gtrk-trk-reco-workflow.cxx b/Detectors/GenericTracking/workflow/src/gtrk-trk-reco-workflow.cxx
new file mode 100644
index 0000000000000..c0c2bff6a6aad
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/src/gtrk-trk-reco-workflow.cxx
@@ -0,0 +1,56 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file gtrk-trk-reco-workflow.cxx
+/// \brief ALICE 3's tracking on the TRK's and FT3's clusters: GenericTracking's
+///        tracks and vertices out (TrackerSpec.h).
+///
+/// O2's TRK and FT3 cluster readers (unless `--clusters-from-upstream`), the
+/// converter of their per-layer streams, the measurement producer and the
+/// tracker of the TRKFT3 layout, the topology dictionaries as CCDB
+/// conditions. With `--vertices-from-upstream` the tracker takes the native
+/// vertex seeds (GTRK/TRKVERTICES) from the workflow before it in the pipe.
+/// No adaptor: ALICE 3 has no O2 track format yet.
+
+#include "RecoWorkflow.h"
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/CallbacksPolicy.h"
+
+using namespace o2::framework;
+
+// DPL looks both of these up by symbol before runDataProcessing.h is included,
+// so they have to keep external linkage.
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::CallbacksPolicy>& policies) { o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies); }
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions) { o2::gtrk::workflow::addRecoOptions(workflowOptions, false); }
+
+#include "GenericTracking/Detectors/TRKFT3.h"
+
+#include "TRKWorkflow/ClusterReaderSpec.h"
+
+#include <string>
+
+#include "Framework/runDataProcessing.h" // IWYU pragma: keep
+
+WorkflowSpec defineDataProcessing(const ConfigContext& context)
+{
+  o2::conf::ConfigurableParam::updateFromString(context.options().get<std::string>("configKeyValues"));
+
+  const bool useMC = !context.options().get<bool>("disable-mc");
+  auto specs = o2::gtrk::workflow::trackingChain<o2::gtrk::detectors::TRKFT3>(context, {o2::trk::getTRKClusterReaderSpec(useMC), o2::trk::getFT3ClusterReaderSpec(useMC)});
+
+  const o2::raw::HBFUtilsInitializer hbfIni(context, specs);
+
+  return specs;
+}
diff --git a/Detectors/GenericTracking/workflow/test/CMakeLists.txt b/Detectors/GenericTracking/workflow/test/CMakeLists.txt
new file mode 100644
index 0000000000000..e00d776e385fa
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/test/CMakeLists.txt
@@ -0,0 +1,30 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+function(gtrk_workflow_test name source)
+  o2_add_test(${name} SOURCES ${source} COMPONENT_NAME generic-tracking
+              PUBLIC_LINK_LIBRARIES O2::GTrkWorkflow O2::GTrkTracking ${ARGN}
+              LABELS generic-tracking TARGETVARNAME target)
+  if(target)
+    target_include_directories(${target} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../tracking/test)
+  endif()
+endfunction()
+
+gtrk_workflow_test(alice-layouts testAliceLayouts.cxx O2::ITSBase O2::MFTBase O2::MathUtils)
+gtrk_workflow_test(alice-clusters testAliceClusters.cxx O2::DataFormatsITSMFT O2::CommonConstants O2::CommonUtils)
+gtrk_workflow_test(disc-chain-pulls testDiscChainPulls.cxx O2::MFTBase O2::MathUtils)
+gtrk_workflow_test(tracker-memory-pool testTrackerMemoryPool.cxx)
+gtrk_workflow_test(grid-config testGridConfig.cxx)
+gtrk_workflow_test(cluster-shape-band testClusterShapeBand.cxx)
+gtrk_workflow_test(o2-parameters testO2Parameters.cxx O2::ReconstructionDataFormats)
+if(ENABLE_UPGRADES)
+  gtrk_workflow_test(trk testTrkChainPulls.cxx O2::MathUtils)
+endif()
diff --git a/Detectors/GenericTracking/workflow/test/testAliceClusters.cxx b/Detectors/GenericTracking/workflow/test/testAliceClusters.cxx
new file mode 100644
index 0000000000000..793e9c7ebd494
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/test/testAliceClusters.cxx
@@ -0,0 +1,111 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testAliceClusters.cxx
+/// \brief The dictionary-free half of the O2 cluster conversion: readout
+///        frames, times and the sensor frame (GenericTracking/Alice/Clusters.h).
+///
+/// The dictionary half is held to O2 on real clusters by
+/// `o2-gtrk-cluster-closure`.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK ALICE clusters
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Alice/Clusters.h"
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Base/TimeEstPS.h"
+
+#include "CommonConstants/LHCConstants.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using o2::itsmft::ROFRecord;
+
+/// \a count frames of \a lengthBC from \a firstBC of orbit \a orbit, with
+/// \a perFrame clusters each.
+std::vector<ROFRecord> frames(int count, int lengthBC, int firstBC, std::uint32_t orbit, int perFrame)
+{
+  std::vector<ROFRecord> result;
+  for (int i = 0; i < count; ++i) {
+    const int bc = firstBC + (i * lengthBC);
+    const o2::InteractionRecord ir{static_cast<std::uint16_t>(bc % o2::constants::lhc::LHCMaxBunches), orbit + static_cast<std::uint32_t>(bc / o2::constants::lhc::LHCMaxBunches)};
+    result.emplace_back(ir, i, i * perFrame, perFrame);
+  }
+  return result;
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(FrameLengthIsTheRecordsSpacing)
+{
+  BOOST_TEST(alice::readoutFrames(frames(40, 198, 64, 0U, 0)).lengthBC == 198);
+  BOOST_TEST(alice::readoutFrames(frames(3, 891, 0, 7U, 0)).lengthBC == 891);
+  BOOST_CHECK_THROW(static_cast<void>(alice::readoutFrames(frames(1, 198, 0, 0U, 0))), std::runtime_error);
+  auto uneven = frames(4, 198, 0, 0U, 0);
+  uneven.back().getBCData() += 1;
+  BOOST_CHECK_THROW(static_cast<void>(alice::readoutFrames(uneven)), std::runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(ClustersTakeTheirFrameAsTimeBoxAndOurSensorFrame)
+{
+  // Two frames of 198 BC in a timeframe starting at orbit 32, the second
+  // across the orbit boundary.
+  const auto rofs = frames(2, 198, 3500, 32U, 2);
+  const std::vector<alice::LocalCluster> local{
+    {.chip = 3, .x = 0.1F, .z = -0.5F, .sigma2X = 4e-8F, .sigma2Z = 9e-8F, .nPixels = 2U},
+    {.chip = 4, .x = -0.3F, .z = 1.2F, .sigma2X = 1e-8F, .sigma2Z = 1e-8F, .nPixels = 1U},
+    {.chip = 5, .x = 0.F, .z = 0.F, .sigma2X = 1e-8F, .sigma2Z = 1e-8F, .nPixels = 7U},
+    {.chip = 6, .x = 0.6F, .z = -1.4F, .sigma2X = 1e-8F, .sigma2Z = 1e-8F, .nPixels = 3U},
+  };
+  const auto clusters = alice::toClusters(local, rofs, {.lengthBC = 198}, 32U);
+  BOOST_REQUIRE(clusters.size() == local.size());
+
+  BOOST_TEST(clusters[0].chipID == 3U);
+  BOOST_TEST(std::abs(static_cast<double>(clusters[0].xLocal) - (0.1 - alice::kActiveCentreX)) < 1e-7);
+  BOOST_TEST(clusters[0].yLocal == -0.5F);
+  BOOST_TEST(std::abs(clusters[0].sigmaXLocal - 2e-4F) < 1e-9F);
+  BOOST_TEST(std::abs(clusters[0].sigmaYLocal - 3e-4F) < 1e-9F);
+
+  // Each cluster's readout frame as its time box, its start and its length
+  // rounded down; the second frame across the orbit boundary.
+  BOOST_TEST(clusters[0].timePS == static_cast<std::uint32_t>(psOfBC(3500)));
+  BOOST_TEST(clusters[0].widthPS == static_cast<std::uint32_t>(psOfBC(198)));
+  BOOST_TEST(clusters[1].timePS == clusters[0].timePS);
+  BOOST_TEST(clusters[2].timePS == static_cast<std::uint32_t>(psOfBC(3500 + 198)));
+  BOOST_TEST(clusters[2].widthPS == clusters[0].widthPS);
+  BOOST_TEST(clusters[3].timePS == clusters[2].timePS);
+}
+
+BOOST_AUTO_TEST_CASE(FramesMustCoverTheClustersInOrder)
+{
+  const std::vector<alice::LocalCluster> local(4);
+  BOOST_CHECK_THROW(static_cast<void>(alice::toClusters(local, frames(1, 198, 0, 0U, 2), {.lengthBC = 198}, 0U)), std::runtime_error);
+  BOOST_CHECK_THROW(static_cast<void>(alice::toClusters(local, frames(3, 198, 0, 0U, 2), {.lengthBC = 198}, 0U)), std::runtime_error);
+  // A frame before the timeframe's first orbit.
+  BOOST_CHECK_THROW(static_cast<void>(alice::toClusters(local, frames(2, 198, 0, 0U, 2), {.lengthBC = 198}, 1U)), std::runtime_error);
+  BOOST_CHECK_NO_THROW(static_cast<void>(alice::toClusters(local, frames(2, 198, 0, 1U, 2), {.lengthBC = 198}, 1U)));
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/workflow/test/testAliceLayouts.cxx b/Detectors/GenericTracking/workflow/test/testAliceLayouts.cxx
new file mode 100644
index 0000000000000..0ef8aac7c74ce
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/test/testAliceLayouts.cxx
@@ -0,0 +1,154 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testAliceLayouts.cxx
+/// \brief O2 sensor placements against L2G matrices and ideal envelopes.
+/// Set GTRK_ALICE_GEOMETRY and GTRK_ALICE_GEOMETRY_IDEAL for both checks.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK ALICE layouts
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Base/LayerEnvelopes.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Detectors/ITS.h"
+#include "GenericTracking/Detectors/MFT.h"
+
+#include "DetectorsBase/GeometryManager.h"
+#include "ITSBase/GeometryTGeo.h"
+#include "MFTBase/GeometryTGeo.h"
+#include "MathUtils/Cartesian.h"
+#include "MathUtils/Utils.h"
+
+#include <array>
+#include <cmath>
+#include <cstdlib>
+#include <memory>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using detectors::ITS;
+using detectors::MFT;
+
+/// Our sensor frame against O2's L2G: ALICE's local (x, 0, z) is our
+/// (x - kActiveCentreX, z, 0) on the same chip.
+template <typename GeometryTGeo>
+void checkAgainstL2G(GeometryTGeo& o2Geometry, std::span<const Sensor> sensors)
+{
+  o2Geometry.fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+  double worst = 0.;
+  for (std::size_t chip = 0; chip < sensors.size(); chip += 7U) {
+    for (const double xa : {-0.6, 0.0581, 0.7}) {
+      for (const double za : {-1.4, 0., 1.4}) {
+        const auto expected = o2Geometry.getMatrixL2G(static_cast<int>(chip))(o2::math_utils::Point3D<double>{xa, 0., za});
+        const double local[3] = {xa - alice::kActiveCentreX, za, 0.};
+        double global[3];
+        sensors[chip].toGlobal(local, global);
+        worst = std::max({worst, std::abs(global[0] - expected.X()), std::abs(global[1] - expected.Y()), std::abs(global[2] - expected.Z())});
+      }
+    }
+    BOOST_TEST(static_cast<int>(sensors[chip].layer) == o2Geometry.getLayer(static_cast<int>(chip)));
+  }
+  BOOST_TEST(worst < 1e-9);
+}
+
+/// The reference envelopes of the ITS and the MFT, measured by
+/// o2-gtrk-import-geometry from an ideal o2sim_geometry-aligned.root. The
+/// measurement at load must give them back to the bit on that geometry.
+// Measured values that happen to lie near mathematical constants are not them.
+// NOLINTBEGIN(modernize-use-std-numbers)
+constexpr std::array<LayerEnvelope, 7> kReferenceIts{{
+  {.position = 2.3260, .rMin = 2.2331, .rMax = 2.6036, .zMin = -13.5571, .zMax = 13.5571},
+  {.position = 3.1354, .rMin = 3.0066, .rMax = 3.4012, .zMin = -13.5571, .zMax = 13.5571},
+  {.position = 3.9162, .rMin = 3.7820, .rMax = 4.1614, .zMin = -13.5571, .zMax = 13.5571},
+  {.position = 19.5882, .rMin = 19.3518, .rMax = 19.8957, .zMin = -42.2071, .zMax = 42.2071},
+  {.position = 24.5272, .rMin = 24.3018, .rMax = 24.8096, .zMin = -42.2071, .zMax = 42.2071},
+  {.position = 34.3546, .rMin = 34.1418, .rMax = 34.6084, .zMin = -73.8721, .zMax = 73.8721},
+  {.position = 39.3106, .rMin = 39.1018, .rMax = 39.5554, .zMin = -73.8721, .zMax = 73.8721},
+}};
+constexpr std::array<LayerEnvelope, 10> kReferenceMft{{
+  {.position = -45.2889, .rMin = 2.3029, .rMax = 12.2259, .zMin = -45.2903, .zMax = -45.2874},
+  {.position = -46.7111, .rMin = 2.3029, .rMax = 12.2259, .zMin = -46.7126, .zMax = -46.7097},
+  {.position = -48.5889, .rMin = 2.3029, .rMax = 12.2259, .zMin = -48.5903, .zMax = -48.5874},
+  {.position = -50.0111, .rMin = 2.3029, .rMax = 12.2259, .zMin = -50.0126, .zMax = -50.0097},
+  {.position = -52.3889, .rMin = 2.3029, .rMax = 13.6984, .zMin = -52.3903, .zMax = -52.3874},
+  {.position = -53.8111, .rMin = 2.3029, .rMax = 13.6984, .zMin = -53.8126, .zMax = -53.8097},
+  {.position = -67.6889, .rMin = 3.4029, .rMax = 16.7089, .zMin = -67.6903, .zMax = -67.6874},
+  {.position = -69.1111, .rMin = 3.4029, .rMax = 16.7089, .zMin = -69.1126, .zMax = -69.1097},
+  {.position = -76.0889, .rMin = 3.8029, .rMax = 17.3105, .zMin = -76.0903, .zMax = -76.0874},
+  {.position = -77.5111, .rMin = 3.8029, .rMax = 17.3105, .zMin = -77.5126, .zMax = -77.5097},
+}};
+// NOLINTEND(modernize-use-std-numbers)
+
+template <DetectorLayout Det, std::size_t N>
+void checkReference(const std::array<LayerEnvelope, N>& reference)
+{
+  static_assert(N == Detector<Det>::nLayers);
+  for (std::size_t layer = 0; layer < N; ++layer) {
+    const auto& e = PlacedEnvelopes<Det>::all()[layer];
+    BOOST_TEST(e.position == reference[layer].position);
+    BOOST_TEST(e.rMin == reference[layer].rMin);
+    BOOST_TEST(e.rMax == reference[layer].rMax);
+    BOOST_TEST(e.zMin == reference[layer].zMin);
+    BOOST_TEST(e.zMax == reference[layer].zMax);
+  }
+}
+
+const char* geometryFile() { return std::getenv("GTRK_ALICE_GEOMETRY"); }
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(PlacementsFollowO2)
+{
+  if (geometryFile() == nullptr) {
+    BOOST_TEST_MESSAGE("GTRK_ALICE_GEOMETRY not set: O2's placements are not checked");
+    return;
+  }
+  o2::base::GeometryManager::loadGeometry(geometryFile());
+  const auto its = alice::placeChecked<ITS>();
+  const auto mft = alice::placeChecked<MFT>();
+  checkAgainstL2G(*o2::its::GeometryTGeo::Instance(), its);
+  checkAgainstL2G(*o2::mft::GeometryTGeo::Instance(), mft);
+
+  // The normal convention the frame mapping gives: away from the beam on the
+  // ITS, alternating along z on the MFT.
+  for (const auto& sensor : its) {
+    const double outward = (sensor.rot[2] * sensor.trans[0]) + (sensor.rot[5] * sensor.trans[1]);
+    BOOST_TEST_REQUIRE(outward > 0.);
+  }
+  for (const auto& sensor : mft) {
+    BOOST_TEST_REQUIRE(std::abs(sensor.rot[8]) > 0.999999);
+  }
+
+  // The envelopes measured at load, against the reference tables. Only the
+  // ideal geometry reproduces them; an aligned one does not, and is not meant
+  // to.
+  if (std::getenv("GTRK_ALICE_GEOMETRY_IDEAL") != nullptr) {
+    [[maybe_unused]] const Geometry<ITS> itsGeometry{its};
+    [[maybe_unused]] const Geometry<MFT> mftGeometry{mft};
+    checkReference<ITS>(kReferenceIts);
+    checkReference<MFT>(kReferenceMft);
+  } else {
+    BOOST_TEST_MESSAGE("GTRK_ALICE_GEOMETRY_IDEAL not set: the measured envelopes are not held to the reference tables");
+  }
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/workflow/test/testClusterShapeBand.cxx b/Detectors/GenericTracking/workflow/test/testClusterShapeBand.cxx
new file mode 100644
index 0000000000000..da4aa56f7be99
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/test/testClusterShapeBand.cxx
@@ -0,0 +1,69 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testClusterShapeBand.cxx
+/// \brief A cluster-shape band's slope interval per cluster shape, and a
+///        line's local slope against one.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK cluster shape band
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/ShapeCut.h"
+#include "GenericTracking/Workflow/ClusterShapeBand.h"
+
+#include <cstddef>
+#include <vector>
+
+using o2::gtrk::workflow::ClusterShapeBand;
+
+namespace
+{
+
+/// A band of three layers, layer 1 calibrated: at most two rows; one column
+/// at slopes [0, 1), two [0, 2) (the hull of two bins), five [1, 2), three
+/// none.
+ClusterShapeBand band()
+{
+  ClusterShapeBand result{
+    .maxRows = {0, 2, 0},
+    .slopeLow = std::vector<float>(3 * ClusterShapeBand::kSpans, ClusterShapeBand::kNone.first),
+    .slopeHigh = std::vector<float>(3 * ClusterShapeBand::kSpans, ClusterShapeBand::kNone.second),
+  };
+  const auto set = [&](std::size_t span, float low, float high) {
+    result.slopeLow[ClusterShapeBand::kSpans + span] = low;
+    result.slopeHigh[ClusterShapeBand::kSpans + span] = high;
+  };
+  set(1, 0.F, 1.F);
+  set(2, 0.F, 2.F);
+  set(5, 1.F, 2.F);
+  return result;
+}
+
+} // namespace
+
+// A cluster's shape gives its interval on a calibrated layer; more rows than
+// the band's, a span no slope gives, a cluster without a pattern and an
+// uncalibrated layer, or one beyond the band's, give none or every one.
+BOOST_AUTO_TEST_CASE(AClusterShapeGivesItsSlopeInterval)
+{
+  const auto shapes = band();
+  BOOST_TEST(shapes.fits(3U));
+  BOOST_TEST(!shapes.fits(2U));
+  BOOST_TEST((shapes.interval(5U, 1U, 1U) == ClusterShapeBand::kEvery));
+  BOOST_TEST((shapes.interval(1U, 1U, 1U) == ClusterShapeBand::Interval(0.F, 1.F)));
+  BOOST_TEST((shapes.interval(1U, 2U, 2U) == ClusterShapeBand::Interval(0.F, 2.F)));
+  BOOST_TEST((shapes.interval(1U, 1U, 5U) == ClusterShapeBand::Interval(1.F, 2.F)));
+  BOOST_TEST((shapes.interval(1U, 3U, 1U) == ClusterShapeBand::kNone));
+  BOOST_TEST((shapes.interval(1U, 1U, 3U) == ClusterShapeBand::kNone));
+  BOOST_TEST((shapes.interval(1U, 1U, 0U) == ClusterShapeBand::kEvery));
+  BOOST_TEST((shapes.interval(0U, 1U, 2U) == ClusterShapeBand::kEvery));
+}
diff --git a/Detectors/GenericTracking/workflow/test/testDiscChainPulls.cxx b/Detectors/GenericTracking/workflow/test/testDiscChainPulls.cxx
new file mode 100644
index 0000000000000..0d37b86121030
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/test/testDiscChainPulls.cxx
@@ -0,0 +1,345 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testDiscChainPulls.cxx
+/// \brief Fit pulls of disc chains that scatter, at theta near pi.
+///
+/// A track through a stack of discs at small angle to the beam has a short
+/// transverse arc, so its chain determines q/p poorly, and the fit takes its
+/// scattering at its filtered momentum. testTrackFitter's pull tests
+/// run on the barrel, where q/p is well determined; these run where it is not.
+///
+/// The chains are generated as `BarrelChain` in testTrackFitter.cxx does:
+/// a straight line from the origin picks the first disc's sensor, then the
+/// helix scatters at every sensor but the last as a thin scatterer carrying
+/// the material of the step outward of it -- the Highland theta0 of the chord
+/// in `UniformMaterial`, which is the fit's own model -- and truth[0] is the
+/// state on the vertex side of the first sensor, which the inward pass
+/// estimates. Only the positions are smeared.
+///
+/// They run on the MFT's placed faces, with `GTRK_ALICE_GEOMETRY` naming an
+/// o2sim geometry file.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK Disc Chain Pulls
+#include <boost/test/unit_test.hpp>
+#include "PullStatistics.h"
+
+#include "GridTestSupport.h"
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Detectors/MFT.h"
+#include "GenericTracking/Tracking/Material.h"
+#include "GenericTracking/Tracking/TrackFitter.h"
+#include "UniformMaterial.h"
+
+#include "DetectorsBase/GeometryManager.h"
+
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdlib>
+#include <memory>
+#include <numbers>
+#include <random>
+#include <span>
+#include <string>
+#include <vector>
+
+namespace o2::gtrk
+{
+namespace
+{
+
+using detectors::MFT;
+
+const char* geometryFile() { return std::getenv("GTRK_ALICE_GEOMETRY"); }
+
+/// Global unit momentum direction from the two angle parameters.
+void directionFromAngles(Scalar phi, Scalar theta, Scalar d[3])
+{
+  Scalar sinPhi = 0.F;
+  Scalar cosPhi = 0.F;
+  Scalar sinTheta = 0.F;
+  Scalar cosTheta = 0.F;
+  sincosOf(phi, sinPhi, cosPhi);
+  sincosOf(theta, sinTheta, cosTheta);
+  d[0] = sinTheta * cosPhi;
+  d[1] = sinTheta * sinPhi;
+  d[2] = cosTheta;
+}
+
+/// How one detector's disc chains are made and measured.
+struct DiscSetup {
+  std::vector<LayerID> layers; ///< in the order of flight, from the vertex
+  Scalar bzKiloGauss = 0.F;
+  double sigmaLoc = 0.;            ///< [cm], both directions
+  double x2X0PerCm = 0.;           ///< UniformMaterial along the chain
+  std::size_t minMeasurements = 0; ///< discs the track must leave a measurement on
+};
+
+/// The MFT's ten faces, -45 to -77 cm, at an ALICE run's field, with the
+/// topology dictionary's median error.
+DiscSetup mftFaces() { return {.layers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, .bzKiloGauss = -5.0066791F, .sigmaLoc = 5.5e-4, .x2X0PerCm = 1e-3, .minMeasurements = 5}; }
+
+template <DetectorLayout Det>
+struct DiscChain {
+  const TrackingGeometry<Det>* tracking;
+  DiscSetup setup;
+  Propagator propagator;
+  std::vector<std::vector<SensorID>> sensorsOfStep; ///< per entry of setup.layers
+  std::vector<BoundTrackState> truth;
+  std::vector<Measurement> measurements;
+
+  DiscChain(const TrackingGeometry<Det>& geometry, DiscSetup s) : tracking(&geometry), setup(std::move(s)), sensorsOfStep(setup.layers.size()), truth(1)
+  {
+    propagator.bzKiloGauss = setup.bzKiloGauss;
+    for (SensorID id = 0; id < static_cast<SensorID>(Det::nSensors); ++id) {
+      const auto found = std::ranges::find(setup.layers, tracking->surface(id).layer);
+      if (found != setup.layers.end()) {
+        sensorsOfStep[static_cast<std::size_t>(found - setup.layers.begin())].push_back(id);
+      }
+    }
+  }
+
+  [[nodiscard]] SensorID crossed(const BoundTrackState& state, const TrackingSurface& from, std::size_t step) const
+  {
+    for (const SensorID id : sensorsOfStep[step]) {
+      BoundTrackState probe = state;
+      if (propagate(propagator, probe, from, tracking->surface(id), PropagationDirection::kForward).status == PropagationStatus::kOk) {
+        return id;
+      }
+    }
+    return kInvalidSensorID;
+  }
+
+  /// truth[0] on the first disc's sensor that a straight line from the
+  /// origin at (phi, theta) crosses; false if it crosses none.
+  bool start(Scalar phi, Scalar theta, Scalar qOverP)
+  {
+    Scalar d[3];
+    directionFromAngles(phi, theta, d);
+    for (const SensorID id : sensorsOfStep[0]) {
+      const auto& s = tracking->surface(id);
+      const Scalar along = (s.origin[0] * s.normal[0]) + (s.origin[1] * s.normal[1]) + (s.origin[2] * s.normal[2]);
+      const Scalar t = along / cosIncidence(s, d);
+      const Scalar g[3]{t * d[0], t * d[1], t * d[2]};
+      Scalar l[3];
+      surfaceToLocal(s, g, l);
+      if (t > 0.F && s.bounds.isInside(l[0], l[1])) {
+        truth[0] = BoundTrackState{};
+        truth[0].par[kLoc0] = l[0];
+        truth[0].par[kLoc1] = l[1];
+        truth[0].par[kPhi] = phi;
+        truth[0].par[kTheta] = theta;
+        truth[0].par[kQOverP] = qOverP;
+        truth[0].surface = id;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /// The rest of the chain from truth[0], scattering if \a scatter. A disc
+  /// the track crosses outside every sensor is passed without a measurement,
+  /// as on the MFT, whose faces each cover part of the circle; the chord of a
+  /// kick then runs to the next measurement, as the fit's does. False if
+  /// fewer than `setup.minMeasurements` remain, or a kick moves the track off
+  /// the sensor it was aimed at.
+  bool generate(bool scatter, std::mt19937& rng)
+  {
+    std::normal_distribution<double> gauss(0., 1.);
+    const auto x2X0PerCm = static_cast<Scalar>(setup.x2X0PerCm);
+    truth.resize(1);
+    for (std::size_t step = 1; step < setup.layers.size(); ++step) {
+      const auto& from = tracking->surface(truth.back().surface);
+      BoundTrackState outgoing = truth.back();
+      const auto unkicked = crossed(outgoing, from, step);
+      if (unkicked == kInvalidSensorID) {
+        continue;
+      }
+      // As the fit models it (`StepMaterial`): half the step's material
+      // kicked on leaving the sensor behind, half on reaching the next, so
+      // truth[k] is the state at sensor k's mid-plane.
+      Scalar theta0Half = 0.F;
+      const auto kick = [&](BoundTrackState& state) {
+        state.par[kTheta] += static_cast<Scalar>(gauss(rng)) * theta0Half;
+        state.par[kPhi] += static_cast<Scalar>(gauss(rng)) * theta0Half / std::sin(state.theta());
+      };
+      if (scatter) {
+        BoundTrackState probe = outgoing;
+        (void)propagate(propagator, probe, from, tracking->surface(unkicked), PropagationDirection::kForward);
+        Scalar a[3]{};
+        Scalar b[3]{};
+        surfaceToGlobal(from, outgoing.loc0(), outgoing.loc1(), a);
+        surfaceToGlobal(tracking->surface(unkicked), probe.loc0(), probe.loc1(), b);
+        const Scalar chord = std::hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+        theta0Half = highlandTheta0(0.5F * x2X0PerCm * chord, betaMomentum(1.F / std::abs(outgoing.qOverP()), propagator.massGeV));
+        kick(outgoing);
+      }
+      const auto id = crossed(outgoing, from, step);
+      if (id == kInvalidSensorID) {
+        return false;
+      }
+      truth.push_back(outgoing);
+      if (propagate(propagator, truth.back(), from, tracking->surface(id), PropagationDirection::kForward).status != PropagationStatus::kOk) {
+        return false;
+      }
+      if (scatter) {
+        kick(truth.back());
+      }
+    }
+    if (truth.size() < setup.minMeasurements) {
+      return false;
+    }
+    const auto var = static_cast<Scalar>(setup.sigmaLoc * setup.sigmaLoc);
+    measurements.clear();
+    for (std::size_t i = 0; i < truth.size(); ++i) {
+      measurements.push_back(Measurement{
+        .loc0 = truth[i].loc0(),
+        .loc1 = truth[i].loc1(),
+        .timePS = test::toyTimeBox(test::kToyTrackTimeNS).start,
+        .widthPS = test::toyTimeBox(test::kToyTrackTimeNS).width,
+        .varLoc0 = var,
+        .covLoc01 = 0.F,
+        .varLoc1 = var,
+        .clusterIndex = static_cast<std::uint32_t>(i),
+        .surface = truth[i].surface,
+      });
+    }
+    return true;
+  }
+};
+
+using namespace test::pulls;
+
+/// How many of MftPullsWithScatteringAreUnit's checks are expected to fail.
+constexpr unsigned kMftExpectedFailures = 39;
+
+template <DetectorLayout Det>
+PullPoint pullsAt(DiscChain<Det>& chain, double ptGeV, double eta, bool withMaterial, int trials, std::uint32_t seed)
+{
+  const UniformMaterial material{.x2X0PerCm = withMaterial ? static_cast<Scalar>(chain.setup.x2X0PerCm) : 0.F};
+  const double theta = 2. * std::atan(std::exp(-eta));
+  const double p = ptGeV / std::sin(theta);
+  std::mt19937 rng(seed);
+  std::normal_distribution<double> gauss(0., 1.);
+  std::uniform_real_distribution<double> uniformPhi(-std::numbers::pi, std::numbers::pi);
+  return collectPulls(chain, ptGeV, eta, trials, [&](int trial) {
+    const Scalar charge = (trial % 2) != 0 ? 1.F : -1.F;
+    bool built = false;
+    // Gaps between sensors lose a good part of the lines; draw again.
+    for (int attempt = 0; attempt < 100 && !built; ++attempt) {
+      built = chain.start(static_cast<Scalar>(uniformPhi(rng)), static_cast<Scalar>(theta), static_cast<Scalar>(static_cast<double>(charge) / p)) && chain.generate(withMaterial, rng);
+    }
+    BOOST_REQUIRE(built);
+    auto smeared = chain.measurements;
+    for (auto& m : smeared) {
+      m.loc0 += static_cast<Scalar>(gauss(rng) * chain.setup.sigmaLoc);
+      m.loc1 += static_cast<Scalar>(gauss(rng) * chain.setup.sigmaLoc);
+    }
+    return fitMeasurements(chain.propagator, *chain.tracking, material, smeared.data(), static_cast<int>(smeared.size()));
+  });
+}
+
+constexpr std::array<double, 5> kPtScan{0.1, 0.2, 0.5, 1., 2.};
+
+template <DetectorLayout Det>
+std::vector<PullPoint> scan(DiscChain<Det>& chain, std::span<const double> etas, bool withMaterial, int trials)
+{
+  std::vector<PullPoint> points;
+  std::uint32_t seed = 20260930;
+  for (const double eta : etas) {
+    for (const double pt : kPtScan) {
+      points.push_back(pullsAt(chain, pt, eta, withMaterial, trials, seed++));
+    }
+  }
+  return points;
+}
+
+/// Every pull width of every point within \a tolerance of one, plain and
+/// robust; every fit a fit with positive variances.
+/// The widths of 1000 unit-Gaussian pulls scatter by about 2 % (plain) and
+/// 4 % (robust); 15 % is far outside that.
+constexpr double kTolerance = 0.15;
+constexpr int kTrials = 1000;
+
+constexpr std::array<double, 3> kMftEtas{-2.6, -3.0, -3.4};
+
+struct Scans {
+  std::vector<PullPoint> clean;
+  std::vector<PullPoint> scattered;
+};
+
+/// Null without `GTRK_ALICE_GEOMETRY`.
+const Scans* mftScans()
+{
+  static const std::unique_ptr<const Scans> scans = []() -> std::unique_ptr<const Scans> {
+    if (geometryFile() == nullptr) {
+      return nullptr;
+    }
+    o2::base::GeometryManager::loadGeometry(geometryFile());
+    const auto geometry = std::make_unique<const Geometry<MFT>>(alice::placeChecked<MFT>());
+    const auto tracking = std::make_unique<const TrackingGeometry<MFT>>(*geometry);
+    DiscChain<MFT> chain(*tracking, mftFaces());
+    auto result = std::make_unique<const Scans>(Scans{.clean = scan(chain, kMftEtas, false, kTrials), .scattered = scan(chain, kMftEtas, true, kTrials)});
+    BOOST_TEST_MESSAGE(report("MFT, no material", result->clean));
+    BOOST_TEST_MESSAGE(report("MFT, 1e-3 X0/cm", result->scattered));
+    return result;
+  }();
+  return scans.get();
+}
+
+} // namespace
+
+/// Without material the MFT's chains fit with unit pulls. A rare fit
+/// loses a variance: with nothing to scatter on, q/p is fixed far
+/// below what a float covariance holds (kChainQOverPSpread, Seed.h). No track
+/// crosses no material, so that one is reported, not asserted.
+BOOST_AUTO_TEST_CASE(MftPullsWithoutMaterialAreUnit)
+{
+  const auto* scans = mftScans();
+  if (scans == nullptr) {
+    BOOST_TEST_MESSAGE("GTRK_ALICE_GEOMETRY not set: the MFT's chains are not fitted");
+    return;
+  }
+  for (const auto& p : scans->clean) {
+    BOOST_TEST_CONTEXT("pT " << p.ptGeV << " eta " << p.eta)
+    {
+      BOOST_TEST(p.failed == 0);
+      for (std::size_t i = 0; i < kNames.size(); ++i) {
+        BOOST_TEST_CONTEXT(kNames[i] << " plain " << p.width[i].plain << " robust " << p.width[i].robust)
+        {
+          BOOST_TEST(std::abs(p.width[i].plain - 1.) < kTolerance);
+          BOOST_TEST(std::abs(p.width[i].robust - 1.) < kTolerance);
+        }
+      }
+    }
+  }
+}
+
+/// The MFT with scattering: the fit takes its scattering at the filtered
+/// momentum, which the MFT alone determines poorly, and where
+/// that momentum runs away the scattering vanishes. The failures are
+/// expected; fewer pass, more fail.
+BOOST_AUTO_TEST_CASE(MftPullsWithScatteringAreUnit, *boost::unit_test::expected_failures(kMftExpectedFailures))
+{
+  const auto* scans = mftScans();
+  if (scans == nullptr) {
+    BOOST_TEST_MESSAGE("GTRK_ALICE_GEOMETRY not set: the MFT's chains are not fitted");
+    return;
+  }
+  checkUnit(scans->scattered, kTolerance);
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/GenericTracking/workflow/test/testGridConfig.cxx b/Detectors/GenericTracking/workflow/test/testGridConfig.cxx
new file mode 100644
index 0000000000000..ae5bf0f874f5c
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/test/testGridConfig.cxx
@@ -0,0 +1,92 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testGridConfig.cxx
+/// \brief The grid's time blocks from the layers' readout frames.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK grid configuration
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Workflow/GridConfig.h"
+#include "GenericTracking/Workflow/RecoParam.h"
+#include "ToyBarrel3.h"
+#include "GenericTracking/Tracking/GridSizing.h"
+#include "GenericTracking/Tracking/MeasurementGrid.h"
+#include "CommonConstants/LHCConstants.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <span>
+#include <vector>
+
+namespace o2::gtrk::workflow
+{
+
+namespace
+{
+
+constexpr std::int64_t kPartsPerPS = kPSPerBCDenominator;
+constexpr std::int64_t kPartsPerBC = kPSPerBCNumerator;
+
+} // namespace
+
+/// With frames of two lengths the blocks are whole frames of the longer,
+/// from its first start; each layer's frames travel with the parameters.
+BOOST_AUTO_TEST_CASE(TheBlocksFollowTheLongestFrame)
+{
+  const RecoSettings param{};
+  BOOST_REQUIRE(param.blockWidthPS == 10'000'000);
+  std::vector<FrameTiming> frames(3U, {.lengthBC = 22, .firstStartBC = 0});
+  frames.resize(11U, {.lengthBC = 81, .firstStartBC = 4});
+  const auto params = gridParams(param, frames);
+  // 10 us is 4.95 frames of 81 BC: five a block.
+  BOOST_TEST(params.partsPerPS == kPartsPerPS);
+  BOOST_TEST(params.blockWidth == kPartsPerBC * 5 * 81);
+  BOOST_TEST(params.blockOrigin == (4 * kPartsPerBC) - kPartsPerPS);
+  BOOST_TEST(std::ranges::equal(frames, std::span{params.frames}.first(frames.size())));
+}
+
+/// One length on every layer: blocks of two readout frames, their edges a
+/// picosecond before the frames' starts. Every frame's box in a 32-orbit
+/// timeframe is binned in its block, and the zero-margin candidate range of a
+/// block's second frame lies in that block.
+BOOST_AUTO_TEST_CASE(OneLengthKeepsItsBlocks)
+{
+  const RecoSettings param{};
+  const std::vector<FrameTiming> frames(7U, {.lengthBC = 198, .firstStartBC = 64});
+  const auto params = gridParams(param, frames);
+  BOOST_TEST(params.blockWidth == kPartsPerBC * 2 * 198);
+  BOOST_TEST(params.blockOrigin == (64 * kPartsPerBC) - kPartsPerPS);
+
+  constexpr std::int64_t kFrameBC = 198;
+  constexpr std::int64_t kFirstBC = 64;
+  constexpr std::int64_t kDurationBC = std::int64_t{32} * o2::constants::lhc::LHCMaxBunches;
+  const IterationSettings settings{};
+  const auto windows = gridLayerWindows<detectors::ToyBarrel3>(std::span{&settings, 1U}, VertexConstraint{});
+  const GridGeometry<detectors::ToyBarrel3> geometry{psOfBC(kDurationBC), params, windows};
+  const auto frameCount = (kDurationBC - kFirstBC) / kFrameBC;
+  for (std::int64_t frame = 0; frame < frameCount; ++frame) {
+    const auto start = kFirstBC + (frame * kFrameBC);
+    const auto block = static_cast<std::int32_t>(frame / 2);
+    const auto box = frameBox(start, start + kFrameBC, 0);
+    BOOST_REQUIRE_EQUAL(geometry.blockOfPS(box.lower()), block);
+    if (frame % 2 == 1) {
+      const LayerPairWindow pair{.phiHalfWidth = 0.1F, .secondHalfWidth = 1.F};
+      const auto window = candidateWindow(pair, box, 0.F, 0.F, 0.F, box.width);
+      BOOST_REQUIRE_EQUAL(geometry.blockOfPS(window.earliestPS), block);
+      BOOST_REQUIRE_EQUAL(geometry.blockOfPS(window.latestPS), block);
+    }
+  }
+  BOOST_TEST(geometry.blockStart(1) == params.blockOrigin + params.blockWidth);
+}
+
+} // namespace o2::gtrk::workflow
diff --git a/Detectors/GenericTracking/workflow/test/testO2Parameters.cxx b/Detectors/GenericTracking/workflow/test/testO2Parameters.cxx
new file mode 100644
index 0000000000000..cae254c2b62bc
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/test/testO2Parameters.cxx
@@ -0,0 +1,309 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testO2Parameters.cxx
+/// \brief A bound state as O2's parameters: the same point, momentum and
+///        charge, and the covariance's Jacobian against finite differences of
+///        the propagator onto O2's plane -- on tilted planes, in every azimuth,
+///        moving outward and inward, at small sin(theta).
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK O2Parameters
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Tracking/Propagator.h"
+#include "GenericTracking/Workflow/O2Parameters.h"
+
+#include <array>
+#include <cmath>
+#include <numbers>
+#include <random>
+
+namespace o2::gtrk::workflow
+{
+namespace
+{
+
+constexpr double kBz = 5.; // the ITS's and the MFT's 0.5 T [kG]
+
+void cross(const double a[3], const double b[3], double out[3])
+{
+  out[0] = (a[1] * b[2]) - (a[2] * b[1]);
+  out[1] = (a[2] * b[0]) - (a[0] * b[2]);
+  out[2] = (a[0] * b[1]) - (a[1] * b[0]);
+}
+
+/// A plane through \a origin with normal \a n (unit) and loc1 along the
+/// component of \a up orthogonal to it.
+TrackingSurface plane(const std::array<double, 3>& origin, const double n[3], const double up[3])
+{
+  const double dot = (up[0] * n[0]) + (up[1] * n[1]) + (up[2] * n[2]);
+  double a1[3] = {up[0] - (dot * n[0]), up[1] - (dot * n[1]), up[2] - (dot * n[2])};
+  const double norm = std::hypot(a1[0], a1[1], a1[2]);
+  for (auto& v : a1) {
+    v /= norm;
+  }
+  double a0[3];
+  cross(a1, n, a0); // axis0 x axis1 = normal
+  TrackingSurface s{};
+  for (int i = 0; i < 3; ++i) {
+    s.origin[i] = static_cast<Scalar>(origin[i]);
+    s.axis0[i] = static_cast<Scalar>(a0[i]);
+    s.axis1[i] = static_cast<Scalar>(a1[i]);
+    s.normal[i] = static_cast<Scalar>(n[i]);
+  }
+  s.bounds = SurfaceBounds{.halfX = 1e6F, .halfY = 1e6F};
+  s.id = 1;
+  return s;
+}
+
+/// A barrel sensor at azimuth \a alpha, radius \a r, its normal tilted by
+/// \a tiltPhi in azimuth and \a tiltZ towards z: alignment.
+TrackingSurface barrelSensor(double alpha, double r, double z, double tiltPhi, double tiltZ)
+{
+  const double n[3] = {std::cos(alpha + tiltPhi) * std::cos(tiltZ), std::sin(alpha + tiltPhi) * std::cos(tiltZ), std::sin(tiltZ)};
+  const double up[3] = {0., 0., 1.};
+  return plane({r * std::cos(alpha), r * std::sin(alpha), z}, n, up);
+}
+
+/// An MFT-like sensor at \a z, its normal +z or -z, tilted by \a tilt.
+TrackingSurface discSensor(double x, double y, double z, double sign, double tilt)
+{
+  const double n[3] = {std::sin(tilt), 0., sign * std::cos(tilt)};
+  const double up[3] = {0., 1., 0.};
+  return plane({x, y, z}, n, up);
+}
+
+BoundTrackState state(double loc0, double loc1, double phi, double theta, double qOverP)
+{
+  BoundTrackState s;
+  s.par[kLoc0] = static_cast<Scalar>(loc0);
+  s.par[kLoc1] = static_cast<Scalar>(loc1);
+  s.par[kPhi] = static_cast<Scalar>(phi);
+  s.par[kTheta] = static_cast<Scalar>(theta);
+  s.par[kQOverP] = static_cast<Scalar>(qOverP);
+  for (int i = 0; i < kNBoundParams; ++i) {
+    s.variance(i) = 1e-4F;
+  }
+  s.surface = 1;
+  return s;
+}
+
+void globalOf(const BoundTrackState& s, const TrackingSurface& p, double r[3], double mom[3])
+{
+  const double pAbs = 1. / std::abs(static_cast<double>(s.qOverP()));
+  for (int i = 0; i < 3; ++i) {
+    r[i] = static_cast<double>(p.origin[i]) + (static_cast<double>(s.loc0()) * p.axis0[i]) + (static_cast<double>(s.loc1()) * p.axis1[i]);
+  }
+  mom[0] = pAbs * std::cos(s.phi()) * std::sin(s.theta());
+  mom[1] = pAbs * std::sin(s.phi()) * std::sin(s.theta());
+  mom[2] = pAbs * std::cos(s.theta());
+}
+
+double cosIncidenceOf(const BoundTrackState& s, const TrackingSurface& p) { return (p.normal[0] * std::cos(s.phi()) * std::sin(s.theta())) + (p.normal[1] * std::sin(s.phi()) * std::sin(s.theta())) + (p.normal[2] * std::cos(s.theta())); }
+
+/// The state propagated onto \a to: forward, else backward (the points are on
+/// both sides at a perturbation's distance).
+bool onto(BoundTrackState& s, const TrackingSurface& from, const TrackingSurface& to)
+{
+  Propagator prop;
+  prop.bzKiloGauss = static_cast<Scalar>(kBz);
+  auto copy = s;
+  if (propagate(prop, copy, from, to, PropagationDirection::kForward).status == PropagationStatus::kOk) {
+    s = copy;
+    return true;
+  }
+  copy = s;
+  if (propagate(prop, copy, from, to, PropagationDirection::kBackward).status == PropagationStatus::kOk) {
+    s = copy;
+    return true;
+  }
+  return false;
+}
+
+/// The O2 parameters of a state already on O2's plane \a target.
+std::array<double, 5> barrelParams(const BoundTrackState& s, const TrackingSurface& target, double alpha)
+{
+  const auto t = toTrackParCov(s, target, alpha, kBz);
+  return {t.getY(), t.getZ(), t.getSnp(), t.getTgl(), t.getQ2Pt()};
+}
+
+std::array<double, 5> forwardParams(const BoundTrackState& s, const TrackingSurface& target)
+{
+  const auto t = toTrackParCovFwd(s, target, kBz, 0.);
+  return {t.getX(), t.getY(), t.getPhi(), t.getTanl(), t.getInvQPt()};
+}
+
+/// The Jacobian's columns by central differences: each parameter moved by
+/// +-h, propagated from \a from onto \a target, written as O2's.
+template <typename Params>
+detail::Jacobian finiteDifferences(const BoundTrackState& s, const TrackingSurface& from, const TrackingSurface& target, Params params, bool& ok)
+{
+  const std::array<double, kNBoundParams> steps{2e-3, 2e-3, 2e-4, 2e-4, 1e-3 * std::abs(static_cast<double>(s.qOverP()))};
+  detail::Jacobian jac{};
+  ok = true;
+  for (int k = 0; k < kNBoundParams; ++k) {
+    auto plus = s;
+    auto minus = s;
+    plus.par[k] += static_cast<Scalar>(steps[k]);
+    minus.par[k] -= static_cast<Scalar>(steps[k]);
+    const double h = static_cast<double>(plus.par[k]) - static_cast<double>(minus.par[k]); // as stored
+    ok = ok && onto(plus, from, target) && onto(minus, from, target);
+    if (!ok) {
+      return jac;
+    }
+    const auto p = params(plus);
+    const auto m = params(minus);
+    for (int i = 0; i < kNBoundParams; ++i) {
+      double d = p[i] - m[i];
+      if (i == 2 && d > std::numbers::pi) { // a forward phi across its seam
+        d -= 2. * std::numbers::pi;
+      } else if (i == 2 && d < -std::numbers::pi) {
+        d += 2. * std::numbers::pi;
+      }
+      jac[i][k] = d / h;
+    }
+  }
+  return jac;
+}
+
+void requireClose(const detail::Jacobian& analytic, const detail::Jacobian& numeric)
+{
+  for (int i = 0; i < kNBoundParams; ++i) {
+    for (int k = 0; k < kNBoundParams; ++k) {
+      BOOST_TEST_CONTEXT("d" << i << "/d" << k << ": analytic " << analytic[i][k] << ", numeric " << numeric[i][k]) { BOOST_TEST(std::abs(analytic[i][k] - numeric[i][k]) <= 2e-4 + (1e-2 * std::abs(analytic[i][k]))); }
+    }
+  }
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(BarrelParametersAreTheStatesPointMomentumAndCharge)
+{
+  std::mt19937 random{4711U};
+  std::uniform_real_distribution<double> uniform{0., 1.};
+  unsigned inward = 0U;
+  unsigned tested = 0U;
+  while (tested < 2000U) {
+    const double sensorAlpha = (2. * uniform(random) - 1.) * std::numbers::pi;
+    const auto p = barrelSensor(sensorAlpha, 2. + (40. * uniform(random)), 30. * (uniform(random) - 0.5), 0.2 * (uniform(random) - 0.5), 0.05 * (uniform(random) - 0.5));
+    const auto s = state(1.5 * (uniform(random) - 0.5), 10. * (uniform(random) - 0.5), (2. * uniform(random) - 1.) * std::numbers::pi, 0.1 + (2.94 * uniform(random)), (uniform(random) < 0.5 ? -1. : 1.) * (0.1 + (10. * uniform(random))));
+    if (std::abs(cosIncidenceOf(s, p)) < 0.05) {
+      continue;
+    }
+    ++tested;
+    const double alpha = frameAlpha(s, sensorAlpha);
+    BOOST_TEST(alpha >= -std::numbers::pi);
+    BOOST_TEST(alpha < std::numbers::pi);
+    inward += std::abs(std::remainder(alpha - sensorAlpha, 2. * std::numbers::pi)) > 1. ? 1U : 0U;
+    const auto t = toTrackParCov(s, p, alpha, kBz);
+    double r[3];
+    double mom[3];
+    globalOf(s, p, r, mom);
+    const auto xyz = t.getXYZGlo();
+    std::array<float, 3> pxyz{};
+    BOOST_TEST(t.getPxPyPzGlo(pxyz));
+    BOOST_TEST(std::abs(xyz.X() - r[0]) < 1e-4);
+    BOOST_TEST(std::abs(xyz.Y() - r[1]) < 1e-4);
+    BOOST_TEST(std::abs(xyz.Z() - r[2]) < 1e-4);
+    for (int i = 0; i < 3; ++i) {
+      BOOST_TEST(std::abs(pxyz[i] - mom[i]) <= 1e-5 * (1. + std::hypot(mom[0], mom[1], mom[2])));
+    }
+    BOOST_TEST(t.getSign() == (s.qOverP() > 0.F ? 1 : -1));
+  }
+  // Both branches were taken: the frame turns for states moving inward.
+  BOOST_TEST(inward > 100U);
+}
+
+BOOST_AUTO_TEST_CASE(ForwardParametersAreTheStatesPointMomentumAndCharge)
+{
+  std::mt19937 random{4712U};
+  std::uniform_real_distribution<double> uniform{0., 1.};
+  for (int n = 0; n < 2000; ++n) {
+    const auto p = discSensor(20. * (uniform(random) - 0.5), 20. * (uniform(random) - 0.5), -45. - (30. * uniform(random)), uniform(random) < 0.5 ? -1. : 1., 0.02 * (uniform(random) - 0.5));
+    // Towards the muon arm, sin(theta) down to 0.05; some moving back.
+    const double theta = uniform(random) < 0.9 ? std::numbers::pi - 0.05 - (0.6 * uniform(random)) : 0.05 + (0.6 * uniform(random));
+    const auto s = state(1.5 * (uniform(random) - 0.5), 0.7 * (uniform(random) - 0.5), (2. * uniform(random) - 1.) * std::numbers::pi, theta, (uniform(random) < 0.5 ? -1. : 1.) * (0.1 + (10. * uniform(random))));
+    const auto t = toTrackParCovFwd(s, p, kBz, 3.5);
+    double r[3];
+    double mom[3];
+    globalOf(s, p, r, mom);
+    BOOST_TEST(std::abs(t.getX() - r[0]) < 1e-9);
+    BOOST_TEST(std::abs(t.getY() - r[1]) < 1e-9);
+    BOOST_TEST(std::abs(t.getZ() - r[2]) < 1e-9);
+    BOOST_TEST(std::abs(t.getPx() - mom[0]) <= 1e-7 * std::hypot(mom[0], mom[1], mom[2]));
+    BOOST_TEST(std::abs(t.getPy() - mom[1]) <= 1e-7 * std::hypot(mom[0], mom[1], mom[2]));
+    BOOST_TEST(std::abs(t.getPz() - mom[2]) <= 1e-7 * std::hypot(mom[0], mom[1], mom[2]));
+    BOOST_TEST(t.getCharge() == (s.qOverP() > 0.F ? 1 : -1));
+    BOOST_TEST(t.getTrackChi2() == 3.5);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(BarrelJacobianIsThePropagatorsOntoTheFrame)
+{
+  std::mt19937 random{4713U};
+  std::uniform_real_distribution<double> uniform{0., 1.};
+  unsigned tested = 0U;
+  for (int n = 0; n < 4000 && tested < 400U; ++n) {
+    const double sensorAlpha = (2. * uniform(random) - 1.) * std::numbers::pi;
+    const auto p = barrelSensor(sensorAlpha, 3. + (40. * uniform(random)), 20. * (uniform(random) - 0.5), 1.2 * (uniform(random) - 0.5), 0.6 * (uniform(random) - 0.5));
+    const auto s = state(1.5 * (uniform(random) - 0.5), 10. * (uniform(random) - 0.5), (2. * uniform(random) - 1.) * std::numbers::pi, 0.3 + (2.54 * uniform(random)), (uniform(random) < 0.5 ? -1. : 1.) * (0.1 + (8. * uniform(random))));
+    if (std::abs(cosIncidenceOf(s, p)) < 0.2) {
+      continue;
+    }
+    const double alpha = frameAlpha(s, sensorAlpha);
+    if (std::cos(static_cast<double>(s.phi()) - alpha) < 0.2) {
+      continue;
+    }
+    double r[3];
+    double mom[3];
+    globalOf(s, p, r, mom);
+    const double e[3] = {std::cos(alpha), std::sin(alpha), 0.};
+    const double up[3] = {0., 0., 1.};
+    const auto target = plane({r[0], r[1], r[2]}, e, up);
+    bool ok = false;
+    const auto numeric = finiteDifferences(s, p, target, [&](const BoundTrackState& at) { return barrelParams(at, target, alpha); }, ok);
+    if (!ok) {
+      continue;
+    }
+    ++tested;
+    BOOST_TEST_CONTEXT("sensor alpha " << sensorAlpha << ", frame alpha " << alpha << ", phi " << s.phi() << ", theta " << s.theta() << ", q/p " << s.qOverP()) { requireClose(detail::barrelJacobian(s, detail::shiftOnto(s, p, e, kBz), alpha), numeric); }
+  }
+  BOOST_TEST(tested >= 400U);
+}
+
+BOOST_AUTO_TEST_CASE(ForwardJacobianIsThePropagatorsOntoFixedZ)
+{
+  std::mt19937 random{4714U};
+  std::uniform_real_distribution<double> uniform{0., 1.};
+  unsigned tested = 0U;
+  for (int n = 0; n < 4000 && tested < 400U; ++n) {
+    const auto p = discSensor(20. * (uniform(random) - 0.5), 20. * (uniform(random) - 0.5), -45. - (30. * uniform(random)), uniform(random) < 0.5 ? -1. : 1., 0.6 * (uniform(random) - 0.5));
+    const double theta = std::numbers::pi - 0.1 - (0.6 * uniform(random));
+    const auto s = state(1.5 * (uniform(random) - 0.5), 0.7 * (uniform(random) - 0.5), (2. * uniform(random) - 1.) * std::numbers::pi, theta, (uniform(random) < 0.5 ? -1. : 1.) * (0.1 + (8. * uniform(random))));
+    double r[3];
+    double mom[3];
+    globalOf(s, p, r, mom);
+    const double e[3] = {0., 0., 1.};
+    const double up[3] = {0., 1., 0.};
+    const auto target = plane({r[0], r[1], r[2]}, e, up);
+    bool ok = false;
+    const auto numeric = finiteDifferences(s, p, target, [&](const BoundTrackState& at) { return forwardParams(at, target); }, ok);
+    if (!ok) {
+      continue;
+    }
+    ++tested;
+    BOOST_TEST_CONTEXT("phi " << s.phi() << ", theta " << s.theta() << ", q/p " << s.qOverP()) { requireClose(detail::forwardJacobian(s, detail::shiftOnto(s, p, e, kBz)), numeric); }
+  }
+  BOOST_TEST(tested >= 400U);
+}
+
+} // namespace o2::gtrk::workflow
diff --git a/Detectors/GenericTracking/workflow/test/testTrackerMemoryPool.cxx b/Detectors/GenericTracking/workflow/test/testTrackerMemoryPool.cxx
new file mode 100644
index 0000000000000..3afade61a4b00
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/test/testTrackerMemoryPool.cxx
@@ -0,0 +1,49 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTrackerMemoryPool.cxx
+/// \brief The tracker's memory pool from GTRKRecoITS.memoryLimitGB.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK tracker memory pool
+#include <boost/test/unit_test.hpp>
+
+#include "GenericTracking/Base/BoundedAllocator.h"
+#include "GenericTracking/Workflow/GridConfig.h"
+#include "GenericTracking/Workflow/RecoParam.h"
+
+#include "CommonUtils/ConfigurableParam.h"
+
+#include <cstddef>
+#include <limits>
+#include <new>
+
+namespace o2::gtrk::workflow
+{
+
+BOOST_AUTO_TEST_CASE(NoLimitByDefault)
+{
+  BOOST_TEST(recoParam<detectors::ITS>().memoryLimitGB == 0.);
+  BOOST_TEST(trackerMemoryPool(recoParam<detectors::ITS>())->getMaxMemory() == std::numeric_limits<std::size_t>::max());
+}
+
+BOOST_AUTO_TEST_CASE(TheLimitBoundsThePool)
+{
+  o2::conf::ConfigurableParam::updateFromString("GTRKRecoITS.memoryLimitGB=0.5");
+  const auto pool = trackerMemoryPool(recoParam<detectors::ITS>());
+  BOOST_TEST(pool->getMaxMemory() == std::size_t{512} * 1024U * 1024U);
+  BoundedVector<std::byte> past{pool.get()};
+  BOOST_CHECK_THROW(past.resize(std::size_t{513} * 1024U * 1024U), std::bad_alloc);
+  BOOST_TEST(pool->getUsedMemory() == 0U);
+  o2::conf::ConfigurableParam::updateFromString("GTRKRecoITS.memoryLimitGB=0");
+}
+
+} // namespace o2::gtrk::workflow
diff --git a/Detectors/GenericTracking/workflow/test/testTrkChainPulls.cxx b/Detectors/GenericTracking/workflow/test/testTrkChainPulls.cxx
new file mode 100644
index 0000000000000..4a4b72ccd17d2
--- /dev/null
+++ b/Detectors/GenericTracking/workflow/test/testTrkChainPulls.cxx
@@ -0,0 +1,735 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testTrkChainPulls.cxx
+/// \brief Fit pulls of chains through the ALICE 3 barrel, curved VD included,
+///        and the TRK's readout frames, and on to FT3's discs.
+///
+/// The chains are made as testDiscChainPulls.cxx makes its own: a straight
+/// line from the origin picks the first VD sensor, then the helix crosses the
+/// barrel layer by layer at 2 T -- or, forward, the VD, the ML layers it still
+/// reaches and the +z discs: each step goes to the layer it crosses first --
+/// scattering at every sensor but the last as a
+/// thin scatterer carrying the material of the step outward of it, as the fit
+/// models it. A VD crossing is bound to the sensor's tangent plane at the
+/// crossing (BoundTrackState::surfacePhi), found by moving the plane to where
+/// the track meets it until the two agree; a measurement there keeps its
+/// unrolled coordinates, so the fit finds the same plane from it
+/// (TrackingGeometry::planeOf). Each measurement is smeared by exactly the
+/// covariance it is given, a pixel's pitch^2 / 12 -- not the hit's exact
+/// crossing, whose pulls would be narrow however right the geometry
+/// -- and the fitted state on the first measurement's plane is
+/// held to truth[0].
+///
+/// Runs with `GTRK_ALICE3_GEOMETRY` naming an o2sim geometry with the TRK;
+/// without it, it reports that it did not. The pulls are
+/// asserted with scattering and without material, barrel and forward, to
+/// pT 20 GeV (200 GeV of momentum at |eta| 3): the fit carries its covariance
+/// as factors (CovarianceFactors), and holds what a float covariance could not.
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE Test GTRK TRK
+#include <boost/test/unit_test.hpp>
+#include "PullStatistics.h"
+
+#include "BetweenBoundCheck.h"
+#include "GridTestSupport.h"
+
+#include "GenericTracking/Alice/Placement.h"
+#include "GenericTracking/Alice/TRK.h"
+#include "GenericTracking/Base/Geometry.h"
+#include "GenericTracking/Detectors/TRKFT3.h"
+#include "GenericTracking/Tracking/LayerMaterial.h"
+#include "GenericTracking/Tracking/Material.h"
+#include "GenericTracking/Tracking/TrackFitter.h"
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "DetectorsBase/GeometryManager.h"
+#include "UniformMaterial.h"
+
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <memory>
+#include <numbers>
+#include <optional>
+#include <random>
+#include <span>
+#include <string>
+#include <unistd.h>
+#include <vector>
+
+namespace o2::gtrk
+{
+
+namespace
+{
+
+using detectors::TRKFT3;
+
+const char* geometryFile() { return std::getenv("GTRK_ALICE3_GEOMETRY"); }
+
+constexpr Scalar kBzKiloGauss = 20.F;
+constexpr double kX2X0PerCm = 1e-3;
+constexpr std::size_t kMinMeasurements = 8; ///< the VD's three and the ML's five
+/// Forward: the VD's three and three discs. At |eta| 3 a track leaves the VD
+/// at its end, passes the ML and falls through the inner holes of two discs.
+constexpr std::size_t kMinForwardMeasurements = 6;
+
+/// Where a state meets a curved sensor: the tangent plane at the angle the
+/// track crosses it, found by moving the plane to where the propagated track
+/// meets it. Each round halves the angle's error many times over (the plane
+/// and the cylinder part by the sagitta), so a few rounds reach float.
+std::optional<std::pair<BoundTrackState, Scalar>> toCylinder(const Propagator& propagator, const BoundTrackState& state, const TrackingSurface& from, const TrackingSurface& cylinder, Scalar angle)
+{
+  BoundTrackState probe = state;
+  for (int round = 0; round < 6; ++round) {
+    probe = state;
+    const auto plane = tangentPlane(cylinder, angle);
+    const auto status = propagate(propagator, probe, from, plane, PropagationDirection::kForward).status;
+    if (status != PropagationStatus::kOk && status != PropagationStatus::kOutOfBounds) {
+      return std::nullopt;
+    }
+    Scalar global[3];
+    surfaceToGlobal(plane, probe.loc0(), probe.loc1(), global);
+    Scalar d[3];
+    for (int i = 0; i < 3; ++i) {
+      d[i] = global[i] - cylinder.origin[i];
+    }
+    const Scalar x = (d[0] * cylinder.axis0[0]) + (d[1] * cylinder.axis0[1]) + (d[2] * cylinder.axis0[2]);
+    const Scalar y = (d[0] * cylinder.axis1[0]) + (d[1] * cylinder.axis1[1]) + (d[2] * cylinder.axis1[2]);
+    angle = std::atan2(y, x);
+  }
+  return std::pair{probe, angle};
+}
+
+/// A sensor's centre in the global frame, and where its layer is crossed.
+struct Candidate {
+  SensorID id;
+  double z;
+  double phi;
+};
+
+struct BarrelChain {
+  const Geometry<TRKFT3>* geometry;
+  const TrackingGeometry<TRKFT3>* tracking;
+  Propagator propagator;
+  std::array<std::vector<Candidate>, Detector<TRKFT3>::nLayers> sensorsOfLayer;
+  std::vector<BoundTrackState> truth;
+  std::vector<Measurement> measurements;
+
+  BarrelChain(const Geometry<TRKFT3>& geo, const TrackingGeometry<TRKFT3>& trk) : geometry(&geo), tracking(&trk), truth(1)
+  {
+    propagator.bzKiloGauss = kBzKiloGauss;
+    for (SensorID id = 0; id < static_cast<SensorID>(TRKFT3::nSensors); ++id) {
+      const auto& sensor = geo.sensor(id);
+      sensorsOfLayer[sensor.layer].push_back({.id = id, .z = sensor.trans[2], .phi = std::atan2(sensor.trans[1], sensor.trans[0])});
+    }
+  }
+
+  [[nodiscard]] static bool curved(LayerID layer) { return Geometry<TRKFT3>::layerSpec(layer).curved(); }
+
+  /// The curved sensor of \a layer whose arc holds the global azimuth
+  /// \a phi, with that azimuth as its local angle; nothing if none does.
+  [[nodiscard]] std::optional<std::pair<SensorID, Scalar>> petalAt(LayerID layer, Scalar phi) const
+  {
+    for (const auto& candidate : sensorsOfLayer[layer]) {
+      const auto& c = tracking->surface(candidate.id);
+      // The direction at phi in the sensor's frame: against its local x and y.
+      const Scalar x = (std::cos(phi) * c.axis0[0]) + (std::sin(phi) * c.axis0[1]);
+      const Scalar y = (std::cos(phi) * c.axis1[0]) + (std::sin(phi) * c.axis1[1]);
+      const Scalar angle = std::atan2(y, x);
+      if (std::abs(angle) * c.radius <= c.bounds.halfX) {
+        return std::pair{candidate.id, angle};
+      }
+    }
+    return std::nullopt;
+  }
+
+  /// The state on the sensor of \a layer the track crosses next; nothing if
+  /// it crosses none.
+  [[nodiscard]] std::optional<BoundTrackState> cross(const BoundTrackState& state, LayerID layer) const
+  {
+    const auto from = tracking->planeOf(state);
+    Scalar global[3];
+    surfaceToGlobal(from, state.loc0(), state.loc1(), global);
+    if (!Detector<TRKFT3>::isBarrelLayer(layer)) {
+      return crossDisc(state, from, layer);
+    }
+    if (curved(layer)) {
+      // Start the plane where the track points, then move it onto the crossing.
+      const auto petal = petalAt(layer, state.phi());
+      if (!petal) {
+        return std::nullopt;
+      }
+      const auto& cylinder = tracking->surface(petal->first);
+      const auto found = toCylinder(propagator, state, from, cylinder, petal->second);
+      if (!found || std::abs(found->second) * cylinder.radius > cylinder.bounds.halfX) {
+        return std::nullopt;
+      }
+      BoundTrackState result = state;
+      if (propagate(propagator, result, from, tracking->plane(petal->first, found->second), PropagationDirection::kForward).status != PropagationStatus::kOk) {
+        return std::nullopt;
+      }
+      return result;
+    }
+    // A flat layer: the chips near the line's crossing of the layer's radius,
+    // the first one the helix reaches inside its bounds.
+    const auto& envelope = PlacedEnvelopes<TRKFT3>::all()[layer];
+    TrackingSurface ring{};
+    ring.axis0[0] = 1.F;
+    ring.axis1[1] = 1.F;
+    ring.normal[2] = 1.F;
+    ring.radius = static_cast<Scalar>(envelope.position);
+    ring.bounds = {.halfX = 1e9F, .halfY = 1e9F};
+    const auto atRing = toCylinder(propagator, state, from, ring, state.phi());
+    if (!atRing) {
+      return std::nullopt;
+    }
+    Scalar point[3];
+    surfaceToGlobal(tangentPlane(ring, atRing->second), atRing->first.loc0(), atRing->first.loc1(), point);
+    const auto pointPhi = static_cast<double>(std::atan2(point[1], point[0]));
+    std::optional<BoundTrackState> best;
+    Scalar bestPath = std::numeric_limits<Scalar>::infinity();
+    for (const auto& candidate : sensorsOfLayer[layer]) {
+      double dPhi = candidate.phi - pointPhi;
+      math_utils::detail::bringToPMPi<double>(dPhi);
+      if (std::abs(candidate.z - static_cast<double>(point[2])) > 2.5 || std::abs(dPhi) * envelope.position > 2.5) {
+        continue;
+      }
+      BoundTrackState probe = state;
+      const auto result = propagate(propagator, probe, from, tracking->surface(candidate.id), PropagationDirection::kForward);
+      if (result.status == PropagationStatus::kOk && result.pathLength > 0.F && result.pathLength < bestPath) {
+        bestPath = result.pathLength;
+        best = probe;
+      }
+    }
+    return best;
+  }
+
+  /// A disc: the chips near where the track meets the disc's plane, the first
+  /// one the helix reaches inside its bounds.
+  [[nodiscard]] std::optional<BoundTrackState> crossDisc(const BoundTrackState& state, const TrackingSurface& from, LayerID layer) const
+  {
+    TrackingSurface plane{};
+    plane.axis0[0] = 1.F;
+    plane.axis1[1] = 1.F;
+    plane.normal[2] = 1.F;
+    plane.origin[2] = static_cast<Scalar>(PlacedEnvelopes<TRKFT3>::all()[layer].position);
+    plane.bounds = {.halfX = 1e9F, .halfY = 1e9F};
+    BoundTrackState atPlane = state;
+    if (propagate(propagator, atPlane, from, plane, PropagationDirection::kForward).status != PropagationStatus::kOk) {
+      return std::nullopt;
+    }
+    Scalar point[3];
+    surfaceToGlobal(plane, atPlane.loc0(), atPlane.loc1(), point);
+    std::optional<BoundTrackState> best;
+    Scalar bestPath = std::numeric_limits<Scalar>::infinity();
+    for (const auto& candidate : sensorsOfLayer[layer]) {
+      const auto& sensor = geometry->sensor(candidate.id);
+      if (std::hypot(sensor.trans[0] - static_cast<double>(point[0]), sensor.trans[1] - static_cast<double>(point[1])) > 2.5) {
+        continue;
+      }
+      BoundTrackState probe = state;
+      const auto result = propagate(propagator, probe, from, tracking->surface(candidate.id), PropagationDirection::kForward);
+      if (result.status == PropagationStatus::kOk && result.pathLength > 0.F && result.pathLength < bestPath) {
+        bestPath = result.pathLength;
+        best = probe;
+      }
+    }
+    return best;
+  }
+
+  /// truth[0] on the VD sensor of layer 0 a straight line from (0, 0, z0)
+  /// at (phi, theta) crosses; false if it crosses none.
+  bool start(Scalar phi, Scalar theta, Scalar qOverP, Scalar z0)
+  {
+    const auto petal = petalAt(0, phi);
+    if (!petal) {
+      return false;
+    }
+    const auto plane = tracking->plane(petal->first, petal->second);
+    const auto& cylinder = tracking->surface(petal->first);
+    const Scalar t = cylinder.radius / std::sin(theta);
+    const Scalar g[3]{t * std::sin(theta) * std::cos(phi), t * std::sin(theta) * std::sin(phi), z0 + (t * std::cos(theta))};
+    Scalar l[3];
+    surfaceToLocal(plane, g, l);
+    if (!plane.bounds.isInside(l[0], l[1])) {
+      return false;
+    }
+    truth[0] = BoundTrackState{};
+    truth[0].par[kLoc0] = l[0];
+    truth[0].par[kLoc1] = l[1];
+    truth[0].par[kPhi] = phi;
+    truth[0].par[kTheta] = theta;
+    truth[0].par[kQOverP] = qOverP;
+    truth[0].surface = petal->first;
+    truth[0].surfacePhi = petal->second;
+    return true;
+  }
+
+  /// Where \a state is, globally.
+  [[nodiscard]] std::array<Scalar, 3> globalOf(const BoundTrackState& state) const
+  {
+    std::array<Scalar, 3> g{};
+    surfaceToGlobal(tracking->planeOf(state), state.loc0(), state.loc1(), g.data());
+    return g;
+  }
+
+  /// The layers a chain may cross after layer 0, in order: the barrel's, then
+  /// with \a forward the +z discs.
+  [[nodiscard]] static std::vector<LayerID> sequence(bool forward)
+  {
+    std::vector<LayerID> layers;
+    for (LayerID layer = 1; std::cmp_less(layer, Detector<TRKFT3>::nBarrelLayers); ++layer) {
+      layers.push_back(layer);
+    }
+    if (forward) {
+      // FT3's order: six discs at -z, then their mirrors at +z.
+      for (int disc = 6; disc < Detector<TRKFT3>::nDiscLayers; ++disc) {
+        layers.push_back(static_cast<LayerID>(Detector<TRKFT3>::nBarrelLayers + disc));
+      }
+    }
+    return layers;
+  }
+
+  /// The rest of the chain from truth[0], scattering if \a scatter: each step
+  /// to the layer of \a layers, after the last one crossed, that the track
+  /// crosses first; false if fewer than \a minMeasurements remain.
+  bool generate(bool scatter, std::mt19937& rng, std::span<const LayerID> layers, std::size_t minMeasurements)
+  {
+    std::normal_distribution<double> gauss(0., 1.);
+    truth.resize(1);
+    std::size_t next = 0;
+    while (next < layers.size()) {
+      BoundTrackState outgoing = truth.back();
+      const auto here = globalOf(outgoing);
+      std::optional<BoundTrackState> unkicked;
+      std::size_t chosen = layers.size();
+      Scalar nearest = std::numeric_limits<Scalar>::infinity();
+      for (std::size_t i = next; i < layers.size(); ++i) {
+        const auto crossing = cross(outgoing, layers[i]);
+        if (!crossing) {
+          continue;
+        }
+        const auto there = globalOf(*crossing);
+        const Scalar distance = std::hypot(there[0] - here[0], there[1] - here[1], there[2] - here[2]);
+        if (distance < nearest) {
+          nearest = distance;
+          unkicked = crossing;
+          chosen = i;
+        }
+      }
+      if (!unkicked) {
+        break;
+      }
+      const LayerID layer = layers[chosen];
+      next = chosen + 1;
+      Scalar theta0Half = 0.F;
+      const auto kick = [&](BoundTrackState& state) {
+        state.par[kTheta] += static_cast<Scalar>(gauss(rng)) * theta0Half;
+        state.par[kPhi] += static_cast<Scalar>(gauss(rng)) * theta0Half / std::sin(state.theta());
+      };
+      if (scatter) {
+        Scalar a[3]{};
+        Scalar b[3]{};
+        surfaceToGlobal(tracking->planeOf(outgoing), outgoing.loc0(), outgoing.loc1(), a);
+        surfaceToGlobal(tracking->planeOf(*unkicked), unkicked->loc0(), unkicked->loc1(), b);
+        const Scalar chord = std::hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+        theta0Half = highlandTheta0(0.5F * static_cast<Scalar>(kX2X0PerCm) * chord, betaMomentum(1.F / std::abs(outgoing.qOverP()), propagator.massGeV));
+        kick(outgoing);
+      }
+      auto crossed = cross(outgoing, layer);
+      if (!crossed) {
+        break;
+      }
+      if (scatter) {
+        kick(*crossed);
+      }
+      truth.push_back(*crossed);
+    }
+    if (truth.size() < minMeasurements) {
+      return false;
+    }
+    measurements.clear();
+    for (std::size_t i = 0; i < truth.size(); ++i) {
+      const auto& spec = Geometry<TRKFT3>::layerSpec(tracking->surface(truth[i].surface).layer);
+      const auto var = static_cast<Scalar>(spec.pitchX * spec.pitchX / 12.);
+      measurements.push_back(Measurement{
+        .loc0 = truth[i].loc0(),
+        .loc1 = truth[i].loc1(),
+        .timePS = test::toyTimeBox(test::kToyTrackTimeNS).start,
+        .widthPS = test::toyTimeBox(test::kToyTrackTimeNS).width,
+        .varLoc0 = var,
+        .covLoc01 = 0.F,
+        .varLoc1 = var,
+        .clusterIndex = static_cast<std::uint32_t>(i),
+        .surface = truth[i].surface,
+      });
+    }
+    return true;
+  }
+};
+
+using namespace test::pulls;
+
+PullPoint pullsAt(BarrelChain& chain, double ptGeV, double eta, bool withMaterial, int trials, std::uint32_t seed)
+{
+  const bool forward = eta > 1.5;
+  const auto layers = BarrelChain::sequence(forward);
+  const UniformMaterial material{.x2X0PerCm = withMaterial ? static_cast<Scalar>(kX2X0PerCm) : 0.F};
+  const double theta = 2. * std::atan(std::exp(-eta));
+  const double p = ptGeV / std::sin(theta);
+  std::mt19937 rng(seed);
+  std::normal_distribution<double> gauss(0., 1.);
+  std::uniform_real_distribution<double> uniformPhi(-std::numbers::pi, std::numbers::pi);
+  // Vertices along the beam, so that the chains cross the chips everywhere
+  // and not all on the seams between them at z = 0.
+  std::uniform_real_distribution<double> uniformZ(-5., 5.);
+  return collectPulls(chain, ptGeV, eta, trials, [&](int trial) {
+    const Scalar charge = (trial % 2) != 0 ? 1.F : -1.F;
+    bool built = false;
+    // Gaps between petals and chips lose some lines; draw again. At |eta| 3
+    // most lines fall through the discs' inner holes, hence the many draws.
+    for (int attempt = 0; attempt < 1000 && !built; ++attempt) {
+      built = chain.start(static_cast<Scalar>(uniformPhi(rng)), static_cast<Scalar>(theta), static_cast<Scalar>(static_cast<double>(charge) / p), static_cast<Scalar>(uniformZ(rng))) && chain.generate(withMaterial, rng, layers, forward ? kMinForwardMeasurements : kMinMeasurements);
+    }
+    BOOST_REQUIRE_MESSAGE(built, "no chain in 1000 draws at pT " << ptGeV << " eta " << eta << (withMaterial ? "" : ", no material"));
+    auto smeared = chain.measurements;
+    for (auto& m : smeared) {
+      m.loc0 += static_cast<Scalar>(gauss(rng)) * std::sqrt(m.varLoc0);
+      m.loc1 += static_cast<Scalar>(gauss(rng)) * std::sqrt(m.varLoc1);
+    }
+    return fitMeasurements(chain.propagator, *chain.tracking, material, smeared.data(), static_cast<int>(smeared.size()));
+  });
+}
+
+/// From where a 2 T track still crosses the ML (0.2 GeV curls at 33 cm), to
+/// where it is nearly straight; at |eta| the OT still covers.
+constexpr std::array<double, 5> kPtScan{0.2, 0.5, 1., 5., 20.};
+constexpr std::array<double, 3> kEtas{0., 0.6, 1.1};
+/// Forward: through the VD and the inner ML onto FT3's +z discs (their |eta|
+/// 1.5-3.2). At high momentum there a float covariance cannot hold the track
+/// (VD to VD at |eta| 3 moves loc1 by 71 cm per radian of theta); the fit
+/// carries it as factors.
+constexpr std::array<double, 5> kForwardPtScan{0.2, 0.5, 1., 5., 20.};
+constexpr std::array<double, 3> kForwardEtas{2., 2.5, 3.};
+/// The widths of n unit-Gaussian pulls scatter by 1 / sqrt(2 n) (plain) and
+/// about 1.6 times that (robust, the median's): at 2000, 1.6 % and 2.6 %, so
+/// 15 % is beyond 5 sigma of either over the scan's 600 widths.
+constexpr int kTrials = 2000;
+constexpr double kTolerance = 0.15;
+
+struct Scans {
+  std::vector<PullPoint> clean;
+  std::vector<PullPoint> scattered;
+  std::vector<PullPoint> forwardClean;
+  std::vector<PullPoint> forwardScattered;
+};
+
+/// Null without `GTRK_ALICE3_GEOMETRY`.
+const Scans* scans()
+{
+  static const std::unique_ptr<const Scans> result = []() -> std::unique_ptr<const Scans> {
+    if (geometryFile() == nullptr) {
+      return nullptr;
+    }
+    o2::base::GeometryManager::loadGeometry(geometryFile());
+    const auto geometry = std::make_unique<const Geometry<TRKFT3>>(alice::placeChecked<TRKFT3>());
+    const auto tracking = std::make_unique<const TrackingGeometry<TRKFT3>>(*geometry);
+    BarrelChain chain(*geometry, *tracking);
+    auto out = std::make_unique<Scans>();
+    std::uint32_t seed = 20261007;
+    std::uint32_t forwardSeed = 20261107; // apart from the barrel's 30 seeds
+    for (const bool withMaterial : {false, true}) {
+      auto& points = withMaterial ? out->scattered : out->clean;
+      for (const double eta : kEtas) {
+        for (const double pt : kPtScan) {
+          points.push_back(pullsAt(chain, pt, eta, withMaterial, kTrials, seed++));
+        }
+      }
+      auto& forward = withMaterial ? out->forwardScattered : out->forwardClean;
+      for (const double eta : kForwardEtas) {
+        for (const double pt : kForwardPtScan) {
+          forward.push_back(pullsAt(chain, pt, eta, withMaterial, kTrials, forwardSeed++));
+        }
+      }
+    }
+    BOOST_TEST_MESSAGE(report("ALICE 3 barrel, no material", out->clean, false));
+    BOOST_TEST_MESSAGE(report("ALICE 3 barrel, 1e-3 X0/cm", out->scattered, false));
+    BOOST_TEST_MESSAGE(report("ALICE 3 forward, onto FT3, no material", out->forwardClean, false));
+    BOOST_TEST_MESSAGE(report("ALICE 3 forward, onto FT3, 1e-3 X0/cm", out->forwardScattered, false));
+    return out;
+  }();
+  return result.get();
+}
+
+void checkUnit(std::span<const PullPoint> points) { test::pulls::checkUnit(points, kTolerance); }
+
+} // namespace
+
+/// A tangent plane is right-handed, radial and touches its sensor where its
+/// angle says, at loc0 = radius * angle.
+/// Every one of the 12 VD sensors: the plane a measurement's unrolled
+/// coordinates name contains that point of the sensor.
+BOOST_AUTO_TEST_CASE(EveryPetalPlacesItsMeasurements)
+{
+  if (geometryFile() == nullptr) {
+    BOOST_TEST_MESSAGE("GTRK_ALICE3_GEOMETRY not set: the TRK is not loaded");
+    return;
+  }
+  o2::base::GeometryManager::loadGeometry(geometryFile());
+  const auto geometry = std::make_unique<const Geometry<TRKFT3>>(alice::placeChecked<TRKFT3>());
+  const auto tracking = std::make_unique<const TrackingGeometry<TRKFT3>>(*geometry);
+  int petals = 0;
+  for (SensorID id = 0; id < static_cast<SensorID>(TRKFT3::nSensors); ++id) {
+    const auto& spec = geometry->specOf(id);
+    if (!spec.curved()) {
+      continue;
+    }
+    ++petals;
+    for (const double u : {-0.99 * spec.halfX, -0.3 * spec.halfX, 0., 0.5 * spec.halfX, 0.99 * spec.halfX}) {
+      const double v = 17.;
+      double frame[3];
+      spec.unrolledToFrame(u, v, 0., frame);
+      double expected[3];
+      geometry->sensor(id).toGlobal(frame, expected);
+      const Measurement m{.loc0 = static_cast<Scalar>(u), .loc1 = static_cast<Scalar>(v), .surface = id};
+      const auto plane = tracking->planeOf(m);
+      Scalar global[3];
+      surfaceToGlobal(plane, m.loc0, m.loc1, global);
+      for (int i = 0; i < 3; ++i) {
+        BOOST_TEST(std::abs(static_cast<double>(global[i]) - expected[i]) < 1e-5); // float, at 25 cm
+      }
+      // The plane's normal is radial there.
+      const double r = std::hypot(expected[0], expected[1]);
+      BOOST_TEST(std::abs((static_cast<double>(plane.normal[0]) * expected[0] / r) + (static_cast<double>(plane.normal[1]) * expected[1] / r) - 1.) < 1e-6);
+    }
+  }
+  BOOST_TEST(petals == 12);
+}
+
+/// With scattering at the fit's own model, chains through the VD's tangent
+/// planes and the ML/OT chips fit with unit pulls.
+BOOST_AUTO_TEST_CASE(BarrelPullsWithScatteringAreUnit)
+{
+  const auto* result = scans();
+  if (result == nullptr) {
+    BOOST_TEST_MESSAGE("GTRK_ALICE3_GEOMETRY not set: the TRK's chains are not fitted");
+    return;
+  }
+  checkUnit(result->scattered);
+}
+
+/// The same forward, through the VD and the inner ML onto FT3's discs.
+BOOST_AUTO_TEST_CASE(DiscPullsWithScatteringAreUnit)
+{
+  const auto* result = scans();
+  if (result == nullptr) {
+    BOOST_TEST_MESSAGE("GTRK_ALICE3_GEOMETRY not set: the TRK's chains are not fitted");
+    return;
+  }
+  checkUnit(result->forwardScattered);
+}
+
+/// No pair's kink between its layers exceeds its link's bound on any link with
+/// one of the measured passives between its layers, at pT 0.1 GeV over a
+/// 5 cm beam spot: the tracklet stage's test at the bound refuses only pairs
+/// the pair's own kink would refuse too.
+BOOST_AUTO_TEST_CASE(NoPairsKinkExceedsItsLinksBound)
+{
+  if (geometryFile() == nullptr) {
+    BOOST_TEST_MESSAGE("GTRK_ALICE3_GEOMETRY not set: the TRK is not loaded");
+    return;
+  }
+  o2::base::GeometryManager::loadGeometry(geometryFile());
+  const auto geometry = std::make_unique<const Geometry<TRKFT3>>(alice::placeChecked<TRKFT3>());
+  SearchWindowParams windows;
+  windows.minPtGeV = 0.1;
+  windows.bzKiloGauss = 20.;
+  const auto scattering = scatteringTable<TRKFT3>(uniformLayerMaterial<TRKFT3>(1.e-3));
+  const auto ratios = test::betweenOverBound<TRKFT3>(scattering, windows, VertexConstraint{.z = 0., .sigmaZ = 5., .sigmaTransverse = 0.005});
+  BOOST_TEST(!ratios.empty());
+  BOOST_TEST(test::segmentMaskMismatches<TRKFT3>(scattering) == 0);
+  for (const auto& ratio : ratios) {
+    BOOST_TEST_CONTEXT("link " << static_cast<int>(ratio.from) << " -> " << static_cast<int>(ratio.to))
+    {
+      BOOST_TEST(ratio.worst <= 1.);
+      BOOST_TEST(ratio.maskMismatches == 0);
+      BOOST_TEST(ratio.sourcePartMismatches == 0);
+    }
+  }
+}
+
+/// The material LUT the tracking reads against the geometry it was made from,
+/// band by band as the layout splits the material: each passive's band
+/// (`passiveMaterial`) and each layer's slab (`layerMaterial`, with the
+/// passives its silicon envelope), sampled at the same azimuths and z on both.
+/// The passives' measured x/X0 (TRKFT3.h) is reported beside them. Runs with
+/// `GTRK_ALICE3_MATLUT` naming the LUT and `GTRK_ALICE3_GEOMETRY` the geometry.
+BOOST_AUTO_TEST_CASE(LutHoldsTheGeometrysMaterial)
+{
+  const char* lutFile = std::getenv("GTRK_ALICE3_MATLUT");
+  if (geometryFile() == nullptr || lutFile == nullptr) {
+    BOOST_TEST_MESSAGE("GTRK_ALICE3_GEOMETRY or GTRK_ALICE3_MATLUT not set: the LUT is not held to the geometry");
+    return;
+  }
+  o2::base::GeometryManager::loadGeometry(geometryFile());
+  const auto geometry = std::make_unique<const Geometry<TRKFT3>>(alice::placeChecked<TRKFT3>());
+  const std::unique_ptr<o2::base::MatLayerCylSet> lut{o2::base::MatLayerCylSet::loadFromFile(lutFile)};
+  BOOST_REQUIRE(lut);
+  // The same averages from the geometry, at random azimuths and z, with the
+  // mean's standard error. Some gaps hold thin radial walls -- the petals'
+  // side walls, the OT's quarter-barrel panels -- inside which a radial
+  // segment runs its whole length, and structures that end along z: a regular
+  // grid hits them by aliasing, and the mean is known to its statistical error.
+  struct Estimate {
+    double mean;
+    double error;
+  };
+  std::mt19937 rng(20261007);
+  std::uniform_real_distribution<double> uniformPhi(0., 2. * std::numbers::pi);
+  const auto fromGeometry = [&](double low, double high, double zMin, double zMax) {
+    constexpr int kSamples = 65536;
+    std::uniform_real_distribution<double> uniformZ(zMin, zMax);
+    double sum = 0.;
+    double sum2 = 0.;
+    {
+      for (int sample = 0; sample < kSamples; ++sample) {
+        const double phi = uniformPhi(rng);
+        const double z = uniformZ(rng);
+        const auto x = static_cast<double>(o2::base::GeometryManager::meanMaterialBudget(o2::math_utils::Point3D<double>{low * std::cos(phi), low * std::sin(phi), z}, o2::math_utils::Point3D<double>{high * std::cos(phi), high * std::sin(phi), z}).meanX2X0);
+        sum += x;
+        sum2 += x * x;
+      }
+    }
+    const double n = kSamples;
+    const double mean = sum / n;
+    return Estimate{.mean = mean, .error = std::sqrt(std::max(0., (sum2 / n) - (mean * mean)) / n)};
+  };
+  // The LUT averages each cell over its own 10 x 10 samples; agreement within
+  // 5 % or 3 standard errors of the geometry's mean, whichever is wider.
+  const auto close = [](double fromLut, const Estimate& geo) { return std::abs(fromLut - geo.mean) <= std::max(0.05 * geo.mean, 3. * geo.error) + 1e-7; };
+  const auto passives = passiveMaterial<TRKFT3>(*lut);
+  std::string out = "passive: radius; x/X0 measured (TRKFT3.h), geometry +- its error, LUT\n";
+  for (std::size_t i = 0; i < passives.size(); ++i) {
+    const auto& spec = TRKFT3::passives[i];
+    const auto geo = fromGeometry(spec.bandLow, spec.bandHigh, spec.low, spec.high);
+    out += fmt::format("  {:2d}: {:8.4f} cm  {:.3e}  {:.3e} +- {:.1e}  {:.3e}\n", i, spec.position, spec.x2X0, geo.mean, geo.error, passives[i]);
+    BOOST_TEST_CONTEXT("passive " << i << " geometry " << geo.mean << " +- " << geo.error << " LUT " << passives[i]) { BOOST_TEST(close(passives[i], geo)); }
+  }
+  // A disc's slab from the geometry as layerMaterial reads it: segments from
+  // z = low to high along the ray from the nominal vertex through each radius
+  // of the disc, scaled to normal incidence.
+  const auto fromDisc = [&](double low, double high, double position, double rMin, double rMax) {
+    constexpr int kSamples = 65536;
+    std::uniform_real_distribution<double> uniformR(rMin, rMax);
+    double sum = 0.;
+    double sum2 = 0.;
+    for (int sample = 0; sample < kSamples; ++sample) {
+      const double phi = uniformPhi(rng);
+      const double r = uniformR(rng);
+      const double rLow = r * low / position;
+      const double rHigh = r * high / position;
+      const double length = std::hypot(rHigh - rLow, high - low);
+      const auto x = static_cast<double>(o2::base::GeometryManager::meanMaterialBudget(o2::math_utils::Point3D<double>{rLow * std::cos(phi), rLow * std::sin(phi), low}, o2::math_utils::Point3D<double>{rHigh * std::cos(phi), rHigh * std::sin(phi), high}).meanX2X0) * std::abs(high - low) / length;
+      sum += x;
+      sum2 += x * x;
+    }
+    const double n = kSamples;
+    const double mean = sum / n;
+    return Estimate{.mean = mean, .error = std::sqrt(std::max(0., (sum2 / n) - (mean * mean)) / n)};
+  };
+  const auto layers = layerMaterial<TRKFT3>(*lut);
+  out +=
+    "layer: x/X0 of its slab (a barrel layer's silicon envelope, the outermost's mirrored about it; a disc's half-gaps to the discs\n"
+    "beside it on its side, the innermost's mirrored), geometry +- its error, LUT\n";
+  constexpr auto kBarrel = static_cast<std::size_t>(Detector<TRKFT3>::nBarrelLayers);
+  for (std::size_t i = 0; i < layers.size(); ++i) {
+    const auto& e = PlacedEnvelopes<TRKFT3>::all()[i];
+    Estimate geo{};
+    if (i < kBarrel) {
+      const double low = TRKFT3::passives[i].bandHigh;
+      const double high = i + 1 < kBarrel ? TRKFT3::passives[i + 1].bandLow : e.position + (e.position - low);
+      geo = fromGeometry(low, high, e.zMin, e.zMax);
+    } else {
+      // The neighbours of the same side, as layerMaterial takes them.
+      const auto sameSide = [&](std::size_t other) { return other >= kBarrel && other < layers.size() && PlacedEnvelopes<TRKFT3>::all()[other].position * e.position > 0.; };
+      const bool hasBelow = sameSide(i - 1);
+      const bool hasAbove = sameSide(i + 1);
+      const double below = hasBelow ? PlacedEnvelopes<TRKFT3>::all()[i - 1].position : 0.;
+      const double above = hasAbove ? PlacedEnvelopes<TRKFT3>::all()[i + 1].position : 0.;
+      double low = hasBelow ? 0.5 * (below + e.position) : 0.;
+      double high = hasAbove ? 0.5 * (above + e.position) : 0.;
+      low = hasBelow ? low : e.position - (high - e.position);
+      high = hasAbove ? high : e.position + (e.position - low);
+      // The outermost discs' mirrored slabs end at the LUT's |z|, as the
+      // LUT's reading does; beyond lies material behind the last disc.
+      const auto zMax = static_cast<double>(lut->getZMax());
+      geo = fromDisc(std::clamp(low, -zMax, zMax), std::clamp(high, -zMax, zMax), e.position, e.rMin, e.rMax);
+    }
+    out += fmt::format("  {:2d}: {:.3e} +- {:.1e}  {:.3e}\n", i, geo.mean, geo.error, layers[i]);
+    BOOST_TEST_CONTEXT("layer " << i << " geometry " << geo.mean << " +- " << geo.error << " LUT " << layers[i]) { BOOST_TEST(close(layers[i], geo)); }
+  }
+  BOOST_TEST_MESSAGE(out);
+}
+
+/// Without material, barrel and forward: with nothing to scatter on, 2.9
+/// and 5.8 um over 80 cm at 2 T fix the track far below what a float
+/// covariance holds; the fit carries it as factors.
+BOOST_AUTO_TEST_CASE(PullsWithoutMaterialAreUnit)
+{
+  const auto* result = scans();
+  if (result == nullptr) {
+    BOOST_TEST_MESSAGE("GTRK_ALICE3_GEOMETRY not set: the TRK's chains are not fitted");
+    return;
+  }
+  checkUnit(result->clean);
+  checkUnit(result->forwardClean);
+}
+
+/// The TRK's and FT3's readout frames come from TRKAlmiraParam, here loaded
+/// from a digitiser's configuration, one per layer, the discs' after the
+/// barrel's: an unset length is O2's 18 BC, and the first start is the bias
+/// and the delay together.
+BOOST_AUTO_TEST_CASE(TheTrksFramesAreTheDigitisersPerLayer)
+{
+  const auto path = (std::filesystem::temp_directory_path() / ("gtrk-test-almira-" + std::to_string(getpid()) + ".ini")).string();
+  {
+    std::ofstream out{path};
+    out << "[TRKAlmiraParam]\n";
+    // The VD's 22 BC, ML and OT's 81 BC, the last layer unset.
+    constexpr std::array<int, 11> kLengths{22, 22, 22, 81, 81, 81, 81, 81, 81, 81, 0};
+    for (std::size_t layer = 0; layer < kLengths.size(); ++layer) {
+      out << "roFrameLengthInBCPerLayer[" << layer << "]=" << kLengths[layer] << '\n';
+    }
+    out << "roFrameBiasInBCPerLayer[4]=5\nroFrameDelayInBCPerLayer[4]=2\n";
+    // FT3's first disc at ML and OT's 81 BC, the others unset.
+    out << "roFrameLengthInBCPerLayer[11]=81\nroFrameBiasInBCPerLayer[11]=3\n";
+  }
+  o2::conf::ConfigurableParam::updateFromFile(path, "TRKAlmiraParam");
+  std::filesystem::remove(path);
+  const auto frames = alice::trkFrameTiming();
+  BOOST_REQUIRE_EQUAL(frames.size(), 23U);
+  BOOST_TEST((frames[0] == FrameTiming{.lengthBC = 22, .firstStartBC = 0}));
+  BOOST_TEST((frames[3] == FrameTiming{.lengthBC = 81, .firstStartBC = 0}));
+  BOOST_TEST((frames[4] == FrameTiming{.lengthBC = 81, .firstStartBC = 7}));
+  BOOST_TEST((frames[10] == FrameTiming{.lengthBC = 18, .firstStartBC = 0}));
+  BOOST_TEST((frames[11] == FrameTiming{.lengthBC = 81, .firstStartBC = 3}));
+  BOOST_TEST((frames[22] == FrameTiming{.lengthBC = 18, .firstStartBC = 0}));
+}
+
+} // namespace o2::gtrk
diff --git a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
index 333f44878af18..3eded48bcfbeb 100644
--- a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
@@ -25,7 +25,7 @@ o2_add_library(ITStracking
                        src/VertexerTraits.cxx
                PUBLIC_LINK_LIBRARIES
                        O2::GPUCommon
-                       O2::GenericTracking
+                       O2::GTrkBase
                        Microsoft.GSL::GSL
                        O2::CommonConstants
                        O2::DataFormatsITSMFT
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index f067098cec991..9d864ea97c4ea 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -16,7 +16,7 @@
 #include <gsl/gsl>
 #include <bitset>
 
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/Configuration.h"
 #include "ITStracking/TrackExtensionHypothesis.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index f2c98509fd580..8f957a2aaaf73 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -16,7 +16,7 @@
 #include <array>
 #include <gsl/gsl>
 
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 #include "ITSMFTTracking/CapacityEstimator.h"
 #include "ITSMFTTracking/ROFLookupTables.h"
 #include "ITStracking/TrackingTopology.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index 3f74f71ed3adf..316a653f4d346 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -22,7 +22,7 @@
 
 #include "ITStrackingGPU/TimeFrameGPU.h"
 #include "ITSMFTTracking/Constants.h"
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 #include "ITStrackingGPU/Utils.h"
 #include "ITStracking/ClusterLines.h"
 #include "ITStracking/LineProjection.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/LineVertexerHelpers.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/LineVertexerHelpers.h
index 3568ffeb3e2f3..09bcbd5e748c6 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/LineVertexerHelpers.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/LineVertexerHelpers.h
@@ -15,7 +15,7 @@
 #include <memory>
 #include <span>
 
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 #include "ITStracking/ClusterLines.h"
 
 namespace o2::its::line_vertexer
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index b3bd3f226b0ab..299420536f234 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -32,7 +32,7 @@
 #include "ITStracking/Tracklet.h"
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/ExternalAllocator.h"
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 #include "ITSMFTTracking/ROFLookupTables.h"
 #include "ITStracking/TrackingTopology.h"
 #include "SimulationDataFormat/MCCompLabel.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index ce3dc6845ce93..4211ec299f9e6 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -33,7 +33,7 @@
 #include "ITStracking/Definitions.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/TrackerTraits.h"
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 
 namespace o2
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 7ae0fcc09e3f0..b7e661d2347df 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -26,7 +26,7 @@
 #include "ITSMFTTracking/CapacityEstimator.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/Cell.h"
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 #include "ITStracking/TrackExtensionHypothesis.h"
 #include "ITStracking/TrackFollower.h"
 #include "ITStracking/TrackITSInternal.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index 920e815299541..35d2336180991 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -19,7 +19,7 @@
 #include "ITStracking/TrackerTraits.h"
 #include "ITStracking/Vertexer.h"
 #include "ITStracking/VertexerTraits.h"
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 #include "DataFormatsParameters/GRPObject.h"
 #include "DataFormatsITSMFT/TopologyDictionary.h"
 #include "DataFormatsCalibration/MeanVertexObject.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index d27ea5694b75e..a96b1e903bcf4 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -30,7 +30,7 @@
 #include "ITStracking/Configuration.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/VertexerTraits.h"
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 
 namespace o2::its
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index 13034b388eb6a..57e741a48d469 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -21,7 +21,7 @@
 #include <string>
 #include <vector>
 
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 #include "ITStracking/Cluster.h"
 #include "ITStracking/ClusterLines.h"
 #include "ITStracking/Configuration.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 89343ff55a4b6..031ceffd6e44b 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -26,7 +26,7 @@
 #include "DataFormatsITSMFT/TopologyDictionary.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "ITSMFTBase/SegmentationAlpide.h"
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 
 namespace
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index ebd9162a00ad2..1afd4c435f6f4 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -14,7 +14,7 @@
 ///
 
 #include "ITStracking/Tracker.h"
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 #include "ITSMFTTracking/Constants.h"
 #include "ITStracking/TrackerTraits.h"
 #include "ITSMFTTracking/ITSTrackingConfigParam.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index b29da0e7d22d3..2768432f1cc6d 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -35,7 +35,7 @@
 
 #include "DetectorsBase/Propagator.h"
 #include "GPUCommonMath.h"
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 #include "ITSMFTTracking/MathUtils.h"
 #include "ITStracking/Cell.h"
 #include "ITSMFTTracking/Constants.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index b71c4219f6084..3a4865c8e7bd8 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -38,7 +38,7 @@
 #include "DataFormatsTRD/TriggerRecord.h"
 #include "CommonDataFormat/IRFrame.h"
 #include "DetectorsBase/GRPGeomHelper.h"
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 #include "Framework/InputRecordWalker.h"
 #include "Framework/DataRefUtils.h"
 #include "Framework/DeviceSpec.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index 18b4791f474d9..2351399584d27 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -14,7 +14,7 @@
 ///
 
 #include "ITStracking/Vertexer.h"
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 #include "ITStracking/VertexerTraits.h"
 #include "ITSMFTTracking/ITSTrackingConfigParam.h"
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index e40088525d7d3..e324117f9c8da 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -21,7 +21,7 @@
 #include <oneapi/tbb/combinable.h>
 
 #include "ITStracking/VertexerTraits.h"
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 #include "ITStracking/ClusterLines.h"
 #include "ITStracking/Definitions.h"
 #include "ITStracking/LineVertexerHelpers.h"
diff --git a/Detectors/ITSMFT/MFT/workflow/CMakeLists.txt b/Detectors/ITSMFT/MFT/workflow/CMakeLists.txt
index 5f904c24011fb..30e7f5a42ca08 100644
--- a/Detectors/ITSMFT/MFT/workflow/CMakeLists.txt
+++ b/Detectors/ITSMFT/MFT/workflow/CMakeLists.txt
@@ -47,6 +47,11 @@ o2_add_executable(assessment-workflow
                   COMPONENT_NAME mft
                   PUBLIC_LINK_LIBRARIES O2::MFTWorkflow)
 
+o2_add_executable(track-writer-workflow
+                  SOURCES src/mft-track-writer-workflow.cxx
+                  COMPONENT_NAME mft
+                  PUBLIC_LINK_LIBRARIES O2::ITSMFTCAWriter)
+
 o2_add_executable(cluster-writer-workflow
                   SOURCES src/mft-cluster-writer-workflow.cxx
                   COMPONENT_NAME mft
diff --git a/Detectors/ITSMFT/MFT/workflow/src/mft-track-writer-workflow.cxx b/Detectors/ITSMFT/MFT/workflow/src/mft-track-writer-workflow.cxx
new file mode 100644
index 0000000000000..973026ebf8f19
--- /dev/null
+++ b/Detectors/ITSMFT/MFT/workflow/src/mft-track-writer-workflow.cxx
@@ -0,0 +1,35 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ITSMFTCAWriter/MFTCATrackWriterSpec.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/CompletionPolicyHelpers.h"
+
+using namespace o2::framework;
+
+void customize(std::vector<o2::framework::CompletionPolicy>& policies)
+{
+  // ordered policies for the writers
+  policies.push_back(CompletionPolicyHelpers::consumeWhenAllOrdered(".*(?:MFT|mft).*[W,w]riter.*"));
+}
+
+void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
+{
+  workflowOptions.push_back(ConfigParamSpec{"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation even if available"}});
+}
+
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
+{
+  auto useMC = !configcontext.options().get<bool>("disable-mc");
+  return WorkflowSpec{o2::mft::getTrackWriterSpec(useMC)};
+}
diff --git a/Detectors/ITSMFT/common/tracking/CMakeLists.txt b/Detectors/ITSMFT/common/tracking/CMakeLists.txt
index 9df4122cec929..974f28e95f317 100644
--- a/Detectors/ITSMFT/common/tracking/CMakeLists.txt
+++ b/Detectors/ITSMFT/common/tracking/CMakeLists.txt
@@ -37,7 +37,7 @@ o2_add_library(ITSMFTTracking
                        src/Tracker.cxx
                PUBLIC_LINK_LIBRARIES
                        O2::ITSMFTTrackingParams
-                       O2::GenericTracking
+                       O2::GTrkBase
                        O2::GPUCommon
                        O2::CommonConstants
                        O2::CommonDataFormat
diff --git a/Detectors/ITSMFT/common/tracking/include/ITSMFTTracking/BoundedAllocator.h b/Detectors/ITSMFT/common/tracking/include/ITSMFTTracking/BoundedAllocator.h
index 5a032ea7156ad..99d4cfa0f48f8 100644
--- a/Detectors/ITSMFT/common/tracking/include/ITSMFTTracking/BoundedAllocator.h
+++ b/Detectors/ITSMFT/common/tracking/include/ITSMFTTracking/BoundedAllocator.h
@@ -13,18 +13,16 @@
 #ifndef ALICEO2_ITSMFT_TRACKING_BOUNDEDALLOCATOR_H_
 #define ALICEO2_ITSMFT_TRACKING_BOUNDEDALLOCATOR_H_
 
-#include "GenericTracking/BoundedAllocator.h"
+#include "GenericTracking/Base/BoundedAllocator.h"
 
 namespace o2::itsmft::tracking
 {
 using o2::gtrk::bounded_vector;
 using o2::gtrk::BoundedMemoryResource;
 using o2::gtrk::BoundedVector;
-using o2::gtrk::clearResizeBoundedArray;
 using o2::gtrk::clearResizeBoundedVector;
 using o2::gtrk::deepVectorClear;
 using o2::gtrk::resizeBoundedVector;
-using o2::gtrk::toSTDVector;
 } // namespace o2::itsmft::tracking
 
 #endif
diff --git a/GPU/Common/GPUCommonDefAPI.h b/GPU/Common/GPUCommonDefAPI.h
index faddcb027e0c5..21f1e7c1bc2f0 100644
--- a/GPU/Common/GPUCommonDefAPI.h
+++ b/GPU/Common/GPUCommonDefAPI.h
@@ -43,6 +43,7 @@
   #define GPUhd()                                   // Host and device function, inlined during GPU compilation to avoid symbol clashes in host code
   #define GPUhdi() inline                           // Host and device function, to-be-inlined on host and device
   #define GPUhdni()                                 // Host and device function, not to-be-inlined automatically
+  #define GPUhdnii() inline                         // Host and device function, not-to-be-inlined on device, inlined on host
   #define GPUg() INVALID_TRIGGER_ERROR_NO_GPU_CODE  // GPU kernel
   #define GPUshared()                               // shared memory variable declaration
   #define GPUglobal()                               // global memory variable declaration (only used for kernel input pointers)
@@ -89,6 +90,7 @@
   #define GPUhd() inline
   #define GPUhdi() inline
   #define GPUhdni()
+  #define GPUhdnii() inline
   #define GPUg() __kernel
   #define GPUshared() __local
   #define GPUglobal() __global
@@ -157,6 +159,7 @@
   #define GPUhd() inline
   #define GPUhdi() inline
   #define GPUhdni()
+  #define GPUhdnii() inline
   #define GPUg() kernel
   #define GPUshared() threadgroup
   #define GPUglobal() device
@@ -187,6 +190,7 @@
   #define GPUhd() __host__ __device__ inline
   #define GPUhdi() __host__ __device__ inline
   #define GPUhdni() __host__ __device__
+  #define GPUhdnii() __host__ __device__ inline __attribute__((noinline))
   #define GPUg() __global__
   #define GPUshared() __shared__
   #if defined(GPUCA_GPUCODE_DEVICE) && 0 // TODO: Fix for HIP
@@ -222,6 +226,7 @@
   #define GPUhd() __host__ __device__ inline
   #define GPUhdi() __host__ __device__ inline
   #define GPUhdni() __host__ __device__
+  #define GPUhdnii() __host__ __device__ inline __attribute__((noinline))
   #define GPUg() __global__
   #define GPUshared() __shared__
   #define GPUglobal()
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 3e7509d8fad73..09e3a7ebca334 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -562,7 +562,7 @@ size_t GPUReconstruction::AllocateRegisteredPermanentMemory()
     GPUError("Must not allocate permanent memory while volatile chunks are allocated");
     throw std::bad_alloc();
   }
-  int32_t total = 0;
+  size_t total = 0;
   for (uint32_t i = 0; i < mMemoryResources.size(); i++) {
     if ((mMemoryResources[i].mType & GPUMemoryResource::MEMORY_PERMANENT) && mMemoryResources[i].mPtr == nullptr) {
       total += AllocateRegisteredMemory(i);
@@ -1305,6 +1305,13 @@ void GPUReconstruction::SetOutputControl(void* ptr, size_t size)
 
 void GPUReconstruction::SetInputControl(void* ptr, size_t size) { mInputControl.set(ptr, size); }
 GPUReconstruction::DeviceType GPUReconstruction::GetDeviceType() const { return (DeviceType)GetDeviceBackendSettings().deviceType; }
+
+size_t GPUReconstruction::DeviceMemoryGap() const
+{
+  const size_t low = GPUProcessor::nextMultipleOf<constants::GPU_MEMALIGN>((size_t)mDeviceMemoryPool);
+  const size_t high = (size_t)mDeviceMemoryPoolEnd - GPUProcessor::getAlignmentMod<constants::GPU_MEMALIGN>((size_t)mDeviceMemoryPoolEnd);
+  return mDeviceMemoryPool == nullptr || high <= low ? 0 : high - low;
+}
 const GPUParam& GPUReconstruction::GetParam() const { return mHostConstantMem->param; }
 void GPUReconstruction::SetResetTimers(bool reset) { mProcessingSettings->resetTimers = reset; }
 void GPUReconstruction::SetDebugLevelTmp(int32_t level) { mProcessingSettings->debugLevel = level; }
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index eb2653fdfb66d..89d70fd0f9baa 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -205,6 +205,7 @@ class GPUReconstruction
 
   // Getters / setters for parameters
   DeviceType GetDeviceType() const;
+  virtual int32_t GetDeviceId() const { return -1; } // The device the backend selected, -1 without one
   bool IsGPU() const { return GetDeviceType() != DeviceType::INVALID_DEVICE && GetDeviceType() != DeviceType::CPU; }
   const GPUParam& GetParam() const;
   const GPUConstantMem& GetConstantMem() const { return *mHostConstantMem; }
@@ -226,6 +227,8 @@ class GPUReconstruction
   GPUOutputControl& OutputControl() { return mOutputControl; }
   uint32_t NStreams() const { return mNStreams; }
   const void* DeviceMemoryBase() const { return mDeviceMemoryBase; }
+  // The device pool's free memory between its two ends, both aligned inwards to GPU_MEMALIGN; 0 if none
+  size_t DeviceMemoryGap() const;
   virtual const GPUDefParameters& getGPUParameters(bool doGPU) const = 0;
 
   RecoStepField GetRecoSteps() const { return mRecoSteps.steps; }
diff --git a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h
index 0b1cb5f643571..be883ede2bf79 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h
@@ -28,6 +28,7 @@ class GPUReconstructionDeviceBase : public GPUReconstructionCPU
   ~GPUReconstructionDeviceBase() override;
 
   const GPUParam* DeviceParam() const;
+  int32_t GetDeviceId() const override { return mDeviceId; }
   struct deviceConstantMemRegistration {
     deviceConstantMemRegistration(void* (*reg)())
     {
diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 0202c784d073b..5eec446ad41ca 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -118,7 +118,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
   o2_add_library(
     ${MODULE}
     SOURCES ${SRCS}
-    PUBLIC_LINK_LIBRARIES O2::GPUTracking O2::ITStrackingCUDA
+    PUBLIC_LINK_LIBRARIES O2::GPUTracking O2::ITStrackingCUDA O2::GTrkTrackingCUDA
     PRIVATE_INCLUDE_DIRECTORIES
       ${CMAKE_SOURCE_DIR}/Detectors/Base/src
       ${CMAKE_SOURCE_DIR}/Detectors/TRD/base/src
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 50d710fd9d557..1368b09cf311a 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -169,7 +169,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
   o2_add_library(
     ${MODULE}
     SOURCES ${SRCS}
-    PUBLIC_LINK_LIBRARIES O2::GPUTracking O2::ITStrackingHIP
+    PUBLIC_LINK_LIBRARIES O2::GPUTracking O2::ITStrackingHIP O2::GTrkTrackingHIP
     PRIVATE_INCLUDE_DIRECTORIES
       ${CMAKE_SOURCE_DIR}/Detectors/Base/src
       ${CMAKE_SOURCE_DIR}/Detectors/TRD/base/src
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypesConfig.h b/GPU/GPUTracking/DataTypes/GPUDataTypesConfig.h
index 82302605adb32..82b834073b50f 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypesConfig.h
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypesConfig.h
@@ -46,6 +46,7 @@ enum class RecoStep : uint32_t { TPCConversion = 1,
                                  TPCClusterFinding = 128,
                                  TPCDecompression = 256,
                                  Refit = 512,
+                                 GenericTracking = 1024,
                                  AllRecoSteps = 0x7FFFFFFF,
                                  NoRecoStep = 0 };
 enum class InOutType : uint32_t { TPCClusters = 1,
@@ -59,7 +60,7 @@ enum class InOutType : uint32_t { TPCClusters = 1,
                                   ITSTracks = 256 };
 #if !defined(__OPENCL__) && !defined(__METAL__)
 static constexpr const char* const DEVICE_TYPE_NAMES[] = {"INVALID", "CPU", "CUDA", "HIP", "OCL", "METAL", "CPUDEVICE"};
-static constexpr const char* const RECO_STEP_NAMES[] = {"TPC Transformation", "TPC Sector Tracking", "TPC Track Merging and Fit", "TPC Compression", "TRD Tracking", "ITS Tracking", "TPC dEdx Computation", "TPC Cluster Finding", "TPC Decompression", "Global Refit"};
+static constexpr const char* const RECO_STEP_NAMES[] = {"TPC Transformation", "TPC Sector Tracking", "TPC Track Merging and Fit", "TPC Compression", "TRD Tracking", "ITS Tracking", "TPC dEdx Computation", "TPC Cluster Finding", "TPC Decompression", "Global Refit", "Generic Tracking"};
 static constexpr const char* const GENERAL_STEP_NAMES[] = {"Prepare", "QA"};
 constexpr static int32_t N_RECO_STEPS = sizeof(gpudatatypes::RECO_STEP_NAMES) / sizeof(gpudatatypes::RECO_STEP_NAMES[0]);
 constexpr static int32_t N_GENERAL_STEPS = sizeof(gpudatatypes::GENERAL_STEP_NAMES) / sizeof(gpudatatypes::GENERAL_STEP_NAMES[0]);
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.cxx b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
index ca22df5b95695..f679042af209f 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
@@ -236,6 +236,8 @@ int32_t GPUO2Interface::RunTracking(GPUTrackingInOutPointers* data, GPUInterface
 
 void GPUO2Interface::Clear(bool clearOutputs, uint32_t iThread) { mCtx[iThread].mRec->ClearAllocatedMemory(clearOutputs); }
 
+GPUReconstruction* GPUO2Interface::GetReconstruction(uint32_t iThread) const { return mNContexts > iThread ? mCtx[iThread].mRec.get() : nullptr; }
+
 int32_t GPUO2Interface::registerMemoryForGPU(const void* ptr, size_t size)
 {
   return mCtx[0].mRec->registerMemoryForGPU(ptr, size);
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.h b/GPU/GPUTracking/Interface/GPUO2Interface.h
index eed7c119f5328..98e985ce9ccea 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.h
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.h
@@ -91,6 +91,7 @@ class GPUO2Interface
   void setErrorCodeOutput(std::vector<std::array<uint32_t, 4>>* v);
 
   const GPUO2InterfaceConfiguration& getConfig() const { return *mConfig; }
+  GPUReconstruction* GetReconstruction(uint32_t iThread = 0) const;
 
  private:
   GPUO2Interface(const GPUO2Interface&);
diff --git a/GPU/Workflow/CMakeLists.txt b/GPU/Workflow/CMakeLists.txt
index db8d22dda1bae..686e7230061b0 100644
--- a/GPU/Workflow/CMakeLists.txt
+++ b/GPU/Workflow/CMakeLists.txt
@@ -13,6 +13,7 @@ o2_add_library(GPUWorkflow
                SOURCES src/GPUWorkflowSpec.cxx
                        src/GPUWorkflowTPC.cxx
                        src/GPUWorkflowITS.cxx
+                       src/GPUWorkflowGenericTracking.cxx
                        src/GPUWorkflowPipeline.cxx
                TARGETVARNAME targetName
                PUBLIC_LINK_LIBRARIES O2::Framework
@@ -28,6 +29,7 @@ o2_add_library(GPUWorkflow
                                      O2::DataFormatsTRD
                PRIVATE_LINK_LIBRARIES O2::GPUTracking
                                       O2::ITSTrackingInterface
+                                      O2::GTrkWorkflow
                                       $<$<BOOL:${ENABLE_UPGRADES}>:O2::ITS3TrackingInterface>)
 
 o2_add_executable(reco-workflow
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index 978c5f312cfe7..ff14c274ea486 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -63,6 +63,11 @@ class TimeFrame;
 class ITSTrackingInterface;
 } // namespace its
 
+namespace gtrk::workflow
+{
+class GPURecoTracking;
+} // namespace gtrk::workflow
+
 namespace itsmft
 {
 class TopologyDictionary;
@@ -128,6 +133,8 @@ class GPURecoWorkflowSpec : public o2::framework::Task
     bool readTRDtracklets = false;
     bool outputErrorQA = false;
     bool runITSTracking = false;
+    bool runGenericTrackingITS = false; // GenericTracking's ITS tracking after the TPC's, on its GPU
+    bool runGenericTrackingMFT = false; // GenericTracking's MFT tracking after the TPC's, on its GPU
     bool itsStaggered = false;
     bool itsOverrBeamEst = false;
     bool tpcTriggerHandling = false;
@@ -186,6 +193,9 @@ class GPURecoWorkflowSpec : public o2::framework::Task
 
   int32_t runMain(o2::framework::ProcessingContext* pc, GPUTrackingInOutPointers* ptrs, GPUInterfaceOutputs* outputRegions, int32_t threadIndex = 0, GPUInterfaceInputUpdate* inputUpdateCallback = nullptr);
   int32_t runITSTracking(o2::framework::ProcessingContext& pc);
+  void createGenericTracking();
+  void initFunctionGenericTracking(o2::framework::InitContext& ic);
+  void runGenericTracking(o2::framework::ProcessingContext& pc, bool reconstructed);
 
   int32_t handlePipeline(o2::framework::ProcessingContext& pc, GPUTrackingInOutPointers& ptrs, gpurecoworkflow_internals::GPURecoWorkflowSpec_TPCZSBuffers& tpcZSmeta, o2::gpu::GPUTrackingInOutZS& tpcZS, std::unique_ptr<gpurecoworkflow_internals::GPURecoWorkflow_QueueObject>& context);
   void RunReceiveThread();
@@ -221,6 +231,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
   std::vector<int32_t> mClusterOutputIds;
   std::vector<int32_t> mTPCSectors;
   std::unique_ptr<o2::its::ITSTrackingInterface> mITSTrackingInterface;
+  std::vector<std::unique_ptr<o2::gtrk::workflow::GPURecoTracking>> mGenericTracking; // GenericTracking's detectors, the ITS first
   std::unique_ptr<gpurecoworkflow_internals::GPURecoWorkflowSpec_PipelineInternals> mPipeline;
   o2::its::TimeFrame<7>* mITSTimeFrame = nullptr;
   std::vector<fair::mq::RegionInfo> mRegionInfos;
diff --git a/GPU/Workflow/src/GPUWorkflowGenericTracking.cxx b/GPU/Workflow/src/GPUWorkflowGenericTracking.cxx
new file mode 100644
index 0000000000000..ec91e0ee2ea50
--- /dev/null
+++ b/GPU/Workflow/src/GPUWorkflowGenericTracking.cxx
@@ -0,0 +1,46 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   GPUWorkflowGenericTracking.cxx
+/// @brief  GenericTracking's ITS and MFT tracking inside the GPU reconstruction, after the TPC's, in its pool
+
+#include "GPUWorkflow/GPUWorkflowSpec.h"
+#include "GPUO2Interface.h"
+#include "GenericTracking/Workflow/GPURecoTracking.h"
+
+namespace o2::gpu
+{
+
+void GPURecoWorkflowSpec::createGenericTracking()
+{
+  if (mSpecConfig.runGenericTrackingITS) {
+    mGenericTracking.push_back(o2::gtrk::workflow::makeGPURecoTracking("its"));
+  }
+  if (mSpecConfig.runGenericTrackingMFT) {
+    mGenericTracking.push_back(o2::gtrk::workflow::makeGPURecoTracking("mft"));
+  }
+}
+
+void GPURecoWorkflowSpec::initFunctionGenericTracking(o2::framework::InitContext& ic)
+{
+  for (auto& tracking : mGenericTracking) {
+    tracking->init(ic, *mGPUReco->GetReconstruction());
+  }
+}
+
+void GPURecoWorkflowSpec::runGenericTracking(o2::framework::ProcessingContext& pc, bool reconstructed)
+{
+  for (auto& tracking : mGenericTracking) {
+    tracking->run(pc, reconstructed);
+  }
+}
+
+} // namespace o2::gpu
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 990873f053fe3..ae93f85d0d494 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -79,6 +79,7 @@
 #include "DetectorsRaw/RDHUtils.h"
 #include "ITStracking/TrackingInterface.h"
 #include "ITSMFTTracking/ITSTrackingConfigParam.h"
+#include "GenericTracking/Workflow/GPURecoTracking.h"
 #include "GPUWorkflowInternal.h"
 #include "GPUDataTypesQA.h"
 // #include "Framework/ThreadPool.h"
@@ -127,6 +128,7 @@ GPURecoWorkflowSpec::GPURecoWorkflowSpec(GPURecoWorkflowSpec::CompletionPolicyDa
   if (mSpecConfig.enableDoublePipeline == 1 && gPolicyOrder) {
     *gPolicyOrder = &mPolicyOrder;
   }
+  createGenericTracking();
 }
 
 GPURecoWorkflowSpec::~GPURecoWorkflowSpec() = default;
@@ -304,6 +306,7 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
     if (mSpecConfig.runITSTracking) {
       initFunctionITS(ic);
     }
+    initFunctionGenericTracking(ic);
   }
 
   if (mSpecConfig.enableDoublePipeline) {
@@ -366,6 +369,9 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
 void GPURecoWorkflowSpec::stop()
 {
   LOGF(info, "GPU Reconstruction total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer->CpuTime(), mTimer->RealTime(), mTimer->Counter() - 1);
+  for (auto& tracking : mGenericTracking) {
+    tracking->stop();
+  }
   handlePipelineStop();
 }
 
@@ -374,6 +380,9 @@ void GPURecoWorkflowSpec::endOfStream(EndOfStreamContext& ec)
   if (mSpecConfig.runITSTracking && mITSTrackingInterface != nullptr) {
     mITSTrackingInterface->printSummary();
   }
+  for (auto& tracking : mGenericTracking) {
+    tracking->endOfStream();
+  }
   handlePipelineEndOfStream(ec);
 }
 
@@ -384,6 +393,11 @@ void GPURecoWorkflowSpec::finaliseCCDB(o2::framework::ConcreteDataMatcher& match
     if (mSpecConfig.runITSTracking) {
       finaliseCCDBITS(matcher, obj);
     }
+    for (auto& tracking : mGenericTracking) {
+      if (tracking->finaliseCCDB(matcher, obj)) {
+        return;
+      }
+    }
   }
   if (GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
     mGRPGeomUpdated = true;
@@ -518,6 +532,10 @@ int32_t GPURecoWorkflowSpec::runMain(o2::framework::ProcessingContext* pc, GPUTr
       retVal = runITSTracking(*pc);
     }
   }
+  if (!mGenericTracking.empty()) {
+    // After the TPC (and O2's ITS), before the pool is cleared; its products empty if the TPC failed.
+    runGenericTracking(*pc, mConfParam->dump < 2 && retVal == 0);
+  }
 
   if (!mSpecConfig.enableDoublePipeline) { // TODO: Why is this needed for double-pipeline?
     mGPUReco->Clear(false, threadIndex);   // clean non-output memory used by GPU Reconstruction
@@ -1339,6 +1357,9 @@ Inputs GPURecoWorkflowSpec::inputs()
     }
   }
 
+  for (auto& tracking : mGenericTracking) {
+    tracking->appendInputs(inputs);
+  }
   return inputs;
 };
 
@@ -1415,12 +1436,16 @@ Outputs GPURecoWorkflowSpec::outputs()
     }
   }
 
+  for (auto& tracking : mGenericTracking) {
+    tracking->appendOutputs(outputSpecs);
+  }
   return outputSpecs;
 };
 
 void GPURecoWorkflowSpec::deinitialize()
 {
   ExitPipeline();
+  mGenericTracking.clear(); // its GPU before the reconstruction's
   mQA.reset(nullptr);
   mDisplayFrontend.reset(nullptr);
   mGPUReco.reset(nullptr);
diff --git a/GPU/Workflow/src/gpu-reco-workflow.cxx b/GPU/Workflow/src/gpu-reco-workflow.cxx
index 847ddf95b3da9..b1957b8d32161 100644
--- a/GPU/Workflow/src/gpu-reco-workflow.cxx
+++ b/GPU/Workflow/src/gpu-reco-workflow.cxx
@@ -52,7 +52,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
 
   std::vector<ConfigParamSpec> options{
     {"input-type", VariantType::String, "digits", {"digits, zsraw, zsonthefly, clusters, compressed-clusters-root, compressed-clusters-flat, trd-tracklets, its-clusters, its-mean-vertex"}},
-    {"output-type", VariantType::String, "tracks", {"cluster, tracks, compressed-clusters-root, compressed-clusters-flat, qa, error-qa, no-shared-cluster-map, send-clusters-per-sector, trd-tracks, tpc-triggers, its-tracks"}},
+    {"output-type", VariantType::String, "tracks", {"cluster, tracks, compressed-clusters-root, compressed-clusters-flat, qa, error-qa, no-shared-cluster-map, send-clusters-per-sector, trd-tracks, tpc-triggers, its-tracks, gtrk-its-tracks, gtrk-mft-tracks"}},
     {"disable-root-input", VariantType::Bool, true, {"disable root-files input reader"}},
     {"disable-mc", VariantType::Bool, false, {"disable sending of MC information"}},
     {"ignore-dist-stf", VariantType::Bool, false, {"do not subscribe to FLP/DISTSUBTIMEFRAME/0 message (no lost TF recovery)"}},
@@ -110,7 +110,9 @@ enum struct ioType { Digits,
                      ITSClusters,
                      ITSTracks,
                      MeanVertex,
-                     TPCTriggers };
+                     TPCTriggers,
+                     GenericTrackingITSTracks,
+                     GenericTrackingMFTTracks };
 
 static const std::unordered_map<std::string, ioType> InputMap{
   {"digits", ioType::Digits},
@@ -135,7 +137,9 @@ static const std::unordered_map<std::string, ioType> OutputMap{
   {"send-clusters-per-sector", ioType::SendClustersPerSector},
   {"trd-tracks", ioType::TRDTracks},
   {"its-tracks", ioType::ITSTracks},
-  {"tpc-triggers", ioType::TPCTriggers}};
+  {"tpc-triggers", ioType::TPCTriggers},
+  {"gtrk-its-tracks", ioType::GenericTrackingITSTracks},
+  {"gtrk-mft-tracks", ioType::GenericTrackingMFTTracks}};
 
 WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 {
@@ -184,9 +188,18 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   cfg.runTRDTracking = isEnabled(outputTypes, ioType::TRDTracks);
   cfg.tpcTriggerHandling = isEnabled(outputTypes, ioType::TPCTriggers) || cfg.caClusterer;
   cfg.enableDoublePipeline = cfgc.options().get<bool>("enableDoublePipeline");
+  if (cfg.enableDoublePipeline && (isEnabled(outputTypes, ioType::GenericTrackingITSTracks) || isEnabled(outputTypes, ioType::GenericTrackingMFTTracks))) {
+    throw std::invalid_argument("gtrk-its-tracks and gtrk-mft-tracks need the processing context of the single pipeline (no enableDoublePipeline)");
+  }
   cfg.tpcDeadMapSources = cfgc.options().get<int32_t>("tpc-deadMap-sources");
   cfg.tpcUseMCTimeGain = cfgc.options().get<bool>("tpc-mc-time-gain");
   cfg.runITSTracking = isEnabled(outputTypes, ioType::ITSTracks);
+  // GenericTracking's tracking on the TPC's GPU: its measurements from o2-gtrk-<det>-reco-workflow --tracking-in-gpu-reco
+  cfg.runGenericTrackingITS = isEnabled(outputTypes, ioType::GenericTrackingITSTracks);
+  cfg.runGenericTrackingMFT = isEnabled(outputTypes, ioType::GenericTrackingMFTTracks);
+  if (cfg.runGenericTrackingITS && cfg.runITSTracking) {
+    throw std::invalid_argument("its-tracks and gtrk-its-tracks: one ITS tracking");
+  }
   cfg.itsStaggered = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(cfgc);
   cfg.itsOverrBeamEst = isEnabled(inputTypes, ioType::MeanVertex);
   cfg.useFilteredOutputSpecs = cfgc.options().get<bool>("filtered-output-specs");