From 2f07757c0ea61afa3c6813c9c2bc095706d4bf6b Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Sun, 30 Aug 2026 16:50:28 -0700
Subject: [PATCH 01/15] Reuse raft::mdarray/mdspan directly in dense dataset
 storage (#2395)

dense_owning_matrix/dense_view_matrix (and the VPQ codebook/code matrix
aliases) picked between raft::device_matrix and raft::host_matrix via
std::conditional_t, even though those are themselves just aliases for
raft::mdarray/raft::mdspan with the exact accessor already computed as
Accessor. Point the aliases at raft::mdarray/raft::mdspan directly instead.

dense_row_major_dataset_owning_storage/_view_storage also wrapped their
matrix/view as a field and hand-forwarded view()/data_handle(), which
raft::mdarray/raft::mdspan already provide natively. They now inherit from
the matrix/view type instead, so those forwards are no longer needed.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 cpp/include/cuvs/neighbors/common.hpp | 83 ++++++++++++++++-----------
 1 file changed, 49 insertions(+), 34 deletions(-)

diff --git a/cpp/include/cuvs/neighbors/common.hpp b/cpp/include/cuvs/neighbors/common.hpp
index 3be6cf1fa1..46b9e7b599 100644
--- a/cpp/include/cuvs/neighbors/common.hpp
+++ b/cpp/include/cuvs/neighbors/common.hpp
@@ -189,26 +189,36 @@ using dataset_owning_accessor_for_view = std::conditional_t<Accessor::is_device_
                                                             device_owning_accessor<DataT>,
                                                             host_owning_accessor<DataT>>;
 
+// Accessor here is already device_owning_accessor<DataT> / host_owning_accessor<DataT> at every
+// call site -- exactly the container policy raft::device_mdarray/host_mdarray default to for
+// element type DataT -- so pass it straight through instead of re-deriving a
+// raft::device_matrix/host_matrix from scratch.
 template <typename DataT, typename IdxT, typename Accessor>
-using dense_owning_matrix = std::conditional_t<Accessor::is_device_accessible,
-                                               raft::device_matrix<DataT, IdxT, raft::row_major>,
-                                               raft::host_matrix<DataT, IdxT, raft::row_major>>;
+using dense_owning_matrix =
+  raft::mdarray<DataT, raft::matrix_extent<IdxT>, raft::row_major, Accessor>;
 
 template <typename DataT, typename IdxT, typename Accessor>
-using dense_view_matrix =
-  std::conditional_t<Accessor::is_device_accessible,
-                     raft::device_matrix_view<const DataT, IdxT, raft::row_major>,
-                     raft::host_matrix_view<const DataT, IdxT, raft::row_major>>;
+using dense_view_matrix = raft::mdspan<const DataT,
+                                       raft::matrix_extent<IdxT>,
+                                       raft::row_major,
+                                       dataset_view_accessor_for_owning<DataT, Accessor>>;
 
 template <typename MathT, typename IdxT, typename Accessor>
-using vpq_vq_book_matrix = std::conditional_t<Accessor::is_device_accessible,
-                                              raft::device_matrix<MathT, uint32_t, raft::row_major>,
-                                              raft::host_matrix<MathT, uint32_t, raft::row_major>>;
+using vpq_vq_book_matrix =
+  raft::mdarray<MathT, raft::matrix_extent<uint32_t>, raft::row_major, Accessor>;
+
+// VPQ codes are always uint8_t regardless of MathT, so retarget the owning accessor's element
+// type instead of re-deriving a device/host matrix; residency is still driven by Accessor.
+template <typename NewT, typename Accessor>
+using owning_accessor_with_value_type = std::conditional_t<Accessor::is_device_accessible,
+                                                           device_owning_accessor<NewT>,
+                                                           host_owning_accessor<NewT>>;
 
 template <typename IdxT, typename Accessor>
-using vpq_data_matrix = std::conditional_t<Accessor::is_device_accessible,
-                                           raft::device_matrix<uint8_t, IdxT, raft::row_major>,
-                                           raft::host_matrix<uint8_t, IdxT, raft::row_major>>;
+using vpq_data_matrix = raft::mdarray<uint8_t,
+                                      raft::matrix_extent<IdxT>,
+                                      raft::row_major,
+                                      owning_accessor_with_value_type<uint8_t, Accessor>>;
 
 // -----------------------------------------------------------------------------
 // empty
@@ -234,7 +244,9 @@ using empty_dataset_view_storage = empty_dataset_storage<IdxT>;
 // -----------------------------------------------------------------------------
 
 /**
- * Dense row-major owning storage shared by padded and standard dataset containers.
+ * Dense row-major owning storage shared by padded and standard dataset containers. Publicly
+ * inherits from MatrixT (an `raft::mdarray`) so `view()`/`data_handle()`/`extent()` etc. are
+ * reused as-is rather than hand-forwarded; `logical_dim_` is the only state this struct adds.
  *
  * Template parameters:
  * - MatrixT: owning matrix type that stores the payload (host/device matrix).
@@ -243,55 +255,58 @@ using empty_dataset_view_storage = empty_dataset_storage<IdxT>;
  * - IdxT: index type used for row counts (`n_rows()` return type).
  */
 template <typename MatrixT, typename ViewT, typename DataT, typename IdxT>
-struct dense_row_major_dataset_owning_storage {
-  MatrixT data_;
+struct dense_row_major_dataset_owning_storage : public MatrixT {
   uint32_t logical_dim_;
 
+  // MatrixT (mdarray) also has its own stride(size_t); pull it back into scope since declaring
+  // our own no-arg stride() below would otherwise hide it entirely (C++ name hiding).
+  using MatrixT::stride;
+
   dense_row_major_dataset_owning_storage(MatrixT&& data, uint32_t logical_dim) noexcept
-    : data_{std::move(data)}, logical_dim_{logical_dim}
+    : MatrixT{std::move(data)}, logical_dim_{logical_dim}
   {
   }
 
-  [[nodiscard]] auto n_rows() const noexcept -> IdxT { return data_.extent(0); }
+  [[nodiscard]] auto n_rows() const noexcept -> IdxT { return this->extent(0); }
   [[nodiscard]] auto dim() const noexcept -> uint32_t { return logical_dim_; }
   [[nodiscard]] auto stride() const noexcept -> uint32_t
   {
-    return static_cast<uint32_t>(data_.extent(1));
+    return static_cast<uint32_t>(this->extent(1));
   }
-  [[nodiscard]] auto view() const noexcept -> ViewT { return data_.view(); }
-  [[nodiscard]] auto data_handle() noexcept -> DataT* { return data_.data_handle(); }
-  [[nodiscard]] auto data_handle() const noexcept -> const DataT* { return data_.data_handle(); }
+  // view() and data_handle() are inherited directly from MatrixT (raft::mdarray); no hand-written
+  // forwarding needed since MatrixT::view() const already returns exactly ViewT.
 };
 
 template <typename ViewT, typename DataT, typename IdxT>
-struct dense_row_major_dataset_view_storage {
-  ViewT data_;
+struct dense_row_major_dataset_view_storage : public ViewT {
   uint32_t logical_dim_;
 
+  // ViewT (mdspan) also has its own stride(size_t); pull it back into scope since declaring our
+  // own no-arg stride() below would otherwise hide it entirely (C++ name hiding), and the body of
+  // that stride() itself needs to call the inherited one.
+  using ViewT::stride;
+
   dense_row_major_dataset_view_storage() noexcept = default;
 
   explicit dense_row_major_dataset_view_storage(ViewT v) noexcept
-    : data_(v), logical_dim_(static_cast<uint32_t>(v.extent(1)))
+    : ViewT(v), logical_dim_(static_cast<uint32_t>(v.extent(1)))
   {
   }
 
   dense_row_major_dataset_view_storage(ViewT v, uint32_t logical_dim) noexcept
-    : data_(v), logical_dim_(logical_dim)
-  {
-  }
-
-  dense_row_major_dataset_view_storage(dense_row_major_dataset_view_storage const& other) noexcept
-    : data_(other.data_), logical_dim_(other.logical_dim_)
+    : ViewT(v), logical_dim_(logical_dim)
   {
   }
 
-  [[nodiscard]] auto n_rows() const noexcept -> IdxT { return data_.extent(0); }
+  [[nodiscard]] auto n_rows() const noexcept -> IdxT { return this->extent(0); }
   [[nodiscard]] auto dim() const noexcept -> uint32_t { return logical_dim_; }
   [[nodiscard]] auto stride() const noexcept -> uint32_t
   {
-    return static_cast<uint32_t>(data_.stride(0) > 0 ? data_.stride(0) : data_.extent(1));
+    return static_cast<uint32_t>(ViewT::stride(0) > 0 ? ViewT::stride(0) : this->extent(1));
   }
-  [[nodiscard]] auto view() const noexcept -> ViewT { return data_; }
+  // ViewT (mdspan) has no view() of its own -- it already *is* the view -- so this shrinks to a
+  // plain upcast instead of reaching into a wrapped field.
+  [[nodiscard]] auto view() const noexcept -> ViewT { return *this; }
 };
 
 template <typename MatrixT, typename ViewT, typename DataT, typename IdxT>

From ba608e5f8e1a01618296f9d71cd743b5df77ea4d Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Wed, 2 Sep 2026 08:29:43 -0700
Subject: [PATCH 02/15] Add experimental Spec-based dataset/dataset_view
 prototype (#2395)

as_dataset_view()/n_rows()/dim() can be shared across all dataset
kinds with zero per-kind dispatch inside dataset/dataset_view
themselves. Adds cuvs::neighbors::experimental::{dataset,dataset_view}
as a Spec/policy-based prototype: every member is a one-line forward
to spec_type::get_*(), with all kind-specific logic (empty_spec,
mdarray_spec, vpq_spec) living outside dataset/dataset_view, which
never name or branch on a concrete kind. dataset and dataset_view
stay two independent, non-inheriting types (no shared_ptr, no
"sometimes owning" object).

Purely additive: lives in its own namespace, not referenced by any
existing type, alias, or call site. Verified via a standalone sandbox
(all three specs, both dataset and dataset_view, asserting n_rows/dim/
as_dataset_view) and a full rebuild + DATASET_C_TEST (7/7) +
CAGRA_C_TEST (14/14) + PREPROCESSING_TEST (226/226) + NEIGHBORS_TEST
(339/339), all passing unchanged from before this commit.

Limitations / not yet done:
- Not wired up: the real dataset/dataset_view types (Container-tagged)
  and every downstream consumer (CAGRA build/search, serialization,
  the C API, compile-time classification traits like
  dataset_view_kind_of/is_padded_dataset_view_v) are untouched. This
  prototype does not replace them yet.
- mdarray_spec's layout choice for the padded case is unverified
  against CAGRA's actual alignment requirements -- needs confirmation
  before real use.
- No sparse (CSR/COO) or scalar-quantized specs; only empty/dense/vpq,
  matching today's four kinds minus the empty/dense split.
- This design is still an open thread with the team, not finalized;
  land as prototype only, pending further review.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 cpp/include/cuvs/neighbors/common.hpp | 237 ++++++++++++++++++++++++++
 1 file changed, 237 insertions(+)

diff --git a/cpp/include/cuvs/neighbors/common.hpp b/cpp/include/cuvs/neighbors/common.hpp
index e8654e6065..8f948b9bdc 100644
--- a/cpp/include/cuvs/neighbors/common.hpp
+++ b/cpp/include/cuvs/neighbors/common.hpp
@@ -36,6 +36,7 @@
 #include <string>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #ifdef __cpp_lib_bitops
 #include <bit>
 #endif
@@ -1354,6 +1355,242 @@ auto make_host_standard_dataset_view(SrcT const& src)
     host_standard_dataset_view<value_type, index_type>>(src, static_cast<uint32_t>(src.extent(1)));
 }
 
+// =====================================================================================
+// Experimental: Spec-based dataset/dataset_view prototype (#2395 follow-up).
+//
+// Not wired up to any public alias, trait, or downstream call site yet -- exists to validate the
+// design in isolation. `dataset<T,IdxT,SpecT>` and `dataset_view<T,IdxT,SpecT>` are single generic
+// templates with zero per-kind dispatch inside them: every member is a one-line forward to
+// `spec_type::get_*(...)`, and all kind-specific logic lives in the per-kind Spec structs below
+// (`empty_spec`, `mdarray_spec`, `vpq_spec`), which dataset/dataset_view never name or branch on.
+// `dataset` and `dataset_view` are deliberately two independent, non-inheriting types (no
+// shared_ptr, no "sometimes owning" object): `dataset` holds owning storage (mdarray-shaped),
+// `dataset_view` holds the corresponding view storage (mdspan-shaped); the same
+// `get_n_rows`/`get_dim` spec functions serve both, since `raft::mdarray`/`raft::mdspan` both
+// expose `.extent(r)`.
+// =====================================================================================
+namespace experimental {
+
+/**
+ * A spec defines a dictionary iff it needs a second storage slot to interpret the data (e.g. PQ
+ * codebooks). Non-compressed specs declare `dictionary_type = std::monostate` -- the same
+ * vocabulary type for "no dictionary," not just an omitted member -- so `dataset`/`dataset_view`
+ * never need to branch on whether the slot exists; they just always have one, sometimes empty.
+ */
+template <typename SpecT>
+concept compressed_dataset_spec = requires {
+  typename SpecT::dictionary_type;
+  typename SpecT::dictionary_view_type;
+} && !std::is_same_v<typename SpecT::dictionary_type, std::monostate>;
+
+// -----------------------------------------------------------------------------
+// empty
+// -----------------------------------------------------------------------------
+
+struct empty_spec {
+  struct rep {
+    uint32_t dim;
+  };
+
+  template <typename T, typename IdxT>
+  struct apply {
+    using value_type           = std::remove_cv_t<T>;
+    using index_type           = std::remove_cv_t<IdxT>;
+    using data_type            = rep;
+    using view_type            = rep;
+    using dictionary_type      = std::monostate;
+    using dictionary_view_type = std::monostate;
+
+    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
+    {
+      return data;
+    }
+    [[nodiscard]] static auto get_n_rows(rep const&) noexcept -> index_type { return 0; }
+    [[nodiscard]] static auto get_dim(rep const& data, dictionary_type const&) noexcept -> uint32_t
+    {
+      return data.dim;
+    }
+    [[nodiscard]] static auto get_dictionary_view(dictionary_type const&) noexcept
+      -> dictionary_view_type
+    {
+      return {};
+    }
+  };
+};
+
+// -----------------------------------------------------------------------------
+// dense (plain or padded), implemented via raft::mdarray
+// -----------------------------------------------------------------------------
+
+template <typename LayoutPolicy, typename ContainerPolicy>
+struct mdarray_spec {
+  template <typename T, typename IdxT>
+  struct apply {
+    using value_type = std::remove_cv_t<T>;
+    using index_type = std::remove_cv_t<IdxT>;
+    using data_type = raft::mdarray<T, raft::matrix_extent<int64_t>, LayoutPolicy, ContainerPolicy>;
+    // `get_data_view` takes `data_type const&`, so `.view()` resolves to the const overload,
+    // returning `const_view_type` (const element type) -- match that here, not the mutable
+    // `view_type`.
+    using view_type            = typename data_type::const_view_type;
+    using dictionary_type      = std::monostate;
+    using dictionary_view_type = std::monostate;
+
+    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
+    {
+      return data.view();
+    }
+    template <typename AnyExtentShaped>
+    [[nodiscard]] static auto get_n_rows(AnyExtentShaped const& data) noexcept -> index_type
+    {
+      return static_cast<index_type>(data.extent(0));
+    }
+    template <typename AnyExtentShaped>
+    [[nodiscard]] static auto get_dim(AnyExtentShaped const& data, dictionary_type const&) noexcept
+      -> uint32_t
+    {
+      return static_cast<uint32_t>(data.extent(1));
+    }
+    [[nodiscard]] static auto get_dictionary_view(dictionary_type const&) noexcept
+      -> dictionary_view_type
+    {
+      return {};
+    }
+  };
+};
+
+// -----------------------------------------------------------------------------
+// VPQ compressed: data = encoded rows (uint8_t codes); dictionary = {vq_code_book, pq_code_book}
+// -----------------------------------------------------------------------------
+
+template <typename MathT, typename BookPolicy, typename CodePolicy>
+struct vpq_spec {
+  template <typename IdxT>
+  using storage_spec =
+    typename mdarray_spec<raft::row_major, CodePolicy>::template apply<uint8_t, IdxT>;
+
+  template <typename T, typename IdxT>
+  struct apply : storage_spec<IdxT> {
+    using value_type = std::remove_cv_t<T>;
+    /* Members of a dependent base aren't visible to unqualified lookup, so pull these in. */
+    using typename storage_spec<IdxT>::data_type;
+    using typename storage_spec<IdxT>::view_type;
+    using math_type = MathT;
+
+    using vq_book_type =
+      raft::mdarray<math_type, raft::matrix_extent<int64_t>, raft::row_major, BookPolicy>;
+    using pq_book_type =
+      raft::mdarray<math_type, raft::matrix_extent<int64_t>, raft::row_major, BookPolicy>;
+
+    struct dictionary_type {
+      vq_book_type vq_code_book;
+      pq_book_type pq_code_book;
+    };
+    struct dictionary_view_type {
+      typename vq_book_type::const_view_type vq_code_book;
+      typename pq_book_type::const_view_type pq_code_book;
+    };
+
+    /* get_data_view/get_n_rows are inherited from storage_spec unchanged; only get_dim and
+    get_dictionary_view differ from a plain dense dataset, since the dimension comes from the VQ
+    codebook, not the encoded rows. */
+    template <typename AnyData, typename AnyDict>
+    [[nodiscard]] static auto get_dim(AnyData const&, AnyDict const& dict) noexcept -> uint32_t
+    {
+      return static_cast<uint32_t>(dict.vq_code_book.extent(1));
+    }
+    [[nodiscard]] static auto get_dictionary_view(dictionary_type const& dict) noexcept
+      -> dictionary_view_type
+    {
+      return {dict.vq_code_book.view(), dict.pq_code_book.view()};
+    }
+  };
+};
+
+// -----------------------------------------------------------------------------
+// dataset / dataset_view
+// -----------------------------------------------------------------------------
+
+template <typename T, typename IdxT, typename SpecT>
+struct dataset_view;
+
+/** Owning dataset: value-held storage (no shared_ptr -- exclusive ownership, like today's
+ * `dataset<Container,...>`). Every member is a one-line forward to `spec_type::get_*`; all
+ * per-kind logic lives in `SpecT`, never inside this struct. */
+template <typename T, typename IdxT, typename SpecT>
+struct dataset {
+  using spec_type       = typename SpecT::template apply<T, IdxT>;
+  using value_type      = typename spec_type::value_type;
+  using index_type      = typename spec_type::index_type;
+  using data_type       = typename spec_type::data_type;
+  using dictionary_type = typename spec_type::dictionary_type;
+
+  explicit dataset(data_type&& data, dictionary_type&& dictionary = dictionary_type{})
+    : data_{std::move(data)}, dictionary_{std::move(dictionary)}
+  {
+  }
+
+  [[nodiscard]] auto n_rows() const noexcept -> index_type { return spec_type::get_n_rows(data_); }
+  [[nodiscard]] auto dim() const noexcept -> uint32_t
+  {
+    return spec_type::get_dim(data_, dictionary_);
+  }
+  [[nodiscard]] auto data_view() const noexcept { return spec_type::get_data_view(data_); }
+  [[nodiscard]] auto dictionary_view() const noexcept
+  {
+    return spec_type::get_dictionary_view(dictionary_);
+  }
+
+  [[nodiscard]] auto as_dataset_view() const noexcept -> dataset_view<T, IdxT, SpecT>
+  {
+    return dataset_view<T, IdxT, SpecT>(data_view(), dictionary_view());
+  }
+
+ private:
+  data_type data_;
+  [[no_unique_address]] dictionary_type dictionary_;
+};
+
+/** Non-owning dataset view: holds only view-shaped storage (mdspan, not mdarray). Deliberately not
+ * derived from `dataset` -- a view type should hold "all view state" with no inheritance and no
+ * shared ownership tying it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec
+ * functions as `dataset`, fed view-shaped arguments instead of owning ones, since `raft::mdspan`
+ * exposes the same `.extent(r)` shape as `raft::mdarray`. */
+template <typename T, typename IdxT, typename SpecT>
+struct dataset_view {
+  using spec_type            = typename SpecT::template apply<T, IdxT>;
+  using value_type           = typename spec_type::value_type;
+  using index_type           = typename spec_type::index_type;
+  using view_type            = typename spec_type::view_type;
+  using dictionary_view_type = typename spec_type::dictionary_view_type;
+
+  explicit dataset_view(view_type data_view,
+                        dictionary_view_type dictionary_view = dictionary_view_type{}) noexcept
+    : data_view_{data_view}, dictionary_view_{dictionary_view}
+  {
+  }
+
+  [[nodiscard]] auto n_rows() const noexcept -> index_type
+  {
+    return spec_type::get_n_rows(data_view_);
+  }
+  [[nodiscard]] auto dim() const noexcept -> uint32_t
+  {
+    return spec_type::get_dim(data_view_, dictionary_view_);
+  }
+  [[nodiscard]] auto data_view() const noexcept -> view_type { return data_view_; }
+  [[nodiscard]] auto dictionary_view() const noexcept -> dictionary_view_type
+  {
+    return dictionary_view_;
+  }
+
+ private:
+  view_type data_view_;
+  [[no_unique_address]] dictionary_view_type dictionary_view_;
+};
+
+}  // namespace experimental
+
 namespace filtering {
 
 /**

From f56f6970948af7e6e308a90bf991081540806e0d Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Fri, 4 Sep 2026 16:23:30 -0700
Subject: [PATCH 03/15] Replace Container-tagged dataset/dataset_view with
 Spec-based design (#2395)

common.hpp's dataset<ContainerType,DataT,IdxT,Accessor>/dataset_view<...>
(four hand-specialized structs tagged by ContainerType) are replaced by
dataset<T,IdxT,SpecT>/dataset_view<T,IdxT,SpecT>: two independent,
non-inheriting types where every member is a one-line forward to a
per-kind Spec (empty_dataset_spec, padded_dataset_spec,
standard_dataset_spec, vpq_dataset_spec) -- no dispatch inside
dataset/dataset_view themselves. VPQ's codebooks move from three flat,
ungrouped matrices (vq_code_book, pq_code_book, data as direct members)
into a dictionary_type{vq_code_book, pq_code_book} bundle alongside data,
giving every kind the same shape (one data slot + one optional
dictionary slot). The old dataset_view -> owner back-pointer (.dset())
is removed; a VPQ view now holds its own dictionary_view() directly,
matching padded/standard views holding their own state.

Public aliases (device_padded_dataset<T,IdxT> etc.) keep their names and
2-arg construction signatures, so most call sites are unaffected. Call
sites that reached into dataset internals directly needed updating:
.view()/.stride() on a dataset or dataset_view -> .data_view(); raw
.vq_code_book/.pq_code_book/.data member access -> .dictionary_view()/
.data_view(); old 3-arg VPQ construction -> 2-arg (codes,
dictionary_type{vq,pq}). Touches CAGRA build/search/serialize/merge,
VPQ training (pq.cuh), SCANN, Vamana, HNSW export, multi-GPU CAGRA, and
the C API's product-quantizer codebook accessors (pq.cpp) -- the one
place the C API reaches into dataset internals rather than going through
the opaque cuvsDataset handle.

Also: removes detail::vpq_dataset_spec_impl (only empty/padded/standard/
vpq_dataset_spec exist as public specs; padded and standard share
dense_dataset_spec_impl since two tags need the same body, but VPQ had
no second tag to share with, so its body is now inlined directly into
vpq_dataset_spec, consistent with how empty_dataset_spec is already
written).

Verified: full rebuild clean; DATASET_C_TEST (7/7), CAGRA_C_TEST (14/14),
PREPROCESSING_TEST (226/226), NEIGHBORS_TEST (339/339) all pass.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 c/src/neighbors/cagra.cpp                     |    8 +-
 c/src/preprocessing/quantize/pq.cpp           |    8 +-
 cpp/include/cuvs/neighbors/common.hpp         | 1180 +++++++----------
 .../cuvs/preprocessing/quantize/pq.hpp        |   10 +-
 cpp/src/neighbors/cagra.cuh                   |    2 +-
 cpp/src/neighbors/detail/cagra/add_nodes.cuh  |    2 +-
 .../neighbors/detail/cagra/cagra_build.cuh    |   10 +-
 .../neighbors/detail/cagra/cagra_merge.cuh    |   24 +-
 .../neighbors/detail/cagra/cagra_search.cuh   |   10 +-
 .../detail/cagra/cagra_serialize.cuh          |   24 +-
 .../cagra/compute_distance_standard.hpp       |    7 +-
 .../detail/cagra/compute_distance_vpq.hpp     |   25 +-
 cpp/src/neighbors/detail/cagra/factory.cuh    |   17 +-
 .../neighbors/detail/dataset_serialize.hpp    |   14 +-
 cpp/src/neighbors/detail/hnsw.hpp             |   17 +-
 .../neighbors/detail/vamana/vamana_build.cuh  |   10 +-
 .../detail/vamana/vamana_serialize.cuh        |    6 +-
 cpp/src/neighbors/mg/mg_cagra_inst.cu.in      |   10 +-
 .../neighbors/scann/detail/scann_build.cuh    |    4 +-
 cpp/src/neighbors/tiered_index.cu             |    4 +-
 cpp/src/preprocessing/quantize/detail/pq.cuh  |   66 +-
 cpp/tests/neighbors/ann_cagra.cuh             |    4 +-
 .../ann_cagra/test_merge_fastener.cu          |   12 +-
 cpp/tests/neighbors/ann_scann.cuh             |    7 +-
 cpp/tests/neighbors/vpq_utils.cuh             |   14 +-
 .../preprocessing/product_quantization.cu     |    4 +-
 26 files changed, 685 insertions(+), 814 deletions(-)

diff --git a/c/src/neighbors/cagra.cpp b/c/src/neighbors/cagra.cpp
index 82dba5424d..5226b52737 100644
--- a/c/src/neighbors/cagra.cpp
+++ b/c/src/neighbors/cagra.cpp
@@ -144,7 +144,7 @@ static void merge_indices_for_layout(
       cuvs::neighbors::cagra::detail::merged_dataset_size<T, uint32_t, DatasetViewT>(
         *res_ptr, index_ptrs, row_filter);
     auto const dim    = static_cast<uint32_t>(index_ptrs.front()->dim());
-    auto const stride = static_cast<int64_t>(index_ptrs.front()->dataset().stride());
+    auto const stride = static_cast<int64_t>(index_ptrs.front()->dataset().data_view().stride());
 
     try {
       auto matrix = raft::make_device_matrix<T, int64_t>(*res_ptr, final_row_count, stride);
@@ -192,8 +192,8 @@ static void merge_indices_for_layout(
       auto const& input = index->dataset();
       raft::copy_matrix(matrix.data_handle() + row_offset * static_cast<std::size_t>(stride),
                         static_cast<std::size_t>(stride),
-                        input.view().data_handle(),
-                        static_cast<std::size_t>(input.stride()),
+                        input.data_view().data_handle(),
+                        static_cast<std::size_t>(input.data_view().stride()),
                         static_cast<std::size_t>(dim),
                         static_cast<std::size_t>(input.n_rows()),
                         stream);
@@ -1159,7 +1159,7 @@ void get_dataset_view(cuvsCagraIndex_t index, DLManagedTensor* dataset)
     box,
     "cuvsCagraIndexGetDataset: null index handle",
     "cuvsCagraIndexGetDataset: host indices are allowed",
-    [&](auto& idx) { cuvs::core::to_dlpack(idx.dataset().view(), dataset); });
+    [&](auto& idx) { cuvs::core::to_dlpack(idx.dataset().data_view(), dataset); });
 }
 
 template <typename T, typename IdxT>
diff --git a/c/src/preprocessing/quantize/pq.cpp b/c/src/preprocessing/quantize/pq.cpp
index 1e3a48694a..9b6a616e0f 100644
--- a/c/src/preprocessing/quantize/pq.cpp
+++ b/c/src/preprocessing/quantize/pq.cpp
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -244,7 +244,8 @@ extern "C" cuvsError_t cuvsProductQuantizerGetPqCodebook(cuvsProductQuantizer_t
       if (quantizer->dtype.code == kDLFloat && quantizer->dtype.bits == 32) {
         auto pq_mdspan =
           (reinterpret_cast<cuvs::preprocessing::quantize::pq::quantizer<float>*>(quant_addr))
-            ->vpq_codebooks.pq_code_book.view();
+            ->vpq_codebooks.dictionary_view()
+            .pq_code_book;
         cuvs::core::to_dlpack(pq_mdspan, pq_codebook);
       } else {
         RAFT_FAIL("Unsupported quantizer dtype: %d and bits: %d",
@@ -266,7 +267,8 @@ extern "C" cuvsError_t cuvsProductQuantizerGetVqCodebook(cuvsProductQuantizer_t
       if (quantizer->dtype.code == kDLFloat && quantizer->dtype.bits == 32) {
         auto pq_mdspan =
           (reinterpret_cast<cuvs::preprocessing::quantize::pq::quantizer<float>*>(quant_addr))
-            ->vpq_codebooks.vq_code_book.view();
+            ->vpq_codebooks.dictionary_view()
+            .vq_code_book;
         cuvs::core::to_dlpack(pq_mdspan, vq_codebook);
       } else {
         RAFT_FAIL("Unsupported quantizer dtype: %d and bits: %d",
diff --git a/cpp/include/cuvs/neighbors/common.hpp b/cpp/include/cuvs/neighbors/common.hpp
index 8f948b9bdc..46ef145412 100644
--- a/cpp/include/cuvs/neighbors/common.hpp
+++ b/cpp/include/cuvs/neighbors/common.hpp
@@ -148,21 +148,37 @@ enum class MergeStrategy {
 /** @} */  // end group neighbors_index
 
 /**
- * @brief Tags selecting dataset representation for `dataset` / `dataset_view`.
+ * @brief Spec-based `dataset` / `dataset_view`.
  *
- * Each container defines nested `owning_storage` then `view_storage` (aliases into `detail::*`
- * storage types shared by device/host). Accessibility (device vs host) is selected by the
- * `Accessor` template parameter on `dataset` / `dataset_view`, not by duplicating containers.
- * Layout kinds: empty, padded, standard, VPQ. `dataset` / `dataset_view` only express ownership
- * vs view.
+ * `dataset<T,IdxT,SpecT>` and `dataset_view<T,IdxT,SpecT>` are single generic templates with zero
+ * per-kind dispatch inside them: every member is a one-line forward to `spec_type::get_*(...)`,
+ * and all kind-specific logic lives in the per-kind Spec structs below (`empty_dataset_spec`,
+ * `padded_dataset_spec`, `standard_dataset_spec`, `vpq_dataset_spec`), which `dataset`/
+ * `dataset_view` never name or branch on. `dataset` and `dataset_view` are deliberately two
+ * independent, non-inheriting types (no shared_ptr, no "sometimes owning" object): `dataset` holds
+ * owning storage (mdarray-shaped), `dataset_view` holds the corresponding view storage
+ * (mdspan-shaped). The same `get_n_rows`/`get_dim` spec functions serve both, since
+ * `raft::mdarray`/`raft::mdspan` both expose `.extent(r)`.
  */
 
-template <typename ContainerType, typename DataT, typename IdxT, typename Accessor>
+template <typename T, typename IdxT, typename SpecT>
 struct dataset;
 
-template <typename ContainerType, typename DataT, typename IdxT, typename Accessor>
+template <typename T, typename IdxT, typename SpecT>
 struct dataset_view;
 
+/**
+ * A spec defines a dictionary iff it needs a second storage slot to interpret the data (e.g. PQ
+ * codebooks). Non-compressed specs declare `dictionary_type = std::monostate` -- the same
+ * vocabulary type for "no dictionary," not just an omitted member -- so `dataset`/`dataset_view`
+ * never need to branch on whether the slot exists; they just always have one, sometimes empty.
+ */
+template <typename SpecT>
+concept compressed_dataset_spec = requires {
+  typename SpecT::dictionary_type;
+  typename SpecT::dictionary_view_type;
+} && !std::is_same_v<typename SpecT::dictionary_type, std::monostate>;
+
 namespace detail {
 
 // Default owning/view accessors for public dataset aliases.
@@ -234,20 +250,14 @@ struct empty_dataset_storage {
   [[nodiscard]] auto dim() const noexcept -> uint32_t { return suggested_dim; }
 };
 
-template <typename IdxT>
-using empty_dataset_owning_storage = empty_dataset_storage<IdxT>;
-
-template <typename IdxT>
-using empty_dataset_view_storage = empty_dataset_storage<IdxT>;
-
 // -----------------------------------------------------------------------------
 // dense row-major (logical dim may differ from row pitch; shared by padded & standard)
 // -----------------------------------------------------------------------------
 
 /**
- * Dense row-major owning storage shared by padded and standard dataset containers. Publicly
- * inherits from MatrixT (an `raft::mdarray`) so `view()`/`data_handle()`/`extent()` etc. are
- * reused as-is rather than hand-forwarded; `logical_dim_` is the only state this struct adds.
+ * Dense row-major owning storage shared by padded and standard dataset specs. Publicly inherits
+ * from MatrixT (a `raft::mdarray`) so `view()`/`data_handle()`/`extent()` etc. are reused as-is
+ * rather than hand-forwarded; `logical_dim_` is the only state this struct adds.
  *
  * Template parameters:
  * - MatrixT: owning matrix type that stores the payload (host/device matrix).
@@ -310,326 +320,388 @@ struct dense_row_major_dataset_view_storage : public ViewT {
   [[nodiscard]] auto view() const noexcept -> ViewT { return *this; }
 };
 
-template <typename MatrixT, typename ViewT, typename DataT, typename IdxT>
-using padded_dataset_owning_storage =
-  dense_row_major_dataset_owning_storage<MatrixT, ViewT, DataT, IdxT>;
-
-template <typename ViewT, typename DataT, typename IdxT>
-using padded_dataset_view_storage = dense_row_major_dataset_view_storage<ViewT, DataT, IdxT>;
+/** Spec-side implementation shared by `padded_dataset_spec`/`standard_dataset_spec`; those two
+ * stay distinct top-level types (identical bodies) purely so classification traits can tell them
+ * apart -- exactly mirroring today's `padded_dataset_container`/`standard_dataset_container`,
+ * which are likewise two differently-named tags over one shared storage implementation. */
+template <typename ContainerPolicy>
+struct dense_dataset_spec_impl {
+  template <typename T, typename IdxT>
+  struct apply {
+    using value_type           = std::remove_cv_t<T>;
+    using index_type           = std::remove_cv_t<IdxT>;
+    using MatrixT              = dense_owning_matrix<T, IdxT, ContainerPolicy>;
+    using ViewT                = dense_view_matrix<T, IdxT, ContainerPolicy>;
+    using data_type            = dense_row_major_dataset_owning_storage<MatrixT, ViewT, T, IdxT>;
+    using view_type            = dense_row_major_dataset_view_storage<ViewT, T, IdxT>;
+    using dictionary_type      = std::monostate;
+    using dictionary_view_type = std::monostate;
 
-template <typename MatrixT, typename ViewT, typename DataT, typename IdxT>
-using standard_dataset_owning_storage =
-  dense_row_major_dataset_owning_storage<MatrixT, ViewT, DataT, IdxT>;
+    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
+    {
+      return view_type(data.view(), data.dim());
+    }
+    template <typename AnyDatasetOrView>
+    [[nodiscard]] static auto get_n_rows(AnyDatasetOrView const& data) noexcept -> index_type
+    {
+      return data.n_rows();
+    }
+    template <typename AnyDatasetOrView>
+    [[nodiscard]] static auto get_dim(AnyDatasetOrView const& data, dictionary_type const&) noexcept
+      -> uint32_t
+    {
+      return data.dim();
+    }
+    [[nodiscard]] static auto get_dictionary_view(dictionary_type const&) noexcept
+      -> dictionary_view_type
+    {
+      return {};
+    }
+  };
+};
 
-template <typename ViewT, typename DataT, typename IdxT>
-using standard_dataset_view_storage = dense_row_major_dataset_view_storage<ViewT, DataT, IdxT>;
+}  // namespace detail
 
 // -----------------------------------------------------------------------------
-// VPQ compressed
+// Public specs -- the only place per-kind logic lives.
 // -----------------------------------------------------------------------------
 
-/**
- * Owning storage for VPQ-compressed datasets.
- *
- * Template parameters:
- * - VqBookMatrixT: owning matrix type for the VQ codebook.
- * - PqBookMatrixT: owning matrix type for the PQ codebook.
- * - DataMatrixT: owning matrix type for encoded row data (uint8 codes).
- * - MathT: floating-point type used by VQ/PQ codebooks.
- * - IdxT: index type used for row counts (`n_rows()` return type).
- */
-template <typename VqBookMatrixT,
-          typename PqBookMatrixT,
-          typename DataMatrixT,
-          typename MathT,
-          typename IdxT>
-struct vpq_dataset_owning_storage {
-  /** Floating-point type used for VQ/PQ codebooks (rows are still uint8 codes). */
-  using math_type = MathT;
-
-  VqBookMatrixT vq_code_book;
-  PqBookMatrixT pq_code_book;
-  DataMatrixT data;
-
-  vpq_dataset_owning_storage(VqBookMatrixT&& vq_code_book,
-                             PqBookMatrixT&& pq_code_book,
-                             DataMatrixT&& data) noexcept
-    : vq_code_book{std::move(vq_code_book)},
-      pq_code_book{std::move(pq_code_book)},
-      data{std::move(data)}
-  {
-  }
+template <typename Accessor>
+struct empty_dataset_spec {
+  using accessor_type = Accessor;
 
-  [[nodiscard]] auto n_rows() const noexcept -> IdxT { return data.extent(0); }
-  [[nodiscard]] auto dim() const noexcept -> uint32_t { return vq_code_book.extent(1); }
+  template <typename T, typename IdxT>
+  struct apply {
+    using value_type           = std::remove_cv_t<T>;
+    using index_type           = std::remove_cv_t<IdxT>;
+    using data_type            = detail::empty_dataset_storage<IdxT>;
+    using view_type            = detail::empty_dataset_storage<IdxT>;
+    using dictionary_type      = std::monostate;
+    using dictionary_view_type = std::monostate;
 
-  [[nodiscard]] constexpr inline auto encoded_row_length() const noexcept -> uint32_t
-  {
-    return data.extent(1);
-  }
-  [[nodiscard]] constexpr inline auto vq_n_centers() const noexcept -> uint32_t
-  {
-    return vq_code_book.extent(0);
-  }
-  [[nodiscard]] constexpr inline auto pq_bits() const noexcept -> uint32_t
-  {
-    auto pq_width = pq_n_centers();
-#ifdef __cpp_lib_bitops
-    return std::countr_zero(pq_width);
-#else
-    uint32_t pq_bits = 0;
-    while (pq_width > 1) {
-      pq_bits++;
-      pq_width >>= 1;
+    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
+    {
+      return data;
     }
-    return pq_bits;
-#endif
-  }
-  [[nodiscard]] constexpr inline auto pq_dim() const noexcept -> uint32_t
-  {
-    return raft::div_rounding_up_unsafe(dim(), pq_len());
-  }
-  [[nodiscard]] constexpr inline auto pq_len() const noexcept -> uint32_t
-  {
-    return pq_code_book.extent(1);
-  }
-  [[nodiscard]] constexpr inline auto pq_n_centers() const noexcept -> uint32_t
-  {
-    return pq_code_book.extent(0);
-  }
+    [[nodiscard]] static auto get_n_rows(data_type const& data) noexcept -> index_type
+    {
+      return static_cast<index_type>(data.n_rows());
+    }
+    [[nodiscard]] static auto get_dim(data_type const& data, dictionary_type const&) noexcept
+      -> uint32_t
+    {
+      return data.dim();
+    }
+    [[nodiscard]] static auto get_dictionary_view(dictionary_type const&) noexcept
+      -> dictionary_view_type
+    {
+      return {};
+    }
+  };
 };
 
-template <typename ContainerType, typename DataT, typename IdxT, typename Accessor>
-struct vpq_dataset_view_storage {
-  using owning_dataset_type =
-    dataset<ContainerType, DataT, IdxT, dataset_owning_accessor_for_view<DataT, Accessor>>;
-
-  owning_dataset_type const* dataset_{nullptr};
-
-  vpq_dataset_view_storage() = default;
-
-  explicit vpq_dataset_view_storage(owning_dataset_type const* ptr) : dataset_(ptr)
-  {
-    RAFT_EXPECTS(ptr != nullptr, "vpq_dataset_view: null dataset pointer");
-  }
+template <typename ContainerPolicy>
+struct padded_dataset_spec {
+  using accessor_type = ContainerPolicy;
+  template <typename T, typename IdxT>
+  struct apply : detail::dense_dataset_spec_impl<ContainerPolicy>::template apply<T, IdxT> {};
+};
 
-  [[nodiscard]] auto n_rows() const noexcept
-  {
-    using idx_type = decltype(std::declval<owning_dataset_type const&>().n_rows());
-    return dataset_ != nullptr ? dataset_->n_rows() : idx_type{0};
-  }
-  [[nodiscard]] auto dim() const noexcept -> uint32_t
-  {
-    return dataset_ != nullptr ? dataset_->dim() : uint32_t{0};
-  }
-  [[nodiscard]] owning_dataset_type const& dset() const noexcept { return *dataset_; }
+template <typename ContainerPolicy>
+struct standard_dataset_spec {
+  using accessor_type = ContainerPolicy;
+  template <typename T, typename IdxT>
+  struct apply : detail::dense_dataset_spec_impl<ContainerPolicy>::template apply<T, IdxT> {};
 };
 
-}  // namespace detail
+/** `Accessor` drives both codebook and code residency, mirroring today's
+ * single-`Accessor`-per-VPQ-dataset design (`vpq_vq_book_matrix`/`vpq_data_matrix` are both keyed
+ * off one `Accessor`). Data = encoded rows (uint8_t codes); dictionary = {vq_code_book,
+ * pq_code_book}. Inlined directly (unlike padded/standard) since no second tag shares this body. */
+template <typename MathT, typename Accessor>
+struct vpq_dataset_spec {
+  using accessor_type = Accessor;
 
-// -----------------------------------------------------------------------------
-// empty
-// -----------------------------------------------------------------------------
+  template <typename T, typename IdxT>
+  struct apply {
+    using value_type = std::remove_cv_t<T>;
+    using index_type = std::remove_cv_t<IdxT>;
+    using math_type  = MathT;
 
-struct empty_dataset_container {
-  template <typename IdxT, typename Accessor>
-  using owning_storage = detail::empty_dataset_owning_storage<IdxT>;
-  template <typename IdxT, typename Accessor>
-  using view_storage = detail::empty_dataset_view_storage<IdxT>;
-};
+    using data_type = detail::vpq_data_matrix<IdxT, Accessor>;
+    using view_type = raft::mdspan<const uint8_t,
+                                   raft::matrix_extent<IdxT>,
+                                   raft::row_major,
+                                   detail::dataset_view_accessor_for_owning<uint8_t, Accessor>>;
 
-// -----------------------------------------------------------------------------
-// padded (row-major with logical dim vs stride)
-// -----------------------------------------------------------------------------
+    using vq_book_type = detail::vpq_vq_book_matrix<MathT, IdxT, Accessor>;
+    using pq_book_type = detail::vpq_vq_book_matrix<MathT, IdxT, Accessor>;
 
-struct padded_dataset_container {
-  template <typename DataT, typename IdxT, typename Accessor>
-  using owning_storage =
-    detail::padded_dataset_owning_storage<detail::dense_owning_matrix<DataT, IdxT, Accessor>,
-                                          detail::dense_view_matrix<DataT, IdxT, Accessor>,
-                                          DataT,
-                                          IdxT>;
-  template <typename DataT, typename IdxT, typename Accessor>
-  using view_storage = detail::
-    padded_dataset_view_storage<detail::dense_view_matrix<DataT, IdxT, Accessor>, DataT, IdxT>;
-};
+    struct dictionary_type {
+      vq_book_type vq_code_book;
+      pq_book_type pq_code_book;
+    };
+    struct dictionary_view_type {
+      typename vq_book_type::const_view_type vq_code_book;
+      typename pq_book_type::const_view_type pq_code_book;
 
-// -----------------------------------------------------------------------------
-// standard (row-major with arbitrary stride; no CAGRA alignment requirement)
-// -----------------------------------------------------------------------------
+      [[nodiscard]] auto dim() const noexcept -> uint32_t
+      {
+        return static_cast<uint32_t>(vq_code_book.extent(1));
+      }
+      [[nodiscard]] auto vq_n_centers() const noexcept -> uint32_t
+      {
+        return static_cast<uint32_t>(vq_code_book.extent(0));
+      }
+      [[nodiscard]] auto pq_n_centers() const noexcept -> uint32_t
+      {
+        return static_cast<uint32_t>(pq_code_book.extent(0));
+      }
+      [[nodiscard]] auto pq_len() const noexcept -> uint32_t
+      {
+        return static_cast<uint32_t>(pq_code_book.extent(1));
+      }
+      [[nodiscard]] auto pq_bits() const noexcept -> uint32_t
+      {
+        auto pq_width = pq_n_centers();
+#ifdef __cpp_lib_bitops
+        return std::countr_zero(pq_width);
+#else
+        uint32_t bits = 0;
+        while (pq_width > 1) {
+          bits++;
+          pq_width >>= 1;
+        }
+        return bits;
+#endif
+      }
+      [[nodiscard]] auto pq_dim() const noexcept -> uint32_t
+      {
+        return raft::div_rounding_up_unsafe(dim(), pq_len());
+      }
+    };
 
-struct standard_dataset_container {
-  template <typename DataT, typename IdxT, typename Accessor>
-  using owning_storage =
-    detail::standard_dataset_owning_storage<detail::dense_owning_matrix<DataT, IdxT, Accessor>,
-                                            detail::dense_view_matrix<DataT, IdxT, Accessor>,
-                                            DataT,
-                                            IdxT>;
-  template <typename DataT, typename IdxT, typename Accessor>
-  using view_storage = detail::
-    standard_dataset_view_storage<detail::dense_view_matrix<DataT, IdxT, Accessor>, DataT, IdxT>;
+    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
+    {
+      return data.view();
+    }
+    template <typename AnyExtentShaped>
+    [[nodiscard]] static auto get_n_rows(AnyExtentShaped const& data) noexcept -> index_type
+    {
+      return static_cast<index_type>(data.extent(0));
+    }
+    /* get_dim differs from a plain dense dataset: the dimension comes from the VQ codebook, not
+    the encoded rows (row padding makes the encoded-row width ambiguous as a dimension). */
+    template <typename AnyData>
+    [[nodiscard]] static auto get_dim(AnyData const&, dictionary_type const& dict) noexcept
+      -> uint32_t
+    {
+      return static_cast<uint32_t>(dict.vq_code_book.extent(1));
+    }
+    template <typename AnyData>
+    [[nodiscard]] static auto get_dim(AnyData const&, dictionary_view_type const& dict) noexcept
+      -> uint32_t
+    {
+      return dict.dim();
+    }
+    [[nodiscard]] static auto get_dictionary_view(dictionary_type const& dict) noexcept
+      -> dictionary_view_type
+    {
+      return {dict.vq_code_book.view(), dict.pq_code_book.view()};
+    }
+    [[nodiscard]] static auto get_encoded_row_length(data_type const& data) noexcept -> uint32_t
+    {
+      return static_cast<uint32_t>(data.extent(1));
+    }
+    [[nodiscard]] static auto get_encoded_row_length(view_type const& data) noexcept -> uint32_t
+    {
+      return static_cast<uint32_t>(data.extent(1));
+    }
+  };
 };
 
 // -----------------------------------------------------------------------------
-// VPQ compressed
+// dataset / dataset_view
 // -----------------------------------------------------------------------------
 
-struct vpq_dataset_container {
-  template <typename MathT, typename IdxT, typename Accessor>
-  using owning_storage =
-    detail::vpq_dataset_owning_storage<detail::vpq_vq_book_matrix<MathT, IdxT, Accessor>,
-                                       detail::vpq_vq_book_matrix<MathT, IdxT, Accessor>,
-                                       detail::vpq_data_matrix<IdxT, Accessor>,
-                                       MathT,
-                                       IdxT>;
-  template <typename MathT, typename IdxT, typename Accessor>
-  using view_storage =
-    detail::vpq_dataset_view_storage<vpq_dataset_container, MathT, IdxT, Accessor>;
-};
-
-template <typename ContainerType, typename DataT, typename IdxT, typename Accessor>
+/** Owning dataset: value-held storage (no shared_ptr -- exclusive ownership). Every member is a
+ * one-line forward to `spec_type::get_*`; all per-kind logic lives in `SpecT`, never inside this
+ * struct. */
+template <typename T, typename IdxT, typename SpecT>
 struct dataset {
-  static_assert(!std::is_same_v<ContainerType, ContainerType>,
-                "dataset: unsupported ContainerType / type-parameter combination");
-};
+  using spec_type       = typename SpecT::template apply<T, IdxT>;
+  using value_type      = typename spec_type::value_type;
+  using index_type      = typename spec_type::index_type;
+  using data_type       = typename spec_type::data_type;
+  using dictionary_type = typename spec_type::dictionary_type;
 
-template <typename ContainerType, typename DataT, typename IdxT, typename Accessor>
-struct dataset_view {
-  static_assert(!std::is_same_v<ContainerType, ContainerType>,
-                "dataset_view: unsupported ContainerType / type-parameter combination");
-};
+  // Non-compressed: forward constructor args straight to data_type's own constructor (e.g.
+  // (MatrixT&&, uint32_t logical_dim) for dense, (uint32_t dim) for empty) -- preserves today's
+  // construction call sites unchanged.
+  template <typename... Args>
+  explicit dataset(Args&&... args)
+    requires(!compressed_dataset_spec<spec_type> && std::is_constructible_v<data_type, Args...>)
+    : data_(std::forward<Args>(args)...), dictionary_{}
+  {
+  }
 
-// -----------------------------------------------------------------------------
-// empty
-// -----------------------------------------------------------------------------
+  // Compressed: data (codes) and dictionary (codebooks) constructed independently.
+  dataset(data_type&& data, dictionary_type&& dictionary)
+    requires(compressed_dataset_spec<spec_type>)
+    : data_(std::move(data)), dictionary_(std::move(dictionary))
+  {
+  }
 
-template <typename IdxT, typename Accessor>
-struct dataset<empty_dataset_container, void, IdxT, Accessor>
-  : empty_dataset_container::template owning_storage<IdxT, Accessor> {
-  using container_type      = empty_dataset_container;
-  using owning_storage_type = typename container_type::template owning_storage<IdxT, Accessor>;
-  using owning_storage_type::owning_storage_type;
-
-  [[nodiscard]] auto as_dataset_view() const noexcept
-    -> dataset_view<empty_dataset_container,
-                    void,
-                    IdxT,
-                    detail::dataset_view_accessor_for_owning<char, Accessor>>
+  [[nodiscard]] auto n_rows() const noexcept -> index_type { return spec_type::get_n_rows(data_); }
+  [[nodiscard]] auto dim() const noexcept -> uint32_t
   {
-    return dataset_view<empty_dataset_container,
-                        void,
-                        IdxT,
-                        detail::dataset_view_accessor_for_owning<char, Accessor>>{this->dim()};
+    return spec_type::get_dim(data_, dictionary_);
+  }
+  [[nodiscard]] auto data_view() const noexcept { return spec_type::get_data_view(data_); }
+  [[nodiscard]] auto dictionary_view() const noexcept
+  {
+    return spec_type::get_dictionary_view(dictionary_);
   }
-};
 
-template <typename IdxT, typename Accessor>
-struct dataset_view<empty_dataset_container, void, IdxT, Accessor>
-  : empty_dataset_container::template view_storage<IdxT, Accessor> {
-  using container_type    = empty_dataset_container;
-  using view_storage_type = typename container_type::template view_storage<IdxT, Accessor>;
-  using view_storage_type::view_storage_type;
-};
+  [[nodiscard]] auto as_dataset_view() const noexcept -> dataset_view<T, IdxT, SpecT>
+  {
+    return dataset_view<T, IdxT, SpecT>(data_view(), dictionary_view());
+  }
 
-// -----------------------------------------------------------------------------
-// standard (row-major with arbitrary stride)
-// -----------------------------------------------------------------------------
+  // Move the owning storage out (e.g. to reuse an already-encoded codes matrix while rebuilding
+  // only the dictionary at a different math_type, as in VPQ's f32->f16 conversion path).
+  [[nodiscard]] auto release_data() noexcept -> data_type&& { return std::move(data_); }
+  [[nodiscard]] auto release_dictionary() noexcept -> dictionary_type&&
+  {
+    return std::move(dictionary_);
+  }
 
-template <typename DataT, typename IdxT, typename Accessor>
-struct dataset<standard_dataset_container, DataT, IdxT, Accessor>
-  : standard_dataset_container::template owning_storage<DataT, IdxT, Accessor> {
-  using container_type = standard_dataset_container;
-  using owning_storage_type =
-    typename container_type::template owning_storage<DataT, IdxT, Accessor>;
-  using owning_storage_type::owning_storage_type;
-
-  [[nodiscard]] auto as_dataset_view() const noexcept
-    -> dataset_view<standard_dataset_container,
-                    DataT,
-                    IdxT,
-                    detail::dataset_view_accessor_for_owning<DataT, Accessor>>
+  // Dictionary-derived helpers (VPQ: encoded_row_length/vq_n_centers/pq_bits/pq_dim/pq_len/
+  // pq_n_centers) forward through dictionary_view() when the dictionary provides them; SFINAE'd
+  // away for kinds without a dictionary, matching today's VPQ-only surface without dataset<>
+  // itself branching on which kind it is.
+  [[nodiscard]] auto encoded_row_length() const noexcept
+    requires requires(data_type const& d) { spec_type::get_encoded_row_length(d); }
   {
-    return dataset_view<standard_dataset_container,
-                        DataT,
-                        IdxT,
-                        detail::dataset_view_accessor_for_owning<DataT, Accessor>>(this->view(),
-                                                                                   this->dim());
+    return spec_type::get_encoded_row_length(data_);
+  }
+  [[nodiscard]] auto vq_n_centers() const noexcept
+    requires requires(decltype(dictionary_view()) const& d) { d.vq_n_centers(); }
+  {
+    return dictionary_view().vq_n_centers();
+  }
+  [[nodiscard]] auto pq_n_centers() const noexcept
+    requires requires(decltype(dictionary_view()) const& d) { d.pq_n_centers(); }
+  {
+    return dictionary_view().pq_n_centers();
+  }
+  [[nodiscard]] auto pq_len() const noexcept
+    requires requires(decltype(dictionary_view()) const& d) { d.pq_len(); }
+  {
+    return dictionary_view().pq_len();
+  }
+  [[nodiscard]] auto pq_bits() const noexcept
+    requires requires(decltype(dictionary_view()) const& d) { d.pq_bits(); }
+  {
+    return dictionary_view().pq_bits();
+  }
+  [[nodiscard]] auto pq_dim() const noexcept
+    requires requires(decltype(dictionary_view()) const& d) { d.pq_dim(); }
+  {
+    return dictionary_view().pq_dim();
   }
-};
 
-template <typename DataT, typename IdxT, typename Accessor>
-struct dataset_view<standard_dataset_container, DataT, IdxT, Accessor>
-  : standard_dataset_container::template view_storage<DataT, IdxT, Accessor> {
-  using container_type    = standard_dataset_container;
-  using view_storage_type = typename container_type::template view_storage<DataT, IdxT, Accessor>;
-  using view_storage_type::view_storage_type;
+ private:
+  data_type data_;
+  [[no_unique_address]] dictionary_type dictionary_;
 };
 
-// -----------------------------------------------------------------------------
-// padded (row-major with logical dim vs stride)
-// -----------------------------------------------------------------------------
+/** Non-owning dataset view: holds only view-shaped storage (mdspan, not mdarray). Deliberately not
+ * derived from `dataset` -- a view type holds "all view state" with no inheritance and no shared
+ * ownership tying it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec functions as
+ * `dataset`, fed view-shaped arguments instead of owning ones. */
+template <typename T, typename IdxT, typename SpecT>
+struct dataset_view {
+  using spec_type            = typename SpecT::template apply<T, IdxT>;
+  using value_type           = typename spec_type::value_type;
+  using index_type           = typename spec_type::index_type;
+  using view_type            = typename spec_type::view_type;
+  using dictionary_view_type = typename spec_type::dictionary_view_type;
 
-template <typename DataT, typename IdxT, typename Accessor>
-struct dataset<padded_dataset_container, DataT, IdxT, Accessor>
-  : padded_dataset_container::template owning_storage<DataT, IdxT, Accessor> {
-  using container_type = padded_dataset_container;
-  using owning_storage_type =
-    typename container_type::template owning_storage<DataT, IdxT, Accessor>;
-  using owning_storage_type::owning_storage_type;
-
-  [[nodiscard]] auto as_dataset_view() const noexcept
-    -> dataset_view<padded_dataset_container,
-                    DataT,
-                    IdxT,
-                    detail::dataset_view_accessor_for_owning<DataT, Accessor>>
+  dataset_view() noexcept = default;
+
+  // Already-constructed (view_type, dictionary_view_type) pair -- the shape `as_dataset_view()`
+  // always constructs with, for every kind (dictionary_view_type is std::monostate and
+  // defaults away when there's no dictionary). Not a template, so it's preferred over the
+  // forwarding constructor below whenever both could apply.
+  dataset_view(view_type data_view, dictionary_view_type dictionary_view = {}) noexcept
+    : data_view_{data_view}, dictionary_view_{dictionary_view}
   {
-    return dataset_view<padded_dataset_container,
-                        DataT,
-                        IdxT,
-                        detail::dataset_view_accessor_for_owning<DataT, Accessor>>(this->view(),
-                                                                                   this->dim());
   }
-};
 
-template <typename DataT, typename IdxT, typename Accessor>
-struct dataset_view<padded_dataset_container, DataT, IdxT, Accessor>
-  : padded_dataset_container::template view_storage<DataT, IdxT, Accessor> {
-  using container_type    = padded_dataset_container;
-  using view_storage_type = typename container_type::template view_storage<DataT, IdxT, Accessor>;
-  using view_storage_type::view_storage_type;
-};
+  // Forward raw constructor args straight to view_type's own constructor (e.g. (ViewT, uint32_t
+  // logical_dim) for dense, (uint32_t dim) for empty) -- preserves today's direct-construction
+  // call sites (e.g. `device_padded_dataset_view<T,IdxT>(raw_mdspan, dim)`) unchanged. `view_type`
+  // is never itself constructible from `(view_type, dictionary_view_type)` (its own constructors
+  // only take mdspan-shaped args), so this and the plain constructor above never both match the
+  // same call -- no ambiguity.
+  template <typename... Args>
+  explicit dataset_view(Args&&... args)
+    requires(std::is_constructible_v<view_type, Args...>)
+    : data_view_(std::forward<Args>(args)...), dictionary_view_{}
+  {
+  }
 
-// -----------------------------------------------------------------------------
-// VPQ compressed (view holds non-owning pointer to owning dataset)
-// -----------------------------------------------------------------------------
+  [[nodiscard]] auto n_rows() const noexcept -> index_type
+  {
+    return spec_type::get_n_rows(data_view_);
+  }
+  [[nodiscard]] auto dim() const noexcept -> uint32_t
+  {
+    return spec_type::get_dim(data_view_, dictionary_view_);
+  }
+  [[nodiscard]] auto data_view() const noexcept -> view_type { return data_view_; }
+  [[nodiscard]] auto dictionary_view() const noexcept -> dictionary_view_type
+  {
+    return dictionary_view_;
+  }
 
-template <typename DataT, typename IdxT, typename Accessor>
-struct dataset<vpq_dataset_container, DataT, IdxT, Accessor>
-  : vpq_dataset_container::template owning_storage<DataT, IdxT, Accessor> {
-  using container_type = vpq_dataset_container;
-  using owning_storage_type =
-    typename container_type::template owning_storage<DataT, IdxT, Accessor>;
-  using owning_storage_type::owning_storage_type;
-
-  [[nodiscard]] auto as_dataset_view() const
-    -> dataset_view<vpq_dataset_container,
-                    DataT,
-                    IdxT,
-                    detail::dataset_view_accessor_for_owning<DataT, Accessor>>
+  // See dataset<>'s equivalent block: VPQ-only helpers, SFINAE'd away for kinds without a
+  // dictionary.
+  [[nodiscard]] auto encoded_row_length() const noexcept
+    requires requires(view_type const& d) { spec_type::get_encoded_row_length(d); }
   {
-    return dataset_view<vpq_dataset_container,
-                        DataT,
-                        IdxT,
-                        detail::dataset_view_accessor_for_owning<DataT, Accessor>>{this};
+    return spec_type::get_encoded_row_length(data_view_);
+  }
+  [[nodiscard]] auto vq_n_centers() const noexcept
+    requires requires(dictionary_view_type const& d) { d.vq_n_centers(); }
+  {
+    return dictionary_view_.vq_n_centers();
+  }
+  [[nodiscard]] auto pq_n_centers() const noexcept
+    requires requires(dictionary_view_type const& d) { d.pq_n_centers(); }
+  {
+    return dictionary_view_.pq_n_centers();
+  }
+  [[nodiscard]] auto pq_len() const noexcept
+    requires requires(dictionary_view_type const& d) { d.pq_len(); }
+  {
+    return dictionary_view_.pq_len();
+  }
+  [[nodiscard]] auto pq_bits() const noexcept
+    requires requires(dictionary_view_type const& d) { d.pq_bits(); }
+  {
+    return dictionary_view_.pq_bits();
+  }
+  [[nodiscard]] auto pq_dim() const noexcept
+    requires requires(dictionary_view_type const& d) { d.pq_dim(); }
+  {
+    return dictionary_view_.pq_dim();
   }
-};
 
-template <typename DataT, typename IdxT, typename Accessor>
-struct dataset_view<vpq_dataset_container, DataT, IdxT, Accessor>
-  : vpq_dataset_container::template view_storage<DataT, IdxT, Accessor> {
-  using container_type    = vpq_dataset_container;
-  using view_storage_type = typename container_type::template view_storage<DataT, IdxT, Accessor>;
-  using view_storage_type::view_storage_type;
+ private:
+  view_type data_view_{};
+  [[no_unique_address]] dictionary_view_type dictionary_view_{};
 };
 
 /**
@@ -637,136 +709,152 @@ struct dataset_view<vpq_dataset_container, DataT, IdxT, Accessor>
  */
 template <typename IdxT>
 using device_empty_dataset =
-  dataset<empty_dataset_container, void, IdxT, detail::device_owning_accessor<char>>;
+  dataset<void, IdxT, empty_dataset_spec<detail::device_view_accessor<char>>>;
 
 template <typename IdxT>
 using device_empty_dataset_view =
-  dataset_view<empty_dataset_container, void, IdxT, detail::device_view_accessor<char>>;
+  dataset_view<void, IdxT, empty_dataset_spec<detail::device_view_accessor<char>>>;
 
 template <typename IdxT>
 using host_empty_dataset =
-  dataset<empty_dataset_container, void, IdxT, detail::host_owning_accessor<char>>;
+  dataset<void, IdxT, empty_dataset_spec<detail::host_view_accessor<char>>>;
 
 template <typename IdxT>
 using host_empty_dataset_view =
-  dataset_view<empty_dataset_container, void, IdxT, detail::host_view_accessor<char>>;
+  dataset_view<void, IdxT, empty_dataset_spec<detail::host_view_accessor<char>>>;
 
 template <typename DataT, typename IdxT>
 using device_padded_dataset =
-  dataset<padded_dataset_container, DataT, IdxT, detail::device_owning_accessor<DataT>>;
+  dataset<DataT, IdxT, padded_dataset_spec<detail::device_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
 using device_padded_dataset_view =
-  dataset_view<padded_dataset_container, DataT, IdxT, detail::device_view_accessor<DataT>>;
+  dataset_view<DataT, IdxT, padded_dataset_spec<detail::device_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
 using host_padded_dataset =
-  dataset<padded_dataset_container, DataT, IdxT, detail::host_owning_accessor<DataT>>;
+  dataset<DataT, IdxT, padded_dataset_spec<detail::host_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
 using host_padded_dataset_view =
-  dataset_view<padded_dataset_container, DataT, IdxT, detail::host_view_accessor<DataT>>;
+  dataset_view<DataT, IdxT, padded_dataset_spec<detail::host_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
 using device_standard_dataset =
-  dataset<standard_dataset_container, DataT, IdxT, detail::device_owning_accessor<DataT>>;
+  dataset<DataT, IdxT, standard_dataset_spec<detail::device_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
 using device_standard_dataset_view =
-  dataset_view<standard_dataset_container, DataT, IdxT, detail::device_view_accessor<DataT>>;
+  dataset_view<DataT, IdxT, standard_dataset_spec<detail::device_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
 using host_standard_dataset =
-  dataset<standard_dataset_container, DataT, IdxT, detail::host_owning_accessor<DataT>>;
+  dataset<DataT, IdxT, standard_dataset_spec<detail::host_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
 using host_standard_dataset_view =
-  dataset_view<standard_dataset_container, DataT, IdxT, detail::host_view_accessor<DataT>>;
+  dataset_view<DataT, IdxT, standard_dataset_spec<detail::host_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
 using device_vpq_dataset =
-  dataset<vpq_dataset_container, DataT, IdxT, detail::device_owning_accessor<DataT>>;
+  dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::device_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
 using device_vpq_dataset_view =
-  dataset_view<vpq_dataset_container, DataT, IdxT, detail::device_view_accessor<DataT>>;
+  dataset_view<DataT, IdxT, vpq_dataset_spec<DataT, detail::device_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
 using host_vpq_dataset =
-  dataset<vpq_dataset_container, DataT, IdxT, detail::host_owning_accessor<DataT>>;
+  dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::host_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
 using host_vpq_dataset_view =
-  dataset_view<vpq_dataset_container, DataT, IdxT, detail::host_view_accessor<DataT>>;
+  dataset_view<DataT, IdxT, vpq_dataset_spec<DataT, detail::host_owning_accessor<DataT>>>;
 
-// Maps a dataset view type to its owning (allocating) dataset counterpart.
-// Used by serialize/deserialize to type the out_dataset output parameter;
-// adding a new dataset type only requires adding a new specialization here.
+// Maps a dataset view type to its owning (allocating) dataset counterpart. Trivial and total under
+// the Spec design: the owning type for `dataset_view<T,IdxT,SpecT>` is always
+// `dataset<T,IdxT,SpecT>`
+// -- no per-kind specialization table needed (unlike the old Container-tagged design).
 template <typename DatasetViewT>
 struct owning_dataset_for_view;
 
-template <typename DataT, typename IdxT>
-struct owning_dataset_for_view<device_padded_dataset_view<DataT, IdxT>> {
-  using type = device_padded_dataset<DataT, IdxT>;
+template <typename T, typename IdxT, typename SpecT>
+struct owning_dataset_for_view<dataset_view<T, IdxT, SpecT>> {
+  using type = dataset<T, IdxT, SpecT>;
 };
 
-template <typename DataT, typename IdxT>
-struct owning_dataset_for_view<device_standard_dataset_view<DataT, IdxT>> {
-  using type = device_standard_dataset<DataT, IdxT>;
-};
+template <typename DatasetViewT>
+using owning_dataset_for_view_t = typename owning_dataset_for_view<DatasetViewT>::type;
+
+// -----------------------------------------------------------------------------
+// Spec-kind classification (all derived from SpecT; dataset/dataset_view never branch on kind).
+// -----------------------------------------------------------------------------
+
+template <typename SpecT>
+struct is_empty_spec : std::false_type {};
+template <typename Accessor>
+struct is_empty_spec<empty_dataset_spec<Accessor>> : std::true_type {};
+template <typename SpecT>
+inline constexpr bool is_empty_spec_v = is_empty_spec<SpecT>::value;
+
+template <typename SpecT>
+struct is_padded_spec : std::false_type {};
+template <typename ContainerPolicy>
+struct is_padded_spec<padded_dataset_spec<ContainerPolicy>> : std::true_type {};
+template <typename SpecT>
+inline constexpr bool is_padded_spec_v = is_padded_spec<SpecT>::value;
 
-template <typename DataT, typename IdxT>
-struct owning_dataset_for_view<host_padded_dataset_view<DataT, IdxT>> {
-  using type = host_padded_dataset<DataT, IdxT>;
-};
+template <typename SpecT>
+struct is_standard_spec : std::false_type {};
+template <typename ContainerPolicy>
+struct is_standard_spec<standard_dataset_spec<ContainerPolicy>> : std::true_type {};
+template <typename SpecT>
+inline constexpr bool is_standard_spec_v = is_standard_spec<SpecT>::value;
 
-template <typename DataT, typename IdxT>
-struct owning_dataset_for_view<host_standard_dataset_view<DataT, IdxT>> {
-  using type = host_standard_dataset<DataT, IdxT>;
-};
+template <typename SpecT>
+struct is_vpq_spec : std::false_type {};
+template <typename MathT, typename Accessor>
+struct is_vpq_spec<vpq_dataset_spec<MathT, Accessor>> : std::true_type {};
+template <typename SpecT>
+inline constexpr bool is_vpq_spec_v = is_vpq_spec<SpecT>::value;
 
-template <typename DataT, typename IdxT>
-struct owning_dataset_for_view<device_vpq_dataset_view<DataT, IdxT>> {
-  using type = device_vpq_dataset<DataT, IdxT>;
+template <typename SpecT>
+struct vpq_spec_math_type {};
+template <typename MathT, typename Accessor>
+struct vpq_spec_math_type<vpq_dataset_spec<MathT, Accessor>> {
+  using type = MathT;
 };
+template <typename SpecT>
+using vpq_spec_math_type_t = typename vpq_spec_math_type<SpecT>::type;
 
-template <typename DatasetViewT>
-using owning_dataset_for_view_t = typename owning_dataset_for_view<DatasetViewT>::type;
-
+/** Owning-side kind traits (mirror today's `is_padded_dataset_v`/`is_standard_dataset_v`/
+ * `is_vpq_dataset_v`, used for SFINAE overload selection in factory.cuh/compute_distance_vpq.hpp).
+ */
 template <typename DatasetT>
 struct is_padded_dataset : std::false_type {};
-
-template <typename DataT, typename IdxT, typename Accessor>
-struct is_padded_dataset<dataset<padded_dataset_container, DataT, IdxT, Accessor>>
-  : std::true_type {};
-
-template <typename DataT, typename IdxT, typename Accessor>
-struct is_padded_dataset<dataset_view<padded_dataset_container, DataT, IdxT, Accessor>>
-  : std::true_type {};
-
+template <typename T, typename IdxT, typename SpecT>
+struct is_padded_dataset<dataset<T, IdxT, SpecT>> : std::bool_constant<is_padded_spec_v<SpecT>> {};
+template <typename T, typename IdxT, typename SpecT>
+struct is_padded_dataset<dataset_view<T, IdxT, SpecT>>
+  : std::bool_constant<is_padded_spec_v<SpecT>> {};
 template <typename DatasetT>
 inline constexpr bool is_padded_dataset_v = is_padded_dataset<DatasetT>::value;
 
 template <typename DatasetT>
 struct is_standard_dataset : std::false_type {};
-
-template <typename DataT, typename IdxT, typename Accessor>
-struct is_standard_dataset<dataset<standard_dataset_container, DataT, IdxT, Accessor>>
-  : std::true_type {};
-
-template <typename DataT, typename IdxT, typename Accessor>
-struct is_standard_dataset<dataset_view<standard_dataset_container, DataT, IdxT, Accessor>>
-  : std::true_type {};
-
+template <typename T, typename IdxT, typename SpecT>
+struct is_standard_dataset<dataset<T, IdxT, SpecT>>
+  : std::bool_constant<is_standard_spec_v<SpecT>> {};
+template <typename T, typename IdxT, typename SpecT>
+struct is_standard_dataset<dataset_view<T, IdxT, SpecT>>
+  : std::bool_constant<is_standard_spec_v<SpecT>> {};
 template <typename DatasetT>
 inline constexpr bool is_standard_dataset_v = is_standard_dataset<DatasetT>::value;
 
 template <typename DatasetT>
 struct is_vpq_dataset : std::false_type {};
-
-template <typename DataT, typename IdxT, typename Accessor>
-struct is_vpq_dataset<dataset<vpq_dataset_container, DataT, IdxT, Accessor>> : std::true_type {};
-
+template <typename T, typename IdxT, typename SpecT>
+struct is_vpq_dataset<dataset<T, IdxT, SpecT>> : std::bool_constant<is_vpq_spec_v<SpecT>> {};
 template <typename DatasetT>
 inline constexpr bool is_vpq_dataset_v = is_vpq_dataset<DatasetT>::value;
 
@@ -794,6 +882,9 @@ enum class dataset_view_kind {
   vpq_f32,
 };
 
+template <typename V>
+using dataset_view_type_t = std::remove_cvref_t<V>;
+
 /** Primary template returns `unknown` so traits safely return `false` for non-dataset-view types.
  */
 template <typename V>
@@ -801,39 +892,34 @@ struct dataset_view_kind_of {
   static constexpr dataset_view_kind value = dataset_view_kind::unknown;
 };
 
-template <typename IdxT, typename Accessor>
-struct dataset_view_kind_of<dataset_view<empty_dataset_container, void, IdxT, Accessor>> {
-  static constexpr dataset_view_kind value = dataset_view_kind::empty;
-};
-
-template <typename DataT, typename IdxT, typename Accessor>
-struct dataset_view_kind_of<dataset_view<padded_dataset_container, DataT, IdxT, Accessor>> {
-  static constexpr dataset_view_kind value = dataset_view_kind::padded;
-};
-
-template <typename DataT, typename IdxT, typename Accessor>
-struct dataset_view_kind_of<dataset_view<standard_dataset_container, DataT, IdxT, Accessor>> {
-  static constexpr dataset_view_kind value = dataset_view_kind::standard;
-};
-
-template <typename MathT, typename IdxT, typename Accessor>
-struct dataset_view_kind_of<dataset_view<vpq_dataset_container, MathT, IdxT, Accessor>> {
-  static_assert(std::is_same_v<MathT, half> || std::is_same_v<MathT, float>,
-                "VPQ dataset_view_kind_of expects MathT to be half or float");
-  static constexpr dataset_view_kind value =
-    std::is_same_v<MathT, half> ? dataset_view_kind::vpq_f16 : dataset_view_kind::vpq_f32;
+template <typename T, typename IdxT, typename SpecT>
+struct dataset_view_kind_of<dataset_view<T, IdxT, SpecT>> {
+  static constexpr dataset_view_kind value = []() constexpr {
+    if constexpr (is_empty_spec_v<SpecT>) {
+      return dataset_view_kind::empty;
+    } else if constexpr (is_padded_spec_v<SpecT>) {
+      return dataset_view_kind::padded;
+    } else if constexpr (is_standard_spec_v<SpecT>) {
+      return dataset_view_kind::standard;
+    } else if constexpr (is_vpq_spec_v<SpecT>) {
+      static_assert(std::is_same_v<vpq_spec_math_type_t<SpecT>, half> ||
+                      std::is_same_v<vpq_spec_math_type_t<SpecT>, float>,
+                    "VPQ dataset_view_kind_of expects MathT to be half or float");
+      return std::is_same_v<vpq_spec_math_type_t<SpecT>, half> ? dataset_view_kind::vpq_f16
+                                                               : dataset_view_kind::vpq_f32;
+    } else {
+      return dataset_view_kind::unknown;
+    }
+  }();
 };
 
-template <typename V>
-using dataset_view_type_t = std::remove_cvref_t<V>;
-
 /** True when the dataset view accessor is device-accessible. */
 template <typename V>
 struct dataset_view_is_device_accessible : std::false_type {};
 
-template <typename ContainerType, typename DataT, typename IdxT, typename Accessor>
-struct dataset_view_is_device_accessible<dataset_view<ContainerType, DataT, IdxT, Accessor>>
-  : std::bool_constant<Accessor::is_device_accessible> {};
+template <typename T, typename IdxT, typename SpecT>
+struct dataset_view_is_device_accessible<dataset_view<T, IdxT, SpecT>>
+  : std::bool_constant<SpecT::accessor_type::is_device_accessible> {};
 
 template <typename V>
 inline constexpr bool dataset_view_is_device_accessible_v =
@@ -939,28 +1025,51 @@ inline constexpr bool compatible_host_device_dataset_views_v =
 
 /**
  * Generic accessor retargeting while preserving the dataset tag/layout and value/index types:
- * `dataset<Tag, DataT, IdxT, OldAccessor>      -> dataset<Tag, DataT, IdxT, NewAccessor>`
- * `dataset_view<Tag, DataT, IdxT, OldAccessor> -> dataset_view<Tag, DataT, IdxT, NewAccessor>`
+ * `dataset<T, IdxT, SpecT<..., OldAccessor>>      -> dataset<T, IdxT, SpecT<..., NewAccessor>>`
+ * `dataset_view<T, IdxT, SpecT<..., OldAccessor>> -> dataset_view<T, IdxT, SpecT<...,
+ * NewAccessor>>`
  */
 template <typename DatasetLikeT, typename NewAccessor>
 struct with_accessor;
 
-template <typename ContainerType,
-          typename DataT,
-          typename IdxT,
-          typename OldAccessor,
-          typename NewAccessor>
-struct with_accessor<dataset<ContainerType, DataT, IdxT, OldAccessor>, NewAccessor> {
-  using type = dataset<ContainerType, DataT, IdxT, NewAccessor>;
+template <typename T, typename IdxT, typename NewAccessor>
+struct with_accessor<dataset<T, IdxT, empty_dataset_spec<NewAccessor>>, NewAccessor> {
+  using type = dataset<T, IdxT, empty_dataset_spec<NewAccessor>>;
+};
+
+template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset<T, IdxT, padded_dataset_spec<OldAccessor>>, NewAccessor> {
+  using type = dataset<T, IdxT, padded_dataset_spec<NewAccessor>>;
+};
+
+template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset<T, IdxT, standard_dataset_spec<OldAccessor>>, NewAccessor> {
+  using type = dataset<T, IdxT, standard_dataset_spec<NewAccessor>>;
+};
+
+template <typename T, typename IdxT, typename MathT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset<T, IdxT, vpq_dataset_spec<MathT, OldAccessor>>, NewAccessor> {
+  using type = dataset<T, IdxT, vpq_dataset_spec<MathT, NewAccessor>>;
+};
+
+template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset_view<T, IdxT, empty_dataset_spec<OldAccessor>>, NewAccessor> {
+  using type = dataset_view<T, IdxT, empty_dataset_spec<NewAccessor>>;
+};
+
+template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset_view<T, IdxT, padded_dataset_spec<OldAccessor>>, NewAccessor> {
+  using type = dataset_view<T, IdxT, padded_dataset_spec<NewAccessor>>;
+};
+
+template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset_view<T, IdxT, standard_dataset_spec<OldAccessor>>, NewAccessor> {
+  using type = dataset_view<T, IdxT, standard_dataset_spec<NewAccessor>>;
 };
 
-template <typename ContainerType,
-          typename DataT,
-          typename IdxT,
-          typename OldAccessor,
-          typename NewAccessor>
-struct with_accessor<dataset_view<ContainerType, DataT, IdxT, OldAccessor>, NewAccessor> {
-  using type = dataset_view<ContainerType, DataT, IdxT, NewAccessor>;
+template <typename T, typename IdxT, typename MathT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset_view<T, IdxT, vpq_dataset_spec<MathT, OldAccessor>>, NewAccessor> {
+  using type = dataset_view<T, IdxT, vpq_dataset_spec<MathT, NewAccessor>>;
 };
 
 template <typename DatasetLikeT, typename NewAccessor>
@@ -990,10 +1099,10 @@ using to_device_accessor_t = typename to_device_accessor<Accessor>::type;
 template <typename HostViewT>
 struct device_counterpart;
 
-template <typename ContainerType, typename DataT, typename IdxT, typename Accessor>
-struct device_counterpart<dataset_view<ContainerType, DataT, IdxT, Accessor>> {
-  using type = with_accessor_t<dataset_view<ContainerType, DataT, IdxT, Accessor>,
-                               to_device_accessor_t<Accessor>>;
+template <typename T, typename IdxT, typename SpecT>
+struct device_counterpart<dataset_view<T, IdxT, SpecT>> {
+  using type = with_accessor_t<dataset_view<T, IdxT, SpecT>,
+                               to_device_accessor_t<typename SpecT::accessor_type>>;
 };
 
 template <typename HostViewT>
@@ -1009,37 +1118,11 @@ template <typename V>
 inline constexpr bool is_dense_row_major_dataset_view_v =
   is_padded_dataset_view_v<V> || is_standard_dataset_view_v<V>;
 
-/** Element type `T` for `cagra::build(res, params, dataset_view)` (deduced, not a template arg). */
-template <typename V, typename = void>
-struct cagra_view_element_type;
-
-template <typename DataT, typename IdxT>
-struct cagra_view_element_type<device_padded_dataset_view<DataT, IdxT>> {
-  using type = DataT;
-};
-
-template <typename DataT, typename IdxT>
-struct cagra_view_element_type<host_padded_dataset_view<DataT, IdxT>> {
-  using type = DataT;
-};
-
-template <typename DataT, typename IdxT>
-struct cagra_view_element_type<device_standard_dataset_view<DataT, IdxT>> {
-  using type = DataT;
-};
-
-template <typename DataT, typename IdxT>
-struct cagra_view_element_type<host_standard_dataset_view<DataT, IdxT>> {
-  using type = DataT;
-};
-
-template <typename MathT, typename IdxT>
-struct cagra_view_element_type<device_vpq_dataset_view<MathT, IdxT>> {
-  using type = MathT;
-};
-
+/** Element type `T` for `cagra::build(res, params, dataset_view)` (deduced, not a template arg).
+ * Trivial under the Spec design: every `dataset_view<T,IdxT,SpecT>` already carries `T` directly.
+ */
 template <typename V>
-using cagra_view_element_type_t = typename cagra_view_element_type<dataset_view_type_t<V>>::type;
+using cagra_view_element_type_t = typename dataset_view_type_t<V>::value_type;
 
 // -----------------------------------------------------------------------------
 // CAGRA row width in elements (same for make_device_padded_dataset* and index layout checks).
@@ -1322,11 +1405,6 @@ auto make_device_standard_dataset_view(SrcT const& src)
  * wire-format `(logical_dim, stride)` because the deserialized host buffer is tight `[n_rows x
  * dim]` while the on-disk stride may be larger. Do not call from user code; prefer
  * `make_device_standard_dataset_view()` when wrapping existing correctly-strided storage.
- *
- * Potential future call sites if an owning copy with explicit stride is needed:
- * - C API dataset upload (mirroring `make_device_padded_dataset` in `c/src/neighbors/cagra.cpp`)
- * - `tiered_index` / composite index paths that materialize standard-layout device storage
- * - Multigpu (MG) index build or merge when rehydrating a strided dataset from host fragments
  */
 template <typename SrcT>
 auto make_device_standard_dataset(const raft::resources& res,
@@ -1355,242 +1433,6 @@ auto make_host_standard_dataset_view(SrcT const& src)
     host_standard_dataset_view<value_type, index_type>>(src, static_cast<uint32_t>(src.extent(1)));
 }
 
-// =====================================================================================
-// Experimental: Spec-based dataset/dataset_view prototype (#2395 follow-up).
-//
-// Not wired up to any public alias, trait, or downstream call site yet -- exists to validate the
-// design in isolation. `dataset<T,IdxT,SpecT>` and `dataset_view<T,IdxT,SpecT>` are single generic
-// templates with zero per-kind dispatch inside them: every member is a one-line forward to
-// `spec_type::get_*(...)`, and all kind-specific logic lives in the per-kind Spec structs below
-// (`empty_spec`, `mdarray_spec`, `vpq_spec`), which dataset/dataset_view never name or branch on.
-// `dataset` and `dataset_view` are deliberately two independent, non-inheriting types (no
-// shared_ptr, no "sometimes owning" object): `dataset` holds owning storage (mdarray-shaped),
-// `dataset_view` holds the corresponding view storage (mdspan-shaped); the same
-// `get_n_rows`/`get_dim` spec functions serve both, since `raft::mdarray`/`raft::mdspan` both
-// expose `.extent(r)`.
-// =====================================================================================
-namespace experimental {
-
-/**
- * A spec defines a dictionary iff it needs a second storage slot to interpret the data (e.g. PQ
- * codebooks). Non-compressed specs declare `dictionary_type = std::monostate` -- the same
- * vocabulary type for "no dictionary," not just an omitted member -- so `dataset`/`dataset_view`
- * never need to branch on whether the slot exists; they just always have one, sometimes empty.
- */
-template <typename SpecT>
-concept compressed_dataset_spec = requires {
-  typename SpecT::dictionary_type;
-  typename SpecT::dictionary_view_type;
-} && !std::is_same_v<typename SpecT::dictionary_type, std::monostate>;
-
-// -----------------------------------------------------------------------------
-// empty
-// -----------------------------------------------------------------------------
-
-struct empty_spec {
-  struct rep {
-    uint32_t dim;
-  };
-
-  template <typename T, typename IdxT>
-  struct apply {
-    using value_type           = std::remove_cv_t<T>;
-    using index_type           = std::remove_cv_t<IdxT>;
-    using data_type            = rep;
-    using view_type            = rep;
-    using dictionary_type      = std::monostate;
-    using dictionary_view_type = std::monostate;
-
-    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
-    {
-      return data;
-    }
-    [[nodiscard]] static auto get_n_rows(rep const&) noexcept -> index_type { return 0; }
-    [[nodiscard]] static auto get_dim(rep const& data, dictionary_type const&) noexcept -> uint32_t
-    {
-      return data.dim;
-    }
-    [[nodiscard]] static auto get_dictionary_view(dictionary_type const&) noexcept
-      -> dictionary_view_type
-    {
-      return {};
-    }
-  };
-};
-
-// -----------------------------------------------------------------------------
-// dense (plain or padded), implemented via raft::mdarray
-// -----------------------------------------------------------------------------
-
-template <typename LayoutPolicy, typename ContainerPolicy>
-struct mdarray_spec {
-  template <typename T, typename IdxT>
-  struct apply {
-    using value_type = std::remove_cv_t<T>;
-    using index_type = std::remove_cv_t<IdxT>;
-    using data_type = raft::mdarray<T, raft::matrix_extent<int64_t>, LayoutPolicy, ContainerPolicy>;
-    // `get_data_view` takes `data_type const&`, so `.view()` resolves to the const overload,
-    // returning `const_view_type` (const element type) -- match that here, not the mutable
-    // `view_type`.
-    using view_type            = typename data_type::const_view_type;
-    using dictionary_type      = std::monostate;
-    using dictionary_view_type = std::monostate;
-
-    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
-    {
-      return data.view();
-    }
-    template <typename AnyExtentShaped>
-    [[nodiscard]] static auto get_n_rows(AnyExtentShaped const& data) noexcept -> index_type
-    {
-      return static_cast<index_type>(data.extent(0));
-    }
-    template <typename AnyExtentShaped>
-    [[nodiscard]] static auto get_dim(AnyExtentShaped const& data, dictionary_type const&) noexcept
-      -> uint32_t
-    {
-      return static_cast<uint32_t>(data.extent(1));
-    }
-    [[nodiscard]] static auto get_dictionary_view(dictionary_type const&) noexcept
-      -> dictionary_view_type
-    {
-      return {};
-    }
-  };
-};
-
-// -----------------------------------------------------------------------------
-// VPQ compressed: data = encoded rows (uint8_t codes); dictionary = {vq_code_book, pq_code_book}
-// -----------------------------------------------------------------------------
-
-template <typename MathT, typename BookPolicy, typename CodePolicy>
-struct vpq_spec {
-  template <typename IdxT>
-  using storage_spec =
-    typename mdarray_spec<raft::row_major, CodePolicy>::template apply<uint8_t, IdxT>;
-
-  template <typename T, typename IdxT>
-  struct apply : storage_spec<IdxT> {
-    using value_type = std::remove_cv_t<T>;
-    /* Members of a dependent base aren't visible to unqualified lookup, so pull these in. */
-    using typename storage_spec<IdxT>::data_type;
-    using typename storage_spec<IdxT>::view_type;
-    using math_type = MathT;
-
-    using vq_book_type =
-      raft::mdarray<math_type, raft::matrix_extent<int64_t>, raft::row_major, BookPolicy>;
-    using pq_book_type =
-      raft::mdarray<math_type, raft::matrix_extent<int64_t>, raft::row_major, BookPolicy>;
-
-    struct dictionary_type {
-      vq_book_type vq_code_book;
-      pq_book_type pq_code_book;
-    };
-    struct dictionary_view_type {
-      typename vq_book_type::const_view_type vq_code_book;
-      typename pq_book_type::const_view_type pq_code_book;
-    };
-
-    /* get_data_view/get_n_rows are inherited from storage_spec unchanged; only get_dim and
-    get_dictionary_view differ from a plain dense dataset, since the dimension comes from the VQ
-    codebook, not the encoded rows. */
-    template <typename AnyData, typename AnyDict>
-    [[nodiscard]] static auto get_dim(AnyData const&, AnyDict const& dict) noexcept -> uint32_t
-    {
-      return static_cast<uint32_t>(dict.vq_code_book.extent(1));
-    }
-    [[nodiscard]] static auto get_dictionary_view(dictionary_type const& dict) noexcept
-      -> dictionary_view_type
-    {
-      return {dict.vq_code_book.view(), dict.pq_code_book.view()};
-    }
-  };
-};
-
-// -----------------------------------------------------------------------------
-// dataset / dataset_view
-// -----------------------------------------------------------------------------
-
-template <typename T, typename IdxT, typename SpecT>
-struct dataset_view;
-
-/** Owning dataset: value-held storage (no shared_ptr -- exclusive ownership, like today's
- * `dataset<Container,...>`). Every member is a one-line forward to `spec_type::get_*`; all
- * per-kind logic lives in `SpecT`, never inside this struct. */
-template <typename T, typename IdxT, typename SpecT>
-struct dataset {
-  using spec_type       = typename SpecT::template apply<T, IdxT>;
-  using value_type      = typename spec_type::value_type;
-  using index_type      = typename spec_type::index_type;
-  using data_type       = typename spec_type::data_type;
-  using dictionary_type = typename spec_type::dictionary_type;
-
-  explicit dataset(data_type&& data, dictionary_type&& dictionary = dictionary_type{})
-    : data_{std::move(data)}, dictionary_{std::move(dictionary)}
-  {
-  }
-
-  [[nodiscard]] auto n_rows() const noexcept -> index_type { return spec_type::get_n_rows(data_); }
-  [[nodiscard]] auto dim() const noexcept -> uint32_t
-  {
-    return spec_type::get_dim(data_, dictionary_);
-  }
-  [[nodiscard]] auto data_view() const noexcept { return spec_type::get_data_view(data_); }
-  [[nodiscard]] auto dictionary_view() const noexcept
-  {
-    return spec_type::get_dictionary_view(dictionary_);
-  }
-
-  [[nodiscard]] auto as_dataset_view() const noexcept -> dataset_view<T, IdxT, SpecT>
-  {
-    return dataset_view<T, IdxT, SpecT>(data_view(), dictionary_view());
-  }
-
- private:
-  data_type data_;
-  [[no_unique_address]] dictionary_type dictionary_;
-};
-
-/** Non-owning dataset view: holds only view-shaped storage (mdspan, not mdarray). Deliberately not
- * derived from `dataset` -- a view type should hold "all view state" with no inheritance and no
- * shared ownership tying it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec
- * functions as `dataset`, fed view-shaped arguments instead of owning ones, since `raft::mdspan`
- * exposes the same `.extent(r)` shape as `raft::mdarray`. */
-template <typename T, typename IdxT, typename SpecT>
-struct dataset_view {
-  using spec_type            = typename SpecT::template apply<T, IdxT>;
-  using value_type           = typename spec_type::value_type;
-  using index_type           = typename spec_type::index_type;
-  using view_type            = typename spec_type::view_type;
-  using dictionary_view_type = typename spec_type::dictionary_view_type;
-
-  explicit dataset_view(view_type data_view,
-                        dictionary_view_type dictionary_view = dictionary_view_type{}) noexcept
-    : data_view_{data_view}, dictionary_view_{dictionary_view}
-  {
-  }
-
-  [[nodiscard]] auto n_rows() const noexcept -> index_type
-  {
-    return spec_type::get_n_rows(data_view_);
-  }
-  [[nodiscard]] auto dim() const noexcept -> uint32_t
-  {
-    return spec_type::get_dim(data_view_, dictionary_view_);
-  }
-  [[nodiscard]] auto data_view() const noexcept -> view_type { return data_view_; }
-  [[nodiscard]] auto dictionary_view() const noexcept -> dictionary_view_type
-  {
-    return dictionary_view_;
-  }
-
- private:
-  view_type data_view_;
-  [[no_unique_address]] dictionary_view_type dictionary_view_;
-};
-
-}  // namespace experimental
-
 namespace filtering {
 
 /**
diff --git a/cpp/include/cuvs/preprocessing/quantize/pq.hpp b/cpp/include/cuvs/preprocessing/quantize/pq.hpp
index a633ac6672..b5617767a9 100644
--- a/cpp/include/cuvs/preprocessing/quantize/pq.hpp
+++ b/cpp/include/cuvs/preprocessing/quantize/pq.hpp
@@ -302,13 +302,13 @@ template <typename SrcT>
                                     SrcT const& src)
   -> cuvs::neighbors::device_vpq_dataset<half, int64_t>
 {
-  // A cuVS dataset keeps its logical width in `dim()` while `view()` spans the full row pitch.
+  // A cuVS dataset keeps its logical width in `dim()` while `data_view()` spans the full row
+  // pitch.
   if constexpr (requires {
-                  src.view();
+                  src.data_view();
                   src.dim();
-                  src.stride();
                 }) {
-    auto const rows    = src.view();
+    auto const rows    = src.data_view();
     using value_type   = typename decltype(rows)::value_type;
     using extents_type = raft::matrix_extent<int64_t>;
     return make_vpq_dataset(
@@ -317,7 +317,7 @@ template <typename SrcT>
       raft::mdspan<const value_type, extents_type, raft::layout_stride>{
         rows.data_handle(),
         raft::make_strided_layout(extents_type{rows.extent(0), int64_t{src.dim()}},
-                                  cuda::std::array<int64_t, 2>{int64_t{src.stride()}, 1})});
+                                  cuda::std::array<int64_t, 2>{int64_t{rows.stride()}, 1})});
   } else {
     using value_type = typename SrcT::value_type;
     static_assert(std::is_same_v<value_type, float> || std::is_same_v<value_type, half> ||
diff --git a/cpp/src/neighbors/cagra.cuh b/cpp/src/neighbors/cagra.cuh
index 7af1251ba0..f0dfe13bec 100644
--- a/cpp/src/neighbors/cagra.cuh
+++ b/cpp/src/neighbors/cagra.cuh
@@ -45,7 +45,7 @@ CUVS_EXPORT void index<T, IdxT, DatasetViewT>::compute_dataset_norms_(raft::reso
 
   if constexpr (nb::is_padded_dataset_view_v<DatasetViewT> ||
                 nb::is_standard_dataset_view_v<DatasetViewT>) {
-    rm_dataset = dataset_.view();
+    rm_dataset = dataset_.data_view().view();
   } else if constexpr (nb::is_vpq_dataset_view_v<DatasetViewT>) {
     skip_norms = true;
   }
diff --git a/cpp/src/neighbors/detail/cagra/add_nodes.cuh b/cpp/src/neighbors/detail/cagra/add_nodes.cuh
index c19314a835..e5030ede5b 100644
--- a/cpp/src/neighbors/detail/cagra/add_nodes.cuh
+++ b/cpp/src/neighbors/detail/cagra/add_nodes.cuh
@@ -363,7 +363,7 @@ void extend_core(raft::resources const& handle,
                "cuvs::neighbors::hnsw::deserialize() before calling extend().");
 
   const std::size_t initial_dataset_size = index.size();
-  const auto extended_view               = extended_dataset.view();
+  const auto extended_view               = extended_dataset.data_view();
   const std::size_t new_dataset_size     = static_cast<std::size_t>(extended_view.extent(0));
   const std::size_t degree               = index.graph_degree();
   const std::size_t dim                  = index.dim();
diff --git a/cpp/src/neighbors/detail/cagra/cagra_build.cuh b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
index 44770fda8f..900f62154f 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_build.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
@@ -1341,7 +1341,7 @@ auto build_ace(raft::resources const& res, const index_params& params, DatasetVi
     params.graph_degree,
     npartitions);
 
-  auto dataset_view   = dataset.view();
+  auto dataset_view   = dataset.data_view();
   size_t dataset_size = dataset.n_rows();
   size_t dataset_dim  = dataset.dim();
 
@@ -2290,7 +2290,7 @@ auto ensure_device_padded_for_iterative_search(
   if constexpr (cuvs::neighbors::is_device_padded_dataset_view_v<DatasetViewT>) {
     return dataset;
   } else {
-    padded_own = cuvs::neighbors::make_device_padded_dataset(res, dataset.view());
+    padded_own = cuvs::neighbors::make_device_padded_dataset(res, dataset.data_view());
     return padded_own->as_dataset_view();
   }
 }
@@ -2315,7 +2315,7 @@ auto iterative_build_graph(raft::resources const& res,
   std::unique_ptr<cuvs::neighbors::device_padded_dataset<T, int64_t>> padded_own;
   auto search_dataset = ensure_device_padded_for_iterative_search<T>(res, dataset, padded_own);
 
-  auto dev_dataset     = search_dataset.view();
+  auto dev_dataset     = search_dataset.data_view();
   uint32_t logical_dim = search_dataset.dim();
 
   // Determine initial graph size.
@@ -2636,7 +2636,7 @@ auto build_from_host_matrix(raft::resources const& res,
                                                            static_cast<int64_t>(n_rows),
                                                            intermediate_degree,
                                                            graph_degree,
-                                                           dataset.view());
+                                                           dataset.data_view());
   }();
 
   RAFT_LOG_TRACE("Graph optimized, creating index");
@@ -2688,7 +2688,7 @@ auto build_from_device_matrix(raft::resources const& res,
                                                            device_dataset.n_rows(),
                                                            intermediate_degree,
                                                            graph_degree,
-                                                           device_dataset.view());
+                                                           device_dataset.data_view());
   }();
 
   RAFT_LOG_TRACE("Graph optimized, creating index");
diff --git a/cpp/src/neighbors/detail/cagra/cagra_merge.cuh b/cpp/src/neighbors/detail/cagra/cagra_merge.cuh
index aa00f73cfe..4eb65fb391 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_merge.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_merge.cuh
@@ -91,10 +91,10 @@ cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge_rebuild(
         "before merge.");
       if (dim == 0) {
         dim    = index->dim();
-        stride = static_cast<int64_t>(dataset.stride());
+        stride = static_cast<int64_t>(dataset.data_view().stride());
       } else {
         RAFT_EXPECTS(dim == index->dim(), "Dimension of datasets in indices must be equal.");
-        RAFT_EXPECTS(stride == static_cast<int64_t>(dataset.stride()),
+        RAFT_EXPECTS(stride == static_cast<int64_t>(dataset.data_view().stride()),
                      "Row stride of datasets in indices must be equal.");
       }
       merged_rows += static_cast<int64_t>(index->size());
@@ -116,12 +116,12 @@ cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge_rebuild(
                "merged_dataset dimension (%u) must equal the input dimension (%u)",
                unsigned(merged_dataset.dim()),
                unsigned(dim));
-  RAFT_EXPECTS(merged_dataset.stride() == stride,
+  RAFT_EXPECTS(merged_dataset.data_view().stride() == stride,
                "merged_dataset stride (%u) must equal the input stride (%ld)",
-               unsigned(merged_dataset.stride()),
+               unsigned(merged_dataset.data_view().stride()),
                long(stride));
 
-  auto output_const_view = merged_dataset.view();
+  auto output_const_view = merged_dataset.data_view();
   auto output_view       = raft::make_device_matrix_view<T, int64_t>(
     const_cast<T*>(output_const_view.data_handle()), final_rows, stride);
 
@@ -132,7 +132,7 @@ cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge_rebuild(
       std::size_t n_rows = 0;
       auto const& v      = index->dataset();
       if constexpr (cuvs::neighbors::is_dense_row_major_dataset_view_v<std::decay_t<decltype(v)>>) {
-        src_ptr = v.view().data_handle();
+        src_ptr = v.data_view().data_handle();
         n_rows  = static_cast<std::size_t>(v.n_rows());
       } else {
         RAFT_FAIL("cagra::merge: unexpected dataset type while copying rows");
@@ -300,14 +300,14 @@ auto preflight_fastener(
     }
     if (result.offsets.size() == 1) {
       result.dim    = static_cast<int64_t>(index->dim());
-      result.stride = static_cast<int64_t>(dataset.stride());
+      result.stride = static_cast<int64_t>(dataset.data_view().stride());
     } else {
       if (result.dim != static_cast<int64_t>(index->dim())) {
         return reject("all input dimensions must match");
       }
       // The merged dataset has a single row pitch, so mixed input strides cannot be consolidated
       // without re-padding each input separately.
-      if (result.stride != static_cast<int64_t>(dataset.stride())) {
+      if (result.stride != static_cast<int64_t>(dataset.data_view().stride())) {
         return reject("all input row strides must match");
       }
     }
@@ -382,8 +382,8 @@ void copy_input_datasets(
     auto const& source = indices[i]->dataset();
     raft::copy_matrix(destination + offsets[i] * destination_stride,
                       static_cast<std::size_t>(destination_stride),
-                      source.view().data_handle(),
-                      static_cast<std::size_t>(source.stride()),
+                      source.data_view().data_handle(),
+                      static_cast<std::size_t>(source.data_view().stride()),
                       static_cast<std::size_t>(dim),
                       static_cast<std::size_t>(source.n_rows()),
                       raft::resource::get_cuda_stream(handle));
@@ -399,7 +399,7 @@ auto merge_fastener(raft::resources const& handle,
                     fastener_preflight_result const& preflight)
   -> cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>
 {
-  auto const stride = static_cast<int64_t>(merged_dataset.stride());
+  auto const stride = static_cast<int64_t>(merged_dataset.data_view().stride());
   RAFT_EXPECTS(merged_dataset.n_rows() == preflight.rows,
                "merged_dataset rows (%ld) must equal the merged row count (%ld)",
                long(merged_dataset.n_rows()),
@@ -409,7 +409,7 @@ auto merge_fastener(raft::resources const& handle,
                unsigned(merged_dataset.dim()),
                long(preflight.dim));
 
-  auto const output_const_view = merged_dataset.view();
+  auto const output_const_view = merged_dataset.data_view();
   auto* destination            = const_cast<T*>(output_const_view.data_handle());
   {
     raft::common::nvtx::range<cuvs::common::nvtx::domain::cuvs> scope("cagra::merge/consolidate");
diff --git a/cpp/src/neighbors/detail/cagra/cagra_search.cuh b/cpp/src/neighbors/detail/cagra/cagra_search.cuh
index 2d7683816c..81cf407909 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_search.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_search.cuh
@@ -101,13 +101,13 @@ void search_main_core(
   std::unique_ptr<cuvs::neighbors::device_padded_dataset<DataT, int64_t>> queries_padded_own;
   if (cuvs::neighbors::matrix_row_width_matches_cagra_required(queries)) {
     auto v           = cuvs::neighbors::make_device_padded_dataset_view(res, queries);
-    queries_buf      = v.view().data_handle();
-    query_row_stride = v.stride();
+    queries_buf      = v.data_view().data_handle();
+    query_row_stride = v.data_view().stride();
   } else {
     queries_padded_own = cuvs::neighbors::make_device_padded_dataset(res, queries);
     auto v             = queries_padded_own->as_dataset_view();
-    queries_buf        = v.view().data_handle();
-    query_row_stride   = v.stride();
+    queries_buf        = v.data_view().data_handle();
+    query_row_stride   = v.data_view().stride();
   }
   const bool can_batch_n_queries = (query_row_stride == query_dim);
 
@@ -245,7 +245,7 @@ void search_main(raft::resources const& res,
       params.smem_dtype = cuvs::neighbors::cagra::internal_dtype::F16;
     }
     auto desc = dataset_descriptor_init_with_cache<T, graph_idx_type, DistanceT>(
-      res, params, vv.dset(), index.metric(), nullptr);
+      res, params, vv, index.metric(), nullptr);
     search_main_core<T, graph_idx_type, DistanceT, CagraSampleFilterT, IdxT, OutputIdxT>(
       res,
       params,
diff --git a/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh b/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
index 461928d4ab..844a20574b 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
@@ -293,8 +293,8 @@ void write_hnswlib_rows_host(
                  "CAGRA dataset rows (%zu) do not match index size (%zu)",
                  static_cast<size_t>(dataset_view.n_rows()),
                  n_rows);
-    dataset_data      = dataset_view.view().data_handle();
-    dataset_stride    = dataset_view.stride();
+    dataset_data      = dataset_view.data_view().data_handle();
+    dataset_stride    = dataset_view.data_view().stride();
     dataset_is_device = is_device_cagra_hnsw_serialize_index_v<T, IdxT, CagraIndexT>;
   }
 
@@ -427,16 +427,16 @@ void write_hnswlib_rows_device(raft::resources const& res,
   for (size_t first_row = 0; first_row < n_rows; first_row += batch_rows) {
     auto const rows   = std::min(batch_rows, n_rows - first_row);
     auto const blocks = (rows + warps_per_block - 1) / warps_per_block;
-    pack_hnswlib_rows<T, IdxT>
-      <<<static_cast<unsigned int>(blocks), block_size, 0, stream>>>(output.data_handle(),
-                                                                     row_size,
-                                                                     graph.data_handle(),
-                                                                     dataset.view().data_handle(),
-                                                                     first_row,
-                                                                     rows,
-                                                                     graph_degree,
-                                                                     dim,
-                                                                     dataset.stride());
+    pack_hnswlib_rows<T, IdxT><<<static_cast<unsigned int>(blocks), block_size, 0, stream>>>(
+      output.data_handle(),
+      row_size,
+      graph.data_handle(),
+      dataset.data_view().data_handle(),
+      first_row,
+      rows,
+      graph_degree,
+      dim,
+      dataset.data_view().stride());
     RAFT_CUDA_TRY(cudaPeekAtLastError());
     raft::resource::sync_stream(res);
 
diff --git a/cpp/src/neighbors/detail/cagra/compute_distance_standard.hpp b/cpp/src/neighbors/detail/cagra/compute_distance_standard.hpp
index 5f7c8efb10..8014d3a070 100644
--- a/cpp/src/neighbors/detail/cagra/compute_distance_standard.hpp
+++ b/cpp/src/neighbors/detail/cagra/compute_distance_standard.hpp
@@ -28,7 +28,7 @@ struct standard_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT>
   template <typename DatasetT>
   constexpr static inline bool accepts_dataset()
   {
-    return is_padded_dataset_v<DatasetT>;
+    return cuvs::neighbors::is_padded_dataset_view_v<DatasetT>;
   }
 
   template <typename DatasetT>
@@ -37,11 +37,12 @@ struct standard_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT>
                    cuvs::distance::DistanceType metric,
                    const DistanceT* dataset_norms = nullptr) -> host_type
   {
+    auto const data_view = dataset.data_view();
     return init_(params,
-                 dataset.view().data_handle(),
+                 data_view.data_handle(),
                  IndexT(dataset.n_rows()),
                  dataset.dim(),
-                 dataset.stride(),
+                 data_view.stride(),
                  dataset_norms);
   }
 
diff --git a/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp b/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
index 7ae9dc87ba..45bb515f15 100644
--- a/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
+++ b/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
@@ -41,16 +41,20 @@ struct vpq_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT> {
   using typename base_type::host_type;
   using typename base_type::index_type;
 
+  // `DatasetT` here is the non-owning dataset_view (not the owning dataset) -- callers pass the
+  // view directly rather than reaching back through a `.dset()`-style owner pointer, so
+  // classification and the codebook element type are read off the view via its own dictionary
+  // state (`is_vpq_dataset_view_v`, `DatasetT::value_type`), not an owning-only trait/typedef.
   template <typename DatasetT>
   constexpr static inline auto accepts_dataset()
-    -> std::enable_if_t<is_vpq_dataset_v<DatasetT>, bool>
+    -> std::enable_if_t<cuvs::neighbors::is_vpq_dataset_view_v<DatasetT>, bool>
   {
-    return std::is_same_v<typename DatasetT::math_type, CodebookT>;
+    return std::is_same_v<typename DatasetT::value_type, CodebookT>;
   }
 
   template <typename DatasetT>
   constexpr static inline auto accepts_dataset()
-    -> std::enable_if_t<!is_vpq_dataset_v<DatasetT>, bool>
+    -> std::enable_if_t<!cuvs::neighbors::is_vpq_dataset_view_v<DatasetT>, bool>
   {
     return false;
   }
@@ -61,11 +65,13 @@ struct vpq_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT> {
                    cuvs::distance::DistanceType metric,
                    const DistanceT* dataset_norms = nullptr) -> host_type
   {
+    auto const data_view = dataset.data_view();
+    auto const dict_view = dataset.dictionary_view();
     return init_(params,
-                 dataset.data.data_handle(),
-                 dataset.encoded_row_length(),
-                 dataset.vq_code_book.data_handle(),
-                 dataset.pq_code_book.data_handle(),
+                 data_view.data_handle(),
+                 static_cast<uint32_t>(data_view.extent(1)),
+                 dict_view.vq_code_book.data_handle(),
+                 dict_view.pq_code_book.data_handle(),
                  IndexT(dataset.n_rows()),
                  dataset.dim());
   }
@@ -79,8 +85,9 @@ struct vpq_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT> {
     if (params.team_size != 0 && TeamSize != params.team_size) { return -1.0; }
     if (cuvs::distance::DistanceType::L2Expanded != metric) { return -1.0; }
     // Match codebook params
-    if (dataset.pq_bits() != PqBits) { return -1.0; }
-    if (dataset.pq_len() != PqLen) { return -1.0; }
+    auto const dict_view = dataset.dictionary_view();
+    if (dict_view.pq_bits() != PqBits) { return -1.0; }
+    if (dict_view.pq_len() != PqLen) { return -1.0; }
     if (select_supported_vpq_smem_dtype(params) != SmemDType) { return -1.0; }
     // Keep auto-selection on the tuned VPQ diagonal while allowing explicit team_size requests to
     // use the expanded team_size / dataset_block_dim grid.
diff --git a/cpp/src/neighbors/detail/cagra/factory.cuh b/cpp/src/neighbors/detail/cagra/factory.cuh
index cdcc18867b..3b746ac680 100644
--- a/cpp/src/neighbors/detail/cagra/factory.cuh
+++ b/cpp/src/neighbors/detail/cagra/factory.cuh
@@ -90,16 +90,19 @@ struct key {
   uint32_t smem_dtype;
 };
 
+// `DatasetT` here is the non-owning dataset_view passed in by the search path, so all state comes
+// off the view's own `data_view()`/`dictionary_view()`, not owning-only members.
 template <typename DatasetT>
 auto make_key(const cagra::search_params& params,
               const DatasetT& dataset,
               cuvs::distance::DistanceType metric)
-  -> std::enable_if_t<is_padded_dataset_v<DatasetT>, key>
+  -> std::enable_if_t<cuvs::neighbors::is_padded_dataset_view_v<DatasetT>, key>
 {
-  return key{reinterpret_cast<uint64_t>(dataset.view().data_handle()),
+  auto const data_view = dataset.data_view();
+  return key{reinterpret_cast<uint64_t>(data_view.data_handle()),
              uint64_t(dataset.n_rows()),
              dataset.dim(),
-             dataset.stride(),
+             data_view.stride(),
              uint32_t(params.team_size),
              uint32_t(metric),
              uint32_t(params.smem_dtype)};
@@ -109,12 +112,14 @@ template <typename DatasetT>
 auto make_key(const cagra::search_params& params,
               const DatasetT& dataset,
               cuvs::distance::DistanceType metric)
-  -> std::enable_if_t<is_vpq_dataset_v<DatasetT>, key>
+  -> std::enable_if_t<cuvs::neighbors::is_vpq_dataset_view_v<DatasetT>, key>
 {
-  return key{reinterpret_cast<uint64_t>(dataset.data.data_handle()),
+  auto const data_view = dataset.data_view();
+  auto const dict_view = dataset.dictionary_view();
+  return key{reinterpret_cast<uint64_t>(data_view.data_handle()),
              uint64_t(dataset.n_rows()),
              dataset.dim(),
-             uint32_t(reinterpret_cast<uint64_t>(dataset.pq_code_book.data_handle()) >> 6),
+             uint32_t(reinterpret_cast<uint64_t>(dict_view.pq_code_book.data_handle()) >> 6),
              uint32_t(params.team_size),
              uint32_t(metric),
              uint32_t(params.smem_dtype)};
diff --git a/cpp/src/neighbors/detail/dataset_serialize.hpp b/cpp/src/neighbors/detail/dataset_serialize.hpp
index e66e60d941..081110eb06 100644
--- a/cpp/src/neighbors/detail/dataset_serialize.hpp
+++ b/cpp/src/neighbors/detail/dataset_serialize.hpp
@@ -85,13 +85,14 @@ template <typename DataT, typename IdxT, typename ViewT>
   requires cuvs::neighbors::is_dense_row_major_dataset_view_v<ViewT>
 void serialize(const raft::resources& res, std::ostream& os, ViewT const& dataset)
 {
-  auto n_rows = dataset.n_rows();
-  auto dim    = dataset.dim();
-  auto stride = dataset.stride();
+  auto n_rows    = dataset.n_rows();
+  auto dim       = dataset.dim();
+  auto data_view = dataset.data_view();
+  auto stride    = data_view.stride();
   raft::serialize_scalar(res, os, n_rows);
   raft::serialize_scalar(res, os, dim);
   raft::serialize_scalar(res, os, stride);
-  auto src            = dataset.view();
+  auto src            = data_view;
   auto const elements = dense_matrix_elements<DataT>(n_rows, dim, "serialize_dense_dataset");
   raft::numpy_serializer::write_header(os,
                                        {raft::numpy_serializer::get_numpy_dtype<DataT>(),
@@ -434,8 +435,9 @@ auto deserialize_vpq(raft::resources const& res, std::istream& is)
   raft::deserialize_mdspan(res, is, pq_code_book.view());
   raft::deserialize_mdspan(res, is, data.view());
 
-  return std::make_unique<device_vpq_dataset<DataT, IdxT>>(
-    std::move(vq_code_book), std::move(pq_code_book), std::move(data));
+  using owning_t = device_vpq_dataset<DataT, IdxT>;
+  typename owning_t::dictionary_type dictionary{std::move(vq_code_book), std::move(pq_code_book)};
+  return std::make_unique<owning_t>(std::move(data), std::move(dictionary));
 }
 
 template <typename DataT, typename IdxT, typename OwningDatasetT, typename Input>
diff --git a/cpp/src/neighbors/detail/hnsw.hpp b/cpp/src/neighbors/detail/hnsw.hpp
index bac127294e..c9df2de391 100644
--- a/cpp/src/neighbors/detail/hnsw.hpp
+++ b/cpp/src/neighbors/detail/hnsw.hpp
@@ -360,8 +360,8 @@ from_cagra(raft::resources const& res,
     host_dataset = raft::make_host_matrix<T, int64_t>(dataset_view.n_rows(), dataset_view.dim());
     raft::copy_matrix(host_dataset.data_handle(),
                       host_dataset.extent(1),
-                      dataset_view.view().data_handle(),
-                      dataset_view.stride(),
+                      dataset_view.data_view().data_handle(),
+                      dataset_view.data_view().stride(),
                       host_dataset.extent(1),
                       dataset_view.n_rows(),
                       raft::resource::get_cuda_stream(res));
@@ -1003,12 +1003,13 @@ void serialize_to_hnswlib_from_inmem(
     source_stride  = dim;
   } else if constexpr (is_host_cagra_hnsw_export_index_v<T, CagraIndexT>) {
     RAFT_FAIL("serialize_to_hnswlib_from_inmem requires dataset for host CAGRA index");
-  } else if (auto dataset_view = index_.dataset(); dataset_view.view().data_handle() != nullptr) {
+  } else if (auto dataset_view = index_.dataset();
+             dataset_view.data_view().data_handle() != nullptr) {
     n_rows         = dataset_view.n_rows();
     dim            = dataset_view.dim();
     device_dataset = true;
-    source_dataset = dataset_view.view().data_handle();
-    source_stride  = dataset_view.stride();
+    source_dataset = dataset_view.data_view().data_handle();
+    source_stride  = dataset_view.data_view().stride();
   } else {
     RAFT_FAIL("serialize_to_hnswlib_from_inmem: No dataset provided");
   }
@@ -1129,12 +1130,12 @@ from_cagra(raft::resources const& res,
   } else if constexpr (is_host_cagra_hnsw_export_index_v<T, CagraIndexT>) {
     RAFT_FAIL("hnsw::from_cagra<GPU> requires dataset for host CAGRA index");
   } else if (auto dataset_view = cagra_index.dataset();
-             dataset_view.view().data_handle() != nullptr) {
+             dataset_view.data_view().data_handle() != nullptr) {
     n_rows         = dataset_view.n_rows();
     dim            = dataset_view.dim();
     device_copy    = true;
-    source_dataset = dataset_view.view().data_handle();
-    source_stride  = dataset_view.stride();
+    source_dataset = dataset_view.data_view().data_handle();
+    source_stride  = dataset_view.data_view().stride();
   } else {
     RAFT_FAIL("hnsw::from_cagra<GPU>: No dataset provided");
   }
diff --git a/cpp/src/neighbors/detail/vamana/vamana_build.cuh b/cpp/src/neighbors/detail/vamana/vamana_build.cuh
index fc262b3311..82aa16e4ea 100644
--- a/cpp/src/neighbors/detail/vamana/vamana_build.cuh
+++ b/cpp/src/neighbors/detail/vamana/vamana_build.cuh
@@ -644,12 +644,14 @@ index<T, IdxT> build(
     // process in batches
     const uint32_t n_rows = dataset.extent(0);
 
+    using vpq_owning_t = cuvs::neighbors::device_vpq_dataset<float, int64_t>;
+    typename vpq_owning_t::dictionary_type vpq_dictionary{
+      raft::make_device_matrix<float, uint32_t, raft::row_major>(res, 0, 0),
+      std::move(pq_codebook)};
     auto quantizer = cuvs::preprocessing::quantize::pq::quantizer<float>(
       pq_params,
-      cuvs::neighbors::device_vpq_dataset<float, int64_t>{
-        raft::make_device_matrix<float, uint32_t, raft::row_major>(res, 0, 0),
-        std::move(pq_codebook),
-        raft::make_device_matrix<uint8_t, int64_t, raft::row_major>(res, 0, 0)});
+      vpq_owning_t(raft::make_device_matrix<uint8_t, int64_t, raft::row_major>(res, 0, 0),
+                   std::move(vpq_dictionary)));
     const int64_t codes_rowlen = cuvs::preprocessing::quantize::pq::get_quantized_dim(pq_params);
     quantized_vectors =
       raft::make_device_matrix<uint8_t, int64_t, raft::row_major>(res, n_rows, codes_rowlen);
diff --git a/cpp/src/neighbors/detail/vamana/vamana_serialize.cuh b/cpp/src/neighbors/detail/vamana/vamana_serialize.cuh
index 8a21ed3f1b..c77482c274 100644
--- a/cpp/src/neighbors/detail/vamana/vamana_serialize.cuh
+++ b/cpp/src/neighbors/detail/vamana/vamana_serialize.cuh
@@ -95,7 +95,7 @@ void serialize_dataset(raft::resources const& res,
 {
   if (dataset == nullptr) { return; }
   try {
-    serialize_dataset_view<T>(res, dataset->view(), dataset_base_file);
+    serialize_dataset_view<T>(res, dataset->data_view(), dataset_base_file);
   } catch (std::bad_alloc& e) {
     RAFT_LOG_INFO("Failed to serialize dataset");
   } catch (raft::logic_error& e) {
@@ -172,8 +172,8 @@ void serialize_sector_aligned(
   auto h_data = raft::make_host_matrix<T, int64_t>(npts, ndims);
   raft::copy_matrix(h_data.data_handle(),
                     ndims,
-                    dataset.view().data_handle(),
-                    dataset.stride(),
+                    dataset.data_view().data_handle(),
+                    dataset.data_view().stride(),
                     ndims,
                     npts,
                     raft::resource::get_cuda_stream(res));
diff --git a/cpp/src/neighbors/mg/mg_cagra_inst.cu.in b/cpp/src/neighbors/mg/mg_cagra_inst.cu.in
index 077a065e58..0fbe7b926f 100644
--- a/cpp/src/neighbors/mg/mg_cagra_inst.cu.in
+++ b/cpp/src/neighbors/mg/mg_cagra_inst.cu.in
@@ -14,7 +14,7 @@ void distribute_padded_dataset(
   cuvs::neighbors::device_padded_dataset_view<T, int64_t> const& padded_dataset,
   RankUpdate&& rank_update)
 {
-  auto padded_mds                 = padded_dataset.view();
+  auto padded_mds                 = padded_dataset.data_view();
   auto stride                     = padded_mds.extent(1);
   const raft::resources& root_res = raft::resource::set_current_device_to_root_rank(res);
   auto padded_host =
@@ -61,7 +61,7 @@ void distribute_padded_dataset(
       res,                                                                                        \
       index,                                                                                      \
       static_cast<const cuvs::neighbors::index_params*>(&index_params),                           \
-      index_dataset.view());                                                                      \
+      index_dataset.data_view());                                                                 \
     return index;                                                                                 \
   }                                                                                               \
                                                                                                   \
@@ -76,7 +76,7 @@ void distribute_padded_dataset(
       res,                                                                                        \
       index,                                                                                      \
       static_cast<const cuvs::neighbors::index_params*>(&index_params),                           \
-      index_dataset.view());                                                                      \
+      index_dataset.data_view());                                                                 \
     return index;                                                                                 \
   }                                                                                               \
                                                                                                   \
@@ -122,7 +122,7 @@ void distribute_padded_dataset(
               cuvs::neighbors::host_padded_dataset_view<T, int64_t> new_vectors,                  \
               std::optional<raft::host_vector_view<const IdxT, int64_t>> new_indices)             \
   {                                                                                               \
-    cuvs::neighbors::snmg::detail::extend(res, index, new_vectors.view(), new_indices);           \
+    cuvs::neighbors::snmg::detail::extend(res, index, new_vectors.data_view(), new_indices);      \
   }                                                                                               \
                                                                                                   \
   void extend(const raft::resources& res,                                                         \
@@ -130,7 +130,7 @@ void distribute_padded_dataset(
               cuvs::neighbors::host_standard_dataset_view<T, int64_t> new_vectors,                \
               std::optional<raft::host_vector_view<const IdxT, int64_t>> new_indices)             \
   {                                                                                               \
-    cuvs::neighbors::snmg::detail::extend(res, index, new_vectors.view(), new_indices);           \
+    cuvs::neighbors::snmg::detail::extend(res, index, new_vectors.data_view(), new_indices);      \
   }                                                                                               \
                                                                                                   \
   void search(                                                                                    \
diff --git a/cpp/src/neighbors/scann/detail/scann_build.cuh b/cpp/src/neighbors/scann/detail/scann_build.cuh
index c01e50bc83..56611268f7 100644
--- a/cpp/src/neighbors/scann/detail/scann_build.cuh
+++ b/cpp/src/neighbors/scann/detail/scann_build.cuh
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -290,7 +290,7 @@ index<T, IdxT> build(
   // Codebooks from VPQ have the shape [subspace idx, subspace dim, code]
   // This converts the codebook into matrix format for easy interoperability
   // with open-source ScaNN search
-  auto full_codebook_view = pq_quantizer.vpq_codebooks.pq_code_book.view();
+  auto full_codebook_view = pq_quantizer.vpq_codebooks.dictionary_view().pq_code_book;
 
   raft::linalg::map_offset(
     res,
diff --git a/cpp/src/neighbors/tiered_index.cu b/cpp/src/neighbors/tiered_index.cu
index fd7848454f..5d75886930 100644
--- a/cpp/src/neighbors/tiered_index.cu
+++ b/cpp/src/neighbors/tiered_index.cu
@@ -59,7 +59,7 @@ auto build(raft::resources const& res,
   -> tiered_index::index<cagra::device_padded_index<float, uint32_t>>
 {
   auto state = detail::build<cagra::device_padded_index<float, uint32_t>>(
-    res, params, cagra_build_for_tiered_padded, dataset.view());
+    res, params, cagra_build_for_tiered_padded, dataset.data_view());
   return cuvs::neighbors::tiered_index::index<cagra::device_padded_index<float, uint32_t>>(state);
 }
 
@@ -92,7 +92,7 @@ auto convert_standard_to_padded_index(
   next_state->ann_index.reset();
 
   if (idx.state->ann_index) {
-    auto padded_mds = padded_dataset.view();
+    auto padded_mds = padded_dataset.data_view();
     auto ann_rows   = static_cast<int64_t>(idx.state->ann_rows());
     auto ann_mds    = raft::make_device_matrix_view<const float, int64_t>(
       padded_mds.data_handle(), ann_rows, static_cast<int64_t>(padded_mds.extent(1)));
diff --git a/cpp/src/preprocessing/quantize/detail/pq.cuh b/cpp/src/preprocessing/quantize/detail/pq.cuh
index 7fea89461a..f0d749b9a6 100644
--- a/cpp/src/preprocessing/quantize/detail/pq.cuh
+++ b/cpp/src/preprocessing/quantize/detail/pq.cuh
@@ -192,9 +192,9 @@ quantizer<MathT> build(
     pq_code_book = cuvs::neighbors::detail::train_pq<MathT>(
       res, filled_params, dataset, raft::make_const_mdspan(vq_code_book.view()));
   }
-  return {filled_params,
-          cuvs::neighbors::device_vpq_dataset<MathT, int64_t>{
-            std::move(vq_code_book), std::move(pq_code_book), std::move(empty_codes)}};
+  using owning_t = cuvs::neighbors::device_vpq_dataset<MathT, int64_t>;
+  typename owning_t::dictionary_type dictionary{std::move(vq_code_book), std::move(pq_code_book)};
+  return {filled_params, owning_t(std::move(empty_codes), std::move(dictionary))};
 }
 
 template <typename T, typename QuantI, typename AccessorType>
@@ -217,7 +217,7 @@ void transform(
   RAFT_EXPECTS(quantizer.params_quantizer.pq_bits >= 4 && quantizer.params_quantizer.pq_bits <= 16,
                "PQ bits must be within [4, 16]");
   // Encode dataset
-  auto vq_centers     = raft::make_const_mdspan(quantizer.vpq_codebooks.vq_code_book.view());
+  auto vq_centers     = quantizer.vpq_codebooks.dictionary_view().vq_code_book;
   auto vq_labels_view = raft::make_device_vector_view<uint32_t, int64_t>(nullptr, 0);
   if (vq_labels.has_value()) { vq_labels_view = vq_labels.value(); }
 
@@ -226,7 +226,7 @@ void transform(
       res,
       to_vpq_params(quantizer.params_quantizer),
       dataset,
-      raft::make_const_mdspan(quantizer.vpq_codebooks.pq_code_book.view()),
+      quantizer.vpq_codebooks.dictionary_view().pq_code_book,
       vq_centers,
       vq_labels_view,
       pq_codes_out);
@@ -235,7 +235,7 @@ void transform(
       res,
       to_vpq_params(quantizer.params_quantizer),
       dataset,
-      raft::make_const_mdspan(quantizer.vpq_codebooks.pq_code_book.view()),
+      quantizer.vpq_codebooks.dictionary_view().pq_code_book,
       vq_centers,
       vq_labels_view,
       pq_codes_out);
@@ -356,30 +356,32 @@ void inverse_transform(
                "Codes matrix doesn't have the correct number of columns");
   RAFT_EXPECTS(quant.params_quantizer.pq_bits >= 4 && quant.params_quantizer.pq_bits <= 16,
                "PQ bits must be within [4, 16]");
-  reconstruct_vectors<T, T, idx_t, label_t>(
-    res,
-    quant.params_quantizer,
-    codes,
-    raft::make_const_mdspan(quant.vpq_codebooks.pq_code_book.view()),
-    raft::make_const_mdspan(quant.vpq_codebooks.vq_code_book.view()),
-    vq_labels,
-    out,
-    quant.params_quantizer.use_subspaces);
+  auto const quant_dict = quant.vpq_codebooks.dictionary_view();
+  reconstruct_vectors<T, T, idx_t, label_t>(res,
+                                            quant.params_quantizer,
+                                            codes,
+                                            quant_dict.pq_code_book,
+                                            quant_dict.vq_code_book,
+                                            vq_labels,
+                                            out,
+                                            quant.params_quantizer.use_subspaces);
 }
 
 template <typename NewMathT, typename OldMathT, typename IdxT>
-void vpq_convert_math_type(const raft::resources& res,
-                           const cuvs::neighbors::device_vpq_dataset<OldMathT, IdxT>& src,
-                           cuvs::neighbors::device_vpq_dataset<NewMathT, IdxT>& dst)
+void vpq_convert_math_type(
+  const raft::resources& res,
+  const cuvs::neighbors::device_vpq_dataset<OldMathT, IdxT>& src,
+  typename cuvs::neighbors::device_vpq_dataset<NewMathT, IdxT>::dictionary_type& dst_dict)
 {
+  auto const src_dict = src.dictionary_view();
   raft::linalg::map(res,
-                    dst.vq_code_book.view(),
+                    dst_dict.vq_code_book.view(),
                     cuvs::spatial::knn::detail::utils::mapping<NewMathT>{},
-                    raft::make_const_mdspan(src.vq_code_book.view()));
+                    src_dict.vq_code_book);
   raft::linalg::map(res,
-                    dst.pq_code_book.view(),
+                    dst_dict.pq_code_book.view(),
                     cuvs::spatial::knn::detail::utils::mapping<NewMathT>{},
-                    raft::make_const_mdspan(src.pq_code_book.view()));
+                    src_dict.pq_code_book);
 }
 
 inline auto make_pq_params_from_vpq(const cuvs::neighbors::vpq_params& in_params,
@@ -437,8 +439,9 @@ auto vpq_build(const raft::resources& res,
     codes.view(),
     true);
 
-  return cuvs::neighbors::device_vpq_dataset<MathT, IdxT>{
-    std::move(vq_code_book), std::move(pq_code_book), std::move(codes)};
+  using owning_t = cuvs::neighbors::device_vpq_dataset<MathT, IdxT>;
+  typename owning_t::dictionary_type dictionary{std::move(vq_code_book), std::move(pq_code_book)};
+  return owning_t(std::move(codes), std::move(dictionary));
 }
 
 template <typename DatasetT>
@@ -446,12 +449,13 @@ auto vpq_build_half(const raft::resources& res,
                     const cuvs::neighbors::vpq_params& params,
                     const DatasetT& dataset) -> cuvs::neighbors::device_vpq_dataset<half, int64_t>
 {
-  auto old_type = vpq_build<decltype(dataset), float, int64_t>(res, params, dataset);
-  auto new_type = cuvs::neighbors::device_vpq_dataset<half, int64_t>{
-    raft::make_device_mdarray<half>(res, old_type.vq_code_book.extents()),
-    raft::make_device_mdarray<half>(res, old_type.pq_code_book.extents()),
-    std::move(old_type.data)};
-  vpq_convert_math_type<half, float, int64_t>(res, old_type, new_type);
-  return new_type;
+  auto old_type       = vpq_build<decltype(dataset), float, int64_t>(res, params, dataset);
+  using new_owning_t  = cuvs::neighbors::device_vpq_dataset<half, int64_t>;
+  auto const old_dict = old_type.dictionary_view();
+  typename new_owning_t::dictionary_type new_dict{
+    raft::make_device_mdarray<half>(res, old_dict.vq_code_book.extents()),
+    raft::make_device_mdarray<half>(res, old_dict.pq_code_book.extents())};
+  vpq_convert_math_type<half, float, int64_t>(res, old_type, new_dict);
+  return new_owning_t(old_type.release_data(), std::move(new_dict));
 }
 }  // namespace cuvs::preprocessing::quantize::pq::detail
diff --git a/cpp/tests/neighbors/ann_cagra.cuh b/cpp/tests/neighbors/ann_cagra.cuh
index ebfbab759e..5a033f4b07 100644
--- a/cpp/tests/neighbors/ann_cagra.cuh
+++ b/cpp/tests/neighbors/ann_cagra.cuh
@@ -1329,7 +1329,7 @@ class AnnCagraIndexFilteredMergeTest : public ::testing::TestWithParam<AnnCagraI
         auto merged_matrix = raft::make_device_matrix<DataT, int64_t>(
           handle_,
           ps.n_rows - static_cast<int64_t>(test_cagra_sample_filter::offset),
-          static_cast<int64_t>(index0.dataset().stride()));
+          static_cast<int64_t>(index0.dataset().data_view().stride()));
         auto merged_dataset = cuvs::neighbors::device_padded_dataset<DataT, int64_t>(
           std::move(merged_matrix), static_cast<uint32_t>(ps.dim));
         auto merge_idx = cuvs::neighbors::cagra::merge(
@@ -1575,7 +1575,7 @@ class AnnCagraIndexMergeTest : public ::testing::TestWithParam<AnnCagraInputs> {
           auto const merged_rows =
             static_cast<int64_t>(index0.size()) + static_cast<int64_t>(index1.size());
           auto merged_matrix = raft::make_device_matrix<DataT, int64_t>(
-            handle_, merged_rows, static_cast<int64_t>(index0.dataset().stride()));
+            handle_, merged_rows, static_cast<int64_t>(index0.dataset().data_view().stride()));
           auto merged_dataset = cuvs::neighbors::device_padded_dataset<DataT, int64_t>(
             std::move(merged_matrix), static_cast<uint32_t>(ps.dim));
           auto merged_idx =
diff --git a/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu b/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu
index 9dee454d8c..867de36177 100644
--- a/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu
+++ b/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu
@@ -216,11 +216,13 @@ void expect_dataset_order(raft::resources const& res,
   // honouring that stride rather than as one contiguous block.
   auto host   = raft::make_host_matrix<T, int64_t>(res, expected.extent(0), expected.extent(1));
   auto stream = raft::resource::get_cuda_stream(res);
-  int64_t const row_stride = static_cast<int64_t>(view.stride());
+  int64_t const row_stride = static_cast<int64_t>(view.data_view().stride());
   int64_t const dim        = static_cast<int64_t>(view.dim());
   for (int64_t row = 0; row < view.n_rows(); ++row) {
-    raft::copy(
-      host.data_handle() + row * dim, view.view().data_handle() + row * row_stride, dim, stream);
+    raft::copy(host.data_handle() + row * dim,
+               view.data_view().data_handle() + row * row_stride,
+               dim,
+               stream);
   }
   raft::resource::sync_stream(res);
   for (int64_t row = 0; row < expected.extent(0); ++row) {
@@ -237,10 +239,10 @@ void expect_zero_padding(raft::resources const& res,
   auto view            = merged.dataset();
   int64_t const rows   = view.n_rows();
   int64_t const dim    = static_cast<int64_t>(view.dim());
-  int64_t const stride = static_cast<int64_t>(view.stride());
+  int64_t const stride = static_cast<int64_t>(view.data_view().stride());
   std::vector<T> host(static_cast<std::size_t>(rows * stride));
   auto stream = raft::resource::get_cuda_stream(res);
-  raft::copy(host.data(), view.view().data_handle(), host.size(), stream);
+  raft::copy(host.data(), view.data_view().data_handle(), host.size(), stream);
   raft::resource::sync_stream(res);
   for (int64_t row = 0; row < rows; ++row) {
     for (int64_t column = dim; column < stride; ++column) {
diff --git a/cpp/tests/neighbors/ann_scann.cuh b/cpp/tests/neighbors/ann_scann.cuh
index 81ef21c8e2..dff3b52a86 100644
--- a/cpp/tests/neighbors/ann_scann.cuh
+++ b/cpp/tests/neighbors/ann_scann.cuh
@@ -184,10 +184,11 @@ class scann_test : public ::testing::TestWithParam<scann_inputs> {
       vq_codebook.data_handle(), idx.centers().data_handle(), idx.centers().size(), stream_);
     auto empty_data = raft::make_device_matrix<uint8_t, int64_t, raft::row_major>(handle_, 0, 0);
 
+    using vpq_owning_t = cuvs::neighbors::device_vpq_dataset<float, int64_t>;
+    typename vpq_owning_t::dictionary_type vpq_dictionary{std::move(vq_codebook),
+                                                          std::move(pq_codebook_copy)};
     cuvs::preprocessing::quantize::pq::quantizer<float> quantizer{
-      pq_params,
-      cuvs::neighbors::device_vpq_dataset<float, int64_t>{
-        std::move(vq_codebook), std::move(pq_codebook_copy), std::move(empty_data)}};
+      pq_params, vpq_owning_t(std::move(empty_data), std::move(vpq_dictionary))};
 
     auto quantized_residuals_device =
       raft::make_device_matrix<uint8_t, IdxT>(handle_, ps.num_db_vecs, num_subspaces);
diff --git a/cpp/tests/neighbors/vpq_utils.cuh b/cpp/tests/neighbors/vpq_utils.cuh
index 23dba3218c..7b5b38e528 100644
--- a/cpp/tests/neighbors/vpq_utils.cuh
+++ b/cpp/tests/neighbors/vpq_utils.cuh
@@ -50,7 +50,9 @@ void decode_vpq_dataset(raft::device_matrix_view<data_t, int64_t> decoded_datase
                         cudaStream_t cuda_stream)
 {
   const auto dataset_size = decoded_dataset.extent(0);
-  RAFT_EXPECTS(vpq_dataset.data.extent(0) == dataset_size, "Dataset sizes mismatch");
+  auto const dict_view    = vpq_dataset.dictionary_view();
+  auto const data_view    = vpq_dataset.data_view();
+  RAFT_EXPECTS(data_view.extent(0) == dataset_size, "Dataset sizes mismatch");
   RAFT_EXPECTS(vpq_dataset.pq_bits() == 8,
                "decode_vpq_dataset currently only supports pq_bits == 8 (got %u)",
                vpq_dataset.pq_bits());
@@ -63,14 +65,14 @@ void decode_vpq_dataset(raft::device_matrix_view<data_t, int64_t> decoded_datase
   decode_vpq_dataset_kernel<data_t, math_t>
     <<<grid_size, block_size, 0, cuda_stream>>>(decoded_dataset.data_handle(),
                                                 decoded_dataset.stride(0),
-                                                vpq_dataset.vq_code_book.data_handle(),
-                                                vpq_dataset.vq_code_book.stride(0),
-                                                vpq_dataset.pq_code_book.data_handle(),
+                                                dict_view.vq_code_book.data_handle(),
+                                                dict_view.vq_code_book.stride(0),
+                                                dict_view.pq_code_book.data_handle(),
                                                 vpq_dataset.pq_len(),
                                                 1u << vpq_dataset.pq_bits(),
                                                 vpq_dataset.dim(),
                                                 dataset_size,
-                                                vpq_dataset.data.data_handle(),
-                                                vpq_dataset.data.stride(0));
+                                                data_view.data_handle(),
+                                                data_view.stride(0));
 }
 }  // namespace cuvs::neighbors
diff --git a/cpp/tests/preprocessing/product_quantization.cu b/cpp/tests/preprocessing/product_quantization.cu
index a392e7e1db..42a57598bf 100644
--- a/cpp/tests/preprocessing/product_quantization.cu
+++ b/cpp/tests/preprocessing/product_quantization.cu
@@ -329,7 +329,7 @@ TEST(ProductQuantizationTestF, MakeVpqDatasetFromHost)
 
   EXPECT_EQ(vpq.n_rows(), n_rows);
   EXPECT_EQ(vpq.dim(), dim);
-  EXPECT_NE(vpq.data.data_handle(), nullptr);
+  EXPECT_NE(vpq.data_view().data_handle(), nullptr);
 }
 
 TEST(ProductQuantizationTestF, MakeVpqDatasetFromPaddedView)
@@ -362,7 +362,7 @@ TEST(ProductQuantizationTestF, MakeVpqDatasetFromPaddedView)
 
   EXPECT_EQ(vpq.n_rows(), n_rows);
   EXPECT_EQ(vpq.dim(), dim);
-  EXPECT_NE(vpq.data.data_handle(), nullptr);
+  EXPECT_NE(vpq.data_view().data_handle(), nullptr);
 }
 
 // Define test cases with different parameters

From b70daa59199bbaade001a2ba998767dc8a8c90e3 Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Mon, 28 Sep 2026 20:39:05 -0700
Subject: [PATCH 04/15] Fix Spec-based dataset API fallout from the
 release/26.10 -> main merge

Merging upstream main (26.12) pulled in code written against pieces of the
old ContainerType-tagged dataset/dataset_view design that this branch
already replaced with dataset<T,IdxT,SpecT>. Git merged these files
without conflict (mostly new/independently-touched code), but the result
didn't compile or was silently wrong against the new API. No functional
changes beyond restoring correct usage of the existing Spec-based API.

- bbq.hpp: BBQ was written as a partial specialization of the old
  4-parameter dataset<ContainerType,DataT,IdxT,Accessor> template, which
  no longer exists. BBQ's shape (a runtime-sized set of alternate
  quantized encodings, mutated in place by the C API) doesn't fit the
  dataset<T,IdxT,SpecT> two-slot (data + dictionary) model that
  padded/standard/vpq share, so it gets standalone bbq_dataset/
  bbq_dataset_view types instead of a SpecT -- same public API as before,
  just no longer named as a dataset<>/dataset_view<> specialization.
  Re-pointed the surrounding trait specializations (owning_dataset_for_view,
  is_bbq_dataset, dataset_view_kind_of, dataset_view_is_device_accessible)
  at the new type names; dropped the now-invalid cagra_view_element_type
  specialization in favor of a plain value_type member.

- factory.cuh: the merge dropped key_hash/operator==(key,key) (needed by
  raft::cache::lru's descriptor cache) entirely, and reverted two of the
  make_key() overloads back to is_vpq_dataset_v (owning-only trait, always
  false for a view) and flat dataset.pq_code_book access. Restored
  key_hash/operator==, fixed the predicate to is_vpq_dataset_view_v, and
  fixed the accessor to go through dictionary_view().pq_code_book.

- cagra.cuh, cagra_build.cuh: reverted back to the old .dset() owner
  back-pointer (dataset_view no longer holds one) in three spots, a bare
  dataset.stride() call (moved to dataset.data_view().stride()), and flat
  vpq_dset.data/.vq_code_book/.pq_code_book member access in
  reconstruct_vpq_queries(); rewritten to use data_view()/dictionary_view().

- test_iterative_cagra_q.cu: a new test added by the merge still used the
  old 3-argument VPQ dataset constructor (vq_code_book, pq_code_book,
  codes); switched to the current 2-argument form (codes, dictionary_type
  {vq_code_book, pq_code_book}).

Verified: full rebuild clean (including the CUB/Thrust version mismatch
from a stale CMakeCache CUB_DIR, fixed by a clean reconfigure -- unrelated
to source changes); DATASET_C_TEST, CAGRA_C_TEST, PREPROCESSING_TEST, and
NEIGHBORS_TEST all pass.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .../cuvs/preprocessing/quantize/bbq.hpp       | 66 ++++++++++---------
 cpp/src/neighbors/cagra.cuh                   |  6 +-
 .../neighbors/detail/cagra/cagra_build.cuh    | 22 ++++---
 cpp/src/neighbors/detail/cagra/factory.cuh    | 23 ++++++-
 .../ann_cagra/test_iterative_cagra_q.cu       |  3 +-
 .../cpp-api-preprocessing-quantize-bbq.md     | 14 ++++
 6 files changed, 85 insertions(+), 49 deletions(-)

diff --git a/cpp/include/cuvs/preprocessing/quantize/bbq.hpp b/cpp/include/cuvs/preprocessing/quantize/bbq.hpp
index 21366d47d0..e93860f9f7 100644
--- a/cpp/include/cuvs/preprocessing/quantize/bbq.hpp
+++ b/cpp/include/cuvs/preprocessing/quantize/bbq.hpp
@@ -243,29 +243,33 @@ void resolve_dequant_factors(
 }  // namespace preprocessing::quantize::bbq
 
 namespace neighbors {
-struct bbq_dataset_container {
-  template <typename DataT, typename IdxT>
-  using owning_storage = cuvs::preprocessing::quantize::bbq::quantizer<DataT, IdxT>;
-  template <typename DataT, typename IdxT>
-  using view_storage = cuvs::preprocessing::quantize::bbq::quantizer_view<DataT, IdxT>;
-};
+
+/**
+ * BBQ doesn't fit the shared Spec-based `dataset`/`dataset_view` shape (one data slot + one
+ * optional dictionary slot): a BBQ dataset is a small bag of alternate encodings of the *same*
+ * rows, one per `bbq_code_layout`, selected at query time. So unlike padded/standard/vpq, BBQ
+ * gets its own standalone owning/view types rather than a `SpecT` plugged into `dataset`/
+ * `dataset_view` -- they only need to satisfy `ann_dataset_view` (`n_rows()`/`dim()`) to work
+ * everywhere a dataset view is expected, plus the handful of trait specializations below.
+ */
+template <typename DataT, typename IdxT, typename Accessor>
+struct bbq_dataset_view;
 
 template <typename DataT, typename IdxT, typename Accessor>
-struct dataset<bbq_dataset_container, DataT, IdxT, Accessor> {
-  using owning_storage_type = bbq_dataset_container::owning_storage<DataT, IdxT>;
+struct bbq_dataset {
+  using value_type          = DataT;
+  using owning_storage_type = cuvs::preprocessing::quantize::bbq::quantizer<DataT, IdxT>;
   std::vector<owning_storage_type> quantizers;
 
-  dataset(owning_storage_type&& quantizer) noexcept { add_quantizer(std::move(quantizer)); }
+  explicit bbq_dataset(owning_storage_type&& quantizer) noexcept
+  {
+    add_quantizer(std::move(quantizer));
+  }
   [[nodiscard]] auto as_dataset_view() const noexcept
-    -> dataset_view<bbq_dataset_container,
-                    DataT,
-                    IdxT,
-                    detail::dataset_view_accessor_for_owning<DataT, Accessor>>
+    -> bbq_dataset_view<DataT, IdxT, detail::dataset_view_accessor_for_owning<DataT, Accessor>>
   {
-    return dataset_view<bbq_dataset_container,
-                        DataT,
-                        IdxT,
-                        detail::dataset_view_accessor_for_owning<DataT, Accessor>>{quantizers};
+    return bbq_dataset_view<DataT, IdxT, detail::dataset_view_accessor_for_owning<DataT, Accessor>>{
+      quantizers};
   }
   [[nodiscard]] constexpr auto n_rows() const noexcept -> IdxT
   {
@@ -291,14 +295,15 @@ struct dataset<bbq_dataset_container, DataT, IdxT, Accessor> {
 };
 
 template <typename DataT, typename IdxT, typename Accessor>
-struct dataset_view<bbq_dataset_container, DataT, IdxT, Accessor> {
-  using owning_storage_type = bbq_dataset_container::owning_storage<DataT, IdxT>;
-  using view_storage_type   = bbq_dataset_container::view_storage<DataT, IdxT>;
+struct bbq_dataset_view {
+  using value_type          = DataT;
+  using owning_storage_type = cuvs::preprocessing::quantize::bbq::quantizer<DataT, IdxT>;
+  using view_storage_type   = cuvs::preprocessing::quantize::bbq::quantizer_view<DataT, IdxT>;
   std::vector<view_storage_type> quantizers;
 
-  dataset_view() noexcept = default;
+  bbq_dataset_view() noexcept = default;
 
-  dataset_view(const std::vector<owning_storage_type>& quantizers) noexcept
+  bbq_dataset_view(const std::vector<owning_storage_type>& quantizers) noexcept
   {
     for (const auto& quantizer : quantizers) {
       add_quantizer(quantizer);
@@ -340,12 +345,10 @@ struct dataset_view<bbq_dataset_container, DataT, IdxT, Accessor> {
 };
 
 template <typename DataT, typename IdxT>
-using device_bbq_dataset =
-  dataset<bbq_dataset_container, DataT, IdxT, detail::device_owning_accessor<DataT>>;
+using device_bbq_dataset = bbq_dataset<DataT, IdxT, detail::device_owning_accessor<DataT>>;
 
 template <typename DataT, typename IdxT>
-using device_bbq_dataset_view =
-  dataset_view<bbq_dataset_container, DataT, IdxT, detail::device_view_accessor<DataT>>;
+using device_bbq_dataset_view = bbq_dataset_view<DataT, IdxT, detail::device_view_accessor<DataT>>;
 
 template <typename DataT, typename IdxT>
 struct owning_dataset_for_view<device_bbq_dataset_view<DataT, IdxT>> {
@@ -356,20 +359,19 @@ template <typename DatasetT>
 struct is_bbq_dataset : std::false_type {};
 
 template <typename DataT, typename IdxT, typename Accessor>
-struct is_bbq_dataset<dataset<bbq_dataset_container, DataT, IdxT, Accessor>> : std::true_type {};
+struct is_bbq_dataset<bbq_dataset<DataT, IdxT, Accessor>> : std::true_type {};
 
 template <typename DatasetT>
 inline constexpr bool is_bbq_dataset_v = is_bbq_dataset<DatasetT>::value;
 
 template <typename DataT, typename IdxT, typename Accessor>
-struct dataset_view_kind_of<dataset_view<bbq_dataset_container, DataT, IdxT, Accessor>> {
+struct dataset_view_kind_of<bbq_dataset_view<DataT, IdxT, Accessor>> {
   static constexpr dataset_view_kind value = dataset_view_kind::bbq;
 };
 
-template <typename DataT, typename IdxT>
-struct cagra_view_element_type<device_bbq_dataset_view<DataT, IdxT>> {
-  using type = DataT;
-};
+template <typename DataT, typename IdxT, typename Accessor>
+struct dataset_view_is_device_accessible<bbq_dataset_view<DataT, IdxT, Accessor>>
+  : std::bool_constant<Accessor::is_device_accessible> {};
 
 template <typename V>
 inline constexpr bool is_device_bbq_dataset_view_v =
diff --git a/cpp/src/neighbors/cagra.cuh b/cpp/src/neighbors/cagra.cuh
index c7fa171676..851ed83dab 100644
--- a/cpp/src/neighbors/cagra.cuh
+++ b/cpp/src/neighbors/cagra.cuh
@@ -320,10 +320,10 @@ auto build(raft::resources const& res, const index_params& params, DatasetViewT
     RAFT_EXPECTS(effective_params.metric == cuvs::distance::DistanceType::L2Expanded,
                  "cagra::build: a VPQ dataset supports only L2Expanded distance");
     RAFT_EXPECTS(dataset.n_rows() > 0, "cagra::build: VPQ dataset must not be empty");
-    RAFT_EXPECTS(dataset.dset().pq_bits() == 8,
+    RAFT_EXPECTS(dataset.pq_bits() == 8,
                  "cagra::build: VPQ dataset requires pq_bits == 8, got %u",
-                 dataset.dset().pq_bits());
-    auto const pq_len = dataset.dset().pq_len();
+                 dataset.pq_bits());
+    auto const pq_len = dataset.pq_len();
     RAFT_EXPECTS(pq_len == 2 || pq_len == 4 || pq_len == 8,
                  "cagra::build: VPQ dataset requires pq_len in {2, 4, 8}, got %u",
                  pq_len);
diff --git a/cpp/src/neighbors/detail/cagra/cagra_build.cuh b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
index f0625cf0aa..40a30a0bc1 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_build.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
@@ -2312,9 +2312,10 @@ void reconstruct_vpq_queries(raft::resources const& res,
                              uint32_t batch_size,
                              raft::device_matrix_view<T, int64_t> output)
 {
-  auto const& vpq_dset     = vpq_view.dset();
-  const uint32_t dim       = vpq_dset.dim();
-  const uint32_t pq_len    = vpq_dset.pq_len();
+  auto const data_view     = vpq_view.data_view();
+  auto const dict_view     = vpq_view.dictionary_view();
+  const uint32_t dim       = vpq_view.dim();
+  const uint32_t pq_len    = vpq_view.pq_len();
   const uint32_t output_ld = static_cast<uint32_t>(output.extent(1));
   const uint32_t threads   = std::min(dim, 256u);
   RAFT_EXPECTS(output_ld >= dim,
@@ -2324,10 +2325,10 @@ void reconstruct_vpq_queries(raft::resources const& res,
 
   kern_reconstruct_vpq_queries<T, MathT>
     <<<batch_size, threads, 0, raft::resource::get_cuda_stream(res).get()>>>(
-      vpq_dset.data.data_handle(),
-      vpq_dset.encoded_row_length(),
-      vpq_dset.vq_code_book.data_handle(),
-      vpq_dset.pq_code_book.data_handle(),
+      data_view.data_handle(),
+      vpq_view.encoded_row_length(),
+      dict_view.vq_code_book.data_handle(),
+      dict_view.pq_code_book.data_handle(),
       dim,
       pq_len,
       offset,
@@ -2480,14 +2481,15 @@ auto iterative_build_graph(raft::resources const& res,
     vpq_dataset      = dataset;
   } else {
     auto const required_stride = cuvs::neighbors::cagra_required_row_width<T>(dataset.dim());
-    RAFT_EXPECTS(dataset.stride() == required_stride,
+    auto const data_view       = dataset.data_view();
+    RAFT_EXPECTS(data_view.stride() == required_stride,
                  "iterative CAGRA build requires a CAGRA-aligned device dataset "
                  "(stride %u, required %u). Pass a device_padded_dataset_view, or a "
                  "device_standard_dataset_view whose row width already matches "
                  "cagra_required_row_width.",
-                 dataset.stride(),
+                 data_view.stride(),
                  required_stride);
-    dev_dataset      = dataset.data_view();
+    dev_dataset      = data_view;
     logical_dim      = dataset.dim();
     final_graph_size = static_cast<uint64_t>(dataset.n_rows());
   }
diff --git a/cpp/src/neighbors/detail/cagra/factory.cuh b/cpp/src/neighbors/detail/cagra/factory.cuh
index e7f3a50bbc..3278a1111e 100644
--- a/cpp/src/neighbors/detail/cagra/factory.cuh
+++ b/cpp/src/neighbors/detail/cagra/factory.cuh
@@ -105,7 +105,7 @@ auto make_key(const cagra::search_params& params,
              reinterpret_cast<uint64_t>(dataset_norms),
              uint64_t(dataset.n_rows()),
              dataset.dim(),
-             dataset.stride(),
+             data_view.stride(),
              uint32_t(params.team_size),
              uint32_t(metric),
              uint32_t(params.smem_dtype)};
@@ -115,7 +115,8 @@ template <typename DatasetT>
 auto make_key(const cagra::search_params& params,
               const DatasetT& dataset,
               cuvs::distance::DistanceType metric,
-              const void* dataset_norms) -> std::enable_if_t<is_vpq_dataset_v<DatasetT>, key>
+              const void* dataset_norms)
+  -> std::enable_if_t<cuvs::neighbors::is_vpq_dataset_view_v<DatasetT>, key>
 {
   auto const data_view = dataset.data_view();
   auto const dict_view = dataset.dictionary_view();
@@ -123,12 +124,28 @@ auto make_key(const cagra::search_params& params,
              reinterpret_cast<uint64_t>(dataset_norms),
              uint64_t(dataset.n_rows()),
              dataset.dim(),
-             uint32_t(reinterpret_cast<uint64_t>(dataset.pq_code_book.data_handle()) >> 6),
+             uint32_t(reinterpret_cast<uint64_t>(dict_view.pq_code_book.data_handle()) >> 6),
              uint32_t(params.team_size),
              uint32_t(metric),
              uint32_t(params.smem_dtype)};
 }
 
+inline auto operator==(const key& a, const key& b) -> bool
+{
+  return a.data_ptr == b.data_ptr && a.norms_ptr == b.norms_ptr && a.n_rows == b.n_rows &&
+         a.dim == b.dim && a.extra_val == b.extra_val && a.team_size == b.team_size &&
+         a.metric == b.metric && a.smem_dtype == b.smem_dtype;
+}
+
+struct key_hash {
+  inline auto operator()(const key& x) const noexcept -> std::size_t
+  {
+    return size_t{x.data_ptr} + size_t{x.norms_ptr} +
+           size_t{x.n_rows} * size_t{x.dim} * size_t{x.extra_val} +
+           (size_t{x.team_size} ^ size_t{x.metric}) + size_t{x.smem_dtype};
+  }
+};
+
 template <typename DataT, typename IndexT, typename DistanceT>
 struct store {
   /** Number of descriptors to cache. */
diff --git a/cpp/tests/neighbors/ann_cagra/test_iterative_cagra_q.cu b/cpp/tests/neighbors/ann_cagra/test_iterative_cagra_q.cu
index abc99b2842..ea0cfcabc5 100644
--- a/cpp/tests/neighbors/ann_cagra/test_iterative_cagra_q.cu
+++ b/cpp/tests/neighbors/ann_cagra/test_iterative_cagra_q.cu
@@ -293,7 +293,8 @@ TEST_F(CagraQContractTest, RejectsEmptyDataset)
   auto vq_code_book = raft::make_device_matrix<half, uint32_t, raft::row_major>(res_, 1, width);
   auto pq_code_book = raft::make_device_matrix<half, uint32_t, raft::row_major>(res_, 256, 2);
   auto codes = raft::make_device_matrix<uint8_t, int64_t, raft::row_major>(res_, 0, 4 + dim / 2);
-  vpq_dataset_t empty{std::move(vq_code_book), std::move(pq_code_book), std::move(codes)};
+  vpq_dataset_t::dictionary_type dictionary{std::move(vq_code_book), std::move(pq_code_book)};
+  vpq_dataset_t empty{std::move(codes), std::move(dictionary)};
   ASSERT_EQ(empty.n_rows(), 0);
 
   EXPECT_THROW(cagra::build(res_, iterative_params(), empty.as_dataset_view()), raft::exception);
diff --git a/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md b/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md
index 67fa8291c1..6e115bec35 100644
--- a/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md
+++ b/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md
@@ -151,3 +151,17 @@ dequant_sum_delta from that delta and quantized_component_sums.
 **Returns**
 
 `void`
+
+## Types
+
+<a id="neighbors-bbq-dataset-view"></a>
+### neighbors::bbq_dataset_view
+
+BBQ doesn't fit the shared Spec-based `dataset`/`dataset_view` shape (one data slot + one
+
+optional dictionary slot): a BBQ dataset is a small bag of alternate encodings of the *same* rows, one per `bbq_code_layout`, selected at query time. So unlike padded/standard/vpq, BBQ gets its own standalone owning/view types rather than a `SpecT` plugged into `dataset`/ `dataset_view` -- they only need to satisfy `ann_dataset_view` (`n_rows()`/`dim()`) to work everywhere a dataset view is expected, plus the handful of trait specializations below.
+
+```cpp
+template <typename DataT, typename IdxT, typename Accessor>
+struct bbq_dataset_view;
+```

From 8bf275f57e655f7cf744382eeddf763906a1ef08 Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Thu, 1 Oct 2026 10:50:06 -0700
Subject: [PATCH 05/15] Remove self-returning view() from dense dataset view
 storage (#2395)

dense_row_major_dataset_view_storage inherits from the mdspan type, so it
already is the view; its view() just returned *this. Drop it and convert
at the two places that called view() on a dataset view (cagra.cuh,
cagra_search.cuh) by using data_view() directly.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 cpp/include/cuvs/neighbors/common.hpp           | 3 ---
 cpp/src/neighbors/cagra.cuh                     | 2 +-
 cpp/src/neighbors/detail/cagra/cagra_search.cuh | 2 +-
 3 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/cpp/include/cuvs/neighbors/common.hpp b/cpp/include/cuvs/neighbors/common.hpp
index 37351edb87..2bf6fb4336 100644
--- a/cpp/include/cuvs/neighbors/common.hpp
+++ b/cpp/include/cuvs/neighbors/common.hpp
@@ -318,9 +318,6 @@ struct dense_row_major_dataset_view_storage : public ViewT {
   {
     return static_cast<uint32_t>(ViewT::stride(0) > 0 ? ViewT::stride(0) : this->extent(1));
   }
-  // ViewT (mdspan) has no view() of its own -- it already *is* the view -- so this shrinks to a
-  // plain upcast instead of reaching into a wrapped field.
-  [[nodiscard]] auto view() const noexcept -> ViewT { return *this; }
 };
 
 /** Spec-side implementation shared by `padded_dataset_spec`/`standard_dataset_spec`; those two
diff --git a/cpp/src/neighbors/cagra.cuh b/cpp/src/neighbors/cagra.cuh
index 851ed83dab..6885ba631f 100644
--- a/cpp/src/neighbors/cagra.cuh
+++ b/cpp/src/neighbors/cagra.cuh
@@ -44,7 +44,7 @@ CUVS_EXPORT void index<T, IdxT, DatasetViewT>::compute_dataset_norms_(raft::reso
 
   if constexpr (nb::is_padded_dataset_view_v<DatasetViewT> ||
                 nb::is_standard_dataset_view_v<DatasetViewT>) {
-    rm_dataset = dataset_.data_view().view();
+    rm_dataset = dataset_.data_view();
   } else if constexpr (nb::is_vpq_dataset_view_v<DatasetViewT> ||
                        nb::is_bbq_dataset_view_v<DatasetViewT>) {
     skip_norms = true;
diff --git a/cpp/src/neighbors/detail/cagra/cagra_search.cuh b/cpp/src/neighbors/detail/cagra/cagra_search.cuh
index 7dd0d0989c..e389bf6508 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_search.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_search.cuh
@@ -270,7 +270,7 @@ void search_main(raft::resources const& res,
       sample_filter);
   } else if constexpr (cuvs::neighbors::is_device_standard_dataset_view_v<DatasetViewT>) {
     RAFT_EXPECTS(
-      cuvs::neighbors::matrix_row_width_matches_cagra_required(index.dataset().view()),
+      cuvs::neighbors::matrix_row_width_matches_cagra_required(index.dataset().data_view()),
       "CAGRA search requires each dataset row to have the CAGRA-aligned stride. Create a padded "
       "dataset with make_device_padded_dataset() and attach it with cagra::update_dataset().");
     run_strided_like(index.dataset());

From 277f441de9c5052656d57de4bc38077d58c63aa9 Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Thu, 1 Oct 2026 10:50:47 -0700
Subject: [PATCH 06/15] Rename dataset data_view() to as_matrix_view() (#2395)

data_view() returned the raft mdspan-derived view of a dataset's rows, while
as_dataset_view() returns the dataset_view type; the two names did not
convey that distinction. Rename data_view() to as_matrix_view() so
"matrix view" consistently means an mdspan derivative (e.g.
device_matrix_view) and "dataset view" means dataset_view. as_dataset_view()
is unchanged. Mechanical rename across dataset/dataset_view, CAGRA,
Vamana, HNSW, MG, tiered index, C API, pq.hpp docs and tests.

Verified: full rebuild clean; DATASET_C_TEST (9/9), CAGRA_C_TEST (15/15),
PREPROCESSING_TEST (226/226), NEIGHBORS_TEST (371/371) pass.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 c/src/neighbors/cagra.cpp                     |  8 +++----
 cpp/include/cuvs/neighbors/common.hpp         |  6 ++---
 .../cuvs/preprocessing/quantize/pq.hpp        |  6 ++---
 cpp/src/neighbors/cagra.cuh                   |  2 +-
 cpp/src/neighbors/detail/cagra/add_nodes.cuh  |  2 +-
 .../neighbors/detail/cagra/cagra_build.cuh    | 23 +++++++++---------
 .../neighbors/detail/cagra/cagra_merge.cuh    | 24 +++++++++----------
 .../neighbors/detail/cagra/cagra_search.cuh   | 10 ++++----
 .../detail/cagra/cagra_serialize.cuh          |  8 +++----
 .../cagra/compute_distance_standard.hpp       |  2 +-
 .../detail/cagra/compute_distance_vpq.hpp     |  2 +-
 cpp/src/neighbors/detail/cagra/factory.cuh    |  6 ++---
 .../neighbors/detail/dataset_serialize.hpp    |  2 +-
 cpp/src/neighbors/detail/hnsw.hpp             | 16 ++++++-------
 .../detail/vamana/vamana_serialize.cuh        |  6 ++---
 cpp/src/neighbors/mg/mg_cagra_inst.cu.in      | 10 ++++----
 cpp/src/neighbors/tiered_index.cu             |  4 ++--
 cpp/tests/neighbors/ann_cagra.cuh             |  4 ++--
 .../ann_cagra/test_merge_fastener.cu          |  8 +++----
 cpp/tests/neighbors/vpq_utils.cuh             |  2 +-
 .../preprocessing/product_quantization.cu     |  4 ++--
 21 files changed, 78 insertions(+), 77 deletions(-)

diff --git a/c/src/neighbors/cagra.cpp b/c/src/neighbors/cagra.cpp
index fafae48d67..90627e6441 100644
--- a/c/src/neighbors/cagra.cpp
+++ b/c/src/neighbors/cagra.cpp
@@ -179,7 +179,7 @@ static void merge_indices_for_layout(
       cuvs::neighbors::cagra::detail::merged_dataset_size<T, uint32_t, DatasetViewT>(
         *res_ptr, index_ptrs, row_filter);
     auto const dim    = static_cast<uint32_t>(index_ptrs.front()->dim());
-    auto const stride = static_cast<int64_t>(index_ptrs.front()->dataset().data_view().stride());
+    auto const stride = static_cast<int64_t>(index_ptrs.front()->dataset().as_matrix_view().stride());
 
     try {
       auto matrix = raft::make_device_matrix<T, int64_t>(*res_ptr, final_row_count, stride);
@@ -227,8 +227,8 @@ static void merge_indices_for_layout(
       auto const& input = index->dataset();
       raft::copy_matrix(matrix.data_handle() + row_offset * static_cast<std::size_t>(stride),
                         static_cast<std::size_t>(stride),
-                        input.data_view().data_handle(),
-                        static_cast<std::size_t>(input.data_view().stride()),
+                        input.as_matrix_view().data_handle(),
+                        static_cast<std::size_t>(input.as_matrix_view().stride()),
                         static_cast<std::size_t>(dim),
                         static_cast<std::size_t>(input.n_rows()),
                         stream);
@@ -1383,7 +1383,7 @@ void get_dataset_view(cuvsCagraIndex_t index, DLManagedTensor* dataset)
         RAFT_FAIL(
           "cuvsCagraIndexGetDataset does not expose quantized datasets as dense DLPack tensors");
       } else {
-        cuvs::core::to_dlpack(idx.dataset().data_view(), dataset);
+        cuvs::core::to_dlpack(idx.dataset().as_matrix_view(), dataset);
       }
     });
 }
diff --git a/cpp/include/cuvs/neighbors/common.hpp b/cpp/include/cuvs/neighbors/common.hpp
index 2bf6fb4336..5a5270f5b0 100644
--- a/cpp/include/cuvs/neighbors/common.hpp
+++ b/cpp/include/cuvs/neighbors/common.hpp
@@ -557,7 +557,7 @@ struct dataset {
   {
     return spec_type::get_dim(data_, dictionary_);
   }
-  [[nodiscard]] auto data_view() const noexcept { return spec_type::get_data_view(data_); }
+  [[nodiscard]] auto as_matrix_view() const noexcept { return spec_type::get_data_view(data_); }
   [[nodiscard]] auto dictionary_view() const noexcept
   {
     return spec_type::get_dictionary_view(dictionary_);
@@ -565,7 +565,7 @@ struct dataset {
 
   [[nodiscard]] auto as_dataset_view() const noexcept -> dataset_view<T, IdxT, SpecT>
   {
-    return dataset_view<T, IdxT, SpecT>(data_view(), dictionary_view());
+    return dataset_view<T, IdxT, SpecT>(as_matrix_view(), dictionary_view());
   }
 
   // Move the owning storage out (e.g. to reuse an already-encoded codes matrix while rebuilding
@@ -660,7 +660,7 @@ struct dataset_view {
   {
     return spec_type::get_dim(data_view_, dictionary_view_);
   }
-  [[nodiscard]] auto data_view() const noexcept -> view_type { return data_view_; }
+  [[nodiscard]] auto as_matrix_view() const noexcept -> view_type { return data_view_; }
   [[nodiscard]] auto dictionary_view() const noexcept -> dictionary_view_type
   {
     return dictionary_view_;
diff --git a/cpp/include/cuvs/preprocessing/quantize/pq.hpp b/cpp/include/cuvs/preprocessing/quantize/pq.hpp
index 2d213cc087..4cc2895c24 100644
--- a/cpp/include/cuvs/preprocessing/quantize/pq.hpp
+++ b/cpp/include/cuvs/preprocessing/quantize/pq.hpp
@@ -299,13 +299,13 @@ template <typename SrcT>
                                     SrcT const& src)
   -> cuvs::neighbors::device_vpq_dataset<half, int64_t>
 {
-  // A cuVS dataset keeps its logical width in `dim()` while `data_view()` spans the full row
+  // A cuVS dataset keeps its logical width in `dim()` while `as_matrix_view()` spans the full row
   // pitch.
   if constexpr (requires {
-                  src.data_view();
+                  src.as_matrix_view();
                   src.dim();
                 }) {
-    auto const rows    = src.data_view();
+    auto const rows    = src.as_matrix_view();
     using value_type   = typename decltype(rows)::value_type;
     using extents_type = raft::matrix_extent<int64_t>;
     return make_vpq_dataset(
diff --git a/cpp/src/neighbors/cagra.cuh b/cpp/src/neighbors/cagra.cuh
index 6885ba631f..2532ee55fe 100644
--- a/cpp/src/neighbors/cagra.cuh
+++ b/cpp/src/neighbors/cagra.cuh
@@ -44,7 +44,7 @@ CUVS_EXPORT void index<T, IdxT, DatasetViewT>::compute_dataset_norms_(raft::reso
 
   if constexpr (nb::is_padded_dataset_view_v<DatasetViewT> ||
                 nb::is_standard_dataset_view_v<DatasetViewT>) {
-    rm_dataset = dataset_.data_view();
+    rm_dataset = dataset_.as_matrix_view();
   } else if constexpr (nb::is_vpq_dataset_view_v<DatasetViewT> ||
                        nb::is_bbq_dataset_view_v<DatasetViewT>) {
     skip_norms = true;
diff --git a/cpp/src/neighbors/detail/cagra/add_nodes.cuh b/cpp/src/neighbors/detail/cagra/add_nodes.cuh
index 158338dc41..a77eae3758 100644
--- a/cpp/src/neighbors/detail/cagra/add_nodes.cuh
+++ b/cpp/src/neighbors/detail/cagra/add_nodes.cuh
@@ -363,7 +363,7 @@ void extend_core(raft::resources const& handle,
                "cuvs::neighbors::hnsw::deserialize() before calling extend().");
 
   const std::size_t initial_dataset_size = index.size();
-  const auto extended_view               = extended_dataset.data_view();
+  const auto extended_view               = extended_dataset.as_matrix_view();
   const std::size_t new_dataset_size     = static_cast<std::size_t>(extended_view.extent(0));
   const std::size_t degree               = index.graph_degree();
   const std::size_t dim                  = index.dim();
diff --git a/cpp/src/neighbors/detail/cagra/cagra_build.cuh b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
index 40a30a0bc1..545b95fb7e 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_build.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
@@ -1347,7 +1347,7 @@ auto build_ace(raft::resources const& res, const index_params& params, DatasetVi
     params.graph_degree,
     npartitions);
 
-  auto dataset_view   = dataset.data_view();
+  auto dataset_view   = dataset.as_matrix_view();
   size_t dataset_size = dataset.n_rows();
   size_t dataset_dim  = dataset.dim();
 
@@ -2312,7 +2312,7 @@ void reconstruct_vpq_queries(raft::resources const& res,
                              uint32_t batch_size,
                              raft::device_matrix_view<T, int64_t> output)
 {
-  auto const data_view     = vpq_view.data_view();
+  auto const data_view     = vpq_view.as_matrix_view();
   auto const dict_view     = vpq_view.dictionary_view();
   const uint32_t dim       = vpq_view.dim();
   const uint32_t pq_len    = vpq_view.pq_len();
@@ -2481,7 +2481,7 @@ auto iterative_build_graph(raft::resources const& res,
     vpq_dataset      = dataset;
   } else {
     auto const required_stride = cuvs::neighbors::cagra_required_row_width<T>(dataset.dim());
-    auto const data_view       = dataset.data_view();
+    auto const data_view       = dataset.as_matrix_view();
     RAFT_EXPECTS(data_view.stride() == required_stride,
                  "iterative CAGRA build requires a CAGRA-aligned device dataset "
                  "(stride %u, required %u). Pass a device_padded_dataset_view, or a "
@@ -2843,7 +2843,7 @@ auto build_from_host_matrix(raft::resources const& res,
                                                            static_cast<int64_t>(n_rows),
                                                            intermediate_degree,
                                                            graph_degree,
-                                                           dataset.data_view());
+                                                           dataset.as_matrix_view());
   }();
 
   RAFT_LOG_TRACE("Graph optimized, creating index");
@@ -2890,13 +2890,14 @@ auto build_from_device_matrix(raft::resources const& res,
     auto cagra_graph = iterative_build_graph<T, IdxT>(res, params, device_dataset);
     idx.update_graph(res, std::move(cagra_graph));
   } else {
-    auto cagra_graph = build_cagra_host_graph_from_knn_params<T, IdxT>(res,
-                                                                       params,
-                                                                       knn_build_params,
-                                                                       device_dataset.n_rows(),
-                                                                       intermediate_degree,
-                                                                       graph_degree,
-                                                                       device_dataset.data_view());
+    auto cagra_graph =
+      build_cagra_host_graph_from_knn_params<T, IdxT>(res,
+                                                      params,
+                                                      knn_build_params,
+                                                      device_dataset.n_rows(),
+                                                      intermediate_degree,
+                                                      graph_degree,
+                                                      device_dataset.as_matrix_view());
     idx.update_graph(res, raft::make_const_mdspan(cagra_graph.view()));
   }
 
diff --git a/cpp/src/neighbors/detail/cagra/cagra_merge.cuh b/cpp/src/neighbors/detail/cagra/cagra_merge.cuh
index 57d0efb435..4de0fbe79e 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_merge.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_merge.cuh
@@ -93,10 +93,10 @@ cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge_rebuild(
         "before merge.");
       if (dim == 0) {
         dim    = index->dim();
-        stride = static_cast<int64_t>(dataset.data_view().stride());
+        stride = static_cast<int64_t>(dataset.as_matrix_view().stride());
       } else {
         RAFT_EXPECTS(dim == index->dim(), "Dimension of datasets in indices must be equal.");
-        RAFT_EXPECTS(stride == static_cast<int64_t>(dataset.data_view().stride()),
+        RAFT_EXPECTS(stride == static_cast<int64_t>(dataset.as_matrix_view().stride()),
                      "Row stride of datasets in indices must be equal.");
       }
       merged_rows += static_cast<int64_t>(index->size());
@@ -118,12 +118,12 @@ cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge_rebuild(
                "merged_dataset dimension (%u) must equal the input dimension (%u)",
                unsigned(merged_dataset.dim()),
                unsigned(dim));
-  RAFT_EXPECTS(merged_dataset.data_view().stride() == stride,
+  RAFT_EXPECTS(merged_dataset.as_matrix_view().stride() == stride,
                "merged_dataset stride (%u) must equal the input stride (%ld)",
-               unsigned(merged_dataset.data_view().stride()),
+               unsigned(merged_dataset.as_matrix_view().stride()),
                long(stride));
 
-  auto output_const_view = merged_dataset.data_view();
+  auto output_const_view = merged_dataset.as_matrix_view();
   auto output_view       = raft::make_device_matrix_view<T, int64_t>(
     const_cast<T*>(output_const_view.data_handle()), final_rows, stride);
 
@@ -134,7 +134,7 @@ cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge_rebuild(
       std::size_t n_rows = 0;
       auto const& v      = index->dataset();
       if constexpr (cuvs::neighbors::is_dense_row_major_dataset_view_v<std::decay_t<decltype(v)>>) {
-        src_ptr = v.data_view().data_handle();
+        src_ptr = v.as_matrix_view().data_handle();
         n_rows  = static_cast<std::size_t>(v.n_rows());
       } else {
         RAFT_FAIL("cagra::merge: unexpected dataset type while copying rows");
@@ -302,14 +302,14 @@ auto preflight_fastener(
     }
     if (result.offsets.size() == 1) {
       result.dim    = static_cast<int64_t>(index->dim());
-      result.stride = static_cast<int64_t>(dataset.data_view().stride());
+      result.stride = static_cast<int64_t>(dataset.as_matrix_view().stride());
     } else {
       if (result.dim != static_cast<int64_t>(index->dim())) {
         return reject("all input dimensions must match");
       }
       // The merged dataset has a single row pitch, so mixed input strides cannot be consolidated
       // without re-padding each input separately.
-      if (result.stride != static_cast<int64_t>(dataset.data_view().stride())) {
+      if (result.stride != static_cast<int64_t>(dataset.as_matrix_view().stride())) {
         return reject("all input row strides must match");
       }
     }
@@ -384,8 +384,8 @@ void copy_input_datasets(
     auto const& source = indices[i]->dataset();
     raft::copy_matrix(destination + offsets[i] * destination_stride,
                       static_cast<std::size_t>(destination_stride),
-                      source.data_view().data_handle(),
-                      static_cast<std::size_t>(source.data_view().stride()),
+                      source.as_matrix_view().data_handle(),
+                      static_cast<std::size_t>(source.as_matrix_view().stride()),
                       static_cast<std::size_t>(dim),
                       static_cast<std::size_t>(source.n_rows()),
                       raft::resource::get_cuda_stream(handle));
@@ -401,7 +401,7 @@ auto merge_fastener(raft::resources const& handle,
                     fastener_preflight_result const& preflight)
   -> cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>
 {
-  auto const stride = static_cast<int64_t>(merged_dataset.data_view().stride());
+  auto const stride = static_cast<int64_t>(merged_dataset.as_matrix_view().stride());
   RAFT_EXPECTS(merged_dataset.n_rows() == preflight.rows,
                "merged_dataset rows (%ld) must equal the merged row count (%ld)",
                long(merged_dataset.n_rows()),
@@ -411,7 +411,7 @@ auto merge_fastener(raft::resources const& handle,
                unsigned(merged_dataset.dim()),
                long(preflight.dim));
 
-  auto const output_const_view = merged_dataset.data_view();
+  auto const output_const_view = merged_dataset.as_matrix_view();
   auto* destination            = const_cast<T*>(output_const_view.data_handle());
   {
     raft::common::nvtx::range<cuvs::common::nvtx::domain::cuvs> scope("cagra::merge/consolidate");
diff --git a/cpp/src/neighbors/detail/cagra/cagra_search.cuh b/cpp/src/neighbors/detail/cagra/cagra_search.cuh
index e389bf6508..ac516c176c 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_search.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_search.cuh
@@ -103,13 +103,13 @@ void search_main_core(
   std::unique_ptr<cuvs::neighbors::device_padded_dataset<DataT, int64_t>> queries_padded_own;
   if (cuvs::neighbors::matrix_row_width_matches_cagra_required(queries)) {
     auto v           = cuvs::neighbors::make_device_padded_dataset_view(res, queries);
-    queries_buf      = v.data_view().data_handle();
-    query_row_stride = v.data_view().stride();
+    queries_buf      = v.as_matrix_view().data_handle();
+    query_row_stride = v.as_matrix_view().stride();
   } else {
     queries_padded_own = cuvs::neighbors::make_device_padded_dataset(res, queries);
     auto v             = queries_padded_own->as_dataset_view();
-    queries_buf        = v.data_view().data_handle();
-    query_row_stride   = v.data_view().stride();
+    queries_buf        = v.as_matrix_view().data_handle();
+    query_row_stride   = v.as_matrix_view().stride();
   }
   const bool can_batch_n_queries = (query_row_stride == query_logical_dim);
 
@@ -270,7 +270,7 @@ void search_main(raft::resources const& res,
       sample_filter);
   } else if constexpr (cuvs::neighbors::is_device_standard_dataset_view_v<DatasetViewT>) {
     RAFT_EXPECTS(
-      cuvs::neighbors::matrix_row_width_matches_cagra_required(index.dataset().data_view()),
+      cuvs::neighbors::matrix_row_width_matches_cagra_required(index.dataset().as_matrix_view()),
       "CAGRA search requires each dataset row to have the CAGRA-aligned stride. Create a padded "
       "dataset with make_device_padded_dataset() and attach it with cagra::update_dataset().");
     run_strided_like(index.dataset());
diff --git a/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh b/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
index 6b00b67999..9f4fe27c1e 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
@@ -312,8 +312,8 @@ void write_hnswlib_rows_host(
                  "CAGRA dataset rows (%zu) do not match index size (%zu)",
                  static_cast<size_t>(dataset_view.n_rows()),
                  n_rows);
-    dataset_data      = dataset_view.data_view().data_handle();
-    dataset_stride    = dataset_view.data_view().stride();
+    dataset_data      = dataset_view.as_matrix_view().data_handle();
+    dataset_stride    = dataset_view.as_matrix_view().stride();
     dataset_is_device = is_device_cagra_hnsw_serialize_index_v<T, IdxT, CagraIndexT>;
   }
 
@@ -450,12 +450,12 @@ void write_hnswlib_rows_device(raft::resources const& res,
       output.data_handle(),
       row_size,
       graph.data_handle(),
-      dataset.data_view().data_handle(),
+      dataset.as_matrix_view().data_handle(),
       first_row,
       rows,
       graph_degree,
       dim,
-      dataset.data_view().stride());
+      dataset.as_matrix_view().stride());
     RAFT_CUDA_TRY(cudaPeekAtLastError());
     raft::resource::sync_stream(res);
 
diff --git a/cpp/src/neighbors/detail/cagra/compute_distance_standard.hpp b/cpp/src/neighbors/detail/cagra/compute_distance_standard.hpp
index 8014d3a070..8f5d975449 100644
--- a/cpp/src/neighbors/detail/cagra/compute_distance_standard.hpp
+++ b/cpp/src/neighbors/detail/cagra/compute_distance_standard.hpp
@@ -37,7 +37,7 @@ struct standard_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT>
                    cuvs::distance::DistanceType metric,
                    const DistanceT* dataset_norms = nullptr) -> host_type
   {
-    auto const data_view = dataset.data_view();
+    auto const data_view = dataset.as_matrix_view();
     return init_(params,
                  data_view.data_handle(),
                  IndexT(dataset.n_rows()),
diff --git a/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp b/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
index 45bb515f15..f220d476bf 100644
--- a/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
+++ b/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
@@ -65,7 +65,7 @@ struct vpq_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT> {
                    cuvs::distance::DistanceType metric,
                    const DistanceT* dataset_norms = nullptr) -> host_type
   {
-    auto const data_view = dataset.data_view();
+    auto const data_view = dataset.as_matrix_view();
     auto const dict_view = dataset.dictionary_view();
     return init_(params,
                  data_view.data_handle(),
diff --git a/cpp/src/neighbors/detail/cagra/factory.cuh b/cpp/src/neighbors/detail/cagra/factory.cuh
index 0fa501f3c3..f82f3d998f 100644
--- a/cpp/src/neighbors/detail/cagra/factory.cuh
+++ b/cpp/src/neighbors/detail/cagra/factory.cuh
@@ -92,7 +92,7 @@ struct key {
 };
 
 // `DatasetT` here is the non-owning dataset_view passed in by the search path, so all state comes
-// off the view's own `data_view()`/`dictionary_view()`, not owning-only members.
+// off the view's own `as_matrix_view()`/`dictionary_view()`, not owning-only members.
 template <typename DatasetT>
 auto make_key(const cagra::search_params& params,
               const DatasetT& dataset,
@@ -102,7 +102,7 @@ auto make_key(const cagra::search_params& params,
                         cuvs::neighbors::is_standard_dataset_v<DatasetT>,
                       key>
 {
-  auto const data_view = dataset.data_view();
+  auto const data_view = dataset.as_matrix_view();
   return key{reinterpret_cast<uint64_t>(data_view.data_handle()),
              reinterpret_cast<uint64_t>(dataset_norms),
              uint64_t(dataset.n_rows()),
@@ -120,7 +120,7 @@ auto make_key(const cagra::search_params& params,
               const void* dataset_norms)
   -> std::enable_if_t<cuvs::neighbors::is_vpq_dataset_view_v<DatasetT>, key>
 {
-  auto const data_view = dataset.data_view();
+  auto const data_view = dataset.as_matrix_view();
   auto const dict_view = dataset.dictionary_view();
   return key{reinterpret_cast<uint64_t>(data_view.data_handle()),
              reinterpret_cast<uint64_t>(dataset_norms),
diff --git a/cpp/src/neighbors/detail/dataset_serialize.hpp b/cpp/src/neighbors/detail/dataset_serialize.hpp
index ef4349152b..1743230cd3 100644
--- a/cpp/src/neighbors/detail/dataset_serialize.hpp
+++ b/cpp/src/neighbors/detail/dataset_serialize.hpp
@@ -87,7 +87,7 @@ void serialize(const raft::resources& res, std::ostream& os, ViewT const& datase
 {
   auto n_rows    = dataset.n_rows();
   auto dim       = dataset.dim();
-  auto data_view = dataset.data_view();
+  auto data_view = dataset.as_matrix_view();
   auto stride    = data_view.stride();
   raft::serialize_scalar(res, os, n_rows);
   raft::serialize_scalar(res, os, dim);
diff --git a/cpp/src/neighbors/detail/hnsw.hpp b/cpp/src/neighbors/detail/hnsw.hpp
index 6d32b5008b..046540539d 100644
--- a/cpp/src/neighbors/detail/hnsw.hpp
+++ b/cpp/src/neighbors/detail/hnsw.hpp
@@ -394,8 +394,8 @@ from_cagra(raft::resources const& res,
     host_dataset = raft::make_host_matrix<T, int64_t>(dataset_view.n_rows(), dataset_view.dim());
     raft::copy_matrix(host_dataset.data_handle(),
                       host_dataset.extent(1),
-                      dataset_view.data_view().data_handle(),
-                      dataset_view.data_view().stride(),
+                      dataset_view.as_matrix_view().data_handle(),
+                      dataset_view.as_matrix_view().stride(),
                       host_dataset.extent(1),
                       dataset_view.n_rows(),
                       raft::resource::get_cuda_stream(res));
@@ -1840,12 +1840,12 @@ void serialize_to_hnswlib_from_inmem(
   } else if constexpr (is_host_cagra_hnsw_export_index_v<T, CagraIndexT>) {
     RAFT_FAIL("serialize_to_hnswlib_from_inmem requires dataset for host CAGRA index");
   } else if (auto dataset_view = index_.dataset();
-             dataset_view.data_view().data_handle() != nullptr) {
+             dataset_view.as_matrix_view().data_handle() != nullptr) {
     n_rows         = dataset_view.n_rows();
     dim            = dataset_view.dim();
     device_dataset = true;
-    source_dataset = dataset_view.data_view().data_handle();
-    source_stride  = dataset_view.data_view().stride();
+    source_dataset = dataset_view.as_matrix_view().data_handle();
+    source_stride  = dataset_view.as_matrix_view().stride();
   } else {
     RAFT_FAIL("serialize_to_hnswlib_from_inmem: No dataset provided");
   }
@@ -1965,12 +1965,12 @@ from_cagra(raft::resources const& res,
   } else if constexpr (is_host_cagra_hnsw_export_index_v<T, CagraIndexT>) {
     RAFT_FAIL("hnsw::from_cagra<GPU> requires dataset for host CAGRA index");
   } else if (auto dataset_view = cagra_index.dataset();
-             dataset_view.data_view().data_handle() != nullptr) {
+             dataset_view.as_matrix_view().data_handle() != nullptr) {
     n_rows         = dataset_view.n_rows();
     dim            = dataset_view.dim();
     device_copy    = true;
-    source_dataset = dataset_view.data_view().data_handle();
-    source_stride  = dataset_view.data_view().stride();
+    source_dataset = dataset_view.as_matrix_view().data_handle();
+    source_stride  = dataset_view.as_matrix_view().stride();
   } else {
     RAFT_FAIL("hnsw::from_cagra<GPU>: No dataset provided");
   }
diff --git a/cpp/src/neighbors/detail/vamana/vamana_serialize.cuh b/cpp/src/neighbors/detail/vamana/vamana_serialize.cuh
index c77482c274..78bac296db 100644
--- a/cpp/src/neighbors/detail/vamana/vamana_serialize.cuh
+++ b/cpp/src/neighbors/detail/vamana/vamana_serialize.cuh
@@ -95,7 +95,7 @@ void serialize_dataset(raft::resources const& res,
 {
   if (dataset == nullptr) { return; }
   try {
-    serialize_dataset_view<T>(res, dataset->data_view(), dataset_base_file);
+    serialize_dataset_view<T>(res, dataset->as_matrix_view(), dataset_base_file);
   } catch (std::bad_alloc& e) {
     RAFT_LOG_INFO("Failed to serialize dataset");
   } catch (raft::logic_error& e) {
@@ -172,8 +172,8 @@ void serialize_sector_aligned(
   auto h_data = raft::make_host_matrix<T, int64_t>(npts, ndims);
   raft::copy_matrix(h_data.data_handle(),
                     ndims,
-                    dataset.data_view().data_handle(),
-                    dataset.data_view().stride(),
+                    dataset.as_matrix_view().data_handle(),
+                    dataset.as_matrix_view().stride(),
                     ndims,
                     npts,
                     raft::resource::get_cuda_stream(res));
diff --git a/cpp/src/neighbors/mg/mg_cagra_inst.cu.in b/cpp/src/neighbors/mg/mg_cagra_inst.cu.in
index 0fbe7b926f..6820480ebb 100644
--- a/cpp/src/neighbors/mg/mg_cagra_inst.cu.in
+++ b/cpp/src/neighbors/mg/mg_cagra_inst.cu.in
@@ -14,7 +14,7 @@ void distribute_padded_dataset(
   cuvs::neighbors::device_padded_dataset_view<T, int64_t> const& padded_dataset,
   RankUpdate&& rank_update)
 {
-  auto padded_mds                 = padded_dataset.data_view();
+  auto padded_mds                 = padded_dataset.as_matrix_view();
   auto stride                     = padded_mds.extent(1);
   const raft::resources& root_res = raft::resource::set_current_device_to_root_rank(res);
   auto padded_host =
@@ -61,7 +61,7 @@ void distribute_padded_dataset(
       res,                                                                                        \
       index,                                                                                      \
       static_cast<const cuvs::neighbors::index_params*>(&index_params),                           \
-      index_dataset.data_view());                                                                 \
+      index_dataset.as_matrix_view());                                                            \
     return index;                                                                                 \
   }                                                                                               \
                                                                                                   \
@@ -76,7 +76,7 @@ void distribute_padded_dataset(
       res,                                                                                        \
       index,                                                                                      \
       static_cast<const cuvs::neighbors::index_params*>(&index_params),                           \
-      index_dataset.data_view());                                                                 \
+      index_dataset.as_matrix_view());                                                            \
     return index;                                                                                 \
   }                                                                                               \
                                                                                                   \
@@ -122,7 +122,7 @@ void distribute_padded_dataset(
               cuvs::neighbors::host_padded_dataset_view<T, int64_t> new_vectors,                  \
               std::optional<raft::host_vector_view<const IdxT, int64_t>> new_indices)             \
   {                                                                                               \
-    cuvs::neighbors::snmg::detail::extend(res, index, new_vectors.data_view(), new_indices);      \
+    cuvs::neighbors::snmg::detail::extend(res, index, new_vectors.as_matrix_view(), new_indices); \
   }                                                                                               \
                                                                                                   \
   void extend(const raft::resources& res,                                                         \
@@ -130,7 +130,7 @@ void distribute_padded_dataset(
               cuvs::neighbors::host_standard_dataset_view<T, int64_t> new_vectors,                \
               std::optional<raft::host_vector_view<const IdxT, int64_t>> new_indices)             \
   {                                                                                               \
-    cuvs::neighbors::snmg::detail::extend(res, index, new_vectors.data_view(), new_indices);      \
+    cuvs::neighbors::snmg::detail::extend(res, index, new_vectors.as_matrix_view(), new_indices); \
   }                                                                                               \
                                                                                                   \
   void search(                                                                                    \
diff --git a/cpp/src/neighbors/tiered_index.cu b/cpp/src/neighbors/tiered_index.cu
index 5d75886930..5c457508a3 100644
--- a/cpp/src/neighbors/tiered_index.cu
+++ b/cpp/src/neighbors/tiered_index.cu
@@ -59,7 +59,7 @@ auto build(raft::resources const& res,
   -> tiered_index::index<cagra::device_padded_index<float, uint32_t>>
 {
   auto state = detail::build<cagra::device_padded_index<float, uint32_t>>(
-    res, params, cagra_build_for_tiered_padded, dataset.data_view());
+    res, params, cagra_build_for_tiered_padded, dataset.as_matrix_view());
   return cuvs::neighbors::tiered_index::index<cagra::device_padded_index<float, uint32_t>>(state);
 }
 
@@ -92,7 +92,7 @@ auto convert_standard_to_padded_index(
   next_state->ann_index.reset();
 
   if (idx.state->ann_index) {
-    auto padded_mds = padded_dataset.data_view();
+    auto padded_mds = padded_dataset.as_matrix_view();
     auto ann_rows   = static_cast<int64_t>(idx.state->ann_rows());
     auto ann_mds    = raft::make_device_matrix_view<const float, int64_t>(
       padded_mds.data_handle(), ann_rows, static_cast<int64_t>(padded_mds.extent(1)));
diff --git a/cpp/tests/neighbors/ann_cagra.cuh b/cpp/tests/neighbors/ann_cagra.cuh
index 736c9d5b04..951e3af13b 100644
--- a/cpp/tests/neighbors/ann_cagra.cuh
+++ b/cpp/tests/neighbors/ann_cagra.cuh
@@ -1330,7 +1330,7 @@ class AnnCagraIndexFilteredMergeTest : public ::testing::TestWithParam<AnnCagraI
         auto merged_matrix = raft::make_device_matrix<DataT, int64_t>(
           handle_,
           ps.n_rows - static_cast<int64_t>(test_cagra_sample_filter::offset),
-          static_cast<int64_t>(index0.dataset().data_view().stride()));
+          static_cast<int64_t>(index0.dataset().as_matrix_view().stride()));
         auto merged_dataset = cuvs::neighbors::device_padded_dataset<DataT, int64_t>(
           std::move(merged_matrix), static_cast<uint32_t>(ps.dim));
         auto merge_idx = cuvs::neighbors::cagra::merge(
@@ -1576,7 +1576,7 @@ class AnnCagraIndexMergeTest : public ::testing::TestWithParam<AnnCagraInputs> {
           auto const merged_rows =
             static_cast<int64_t>(index0.size()) + static_cast<int64_t>(index1.size());
           auto merged_matrix = raft::make_device_matrix<DataT, int64_t>(
-            handle_, merged_rows, static_cast<int64_t>(index0.dataset().data_view().stride()));
+            handle_, merged_rows, static_cast<int64_t>(index0.dataset().as_matrix_view().stride()));
           auto merged_dataset = cuvs::neighbors::device_padded_dataset<DataT, int64_t>(
             std::move(merged_matrix), static_cast<uint32_t>(ps.dim));
           auto merged_idx =
diff --git a/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu b/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu
index 13548e98fb..b817d540ab 100644
--- a/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu
+++ b/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu
@@ -216,11 +216,11 @@ void expect_dataset_order(raft::resources const& res,
   // honouring that stride rather than as one contiguous block.
   auto host   = raft::make_host_matrix<T, int64_t>(res, expected.extent(0), expected.extent(1));
   auto stream = raft::resource::get_cuda_stream(res);
-  int64_t const row_stride = static_cast<int64_t>(view.data_view().stride());
+  int64_t const row_stride = static_cast<int64_t>(view.as_matrix_view().stride());
   int64_t const dim        = static_cast<int64_t>(view.dim());
   for (int64_t row = 0; row < view.n_rows(); ++row) {
     raft::copy(host.data_handle() + row * dim,
-               view.data_view().data_handle() + row * row_stride,
+               view.as_matrix_view().data_handle() + row * row_stride,
                dim,
                stream);
   }
@@ -239,10 +239,10 @@ void expect_zero_padding(raft::resources const& res,
   auto view            = merged.dataset();
   int64_t const rows   = view.n_rows();
   int64_t const dim    = static_cast<int64_t>(view.dim());
-  int64_t const stride = static_cast<int64_t>(view.data_view().stride());
+  int64_t const stride = static_cast<int64_t>(view.as_matrix_view().stride());
   std::vector<T> host(static_cast<std::size_t>(rows * stride));
   auto stream = raft::resource::get_cuda_stream(res);
-  raft::copy(host.data(), view.data_view().data_handle(), host.size(), stream);
+  raft::copy(host.data(), view.as_matrix_view().data_handle(), host.size(), stream);
   raft::resource::sync_stream(res);
   for (int64_t row = 0; row < rows; ++row) {
     for (int64_t column = dim; column < stride; ++column) {
diff --git a/cpp/tests/neighbors/vpq_utils.cuh b/cpp/tests/neighbors/vpq_utils.cuh
index 7b5b38e528..5fc5d1bba0 100644
--- a/cpp/tests/neighbors/vpq_utils.cuh
+++ b/cpp/tests/neighbors/vpq_utils.cuh
@@ -51,7 +51,7 @@ void decode_vpq_dataset(raft::device_matrix_view<data_t, int64_t> decoded_datase
 {
   const auto dataset_size = decoded_dataset.extent(0);
   auto const dict_view    = vpq_dataset.dictionary_view();
-  auto const data_view    = vpq_dataset.data_view();
+  auto const data_view    = vpq_dataset.as_matrix_view();
   RAFT_EXPECTS(data_view.extent(0) == dataset_size, "Dataset sizes mismatch");
   RAFT_EXPECTS(vpq_dataset.pq_bits() == 8,
                "decode_vpq_dataset currently only supports pq_bits == 8 (got %u)",
diff --git a/cpp/tests/preprocessing/product_quantization.cu b/cpp/tests/preprocessing/product_quantization.cu
index 8ef2811fc9..bdf4680a3f 100644
--- a/cpp/tests/preprocessing/product_quantization.cu
+++ b/cpp/tests/preprocessing/product_quantization.cu
@@ -329,7 +329,7 @@ TEST(ProductQuantizationTestF, MakeVpqDatasetFromHost)
 
   EXPECT_EQ(vpq.n_rows(), n_rows);
   EXPECT_EQ(vpq.dim(), dim);
-  EXPECT_NE(vpq.data_view().data_handle(), nullptr);
+  EXPECT_NE(vpq.as_matrix_view().data_handle(), nullptr);
 }
 
 TEST(ProductQuantizationTestF, MakeVpqDatasetFromPaddedView)
@@ -362,7 +362,7 @@ TEST(ProductQuantizationTestF, MakeVpqDatasetFromPaddedView)
 
   EXPECT_EQ(vpq.n_rows(), n_rows);
   EXPECT_EQ(vpq.dim(), dim);
-  EXPECT_NE(vpq.data_view().data_handle(), nullptr);
+  EXPECT_NE(vpq.as_matrix_view().data_handle(), nullptr);
 }
 
 // Define test cases with different parameters

From 54d7fc5522fba71862e58699b35bed7938788669 Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Thu, 1 Oct 2026 11:57:39 -0700
Subject: [PATCH 07/15] Strip dataset/dataset_view down to a minimal,
 kind-agnostic core (#2395)

dataset<T,IdxT,SpecT> and dataset_view<T,IdxT,SpecT> carried VPQ-specific
state and methods (a dictionary slot holding the codebooks, and
encoded_row_length/vq_n_centers/pq_n_centers/pq_len/pq_bits/pq_dim gated
behind `requires` clauses). Padded, standard and empty datasets have no
such state, so the shared structs were leaking one kind's abstraction into
every kind, and BBQ could not use them at all (it needed standalone types).

dataset/dataset_view now hold exactly one payload (data_type / view_type,
chosen by the spec) and expose only what every dataset has: n_rows(),
dim(), as_matrix_view(), as_dataset_view() and data(). A spec has three
functions: get_data_view(), get_n_rows(), get_dim(). Anything else a kind
needs is state and methods of that kind's payload, reached through data().

Removed from dataset/dataset_view:
- dictionary_type, dictionary_view_type, dictionary_view(),
  release_dictionary(), release_data() and the std::monostate placeholders
  that padded/standard/empty used for "no dictionary"
- compressed_dataset_spec and the compressed/uncompressed constructor split
- the six VPQ helper methods

VPQ: vpq_owning_storage / vpq_view_storage are the payloads. Each is the
uint8_t codes mdarray/mdspan (so as_matrix_view().data_handle()/extent()
keep working) plus vq_code_book and pq_code_book, with the helper methods
as members. Construction is (codes, vq_code_book, pq_code_book). Callers
that used dictionary_view() now use as_matrix_view(); callers of the
helpers use data().pq_bits() etc.

BBQ: bbq_dataset_spec plugs the quantizer payloads (bbq_owning_storage /
bbq_view_storage, formerly the standalone bbq_dataset / bbq_dataset_view)
into dataset/dataset_view like any other kind. quantizers, add_quantizer,
has_layout and get_quantizer are reached through data(). This undoes the
standalone-BBQ workaround from b70daa591, which only existed because of
the dictionary slot. owning_dataset_for_view and
dataset_view_is_device_accessible now work for BBQ through the generic
templates; dataset_view_kind_of keeps a BBQ partial specialization.

Not moved yet: the VPQ and BBQ payloads/specs/traits still live in
cuvs::neighbors (common.hpp and bbq.hpp). Relocating them out of
cuvs::neighbors is the next step.

Also:
- ann_cagra_bbq.cuh, ann_nn_descent_bbq.cuh: rmm::cuda_stream_view ->
  cuda::stream_ref. These did not compile at HEAD (BBQ #2654 merged
  alongside the stream_ref migration #2521) and are the tests that
  exercise the BBQ change.
- Regenerated Fern pages for the changed headers (fern-api-reference
  hook).

Verified: full rebuild clean. DATASET_C_TEST (9/9), CAGRA_C_TEST (15/15),
PREPROCESSING_TEST (226/226), NEIGHBORS_TEST (371/371),
NEIGHBORS_ANN_CAGRA_BBQ_UINT32_TEST (105), NEIGHBORS_ANN_NN_DESCENT_TEST
(572), NEIGHBORS_ANN_CAGRA_MERGE_TEST (26) pass.
NEIGHBORS_ANN_CAGRA_FLOAT_UINT32_TEST was still running at commit time.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 c/src/neighbors/cagra.cpp                     |  14 +-
 c/src/preprocessing/quantize/pq.cpp           |   4 +-
 cpp/include/cuvs/neighbors/common.hpp         | 448 +++++++-----------
 .../cuvs/preprocessing/quantize/bbq.hpp       |  85 ++--
 .../preprocessing/bbq_cpu_quantize.hpp        |   6 +-
 cpp/src/neighbors/cagra.cuh                   |   6 +-
 .../neighbors/detail/cagra/cagra_build.cuh    |  11 +-
 .../detail/cagra/compute_distance_vpq.hpp     |  14 +-
 cpp/src/neighbors/detail/cagra/factory.cuh    |   5 +-
 .../neighbors/detail/cagra/graph_shared.cu    |  24 +-
 .../neighbors/detail/dataset_serialize.hpp    |   4 +-
 cpp/src/neighbors/detail/nn_descent.cuh       |  31 +-
 .../neighbors/detail/vamana/vamana_build.cuh  |   8 +-
 .../neighbors/scann/detail/scann_build.cuh    |   2 +-
 cpp/src/preprocessing/quantize/detail/pq.cuh  |  46 +-
 .../ann_cagra/test_iterative_cagra_q.cu       |   9 +-
 cpp/tests/neighbors/ann_cagra_bbq.cuh         |   6 +-
 cpp/tests/neighbors/ann_nn_descent_bbq.cuh    |   2 +-
 cpp/tests/neighbors/ann_scann.cuh             |   5 +-
 cpp/tests/neighbors/vpq_utils.cuh             |  15 +-
 .../pages/cpp_api/cpp-api-neighbors-common.md |  12 +-
 .../cpp-api-preprocessing-quantize-bbq.md     |  12 +-
 22 files changed, 344 insertions(+), 425 deletions(-)

diff --git a/c/src/neighbors/cagra.cpp b/c/src/neighbors/cagra.cpp
index 90627e6441..e89555c03f 100644
--- a/c/src/neighbors/cagra.cpp
+++ b/c/src/neighbors/cagra.cpp
@@ -413,8 +413,8 @@ template <typename T>
 void validate_bbq_layouts(cuvs::neighbors::device_bbq_dataset_view<T, int64_t> const& dataset)
 {
   using layout_t = cuvs::preprocessing::quantize::bbq::bbq_code_layout;
-  if (dataset.quantizers.size() == 1) {
-    auto layout = dataset.quantizers.front().layout;
+  if (dataset.data().quantizers.size() == 1) {
+    auto layout = dataset.data().quantizers.front().layout;
     RAFT_EXPECTS(layout == layout_t::packed_1b || layout == layout_t::transposed_2b ||
                    layout == layout_t::packed_4b || layout == layout_t::packed_7b ||
                    layout == layout_t::packed_8b,
@@ -422,10 +422,10 @@ void validate_bbq_layouts(cuvs::neighbors::device_bbq_dataset_view<T, int64_t> c
     return;
   }
 
-  const bool has_1b  = dataset.has_layout(layout_t::packed_1b);
-  const bool has_2bt = dataset.has_layout(layout_t::transposed_2b);
-  const bool has_4b  = dataset.has_layout(layout_t::packed_4b);
-  const bool has_4bt = dataset.has_layout(layout_t::transposed_4b);
+  const bool has_1b  = dataset.data().has_layout(layout_t::packed_1b);
+  const bool has_2bt = dataset.data().has_layout(layout_t::transposed_2b);
+  const bool has_4b  = dataset.data().has_layout(layout_t::packed_4b);
+  const bool has_4bt = dataset.data().has_layout(layout_t::transposed_4b);
   RAFT_EXPECTS((has_1b && (has_4b || has_2bt || has_4bt)) || (has_2bt && has_4bt),
                "cuvsDatasetMakeBbqView: unsupported asymmetric BBQ layout pair");
 }
@@ -469,7 +469,7 @@ auto make_bbq_dataset_view(cuvsBbqQuantizer_t* quantizers, std::size_t num_quant
       RAFT_EXPECTS(quantizer.metric == expected_metric,
                    "cuvsDatasetMakeBbqView: all quantizers must use the same metric");
     }
-    dataset->add_quantizer(quantizer);
+    dataset->data().add_quantizer(quantizer);
   }
 
   return dataset;
diff --git a/c/src/preprocessing/quantize/pq.cpp b/c/src/preprocessing/quantize/pq.cpp
index 9b6a616e0f..74f656e9a2 100644
--- a/c/src/preprocessing/quantize/pq.cpp
+++ b/c/src/preprocessing/quantize/pq.cpp
@@ -244,7 +244,7 @@ extern "C" cuvsError_t cuvsProductQuantizerGetPqCodebook(cuvsProductQuantizer_t
       if (quantizer->dtype.code == kDLFloat && quantizer->dtype.bits == 32) {
         auto pq_mdspan =
           (reinterpret_cast<cuvs::preprocessing::quantize::pq::quantizer<float>*>(quant_addr))
-            ->vpq_codebooks.dictionary_view()
+            ->vpq_codebooks.as_matrix_view()
             .pq_code_book;
         cuvs::core::to_dlpack(pq_mdspan, pq_codebook);
       } else {
@@ -267,7 +267,7 @@ extern "C" cuvsError_t cuvsProductQuantizerGetVqCodebook(cuvsProductQuantizer_t
       if (quantizer->dtype.code == kDLFloat && quantizer->dtype.bits == 32) {
         auto pq_mdspan =
           (reinterpret_cast<cuvs::preprocessing::quantize::pq::quantizer<float>*>(quant_addr))
-            ->vpq_codebooks.dictionary_view()
+            ->vpq_codebooks.as_matrix_view()
             .vq_code_book;
         cuvs::core::to_dlpack(pq_mdspan, vq_codebook);
       } else {
diff --git a/cpp/include/cuvs/neighbors/common.hpp b/cpp/include/cuvs/neighbors/common.hpp
index 5a5270f5b0..ecfce392e4 100644
--- a/cpp/include/cuvs/neighbors/common.hpp
+++ b/cpp/include/cuvs/neighbors/common.hpp
@@ -153,15 +153,16 @@ enum class MergeStrategy {
 /**
  * @brief Spec-based `dataset` / `dataset_view`.
  *
- * `dataset<T,IdxT,SpecT>` and `dataset_view<T,IdxT,SpecT>` are single generic templates with zero
- * per-kind dispatch inside them: every member is a one-line forward to `spec_type::get_*(...)`,
- * and all kind-specific logic lives in the per-kind Spec structs below (`empty_dataset_spec`,
- * `padded_dataset_spec`, `standard_dataset_spec`, `vpq_dataset_spec`), which `dataset`/
- * `dataset_view` never name or branch on. `dataset` and `dataset_view` are deliberately two
- * independent, non-inheriting types (no shared_ptr, no "sometimes owning" object): `dataset` holds
- * owning storage (mdarray-shaped), `dataset_view` holds the corresponding view storage
- * (mdspan-shaped). The same `get_n_rows`/`get_dim` spec functions serve both, since
- * `raft::mdarray`/`raft::mdspan` both expose `.extent(r)`.
+ * `dataset<T,IdxT,SpecT>` and `dataset_view<T,IdxT,SpecT>` are single generic templates that know
+ * nothing about any particular kind of dataset. They hold exactly one payload (`data_type` /
+ * `view_type`, chosen by the spec) and expose only what every dataset has: `n_rows()`, `dim()`,
+ * `as_matrix_view()`, `as_dataset_view()` and `data()`. Each is a one-line forward to one of the
+ * three spec functions `get_data_view()`, `get_n_rows()` and `get_dim()`. Anything else a kind
+ * needs (e.g. VPQ codebooks, BBQ quantizers) is state and methods of that kind's payload type,
+ * reached through `data()`; `dataset`/`dataset_view` never name or branch on it. `dataset` and
+ * `dataset_view` are deliberately two independent, non-inheriting types (no shared_ptr, no
+ * "sometimes owning" object): `dataset` holds the owning payload, `dataset_view` the
+ * corresponding non-owning payload.
  */
 
 template <typename T, typename IdxT, typename SpecT>
@@ -170,18 +171,6 @@ struct dataset;
 template <typename T, typename IdxT, typename SpecT>
 struct dataset_view;
 
-/**
- * A spec defines a dictionary iff it needs a second storage slot to interpret the data (e.g. PQ
- * codebooks). Non-compressed specs declare `dictionary_type = std::monostate` -- the same
- * vocabulary type for "no dictionary," not just an omitted member -- so `dataset`/`dataset_view`
- * never need to branch on whether the slot exists; they just always have one, sometimes empty.
- */
-template <typename SpecT>
-concept compressed_dataset_spec = requires {
-  typename SpecT::dictionary_type;
-  typename SpecT::dictionary_view_type;
-} && !std::is_same_v<typename SpecT::dictionary_type, std::monostate>;
-
 namespace detail {
 
 // Default owning/view accessors for public dataset aliases.
@@ -328,38 +317,134 @@ template <typename ContainerPolicy>
 struct dense_dataset_spec_impl {
   template <typename T, typename IdxT>
   struct apply {
-    using value_type           = std::remove_cv_t<T>;
-    using index_type           = std::remove_cv_t<IdxT>;
-    using MatrixT              = dense_owning_matrix<T, IdxT, ContainerPolicy>;
-    using ViewT                = dense_view_matrix<T, IdxT, ContainerPolicy>;
-    using data_type            = dense_row_major_dataset_owning_storage<MatrixT, ViewT, T, IdxT>;
-    using view_type            = dense_row_major_dataset_view_storage<ViewT, T, IdxT>;
-    using dictionary_type      = std::monostate;
-    using dictionary_view_type = std::monostate;
+    using value_type = std::remove_cv_t<T>;
+    using index_type = std::remove_cv_t<IdxT>;
+    using MatrixT    = dense_owning_matrix<T, IdxT, ContainerPolicy>;
+    using ViewT      = dense_view_matrix<T, IdxT, ContainerPolicy>;
+    using data_type  = dense_row_major_dataset_owning_storage<MatrixT, ViewT, T, IdxT>;
+    using view_type  = dense_row_major_dataset_view_storage<ViewT, T, IdxT>;
 
     [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
     {
       return view_type(data.view(), data.dim());
     }
-    template <typename AnyDatasetOrView>
-    [[nodiscard]] static auto get_n_rows(AnyDatasetOrView const& data) noexcept -> index_type
+    template <typename AnyStorage>
+    [[nodiscard]] static auto get_n_rows(AnyStorage const& data) noexcept -> index_type
     {
       return data.n_rows();
     }
-    template <typename AnyDatasetOrView>
-    [[nodiscard]] static auto get_dim(AnyDatasetOrView const& data, dictionary_type const&) noexcept
-      -> uint32_t
+    template <typename AnyStorage>
+    [[nodiscard]] static auto get_dim(AnyStorage const& data) noexcept -> uint32_t
     {
       return data.dim();
     }
-    [[nodiscard]] static auto get_dictionary_view(dictionary_type const&) noexcept
-      -> dictionary_view_type
-    {
-      return {};
-    }
   };
 };
 
+// -----------------------------------------------------------------------------
+// vpq payloads: everything VPQ-specific lives here, not in dataset/dataset_view.
+// -----------------------------------------------------------------------------
+
+/** Read-only helpers derived from the codebook shapes; shared by the owning and view payloads.
+ * `Derived` provides `vq_code_book`, `pq_code_book` and the codes' `extent(r)`. */
+template <typename Derived>
+struct vpq_codebook_helpers {
+  /** Logical dimension: it comes from the VQ codebook, not from the encoded rows (row padding
+   * makes the encoded-row width ambiguous as a dimension). */
+  [[nodiscard]] auto dim() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().vq_code_book.extent(1));
+  }
+  [[nodiscard]] auto vq_n_centers() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().vq_code_book.extent(0));
+  }
+  [[nodiscard]] auto pq_n_centers() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().pq_code_book.extent(0));
+  }
+  [[nodiscard]] auto pq_len() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().pq_code_book.extent(1));
+  }
+  [[nodiscard]] auto pq_bits() const noexcept -> uint32_t
+  {
+    auto pq_width = pq_n_centers();
+#ifdef __cpp_lib_bitops
+    return std::countr_zero(pq_width);
+#else
+    uint32_t bits = 0;
+    while (pq_width > 1) {
+      bits++;
+      pq_width >>= 1;
+    }
+    return bits;
+#endif
+  }
+  [[nodiscard]] auto pq_dim() const noexcept -> uint32_t
+  {
+    return raft::div_rounding_up_unsafe(dim(), pq_len());
+  }
+  [[nodiscard]] auto encoded_row_length() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().extent(1));
+  }
+
+ private:
+  [[nodiscard]] auto self() const noexcept -> Derived const&
+  {
+    return static_cast<Derived const&>(*this);
+  }
+};
+
+/** Owning VPQ payload: the encoded rows (it *is* the `uint8_t` codes mdarray) plus the VQ and PQ
+ * codebooks. `Accessor` drives both codebook and code residency. */
+template <typename MathT, typename IdxT, typename Accessor>
+struct vpq_owning_storage : public vpq_data_matrix<IdxT, Accessor>,
+                            public vpq_codebook_helpers<vpq_owning_storage<MathT, IdxT, Accessor>> {
+  using codes_type   = vpq_data_matrix<IdxT, Accessor>;
+  using vq_book_type = vpq_vq_book_matrix<MathT, IdxT, Accessor>;
+  using pq_book_type = vpq_vq_book_matrix<MathT, IdxT, Accessor>;
+
+  vq_book_type vq_code_book;
+  pq_book_type pq_code_book;
+
+  vpq_owning_storage(codes_type&& codes, vq_book_type&& vq_codes, pq_book_type&& pq_codes) noexcept
+    : codes_type{std::move(codes)},
+      vq_code_book{std::move(vq_codes)},
+      pq_code_book{std::move(pq_codes)}
+  {
+  }
+};
+
+/** Non-owning VPQ payload: a view of the encoded rows plus views of the VQ and PQ codebooks. */
+template <typename MathT, typename IdxT, typename Accessor>
+struct vpq_view_storage : public raft::mdspan<const uint8_t,
+                                              raft::matrix_extent<IdxT>,
+                                              raft::row_major,
+                                              dataset_view_accessor_for_owning<uint8_t, Accessor>>,
+                          public vpq_codebook_helpers<vpq_view_storage<MathT, IdxT, Accessor>> {
+  using codes_view_type = raft::mdspan<const uint8_t,
+                                       raft::matrix_extent<IdxT>,
+                                       raft::row_major,
+                                       dataset_view_accessor_for_owning<uint8_t, Accessor>>;
+  using vq_book_view_type =
+    typename vpq_owning_storage<MathT, IdxT, Accessor>::vq_book_type::const_view_type;
+  using pq_book_view_type =
+    typename vpq_owning_storage<MathT, IdxT, Accessor>::pq_book_type::const_view_type;
+
+  vq_book_view_type vq_code_book;
+  pq_book_view_type pq_code_book;
+
+  vpq_view_storage() noexcept = default;
+  vpq_view_storage(codes_view_type codes,
+                   vq_book_view_type vq_codes,
+                   pq_book_view_type pq_codes) noexcept
+    : codes_view_type(codes), vq_code_book(vq_codes), pq_code_book(pq_codes)
+  {
+  }
+};
+
 }  // namespace detail
 
 // -----------------------------------------------------------------------------
@@ -372,12 +457,10 @@ struct empty_dataset_spec {
 
   template <typename T, typename IdxT>
   struct apply {
-    using value_type           = std::remove_cv_t<T>;
-    using index_type           = std::remove_cv_t<IdxT>;
-    using data_type            = detail::empty_dataset_storage<IdxT>;
-    using view_type            = detail::empty_dataset_storage<IdxT>;
-    using dictionary_type      = std::monostate;
-    using dictionary_view_type = std::monostate;
+    using value_type = std::remove_cv_t<T>;
+    using index_type = std::remove_cv_t<IdxT>;
+    using data_type  = detail::empty_dataset_storage<IdxT>;
+    using view_type  = detail::empty_dataset_storage<IdxT>;
 
     [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
     {
@@ -387,16 +470,10 @@ struct empty_dataset_spec {
     {
       return static_cast<index_type>(data.n_rows());
     }
-    [[nodiscard]] static auto get_dim(data_type const& data, dictionary_type const&) noexcept
-      -> uint32_t
+    [[nodiscard]] static auto get_dim(data_type const& data) noexcept -> uint32_t
     {
       return data.dim();
     }
-    [[nodiscard]] static auto get_dictionary_view(dictionary_type const&) noexcept
-      -> dictionary_view_type
-    {
-      return {};
-    }
   };
 };
 
@@ -415,9 +492,8 @@ struct standard_dataset_spec {
 };
 
 /** `Accessor` drives both codebook and code residency, mirroring today's
- * single-`Accessor`-per-VPQ-dataset design (`vpq_vq_book_matrix`/`vpq_data_matrix` are both keyed
- * off one `Accessor`). Data = encoded rows (uint8_t codes); dictionary = {vq_code_book,
- * pq_code_book}. Inlined directly (unlike padded/standard) since no second tag shares this body. */
+ * single-`Accessor`-per-VPQ-dataset design. The payload (`detail::vpq_owning_storage` /
+ * `detail::vpq_view_storage`) holds the encoded rows and the VQ/PQ codebooks. */
 template <typename MathT, typename Accessor>
 struct vpq_dataset_spec {
   using accessor_type = Accessor;
@@ -428,94 +504,22 @@ struct vpq_dataset_spec {
     using index_type = std::remove_cv_t<IdxT>;
     using math_type  = MathT;
 
-    using data_type = detail::vpq_data_matrix<IdxT, Accessor>;
-    using view_type = raft::mdspan<const uint8_t,
-                                   raft::matrix_extent<IdxT>,
-                                   raft::row_major,
-                                   detail::dataset_view_accessor_for_owning<uint8_t, Accessor>>;
-
-    using vq_book_type = detail::vpq_vq_book_matrix<MathT, IdxT, Accessor>;
-    using pq_book_type = detail::vpq_vq_book_matrix<MathT, IdxT, Accessor>;
-
-    struct dictionary_type {
-      vq_book_type vq_code_book;
-      pq_book_type pq_code_book;
-    };
-    struct dictionary_view_type {
-      typename vq_book_type::const_view_type vq_code_book;
-      typename pq_book_type::const_view_type pq_code_book;
-
-      [[nodiscard]] auto dim() const noexcept -> uint32_t
-      {
-        return static_cast<uint32_t>(vq_code_book.extent(1));
-      }
-      [[nodiscard]] auto vq_n_centers() const noexcept -> uint32_t
-      {
-        return static_cast<uint32_t>(vq_code_book.extent(0));
-      }
-      [[nodiscard]] auto pq_n_centers() const noexcept -> uint32_t
-      {
-        return static_cast<uint32_t>(pq_code_book.extent(0));
-      }
-      [[nodiscard]] auto pq_len() const noexcept -> uint32_t
-      {
-        return static_cast<uint32_t>(pq_code_book.extent(1));
-      }
-      [[nodiscard]] auto pq_bits() const noexcept -> uint32_t
-      {
-        auto pq_width = pq_n_centers();
-#ifdef __cpp_lib_bitops
-        return std::countr_zero(pq_width);
-#else
-        uint32_t bits = 0;
-        while (pq_width > 1) {
-          bits++;
-          pq_width >>= 1;
-        }
-        return bits;
-#endif
-      }
-      [[nodiscard]] auto pq_dim() const noexcept -> uint32_t
-      {
-        return raft::div_rounding_up_unsafe(dim(), pq_len());
-      }
-    };
+    using data_type = detail::vpq_owning_storage<MathT, IdxT, Accessor>;
+    using view_type = detail::vpq_view_storage<MathT, IdxT, Accessor>;
 
     [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
     {
-      return data.view();
+      return view_type(data.view(), data.vq_code_book.view(), data.pq_code_book.view());
     }
-    template <typename AnyExtentShaped>
-    [[nodiscard]] static auto get_n_rows(AnyExtentShaped const& data) noexcept -> index_type
+    template <typename AnyStorage>
+    [[nodiscard]] static auto get_n_rows(AnyStorage const& data) noexcept -> index_type
     {
       return static_cast<index_type>(data.extent(0));
     }
-    /* get_dim differs from a plain dense dataset: the dimension comes from the VQ codebook, not
-    the encoded rows (row padding makes the encoded-row width ambiguous as a dimension). */
-    template <typename AnyData>
-    [[nodiscard]] static auto get_dim(AnyData const&, dictionary_type const& dict) noexcept
-      -> uint32_t
-    {
-      return static_cast<uint32_t>(dict.vq_code_book.extent(1));
-    }
-    template <typename AnyData>
-    [[nodiscard]] static auto get_dim(AnyData const&, dictionary_view_type const& dict) noexcept
-      -> uint32_t
-    {
-      return dict.dim();
-    }
-    [[nodiscard]] static auto get_dictionary_view(dictionary_type const& dict) noexcept
-      -> dictionary_view_type
-    {
-      return {dict.vq_code_book.view(), dict.pq_code_book.view()};
-    }
-    [[nodiscard]] static auto get_encoded_row_length(data_type const& data) noexcept -> uint32_t
+    template <typename AnyStorage>
+    [[nodiscard]] static auto get_dim(AnyStorage const& data) noexcept -> uint32_t
     {
-      return static_cast<uint32_t>(data.extent(1));
-    }
-    [[nodiscard]] static auto get_encoded_row_length(view_type const& data) noexcept -> uint32_t
-    {
-      return static_cast<uint32_t>(data.extent(1));
+      return data.dim();
     }
   };
 };
@@ -524,131 +528,68 @@ struct vpq_dataset_spec {
 // dataset / dataset_view
 // -----------------------------------------------------------------------------
 
-/** Owning dataset: value-held storage (no shared_ptr -- exclusive ownership). Every member is a
- * one-line forward to `spec_type::get_*`; all per-kind logic lives in `SpecT`, never inside this
- * struct. */
+/** Owning dataset: value-held payload (no shared_ptr -- exclusive ownership). Every member is a
+ * one-line forward to `spec_type::get_*` or to the payload; all per-kind state and logic lives in
+ * the spec's `data_type`, never inside this struct. */
 template <typename T, typename IdxT, typename SpecT>
 struct dataset {
-  using spec_type       = typename SpecT::template apply<T, IdxT>;
-  using value_type      = typename spec_type::value_type;
-  using index_type      = typename spec_type::index_type;
-  using data_type       = typename spec_type::data_type;
-  using dictionary_type = typename spec_type::dictionary_type;
-
-  // Non-compressed: forward constructor args straight to data_type's own constructor (e.g.
-  // (MatrixT&&, uint32_t logical_dim) for dense, (uint32_t dim) for empty) -- preserves today's
-  // construction call sites unchanged.
+  using spec_type  = typename SpecT::template apply<T, IdxT>;
+  using value_type = typename spec_type::value_type;
+  using index_type = typename spec_type::index_type;
+  using data_type  = typename spec_type::data_type;
+
+  // Forward constructor args straight to data_type's own constructor (e.g. (MatrixT&&, uint32_t
+  // logical_dim) for dense, (uint32_t dim) for empty, (codes&&, vq&&, pq&&) for VPQ).
   template <typename... Args>
   explicit dataset(Args&&... args)
-    requires(!compressed_dataset_spec<spec_type> && std::is_constructible_v<data_type, Args...>)
-    : data_(std::forward<Args>(args)...), dictionary_{}
-  {
-  }
-
-  // Compressed: data (codes) and dictionary (codebooks) constructed independently.
-  dataset(data_type&& data, dictionary_type&& dictionary)
-    requires(compressed_dataset_spec<spec_type>)
-    : data_(std::move(data)), dictionary_(std::move(dictionary))
+    requires(std::is_constructible_v<data_type, Args...>)
+    : data_(std::forward<Args>(args)...)
   {
   }
 
   [[nodiscard]] auto n_rows() const noexcept -> index_type { return spec_type::get_n_rows(data_); }
-  [[nodiscard]] auto dim() const noexcept -> uint32_t
-  {
-    return spec_type::get_dim(data_, dictionary_);
-  }
+  [[nodiscard]] auto dim() const noexcept -> uint32_t { return spec_type::get_dim(data_); }
+  /** The spec-defined non-owning view of the payload (for dense and VPQ it is an mdspan
+   * derivative). */
   [[nodiscard]] auto as_matrix_view() const noexcept { return spec_type::get_data_view(data_); }
-  [[nodiscard]] auto dictionary_view() const noexcept
-  {
-    return spec_type::get_dictionary_view(dictionary_);
-  }
-
   [[nodiscard]] auto as_dataset_view() const noexcept -> dataset_view<T, IdxT, SpecT>
   {
-    return dataset_view<T, IdxT, SpecT>(as_matrix_view(), dictionary_view());
+    return dataset_view<T, IdxT, SpecT>(as_matrix_view());
   }
 
-  // Move the owning storage out (e.g. to reuse an already-encoded codes matrix while rebuilding
-  // only the dictionary at a different math_type, as in VPQ's f32->f16 conversion path).
-  [[nodiscard]] auto release_data() noexcept -> data_type&& { return std::move(data_); }
-  [[nodiscard]] auto release_dictionary() noexcept -> dictionary_type&&
-  {
-    return std::move(dictionary_);
-  }
-
-  // Dictionary-derived helpers (VPQ: encoded_row_length/vq_n_centers/pq_bits/pq_dim/pq_len/
-  // pq_n_centers) forward through dictionary_view() when the dictionary provides them; SFINAE'd
-  // away for kinds without a dictionary, matching today's VPQ-only surface without dataset<>
-  // itself branching on which kind it is.
-  [[nodiscard]] auto encoded_row_length() const noexcept
-    requires requires(data_type const& d) { spec_type::get_encoded_row_length(d); }
-  {
-    return spec_type::get_encoded_row_length(data_);
-  }
-  [[nodiscard]] auto vq_n_centers() const noexcept
-    requires requires(decltype(dictionary_view()) const& d) { d.vq_n_centers(); }
-  {
-    return dictionary_view().vq_n_centers();
-  }
-  [[nodiscard]] auto pq_n_centers() const noexcept
-    requires requires(decltype(dictionary_view()) const& d) { d.pq_n_centers(); }
-  {
-    return dictionary_view().pq_n_centers();
-  }
-  [[nodiscard]] auto pq_len() const noexcept
-    requires requires(decltype(dictionary_view()) const& d) { d.pq_len(); }
-  {
-    return dictionary_view().pq_len();
-  }
-  [[nodiscard]] auto pq_bits() const noexcept
-    requires requires(decltype(dictionary_view()) const& d) { d.pq_bits(); }
-  {
-    return dictionary_view().pq_bits();
-  }
-  [[nodiscard]] auto pq_dim() const noexcept
-    requires requires(decltype(dictionary_view()) const& d) { d.pq_dim(); }
-  {
-    return dictionary_view().pq_dim();
-  }
+  /** The owning payload; kind-specific state and methods are reached through it. */
+  [[nodiscard]] auto data() const noexcept -> data_type const& { return data_; }
+  [[nodiscard]] auto data() noexcept -> data_type& { return data_; }
 
  private:
   data_type data_;
-  [[no_unique_address]] dictionary_type dictionary_;
 };
 
-/** Non-owning dataset view: holds only view-shaped storage (mdspan, not mdarray). Deliberately not
- * derived from `dataset` -- a view type holds "all view state" with no inheritance and no shared
- * ownership tying it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec functions as
- * `dataset`, fed view-shaped arguments instead of owning ones. */
+/** Non-owning dataset view: holds only the view-shaped payload. Deliberately not derived from
+ * `dataset` -- a view type holds "all view state" with no inheritance and no shared ownership tying
+ * it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec functions as `dataset`, fed
+ * the view payload instead of the owning one. */
 template <typename T, typename IdxT, typename SpecT>
 struct dataset_view {
-  using spec_type            = typename SpecT::template apply<T, IdxT>;
-  using value_type           = typename spec_type::value_type;
-  using index_type           = typename spec_type::index_type;
-  using view_type            = typename spec_type::view_type;
-  using dictionary_view_type = typename spec_type::dictionary_view_type;
+  using spec_type  = typename SpecT::template apply<T, IdxT>;
+  using value_type = typename spec_type::value_type;
+  using index_type = typename spec_type::index_type;
+  using view_type  = typename spec_type::view_type;
 
   dataset_view() noexcept = default;
 
-  // Already-constructed (view_type, dictionary_view_type) pair -- the shape `as_dataset_view()`
-  // always constructs with, for every kind (dictionary_view_type is std::monostate and
-  // defaults away when there's no dictionary). Not a template, so it's preferred over the
-  // forwarding constructor below whenever both could apply.
-  dataset_view(view_type data_view, dictionary_view_type dictionary_view = {}) noexcept
-    : data_view_{data_view}, dictionary_view_{dictionary_view}
-  {
-  }
+  // Already-constructed view payload -- the shape `as_dataset_view()` always constructs with, for
+  // every kind. Not a template, so it's preferred over the forwarding constructor below whenever
+  // both could apply.
+  explicit dataset_view(view_type data_view) noexcept : data_view_{data_view} {}
 
   // Forward raw constructor args straight to view_type's own constructor (e.g. (ViewT, uint32_t
   // logical_dim) for dense, (uint32_t dim) for empty) -- preserves today's direct-construction
-  // call sites (e.g. `device_padded_dataset_view<T,IdxT>(raw_mdspan, dim)`) unchanged. `view_type`
-  // is never itself constructible from `(view_type, dictionary_view_type)` (its own constructors
-  // only take mdspan-shaped args), so this and the plain constructor above never both match the
-  // same call -- no ambiguity.
+  // call sites (e.g. `device_padded_dataset_view<T,IdxT>(raw_mdspan, dim)`) unchanged.
   template <typename... Args>
   explicit dataset_view(Args&&... args)
     requires(std::is_constructible_v<view_type, Args...>)
-    : data_view_(std::forward<Args>(args)...), dictionary_view_{}
+    : data_view_(std::forward<Args>(args)...)
   {
   }
 
@@ -656,52 +597,15 @@ struct dataset_view {
   {
     return spec_type::get_n_rows(data_view_);
   }
-  [[nodiscard]] auto dim() const noexcept -> uint32_t
-  {
-    return spec_type::get_dim(data_view_, dictionary_view_);
-  }
+  [[nodiscard]] auto dim() const noexcept -> uint32_t { return spec_type::get_dim(data_view_); }
   [[nodiscard]] auto as_matrix_view() const noexcept -> view_type { return data_view_; }
-  [[nodiscard]] auto dictionary_view() const noexcept -> dictionary_view_type
-  {
-    return dictionary_view_;
-  }
 
-  // See dataset<>'s equivalent block: VPQ-only helpers, SFINAE'd away for kinds without a
-  // dictionary.
-  [[nodiscard]] auto encoded_row_length() const noexcept
-    requires requires(view_type const& d) { spec_type::get_encoded_row_length(d); }
-  {
-    return spec_type::get_encoded_row_length(data_view_);
-  }
-  [[nodiscard]] auto vq_n_centers() const noexcept
-    requires requires(dictionary_view_type const& d) { d.vq_n_centers(); }
-  {
-    return dictionary_view_.vq_n_centers();
-  }
-  [[nodiscard]] auto pq_n_centers() const noexcept
-    requires requires(dictionary_view_type const& d) { d.pq_n_centers(); }
-  {
-    return dictionary_view_.pq_n_centers();
-  }
-  [[nodiscard]] auto pq_len() const noexcept
-    requires requires(dictionary_view_type const& d) { d.pq_len(); }
-  {
-    return dictionary_view_.pq_len();
-  }
-  [[nodiscard]] auto pq_bits() const noexcept
-    requires requires(dictionary_view_type const& d) { d.pq_bits(); }
-  {
-    return dictionary_view_.pq_bits();
-  }
-  [[nodiscard]] auto pq_dim() const noexcept
-    requires requires(dictionary_view_type const& d) { d.pq_dim(); }
-  {
-    return dictionary_view_.pq_dim();
-  }
+  /** The view payload; kind-specific state and methods are reached through it. */
+  [[nodiscard]] auto data() const noexcept -> view_type const& { return data_view_; }
+  [[nodiscard]] auto data() noexcept -> view_type& { return data_view_; }
 
  private:
   view_type data_view_{};
-  [[no_unique_address]] dictionary_view_type dictionary_view_{};
 };
 
 /**
diff --git a/cpp/include/cuvs/preprocessing/quantize/bbq.hpp b/cpp/include/cuvs/preprocessing/quantize/bbq.hpp
index e93860f9f7..332994a5f3 100644
--- a/cpp/include/cuvs/preprocessing/quantize/bbq.hpp
+++ b/cpp/include/cuvs/preprocessing/quantize/bbq.hpp
@@ -244,33 +244,26 @@ void resolve_dequant_factors(
 
 namespace neighbors {
 
+namespace detail {
+
 /**
- * BBQ doesn't fit the shared Spec-based `dataset`/`dataset_view` shape (one data slot + one
- * optional dictionary slot): a BBQ dataset is a small bag of alternate encodings of the *same*
- * rows, one per `bbq_code_layout`, selected at query time. So unlike padded/standard/vpq, BBQ
- * gets its own standalone owning/view types rather than a `SpecT` plugged into `dataset`/
- * `dataset_view` -- they only need to satisfy `ann_dataset_view` (`n_rows()`/`dim()`) to work
- * everywhere a dataset view is expected, plus the handful of trait specializations below.
+ * BBQ payloads: a BBQ dataset is a small bag of alternate encodings of the *same* rows, one per
+ * `bbq_code_layout`, selected at query time. The quantizers and the methods that manage them live
+ * here, in the BBQ payload, not in `dataset`/`dataset_view`; they are reached through `data()`.
  */
-template <typename DataT, typename IdxT, typename Accessor>
-struct bbq_dataset_view;
+template <typename DataT, typename IdxT>
+struct bbq_view_storage;
 
-template <typename DataT, typename IdxT, typename Accessor>
-struct bbq_dataset {
+template <typename DataT, typename IdxT>
+struct bbq_owning_storage {
   using value_type          = DataT;
   using owning_storage_type = cuvs::preprocessing::quantize::bbq::quantizer<DataT, IdxT>;
   std::vector<owning_storage_type> quantizers;
 
-  explicit bbq_dataset(owning_storage_type&& quantizer) noexcept
+  explicit bbq_owning_storage(owning_storage_type&& quantizer) noexcept
   {
     add_quantizer(std::move(quantizer));
   }
-  [[nodiscard]] auto as_dataset_view() const noexcept
-    -> bbq_dataset_view<DataT, IdxT, detail::dataset_view_accessor_for_owning<DataT, Accessor>>
-  {
-    return bbq_dataset_view<DataT, IdxT, detail::dataset_view_accessor_for_owning<DataT, Accessor>>{
-      quantizers};
-  }
   [[nodiscard]] constexpr auto n_rows() const noexcept -> IdxT
   {
     return quantizers.size() > 0 ? quantizers[0].n_rows() : 0;
@@ -294,16 +287,16 @@ struct bbq_dataset {
   }
 };
 
-template <typename DataT, typename IdxT, typename Accessor>
-struct bbq_dataset_view {
+template <typename DataT, typename IdxT>
+struct bbq_view_storage {
   using value_type          = DataT;
   using owning_storage_type = cuvs::preprocessing::quantize::bbq::quantizer<DataT, IdxT>;
   using view_storage_type   = cuvs::preprocessing::quantize::bbq::quantizer_view<DataT, IdxT>;
   std::vector<view_storage_type> quantizers;
 
-  bbq_dataset_view() noexcept = default;
+  bbq_view_storage() noexcept = default;
 
-  bbq_dataset_view(const std::vector<owning_storage_type>& quantizers) noexcept
+  bbq_view_storage(const std::vector<owning_storage_type>& quantizers) noexcept
   {
     for (const auto& quantizer : quantizers) {
       add_quantizer(quantizer);
@@ -344,35 +337,61 @@ struct bbq_dataset_view {
   }
 };
 
-template <typename DataT, typename IdxT>
-using device_bbq_dataset = bbq_dataset<DataT, IdxT, detail::device_owning_accessor<DataT>>;
+}  // namespace detail
+
+/** BBQ is just another dataset type: it plugs its payloads into the shared `dataset`/
+ * `dataset_view` through a spec, like padded/standard/vpq do. */
+template <typename Accessor>
+struct bbq_dataset_spec {
+  using accessor_type = Accessor;
+
+  template <typename T, typename IdxT>
+  struct apply {
+    using value_type = std::remove_cv_t<T>;
+    using index_type = std::remove_cv_t<IdxT>;
+
+    using data_type = detail::bbq_owning_storage<T, IdxT>;
+    using view_type = detail::bbq_view_storage<T, IdxT>;
+
+    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
+    {
+      return view_type{data.quantizers};
+    }
+    template <typename AnyStorage>
+    [[nodiscard]] static auto get_n_rows(AnyStorage const& data) noexcept -> index_type
+    {
+      return data.n_rows();
+    }
+    template <typename AnyStorage>
+    [[nodiscard]] static auto get_dim(AnyStorage const& data) noexcept -> uint32_t
+    {
+      return data.dim();
+    }
+  };
+};
 
 template <typename DataT, typename IdxT>
-using device_bbq_dataset_view = bbq_dataset_view<DataT, IdxT, detail::device_view_accessor<DataT>>;
+using device_bbq_dataset =
+  dataset<DataT, IdxT, bbq_dataset_spec<detail::device_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
-struct owning_dataset_for_view<device_bbq_dataset_view<DataT, IdxT>> {
-  using type = device_bbq_dataset<DataT, IdxT>;
-};
+using device_bbq_dataset_view =
+  dataset_view<DataT, IdxT, bbq_dataset_spec<detail::device_owning_accessor<DataT>>>;
 
 template <typename DatasetT>
 struct is_bbq_dataset : std::false_type {};
 
 template <typename DataT, typename IdxT, typename Accessor>
-struct is_bbq_dataset<bbq_dataset<DataT, IdxT, Accessor>> : std::true_type {};
+struct is_bbq_dataset<dataset<DataT, IdxT, bbq_dataset_spec<Accessor>>> : std::true_type {};
 
 template <typename DatasetT>
 inline constexpr bool is_bbq_dataset_v = is_bbq_dataset<DatasetT>::value;
 
 template <typename DataT, typename IdxT, typename Accessor>
-struct dataset_view_kind_of<bbq_dataset_view<DataT, IdxT, Accessor>> {
+struct dataset_view_kind_of<dataset_view<DataT, IdxT, bbq_dataset_spec<Accessor>>> {
   static constexpr dataset_view_kind value = dataset_view_kind::bbq;
 };
 
-template <typename DataT, typename IdxT, typename Accessor>
-struct dataset_view_is_device_accessible<bbq_dataset_view<DataT, IdxT, Accessor>>
-  : std::bool_constant<Accessor::is_device_accessible> {};
-
 template <typename V>
 inline constexpr bool is_device_bbq_dataset_view_v =
   dataset_view_kind_v<V> == dataset_view_kind::bbq && dataset_view_is_device_accessible_v<V>;
diff --git a/cpp/internal/cuvs_internal/preprocessing/bbq_cpu_quantize.hpp b/cpp/internal/cuvs_internal/preprocessing/bbq_cpu_quantize.hpp
index 603517e518..0ae1172147 100644
--- a/cpp/internal/cuvs_internal/preprocessing/bbq_cpu_quantize.hpp
+++ b/cpp/internal/cuvs_internal/preprocessing/bbq_cpu_quantize.hpp
@@ -331,10 +331,10 @@ inline host_quantizer_storage quantize(const float* data,
 template <typename IdxT>
 auto copy_bbq_owning_storage_host_to_device(raft::resources const& res,
                                             host_quantizer_storage const& host_storage) ->
-  typename cuvs::neighbors::device_bbq_dataset<float, IdxT>::owning_storage_type
+  typename cuvs::neighbors::device_bbq_dataset<float, IdxT>::data_type::owning_storage_type
 {
   using device_storage =
-    typename cuvs::neighbors::device_bbq_dataset<float, IdxT>::owning_storage_type;
+    typename cuvs::neighbors::device_bbq_dataset<float, IdxT>::data_type::owning_storage_type;
   auto stream = raft::resource::get_cuda_stream(res);
   device_storage device{res,
                         static_cast<IdxT>(host_storage.codes.extent(0)),
@@ -389,7 +389,7 @@ auto make_device_bbq_dataset(raft::resources const& res,
   cuvs::neighbors::device_bbq_dataset<float, IdxT> device{
     copy_bbq_owning_storage_host_to_device<IdxT>(res, host[0])};
   for (std::size_t i = 1; i < host.size(); ++i) {
-    device.add_quantizer(copy_bbq_owning_storage_host_to_device<IdxT>(res, host[i]));
+    device.data().add_quantizer(copy_bbq_owning_storage_host_to_device<IdxT>(res, host[i]));
   }
   return device;
 }
diff --git a/cpp/src/neighbors/cagra.cuh b/cpp/src/neighbors/cagra.cuh
index 2532ee55fe..47d6e6a7ac 100644
--- a/cpp/src/neighbors/cagra.cuh
+++ b/cpp/src/neighbors/cagra.cuh
@@ -320,10 +320,10 @@ auto build(raft::resources const& res, const index_params& params, DatasetViewT
     RAFT_EXPECTS(effective_params.metric == cuvs::distance::DistanceType::L2Expanded,
                  "cagra::build: a VPQ dataset supports only L2Expanded distance");
     RAFT_EXPECTS(dataset.n_rows() > 0, "cagra::build: VPQ dataset must not be empty");
-    RAFT_EXPECTS(dataset.pq_bits() == 8,
+    RAFT_EXPECTS(dataset.data().pq_bits() == 8,
                  "cagra::build: VPQ dataset requires pq_bits == 8, got %u",
-                 dataset.pq_bits());
-    auto const pq_len = dataset.pq_len();
+                 dataset.data().pq_bits());
+    auto const pq_len = dataset.data().pq_len();
     RAFT_EXPECTS(pq_len == 2 || pq_len == 4 || pq_len == 8,
                  "cagra::build: VPQ dataset requires pq_len in {2, 4, 8}, got %u",
                  pq_len);
diff --git a/cpp/src/neighbors/detail/cagra/cagra_build.cuh b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
index 545b95fb7e..d89af69dc5 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_build.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
@@ -2313,9 +2313,8 @@ void reconstruct_vpq_queries(raft::resources const& res,
                              raft::device_matrix_view<T, int64_t> output)
 {
   auto const data_view     = vpq_view.as_matrix_view();
-  auto const dict_view     = vpq_view.dictionary_view();
   const uint32_t dim       = vpq_view.dim();
-  const uint32_t pq_len    = vpq_view.pq_len();
+  const uint32_t pq_len    = vpq_view.data().pq_len();
   const uint32_t output_ld = static_cast<uint32_t>(output.extent(1));
   const uint32_t threads   = std::min(dim, 256u);
   RAFT_EXPECTS(output_ld >= dim,
@@ -2326,9 +2325,9 @@ void reconstruct_vpq_queries(raft::resources const& res,
   kern_reconstruct_vpq_queries<T, MathT>
     <<<batch_size, threads, 0, raft::resource::get_cuda_stream(res).get()>>>(
       data_view.data_handle(),
-      vpq_view.encoded_row_length(),
-      dict_view.vq_code_book.data_handle(),
-      dict_view.pq_code_book.data_handle(),
+      vpq_view.data().encoded_row_length(),
+      data_view.vq_code_book.data_handle(),
+      data_view.pq_code_book.data_handle(),
       dim,
       pq_len,
       offset,
@@ -2950,7 +2949,7 @@ auto build_from_bbq_dataset(raft::resources const& res,
                             DatasetViewT const& dataset)
   -> cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>
 {
-  RAFT_EXPECTS(!dataset.quantizers.empty(), "cagra::build: the BBQ dataset is empty.");
+  RAFT_EXPECTS(!dataset.data().quantizers.empty(), "cagra::build: the BBQ dataset is empty.");
   RAFT_EXPECTS(params.metric == cuvs::distance::DistanceType::L2Expanded ||
                  params.metric == cuvs::distance::DistanceType::L2SqrtExpanded ||
                  params.metric == cuvs::distance::DistanceType::CosineExpanded ||
diff --git a/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp b/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
index f220d476bf..281a9f84f3 100644
--- a/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
+++ b/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
@@ -43,8 +43,8 @@ struct vpq_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT> {
 
   // `DatasetT` here is the non-owning dataset_view (not the owning dataset) -- callers pass the
   // view directly rather than reaching back through a `.dset()`-style owner pointer, so
-  // classification and the codebook element type are read off the view via its own dictionary
-  // state (`is_vpq_dataset_view_v`, `DatasetT::value_type`), not an owning-only trait/typedef.
+  // classification and the codebook element type are read off the view via its own VPQ payload
+  // (`is_vpq_dataset_view_v`, `DatasetT::value_type`), not an owning-only trait/typedef.
   template <typename DatasetT>
   constexpr static inline auto accepts_dataset()
     -> std::enable_if_t<cuvs::neighbors::is_vpq_dataset_view_v<DatasetT>, bool>
@@ -66,12 +66,11 @@ struct vpq_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT> {
                    const DistanceT* dataset_norms = nullptr) -> host_type
   {
     auto const data_view = dataset.as_matrix_view();
-    auto const dict_view = dataset.dictionary_view();
     return init_(params,
                  data_view.data_handle(),
                  static_cast<uint32_t>(data_view.extent(1)),
-                 dict_view.vq_code_book.data_handle(),
-                 dict_view.pq_code_book.data_handle(),
+                 data_view.vq_code_book.data_handle(),
+                 data_view.pq_code_book.data_handle(),
                  IndexT(dataset.n_rows()),
                  dataset.dim());
   }
@@ -85,9 +84,8 @@ struct vpq_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT> {
     if (params.team_size != 0 && TeamSize != params.team_size) { return -1.0; }
     if (cuvs::distance::DistanceType::L2Expanded != metric) { return -1.0; }
     // Match codebook params
-    auto const dict_view = dataset.dictionary_view();
-    if (dict_view.pq_bits() != PqBits) { return -1.0; }
-    if (dict_view.pq_len() != PqLen) { return -1.0; }
+    if (dataset.data().pq_bits() != PqBits) { return -1.0; }
+    if (dataset.data().pq_len() != PqLen) { return -1.0; }
     if (select_supported_vpq_smem_dtype(params) != SmemDType) { return -1.0; }
     // Keep auto-selection on the tuned VPQ diagonal while allowing explicit team_size requests to
     // use the expanded team_size / dataset_block_dim grid.
diff --git a/cpp/src/neighbors/detail/cagra/factory.cuh b/cpp/src/neighbors/detail/cagra/factory.cuh
index f82f3d998f..ec1a6f4313 100644
--- a/cpp/src/neighbors/detail/cagra/factory.cuh
+++ b/cpp/src/neighbors/detail/cagra/factory.cuh
@@ -92,7 +92,7 @@ struct key {
 };
 
 // `DatasetT` here is the non-owning dataset_view passed in by the search path, so all state comes
-// off the view's own `as_matrix_view()`/`dictionary_view()`, not owning-only members.
+// off the view's own `as_matrix_view()`, not owning-only members.
 template <typename DatasetT>
 auto make_key(const cagra::search_params& params,
               const DatasetT& dataset,
@@ -121,12 +121,11 @@ auto make_key(const cagra::search_params& params,
   -> std::enable_if_t<cuvs::neighbors::is_vpq_dataset_view_v<DatasetT>, key>
 {
   auto const data_view = dataset.as_matrix_view();
-  auto const dict_view = dataset.dictionary_view();
   return key{reinterpret_cast<uint64_t>(data_view.data_handle()),
              reinterpret_cast<uint64_t>(dataset_norms),
              uint64_t(dataset.n_rows()),
              dataset.dim(),
-             uint32_t(reinterpret_cast<uint64_t>(dict_view.pq_code_book.data_handle()) >> 6),
+             uint32_t(reinterpret_cast<uint64_t>(data_view.pq_code_book.data_handle()) >> 6),
              uint32_t(params.team_size),
              uint32_t(metric),
              uint32_t(params.smem_dtype)};
diff --git a/cpp/src/neighbors/detail/cagra/graph_shared.cu b/cpp/src/neighbors/detail/cagra/graph_shared.cu
index 8dcb4d8b6f..5e362f8f5f 100644
--- a/cpp/src/neighbors/detail/cagra/graph_shared.cu
+++ b/cpp/src/neighbors/detail/cagra/graph_shared.cu
@@ -257,12 +257,14 @@ auto select_sort_quantizers(cuvs::neighbors::device_bbq_dataset_view<DataT, int6
 {
   using bbq_code_layout = cuvs::preprocessing::quantize::bbq::bbq_code_layout;
 
-  if (dataset.quantizers.size() == 1) { return {dataset.quantizers[0], dataset.quantizers[0]}; }
+  if (dataset.data().quantizers.size() == 1) {
+    return {dataset.data().quantizers[0], dataset.data().quantizers[0]};
+  }
 
-  const bool has_1b  = dataset.has_layout(bbq_code_layout::packed_1b);
-  const bool has_4b  = dataset.has_layout(bbq_code_layout::packed_4b);
-  const bool has_2bt = dataset.has_layout(bbq_code_layout::transposed_2b);
-  const bool has_4bt = dataset.has_layout(bbq_code_layout::transposed_4b);
+  const bool has_1b  = dataset.data().has_layout(bbq_code_layout::packed_1b);
+  const bool has_4b  = dataset.data().has_layout(bbq_code_layout::packed_4b);
+  const bool has_2bt = dataset.data().has_layout(bbq_code_layout::transposed_2b);
+  const bool has_4bt = dataset.data().has_layout(bbq_code_layout::transposed_4b);
 
   const bool tc_pair   = has_1b && has_4b;
   const bool simt_pair = (has_4bt && (has_1b || has_2bt)) || (has_2bt && has_1b);
@@ -270,11 +272,11 @@ auto select_sort_quantizers(cuvs::neighbors::device_bbq_dataset_view<DataT, int6
                "Unsupported BBQ layout pair for an asymmetric dataset. Supported (document, "
                "query) pairs: (packed_1b, packed_4b), (packed_1b, transposed_2b), "
                "(packed_1b, transposed_4b), (transposed_2b, transposed_4b).");
-  return {has_1b ? dataset.get_quantizer(bbq_code_layout::packed_1b)
-                 : dataset.get_quantizer(bbq_code_layout::transposed_2b),
-          tc_pair   ? dataset.get_quantizer(bbq_code_layout::packed_4b)
-          : has_4bt ? dataset.get_quantizer(bbq_code_layout::transposed_4b)
-                    : dataset.get_quantizer(bbq_code_layout::transposed_2b)};
+  return {has_1b ? dataset.data().get_quantizer(bbq_code_layout::packed_1b)
+                 : dataset.data().get_quantizer(bbq_code_layout::transposed_2b),
+          tc_pair   ? dataset.data().get_quantizer(bbq_code_layout::packed_4b)
+          : has_4bt ? dataset.data().get_quantizer(bbq_code_layout::transposed_4b)
+                    : dataset.data().get_quantizer(bbq_code_layout::transposed_2b)};
 }
 
 template <typename DataT>
@@ -285,7 +287,7 @@ void sort_knn_graph_bbq_impl(raft::resources const& res,
 {
   namespace bbq = cuvs::preprocessing::quantize::bbq;
 
-  RAFT_EXPECTS(!dataset.quantizers.empty(), "the BBQ dataset holds no quantizer");
+  RAFT_EXPECTS(!dataset.data().quantizers.empty(), "the BBQ dataset holds no quantizer");
   RAFT_EXPECTS(dataset.n_rows() == knn_graph.extent(0),
                "dataset size is expected to have the same number of graph index size");
   RAFT_EXPECTS(metric == cuvs::distance::DistanceType::L2Expanded ||
diff --git a/cpp/src/neighbors/detail/dataset_serialize.hpp b/cpp/src/neighbors/detail/dataset_serialize.hpp
index 1743230cd3..740a16744f 100644
--- a/cpp/src/neighbors/detail/dataset_serialize.hpp
+++ b/cpp/src/neighbors/detail/dataset_serialize.hpp
@@ -436,8 +436,8 @@ auto deserialize_vpq(raft::resources const& res, std::istream& is)
   raft::deserialize_mdspan(res, is, data.view());
 
   using owning_t = device_vpq_dataset<DataT, IdxT>;
-  typename owning_t::dictionary_type dictionary{std::move(vq_code_book), std::move(pq_code_book)};
-  return std::make_unique<owning_t>(std::move(data), std::move(dictionary));
+  return std::make_unique<owning_t>(
+    std::move(data), std::move(vq_code_book), std::move(pq_code_book));
 }
 
 template <typename DataT, typename IdxT, typename OwningDatasetT, typename Input>
diff --git a/cpp/src/neighbors/detail/nn_descent.cuh b/cpp/src/neighbors/detail/nn_descent.cuh
index b1260784b1..7aa70b4800 100644
--- a/cpp/src/neighbors/detail/nn_descent.cuh
+++ b/cpp/src/neighbors/detail/nn_descent.cuh
@@ -2485,11 +2485,11 @@ void GNND<Data_t, Index_t>::local_join(
   // Both kernels take the same (document, query) pair, so there is no symmetric/asymmetric split
   // here: a single quantizer just means the same one on both operands, which is exactly what
   // SelfJoin encodes. Picking the two quantizers is all that differs.
-  const bool self_join = dataset.quantizers.size() == 1;
-  const bool has_1b    = dataset.has_layout(bbq_code_layout::packed_1b);
-  const bool has_4b    = dataset.has_layout(bbq_code_layout::packed_4b);
-  const bool has_2bt   = dataset.has_layout(bbq_code_layout::transposed_2b);
-  const bool has_4bt   = dataset.has_layout(bbq_code_layout::transposed_4b);
+  const bool self_join = dataset.data().quantizers.size() == 1;
+  const bool has_1b    = dataset.data().has_layout(bbq_code_layout::packed_1b);
+  const bool has_4b    = dataset.data().has_layout(bbq_code_layout::packed_4b);
+  const bool has_2bt   = dataset.data().has_layout(bbq_code_layout::transposed_2b);
+  const bool has_4bt   = dataset.data().has_layout(bbq_code_layout::transposed_4b);
 
   // Asymmetric: a packed_4b query selects the tensor-core path, a transposed query the SIMT one.
   // Only packed_1b promotes to the tensor-core path; transposed_2b is SIMT-only (it would need
@@ -2501,13 +2501,14 @@ void GNND<Data_t, Index_t>::local_join(
                "packed_1b x packed_4b (tensor core); packed_1b x transposed_2b, "
                "packed_1b x transposed_4b, transposed_2b x transposed_4b (SIMT).");
   auto quantizer_query =
-    self_join ? dataset.quantizers[0]
-              : (tc_pair ? dataset.get_quantizer(bbq_code_layout::packed_4b)
-                         : (has_4bt ? dataset.get_quantizer(bbq_code_layout::transposed_4b)
-                                    : dataset.get_quantizer(bbq_code_layout::transposed_2b)));
-  auto quantizer_document = self_join ? dataset.quantizers[0]
-                            : has_1b  ? dataset.get_quantizer(bbq_code_layout::packed_1b)
-                                      : dataset.get_quantizer(bbq_code_layout::transposed_2b);
+    self_join
+      ? dataset.data().quantizers[0]
+      : (tc_pair ? dataset.data().get_quantizer(bbq_code_layout::packed_4b)
+                 : (has_4bt ? dataset.data().get_quantizer(bbq_code_layout::transposed_4b)
+                            : dataset.data().get_quantizer(bbq_code_layout::transposed_2b)));
+  auto quantizer_document = self_join ? dataset.data().quantizers[0]
+                            : has_1b  ? dataset.data().get_quantizer(bbq_code_layout::packed_1b)
+                                     : dataset.data().get_quantizer(bbq_code_layout::transposed_2b);
 
   // stage_tile_simt / stage_promoted_tile cast code buffers to uint32_t*, so every plane stride
   // must be 4-byte aligned.
@@ -2982,8 +2983,8 @@ void build(raft::resources const& res,
            cuvs::neighbors::device_bbq_dataset_view<DataT, int64_t> dataset,
            index<IdxT>& idx)
 {
-  RAFT_EXPECTS(dataset.quantizers.size() > 0, "BBQ dataset must not be empty.");
-  auto front_quantizer = dataset.quantizers[0];
+  RAFT_EXPECTS(dataset.data().quantizers.size() > 0, "BBQ dataset must not be empty.");
+  auto front_quantizer = dataset.data().quantizers[0];
   cuvs::common::nvtx::range<cuvs::common::nvtx::domain::cuvs> fun_scope(
     "neighbors::nn_descent::detail::build-bbq(%zu, %zu, %zu, %zu, %zu)",
     size_t(dataset.n_rows()),
@@ -3001,7 +3002,7 @@ void build(raft::resources const& res,
                "BBQ dataset metric does not match the NN-Descent metric.");
   // packed_4b is the only layout dispatched to local_join_kernel_bbq_wmma, and the int4 MMA that
   // kernel is built around only exists from sm_75 on.
-  if (dataset.has_layout(bbq_code_layout::packed_4b)) {
+  if (dataset.data().has_layout(bbq_code_layout::packed_4b)) {
     auto kernel       = local_join_kernel_bbq_wmma<bbq_code_layout::packed_4b,
                                                    bbq_code_layout::packed_4b,
                                                    true,
diff --git a/cpp/src/neighbors/detail/vamana/vamana_build.cuh b/cpp/src/neighbors/detail/vamana/vamana_build.cuh
index 7651c75ce4..ebe134cc4a 100644
--- a/cpp/src/neighbors/detail/vamana/vamana_build.cuh
+++ b/cpp/src/neighbors/detail/vamana/vamana_build.cuh
@@ -678,13 +678,11 @@ index<T, IdxT> build(
     const uint32_t n_rows = dataset.extent(0);
 
     using vpq_owning_t = cuvs::neighbors::device_vpq_dataset<float, int64_t>;
-    typename vpq_owning_t::dictionary_type vpq_dictionary{
-      raft::make_device_matrix<float, uint32_t, raft::row_major>(res, 0, 0),
-      std::move(pq_codebook)};
-    auto quantizer = cuvs::preprocessing::quantize::pq::quantizer<float>(
+    auto quantizer     = cuvs::preprocessing::quantize::pq::quantizer<float>(
       pq_params,
       vpq_owning_t(raft::make_device_matrix<uint8_t, int64_t, raft::row_major>(res, 0, 0),
-                   std::move(vpq_dictionary)));
+                   raft::make_device_matrix<float, uint32_t, raft::row_major>(res, 0, 0),
+                   std::move(pq_codebook)));
     const int64_t codes_rowlen = cuvs::preprocessing::quantize::pq::get_quantized_dim(pq_params);
     quantized_vectors =
       raft::make_device_matrix<uint8_t, int64_t, raft::row_major>(res, n_rows, codes_rowlen);
diff --git a/cpp/src/neighbors/scann/detail/scann_build.cuh b/cpp/src/neighbors/scann/detail/scann_build.cuh
index 634a8d6567..3bf0fa6b30 100644
--- a/cpp/src/neighbors/scann/detail/scann_build.cuh
+++ b/cpp/src/neighbors/scann/detail/scann_build.cuh
@@ -437,7 +437,7 @@ index<T, IdxT> build(
   // Codebooks from VPQ have the shape [subspace idx, subspace dim, code]
   // This converts the codebook into matrix format for easy interoperability
   // with open-source ScaNN search
-  auto full_codebook_view = pq_quantizer.vpq_codebooks.dictionary_view().pq_code_book;
+  auto full_codebook_view = pq_quantizer.vpq_codebooks.as_matrix_view().pq_code_book;
 
   raft::linalg::map_offset(
     res,
diff --git a/cpp/src/preprocessing/quantize/detail/pq.cuh b/cpp/src/preprocessing/quantize/detail/pq.cuh
index c52a8a8790..14d5490aca 100644
--- a/cpp/src/preprocessing/quantize/detail/pq.cuh
+++ b/cpp/src/preprocessing/quantize/detail/pq.cuh
@@ -193,8 +193,8 @@ quantizer<MathT> build(
       res, filled_params, dataset, raft::make_const_mdspan(vq_code_book.view()));
   }
   using owning_t = cuvs::neighbors::device_vpq_dataset<MathT, int64_t>;
-  typename owning_t::dictionary_type dictionary{std::move(vq_code_book), std::move(pq_code_book)};
-  return {filled_params, owning_t(std::move(empty_codes), std::move(dictionary))};
+  return {filled_params,
+          owning_t(std::move(empty_codes), std::move(vq_code_book), std::move(pq_code_book))};
 }
 
 template <typename T, typename QuantI, typename AccessorType>
@@ -217,7 +217,7 @@ void transform(
   RAFT_EXPECTS(quantizer.params_quantizer.pq_bits >= 4 && quantizer.params_quantizer.pq_bits <= 16,
                "PQ bits must be within [4, 16]");
   // Encode dataset
-  auto vq_centers     = quantizer.vpq_codebooks.dictionary_view().vq_code_book;
+  auto vq_centers     = quantizer.vpq_codebooks.as_matrix_view().vq_code_book;
   auto vq_labels_view = raft::make_device_vector_view<uint32_t, int64_t>(nullptr, 0);
   if (vq_labels.has_value()) { vq_labels_view = vq_labels.value(); }
 
@@ -226,7 +226,7 @@ void transform(
       res,
       to_vpq_params(quantizer.params_quantizer),
       dataset,
-      quantizer.vpq_codebooks.dictionary_view().pq_code_book,
+      quantizer.vpq_codebooks.as_matrix_view().pq_code_book,
       vq_centers,
       vq_labels_view,
       pq_codes_out);
@@ -235,7 +235,7 @@ void transform(
       res,
       to_vpq_params(quantizer.params_quantizer),
       dataset,
-      quantizer.vpq_codebooks.dictionary_view().pq_code_book,
+      quantizer.vpq_codebooks.as_matrix_view().pq_code_book,
       vq_centers,
       vq_labels_view,
       pq_codes_out);
@@ -356,7 +356,7 @@ void inverse_transform(
                "Codes matrix doesn't have the correct number of columns");
   RAFT_EXPECTS(quant.params_quantizer.pq_bits >= 4 && quant.params_quantizer.pq_bits <= 16,
                "PQ bits must be within [4, 16]");
-  auto const quant_dict = quant.vpq_codebooks.dictionary_view();
+  auto const quant_dict = quant.vpq_codebooks.as_matrix_view();
   reconstruct_vectors<T, T, idx_t, label_t>(res,
                                             quant.params_quantizer,
                                             codes,
@@ -371,17 +371,18 @@ template <typename NewMathT, typename OldMathT, typename IdxT>
 void vpq_convert_math_type(
   const raft::resources& res,
   const cuvs::neighbors::device_vpq_dataset<OldMathT, IdxT>& src,
-  typename cuvs::neighbors::device_vpq_dataset<NewMathT, IdxT>::dictionary_type& dst_dict)
+  raft::device_matrix_view<NewMathT, uint32_t, raft::row_major> dst_vq_code_book,
+  raft::device_matrix_view<NewMathT, uint32_t, raft::row_major> dst_pq_code_book)
 {
-  auto const src_dict = src.dictionary_view();
+  auto const src_view = src.as_matrix_view();
   raft::linalg::map(res,
-                    dst_dict.vq_code_book.view(),
+                    dst_vq_code_book,
                     cuvs::spatial::knn::detail::utils::mapping<NewMathT>{},
-                    src_dict.vq_code_book);
+                    src_view.vq_code_book);
   raft::linalg::map(res,
-                    dst_dict.pq_code_book.view(),
+                    dst_pq_code_book,
                     cuvs::spatial::knn::detail::utils::mapping<NewMathT>{},
-                    src_dict.pq_code_book);
+                    src_view.pq_code_book);
 }
 
 inline auto make_pq_params_from_vpq(const cuvs::neighbors::vpq_params& in_params,
@@ -440,8 +441,7 @@ auto vpq_build(const raft::resources& res,
     true);
 
   using owning_t = cuvs::neighbors::device_vpq_dataset<MathT, IdxT>;
-  typename owning_t::dictionary_type dictionary{std::move(vq_code_book), std::move(pq_code_book)};
-  return owning_t(std::move(codes), std::move(dictionary));
+  return owning_t(std::move(codes), std::move(vq_code_book), std::move(pq_code_book));
 }
 
 template <typename DatasetT>
@@ -449,13 +449,15 @@ auto vpq_build_half(const raft::resources& res,
                     const cuvs::neighbors::vpq_params& params,
                     const DatasetT& dataset) -> cuvs::neighbors::device_vpq_dataset<half, int64_t>
 {
-  auto old_type       = vpq_build<decltype(dataset), float, int64_t>(res, params, dataset);
-  using new_owning_t  = cuvs::neighbors::device_vpq_dataset<half, int64_t>;
-  auto const old_dict = old_type.dictionary_view();
-  typename new_owning_t::dictionary_type new_dict{
-    raft::make_device_mdarray<half>(res, old_dict.vq_code_book.extents()),
-    raft::make_device_mdarray<half>(res, old_dict.pq_code_book.extents())};
-  vpq_convert_math_type<half, float, int64_t>(res, old_type, new_dict);
-  return new_owning_t(old_type.release_data(), std::move(new_dict));
+  auto old_type         = vpq_build<decltype(dataset), float, int64_t>(res, params, dataset);
+  using new_owning_t    = cuvs::neighbors::device_vpq_dataset<half, int64_t>;
+  auto const old_view   = old_type.as_matrix_view();
+  auto new_vq_code_book = raft::make_device_mdarray<half>(res, old_view.vq_code_book.extents());
+  auto new_pq_code_book = raft::make_device_mdarray<half>(res, old_view.pq_code_book.extents());
+  vpq_convert_math_type<half, float, int64_t>(
+    res, old_type, new_vq_code_book.view(), new_pq_code_book.view());
+  // Reuse the already-encoded codes (the owning payload's mdarray base) with the new codebooks.
+  return new_owning_t(
+    std::move(old_type.data()), std::move(new_vq_code_book), std::move(new_pq_code_book));
 }
 }  // namespace cuvs::preprocessing::quantize::pq::detail
diff --git a/cpp/tests/neighbors/ann_cagra/test_iterative_cagra_q.cu b/cpp/tests/neighbors/ann_cagra/test_iterative_cagra_q.cu
index ea0cfcabc5..e0f250a2b0 100644
--- a/cpp/tests/neighbors/ann_cagra/test_iterative_cagra_q.cu
+++ b/cpp/tests/neighbors/ann_cagra/test_iterative_cagra_q.cu
@@ -179,7 +179,7 @@ class CagraQBuildTest : public CagraQCompressedTestBase,
 TEST_P(CagraQBuildTest, BuildsAndSearchesAFreshlyCompressedDataset)
 {
   auto compressed = compress(res_, dataset(), params_.pq_dim);
-  ASSERT_EQ(compressed.pq_len(), static_cast<uint32_t>(params_.dim / params_.pq_dim));
+  ASSERT_EQ(compressed.data().pq_len(), static_cast<uint32_t>(params_.dim / params_.pq_dim));
 
   auto idx = cagra::build(res_, iterative_params(), compressed.as_dataset_view());
   ASSERT_EQ(idx.size(), params_.n_rows);
@@ -272,7 +272,7 @@ TEST_F(CagraQContractTest, RejectsMetricOtherThanL2Expanded)
 TEST_F(CagraQContractTest, RejectsPqBitsOtherThan8)
 {
   auto compressed = compress(res_, dataset(), 32, /* pq_bits */ 6);
-  ASSERT_EQ(compressed.pq_bits(), 6u);
+  ASSERT_EQ(compressed.data().pq_bits(), 6u);
   EXPECT_THROW(cagra::build(res_, iterative_params(), compressed.as_dataset_view()),
                raft::exception);
 }
@@ -280,7 +280,7 @@ TEST_F(CagraQContractTest, RejectsPqBitsOtherThan8)
 TEST_F(CagraQContractTest, RejectsPqLenOutsideSupportedSet)
 {
   auto compressed = compress(res_, dataset(), /* pq_dim */ 4);  // pq_len = 64 / 4 = 16
-  ASSERT_EQ(compressed.pq_len(), 16u);
+  ASSERT_EQ(compressed.data().pq_len(), 16u);
   EXPECT_THROW(cagra::build(res_, iterative_params(), compressed.as_dataset_view()),
                raft::exception);
 }
@@ -293,8 +293,7 @@ TEST_F(CagraQContractTest, RejectsEmptyDataset)
   auto vq_code_book = raft::make_device_matrix<half, uint32_t, raft::row_major>(res_, 1, width);
   auto pq_code_book = raft::make_device_matrix<half, uint32_t, raft::row_major>(res_, 256, 2);
   auto codes = raft::make_device_matrix<uint8_t, int64_t, raft::row_major>(res_, 0, 4 + dim / 2);
-  vpq_dataset_t::dictionary_type dictionary{std::move(vq_code_book), std::move(pq_code_book)};
-  vpq_dataset_t empty{std::move(codes), std::move(dictionary)};
+  vpq_dataset_t empty{std::move(codes), std::move(vq_code_book), std::move(pq_code_book)};
   ASSERT_EQ(empty.n_rows(), 0);
 
   EXPECT_THROW(cagra::build(res_, iterative_params(), empty.as_dataset_view()), raft::exception);
diff --git a/cpp/tests/neighbors/ann_cagra_bbq.cuh b/cpp/tests/neighbors/ann_cagra_bbq.cuh
index 9ecc4bd1d4..0ac52e2265 100644
--- a/cpp/tests/neighbors/ann_cagra_bbq.cuh
+++ b/cpp/tests/neighbors/ann_cagra_bbq.cuh
@@ -261,7 +261,7 @@ class AnnCagraBbqTest : public ::testing::TestWithParam<AnnCagraBbqInputs> {
     ASSERT_EQ(restored.graph_degree(), graph_index.graph_degree());
     EXPECT_EQ(restored.metric(), graph_index.metric());
     EXPECT_EQ(restored.dataset().n_rows(), 0);
-    EXPECT_TRUE(restored.dataset().quantizers.empty());
+    EXPECT_TRUE(restored.dataset().data().quantizers.empty());
 
     auto original   = cagra::update_dataset(handle_, std::move(graph_index), device_padded.view);
     auto reattached = cagra::update_dataset(handle_, std::move(restored), device_padded.view);
@@ -284,7 +284,7 @@ class AnnCagraBbqTest : public ::testing::TestWithParam<AnnCagraBbqInputs> {
     ASSERT_EQ(index.graph_size(), static_cast<uint32_t>(ps.n_rows));
     ASSERT_EQ(index.graph_degree(), static_cast<uint32_t>(ps.graph_degree));
     EXPECT_EQ(index.dataset().n_rows(), 0);
-    EXPECT_TRUE(index.dataset().quantizers.empty());
+    EXPECT_TRUE(index.dataset().data().quantizers.empty());
   }
 
   /** Only NN-descent graph construction and the four BBQ metrics are accepted. */
@@ -331,7 +331,7 @@ class AnnCagraBbqTest : public ::testing::TestWithParam<AnnCagraBbqInputs> {
 
  private:
   raft::resources handle_;
-  rmm::cuda_stream_view stream_;
+  cuda::stream_ref stream_;
   AnnCagraBbqInputs ps;
   rmm::device_uvector<float> database;
   rmm::device_uvector<float> search_queries;
diff --git a/cpp/tests/neighbors/ann_nn_descent_bbq.cuh b/cpp/tests/neighbors/ann_nn_descent_bbq.cuh
index 295cae935f..675b6399ba 100644
--- a/cpp/tests/neighbors/ann_nn_descent_bbq.cuh
+++ b/cpp/tests/neighbors/ann_nn_descent_bbq.cuh
@@ -153,7 +153,7 @@ class AnnNNDescentBbqTest : public ::testing::TestWithParam<AnnNNDescentBbqInput
 
  private:
   raft::resources handle_;
-  rmm::cuda_stream_view stream_;
+  cuda::stream_ref stream_;
   AnnNNDescentBbqInputs ps;
   raft::device_matrix<float, int64_t> database;
 };
diff --git a/cpp/tests/neighbors/ann_scann.cuh b/cpp/tests/neighbors/ann_scann.cuh
index 8809e203ef..02c145e203 100644
--- a/cpp/tests/neighbors/ann_scann.cuh
+++ b/cpp/tests/neighbors/ann_scann.cuh
@@ -186,10 +186,9 @@ class scann_test : public ::testing::TestWithParam<scann_inputs> {
     auto empty_data = raft::make_device_matrix<uint8_t, int64_t, raft::row_major>(handle_, 0, 0);
 
     using vpq_owning_t = cuvs::neighbors::device_vpq_dataset<float, int64_t>;
-    typename vpq_owning_t::dictionary_type vpq_dictionary{std::move(vq_codebook),
-                                                          std::move(pq_codebook_copy)};
     cuvs::preprocessing::quantize::pq::quantizer<float> quantizer{
-      pq_params, vpq_owning_t(std::move(empty_data), std::move(vpq_dictionary))};
+      pq_params,
+      vpq_owning_t(std::move(empty_data), std::move(vq_codebook), std::move(pq_codebook_copy))};
 
     auto quantized_residuals_device =
       raft::make_device_matrix<uint8_t, IdxT>(handle_, ps.num_db_vecs, num_subspaces);
diff --git a/cpp/tests/neighbors/vpq_utils.cuh b/cpp/tests/neighbors/vpq_utils.cuh
index 5fc5d1bba0..ed6a8d9264 100644
--- a/cpp/tests/neighbors/vpq_utils.cuh
+++ b/cpp/tests/neighbors/vpq_utils.cuh
@@ -50,12 +50,11 @@ void decode_vpq_dataset(raft::device_matrix_view<data_t, int64_t> decoded_datase
                         cudaStream_t cuda_stream)
 {
   const auto dataset_size = decoded_dataset.extent(0);
-  auto const dict_view    = vpq_dataset.dictionary_view();
   auto const data_view    = vpq_dataset.as_matrix_view();
   RAFT_EXPECTS(data_view.extent(0) == dataset_size, "Dataset sizes mismatch");
-  RAFT_EXPECTS(vpq_dataset.pq_bits() == 8,
+  RAFT_EXPECTS(vpq_dataset.data().pq_bits() == 8,
                "decode_vpq_dataset currently only supports pq_bits == 8 (got %u)",
-               vpq_dataset.pq_bits());
+               vpq_dataset.data().pq_bits());
 
   constexpr uint32_t block_size  = 256;
   constexpr uint32_t warp_size   = 32;
@@ -65,11 +64,11 @@ void decode_vpq_dataset(raft::device_matrix_view<data_t, int64_t> decoded_datase
   decode_vpq_dataset_kernel<data_t, math_t>
     <<<grid_size, block_size, 0, cuda_stream>>>(decoded_dataset.data_handle(),
                                                 decoded_dataset.stride(0),
-                                                dict_view.vq_code_book.data_handle(),
-                                                dict_view.vq_code_book.stride(0),
-                                                dict_view.pq_code_book.data_handle(),
-                                                vpq_dataset.pq_len(),
-                                                1u << vpq_dataset.pq_bits(),
+                                                data_view.vq_code_book.data_handle(),
+                                                data_view.vq_code_book.stride(0),
+                                                data_view.pq_code_book.data_handle(),
+                                                vpq_dataset.data().pq_len(),
+                                                1u << vpq_dataset.data().pq_bits(),
                                                 vpq_dataset.dim(),
                                                 dataset_size,
                                                 data_view.data_handle(),
diff --git a/fern/pages/cpp_api/cpp-api-neighbors-common.md b/fern/pages/cpp_api/cpp-api-neighbors-common.md
index 2f8c347e15..457c97c53d 100644
--- a/fern/pages/cpp_api/cpp-api-neighbors-common.md
+++ b/fern/pages/cpp_api/cpp-api-neighbors-common.md
@@ -64,7 +64,7 @@ enum class MergeStrategy {
 
 Spec-based `dataset` / `dataset_view`.
 
-`dataset&lt;T,IdxT,SpecT&gt;` and `dataset_view&lt;T,IdxT,SpecT&gt;` are single generic templates with zero per-kind dispatch inside them: every member is a one-line forward to `spec_type::get_*(...)`, and all kind-specific logic lives in the per-kind Spec structs below (`empty_dataset_spec`, `padded_dataset_spec`, `standard_dataset_spec`, `vpq_dataset_spec`), which `dataset`/ `dataset_view` never name or branch on. `dataset` and `dataset_view` are deliberately two independent, non-inheriting types (no shared_ptr, no "sometimes owning" object): `dataset` holds owning storage (mdarray-shaped), `dataset_view` holds the corresponding view storage (mdspan-shaped). The same `get_n_rows`/`get_dim` spec functions serve both, since `raft::mdarray`/`raft::mdspan` both expose `.extent(r)`.
+`dataset&lt;T,IdxT,SpecT&gt;` and `dataset_view&lt;T,IdxT,SpecT&gt;` are single generic templates that know nothing about any particular kind of dataset. They hold exactly one payload (`data_type` / `view_type`, chosen by the spec) and expose only what every dataset has: `n_rows()`, `dim()`, `as_matrix_view()`, `as_dataset_view()` and `data()`. Each is a one-line forward to one of the three spec functions `get_data_view()`, `get_n_rows()` and `get_dim()`. Anything else a kind needs (e.g. VPQ codebooks, BBQ quantizers) is state and methods of that kind's payload type, reached through `data()`; `dataset`/`dataset_view` never name or branch on it. `dataset` and `dataset_view` are deliberately two independent, non-inheriting types (no shared_ptr, no "sometimes owning" object): `dataset` holds the owning payload, `dataset_view` the corresponding non-owning payload.
 
 ```cpp
 template <typename T, typename IdxT, typename SpecT>
@@ -76,7 +76,7 @@ struct dataset;
 
 `Accessor` drives both codebook and code residency, mirroring today's
 
-single-`Accessor`-per-VPQ-dataset design (`vpq_vq_book_matrix`/`vpq_data_matrix` are both keyed off one `Accessor`). Data = encoded rows (uint8_t codes); dictionary = \{vq_code_book, pq_code_book\}. Inlined directly (unlike padded/standard) since no second tag shares this body.
+single-`Accessor`-per-VPQ-dataset design. The payload (`detail::vpq_owning_storage` / `detail::vpq_view_storage`) holds the encoded rows and the VQ/PQ codebooks.
 
 ```cpp
 template <typename MathT, typename Accessor>
@@ -86,9 +86,9 @@ struct vpq_dataset_spec;
 <a id="neighbors-dataset"></a>
 ### neighbors::dataset
 
-Owning dataset: value-held storage (no shared_ptr -- exclusive ownership). Every member is a
+Owning dataset: value-held payload (no shared_ptr -- exclusive ownership). Every member is a
 
-one-line forward to `spec_type::get_*`; all per-kind logic lives in `SpecT`, never inside this struct.
+one-line forward to `spec_type::get_*` or to the payload; all per-kind state and logic lives in the spec's `data_type`, never inside this struct.
 
 ```cpp
 template <typename T, typename IdxT, typename SpecT>
@@ -98,9 +98,9 @@ struct dataset;
 <a id="neighbors-dataset-view"></a>
 ### neighbors::dataset_view
 
-Non-owning dataset view: holds only view-shaped storage (mdspan, not mdarray). Deliberately not
+Non-owning dataset view: holds only the view-shaped payload. Deliberately not derived from
 
-derived from `dataset` -- a view type holds "all view state" with no inheritance and no shared ownership tying it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec functions as `dataset`, fed view-shaped arguments instead of owning ones.
+`dataset` -- a view type holds "all view state" with no inheritance and no shared ownership tying it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec functions as `dataset`, fed the view payload instead of the owning one.
 
 ```cpp
 template <typename T, typename IdxT, typename SpecT>
diff --git a/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md b/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md
index 6e115bec35..a5656e234e 100644
--- a/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md
+++ b/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md
@@ -154,14 +154,14 @@ dequant_sum_delta from that delta and quantized_component_sums.
 
 ## Types
 
-<a id="neighbors-bbq-dataset-view"></a>
-### neighbors::bbq_dataset_view
+<a id="neighbors-bbq-dataset-spec"></a>
+### neighbors::bbq_dataset_spec
 
-BBQ doesn't fit the shared Spec-based `dataset`/`dataset_view` shape (one data slot + one
+BBQ is just another dataset type: it plugs its payloads into the shared `dataset`/
 
-optional dictionary slot): a BBQ dataset is a small bag of alternate encodings of the *same* rows, one per `bbq_code_layout`, selected at query time. So unlike padded/standard/vpq, BBQ gets its own standalone owning/view types rather than a `SpecT` plugged into `dataset`/ `dataset_view` -- they only need to satisfy `ann_dataset_view` (`n_rows()`/`dim()`) to work everywhere a dataset view is expected, plus the handful of trait specializations below.
+`dataset_view` through a spec, like padded/standard/vpq do.
 
 ```cpp
-template <typename DataT, typename IdxT, typename Accessor>
-struct bbq_dataset_view;
+template <typename Accessor>
+struct bbq_dataset_spec;
 ```

From 9832a4f26150d1a69e6de2240aae8760d319dd47 Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Thu, 1 Oct 2026 19:43:06 -0700
Subject: [PATCH 08/15] Move dataset/dataset_view out of neighbors/common.hpp
 into core/dataset.hpp (#2395)

Datasets are a core type, not a neighbors one: quantizers (pq.hpp, bbq.hpp)
and clustering also need them and should not depend on anything in
neighbors. Create cuvs/core/dataset.hpp as the root of the dataset header
tree and move the whole dataset section of neighbors/common.hpp into it:
dataset and dataset_view, the accessor aliases and dense/empty storage,
the empty/padded/standard/vpq specs and their aliases, the kind traits,
with_accessor/device_counterpart, the CAGRA row-width helpers, and the
make_*_padded_dataset / make_*_standard_dataset factories.

neighbors/common.hpp includes the new header, so none of its 67 includers
change. This is a pure cut and paste: the 1187 moved lines are
byte-identical to the removed block, the namespace is still
cuvs::neighbors, and there are no call-site changes. The Fern API
reference is regenerated for the new header (fern-api-reference hook).

Not done yet (follow-ups): the VPQ and BBQ pieces and the
dataset_view_kind enum still live in the moved block and will move into
quantize/pq.hpp and quantize/bbq.hpp as children of dataset; the dataset
types then move from cuvs::neighbors to cuvs::core.

Verified: full rebuild clean; DATASET_C_TEST (9), CAGRA_C_TEST (15),
PREPROCESSING_TEST (226), NEIGHBORS_TEST (371),
NEIGHBORS_ANN_CAGRA_BBQ_UINT32_TEST (105), NEIGHBORS_ANN_NN_DESCENT_TEST
(572), NEIGHBORS_ANN_CAGRA_MERGE_TEST (26),
NEIGHBORS_ANN_CAGRA_FLOAT_UINT32_TEST (3594) pass.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 cpp/include/cuvs/core/dataset.hpp             | 1229 +++++++++++++++++
 cpp/include/cuvs/neighbors/common.hpp         | 1189 +---------------
 fern/docs.yml                                 |    2 +
 fern/pages/cpp_api/cpp-api-core-dataset.md    |  129 ++
 .../pages/cpp_api/cpp-api-neighbors-common.md |  204 +--
 fern/pages/cpp_api/index.md                   |    1 +
 6 files changed, 1404 insertions(+), 1350 deletions(-)
 create mode 100644 cpp/include/cuvs/core/dataset.hpp
 create mode 100644 fern/pages/cpp_api/cpp-api-core-dataset.md

diff --git a/cpp/include/cuvs/core/dataset.hpp b/cpp/include/cuvs/core/dataset.hpp
new file mode 100644
index 0000000000..aac994b01b
--- /dev/null
+++ b/cpp/include/cuvs/core/dataset.hpp
@@ -0,0 +1,1229 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <raft/core/device_container_policy.hpp>
+#include <raft/core/device_mdarray.hpp>
+#include <raft/core/device_resources.hpp>
+#include <raft/core/host_container_policy.hpp>
+#include <raft/core/host_device_accessor.hpp>
+#include <raft/core/host_mdarray.hpp>
+#include <raft/core/host_mdspan.hpp>
+#include <raft/core/mdarray.hpp>
+#include <raft/core/resource/cuda_stream.hpp>
+#include <raft/core/resources.hpp>
+#include <raft/util/cudart_utils.hpp>   // get_device_for_address, copy_matrix
+#include <raft/util/integer_utils.hpp>  // rounding up
+
+#include <cuvs/core/export.hpp>
+#include <raft/core/detail/macros.hpp>
+
+#include <cuda_fp16.h>
+
+#include <concepts>
+#include <cstring>
+#include <memory>
+#include <numeric>
+#include <type_traits>
+#include <utility>
+#ifdef __cpp_lib_bitops
+#include <bit>
+#endif
+
+namespace CUVS_EXPORT cuvs {
+namespace neighbors {
+
+/**
+ * @brief Spec-based `dataset` / `dataset_view`.
+ *
+ * `dataset<T,IdxT,SpecT>` and `dataset_view<T,IdxT,SpecT>` are single generic templates that know
+ * nothing about any particular kind of dataset. They hold exactly one payload (`data_type` /
+ * `view_type`, chosen by the spec) and expose only what every dataset has: `n_rows()`, `dim()`,
+ * `as_matrix_view()`, `as_dataset_view()` and `data()`. Each is a one-line forward to one of the
+ * three spec functions `get_data_view()`, `get_n_rows()` and `get_dim()`. Anything else a kind
+ * needs (e.g. VPQ codebooks, BBQ quantizers) is state and methods of that kind's payload type,
+ * reached through `data()`; `dataset`/`dataset_view` never name or branch on it. `dataset` and
+ * `dataset_view` are deliberately two independent, non-inheriting types (no shared_ptr, no
+ * "sometimes owning" object): `dataset` holds the owning payload, `dataset_view` the
+ * corresponding non-owning payload.
+ */
+
+template <typename T, typename IdxT, typename SpecT>
+struct dataset;
+
+template <typename T, typename IdxT, typename SpecT>
+struct dataset_view;
+
+namespace detail {
+
+// Default owning/view accessors for public dataset aliases.
+template <typename T>
+using device_owning_accessor = raft::device_accessor<raft::device_container_policy<T>>;
+
+template <typename T>
+using host_owning_accessor = raft::host_accessor<raft::host_container_policy<T>>;
+
+template <typename T>
+using device_view_accessor = raft::device_accessor<cuda::std::default_accessor<const T>>;
+
+template <typename T>
+using host_view_accessor = raft::host_accessor<cuda::std::default_accessor<const T>>;
+
+/** View accessor paired with an owning dataset accessor (same residency). */
+template <typename DataT, typename Accessor>
+using dataset_view_accessor_for_owning = std::conditional_t<Accessor::is_device_accessible,
+                                                            device_view_accessor<DataT>,
+                                                            host_view_accessor<DataT>>;
+
+/** Owning accessor paired with a view accessor (same residency). */
+template <typename DataT, typename Accessor>
+using dataset_owning_accessor_for_view = std::conditional_t<Accessor::is_device_accessible,
+                                                            device_owning_accessor<DataT>,
+                                                            host_owning_accessor<DataT>>;
+
+// Accessor here is already device_owning_accessor<DataT> / host_owning_accessor<DataT> at every
+// call site -- exactly the container policy raft::device_mdarray/host_mdarray default to for
+// element type DataT -- so pass it straight through instead of re-deriving a
+// raft::device_matrix/host_matrix from scratch.
+template <typename DataT, typename IdxT, typename Accessor>
+using dense_owning_matrix =
+  raft::mdarray<DataT, raft::matrix_extent<IdxT>, raft::row_major, Accessor>;
+
+template <typename DataT, typename IdxT, typename Accessor>
+using dense_view_matrix = raft::mdspan<const DataT,
+                                       raft::matrix_extent<IdxT>,
+                                       raft::row_major,
+                                       dataset_view_accessor_for_owning<DataT, Accessor>>;
+
+template <typename MathT, typename IdxT, typename Accessor>
+using vpq_vq_book_matrix =
+  raft::mdarray<MathT, raft::matrix_extent<uint32_t>, raft::row_major, Accessor>;
+
+// VPQ codes are always uint8_t regardless of MathT, so retarget the owning accessor's element
+// type instead of re-deriving a device/host matrix; residency is still driven by Accessor.
+template <typename NewT, typename Accessor>
+using owning_accessor_with_value_type = std::conditional_t<Accessor::is_device_accessible,
+                                                           device_owning_accessor<NewT>,
+                                                           host_owning_accessor<NewT>>;
+
+template <typename IdxT, typename Accessor>
+using vpq_data_matrix = raft::mdarray<uint8_t,
+                                      raft::matrix_extent<IdxT>,
+                                      raft::row_major,
+                                      owning_accessor_with_value_type<uint8_t, Accessor>>;
+
+// -----------------------------------------------------------------------------
+// empty
+// -----------------------------------------------------------------------------
+
+template <typename IdxT>
+struct empty_dataset_storage {
+  uint32_t suggested_dim{};
+  empty_dataset_storage() noexcept = default;
+  explicit empty_dataset_storage(uint32_t dim) noexcept : suggested_dim(dim) {}
+  [[nodiscard]] auto n_rows() const noexcept -> IdxT { return 0; }
+  [[nodiscard]] auto dim() const noexcept -> uint32_t { return suggested_dim; }
+};
+
+// -----------------------------------------------------------------------------
+// dense row-major (logical dim may differ from row pitch; shared by padded & standard)
+// -----------------------------------------------------------------------------
+
+/**
+ * Dense row-major owning storage shared by padded and standard dataset specs. Publicly inherits
+ * from MatrixT (a `raft::mdarray`) so `view()`/`data_handle()`/`extent()` etc. are reused as-is
+ * rather than hand-forwarded; `logical_dim_` is the only state this struct adds.
+ *
+ * Template parameters:
+ * - MatrixT: owning matrix type that stores the payload (host/device matrix).
+ * - ViewT: non-owning row-major view type returned by `view()`.
+ * - DataT: scalar element type of the dataset payload.
+ * - IdxT: index type used for row counts (`n_rows()` return type).
+ */
+template <typename MatrixT, typename ViewT, typename DataT, typename IdxT>
+struct dense_row_major_dataset_owning_storage : public MatrixT {
+  uint32_t logical_dim_;
+
+  // MatrixT (mdarray) also has its own stride(size_t); pull it back into scope since declaring
+  // our own no-arg stride() below would otherwise hide it entirely (C++ name hiding).
+  using MatrixT::stride;
+
+  dense_row_major_dataset_owning_storage(MatrixT&& data, uint32_t logical_dim) noexcept
+    : MatrixT{std::move(data)}, logical_dim_{logical_dim}
+  {
+  }
+
+  [[nodiscard]] auto n_rows() const noexcept -> IdxT { return this->extent(0); }
+  [[nodiscard]] auto dim() const noexcept -> uint32_t { return logical_dim_; }
+  [[nodiscard]] auto stride() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(this->extent(1));
+  }
+  // view() and data_handle() are inherited directly from MatrixT (raft::mdarray); no hand-written
+  // forwarding needed since MatrixT::view() const already returns exactly ViewT.
+};
+
+template <typename ViewT, typename DataT, typename IdxT>
+struct dense_row_major_dataset_view_storage : public ViewT {
+  uint32_t logical_dim_;
+
+  // ViewT (mdspan) also has its own stride(size_t); pull it back into scope since declaring our
+  // own no-arg stride() below would otherwise hide it entirely (C++ name hiding), and the body of
+  // that stride() itself needs to call the inherited one.
+  using ViewT::stride;
+
+  dense_row_major_dataset_view_storage() noexcept = default;
+
+  explicit dense_row_major_dataset_view_storage(ViewT v) noexcept
+    : ViewT(v), logical_dim_(static_cast<uint32_t>(v.extent(1)))
+  {
+  }
+
+  dense_row_major_dataset_view_storage(ViewT v, uint32_t logical_dim) noexcept
+    : ViewT(v), logical_dim_(logical_dim)
+  {
+  }
+
+  [[nodiscard]] auto n_rows() const noexcept -> IdxT { return this->extent(0); }
+  [[nodiscard]] auto dim() const noexcept -> uint32_t { return logical_dim_; }
+  [[nodiscard]] auto stride() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(ViewT::stride(0) > 0 ? ViewT::stride(0) : this->extent(1));
+  }
+};
+
+/** Spec-side implementation shared by `padded_dataset_spec`/`standard_dataset_spec`; those two
+ * stay distinct top-level types (identical bodies) purely so classification traits can tell them
+ * apart -- exactly mirroring today's `padded_dataset_container`/`standard_dataset_container`,
+ * which are likewise two differently-named tags over one shared storage implementation. */
+template <typename ContainerPolicy>
+struct dense_dataset_spec_impl {
+  template <typename T, typename IdxT>
+  struct apply {
+    using value_type = std::remove_cv_t<T>;
+    using index_type = std::remove_cv_t<IdxT>;
+    using MatrixT    = dense_owning_matrix<T, IdxT, ContainerPolicy>;
+    using ViewT      = dense_view_matrix<T, IdxT, ContainerPolicy>;
+    using data_type  = dense_row_major_dataset_owning_storage<MatrixT, ViewT, T, IdxT>;
+    using view_type  = dense_row_major_dataset_view_storage<ViewT, T, IdxT>;
+
+    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
+    {
+      return view_type(data.view(), data.dim());
+    }
+    template <typename AnyStorage>
+    [[nodiscard]] static auto get_n_rows(AnyStorage const& data) noexcept -> index_type
+    {
+      return data.n_rows();
+    }
+    template <typename AnyStorage>
+    [[nodiscard]] static auto get_dim(AnyStorage const& data) noexcept -> uint32_t
+    {
+      return data.dim();
+    }
+  };
+};
+
+// -----------------------------------------------------------------------------
+// vpq payloads: everything VPQ-specific lives here, not in dataset/dataset_view.
+// -----------------------------------------------------------------------------
+
+/** Read-only helpers derived from the codebook shapes; shared by the owning and view payloads.
+ * `Derived` provides `vq_code_book`, `pq_code_book` and the codes' `extent(r)`. */
+template <typename Derived>
+struct vpq_codebook_helpers {
+  /** Logical dimension: it comes from the VQ codebook, not from the encoded rows (row padding
+   * makes the encoded-row width ambiguous as a dimension). */
+  [[nodiscard]] auto dim() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().vq_code_book.extent(1));
+  }
+  [[nodiscard]] auto vq_n_centers() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().vq_code_book.extent(0));
+  }
+  [[nodiscard]] auto pq_n_centers() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().pq_code_book.extent(0));
+  }
+  [[nodiscard]] auto pq_len() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().pq_code_book.extent(1));
+  }
+  [[nodiscard]] auto pq_bits() const noexcept -> uint32_t
+  {
+    auto pq_width = pq_n_centers();
+#ifdef __cpp_lib_bitops
+    return std::countr_zero(pq_width);
+#else
+    uint32_t bits = 0;
+    while (pq_width > 1) {
+      bits++;
+      pq_width >>= 1;
+    }
+    return bits;
+#endif
+  }
+  [[nodiscard]] auto pq_dim() const noexcept -> uint32_t
+  {
+    return raft::div_rounding_up_unsafe(dim(), pq_len());
+  }
+  [[nodiscard]] auto encoded_row_length() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().extent(1));
+  }
+
+ private:
+  [[nodiscard]] auto self() const noexcept -> Derived const&
+  {
+    return static_cast<Derived const&>(*this);
+  }
+};
+
+/** Owning VPQ payload: the encoded rows (it *is* the `uint8_t` codes mdarray) plus the VQ and PQ
+ * codebooks. `Accessor` drives both codebook and code residency. */
+template <typename MathT, typename IdxT, typename Accessor>
+struct vpq_owning_storage : public vpq_data_matrix<IdxT, Accessor>,
+                            public vpq_codebook_helpers<vpq_owning_storage<MathT, IdxT, Accessor>> {
+  using codes_type   = vpq_data_matrix<IdxT, Accessor>;
+  using vq_book_type = vpq_vq_book_matrix<MathT, IdxT, Accessor>;
+  using pq_book_type = vpq_vq_book_matrix<MathT, IdxT, Accessor>;
+
+  vq_book_type vq_code_book;
+  pq_book_type pq_code_book;
+
+  vpq_owning_storage(codes_type&& codes, vq_book_type&& vq_codes, pq_book_type&& pq_codes) noexcept
+    : codes_type{std::move(codes)},
+      vq_code_book{std::move(vq_codes)},
+      pq_code_book{std::move(pq_codes)}
+  {
+  }
+};
+
+/** Non-owning VPQ payload: a view of the encoded rows plus views of the VQ and PQ codebooks. */
+template <typename MathT, typename IdxT, typename Accessor>
+struct vpq_view_storage : public raft::mdspan<const uint8_t,
+                                              raft::matrix_extent<IdxT>,
+                                              raft::row_major,
+                                              dataset_view_accessor_for_owning<uint8_t, Accessor>>,
+                          public vpq_codebook_helpers<vpq_view_storage<MathT, IdxT, Accessor>> {
+  using codes_view_type = raft::mdspan<const uint8_t,
+                                       raft::matrix_extent<IdxT>,
+                                       raft::row_major,
+                                       dataset_view_accessor_for_owning<uint8_t, Accessor>>;
+  using vq_book_view_type =
+    typename vpq_owning_storage<MathT, IdxT, Accessor>::vq_book_type::const_view_type;
+  using pq_book_view_type =
+    typename vpq_owning_storage<MathT, IdxT, Accessor>::pq_book_type::const_view_type;
+
+  vq_book_view_type vq_code_book;
+  pq_book_view_type pq_code_book;
+
+  vpq_view_storage() noexcept = default;
+  vpq_view_storage(codes_view_type codes,
+                   vq_book_view_type vq_codes,
+                   pq_book_view_type pq_codes) noexcept
+    : codes_view_type(codes), vq_code_book(vq_codes), pq_code_book(pq_codes)
+  {
+  }
+};
+
+}  // namespace detail
+
+// -----------------------------------------------------------------------------
+// Public specs -- the only place per-kind logic lives.
+// -----------------------------------------------------------------------------
+
+template <typename Accessor>
+struct empty_dataset_spec {
+  using accessor_type = Accessor;
+
+  template <typename T, typename IdxT>
+  struct apply {
+    using value_type = std::remove_cv_t<T>;
+    using index_type = std::remove_cv_t<IdxT>;
+    using data_type  = detail::empty_dataset_storage<IdxT>;
+    using view_type  = detail::empty_dataset_storage<IdxT>;
+
+    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
+    {
+      return data;
+    }
+    [[nodiscard]] static auto get_n_rows(data_type const& data) noexcept -> index_type
+    {
+      return static_cast<index_type>(data.n_rows());
+    }
+    [[nodiscard]] static auto get_dim(data_type const& data) noexcept -> uint32_t
+    {
+      return data.dim();
+    }
+  };
+};
+
+template <typename ContainerPolicy>
+struct padded_dataset_spec {
+  using accessor_type = ContainerPolicy;
+  template <typename T, typename IdxT>
+  struct apply : detail::dense_dataset_spec_impl<ContainerPolicy>::template apply<T, IdxT> {};
+};
+
+template <typename ContainerPolicy>
+struct standard_dataset_spec {
+  using accessor_type = ContainerPolicy;
+  template <typename T, typename IdxT>
+  struct apply : detail::dense_dataset_spec_impl<ContainerPolicy>::template apply<T, IdxT> {};
+};
+
+/** `Accessor` drives both codebook and code residency, mirroring today's
+ * single-`Accessor`-per-VPQ-dataset design. The payload (`detail::vpq_owning_storage` /
+ * `detail::vpq_view_storage`) holds the encoded rows and the VQ/PQ codebooks. */
+template <typename MathT, typename Accessor>
+struct vpq_dataset_spec {
+  using accessor_type = Accessor;
+
+  template <typename T, typename IdxT>
+  struct apply {
+    using value_type = std::remove_cv_t<T>;
+    using index_type = std::remove_cv_t<IdxT>;
+    using math_type  = MathT;
+
+    using data_type = detail::vpq_owning_storage<MathT, IdxT, Accessor>;
+    using view_type = detail::vpq_view_storage<MathT, IdxT, Accessor>;
+
+    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
+    {
+      return view_type(data.view(), data.vq_code_book.view(), data.pq_code_book.view());
+    }
+    template <typename AnyStorage>
+    [[nodiscard]] static auto get_n_rows(AnyStorage const& data) noexcept -> index_type
+    {
+      return static_cast<index_type>(data.extent(0));
+    }
+    template <typename AnyStorage>
+    [[nodiscard]] static auto get_dim(AnyStorage const& data) noexcept -> uint32_t
+    {
+      return data.dim();
+    }
+  };
+};
+
+// -----------------------------------------------------------------------------
+// dataset / dataset_view
+// -----------------------------------------------------------------------------
+
+/** Owning dataset: value-held payload (no shared_ptr -- exclusive ownership). Every member is a
+ * one-line forward to `spec_type::get_*` or to the payload; all per-kind state and logic lives in
+ * the spec's `data_type`, never inside this struct. */
+template <typename T, typename IdxT, typename SpecT>
+struct dataset {
+  using spec_type  = typename SpecT::template apply<T, IdxT>;
+  using value_type = typename spec_type::value_type;
+  using index_type = typename spec_type::index_type;
+  using data_type  = typename spec_type::data_type;
+
+  // Forward constructor args straight to data_type's own constructor (e.g. (MatrixT&&, uint32_t
+  // logical_dim) for dense, (uint32_t dim) for empty, (codes&&, vq&&, pq&&) for VPQ).
+  template <typename... Args>
+  explicit dataset(Args&&... args)
+    requires(std::is_constructible_v<data_type, Args...>)
+    : data_(std::forward<Args>(args)...)
+  {
+  }
+
+  [[nodiscard]] auto n_rows() const noexcept -> index_type { return spec_type::get_n_rows(data_); }
+  [[nodiscard]] auto dim() const noexcept -> uint32_t { return spec_type::get_dim(data_); }
+  /** The spec-defined non-owning view of the payload (for dense and VPQ it is an mdspan
+   * derivative). */
+  [[nodiscard]] auto as_matrix_view() const noexcept { return spec_type::get_data_view(data_); }
+  [[nodiscard]] auto as_dataset_view() const noexcept -> dataset_view<T, IdxT, SpecT>
+  {
+    return dataset_view<T, IdxT, SpecT>(as_matrix_view());
+  }
+
+  /** The owning payload; kind-specific state and methods are reached through it. */
+  [[nodiscard]] auto data() const noexcept -> data_type const& { return data_; }
+  [[nodiscard]] auto data() noexcept -> data_type& { return data_; }
+
+ private:
+  data_type data_;
+};
+
+/** Non-owning dataset view: holds only the view-shaped payload. Deliberately not derived from
+ * `dataset` -- a view type holds "all view state" with no inheritance and no shared ownership tying
+ * it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec functions as `dataset`, fed
+ * the view payload instead of the owning one. */
+template <typename T, typename IdxT, typename SpecT>
+struct dataset_view {
+  using spec_type  = typename SpecT::template apply<T, IdxT>;
+  using value_type = typename spec_type::value_type;
+  using index_type = typename spec_type::index_type;
+  using view_type  = typename spec_type::view_type;
+
+  dataset_view() noexcept = default;
+
+  // Already-constructed view payload -- the shape `as_dataset_view()` always constructs with, for
+  // every kind. Not a template, so it's preferred over the forwarding constructor below whenever
+  // both could apply.
+  explicit dataset_view(view_type data_view) noexcept : data_view_{data_view} {}
+
+  // Forward raw constructor args straight to view_type's own constructor (e.g. (ViewT, uint32_t
+  // logical_dim) for dense, (uint32_t dim) for empty) -- preserves today's direct-construction
+  // call sites (e.g. `device_padded_dataset_view<T,IdxT>(raw_mdspan, dim)`) unchanged.
+  template <typename... Args>
+  explicit dataset_view(Args&&... args)
+    requires(std::is_constructible_v<view_type, Args...>)
+    : data_view_(std::forward<Args>(args)...)
+  {
+  }
+
+  [[nodiscard]] auto n_rows() const noexcept -> index_type
+  {
+    return spec_type::get_n_rows(data_view_);
+  }
+  [[nodiscard]] auto dim() const noexcept -> uint32_t { return spec_type::get_dim(data_view_); }
+  [[nodiscard]] auto as_matrix_view() const noexcept -> view_type { return data_view_; }
+
+  /** The view payload; kind-specific state and methods are reached through it. */
+  [[nodiscard]] auto data() const noexcept -> view_type const& { return data_view_; }
+  [[nodiscard]] auto data() noexcept -> view_type& { return data_view_; }
+
+ private:
+  view_type data_view_{};
+};
+
+/**
+ * @brief Aliases for concrete `dataset` / `dataset_view` layouts.
+ */
+template <typename IdxT>
+using device_empty_dataset =
+  dataset<void, IdxT, empty_dataset_spec<detail::device_view_accessor<char>>>;
+
+template <typename IdxT>
+using device_empty_dataset_view =
+  dataset_view<void, IdxT, empty_dataset_spec<detail::device_view_accessor<char>>>;
+
+template <typename IdxT>
+using host_empty_dataset =
+  dataset<void, IdxT, empty_dataset_spec<detail::host_view_accessor<char>>>;
+
+template <typename IdxT>
+using host_empty_dataset_view =
+  dataset_view<void, IdxT, empty_dataset_spec<detail::host_view_accessor<char>>>;
+
+template <typename DataT, typename IdxT>
+using device_padded_dataset =
+  dataset<DataT, IdxT, padded_dataset_spec<detail::device_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using device_padded_dataset_view =
+  dataset_view<DataT, IdxT, padded_dataset_spec<detail::device_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using host_padded_dataset =
+  dataset<DataT, IdxT, padded_dataset_spec<detail::host_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using host_padded_dataset_view =
+  dataset_view<DataT, IdxT, padded_dataset_spec<detail::host_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using device_standard_dataset =
+  dataset<DataT, IdxT, standard_dataset_spec<detail::device_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using device_standard_dataset_view =
+  dataset_view<DataT, IdxT, standard_dataset_spec<detail::device_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using host_standard_dataset =
+  dataset<DataT, IdxT, standard_dataset_spec<detail::host_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using host_standard_dataset_view =
+  dataset_view<DataT, IdxT, standard_dataset_spec<detail::host_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using device_vpq_dataset =
+  dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::device_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using device_vpq_dataset_view =
+  dataset_view<DataT, IdxT, vpq_dataset_spec<DataT, detail::device_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using host_vpq_dataset =
+  dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::host_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using host_vpq_dataset_view =
+  dataset_view<DataT, IdxT, vpq_dataset_spec<DataT, detail::host_owning_accessor<DataT>>>;
+
+// Maps a dataset view type to its owning (allocating) dataset counterpart. Trivial and total under
+// the Spec design: the owning type for `dataset_view<T,IdxT,SpecT>` is always
+// `dataset<T,IdxT,SpecT>`
+// -- no per-kind specialization table needed (unlike the old Container-tagged design).
+template <typename DatasetViewT>
+struct owning_dataset_for_view;
+
+template <typename T, typename IdxT, typename SpecT>
+struct owning_dataset_for_view<dataset_view<T, IdxT, SpecT>> {
+  using type = dataset<T, IdxT, SpecT>;
+};
+
+template <typename DatasetViewT>
+using owning_dataset_for_view_t = typename owning_dataset_for_view<DatasetViewT>::type;
+
+// -----------------------------------------------------------------------------
+// Spec-kind classification (all derived from SpecT; dataset/dataset_view never branch on kind).
+// -----------------------------------------------------------------------------
+
+template <typename SpecT>
+struct is_empty_spec : std::false_type {};
+template <typename Accessor>
+struct is_empty_spec<empty_dataset_spec<Accessor>> : std::true_type {};
+template <typename SpecT>
+inline constexpr bool is_empty_spec_v = is_empty_spec<SpecT>::value;
+
+template <typename SpecT>
+struct is_padded_spec : std::false_type {};
+template <typename ContainerPolicy>
+struct is_padded_spec<padded_dataset_spec<ContainerPolicy>> : std::true_type {};
+template <typename SpecT>
+inline constexpr bool is_padded_spec_v = is_padded_spec<SpecT>::value;
+
+template <typename SpecT>
+struct is_standard_spec : std::false_type {};
+template <typename ContainerPolicy>
+struct is_standard_spec<standard_dataset_spec<ContainerPolicy>> : std::true_type {};
+template <typename SpecT>
+inline constexpr bool is_standard_spec_v = is_standard_spec<SpecT>::value;
+
+template <typename SpecT>
+struct is_vpq_spec : std::false_type {};
+template <typename MathT, typename Accessor>
+struct is_vpq_spec<vpq_dataset_spec<MathT, Accessor>> : std::true_type {};
+template <typename SpecT>
+inline constexpr bool is_vpq_spec_v = is_vpq_spec<SpecT>::value;
+
+template <typename SpecT>
+struct vpq_spec_math_type {};
+template <typename MathT, typename Accessor>
+struct vpq_spec_math_type<vpq_dataset_spec<MathT, Accessor>> {
+  using type = MathT;
+};
+template <typename SpecT>
+using vpq_spec_math_type_t = typename vpq_spec_math_type<SpecT>::type;
+
+/** Owning-side kind traits (mirror today's `is_padded_dataset_v`/`is_standard_dataset_v`/
+ * `is_vpq_dataset_v`, used for SFINAE overload selection in factory.cuh/compute_distance_vpq.hpp).
+ */
+template <typename DatasetT>
+struct is_padded_dataset : std::false_type {};
+template <typename T, typename IdxT, typename SpecT>
+struct is_padded_dataset<dataset<T, IdxT, SpecT>> : std::bool_constant<is_padded_spec_v<SpecT>> {};
+template <typename T, typename IdxT, typename SpecT>
+struct is_padded_dataset<dataset_view<T, IdxT, SpecT>>
+  : std::bool_constant<is_padded_spec_v<SpecT>> {};
+template <typename DatasetT>
+inline constexpr bool is_padded_dataset_v = is_padded_dataset<DatasetT>::value;
+
+template <typename DatasetT>
+struct is_standard_dataset : std::false_type {};
+template <typename T, typename IdxT, typename SpecT>
+struct is_standard_dataset<dataset<T, IdxT, SpecT>>
+  : std::bool_constant<is_standard_spec_v<SpecT>> {};
+template <typename T, typename IdxT, typename SpecT>
+struct is_standard_dataset<dataset_view<T, IdxT, SpecT>>
+  : std::bool_constant<is_standard_spec_v<SpecT>> {};
+template <typename DatasetT>
+inline constexpr bool is_standard_dataset_v = is_standard_dataset<DatasetT>::value;
+
+template <typename DatasetT>
+struct is_vpq_dataset : std::false_type {};
+template <typename T, typename IdxT, typename SpecT>
+struct is_vpq_dataset<dataset<T, IdxT, SpecT>> : std::bool_constant<is_vpq_spec_v<SpecT>> {};
+template <typename DatasetT>
+inline constexpr bool is_vpq_dataset_v = is_vpq_dataset<DatasetT>::value;
+
+// -----------------------------------------------------------------------------
+// Dataset view compile-time classification (replaces runtime std::variant dispatch).
+// -----------------------------------------------------------------------------
+
+/** Any non-owning dataset view exposing row count and logical dimension. */
+template <typename V, typename IdxT = int64_t>
+concept ann_dataset_view = requires(V const& v) {
+  { v.n_rows() } -> std::convertible_to<IdxT>;
+  { v.dim() } -> std::convertible_to<uint32_t>;
+};
+
+enum class dataset_view_kind {
+  // TODO(removal): Remove `unknown` once all deprecated host_matrix_view / device_matrix_view /
+  // mdspan overloads are deleted. It exists solely so that overload resolution on the deprecated
+  // build(host_matrix_view) / build(device_matrix_view) shims does not cause a hard error when
+  // the compiler evaluates is_host/device_dataset_view_v for a plain mdspan type.
+  unknown,
+  empty,
+  padded,
+  standard,
+  vpq_f16,
+  vpq_f32,
+  bbq,
+};
+
+template <typename V>
+using dataset_view_type_t = std::remove_cvref_t<V>;
+
+/** Primary template returns `unknown` so traits safely return `false` for non-dataset-view types.
+ */
+template <typename V>
+struct dataset_view_kind_of {
+  static constexpr dataset_view_kind value = dataset_view_kind::unknown;
+};
+
+template <typename T, typename IdxT, typename SpecT>
+struct dataset_view_kind_of<dataset_view<T, IdxT, SpecT>> {
+  static constexpr dataset_view_kind value = []() constexpr {
+    if constexpr (is_empty_spec_v<SpecT>) {
+      return dataset_view_kind::empty;
+    } else if constexpr (is_padded_spec_v<SpecT>) {
+      return dataset_view_kind::padded;
+    } else if constexpr (is_standard_spec_v<SpecT>) {
+      return dataset_view_kind::standard;
+    } else if constexpr (is_vpq_spec_v<SpecT>) {
+      static_assert(std::is_same_v<vpq_spec_math_type_t<SpecT>, half> ||
+                      std::is_same_v<vpq_spec_math_type_t<SpecT>, float>,
+                    "VPQ dataset_view_kind_of expects MathT to be half or float");
+      return std::is_same_v<vpq_spec_math_type_t<SpecT>, half> ? dataset_view_kind::vpq_f16
+                                                               : dataset_view_kind::vpq_f32;
+    } else {
+      return dataset_view_kind::unknown;
+    }
+  }();
+};
+
+/** True when the dataset view accessor is device-accessible. */
+template <typename V>
+struct dataset_view_is_device_accessible : std::false_type {};
+
+template <typename T, typename IdxT, typename SpecT>
+struct dataset_view_is_device_accessible<dataset_view<T, IdxT, SpecT>>
+  : std::bool_constant<SpecT::accessor_type::is_device_accessible> {};
+
+template <typename V>
+inline constexpr bool dataset_view_is_device_accessible_v =
+  dataset_view_is_device_accessible<dataset_view_type_t<V>>::value;
+
+template <typename V>
+inline constexpr dataset_view_kind dataset_view_kind_v =
+  dataset_view_kind_of<dataset_view_type_t<V>>::value;
+
+template <typename V>
+inline constexpr bool is_device_empty_dataset_view_v =
+  dataset_view_kind_v<V> == dataset_view_kind::empty && dataset_view_is_device_accessible_v<V>;
+
+template <typename V>
+inline constexpr bool is_host_empty_dataset_view_v =
+  dataset_view_kind_v<V> == dataset_view_kind::empty && !dataset_view_is_device_accessible_v<V>;
+
+/** True for any empty dataset view (device or host). */
+template <typename V>
+inline constexpr bool is_empty_dataset_view_v =
+  is_device_empty_dataset_view_v<V> || is_host_empty_dataset_view_v<V>;
+
+template <typename V>
+inline constexpr bool is_device_padded_dataset_view_v =
+  dataset_view_kind_v<V> == dataset_view_kind::padded && dataset_view_is_device_accessible_v<V>;
+
+template <typename V>
+inline constexpr bool is_host_padded_dataset_view_v =
+  dataset_view_kind_v<V> == dataset_view_kind::padded && !dataset_view_is_device_accessible_v<V>;
+
+/** True for either `device_padded_dataset_view` or `host_padded_dataset_view`. */
+template <typename V>
+inline constexpr bool is_padded_dataset_view_v =
+  is_device_padded_dataset_view_v<V> || is_host_padded_dataset_view_v<V>;
+
+template <typename V>
+inline constexpr bool is_device_standard_dataset_view_v =
+  dataset_view_kind_v<V> == dataset_view_kind::standard && dataset_view_is_device_accessible_v<V>;
+
+template <typename V>
+inline constexpr bool is_host_standard_dataset_view_v =
+  dataset_view_kind_v<V> == dataset_view_kind::standard && !dataset_view_is_device_accessible_v<V>;
+
+/** True for either `device_standard_dataset_view` or `host_standard_dataset_view`. */
+template <typename V>
+inline constexpr bool is_standard_dataset_view_v =
+  is_device_standard_dataset_view_v<V> || is_host_standard_dataset_view_v<V>;
+
+template <typename V>
+inline constexpr bool is_device_vpq_f16_dataset_view_v =
+  dataset_view_kind_v<V> == dataset_view_kind::vpq_f16 && dataset_view_is_device_accessible_v<V>;
+
+template <typename V>
+inline constexpr bool is_host_vpq_f16_dataset_view_v =
+  dataset_view_kind_v<V> == dataset_view_kind::vpq_f16 && !dataset_view_is_device_accessible_v<V>;
+
+template <typename V>
+inline constexpr bool is_vpq_f16_dataset_view_v =
+  is_device_vpq_f16_dataset_view_v<V> || is_host_vpq_f16_dataset_view_v<V>;
+
+template <typename V>
+inline constexpr bool is_device_vpq_f32_dataset_view_v =
+  dataset_view_kind_v<V> == dataset_view_kind::vpq_f32 && dataset_view_is_device_accessible_v<V>;
+
+template <typename V>
+inline constexpr bool is_host_vpq_f32_dataset_view_v =
+  dataset_view_kind_v<V> == dataset_view_kind::vpq_f32 && !dataset_view_is_device_accessible_v<V>;
+
+template <typename V>
+inline constexpr bool is_vpq_f32_dataset_view_v =
+  is_device_vpq_f32_dataset_view_v<V> || is_host_vpq_f32_dataset_view_v<V>;
+
+template <typename V>
+inline constexpr bool is_device_vpq_dataset_view_v =
+  is_device_vpq_f16_dataset_view_v<V> || is_device_vpq_f32_dataset_view_v<V>;
+
+template <typename V>
+inline constexpr bool is_host_vpq_dataset_view_v =
+  is_host_vpq_f16_dataset_view_v<V> || is_host_vpq_f32_dataset_view_v<V>;
+
+template <typename V>
+inline constexpr bool is_vpq_dataset_view_v =
+  is_device_vpq_dataset_view_v<V> || is_host_vpq_dataset_view_v<V>;
+
+/** True for any device-resident dataset view. */
+template <typename V>
+inline constexpr bool is_device_dataset_view_v =
+  dataset_view_kind_v<V> != dataset_view_kind::unknown && dataset_view_is_device_accessible_v<V>;
+
+/** True for any host-resident dataset view. */
+template <typename V>
+inline constexpr bool is_host_dataset_view_v =
+  dataset_view_kind_v<V> != dataset_view_kind::unknown && !dataset_view_is_device_accessible_v<V>;
+
+/**
+ * True when a host view `H` and device view `D` represent the same storage kind and differ
+ * only in residency (host vs. device). Used by host/device conversion helpers.
+ */
+template <typename HostViewT, typename DeviceViewT>
+inline constexpr bool compatible_host_device_dataset_views_v =
+  is_host_dataset_view_v<HostViewT> && is_device_dataset_view_v<DeviceViewT> &&
+  (dataset_view_kind_v<HostViewT> == dataset_view_kind_v<DeviceViewT>);
+
+/**
+ * Generic accessor retargeting while preserving the dataset tag/layout and value/index types:
+ * `dataset<T, IdxT, SpecT<..., OldAccessor>>      -> dataset<T, IdxT, SpecT<..., NewAccessor>>`
+ * `dataset_view<T, IdxT, SpecT<..., OldAccessor>> -> dataset_view<T, IdxT, SpecT<...,
+ * NewAccessor>>`
+ */
+template <typename DatasetLikeT, typename NewAccessor>
+struct with_accessor;
+
+template <typename T, typename IdxT, typename NewAccessor>
+struct with_accessor<dataset<T, IdxT, empty_dataset_spec<NewAccessor>>, NewAccessor> {
+  using type = dataset<T, IdxT, empty_dataset_spec<NewAccessor>>;
+};
+
+template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset<T, IdxT, padded_dataset_spec<OldAccessor>>, NewAccessor> {
+  using type = dataset<T, IdxT, padded_dataset_spec<NewAccessor>>;
+};
+
+template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset<T, IdxT, standard_dataset_spec<OldAccessor>>, NewAccessor> {
+  using type = dataset<T, IdxT, standard_dataset_spec<NewAccessor>>;
+};
+
+template <typename T, typename IdxT, typename MathT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset<T, IdxT, vpq_dataset_spec<MathT, OldAccessor>>, NewAccessor> {
+  using type = dataset<T, IdxT, vpq_dataset_spec<MathT, NewAccessor>>;
+};
+
+template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset_view<T, IdxT, empty_dataset_spec<OldAccessor>>, NewAccessor> {
+  using type = dataset_view<T, IdxT, empty_dataset_spec<NewAccessor>>;
+};
+
+template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset_view<T, IdxT, padded_dataset_spec<OldAccessor>>, NewAccessor> {
+  using type = dataset_view<T, IdxT, padded_dataset_spec<NewAccessor>>;
+};
+
+template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset_view<T, IdxT, standard_dataset_spec<OldAccessor>>, NewAccessor> {
+  using type = dataset_view<T, IdxT, standard_dataset_spec<NewAccessor>>;
+};
+
+template <typename T, typename IdxT, typename MathT, typename OldAccessor, typename NewAccessor>
+struct with_accessor<dataset_view<T, IdxT, vpq_dataset_spec<MathT, OldAccessor>>, NewAccessor> {
+  using type = dataset_view<T, IdxT, vpq_dataset_spec<MathT, NewAccessor>>;
+};
+
+template <typename DatasetLikeT, typename NewAccessor>
+using with_accessor_t =
+  typename with_accessor<dataset_view_type_t<DatasetLikeT>, NewAccessor>::type;
+
+/** Map any host accessor to its device counterpart (same payload policy). */
+template <typename Accessor>
+struct to_device_accessor {
+  using type = Accessor;
+};
+
+template <typename T>
+struct to_device_accessor<detail::host_view_accessor<T>> {
+  using type = detail::device_view_accessor<T>;
+};
+
+template <typename T>
+struct to_device_accessor<detail::host_owning_accessor<T>> {
+  using type = detail::device_owning_accessor<T>;
+};
+
+template <typename Accessor>
+using to_device_accessor_t = typename to_device_accessor<Accessor>::type;
+
+/** Maps a host dataset view type to its device-resident counterpart. */
+template <typename HostViewT>
+struct device_counterpart;
+
+template <typename T, typename IdxT, typename SpecT>
+struct device_counterpart<dataset_view<T, IdxT, SpecT>> {
+  using type = with_accessor_t<dataset_view<T, IdxT, SpecT>,
+                               to_device_accessor_t<typename SpecT::accessor_type>>;
+};
+
+template <typename HostViewT>
+using device_counterpart_t = typename device_counterpart<dataset_view_type_t<HostViewT>>::type;
+
+/** True for device padded or standard views accepted by dense graph build (VPQ excluded). */
+template <typename V>
+inline constexpr bool is_dense_row_major_device_dataset_view_v =
+  is_device_padded_dataset_view_v<V> || is_device_standard_dataset_view_v<V>;
+
+/** True for host or device padded/standard views (dense graph build; VPQ excluded). */
+template <typename V>
+inline constexpr bool is_dense_row_major_dataset_view_v =
+  is_padded_dataset_view_v<V> || is_standard_dataset_view_v<V>;
+
+/** Element type `T` for `cagra::build(res, params, dataset_view)` (deduced, not a template arg).
+ * Trivial under the Spec design: every `dataset_view<T,IdxT,SpecT>` already carries `T` directly.
+ */
+template <typename V>
+using cagra_view_element_type_t = typename dataset_view_type_t<V>::value_type;
+
+// -----------------------------------------------------------------------------
+// CAGRA row width in elements (same for make_device_padded_dataset* and index layout checks).
+// -----------------------------------------------------------------------------
+
+/**
+ * @brief Required row width in elements for CAGRA: minimum leading dimension (LDA) per row for the
+ *        default per-row byte alignment (16 bytes, combined with `sizeof` element type), given
+ *        `logical_columns` feature columns.
+ */
+[[nodiscard]] inline uint32_t cagra_required_row_width(uint32_t logical_columns,
+                                                       std::size_t sizeof_value,
+                                                       uint32_t align_bytes = 16)
+{
+  return static_cast<uint32_t>(
+    raft::round_up_safe<std::size_t>(static_cast<std::size_t>(logical_columns) * sizeof_value,
+                                     std::lcm(align_bytes, static_cast<uint32_t>(sizeof_value))) /
+    sizeof_value);
+}
+
+template <typename ValueT>
+[[nodiscard]] inline uint32_t cagra_required_row_width(uint32_t logical_columns,
+                                                       uint32_t align_bytes = 16)
+{
+  return cagra_required_row_width(logical_columns, sizeof(ValueT), align_bytes);
+}
+
+/** Actual row width in elements (leading dimension) of a 2D row-major matrix view. */
+template <typename T, typename I, typename L>
+[[nodiscard]] inline uint32_t matrix_actual_row_width(raft::device_matrix_view<T, I, L> m)
+{
+  return m.stride(0) > 0 ? static_cast<uint32_t>(m.stride(0)) : static_cast<uint32_t>(m.extent(1));
+}
+
+template <typename T, typename I, typename L>
+[[nodiscard]] inline uint32_t matrix_actual_row_width(raft::host_matrix_view<T, I, L> m)
+{
+  return m.stride(0) > 0 ? static_cast<uint32_t>(m.stride(0)) : static_cast<uint32_t>(m.extent(1));
+}
+
+/**
+ * @brief True if the matrix's row width in elements matches `cagra_required_row_width` for
+ *        `m.extent(1)` and element type `T` (CAGRA row layout is satisfied for this view).
+ */
+template <typename T, typename I, typename L>
+[[nodiscard]] inline bool matrix_row_width_matches_cagra_required(
+  raft::device_matrix_view<T, I, L> m, uint32_t align_bytes = 16)
+{
+  using value_type = std::remove_const_t<T>;
+  const uint32_t need =
+    cagra_required_row_width<value_type>(static_cast<uint32_t>(m.extent(1)), align_bytes);
+  return matrix_actual_row_width(m) == need;
+}
+
+template <typename T, typename I, typename L>
+[[nodiscard]] inline bool matrix_row_width_matches_cagra_required(raft::host_matrix_view<T, I, L> m,
+                                                                  uint32_t align_bytes = 16)
+{
+  using value_type = std::remove_const_t<T>;
+  const uint32_t need =
+    cagra_required_row_width<value_type>(static_cast<uint32_t>(m.extent(1)), align_bytes);
+  return matrix_actual_row_width(m) == need;
+}
+
+namespace detail {
+
+template <typename SrcT>
+[[nodiscard]] inline uint32_t mdspan_row_stride_elements(SrcT const& src)
+{
+  return src.stride(0) > 0 ? static_cast<uint32_t>(src.stride(0))
+                           : static_cast<uint32_t>(src.extent(1));
+}
+
+template <typename ValueT, typename SrcT>
+[[nodiscard]] inline ValueT* expect_device_accessible_data_handle(SrcT const& src,
+                                                                  char const* error_msg)
+{
+  cudaPointerAttributes ptr_attrs;
+  RAFT_CUDA_TRY(cudaPointerGetAttributes(&ptr_attrs, src.data_handle()));
+  // `devicePointer` is relative to the *current* device: it is null for an allocation owned by
+  // another device without peer access, even though that allocation is perfectly usable once the
+  // caller switches to the owning device (as the multi-GPU paths do). Accept device and managed
+  // allocations on their own merit and only consult `devicePointer` for host memory, which needs a
+  // mapping to be reachable at all.
+  if (ptr_attrs.type == cudaMemoryTypeDevice || ptr_attrs.type == cudaMemoryTypeManaged) {
+    return const_cast<ValueT*>(src.data_handle());
+  }
+  auto* device_ptr = reinterpret_cast<ValueT*>(ptr_attrs.devicePointer);
+  RAFT_EXPECTS(device_ptr != nullptr, "%s", error_msg);
+  return device_ptr;
+}
+
+template <typename ValueT, typename IndexT, typename ViewT, typename SrcT>
+[[nodiscard]] inline ViewT make_device_dense_row_major_view_from_src(SrcT const& src,
+                                                                     uint32_t logical_dim)
+{
+  auto* device_ptr = expect_device_accessible_data_handle<ValueT>(
+    src, "make_device_*_dataset_view: source must be device-accessible.");
+  auto v = raft::make_device_matrix_view(
+    device_ptr, src.extent(0), static_cast<IndexT>(mdspan_row_stride_elements(src)));
+  return ViewT(v, logical_dim);
+}
+
+template <typename ValueT, typename IndexT, typename ViewT, typename SrcT>
+[[nodiscard]] inline ViewT make_host_dense_row_major_view_from_src(SrcT const& src,
+                                                                   uint32_t logical_dim)
+{
+  RAFT_EXPECTS(raft::get_device_for_address(src.data_handle()) == -1,
+               "make_host_*_dataset_view: source must be host-accessible.");
+  auto v = raft::make_host_matrix_view(const_cast<ValueT*>(src.data_handle()),
+                                       src.extent(0),
+                                       static_cast<IndexT>(mdspan_row_stride_elements(src)));
+  return ViewT(v, logical_dim);
+}
+
+template <typename DatasetT, typename ValueT, typename IndexT, typename SrcT>
+auto make_device_dense_row_major_dataset_from_src(raft::resources const& res,
+                                                  SrcT const& src,
+                                                  uint32_t logical_dim,
+                                                  uint32_t target_stride,
+                                                  char const* view_factory_name)
+  -> std::unique_ptr<DatasetT>
+{
+  uint32_t const src_stride = mdspan_row_stride_elements(src);
+  RAFT_EXPECTS(logical_dim <= target_stride,
+               "logical dim (%u) must not exceed row stride (%u).",
+               static_cast<unsigned>(logical_dim),
+               static_cast<unsigned>(target_stride));
+  RAFT_EXPECTS(static_cast<uint32_t>(src.extent(1)) <= target_stride,
+               "Source row length must not exceed required stride.");
+  cudaPointerAttributes ptr_attrs;
+  RAFT_CUDA_TRY(cudaPointerGetAttributes(&ptr_attrs, src.data_handle()));
+  bool const device_src =
+    (ptr_attrs.type == cudaMemoryTypeDevice) || (ptr_attrs.type == cudaMemoryTypeManaged);
+  if (device_src && src_stride == target_stride) {
+    RAFT_EXPECTS(false,
+                 "source is device and stride is already correct. "
+                 "Use %s() to get a view instead.",
+                 view_factory_name);
+  }
+  auto out_array = raft::make_device_matrix<ValueT, IndexT>(res, src.extent(0), target_stride);
+  RAFT_CUDA_TRY(cudaMemsetAsync(out_array.data_handle(),
+                                0,
+                                out_array.size() * sizeof(ValueT),
+                                raft::resource::get_cuda_stream(res).get()));
+  raft::copy_matrix(out_array.data_handle(),
+                    target_stride,
+                    src.data_handle(),
+                    src_stride,
+                    logical_dim,
+                    src.extent(0),
+                    raft::resource::get_cuda_stream(res));
+  return std::make_unique<DatasetT>(std::move(out_array), logical_dim);
+}
+
+template <typename DatasetT, typename ValueT, typename IndexT, typename SrcT>
+auto make_host_dense_row_major_dataset_from_src(raft::resources const& res,
+                                                SrcT const& src,
+                                                uint32_t logical_dim,
+                                                uint32_t target_stride,
+                                                char const* view_factory_name)
+  -> std::unique_ptr<DatasetT>
+{
+  uint32_t const src_stride = mdspan_row_stride_elements(src);
+  constexpr bool device_src = SrcT::accessor_type::is_device_accessible;
+  RAFT_EXPECTS(logical_dim <= target_stride,
+               "logical dim (%u) must not exceed row stride (%u).",
+               static_cast<unsigned>(logical_dim),
+               static_cast<unsigned>(target_stride));
+  if (!device_src && src_stride == target_stride) {
+    RAFT_EXPECTS(false,
+                 "source stride is already correct. Use %s() to get a view instead.",
+                 view_factory_name);
+  }
+  RAFT_EXPECTS(static_cast<uint32_t>(src.extent(1)) <= target_stride,
+               "Source row length must not exceed required stride.");
+  auto out_array = raft::make_host_matrix<ValueT, IndexT>(src.extent(0), target_stride);
+  std::memset(out_array.data_handle(), 0, out_array.size() * sizeof(ValueT));
+  raft::copy_matrix(out_array.data_handle(),
+                    target_stride,
+                    src.data_handle(),
+                    src_stride,
+                    logical_dim,
+                    src.extent(0),
+                    raft::resource::get_cuda_stream(res));
+  if (device_src) { raft::resource::sync_stream(res); }
+  return std::make_unique<DatasetT>(std::move(out_array), logical_dim);
+}
+
+}  // namespace detail
+
+template <typename SrcT>
+auto make_device_padded_dataset_view(const raft::resources& res,
+                                     SrcT const& src,
+                                     uint32_t align_bytes = 16)
+  -> device_padded_dataset_view<typename SrcT::value_type, typename SrcT::index_type>
+{
+  using value_type = typename SrcT::value_type;
+  using index_type = typename SrcT::index_type;
+  uint32_t required_stride =
+    cagra_required_row_width<value_type>(static_cast<uint32_t>(src.extent(1)), align_bytes);
+  RAFT_EXPECTS(
+    detail::mdspan_row_stride_elements(src) == required_stride,
+    "make_device_padded_dataset_view: stride is incorrect (required stride for alignment). "
+    "Use make_device_padded_dataset() to get an owning padded copy.");
+  return detail::make_device_dense_row_major_view_from_src<
+    value_type,
+    index_type,
+    device_padded_dataset_view<value_type, index_type>>(src, static_cast<uint32_t>(src.extent(1)));
+}
+
+template <typename SrcT>
+auto make_device_padded_dataset(const raft::resources& res,
+                                SrcT const& src,
+                                uint32_t align_bytes = 16)
+  -> std::unique_ptr<device_padded_dataset<typename SrcT::value_type, typename SrcT::index_type>>
+{
+  using value_type               = typename SrcT::value_type;
+  using index_type               = typename SrcT::index_type;
+  uint32_t const logical_dim     = static_cast<uint32_t>(src.extent(1));
+  uint32_t const required_stride = cagra_required_row_width<value_type>(logical_dim, align_bytes);
+  return detail::make_device_dense_row_major_dataset_from_src<
+    device_padded_dataset<value_type, index_type>,
+    value_type,
+    index_type>(res, src, logical_dim, required_stride, "make_device_padded_dataset_view");
+}
+
+template <typename SrcT>
+auto make_host_padded_dataset_view(SrcT const& src, uint32_t align_bytes = 16)
+  -> host_padded_dataset_view<typename SrcT::value_type, typename SrcT::index_type>
+{
+  using value_type = typename SrcT::value_type;
+  using index_type = typename SrcT::index_type;
+  uint32_t required_stride =
+    cagra_required_row_width<value_type>(static_cast<uint32_t>(src.extent(1)), align_bytes);
+  RAFT_EXPECTS(
+    detail::mdspan_row_stride_elements(src) == required_stride,
+    "make_host_padded_dataset_view: stride is incorrect (required stride for alignment). "
+    "Use make_host_padded_dataset() to get an owning padded copy.");
+  return detail::make_host_dense_row_major_view_from_src<
+    value_type,
+    index_type,
+    host_padded_dataset_view<value_type, index_type>>(src, static_cast<uint32_t>(src.extent(1)));
+}
+
+template <typename SrcT>
+auto make_host_padded_dataset(const raft::resources& res,
+                              SrcT const& src,
+                              uint32_t align_bytes = 16)
+  -> std::unique_ptr<host_padded_dataset<typename SrcT::value_type, typename SrcT::index_type>>
+{
+  using value_type               = typename SrcT::value_type;
+  using index_type               = typename SrcT::index_type;
+  uint32_t const logical_dim     = static_cast<uint32_t>(src.extent(1));
+  uint32_t const required_stride = cagra_required_row_width<value_type>(logical_dim, align_bytes);
+  return detail::make_host_dense_row_major_dataset_from_src<
+    host_padded_dataset<value_type, index_type>,
+    value_type,
+    index_type>(res, src, logical_dim, required_stride, "make_host_padded_dataset_view");
+}
+
+template <typename SrcT>
+auto make_device_standard_dataset_view(SrcT const& src)
+  -> device_standard_dataset_view<typename SrcT::value_type, typename SrcT::index_type>
+{
+  using value_type = typename SrcT::value_type;
+  using index_type = typename SrcT::index_type;
+  return detail::make_device_dense_row_major_view_from_src<
+    value_type,
+    index_type,
+    device_standard_dataset_view<value_type, index_type>>(src,
+                                                          static_cast<uint32_t>(src.extent(1)));
+}
+
+/**
+ * @brief Create an owning device standard dataset with explicit row layout.
+ *
+ * Internal use only: the sole call site today is
+ * `cuvs::neighbors::detail::deserialize_standard()` in `dataset_serialize.hpp`, which must pass
+ * wire-format `(logical_dim, stride)` because the deserialized host buffer is tight `[n_rows x
+ * dim]` while the on-disk stride may be larger. Do not call from user code; prefer
+ * `make_device_standard_dataset_view()` when wrapping existing correctly-strided storage.
+ */
+template <typename SrcT>
+auto make_device_standard_dataset(const raft::resources& res,
+                                  SrcT const& src,
+                                  uint32_t logical_dim,
+                                  uint32_t target_stride)
+  -> std::unique_ptr<device_standard_dataset<typename SrcT::value_type, typename SrcT::index_type>>
+{
+  using value_type = typename SrcT::value_type;
+  using index_type = typename SrcT::index_type;
+  return detail::make_device_dense_row_major_dataset_from_src<
+    device_standard_dataset<value_type, index_type>,
+    value_type,
+    index_type>(res, src, logical_dim, target_stride, "make_device_standard_dataset_view");
+}
+
+template <typename SrcT>
+auto make_host_standard_dataset_view(SrcT const& src)
+  -> host_standard_dataset_view<typename SrcT::value_type, typename SrcT::index_type>
+{
+  using value_type = typename SrcT::value_type;
+  using index_type = typename SrcT::index_type;
+  return detail::make_host_dense_row_major_view_from_src<
+    value_type,
+    index_type,
+    host_standard_dataset_view<value_type, index_type>>(src, static_cast<uint32_t>(src.extent(1)));
+}
+
+}  // namespace neighbors
+}  // namespace CUVS_EXPORT cuvs
diff --git a/cpp/include/cuvs/neighbors/common.hpp b/cpp/include/cuvs/neighbors/common.hpp
index ecfce392e4..f23bc8ea95 100644
--- a/cpp/include/cuvs/neighbors/common.hpp
+++ b/cpp/include/cuvs/neighbors/common.hpp
@@ -24,6 +24,7 @@
 
 #include <cuvs/core/bitmap.hpp>
 #include <cuvs/core/bitset.hpp>
+#include <cuvs/core/dataset.hpp>
 #include <cuvs/core/export.hpp>
 #include <raft/core/detail/macros.hpp>
 
@@ -150,1194 +151,6 @@ enum class MergeStrategy {
 
 /** @} */  // end group neighbors_index
 
-/**
- * @brief Spec-based `dataset` / `dataset_view`.
- *
- * `dataset<T,IdxT,SpecT>` and `dataset_view<T,IdxT,SpecT>` are single generic templates that know
- * nothing about any particular kind of dataset. They hold exactly one payload (`data_type` /
- * `view_type`, chosen by the spec) and expose only what every dataset has: `n_rows()`, `dim()`,
- * `as_matrix_view()`, `as_dataset_view()` and `data()`. Each is a one-line forward to one of the
- * three spec functions `get_data_view()`, `get_n_rows()` and `get_dim()`. Anything else a kind
- * needs (e.g. VPQ codebooks, BBQ quantizers) is state and methods of that kind's payload type,
- * reached through `data()`; `dataset`/`dataset_view` never name or branch on it. `dataset` and
- * `dataset_view` are deliberately two independent, non-inheriting types (no shared_ptr, no
- * "sometimes owning" object): `dataset` holds the owning payload, `dataset_view` the
- * corresponding non-owning payload.
- */
-
-template <typename T, typename IdxT, typename SpecT>
-struct dataset;
-
-template <typename T, typename IdxT, typename SpecT>
-struct dataset_view;
-
-namespace detail {
-
-// Default owning/view accessors for public dataset aliases.
-template <typename T>
-using device_owning_accessor = raft::device_accessor<raft::device_container_policy<T>>;
-
-template <typename T>
-using host_owning_accessor = raft::host_accessor<raft::host_container_policy<T>>;
-
-template <typename T>
-using device_view_accessor = raft::device_accessor<cuda::std::default_accessor<const T>>;
-
-template <typename T>
-using host_view_accessor = raft::host_accessor<cuda::std::default_accessor<const T>>;
-
-/** View accessor paired with an owning dataset accessor (same residency). */
-template <typename DataT, typename Accessor>
-using dataset_view_accessor_for_owning = std::conditional_t<Accessor::is_device_accessible,
-                                                            device_view_accessor<DataT>,
-                                                            host_view_accessor<DataT>>;
-
-/** Owning accessor paired with a view accessor (same residency). */
-template <typename DataT, typename Accessor>
-using dataset_owning_accessor_for_view = std::conditional_t<Accessor::is_device_accessible,
-                                                            device_owning_accessor<DataT>,
-                                                            host_owning_accessor<DataT>>;
-
-// Accessor here is already device_owning_accessor<DataT> / host_owning_accessor<DataT> at every
-// call site -- exactly the container policy raft::device_mdarray/host_mdarray default to for
-// element type DataT -- so pass it straight through instead of re-deriving a
-// raft::device_matrix/host_matrix from scratch.
-template <typename DataT, typename IdxT, typename Accessor>
-using dense_owning_matrix =
-  raft::mdarray<DataT, raft::matrix_extent<IdxT>, raft::row_major, Accessor>;
-
-template <typename DataT, typename IdxT, typename Accessor>
-using dense_view_matrix = raft::mdspan<const DataT,
-                                       raft::matrix_extent<IdxT>,
-                                       raft::row_major,
-                                       dataset_view_accessor_for_owning<DataT, Accessor>>;
-
-template <typename MathT, typename IdxT, typename Accessor>
-using vpq_vq_book_matrix =
-  raft::mdarray<MathT, raft::matrix_extent<uint32_t>, raft::row_major, Accessor>;
-
-// VPQ codes are always uint8_t regardless of MathT, so retarget the owning accessor's element
-// type instead of re-deriving a device/host matrix; residency is still driven by Accessor.
-template <typename NewT, typename Accessor>
-using owning_accessor_with_value_type = std::conditional_t<Accessor::is_device_accessible,
-                                                           device_owning_accessor<NewT>,
-                                                           host_owning_accessor<NewT>>;
-
-template <typename IdxT, typename Accessor>
-using vpq_data_matrix = raft::mdarray<uint8_t,
-                                      raft::matrix_extent<IdxT>,
-                                      raft::row_major,
-                                      owning_accessor_with_value_type<uint8_t, Accessor>>;
-
-// -----------------------------------------------------------------------------
-// empty
-// -----------------------------------------------------------------------------
-
-template <typename IdxT>
-struct empty_dataset_storage {
-  uint32_t suggested_dim{};
-  empty_dataset_storage() noexcept = default;
-  explicit empty_dataset_storage(uint32_t dim) noexcept : suggested_dim(dim) {}
-  [[nodiscard]] auto n_rows() const noexcept -> IdxT { return 0; }
-  [[nodiscard]] auto dim() const noexcept -> uint32_t { return suggested_dim; }
-};
-
-// -----------------------------------------------------------------------------
-// dense row-major (logical dim may differ from row pitch; shared by padded & standard)
-// -----------------------------------------------------------------------------
-
-/**
- * Dense row-major owning storage shared by padded and standard dataset specs. Publicly inherits
- * from MatrixT (a `raft::mdarray`) so `view()`/`data_handle()`/`extent()` etc. are reused as-is
- * rather than hand-forwarded; `logical_dim_` is the only state this struct adds.
- *
- * Template parameters:
- * - MatrixT: owning matrix type that stores the payload (host/device matrix).
- * - ViewT: non-owning row-major view type returned by `view()`.
- * - DataT: scalar element type of the dataset payload.
- * - IdxT: index type used for row counts (`n_rows()` return type).
- */
-template <typename MatrixT, typename ViewT, typename DataT, typename IdxT>
-struct dense_row_major_dataset_owning_storage : public MatrixT {
-  uint32_t logical_dim_;
-
-  // MatrixT (mdarray) also has its own stride(size_t); pull it back into scope since declaring
-  // our own no-arg stride() below would otherwise hide it entirely (C++ name hiding).
-  using MatrixT::stride;
-
-  dense_row_major_dataset_owning_storage(MatrixT&& data, uint32_t logical_dim) noexcept
-    : MatrixT{std::move(data)}, logical_dim_{logical_dim}
-  {
-  }
-
-  [[nodiscard]] auto n_rows() const noexcept -> IdxT { return this->extent(0); }
-  [[nodiscard]] auto dim() const noexcept -> uint32_t { return logical_dim_; }
-  [[nodiscard]] auto stride() const noexcept -> uint32_t
-  {
-    return static_cast<uint32_t>(this->extent(1));
-  }
-  // view() and data_handle() are inherited directly from MatrixT (raft::mdarray); no hand-written
-  // forwarding needed since MatrixT::view() const already returns exactly ViewT.
-};
-
-template <typename ViewT, typename DataT, typename IdxT>
-struct dense_row_major_dataset_view_storage : public ViewT {
-  uint32_t logical_dim_;
-
-  // ViewT (mdspan) also has its own stride(size_t); pull it back into scope since declaring our
-  // own no-arg stride() below would otherwise hide it entirely (C++ name hiding), and the body of
-  // that stride() itself needs to call the inherited one.
-  using ViewT::stride;
-
-  dense_row_major_dataset_view_storage() noexcept = default;
-
-  explicit dense_row_major_dataset_view_storage(ViewT v) noexcept
-    : ViewT(v), logical_dim_(static_cast<uint32_t>(v.extent(1)))
-  {
-  }
-
-  dense_row_major_dataset_view_storage(ViewT v, uint32_t logical_dim) noexcept
-    : ViewT(v), logical_dim_(logical_dim)
-  {
-  }
-
-  [[nodiscard]] auto n_rows() const noexcept -> IdxT { return this->extent(0); }
-  [[nodiscard]] auto dim() const noexcept -> uint32_t { return logical_dim_; }
-  [[nodiscard]] auto stride() const noexcept -> uint32_t
-  {
-    return static_cast<uint32_t>(ViewT::stride(0) > 0 ? ViewT::stride(0) : this->extent(1));
-  }
-};
-
-/** Spec-side implementation shared by `padded_dataset_spec`/`standard_dataset_spec`; those two
- * stay distinct top-level types (identical bodies) purely so classification traits can tell them
- * apart -- exactly mirroring today's `padded_dataset_container`/`standard_dataset_container`,
- * which are likewise two differently-named tags over one shared storage implementation. */
-template <typename ContainerPolicy>
-struct dense_dataset_spec_impl {
-  template <typename T, typename IdxT>
-  struct apply {
-    using value_type = std::remove_cv_t<T>;
-    using index_type = std::remove_cv_t<IdxT>;
-    using MatrixT    = dense_owning_matrix<T, IdxT, ContainerPolicy>;
-    using ViewT      = dense_view_matrix<T, IdxT, ContainerPolicy>;
-    using data_type  = dense_row_major_dataset_owning_storage<MatrixT, ViewT, T, IdxT>;
-    using view_type  = dense_row_major_dataset_view_storage<ViewT, T, IdxT>;
-
-    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
-    {
-      return view_type(data.view(), data.dim());
-    }
-    template <typename AnyStorage>
-    [[nodiscard]] static auto get_n_rows(AnyStorage const& data) noexcept -> index_type
-    {
-      return data.n_rows();
-    }
-    template <typename AnyStorage>
-    [[nodiscard]] static auto get_dim(AnyStorage const& data) noexcept -> uint32_t
-    {
-      return data.dim();
-    }
-  };
-};
-
-// -----------------------------------------------------------------------------
-// vpq payloads: everything VPQ-specific lives here, not in dataset/dataset_view.
-// -----------------------------------------------------------------------------
-
-/** Read-only helpers derived from the codebook shapes; shared by the owning and view payloads.
- * `Derived` provides `vq_code_book`, `pq_code_book` and the codes' `extent(r)`. */
-template <typename Derived>
-struct vpq_codebook_helpers {
-  /** Logical dimension: it comes from the VQ codebook, not from the encoded rows (row padding
-   * makes the encoded-row width ambiguous as a dimension). */
-  [[nodiscard]] auto dim() const noexcept -> uint32_t
-  {
-    return static_cast<uint32_t>(self().vq_code_book.extent(1));
-  }
-  [[nodiscard]] auto vq_n_centers() const noexcept -> uint32_t
-  {
-    return static_cast<uint32_t>(self().vq_code_book.extent(0));
-  }
-  [[nodiscard]] auto pq_n_centers() const noexcept -> uint32_t
-  {
-    return static_cast<uint32_t>(self().pq_code_book.extent(0));
-  }
-  [[nodiscard]] auto pq_len() const noexcept -> uint32_t
-  {
-    return static_cast<uint32_t>(self().pq_code_book.extent(1));
-  }
-  [[nodiscard]] auto pq_bits() const noexcept -> uint32_t
-  {
-    auto pq_width = pq_n_centers();
-#ifdef __cpp_lib_bitops
-    return std::countr_zero(pq_width);
-#else
-    uint32_t bits = 0;
-    while (pq_width > 1) {
-      bits++;
-      pq_width >>= 1;
-    }
-    return bits;
-#endif
-  }
-  [[nodiscard]] auto pq_dim() const noexcept -> uint32_t
-  {
-    return raft::div_rounding_up_unsafe(dim(), pq_len());
-  }
-  [[nodiscard]] auto encoded_row_length() const noexcept -> uint32_t
-  {
-    return static_cast<uint32_t>(self().extent(1));
-  }
-
- private:
-  [[nodiscard]] auto self() const noexcept -> Derived const&
-  {
-    return static_cast<Derived const&>(*this);
-  }
-};
-
-/** Owning VPQ payload: the encoded rows (it *is* the `uint8_t` codes mdarray) plus the VQ and PQ
- * codebooks. `Accessor` drives both codebook and code residency. */
-template <typename MathT, typename IdxT, typename Accessor>
-struct vpq_owning_storage : public vpq_data_matrix<IdxT, Accessor>,
-                            public vpq_codebook_helpers<vpq_owning_storage<MathT, IdxT, Accessor>> {
-  using codes_type   = vpq_data_matrix<IdxT, Accessor>;
-  using vq_book_type = vpq_vq_book_matrix<MathT, IdxT, Accessor>;
-  using pq_book_type = vpq_vq_book_matrix<MathT, IdxT, Accessor>;
-
-  vq_book_type vq_code_book;
-  pq_book_type pq_code_book;
-
-  vpq_owning_storage(codes_type&& codes, vq_book_type&& vq_codes, pq_book_type&& pq_codes) noexcept
-    : codes_type{std::move(codes)},
-      vq_code_book{std::move(vq_codes)},
-      pq_code_book{std::move(pq_codes)}
-  {
-  }
-};
-
-/** Non-owning VPQ payload: a view of the encoded rows plus views of the VQ and PQ codebooks. */
-template <typename MathT, typename IdxT, typename Accessor>
-struct vpq_view_storage : public raft::mdspan<const uint8_t,
-                                              raft::matrix_extent<IdxT>,
-                                              raft::row_major,
-                                              dataset_view_accessor_for_owning<uint8_t, Accessor>>,
-                          public vpq_codebook_helpers<vpq_view_storage<MathT, IdxT, Accessor>> {
-  using codes_view_type = raft::mdspan<const uint8_t,
-                                       raft::matrix_extent<IdxT>,
-                                       raft::row_major,
-                                       dataset_view_accessor_for_owning<uint8_t, Accessor>>;
-  using vq_book_view_type =
-    typename vpq_owning_storage<MathT, IdxT, Accessor>::vq_book_type::const_view_type;
-  using pq_book_view_type =
-    typename vpq_owning_storage<MathT, IdxT, Accessor>::pq_book_type::const_view_type;
-
-  vq_book_view_type vq_code_book;
-  pq_book_view_type pq_code_book;
-
-  vpq_view_storage() noexcept = default;
-  vpq_view_storage(codes_view_type codes,
-                   vq_book_view_type vq_codes,
-                   pq_book_view_type pq_codes) noexcept
-    : codes_view_type(codes), vq_code_book(vq_codes), pq_code_book(pq_codes)
-  {
-  }
-};
-
-}  // namespace detail
-
-// -----------------------------------------------------------------------------
-// Public specs -- the only place per-kind logic lives.
-// -----------------------------------------------------------------------------
-
-template <typename Accessor>
-struct empty_dataset_spec {
-  using accessor_type = Accessor;
-
-  template <typename T, typename IdxT>
-  struct apply {
-    using value_type = std::remove_cv_t<T>;
-    using index_type = std::remove_cv_t<IdxT>;
-    using data_type  = detail::empty_dataset_storage<IdxT>;
-    using view_type  = detail::empty_dataset_storage<IdxT>;
-
-    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
-    {
-      return data;
-    }
-    [[nodiscard]] static auto get_n_rows(data_type const& data) noexcept -> index_type
-    {
-      return static_cast<index_type>(data.n_rows());
-    }
-    [[nodiscard]] static auto get_dim(data_type const& data) noexcept -> uint32_t
-    {
-      return data.dim();
-    }
-  };
-};
-
-template <typename ContainerPolicy>
-struct padded_dataset_spec {
-  using accessor_type = ContainerPolicy;
-  template <typename T, typename IdxT>
-  struct apply : detail::dense_dataset_spec_impl<ContainerPolicy>::template apply<T, IdxT> {};
-};
-
-template <typename ContainerPolicy>
-struct standard_dataset_spec {
-  using accessor_type = ContainerPolicy;
-  template <typename T, typename IdxT>
-  struct apply : detail::dense_dataset_spec_impl<ContainerPolicy>::template apply<T, IdxT> {};
-};
-
-/** `Accessor` drives both codebook and code residency, mirroring today's
- * single-`Accessor`-per-VPQ-dataset design. The payload (`detail::vpq_owning_storage` /
- * `detail::vpq_view_storage`) holds the encoded rows and the VQ/PQ codebooks. */
-template <typename MathT, typename Accessor>
-struct vpq_dataset_spec {
-  using accessor_type = Accessor;
-
-  template <typename T, typename IdxT>
-  struct apply {
-    using value_type = std::remove_cv_t<T>;
-    using index_type = std::remove_cv_t<IdxT>;
-    using math_type  = MathT;
-
-    using data_type = detail::vpq_owning_storage<MathT, IdxT, Accessor>;
-    using view_type = detail::vpq_view_storage<MathT, IdxT, Accessor>;
-
-    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
-    {
-      return view_type(data.view(), data.vq_code_book.view(), data.pq_code_book.view());
-    }
-    template <typename AnyStorage>
-    [[nodiscard]] static auto get_n_rows(AnyStorage const& data) noexcept -> index_type
-    {
-      return static_cast<index_type>(data.extent(0));
-    }
-    template <typename AnyStorage>
-    [[nodiscard]] static auto get_dim(AnyStorage const& data) noexcept -> uint32_t
-    {
-      return data.dim();
-    }
-  };
-};
-
-// -----------------------------------------------------------------------------
-// dataset / dataset_view
-// -----------------------------------------------------------------------------
-
-/** Owning dataset: value-held payload (no shared_ptr -- exclusive ownership). Every member is a
- * one-line forward to `spec_type::get_*` or to the payload; all per-kind state and logic lives in
- * the spec's `data_type`, never inside this struct. */
-template <typename T, typename IdxT, typename SpecT>
-struct dataset {
-  using spec_type  = typename SpecT::template apply<T, IdxT>;
-  using value_type = typename spec_type::value_type;
-  using index_type = typename spec_type::index_type;
-  using data_type  = typename spec_type::data_type;
-
-  // Forward constructor args straight to data_type's own constructor (e.g. (MatrixT&&, uint32_t
-  // logical_dim) for dense, (uint32_t dim) for empty, (codes&&, vq&&, pq&&) for VPQ).
-  template <typename... Args>
-  explicit dataset(Args&&... args)
-    requires(std::is_constructible_v<data_type, Args...>)
-    : data_(std::forward<Args>(args)...)
-  {
-  }
-
-  [[nodiscard]] auto n_rows() const noexcept -> index_type { return spec_type::get_n_rows(data_); }
-  [[nodiscard]] auto dim() const noexcept -> uint32_t { return spec_type::get_dim(data_); }
-  /** The spec-defined non-owning view of the payload (for dense and VPQ it is an mdspan
-   * derivative). */
-  [[nodiscard]] auto as_matrix_view() const noexcept { return spec_type::get_data_view(data_); }
-  [[nodiscard]] auto as_dataset_view() const noexcept -> dataset_view<T, IdxT, SpecT>
-  {
-    return dataset_view<T, IdxT, SpecT>(as_matrix_view());
-  }
-
-  /** The owning payload; kind-specific state and methods are reached through it. */
-  [[nodiscard]] auto data() const noexcept -> data_type const& { return data_; }
-  [[nodiscard]] auto data() noexcept -> data_type& { return data_; }
-
- private:
-  data_type data_;
-};
-
-/** Non-owning dataset view: holds only the view-shaped payload. Deliberately not derived from
- * `dataset` -- a view type holds "all view state" with no inheritance and no shared ownership tying
- * it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec functions as `dataset`, fed
- * the view payload instead of the owning one. */
-template <typename T, typename IdxT, typename SpecT>
-struct dataset_view {
-  using spec_type  = typename SpecT::template apply<T, IdxT>;
-  using value_type = typename spec_type::value_type;
-  using index_type = typename spec_type::index_type;
-  using view_type  = typename spec_type::view_type;
-
-  dataset_view() noexcept = default;
-
-  // Already-constructed view payload -- the shape `as_dataset_view()` always constructs with, for
-  // every kind. Not a template, so it's preferred over the forwarding constructor below whenever
-  // both could apply.
-  explicit dataset_view(view_type data_view) noexcept : data_view_{data_view} {}
-
-  // Forward raw constructor args straight to view_type's own constructor (e.g. (ViewT, uint32_t
-  // logical_dim) for dense, (uint32_t dim) for empty) -- preserves today's direct-construction
-  // call sites (e.g. `device_padded_dataset_view<T,IdxT>(raw_mdspan, dim)`) unchanged.
-  template <typename... Args>
-  explicit dataset_view(Args&&... args)
-    requires(std::is_constructible_v<view_type, Args...>)
-    : data_view_(std::forward<Args>(args)...)
-  {
-  }
-
-  [[nodiscard]] auto n_rows() const noexcept -> index_type
-  {
-    return spec_type::get_n_rows(data_view_);
-  }
-  [[nodiscard]] auto dim() const noexcept -> uint32_t { return spec_type::get_dim(data_view_); }
-  [[nodiscard]] auto as_matrix_view() const noexcept -> view_type { return data_view_; }
-
-  /** The view payload; kind-specific state and methods are reached through it. */
-  [[nodiscard]] auto data() const noexcept -> view_type const& { return data_view_; }
-  [[nodiscard]] auto data() noexcept -> view_type& { return data_view_; }
-
- private:
-  view_type data_view_{};
-};
-
-/**
- * @brief Aliases for concrete `dataset` / `dataset_view` layouts.
- */
-template <typename IdxT>
-using device_empty_dataset =
-  dataset<void, IdxT, empty_dataset_spec<detail::device_view_accessor<char>>>;
-
-template <typename IdxT>
-using device_empty_dataset_view =
-  dataset_view<void, IdxT, empty_dataset_spec<detail::device_view_accessor<char>>>;
-
-template <typename IdxT>
-using host_empty_dataset =
-  dataset<void, IdxT, empty_dataset_spec<detail::host_view_accessor<char>>>;
-
-template <typename IdxT>
-using host_empty_dataset_view =
-  dataset_view<void, IdxT, empty_dataset_spec<detail::host_view_accessor<char>>>;
-
-template <typename DataT, typename IdxT>
-using device_padded_dataset =
-  dataset<DataT, IdxT, padded_dataset_spec<detail::device_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using device_padded_dataset_view =
-  dataset_view<DataT, IdxT, padded_dataset_spec<detail::device_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using host_padded_dataset =
-  dataset<DataT, IdxT, padded_dataset_spec<detail::host_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using host_padded_dataset_view =
-  dataset_view<DataT, IdxT, padded_dataset_spec<detail::host_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using device_standard_dataset =
-  dataset<DataT, IdxT, standard_dataset_spec<detail::device_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using device_standard_dataset_view =
-  dataset_view<DataT, IdxT, standard_dataset_spec<detail::device_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using host_standard_dataset =
-  dataset<DataT, IdxT, standard_dataset_spec<detail::host_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using host_standard_dataset_view =
-  dataset_view<DataT, IdxT, standard_dataset_spec<detail::host_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using device_vpq_dataset =
-  dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::device_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using device_vpq_dataset_view =
-  dataset_view<DataT, IdxT, vpq_dataset_spec<DataT, detail::device_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using host_vpq_dataset =
-  dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::host_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using host_vpq_dataset_view =
-  dataset_view<DataT, IdxT, vpq_dataset_spec<DataT, detail::host_owning_accessor<DataT>>>;
-
-// Maps a dataset view type to its owning (allocating) dataset counterpart. Trivial and total under
-// the Spec design: the owning type for `dataset_view<T,IdxT,SpecT>` is always
-// `dataset<T,IdxT,SpecT>`
-// -- no per-kind specialization table needed (unlike the old Container-tagged design).
-template <typename DatasetViewT>
-struct owning_dataset_for_view;
-
-template <typename T, typename IdxT, typename SpecT>
-struct owning_dataset_for_view<dataset_view<T, IdxT, SpecT>> {
-  using type = dataset<T, IdxT, SpecT>;
-};
-
-template <typename DatasetViewT>
-using owning_dataset_for_view_t = typename owning_dataset_for_view<DatasetViewT>::type;
-
-// -----------------------------------------------------------------------------
-// Spec-kind classification (all derived from SpecT; dataset/dataset_view never branch on kind).
-// -----------------------------------------------------------------------------
-
-template <typename SpecT>
-struct is_empty_spec : std::false_type {};
-template <typename Accessor>
-struct is_empty_spec<empty_dataset_spec<Accessor>> : std::true_type {};
-template <typename SpecT>
-inline constexpr bool is_empty_spec_v = is_empty_spec<SpecT>::value;
-
-template <typename SpecT>
-struct is_padded_spec : std::false_type {};
-template <typename ContainerPolicy>
-struct is_padded_spec<padded_dataset_spec<ContainerPolicy>> : std::true_type {};
-template <typename SpecT>
-inline constexpr bool is_padded_spec_v = is_padded_spec<SpecT>::value;
-
-template <typename SpecT>
-struct is_standard_spec : std::false_type {};
-template <typename ContainerPolicy>
-struct is_standard_spec<standard_dataset_spec<ContainerPolicy>> : std::true_type {};
-template <typename SpecT>
-inline constexpr bool is_standard_spec_v = is_standard_spec<SpecT>::value;
-
-template <typename SpecT>
-struct is_vpq_spec : std::false_type {};
-template <typename MathT, typename Accessor>
-struct is_vpq_spec<vpq_dataset_spec<MathT, Accessor>> : std::true_type {};
-template <typename SpecT>
-inline constexpr bool is_vpq_spec_v = is_vpq_spec<SpecT>::value;
-
-template <typename SpecT>
-struct vpq_spec_math_type {};
-template <typename MathT, typename Accessor>
-struct vpq_spec_math_type<vpq_dataset_spec<MathT, Accessor>> {
-  using type = MathT;
-};
-template <typename SpecT>
-using vpq_spec_math_type_t = typename vpq_spec_math_type<SpecT>::type;
-
-/** Owning-side kind traits (mirror today's `is_padded_dataset_v`/`is_standard_dataset_v`/
- * `is_vpq_dataset_v`, used for SFINAE overload selection in factory.cuh/compute_distance_vpq.hpp).
- */
-template <typename DatasetT>
-struct is_padded_dataset : std::false_type {};
-template <typename T, typename IdxT, typename SpecT>
-struct is_padded_dataset<dataset<T, IdxT, SpecT>> : std::bool_constant<is_padded_spec_v<SpecT>> {};
-template <typename T, typename IdxT, typename SpecT>
-struct is_padded_dataset<dataset_view<T, IdxT, SpecT>>
-  : std::bool_constant<is_padded_spec_v<SpecT>> {};
-template <typename DatasetT>
-inline constexpr bool is_padded_dataset_v = is_padded_dataset<DatasetT>::value;
-
-template <typename DatasetT>
-struct is_standard_dataset : std::false_type {};
-template <typename T, typename IdxT, typename SpecT>
-struct is_standard_dataset<dataset<T, IdxT, SpecT>>
-  : std::bool_constant<is_standard_spec_v<SpecT>> {};
-template <typename T, typename IdxT, typename SpecT>
-struct is_standard_dataset<dataset_view<T, IdxT, SpecT>>
-  : std::bool_constant<is_standard_spec_v<SpecT>> {};
-template <typename DatasetT>
-inline constexpr bool is_standard_dataset_v = is_standard_dataset<DatasetT>::value;
-
-template <typename DatasetT>
-struct is_vpq_dataset : std::false_type {};
-template <typename T, typename IdxT, typename SpecT>
-struct is_vpq_dataset<dataset<T, IdxT, SpecT>> : std::bool_constant<is_vpq_spec_v<SpecT>> {};
-template <typename DatasetT>
-inline constexpr bool is_vpq_dataset_v = is_vpq_dataset<DatasetT>::value;
-
-// -----------------------------------------------------------------------------
-// Dataset view compile-time classification (replaces runtime std::variant dispatch).
-// -----------------------------------------------------------------------------
-
-/** Any non-owning dataset view exposing row count and logical dimension. */
-template <typename V, typename IdxT = int64_t>
-concept ann_dataset_view = requires(V const& v) {
-  { v.n_rows() } -> std::convertible_to<IdxT>;
-  { v.dim() } -> std::convertible_to<uint32_t>;
-};
-
-enum class dataset_view_kind {
-  // TODO(removal): Remove `unknown` once all deprecated host_matrix_view / device_matrix_view /
-  // mdspan overloads are deleted. It exists solely so that overload resolution on the deprecated
-  // build(host_matrix_view) / build(device_matrix_view) shims does not cause a hard error when
-  // the compiler evaluates is_host/device_dataset_view_v for a plain mdspan type.
-  unknown,
-  empty,
-  padded,
-  standard,
-  vpq_f16,
-  vpq_f32,
-  bbq,
-};
-
-template <typename V>
-using dataset_view_type_t = std::remove_cvref_t<V>;
-
-/** Primary template returns `unknown` so traits safely return `false` for non-dataset-view types.
- */
-template <typename V>
-struct dataset_view_kind_of {
-  static constexpr dataset_view_kind value = dataset_view_kind::unknown;
-};
-
-template <typename T, typename IdxT, typename SpecT>
-struct dataset_view_kind_of<dataset_view<T, IdxT, SpecT>> {
-  static constexpr dataset_view_kind value = []() constexpr {
-    if constexpr (is_empty_spec_v<SpecT>) {
-      return dataset_view_kind::empty;
-    } else if constexpr (is_padded_spec_v<SpecT>) {
-      return dataset_view_kind::padded;
-    } else if constexpr (is_standard_spec_v<SpecT>) {
-      return dataset_view_kind::standard;
-    } else if constexpr (is_vpq_spec_v<SpecT>) {
-      static_assert(std::is_same_v<vpq_spec_math_type_t<SpecT>, half> ||
-                      std::is_same_v<vpq_spec_math_type_t<SpecT>, float>,
-                    "VPQ dataset_view_kind_of expects MathT to be half or float");
-      return std::is_same_v<vpq_spec_math_type_t<SpecT>, half> ? dataset_view_kind::vpq_f16
-                                                               : dataset_view_kind::vpq_f32;
-    } else {
-      return dataset_view_kind::unknown;
-    }
-  }();
-};
-
-/** True when the dataset view accessor is device-accessible. */
-template <typename V>
-struct dataset_view_is_device_accessible : std::false_type {};
-
-template <typename T, typename IdxT, typename SpecT>
-struct dataset_view_is_device_accessible<dataset_view<T, IdxT, SpecT>>
-  : std::bool_constant<SpecT::accessor_type::is_device_accessible> {};
-
-template <typename V>
-inline constexpr bool dataset_view_is_device_accessible_v =
-  dataset_view_is_device_accessible<dataset_view_type_t<V>>::value;
-
-template <typename V>
-inline constexpr dataset_view_kind dataset_view_kind_v =
-  dataset_view_kind_of<dataset_view_type_t<V>>::value;
-
-template <typename V>
-inline constexpr bool is_device_empty_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::empty && dataset_view_is_device_accessible_v<V>;
-
-template <typename V>
-inline constexpr bool is_host_empty_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::empty && !dataset_view_is_device_accessible_v<V>;
-
-/** True for any empty dataset view (device or host). */
-template <typename V>
-inline constexpr bool is_empty_dataset_view_v =
-  is_device_empty_dataset_view_v<V> || is_host_empty_dataset_view_v<V>;
-
-template <typename V>
-inline constexpr bool is_device_padded_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::padded && dataset_view_is_device_accessible_v<V>;
-
-template <typename V>
-inline constexpr bool is_host_padded_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::padded && !dataset_view_is_device_accessible_v<V>;
-
-/** True for either `device_padded_dataset_view` or `host_padded_dataset_view`. */
-template <typename V>
-inline constexpr bool is_padded_dataset_view_v =
-  is_device_padded_dataset_view_v<V> || is_host_padded_dataset_view_v<V>;
-
-template <typename V>
-inline constexpr bool is_device_standard_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::standard && dataset_view_is_device_accessible_v<V>;
-
-template <typename V>
-inline constexpr bool is_host_standard_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::standard && !dataset_view_is_device_accessible_v<V>;
-
-/** True for either `device_standard_dataset_view` or `host_standard_dataset_view`. */
-template <typename V>
-inline constexpr bool is_standard_dataset_view_v =
-  is_device_standard_dataset_view_v<V> || is_host_standard_dataset_view_v<V>;
-
-template <typename V>
-inline constexpr bool is_device_vpq_f16_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::vpq_f16 && dataset_view_is_device_accessible_v<V>;
-
-template <typename V>
-inline constexpr bool is_host_vpq_f16_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::vpq_f16 && !dataset_view_is_device_accessible_v<V>;
-
-template <typename V>
-inline constexpr bool is_vpq_f16_dataset_view_v =
-  is_device_vpq_f16_dataset_view_v<V> || is_host_vpq_f16_dataset_view_v<V>;
-
-template <typename V>
-inline constexpr bool is_device_vpq_f32_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::vpq_f32 && dataset_view_is_device_accessible_v<V>;
-
-template <typename V>
-inline constexpr bool is_host_vpq_f32_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::vpq_f32 && !dataset_view_is_device_accessible_v<V>;
-
-template <typename V>
-inline constexpr bool is_vpq_f32_dataset_view_v =
-  is_device_vpq_f32_dataset_view_v<V> || is_host_vpq_f32_dataset_view_v<V>;
-
-template <typename V>
-inline constexpr bool is_device_vpq_dataset_view_v =
-  is_device_vpq_f16_dataset_view_v<V> || is_device_vpq_f32_dataset_view_v<V>;
-
-template <typename V>
-inline constexpr bool is_host_vpq_dataset_view_v =
-  is_host_vpq_f16_dataset_view_v<V> || is_host_vpq_f32_dataset_view_v<V>;
-
-template <typename V>
-inline constexpr bool is_vpq_dataset_view_v =
-  is_device_vpq_dataset_view_v<V> || is_host_vpq_dataset_view_v<V>;
-
-/** True for any device-resident dataset view. */
-template <typename V>
-inline constexpr bool is_device_dataset_view_v =
-  dataset_view_kind_v<V> != dataset_view_kind::unknown && dataset_view_is_device_accessible_v<V>;
-
-/** True for any host-resident dataset view. */
-template <typename V>
-inline constexpr bool is_host_dataset_view_v =
-  dataset_view_kind_v<V> != dataset_view_kind::unknown && !dataset_view_is_device_accessible_v<V>;
-
-/**
- * True when a host view `H` and device view `D` represent the same storage kind and differ
- * only in residency (host vs. device). Used by host/device conversion helpers.
- */
-template <typename HostViewT, typename DeviceViewT>
-inline constexpr bool compatible_host_device_dataset_views_v =
-  is_host_dataset_view_v<HostViewT> && is_device_dataset_view_v<DeviceViewT> &&
-  (dataset_view_kind_v<HostViewT> == dataset_view_kind_v<DeviceViewT>);
-
-/**
- * Generic accessor retargeting while preserving the dataset tag/layout and value/index types:
- * `dataset<T, IdxT, SpecT<..., OldAccessor>>      -> dataset<T, IdxT, SpecT<..., NewAccessor>>`
- * `dataset_view<T, IdxT, SpecT<..., OldAccessor>> -> dataset_view<T, IdxT, SpecT<...,
- * NewAccessor>>`
- */
-template <typename DatasetLikeT, typename NewAccessor>
-struct with_accessor;
-
-template <typename T, typename IdxT, typename NewAccessor>
-struct with_accessor<dataset<T, IdxT, empty_dataset_spec<NewAccessor>>, NewAccessor> {
-  using type = dataset<T, IdxT, empty_dataset_spec<NewAccessor>>;
-};
-
-template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset<T, IdxT, padded_dataset_spec<OldAccessor>>, NewAccessor> {
-  using type = dataset<T, IdxT, padded_dataset_spec<NewAccessor>>;
-};
-
-template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset<T, IdxT, standard_dataset_spec<OldAccessor>>, NewAccessor> {
-  using type = dataset<T, IdxT, standard_dataset_spec<NewAccessor>>;
-};
-
-template <typename T, typename IdxT, typename MathT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset<T, IdxT, vpq_dataset_spec<MathT, OldAccessor>>, NewAccessor> {
-  using type = dataset<T, IdxT, vpq_dataset_spec<MathT, NewAccessor>>;
-};
-
-template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset_view<T, IdxT, empty_dataset_spec<OldAccessor>>, NewAccessor> {
-  using type = dataset_view<T, IdxT, empty_dataset_spec<NewAccessor>>;
-};
-
-template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset_view<T, IdxT, padded_dataset_spec<OldAccessor>>, NewAccessor> {
-  using type = dataset_view<T, IdxT, padded_dataset_spec<NewAccessor>>;
-};
-
-template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset_view<T, IdxT, standard_dataset_spec<OldAccessor>>, NewAccessor> {
-  using type = dataset_view<T, IdxT, standard_dataset_spec<NewAccessor>>;
-};
-
-template <typename T, typename IdxT, typename MathT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset_view<T, IdxT, vpq_dataset_spec<MathT, OldAccessor>>, NewAccessor> {
-  using type = dataset_view<T, IdxT, vpq_dataset_spec<MathT, NewAccessor>>;
-};
-
-template <typename DatasetLikeT, typename NewAccessor>
-using with_accessor_t =
-  typename with_accessor<dataset_view_type_t<DatasetLikeT>, NewAccessor>::type;
-
-/** Map any host accessor to its device counterpart (same payload policy). */
-template <typename Accessor>
-struct to_device_accessor {
-  using type = Accessor;
-};
-
-template <typename T>
-struct to_device_accessor<detail::host_view_accessor<T>> {
-  using type = detail::device_view_accessor<T>;
-};
-
-template <typename T>
-struct to_device_accessor<detail::host_owning_accessor<T>> {
-  using type = detail::device_owning_accessor<T>;
-};
-
-template <typename Accessor>
-using to_device_accessor_t = typename to_device_accessor<Accessor>::type;
-
-/** Maps a host dataset view type to its device-resident counterpart. */
-template <typename HostViewT>
-struct device_counterpart;
-
-template <typename T, typename IdxT, typename SpecT>
-struct device_counterpart<dataset_view<T, IdxT, SpecT>> {
-  using type = with_accessor_t<dataset_view<T, IdxT, SpecT>,
-                               to_device_accessor_t<typename SpecT::accessor_type>>;
-};
-
-template <typename HostViewT>
-using device_counterpart_t = typename device_counterpart<dataset_view_type_t<HostViewT>>::type;
-
-/** True for device padded or standard views accepted by dense graph build (VPQ excluded). */
-template <typename V>
-inline constexpr bool is_dense_row_major_device_dataset_view_v =
-  is_device_padded_dataset_view_v<V> || is_device_standard_dataset_view_v<V>;
-
-/** True for host or device padded/standard views (dense graph build; VPQ excluded). */
-template <typename V>
-inline constexpr bool is_dense_row_major_dataset_view_v =
-  is_padded_dataset_view_v<V> || is_standard_dataset_view_v<V>;
-
-/** Element type `T` for `cagra::build(res, params, dataset_view)` (deduced, not a template arg).
- * Trivial under the Spec design: every `dataset_view<T,IdxT,SpecT>` already carries `T` directly.
- */
-template <typename V>
-using cagra_view_element_type_t = typename dataset_view_type_t<V>::value_type;
-
-// -----------------------------------------------------------------------------
-// CAGRA row width in elements (same for make_device_padded_dataset* and index layout checks).
-// -----------------------------------------------------------------------------
-
-/**
- * @brief Required row width in elements for CAGRA: minimum leading dimension (LDA) per row for the
- *        default per-row byte alignment (16 bytes, combined with `sizeof` element type), given
- *        `logical_columns` feature columns.
- */
-[[nodiscard]] inline uint32_t cagra_required_row_width(uint32_t logical_columns,
-                                                       std::size_t sizeof_value,
-                                                       uint32_t align_bytes = 16)
-{
-  return static_cast<uint32_t>(
-    raft::round_up_safe<std::size_t>(static_cast<std::size_t>(logical_columns) * sizeof_value,
-                                     std::lcm(align_bytes, static_cast<uint32_t>(sizeof_value))) /
-    sizeof_value);
-}
-
-template <typename ValueT>
-[[nodiscard]] inline uint32_t cagra_required_row_width(uint32_t logical_columns,
-                                                       uint32_t align_bytes = 16)
-{
-  return cagra_required_row_width(logical_columns, sizeof(ValueT), align_bytes);
-}
-
-/** Actual row width in elements (leading dimension) of a 2D row-major matrix view. */
-template <typename T, typename I, typename L>
-[[nodiscard]] inline uint32_t matrix_actual_row_width(raft::device_matrix_view<T, I, L> m)
-{
-  return m.stride(0) > 0 ? static_cast<uint32_t>(m.stride(0)) : static_cast<uint32_t>(m.extent(1));
-}
-
-template <typename T, typename I, typename L>
-[[nodiscard]] inline uint32_t matrix_actual_row_width(raft::host_matrix_view<T, I, L> m)
-{
-  return m.stride(0) > 0 ? static_cast<uint32_t>(m.stride(0)) : static_cast<uint32_t>(m.extent(1));
-}
-
-/**
- * @brief True if the matrix's row width in elements matches `cagra_required_row_width` for
- *        `m.extent(1)` and element type `T` (CAGRA row layout is satisfied for this view).
- */
-template <typename T, typename I, typename L>
-[[nodiscard]] inline bool matrix_row_width_matches_cagra_required(
-  raft::device_matrix_view<T, I, L> m, uint32_t align_bytes = 16)
-{
-  using value_type = std::remove_const_t<T>;
-  const uint32_t need =
-    cagra_required_row_width<value_type>(static_cast<uint32_t>(m.extent(1)), align_bytes);
-  return matrix_actual_row_width(m) == need;
-}
-
-template <typename T, typename I, typename L>
-[[nodiscard]] inline bool matrix_row_width_matches_cagra_required(raft::host_matrix_view<T, I, L> m,
-                                                                  uint32_t align_bytes = 16)
-{
-  using value_type = std::remove_const_t<T>;
-  const uint32_t need =
-    cagra_required_row_width<value_type>(static_cast<uint32_t>(m.extent(1)), align_bytes);
-  return matrix_actual_row_width(m) == need;
-}
-
-namespace detail {
-
-template <typename SrcT>
-[[nodiscard]] inline uint32_t mdspan_row_stride_elements(SrcT const& src)
-{
-  return src.stride(0) > 0 ? static_cast<uint32_t>(src.stride(0))
-                           : static_cast<uint32_t>(src.extent(1));
-}
-
-template <typename ValueT, typename SrcT>
-[[nodiscard]] inline ValueT* expect_device_accessible_data_handle(SrcT const& src,
-                                                                  char const* error_msg)
-{
-  cudaPointerAttributes ptr_attrs;
-  RAFT_CUDA_TRY(cudaPointerGetAttributes(&ptr_attrs, src.data_handle()));
-  // `devicePointer` is relative to the *current* device: it is null for an allocation owned by
-  // another device without peer access, even though that allocation is perfectly usable once the
-  // caller switches to the owning device (as the multi-GPU paths do). Accept device and managed
-  // allocations on their own merit and only consult `devicePointer` for host memory, which needs a
-  // mapping to be reachable at all.
-  if (ptr_attrs.type == cudaMemoryTypeDevice || ptr_attrs.type == cudaMemoryTypeManaged) {
-    return const_cast<ValueT*>(src.data_handle());
-  }
-  auto* device_ptr = reinterpret_cast<ValueT*>(ptr_attrs.devicePointer);
-  RAFT_EXPECTS(device_ptr != nullptr, "%s", error_msg);
-  return device_ptr;
-}
-
-template <typename ValueT, typename IndexT, typename ViewT, typename SrcT>
-[[nodiscard]] inline ViewT make_device_dense_row_major_view_from_src(SrcT const& src,
-                                                                     uint32_t logical_dim)
-{
-  auto* device_ptr = expect_device_accessible_data_handle<ValueT>(
-    src, "make_device_*_dataset_view: source must be device-accessible.");
-  auto v = raft::make_device_matrix_view(
-    device_ptr, src.extent(0), static_cast<IndexT>(mdspan_row_stride_elements(src)));
-  return ViewT(v, logical_dim);
-}
-
-template <typename ValueT, typename IndexT, typename ViewT, typename SrcT>
-[[nodiscard]] inline ViewT make_host_dense_row_major_view_from_src(SrcT const& src,
-                                                                   uint32_t logical_dim)
-{
-  RAFT_EXPECTS(raft::get_device_for_address(src.data_handle()) == -1,
-               "make_host_*_dataset_view: source must be host-accessible.");
-  auto v = raft::make_host_matrix_view(const_cast<ValueT*>(src.data_handle()),
-                                       src.extent(0),
-                                       static_cast<IndexT>(mdspan_row_stride_elements(src)));
-  return ViewT(v, logical_dim);
-}
-
-template <typename DatasetT, typename ValueT, typename IndexT, typename SrcT>
-auto make_device_dense_row_major_dataset_from_src(raft::resources const& res,
-                                                  SrcT const& src,
-                                                  uint32_t logical_dim,
-                                                  uint32_t target_stride,
-                                                  char const* view_factory_name)
-  -> std::unique_ptr<DatasetT>
-{
-  uint32_t const src_stride = mdspan_row_stride_elements(src);
-  RAFT_EXPECTS(logical_dim <= target_stride,
-               "logical dim (%u) must not exceed row stride (%u).",
-               static_cast<unsigned>(logical_dim),
-               static_cast<unsigned>(target_stride));
-  RAFT_EXPECTS(static_cast<uint32_t>(src.extent(1)) <= target_stride,
-               "Source row length must not exceed required stride.");
-  cudaPointerAttributes ptr_attrs;
-  RAFT_CUDA_TRY(cudaPointerGetAttributes(&ptr_attrs, src.data_handle()));
-  bool const device_src =
-    (ptr_attrs.type == cudaMemoryTypeDevice) || (ptr_attrs.type == cudaMemoryTypeManaged);
-  if (device_src && src_stride == target_stride) {
-    RAFT_EXPECTS(false,
-                 "source is device and stride is already correct. "
-                 "Use %s() to get a view instead.",
-                 view_factory_name);
-  }
-  auto out_array = raft::make_device_matrix<ValueT, IndexT>(res, src.extent(0), target_stride);
-  RAFT_CUDA_TRY(cudaMemsetAsync(out_array.data_handle(),
-                                0,
-                                out_array.size() * sizeof(ValueT),
-                                raft::resource::get_cuda_stream(res).get()));
-  raft::copy_matrix(out_array.data_handle(),
-                    target_stride,
-                    src.data_handle(),
-                    src_stride,
-                    logical_dim,
-                    src.extent(0),
-                    raft::resource::get_cuda_stream(res));
-  return std::make_unique<DatasetT>(std::move(out_array), logical_dim);
-}
-
-template <typename DatasetT, typename ValueT, typename IndexT, typename SrcT>
-auto make_host_dense_row_major_dataset_from_src(raft::resources const& res,
-                                                SrcT const& src,
-                                                uint32_t logical_dim,
-                                                uint32_t target_stride,
-                                                char const* view_factory_name)
-  -> std::unique_ptr<DatasetT>
-{
-  uint32_t const src_stride = mdspan_row_stride_elements(src);
-  constexpr bool device_src = SrcT::accessor_type::is_device_accessible;
-  RAFT_EXPECTS(logical_dim <= target_stride,
-               "logical dim (%u) must not exceed row stride (%u).",
-               static_cast<unsigned>(logical_dim),
-               static_cast<unsigned>(target_stride));
-  if (!device_src && src_stride == target_stride) {
-    RAFT_EXPECTS(false,
-                 "source stride is already correct. Use %s() to get a view instead.",
-                 view_factory_name);
-  }
-  RAFT_EXPECTS(static_cast<uint32_t>(src.extent(1)) <= target_stride,
-               "Source row length must not exceed required stride.");
-  auto out_array = raft::make_host_matrix<ValueT, IndexT>(src.extent(0), target_stride);
-  std::memset(out_array.data_handle(), 0, out_array.size() * sizeof(ValueT));
-  raft::copy_matrix(out_array.data_handle(),
-                    target_stride,
-                    src.data_handle(),
-                    src_stride,
-                    logical_dim,
-                    src.extent(0),
-                    raft::resource::get_cuda_stream(res));
-  if (device_src) { raft::resource::sync_stream(res); }
-  return std::make_unique<DatasetT>(std::move(out_array), logical_dim);
-}
-
-}  // namespace detail
-
-template <typename SrcT>
-auto make_device_padded_dataset_view(const raft::resources& res,
-                                     SrcT const& src,
-                                     uint32_t align_bytes = 16)
-  -> device_padded_dataset_view<typename SrcT::value_type, typename SrcT::index_type>
-{
-  using value_type = typename SrcT::value_type;
-  using index_type = typename SrcT::index_type;
-  uint32_t required_stride =
-    cagra_required_row_width<value_type>(static_cast<uint32_t>(src.extent(1)), align_bytes);
-  RAFT_EXPECTS(
-    detail::mdspan_row_stride_elements(src) == required_stride,
-    "make_device_padded_dataset_view: stride is incorrect (required stride for alignment). "
-    "Use make_device_padded_dataset() to get an owning padded copy.");
-  return detail::make_device_dense_row_major_view_from_src<
-    value_type,
-    index_type,
-    device_padded_dataset_view<value_type, index_type>>(src, static_cast<uint32_t>(src.extent(1)));
-}
-
-template <typename SrcT>
-auto make_device_padded_dataset(const raft::resources& res,
-                                SrcT const& src,
-                                uint32_t align_bytes = 16)
-  -> std::unique_ptr<device_padded_dataset<typename SrcT::value_type, typename SrcT::index_type>>
-{
-  using value_type               = typename SrcT::value_type;
-  using index_type               = typename SrcT::index_type;
-  uint32_t const logical_dim     = static_cast<uint32_t>(src.extent(1));
-  uint32_t const required_stride = cagra_required_row_width<value_type>(logical_dim, align_bytes);
-  return detail::make_device_dense_row_major_dataset_from_src<
-    device_padded_dataset<value_type, index_type>,
-    value_type,
-    index_type>(res, src, logical_dim, required_stride, "make_device_padded_dataset_view");
-}
-
-template <typename SrcT>
-auto make_host_padded_dataset_view(SrcT const& src, uint32_t align_bytes = 16)
-  -> host_padded_dataset_view<typename SrcT::value_type, typename SrcT::index_type>
-{
-  using value_type = typename SrcT::value_type;
-  using index_type = typename SrcT::index_type;
-  uint32_t required_stride =
-    cagra_required_row_width<value_type>(static_cast<uint32_t>(src.extent(1)), align_bytes);
-  RAFT_EXPECTS(
-    detail::mdspan_row_stride_elements(src) == required_stride,
-    "make_host_padded_dataset_view: stride is incorrect (required stride for alignment). "
-    "Use make_host_padded_dataset() to get an owning padded copy.");
-  return detail::make_host_dense_row_major_view_from_src<
-    value_type,
-    index_type,
-    host_padded_dataset_view<value_type, index_type>>(src, static_cast<uint32_t>(src.extent(1)));
-}
-
-template <typename SrcT>
-auto make_host_padded_dataset(const raft::resources& res,
-                              SrcT const& src,
-                              uint32_t align_bytes = 16)
-  -> std::unique_ptr<host_padded_dataset<typename SrcT::value_type, typename SrcT::index_type>>
-{
-  using value_type               = typename SrcT::value_type;
-  using index_type               = typename SrcT::index_type;
-  uint32_t const logical_dim     = static_cast<uint32_t>(src.extent(1));
-  uint32_t const required_stride = cagra_required_row_width<value_type>(logical_dim, align_bytes);
-  return detail::make_host_dense_row_major_dataset_from_src<
-    host_padded_dataset<value_type, index_type>,
-    value_type,
-    index_type>(res, src, logical_dim, required_stride, "make_host_padded_dataset_view");
-}
-
-template <typename SrcT>
-auto make_device_standard_dataset_view(SrcT const& src)
-  -> device_standard_dataset_view<typename SrcT::value_type, typename SrcT::index_type>
-{
-  using value_type = typename SrcT::value_type;
-  using index_type = typename SrcT::index_type;
-  return detail::make_device_dense_row_major_view_from_src<
-    value_type,
-    index_type,
-    device_standard_dataset_view<value_type, index_type>>(src,
-                                                          static_cast<uint32_t>(src.extent(1)));
-}
-
-/**
- * @brief Create an owning device standard dataset with explicit row layout.
- *
- * Internal use only: the sole call site today is
- * `cuvs::neighbors::detail::deserialize_standard()` in `dataset_serialize.hpp`, which must pass
- * wire-format `(logical_dim, stride)` because the deserialized host buffer is tight `[n_rows x
- * dim]` while the on-disk stride may be larger. Do not call from user code; prefer
- * `make_device_standard_dataset_view()` when wrapping existing correctly-strided storage.
- */
-template <typename SrcT>
-auto make_device_standard_dataset(const raft::resources& res,
-                                  SrcT const& src,
-                                  uint32_t logical_dim,
-                                  uint32_t target_stride)
-  -> std::unique_ptr<device_standard_dataset<typename SrcT::value_type, typename SrcT::index_type>>
-{
-  using value_type = typename SrcT::value_type;
-  using index_type = typename SrcT::index_type;
-  return detail::make_device_dense_row_major_dataset_from_src<
-    device_standard_dataset<value_type, index_type>,
-    value_type,
-    index_type>(res, src, logical_dim, target_stride, "make_device_standard_dataset_view");
-}
-
-template <typename SrcT>
-auto make_host_standard_dataset_view(SrcT const& src)
-  -> host_standard_dataset_view<typename SrcT::value_type, typename SrcT::index_type>
-{
-  using value_type = typename SrcT::value_type;
-  using index_type = typename SrcT::index_type;
-  return detail::make_host_dense_row_major_view_from_src<
-    value_type,
-    index_type,
-    host_standard_dataset_view<value_type, index_type>>(src, static_cast<uint32_t>(src.extent(1)));
-}
-
 namespace filtering {
 
 /**
diff --git a/fern/docs.yml b/fern/docs.yml
index 77ee0dae2a..b055d844f1 100644
--- a/fern/docs.yml
+++ b/fern/docs.yml
@@ -358,6 +358,8 @@ navigation:
                 path: "./pages/cpp_api/cpp-api-common-types-copy-serialization-and-utility-apis.md"
               - page: "Errors and Logging"
                 path: "./pages/cpp_api/cpp-api-common-types-errors-and-logging.md"
+          - page: "Core Dataset"
+            path: "./pages/cpp_api/cpp-api-core-dataset.md"
           - page: "Core Roaring Allowlist"
             path: "./pages/cpp_api/cpp-api-core-roaring-allowlist.md"
           - page: "Distance Distance"
diff --git a/fern/pages/cpp_api/cpp-api-core-dataset.md b/fern/pages/cpp_api/cpp-api-core-dataset.md
new file mode 100644
index 0000000000..86a2a17e80
--- /dev/null
+++ b/fern/pages/cpp_api/cpp-api-core-dataset.md
@@ -0,0 +1,129 @@
+---
+slug: api-reference/cpp-api-core-dataset
+---
+
+# Dataset
+
+_Source header: `cuvs/core/dataset.hpp`_
+
+## Types
+
+<a id="neighbors-dataset"></a>
+### neighbors::dataset
+
+Spec-based `dataset` / `dataset_view`.
+
+`dataset&lt;T,IdxT,SpecT&gt;` and `dataset_view&lt;T,IdxT,SpecT&gt;` are single generic templates that know nothing about any particular kind of dataset. They hold exactly one payload (`data_type` / `view_type`, chosen by the spec) and expose only what every dataset has: `n_rows()`, `dim()`, `as_matrix_view()`, `as_dataset_view()` and `data()`. Each is a one-line forward to one of the three spec functions `get_data_view()`, `get_n_rows()` and `get_dim()`. Anything else a kind needs (e.g. VPQ codebooks, BBQ quantizers) is state and methods of that kind's payload type, reached through `data()`; `dataset`/`dataset_view` never name or branch on it. `dataset` and `dataset_view` are deliberately two independent, non-inheriting types (no shared_ptr, no "sometimes owning" object): `dataset` holds the owning payload, `dataset_view` the corresponding non-owning payload.
+
+```cpp
+template <typename T, typename IdxT, typename SpecT>
+struct dataset;
+```
+
+<a id="neighbors-vpq-dataset-spec"></a>
+### neighbors::vpq_dataset_spec
+
+`Accessor` drives both codebook and code residency, mirroring today's
+
+single-`Accessor`-per-VPQ-dataset design. The payload (`detail::vpq_owning_storage` / `detail::vpq_view_storage`) holds the encoded rows and the VQ/PQ codebooks.
+
+```cpp
+template <typename MathT, typename Accessor>
+struct vpq_dataset_spec;
+```
+
+<a id="neighbors-dataset"></a>
+### neighbors::dataset
+
+Owning dataset: value-held payload (no shared_ptr -- exclusive ownership). Every member is a
+
+one-line forward to `spec_type::get_*` or to the payload; all per-kind state and logic lives in the spec's `data_type`, never inside this struct.
+
+```cpp
+template <typename T, typename IdxT, typename SpecT>
+struct dataset;
+```
+
+<a id="neighbors-dataset-view"></a>
+### neighbors::dataset_view
+
+Non-owning dataset view: holds only the view-shaped payload. Deliberately not derived from
+
+`dataset` -- a view type holds "all view state" with no inheritance and no shared ownership tying it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec functions as `dataset`, fed the view payload instead of the owning one.
+
+```cpp
+template <typename T, typename IdxT, typename SpecT>
+struct dataset_view;
+```
+
+<a id="neighbors-is-padded-dataset"></a>
+### neighbors::is_padded_dataset
+
+Owning-side kind traits (mirror today's `is_padded_dataset_v`/`is_standard_dataset_v`/
+
+`is_vpq_dataset_v`, used for SFINAE overload selection in factory.cuh/compute_distance_vpq.hpp).
+
+```cpp
+template <typename DatasetT>
+struct is_padded_dataset;
+```
+
+<a id="neighbors-dataset-view-kind-of"></a>
+### neighbors::dataset_view_kind_of
+
+Primary template returns `unknown` so traits safely return `false` for non-dataset-view types.
+
+```cpp
+template <typename V>
+struct dataset_view_kind_of {
+  static constexpr dataset_view_kind value;
+};
+```
+
+**Fields**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| `value` | `static constexpr dataset_view_kind` |  |
+
+<a id="neighbors-dataset-view-is-device-accessible"></a>
+### neighbors::dataset_view_is_device_accessible
+
+True when the dataset view accessor is device-accessible.
+
+```cpp
+template <typename V>
+struct dataset_view_is_device_accessible;
+```
+
+<a id="neighbors-with-accessor"></a>
+### neighbors::with_accessor
+
+Generic accessor retargeting while preserving the dataset tag/layout and value/index types:
+
+`dataset&lt;T, IdxT, SpecT&lt;..., OldAccessor&gt;&gt;      -&gt; dataset&lt;T, IdxT, SpecT&lt;..., NewAccessor&gt;&gt;` `dataset_view&lt;T, IdxT, SpecT&lt;..., OldAccessor&gt;&gt; -&gt; dataset_view&lt;T, IdxT, SpecT&lt;..., NewAccessor&gt;&gt;`
+
+```cpp
+template <typename DatasetLikeT, typename NewAccessor>
+struct with_accessor;
+```
+
+<a id="neighbors-to-device-accessor"></a>
+### neighbors::to_device_accessor
+
+Map any host accessor to its device counterpart (same payload policy).
+
+```cpp
+template <typename Accessor>
+struct to_device_accessor;
+```
+
+<a id="neighbors-device-counterpart"></a>
+### neighbors::device_counterpart
+
+Maps a host dataset view type to its device-resident counterpart.
+
+```cpp
+template <typename HostViewT>
+struct device_counterpart;
+```
diff --git a/fern/pages/cpp_api/cpp-api-neighbors-common.md b/fern/pages/cpp_api/cpp-api-neighbors-common.md
index 457c97c53d..da72bab316 100644
--- a/fern/pages/cpp_api/cpp-api-neighbors-common.md
+++ b/fern/pages/cpp_api/cpp-api-neighbors-common.md
@@ -57,168 +57,6 @@ enum class MergeStrategy {
 | `MERGE_STRATEGY_PHYSICAL` | `0` |
 | `MERGE_STRATEGY_LOGICAL` | `1` |
 
-## Types
-
-<a id="neighbors-dataset"></a>
-### neighbors::dataset
-
-Spec-based `dataset` / `dataset_view`.
-
-`dataset&lt;T,IdxT,SpecT&gt;` and `dataset_view&lt;T,IdxT,SpecT&gt;` are single generic templates that know nothing about any particular kind of dataset. They hold exactly one payload (`data_type` / `view_type`, chosen by the spec) and expose only what every dataset has: `n_rows()`, `dim()`, `as_matrix_view()`, `as_dataset_view()` and `data()`. Each is a one-line forward to one of the three spec functions `get_data_view()`, `get_n_rows()` and `get_dim()`. Anything else a kind needs (e.g. VPQ codebooks, BBQ quantizers) is state and methods of that kind's payload type, reached through `data()`; `dataset`/`dataset_view` never name or branch on it. `dataset` and `dataset_view` are deliberately two independent, non-inheriting types (no shared_ptr, no "sometimes owning" object): `dataset` holds the owning payload, `dataset_view` the corresponding non-owning payload.
-
-```cpp
-template <typename T, typename IdxT, typename SpecT>
-struct dataset;
-```
-
-<a id="neighbors-vpq-dataset-spec"></a>
-### neighbors::vpq_dataset_spec
-
-`Accessor` drives both codebook and code residency, mirroring today's
-
-single-`Accessor`-per-VPQ-dataset design. The payload (`detail::vpq_owning_storage` / `detail::vpq_view_storage`) holds the encoded rows and the VQ/PQ codebooks.
-
-```cpp
-template <typename MathT, typename Accessor>
-struct vpq_dataset_spec;
-```
-
-<a id="neighbors-dataset"></a>
-### neighbors::dataset
-
-Owning dataset: value-held payload (no shared_ptr -- exclusive ownership). Every member is a
-
-one-line forward to `spec_type::get_*` or to the payload; all per-kind state and logic lives in the spec's `data_type`, never inside this struct.
-
-```cpp
-template <typename T, typename IdxT, typename SpecT>
-struct dataset;
-```
-
-<a id="neighbors-dataset-view"></a>
-### neighbors::dataset_view
-
-Non-owning dataset view: holds only the view-shaped payload. Deliberately not derived from
-
-`dataset` -- a view type holds "all view state" with no inheritance and no shared ownership tying it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec functions as `dataset`, fed the view payload instead of the owning one.
-
-```cpp
-template <typename T, typename IdxT, typename SpecT>
-struct dataset_view;
-```
-
-<a id="neighbors-is-padded-dataset"></a>
-### neighbors::is_padded_dataset
-
-Owning-side kind traits (mirror today's `is_padded_dataset_v`/`is_standard_dataset_v`/
-
-`is_vpq_dataset_v`, used for SFINAE overload selection in factory.cuh/compute_distance_vpq.hpp).
-
-```cpp
-template <typename DatasetT>
-struct is_padded_dataset;
-```
-
-<a id="neighbors-dataset-view-kind-of"></a>
-### neighbors::dataset_view_kind_of
-
-Primary template returns `unknown` so traits safely return `false` for non-dataset-view types.
-
-```cpp
-template <typename V>
-struct dataset_view_kind_of {
-  static constexpr dataset_view_kind value;
-};
-```
-
-**Fields**
-
-| Name | Type | Description |
-| --- | --- | --- |
-| `value` | `static constexpr dataset_view_kind` |  |
-
-<a id="neighbors-dataset-view-is-device-accessible"></a>
-### neighbors::dataset_view_is_device_accessible
-
-True when the dataset view accessor is device-accessible.
-
-```cpp
-template <typename V>
-struct dataset_view_is_device_accessible;
-```
-
-<a id="neighbors-with-accessor"></a>
-### neighbors::with_accessor
-
-Generic accessor retargeting while preserving the dataset tag/layout and value/index types:
-
-`dataset&lt;T, IdxT, SpecT&lt;..., OldAccessor&gt;&gt;      -&gt; dataset&lt;T, IdxT, SpecT&lt;..., NewAccessor&gt;&gt;` `dataset_view&lt;T, IdxT, SpecT&lt;..., OldAccessor&gt;&gt; -&gt; dataset_view&lt;T, IdxT, SpecT&lt;..., NewAccessor&gt;&gt;`
-
-```cpp
-template <typename DatasetLikeT, typename NewAccessor>
-struct with_accessor;
-```
-
-<a id="neighbors-to-device-accessor"></a>
-### neighbors::to_device_accessor
-
-Map any host accessor to its device counterpart (same payload policy).
-
-```cpp
-template <typename Accessor>
-struct to_device_accessor;
-```
-
-<a id="neighbors-device-counterpart"></a>
-### neighbors::device_counterpart
-
-Maps a host dataset view type to its device-resident counterpart.
-
-```cpp
-template <typename HostViewT>
-struct device_counterpart;
-```
-
-<a id="neighbors-ivf-list-base"></a>
-### neighbors::ivf::list_base
-
-Abstract base class for IVF list data.
-
-This allows polymorphic access to list data regardless of the underlying layout.
-
-TODO: Make this struct internal (tracking issue: https://github.com/nvidia/cuvs/issues/1726)
-
-```cpp
-template <typename ValueT, typename IdxT, typename SizeT = uint32_t>
-struct list_base;
-```
-
-<a id="neighbors-ivf-list"></a>
-### neighbors::ivf::list
-
-The data for a single IVF list.
-
-```cpp
-template <template <typename, typename...> typename SpecT,
-typename SizeT,
-typename... SpecExtraArgs>
-struct list : public list_base<typename SpecT<SizeT, SpecExtraArgs...>::value_type,
-typename SpecT<SizeT, SpecExtraArgs...>::index_type,
-SizeT> {
-  raft::device_mdarray<value_type, list_extents, raft::row_major> data;
-  raft::device_mdarray<index_type, raft::extent_1d<size_type>, raft::row_major> indices;
-  std::atomic<size_type> size;
-};
-```
-
-**Fields**
-
-| Name | Type | Description |
-| --- | --- | --- |
-| `data` | [`raft::device_mdarray<value_type, list_extents, raft::row_major>`](/api-reference/cpp-api-neighbors-ivf-pq#list-extents) | Possibly encoded data; it's layout is defined by `SpecT`. |
-| `indices` | `raft::device_mdarray<index_type, raft::extent_1d<size_type>, raft::row_major>` | Source indices. |
-| `size` | `std::atomic<size_type>` | The actual size of the content. |
-
 ## Filtering for ANN Types
 
 <a id="neighbors-filtering-filtertype"></a>
@@ -575,6 +413,48 @@ struct udf_filter : public base_filter {
 | `filtering_rate` | `float` | Estimated fraction of rows rejected by the predicate, or negative if unknown. |
 | `function_name` | `std::string` | Device function name to call from the generated CAGRA sample filter. |
 
+## Types
+
+<a id="neighbors-ivf-list-base"></a>
+### neighbors::ivf::list_base
+
+Abstract base class for IVF list data.
+
+This allows polymorphic access to list data regardless of the underlying layout.
+
+TODO: Make this struct internal (tracking issue: https://github.com/nvidia/cuvs/issues/1726)
+
+```cpp
+template <typename ValueT, typename IdxT, typename SizeT = uint32_t>
+struct list_base;
+```
+
+<a id="neighbors-ivf-list"></a>
+### neighbors::ivf::list
+
+The data for a single IVF list.
+
+```cpp
+template <template <typename, typename...> typename SpecT,
+typename SizeT,
+typename... SpecExtraArgs>
+struct list : public list_base<typename SpecT<SizeT, SpecExtraArgs...>::value_type,
+typename SpecT<SizeT, SpecExtraArgs...>::index_type,
+SizeT> {
+  raft::device_mdarray<value_type, list_extents, raft::row_major> data;
+  raft::device_mdarray<index_type, raft::extent_1d<size_type>, raft::row_major> indices;
+  std::atomic<size_type> size;
+};
+```
+
+**Fields**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| `data` | [`raft::device_mdarray<value_type, list_extents, raft::row_major>`](/api-reference/cpp-api-neighbors-ivf-pq#list-extents) | Possibly encoded data; it's layout is defined by `SpecT`. |
+| `indices` | `raft::device_mdarray<index_type, raft::extent_1d<size_type>, raft::row_major>` | Source indices. |
+| `size` | `std::atomic<size_type>` | The actual size of the content. |
+
 ## ANN MG index build parameters
 
 <a id="neighbors-distribution-mode"></a>
diff --git a/fern/pages/cpp_api/index.md b/fern/pages/cpp_api/index.md
index 07115a5eca..67cb45e0f8 100644
--- a/fern/pages/cpp_api/index.md
+++ b/fern/pages/cpp_api/index.md
@@ -13,6 +13,7 @@ These pages are generated from the documented public headers in the cuVS source
 
 - [Bloom Filter](/api-reference/cpp-api-core-bloom-filter)
 - [Common Types](/api-reference/cpp-api-common-types)
+- [Dataset](/api-reference/cpp-api-core-dataset)
 - [Roaring Allowlist](/api-reference/cpp-api-core-roaring-allowlist)
 
 ## Distance

From d48bd913ff3a4252d76f3f2dc0511e8ed96267c0 Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Fri, 2 Oct 2026 14:06:26 -0700
Subject: [PATCH 09/15] Make quantized datasets children of the core dataset;
 drop kind enum (#2395)

core/dataset.hpp is the root of the dataset header tree and must not know
about any compressed kind. Quantizers (pq.hpp, bbq.hpp) include it and
define their datasets as children of dataset/dataset_view, with no
dependency on anything in neighbors/.

core/dataset.hpp:
- Remove the dataset_view_kind enum and dataset_view_kind_of, which named
  vpq_f16/vpq_f32/bbq, and every VPQ-specific type and trait.
- Padded/standard/empty classification is built directly on the spec
  types. New generic dataset_view_has_spec_v<V, SpecPred> lets any kind
  classify its own views with a spec predicate.
- is_dataset_view_v replaces "kind != unknown"; it is false (never a hard
  error) for non-dataset types such as the plain mdspans passed to the
  deprecated build() overloads.
- with_accessor is generic: every spec provides rebind_accessor<NewAccessor>,
  replacing the eight per-kind specializations.
- compatible_host_device_dataset_views_v is "same type as
  device_counterpart_t<H>" instead of comparing kind enums.

quantize/pq.hpp (cuvs::preprocessing::quantize::pq):
- Now holds the VPQ payloads (vpq_owning_storage / vpq_view_storage),
  vpq_dataset_spec, the device_/host_vpq_dataset[_view] aliases, the
  is_vpq_* traits (including the f16/f32 variants) and vpq_params.
- Includes core/dataset.hpp and cluster/kmeans.hpp only; no longer
  includes neighbors/common.hpp.

quantize/bbq.hpp (cuvs::preprocessing::quantize::bbq):
- Includes core/dataset.hpp instead of neighbors/common.hpp. The BBQ
  payloads, bbq_dataset_spec, aliases and traits move here from
  cuvs::neighbors, classified through dataset_view_has_spec_v.

This is a breaking change to the public C++ API: device_vpq_dataset[_view],
host_vpq_dataset[_view], vpq_params, is_vpq_*, device_bbq_dataset[_view] and
is_bbq_* are no longer in cuvs::neighbors. Call sites (CAGRA, NN-descent,
Vamana, SCANN, the C API, benchmarks and tests) are updated; cagra.hpp and
the serialize/test helpers now include pq.hpp explicitly. Fern API pages
are regenerated.

Not done yet: the dataset types themselves are still in cuvs::neighbors
(core/dataset.hpp), so pq.hpp/bbq.hpp still name cuvs::neighbors::dataset;
moving them to cuvs::core is the next step.

Verified: full rebuild clean (13 test targets, including after
clang-format). DATASET_C_TEST (9), CAGRA_C_TEST (15), PREPROCESSING_TEST
(226), NEIGHBORS_TEST (371), NEIGHBORS_ANN_CAGRA_BBQ_UINT32_TEST (105),
NEIGHBORS_ANN_NN_DESCENT_TEST (572), NEIGHBORS_ANN_CAGRA_MERGE_TEST (26),
NEIGHBORS_ANN_CAGRA_FLOAT_UINT32_TEST (3594), NEIGHBORS_ANN_SCANN_TEST
(105), NEIGHBORS_ANN_VAMANA_TEST (1260), NEIGHBORS_HNSW_TEST (256),
NEIGHBORS_TIERED_INDEX_TEST (72) and NEIGHBORS_MG_TEST pass. The ANN
benchmarks are not built in this configuration, so those sources were
updated but not compiled.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 c/src/neighbors/cagra.cpp                     |  40 +-
 .../src/cuvs/cuvs_ann_bench_param_parser.h    |   5 +-
 cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h   |  15 +-
 cpp/include/cuvs/core/dataset.hpp             | 402 +++---------------
 cpp/include/cuvs/neighbors/cagra.hpp          | 341 ++++++++++-----
 cpp/include/cuvs/neighbors/common.hpp         |  58 ---
 cpp/include/cuvs/neighbors/nn_descent.hpp     |  14 +-
 .../cuvs/preprocessing/quantize/bbq.hpp       |  50 ++-
 .../cuvs/preprocessing/quantize/pq.hpp        | 336 ++++++++++++++-
 .../preprocessing/bbq_cpu_quantize.hpp        |  15 +-
 cpp/src/neighbors/cagra.cuh                   |   9 +-
 cpp/src/neighbors/cagra_build_inst.cu.in      |   5 +-
 cpp/src/neighbors/cagra_search_inst.cu.in     |   8 +-
 cpp/src/neighbors/cagra_serialize_inst.cu.in  |   3 +-
 .../neighbors/detail/cagra/cagra_build.cuh    |  34 +-
 .../neighbors/detail/cagra/cagra_search.cuh   |   3 +-
 .../detail/cagra/cagra_serialize.cuh          |   4 +-
 .../detail/cagra/compute_distance_vpq.hpp     |   4 +-
 cpp/src/neighbors/detail/cagra/factory.cuh    |   2 +-
 .../neighbors/detail/cagra/graph_shared.cu    |  27 +-
 .../neighbors/detail/cagra/graph_shared.cuh   |  10 +-
 .../neighbors/detail/dataset_serialize.hpp    |   5 +-
 cpp/src/neighbors/detail/nn_descent.cuh       |  15 +-
 cpp/src/neighbors/detail/nn_descent_gnnd.hpp  |  15 +-
 .../neighbors/detail/vamana/vamana_build.cuh  |   2 +-
 cpp/src/neighbors/detail/vpq_dataset.cuh      |  23 +-
 cpp/src/neighbors/nn_descent.cuh              |   5 +-
 cpp/src/neighbors/nn_descent_gnnd_inst.cu     |   3 +-
 cpp/src/neighbors/nn_descent_inst.cu.in       |   2 +-
 cpp/src/preprocessing/quantize/detail/pq.cuh  |  24 +-
 cpp/src/preprocessing/quantize/pq.cu          |  14 +-
 .../ann_cagra/bug_iterative_cagra_build.cu    |   2 +-
 .../ann_cagra/test_iterative_cagra_q.cu       |   4 +-
 cpp/tests/neighbors/ann_cagra_bbq.cuh         |   2 +-
 cpp/tests/neighbors/ann_scann.cuh             |   2 +-
 cpp/tests/neighbors/vpq_utils.cuh             |   8 +-
 .../preprocessing/product_quantization.cu     |   4 +-
 fern/pages/cpp_api/cpp-api-core-dataset.md    |  48 +--
 fern/pages/cpp_api/cpp-api-neighbors-cagra.md | 133 +++---
 .../cpp_api/cpp-api-neighbors-nn-descent.md   |  22 +-
 .../cpp-api-preprocessing-quantize-bbq.md     |  26 +-
 .../cpp-api-preprocessing-quantize-pq.md      |  88 +++-
 42 files changed, 1014 insertions(+), 818 deletions(-)

diff --git a/c/src/neighbors/cagra.cpp b/c/src/neighbors/cagra.cpp
index e89555c03f..ca941d958e 100644
--- a/c/src/neighbors/cagra.cpp
+++ b/c/src/neighbors/cagra.cpp
@@ -73,9 +73,9 @@ constexpr auto sg_cagra_index_layout_from_view()
     return sg_cagra_c_api_index_box::dataset_layout::device_standard;
   } else if constexpr (cuvs::neighbors::is_device_padded_dataset_view_v<DatasetViewT>) {
     return sg_cagra_c_api_index_box::dataset_layout::device_padded;
-  } else if constexpr (cuvs::neighbors::is_device_vpq_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::preprocessing::quantize::pq::is_device_vpq_dataset_view_v<DatasetViewT>) {
     return sg_cagra_c_api_index_box::dataset_layout::device_vpq;
-  } else if constexpr (cuvs::neighbors::is_device_bbq_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::preprocessing::quantize::bbq::is_device_bbq_dataset_view_v<DatasetViewT>) {
     return sg_cagra_c_api_index_box::dataset_layout::device_bbq;
   } else if constexpr (cuvs::neighbors::is_host_standard_dataset_view_v<DatasetViewT>) {
     return sg_cagra_c_api_index_box::dataset_layout::host_standard;
@@ -120,7 +120,7 @@ static void with_index_by_layout(sg_cagra_c_api_index_box* box,
     }
     case sg_cagra_c_api_index_box::dataset_layout::device_vpq: {
       using index_t = cuvs::neighbors::cagra::
-        index<T, IdxT, cuvs::neighbors::device_vpq_dataset_view<half, int64_t>>;
+        index<T, IdxT, cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
       auto* idx = reinterpret_cast<index_t*>(box->index_ptr);
       fn(*idx);
       break;
@@ -410,7 +410,7 @@ static void with_dataset_view(cuvsDataset_t dataset, Fn&& fn)
 }
 
 template <typename T>
-void validate_bbq_layouts(cuvs::neighbors::device_bbq_dataset_view<T, int64_t> const& dataset)
+void validate_bbq_layouts(cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<T, int64_t> const& dataset)
 {
   using layout_t = cuvs::preprocessing::quantize::bbq::bbq_code_layout;
   if (dataset.data().quantizers.size() == 1) {
@@ -446,9 +446,9 @@ auto get_cpp_bbq_quantizer_view(cuvsBbqQuantizer_t quantizer)
 
 template <typename T>
 auto make_bbq_dataset_view(cuvsBbqQuantizer_t* quantizers, std::size_t num_quantizers)
-  -> std::unique_ptr<cuvs::neighbors::device_bbq_dataset_view<T, int64_t>>
+  -> std::unique_ptr<cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<T, int64_t>>
 {
-  using dataset_view_t = cuvs::neighbors::device_bbq_dataset_view<T, int64_t>;
+  using dataset_view_t = cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<T, int64_t>;
   auto dataset         = std::make_unique<dataset_view_t>();
   int64_t expected_rows{-1};
   uint32_t expected_dim{};
@@ -481,7 +481,7 @@ void make_and_bind_bbq_dataset(cuvsBbqQuantizer_t* quantizers,
                                DLDataType dtype,
                                cuvsDataset_t* output)
 {
-  using dataset_view_t = cuvs::neighbors::device_bbq_dataset_view<T, int64_t>;
+  using dataset_view_t = cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<T, int64_t>;
   auto view            = make_bbq_dataset_view<T>(quantizers, num_quantizers);
   validate_bbq_layouts(*view);
 
@@ -495,8 +495,8 @@ void make_and_bind_bbq_dataset(cuvsBbqQuantizer_t* quantizers,
   *output              = handle.release();
 }
 
-using device_vpq_owner_t = cuvs::neighbors::device_vpq_dataset<half, int64_t>;
-using device_vpq_view_t  = cuvs::neighbors::device_vpq_dataset_view<half, int64_t>;
+using device_vpq_owner_t = cuvs::preprocessing::quantize::pq::device_vpq_dataset<half, int64_t>;
+using device_vpq_view_t  = cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>;
 
 static void bind_vpq_owner_to_dataset(std::unique_ptr<device_vpq_owner_t> owner,
                                       cuvsDataset_t* output)
@@ -515,9 +515,9 @@ static void bind_vpq_owner_to_dataset(std::unique_ptr<device_vpq_owner_t> owner,
 }
 
 static auto make_cpp_vpq_params(cuvsPqParams const& params)
-  -> cuvs::neighbors::vpq_params
+  -> cuvs::preprocessing::quantize::pq::vpq_params
 {
-  auto out                            = cuvs::neighbors::vpq_params{};
+  auto out                            = cuvs::preprocessing::quantize::pq::vpq_params{};
   out.pq_bits                         = params.pq_bits;
   out.pq_dim                          = params.pq_dim;
   out.vq_n_centers                    = params.vq_n_centers;
@@ -1119,11 +1119,11 @@ void _serialize(cuvsResources_t res, const char *filename,
   with_index_by_layout<T, uint32_t,
                        true>(box, null_handle_err, "", [&](auto &idx) {
     using index_dataset_view_t = std::remove_cvref_t<decltype(idx.dataset())>;
-    if constexpr (cuvs::neighbors::is_bbq_dataset_view_v<index_dataset_view_t>) {
+    if constexpr (cuvs::preprocessing::quantize::bbq::is_bbq_dataset_view_v<index_dataset_view_t>) {
       RAFT_EXPECTS(!include_dataset,
                    "cuvsCagraSerializeGraphAndDataset is not supported for BBQ indices");
       cuvs::neighbors::cagra::serialize(*res_ptr, std::string(filename), idx);
-    } else if constexpr (cuvs::neighbors::is_vpq_dataset_view_v<index_dataset_view_t>) {
+    } else if constexpr (cuvs::preprocessing::quantize::pq::is_vpq_dataset_view_v<index_dataset_view_t>) {
       RAFT_EXPECTS(
         !include_dataset,
         "cuvsCagraSerializeGraphAndDataset is not supported for PQ indices; serialize the PQ "
@@ -1295,8 +1295,8 @@ void _serialize_to_hnswlib(cuvsResources_t res, const char *filename,
       "cuvsCagraSerializeToHnswlib: host indices are allowed",
       [&](auto &idx) {
         using index_dataset_view_t = std::remove_cvref_t<decltype(idx.dataset())>;
-        if constexpr (cuvs::neighbors::is_vpq_dataset_view_v<index_dataset_view_t> ||
-                      cuvs::neighbors::is_bbq_dataset_view_v<index_dataset_view_t>) {
+        if constexpr (cuvs::preprocessing::quantize::pq::is_vpq_dataset_view_v<index_dataset_view_t> ||
+                      cuvs::preprocessing::quantize::bbq::is_bbq_dataset_view_v<index_dataset_view_t>) {
           RAFT_FAIL("cuvsCagraSerializeToHnswlib is not supported for quantized dataset layouts");
         } else {
           cuvs::neighbors::cagra::serialize_to_hnswlib(
@@ -1378,8 +1378,8 @@ void get_dataset_view(cuvsCagraIndex_t index, DLManagedTensor* dataset)
     "cuvsCagraIndexGetDataset: host indices are allowed",
     [&](auto& idx) {
       using index_dataset_view_t = std::remove_cvref_t<decltype(idx.dataset())>;
-      if constexpr (cuvs::neighbors::is_vpq_dataset_view_v<index_dataset_view_t> ||
-                    cuvs::neighbors::is_bbq_dataset_view_v<index_dataset_view_t>) {
+      if constexpr (cuvs::preprocessing::quantize::pq::is_vpq_dataset_view_v<index_dataset_view_t> ||
+                    cuvs::preprocessing::quantize::bbq::is_bbq_dataset_view_v<index_dataset_view_t>) {
         RAFT_FAIL(
           "cuvsCagraIndexGetDataset does not expose quantized datasets as dense DLPack tensors");
       } else {
@@ -1921,8 +1921,8 @@ static void build_dispatch_on_mem_type_and_layout(raft::resources* res_ptr,
   if (dataset->layout == CUVS_DATASET_LAYOUT_BBQ) {
     RAFT_EXPECTS(dataset->mem_type == CUVS_DATASET_MEM_TYPE_DEVICE,
                  "cuvsCagraBuild: BBQ dataset must be device-resident");
-    using owner_t = cuvs::neighbors::device_bbq_dataset<T, int64_t>;
-    using view_t  = cuvs::neighbors::device_bbq_dataset_view<T, int64_t>;
+    using owner_t = cuvs::preprocessing::quantize::bbq::device_bbq_dataset<T, int64_t>;
+    using view_t  = cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<T, int64_t>;
     with_dataset_view<owner_t, view_t>(dataset, [&](auto const& view) {
       build_index_from_dataset_view<T>(res_ptr, params, view, index);
     });
@@ -2302,7 +2302,7 @@ extern "C" cuvsError_t cuvsCagraMergeParamsDestroy(cuvsCagraMergeParams_t params
 extern "C" cuvsError_t cuvsCagraCompressionParamsCreate(cuvsCagraCompressionParams_t* params)
 {
   return cuvs::core::translate_exceptions([=] {
-    auto ps = cuvs::neighbors::vpq_params();
+    auto ps = cuvs::preprocessing::quantize::pq::vpq_params();
     *params =
       new cuvsCagraCompressionParams{.pq_bits                     = ps.pq_bits,
                                      .pq_dim                      = ps.pq_dim,
diff --git a/cpp/bench/ann/src/cuvs/cuvs_ann_bench_param_parser.h b/cpp/bench/ann/src/cuvs/cuvs_ann_bench_param_parser.h
index 3b5dfd16ab..083def411a 100644
--- a/cpp/bench/ann/src/cuvs/cuvs_ann_bench_param_parser.h
+++ b/cpp/bench/ann/src/cuvs/cuvs_ann_bench_param_parser.h
@@ -271,7 +271,8 @@ void parse_build_param(const nlohmann::json& conf, cuvs::neighbors::nn_descent::
   }
 }
 
-inline void parse_build_param(const nlohmann::json& conf, cuvs::neighbors::vpq_params& param)
+inline void parse_build_param(const nlohmann::json& conf,
+                              cuvs::preprocessing::quantize::pq::vpq_params& param)
 {
   if (conf.contains("pq_bits")) { param.pq_bits = conf.at("pq_bits"); }
   if (conf.contains("pq_dim")) { param.pq_dim = conf.at("pq_dim"); }
@@ -445,7 +446,7 @@ void parse_build_param(const nlohmann::json& conf,
 
   nlohmann::json comp_search_conf = collect_conf_with_prefix(conf, "compression_");
   if (!comp_search_conf.empty()) {
-    auto vpq_pams = param.compression.value_or(cuvs::neighbors::vpq_params{});
+    auto vpq_pams = param.compression.value_or(cuvs::preprocessing::quantize::pq::vpq_params{});
     parse_build_param(comp_search_conf, vpq_pams);
     param.compression.emplace(vpq_pams);
   }
diff --git a/cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h b/cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h
index da5e5baa9d..680d8f177e 100644
--- a/cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h
+++ b/cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h
@@ -165,9 +165,9 @@ class cuvs_cagra : public algo<T>, public algo_gpu {
     using dataset_dependent_params = std::function<cuvs::neighbors::cagra::index_params(
       raft::matrix_extent<int64_t>, cuvs::distance::DistanceType)>;
     dataset_dependent_params cagra_params;
-    std::optional<cuvs::neighbors::vpq_params> compression = std::nullopt;
-    size_t num_dataset_splits                              = 1;
-    CagraMergeType merge_type                              = CagraMergeType::kPhysical;
+    std::optional<cuvs::preprocessing::quantize::pq::vpq_params> compression = std::nullopt;
+    size_t num_dataset_splits                                                = 1;
+    CagraMergeType merge_type = CagraMergeType::kPhysical;
     cuvs::neighbors::cagra::merge_params merge_params;
   };
 
@@ -267,7 +267,8 @@ class cuvs_cagra : public algo<T>, public algo_gpu {
   std::shared_ptr<std::vector<raft::device_matrix<T, int64_t, raft::row_major>>>
     sub_dataset_buffers_ =
       std::make_shared<std::vector<raft::device_matrix<T, int64_t, raft::row_major>>>();
-  std::shared_ptr<cuvs::neighbors::device_vpq_dataset<half, int64_t>> vpq_dataset_;
+  std::shared_ptr<cuvs::preprocessing::quantize::pq::device_vpq_dataset<half, int64_t>>
+    vpq_dataset_;
   std::shared_ptr<cuvs::neighbors::cagra::device_pq_index<T, IdxT, half>> vpq_index_;
 
   inline rmm::device_async_resource_ref get_mr(AllocatorType mem_type)
@@ -410,8 +411,10 @@ void cuvs_cagra<T, IdxT>::compress_dataset(const T* dataset, size_t nrow)
   // make_vpq_dataset() reads the rows wherever they are: host-resident ones are subsampled and
   // encoded in bounded batches instead of being staged on the device.
   auto src = raft::make_device_matrix_view<const T, int64_t, raft::row_major>(dataset, rows, dim_);
-  vpq_dataset_ = std::make_shared<cuvs::neighbors::device_vpq_dataset<half, int64_t>>(
-    cuvs::preprocessing::quantize::pq::make_vpq_dataset(handle_, *index_params_.compression, src));
+  vpq_dataset_ =
+    std::make_shared<cuvs::preprocessing::quantize::pq::device_vpq_dataset<half, int64_t>>(
+      cuvs::preprocessing::quantize::pq::make_vpq_dataset(
+        handle_, *index_params_.compression, src));
   vpq_index_ = std::make_shared<cuvs::neighbors::cagra::device_pq_index<T, IdxT, half>>(
     handle_, parse_metric_type(metric_), vpq_dataset_->as_dataset_view(), index_->graph());
 
diff --git a/cpp/include/cuvs/core/dataset.hpp b/cpp/include/cuvs/core/dataset.hpp
index aac994b01b..70e89fc58d 100644
--- a/cpp/include/cuvs/core/dataset.hpp
+++ b/cpp/include/cuvs/core/dataset.hpp
@@ -30,9 +30,6 @@
 #include <numeric>
 #include <type_traits>
 #include <utility>
-#ifdef __cpp_lib_bitops
-#include <bit>
-#endif
 
 namespace CUVS_EXPORT cuvs {
 namespace neighbors {
@@ -45,8 +42,10 @@ namespace neighbors {
  * `view_type`, chosen by the spec) and expose only what every dataset has: `n_rows()`, `dim()`,
  * `as_matrix_view()`, `as_dataset_view()` and `data()`. Each is a one-line forward to one of the
  * three spec functions `get_data_view()`, `get_n_rows()` and `get_dim()`. Anything else a kind
- * needs (e.g. VPQ codebooks, BBQ quantizers) is state and methods of that kind's payload type,
- * reached through `data()`; `dataset`/`dataset_view` never name or branch on it. `dataset` and
+ * needs (e.g. codebooks or quantizers of a compressed dataset) is state and methods of that
+ * kind's payload type, reached through `data()`; `dataset`/`dataset_view` never name or branch on
+ * it. Compressed kinds define their payloads and specs in their own headers (quantize/pq.hpp,
+ * quantize/bbq.hpp) as children of these two structs. `dataset` and
  * `dataset_view` are deliberately two independent, non-inheriting types (no shared_ptr, no
  * "sometimes owning" object): `dataset` holds the owning payload, `dataset_view` the
  * corresponding non-owning payload.
@@ -99,23 +98,6 @@ using dense_view_matrix = raft::mdspan<const DataT,
                                        raft::row_major,
                                        dataset_view_accessor_for_owning<DataT, Accessor>>;
 
-template <typename MathT, typename IdxT, typename Accessor>
-using vpq_vq_book_matrix =
-  raft::mdarray<MathT, raft::matrix_extent<uint32_t>, raft::row_major, Accessor>;
-
-// VPQ codes are always uint8_t regardless of MathT, so retarget the owning accessor's element
-// type instead of re-deriving a device/host matrix; residency is still driven by Accessor.
-template <typename NewT, typename Accessor>
-using owning_accessor_with_value_type = std::conditional_t<Accessor::is_device_accessible,
-                                                           device_owning_accessor<NewT>,
-                                                           host_owning_accessor<NewT>>;
-
-template <typename IdxT, typename Accessor>
-using vpq_data_matrix = raft::mdarray<uint8_t,
-                                      raft::matrix_extent<IdxT>,
-                                      raft::row_major,
-                                      owning_accessor_with_value_type<uint8_t, Accessor>>;
-
 // -----------------------------------------------------------------------------
 // empty
 // -----------------------------------------------------------------------------
@@ -228,110 +210,6 @@ struct dense_dataset_spec_impl {
   };
 };
 
-// -----------------------------------------------------------------------------
-// vpq payloads: everything VPQ-specific lives here, not in dataset/dataset_view.
-// -----------------------------------------------------------------------------
-
-/** Read-only helpers derived from the codebook shapes; shared by the owning and view payloads.
- * `Derived` provides `vq_code_book`, `pq_code_book` and the codes' `extent(r)`. */
-template <typename Derived>
-struct vpq_codebook_helpers {
-  /** Logical dimension: it comes from the VQ codebook, not from the encoded rows (row padding
-   * makes the encoded-row width ambiguous as a dimension). */
-  [[nodiscard]] auto dim() const noexcept -> uint32_t
-  {
-    return static_cast<uint32_t>(self().vq_code_book.extent(1));
-  }
-  [[nodiscard]] auto vq_n_centers() const noexcept -> uint32_t
-  {
-    return static_cast<uint32_t>(self().vq_code_book.extent(0));
-  }
-  [[nodiscard]] auto pq_n_centers() const noexcept -> uint32_t
-  {
-    return static_cast<uint32_t>(self().pq_code_book.extent(0));
-  }
-  [[nodiscard]] auto pq_len() const noexcept -> uint32_t
-  {
-    return static_cast<uint32_t>(self().pq_code_book.extent(1));
-  }
-  [[nodiscard]] auto pq_bits() const noexcept -> uint32_t
-  {
-    auto pq_width = pq_n_centers();
-#ifdef __cpp_lib_bitops
-    return std::countr_zero(pq_width);
-#else
-    uint32_t bits = 0;
-    while (pq_width > 1) {
-      bits++;
-      pq_width >>= 1;
-    }
-    return bits;
-#endif
-  }
-  [[nodiscard]] auto pq_dim() const noexcept -> uint32_t
-  {
-    return raft::div_rounding_up_unsafe(dim(), pq_len());
-  }
-  [[nodiscard]] auto encoded_row_length() const noexcept -> uint32_t
-  {
-    return static_cast<uint32_t>(self().extent(1));
-  }
-
- private:
-  [[nodiscard]] auto self() const noexcept -> Derived const&
-  {
-    return static_cast<Derived const&>(*this);
-  }
-};
-
-/** Owning VPQ payload: the encoded rows (it *is* the `uint8_t` codes mdarray) plus the VQ and PQ
- * codebooks. `Accessor` drives both codebook and code residency. */
-template <typename MathT, typename IdxT, typename Accessor>
-struct vpq_owning_storage : public vpq_data_matrix<IdxT, Accessor>,
-                            public vpq_codebook_helpers<vpq_owning_storage<MathT, IdxT, Accessor>> {
-  using codes_type   = vpq_data_matrix<IdxT, Accessor>;
-  using vq_book_type = vpq_vq_book_matrix<MathT, IdxT, Accessor>;
-  using pq_book_type = vpq_vq_book_matrix<MathT, IdxT, Accessor>;
-
-  vq_book_type vq_code_book;
-  pq_book_type pq_code_book;
-
-  vpq_owning_storage(codes_type&& codes, vq_book_type&& vq_codes, pq_book_type&& pq_codes) noexcept
-    : codes_type{std::move(codes)},
-      vq_code_book{std::move(vq_codes)},
-      pq_code_book{std::move(pq_codes)}
-  {
-  }
-};
-
-/** Non-owning VPQ payload: a view of the encoded rows plus views of the VQ and PQ codebooks. */
-template <typename MathT, typename IdxT, typename Accessor>
-struct vpq_view_storage : public raft::mdspan<const uint8_t,
-                                              raft::matrix_extent<IdxT>,
-                                              raft::row_major,
-                                              dataset_view_accessor_for_owning<uint8_t, Accessor>>,
-                          public vpq_codebook_helpers<vpq_view_storage<MathT, IdxT, Accessor>> {
-  using codes_view_type = raft::mdspan<const uint8_t,
-                                       raft::matrix_extent<IdxT>,
-                                       raft::row_major,
-                                       dataset_view_accessor_for_owning<uint8_t, Accessor>>;
-  using vq_book_view_type =
-    typename vpq_owning_storage<MathT, IdxT, Accessor>::vq_book_type::const_view_type;
-  using pq_book_view_type =
-    typename vpq_owning_storage<MathT, IdxT, Accessor>::pq_book_type::const_view_type;
-
-  vq_book_view_type vq_code_book;
-  pq_book_view_type pq_code_book;
-
-  vpq_view_storage() noexcept = default;
-  vpq_view_storage(codes_view_type codes,
-                   vq_book_view_type vq_codes,
-                   pq_book_view_type pq_codes) noexcept
-    : codes_view_type(codes), vq_code_book(vq_codes), pq_code_book(pq_codes)
-  {
-  }
-};
-
 }  // namespace detail
 
 // -----------------------------------------------------------------------------
@@ -341,6 +219,8 @@ struct vpq_view_storage : public raft::mdspan<const uint8_t,
 template <typename Accessor>
 struct empty_dataset_spec {
   using accessor_type = Accessor;
+  template <typename NewAccessor>
+  using rebind_accessor = empty_dataset_spec<NewAccessor>;
 
   template <typename T, typename IdxT>
   struct apply {
@@ -367,6 +247,8 @@ struct empty_dataset_spec {
 template <typename ContainerPolicy>
 struct padded_dataset_spec {
   using accessor_type = ContainerPolicy;
+  template <typename NewAccessor>
+  using rebind_accessor = padded_dataset_spec<NewAccessor>;
   template <typename T, typename IdxT>
   struct apply : detail::dense_dataset_spec_impl<ContainerPolicy>::template apply<T, IdxT> {};
 };
@@ -374,43 +256,12 @@ struct padded_dataset_spec {
 template <typename ContainerPolicy>
 struct standard_dataset_spec {
   using accessor_type = ContainerPolicy;
+  template <typename NewAccessor>
+  using rebind_accessor = standard_dataset_spec<NewAccessor>;
   template <typename T, typename IdxT>
   struct apply : detail::dense_dataset_spec_impl<ContainerPolicy>::template apply<T, IdxT> {};
 };
 
-/** `Accessor` drives both codebook and code residency, mirroring today's
- * single-`Accessor`-per-VPQ-dataset design. The payload (`detail::vpq_owning_storage` /
- * `detail::vpq_view_storage`) holds the encoded rows and the VQ/PQ codebooks. */
-template <typename MathT, typename Accessor>
-struct vpq_dataset_spec {
-  using accessor_type = Accessor;
-
-  template <typename T, typename IdxT>
-  struct apply {
-    using value_type = std::remove_cv_t<T>;
-    using index_type = std::remove_cv_t<IdxT>;
-    using math_type  = MathT;
-
-    using data_type = detail::vpq_owning_storage<MathT, IdxT, Accessor>;
-    using view_type = detail::vpq_view_storage<MathT, IdxT, Accessor>;
-
-    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
-    {
-      return view_type(data.view(), data.vq_code_book.view(), data.pq_code_book.view());
-    }
-    template <typename AnyStorage>
-    [[nodiscard]] static auto get_n_rows(AnyStorage const& data) noexcept -> index_type
-    {
-      return static_cast<index_type>(data.extent(0));
-    }
-    template <typename AnyStorage>
-    [[nodiscard]] static auto get_dim(AnyStorage const& data) noexcept -> uint32_t
-    {
-      return data.dim();
-    }
-  };
-};
-
 // -----------------------------------------------------------------------------
 // dataset / dataset_view
 // -----------------------------------------------------------------------------
@@ -426,7 +277,8 @@ struct dataset {
   using data_type  = typename spec_type::data_type;
 
   // Forward constructor args straight to data_type's own constructor (e.g. (MatrixT&&, uint32_t
-  // logical_dim) for dense, (uint32_t dim) for empty, (codes&&, vq&&, pq&&) for VPQ).
+  // logical_dim) for dense, (uint32_t dim) for empty, or whatever a compressed kind's payload
+  // takes).
   template <typename... Args>
   explicit dataset(Args&&... args)
     requires(std::is_constructible_v<data_type, Args...>)
@@ -436,8 +288,7 @@ struct dataset {
 
   [[nodiscard]] auto n_rows() const noexcept -> index_type { return spec_type::get_n_rows(data_); }
   [[nodiscard]] auto dim() const noexcept -> uint32_t { return spec_type::get_dim(data_); }
-  /** The spec-defined non-owning view of the payload (for dense and VPQ it is an mdspan
-   * derivative). */
+  /** The spec-defined non-owning view of the payload (an mdspan derivative for dense kinds). */
   [[nodiscard]] auto as_matrix_view() const noexcept { return spec_type::get_data_view(data_); }
   [[nodiscard]] auto as_dataset_view() const noexcept -> dataset_view<T, IdxT, SpecT>
   {
@@ -546,22 +397,6 @@ template <typename DataT, typename IdxT>
 using host_standard_dataset_view =
   dataset_view<DataT, IdxT, standard_dataset_spec<detail::host_owning_accessor<DataT>>>;
 
-template <typename DataT, typename IdxT>
-using device_vpq_dataset =
-  dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::device_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using device_vpq_dataset_view =
-  dataset_view<DataT, IdxT, vpq_dataset_spec<DataT, detail::device_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using host_vpq_dataset =
-  dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::host_owning_accessor<DataT>>>;
-
-template <typename DataT, typename IdxT>
-using host_vpq_dataset_view =
-  dataset_view<DataT, IdxT, vpq_dataset_spec<DataT, detail::host_owning_accessor<DataT>>>;
-
 // Maps a dataset view type to its owning (allocating) dataset counterpart. Trivial and total under
 // the Spec design: the owning type for `dataset_view<T,IdxT,SpecT>` is always
 // `dataset<T,IdxT,SpecT>`
@@ -578,7 +413,9 @@ template <typename DatasetViewT>
 using owning_dataset_for_view_t = typename owning_dataset_for_view<DatasetViewT>::type;
 
 // -----------------------------------------------------------------------------
-// Spec-kind classification (all derived from SpecT; dataset/dataset_view never branch on kind).
+// Spec-kind classification. Only the kinds that live in this header are named here; every other
+// kind (e.g. the compressed kinds in quantize/pq.hpp and quantize/bbq.hpp) defines its own spec
+// predicate next to its own spec and reuses `dataset_view_has_spec_v` below.
 // -----------------------------------------------------------------------------
 
 template <typename SpecT>
@@ -602,25 +439,7 @@ struct is_standard_spec<standard_dataset_spec<ContainerPolicy>> : std::true_type
 template <typename SpecT>
 inline constexpr bool is_standard_spec_v = is_standard_spec<SpecT>::value;
 
-template <typename SpecT>
-struct is_vpq_spec : std::false_type {};
-template <typename MathT, typename Accessor>
-struct is_vpq_spec<vpq_dataset_spec<MathT, Accessor>> : std::true_type {};
-template <typename SpecT>
-inline constexpr bool is_vpq_spec_v = is_vpq_spec<SpecT>::value;
-
-template <typename SpecT>
-struct vpq_spec_math_type {};
-template <typename MathT, typename Accessor>
-struct vpq_spec_math_type<vpq_dataset_spec<MathT, Accessor>> {
-  using type = MathT;
-};
-template <typename SpecT>
-using vpq_spec_math_type_t = typename vpq_spec_math_type<SpecT>::type;
-
-/** Owning-side kind traits (mirror today's `is_padded_dataset_v`/`is_standard_dataset_v`/
- * `is_vpq_dataset_v`, used for SFINAE overload selection in factory.cuh/compute_distance_vpq.hpp).
- */
+/** Owning-side kind traits (true for both `dataset<...>` and `dataset_view<...>` of that kind). */
 template <typename DatasetT>
 struct is_padded_dataset : std::false_type {};
 template <typename T, typename IdxT, typename SpecT>
@@ -642,13 +461,6 @@ struct is_standard_dataset<dataset_view<T, IdxT, SpecT>>
 template <typename DatasetT>
 inline constexpr bool is_standard_dataset_v = is_standard_dataset<DatasetT>::value;
 
-template <typename DatasetT>
-struct is_vpq_dataset : std::false_type {};
-template <typename T, typename IdxT, typename SpecT>
-struct is_vpq_dataset<dataset<T, IdxT, SpecT>> : std::bool_constant<is_vpq_spec_v<SpecT>> {};
-template <typename DatasetT>
-inline constexpr bool is_vpq_dataset_v = is_vpq_dataset<DatasetT>::value;
-
 // -----------------------------------------------------------------------------
 // Dataset view compile-time classification (replaces runtime std::variant dispatch).
 // -----------------------------------------------------------------------------
@@ -660,50 +472,28 @@ concept ann_dataset_view = requires(V const& v) {
   { v.dim() } -> std::convertible_to<uint32_t>;
 };
 
-enum class dataset_view_kind {
-  // TODO(removal): Remove `unknown` once all deprecated host_matrix_view / device_matrix_view /
-  // mdspan overloads are deleted. It exists solely so that overload resolution on the deprecated
-  // build(host_matrix_view) / build(device_matrix_view) shims does not cause a hard error when
-  // the compiler evaluates is_host/device_dataset_view_v for a plain mdspan type.
-  unknown,
-  empty,
-  padded,
-  standard,
-  vpq_f16,
-  vpq_f32,
-  bbq,
-};
-
 template <typename V>
 using dataset_view_type_t = std::remove_cvref_t<V>;
 
-/** Primary template returns `unknown` so traits safely return `false` for non-dataset-view types.
- */
+/** True for any `dataset_view<...>` specialization. Evaluates to `false` (never a hard error) for
+ * everything else, e.g. a plain mdspan passed to a deprecated `build(matrix_view)` overload. */
 template <typename V>
-struct dataset_view_kind_of {
-  static constexpr dataset_view_kind value = dataset_view_kind::unknown;
-};
-
+struct is_dataset_view : std::false_type {};
 template <typename T, typename IdxT, typename SpecT>
-struct dataset_view_kind_of<dataset_view<T, IdxT, SpecT>> {
-  static constexpr dataset_view_kind value = []() constexpr {
-    if constexpr (is_empty_spec_v<SpecT>) {
-      return dataset_view_kind::empty;
-    } else if constexpr (is_padded_spec_v<SpecT>) {
-      return dataset_view_kind::padded;
-    } else if constexpr (is_standard_spec_v<SpecT>) {
-      return dataset_view_kind::standard;
-    } else if constexpr (is_vpq_spec_v<SpecT>) {
-      static_assert(std::is_same_v<vpq_spec_math_type_t<SpecT>, half> ||
-                      std::is_same_v<vpq_spec_math_type_t<SpecT>, float>,
-                    "VPQ dataset_view_kind_of expects MathT to be half or float");
-      return std::is_same_v<vpq_spec_math_type_t<SpecT>, half> ? dataset_view_kind::vpq_f16
-                                                               : dataset_view_kind::vpq_f32;
-    } else {
-      return dataset_view_kind::unknown;
-    }
-  }();
-};
+struct is_dataset_view<dataset_view<T, IdxT, SpecT>> : std::true_type {};
+template <typename V>
+inline constexpr bool is_dataset_view_v = is_dataset_view<dataset_view_type_t<V>>::value;
+
+/** True when `V` is a `dataset_view` whose spec satisfies the predicate `SpecPred<SpecT>::value`.
+ * This is how a kind that lives outside this header classifies its own views. */
+template <typename V, template <typename> typename SpecPred>
+struct dataset_view_has_spec : std::false_type {};
+template <typename T, typename IdxT, typename SpecT, template <typename> typename SpecPred>
+struct dataset_view_has_spec<dataset_view<T, IdxT, SpecT>, SpecPred>
+  : std::bool_constant<SpecPred<SpecT>::value> {};
+template <typename V, template <typename> typename SpecPred>
+inline constexpr bool dataset_view_has_spec_v =
+  dataset_view_has_spec<dataset_view_type_t<V>, SpecPred>::value;
 
 /** True when the dataset view accessor is device-accessible. */
 template <typename V>
@@ -717,17 +507,13 @@ template <typename V>
 inline constexpr bool dataset_view_is_device_accessible_v =
   dataset_view_is_device_accessible<dataset_view_type_t<V>>::value;
 
-template <typename V>
-inline constexpr dataset_view_kind dataset_view_kind_v =
-  dataset_view_kind_of<dataset_view_type_t<V>>::value;
-
 template <typename V>
 inline constexpr bool is_device_empty_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::empty && dataset_view_is_device_accessible_v<V>;
+  dataset_view_has_spec_v<V, is_empty_spec> && dataset_view_is_device_accessible_v<V>;
 
 template <typename V>
 inline constexpr bool is_host_empty_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::empty && !dataset_view_is_device_accessible_v<V>;
+  dataset_view_has_spec_v<V, is_empty_spec> && !dataset_view_is_device_accessible_v<V>;
 
 /** True for any empty dataset view (device or host). */
 template <typename V>
@@ -736,11 +522,11 @@ inline constexpr bool is_empty_dataset_view_v =
 
 template <typename V>
 inline constexpr bool is_device_padded_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::padded && dataset_view_is_device_accessible_v<V>;
+  dataset_view_has_spec_v<V, is_padded_spec> && dataset_view_is_device_accessible_v<V>;
 
 template <typename V>
 inline constexpr bool is_host_padded_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::padded && !dataset_view_is_device_accessible_v<V>;
+  dataset_view_has_spec_v<V, is_padded_spec> && !dataset_view_is_device_accessible_v<V>;
 
 /** True for either `device_padded_dataset_view` or `host_padded_dataset_view`. */
 template <typename V>
@@ -749,119 +535,46 @@ inline constexpr bool is_padded_dataset_view_v =
 
 template <typename V>
 inline constexpr bool is_device_standard_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::standard && dataset_view_is_device_accessible_v<V>;
+  dataset_view_has_spec_v<V, is_standard_spec> && dataset_view_is_device_accessible_v<V>;
 
 template <typename V>
 inline constexpr bool is_host_standard_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::standard && !dataset_view_is_device_accessible_v<V>;
+  dataset_view_has_spec_v<V, is_standard_spec> && !dataset_view_is_device_accessible_v<V>;
 
 /** True for either `device_standard_dataset_view` or `host_standard_dataset_view`. */
 template <typename V>
 inline constexpr bool is_standard_dataset_view_v =
   is_device_standard_dataset_view_v<V> || is_host_standard_dataset_view_v<V>;
 
-template <typename V>
-inline constexpr bool is_device_vpq_f16_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::vpq_f16 && dataset_view_is_device_accessible_v<V>;
-
-template <typename V>
-inline constexpr bool is_host_vpq_f16_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::vpq_f16 && !dataset_view_is_device_accessible_v<V>;
-
-template <typename V>
-inline constexpr bool is_vpq_f16_dataset_view_v =
-  is_device_vpq_f16_dataset_view_v<V> || is_host_vpq_f16_dataset_view_v<V>;
-
-template <typename V>
-inline constexpr bool is_device_vpq_f32_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::vpq_f32 && dataset_view_is_device_accessible_v<V>;
-
-template <typename V>
-inline constexpr bool is_host_vpq_f32_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::vpq_f32 && !dataset_view_is_device_accessible_v<V>;
-
-template <typename V>
-inline constexpr bool is_vpq_f32_dataset_view_v =
-  is_device_vpq_f32_dataset_view_v<V> || is_host_vpq_f32_dataset_view_v<V>;
-
-template <typename V>
-inline constexpr bool is_device_vpq_dataset_view_v =
-  is_device_vpq_f16_dataset_view_v<V> || is_device_vpq_f32_dataset_view_v<V>;
-
-template <typename V>
-inline constexpr bool is_host_vpq_dataset_view_v =
-  is_host_vpq_f16_dataset_view_v<V> || is_host_vpq_f32_dataset_view_v<V>;
-
-template <typename V>
-inline constexpr bool is_vpq_dataset_view_v =
-  is_device_vpq_dataset_view_v<V> || is_host_vpq_dataset_view_v<V>;
-
 /** True for any device-resident dataset view. */
 template <typename V>
 inline constexpr bool is_device_dataset_view_v =
-  dataset_view_kind_v<V> != dataset_view_kind::unknown && dataset_view_is_device_accessible_v<V>;
+  is_dataset_view_v<V> && dataset_view_is_device_accessible_v<V>;
 
 /** True for any host-resident dataset view. */
 template <typename V>
 inline constexpr bool is_host_dataset_view_v =
-  dataset_view_kind_v<V> != dataset_view_kind::unknown && !dataset_view_is_device_accessible_v<V>;
+  is_dataset_view_v<V> && !dataset_view_is_device_accessible_v<V>;
 
 /**
- * True when a host view `H` and device view `D` represent the same storage kind and differ
- * only in residency (host vs. device). Used by host/device conversion helpers.
- */
-template <typename HostViewT, typename DeviceViewT>
-inline constexpr bool compatible_host_device_dataset_views_v =
-  is_host_dataset_view_v<HostViewT> && is_device_dataset_view_v<DeviceViewT> &&
-  (dataset_view_kind_v<HostViewT> == dataset_view_kind_v<DeviceViewT>);
-
-/**
- * Generic accessor retargeting while preserving the dataset tag/layout and value/index types:
+ * Generic accessor retargeting while preserving the spec kind and value/index types:
  * `dataset<T, IdxT, SpecT<..., OldAccessor>>      -> dataset<T, IdxT, SpecT<..., NewAccessor>>`
  * `dataset_view<T, IdxT, SpecT<..., OldAccessor>> -> dataset_view<T, IdxT, SpecT<...,
  * NewAccessor>>`
+ * Every spec provides `rebind_accessor<NewAccessor>` for this, so this header does not need to
+ * know about any particular kind.
  */
 template <typename DatasetLikeT, typename NewAccessor>
 struct with_accessor;
 
-template <typename T, typename IdxT, typename NewAccessor>
-struct with_accessor<dataset<T, IdxT, empty_dataset_spec<NewAccessor>>, NewAccessor> {
-  using type = dataset<T, IdxT, empty_dataset_spec<NewAccessor>>;
-};
-
-template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset<T, IdxT, padded_dataset_spec<OldAccessor>>, NewAccessor> {
-  using type = dataset<T, IdxT, padded_dataset_spec<NewAccessor>>;
-};
-
-template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset<T, IdxT, standard_dataset_spec<OldAccessor>>, NewAccessor> {
-  using type = dataset<T, IdxT, standard_dataset_spec<NewAccessor>>;
-};
-
-template <typename T, typename IdxT, typename MathT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset<T, IdxT, vpq_dataset_spec<MathT, OldAccessor>>, NewAccessor> {
-  using type = dataset<T, IdxT, vpq_dataset_spec<MathT, NewAccessor>>;
-};
-
-template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset_view<T, IdxT, empty_dataset_spec<OldAccessor>>, NewAccessor> {
-  using type = dataset_view<T, IdxT, empty_dataset_spec<NewAccessor>>;
-};
-
-template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset_view<T, IdxT, padded_dataset_spec<OldAccessor>>, NewAccessor> {
-  using type = dataset_view<T, IdxT, padded_dataset_spec<NewAccessor>>;
-};
-
-template <typename T, typename IdxT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset_view<T, IdxT, standard_dataset_spec<OldAccessor>>, NewAccessor> {
-  using type = dataset_view<T, IdxT, standard_dataset_spec<NewAccessor>>;
+template <typename T, typename IdxT, typename SpecT, typename NewAccessor>
+struct with_accessor<dataset<T, IdxT, SpecT>, NewAccessor> {
+  using type = dataset<T, IdxT, typename SpecT::template rebind_accessor<NewAccessor>>;
 };
 
-template <typename T, typename IdxT, typename MathT, typename OldAccessor, typename NewAccessor>
-struct with_accessor<dataset_view<T, IdxT, vpq_dataset_spec<MathT, OldAccessor>>, NewAccessor> {
-  using type = dataset_view<T, IdxT, vpq_dataset_spec<MathT, NewAccessor>>;
+template <typename T, typename IdxT, typename SpecT, typename NewAccessor>
+struct with_accessor<dataset_view<T, IdxT, SpecT>, NewAccessor> {
+  using type = dataset_view<T, IdxT, typename SpecT::template rebind_accessor<NewAccessor>>;
 };
 
 template <typename DatasetLikeT, typename NewAccessor>
@@ -900,12 +613,21 @@ struct device_counterpart<dataset_view<T, IdxT, SpecT>> {
 template <typename HostViewT>
 using device_counterpart_t = typename device_counterpart<dataset_view_type_t<HostViewT>>::type;
 
-/** True for device padded or standard views accepted by dense graph build (VPQ excluded). */
+/**
+ * True when a host view `H` and device view `D` represent the same storage kind and differ
+ * only in residency (host vs. device). Used by host/device conversion helpers.
+ */
+template <typename HostViewT, typename DeviceViewT>
+inline constexpr bool compatible_host_device_dataset_views_v =
+  is_host_dataset_view_v<HostViewT> && is_device_dataset_view_v<DeviceViewT> &&
+  std::is_same_v<device_counterpart_t<HostViewT>, dataset_view_type_t<DeviceViewT>>;
+
+/** True for device padded or standard views accepted by dense graph build. */
 template <typename V>
 inline constexpr bool is_dense_row_major_device_dataset_view_v =
   is_device_padded_dataset_view_v<V> || is_device_standard_dataset_view_v<V>;
 
-/** True for host or device padded/standard views (dense graph build; VPQ excluded). */
+/** True for host or device padded/standard views (dense graph build). */
 template <typename V>
 inline constexpr bool is_dense_row_major_dataset_view_v =
   is_padded_dataset_view_v<V> || is_standard_dataset_view_v<V>;
diff --git a/cpp/include/cuvs/neighbors/cagra.hpp b/cpp/include/cuvs/neighbors/cagra.hpp
index 418db9d88f..93c399e159 100644
--- a/cpp/include/cuvs/neighbors/cagra.hpp
+++ b/cpp/include/cuvs/neighbors/cagra.hpp
@@ -12,6 +12,7 @@
 #include <cuvs/neighbors/ivf_pq.hpp>
 #include <cuvs/neighbors/nn_descent.hpp>
 #include <cuvs/preprocessing/quantize/bbq.hpp>
+#include <cuvs/preprocessing/quantize/pq.hpp>
 #include <cuvs/util/file_io.hpp>
 
 #include <raft/core/device_mdarray.hpp>
@@ -955,20 +956,21 @@ using host_standard_index = index<T, IdxT, cuvs::neighbors::host_standard_datase
 /** CAGRA index with a device-resident VPQ dataset. */
 template <typename T, typename IdxT = uint32_t, typename CodebookT = half>
 using device_pq_index =
-  index<T, IdxT, cuvs::neighbors::device_vpq_dataset_view<CodebookT, int64_t>>;
+  index<T, IdxT, cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<CodebookT, int64_t>>;
 
 /** CAGRA index with a device-resident BBQ-quantized dataset. */
 template <typename T, typename IdxT = uint32_t>
-using device_bbq_index = index<T, IdxT, cuvs::neighbors::device_bbq_dataset_view<T, int64_t>>;
+using device_bbq_index =
+  index<T, IdxT, cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<T, int64_t>>;
 
 /** Index type returned by `cagra::build(res, params, dataset_view)`. */
 template <typename DatasetViewT>
-using cagra_index_t =
-  std::conditional_t<cuvs::neighbors::is_device_vpq_f16_dataset_view_v<DatasetViewT>,
-                     device_pq_index<float>,
-                     index<cuvs::neighbors::cagra_view_element_type_t<DatasetViewT>,
-                           uint32_t,
-                           cuvs::neighbors::dataset_view_type_t<DatasetViewT>>>;
+using cagra_index_t = std::conditional_t<
+  cuvs::preprocessing::quantize::pq::is_device_vpq_f16_dataset_view_v<DatasetViewT>,
+  device_pq_index<float>,
+  index<cuvs::neighbors::cagra_view_element_type_t<DatasetViewT>,
+        uint32_t,
+        cuvs::neighbors::dataset_view_type_t<DatasetViewT>>>;
 
 /**
  * @}
@@ -1020,11 +1022,12 @@ using cagra_index_t =
  * @param[in] res raft resources
  * @param[in] params CAGRA index build parameters
  * @param[in] dataset device VPQ dataset view
- * @return built `index<float, uint32_t, device_vpq_dataset_view<half, int64_t>>`
+ * @return built `index<float, uint32_t,
+ * cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>`
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::device_vpq_dataset_view<half, int64_t> const& dataset)
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::device_pq_index<float, uint32_t, half>;
 
 /**
@@ -1236,30 +1239,34 @@ auto build(raft::resources const& res,
  * @param[in] dataset device BBQ dataset view [n_rows, dim]
  * @return built `device_bbq_index<float, uint32_t>`
  */
-auto build(raft::resources const& res,
-           const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::device_bbq_dataset_view<float, int64_t> const& dataset)
+auto build(
+  raft::resources const& res,
+  const cuvs::neighbors::cagra::index_params& params,
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::device_bbq_index<float, uint32_t>;
 
 /** @copydoc build(raft::resources const& res, const cuvs::neighbors::cagra::index_params& params,
- * cuvs::neighbors::device_bbq_dataset_view<float, int64_t> const& dataset) */
-auto build(raft::resources const& res,
-           const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::device_bbq_dataset_view<half, int64_t> const& dataset)
+ * cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t> const& dataset) */
+auto build(
+  raft::resources const& res,
+  const cuvs::neighbors::cagra::index_params& params,
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<half, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::device_bbq_index<half, uint32_t>;
 
 /** @copydoc build(raft::resources const& res, const cuvs::neighbors::cagra::index_params& params,
- * cuvs::neighbors::device_bbq_dataset_view<float, int64_t> const& dataset) */
-auto build(raft::resources const& res,
-           const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::device_bbq_dataset_view<int8_t, int64_t> const& dataset)
+ * cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t> const& dataset) */
+auto build(
+  raft::resources const& res,
+  const cuvs::neighbors::cagra::index_params& params,
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<int8_t, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::device_bbq_index<int8_t, uint32_t>;
 
 /** @copydoc build(raft::resources const& res, const cuvs::neighbors::cagra::index_params& params,
- * cuvs::neighbors::device_bbq_dataset_view<float, int64_t> const& dataset) */
-auto build(raft::resources const& res,
-           const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::device_bbq_dataset_view<uint8_t, int64_t> const& dataset)
+ * cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t> const& dataset) */
+auto build(
+  raft::resources const& res,
+  const cuvs::neighbors::cagra::index_params& params,
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<uint8_t, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::device_bbq_index<uint8_t, uint32_t>;
 
 /**
@@ -4728,158 +4735,256 @@ auto update_dataset(
 auto update_dataset(
   raft::resources const& res,
   index<float, uint32_t, host_standard_dataset_view<float, int64_t>>&& cagra_index,
-  device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<float, uint32_t, device_vpq_dataset_view<half, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<half, uint32_t, host_standard_dataset_view<half, int64_t>>&& cagra_index,
-                    device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<float,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<half, uint32_t, host_standard_dataset_view<half, int64_t>>&& cagra_index,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<half,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
   index<int8_t, uint32_t, host_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
-  device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<int8_t,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
   index<uint8_t, uint32_t, host_standard_dataset_view<uint8_t, int64_t>>&& cagra_index,
-  device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<uint8_t,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 
-auto update_dataset(raft::resources const& res,
-                    index<float, uint32_t, host_padded_dataset_view<float, int64_t>>&& cagra_index,
-                    device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<float, uint32_t, device_vpq_dataset_view<half, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<half, uint32_t, host_padded_dataset_view<half, int64_t>>&& cagra_index,
-                    device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<float, uint32_t, host_padded_dataset_view<float, int64_t>>&& cagra_index,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<float,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<half, uint32_t, host_padded_dataset_view<half, int64_t>>&& cagra_index,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<half,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
   index<int8_t, uint32_t, host_padded_dataset_view<int8_t, int64_t>>&& cagra_index,
-  device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<int8_t,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
   index<uint8_t, uint32_t, host_padded_dataset_view<uint8_t, int64_t>>&& cagra_index,
-  device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<uint8_t,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 
 auto update_dataset(
   raft::resources const& res,
   index<float, uint32_t, device_standard_dataset_view<float, int64_t>>&& cagra_index,
-  device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<float, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<float,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
   index<half, uint32_t, device_standard_dataset_view<half, int64_t>>&& cagra_index,
-  device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<half,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
   index<int8_t, uint32_t, device_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
-  device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<int8_t,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
   index<uint8_t, uint32_t, device_standard_dataset_view<uint8_t, int64_t>>&& cagra_index,
-  device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<uint8_t,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 
 auto update_dataset(
   raft::resources const& res,
   index<float, uint32_t, device_padded_dataset_view<float, int64_t>>&& cagra_index,
-  device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<float, uint32_t, device_vpq_dataset_view<half, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<half, uint32_t, device_padded_dataset_view<half, int64_t>>&& cagra_index,
-                    device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<float,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<half, uint32_t, device_padded_dataset_view<half, int64_t>>&& cagra_index,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<half,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
   index<int8_t, uint32_t, device_padded_dataset_view<int8_t, int64_t>>&& cagra_index,
-  device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<int8_t,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
   index<uint8_t, uint32_t, device_padded_dataset_view<uint8_t, int64_t>>&& cagra_index,
-  device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<uint8_t,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 
-auto update_dataset(raft::resources const& res,
-                    index<float, uint32_t, device_vpq_dataset_view<half, int64_t>>&& cagra_index,
-                    device_padded_dataset_view<float, int64_t> dataset)
+auto update_dataset(
+  raft::resources const& res,
+  index<float,
+        uint32_t,
+        cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>&& cagra_index,
+  device_padded_dataset_view<float, int64_t> dataset)
   -> index<float, uint32_t, device_padded_dataset_view<float, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<half, uint32_t, device_vpq_dataset_view<half, int64_t>>&& cagra_index,
-                    device_padded_dataset_view<half, int64_t> dataset)
+auto update_dataset(
+  raft::resources const& res,
+  index<half, uint32_t, cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>&&
+    cagra_index,
+  device_padded_dataset_view<half, int64_t> dataset)
   -> index<half, uint32_t, device_padded_dataset_view<half, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<int8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>&& cagra_index,
-                    device_padded_dataset_view<int8_t, int64_t> dataset)
+auto update_dataset(
+  raft::resources const& res,
+  index<int8_t,
+        uint32_t,
+        cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>&& cagra_index,
+  device_padded_dataset_view<int8_t, int64_t> dataset)
   -> index<int8_t, uint32_t, device_padded_dataset_view<int8_t, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<uint8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>&& cagra_index,
-                    device_padded_dataset_view<uint8_t, int64_t> dataset)
+auto update_dataset(
+  raft::resources const& res,
+  index<uint8_t,
+        uint32_t,
+        cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>&& cagra_index,
+  device_padded_dataset_view<uint8_t, int64_t> dataset)
   -> index<uint8_t, uint32_t, device_padded_dataset_view<uint8_t, int64_t>>;
 
-auto update_dataset(raft::resources const& res,
-                    index<float, uint32_t, device_vpq_dataset_view<half, int64_t>>&& cagra_index,
-                    device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<float, uint32_t, device_vpq_dataset_view<half, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<half, uint32_t, device_vpq_dataset_view<half, int64_t>>&& cagra_index,
-                    device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_vpq_dataset_view<half, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<int8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>&& cagra_index,
-                    device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<uint8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>&& cagra_index,
-                    device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<float,
+        uint32_t,
+        cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>&& cagra_index,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<float,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<half, uint32_t, cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>&&
+    cagra_index,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<half,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<int8_t,
+        uint32_t,
+        cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>&& cagra_index,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<int8_t,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<uint8_t,
+        uint32_t,
+        cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>&& cagra_index,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<uint8_t,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 
-auto update_dataset(raft::resources const& res,
-                    index<float, uint32_t, device_bbq_dataset_view<float, int64_t>>&& cagra_index,
-                    device_padded_dataset_view<float, int64_t> dataset)
+auto update_dataset(
+  raft::resources const& res,
+  index<float,
+        uint32_t,
+        cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t>>&& cagra_index,
+  device_padded_dataset_view<float, int64_t> dataset)
   -> index<float, uint32_t, device_padded_dataset_view<float, int64_t>>;
 
-auto update_dataset(raft::resources const& res,
-                    index<half, uint32_t, device_bbq_dataset_view<half, int64_t>>&& cagra_index,
-                    device_padded_dataset_view<half, int64_t> dataset)
+auto update_dataset(
+  raft::resources const& res,
+  index<half,
+        uint32_t,
+        cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<half, int64_t>>&& cagra_index,
+  device_padded_dataset_view<half, int64_t> dataset)
   -> index<half, uint32_t, device_padded_dataset_view<half, int64_t>>;
 
-auto update_dataset(raft::resources const& res,
-                    index<int8_t, uint32_t, device_bbq_dataset_view<int8_t, int64_t>>&& cagra_index,
-                    device_padded_dataset_view<int8_t, int64_t> dataset)
+auto update_dataset(
+  raft::resources const& res,
+  index<int8_t,
+        uint32_t,
+        cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<int8_t, int64_t>>&& cagra_index,
+  device_padded_dataset_view<int8_t, int64_t> dataset)
   -> index<int8_t, uint32_t, device_padded_dataset_view<int8_t, int64_t>>;
 
 auto update_dataset(
   raft::resources const& res,
-  index<uint8_t, uint32_t, device_bbq_dataset_view<uint8_t, int64_t>>&& cagra_index,
+  index<uint8_t,
+        uint32_t,
+        cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<uint8_t, int64_t>>&&
+    cagra_index,
   device_padded_dataset_view<uint8_t, int64_t> dataset)
   -> index<uint8_t, uint32_t, device_padded_dataset_view<uint8_t, int64_t>>;
 
-auto update_dataset(raft::resources const& res,
-                    index<float, uint32_t, device_bbq_dataset_view<float, int64_t>>&& cagra_index,
-                    device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<float, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<float,
+        uint32_t,
+        cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t>>&& cagra_index,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<float,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 
-auto update_dataset(raft::resources const& res,
-                    index<half, uint32_t, device_bbq_dataset_view<half, int64_t>>&& cagra_index,
-                    device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<half,
+        uint32_t,
+        cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<half, int64_t>>&& cagra_index,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<half,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 
-auto update_dataset(raft::resources const& res,
-                    index<int8_t, uint32_t, device_bbq_dataset_view<int8_t, int64_t>>&& cagra_index,
-                    device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<int8_t,
+        uint32_t,
+        cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<int8_t, int64_t>>&& cagra_index,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<int8_t,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 
 auto update_dataset(
   raft::resources const& res,
-  index<uint8_t, uint32_t, device_bbq_dataset_view<uint8_t, int64_t>>&& cagra_index,
-  device_vpq_dataset_view<half, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_vpq_dataset_view<half, int64_t>>;
+  index<uint8_t,
+        uint32_t,
+        cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<uint8_t, int64_t>>&&
+    cagra_index,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
+  -> index<uint8_t,
+           uint32_t,
+           cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 
 }  // namespace cagra
 }  // namespace neighbors
diff --git a/cpp/include/cuvs/neighbors/common.hpp b/cpp/include/cuvs/neighbors/common.hpp
index f23bc8ea95..7d4acc234b 100644
--- a/cpp/include/cuvs/neighbors/common.hpp
+++ b/cpp/include/cuvs/neighbors/common.hpp
@@ -58,64 +58,6 @@ namespace neighbors {
 /* Graph build algo used in cagra and all_neighbors */
 enum GRAPH_BUILD_ALGO { BRUTE_FORCE = 0, IVF_PQ = 1, NN_DESCENT = 2, ACE = 3 };
 
-/** Parameters for VPQ compression. */
-struct vpq_params {
-  /**
-   * The bit length of the vector element after compression by PQ.
-   *
-   * Possible values: [4, 5, 6, 7, 8].
-   *
-   * Hint: the smaller the 'pq_bits', the smaller the index size and the better the search
-   * performance, but the lower the recall.
-   */
-  uint32_t pq_bits = 8;
-  /**
-   * The dimensionality of the vector after compression by PQ.
-   * When zero, an optimal value is selected using a heuristic.
-   *
-   * TODO: at the moment `dim` must be a multiple `pq_dim`.
-   */
-  uint32_t pq_dim = 0;
-  /**
-   * Vector Quantization (VQ) codebook size - number of "coarse cluster centers".
-   * When zero, an optimal value is selected using a heuristic.
-   */
-  uint32_t vq_n_centers = 0;
-  /** The number of iterations searching for kmeans centers (both VQ & PQ phases). */
-  uint32_t kmeans_n_iters = 25;
-  /**
-   * The fraction of data to use during iterative kmeans building (VQ phase).
-   * When zero, an optimal value is selected using a heuristic.
-   * @deprecated Prefer using `max_train_points_per_vq_cluster` instead.
-   */
-  double vq_kmeans_trainset_fraction = 0;
-  /**
-   * The fraction of data to use during iterative kmeans building (PQ phase).
-   * When zero, an optimal value is selected using a heuristic.
-   * @deprecated Prefer using `max_train_points_per_pq_code` instead.
-   */
-  double pq_kmeans_trainset_fraction = 0;
-  /**
-   * Type of k-means algorithm for PQ training.
-   * Balanced k-means tends to be faster than regular k-means for PQ training, for
-   * problem sets where the number of points per cluster are approximately equal.
-   * Regular k-means may be better for skewed cluster distributions.
-   */
-  cuvs::cluster::kmeans::kmeans_type pq_kmeans_type =
-    cuvs::cluster::kmeans::kmeans_type::KMeansBalanced;
-  /**
-   * The max number of data points to use per PQ code during PQ codebook training. Using more data
-   * points per PQ code may increase the quality of PQ codebook but may also increase the build
-   * time. We will use `pq_n_centers * max_train_points_per_pq_code` training
-   * points to train each PQ codebook.
-   */
-  uint32_t max_train_points_per_pq_code = 256;
-  /**
-   * The max number of data points to use per VQ cluster during training.
-   */
-  uint32_t max_train_points_per_vq_cluster = 1024;
-};
-
 /** @} */  // end group cagra_cpp_index_params
 
 /**
diff --git a/cpp/include/cuvs/neighbors/nn_descent.hpp b/cpp/include/cuvs/neighbors/nn_descent.hpp
index 1e1546c651..907fc2f089 100644
--- a/cpp/include/cuvs/neighbors/nn_descent.hpp
+++ b/cpp/include/cuvs/neighbors/nn_descent.hpp
@@ -539,40 +539,40 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            index_params const& params,
-           cuvs::neighbors::device_bbq_dataset_view<float, int64_t> dataset,
+           cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t> dataset,
            std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>> graph =
              std::nullopt) -> cuvs::neighbors::nn_descent::index<uint32_t>;
 /**
  * @copydoc build(raft::resources const& res, index_params const& params,
- * cuvs::neighbors::device_bbq_dataset_view<float, int64_t> dataset,
+ * cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t> dataset,
  * std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>> graph = std::nullopt)
  * -> cuvs::neighbors::nn_descent::index<uint32_t>
  */
 auto build(raft::resources const& res,
            index_params const& params,
-           cuvs::neighbors::device_bbq_dataset_view<half, int64_t> dataset,
+           cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<half, int64_t> dataset,
            std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>> graph =
              std::nullopt) -> cuvs::neighbors::nn_descent::index<uint32_t>;
 /**
  * @copydoc build(raft::resources const& res, index_params const& params,
- * cuvs::neighbors::device_bbq_dataset_view<float, int64_t> dataset,
+ * cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t> dataset,
  * std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>> graph = std::nullopt)
  * -> cuvs::neighbors::nn_descent::index<uint32_t>
  */
 auto build(raft::resources const& res,
            index_params const& params,
-           cuvs::neighbors::device_bbq_dataset_view<int8_t, int64_t> dataset,
+           cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<int8_t, int64_t> dataset,
            std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>> graph =
              std::nullopt) -> cuvs::neighbors::nn_descent::index<uint32_t>;
 /**
  * @copydoc build(raft::resources const& res, index_params const& params,
- * cuvs::neighbors::device_bbq_dataset_view<float, int64_t> dataset,
+ * cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t> dataset,
  * std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>> graph = std::nullopt)
  * -> cuvs::neighbors::nn_descent::index<uint32_t>
  */
 auto build(raft::resources const& res,
            index_params const& params,
-           cuvs::neighbors::device_bbq_dataset_view<uint8_t, int64_t> dataset,
+           cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<uint8_t, int64_t> dataset,
            std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>> graph =
              std::nullopt) -> cuvs::neighbors::nn_descent::index<uint32_t>;
 
diff --git a/cpp/include/cuvs/preprocessing/quantize/bbq.hpp b/cpp/include/cuvs/preprocessing/quantize/bbq.hpp
index 332994a5f3..db0b0c2a1f 100644
--- a/cpp/include/cuvs/preprocessing/quantize/bbq.hpp
+++ b/cpp/include/cuvs/preprocessing/quantize/bbq.hpp
@@ -5,9 +5,9 @@
 
 #pragma once
 
+#include <cuvs/core/dataset.hpp>
 #include <cuvs/core/export.hpp>
 #include <cuvs/distance/distance.hpp>
-#include <cuvs/neighbors/common.hpp>
 
 #include <raft/core/device_mdarray.hpp>
 #include <raft/core/device_mdspan.hpp>
@@ -242,7 +242,12 @@ void resolve_dequant_factors(
 
 }  // namespace preprocessing::quantize::bbq
 
-namespace neighbors {
+namespace preprocessing::quantize::bbq {
+
+// -----------------------------------------------------------------------------
+// BBQ dataset: a child of `cuvs::neighbors::dataset` / `dataset_view`. The quantizers and the
+// methods that manage them live in the payload types below; `dataset` itself knows nothing of them.
+// -----------------------------------------------------------------------------
 
 namespace detail {
 
@@ -340,10 +345,12 @@ struct bbq_view_storage {
 }  // namespace detail
 
 /** BBQ is just another dataset type: it plugs its payloads into the shared `dataset`/
- * `dataset_view` through a spec, like padded/standard/vpq do. */
+ * `dataset_view` through a spec, like every other kind does. */
 template <typename Accessor>
 struct bbq_dataset_spec {
   using accessor_type = Accessor;
+  template <typename NewAccessor>
+  using rebind_accessor = bbq_dataset_spec<NewAccessor>;
 
   template <typename T, typename IdxT>
   struct apply {
@@ -371,39 +378,48 @@ struct bbq_dataset_spec {
 };
 
 template <typename DataT, typename IdxT>
-using device_bbq_dataset =
-  dataset<DataT, IdxT, bbq_dataset_spec<detail::device_owning_accessor<DataT>>>;
+using device_bbq_dataset = cuvs::neighbors::
+  dataset<DataT, IdxT, bbq_dataset_spec<cuvs::neighbors::detail::device_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
-using device_bbq_dataset_view =
-  dataset_view<DataT, IdxT, bbq_dataset_spec<detail::device_owning_accessor<DataT>>>;
+using device_bbq_dataset_view = cuvs::neighbors::dataset_view<
+  DataT,
+  IdxT,
+  bbq_dataset_spec<cuvs::neighbors::detail::device_owning_accessor<DataT>>>;
+
+/** Spec predicate for `cuvs::neighbors::dataset_view_has_spec_v`. */
+template <typename SpecT>
+struct is_bbq_spec : std::false_type {};
+template <typename Accessor>
+struct is_bbq_spec<bbq_dataset_spec<Accessor>> : std::true_type {};
+template <typename SpecT>
+inline constexpr bool is_bbq_spec_v = is_bbq_spec<SpecT>::value;
 
+/** True for an owning `dataset<...>` of the BBQ kind. */
 template <typename DatasetT>
 struct is_bbq_dataset : std::false_type {};
 
-template <typename DataT, typename IdxT, typename Accessor>
-struct is_bbq_dataset<dataset<DataT, IdxT, bbq_dataset_spec<Accessor>>> : std::true_type {};
+template <typename DataT, typename IdxT, typename SpecT>
+struct is_bbq_dataset<cuvs::neighbors::dataset<DataT, IdxT, SpecT>>
+  : std::bool_constant<is_bbq_spec_v<SpecT>> {};
 
 template <typename DatasetT>
 inline constexpr bool is_bbq_dataset_v = is_bbq_dataset<DatasetT>::value;
 
-template <typename DataT, typename IdxT, typename Accessor>
-struct dataset_view_kind_of<dataset_view<DataT, IdxT, bbq_dataset_spec<Accessor>>> {
-  static constexpr dataset_view_kind value = dataset_view_kind::bbq;
-};
-
 template <typename V>
 inline constexpr bool is_device_bbq_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::bbq && dataset_view_is_device_accessible_v<V>;
+  cuvs::neighbors::dataset_view_has_spec_v<V, is_bbq_spec> &&
+  cuvs::neighbors::dataset_view_is_device_accessible_v<V>;
 
 template <typename V>
 inline constexpr bool is_host_bbq_dataset_view_v =
-  dataset_view_kind_v<V> == dataset_view_kind::bbq && !dataset_view_is_device_accessible_v<V>;
+  cuvs::neighbors::dataset_view_has_spec_v<V, is_bbq_spec> &&
+  !cuvs::neighbors::dataset_view_is_device_accessible_v<V>;
 
 template <typename V>
 inline constexpr bool is_bbq_dataset_view_v =
   is_device_bbq_dataset_view_v<V> || is_host_bbq_dataset_view_v<V>;
 
-}  // namespace neighbors
+}  // namespace preprocessing::quantize::bbq
 
 }  // namespace CUVS_EXPORT cuvs
diff --git a/cpp/include/cuvs/preprocessing/quantize/pq.hpp b/cpp/include/cuvs/preprocessing/quantize/pq.hpp
index 4cc2895c24..f23eaaade9 100644
--- a/cpp/include/cuvs/preprocessing/quantize/pq.hpp
+++ b/cpp/include/cuvs/preprocessing/quantize/pq.hpp
@@ -6,7 +6,7 @@
 #pragma once
 
 #include <cuvs/cluster/kmeans.hpp>
-#include <cuvs/neighbors/common.hpp>
+#include <cuvs/core/dataset.hpp>
 #include <raft/core/device_mdspan.hpp>
 #include <raft/core/handle.hpp>
 #include <raft/core/host_mdspan.hpp>
@@ -16,6 +16,9 @@
 #include <cuvs/core/export.hpp>
 #include <type_traits>
 #include <variant>
+#ifdef __cpp_lib_bitops
+#include <bit>
+#endif
 
 namespace CUVS_EXPORT cuvs {
 namespace preprocessing {
@@ -139,6 +142,324 @@ struct params {
   uint32_t max_train_points_per_vq_cluster = 1024;
 };
 
+/** Parameters for VPQ compression. */
+struct vpq_params {
+  /**
+   * The bit length of the vector element after compression by PQ.
+   *
+   * Possible values: [4, 5, 6, 7, 8].
+   *
+   * Hint: the smaller the 'pq_bits', the smaller the index size and the better the search
+   * performance, but the lower the recall.
+   */
+  uint32_t pq_bits = 8;
+  /**
+   * The dimensionality of the vector after compression by PQ.
+   * When zero, an optimal value is selected using a heuristic.
+   *
+   * TODO: at the moment `dim` must be a multiple `pq_dim`.
+   */
+  uint32_t pq_dim = 0;
+  /**
+   * Vector Quantization (VQ) codebook size - number of "coarse cluster centers".
+   * When zero, an optimal value is selected using a heuristic.
+   */
+  uint32_t vq_n_centers = 0;
+  /** The number of iterations searching for kmeans centers (both VQ & PQ phases). */
+  uint32_t kmeans_n_iters = 25;
+  /**
+   * The fraction of data to use during iterative kmeans building (VQ phase).
+   * When zero, an optimal value is selected using a heuristic.
+   * @deprecated Prefer using `max_train_points_per_vq_cluster` instead.
+   */
+  double vq_kmeans_trainset_fraction = 0;
+  /**
+   * The fraction of data to use during iterative kmeans building (PQ phase).
+   * When zero, an optimal value is selected using a heuristic.
+   * @deprecated Prefer using `max_train_points_per_pq_code` instead.
+   */
+  double pq_kmeans_trainset_fraction = 0;
+  /**
+   * Type of k-means algorithm for PQ training.
+   * Balanced k-means tends to be faster than regular k-means for PQ training, for
+   * problem sets where the number of points per cluster are approximately equal.
+   * Regular k-means may be better for skewed cluster distributions.
+   */
+  cuvs::cluster::kmeans::kmeans_type pq_kmeans_type =
+    cuvs::cluster::kmeans::kmeans_type::KMeansBalanced;
+  /**
+   * The max number of data points to use per PQ code during PQ codebook training. Using more data
+   * points per PQ code may increase the quality of PQ codebook but may also increase the build
+   * time. We will use `pq_n_centers * max_train_points_per_pq_code` training
+   * points to train each PQ codebook.
+   */
+  uint32_t max_train_points_per_pq_code = 256;
+  /**
+   * The max number of data points to use per VQ cluster during training.
+   */
+  uint32_t max_train_points_per_vq_cluster = 1024;
+};
+
+// -----------------------------------------------------------------------------
+// VPQ dataset: a child of `cuvs::neighbors::dataset` / `dataset_view`. All VPQ-specific state
+// (codebooks) and methods live in the payload types below; `dataset` itself knows nothing of them.
+// -----------------------------------------------------------------------------
+
+namespace detail {
+
+// The accessor aliases are shared with every dataset kind and live next to `dataset`.
+using cuvs::neighbors::detail::dataset_view_accessor_for_owning;
+using cuvs::neighbors::detail::device_owning_accessor;
+using cuvs::neighbors::detail::host_owning_accessor;
+
+template <typename MathT, typename IdxT, typename Accessor>
+using vpq_vq_book_matrix =
+  raft::mdarray<MathT, raft::matrix_extent<uint32_t>, raft::row_major, Accessor>;
+
+// VPQ codes are always uint8_t regardless of MathT, so retarget the owning accessor's element
+// type instead of re-deriving a device/host matrix; residency is still driven by Accessor.
+template <typename NewT, typename Accessor>
+using owning_accessor_with_value_type = std::conditional_t<Accessor::is_device_accessible,
+                                                           device_owning_accessor<NewT>,
+                                                           host_owning_accessor<NewT>>;
+
+template <typename IdxT, typename Accessor>
+using vpq_data_matrix = raft::mdarray<uint8_t,
+                                      raft::matrix_extent<IdxT>,
+                                      raft::row_major,
+                                      owning_accessor_with_value_type<uint8_t, Accessor>>;
+
+/** Read-only helpers derived from the codebook shapes; shared by the owning and view payloads.
+ * `Derived` provides `vq_code_book`, `pq_code_book` and the codes' `extent(r)`. */
+template <typename Derived>
+struct vpq_codebook_helpers {
+  /** Logical dimension: it comes from the VQ codebook, not from the encoded rows (row padding
+   * makes the encoded-row width ambiguous as a dimension). */
+  [[nodiscard]] auto dim() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().vq_code_book.extent(1));
+  }
+  [[nodiscard]] auto vq_n_centers() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().vq_code_book.extent(0));
+  }
+  [[nodiscard]] auto pq_n_centers() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().pq_code_book.extent(0));
+  }
+  [[nodiscard]] auto pq_len() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().pq_code_book.extent(1));
+  }
+  [[nodiscard]] auto pq_bits() const noexcept -> uint32_t
+  {
+    auto pq_width = pq_n_centers();
+#ifdef __cpp_lib_bitops
+    return std::countr_zero(pq_width);
+#else
+    uint32_t bits = 0;
+    while (pq_width > 1) {
+      bits++;
+      pq_width >>= 1;
+    }
+    return bits;
+#endif
+  }
+  [[nodiscard]] auto pq_dim() const noexcept -> uint32_t
+  {
+    return raft::div_rounding_up_unsafe(dim(), pq_len());
+  }
+  [[nodiscard]] auto encoded_row_length() const noexcept -> uint32_t
+  {
+    return static_cast<uint32_t>(self().extent(1));
+  }
+
+ private:
+  [[nodiscard]] auto self() const noexcept -> Derived const&
+  {
+    return static_cast<Derived const&>(*this);
+  }
+};
+
+/** Owning VPQ payload: the encoded rows (it *is* the `uint8_t` codes mdarray) plus the VQ and PQ
+ * codebooks. `Accessor` drives both codebook and code residency. */
+template <typename MathT, typename IdxT, typename Accessor>
+struct vpq_owning_storage : public vpq_data_matrix<IdxT, Accessor>,
+                            public vpq_codebook_helpers<vpq_owning_storage<MathT, IdxT, Accessor>> {
+  using codes_type   = vpq_data_matrix<IdxT, Accessor>;
+  using vq_book_type = vpq_vq_book_matrix<MathT, IdxT, Accessor>;
+  using pq_book_type = vpq_vq_book_matrix<MathT, IdxT, Accessor>;
+
+  vq_book_type vq_code_book;
+  pq_book_type pq_code_book;
+
+  vpq_owning_storage(codes_type&& codes, vq_book_type&& vq_codes, pq_book_type&& pq_codes) noexcept
+    : codes_type{std::move(codes)},
+      vq_code_book{std::move(vq_codes)},
+      pq_code_book{std::move(pq_codes)}
+  {
+  }
+};
+
+/** Non-owning VPQ payload: a view of the encoded rows plus views of the VQ and PQ codebooks. */
+template <typename MathT, typename IdxT, typename Accessor>
+struct vpq_view_storage : public raft::mdspan<const uint8_t,
+                                              raft::matrix_extent<IdxT>,
+                                              raft::row_major,
+                                              dataset_view_accessor_for_owning<uint8_t, Accessor>>,
+                          public vpq_codebook_helpers<vpq_view_storage<MathT, IdxT, Accessor>> {
+  using codes_view_type = raft::mdspan<const uint8_t,
+                                       raft::matrix_extent<IdxT>,
+                                       raft::row_major,
+                                       dataset_view_accessor_for_owning<uint8_t, Accessor>>;
+  using vq_book_view_type =
+    typename vpq_owning_storage<MathT, IdxT, Accessor>::vq_book_type::const_view_type;
+  using pq_book_view_type =
+    typename vpq_owning_storage<MathT, IdxT, Accessor>::pq_book_type::const_view_type;
+
+  vq_book_view_type vq_code_book;
+  pq_book_view_type pq_code_book;
+
+  vpq_view_storage() noexcept = default;
+  vpq_view_storage(codes_view_type codes,
+                   vq_book_view_type vq_codes,
+                   pq_book_view_type pq_codes) noexcept
+    : codes_view_type(codes), vq_code_book(vq_codes), pq_code_book(pq_codes)
+  {
+  }
+};
+
+}  // namespace detail
+
+/** `Accessor` drives both codebook and code residency, mirroring today's
+ * single-`Accessor`-per-VPQ-dataset design. The payload (`detail::vpq_owning_storage` /
+ * `detail::vpq_view_storage`) holds the encoded rows and the VQ/PQ codebooks. */
+template <typename MathT, typename Accessor>
+struct vpq_dataset_spec {
+  using accessor_type = Accessor;
+  template <typename NewAccessor>
+  using rebind_accessor = vpq_dataset_spec<MathT, NewAccessor>;
+
+  template <typename T, typename IdxT>
+  struct apply {
+    using value_type = std::remove_cv_t<T>;
+    using index_type = std::remove_cv_t<IdxT>;
+    using math_type  = MathT;
+
+    using data_type = detail::vpq_owning_storage<MathT, IdxT, Accessor>;
+    using view_type = detail::vpq_view_storage<MathT, IdxT, Accessor>;
+
+    [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
+    {
+      return view_type(data.view(), data.vq_code_book.view(), data.pq_code_book.view());
+    }
+    template <typename AnyStorage>
+    [[nodiscard]] static auto get_n_rows(AnyStorage const& data) noexcept -> index_type
+    {
+      return static_cast<index_type>(data.extent(0));
+    }
+    template <typename AnyStorage>
+    [[nodiscard]] static auto get_dim(AnyStorage const& data) noexcept -> uint32_t
+    {
+      return data.dim();
+    }
+  };
+};
+
+template <typename DataT, typename IdxT>
+using device_vpq_dataset = cuvs::neighbors::
+  dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::device_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using device_vpq_dataset_view = cuvs::neighbors::
+  dataset_view<DataT, IdxT, vpq_dataset_spec<DataT, detail::device_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using host_vpq_dataset = cuvs::neighbors::
+  dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::host_owning_accessor<DataT>>>;
+
+template <typename DataT, typename IdxT>
+using host_vpq_dataset_view = cuvs::neighbors::
+  dataset_view<DataT, IdxT, vpq_dataset_spec<DataT, detail::host_owning_accessor<DataT>>>;
+
+/** Spec predicate for `cuvs::neighbors::dataset_view_has_spec_v`. */
+template <typename SpecT>
+struct is_vpq_spec : std::false_type {};
+template <typename MathT, typename Accessor>
+struct is_vpq_spec<vpq_dataset_spec<MathT, Accessor>> : std::true_type {};
+template <typename SpecT>
+inline constexpr bool is_vpq_spec_v = is_vpq_spec<SpecT>::value;
+
+template <typename SpecT>
+struct vpq_spec_math_type {};
+template <typename MathT, typename Accessor>
+struct vpq_spec_math_type<vpq_dataset_spec<MathT, Accessor>> {
+  using type = MathT;
+};
+template <typename SpecT>
+using vpq_spec_math_type_t = typename vpq_spec_math_type<SpecT>::type;
+
+/** True for an owning `dataset<...>` of the VPQ kind. */
+template <typename DatasetT>
+struct is_vpq_dataset : std::false_type {};
+template <typename T, typename IdxT, typename SpecT>
+struct is_vpq_dataset<cuvs::neighbors::dataset<T, IdxT, SpecT>>
+  : std::bool_constant<is_vpq_spec_v<SpecT>> {};
+template <typename DatasetT>
+inline constexpr bool is_vpq_dataset_v = is_vpq_dataset<DatasetT>::value;
+
+/** True when `V` is a VPQ `dataset_view` whose codebooks have element type `MathT`. */
+template <typename V, typename MathT>
+struct is_vpq_dataset_view_with_math : std::false_type {};
+template <typename T, typename IdxT, typename VpqMathT, typename Accessor, typename MathT>
+struct is_vpq_dataset_view_with_math<
+  cuvs::neighbors::dataset_view<T, IdxT, vpq_dataset_spec<VpqMathT, Accessor>>,
+  MathT> : std::is_same<VpqMathT, MathT> {};
+template <typename V, typename MathT>
+inline constexpr bool is_vpq_dataset_view_with_math_v =
+  is_vpq_dataset_view_with_math<cuvs::neighbors::dataset_view_type_t<V>, MathT>::value;
+
+template <typename V>
+inline constexpr bool is_device_vpq_f16_dataset_view_v =
+  is_vpq_dataset_view_with_math_v<V, half> &&
+  cuvs::neighbors::dataset_view_is_device_accessible_v<V>;
+
+template <typename V>
+inline constexpr bool is_host_vpq_f16_dataset_view_v =
+  is_vpq_dataset_view_with_math_v<V, half> &&
+  !cuvs::neighbors::dataset_view_is_device_accessible_v<V>;
+
+template <typename V>
+inline constexpr bool is_vpq_f16_dataset_view_v =
+  is_device_vpq_f16_dataset_view_v<V> || is_host_vpq_f16_dataset_view_v<V>;
+
+template <typename V>
+inline constexpr bool is_device_vpq_f32_dataset_view_v =
+  is_vpq_dataset_view_with_math_v<V, float> &&
+  cuvs::neighbors::dataset_view_is_device_accessible_v<V>;
+
+template <typename V>
+inline constexpr bool is_host_vpq_f32_dataset_view_v =
+  is_vpq_dataset_view_with_math_v<V, float> &&
+  !cuvs::neighbors::dataset_view_is_device_accessible_v<V>;
+
+template <typename V>
+inline constexpr bool is_vpq_f32_dataset_view_v =
+  is_device_vpq_f32_dataset_view_v<V> || is_host_vpq_f32_dataset_view_v<V>;
+
+template <typename V>
+inline constexpr bool is_device_vpq_dataset_view_v =
+  is_device_vpq_f16_dataset_view_v<V> || is_device_vpq_f32_dataset_view_v<V>;
+
+template <typename V>
+inline constexpr bool is_host_vpq_dataset_view_v =
+  is_host_vpq_f16_dataset_view_v<V> || is_host_vpq_f32_dataset_view_v<V>;
+
+/** True for any VPQ dataset view (host or device, f16 or f32 codebooks). */
+template <typename V>
+inline constexpr bool is_vpq_dataset_view_v =
+  is_device_vpq_dataset_view_v<V> || is_host_vpq_dataset_view_v<V>;
+
 /**
  * @brief Defines and stores VPQ codebooks upon training
  *
@@ -150,7 +471,7 @@ struct quantizer {
   /** Parameters used to build this quantizer. */
   params params_quantizer;
   /** VPQ codebooks produced during training. */
-  cuvs::neighbors::device_vpq_dataset<T, int64_t> vpq_codebooks;
+  device_vpq_dataset<T, int64_t> vpq_codebooks;
 };
 
 /**
@@ -255,9 +576,9 @@ namespace detail {
 // default visibility, an instantiation cannot be exported from the shared library when one of its
 // template arguments (`half`, or any mdspan type) is itself hidden, because the visibility of an
 // instantiation is capped by that of its template arguments.
-[[nodiscard]] CUVS_EXPORT cuvs::neighbors::device_vpq_dataset<half, int64_t> vpq_train_from_rows(
+[[nodiscard]] CUVS_EXPORT device_vpq_dataset<half, int64_t> vpq_train_from_rows(
   raft::resources const& res,
-  cuvs::neighbors::vpq_params const& params,
+  vpq_params const& params,
   void const* src_ptr,
   cudaDataType_t dtype,
   int64_t n_rows,
@@ -288,16 +609,15 @@ namespace detail {
  * #include <cuvs/preprocessing/quantize/pq.hpp>
  *
  * // `padded` is a `device_padded_dataset_view<float, int64_t>` over the source rows.
- * cuvs::neighbors::vpq_params vpq_params{};
+ * cuvs::preprocessing::quantize::pq::vpq_params vpq_params{};
  * auto vpq = cuvs::preprocessing::quantize::pq::make_vpq_dataset(res, vpq_params, padded);
  * auto idx = cuvs::neighbors::cagra::build(res, cagra_params, vpq.as_dataset_view());
  * @endcode
  */
 template <typename SrcT>
 [[nodiscard]] auto make_vpq_dataset(raft::resources const& res,
-                                    cuvs::neighbors::vpq_params const& params,
-                                    SrcT const& src)
-  -> cuvs::neighbors::device_vpq_dataset<half, int64_t>
+                                    vpq_params const& params,
+                                    SrcT const& src) -> device_vpq_dataset<half, int64_t>
 {
   // A cuVS dataset keeps its logical width in `dim()` while `as_matrix_view()` spans the full row
   // pitch.
diff --git a/cpp/internal/cuvs_internal/preprocessing/bbq_cpu_quantize.hpp b/cpp/internal/cuvs_internal/preprocessing/bbq_cpu_quantize.hpp
index 0ae1172147..6b17492e6d 100644
--- a/cpp/internal/cuvs_internal/preprocessing/bbq_cpu_quantize.hpp
+++ b/cpp/internal/cuvs_internal/preprocessing/bbq_cpu_quantize.hpp
@@ -331,10 +331,11 @@ inline host_quantizer_storage quantize(const float* data,
 template <typename IdxT>
 auto copy_bbq_owning_storage_host_to_device(raft::resources const& res,
                                             host_quantizer_storage const& host_storage) ->
-  typename cuvs::neighbors::device_bbq_dataset<float, IdxT>::data_type::owning_storage_type
+  typename cuvs::preprocessing::quantize::bbq::device_bbq_dataset<float, IdxT>::data_type::
+    owning_storage_type
 {
-  using device_storage =
-    typename cuvs::neighbors::device_bbq_dataset<float, IdxT>::data_type::owning_storage_type;
+  using device_storage = typename cuvs::preprocessing::quantize::bbq::
+    device_bbq_dataset<float, IdxT>::data_type::owning_storage_type;
   auto stream = raft::resource::get_cuda_stream(res);
   device_storage device{res,
                         static_cast<IdxT>(host_storage.codes.extent(0)),
@@ -383,10 +384,10 @@ auto copy_bbq_owning_storage_host_to_device(raft::resources const& res,
 template <typename IdxT>
 auto make_device_bbq_dataset(raft::resources const& res,
                              std::vector<host_quantizer_storage> const& host)
-  -> cuvs::neighbors::device_bbq_dataset<float, IdxT>
+  -> cuvs::preprocessing::quantize::bbq::device_bbq_dataset<float, IdxT>
 {
   RAFT_EXPECTS(host.size() != 0, "host BBQ dataset has no storage");
-  cuvs::neighbors::device_bbq_dataset<float, IdxT> device{
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset<float, IdxT> device{
     copy_bbq_owning_storage_host_to_device<IdxT>(res, host[0])};
   for (std::size_t i = 1; i < host.size(); ++i) {
     device.data().add_quantizer(copy_bbq_owning_storage_host_to_device<IdxT>(res, host[i]));
@@ -595,7 +596,7 @@ inline auto quantize_to_device(raft::resources const& res,
                                cuvs::distance::DistanceType metric,
                                bbq_code_layout query_layout,
                                bbq_code_layout doc_layout)
-  -> cuvs::neighbors::device_bbq_dataset<float, int64_t>
+  -> cuvs::preprocessing::quantize::bbq::device_bbq_dataset<float, int64_t>
 {
   validate_layout_pair(query_layout, doc_layout);
   std::vector<host_quantizer_storage> host;
@@ -616,7 +617,7 @@ inline auto quantize_to_device(raft::resources const& res,
                                cuvs::distance::DistanceType metric,
                                std::string_view query_token,
                                std::string_view doc_token)
-  -> cuvs::neighbors::device_bbq_dataset<float, int64_t>
+  -> cuvs::preprocessing::quantize::bbq::device_bbq_dataset<float, int64_t>
 {
   return quantize_to_device(res,
                             rows,
diff --git a/cpp/src/neighbors/cagra.cuh b/cpp/src/neighbors/cagra.cuh
index 47d6e6a7ac..bc070e0180 100644
--- a/cpp/src/neighbors/cagra.cuh
+++ b/cpp/src/neighbors/cagra.cuh
@@ -45,8 +45,8 @@ CUVS_EXPORT void index<T, IdxT, DatasetViewT>::compute_dataset_norms_(raft::reso
   if constexpr (nb::is_padded_dataset_view_v<DatasetViewT> ||
                 nb::is_standard_dataset_view_v<DatasetViewT>) {
     rm_dataset = dataset_.as_matrix_view();
-  } else if constexpr (nb::is_vpq_dataset_view_v<DatasetViewT> ||
-                       nb::is_bbq_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::preprocessing::quantize::pq::is_vpq_dataset_view_v<DatasetViewT> ||
+                       cuvs::preprocessing::quantize::bbq::is_bbq_dataset_view_v<DatasetViewT>) {
     skip_norms = true;
   }
 
@@ -305,10 +305,11 @@ auto build(raft::resources const& res, const index_params& params, DatasetViewT
 
   // Dense paths build the graph and optionally attach the input dataset view. Host indexes remain
   // non-searchable until the type-changing update_dataset(...) supplies a device-padded dataset.
-  if constexpr (cuvs::neighbors::is_device_bbq_dataset_view_v<DatasetViewT>) {
+  if constexpr (cuvs::preprocessing::quantize::bbq::is_device_bbq_dataset_view_v<DatasetViewT>) {
     return cuvs::neighbors::cagra::detail::build_from_bbq_dataset<T, IdxT, DatasetViewT>(
       res, params, dataset);
-  } else if constexpr (cuvs::neighbors::is_device_vpq_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::preprocessing::quantize::pq::is_device_vpq_dataset_view_v<
+                         DatasetViewT>) {
     auto effective_params = params;
     if (std::holds_alternative<std::monostate>(effective_params.graph_build_params)) {
       effective_params.graph_build_params = graph_build_params::iterative_search_params{};
diff --git a/cpp/src/neighbors/cagra_build_inst.cu.in b/cpp/src/neighbors/cagra_build_inst.cu.in
index 2a3e2b43c1..c2d01f2570 100644
--- a/cpp/src/neighbors/cagra_build_inst.cu.in
+++ b/cpp/src/neighbors/cagra_build_inst.cu.in
@@ -19,8 +19,9 @@ using inst_device_padded_view_t   = cuvs::neighbors::device_padded_dataset_view<
 using inst_device_standard_view_t = cuvs::neighbors::device_standard_dataset_view<data_t, int64_t>;
 using inst_host_padded_view_t     = cuvs::neighbors::host_padded_dataset_view<data_t, int64_t>;
 using inst_host_standard_view_t   = cuvs::neighbors::host_standard_dataset_view<data_t, int64_t>;
-using inst_vpq_view_t             = cuvs::neighbors::device_vpq_dataset_view<half, int64_t>;
-using inst_bbq_view_t             = cuvs::neighbors::device_bbq_dataset_view<data_t, int64_t>;
+using inst_vpq_view_t = cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>;
+using inst_bbq_view_t =
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<data_t, int64_t>;
 }  // namespace
 
 namespace cuvs::neighbors::cagra {
diff --git a/cpp/src/neighbors/cagra_search_inst.cu.in b/cpp/src/neighbors/cagra_search_inst.cu.in
index 9e42ac476f..2070a1f29a 100644
--- a/cpp/src/neighbors/cagra_search_inst.cu.in
+++ b/cpp/src/neighbors/cagra_search_inst.cu.in
@@ -12,9 +12,11 @@ namespace {
 using data_t                      = @data_type@;
 using inst_device_padded_view_t   = cuvs::neighbors::device_padded_dataset_view<data_t, int64_t>;
 using inst_device_standard_view_t = cuvs::neighbors::device_standard_dataset_view<data_t, int64_t>;
-using inst_vpq_f16_view_t         = cuvs::neighbors::device_vpq_dataset_view<half, int64_t>;
-using inst_bbq_view_t             = cuvs::neighbors::device_bbq_dataset_view<data_t, int64_t>;
-using inst_empty_view_t           = cuvs::neighbors::device_empty_dataset_view<int64_t>;
+using inst_vpq_f16_view_t =
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>;
+using inst_bbq_view_t =
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<data_t, int64_t>;
+using inst_empty_view_t = cuvs::neighbors::device_empty_dataset_view<int64_t>;
 
 }  // namespace
 
diff --git a/cpp/src/neighbors/cagra_serialize_inst.cu.in b/cpp/src/neighbors/cagra_serialize_inst.cu.in
index 58e555d17e..48df1dd596 100644
--- a/cpp/src/neighbors/cagra_serialize_inst.cu.in
+++ b/cpp/src/neighbors/cagra_serialize_inst.cu.in
@@ -12,7 +12,8 @@ namespace {
 using data_t                      = @data_type@;
 using inst_device_padded_view_t   = cuvs::neighbors::device_padded_dataset_view<data_t, int64_t>;
 using inst_device_standard_view_t = cuvs::neighbors::device_standard_dataset_view<data_t, int64_t>;
-using inst_vpq_f16_view_t         = cuvs::neighbors::device_vpq_dataset_view<half, int64_t>;
+using inst_vpq_f16_view_t =
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>;
 
 }  // namespace
 
diff --git a/cpp/src/neighbors/detail/cagra/cagra_build.cuh b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
index d89af69dc5..8f24b307c9 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_build.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
@@ -2213,10 +2213,11 @@ void build_knn_graph(
 }
 
 template <typename DataT, typename IdxT>
-void build_knn_graph(raft::resources const& res,
-                     cuvs::neighbors::device_bbq_dataset_view<DataT, int64_t> dataset,
-                     raft::host_matrix_view<IdxT, int64_t, raft::row_major> knn_graph,
-                     cuvs::neighbors::nn_descent::index_params build_params)
+void build_knn_graph(
+  raft::resources const& res,
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<DataT, int64_t> dataset,
+  raft::host_matrix_view<IdxT, int64_t, raft::row_major> knn_graph,
+  cuvs::neighbors::nn_descent::index_params build_params)
 {
   raft::common::nvtx::range<cuvs::common::nvtx::domain::cuvs> fun_scope(
     "cagra::build_knn_graph<NN-DESCENT,BBQ>(%zu, %zu, %u)",
@@ -2306,11 +2307,12 @@ __global__ void kern_reconstruct_vpq_queries(const uint8_t* encoded_data,
 }
 
 template <typename T, typename MathT, typename IdxT>
-void reconstruct_vpq_queries(raft::resources const& res,
-                             cuvs::neighbors::device_vpq_dataset_view<MathT, IdxT> const& vpq_view,
-                             uint64_t offset,
-                             uint32_t batch_size,
-                             raft::device_matrix_view<T, int64_t> output)
+void reconstruct_vpq_queries(
+  raft::resources const& res,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<MathT, IdxT> const& vpq_view,
+  uint64_t offset,
+  uint32_t batch_size,
+  raft::device_matrix_view<T, int64_t> output)
 {
   auto const data_view     = vpq_view.as_matrix_view();
   const uint32_t dim       = vpq_view.dim();
@@ -2365,9 +2367,9 @@ auto search_and_optimize(
   size_t next_graph_degree,
   uint64_t max_chunk_size,
   bool guarantee_connectivity,
-  std::optional<raft::device_matrix_view<T, int64_t>> reconstructed_batch_queries    = std::nullopt,
-  std::optional<cuvs::neighbors::device_vpq_dataset_view<half, int64_t>> vpq_queries = std::nullopt)
-  -> raft::device_matrix<IdxT, int64_t>
+  std::optional<raft::device_matrix_view<T, int64_t>> reconstructed_batch_queries = std::nullopt,
+  std::optional<cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>
+    vpq_queries = std::nullopt) -> raft::device_matrix<IdxT, int64_t>
 {
   auto stream                = raft::resource::get_cuda_stream(res);
   auto const curr_query_size = knn_graph.extent(0);
@@ -2450,7 +2452,7 @@ auto search_and_optimize(
 
 template <typename T, typename IdxT = uint32_t, typename DatasetViewT>
   requires(cuvs::neighbors::is_dense_row_major_device_dataset_view_v<DatasetViewT> ||
-           cuvs::neighbors::is_device_vpq_f16_dataset_view_v<DatasetViewT>)
+           cuvs::preprocessing::quantize::pq::is_device_vpq_f16_dataset_view_v<DatasetViewT>)
 auto iterative_build_graph(raft::resources const& res,
                            const index_params& params,
                            DatasetViewT const& dataset) -> raft::device_matrix<IdxT, int64_t>
@@ -2473,9 +2475,9 @@ auto iterative_build_graph(raft::resources const& res,
     raft::make_device_matrix_view<const T, int64_t>(static_cast<const T*>(nullptr), 0, 0);
   uint32_t logical_dim = dataset.dim();
   uint64_t final_graph_size;
-  auto vpq_dataset = cuvs::neighbors::device_vpq_dataset_view<half, int64_t>{};
+  auto vpq_dataset = cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>{};
 
-  if constexpr (cuvs::neighbors::is_device_vpq_f16_dataset_view_v<DatasetViewT>) {
+  if constexpr (cuvs::preprocessing::quantize::pq::is_device_vpq_f16_dataset_view_v<DatasetViewT>) {
     final_graph_size = static_cast<uint64_t>(dataset.n_rows());
     vpq_dataset      = dataset;
   } else {
@@ -2943,7 +2945,7 @@ auto build_from_device_matrix(raft::resources const& res,
  * the same graph.
  */
 template <typename T, typename IdxT, typename DatasetViewT>
-  requires cuvs::neighbors::is_device_bbq_dataset_view_v<DatasetViewT>
+  requires cuvs::preprocessing::quantize::bbq::is_device_bbq_dataset_view_v<DatasetViewT>
 auto build_from_bbq_dataset(raft::resources const& res,
                             const index_params& params,
                             DatasetViewT const& dataset)
diff --git a/cpp/src/neighbors/detail/cagra/cagra_search.cuh b/cpp/src/neighbors/detail/cagra/cagra_search.cuh
index ac516c176c..7c8df90964 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_search.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_search.cuh
@@ -247,7 +247,8 @@ void search_main(raft::resources const& res,
     RAFT_FAIL(
       "Attempted to search without a dataset. Please call "
       "cagra::update_dataset(res, std::move(index), dataset) first.");
-  } else if constexpr (cuvs::neighbors::is_device_vpq_f16_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::preprocessing::quantize::pq::is_device_vpq_f16_dataset_view_v<
+                         DatasetViewT>) {
     auto const& vv = index.dataset();
     if (params.smem_dtype == cuvs::neighbors::cagra::internal_dtype::E5M2 &&
         raft::getComputeCapability().first < 9) {
diff --git a/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh b/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
index 9f4fe27c1e..89d631c8c8 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
@@ -83,8 +83,8 @@ constexpr bool is_valid_serialized_dataset_kind(std::uint32_t raw)
  */
 template <typename DatasetViewT>
 inline constexpr bool is_graph_only_dataset_view_v =
-  cuvs::neighbors::is_vpq_dataset_view_v<DatasetViewT> ||
-  cuvs::neighbors::is_bbq_dataset_view_v<DatasetViewT>;
+  cuvs::preprocessing::quantize::pq::is_vpq_dataset_view_v<DatasetViewT> ||
+  cuvs::preprocessing::quantize::bbq::is_bbq_dataset_view_v<DatasetViewT>;
 
 inline constexpr char const* kGraphOnlyDatasetMessage =
   "CAGRA indexes with a quantized dataset store only the graph; serialize the quantized dataset "
diff --git a/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp b/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
index 281a9f84f3..7683ebcfc3 100644
--- a/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
+++ b/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
@@ -47,14 +47,14 @@ struct vpq_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT> {
   // (`is_vpq_dataset_view_v`, `DatasetT::value_type`), not an owning-only trait/typedef.
   template <typename DatasetT>
   constexpr static inline auto accepts_dataset()
-    -> std::enable_if_t<cuvs::neighbors::is_vpq_dataset_view_v<DatasetT>, bool>
+    -> std::enable_if_t<cuvs::preprocessing::quantize::pq::is_vpq_dataset_view_v<DatasetT>, bool>
   {
     return std::is_same_v<typename DatasetT::value_type, CodebookT>;
   }
 
   template <typename DatasetT>
   constexpr static inline auto accepts_dataset()
-    -> std::enable_if_t<!cuvs::neighbors::is_vpq_dataset_view_v<DatasetT>, bool>
+    -> std::enable_if_t<!cuvs::preprocessing::quantize::pq::is_vpq_dataset_view_v<DatasetT>, bool>
   {
     return false;
   }
diff --git a/cpp/src/neighbors/detail/cagra/factory.cuh b/cpp/src/neighbors/detail/cagra/factory.cuh
index ec1a6f4313..0dd3477944 100644
--- a/cpp/src/neighbors/detail/cagra/factory.cuh
+++ b/cpp/src/neighbors/detail/cagra/factory.cuh
@@ -118,7 +118,7 @@ auto make_key(const cagra::search_params& params,
               const DatasetT& dataset,
               cuvs::distance::DistanceType metric,
               const void* dataset_norms)
-  -> std::enable_if_t<cuvs::neighbors::is_vpq_dataset_view_v<DatasetT>, key>
+  -> std::enable_if_t<cuvs::preprocessing::quantize::pq::is_vpq_dataset_view_v<DatasetT>, key>
 {
   auto const data_view = dataset.as_matrix_view();
   return key{reinterpret_cast<uint64_t>(data_view.data_handle()),
diff --git a/cpp/src/neighbors/detail/cagra/graph_shared.cu b/cpp/src/neighbors/detail/cagra/graph_shared.cu
index 5e362f8f5f..8965966aa1 100644
--- a/cpp/src/neighbors/detail/cagra/graph_shared.cu
+++ b/cpp/src/neighbors/detail/cagra/graph_shared.cu
@@ -252,7 +252,8 @@ auto select_sort_bbq_kernel(uint32_t degree) -> sort_bbq_kernel_type<DataT>
 }
 
 template <typename DataT>
-auto select_sort_quantizers(cuvs::neighbors::device_bbq_dataset_view<DataT, int64_t> const& dataset)
+auto select_sort_quantizers(
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<DataT, int64_t> const& dataset)
   -> std::pair<bbq_quantizer_view_t<DataT, int64_t>, bbq_quantizer_view_t<DataT, int64_t>>
 {
   using bbq_code_layout = cuvs::preprocessing::quantize::bbq::bbq_code_layout;
@@ -280,10 +281,11 @@ auto select_sort_quantizers(cuvs::neighbors::device_bbq_dataset_view<DataT, int6
 }
 
 template <typename DataT>
-void sort_knn_graph_bbq_impl(raft::resources const& res,
-                             cuvs::distance::DistanceType metric,
-                             cuvs::neighbors::device_bbq_dataset_view<DataT, int64_t> dataset,
-                             raft::host_matrix_view<uint32_t, int64_t, raft::row_major> knn_graph)
+void sort_knn_graph_bbq_impl(
+  raft::resources const& res,
+  cuvs::distance::DistanceType metric,
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<DataT, int64_t> dataset,
+  raft::host_matrix_view<uint32_t, int64_t, raft::row_major> knn_graph)
 {
   namespace bbq = cuvs::preprocessing::quantize::bbq;
 
@@ -369,13 +371,14 @@ CUVS_DEFINE_CAGRA_GRAPH_SORT(uint8_t)
 
 #undef CUVS_DEFINE_CAGRA_GRAPH_SORT
 
-#define CUVS_DEFINE_CAGRA_GRAPH_SORT_BBQ(DataT)                                                 \
-  void sort_knn_graph_bbq(raft::resources const& res,                                           \
-                          cuvs::distance::DistanceType metric,                                  \
-                          cuvs::neighbors::device_bbq_dataset_view<DataT, int64_t> dataset,     \
-                          raft::host_matrix_view<uint32_t, int64_t, raft::row_major> knn_graph) \
-  {                                                                                             \
-    sort_knn_graph_bbq_impl(res, metric, dataset, knn_graph);                                   \
+#define CUVS_DEFINE_CAGRA_GRAPH_SORT_BBQ(DataT)                                          \
+  void sort_knn_graph_bbq(                                                               \
+    raft::resources const& res,                                                          \
+    cuvs::distance::DistanceType metric,                                                 \
+    cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<DataT, int64_t> dataset, \
+    raft::host_matrix_view<uint32_t, int64_t, raft::row_major> knn_graph)                \
+  {                                                                                      \
+    sort_knn_graph_bbq_impl(res, metric, dataset, knn_graph);                            \
   }
 
 CUVS_DEFINE_CAGRA_GRAPH_SORT_BBQ(float)
diff --git a/cpp/src/neighbors/detail/cagra/graph_shared.cuh b/cpp/src/neighbors/detail/cagra/graph_shared.cuh
index 33ec7f92ed..3cb367872a 100644
--- a/cpp/src/neighbors/detail/cagra/graph_shared.cuh
+++ b/cpp/src/neighbors/detail/cagra/graph_shared.cuh
@@ -37,11 +37,11 @@ CUVS_DECL_CAGRA_GRAPH_SORT(uint8_t);
 
 #undef CUVS_DECL_CAGRA_GRAPH_SORT
 
-#define CUVS_DECL_CAGRA_GRAPH_SORT_BBQ(DataT)                         \
-  CUVS_EXPORT void sort_knn_graph_bbq(                                \
-    raft::resources const& res,                                       \
-    cuvs::distance::DistanceType metric,                              \
-    cuvs::neighbors::device_bbq_dataset_view<DataT, int64_t> dataset, \
+#define CUVS_DECL_CAGRA_GRAPH_SORT_BBQ(DataT)                                            \
+  CUVS_EXPORT void sort_knn_graph_bbq(                                                   \
+    raft::resources const& res,                                                          \
+    cuvs::distance::DistanceType metric,                                                 \
+    cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<DataT, int64_t> dataset, \
     raft::host_matrix_view<uint32_t, int64_t, raft::row_major> knn_graph)
 
 CUVS_DECL_CAGRA_GRAPH_SORT_BBQ(float);
diff --git a/cpp/src/neighbors/detail/dataset_serialize.hpp b/cpp/src/neighbors/detail/dataset_serialize.hpp
index 740a16744f..e7954a6eaa 100644
--- a/cpp/src/neighbors/detail/dataset_serialize.hpp
+++ b/cpp/src/neighbors/detail/dataset_serialize.hpp
@@ -5,6 +5,7 @@
 #pragma once
 
 #include <cuvs/neighbors/common.hpp>
+#include <cuvs/preprocessing/quantize/pq.hpp>
 #include <cuvs/util/file_io.hpp>
 #include <raft/core/device_mdarray.hpp>
 #include <raft/core/host_mdarray.hpp>
@@ -415,7 +416,7 @@ auto deserialize_host_dense(raft::resources const& res, std::istream& is)
 
 template <typename DataT, typename IdxT>
 auto deserialize_vpq(raft::resources const& res, std::istream& is)
-  -> std::unique_ptr<device_vpq_dataset<DataT, IdxT>>
+  -> std::unique_ptr<cuvs::preprocessing::quantize::pq::device_vpq_dataset<DataT, IdxT>>
 {
   auto n_rows             = raft::deserialize_scalar<IdxT>(res, is);
   auto dim                = raft::deserialize_scalar<uint32_t>(res, is);
@@ -435,7 +436,7 @@ auto deserialize_vpq(raft::resources const& res, std::istream& is)
   raft::deserialize_mdspan(res, is, pq_code_book.view());
   raft::deserialize_mdspan(res, is, data.view());
 
-  using owning_t = device_vpq_dataset<DataT, IdxT>;
+  using owning_t = cuvs::preprocessing::quantize::pq::device_vpq_dataset<DataT, IdxT>;
   return std::make_unique<owning_t>(
     std::move(data), std::move(vq_code_book), std::move(pq_code_book));
 }
diff --git a/cpp/src/neighbors/detail/nn_descent.cuh b/cpp/src/neighbors/detail/nn_descent.cuh
index 7aa70b4800..5253996881 100644
--- a/cpp/src/neighbors/detail/nn_descent.cuh
+++ b/cpp/src/neighbors/detail/nn_descent.cuh
@@ -2477,7 +2477,8 @@ template <typename Data_t, typename Index_t>
 template <typename DistEpilogue_t>
 void GNND<Data_t, Index_t>::local_join(
   cudaStream_t stream,
-  cuvs::neighbors::device_bbq_dataset_view<std::remove_const_t<Data_t>, int64_t> dataset,
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<std::remove_const_t<Data_t>, int64_t>
+    dataset,
   DistEpilogue_t dist_epilogue)
 {
   raft::matrix::fill(res, dists_buffer_.view(), std::numeric_limits<float>::max());
@@ -2860,7 +2861,8 @@ void GNND<Data_t, Index_t>::build(Data_t* data,
 template <typename Data_t, typename Index_t>
 template <typename DistEpilogue_t>
 void GNND<Data_t, Index_t>::build(
-  cuvs::neighbors::device_bbq_dataset_view<std::remove_const_t<Data_t>, int64_t> dataset,
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<std::remove_const_t<Data_t>, int64_t>
+    dataset,
   Index_t* output_graph,
   bool return_distances,
   DistData_t* output_distances,
@@ -2980,7 +2982,7 @@ void GNND<Data_t, Index_t>::build(
 template <typename DataT, typename IdxT = uint32_t>
 void build(raft::resources const& res,
            const index_params& params,
-           cuvs::neighbors::device_bbq_dataset_view<DataT, int64_t> dataset,
+           cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<DataT, int64_t> dataset,
            index<IdxT>& idx)
 {
   RAFT_EXPECTS(dataset.data().quantizers.size() > 0, "BBQ dataset must not be empty.");
@@ -3113,9 +3115,10 @@ void build(raft::resources const& res,
 }
 
 template <typename DataT, typename IdxT = uint32_t>
-index<IdxT> build(raft::resources const& res,
-                  const index_params& params,
-                  cuvs::neighbors::device_bbq_dataset_view<DataT, int64_t> dataset)
+index<IdxT> build(
+  raft::resources const& res,
+  const index_params& params,
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<DataT, int64_t> dataset)
 {
   size_t graph_degree = params.graph_degree;
   if (params.intermediate_graph_degree < graph_degree) {
diff --git a/cpp/src/neighbors/detail/nn_descent_gnnd.hpp b/cpp/src/neighbors/detail/nn_descent_gnnd.hpp
index 07db8b7064..0179f8864f 100644
--- a/cpp/src/neighbors/detail/nn_descent_gnnd.hpp
+++ b/cpp/src/neighbors/detail/nn_descent_gnnd.hpp
@@ -207,11 +207,13 @@ class CUVS_EXPORT GNND {
              DistEpilogue_t dist_epilogue = DistEpilogue_t{});
 
   template <typename DistEpilogue_t = raft::identity_op>
-  void build(cuvs::neighbors::device_bbq_dataset_view<std::remove_const_t<Data_t>, int64_t> dataset,
-             Index_t* output_graph,
-             bool return_distances,
-             DistData_t* output_distances,
-             DistEpilogue_t dist_epilogue = DistEpilogue_t{});
+  void build(
+    cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<std::remove_const_t<Data_t>,
+                                                                int64_t> dataset,
+    Index_t* output_graph,
+    bool return_distances,
+    DistData_t* output_distances,
+    DistEpilogue_t dist_epilogue = DistEpilogue_t{});
   ~GNND()    = default;
   using ID_t = InternalID_t<Index_t>;
   void reset(raft::resources const& res);
@@ -229,7 +231,8 @@ class CUVS_EXPORT GNND {
   template <typename DistEpilogue_t>
   void local_join(
     cudaStream_t stream,
-    cuvs::neighbors::device_bbq_dataset_view<std::remove_const_t<Data_t>, int64_t> dataset,
+    cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<std::remove_const_t<Data_t>,
+                                                                int64_t> dataset,
     DistEpilogue_t dist_epilogue = DistEpilogue_t{});
 
   raft::resources const& res;
diff --git a/cpp/src/neighbors/detail/vamana/vamana_build.cuh b/cpp/src/neighbors/detail/vamana/vamana_build.cuh
index ebe134cc4a..15fe796e37 100644
--- a/cpp/src/neighbors/detail/vamana/vamana_build.cuh
+++ b/cpp/src/neighbors/detail/vamana/vamana_build.cuh
@@ -677,7 +677,7 @@ index<T, IdxT> build(
     // process in batches
     const uint32_t n_rows = dataset.extent(0);
 
-    using vpq_owning_t = cuvs::neighbors::device_vpq_dataset<float, int64_t>;
+    using vpq_owning_t = cuvs::preprocessing::quantize::pq::device_vpq_dataset<float, int64_t>;
     auto quantizer     = cuvs::preprocessing::quantize::pq::quantizer<float>(
       pq_params,
       vpq_owning_t(raft::make_device_matrix<uint8_t, int64_t, raft::row_major>(res, 0, 0),
diff --git a/cpp/src/neighbors/detail/vpq_dataset.cuh b/cpp/src/neighbors/detail/vpq_dataset.cuh
index 4d27c5424a..ee17e5b1f8 100644
--- a/cpp/src/neighbors/detail/vpq_dataset.cuh
+++ b/cpp/src/neighbors/detail/vpq_dataset.cuh
@@ -122,11 +122,13 @@ void train_pq_centers(
 }
 
 template <typename DatasetT>
-auto fill_missing_params_heuristics(const vpq_params& params, const DatasetT& dataset) -> vpq_params
+auto fill_missing_params_heuristics(const cuvs::preprocessing::quantize::pq::vpq_params& params,
+                                    const DatasetT& dataset)
+  -> cuvs::preprocessing::quantize::pq::vpq_params
 {
-  vpq_params r  = params;
-  double n_rows = dataset.extent(0);
-  size_t dim    = dataset.extent(1);
+  cuvs::preprocessing::quantize::pq::vpq_params r = params;
+  double n_rows                                   = dataset.extent(0);
+  size_t dim                                      = dataset.extent(1);
   if (r.pq_dim == 0) { r.pq_dim = raft::div_rounding_up_safe(dim, size_t{4}); }
   if (r.pq_bits == 0) { r.pq_bits = 8; }
   if (r.vq_n_centers == 0) { r.vq_n_centers = raft::round_up_safe<uint32_t>(std::sqrt(n_rows), 8); }
@@ -168,8 +170,9 @@ auto transform_data(const raft::resources& res, DatasetT dataset)
 using ix_t = int64_t;
 
 template <typename MathT, typename DatasetT>
-auto train_vq(const raft::resources& res, const vpq_params& params, const DatasetT& dataset)
-  -> raft::device_matrix<MathT, uint32_t, raft::row_major>
+auto train_vq(const raft::resources& res,
+              const cuvs::preprocessing::quantize::pq::vpq_params& params,
+              const DatasetT& dataset) -> raft::device_matrix<MathT, uint32_t, raft::row_major>
 {
   using kmeans_in_type    = typename DatasetT::value_type;
   const ix_t n_rows       = dataset.extent(0);
@@ -413,7 +416,7 @@ __launch_bounds__(BlockSize) RAFT_KERNEL process_and_fill_codes_kernel(
 template <typename MathT, typename IdxT, typename DatasetT>
 void process_and_fill_codes(
   const raft::resources& res,
-  const vpq_params& params,
+  const cuvs::preprocessing::quantize::pq::vpq_params& params,
   const DatasetT& dataset,
   raft::device_matrix_view<const MathT, uint32_t, raft::row_major> pq_centers,
   raft::device_matrix_view<const MathT, uint32_t, raft::row_major> vq_centers,
@@ -422,7 +425,7 @@ void process_and_fill_codes(
   bool inline_vq_labels = false)
 {
   using data_t     = typename DatasetT::value_type;
-  using cdataset_t = device_vpq_dataset<MathT, IdxT>;
+  using cdataset_t = cuvs::preprocessing::quantize::pq::device_vpq_dataset<MathT, IdxT>;
   using label_t    = uint32_t;
 
   const ix_t n_rows       = dataset.extent(0);
@@ -807,7 +810,7 @@ __launch_bounds__(BlockSize) RAFT_KERNEL process_and_fill_codes_subspaces_kernel
 template <typename MathT, typename IdxT, typename DatasetT>
 void process_and_fill_codes_subspaces(
   const raft::resources& res,
-  const vpq_params& params,
+  const cuvs::preprocessing::quantize::pq::vpq_params& params,
   const DatasetT& dataset,
   raft::device_matrix_view<const MathT, uint32_t, raft::row_major> pq_centers,
   raft::device_matrix_view<const MathT, uint32_t, raft::row_major> vq_centers,
@@ -815,7 +818,7 @@ void process_and_fill_codes_subspaces(
   raft::device_matrix_view<uint8_t, IdxT, raft::row_major> codes)
 {
   using data_t     = typename DatasetT::value_type;
-  using cdataset_t = device_vpq_dataset<MathT, IdxT>;
+  using cdataset_t = cuvs::preprocessing::quantize::pq::device_vpq_dataset<MathT, IdxT>;
   using label_t    = uint32_t;
 
   const ix_t n_rows       = dataset.extent(0);
diff --git a/cpp/src/neighbors/nn_descent.cuh b/cpp/src/neighbors/nn_descent.cuh
index 9c9b3c5540..89f35dce92 100644
--- a/cpp/src/neighbors/nn_descent.cuh
+++ b/cpp/src/neighbors/nn_descent.cuh
@@ -187,7 +187,8 @@ void build(raft::resources const& res,
 template <typename DataT, typename IdxT = uint32_t>
 auto build(raft::resources const& res,
            index_params const& params,
-           cuvs::neighbors::device_bbq_dataset_view<DataT, int64_t> dataset) -> index<IdxT>
+           cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<DataT, int64_t> dataset)
+  -> index<IdxT>
 {
   return detail::build<DataT, IdxT>(res, params, dataset);
 }
@@ -195,7 +196,7 @@ auto build(raft::resources const& res,
 template <typename DataT, typename IdxT = uint32_t>
 void build(raft::resources const& res,
            index_params const& params,
-           cuvs::neighbors::device_bbq_dataset_view<DataT, int64_t> dataset,
+           cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<DataT, int64_t> dataset,
            index<IdxT>& idx)
 {
   detail::build<DataT, IdxT>(res, params, dataset, idx);
diff --git a/cpp/src/neighbors/nn_descent_gnnd_inst.cu b/cpp/src/neighbors/nn_descent_gnnd_inst.cu
index a5b2517b9c..ecb9c01cff 100644
--- a/cpp/src/neighbors/nn_descent_gnnd_inst.cu
+++ b/cpp/src/neighbors/nn_descent_gnnd_inst.cu
@@ -40,7 +40,8 @@ template void detail::GNND<const data_t, int>::build<raft::identity_op>(
   float* output_distances,
   raft::identity_op dist_epilogue);
 template void detail::GNND<const data_t, int>::build<raft::identity_op>(
-  cuvs::neighbors::device_bbq_dataset_view<std::remove_const_t<data_t>, int64_t> dataset,
+  cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<std::remove_const_t<data_t>, int64_t>
+    dataset,
   int* output_graph,
   bool return_distances,
   float* output_distances,
diff --git a/cpp/src/neighbors/nn_descent_inst.cu.in b/cpp/src/neighbors/nn_descent_inst.cu.in
index 62d749e5b6..141ccb6881 100644
--- a/cpp/src/neighbors/nn_descent_inst.cu.in
+++ b/cpp/src/neighbors/nn_descent_inst.cu.in
@@ -54,7 +54,7 @@ auto build(raft::resources const& handle,
 
 auto build(raft::resources const& handle,
            const cuvs::neighbors::nn_descent::index_params& params,
-           cuvs::neighbors::device_bbq_dataset_view<data_t, int64_t> dataset,
+           cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<data_t, int64_t> dataset,
            std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>> graph)
   -> cuvs::neighbors::nn_descent::index<index_t>
 {
diff --git a/cpp/src/preprocessing/quantize/detail/pq.cuh b/cpp/src/preprocessing/quantize/detail/pq.cuh
index 14d5490aca..5a6a7f0d9b 100644
--- a/cpp/src/preprocessing/quantize/detail/pq.cuh
+++ b/cpp/src/preprocessing/quantize/detail/pq.cuh
@@ -56,11 +56,11 @@ inline cuvs::distance::DistanceType get_kmeans_metric(
 }
 
 inline auto to_vpq_params(const cuvs::preprocessing::quantize::pq::params& params)
-  -> cuvs::neighbors::vpq_params
+  -> cuvs::preprocessing::quantize::pq::vpq_params
 {
   auto kmeans_type = is_balanced_kmeans(params) ? cuvs::cluster::kmeans::kmeans_type::KMeansBalanced
                                                 : cuvs::cluster::kmeans::kmeans_type::KMeans;
-  return cuvs::neighbors::vpq_params{
+  return cuvs::preprocessing::quantize::pq::vpq_params{
     .pq_bits                         = params.pq_bits,
     .pq_dim                          = params.pq_dim,
     .vq_n_centers                    = params.vq_n_centers,
@@ -192,7 +192,7 @@ quantizer<MathT> build(
     pq_code_book = cuvs::neighbors::detail::train_pq<MathT>(
       res, filled_params, dataset, raft::make_const_mdspan(vq_code_book.view()));
   }
-  using owning_t = cuvs::neighbors::device_vpq_dataset<MathT, int64_t>;
+  using owning_t = cuvs::preprocessing::quantize::pq::device_vpq_dataset<MathT, int64_t>;
   return {filled_params,
           owning_t(std::move(empty_codes), std::move(vq_code_book), std::move(pq_code_book))};
 }
@@ -370,7 +370,7 @@ void inverse_transform(
 template <typename NewMathT, typename OldMathT, typename IdxT>
 void vpq_convert_math_type(
   const raft::resources& res,
-  const cuvs::neighbors::device_vpq_dataset<OldMathT, IdxT>& src,
+  const cuvs::preprocessing::quantize::pq::device_vpq_dataset<OldMathT, IdxT>& src,
   raft::device_matrix_view<NewMathT, uint32_t, raft::row_major> dst_vq_code_book,
   raft::device_matrix_view<NewMathT, uint32_t, raft::row_major> dst_pq_code_book)
 {
@@ -385,7 +385,7 @@ void vpq_convert_math_type(
                     src_view.pq_code_book);
 }
 
-inline auto make_pq_params_from_vpq(const cuvs::neighbors::vpq_params& in_params,
+inline auto make_pq_params_from_vpq(const cuvs::preprocessing::quantize::pq::vpq_params& in_params,
                                     const uint64_t n_rows)
   -> cuvs::preprocessing::quantize::pq::params
 {
@@ -411,8 +411,9 @@ inline auto make_pq_params_from_vpq(const cuvs::neighbors::vpq_params& in_params
 
 template <typename DatasetT, typename MathT, typename IdxT>
 auto vpq_build(const raft::resources& res,
-               const cuvs::neighbors::vpq_params& params,
-               const DatasetT& dataset) -> cuvs::neighbors::device_vpq_dataset<MathT, IdxT>
+               const cuvs::preprocessing::quantize::pq::vpq_params& params,
+               const DatasetT& dataset)
+  -> cuvs::preprocessing::quantize::pq::device_vpq_dataset<MathT, IdxT>
 {
   using label_t = uint32_t;
   // Use a heuristic to impute missing parameters.
@@ -440,17 +441,18 @@ auto vpq_build(const raft::resources& res,
     codes.view(),
     true);
 
-  using owning_t = cuvs::neighbors::device_vpq_dataset<MathT, IdxT>;
+  using owning_t = cuvs::preprocessing::quantize::pq::device_vpq_dataset<MathT, IdxT>;
   return owning_t(std::move(codes), std::move(vq_code_book), std::move(pq_code_book));
 }
 
 template <typename DatasetT>
 auto vpq_build_half(const raft::resources& res,
-                    const cuvs::neighbors::vpq_params& params,
-                    const DatasetT& dataset) -> cuvs::neighbors::device_vpq_dataset<half, int64_t>
+                    const cuvs::preprocessing::quantize::pq::vpq_params& params,
+                    const DatasetT& dataset)
+  -> cuvs::preprocessing::quantize::pq::device_vpq_dataset<half, int64_t>
 {
   auto old_type         = vpq_build<decltype(dataset), float, int64_t>(res, params, dataset);
-  using new_owning_t    = cuvs::neighbors::device_vpq_dataset<half, int64_t>;
+  using new_owning_t    = cuvs::preprocessing::quantize::pq::device_vpq_dataset<half, int64_t>;
   auto const old_view   = old_type.as_matrix_view();
   auto new_vq_code_book = raft::make_device_mdarray<half>(res, old_view.vq_code_book.extents());
   auto new_pq_code_book = raft::make_device_mdarray<half>(res, old_view.pq_code_book.extents());
diff --git a/cpp/src/preprocessing/quantize/pq.cu b/cpp/src/preprocessing/quantize/pq.cu
index 20b8f21d36..55276553c2 100644
--- a/cpp/src/preprocessing/quantize/pq.cu
+++ b/cpp/src/preprocessing/quantize/pq.cu
@@ -57,13 +57,13 @@ CUVS_INST_QUANTIZATION(float, uint8_t);
 
 #define CUVS_INST_VPQ_BUILD(T)                                                               \
   auto vpq_build(const raft::resources& res,                                                 \
-                 const cuvs::neighbors::vpq_params& params,                                  \
+                 const cuvs::preprocessing::quantize::pq::vpq_params& params,                \
                  const raft::host_matrix_view<const T, int64_t, raft::row_major>& dataset)   \
   {                                                                                          \
     return detail::vpq_build_half<decltype(dataset)>(res, params, dataset);                  \
   }                                                                                          \
   auto vpq_build(const raft::resources& res,                                                 \
-                 const cuvs::neighbors::vpq_params& params,                                  \
+                 const cuvs::preprocessing::quantize::pq::vpq_params& params,                \
                  const raft::device_matrix_view<const T, int64_t, raft::row_major>& dataset) \
   {                                                                                          \
     return detail::vpq_build_half<decltype(dataset)>(res, params, dataset);                  \
@@ -80,11 +80,12 @@ namespace detail {
 
 template <typename T>
 auto train_from_rows(raft::resources const& res,
-                     cuvs::neighbors::vpq_params const& params,
+                     cuvs::preprocessing::quantize::pq::vpq_params const& params,
                      T const* src_ptr,
                      int64_t n_rows,
                      int64_t dim,
-                     int64_t stride) -> cuvs::neighbors::device_vpq_dataset<half, int64_t>
+                     int64_t stride)
+  -> cuvs::preprocessing::quantize::pq::device_vpq_dataset<half, int64_t>
 {
   cudaPointerAttributes ptr_attrs;
   RAFT_CUDA_TRY(cudaPointerGetAttributes(&ptr_attrs, src_ptr));
@@ -114,12 +115,13 @@ auto train_from_rows(raft::resources const& res,
 }
 
 auto vpq_train_from_rows(raft::resources const& res,
-                         cuvs::neighbors::vpq_params const& params,
+                         cuvs::preprocessing::quantize::pq::vpq_params const& params,
                          void const* src_ptr,
                          cudaDataType_t dtype,
                          int64_t n_rows,
                          int64_t dim,
-                         int64_t stride) -> cuvs::neighbors::device_vpq_dataset<half, int64_t>
+                         int64_t stride)
+  -> cuvs::preprocessing::quantize::pq::device_vpq_dataset<half, int64_t>
 {
   switch (dtype) {
     case CUDA_R_32F:
diff --git a/cpp/tests/neighbors/ann_cagra/bug_iterative_cagra_build.cu b/cpp/tests/neighbors/ann_cagra/bug_iterative_cagra_build.cu
index 8a0b7c3d36..d418a548bc 100644
--- a/cpp/tests/neighbors/ann_cagra/bug_iterative_cagra_build.cu
+++ b/cpp/tests/neighbors/ann_cagra/bug_iterative_cagra_build.cu
@@ -59,7 +59,7 @@ class CagraIterativeBuildBugTest : public ::testing::Test {
   // so the searches driving the build run on compressed rows instead of dense ones.
   void run_compressed()
   {
-    cuvs::neighbors::vpq_params vpq_params;
+    cuvs::preprocessing::quantize::pq::vpq_params vpq_params;
     // pq_len = n_dim / pq_dim must be 2, 4 or 8 for CAGRA-Q. Codebook quality is irrelevant here,
     // since only graph construction is under test, so training stays short.
     vpq_params.pq_dim         = static_cast<uint32_t>(n_dim / 4);
diff --git a/cpp/tests/neighbors/ann_cagra/test_iterative_cagra_q.cu b/cpp/tests/neighbors/ann_cagra/test_iterative_cagra_q.cu
index e0f250a2b0..84e6014ab5 100644
--- a/cpp/tests/neighbors/ann_cagra/test_iterative_cagra_q.cu
+++ b/cpp/tests/neighbors/ann_cagra/test_iterative_cagra_q.cu
@@ -37,7 +37,7 @@
 
 namespace cuvs::neighbors::cagra {
 
-using vpq_dataset_t = cuvs::neighbors::device_vpq_dataset<half, int64_t>;
+using vpq_dataset_t = cuvs::preprocessing::quantize::pq::device_vpq_dataset<half, int64_t>;
 
 namespace {
 
@@ -46,7 +46,7 @@ auto compress(const raft::resources& res,
               uint32_t pq_dim,
               uint32_t pq_bits = 8) -> vpq_dataset_t
 {
-  cuvs::neighbors::vpq_params params;
+  cuvs::preprocessing::quantize::pq::vpq_params params;
   params.pq_dim         = pq_dim;
   params.pq_bits        = pq_bits;
   params.vq_n_centers   = 32;
diff --git a/cpp/tests/neighbors/ann_cagra_bbq.cuh b/cpp/tests/neighbors/ann_cagra_bbq.cuh
index 0ac52e2265..c03c963fe8 100644
--- a/cpp/tests/neighbors/ann_cagra_bbq.cuh
+++ b/cpp/tests/neighbors/ann_cagra_bbq.cuh
@@ -65,7 +65,7 @@ class AnnCagraBbqTest : public ::testing::TestWithParam<AnnCagraBbqInputs> {
 
  protected:
   /** Quantize the float database on the host and upload the codes. */
-  auto quantize_database() -> cuvs::neighbors::device_bbq_dataset<float, int64_t>
+  auto quantize_database() -> cuvs::preprocessing::quantize::bbq::device_bbq_dataset<float, int64_t>
   {
     std::vector<float> host_data(static_cast<size_t>(ps.n_rows) * ps.dim);
     raft::update_host(host_data.data(), database.data(), host_data.size(), stream_);
diff --git a/cpp/tests/neighbors/ann_scann.cuh b/cpp/tests/neighbors/ann_scann.cuh
index 02c145e203..824fa44e1a 100644
--- a/cpp/tests/neighbors/ann_scann.cuh
+++ b/cpp/tests/neighbors/ann_scann.cuh
@@ -185,7 +185,7 @@ class scann_test : public ::testing::TestWithParam<scann_inputs> {
       vq_codebook.data_handle(), idx.centers().data_handle(), idx.centers().size(), stream_);
     auto empty_data = raft::make_device_matrix<uint8_t, int64_t, raft::row_major>(handle_, 0, 0);
 
-    using vpq_owning_t = cuvs::neighbors::device_vpq_dataset<float, int64_t>;
+    using vpq_owning_t = cuvs::preprocessing::quantize::pq::device_vpq_dataset<float, int64_t>;
     cuvs::preprocessing::quantize::pq::quantizer<float> quantizer{
       pq_params,
       vpq_owning_t(std::move(empty_data), std::move(vq_codebook), std::move(pq_codebook_copy))};
diff --git a/cpp/tests/neighbors/vpq_utils.cuh b/cpp/tests/neighbors/vpq_utils.cuh
index ed6a8d9264..d4c875a3af 100644
--- a/cpp/tests/neighbors/vpq_utils.cuh
+++ b/cpp/tests/neighbors/vpq_utils.cuh
@@ -5,6 +5,7 @@
 #pragma once
 
 #include <cuvs/neighbors/common.hpp>
+#include <cuvs/preprocessing/quantize/pq.hpp>
 #include <raft/core/device_mdspan.hpp>
 #include <raft/util/integer_utils.hpp>
 
@@ -45,9 +46,10 @@ __global__ void decode_vpq_dataset_kernel(data_t* const decoded_dataset_ptr,
 }
 
 template <class data_t, class math_t>
-void decode_vpq_dataset(raft::device_matrix_view<data_t, int64_t> decoded_dataset,
-                        const cuvs::neighbors::device_vpq_dataset<math_t, int64_t>& vpq_dataset,
-                        cudaStream_t cuda_stream)
+void decode_vpq_dataset(
+  raft::device_matrix_view<data_t, int64_t> decoded_dataset,
+  const cuvs::preprocessing::quantize::pq::device_vpq_dataset<math_t, int64_t>& vpq_dataset,
+  cudaStream_t cuda_stream)
 {
   const auto dataset_size = decoded_dataset.extent(0);
   auto const data_view    = vpq_dataset.as_matrix_view();
diff --git a/cpp/tests/preprocessing/product_quantization.cu b/cpp/tests/preprocessing/product_quantization.cu
index bdf4680a3f..cc14c9c5d2 100644
--- a/cpp/tests/preprocessing/product_quantization.cu
+++ b/cpp/tests/preprocessing/product_quantization.cu
@@ -322,7 +322,7 @@ TEST(ProductQuantizationTestF, MakeVpqDatasetFromHost)
     dataset.data_handle()[i] = static_cast<float>(i % 31) / 31.0f;
   }
 
-  cuvs::neighbors::vpq_params params{
+  cuvs::preprocessing::quantize::pq::vpq_params params{
     .pq_bits = 4, .pq_dim = 4, .vq_n_centers = 1, .kmeans_n_iters = 2};
   auto vpq = make_vpq_dataset(handle, params, raft::make_const_mdspan(dataset.view()));
   raft::resource::sync_stream(handle);
@@ -355,7 +355,7 @@ TEST(ProductQuantizationTestF, MakeVpqDatasetFromPaddedView)
     raft::make_device_matrix_view<const float, int64_t>(device_rows.data_handle(), n_rows, stride),
     dim);
 
-  cuvs::neighbors::vpq_params params{
+  cuvs::preprocessing::quantize::pq::vpq_params params{
     .pq_bits = 4, .pq_dim = 4, .vq_n_centers = 1, .kmeans_n_iters = 2};
   auto vpq = make_vpq_dataset(handle, params, padded);
   raft::resource::sync_stream(handle);
diff --git a/fern/pages/cpp_api/cpp-api-core-dataset.md b/fern/pages/cpp_api/cpp-api-core-dataset.md
index 86a2a17e80..9115c01f45 100644
--- a/fern/pages/cpp_api/cpp-api-core-dataset.md
+++ b/fern/pages/cpp_api/cpp-api-core-dataset.md
@@ -13,25 +13,13 @@ _Source header: `cuvs/core/dataset.hpp`_
 
 Spec-based `dataset` / `dataset_view`.
 
-`dataset&lt;T,IdxT,SpecT&gt;` and `dataset_view&lt;T,IdxT,SpecT&gt;` are single generic templates that know nothing about any particular kind of dataset. They hold exactly one payload (`data_type` / `view_type`, chosen by the spec) and expose only what every dataset has: `n_rows()`, `dim()`, `as_matrix_view()`, `as_dataset_view()` and `data()`. Each is a one-line forward to one of the three spec functions `get_data_view()`, `get_n_rows()` and `get_dim()`. Anything else a kind needs (e.g. VPQ codebooks, BBQ quantizers) is state and methods of that kind's payload type, reached through `data()`; `dataset`/`dataset_view` never name or branch on it. `dataset` and `dataset_view` are deliberately two independent, non-inheriting types (no shared_ptr, no "sometimes owning" object): `dataset` holds the owning payload, `dataset_view` the corresponding non-owning payload.
+`dataset&lt;T,IdxT,SpecT&gt;` and `dataset_view&lt;T,IdxT,SpecT&gt;` are single generic templates that know nothing about any particular kind of dataset. They hold exactly one payload (`data_type` / `view_type`, chosen by the spec) and expose only what every dataset has: `n_rows()`, `dim()`, `as_matrix_view()`, `as_dataset_view()` and `data()`. Each is a one-line forward to one of the three spec functions `get_data_view()`, `get_n_rows()` and `get_dim()`. Anything else a kind needs (e.g. codebooks or quantizers of a compressed dataset) is state and methods of that kind's payload type, reached through `data()`; `dataset`/`dataset_view` never name or branch on it. Compressed kinds define their payloads and specs in their own headers (quantize/pq.hpp, quantize/bbq.hpp) as children of these two structs. `dataset` and `dataset_view` are deliberately two independent, non-inheriting types (no shared_ptr, no "sometimes owning" object): `dataset` holds the owning payload, `dataset_view` the corresponding non-owning payload.
 
 ```cpp
 template <typename T, typename IdxT, typename SpecT>
 struct dataset;
 ```
 
-<a id="neighbors-vpq-dataset-spec"></a>
-### neighbors::vpq_dataset_spec
-
-`Accessor` drives both codebook and code residency, mirroring today's
-
-single-`Accessor`-per-VPQ-dataset design. The payload (`detail::vpq_owning_storage` / `detail::vpq_view_storage`) holds the encoded rows and the VQ/PQ codebooks.
-
-```cpp
-template <typename MathT, typename Accessor>
-struct vpq_dataset_spec;
-```
-
 <a id="neighbors-dataset"></a>
 ### neighbors::dataset
 
@@ -59,32 +47,36 @@ struct dataset_view;
 <a id="neighbors-is-padded-dataset"></a>
 ### neighbors::is_padded_dataset
 
-Owning-side kind traits (mirror today's `is_padded_dataset_v`/`is_standard_dataset_v`/
-
-`is_vpq_dataset_v`, used for SFINAE overload selection in factory.cuh/compute_distance_vpq.hpp).
+Owning-side kind traits (true for both `dataset&lt;...&gt;` and `dataset_view&lt;...&gt;` of that kind).
 
 ```cpp
 template <typename DatasetT>
 struct is_padded_dataset;
 ```
 
-<a id="neighbors-dataset-view-kind-of"></a>
-### neighbors::dataset_view_kind_of
+<a id="neighbors-is-dataset-view"></a>
+### neighbors::is_dataset_view
+
+True for any `dataset_view&lt;...&gt;` specialization. Evaluates to `false` (never a hard error) for
 
-Primary template returns `unknown` so traits safely return `false` for non-dataset-view types.
+everything else, e.g. a plain mdspan passed to a deprecated `build(matrix_view)` overload.
 
 ```cpp
 template <typename V>
-struct dataset_view_kind_of {
-  static constexpr dataset_view_kind value;
-};
+struct is_dataset_view;
 ```
 
-**Fields**
+<a id="neighbors-dataset-view-has-spec"></a>
+### neighbors::dataset_view_has_spec
+
+True when `V` is a `dataset_view` whose spec satisfies the predicate `SpecPred&lt;SpecT&gt;::value`.
 
-| Name | Type | Description |
-| --- | --- | --- |
-| `value` | `static constexpr dataset_view_kind` |  |
+This is how a kind that lives outside this header classifies its own views.
+
+```cpp
+template <typename V, template <typename> typename SpecPred>
+struct dataset_view_has_spec;
+```
 
 <a id="neighbors-dataset-view-is-device-accessible"></a>
 ### neighbors::dataset_view_is_device_accessible
@@ -99,9 +91,9 @@ struct dataset_view_is_device_accessible;
 <a id="neighbors-with-accessor"></a>
 ### neighbors::with_accessor
 
-Generic accessor retargeting while preserving the dataset tag/layout and value/index types:
+Generic accessor retargeting while preserving the spec kind and value/index types:
 
-`dataset&lt;T, IdxT, SpecT&lt;..., OldAccessor&gt;&gt;      -&gt; dataset&lt;T, IdxT, SpecT&lt;..., NewAccessor&gt;&gt;` `dataset_view&lt;T, IdxT, SpecT&lt;..., OldAccessor&gt;&gt; -&gt; dataset_view&lt;T, IdxT, SpecT&lt;..., NewAccessor&gt;&gt;`
+`dataset&lt;T, IdxT, SpecT&lt;..., OldAccessor&gt;&gt;      -&gt; dataset&lt;T, IdxT, SpecT&lt;..., NewAccessor&gt;&gt;` `dataset_view&lt;T, IdxT, SpecT&lt;..., OldAccessor&gt;&gt; -&gt; dataset_view&lt;T, IdxT, SpecT&lt;..., NewAccessor&gt;&gt;` Every spec provides `rebind_accessor&lt;NewAccessor&gt;` for this, so this header does not need to know about any particular kind.
 
 ```cpp
 template <typename DatasetLikeT, typename NewAccessor>
diff --git a/fern/pages/cpp_api/cpp-api-neighbors-cagra.md b/fern/pages/cpp_api/cpp-api-neighbors-cagra.md
index 2560f59ef1..33930d4da8 100644
--- a/fern/pages/cpp_api/cpp-api-neighbors-cagra.md
+++ b/fern/pages/cpp_api/cpp-api-neighbors-cagra.md
@@ -31,24 +31,32 @@ enum class search_algo {
 | `MULTI_KERNEL` | `2` |
 | `AUTO` | `100` |
 
-## CAGRA index build parameters
+## Types
+
+<a id="neighbors-graph-build-params-iterative-search-params"></a>
+### neighbors::graph_build_params::iterative_search_params
+
+Parameters for the iterative CAGRA graph build algorithm.
+
+Inherits from cagra::search_params so that all search tuning knobs (search_width, max_iterations, itopk_size, etc.) are available for controlling the search-and-optimize loop during graph construction. The defaults are tuned for the build loop (e.g. search_width=1, max_iterations=8) and may differ from the regular search defaults.
+
+```cpp
+struct iterative_search_params;
+```
 
-<a id="neighbors-vpq-params"></a>
-### neighbors::vpq_params
+<a id="neighbors-graph-build-params-ace-params"></a>
+### neighbors::graph_build_params::ace_params
 
-Parameters for VPQ compression.
+Specialized parameters for ACE (Augmented Core Extraction) graph build
 
 ```cpp
-struct vpq_params {
-  uint32_t pq_bits;
-  uint32_t pq_dim;
-  uint32_t vq_n_centers;
-  uint32_t kmeans_n_iters;
-  double vq_kmeans_trainset_fraction;
-  double pq_kmeans_trainset_fraction;
-  cuvs::cluster::kmeans::kmeans_type pq_kmeans_type;
-  uint32_t max_train_points_per_pq_code;
-  uint32_t max_train_points_per_vq_cluster;
+struct ace_params {
+  size_t npartitions;
+  size_t ef_construction;
+  std::string build_dir;
+  bool use_disk;
+  double max_host_memory_gb;
+  double max_gpu_memory_gb;
 };
 ```
 
@@ -56,15 +64,14 @@ struct vpq_params {
 
 | Name | Type | Description |
 | --- | --- | --- |
-| `pq_bits` | `uint32_t` | The bit length of the vector element after compression by PQ.<br /><br />Possible values: [4, 5, 6, 7, 8].<br /><br />Hint: the smaller the 'pq_bits', the smaller the index size and the better the search performance, but the lower the recall. |
-| `pq_dim` | `uint32_t` | The dimensionality of the vector after compression by PQ. When zero, an optimal value is selected using a heuristic.<br /><br />TODO: at the moment `dim` must be a multiple `pq_dim`. |
-| `vq_n_centers` | `uint32_t` | Vector Quantization (VQ) codebook size - number of "coarse cluster centers". When zero, an optimal value is selected using a heuristic. |
-| `kmeans_n_iters` | `uint32_t` | The number of iterations searching for kmeans centers (both VQ & PQ phases). |
-| `vq_kmeans_trainset_fraction` | `double` | The fraction of data to use during iterative kmeans building (VQ phase). When zero, an optimal value is selected using a heuristic. |
-| `pq_kmeans_trainset_fraction` | `double` | The fraction of data to use during iterative kmeans building (PQ phase). When zero, an optimal value is selected using a heuristic. |
-| `pq_kmeans_type` | [`cuvs::cluster::kmeans::kmeans_type`](/api-reference/cpp-api-cluster-kmeans#cluster-kmeans-kmeans-type) | Type of k-means algorithm for PQ training. Balanced k-means tends to be faster than regular k-means for PQ training, for problem sets where the number of points per cluster are approximately equal. Regular k-means may be better for skewed cluster distributions. |
-| `max_train_points_per_pq_code` | `uint32_t` | The max number of data points to use per PQ code during PQ codebook training. Using more data points per PQ code may increase the quality of PQ codebook but may also increase the build time. We will use `pq_n_centers * max_train_points_per_pq_code` training points to train each PQ codebook. |
-| `max_train_points_per_vq_cluster` | `uint32_t` | The max number of data points to use per VQ cluster during training. |
+| `npartitions` | `size_t` | Number of partitions for ACE (Augmented Core Extraction) partitioned build.<br /><br />When set to 0 (default), the number of partitions is automatically derived based on available host and GPU memory to maximize partition size while ensuring the build fits in memory.<br /><br />Small values might improve recall but potentially degrade performance and increase memory usage. Partitions should not be too small to prevent issues in KNN graph construction. The partition size is on average 2 * (n_rows / npartitions) * dim * sizeof(T). 2 is because of the core and augmented vectors. Please account for imbalance in the partition sizes (up to 3x in our tests).<br /><br />If the specified number of partitions results in partitions that exceed available memory, the value will be automatically increased to fit memory constraints and a warning will be issued. |
+| `ef_construction` | `size_t` | The index quality for the ACE build.<br /><br />Bigger values increase the index quality. At some point, increasing this will no longer improve the quality. |
+| `build_dir` | `std::string` | Directory to store ACE build artifacts (e.g., KNN graph, optimized graph).<br /><br />Used when `use_disk` is true or when the graph does not fit in host and GPU memory. This should be the fastest disk in the system and hold enough space for twice the dataset, final graph, and label mapping. The directory may already exist, but ACE's named artifacts must not already exist. Simultaneous builds must use different directories. On failure, ACE removes only artifacts it created and never deletes unrelated directory contents. |
+| `use_disk` | `bool` | Whether to use disk-based storage for ACE build.<br /><br />When true, enables disk-based operations for memory-efficient graph construction. |
+| `max_host_memory_gb` | `double` | Maximum host memory to use for ACE build in GiB.<br /><br />When set to 0 (default), uses available host memory. When set to a positive value, limits host memory usage to the specified amount. Useful for testing or when running alongside other memory-intensive processes. |
+| `max_gpu_memory_gb` | `double` | Maximum GPU memory to use for ACE build in GiB.<br /><br />When set to 0 (default), uses available GPU memory. When set to a positive value, limits GPU memory usage to the specified amount. Useful for testing or when running alongside other memory-intensive processes. |
+
+## CAGRA index build parameters
 
 <a id="graph-build-params-t"></a>
 ### graph_build_params_t
@@ -182,46 +189,6 @@ Usage example:
 
 `static cagra::index_params`
 
-## Types
-
-<a id="neighbors-graph-build-params-iterative-search-params"></a>
-### neighbors::graph_build_params::iterative_search_params
-
-Parameters for the iterative CAGRA graph build algorithm.
-
-Inherits from cagra::search_params so that all search tuning knobs (search_width, max_iterations, itopk_size, etc.) are available for controlling the search-and-optimize loop during graph construction. The defaults are tuned for the build loop (e.g. search_width=1, max_iterations=8) and may differ from the regular search defaults.
-
-```cpp
-struct iterative_search_params;
-```
-
-<a id="neighbors-graph-build-params-ace-params"></a>
-### neighbors::graph_build_params::ace_params
-
-Specialized parameters for ACE (Augmented Core Extraction) graph build
-
-```cpp
-struct ace_params {
-  size_t npartitions;
-  size_t ef_construction;
-  std::string build_dir;
-  bool use_disk;
-  double max_host_memory_gb;
-  double max_gpu_memory_gb;
-};
-```
-
-**Fields**
-
-| Name | Type | Description |
-| --- | --- | --- |
-| `npartitions` | `size_t` | Number of partitions for ACE (Augmented Core Extraction) partitioned build.<br /><br />When set to 0 (default), the number of partitions is automatically derived based on available host and GPU memory to maximize partition size while ensuring the build fits in memory.<br /><br />Small values might improve recall but potentially degrade performance and increase memory usage. Partitions should not be too small to prevent issues in KNN graph construction. The partition size is on average 2 * (n_rows / npartitions) * dim * sizeof(T). 2 is because of the core and augmented vectors. Please account for imbalance in the partition sizes (up to 3x in our tests).<br /><br />If the specified number of partitions results in partitions that exceed available memory, the value will be automatically increased to fit memory constraints and a warning will be issued. |
-| `ef_construction` | `size_t` | The index quality for the ACE build.<br /><br />Bigger values increase the index quality. At some point, increasing this will no longer improve the quality. |
-| `build_dir` | `std::string` | Directory to store ACE build artifacts (e.g., KNN graph, optimized graph).<br /><br />Used when `use_disk` is true or when the graph does not fit in host and GPU memory. This should be the fastest disk in the system and hold enough space for twice the dataset, final graph, and label mapping. The directory may already exist, but ACE's named artifacts must not already exist. Simultaneous builds must use different directories. On failure, ACE removes only artifacts it created and never deletes unrelated directory contents. |
-| `use_disk` | `bool` | Whether to use disk-based storage for ACE build.<br /><br />When true, enables disk-based operations for memory-efficient graph construction. |
-| `max_host_memory_gb` | `double` | Maximum host memory to use for ACE build in GiB.<br /><br />When set to 0 (default), uses available host memory. When set to a positive value, limits host memory usage to the specified amount. Useful for testing or when running alongside other memory-intensive processes. |
-| `max_gpu_memory_gb` | `double` | Maximum GPU memory to use for ACE build in GiB.<br /><br />When set to 0 (default), uses available GPU memory. When set to a positive value, limits GPU memory usage to the specified amount. Useful for testing or when running alongside other memory-intensive processes. |
-
 ## CAGRA index extend parameters
 
 <a id="neighbors-cagra-extend-params"></a>
@@ -676,7 +643,7 @@ Build directly from a device VPQ dataset view with FP16 codebooks.
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::device_vpq_dataset_view<half, int64_t> const& dataset)
+cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::device_pq_index<float, uint32_t, half>;
 ```
 
@@ -690,13 +657,13 @@ The returned index accepts float queries and stores a non-owning copy of `datase
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::device_vpq_dataset_view<half, int64_t> const&` | device VPQ dataset view |
+| `dataset` | in | `cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> const&` | device VPQ dataset view |
 
 **Returns**
 
 `cuvs::neighbors::cagra::device_pq_index<float, uint32_t, half>`
 
-built `index&lt;float, uint32_t, device_vpq_dataset_view&lt;half, int64_t&gt;&gt;`
+built `index&lt;float, uint32_t, cuvs::preprocessing::quantize::pq::device_vpq_dataset_view&lt;half, int64_t&gt;&gt;`
 
 **Additional overload:** `neighbors::cagra::build`
 
@@ -1103,9 +1070,10 @@ built `host_standard_index&lt;uint8_t, uint32_t&gt;`
 Build from a device BBQ-quantized dataset view.
 
 ```cpp
-auto build(raft::resources const& res,
+auto build(
+raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::device_bbq_dataset_view<float, int64_t> const& dataset)
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::device_bbq_index<float, uint32_t>;
 ```
 
@@ -1119,7 +1087,7 @@ The returned index cannot be searched: CAGRA has no BBQ search kernels. Call the
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::device_bbq_dataset_view<float, int64_t> const&` | device BBQ dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t> const&` | device BBQ dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -1129,12 +1097,13 @@ built `device_bbq_index&lt;float, uint32_t&gt;`
 
 **Additional overload:** `neighbors::cagra::build`
 
-cuvs::neighbors::device_bbq_dataset_view&lt;float, int64_t&gt; const& dataset)
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view&lt;float, int64_t&gt; const& dataset)
 
 ```cpp
-auto build(raft::resources const& res,
+auto build(
+raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::device_bbq_dataset_view<half, int64_t> const& dataset)
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<half, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::device_bbq_index<half, uint32_t>;
 ```
 
@@ -1144,7 +1113,7 @@ cuvs::neighbors::device_bbq_dataset_view<half, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` |  | `raft::resources const&` |  |
 | `params` |  | `const cuvs::neighbors::cagra::index_params&` |  |
-| `dataset` |  | `cuvs::neighbors::device_bbq_dataset_view<half, int64_t> const&` |  |
+| `dataset` |  | `cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<half, int64_t> const&` |  |
 
 **Returns**
 
@@ -1152,12 +1121,13 @@ cuvs::neighbors::device_bbq_dataset_view<half, int64_t> const& dataset)
 
 **Additional overload:** `neighbors::cagra::build`
 
-cuvs::neighbors::device_bbq_dataset_view&lt;float, int64_t&gt; const& dataset)
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view&lt;float, int64_t&gt; const& dataset)
 
 ```cpp
-auto build(raft::resources const& res,
+auto build(
+raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::device_bbq_dataset_view<int8_t, int64_t> const& dataset)
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<int8_t, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::device_bbq_index<int8_t, uint32_t>;
 ```
 
@@ -1167,7 +1137,7 @@ cuvs::neighbors::device_bbq_dataset_view<int8_t, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` |  | `raft::resources const&` |  |
 | `params` |  | `const cuvs::neighbors::cagra::index_params&` |  |
-| `dataset` |  | `cuvs::neighbors::device_bbq_dataset_view<int8_t, int64_t> const&` |  |
+| `dataset` |  | `cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<int8_t, int64_t> const&` |  |
 
 **Returns**
 
@@ -1175,12 +1145,13 @@ cuvs::neighbors::device_bbq_dataset_view<int8_t, int64_t> const& dataset)
 
 **Additional overload:** `neighbors::cagra::build`
 
-cuvs::neighbors::device_bbq_dataset_view&lt;float, int64_t&gt; const& dataset)
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view&lt;float, int64_t&gt; const& dataset)
 
 ```cpp
-auto build(raft::resources const& res,
+auto build(
+raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::device_bbq_dataset_view<uint8_t, int64_t> const& dataset)
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<uint8_t, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::device_bbq_index<uint8_t, uint32_t>;
 ```
 
@@ -1190,7 +1161,7 @@ cuvs::neighbors::device_bbq_dataset_view<uint8_t, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` |  | `raft::resources const&` |  |
 | `params` |  | `const cuvs::neighbors::cagra::index_params&` |  |
-| `dataset` |  | `cuvs::neighbors::device_bbq_dataset_view<uint8_t, int64_t> const&` |  |
+| `dataset` |  | `cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<uint8_t, int64_t> const&` |  |
 
 **Returns**
 
diff --git a/fern/pages/cpp_api/cpp-api-neighbors-nn-descent.md b/fern/pages/cpp_api/cpp-api-neighbors-nn-descent.md
index 396966c202..056b98bece 100644
--- a/fern/pages/cpp_api/cpp-api-neighbors-nn-descent.md
+++ b/fern/pages/cpp_api/cpp-api-neighbors-nn-descent.md
@@ -536,7 +536,7 @@ Build an NN-Descent index directly from a device-resident BBQ dataset.
 ```cpp
 auto build(raft::resources const& res,
 index_params const& params,
-cuvs::neighbors::device_bbq_dataset_view<float, int64_t> dataset,
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t> dataset,
 std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>> graph =
 std::nullopt) -> cuvs::neighbors::nn_descent::index<uint32_t>;
 ```
@@ -549,7 +549,7 @@ Symmetric compressed-code distances are used during graph construction. Supporte
 | --- | --- | --- | --- |
 | `res` |  | `raft::resources const&` | raft resources |
 | `params` |  | [`index_params const&`](/api-reference/cpp-api-neighbors-nn-descent#neighbors-nn-descent-index-params) | NN-Descent build parameters |
-| `dataset` |  | `cuvs::neighbors::device_bbq_dataset_view<float, int64_t>` | BBQ codes and correction terms in device memory |
+| `dataset` |  | `cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t>` | BBQ codes and correction terms in device memory |
 | `graph` |  | `std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>>` | optional caller-owned host graph<br />Default: `std::nullopt`. |
 
 **Returns**
@@ -558,12 +558,12 @@ Symmetric compressed-code distances are used during graph construction. Supporte
 
 **Additional overload:** `neighbors::nn_descent::build`
 
-cuvs::neighbors::device_bbq_dataset_view&lt;float, int64_t&gt; dataset,
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view&lt;float, int64_t&gt; dataset,
 
 ```cpp
 auto build(raft::resources const& res,
 index_params const& params,
-cuvs::neighbors::device_bbq_dataset_view<half, int64_t> dataset,
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<half, int64_t> dataset,
 std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>> graph =
 std::nullopt) -> cuvs::neighbors::nn_descent::index<uint32_t>;
 ```
@@ -576,7 +576,7 @@ std::optional&lt;raft::host_matrix_view&lt;uint32_t, int64_t, raft::row_major&gt
 | --- | --- | --- | --- |
 | `res` |  | `raft::resources const&` |  |
 | `params` |  | [`index_params const&`](/api-reference/cpp-api-neighbors-nn-descent#neighbors-nn-descent-index-params) |  |
-| `dataset` |  | `cuvs::neighbors::device_bbq_dataset_view<half, int64_t>` |  |
+| `dataset` |  | `cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<half, int64_t>` |  |
 | `graph` |  | `std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>>` | Default: `std::nullopt`. |
 
 **Returns**
@@ -585,12 +585,12 @@ std::optional&lt;raft::host_matrix_view&lt;uint32_t, int64_t, raft::row_major&gt
 
 **Additional overload:** `neighbors::nn_descent::build`
 
-cuvs::neighbors::device_bbq_dataset_view&lt;float, int64_t&gt; dataset,
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view&lt;float, int64_t&gt; dataset,
 
 ```cpp
 auto build(raft::resources const& res,
 index_params const& params,
-cuvs::neighbors::device_bbq_dataset_view<int8_t, int64_t> dataset,
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<int8_t, int64_t> dataset,
 std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>> graph =
 std::nullopt) -> cuvs::neighbors::nn_descent::index<uint32_t>;
 ```
@@ -603,7 +603,7 @@ std::optional&lt;raft::host_matrix_view&lt;uint32_t, int64_t, raft::row_major&gt
 | --- | --- | --- | --- |
 | `res` |  | `raft::resources const&` |  |
 | `params` |  | [`index_params const&`](/api-reference/cpp-api-neighbors-nn-descent#neighbors-nn-descent-index-params) |  |
-| `dataset` |  | `cuvs::neighbors::device_bbq_dataset_view<int8_t, int64_t>` |  |
+| `dataset` |  | `cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<int8_t, int64_t>` |  |
 | `graph` |  | `std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>>` | Default: `std::nullopt`. |
 
 **Returns**
@@ -612,12 +612,12 @@ std::optional&lt;raft::host_matrix_view&lt;uint32_t, int64_t, raft::row_major&gt
 
 **Additional overload:** `neighbors::nn_descent::build`
 
-cuvs::neighbors::device_bbq_dataset_view&lt;float, int64_t&gt; dataset,
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view&lt;float, int64_t&gt; dataset,
 
 ```cpp
 auto build(raft::resources const& res,
 index_params const& params,
-cuvs::neighbors::device_bbq_dataset_view<uint8_t, int64_t> dataset,
+cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<uint8_t, int64_t> dataset,
 std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>> graph =
 std::nullopt) -> cuvs::neighbors::nn_descent::index<uint32_t>;
 ```
@@ -630,7 +630,7 @@ std::optional&lt;raft::host_matrix_view&lt;uint32_t, int64_t, raft::row_major&gt
 | --- | --- | --- | --- |
 | `res` |  | `raft::resources const&` |  |
 | `params` |  | [`index_params const&`](/api-reference/cpp-api-neighbors-nn-descent#neighbors-nn-descent-index-params) |  |
-| `dataset` |  | `cuvs::neighbors::device_bbq_dataset_view<uint8_t, int64_t>` |  |
+| `dataset` |  | `cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<uint8_t, int64_t>` |  |
 | `graph` |  | `std::optional<raft::host_matrix_view<uint32_t, int64_t, raft::row_major>>` | Default: `std::nullopt`. |
 
 **Returns**
diff --git a/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md b/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md
index a5656e234e..083315f0b6 100644
--- a/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md
+++ b/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md
@@ -154,14 +154,34 @@ dequant_sum_delta from that delta and quantized_component_sums.
 
 ## Types
 
-<a id="neighbors-bbq-dataset-spec"></a>
-### neighbors::bbq_dataset_spec
+<a id="preprocessing-quantize-bbq-bbq-dataset-spec"></a>
+### preprocessing::quantize::bbq::bbq_dataset_spec
 
 BBQ is just another dataset type: it plugs its payloads into the shared `dataset`/
 
-`dataset_view` through a spec, like padded/standard/vpq do.
+`dataset_view` through a spec, like every other kind does.
 
 ```cpp
 template <typename Accessor>
 struct bbq_dataset_spec;
 ```
+
+<a id="preprocessing-quantize-bbq-is-bbq-spec"></a>
+### preprocessing::quantize::bbq::is_bbq_spec
+
+Spec predicate for `cuvs::neighbors::dataset_view_has_spec_v`.
+
+```cpp
+template <typename SpecT>
+struct is_bbq_spec;
+```
+
+<a id="preprocessing-quantize-bbq-is-bbq-dataset"></a>
+### preprocessing::quantize::bbq::is_bbq_dataset
+
+True for an owning `dataset&lt;...&gt;` of the BBQ kind.
+
+```cpp
+template <typename DatasetT>
+struct is_bbq_dataset;
+```
diff --git a/fern/pages/cpp_api/cpp-api-preprocessing-quantize-pq.md b/fern/pages/cpp_api/cpp-api-preprocessing-quantize-pq.md
index 10f88b92a4..c9be7a7226 100644
--- a/fern/pages/cpp_api/cpp-api-preprocessing-quantize-pq.md
+++ b/fern/pages/cpp_api/cpp-api-preprocessing-quantize-pq.md
@@ -85,6 +85,81 @@ uint32_t max_train_points_per_vq_cluster = 1024);
 
 `void`
 
+<a id="preprocessing-quantize-pq-vpq-params"></a>
+### preprocessing::quantize::pq::vpq_params
+
+Parameters for VPQ compression.
+
+```cpp
+struct vpq_params {
+  uint32_t pq_bits;
+  uint32_t pq_dim;
+  uint32_t vq_n_centers;
+  uint32_t kmeans_n_iters;
+  double vq_kmeans_trainset_fraction;
+  double pq_kmeans_trainset_fraction;
+  cuvs::cluster::kmeans::kmeans_type pq_kmeans_type;
+  uint32_t max_train_points_per_pq_code;
+  uint32_t max_train_points_per_vq_cluster;
+};
+```
+
+**Fields**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| `pq_bits` | `uint32_t` | The bit length of the vector element after compression by PQ.<br /><br />Possible values: [4, 5, 6, 7, 8].<br /><br />Hint: the smaller the 'pq_bits', the smaller the index size and the better the search performance, but the lower the recall. |
+| `pq_dim` | `uint32_t` | The dimensionality of the vector after compression by PQ. When zero, an optimal value is selected using a heuristic.<br /><br />TODO: at the moment `dim` must be a multiple `pq_dim`. |
+| `vq_n_centers` | `uint32_t` | Vector Quantization (VQ) codebook size - number of "coarse cluster centers". When zero, an optimal value is selected using a heuristic. |
+| `kmeans_n_iters` | `uint32_t` | The number of iterations searching for kmeans centers (both VQ & PQ phases). |
+| `vq_kmeans_trainset_fraction` | `double` | The fraction of data to use during iterative kmeans building (VQ phase). When zero, an optimal value is selected using a heuristic. |
+| `pq_kmeans_trainset_fraction` | `double` | The fraction of data to use during iterative kmeans building (PQ phase). When zero, an optimal value is selected using a heuristic. |
+| `pq_kmeans_type` | [`cuvs::cluster::kmeans::kmeans_type`](/api-reference/cpp-api-cluster-kmeans#cluster-kmeans-kmeans-type) | Type of k-means algorithm for PQ training. Balanced k-means tends to be faster than regular k-means for PQ training, for problem sets where the number of points per cluster are approximately equal. Regular k-means may be better for skewed cluster distributions. |
+| `max_train_points_per_pq_code` | `uint32_t` | The max number of data points to use per PQ code during PQ codebook training. Using more data points per PQ code may increase the quality of PQ codebook but may also increase the build time. We will use `pq_n_centers * max_train_points_per_pq_code` training points to train each PQ codebook. |
+| `max_train_points_per_vq_cluster` | `uint32_t` | The max number of data points to use per VQ cluster during training. |
+
+<a id="preprocessing-quantize-pq-vpq-dataset-spec"></a>
+### preprocessing::quantize::pq::vpq_dataset_spec
+
+`Accessor` drives both codebook and code residency, mirroring today's
+
+single-`Accessor`-per-VPQ-dataset design. The payload (`detail::vpq_owning_storage` / `detail::vpq_view_storage`) holds the encoded rows and the VQ/PQ codebooks.
+
+```cpp
+template <typename MathT, typename Accessor>
+struct vpq_dataset_spec;
+```
+
+<a id="preprocessing-quantize-pq-is-vpq-spec"></a>
+### preprocessing::quantize::pq::is_vpq_spec
+
+Spec predicate for `cuvs::neighbors::dataset_view_has_spec_v`.
+
+```cpp
+template <typename SpecT>
+struct is_vpq_spec;
+```
+
+<a id="preprocessing-quantize-pq-is-vpq-dataset"></a>
+### preprocessing::quantize::pq::is_vpq_dataset
+
+True for an owning `dataset&lt;...&gt;` of the VPQ kind.
+
+```cpp
+template <typename DatasetT>
+struct is_vpq_dataset;
+```
+
+<a id="preprocessing-quantize-pq-is-vpq-dataset-view-with-math"></a>
+### preprocessing::quantize::pq::is_vpq_dataset_view_with_math
+
+True when `V` is a VPQ `dataset_view` whose codebooks have element type `MathT`.
+
+```cpp
+template <typename V, typename MathT>
+struct is_vpq_dataset_view_with_math;
+```
+
 <a id="preprocessing-quantize-pq-quantizer"></a>
 ### preprocessing::quantize::pq::quantizer
 
@@ -94,7 +169,7 @@ Defines and stores VPQ codebooks upon training
 template <typename T>
 struct quantizer {
   params params_quantizer;
-  cuvs::neighbors::device_vpq_dataset<T, int64_t> vpq_codebooks;
+  device_vpq_dataset<T, int64_t> vpq_codebooks;
 };
 ```
 
@@ -103,7 +178,7 @@ struct quantizer {
 | Name | Type | Description |
 | --- | --- | --- |
 | `params_quantizer` | [`params`](/api-reference/cpp-api-preprocessing-quantize-pq#preprocessing-quantize-pq-params) | Parameters used to build this quantizer. |
-| `vpq_codebooks` | `cuvs::neighbors::device_vpq_dataset<T, int64_t>` | VPQ codebooks produced during training. |
+| `vpq_codebooks` | `device_vpq_dataset<T, int64_t>` | VPQ codebooks produced during training. |
 
 <a id="preprocessing-quantize-pq-build"></a>
 ### preprocessing::quantize::pq::build
@@ -262,9 +337,8 @@ Train VPQ storage (codebooks + encoded rows) from a row-major mdspan/mdarray/dat
 ```cpp
 template <typename SrcT>
 [[nodiscard]] auto make_vpq_dataset(raft::resources const& res,
-cuvs::neighbors::vpq_params const& params,
-SrcT const& src)
--> cuvs::neighbors::device_vpq_dataset<half, int64_t>;
+vpq_params const& params,
+SrcT const& src) -> device_vpq_dataset<half, int64_t>;
 ```
 
 Accepts either a row-major mdspan with `value_type`, `extent`, `stride`, and `data_handle` (same pattern as `cuvs::neighbors::make_device_padded_dataset`), or any cuVS dense dataset / dataset view exposing `view`, `dim` and `stride`, in which case the logical `dim()` is quantized and the row padding is skipped. The rows may be device-accessible or host-resident. Device-accessible rows (device, managed or pinned) with tight row-major storage (logical stride equals dimension) are passed through to training as they are; a wider row pitch triggers a contiguous dense copy first. Host-resident rows are subsampled for training and encoded in bounded batches, so the dense dataset is never staged on the device in full; they must be tightly packed. Empty sources are rejected. The element type must be `float`, `half`, `int8_t` or `uint8_t`.
@@ -276,9 +350,9 @@ Typical **CAGRA-Q** usage: compress the source rows, then build the graph direct
 | Name | Direction | Type | Description |
 | --- | --- | --- | --- |
 | `res` |  | `raft::resources const&` |  |
-| `params` |  | [`cuvs::neighbors::vpq_params const&`](/api-reference/cpp-api-neighbors-cagra#neighbors-vpq-params) |  |
+| `params` |  | [`vpq_params const&`](/api-reference/cpp-api-preprocessing-quantize-pq#preprocessing-quantize-pq-vpq-params) |  |
 | `src` |  | `SrcT const&` |  |
 
 **Returns**
 
-`cuvs::neighbors::device_vpq_dataset<half, int64_t>`
+`device_vpq_dataset<half, int64_t>`

From 5cd4d2da92f30d41d46d392fd6486e9bac85698a Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Fri, 2 Oct 2026 17:04:53 -0700
Subject: [PATCH 10/15] Move datasets from cuvs::neighbors to cuvs::core
 (#2395)

Datasets are a core type, so they now live in the namespace that matches
their header: everything declared in cuvs/core/dataset.hpp moves from
cuvs::neighbors to cuvs::core. The quantizers (pq.hpp, bbq.hpp) build their
datasets on cuvs::core::dataset / dataset_view and no longer name anything
in neighbors.

Moved to cuvs::core:
- dataset, dataset_view and the empty/padded/standard specs and aliases
  (device_/host_{empty,padded,standard}_dataset[_view])
- the kind traits, dataset_view_has_spec_v, is_dataset_view_v,
  with_accessor, device_counterpart, owning_dataset_for_view and
  ann_dataset_view
- the make_{device,host}_{padded,standard}_dataset[_view] factories and the
  CAGRA row-width helpers
- the accessor aliases and dense-storage helpers in core::detail

This is a hard break of the public C++ API with no compatibility aliases in
cuvs::neighbors: user code that names cuvs::neighbors::make_device_padded_dataset,
device_padded_dataset_view and the other moved names must switch to
cuvs::core. The PR should be labelled breaking.

Call sites are updated mechanically across cpp, c and examples: about 480
fully-qualified references, plus unqualified uses inside
namespace cuvs::neighbors (mostly cagra.hpp and the C API). The unused
`nb = cuvs::neighbors` alias in cagra.cuh is removed. The Fern API pages are
regenerated and list the types as core::*.

The rewrite had to avoid identifiers that share a name with the moved API:
local variables and parameters named like a type alias (for example
device_empty_dataset_view in add_nodes.cuh and the C API's
device_padded_dataset parameters), and the C API's own static helpers
make_device_padded_dataset / make_host_padded_dataset_view and friends in
c/src/neighbors/cagra.cpp, which are not the core factories. Those are left
unqualified; type names are only qualified where used as templates and
function names only where called.

The examples and the ANN benchmarks are not built in this configuration, so
those sources were updated but not compiled.

Verified: full rebuild clean (13 test targets, including after
clang-format); all pre-commit hooks pass. DATASET_C_TEST (9), CAGRA_C_TEST
(15), PREPROCESSING_TEST (226), NEIGHBORS_TEST (371),
NEIGHBORS_ANN_CAGRA_BBQ_UINT32_TEST (105), NEIGHBORS_ANN_NN_DESCENT_TEST
(572), NEIGHBORS_ANN_CAGRA_MERGE_TEST (26),
NEIGHBORS_ANN_CAGRA_FLOAT_UINT32_TEST (3594), NEIGHBORS_ANN_SCANN_TEST
(105), NEIGHBORS_ANN_VAMANA_TEST (1260), NEIGHBORS_HNSW_TEST (256),
NEIGHBORS_TIERED_INDEX_TEST (72) and NEIGHBORS_MG_TEST pass.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 c/src/neighbors/cagra.cpp                     | 146 +++---
 c/src/neighbors/cagra.hpp                     |   2 +-
 c/src/neighbors/mg_cagra.cpp                  |  20 +-
 c/src/neighbors/tiered_index.cpp              |   4 +-
 cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h   |  22 +-
 .../ann/src/cuvs/cuvs_mg_cagra_wrapper.h      |   4 +-
 cpp/cmake/patches/faiss-1.14-cuvs-26.08.diff  |  28 +-
 cpp/include/cuvs/core/dataset.hpp             |   4 +-
 cpp/include/cuvs/neighbors/cagra.hpp          | 461 +++++++++---------
 cpp/include/cuvs/neighbors/common.hpp         |   5 +-
 cpp/include/cuvs/neighbors/tiered_index.hpp   |   4 +-
 cpp/include/cuvs/neighbors/vamana.hpp         |  12 +-
 .../cuvs/preprocessing/quantize/bbq.hpp       |  24 +-
 .../cuvs/preprocessing/quantize/pq.hpp        |  42 +-
 cpp/src/neighbors/cagra.cuh                   |  40 +-
 cpp/src/neighbors/cagra_build_inst.cu.in      |   8 +-
 cpp/src/neighbors/cagra_extend_inst.cu.in     |  20 +-
 cpp/src/neighbors/cagra_merge_inst.cu.in      |   4 +-
 cpp/src/neighbors/cagra_search_inst.cu.in     |   6 +-
 cpp/src/neighbors/cagra_serialize.cuh         |  30 +-
 cpp/src/neighbors/cagra_serialize_inst.cu.in  |   4 +-
 cpp/src/neighbors/detail/cagra/add_nodes.cuh  |  18 +-
 .../neighbors/detail/cagra/cagra_build.cuh    |  37 +-
 .../neighbors/detail/cagra/cagra_merge.cuh    |  21 +-
 .../detail/cagra/cagra_merge_scaffold.cuh     |   2 +-
 .../neighbors/detail/cagra/cagra_search.cuh   |  27 +-
 .../detail/cagra/cagra_serialize.cuh          |  38 +-
 .../cagra/compute_distance_standard.hpp       |   2 +-
 cpp/src/neighbors/detail/cagra/factory.cuh    |   4 +-
 .../neighbors/detail/dataset_serialize.hpp    |  41 +-
 cpp/src/neighbors/detail/hnsw.hpp             |   2 +-
 cpp/src/neighbors/detail/tiered_index.cuh     |   4 +-
 .../detail/vamana/vamana_serialize.cuh        |  13 +-
 cpp/src/neighbors/iface/iface.hpp             |  30 +-
 cpp/src/neighbors/mg/mg_cagra_inst.cu.in      |  16 +-
 cpp/src/neighbors/tiered_index.cu             |  12 +-
 cpp/tests/neighbors/ann_cagra.cuh             |  10 +-
 .../bug_graph_smaller_than_dataset.cu         |   8 +-
 .../neighbors/ann_cagra/test_filter_udf.cu    |  16 +-
 .../ann_cagra/test_merge_fastener.cu          |  14 +-
 cpp/tests/neighbors/ann_hnsw_ace.cuh          |   2 +-
 .../neighbors/cagra_padded_build_helpers.cuh  |  14 +-
 .../neighbors/dynamic_batching/test_cagra.cu  |   2 +-
 cpp/tests/neighbors/mg.cuh                    |  12 +-
 cpp/tests/neighbors/tiered_index.cu           |   7 +-
 .../preprocessing/product_quantization.cu     |   2 +-
 .../cpp/src/cagra_bloom_filter_example.cu     |   2 +-
 examples/cpp/src/cagra_example.cu             |   2 +-
 examples/cpp/src/cagra_filter_udf_example.cu  |   2 +-
 examples/cpp/src/cagra_hnsw_ace_example.cu    |   6 +-
 examples/cpp/src/cagra_persistent_example.cu  |   2 +-
 .../cagra_roaring_bitmap_filter_example.cu    |   2 +-
 examples/cpp/src/dynamic_batching_example.cu  |   2 +-
 fern/pages/cpp_api/cpp-api-core-dataset.md    |  40 +-
 fern/pages/cpp_api/cpp-api-neighbors-cagra.md | 149 +++---
 .../pages/cpp_api/cpp-api-neighbors-vamana.md |   4 +-
 .../cpp-api-preprocessing-quantize-bbq.md     |   2 +-
 .../cpp-api-preprocessing-quantize-pq.md      |   4 +-
 58 files changed, 729 insertions(+), 732 deletions(-)

diff --git a/c/src/neighbors/cagra.cpp b/c/src/neighbors/cagra.cpp
index ca941d958e..3d4c13b25b 100644
--- a/c/src/neighbors/cagra.cpp
+++ b/c/src/neighbors/cagra.cpp
@@ -47,7 +47,7 @@ namespace {
  * Heap-allocated bundle for the C API: owns only `cagra::index`.
  * Lives behind `cuvsCagraIndex::addr` via `sg_cagra_c_api_index_box`.
  */
-template <typename T, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
 struct cuvs_cagra_c_api_index_lifetime_holder {
   cuvs::neighbors::cagra::index<T, uint32_t, DatasetViewT> idx;
 };
@@ -66,18 +66,18 @@ struct sg_cagra_c_api_index_box {
   cuvs::neighbors::c_api::detail::owner_record owner_rec;
 };
 
-template <cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <cuvs::core::ann_dataset_view DatasetViewT>
 constexpr auto sg_cagra_index_layout_from_view()
 {
-  if constexpr (cuvs::neighbors::is_device_standard_dataset_view_v<DatasetViewT>) {
+  if constexpr (cuvs::core::is_device_standard_dataset_view_v<DatasetViewT>) {
     return sg_cagra_c_api_index_box::dataset_layout::device_standard;
-  } else if constexpr (cuvs::neighbors::is_device_padded_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::core::is_device_padded_dataset_view_v<DatasetViewT>) {
     return sg_cagra_c_api_index_box::dataset_layout::device_padded;
   } else if constexpr (cuvs::preprocessing::quantize::pq::is_device_vpq_dataset_view_v<DatasetViewT>) {
     return sg_cagra_c_api_index_box::dataset_layout::device_vpq;
   } else if constexpr (cuvs::preprocessing::quantize::bbq::is_device_bbq_dataset_view_v<DatasetViewT>) {
     return sg_cagra_c_api_index_box::dataset_layout::device_bbq;
-  } else if constexpr (cuvs::neighbors::is_host_standard_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::core::is_host_standard_dataset_view_v<DatasetViewT>) {
     return sg_cagra_c_api_index_box::dataset_layout::host_standard;
   } else {
     return sg_cagra_c_api_index_box::dataset_layout::host_padded;
@@ -151,7 +151,7 @@ static void with_index_by_layout(sg_cagra_c_api_index_box* box,
 template <typename T>
 static void destroy_typed_addr(void* ptr);
 
-template <typename T, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
 static void merge_indices_for_layout(
   raft::resources* res_ptr,
   cuvs::neighbors::cagra::index_params const& params_cpp,
@@ -166,7 +166,7 @@ static void merge_indices_for_layout(
                "cuvsCagraMerge: merged dataset handle must be empty");
 
   constexpr auto output_layout =
-    cuvs::neighbors::is_padded_dataset_view_v<DatasetViewT> ? CUVS_DATASET_LAYOUT_PADDED
+    cuvs::core::is_padded_dataset_view_v<DatasetViewT> ? CUVS_DATASET_LAYOUT_PADDED
                                                             : CUVS_DATASET_LAYOUT_STANDARD;
 
   int64_t merged_row_count = 0;
@@ -183,7 +183,7 @@ static void merge_indices_for_layout(
 
     try {
       auto matrix = raft::make_device_matrix<T, int64_t>(*res_ptr, final_row_count, stride);
-      using owner_t = cuvs::neighbors::owning_dataset_for_view_t<DatasetViewT>;
+      using owner_t = cuvs::core::owning_dataset_for_view_t<DatasetViewT>;
       auto owner    = std::make_unique<owner_t>(std::move(matrix), dim);
       auto view     = owner->as_dataset_view();
       auto merged_idx =
@@ -213,10 +213,10 @@ static void merge_indices_for_layout(
     }
 
     using host_view_t = std::conditional_t<
-      cuvs::neighbors::is_padded_dataset_view_v<DatasetViewT>,
-      cuvs::neighbors::host_padded_dataset_view<T, int64_t>,
-      cuvs::neighbors::host_standard_dataset_view<T, int64_t>>;
-    using host_owner_t = cuvs::neighbors::owning_dataset_for_view_t<host_view_t>;
+      cuvs::core::is_padded_dataset_view_v<DatasetViewT>,
+      cuvs::core::host_padded_dataset_view<T, int64_t>,
+      cuvs::core::host_standard_dataset_view<T, int64_t>>;
+    using host_owner_t = cuvs::core::owning_dataset_for_view_t<host_view_t>;
 
     auto matrix = raft::make_host_matrix<T, int64_t>(final_row_count, stride);
     std::fill_n(matrix.data_handle(), static_cast<std::size_t>(matrix.size()), T{});
@@ -268,7 +268,7 @@ static void merge_indices_for_layout(
   }
 }
 
-template <typename T, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
 static auto convert_opaque_indices_to_concrete_types(cuvsCagraIndex_t* indices, size_t num_indices)
   -> std::vector<cuvs::neighbors::cagra::index<T, uint32_t, DatasetViewT>*>
 {
@@ -296,14 +296,14 @@ static void with_dataset_view_for_layout(raft::resources* res_ptr,
     if (cuvs::core::is_dlpack_device_compatible(dataset)) {
       using mdspan_type = raft::device_matrix_view<T const, int64_t, raft::row_major>;
       auto mds = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-      auto ds_view = cuvs::neighbors::make_device_padded_dataset_view(*res_ptr, mds);
+      auto ds_view = cuvs::core::make_device_padded_dataset_view(*res_ptr, mds);
       fn(ds_view);
       return;
     } else if (cuvs::core::is_dlpack_host_compatible(dataset)) {
       if constexpr (!AllowHost) { RAFT_FAIL("%s", host_not_allowed_err); }
       using mdspan_type = raft::host_matrix_view<T const, int64_t, raft::row_major>;
       auto mds = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-      auto ds_view = cuvs::neighbors::make_host_padded_dataset_view(mds);
+      auto ds_view = cuvs::core::make_host_padded_dataset_view(mds);
       fn(ds_view);
       return;
     }
@@ -311,14 +311,14 @@ static void with_dataset_view_for_layout(raft::resources* res_ptr,
     if (cuvs::core::is_dlpack_device_compatible(dataset)) {
       using mdspan_type = raft::device_matrix_view<T const, int64_t, raft::row_major>;
       auto mds = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-      auto ds_view = cuvs::neighbors::make_device_standard_dataset_view(mds);
+      auto ds_view = cuvs::core::make_device_standard_dataset_view(mds);
       fn(ds_view);
       return;
     } else if (cuvs::core::is_dlpack_host_compatible(dataset)) {
       if constexpr (!AllowHost) { RAFT_FAIL("%s", host_not_allowed_err); }
       using mdspan_type = raft::host_matrix_view<T const, int64_t, raft::row_major>;
       auto mds = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-      auto ds_view = cuvs::neighbors::make_host_standard_dataset_view(mds);
+      auto ds_view = cuvs::core::make_host_standard_dataset_view(mds);
       fn(ds_view);
       return;
     }
@@ -328,7 +328,7 @@ static void with_dataset_view_for_layout(raft::resources* res_ptr,
   RAFT_FAIL("%s: dataset must have host- or device-compatible memory", err_prefix);
 }
 
-template <typename T, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
 static void compute_ivfpq_shape_from_indices(cuvsCagraIndex_t* indices,
                                              size_t num_indices,
                                              int64_t* total_size,
@@ -348,7 +348,7 @@ static void compute_ivfpq_shape_from_indices(cuvsCagraIndex_t* indices,
   }
 }
 
-template <typename T, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
 static auto make_sg_cagra_c_api_index_box(
   cuvs_cagra_c_api_index_lifetime_holder<T, DatasetViewT>* holder)
   -> std::unique_ptr<sg_cagra_c_api_index_box>
@@ -359,7 +359,7 @@ static auto make_sg_cagra_c_api_index_box(
                              cuvs::neighbors::c_api::detail::make_owner_record(holder)});
 }
 
-template <typename T, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
 static void bind_index_lifetime_holder_to_C_index(
   cuvsCagraIndex_t out,
   DLDataType dtype,
@@ -370,7 +370,7 @@ static void bind_index_lifetime_holder_to_C_index(
   out->dtype = dtype;
 }
 
-template <typename T, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
 static void wrap_CPP_index_in_lifetime_holder_and_bind_to_C_index(
   cuvsCagraIndex_t out,
   DLDataType dtype,
@@ -546,19 +546,19 @@ static auto make_device_pq_dataset(raft::resources* res_ptr,
   const bool padded = dataset->layout == CUVS_DATASET_LAYOUT_PADDED;
   if (dataset->mem_type == CUVS_DATASET_MEM_TYPE_DEVICE) {
     if (padded) {
-      with_dataset_view<cuvs::neighbors::device_padded_dataset<T, int64_t>,
-                        cuvs::neighbors::device_padded_dataset_view<T, int64_t>>(dataset, make);
+      with_dataset_view<cuvs::core::device_padded_dataset<T, int64_t>,
+                        cuvs::core::device_padded_dataset_view<T, int64_t>>(dataset, make);
     } else {
-      with_dataset_view<cuvs::neighbors::device_standard_dataset<T, int64_t>,
-                        cuvs::neighbors::device_standard_dataset_view<T, int64_t>>(dataset, make);
+      with_dataset_view<cuvs::core::device_standard_dataset<T, int64_t>,
+                        cuvs::core::device_standard_dataset_view<T, int64_t>>(dataset, make);
     }
   } else if (dataset->mem_type == CUVS_DATASET_MEM_TYPE_HOST) {
     if (padded) {
-      with_dataset_view<cuvs::neighbors::host_padded_dataset<T, int64_t>,
-                        cuvs::neighbors::host_padded_dataset_view<T, int64_t>>(dataset, make);
+      with_dataset_view<cuvs::core::host_padded_dataset<T, int64_t>,
+                        cuvs::core::host_padded_dataset_view<T, int64_t>>(dataset, make);
     } else {
-      with_dataset_view<cuvs::neighbors::host_standard_dataset<T, int64_t>,
-                        cuvs::neighbors::host_standard_dataset_view<T, int64_t>>(dataset, make);
+      with_dataset_view<cuvs::core::host_standard_dataset<T, int64_t>,
+                        cuvs::core::host_standard_dataset_view<T, int64_t>>(dataset, make);
     }
   } else {
     RAFT_FAIL("cuvsDatasetMakePQ: invalid source dataset memory type");
@@ -572,16 +572,16 @@ static void make_device_padded_dataset(raft::resources* res_ptr,
                                        cuvsDataset_t* output_padded_dataset)
 {
   auto dataset = dataset_tensor->dl_tensor;
-  using owner_type = cuvs::neighbors::device_padded_dataset<T, int64_t>;
+  using owner_type = cuvs::core::device_padded_dataset<T, int64_t>;
   std::unique_ptr<owner_type> owner;
   if (cuvs::core::is_dlpack_device_compatible(dataset)) {
     using mdspan_type = raft::device_matrix_view<T const, int64_t, raft::row_major>;
     auto mds          = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-    owner             = cuvs::neighbors::make_device_padded_dataset(*res_ptr, mds);
+    owner             = cuvs::core::make_device_padded_dataset(*res_ptr, mds);
   } else if (cuvs::core::is_dlpack_host_compatible(dataset)) {
     using mdspan_type = raft::host_matrix_view<T const, int64_t, raft::row_major>;
     auto mds          = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-    owner             = cuvs::neighbors::make_device_padded_dataset(*res_ptr, mds);
+    owner             = cuvs::core::make_device_padded_dataset(*res_ptr, mds);
   } else {
     RAFT_FAIL("cuvsDatasetMakePadded: unsupported source tensor memory type");
   }
@@ -601,16 +601,16 @@ static void make_host_padded_dataset(raft::resources* res_ptr,
                                      cuvsDataset_t* output_padded_dataset)
 {
   auto dataset = dataset_tensor->dl_tensor;
-  using owner_type = cuvs::neighbors::host_padded_dataset<T, int64_t>;
+  using owner_type = cuvs::core::host_padded_dataset<T, int64_t>;
   std::unique_ptr<owner_type> owner;
   if (cuvs::core::is_dlpack_host_compatible(dataset)) {
     using mdspan_type = raft::host_matrix_view<T const, int64_t, raft::row_major>;
     auto mds          = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-    owner             = cuvs::neighbors::make_host_padded_dataset(*res_ptr, mds);
+    owner             = cuvs::core::make_host_padded_dataset(*res_ptr, mds);
   } else if (cuvs::core::is_dlpack_device_compatible(dataset)) {
     using mdspan_type = raft::device_matrix_view<T const, int64_t, raft::row_major>;
     auto mds          = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-    owner             = cuvs::neighbors::make_host_padded_dataset(*res_ptr, mds);
+    owner             = cuvs::core::make_host_padded_dataset(*res_ptr, mds);
   } else {
     RAFT_FAIL("cuvsDatasetMakePadded: unsupported source tensor memory type");
   }
@@ -637,7 +637,7 @@ static void make_device_padded_dataset_view(raft::resources* res_ptr,
   }
   using mdspan_type = raft::device_matrix_view<T const, int64_t, raft::row_major>;
   auto mds          = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-  auto ds_view      = cuvs::neighbors::make_device_padded_dataset_view(*res_ptr, mds);
+  auto ds_view      = cuvs::core::make_device_padded_dataset_view(*res_ptr, mds);
   auto* owned_view = new decltype(ds_view){ds_view};
   out->addr        = reinterpret_cast<uintptr_t>(owned_view);
   out->destroy_addr = &destroy_typed_addr<decltype(ds_view)>;
@@ -661,7 +661,7 @@ static void make_host_padded_dataset_view(raft::resources*,
   }
   using mdspan_type = raft::host_matrix_view<T const, int64_t, raft::row_major>;
   auto mds          = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-  auto ds_view      = cuvs::neighbors::make_host_padded_dataset_view(mds);
+  auto ds_view      = cuvs::core::make_host_padded_dataset_view(mds);
   auto* owned_view = new decltype(ds_view){ds_view};
   out->addr        = reinterpret_cast<uintptr_t>(owned_view);
   out->destroy_addr = &destroy_typed_addr<decltype(ds_view)>;
@@ -685,7 +685,7 @@ static void make_device_standard_dataset_view(raft::resources*,
   }
   using mdspan_type = raft::device_matrix_view<T const, int64_t, raft::row_major>;
   auto mds          = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-  auto ds_view      = cuvs::neighbors::make_device_standard_dataset_view(mds);
+  auto ds_view      = cuvs::core::make_device_standard_dataset_view(mds);
   auto* owned_view = new decltype(ds_view){ds_view};
   out->addr        = reinterpret_cast<uintptr_t>(owned_view);
   out->destroy_addr = &destroy_typed_addr<decltype(ds_view)>;
@@ -709,7 +709,7 @@ static void make_host_standard_dataset_view(raft::resources*,
   }
   using mdspan_type = raft::host_matrix_view<T const, int64_t, raft::row_major>;
   auto mds          = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-  auto ds_view      = cuvs::neighbors::make_host_standard_dataset_view(mds);
+  auto ds_view      = cuvs::core::make_host_standard_dataset_view(mds);
   auto* owned_view = new decltype(ds_view){ds_view};
   out->addr        = reinterpret_cast<uintptr_t>(owned_view);
   out->destroy_addr = &destroy_typed_addr<decltype(ds_view)>;
@@ -755,8 +755,8 @@ static void update_dataset(raft::resources* res_ptr,
   if (dataset->layout == CUVS_DATASET_LAYOUT_PQ) {
     with_dataset_view<device_vpq_owner_t, device_vpq_view_t>(dataset, rebind);
   } else {
-    using owner_t = cuvs::neighbors::device_padded_dataset<T, int64_t>;
-    using view_t  = cuvs::neighbors::device_padded_dataset_view<T, int64_t>;
+    using owner_t = cuvs::core::device_padded_dataset<T, int64_t>;
+    using view_t  = cuvs::core::device_padded_dataset_view<T, int64_t>;
     with_dataset_view<owner_t, view_t>(dataset, rebind);
   }
 }
@@ -864,8 +864,8 @@ void _from_args(cuvsResources_t res,
   if (cuvs::core::is_dlpack_device_compatible(dataset)) {
     using mdspan_type = raft::device_matrix_view<T const, int64_t, raft::row_major>;
     auto mds          = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-    if (cuvs::neighbors::matrix_row_width_matches_cagra_required(mds)) {
-      auto dataset_view = cuvs::neighbors::make_device_padded_dataset_view(*res_ptr, mds);
+    if (cuvs::core::matrix_row_width_matches_cagra_required(mds)) {
+      auto dataset_view = cuvs::core::make_device_padded_dataset_view(*res_ptr, mds);
       auto* raw         = new cuvs::neighbors::cagra::device_padded_index<T, uint32_t>(
         *res_ptr, metric);
       *raw =
@@ -873,10 +873,10 @@ void _from_args(cuvsResources_t res,
       update_graph_from_dlpack(raw);
       wrap_CPP_index_in_lifetime_holder_and_bind_to_C_index<
         T,
-        cuvs::neighbors::device_padded_dataset_view<T, int64_t>>(
+        cuvs::core::device_padded_dataset_view<T, int64_t>>(
         output_index, output_index->dtype, raw);
     } else {
-      auto dataset_view = cuvs::neighbors::make_device_standard_dataset_view(mds);
+      auto dataset_view = cuvs::core::make_device_standard_dataset_view(mds);
       auto* raw         = new cuvs::neighbors::cagra::device_standard_index<T, uint32_t>(
         *res_ptr, metric);
       *raw =
@@ -884,7 +884,7 @@ void _from_args(cuvsResources_t res,
       update_graph_from_dlpack(raw);
       wrap_CPP_index_in_lifetime_holder_and_bind_to_C_index<
         T,
-        cuvs::neighbors::device_standard_dataset_view<T, int64_t>>(
+        cuvs::core::device_standard_dataset_view<T, int64_t>>(
         output_index, output_index->dtype, raw);
     }
   } else if (cuvs::core::is_dlpack_host_compatible(dataset)) {
@@ -929,8 +929,8 @@ void _extend(cuvsResources_t res,
       if constexpr (!idx_is_padded) {
         RAFT_FAIL("cuvsCagraExtend: only device_padded indices are extendable");
       } else {
-        using out_owner_t = cuvs::neighbors::device_padded_dataset<T, int64_t>;
-        using out_view_t  = cuvs::neighbors::device_padded_dataset_view<T, int64_t>;
+        using out_owner_t = cuvs::core::device_padded_dataset<T, int64_t>;
+        using out_view_t  = cuvs::core::device_padded_dataset_view<T, int64_t>;
         with_dataset_view<out_owner_t, out_view_t>(extended_dataset, [&](auto& out_dataset) {
           cuvs::neighbors::cagra::extend(
             *res_ptr, extend_params, out_dataset, new_start_row, idx);
@@ -1212,34 +1212,34 @@ void dispatch_serialized_dataset_kind(
   switch (kind) {
     case serialized_kind::device_padded:
       fn.template operator()<
-          cuvs::neighbors::device_padded_dataset_view<T, int64_t>>();
+          cuvs::core::device_padded_dataset_view<T, int64_t>>();
       break;
     case serialized_kind::device_standard:
       fn.template operator()<
-          cuvs::neighbors::device_standard_dataset_view<T, int64_t>>();
+          cuvs::core::device_standard_dataset_view<T, int64_t>>();
       break;
     case serialized_kind::host_padded:
       fn.template operator()<
-          cuvs::neighbors::host_padded_dataset_view<T, int64_t>>();
+          cuvs::core::host_padded_dataset_view<T, int64_t>>();
       break;
     case serialized_kind::host_standard:
       fn.template operator()<
-          cuvs::neighbors::host_standard_dataset_view<T, int64_t>>();
+          cuvs::core::host_standard_dataset_view<T, int64_t>>();
       break;
     case serialized_kind::none:
       fn.template operator()<
-          cuvs::neighbors::device_padded_dataset_view<T, int64_t>>();
+          cuvs::core::device_padded_dataset_view<T, int64_t>>();
       break;
   }
 }
 
-template <typename T, cuvs::neighbors::ann_dataset_view ViewT>
+template <typename T, cuvs::core::ann_dataset_view ViewT>
 void _deserialize(cuvsResources_t res, const char *filename,
                   cuvsCagraIndex_t output_index, DLDataType dtype,
                   bool include_dataset, cuvsDataset_t *out_dataset) {
   auto res_ptr = reinterpret_cast<raft::resources *>(res);
   using view_t = ViewT;
-  using owner_dataset_t = cuvs::neighbors::owning_dataset_for_view_t<view_t>;
+  using owner_dataset_t = cuvs::core::owning_dataset_for_view_t<view_t>;
   using holder_t = cuvs_cagra_c_api_index_lifetime_holder<T, view_t>;
 
   auto holder = std::make_unique<holder_t>(
@@ -1262,11 +1262,11 @@ void _deserialize(cuvsResources_t res, const char *filename,
     dataset_handle->destroy_addr = &destroy_typed_addr<owner_dataset_t>;
     dataset_handle->dtype = dtype;
     dataset_handle->mem_type =
-        cuvs::neighbors::is_device_dataset_view_v<view_t>
+        cuvs::core::is_device_dataset_view_v<view_t>
             ? CUVS_DATASET_MEM_TYPE_DEVICE
             : CUVS_DATASET_MEM_TYPE_HOST;
     dataset_handle->layout =
-        cuvs::neighbors::is_padded_dataset_view_v<view_t>
+        cuvs::core::is_padded_dataset_view_v<view_t>
             ? CUVS_DATASET_LAYOUT_PADDED
             : CUVS_DATASET_LAYOUT_STANDARD;
     dataset_handle->is_owning = true;
@@ -1340,10 +1340,10 @@ void _merge(cuvsResources_t res,
   }
   if (params.build_algo == cuvsCagraGraphBuildAlgo::IVF_PQ) {
     if (layout == sg_cagra_c_api_index_box::dataset_layout::device_padded) {
-      compute_ivfpq_shape_from_indices<T, cuvs::neighbors::device_padded_dataset_view<T, int64_t>>(
+      compute_ivfpq_shape_from_indices<T, cuvs::core::device_padded_dataset_view<T, int64_t>>(
         indices, num_indices, &total_size, &dim);
     } else {
-      compute_ivfpq_shape_from_indices<T, cuvs::neighbors::device_standard_dataset_view<T, int64_t>>(
+      compute_ivfpq_shape_from_indices<T, cuvs::core::device_standard_dataset_view<T, int64_t>>(
         indices, num_indices, &total_size, &dim);
     }
   }
@@ -1355,15 +1355,15 @@ void _merge(cuvsResources_t res,
                           dim);
   if (layout == sg_cagra_c_api_index_box::dataset_layout::device_padded) {
     auto index_ptrs =
-      convert_opaque_indices_to_concrete_types<T, cuvs::neighbors::device_padded_dataset_view<T, int64_t>>(
+      convert_opaque_indices_to_concrete_types<T, cuvs::core::device_padded_dataset_view<T, int64_t>>(
         indices, num_indices);
-    merge_indices_for_layout<T, cuvs::neighbors::device_padded_dataset_view<T, int64_t>>(
+    merge_indices_for_layout<T, cuvs::core::device_padded_dataset_view<T, int64_t>>(
       res_ptr, params_cpp, index_ptrs, filter, merge_params, merged_dataset, output_index);
   } else {
     auto index_ptrs =
-      convert_opaque_indices_to_concrete_types<T, cuvs::neighbors::device_standard_dataset_view<T, int64_t>>(
+      convert_opaque_indices_to_concrete_types<T, cuvs::core::device_standard_dataset_view<T, int64_t>>(
         indices, num_indices);
-    merge_indices_for_layout<T, cuvs::neighbors::device_standard_dataset_view<T, int64_t>>(
+    merge_indices_for_layout<T, cuvs::core::device_standard_dataset_view<T, int64_t>>(
       res_ptr, params_cpp, index_ptrs, filter, merge_params, merged_dataset, output_index);
   }
 }
@@ -1892,7 +1892,7 @@ extern "C" cuvsError_t cuvsCagraUpdateDataset(cuvsResources_t res,
  * Build from an already-constructed C++ dataset view. `DatasetViewT` selects the
  * `cuvs::neighbors::cagra::build` overload, and therefore the resulting index type.
  */
-template <typename T, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
 static void build_index_from_dataset_view(raft::resources* res_ptr,
                                           cuvsCagraIndexParams_t params,
                                           DatasetViewT const& ds_view,
@@ -1933,28 +1933,28 @@ static void build_dispatch_on_mem_type_and_layout(raft::resources* res_ptr,
 
   if (dataset->mem_type == CUVS_DATASET_MEM_TYPE_DEVICE) {
     if (is_padded) {
-      using owner_t = cuvs::neighbors::device_padded_dataset<T, int64_t>;
-      using view_t = cuvs::neighbors::device_padded_dataset_view<T, int64_t>;
+      using owner_t = cuvs::core::device_padded_dataset<T, int64_t>;
+      using view_t = cuvs::core::device_padded_dataset_view<T, int64_t>;
       with_dataset_view<owner_t, view_t>(dataset, [&](auto const& view) {
         build_index_from_dataset_view<T>(res_ptr, params, view, index);
       });
     } else {
-      using owner_t = cuvs::neighbors::device_standard_dataset<T, int64_t>;
-      using view_t = cuvs::neighbors::device_standard_dataset_view<T, int64_t>;
+      using owner_t = cuvs::core::device_standard_dataset<T, int64_t>;
+      using view_t = cuvs::core::device_standard_dataset_view<T, int64_t>;
       with_dataset_view<owner_t, view_t>(dataset, [&](auto const& view) {
         build_index_from_dataset_view<T>(res_ptr, params, view, index);
       });
     }
   } else if (dataset->mem_type == CUVS_DATASET_MEM_TYPE_HOST) {
     if (is_padded) {
-      using owner_t = cuvs::neighbors::host_padded_dataset<T, int64_t>;
-      using view_t = cuvs::neighbors::host_padded_dataset_view<T, int64_t>;
+      using owner_t = cuvs::core::host_padded_dataset<T, int64_t>;
+      using view_t = cuvs::core::host_padded_dataset_view<T, int64_t>;
       with_dataset_view<owner_t, view_t>(dataset, [&](auto const& view) {
         build_index_from_dataset_view<T>(res_ptr, params, view, index);
       });
     } else {
-      using owner_t = cuvs::neighbors::host_standard_dataset<T, int64_t>;
-      using view_t = cuvs::neighbors::host_standard_dataset_view<T, int64_t>;
+      using owner_t = cuvs::core::host_standard_dataset<T, int64_t>;
+      using view_t = cuvs::core::host_standard_dataset_view<T, int64_t>;
       with_dataset_view<owner_t, view_t>(dataset, [&](auto const& view) {
         build_index_from_dataset_view<T>(res_ptr, params, view, index);
       });
@@ -2433,7 +2433,7 @@ extern "C" cuvsError_t cuvsCagraDeserializeGraph(cuvsResources_t res,
                  "cuvsCagraDeserializeGraph: null index handle");
     auto const header = read_serialized_header(res, filename);
     dispatch_serialized_dtype(header.dtype, [&]<typename T>() {
-      using view_t = cuvs::neighbors::device_padded_dataset_view<T, int64_t>;
+      using view_t = cuvs::core::device_padded_dataset_view<T, int64_t>;
       _deserialize<T, view_t>(
           res, filename, index, header.dtype, false, nullptr);
     });
diff --git a/c/src/neighbors/cagra.hpp b/c/src/neighbors/cagra.hpp
index 562f78f124..d8b4acfc3c 100644
--- a/c/src/neighbors/cagra.hpp
+++ b/c/src/neighbors/cagra.hpp
@@ -20,7 +20,7 @@ void convert_c_search_params(cuvsCagraSearchParams params,
 void* cagra_c_api_index_ptr(cuvsCagraIndex const* idx);
 
 namespace detail {
-template <typename T, typename IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 int64_t merged_dataset_size(
   raft::resources const& res,
   std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*> const& indices,
diff --git a/c/src/neighbors/mg_cagra.cpp b/c/src/neighbors/mg_cagra.cpp
index 664883cd6f..b4ceaee990 100644
--- a/c/src/neighbors/mg_cagra.cpp
+++ b/c/src/neighbors/mg_cagra.cpp
@@ -75,8 +75,8 @@ static void with_mg_index_by_layout(mg_cagra_c_api_index_box* box,
 template <typename T, typename Fn>
 static void with_device_padded_dataset_view(cuvsDataset_t dataset, Fn&& fn)
 {
-  using owner_t = cuvs::neighbors::device_padded_dataset<T, int64_t>;
-  using view_t  = cuvs::neighbors::device_padded_dataset_view<T, int64_t>;
+  using owner_t = cuvs::core::device_padded_dataset<T, int64_t>;
+  using view_t  = cuvs::core::device_padded_dataset_view<T, int64_t>;
   if (dataset->is_owning) {
     auto* owner = reinterpret_cast<owner_t*>(dataset->addr);
     auto view   = owner->as_dataset_view();
@@ -204,13 +204,13 @@ void* _mg_build(cuvsResources_t res,
 
   if (layout == mg_cagra_dataset_layout::device_padded) {
     using padded_ann_t = cuvs::neighbors::cagra::device_padded_index<T, uint32_t>;
-    auto padded_mds    = cuvs::neighbors::make_host_padded_dataset_view(mds);
+    auto padded_mds    = cuvs::core::make_host_padded_dataset_view(mds);
     auto* mg_index     = new mg_cagra_index_t<T, padded_ann_t>(
       cuvs::neighbors::cagra::build(*res_ptr, mg_params, padded_mds));
     return make_mg_cagra_box<T, padded_ann_t>(mg_index, mg_cagra_dataset_layout::device_padded);
   }
   using standard_ann_t = cuvs::neighbors::cagra::device_standard_index<T, uint32_t>;
-  auto standard_mds    = cuvs::neighbors::make_host_standard_dataset_view(mds);
+  auto standard_mds    = cuvs::core::make_host_standard_dataset_view(mds);
   auto* mg_index       = new mg_cagra_index_t<T, standard_ann_t>(
     cuvs::neighbors::cagra::build(*res_ptr, mg_params, standard_mds));
   return make_mg_cagra_box<T, standard_ann_t>(mg_index, mg_cagra_dataset_layout::device_standard);
@@ -296,13 +296,13 @@ void _mg_extend(cuvsResources_t res,
     using padded_ann_t = cuvs::neighbors::cagra::device_padded_index<T, uint32_t>;
     auto* mg_index_ptr =
       reinterpret_cast<mg_cagra_index_t<T, padded_ann_t>*>(box->index_ptr);
-    auto new_vectors = cuvs::neighbors::make_host_padded_dataset_view(new_vectors_mds);
+    auto new_vectors = cuvs::core::make_host_padded_dataset_view(new_vectors_mds);
     cuvs::neighbors::cagra::extend(*res_ptr, *mg_index_ptr, new_vectors, new_indices_mds);
   } else {
     using standard_ann_t = cuvs::neighbors::cagra::device_standard_index<T, uint32_t>;
     auto* mg_index_ptr =
       reinterpret_cast<mg_cagra_index_t<T, standard_ann_t>*>(box->index_ptr);
-    auto new_vectors = cuvs::neighbors::make_host_standard_dataset_view(new_vectors_mds);
+    auto new_vectors = cuvs::core::make_host_standard_dataset_view(new_vectors_mds);
     cuvs::neighbors::cagra::extend(*res_ptr, *mg_index_ptr, new_vectors, new_indices_mds);
   }
 }
@@ -372,28 +372,28 @@ extern "C" cuvsError_t cuvsMultiGpuCagraBuild(cuvsResources_t res,
     if (dataset.dtype.code == kDLFloat && dataset.dtype.bits == 32) {
       auto mds = cuvs::core::from_dlpack<raft::host_matrix_view<const float, int64_t, raft::row_major>>(
         dataset_tensor);
-      auto layout = cuvs::neighbors::matrix_row_width_matches_cagra_required(mds)
+      auto layout = cuvs::core::matrix_row_width_matches_cagra_required(mds)
                       ? mg_cagra_dataset_layout::device_padded
                       : mg_cagra_dataset_layout::device_standard;
       index->addr = reinterpret_cast<uintptr_t>(_mg_build<float>(res, *params, dataset_tensor, layout));
     } else if (dataset.dtype.code == kDLFloat && dataset.dtype.bits == 16) {
       auto mds = cuvs::core::from_dlpack<raft::host_matrix_view<const half, int64_t, raft::row_major>>(
         dataset_tensor);
-      auto layout = cuvs::neighbors::matrix_row_width_matches_cagra_required(mds)
+      auto layout = cuvs::core::matrix_row_width_matches_cagra_required(mds)
                       ? mg_cagra_dataset_layout::device_padded
                       : mg_cagra_dataset_layout::device_standard;
       index->addr = reinterpret_cast<uintptr_t>(_mg_build<half>(res, *params, dataset_tensor, layout));
     } else if (dataset.dtype.code == kDLInt && dataset.dtype.bits == 8) {
       auto mds = cuvs::core::from_dlpack<raft::host_matrix_view<const int8_t, int64_t, raft::row_major>>(
         dataset_tensor);
-      auto layout = cuvs::neighbors::matrix_row_width_matches_cagra_required(mds)
+      auto layout = cuvs::core::matrix_row_width_matches_cagra_required(mds)
                       ? mg_cagra_dataset_layout::device_padded
                       : mg_cagra_dataset_layout::device_standard;
       index->addr = reinterpret_cast<uintptr_t>(_mg_build<int8_t>(res, *params, dataset_tensor, layout));
     } else if (dataset.dtype.code == kDLUInt && dataset.dtype.bits == 8) {
       auto mds = cuvs::core::from_dlpack<raft::host_matrix_view<const uint8_t, int64_t, raft::row_major>>(
         dataset_tensor);
-      auto layout = cuvs::neighbors::matrix_row_width_matches_cagra_required(mds)
+      auto layout = cuvs::core::matrix_row_width_matches_cagra_required(mds)
                       ? mg_cagra_dataset_layout::device_padded
                       : mg_cagra_dataset_layout::device_standard;
       index->addr = reinterpret_cast<uintptr_t>(_mg_build<uint8_t>(res, *params, dataset_tensor, layout));
diff --git a/c/src/neighbors/tiered_index.cpp b/c/src/neighbors/tiered_index.cpp
index 5ef16833d5..22c385c4af 100644
--- a/c/src/neighbors/tiered_index.cpp
+++ b/c/src/neighbors/tiered_index.cpp
@@ -140,8 +140,8 @@ void* _build(cuvsResources_t res, cuvsTieredIndexParams params, DLManagedTensor*
     case CUVS_TIERED_INDEX_ALGO_CAGRA: {
       auto build_params = tiered_index::index_params<cagra::index_params>();
       convert_c_index_params(params, dataset.shape[0], dataset.shape[1], &build_params);
-      if (cuvs::neighbors::matrix_row_width_matches_cagra_required(mds)) {
-        auto padded_view = cuvs::neighbors::make_device_padded_dataset_view(*res_ptr, mds);
+      if (cuvs::core::matrix_row_width_matches_cagra_required(mds)) {
+        auto padded_view = cuvs::core::make_device_padded_dataset_view(*res_ptr, mds);
         auto* ptr = new tiered_index::index<cagra::device_padded_index<T, uint32_t>>(
           tiered_index::build(*res_ptr, build_params, padded_view));
         return make_tiered_index_box(
diff --git a/cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h b/cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h
index 680d8f177e..87c78bf791 100644
--- a/cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h
+++ b/cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h
@@ -85,11 +85,11 @@ template <typename T, typename SrcT>
 auto make_padded_view(const raft::resources& res,
                       SrcT src,
                       raft::device_matrix<T, int64_t, raft::row_major>& buffer)
-  -> cuvs::neighbors::device_padded_dataset_view<T, int64_t>
+  -> cuvs::core::device_padded_dataset_view<T, int64_t>
 {
   if constexpr (SrcT::accessor_type::is_device_accessible) {
-    if (cuvs::neighbors::matrix_row_width_matches_cagra_required(src)) {
-      return cuvs::neighbors::make_device_padded_dataset_view(res, src);
+    if (cuvs::core::matrix_row_width_matches_cagra_required(src)) {
+      return cuvs::core::make_device_padded_dataset_view(res, src);
     }
   }
   cuvs::neighbors::cagra::detail::copy_with_padding(res, buffer, src);
@@ -303,7 +303,7 @@ void cuvs_cagra<T, IdxT>::build(const T* dataset, size_t nrow)
       // (and dispatches to ACE when it is configured), so the dataset is not uploaded here at all.
       // The single device copy needed for search is made later, by set_search_param.
       host_index_ = std::make_shared<host_index_type>(cuvs::neighbors::cagra::build(
-        handle_, host_params, cuvs::neighbors::make_host_standard_dataset_view(dataset_view_host)));
+        handle_, host_params, cuvs::core::make_host_standard_dataset_view(dataset_view_host)));
       index_ =
         std::make_shared<index_type>(detail::to_graph_only_index<T, IdxT>(handle_, *host_index_));
       // The graph moved into the index along with the file descriptors; nothing views the host
@@ -349,7 +349,7 @@ void cuvs_cagra<T, IdxT>::build(const T* dataset, size_t nrow)
           // As in the single-split case: graph only, the rows are uploaded by set_search_dataset.
           sub_host_indices_.push_back(
             std::make_shared<host_index_type>(cuvs::neighbors::cagra::build(
-              handle_, host_params, cuvs::neighbors::make_host_standard_dataset_view(sub_host))));
+              handle_, host_params, cuvs::core::make_host_standard_dataset_view(sub_host))));
           sub_index = detail::to_graph_only_index<T, IdxT>(handle_, *sub_host_indices_.back());
           if (sub_index.graph_fd().has_value()) { sub_host_indices_.pop_back(); }
         } else {
@@ -371,10 +371,10 @@ void cuvs_cagra<T, IdxT>::build(const T* dataset, size_t nrow)
       for (auto* index : indices) {
         merged_rows += static_cast<int64_t>(index->size());
       }
-      auto const stride = static_cast<int64_t>(
-        cuvs::neighbors::cagra_required_row_width<T>(static_cast<uint32_t>(dim_)));
+      auto const stride =
+        static_cast<int64_t>(cuvs::core::cagra_required_row_width<T>(static_cast<uint32_t>(dim_)));
       *dataset_                = raft::make_device_matrix<T, int64_t>(handle_, merged_rows, stride);
-      auto merged_dataset_view = cuvs::neighbors::device_padded_dataset_view<T, int64_t>(
+      auto merged_dataset_view = cuvs::core::device_padded_dataset_view<T, int64_t>(
         raft::make_const_mdspan(dataset_->view()), static_cast<uint32_t>(dim_));
       index_ =
         std::make_shared<index_type>(cuvs::neighbors::cagra::merge(handle_,
@@ -419,7 +419,7 @@ void cuvs_cagra<T, IdxT>::compress_dataset(const T* dataset, size_t nrow)
     handle_, parse_metric_type(metric_), vpq_dataset_->as_dataset_view(), index_->graph());
 
   // Search runs on the compressed rows and the graph, so release the dense copy of the dataset.
-  cuvs::neighbors::device_padded_dataset_view<T, int64_t> empty_dv(
+  cuvs::core::device_padded_dataset_view<T, int64_t> empty_dv(
     raft::make_device_matrix_view(static_cast<T const*>(nullptr), 0, this->dim_), this->dim_);
   *index_   = cuvs::neighbors::cagra::update_dataset(handle_, std::move(*index_), empty_dv);
   *dataset_ = raft::make_device_matrix<T, int64_t>(handle_, 0, 0);
@@ -486,7 +486,7 @@ void cuvs_cagra<T, IdxT>::set_search_param(const search_param_base& param,
 
     // First free up existing memory
     *dataset_ = raft::make_device_matrix<T, int64_t>(handle_, 0, 0);
-    cuvs::neighbors::device_padded_dataset_view<T, int64_t> empty_dv(
+    cuvs::core::device_padded_dataset_view<T, int64_t> empty_dv(
       raft::make_device_matrix_view(static_cast<T const*>(nullptr), 0, this->dim_), this->dim_);
     *index_ = cuvs::neighbors::cagra::update_dataset(handle_, std::move(*index_), empty_dv);
 
@@ -497,7 +497,7 @@ void cuvs_cagra<T, IdxT>::set_search_param(const search_param_base& param,
     auto mr = get_mr(dataset_mem_);
     cuvs::neighbors::cagra::detail::copy_with_padding(handle_, *dataset_, *input_dataset_v_, mr);
 
-    cuvs::neighbors::device_padded_dataset_view<T, int64_t> dv(
+    cuvs::core::device_padded_dataset_view<T, int64_t> dv(
       raft::make_device_matrix_view(
         dataset_->data_handle(), dataset_->extent(0), dataset_->extent(1)),
       this->dim_);
diff --git a/cpp/bench/ann/src/cuvs/cuvs_mg_cagra_wrapper.h b/cpp/bench/ann/src/cuvs/cuvs_mg_cagra_wrapper.h
index 7a89b68394..439697a19f 100644
--- a/cpp/bench/ann/src/cuvs/cuvs_mg_cagra_wrapper.h
+++ b/cpp/bench/ann/src/cuvs/cuvs_mg_cagra_wrapper.h
@@ -95,8 +95,8 @@ void cuvs_mg_cagra<T, IdxT>::build(const T* dataset, size_t nrow)
     raft::make_host_matrix_view<const T, int64_t, raft::row_major>(dataset, nrow, dim_);
   // The row alignment of the host view is irrelevant: every per-rank device shard is padded
   // individually during the multi-GPU build.
-  cuvs::neighbors::host_padded_dataset_view<T, int64_t> dataset_view(dataset_mds,
-                                                                     static_cast<uint32_t>(dim_));
+  cuvs::core::host_padded_dataset_view<T, int64_t> dataset_view(dataset_mds,
+                                                                static_cast<uint32_t>(dim_));
   auto idx = cuvs::neighbors::cagra::build(clique_, build_params, dataset_view);
   index_   = std::make_shared<
       cuvs::neighbors::mg_index<cuvs::neighbors::cagra::device_padded_index<T, IdxT>, T, IdxT>>(
diff --git a/cpp/cmake/patches/faiss-1.14-cuvs-26.08.diff b/cpp/cmake/patches/faiss-1.14-cuvs-26.08.diff
index 738ae8fa3b..fcb61a8b8b 100644
--- a/cpp/cmake/patches/faiss-1.14-cuvs-26.08.diff
+++ b/cpp/cmake/patches/faiss-1.14-cuvs-26.08.diff
@@ -23,7 +23,7 @@ index 4be7cebb8..42315d027 100644
                  raft::make_device_matrix_view<const uint8_t, int64_t>(
                          train_dataset, n, dim / 8);
 +        auto dataset_view =
-+                cuvs::neighbors::make_device_padded_dataset_view(raft_handle, dataset_mds);
++                cuvs::core::make_device_padded_dataset_view(raft_handle, dataset_mds);
 
          cuvs_index = std::make_shared<
                  cuvs::neighbors::cagra::index<uint8_t, uint32_t>>(
@@ -39,7 +39,7 @@ index 4be7cebb8..42315d027 100644
          auto dataset_mds = raft::make_host_matrix_view<const uint8_t, int64_t>(
                  train_dataset, n, dim / 8);
 +        host_to_device_dataset_ =
-+                cuvs::neighbors::make_device_padded_dataset(raft_handle, dataset_mds);
++                cuvs::core::make_device_padded_dataset(raft_handle, dataset_mds);
 
          cuvs_index = std::make_shared<
                  cuvs::neighbors::cagra::index<uint8_t, uint32_t>>(
@@ -55,7 +55,7 @@ index 4be7cebb8..42315d027 100644
          auto dataset = raft::make_device_matrix_view<const uint8_t, int64_t>(
                  x, n, dim_ / 8);
 +        auto dataset_view =
-+                cuvs::neighbors::make_device_padded_dataset_view(raft_handle, dataset);
++                cuvs::core::make_device_padded_dataset_view(raft_handle, dataset);
          cuvs_index = std::make_shared<
                  cuvs::neighbors::cagra::index<uint8_t, uint32_t>>(
                  cuvs::neighbors::cagra::build(
@@ -66,7 +66,7 @@ index 4be7cebb8..42315d027 100644
          auto dataset = raft::make_host_matrix_view<const uint8_t, int64_t>(
                  x, n, dim_ / 8);
 +        host_to_device_dataset_ =
-+                cuvs::neighbors::make_device_padded_dataset(raft_handle, dataset);
++                cuvs::core::make_device_padded_dataset(raft_handle, dataset);
          cuvs_index = std::make_shared<
                  cuvs::neighbors::cagra::index<uint8_t, uint32_t>>(
                  cuvs::neighbors::cagra::build(
@@ -86,7 +86,7 @@ index 4be7cebb8..42315d027 100644
                              storage_, n_, dim_ / 8);
 -            cuvs_index->update_dataset(raft_handle, dataset);
 +            auto dataset_view =
-+                    cuvs::neighbors::make_device_padded_dataset_view(raft_handle, dataset);
++                    cuvs::core::make_device_padded_dataset_view(raft_handle, dataset);
 +            *cuvs_index = cuvs::neighbors::cagra::update_dataset(
 +                    raft_handle, std::move(*cuvs_index), dataset_view);
          } else {
@@ -95,7 +95,7 @@ index 4be7cebb8..42315d027 100644
                      storage_, n_, dim_ / 8);
 -            cuvs_index->update_dataset(raft_handle, dataset);
 +            host_to_device_dataset_ =
-+                    cuvs::neighbors::make_device_padded_dataset(raft_handle, host_dataset);
++                    cuvs::core::make_device_padded_dataset(raft_handle, host_dataset);
 +            *cuvs_index = cuvs::neighbors::cagra::update_dataset(
 +                    raft_handle,
 +                    std::move(*cuvs_index),
@@ -135,7 +135,7 @@ index 3c7a9eb68..1038380a2 100644
      size_t nn_descent_niter_ = 20;
 
 +    /// Device padded copy when `storage_` is host memory (KNN-graph ctor path).
-+    std::unique_ptr<cuvs::neighbors::device_padded_dataset<uint8_t, int64_t>>
++    std::unique_ptr<cuvs::core::device_padded_dataset<uint8_t, int64_t>>
 +            host_to_device_dataset_;
 +
      /// Instance of trained cuVS CAGRA index
@@ -166,7 +166,7 @@ index 6ff3419b7..f03a5e5f0 100644
          auto dataset_mds = raft::make_device_matrix_view<const data_t, int64_t>(
                  dataset, n, dim);
 +        auto dataset_view =
-+                cuvs::neighbors::make_device_padded_dataset_view(raft_handle, dataset_mds);
++                cuvs::core::make_device_padded_dataset_view(raft_handle, dataset_mds);
 
          cuvs_index = std::make_shared<
                  cuvs::neighbors::cagra::index<data_t, uint32_t>>(
@@ -182,7 +182,7 @@ index 6ff3419b7..f03a5e5f0 100644
          auto dataset_mds = raft::make_host_matrix_view<const data_t, int64_t>(
                  dataset, n, dim);
 +        host_to_device_dataset_ =
-+                cuvs::neighbors::make_device_padded_dataset(raft_handle, dataset_mds);
++                cuvs::core::make_device_padded_dataset(raft_handle, dataset_mds);
 
          cuvs_index = std::make_shared<
                  cuvs::neighbors::cagra::index<data_t, uint32_t>>(
@@ -198,7 +198,7 @@ index 6ff3419b7..f03a5e5f0 100644
          auto dataset = raft::make_device_matrix_view<const data_t, int64_t>(
                  x, n, dim_);
 +        auto dataset_view =
-+                cuvs::neighbors::make_device_padded_dataset_view(raft_handle, dataset);
++                cuvs::core::make_device_padded_dataset_view(raft_handle, dataset);
          cuvs_index = std::make_shared<
                  cuvs::neighbors::cagra::index<data_t, uint32_t>>(
                  cuvs::neighbors::cagra::build(
@@ -209,7 +209,7 @@ index 6ff3419b7..f03a5e5f0 100644
          auto dataset =
                  raft::make_host_matrix_view<const data_t, int64_t>(x, n, dim_);
 +        host_to_device_dataset_ =
-+                cuvs::neighbors::make_device_padded_dataset(raft_handle, dataset);
++                cuvs::core::make_device_padded_dataset(raft_handle, dataset);
          cuvs_index = std::make_shared<
                  cuvs::neighbors::cagra::index<data_t, uint32_t>>(
                  cuvs::neighbors::cagra::build(
@@ -228,7 +228,7 @@ index 6ff3419b7..f03a5e5f0 100644
                      storage_, n_, dim_);
 -            cuvs_index->update_dataset(raft_handle, dataset);
 +            auto dataset_view =
-+                    cuvs::neighbors::make_device_padded_dataset_view(raft_handle, dataset);
++                    cuvs::core::make_device_padded_dataset_view(raft_handle, dataset);
 +            *cuvs_index = cuvs::neighbors::cagra::update_dataset(
 +                    raft_handle, std::move(*cuvs_index), dataset_view);
          } else {
@@ -237,7 +237,7 @@ index 6ff3419b7..f03a5e5f0 100644
                      storage_, n_, dim_);
 -            cuvs_index->update_dataset(raft_handle, dataset);
 +            host_to_device_dataset_ =
-+                    cuvs::neighbors::make_device_padded_dataset(raft_handle, host_dataset);
++                    cuvs::core::make_device_padded_dataset(raft_handle, host_dataset);
 +            *cuvs_index = cuvs::neighbors::cagra::update_dataset(
 +                    raft_handle,
 +                    std::move(*cuvs_index),
@@ -278,7 +278,7 @@ index b4c1989c6..3ad960b92 100644
      bool guarantee_connectivity_ = false;
 
 +    /// Device padded copy when `storage_` is host memory (KNN-graph ctor path).
-+    std::unique_ptr<cuvs::neighbors::device_padded_dataset<data_t, int64_t>>
++    std::unique_ptr<cuvs::core::device_padded_dataset<data_t, int64_t>>
 +            host_to_device_dataset_;
 +
      /// Instance of trained cuVS CAGRA index
diff --git a/cpp/include/cuvs/core/dataset.hpp b/cpp/include/cuvs/core/dataset.hpp
index 70e89fc58d..d80bed23dd 100644
--- a/cpp/include/cuvs/core/dataset.hpp
+++ b/cpp/include/cuvs/core/dataset.hpp
@@ -32,7 +32,7 @@
 #include <utility>
 
 namespace CUVS_EXPORT cuvs {
-namespace neighbors {
+namespace core {
 
 /**
  * @brief Spec-based `dataset` / `dataset_view`.
@@ -947,5 +947,5 @@ auto make_host_standard_dataset_view(SrcT const& src)
     host_standard_dataset_view<value_type, index_type>>(src, static_cast<uint32_t>(src.extent(1)));
 }
 
-}  // namespace neighbors
+}  // namespace core
 }  // namespace CUVS_EXPORT cuvs
diff --git a/cpp/include/cuvs/neighbors/cagra.hpp b/cpp/include/cuvs/neighbors/cagra.hpp
index 93c399e159..86c6983147 100644
--- a/cpp/include/cuvs/neighbors/cagra.hpp
+++ b/cpp/include/cuvs/neighbors/cagra.hpp
@@ -345,7 +345,7 @@ struct index_params : cuvs::neighbors::index_params {
    * Disk-based ACE builds manage file-backed dataset state separately and ignore this flag.
    *
    * @code{.cpp}
-   *   auto dataset = cuvs::neighbors::make_device_padded_dataset(res, host_matrix.view());
+   *   auto dataset = cuvs::core::make_device_padded_dataset(res, host_matrix.view());
    *   cagra::index_params index_params;
    *   // Build graph only — caller attaches dataset later.
    *   index_params.attach_dataset_on_build = false;
@@ -483,7 +483,8 @@ static_assert(std::is_aggregate_v<search_params>);
  */
 template <typename T,
           typename IdxT,
-          ann_dataset_view DatasetViewT = device_padded_dataset_view<T, int64_t>>
+          cuvs::core::ann_dataset_view DatasetViewT =
+            cuvs::core::device_padded_dataset_view<T, int64_t>>
 struct CUVS_EXPORT index : cuvs::neighbors::index {
   using index_params_type  = cagra::index_params;
   using search_params_type = cagra::search_params;
@@ -589,7 +590,7 @@ struct CUVS_EXPORT index : cuvs::neighbors::index {
   /** Construct a graph-only index with a zero-row dataset view placeholder. */
   explicit index(raft::resources const& res,
                  cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Expanded)
-    requires(cuvs::neighbors::ann_dataset_view<DatasetViewT, int64_t>)
+    requires(cuvs::core::ann_dataset_view<DatasetViewT, int64_t>)
     : cuvs::neighbors::index(),
       metric_(metric),
       graph_(raft::make_device_matrix<graph_index_type, int64_t>(res, 0, 0)),
@@ -607,7 +608,7 @@ struct CUVS_EXPORT index : cuvs::neighbors::index {
    * that matrix must outlive the index):
    * @code{.cpp}
    *   raft::device_matrix_view<const float, int64_t, raft::row_major> dataset = ...;
-   *   auto view = cuvs::neighbors::make_device_padded_dataset_view(res, dataset);
+   *   auto view = cuvs::core::make_device_padded_dataset_view(res, dataset);
    *   auto graph = raft::make_device_matrix_view<const uint32_t, int64_t>(...);
    *   cuvs::neighbors::cagra::device_padded_index<float> idx(res, metric, view,
    *                                                       raft::make_const_mdspan(graph));
@@ -618,7 +619,7 @@ struct CUVS_EXPORT index : cuvs::neighbors::index {
    * **keep that object alive** (e.g. hold the `unique_ptr` in a variable or member) for as long as
    * the index uses the dataset; the index does not take ownership of the buffer.
    * @code{.cpp}
-   *   auto padded_owner = cuvs::neighbors::make_device_padded_dataset(res, dataset_mdspan);
+   *   auto padded_owner = cuvs::core::make_device_padded_dataset(res, dataset_mdspan);
    *   auto view         = padded_owner->as_dataset_view();
    *   cuvs::neighbors::cagra::device_padded_index<float> idx(res, metric, view,
    *                                                       raft::make_const_mdspan(graph));
@@ -643,7 +644,7 @@ struct CUVS_EXPORT index : cuvs::neighbors::index {
                  "Dataset and knn_graph must have equal number of rows");
     update_graph(res, knn_graph);
 
-    if constexpr (cuvs::neighbors::is_device_dataset_view_v<DatasetViewT>) {
+    if constexpr (cuvs::core::is_device_dataset_view_v<DatasetViewT>) {
       if (metric_ == cuvs::distance::DistanceType::CosineExpanded && dataset.n_rows() > 0) {
         compute_dataset_norms_(res);
       }
@@ -654,7 +655,7 @@ struct CUVS_EXPORT index : cuvs::neighbors::index {
 
   /* Construct an index with a new dataset type by moving the old index and passing in a new
    * dataset*/
-  template <ann_dataset_view SrcDatasetViewT>
+  template <cuvs::core::ann_dataset_view SrcDatasetViewT>
   index(raft::resources const& res, index<T, IdxT, SrcDatasetViewT>&& other, DatasetViewT dataset)
     : metric_(other.metric_),
       graph_(std::move(other.graph_)),
@@ -668,7 +669,7 @@ struct CUVS_EXPORT index : cuvs::neighbors::index {
       dim_(other.dim_),
       graph_degree_(other.graph_degree_)
   {
-    if constexpr (is_device_dataset_view_v<DatasetViewT>) {
+    if constexpr (cuvs::core::is_device_dataset_view_v<DatasetViewT>) {
       if (metric() == cuvs::distance::DistanceType::CosineExpanded) {
         if (dataset_.n_rows() > 0) { compute_dataset_norms_(res); }
       }
@@ -794,23 +795,23 @@ struct CUVS_EXPORT index : cuvs::neighbors::index {
     // Re-open the file descriptor in read-only mode for subsequent operations
     dataset_fd_.emplace(std::move(fd));
 
-    if constexpr (cuvs::neighbors::is_device_padded_dataset_view_v<DatasetViewT>) {
+    if constexpr (cuvs::core::is_device_padded_dataset_view_v<DatasetViewT>) {
       auto v = raft::make_device_matrix_view<const T, int64_t>(
         static_cast<const T*>(nullptr), int64_t{0}, dim_);
       dataset_ = DatasetViewT(v, dim_);
-    } else if constexpr (cuvs::neighbors::is_device_standard_dataset_view_v<DatasetViewT>) {
+    } else if constexpr (cuvs::core::is_device_standard_dataset_view_v<DatasetViewT>) {
       auto v = raft::make_device_matrix_view<const T, int64_t>(
         static_cast<const T*>(nullptr), int64_t{0}, dim_);
       dataset_ = DatasetViewT(v);
-    } else if constexpr (cuvs::neighbors::is_host_padded_dataset_view_v<DatasetViewT>) {
+    } else if constexpr (cuvs::core::is_host_padded_dataset_view_v<DatasetViewT>) {
       auto v = raft::make_host_matrix_view<const T, int64_t>(
         static_cast<const T*>(nullptr), int64_t{0}, dim_);
       dataset_ = DatasetViewT(v, dim_);
-    } else if constexpr (cuvs::neighbors::is_host_standard_dataset_view_v<DatasetViewT>) {
+    } else if constexpr (cuvs::core::is_host_standard_dataset_view_v<DatasetViewT>) {
       auto v = raft::make_host_matrix_view<const T, int64_t>(
         static_cast<const T*>(nullptr), int64_t{0}, dim_);
       dataset_ = DatasetViewT(v);
-    } else if constexpr (cuvs::neighbors::is_empty_dataset_view_v<DatasetViewT>) {
+    } else if constexpr (cuvs::core::is_empty_dataset_view_v<DatasetViewT>) {
       dataset_ = DatasetViewT{dim_};
     } else {
       RAFT_FAIL("update_dataset(fd): unsupported DatasetViewT for disk-backed dataset");
@@ -895,7 +896,7 @@ struct CUVS_EXPORT index : cuvs::neighbors::index {
   }
 
  private:
-  template <typename, typename, ann_dataset_view>
+  template <typename, typename, cuvs::core::ann_dataset_view>
   friend struct index;
 
   friend struct detail::fd_transfer;
@@ -938,20 +939,19 @@ struct CUVS_EXPORT index : cuvs::neighbors::index {
 
 /** CAGRA index with the usual padded device dataset view (graph build output type). */
 template <typename T, typename IdxT = uint32_t>
-using device_padded_index = index<T, IdxT, cuvs::neighbors::device_padded_dataset_view<T, int64_t>>;
+using device_padded_index = index<T, IdxT, cuvs::core::device_padded_dataset_view<T, int64_t>>;
 
 /** CAGRA index with a host-resident padded dataset view (returned by host build path). */
 template <typename T, typename IdxT = uint32_t>
-using host_padded_index = index<T, IdxT, cuvs::neighbors::host_padded_dataset_view<T, int64_t>>;
+using host_padded_index = index<T, IdxT, cuvs::core::host_padded_dataset_view<T, int64_t>>;
 
 /** CAGRA index with a device-resident standard (arbitrary stride) dataset view. */
 template <typename T, typename IdxT = uint32_t>
-using device_standard_index =
-  index<T, IdxT, cuvs::neighbors::device_standard_dataset_view<T, int64_t>>;
+using device_standard_index = index<T, IdxT, cuvs::core::device_standard_dataset_view<T, int64_t>>;
 
 /** CAGRA index with a host-resident standard dataset view. */
 template <typename T, typename IdxT = uint32_t>
-using host_standard_index = index<T, IdxT, cuvs::neighbors::host_standard_dataset_view<T, int64_t>>;
+using host_standard_index = index<T, IdxT, cuvs::core::host_standard_dataset_view<T, int64_t>>;
 
 /** CAGRA index with a device-resident VPQ dataset. */
 template <typename T, typename IdxT = uint32_t, typename CodebookT = half>
@@ -968,9 +968,9 @@ template <typename DatasetViewT>
 using cagra_index_t = std::conditional_t<
   cuvs::preprocessing::quantize::pq::is_device_vpq_f16_dataset_view_v<DatasetViewT>,
   device_pq_index<float>,
-  index<cuvs::neighbors::cagra_view_element_type_t<DatasetViewT>,
+  index<cuvs::core::cagra_view_element_type_t<DatasetViewT>,
         uint32_t,
-        cuvs::neighbors::dataset_view_type_t<DatasetViewT>>>;
+        cuvs::core::dataset_view_type_t<DatasetViewT>>>;
 
 /**
  * @}
@@ -1039,7 +1039,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::device_padded_dataset_view<float, int64_t> const& dataset)
+           cuvs::core::device_padded_dataset_view<float, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::device_padded_index<float, uint32_t>;
 
 /**
@@ -1051,7 +1051,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::device_standard_dataset_view<float, int64_t> const& dataset)
+           cuvs::core::device_standard_dataset_view<float, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::device_standard_index<float, uint32_t>;
 
 /**
@@ -1063,7 +1063,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::host_padded_dataset_view<float, int64_t> const& dataset)
+           cuvs::core::host_padded_dataset_view<float, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::host_padded_index<float, uint32_t>;
 
 /**
@@ -1075,7 +1075,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::host_standard_dataset_view<float, int64_t> const& dataset)
+           cuvs::core::host_standard_dataset_view<float, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::host_standard_index<float, uint32_t>;
 
 /**
@@ -1087,7 +1087,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::device_padded_dataset_view<half, int64_t> const& dataset)
+           cuvs::core::device_padded_dataset_view<half, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::device_padded_index<half, uint32_t>;
 
 /**
@@ -1099,7 +1099,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::device_standard_dataset_view<half, int64_t> const& dataset)
+           cuvs::core::device_standard_dataset_view<half, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::device_standard_index<half, uint32_t>;
 
 /**
@@ -1111,7 +1111,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::host_padded_dataset_view<half, int64_t> const& dataset)
+           cuvs::core::host_padded_dataset_view<half, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::host_padded_index<half, uint32_t>;
 
 /**
@@ -1123,7 +1123,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::host_standard_dataset_view<half, int64_t> const& dataset)
+           cuvs::core::host_standard_dataset_view<half, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::host_standard_index<half, uint32_t>;
 
 /**
@@ -1135,7 +1135,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::device_padded_dataset_view<int8_t, int64_t> const& dataset)
+           cuvs::core::device_padded_dataset_view<int8_t, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::device_padded_index<int8_t, uint32_t>;
 
 /**
@@ -1147,7 +1147,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::device_standard_dataset_view<int8_t, int64_t> const& dataset)
+           cuvs::core::device_standard_dataset_view<int8_t, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::device_standard_index<int8_t, uint32_t>;
 
 /**
@@ -1159,7 +1159,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::host_padded_dataset_view<int8_t, int64_t> const& dataset)
+           cuvs::core::host_padded_dataset_view<int8_t, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::host_padded_index<int8_t, uint32_t>;
 
 /**
@@ -1171,7 +1171,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::host_standard_dataset_view<int8_t, int64_t> const& dataset)
+           cuvs::core::host_standard_dataset_view<int8_t, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::host_standard_index<int8_t, uint32_t>;
 
 /**
@@ -1183,7 +1183,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::device_padded_dataset_view<uint8_t, int64_t> const& dataset)
+           cuvs::core::device_padded_dataset_view<uint8_t, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::device_padded_index<uint8_t, uint32_t>;
 
 /**
@@ -1195,7 +1195,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::device_standard_dataset_view<uint8_t, int64_t> const& dataset)
+           cuvs::core::device_standard_dataset_view<uint8_t, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::device_standard_index<uint8_t, uint32_t>;
 
 /**
@@ -1207,7 +1207,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::host_padded_dataset_view<uint8_t, int64_t> const& dataset)
+           cuvs::core::host_padded_dataset_view<uint8_t, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::host_padded_index<uint8_t, uint32_t>;
 
 /**
@@ -1219,7 +1219,7 @@ auto build(raft::resources const& res,
  */
 auto build(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
-           cuvs::neighbors::host_standard_dataset_view<uint8_t, int64_t> const& dataset)
+           cuvs::core::host_standard_dataset_view<uint8_t, int64_t> const& dataset)
   -> cuvs::neighbors::cagra::host_standard_index<uint8_t, uint32_t>;
 
 /**
@@ -1299,7 +1299,7 @@ auto build(
  * @code{.cpp}
  *   using namespace cuvs::neighbors;
  *   // Build `extended` = old || new on device, padded for CAGRA.
- *   auto extended = make_device_padded_dataset(res, concatenated_view);
+ *   auto extended = cuvs::core::make_device_padded_dataset(res, concatenated_view);
  *   auto extended_view = extended->as_dataset_view();
  *
  *   cagra::extend_params params;
@@ -1315,28 +1315,28 @@ auto build(
  */
 void extend(raft::resources const& handle,
             const cagra::extend_params& params,
-            cuvs::neighbors::device_padded_dataset_view<float, int64_t> extended_dataset,
+            cuvs::core::device_padded_dataset_view<float, int64_t> extended_dataset,
             int64_t new_start_row,
             cuvs::neighbors::cagra::device_padded_index<float, uint32_t>& idx);
 
 /** @brief Add new vectors to a CAGRA index. See the float overload for the full contract. */
 void extend(raft::resources const& handle,
             const cagra::extend_params& params,
-            cuvs::neighbors::device_padded_dataset_view<half, int64_t> extended_dataset,
+            cuvs::core::device_padded_dataset_view<half, int64_t> extended_dataset,
             int64_t new_start_row,
             cuvs::neighbors::cagra::device_padded_index<half, uint32_t>& idx);
 
 /** @brief Add new vectors to a CAGRA index. See the float overload for the full contract. */
 void extend(raft::resources const& handle,
             const cagra::extend_params& params,
-            cuvs::neighbors::device_padded_dataset_view<int8_t, int64_t> extended_dataset,
+            cuvs::core::device_padded_dataset_view<int8_t, int64_t> extended_dataset,
             int64_t new_start_row,
             cuvs::neighbors::cagra::device_padded_index<int8_t, uint32_t>& idx);
 
 /** @brief Add new vectors to a CAGRA index. See the float overload for the full contract. */
 void extend(raft::resources const& handle,
             const cagra::extend_params& params,
-            cuvs::neighbors::device_padded_dataset_view<uint8_t, int64_t> extended_dataset,
+            cuvs::core::device_padded_dataset_view<uint8_t, int64_t> extended_dataset,
             int64_t new_start_row,
             cuvs::neighbors::cagra::device_padded_index<uint8_t, uint32_t>& idx);
 
@@ -2233,7 +2233,7 @@ void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::device_padded_index<float>* index,
-  std::unique_ptr<cuvs::neighbors::device_padded_dataset<float, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::device_padded_dataset<float, int64_t>>* out_dataset = nullptr);
 
 /**
  * Write the index to an output stream
@@ -2290,7 +2290,7 @@ void deserialize(
   raft::resources const& handle,
   std::istream& is,
   cuvs::neighbors::cagra::device_padded_index<float>* index,
-  std::unique_ptr<cuvs::neighbors::device_padded_dataset<float, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::device_padded_dataset<float, int64_t>>* out_dataset = nullptr);
 /**
  * Save the index to file.
  *
@@ -2348,7 +2348,7 @@ void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::device_padded_index<half>* index,
-  std::unique_ptr<cuvs::neighbors::device_padded_dataset<half, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::device_padded_dataset<half, int64_t>>* out_dataset = nullptr);
 
 /**
  * Write the index to an output stream
@@ -2405,7 +2405,7 @@ void deserialize(
   raft::resources const& handle,
   std::istream& is,
   cuvs::neighbors::cagra::device_padded_index<half>* index,
-  std::unique_ptr<cuvs::neighbors::device_padded_dataset<half, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::device_padded_dataset<half, int64_t>>* out_dataset = nullptr);
 
 /**
  * Save the index to file.
@@ -2463,7 +2463,7 @@ void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::device_padded_index<int8_t>* index,
-  std::unique_ptr<cuvs::neighbors::device_padded_dataset<int8_t, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::device_padded_dataset<int8_t, int64_t>>* out_dataset = nullptr);
 
 /**
  * Write the index to an output stream
@@ -2520,7 +2520,7 @@ void deserialize(
   raft::resources const& handle,
   std::istream& is,
   cuvs::neighbors::cagra::device_padded_index<int8_t>* index,
-  std::unique_ptr<cuvs::neighbors::device_padded_dataset<int8_t, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::device_padded_dataset<int8_t, int64_t>>* out_dataset = nullptr);
 
 /**
  * Save the index to file.
@@ -2578,7 +2578,7 @@ void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::device_padded_index<uint8_t>* index,
-  std::unique_ptr<cuvs::neighbors::device_padded_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::device_padded_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
 
 /**
  * Write the index to an output stream
@@ -2635,7 +2635,7 @@ void deserialize(
   raft::resources const& handle,
   std::istream& is,
   cuvs::neighbors::cagra::device_padded_index<uint8_t>* index,
-  std::unique_ptr<cuvs::neighbors::device_padded_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::device_padded_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
 
 void serialize(raft::resources const& handle,
                const std::string& filename,
@@ -2646,7 +2646,7 @@ void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::device_standard_index<float>* index,
-  std::unique_ptr<cuvs::neighbors::device_standard_dataset<float, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::device_standard_dataset<float, int64_t>>* out_dataset = nullptr);
 
 void serialize(raft::resources const& handle,
                std::ostream& os,
@@ -2657,7 +2657,7 @@ void deserialize(
   raft::resources const& handle,
   std::istream& is,
   cuvs::neighbors::cagra::device_standard_index<float>* index,
-  std::unique_ptr<cuvs::neighbors::device_standard_dataset<float, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::device_standard_dataset<float, int64_t>>* out_dataset = nullptr);
 
 void serialize(raft::resources const& handle,
                const std::string& filename,
@@ -2668,7 +2668,7 @@ void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::device_standard_index<half>* index,
-  std::unique_ptr<cuvs::neighbors::device_standard_dataset<half, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::device_standard_dataset<half, int64_t>>* out_dataset = nullptr);
 
 void serialize(raft::resources const& handle,
                std::ostream& os,
@@ -2679,51 +2679,51 @@ void deserialize(
   raft::resources const& handle,
   std::istream& is,
   cuvs::neighbors::cagra::device_standard_index<half>* index,
-  std::unique_ptr<cuvs::neighbors::device_standard_dataset<half, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::device_standard_dataset<half, int64_t>>* out_dataset = nullptr);
 
 void serialize(raft::resources const& handle,
                const std::string& filename,
                const cuvs::neighbors::cagra::device_standard_index<int8_t>& index,
                bool include_dataset = true);
 
-void deserialize(raft::resources const& handle,
-                 const std::string& filename,
-                 cuvs::neighbors::cagra::device_standard_index<int8_t>* index,
-                 std::unique_ptr<cuvs::neighbors::device_standard_dataset<int8_t, int64_t>>*
-                   out_dataset = nullptr);
+void deserialize(
+  raft::resources const& handle,
+  const std::string& filename,
+  cuvs::neighbors::cagra::device_standard_index<int8_t>* index,
+  std::unique_ptr<cuvs::core::device_standard_dataset<int8_t, int64_t>>* out_dataset = nullptr);
 
 void serialize(raft::resources const& handle,
                std::ostream& os,
                const cuvs::neighbors::cagra::device_standard_index<int8_t>& index,
                bool include_dataset = true);
 
-void deserialize(raft::resources const& handle,
-                 std::istream& is,
-                 cuvs::neighbors::cagra::device_standard_index<int8_t>* index,
-                 std::unique_ptr<cuvs::neighbors::device_standard_dataset<int8_t, int64_t>>*
-                   out_dataset = nullptr);
+void deserialize(
+  raft::resources const& handle,
+  std::istream& is,
+  cuvs::neighbors::cagra::device_standard_index<int8_t>* index,
+  std::unique_ptr<cuvs::core::device_standard_dataset<int8_t, int64_t>>* out_dataset = nullptr);
 
 void serialize(raft::resources const& handle,
                const std::string& filename,
                const cuvs::neighbors::cagra::device_standard_index<uint8_t>& index,
                bool include_dataset = true);
 
-void deserialize(raft::resources const& handle,
-                 const std::string& filename,
-                 cuvs::neighbors::cagra::device_standard_index<uint8_t>* index,
-                 std::unique_ptr<cuvs::neighbors::device_standard_dataset<uint8_t, int64_t>>*
-                   out_dataset = nullptr);
+void deserialize(
+  raft::resources const& handle,
+  const std::string& filename,
+  cuvs::neighbors::cagra::device_standard_index<uint8_t>* index,
+  std::unique_ptr<cuvs::core::device_standard_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
 
 void serialize(raft::resources const& handle,
                std::ostream& os,
                const cuvs::neighbors::cagra::device_standard_index<uint8_t>& index,
                bool include_dataset = true);
 
-void deserialize(raft::resources const& handle,
-                 std::istream& is,
-                 cuvs::neighbors::cagra::device_standard_index<uint8_t>* index,
-                 std::unique_ptr<cuvs::neighbors::device_standard_dataset<uint8_t, int64_t>>*
-                   out_dataset = nullptr);
+void deserialize(
+  raft::resources const& handle,
+  std::istream& is,
+  cuvs::neighbors::cagra::device_standard_index<uint8_t>* index,
+  std::unique_ptr<cuvs::core::device_standard_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
 
 /* FP16-codebook device_pq_index graph-only overloads (CAGRA-Q).
  *
@@ -2964,56 +2964,56 @@ void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::host_padded_index<float>* index,
-  std::unique_ptr<cuvs::neighbors::host_padded_dataset<float, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::host_padded_dataset<float, int64_t>>* out_dataset = nullptr);
 
 /** @copydoc deserialize */
 void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::host_standard_index<float>* index,
-  std::unique_ptr<cuvs::neighbors::host_standard_dataset<float, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::host_standard_dataset<float, int64_t>>* out_dataset = nullptr);
 
 /** @copydoc deserialize */
 void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::host_padded_index<half>* index,
-  std::unique_ptr<cuvs::neighbors::host_padded_dataset<half, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::host_padded_dataset<half, int64_t>>* out_dataset = nullptr);
 
 /** @copydoc deserialize */
 void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::host_standard_index<half>* index,
-  std::unique_ptr<cuvs::neighbors::host_standard_dataset<half, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::host_standard_dataset<half, int64_t>>* out_dataset = nullptr);
 
 /** @copydoc deserialize */
 void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::host_padded_index<int8_t>* index,
-  std::unique_ptr<cuvs::neighbors::host_padded_dataset<int8_t, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::host_padded_dataset<int8_t, int64_t>>* out_dataset = nullptr);
 
 /** @copydoc deserialize */
 void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::host_standard_index<int8_t>* index,
-  std::unique_ptr<cuvs::neighbors::host_standard_dataset<int8_t, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::host_standard_dataset<int8_t, int64_t>>* out_dataset = nullptr);
 
 /** @copydoc deserialize */
 void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::host_padded_index<uint8_t>* index,
-  std::unique_ptr<cuvs::neighbors::host_padded_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::host_padded_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
 
 /** @copydoc deserialize */
 void deserialize(
   raft::resources const& handle,
   const std::string& filename,
   cuvs::neighbors::cagra::host_standard_index<uint8_t>* index,
-  std::unique_ptr<cuvs::neighbors::host_standard_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
+  std::unique_ptr<cuvs::core::host_standard_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
 
 /**
  * Write the CAGRA built index as a base layer HNSW index to an output stream
@@ -3520,7 +3520,7 @@ struct merge_params {
  * explicit FASTENER.
  * @return The merged physical CAGRA index.
  */
-template <typename T, typename IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 auto merge(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
            std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*>& indices,
@@ -3532,7 +3532,7 @@ auto merge(raft::resources const& res,
 /** @copydoc merge
  * @param[in] merge_params Parameters for the merge, including the algorithm selection.
  */
-template <typename T, typename IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 auto merge(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
            std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*>& indices,
@@ -3567,7 +3567,7 @@ auto merge(raft::resources const& res,
  */
 auto build(const raft::resources& clique,
            const cuvs::neighbors::mg_index_params<cagra::index_params>& index_params,
-           cuvs::neighbors::host_standard_dataset_view<float, int64_t> const& index_dataset)
+           cuvs::core::host_standard_dataset_view<float, int64_t> const& index_dataset)
   -> cuvs::neighbors::mg_index<cagra::device_standard_index<float, uint32_t>, float, uint32_t>;
 
 /// \ingroup mg_cpp_index_build
@@ -3589,7 +3589,7 @@ auto build(const raft::resources& clique,
  */
 auto build(const raft::resources& clique,
            const cuvs::neighbors::mg_index_params<cagra::index_params>& index_params,
-           cuvs::neighbors::host_standard_dataset_view<half, int64_t> const& index_dataset)
+           cuvs::core::host_standard_dataset_view<half, int64_t> const& index_dataset)
   -> cuvs::neighbors::mg_index<cagra::device_standard_index<half, uint32_t>, half, uint32_t>;
 
 /// \ingroup mg_cpp_index_build
@@ -3611,7 +3611,7 @@ auto build(const raft::resources& clique,
  */
 auto build(const raft::resources& clique,
            const cuvs::neighbors::mg_index_params<cagra::index_params>& index_params,
-           cuvs::neighbors::host_standard_dataset_view<int8_t, int64_t> const& index_dataset)
+           cuvs::core::host_standard_dataset_view<int8_t, int64_t> const& index_dataset)
   -> cuvs::neighbors::mg_index<cagra::device_standard_index<int8_t, uint32_t>, int8_t, uint32_t>;
 
 /// \ingroup mg_cpp_index_build
@@ -3633,27 +3633,27 @@ auto build(const raft::resources& clique,
  */
 auto build(const raft::resources& clique,
            const cuvs::neighbors::mg_index_params<cagra::index_params>& index_params,
-           cuvs::neighbors::host_standard_dataset_view<uint8_t, int64_t> const& index_dataset)
+           cuvs::core::host_standard_dataset_view<uint8_t, int64_t> const& index_dataset)
   -> cuvs::neighbors::mg_index<cagra::device_standard_index<uint8_t, uint32_t>, uint8_t, uint32_t>;
 
 auto build(const raft::resources& clique,
            const cuvs::neighbors::mg_index_params<cagra::index_params>& index_params,
-           cuvs::neighbors::host_padded_dataset_view<float, int64_t> const& index_dataset)
+           cuvs::core::host_padded_dataset_view<float, int64_t> const& index_dataset)
   -> cuvs::neighbors::mg_index<cagra::device_padded_index<float, uint32_t>, float, uint32_t>;
 
 auto build(const raft::resources& clique,
            const cuvs::neighbors::mg_index_params<cagra::index_params>& index_params,
-           cuvs::neighbors::host_padded_dataset_view<half, int64_t> const& index_dataset)
+           cuvs::core::host_padded_dataset_view<half, int64_t> const& index_dataset)
   -> cuvs::neighbors::mg_index<cagra::device_padded_index<half, uint32_t>, half, uint32_t>;
 
 auto build(const raft::resources& clique,
            const cuvs::neighbors::mg_index_params<cagra::index_params>& index_params,
-           cuvs::neighbors::host_padded_dataset_view<int8_t, int64_t> const& index_dataset)
+           cuvs::core::host_padded_dataset_view<int8_t, int64_t> const& index_dataset)
   -> cuvs::neighbors::mg_index<cagra::device_padded_index<int8_t, uint32_t>, int8_t, uint32_t>;
 
 auto build(const raft::resources& clique,
            const cuvs::neighbors::mg_index_params<cagra::index_params>& index_params,
-           cuvs::neighbors::host_padded_dataset_view<uint8_t, int64_t> const& index_dataset)
+           cuvs::core::host_padded_dataset_view<uint8_t, int64_t> const& index_dataset)
   -> cuvs::neighbors::mg_index<cagra::device_padded_index<uint8_t, uint32_t>, uint8_t, uint32_t>;
 
 /**
@@ -3664,26 +3664,26 @@ auto build(const raft::resources& clique,
 auto update_dataset(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_standard_index<float, uint32_t>, float, uint32_t>&& idx,
-  cuvs::neighbors::device_padded_dataset_view<float, int64_t> const& padded_dataset)
+  cuvs::core::device_padded_dataset_view<float, int64_t> const& padded_dataset)
   -> cuvs::neighbors::mg_index<cagra::device_padded_index<float, uint32_t>, float, uint32_t>;
 
 auto update_dataset(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_standard_index<half, uint32_t>, half, uint32_t>&& idx,
-  cuvs::neighbors::device_padded_dataset_view<half, int64_t> const& padded_dataset)
+  cuvs::core::device_padded_dataset_view<half, int64_t> const& padded_dataset)
   -> cuvs::neighbors::mg_index<cagra::device_padded_index<half, uint32_t>, half, uint32_t>;
 
 auto update_dataset(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_standard_index<int8_t, uint32_t>, int8_t, uint32_t>&& idx,
-  cuvs::neighbors::device_padded_dataset_view<int8_t, int64_t> const& padded_dataset)
+  cuvs::core::device_padded_dataset_view<int8_t, int64_t> const& padded_dataset)
   -> cuvs::neighbors::mg_index<cagra::device_padded_index<int8_t, uint32_t>, int8_t, uint32_t>;
 
 auto update_dataset(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_standard_index<uint8_t, uint32_t>, uint8_t, uint32_t>&&
     idx,
-  cuvs::neighbors::device_padded_dataset_view<uint8_t, int64_t> const& padded_dataset)
+  cuvs::core::device_padded_dataset_view<uint8_t, int64_t> const& padded_dataset)
   -> cuvs::neighbors::mg_index<cagra::device_padded_index<uint8_t, uint32_t>, uint8_t, uint32_t>;
 
 /**
@@ -3692,22 +3692,22 @@ auto update_dataset(
 void update_dataset(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_padded_index<float, uint32_t>, float, uint32_t>& idx,
-  cuvs::neighbors::device_padded_dataset_view<float, int64_t> const& padded_dataset);
+  cuvs::core::device_padded_dataset_view<float, int64_t> const& padded_dataset);
 
 void update_dataset(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_padded_index<half, uint32_t>, half, uint32_t>& idx,
-  cuvs::neighbors::device_padded_dataset_view<half, int64_t> const& padded_dataset);
+  cuvs::core::device_padded_dataset_view<half, int64_t> const& padded_dataset);
 
 void update_dataset(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_padded_index<int8_t, uint32_t>, int8_t, uint32_t>& idx,
-  cuvs::neighbors::device_padded_dataset_view<int8_t, int64_t> const& padded_dataset);
+  cuvs::core::device_padded_dataset_view<int8_t, int64_t> const& padded_dataset);
 
 void update_dataset(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_padded_index<uint8_t, uint32_t>, uint8_t, uint32_t>& idx,
-  cuvs::neighbors::device_padded_dataset_view<uint8_t, int64_t> const& padded_dataset);
+  cuvs::core::device_padded_dataset_view<uint8_t, int64_t> const& padded_dataset);
 
 /// \defgroup mg_cpp_index_extend ANN MG index extend
 
@@ -3733,7 +3733,7 @@ void update_dataset(
 void extend(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_padded_index<float, uint32_t>, float, uint32_t>& index,
-  cuvs::neighbors::host_padded_dataset_view<float, int64_t> new_vectors,
+  cuvs::core::host_padded_dataset_view<float, int64_t> new_vectors,
   std::optional<raft::host_vector_view<const uint32_t, int64_t>> new_indices);
 
 /// \ingroup mg_cpp_index_extend
@@ -3758,7 +3758,7 @@ void extend(
 void extend(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_standard_index<float, uint32_t>, float, uint32_t>& index,
-  cuvs::neighbors::host_standard_dataset_view<float, int64_t> new_vectors,
+  cuvs::core::host_standard_dataset_view<float, int64_t> new_vectors,
   std::optional<raft::host_vector_view<const uint32_t, int64_t>> new_indices);
 
 /// \ingroup mg_cpp_index_extend
@@ -3783,14 +3783,14 @@ void extend(
 void extend(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_padded_index<half, uint32_t>, half, uint32_t>& index,
-  cuvs::neighbors::host_padded_dataset_view<half, int64_t> new_vectors,
+  cuvs::core::host_padded_dataset_view<half, int64_t> new_vectors,
   std::optional<raft::host_vector_view<const uint32_t, int64_t>> new_indices);
 
 /** @copydoc extend */
 void extend(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_standard_index<half, uint32_t>, half, uint32_t>& index,
-  cuvs::neighbors::host_standard_dataset_view<half, int64_t> new_vectors,
+  cuvs::core::host_standard_dataset_view<half, int64_t> new_vectors,
   std::optional<raft::host_vector_view<const uint32_t, int64_t>> new_indices);
 
 /// \ingroup mg_cpp_index_extend
@@ -3815,7 +3815,7 @@ void extend(
 void extend(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_padded_index<int8_t, uint32_t>, int8_t, uint32_t>& index,
-  cuvs::neighbors::host_padded_dataset_view<int8_t, int64_t> new_vectors,
+  cuvs::core::host_padded_dataset_view<int8_t, int64_t> new_vectors,
   std::optional<raft::host_vector_view<const uint32_t, int64_t>> new_indices);
 
 /** @copydoc extend */
@@ -3823,7 +3823,7 @@ void extend(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_standard_index<int8_t, uint32_t>, int8_t, uint32_t>&
     index,
-  cuvs::neighbors::host_standard_dataset_view<int8_t, int64_t> new_vectors,
+  cuvs::core::host_standard_dataset_view<int8_t, int64_t> new_vectors,
   std::optional<raft::host_vector_view<const uint32_t, int64_t>> new_indices);
 
 /// \ingroup mg_cpp_index_extend
@@ -3849,7 +3849,7 @@ void extend(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_padded_index<uint8_t, uint32_t>, uint8_t, uint32_t>&
     index,
-  cuvs::neighbors::host_padded_dataset_view<uint8_t, int64_t> new_vectors,
+  cuvs::core::host_padded_dataset_view<uint8_t, int64_t> new_vectors,
   std::optional<raft::host_vector_view<const uint32_t, int64_t>> new_indices);
 
 /** @copydoc extend */
@@ -3857,7 +3857,7 @@ void extend(
   const raft::resources& clique,
   cuvs::neighbors::mg_index<cagra::device_standard_index<uint8_t, uint32_t>, uint8_t, uint32_t>&
     index,
-  cuvs::neighbors::host_standard_dataset_view<uint8_t, int64_t> new_vectors,
+  cuvs::core::host_standard_dataset_view<uint8_t, int64_t> new_vectors,
   std::optional<raft::host_vector_view<const uint32_t, int64_t>> new_indices);
 
 /// \defgroup mg_cpp_index_search ANN MG index search
@@ -4407,7 +4407,7 @@ void distribute(const raft::resources& clique,
  *   auto optimized_graph = raft::make_host_matrix<uint32_t, int64_t>(dataset.extent(0), 64);
  *   cagra::helpers::optimize(res, knn_graph.view(), optimized_graph.view());
  *   // Construct an index from dataset and optimized knn_graph
- *   auto dataset_view = make_host_standard_dataset_view(dataset);
+ *   auto dataset_view = cuvs::core::make_host_standard_dataset_view(dataset);
  *   auto index = cagra::host_standard_index<float, uint32_t>(
  *     res, metric, dataset_view, raft::make_const_mdspan(optimized_graph.view()));
  * @endcode
@@ -4448,7 +4448,7 @@ void build_knn_graph(raft::resources const& res,
  *   auto optimized_graph = raft::make_host_matrix<uint32_t, int64_t>(dataset.extent(0), 64);
  *   cagra::helpers::optimize(res, knn_graph.view(), optimized_graph.view());
  *   // Construct an index from dataset and optimized knn_graph
- *   auto dataset_view = make_host_standard_dataset_view(dataset);
+ *   auto dataset_view = cuvs::core::make_host_standard_dataset_view(dataset);
  *   auto index = cagra::host_standard_index<half, uint32_t>(
  *     res, metric, dataset_view, raft::make_const_mdspan(optimized_graph.view()));
  * @endcode
@@ -4489,7 +4489,7 @@ void build_knn_graph(raft::resources const& res,
  *   auto optimized_graph = raft::make_host_matrix<uint32_t, int64_t>(dataset.extent(0), 64);
  *   cagra::helpers::optimize(res, knn_graph.view(), optimized_graph.view());
  *   // Construct an index from dataset and optimized knn_graph
- *   auto dataset_view = make_host_standard_dataset_view(dataset);
+ *   auto dataset_view = cuvs::core::make_host_standard_dataset_view(dataset);
  *   auto index = cagra::host_standard_index<int8_t, uint32_t>(
  *     res, metric, dataset_view, raft::make_const_mdspan(optimized_graph.view()));
  * @endcode
@@ -4530,7 +4530,7 @@ void build_knn_graph(raft::resources const& res,
  *   auto optimized_graph = raft::make_host_matrix<uint32_t, int64_t>(dataset.extent(0), 64);
  *   cagra::helpers::optimize(res, knn_graph.view(), optimized_graph.view());
  *   // Construct an index from dataset and optimized knn_graph
- *   auto dataset_view = make_host_standard_dataset_view(dataset);
+ *   auto dataset_view = cuvs::core::make_host_standard_dataset_view(dataset);
  *   auto index = cagra::host_standard_index<uint8_t, uint32_t>(
  *     res, metric, dataset_view, raft::make_const_mdspan(optimized_graph.view()));
  * @endcode
@@ -4555,8 +4555,8 @@ namespace detail {
 struct fd_transfer {
   template <typename T,
             typename IdxT,
-            cuvs::neighbors::ann_dataset_view SrcDatasetViewT,
-            cuvs::neighbors::ann_dataset_view DstDatasetViewT>
+            cuvs::core::ann_dataset_view SrcDatasetViewT,
+            cuvs::core::ann_dataset_view DstDatasetViewT>
   static inline void steal_disk_fds_to(raft::resources const& res,
                                        index<T, IdxT, SrcDatasetViewT>& src,
                                        index<T, IdxT, DstDatasetViewT>& dst)
@@ -4587,16 +4587,15 @@ struct fd_transfer {
 template <typename T, typename IdxT>
 auto convert_standard_to_padded_index(
   raft::resources const& res,
-  index<T, IdxT, cuvs::neighbors::device_standard_dataset_view<T, int64_t>> const& standard_idx,
-  cuvs::neighbors::device_padded_dataset_view<T, int64_t> const& padded_dataset)
+  index<T, IdxT, cuvs::core::device_standard_dataset_view<T, int64_t>> const& standard_idx,
+  cuvs::core::device_padded_dataset_view<T, int64_t> const& padded_dataset)
   -> device_padded_index<T, IdxT>
 {
   RAFT_EXPECTS(padded_dataset.n_rows() == standard_idx.size(),
                "Padded dataset row count must match the index size");
 
   using GraphIndexType =
-    typename index<T, IdxT, cuvs::neighbors::device_standard_dataset_view<T, int64_t>>::
-      graph_index_type;
+    typename index<T, IdxT, cuvs::core::device_standard_dataset_view<T, int64_t>>::graph_index_type;
   auto graph_host = raft::make_host_matrix<GraphIndexType, int64_t>(standard_idx.graph().extent(0),
                                                                     standard_idx.graph().extent(1));
   if (standard_idx.graph().size() > 0) {
@@ -4616,146 +4615,153 @@ auto convert_standard_to_padded_index(
 
 auto update_dataset(
   raft::resources const& res,
-  index<float, uint32_t, host_standard_dataset_view<float, int64_t>>&& cagra_index,
-  device_padded_dataset_view<float, int64_t> dataset)
-  -> index<float, uint32_t, device_padded_dataset_view<float, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<half, uint32_t, host_standard_dataset_view<half, int64_t>>&& cagra_index,
-                    device_padded_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_padded_dataset_view<half, int64_t>>;
+  index<float, uint32_t, cuvs::core::host_standard_dataset_view<float, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<float, int64_t> dataset)
+  -> index<float, uint32_t, cuvs::core::device_padded_dataset_view<float, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<half, uint32_t, cuvs::core::host_standard_dataset_view<half, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<half, int64_t> dataset)
+  -> index<half, uint32_t, cuvs::core::device_padded_dataset_view<half, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<int8_t, uint32_t, cuvs::core::host_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<int8_t, int64_t> dataset)
+  -> index<int8_t, uint32_t, cuvs::core::device_padded_dataset_view<int8_t, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<uint8_t, uint32_t, cuvs::core::host_standard_dataset_view<uint8_t, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<uint8_t, int64_t> dataset)
+  -> index<uint8_t, uint32_t, cuvs::core::device_padded_dataset_view<uint8_t, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<float, uint32_t, cuvs::core::host_standard_dataset_view<float, int64_t>>&& cagra_index,
+  cuvs::core::device_standard_dataset_view<float, int64_t> dataset)
+  -> index<float, uint32_t, cuvs::core::device_standard_dataset_view<float, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<int8_t, uint32_t, host_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
-  device_padded_dataset_view<int8_t, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_padded_dataset_view<int8_t, int64_t>>;
+  index<half, uint32_t, cuvs::core::host_standard_dataset_view<half, int64_t>>&& cagra_index,
+  cuvs::core::device_standard_dataset_view<half, int64_t> dataset)
+  -> index<half, uint32_t, cuvs::core::device_standard_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<uint8_t, uint32_t, host_standard_dataset_view<uint8_t, int64_t>>&& cagra_index,
-  device_padded_dataset_view<uint8_t, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_padded_dataset_view<uint8_t, int64_t>>;
+  index<int8_t, uint32_t, cuvs::core::host_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
+  cuvs::core::device_standard_dataset_view<int8_t, int64_t> dataset)
+  -> index<int8_t, uint32_t, cuvs::core::device_standard_dataset_view<int8_t, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<float, uint32_t, host_standard_dataset_view<float, int64_t>>&& cagra_index,
-  device_standard_dataset_view<float, int64_t> dataset)
-  -> index<float, uint32_t, device_standard_dataset_view<float, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<half, uint32_t, host_standard_dataset_view<half, int64_t>>&& cagra_index,
-                    device_standard_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_standard_dataset_view<half, int64_t>>;
+  index<uint8_t, uint32_t, cuvs::core::host_standard_dataset_view<uint8_t, int64_t>>&& cagra_index,
+  cuvs::core::device_standard_dataset_view<uint8_t, int64_t> dataset)
+  -> index<uint8_t, uint32_t, cuvs::core::device_standard_dataset_view<uint8_t, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<int8_t, uint32_t, host_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
-  device_standard_dataset_view<int8_t, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_standard_dataset_view<int8_t, int64_t>>;
+  index<float, uint32_t, cuvs::core::host_padded_dataset_view<float, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<float, int64_t> dataset)
+  -> index<float, uint32_t, cuvs::core::device_padded_dataset_view<float, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<uint8_t, uint32_t, host_standard_dataset_view<uint8_t, int64_t>>&& cagra_index,
-  device_standard_dataset_view<uint8_t, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_standard_dataset_view<uint8_t, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<float, uint32_t, host_padded_dataset_view<float, int64_t>>&& cagra_index,
-                    device_padded_dataset_view<float, int64_t> dataset)
-  -> index<float, uint32_t, device_padded_dataset_view<float, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<half, uint32_t, host_padded_dataset_view<half, int64_t>>&& cagra_index,
-                    device_padded_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_padded_dataset_view<half, int64_t>>;
+  index<half, uint32_t, cuvs::core::host_padded_dataset_view<half, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<half, int64_t> dataset)
+  -> index<half, uint32_t, cuvs::core::device_padded_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<int8_t, uint32_t, host_padded_dataset_view<int8_t, int64_t>>&& cagra_index,
-  device_padded_dataset_view<int8_t, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_padded_dataset_view<int8_t, int64_t>>;
+  index<int8_t, uint32_t, cuvs::core::host_padded_dataset_view<int8_t, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<int8_t, int64_t> dataset)
+  -> index<int8_t, uint32_t, cuvs::core::device_padded_dataset_view<int8_t, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<uint8_t, uint32_t, host_padded_dataset_view<uint8_t, int64_t>>&& cagra_index,
-  device_padded_dataset_view<uint8_t, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_padded_dataset_view<uint8_t, int64_t>>;
+  index<uint8_t, uint32_t, cuvs::core::host_padded_dataset_view<uint8_t, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<uint8_t, int64_t> dataset)
+  -> index<uint8_t, uint32_t, cuvs::core::device_padded_dataset_view<uint8_t, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<float, uint32_t, device_standard_dataset_view<float, int64_t>>&& cagra_index,
-  device_padded_dataset_view<float, int64_t> dataset)
-  -> index<float, uint32_t, device_padded_dataset_view<float, int64_t>>;
+  index<float, uint32_t, cuvs::core::device_standard_dataset_view<float, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<float, int64_t> dataset)
+  -> index<float, uint32_t, cuvs::core::device_padded_dataset_view<float, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<half, uint32_t, device_standard_dataset_view<half, int64_t>>&& cagra_index,
-  device_padded_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_padded_dataset_view<half, int64_t>>;
+  index<half, uint32_t, cuvs::core::device_standard_dataset_view<half, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<half, int64_t> dataset)
+  -> index<half, uint32_t, cuvs::core::device_padded_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<int8_t, uint32_t, device_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
-  device_padded_dataset_view<int8_t, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_padded_dataset_view<int8_t, int64_t>>;
+  index<int8_t, uint32_t, cuvs::core::device_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<int8_t, int64_t> dataset)
+  -> index<int8_t, uint32_t, cuvs::core::device_padded_dataset_view<int8_t, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<uint8_t, uint32_t, device_standard_dataset_view<uint8_t, int64_t>>&& cagra_index,
-  device_padded_dataset_view<uint8_t, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_padded_dataset_view<uint8_t, int64_t>>;
+  index<uint8_t, uint32_t, cuvs::core::device_standard_dataset_view<uint8_t, int64_t>>&&
+    cagra_index,
+  cuvs::core::device_padded_dataset_view<uint8_t, int64_t> dataset)
+  -> index<uint8_t, uint32_t, cuvs::core::device_padded_dataset_view<uint8_t, int64_t>>;
 
 auto update_dataset(
   raft::resources const& res,
-  index<float, uint32_t, device_standard_dataset_view<float, int64_t>>&& cagra_index,
-  device_standard_dataset_view<float, int64_t> dataset)
-  -> index<float, uint32_t, device_standard_dataset_view<float, int64_t>>;
+  index<float, uint32_t, cuvs::core::device_standard_dataset_view<float, int64_t>>&& cagra_index,
+  cuvs::core::device_standard_dataset_view<float, int64_t> dataset)
+  -> index<float, uint32_t, cuvs::core::device_standard_dataset_view<float, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<half, uint32_t, device_standard_dataset_view<half, int64_t>>&& cagra_index,
-  device_standard_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_standard_dataset_view<half, int64_t>>;
+  index<half, uint32_t, cuvs::core::device_standard_dataset_view<half, int64_t>>&& cagra_index,
+  cuvs::core::device_standard_dataset_view<half, int64_t> dataset)
+  -> index<half, uint32_t, cuvs::core::device_standard_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<int8_t, uint32_t, device_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
-  device_standard_dataset_view<int8_t, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_standard_dataset_view<int8_t, int64_t>>;
+  index<int8_t, uint32_t, cuvs::core::device_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
+  cuvs::core::device_standard_dataset_view<int8_t, int64_t> dataset)
+  -> index<int8_t, uint32_t, cuvs::core::device_standard_dataset_view<int8_t, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<uint8_t, uint32_t, device_standard_dataset_view<uint8_t, int64_t>>&& cagra_index,
-  device_standard_dataset_view<uint8_t, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_standard_dataset_view<uint8_t, int64_t>>;
+  index<uint8_t, uint32_t, cuvs::core::device_standard_dataset_view<uint8_t, int64_t>>&&
+    cagra_index,
+  cuvs::core::device_standard_dataset_view<uint8_t, int64_t> dataset)
+  -> index<uint8_t, uint32_t, cuvs::core::device_standard_dataset_view<uint8_t, int64_t>>;
 
 auto update_dataset(
   raft::resources const& res,
-  index<float, uint32_t, device_padded_dataset_view<float, int64_t>>&& cagra_index,
-  device_padded_dataset_view<float, int64_t> dataset)
-  -> index<float, uint32_t, device_padded_dataset_view<float, int64_t>>;
-auto update_dataset(raft::resources const& res,
-                    index<half, uint32_t, device_padded_dataset_view<half, int64_t>>&& cagra_index,
-                    device_padded_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_padded_dataset_view<half, int64_t>>;
+  index<float, uint32_t, cuvs::core::device_padded_dataset_view<float, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<float, int64_t> dataset)
+  -> index<float, uint32_t, cuvs::core::device_padded_dataset_view<float, int64_t>>;
+auto update_dataset(
+  raft::resources const& res,
+  index<half, uint32_t, cuvs::core::device_padded_dataset_view<half, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<half, int64_t> dataset)
+  -> index<half, uint32_t, cuvs::core::device_padded_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<int8_t, uint32_t, device_padded_dataset_view<int8_t, int64_t>>&& cagra_index,
-  device_padded_dataset_view<int8_t, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_padded_dataset_view<int8_t, int64_t>>;
+  index<int8_t, uint32_t, cuvs::core::device_padded_dataset_view<int8_t, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<int8_t, int64_t> dataset)
+  -> index<int8_t, uint32_t, cuvs::core::device_padded_dataset_view<int8_t, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<uint8_t, uint32_t, device_padded_dataset_view<uint8_t, int64_t>>&& cagra_index,
-  device_padded_dataset_view<uint8_t, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_padded_dataset_view<uint8_t, int64_t>>;
+  index<uint8_t, uint32_t, cuvs::core::device_padded_dataset_view<uint8_t, int64_t>>&& cagra_index,
+  cuvs::core::device_padded_dataset_view<uint8_t, int64_t> dataset)
+  -> index<uint8_t, uint32_t, cuvs::core::device_padded_dataset_view<uint8_t, int64_t>>;
 
 auto update_dataset(
   raft::resources const& res,
-  index<float, uint32_t, host_standard_dataset_view<float, int64_t>>&& cagra_index,
+  index<float, uint32_t, cuvs::core::host_standard_dataset_view<float, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<float,
            uint32_t,
            cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<half, uint32_t, host_standard_dataset_view<half, int64_t>>&& cagra_index,
+  index<half, uint32_t, cuvs::core::host_standard_dataset_view<half, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<half,
            uint32_t,
            cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<int8_t, uint32_t, host_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
+  index<int8_t, uint32_t, cuvs::core::host_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<int8_t,
            uint32_t,
            cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<uint8_t, uint32_t, host_standard_dataset_view<uint8_t, int64_t>>&& cagra_index,
+  index<uint8_t, uint32_t, cuvs::core::host_standard_dataset_view<uint8_t, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<uint8_t,
            uint32_t,
@@ -4763,28 +4769,28 @@ auto update_dataset(
 
 auto update_dataset(
   raft::resources const& res,
-  index<float, uint32_t, host_padded_dataset_view<float, int64_t>>&& cagra_index,
+  index<float, uint32_t, cuvs::core::host_padded_dataset_view<float, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<float,
            uint32_t,
            cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<half, uint32_t, host_padded_dataset_view<half, int64_t>>&& cagra_index,
+  index<half, uint32_t, cuvs::core::host_padded_dataset_view<half, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<half,
            uint32_t,
            cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<int8_t, uint32_t, host_padded_dataset_view<int8_t, int64_t>>&& cagra_index,
+  index<int8_t, uint32_t, cuvs::core::host_padded_dataset_view<int8_t, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<int8_t,
            uint32_t,
            cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<uint8_t, uint32_t, host_padded_dataset_view<uint8_t, int64_t>>&& cagra_index,
+  index<uint8_t, uint32_t, cuvs::core::host_padded_dataset_view<uint8_t, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<uint8_t,
            uint32_t,
@@ -4792,28 +4798,29 @@ auto update_dataset(
 
 auto update_dataset(
   raft::resources const& res,
-  index<float, uint32_t, device_standard_dataset_view<float, int64_t>>&& cagra_index,
+  index<float, uint32_t, cuvs::core::device_standard_dataset_view<float, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<float,
            uint32_t,
            cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<half, uint32_t, device_standard_dataset_view<half, int64_t>>&& cagra_index,
+  index<half, uint32_t, cuvs::core::device_standard_dataset_view<half, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<half,
            uint32_t,
            cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<int8_t, uint32_t, device_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
+  index<int8_t, uint32_t, cuvs::core::device_standard_dataset_view<int8_t, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<int8_t,
            uint32_t,
            cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<uint8_t, uint32_t, device_standard_dataset_view<uint8_t, int64_t>>&& cagra_index,
+  index<uint8_t, uint32_t, cuvs::core::device_standard_dataset_view<uint8_t, int64_t>>&&
+    cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<uint8_t,
            uint32_t,
@@ -4821,28 +4828,28 @@ auto update_dataset(
 
 auto update_dataset(
   raft::resources const& res,
-  index<float, uint32_t, device_padded_dataset_view<float, int64_t>>&& cagra_index,
+  index<float, uint32_t, cuvs::core::device_padded_dataset_view<float, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<float,
            uint32_t,
            cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<half, uint32_t, device_padded_dataset_view<half, int64_t>>&& cagra_index,
+  index<half, uint32_t, cuvs::core::device_padded_dataset_view<half, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<half,
            uint32_t,
            cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<int8_t, uint32_t, device_padded_dataset_view<int8_t, int64_t>>&& cagra_index,
+  index<int8_t, uint32_t, cuvs::core::device_padded_dataset_view<int8_t, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<int8_t,
            uint32_t,
            cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
-  index<uint8_t, uint32_t, device_padded_dataset_view<uint8_t, int64_t>>&& cagra_index,
+  index<uint8_t, uint32_t, cuvs::core::device_padded_dataset_view<uint8_t, int64_t>>&& cagra_index,
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t> dataset)
   -> index<uint8_t,
            uint32_t,
@@ -4853,28 +4860,28 @@ auto update_dataset(
   index<float,
         uint32_t,
         cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>&& cagra_index,
-  device_padded_dataset_view<float, int64_t> dataset)
-  -> index<float, uint32_t, device_padded_dataset_view<float, int64_t>>;
+  cuvs::core::device_padded_dataset_view<float, int64_t> dataset)
+  -> index<float, uint32_t, cuvs::core::device_padded_dataset_view<float, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
   index<half, uint32_t, cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>&&
     cagra_index,
-  device_padded_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_padded_dataset_view<half, int64_t>>;
+  cuvs::core::device_padded_dataset_view<half, int64_t> dataset)
+  -> index<half, uint32_t, cuvs::core::device_padded_dataset_view<half, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
   index<int8_t,
         uint32_t,
         cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>&& cagra_index,
-  device_padded_dataset_view<int8_t, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_padded_dataset_view<int8_t, int64_t>>;
+  cuvs::core::device_padded_dataset_view<int8_t, int64_t> dataset)
+  -> index<int8_t, uint32_t, cuvs::core::device_padded_dataset_view<int8_t, int64_t>>;
 auto update_dataset(
   raft::resources const& res,
   index<uint8_t,
         uint32_t,
         cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>>&& cagra_index,
-  device_padded_dataset_view<uint8_t, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_padded_dataset_view<uint8_t, int64_t>>;
+  cuvs::core::device_padded_dataset_view<uint8_t, int64_t> dataset)
+  -> index<uint8_t, uint32_t, cuvs::core::device_padded_dataset_view<uint8_t, int64_t>>;
 
 auto update_dataset(
   raft::resources const& res,
@@ -4917,24 +4924,24 @@ auto update_dataset(
   index<float,
         uint32_t,
         cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<float, int64_t>>&& cagra_index,
-  device_padded_dataset_view<float, int64_t> dataset)
-  -> index<float, uint32_t, device_padded_dataset_view<float, int64_t>>;
+  cuvs::core::device_padded_dataset_view<float, int64_t> dataset)
+  -> index<float, uint32_t, cuvs::core::device_padded_dataset_view<float, int64_t>>;
 
 auto update_dataset(
   raft::resources const& res,
   index<half,
         uint32_t,
         cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<half, int64_t>>&& cagra_index,
-  device_padded_dataset_view<half, int64_t> dataset)
-  -> index<half, uint32_t, device_padded_dataset_view<half, int64_t>>;
+  cuvs::core::device_padded_dataset_view<half, int64_t> dataset)
+  -> index<half, uint32_t, cuvs::core::device_padded_dataset_view<half, int64_t>>;
 
 auto update_dataset(
   raft::resources const& res,
   index<int8_t,
         uint32_t,
         cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<int8_t, int64_t>>&& cagra_index,
-  device_padded_dataset_view<int8_t, int64_t> dataset)
-  -> index<int8_t, uint32_t, device_padded_dataset_view<int8_t, int64_t>>;
+  cuvs::core::device_padded_dataset_view<int8_t, int64_t> dataset)
+  -> index<int8_t, uint32_t, cuvs::core::device_padded_dataset_view<int8_t, int64_t>>;
 
 auto update_dataset(
   raft::resources const& res,
@@ -4942,8 +4949,8 @@ auto update_dataset(
         uint32_t,
         cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<uint8_t, int64_t>>&&
     cagra_index,
-  device_padded_dataset_view<uint8_t, int64_t> dataset)
-  -> index<uint8_t, uint32_t, device_padded_dataset_view<uint8_t, int64_t>>;
+  cuvs::core::device_padded_dataset_view<uint8_t, int64_t> dataset)
+  -> index<uint8_t, uint32_t, cuvs::core::device_padded_dataset_view<uint8_t, int64_t>>;
 
 auto update_dataset(
   raft::resources const& res,
diff --git a/cpp/include/cuvs/neighbors/common.hpp b/cpp/include/cuvs/neighbors/common.hpp
index 7d4acc234b..e17d67a7c6 100644
--- a/cpp/include/cuvs/neighbors/common.hpp
+++ b/cpp/include/cuvs/neighbors/common.hpp
@@ -642,10 +642,9 @@ struct iface {
   std::optional<AnnIndexType> index_;
   /** Used by CAGRA when deserializing an index that contains a dataset; keeps it alive for the
    * view. */
-  std::unique_ptr<cuvs::neighbors::device_padded_dataset<T, int64_t>> cagra_owned_padded_dataset_;
+  std::unique_ptr<cuvs::core::device_padded_dataset<T, int64_t>> cagra_owned_padded_dataset_;
   /** Used by CAGRA standard-layout paths to keep deserialized/attached dataset views alive. */
-  std::unique_ptr<cuvs::neighbors::device_standard_dataset<T, int64_t>>
-    cagra_owned_standard_dataset_;
+  std::unique_ptr<cuvs::core::device_standard_dataset<T, int64_t>> cagra_owned_standard_dataset_;
   std::shared_ptr<std::mutex> mutex_;
 };
 
diff --git a/cpp/include/cuvs/neighbors/tiered_index.hpp b/cpp/include/cuvs/neighbors/tiered_index.hpp
index 015e48c7e2..695e37d6e3 100644
--- a/cpp/include/cuvs/neighbors/tiered_index.hpp
+++ b/cpp/include/cuvs/neighbors/tiered_index.hpp
@@ -98,12 +98,12 @@ auto build(raft::resources const& res,
 auto convert_standard_to_padded_index(
   raft::resources const& res,
   const index<cagra::device_standard_index<float, uint32_t>>& idx,
-  cuvs::neighbors::device_padded_dataset_view<float, int64_t> padded_dataset)
+  cuvs::core::device_padded_dataset_view<float, int64_t> padded_dataset)
   -> index<cagra::device_padded_index<float, uint32_t>>;
 
 auto build(raft::resources const& res,
            const index_params<cagra::index_params>& index_params,
-           cuvs::neighbors::device_padded_dataset_view<float, int64_t> dataset)
+           cuvs::core::device_padded_dataset_view<float, int64_t> dataset)
   -> tiered_index::index<cagra::device_padded_index<float, uint32_t>>;
 
 /** @copydoc build */
diff --git a/cpp/include/cuvs/neighbors/vamana.hpp b/cpp/include/cuvs/neighbors/vamana.hpp
index 517e1f76e1..f80657c987 100644
--- a/cpp/include/cuvs/neighbors/vamana.hpp
+++ b/cpp/include/cuvs/neighbors/vamana.hpp
@@ -133,7 +133,7 @@ struct index : cuvs::neighbors::index {
   /** Non-owning dataset view stored by the index (full-precision vectors may live in
    * `full_precision_storage_`). */
   [[nodiscard]] inline auto data() const noexcept
-    -> const cuvs::neighbors::device_padded_dataset_view<T, int64_t>&
+    -> const cuvs::core::device_padded_dataset_view<T, int64_t>&
   {
     return dataset_.value();
   }
@@ -204,13 +204,13 @@ struct index : cuvs::neighbors::index {
         dataset.stride(0) > 0 ? static_cast<int64_t>(dataset.stride(0)) : dataset.extent(1);
       auto d_m = raft::make_device_matrix_view<const T, int64_t>(
         dataset.data_handle(), dataset.extent(0), row_stride);
-      use_padded_view = cuvs::neighbors::matrix_row_width_matches_cagra_required(d_m);
+      use_padded_view = cuvs::core::matrix_row_width_matches_cagra_required(d_m);
     }
 
     if (use_padded_view) {
-      dataset_ = cuvs::neighbors::make_device_padded_dataset_view(res, dataset);
+      dataset_ = cuvs::core::make_device_padded_dataset_view(res, dataset);
     } else {
-      full_precision_storage_ = cuvs::neighbors::make_device_padded_dataset(res, dataset);
+      full_precision_storage_ = cuvs::core::make_device_padded_dataset(res, dataset);
       dataset_                = full_precision_storage_->as_dataset_view();
     }
     update_graph(res, vamana_graph);
@@ -288,8 +288,8 @@ struct index : cuvs::neighbors::index {
   raft::device_matrix<IdxT, int64_t, raft::row_major> graph_;
   raft::device_matrix_view<const IdxT, int64_t, raft::row_major> graph_view_;
   /** Owns CAGRA-padded full-precision device storage for the index dataset view. */
-  std::unique_ptr<cuvs::neighbors::device_padded_dataset<T, int64_t>> full_precision_storage_;
-  std::optional<cuvs::neighbors::device_padded_dataset_view<T, int64_t>> dataset_;
+  std::unique_ptr<cuvs::core::device_padded_dataset<T, int64_t>> full_precision_storage_;
+  std::optional<cuvs::core::device_padded_dataset_view<T, int64_t>> dataset_;
   raft::device_matrix<uint8_t, int64_t, raft::row_major> quantized_dataset_;
   IdxT medoid_id_;
 };
diff --git a/cpp/include/cuvs/preprocessing/quantize/bbq.hpp b/cpp/include/cuvs/preprocessing/quantize/bbq.hpp
index db0b0c2a1f..45b6d50710 100644
--- a/cpp/include/cuvs/preprocessing/quantize/bbq.hpp
+++ b/cpp/include/cuvs/preprocessing/quantize/bbq.hpp
@@ -245,7 +245,7 @@ void resolve_dequant_factors(
 namespace preprocessing::quantize::bbq {
 
 // -----------------------------------------------------------------------------
-// BBQ dataset: a child of `cuvs::neighbors::dataset` / `dataset_view`. The quantizers and the
+// BBQ dataset: a child of `cuvs::core::dataset` / `dataset_view`. The quantizers and the
 // methods that manage them live in the payload types below; `dataset` itself knows nothing of them.
 // -----------------------------------------------------------------------------
 
@@ -378,16 +378,14 @@ struct bbq_dataset_spec {
 };
 
 template <typename DataT, typename IdxT>
-using device_bbq_dataset = cuvs::neighbors::
-  dataset<DataT, IdxT, bbq_dataset_spec<cuvs::neighbors::detail::device_owning_accessor<DataT>>>;
+using device_bbq_dataset = cuvs::core::
+  dataset<DataT, IdxT, bbq_dataset_spec<cuvs::core::detail::device_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
-using device_bbq_dataset_view = cuvs::neighbors::dataset_view<
-  DataT,
-  IdxT,
-  bbq_dataset_spec<cuvs::neighbors::detail::device_owning_accessor<DataT>>>;
+using device_bbq_dataset_view = cuvs::core::
+  dataset_view<DataT, IdxT, bbq_dataset_spec<cuvs::core::detail::device_owning_accessor<DataT>>>;
 
-/** Spec predicate for `cuvs::neighbors::dataset_view_has_spec_v`. */
+/** Spec predicate for `cuvs::core::dataset_view_has_spec_v`. */
 template <typename SpecT>
 struct is_bbq_spec : std::false_type {};
 template <typename Accessor>
@@ -400,7 +398,7 @@ template <typename DatasetT>
 struct is_bbq_dataset : std::false_type {};
 
 template <typename DataT, typename IdxT, typename SpecT>
-struct is_bbq_dataset<cuvs::neighbors::dataset<DataT, IdxT, SpecT>>
+struct is_bbq_dataset<cuvs::core::dataset<DataT, IdxT, SpecT>>
   : std::bool_constant<is_bbq_spec_v<SpecT>> {};
 
 template <typename DatasetT>
@@ -408,13 +406,13 @@ inline constexpr bool is_bbq_dataset_v = is_bbq_dataset<DatasetT>::value;
 
 template <typename V>
 inline constexpr bool is_device_bbq_dataset_view_v =
-  cuvs::neighbors::dataset_view_has_spec_v<V, is_bbq_spec> &&
-  cuvs::neighbors::dataset_view_is_device_accessible_v<V>;
+  cuvs::core::dataset_view_has_spec_v<V, is_bbq_spec> &&
+  cuvs::core::dataset_view_is_device_accessible_v<V>;
 
 template <typename V>
 inline constexpr bool is_host_bbq_dataset_view_v =
-  cuvs::neighbors::dataset_view_has_spec_v<V, is_bbq_spec> &&
-  !cuvs::neighbors::dataset_view_is_device_accessible_v<V>;
+  cuvs::core::dataset_view_has_spec_v<V, is_bbq_spec> &&
+  !cuvs::core::dataset_view_is_device_accessible_v<V>;
 
 template <typename V>
 inline constexpr bool is_bbq_dataset_view_v =
diff --git a/cpp/include/cuvs/preprocessing/quantize/pq.hpp b/cpp/include/cuvs/preprocessing/quantize/pq.hpp
index f23eaaade9..aac6def506 100644
--- a/cpp/include/cuvs/preprocessing/quantize/pq.hpp
+++ b/cpp/include/cuvs/preprocessing/quantize/pq.hpp
@@ -201,16 +201,16 @@ struct vpq_params {
 };
 
 // -----------------------------------------------------------------------------
-// VPQ dataset: a child of `cuvs::neighbors::dataset` / `dataset_view`. All VPQ-specific state
+// VPQ dataset: a child of `cuvs::core::dataset` / `dataset_view`. All VPQ-specific state
 // (codebooks) and methods live in the payload types below; `dataset` itself knows nothing of them.
 // -----------------------------------------------------------------------------
 
 namespace detail {
 
 // The accessor aliases are shared with every dataset kind and live next to `dataset`.
-using cuvs::neighbors::detail::dataset_view_accessor_for_owning;
-using cuvs::neighbors::detail::device_owning_accessor;
-using cuvs::neighbors::detail::host_owning_accessor;
+using cuvs::core::detail::dataset_view_accessor_for_owning;
+using cuvs::core::detail::device_owning_accessor;
+using cuvs::core::detail::host_owning_accessor;
 
 template <typename MathT, typename IdxT, typename Accessor>
 using vpq_vq_book_matrix =
@@ -367,22 +367,22 @@ struct vpq_dataset_spec {
 };
 
 template <typename DataT, typename IdxT>
-using device_vpq_dataset = cuvs::neighbors::
-  dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::device_owning_accessor<DataT>>>;
+using device_vpq_dataset =
+  cuvs::core::dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::device_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
-using device_vpq_dataset_view = cuvs::neighbors::
+using device_vpq_dataset_view = cuvs::core::
   dataset_view<DataT, IdxT, vpq_dataset_spec<DataT, detail::device_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
-using host_vpq_dataset = cuvs::neighbors::
-  dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::host_owning_accessor<DataT>>>;
+using host_vpq_dataset =
+  cuvs::core::dataset<DataT, IdxT, vpq_dataset_spec<DataT, detail::host_owning_accessor<DataT>>>;
 
 template <typename DataT, typename IdxT>
-using host_vpq_dataset_view = cuvs::neighbors::
+using host_vpq_dataset_view = cuvs::core::
   dataset_view<DataT, IdxT, vpq_dataset_spec<DataT, detail::host_owning_accessor<DataT>>>;
 
-/** Spec predicate for `cuvs::neighbors::dataset_view_has_spec_v`. */
+/** Spec predicate for `cuvs::core::dataset_view_has_spec_v`. */
 template <typename SpecT>
 struct is_vpq_spec : std::false_type {};
 template <typename MathT, typename Accessor>
@@ -403,7 +403,7 @@ using vpq_spec_math_type_t = typename vpq_spec_math_type<SpecT>::type;
 template <typename DatasetT>
 struct is_vpq_dataset : std::false_type {};
 template <typename T, typename IdxT, typename SpecT>
-struct is_vpq_dataset<cuvs::neighbors::dataset<T, IdxT, SpecT>>
+struct is_vpq_dataset<cuvs::core::dataset<T, IdxT, SpecT>>
   : std::bool_constant<is_vpq_spec_v<SpecT>> {};
 template <typename DatasetT>
 inline constexpr bool is_vpq_dataset_v = is_vpq_dataset<DatasetT>::value;
@@ -413,21 +413,19 @@ template <typename V, typename MathT>
 struct is_vpq_dataset_view_with_math : std::false_type {};
 template <typename T, typename IdxT, typename VpqMathT, typename Accessor, typename MathT>
 struct is_vpq_dataset_view_with_math<
-  cuvs::neighbors::dataset_view<T, IdxT, vpq_dataset_spec<VpqMathT, Accessor>>,
+  cuvs::core::dataset_view<T, IdxT, vpq_dataset_spec<VpqMathT, Accessor>>,
   MathT> : std::is_same<VpqMathT, MathT> {};
 template <typename V, typename MathT>
 inline constexpr bool is_vpq_dataset_view_with_math_v =
-  is_vpq_dataset_view_with_math<cuvs::neighbors::dataset_view_type_t<V>, MathT>::value;
+  is_vpq_dataset_view_with_math<cuvs::core::dataset_view_type_t<V>, MathT>::value;
 
 template <typename V>
 inline constexpr bool is_device_vpq_f16_dataset_view_v =
-  is_vpq_dataset_view_with_math_v<V, half> &&
-  cuvs::neighbors::dataset_view_is_device_accessible_v<V>;
+  is_vpq_dataset_view_with_math_v<V, half> && cuvs::core::dataset_view_is_device_accessible_v<V>;
 
 template <typename V>
 inline constexpr bool is_host_vpq_f16_dataset_view_v =
-  is_vpq_dataset_view_with_math_v<V, half> &&
-  !cuvs::neighbors::dataset_view_is_device_accessible_v<V>;
+  is_vpq_dataset_view_with_math_v<V, half> && !cuvs::core::dataset_view_is_device_accessible_v<V>;
 
 template <typename V>
 inline constexpr bool is_vpq_f16_dataset_view_v =
@@ -435,13 +433,11 @@ inline constexpr bool is_vpq_f16_dataset_view_v =
 
 template <typename V>
 inline constexpr bool is_device_vpq_f32_dataset_view_v =
-  is_vpq_dataset_view_with_math_v<V, float> &&
-  cuvs::neighbors::dataset_view_is_device_accessible_v<V>;
+  is_vpq_dataset_view_with_math_v<V, float> && cuvs::core::dataset_view_is_device_accessible_v<V>;
 
 template <typename V>
 inline constexpr bool is_host_vpq_f32_dataset_view_v =
-  is_vpq_dataset_view_with_math_v<V, float> &&
-  !cuvs::neighbors::dataset_view_is_device_accessible_v<V>;
+  is_vpq_dataset_view_with_math_v<V, float> && !cuvs::core::dataset_view_is_device_accessible_v<V>;
 
 template <typename V>
 inline constexpr bool is_vpq_f32_dataset_view_v =
@@ -591,7 +587,7 @@ namespace detail {
  * @brief Train VPQ storage (codebooks + encoded rows) from a row-major mdspan/mdarray/dataset.
  *
  * Accepts either a row-major mdspan with `value_type`, `extent`, `stride`, and `data_handle` (same
- * pattern as `cuvs::neighbors::make_device_padded_dataset`), or any cuVS dense dataset / dataset
+ * pattern as `cuvs::core::make_device_padded_dataset`), or any cuVS dense dataset / dataset
  * view exposing `view`, `dim` and `stride`, in which case the logical `dim()` is quantized and the
  * row padding is skipped. The rows may be device-accessible or host-resident. Device-accessible
  * rows (device, managed or pinned) with tight row-major storage (logical stride equals dimension)
diff --git a/cpp/src/neighbors/cagra.cuh b/cpp/src/neighbors/cagra.cuh
index bc070e0180..f04993e2f9 100644
--- a/cpp/src/neighbors/cagra.cuh
+++ b/cpp/src/neighbors/cagra.cuh
@@ -32,18 +32,17 @@
 
 namespace cuvs::neighbors::cagra {
 
-template <typename T, typename IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 CUVS_EXPORT void index<T, IdxT, DatasetViewT>::compute_dataset_norms_(raft::resources const& res)
 {
   // raft::linalg::reduce wants row-major with leading dim = row pitch in elements.
   // Skip norm precomputation for VPQ/empty/non-dense views; CosineExpanded with VPQ is handled
   // (or rejected) on the search path.
-  namespace nb    = cuvs::neighbors;
   bool skip_norms = false;
   std::optional<raft::device_matrix_view<const T, int64_t, raft::row_major>> rm_dataset;
 
-  if constexpr (nb::is_padded_dataset_view_v<DatasetViewT> ||
-                nb::is_standard_dataset_view_v<DatasetViewT>) {
+  if constexpr (cuvs::core::is_padded_dataset_view_v<DatasetViewT> ||
+                cuvs::core::is_standard_dataset_view_v<DatasetViewT>) {
     rm_dataset = dataset_.as_matrix_view();
   } else if constexpr (cuvs::preprocessing::quantize::pq::is_vpq_dataset_view_v<DatasetViewT> ||
                        cuvs::preprocessing::quantize::bbq::is_bbq_dataset_view_v<DatasetViewT>) {
@@ -106,7 +105,7 @@ CUVS_EXPORT void index<T, IdxT, DatasetViewT>::compute_dataset_norms_(raft::reso
  *   auto optimized_gaph = raft::make_host_matrix<IdxT, IdxT>(dataset.extent(0), 64);
  *   cagra::optimize(res, dataset, knn_graph.view(), optimized_graph.view());
  *   // Construct an index from dataset and optimized knn_graph
- *   auto index = cagra::index<T, IdxT, cuvs::neighbors::device_padded_dataset_view<T, int64_t>>(
+ *   auto index = cagra::index<T, IdxT, cuvs::core::device_padded_dataset_view<T, int64_t>>(
  *     res, build_params.metric(), dataset, optimized_graph.view());
  * @endcode
  *
@@ -210,7 +209,7 @@ void build_knn_graph(
  *   // optimize graph
  *   cagra::optimize(res, dataset, knn_graph.view(), optimized_graph.view());
  *   // Construct an index from dataset and optimized knn_graph
- *   auto index = cagra::index<T, IdxT, cuvs::neighbors::device_padded_dataset_view<T, int64_t>>(
+ *   auto index = cagra::index<T, IdxT, cuvs::core::device_padded_dataset_view<T, int64_t>>(
  *     res, build_params.metric(), dataset, optimized_graph.view());
  * @endcode
  *
@@ -293,9 +292,9 @@ void optimize(
  * device-padded dataset to get a search-ready device index.
  */
 template <typename DatasetViewT>
-  requires(!cuvs::neighbors::is_empty_dataset_view_v<DatasetViewT> &&
-           (cuvs::neighbors::is_device_dataset_view_v<DatasetViewT> ||
-            cuvs::neighbors::is_host_dataset_view_v<DatasetViewT>))
+  requires(!cuvs::core::is_empty_dataset_view_v<DatasetViewT> &&
+           (cuvs::core::is_device_dataset_view_v<DatasetViewT> ||
+            cuvs::core::is_host_dataset_view_v<DatasetViewT>))
 auto build(raft::resources const& res, const index_params& params, DatasetViewT const& dataset)
   -> cuvs::neighbors::cagra::cagra_index_t<DatasetViewT>
 {
@@ -340,7 +339,7 @@ auto build(raft::resources const& res, const index_params& params, DatasetViewT
       idx = cuvs::neighbors::cagra::update_dataset(res, std::move(idx), dataset);
     }
     return idx;
-  } else if constexpr (cuvs::neighbors::is_dense_row_major_device_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::core::is_dense_row_major_device_dataset_view_v<DatasetViewT>) {
     auto idx = cuvs::neighbors::cagra::detail::build_from_device_matrix<T, IdxT, DatasetViewT>(
       res, params, dataset);
     if (params.attach_dataset_on_build) {
@@ -399,7 +398,7 @@ template <typename T,
           typename IdxT,
           typename CagraSampleFilterT,
           typename OutputIdxT,
-          cuvs::neighbors::ann_dataset_view DatasetViewT>
+          cuvs::core::ann_dataset_view DatasetViewT>
 void search_with_filtering(raft::resources const& res,
                            const search_params& params,
                            const index<T, IdxT, DatasetViewT>& idx,
@@ -421,10 +420,7 @@ void search_with_filtering(raft::resources const& res,
     res, params, idx, queries, neighbors, distances, sample_filter);
 }
 
-template <typename T,
-          typename IdxT,
-          cuvs::neighbors::ann_dataset_view DatasetViewT,
-          typename OutputIdxT>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT, typename OutputIdxT>
 void search(raft::resources const& res,
             const search_params& params,
             const index<T, IdxT, DatasetViewT>& idx,
@@ -520,19 +516,19 @@ void search(raft::resources const& res,
   }
 }
 
-template <class T, class IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 void extend(raft::resources const& handle,
             const cagra::extend_params& params,
-            cuvs::neighbors::device_padded_dataset_view<T, int64_t> extended_dataset,
+            cuvs::core::device_padded_dataset_view<T, int64_t> extended_dataset,
             int64_t new_start_row,
             cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>& index)
 {
-  static_assert(cuvs::neighbors::is_padded_dataset_view_v<DatasetViewT>,
+  static_assert(cuvs::core::is_padded_dataset_view_v<DatasetViewT>,
                 "cagra::extend requires a padded index dataset type");
   extend_core<T, IdxT, DatasetViewT>(handle, index, params, extended_dataset, new_start_row);
 }
 
-template <class T, class IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge(
   raft::resources const& handle,
   const cagra::index_params& params,
@@ -544,7 +540,7 @@ cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge(
     handle, params, indices, merged_dataset, row_filter);
 }
 
-template <class T, class IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge(
   raft::resources const& handle,
   const cagra::index_params& params,
@@ -623,8 +619,8 @@ void search(
 
 template <typename T,
           typename IdxT,
-          ann_dataset_view SrcDatasetViewT,
-          ann_dataset_view DstDatasetViewT>
+          cuvs::core::ann_dataset_view SrcDatasetViewT,
+          cuvs::core::ann_dataset_view DstDatasetViewT>
 auto update_dataset(raft::resources const& res,
                     index<T, IdxT, SrcDatasetViewT>&& cagra_index,
                     DstDatasetViewT dataset) -> index<T, IdxT, DstDatasetViewT>
diff --git a/cpp/src/neighbors/cagra_build_inst.cu.in b/cpp/src/neighbors/cagra_build_inst.cu.in
index c2d01f2570..8145c62def 100644
--- a/cpp/src/neighbors/cagra_build_inst.cu.in
+++ b/cpp/src/neighbors/cagra_build_inst.cu.in
@@ -15,10 +15,10 @@ namespace {
 
 using data_t                      = @data_type@;
 using index_t                     = @index_type@;
-using inst_device_padded_view_t   = cuvs::neighbors::device_padded_dataset_view<data_t, int64_t>;
-using inst_device_standard_view_t = cuvs::neighbors::device_standard_dataset_view<data_t, int64_t>;
-using inst_host_padded_view_t     = cuvs::neighbors::host_padded_dataset_view<data_t, int64_t>;
-using inst_host_standard_view_t   = cuvs::neighbors::host_standard_dataset_view<data_t, int64_t>;
+using inst_device_padded_view_t   = cuvs::core::device_padded_dataset_view<data_t, int64_t>;
+using inst_device_standard_view_t = cuvs::core::device_standard_dataset_view<data_t, int64_t>;
+using inst_host_padded_view_t     = cuvs::core::host_padded_dataset_view<data_t, int64_t>;
+using inst_host_standard_view_t   = cuvs::core::host_standard_dataset_view<data_t, int64_t>;
 using inst_vpq_view_t = cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>;
 using inst_bbq_view_t =
   cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<data_t, int64_t>;
diff --git a/cpp/src/neighbors/cagra_extend_inst.cu.in b/cpp/src/neighbors/cagra_extend_inst.cu.in
index 6f45fe1fd3..b9573a0f91 100644
--- a/cpp/src/neighbors/cagra_extend_inst.cu.in
+++ b/cpp/src/neighbors/cagra_extend_inst.cu.in
@@ -10,7 +10,7 @@ namespace {
 
 using data_t                    = @data_type@;
 using index_t                   = @index_type@;
-using inst_device_padded_view_t = cuvs::neighbors::device_padded_dataset_view<data_t, int64_t>;
+using inst_device_padded_view_t = cuvs::core::device_padded_dataset_view<data_t, int64_t>;
 
 }  // namespace
 
@@ -19,15 +19,15 @@ namespace cuvs::neighbors::cagra {
 extern template void index<data_t, index_t, inst_device_padded_view_t>::compute_dataset_norms_(
   raft::resources const&);
 
-#define CUVS_INST_CAGRA_EXTEND(T, IdxT, DatasetViewT)                                   \
-  void extend(raft::resources const& handle,                                            \
-              const cuvs::neighbors::cagra::extend_params& params,                      \
-              cuvs::neighbors::device_padded_dataset_view<T, int64_t> extended_dataset, \
-              int64_t new_start_row,                                                    \
-              cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>& index)              \
-  {                                                                                     \
-    cuvs::neighbors::cagra::extend<T, IdxT, DatasetViewT>(                              \
-      handle, params, extended_dataset, new_start_row, index);                          \
+#define CUVS_INST_CAGRA_EXTEND(T, IdxT, DatasetViewT)                              \
+  void extend(raft::resources const& handle,                                       \
+              const cuvs::neighbors::cagra::extend_params& params,                 \
+              cuvs::core::device_padded_dataset_view<T, int64_t> extended_dataset, \
+              int64_t new_start_row,                                               \
+              cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>& index)         \
+  {                                                                                \
+    cuvs::neighbors::cagra::extend<T, IdxT, DatasetViewT>(                         \
+      handle, params, extended_dataset, new_start_row, index);                     \
   }
 
 CUVS_INST_CAGRA_EXTEND(data_t, index_t, inst_device_padded_view_t);
diff --git a/cpp/src/neighbors/cagra_merge_inst.cu.in b/cpp/src/neighbors/cagra_merge_inst.cu.in
index da95e279b6..4ed7fe078f 100644
--- a/cpp/src/neighbors/cagra_merge_inst.cu.in
+++ b/cpp/src/neighbors/cagra_merge_inst.cu.in
@@ -12,13 +12,13 @@ namespace {
 
 using data_t                    = @data_type@;
 using index_t                   = @index_type@;
-using inst_device_padded_view_t = cuvs::neighbors::device_padded_dataset_view<data_t, int64_t>;
+using inst_device_padded_view_t = cuvs::core::device_padded_dataset_view<data_t, int64_t>;
 
 }  // namespace
 
 namespace cuvs::neighbors::cagra {
 
-using inst_device_standard_view_t = cuvs::neighbors::device_standard_dataset_view<data_t, int64_t>;
+using inst_device_standard_view_t = cuvs::core::device_standard_dataset_view<data_t, int64_t>;
 
 extern template void index<data_t, index_t, inst_device_padded_view_t>::compute_dataset_norms_(
   raft::resources const&);
diff --git a/cpp/src/neighbors/cagra_search_inst.cu.in b/cpp/src/neighbors/cagra_search_inst.cu.in
index 2070a1f29a..4e91a50a8d 100644
--- a/cpp/src/neighbors/cagra_search_inst.cu.in
+++ b/cpp/src/neighbors/cagra_search_inst.cu.in
@@ -10,13 +10,13 @@
 namespace {
 
 using data_t                      = @data_type@;
-using inst_device_padded_view_t   = cuvs::neighbors::device_padded_dataset_view<data_t, int64_t>;
-using inst_device_standard_view_t = cuvs::neighbors::device_standard_dataset_view<data_t, int64_t>;
+using inst_device_padded_view_t   = cuvs::core::device_padded_dataset_view<data_t, int64_t>;
+using inst_device_standard_view_t = cuvs::core::device_standard_dataset_view<data_t, int64_t>;
 using inst_vpq_f16_view_t =
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>;
 using inst_bbq_view_t =
   cuvs::preprocessing::quantize::bbq::device_bbq_dataset_view<data_t, int64_t>;
-using inst_empty_view_t = cuvs::neighbors::device_empty_dataset_view<int64_t>;
+using inst_empty_view_t = cuvs::core::device_empty_dataset_view<int64_t>;
 
 }  // namespace
 
diff --git a/cpp/src/neighbors/cagra_serialize.cuh b/cpp/src/neighbors/cagra_serialize.cuh
index 18e807b90f..284cc2bb5f 100644
--- a/cpp/src/neighbors/cagra_serialize.cuh
+++ b/cpp/src/neighbors/cagra_serialize.cuh
@@ -23,7 +23,7 @@ namespace cuvs::neighbors::cagra {
     raft::resources const& handle,                                                                \
     const std::string& filename,                                                                  \
     cuvs::neighbors::cagra::device_padded_index<DTYPE, uint32_t>* index,                          \
-    std::unique_ptr<cuvs::neighbors::device_padded_dataset<DTYPE, int64_t>>* out_dataset)         \
+    std::unique_ptr<cuvs::core::device_padded_dataset<DTYPE, int64_t>>* out_dataset)              \
   {                                                                                               \
     cuvs::neighbors::cagra::detail::deserialize<DTYPE, uint32_t>(                                 \
       handle, filename, index, out_dataset);                                                      \
@@ -41,7 +41,7 @@ namespace cuvs::neighbors::cagra {
     raft::resources const& handle,                                                                \
     std::istream& is,                                                                             \
     cuvs::neighbors::cagra::device_padded_index<DTYPE, uint32_t>* index,                          \
-    std::unique_ptr<cuvs::neighbors::device_padded_dataset<DTYPE, int64_t>>* out_dataset)         \
+    std::unique_ptr<cuvs::core::device_padded_dataset<DTYPE, int64_t>>* out_dataset)              \
   {                                                                                               \
     cuvs::neighbors::cagra::detail::deserialize<DTYPE, uint32_t>(handle, is, index, out_dataset); \
   }                                                                                               \
@@ -59,7 +59,7 @@ namespace cuvs::neighbors::cagra {
     raft::resources const& handle,                                                                \
     const std::string& filename,                                                                  \
     cuvs::neighbors::cagra::device_standard_index<DTYPE, uint32_t>* index,                        \
-    std::unique_ptr<cuvs::neighbors::device_standard_dataset<DTYPE, int64_t>>* out_dataset)       \
+    std::unique_ptr<cuvs::core::device_standard_dataset<DTYPE, int64_t>>* out_dataset)            \
   {                                                                                               \
     cuvs::neighbors::cagra::detail::deserialize<DTYPE, uint32_t>(                                 \
       handle, filename, index, out_dataset);                                                      \
@@ -77,7 +77,7 @@ namespace cuvs::neighbors::cagra {
     raft::resources const& handle,                                                                \
     std::istream& is,                                                                             \
     cuvs::neighbors::cagra::device_standard_index<DTYPE, uint32_t>* index,                        \
-    std::unique_ptr<cuvs::neighbors::device_standard_dataset<DTYPE, int64_t>>* out_dataset)       \
+    std::unique_ptr<cuvs::core::device_standard_dataset<DTYPE, int64_t>>* out_dataset)            \
   {                                                                                               \
     cuvs::neighbors::cagra::detail::deserialize<DTYPE, uint32_t>(handle, is, index, out_dataset); \
   }                                                                                               \
@@ -90,11 +90,10 @@ namespace cuvs::neighbors::cagra {
       handle, filename, index, include_dataset);                                                  \
   }                                                                                               \
                                                                                                   \
-  void deserialize(                                                                               \
-    raft::resources const& handle,                                                                \
-    const std::string& filename,                                                                  \
-    cuvs::neighbors::cagra::host_padded_index<DTYPE, uint32_t>* index,                            \
-    std::unique_ptr<cuvs::neighbors::host_padded_dataset<DTYPE, int64_t>>* out_dataset)           \
+  void deserialize(raft::resources const& handle,                                                 \
+                   const std::string& filename,                                                   \
+                   cuvs::neighbors::cagra::host_padded_index<DTYPE, uint32_t>* index,             \
+                   std::unique_ptr<cuvs::core::host_padded_dataset<DTYPE, int64_t>>* out_dataset) \
   {                                                                                               \
     cuvs::neighbors::cagra::detail::deserialize<DTYPE, uint32_t>(                                 \
       handle, filename, index, out_dataset);                                                      \
@@ -109,11 +108,10 @@ namespace cuvs::neighbors::cagra {
       handle, os, index, include_dataset);                                                        \
   }                                                                                               \
                                                                                                   \
-  void deserialize(                                                                               \
-    raft::resources const& handle,                                                                \
-    std::istream& is,                                                                             \
-    cuvs::neighbors::cagra::host_padded_index<DTYPE, uint32_t>* index,                            \
-    std::unique_ptr<cuvs::neighbors::host_padded_dataset<DTYPE, int64_t>>* out_dataset)           \
+  void deserialize(raft::resources const& handle,                                                 \
+                   std::istream& is,                                                              \
+                   cuvs::neighbors::cagra::host_padded_index<DTYPE, uint32_t>* index,             \
+                   std::unique_ptr<cuvs::core::host_padded_dataset<DTYPE, int64_t>>* out_dataset) \
   {                                                                                               \
     cuvs::neighbors::cagra::detail::deserialize<DTYPE, uint32_t>(handle, is, index, out_dataset); \
   }                                                                                               \
@@ -131,7 +129,7 @@ namespace cuvs::neighbors::cagra {
     raft::resources const& handle,                                                                \
     const std::string& filename,                                                                  \
     cuvs::neighbors::cagra::host_standard_index<DTYPE, uint32_t>* index,                          \
-    std::unique_ptr<cuvs::neighbors::host_standard_dataset<DTYPE, int64_t>>* out_dataset)         \
+    std::unique_ptr<cuvs::core::host_standard_dataset<DTYPE, int64_t>>* out_dataset)              \
   {                                                                                               \
     cuvs::neighbors::cagra::detail::deserialize<DTYPE, uint32_t>(                                 \
       handle, filename, index, out_dataset);                                                      \
@@ -150,7 +148,7 @@ namespace cuvs::neighbors::cagra {
     raft::resources const& handle,                                                                \
     std::istream& is,                                                                             \
     cuvs::neighbors::cagra::host_standard_index<DTYPE, uint32_t>* index,                          \
-    std::unique_ptr<cuvs::neighbors::host_standard_dataset<DTYPE, int64_t>>* out_dataset)         \
+    std::unique_ptr<cuvs::core::host_standard_dataset<DTYPE, int64_t>>* out_dataset)              \
   {                                                                                               \
     cuvs::neighbors::cagra::detail::deserialize<DTYPE, uint32_t>(handle, is, index, out_dataset); \
   }                                                                                               \
diff --git a/cpp/src/neighbors/cagra_serialize_inst.cu.in b/cpp/src/neighbors/cagra_serialize_inst.cu.in
index 48df1dd596..0d8d399c69 100644
--- a/cpp/src/neighbors/cagra_serialize_inst.cu.in
+++ b/cpp/src/neighbors/cagra_serialize_inst.cu.in
@@ -10,8 +10,8 @@
 namespace {
 
 using data_t                      = @data_type@;
-using inst_device_padded_view_t   = cuvs::neighbors::device_padded_dataset_view<data_t, int64_t>;
-using inst_device_standard_view_t = cuvs::neighbors::device_standard_dataset_view<data_t, int64_t>;
+using inst_device_padded_view_t   = cuvs::core::device_padded_dataset_view<data_t, int64_t>;
+using inst_device_standard_view_t = cuvs::core::device_standard_dataset_view<data_t, int64_t>;
 using inst_vpq_f16_view_t =
   cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<half, int64_t>;
 
diff --git a/cpp/src/neighbors/detail/cagra/add_nodes.cuh b/cpp/src/neighbors/detail/cagra/add_nodes.cuh
index a77eae3758..a2a69abcae 100644
--- a/cpp/src/neighbors/detail/cagra/add_nodes.cuh
+++ b/cpp/src/neighbors/detail/cagra/add_nodes.cuh
@@ -20,7 +20,7 @@
 
 namespace cuvs::neighbors::cagra {
 
-template <class T, class IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT, class Accessor>
+template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT, class Accessor>
 void add_node_core(
   raft::resources const& handle,
   const cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>& idx,
@@ -276,7 +276,7 @@ void add_node_core(
   }
 }
 
-template <class T, class IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 void add_graph_nodes(
   raft::resources const& handle,
   raft::device_matrix_view<const T, int64_t, raft::layout_stride> input_updated_dataset_view,
@@ -301,7 +301,7 @@ void add_graph_nodes(
     updated_graph_view.data_handle(), initial_dataset_size, degree);
   raft::copy(handle, updated_graph_prefix, raft::make_const_mdspan(index.graph()));
 
-  using padded_view_t = cuvs::neighbors::device_padded_dataset_view<T, int64_t>;
+  using padded_view_t = cuvs::core::device_padded_dataset_view<T, int64_t>;
   auto zero_row       = raft::make_device_matrix_view<const T, int64_t>(
     static_cast<const T*>(nullptr), int64_t{0}, static_cast<uint32_t>(dim));
   padded_view_t device_empty_dataset_view(zero_row, static_cast<uint32_t>(dim));
@@ -324,7 +324,7 @@ void add_graph_nodes(
 
     // add_node_core() uses CAGRA search internally, which requires a padded device dataset.
     // Keep this path allocation-free by requiring pre-padded chunk views.
-    auto pdv       = cuvs::neighbors::make_device_padded_dataset_view(handle, dataset_view);
+    auto pdv       = cuvs::core::make_device_padded_dataset_view(handle, dataset_view);
     internal_index = cuvs::neighbors::cagra::update_dataset(handle, std::move(internal_index), pdv);
 
     // Note: The graph is copied to the device memory.
@@ -348,14 +348,14 @@ void add_graph_nodes(
   }
 }
 
-template <class T, class IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 void extend_core(raft::resources const& handle,
                  cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>& index,
                  const cagra::extend_params& params,
-                 cuvs::neighbors::device_padded_dataset_view<T, int64_t> extended_dataset,
+                 cuvs::core::device_padded_dataset_view<T, int64_t> extended_dataset,
                  int64_t new_start_row)
 {
-  static_assert(cuvs::neighbors::is_padded_dataset_view_v<DatasetViewT>,
+  static_assert(cuvs::core::is_padded_dataset_view_v<DatasetViewT>,
                 "cagra::extend requires a padded dataset view index type");
   RAFT_EXPECTS(!index.dataset_fd().has_value(),
                "Cannot extend a disk-backed CAGRA index. Convert it with "
@@ -385,12 +385,12 @@ void extend_core(raft::resources const& handle,
                dim);
 
   auto const& leaf = index.dataset();
-  if constexpr (cuvs::neighbors::is_empty_dataset_view_v<std::decay_t<decltype(leaf)>>) {
+  if constexpr (cuvs::core::is_empty_dataset_view_v<std::decay_t<decltype(leaf)>>) {
     RAFT_FAIL(
       "cagra::extend only supports an index to which the dataset is attached. Please check if the "
       "index has an empty dataset; attach one with update_dataset before "
       "extend.");
-  } else if constexpr (!cuvs::neighbors::is_padded_dataset_view_v<std::decay_t<decltype(leaf)>>) {
+  } else if constexpr (!cuvs::core::is_padded_dataset_view_v<std::decay_t<decltype(leaf)>>) {
     RAFT_FAIL("cagra::extend only supports an uncompressed padded dataset index");
   } else {
     // Caller owns dataset concatenation. Extend only grows the graph and rebinds the view.
diff --git a/cpp/src/neighbors/detail/cagra/cagra_build.cuh b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
index 8f24b307c9..b654e145b4 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_build.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
@@ -1303,14 +1303,14 @@ void ace_validate_disk_mode_partitions(raft::resources const& res,
 }
 
 template <typename T, typename IdxT, typename DatasetViewT>
-  requires cuvs::neighbors::is_dense_row_major_device_dataset_view_v<DatasetViewT>
+  requires cuvs::core::is_dense_row_major_device_dataset_view_v<DatasetViewT>
 auto build_from_device_matrix(raft::resources const& res,
                               const index_params& params,
                               DatasetViewT const& device_dataset)
   -> cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>;
 
 template <typename T, typename IdxT, typename DatasetViewT>
-  requires cuvs::neighbors::is_host_dataset_view_v<DatasetViewT>
+  requires cuvs::core::is_host_dataset_view_v<DatasetViewT>
 auto build_from_host_matrix(raft::resources const& res,
                             const index_params& params,
                             DatasetViewT const& dataset)
@@ -1326,7 +1326,7 @@ auto build_from_host_matrix(raft::resources const& res,
 // In disk mode, the graph is stored in build_dir and dataset is reordered on disk.
 // The returned index is not usable for search. Use the created files for search instead.
 template <typename T, typename IdxT, typename DatasetViewT>
-  requires cuvs::neighbors::is_host_dataset_view_v<DatasetViewT>
+  requires cuvs::core::is_host_dataset_view_v<DatasetViewT>
 auto build_ace(raft::resources const& res, const index_params& params, DatasetViewT const& dataset)
   -> cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>
 {
@@ -1614,14 +1614,12 @@ auto build_ace(raft::resources const& res, const index_params& params, DatasetVi
                                                             sub_dataset_tight.view());
               read_end              = std::chrono::high_resolution_clock::now();
               auto sub_dataset_view = raft::make_const_mdspan(sub_dataset_tight.view());
-              std::unique_ptr<cuvs::neighbors::device_padded_dataset<T, int64_t>>
-                sub_dataset_padded;
+              std::unique_ptr<cuvs::core::device_padded_dataset<T, int64_t>> sub_dataset_padded;
               auto sub_dataset_dev = [&]() {
-                if (cuvs::neighbors::matrix_row_width_matches_cagra_required(sub_dataset_view)) {
-                  return cuvs::neighbors::make_device_padded_dataset_view(res, sub_dataset_view);
+                if (cuvs::core::matrix_row_width_matches_cagra_required(sub_dataset_view)) {
+                  return cuvs::core::make_device_padded_dataset_view(res, sub_dataset_view);
                 }
-                sub_dataset_padded =
-                  cuvs::neighbors::make_device_padded_dataset(res, sub_dataset_view);
+                sub_dataset_padded = cuvs::core::make_device_padded_dataset(res, sub_dataset_view);
                 return sub_dataset_padded->as_dataset_view();
               }();
               auto direct_index =
@@ -1650,7 +1648,7 @@ auto build_ace(raft::resources const& res, const index_params& params, DatasetVi
                                                         augmented_header_size,
                                                         sub_dataset.view());
           read_end              = std::chrono::high_resolution_clock::now();
-          auto sub_dataset_view = cuvs::neighbors::make_host_standard_dataset_view(
+          auto sub_dataset_view = cuvs::core::make_host_standard_dataset_view(
             raft::make_const_mdspan(sub_dataset.view()));
           auto host_index =
             ::cuvs::neighbors::cagra::build(res, sub_index_params, sub_dataset_view);
@@ -1669,9 +1667,9 @@ auto build_ace(raft::resources const& res, const index_params& params, DatasetVi
                                               core_partition_offsets.view(),
                                               augmented_partition_offsets.view(),
                                               sub_dataset.view());
-        read_end              = std::chrono::high_resolution_clock::now();
-        auto sub_dataset_view = cuvs::neighbors::make_host_standard_dataset_view(
-          raft::make_const_mdspan(sub_dataset.view()));
+        read_end = std::chrono::high_resolution_clock::now();
+        auto sub_dataset_view =
+          cuvs::core::make_host_standard_dataset_view(raft::make_const_mdspan(sub_dataset.view()));
         auto host_index = ::cuvs::neighbors::cagra::build(res, sub_index_params, sub_dataset_view);
         static_assert(std::is_same_v<decltype(host_index), host_sub_index_t>);
         return sub_index_t{std::in_place_type<host_sub_index_t>, std::move(host_index)};
@@ -2451,7 +2449,7 @@ auto search_and_optimize(
 }
 
 template <typename T, typename IdxT = uint32_t, typename DatasetViewT>
-  requires(cuvs::neighbors::is_dense_row_major_device_dataset_view_v<DatasetViewT> ||
+  requires(cuvs::core::is_dense_row_major_device_dataset_view_v<DatasetViewT> ||
            cuvs::preprocessing::quantize::pq::is_device_vpq_f16_dataset_view_v<DatasetViewT>)
 auto iterative_build_graph(raft::resources const& res,
                            const index_params& params,
@@ -2481,7 +2479,7 @@ auto iterative_build_graph(raft::resources const& res,
     final_graph_size = static_cast<uint64_t>(dataset.n_rows());
     vpq_dataset      = dataset;
   } else {
-    auto const required_stride = cuvs::neighbors::cagra_required_row_width<T>(dataset.dim());
+    auto const required_stride = cuvs::core::cagra_required_row_width<T>(dataset.dim());
     auto const data_view       = dataset.as_matrix_view();
     RAFT_EXPECTS(data_view.stride() == required_stride,
                  "iterative CAGRA build requires a CAGRA-aligned device dataset "
@@ -2523,7 +2521,7 @@ auto iterative_build_graph(raft::resources const& res,
   std::optional<raft::device_matrix<T, int64_t>> reconstructed_batch_queries;
   if (vpq_dataset.n_rows() > 0) {
     auto const query_stride_i64 = static_cast<int64_t>(
-      cuvs::neighbors::cagra_required_row_width<T>(static_cast<uint32_t>(logical_dim)));
+      cuvs::core::cagra_required_row_width<T>(static_cast<uint32_t>(logical_dim)));
     reconstructed_batch_queries.emplace(
       raft::make_device_matrix<T, int64_t>(res, chunk_i64, query_stride_i64));
     // Padding columns must be zero: search_main cosine post-process reduces over the full row
@@ -2654,8 +2652,7 @@ auto iterative_build_graph(raft::resources const& res,
     } else {
       auto dev_dataset_view = raft::make_device_matrix_view<const T, int64_t>(
         dev_dataset.data_handle(), static_cast<int64_t>(curr_graph_size), dev_dataset.extent(1));
-      cuvs::neighbors::device_padded_dataset_view<T, int64_t> sub_padded(dev_dataset_view,
-                                                                         logical_dim);
+      cuvs::core::device_padded_dataset_view<T, int64_t> sub_padded(dev_dataset_view, logical_dim);
       auto idx = cuvs::neighbors::cagra::update_dataset(
         res, cuvs::neighbors::cagra::device_padded_index<T, IdxT>(res, params.metric), sub_padded);
       idx.update_graph(res, raft::make_const_mdspan(dev_graph.view()));
@@ -2807,7 +2804,7 @@ auto build_cagra_host_graph_from_knn_params(raft::resources const& res,
  * it still requires a device dataset before search.
  */
 template <typename T, typename IdxT = uint32_t, typename DatasetViewT>
-  requires cuvs::neighbors::is_host_dataset_view_v<DatasetViewT>
+  requires cuvs::core::is_host_dataset_view_v<DatasetViewT>
 auto build_from_host_matrix(raft::resources const& res,
                             const index_params& params,
                             DatasetViewT const& dataset)
@@ -2865,7 +2862,7 @@ auto build_from_host_matrix(raft::resources const& res,
  * `cagra::update_dataset` before search.
  */
 template <typename T, typename IdxT, typename DatasetViewT>
-  requires cuvs::neighbors::is_dense_row_major_device_dataset_view_v<DatasetViewT>
+  requires cuvs::core::is_dense_row_major_device_dataset_view_v<DatasetViewT>
 auto build_from_device_matrix(raft::resources const& res,
                               const index_params& params,
                               DatasetViewT const& device_dataset)
diff --git a/cpp/src/neighbors/detail/cagra/cagra_merge.cuh b/cpp/src/neighbors/detail/cagra/cagra_merge.cuh
index 4de0fbe79e..591a144954 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_merge.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_merge.cuh
@@ -37,7 +37,7 @@
 
 namespace cuvs::neighbors::cagra::detail {
 
-template <class T, class IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 int64_t merged_dataset_size(
   raft::resources const& handle,
   std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*> const& indices,
@@ -59,7 +59,7 @@ int64_t merged_dataset_size(
   return merged_rows;
 }
 
-template <class T, class IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge_rebuild(
   raft::resources const& handle,
   const cagra::index_params& params,
@@ -84,8 +84,7 @@ cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge_rebuild(
     RAFT_EXPECTS(index != nullptr,
                  "Null pointer detected in 'indices'. Ensure all elements are valid before usage.");
     auto const& dataset = index->dataset();
-    if constexpr (cuvs::neighbors::is_dense_row_major_dataset_view_v<
-                    std::decay_t<decltype(dataset)>>) {
+    if constexpr (cuvs::core::is_dense_row_major_dataset_view_v<std::decay_t<decltype(dataset)>>) {
       RAFT_EXPECTS(
         dataset.n_rows() != 0,
         "cagra::merge only supports an index to which the dataset is attached. Please check if "
@@ -133,7 +132,7 @@ cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge_rebuild(
       const T* src_ptr   = nullptr;
       std::size_t n_rows = 0;
       auto const& v      = index->dataset();
-      if constexpr (cuvs::neighbors::is_dense_row_major_dataset_view_v<std::decay_t<decltype(v)>>) {
+      if constexpr (cuvs::core::is_dense_row_major_dataset_view_v<std::decay_t<decltype(v)>>) {
         src_ptr = v.as_matrix_view().data_handle();
         n_rows  = static_cast<std::size_t>(v.n_rows());
       } else {
@@ -215,7 +214,7 @@ struct fastener_preflight_result {
 };
 
 /** Validate every input and option without mutating anything. */
-template <typename T, typename IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 auto preflight_fastener(
   raft::resources const& handle,
   cagra::index_params const& params,
@@ -236,7 +235,7 @@ auto preflight_fastener(
   }
   // Fastener reads the dataset densely per row with an explicit stride, so it needs a dense
   // device view; VPQ and host views are rejected here rather than deep inside a kernel.
-  if constexpr (!cuvs::neighbors::is_dense_row_major_device_dataset_view_v<DatasetViewT>) {
+  if constexpr (!cuvs::core::is_dense_row_major_device_dataset_view_v<DatasetViewT>) {
     return reject("only dense row-major device datasets are supported");
   }
   if (indices.size() < 2) { return reject("at least two input indices are required"); }
@@ -371,7 +370,7 @@ auto preflight_fastener(
 /** Copy every input dataset into its row range of the caller-supplied merged dataset. Both sides
  *  carry a row pitch: the inputs share one stride (enforced by preflight) and the destination uses
  *  the merged dataset's own stride. */
-template <typename T, typename IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 void copy_input_datasets(
   raft::resources const& handle,
   std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*> const& indices,
@@ -392,7 +391,7 @@ void copy_input_datasets(
   }
 }
 
-template <typename T, typename IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 auto merge_fastener(raft::resources const& handle,
                     cagra::index_params const& params,
                     cagra::merge_params const& merge_params,
@@ -487,7 +486,7 @@ auto merge_fastener(raft::resources const& handle,
   return merged_index;
 }
 
-template <class T, class IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 auto merge(raft::resources const& handle,
            cagra::index_params const& params,
            std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*>& indices,
@@ -540,7 +539,7 @@ auto merge(raft::resources const& handle,
 }
 
 /** AUTO-algorithm convenience overload matching the base `merge` signature. */
-template <class T, class IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 auto merge(raft::resources const& handle,
            cagra::index_params const& params,
            std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*>& indices,
diff --git a/cpp/src/neighbors/detail/cagra/cagra_merge_scaffold.cuh b/cpp/src/neighbors/detail/cagra/cagra_merge_scaffold.cuh
index 897991d2d5..df56bcf6c6 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_merge_scaffold.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_merge_scaffold.cuh
@@ -1142,7 +1142,7 @@ auto build(raft::resources const& res,
  *
  * The maximum input graph degree defines the base width, allowing partitions with mixed degrees.
  */
-template <typename T, typename IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 void append_to_input_graphs(
   raft::resources const& res,
   std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*> const& indices,
diff --git a/cpp/src/neighbors/detail/cagra/cagra_search.cuh b/cpp/src/neighbors/detail/cagra/cagra_search.cuh
index 7c8df90964..0bfe01cd41 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_search.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_search.cuh
@@ -100,13 +100,13 @@ void search_main_core(
   // batched path when stride==dim).
   const DataT* queries_buf{};
   uint32_t query_row_stride{};
-  std::unique_ptr<cuvs::neighbors::device_padded_dataset<DataT, int64_t>> queries_padded_own;
-  if (cuvs::neighbors::matrix_row_width_matches_cagra_required(queries)) {
-    auto v           = cuvs::neighbors::make_device_padded_dataset_view(res, queries);
+  std::unique_ptr<cuvs::core::device_padded_dataset<DataT, int64_t>> queries_padded_own;
+  if (cuvs::core::matrix_row_width_matches_cagra_required(queries)) {
+    auto v           = cuvs::core::make_device_padded_dataset_view(res, queries);
     queries_buf      = v.as_matrix_view().data_handle();
     query_row_stride = v.as_matrix_view().stride();
   } else {
-    queries_padded_own = cuvs::neighbors::make_device_padded_dataset(res, queries);
+    queries_padded_own = cuvs::core::make_device_padded_dataset(res, queries);
     auto v             = queries_padded_own->as_dataset_view();
     queries_buf        = v.as_matrix_view().data_handle();
     query_row_stride   = v.as_matrix_view().stride();
@@ -188,7 +188,7 @@ template <typename T,
           typename CagraSampleFilterT,
           typename IdxT      = uint32_t,
           typename DistanceT = float,
-          cuvs::neighbors::ann_dataset_view DatasetViewT>
+          cuvs::core::ann_dataset_view DatasetViewT>
 void search_main(raft::resources const& res,
                  search_params params,
                  const index<T, IdxT, DatasetViewT>& index,
@@ -206,7 +206,7 @@ void search_main(raft::resources const& res,
 
   const uint32_t query_logical_dim = index.dim();
   const uint32_t query_row_width   = static_cast<uint32_t>(queries.extent(1));
-  const uint32_t required_stride = cuvs::neighbors::cagra_required_row_width<T>(query_logical_dim);
+  const uint32_t required_stride   = cuvs::core::cagra_required_row_width<T>(query_logical_dim);
   RAFT_EXPECTS(query_row_width == query_logical_dim || query_row_width == required_stride,
                "CAGRA search queries must have %u logical dimensions or CAGRA-padded row width %u "
                "(got %u).",
@@ -243,7 +243,7 @@ void search_main(raft::resources const& res,
       sample_filter);
   };
 
-  if constexpr (cuvs::neighbors::is_empty_dataset_view_v<DatasetViewT>) {
+  if constexpr (cuvs::core::is_empty_dataset_view_v<DatasetViewT>) {
     RAFT_FAIL(
       "Attempted to search without a dataset. Please call "
       "cagra::update_dataset(res, std::move(index), dataset) first.");
@@ -269,15 +269,16 @@ void search_main(raft::resources const& res,
       distances,
       query_logical_dim,
       sample_filter);
-  } else if constexpr (cuvs::neighbors::is_device_standard_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::core::is_device_standard_dataset_view_v<DatasetViewT>) {
     RAFT_EXPECTS(
-      cuvs::neighbors::matrix_row_width_matches_cagra_required(index.dataset().as_matrix_view()),
+      cuvs::core::matrix_row_width_matches_cagra_required(index.dataset().as_matrix_view()),
       "CAGRA search requires each dataset row to have the CAGRA-aligned stride. Create a padded "
-      "dataset with make_device_padded_dataset() and attach it with cagra::update_dataset().");
+      "dataset with cuvs::core::make_device_padded_dataset() and attach it with "
+      "cagra::update_dataset().");
     run_strided_like(index.dataset());
-  } else if constexpr (cuvs::neighbors::is_device_padded_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::core::is_device_padded_dataset_view_v<DatasetViewT>) {
     run_strided_like(index.dataset());
-  } else if constexpr (cuvs::neighbors::is_host_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::core::is_host_dataset_view_v<DatasetViewT>) {
     static_assert(sizeof(DatasetViewT) == 0,
                   "search requires a device-resident dataset. "
                   "Call cagra::update_dataset(res, std::move(index), padded_view) "
@@ -371,7 +372,7 @@ void search_multi_partition(
   // The index type in this signature pins the dataset view to the default, so every partition is
   // statically known to hold a padded (non-compressed) device dataset.
   using partition_dataset_view_t = std::remove_cvref_t<decltype(indices[0]->dataset())>;
-  static_assert(cuvs::neighbors::is_device_padded_dataset_view_v<partition_dataset_view_t>,
+  static_assert(cuvs::core::is_device_padded_dataset_view_v<partition_dataset_view_t>,
                 "Multi-partition search requires padded device datasets");
 
   const uint32_t num_partitions = static_cast<uint32_t>(indices.size());
diff --git a/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh b/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
index 89d631c8c8..6ac99136cd 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
@@ -53,17 +53,17 @@ inline constexpr bool is_host_cagra_hnsw_serialize_index_v =
 
 constexpr int serialization_version = cuvs::neighbors::cagra::cagra_serialization_version;
 
-template <cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <cuvs::core::ann_dataset_view DatasetViewT>
 constexpr auto serialized_dataset_kind_for_view() -> cuvs::neighbors::cagra::serialized_dataset_kind
 {
   using kind = cuvs::neighbors::cagra::serialized_dataset_kind;
-  if constexpr (cuvs::neighbors::is_device_padded_dataset_view_v<DatasetViewT>) {
+  if constexpr (cuvs::core::is_device_padded_dataset_view_v<DatasetViewT>) {
     return kind::device_padded;
-  } else if constexpr (cuvs::neighbors::is_device_standard_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::core::is_device_standard_dataset_view_v<DatasetViewT>) {
     return kind::device_standard;
-  } else if constexpr (cuvs::neighbors::is_host_padded_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::core::is_host_padded_dataset_view_v<DatasetViewT>) {
     return kind::host_padded;
-  } else if constexpr (cuvs::neighbors::is_host_standard_dataset_view_v<DatasetViewT>) {
+  } else if constexpr (cuvs::core::is_host_standard_dataset_view_v<DatasetViewT>) {
     return kind::host_standard;
   } else {
     static_assert(sizeof(DatasetViewT) == 0,
@@ -106,7 +106,7 @@ void serialize_index_mdspan(raft::resources const& res, std::ostream& os, Mdspan
  * @param[in] index_ CAGRA index
  *
  */
-template <typename T, typename IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 void serialize(raft::resources const& res,
                std::ostream& os,
                const cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>& index_,
@@ -149,7 +149,7 @@ void serialize(raft::resources const& res,
   raft::serialize_scalar(res, os, content_map);
   if (include_dataset) {
     RAFT_LOG_DEBUG("Saving CAGRA index with dataset");
-    if constexpr (cuvs::neighbors::is_dense_row_major_dataset_view_v<DatasetViewT>) {
+    if constexpr (cuvs::core::is_dense_row_major_dataset_view_v<DatasetViewT>) {
       neighbors::detail::serialize_cagra_dense_dataset<T, int64_t>(res, os, index_.dataset());
     } else if constexpr (is_graph_only_dataset_view_v<DatasetViewT>) {
       RAFT_FAIL(kGraphOnlyDatasetMessage);
@@ -167,7 +167,7 @@ void serialize(raft::resources const& res,
   if (has_source_indices) { serialize_index_mdspan(res, os, index_.source_indices().value()); }
 }
 
-template <typename T, typename IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 void serialize(raft::resources const& res,
                const std::string& filename,
                const cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>& index_,
@@ -540,12 +540,12 @@ void serialize_to_hnswlib(
  * @param[in] index_ CAGRA index
  *
  */
-template <typename T, typename IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT, typename Input>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT, typename Input>
 void deserialize_impl(
   raft::resources const& res,
   Input& input,
   cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>* index_,
-  std::unique_ptr<cuvs::neighbors::owning_dataset_for_view_t<DatasetViewT>>* out_dataset = nullptr)
+  std::unique_ptr<cuvs::core::owning_dataset_for_view_t<DatasetViewT>>* out_dataset = nullptr)
 {
   raft::common::nvtx::range<cuvs::common::nvtx::domain::cuvs> fun_scope("cagra::deserialize");
   auto& is = cuvs::util::detail::input_stream(input);
@@ -595,7 +595,7 @@ void deserialize_impl(
     RAFT_EXPECTS(has_dataset == (dataset_kind != kind::none),
                  "cagra::deserialize: dataset kind and content map disagree");
 
-    using owner_t = cuvs::neighbors::owning_dataset_for_view_t<DatasetViewT>;
+    using owner_t = cuvs::core::owning_dataset_for_view_t<DatasetViewT>;
     std::unique_ptr<owner_t> dataset_owner{};
     if (has_dataset) {
       if (out_dataset == nullptr) {
@@ -614,16 +614,16 @@ void deserialize_impl(
             "cagra::deserialize: serialized dataset kind %u does not match requested kind %u",
             dataset_kind_raw,
             static_cast<std::uint32_t>(expected_kind));
-          if constexpr (cuvs::neighbors::is_device_padded_dataset_view_v<DatasetViewT>) {
+          if constexpr (cuvs::core::is_device_padded_dataset_view_v<DatasetViewT>) {
             dataset_owner =
               cuvs::neighbors::detail::deserialize_padded_dataset<T, int64_t>(res, input);
-          } else if constexpr (cuvs::neighbors::is_device_standard_dataset_view_v<DatasetViewT>) {
+          } else if constexpr (cuvs::core::is_device_standard_dataset_view_v<DatasetViewT>) {
             dataset_owner =
               cuvs::neighbors::detail::deserialize_standard_dataset<T, int64_t>(res, input);
-          } else if constexpr (cuvs::neighbors::is_host_padded_dataset_view_v<DatasetViewT>) {
+          } else if constexpr (cuvs::core::is_host_padded_dataset_view_v<DatasetViewT>) {
             dataset_owner =
               cuvs::neighbors::detail::deserialize_host_padded_dataset<T, int64_t>(res, input);
-          } else if constexpr (cuvs::neighbors::is_host_standard_dataset_view_v<DatasetViewT>) {
+          } else if constexpr (cuvs::core::is_host_standard_dataset_view_v<DatasetViewT>) {
             dataset_owner =
               cuvs::neighbors::detail::deserialize_host_standard_dataset<T, int64_t>(res, input);
           } else {
@@ -678,22 +678,22 @@ void deserialize_impl(
   }
 }
 
-template <typename T, typename IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 void deserialize(
   raft::resources const& res,
   std::istream& is,
   cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>* index_,
-  std::unique_ptr<cuvs::neighbors::owning_dataset_for_view_t<DatasetViewT>>* out_dataset = nullptr)
+  std::unique_ptr<cuvs::core::owning_dataset_for_view_t<DatasetViewT>>* out_dataset = nullptr)
 {
   deserialize_impl(res, is, index_, out_dataset);
 }
 
-template <typename T, typename IdxT, cuvs::neighbors::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
 void deserialize(
   raft::resources const& res,
   const std::string& filename,
   cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>* index_,
-  std::unique_ptr<cuvs::neighbors::owning_dataset_for_view_t<DatasetViewT>>* out_dataset = nullptr)
+  std::unique_ptr<cuvs::core::owning_dataset_for_view_t<DatasetViewT>>* out_dataset = nullptr)
 {
   cuvs::util::kvikio_file_reader reader(filename);
   deserialize_impl(res, reader, index_, out_dataset);
diff --git a/cpp/src/neighbors/detail/cagra/compute_distance_standard.hpp b/cpp/src/neighbors/detail/cagra/compute_distance_standard.hpp
index 8f5d975449..fba16934fc 100644
--- a/cpp/src/neighbors/detail/cagra/compute_distance_standard.hpp
+++ b/cpp/src/neighbors/detail/cagra/compute_distance_standard.hpp
@@ -28,7 +28,7 @@ struct standard_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT>
   template <typename DatasetT>
   constexpr static inline bool accepts_dataset()
   {
-    return cuvs::neighbors::is_padded_dataset_view_v<DatasetT>;
+    return cuvs::core::is_padded_dataset_view_v<DatasetT>;
   }
 
   template <typename DatasetT>
diff --git a/cpp/src/neighbors/detail/cagra/factory.cuh b/cpp/src/neighbors/detail/cagra/factory.cuh
index 0dd3477944..aea0e3d9a1 100644
--- a/cpp/src/neighbors/detail/cagra/factory.cuh
+++ b/cpp/src/neighbors/detail/cagra/factory.cuh
@@ -98,8 +98,8 @@ auto make_key(const cagra::search_params& params,
               const DatasetT& dataset,
               cuvs::distance::DistanceType metric,
               const void* dataset_norms)
-  -> std::enable_if_t<cuvs::neighbors::is_padded_dataset_v<DatasetT> ||
-                        cuvs::neighbors::is_standard_dataset_v<DatasetT>,
+  -> std::enable_if_t<cuvs::core::is_padded_dataset_v<DatasetT> ||
+                        cuvs::core::is_standard_dataset_v<DatasetT>,
                       key>
 {
   auto const data_view = dataset.as_matrix_view();
diff --git a/cpp/src/neighbors/detail/dataset_serialize.hpp b/cpp/src/neighbors/detail/dataset_serialize.hpp
index e7954a6eaa..0c811dd234 100644
--- a/cpp/src/neighbors/detail/dataset_serialize.hpp
+++ b/cpp/src/neighbors/detail/dataset_serialize.hpp
@@ -83,7 +83,7 @@ auto dense_matrix_elements(IdxT n_rows, uint32_t dim, char const* context) -> st
 }
 
 template <typename DataT, typename IdxT, typename ViewT>
-  requires cuvs::neighbors::is_dense_row_major_dataset_view_v<ViewT>
+  requires cuvs::core::is_dense_row_major_dataset_view_v<ViewT>
 void serialize(const raft::resources& res, std::ostream& os, ViewT const& dataset)
 {
   auto n_rows    = dataset.n_rows();
@@ -102,7 +102,7 @@ void serialize(const raft::resources& res, std::ostream& os, ViewT const& datase
                                          static_cast<raft::numpy_serializer::ndarray_len_t>(dim)}});
   if (elements == 0) { return; }
 
-  if constexpr (cuvs::neighbors::is_device_dataset_view_v<ViewT>) {
+  if constexpr (cuvs::core::is_device_dataset_view_v<ViewT>) {
     if (auto* kvikio_stream = dynamic_cast<cuvs::util::kvikio_ofstream*>(&os);
         kvikio_stream != nullptr) {
       auto const row_bytes = static_cast<std::size_t>(dim) * sizeof(DataT);
@@ -156,7 +156,7 @@ void serialize(const raft::resources& res, std::ostream& os, ViewT const& datase
 
 /** Write CAGRA index dataset blob (tag + element dtype + strided payload). */
 template <typename DataT, typename IdxT, typename ViewT>
-  requires cuvs::neighbors::is_dense_row_major_dataset_view_v<ViewT>
+  requires cuvs::core::is_dense_row_major_dataset_view_v<ViewT>
 void serialize_cagra_dense_dataset(const raft::resources& res,
                                    std::ostream& os,
                                    ViewT const& dataset)
@@ -178,10 +178,10 @@ void serialize_cagra_dense_dataset(const raft::resources& res,
 
 template <typename IdxT>
 auto deserialize_empty(raft::resources const& res, std::istream& is)
-  -> std::unique_ptr<device_empty_dataset<IdxT>>
+  -> std::unique_ptr<cuvs::core::device_empty_dataset<IdxT>>
 {
   auto suggested_dim = raft::deserialize_scalar<uint32_t>(res, is);
-  return std::make_unique<device_empty_dataset<IdxT>>(suggested_dim);
+  return std::make_unique<cuvs::core::device_empty_dataset<IdxT>>(suggested_dim);
 }
 
 /** Read and validate shared dense wire metadata and the tight `[n_rows x dim]` NumPy header. */
@@ -459,13 +459,16 @@ auto deserialize_dense_dataset(raft::resources const& res, Input& input)
                "deserialize_dataset: serialized dtype (%d) does not match expected (%d)",
                static_cast<int>(dtype),
                static_cast<int>(expected_dtype));
-  if constexpr (std::is_same_v<OwningDatasetT, device_padded_dataset<DataT, IdxT>>) {
+  if constexpr (std::is_same_v<OwningDatasetT, cuvs::core::device_padded_dataset<DataT, IdxT>>) {
     return deserialize_device_dense<DataT, IdxT, OwningDatasetT>(res, input);
-  } else if constexpr (std::is_same_v<OwningDatasetT, device_standard_dataset<DataT, IdxT>>) {
+  } else if constexpr (std::is_same_v<OwningDatasetT,
+                                      cuvs::core::device_standard_dataset<DataT, IdxT>>) {
     return deserialize_device_dense<DataT, IdxT, OwningDatasetT>(res, input);
-  } else if constexpr (std::is_same_v<OwningDatasetT, host_padded_dataset<DataT, IdxT>>) {
+  } else if constexpr (std::is_same_v<OwningDatasetT,
+                                      cuvs::core::host_padded_dataset<DataT, IdxT>>) {
     return deserialize_host_dense<DataT, IdxT, OwningDatasetT>(res, is);
-  } else if constexpr (std::is_same_v<OwningDatasetT, host_standard_dataset<DataT, IdxT>>) {
+  } else if constexpr (std::is_same_v<OwningDatasetT,
+                                      cuvs::core::host_standard_dataset<DataT, IdxT>>) {
     return deserialize_host_dense<DataT, IdxT, OwningDatasetT>(res, is);
   } else {
     static_assert(!std::is_same_v<OwningDatasetT, OwningDatasetT>,
@@ -498,30 +501,34 @@ void skip_dense_dataset(raft::resources const& res, std::istream& is)
 // type-erased variant routing.
 template <typename DataT, typename IdxT, typename Input>
 auto deserialize_padded_dataset(raft::resources const& res, Input& input)
-  -> std::unique_ptr<device_padded_dataset<DataT, IdxT>>
+  -> std::unique_ptr<cuvs::core::device_padded_dataset<DataT, IdxT>>
 {
-  return deserialize_dense_dataset<DataT, IdxT, device_padded_dataset<DataT, IdxT>>(res, input);
+  return deserialize_dense_dataset<DataT, IdxT, cuvs::core::device_padded_dataset<DataT, IdxT>>(
+    res, input);
 }
 
 template <typename DataT, typename IdxT, typename Input>
 auto deserialize_standard_dataset(raft::resources const& res, Input& input)
-  -> std::unique_ptr<device_standard_dataset<DataT, IdxT>>
+  -> std::unique_ptr<cuvs::core::device_standard_dataset<DataT, IdxT>>
 {
-  return deserialize_dense_dataset<DataT, IdxT, device_standard_dataset<DataT, IdxT>>(res, input);
+  return deserialize_dense_dataset<DataT, IdxT, cuvs::core::device_standard_dataset<DataT, IdxT>>(
+    res, input);
 }
 
 template <typename DataT, typename IdxT, typename Input>
 auto deserialize_host_padded_dataset(raft::resources const& res, Input& input)
-  -> std::unique_ptr<host_padded_dataset<DataT, IdxT>>
+  -> std::unique_ptr<cuvs::core::host_padded_dataset<DataT, IdxT>>
 {
-  return deserialize_dense_dataset<DataT, IdxT, host_padded_dataset<DataT, IdxT>>(res, input);
+  return deserialize_dense_dataset<DataT, IdxT, cuvs::core::host_padded_dataset<DataT, IdxT>>(
+    res, input);
 }
 
 template <typename DataT, typename IdxT, typename Input>
 auto deserialize_host_standard_dataset(raft::resources const& res, Input& input)
-  -> std::unique_ptr<host_standard_dataset<DataT, IdxT>>
+  -> std::unique_ptr<cuvs::core::host_standard_dataset<DataT, IdxT>>
 {
-  return deserialize_dense_dataset<DataT, IdxT, host_standard_dataset<DataT, IdxT>>(res, input);
+  return deserialize_dense_dataset<DataT, IdxT, cuvs::core::host_standard_dataset<DataT, IdxT>>(
+    res, input);
 }
 
 }  // namespace cuvs::neighbors::detail
diff --git a/cpp/src/neighbors/detail/hnsw.hpp b/cpp/src/neighbors/detail/hnsw.hpp
index 046540539d..4af370a15f 100644
--- a/cpp/src/neighbors/detail/hnsw.hpp
+++ b/cpp/src/neighbors/detail/hnsw.hpp
@@ -3004,7 +3004,7 @@ std::unique_ptr<index<T>> build(raft::resources const& res,
 
   // Public HNSW API uses host_matrix_view; CAGRA build expects a padded dataset view.
   // Host build stores only the graph; vectors are passed separately to from_cagra below.
-  cuvs::neighbors::host_padded_dataset_view<T, int64_t> host_padded_view(
+  cuvs::core::host_padded_dataset_view<T, int64_t> host_padded_view(
     dataset, static_cast<uint32_t>(dataset.extent(1)));
   auto ace_host_index = cuvs::neighbors::cagra::build(res, cagra_params, host_padded_view);
 
diff --git a/cpp/src/neighbors/detail/tiered_index.cuh b/cpp/src/neighbors/detail/tiered_index.cuh
index 5e81958aa6..feaf06b75e 100644
--- a/cpp/src/neighbors/detail/tiered_index.cuh
+++ b/cpp/src/neighbors/detail/tiered_index.cuh
@@ -127,7 +127,7 @@ struct index_state {
     auto index = std::forward<BuildFn>(build_fn)(res, tiered_params, dataset);
     if constexpr (std::is_same_v<UpstreamT, cuvs::neighbors::cagra::device_standard_index<float>>) {
       index = cuvs::neighbors::cagra::update_dataset(
-        res, std::move(index), cuvs::neighbors::make_device_standard_dataset_view(dataset));
+        res, std::move(index), cuvs::core::make_device_standard_dataset_view(dataset));
     }
     return std::make_shared<UpstreamT>(std::move(index));
   }
@@ -303,7 +303,7 @@ inline void update_cagra_ann_dataset_for_stride(
   raft::device_matrix_view<const float, int64_t, raft::row_major> dataset)
 {
   ann_index = cuvs::neighbors::cagra::update_dataset(
-    res, std::move(ann_index), cuvs::neighbors::make_device_standard_dataset_view(dataset));
+    res, std::move(ann_index), cuvs::core::make_device_standard_dataset_view(dataset));
 }
 
 /**
diff --git a/cpp/src/neighbors/detail/vamana/vamana_serialize.cuh b/cpp/src/neighbors/detail/vamana/vamana_serialize.cuh
index 78bac296db..b6576f602d 100644
--- a/cpp/src/neighbors/detail/vamana/vamana_serialize.cuh
+++ b/cpp/src/neighbors/detail/vamana/vamana_serialize.cuh
@@ -90,7 +90,7 @@ void serialize_dataset_view(raft::resources const& res,
  */
 template <typename T>
 void serialize_dataset(raft::resources const& res,
-                       const cuvs::neighbors::device_padded_dataset_view<T, int64_t>* dataset,
+                       const cuvs::core::device_padded_dataset_view<T, int64_t>* dataset,
                        const std::string& dataset_base_file)
 {
   if (dataset == nullptr) { return; }
@@ -129,12 +129,11 @@ void serialize_dataset(raft::resources const& res,
  *
  */
 template <typename T, typename IdxT, typename HostMatT>
-void serialize_sector_aligned(
-  raft::resources const& res,
-  const HostMatT& h_graph,
-  const cuvs::neighbors::device_padded_dataset_view<T, int64_t>& dataset,
-  const uint64_t medoid,
-  std::ostream& output_writer)
+void serialize_sector_aligned(raft::resources const& res,
+                              const HostMatT& h_graph,
+                              const cuvs::core::device_padded_dataset_view<T, int64_t>& dataset,
+                              const uint64_t medoid,
+                              std::ostream& output_writer)
 {
   if constexpr (!std::is_same_v<IdxT, uint32_t>) {
     RAFT_FAIL("serialization is only implemented for uint32_t graph");
diff --git a/cpp/src/neighbors/iface/iface.hpp b/cpp/src/neighbors/iface/iface.hpp
index 574859ae7a..6fdf35eff0 100644
--- a/cpp/src/neighbors/iface/iface.hpp
+++ b/cpp/src/neighbors/iface/iface.hpp
@@ -33,7 +33,7 @@ bool dataset_mdspan_uses_padded_device_view(
 {
   using value_type = T;
   uint32_t const required_stride =
-    cagra_required_row_width<value_type>(static_cast<uint32_t>(mds.extent(1)));
+    cuvs::core::cagra_required_row_width<value_type>(static_cast<uint32_t>(mds.extent(1)));
   uint32_t const src_stride =
     mds.stride(0) > 0 ? static_cast<uint32_t>(mds.stride(0)) : static_cast<uint32_t>(mds.extent(1));
   cudaPointerAttributes a{};
@@ -55,12 +55,12 @@ void cagra_build_from_device_dataset(
   auto dview = raft::make_device_strided_matrix_view<const T, int64_t, row_major>(
     m.data_handle(), m.extent(0), m.extent(1), stride);
   if constexpr (std::is_same_v<AnnIndexType, cagra::device_padded_index<T, IdxT>>) {
-    auto padded = cuvs::neighbors::make_device_padded_dataset_view(h, dview);
+    auto padded = cuvs::core::make_device_padded_dataset_view(h, dview);
     auto index  = cuvs::neighbors::cagra::build(h, cagra_params, padded);
     index       = cuvs::neighbors::cagra::update_dataset(h, std::move(index), padded);
     interface.index_.emplace(std::move(index));
   } else {
-    auto standard = cuvs::neighbors::make_device_standard_dataset_view(dview);
+    auto standard = cuvs::core::make_device_standard_dataset_view(dview);
     auto index    = cuvs::neighbors::cagra::build(h, cagra_params, standard);
     index         = cuvs::neighbors::cagra::update_dataset(h, std::move(index), standard);
     interface.index_.emplace(std::move(index));
@@ -104,23 +104,23 @@ void build(const raft::resources& handle,
       auto host_view = raft::make_host_matrix_view<const T, int64_t, raft::row_major>(
         index_dataset.data_handle(), index_dataset.extent(0), index_dataset.extent(1));
       if constexpr (std::is_same<AnnIndexType, cagra::device_padded_index<T, IdxT>>::value) {
-        cuvs::neighbors::host_padded_dataset_view<T, int64_t> host_padded(
+        cuvs::core::host_padded_dataset_view<T, int64_t> host_padded(
           host_view, static_cast<uint32_t>(host_view.extent(1)));
         auto host_idx   = cuvs::neighbors::cagra::build(handle, cagra_params, host_padded);
-        auto padded_r   = cuvs::neighbors::make_device_padded_dataset(handle, index_dataset);
+        auto padded_r   = cuvs::core::make_device_padded_dataset(handle, index_dataset);
         auto device_idx = cuvs::neighbors::cagra::update_dataset(
           handle, std::move(host_idx), padded_r->as_dataset_view());
         interface.cagra_owned_padded_dataset_ = std::move(padded_r);
         interface.cagra_owned_standard_dataset_.reset();
         interface.index_.emplace(std::move(device_idx));
       } else {
-        auto host_standard = cuvs::neighbors::make_host_standard_dataset_view(host_view);
+        auto host_standard = cuvs::core::make_host_standard_dataset_view(host_view);
         auto host_idx      = cuvs::neighbors::cagra::build(handle, cagra_params, host_standard);
-        auto standard_r    = cuvs::neighbors::make_device_standard_dataset(
-          handle,
-          index_dataset,
-          static_cast<uint32_t>(index_dataset.extent(1)),
-          static_cast<uint32_t>(index_dataset.stride(0)));
+        auto standard_r =
+          cuvs::core::make_device_standard_dataset(handle,
+                                                   index_dataset,
+                                                   static_cast<uint32_t>(index_dataset.extent(1)),
+                                                   static_cast<uint32_t>(index_dataset.stride(0)));
         auto device_idx = cuvs::neighbors::cagra::update_dataset(
           handle, std::move(host_idx), standard_r->as_dataset_view());
         interface.cagra_owned_standard_dataset_ = std::move(standard_r);
@@ -251,7 +251,7 @@ void deserialize(const raft::resources& handle,
     interface.index_.emplace(std::move(idx));
   } else if constexpr (std::is_same<AnnIndexType, cagra::device_padded_index<T, IdxT>>::value) {
     cagra::device_padded_index<T, IdxT> idx(handle);
-    std::unique_ptr<cuvs::neighbors::device_padded_dataset<T, int64_t>> out_dataset;
+    std::unique_ptr<cuvs::core::device_padded_dataset<T, int64_t>> out_dataset;
     cagra::deserialize(handle, is, &idx, &out_dataset);
     interface.cagra_owned_padded_dataset_.reset();
     interface.cagra_owned_standard_dataset_.reset();
@@ -260,7 +260,7 @@ void deserialize(const raft::resources& handle,
     interface.index_.emplace(std::move(idx));
   } else if constexpr (std::is_same<AnnIndexType, cagra::device_standard_index<T, IdxT>>::value) {
     cagra::device_standard_index<T, IdxT> idx(handle);
-    std::unique_ptr<cuvs::neighbors::device_standard_dataset<T, int64_t>> out_dataset;
+    std::unique_ptr<cuvs::core::device_standard_dataset<T, int64_t>> out_dataset;
     cagra::deserialize(handle, is, &idx, &out_dataset);
     interface.cagra_owned_padded_dataset_.reset();
     interface.cagra_owned_standard_dataset_.reset();
@@ -289,7 +289,7 @@ void deserialize(const raft::resources& handle,
     interface.index_.emplace(std::move(idx));
   } else if constexpr (std::is_same<AnnIndexType, cagra::device_padded_index<T, IdxT>>::value) {
     cagra::device_padded_index<T, IdxT> idx(handle);
-    std::unique_ptr<cuvs::neighbors::device_padded_dataset<T, int64_t>> out_dataset;
+    std::unique_ptr<cuvs::core::device_padded_dataset<T, int64_t>> out_dataset;
     cagra::deserialize(handle, filename, &idx, &out_dataset);
     interface.cagra_owned_padded_dataset_.reset();
     interface.cagra_owned_standard_dataset_.reset();
@@ -298,7 +298,7 @@ void deserialize(const raft::resources& handle,
     interface.index_.emplace(std::move(idx));
   } else if constexpr (std::is_same<AnnIndexType, cagra::device_standard_index<T, IdxT>>::value) {
     cagra::device_standard_index<T, IdxT> idx(handle);
-    std::unique_ptr<cuvs::neighbors::device_standard_dataset<T, int64_t>> out_dataset;
+    std::unique_ptr<cuvs::core::device_standard_dataset<T, int64_t>> out_dataset;
     cagra::deserialize(handle, filename, &idx, &out_dataset);
     interface.cagra_owned_padded_dataset_.reset();
     interface.cagra_owned_standard_dataset_.reset();
diff --git a/cpp/src/neighbors/mg/mg_cagra_inst.cu.in b/cpp/src/neighbors/mg/mg_cagra_inst.cu.in
index 6820480ebb..d155f20461 100644
--- a/cpp/src/neighbors/mg/mg_cagra_inst.cu.in
+++ b/cpp/src/neighbors/mg/mg_cagra_inst.cu.in
@@ -11,7 +11,7 @@ template <typename T, typename IdxT, typename AnnIndexT, typename RankUpdate>
 void distribute_padded_dataset(
   const raft::resources& res,
   const cuvs::neighbors::mg_index<AnnIndexT, T, IdxT>& idx,
-  cuvs::neighbors::device_padded_dataset_view<T, int64_t> const& padded_dataset,
+  cuvs::core::device_padded_dataset_view<T, int64_t> const& padded_dataset,
   RankUpdate&& rank_update)
 {
   auto padded_mds                 = padded_dataset.as_matrix_view();
@@ -38,7 +38,7 @@ void distribute_padded_dataset(
     auto rank_device_matrix =
       raft::make_device_matrix<T, int64_t, raft::row_major>(dev_res, rank_rows, stride);
     raft::copy(dev_res, rank_device_matrix.view(), rank_host_mds);
-    auto rank_device_padded = std::make_unique<cuvs::neighbors::device_padded_dataset<T, int64_t>>(
+    auto rank_device_padded = std::make_unique<cuvs::core::device_padded_dataset<T, int64_t>>(
       std::move(rank_device_matrix), padded_dataset.dim());
     rank_update(dev_res, rank, std::move(rank_device_padded));
     if (idx.mode_ == cuvs::neighbors::SHARDED) { offset += rank_rows; }
@@ -53,7 +53,7 @@ void distribute_padded_dataset(
   cuvs::neighbors::mg_index<cagra::device_standard_index<T, IdxT>, T, IdxT> build(                \
     const raft::resources& res,                                                                   \
     const mg_index_params<cagra::index_params>& index_params,                                     \
-    cuvs::neighbors::host_standard_dataset_view<T, int64_t> const& index_dataset)                 \
+    cuvs::core::host_standard_dataset_view<T, int64_t> const& index_dataset)                      \
   {                                                                                               \
     cuvs::neighbors::mg_index<cagra::device_standard_index<T, IdxT>, T, IdxT> index(              \
       res, index_params.mode);                                                                    \
@@ -68,7 +68,7 @@ void distribute_padded_dataset(
   cuvs::neighbors::mg_index<cagra::device_padded_index<T, IdxT>, T, IdxT> build(                  \
     const raft::resources& res,                                                                   \
     const mg_index_params<cagra::index_params>& index_params,                                     \
-    cuvs::neighbors::host_padded_dataset_view<T, int64_t> const& index_dataset)                   \
+    cuvs::core::host_padded_dataset_view<T, int64_t> const& index_dataset)                        \
   {                                                                                               \
     cuvs::neighbors::mg_index<cagra::device_padded_index<T, IdxT>, T, IdxT> index(                \
       res, index_params.mode);                                                                    \
@@ -83,7 +83,7 @@ void distribute_padded_dataset(
   auto update_dataset(                                                                            \
     const raft::resources& res,                                                                   \
     cuvs::neighbors::mg_index<cagra::device_standard_index<T, IdxT>, T, IdxT>&& idx,              \
-    cuvs::neighbors::device_padded_dataset_view<T, int64_t> const& padded_dataset)                \
+    cuvs::core::device_padded_dataset_view<T, int64_t> const& padded_dataset)                     \
     -> cuvs::neighbors::mg_index<cagra::device_padded_index<T, IdxT>, T, IdxT>                    \
   {                                                                                               \
     cuvs::neighbors::mg_index<cagra::device_padded_index<T, IdxT>, T, IdxT> out(res, idx.mode_);  \
@@ -104,7 +104,7 @@ void distribute_padded_dataset(
   void update_dataset(                                                                            \
     const raft::resources& res,                                                                   \
     cuvs::neighbors::mg_index<cagra::device_padded_index<T, IdxT>, T, IdxT>& idx,                 \
-    cuvs::neighbors::device_padded_dataset_view<T, int64_t> const& padded_dataset)                \
+    cuvs::core::device_padded_dataset_view<T, int64_t> const& padded_dataset)                     \
   {                                                                                               \
     detail::distribute_padded_dataset(                                                            \
       res, idx, padded_dataset, [&](const raft::resources& dev_res, int rank, auto dataset) {     \
@@ -119,7 +119,7 @@ void distribute_padded_dataset(
                                                                                                   \
   void extend(const raft::resources& res,                                                         \
               cuvs::neighbors::mg_index<cagra::device_padded_index<T, IdxT>, T, IdxT>& index,     \
-              cuvs::neighbors::host_padded_dataset_view<T, int64_t> new_vectors,                  \
+              cuvs::core::host_padded_dataset_view<T, int64_t> new_vectors,                       \
               std::optional<raft::host_vector_view<const IdxT, int64_t>> new_indices)             \
   {                                                                                               \
     cuvs::neighbors::snmg::detail::extend(res, index, new_vectors.as_matrix_view(), new_indices); \
@@ -127,7 +127,7 @@ void distribute_padded_dataset(
                                                                                                   \
   void extend(const raft::resources& res,                                                         \
               cuvs::neighbors::mg_index<cagra::device_standard_index<T, IdxT>, T, IdxT>& index,   \
-              cuvs::neighbors::host_standard_dataset_view<T, int64_t> new_vectors,                \
+              cuvs::core::host_standard_dataset_view<T, int64_t> new_vectors,                     \
               std::optional<raft::host_vector_view<const IdxT, int64_t>> new_indices)             \
   {                                                                                               \
     cuvs::neighbors::snmg::detail::extend(res, index, new_vectors.as_matrix_view(), new_indices); \
diff --git a/cpp/src/neighbors/tiered_index.cu b/cpp/src/neighbors/tiered_index.cu
index 5c457508a3..592888c171 100644
--- a/cpp/src/neighbors/tiered_index.cu
+++ b/cpp/src/neighbors/tiered_index.cu
@@ -37,7 +37,7 @@ cuvs::neighbors::cagra::device_standard_index<float, uint32_t> cagra_build_for_t
   cuvs::neighbors::cagra::index_params const& params,
   raft::device_matrix_view<const float, int64_t, raft::row_major> dataset)
 {
-  auto view = cuvs::neighbors::make_device_standard_dataset_view(dataset);
+  auto view = cuvs::core::make_device_standard_dataset_view(dataset);
   return cuvs::neighbors::cagra::build(res, params, view);
 }
 
@@ -46,7 +46,7 @@ cuvs::neighbors::cagra::device_padded_index<float, uint32_t> cagra_build_for_tie
   cuvs::neighbors::cagra::index_params const& params,
   raft::device_matrix_view<const float, int64_t, raft::row_major> dataset)
 {
-  auto view = cuvs::neighbors::make_device_padded_dataset_view(res, dataset);
+  auto view = cuvs::core::make_device_padded_dataset_view(res, dataset);
   return cuvs::neighbors::cagra::build(res, params, view);
 }
 
@@ -55,7 +55,7 @@ cuvs::neighbors::cagra::device_padded_index<float, uint32_t> cagra_build_for_tie
 namespace cuvs::neighbors::tiered_index {
 auto build(raft::resources const& res,
            const index_params<cagra::index_params>& params,
-           cuvs::neighbors::device_padded_dataset_view<float, int64_t> dataset)
+           cuvs::core::device_padded_dataset_view<float, int64_t> dataset)
   -> tiered_index::index<cagra::device_padded_index<float, uint32_t>>
 {
   auto state = detail::build<cagra::device_padded_index<float, uint32_t>>(
@@ -76,7 +76,7 @@ auto build(raft::resources const& res,
 auto convert_standard_to_padded_index(
   raft::resources const& res,
   const tiered_index::index<cagra::device_standard_index<float, uint32_t>>& idx,
-  cuvs::neighbors::device_padded_dataset_view<float, int64_t> padded_dataset)
+  cuvs::core::device_padded_dataset_view<float, int64_t> padded_dataset)
   -> tiered_index::index<cagra::device_padded_index<float, uint32_t>>
 {
   RAFT_EXPECTS(padded_dataset.n_rows() == idx.size(),
@@ -97,7 +97,7 @@ auto convert_standard_to_padded_index(
     auto ann_mds    = raft::make_device_matrix_view<const float, int64_t>(
       padded_mds.data_handle(), ann_rows, static_cast<int64_t>(padded_mds.extent(1)));
     auto ann_padded_view =
-      cuvs::neighbors::device_padded_dataset_view<float, int64_t>(ann_mds, padded_dataset.dim());
+      cuvs::core::device_padded_dataset_view<float, int64_t>(ann_mds, padded_dataset.dim());
     auto ann_padded_idx = cuvs::neighbors::cagra::convert_standard_to_padded_index(
       res, *idx.state->ann_index, ann_padded_view);
     next_state->ann_index =
@@ -243,7 +243,7 @@ void search(raft::resources const& res,
   auto storage = index.state->storage;
   auto vectors = raft::make_device_matrix_view<const float, int64_t>(
     storage->dataset.data(), index.size(), static_cast<int64_t>(storage->dim));
-  auto padded_dataset = cuvs::neighbors::make_device_padded_dataset(res, vectors);
+  auto padded_dataset = cuvs::core::make_device_padded_dataset(res, vectors);
   auto padded_index =
     convert_standard_to_padded_index(res, index, padded_dataset->as_dataset_view());
   padded_index.state->search(
diff --git a/cpp/tests/neighbors/ann_cagra.cuh b/cpp/tests/neighbors/ann_cagra.cuh
index 951e3af13b..5a41102c88 100644
--- a/cpp/tests/neighbors/ann_cagra.cuh
+++ b/cpp/tests/neighbors/ann_cagra.cuh
@@ -65,11 +65,11 @@ void cagra_build_into_index(
   raft::resources const& res,
   cagra::index_params const& params,
   std::optional<raft::host_matrix_view<const DataT, int64_t>> ace_host_dataset,
-  cuvs::neighbors::device_padded_dataset_view<DataT, int64_t> const& padded,
+  cuvs::core::device_padded_dataset_view<DataT, int64_t> const& padded,
   cagra::device_padded_index<DataT>& index)
 {
   if (ace_host_dataset.has_value()) {
-    cuvs::neighbors::host_padded_dataset_view<DataT, int64_t> host_view(
+    cuvs::core::host_padded_dataset_view<DataT, int64_t> host_view(
       *ace_host_dataset, static_cast<uint32_t>(ace_host_dataset->extent(1)));
     auto host_idx = cagra::build(res, params, host_view);
     // In-memory ACE returns graph-only; attach device padded storage for search.
@@ -489,7 +489,7 @@ class AnnCagraTest : public ::testing::TestWithParam<AnnCagraInputs> {
         }
 
         cagra::device_padded_index<DataT, IdxT> index(handle_);
-        std::unique_ptr<cuvs::neighbors::device_padded_dataset<DataT, int64_t>> loaded_dataset;
+        std::unique_ptr<cuvs::core::device_padded_dataset<DataT, int64_t>> loaded_dataset;
         cagra::deserialize(handle_, index_file.filename, &index, &loaded_dataset);
 
         if (!ps.include_serialized_dataset) {
@@ -1331,7 +1331,7 @@ class AnnCagraIndexFilteredMergeTest : public ::testing::TestWithParam<AnnCagraI
           handle_,
           ps.n_rows - static_cast<int64_t>(test_cagra_sample_filter::offset),
           static_cast<int64_t>(index0.dataset().as_matrix_view().stride()));
-        auto merged_dataset = cuvs::neighbors::device_padded_dataset<DataT, int64_t>(
+        auto merged_dataset = cuvs::core::device_padded_dataset<DataT, int64_t>(
           std::move(merged_matrix), static_cast<uint32_t>(ps.dim));
         auto merge_idx = cuvs::neighbors::cagra::merge(
           handle_, index_params, indices, merged_dataset.as_dataset_view(), bitset_filter_obj);
@@ -1577,7 +1577,7 @@ class AnnCagraIndexMergeTest : public ::testing::TestWithParam<AnnCagraInputs> {
             static_cast<int64_t>(index0.size()) + static_cast<int64_t>(index1.size());
           auto merged_matrix = raft::make_device_matrix<DataT, int64_t>(
             handle_, merged_rows, static_cast<int64_t>(index0.dataset().as_matrix_view().stride()));
-          auto merged_dataset = cuvs::neighbors::device_padded_dataset<DataT, int64_t>(
+          auto merged_dataset = cuvs::core::device_padded_dataset<DataT, int64_t>(
             std::move(merged_matrix), static_cast<uint32_t>(ps.dim));
           auto merged_idx =
             ps.physical_merge_params.has_value()
diff --git a/cpp/tests/neighbors/ann_cagra/bug_graph_smaller_than_dataset.cu b/cpp/tests/neighbors/ann_cagra/bug_graph_smaller_than_dataset.cu
index a6ad284a1a..a60215eab5 100644
--- a/cpp/tests/neighbors/ann_cagra/bug_graph_smaller_than_dataset.cu
+++ b/cpp/tests/neighbors/ann_cagra/bug_graph_smaller_than_dataset.cu
@@ -83,10 +83,10 @@ class cagra_graph_smaller_than_dataset_test : public ::testing::Test {
 
     // Step 2: Update to FULL dataset (1000 points) but keep small graph (500 nodes)
     // This creates the exact bug scenario: dataset.size=1000, graph.extent(0)=500
-    small_index = cagra::update_dataset(res,
-                                        std::move(small_index),
-                                        cuvs::neighbors::make_device_padded_dataset_view(
-                                          res, raft::make_const_mdspan(dataset.view())));
+    small_index = cagra::update_dataset(
+      res,
+      std::move(small_index),
+      cuvs::core::make_device_padded_dataset_view(res, raft::make_const_mdspan(dataset.view())));
 
     // Verify the mismatch - THIS IS THE BUG SCENARIO!
     ASSERT_EQ(small_index.graph().extent(0), n_graph);  // Graph has 500 nodes
diff --git a/cpp/tests/neighbors/ann_cagra/test_filter_udf.cu b/cpp/tests/neighbors/ann_cagra/test_filter_udf.cu
index 68794c3151..ad9370e158 100644
--- a/cpp/tests/neighbors/ann_cagra/test_filter_udf.cu
+++ b/cpp/tests/neighbors/ann_cagra/test_filter_udf.cu
@@ -126,10 +126,10 @@ class CagraUdfFilterTest : public ::testing::TestWithParam<cagra::search_algo> {
     index_params.graph_build_params =
       cagra::graph_build_params::nn_descent_params(index_params.intermediate_graph_degree);
 
-    index.emplace(cagra::build(res,
-                               index_params,
-                               cuvs::neighbors::make_device_padded_dataset_view(
-                                 res, raft::make_const_mdspan(dataset->view()))));
+    index.emplace(cagra::build(
+      res,
+      index_params,
+      cuvs::core::make_device_padded_dataset_view(res, raft::make_const_mdspan(dataset->view()))));
     raft::resource::sync_stream(res);
   }
 
@@ -205,10 +205,10 @@ class CagraUdfFilterHalfTest : public ::testing::TestWithParam<cagra::search_alg
     index_params.graph_build_params =
       cagra::graph_build_params::nn_descent_params(index_params.intermediate_graph_degree);
 
-    index.emplace(cagra::build(res,
-                               index_params,
-                               cuvs::neighbors::make_device_padded_dataset_view(
-                                 res, raft::make_const_mdspan(dataset->view()))));
+    index.emplace(cagra::build(
+      res,
+      index_params,
+      cuvs::core::make_device_padded_dataset_view(res, raft::make_const_mdspan(dataset->view()))));
     raft::resource::sync_stream(res);
   }
 
diff --git a/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu b/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu
index b817d540ab..bbf54d9892 100644
--- a/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu
+++ b/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu
@@ -57,7 +57,7 @@ inline auto make_ranges(raft::resources const& res,
 template <typename T>
 struct padded_storage {
   raft::device_matrix<T, int64_t> matrix;
-  cuvs::neighbors::device_padded_dataset_view<T, int64_t> view;
+  cuvs::core::device_padded_dataset_view<T, int64_t> view;
 };
 
 template <typename T>
@@ -66,7 +66,7 @@ auto make_padded(raft::resources const& res, raft::host_matrix_view<const T, int
 {
   auto stream       = raft::resource::get_cuda_stream(res);
   auto const dim    = static_cast<uint32_t>(src.extent(1));
-  auto const stride = cuvs::neighbors::cagra_required_row_width<T>(dim, 16);
+  auto const stride = cuvs::core::cagra_required_row_width<T>(dim, 16);
   auto matrix =
     raft::make_device_matrix<T, int64_t>(res, src.extent(0), static_cast<int64_t>(stride));
   RAFT_CUDA_TRY(cudaMemsetAsync(
@@ -79,8 +79,8 @@ auto make_padded(raft::resources const& res, raft::host_matrix_view<const T, int
                     static_cast<size_t>(src.extent(0)),
                     stream);
   raft::resource::sync_stream(res);
-  cuvs::neighbors::device_padded_dataset_view<T, int64_t> view(
-    raft::make_const_mdspan(matrix.view()), dim);
+  cuvs::core::device_padded_dataset_view<T, int64_t> view(raft::make_const_mdspan(matrix.view()),
+                                                          dim);
   return padded_storage<T>{std::move(matrix), view};
 }
 
@@ -88,10 +88,10 @@ auto make_padded(raft::resources const& res, raft::host_matrix_view<const T, int
 template <typename T>
 auto make_merged_storage(raft::resources const& res, int64_t rows, int64_t dim) -> padded_storage<T>
 {
-  auto const stride = cuvs::neighbors::cagra_required_row_width<T>(static_cast<uint32_t>(dim), 16);
+  auto const stride = cuvs::core::cagra_required_row_width<T>(static_cast<uint32_t>(dim), 16);
   auto matrix       = raft::make_device_matrix<T, int64_t>(res, rows, static_cast<int64_t>(stride));
-  cuvs::neighbors::device_padded_dataset_view<T, int64_t> view(
-    raft::make_const_mdspan(matrix.view()), static_cast<uint32_t>(dim));
+  cuvs::core::device_padded_dataset_view<T, int64_t> view(raft::make_const_mdspan(matrix.view()),
+                                                          static_cast<uint32_t>(dim));
   return padded_storage<T>{std::move(matrix), view};
 }
 
diff --git a/cpp/tests/neighbors/ann_hnsw_ace.cuh b/cpp/tests/neighbors/ann_hnsw_ace.cuh
index 90a3e46caf..2716e028ad 100644
--- a/cpp/tests/neighbors/ann_hnsw_ace.cuh
+++ b/cpp/tests/neighbors/ann_hnsw_ace.cuh
@@ -108,7 +108,7 @@ void build_ace_with_workspace(raft::resources const& resources,
   ace_params.use_disk        = true;
   params.graph_build_params  = ace_params;
 
-  auto dataset_view           = cuvs::neighbors::make_host_standard_dataset_view(dataset);
+  auto dataset_view           = cuvs::core::make_host_standard_dataset_view(dataset);
   [[maybe_unused]] auto index = cagra::build(resources, params, dataset_view);
 }
 
diff --git a/cpp/tests/neighbors/cagra_padded_build_helpers.cuh b/cpp/tests/neighbors/cagra_padded_build_helpers.cuh
index 215b845d9d..b45c4cbd5c 100644
--- a/cpp/tests/neighbors/cagra_padded_build_helpers.cuh
+++ b/cpp/tests/neighbors/cagra_padded_build_helpers.cuh
@@ -20,8 +20,8 @@ namespace cuvs::neighbors::test {
  */
 template <typename DataT>
 struct padded_device_matrix_for_cagra {
-  std::unique_ptr<cuvs::neighbors::device_padded_dataset<DataT, int64_t>> owned;
-  cuvs::neighbors::device_padded_dataset_view<DataT, int64_t> view;
+  std::unique_ptr<cuvs::core::device_padded_dataset<DataT, int64_t>> owned;
+  cuvs::core::device_padded_dataset_view<DataT, int64_t> view;
 
   padded_device_matrix_for_cagra(
     raft::resources const& res, raft::device_matrix_view<const DataT, int64_t, raft::row_major> src)
@@ -31,8 +31,8 @@ struct padded_device_matrix_for_cagra {
 
  private:
   struct build_result {
-    std::unique_ptr<cuvs::neighbors::device_padded_dataset<DataT, int64_t>> owned;
-    cuvs::neighbors::device_padded_dataset_view<DataT, int64_t> view;
+    std::unique_ptr<cuvs::core::device_padded_dataset<DataT, int64_t>> owned;
+    cuvs::core::device_padded_dataset_view<DataT, int64_t> view;
   };
 
   // device_padded_dataset_view has no default constructor; fill both members from one build step.
@@ -46,10 +46,10 @@ struct padded_device_matrix_for_cagra {
     -> build_result
   {
     using namespace cuvs::neighbors;
-    if (matrix_row_width_matches_cagra_required(src)) {
-      return build_result{nullptr, make_device_padded_dataset_view(res, src)};
+    if (cuvs::core::matrix_row_width_matches_cagra_required(src)) {
+      return build_result{nullptr, cuvs::core::make_device_padded_dataset_view(res, src)};
     } else {
-      auto own = make_device_padded_dataset(res, src);
+      auto own = cuvs::core::make_device_padded_dataset(res, src);
       auto vw  = own->as_dataset_view();
       return build_result{std::move(own), vw};
     }
diff --git a/cpp/tests/neighbors/dynamic_batching/test_cagra.cu b/cpp/tests/neighbors/dynamic_batching/test_cagra.cu
index 03669d15dd..ddee181daa 100644
--- a/cpp/tests/neighbors/dynamic_batching/test_cagra.cu
+++ b/cpp/tests/neighbors/dynamic_batching/test_cagra.cu
@@ -20,7 +20,7 @@ auto build_cagra_with_dataset(raft::resources const& res,
                               raft::device_matrix_view<const T, int64_t, raft::row_major> dataset)
   -> cagra::device_padded_index<T, IdxT>
 {
-  auto padded = cuvs::neighbors::make_device_padded_dataset_view(res, dataset);
+  auto padded = cuvs::core::make_device_padded_dataset_view(res, dataset);
   auto index  = cagra::build(res, params, padded);
   index       = cagra::update_dataset(res, std::move(index), padded);
   return index;
diff --git a/cpp/tests/neighbors/mg.cuh b/cpp/tests/neighbors/mg.cuh
index 336563d9c4..e1023f0452 100644
--- a/cpp/tests/neighbors/mg.cuh
+++ b/cpp/tests/neighbors/mg.cuh
@@ -226,7 +226,7 @@ class AnnMGTest : public ::testing::TestWithParam<AnnMGInputs> {
 
       auto index_dataset = raft::make_host_matrix_view<const DataT, int64_t, row_major>(
         h_index_dataset.data(), ps.num_db_vecs, ps.dim);
-      auto index_dataset_view = cuvs::neighbors::make_host_standard_dataset_view(index_dataset);
+      auto index_dataset_view = cuvs::core::make_host_standard_dataset_view(index_dataset);
       auto queries            = raft::make_host_matrix_view<const DataT, int64_t, row_major>(
         h_queries.data(), ps.num_queries, ps.dim);
       auto neighbors = raft::make_host_matrix_view<int64_t, int64_t, row_major>(
@@ -248,7 +248,7 @@ class AnnMGTest : public ::testing::TestWithParam<AnnMGInputs> {
       auto index_dataset_device = raft::make_device_matrix_view<const DataT, int64_t>(
         d_index_dataset.data(), ps.num_db_vecs, ps.dim);
       auto padded_index_dataset =
-        cuvs::neighbors::make_device_padded_dataset_view(clique_, index_dataset_device);
+        cuvs::core::make_device_padded_dataset_view(clique_, index_dataset_device);
       auto search_index =
         cuvs::neighbors::cagra::update_dataset(clique_, std::move(new_index), padded_index_dataset);
 
@@ -387,7 +387,7 @@ class AnnMGTest : public ::testing::TestWithParam<AnnMGInputs> {
       {
         auto index_dataset = raft::make_device_matrix_view<const DataT, int64_t>(
           d_index_dataset.data(), ps.num_db_vecs, ps.dim);
-        auto standard_view = cuvs::neighbors::make_device_standard_dataset_view(index_dataset);
+        auto standard_view = cuvs::core::make_device_standard_dataset_view(index_dataset);
         auto index         = cuvs::neighbors::cagra::build(clique_, index_params, standard_view);
         cuvs::neighbors::cagra::serialize(clique_, index_file.filename, index);
       }
@@ -408,7 +408,7 @@ class AnnMGTest : public ::testing::TestWithParam<AnnMGInputs> {
       auto index_dataset_device = raft::make_device_matrix_view<const DataT, int64_t>(
         d_index_dataset.data(), ps.num_db_vecs, ps.dim);
       auto padded_index_dataset =
-        cuvs::neighbors::make_device_padded_dataset_view(clique_, index_dataset_device);
+        cuvs::core::make_device_padded_dataset_view(clique_, index_dataset_device);
       auto search_index = cuvs::neighbors::cagra::update_dataset(
         clique_, std::move(distributed_index), padded_index_dataset);
 
@@ -585,7 +585,7 @@ class AnnMGTest : public ::testing::TestWithParam<AnnMGInputs> {
 
       auto index_dataset = raft::make_host_matrix_view<const DataT, int64_t, row_major>(
         h_index_dataset.data(), ps.num_db_vecs, ps.dim);
-      auto index_dataset_view = cuvs::neighbors::make_host_standard_dataset_view(index_dataset);
+      auto index_dataset_view = cuvs::core::make_host_standard_dataset_view(index_dataset);
       auto small_batch_query  = raft::make_host_matrix_view<const DataT, int64_t, row_major>(
         h_queries.data(), ps.num_queries, ps.dim);
 
@@ -593,7 +593,7 @@ class AnnMGTest : public ::testing::TestWithParam<AnnMGInputs> {
       auto index_dataset_device = raft::make_device_matrix_view<const DataT, int64_t>(
         d_index_dataset.data(), ps.num_db_vecs, ps.dim);
       auto padded_index_dataset =
-        cuvs::neighbors::make_device_padded_dataset_view(clique_, index_dataset_device);
+        cuvs::core::make_device_padded_dataset_view(clique_, index_dataset_device);
       auto search_index =
         cuvs::neighbors::cagra::update_dataset(clique_, std::move(index), padded_index_dataset);
 
diff --git a/cpp/tests/neighbors/tiered_index.cu b/cpp/tests/neighbors/tiered_index.cu
index 5c71c31319..0d4772ac28 100644
--- a/cpp/tests/neighbors/tiered_index.cu
+++ b/cpp/tests/neighbors/tiered_index.cu
@@ -163,16 +163,15 @@ class ANNTieredIndexTest : public ::testing::TestWithParam<AnnTieredIndexInputs>
       if constexpr (std::is_same_v<UpstreamT, cagra::device_standard_index<float, uint32_t>>) {
         auto full_database_view = raft::make_device_matrix_view<const value_type, int64_t>(
           (const value_type*)database.data(), ps.n_rows, ps.dim);
-        if (cuvs::neighbors::matrix_row_width_matches_cagra_required(full_database_view)) {
+        if (cuvs::core::matrix_row_width_matches_cagra_required(full_database_view)) {
           auto padded_view =
-            cuvs::neighbors::make_device_padded_dataset_view(handle_, full_database_view);
+            cuvs::core::make_device_padded_dataset_view(handle_, full_database_view);
           auto attached_index = cuvs::neighbors::tiered_index::convert_standard_to_padded_index(
             handle_, *final_index, padded_view);
           cuvs::neighbors::tiered_index::search(
             handle_, search_params, attached_index, queries_view, indices_view, distances_view);
         } else {
-          auto padded_dataset =
-            cuvs::neighbors::make_device_padded_dataset(handle_, full_database_view);
+          auto padded_dataset = cuvs::core::make_device_padded_dataset(handle_, full_database_view);
           auto attached_index = cuvs::neighbors::tiered_index::convert_standard_to_padded_index(
             handle_, *final_index, padded_dataset->as_dataset_view());
           cuvs::neighbors::tiered_index::search(
diff --git a/cpp/tests/preprocessing/product_quantization.cu b/cpp/tests/preprocessing/product_quantization.cu
index cc14c9c5d2..7e98bdd2ff 100644
--- a/cpp/tests/preprocessing/product_quantization.cu
+++ b/cpp/tests/preprocessing/product_quantization.cu
@@ -351,7 +351,7 @@ TEST(ProductQuantizationTestF, MakeVpqDatasetFromPaddedView)
              host_rows.data_handle(),
              host_rows.size(),
              raft::resource::get_cuda_stream(handle));
-  cuvs::neighbors::device_padded_dataset_view<float, int64_t> padded(
+  cuvs::core::device_padded_dataset_view<float, int64_t> padded(
     raft::make_device_matrix_view<const float, int64_t>(device_rows.data_handle(), n_rows, stride),
     dim);
 
diff --git a/examples/cpp/src/cagra_bloom_filter_example.cu b/examples/cpp/src/cagra_bloom_filter_example.cu
index f84ab08fd9..444ae13f9e 100644
--- a/examples/cpp/src/cagra_bloom_filter_example.cu
+++ b/examples/cpp/src/cagra_bloom_filter_example.cu
@@ -71,7 +71,7 @@ int main()
 
   std::cout << "Building CAGRA index" << std::endl;
   auto padded =
-    cuvs::neighbors::make_device_padded_dataset_view(res, raft::make_const_mdspan(dataset.view()));
+    cuvs::core::make_device_padded_dataset_view(res, raft::make_const_mdspan(dataset.view()));
   auto index = cuvs::neighbors::cagra::build(res, index_params, padded);
   index      = cuvs::neighbors::cagra::update_dataset(res, std::move(index), padded);
 
diff --git a/examples/cpp/src/cagra_example.cu b/examples/cpp/src/cagra_example.cu
index 5fa5c55f6e..4e52c07207 100644
--- a/examples/cpp/src/cagra_example.cu
+++ b/examples/cpp/src/cagra_example.cu
@@ -34,7 +34,7 @@ void cagra_build_search_simple(raft::device_resources const& dev_resources,
   cagra::index_params index_params;
 
   std::cout << "Building CAGRA index (search graph)" << std::endl;
-  auto padded = cuvs::neighbors::make_device_padded_dataset_view(dev_resources, dataset);
+  auto padded = cuvs::core::make_device_padded_dataset_view(dev_resources, dataset);
   auto index  = cagra::build(dev_resources, index_params, padded);
   index       = cagra::update_dataset(dev_resources, std::move(index), padded);
 
diff --git a/examples/cpp/src/cagra_filter_udf_example.cu b/examples/cpp/src/cagra_filter_udf_example.cu
index 23b3a316cc..a4ade31e3d 100644
--- a/examples/cpp/src/cagra_filter_udf_example.cu
+++ b/examples/cpp/src/cagra_filter_udf_example.cu
@@ -146,7 +146,7 @@ int main()
     index_params.intermediate_graph_degree);
 
   std::cout << "Building CAGRA index" << std::endl;
-  auto padded = cuvs::neighbors::make_device_padded_dataset_view(res, dataset.view());
+  auto padded = cuvs::core::make_device_padded_dataset_view(res, dataset.view());
   auto index  = cuvs::neighbors::cagra::build(res, index_params, padded);
   index       = cuvs::neighbors::cagra::update_dataset(res, std::move(index), padded);
 
diff --git a/examples/cpp/src/cagra_hnsw_ace_example.cu b/examples/cpp/src/cagra_hnsw_ace_example.cu
index e27d4dfa47..df57a9b5e7 100644
--- a/examples/cpp/src/cagra_hnsw_ace_example.cu
+++ b/examples/cpp/src/cagra_hnsw_ace_example.cu
@@ -68,7 +68,7 @@ void cagra_build_search_ace(raft::device_resources const& dev_resources,
     dataset_host.data_handle(), dataset_host.extent(0), dataset_host.extent(1));
   // Wrap in a host_padded_dataset_view. ACE graph construction is host-side CPU work and does not
   // require CUDA row-alignment; construct the view directly to avoid the alignment check.
-  cuvs::neighbors::host_padded_dataset_view<float, int64_t> host_padded_view(
+  cuvs::core::host_padded_dataset_view<float, int64_t> host_padded_view(
     dataset_host_view, static_cast<uint32_t>(dataset_host_view.extent(1)));
 
   std::cout << "Building CAGRA index (search graph)" << std::endl;
@@ -87,7 +87,7 @@ void cagra_build_search_ace(raft::device_resources const& dev_resources,
   hnsw_params.hierarchy = hnsw::HnswHierarchy::GPU;  // Offload hierarchy construction to GPU
 
   std::unique_ptr<hnsw::index<float>> hnsw_index;
-  std::unique_ptr<cuvs::neighbors::device_padded_dataset<float, int64_t>> padded_owner;
+  std::unique_ptr<cuvs::core::device_padded_dataset<float, int64_t>> padded_owner;
   if (ace_host_index.dataset_fd().has_value()) {
     // Disk ACE path: ACE artifacts (dataset, graph, mapping) live on disk. Transfer file
     // descriptors to a device index so from_cagra can serialize to hnsw_index.bin on disk.
@@ -98,7 +98,7 @@ void cagra_build_search_ace(raft::device_resources const& dev_resources,
   } else {
     // In-memory ACE path: graph is in host memory. Upload the original dataset to device and
     // attach it before from_cagra builds the HNSW hierarchy in memory.
-    padded_owner = cuvs::neighbors::make_device_padded_dataset(dev_resources, dataset_host_view);
+    padded_owner      = cuvs::core::make_device_padded_dataset(dev_resources, dataset_host_view);
     auto device_index = cagra::update_dataset(
       dev_resources, std::move(ace_host_index), padded_owner->as_dataset_view());
     hnsw_index = hnsw::from_cagra(dev_resources, hnsw_params, device_index, dataset_host_view);
diff --git a/examples/cpp/src/cagra_persistent_example.cu b/examples/cpp/src/cagra_persistent_example.cu
index ccc5930efd..24bbd6e13e 100644
--- a/examples/cpp/src/cagra_persistent_example.cu
+++ b/examples/cpp/src/cagra_persistent_example.cu
@@ -70,7 +70,7 @@ void cagra_build_search_variants(raft::device_resources const& res,
   cagra::index_params index_params;
 
   std::cout << "Building CAGRA index (search graph)" << std::endl;
-  auto padded = cuvs::neighbors::make_device_padded_dataset_view(res, dataset);
+  auto padded = cuvs::core::make_device_padded_dataset_view(res, dataset);
   auto index  = cagra::build(res, index_params, padded);
   index       = cagra::update_dataset(res, std::move(index), padded);
 
diff --git a/examples/cpp/src/cagra_roaring_bitmap_filter_example.cu b/examples/cpp/src/cagra_roaring_bitmap_filter_example.cu
index 929fcaa5a5..e5261aef72 100644
--- a/examples/cpp/src/cagra_roaring_bitmap_filter_example.cu
+++ b/examples/cpp/src/cagra_roaring_bitmap_filter_example.cu
@@ -45,7 +45,7 @@ int main()
   index_params.graph_degree              = 32;
   index_params.intermediate_graph_degree = 64;
   auto padded =
-    cuvs::neighbors::make_device_padded_dataset_view(res, raft::make_const_mdspan(dataset.view()));
+    cuvs::core::make_device_padded_dataset_view(res, raft::make_const_mdspan(dataset.view()));
   auto index = cuvs::neighbors::cagra::build(res, index_params, padded);
 
   // Each owner is independently reusable. The filter supplies the query-to-allowlist mapping by
diff --git a/examples/cpp/src/dynamic_batching_example.cu b/examples/cpp/src/dynamic_batching_example.cu
index 2745b5e4a7..b8666be49b 100644
--- a/examples/cpp/src/dynamic_batching_example.cu
+++ b/examples/cpp/src/dynamic_batching_example.cu
@@ -116,7 +116,7 @@ void dynamic_batching_example(raft::resources const& res,
   cagra::index_params orig_index_params;
 
   std::cout << "Building CAGRA index (search graph)" << std::endl;
-  auto padded     = cuvs::neighbors::make_device_padded_dataset_view(res, dataset);
+  auto padded     = cuvs::core::make_device_padded_dataset_view(res, dataset);
   auto orig_index = cagra::build(res, orig_index_params, padded);
   orig_index      = cagra::update_dataset(res, std::move(orig_index), padded);
 
diff --git a/fern/pages/cpp_api/cpp-api-core-dataset.md b/fern/pages/cpp_api/cpp-api-core-dataset.md
index 9115c01f45..ed9d79cb79 100644
--- a/fern/pages/cpp_api/cpp-api-core-dataset.md
+++ b/fern/pages/cpp_api/cpp-api-core-dataset.md
@@ -8,8 +8,8 @@ _Source header: `cuvs/core/dataset.hpp`_
 
 ## Types
 
-<a id="neighbors-dataset"></a>
-### neighbors::dataset
+<a id="core-dataset"></a>
+### core::dataset
 
 Spec-based `dataset` / `dataset_view`.
 
@@ -20,8 +20,8 @@ template <typename T, typename IdxT, typename SpecT>
 struct dataset;
 ```
 
-<a id="neighbors-dataset"></a>
-### neighbors::dataset
+<a id="core-dataset"></a>
+### core::dataset
 
 Owning dataset: value-held payload (no shared_ptr -- exclusive ownership). Every member is a
 
@@ -32,8 +32,8 @@ template <typename T, typename IdxT, typename SpecT>
 struct dataset;
 ```
 
-<a id="neighbors-dataset-view"></a>
-### neighbors::dataset_view
+<a id="core-dataset-view"></a>
+### core::dataset_view
 
 Non-owning dataset view: holds only the view-shaped payload. Deliberately not derived from
 
@@ -44,8 +44,8 @@ template <typename T, typename IdxT, typename SpecT>
 struct dataset_view;
 ```
 
-<a id="neighbors-is-padded-dataset"></a>
-### neighbors::is_padded_dataset
+<a id="core-is-padded-dataset"></a>
+### core::is_padded_dataset
 
 Owning-side kind traits (true for both `dataset&lt;...&gt;` and `dataset_view&lt;...&gt;` of that kind).
 
@@ -54,8 +54,8 @@ template <typename DatasetT>
 struct is_padded_dataset;
 ```
 
-<a id="neighbors-is-dataset-view"></a>
-### neighbors::is_dataset_view
+<a id="core-is-dataset-view"></a>
+### core::is_dataset_view
 
 True for any `dataset_view&lt;...&gt;` specialization. Evaluates to `false` (never a hard error) for
 
@@ -66,8 +66,8 @@ template <typename V>
 struct is_dataset_view;
 ```
 
-<a id="neighbors-dataset-view-has-spec"></a>
-### neighbors::dataset_view_has_spec
+<a id="core-dataset-view-has-spec"></a>
+### core::dataset_view_has_spec
 
 True when `V` is a `dataset_view` whose spec satisfies the predicate `SpecPred&lt;SpecT&gt;::value`.
 
@@ -78,8 +78,8 @@ template <typename V, template <typename> typename SpecPred>
 struct dataset_view_has_spec;
 ```
 
-<a id="neighbors-dataset-view-is-device-accessible"></a>
-### neighbors::dataset_view_is_device_accessible
+<a id="core-dataset-view-is-device-accessible"></a>
+### core::dataset_view_is_device_accessible
 
 True when the dataset view accessor is device-accessible.
 
@@ -88,8 +88,8 @@ template <typename V>
 struct dataset_view_is_device_accessible;
 ```
 
-<a id="neighbors-with-accessor"></a>
-### neighbors::with_accessor
+<a id="core-with-accessor"></a>
+### core::with_accessor
 
 Generic accessor retargeting while preserving the spec kind and value/index types:
 
@@ -100,8 +100,8 @@ template <typename DatasetLikeT, typename NewAccessor>
 struct with_accessor;
 ```
 
-<a id="neighbors-to-device-accessor"></a>
-### neighbors::to_device_accessor
+<a id="core-to-device-accessor"></a>
+### core::to_device_accessor
 
 Map any host accessor to its device counterpart (same payload policy).
 
@@ -110,8 +110,8 @@ template <typename Accessor>
 struct to_device_accessor;
 ```
 
-<a id="neighbors-device-counterpart"></a>
-### neighbors::device_counterpart
+<a id="core-device-counterpart"></a>
+### core::device_counterpart
 
 Maps a host dataset view type to its device-resident counterpart.
 
diff --git a/fern/pages/cpp_api/cpp-api-neighbors-cagra.md b/fern/pages/cpp_api/cpp-api-neighbors-cagra.md
index 33930d4da8..056f7133d2 100644
--- a/fern/pages/cpp_api/cpp-api-neighbors-cagra.md
+++ b/fern/pages/cpp_api/cpp-api-neighbors-cagra.md
@@ -220,7 +220,8 @@ The index stores the dataset and a kNN graph in device memory.
 ```cpp
 template <typename T,
 typename IdxT,
-ann_dataset_view DatasetViewT = device_padded_dataset_view<T, int64_t>>
+cuvs::core::ann_dataset_view DatasetViewT =
+cuvs::core::device_padded_dataset_view<T, int64_t>>
 struct index;
 ```
 
@@ -410,7 +411,7 @@ Construct a graph-only index with a zero-row dataset view placeholder.
 ```cpp
 explicit index(raft::resources const& res,
 cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Expanded)
-requires(cuvs::neighbors::ann_dataset_view<DatasetViewT, int64_t>)
+requires(cuvs::core::ann_dataset_view<DatasetViewT, int64_t>)
 : cuvs::neighbors::index(),;
 ```
 
@@ -672,7 +673,7 @@ Build from a device padded dataset view (`float`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::device_padded_dataset_view<float, int64_t> const& dataset)
+cuvs::core::device_padded_dataset_view<float, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::device_padded_index<float, uint32_t>;
 ```
 
@@ -682,7 +683,7 @@ cuvs::neighbors::device_padded_dataset_view<float, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::device_padded_dataset_view<float, int64_t> const&` | device padded dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::device_padded_dataset_view<float, int64_t> const&` | device padded dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -697,7 +698,7 @@ Build from a device standard dataset view (`float`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::device_standard_dataset_view<float, int64_t> const& dataset)
+cuvs::core::device_standard_dataset_view<float, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::device_standard_index<float, uint32_t>;
 ```
 
@@ -707,7 +708,7 @@ cuvs::neighbors::device_standard_dataset_view<float, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::device_standard_dataset_view<float, int64_t> const&` | device standard dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::device_standard_dataset_view<float, int64_t> const&` | device standard dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -722,7 +723,7 @@ Build from a host padded dataset view (`float`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::host_padded_dataset_view<float, int64_t> const& dataset)
+cuvs::core::host_padded_dataset_view<float, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::host_padded_index<float, uint32_t>;
 ```
 
@@ -732,7 +733,7 @@ cuvs::neighbors::host_padded_dataset_view<float, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::host_padded_dataset_view<float, int64_t> const&` | host padded dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::host_padded_dataset_view<float, int64_t> const&` | host padded dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -747,7 +748,7 @@ Build from a host standard dataset view (`float`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::host_standard_dataset_view<float, int64_t> const& dataset)
+cuvs::core::host_standard_dataset_view<float, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::host_standard_index<float, uint32_t>;
 ```
 
@@ -757,7 +758,7 @@ cuvs::neighbors::host_standard_dataset_view<float, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::host_standard_dataset_view<float, int64_t> const&` | host standard dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::host_standard_dataset_view<float, int64_t> const&` | host standard dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -772,7 +773,7 @@ Build from a device padded dataset view (`half`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::device_padded_dataset_view<half, int64_t> const& dataset)
+cuvs::core::device_padded_dataset_view<half, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::device_padded_index<half, uint32_t>;
 ```
 
@@ -782,7 +783,7 @@ cuvs::neighbors::device_padded_dataset_view<half, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::device_padded_dataset_view<half, int64_t> const&` | device padded dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::device_padded_dataset_view<half, int64_t> const&` | device padded dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -797,7 +798,7 @@ Build from a device standard dataset view (`half`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::device_standard_dataset_view<half, int64_t> const& dataset)
+cuvs::core::device_standard_dataset_view<half, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::device_standard_index<half, uint32_t>;
 ```
 
@@ -807,7 +808,7 @@ cuvs::neighbors::device_standard_dataset_view<half, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::device_standard_dataset_view<half, int64_t> const&` | device standard dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::device_standard_dataset_view<half, int64_t> const&` | device standard dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -822,7 +823,7 @@ Build from a host padded dataset view (`half`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::host_padded_dataset_view<half, int64_t> const& dataset)
+cuvs::core::host_padded_dataset_view<half, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::host_padded_index<half, uint32_t>;
 ```
 
@@ -832,7 +833,7 @@ cuvs::neighbors::host_padded_dataset_view<half, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::host_padded_dataset_view<half, int64_t> const&` | host padded dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::host_padded_dataset_view<half, int64_t> const&` | host padded dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -847,7 +848,7 @@ Build from a host standard dataset view (`half`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::host_standard_dataset_view<half, int64_t> const& dataset)
+cuvs::core::host_standard_dataset_view<half, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::host_standard_index<half, uint32_t>;
 ```
 
@@ -857,7 +858,7 @@ cuvs::neighbors::host_standard_dataset_view<half, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::host_standard_dataset_view<half, int64_t> const&` | host standard dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::host_standard_dataset_view<half, int64_t> const&` | host standard dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -872,7 +873,7 @@ Build from a device padded dataset view (`int8_t`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::device_padded_dataset_view<int8_t, int64_t> const& dataset)
+cuvs::core::device_padded_dataset_view<int8_t, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::device_padded_index<int8_t, uint32_t>;
 ```
 
@@ -882,7 +883,7 @@ cuvs::neighbors::device_padded_dataset_view<int8_t, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::device_padded_dataset_view<int8_t, int64_t> const&` | device padded dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::device_padded_dataset_view<int8_t, int64_t> const&` | device padded dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -897,7 +898,7 @@ Build from a device standard dataset view (`int8_t`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::device_standard_dataset_view<int8_t, int64_t> const& dataset)
+cuvs::core::device_standard_dataset_view<int8_t, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::device_standard_index<int8_t, uint32_t>;
 ```
 
@@ -907,7 +908,7 @@ cuvs::neighbors::device_standard_dataset_view<int8_t, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::device_standard_dataset_view<int8_t, int64_t> const&` | device standard dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::device_standard_dataset_view<int8_t, int64_t> const&` | device standard dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -922,7 +923,7 @@ Build from a host padded dataset view (`int8_t`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::host_padded_dataset_view<int8_t, int64_t> const& dataset)
+cuvs::core::host_padded_dataset_view<int8_t, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::host_padded_index<int8_t, uint32_t>;
 ```
 
@@ -932,7 +933,7 @@ cuvs::neighbors::host_padded_dataset_view<int8_t, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::host_padded_dataset_view<int8_t, int64_t> const&` | host padded dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::host_padded_dataset_view<int8_t, int64_t> const&` | host padded dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -947,7 +948,7 @@ Build from a host standard dataset view (`int8_t`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::host_standard_dataset_view<int8_t, int64_t> const& dataset)
+cuvs::core::host_standard_dataset_view<int8_t, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::host_standard_index<int8_t, uint32_t>;
 ```
 
@@ -957,7 +958,7 @@ cuvs::neighbors::host_standard_dataset_view<int8_t, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::host_standard_dataset_view<int8_t, int64_t> const&` | host standard dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::host_standard_dataset_view<int8_t, int64_t> const&` | host standard dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -972,7 +973,7 @@ Build from a device padded dataset view (`uint8_t`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::device_padded_dataset_view<uint8_t, int64_t> const& dataset)
+cuvs::core::device_padded_dataset_view<uint8_t, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::device_padded_index<uint8_t, uint32_t>;
 ```
 
@@ -982,7 +983,7 @@ cuvs::neighbors::device_padded_dataset_view<uint8_t, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::device_padded_dataset_view<uint8_t, int64_t> const&` | device padded dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::device_padded_dataset_view<uint8_t, int64_t> const&` | device padded dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -997,7 +998,7 @@ Build from a device standard dataset view (`uint8_t`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::device_standard_dataset_view<uint8_t, int64_t> const& dataset)
+cuvs::core::device_standard_dataset_view<uint8_t, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::device_standard_index<uint8_t, uint32_t>;
 ```
 
@@ -1007,7 +1008,7 @@ cuvs::neighbors::device_standard_dataset_view<uint8_t, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::device_standard_dataset_view<uint8_t, int64_t> const&` | device standard dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::device_standard_dataset_view<uint8_t, int64_t> const&` | device standard dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -1022,7 +1023,7 @@ Build from a host padded dataset view (`uint8_t`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::host_padded_dataset_view<uint8_t, int64_t> const& dataset)
+cuvs::core::host_padded_dataset_view<uint8_t, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::host_padded_index<uint8_t, uint32_t>;
 ```
 
@@ -1032,7 +1033,7 @@ cuvs::neighbors::host_padded_dataset_view<uint8_t, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::host_padded_dataset_view<uint8_t, int64_t> const&` | host padded dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::host_padded_dataset_view<uint8_t, int64_t> const&` | host padded dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -1047,7 +1048,7 @@ Build from a host standard dataset view (`uint8_t`).
 ```cpp
 auto build(raft::resources const& res,
 const cuvs::neighbors::cagra::index_params& params,
-cuvs::neighbors::host_standard_dataset_view<uint8_t, int64_t> const& dataset)
+cuvs::core::host_standard_dataset_view<uint8_t, int64_t> const& dataset)
 -> cuvs::neighbors::cagra::host_standard_index<uint8_t, uint32_t>;
 ```
 
@@ -1057,7 +1058,7 @@ cuvs::neighbors::host_standard_dataset_view<uint8_t, int64_t> const& dataset)
 | --- | --- | --- | --- |
 | `res` | in | `raft::resources const&` | raft resources |
 | `params` | in | `const cuvs::neighbors::cagra::index_params&` | CAGRA index build parameters |
-| `dataset` | in | `cuvs::neighbors::host_standard_dataset_view<uint8_t, int64_t> const&` | host standard dataset view [n_rows, dim] |
+| `dataset` | in | `cuvs::core::host_standard_dataset_view<uint8_t, int64_t> const&` | host standard dataset view [n_rows, dim] |
 
 **Returns**
 
@@ -1177,7 +1178,7 @@ Add new vectors to a CAGRA index
 ```cpp
 void extend(raft::resources const& handle,
 const cagra::extend_params& params,
-cuvs::neighbors::device_padded_dataset_view<float, int64_t> extended_dataset,
+cuvs::core::device_padded_dataset_view<float, int64_t> extended_dataset,
 int64_t new_start_row,
 cuvs::neighbors::cagra::device_padded_index<float, uint32_t>& idx);
 ```
@@ -1195,7 +1196,7 @@ Usage example:
 | --- | --- | --- | --- |
 | `handle` | in | `raft::resources const&` | raft resources |
 | `params` | in | [`const cagra::extend_params&`](/api-reference/cpp-api-neighbors-cagra#neighbors-cagra-extend-params) | extend params |
-| `extended_dataset` | in | `cuvs::neighbors::device_padded_dataset_view<float, int64_t>` | caller-owned device-padded view already containing old \|\| new rows |
+| `extended_dataset` | in | `cuvs::core::device_padded_dataset_view<float, int64_t>` | caller-owned device-padded view already containing old \|\| new rows |
 | `new_start_row` | in | `int64_t` | row index where the additional vectors begin (must equal `idx.size()`) |
 | `idx` | in,out | `cuvs::neighbors::cagra::device_padded_index<float, uint32_t>&` | CAGRA index; graph is extended and dataset view is rebound |
 
@@ -1210,7 +1211,7 @@ Add new vectors to a CAGRA index. See the float overload for the full contract.
 ```cpp
 void extend(raft::resources const& handle,
 const cagra::extend_params& params,
-cuvs::neighbors::device_padded_dataset_view<half, int64_t> extended_dataset,
+cuvs::core::device_padded_dataset_view<half, int64_t> extended_dataset,
 int64_t new_start_row,
 cuvs::neighbors::cagra::device_padded_index<half, uint32_t>& idx);
 ```
@@ -1221,7 +1222,7 @@ cuvs::neighbors::cagra::device_padded_index<half, uint32_t>& idx);
 | --- | --- | --- | --- |
 | `handle` |  | `raft::resources const&` |  |
 | `params` |  | [`const cagra::extend_params&`](/api-reference/cpp-api-neighbors-cagra#neighbors-cagra-extend-params) |  |
-| `extended_dataset` |  | `cuvs::neighbors::device_padded_dataset_view<half, int64_t>` |  |
+| `extended_dataset` |  | `cuvs::core::device_padded_dataset_view<half, int64_t>` |  |
 | `new_start_row` |  | `int64_t` |  |
 | `idx` |  | `cuvs::neighbors::cagra::device_padded_index<half, uint32_t>&` |  |
 
@@ -1236,7 +1237,7 @@ Add new vectors to a CAGRA index. See the float overload for the full contract.
 ```cpp
 void extend(raft::resources const& handle,
 const cagra::extend_params& params,
-cuvs::neighbors::device_padded_dataset_view<int8_t, int64_t> extended_dataset,
+cuvs::core::device_padded_dataset_view<int8_t, int64_t> extended_dataset,
 int64_t new_start_row,
 cuvs::neighbors::cagra::device_padded_index<int8_t, uint32_t>& idx);
 ```
@@ -1247,7 +1248,7 @@ cuvs::neighbors::cagra::device_padded_index<int8_t, uint32_t>& idx);
 | --- | --- | --- | --- |
 | `handle` |  | `raft::resources const&` |  |
 | `params` |  | [`const cagra::extend_params&`](/api-reference/cpp-api-neighbors-cagra#neighbors-cagra-extend-params) |  |
-| `extended_dataset` |  | `cuvs::neighbors::device_padded_dataset_view<int8_t, int64_t>` |  |
+| `extended_dataset` |  | `cuvs::core::device_padded_dataset_view<int8_t, int64_t>` |  |
 | `new_start_row` |  | `int64_t` |  |
 | `idx` |  | `cuvs::neighbors::cagra::device_padded_index<int8_t, uint32_t>&` |  |
 
@@ -1262,7 +1263,7 @@ Add new vectors to a CAGRA index. See the float overload for the full contract.
 ```cpp
 void extend(raft::resources const& handle,
 const cagra::extend_params& params,
-cuvs::neighbors::device_padded_dataset_view<uint8_t, int64_t> extended_dataset,
+cuvs::core::device_padded_dataset_view<uint8_t, int64_t> extended_dataset,
 int64_t new_start_row,
 cuvs::neighbors::cagra::device_padded_index<uint8_t, uint32_t>& idx);
 ```
@@ -1273,7 +1274,7 @@ cuvs::neighbors::cagra::device_padded_index<uint8_t, uint32_t>& idx);
 | --- | --- | --- | --- |
 | `handle` |  | `raft::resources const&` |  |
 | `params` |  | [`const cagra::extend_params&`](/api-reference/cpp-api-neighbors-cagra#neighbors-cagra-extend-params) |  |
-| `extended_dataset` |  | `cuvs::neighbors::device_padded_dataset_view<uint8_t, int64_t>` |  |
+| `extended_dataset` |  | `cuvs::core::device_padded_dataset_view<uint8_t, int64_t>` |  |
 | `new_start_row` |  | `int64_t` |  |
 | `idx` |  | `cuvs::neighbors::cagra::device_padded_index<uint8_t, uint32_t>&` |  |
 
@@ -1345,7 +1346,7 @@ void deserialize(
 raft::resources const& handle,
 const std::string& filename,
 cuvs::neighbors::cagra::device_padded_index<float>* index,
-std::unique_ptr<cuvs::neighbors::device_padded_dataset<float, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::device_padded_dataset<float, int64_t>>* out_dataset = nullptr);
 ```
 
 Experimental, both the API and the serialization format are subject to change.
@@ -1357,7 +1358,7 @@ Experimental, both the API and the serialization format are subject to change.
 | `handle` | in | `raft::resources const&` | the raft handle |
 | `filename` | in | `const std::string&` | the name of the file that stores the index |
 | `index` | out | `cuvs::neighbors::cagra::device_padded_index<float>*` | the cagra index |
-| `out_dataset` | out | `std::unique_ptr<cuvs::neighbors::device_padded_dataset<float, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the file includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
+| `out_dataset` | out | `std::unique_ptr<cuvs::core::device_padded_dataset<float, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the file includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
 
 **Returns**
 
@@ -1398,7 +1399,7 @@ void deserialize(
 raft::resources const& handle,
 std::istream& is,
 cuvs::neighbors::cagra::device_padded_index<float>* index,
-std::unique_ptr<cuvs::neighbors::device_padded_dataset<float, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::device_padded_dataset<float, int64_t>>* out_dataset = nullptr);
 ```
 
 Experimental, both the API and the serialization format are subject to change.
@@ -1410,7 +1411,7 @@ Experimental, both the API and the serialization format are subject to change.
 | `handle` | in | `raft::resources const&` | the raft handle |
 | `is` | in | `std::istream&` | input stream |
 | `index` | out | `cuvs::neighbors::cagra::device_padded_index<float>*` | the cagra index |
-| `out_dataset` | out | `std::unique_ptr<cuvs::neighbors::device_padded_dataset<float, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the stream includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
+| `out_dataset` | out | `std::unique_ptr<cuvs::core::device_padded_dataset<float, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the stream includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
 
 **Returns**
 
@@ -1451,7 +1452,7 @@ void deserialize(
 raft::resources const& handle,
 const std::string& filename,
 cuvs::neighbors::cagra::device_padded_index<half>* index,
-std::unique_ptr<cuvs::neighbors::device_padded_dataset<half, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::device_padded_dataset<half, int64_t>>* out_dataset = nullptr);
 ```
 
 Experimental, both the API and the serialization format are subject to change.
@@ -1463,7 +1464,7 @@ Experimental, both the API and the serialization format are subject to change.
 | `handle` | in | `raft::resources const&` | the raft handle |
 | `filename` | in | `const std::string&` | the name of the file that stores the index |
 | `index` | out | `cuvs::neighbors::cagra::device_padded_index<half>*` | the cagra index |
-| `out_dataset` | out | `std::unique_ptr<cuvs::neighbors::device_padded_dataset<half, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the file includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
+| `out_dataset` | out | `std::unique_ptr<cuvs::core::device_padded_dataset<half, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the file includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
 
 **Returns**
 
@@ -1504,7 +1505,7 @@ void deserialize(
 raft::resources const& handle,
 std::istream& is,
 cuvs::neighbors::cagra::device_padded_index<half>* index,
-std::unique_ptr<cuvs::neighbors::device_padded_dataset<half, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::device_padded_dataset<half, int64_t>>* out_dataset = nullptr);
 ```
 
 Experimental, both the API and the serialization format are subject to change.
@@ -1516,7 +1517,7 @@ Experimental, both the API and the serialization format are subject to change.
 | `handle` | in | `raft::resources const&` | the raft handle |
 | `is` | in | `std::istream&` | input stream |
 | `index` | out | `cuvs::neighbors::cagra::device_padded_index<half>*` | the cagra index |
-| `out_dataset` | out | `std::unique_ptr<cuvs::neighbors::device_padded_dataset<half, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the stream includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
+| `out_dataset` | out | `std::unique_ptr<cuvs::core::device_padded_dataset<half, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the stream includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
 
 **Returns**
 
@@ -1557,7 +1558,7 @@ void deserialize(
 raft::resources const& handle,
 const std::string& filename,
 cuvs::neighbors::cagra::device_padded_index<int8_t>* index,
-std::unique_ptr<cuvs::neighbors::device_padded_dataset<int8_t, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::device_padded_dataset<int8_t, int64_t>>* out_dataset = nullptr);
 ```
 
 Experimental, both the API and the serialization format are subject to change.
@@ -1569,7 +1570,7 @@ Experimental, both the API and the serialization format are subject to change.
 | `handle` | in | `raft::resources const&` | the raft handle |
 | `filename` | in | `const std::string&` | the name of the file that stores the index |
 | `index` | out | `cuvs::neighbors::cagra::device_padded_index<int8_t>*` | the cagra index |
-| `out_dataset` | out | `std::unique_ptr<cuvs::neighbors::device_padded_dataset<int8_t, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the file includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
+| `out_dataset` | out | `std::unique_ptr<cuvs::core::device_padded_dataset<int8_t, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the file includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
 
 **Returns**
 
@@ -1610,7 +1611,7 @@ void deserialize(
 raft::resources const& handle,
 std::istream& is,
 cuvs::neighbors::cagra::device_padded_index<int8_t>* index,
-std::unique_ptr<cuvs::neighbors::device_padded_dataset<int8_t, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::device_padded_dataset<int8_t, int64_t>>* out_dataset = nullptr);
 ```
 
 Experimental, both the API and the serialization format are subject to change.
@@ -1622,7 +1623,7 @@ Experimental, both the API and the serialization format are subject to change.
 | `handle` | in | `raft::resources const&` | the raft handle |
 | `is` | in | `std::istream&` | input stream |
 | `index` | out | `cuvs::neighbors::cagra::device_padded_index<int8_t>*` | the cagra index |
-| `out_dataset` | out | `std::unique_ptr<cuvs::neighbors::device_padded_dataset<int8_t, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the stream includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
+| `out_dataset` | out | `std::unique_ptr<cuvs::core::device_padded_dataset<int8_t, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the stream includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
 
 **Returns**
 
@@ -1663,7 +1664,7 @@ void deserialize(
 raft::resources const& handle,
 const std::string& filename,
 cuvs::neighbors::cagra::device_padded_index<uint8_t>* index,
-std::unique_ptr<cuvs::neighbors::device_padded_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::device_padded_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
 ```
 
 Experimental, both the API and the serialization format are subject to change.
@@ -1675,7 +1676,7 @@ Experimental, both the API and the serialization format are subject to change.
 | `handle` | in | `raft::resources const&` | the raft handle |
 | `filename` | in | `const std::string&` | the name of the file that stores the index |
 | `index` | out | `cuvs::neighbors::cagra::device_padded_index<uint8_t>*` | the cagra index |
-| `out_dataset` | out | `std::unique_ptr<cuvs::neighbors::device_padded_dataset<uint8_t, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the file includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
+| `out_dataset` | out | `std::unique_ptr<cuvs::core::device_padded_dataset<uint8_t, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the file includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
 
 **Returns**
 
@@ -1716,7 +1717,7 @@ void deserialize(
 raft::resources const& handle,
 std::istream& is,
 cuvs::neighbors::cagra::device_padded_index<uint8_t>* index,
-std::unique_ptr<cuvs::neighbors::device_padded_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::device_padded_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
 ```
 
 Experimental, both the API and the serialization format are subject to change.
@@ -1728,7 +1729,7 @@ Experimental, both the API and the serialization format are subject to change.
 | `handle` | in | `raft::resources const&` | the raft handle |
 | `is` | in | `std::istream&` | input stream |
 | `index` | out | `cuvs::neighbors::cagra::device_padded_index<uint8_t>*` | the cagra index |
-| `out_dataset` | out | `std::unique_ptr<cuvs::neighbors::device_padded_dataset<uint8_t, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the stream includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
+| `out_dataset` | out | `std::unique_ptr<cuvs::core::device_padded_dataset<uint8_t, int64_t>>*` | if non-null, on success may be set to an owned deserialized dataset when the stream includes dataset data; may be left unchanged otherwise. Optional; pass nullptr to ignore.<br />Default: `nullptr`. |
 
 **Returns**
 
@@ -2093,7 +2094,7 @@ void deserialize(
 raft::resources const& handle,
 const std::string& filename,
 cuvs::neighbors::cagra::host_padded_index<float>* index,
-std::unique_ptr<cuvs::neighbors::host_padded_dataset<float, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::host_padded_dataset<float, int64_t>>* out_dataset = nullptr);
 ```
 
 **Parameters**
@@ -2103,7 +2104,7 @@ std::unique_ptr<cuvs::neighbors::host_padded_dataset<float, int64_t>>* out_datas
 | `handle` |  | `raft::resources const&` |  |
 | `filename` |  | `const std::string&` |  |
 | `index` |  | `cuvs::neighbors::cagra::host_padded_index<float>*` |  |
-| `out_dataset` |  | `std::unique_ptr<cuvs::neighbors::host_padded_dataset<float, int64_t>>*` | Default: `nullptr`. |
+| `out_dataset` |  | `std::unique_ptr<cuvs::core::host_padded_dataset<float, int64_t>>*` | Default: `nullptr`. |
 
 **Returns**
 
@@ -2116,7 +2117,7 @@ void deserialize(
 raft::resources const& handle,
 const std::string& filename,
 cuvs::neighbors::cagra::host_standard_index<float>* index,
-std::unique_ptr<cuvs::neighbors::host_standard_dataset<float, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::host_standard_dataset<float, int64_t>>* out_dataset = nullptr);
 ```
 
 **Parameters**
@@ -2126,7 +2127,7 @@ std::unique_ptr<cuvs::neighbors::host_standard_dataset<float, int64_t>>* out_dat
 | `handle` |  | `raft::resources const&` |  |
 | `filename` |  | `const std::string&` |  |
 | `index` |  | `cuvs::neighbors::cagra::host_standard_index<float>*` |  |
-| `out_dataset` |  | `std::unique_ptr<cuvs::neighbors::host_standard_dataset<float, int64_t>>*` | Default: `nullptr`. |
+| `out_dataset` |  | `std::unique_ptr<cuvs::core::host_standard_dataset<float, int64_t>>*` | Default: `nullptr`. |
 
 **Returns**
 
@@ -2139,7 +2140,7 @@ void deserialize(
 raft::resources const& handle,
 const std::string& filename,
 cuvs::neighbors::cagra::host_padded_index<half>* index,
-std::unique_ptr<cuvs::neighbors::host_padded_dataset<half, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::host_padded_dataset<half, int64_t>>* out_dataset = nullptr);
 ```
 
 **Parameters**
@@ -2149,7 +2150,7 @@ std::unique_ptr<cuvs::neighbors::host_padded_dataset<half, int64_t>>* out_datase
 | `handle` |  | `raft::resources const&` |  |
 | `filename` |  | `const std::string&` |  |
 | `index` |  | `cuvs::neighbors::cagra::host_padded_index<half>*` |  |
-| `out_dataset` |  | `std::unique_ptr<cuvs::neighbors::host_padded_dataset<half, int64_t>>*` | Default: `nullptr`. |
+| `out_dataset` |  | `std::unique_ptr<cuvs::core::host_padded_dataset<half, int64_t>>*` | Default: `nullptr`. |
 
 **Returns**
 
@@ -2162,7 +2163,7 @@ void deserialize(
 raft::resources const& handle,
 const std::string& filename,
 cuvs::neighbors::cagra::host_standard_index<half>* index,
-std::unique_ptr<cuvs::neighbors::host_standard_dataset<half, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::host_standard_dataset<half, int64_t>>* out_dataset = nullptr);
 ```
 
 **Parameters**
@@ -2172,7 +2173,7 @@ std::unique_ptr<cuvs::neighbors::host_standard_dataset<half, int64_t>>* out_data
 | `handle` |  | `raft::resources const&` |  |
 | `filename` |  | `const std::string&` |  |
 | `index` |  | `cuvs::neighbors::cagra::host_standard_index<half>*` |  |
-| `out_dataset` |  | `std::unique_ptr<cuvs::neighbors::host_standard_dataset<half, int64_t>>*` | Default: `nullptr`. |
+| `out_dataset` |  | `std::unique_ptr<cuvs::core::host_standard_dataset<half, int64_t>>*` | Default: `nullptr`. |
 
 **Returns**
 
@@ -2185,7 +2186,7 @@ void deserialize(
 raft::resources const& handle,
 const std::string& filename,
 cuvs::neighbors::cagra::host_padded_index<int8_t>* index,
-std::unique_ptr<cuvs::neighbors::host_padded_dataset<int8_t, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::host_padded_dataset<int8_t, int64_t>>* out_dataset = nullptr);
 ```
 
 **Parameters**
@@ -2195,7 +2196,7 @@ std::unique_ptr<cuvs::neighbors::host_padded_dataset<int8_t, int64_t>>* out_data
 | `handle` |  | `raft::resources const&` |  |
 | `filename` |  | `const std::string&` |  |
 | `index` |  | `cuvs::neighbors::cagra::host_padded_index<int8_t>*` |  |
-| `out_dataset` |  | `std::unique_ptr<cuvs::neighbors::host_padded_dataset<int8_t, int64_t>>*` | Default: `nullptr`. |
+| `out_dataset` |  | `std::unique_ptr<cuvs::core::host_padded_dataset<int8_t, int64_t>>*` | Default: `nullptr`. |
 
 **Returns**
 
@@ -2208,7 +2209,7 @@ void deserialize(
 raft::resources const& handle,
 const std::string& filename,
 cuvs::neighbors::cagra::host_standard_index<int8_t>* index,
-std::unique_ptr<cuvs::neighbors::host_standard_dataset<int8_t, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::host_standard_dataset<int8_t, int64_t>>* out_dataset = nullptr);
 ```
 
 **Parameters**
@@ -2218,7 +2219,7 @@ std::unique_ptr<cuvs::neighbors::host_standard_dataset<int8_t, int64_t>>* out_da
 | `handle` |  | `raft::resources const&` |  |
 | `filename` |  | `const std::string&` |  |
 | `index` |  | `cuvs::neighbors::cagra::host_standard_index<int8_t>*` |  |
-| `out_dataset` |  | `std::unique_ptr<cuvs::neighbors::host_standard_dataset<int8_t, int64_t>>*` | Default: `nullptr`. |
+| `out_dataset` |  | `std::unique_ptr<cuvs::core::host_standard_dataset<int8_t, int64_t>>*` | Default: `nullptr`. |
 
 **Returns**
 
@@ -2231,7 +2232,7 @@ void deserialize(
 raft::resources const& handle,
 const std::string& filename,
 cuvs::neighbors::cagra::host_padded_index<uint8_t>* index,
-std::unique_ptr<cuvs::neighbors::host_padded_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::host_padded_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
 ```
 
 **Parameters**
@@ -2241,7 +2242,7 @@ std::unique_ptr<cuvs::neighbors::host_padded_dataset<uint8_t, int64_t>>* out_dat
 | `handle` |  | `raft::resources const&` |  |
 | `filename` |  | `const std::string&` |  |
 | `index` |  | `cuvs::neighbors::cagra::host_padded_index<uint8_t>*` |  |
-| `out_dataset` |  | `std::unique_ptr<cuvs::neighbors::host_padded_dataset<uint8_t, int64_t>>*` | Default: `nullptr`. |
+| `out_dataset` |  | `std::unique_ptr<cuvs::core::host_padded_dataset<uint8_t, int64_t>>*` | Default: `nullptr`. |
 
 **Returns**
 
@@ -2254,7 +2255,7 @@ void deserialize(
 raft::resources const& handle,
 const std::string& filename,
 cuvs::neighbors::cagra::host_standard_index<uint8_t>* index,
-std::unique_ptr<cuvs::neighbors::host_standard_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
+std::unique_ptr<cuvs::core::host_standard_dataset<uint8_t, int64_t>>* out_dataset = nullptr);
 ```
 
 **Parameters**
@@ -2264,7 +2265,7 @@ std::unique_ptr<cuvs::neighbors::host_standard_dataset<uint8_t, int64_t>>* out_d
 | `handle` |  | `raft::resources const&` |  |
 | `filename` |  | `const std::string&` |  |
 | `index` |  | `cuvs::neighbors::cagra::host_standard_index<uint8_t>*` |  |
-| `out_dataset` |  | `std::unique_ptr<cuvs::neighbors::host_standard_dataset<uint8_t, int64_t>>*` | Default: `nullptr`. |
+| `out_dataset` |  | `std::unique_ptr<cuvs::core::host_standard_dataset<uint8_t, int64_t>>*` | Default: `nullptr`. |
 
 **Returns**
 
diff --git a/fern/pages/cpp_api/cpp-api-neighbors-vamana.md b/fern/pages/cpp_api/cpp-api-neighbors-vamana.md
index d731acfb92..4606df2a73 100644
--- a/fern/pages/cpp_api/cpp-api-neighbors-vamana.md
+++ b/fern/pages/cpp_api/cpp-api-neighbors-vamana.md
@@ -138,14 +138,14 @@ Non-owning dataset view stored by the index (full-precision vectors may live in
 
 ```cpp
 [[nodiscard]] inline auto data() const noexcept
--> const cuvs::neighbors::device_padded_dataset_view<T, int64_t>&;
+-> const cuvs::core::device_padded_dataset_view<T, int64_t>&;
 ```
 
 `full_precision_storage_`).
 
 **Returns**
 
-`const cuvs::neighbors::device_padded_dataset_view<T, int64_t>&`
+`const cuvs::core::device_padded_dataset_view<T, int64_t>&`
 
 <a id="neighbors-vamana-index-quantized-data"></a>
 ### neighbors::vamana::index::quantized_data
diff --git a/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md b/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md
index 083315f0b6..55a421c7aa 100644
--- a/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md
+++ b/fern/pages/cpp_api/cpp-api-preprocessing-quantize-bbq.md
@@ -169,7 +169,7 @@ struct bbq_dataset_spec;
 <a id="preprocessing-quantize-bbq-is-bbq-spec"></a>
 ### preprocessing::quantize::bbq::is_bbq_spec
 
-Spec predicate for `cuvs::neighbors::dataset_view_has_spec_v`.
+Spec predicate for `cuvs::core::dataset_view_has_spec_v`.
 
 ```cpp
 template <typename SpecT>
diff --git a/fern/pages/cpp_api/cpp-api-preprocessing-quantize-pq.md b/fern/pages/cpp_api/cpp-api-preprocessing-quantize-pq.md
index c9be7a7226..55a46c5c81 100644
--- a/fern/pages/cpp_api/cpp-api-preprocessing-quantize-pq.md
+++ b/fern/pages/cpp_api/cpp-api-preprocessing-quantize-pq.md
@@ -133,7 +133,7 @@ struct vpq_dataset_spec;
 <a id="preprocessing-quantize-pq-is-vpq-spec"></a>
 ### preprocessing::quantize::pq::is_vpq_spec
 
-Spec predicate for `cuvs::neighbors::dataset_view_has_spec_v`.
+Spec predicate for `cuvs::core::dataset_view_has_spec_v`.
 
 ```cpp
 template <typename SpecT>
@@ -341,7 +341,7 @@ vpq_params const& params,
 SrcT const& src) -> device_vpq_dataset<half, int64_t>;
 ```
 
-Accepts either a row-major mdspan with `value_type`, `extent`, `stride`, and `data_handle` (same pattern as `cuvs::neighbors::make_device_padded_dataset`), or any cuVS dense dataset / dataset view exposing `view`, `dim` and `stride`, in which case the logical `dim()` is quantized and the row padding is skipped. The rows may be device-accessible or host-resident. Device-accessible rows (device, managed or pinned) with tight row-major storage (logical stride equals dimension) are passed through to training as they are; a wider row pitch triggers a contiguous dense copy first. Host-resident rows are subsampled for training and encoded in bounded batches, so the dense dataset is never staged on the device in full; they must be tightly packed. Empty sources are rejected. The element type must be `float`, `half`, `int8_t` or `uint8_t`.
+Accepts either a row-major mdspan with `value_type`, `extent`, `stride`, and `data_handle` (same pattern as `cuvs::core::make_device_padded_dataset`), or any cuVS dense dataset / dataset view exposing `view`, `dim` and `stride`, in which case the logical `dim()` is quantized and the row padding is skipped. The rows may be device-accessible or host-resident. Device-accessible rows (device, managed or pinned) with tight row-major storage (logical stride equals dimension) are passed through to training as they are; a wider row pitch triggers a contiguous dense copy first. Host-resident rows are subsampled for training and encoded in bounded batches, so the dense dataset is never staged on the device in full; they must be tightly packed. Empty sources are rejected. The element type must be `float`, `half`, `int8_t` or `uint8_t`.
 
 Typical **CAGRA-Q** usage: compress the source rows, then build the graph directly from the VPQ dataset (the metric must be `L2Expanded`). Keep the `device_vpq_dataset` alive because the index holds a non-owning view of it.
 

From be58138a33db78cf30588db25f305fe4c061a5e1 Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Mon, 5 Oct 2026 20:41:43 -0700
Subject: [PATCH 11/15] Rename CAGRA/ANN-specific names out of core/dataset.hpp
 (#2395)

core holds vocabulary types shared by every algorithm, so nothing in it may
carry the name of a child namespace (cagra, ann, ...). Rename the four
identifiers in core/dataset.hpp that did, and reword the comments that tied
the header to CAGRA.

Renames (no behaviour change; unique identifiers, mechanical across cpp, c
and examples):
- ann_dataset_view               -> dataset_like           (46 uses)
- cagra_required_row_width       -> padded_row_width       (18 uses)
- matrix_row_width_matches_cagra_required
                                 -> matrix_has_padded_row_width (15 uses)
- cagra_view_element_type_t      -> dataset_view_value_t   (2 uses)

dataset_like is a structural concept: any type with n_rows() and dim().
Owning datasets and dataset views both satisfy it, so the doc comment no
longer claims it checks for a non-owning view; is_dataset_view_v remains the
nominal check for a literal dataset_view<...>. The padded-width helpers are
general row-padding arithmetic used by the make_*_padded_dataset factories,
not anything specific to CAGRA, so they are renamed rather than moved.

Comments in core/dataset.hpp that referred to "dense graph build", "for
CAGRA", the CAGRA row-width banner, and
cuvs::neighbors::detail::deserialize_standard() are reworded generically. The
header no longer mentions cagra, ann, ivf, hnsw, vamana, scann, brute force,
nn_descent, neighbors, graph, knn or recall in code or comments.

Verified: full rebuild clean (14 test targets, including the Roaring test now
that the upstream stream-API fix is merged); all pre-commit hooks pass.
DATASET_C_TEST (9), CAGRA_C_TEST (15), PREPROCESSING_TEST (226),
CORE_ROARING_ALLOWLIST_TEST (6), NEIGHBORS_TEST (371),
NEIGHBORS_ANN_CAGRA_BBQ_UINT32_TEST (105), NEIGHBORS_ANN_NN_DESCENT_TEST (572),
NEIGHBORS_ANN_CAGRA_MERGE_TEST (26), NEIGHBORS_ANN_SCANN_TEST (105),
NEIGHBORS_ANN_VAMANA_TEST (1260), NEIGHBORS_HNSW_TEST (256) and
NEIGHBORS_TIERED_INDEX_TEST (72) pass. NEIGHBORS_ANN_CAGRA_FLOAT_UINT32_TEST
and NEIGHBORS_MG_TEST had not finished at commit time (the float suite had
1700+ passing and no failures).
---
 c/src/neighbors/cagra.cpp                     | 22 +++----
 c/src/neighbors/cagra.hpp                     |  2 +-
 c/src/neighbors/mg_cagra.cpp                  |  8 +--
 c/src/neighbors/tiered_index.cpp              |  2 +-
 cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h   |  4 +-
 cpp/include/cuvs/core/dataset.hpp             | 64 +++++++++----------
 cpp/include/cuvs/neighbors/cagra.hpp          | 18 +++---
 cpp/include/cuvs/neighbors/vamana.hpp         |  2 +-
 cpp/src/neighbors/cagra.cuh                   | 16 ++---
 cpp/src/neighbors/detail/cagra/add_nodes.cuh  |  6 +-
 .../neighbors/detail/cagra/cagra_build.cuh    | 10 +--
 .../neighbors/detail/cagra/cagra_merge.cuh    | 14 ++--
 .../detail/cagra/cagra_merge_scaffold.cuh     |  2 +-
 .../neighbors/detail/cagra/cagra_search.cuh   |  8 +--
 .../detail/cagra/cagra_serialize.cuh          | 12 ++--
 cpp/src/neighbors/iface/iface.hpp             |  2 +-
 .../ann_cagra/test_merge_fastener.cu          |  4 +-
 .../neighbors/cagra_padded_build_helpers.cuh  |  2 +-
 cpp/tests/neighbors/tiered_index.cu           |  2 +-
 fern/pages/cpp_api/cpp-api-neighbors-cagra.md |  4 +-
 20 files changed, 102 insertions(+), 102 deletions(-)

diff --git a/c/src/neighbors/cagra.cpp b/c/src/neighbors/cagra.cpp
index 3d4c13b25b..9610800016 100644
--- a/c/src/neighbors/cagra.cpp
+++ b/c/src/neighbors/cagra.cpp
@@ -47,7 +47,7 @@ namespace {
  * Heap-allocated bundle for the C API: owns only `cagra::index`.
  * Lives behind `cuvsCagraIndex::addr` via `sg_cagra_c_api_index_box`.
  */
-template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::dataset_like DatasetViewT>
 struct cuvs_cagra_c_api_index_lifetime_holder {
   cuvs::neighbors::cagra::index<T, uint32_t, DatasetViewT> idx;
 };
@@ -66,7 +66,7 @@ struct sg_cagra_c_api_index_box {
   cuvs::neighbors::c_api::detail::owner_record owner_rec;
 };
 
-template <cuvs::core::ann_dataset_view DatasetViewT>
+template <cuvs::core::dataset_like DatasetViewT>
 constexpr auto sg_cagra_index_layout_from_view()
 {
   if constexpr (cuvs::core::is_device_standard_dataset_view_v<DatasetViewT>) {
@@ -151,7 +151,7 @@ static void with_index_by_layout(sg_cagra_c_api_index_box* box,
 template <typename T>
 static void destroy_typed_addr(void* ptr);
 
-template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::dataset_like DatasetViewT>
 static void merge_indices_for_layout(
   raft::resources* res_ptr,
   cuvs::neighbors::cagra::index_params const& params_cpp,
@@ -268,7 +268,7 @@ static void merge_indices_for_layout(
   }
 }
 
-template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::dataset_like DatasetViewT>
 static auto convert_opaque_indices_to_concrete_types(cuvsCagraIndex_t* indices, size_t num_indices)
   -> std::vector<cuvs::neighbors::cagra::index<T, uint32_t, DatasetViewT>*>
 {
@@ -328,7 +328,7 @@ static void with_dataset_view_for_layout(raft::resources* res_ptr,
   RAFT_FAIL("%s: dataset must have host- or device-compatible memory", err_prefix);
 }
 
-template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::dataset_like DatasetViewT>
 static void compute_ivfpq_shape_from_indices(cuvsCagraIndex_t* indices,
                                              size_t num_indices,
                                              int64_t* total_size,
@@ -348,7 +348,7 @@ static void compute_ivfpq_shape_from_indices(cuvsCagraIndex_t* indices,
   }
 }
 
-template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::dataset_like DatasetViewT>
 static auto make_sg_cagra_c_api_index_box(
   cuvs_cagra_c_api_index_lifetime_holder<T, DatasetViewT>* holder)
   -> std::unique_ptr<sg_cagra_c_api_index_box>
@@ -359,7 +359,7 @@ static auto make_sg_cagra_c_api_index_box(
                              cuvs::neighbors::c_api::detail::make_owner_record(holder)});
 }
 
-template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::dataset_like DatasetViewT>
 static void bind_index_lifetime_holder_to_C_index(
   cuvsCagraIndex_t out,
   DLDataType dtype,
@@ -370,7 +370,7 @@ static void bind_index_lifetime_holder_to_C_index(
   out->dtype = dtype;
 }
 
-template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::dataset_like DatasetViewT>
 static void wrap_CPP_index_in_lifetime_holder_and_bind_to_C_index(
   cuvsCagraIndex_t out,
   DLDataType dtype,
@@ -864,7 +864,7 @@ void _from_args(cuvsResources_t res,
   if (cuvs::core::is_dlpack_device_compatible(dataset)) {
     using mdspan_type = raft::device_matrix_view<T const, int64_t, raft::row_major>;
     auto mds          = cuvs::core::from_dlpack<mdspan_type>(dataset_tensor);
-    if (cuvs::core::matrix_row_width_matches_cagra_required(mds)) {
+    if (cuvs::core::matrix_has_padded_row_width(mds)) {
       auto dataset_view = cuvs::core::make_device_padded_dataset_view(*res_ptr, mds);
       auto* raw         = new cuvs::neighbors::cagra::device_padded_index<T, uint32_t>(
         *res_ptr, metric);
@@ -1233,7 +1233,7 @@ void dispatch_serialized_dataset_kind(
   }
 }
 
-template <typename T, cuvs::core::ann_dataset_view ViewT>
+template <typename T, cuvs::core::dataset_like ViewT>
 void _deserialize(cuvsResources_t res, const char *filename,
                   cuvsCagraIndex_t output_index, DLDataType dtype,
                   bool include_dataset, cuvsDataset_t *out_dataset) {
@@ -1892,7 +1892,7 @@ extern "C" cuvsError_t cuvsCagraUpdateDataset(cuvsResources_t res,
  * Build from an already-constructed C++ dataset view. `DatasetViewT` selects the
  * `cuvs::neighbors::cagra::build` overload, and therefore the resulting index type.
  */
-template <typename T, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, cuvs::core::dataset_like DatasetViewT>
 static void build_index_from_dataset_view(raft::resources* res_ptr,
                                           cuvsCagraIndexParams_t params,
                                           DatasetViewT const& ds_view,
diff --git a/c/src/neighbors/cagra.hpp b/c/src/neighbors/cagra.hpp
index d8b4acfc3c..db579eebff 100644
--- a/c/src/neighbors/cagra.hpp
+++ b/c/src/neighbors/cagra.hpp
@@ -20,7 +20,7 @@ void convert_c_search_params(cuvsCagraSearchParams params,
 void* cagra_c_api_index_ptr(cuvsCagraIndex const* idx);
 
 namespace detail {
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT>
 int64_t merged_dataset_size(
   raft::resources const& res,
   std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*> const& indices,
diff --git a/c/src/neighbors/mg_cagra.cpp b/c/src/neighbors/mg_cagra.cpp
index b4ceaee990..496a93b807 100644
--- a/c/src/neighbors/mg_cagra.cpp
+++ b/c/src/neighbors/mg_cagra.cpp
@@ -372,28 +372,28 @@ extern "C" cuvsError_t cuvsMultiGpuCagraBuild(cuvsResources_t res,
     if (dataset.dtype.code == kDLFloat && dataset.dtype.bits == 32) {
       auto mds = cuvs::core::from_dlpack<raft::host_matrix_view<const float, int64_t, raft::row_major>>(
         dataset_tensor);
-      auto layout = cuvs::core::matrix_row_width_matches_cagra_required(mds)
+      auto layout = cuvs::core::matrix_has_padded_row_width(mds)
                       ? mg_cagra_dataset_layout::device_padded
                       : mg_cagra_dataset_layout::device_standard;
       index->addr = reinterpret_cast<uintptr_t>(_mg_build<float>(res, *params, dataset_tensor, layout));
     } else if (dataset.dtype.code == kDLFloat && dataset.dtype.bits == 16) {
       auto mds = cuvs::core::from_dlpack<raft::host_matrix_view<const half, int64_t, raft::row_major>>(
         dataset_tensor);
-      auto layout = cuvs::core::matrix_row_width_matches_cagra_required(mds)
+      auto layout = cuvs::core::matrix_has_padded_row_width(mds)
                       ? mg_cagra_dataset_layout::device_padded
                       : mg_cagra_dataset_layout::device_standard;
       index->addr = reinterpret_cast<uintptr_t>(_mg_build<half>(res, *params, dataset_tensor, layout));
     } else if (dataset.dtype.code == kDLInt && dataset.dtype.bits == 8) {
       auto mds = cuvs::core::from_dlpack<raft::host_matrix_view<const int8_t, int64_t, raft::row_major>>(
         dataset_tensor);
-      auto layout = cuvs::core::matrix_row_width_matches_cagra_required(mds)
+      auto layout = cuvs::core::matrix_has_padded_row_width(mds)
                       ? mg_cagra_dataset_layout::device_padded
                       : mg_cagra_dataset_layout::device_standard;
       index->addr = reinterpret_cast<uintptr_t>(_mg_build<int8_t>(res, *params, dataset_tensor, layout));
     } else if (dataset.dtype.code == kDLUInt && dataset.dtype.bits == 8) {
       auto mds = cuvs::core::from_dlpack<raft::host_matrix_view<const uint8_t, int64_t, raft::row_major>>(
         dataset_tensor);
-      auto layout = cuvs::core::matrix_row_width_matches_cagra_required(mds)
+      auto layout = cuvs::core::matrix_has_padded_row_width(mds)
                       ? mg_cagra_dataset_layout::device_padded
                       : mg_cagra_dataset_layout::device_standard;
       index->addr = reinterpret_cast<uintptr_t>(_mg_build<uint8_t>(res, *params, dataset_tensor, layout));
diff --git a/c/src/neighbors/tiered_index.cpp b/c/src/neighbors/tiered_index.cpp
index 22c385c4af..98c74e90c8 100644
--- a/c/src/neighbors/tiered_index.cpp
+++ b/c/src/neighbors/tiered_index.cpp
@@ -140,7 +140,7 @@ void* _build(cuvsResources_t res, cuvsTieredIndexParams params, DLManagedTensor*
     case CUVS_TIERED_INDEX_ALGO_CAGRA: {
       auto build_params = tiered_index::index_params<cagra::index_params>();
       convert_c_index_params(params, dataset.shape[0], dataset.shape[1], &build_params);
-      if (cuvs::core::matrix_row_width_matches_cagra_required(mds)) {
+      if (cuvs::core::matrix_has_padded_row_width(mds)) {
         auto padded_view = cuvs::core::make_device_padded_dataset_view(*res_ptr, mds);
         auto* ptr = new tiered_index::index<cagra::device_padded_index<T, uint32_t>>(
           tiered_index::build(*res_ptr, build_params, padded_view));
diff --git a/cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h b/cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h
index 87c78bf791..e6a0755c89 100644
--- a/cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h
+++ b/cpp/bench/ann/src/cuvs/cuvs_cagra_wrapper.h
@@ -88,7 +88,7 @@ auto make_padded_view(const raft::resources& res,
   -> cuvs::core::device_padded_dataset_view<T, int64_t>
 {
   if constexpr (SrcT::accessor_type::is_device_accessible) {
-    if (cuvs::core::matrix_row_width_matches_cagra_required(src)) {
+    if (cuvs::core::matrix_has_padded_row_width(src)) {
       return cuvs::core::make_device_padded_dataset_view(res, src);
     }
   }
@@ -372,7 +372,7 @@ void cuvs_cagra<T, IdxT>::build(const T* dataset, size_t nrow)
         merged_rows += static_cast<int64_t>(index->size());
       }
       auto const stride =
-        static_cast<int64_t>(cuvs::core::cagra_required_row_width<T>(static_cast<uint32_t>(dim_)));
+        static_cast<int64_t>(cuvs::core::padded_row_width<T>(static_cast<uint32_t>(dim_)));
       *dataset_                = raft::make_device_matrix<T, int64_t>(handle_, merged_rows, stride);
       auto merged_dataset_view = cuvs::core::device_padded_dataset_view<T, int64_t>(
         raft::make_const_mdspan(dataset_->view()), static_cast<uint32_t>(dim_));
diff --git a/cpp/include/cuvs/core/dataset.hpp b/cpp/include/cuvs/core/dataset.hpp
index d80bed23dd..8d1092eec0 100644
--- a/cpp/include/cuvs/core/dataset.hpp
+++ b/cpp/include/cuvs/core/dataset.hpp
@@ -465,9 +465,11 @@ inline constexpr bool is_standard_dataset_v = is_standard_dataset<DatasetT>::val
 // Dataset view compile-time classification (replaces runtime std::variant dispatch).
 // -----------------------------------------------------------------------------
 
-/** Any non-owning dataset view exposing row count and logical dimension. */
+/** Any type that behaves like a dataset: it exposes a row count (`n_rows()`) and a logical
+ * dimension (`dim()`). This is a structural check, so owning datasets and dataset views both
+ * satisfy it. To ask whether a type is literally a `dataset_view<...>`, use `is_dataset_view_v`. */
 template <typename V, typename IdxT = int64_t>
-concept ann_dataset_view = requires(V const& v) {
+concept dataset_like = requires(V const& v) {
   { v.n_rows() } -> std::convertible_to<IdxT>;
   { v.dim() } -> std::convertible_to<uint32_t>;
 };
@@ -622,34 +624,34 @@ inline constexpr bool compatible_host_device_dataset_views_v =
   is_host_dataset_view_v<HostViewT> && is_device_dataset_view_v<DeviceViewT> &&
   std::is_same_v<device_counterpart_t<HostViewT>, dataset_view_type_t<DeviceViewT>>;
 
-/** True for device padded or standard views accepted by dense graph build. */
+/** True for device padded or standard (dense row-major) dataset views. */
 template <typename V>
 inline constexpr bool is_dense_row_major_device_dataset_view_v =
   is_device_padded_dataset_view_v<V> || is_device_standard_dataset_view_v<V>;
 
-/** True for host or device padded/standard views (dense graph build). */
+/** True for host or device padded or standard (dense row-major) dataset views. */
 template <typename V>
 inline constexpr bool is_dense_row_major_dataset_view_v =
   is_padded_dataset_view_v<V> || is_standard_dataset_view_v<V>;
 
-/** Element type `T` for `cagra::build(res, params, dataset_view)` (deduced, not a template arg).
- * Trivial under the Spec design: every `dataset_view<T,IdxT,SpecT>` already carries `T` directly.
- */
+/** Element type `T` of a dataset view, deduced from the view. Trivial under the Spec design: every
+ * `dataset_view<T,IdxT,SpecT>` already carries `T` directly. */
 template <typename V>
-using cagra_view_element_type_t = typename dataset_view_type_t<V>::value_type;
+using dataset_view_value_t = typename dataset_view_type_t<V>::value_type;
 
 // -----------------------------------------------------------------------------
-// CAGRA row width in elements (same for make_device_padded_dataset* and index layout checks).
+// Padded row width in elements (shared by the make_*_padded_dataset* factories and row-width
+// checks).
 // -----------------------------------------------------------------------------
 
 /**
- * @brief Required row width in elements for CAGRA: minimum leading dimension (LDA) per row for the
- *        default per-row byte alignment (16 bytes, combined with `sizeof` element type), given
- *        `logical_columns` feature columns.
+ * @brief Minimum row width in elements (the leading dimension) for `logical_columns` feature
+ *        columns, such that each row occupies a whole multiple of `align_bytes` bytes (default 16,
+ *        combined with `sizeof` of the element type).
  */
-[[nodiscard]] inline uint32_t cagra_required_row_width(uint32_t logical_columns,
-                                                       std::size_t sizeof_value,
-                                                       uint32_t align_bytes = 16)
+[[nodiscard]] inline uint32_t padded_row_width(uint32_t logical_columns,
+                                               std::size_t sizeof_value,
+                                               uint32_t align_bytes = 16)
 {
   return static_cast<uint32_t>(
     raft::round_up_safe<std::size_t>(static_cast<std::size_t>(logical_columns) * sizeof_value,
@@ -658,10 +660,9 @@ using cagra_view_element_type_t = typename dataset_view_type_t<V>::value_type;
 }
 
 template <typename ValueT>
-[[nodiscard]] inline uint32_t cagra_required_row_width(uint32_t logical_columns,
-                                                       uint32_t align_bytes = 16)
+[[nodiscard]] inline uint32_t padded_row_width(uint32_t logical_columns, uint32_t align_bytes = 16)
 {
-  return cagra_required_row_width(logical_columns, sizeof(ValueT), align_bytes);
+  return padded_row_width(logical_columns, sizeof(ValueT), align_bytes);
 }
 
 /** Actual row width in elements (leading dimension) of a 2D row-major matrix view. */
@@ -678,26 +679,26 @@ template <typename T, typename I, typename L>
 }
 
 /**
- * @brief True if the matrix's row width in elements matches `cagra_required_row_width` for
- *        `m.extent(1)` and element type `T` (CAGRA row layout is satisfied for this view).
+ * @brief True if the matrix's row width in elements equals `padded_row_width` for `m.extent(1)`
+ *        and element type `T`, i.e. its rows are already padded.
  */
 template <typename T, typename I, typename L>
-[[nodiscard]] inline bool matrix_row_width_matches_cagra_required(
-  raft::device_matrix_view<T, I, L> m, uint32_t align_bytes = 16)
+[[nodiscard]] inline bool matrix_has_padded_row_width(raft::device_matrix_view<T, I, L> m,
+                                                      uint32_t align_bytes = 16)
 {
   using value_type = std::remove_const_t<T>;
   const uint32_t need =
-    cagra_required_row_width<value_type>(static_cast<uint32_t>(m.extent(1)), align_bytes);
+    padded_row_width<value_type>(static_cast<uint32_t>(m.extent(1)), align_bytes);
   return matrix_actual_row_width(m) == need;
 }
 
 template <typename T, typename I, typename L>
-[[nodiscard]] inline bool matrix_row_width_matches_cagra_required(raft::host_matrix_view<T, I, L> m,
-                                                                  uint32_t align_bytes = 16)
+[[nodiscard]] inline bool matrix_has_padded_row_width(raft::host_matrix_view<T, I, L> m,
+                                                      uint32_t align_bytes = 16)
 {
   using value_type = std::remove_const_t<T>;
   const uint32_t need =
-    cagra_required_row_width<value_type>(static_cast<uint32_t>(m.extent(1)), align_bytes);
+    padded_row_width<value_type>(static_cast<uint32_t>(m.extent(1)), align_bytes);
   return matrix_actual_row_width(m) == need;
 }
 
@@ -837,7 +838,7 @@ auto make_device_padded_dataset_view(const raft::resources& res,
   using value_type = typename SrcT::value_type;
   using index_type = typename SrcT::index_type;
   uint32_t required_stride =
-    cagra_required_row_width<value_type>(static_cast<uint32_t>(src.extent(1)), align_bytes);
+    padded_row_width<value_type>(static_cast<uint32_t>(src.extent(1)), align_bytes);
   RAFT_EXPECTS(
     detail::mdspan_row_stride_elements(src) == required_stride,
     "make_device_padded_dataset_view: stride is incorrect (required stride for alignment). "
@@ -857,7 +858,7 @@ auto make_device_padded_dataset(const raft::resources& res,
   using value_type               = typename SrcT::value_type;
   using index_type               = typename SrcT::index_type;
   uint32_t const logical_dim     = static_cast<uint32_t>(src.extent(1));
-  uint32_t const required_stride = cagra_required_row_width<value_type>(logical_dim, align_bytes);
+  uint32_t const required_stride = padded_row_width<value_type>(logical_dim, align_bytes);
   return detail::make_device_dense_row_major_dataset_from_src<
     device_padded_dataset<value_type, index_type>,
     value_type,
@@ -871,7 +872,7 @@ auto make_host_padded_dataset_view(SrcT const& src, uint32_t align_bytes = 16)
   using value_type = typename SrcT::value_type;
   using index_type = typename SrcT::index_type;
   uint32_t required_stride =
-    cagra_required_row_width<value_type>(static_cast<uint32_t>(src.extent(1)), align_bytes);
+    padded_row_width<value_type>(static_cast<uint32_t>(src.extent(1)), align_bytes);
   RAFT_EXPECTS(
     detail::mdspan_row_stride_elements(src) == required_stride,
     "make_host_padded_dataset_view: stride is incorrect (required stride for alignment). "
@@ -891,7 +892,7 @@ auto make_host_padded_dataset(const raft::resources& res,
   using value_type               = typename SrcT::value_type;
   using index_type               = typename SrcT::index_type;
   uint32_t const logical_dim     = static_cast<uint32_t>(src.extent(1));
-  uint32_t const required_stride = cagra_required_row_width<value_type>(logical_dim, align_bytes);
+  uint32_t const required_stride = padded_row_width<value_type>(logical_dim, align_bytes);
   return detail::make_host_dense_row_major_dataset_from_src<
     host_padded_dataset<value_type, index_type>,
     value_type,
@@ -914,8 +915,7 @@ auto make_device_standard_dataset_view(SrcT const& src)
 /**
  * @brief Create an owning device standard dataset with explicit row layout.
  *
- * Internal use only: the sole call site today is
- * `cuvs::neighbors::detail::deserialize_standard()` in `dataset_serialize.hpp`, which must pass
+ * Internal use only: the sole caller today deserializes a dataset from disk and must pass
  * wire-format `(logical_dim, stride)` because the deserialized host buffer is tight `[n_rows x
  * dim]` while the on-disk stride may be larger. Do not call from user code; prefer
  * `make_device_standard_dataset_view()` when wrapping existing correctly-strided storage.
diff --git a/cpp/include/cuvs/neighbors/cagra.hpp b/cpp/include/cuvs/neighbors/cagra.hpp
index 86c6983147..c9621109e9 100644
--- a/cpp/include/cuvs/neighbors/cagra.hpp
+++ b/cpp/include/cuvs/neighbors/cagra.hpp
@@ -483,7 +483,7 @@ static_assert(std::is_aggregate_v<search_params>);
  */
 template <typename T,
           typename IdxT,
-          cuvs::core::ann_dataset_view DatasetViewT =
+          cuvs::core::dataset_like DatasetViewT =
             cuvs::core::device_padded_dataset_view<T, int64_t>>
 struct CUVS_EXPORT index : cuvs::neighbors::index {
   using index_params_type  = cagra::index_params;
@@ -590,7 +590,7 @@ struct CUVS_EXPORT index : cuvs::neighbors::index {
   /** Construct a graph-only index with a zero-row dataset view placeholder. */
   explicit index(raft::resources const& res,
                  cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Expanded)
-    requires(cuvs::core::ann_dataset_view<DatasetViewT, int64_t>)
+    requires(cuvs::core::dataset_like<DatasetViewT, int64_t>)
     : cuvs::neighbors::index(),
       metric_(metric),
       graph_(raft::make_device_matrix<graph_index_type, int64_t>(res, 0, 0)),
@@ -655,7 +655,7 @@ struct CUVS_EXPORT index : cuvs::neighbors::index {
 
   /* Construct an index with a new dataset type by moving the old index and passing in a new
    * dataset*/
-  template <cuvs::core::ann_dataset_view SrcDatasetViewT>
+  template <cuvs::core::dataset_like SrcDatasetViewT>
   index(raft::resources const& res, index<T, IdxT, SrcDatasetViewT>&& other, DatasetViewT dataset)
     : metric_(other.metric_),
       graph_(std::move(other.graph_)),
@@ -896,7 +896,7 @@ struct CUVS_EXPORT index : cuvs::neighbors::index {
   }
 
  private:
-  template <typename, typename, cuvs::core::ann_dataset_view>
+  template <typename, typename, cuvs::core::dataset_like>
   friend struct index;
 
   friend struct detail::fd_transfer;
@@ -968,7 +968,7 @@ template <typename DatasetViewT>
 using cagra_index_t = std::conditional_t<
   cuvs::preprocessing::quantize::pq::is_device_vpq_f16_dataset_view_v<DatasetViewT>,
   device_pq_index<float>,
-  index<cuvs::core::cagra_view_element_type_t<DatasetViewT>,
+  index<cuvs::core::dataset_view_value_t<DatasetViewT>,
         uint32_t,
         cuvs::core::dataset_view_type_t<DatasetViewT>>>;
 
@@ -3520,7 +3520,7 @@ struct merge_params {
  * explicit FASTENER.
  * @return The merged physical CAGRA index.
  */
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT>
 auto merge(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
            std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*>& indices,
@@ -3532,7 +3532,7 @@ auto merge(raft::resources const& res,
 /** @copydoc merge
  * @param[in] merge_params Parameters for the merge, including the algorithm selection.
  */
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT>
 auto merge(raft::resources const& res,
            const cuvs::neighbors::cagra::index_params& params,
            std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*>& indices,
@@ -4555,8 +4555,8 @@ namespace detail {
 struct fd_transfer {
   template <typename T,
             typename IdxT,
-            cuvs::core::ann_dataset_view SrcDatasetViewT,
-            cuvs::core::ann_dataset_view DstDatasetViewT>
+            cuvs::core::dataset_like SrcDatasetViewT,
+            cuvs::core::dataset_like DstDatasetViewT>
   static inline void steal_disk_fds_to(raft::resources const& res,
                                        index<T, IdxT, SrcDatasetViewT>& src,
                                        index<T, IdxT, DstDatasetViewT>& dst)
diff --git a/cpp/include/cuvs/neighbors/vamana.hpp b/cpp/include/cuvs/neighbors/vamana.hpp
index f80657c987..efec7bd953 100644
--- a/cpp/include/cuvs/neighbors/vamana.hpp
+++ b/cpp/include/cuvs/neighbors/vamana.hpp
@@ -204,7 +204,7 @@ struct index : cuvs::neighbors::index {
         dataset.stride(0) > 0 ? static_cast<int64_t>(dataset.stride(0)) : dataset.extent(1);
       auto d_m = raft::make_device_matrix_view<const T, int64_t>(
         dataset.data_handle(), dataset.extent(0), row_stride);
-      use_padded_view = cuvs::core::matrix_row_width_matches_cagra_required(d_m);
+      use_padded_view = cuvs::core::matrix_has_padded_row_width(d_m);
     }
 
     if (use_padded_view) {
diff --git a/cpp/src/neighbors/cagra.cuh b/cpp/src/neighbors/cagra.cuh
index f04993e2f9..088581b942 100644
--- a/cpp/src/neighbors/cagra.cuh
+++ b/cpp/src/neighbors/cagra.cuh
@@ -32,7 +32,7 @@
 
 namespace cuvs::neighbors::cagra {
 
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT>
 CUVS_EXPORT void index<T, IdxT, DatasetViewT>::compute_dataset_norms_(raft::resources const& res)
 {
   // raft::linalg::reduce wants row-major with leading dim = row pitch in elements.
@@ -398,7 +398,7 @@ template <typename T,
           typename IdxT,
           typename CagraSampleFilterT,
           typename OutputIdxT,
-          cuvs::core::ann_dataset_view DatasetViewT>
+          cuvs::core::dataset_like DatasetViewT>
 void search_with_filtering(raft::resources const& res,
                            const search_params& params,
                            const index<T, IdxT, DatasetViewT>& idx,
@@ -420,7 +420,7 @@ void search_with_filtering(raft::resources const& res,
     res, params, idx, queries, neighbors, distances, sample_filter);
 }
 
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT, typename OutputIdxT>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT, typename OutputIdxT>
 void search(raft::resources const& res,
             const search_params& params,
             const index<T, IdxT, DatasetViewT>& idx,
@@ -516,7 +516,7 @@ void search(raft::resources const& res,
   }
 }
 
-template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::dataset_like DatasetViewT>
 void extend(raft::resources const& handle,
             const cagra::extend_params& params,
             cuvs::core::device_padded_dataset_view<T, int64_t> extended_dataset,
@@ -528,7 +528,7 @@ void extend(raft::resources const& handle,
   extend_core<T, IdxT, DatasetViewT>(handle, index, params, extended_dataset, new_start_row);
 }
 
-template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::dataset_like DatasetViewT>
 cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge(
   raft::resources const& handle,
   const cagra::index_params& params,
@@ -540,7 +540,7 @@ cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge(
     handle, params, indices, merged_dataset, row_filter);
 }
 
-template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::dataset_like DatasetViewT>
 cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge(
   raft::resources const& handle,
   const cagra::index_params& params,
@@ -619,8 +619,8 @@ void search(
 
 template <typename T,
           typename IdxT,
-          cuvs::core::ann_dataset_view SrcDatasetViewT,
-          cuvs::core::ann_dataset_view DstDatasetViewT>
+          cuvs::core::dataset_like SrcDatasetViewT,
+          cuvs::core::dataset_like DstDatasetViewT>
 auto update_dataset(raft::resources const& res,
                     index<T, IdxT, SrcDatasetViewT>&& cagra_index,
                     DstDatasetViewT dataset) -> index<T, IdxT, DstDatasetViewT>
diff --git a/cpp/src/neighbors/detail/cagra/add_nodes.cuh b/cpp/src/neighbors/detail/cagra/add_nodes.cuh
index a2a69abcae..e8ff3d95ac 100644
--- a/cpp/src/neighbors/detail/cagra/add_nodes.cuh
+++ b/cpp/src/neighbors/detail/cagra/add_nodes.cuh
@@ -20,7 +20,7 @@
 
 namespace cuvs::neighbors::cagra {
 
-template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT, class Accessor>
+template <class T, class IdxT, cuvs::core::dataset_like DatasetViewT, class Accessor>
 void add_node_core(
   raft::resources const& handle,
   const cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>& idx,
@@ -276,7 +276,7 @@ void add_node_core(
   }
 }
 
-template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::dataset_like DatasetViewT>
 void add_graph_nodes(
   raft::resources const& handle,
   raft::device_matrix_view<const T, int64_t, raft::layout_stride> input_updated_dataset_view,
@@ -348,7 +348,7 @@ void add_graph_nodes(
   }
 }
 
-template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::dataset_like DatasetViewT>
 void extend_core(raft::resources const& handle,
                  cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>& index,
                  const cagra::extend_params& params,
diff --git a/cpp/src/neighbors/detail/cagra/cagra_build.cuh b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
index b654e145b4..d25097a9b6 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_build.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
@@ -1616,7 +1616,7 @@ auto build_ace(raft::resources const& res, const index_params& params, DatasetVi
               auto sub_dataset_view = raft::make_const_mdspan(sub_dataset_tight.view());
               std::unique_ptr<cuvs::core::device_padded_dataset<T, int64_t>> sub_dataset_padded;
               auto sub_dataset_dev = [&]() {
-                if (cuvs::core::matrix_row_width_matches_cagra_required(sub_dataset_view)) {
+                if (cuvs::core::matrix_has_padded_row_width(sub_dataset_view)) {
                   return cuvs::core::make_device_padded_dataset_view(res, sub_dataset_view);
                 }
                 sub_dataset_padded = cuvs::core::make_device_padded_dataset(res, sub_dataset_view);
@@ -2479,13 +2479,13 @@ auto iterative_build_graph(raft::resources const& res,
     final_graph_size = static_cast<uint64_t>(dataset.n_rows());
     vpq_dataset      = dataset;
   } else {
-    auto const required_stride = cuvs::core::cagra_required_row_width<T>(dataset.dim());
+    auto const required_stride = cuvs::core::padded_row_width<T>(dataset.dim());
     auto const data_view       = dataset.as_matrix_view();
     RAFT_EXPECTS(data_view.stride() == required_stride,
                  "iterative CAGRA build requires a CAGRA-aligned device dataset "
                  "(stride %u, required %u). Pass a device_padded_dataset_view, or a "
                  "device_standard_dataset_view whose row width already matches "
-                 "cagra_required_row_width.",
+                 "padded_row_width.",
                  data_view.stride(),
                  required_stride);
     dev_dataset      = data_view;
@@ -2520,8 +2520,8 @@ auto iterative_build_graph(raft::resources const& res,
 
   std::optional<raft::device_matrix<T, int64_t>> reconstructed_batch_queries;
   if (vpq_dataset.n_rows() > 0) {
-    auto const query_stride_i64 = static_cast<int64_t>(
-      cuvs::core::cagra_required_row_width<T>(static_cast<uint32_t>(logical_dim)));
+    auto const query_stride_i64 =
+      static_cast<int64_t>(cuvs::core::padded_row_width<T>(static_cast<uint32_t>(logical_dim)));
     reconstructed_batch_queries.emplace(
       raft::make_device_matrix<T, int64_t>(res, chunk_i64, query_stride_i64));
     // Padding columns must be zero: search_main cosine post-process reduces over the full row
diff --git a/cpp/src/neighbors/detail/cagra/cagra_merge.cuh b/cpp/src/neighbors/detail/cagra/cagra_merge.cuh
index 591a144954..7b8feea1e4 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_merge.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_merge.cuh
@@ -37,7 +37,7 @@
 
 namespace cuvs::neighbors::cagra::detail {
 
-template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::dataset_like DatasetViewT>
 int64_t merged_dataset_size(
   raft::resources const& handle,
   std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*> const& indices,
@@ -59,7 +59,7 @@ int64_t merged_dataset_size(
   return merged_rows;
 }
 
-template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::dataset_like DatasetViewT>
 cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT> merge_rebuild(
   raft::resources const& handle,
   const cagra::index_params& params,
@@ -214,7 +214,7 @@ struct fastener_preflight_result {
 };
 
 /** Validate every input and option without mutating anything. */
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT>
 auto preflight_fastener(
   raft::resources const& handle,
   cagra::index_params const& params,
@@ -370,7 +370,7 @@ auto preflight_fastener(
 /** Copy every input dataset into its row range of the caller-supplied merged dataset. Both sides
  *  carry a row pitch: the inputs share one stride (enforced by preflight) and the destination uses
  *  the merged dataset's own stride. */
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT>
 void copy_input_datasets(
   raft::resources const& handle,
   std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*> const& indices,
@@ -391,7 +391,7 @@ void copy_input_datasets(
   }
 }
 
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT>
 auto merge_fastener(raft::resources const& handle,
                     cagra::index_params const& params,
                     cagra::merge_params const& merge_params,
@@ -486,7 +486,7 @@ auto merge_fastener(raft::resources const& handle,
   return merged_index;
 }
 
-template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::dataset_like DatasetViewT>
 auto merge(raft::resources const& handle,
            cagra::index_params const& params,
            std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*>& indices,
@@ -539,7 +539,7 @@ auto merge(raft::resources const& handle,
 }
 
 /** AUTO-algorithm convenience overload matching the base `merge` signature. */
-template <class T, class IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <class T, class IdxT, cuvs::core::dataset_like DatasetViewT>
 auto merge(raft::resources const& handle,
            cagra::index_params const& params,
            std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*>& indices,
diff --git a/cpp/src/neighbors/detail/cagra/cagra_merge_scaffold.cuh b/cpp/src/neighbors/detail/cagra/cagra_merge_scaffold.cuh
index df56bcf6c6..9c22cacf1e 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_merge_scaffold.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_merge_scaffold.cuh
@@ -1142,7 +1142,7 @@ auto build(raft::resources const& res,
  *
  * The maximum input graph degree defines the base width, allowing partitions with mixed degrees.
  */
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT>
 void append_to_input_graphs(
   raft::resources const& res,
   std::vector<cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>*> const& indices,
diff --git a/cpp/src/neighbors/detail/cagra/cagra_search.cuh b/cpp/src/neighbors/detail/cagra/cagra_search.cuh
index 0bfe01cd41..f52280233c 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_search.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_search.cuh
@@ -101,7 +101,7 @@ void search_main_core(
   const DataT* queries_buf{};
   uint32_t query_row_stride{};
   std::unique_ptr<cuvs::core::device_padded_dataset<DataT, int64_t>> queries_padded_own;
-  if (cuvs::core::matrix_row_width_matches_cagra_required(queries)) {
+  if (cuvs::core::matrix_has_padded_row_width(queries)) {
     auto v           = cuvs::core::make_device_padded_dataset_view(res, queries);
     queries_buf      = v.as_matrix_view().data_handle();
     query_row_stride = v.as_matrix_view().stride();
@@ -188,7 +188,7 @@ template <typename T,
           typename CagraSampleFilterT,
           typename IdxT      = uint32_t,
           typename DistanceT = float,
-          cuvs::core::ann_dataset_view DatasetViewT>
+          cuvs::core::dataset_like DatasetViewT>
 void search_main(raft::resources const& res,
                  search_params params,
                  const index<T, IdxT, DatasetViewT>& index,
@@ -206,7 +206,7 @@ void search_main(raft::resources const& res,
 
   const uint32_t query_logical_dim = index.dim();
   const uint32_t query_row_width   = static_cast<uint32_t>(queries.extent(1));
-  const uint32_t required_stride   = cuvs::core::cagra_required_row_width<T>(query_logical_dim);
+  const uint32_t required_stride   = cuvs::core::padded_row_width<T>(query_logical_dim);
   RAFT_EXPECTS(query_row_width == query_logical_dim || query_row_width == required_stride,
                "CAGRA search queries must have %u logical dimensions or CAGRA-padded row width %u "
                "(got %u).",
@@ -271,7 +271,7 @@ void search_main(raft::resources const& res,
       sample_filter);
   } else if constexpr (cuvs::core::is_device_standard_dataset_view_v<DatasetViewT>) {
     RAFT_EXPECTS(
-      cuvs::core::matrix_row_width_matches_cagra_required(index.dataset().as_matrix_view()),
+      cuvs::core::matrix_has_padded_row_width(index.dataset().as_matrix_view()),
       "CAGRA search requires each dataset row to have the CAGRA-aligned stride. Create a padded "
       "dataset with cuvs::core::make_device_padded_dataset() and attach it with "
       "cagra::update_dataset().");
diff --git a/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh b/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
index 6ac99136cd..d09c9cc2e6 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_serialize.cuh
@@ -53,7 +53,7 @@ inline constexpr bool is_host_cagra_hnsw_serialize_index_v =
 
 constexpr int serialization_version = cuvs::neighbors::cagra::cagra_serialization_version;
 
-template <cuvs::core::ann_dataset_view DatasetViewT>
+template <cuvs::core::dataset_like DatasetViewT>
 constexpr auto serialized_dataset_kind_for_view() -> cuvs::neighbors::cagra::serialized_dataset_kind
 {
   using kind = cuvs::neighbors::cagra::serialized_dataset_kind;
@@ -106,7 +106,7 @@ void serialize_index_mdspan(raft::resources const& res, std::ostream& os, Mdspan
  * @param[in] index_ CAGRA index
  *
  */
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT>
 void serialize(raft::resources const& res,
                std::ostream& os,
                const cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>& index_,
@@ -167,7 +167,7 @@ void serialize(raft::resources const& res,
   if (has_source_indices) { serialize_index_mdspan(res, os, index_.source_indices().value()); }
 }
 
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT>
 void serialize(raft::resources const& res,
                const std::string& filename,
                const cuvs::neighbors::cagra::index<T, IdxT, DatasetViewT>& index_,
@@ -540,7 +540,7 @@ void serialize_to_hnswlib(
  * @param[in] index_ CAGRA index
  *
  */
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT, typename Input>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT, typename Input>
 void deserialize_impl(
   raft::resources const& res,
   Input& input,
@@ -678,7 +678,7 @@ void deserialize_impl(
   }
 }
 
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT>
 void deserialize(
   raft::resources const& res,
   std::istream& is,
@@ -688,7 +688,7 @@ void deserialize(
   deserialize_impl(res, is, index_, out_dataset);
 }
 
-template <typename T, typename IdxT, cuvs::core::ann_dataset_view DatasetViewT>
+template <typename T, typename IdxT, cuvs::core::dataset_like DatasetViewT>
 void deserialize(
   raft::resources const& res,
   const std::string& filename,
diff --git a/cpp/src/neighbors/iface/iface.hpp b/cpp/src/neighbors/iface/iface.hpp
index 6fdf35eff0..dc950df185 100644
--- a/cpp/src/neighbors/iface/iface.hpp
+++ b/cpp/src/neighbors/iface/iface.hpp
@@ -33,7 +33,7 @@ bool dataset_mdspan_uses_padded_device_view(
 {
   using value_type = T;
   uint32_t const required_stride =
-    cuvs::core::cagra_required_row_width<value_type>(static_cast<uint32_t>(mds.extent(1)));
+    cuvs::core::padded_row_width<value_type>(static_cast<uint32_t>(mds.extent(1)));
   uint32_t const src_stride =
     mds.stride(0) > 0 ? static_cast<uint32_t>(mds.stride(0)) : static_cast<uint32_t>(mds.extent(1));
   cudaPointerAttributes a{};
diff --git a/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu b/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu
index e030f36c1e..939078c909 100644
--- a/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu
+++ b/cpp/tests/neighbors/ann_cagra/test_merge_fastener.cu
@@ -66,7 +66,7 @@ auto make_padded(raft::resources const& res, raft::host_matrix_view<const T, int
 {
   auto stream       = raft::resource::get_cuda_stream(res);
   auto const dim    = static_cast<uint32_t>(src.extent(1));
-  auto const stride = cuvs::core::cagra_required_row_width<T>(dim, 16);
+  auto const stride = cuvs::core::padded_row_width<T>(dim, 16);
   auto matrix =
     raft::make_device_matrix<T, int64_t>(res, src.extent(0), static_cast<int64_t>(stride));
   RAFT_CUDA_TRY(cudaMemsetAsync(
@@ -88,7 +88,7 @@ auto make_padded(raft::resources const& res, raft::host_matrix_view<const T, int
 template <typename T>
 auto make_merged_storage(raft::resources const& res, int64_t rows, int64_t dim) -> padded_storage<T>
 {
-  auto const stride = cuvs::core::cagra_required_row_width<T>(static_cast<uint32_t>(dim), 16);
+  auto const stride = cuvs::core::padded_row_width<T>(static_cast<uint32_t>(dim), 16);
   auto matrix       = raft::make_device_matrix<T, int64_t>(res, rows, static_cast<int64_t>(stride));
   cuvs::core::device_padded_dataset_view<T, int64_t> view(raft::make_const_mdspan(matrix.view()),
                                                           static_cast<uint32_t>(dim));
diff --git a/cpp/tests/neighbors/cagra_padded_build_helpers.cuh b/cpp/tests/neighbors/cagra_padded_build_helpers.cuh
index b45c4cbd5c..e0529bb4fd 100644
--- a/cpp/tests/neighbors/cagra_padded_build_helpers.cuh
+++ b/cpp/tests/neighbors/cagra_padded_build_helpers.cuh
@@ -46,7 +46,7 @@ struct padded_device_matrix_for_cagra {
     -> build_result
   {
     using namespace cuvs::neighbors;
-    if (cuvs::core::matrix_row_width_matches_cagra_required(src)) {
+    if (cuvs::core::matrix_has_padded_row_width(src)) {
       return build_result{nullptr, cuvs::core::make_device_padded_dataset_view(res, src)};
     } else {
       auto own = cuvs::core::make_device_padded_dataset(res, src);
diff --git a/cpp/tests/neighbors/tiered_index.cu b/cpp/tests/neighbors/tiered_index.cu
index 0d4772ac28..7382fb011d 100644
--- a/cpp/tests/neighbors/tiered_index.cu
+++ b/cpp/tests/neighbors/tiered_index.cu
@@ -163,7 +163,7 @@ class ANNTieredIndexTest : public ::testing::TestWithParam<AnnTieredIndexInputs>
       if constexpr (std::is_same_v<UpstreamT, cagra::device_standard_index<float, uint32_t>>) {
         auto full_database_view = raft::make_device_matrix_view<const value_type, int64_t>(
           (const value_type*)database.data(), ps.n_rows, ps.dim);
-        if (cuvs::core::matrix_row_width_matches_cagra_required(full_database_view)) {
+        if (cuvs::core::matrix_has_padded_row_width(full_database_view)) {
           auto padded_view =
             cuvs::core::make_device_padded_dataset_view(handle_, full_database_view);
           auto attached_index = cuvs::neighbors::tiered_index::convert_standard_to_padded_index(
diff --git a/fern/pages/cpp_api/cpp-api-neighbors-cagra.md b/fern/pages/cpp_api/cpp-api-neighbors-cagra.md
index 056f7133d2..b6464fe4b2 100644
--- a/fern/pages/cpp_api/cpp-api-neighbors-cagra.md
+++ b/fern/pages/cpp_api/cpp-api-neighbors-cagra.md
@@ -220,7 +220,7 @@ The index stores the dataset and a kNN graph in device memory.
 ```cpp
 template <typename T,
 typename IdxT,
-cuvs::core::ann_dataset_view DatasetViewT =
+cuvs::core::dataset_like DatasetViewT =
 cuvs::core::device_padded_dataset_view<T, int64_t>>
 struct index;
 ```
@@ -411,7 +411,7 @@ Construct a graph-only index with a zero-row dataset view placeholder.
 ```cpp
 explicit index(raft::resources const& res,
 cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Expanded)
-requires(cuvs::core::ann_dataset_view<DatasetViewT, int64_t>)
+requires(cuvs::core::dataset_like<DatasetViewT, int64_t>)
 : cuvs::neighbors::index(),;
 ```
 

From 5ef4515cf4ef03de4c9c30f57aa8dc24196e8014 Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Mon, 5 Oct 2026 22:59:02 -0700
Subject: [PATCH 12/15] Unify the VPQ payload and bind it once per function
 (#2395)

The owning and view VPQ payloads were two separate structs that each
declared vq_code_book and pq_code_book, and the call sites reached them
through a mix of as_matrix_view() and data() on the same dataset. Define the
payload once and make every call site bind it a single time.

Unified payload (quantize/pq.hpp):
- vpq_storage<CodesT, BookT> is the single definition: it derives from the
  encoded-rows matrix and holds the VQ and PQ codebooks, sharing the
  existing helper methods (pq_bits, pq_len, ...).
- vpq_owning_storage and vpq_view_storage are now aliases of it, so every
  existing name and member is unchanged. The owning form uses mdarrays; the
  view form uses their const_view_type.
- The type aliases are now grouped as an owning pair: vpq_data_matrix
  (encoded uint8 rows) and vpq_codebook_matrix (renamed from
  vpq_vq_book_matrix, which was misleading because it also types the PQ
  codebook). The non-owning forms are derived from each with
  ::const_view_type, so the separate vpq_codes_view alias and the
  accessor using-declaration it needed are removed. A compile-time check
  confirmed the derived view type is identical to the spelled-out one for
  device and host accessors, half and float codebooks, and 32- and 64-bit
  indices.

Call sites:
- Owning-dataset code binds the payload once as `auto const& vpq =
  X.data()` and uses it for shape, helpers, pointers and strides: the
  decode test helper (vpq_utils.cuh), pq.cuh (transform, inverse_transform,
  vpq_convert_math_type, vpq_build_half) and the C API codebook getters.
  .view() is called only where a view type is required (functions taking
  views, the ScaNN device lambda, DLPack export).
- Code that receives a dataset_view binds the view payload as `auto const&
  vpq_view = dataset_view.data()`: cagra build(), the descriptor-cache
  make_key(), the VPQ distance descriptor init()/priority(), and
  reconstruct_vpq_queries(). The parameter in those functions that was
  called `dataset` is renamed `dataset_view` (and reconstruct_vpq_queries'
  `vpq_view` parameter becomes `dataset_view`) so the owning/view
  distinction is visible from the names. Only code identifiers are renamed,
  not error strings or comments.
- scann_build.cuh binds the codebook through a const reference, keeping the
  read-only view the original code produced (a non-const `data()` would
  otherwise have yielded a mutable view).

No behaviour change.

Verified: formatting hooks pass; full rebuild clean (14 test targets).
DATASET_C_TEST (9), CAGRA_C_TEST (14, with CagraC.BuildSearchACEDisk
excluded because a stale /tmp/cagra_ace_test_disk from an earlier run makes
it fail), PREPROCESSING_TEST (226), CORE_ROARING_ALLOWLIST_TEST (6),
NEIGHBORS_ANN_CAGRA_BBQ_UINT32_TEST (105), NEIGHBORS_ANN_NN_DESCENT_TEST
(572), NEIGHBORS_ANN_CAGRA_MERGE_TEST (26) and NEIGHBORS_ANN_SCANN_TEST (105)
pass. NEIGHBORS_ANN_VAMANA_TEST, NEIGHBORS_HNSW_TEST,
NEIGHBORS_TIERED_INDEX_TEST, NEIGHBORS_TEST,
NEIGHBORS_ANN_CAGRA_FLOAT_UINT32_TEST and NEIGHBORS_MG_TEST had not
finished at commit time (no failures so far).
---
 c/src/preprocessing/quantize/pq.cpp           | 12 +--
 .../cuvs/preprocessing/quantize/pq.hpp        | 82 ++++++++-----------
 cpp/src/neighbors/cagra.cuh                   | 28 ++++---
 .../neighbors/detail/cagra/cagra_build.cuh    | 16 ++--
 .../detail/cagra/compute_distance_vpq.hpp     | 27 +++---
 cpp/src/neighbors/detail/cagra/factory.cuh    | 22 ++---
 .../neighbors/scann/detail/scann_build.cuh    |  3 +-
 cpp/src/preprocessing/quantize/detail/pq.cuh  | 25 +++---
 cpp/tests/neighbors/vpq_utils.cuh             | 22 ++---
 .../preprocessing/product_quantization.cu     |  4 +-
 10 files changed, 117 insertions(+), 124 deletions(-)

diff --git a/c/src/preprocessing/quantize/pq.cpp b/c/src/preprocessing/quantize/pq.cpp
index 74f656e9a2..394061484f 100644
--- a/c/src/preprocessing/quantize/pq.cpp
+++ b/c/src/preprocessing/quantize/pq.cpp
@@ -242,10 +242,10 @@ extern "C" cuvsError_t cuvsProductQuantizerGetPqCodebook(cuvsProductQuantizer_t
     if (quantizer != nullptr) {
       auto quant_addr = quantizer->addr;
       if (quantizer->dtype.code == kDLFloat && quantizer->dtype.bits == 32) {
-        auto pq_mdspan =
+        auto const& vpq =
           (reinterpret_cast<cuvs::preprocessing::quantize::pq::quantizer<float>*>(quant_addr))
-            ->vpq_codebooks.as_matrix_view()
-            .pq_code_book;
+            ->vpq_codebooks.data();
+        auto pq_mdspan = vpq.pq_code_book.view();
         cuvs::core::to_dlpack(pq_mdspan, pq_codebook);
       } else {
         RAFT_FAIL("Unsupported quantizer dtype: %d and bits: %d",
@@ -265,10 +265,10 @@ extern "C" cuvsError_t cuvsProductQuantizerGetVqCodebook(cuvsProductQuantizer_t
     if (quantizer != nullptr) {
       auto quant_addr = quantizer->addr;
       if (quantizer->dtype.code == kDLFloat && quantizer->dtype.bits == 32) {
-        auto pq_mdspan =
+        auto const& vpq =
           (reinterpret_cast<cuvs::preprocessing::quantize::pq::quantizer<float>*>(quant_addr))
-            ->vpq_codebooks.as_matrix_view()
-            .vq_code_book;
+            ->vpq_codebooks.data();
+        auto pq_mdspan = vpq.vq_code_book.view();
         cuvs::core::to_dlpack(pq_mdspan, vq_codebook);
       } else {
         RAFT_FAIL("Unsupported quantizer dtype: %d and bits: %d",
diff --git a/cpp/include/cuvs/preprocessing/quantize/pq.hpp b/cpp/include/cuvs/preprocessing/quantize/pq.hpp
index aac6def506..24a2cff52e 100644
--- a/cpp/include/cuvs/preprocessing/quantize/pq.hpp
+++ b/cpp/include/cuvs/preprocessing/quantize/pq.hpp
@@ -208,14 +208,9 @@ struct vpq_params {
 namespace detail {
 
 // The accessor aliases are shared with every dataset kind and live next to `dataset`.
-using cuvs::core::detail::dataset_view_accessor_for_owning;
 using cuvs::core::detail::device_owning_accessor;
 using cuvs::core::detail::host_owning_accessor;
 
-template <typename MathT, typename IdxT, typename Accessor>
-using vpq_vq_book_matrix =
-  raft::mdarray<MathT, raft::matrix_extent<uint32_t>, raft::row_major, Accessor>;
-
 // VPQ codes are always uint8_t regardless of MathT, so retarget the owning accessor's element
 // type instead of re-deriving a device/host matrix; residency is still driven by Accessor.
 template <typename NewT, typename Accessor>
@@ -223,12 +218,21 @@ using owning_accessor_with_value_type = std::conditional_t<Accessor::is_device_a
                                                            device_owning_accessor<NewT>,
                                                            host_owning_accessor<NewT>>;
 
+// The two matrix types of a VPQ dataset. Both are owning (`mdarray`); the non-owning form of each
+// is its `const_view_type`, which the view payload below uses directly.
+
+/** Encoded rows (`uint8_t`): each row holds the VQ code followed by the PQ codes. Owning. */
 template <typename IdxT, typename Accessor>
 using vpq_data_matrix = raft::mdarray<uint8_t,
                                       raft::matrix_extent<IdxT>,
                                       raft::row_major,
                                       owning_accessor_with_value_type<uint8_t, Accessor>>;
 
+/** A codebook (used for both the VQ and the PQ codebook). Owning. */
+template <typename MathT, typename IdxT, typename Accessor>
+using vpq_codebook_matrix =
+  raft::mdarray<MathT, raft::matrix_extent<uint32_t>, raft::row_major, Accessor>;
+
 /** Read-only helpers derived from the codebook shapes; shared by the owning and view payloads.
  * `Derived` provides `vq_code_book`, `pq_code_book` and the codes' `extent(r)`. */
 template <typename Derived>
@@ -281,53 +285,37 @@ struct vpq_codebook_helpers {
   }
 };
 
-/** Owning VPQ payload: the encoded rows (it *is* the `uint8_t` codes mdarray) plus the VQ and PQ
- * codebooks. `Accessor` drives both codebook and code residency. */
-template <typename MathT, typename IdxT, typename Accessor>
-struct vpq_owning_storage : public vpq_data_matrix<IdxT, Accessor>,
-                            public vpq_codebook_helpers<vpq_owning_storage<MathT, IdxT, Accessor>> {
-  using codes_type   = vpq_data_matrix<IdxT, Accessor>;
-  using vq_book_type = vpq_vq_book_matrix<MathT, IdxT, Accessor>;
-  using pq_book_type = vpq_vq_book_matrix<MathT, IdxT, Accessor>;
-
-  vq_book_type vq_code_book;
-  pq_book_type pq_code_book;
-
-  vpq_owning_storage(codes_type&& codes, vq_book_type&& vq_codes, pq_book_type&& pq_codes) noexcept
-    : codes_type{std::move(codes)},
-      vq_code_book{std::move(vq_codes)},
-      pq_code_book{std::move(pq_codes)}
+/** The VPQ payload, defined once. `CodesT` is the encoded-rows matrix and `BookT` the type of each
+ * codebook: raft `mdarray`s for an owning dataset, `mdspan`s for a non-owning view. The payload
+ * *is* the `uint8_t` codes matrix (it derives from `CodesT`) and additionally holds the VQ and PQ
+ * codebooks, so `vq_code_book`, `pq_code_book` and the helpers below mean the same thing in both
+ * forms and only the ownership of the arrays differs. Use the aliases below rather than naming
+ * this template directly. */
+template <typename CodesT, typename BookT>
+struct vpq_storage : public CodesT, public vpq_codebook_helpers<vpq_storage<CodesT, BookT>> {
+  BookT vq_code_book;
+  BookT pq_code_book;
+
+  // Only usable when every member is default-constructible, i.e. for the view form.
+  vpq_storage() noexcept = default;
+
+  vpq_storage(CodesT&& codes, BookT&& vq_codes, BookT&& pq_codes) noexcept
+    : CodesT(std::move(codes)), vq_code_book(std::move(vq_codes)), pq_code_book(std::move(pq_codes))
   {
   }
 };
 
-/** Non-owning VPQ payload: a view of the encoded rows plus views of the VQ and PQ codebooks. */
+/** Owning VPQ payload: `mdarray` codes and codebooks. `Accessor` drives both codebook and code
+ * residency. */
 template <typename MathT, typename IdxT, typename Accessor>
-struct vpq_view_storage : public raft::mdspan<const uint8_t,
-                                              raft::matrix_extent<IdxT>,
-                                              raft::row_major,
-                                              dataset_view_accessor_for_owning<uint8_t, Accessor>>,
-                          public vpq_codebook_helpers<vpq_view_storage<MathT, IdxT, Accessor>> {
-  using codes_view_type = raft::mdspan<const uint8_t,
-                                       raft::matrix_extent<IdxT>,
-                                       raft::row_major,
-                                       dataset_view_accessor_for_owning<uint8_t, Accessor>>;
-  using vq_book_view_type =
-    typename vpq_owning_storage<MathT, IdxT, Accessor>::vq_book_type::const_view_type;
-  using pq_book_view_type =
-    typename vpq_owning_storage<MathT, IdxT, Accessor>::pq_book_type::const_view_type;
-
-  vq_book_view_type vq_code_book;
-  pq_book_view_type pq_code_book;
-
-  vpq_view_storage() noexcept = default;
-  vpq_view_storage(codes_view_type codes,
-                   vq_book_view_type vq_codes,
-                   pq_book_view_type pq_codes) noexcept
-    : codes_view_type(codes), vq_code_book(vq_codes), pq_code_book(pq_codes)
-  {
-  }
-};
+using vpq_owning_storage =
+  vpq_storage<vpq_data_matrix<IdxT, Accessor>, vpq_codebook_matrix<MathT, IdxT, Accessor>>;
+
+/** Non-owning VPQ payload: `mdspan` views of the codes and of both codebooks. */
+template <typename MathT, typename IdxT, typename Accessor>
+using vpq_view_storage =
+  vpq_storage<typename vpq_data_matrix<IdxT, Accessor>::const_view_type,
+              typename vpq_codebook_matrix<MathT, IdxT, Accessor>::const_view_type>;
 
 }  // namespace detail
 
diff --git a/cpp/src/neighbors/cagra.cuh b/cpp/src/neighbors/cagra.cuh
index 088581b942..b294b50ad5 100644
--- a/cpp/src/neighbors/cagra.cuh
+++ b/cpp/src/neighbors/cagra.cuh
@@ -295,7 +295,7 @@ template <typename DatasetViewT>
   requires(!cuvs::core::is_empty_dataset_view_v<DatasetViewT> &&
            (cuvs::core::is_device_dataset_view_v<DatasetViewT> ||
             cuvs::core::is_host_dataset_view_v<DatasetViewT>))
-auto build(raft::resources const& res, const index_params& params, DatasetViewT const& dataset)
+auto build(raft::resources const& res, const index_params& params, DatasetViewT const& dataset_view)
   -> cuvs::neighbors::cagra::cagra_index_t<DatasetViewT>
 {
   using index_type = cuvs::neighbors::cagra::cagra_index_t<DatasetViewT>;
@@ -306,7 +306,7 @@ auto build(raft::resources const& res, const index_params& params, DatasetViewT
   // non-searchable until the type-changing update_dataset(...) supplies a device-padded dataset.
   if constexpr (cuvs::preprocessing::quantize::bbq::is_device_bbq_dataset_view_v<DatasetViewT>) {
     return cuvs::neighbors::cagra::detail::build_from_bbq_dataset<T, IdxT, DatasetViewT>(
-      res, params, dataset);
+      res, params, dataset_view);
   } else if constexpr (cuvs::preprocessing::quantize::pq::is_device_vpq_dataset_view_v<
                          DatasetViewT>) {
     auto effective_params = params;
@@ -319,39 +319,41 @@ auto build(raft::resources const& res, const index_params& params, DatasetViewT
                  "cagra::build: a VPQ dataset requires iterative_search_params graph construction");
     RAFT_EXPECTS(effective_params.metric == cuvs::distance::DistanceType::L2Expanded,
                  "cagra::build: a VPQ dataset supports only L2Expanded distance");
-    RAFT_EXPECTS(dataset.n_rows() > 0, "cagra::build: VPQ dataset must not be empty");
-    RAFT_EXPECTS(dataset.data().pq_bits() == 8,
+    RAFT_EXPECTS(dataset_view.n_rows() > 0, "cagra::build: VPQ dataset must not be empty");
+    auto const& vpq_view = dataset_view.data();
+    RAFT_EXPECTS(vpq_view.pq_bits() == 8,
                  "cagra::build: VPQ dataset requires pq_bits == 8, got %u",
-                 dataset.data().pq_bits());
-    auto const pq_len = dataset.data().pq_len();
+                 vpq_view.pq_bits());
+    auto const pq_len = vpq_view.pq_len();
     RAFT_EXPECTS(pq_len == 2 || pq_len == 4 || pq_len == 8,
                  "cagra::build: VPQ dataset requires pq_len in {2, 4, 8}, got %u",
                  pq_len);
 
     detail::check_graph_degree<T, IdxT>(effective_params.intermediate_graph_degree,
                                         effective_params.graph_degree,
-                                        static_cast<size_t>(dataset.n_rows()));
-    auto cagra_graph = detail::iterative_build_graph<T, IdxT>(res, effective_params, dataset);
+                                        static_cast<size_t>(dataset_view.n_rows()));
+    auto cagra_graph = detail::iterative_build_graph<T, IdxT>(res, effective_params, dataset_view);
 
     index_type idx(res, effective_params.metric);
     idx.update_graph(res, std::move(cagra_graph));
     if (effective_params.attach_dataset_on_build) {
-      idx = cuvs::neighbors::cagra::update_dataset(res, std::move(idx), dataset);
+      idx = cuvs::neighbors::cagra::update_dataset(res, std::move(idx), dataset_view);
     }
     return idx;
   } else if constexpr (cuvs::core::is_dense_row_major_device_dataset_view_v<DatasetViewT>) {
     auto idx = cuvs::neighbors::cagra::detail::build_from_device_matrix<T, IdxT, DatasetViewT>(
-      res, params, dataset);
+      res, params, dataset_view);
     if (params.attach_dataset_on_build) {
-      idx = cuvs::neighbors::cagra::update_dataset(res, std::move(idx), dataset);
+      idx = cuvs::neighbors::cagra::update_dataset(res, std::move(idx), dataset_view);
     }
     return idx;
   } else {
     if (std::holds_alternative<graph_build_params::ace_params>(params.graph_build_params)) {
-      return cuvs::neighbors::cagra::detail::build_ace<T, IdxT, DatasetViewT>(res, params, dataset);
+      return cuvs::neighbors::cagra::detail::build_ace<T, IdxT, DatasetViewT>(
+        res, params, dataset_view);
     }
     return cuvs::neighbors::cagra::detail::build_from_host_matrix<T, IdxT, DatasetViewT>(
-      res, params, dataset);
+      res, params, dataset_view);
   }
 }
 
diff --git a/cpp/src/neighbors/detail/cagra/cagra_build.cuh b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
index d25097a9b6..472e16656e 100644
--- a/cpp/src/neighbors/detail/cagra/cagra_build.cuh
+++ b/cpp/src/neighbors/detail/cagra/cagra_build.cuh
@@ -2307,14 +2307,14 @@ __global__ void kern_reconstruct_vpq_queries(const uint8_t* encoded_data,
 template <typename T, typename MathT, typename IdxT>
 void reconstruct_vpq_queries(
   raft::resources const& res,
-  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<MathT, IdxT> const& vpq_view,
+  cuvs::preprocessing::quantize::pq::device_vpq_dataset_view<MathT, IdxT> const& dataset_view,
   uint64_t offset,
   uint32_t batch_size,
   raft::device_matrix_view<T, int64_t> output)
 {
-  auto const data_view     = vpq_view.as_matrix_view();
-  const uint32_t dim       = vpq_view.dim();
-  const uint32_t pq_len    = vpq_view.data().pq_len();
+  auto const& vpq_view     = dataset_view.data();
+  const uint32_t dim       = dataset_view.dim();
+  const uint32_t pq_len    = vpq_view.pq_len();
   const uint32_t output_ld = static_cast<uint32_t>(output.extent(1));
   const uint32_t threads   = std::min(dim, 256u);
   RAFT_EXPECTS(output_ld >= dim,
@@ -2324,10 +2324,10 @@ void reconstruct_vpq_queries(
 
   kern_reconstruct_vpq_queries<T, MathT>
     <<<batch_size, threads, 0, raft::resource::get_cuda_stream(res).get()>>>(
-      data_view.data_handle(),
-      vpq_view.data().encoded_row_length(),
-      data_view.vq_code_book.data_handle(),
-      data_view.pq_code_book.data_handle(),
+      vpq_view.data_handle(),
+      vpq_view.encoded_row_length(),
+      vpq_view.vq_code_book.data_handle(),
+      vpq_view.pq_code_book.data_handle(),
       dim,
       pq_len,
       offset,
diff --git a/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp b/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
index 7683ebcfc3..569fd7b24e 100644
--- a/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
+++ b/cpp/src/neighbors/detail/cagra/compute_distance_vpq.hpp
@@ -61,31 +61,32 @@ struct vpq_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT> {
 
   template <typename DatasetT>
   static auto init(const cagra::search_params& params,
-                   const DatasetT& dataset,
+                   const DatasetT& dataset_view,
                    cuvs::distance::DistanceType metric,
                    const DistanceT* dataset_norms = nullptr) -> host_type
   {
-    auto const data_view = dataset.as_matrix_view();
+    auto const& vpq_view = dataset_view.data();
     return init_(params,
-                 data_view.data_handle(),
-                 static_cast<uint32_t>(data_view.extent(1)),
-                 data_view.vq_code_book.data_handle(),
-                 data_view.pq_code_book.data_handle(),
-                 IndexT(dataset.n_rows()),
-                 dataset.dim());
+                 vpq_view.data_handle(),
+                 static_cast<uint32_t>(vpq_view.extent(1)),
+                 vpq_view.vq_code_book.data_handle(),
+                 vpq_view.pq_code_book.data_handle(),
+                 IndexT(dataset_view.n_rows()),
+                 dataset_view.dim());
   }
 
   template <typename DatasetT>
   static auto priority(const cagra::search_params& params,
-                       const DatasetT& dataset,
+                       const DatasetT& dataset_view,
                        cuvs::distance::DistanceType metric) -> double
   {
     // If explicit team_size is specified and doesn't match the instance, discard it
     if (params.team_size != 0 && TeamSize != params.team_size) { return -1.0; }
     if (cuvs::distance::DistanceType::L2Expanded != metric) { return -1.0; }
     // Match codebook params
-    if (dataset.data().pq_bits() != PqBits) { return -1.0; }
-    if (dataset.data().pq_len() != PqLen) { return -1.0; }
+    auto const& vpq_view = dataset_view.data();
+    if (vpq_view.pq_bits() != PqBits) { return -1.0; }
+    if (vpq_view.pq_len() != PqLen) { return -1.0; }
     if (select_supported_vpq_smem_dtype(params) != SmemDType) { return -1.0; }
     // Keep auto-selection on the tuned VPQ diagonal while allowing explicit team_size requests to
     // use the expanded team_size / dataset_block_dim grid.
@@ -96,8 +97,8 @@ struct vpq_descriptor_spec : public instance_spec<DataT, IndexT, DistanceT> {
     // Otherwise, favor the closest dataset dimensionality.
     constexpr std::uint32_t preferred_load_elmes_per_thread =
       16; /*magic number that is good based on experiments.*/
-    return 1.0 / (0.1 + std::abs(double(dataset.dim()) - double(DatasetBlockDim))) * TeamSize +
-           1.0 / (0.1 + std::abs(double(dataset.dim()) / TeamSize / PqLen -
+    return 1.0 / (0.1 + std::abs(double(dataset_view.dim()) - double(DatasetBlockDim))) * TeamSize +
+           1.0 / (0.1 + std::abs(double(dataset_view.dim()) / TeamSize / PqLen -
                                  preferred_load_elmes_per_thread));
   }
 
diff --git a/cpp/src/neighbors/detail/cagra/factory.cuh b/cpp/src/neighbors/detail/cagra/factory.cuh
index aea0e3d9a1..444efcd88a 100644
--- a/cpp/src/neighbors/detail/cagra/factory.cuh
+++ b/cpp/src/neighbors/detail/cagra/factory.cuh
@@ -92,21 +92,21 @@ struct key {
 };
 
 // `DatasetT` here is the non-owning dataset_view passed in by the search path, so all state comes
-// off the view's own `as_matrix_view()`, not owning-only members.
+// off the view's own `as_matrix_view()`/`data()`, not owning-only members.
 template <typename DatasetT>
 auto make_key(const cagra::search_params& params,
-              const DatasetT& dataset,
+              const DatasetT& dataset_view,
               cuvs::distance::DistanceType metric,
               const void* dataset_norms)
   -> std::enable_if_t<cuvs::core::is_padded_dataset_v<DatasetT> ||
                         cuvs::core::is_standard_dataset_v<DatasetT>,
                       key>
 {
-  auto const data_view = dataset.as_matrix_view();
+  auto const data_view = dataset_view.as_matrix_view();
   return key{reinterpret_cast<uint64_t>(data_view.data_handle()),
              reinterpret_cast<uint64_t>(dataset_norms),
-             uint64_t(dataset.n_rows()),
-             dataset.dim(),
+             uint64_t(dataset_view.n_rows()),
+             dataset_view.dim(),
              data_view.stride(),
              uint32_t(params.team_size),
              uint32_t(metric),
@@ -115,17 +115,17 @@ auto make_key(const cagra::search_params& params,
 
 template <typename DatasetT>
 auto make_key(const cagra::search_params& params,
-              const DatasetT& dataset,
+              const DatasetT& dataset_view,
               cuvs::distance::DistanceType metric,
               const void* dataset_norms)
   -> std::enable_if_t<cuvs::preprocessing::quantize::pq::is_vpq_dataset_view_v<DatasetT>, key>
 {
-  auto const data_view = dataset.as_matrix_view();
-  return key{reinterpret_cast<uint64_t>(data_view.data_handle()),
+  auto const& vpq_view = dataset_view.data();
+  return key{reinterpret_cast<uint64_t>(vpq_view.data_handle()),
              reinterpret_cast<uint64_t>(dataset_norms),
-             uint64_t(dataset.n_rows()),
-             dataset.dim(),
-             uint32_t(reinterpret_cast<uint64_t>(data_view.pq_code_book.data_handle()) >> 6),
+             uint64_t(dataset_view.n_rows()),
+             dataset_view.dim(),
+             uint32_t(reinterpret_cast<uint64_t>(vpq_view.pq_code_book.data_handle()) >> 6),
              uint32_t(params.team_size),
              uint32_t(metric),
              uint32_t(params.smem_dtype)};
diff --git a/cpp/src/neighbors/scann/detail/scann_build.cuh b/cpp/src/neighbors/scann/detail/scann_build.cuh
index 3bf0fa6b30..b0f93a7979 100644
--- a/cpp/src/neighbors/scann/detail/scann_build.cuh
+++ b/cpp/src/neighbors/scann/detail/scann_build.cuh
@@ -437,7 +437,8 @@ index<T, IdxT> build(
   // Codebooks from VPQ have the shape [subspace idx, subspace dim, code]
   // This converts the codebook into matrix format for easy interoperability
   // with open-source ScaNN search
-  auto full_codebook_view = pq_quantizer.vpq_codebooks.as_matrix_view().pq_code_book;
+  auto const& vpq         = pq_quantizer.vpq_codebooks.data();
+  auto full_codebook_view = vpq.pq_code_book.view();
 
   raft::linalg::map_offset(
     res,
diff --git a/cpp/src/preprocessing/quantize/detail/pq.cuh b/cpp/src/preprocessing/quantize/detail/pq.cuh
index 5a6a7f0d9b..5f7e8c2145 100644
--- a/cpp/src/preprocessing/quantize/detail/pq.cuh
+++ b/cpp/src/preprocessing/quantize/detail/pq.cuh
@@ -217,7 +217,8 @@ void transform(
   RAFT_EXPECTS(quantizer.params_quantizer.pq_bits >= 4 && quantizer.params_quantizer.pq_bits <= 16,
                "PQ bits must be within [4, 16]");
   // Encode dataset
-  auto vq_centers     = quantizer.vpq_codebooks.as_matrix_view().vq_code_book;
+  auto const& vpq     = quantizer.vpq_codebooks.data();
+  auto vq_centers     = vpq.vq_code_book.view();
   auto vq_labels_view = raft::make_device_vector_view<uint32_t, int64_t>(nullptr, 0);
   if (vq_labels.has_value()) { vq_labels_view = vq_labels.value(); }
 
@@ -226,7 +227,7 @@ void transform(
       res,
       to_vpq_params(quantizer.params_quantizer),
       dataset,
-      quantizer.vpq_codebooks.as_matrix_view().pq_code_book,
+      vpq.pq_code_book.view(),
       vq_centers,
       vq_labels_view,
       pq_codes_out);
@@ -235,7 +236,7 @@ void transform(
       res,
       to_vpq_params(quantizer.params_quantizer),
       dataset,
-      quantizer.vpq_codebooks.as_matrix_view().pq_code_book,
+      vpq.pq_code_book.view(),
       vq_centers,
       vq_labels_view,
       pq_codes_out);
@@ -356,12 +357,12 @@ void inverse_transform(
                "Codes matrix doesn't have the correct number of columns");
   RAFT_EXPECTS(quant.params_quantizer.pq_bits >= 4 && quant.params_quantizer.pq_bits <= 16,
                "PQ bits must be within [4, 16]");
-  auto const quant_dict = quant.vpq_codebooks.as_matrix_view();
+  auto const& vpq = quant.vpq_codebooks.data();
   reconstruct_vectors<T, T, idx_t, label_t>(res,
                                             quant.params_quantizer,
                                             codes,
-                                            quant_dict.pq_code_book,
-                                            quant_dict.vq_code_book,
+                                            vpq.pq_code_book.view(),
+                                            vpq.vq_code_book.view(),
                                             vq_labels,
                                             out,
                                             quant.params_quantizer.use_subspaces);
@@ -374,15 +375,15 @@ void vpq_convert_math_type(
   raft::device_matrix_view<NewMathT, uint32_t, raft::row_major> dst_vq_code_book,
   raft::device_matrix_view<NewMathT, uint32_t, raft::row_major> dst_pq_code_book)
 {
-  auto const src_view = src.as_matrix_view();
+  auto const& src_vpq = src.data();
   raft::linalg::map(res,
                     dst_vq_code_book,
                     cuvs::spatial::knn::detail::utils::mapping<NewMathT>{},
-                    src_view.vq_code_book);
+                    src_vpq.vq_code_book.view());
   raft::linalg::map(res,
                     dst_pq_code_book,
                     cuvs::spatial::knn::detail::utils::mapping<NewMathT>{},
-                    src_view.pq_code_book);
+                    src_vpq.pq_code_book.view());
 }
 
 inline auto make_pq_params_from_vpq(const cuvs::preprocessing::quantize::pq::vpq_params& in_params,
@@ -453,9 +454,9 @@ auto vpq_build_half(const raft::resources& res,
 {
   auto old_type         = vpq_build<decltype(dataset), float, int64_t>(res, params, dataset);
   using new_owning_t    = cuvs::preprocessing::quantize::pq::device_vpq_dataset<half, int64_t>;
-  auto const old_view   = old_type.as_matrix_view();
-  auto new_vq_code_book = raft::make_device_mdarray<half>(res, old_view.vq_code_book.extents());
-  auto new_pq_code_book = raft::make_device_mdarray<half>(res, old_view.pq_code_book.extents());
+  auto const& old_vpq   = old_type.data();
+  auto new_vq_code_book = raft::make_device_mdarray<half>(res, old_vpq.vq_code_book.extents());
+  auto new_pq_code_book = raft::make_device_mdarray<half>(res, old_vpq.pq_code_book.extents());
   vpq_convert_math_type<half, float, int64_t>(
     res, old_type, new_vq_code_book.view(), new_pq_code_book.view());
   // Reuse the already-encoded codes (the owning payload's mdarray base) with the new codebooks.
diff --git a/cpp/tests/neighbors/vpq_utils.cuh b/cpp/tests/neighbors/vpq_utils.cuh
index d4c875a3af..d29f4428c5 100644
--- a/cpp/tests/neighbors/vpq_utils.cuh
+++ b/cpp/tests/neighbors/vpq_utils.cuh
@@ -52,11 +52,11 @@ void decode_vpq_dataset(
   cudaStream_t cuda_stream)
 {
   const auto dataset_size = decoded_dataset.extent(0);
-  auto const data_view    = vpq_dataset.as_matrix_view();
-  RAFT_EXPECTS(data_view.extent(0) == dataset_size, "Dataset sizes mismatch");
-  RAFT_EXPECTS(vpq_dataset.data().pq_bits() == 8,
+  auto const& vpq         = vpq_dataset.data();
+  RAFT_EXPECTS(vpq.extent(0) == dataset_size, "Dataset sizes mismatch");
+  RAFT_EXPECTS(vpq.pq_bits() == 8,
                "decode_vpq_dataset currently only supports pq_bits == 8 (got %u)",
-               vpq_dataset.data().pq_bits());
+               vpq.pq_bits());
 
   constexpr uint32_t block_size  = 256;
   constexpr uint32_t warp_size   = 32;
@@ -66,14 +66,14 @@ void decode_vpq_dataset(
   decode_vpq_dataset_kernel<data_t, math_t>
     <<<grid_size, block_size, 0, cuda_stream>>>(decoded_dataset.data_handle(),
                                                 decoded_dataset.stride(0),
-                                                data_view.vq_code_book.data_handle(),
-                                                data_view.vq_code_book.stride(0),
-                                                data_view.pq_code_book.data_handle(),
-                                                vpq_dataset.data().pq_len(),
-                                                1u << vpq_dataset.data().pq_bits(),
+                                                vpq.vq_code_book.data_handle(),
+                                                vpq.vq_code_book.stride(0),
+                                                vpq.pq_code_book.data_handle(),
+                                                vpq.pq_len(),
+                                                1u << vpq.pq_bits(),
                                                 vpq_dataset.dim(),
                                                 dataset_size,
-                                                data_view.data_handle(),
-                                                data_view.stride(0));
+                                                vpq.data_handle(),
+                                                vpq.stride(0));
 }
 }  // namespace cuvs::neighbors
diff --git a/cpp/tests/preprocessing/product_quantization.cu b/cpp/tests/preprocessing/product_quantization.cu
index 7e98bdd2ff..42ca8c9a61 100644
--- a/cpp/tests/preprocessing/product_quantization.cu
+++ b/cpp/tests/preprocessing/product_quantization.cu
@@ -329,7 +329,7 @@ TEST(ProductQuantizationTestF, MakeVpqDatasetFromHost)
 
   EXPECT_EQ(vpq.n_rows(), n_rows);
   EXPECT_EQ(vpq.dim(), dim);
-  EXPECT_NE(vpq.as_matrix_view().data_handle(), nullptr);
+  EXPECT_NE(vpq.data().data_handle(), nullptr);
 }
 
 TEST(ProductQuantizationTestF, MakeVpqDatasetFromPaddedView)
@@ -362,7 +362,7 @@ TEST(ProductQuantizationTestF, MakeVpqDatasetFromPaddedView)
 
   EXPECT_EQ(vpq.n_rows(), n_rows);
   EXPECT_EQ(vpq.dim(), dim);
-  EXPECT_NE(vpq.as_matrix_view().data_handle(), nullptr);
+  EXPECT_NE(vpq.data().data_handle(), nullptr);
 }
 
 // Define test cases with different parameters

From 898a9a6e9145ced3744d0989c09d4e646c1bf2a4 Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Tue, 6 Oct 2026 21:17:27 -0700
Subject: [PATCH 13/15] Allow brace-initialization of datasets and dataset
 views (#2395)

CI fails building the ANN benchmarks:

  cuvs_cagra_wrapper.h(96): error: copy-list-initialization cannot use a
  constructor marked "explicit"
      return {raft::make_const_mdspan(buffer.view()), static_cast<uint32_t>(src.extent(1))};

That line is unchanged from main, where it compiles. The generic
dataset/dataset_view introduced by the Spec-based rewrite forwards its
constructor arguments to the payload through a single variadic constructor
that was marked `explicit` for every argument count. `return {view, dim};`
is copy-list-initialization, which may not use an explicit constructor, so
every two-argument brace-initialization of a dataset or dataset view stopped
compiling.

The explicit was there to stop a lone raw matrix view from converting
implicitly into a dataset view (and silently binding to overloads meant for
dataset views). That risk only exists for a single argument, so make the
constructors `explicit(sizeof...(Args) == 1)`:
- direct initialization, e.g. device_padded_dataset_view<T, I>(view, dim),
  is unchanged;
- multi-argument brace initialization, e.g. `return {view, dim};`, works
  again as it did before datasets were generic;
- a single argument still cannot convert implicitly.

Applies to both dataset and dataset_view. No call sites change.

Not built locally: the ANN benchmarks (their dependencies are not present
in this configuration), which is why this was only caught in CI. The failing
statement was reproduced and verified in a standalone translation unit
instead: it fails to compile before this change and compiles after it, for a
dataset view and for an owning dataset, with static_asserts confirming that a
single-argument implicit conversion is still rejected.

Verified: formatting hooks pass. The rebuild of the 14 test targets and the
full test run were still in progress at commit time.
---
 cpp/include/cuvs/core/dataset.hpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/cpp/include/cuvs/core/dataset.hpp b/cpp/include/cuvs/core/dataset.hpp
index 8d1092eec0..faa6287410 100644
--- a/cpp/include/cuvs/core/dataset.hpp
+++ b/cpp/include/cuvs/core/dataset.hpp
@@ -278,9 +278,11 @@ struct dataset {
 
   // Forward constructor args straight to data_type's own constructor (e.g. (MatrixT&&, uint32_t
   // logical_dim) for dense, (uint32_t dim) for empty, or whatever a compressed kind's payload
-  // takes).
+  // takes). Explicit only for a single argument, so that a lone value never converts to a dataset
+  // implicitly, while multi-argument brace initialization such as `return {matrix, dim};` keeps
+  // working as it did before datasets were generic.
   template <typename... Args>
-  explicit dataset(Args&&... args)
+  explicit(sizeof...(Args) == 1) dataset(Args&&... args)
     requires(std::is_constructible_v<data_type, Args...>)
     : data_(std::forward<Args>(args)...)
   {
@@ -323,9 +325,12 @@ struct dataset_view {
 
   // Forward raw constructor args straight to view_type's own constructor (e.g. (ViewT, uint32_t
   // logical_dim) for dense, (uint32_t dim) for empty) -- preserves today's direct-construction
-  // call sites (e.g. `device_padded_dataset_view<T,IdxT>(raw_mdspan, dim)`) unchanged.
+  // call sites (e.g. `device_padded_dataset_view<T,IdxT>(raw_mdspan, dim)`) unchanged. Explicit
+  // only for a single argument, so that a raw matrix view never converts to a dataset view
+  // implicitly (which would let it silently bind to overloads meant for dataset views), while
+  // multi-argument brace initialization such as `return {view, dim};` keeps working.
   template <typename... Args>
-  explicit dataset_view(Args&&... args)
+  explicit(sizeof...(Args) == 1) dataset_view(Args&&... args)
     requires(std::is_constructible_v<view_type, Args...>)
     : data_view_(std::forward<Args>(args)...)
   {

From f3ad116078dbdb5d844b75d3a056853ef1f88c9e Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Tue, 6 Oct 2026 22:07:06 -0700
Subject: [PATCH 14/15] Remove dataset forward declarations by reordering
 dataset_view first

`dataset::as_dataset_view()` named `dataset_view` before its definition,
which is why both structs had forward declarations. `dataset_view` does
not refer to `dataset`, and nothing else in the header names `dataset`
before its definition, so:

- drop the `dataset` forward declaration (it was never required)
- define `dataset_view` before `dataset`, which removes the
  `dataset_view` forward declaration too

No behavior change: the two struct definitions are only swapped.
Regenerates the Fern core dataset reference page to match the new order.
---
 cpp/include/cuvs/core/dataset.hpp          | 84 ++++++++++------------
 fern/pages/cpp_api/cpp-api-core-dataset.md | 22 ++----
 2 files changed, 44 insertions(+), 62 deletions(-)

diff --git a/cpp/include/cuvs/core/dataset.hpp b/cpp/include/cuvs/core/dataset.hpp
index faa6287410..b7a0e7dcf1 100644
--- a/cpp/include/cuvs/core/dataset.hpp
+++ b/cpp/include/cuvs/core/dataset.hpp
@@ -51,12 +51,6 @@ namespace core {
  * corresponding non-owning payload.
  */
 
-template <typename T, typename IdxT, typename SpecT>
-struct dataset;
-
-template <typename T, typename IdxT, typename SpecT>
-struct dataset_view;
-
 namespace detail {
 
 // Default owning/view accessors for public dataset aliases.
@@ -266,45 +260,6 @@ struct standard_dataset_spec {
 // dataset / dataset_view
 // -----------------------------------------------------------------------------
 
-/** Owning dataset: value-held payload (no shared_ptr -- exclusive ownership). Every member is a
- * one-line forward to `spec_type::get_*` or to the payload; all per-kind state and logic lives in
- * the spec's `data_type`, never inside this struct. */
-template <typename T, typename IdxT, typename SpecT>
-struct dataset {
-  using spec_type  = typename SpecT::template apply<T, IdxT>;
-  using value_type = typename spec_type::value_type;
-  using index_type = typename spec_type::index_type;
-  using data_type  = typename spec_type::data_type;
-
-  // Forward constructor args straight to data_type's own constructor (e.g. (MatrixT&&, uint32_t
-  // logical_dim) for dense, (uint32_t dim) for empty, or whatever a compressed kind's payload
-  // takes). Explicit only for a single argument, so that a lone value never converts to a dataset
-  // implicitly, while multi-argument brace initialization such as `return {matrix, dim};` keeps
-  // working as it did before datasets were generic.
-  template <typename... Args>
-  explicit(sizeof...(Args) == 1) dataset(Args&&... args)
-    requires(std::is_constructible_v<data_type, Args...>)
-    : data_(std::forward<Args>(args)...)
-  {
-  }
-
-  [[nodiscard]] auto n_rows() const noexcept -> index_type { return spec_type::get_n_rows(data_); }
-  [[nodiscard]] auto dim() const noexcept -> uint32_t { return spec_type::get_dim(data_); }
-  /** The spec-defined non-owning view of the payload (an mdspan derivative for dense kinds). */
-  [[nodiscard]] auto as_matrix_view() const noexcept { return spec_type::get_data_view(data_); }
-  [[nodiscard]] auto as_dataset_view() const noexcept -> dataset_view<T, IdxT, SpecT>
-  {
-    return dataset_view<T, IdxT, SpecT>(as_matrix_view());
-  }
-
-  /** The owning payload; kind-specific state and methods are reached through it. */
-  [[nodiscard]] auto data() const noexcept -> data_type const& { return data_; }
-  [[nodiscard]] auto data() noexcept -> data_type& { return data_; }
-
- private:
-  data_type data_;
-};
-
 /** Non-owning dataset view: holds only the view-shaped payload. Deliberately not derived from
  * `dataset` -- a view type holds "all view state" with no inheritance and no shared ownership tying
  * it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec functions as `dataset`, fed
@@ -351,6 +306,45 @@ struct dataset_view {
   view_type data_view_{};
 };
 
+/** Owning dataset: value-held payload (no shared_ptr -- exclusive ownership). Every member is a
+ * one-line forward to `spec_type::get_*` or to the payload; all per-kind state and logic lives in
+ * the spec's `data_type`, never inside this struct. */
+template <typename T, typename IdxT, typename SpecT>
+struct dataset {
+  using spec_type  = typename SpecT::template apply<T, IdxT>;
+  using value_type = typename spec_type::value_type;
+  using index_type = typename spec_type::index_type;
+  using data_type  = typename spec_type::data_type;
+
+  // Forward constructor args straight to data_type's own constructor (e.g. (MatrixT&&, uint32_t
+  // logical_dim) for dense, (uint32_t dim) for empty, or whatever a compressed kind's payload
+  // takes). Explicit only for a single argument, so that a lone value never converts to a dataset
+  // implicitly, while multi-argument brace initialization such as `return {matrix, dim};` keeps
+  // working as it did before datasets were generic.
+  template <typename... Args>
+  explicit(sizeof...(Args) == 1) dataset(Args&&... args)
+    requires(std::is_constructible_v<data_type, Args...>)
+    : data_(std::forward<Args>(args)...)
+  {
+  }
+
+  [[nodiscard]] auto n_rows() const noexcept -> index_type { return spec_type::get_n_rows(data_); }
+  [[nodiscard]] auto dim() const noexcept -> uint32_t { return spec_type::get_dim(data_); }
+  /** The spec-defined non-owning view of the payload (an mdspan derivative for dense kinds). */
+  [[nodiscard]] auto as_matrix_view() const noexcept { return spec_type::get_data_view(data_); }
+  [[nodiscard]] auto as_dataset_view() const noexcept -> dataset_view<T, IdxT, SpecT>
+  {
+    return dataset_view<T, IdxT, SpecT>(as_matrix_view());
+  }
+
+  /** The owning payload; kind-specific state and methods are reached through it. */
+  [[nodiscard]] auto data() const noexcept -> data_type const& { return data_; }
+  [[nodiscard]] auto data() noexcept -> data_type& { return data_; }
+
+ private:
+  data_type data_;
+};
+
 /**
  * @brief Aliases for concrete `dataset` / `dataset_view` layouts.
  */
diff --git a/fern/pages/cpp_api/cpp-api-core-dataset.md b/fern/pages/cpp_api/cpp-api-core-dataset.md
index ed9d79cb79..8c82369cd2 100644
--- a/fern/pages/cpp_api/cpp-api-core-dataset.md
+++ b/fern/pages/cpp_api/cpp-api-core-dataset.md
@@ -8,16 +8,16 @@ _Source header: `cuvs/core/dataset.hpp`_
 
 ## Types
 
-<a id="core-dataset"></a>
-### core::dataset
+<a id="core-dataset-view"></a>
+### core::dataset_view
 
-Spec-based `dataset` / `dataset_view`.
+Non-owning dataset view: holds only the view-shaped payload. Deliberately not derived from
 
-`dataset&lt;T,IdxT,SpecT&gt;` and `dataset_view&lt;T,IdxT,SpecT&gt;` are single generic templates that know nothing about any particular kind of dataset. They hold exactly one payload (`data_type` / `view_type`, chosen by the spec) and expose only what every dataset has: `n_rows()`, `dim()`, `as_matrix_view()`, `as_dataset_view()` and `data()`. Each is a one-line forward to one of the three spec functions `get_data_view()`, `get_n_rows()` and `get_dim()`. Anything else a kind needs (e.g. codebooks or quantizers of a compressed dataset) is state and methods of that kind's payload type, reached through `data()`; `dataset`/`dataset_view` never name or branch on it. Compressed kinds define their payloads and specs in their own headers (quantize/pq.hpp, quantize/bbq.hpp) as children of these two structs. `dataset` and `dataset_view` are deliberately two independent, non-inheriting types (no shared_ptr, no "sometimes owning" object): `dataset` holds the owning payload, `dataset_view` the corresponding non-owning payload.
+`dataset` -- a view type holds "all view state" with no inheritance and no shared ownership tying it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec functions as `dataset`, fed the view payload instead of the owning one.
 
 ```cpp
 template <typename T, typename IdxT, typename SpecT>
-struct dataset;
+struct dataset_view;
 ```
 
 <a id="core-dataset"></a>
@@ -32,18 +32,6 @@ template <typename T, typename IdxT, typename SpecT>
 struct dataset;
 ```
 
-<a id="core-dataset-view"></a>
-### core::dataset_view
-
-Non-owning dataset view: holds only the view-shaped payload. Deliberately not derived from
-
-`dataset` -- a view type holds "all view state" with no inheritance and no shared ownership tying it to the owning type. Reuses the same `get_n_rows`/`get_dim` spec functions as `dataset`, fed the view payload instead of the owning one.
-
-```cpp
-template <typename T, typename IdxT, typename SpecT>
-struct dataset_view;
-```
-
 <a id="core-is-padded-dataset"></a>
 ### core::is_padded_dataset
 

From 542404129e52af852c1e6a6033e4d80bcd4a610a Mon Sep 17 00:00:00 2001
From: Howard Huang <howardhuangb@gmail.com>
Date: Tue, 6 Oct 2026 22:38:27 -0700
Subject: [PATCH 15/15] Unify dense owning and view payloads into
 dense_row_major_storage

The owning and view dense payloads were two near-identical structs that
each inherited from a matrix type and added `logical_dim_`. Replace them
with a single `dense_row_major_storage<BaseT>`: the owning payload
passes its `raft::mdarray` as `BaseT`, the view payload passes the
`raft::mdspan`, mirroring how `vpq_storage` already serves both.

- `stride()` now uses the view's rule (`BaseT::stride(0)` when
  positive, otherwise `extent(1)`). For a row-major mdarray `stride(0)`
  equals `extent(1)`, so the owning result is unchanged.
- Constructors are the union of the old ones: default, `(BaseT)` which
  infers `logical_dim_` from `extent(1)`, and `(BaseT, dim)`. `BaseT` is
  taken by value so an owning matrix is moved in and a view is copied.
  The single-argument constructor stays explicit and the owning payload
  stays move-only.
- Drop the unused `DataT` and the redundant `ViewT`/`IdxT` template
  parameters; `n_rows()` returns `BaseT::index_type`.

No behavior change.
---
 cpp/include/cuvs/core/dataset.hpp | 68 +++++++++++--------------------
 1 file changed, 23 insertions(+), 45 deletions(-)

diff --git a/cpp/include/cuvs/core/dataset.hpp b/cpp/include/cuvs/core/dataset.hpp
index b7a0e7dcf1..2786d92fe0 100644
--- a/cpp/include/cuvs/core/dataset.hpp
+++ b/cpp/include/cuvs/core/dataset.hpp
@@ -110,65 +110,43 @@ struct empty_dataset_storage {
 // -----------------------------------------------------------------------------
 
 /**
- * Dense row-major owning storage shared by padded and standard dataset specs. Publicly inherits
- * from MatrixT (a `raft::mdarray`) so `view()`/`data_handle()`/`extent()` etc. are reused as-is
- * rather than hand-forwarded; `logical_dim_` is the only state this struct adds.
+ * Dense row-major payload shared by padded and standard dataset specs, owning and non-owning
+ * alike: the owning payload passes its `raft::mdarray` as `BaseT`, the view payload passes the
+ * `raft::mdspan`. Publicly inherits from `BaseT` so `view()`/`data_handle()`/`extent()` etc. are
+ * reused as-is rather than hand-forwarded; `logical_dim_` is the only state this struct adds.
  *
  * Template parameters:
- * - MatrixT: owning matrix type that stores the payload (host/device matrix).
- * - ViewT: non-owning row-major view type returned by `view()`.
- * - DataT: scalar element type of the dataset payload.
- * - IdxT: index type used for row counts (`n_rows()` return type).
+ * - BaseT: the owning matrix (`raft::mdarray`) or the non-owning row-major view (`raft::mdspan`).
  */
-template <typename MatrixT, typename ViewT, typename DataT, typename IdxT>
-struct dense_row_major_dataset_owning_storage : public MatrixT {
-  uint32_t logical_dim_;
+template <typename BaseT>
+struct dense_row_major_storage : public BaseT {
+  using index_type = typename BaseT::index_type;
 
-  // MatrixT (mdarray) also has its own stride(size_t); pull it back into scope since declaring
-  // our own no-arg stride() below would otherwise hide it entirely (C++ name hiding).
-  using MatrixT::stride;
+  uint32_t logical_dim_{};
 
-  dense_row_major_dataset_owning_storage(MatrixT&& data, uint32_t logical_dim) noexcept
-    : MatrixT{std::move(data)}, logical_dim_{logical_dim}
-  {
-  }
-
-  [[nodiscard]] auto n_rows() const noexcept -> IdxT { return this->extent(0); }
-  [[nodiscard]] auto dim() const noexcept -> uint32_t { return logical_dim_; }
-  [[nodiscard]] auto stride() const noexcept -> uint32_t
-  {
-    return static_cast<uint32_t>(this->extent(1));
-  }
-  // view() and data_handle() are inherited directly from MatrixT (raft::mdarray); no hand-written
-  // forwarding needed since MatrixT::view() const already returns exactly ViewT.
-};
-
-template <typename ViewT, typename DataT, typename IdxT>
-struct dense_row_major_dataset_view_storage : public ViewT {
-  uint32_t logical_dim_;
-
-  // ViewT (mdspan) also has its own stride(size_t); pull it back into scope since declaring our
-  // own no-arg stride() below would otherwise hide it entirely (C++ name hiding), and the body of
-  // that stride() itself needs to call the inherited one.
-  using ViewT::stride;
+  // BaseT (mdarray/mdspan) also has its own stride(size_t); pull it back into scope since
+  // declaring our own no-arg stride() below would otherwise hide it entirely (C++ name hiding),
+  // and the body of that stride() itself needs to call the inherited one.
+  using BaseT::stride;
 
-  dense_row_major_dataset_view_storage() noexcept = default;
+  dense_row_major_storage() noexcept = default;
 
-  explicit dense_row_major_dataset_view_storage(ViewT v) noexcept
-    : ViewT(v), logical_dim_(static_cast<uint32_t>(v.extent(1)))
+  // Takes BaseT by value so an owning matrix is moved in and a view is simply copied.
+  explicit dense_row_major_storage(BaseT base) noexcept
+    : BaseT(std::move(base)), logical_dim_(static_cast<uint32_t>(this->extent(1)))
   {
   }
 
-  dense_row_major_dataset_view_storage(ViewT v, uint32_t logical_dim) noexcept
-    : ViewT(v), logical_dim_(logical_dim)
+  dense_row_major_storage(BaseT base, uint32_t logical_dim) noexcept
+    : BaseT(std::move(base)), logical_dim_(logical_dim)
   {
   }
 
-  [[nodiscard]] auto n_rows() const noexcept -> IdxT { return this->extent(0); }
+  [[nodiscard]] auto n_rows() const noexcept -> index_type { return this->extent(0); }
   [[nodiscard]] auto dim() const noexcept -> uint32_t { return logical_dim_; }
   [[nodiscard]] auto stride() const noexcept -> uint32_t
   {
-    return static_cast<uint32_t>(ViewT::stride(0) > 0 ? ViewT::stride(0) : this->extent(1));
+    return static_cast<uint32_t>(BaseT::stride(0) > 0 ? BaseT::stride(0) : this->extent(1));
   }
 };
 
@@ -184,8 +162,8 @@ struct dense_dataset_spec_impl {
     using index_type = std::remove_cv_t<IdxT>;
     using MatrixT    = dense_owning_matrix<T, IdxT, ContainerPolicy>;
     using ViewT      = dense_view_matrix<T, IdxT, ContainerPolicy>;
-    using data_type  = dense_row_major_dataset_owning_storage<MatrixT, ViewT, T, IdxT>;
-    using view_type  = dense_row_major_dataset_view_storage<ViewT, T, IdxT>;
+    using data_type  = dense_row_major_storage<MatrixT>;
+    using view_type  = dense_row_major_storage<ViewT>;
 
     [[nodiscard]] static auto get_data_view(data_type const& data) noexcept -> view_type
     {