From fddf6f3afba08835205f7f886108a6ce1016f23e Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Mon, 17 Nov 2025 14:50:02 +0300
Subject: [PATCH 01/34] sorting index tracks max series id

---
 pp/series_index/sorting_index.h               | 19 +++++++----
 pp/series_index/tests/sorting_index_tests.cpp | 32 +++++++++++++++++++
 2 files changed, 45 insertions(+), 6 deletions(-)

diff --git a/pp/series_index/sorting_index.h b/pp/series_index/sorting_index.h
index 6906e22ce..a5c704752 100644
--- a/pp/series_index/sorting_index.h
+++ b/pp/series_index/sorting_index.h
@@ -40,6 +40,7 @@ template <class Set, template <class> class Vector, uint32_t kMaxIndexValue = st
 class SortingIndexBuilder {
  public:
   using Index = SortingIndex<Vector>;
+  using IndexValueType = uint32_t;
 
   explicit SortingIndexBuilder(const Set& ls_id_set) : ls_id_set_(ls_id_set) {}
 
@@ -57,10 +58,14 @@ class SortingIndexBuilder {
       return;
     }
 
+    const uint64_t ls_id = *ls_id_iterator;
+    max_id_ = std::max<uint64_t>(max_id_, ls_id);
+
     const uint64_t previous = get_previous(ls_id_iterator);
     const uint64_t next = get_next(ls_id_iterator);
     if (uint32_t value = (previous + next) / 2; value > previous) [[likely]] {
-      index_.index.emplace_back(value);
+      index_.index.resize(max_id_ + 1);
+      index_.index[ls_id] = value;
     } else {
       // If we can't insert item we don't need to rebuild index, because it's very expensive operation for CPU.
       // Index will be built on demand in sort method
@@ -79,11 +84,13 @@ class SortingIndexBuilder {
  private:
   const Set& ls_id_set_;
   Index index_;
+  IndexValueType max_id_{0};
 
   void rebuild() {
-    index_.index.resize(ls_id_set_.size());
+    max_id_ = *std::max_element(ls_id_set_.begin(), ls_id_set_.end());
+    index_.index.resize(max_id_ + 1);
 
-    const uint32_t step = kMaxIndexValue / (ls_id_set_.size() + 1);
+    const uint32_t step = kMaxIndexValue / (max_id_ + 2);
     uint32_t index_value = 0;
     for (auto ls_id : ls_id_set_) {
       index_value += step;
@@ -93,15 +100,15 @@ class SortingIndexBuilder {
 
   PROMPP_ALWAYS_INLINE uint32_t get_previous(typename Set::const_iterator ls_id_iterator) const noexcept {
     if (ls_id_iterator != ls_id_set_.begin()) {
-      return index_.index[*--ls_id_iterator];
+      return index_.index[*std::prev(ls_id_iterator)];
     }
 
     return 0;
   }
 
   PROMPP_ALWAYS_INLINE uint32_t get_next(typename Set::const_iterator ls_id_iterator) const noexcept {
-    if (++ls_id_iterator != ls_id_set_.end()) {
-      return index_.index[*ls_id_iterator];
+    if (const auto next_iterator = std::next(ls_id_iterator); next_iterator != ls_id_set_.end()) {
+      return index_.index[*next_iterator];
     }
 
     return kMaxIndexValue;
diff --git a/pp/series_index/tests/sorting_index_tests.cpp b/pp/series_index/tests/sorting_index_tests.cpp
index 04be0d3fa..2c9892a63 100644
--- a/pp/series_index/tests/sorting_index_tests.cpp
+++ b/pp/series_index/tests/sorting_index_tests.cpp
@@ -101,6 +101,38 @@ TEST_F(SortingIndexFixture, BuildIndexInSort) {
   EXPECT_THAT(series_ids, testing::ElementsAre("a"_idx, "b"_idx, "c"_idx, "d"_idx));
 }
 
+TEST_F(SortingIndexFixture, BuildIndexOutOfOrderInSort) {
+  // Arrange
+  set_.emplace(2);
+  set_.emplace(3);
+  set_.emplace(0);
+  set_.emplace(1);
+
+  std::array series_ids{"d"_idx, "c"_idx, "b"_idx, "a"_idx};
+
+  // Act
+  index_.sort(series_ids.begin(), series_ids.end());
+
+  // Assert
+  EXPECT_FALSE(index_.empty());
+  EXPECT_THAT(series_ids, testing::ElementsAre("a"_idx, "b"_idx, "c"_idx, "d"_idx));
+}
+
+TEST_F(SortingIndexFixture, BuildIndexOutOfOrderWithSkipInSort) {
+  // Arrange
+  set_.emplace(3);
+  set_.emplace(0);
+
+  std::array series_ids{"c"_idx, "b"_idx};
+
+  // Act
+  index_.sort(series_ids.begin(), series_ids.end());
+
+  // Assert
+  EXPECT_FALSE(index_.empty());
+  EXPECT_THAT(series_ids, testing::ElementsAre("b"_idx, "c"_idx));
+}
+
 TEST_F(SortingIndexFixture, IndexSnapshot) {
   // Arrange
   SortingIndexBuilder<Set, SharedVector, kItems.size() + 1> index{set_};

From eca36e788b1bdf5e476c755676b4cc6bf3e9b63d Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Mon, 17 Nov 2025 17:17:35 +0300
Subject: [PATCH 02/34] after_items_load_impl now accepts range of ls_ids

---
 pp/bare_bones/snug_composite.h             | 59 ++++++++++++++--------
 pp/series_index/queryable_encoding_bimap.h |  9 ++--
 2 files changed, 44 insertions(+), 24 deletions(-)

diff --git a/pp/bare_bones/snug_composite.h b/pp/bare_bones/snug_composite.h
index 1056b6515..07ea91b92 100644
--- a/pp/bare_bones/snug_composite.h
+++ b/pp/bare_bones/snug_composite.h
@@ -8,6 +8,8 @@
 
 #include <scope_exit.h>
 
+#include <ranges>
+
 #include "bare_bones/allocator.h"
 #include "bare_bones/exception.h"
 #include "bare_bones/streams.h"
@@ -24,6 +26,9 @@ namespace BareBones::SnugComposite {
  */
 enum class SerializationMode : char { SNAPSHOT = 1, DELTA = 2 };
 
+template <class Range>
+concept ls_id_range = std::ranges::range<Range> && std::same_as<std::ranges::range_value_t<Range>, uint32_t>;
+
 template <class FilamentDataType>
 concept is_shrinkable = requires(FilamentDataType& data_type) {
   { data_type.shrink_to(uint32_t()) };
@@ -39,10 +44,8 @@ concept has_rollback = requires(Derived derived, const Checkpoint& checkpoint) {
   { derived.rollback_impl(checkpoint) };
 };
 
-template <class Derived>
-concept has_after_items_load = requires(Derived derived) {
-  { derived.after_items_load_impl(uint32_t()) };
-};
+template <class Derived, class R>
+concept has_after_items_load = ls_id_range<R> && requires(Derived derived, R&& range) { derived.after_items_load_impl(std::forward<R>(range)); };
 
 template <class Derived, template <template <class> class> class Filament, template <class> class Vector>
 class GenericDecodingTable {
@@ -381,9 +384,10 @@ class GenericDecodingTable {
     }
 
     // post processing
-    if constexpr (has_after_items_load<Derived>) {
-      static_assert(noexcept(static_cast<Derived*>(this)->after_items_load_impl(original_size)));
-      static_cast<Derived*>(this)->after_items_load_impl(original_size);
+    if constexpr (has_after_items_load<Derived, std::ranges::iota_view<uint32_t>>) {
+      auto r = std::views::iota(original_size, items_.size());
+      static_assert(noexcept(static_cast<Derived*>(this)->after_items_load_impl(r)));
+      static_cast<Derived*>(this)->after_items_load_impl(r);
     }
   }
 
@@ -615,9 +619,12 @@ class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEnc
 
   [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index_impl() const noexcept { return shift_ + Base::items_.size(); }
 
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(uint32_t first_loaded_id) noexcept {
-    set_.reserve(Base::items_.size());
-    for (auto id = first_loaded_id; id != Base::items_.size(); ++id) {
+  template <ls_id_range R>
+  PROMPP_ALWAYS_INLINE void after_items_load_impl(R&& loaded_ids) noexcept {
+    if constexpr (std::ranges::sized_range<R>) {
+      set_.reserve(std::ranges::size(loaded_ids));
+    }
+    for (const auto id : loaded_ids) {
       set_.emplace(typename Base::Proxy(id));
     }
   }
@@ -631,9 +638,12 @@ class EncodingBimap : public GenericDecodingTable<EncodingBimap<Filament, Vector
 
   phmap::flat_hash_set<typename Base::Proxy, typename Base::Hasher, typename Base::EqualityComparator> set_{{}, 0, Base::hasher(), Base::equality_comparator()};
 
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(uint32_t first_loaded_id) noexcept {
-    set_.reserve(Base::items_.size());
-    for (auto id = first_loaded_id; id != Base::items_.size(); ++id) {
+  template <ls_id_range R>
+  PROMPP_ALWAYS_INLINE void after_items_load_impl(R&& loaded_ids) noexcept {
+    if constexpr (std::ranges::sized_range<R>) {
+      set_.reserve(std::ranges::size(loaded_ids));
+    }
+    for (const auto id : loaded_ids) {
       set_.emplace(typename Base::Proxy(id));
     }
   }
@@ -716,9 +726,12 @@ class ParallelEncodingBimap : public GenericDecodingTable<ParallelEncodingBimap<
 
   phmap::parallel_flat_hash_set<typename Base::Proxy, typename Base::Hasher, typename Base::EqualityComparator> set_;
 
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(uint32_t first_loaded_id) noexcept {
-    set_.reserve(Base::items_.size());
-    for (auto id = first_loaded_id; id != Base::items_.size(); ++id) {
+  template <ls_id_range R>
+  PROMPP_ALWAYS_INLINE void after_items_load_impl(R&& loaded_ids) noexcept {
+    if constexpr (std::ranges::sized_range<R>) {
+      set_.reserve(std::ranges::size(loaded_ids));
+    }
+    for (const auto id : loaded_ids) {
       set_.emplace(typename Base::Proxy(id));
     }
   }
@@ -788,8 +801,9 @@ class OrderedEncodingBimap : public GenericDecodingTable<OrderedEncodingBimap<Fi
   Set set_;
 
  protected:
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(uint32_t first_loaded_id) noexcept {
-    for (auto id = first_loaded_id; id != Base::items_.size(); ++id) {
+  template <ls_id_range R>
+  PROMPP_ALWAYS_INLINE void after_items_load_impl(R&& loaded_ids) noexcept {
+    for (const auto id : loaded_ids) {
       set_.emplace(typename Base::Proxy(id));
     }
   }
@@ -895,9 +909,12 @@ class EncodingBimapWithOrderedAccess : public GenericDecodingTable<EncodingBimap
   using Set = phmap::flat_hash_set<typename Base::Proxy, typename Base::Hasher, typename Base::EqualityComparator>;
   Set set_;
 
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(uint32_t first_loaded_id) noexcept {
-    set_.reserve(Base::items_.size());
-    for (auto id = first_loaded_id; id != Base::items_.size(); ++id) {
+  template <ls_id_range R>
+  PROMPP_ALWAYS_INLINE void after_items_load_impl(R&& loaded_ids) noexcept {
+    if constexpr (std::ranges::sized_range<R>) {
+      set_.reserve(std::ranges::size(loaded_ids));
+    }
+    for (const auto id : loaded_ids) {
       set_.emplace(typename Base::Proxy(id));
       ordered_set_.emplace(typename Base::Proxy(id));
     }
diff --git a/pp/series_index/queryable_encoding_bimap.h b/pp/series_index/queryable_encoding_bimap.h
index 1b265e320..5b368eccd 100644
--- a/pp/series_index/queryable_encoding_bimap.h
+++ b/pp/series_index/queryable_encoding_bimap.h
@@ -101,11 +101,14 @@ class QueryableEncodingBimap final : public BareBones::SnugComposite::GenericDec
 
   BareBones::Bitset added_series_;
 
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(uint32_t first_loaded_id) noexcept {
-    ls_id_hash_set_.reserve(Base::items_.size());
+  template <BareBones::SnugComposite::ls_id_range R>
+  PROMPP_ALWAYS_INLINE void after_items_load_impl(R&& loaded_ids) noexcept {
+    if constexpr (std::ranges::sized_range<R>) {
+      ls_id_hash_set_.reserve(std::ranges::size(loaded_ids));
+    }
 
     const auto hasher = Base::hasher();
-    for (auto ls_id = first_loaded_id; ls_id < Base::items_.size(); ++ls_id) {
+    for (const auto ls_id : loaded_ids) {
       auto label_set = this->operator[](ls_id);
       update_indexes(ls_id, label_set, phmap_hash(hasher(label_set)));
     }

From c5237dd0293f76d7e5f6d4c6734e25f9838c17a3 Mon Sep 17 00:00:00 2001
From: Vladimir Pustovalov <cherep@sura.ru>
Date: Mon, 17 Nov 2025 18:14:12 +0300
Subject: [PATCH 03/34] used lazy_emplace_with_hash instead of find/emplace

---
 pp/series_index/benchmarks/BUILD              | 10 +++
 .../benchmarks/find_or_emplace_benchmark.cpp  | 61 +++++++++++++++++++
 pp/series_index/queryable_encoding_bimap.h    | 20 +++---
 .../tests/queryable_encoding_bimap_tests.cpp  | 21 +++++++
 4 files changed, 102 insertions(+), 10 deletions(-)
 create mode 100644 pp/series_index/benchmarks/find_or_emplace_benchmark.cpp

diff --git a/pp/series_index/benchmarks/BUILD b/pp/series_index/benchmarks/BUILD
index 2c63db31e..591f7ab2f 100644
--- a/pp/series_index/benchmarks/BUILD
+++ b/pp/series_index/benchmarks/BUILD
@@ -8,4 +8,14 @@ cc_binary(
         "//:series_index",
         "//:benchmark",
     ],
+)
+
+cc_binary(
+    name = "find_or_emplace",
+    srcs = ["find_or_emplace_benchmark.cpp"],
+    malloc = "@jemalloc",
+    deps = [
+        "//:series_index",
+        "//:benchmark",
+    ],
 )
\ No newline at end of file
diff --git a/pp/series_index/benchmarks/find_or_emplace_benchmark.cpp b/pp/series_index/benchmarks/find_or_emplace_benchmark.cpp
new file mode 100644
index 000000000..79c1fe3b7
--- /dev/null
+++ b/pp/series_index/benchmarks/find_or_emplace_benchmark.cpp
@@ -0,0 +1,61 @@
+#include <benchmark/benchmark.h>
+
+#include "primitives/snug_composites.h"
+#include "profiling/profiling.h"
+#include "series_index/queryable_encoding_bimap.h"
+#include "series_index/trie/cedarpp_tree.h"
+
+namespace {
+
+using QueryableEncodingBimap =
+    series_index::QueryableEncodingBimap<PromPP::Primitives::SnugComposites::LabelSet::EncodingBimapFilament, BareBones::Vector, series_index::trie::CedarTrie>;
+
+std::string_view get_lss_file() {
+  if (auto& context = benchmark::internal::GetGlobalContext(); context != nullptr) {
+    return context->operator[]("lss_file");
+  }
+
+  return {};
+}
+
+QueryableEncodingBimap& get_lss() {
+  static QueryableEncodingBimap lss;
+  if (lss.size() == 0) {
+    std::ifstream infile(get_lss_file().data(), std::ios_base::binary);
+    infile >> lss;
+  }
+
+  return lss;
+}
+
+void BenchmarkFindOrEmplaceWithEmplace(benchmark::State& state) {
+  ZoneScoped;
+  const auto& lss = get_lss();
+
+  for ([[maybe_unused]] auto _ : state) {
+    QueryableEncodingBimap lss2;
+    for (const auto& label_set : lss) {
+      lss2.find_or_emplace(label_set);
+    }
+  }
+}
+
+void BenchmarkFindOrEmplaceWithFind(benchmark::State& state) {
+  ZoneScoped;
+  auto& lss = get_lss();
+
+  for ([[maybe_unused]] auto _ : state) {
+    for (const auto& label_set : lss) {
+      lss.find_or_emplace(label_set);
+    }
+  }
+}
+
+double min_value(const std::vector<double>& v) noexcept {
+  return *std::ranges::min_element(v);
+}
+
+BENCHMARK(BenchmarkFindOrEmplaceWithEmplace)->ComputeStatistics("min", min_value);
+BENCHMARK(BenchmarkFindOrEmplaceWithFind)->ComputeStatistics("min", min_value);
+
+}  // namespace
diff --git a/pp/series_index/queryable_encoding_bimap.h b/pp/series_index/queryable_encoding_bimap.h
index 1b265e320..4346589a9 100644
--- a/pp/series_index/queryable_encoding_bimap.h
+++ b/pp/series_index/queryable_encoding_bimap.h
@@ -50,14 +50,14 @@ class QueryableEncodingBimap final : public BareBones::SnugComposite::GenericDec
   template <class LabelSet>
   PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const LabelSet& label_set, size_t hash) noexcept {
     hash = phmap_hash(hash);
-    if (auto it = ls_id_hash_set_.find(label_set, hash); it != ls_id_hash_set_.end()) {
-      mark_series_as_added(*it);
-      return *it;
-    }
+    const auto ls_id = *ls_id_hash_set_.lazy_emplace_with_hash(label_set, hash, [&](const auto& ctor) {
+      auto new_ls_id = Base::items_.size();
+      ctor(typename Base::Proxy(new_ls_id));
+      auto composite_label_set = Base::items_.emplace_back(Base::data_, label_set).composite(Base::data());
+      update_indexes(new_ls_id, composite_label_set);
+      return new_ls_id;
+    });
 
-    auto ls_id = Base::items_.size();
-    auto composite_label_set = Base::items_.emplace_back(Base::data_, label_set).composite(Base::data());
-    update_indexes(ls_id, composite_label_set, hash);
     mark_series_as_added(ls_id);
     return ls_id;
   }
@@ -107,12 +107,12 @@ class QueryableEncodingBimap final : public BareBones::SnugComposite::GenericDec
     const auto hasher = Base::hasher();
     for (auto ls_id = first_loaded_id; ls_id < Base::items_.size(); ++ls_id) {
       auto label_set = this->operator[](ls_id);
-      update_indexes(ls_id, label_set, phmap_hash(hasher(label_set)));
+      ls_id_hash_set_.emplace_with_hash(phmap_hash(hasher(label_set)), typename Base::Proxy(ls_id));
+      update_indexes(ls_id, label_set);
     }
   }
 
-  void update_indexes(uint32_t ls_id, const LabelSet& label_set, size_t label_set_phmap_hash) {
-    ls_id_hash_set_.emplace_with_hash(label_set_phmap_hash, typename Base::Proxy(ls_id));
+  void update_indexes(uint32_t ls_id, const LabelSet& label_set) {
     auto ls_id_set_iterator = ls_id_set_.emplace(ls_id).first;
 
     for (auto label = label_set.begin(); label != label_set.end(); ++label) {
diff --git a/pp/series_index/tests/queryable_encoding_bimap_tests.cpp b/pp/series_index/tests/queryable_encoding_bimap_tests.cpp
index 72f2e3910..c606e302c 100644
--- a/pp/series_index/tests/queryable_encoding_bimap_tests.cpp
+++ b/pp/series_index/tests/queryable_encoding_bimap_tests.cpp
@@ -119,6 +119,27 @@ TEST_F(QueryableEncodingBimapFixture, EmplaceDuplicatedLabelSet) {
   EXPECT_NE(ls_id1, ls_id2);
 }
 
+TEST_F(QueryableEncodingBimapFixture, Load) {
+  // Arrange
+  const auto label_set1 = LabelViewSet{{"job", "cron"}, {"key", ""}, {"process", "php"}};
+  const auto label_set2 = LabelViewSet{{"job", "cron"}, {"key", ""}, {"process", "php1"}};
+
+  const auto ls_id1 = lss_.find_or_emplace(label_set1);
+  const auto ls_id2 = lss_.find_or_emplace(label_set2);
+
+  std::stringstream stream;
+  stream << lss_;
+
+  Lss lss2;
+
+  // Act
+  stream >> lss2;
+
+  // Assert
+  EXPECT_EQ(ls_id1, lss2.find(label_set1));
+  EXPECT_EQ(ls_id2, lss2.find(label_set2));
+}
+
 class QueryableEncodingBimapCopierFixture : public QueryableEncodingBimapFixture {
  protected:
   BareBones::Vector<uint32_t> dst_src_ids_mapping_;

From 0594e0954321179967f8679228f00c54f44ac8ed Mon Sep 17 00:00:00 2001
From: Vladimir Pustovalov <cherep@sura.ru>
Date: Tue, 18 Nov 2025 13:12:45 +0300
Subject: [PATCH 04/34] removed ParallelEncodingBimap

---
 pp/bare_bones/snug_composite.h                | 70 -------------------
 pp/bare_bones/tests/snug_composite_tests.cpp  |  1 -
 .../filling_snug_composites_from_stream.cpp   |  7 --
 pp/performance_tests/full_load_lss_test.cpp   | 18 -----
 pp/performance_tests/save_lss_to_wal_test.cpp |  2 +-
 pp/primitives/snug_composites.h               |  9 ---
 6 files changed, 1 insertion(+), 106 deletions(-)

diff --git a/pp/bare_bones/snug_composite.h b/pp/bare_bones/snug_composite.h
index 1056b6515..68707c8f4 100644
--- a/pp/bare_bones/snug_composite.h
+++ b/pp/bare_bones/snug_composite.h
@@ -708,76 +708,6 @@ class EncodingBimap : public GenericDecodingTable<EncodingBimap<Filament, Vector
   }
 };
 
-template <template <template <class> class> class Filament, template <class> class Vector>
-class ParallelEncodingBimap : public GenericDecodingTable<ParallelEncodingBimap<Filament, Vector>, Filament, Vector> {
-  using Base = GenericDecodingTable<ParallelEncodingBimap, Filament, Vector>;
-
-  friend class GenericDecodingTable<ParallelEncodingBimap, Filament, Vector>;
-
-  phmap::parallel_flat_hash_set<typename Base::Proxy, typename Base::Hasher, typename Base::EqualityComparator> set_;
-
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(uint32_t first_loaded_id) noexcept {
-    set_.reserve(Base::items_.size());
-    for (auto id = first_loaded_id; id != Base::items_.size(); ++id) {
-      set_.emplace(typename Base::Proxy(id));
-    }
-  }
-
- public:
-  inline __attribute__((always_inline)) ParallelEncodingBimap() noexcept : set_({}, 0, Base::hasher(), Base::equality_comparator()) {}
-
-  ParallelEncodingBimap(const ParallelEncodingBimap&) = delete;
-  ParallelEncodingBimap(ParallelEncodingBimap&&) = delete;
-  ParallelEncodingBimap& operator=(const ParallelEncodingBimap&) = delete;
-  ParallelEncodingBimap& operator=(ParallelEncodingBimap&&) = delete;
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t find_or_emplace(const Class& c) noexcept {
-    return *set_.lazy_emplace(c, [&](const auto& ctor) {
-      uint32_t id = Base::items_.size();
-      Base::items_.emplace_back(Base::data_, c);
-      ctor(id);
-    });
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t find_or_emplace(const Class& c, size_t hashval) noexcept {
-    return *set_.lazy_emplace_with_hash(c, phmap::phmap_mix<sizeof(size_t)>()(hashval), [&](const auto& ctor) {
-      uint32_t id = Base::items_.size();
-      Base::items_.emplace_back(Base::data_, c);
-      ctor(id);
-    });
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) std::optional<uint32_t> find(const Class& c) const noexcept {
-    if (auto i = set_.find(c); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) std::optional<uint32_t> find(const Class& c, size_t hashval) const noexcept {
-    if (auto i = set_.find(c, phmap::phmap_mix<sizeof(size_t)>()(hashval)); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  inline __attribute__((always_inline)) void rollback_impl(const typename Base::checkpoint_type& s) noexcept
-    requires(!Base::kIsReadOnly)
-  {
-    assert(s.size() <= Base::items_.size());
-
-    for (uint32_t i = s.size(); i != Base::items_.size(); ++i) {
-      set_.erase(typename Base::Proxy(i));
-    }
-  }
-
-  // TODO wrap everything with read/write mutex, and test it!
-};
-
 template <template <template <class> class> class Filament, template <class> class Vector>
 class OrderedEncodingBimap : public GenericDecodingTable<OrderedEncodingBimap<Filament, Vector>, Filament, Vector> {
   using Base = GenericDecodingTable<OrderedEncodingBimap, Filament, Vector>;
diff --git a/pp/bare_bones/tests/snug_composite_tests.cpp b/pp/bare_bones/tests/snug_composite_tests.cpp
index 92cdcf30b..78290b8a2 100644
--- a/pp/bare_bones/tests/snug_composite_tests.cpp
+++ b/pp/bare_bones/tests/snug_composite_tests.cpp
@@ -108,7 +108,6 @@ class TestSnugCompositesStringFilament {
 };
 
 typedef testing::Types<BareBones::SnugComposite::EncodingBimap<TestSnugCompositesStringFilament, Vector>,
-                       BareBones::SnugComposite::ParallelEncodingBimap<TestSnugCompositesStringFilament, Vector>,
                        BareBones::SnugComposite::OrderedEncodingBimap<TestSnugCompositesStringFilament, Vector>,
                        BareBones::SnugComposite::EncodingBimapWithOrderedAccess<TestSnugCompositesStringFilament, Vector>>
     SnugCompositesBimapTypes;
diff --git a/pp/integration_tests/filling_snug_composites_from_stream.cpp b/pp/integration_tests/filling_snug_composites_from_stream.cpp
index da0cda5e5..2dc8f6e28 100644
--- a/pp/integration_tests/filling_snug_composites_from_stream.cpp
+++ b/pp/integration_tests/filling_snug_composites_from_stream.cpp
@@ -55,13 +55,6 @@ TEST_F(SnugComposite, DecodingTable) {
   EXPECT_TRUE(std::ranges::equal(expected_result.begin(), expected_result.end(), actual_result.begin(), actual_result.end()));
 }
 
-TEST_F(SnugComposite, ParallelEncodingBimap) {
-  Primitives::SnugComposites::LabelSet::ParallelEncodingBimap<BareBones::Vector> actual_result;
-  lss_full_lz4_stream >> actual_result;
-
-  EXPECT_TRUE(std::ranges::equal(expected_result.begin(), expected_result.end(), actual_result.begin(), actual_result.end(), std::equal_to()));
-}
-
 TEST_F(SnugComposite, EncodingBimap) {
   Primitives::SnugComposites::LabelSet::EncodingBimap<BareBones::Vector> actual_result;
   lss_full_lz4_stream >> actual_result;
diff --git a/pp/performance_tests/full_load_lss_test.cpp b/pp/performance_tests/full_load_lss_test.cpp
index 31b9cd7d4..08b0c83ff 100644
--- a/pp/performance_tests/full_load_lss_test.cpp
+++ b/pp/performance_tests/full_load_lss_test.cpp
@@ -26,24 +26,6 @@ void full_load_lss::execute(const Config& config, Metrics& metrics) const {
                          << (std::chrono::duration_cast<std::chrono::microseconds>(now - start).count()));
   }
 
-  // test load time: ParallelEncodingBimap
-  {
-    std::ifstream infile(input_file_full_name(config), std::ios_base::binary);
-    BareBones::LZ4Stream::istream in(&infile);
-    if (!infile.is_open()) {
-      throw std::runtime_error("failed to open file '" + input_file_full_name(config) + "'");
-    }
-
-    Primitives::SnugComposites::LabelSet::ParallelEncodingBimap<BareBones::Vector> lss;
-
-    auto start = std::chrono::steady_clock::now();
-    in >> lss;
-    auto now = std::chrono::steady_clock::now();
-
-    metrics << (Metric() << "parallel_encoding_bimap_load_from_file_duration_microseconds"
-                         << (std::chrono::duration_cast<std::chrono::microseconds>(now - start).count()));
-  }
-
   // test load time: EncodingBimap
   {
     std::ifstream infile(input_file_full_name(config), std::ios_base::binary);
diff --git a/pp/performance_tests/save_lss_to_wal_test.cpp b/pp/performance_tests/save_lss_to_wal_test.cpp
index 2cd7a4eb9..ccc6fc53b 100644
--- a/pp/performance_tests/save_lss_to_wal_test.cpp
+++ b/pp/performance_tests/save_lss_to_wal_test.cpp
@@ -15,7 +15,7 @@ void save_lss_to_wal::execute(const Config& config, Metrics& metrics) const {
 
   DummyWal::Timeseries tmsr;
   DummyWal dummy_wal(input_file_full_name(config));
-  Primitives::SnugComposites::LabelSet::ParallelEncodingBimap<BareBones::Vector> lss;
+  Primitives::SnugComposites::LabelSet::EncodingBimap<BareBones::Vector> lss;
 
   auto checkpoint = lss.checkpoint();
 
diff --git a/pp/primitives/snug_composites.h b/pp/primitives/snug_composites.h
index fb70ac6a0..2d6bf1791 100644
--- a/pp/primitives/snug_composites.h
+++ b/pp/primitives/snug_composites.h
@@ -12,9 +12,6 @@ using DecodingTable = BareBones::SnugComposite::DecodingTable<Filaments::Symbol,
 template <template <class> class Vector>
 using EncodingBimap = BareBones::SnugComposite::EncodingBimap<Filaments::Symbol, Vector>;
 
-template <template <class> class Vector>
-using ParallelEncodingBimap = BareBones::SnugComposite::ParallelEncodingBimap<Filaments::Symbol, Vector>;
-
 template <template <class> class Vector>
 using OrderedEncodingBimap = BareBones::SnugComposite::OrderedEncodingBimap<Filaments::Symbol, Vector>;
 
@@ -77,12 +74,6 @@ using EncodingBimap = BareBones::SnugComposite::EncodingBimap<EncodingBimapFilam
 template <template <class> class Vector>
 using ShrinkableEncodingBimap = BareBones::SnugComposite::ShrinkableEncodingBimap<EncodingBimapFilament, Vector>;
 
-template <template <class> class Vector>
-using ParallelEncodingBimapFilament = Filaments::LabelSet<Symbol::EncodingBimap, LabelNameSet::EncodingBimap, Vector>;
-
-template <template <class> class Vector>
-using ParallelEncodingBimap = BareBones::SnugComposite::ParallelEncodingBimap<EncodingBimapFilament, Vector>;
-
 template <template <class> class Vector>
 using OrderedEncodingBimapFilament = Filaments::LabelSet<Symbol::OrderedEncodingBimap, LabelNameSet::OrderedEncodingBimap, Vector>;
 

From 6454d5fa0254ffafefb9fe26df50034289b87950 Mon Sep 17 00:00:00 2001
From: Vladimir Pustovalov <cherep@sura.ru>
Date: Tue, 18 Nov 2025 13:21:50 +0300
Subject: [PATCH 05/34] removed OrderedIndexingTable

---
 pp/bare_bones/snug_composite.h                | 87 -------------------
 pp/bare_bones/tests/snug_composite_tests.cpp  |  3 +-
 .../filling_snug_composites_from_stream.cpp   |  7 --
 pp/performance_tests/full_load_lss_test.cpp   | 18 ----
 ...ad_ordered_indexing_table_in_loop_test.cpp | 30 -------
 ...load_ordered_indexing_table_in_loop_test.h | 10 ---
 pp/performance_tests/performance_tests.cpp    |  2 -
 pp/primitives/snug_composites.h               | 21 -----
 8 files changed, 1 insertion(+), 177 deletions(-)
 delete mode 100644 pp/performance_tests/load_ordered_indexing_table_in_loop_test.cpp
 delete mode 100644 pp/performance_tests/load_ordered_indexing_table_in_loop_test.h

diff --git a/pp/bare_bones/snug_composite.h b/pp/bare_bones/snug_composite.h
index 68707c8f4..7320ff8e0 100644
--- a/pp/bare_bones/snug_composite.h
+++ b/pp/bare_bones/snug_composite.h
@@ -813,91 +813,4 @@ class OrderedDecodingTable : public GenericDecodingTable<OrderedDecodingTable<Fi
   }
 };
 
-template <template <template <class> class> class Filament, template <class> class Vector>
-class EncodingBimapWithOrderedAccess : public GenericDecodingTable<EncodingBimapWithOrderedAccess<Filament, Vector>, Filament, Vector> {
-  using Base = GenericDecodingTable<EncodingBimapWithOrderedAccess, Filament, Vector>;
-
-  friend class GenericDecodingTable<EncodingBimapWithOrderedAccess, Filament, Vector>;
-
-  using OrderedSet = phmap::btree_set<typename Base::Proxy, typename Base::LessComparator>;
-  OrderedSet ordered_set_;
-
-  using Set = phmap::flat_hash_set<typename Base::Proxy, typename Base::Hasher, typename Base::EqualityComparator>;
-  Set set_;
-
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(uint32_t first_loaded_id) noexcept {
-    set_.reserve(Base::items_.size());
-    for (auto id = first_loaded_id; id != Base::items_.size(); ++id) {
-      set_.emplace(typename Base::Proxy(id));
-      ordered_set_.emplace(typename Base::Proxy(id));
-    }
-  }
-
- public:
-  inline __attribute__((always_inline)) EncodingBimapWithOrderedAccess() noexcept
-      : ordered_set_({}, Base::less_comparator()), set_({}, 0, Base::hasher(), Base::equality_comparator()) {}
-
-  EncodingBimapWithOrderedAccess(const EncodingBimapWithOrderedAccess&) = delete;
-  EncodingBimapWithOrderedAccess(EncodingBimapWithOrderedAccess&&) = delete;
-  EncodingBimapWithOrderedAccess& operator=(const EncodingBimapWithOrderedAccess&) = delete;
-  EncodingBimapWithOrderedAccess& operator=(EncodingBimapWithOrderedAccess&&) = delete;
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t find_or_emplace(const Class& c) noexcept {
-    return *set_.lazy_emplace(c, [&](const auto& ctor) {
-      uint32_t id = Base::items_.size();
-      Base::items_.emplace_back(Base::data_, c);
-      ordered_set_.insert(typename Base::Proxy(id));
-      ctor(id);
-    });
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t find_or_emplace(const Class& c, size_t hashval) noexcept {
-    return *set_.lazy_emplace_with_hash(c, phmap::phmap_mix<sizeof(size_t)>()(hashval), [&](const auto& ctor) {
-      uint32_t id = Base::items_.size();
-      Base::items_.emplace_back(Base::data_, c);
-      ordered_set_.insert(typename Base::Proxy(id));
-      ctor(id);
-    });
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) std::optional<uint32_t> find(const Class& c) const noexcept {
-    if (auto i = set_.find(c); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) std::optional<uint32_t> find(const Class& c, size_t hashval) const noexcept {
-    if (auto i = set_.find(c, phmap::phmap_mix<sizeof(size_t)>()(hashval)); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  PROMPP_ALWAYS_INLINE void rollback_impl(const typename Base::checkpoint_type& s) noexcept
-    requires(!Base::kIsReadOnly)
-  {
-    assert(s.size() <= Base::items_.size());
-
-    for (uint32_t i = s.size(); i != Base::items_.size(); ++i) {
-      ordered_set_.erase(typename Base::Proxy(i));
-      set_.erase(typename Base::Proxy(i));
-    }
-  }
-
-  inline __attribute__((always_inline)) auto begin() const noexcept {
-    return typename Base::template ItemIDIterator<typename OrderedSet::const_iterator>(this, ordered_set_.begin());
-  }
-  inline __attribute__((always_inline)) auto end() const noexcept {
-    return typename Base::template IteratorSentinel<typename OrderedSet::const_iterator>(ordered_set_.end());
-  }
-
-  inline __attribute__((always_inline)) auto unordered_begin() const noexcept { return Base::begin(); }
-  inline __attribute__((always_inline)) auto unordered_end() const noexcept { return Base::end(); }
-};
-
 }  // namespace BareBones::SnugComposite
diff --git a/pp/bare_bones/tests/snug_composite_tests.cpp b/pp/bare_bones/tests/snug_composite_tests.cpp
index 78290b8a2..405274a3f 100644
--- a/pp/bare_bones/tests/snug_composite_tests.cpp
+++ b/pp/bare_bones/tests/snug_composite_tests.cpp
@@ -108,8 +108,7 @@ class TestSnugCompositesStringFilament {
 };
 
 typedef testing::Types<BareBones::SnugComposite::EncodingBimap<TestSnugCompositesStringFilament, Vector>,
-                       BareBones::SnugComposite::OrderedEncodingBimap<TestSnugCompositesStringFilament, Vector>,
-                       BareBones::SnugComposite::EncodingBimapWithOrderedAccess<TestSnugCompositesStringFilament, Vector>>
+                       BareBones::SnugComposite::OrderedEncodingBimap<TestSnugCompositesStringFilament, Vector>>
     SnugCompositesBimapTypes;
 
 template <class T>
diff --git a/pp/integration_tests/filling_snug_composites_from_stream.cpp b/pp/integration_tests/filling_snug_composites_from_stream.cpp
index 2dc8f6e28..7f74a9884 100644
--- a/pp/integration_tests/filling_snug_composites_from_stream.cpp
+++ b/pp/integration_tests/filling_snug_composites_from_stream.cpp
@@ -70,11 +70,4 @@ TEST_F(SnugComposite, OrderedEncodingBimap) {
       std::ranges::equal(expected_result.begin(), expected_result.end(), actual_result.unordered_begin(), actual_result.unordered_end(), std::equal_to()));
 }
 
-TEST_F(SnugComposite, OrderedIndexingTable) {
-  Primitives::SnugComposites::LabelSet::OrderedIndexingTable<BareBones::Vector> actual_result;
-  lss_full_lz4_stream >> actual_result;
-
-  EXPECT_TRUE(std::ranges::equal(expected_result.begin(), expected_result.end(), actual_result.begin(), actual_result.end(), std::equal_to()));
-}
-
 }  // namespace
diff --git a/pp/performance_tests/full_load_lss_test.cpp b/pp/performance_tests/full_load_lss_test.cpp
index 08b0c83ff..0d7d594d1 100644
--- a/pp/performance_tests/full_load_lss_test.cpp
+++ b/pp/performance_tests/full_load_lss_test.cpp
@@ -61,22 +61,4 @@ void full_load_lss::execute(const Config& config, Metrics& metrics) const {
     metrics << (Metric() << "ordered_encoding_bimap_load_from_file_duration_microseconds"
                          << (std::chrono::duration_cast<std::chrono::microseconds>(now - start).count()));
   }
-
-  // test load time: OrderedIndexingTable
-  {
-    std::ifstream infile(input_file_full_name(config), std::ios_base::binary);
-    if (!infile.is_open()) {
-      throw std::runtime_error("failed to open file '" + input_file_full_name(config) + "'");
-    }
-
-    Primitives::SnugComposites::LabelSet::OrderedIndexingTable<BareBones::Vector> lss;
-
-    BareBones::LZ4Stream::istream in(&infile);
-    auto start = std::chrono::steady_clock::now();
-    in >> lss;
-    auto now = std::chrono::steady_clock::now();
-
-    metrics << (Metric() << "ordered_indexing_table_load_from_file_duration_microseconds"
-                         << (std::chrono::duration_cast<std::chrono::microseconds>(now - start).count()));
-  }
 }
diff --git a/pp/performance_tests/load_ordered_indexing_table_in_loop_test.cpp b/pp/performance_tests/load_ordered_indexing_table_in_loop_test.cpp
deleted file mode 100644
index 94a49a273..000000000
--- a/pp/performance_tests/load_ordered_indexing_table_in_loop_test.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "load_ordered_indexing_table_in_loop_test.h"
-
-#include <chrono>
-
-#include "bare_bones/lz4_stream.h"
-#include "primitives/snug_composites.h"
-
-using namespace PromPP;  // NOLINT
-
-void load_ordered_indexing_table_in_loop::execute(const Config& config, Metrics& metrics) const {
-  Primitives::SnugComposites::LabelSet::OrderedEncodingBimap<BareBones::Vector> source_lss;
-  std::ifstream infile(input_file_full_name(config), std::ios_base::binary);
-  BareBones::LZ4Stream::istream in(&infile);
-  if (!infile.is_open()) {
-    throw std::runtime_error("failed to open file '" + input_file_full_name(config) + "'");
-  }
-
-  in >> source_lss;
-
-  // Load
-  Primitives::SnugComposites::LabelSet::OrderedIndexingTable<BareBones::Vector> lss;
-
-  auto start = std::chrono::steady_clock::now();
-  for (auto i = source_lss.begin(); i != source_lss.end(); ++i) {
-    lss.emplace_back(*i);
-  }
-  auto now = std::chrono::steady_clock::now();
-
-  metrics << (Metric() << "ordered_indexing_table_add_label_sets_one_by_one" << std::chrono::duration_cast<std::chrono::microseconds>(now - start).count());
-}
diff --git a/pp/performance_tests/load_ordered_indexing_table_in_loop_test.h b/pp/performance_tests/load_ordered_indexing_table_in_loop_test.h
deleted file mode 100644
index 17af1c89d..000000000
--- a/pp/performance_tests/load_ordered_indexing_table_in_loop_test.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-#include "test_with_input_only.h"
-
-struct load_ordered_indexing_table_in_loop : TestWithInputOnly {
-  std::string input_file_base_name() const final { return "lss_full"; }
-  bool has_output() const final { return false; }
-  std::string output_file_base_name() const final { return ""; }
-  void execute(const Config& config, Metrics& metrics) const final;
-};
diff --git a/pp/performance_tests/performance_tests.cpp b/pp/performance_tests/performance_tests.cpp
index 39e2e7da6..269126674 100644
--- a/pp/performance_tests/performance_tests.cpp
+++ b/pp/performance_tests/performance_tests.cpp
@@ -11,7 +11,6 @@
 #include "load_gorilla_from_wal_and_iterate_over_series_label_name_ids_test.h"
 #include "load_gorilla_from_wal_and_make_remote_write_from_it_test.h"
 #include "load_lss_from_wal_test.h"
-#include "load_ordered_indexing_table_in_loop_test.h"
 #include "load_protobuf_non_naned_wal_and_process_it_with_stale_nans.h"
 #include "load_protobuf_wal_and_save_gorilla_to_sharded_wal_test.h"
 #include "load_protobuf_wal_and_save_gorilla_to_wal_test.h"
@@ -72,7 +71,6 @@ int main([[maybe_unused]] int argc, char* argv[]) {
     test_db.add(std::make_unique<full_load_lss>());
     test_db.add(std::make_unique<performance_tests::SeriesDataEncoder>());
     test_db.add(std::make_unique<performance_tests::ChunkRecoder>());
-    test_db.add(std::make_unique<load_ordered_indexing_table_in_loop>());
     test_db.add(std::make_unique<save_gorilla_to_wal>());
     test_db.add(std::make_unique<performance_tests::series_index::GenerateSeriesReverseIndex>());
     test_db.add(std::make_unique<performance_tests::series_index::GenerateCedarppSeriesIndex>());
diff --git a/pp/primitives/snug_composites.h b/pp/primitives/snug_composites.h
index 2d6bf1791..78bd392a6 100644
--- a/pp/primitives/snug_composites.h
+++ b/pp/primitives/snug_composites.h
@@ -15,9 +15,6 @@ using EncodingBimap = BareBones::SnugComposite::EncodingBimap<Filaments::Symbol,
 template <template <class> class Vector>
 using OrderedEncodingBimap = BareBones::SnugComposite::OrderedEncodingBimap<Filaments::Symbol, Vector>;
 
-template <template <class> class Vector>
-using EncodingBimapWithOrderedAccess = BareBones::SnugComposite::EncodingBimapWithOrderedAccess<Filaments::Symbol, Vector>;
-
 template <template <class> class Vector>
 using OrderedDecodingTable = BareBones::SnugComposite::OrderedDecodingTable<Filaments::Symbol, Vector>;
 
@@ -43,18 +40,6 @@ using OrderedEncodingBimapFilament = Filaments::LabelNameSet<Symbol::OrderedEnco
 template <template <class> class Vector>
 using OrderedEncodingBimap = BareBones::SnugComposite::OrderedEncodingBimap<OrderedEncodingBimapFilament, Vector>;
 
-template <template <class> class Vector>
-using EncodingBimapWithOrderedAccessFilament = Filaments::LabelNameSet<Symbol::EncodingBimapWithOrderedAccess, Vector>;
-
-template <template <class> class Vector>
-using EncodingBimapWithOrderedAccess = BareBones::SnugComposite::EncodingBimapWithOrderedAccess<EncodingBimapWithOrderedAccessFilament, Vector>;
-
-template <template <class> class Vector>
-using EncodingBimapWithOrderedAccessToSymbolsFilament = Filaments::LabelNameSet<Symbol::EncodingBimapWithOrderedAccess, Vector>;
-
-template <template <class> class Vector>
-using EncodingBimapWithOrderedAccessToSymbols = BareBones::SnugComposite::EncodingBimap<EncodingBimapWithOrderedAccessToSymbolsFilament, Vector>;
-
 }  // namespace LabelNameSet
 
 namespace LabelSet {
@@ -80,12 +65,6 @@ using OrderedEncodingBimapFilament = Filaments::LabelSet<Symbol::OrderedEncoding
 template <template <class> class Vector>
 using OrderedEncodingBimap = BareBones::SnugComposite::OrderedEncodingBimap<OrderedEncodingBimapFilament, Vector>;
 
-template <template <class> class Vector>
-using OrderedIndexingTableFilament = Filaments::LabelSet<Symbol::EncodingBimapWithOrderedAccess, LabelNameSet::EncodingBimapWithOrderedAccessToSymbols, Vector>;
-
-template <template <class> class Vector>
-using OrderedIndexingTable = BareBones::SnugComposite::OrderedDecodingTable<OrderedIndexingTableFilament, Vector>;
-
 }  // namespace LabelSet
 
 }  // namespace PromPP::Primitives::SnugComposites
\ No newline at end of file

From 7cf742cba7abfaeeb866d08897069650f9baf710 Mon Sep 17 00:00:00 2001
From: Vladimir Pustovalov <cherep@sura.ru>
Date: Tue, 18 Nov 2025 13:34:17 +0300
Subject: [PATCH 06/34] removed OrderedEncodingBimap

---
 pp/bare_bones/snug_composite.h                | 105 ------------------
 pp/bare_bones/tests/snug_composite_tests.cpp  |  70 ++++++------
 pp/entrypoint/head/lss.h                      |   9 +-
 pp/go/cppbridge/primitives_lss.go             |   6 -
 pp/go/cppbridge/primitives_lss_test.go        |   8 --
 .../filling_snug_composites_from_stream.cpp   |   8 --
 pp/performance_tests/full_load_lss_test.cpp   |  18 ---
 pp/primitives/snug_composites.h               |  18 ---
 pp/primitives/tests/snug_composites_tests.cpp |   7 --
 pp/prometheus/tests/relabeler_tests.cpp       |   1 -
 10 files changed, 33 insertions(+), 217 deletions(-)

diff --git a/pp/bare_bones/snug_composite.h b/pp/bare_bones/snug_composite.h
index 7320ff8e0..e8526fe41 100644
--- a/pp/bare_bones/snug_composite.h
+++ b/pp/bare_bones/snug_composite.h
@@ -708,109 +708,4 @@ class EncodingBimap : public GenericDecodingTable<EncodingBimap<Filament, Vector
   }
 };
 
-template <template <template <class> class> class Filament, template <class> class Vector>
-class OrderedEncodingBimap : public GenericDecodingTable<OrderedEncodingBimap<Filament, Vector>, Filament, Vector> {
-  using Base = GenericDecodingTable<OrderedEncodingBimap, Filament, Vector>;
-
-  friend class GenericDecodingTable<OrderedEncodingBimap, Filament, Vector>;
-
-  using Set = phmap::btree_set<typename Base::Proxy, typename Base::LessComparator>;
-  Set set_;
-
- protected:
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(uint32_t first_loaded_id) noexcept {
-    for (auto id = first_loaded_id; id != Base::items_.size(); ++id) {
-      set_.emplace(typename Base::Proxy(id));
-    }
-  }
-
- public:
-  inline __attribute__((always_inline)) OrderedEncodingBimap() noexcept : set_({}, Base::less_comparator()) {}
-
-  OrderedEncodingBimap(const OrderedEncodingBimap&) = delete;
-  OrderedEncodingBimap(OrderedEncodingBimap&&) = delete;
-  OrderedEncodingBimap& operator=(const OrderedEncodingBimap&) = delete;
-  OrderedEncodingBimap& operator=(OrderedEncodingBimap&&) = delete;
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t find_or_emplace(const Class& c) noexcept {
-    auto i = set_.lower_bound(c);
-    if (i != set_.end() && (*this)[*i] == c) {
-      return *i;
-    }
-
-    uint32_t id = Base::items_.size();
-    Base::items_.emplace_back(Base::data_, c);
-    set_.insert(i, typename Base::Proxy(id));
-
-    return id;
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t find_or_emplace(const Class& c, [[maybe_unused]] size_t hashval) noexcept {
-    return find_or_emplace(c);
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) std::optional<uint32_t> find(const Class& c) const noexcept {
-    if (auto i = set_.find(c); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) std::optional<uint32_t> find(const Class& c, [[maybe_unused]] size_t hashval) const noexcept {
-    if (auto i = set_.find(c); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  PROMPP_ALWAYS_INLINE void rollback_impl(const typename Base::checkpoint_type& s) noexcept
-    requires(!Base::kIsReadOnly)
-  {
-    assert(s.size() <= Base::items_.size());
-
-    for (uint32_t i = s.size(); i != Base::items_.size(); ++i) {
-      set_.erase(typename Base::Proxy(i));
-    }
-  }
-
-  inline __attribute__((always_inline)) auto begin() const noexcept {
-    return typename Base::template ItemIDIterator<typename Set::const_iterator>(this, set_.begin());
-  }
-  inline __attribute__((always_inline)) auto end() const noexcept { return typename Base::template IteratorSentinel<typename Set::const_iterator>(set_.end()); }
-
-  inline __attribute__((always_inline)) auto unordered_begin() const noexcept { return Base::begin(); }
-  inline __attribute__((always_inline)) auto unordered_end() const noexcept { return Base::end(); }
-};
-
-template <template <template <class> class> class Filament, template <class> class Vector>
-class OrderedDecodingTable : public GenericDecodingTable<OrderedDecodingTable<Filament, Vector>, Filament, Vector> {
-  using Base = GenericDecodingTable<OrderedDecodingTable, Filament, Vector>;
-
- public:
-  using Base::Base;
-  OrderedDecodingTable(const OrderedDecodingTable&) = delete;
-  OrderedDecodingTable(OrderedDecodingTable&&) = delete;
-  OrderedDecodingTable& operator=(const OrderedDecodingTable&) = delete;
-  OrderedDecodingTable& operator=(OrderedDecodingTable&&) = delete;
-
-  auto back() const noexcept { return Base::items_.back().composite(Base::data_); }
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t emplace_back(const Class& c) {
-    const uint32_t id = Base::items_.size();
-
-    if (id != 0 && c < back()) {
-      throw BareBones::Exception(0xf677f03159e75ee7, "Broken order of OrderedDecodingTable item emplacement");
-    }
-
-    Base::items_.emplace_back(Base::data_, c);
-
-    return id;
-  }
-};
-
 }  // namespace BareBones::SnugComposite
diff --git a/pp/bare_bones/tests/snug_composite_tests.cpp b/pp/bare_bones/tests/snug_composite_tests.cpp
index 405274a3f..49f8b51ff 100644
--- a/pp/bare_bones/tests/snug_composite_tests.cpp
+++ b/pp/bare_bones/tests/snug_composite_tests.cpp
@@ -107,9 +107,7 @@ class TestSnugCompositesStringFilament {
   }
 };
 
-typedef testing::Types<BareBones::SnugComposite::EncodingBimap<TestSnugCompositesStringFilament, Vector>,
-                       BareBones::SnugComposite::OrderedEncodingBimap<TestSnugCompositesStringFilament, Vector>>
-    SnugCompositesBimapTypes;
+typedef testing::Types<BareBones::SnugComposite::EncodingBimap<TestSnugCompositesStringFilament, Vector>> SnugCompositesBimapTypes;
 
 template <class T>
 struct SnugComposite : public testing::Test {
@@ -139,30 +137,28 @@ TYPED_TEST(SnugComposite, should_return_same_id_for_same_data) {
 }
 
 TYPED_TEST(SnugComposite, should_return_same_id_for_same_data_with_hash) {
-  if constexpr (!std::is_same_v<TypeParam, BareBones::SnugComposite::OrderedEncodingBimap<TestSnugCompositesStringFilament, Vector>>) {
-    TypeParam outcomes;
-    this->fill_table_with_random_values(outcomes);
+  TypeParam outcomes;
+  this->fill_table_with_random_values(outcomes);
 
-    std::string v = "12";
-    auto hash_val = BareBones::XXHash::hash(v);
-    auto id = outcomes.find_or_emplace(v, hash_val);
+  std::string v = "12";
+  auto hash_val = BareBones::XXHash::hash(v);
+  auto id = outcomes.find_or_emplace(v, hash_val);
 
-    EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
-    EXPECT_EQ(id, outcomes.find_or_emplace(v));
+  EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
+  EXPECT_EQ(id, outcomes.find_or_emplace(v));
 
-    EXPECT_EQ(outcomes.find_or_emplace(v, hash_val), outcomes.find(v, hash_val));
-    EXPECT_EQ(outcomes.find_or_emplace(v, hash_val), outcomes.find(v));
+  EXPECT_EQ(outcomes.find_or_emplace(v, hash_val), outcomes.find(v, hash_val));
+  EXPECT_EQ(outcomes.find_or_emplace(v, hash_val), outcomes.find(v));
 
-    v = "21";
-    hash_val = BareBones::XXHash::hash(v);
-    id = outcomes.find_or_emplace(v);
+  v = "21";
+  hash_val = BareBones::XXHash::hash(v);
+  id = outcomes.find_or_emplace(v);
 
-    EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
-    EXPECT_EQ(id, outcomes.find_or_emplace(v));
+  EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
+  EXPECT_EQ(id, outcomes.find_or_emplace(v));
 
-    EXPECT_EQ(outcomes.find_or_emplace(v), outcomes.find(v));
-    EXPECT_EQ(outcomes.find_or_emplace(v), outcomes.find(v, hash_val));
-  }
+  EXPECT_EQ(outcomes.find_or_emplace(v), outcomes.find(v));
+  EXPECT_EQ(outcomes.find_or_emplace(v), outcomes.find(v, hash_val));
 }
 
 TYPED_TEST(SnugComposite, should_return_different_id_for_different_data) {
@@ -181,29 +177,27 @@ TYPED_TEST(SnugComposite, should_return_different_id_for_different_data) {
 }
 
 TYPED_TEST(SnugComposite, should_return_different_id_for_different_data_with_hash) {
-  if constexpr (!std::is_same_v<TypeParam, BareBones::SnugComposite::OrderedEncodingBimap<TestSnugCompositesStringFilament, Vector>>) {
-    TypeParam outcomes;
-    this->fill_table_with_random_values(outcomes);
+  TypeParam outcomes;
+  this->fill_table_with_random_values(outcomes);
 
-    std::string v = "12";
-    size_t hash_val = std::hash<std::string>()(v);
-    auto id = outcomes.find_or_emplace(v, hash_val);
+  std::string v = "12";
+  size_t hash_val = std::hash<std::string>()(v);
+  auto id = outcomes.find_or_emplace(v, hash_val);
 
-    v = "21";
-    hash_val = std::hash<std::string>()(v);
+  v = "21";
+  hash_val = std::hash<std::string>()(v);
 
-    EXPECT_NE(id, outcomes.find_or_emplace(v, hash_val));
-    EXPECT_NE(id, outcomes.find_or_emplace(v));
+  EXPECT_NE(id, outcomes.find_or_emplace(v, hash_val));
+  EXPECT_NE(id, outcomes.find_or_emplace(v));
 
-    v = "13";
-    id = outcomes.find_or_emplace(v);
+  v = "13";
+  id = outcomes.find_or_emplace(v);
 
-    v = "31";
-    hash_val = std::hash<std::string>()(v);
+  v = "31";
+  hash_val = std::hash<std::string>()(v);
 
-    EXPECT_NE(id, outcomes.find_or_emplace(v, hash_val));
-    EXPECT_NE(id, outcomes.find_or_emplace(v));
-  }
+  EXPECT_NE(id, outcomes.find_or_emplace(v, hash_val));
+  EXPECT_NE(id, outcomes.find_or_emplace(v));
 }
 
 TYPED_TEST(SnugComposite, should_assign_new_ids_after_rollback) {
diff --git a/pp/entrypoint/head/lss.h b/pp/entrypoint/head/lss.h
index 4114ab24b..48d8cfc60 100644
--- a/pp/entrypoint/head/lss.h
+++ b/pp/entrypoint/head/lss.h
@@ -16,13 +16,10 @@ using LsIdsSlicePtr = std::unique_ptr<LsIdsSlice>;
 
 enum class LssType : uint32_t {
   kEncodingBimap = 0,
-  kOrderedEncodingBimap,
   kQueryableEncodingBimap,
   kReadonlyLss,
 };
 
-using OrderedEncodingBimap = PromPP::Primitives::SnugComposites::LabelSet::OrderedEncodingBimap<BareBones::Vector>;
-
 namespace lss_memory {
 
 thread_local inline bool has_reallocations{};
@@ -96,7 +93,7 @@ class ReallocationsDetector {
   }
 };
 
-using LssVariant = std::variant<EncodingBimap, OrderedEncodingBimap, QueryableEncodingBimap, ReadonlyLss>;
+using LssVariant = std::variant<EncodingBimap, QueryableEncodingBimap, ReadonlyLss>;
 using LssVariantPtr = std::unique_ptr<LssVariant>;
 
 static_assert(sizeof(LssVariantPtr) == sizeof(void*));
@@ -107,10 +104,6 @@ inline LssVariantPtr create_lss(LssType type) {
       return std::make_unique<LssVariant>(std::in_place_index<static_cast<int>(LssType::kEncodingBimap)>);
     }
 
-    case LssType::kOrderedEncodingBimap: {
-      return std::make_unique<LssVariant>(std::in_place_index<static_cast<int>(LssType::kOrderedEncodingBimap)>);
-    }
-
     case LssType::kQueryableEncodingBimap: {
       return std::make_unique<LssVariant>(std::in_place_index<static_cast<int>(LssType::kQueryableEncodingBimap)>);
     }
diff --git a/pp/go/cppbridge/primitives_lss.go b/pp/go/cppbridge/primitives_lss.go
index a0bef17dc..01328ac92 100644
--- a/pp/go/cppbridge/primitives_lss.go
+++ b/pp/go/cppbridge/primitives_lss.go
@@ -9,7 +9,6 @@ import (
 
 const (
 	lssEncodingBimap uint32 = iota
-	lssOrderedEncodingBimap
 	lssQueryableEncodingBimap
 )
 
@@ -39,11 +38,6 @@ func NewLssStorage() *LabelSetStorage {
 	return newLabelSetStorage(lssEncodingBimap)
 }
 
-// NewOrderedLssStorage init new LabelSetStorage based on OrderedEncodingBimap.
-func NewOrderedLssStorage() *LabelSetStorage {
-	return newLabelSetStorage(lssOrderedEncodingBimap)
-}
-
 // NewQueryableLssStorage init new LabelSetStorage based on QueryableEncodingBimap.
 func NewQueryableLssStorage() *LabelSetStorage {
 	return newLabelSetStorage(lssQueryableEncodingBimap)
diff --git a/pp/go/cppbridge/primitives_lss_test.go b/pp/go/cppbridge/primitives_lss_test.go
index d004ef5d9..f7e0c2c68 100644
--- a/pp/go/cppbridge/primitives_lss_test.go
+++ b/pp/go/cppbridge/primitives_lss_test.go
@@ -32,14 +32,6 @@ func (s *LSSSuite) TestLSS() {
 	s.Require().NotEqual(0, cp)
 }
 
-func (s *LSSSuite) TestOrderedLSS() {
-	lss := cppbridge.NewOrderedLssStorage()
-
-	s.Equal(uint64(0), lss.AllocatedMemory())
-	cp := lss.Pointer()
-	s.Require().NotEqual(0, cp)
-}
-
 func (s *LSSSuite) TestQueryableLSS() {
 	lss := cppbridge.NewQueryableLssStorage()
 
diff --git a/pp/integration_tests/filling_snug_composites_from_stream.cpp b/pp/integration_tests/filling_snug_composites_from_stream.cpp
index 7f74a9884..35e1fcc8e 100644
--- a/pp/integration_tests/filling_snug_composites_from_stream.cpp
+++ b/pp/integration_tests/filling_snug_composites_from_stream.cpp
@@ -62,12 +62,4 @@ TEST_F(SnugComposite, EncodingBimap) {
   EXPECT_TRUE(std::ranges::equal(expected_result.begin(), expected_result.end(), actual_result.begin(), actual_result.end(), std::equal_to()));
 }
 
-TEST_F(SnugComposite, OrderedEncodingBimap) {
-  Primitives::SnugComposites::LabelSet::OrderedEncodingBimap<BareBones::Vector> actual_result;
-  lss_full_lz4_stream >> actual_result;
-
-  EXPECT_TRUE(
-      std::ranges::equal(expected_result.begin(), expected_result.end(), actual_result.unordered_begin(), actual_result.unordered_end(), std::equal_to()));
-}
-
 }  // namespace
diff --git a/pp/performance_tests/full_load_lss_test.cpp b/pp/performance_tests/full_load_lss_test.cpp
index 0d7d594d1..fef198e2e 100644
--- a/pp/performance_tests/full_load_lss_test.cpp
+++ b/pp/performance_tests/full_load_lss_test.cpp
@@ -43,22 +43,4 @@ void full_load_lss::execute(const Config& config, Metrics& metrics) const {
     metrics << (Metric() << "encoding_bimap_load_from_file_duration_microseconds"
                          << (std::chrono::duration_cast<std::chrono::microseconds>(now - start).count()));
   }
-
-  // test load time: OrderedEncodingBimap
-  {
-    std::ifstream infile(input_file_full_name(config), std::ios_base::binary);
-    if (!infile.is_open()) {
-      throw std::runtime_error("failed to open file '" + input_file_full_name(config) + "'");
-    }
-
-    Primitives::SnugComposites::LabelSet::OrderedEncodingBimap<BareBones::Vector> lss;
-
-    BareBones::LZ4Stream::istream in(&infile);
-    auto start = std::chrono::steady_clock::now();
-    in >> lss;
-    auto now = std::chrono::steady_clock::now();
-
-    metrics << (Metric() << "ordered_encoding_bimap_load_from_file_duration_microseconds"
-                         << (std::chrono::duration_cast<std::chrono::microseconds>(now - start).count()));
-  }
 }
diff --git a/pp/primitives/snug_composites.h b/pp/primitives/snug_composites.h
index 78bd392a6..00d2226d0 100644
--- a/pp/primitives/snug_composites.h
+++ b/pp/primitives/snug_composites.h
@@ -12,12 +12,6 @@ using DecodingTable = BareBones::SnugComposite::DecodingTable<Filaments::Symbol,
 template <template <class> class Vector>
 using EncodingBimap = BareBones::SnugComposite::EncodingBimap<Filaments::Symbol, Vector>;
 
-template <template <class> class Vector>
-using OrderedEncodingBimap = BareBones::SnugComposite::OrderedEncodingBimap<Filaments::Symbol, Vector>;
-
-template <template <class> class Vector>
-using OrderedDecodingTable = BareBones::SnugComposite::OrderedDecodingTable<Filaments::Symbol, Vector>;
-
 }  // namespace Symbol
 
 namespace LabelNameSet {
@@ -34,12 +28,6 @@ using EncodingBimapFilament = Filaments::LabelNameSet<Symbol::EncodingBimap, Vec
 template <template <class> class Vector>
 using EncodingBimap = BareBones::SnugComposite::EncodingBimap<EncodingBimapFilament, Vector>;
 
-template <template <class> class Vector>
-using OrderedEncodingBimapFilament = Filaments::LabelNameSet<Symbol::OrderedEncodingBimap, Vector>;
-
-template <template <class> class Vector>
-using OrderedEncodingBimap = BareBones::SnugComposite::OrderedEncodingBimap<OrderedEncodingBimapFilament, Vector>;
-
 }  // namespace LabelNameSet
 
 namespace LabelSet {
@@ -59,12 +47,6 @@ using EncodingBimap = BareBones::SnugComposite::EncodingBimap<EncodingBimapFilam
 template <template <class> class Vector>
 using ShrinkableEncodingBimap = BareBones::SnugComposite::ShrinkableEncodingBimap<EncodingBimapFilament, Vector>;
 
-template <template <class> class Vector>
-using OrderedEncodingBimapFilament = Filaments::LabelSet<Symbol::OrderedEncodingBimap, LabelNameSet::OrderedEncodingBimap, Vector>;
-
-template <template <class> class Vector>
-using OrderedEncodingBimap = BareBones::SnugComposite::OrderedEncodingBimap<OrderedEncodingBimapFilament, Vector>;
-
 }  // namespace LabelSet
 
 }  // namespace PromPP::Primitives::SnugComposites
\ No newline at end of file
diff --git a/pp/primitives/tests/snug_composites_tests.cpp b/pp/primitives/tests/snug_composites_tests.cpp
index 3e5d57ffe..870f472ca 100644
--- a/pp/primitives/tests/snug_composites_tests.cpp
+++ b/pp/primitives/tests/snug_composites_tests.cpp
@@ -62,13 +62,6 @@ using LabelSet = GenericLabelSet<Vector>;
 
 struct SnugComposites : public testing::Test {};
 
-TEST(SnugComposites, OrderedDecodingTableWithSymbolsHandlesZeroStringAsFirstElementCorrectly) {
-  PromPP::Primitives::SnugComposites::Symbol::OrderedDecodingTable<Vector> t;
-
-  EXPECT_EQ(t.emplace_back(""), 0);
-  EXPECT_EQ(t[0], "");
-}
-
 TEST(SnugComposites, SnapshotRollbackSymbolEncodingBimap) {
   PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_bimap;
 
diff --git a/pp/prometheus/tests/relabeler_tests.cpp b/pp/prometheus/tests/relabeler_tests.cpp
index 54056f0ab..83a5198fa 100644
--- a/pp/prometheus/tests/relabeler_tests.cpp
+++ b/pp/prometheus/tests/relabeler_tests.cpp
@@ -19,7 +19,6 @@ using PromPP::Primitives::Sample;
 using PromPP::Primitives::Timestamp;
 using PromPP::Primitives::Go::SliceView;
 using PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap;
-using PromPP::Primitives::SnugComposites::LabelSet::OrderedEncodingBimap;
 using PromPP::Prometheus::Relabel::hard_validate;
 using PromPP::Prometheus::Relabel::InnerSerie;
 using PromPP::Prometheus::Relabel::InnerSeries;

From aa07e6caef744f100ebb5577bdd1f8a5ed37cfb7 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Thu, 4 Dec 2025 16:14:00 +0300
Subject: [PATCH 07/34] tmp v2

---
 pp/bare_bones/snug_composite_v2.h | 570 ++++++++++++++++++++++++++++++
 1 file changed, 570 insertions(+)
 create mode 100644 pp/bare_bones/snug_composite_v2.h

diff --git a/pp/bare_bones/snug_composite_v2.h b/pp/bare_bones/snug_composite_v2.h
new file mode 100644
index 000000000..56d54486d
--- /dev/null
+++ b/pp/bare_bones/snug_composite_v2.h
@@ -0,0 +1,570 @@
+#pragma once
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#include <parallel_hashmap/btree.h>
+#include <parallel_hashmap/phmap.h>
+#pragma GCC diagnostic pop
+
+#include <scope_exit.h>
+
+#include <ranges>
+
+#include "bare_bones/allocator.h"
+#include "bare_bones/exception.h"
+#include "bare_bones/streams.h"
+#include "bare_bones/vector.h"
+#include "bare_bones/xxhash.h"
+
+namespace BareBones::SnugComposite::V2 {
+
+/**
+ * Serialization mode used to annotate encoded data and how to apply it on container.
+ * We use Delta for save difference between two states of container. It doesn't matter
+ * how first state was made (from snapshot or other delta). Snapshot may be explain
+ * as delta from init (zero) state.
+ */
+enum class SerializationMode : char { SNAPSHOT = 1, DELTA = 2 };
+
+template <class Range>
+concept ls_id_range = std::ranges::range<Range> && std::same_as<std::ranges::range_value_t<Range>, uint32_t>;
+
+template <class FilamentDataType>
+concept is_shrinkable = requires(FilamentDataType& data_type) {
+  { data_type.shrink_to(uint32_t()) };
+};
+
+template <class Derived>
+concept has_next_item_index = requires(Derived derived) {
+  { derived.next_item_index_impl() };
+};
+
+template <class Derived, class Checkpoint>
+concept has_rollback = requires(Derived derived, const Checkpoint& checkpoint) {
+  { derived.rollback_impl(checkpoint) };
+};
+
+template <class Derived, class R>
+concept has_after_items_load = ls_id_range<R> && requires(Derived derived, R&& range) { derived.after_items_load_impl(std::forward<R>(range)); };
+
+template <class Derived, template <template <class> class> class Filament, template <class> class Vector>
+class GenericDecodingTable {
+  static_assert(!std::is_integral_v<typename Filament<Vector>::composite_type>, "Filament::composite_type can't be an integral type");
+
+  template <class AnyDerived, template <template <class> class> class AnyFilament, template <class> class AnyVector>
+  friend class GenericDecodingTable;
+
+ public:
+  using storage_type = Filament<Vector>::storage_type;
+  using value_type = typename storage_type::composite_type;
+
+  static constexpr bool kIsReadOnly = IsSharedSpan<Vector<uint8_t>>::value;
+
+  static constexpr auto kInvalidId = std::numeric_limits<uint32_t>::max();
+
+ protected:
+  class Proxy {
+    uint32_t id_;
+
+   public:
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    PROMPP_ALWAYS_INLINE Proxy(uint32_t id) noexcept : id_(id) {}
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    PROMPP_ALWAYS_INLINE operator uint32_t() const noexcept { return id_; }
+
+    PROMPP_ALWAYS_INLINE bool operator==(const Proxy& o) noexcept { return id_ == o.id_; }
+  };
+
+  struct Hasher {
+    using is_transparent = void;
+
+    const GenericDecodingTable* decoding_table;
+    PROMPP_ALWAYS_INLINE explicit Hasher(const GenericDecodingTable* _decoding_table = nullptr) noexcept : decoding_table(_decoding_table) {}
+
+    PROMPP_ALWAYS_INLINE size_t operator()(const std::string_view& str) const noexcept { return XXHash::hash(str); }
+    PROMPP_ALWAYS_INLINE size_t operator()(const std::string& str) const noexcept { return XXHash::hash(str); }
+
+    template <class Class>
+    PROMPP_ALWAYS_INLINE size_t operator()(const Class& c) const noexcept {
+      return phmap::Hash<Class>()(c);
+    }
+
+    PROMPP_ALWAYS_INLINE size_t operator()(const Proxy& p) const noexcept { return this->operator()(decoding_table->storage_.composite(p)); }
+  };
+
+  struct EqualityComparator {
+    using is_transparent = void;
+
+    const GenericDecodingTable* decoding_table;
+    PROMPP_ALWAYS_INLINE explicit EqualityComparator(const GenericDecodingTable* _decoding_table = nullptr) noexcept : decoding_table(_decoding_table) {}
+
+    PROMPP_ALWAYS_INLINE bool operator()(const Proxy& a, const Proxy& b) const noexcept { return a == b; }
+
+    template <class Class>
+    PROMPP_ALWAYS_INLINE bool operator()(const Proxy& a, const Class& b) const noexcept {
+      return decoding_table->storage_.composite(a) == b;
+    }
+  };
+
+  struct LessComparator {
+    using is_transparent = void;
+
+    PROMPP_ALWAYS_INLINE explicit LessComparator(const GenericDecodingTable* decoding_table) noexcept : decoding_table_(decoding_table) {}
+
+    PROMPP_ALWAYS_INLINE bool operator()(const Proxy& a, const Proxy& b) const noexcept {
+      return decoding_table_->storage_.composite(a) < decoding_table_->storage_.composite(b);
+    }
+
+    template <class Class>
+    PROMPP_ALWAYS_INLINE bool operator()(const Proxy& a, const Class& b) const noexcept {
+      return decoding_table_->storage_.composite(a) < b;
+    }
+
+    template <class Class>
+      requires(!std::is_same_v<Class, Proxy>)
+    PROMPP_ALWAYS_INLINE bool operator()(const Class& a, const Proxy& b) const noexcept {
+      return a < decoding_table_->storage_.composite(b);
+    }
+
+   private:
+    const GenericDecodingTable* decoding_table_;
+  };
+
+  template <class DecodingTable>
+  class Checkpoint {
+    const DecodingTable* decoding_table_;
+    uint32_t next_item_index_;
+    uint32_t size_;
+    typename storage_type::checkpoint_type data_checkpoint_;
+
+   public:
+    explicit PROMPP_ALWAYS_INLINE Checkpoint(const DecodingTable& decoding_table, uint32_t next_item_index) noexcept
+        : decoding_table_(&decoding_table),
+          next_item_index_(next_item_index),
+          size_(decoding_table.size()),
+          data_checkpoint_(decoding_table.data().checkpoint()) {}
+
+    [[nodiscard]] PROMPP_ALWAYS_INLINE size_t size() const noexcept { return size_; }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return next_item_index_; }
+
+    const typename storage_type::checkpoint_type& data_checkpoint() const noexcept { return data_checkpoint_; }
+
+    template <OutputStream S>
+    void save(S& out, const Checkpoint* from = nullptr) const {
+      auto original_exceptions = out.exceptions();
+      auto sg1 = std::experimental::scope_exit([&]() { out.exceptions(original_exceptions); });
+      out.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+
+      // write version
+      out.put(2);
+
+      // write mode
+      SerializationMode mode = (from != nullptr) ? SerializationMode::DELTA : SerializationMode::SNAPSHOT;
+      out.put(static_cast<char>(mode));
+
+      // write index of first item in the portion
+      uint32_t first_to_save_i = 0;
+      if (from != nullptr) {
+        first_to_save_i = from->next_item_index_;
+        out.write(reinterpret_cast<const char*>(&from->next_item_index_), sizeof(from->next_item_index_));
+      }
+      const uint32_t first_item_index_in_decoding_table = decoding_table_->next_item_index() - decoding_table_->items().size();
+      assert(first_to_save_i >= first_item_index_in_decoding_table);
+
+      // write size
+      uint32_t size_to_save = next_item_index_ - first_to_save_i;
+      out.write(reinterpret_cast<char*>(&size_to_save), sizeof(size_to_save));
+      // if there are no items to write, we finish here
+      if (!size_to_save) {
+        return;
+      }
+
+      // write items
+      out.write(reinterpret_cast<const char*>(&decoding_table_->items()[first_to_save_i - first_item_index_in_decoding_table]),
+                sizeof(Filament<Vector>) * size_to_save);
+
+      // write data
+      if (from != nullptr) {
+        data_checkpoint_.save(out, decoding_table_->data(), &from->data_checkpoint_);
+      } else {
+        data_checkpoint_.save(out, decoding_table_->data());
+      }
+    }
+
+    template <OutputStream S>
+    friend S& operator<<(S& out, const Checkpoint& cp) {
+      cp.save(out);
+      return out;
+    }
+
+    size_t save_size(const Checkpoint* from = nullptr) const noexcept {
+      // version is written and read by methods put() and get() and they write and read 1 byte
+      size_t res = 1 + sizeof(SerializationMode);
+
+      // index of first item in the portion
+      uint32_t first_to_save_i = 0;
+      if (from != nullptr) {
+        first_to_save_i = from->next_item_index_;
+        res += sizeof(uint32_t);
+      }
+
+      // size
+      const uint32_t size_to_save = next_item_index_ - first_to_save_i;
+      res += sizeof(uint32_t);
+
+      // if there are no items to write, we finish here
+      if (!size_to_save)
+        return res;
+
+      // items
+      res += sizeof(Filament<Vector>) * size_to_save;
+
+      // data
+      if (from != nullptr) {
+        res += data_checkpoint_.save_size(decoding_table_->data(), &from->data_checkpoint_);
+      } else {
+        res += data_checkpoint_.save_size(decoding_table_->data());
+      }
+
+      return res;
+    }
+
+    /**
+     * ATTENTION! This class persists only pointers to checkpoint. It's a user resposability
+     * to prevent using delta out of checkpoints scope!
+     */
+    class Delta {
+      Checkpoint const* from_;
+      Checkpoint const* to_;
+
+     public:
+      PROMPP_ALWAYS_INLINE Delta(Checkpoint const& from, Checkpoint const& to) noexcept : from_(&from), to_(&to) {}
+
+      [[nodiscard]] bool empty() const noexcept { return from_->size() >= to_->size(); }
+
+      template <OutputStream S>
+      friend S& operator<<(S& out, Delta dt) {
+        dt.to_->save(out, dt.from_);
+        return out;
+      }
+
+      [[nodiscard]] size_t save_size() const noexcept { return to_->save_size(from_); }
+    };
+
+    Delta operator-(const Checkpoint& from) const noexcept { return Delta(from, *this); }
+  };
+
+  [[nodiscard]] PROMPP_ALWAYS_INLINE Hasher hasher() const noexcept { return Hasher(this); }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE EqualityComparator equality_comparator() const noexcept { return EqualityComparator(this); }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE LessComparator less_comparator() const noexcept { return LessComparator(this); }
+
+  storage_type storage_;
+
+ public:
+  using checkpoint_type = Checkpoint<GenericDecodingTable>;
+  using delta_type = typename checkpoint_type::Delta;
+
+  GenericDecodingTable() noexcept = default;
+  GenericDecodingTable(const GenericDecodingTable& other) = delete;
+
+  template <class AnotherDerived, template <template <class> class> class AnotherFilament, template <class> class AnotherVector>
+    requires kIsReadOnly
+  explicit GenericDecodingTable(const GenericDecodingTable<AnotherDerived, AnotherFilament, AnotherVector>& other) : storage_(other.storage_) {}
+
+  GenericDecodingTable(GenericDecodingTable&& other) noexcept = delete;
+  GenericDecodingTable& operator=(const GenericDecodingTable& other) = delete;
+  GenericDecodingTable& operator=(GenericDecodingTable&& other) noexcept = delete;
+
+  PROMPP_ALWAYS_INLINE value_type operator[](uint32_t id) const noexcept { return storage_.composite(id); }
+
+  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return storage_.size(); }
+
+  [[nodiscard]] PROMPP_ALWAYS_INLINE size_t allocated_memory() const noexcept { return mem::allocated_memory(storage_); }
+
+  template <class DerivedOther, template <template <class> class> class FilamentOther, template <class> class VectorOther>
+  PROMPP_ALWAYS_INLINE void reserve(const GenericDecodingTable<DerivedOther, FilamentOther, VectorOther>& other) {
+    storage_.reserve(other.items_.size());
+  }
+
+  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept {
+    if constexpr (has_next_item_index<Derived>) {
+      return static_cast<const Derived*>(this)->next_item_index_impl();
+    } else {
+      return storage_.next_item_index();
+    }
+  }
+
+  PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return checkpoint_type(*this, storage_.size()); }
+
+  PROMPP_ALWAYS_INLINE void rollback(const checkpoint_type& s) noexcept
+    requires(!kIsReadOnly)
+  {
+    if constexpr (has_rollback<Derived, checkpoint_type>) {
+      static_cast<Derived*>(this)->rollback_impl(s);
+    }
+
+    if constexpr (!kIsReadOnly) {
+      assert(s.size() <= storage_.size());
+      storage_.rollback(s.data_checkpoint());
+    }
+  }
+
+  template <InputStream S>
+  void load(S& in) {
+    // read version
+    const uint8_t version = in.get();
+
+    // return successfully if stream is empty
+    if (in.eof()) {
+      return;
+    }
+
+    // check version
+    if (version != 2) {
+      throw BareBones::Exception(0x343b7bcc6814f2d5, "Invalid EncodingSequence version %d got from input stream, only version 2 is supported", version);
+    }
+
+    auto original_exceptions = in.exceptions();
+    auto sg1 = std::experimental::scope_exit([&]() { in.exceptions(original_exceptions); });
+    in.exceptions(std::ifstream::failbit | std::ifstream::badbit | std::ifstream::eofbit);
+
+    // read mode
+    const auto mode = static_cast<SerializationMode>(in.get());
+
+    // read index of the first item in the portion if we are reading wal
+    uint32_t first_to_load_i = 0;
+    if (mode == SerializationMode::DELTA) {
+      in.read(reinterpret_cast<char*>(&first_to_load_i), sizeof(first_to_load_i));
+    }
+    if (first_to_load_i != next_item_index()) {
+      if (mode == SerializationMode::SNAPSHOT) {
+        throw BareBones::Exception(0x7bcd6011e39bbabc, "Attempt to load snapshot into non-empty DecodingTable");
+      } else if (first_to_load_i < storage_.size()) {
+        throw BareBones::Exception(0x3387739a7b4f574a, "Attempt to load segment over existing DecodingTable data");
+      } else {
+        throw BareBones::Exception(0x4ece66e098927bc6,
+                                   "Attempt to load incomplete data from segment, DecodingTable data vector length (%u) is less than segment size(%d)",
+                                   storage_.size(), first_to_load_i);
+      }
+    }
+
+    auto storage_checkpoint = storage_.checkpoint();
+    auto sg2 = std::experimental::scope_fail([&]() { storage_.rollback(storage_checkpoint); });
+    const auto loaded_range = storage_.load(in);
+
+    // post-processing
+    if constexpr (has_after_items_load<Derived, decltype(loaded_range)>) {
+      static_assert(noexcept(static_cast<Derived*>(this)->after_items_load_impl(loaded_range)));
+      static_cast<Derived*>(this)->after_items_load_impl(loaded_range);
+    }
+  }
+
+  template <OutputStream S>
+  friend S& operator<<(S& out, GenericDecodingTable& decoding_table) {
+    out << decoding_table.checkpoint();
+    return out;
+  }
+
+  template <InputStream S>
+  friend S& operator>>(S& in, GenericDecodingTable& decoding_table) {
+    decoding_table.load(in);
+    return in;
+  }
+
+  PROMPP_ALWAYS_INLINE auto begin() const noexcept { return storage_.begin(); }
+  PROMPP_ALWAYS_INLINE auto end() const noexcept { return storage_.end(); }
+
+  PROMPP_ALWAYS_INLINE auto remainder_size() const noexcept { return this->storage_.remainder_size(); }
+};
+
+template <template <template <class> class> class Filament, template <class> class Vector>
+class DecodingTable : public GenericDecodingTable<DecodingTable<Filament, Vector>, Filament, Vector> {
+ public:
+  using Base = GenericDecodingTable<DecodingTable, Filament, Vector>;
+
+  using Base::Base;
+};
+
+template <template <template <class> class> class Filament, template <class> class Vector>
+  requires is_shrinkable<typename Filament<Vector>::data_type>
+class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEncodingBimap<Filament, Vector>, Filament, Vector> {
+ public:
+  using Base = GenericDecodingTable<ShrinkableEncodingBimap, Filament, Vector>;
+  using checkpoint_type = typename Base::template Checkpoint<ShrinkableEncodingBimap>;
+  using delta_type = typename checkpoint_type::Delta;
+  using value_type = typename Base::value_type;
+
+  using Base::load;
+  using Base::next_item_index;
+  using Base::size;
+
+  friend class GenericDecodingTable<ShrinkableEncodingBimap, Filament, Vector>;
+
+  template <class Class>
+  PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const Class& c) noexcept {
+    return *set_.lazy_emplace(c, [&](const auto& ctor) {
+      const auto id = Base::storage_.emplace_back(c);
+      ctor(id);
+    }) + shift_;
+  }
+
+  template <class Class>
+  PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const Class& c, size_t hashval) noexcept {
+    return *set_.lazy_emplace_with_hash(c, phmap::phmap_mix<sizeof(size_t)>()(hashval), [&](const auto& ctor) {
+      const auto id = Base::storage_.emplace_back(c);
+      ctor(id);
+    }) + shift_;
+  }
+
+  template <class Class>
+  PROMPP_ALWAYS_INLINE std::optional<uint32_t> find(const Class& c) const noexcept {
+    if (auto i = set_.find(c); i != set_.end()) {
+      return *i + shift_;
+    }
+    return {};
+  }
+
+  template <class Class>
+  PROMPP_ALWAYS_INLINE std::optional<uint32_t> find(const Class& c, size_t hashval) const noexcept {
+    if (auto i = set_.find(c, phmap::phmap_mix<sizeof(size_t)>()(hashval)); i != set_.end()) {
+      return *i + shift_;
+    }
+    return {};
+  }
+
+  PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return checkpoint_type(*this, next_item_index_impl()); }
+
+  void shrink_to_checkpoint_size(const checkpoint_type& checkpoint) {
+    if (checkpoint.next_item_index() != next_item_index_impl()) {
+      throw Exception(0x1bf0dbff9fe3d955, "Invalid checkpoint to shrink: checkpoint next_item_index [%u], next_item_index [%u]", checkpoint.next_item_index(),
+                      next_item_index_impl());
+    }
+
+    shift_ += Base::size();
+    Base::storage_.shrink();
+    set_.clear();
+  }
+
+  [[nodiscard]] PROMPP_ALWAYS_INLINE size_t allocated_memory() const noexcept { return Base::allocated_memory() + set_allocated_memory_; }
+
+  PROMPP_ALWAYS_INLINE value_type operator[](uint32_t id) const noexcept {
+    assert(id >= shift_);
+    return Base::operator[](id - shift_);
+  }
+
+  template <InputStream S>
+  friend S& operator>>(S& in, ShrinkableEncodingBimap& shrinkable_encoding_bimap) {
+    shrinkable_encoding_bimap.load(in);
+    return in;
+  }
+
+ private:
+  uint32_t set_allocated_memory_{};
+  phmap::flat_hash_set<typename Base::Proxy, typename Base::Hasher, typename Base::EqualityComparator, Allocator<typename Base::Proxy, uint32_t>> set_{
+      {},
+      0,
+      Base::hasher(),
+      Base::equality_comparator(),
+      Allocator<typename Base::Proxy, uint32_t>{set_allocated_memory_}};
+  uint32_t shift_{0};
+
+  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index_impl() const noexcept { return shift_ + Base::size(); }
+
+  template <ls_id_range R>
+  PROMPP_ALWAYS_INLINE void after_items_load_impl(R&& loaded_ids) noexcept {
+    if constexpr (std::ranges::sized_range<R>) {
+      set_.reserve(std::ranges::size(loaded_ids));
+    }
+    for (const auto id : loaded_ids) {
+      set_.emplace(typename Base::Proxy(id));
+    }
+  }
+};
+
+template <template <template <class> class> class Filament, template <class> class Vector>
+class EncodingBimap : public GenericDecodingTable<EncodingBimap<Filament, Vector>, Filament, Vector> {
+  using Base = GenericDecodingTable<EncodingBimap, Filament, Vector>;
+
+  friend class GenericDecodingTable<EncodingBimap, Filament, Vector>;
+
+  phmap::flat_hash_set<typename Base::Proxy, typename Base::Hasher, typename Base::EqualityComparator> set_{{}, 0, Base::hasher(), Base::equality_comparator()};
+
+  template <ls_id_range R>
+  PROMPP_ALWAYS_INLINE void after_items_load_impl(R&& loaded_ids) noexcept {
+    if constexpr (std::ranges::sized_range<R>) {
+      set_.reserve(std::ranges::size(loaded_ids));
+    }
+    for (const auto id : loaded_ids) {
+      set_.emplace(typename Base::Proxy(id));
+    }
+  }
+
+ public:
+  EncodingBimap() noexcept = default;
+  EncodingBimap(const EncodingBimap& other) = delete;
+  EncodingBimap(EncodingBimap&&) noexcept = delete;
+  EncodingBimap& operator=(const EncodingBimap&) = delete;
+  EncodingBimap& operator=(EncodingBimap&&) noexcept = delete;
+
+  template <class Class>
+  PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const Class& c) noexcept {
+    return *set_.lazy_emplace(c, [&](const auto& ctor) {
+      const uint32_t id = Base::storage_.emplace_back(c);
+      ctor(id);
+    });
+  }
+
+  template <class Class>
+  PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const Class& c, size_t hashval) noexcept {
+    return *set_.lazy_emplace_with_hash(c, phmap::phmap_mix<sizeof(size_t)>()(hashval), [&](const auto& ctor) {
+      const uint32_t id = Base::storage_.emplace_back(Base::data_, c);
+      ctor(id);
+    });
+  }
+
+  template <class Class, class Cache, class... Args>
+  PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_with_cache(const Class& c, uint32_t id, Cache& cache, Args&&... args) noexcept {
+    if (const auto value = cache[id]; value != Base::kInvalidId) {
+      return value;
+    }
+
+    return *set_.lazy_emplace(c, [&](const auto& ctor) {
+      uint32_t new_id = Base::storage_.emplace_back(Base::data_, c, std::forward<Args>(args)...);
+      ctor(new_id);
+      cache[id] = new_id;
+    });
+  }
+
+  template <class Class>
+  PROMPP_ALWAYS_INLINE std::optional<uint32_t> find(const Class& c) const noexcept {
+    if (auto i = set_.find(c); i != set_.end()) {
+      return *i;
+    }
+    return {};
+  }
+
+  template <class Class>
+  PROMPP_ALWAYS_INLINE std::optional<uint32_t> find(const Class& c, size_t hashval) const noexcept {
+    if (auto i = set_.find(c, phmap::phmap_mix<sizeof(size_t)>()(hashval)); i != set_.end()) {
+      return *i;
+    }
+    return {};
+  }
+
+  PROMPP_ALWAYS_INLINE void rollback_impl(const typename Base::checkpoint_type& s) noexcept
+    requires(!Base::kIsReadOnly)
+  {
+    assert(s.size() <= Base::size());
+
+    for (uint32_t i = s.size(); i != Base::items_.size(); ++i) {
+      set_.erase(typename Base::Proxy(i));
+    }
+  }
+
+  [[nodiscard]] PROMPP_ALWAYS_INLINE size_t allocated_memory() const noexcept {
+    return Base::allocated_memory() + set_.capacity() * sizeof(typename Base::Proxy);
+  }
+};
+
+}  // namespace BareBones::SnugComposite::V2

From cd127dfd87c32936f5afbb9637162b8f709dbf32 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Wed, 10 Dec 2025 18:25:13 +0300
Subject: [PATCH 08/34] working symbol

---
 pp/bare_bones/iterator.h                      |   4 +
 pp/bare_bones/snug_composite_v2.h             |  79 ++++---
 pp/primitives/snug_composites_filaments.h     | 206 +++++++++++++++++-
 .../tests/snug_composites_filaments_tests.cpp |  66 ++++++
 4 files changed, 312 insertions(+), 43 deletions(-)

diff --git a/pp/bare_bones/iterator.h b/pp/bare_bones/iterator.h
index 6b6c0cedf..a26c30e51 100644
--- a/pp/bare_bones/iterator.h
+++ b/pp/bare_bones/iterator.h
@@ -9,6 +9,10 @@
 
 namespace BareBones::iterator {
 
+// std-compatible universal sentinel
+using IteratorSentinelType = std::default_sentinel_t;
+inline constexpr IteratorSentinelType kSentinel = {};
+
 template <class Operation>
 class OperationIterator {
  public:
diff --git a/pp/bare_bones/snug_composite_v2.h b/pp/bare_bones/snug_composite_v2.h
index 56d54486d..01482d81a 100644
--- a/pp/bare_bones/snug_composite_v2.h
+++ b/pp/bare_bones/snug_composite_v2.h
@@ -20,8 +20,8 @@ namespace BareBones::SnugComposite::V2 {
 
 /**
  * Serialization mode used to annotate encoded data and how to apply it on container.
- * We use Delta for save difference between two states of container. It doesn't matter
- * how first state was made (from snapshot or other delta). Snapshot may be explain
+ * We use Delta to save the difference between two states of container. It doesn't matter
+ * how the first state was made (from snapshot or other delta). Snapshot may be explained
  * as delta from init (zero) state.
  */
 enum class SerializationMode : char { SNAPSHOT = 1, DELTA = 2 };
@@ -56,7 +56,7 @@ class GenericDecodingTable {
 
  public:
   using storage_type = Filament<Vector>::storage_type;
-  using value_type = typename storage_type::composite_type;
+  using value_type = Filament<Vector>::composite_type;
 
   static constexpr bool kIsReadOnly = IsSharedSpan<Vector<uint8_t>>::value;
 
@@ -131,24 +131,20 @@ class GenericDecodingTable {
     const GenericDecodingTable* decoding_table_;
   };
 
-  template <class DecodingTable>
   class Checkpoint {
-    const DecodingTable* decoding_table_;
+    const storage_type* storage_ptr_;
     uint32_t next_item_index_;
     uint32_t size_;
-    typename storage_type::checkpoint_type data_checkpoint_;
+    typename storage_type::checkpoint_type storage_checkpoint_;
 
    public:
-    explicit PROMPP_ALWAYS_INLINE Checkpoint(const DecodingTable& decoding_table, uint32_t next_item_index) noexcept
-        : decoding_table_(&decoding_table),
-          next_item_index_(next_item_index),
-          size_(decoding_table.size()),
-          data_checkpoint_(decoding_table.data().checkpoint()) {}
+    explicit PROMPP_ALWAYS_INLINE Checkpoint(const storage_type& storage, uint32_t next_item_index, uint32_t size) noexcept
+        : storage_ptr_(&storage), next_item_index_(next_item_index), size_(size), storage_checkpoint_(storage.checkpoint()) {}
 
     [[nodiscard]] PROMPP_ALWAYS_INLINE size_t size() const noexcept { return size_; }
     [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return next_item_index_; }
 
-    const typename storage_type::checkpoint_type& data_checkpoint() const noexcept { return data_checkpoint_; }
+    const typename storage_type::checkpoint_type& storage_checkpoint() const noexcept { return storage_checkpoint_; }
 
     template <OutputStream S>
     void save(S& out, const Checkpoint* from = nullptr) const {
@@ -156,20 +152,21 @@ class GenericDecodingTable {
       auto sg1 = std::experimental::scope_exit([&]() { out.exceptions(original_exceptions); });
       out.exceptions(std::ifstream::failbit | std::ifstream::badbit);
 
-      // write version
+      // write a version
       out.put(2);
 
       // write mode
       SerializationMode mode = (from != nullptr) ? SerializationMode::DELTA : SerializationMode::SNAPSHOT;
       out.put(static_cast<char>(mode));
 
-      // write index of first item in the portion
+      // write index of the first item in the portion
       uint32_t first_to_save_i = 0;
       if (from != nullptr) {
         first_to_save_i = from->next_item_index_;
         out.write(reinterpret_cast<const char*>(&from->next_item_index_), sizeof(from->next_item_index_));
       }
-      const uint32_t first_item_index_in_decoding_table = decoding_table_->next_item_index() - decoding_table_->items().size();
+      const uint32_t first_item_index_in_decoding_table = next_item_index_ - size_;
+      const uint32_t id_offset = first_to_save_i - first_item_index_in_decoding_table;
       assert(first_to_save_i >= first_item_index_in_decoding_table);
 
       // write size
@@ -180,15 +177,11 @@ class GenericDecodingTable {
         return;
       }
 
-      // write items
-      out.write(reinterpret_cast<const char*>(&decoding_table_->items()[first_to_save_i - first_item_index_in_decoding_table]),
-                sizeof(Filament<Vector>) * size_to_save);
-
       // write data
       if (from != nullptr) {
-        data_checkpoint_.save(out, decoding_table_->data(), &from->data_checkpoint_);
+        storage_checkpoint_.save(out, *storage_ptr_, id_offset, size_to_save, &from->storage_checkpoint_);
       } else {
-        data_checkpoint_.save(out, decoding_table_->data());
+        storage_checkpoint_.save(out, *storage_ptr_, id_offset, size_to_save);
       }
     }
 
@@ -202,7 +195,7 @@ class GenericDecodingTable {
       // version is written and read by methods put() and get() and they write and read 1 byte
       size_t res = 1 + sizeof(SerializationMode);
 
-      // index of first item in the portion
+      // index of the first item in the portion
       uint32_t first_to_save_i = 0;
       if (from != nullptr) {
         first_to_save_i = from->next_item_index_;
@@ -217,22 +210,19 @@ class GenericDecodingTable {
       if (!size_to_save)
         return res;
 
-      // items
-      res += sizeof(Filament<Vector>) * size_to_save;
-
       // data
       if (from != nullptr) {
-        res += data_checkpoint_.save_size(decoding_table_->data(), &from->data_checkpoint_);
+        res += storage_checkpoint_.save_size(&storage_ptr_, &from->storage_checkpoint_);
       } else {
-        res += data_checkpoint_.save_size(decoding_table_->data());
+        res += storage_checkpoint_.save_size(&storage_ptr_);
       }
 
       return res;
     }
 
     /**
-     * ATTENTION! This class persists only pointers to checkpoint. It's a user resposability
-     * to prevent using delta out of checkpoints scope!
+     * ATTENTION! This class persists only pointers to checkpoint. It's a user responsibility
+     * to prevent using delta out of checkpoint scope!
      */
     class Delta {
       Checkpoint const* from_;
@@ -262,7 +252,7 @@ class GenericDecodingTable {
   storage_type storage_;
 
  public:
-  using checkpoint_type = Checkpoint<GenericDecodingTable>;
+  using checkpoint_type = Checkpoint;
   using delta_type = typename checkpoint_type::Delta;
 
   GenericDecodingTable() noexcept = default;
@@ -284,7 +274,7 @@ class GenericDecodingTable {
 
   template <class DerivedOther, template <template <class> class> class FilamentOther, template <class> class VectorOther>
   PROMPP_ALWAYS_INLINE void reserve(const GenericDecodingTable<DerivedOther, FilamentOther, VectorOther>& other) {
-    storage_.reserve(other.items_.size());
+    storage_.reserve(other.storage_);
   }
 
   [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept {
@@ -295,18 +285,18 @@ class GenericDecodingTable {
     }
   }
 
-  PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return checkpoint_type(*this, storage_.size()); }
+  PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return checkpoint_type(storage_, next_item_index(), size()); }
 
-  PROMPP_ALWAYS_INLINE void rollback(const checkpoint_type& s) noexcept
+  PROMPP_ALWAYS_INLINE void rollback(const checkpoint_type& checkpoint) noexcept
     requires(!kIsReadOnly)
   {
     if constexpr (has_rollback<Derived, checkpoint_type>) {
-      static_cast<Derived*>(this)->rollback_impl(s);
+      static_cast<Derived*>(this)->rollback_impl(checkpoint);
     }
 
     if constexpr (!kIsReadOnly) {
-      assert(s.size() <= storage_.size());
-      storage_.rollback(s.data_checkpoint());
+      assert(checkpoint.size() <= storage_.size());
+      storage_.rollback(checkpoint.storage_checkpoint());
     }
   }
 
@@ -315,7 +305,7 @@ class GenericDecodingTable {
     // read version
     const uint8_t version = in.get();
 
-    // return successfully if stream is empty
+    // return successfully if the stream is empty
     if (in.eof()) {
       return;
     }
@@ -349,9 +339,18 @@ class GenericDecodingTable {
       }
     }
 
+    // read size
+    uint32_t size_to_load;
+    in.read(reinterpret_cast<char*>(&size_to_load), sizeof(size_to_load));
+
+    // read is completed if there are no items
+    if (!size_to_load) {
+      return;
+    }
+
     auto storage_checkpoint = storage_.checkpoint();
     auto sg2 = std::experimental::scope_fail([&]() { storage_.rollback(storage_checkpoint); });
-    const auto loaded_range = storage_.load(in);
+    const auto loaded_range = storage_.load(in, size_to_load);
 
     // post-processing
     if constexpr (has_after_items_load<Derived, decltype(loaded_range)>) {
@@ -518,7 +517,7 @@ class EncodingBimap : public GenericDecodingTable<EncodingBimap<Filament, Vector
   template <class Class>
   PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const Class& c, size_t hashval) noexcept {
     return *set_.lazy_emplace_with_hash(c, phmap::phmap_mix<sizeof(size_t)>()(hashval), [&](const auto& ctor) {
-      const uint32_t id = Base::storage_.emplace_back(Base::data_, c);
+      const uint32_t id = Base::storage_.emplace_back(c);
       ctor(id);
     });
   }
@@ -530,7 +529,7 @@ class EncodingBimap : public GenericDecodingTable<EncodingBimap<Filament, Vector
     }
 
     return *set_.lazy_emplace(c, [&](const auto& ctor) {
-      uint32_t new_id = Base::storage_.emplace_back(Base::data_, c, std::forward<Args>(args)...);
+      uint32_t new_id = Base::storage_.emplace_back(c, std::forward<Args>(args)...);
       ctor(new_id);
       cache[id] = new_id;
     });
diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index b2f7421f6..4c27a8c41 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -3,6 +3,8 @@
 #include <scope_exit.h>
 
 #include "bare_bones/exception.h"
+#include "bare_bones/iterator.h"
+#include "bare_bones/memory.h"
 #include "bare_bones/snug_composite.h"
 #include "bare_bones/stream_v_byte.h"
 #include "hash.h"
@@ -10,7 +12,7 @@
 namespace PromPP::Primitives::SnugComposites::Filaments {
 
 template <template <class> class Vector>
-class Symbol {
+struct Symbol {
   uint32_t pos_;
   uint32_t length_;
 
@@ -167,6 +169,204 @@ class Symbol {
   }
 
   [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t length() const noexcept { return length_; }
+
+  struct storage_type {
+    struct item_type {
+      uint32_t pos;
+      uint32_t length;
+    };
+
+    struct checkpoint_type {
+      uint32_t data_size;
+      uint32_t items_size;
+
+      using SerializationMode = BareBones::SnugComposite::SerializationMode;
+
+      template <BareBones::OutputStream S>
+      void save(S& out, const storage_type& storage, uint32_t id_offset, uint32_t id_count, checkpoint_type const* from = nullptr) const {
+        // write a version
+        out.put(1);
+
+        // write mode
+        SerializationMode mode = (from != nullptr) ? SerializationMode::DELTA : SerializationMode::SNAPSHOT;
+        out.put(static_cast<char>(mode));
+
+        // write pos of the first seq in the portion if we are writing delta
+        uint32_t first_to_save = 0;
+        if (from != nullptr) {
+          first_to_save = from->data_size;
+          out.write(reinterpret_cast<const char*>(&first_to_save), sizeof(first_to_save));
+        }
+
+        // write size
+        uint32_t size_to_save = data_size - first_to_save;
+        out.write(reinterpret_cast<char*>(&size_to_save), sizeof(size_to_save));
+
+        // write data
+        if (size_to_save > 0) {
+          out.write(&storage.data[first_to_save], size_to_save);
+        }
+
+        // write items
+        out.write(reinterpret_cast<const char*>(&storage.items[id_offset]), sizeof(item_type) * id_count);
+      }
+
+      uint32_t save_size(const storage_type&, uint32_t, uint32_t id_count, checkpoint_type const* from = nullptr) const {
+        uint32_t res = 0;
+
+        // version
+        ++res;
+
+        // mode
+        ++res;
+
+        // pos of first seq in the portion, if we are writing delta
+        uint32_t first_to_save = 0;
+        if (from != nullptr) {
+          first_to_save = from->data_size;
+          res += sizeof(uint32_t);  // first index
+        }
+
+        // size
+        const uint32_t size_to_save = data_size - first_to_save;
+        res += sizeof(uint32_t);
+
+        // data
+        res += size_to_save;
+
+        // items
+        res += sizeof(item_type) * id_count;
+
+        return res;
+      }
+    };
+
+    static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
+
+    Vector<char> data;
+    Vector<item_type> items;
+
+    [[nodiscard]] uint32_t size() const noexcept { return items.size(); }
+    [[nodiscard]] size_t remainder_size() const noexcept {
+      constexpr size_t max_ui32 = std::numeric_limits<uint32_t>::max();
+      assert(this->size() <= max_ui32);
+      return max_ui32 - this->size();
+    }
+
+    template <template <class> class OtherVector>
+    void reserve(const typename Symbol<OtherVector>::storage_type& other) noexcept {
+      items.reserve(other.items_.size());
+      data.reserve(other.data_.size());
+    }
+
+    [[nodiscard]] composite_type composite(uint32_t id) const noexcept {
+      const auto item = items[id];
+      return std::string_view(data.data() + item.pos, item.length);
+    }
+
+    void validate(uint32_t id) const {
+      if (const auto item = items[id]; item.pos + item.length > data.size()) {
+        throw BareBones::Exception(0x75555f55ebe357a3, "Symbol validation error: length is out of data vector range");
+      }
+    }
+
+    [[nodiscard]] uint32_t allocated_memory() const noexcept { return BareBones::mem::allocated_memory(data) + BareBones::mem::allocated_memory(items); }
+
+    [[nodiscard]] uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
+
+    [[nodiscard]] uint32_t emplace_back(composite_type str) noexcept {
+      const uint32_t id = items.size();
+      items.emplace_back(data.size(), str.length());
+      data.push_back(str.begin(), str.end());
+      return id;
+    }
+
+    [[nodiscard]] checkpoint_type checkpoint() const noexcept { return {data.size(), items.size()}; }
+    void rollback(const checkpoint_type& checkpoint) noexcept {
+      assert(checkpoint.data_size <= data.size());
+      assert(checkpoint.items_size <= items.size());
+      data.resize(checkpoint.data_size);
+      items.resize(checkpoint.items_size);
+    }
+
+    template <class InputStream>
+    auto load(InputStream& in, uint32_t items_size) {
+      // read version
+      const uint8_t version = in.get();
+      if (version != 1) {
+        throw BareBones::Exception(0x67c010edbd64e272,
+                                   "Invalid stream data version (%d) for loading into data vector (Symbol::data_type), only version 1 is supported", version);
+      }
+
+      // read mode
+      const auto mode = static_cast<BareBones::SnugComposite::SerializationMode>(in.get());
+
+      // read pos of the first symbol in the portion if we are reading wal
+      uint32_t first_to_load_i = 0;
+      if (mode == BareBones::SnugComposite::SerializationMode::DELTA) {
+        in.read(reinterpret_cast<char*>(&first_to_load_i), sizeof(first_to_load_i));
+      }
+
+      if (first_to_load_i != this->size()) {
+        if (mode == BareBones::SnugComposite::SerializationMode::SNAPSHOT) {
+          throw BareBones::Exception(0x4c0ca0586da6da3f, "Attempt to load snapshot into non-empty data vector");
+        } else if (first_to_load_i < this->size()) {
+          throw BareBones::Exception(0x55cb9b02c23f7bbc, "Attempt to load segment over existing data");
+        } else {
+          throw BareBones::Exception(0x55cb9b02c23f7bbc, "Attempt to load incomplete data from segment, data vector length (%u) is less than segment size (%d)",
+                                     this->size(), first_to_load_i);
+        }
+      }
+
+      // read size
+      uint32_t size_to_load;
+      in.read(reinterpret_cast<char*>(&size_to_load), sizeof(size_to_load));
+
+      // read data
+      data.resize(size() + size_to_load);
+      in.read(data.begin() + first_to_load_i, size_to_load);
+
+      // read items
+      const auto original_size = items.size();
+      items.resize(original_size + items_size);
+      in.read(reinterpret_cast<char*>(&items[original_size]), sizeof(item_type) * items_size);
+
+      return std::views::iota(original_size, items.size());
+    }
+
+    class iterator_type {
+     public:
+      using iterator_category = std::input_iterator_tag;
+      using value_type = composite_type;
+      using difference_type = std::ptrdiff_t;
+
+      iterator_type() = default;
+      explicit iterator_type(const storage_type& storage, uint32_t id) noexcept : id_{id}, storage_ptr_(&storage) {}
+
+      iterator_type& operator++() noexcept {
+        ++id_;
+        return *this;
+      }
+
+      iterator_type operator++(int) noexcept {
+        iterator_type retval = *this;
+        ++(*this);
+        return retval;
+      }
+
+      bool operator==(const iterator_type& other) const noexcept { return id_ == other.id_ && storage_ptr_ == other.storage_ptr_; }
+      bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept { return id_ == storage_ptr_->items.size(); }
+
+      value_type operator*() const noexcept { return storage_ptr_->composite(id_); }
+
+     private:
+      uint32_t id_{0};
+      const storage_type* storage_ptr_;
+    };
+
+    auto begin() const noexcept { return iterator_type{*this, 0}; }
+    auto end() const noexcept { return iterator_type{*this, items.size()}; }
+  };
 };
 
 }  // namespace PromPP::Primitives::SnugComposites::Filaments
@@ -642,9 +842,9 @@ class LabelSet {
    public:
     using SymbolIdsCodec = BareBones::StreamVByte::Codec1234;
 
-    symbols_tables_type symbols_tables;
+    symbols_tables_type symbols_tables;  // lns -> symbols
     symbols_ids_sequences_type symbols_ids_sequences;
-    LabelNameSetsTableType<Vector> label_name_sets_table;
+    LabelNameSetsTableType<Vector> label_name_sets_table;  // lns -> lable name set -> symbols
     uint32_t next_item_index_{};
     uint32_t shrinked_size_{};
     data_type() noexcept = default;
diff --git a/pp/primitives/tests/snug_composites_filaments_tests.cpp b/pp/primitives/tests/snug_composites_filaments_tests.cpp
index a57b3b538..8a8c67a67 100644
--- a/pp/primitives/tests/snug_composites_filaments_tests.cpp
+++ b/pp/primitives/tests/snug_composites_filaments_tests.cpp
@@ -5,6 +5,8 @@
 #include "primitives/label_set.h"
 #include "primitives/snug_composites_filaments.h"
 
+#include "bare_bones/snug_composite_v2.h"
+
 namespace {
 
 using BareBones::Vector;
@@ -333,4 +335,68 @@ TEST_F(ShrinkableEncodingBimapLabelSetFixture, CheckSaveSize) {
   EXPECT_EQ(ss.str().length(), save_size);
 }
 
+template <template <class> class Vector>
+using DecodingTableV2 = BareBones::SnugComposite::V2::DecodingTable<PromPP::Primitives::SnugComposites::Filaments::Symbol, Vector>;
+
+template <template <class> class Vector>
+using EncodingBimapV2 = BareBones::SnugComposite::V2::EncodingBimap<PromPP::Primitives::SnugComposites::Filaments::Symbol, Vector>;
+
+class V2Test : public testing::Test {
+ protected:
+  EncodingBimapV2<Vector> encoding_table_;
+  DecodingTableV2<Vector> decoding_table_;
+};
+
+TEST_F(V2Test, Test) {
+  // Arrange
+  const std::array<std::string, 4> arr = {"aboba", "lol", "kek", "cheburek"};
+
+  // Act
+  const auto id0 = encoding_table_.find_or_emplace(arr[0]);
+  const auto id1 = encoding_table_.find_or_emplace(arr[1]);
+  const auto id2 = encoding_table_.find_or_emplace(arr[2]);
+  const auto id3 = encoding_table_.find_or_emplace(arr[3]);
+
+  // Assert
+  EXPECT_EQ(encoding_table_.size(), 4);
+
+  EXPECT_EQ(encoding_table_[id0], arr[0]);
+  EXPECT_EQ(encoding_table_[id1], arr[1]);
+  EXPECT_EQ(encoding_table_[id2], arr[2]);
+  EXPECT_EQ(encoding_table_[id3], arr[3]);
+
+  EXPECT_EQ(encoding_table_.find(arr[0]), id0);
+  EXPECT_EQ(encoding_table_.find(arr[1]), id1);
+  EXPECT_EQ(encoding_table_.find(arr[2]), id2);
+  EXPECT_EQ(encoding_table_.find(arr[3]), id3);
+
+  EXPECT_TRUE(std::ranges::equal(arr, encoding_table_));
+}
+
+TEST_F(V2Test, CheckpointTest) {
+  // Arrange
+  const std::array<std::string, 4> arr = {"aboba", "lol", "kek", "cheburek"};
+
+  // Act
+  const auto id0 = encoding_table_.find_or_emplace(arr[0]);
+  const auto id1 = encoding_table_.find_or_emplace(arr[1]);
+  const auto id2 = encoding_table_.find_or_emplace(arr[2]);
+  const auto id3 = encoding_table_.find_or_emplace(arr[3]);
+
+  const auto checkpoint = encoding_table_.checkpoint();
+  std::stringstream ss;
+  checkpoint.save(ss);
+  decoding_table_.load(ss);
+
+  // Assert
+  EXPECT_EQ(decoding_table_.size(), 4);
+
+  EXPECT_EQ(decoding_table_[id0], arr[0]);
+  EXPECT_EQ(decoding_table_[id1], arr[1]);
+  EXPECT_EQ(decoding_table_[id2], arr[2]);
+  EXPECT_EQ(decoding_table_[id3], arr[3]);
+
+  EXPECT_TRUE(std::ranges::equal(arr, decoding_table_));
+}
+
 }  // namespace

From 650ab84b8e7b665d545506e8d065041f480b241d Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Wed, 10 Dec 2025 22:18:09 +0300
Subject: [PATCH 09/34] fix global tests for new Symbol

---
 pp/bare_bones/snug_composite_v2.h             | 76 ++++++++++++++++++-
 pp/primitives/snug_composites_filaments.h     | 38 ++++++----
 .../tests/snug_composites_filaments_tests.cpp |  2 +
 3 files changed, 98 insertions(+), 18 deletions(-)

diff --git a/pp/bare_bones/snug_composite_v2.h b/pp/bare_bones/snug_composite_v2.h
index 01482d81a..90c781220 100644
--- a/pp/bare_bones/snug_composite_v2.h
+++ b/pp/bare_bones/snug_composite_v2.h
@@ -212,9 +212,9 @@ class GenericDecodingTable {
 
       // data
       if (from != nullptr) {
-        res += storage_checkpoint_.save_size(&storage_ptr_, &from->storage_checkpoint_);
+        res += storage_checkpoint_.save_size(*storage_ptr_, size_to_save, &from->storage_checkpoint_);
       } else {
-        res += storage_checkpoint_.save_size(&storage_ptr_);
+        res += storage_checkpoint_.save_size(*storage_ptr_, size_to_save);
       }
 
       return res;
@@ -371,6 +371,74 @@ class GenericDecodingTable {
     return in;
   }
 
+  template <class InnerIteratorType>
+  class IteratorSentinel {
+    InnerIteratorType i_;
+
+   public:
+    inline __attribute__((always_inline)) explicit IteratorSentinel(InnerIteratorType i = InnerIteratorType()) noexcept : i_(i) {}
+
+    inline __attribute__((always_inline)) const InnerIteratorType& inner_iterator() const noexcept { return i_; }
+  };
+
+  template <class InnerIteratorType>
+  class ItemIDIterator {
+    const GenericDecodingTable* decoding_table_;
+    InnerIteratorType i_;
+
+   public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = typename Filament<Vector>::composite_type;
+    using difference_type = std::ptrdiff_t;
+
+    inline __attribute__((always_inline)) explicit ItemIDIterator(const GenericDecodingTable* decoding_table = nullptr,
+                                                                  InnerIteratorType i = InnerIteratorType()) noexcept
+        : decoding_table_(decoding_table), i_(i) {}
+    inline __attribute__((always_inline)) ItemIDIterator& operator++() {
+      ++i_;
+      return *this;
+    }
+
+    inline __attribute__((always_inline)) ItemIDIterator operator++(int) noexcept {
+      ItemIDIterator retval = *this;
+      ++(*this);
+      return retval;
+    }
+
+    inline __attribute__((always_inline)) bool operator==(const ItemIDIterator& other) const noexcept { return i_ == other.i_; }
+
+    template <class InnerIteratorSentinelType>
+    inline __attribute__((always_inline)) bool operator==(const IteratorSentinel<InnerIteratorSentinelType>& other) const noexcept {
+      return i_ == other.inner_iterator();
+    }
+
+    inline __attribute__((always_inline)) value_type operator*() const noexcept { return (*decoding_table_)[*i_]; }
+
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t id() const noexcept { return *i_; }
+  };
+
+  template <class InnerIteratorType, class InnerIteratorSentinelType>
+  class Resolver {
+    using inner_iterator_type = InnerIteratorType;
+    using inner_iterator_sentinel_type = InnerIteratorSentinelType;
+
+    const GenericDecodingTable* decoding_table_;
+    inner_iterator_type begin_;
+    inner_iterator_sentinel_type end_;
+
+   public:
+    using value_type = typename Filament<Vector>::composite_type;
+
+    inline __attribute__((always_inline)) explicit Resolver(const GenericDecodingTable* decoding_table = nullptr,
+                                                            inner_iterator_type begin = inner_iterator_type(),
+                                                            inner_iterator_sentinel_type end = inner_iterator_sentinel_type()) noexcept
+        : decoding_table_(decoding_table), begin_(begin), end_(end) {}
+
+    inline __attribute__((always_inline)) auto begin() const noexcept { return ItemIDIterator<inner_iterator_type>(decoding_table_, begin_); }
+    inline __attribute__((always_inline)) auto end() const noexcept { return IteratorSentinel<inner_iterator_sentinel_type>(end_); }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE size_t size() const noexcept { return end_ - begin_; }
+  };
+
   PROMPP_ALWAYS_INLINE auto begin() const noexcept { return storage_.begin(); }
   PROMPP_ALWAYS_INLINE auto end() const noexcept { return storage_.end(); }
 
@@ -432,7 +500,7 @@ class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEnc
     return {};
   }
 
-  PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return checkpoint_type(*this, next_item_index_impl()); }
+  PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return checkpoint_type(*this, next_item_index_impl(), size()); }
 
   void shrink_to_checkpoint_size(const checkpoint_type& checkpoint) {
     if (checkpoint.next_item_index() != next_item_index_impl()) {
@@ -556,7 +624,7 @@ class EncodingBimap : public GenericDecodingTable<EncodingBimap<Filament, Vector
   {
     assert(s.size() <= Base::size());
 
-    for (uint32_t i = s.size(); i != Base::items_.size(); ++i) {
+    for (uint32_t i = s.size(); i != Base::size(); ++i) {
       set_.erase(typename Base::Proxy(i));
     }
   }
diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index 4c27a8c41..7e9f8c0aa 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -6,13 +6,14 @@
 #include "bare_bones/iterator.h"
 #include "bare_bones/memory.h"
 #include "bare_bones/snug_composite.h"
+#include "bare_bones/snug_composite_v2.h"
 #include "bare_bones/stream_v_byte.h"
 #include "hash.h"
 
 namespace PromPP::Primitives::SnugComposites::Filaments {
 
 template <template <class> class Vector>
-struct Symbol {
+class Symbol {
   uint32_t pos_;
   uint32_t length_;
 
@@ -211,7 +212,7 @@ struct Symbol {
         out.write(reinterpret_cast<const char*>(&storage.items[id_offset]), sizeof(item_type) * id_count);
       }
 
-      uint32_t save_size(const storage_type&, uint32_t, uint32_t id_count, checkpoint_type const* from = nullptr) const {
+      uint32_t save_size(const storage_type&, uint32_t id_count, checkpoint_type const* from = nullptr) const {
         uint32_t res = 0;
 
         // version
@@ -243,20 +244,25 @@ struct Symbol {
 
     static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
 
+    storage_type() noexcept = default;
+    template <class AnotherStorageType>
+      requires kIsReadOnly
+    explicit storage_type(const AnotherStorageType& other) : data{other.data}, items{other.items} {}
+
     Vector<char> data;
     Vector<item_type> items;
 
     [[nodiscard]] uint32_t size() const noexcept { return items.size(); }
     [[nodiscard]] size_t remainder_size() const noexcept {
       constexpr size_t max_ui32 = std::numeric_limits<uint32_t>::max();
-      assert(this->size() <= max_ui32);
-      return max_ui32 - this->size();
+      assert(items.size() <= max_ui32);
+      return max_ui32 - items.size();
     }
 
-    template <template <class> class OtherVector>
-    void reserve(const typename Symbol<OtherVector>::storage_type& other) noexcept {
-      items.reserve(other.items_.size());
-      data.reserve(other.data_.size());
+    template <class AnotherStorageType>
+    void reserve(const AnotherStorageType& other) noexcept {
+      items.reserve(other.items.size());
+      data.reserve(other.data.size());
     }
 
     [[nodiscard]] composite_type composite(uint32_t id) const noexcept {
@@ -307,14 +313,14 @@ struct Symbol {
         in.read(reinterpret_cast<char*>(&first_to_load_i), sizeof(first_to_load_i));
       }
 
-      if (first_to_load_i != this->size()) {
+      if (first_to_load_i != data.size()) {
         if (mode == BareBones::SnugComposite::SerializationMode::SNAPSHOT) {
           throw BareBones::Exception(0x4c0ca0586da6da3f, "Attempt to load snapshot into non-empty data vector");
-        } else if (first_to_load_i < this->size()) {
-          throw BareBones::Exception(0x55cb9b02c23f7bbc, "Attempt to load segment over existing data");
+        } else if (first_to_load_i < data.size()) {
+          throw BareBones::Exception(0x55cb9b02c23f7bbd, "Attempt to load segment over existing data");
         } else {
-          throw BareBones::Exception(0x55cb9b02c23f7bbc, "Attempt to load incomplete data from segment, data vector length (%u) is less than segment size (%d)",
-                                     this->size(), first_to_load_i);
+          throw BareBones::Exception(0x55cb9b02c23f7bbd, "Attempt to load incomplete data from segment, data vector length (%u) is less than segment size (%d)",
+                                     data.size(), first_to_load_i);
         }
       }
 
@@ -323,7 +329,7 @@ struct Symbol {
       in.read(reinterpret_cast<char*>(&size_to_load), sizeof(size_to_load));
 
       // read data
-      data.resize(size() + size_to_load);
+      data.resize(data.size() + size_to_load);
       in.read(data.begin() + first_to_load_i, size_to_load);
 
       // read items
@@ -375,6 +381,10 @@ template <template <class> class Vector>
 struct BareBones::IsTriviallyReallocatable<BareBones::SnugComposite::DecodingTable<PromPP::Primitives::SnugComposites::Filaments::Symbol, Vector>>
     : std::true_type {};
 
+template <template <class> class Vector>
+struct BareBones::IsTriviallyReallocatable<BareBones::SnugComposite::V2::DecodingTable<PromPP::Primitives::SnugComposites::Filaments::Symbol, Vector>>
+    : std::true_type {};
+
 namespace PromPP::Primitives::SnugComposites::Filaments {
 
 template <class Iterator>
diff --git a/pp/primitives/tests/snug_composites_filaments_tests.cpp b/pp/primitives/tests/snug_composites_filaments_tests.cpp
index 8a8c67a67..205ed06ed 100644
--- a/pp/primitives/tests/snug_composites_filaments_tests.cpp
+++ b/pp/primitives/tests/snug_composites_filaments_tests.cpp
@@ -389,6 +389,8 @@ TEST_F(V2Test, CheckpointTest) {
   decoding_table_.load(ss);
 
   // Assert
+  EXPECT_EQ(ss.str().size(), checkpoint.save_size());
+
   EXPECT_EQ(decoding_table_.size(), 4);
 
   EXPECT_EQ(decoding_table_[id0], arr[0]);

From c0358d7f57ebe67bda7311b2085a094bad0b249e Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Thu, 11 Dec 2025 20:00:14 +0300
Subject: [PATCH 10/34] fix global tests for new LabelNameSet

---
 pp/bare_bones/snug_composite_v2.h         |  17 +-
 pp/primitives/snug_composites.h           |   9 +-
 pp/primitives/snug_composites_filaments.h | 304 +++++++++++++++++++++-
 3 files changed, 316 insertions(+), 14 deletions(-)

diff --git a/pp/bare_bones/snug_composite_v2.h b/pp/bare_bones/snug_composite_v2.h
index 90c781220..58d983dfc 100644
--- a/pp/bare_bones/snug_composite_v2.h
+++ b/pp/bare_bones/snug_composite_v2.h
@@ -55,8 +55,9 @@ class GenericDecodingTable {
   friend class GenericDecodingTable;
 
  public:
-  using storage_type = Filament<Vector>::storage_type;
-  using value_type = Filament<Vector>::composite_type;
+  using filament_type = Filament<Vector>;
+  using storage_type = filament_type::storage_type;
+  using value_type = storage_type::composite_type;
 
   static constexpr bool kIsReadOnly = IsSharedSpan<Vector<uint8_t>>::value;
 
@@ -268,10 +269,12 @@ class GenericDecodingTable {
 
   PROMPP_ALWAYS_INLINE value_type operator[](uint32_t id) const noexcept { return storage_.composite(id); }
 
-  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return storage_.size(); }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return storage_.count(); }
 
   [[nodiscard]] PROMPP_ALWAYS_INLINE size_t allocated_memory() const noexcept { return mem::allocated_memory(storage_); }
 
+  PROMPP_ALWAYS_INLINE const storage_type& data() const noexcept { return storage_; }
+
   template <class DerivedOther, template <template <class> class> class FilamentOther, template <class> class VectorOther>
   PROMPP_ALWAYS_INLINE void reserve(const GenericDecodingTable<DerivedOther, FilamentOther, VectorOther>& other) {
     storage_.reserve(other.storage_);
@@ -295,7 +298,7 @@ class GenericDecodingTable {
     }
 
     if constexpr (!kIsReadOnly) {
-      assert(checkpoint.size() <= storage_.size());
+      assert(checkpoint.size() <= size());
       storage_.rollback(checkpoint.storage_checkpoint());
     }
   }
@@ -330,12 +333,12 @@ class GenericDecodingTable {
     if (first_to_load_i != next_item_index()) {
       if (mode == SerializationMode::SNAPSHOT) {
         throw BareBones::Exception(0x7bcd6011e39bbabc, "Attempt to load snapshot into non-empty DecodingTable");
-      } else if (first_to_load_i < storage_.size()) {
+      } else if (first_to_load_i < size()) {
         throw BareBones::Exception(0x3387739a7b4f574a, "Attempt to load segment over existing DecodingTable data");
       } else {
         throw BareBones::Exception(0x4ece66e098927bc6,
-                                   "Attempt to load incomplete data from segment, DecodingTable data vector length (%u) is less than segment size(%d)",
-                                   storage_.size(), first_to_load_i);
+                                   "Attempt to load incomplete data from segment, DecodingTable data vector length (%u) is less than segment size(%d)", size(),
+                                   first_to_load_i);
       }
     }
 
diff --git a/pp/primitives/snug_composites.h b/pp/primitives/snug_composites.h
index 00d2226d0..ded9e0688 100644
--- a/pp/primitives/snug_composites.h
+++ b/pp/primitives/snug_composites.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "bare_bones/snug_composite_v2.h"
 #include "snug_composites_filaments.h"
 
 namespace PromPP::Primitives::SnugComposites {
@@ -7,10 +8,10 @@ namespace PromPP::Primitives::SnugComposites {
 namespace Symbol {
 
 template <template <class> class Vector>
-using DecodingTable = BareBones::SnugComposite::DecodingTable<Filaments::Symbol, Vector>;
+using DecodingTable = BareBones::SnugComposite::V2::DecodingTable<Filaments::Symbol, Vector>;
 
 template <template <class> class Vector>
-using EncodingBimap = BareBones::SnugComposite::EncodingBimap<Filaments::Symbol, Vector>;
+using EncodingBimap = BareBones::SnugComposite::V2::EncodingBimap<Filaments::Symbol, Vector>;
 
 }  // namespace Symbol
 
@@ -20,13 +21,13 @@ template <template <class> class Vector>
 using DecodingTableFilament = Filaments::LabelNameSet<Symbol::DecodingTable, Vector>;
 
 template <template <class> class Vector>
-using DecodingTable = BareBones::SnugComposite::DecodingTable<DecodingTableFilament, Vector>;
+using DecodingTable = BareBones::SnugComposite::V2::DecodingTable<DecodingTableFilament, Vector>;
 
 template <template <class> class Vector>
 using EncodingBimapFilament = Filaments::LabelNameSet<Symbol::EncodingBimap, Vector>;
 
 template <template <class> class Vector>
-using EncodingBimap = BareBones::SnugComposite::EncodingBimap<EncodingBimapFilament, Vector>;
+using EncodingBimap = BareBones::SnugComposite::V2::EncodingBimap<EncodingBimapFilament, Vector>;
 
 }  // namespace LabelNameSet
 
diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index 7e9f8c0aa..c51966c13 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -172,6 +172,7 @@ class Symbol {
   [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t length() const noexcept { return length_; }
 
   struct storage_type {
+    using composite_type = std::string_view;
     struct item_type {
       uint32_t pos;
       uint32_t length;
@@ -252,11 +253,12 @@ class Symbol {
     Vector<char> data;
     Vector<item_type> items;
 
-    [[nodiscard]] uint32_t size() const noexcept { return items.size(); }
+    [[nodiscard]] uint32_t count() const noexcept { return items.size(); }
+
     [[nodiscard]] size_t remainder_size() const noexcept {
       constexpr size_t max_ui32 = std::numeric_limits<uint32_t>::max();
-      assert(items.size() <= max_ui32);
-      return max_ui32 - items.size();
+      assert(data.size() <= max_ui32);
+      return max_ui32 - data.size();
     }
 
     template <class AnotherStorageType>
@@ -661,6 +663,302 @@ class LabelNameSet {
 
     return data.symbols_table.find_or_emplace(*label_name);
   }
+
+ public:
+  struct storage_type {
+    using symbols_table_type = SymbolsTableType<Vector>;
+    using symbols_ids_sequences_type = Vector<uint32_t>;
+
+    class composite_type : public symbols_table_type::template Resolver<typename symbols_ids_sequences_type::const_iterator,
+                                                                        typename symbols_ids_sequences_type::const_iterator> {
+      using Base = typename symbols_table_type::template Resolver<typename symbols_ids_sequences_type::const_iterator,
+                                                                  typename symbols_ids_sequences_type::const_iterator>;
+
+     public:
+      using Base::Base;
+
+      template <class T>
+      PROMPP_ALWAYS_INLINE bool operator==(const T& b) const noexcept {
+        return std::ranges::equal(Base::begin(), Base::end(), b.begin(), b.end());
+      }
+
+      template <class T>
+      PROMPP_ALWAYS_INLINE bool operator<(const T& b) const noexcept {
+        return std::ranges::lexicographical_compare(Base::begin(), Base::end(), b.begin(), b.end());
+      }
+
+      PROMPP_ALWAYS_INLINE friend size_t hash_value(const composite_type& lns) noexcept { return hash::hash_of_string_list(lns); }
+    };
+
+    struct item_type {
+      uint32_t pos;
+      uint32_t size;
+    };
+
+    struct checkpoint_type {
+      uint32_t symbols_ids_size;
+      symbols_table_type::checkpoint_type symbols_table_checkpoint;
+      uint32_t items_size;
+
+      using SerializationMode = BareBones::SnugComposite::SerializationMode;
+
+      template <BareBones::OutputStream S>
+      void save(S& out, const storage_type& storage, uint32_t id_offset, uint32_t id_count, checkpoint_type const* from = nullptr) const {
+        // write a version
+        out.put(1);
+
+        // write mode
+        SerializationMode mode = (from != nullptr) ? SerializationMode::DELTA : SerializationMode::SNAPSHOT;
+        out.put(static_cast<char>(mode));
+
+        // write pos of the first seq in the portion if we are writing delta
+        uint32_t first_to_save = 0;
+        if (from != nullptr) {
+          first_to_save = from->symbols_ids_size;
+          out.write(reinterpret_cast<const char*>(&first_to_save), sizeof(first_to_save));
+        }
+
+        // write size
+        uint32_t size_to_save = symbols_ids_size - first_to_save;
+        out.write(reinterpret_cast<char*>(&size_to_save), sizeof(size_to_save));
+
+        // write symbols ids
+        out.write(reinterpret_cast<const char*>(&storage.symbols_ids_sequences[first_to_save]),
+                  sizeof(storage.symbols_ids_sequences[first_to_save]) * size_to_save);
+
+        // write symbols table
+        if (from != nullptr) {
+          symbols_table_checkpoint.save(out, &from->symbols_table_checkpoint);
+        } else {
+          symbols_table_checkpoint.save(out);
+        }
+
+        // write items
+        out.write(reinterpret_cast<const char*>(&storage.items[id_offset]), sizeof(item_type) * id_count);
+      }
+
+      uint32_t save_size(const storage_type& storage, uint32_t id_count, checkpoint_type const* from = nullptr) const {
+        uint32_t res = 0;
+
+        // version
+        ++res;
+
+        // mode
+        ++res;
+
+        // pos of first seq in the portion, if we are writing delta
+        uint32_t first_to_save = 0;
+        if (from != nullptr) {
+          first_to_save = from->symbols_ids_size;
+          res += sizeof(uint32_t);
+        }
+
+        // size
+        const uint32_t size_to_save = symbols_ids_size - first_to_save;
+        res += sizeof(uint32_t);
+
+        // data
+        res += sizeof(storage.symbols_ids_sequences[first_to_save]) * size_to_save;
+
+        // symbols table
+        if (from != nullptr) {
+          res += symbols_table_checkpoint.save_size(&from->symbols_table_checkpoint);
+        } else {
+          res += symbols_table_checkpoint.save_size();
+        }
+
+        // items
+        res += sizeof(item_type) * id_count;
+
+        return res;
+      }
+    };
+
+    static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
+
+    storage_type() noexcept = default;
+    template <class AnotherStorageType>
+      requires kIsReadOnly
+    explicit storage_type(const AnotherStorageType& other)
+        : symbols_table{other.symbols_table}, symbols_ids_sequences{other.symbols_ids_sequences}, items{other.items} {}
+
+    symbols_table_type symbols_table;
+    symbols_ids_sequences_type symbols_ids_sequences;
+    Vector<item_type> items;
+
+    [[nodiscard]] uint32_t count() const noexcept { return items.size(); }
+
+    [[nodiscard]] size_t remainder_size() const noexcept {
+      constexpr size_t max_ui32 = std::numeric_limits<uint32_t>::max();
+      assert(symbols_ids_sequences.size() <= max_ui32);
+
+      size_t remainder_for_symbols = max_ui32 - symbols_ids_sequences.size();
+      return std::min(symbols_table.remainder_size(), remainder_for_symbols);
+    }
+
+    template <class AnotherStorageType>
+    void reserve(const AnotherStorageType& other) noexcept {
+      symbols_table.reserve(other.symbols_table);
+      symbols_ids_sequences.reserve(other.symbols_ids_sequences.size());
+      items.reserve(other.items.size());
+    }
+
+    [[nodiscard]] composite_type composite(uint32_t id) const noexcept {
+      const auto item = items[id];
+      const auto begin = symbols_ids_sequences.begin() + item.pos;
+      return composite_type(&symbols_table, begin, begin + item.size);
+    }
+
+    void validate(uint32_t id) const {
+      const auto item = items[id];
+
+      if (item.pos + item.size > symbols_ids_sequences.size()) {
+        throw BareBones::Exception(0x45e8bdc1455fd8e4, "LabelSetNames data validation error: expected LabelSetNames length is out of data vector range");
+      }
+
+      for (auto i = symbols_ids_sequences.begin() + item.pos; i != symbols_ids_sequences.begin() + item.pos + item.size; ++i) {
+        if (*i >= symbols_table.size()) {
+          throw BareBones::Exception(0x218410dde097cc6b,
+                                     "LabelSetNames data validation error: expected LabelSetNames length is out of data symbols table range");
+        }
+      }
+    }
+
+    [[nodiscard]] uint32_t allocated_memory() const noexcept {
+      return BareBones::mem::allocated_memory(symbols_table) + BareBones::mem::allocated_memory(symbols_ids_sequences) +
+             BareBones::mem::allocated_memory(items);
+    }
+
+    [[nodiscard]] uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
+
+    template <class OtherLabelNameSet, class Cache = NoCache>
+    [[nodiscard]] uint32_t emplace_back(const OtherLabelNameSet& label_name_set, Cache&& cache = {}) noexcept {
+      const uint32_t id = items.size();
+
+      uint32_t pos = symbols_ids_sequences.size();
+      uint32_t size = 0;
+
+      if constexpr (BareBones::concepts::has_size<OtherLabelNameSet>) {
+        size = label_name_set.size();
+      }
+
+      if constexpr (BareBones::concepts::has_size<OtherLabelNameSet>) {
+        symbols_ids_sequences.reserve(symbols_ids_sequences.size() + size);
+      }
+
+      for (auto it = label_name_set.begin(), end = label_name_set.end(); it != end; ++it) {
+        symbols_ids_sequences.push_back(find_or_emplace_label_name(it, std::forward<Cache>(cache)));
+        if constexpr (!BareBones::concepts::has_size<OtherLabelNameSet>) {
+          ++size;
+        }
+      }
+
+      items.emplace_back(pos, size);
+
+      return id;
+    }
+
+    [[nodiscard]] checkpoint_type checkpoint() const noexcept { return {symbols_ids_sequences.size(), symbols_table.checkpoint(), items.size()}; }
+    void rollback(const checkpoint_type& checkpoint) noexcept {
+      assert(checkpoint.symbols_ids_size <= symbols_ids_sequences.size());
+      assert(checkpoint.items_size <= items.size());
+
+      symbols_ids_sequences.resize(checkpoint.symbols_ids_size);
+      symbols_table.rollback(checkpoint.symbols_table_checkpoint);
+      items.resize(checkpoint.items_size);
+    }
+
+    template <class InputStream>
+    auto load(InputStream& in, uint32_t items_size) {
+      // read version
+      const uint8_t version = in.get();
+      if (version != 1) {
+        throw BareBones::Exception(0xe7b943f626c40350,
+                                   "Invalid stream data version (%d) for loading into LabelSetNames::data_type vector, only version 1 is supported", version);
+      }
+
+      // read mode
+      const auto mode = static_cast<BareBones::SnugComposite::SerializationMode>(in.get());
+
+      // read pos of first seq in the portion if we are reading wal
+      uint32_t first_to_load_i = 0;
+      if (mode == BareBones::SnugComposite::SerializationMode::DELTA) {
+        in.read(reinterpret_cast<char*>(&first_to_load_i), sizeof(first_to_load_i));
+      }
+      if (first_to_load_i != symbols_ids_sequences.size()) {
+        if (mode == BareBones::SnugComposite::SerializationMode::SNAPSHOT) {
+          throw BareBones::Exception(0x484607065485b4ab, "Attempt to load snapshot into non-empty LabelSetNames data vector");
+        } else if (first_to_load_i < symbols_ids_sequences.size()) {
+          throw BareBones::Exception(0xc042fdcb4b149d95, "Attempt to load segment over existing LabelSetNames data");
+        } else {
+          throw BareBones::Exception(0x79995816e0a9690b,
+                                     "Attempt to load incomplete data from segment, LabelSetNames data vector length (%u) is less than segment size (%d)",
+                                     symbols_ids_sequences.size(), first_to_load_i);
+        }
+      }
+
+      // read size
+      uint32_t size_to_load;
+      in.read(reinterpret_cast<char*>(&size_to_load), sizeof(size_to_load));
+
+      // read data
+      auto original_size = symbols_ids_sequences.size();
+      auto sg1 = std::experimental::scope_fail([&]() { symbols_ids_sequences.resize(original_size); });
+      symbols_ids_sequences.resize(original_size + size_to_load);
+      in.read(reinterpret_cast<char*>(&symbols_ids_sequences[first_to_load_i]), sizeof(symbols_ids_sequences[first_to_load_i]) * size_to_load);
+
+      // read symbols table
+      symbols_table.load(in);
+
+      // read items
+      const auto items_original_size = items.size();
+      items.resize(items_original_size + items_size);
+      in.read(reinterpret_cast<char*>(&items[items_original_size]), sizeof(item_type) * items_size);
+
+      return std::views::iota(items_original_size, items.size());
+    }
+
+    class iterator_type {
+     public:
+      using iterator_category = std::input_iterator_tag;
+      using value_type = composite_type;
+      using difference_type = std::ptrdiff_t;
+
+      iterator_type() = default;
+      explicit iterator_type(const storage_type& storage, uint32_t id) noexcept : id_{id}, storage_ptr_(&storage) {}
+
+      iterator_type& operator++() noexcept {
+        ++id_;
+        return *this;
+      }
+
+      iterator_type operator++(int) noexcept {
+        iterator_type retval = *this;
+        ++(*this);
+        return retval;
+      }
+      bool operator==(const iterator_type& other) const noexcept { return id_ == other.id_ && storage_ptr_ == other.storage_ptr_; }
+      bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept { return id_ == storage_ptr_->items.size(); }
+
+      value_type operator*() const noexcept { return storage_ptr_->composite(id_); }
+
+     private:
+      uint32_t id_{0};
+      const storage_type* storage_ptr_;
+    };
+    auto begin() const noexcept { return iterator_type{*this, 0}; }
+    auto end() const noexcept { return iterator_type{*this, items.size()}; }
+
+   private:
+    template <class LabelNameIterator, class Cache>
+    PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_label_name(const LabelNameIterator& label_name, Cache&& cache) {
+      if constexpr (use_find_or_emplace_with_cache<Cache, LabelNameIterator, symbols_table_type, decltype(*label_name)>) {
+        symbols_table.find_or_emplace_with_cache(*label_name, label_name.id(), cache.names);
+      }
+
+      return symbols_table.find_or_emplace(*label_name);
+    }
+  };
 };
 
 template <template <template <class> class> class SymbolsTableType,

From 4aa88392b6bcd19f3ce0981cf56452ef10bb3fed Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Mon, 15 Dec 2025 13:51:36 +0300
Subject: [PATCH 11/34] fix global tests for new LabelSet

---
 pp/bare_bones/snug_composite_v2.h         |  40 +-
 pp/primitives/snug_composites_filaments.h | 584 +++++++++++++++++++++-
 2 files changed, 604 insertions(+), 20 deletions(-)

diff --git a/pp/bare_bones/snug_composite_v2.h b/pp/bare_bones/snug_composite_v2.h
index 58d983dfc..7cd11267b 100644
--- a/pp/bare_bones/snug_composite_v2.h
+++ b/pp/bare_bones/snug_composite_v2.h
@@ -379,9 +379,9 @@ class GenericDecodingTable {
     InnerIteratorType i_;
 
    public:
-    inline __attribute__((always_inline)) explicit IteratorSentinel(InnerIteratorType i = InnerIteratorType()) noexcept : i_(i) {}
+    PROMPP_ALWAYS_INLINE explicit IteratorSentinel(InnerIteratorType i = InnerIteratorType()) noexcept : i_(i) {}
 
-    inline __attribute__((always_inline)) const InnerIteratorType& inner_iterator() const noexcept { return i_; }
+    PROMPP_ALWAYS_INLINE const InnerIteratorType& inner_iterator() const noexcept { return i_; }
   };
 
   template <class InnerIteratorType>
@@ -394,28 +394,27 @@ class GenericDecodingTable {
     using value_type = typename Filament<Vector>::composite_type;
     using difference_type = std::ptrdiff_t;
 
-    inline __attribute__((always_inline)) explicit ItemIDIterator(const GenericDecodingTable* decoding_table = nullptr,
-                                                                  InnerIteratorType i = InnerIteratorType()) noexcept
+    PROMPP_ALWAYS_INLINE explicit ItemIDIterator(const GenericDecodingTable* decoding_table = nullptr, InnerIteratorType i = InnerIteratorType()) noexcept
         : decoding_table_(decoding_table), i_(i) {}
-    inline __attribute__((always_inline)) ItemIDIterator& operator++() {
+    PROMPP_ALWAYS_INLINE ItemIDIterator& operator++() {
       ++i_;
       return *this;
     }
 
-    inline __attribute__((always_inline)) ItemIDIterator operator++(int) noexcept {
+    PROMPP_ALWAYS_INLINE ItemIDIterator operator++(int) noexcept {
       ItemIDIterator retval = *this;
       ++(*this);
       return retval;
     }
 
-    inline __attribute__((always_inline)) bool operator==(const ItemIDIterator& other) const noexcept { return i_ == other.i_; }
+    PROMPP_ALWAYS_INLINE bool operator==(const ItemIDIterator& other) const noexcept { return i_ == other.i_; }
 
     template <class InnerIteratorSentinelType>
-    inline __attribute__((always_inline)) bool operator==(const IteratorSentinel<InnerIteratorSentinelType>& other) const noexcept {
+    PROMPP_ALWAYS_INLINE bool operator==(const IteratorSentinel<InnerIteratorSentinelType>& other) const noexcept {
       return i_ == other.inner_iterator();
     }
 
-    inline __attribute__((always_inline)) value_type operator*() const noexcept { return (*decoding_table_)[*i_]; }
+    PROMPP_ALWAYS_INLINE value_type operator*() const noexcept { return (*decoding_table_)[*i_]; }
 
     [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t id() const noexcept { return *i_; }
   };
@@ -432,20 +431,20 @@ class GenericDecodingTable {
    public:
     using value_type = typename Filament<Vector>::composite_type;
 
-    inline __attribute__((always_inline)) explicit Resolver(const GenericDecodingTable* decoding_table = nullptr,
-                                                            inner_iterator_type begin = inner_iterator_type(),
-                                                            inner_iterator_sentinel_type end = inner_iterator_sentinel_type()) noexcept
+    PROMPP_ALWAYS_INLINE explicit Resolver(const GenericDecodingTable* decoding_table = nullptr,
+                                           inner_iterator_type begin = inner_iterator_type(),
+                                           inner_iterator_sentinel_type end = inner_iterator_sentinel_type()) noexcept
         : decoding_table_(decoding_table), begin_(begin), end_(end) {}
 
-    inline __attribute__((always_inline)) auto begin() const noexcept { return ItemIDIterator<inner_iterator_type>(decoding_table_, begin_); }
-    inline __attribute__((always_inline)) auto end() const noexcept { return IteratorSentinel<inner_iterator_sentinel_type>(end_); }
+    PROMPP_ALWAYS_INLINE auto begin() const noexcept { return ItemIDIterator<inner_iterator_type>(decoding_table_, begin_); }
+    PROMPP_ALWAYS_INLINE auto end() const noexcept { return IteratorSentinel<inner_iterator_sentinel_type>(end_); }
     [[nodiscard]] PROMPP_ALWAYS_INLINE size_t size() const noexcept { return end_ - begin_; }
   };
 
   PROMPP_ALWAYS_INLINE auto begin() const noexcept { return storage_.begin(); }
   PROMPP_ALWAYS_INLINE auto end() const noexcept { return storage_.end(); }
 
-  PROMPP_ALWAYS_INLINE auto remainder_size() const noexcept { return this->storage_.remainder_size(); }
+  PROMPP_ALWAYS_INLINE auto remainder_size() const noexcept { return storage_.remainder_size(); }
 };
 
 template <template <template <class> class> class Filament, template <class> class Vector>
@@ -461,12 +460,15 @@ template <template <template <class> class> class Filament, template <class> cla
 class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEncodingBimap<Filament, Vector>, Filament, Vector> {
  public:
   using Base = GenericDecodingTable<ShrinkableEncodingBimap, Filament, Vector>;
-  using checkpoint_type = typename Base::template Checkpoint<ShrinkableEncodingBimap>;
-  using delta_type = typename checkpoint_type::Delta;
+  // using typename Base::checkpoint_type;
+  // using delta_type = typename checkpoint_type::Delta;
+  using checkpoint_type = typename Base::checkpoint_type;
   using value_type = typename Base::value_type;
 
+  using Base::checkpoint;
   using Base::load;
   using Base::next_item_index;
+  using Base::remainder_size;
   using Base::size;
 
   friend class GenericDecodingTable<ShrinkableEncodingBimap, Filament, Vector>;
@@ -503,7 +505,7 @@ class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEnc
     return {};
   }
 
-  PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return checkpoint_type(*this, next_item_index_impl(), size()); }
+  // PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return checkpoint_type(*this, next_item_index_impl(), size()); }
 
   void shrink_to_checkpoint_size(const checkpoint_type& checkpoint) {
     if (checkpoint.next_item_index() != next_item_index_impl()) {
@@ -539,7 +541,7 @@ class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEnc
       Allocator<typename Base::Proxy, uint32_t>{set_allocated_memory_}};
   uint32_t shift_{0};
 
-  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index_impl() const noexcept { return shift_ + Base::size(); }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index_impl() const noexcept { return shift_ + Base::storage_.next_item_index(); }
 
   template <ls_id_range R>
   PROMPP_ALWAYS_INLINE void after_items_load_impl(R&& loaded_ids) noexcept {
diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index c51966c13..c7e1f7194 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -972,7 +972,6 @@ class LabelSet {
 
  public:
   using symbols_tables_type = std::conditional_t<kIsReadOnly, BareBones::Vector<SymbolsTableType<Vector>>, Vector<std::unique_ptr<SymbolsTableType<Vector>>>>;
-
   using symbols_ids_sequences_type = Vector<uint8_t>;
 
   // NOLINTNEXTLINE(readability-identifier-naming)
@@ -1522,6 +1521,589 @@ class LabelSet {
 
     return data.symbols_tables[lns_id]->find_or_emplace((*label).second);
   }
+
+ public:
+  struct storage_type {
+    static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
+    using SymbolIdsCodec = BareBones::StreamVByte::Codec1234;
+    using symbols_tables_type = std::conditional_t<kIsReadOnly, BareBones::Vector<SymbolsTableType<Vector>>, Vector<std::unique_ptr<SymbolsTableType<Vector>>>>;
+    using symbols_ids_sequences_type = Vector<uint8_t>;
+
+    class composite_type {
+      using label_name_set_type = typename LabelNameSetsTableType<Vector>::value_type;
+      using values_iterator_type =
+          BareBones::StreamVByte::DecodeIterator<typename data_type::SymbolIdsCodec, typename symbols_ids_sequences_type::const_iterator>;
+      using values_iterator_sentinel_type = BareBones::StreamVByte::DecodeIteratorSentinel;
+
+      label_name_set_type label_name_set_;
+      const storage_type* data_;
+      values_iterator_type values_begin_;
+      [[no_unique_address]] values_iterator_sentinel_type values_end_;
+      uint32_t id_;
+
+     public:
+      PROMPP_ALWAYS_INLINE explicit composite_type(const storage_type* data = nullptr,
+                                                   label_name_set_type label_name_set = label_name_set_type(),
+                                                   values_iterator_type values_begin = values_iterator_type(),
+                                                   values_iterator_sentinel_type values_end = values_iterator_sentinel_type(),
+                                                   uint32_t id = 0) noexcept
+          : label_name_set_(label_name_set), data_(data), values_begin_(values_begin), values_end_(values_end), id_(id) {}
+
+      using value_type = std::pair<typename label_name_set_type::value_type, typename Symbol<Vector>::composite_type>;
+
+      PROMPP_ALWAYS_INLINE const label_name_set_type& names() const noexcept { return label_name_set_; }
+
+      PROMPP_ALWAYS_INLINE auto size() const noexcept { return label_name_set_.size(); }
+      PROMPP_ALWAYS_INLINE auto id() const noexcept { return id_; }
+
+      template <class LabelNameSetIteratorType, class ValuesIteratorType>
+      class Iterator {
+        LabelNameSetIteratorType lnsi_;
+        ValuesIteratorType vi_;
+        const storage_type* data_;
+
+        friend class composite_type;
+
+       public:
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = composite_type::value_type;
+        using difference_type = std::ptrdiff_t;
+
+        PROMPP_ALWAYS_INLINE explicit Iterator(const storage_type* data = 0,
+                                               LabelNameSetIteratorType lnsi = LabelNameSetIteratorType(),
+                                               ValuesIteratorType vi = ValuesIteratorType()) noexcept
+            : lnsi_(lnsi), vi_(vi), data_(data) {}
+
+        PROMPP_ALWAYS_INLINE Iterator& operator++() noexcept {
+          ++lnsi_;
+          ++vi_;
+          return *this;
+        }
+
+        PROMPP_ALWAYS_INLINE Iterator operator++(int) noexcept {
+          Iterator retval = *this;
+          ++(*this);
+          return retval;
+        }
+
+        template <class OtherIteratorType>
+        PROMPP_ALWAYS_INLINE bool operator==(const OtherIteratorType& other) const noexcept {
+          return lnsi_ == other.lnsi_ && vi_ == other.vi_;
+        }
+
+        PROMPP_ALWAYS_INLINE value_type operator*() const noexcept {
+          if constexpr (BareBones::concepts::is_dereferenceable<decltype(data_->symbols_tables[lnsi_.id()])>) {
+            const auto& smbl_tbl = *data_->symbols_tables[lnsi_.id()];
+            return make_pair(*lnsi_, smbl_tbl[*vi_]);
+          } else {
+            const auto& smbl_tbl = data_->symbols_tables[lnsi_.id()];
+            return make_pair(*lnsi_, smbl_tbl[*vi_]);
+          }
+        }
+
+        [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t name_id() const noexcept { return lnsi_.id(); }
+
+        [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t value_id() const noexcept { return *vi_; }
+      };
+
+      using iterator = Iterator<decltype(label_name_set_.begin()), decltype(values_begin_)>;
+      using end_iterator = Iterator<decltype(label_name_set_.end()), decltype(values_end_)>;
+
+      PROMPP_ALWAYS_INLINE auto begin() const noexcept {
+        return Iterator<decltype(label_name_set_.begin()), decltype(values_begin_)>(data_, label_name_set_.begin(), values_begin_);
+      }
+
+      PROMPP_ALWAYS_INLINE auto end() const noexcept {
+        return Iterator<decltype(label_name_set_.end()), decltype(values_end_)>(data_, label_name_set_.end(), values_end_);
+      }
+
+      template <class T>
+      PROMPP_ALWAYS_INLINE bool operator==(const T& b) const noexcept {
+        return std::ranges::equal(begin(), end(), b.begin(), b.end(), [](const auto& a, const auto& b) { return a == b; });
+      }
+
+      template <class T>
+      PROMPP_ALWAYS_INLINE bool operator<(const T& b) const noexcept {
+        return std::ranges::lexicographical_compare(begin(), end(), b.begin(), b.end(), [](const auto& a, const auto& b) { return a < b; });
+      }
+
+      PROMPP_ALWAYS_INLINE friend size_t hash_value(const composite_type& ls) noexcept { return hash::hash_of_label_set(ls); }
+    };
+
+    struct item_type {
+      uint32_t lns_id;
+      uint32_t pos;
+    };
+
+    struct checkpoint_type {
+      using SerializationMode = BareBones::SnugComposite::SerializationMode;
+      using symbols_checkpoints_type = Vector<typename SymbolsTableType<Vector>::checkpoint_type>;
+
+      uint32_t next_item_index_;
+      uint32_t size_;
+      uint32_t items_size;
+      typename LabelNameSetsTableType<Vector>::checkpoint_type label_name_sets_table_checkpoint_;
+      symbols_checkpoints_type symbols_tables_checkpoints_;
+
+      template <BareBones::OutputStream S>
+      void save(S& out, const storage_type& storage, uint32_t id_offset, uint32_t id_count, checkpoint_type const* from = nullptr) const {
+        // write version
+        out.put(1);
+
+        // write mode
+        SerializationMode mode = (from != nullptr) ? SerializationMode::DELTA : SerializationMode::SNAPSHOT;
+        out.put(static_cast<char>(mode));
+
+        // write pos of first seq in the portion, if we are writing delta
+        uint32_t first_to_save = 0;
+        if (from != nullptr) {
+          first_to_save = from->next_item_index_;
+          out.write(reinterpret_cast<const char*>(&first_to_save), sizeof(first_to_save));
+        }
+        const uint32_t first_item_index_in_ids_sequence = next_item_index_ - size_;
+        assert(first_to_save >= first_item_index_in_ids_sequence);
+
+        // write  size
+        uint32_t size_to_save = next_item_index_ - first_to_save;
+        out.write(reinterpret_cast<char*>(&size_to_save), sizeof(size_to_save));
+
+        // write data
+        out.write(reinterpret_cast<const char*>(&storage.symbols_ids_sequences[first_to_save - first_item_index_in_ids_sequence]),
+                  sizeof(storage.symbols_ids_sequences[0]) * size_to_save);
+
+        // write label name sets table
+        if (from != nullptr) {
+          label_name_sets_table_checkpoint_.save(out, &from->label_name_sets_table_checkpoint_);
+        } else {
+          label_name_sets_table_checkpoint_.save(out);
+        }
+
+        // count tables, we have to write
+        uint32_t number_of_symbols_tables_to_save = symbols_tables_checkpoints_.size();
+        if (from != nullptr) {
+          for (uint32_t i = 0; i < from->symbols_tables_checkpoints_.size(); ++i) {
+            auto from_checkpoint = from->symbols_tables_checkpoints_[i];
+            auto to_checkpoint = symbols_tables_checkpoints_[i];
+            if ((to_checkpoint - from_checkpoint).empty()) {
+              --number_of_symbols_tables_to_save;
+            }
+          }
+        }
+
+        // write number of symbols tables
+        out.write(reinterpret_cast<char*>(&number_of_symbols_tables_to_save), sizeof(number_of_symbols_tables_to_save));
+        // write symbols tables
+        if (from != nullptr) {
+          for (uint32_t i = 0; i < symbols_tables_checkpoints_.size(); ++i) {
+            auto to_checkpoint = symbols_tables_checkpoints_[i];
+            if (i >= from->symbols_tables_checkpoints_.size()) {
+              // write id
+              out.write(reinterpret_cast<char*>(&i), sizeof(i));
+              // write symbols table
+              to_checkpoint.save(out);
+              continue;
+            }
+            auto from_checkpoint = from->symbols_tables_checkpoints_[i];
+            if ((to_checkpoint - from_checkpoint).empty()) {
+              continue;
+            }
+            // write id
+            out.write(reinterpret_cast<char*>(&i), sizeof(i));
+            // write symbols table
+            to_checkpoint.save(out, &from_checkpoint);
+          }
+        } else {
+          for (uint32_t i = 0; i < symbols_tables_checkpoints_.size(); ++i) {
+            // write symbols table
+            symbols_tables_checkpoints_[i].save(out);
+          }
+        }
+
+        // write items
+        out.write(reinterpret_cast<const char*>(&storage.items[id_offset]), sizeof(item_type) * id_count);
+      }
+
+      uint32_t save_size(const storage_type& storage, uint32_t id_count, checkpoint_type const* from = nullptr) const {
+        uint32_t res = 0;
+
+        // version
+        ++res;
+
+        // mode
+        ++res;
+
+        // pos of first seq in the portion, if we are writing wal
+        uint32_t first_to_save = 0;
+        if (from != nullptr) {
+          first_to_save = from->next_item_index_;
+          res += sizeof(uint32_t);
+        }
+
+        // size
+        const uint32_t size_to_save = next_item_index_ - first_to_save;
+        res += sizeof(uint32_t);
+
+        // data
+        res += sizeof(storage.symbols_ids_sequences[0]) * size_to_save;
+
+        // label name sets table
+        if (from != nullptr) {
+          res += label_name_sets_table_checkpoint_.save_size(&from->label_name_sets_table_checkpoint_);
+        } else {
+          res += label_name_sets_table_checkpoint_.save_size();
+        }
+
+        // number of symbols tables
+        res += sizeof(uint32_t);
+
+        // symbols tables
+        if (from != nullptr) {
+          for (uint32_t i = 0; i < symbols_tables_checkpoints_.size(); ++i) {
+            const typename SymbolsTableType<Vector>::checkpoint_type* from_checkpoint = nullptr;
+            if (i < from->symbols_tables_checkpoints_.size()) {
+              from_checkpoint = &from->symbols_tables_checkpoints_[i];
+            }
+            auto to_checkpoint = symbols_tables_checkpoints_[i];
+            if (from_checkpoint != nullptr) {
+              if ((to_checkpoint - *from_checkpoint).empty()) {
+                continue;
+              }
+            }
+            // write id
+            res += sizeof(i);
+            // write symbols table
+            res += to_checkpoint.save_size(from_checkpoint);
+          }
+        } else {
+          for (uint32_t i = 0; i < symbols_tables_checkpoints_.size(); ++i) {
+            // write symbols table
+            res += symbols_tables_checkpoints_[i].save_size();
+          }
+        }
+
+        // items
+        res += sizeof(item_type) * id_count;
+
+        return res;
+      }
+    };
+
+    storage_type() noexcept = default;
+    template <class AnotherStorageType>
+      requires kIsReadOnly
+    explicit storage_type(const AnotherStorageType& other)
+        : symbols_ids_sequences(other.symbols_ids_sequences),
+          label_name_sets_table(other.label_name_sets_table),
+          next_item_index_(other.next_item_index_),
+          shrinked_size(other.shrinked_size),
+          items{other.items} {
+      symbols_tables.reserve_and_write(other.symbols_tables.size(), [&other](auto memory, uint32_t size) {
+        for (auto& symbol_table : other.symbols_tables) {
+          std::construct_at(memory++, *symbol_table);
+        }
+        return size;
+      });
+    }
+
+    symbols_tables_type symbols_tables;
+    symbols_ids_sequences_type symbols_ids_sequences;
+    LabelNameSetsTableType<Vector> label_name_sets_table;
+    uint32_t next_item_index_{};
+    uint32_t shrinked_size{};
+    Vector<item_type> items;
+
+    [[nodiscard]] uint32_t count() const noexcept { return items.size(); }
+
+    [[nodiscard]] size_t remainder_size() const noexcept {
+      constexpr size_t max_ui32 = std::numeric_limits<uint32_t>::max();
+
+      assert(symbols_ids_sequences.size() <= max_ui32);
+
+      size_t remainder_for_label_sets_table = label_name_sets_table.remainder_size();
+      size_t remainder_for_symbols_ids_sequences = max_ui32 - symbols_ids_sequences.size();
+      size_t remainder_for_symbol_table = std::numeric_limits<uint32_t>::max();
+      for (const auto& table : symbols_tables) {
+        if (const size_t n = table->remainder_size(); n < remainder_for_symbol_table) {
+          remainder_for_symbol_table = n;
+        }
+      }
+      return std::min({remainder_for_label_sets_table, remainder_for_symbols_ids_sequences, remainder_for_symbol_table});
+    }
+
+    template <class AnotherStorageType>
+    void reserve(const AnotherStorageType& other) noexcept {
+      symbols_ids_sequences.reserve(other.symbols_ids_sequences.size());
+      symbols_tables.reserve(other.symbols_tables.size());
+      label_name_sets_table.reserve(other.label_name_sets_table);
+      items.reserve(other.items.size());
+    }
+
+    [[nodiscard]] composite_type composite(uint32_t id) const noexcept {
+      const auto item = items[id];
+
+      auto lns = label_name_sets_table[item.lns_id];
+      auto [values_begin, values_end] =
+          BareBones::StreamVByte::decoder<typename storage_type::SymbolIdsCodec>(symbols_ids_sequences.begin() + item.pos - shrinked_size, lns.size());
+
+      return composite_type(this, std::move(lns), std::move(values_begin), std::move(values_end), item.lns_id);
+    }
+
+    void validate(uint32_t id) const {
+      const auto item = items[id];
+
+      if (item.lns_id >= label_name_sets_table.size()) {
+        throw BareBones::Exception(0x48dd6c9d357d3a7e,
+                                   "LabelSets data validation error: expected LabelSets length is out of label name sets table vector range");
+      }
+
+      const auto& lns = label_name_sets_table[item.lns_id];
+
+      // check that streamvbyte keys are in range
+      auto keys_size = BareBones::StreamVByte::keys_size(lns.size());
+      if (item.pos - shrinked_size + keys_size > symbols_ids_sequences.size()) {
+        throw BareBones::Exception(0x22f5a82dd120e0e7, "LabelSets data validation error: expected LabelSets keys length is out of data symbols vector range");
+      }
+
+      // check that streamvbyte data is in range
+      const uint32_t data_size =
+          BareBones::StreamVByte::decode_data_size<BareBones::StreamVByte::Codec1234>(lns.size(), symbols_ids_sequences.begin() + item.pos - shrinked_size);
+      if (item.pos - shrinked_size + keys_size + data_size > symbols_ids_sequences.size()) {
+        throw BareBones::Exception(0xd02e54dac8e1d328, "LabelSets data validation error: expected LabelSets values length is out of data symbols vector range");
+      }
+
+      // check that all symbols are in range
+      auto [values_begin, values_end] =
+          BareBones::StreamVByte::decoder<BareBones::StreamVByte::Codec1234>(symbols_ids_sequences.begin() + item.pos - shrinked_size, lns.size());
+      for (auto i = lns.begin(); i != lns.end(); ++i) {
+        if (*values_begin++ >= symbols_tables[i.id()]->size()) {
+          throw BareBones::Exception(0x0f0c520ad6285f15,
+                                     "LabelSets data validation error: expected LabelSets symbols length is out of data symbols vector range");
+        }
+      }
+    }
+
+    [[nodiscard]] uint32_t allocated_memory() const noexcept {
+      return BareBones::mem::allocated_memory(symbols_tables) + BareBones::mem::allocated_memory(symbols_ids_sequences) +
+             BareBones::mem::allocated_memory(label_name_sets_table) + BareBones::mem::allocated_memory(items);
+    }
+
+    [[nodiscard]] uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
+
+    template <class OtherLabelSet, class Cache = NoCache>
+    [[nodiscard]] uint32_t emplace_back(const OtherLabelSet& label_set, Cache&& cache = {}) noexcept {
+      const uint32_t id = items.size();
+
+      uint32_t lns_id = find_or_emplace_label_names_set(label_set, std::forward<Cache>(cache));
+      uint32_t pos = symbols_ids_sequences.size() + shrinked_size;
+      // resize, if there are new symbols (in lns table)
+      symbols_tables.reserve(label_name_sets_table.data().symbols_table.size());
+      for (auto i = symbols_tables.size(); i < label_name_sets_table.data().symbols_table.size(); ++i) {
+        symbols_tables.emplace_back(std::make_unique<SymbolsTableType<Vector>>());
+      }
+
+      auto lns = label_name_sets_table[lns_id];
+      auto lns_i = lns.begin();
+      auto size_before = symbols_ids_sequences.size();
+      auto i = BareBones::StreamVByte::back_inserter<typename storage_type::SymbolIdsCodec>(symbols_ids_sequences, lns.size());
+      for (auto it = label_set.begin(); it != label_set.end(); ++it) {
+        *i++ = find_or_emplace_symbol(lns_i.id(), it, std::forward<Cache>(cache));
+        ++lns_i;
+      }
+
+      next_item_index_ += symbols_ids_sequences.size() - size_before;
+
+      items.emplace_back(lns_id, pos);
+
+      return id;
+    }
+
+    void shrink() noexcept {
+      items.resize(0);
+      items.shrink_to_fit();
+      shrinked_size += symbols_ids_sequences.size();
+      symbols_ids_sequences.resize(0);
+      symbols_ids_sequences.shrink_to_fit();
+    }
+
+    [[nodiscard]] checkpoint_type checkpoint() const noexcept {
+      auto checkpoint = checkpoint_type{next_item_index_, symbols_ids_sequences.size(), items.size(), label_name_sets_table.checkpoint(), {}};
+      checkpoint.symbols_tables_checkpoints_.reserve_and_write(symbols_tables.size(), [this](auto memory, uint32_t size) {
+        for (auto& symbol_table : this->symbols_tables) {
+          std::construct_at(memory++, symbol_table->checkpoint());
+        }
+        return size;
+      });
+      return checkpoint;
+    }
+
+    void rollback(const checkpoint_type& checkpoint) noexcept {
+      assert(checkpoint.size_ <= symbols_ids_sequences.size());
+      symbols_ids_sequences.resize(checkpoint.size_);
+
+      label_name_sets_table.rollback(checkpoint.label_name_sets_table_checkpoint_);
+
+      auto symbols_tables_checkpoints = checkpoint.symbols_tables_checkpoints_;
+      assert(symbols_tables_checkpoints.size() <= symbols_tables.size());
+      for (uint32_t i = 0; i != symbols_tables_checkpoints.size(); ++i) {
+        symbols_tables[i]->rollback(symbols_tables_checkpoints[i]);
+      }
+      symbols_tables.resize(symbols_tables_checkpoints.size());
+      items.resize(checkpoint.items_size);
+    }
+
+    template <class InputStream>
+    auto load(InputStream& in, uint32_t items_size) {
+      // read version
+      const uint8_t version = in.get();
+      if (version != 1) {
+        throw BareBones::Exception(0x7524f0b0ab963554, "Invalid stream data version (%d) for loading LabelSets into data vector, only version 1 is supported",
+                                   version);
+      }
+
+      // read mode
+      const auto mode = static_cast<BareBones::SnugComposite::SerializationMode>(in.get());
+
+      // read pos of first seq in the portion, if we are reading wal
+      uint32_t first_to_load_i = 0;
+      if (mode == BareBones::SnugComposite::SerializationMode::DELTA) {
+        in.read(reinterpret_cast<char*>(&first_to_load_i), sizeof(first_to_load_i));
+      }
+      if (first_to_load_i != next_item_index_) {
+        if (mode == BareBones::SnugComposite::SerializationMode::SNAPSHOT) {
+          throw BareBones::Exception(0xefdd57cef4b89243, "Attempt to load snapshot into non-empty LabelSets data vector");
+        } else if (first_to_load_i < symbols_ids_sequences.size()) {
+          throw BareBones::Exception(0xfead3117c5a549bd, "Attempt to load segment over existing LabelSets data");
+        } else {
+          throw BareBones::Exception(0xbb996a8ffbcbb53b,
+                                     "Attempt to load incomplete data from segment, LabelSets data vector length (%u) is less than segment size (%d)",
+                                     symbols_ids_sequences.size(), first_to_load_i);
+        }
+      }
+
+      // read size
+      uint32_t size_to_load;
+      in.read(reinterpret_cast<char*>(&size_to_load), sizeof(size_to_load));
+
+      // read data
+      auto sg1 = std::experimental::scope_fail([original_size = symbols_ids_sequences.size(), this] { symbols_ids_sequences.resize(original_size); });
+
+      symbols_ids_sequences.reserve_and_write(size_to_load + sizeof(SymbolIdsCodec::value_type), [&in, size_to_load](uint8_t* buffer, uint32_t) {
+        in.read(reinterpret_cast<char*>(buffer), size_to_load * sizeof(symbols_ids_sequences[first_to_load_i]));
+        return size_to_load;
+      });
+      next_item_index_ += size_to_load;
+
+      // read label name sets table
+      auto label_name_sets_table_checkpoint = label_name_sets_table.checkpoint();
+      auto sg2 = std::experimental::scope_fail([&]() { label_name_sets_table.rollback(label_name_sets_table_checkpoint); });
+      label_name_sets_table.load(in);
+
+      // read number of tables
+      uint32_t number_of_symbols_tables_to_load;
+      in.read(reinterpret_cast<char*>(&number_of_symbols_tables_to_load), sizeof(number_of_symbols_tables_to_load));
+
+      // read tables
+      auto original_symbols_tables_size = symbols_tables.size();
+      BareBones::Vector<std::pair<uint32_t, typename SymbolsTableType<Vector>::checkpoint_type>> symbols_tables_checkpoints;
+      auto sg3 = std::experimental::scope_fail([&]() {
+        for (const auto& [id, checkpoint] : symbols_tables_checkpoints) {
+          symbols_tables[id]->rollback(checkpoint);
+        }
+        symbols_tables.resize(original_symbols_tables_size);
+      });
+      for (uint32_t i = 0; i < number_of_symbols_tables_to_load; ++i) {
+        // read id
+        uint32_t id;
+
+        if (mode == BareBones::SnugComposite::SerializationMode::DELTA) {
+          in.read(reinterpret_cast<char*>(&id), sizeof(id));
+        } else {
+          id = i;
+        }
+
+        // resize, if needed
+        if (id >= symbols_tables.size()) [[unlikely]] {
+          if (id > symbols_tables.size()) [[unlikely]] {
+            throw BareBones::Exception(0x13fe3e1aae45bb34, "Symbol id sequence is incorrect: id (%u), size: (%u)", id, symbols_tables.size());
+          }
+
+          const auto number_of_tables_stil_left_to_load = number_of_symbols_tables_to_load - i;
+          uint64_t size_will_be_at_least = static_cast<uint64_t>(symbols_tables.size()) + number_of_tables_stil_left_to_load;
+          if (size_will_be_at_least >= std::numeric_limits<uint32_t>::max()) [[unlikely]] {
+            throw BareBones::Exception(0x98d95ce3b05ec2b5, "Max symbol id (%lu) is greater than UINT32_MAX", size_will_be_at_least);
+          }
+
+          symbols_tables.reserve(size_will_be_at_least);
+          for (uint32_t j = 0; j < number_of_tables_stil_left_to_load; ++j) {
+            symbols_tables.emplace_back(std::make_unique<SymbolsTableType<Vector>>());
+          }
+        }
+
+        // read symbols table
+        if (mode == BareBones::SnugComposite::SerializationMode::DELTA && id < original_symbols_tables_size)
+          symbols_tables_checkpoints.emplace_back(id, symbols_tables[id]->checkpoint());
+        symbols_tables[id]->load(in);
+      }
+
+      // read items
+      const auto items_original_size = items.size();
+      items.resize(items_original_size + items_size);
+      in.read(reinterpret_cast<char*>(&items[items_original_size]), sizeof(item_type) * items_size);
+
+      return std::views::iota(items_original_size, items.size());
+    }
+
+    class iterator_type {
+     public:
+      using iterator_category = std::input_iterator_tag;
+      using value_type = composite_type;
+      using difference_type = std::ptrdiff_t;
+
+      iterator_type() = default;
+      explicit iterator_type(const storage_type& storage, uint32_t id) noexcept : id_{id}, storage_ptr_(&storage) {}
+
+      iterator_type& operator++() noexcept {
+        ++id_;
+        return *this;
+      }
+
+      iterator_type operator++(int) noexcept {
+        iterator_type retval = *this;
+        ++(*this);
+        return retval;
+      }
+      bool operator==(const iterator_type& other) const noexcept { return id_ == other.id_ && storage_ptr_ == other.storage_ptr_; }
+      bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept { return id_ == storage_ptr_->items.size(); }
+
+      value_type operator*() const noexcept { return storage_ptr_->composite(id_); }
+
+     private:
+      uint32_t id_{0};
+      const storage_type* storage_ptr_;
+    };
+    auto begin() const noexcept { return iterator_type{*this, 0}; }
+    auto end() const noexcept { return iterator_type{*this, items.size()}; }
+
+   private:
+    template <class LabelSet, class Cache>
+    PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_label_names_set(LabelSet& label_set, Cache&& cache) {
+      if constexpr (use_find_or_emplace_with_cache<Cache, LabelSet, decltype(label_name_sets_table), decltype(label_set.names())>) {
+        return label_name_sets_table.find_or_emplace_with_cache(label_set.names(), label_set.id(), cache.name_sets, cache);
+      }
+
+      return label_name_sets_table.find_or_emplace(label_set.names());
+    }
+
+    template <class LabelIterator, class Cache>
+    PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_symbol(uint32_t lns_id, const LabelIterator& label, Cache&& cache) {
+      if constexpr (use_find_or_emplace_with_cache<Cache, LabelIterator, decltype(*symbols_tables[0]), decltype((*label).second)>) {
+        const auto name_id = label.name_id();
+        return symbols_tables[lns_id]->find_or_emplace_with_cache((*label).second, label.value_id(), cache.values[name_id]);
+      }
+
+      return symbols_tables[lns_id]->find_or_emplace((*label).second);
+    }
+  };
 };
 
 }  // namespace PromPP::Primitives::SnugComposites::Filaments

From d1d84c2615be4f4bd95a08eb2e844e0b1d78ae23 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Mon, 15 Dec 2025 16:05:14 +0300
Subject: [PATCH 12/34] fixes

---
 pp/bare_bones/snug_composite_v2.h         |  71 -------------
 pp/primitives/snug_composites_filaments.h | 124 +++++++++++++++-------
 2 files changed, 83 insertions(+), 112 deletions(-)

diff --git a/pp/bare_bones/snug_composite_v2.h b/pp/bare_bones/snug_composite_v2.h
index 7cd11267b..b626c6a9c 100644
--- a/pp/bare_bones/snug_composite_v2.h
+++ b/pp/bare_bones/snug_composite_v2.h
@@ -374,73 +374,6 @@ class GenericDecodingTable {
     return in;
   }
 
-  template <class InnerIteratorType>
-  class IteratorSentinel {
-    InnerIteratorType i_;
-
-   public:
-    PROMPP_ALWAYS_INLINE explicit IteratorSentinel(InnerIteratorType i = InnerIteratorType()) noexcept : i_(i) {}
-
-    PROMPP_ALWAYS_INLINE const InnerIteratorType& inner_iterator() const noexcept { return i_; }
-  };
-
-  template <class InnerIteratorType>
-  class ItemIDIterator {
-    const GenericDecodingTable* decoding_table_;
-    InnerIteratorType i_;
-
-   public:
-    using iterator_category = std::input_iterator_tag;
-    using value_type = typename Filament<Vector>::composite_type;
-    using difference_type = std::ptrdiff_t;
-
-    PROMPP_ALWAYS_INLINE explicit ItemIDIterator(const GenericDecodingTable* decoding_table = nullptr, InnerIteratorType i = InnerIteratorType()) noexcept
-        : decoding_table_(decoding_table), i_(i) {}
-    PROMPP_ALWAYS_INLINE ItemIDIterator& operator++() {
-      ++i_;
-      return *this;
-    }
-
-    PROMPP_ALWAYS_INLINE ItemIDIterator operator++(int) noexcept {
-      ItemIDIterator retval = *this;
-      ++(*this);
-      return retval;
-    }
-
-    PROMPP_ALWAYS_INLINE bool operator==(const ItemIDIterator& other) const noexcept { return i_ == other.i_; }
-
-    template <class InnerIteratorSentinelType>
-    PROMPP_ALWAYS_INLINE bool operator==(const IteratorSentinel<InnerIteratorSentinelType>& other) const noexcept {
-      return i_ == other.inner_iterator();
-    }
-
-    PROMPP_ALWAYS_INLINE value_type operator*() const noexcept { return (*decoding_table_)[*i_]; }
-
-    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t id() const noexcept { return *i_; }
-  };
-
-  template <class InnerIteratorType, class InnerIteratorSentinelType>
-  class Resolver {
-    using inner_iterator_type = InnerIteratorType;
-    using inner_iterator_sentinel_type = InnerIteratorSentinelType;
-
-    const GenericDecodingTable* decoding_table_;
-    inner_iterator_type begin_;
-    inner_iterator_sentinel_type end_;
-
-   public:
-    using value_type = typename Filament<Vector>::composite_type;
-
-    PROMPP_ALWAYS_INLINE explicit Resolver(const GenericDecodingTable* decoding_table = nullptr,
-                                           inner_iterator_type begin = inner_iterator_type(),
-                                           inner_iterator_sentinel_type end = inner_iterator_sentinel_type()) noexcept
-        : decoding_table_(decoding_table), begin_(begin), end_(end) {}
-
-    PROMPP_ALWAYS_INLINE auto begin() const noexcept { return ItemIDIterator<inner_iterator_type>(decoding_table_, begin_); }
-    PROMPP_ALWAYS_INLINE auto end() const noexcept { return IteratorSentinel<inner_iterator_sentinel_type>(end_); }
-    [[nodiscard]] PROMPP_ALWAYS_INLINE size_t size() const noexcept { return end_ - begin_; }
-  };
-
   PROMPP_ALWAYS_INLINE auto begin() const noexcept { return storage_.begin(); }
   PROMPP_ALWAYS_INLINE auto end() const noexcept { return storage_.end(); }
 
@@ -460,8 +393,6 @@ template <template <template <class> class> class Filament, template <class> cla
 class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEncodingBimap<Filament, Vector>, Filament, Vector> {
  public:
   using Base = GenericDecodingTable<ShrinkableEncodingBimap, Filament, Vector>;
-  // using typename Base::checkpoint_type;
-  // using delta_type = typename checkpoint_type::Delta;
   using checkpoint_type = typename Base::checkpoint_type;
   using value_type = typename Base::value_type;
 
@@ -505,8 +436,6 @@ class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEnc
     return {};
   }
 
-  // PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return checkpoint_type(*this, next_item_index_impl(), size()); }
-
   void shrink_to_checkpoint_size(const checkpoint_type& checkpoint) {
     if (checkpoint.next_item_index() != next_item_index_impl()) {
       throw Exception(0x1bf0dbff9fe3d955, "Invalid checkpoint to shrink: checkpoint next_item_index [%u], next_item_index [%u]", checkpoint.next_item_index(),
diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index c7e1f7194..af1fe498a 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -172,6 +172,8 @@ class Symbol {
   [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t length() const noexcept { return length_; }
 
   struct storage_type {
+    static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
+
     using composite_type = std::string_view;
     struct item_type {
       uint32_t pos;
@@ -243,8 +245,6 @@ class Symbol {
       }
     };
 
-    static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
-
     storage_type() noexcept = default;
     template <class AnotherStorageType>
       requires kIsReadOnly
@@ -666,33 +666,76 @@ class LabelNameSet {
 
  public:
   struct storage_type {
+    static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
+
     using symbols_table_type = SymbolsTableType<Vector>;
     using symbols_ids_sequences_type = Vector<uint32_t>;
 
-    class composite_type : public symbols_table_type::template Resolver<typename symbols_ids_sequences_type::const_iterator,
-                                                                        typename symbols_ids_sequences_type::const_iterator> {
-      using Base = typename symbols_table_type::template Resolver<typename symbols_ids_sequences_type::const_iterator,
-                                                                  typename symbols_ids_sequences_type::const_iterator>;
+    struct item_type {
+      uint32_t pos;
+      uint32_t size;
+    };
 
+    class composite_type {
      public:
-      using Base::Base;
+      class iterator_type {
+       public:
+        using iterator_category = std::input_iterator_tag;
+        using value_type = typename symbols_table_type::value_type;
+        using difference_type = std::ptrdiff_t;
+
+        iterator_type() = default;
+        explicit iterator_type(const symbols_table_type* symbols_table_ptr, symbols_ids_sequences_type::const_iterator it) noexcept
+            : symbols_table_ptr_{symbols_table_ptr}, symbols_ids_it_{it} {}
+
+        iterator_type& operator++() noexcept {
+          ++symbols_ids_it_;
+          return *this;
+        }
+
+        iterator_type operator++(int) noexcept {
+          iterator_type retval = *this;
+          ++(*this);
+          return retval;
+        }
+        bool operator==(const iterator_type& other) const noexcept {
+          return symbols_table_ptr_ == other.symbols_table_ptr_ && symbols_ids_it_ == other.symbols_ids_it_;
+        }
+
+        value_type operator*() const noexcept { return symbols_table_ptr_->operator[](*symbols_ids_it_); }
+
+        [[nodiscard]] uint32_t id() const noexcept { return *symbols_ids_it_; }
+
+       private:
+        const symbols_table_type* symbols_table_ptr_;
+        symbols_ids_sequences_type::const_iterator symbols_ids_it_;
+      };
+      using value_type = iterator_type::value_type;
+
+      composite_type() = default;
+      explicit composite_type(const symbols_table_type* symbols_table_ptr, symbols_ids_sequences_type::const_iterator symbols_ids_it, uint32_t size)
+          : symbols_table_ptr_{symbols_table_ptr}, symbols_ids_it_{symbols_ids_it}, size_{size} {}
+
+      auto begin() const noexcept { return iterator_type{symbols_table_ptr_, symbols_ids_it_}; }
+      auto end() const noexcept { return iterator_type{symbols_table_ptr_, symbols_ids_it_ + size()}; }
+      [[nodiscard]] size_t size() const noexcept { return size_; }
 
       template <class T>
-      PROMPP_ALWAYS_INLINE bool operator==(const T& b) const noexcept {
-        return std::ranges::equal(Base::begin(), Base::end(), b.begin(), b.end());
+      bool operator==(const T& other) const noexcept {
+        return std::ranges::equal(begin(), end(), other.begin(), other.end());
       }
 
       template <class T>
-      PROMPP_ALWAYS_INLINE bool operator<(const T& b) const noexcept {
-        return std::ranges::lexicographical_compare(Base::begin(), Base::end(), b.begin(), b.end());
+      bool operator<(const T& other) const noexcept {
+        return std::ranges::lexicographical_compare(begin(), end(), other.begin(), other.end());
       }
 
-      PROMPP_ALWAYS_INLINE friend size_t hash_value(const composite_type& lns) noexcept { return hash::hash_of_string_list(lns); }
-    };
+      friend size_t hash_value(const composite_type& lns) noexcept { return hash::hash_of_string_list(lns); }
 
-    struct item_type {
-      uint32_t pos;
-      uint32_t size;
+     private:
+      const symbols_table_type* symbols_table_ptr_;
+      symbols_ids_sequences_type::const_iterator symbols_ids_it_;
+      uint32_t size_{};
     };
 
     struct checkpoint_type {
@@ -774,8 +817,6 @@ class LabelNameSet {
       }
     };
 
-    static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
-
     storage_type() noexcept = default;
     template <class AnotherStorageType>
       requires kIsReadOnly
@@ -792,7 +833,7 @@ class LabelNameSet {
       constexpr size_t max_ui32 = std::numeric_limits<uint32_t>::max();
       assert(symbols_ids_sequences.size() <= max_ui32);
 
-      size_t remainder_for_symbols = max_ui32 - symbols_ids_sequences.size();
+      const size_t remainder_for_symbols = max_ui32 - symbols_ids_sequences.size();
       return std::min(symbols_table.remainder_size(), remainder_for_symbols);
     }
 
@@ -806,17 +847,17 @@ class LabelNameSet {
     [[nodiscard]] composite_type composite(uint32_t id) const noexcept {
       const auto item = items[id];
       const auto begin = symbols_ids_sequences.begin() + item.pos;
-      return composite_type(&symbols_table, begin, begin + item.size);
+      return composite_type(&symbols_table, begin, item.size);
     }
 
     void validate(uint32_t id) const {
-      const auto item = items[id];
+      const auto [pos, size] = items[id];
 
-      if (item.pos + item.size > symbols_ids_sequences.size()) {
+      if (pos + size > symbols_ids_sequences.size()) {
         throw BareBones::Exception(0x45e8bdc1455fd8e4, "LabelSetNames data validation error: expected LabelSetNames length is out of data vector range");
       }
 
-      for (auto i = symbols_ids_sequences.begin() + item.pos; i != symbols_ids_sequences.begin() + item.pos + item.size; ++i) {
+      for (auto i = symbols_ids_sequences.begin() + pos; i != symbols_ids_sequences.begin() + pos + size; ++i) {
         if (*i >= symbols_table.size()) {
           throw BareBones::Exception(0x218410dde097cc6b,
                                      "LabelSetNames data validation error: expected LabelSetNames length is out of data symbols table range");
@@ -951,7 +992,7 @@ class LabelNameSet {
 
    private:
     template <class LabelNameIterator, class Cache>
-    PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_label_name(const LabelNameIterator& label_name, Cache&& cache) {
+    uint32_t find_or_emplace_label_name(const LabelNameIterator& label_name, Cache&& cache) {
       if constexpr (use_find_or_emplace_with_cache<Cache, LabelNameIterator, symbols_table_type, decltype(*label_name)>) {
         symbols_table.find_or_emplace_with_cache(*label_name, label_name.id(), cache.names);
       }
@@ -1525,6 +1566,7 @@ class LabelSet {
  public:
   struct storage_type {
     static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
+
     using SymbolIdsCodec = BareBones::StreamVByte::Codec1234;
     using symbols_tables_type = std::conditional_t<kIsReadOnly, BareBones::Vector<SymbolsTableType<Vector>>, Vector<std::unique_ptr<SymbolsTableType<Vector>>>>;
     using symbols_ids_sequences_type = Vector<uint8_t>;
@@ -1839,41 +1881,40 @@ class LabelSet {
     }
 
     [[nodiscard]] composite_type composite(uint32_t id) const noexcept {
-      const auto item = items[id];
+      const auto [lns_id, pos] = items[id];
 
-      auto lns = label_name_sets_table[item.lns_id];
-      auto [values_begin, values_end] =
-          BareBones::StreamVByte::decoder<typename storage_type::SymbolIdsCodec>(symbols_ids_sequences.begin() + item.pos - shrinked_size, lns.size());
+      auto lns = label_name_sets_table[lns_id];
+      auto [values_begin, values_end] = BareBones::StreamVByte::decoder<SymbolIdsCodec>(symbols_ids_sequences.begin() + pos - shrinked_size, lns.size());
 
-      return composite_type(this, std::move(lns), std::move(values_begin), std::move(values_end), item.lns_id);
+      return composite_type(this, std::move(lns), std::move(values_begin), std::move(values_end), lns_id);
     }
 
     void validate(uint32_t id) const {
-      const auto item = items[id];
+      const auto [lns_id, pos] = items[id];
 
-      if (item.lns_id >= label_name_sets_table.size()) {
+      if (lns_id >= label_name_sets_table.size()) {
         throw BareBones::Exception(0x48dd6c9d357d3a7e,
                                    "LabelSets data validation error: expected LabelSets length is out of label name sets table vector range");
       }
 
-      const auto& lns = label_name_sets_table[item.lns_id];
+      const auto& lns = label_name_sets_table[lns_id];
 
       // check that streamvbyte keys are in range
       auto keys_size = BareBones::StreamVByte::keys_size(lns.size());
-      if (item.pos - shrinked_size + keys_size > symbols_ids_sequences.size()) {
+      if (pos - shrinked_size + keys_size > symbols_ids_sequences.size()) {
         throw BareBones::Exception(0x22f5a82dd120e0e7, "LabelSets data validation error: expected LabelSets keys length is out of data symbols vector range");
       }
 
       // check that streamvbyte data is in range
       const uint32_t data_size =
-          BareBones::StreamVByte::decode_data_size<BareBones::StreamVByte::Codec1234>(lns.size(), symbols_ids_sequences.begin() + item.pos - shrinked_size);
-      if (item.pos - shrinked_size + keys_size + data_size > symbols_ids_sequences.size()) {
+          BareBones::StreamVByte::decode_data_size<BareBones::StreamVByte::Codec1234>(lns.size(), symbols_ids_sequences.begin() + pos - shrinked_size);
+      if (pos - shrinked_size + keys_size + data_size > symbols_ids_sequences.size()) {
         throw BareBones::Exception(0xd02e54dac8e1d328, "LabelSets data validation error: expected LabelSets values length is out of data symbols vector range");
       }
 
       // check that all symbols are in range
       auto [values_begin, values_end] =
-          BareBones::StreamVByte::decoder<BareBones::StreamVByte::Codec1234>(symbols_ids_sequences.begin() + item.pos - shrinked_size, lns.size());
+          BareBones::StreamVByte::decoder<BareBones::StreamVByte::Codec1234>(symbols_ids_sequences.begin() + pos - shrinked_size, lns.size());
       for (auto i = lns.begin(); i != lns.end(); ++i) {
         if (*values_begin++ >= symbols_tables[i.id()]->size()) {
           throw BareBones::Exception(0x0f0c520ad6285f15,
@@ -1893,8 +1934,8 @@ class LabelSet {
     [[nodiscard]] uint32_t emplace_back(const OtherLabelSet& label_set, Cache&& cache = {}) noexcept {
       const uint32_t id = items.size();
 
-      uint32_t lns_id = find_or_emplace_label_names_set(label_set, std::forward<Cache>(cache));
-      uint32_t pos = symbols_ids_sequences.size() + shrinked_size;
+      const uint32_t lns_id = find_or_emplace_label_names_set(label_set, std::forward<Cache>(cache));
+      const uint32_t pos = symbols_ids_sequences.size() + shrinked_size;
       // resize, if there are new symbols (in lns table)
       symbols_tables.reserve(label_name_sets_table.data().symbols_table.size());
       for (auto i = symbols_tables.size(); i < label_name_sets_table.data().symbols_table.size(); ++i) {
@@ -1918,9 +1959,10 @@ class LabelSet {
     }
 
     void shrink() noexcept {
+      shrinked_size += symbols_ids_sequences.size();
+
       items.resize(0);
       items.shrink_to_fit();
-      shrinked_size += symbols_ids_sequences.size();
       symbols_ids_sequences.resize(0);
       symbols_ids_sequences.shrink_to_fit();
     }
@@ -2086,7 +2128,7 @@ class LabelSet {
 
    private:
     template <class LabelSet, class Cache>
-    PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_label_names_set(LabelSet& label_set, Cache&& cache) {
+    uint32_t find_or_emplace_label_names_set(LabelSet& label_set, Cache&& cache) {
       if constexpr (use_find_or_emplace_with_cache<Cache, LabelSet, decltype(label_name_sets_table), decltype(label_set.names())>) {
         return label_name_sets_table.find_or_emplace_with_cache(label_set.names(), label_set.id(), cache.name_sets, cache);
       }
@@ -2095,7 +2137,7 @@ class LabelSet {
     }
 
     template <class LabelIterator, class Cache>
-    PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_symbol(uint32_t lns_id, const LabelIterator& label, Cache&& cache) {
+    uint32_t find_or_emplace_symbol(uint32_t lns_id, const LabelIterator& label, Cache&& cache) {
       if constexpr (use_find_or_emplace_with_cache<Cache, LabelIterator, decltype(*symbols_tables[0]), decltype((*label).second)>) {
         const auto name_id = label.name_id();
         return symbols_tables[lns_id]->find_or_emplace_with_cache((*label).second, label.value_id(), cache.values[name_id]);

From 448a06dd961ccf59eb051c1b7ad6aa97b226f549 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Mon, 15 Dec 2025 16:37:55 +0300
Subject: [PATCH 13/34] linter fix

---
 pp/primitives/snug_composites_filaments.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index af1fe498a..5f4ac0d80 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -887,7 +887,8 @@ class LabelNameSet {
         symbols_ids_sequences.reserve(symbols_ids_sequences.size() + size);
       }
 
-      for (auto it = label_name_set.begin(), end = label_name_set.end(); it != end; ++it) {
+      const auto end = label_name_set.end();
+      for (auto it = label_name_set.begin(); it != end; ++it) {
         symbols_ids_sequences.push_back(find_or_emplace_label_name(it, std::forward<Cache>(cache)));
         if constexpr (!BareBones::concepts::has_size<OtherLabelNameSet>) {
           ++size;

From 92f753d89ad42bfcbd1b6985d57a4ea136b39656 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Wed, 17 Dec 2025 13:26:22 +0300
Subject: [PATCH 14/34] filaments' storage view types

---
 pp/bare_bones/snug_composite_v2.h         |   6 +-
 pp/primitives/snug_composites.h           |   4 +-
 pp/primitives/snug_composites_filaments.h | 335 +++++++++++++++-------
 3 files changed, 236 insertions(+), 109 deletions(-)

diff --git a/pp/bare_bones/snug_composite_v2.h b/pp/bare_bones/snug_composite_v2.h
index b626c6a9c..7b6c30f2e 100644
--- a/pp/bare_bones/snug_composite_v2.h
+++ b/pp/bare_bones/snug_composite_v2.h
@@ -273,7 +273,7 @@ class GenericDecodingTable {
 
   [[nodiscard]] PROMPP_ALWAYS_INLINE size_t allocated_memory() const noexcept { return mem::allocated_memory(storage_); }
 
-  PROMPP_ALWAYS_INLINE const storage_type& data() const noexcept { return storage_; }
+  PROMPP_ALWAYS_INLINE storage_type::view_type data_view() const noexcept { return storage_.view(); }
 
   template <class DerivedOther, template <template <class> class> class FilamentOther, template <class> class VectorOther>
   PROMPP_ALWAYS_INLINE void reserve(const GenericDecodingTable<DerivedOther, FilamentOther, VectorOther>& other) {
@@ -374,8 +374,8 @@ class GenericDecodingTable {
     return in;
   }
 
-  PROMPP_ALWAYS_INLINE auto begin() const noexcept { return storage_.begin(); }
-  PROMPP_ALWAYS_INLINE auto end() const noexcept { return storage_.end(); }
+  PROMPP_ALWAYS_INLINE auto begin() const noexcept { return storage_.view().begin(); }
+  PROMPP_ALWAYS_INLINE auto end() const noexcept { return storage_.view().end(); }
 
   PROMPP_ALWAYS_INLINE auto remainder_size() const noexcept { return storage_.remainder_size(); }
 };
diff --git a/pp/primitives/snug_composites.h b/pp/primitives/snug_composites.h
index ded9e0688..748cbf478 100644
--- a/pp/primitives/snug_composites.h
+++ b/pp/primitives/snug_composites.h
@@ -37,13 +37,13 @@ template <template <class> class Vector>
 using DecodingTableFilament = Filaments::LabelSet<Symbol::DecodingTable, LabelNameSet::DecodingTable, Vector>;
 
 template <template <class> class Vector>
-using DecodingTable = BareBones::SnugComposite::DecodingTable<DecodingTableFilament, Vector>;
+using DecodingTable = BareBones::SnugComposite::V2::DecodingTable<DecodingTableFilament, Vector>;
 
 template <template <class> class Vector>
 using EncodingBimapFilament = Filaments::LabelSet<Symbol::EncodingBimap, LabelNameSet::EncodingBimap, Vector>;
 
 template <template <class> class Vector>
-using EncodingBimap = BareBones::SnugComposite::EncodingBimap<EncodingBimapFilament, Vector>;
+using EncodingBimap = BareBones::SnugComposite::V2::EncodingBimap<EncodingBimapFilament, Vector>;
 
 template <template <class> class Vector>
 using ShrinkableEncodingBimap = BareBones::SnugComposite::ShrinkableEncodingBimap<EncodingBimapFilament, Vector>;
diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index 5f4ac0d80..62939a623 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -245,6 +245,50 @@ class Symbol {
       }
     };
 
+    struct symbols_view {
+      const storage_type* storage_ptr;
+
+      class iterator_type {
+       public:
+        using iterator_category = std::input_iterator_tag;
+        using value_type = composite_type;
+        using difference_type = std::ptrdiff_t;
+
+        iterator_type() = default;
+        explicit iterator_type(const storage_type& storage, uint32_t id) noexcept : id_{id}, storage_ptr_(&storage) {}
+
+        iterator_type& operator++() noexcept {
+          ++id_;
+          return *this;
+        }
+
+        iterator_type operator++(int) noexcept {
+          iterator_type retval = *this;
+          ++(*this);
+          return retval;
+        }
+
+        bool operator==(const iterator_type& other) const noexcept { return id_ == other.id_ && storage_ptr_ == other.storage_ptr_; }
+        bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept { return id_ == storage_ptr_->items.size(); }
+
+        value_type operator*() const noexcept { return storage_ptr_->composite(id_); }
+
+        [[nodiscard]] uint32_t id() const noexcept { return id_; }
+
+       private:
+        uint32_t id_{0};
+        const storage_type* storage_ptr_;
+      };
+
+      auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
+      auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
+
+      [[nodiscard]] size_t size() const noexcept { return storage_ptr->count(); }
+      [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
+    };
+
+    using view_type = symbols_view;
+
     storage_type() noexcept = default;
     template <class AnotherStorageType>
       requires kIsReadOnly
@@ -342,38 +386,7 @@ class Symbol {
       return std::views::iota(original_size, items.size());
     }
 
-    class iterator_type {
-     public:
-      using iterator_category = std::input_iterator_tag;
-      using value_type = composite_type;
-      using difference_type = std::ptrdiff_t;
-
-      iterator_type() = default;
-      explicit iterator_type(const storage_type& storage, uint32_t id) noexcept : id_{id}, storage_ptr_(&storage) {}
-
-      iterator_type& operator++() noexcept {
-        ++id_;
-        return *this;
-      }
-
-      iterator_type operator++(int) noexcept {
-        iterator_type retval = *this;
-        ++(*this);
-        return retval;
-      }
-
-      bool operator==(const iterator_type& other) const noexcept { return id_ == other.id_ && storage_ptr_ == other.storage_ptr_; }
-      bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept { return id_ == storage_ptr_->items.size(); }
-
-      value_type operator*() const noexcept { return storage_ptr_->composite(id_); }
-
-     private:
-      uint32_t id_{0};
-      const storage_type* storage_ptr_;
-    };
-
-    auto begin() const noexcept { return iterator_type{*this, 0}; }
-    auto end() const noexcept { return iterator_type{*this, items.size()}; }
+    view_type view() const noexcept { return {.storage_ptr = this}; }
   };
 };
 
@@ -817,6 +830,52 @@ class LabelNameSet {
       }
     };
 
+    struct label_name_set_view {
+      using symbols_view_type = symbols_table_type::storage_type::view_type;
+      const storage_type* storage_ptr;
+
+      class iterator_type {
+       public:
+        using iterator_category = std::input_iterator_tag;
+        using value_type = composite_type;
+        using difference_type = std::ptrdiff_t;
+
+        iterator_type() = default;
+        explicit iterator_type(const storage_type& storage, uint32_t id) noexcept : id_{id}, storage_ptr_(&storage) {}
+
+        iterator_type& operator++() noexcept {
+          ++id_;
+          return *this;
+        }
+
+        iterator_type operator++(int) noexcept {
+          iterator_type retval = *this;
+          ++(*this);
+          return retval;
+        }
+        bool operator==(const iterator_type& other) const noexcept { return id_ == other.id_ && storage_ptr_ == other.storage_ptr_; }
+        bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept { return id_ == storage_ptr_->items.size(); }
+
+        value_type operator*() const noexcept { return storage_ptr_->composite(id_); }
+
+        [[nodiscard]] uint32_t id() const noexcept { return id_; }
+
+       private:
+        uint32_t id_{0};
+        const storage_type* storage_ptr_;
+      };
+
+      auto begin() const noexcept { return iterator_type{storage_ptr, 0}; }
+      auto end() const noexcept { return iterator_type{storage_ptr, storage_ptr->items.size()}; }
+
+      [[nodiscard]] size_t size() const noexcept { return storage_ptr->count(); }
+      [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
+
+      symbols_view_type symbols() const noexcept { return storage_ptr->symbols_table.data_view(); }
+    };
+
+    using view_type = label_name_set_view;
+
     storage_type() noexcept = default;
     template <class AnotherStorageType>
       requires kIsReadOnly
@@ -960,36 +1019,7 @@ class LabelNameSet {
       return std::views::iota(items_original_size, items.size());
     }
 
-    class iterator_type {
-     public:
-      using iterator_category = std::input_iterator_tag;
-      using value_type = composite_type;
-      using difference_type = std::ptrdiff_t;
-
-      iterator_type() = default;
-      explicit iterator_type(const storage_type& storage, uint32_t id) noexcept : id_{id}, storage_ptr_(&storage) {}
-
-      iterator_type& operator++() noexcept {
-        ++id_;
-        return *this;
-      }
-
-      iterator_type operator++(int) noexcept {
-        iterator_type retval = *this;
-        ++(*this);
-        return retval;
-      }
-      bool operator==(const iterator_type& other) const noexcept { return id_ == other.id_ && storage_ptr_ == other.storage_ptr_; }
-      bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept { return id_ == storage_ptr_->items.size(); }
-
-      value_type operator*() const noexcept { return storage_ptr_->composite(id_); }
-
-     private:
-      uint32_t id_{0};
-      const storage_type* storage_ptr_;
-    };
-    auto begin() const noexcept { return iterator_type{*this, 0}; }
-    auto end() const noexcept { return iterator_type{*this, items.size()}; }
+    view_type view() const noexcept { return {.storage_ptr = this}; }
 
    private:
     template <class LabelNameIterator, class Cache>
@@ -1568,14 +1598,18 @@ class LabelSet {
   struct storage_type {
     static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
 
-    using SymbolIdsCodec = BareBones::StreamVByte::Codec1234;
-    using symbols_tables_type = std::conditional_t<kIsReadOnly, BareBones::Vector<SymbolsTableType<Vector>>, Vector<std::unique_ptr<SymbolsTableType<Vector>>>>;
+    using label_values_symbols_table_type = SymbolsTableType<Vector>;
+    using label_name_sets_table_type = LabelNameSetsTableType<Vector>;
+
+    using symbols_tables_type =
+        std::conditional_t<kIsReadOnly, BareBones::Vector<label_values_symbols_table_type>, Vector<std::unique_ptr<label_values_symbols_table_type>>>;
+
+    using symbol_ids_codec_type = BareBones::StreamVByte::Codec1234;
     using symbols_ids_sequences_type = Vector<uint8_t>;
 
     class composite_type {
       using label_name_set_type = typename LabelNameSetsTableType<Vector>::value_type;
-      using values_iterator_type =
-          BareBones::StreamVByte::DecodeIterator<typename data_type::SymbolIdsCodec, typename symbols_ids_sequences_type::const_iterator>;
+      using values_iterator_type = BareBones::StreamVByte::DecodeIterator<symbol_ids_codec_type, typename symbols_ids_sequences_type::const_iterator>;
       using values_iterator_sentinel_type = BareBones::StreamVByte::DecodeIteratorSentinel;
 
       label_name_set_type label_name_set_;
@@ -1831,6 +1865,128 @@ class LabelSet {
       }
     };
 
+    struct label_sets_values_view {
+      using keys_view_type = label_name_sets_table_type::view_type::symbols_view;
+      using values_view_type = label_values_symbols_table_type::view_type;
+      const storage_type* storage_ptr;
+
+      class iterator_type {
+       public:
+        using iterator_category = std::input_iterator_tag;
+        using value_type = label_values_symbols_table_type::composite_type;
+        using difference_type = std::ptrdiff_t;
+
+        iterator_type() = default;
+        explicit iterator_type(const symbols_tables_type& symbols_tables,
+                               const keys_view_type::iterator_type& key_it,
+                               const keys_view_type::iterator_type& key_it_end) noexcept
+            : symbols_tables_ptr_{&symbols_tables}, key_it_{key_it}, key_it_end_(key_it_end) {}
+
+        iterator_type& operator++() noexcept {
+          ++value_it_;
+          if (value_it_ == value_it_end_) {
+            ++key_it_;
+            get_values_range();
+          }
+          return *this;
+        }
+
+        iterator_type operator++(int) noexcept {
+          iterator_type retval = *this;
+          ++(*this);
+          return retval;
+        }
+
+        bool operator==(const iterator_type& other) const = default;
+        bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept { return key_it_ == key_it_end_ && value_it_ == value_it_end_; }
+
+        value_type operator*() const noexcept { return *value_it_; }
+
+        [[nodiscard]] uint32_t key_id() const noexcept { return key_it_->id(); }
+        [[nodiscard]] uint32_t value_id() const noexcept { return value_it_->id(); }
+
+       private:
+        void get_values_range() noexcept {
+          while (key_it_ != key_it_end_) {
+            if constexpr (BareBones::concepts::is_dereferenceable<typename symbols_tables_type::value_type>) {
+              const auto values_view = (*(*symbols_tables_ptr_)[key_it_.id()]).view();
+              value_it_ = values_view.begin();
+              value_it_end_ = values_view.end();
+            } else {
+              const auto values_view = (*symbols_tables_ptr_)[key_it_.id()].view();
+              value_it_ = values_view.begin();
+              value_it_end_ = values_view.end();
+            }
+
+            if (value_it_ != value_it_end_)
+              return;
+
+            ++key_it_;
+          }
+        }
+
+        const symbols_tables_type* symbols_tables_ptr_;
+
+        const keys_view_type::iterator_type key_it_;
+        const keys_view_type::iterator_type key_it_end_;
+
+        const values_view_type::iterator_type value_it_;
+        const values_view_type::iterator_type value_it_end_;
+      };
+
+      auto begin() const noexcept { return iterator_type{storage_ptr, 0}; }
+      auto end() const noexcept { return iterator_type{storage_ptr, storage_ptr->items.size()}; }
+    };
+
+    struct label_set_view {
+      using keys_view_type = label_name_sets_table_type::view_type::symbols_view;
+      using values_view_type = label_sets_values_view;
+      const storage_type* storage_ptr;
+
+      class iterator_type {
+       public:
+        using iterator_category = std::input_iterator_tag;
+        using value_type = composite_type;
+        using difference_type = std::ptrdiff_t;
+
+        iterator_type() = default;
+        explicit iterator_type(const storage_type& storage, uint32_t id) noexcept : id_{id}, storage_ptr_(&storage) {}
+
+        iterator_type& operator++() noexcept {
+          ++id_;
+          return *this;
+        }
+
+        iterator_type operator++(int) noexcept {
+          iterator_type retval = *this;
+          ++(*this);
+          return retval;
+        }
+
+        bool operator==(const iterator_type& other) const noexcept { return id_ == other.id_ && storage_ptr_ == other.storage_ptr_; }
+        bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept { return id_ == storage_ptr_->items.size(); }
+
+        value_type operator*() const noexcept { return storage_ptr_->composite(id_); }
+
+        [[nodiscard]] uint32_t id() const noexcept { return id_; }
+
+       private:
+        uint32_t id_{0};
+        const storage_type* storage_ptr_;
+      };
+
+      auto begin() const noexcept { return iterator_type{storage_ptr, 0}; }
+      auto end() const noexcept { return iterator_type{storage_ptr, storage_ptr->items.size()}; }
+
+      [[nodiscard]] size_t size() const noexcept { return storage_ptr->count(); }
+      [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
+
+      keys_view_type labels_keys() const noexcept { return storage_ptr->label_name_sets_table.data_view().symbols(); }
+      values_view_type labels_values() const noexcept { return label_sets_values_view{.storage_ptr = storage_ptr}; }
+    };
+
+    using view_type = label_set_view;
+
     storage_type() noexcept = default;
     template <class AnotherStorageType>
       requires kIsReadOnly
@@ -1850,7 +2006,7 @@ class LabelSet {
 
     symbols_tables_type symbols_tables;
     symbols_ids_sequences_type symbols_ids_sequences;
-    LabelNameSetsTableType<Vector> label_name_sets_table;
+    label_name_sets_table_type label_name_sets_table;
     uint32_t next_item_index_{};
     uint32_t shrinked_size{};
     Vector<item_type> items;
@@ -1885,7 +2041,7 @@ class LabelSet {
       const auto [lns_id, pos] = items[id];
 
       auto lns = label_name_sets_table[lns_id];
-      auto [values_begin, values_end] = BareBones::StreamVByte::decoder<SymbolIdsCodec>(symbols_ids_sequences.begin() + pos - shrinked_size, lns.size());
+      auto [values_begin, values_end] = BareBones::StreamVByte::decoder<symbol_ids_codec_type>(symbols_ids_sequences.begin() + pos - shrinked_size, lns.size());
 
       return composite_type(this, std::move(lns), std::move(values_begin), std::move(values_end), lns_id);
     }
@@ -1937,16 +2093,18 @@ class LabelSet {
 
       const uint32_t lns_id = find_or_emplace_label_names_set(label_set, std::forward<Cache>(cache));
       const uint32_t pos = symbols_ids_sequences.size() + shrinked_size;
-      // resize, if there are new symbols (in lns table)
-      symbols_tables.reserve(label_name_sets_table.data().symbols_table.size());
-      for (auto i = symbols_tables.size(); i < label_name_sets_table.data().symbols_table.size(); ++i) {
+      // resize if there are new symbols (in lns table)
+      symbols_tables.reserve(label_name_sets_table.data_view().symbols().size());  // label_name_sets_table.view().symbols().size()
+      // label_name_sets_table.view() -> label_names_view;
+      // label_names_view.symbols() -> symbols_view;
+      for (auto i = symbols_tables.size(); i < label_name_sets_table.data_view().symbols().size(); ++i) {
         symbols_tables.emplace_back(std::make_unique<SymbolsTableType<Vector>>());
       }
 
       auto lns = label_name_sets_table[lns_id];
       auto lns_i = lns.begin();
       auto size_before = symbols_ids_sequences.size();
-      auto i = BareBones::StreamVByte::back_inserter<typename storage_type::SymbolIdsCodec>(symbols_ids_sequences, lns.size());
+      auto i = BareBones::StreamVByte::back_inserter<symbol_ids_codec_type>(symbols_ids_sequences, lns.size());
       for (auto it = label_set.begin(); it != label_set.end(); ++it) {
         *i++ = find_or_emplace_symbol(lns_i.id(), it, std::forward<Cache>(cache));
         ++lns_i;
@@ -2030,7 +2188,7 @@ class LabelSet {
       // read data
       auto sg1 = std::experimental::scope_fail([original_size = symbols_ids_sequences.size(), this] { symbols_ids_sequences.resize(original_size); });
 
-      symbols_ids_sequences.reserve_and_write(size_to_load + sizeof(SymbolIdsCodec::value_type), [&in, size_to_load](uint8_t* buffer, uint32_t) {
+      symbols_ids_sequences.reserve_and_write(size_to_load + sizeof(symbol_ids_codec_type::value_type), [&in, size_to_load](uint8_t* buffer, uint32_t) {
         in.read(reinterpret_cast<char*>(buffer), size_to_load * sizeof(symbols_ids_sequences[first_to_load_i]));
         return size_to_load;
       });
@@ -2096,37 +2254,6 @@ class LabelSet {
       return std::views::iota(items_original_size, items.size());
     }
 
-    class iterator_type {
-     public:
-      using iterator_category = std::input_iterator_tag;
-      using value_type = composite_type;
-      using difference_type = std::ptrdiff_t;
-
-      iterator_type() = default;
-      explicit iterator_type(const storage_type& storage, uint32_t id) noexcept : id_{id}, storage_ptr_(&storage) {}
-
-      iterator_type& operator++() noexcept {
-        ++id_;
-        return *this;
-      }
-
-      iterator_type operator++(int) noexcept {
-        iterator_type retval = *this;
-        ++(*this);
-        return retval;
-      }
-      bool operator==(const iterator_type& other) const noexcept { return id_ == other.id_ && storage_ptr_ == other.storage_ptr_; }
-      bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept { return id_ == storage_ptr_->items.size(); }
-
-      value_type operator*() const noexcept { return storage_ptr_->composite(id_); }
-
-     private:
-      uint32_t id_{0};
-      const storage_type* storage_ptr_;
-    };
-    auto begin() const noexcept { return iterator_type{*this, 0}; }
-    auto end() const noexcept { return iterator_type{*this, items.size()}; }
-
    private:
     template <class LabelSet, class Cache>
     uint32_t find_or_emplace_label_names_set(LabelSet& label_set, Cache&& cache) {

From c9660f744a94dc9d09660bec480c6e7b3e4a9428 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Wed, 17 Dec 2025 13:33:37 +0300
Subject: [PATCH 15/34] remove old filament and tables

---
 pp/bare_bones/snug_composite.h            | 316 ++-----
 pp/bare_bones/snug_composite_v2.h         | 571 -------------
 pp/primitives/snug_composites.h           |  13 +-
 pp/primitives/snug_composites_filaments.h | 976 +---------------------
 4 files changed, 92 insertions(+), 1784 deletions(-)
 delete mode 100644 pp/bare_bones/snug_composite_v2.h

diff --git a/pp/bare_bones/snug_composite.h b/pp/bare_bones/snug_composite.h
index ec5096c51..3e5ffac89 100644
--- a/pp/bare_bones/snug_composite.h
+++ b/pp/bare_bones/snug_composite.h
@@ -20,8 +20,8 @@ namespace BareBones::SnugComposite {
 
 /**
  * Serialization mode used to annotate encoded data and how to apply it on container.
- * We use Delta for save difference between two states of container. It doesn't matter
- * how first state was made (from snapshot or other delta). Snapshot may be explain
+ * We use Delta to save the difference between two states of container. It doesn't matter
+ * how the first state was made (from snapshot or other delta). Snapshot may be explained
  * as delta from init (zero) state.
  */
 enum class SerializationMode : char { SNAPSHOT = 1, DELTA = 2 };
@@ -55,8 +55,9 @@ class GenericDecodingTable {
   friend class GenericDecodingTable;
 
  public:
-  using value_type = typename Filament<Vector>::composite_type;
-  using data_type = typename Filament<Vector>::data_type;  // FIXME make it private
+  using filament_type = Filament<Vector>;
+  using storage_type = filament_type::storage_type;
+  using value_type = storage_type::composite_type;
 
   static constexpr bool kIsReadOnly = IsSharedSpan<Vector<uint8_t>>::value;
 
@@ -68,12 +69,12 @@ class GenericDecodingTable {
 
    public:
     // NOLINTNEXTLINE(google-explicit-constructor)
-    inline __attribute__((always_inline)) Proxy(uint32_t id) noexcept : id_(id) {}
+    PROMPP_ALWAYS_INLINE Proxy(uint32_t id) noexcept : id_(id) {}
 
     // NOLINTNEXTLINE(google-explicit-constructor)
-    inline __attribute__((always_inline)) operator uint32_t() const noexcept { return id_; }
+    PROMPP_ALWAYS_INLINE operator uint32_t() const noexcept { return id_; }
 
-    inline __attribute__((always_inline)) bool operator==(const Proxy& o) noexcept { return id_ == o.id_; }
+    PROMPP_ALWAYS_INLINE bool operator==(const Proxy& o) noexcept { return id_ == o.id_; }
   };
 
   struct Hasher {
@@ -90,23 +91,20 @@ class GenericDecodingTable {
       return phmap::Hash<Class>()(c);
     }
 
-    PROMPP_ALWAYS_INLINE size_t operator()(const Proxy& p) const noexcept {
-      return this->operator()(decoding_table->items_[p].composite(decoding_table->data_));
-    }
+    PROMPP_ALWAYS_INLINE size_t operator()(const Proxy& p) const noexcept { return this->operator()(decoding_table->storage_.composite(p)); }
   };
 
   struct EqualityComparator {
     using is_transparent = void;
 
     const GenericDecodingTable* decoding_table;
-    inline __attribute__((always_inline)) explicit EqualityComparator(const GenericDecodingTable* _decoding_table = nullptr) noexcept
-        : decoding_table(_decoding_table) {}
+    PROMPP_ALWAYS_INLINE explicit EqualityComparator(const GenericDecodingTable* _decoding_table = nullptr) noexcept : decoding_table(_decoding_table) {}
 
-    inline __attribute__((always_inline)) bool operator()(const Proxy& a, const Proxy& b) const noexcept { return a == b; }
+    PROMPP_ALWAYS_INLINE bool operator()(const Proxy& a, const Proxy& b) const noexcept { return a == b; }
 
     template <class Class>
-    inline __attribute__((always_inline)) bool operator()(const Proxy& a, const Class& b) const noexcept {
-      return decoding_table->items_[a].composite(decoding_table->data_) == b;
+    PROMPP_ALWAYS_INLINE bool operator()(const Proxy& a, const Class& b) const noexcept {
+      return decoding_table->storage_.composite(a) == b;
     }
   };
 
@@ -116,42 +114,38 @@ class GenericDecodingTable {
     PROMPP_ALWAYS_INLINE explicit LessComparator(const GenericDecodingTable* decoding_table) noexcept : decoding_table_(decoding_table) {}
 
     PROMPP_ALWAYS_INLINE bool operator()(const Proxy& a, const Proxy& b) const noexcept {
-      return decoding_table_->items_[a].composite(decoding_table_->data_) < decoding_table_->items_[b].composite(decoding_table_->data_);
+      return decoding_table_->storage_.composite(a) < decoding_table_->storage_.composite(b);
     }
 
     template <class Class>
     PROMPP_ALWAYS_INLINE bool operator()(const Proxy& a, const Class& b) const noexcept {
-      return decoding_table_->items_[a].composite(decoding_table_->data_) < b;
+      return decoding_table_->storage_.composite(a) < b;
     }
 
     template <class Class>
       requires(!std::is_same_v<Class, Proxy>)
     PROMPP_ALWAYS_INLINE bool operator()(const Class& a, const Proxy& b) const noexcept {
-      return a < decoding_table_->items_[b].composite(decoding_table_->data_);
+      return a < decoding_table_->storage_.composite(b);
     }
 
    private:
     const GenericDecodingTable* decoding_table_;
   };
 
-  template <class DecodingTable>
   class Checkpoint {
-    const DecodingTable* decoding_table_;
+    const storage_type* storage_ptr_;
     uint32_t next_item_index_;
     uint32_t size_;
-    typename data_type::checkpoint_type data_checkpoint_;
+    typename storage_type::checkpoint_type storage_checkpoint_;
 
    public:
-    explicit inline __attribute__((always_inline)) Checkpoint(const DecodingTable& decoding_table, uint32_t next_item_index) noexcept
-        : decoding_table_(&decoding_table),
-          next_item_index_(next_item_index),
-          size_(decoding_table.size()),
-          data_checkpoint_(decoding_table.data().checkpoint()) {}
+    explicit PROMPP_ALWAYS_INLINE Checkpoint(const storage_type& storage, uint32_t next_item_index, uint32_t size) noexcept
+        : storage_ptr_(&storage), next_item_index_(next_item_index), size_(size), storage_checkpoint_(storage.checkpoint()) {}
 
     [[nodiscard]] PROMPP_ALWAYS_INLINE size_t size() const noexcept { return size_; }
     [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return next_item_index_; }
 
-    const typename data_type::checkpoint_type& data_checkpoint() const noexcept { return data_checkpoint_; }
+    const typename storage_type::checkpoint_type& storage_checkpoint() const noexcept { return storage_checkpoint_; }
 
     template <OutputStream S>
     void save(S& out, const Checkpoint* from = nullptr) const {
@@ -159,20 +153,21 @@ class GenericDecodingTable {
       auto sg1 = std::experimental::scope_exit([&]() { out.exceptions(original_exceptions); });
       out.exceptions(std::ifstream::failbit | std::ifstream::badbit);
 
-      // write version
-      out.put(1);
+      // write a version
+      out.put(2);
 
       // write mode
       SerializationMode mode = (from != nullptr) ? SerializationMode::DELTA : SerializationMode::SNAPSHOT;
       out.put(static_cast<char>(mode));
 
-      // write index of first item in the portion
+      // write index of the first item in the portion
       uint32_t first_to_save_i = 0;
       if (from != nullptr) {
         first_to_save_i = from->next_item_index_;
         out.write(reinterpret_cast<const char*>(&from->next_item_index_), sizeof(from->next_item_index_));
       }
-      const uint32_t first_item_index_in_decoding_table = decoding_table_->next_item_index() - decoding_table_->items().size();
+      const uint32_t first_item_index_in_decoding_table = next_item_index_ - size_;
+      const uint32_t id_offset = first_to_save_i - first_item_index_in_decoding_table;
       assert(first_to_save_i >= first_item_index_in_decoding_table);
 
       // write size
@@ -183,15 +178,11 @@ class GenericDecodingTable {
         return;
       }
 
-      // write items
-      out.write(reinterpret_cast<const char*>(&decoding_table_->items()[first_to_save_i - first_item_index_in_decoding_table]),
-                sizeof(Filament<Vector>) * size_to_save);
-
       // write data
       if (from != nullptr) {
-        data_checkpoint_.save(out, decoding_table_->data(), &from->data_checkpoint_);
+        storage_checkpoint_.save(out, *storage_ptr_, id_offset, size_to_save, &from->storage_checkpoint_);
       } else {
-        data_checkpoint_.save(out, decoding_table_->data());
+        storage_checkpoint_.save(out, *storage_ptr_, id_offset, size_to_save);
       }
     }
 
@@ -205,7 +196,7 @@ class GenericDecodingTable {
       // version is written and read by methods put() and get() and they write and read 1 byte
       size_t res = 1 + sizeof(SerializationMode);
 
-      // index of first item in the portion
+      // index of the first item in the portion
       uint32_t first_to_save_i = 0;
       if (from != nullptr) {
         first_to_save_i = from->next_item_index_;
@@ -220,29 +211,26 @@ class GenericDecodingTable {
       if (!size_to_save)
         return res;
 
-      // items
-      res += sizeof(Filament<Vector>) * size_to_save;
-
       // data
       if (from != nullptr) {
-        res += data_checkpoint_.save_size(decoding_table_->data(), &from->data_checkpoint_);
+        res += storage_checkpoint_.save_size(*storage_ptr_, size_to_save, &from->storage_checkpoint_);
       } else {
-        res += data_checkpoint_.save_size(decoding_table_->data());
+        res += storage_checkpoint_.save_size(*storage_ptr_, size_to_save);
       }
 
       return res;
     }
 
     /**
-     * ATTENTION! This class persists only pointers to checkpoint. It's a user resposability
-     * to prevent using delta out of checkpoints scope!
+     * ATTENTION! This class persists only pointers to checkpoint. It's a user responsibility
+     * to prevent using delta out of checkpoint scope!
      */
     class Delta {
       Checkpoint const* from_;
       Checkpoint const* to_;
 
      public:
-      inline __attribute__((always_inline)) Delta(Checkpoint const& from, Checkpoint const& to) noexcept : from_(&from), to_(&to) {}
+      PROMPP_ALWAYS_INLINE Delta(Checkpoint const& from, Checkpoint const& to) noexcept : from_(&from), to_(&to) {}
 
       [[nodiscard]] bool empty() const noexcept { return from_->size() >= to_->size(); }
 
@@ -262,11 +250,10 @@ class GenericDecodingTable {
   [[nodiscard]] PROMPP_ALWAYS_INLINE EqualityComparator equality_comparator() const noexcept { return EqualityComparator(this); }
   [[nodiscard]] PROMPP_ALWAYS_INLINE LessComparator less_comparator() const noexcept { return LessComparator(this); }
 
-  data_type data_;
-  Vector<Filament<Vector>> items_;
+  storage_type storage_;
 
  public:
-  using checkpoint_type = Checkpoint<GenericDecodingTable>;
+  using checkpoint_type = Checkpoint;
   using delta_type = typename checkpoint_type::Delta;
 
   GenericDecodingTable() noexcept = default;
@@ -274,49 +261,45 @@ class GenericDecodingTable {
 
   template <class AnotherDerived, template <template <class> class> class AnotherFilament, template <class> class AnotherVector>
     requires kIsReadOnly
-  explicit GenericDecodingTable(const GenericDecodingTable<AnotherDerived, AnotherFilament, AnotherVector>& other) : data_(other.data_), items_(other.items_) {}
+  explicit GenericDecodingTable(const GenericDecodingTable<AnotherDerived, AnotherFilament, AnotherVector>& other) : storage_(other.storage_) {}
 
   GenericDecodingTable(GenericDecodingTable&& other) noexcept = delete;
   GenericDecodingTable& operator=(const GenericDecodingTable& other) = delete;
   GenericDecodingTable& operator=(GenericDecodingTable&& other) noexcept = delete;
 
-  inline __attribute__((always_inline)) value_type operator[](uint32_t id) const noexcept { return items_[id].composite(data_); }
+  PROMPP_ALWAYS_INLINE value_type operator[](uint32_t id) const noexcept { return storage_.composite(id); }
 
-  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return items_.size(); }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return storage_.count(); }
 
-  [[nodiscard]] PROMPP_ALWAYS_INLINE size_t allocated_memory() const noexcept { return mem::allocated_memory(data_) + mem::allocated_memory(items_); }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE size_t allocated_memory() const noexcept { return mem::allocated_memory(storage_); }
 
-  inline __attribute__((always_inline)) const data_type& data() const noexcept { return data_; }
-
-  inline __attribute__((always_inline)) const auto& items() const noexcept { return items_; }
+  PROMPP_ALWAYS_INLINE storage_type::view_type data_view() const noexcept { return storage_.view(); }
 
   template <class DerivedOther, template <template <class> class> class FilamentOther, template <class> class VectorOther>
   PROMPP_ALWAYS_INLINE void reserve(const GenericDecodingTable<DerivedOther, FilamentOther, VectorOther>& other) {
-    items_.reserve(other.items_.size());
-    data_.reserve(other.data_);
+    storage_.reserve(other.storage_);
   }
 
   [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept {
     if constexpr (has_next_item_index<Derived>) {
       return static_cast<const Derived*>(this)->next_item_index_impl();
     } else {
-      return items_.size();
+      return storage_.next_item_index();
     }
   }
 
-  inline __attribute__((always_inline)) auto checkpoint() const noexcept { return checkpoint_type(*this, items_.size()); }
+  PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return checkpoint_type(storage_, next_item_index(), size()); }
 
-  PROMPP_ALWAYS_INLINE void rollback(const checkpoint_type& s) noexcept
+  PROMPP_ALWAYS_INLINE void rollback(const checkpoint_type& checkpoint) noexcept
     requires(!kIsReadOnly)
   {
     if constexpr (has_rollback<Derived, checkpoint_type>) {
-      static_cast<Derived*>(this)->rollback_impl(s);
+      static_cast<Derived*>(this)->rollback_impl(checkpoint);
     }
 
     if constexpr (!kIsReadOnly) {
-      assert(s.size() <= items_.size());
-      items_.resize(s.size());
-      data_.rollback(s.data_checkpoint());
+      assert(checkpoint.size() <= size());
+      storage_.rollback(checkpoint.storage_checkpoint());
     }
   }
 
@@ -325,13 +308,14 @@ class GenericDecodingTable {
     // read version
     const uint8_t version = in.get();
 
-    // return successfully, if stream is empty
-    if (in.eof())
+    // return successfully if the stream is empty
+    if (in.eof()) {
       return;
+    }
 
     // check version
-    if (version != 1) {
-      throw BareBones::Exception(0x343b7bcc6814f2d5, "Invalid EncodingSequence version %d got from input stream, only version 1 is supported", version);
+    if (version != 2) {
+      throw BareBones::Exception(0x343b7bcc6814f2d5, "Invalid EncodingSequence version %d got from input stream, only version 2 is supported", version);
     }
 
     auto original_exceptions = in.exceptions();
@@ -341,7 +325,7 @@ class GenericDecodingTable {
     // read mode
     const auto mode = static_cast<SerializationMode>(in.get());
 
-    // read index of first item in the portion, if we are reading wal
+    // read index of the first item in the portion if we are reading wal
     uint32_t first_to_load_i = 0;
     if (mode == SerializationMode::DELTA) {
       in.read(reinterpret_cast<char*>(&first_to_load_i), sizeof(first_to_load_i));
@@ -349,12 +333,12 @@ class GenericDecodingTable {
     if (first_to_load_i != next_item_index()) {
       if (mode == SerializationMode::SNAPSHOT) {
         throw BareBones::Exception(0x7bcd6011e39bbabc, "Attempt to load snapshot into non-empty DecodingTable");
-      } else if (first_to_load_i < items_.size()) {
+      } else if (first_to_load_i < size()) {
         throw BareBones::Exception(0x3387739a7b4f574a, "Attempt to load segment over existing DecodingTable data");
       } else {
         throw BareBones::Exception(0x4ece66e098927bc6,
-                                   "Attempt to load incomplete data from segment, DecodingTable data vector length (%u) is less than segment size(%d)",
-                                   items_.size(), first_to_load_i);
+                                   "Attempt to load incomplete data from segment, DecodingTable data vector length (%u) is less than segment size(%d)", size(),
+                                   first_to_load_i);
       }
     }
 
@@ -362,32 +346,19 @@ class GenericDecodingTable {
     uint32_t size_to_load;
     in.read(reinterpret_cast<char*>(&size_to_load), sizeof(size_to_load));
 
-    // read is completed, if there are no items
+    // read is completed if there are no items
     if (!size_to_load) {
       return;
     }
 
-    // read items
-    const auto original_size = items_.size();
-    auto sg2 = std::experimental::scope_fail([&]() { items_.resize(original_size); });
-    items_.resize(items_.size() + size_to_load);
-    in.read(reinterpret_cast<char*>(&items_[original_size]), sizeof(Filament<Vector>) * size_to_load);
+    auto storage_checkpoint = storage_.checkpoint();
+    auto sg2 = std::experimental::scope_fail([&]() { storage_.rollback(storage_checkpoint); });
+    const auto loaded_range = storage_.load(in, size_to_load);
 
-    // read data
-    auto data_checkpoint = data_.checkpoint();
-    auto sg3 = std::experimental::scope_fail([&]() { data_.rollback(data_checkpoint); });
-    data_.load(in);
-
-    // validate each item (check ranges, etc)
-    for (auto i = original_size; i != items_.size(); ++i) {
-      items_[i].validate(data_);
-    }
-
-    // post processing
-    if constexpr (has_after_items_load<Derived, std::ranges::iota_view<uint32_t>>) {
-      auto r = std::views::iota(original_size, items_.size());
-      static_assert(noexcept(static_cast<Derived*>(this)->after_items_load_impl(r)));
-      static_cast<Derived*>(this)->after_items_load_impl(r);
+    // post-processing
+    if constexpr (has_after_items_load<Derived, decltype(loaded_range)>) {
+      static_assert(noexcept(static_cast<Derived*>(this)->after_items_load_impl(loaded_range)));
+      static_cast<Derived*>(this)->after_items_load_impl(loaded_range);
     }
   }
 
@@ -403,123 +374,10 @@ class GenericDecodingTable {
     return in;
   }
 
-  template <class InnerIteratorType>
-  class IteratorSentinel {
-    InnerIteratorType i_;
-
-   public:
-    inline __attribute__((always_inline)) explicit IteratorSentinel(InnerIteratorType i = InnerIteratorType()) noexcept : i_(i) {}
-
-    inline __attribute__((always_inline)) const InnerIteratorType& inner_iterator() const noexcept { return i_; }
-  };
-
-  template <class InnerIteratorType>
-  class ItemIterator {
-    const GenericDecodingTable* decoding_table_;
-    InnerIteratorType i_;
-
-   public:
-    using iterator_category = std::input_iterator_tag;
-    using value_type = typename Filament<Vector>::composite_type;
-    using difference_type = std::ptrdiff_t;
-
-    inline __attribute__((always_inline)) explicit ItemIterator(const GenericDecodingTable* decoding_table = nullptr,
-                                                                InnerIteratorType i = InnerIteratorType()) noexcept
-        : decoding_table_(decoding_table), i_(i) {}
-
-    inline __attribute__((always_inline)) ItemIterator& operator++() noexcept {
-      ++i_;
-      return *this;
-    }
-
-    inline __attribute__((always_inline)) ItemIterator operator++(int) noexcept {
-      ItemIterator retval = *this;
-      ++(*this);
-      return retval;
-    }
-
-    inline __attribute__((always_inline)) bool operator==(const ItemIterator& other) const noexcept { return i_ == other.i_; }
-
-    template <class InnerIteratorSentinelType>
-    inline __attribute__((always_inline)) bool operator==(const IteratorSentinel<InnerIteratorSentinelType>& other) const noexcept {
-      return i_ == other.inner_iterator();
-    }
-
-    inline __attribute__((always_inline)) value_type operator*() const noexcept { return i_->composite(decoding_table_->data()); }
-  };
-
-  template <class InnerIteratorType>
-  class ItemIDIterator {
-    const GenericDecodingTable* decoding_table_;
-    InnerIteratorType i_;
+  PROMPP_ALWAYS_INLINE auto begin() const noexcept { return storage_.view().begin(); }
+  PROMPP_ALWAYS_INLINE auto end() const noexcept { return storage_.view().end(); }
 
-   public:
-    using iterator_category = std::input_iterator_tag;
-    using value_type = typename Filament<Vector>::composite_type;
-    using difference_type = std::ptrdiff_t;
-
-    inline __attribute__((always_inline)) explicit ItemIDIterator(const GenericDecodingTable* decoding_table = nullptr,
-                                                                  InnerIteratorType i = InnerIteratorType()) noexcept
-        : decoding_table_(decoding_table), i_(i) {}
-    inline __attribute__((always_inline)) ItemIDIterator& operator++() {
-      ++i_;
-      return *this;
-    }
-
-    inline __attribute__((always_inline)) ItemIDIterator operator++(int) noexcept {
-      ItemIDIterator retval = *this;
-      ++(*this);
-      return retval;
-    }
-
-    inline __attribute__((always_inline)) bool operator==(const ItemIDIterator& other) const noexcept { return i_ == other.i_; }
-
-    template <class InnerIteratorSentinelType>
-    inline __attribute__((always_inline)) bool operator==(const IteratorSentinel<InnerIteratorSentinelType>& other) const noexcept {
-      return i_ == other.inner_iterator();
-    }
-
-    inline __attribute__((always_inline)) value_type operator*() const noexcept { return (*decoding_table_)[*i_]; }
-
-    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t id() const noexcept { return *i_; }
-  };
-
-  template <class InnerIteratorType, class InnerIteratorSentinelType>
-  class Resolver {
-    using inner_iterator_type = InnerIteratorType;
-    using inner_iterator_sentinel_type = InnerIteratorSentinelType;
-
-    const GenericDecodingTable* decoding_table_;
-    inner_iterator_type begin_;
-    inner_iterator_sentinel_type end_;
-
-   public:
-    using value_type = typename Filament<Vector>::composite_type;
-
-    inline __attribute__((always_inline)) explicit Resolver(const GenericDecodingTable* decoding_table = nullptr,
-                                                            inner_iterator_type begin = inner_iterator_type(),
-                                                            inner_iterator_sentinel_type end = inner_iterator_sentinel_type()) noexcept
-        : decoding_table_(decoding_table), begin_(begin), end_(end) {}
-
-    inline __attribute__((always_inline)) auto begin() const noexcept { return ItemIDIterator<inner_iterator_type>(decoding_table_, begin_); }
-    inline __attribute__((always_inline)) auto end() const noexcept { return IteratorSentinel<inner_iterator_sentinel_type>(end_); }
-    [[nodiscard]] PROMPP_ALWAYS_INLINE size_t size() const noexcept { return end_ - begin_; }
-  };
-
-  template <class IteratorType, class IteratorSentinelType>
-  inline __attribute__((always_inline)) Resolver<IteratorType, IteratorSentinelType> resolve(IteratorType begin, IteratorSentinelType end) const noexcept {
-    return Resolver<IteratorType, IteratorSentinelType>(this, begin, end);
-  }
-
-  template <class R>
-  inline __attribute__((always_inline)) auto resolve(const R& range) const noexcept {
-    return resolve(range.begin(), range.end());
-  }
-
-  inline __attribute__((always_inline)) auto begin() const noexcept { return ItemIterator<decltype(items_.begin())>(this, items_.begin()); }
-  inline __attribute__((always_inline)) auto end() const noexcept { return IteratorSentinel<decltype(items_.end())>(items_.end()); }
-
-  inline __attribute__((always_inline)) auto remainder_size() const noexcept { return this->data_.remainder_size(); }
+  PROMPP_ALWAYS_INLINE auto remainder_size() const noexcept { return storage_.remainder_size(); }
 };
 
 template <template <template <class> class> class Filament, template <class> class Vector>
@@ -535,14 +393,13 @@ template <template <template <class> class> class Filament, template <class> cla
 class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEncodingBimap<Filament, Vector>, Filament, Vector> {
  public:
   using Base = GenericDecodingTable<ShrinkableEncodingBimap, Filament, Vector>;
-  using checkpoint_type = typename Base::template Checkpoint<ShrinkableEncodingBimap>;
-  using delta_type = typename checkpoint_type::Delta;
+  using checkpoint_type = typename Base::checkpoint_type;
   using value_type = typename Base::value_type;
 
-  using Base::data;
-  using Base::items;
+  using Base::checkpoint;
   using Base::load;
   using Base::next_item_index;
+  using Base::remainder_size;
   using Base::size;
 
   friend class GenericDecodingTable<ShrinkableEncodingBimap, Filament, Vector>;
@@ -550,16 +407,16 @@ class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEnc
   template <class Class>
   PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const Class& c) noexcept {
     return *set_.lazy_emplace(c, [&](const auto& ctor) {
-      ctor(Base::items_.size());
-      Base::items_.emplace_back(Base::data_, c);
+      const auto id = Base::storage_.emplace_back(c);
+      ctor(id);
     }) + shift_;
   }
 
   template <class Class>
   PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const Class& c, size_t hashval) noexcept {
     return *set_.lazy_emplace_with_hash(c, phmap::phmap_mix<sizeof(size_t)>()(hashval), [&](const auto& ctor) {
-      ctor(Base::items_.size());
-      Base::items_.emplace_back(Base::data_, c);
+      const auto id = Base::storage_.emplace_back(c);
+      ctor(id);
     }) + shift_;
   }
 
@@ -579,18 +436,14 @@ class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEnc
     return {};
   }
 
-  PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return checkpoint_type(*this, next_item_index_impl()); }
-
   void shrink_to_checkpoint_size(const checkpoint_type& checkpoint) {
     if (checkpoint.next_item_index() != next_item_index_impl()) {
       throw Exception(0x1bf0dbff9fe3d955, "Invalid checkpoint to shrink: checkpoint next_item_index [%u], next_item_index [%u]", checkpoint.next_item_index(),
                       next_item_index_impl());
     }
 
-    shift_ += Base::items_.size();
-    Base::items_.resize(0);
-    Base::items_.shrink_to_fit();
-    Base::data_.shrink_to(0);
+    shift_ += Base::size();
+    Base::storage_.shrink();
     set_.clear();
   }
 
@@ -617,7 +470,7 @@ class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEnc
       Allocator<typename Base::Proxy, uint32_t>{set_allocated_memory_}};
   uint32_t shift_{0};
 
-  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index_impl() const noexcept { return shift_ + Base::items_.size(); }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index_impl() const noexcept { return shift_ + Base::storage_.next_item_index(); }
 
   template <ls_id_range R>
   PROMPP_ALWAYS_INLINE void after_items_load_impl(R&& loaded_ids) noexcept {
@@ -658,8 +511,7 @@ class EncodingBimap : public GenericDecodingTable<EncodingBimap<Filament, Vector
   template <class Class>
   PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const Class& c) noexcept {
     return *set_.lazy_emplace(c, [&](const auto& ctor) {
-      uint32_t id = Base::items_.size();
-      Base::items_.emplace_back(Base::data_, c);
+      const uint32_t id = Base::storage_.emplace_back(c);
       ctor(id);
     });
   }
@@ -667,8 +519,7 @@ class EncodingBimap : public GenericDecodingTable<EncodingBimap<Filament, Vector
   template <class Class>
   PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const Class& c, size_t hashval) noexcept {
     return *set_.lazy_emplace_with_hash(c, phmap::phmap_mix<sizeof(size_t)>()(hashval), [&](const auto& ctor) {
-      uint32_t id = Base::items_.size();
-      Base::items_.emplace_back(Base::data_, c);
+      const uint32_t id = Base::storage_.emplace_back(c);
       ctor(id);
     });
   }
@@ -680,8 +531,7 @@ class EncodingBimap : public GenericDecodingTable<EncodingBimap<Filament, Vector
     }
 
     return *set_.lazy_emplace(c, [&](const auto& ctor) {
-      uint32_t new_id = Base::items_.size();
-      Base::items_.emplace_back(Base::data_, c, std::forward<Args>(args)...);
+      uint32_t new_id = Base::storage_.emplace_back(c, std::forward<Args>(args)...);
       ctor(new_id);
       cache[id] = new_id;
     });
@@ -706,9 +556,9 @@ class EncodingBimap : public GenericDecodingTable<EncodingBimap<Filament, Vector
   PROMPP_ALWAYS_INLINE void rollback_impl(const typename Base::checkpoint_type& s) noexcept
     requires(!Base::kIsReadOnly)
   {
-    assert(s.size() <= Base::items_.size());
+    assert(s.size() <= Base::size());
 
-    for (uint32_t i = s.size(); i != Base::items_.size(); ++i) {
+    for (uint32_t i = s.size(); i != Base::size(); ++i) {
       set_.erase(typename Base::Proxy(i));
     }
   }
diff --git a/pp/bare_bones/snug_composite_v2.h b/pp/bare_bones/snug_composite_v2.h
deleted file mode 100644
index 7b6c30f2e..000000000
--- a/pp/bare_bones/snug_composite_v2.h
+++ /dev/null
@@ -1,571 +0,0 @@
-#pragma once
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#include <parallel_hashmap/btree.h>
-#include <parallel_hashmap/phmap.h>
-#pragma GCC diagnostic pop
-
-#include <scope_exit.h>
-
-#include <ranges>
-
-#include "bare_bones/allocator.h"
-#include "bare_bones/exception.h"
-#include "bare_bones/streams.h"
-#include "bare_bones/vector.h"
-#include "bare_bones/xxhash.h"
-
-namespace BareBones::SnugComposite::V2 {
-
-/**
- * Serialization mode used to annotate encoded data and how to apply it on container.
- * We use Delta to save the difference between two states of container. It doesn't matter
- * how the first state was made (from snapshot or other delta). Snapshot may be explained
- * as delta from init (zero) state.
- */
-enum class SerializationMode : char { SNAPSHOT = 1, DELTA = 2 };
-
-template <class Range>
-concept ls_id_range = std::ranges::range<Range> && std::same_as<std::ranges::range_value_t<Range>, uint32_t>;
-
-template <class FilamentDataType>
-concept is_shrinkable = requires(FilamentDataType& data_type) {
-  { data_type.shrink_to(uint32_t()) };
-};
-
-template <class Derived>
-concept has_next_item_index = requires(Derived derived) {
-  { derived.next_item_index_impl() };
-};
-
-template <class Derived, class Checkpoint>
-concept has_rollback = requires(Derived derived, const Checkpoint& checkpoint) {
-  { derived.rollback_impl(checkpoint) };
-};
-
-template <class Derived, class R>
-concept has_after_items_load = ls_id_range<R> && requires(Derived derived, R&& range) { derived.after_items_load_impl(std::forward<R>(range)); };
-
-template <class Derived, template <template <class> class> class Filament, template <class> class Vector>
-class GenericDecodingTable {
-  static_assert(!std::is_integral_v<typename Filament<Vector>::composite_type>, "Filament::composite_type can't be an integral type");
-
-  template <class AnyDerived, template <template <class> class> class AnyFilament, template <class> class AnyVector>
-  friend class GenericDecodingTable;
-
- public:
-  using filament_type = Filament<Vector>;
-  using storage_type = filament_type::storage_type;
-  using value_type = storage_type::composite_type;
-
-  static constexpr bool kIsReadOnly = IsSharedSpan<Vector<uint8_t>>::value;
-
-  static constexpr auto kInvalidId = std::numeric_limits<uint32_t>::max();
-
- protected:
-  class Proxy {
-    uint32_t id_;
-
-   public:
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    PROMPP_ALWAYS_INLINE Proxy(uint32_t id) noexcept : id_(id) {}
-
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    PROMPP_ALWAYS_INLINE operator uint32_t() const noexcept { return id_; }
-
-    PROMPP_ALWAYS_INLINE bool operator==(const Proxy& o) noexcept { return id_ == o.id_; }
-  };
-
-  struct Hasher {
-    using is_transparent = void;
-
-    const GenericDecodingTable* decoding_table;
-    PROMPP_ALWAYS_INLINE explicit Hasher(const GenericDecodingTable* _decoding_table = nullptr) noexcept : decoding_table(_decoding_table) {}
-
-    PROMPP_ALWAYS_INLINE size_t operator()(const std::string_view& str) const noexcept { return XXHash::hash(str); }
-    PROMPP_ALWAYS_INLINE size_t operator()(const std::string& str) const noexcept { return XXHash::hash(str); }
-
-    template <class Class>
-    PROMPP_ALWAYS_INLINE size_t operator()(const Class& c) const noexcept {
-      return phmap::Hash<Class>()(c);
-    }
-
-    PROMPP_ALWAYS_INLINE size_t operator()(const Proxy& p) const noexcept { return this->operator()(decoding_table->storage_.composite(p)); }
-  };
-
-  struct EqualityComparator {
-    using is_transparent = void;
-
-    const GenericDecodingTable* decoding_table;
-    PROMPP_ALWAYS_INLINE explicit EqualityComparator(const GenericDecodingTable* _decoding_table = nullptr) noexcept : decoding_table(_decoding_table) {}
-
-    PROMPP_ALWAYS_INLINE bool operator()(const Proxy& a, const Proxy& b) const noexcept { return a == b; }
-
-    template <class Class>
-    PROMPP_ALWAYS_INLINE bool operator()(const Proxy& a, const Class& b) const noexcept {
-      return decoding_table->storage_.composite(a) == b;
-    }
-  };
-
-  struct LessComparator {
-    using is_transparent = void;
-
-    PROMPP_ALWAYS_INLINE explicit LessComparator(const GenericDecodingTable* decoding_table) noexcept : decoding_table_(decoding_table) {}
-
-    PROMPP_ALWAYS_INLINE bool operator()(const Proxy& a, const Proxy& b) const noexcept {
-      return decoding_table_->storage_.composite(a) < decoding_table_->storage_.composite(b);
-    }
-
-    template <class Class>
-    PROMPP_ALWAYS_INLINE bool operator()(const Proxy& a, const Class& b) const noexcept {
-      return decoding_table_->storage_.composite(a) < b;
-    }
-
-    template <class Class>
-      requires(!std::is_same_v<Class, Proxy>)
-    PROMPP_ALWAYS_INLINE bool operator()(const Class& a, const Proxy& b) const noexcept {
-      return a < decoding_table_->storage_.composite(b);
-    }
-
-   private:
-    const GenericDecodingTable* decoding_table_;
-  };
-
-  class Checkpoint {
-    const storage_type* storage_ptr_;
-    uint32_t next_item_index_;
-    uint32_t size_;
-    typename storage_type::checkpoint_type storage_checkpoint_;
-
-   public:
-    explicit PROMPP_ALWAYS_INLINE Checkpoint(const storage_type& storage, uint32_t next_item_index, uint32_t size) noexcept
-        : storage_ptr_(&storage), next_item_index_(next_item_index), size_(size), storage_checkpoint_(storage.checkpoint()) {}
-
-    [[nodiscard]] PROMPP_ALWAYS_INLINE size_t size() const noexcept { return size_; }
-    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return next_item_index_; }
-
-    const typename storage_type::checkpoint_type& storage_checkpoint() const noexcept { return storage_checkpoint_; }
-
-    template <OutputStream S>
-    void save(S& out, const Checkpoint* from = nullptr) const {
-      auto original_exceptions = out.exceptions();
-      auto sg1 = std::experimental::scope_exit([&]() { out.exceptions(original_exceptions); });
-      out.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-
-      // write a version
-      out.put(2);
-
-      // write mode
-      SerializationMode mode = (from != nullptr) ? SerializationMode::DELTA : SerializationMode::SNAPSHOT;
-      out.put(static_cast<char>(mode));
-
-      // write index of the first item in the portion
-      uint32_t first_to_save_i = 0;
-      if (from != nullptr) {
-        first_to_save_i = from->next_item_index_;
-        out.write(reinterpret_cast<const char*>(&from->next_item_index_), sizeof(from->next_item_index_));
-      }
-      const uint32_t first_item_index_in_decoding_table = next_item_index_ - size_;
-      const uint32_t id_offset = first_to_save_i - first_item_index_in_decoding_table;
-      assert(first_to_save_i >= first_item_index_in_decoding_table);
-
-      // write size
-      uint32_t size_to_save = next_item_index_ - first_to_save_i;
-      out.write(reinterpret_cast<char*>(&size_to_save), sizeof(size_to_save));
-      // if there are no items to write, we finish here
-      if (!size_to_save) {
-        return;
-      }
-
-      // write data
-      if (from != nullptr) {
-        storage_checkpoint_.save(out, *storage_ptr_, id_offset, size_to_save, &from->storage_checkpoint_);
-      } else {
-        storage_checkpoint_.save(out, *storage_ptr_, id_offset, size_to_save);
-      }
-    }
-
-    template <OutputStream S>
-    friend S& operator<<(S& out, const Checkpoint& cp) {
-      cp.save(out);
-      return out;
-    }
-
-    size_t save_size(const Checkpoint* from = nullptr) const noexcept {
-      // version is written and read by methods put() and get() and they write and read 1 byte
-      size_t res = 1 + sizeof(SerializationMode);
-
-      // index of the first item in the portion
-      uint32_t first_to_save_i = 0;
-      if (from != nullptr) {
-        first_to_save_i = from->next_item_index_;
-        res += sizeof(uint32_t);
-      }
-
-      // size
-      const uint32_t size_to_save = next_item_index_ - first_to_save_i;
-      res += sizeof(uint32_t);
-
-      // if there are no items to write, we finish here
-      if (!size_to_save)
-        return res;
-
-      // data
-      if (from != nullptr) {
-        res += storage_checkpoint_.save_size(*storage_ptr_, size_to_save, &from->storage_checkpoint_);
-      } else {
-        res += storage_checkpoint_.save_size(*storage_ptr_, size_to_save);
-      }
-
-      return res;
-    }
-
-    /**
-     * ATTENTION! This class persists only pointers to checkpoint. It's a user responsibility
-     * to prevent using delta out of checkpoint scope!
-     */
-    class Delta {
-      Checkpoint const* from_;
-      Checkpoint const* to_;
-
-     public:
-      PROMPP_ALWAYS_INLINE Delta(Checkpoint const& from, Checkpoint const& to) noexcept : from_(&from), to_(&to) {}
-
-      [[nodiscard]] bool empty() const noexcept { return from_->size() >= to_->size(); }
-
-      template <OutputStream S>
-      friend S& operator<<(S& out, Delta dt) {
-        dt.to_->save(out, dt.from_);
-        return out;
-      }
-
-      [[nodiscard]] size_t save_size() const noexcept { return to_->save_size(from_); }
-    };
-
-    Delta operator-(const Checkpoint& from) const noexcept { return Delta(from, *this); }
-  };
-
-  [[nodiscard]] PROMPP_ALWAYS_INLINE Hasher hasher() const noexcept { return Hasher(this); }
-  [[nodiscard]] PROMPP_ALWAYS_INLINE EqualityComparator equality_comparator() const noexcept { return EqualityComparator(this); }
-  [[nodiscard]] PROMPP_ALWAYS_INLINE LessComparator less_comparator() const noexcept { return LessComparator(this); }
-
-  storage_type storage_;
-
- public:
-  using checkpoint_type = Checkpoint;
-  using delta_type = typename checkpoint_type::Delta;
-
-  GenericDecodingTable() noexcept = default;
-  GenericDecodingTable(const GenericDecodingTable& other) = delete;
-
-  template <class AnotherDerived, template <template <class> class> class AnotherFilament, template <class> class AnotherVector>
-    requires kIsReadOnly
-  explicit GenericDecodingTable(const GenericDecodingTable<AnotherDerived, AnotherFilament, AnotherVector>& other) : storage_(other.storage_) {}
-
-  GenericDecodingTable(GenericDecodingTable&& other) noexcept = delete;
-  GenericDecodingTable& operator=(const GenericDecodingTable& other) = delete;
-  GenericDecodingTable& operator=(GenericDecodingTable&& other) noexcept = delete;
-
-  PROMPP_ALWAYS_INLINE value_type operator[](uint32_t id) const noexcept { return storage_.composite(id); }
-
-  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return storage_.count(); }
-
-  [[nodiscard]] PROMPP_ALWAYS_INLINE size_t allocated_memory() const noexcept { return mem::allocated_memory(storage_); }
-
-  PROMPP_ALWAYS_INLINE storage_type::view_type data_view() const noexcept { return storage_.view(); }
-
-  template <class DerivedOther, template <template <class> class> class FilamentOther, template <class> class VectorOther>
-  PROMPP_ALWAYS_INLINE void reserve(const GenericDecodingTable<DerivedOther, FilamentOther, VectorOther>& other) {
-    storage_.reserve(other.storage_);
-  }
-
-  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept {
-    if constexpr (has_next_item_index<Derived>) {
-      return static_cast<const Derived*>(this)->next_item_index_impl();
-    } else {
-      return storage_.next_item_index();
-    }
-  }
-
-  PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return checkpoint_type(storage_, next_item_index(), size()); }
-
-  PROMPP_ALWAYS_INLINE void rollback(const checkpoint_type& checkpoint) noexcept
-    requires(!kIsReadOnly)
-  {
-    if constexpr (has_rollback<Derived, checkpoint_type>) {
-      static_cast<Derived*>(this)->rollback_impl(checkpoint);
-    }
-
-    if constexpr (!kIsReadOnly) {
-      assert(checkpoint.size() <= size());
-      storage_.rollback(checkpoint.storage_checkpoint());
-    }
-  }
-
-  template <InputStream S>
-  void load(S& in) {
-    // read version
-    const uint8_t version = in.get();
-
-    // return successfully if the stream is empty
-    if (in.eof()) {
-      return;
-    }
-
-    // check version
-    if (version != 2) {
-      throw BareBones::Exception(0x343b7bcc6814f2d5, "Invalid EncodingSequence version %d got from input stream, only version 2 is supported", version);
-    }
-
-    auto original_exceptions = in.exceptions();
-    auto sg1 = std::experimental::scope_exit([&]() { in.exceptions(original_exceptions); });
-    in.exceptions(std::ifstream::failbit | std::ifstream::badbit | std::ifstream::eofbit);
-
-    // read mode
-    const auto mode = static_cast<SerializationMode>(in.get());
-
-    // read index of the first item in the portion if we are reading wal
-    uint32_t first_to_load_i = 0;
-    if (mode == SerializationMode::DELTA) {
-      in.read(reinterpret_cast<char*>(&first_to_load_i), sizeof(first_to_load_i));
-    }
-    if (first_to_load_i != next_item_index()) {
-      if (mode == SerializationMode::SNAPSHOT) {
-        throw BareBones::Exception(0x7bcd6011e39bbabc, "Attempt to load snapshot into non-empty DecodingTable");
-      } else if (first_to_load_i < size()) {
-        throw BareBones::Exception(0x3387739a7b4f574a, "Attempt to load segment over existing DecodingTable data");
-      } else {
-        throw BareBones::Exception(0x4ece66e098927bc6,
-                                   "Attempt to load incomplete data from segment, DecodingTable data vector length (%u) is less than segment size(%d)", size(),
-                                   first_to_load_i);
-      }
-    }
-
-    // read size
-    uint32_t size_to_load;
-    in.read(reinterpret_cast<char*>(&size_to_load), sizeof(size_to_load));
-
-    // read is completed if there are no items
-    if (!size_to_load) {
-      return;
-    }
-
-    auto storage_checkpoint = storage_.checkpoint();
-    auto sg2 = std::experimental::scope_fail([&]() { storage_.rollback(storage_checkpoint); });
-    const auto loaded_range = storage_.load(in, size_to_load);
-
-    // post-processing
-    if constexpr (has_after_items_load<Derived, decltype(loaded_range)>) {
-      static_assert(noexcept(static_cast<Derived*>(this)->after_items_load_impl(loaded_range)));
-      static_cast<Derived*>(this)->after_items_load_impl(loaded_range);
-    }
-  }
-
-  template <OutputStream S>
-  friend S& operator<<(S& out, GenericDecodingTable& decoding_table) {
-    out << decoding_table.checkpoint();
-    return out;
-  }
-
-  template <InputStream S>
-  friend S& operator>>(S& in, GenericDecodingTable& decoding_table) {
-    decoding_table.load(in);
-    return in;
-  }
-
-  PROMPP_ALWAYS_INLINE auto begin() const noexcept { return storage_.view().begin(); }
-  PROMPP_ALWAYS_INLINE auto end() const noexcept { return storage_.view().end(); }
-
-  PROMPP_ALWAYS_INLINE auto remainder_size() const noexcept { return storage_.remainder_size(); }
-};
-
-template <template <template <class> class> class Filament, template <class> class Vector>
-class DecodingTable : public GenericDecodingTable<DecodingTable<Filament, Vector>, Filament, Vector> {
- public:
-  using Base = GenericDecodingTable<DecodingTable, Filament, Vector>;
-
-  using Base::Base;
-};
-
-template <template <template <class> class> class Filament, template <class> class Vector>
-  requires is_shrinkable<typename Filament<Vector>::data_type>
-class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEncodingBimap<Filament, Vector>, Filament, Vector> {
- public:
-  using Base = GenericDecodingTable<ShrinkableEncodingBimap, Filament, Vector>;
-  using checkpoint_type = typename Base::checkpoint_type;
-  using value_type = typename Base::value_type;
-
-  using Base::checkpoint;
-  using Base::load;
-  using Base::next_item_index;
-  using Base::remainder_size;
-  using Base::size;
-
-  friend class GenericDecodingTable<ShrinkableEncodingBimap, Filament, Vector>;
-
-  template <class Class>
-  PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const Class& c) noexcept {
-    return *set_.lazy_emplace(c, [&](const auto& ctor) {
-      const auto id = Base::storage_.emplace_back(c);
-      ctor(id);
-    }) + shift_;
-  }
-
-  template <class Class>
-  PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const Class& c, size_t hashval) noexcept {
-    return *set_.lazy_emplace_with_hash(c, phmap::phmap_mix<sizeof(size_t)>()(hashval), [&](const auto& ctor) {
-      const auto id = Base::storage_.emplace_back(c);
-      ctor(id);
-    }) + shift_;
-  }
-
-  template <class Class>
-  PROMPP_ALWAYS_INLINE std::optional<uint32_t> find(const Class& c) const noexcept {
-    if (auto i = set_.find(c); i != set_.end()) {
-      return *i + shift_;
-    }
-    return {};
-  }
-
-  template <class Class>
-  PROMPP_ALWAYS_INLINE std::optional<uint32_t> find(const Class& c, size_t hashval) const noexcept {
-    if (auto i = set_.find(c, phmap::phmap_mix<sizeof(size_t)>()(hashval)); i != set_.end()) {
-      return *i + shift_;
-    }
-    return {};
-  }
-
-  void shrink_to_checkpoint_size(const checkpoint_type& checkpoint) {
-    if (checkpoint.next_item_index() != next_item_index_impl()) {
-      throw Exception(0x1bf0dbff9fe3d955, "Invalid checkpoint to shrink: checkpoint next_item_index [%u], next_item_index [%u]", checkpoint.next_item_index(),
-                      next_item_index_impl());
-    }
-
-    shift_ += Base::size();
-    Base::storage_.shrink();
-    set_.clear();
-  }
-
-  [[nodiscard]] PROMPP_ALWAYS_INLINE size_t allocated_memory() const noexcept { return Base::allocated_memory() + set_allocated_memory_; }
-
-  PROMPP_ALWAYS_INLINE value_type operator[](uint32_t id) const noexcept {
-    assert(id >= shift_);
-    return Base::operator[](id - shift_);
-  }
-
-  template <InputStream S>
-  friend S& operator>>(S& in, ShrinkableEncodingBimap& shrinkable_encoding_bimap) {
-    shrinkable_encoding_bimap.load(in);
-    return in;
-  }
-
- private:
-  uint32_t set_allocated_memory_{};
-  phmap::flat_hash_set<typename Base::Proxy, typename Base::Hasher, typename Base::EqualityComparator, Allocator<typename Base::Proxy, uint32_t>> set_{
-      {},
-      0,
-      Base::hasher(),
-      Base::equality_comparator(),
-      Allocator<typename Base::Proxy, uint32_t>{set_allocated_memory_}};
-  uint32_t shift_{0};
-
-  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index_impl() const noexcept { return shift_ + Base::storage_.next_item_index(); }
-
-  template <ls_id_range R>
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(R&& loaded_ids) noexcept {
-    if constexpr (std::ranges::sized_range<R>) {
-      set_.reserve(std::ranges::size(loaded_ids));
-    }
-    for (const auto id : loaded_ids) {
-      set_.emplace(typename Base::Proxy(id));
-    }
-  }
-};
-
-template <template <template <class> class> class Filament, template <class> class Vector>
-class EncodingBimap : public GenericDecodingTable<EncodingBimap<Filament, Vector>, Filament, Vector> {
-  using Base = GenericDecodingTable<EncodingBimap, Filament, Vector>;
-
-  friend class GenericDecodingTable<EncodingBimap, Filament, Vector>;
-
-  phmap::flat_hash_set<typename Base::Proxy, typename Base::Hasher, typename Base::EqualityComparator> set_{{}, 0, Base::hasher(), Base::equality_comparator()};
-
-  template <ls_id_range R>
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(R&& loaded_ids) noexcept {
-    if constexpr (std::ranges::sized_range<R>) {
-      set_.reserve(std::ranges::size(loaded_ids));
-    }
-    for (const auto id : loaded_ids) {
-      set_.emplace(typename Base::Proxy(id));
-    }
-  }
-
- public:
-  EncodingBimap() noexcept = default;
-  EncodingBimap(const EncodingBimap& other) = delete;
-  EncodingBimap(EncodingBimap&&) noexcept = delete;
-  EncodingBimap& operator=(const EncodingBimap&) = delete;
-  EncodingBimap& operator=(EncodingBimap&&) noexcept = delete;
-
-  template <class Class>
-  PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const Class& c) noexcept {
-    return *set_.lazy_emplace(c, [&](const auto& ctor) {
-      const uint32_t id = Base::storage_.emplace_back(c);
-      ctor(id);
-    });
-  }
-
-  template <class Class>
-  PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const Class& c, size_t hashval) noexcept {
-    return *set_.lazy_emplace_with_hash(c, phmap::phmap_mix<sizeof(size_t)>()(hashval), [&](const auto& ctor) {
-      const uint32_t id = Base::storage_.emplace_back(c);
-      ctor(id);
-    });
-  }
-
-  template <class Class, class Cache, class... Args>
-  PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_with_cache(const Class& c, uint32_t id, Cache& cache, Args&&... args) noexcept {
-    if (const auto value = cache[id]; value != Base::kInvalidId) {
-      return value;
-    }
-
-    return *set_.lazy_emplace(c, [&](const auto& ctor) {
-      uint32_t new_id = Base::storage_.emplace_back(c, std::forward<Args>(args)...);
-      ctor(new_id);
-      cache[id] = new_id;
-    });
-  }
-
-  template <class Class>
-  PROMPP_ALWAYS_INLINE std::optional<uint32_t> find(const Class& c) const noexcept {
-    if (auto i = set_.find(c); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  template <class Class>
-  PROMPP_ALWAYS_INLINE std::optional<uint32_t> find(const Class& c, size_t hashval) const noexcept {
-    if (auto i = set_.find(c, phmap::phmap_mix<sizeof(size_t)>()(hashval)); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  PROMPP_ALWAYS_INLINE void rollback_impl(const typename Base::checkpoint_type& s) noexcept
-    requires(!Base::kIsReadOnly)
-  {
-    assert(s.size() <= Base::size());
-
-    for (uint32_t i = s.size(); i != Base::size(); ++i) {
-      set_.erase(typename Base::Proxy(i));
-    }
-  }
-
-  [[nodiscard]] PROMPP_ALWAYS_INLINE size_t allocated_memory() const noexcept {
-    return Base::allocated_memory() + set_.capacity() * sizeof(typename Base::Proxy);
-  }
-};
-
-}  // namespace BareBones::SnugComposite::V2
diff --git a/pp/primitives/snug_composites.h b/pp/primitives/snug_composites.h
index 748cbf478..00d2226d0 100644
--- a/pp/primitives/snug_composites.h
+++ b/pp/primitives/snug_composites.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "bare_bones/snug_composite_v2.h"
 #include "snug_composites_filaments.h"
 
 namespace PromPP::Primitives::SnugComposites {
@@ -8,10 +7,10 @@ namespace PromPP::Primitives::SnugComposites {
 namespace Symbol {
 
 template <template <class> class Vector>
-using DecodingTable = BareBones::SnugComposite::V2::DecodingTable<Filaments::Symbol, Vector>;
+using DecodingTable = BareBones::SnugComposite::DecodingTable<Filaments::Symbol, Vector>;
 
 template <template <class> class Vector>
-using EncodingBimap = BareBones::SnugComposite::V2::EncodingBimap<Filaments::Symbol, Vector>;
+using EncodingBimap = BareBones::SnugComposite::EncodingBimap<Filaments::Symbol, Vector>;
 
 }  // namespace Symbol
 
@@ -21,13 +20,13 @@ template <template <class> class Vector>
 using DecodingTableFilament = Filaments::LabelNameSet<Symbol::DecodingTable, Vector>;
 
 template <template <class> class Vector>
-using DecodingTable = BareBones::SnugComposite::V2::DecodingTable<DecodingTableFilament, Vector>;
+using DecodingTable = BareBones::SnugComposite::DecodingTable<DecodingTableFilament, Vector>;
 
 template <template <class> class Vector>
 using EncodingBimapFilament = Filaments::LabelNameSet<Symbol::EncodingBimap, Vector>;
 
 template <template <class> class Vector>
-using EncodingBimap = BareBones::SnugComposite::V2::EncodingBimap<EncodingBimapFilament, Vector>;
+using EncodingBimap = BareBones::SnugComposite::EncodingBimap<EncodingBimapFilament, Vector>;
 
 }  // namespace LabelNameSet
 
@@ -37,13 +36,13 @@ template <template <class> class Vector>
 using DecodingTableFilament = Filaments::LabelSet<Symbol::DecodingTable, LabelNameSet::DecodingTable, Vector>;
 
 template <template <class> class Vector>
-using DecodingTable = BareBones::SnugComposite::V2::DecodingTable<DecodingTableFilament, Vector>;
+using DecodingTable = BareBones::SnugComposite::DecodingTable<DecodingTableFilament, Vector>;
 
 template <template <class> class Vector>
 using EncodingBimapFilament = Filaments::LabelSet<Symbol::EncodingBimap, LabelNameSet::EncodingBimap, Vector>;
 
 template <template <class> class Vector>
-using EncodingBimap = BareBones::SnugComposite::V2::EncodingBimap<EncodingBimapFilament, Vector>;
+using EncodingBimap = BareBones::SnugComposite::EncodingBimap<EncodingBimapFilament, Vector>;
 
 template <template <class> class Vector>
 using ShrinkableEncodingBimap = BareBones::SnugComposite::ShrinkableEncodingBimap<EncodingBimapFilament, Vector>;
diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index 62939a623..7c236ea62 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -6,171 +6,13 @@
 #include "bare_bones/iterator.h"
 #include "bare_bones/memory.h"
 #include "bare_bones/snug_composite.h"
-#include "bare_bones/snug_composite_v2.h"
 #include "bare_bones/stream_v_byte.h"
 #include "hash.h"
 
 namespace PromPP::Primitives::SnugComposites::Filaments {
 
 template <template <class> class Vector>
-class Symbol {
-  uint32_t pos_;
-  uint32_t length_;
-
-  static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
-
- public:
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  class data_type : public Vector<char> {
-    class Checkpoint {
-      uint32_t size_;
-
-      using SerializationMode = BareBones::SnugComposite::SerializationMode;
-
-     public:
-      explicit Checkpoint(uint32_t size) noexcept : size_(size) {}
-
-      [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const { return size_; }
-
-      template <BareBones::OutputStream S>
-      void save(S& out, data_type const& data, Checkpoint const* from = nullptr) const {
-        // write version
-        out.put(1);
-
-        // write mode
-        SerializationMode mode = (from != nullptr) ? SerializationMode::DELTA : SerializationMode::SNAPSHOT;
-        out.put(static_cast<char>(mode));
-
-        // write pos of first seq in the portion, if we are writing delta
-        uint32_t first_to_save = 0;
-        if (from != nullptr) {
-          first_to_save = from->size_;
-          out.write(reinterpret_cast<const char*>(&first_to_save), sizeof(first_to_save));
-        }
-
-        // write  size
-        uint32_t size_to_save = size_ - first_to_save;
-        out.write(reinterpret_cast<char*>(&size_to_save), sizeof(size_to_save));
-
-        // write data
-        if (size_to_save > 0) {
-          out.write(&data[first_to_save], size_to_save);
-        }
-      }
-
-      PROMPP_ALWAYS_INLINE uint32_t save_size(data_type const&, Checkpoint const* from = nullptr) const {
-        uint32_t res = 0;
-
-        // version
-        ++res;
-
-        // mode
-        ++res;
-
-        // pos of first seq in the portion, if we are writing delta
-        uint32_t first_to_save = 0;
-        if (from != nullptr) {
-          first_to_save = from->size_;
-          res += sizeof(uint32_t);  // first index
-        }
-
-        // size
-        const uint32_t size_to_save = size_ - first_to_save;
-        res += sizeof(uint32_t);
-
-        // data
-        res += size_to_save;
-
-        return res;
-      }
-    };
-
-   public:
-    using checkpoint_type = Checkpoint;
-
-    data_type() noexcept = default;
-    data_type(const data_type&) = delete;
-    template <class AnotherDataType>
-      requires kIsReadOnly
-    explicit data_type(const AnotherDataType& other) : Vector<char>(other) {}
-    data_type(data_type&&) noexcept = delete;
-    data_type& operator=(const data_type&) = delete;
-    data_type& operator=(data_type&&) noexcept = delete;
-
-    PROMPP_ALWAYS_INLINE auto checkpoint() const { return Checkpoint(this->size()); }
-    PROMPP_ALWAYS_INLINE void rollback(const checkpoint_type& s) noexcept {
-      assert(s.size() <= this->size());
-      this->resize(s.size());
-    }
-
-    template <class InputStream>
-    void load(InputStream& in) {
-      // read version
-      const uint8_t version = in.get();
-      if (version != 1) {
-        throw BareBones::Exception(0x67c010edbd64e272,
-                                   "Invalid stream data version (%d) for loading into data vector (Symbol::data_type), only version 1 is supported", version);
-      }
-
-      // read mode
-      const auto mode = static_cast<BareBones::SnugComposite::SerializationMode>(in.get());
-
-      // read pos of first symbol in the portion, if we are reading wal
-      uint32_t first_to_load_i = 0;
-      if (mode == BareBones::SnugComposite::SerializationMode::DELTA) {
-        in.read(reinterpret_cast<char*>(&first_to_load_i), sizeof(first_to_load_i));
-      }
-
-      if (first_to_load_i != this->size()) {
-        if (mode == BareBones::SnugComposite::SerializationMode::SNAPSHOT) {
-          throw BareBones::Exception(0x4c0ca0586da6da3f, "Attempt to load snapshot into non-empty data vector");
-        } else if (first_to_load_i < this->size()) {
-          throw BareBones::Exception(0x55cb9b02c23f7bbc, "Attempt to load segment over existing data");
-        } else {
-          throw BareBones::Exception(0x55cb9b02c23f7bbc, "Attempt to load incomplete data from segment, data vector length (%u) is less than segment size (%d)",
-                                     this->size(), first_to_load_i);
-        }
-      }
-
-      // read size
-      uint32_t size_to_load;
-      in.read(reinterpret_cast<char*>(&size_to_load), sizeof(size_to_load));
-
-      // read data
-      this->resize(this->size() + size_to_load);
-      in.read(this->begin() + first_to_load_i, size_to_load);
-    }
-
-    [[nodiscard]] PROMPP_ALWAYS_INLINE size_t remainder_size() const noexcept {
-      constexpr size_t max_ui32 = std::numeric_limits<uint32_t>::max();
-      assert(this->size() <= max_ui32);
-      return max_ui32 - this->size();
-    }
-
-    template <class DataType>
-    PROMPP_ALWAYS_INLINE void reserve(const DataType& other) {
-      Vector<char>::reserve(other.size());
-    }
-  };
-
-  using composite_type = std::string_view;
-
-  PROMPP_ALWAYS_INLINE Symbol() noexcept = default;
-
-  PROMPP_ALWAYS_INLINE Symbol(data_type& data, std::string_view str) noexcept : pos_(data.size()), length_(str.length()) {
-    data.push_back(str.begin(), str.end());
-  }
-
-  PROMPP_ALWAYS_INLINE composite_type composite(const data_type& data) const noexcept { return std::string_view(data.data() + pos_, length_); }
-
-  PROMPP_ALWAYS_INLINE void validate(const data_type& data) const {
-    if (pos_ + length_ > data.size()) {
-      throw BareBones::Exception(0x75555f55ebe357a3, "Symbol validation error: length is out of data vector range");
-    }
-  }
-
-  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t length() const noexcept { return length_; }
-
+struct Symbol {
   struct storage_type {
     static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
 
@@ -396,10 +238,6 @@ template <template <class> class Vector>
 struct BareBones::IsTriviallyReallocatable<BareBones::SnugComposite::DecodingTable<PromPP::Primitives::SnugComposites::Filaments::Symbol, Vector>>
     : std::true_type {};
 
-template <template <class> class Vector>
-struct BareBones::IsTriviallyReallocatable<BareBones::SnugComposite::V2::DecodingTable<PromPP::Primitives::SnugComposites::Filaments::Symbol, Vector>>
-    : std::true_type {};
-
 namespace PromPP::Primitives::SnugComposites::Filaments {
 
 template <class Iterator>
@@ -427,257 +265,7 @@ concept use_find_or_emplace_with_cache =
     !std::same_as<Cache, NoCache> && has_id_or_name_id<Iterator> && has_find_or_emplace_with_cache<Table, Item, typename std::remove_cvref_t<Cache>::ItemList>;
 
 template <template <template <class> class> class SymbolsTableType, template <class> class Vector>
-class LabelNameSet {
-  uint32_t pos_;
-  uint32_t size_;
-
-  static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
-
- public:
-  using symbols_table_type = SymbolsTableType<Vector>;
-  using symbols_ids_sequences_type = Vector<uint32_t>;
-
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  struct data_type {
-   private:
-    class Checkpoint {
-      using SerializationMode = BareBones::SnugComposite::SerializationMode;
-
-      uint32_t size_;
-      typename symbols_table_type::checkpoint_type symbols_table_checkpoint_;
-
-     public:
-      PROMPP_ALWAYS_INLINE explicit Checkpoint(data_type const& data) noexcept
-          : size_(data.symbols_ids_sequences.size()), symbols_table_checkpoint_(data.symbols_table.checkpoint()) {}
-
-      [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return size_; }
-
-      PROMPP_ALWAYS_INLINE typename symbols_table_type::checkpoint_type symbols_table() const noexcept { return symbols_table_checkpoint_; }
-
-      template <BareBones::OutputStream S>
-      PROMPP_ALWAYS_INLINE void save(S& out, data_type const& data, Checkpoint const* from = nullptr) const {
-        // write version
-        out.put(1);
-
-        // write mode
-        SerializationMode mode = (from != nullptr) ? SerializationMode::DELTA : SerializationMode::SNAPSHOT;
-        out.put(static_cast<char>(mode));
-
-        // write pos of first seq in the portion, if we are writing delta
-        uint32_t first_to_save = 0;
-        if (from != nullptr) {
-          first_to_save = from->size_;
-          out.write(reinterpret_cast<const char*>(&first_to_save), sizeof(first_to_save));
-        }
-
-        // write  size
-        uint32_t size_to_save = size_ - first_to_save;
-        out.write(reinterpret_cast<char*>(&size_to_save), sizeof(size_to_save));
-
-        // write data
-        out.write(reinterpret_cast<const char*>(&data.symbols_ids_sequences[first_to_save]), sizeof(data.symbols_ids_sequences[first_to_save]) * size_to_save);
-
-        // write symbols table
-        if (from != nullptr) {
-          symbols_table_checkpoint_.save(out, &from->symbols_table_checkpoint_);
-        } else {
-          symbols_table_checkpoint_.save(out);
-        }
-      }
-
-      PROMPP_ALWAYS_INLINE uint32_t save_size([[maybe_unused]] data_type const& data, Checkpoint const* from = nullptr) const {
-        uint32_t res = 0;
-
-        // version
-        ++res;
-
-        // mode
-        ++res;
-
-        // pos of first seq in the portion, if we are writing delta
-        uint32_t first_to_save = 0;
-        if (from != nullptr) {
-          first_to_save = from->size_;
-          res += sizeof(uint32_t);
-        }
-
-        // size
-        const uint32_t size_to_save = size_ - first_to_save;
-        res += sizeof(uint32_t);
-
-        // data
-        res += sizeof(data.symbols_ids_sequences[first_to_save]) * size_to_save;
-
-        // symbols table
-        if (from != nullptr) {
-          res += symbols_table_checkpoint_.save_size(&from->symbols_table_checkpoint_);
-        } else {
-          res += symbols_table_checkpoint_.save_size();
-        }
-
-        return res;
-      }
-    };
-
-   public:
-    symbols_table_type symbols_table;
-    symbols_ids_sequences_type symbols_ids_sequences;
-    data_type() noexcept = default;
-    data_type(const data_type&) = delete;
-    template <class AnotherDataType>
-      requires kIsReadOnly
-    explicit data_type(const AnotherDataType& other) : symbols_table(other.symbols_table), symbols_ids_sequences(other.symbols_ids_sequences) {}
-    data_type(data_type&&) noexcept = delete;
-    data_type& operator=(const data_type&) = delete;
-    data_type& operator=(data_type&&) noexcept = delete;
-
-    using checkpoint_type = Checkpoint;
-
-    PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return Checkpoint(*this); }
-
-    PROMPP_ALWAYS_INLINE void rollback(const checkpoint_type& s) noexcept {
-      assert(s.size() <= symbols_ids_sequences.size());
-      symbols_ids_sequences.resize(s.size());
-      symbols_table.rollback(s.symbols_table());
-    }
-
-    template <class InputStream>
-    void load(InputStream& in) {
-      // read version
-      const uint8_t version = in.get();
-      if (version != 1) {
-        throw BareBones::Exception(0xe7b943f626c40350,
-                                   "Invalid stream data version (%d) for loading into LabelSetNames::data_type vector, only version 1 is supported", version);
-      }
-
-      // read mode
-      const auto mode = static_cast<BareBones::SnugComposite::SerializationMode>(in.get());
-
-      // read pos of first seq in the portion, if we are reading wal
-      uint32_t first_to_load_i = 0;
-      if (mode == BareBones::SnugComposite::SerializationMode::DELTA) {
-        in.read(reinterpret_cast<char*>(&first_to_load_i), sizeof(first_to_load_i));
-      }
-      if (first_to_load_i != symbols_ids_sequences.size()) {
-        if (mode == BareBones::SnugComposite::SerializationMode::SNAPSHOT) {
-          throw BareBones::Exception(0x484607065485b4ab, "Attempt to load snapshot into non-empty LabelSetNames data vector");
-        } else if (first_to_load_i < symbols_ids_sequences.size()) {
-          throw BareBones::Exception(0xc042fdcb4b149d95, "Attempt to load segment over existing LabelSetNames data");
-        } else {
-          throw BareBones::Exception(0x79995816e0a9690b,
-                                     "Attempt to load incomplete data from segment, LabelSetNames data vector length (%u) is less than segment size (%d)",
-                                     symbols_ids_sequences.size(), first_to_load_i);
-        }
-      }
-
-      // read size
-      uint32_t size_to_load;
-      in.read(reinterpret_cast<char*>(&size_to_load), sizeof(size_to_load));
-
-      // read data
-      auto original_size = symbols_ids_sequences.size();
-      auto sg1 = std::experimental::scope_fail([&]() { symbols_ids_sequences.resize(original_size); });
-      symbols_ids_sequences.resize(original_size + size_to_load);
-      in.read(reinterpret_cast<char*>(&symbols_ids_sequences[first_to_load_i]), sizeof(symbols_ids_sequences[first_to_load_i]) * size_to_load);
-
-      // read symbols table
-      symbols_table.load(in);
-    }
-
-    [[nodiscard]] PROMPP_ALWAYS_INLINE size_t remainder_size() const noexcept {
-      constexpr size_t max_ui32 = std::numeric_limits<uint32_t>::max();
-      assert(this->symbols_ids_sequences.size() <= max_ui32);
-
-      size_t remainder_for_symbols = max_ui32 - this->symbols_ids_sequences.size();
-
-      return std::min(this->symbols_table.remainder_size(), remainder_for_symbols);
-    }
-
-    [[nodiscard]] PROMPP_ALWAYS_INLINE size_t allocated_memory() const noexcept {
-      return symbols_table.allocated_memory() + BareBones::mem::allocated_memory(symbols_ids_sequences);
-    }
-
-    template <class DataType>
-    PROMPP_ALWAYS_INLINE void reserve(const DataType& other) noexcept {
-      symbols_table.reserve(other.symbols_table);
-      symbols_ids_sequences.reserve(other.symbols_ids_sequences.size());
-    }
-  };
-
-  PROMPP_ALWAYS_INLINE LabelNameSet() noexcept = default;
-  template <class OtherLabelNameSet, class Cache = NoCache>
-  // TODO requires is_label_name_set
-  PROMPP_ALWAYS_INLINE LabelNameSet(data_type& data, const OtherLabelNameSet& lns, Cache&& cache = {}) noexcept : pos_(data.symbols_ids_sequences.size()) {
-    if constexpr (BareBones::concepts::has_size<OtherLabelNameSet>) {
-      size_ = lns.size();
-    } else {
-      size_ = 0;
-    }
-
-    if constexpr (BareBones::concepts::has_size<OtherLabelNameSet>) {
-      data.symbols_ids_sequences.reserve(data.symbols_ids_sequences.size() + size_);
-    }
-
-    for (auto it = lns.begin(); it != lns.end(); ++it) {
-      data.symbols_ids_sequences.push_back(find_or_emplace_label_name(data, it, std::forward<Cache>(cache)));
-      if constexpr (!BareBones::concepts::has_size<OtherLabelNameSet>) {
-        ++size_;
-      }
-    }
-  }
-
-  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return size_; }
-
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  class composite_type
-      : public symbols_table_type::template Resolver<typename symbols_ids_sequences_type::const_iterator, typename symbols_ids_sequences_type::const_iterator> {
-    using Base = typename symbols_table_type::template Resolver<typename symbols_ids_sequences_type::const_iterator,
-                                                                typename symbols_ids_sequences_type::const_iterator>;
-
-   public:
-    using Base::Base;
-
-    template <class T>
-    PROMPP_ALWAYS_INLINE bool operator==(const T& b) const noexcept {
-      return std::ranges::equal(Base::begin(), Base::end(), b.begin(), b.end());
-    }
-
-    template <class T>
-    PROMPP_ALWAYS_INLINE bool operator<(const T& b) const noexcept {
-      return std::ranges::lexicographical_compare(Base::begin(), Base::end(), b.begin(), b.end());
-    }
-
-    PROMPP_ALWAYS_INLINE friend size_t hash_value(const composite_type& lns) noexcept { return hash::hash_of_string_list(lns); }
-  };
-
-  PROMPP_ALWAYS_INLINE composite_type composite(const data_type& data) const noexcept {
-    auto begin = data.symbols_ids_sequences.begin() + pos_;
-    return composite_type(&data.symbols_table, begin, begin + size_);
-  }
-
-  PROMPP_ALWAYS_INLINE void validate(const data_type& data) const {
-    if (pos_ + size_ > data.symbols_ids_sequences.size()) {
-      throw BareBones::Exception(0x45e8bdc1455fd8e4, "LabelSetNames data validation error: expected LabelSetNames length is out of data vector range");
-    }
-
-    for (auto i = data.symbols_ids_sequences.begin() + pos_; i != data.symbols_ids_sequences.begin() + pos_ + size_; ++i) {
-      if (*i >= data.symbols_table.size()) {
-        throw BareBones::Exception(0x218410dde097cc6b, "LabelSetNames data validation error: expected LabelSetNames length is out of data symbols table range");
-      }
-    }
-  }
-
- private:
-  template <class LabelNameIterator, class Cache>
-  PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_label_name(data_type& data, const LabelNameIterator& label_name, Cache&& cache) {
-    if constexpr (use_find_or_emplace_with_cache<Cache, LabelNameIterator, decltype(data.symbols_table), decltype(*label_name)>) {
-      data.symbols_table.find_or_emplace_with_cache(*label_name, label_name.id(), cache.names);
-    }
-
-    return data.symbols_table.find_or_emplace(*label_name);
-  }
-
- public:
+struct LabelNameSet {
   struct storage_type {
     static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
 
@@ -1036,565 +624,7 @@ class LabelNameSet {
 template <template <template <class> class> class SymbolsTableType,
           template <template <class> class> class LabelNameSetsTableType,
           template <class> class Vector>
-class LabelSet {
-  uint32_t lns_id_;
-  uint32_t pos_;
-
-  static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
-
- public:
-  using symbols_tables_type = std::conditional_t<kIsReadOnly, BareBones::Vector<SymbolsTableType<Vector>>, Vector<std::unique_ptr<SymbolsTableType<Vector>>>>;
-  using symbols_ids_sequences_type = Vector<uint8_t>;
-
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  struct data_type {
-   private:
-    class Checkpoint {
-      using SerializationMode = BareBones::SnugComposite::SerializationMode;
-      using symbols_checkpoints_type = Vector<typename SymbolsTableType<Vector>::checkpoint_type>;
-
-      const data_type* data_;
-      uint32_t next_item_index_;
-      uint32_t size_;
-      typename LabelNameSetsTableType<Vector>::checkpoint_type label_name_sets_table_checkpoint_;
-      symbols_checkpoints_type symbols_tables_checkpoints_;
-
-     public:
-      explicit PROMPP_ALWAYS_INLINE Checkpoint(const data_type& data) noexcept
-          : data_(&data),
-            next_item_index_(data.next_item_index_),
-            size_(data.symbols_ids_sequences.size()),
-            label_name_sets_table_checkpoint_(data.label_name_sets_table.checkpoint()) {
-        symbols_tables_checkpoints_.reserve_and_write(data.symbols_tables.size(), [&data](auto memory, uint32_t size) {
-          for (auto& symbol_table : data.symbols_tables) {
-            std::construct_at(memory++, symbol_table->checkpoint());
-          }
-          return size;
-        });
-      }
-
-      [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return size_; }
-
-      PROMPP_ALWAYS_INLINE typename LabelNameSetsTableType<Vector>::checkpoint_type const label_name_sets() const noexcept {
-        return label_name_sets_table_checkpoint_;
-      }
-
-      PROMPP_ALWAYS_INLINE Vector<typename SymbolsTableType<Vector>::checkpoint_type> symbols() const noexcept { return symbols_tables_checkpoints_; }
-
-      template <BareBones::OutputStream S>
-      PROMPP_ALWAYS_INLINE void save(S& out, data_type const& data, Checkpoint const* from = nullptr) const {
-        // write version
-        out.put(1);
-
-        // write mode
-        SerializationMode mode = (from != nullptr) ? SerializationMode::DELTA : SerializationMode::SNAPSHOT;
-        out.put(static_cast<char>(mode));
-
-        // write pos of first seq in the portion, if we are writing delta
-        uint32_t first_to_save = 0;
-        if (from != nullptr) {
-          first_to_save = from->next_item_index_;
-          out.write(reinterpret_cast<const char*>(&first_to_save), sizeof(first_to_save));
-        }
-        const uint32_t first_item_index_in_ids_sequence = data_->next_item_index() - data_->symbols_ids_sequences.size();
-        assert(first_to_save >= first_item_index_in_ids_sequence);
-
-        // write  size
-        uint32_t size_to_save = next_item_index_ - first_to_save;
-        out.write(reinterpret_cast<char*>(&size_to_save), sizeof(size_to_save));
-
-        // write data
-        out.write(reinterpret_cast<const char*>(&data.symbols_ids_sequences[first_to_save - first_item_index_in_ids_sequence]),
-                  sizeof(data.symbols_ids_sequences[0]) * size_to_save);
-
-        // write label name sets table
-        if (from != nullptr) {
-          label_name_sets_table_checkpoint_.save(out, &from->label_name_sets_table_checkpoint_);
-        } else {
-          label_name_sets_table_checkpoint_.save(out);
-        }
-
-        // count tables, we have to write
-        uint32_t number_of_symbols_tables_to_save = symbols_tables_checkpoints_.size();
-        if (from != nullptr) {
-          for (uint32_t i = 0; i < from->symbols_tables_checkpoints_.size(); ++i) {
-            auto from_checkpoint = from->symbols_tables_checkpoints_[i];
-            auto to_checkpoint = symbols_tables_checkpoints_[i];
-            if ((to_checkpoint - from_checkpoint).empty()) {
-              --number_of_symbols_tables_to_save;
-            }
-          }
-        }
-
-        // write number of symbols tables
-        out.write(reinterpret_cast<char*>(&number_of_symbols_tables_to_save), sizeof(number_of_symbols_tables_to_save));
-        // write symbols tables
-        if (from != nullptr) {
-          for (uint32_t i = 0; i < symbols_tables_checkpoints_.size(); ++i) {
-            auto to_checkpoint = symbols_tables_checkpoints_[i];
-            if (i >= from->symbols_tables_checkpoints_.size()) {
-              // write id
-              out.write(reinterpret_cast<char*>(&i), sizeof(i));
-              // write symbols table
-              to_checkpoint.save(out);
-              continue;
-            }
-            auto from_checkpoint = from->symbols_tables_checkpoints_[i];
-            if ((to_checkpoint - from_checkpoint).empty()) {
-              continue;
-            }
-            // write id
-            out.write(reinterpret_cast<char*>(&i), sizeof(i));
-            // write symbols table
-            to_checkpoint.save(out, &from_checkpoint);
-          }
-        } else {
-          for (uint32_t i = 0; i < symbols_tables_checkpoints_.size(); ++i) {
-            // write symbols table
-            symbols_tables_checkpoints_[i].save(out);
-          }
-        }
-      }
-
-      PROMPP_ALWAYS_INLINE uint32_t save_size([[maybe_unused]] data_type const& data, Checkpoint const* from = nullptr) const {
-        uint32_t res = 0;
-
-        // version
-        ++res;
-
-        // mode
-        ++res;
-
-        // pos of first seq in the portion, if we are writing wal
-        uint32_t first_to_save = 0;
-        if (from != nullptr) {
-          first_to_save = from->next_item_index_;
-          res += sizeof(uint32_t);
-        }
-
-        // size
-        const uint32_t size_to_save = next_item_index_ - first_to_save;
-        res += sizeof(uint32_t);
-
-        // data
-        res += sizeof(data.symbols_ids_sequences[0]) * size_to_save;
-
-        // label name sets table
-        if (from != nullptr) {
-          res += label_name_sets_table_checkpoint_.save_size(&from->label_name_sets_table_checkpoint_);
-        } else {
-          res += label_name_sets_table_checkpoint_.save_size();
-        }
-
-        // number of symbols tables
-        res += sizeof(uint32_t);
-
-        // symbols tables
-        if (from != nullptr) {
-          for (uint32_t i = 0; i < symbols_tables_checkpoints_.size(); ++i) {
-            const typename SymbolsTableType<Vector>::checkpoint_type* from_checkpoint = nullptr;
-            if (i < from->symbols_tables_checkpoints_.size()) {
-              from_checkpoint = &from->symbols_tables_checkpoints_[i];
-            }
-            auto to_checkpoint = symbols_tables_checkpoints_[i];
-            if (from_checkpoint != nullptr) {
-              if ((to_checkpoint - *from_checkpoint).empty()) {
-                continue;
-              }
-            }
-            // write id
-            res += sizeof(i);
-            // write symbols table
-            res += to_checkpoint.save_size(from_checkpoint);
-          }
-        } else {
-          for (uint32_t i = 0; i < symbols_tables_checkpoints_.size(); ++i) {
-            // write symbols table
-            res += symbols_tables_checkpoints_[i].save_size();
-          }
-        }
-
-        return res;
-      }
-    };
-
-   public:
-    using SymbolIdsCodec = BareBones::StreamVByte::Codec1234;
-
-    symbols_tables_type symbols_tables;  // lns -> symbols
-    symbols_ids_sequences_type symbols_ids_sequences;
-    LabelNameSetsTableType<Vector> label_name_sets_table;  // lns -> lable name set -> symbols
-    uint32_t next_item_index_{};
-    uint32_t shrinked_size_{};
-    data_type() noexcept = default;
-    data_type(const data_type&) = delete;
-
-    template <class AnotherDataType>
-      requires kIsReadOnly
-    explicit data_type(const AnotherDataType& other)
-        : symbols_ids_sequences(other.symbols_ids_sequences),
-          label_name_sets_table(other.label_name_sets_table),
-          next_item_index_(other.next_item_index_),
-          shrinked_size_(other.shrinked_size_) {
-      symbols_tables.reserve_and_write(other.symbols_tables.size(), [&other](auto memory, uint32_t size) {
-        for (auto& symbol_table : other.symbols_tables) {
-          std::construct_at(memory++, *symbol_table);
-        }
-        return size;
-      });
-    }
-
-    data_type(data_type&&) noexcept = delete;
-    data_type& operator=(const data_type&) = delete;
-    data_type& operator=(data_type&&) noexcept = delete;
-
-    using checkpoint_type = Checkpoint;
-
-    PROMPP_ALWAYS_INLINE void shrink_to(uint32_t size) {
-      assert(size <= symbols_ids_sequences.size());
-
-      shrinked_size_ += symbols_ids_sequences.size() - size;
-      symbols_ids_sequences.resize(size);
-      symbols_ids_sequences.shrink_to_fit();
-    }
-
-    PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return Checkpoint(*this); }
-
-    PROMPP_ALWAYS_INLINE void rollback(const checkpoint_type& s) noexcept {
-      assert(s.size() <= symbols_ids_sequences.size());
-      symbols_ids_sequences.resize(s.size());
-
-      label_name_sets_table.rollback(s.label_name_sets());
-
-      auto symbols_tables_checkpoints = s.symbols();
-      assert(symbols_tables_checkpoints.size() <= symbols_tables.size());
-      for (uint32_t i = 0; i != symbols_tables_checkpoints.size(); ++i) {
-        symbols_tables[i]->rollback(symbols_tables_checkpoints[i]);
-      }
-      symbols_tables.resize(symbols_tables_checkpoints.size());
-    }
-
-    template <class DataType>
-    void reserve(const DataType& other) {
-      symbols_ids_sequences.reserve(other.symbols_ids_sequences.size());
-      symbols_tables.reserve(other.symbols_tables.size());
-      label_name_sets_table.reserve(other.label_name_sets_table);
-    }
-
-    template <class InputStream>
-    void load(InputStream& in) {
-      // read version
-      const uint8_t version = in.get();
-      if (version != 1) {
-        throw BareBones::Exception(0x7524f0b0ab963554, "Invalid stream data version (%d) for loading LabelSets into data vector, only version 1 is supported",
-                                   version);
-      }
-
-      // read mode
-      const auto mode = static_cast<BareBones::SnugComposite::SerializationMode>(in.get());
-
-      // read pos of first seq in the portion, if we are reading wal
-      uint32_t first_to_load_i = 0;
-      if (mode == BareBones::SnugComposite::SerializationMode::DELTA) {
-        in.read(reinterpret_cast<char*>(&first_to_load_i), sizeof(first_to_load_i));
-      }
-      if (first_to_load_i != next_item_index_) {
-        if (mode == BareBones::SnugComposite::SerializationMode::SNAPSHOT) {
-          throw BareBones::Exception(0xefdd57cef4b89243, "Attempt to load snapshot into non-empty LabelSets data vector");
-        } else if (first_to_load_i < symbols_ids_sequences.size()) {
-          throw BareBones::Exception(0xfead3117c5a549bd, "Attempt to load segment over existing LabelSets data");
-        } else {
-          throw BareBones::Exception(0xbb996a8ffbcbb53b,
-                                     "Attempt to load incomplete data from segment, LabelSets data vector length (%u) is less than segment size (%d)",
-                                     symbols_ids_sequences.size(), first_to_load_i);
-        }
-      }
-
-      // read size
-      uint32_t size_to_load;
-      in.read(reinterpret_cast<char*>(&size_to_load), sizeof(size_to_load));
-
-      // read data
-      auto sg1 = std::experimental::scope_fail([original_size = symbols_ids_sequences.size(), this] { symbols_ids_sequences.resize(original_size); });
-
-      symbols_ids_sequences.reserve_and_write(size_to_load + sizeof(SymbolIdsCodec::value_type), [&in, size_to_load](uint8_t* buffer, uint32_t) {
-        in.read(reinterpret_cast<char*>(buffer), size_to_load * sizeof(symbols_ids_sequences[first_to_load_i]));
-        return size_to_load;
-      });
-      next_item_index_ += size_to_load;
-
-      // read label name sets table
-      auto label_name_sets_table_checkpoint = label_name_sets_table.checkpoint();
-      auto sg2 = std::experimental::scope_fail([&]() { label_name_sets_table.rollback(label_name_sets_table_checkpoint); });
-      label_name_sets_table.load(in);
-
-      // read number of tables
-      uint32_t number_of_symbols_tables_to_load;
-      in.read(reinterpret_cast<char*>(&number_of_symbols_tables_to_load), sizeof(number_of_symbols_tables_to_load));
-
-      // read tables
-      auto original_symbols_tables_size = symbols_tables.size();
-      BareBones::Vector<std::pair<uint32_t, typename SymbolsTableType<Vector>::checkpoint_type>> symbols_tables_checkpoints;
-      auto sg3 = std::experimental::scope_fail([&]() {
-        for (const auto& [id, checkpoint] : symbols_tables_checkpoints) {
-          symbols_tables[id]->rollback(checkpoint);
-        }
-        symbols_tables.resize(original_symbols_tables_size);
-      });
-      for (uint32_t i = 0; i < number_of_symbols_tables_to_load; ++i) {
-        // read id
-        uint32_t id;
-
-        if (mode == BareBones::SnugComposite::SerializationMode::DELTA) {
-          in.read(reinterpret_cast<char*>(&id), sizeof(id));
-        } else {
-          id = i;
-        }
-
-        // resize, if needed
-        if (id >= symbols_tables.size()) [[unlikely]] {
-          if (id > symbols_tables.size()) [[unlikely]] {
-            throw BareBones::Exception(0x13fe3e1aae45bb34, "Symbol id sequence is incorrect: id (%u), size: (%u)", id, symbols_tables.size());
-          }
-
-          const auto number_of_tables_stil_left_to_load = number_of_symbols_tables_to_load - i;
-          uint64_t size_will_be_at_least = static_cast<uint64_t>(symbols_tables.size()) + number_of_tables_stil_left_to_load;
-          if (size_will_be_at_least >= std::numeric_limits<uint32_t>::max()) [[unlikely]] {
-            throw BareBones::Exception(0x98d95ce3b05ec2b5, "Max symbol id (%lu) is greater than UINT32_MAX", size_will_be_at_least);
-          }
-
-          symbols_tables.reserve(size_will_be_at_least);
-          for (uint32_t j = 0; j < number_of_tables_stil_left_to_load; ++j) {
-            symbols_tables.emplace_back(std::make_unique<SymbolsTableType<Vector>>());
-          }
-
-          // just to be 100% sure
-          assert(id < symbols_tables.size());
-        }
-
-        // read symbols table
-        if (mode == BareBones::SnugComposite::SerializationMode::DELTA && id < original_symbols_tables_size)
-          symbols_tables_checkpoints.emplace_back(id, symbols_tables[id]->checkpoint());
-        symbols_tables[id]->load(in);
-      }
-
-      // just to be 100% sure
-      assert(label_name_sets_table.data().symbols_table.size() == symbols_tables.size());
-    }
-
-    // it drains before the maximum available symbols count would be exceeded.
-    [[nodiscard]] PROMPP_ALWAYS_INLINE size_t remainder_size() const noexcept {
-      constexpr size_t max_ui32 = std::numeric_limits<uint32_t>::max();
-
-      assert(this->symbols_ids_sequences.size() <= max_ui32);
-
-      size_t remainder_for_label_sets_table = this->label_name_sets_table.remainder_size();
-      size_t remainder_for_symbols_ids_sequences = max_ui32 - this->symbols_ids_sequences.size();
-      size_t remainder_for_symbol_table = std::numeric_limits<uint32_t>::max();
-      for (const auto& table : this->symbols_tables) {
-        if (const size_t n = table->remainder_size(); n < remainder_for_symbol_table) {
-          remainder_for_symbol_table = n;
-        }
-      }
-      return std::min({remainder_for_label_sets_table, remainder_for_symbols_ids_sequences, remainder_for_symbol_table});
-    }
-
-    [[nodiscard]] PROMPP_ALWAYS_INLINE size_t allocated_memory() const noexcept {
-      return symbols_tables.allocated_memory() + BareBones::mem::allocated_memory(symbols_ids_sequences) +
-             BareBones::mem::allocated_memory(label_name_sets_table);
-    }
-
-    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return next_item_index_; }
-  };
-
-  PROMPP_ALWAYS_INLINE LabelSet() noexcept = default;
-
-  // FIXME inline of this function causes 30ns lost in indexing performance
-  template <class T, class Cache = NoCache>
-  // TODO requires is_label_set
-  LabelSet(data_type& data, const T& label_set, Cache&& cache = {}) noexcept
-      : lns_id_(find_or_emplace_label_names_set(data, label_set, std::forward<Cache>(cache))), pos_(data.symbols_ids_sequences.size() + data.shrinked_size_) {
-    // resize, if there are new symbols (in lns table)
-    data.symbols_tables.reserve(data.label_name_sets_table.data().symbols_table.size());
-    for (auto i = data.symbols_tables.size(); i < data.label_name_sets_table.data().symbols_table.size(); ++i) {
-      data.symbols_tables.emplace_back(std::make_unique<SymbolsTableType<Vector>>());
-    }
-
-    auto lns = data.label_name_sets_table[lns_id_];
-    auto lns_i = lns.begin();
-    auto size_before = data.symbols_ids_sequences.size();
-    auto i = BareBones::StreamVByte::back_inserter<typename data_type::SymbolIdsCodec>(data.symbols_ids_sequences, lns.size());
-    for (auto it = label_set.begin(); it != label_set.end(); ++it) {
-      *i++ = find_or_emplace_symbol(data, lns_i.id(), it, std::forward<Cache>(cache));
-      ++lns_i;
-    }
-
-    data.next_item_index_ += data.symbols_ids_sequences.size() - size_before;
-  }
-
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  class composite_type {
-    using label_name_set_type = typename LabelNameSetsTableType<Vector>::value_type;
-    using values_iterator_type =
-        BareBones::StreamVByte::DecodeIterator<typename data_type::SymbolIdsCodec, typename symbols_ids_sequences_type::const_iterator>;
-    using values_iterator_sentinel_type = BareBones::StreamVByte::DecodeIteratorSentinel;
-
-    label_name_set_type label_name_set_;
-    const data_type* data_;
-    values_iterator_type values_begin_;
-    [[no_unique_address]] values_iterator_sentinel_type values_end_;
-    uint32_t id_;
-
-   public:
-    PROMPP_ALWAYS_INLINE explicit composite_type(const data_type* data = nullptr,
-                                                 label_name_set_type label_name_set = label_name_set_type(),
-                                                 values_iterator_type values_begin = values_iterator_type(),
-                                                 values_iterator_sentinel_type values_end = values_iterator_sentinel_type(),
-                                                 uint32_t id = 0) noexcept
-        : label_name_set_(label_name_set), data_(data), values_begin_(values_begin), values_end_(values_end), id_(id) {}
-
-    using value_type = std::pair<typename label_name_set_type::value_type, typename Symbol<Vector>::composite_type>;
-
-    PROMPP_ALWAYS_INLINE const label_name_set_type& names() const noexcept { return label_name_set_; }
-
-    PROMPP_ALWAYS_INLINE auto size() const noexcept { return label_name_set_.size(); }
-    PROMPP_ALWAYS_INLINE auto id() const noexcept { return id_; }
-
-    template <class LabelNameSetIteratorType, class ValuesIteratorType>
-    class Iterator {
-      LabelNameSetIteratorType lnsi_;
-      ValuesIteratorType vi_;
-      const data_type* data_;
-
-      friend class composite_type;
-
-     public:
-      using iterator_category = std::forward_iterator_tag;
-      using value_type = composite_type::value_type;
-      using difference_type = std::ptrdiff_t;
-
-      PROMPP_ALWAYS_INLINE explicit Iterator(const data_type* data = 0,
-                                             LabelNameSetIteratorType lnsi = LabelNameSetIteratorType(),
-                                             ValuesIteratorType vi = ValuesIteratorType()) noexcept
-          : lnsi_(lnsi), vi_(vi), data_(data) {}
-
-      PROMPP_ALWAYS_INLINE Iterator& operator++() noexcept {
-        ++lnsi_;
-        ++vi_;
-        return *this;
-      }
-
-      PROMPP_ALWAYS_INLINE Iterator operator++(int) noexcept {
-        Iterator retval = *this;
-        ++(*this);
-        return retval;
-      }
-
-      template <class OtherIteratorType>
-      PROMPP_ALWAYS_INLINE bool operator==(const OtherIteratorType& other) const noexcept {
-        return lnsi_ == other.lnsi_ && vi_ == other.vi_;
-      }
-
-      PROMPP_ALWAYS_INLINE value_type operator*() const noexcept {
-        if constexpr (BareBones::concepts::is_dereferenceable<decltype(data_->symbols_tables[lnsi_.id()])>) {
-          const auto& smbl_tbl = *data_->symbols_tables[lnsi_.id()];
-          return make_pair(*lnsi_, smbl_tbl[*vi_]);
-        } else {
-          const auto& smbl_tbl = data_->symbols_tables[lnsi_.id()];
-          return make_pair(*lnsi_, smbl_tbl[*vi_]);
-        }
-      }
-
-      [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t name_id() const noexcept { return lnsi_.id(); }
-
-      [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t value_id() const noexcept { return *vi_; }
-    };
-
-    using iterator = Iterator<decltype(label_name_set_.begin()), decltype(values_begin_)>;
-    using end_iterator = Iterator<decltype(label_name_set_.end()), decltype(values_end_)>;
-
-    PROMPP_ALWAYS_INLINE auto begin() const noexcept {
-      return Iterator<decltype(label_name_set_.begin()), decltype(values_begin_)>(data_, label_name_set_.begin(), values_begin_);
-    }
-
-    PROMPP_ALWAYS_INLINE auto end() const noexcept {
-      return Iterator<decltype(label_name_set_.end()), decltype(values_end_)>(data_, label_name_set_.end(), values_end_);
-    }
-
-    template <class T>
-    PROMPP_ALWAYS_INLINE bool operator==(const T& b) const noexcept {
-      return std::ranges::equal(begin(), end(), b.begin(), b.end(), [](const auto& a, const auto& b) { return a == b; });
-    }
-
-    template <class T>
-    PROMPP_ALWAYS_INLINE bool operator<(const T& b) const noexcept {
-      return std::ranges::lexicographical_compare(begin(), end(), b.begin(), b.end(), [](const auto& a, const auto& b) { return a < b; });
-    }
-
-    PROMPP_ALWAYS_INLINE friend size_t hash_value(const composite_type& ls) noexcept { return hash::hash_of_label_set(ls); }
-  };
-
-  PROMPP_ALWAYS_INLINE composite_type composite(const data_type& data) const noexcept {
-    auto lns = data.label_name_sets_table[lns_id_];
-
-    auto [values_begin, values_end] =
-        BareBones::StreamVByte::decoder<typename data_type::SymbolIdsCodec>(data.symbols_ids_sequences.begin() + pos_ - data.shrinked_size_, lns.size());
-
-    return composite_type(&data, std::move(lns), std::move(values_begin), std::move(values_end), lns_id_);
-  }
-
-  PROMPP_ALWAYS_INLINE void validate(const data_type& data) const {
-    if (lns_id_ >= data.label_name_sets_table.size()) {
-      throw BareBones::Exception(0x48dd6c9d357d3a7e, "LabelSets data validation error: expected LabelSets length is out of label name sets table vector range");
-    }
-
-    const auto& lns = data.label_name_sets_table[lns_id_];
-
-    // check that streamvbyte keys are in range
-    auto keys_size = BareBones::StreamVByte::keys_size(lns.size());
-    if (pos_ - data.shrinked_size_ + keys_size > data.symbols_ids_sequences.size()) {
-      throw BareBones::Exception(0x22f5a82dd120e0e7, "LabelSets data validation error: expected LabelSets keys length is out of data symbols vector range");
-    }
-
-    // check that streamvbyte data is in range
-    const uint32_t data_size = BareBones::StreamVByte::decode_data_size<BareBones::StreamVByte::Codec1234>(
-        lns.size(), data.symbols_ids_sequences.begin() + pos_ - data.shrinked_size_);
-    if (pos_ - data.shrinked_size_ + keys_size + data_size > data.symbols_ids_sequences.size()) {
-      throw BareBones::Exception(0xd02e54dac8e1d328, "LabelSets data validation error: expected LabelSets values length is out of data symbols vector range");
-    }
-
-    // check that all symbols are in range
-    auto [values_begin, values_end] =
-        BareBones::StreamVByte::decoder<BareBones::StreamVByte::Codec1234>(data.symbols_ids_sequences.begin() + pos_ - data.shrinked_size_, lns.size());
-    for (auto i = lns.begin(); i != lns.end(); ++i) {
-      if (*values_begin++ >= data.symbols_tables[i.id()]->size()) {
-        throw BareBones::Exception(0x0f0c520ad6285f15,
-                                   "LabelSets data validation error: expected LabelSets symbols length is out of data symbols vector range");
-      }
-    }
-  }
-
- private:
-  template <class LabelSet, class Cache>
-  PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_label_names_set(data_type& data, LabelSet& label_set, Cache&& cache) {
-    if constexpr (use_find_or_emplace_with_cache<Cache, LabelSet, decltype(data.label_name_sets_table), decltype(label_set.names())>) {
-      return data.label_name_sets_table.find_or_emplace_with_cache(label_set.names(), label_set.id(), cache.name_sets, cache);
-    }
-
-    return data.label_name_sets_table.find_or_emplace(label_set.names());
-  }
-
-  template <class LabelIterator, class Cache>
-  PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_symbol(data_type& data, uint32_t lns_id, const LabelIterator& label, Cache&& cache) {
-    if constexpr (use_find_or_emplace_with_cache<Cache, LabelIterator, decltype(*data.symbols_tables[0]), decltype((*label).second)>) {
-      const auto name_id = label.name_id();
-      return data.symbols_tables[lns_id]->find_or_emplace_with_cache((*label).second, label.value_id(), cache.values[name_id]);
-    }
-
-    return data.symbols_tables[lns_id]->find_or_emplace((*label).second);
-  }
-
- public:
+struct LabelSet {
   struct storage_type {
     static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
 

From 8538029cc31a9164639698488f844aac6b61c0a0 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Wed, 17 Dec 2025 14:11:52 +0300
Subject: [PATCH 16/34] restore items write place to version 1

---
 pp/bare_bones/snug_composite.h            |  8 +--
 pp/primitives/snug_composites_filaments.h | 70 +++++++++++------------
 2 files changed, 38 insertions(+), 40 deletions(-)

diff --git a/pp/bare_bones/snug_composite.h b/pp/bare_bones/snug_composite.h
index 3e5ffac89..21ea6482a 100644
--- a/pp/bare_bones/snug_composite.h
+++ b/pp/bare_bones/snug_composite.h
@@ -22,7 +22,7 @@ namespace BareBones::SnugComposite {
  * Serialization mode used to annotate encoded data and how to apply it on container.
  * We use Delta to save the difference between two states of container. It doesn't matter
  * how the first state was made (from snapshot or other delta). Snapshot may be explained
- * as delta from init (zero) state.
+ * as a delta from the init (zero) state.
  */
 enum class SerializationMode : char { SNAPSHOT = 1, DELTA = 2 };
 
@@ -154,7 +154,7 @@ class GenericDecodingTable {
       out.exceptions(std::ifstream::failbit | std::ifstream::badbit);
 
       // write a version
-      out.put(2);
+      out.put(1);
 
       // write mode
       SerializationMode mode = (from != nullptr) ? SerializationMode::DELTA : SerializationMode::SNAPSHOT;
@@ -314,8 +314,8 @@ class GenericDecodingTable {
     }
 
     // check version
-    if (version != 2) {
-      throw BareBones::Exception(0x343b7bcc6814f2d5, "Invalid EncodingSequence version %d got from input stream, only version 2 is supported", version);
+    if (version != 1) {
+      throw BareBones::Exception(0x343b7bcc6814f2d5, "Invalid EncodingSequence version %d got from input stream, only version 1 is supported", version);
     }
 
     auto original_exceptions = in.exceptions();
diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index 7c236ea62..c2cec0cfa 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -30,6 +30,9 @@ struct Symbol {
 
       template <BareBones::OutputStream S>
       void save(S& out, const storage_type& storage, uint32_t id_offset, uint32_t id_count, checkpoint_type const* from = nullptr) const {
+        // write items
+        out.write(reinterpret_cast<const char*>(&storage.items[id_offset]), sizeof(item_type) * id_count);
+
         // write a version
         out.put(1);
 
@@ -52,14 +55,14 @@ struct Symbol {
         if (size_to_save > 0) {
           out.write(&storage.data[first_to_save], size_to_save);
         }
-
-        // write items
-        out.write(reinterpret_cast<const char*>(&storage.items[id_offset]), sizeof(item_type) * id_count);
       }
 
       uint32_t save_size(const storage_type&, uint32_t id_count, checkpoint_type const* from = nullptr) const {
         uint32_t res = 0;
 
+        // items
+        res += sizeof(item_type) * id_count;
+
         // version
         ++res;
 
@@ -80,9 +83,6 @@ struct Symbol {
         // data
         res += size_to_save;
 
-        // items
-        res += sizeof(item_type) * id_count;
-
         return res;
       }
     };
@@ -185,6 +185,11 @@ struct Symbol {
 
     template <class InputStream>
     auto load(InputStream& in, uint32_t items_size) {
+      // read items
+      const auto original_size = items.size();
+      items.resize(original_size + items_size);
+      in.read(reinterpret_cast<char*>(&items[original_size]), sizeof(item_type) * items_size);
+
       // read version
       const uint8_t version = in.get();
       if (version != 1) {
@@ -220,11 +225,6 @@ struct Symbol {
       data.resize(data.size() + size_to_load);
       in.read(data.begin() + first_to_load_i, size_to_load);
 
-      // read items
-      const auto original_size = items.size();
-      items.resize(original_size + items_size);
-      in.read(reinterpret_cast<char*>(&items[original_size]), sizeof(item_type) * items_size);
-
       return std::views::iota(original_size, items.size());
     }
 
@@ -348,6 +348,9 @@ struct LabelNameSet {
 
       template <BareBones::OutputStream S>
       void save(S& out, const storage_type& storage, uint32_t id_offset, uint32_t id_count, checkpoint_type const* from = nullptr) const {
+        // write items
+        out.write(reinterpret_cast<const char*>(&storage.items[id_offset]), sizeof(item_type) * id_count);
+
         // write a version
         out.put(1);
 
@@ -376,14 +379,14 @@ struct LabelNameSet {
         } else {
           symbols_table_checkpoint.save(out);
         }
-
-        // write items
-        out.write(reinterpret_cast<const char*>(&storage.items[id_offset]), sizeof(item_type) * id_count);
       }
 
       uint32_t save_size(const storage_type& storage, uint32_t id_count, checkpoint_type const* from = nullptr) const {
         uint32_t res = 0;
 
+        // items
+        res += sizeof(item_type) * id_count;
+
         // version
         ++res;
 
@@ -411,9 +414,6 @@ struct LabelNameSet {
           res += symbols_table_checkpoint.save_size();
         }
 
-        // items
-        res += sizeof(item_type) * id_count;
-
         return res;
       }
     };
@@ -559,6 +559,11 @@ struct LabelNameSet {
 
     template <class InputStream>
     auto load(InputStream& in, uint32_t items_size) {
+      // read items
+      const auto items_original_size = items.size();
+      items.resize(items_original_size + items_size);
+      in.read(reinterpret_cast<char*>(&items[items_original_size]), sizeof(item_type) * items_size);
+
       // read version
       const uint8_t version = in.get();
       if (version != 1) {
@@ -599,11 +604,6 @@ struct LabelNameSet {
       // read symbols table
       symbols_table.load(in);
 
-      // read items
-      const auto items_original_size = items.size();
-      items.resize(items_original_size + items_size);
-      in.read(reinterpret_cast<char*>(&items[items_original_size]), sizeof(item_type) * items_size);
-
       return std::views::iota(items_original_size, items.size());
     }
 
@@ -754,6 +754,9 @@ struct LabelSet {
 
       template <BareBones::OutputStream S>
       void save(S& out, const storage_type& storage, uint32_t id_offset, uint32_t id_count, checkpoint_type const* from = nullptr) const {
+        // write items
+        out.write(reinterpret_cast<const char*>(&storage.items[id_offset]), sizeof(item_type) * id_count);
+
         // write version
         out.put(1);
 
@@ -825,14 +828,14 @@ struct LabelSet {
             symbols_tables_checkpoints_[i].save(out);
           }
         }
-
-        // write items
-        out.write(reinterpret_cast<const char*>(&storage.items[id_offset]), sizeof(item_type) * id_count);
       }
 
       uint32_t save_size(const storage_type& storage, uint32_t id_count, checkpoint_type const* from = nullptr) const {
         uint32_t res = 0;
 
+        // items
+        res += sizeof(item_type) * id_count;
+
         // version
         ++res;
 
@@ -888,9 +891,6 @@ struct LabelSet {
           }
         }
 
-        // items
-        res += sizeof(item_type) * id_count;
-
         return res;
       }
     };
@@ -1124,9 +1124,7 @@ struct LabelSet {
       const uint32_t lns_id = find_or_emplace_label_names_set(label_set, std::forward<Cache>(cache));
       const uint32_t pos = symbols_ids_sequences.size() + shrinked_size;
       // resize if there are new symbols (in lns table)
-      symbols_tables.reserve(label_name_sets_table.data_view().symbols().size());  // label_name_sets_table.view().symbols().size()
-      // label_name_sets_table.view() -> label_names_view;
-      // label_names_view.symbols() -> symbols_view;
+      symbols_tables.reserve(label_name_sets_table.data_view().symbols().size());
       for (auto i = symbols_tables.size(); i < label_name_sets_table.data_view().symbols().size(); ++i) {
         symbols_tables.emplace_back(std::make_unique<SymbolsTableType<Vector>>());
       }
@@ -1184,6 +1182,11 @@ struct LabelSet {
 
     template <class InputStream>
     auto load(InputStream& in, uint32_t items_size) {
+      // read items
+      const auto items_original_size = items.size();
+      items.resize(items_original_size + items_size);
+      in.read(reinterpret_cast<char*>(&items[items_original_size]), sizeof(item_type) * items_size);
+
       // read version
       const uint8_t version = in.get();
       if (version != 1) {
@@ -1276,11 +1279,6 @@ struct LabelSet {
         symbols_tables[id]->load(in);
       }
 
-      // read items
-      const auto items_original_size = items.size();
-      items.resize(items_original_size + items_size);
-      in.read(reinterpret_cast<char*>(&items[items_original_size]), sizeof(item_type) * items_size);
-
       return std::views::iota(items_original_size, items.size());
     }
 

From a1ef708eaacf8a38dab0acc1fb2b4ab927d71ac3 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Wed, 17 Dec 2025 14:45:15 +0300
Subject: [PATCH 17/34] snug composite test rework

---
 pp/bare_bones/snug_composite.h               |   8 +-
 pp/bare_bones/tests/snug_composite_tests.cpp | 703 ++++++++++++-------
 2 files changed, 435 insertions(+), 276 deletions(-)

diff --git a/pp/bare_bones/snug_composite.h b/pp/bare_bones/snug_composite.h
index 21ea6482a..8f5321c22 100644
--- a/pp/bare_bones/snug_composite.h
+++ b/pp/bare_bones/snug_composite.h
@@ -29,9 +29,9 @@ enum class SerializationMode : char { SNAPSHOT = 1, DELTA = 2 };
 template <class Range>
 concept ls_id_range = std::ranges::range<Range> && std::same_as<std::ranges::range_value_t<Range>, uint32_t>;
 
-template <class FilamentDataType>
-concept is_shrinkable = requires(FilamentDataType& data_type) {
-  { data_type.shrink_to(uint32_t()) };
+template <class FilamentStorageType>
+concept is_shrinkable = requires(FilamentStorageType& storage) {
+  { storage.shrink() };
 };
 
 template <class Derived>
@@ -49,7 +49,7 @@ concept has_after_items_load = ls_id_range<R> && requires(Derived derived, R&& r
 
 template <class Derived, template <template <class> class> class Filament, template <class> class Vector>
 class GenericDecodingTable {
-  static_assert(!std::is_integral_v<typename Filament<Vector>::composite_type>, "Filament::composite_type can't be an integral type");
+  static_assert(!std::is_integral_v<typename Filament<Vector>::storage_type::composite_type>, "Filament::composite_type can't be an integral type");
 
   template <class AnyDerived, template <template <class> class> class AnyFilament, template <class> class AnyVector>
   friend class GenericDecodingTable;
diff --git a/pp/bare_bones/tests/snug_composite_tests.cpp b/pp/bare_bones/tests/snug_composite_tests.cpp
index 49f8b51ff..137e6e687 100644
--- a/pp/bare_bones/tests/snug_composite_tests.cpp
+++ b/pp/bare_bones/tests/snug_composite_tests.cpp
@@ -1,4 +1,5 @@
-#include <random>
+#include <limits>
+#include <sstream>
 
 #include <gtest/gtest.h>
 
@@ -10,345 +11,494 @@ using BareBones::Vector;
 using std::string_literals::operator""s;
 
 template <template <class> class Vector>
-class TestSnugCompositesStringFilament {
-  uint32_t pos_;
-  uint32_t len_;
+struct TestStringFilament {
+  struct storage_type {
+    static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
 
- public:
-  // NOLINTNEXTLINE
-  class data_type : public Vector<char> {
-    class Checkpoint {
-      uint32_t size_;
+    using composite_type = std::string_view;
 
-      using SerializationMode = BareBones::SnugComposite::SerializationMode;
+    struct item_type {
+      uint32_t pos;
+      uint32_t length;
+    };
 
-     public:
-      explicit Checkpoint(uint32_t size) noexcept : size_(size) {}
+    struct checkpoint_type {
+      uint32_t data_size;
+      uint32_t items_size;
 
-      uint32_t size() const { return size_; }
+      using SerializationMode = BareBones::SnugComposite::SerializationMode;
 
       template <BareBones::OutputStream S>
-      void save(S& out, const data_type& data, Checkpoint const* from = nullptr) const {
+      void save(S& out, const storage_type& storage, uint32_t id_offset, uint32_t id_count, checkpoint_type const* from = nullptr) const {
+        // write items
+        out.write(reinterpret_cast<const char*>(&storage.items[id_offset]), sizeof(item_type) * id_count);
+
+        // write a version
+        out.put(1);
+
+        // write mode
         SerializationMode mode = (from != nullptr) ? SerializationMode::DELTA : SerializationMode::SNAPSHOT;
         out.put(static_cast<char>(mode));
+
+        // write pos of the first seq in the portion if we are writing delta
         uint32_t first_to_save = 0;
         if (from != nullptr) {
-          first_to_save = from->size_;
+          first_to_save = from->data_size;
           out.write(reinterpret_cast<const char*>(&first_to_save), sizeof(first_to_save));
         }
-        uint32_t size_to_save = size_ - first_to_save;
+
+        // write size
+        uint32_t size_to_save = data_size - first_to_save;
         out.write(reinterpret_cast<char*>(&size_to_save), sizeof(size_to_save));
-        out.write(data.begin() + first_to_save, size_to_save);
+
+        // write data
+        if (size_to_save > 0) {
+          out.write(&storage.data[first_to_save], size_to_save);
+        }
       }
 
-      uint32_t save_size(const data_type&, Checkpoint const* from = nullptr) const {
-        uint32_t res = 1;  // mode
+      uint32_t save_size(const storage_type&, uint32_t id_count, checkpoint_type const* from = nullptr) const {
+        uint32_t res = 0;
+
+        // items
+        res += sizeof(item_type) * id_count;
+
+        // version
+        ++res;
+
+        // mode
+        ++res;
+
+        // pos of first seq in the portion, if we are writing delta
         uint32_t first_to_save = 0;
         if (from != nullptr) {
-          first_to_save = from->size_;
+          first_to_save = from->data_size;
           res += sizeof(uint32_t);  // first index
         }
-        uint32_t size_to_save = size_ - first_to_save;
-        res += sizeof(uint32_t);  // length
-        res += size_to_save;      // data
+
+        // size
+        const uint32_t size_to_save = data_size - first_to_save;
+        res += sizeof(uint32_t);
+
+        // data
+        res += size_to_save;
+
         return res;
       }
     };
 
-    uint32_t shift_{};
+    struct view {
+      const storage_type* storage_ptr;
+
+      class iterator_type {
+       public:
+        using iterator_category = std::input_iterator_tag;
+        using value_type = composite_type;
+        using difference_type = std::ptrdiff_t;
+
+        iterator_type() = default;
+        explicit iterator_type(const storage_type& storage, uint32_t id) noexcept : id_{id}, storage_ptr_(&storage) {}
+
+        iterator_type& operator++() noexcept {
+          ++id_;
+          return *this;
+        }
+
+        iterator_type operator++(int) noexcept {
+          iterator_type retval = *this;
+          ++(*this);
+          return retval;
+        }
+
+        bool operator==(const iterator_type& other) const noexcept { return id_ == other.id_ && storage_ptr_ == other.storage_ptr_; }
+
+        value_type operator*() const noexcept { return storage_ptr_->composite(id_); }
+
+        [[nodiscard]] uint32_t id() const noexcept { return id_; }
+
+       private:
+        uint32_t id_{0};
+        const storage_type* storage_ptr_;
+      };
+
+      [[nodiscard]] auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
+      [[nodiscard]] auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
+
+      [[nodiscard]] size_t size() const noexcept { return storage_ptr->count(); }
+      [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
+    };
+
+    using view_type = view;
+
+    storage_type() noexcept = default;
+    template <class AnotherStorageType>
+      requires kIsReadOnly
+    explicit storage_type(const AnotherStorageType& other) : data{other.data}, items{other.items} {}
+
+    Vector<char> data;
+    Vector<item_type> items;
+
+    [[nodiscard]] uint32_t count() const noexcept { return items.size(); }
+
+    [[nodiscard]] size_t remainder_size() const noexcept {
+      constexpr size_t max_ui32 = std::numeric_limits<uint32_t>::max();
+      assert(data.size() <= max_ui32);
+      return max_ui32 - data.size();
+    }
+
+    template <class AnotherStorageType>
+    void reserve(const AnotherStorageType& other) noexcept {
+      items.reserve(other.items.size());
+      data.reserve(other.data.size());
+    }
+
+    [[nodiscard]] composite_type composite(uint32_t id) const noexcept {
+      const auto item = items[id];
+      return std::string_view(data.data() + item.pos, item.length);
+    }
+
+    void validate(uint32_t id) const {
+      if (const auto item = items[id]; item.pos + item.length > data.size()) {
+        throw BareBones::Exception(0x75555f55ebe357a3, "TestStringFilament validation error: length is out of data vector range");
+      }
+    }
+
+    [[nodiscard]] uint32_t allocated_memory() const noexcept { return BareBones::mem::allocated_memory(data) + BareBones::mem::allocated_memory(items); }
+
+    [[nodiscard]] uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
 
-   public:
-    using checkpoint_type = Checkpoint;
-    inline __attribute__((always_inline)) auto checkpoint() const noexcept { return Checkpoint(this->size()); }
-    inline __attribute__((always_inline)) void rollback(const checkpoint_type& s) noexcept {
-      assert(s.size() <= this->size());
-      this->resize(s.size());
+    [[nodiscard]] uint32_t emplace_back(composite_type str) noexcept {
+      const uint32_t id = items.size();
+      items.emplace_back(data.size(), str.length());
+      data.push_back(str.begin(), str.end());
+      return id;
     }
 
-    template <BareBones::InputStream S>
-    void load(S& in) {
-      BareBones::SnugComposite::SerializationMode mode = static_cast<BareBones::SnugComposite::SerializationMode>(in.get());
-      // read pos of first symbol in the portion, if we are reading wal
+    [[nodiscard]] checkpoint_type checkpoint() const noexcept { return {data.size(), items.size()}; }
+    void rollback(const checkpoint_type& checkpoint) noexcept {
+      assert(checkpoint.data_size <= data.size());
+      assert(checkpoint.items_size <= items.size());
+      data.resize(checkpoint.data_size);
+      items.resize(checkpoint.items_size);
+    }
+
+    template <class InputStream>
+    auto load(InputStream& in, uint32_t items_size) {
+      // read items
+      const auto original_size = items.size();
+      items.resize(original_size + items_size);
+      in.read(reinterpret_cast<char*>(&items[original_size]), sizeof(item_type) * items_size);
+
+      // read version
+      const uint8_t version = in.get();
+      if (version != 1) {
+        throw BareBones::Exception(
+            0x67c010edbd64e272, "Invalid stream data version (%d) for loading into data vector (TestStringFilament::storage_type), only version 1 is supported",
+            version);
+      }
+
+      // read mode
+      const auto mode = static_cast<BareBones::SnugComposite::SerializationMode>(in.get());
+
+      // read pos of the first symbol in the portion if we are reading wal
       uint32_t first_to_load_i = 0;
       if (mode == BareBones::SnugComposite::SerializationMode::DELTA) {
         in.read(reinterpret_cast<char*>(&first_to_load_i), sizeof(first_to_load_i));
       }
 
-      if (first_to_load_i - shift_ != this->size()) {
-        throw std::runtime_error("something went wrong");
+      if (first_to_load_i != data.size()) {
+        if (mode == BareBones::SnugComposite::SerializationMode::SNAPSHOT) {
+          throw BareBones::Exception(0x4c0ca0586da6da3f, "Attempt to load snapshot into non-empty data vector");
+        } else if (first_to_load_i < data.size()) {
+          throw BareBones::Exception(0x55cb9b02c23f7bbd, "Attempt to load segment over existing data");
+        } else {
+          throw BareBones::Exception(0x55cb9b02c23f7bbd, "Attempt to load incomplete data from segment, data vector length (%u) is less than segment size (%d)",
+                                     data.size(), first_to_load_i);
+        }
       }
 
+      // read size
       uint32_t size_to_load;
       in.read(reinterpret_cast<char*>(&size_to_load), sizeof(size_to_load));
 
       // read data
-      this->resize(this->size() + size_to_load);
-      in.read(this->begin() + first_to_load_i - shift_, size_to_load);
-    }
+      data.resize(data.size() + size_to_load);
+      in.read(data.begin() + first_to_load_i, size_to_load);
 
-    void shrink_to(uint32_t size) {
-      shift_ += BareBones::Vector<char>::size();
-      this->resize(size);
+      return std::views::iota(original_size, items.size());
     }
 
-    [[nodiscard]] uint32_t shift() const noexcept { return shift_; }
-  };
+    [[nodiscard]] view_type view() const noexcept { return {.storage_ptr = this}; }
 
-  using composite_type = std::string_view;
+    void shrink() {
+      data.clear();
+      items.clear();
+    }
+  };
 
-  TestSnugCompositesStringFilament() = default;
-  TestSnugCompositesStringFilament(data_type& data, std::string x) : pos_(data.size()), len_(x.length()) { data.push_back(x.data(), x.data() + x.length()); }
+  using data_type = storage_type;
+};
 
-  const std::string_view composite(const data_type& data) const { return std::string_view(data.begin() + pos_ - data.shift(), len_); }
+using EncodingBimap = BareBones::SnugComposite::EncodingBimap<TestStringFilament, Vector>;
+using ShrinkableEncodingBimap = BareBones::SnugComposite::ShrinkableEncodingBimap<TestStringFilament, Vector>;
 
-  void validate(const data_type& data) const {
-    if (pos_ + len_ > data.size() + data.shift())
-      throw std::runtime_error("something went wrong");
-  }
+class EncodingBimapFixture : public testing::Test {
+ protected:
+  EncodingBimap table_;
 };
 
-typedef testing::Types<BareBones::SnugComposite::EncodingBimap<TestSnugCompositesStringFilament, Vector>> SnugCompositesBimapTypes;
+TEST_F(EncodingBimapFixture, Empty) {
+  // Arrange
 
-template <class T>
-struct SnugComposite : public testing::Test {
-  using StringFilament = TestSnugCompositesStringFilament<Vector>;
+  // Act
 
-  static void fill_table_with_random_values(auto& table) {
-    table.find_or_emplace("10"s);
-    table.find_or_emplace("11"s);
-    table.find_or_emplace("13"s);
-  }
-};
+  // Assert
+  EXPECT_EQ(0U, table_.size());
+}
+
+TEST_F(EncodingBimapFixture, FindOrEmplaceNewValue) {
+  // Arrange
+  const auto value = "test"s;
+
+  // Act
+  const auto expected_id = table_.next_item_index();
+  const auto id = table_.find_or_emplace(value);
+
+  // Assert
+  EXPECT_EQ(expected_id, id);
+  EXPECT_EQ(1U, table_.size());
+}
+
+TEST_F(EncodingBimapFixture, FindOrEmplaceExistingValue) {
+  // Arrange
+  const auto value = "test"s;
+  const auto id1 = table_.find_or_emplace(value);
+
+  // Act
+  const auto id2 = table_.find_or_emplace(value);
+
+  // Assert
+  EXPECT_EQ(id1, id2);
+  EXPECT_EQ(1U, table_.size());
+}
+
+TEST_F(EncodingBimapFixture, FindOrEmplaceDifferentValues) {
+  // Arrange
+  const std::string value1 = "test1"s;
+  const std::string value2 = "test2"s;
+
+  // Act
+  const auto id1 = table_.find_or_emplace(value1);
+  const auto id2 = table_.find_or_emplace(value2);
+
+  // Assert
+  EXPECT_NE(id1, id2);
+  EXPECT_EQ(2U, table_.size());
+}
+
+TEST_F(EncodingBimapFixture, FindOrEmplaceWithHash) {
+  // Arrange
+  const std::string value = "test"s;
+  const auto hash_val = BareBones::XXHash::hash(value);
 
-TYPED_TEST_SUITE(SnugComposite, SnugCompositesBimapTypes);
+  // Act
+  const auto id1 = table_.find_or_emplace(value, hash_val);
+  const auto id2 = table_.find_or_emplace(value, hash_val);
+
+  // Assert
+  EXPECT_EQ(id1, id2);
+  EXPECT_EQ(1U, table_.size());
+}
 
-TYPED_TEST(SnugComposite, should_return_same_id_for_same_data) {
+TEST_F(EncodingBimapFixture, FindExistingValue) {
   // Arrange
-  TypeParam outcomes;
-  this->fill_table_with_random_values(outcomes);
-  static auto v = "12"s;
+  table_.find_or_emplace("test1"s);
+  table_.find_or_emplace("test2"s);
+  const std::string value = "test"s;
+  const auto id = table_.find_or_emplace(value);
 
   // Act
-  auto id = outcomes.find_or_emplace(v);
+  const auto found_id = table_.find(value);
 
   // Assert
-  ASSERT_EQ(id, outcomes.find_or_emplace(v));
-  ASSERT_EQ(outcomes.find_or_emplace(v), outcomes.find(v));
+  ASSERT_TRUE(found_id.has_value());
+  EXPECT_EQ(id, found_id.value());
 }
 
-TYPED_TEST(SnugComposite, should_return_same_id_for_same_data_with_hash) {
-  TypeParam outcomes;
-  this->fill_table_with_random_values(outcomes);
+TEST_F(EncodingBimapFixture, FindNonExistingValue) {
+  // Arrange
+  table_.find_or_emplace("test1"s);
+  table_.find_or_emplace("test2"s);
+  const std::string value = "test"s;
+
+  // Act
+  const auto found_id = table_.find(value);
+
+  // Assert
+  EXPECT_FALSE(found_id.has_value());
+}
 
-  std::string v = "12";
-  auto hash_val = BareBones::XXHash::hash(v);
-  auto id = outcomes.find_or_emplace(v, hash_val);
+TEST_F(EncodingBimapFixture, FindWithHash) {
+  // Arrange
+  const std::string value = "test"s;
+  const auto hash_val = BareBones::XXHash::hash(value);
+  const auto id = table_.find_or_emplace(value, hash_val);
 
-  EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
-  EXPECT_EQ(id, outcomes.find_or_emplace(v));
+  // Act
+  const auto found_id = table_.find(value, hash_val);
 
-  EXPECT_EQ(outcomes.find_or_emplace(v, hash_val), outcomes.find(v, hash_val));
-  EXPECT_EQ(outcomes.find_or_emplace(v, hash_val), outcomes.find(v));
+  // Assert
+  ASSERT_TRUE(found_id.has_value());
+  EXPECT_EQ(id, found_id.value());
+}
 
-  v = "21";
-  hash_val = BareBones::XXHash::hash(v);
-  id = outcomes.find_or_emplace(v);
+TEST_F(EncodingBimapFixture, OperatorBracket) {
+  // Arrange
+  table_.find_or_emplace("test1"s);
+  table_.find_or_emplace("test2"s);
+  const std::string value = "test"s;
+  const auto id = table_.find_or_emplace(value);
 
-  EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
-  EXPECT_EQ(id, outcomes.find_or_emplace(v));
+  // Act
+  const auto composite = table_[id];
 
-  EXPECT_EQ(outcomes.find_or_emplace(v), outcomes.find(v));
-  EXPECT_EQ(outcomes.find_or_emplace(v), outcomes.find(v, hash_val));
+  // Assert
+  EXPECT_EQ(value, composite);
 }
 
-TYPED_TEST(SnugComposite, should_return_different_id_for_different_data) {
+TEST_F(EncodingBimapFixture, Checkpoint) {
   // Arrange
-  TypeParam outcomes;
-  this->fill_table_with_random_values(outcomes);
-  static auto v1 = "12"s;
-  static auto v2 = "21"s;
+  table_.find_or_emplace("test1"s);
+  table_.find_or_emplace("test2"s);
 
   // Act
-  auto id1 = outcomes.find_or_emplace(v1);
-  auto id2 = outcomes.find_or_emplace(v2);
+  const auto checkpoint = table_.checkpoint();
 
   // Assert
-  ASSERT_NE(id1, id2);
+  EXPECT_EQ(2U, checkpoint.size());
 }
 
-TYPED_TEST(SnugComposite, should_return_different_id_for_different_data_with_hash) {
-  TypeParam outcomes;
-  this->fill_table_with_random_values(outcomes);
+TEST_F(EncodingBimapFixture, Rollback) {
+  // Arrange
+  table_.find_or_emplace("test1"s);
+  const auto checkpoint = table_.checkpoint();
+  table_.find_or_emplace("test2"s);
+
+  // Act
+  table_.rollback(checkpoint);
 
-  std::string v = "12";
-  size_t hash_val = std::hash<std::string>()(v);
-  auto id = outcomes.find_or_emplace(v, hash_val);
+  // Assert
+  EXPECT_EQ(1U, table_.size());
+  EXPECT_TRUE(table_.find("test1"s).has_value());
+  EXPECT_FALSE(table_.find("test2"s).has_value());
+}
 
-  v = "21";
-  hash_val = std::hash<std::string>()(v);
+TEST_F(EncodingBimapFixture, RollbackToEmpty) {
+  // Arrange
+  const auto checkpoint = table_.checkpoint();
+  table_.find_or_emplace("test1"s);
 
-  EXPECT_NE(id, outcomes.find_or_emplace(v, hash_val));
-  EXPECT_NE(id, outcomes.find_or_emplace(v));
+  // Act
+  table_.rollback(checkpoint);
+
+  // Assert
+  EXPECT_EQ(0U, table_.size());
+}
 
-  v = "13";
-  id = outcomes.find_or_emplace(v);
+TEST_F(EncodingBimapFixture, SerializeDeserializeSnapshot) {
+  // Arrange
+  table_.find_or_emplace("test1"s);
+  table_.find_or_emplace("test2"s);
+  std::stringstream stream;
 
-  v = "31";
-  hash_val = std::hash<std::string>()(v);
+  // Act
+  stream << table_;
+  EncodingBimap table2;
+  stream >> table2;
 
-  EXPECT_NE(id, outcomes.find_or_emplace(v, hash_val));
-  EXPECT_NE(id, outcomes.find_or_emplace(v));
+  // Assert
+  EXPECT_EQ(table_.size(), table2.size());
+  EXPECT_EQ("test1"s, table2[0]);
+  EXPECT_EQ("test2"s, table2[1]);
 }
 
-TYPED_TEST(SnugComposite, should_assign_new_ids_after_rollback) {
-  TypeParam outcomes;
-
-  auto checkpoint0 = outcomes.checkpoint();
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test1")), 0);
-  ASSERT_EQ(std::ranges::distance(outcomes.begin(), outcomes.end()), 1);
-
-  auto checkpoint1 = outcomes.checkpoint();
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test2")), 1);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test3")), 2);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test1")), 0);
-  ASSERT_EQ(std::ranges::distance(outcomes.begin(), outcomes.end()), 3);
-
-  outcomes.rollback(checkpoint1);
-  ASSERT_EQ(std::ranges::distance(outcomes.begin(), outcomes.end()), 1);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test_new")), 1);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test2")), 2);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test3")), 3);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test1")), 0);
-  ASSERT_EQ(std::ranges::distance(outcomes.begin(), outcomes.end()), 4);
-
-  auto checkpoint2 = outcomes.checkpoint();
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test4")), 4);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test_new")), 1);
-  ASSERT_EQ(std::ranges::distance(outcomes.begin(), outcomes.end()), 5);
-
-  outcomes.rollback(checkpoint2);
-  ASSERT_EQ(std::ranges::distance(outcomes.begin(), outcomes.end()), 4);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test_more_new")), 4);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test4")), 5);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test_new")), 1);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test2")), 2);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test3")), 3);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test1")), 0);
-
-  outcomes.rollback(checkpoint1);
-  ASSERT_EQ(std::ranges::distance(outcomes.begin(), outcomes.end()), 1);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test_more_new")), 1);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test1")), 0);
-
-  outcomes.rollback(checkpoint0);
-  ASSERT_EQ(std::ranges::distance(outcomes.begin(), outcomes.end()), 0);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test_new")), 0);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test1")), 1);
+TEST_F(EncodingBimapFixture, SerializeDeserializeDelta) {
+  // Arrange
+  table_.find_or_emplace("test1"s);
+  const auto checkpoint1 = table_.checkpoint();
+  table_.find_or_emplace("test2"s);
+  const auto checkpoint2 = table_.checkpoint();
+  std::stringstream stream;
+
+  // Act
+  stream << (checkpoint2 - checkpoint1);
+  EncodingBimap table2;
+  table2.find_or_emplace("test1"s);
+  stream >> table2;
+
+  // Assert
+  EXPECT_EQ(2U, table2.size());
+  EXPECT_EQ("test1"s, table2[0]);
+  EXPECT_EQ("test2"s, table2[1]);
 }
 
-TYPED_TEST(SnugComposite, should_write_the_same_wal_after_rollback) {
-  TypeParam outcomes;
-
-  // checkpoint names template is checkpoint<base><variant>
-  // for example, if we have state X and checkpoint to this state checkpoint21
-  // then we change state with adding some data, then we get new checkpoint211
-  // Now if we rollback state to checkpoint2_1 and add some data we get new checkpoint212
-  //
-  // wal names template is wal<last checkpoint index>
-  // for example, wal between checkpoint212 and checkpoint21 we get wal212
-
-  auto checkpoint = outcomes.checkpoint();
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test1")), 0);
-
-  auto checkpoint1 = outcomes.checkpoint();
-  std::ostringstream wal1;
-  wal1 << (checkpoint1 - checkpoint) << std::flush;
-
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test2")), 1);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test3")), 2);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test1")), 0);
-
-  auto checkpoint11 = outcomes.checkpoint();
-  std::ostringstream wal11;
-  wal11 << (checkpoint11 - checkpoint1) << std::flush;
-
-  outcomes.rollback(checkpoint1);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test2")), 1);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test3")), 2);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test1")), 0);
-
-  auto checkpoint12 = outcomes.checkpoint();
-  std::ostringstream wal12;
-  wal12 << (checkpoint12 - checkpoint1) << std::flush;
-  ASSERT_EQ(wal11.str(), wal12.str());
-
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test4")), 3);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test5")), 4);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test1")), 0);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test3")), 2);
-
-  auto checkpoint121 = outcomes.checkpoint();
-  std::ostringstream wal121;
-  wal121 << (checkpoint121 - checkpoint12) << std::flush;
-
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test6")), 5);
-
-  outcomes.rollback(checkpoint12);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test4")), 3);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test5")), 4);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test1")), 0);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test3")), 2);
-
-  auto checkpoint122 = outcomes.checkpoint();
-  std::ostringstream wal122;
-  wal122 << (checkpoint122 - checkpoint12) << std::flush;
-  ASSERT_EQ(wal121.str(), wal122.str());
-
-  outcomes.rollback(checkpoint);
-  ASSERT_EQ(outcomes.find_or_emplace(std::string("test1")), 0);
-
-  auto checkpoint2 = outcomes.checkpoint();
-  std::ostringstream wal2;
-  wal2 << (checkpoint2 - checkpoint) << std::flush;
-  ASSERT_EQ(wal1.str(), wal2.str());
+TEST_F(EncodingBimapFixture, DataView) {
+  // Arrange
+  table_.find_or_emplace("test1"s);
+  table_.find_or_emplace("test2"s);
+
+  // Act
+  const auto view = table_.data_view();
+
+  // Assert
+  EXPECT_EQ(2U, view.size());
+  EXPECT_EQ("test1"s, *view.begin());
+  EXPECT_EQ("test2"s, *std::next(view.begin()));
 }
 
 class ShrinkableEncodingBimapFixture : public testing::Test {
  protected:
-  using Table = BareBones::SnugComposite::ShrinkableEncodingBimap<TestSnugCompositesStringFilament, Vector>;
-
+  ShrinkableEncodingBimap table_;
   static constexpr auto kInvalidId = std::numeric_limits<uint32_t>::max();
-
-  Table table_;
 };
 
-TEST_F(ShrinkableEncodingBimapFixture, Emplace) {
+TEST_F(ShrinkableEncodingBimapFixture, Empty) {
+  // Arrange
+
+  // Act
+
+  // Assert
+  EXPECT_EQ(0U, table_.size());
+}
+
+TEST_F(ShrinkableEncodingBimapFixture, FindOrEmplace) {
   // Arrange
+  const std::string value = "test"s;
 
   // Act
-  const auto id1 = table_.find_or_emplace("1"s);
-  const auto id2 = table_.find_or_emplace("2"s);
+  const auto id = table_.find_or_emplace(value);
 
   // Assert
-  EXPECT_EQ(0U, id1);
-  EXPECT_EQ(1U, id2);
+  EXPECT_EQ(0U, id);
+  EXPECT_EQ(1U, table_.size());
 }
 
-TEST_F(ShrinkableEncodingBimapFixture, EmplaceExisting) {
+TEST_F(ShrinkableEncodingBimapFixture, FindOrEmplaceExisting) {
   // Arrange
+  const std::string value = "test"s;
+  const auto id1 = table_.find_or_emplace(value);
 
   // Act
-  const auto id1 = table_.find_or_emplace("1"s);
-  const auto id2 = table_.find_or_emplace("1"s);
+  const auto id2 = table_.find_or_emplace(value);
 
   // Assert
-  EXPECT_EQ(0U, id1);
-  EXPECT_EQ(0U, id2);
+  EXPECT_EQ(id1, id2);
+  EXPECT_EQ(1U, table_.size());
 }
 
 TEST_F(ShrinkableEncodingBimapFixture, Checkpoint) {
   // Arrange
-  table_.find_or_emplace("1"s);
+  table_.find_or_emplace("test"s);
 
   // Act
   const auto checkpoint = table_.checkpoint();
@@ -359,82 +509,91 @@ TEST_F(ShrinkableEncodingBimapFixture, Checkpoint) {
 
 TEST_F(ShrinkableEncodingBimapFixture, ShrinkToCheckpointSize) {
   // Arrange
-  table_.find_or_emplace("1"s);
+  table_.find_or_emplace("test1"s);
+  const auto checkpoint = table_.checkpoint();
 
   // Act
-  table_.shrink_to_checkpoint_size(table_.checkpoint());
+  table_.shrink_to_checkpoint_size(checkpoint);
 
   // Assert
   EXPECT_EQ(0U, table_.size());
 }
 
-TEST_F(ShrinkableEncodingBimapFixture, EmplaceAfterShrinkToCheckpointSize) {
+TEST_F(ShrinkableEncodingBimapFixture, EmplaceAfterShrink) {
   // Arrange
-  const auto id_before = table_.find_or_emplace("1"s);
+  const auto id_before = table_.find_or_emplace("test1"s);
+  table_.shrink_to_checkpoint_size(table_.checkpoint());
 
   // Act
-  table_.shrink_to_checkpoint_size(table_.checkpoint());
-  const auto id_after = table_.find_or_emplace("1"s);
+  const auto id_after = table_.find_or_emplace("test1"s);
 
   // Assert
   EXPECT_EQ(0U, id_before);
-  EXPECT_EQ(1U, table_.size());
   EXPECT_EQ(1U, id_after);
+  EXPECT_EQ(1U, table_.size());
 }
 
-TEST_F(ShrinkableEncodingBimapFixture, ShrinkToOutdatedCheckpoint) {
+TEST_F(ShrinkableEncodingBimapFixture, ShrinkToOutdatedCheckpointThrows) {
   // Arrange
-  table_.find_or_emplace("1"s);
+  table_.find_or_emplace("test1"s);
   const auto checkpoint = table_.checkpoint();
-
-  // Act
   table_.shrink_to_checkpoint_size(checkpoint);
-  table_.find_or_emplace("2"s);
+  table_.find_or_emplace("test2"s);
 
-  // Assert
+  // Act & Assert
   EXPECT_THROW(table_.shrink_to_checkpoint_size(checkpoint), BareBones::Exception);
 }
 
-TEST_F(ShrinkableEncodingBimapFixture, LoadCheckpointWithoutShrink) {
+TEST_F(ShrinkableEncodingBimapFixture, OperatorBracketWithShift) {
   // Arrange
-  Table table2;
-  std::stringstream stream;
-
-  table_.find_or_emplace("0"s);
-  table_.find_or_emplace("1"s);
-  stream << table_.checkpoint();
+  table_.find_or_emplace("test1"s);
+  table_.shrink_to_checkpoint_size(table_.checkpoint());
+  const auto id = table_.find_or_emplace("test2"s);
 
   // Act
-  stream >> table2;
+  const auto composite = table_[id];
 
   // Assert
-  EXPECT_EQ(1U, table2.find("1"s).value_or(kInvalidId));
+  EXPECT_EQ("test2"s, composite);
 }
 
-TEST_F(ShrinkableEncodingBimapFixture, LoadCheckpointAfterShrink) {
+TEST_F(ShrinkableEncodingBimapFixture, SerializeDeserializeSnapshot) {
   // Arrange
-  Table table2;
+  table_.find_or_emplace("test1"s);
+  table_.find_or_emplace("test2"s);
   std::stringstream stream;
 
   // Act
-  table_.find_or_emplace("01"s);
-  table_.find_or_emplace("11"s);
-  table_.find_or_emplace("21"s);
-  table_.find_or_emplace("31"s);
-  const auto checkpoint = table_.checkpoint();
-  stream << checkpoint;
+  stream << table_.checkpoint();
+  ShrinkableEncodingBimap table2;
   stream >> table2;
+
+  // Assert
+  EXPECT_EQ(table_.size(), table2.size());
+  EXPECT_EQ("test1"s, table2[0]);
+  EXPECT_EQ("test2"s, table2[1]);
+}
+
+TEST_F(ShrinkableEncodingBimapFixture, SerializeDeserializeDeltaAfterShrink) {
+  // Arrange
+  table_.find_or_emplace("test1"s);
+  table_.find_or_emplace("test2"s);
+  const auto checkpoint = table_.checkpoint();
+  std::stringstream snapshot_stream;
+  snapshot_stream << checkpoint;
+  ShrinkableEncodingBimap table2;
+  snapshot_stream >> table2;
   table2.shrink_to_checkpoint_size(table2.checkpoint());
+  table_.find_or_emplace("test3"s);
+  std::stringstream delta_stream;
 
-  table_.find_or_emplace("41"s);
-  table_.find_or_emplace("51"s);
-  stream << table_.checkpoint() - checkpoint;
-  stream >> table2;
+  // Act
+  delta_stream << (table_.checkpoint() - checkpoint);
+  delta_stream >> table2;
 
   // Assert
-  EXPECT_EQ(kInvalidId, table2.find("01"s).value_or(kInvalidId));
-  EXPECT_EQ(4U, table2.find("41"s).value_or(kInvalidId));
-  EXPECT_EQ(5U, table2.find("51"s).value_or(kInvalidId));
+  EXPECT_EQ(3U, table2.size());
+  EXPECT_EQ("test3"s, table2[2]);
 }
 
 }  // namespace

From 09e795c98d9c84b58625bd1c8ec4ba56c48b0364 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Wed, 17 Dec 2025 15:25:54 +0300
Subject: [PATCH 18/34] test environment fixes

---
 pp/bare_bones/tests/snug_composite_tests.cpp | 55 ++++++++++++++------
 1 file changed, 38 insertions(+), 17 deletions(-)

diff --git a/pp/bare_bones/tests/snug_composite_tests.cpp b/pp/bare_bones/tests/snug_composite_tests.cpp
index 137e6e687..59b71ffc5 100644
--- a/pp/bare_bones/tests/snug_composite_tests.cpp
+++ b/pp/bare_bones/tests/snug_composite_tests.cpp
@@ -133,10 +133,11 @@ struct TestStringFilament {
     storage_type() noexcept = default;
     template <class AnotherStorageType>
       requires kIsReadOnly
-    explicit storage_type(const AnotherStorageType& other) : data{other.data}, items{other.items} {}
+    explicit storage_type(const AnotherStorageType& other) : data{other.data}, items{other.items}, shrinked_size{other.shrinked_size} {}
 
     Vector<char> data;
     Vector<item_type> items;
+    uint32_t shrinked_size{};
 
     [[nodiscard]] uint32_t count() const noexcept { return items.size(); }
 
@@ -158,7 +159,8 @@ struct TestStringFilament {
     }
 
     void validate(uint32_t id) const {
-      if (const auto item = items[id]; item.pos + item.length > data.size()) {
+      const auto item = items[id];
+      if (item.pos + item.length > data.size()) {
         throw BareBones::Exception(0x75555f55ebe357a3, "TestStringFilament validation error: length is out of data vector range");
       }
     }
@@ -169,7 +171,8 @@ struct TestStringFilament {
 
     [[nodiscard]] uint32_t emplace_back(composite_type str) noexcept {
       const uint32_t id = items.size();
-      items.emplace_back(data.size(), str.length());
+      const uint32_t pos = data.size();
+      items.emplace_back(pos, str.length());
       data.push_back(str.begin(), str.end());
       return id;
     }
@@ -206,14 +209,15 @@ struct TestStringFilament {
         in.read(reinterpret_cast<char*>(&first_to_load_i), sizeof(first_to_load_i));
       }
 
-      if (first_to_load_i != data.size()) {
+      const uint32_t next_item_index = data.size();
+      if (first_to_load_i != next_item_index) {
         if (mode == BareBones::SnugComposite::SerializationMode::SNAPSHOT) {
           throw BareBones::Exception(0x4c0ca0586da6da3f, "Attempt to load snapshot into non-empty data vector");
-        } else if (first_to_load_i < data.size()) {
+        } else if (first_to_load_i < next_item_index) {
           throw BareBones::Exception(0x55cb9b02c23f7bbd, "Attempt to load segment over existing data");
         } else {
           throw BareBones::Exception(0x55cb9b02c23f7bbd, "Attempt to load incomplete data from segment, data vector length (%u) is less than segment size (%d)",
-                                     data.size(), first_to_load_i);
+                                     next_item_index, first_to_load_i);
         }
       }
 
@@ -230,8 +234,8 @@ struct TestStringFilament {
 
     [[nodiscard]] view_type view() const noexcept { return {.storage_ptr = this}; }
 
-    void shrink() {
-      data.clear();
+    void shrink() noexcept {
+      shrinked_size += items.size();
       items.clear();
     }
   };
@@ -531,16 +535,22 @@ TEST_F(ShrinkableEncodingBimapFixture, EmplaceAfterShrink) {
   EXPECT_EQ(0U, id_before);
   EXPECT_EQ(1U, id_after);
   EXPECT_EQ(1U, table_.size());
+
+  EXPECT_EQ("test1"s, table_[id_after]);
 }
 
 TEST_F(ShrinkableEncodingBimapFixture, ShrinkToOutdatedCheckpointThrows) {
   // Arrange
   table_.find_or_emplace("test1"s);
+
   const auto checkpoint = table_.checkpoint();
   table_.shrink_to_checkpoint_size(checkpoint);
+
   table_.find_or_emplace("test2"s);
 
-  // Act & Assert
+  // Act
+
+  // Assert
   EXPECT_THROW(table_.shrink_to_checkpoint_size(checkpoint), BareBones::Exception);
 }
 
@@ -561,10 +571,11 @@ TEST_F(ShrinkableEncodingBimapFixture, SerializeDeserializeSnapshot) {
   // Arrange
   table_.find_or_emplace("test1"s);
   table_.find_or_emplace("test2"s);
+  const auto checkpoint = table_.checkpoint();
   std::stringstream stream;
 
   // Act
-  stream << table_.checkpoint();
+  stream << checkpoint;
   ShrinkableEncodingBimap table2;
   stream >> table2;
 
@@ -576,24 +587,34 @@ TEST_F(ShrinkableEncodingBimapFixture, SerializeDeserializeSnapshot) {
 
 TEST_F(ShrinkableEncodingBimapFixture, SerializeDeserializeDeltaAfterShrink) {
   // Arrange
+  ShrinkableEncodingBimap table2;
+  std::stringstream snapshot_stream;
+
   table_.find_or_emplace("test1"s);
   table_.find_or_emplace("test2"s);
-  const auto checkpoint = table_.checkpoint();
-  std::stringstream snapshot_stream;
-  snapshot_stream << checkpoint;
-  ShrinkableEncodingBimap table2;
+  const auto initial_checkpoint = table_.checkpoint();
+
+  snapshot_stream << initial_checkpoint;
   snapshot_stream >> table2;
   table2.shrink_to_checkpoint_size(table2.checkpoint());
+
   table_.find_or_emplace("test3"s);
-  std::stringstream delta_stream;
+  table_.find_or_emplace("test4"s);
+  const auto final_checkpoint = table_.checkpoint();
+  const auto delta = final_checkpoint - initial_checkpoint;
 
   // Act
-  delta_stream << (table_.checkpoint() - checkpoint);
+  std::stringstream delta_stream;
+  delta_stream << delta;
   delta_stream >> table2;
 
   // Assert
-  EXPECT_EQ(3U, table2.size());
+  EXPECT_EQ(2U, table2.size());
+
   EXPECT_EQ("test3"s, table2[2]);
+  EXPECT_EQ("test4"s, table2[3]);
+  EXPECT_EQ(kInvalidId, table2.find("test1"s).value_or(kInvalidId));
+  EXPECT_EQ(kInvalidId, table2.find("test2"s).value_or(kInvalidId));
 }
 
 }  // namespace

From 0c88beb24f204c9ccf5d237df69d2492b3d1e8f3 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Wed, 17 Dec 2025 15:34:59 +0300
Subject: [PATCH 19/34] more coverage

---
 pp/bare_bones/tests/snug_composite_tests.cpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/pp/bare_bones/tests/snug_composite_tests.cpp b/pp/bare_bones/tests/snug_composite_tests.cpp
index 59b71ffc5..5cd6c7dde 100644
--- a/pp/bare_bones/tests/snug_composite_tests.cpp
+++ b/pp/bare_bones/tests/snug_composite_tests.cpp
@@ -249,6 +249,8 @@ using ShrinkableEncodingBimap = BareBones::SnugComposite::ShrinkableEncodingBima
 class EncodingBimapFixture : public testing::Test {
  protected:
   EncodingBimap table_;
+
+  static constexpr auto kInvalidId = std::numeric_limits<uint32_t>::max();
 };
 
 TEST_F(EncodingBimapFixture, Empty) {
@@ -340,6 +342,7 @@ TEST_F(EncodingBimapFixture, FindNonExistingValue) {
 
   // Assert
   EXPECT_FALSE(found_id.has_value());
+  EXPECT_EQ(kInvalidId, table_.find(value).value_or(kInvalidId));
 }
 
 TEST_F(EncodingBimapFixture, FindWithHash) {
@@ -598,8 +601,8 @@ TEST_F(ShrinkableEncodingBimapFixture, SerializeDeserializeDeltaAfterShrink) {
   snapshot_stream >> table2;
   table2.shrink_to_checkpoint_size(table2.checkpoint());
 
-  table_.find_or_emplace("test3"s);
-  table_.find_or_emplace("test4"s);
+  const auto test3_id = table_.find_or_emplace("test3"s);
+  const auto test4_id = table_.find_or_emplace("test4"s);
   const auto final_checkpoint = table_.checkpoint();
   const auto delta = final_checkpoint - initial_checkpoint;
 
@@ -611,10 +614,10 @@ TEST_F(ShrinkableEncodingBimapFixture, SerializeDeserializeDeltaAfterShrink) {
   // Assert
   EXPECT_EQ(2U, table2.size());
 
-  EXPECT_EQ("test3"s, table2[2]);
-  EXPECT_EQ("test4"s, table2[3]);
   EXPECT_EQ(kInvalidId, table2.find("test1"s).value_or(kInvalidId));
   EXPECT_EQ(kInvalidId, table2.find("test2"s).value_or(kInvalidId));
+  EXPECT_EQ(test3_id, table2.find("test3"s).value_or(kInvalidId));
+  EXPECT_EQ(test4_id, table2.find("test4"s).value_or(kInvalidId));
 }
 
 }  // namespace

From d3f5c13371da7c8db6aa84c99fa3bf7c798e2284 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Wed, 17 Dec 2025 20:47:24 +0300
Subject: [PATCH 20/34] primitives tests update

---
 pp/primitives/snug_composites_filaments.h     |  14 +-
 .../tests/snug_composites_filaments_tests.cpp | 404 ----------
 pp/primitives/tests/snug_composites_tests.cpp | 754 +++++++++++-------
 3 files changed, 475 insertions(+), 697 deletions(-)
 delete mode 100644 pp/primitives/tests/snug_composites_filaments_tests.cpp

diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index c2cec0cfa..315e16e1a 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -453,8 +453,8 @@ struct LabelNameSet {
         const storage_type* storage_ptr_;
       };
 
-      auto begin() const noexcept { return iterator_type{storage_ptr, 0}; }
-      auto end() const noexcept { return iterator_type{storage_ptr, storage_ptr->items.size()}; }
+      auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
+      auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
 
       [[nodiscard]] size_t size() const noexcept { return storage_ptr->count(); }
       [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
@@ -656,7 +656,7 @@ struct LabelSet {
                                                    uint32_t id = 0) noexcept
           : label_name_set_(label_name_set), data_(data), values_begin_(values_begin), values_end_(values_end), id_(id) {}
 
-      using value_type = std::pair<typename label_name_set_type::value_type, typename Symbol<Vector>::composite_type>;
+      using value_type = std::pair<typename label_name_set_type::value_type, typename Symbol<Vector>::storage_type::composite_type>;
 
       PROMPP_ALWAYS_INLINE const label_name_set_type& names() const noexcept { return label_name_set_; }
 
@@ -969,7 +969,7 @@ struct LabelSet {
     };
 
     struct label_set_view {
-      using keys_view_type = label_name_sets_table_type::view_type::symbols_view;
+      using keys_view_type = label_name_sets_table_type::filament_type::storage_type::view_type::symbols_view_type;
       using values_view_type = label_sets_values_view;
       const storage_type* storage_ptr;
 
@@ -1005,8 +1005,8 @@ struct LabelSet {
         const storage_type* storage_ptr_;
       };
 
-      auto begin() const noexcept { return iterator_type{storage_ptr, 0}; }
-      auto end() const noexcept { return iterator_type{storage_ptr, storage_ptr->items.size()}; }
+      auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
+      auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
 
       [[nodiscard]] size_t size() const noexcept { return storage_ptr->count(); }
       [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
@@ -1282,6 +1282,8 @@ struct LabelSet {
       return std::views::iota(items_original_size, items.size());
     }
 
+    view_type view() const noexcept { return {.storage_ptr = this}; }
+
    private:
     template <class LabelSet, class Cache>
     uint32_t find_or_emplace_label_names_set(LabelSet& label_set, Cache&& cache) {
diff --git a/pp/primitives/tests/snug_composites_filaments_tests.cpp b/pp/primitives/tests/snug_composites_filaments_tests.cpp
deleted file mode 100644
index 205ed06ed..000000000
--- a/pp/primitives/tests/snug_composites_filaments_tests.cpp
+++ /dev/null
@@ -1,404 +0,0 @@
-#include <random>
-
-#include "gtest/gtest.h"
-
-#include "primitives/label_set.h"
-#include "primitives/snug_composites_filaments.h"
-
-#include "bare_bones/snug_composite_v2.h"
-
-namespace {
-
-using BareBones::Vector;
-using BareBones::SnugComposite::DecodingTable;
-using BareBones::SnugComposite::EncodingBimap;
-using PromPP::Primitives::kInvalidLabelSetID;
-using PromPP::Primitives::LabelSet;
-using PromPP::Primitives::LabelViewSet;
-
-template <template <class> class Vector>
-using SymbolFilament = EncodingBimap<PromPP::Primitives::SnugComposites::Filaments::Symbol, Vector>;
-
-template <template <class> class Vector>
-using LabelNameSetFilament = PromPP::Primitives::SnugComposites::Filaments::LabelNameSet<SymbolFilament, Vector>;
-
-template <template <class> class Vector>
-using LabelSetFilament = EncodingBimap<LabelNameSetFilament, Vector>;
-
-template <template <class> class Vector>
-using FilamentLabelSet = PromPP::Primitives::SnugComposites::Filaments::LabelSet<SymbolFilament, LabelSetFilament, Vector>;
-
-class NamesSetForTest : public std::vector<std::string> {
-  using Base = std::vector<std::string>;
-
- public:
-  using Base::Base;
-  friend size_t hash_value(const NamesSetForTest& lns) { return PromPP::Primitives::hash::hash_of_string_list(lns); }
-};
-
-class LabelSetForTest : public std::vector<std::pair<std::string, std::string>> {
-  using Base = std::vector<std::pair<std::string, std::string>>;
-
- public:
-  using Base::Base;
-
-  NamesSetForTest names() const {
-    NamesSetForTest tns;
-
-    for (const auto& [label_name, _] : *this) {
-      tns.push_back(label_name);
-    }
-
-    return tns;
-  }
-
-  friend size_t hash_value(const LabelSetForTest& tls) { return PromPP::Primitives::hash::hash_of_label_set(tls); }
-};
-
-const char SYMBOLS_DATA[89] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-+=/|.,\\?<>!@#$%^&*()\"':;";
-const int NUM_VALUES = 100;
-
-std::string generate_str(int seed) {
-  std::mt19937 gen32(seed);
-  std::string b;
-  int maxlen = 4 + (gen32() % 28);
-  b.resize(maxlen);
-  for (int i = 0; i < maxlen; i++) {
-    b[i] = SYMBOLS_DATA[gen32() % 89];
-  }
-
-  return b;
-};
-
-NamesSetForTest generate_names_set() {
-  NamesSetForTest nst;
-
-  for (int i = 0; i < NUM_VALUES; i++) {
-    nst.push_back(generate_str(i));
-  }
-
-  return nst;
-};
-
-LabelSetForTest generate_label_set() {
-  LabelSetForTest lst;
-
-  for (auto i = 0; i < NUM_VALUES; ++i) {
-    lst.push_back({generate_str(i), generate_str(i + NUM_VALUES)});
-  }
-
-  return lst;
-};
-
-struct SnugCompositesFilaments : public testing::Test {};
-
-TEST_F(SnugCompositesFilaments, Symbol) {
-  PromPP::Primitives::SnugComposites::Filaments::Symbol<Vector>::data_type data;
-
-  std::vector<std::pair<std::string, PromPP::Primitives::SnugComposites::Filaments::Symbol<Vector>>> etalons_and_outcomes;
-
-  for (int i = 0; i < NUM_VALUES; i++) {
-    const auto etalon = generate_str(i);
-    auto outcome = PromPP::Primitives::SnugComposites::Filaments::Symbol<Vector>(data, etalon);
-    EXPECT_NO_THROW(outcome.validate(data));
-
-    etalons_and_outcomes.push_back({etalon, outcome});
-  }
-
-  for (const auto& [etalon, outcome] : etalons_and_outcomes) {
-    EXPECT_EQ(outcome.composite(data), etalon);
-  }
-}
-
-TEST_F(SnugCompositesFilaments, LabelNamesSet) {
-  using FilamentLabelNameSet = PromPP::Primitives::SnugComposites::Filaments::LabelNameSet<SymbolFilament, Vector>;
-
-  FilamentLabelNameSet::data_type data;
-  const NamesSetForTest etalons = generate_names_set();
-
-  auto lns = FilamentLabelNameSet(data, etalons);
-  EXPECT_NO_THROW(lns.validate(data));
-  auto outcomes = lns.composite(data);
-
-  auto etalon = etalons.begin();
-  auto outcome = outcomes.begin();
-  while (etalon != etalons.end() && outcome != outcomes.end()) {
-    EXPECT_EQ(*outcome++, *etalon++);
-  }
-
-  EXPECT_EQ(outcome == outcomes.end(), etalon == etalons.end());
-  EXPECT_EQ(outcomes.size(), etalons.size());
-  EXPECT_EQ(hash_value(outcomes), hash_value(etalons));
-}
-
-TEST_F(SnugCompositesFilaments, LabelSet) {
-  FilamentLabelSet<Vector>::data_type data;
-  const LabelSetForTest etalons = generate_label_set();
-
-  FilamentLabelSet<Vector> ls(data, etalons);
-  EXPECT_NO_THROW(ls.validate(data));
-  auto outcomes = ls.composite(data);
-
-  auto etalon = etalons.begin();
-  auto outcome = outcomes.begin();
-  while (etalon != etalons.end() && outcome != outcomes.end()) {
-    EXPECT_EQ((*outcome).first, (*etalon).first);
-    EXPECT_EQ((*outcome).second, (*etalon).second);
-    ++etalon;
-    ++outcome;
-  }
-
-  EXPECT_EQ(outcome == outcomes.end(), etalon == etalons.end());
-  EXPECT_EQ(outcomes.size(), etalons.size());
-
-  EXPECT_EQ(hash_value(outcomes), hash_value(etalons));
-}
-
-class ShrinkableEncodingBimapLabelSetFixture : public testing::Test {
- protected:
-  BareBones::SnugComposite::ShrinkableEncodingBimap<FilamentLabelSet, Vector> encoding_table_;
-  BareBones::SnugComposite::DecodingTable<FilamentLabelSet, Vector> decoding_table_;
-  std::array<LabelSetForTest, 6> ls_;
-
-  void SetUp() override {
-    ls_[0].emplace_back("1", "1");
-    ls_[0].emplace_back("2", "2");
-
-    ls_[1].emplace_back("3", "3");
-
-    ls_[2].emplace_back("4", "4");
-    ls_[3].emplace_back("5", "5");
-    ls_[4].emplace_back("6", "6");
-    ls_[5].emplace_back("7", "7");
-  }
-
-  auto create_and_load_checkpoint(const BareBones::SnugComposite::ShrinkableEncodingBimap<FilamentLabelSet, Vector>::checkpoint_type* from) {
-    auto checkpoint = encoding_table_.checkpoint();
-    std::stringstream ss;
-    checkpoint.save(ss, from);
-    decoding_table_.load(ss);
-
-    return checkpoint;
-  }
-
-  void check_decoding_table() const {
-    ASSERT_EQ(3U, decoding_table_.size());
-    {
-      auto composite = decoding_table_.items()[0].composite(decoding_table_.data());
-      ASSERT_EQ(2U, composite.size());
-      auto it = composite.begin();
-      EXPECT_EQ((std::pair<std::string_view, std::string_view>("1", "1")), *it++);
-      EXPECT_EQ((std::pair<std::string_view, std::string_view>("2", "2")), *it);
-    }
-    {
-      auto composite = decoding_table_.items()[1].composite(decoding_table_.data());
-      ASSERT_EQ(1U, composite.size());
-      EXPECT_EQ((std::pair<std::string_view, std::string_view>("3", "3")), *composite.begin());
-    }
-    {
-      auto composite = decoding_table_.items()[2].composite(decoding_table_.data());
-      ASSERT_EQ(1U, composite.size());
-      EXPECT_EQ((std::pair<std::string_view, std::string_view>("4", "4")), *composite.begin());
-    }
-  }
-};
-
-TEST_F(ShrinkableEncodingBimapLabelSetFixture, ShrinkAndLoad) {
-  // Arrange
-
-  // Act
-  {
-    encoding_table_.find_or_emplace(ls_[0]);
-    encoding_table_.find_or_emplace(ls_[1]);
-    const auto checkpoint = create_and_load_checkpoint(nullptr);
-    encoding_table_.shrink_to_checkpoint_size(checkpoint);
-  }
-  {
-    const auto empty_checkpoint = encoding_table_.checkpoint();
-    encoding_table_.find_or_emplace(ls_[2]);
-    const auto checkpoint = create_and_load_checkpoint(&empty_checkpoint);
-    encoding_table_.shrink_to_checkpoint_size(checkpoint);
-  }
-
-  // Assert
-  check_decoding_table();
-}
-
-TEST_F(ShrinkableEncodingBimapLabelSetFixture, LoadWithoutShrink) {
-  // Arrange
-
-  // Act
-  {
-    encoding_table_.find_or_emplace(ls_[0]);
-    encoding_table_.find_or_emplace(ls_[1]);
-    create_and_load_checkpoint(nullptr);
-  }
-  {
-    const auto empty_checkpoint = encoding_table_.checkpoint();
-    encoding_table_.find_or_emplace(ls_[2]);
-    create_and_load_checkpoint(&empty_checkpoint);
-  }
-
-  // Assert
-  check_decoding_table();
-}
-
-TEST_F(ShrinkableEncodingBimapLabelSetFixture, LoadFromNonShrinkableTable) {
-  // Arrange
-  BareBones::SnugComposite::EncodingBimap<FilamentLabelSet, Vector> lss;
-  std::stringstream stream;
-
-  // Act
-  lss.find_or_emplace(LabelViewSet{{"process", "php"}});
-  lss.find_or_emplace(LabelViewSet{{"process", "nodejs"}});
-  lss.find_or_emplace(LabelViewSet{{"process", "python"}});
-  const auto checkpoint = lss.checkpoint();
-  stream << checkpoint;
-  stream >> encoding_table_;
-  encoding_table_.shrink_to_checkpoint_size(encoding_table_.checkpoint());
-
-  const auto nginx_id = lss.find_or_emplace(LabelViewSet{{"process", "nginx"}});
-  const auto apache_id = lss.find_or_emplace(LabelViewSet{{"process", "apache"}});
-  stream << lss.checkpoint() - checkpoint;
-  stream >> encoding_table_;
-
-  // Assert
-  EXPECT_EQ(kInvalidLabelSetID, encoding_table_.find(LabelViewSet{{"process", "php"}}).value_or(kInvalidLabelSetID));
-  EXPECT_EQ(nginx_id, encoding_table_.find(LabelViewSet{{"process", "nginx"}}).value_or(kInvalidLabelSetID));
-  EXPECT_EQ(apache_id, encoding_table_.find(LabelViewSet{{"process", "apache"}}).value_or(kInvalidLabelSetID));
-}
-
-TEST_F(ShrinkableEncodingBimapLabelSetFixture, EmptyCheckpointWithShrink) {
-  // Arrange
-
-  // Act
-  {
-    encoding_table_.find_or_emplace(ls_[0]);
-    encoding_table_.find_or_emplace(ls_[1]);
-    encoding_table_.find_or_emplace(ls_[2]);
-    const auto checkpoint = create_and_load_checkpoint(nullptr);
-    encoding_table_.shrink_to_checkpoint_size(checkpoint);
-  }
-  {
-    const auto empty_checkpoint = encoding_table_.checkpoint();
-    create_and_load_checkpoint(&empty_checkpoint);
-  }
-
-  // Assert
-  check_decoding_table();
-}
-
-TEST_F(ShrinkableEncodingBimapLabelSetFixture, EmptyCheckpointWithoutShrink) {
-  // Arrange
-
-  // Act
-  {
-    encoding_table_.find_or_emplace(ls_[0]);
-    encoding_table_.find_or_emplace(ls_[1]);
-    encoding_table_.find_or_emplace(ls_[2]);
-    create_and_load_checkpoint(nullptr);
-  }
-  {
-    const auto empty_checkpoint = encoding_table_.checkpoint();
-    create_and_load_checkpoint(&empty_checkpoint);
-  }
-
-  // Assert
-  check_decoding_table();
-}
-
-TEST_F(ShrinkableEncodingBimapLabelSetFixture, CheckSaveSize) {
-  // Arrange
-  encoding_table_.find_or_emplace(ls_[0]);
-  encoding_table_.find_or_emplace(ls_[1]);
-
-  auto checkpoint = encoding_table_.checkpoint();
-
-  encoding_table_.shrink_to_checkpoint_size(checkpoint);
-
-  encoding_table_.find_or_emplace(ls_[1]);
-  encoding_table_.find_or_emplace(ls_[2]);
-  encoding_table_.find_or_emplace(ls_[3]);
-  encoding_table_.find_or_emplace(ls_[4]);
-  encoding_table_.find_or_emplace(ls_[5]);
-
-  auto checkpoint2 = encoding_table_.checkpoint();
-
-  auto delta = checkpoint2 - checkpoint;
-  std::stringstream ss;
-  ss << delta;
-
-  // Act
-  const auto save_size = delta.save_size();
-
-  // Assert
-  EXPECT_EQ(ss.str().length(), save_size);
-}
-
-template <template <class> class Vector>
-using DecodingTableV2 = BareBones::SnugComposite::V2::DecodingTable<PromPP::Primitives::SnugComposites::Filaments::Symbol, Vector>;
-
-template <template <class> class Vector>
-using EncodingBimapV2 = BareBones::SnugComposite::V2::EncodingBimap<PromPP::Primitives::SnugComposites::Filaments::Symbol, Vector>;
-
-class V2Test : public testing::Test {
- protected:
-  EncodingBimapV2<Vector> encoding_table_;
-  DecodingTableV2<Vector> decoding_table_;
-};
-
-TEST_F(V2Test, Test) {
-  // Arrange
-  const std::array<std::string, 4> arr = {"aboba", "lol", "kek", "cheburek"};
-
-  // Act
-  const auto id0 = encoding_table_.find_or_emplace(arr[0]);
-  const auto id1 = encoding_table_.find_or_emplace(arr[1]);
-  const auto id2 = encoding_table_.find_or_emplace(arr[2]);
-  const auto id3 = encoding_table_.find_or_emplace(arr[3]);
-
-  // Assert
-  EXPECT_EQ(encoding_table_.size(), 4);
-
-  EXPECT_EQ(encoding_table_[id0], arr[0]);
-  EXPECT_EQ(encoding_table_[id1], arr[1]);
-  EXPECT_EQ(encoding_table_[id2], arr[2]);
-  EXPECT_EQ(encoding_table_[id3], arr[3]);
-
-  EXPECT_EQ(encoding_table_.find(arr[0]), id0);
-  EXPECT_EQ(encoding_table_.find(arr[1]), id1);
-  EXPECT_EQ(encoding_table_.find(arr[2]), id2);
-  EXPECT_EQ(encoding_table_.find(arr[3]), id3);
-
-  EXPECT_TRUE(std::ranges::equal(arr, encoding_table_));
-}
-
-TEST_F(V2Test, CheckpointTest) {
-  // Arrange
-  const std::array<std::string, 4> arr = {"aboba", "lol", "kek", "cheburek"};
-
-  // Act
-  const auto id0 = encoding_table_.find_or_emplace(arr[0]);
-  const auto id1 = encoding_table_.find_or_emplace(arr[1]);
-  const auto id2 = encoding_table_.find_or_emplace(arr[2]);
-  const auto id3 = encoding_table_.find_or_emplace(arr[3]);
-
-  const auto checkpoint = encoding_table_.checkpoint();
-  std::stringstream ss;
-  checkpoint.save(ss);
-  decoding_table_.load(ss);
-
-  // Assert
-  EXPECT_EQ(ss.str().size(), checkpoint.save_size());
-
-  EXPECT_EQ(decoding_table_.size(), 4);
-
-  EXPECT_EQ(decoding_table_[id0], arr[0]);
-  EXPECT_EQ(decoding_table_[id1], arr[1]);
-  EXPECT_EQ(decoding_table_[id2], arr[2]);
-  EXPECT_EQ(decoding_table_[id3], arr[3]);
-
-  EXPECT_TRUE(std::ranges::equal(arr, decoding_table_));
-}
-
-}  // namespace
diff --git a/pp/primitives/tests/snug_composites_tests.cpp b/pp/primitives/tests/snug_composites_tests.cpp
index 870f472ca..f2eb6faca 100644
--- a/pp/primitives/tests/snug_composites_tests.cpp
+++ b/pp/primitives/tests/snug_composites_tests.cpp
@@ -1,378 +1,558 @@
 #include <sstream>
 
 #include "gtest/gtest.h"
-#include "primitives/hash.h"
-#include "primitives/label_set.h"
 
+#include "bare_bones/streams.h"
+#include "primitives/label_set.h"
 #include "primitives/snug_composites.h"
 #include "primitives/snug_composites_filaments.h"
 
 namespace {
 
-using BareBones::SharedSpan;
-using BareBones::SharedVector;
+template <class T>
+using SharedSpan = BareBones::SharedSpan<T, BareBones::DefaultReallocator>;
+
+template <class T>
+using SharedVector = BareBones::SharedVector<T, BareBones::DefaultReallocator>;
+
 using BareBones::Vector;
 using PromPP::Primitives::LabelViewSet;
 using std::operator""sv;
+using std::string_literals::operator""s;
 
-template <template <class> class Vector>
-class GenericNamesSetForTest : public Vector<std::string> {
-  using Base = Vector<std::string>;
-
- public:
-  using Base::Base;
-  friend size_t hash_value(const GenericNamesSetForTest& lns) { return PromPP::Primitives::hash::hash_of_string_list(lns); }
+class SymbolEncodingBimapTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_table_;
 };
 
-using NamesSetForTest = GenericNamesSetForTest<std::vector>;
+TEST_F(SymbolEncodingBimapTest, StoreAndRetrieveSymbol) {
+  // Arrange
+  const std::string symbol = "test_symbol";
 
-template <template <class> class Vector>
-class GenericLabelSetForTest : public Vector<std::pair<std::string, std::string>> {
-  using Base = Vector<std::pair<std::string, std::string>>;
+  // Act
+  const auto id = encoding_table_.find_or_emplace(symbol);
 
- public:
-  using Base::Base;
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_EQ(symbol, encoding_table_[id]);
+  EXPECT_EQ(id, encoding_table_.find(symbol));
+}
 
-  GenericNamesSetForTest<Vector> names() const {
-    GenericNamesSetForTest<Vector> tns;
+TEST_F(SymbolEncodingBimapTest, StoreMultipleSymbols) {
+  // Arrange
+  const std::string symbol1 = "first";
+  const std::string symbol2 = "second";
+  const std::string symbol3 = "third";
 
-    for (const auto& [label_name, _] : *this) {
-      tns.push_back(label_name);
-    }
+  // Act
+  const auto id1 = encoding_table_.find_or_emplace(symbol1);
+  const auto id2 = encoding_table_.find_or_emplace(symbol2);
+  const auto id3 = encoding_table_.find_or_emplace(symbol3);
 
-    return tns;
-  }
-};
+  // Assert
+  EXPECT_EQ(3U, encoding_table_.size());
 
-using LabelSetForTest = GenericLabelSetForTest<std::vector>;
+  EXPECT_EQ(symbol1, encoding_table_[id1]);
+  EXPECT_EQ(symbol2, encoding_table_[id2]);
+  EXPECT_EQ(symbol3, encoding_table_[id3]);
 
-template <template <class> class Vector>
-using SymbolFilament = BareBones::SnugComposite::EncodingBimap<PromPP::Primitives::SnugComposites::Filaments::Symbol, Vector>;
+  EXPECT_EQ(id1, encoding_table_.find(symbol1));
+  EXPECT_EQ(id2, encoding_table_.find(symbol2));
+  EXPECT_EQ(id3, encoding_table_.find(symbol3));
+}
 
-template <template <class> class Vector>
-using LabelNameSetFilament = PromPP::Primitives::SnugComposites::Filaments::LabelNameSet<SymbolFilament, Vector>;
+TEST_F(SymbolEncodingBimapTest, FindOrEmplaceReturnsSameIdForDuplicate) {
+  // Arrange
+  const std::string symbol = "duplicate";
 
-template <template <class> class Vector>
-using LabelSetFilament = BareBones::SnugComposite::EncodingBimap<LabelNameSetFilament, Vector>;
+  // Act
+  const auto id1 = encoding_table_.find_or_emplace(symbol);
+  const auto id2 = encoding_table_.find_or_emplace(symbol);
 
-template <template <class> class Vector>
-using GenericLabelSet = PromPP::Primitives::SnugComposites::Filaments::LabelSet<SymbolFilament, LabelSetFilament, Vector>;
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_EQ(id1, id2);
+}
 
-using LabelSet = GenericLabelSet<Vector>;
+TEST_F(SymbolEncodingBimapTest, IterateOverSymbols) {
+  // Arrange
+  const std::string symbol1 = "a";
+  const std::string symbol2 = "b";
+  const std::string symbol3 = "c";
 
-struct SnugComposites : public testing::Test {};
+  // Act
+  encoding_table_.find_or_emplace(symbol1);
+  encoding_table_.find_or_emplace(symbol2);
+  encoding_table_.find_or_emplace(symbol3);
 
-TEST(SnugComposites, SnapshotRollbackSymbolEncodingBimap) {
-  PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_bimap;
+  // Assert
+  EXPECT_EQ(3U, encoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(encoding_table_, std::initializer_list{"a"s, "b"s, "c"s}));
+}
 
-  const std::vector<std::string> etalons_rollback = {"11111", "22222", "33333"};
-  const std::vector<std::string> etalons = {"44444", "55555", "66666"};
-  const auto first_element = "xxxxx";
+TEST_F(SymbolEncodingBimapTest, CheckpointAndRollback) {
+  // Arrange
+  const std::string symbol1 = "before_checkpoint";
+  const std::string symbol2 = "after_checkpoint";
 
-  // add one element
-  encoding_bimap.find_or_emplace(first_element);
-  // checkpoint
-  auto checkpoint = encoding_bimap.checkpoint();
+  // Act
+  encoding_table_.find_or_emplace(symbol1);
+  const auto checkpoint = encoding_table_.checkpoint();
+  encoding_table_.find_or_emplace(symbol2);
+  encoding_table_.rollback(checkpoint);
 
-  // add elements
-  for (const auto& etalon : etalons_rollback) {
-    encoding_bimap.find_or_emplace(etalon);
-  }
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_TRUE(encoding_table_.find(symbol1).has_value());
+  EXPECT_FALSE(encoding_table_.find(symbol2).has_value());
+}
 
-  // check elements
-  auto etalon = etalons_rollback.begin();
-  auto outcome = encoding_bimap.begin();
-  EXPECT_EQ(*outcome, first_element);
-  outcome++;
-  while (etalon != etalons_rollback.end() && outcome != encoding_bimap.end()) {
-    EXPECT_EQ(*outcome++, *etalon++);
-  }
+class SymbolDecodingTableTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_table_;
+  PromPP::Primitives::SnugComposites::Symbol::DecodingTable<Vector> decoding_table_;
+};
 
-  // rollback
-  encoding_bimap.rollback(checkpoint);
+TEST_F(SymbolDecodingTableTest, LoadFromCheckpoint) {
+  // Arrange
+  const std::string symbol1 = "first";
+  const std::string symbol2 = "second";
+  const auto id1 = encoding_table_.find_or_emplace(symbol1);
+  const auto id2 = encoding_table_.find_or_emplace(symbol2);
+  const auto checkpoint = encoding_table_.checkpoint();
 
-  // add new elements
-  for (const auto& str : etalons) {
-    encoding_bimap.find_or_emplace(str);
-  }
+  // Act
+  std::stringstream ss;
+  checkpoint.save(ss);
+  decoding_table_.load(ss);
 
-  // check new elements
-  etalon = etalons.begin();
-  outcome = encoding_bimap.begin();
-  EXPECT_EQ(*outcome, first_element);
-  outcome++;
-  while (etalon != etalons.end() && outcome != encoding_bimap.end()) {
-    EXPECT_EQ(*outcome++, *etalon++);
-  }
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_EQ(symbol1, decoding_table_[id1]);
+  EXPECT_EQ(symbol2, decoding_table_[id2]);
 }
 
-TEST(SnugComposites, SnapshotRollbackLabelNameSetEncodingBimap) {
-  PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector> encoding_bimap;
-
-  const std::vector<NamesSetForTest> etalons_rollback = {{"11111", "22222", "33333"}, {"44444", "55555", "66666"}};
-  const std::vector<NamesSetForTest> etalons = {{"77777", "88888", "99999"}, {"aaaaa", "sssss", "ddddd"}};
-  const NamesSetForTest first_element = {"xxxxx", "zzzzz", "ccccc"};
-
-  // add one element
-  encoding_bimap.find_or_emplace(first_element);
-  // checkpoint
-  auto checkpoint = encoding_bimap.checkpoint();
-
-  // add elements
-  for (const auto& etalon : etalons_rollback) {
-    encoding_bimap.find_or_emplace(etalon);
-  }
-
-  // check elements
-  auto etalon = etalons_rollback.begin();
-  auto outcome = encoding_bimap.begin();
-  EXPECT_EQ(*outcome, first_element);
-  outcome++;
-  while (etalon != etalons_rollback.end() && outcome != encoding_bimap.end()) {
-    EXPECT_EQ(*outcome++, *etalon++);
-  }
-
-  // rollback
-  encoding_bimap.rollback(checkpoint);
-
-  // add new elements
-  for (const auto& etalon : etalons) {
-    encoding_bimap.find_or_emplace(etalon);
-  }
-
-  // check new elements
-  etalon = etalons.begin();
-  outcome = encoding_bimap.begin();
-  EXPECT_EQ(*outcome, first_element);
-  outcome++;
-  while (etalon != etalons.end() && outcome != encoding_bimap.end()) {
-    EXPECT_EQ(*outcome++, *etalon++);
-  }
+TEST_F(SymbolDecodingTableTest, IterateOverDecodingTable) {
+  // Arrange
+  const std::string symbol1 = "a";
+  const std::string symbol2 = "b";
+  encoding_table_.find_or_emplace(symbol1);
+  encoding_table_.find_or_emplace(symbol2);
+  const auto checkpoint = encoding_table_.checkpoint();
+
+  // Act
+  std::stringstream ss;
+  checkpoint.save(ss);
+  decoding_table_.load(ss);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(decoding_table_, std::initializer_list{"a"s, "b"s}));
 }
 
-TEST(SnugComposites, SnapshotRollbackLabelSetEncodingBimap) {
-  LabelSet::data_type data;
-  auto data_checkpoint = data.checkpoint();
-
-  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_bimap;
-
-  const std::vector<LabelSetForTest> etalons_rollback = {{{"11111", "22222"}}, {{"33333", "44444"}}, {{"55555", "66666"}}};
-  const std::vector<LabelSetForTest> etalons = {{{"77777", "88888"}}, {{"99999", "aaaaa"}}, {{"sssss", "ddddd"}}};
-  const LabelSetForTest first_element = {{"xxxxx", "zzzzz"}};
-
-  // add one element
-  auto ls = LabelSet(data, first_element);
-  EXPECT_NO_THROW(ls.validate(data));
-  encoding_bimap.find_or_emplace(ls.composite(data));
-  // checkpoint
-  auto checkpoint = encoding_bimap.checkpoint();
-
-  // add elements
-  for (const auto& etalon : etalons_rollback) {
-    ls = LabelSet(data, etalon);
-    EXPECT_NO_THROW(ls.validate(data));
-    encoding_bimap.find_or_emplace(ls.composite(data));
-  }
-
-  // check elements
-  auto etalon = etalons_rollback.begin();
-  auto outcome = encoding_bimap.begin();
-
-  auto etalon_first = first_element.begin();
-  auto outcome_first = (*outcome).begin();
-  while (etalon_first != first_element.end() && outcome_first != (*outcome).end()) {
-    EXPECT_EQ((*outcome_first).first, (*etalon_first).first);
-    EXPECT_EQ((*outcome_first).second, (*etalon_first).second);
-    ++etalon_first;
-    ++outcome_first;
-  }
-
-  outcome++;
-  while (etalon != etalons_rollback.end() && outcome != encoding_bimap.end()) {
-    auto etalon_another = (*etalon).begin();
-    auto outcome_another = (*outcome).begin();
-
-    while (etalon_another != (*etalon).end() && outcome_another != (*outcome).end()) {
-      EXPECT_EQ((*outcome_another).first, (*etalon_another).first);
-      EXPECT_EQ((*outcome_another).second, (*etalon_another).second);
-      ++etalon_another;
-      ++outcome_another;
-    }
-
-    etalon++;
-    outcome++;
-  }
-
-  // rollback
-  data.rollback(data_checkpoint);
-  encoding_bimap.rollback(checkpoint);
-
-  // add new elements
-  for (const auto& etalon : etalons) {
-    ls = LabelSet(data, etalon);
-    EXPECT_NO_THROW(ls.validate(data));
-    encoding_bimap.find_or_emplace(ls.composite(data));
-  }
-
-  // check new elements
-  etalon = etalons.begin();
-  outcome = encoding_bimap.begin();
-
-  etalon_first = first_element.begin();
-  outcome_first = (*outcome).begin();
-  while (etalon_first != first_element.end() && outcome_first != (*outcome).end()) {
-    EXPECT_EQ((*outcome_first).first, (*etalon_first).first);
-    EXPECT_EQ((*outcome_first).second, (*etalon_first).second);
-    ++etalon_first;
-    ++outcome_first;
-  }
-
-  outcome++;
-  while (etalon != etalons.end() && outcome != encoding_bimap.end()) {
-    auto etalon_another = (*etalon).begin();
-    auto outcome_another = (*outcome).begin();
-
-    while (etalon_another != (*etalon).end() && outcome_another != (*outcome).end()) {
-      EXPECT_EQ((*outcome_another).first, (*etalon_another).first);
-      EXPECT_EQ((*outcome_another).second, (*etalon_another).second);
-      ++etalon_another;
-      ++outcome_another;
-    }
-
-    etalon++;
-    outcome++;
-  }
+TEST_F(SymbolDecodingTableTest, CheckpointSaveSizeMatchesActualSize) {
+  // Arrange
+  encoding_table_.find_or_emplace("test"sv);
+  const auto checkpoint = encoding_table_.checkpoint();
+  BareBones::ShrinkedToFitOStringStream ss;
+
+  // Act
+  checkpoint.save(ss);
+  const auto save_size = checkpoint.save_size();
+
+  // Assert
+  EXPECT_EQ(ss.view().size(), save_size);
 }
 
-template <class T>
-class EncodingBimap : public testing::Test {
- public:
-  static void find_or_emplace(PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector>& encoding_bimap) {
-    const auto str = "11111";
-    encoding_bimap.find_or_emplace(str);
-  };
-
-  static void find_or_emplace(PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector>& encoding_bimap) {
-    const NamesSetForTest nst = {"11111"};
-    encoding_bimap.find_or_emplace(nst);
-  };
-
-  static void find_or_emplace(PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector>& encoding_bimap) {
-    const LabelSetForTest lst = {{"11111", "22222"}};
-    LabelSet::data_type data;
-    auto ls = LabelSet(data, lst);
-    EXPECT_NO_THROW(ls.validate(data));
-
-    encoding_bimap.find_or_emplace(ls.composite(data));
-  };
+TEST_F(SymbolEncodingBimapTest, CreateViewFromEncodingBimap) {
+  // Arrange
+  encoding_table_.find_or_emplace("lol"s);
+  encoding_table_.find_or_emplace("kek"s);
+  encoding_table_.find_or_emplace("pod"s);
+  encoding_table_.find_or_emplace("job"s);
+
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  EXPECT_EQ(4U, view.size());
+  EXPECT_TRUE(std::ranges::equal(view, encoding_table_));
+}
+
+TEST_F(SymbolEncodingBimapTest, EncodingBimapViewIteratorId) {
+  // Arrange
+  const auto id1 = encoding_table_.find_or_emplace("lol"s);
+  const auto id2 = encoding_table_.find_or_emplace("kek"s);
+  const auto id3 = encoding_table_.find_or_emplace("pod"s);
+  const auto id4 = encoding_table_.find_or_emplace("job"s);
+
+  // Act
+  auto view_iter = encoding_table_.data_view().begin();
+
+  // Assert
+  EXPECT_EQ(id1, (view_iter++).id());
+  EXPECT_EQ(id2, (view_iter++).id());
+  EXPECT_EQ(id3, (view_iter++).id());
+  EXPECT_EQ(id4, (view_iter++).id());
+}
+
+class LabelNameSetEncodingBimapTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector> encoding_table_;
 };
 
-typedef testing::Types<PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector>,
-                       PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector>,
-                       PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector>>
-    FilamentTypes;
-TYPED_TEST_SUITE(EncodingBimap, FilamentTypes);
-
-TYPED_TEST(EncodingBimap, SaveSizeFULL) {
-  TypeParam encoding_bimap;
-  std::ostringstream stream;
-
-  EncodingBimap<TypeParam>::find_or_emplace(encoding_bimap);
-  auto checkpoint = encoding_bimap.checkpoint();
-  const auto etalon_save_size_full = checkpoint.save_size();
-  stream << checkpoint;
-  EXPECT_EQ(stream.tellp(), etalon_save_size_full);
+TEST_F(LabelNameSetEncodingBimapTest, StoreAndRetrieveLabelNameSet) {
+  // Arrange
+  const LabelViewSet label_set = {{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
+
+  // Act
+  const auto id = encoding_table_.find_or_emplace(label_set.names());
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  const auto retrieved = encoding_table_[id];
+  EXPECT_TRUE(std::ranges::equal(label_set.names(), retrieved));
 }
 
-TYPED_TEST(EncodingBimap, SaveSizeWAL) {
-  TypeParam encoding_bimap;
-  std::ostringstream stream;
-
-  auto base = encoding_bimap.checkpoint();
-  EncodingBimap<TypeParam>::find_or_emplace(encoding_bimap);
-  auto checkpoint = encoding_bimap.checkpoint();
-  auto delta = checkpoint - base;
-  const auto etalon_save_size_wal = delta.save_size();
-  stream << delta;
-  EXPECT_EQ(stream.tellp(), etalon_save_size_wal);
+TEST_F(LabelNameSetEncodingBimapTest, StoreMultipleLabelNameSets) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}, {"b", "2"}};
+  const LabelViewSet label_set2 = {{"c", "3"}, {"d", "4"}, {"e", "5"}};
+
+  // Act
+  const auto id1 = encoding_table_.find_or_emplace(label_set1.names());
+  const auto id2 = encoding_table_.find_or_emplace(label_set2.names());
+
+  // Assert
+  EXPECT_EQ(2U, encoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1.names(), encoding_table_[id1]));
+  EXPECT_TRUE(std::ranges::equal(label_set2.names(), encoding_table_[id2]));
+}
+
+TEST_F(LabelNameSetEncodingBimapTest, FindOrEmplaceReturnsSameIdForDuplicate) {
+  // Arrange
+  const LabelViewSet label_set = {{"duplicate", "value1"}, {"set", "value2"}};
+
+  // Act
+  const auto id1 = encoding_table_.find_or_emplace(label_set.names());
+  const auto id2 = encoding_table_.find_or_emplace(label_set.names());
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_EQ(id1, id2);
+}
+
+TEST_F(LabelNameSetEncodingBimapTest, IterateOverLabelNameSets) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
+
+  // Act
+  encoding_table_.find_or_emplace(label_set1.names());
+  encoding_table_.find_or_emplace(label_set2.names());
+
+  // Assert
+  EXPECT_EQ(2U, encoding_table_.size());
+  auto it = encoding_table_.begin();
+  EXPECT_TRUE(std::ranges::equal(label_set1.names(), *it++));
+  EXPECT_TRUE(std::ranges::equal(label_set2.names(), *it++));
+  EXPECT_EQ(encoding_table_.end(), it);
+}
+
+TEST_F(LabelNameSetEncodingBimapTest, CheckpointAndRollback) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"before", "checkpoint"}};
+  const LabelViewSet label_set2 = {{"after", "checkpoint"}};
+
+  // Act
+  encoding_table_.find_or_emplace(label_set1.names());
+  const auto checkpoint = encoding_table_.checkpoint();
+  encoding_table_.find_or_emplace(label_set2.names());
+  encoding_table_.rollback(checkpoint);
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1.names(), *encoding_table_.begin()));
 }
 
-class LssViewFixture : public testing::Test {
+class LabelNameSetDecodingTableTest : public testing::Test {
  protected:
-  template <class T>
-  using SharedVector = BareBones::SharedVector<T, BareBones::DefaultReallocator>;
+  PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector> encoding_table_;
+  PromPP::Primitives::SnugComposites::LabelNameSet::DecodingTable<Vector> decoding_table_;
+};
 
-  template <class T>
-  using SharedSpan = BareBones::SharedSpan<T, BareBones::DefaultReallocator>;
+TEST_F(LabelNameSetDecodingTableTest, LoadFromCheckpoint) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"first", "1"}};
+  const LabelViewSet label_set2 = {{"second", "2"}, {"third", "3"}};
+  const auto id1 = encoding_table_.find_or_emplace(label_set1.names());
+  const auto id2 = encoding_table_.find_or_emplace(label_set2.names());
+  const auto checkpoint = encoding_table_.checkpoint();
 
-  using Symbol = PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<SharedVector>;
-  using SymbolView = PromPP::Primitives::SnugComposites::Symbol::DecodingTable<SharedSpan>;
+  // Act
+  std::stringstream ss;
+  checkpoint.save(ss);
+  decoding_table_.load(ss);
 
-  using LabelNameSet = PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<SharedVector>;
-  using LabelNameSetView = PromPP::Primitives::SnugComposites::LabelNameSet::DecodingTable<SharedSpan>;
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1.names(), decoding_table_[id1]));
+  EXPECT_TRUE(std::ranges::equal(label_set2.names(), decoding_table_[id2]));
+}
+
+TEST_F(LabelNameSetDecodingTableTest, IterateOverDecodingTable) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
+  encoding_table_.find_or_emplace(label_set1.names());
+  encoding_table_.find_or_emplace(label_set2.names());
+  const auto checkpoint = encoding_table_.checkpoint();
+  std::stringstream ss;
+  checkpoint.save(ss);
+  decoding_table_.load(ss);
+
+  // Act & Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  auto it = decoding_table_.begin();
+  EXPECT_TRUE(std::ranges::equal(label_set1.names(), *it++));
+  EXPECT_TRUE(std::ranges::equal(label_set2.names(), *it++));
+  EXPECT_EQ(decoding_table_.end(), it);
+}
 
-  using LabelSet = PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<SharedVector>;
-  using LabelSetView = PromPP::Primitives::SnugComposites::LabelSet::DecodingTable<SharedSpan>;
+class LabelNameSetViewTest : public testing::Test {
+ protected:
+  using LabelNameSetEncodingBimap = PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<SharedVector>;
+  using LabelNameSetDecodingTable = PromPP::Primitives::SnugComposites::LabelNameSet::DecodingTable<SharedSpan>;
 };
 
-TEST_F(LssViewFixture, CopySymbol) {
+TEST_F(LabelNameSetViewTest, CreateViewFromEncodingBimap) {
   // Arrange
-  Symbol source;
-  constexpr auto source_data = "string1"sv;
-  source.find_or_emplace(source_data);
+  LabelNameSetEncodingBimap source;
+  const LabelViewSet source_label_set = {{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
+  source.find_or_emplace(source_label_set.names());
 
   // Act
-  const SymbolView view(source);
-  source.find_or_emplace("string2"sv);
+  const LabelNameSetDecodingTable view(source);
+  source.find_or_emplace(LabelViewSet{{"name4", "value4"}, {"name5", "value5"}}.names());
 
   // Assert
   EXPECT_EQ(1U, view.size());
-  EXPECT_EQ(source_data, view[0]);
+  EXPECT_TRUE(std::ranges::equal(source_label_set.names(), view[0]));
 }
 
-TEST_F(LssViewFixture, CopyLabelNameSet) {
+TEST_F(LabelNameSetViewTest, ViewRemainsValidAfterSourceModification) {
   // Arrange
-  LabelNameSet source;
-  const NamesSetForTest source_data{"name1", "name2", "name3"};
-  source.find_or_emplace(source_data);
+  auto source = std::make_unique<LabelNameSetEncodingBimap>();
+  const LabelViewSet source_label_set = {{"persistent", "value"}};
+  source->find_or_emplace(source_label_set.names());
 
   // Act
-  const LabelNameSetView view(source);
-  source.find_or_emplace(NamesSetForTest{"name4", "name5"});
+  const LabelNameSetDecodingTable view(*source);
+  source.reset();
 
   // Assert
   EXPECT_EQ(1U, view.size());
-  EXPECT_EQ(source_data, view[0]);
+  EXPECT_TRUE(std::ranges::equal(source_label_set.names(), view[0]));
+}
+
+class LabelSetEncodingBimapTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_table_;
+};
+
+TEST_F(LabelSetEncodingBimapTest, StoreAndRetrieveLabelSet) {
+  // Arrange
+  const LabelViewSet label_set = {{"name1", "value1"}, {"name2", "value2"}};
+
+  // Act
+  const auto id = encoding_table_.find_or_emplace(label_set);
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  const auto retrieved = encoding_table_[id];
+  EXPECT_TRUE(std::ranges::equal(label_set, retrieved, [](const auto& a, const auto& b) { return a == b; }));
+}
+
+TEST_F(LabelSetEncodingBimapTest, StoreMultipleLabelSets) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
+
+  // Act
+  const auto id1 = encoding_table_.find_or_emplace(label_set1);
+  const auto id2 = encoding_table_.find_or_emplace(label_set2);
+
+  // Assert
+  EXPECT_EQ(2U, encoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1, encoding_table_[id1], [](const auto& a, const auto& b) { return a == b; }));
+  EXPECT_TRUE(std::ranges::equal(label_set2, encoding_table_[id2], [](const auto& a, const auto& b) { return a == b; }));
 }
 
-TEST_F(LssViewFixture, CopyLabelSet) {
+TEST_F(LabelSetEncodingBimapTest, FindOrEmplaceReturnsSameIdForDuplicate) {
   // Arrange
-  LabelSet source;
-  const LabelViewSet source_data{{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
+  const LabelViewSet label_set = {{"duplicate", "set"}};
+
+  // Act
+  const auto id1 = encoding_table_.find_or_emplace(label_set);
+  const auto id2 = encoding_table_.find_or_emplace(label_set);
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_EQ(id1, id2);
+}
+
+TEST_F(LabelSetEncodingBimapTest, IterateOverLabelSets) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}};
+
+  // Act
+  encoding_table_.find_or_emplace(label_set1);
+  encoding_table_.find_or_emplace(label_set2);
+
+  // Assert
+  EXPECT_EQ(2U, encoding_table_.size());
+  auto it = encoding_table_.begin();
+  EXPECT_TRUE(std::ranges::equal(label_set1, *it++, [](const auto& a, const auto& b) { return a == b; }));
+  EXPECT_TRUE(std::ranges::equal(label_set2, *it++, [](const auto& a, const auto& b) { return a == b; }));
+  EXPECT_EQ(encoding_table_.end(), it);
+}
+
+TEST_F(LabelSetEncodingBimapTest, CheckpointAndRollback) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"before", "checkpoint"}};
+  const LabelViewSet label_set2 = {{"after", "checkpoint"}};
+
+  // Act
+  encoding_table_.find_or_emplace(label_set1);
+  const auto checkpoint = encoding_table_.checkpoint();
+  encoding_table_.find_or_emplace(label_set2);
+  encoding_table_.rollback(checkpoint);
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1, *encoding_table_.begin(), [](const auto& a, const auto& b) { return a == b; }));
+}
+
+class LabelSetDecodingTableTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_table_;
+  PromPP::Primitives::SnugComposites::LabelSet::DecodingTable<Vector> decoding_table_;
+};
+
+TEST_F(LabelSetDecodingTableTest, LoadFromCheckpoint) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"first", "1"}};
+  const LabelViewSet label_set2 = {{"second", "2"}, {"third", "3"}};
+  const auto id1 = encoding_table_.find_or_emplace(label_set1);
+  const auto id2 = encoding_table_.find_or_emplace(label_set2);
+  const auto checkpoint = encoding_table_.checkpoint();
+
+  // Act
+  std::stringstream ss;
+  checkpoint.save(ss);
+  decoding_table_.load(ss);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1, decoding_table_[id1], [](const auto& a, const auto& b) { return a == b; }));
+  EXPECT_TRUE(std::ranges::equal(label_set2, decoding_table_[id2], [](const auto& a, const auto& b) { return a == b; }));
+}
+
+TEST_F(LabelSetDecodingTableTest, IterateOverDecodingTable) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}};
+  encoding_table_.find_or_emplace(label_set1);
+  encoding_table_.find_or_emplace(label_set2);
+  const auto checkpoint = encoding_table_.checkpoint();
+  std::stringstream ss;
+  checkpoint.save(ss);
+  decoding_table_.load(ss);
+
+  // Act & Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  auto it = decoding_table_.begin();
+  EXPECT_TRUE(std::ranges::equal(label_set1, *it++, [](const auto& a, const auto& b) { return a == b; }));
+  EXPECT_TRUE(std::ranges::equal(label_set2, *it++, [](const auto& a, const auto& b) { return a == b; }));
+  EXPECT_EQ(decoding_table_.end(), it);
+}
+
+class LabelSetViewTest : public testing::Test {
+ protected:
+  using LabelSetEncodingBimap = PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<SharedVector>;
+  using LabelSetDecodingTable = PromPP::Primitives::SnugComposites::LabelSet::DecodingTable<SharedSpan>;
+};
+
+TEST_F(LabelSetViewTest, CreateViewFromEncodingBimap) {
+  // Arrange
+  LabelSetEncodingBimap source;
+  const LabelViewSet source_data = {{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
   source.find_or_emplace(source_data);
 
   // Act
-  const LabelSetView view(source);
+  const LabelSetDecodingTable view(source);
   source.find_or_emplace(LabelViewSet{{"name4", "value4"}});
 
   // Assert
   EXPECT_EQ(1U, view.size());
-  EXPECT_EQ(source_data, view[0]);
+  EXPECT_TRUE(std::ranges::equal(source_data, view[0], [](const auto& a, const auto& b) { return a == b; }));
 }
 
-TEST_F(LssViewFixture, UseCopyLabelSetAfterFreeSourceLabelSet) {
+TEST_F(LabelSetViewTest, ViewRemainsValidAfterSourceModification) {
   // Arrange
-  auto source = std::make_unique<LabelSet>();
-  const LabelViewSet source_data{{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
+  auto source = std::make_unique<LabelSetEncodingBimap>();
+  const LabelViewSet source_data = {{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
   source->find_or_emplace(source_data);
 
   // Act
-  const LabelSetView view(*source);
+  const LabelSetDecodingTable view(*source);
   source.reset();
 
   // Assert
   EXPECT_EQ(1U, view.size());
-  EXPECT_EQ(source_data, view[0]);
+  EXPECT_TRUE(std::ranges::equal(source_data, view[0], [](const auto& a, const auto& b) { return a == b; }));
+}
+
+TEST_F(LabelSetViewTest, AccessViewDataView) {
+  // Arrange
+  LabelSetEncodingBimap source;
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}};
+  source.find_or_emplace(label_set1);
+  source.find_or_emplace(label_set2);
+  const LabelSetDecodingTable view(source);
+
+  // Act
+  const auto data_view = view.data_view();
+
+  // Assert
+  EXPECT_EQ(2U, data_view.size());
+  auto it = data_view.begin();
+  EXPECT_TRUE(std::ranges::equal(label_set1, *it++, [](const auto& a, const auto& b) { return a == b; }));
+  EXPECT_TRUE(std::ranges::equal(label_set2, *it++, [](const auto& a, const auto& b) { return a == b; }));
+}
+
+class SymbolDeltaCheckpointTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_table_;
+};
+
+TEST_F(SymbolDeltaCheckpointTest, DeltaCheckpointSaveSize) {
+  // Arrange
+  encoding_table_.find_or_emplace("first"sv);
+  const auto base_checkpoint = encoding_table_.checkpoint();
+  encoding_table_.find_or_emplace("second"sv);
+  const auto checkpoint = encoding_table_.checkpoint();
+  const auto delta = checkpoint - base_checkpoint;
+  BareBones::ShrinkedToFitOStringStream ss;
+
+  // Act
+  ss << delta;
+  const auto save_size = delta.save_size();
+
+  // Assert
+  EXPECT_EQ(ss.view().size(), save_size);
 }
 
 }  // namespace

From 7c7f2e10b5962db94a2d482e3c9e76ba98846cea Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Wed, 17 Dec 2025 23:06:16 +0300
Subject: [PATCH 21/34] snug composites tests fixes

---
 pp/primitives/tests/snug_composites_tests.cpp | 80 +++++++------------
 1 file changed, 29 insertions(+), 51 deletions(-)

diff --git a/pp/primitives/tests/snug_composites_tests.cpp b/pp/primitives/tests/snug_composites_tests.cpp
index f2eb6faca..f11c0a117 100644
--- a/pp/primitives/tests/snug_composites_tests.cpp
+++ b/pp/primitives/tests/snug_composites_tests.cpp
@@ -307,52 +307,33 @@ TEST_F(LabelNameSetDecodingTableTest, IterateOverDecodingTable) {
   encoding_table_.find_or_emplace(label_set1.names());
   encoding_table_.find_or_emplace(label_set2.names());
   const auto checkpoint = encoding_table_.checkpoint();
+
+  // Act
   std::stringstream ss;
   checkpoint.save(ss);
   decoding_table_.load(ss);
 
-  // Act & Assert
-  EXPECT_EQ(2U, decoding_table_.size());
-  auto it = decoding_table_.begin();
-  EXPECT_TRUE(std::ranges::equal(label_set1.names(), *it++));
-  EXPECT_TRUE(std::ranges::equal(label_set2.names(), *it++));
-  EXPECT_EQ(decoding_table_.end(), it);
-}
-
-class LabelNameSetViewTest : public testing::Test {
- protected:
-  using LabelNameSetEncodingBimap = PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<SharedVector>;
-  using LabelNameSetDecodingTable = PromPP::Primitives::SnugComposites::LabelNameSet::DecodingTable<SharedSpan>;
-};
-
-TEST_F(LabelNameSetViewTest, CreateViewFromEncodingBimap) {
-  // Arrange
-  LabelNameSetEncodingBimap source;
-  const LabelViewSet source_label_set = {{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
-  source.find_or_emplace(source_label_set.names());
-
-  // Act
-  const LabelNameSetDecodingTable view(source);
-  source.find_or_emplace(LabelViewSet{{"name4", "value4"}, {"name5", "value5"}}.names());
-
   // Assert
-  EXPECT_EQ(1U, view.size());
-  EXPECT_TRUE(std::ranges::equal(source_label_set.names(), view[0]));
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_TRUE(
+      std::ranges::equal(decoding_table_, std::initializer_list{label_set1.names(), label_set2.names()}, [](const auto& a, const auto& b) { return a == b; }));
 }
 
-TEST_F(LabelNameSetViewTest, ViewRemainsValidAfterSourceModification) {
+TEST_F(LabelNameSetDecodingTableTest, CreateViewFromEncodingBimap) {
   // Arrange
-  auto source = std::make_unique<LabelNameSetEncodingBimap>();
-  const LabelViewSet source_label_set = {{"persistent", "value"}};
-  source->find_or_emplace(source_label_set.names());
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
+  const LabelViewSet label_set3 = {{"d", "4"}, {"e", "5"}, {"f", "6"}};
+  encoding_table_.find_or_emplace(label_set1.names());
+  encoding_table_.find_or_emplace(label_set2.names());
+  encoding_table_.find_or_emplace(label_set3.names());
 
   // Act
-  const LabelNameSetDecodingTable view(*source);
-  source.reset();
+  const auto symbols = encoding_table_.data_view().symbols();
 
   // Assert
-  EXPECT_EQ(1U, view.size());
-  EXPECT_TRUE(std::ranges::equal(source_label_set.names(), view[0]));
+  EXPECT_EQ(6U, symbols.size());
+  EXPECT_TRUE(std::ranges::equal(symbols, std::initializer_list{"a", "b", "c", "d", "e", "f"}));
 }
 
 class LabelSetEncodingBimapTest : public testing::Test {
@@ -370,7 +351,7 @@ TEST_F(LabelSetEncodingBimapTest, StoreAndRetrieveLabelSet) {
   // Assert
   EXPECT_EQ(1U, encoding_table_.size());
   const auto retrieved = encoding_table_[id];
-  EXPECT_TRUE(std::ranges::equal(label_set, retrieved, [](const auto& a, const auto& b) { return a == b; }));
+  EXPECT_TRUE(std::ranges::equal(label_set, retrieved));
 }
 
 TEST_F(LabelSetEncodingBimapTest, StoreMultipleLabelSets) {
@@ -384,8 +365,8 @@ TEST_F(LabelSetEncodingBimapTest, StoreMultipleLabelSets) {
 
   // Assert
   EXPECT_EQ(2U, encoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(label_set1, encoding_table_[id1], [](const auto& a, const auto& b) { return a == b; }));
-  EXPECT_TRUE(std::ranges::equal(label_set2, encoding_table_[id2], [](const auto& a, const auto& b) { return a == b; }));
+  EXPECT_TRUE(std::ranges::equal(label_set1, encoding_table_[id1]));
+  EXPECT_TRUE(std::ranges::equal(label_set2, encoding_table_[id2]));
 }
 
 TEST_F(LabelSetEncodingBimapTest, FindOrEmplaceReturnsSameIdForDuplicate) {
@@ -404,7 +385,7 @@ TEST_F(LabelSetEncodingBimapTest, FindOrEmplaceReturnsSameIdForDuplicate) {
 TEST_F(LabelSetEncodingBimapTest, IterateOverLabelSets) {
   // Arrange
   const LabelViewSet label_set1 = {{"a", "1"}};
-  const LabelViewSet label_set2 = {{"b", "2"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
 
   // Act
   encoding_table_.find_or_emplace(label_set1);
@@ -412,10 +393,7 @@ TEST_F(LabelSetEncodingBimapTest, IterateOverLabelSets) {
 
   // Assert
   EXPECT_EQ(2U, encoding_table_.size());
-  auto it = encoding_table_.begin();
-  EXPECT_TRUE(std::ranges::equal(label_set1, *it++, [](const auto& a, const auto& b) { return a == b; }));
-  EXPECT_TRUE(std::ranges::equal(label_set2, *it++, [](const auto& a, const auto& b) { return a == b; }));
-  EXPECT_EQ(encoding_table_.end(), it);
+  EXPECT_TRUE(std::ranges::equal(encoding_table_, std::initializer_list{label_set1, label_set2}, [](const auto& a, const auto& b) { return a == b; }));
 }
 
 TEST_F(LabelSetEncodingBimapTest, CheckpointAndRollback) {
@@ -424,14 +402,15 @@ TEST_F(LabelSetEncodingBimapTest, CheckpointAndRollback) {
   const LabelViewSet label_set2 = {{"after", "checkpoint"}};
 
   // Act
-  encoding_table_.find_or_emplace(label_set1);
+  const auto id1 = encoding_table_.find_or_emplace(label_set1);
   const auto checkpoint = encoding_table_.checkpoint();
   encoding_table_.find_or_emplace(label_set2);
   encoding_table_.rollback(checkpoint);
 
   // Assert
   EXPECT_EQ(1U, encoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(label_set1, *encoding_table_.begin(), [](const auto& a, const auto& b) { return a == b; }));
+  EXPECT_EQ(id1, encoding_table_.find(label_set1).value());
+  EXPECT_FALSE(encoding_table_.find(label_set2).has_value());
 }
 
 class LabelSetDecodingTableTest : public testing::Test {
@@ -455,8 +434,8 @@ TEST_F(LabelSetDecodingTableTest, LoadFromCheckpoint) {
 
   // Assert
   EXPECT_EQ(2U, decoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(label_set1, decoding_table_[id1], [](const auto& a, const auto& b) { return a == b; }));
-  EXPECT_TRUE(std::ranges::equal(label_set2, decoding_table_[id2], [](const auto& a, const auto& b) { return a == b; }));
+  EXPECT_TRUE(std::ranges::equal(label_set1, decoding_table_[id1]));
+  EXPECT_TRUE(std::ranges::equal(label_set2, decoding_table_[id2]));
 }
 
 TEST_F(LabelSetDecodingTableTest, IterateOverDecodingTable) {
@@ -466,16 +445,15 @@ TEST_F(LabelSetDecodingTableTest, IterateOverDecodingTable) {
   encoding_table_.find_or_emplace(label_set1);
   encoding_table_.find_or_emplace(label_set2);
   const auto checkpoint = encoding_table_.checkpoint();
+
+  // Act
   std::stringstream ss;
   checkpoint.save(ss);
   decoding_table_.load(ss);
 
-  // Act & Assert
+  // Assert
   EXPECT_EQ(2U, decoding_table_.size());
-  auto it = decoding_table_.begin();
-  EXPECT_TRUE(std::ranges::equal(label_set1, *it++, [](const auto& a, const auto& b) { return a == b; }));
-  EXPECT_TRUE(std::ranges::equal(label_set2, *it++, [](const auto& a, const auto& b) { return a == b; }));
-  EXPECT_EQ(decoding_table_.end(), it);
+  EXPECT_TRUE(std::ranges::equal(decoding_table_, std::initializer_list{label_set1, label_set2}, [](const auto& a, const auto& b) { return a == b; }));
 }
 
 class LabelSetViewTest : public testing::Test {

From 8c3950d33647cce147321c69ef8985fbaa77fa60 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Thu, 18 Dec 2025 11:04:46 +0300
Subject: [PATCH 22/34] restore ShrinkableEncodingBimap tests

---
 pp/bare_bones/snug_composite.h                |   2 +-
 pp/primitives/tests/snug_composites_tests.cpp | 177 ++++++++++++++++++
 2 files changed, 178 insertions(+), 1 deletion(-)

diff --git a/pp/bare_bones/snug_composite.h b/pp/bare_bones/snug_composite.h
index 8f5321c22..9e80021d4 100644
--- a/pp/bare_bones/snug_composite.h
+++ b/pp/bare_bones/snug_composite.h
@@ -389,7 +389,7 @@ class DecodingTable : public GenericDecodingTable<DecodingTable<Filament, Vector
 };
 
 template <template <template <class> class> class Filament, template <class> class Vector>
-  requires is_shrinkable<typename Filament<Vector>::data_type>
+  requires is_shrinkable<typename Filament<Vector>::storage_type>
 class ShrinkableEncodingBimap final : private GenericDecodingTable<ShrinkableEncodingBimap<Filament, Vector>, Filament, Vector> {
  public:
   using Base = GenericDecodingTable<ShrinkableEncodingBimap, Filament, Vector>;
diff --git a/pp/primitives/tests/snug_composites_tests.cpp b/pp/primitives/tests/snug_composites_tests.cpp
index f11c0a117..7b5b66380 100644
--- a/pp/primitives/tests/snug_composites_tests.cpp
+++ b/pp/primitives/tests/snug_composites_tests.cpp
@@ -533,4 +533,181 @@ TEST_F(SymbolDeltaCheckpointTest, DeltaCheckpointSaveSize) {
   EXPECT_EQ(ss.view().size(), save_size);
 }
 
+class ShrinkableEncodingBimapLabelSetFixture : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::LabelSet::ShrinkableEncodingBimap<Vector> encoding_table_;
+  PromPP::Primitives::SnugComposites::LabelSet::DecodingTable<Vector> decoding_table_;
+  std::array<LabelViewSet, 6> ls_;
+
+  void SetUp() override {
+    ls_[0] = {{"1", "1"}, {"2", "2"}};
+    ls_[1] = {{"3", "3"}};
+    ls_[2] = {{"4", "4"}};
+    ls_[3] = {{"5", "5"}};
+    ls_[4] = {{"6", "6"}};
+    ls_[5] = {{"7", "7"}};
+  }
+
+  auto create_and_load_checkpoint(const typename PromPP::Primitives::SnugComposites::LabelSet::ShrinkableEncodingBimap<Vector>::checkpoint_type* from) {
+    auto checkpoint = encoding_table_.checkpoint();
+    std::stringstream ss;
+    checkpoint.save(ss, from);
+    decoding_table_.load(ss);
+    return checkpoint;
+  }
+
+  void check_decoding_table() const {
+    ASSERT_EQ(3U, decoding_table_.size());
+    {
+      auto composite = decoding_table_[0];
+      ASSERT_EQ(2U, composite.size());
+      auto it = composite.begin();
+      EXPECT_EQ((std::pair<std::string_view, std::string_view>("1", "1")), *it++);
+      EXPECT_EQ((std::pair<std::string_view, std::string_view>("2", "2")), *it);
+    }
+    {
+      auto composite = decoding_table_[1];
+      ASSERT_EQ(1U, composite.size());
+      EXPECT_EQ((std::pair<std::string_view, std::string_view>("3", "3")), *composite.begin());
+    }
+    {
+      auto composite = decoding_table_[2];
+      ASSERT_EQ(1U, composite.size());
+      EXPECT_EQ((std::pair<std::string_view, std::string_view>("4", "4")), *composite.begin());
+    }
+  }
+};
+
+TEST_F(ShrinkableEncodingBimapLabelSetFixture, ShrinkAndLoad) {
+  // Arrange
+
+  // Act
+  {
+    encoding_table_.find_or_emplace(ls_[0]);
+    encoding_table_.find_or_emplace(ls_[1]);
+    const auto checkpoint = create_and_load_checkpoint(nullptr);
+    encoding_table_.shrink_to_checkpoint_size(checkpoint);
+  }
+  {
+    const auto empty_checkpoint = encoding_table_.checkpoint();
+    encoding_table_.find_or_emplace(ls_[2]);
+    const auto checkpoint = create_and_load_checkpoint(&empty_checkpoint);
+    encoding_table_.shrink_to_checkpoint_size(checkpoint);
+  }
+
+  // Assert
+  check_decoding_table();
+}
+
+TEST_F(ShrinkableEncodingBimapLabelSetFixture, LoadWithoutShrink) {
+  // Arrange
+
+  // Act
+  {
+    encoding_table_.find_or_emplace(ls_[0]);
+    encoding_table_.find_or_emplace(ls_[1]);
+    create_and_load_checkpoint(nullptr);
+  }
+  {
+    const auto empty_checkpoint = encoding_table_.checkpoint();
+    encoding_table_.find_or_emplace(ls_[2]);
+    create_and_load_checkpoint(&empty_checkpoint);
+  }
+
+  // Assert
+  check_decoding_table();
+}
+
+TEST_F(ShrinkableEncodingBimapLabelSetFixture, LoadFromNonShrinkableTable) {
+  // Arrange
+  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> lss;
+  std::stringstream stream;
+
+  // Act
+  lss.find_or_emplace(LabelViewSet{{"process", "php"}});
+  lss.find_or_emplace(LabelViewSet{{"process", "nodejs"}});
+  lss.find_or_emplace(LabelViewSet{{"process", "python"}});
+  const auto checkpoint = lss.checkpoint();
+  stream << checkpoint;
+  stream >> encoding_table_;
+  encoding_table_.shrink_to_checkpoint_size(encoding_table_.checkpoint());
+
+  const auto nginx_id = lss.find_or_emplace(LabelViewSet{{"process", "nginx"}});
+  const auto apache_id = lss.find_or_emplace(LabelViewSet{{"process", "apache"}});
+  stream << lss.checkpoint() - checkpoint;
+  stream >> encoding_table_;
+
+  // Assert
+  EXPECT_FALSE(encoding_table_.find(LabelViewSet{{"process", "php"}}).has_value());
+  EXPECT_EQ(nginx_id, encoding_table_.find(LabelViewSet{{"process", "nginx"}}).value());
+  EXPECT_EQ(apache_id, encoding_table_.find(LabelViewSet{{"process", "apache"}}).value());
+}
+
+TEST_F(ShrinkableEncodingBimapLabelSetFixture, EmptyCheckpointWithShrink) {
+  // Arrange
+
+  // Act
+  {
+    encoding_table_.find_or_emplace(ls_[0]);
+    encoding_table_.find_or_emplace(ls_[1]);
+    encoding_table_.find_or_emplace(ls_[2]);
+    const auto checkpoint = create_and_load_checkpoint(nullptr);
+    encoding_table_.shrink_to_checkpoint_size(checkpoint);
+  }
+  {
+    const auto empty_checkpoint = encoding_table_.checkpoint();
+    create_and_load_checkpoint(&empty_checkpoint);
+  }
+
+  // Assert
+  check_decoding_table();
+}
+
+TEST_F(ShrinkableEncodingBimapLabelSetFixture, EmptyCheckpointWithoutShrink) {
+  // Arrange
+
+  // Act
+  {
+    encoding_table_.find_or_emplace(ls_[0]);
+    encoding_table_.find_or_emplace(ls_[1]);
+    encoding_table_.find_or_emplace(ls_[2]);
+    create_and_load_checkpoint(nullptr);
+  }
+  {
+    const auto empty_checkpoint = encoding_table_.checkpoint();
+    create_and_load_checkpoint(&empty_checkpoint);
+  }
+
+  // Assert
+  check_decoding_table();
+}
+
+TEST_F(ShrinkableEncodingBimapLabelSetFixture, CheckSaveSize) {
+  // Arrange
+  encoding_table_.find_or_emplace(ls_[0]);
+  encoding_table_.find_or_emplace(ls_[1]);
+
+  auto checkpoint = encoding_table_.checkpoint();
+
+  encoding_table_.shrink_to_checkpoint_size(checkpoint);
+
+  encoding_table_.find_or_emplace(ls_[1]);
+  encoding_table_.find_or_emplace(ls_[2]);
+  encoding_table_.find_or_emplace(ls_[3]);
+  encoding_table_.find_or_emplace(ls_[4]);
+  encoding_table_.find_or_emplace(ls_[5]);
+
+  auto checkpoint2 = encoding_table_.checkpoint();
+
+  auto delta = checkpoint2 - checkpoint;
+  BareBones::ShrinkedToFitOStringStream ss;
+  ss << delta;
+
+  // Act
+  const auto save_size = delta.save_size();
+
+  // Assert
+  EXPECT_EQ(ss.view().size(), save_size);
+}
+
 }  // namespace

From 3bc1b3b2c0a14b92b201a8d603049f96c3cf2a2f Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Thu, 18 Dec 2025 15:09:23 +0300
Subject: [PATCH 23/34] test fixes

---
 pp/primitives/snug_composites_filaments.h     |  39 +-
 pp/primitives/tests/snug_composites_tests.cpp | 369 +++++++++++-------
 2 files changed, 258 insertions(+), 150 deletions(-)

diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index 315e16e1a..ade029010 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -896,21 +896,24 @@ struct LabelSet {
     };
 
     struct label_sets_values_view {
-      using keys_view_type = label_name_sets_table_type::view_type::symbols_view;
-      using values_view_type = label_values_symbols_table_type::view_type;
+      using keys_view_type = label_name_sets_table_type::filament_type::storage_type::view_type::symbols_view_type;
+      using values_view_type = label_values_symbols_table_type::filament_type::storage_type::view_type;
+
       const storage_type* storage_ptr;
 
       class iterator_type {
        public:
         using iterator_category = std::input_iterator_tag;
-        using value_type = label_values_symbols_table_type::composite_type;
+        using value_type = label_values_symbols_table_type::value_type;
         using difference_type = std::ptrdiff_t;
 
         iterator_type() = default;
         explicit iterator_type(const symbols_tables_type& symbols_tables,
                                const keys_view_type::iterator_type& key_it,
                                const keys_view_type::iterator_type& key_it_end) noexcept
-            : symbols_tables_ptr_{&symbols_tables}, key_it_{key_it}, key_it_end_(key_it_end) {}
+            : symbols_tables_ptr_{&symbols_tables}, key_it_{key_it}, key_it_end_(key_it_end) {
+          get_values_range();
+        }
 
         iterator_type& operator++() noexcept {
           ++value_it_;
@@ -932,18 +935,20 @@ struct LabelSet {
 
         value_type operator*() const noexcept { return *value_it_; }
 
-        [[nodiscard]] uint32_t key_id() const noexcept { return key_it_->id(); }
-        [[nodiscard]] uint32_t value_id() const noexcept { return value_it_->id(); }
+        [[nodiscard]] uint32_t key_id() const noexcept { return key_it_.id(); }
+        [[nodiscard]] uint32_t value_id() const noexcept { return value_it_.id(); }
 
        private:
         void get_values_range() noexcept {
+          value_it_ = {};
+          value_it_end_ = {};
           while (key_it_ != key_it_end_) {
             if constexpr (BareBones::concepts::is_dereferenceable<typename symbols_tables_type::value_type>) {
-              const auto values_view = (*(*symbols_tables_ptr_)[key_it_.id()]).view();
+              const auto values_view = (*(*symbols_tables_ptr_)[key_it_.id()]).data_view();
               value_it_ = values_view.begin();
               value_it_end_ = values_view.end();
             } else {
-              const auto values_view = (*symbols_tables_ptr_)[key_it_.id()].view();
+              const auto values_view = (*symbols_tables_ptr_)[key_it_.id()].data_view();
               value_it_ = values_view.begin();
               value_it_end_ = values_view.end();
             }
@@ -957,15 +962,21 @@ struct LabelSet {
 
         const symbols_tables_type* symbols_tables_ptr_;
 
-        const keys_view_type::iterator_type key_it_;
-        const keys_view_type::iterator_type key_it_end_;
+        keys_view_type::iterator_type key_it_;
+        keys_view_type::iterator_type key_it_end_;
 
-        const values_view_type::iterator_type value_it_;
-        const values_view_type::iterator_type value_it_end_;
+        values_view_type::iterator_type value_it_;
+        values_view_type::iterator_type value_it_end_;
       };
 
-      auto begin() const noexcept { return iterator_type{storage_ptr, 0}; }
-      auto end() const noexcept { return iterator_type{storage_ptr, storage_ptr->items.size()}; }
+      auto begin() const noexcept {
+        return iterator_type{storage_ptr->symbols_tables, storage_ptr->label_name_sets_table.data_view().symbols().begin(),
+                             storage_ptr->label_name_sets_table.data_view().symbols().end()};
+      }
+      auto end() const noexcept {
+        return iterator_type{storage_ptr->symbols_tables, storage_ptr->label_name_sets_table.data_view().symbols().end(),
+                             storage_ptr->label_name_sets_table.data_view().symbols().end()};
+      }
     };
 
     struct label_set_view {
diff --git a/pp/primitives/tests/snug_composites_tests.cpp b/pp/primitives/tests/snug_composites_tests.cpp
index 7b5b66380..d8c7df721 100644
--- a/pp/primitives/tests/snug_composites_tests.cpp
+++ b/pp/primitives/tests/snug_composites_tests.cpp
@@ -8,13 +8,6 @@
 #include "primitives/snug_composites_filaments.h"
 
 namespace {
-
-template <class T>
-using SharedSpan = BareBones::SharedSpan<T, BareBones::DefaultReallocator>;
-
-template <class T>
-using SharedVector = BareBones::SharedVector<T, BareBones::DefaultReallocator>;
-
 using BareBones::Vector;
 using PromPP::Primitives::LabelViewSet;
 using std::operator""sv;
@@ -107,6 +100,40 @@ TEST_F(SymbolEncodingBimapTest, CheckpointAndRollback) {
   EXPECT_FALSE(encoding_table_.find(symbol2).has_value());
 }
 
+TEST_F(SymbolEncodingBimapTest, CreateViewFromEncodingBimap) {
+  // Arrange
+  encoding_table_.find_or_emplace("lol"s);
+  encoding_table_.find_or_emplace("kek"s);
+  encoding_table_.find_or_emplace("pod"s);
+  encoding_table_.find_or_emplace("job"s);
+
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  EXPECT_EQ(4U, view.size());
+  EXPECT_TRUE(std::ranges::equal(view, encoding_table_));
+}
+
+TEST_F(SymbolEncodingBimapTest, EncodingBimapViewIteratorId) {
+  // Arrange
+  const auto id1 = encoding_table_.find_or_emplace("lol"s);
+  const auto id2 = encoding_table_.find_or_emplace("kek"s);
+  const auto id3 = encoding_table_.find_or_emplace("pod"s);
+  const auto id4 = encoding_table_.find_or_emplace("job"s);
+
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  std::vector<uint32_t> view_ids;
+  view_ids.reserve(view.size());
+  for (auto it = view.begin(), e = view.end(); it != e; ++it) {
+    view_ids.push_back(it.id());
+  }
+  EXPECT_TRUE(std::ranges::equal(view_ids, std::initializer_list{id1, id2, id3, id4}));
+}
+
 class SymbolDecodingTableTest : public testing::Test {
  protected:
   PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_table_;
@@ -164,38 +191,6 @@ TEST_F(SymbolDecodingTableTest, CheckpointSaveSizeMatchesActualSize) {
   EXPECT_EQ(ss.view().size(), save_size);
 }
 
-TEST_F(SymbolEncodingBimapTest, CreateViewFromEncodingBimap) {
-  // Arrange
-  encoding_table_.find_or_emplace("lol"s);
-  encoding_table_.find_or_emplace("kek"s);
-  encoding_table_.find_or_emplace("pod"s);
-  encoding_table_.find_or_emplace("job"s);
-
-  // Act
-  const auto view = encoding_table_.data_view();
-
-  // Assert
-  EXPECT_EQ(4U, view.size());
-  EXPECT_TRUE(std::ranges::equal(view, encoding_table_));
-}
-
-TEST_F(SymbolEncodingBimapTest, EncodingBimapViewIteratorId) {
-  // Arrange
-  const auto id1 = encoding_table_.find_or_emplace("lol"s);
-  const auto id2 = encoding_table_.find_or_emplace("kek"s);
-  const auto id3 = encoding_table_.find_or_emplace("pod"s);
-  const auto id4 = encoding_table_.find_or_emplace("job"s);
-
-  // Act
-  auto view_iter = encoding_table_.data_view().begin();
-
-  // Assert
-  EXPECT_EQ(id1, (view_iter++).id());
-  EXPECT_EQ(id2, (view_iter++).id());
-  EXPECT_EQ(id3, (view_iter++).id());
-  EXPECT_EQ(id4, (view_iter++).id());
-}
-
 class LabelNameSetEncodingBimapTest : public testing::Test {
  protected:
   PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector> encoding_table_;
@@ -275,6 +270,45 @@ TEST_F(LabelNameSetEncodingBimapTest, CheckpointAndRollback) {
   EXPECT_TRUE(std::ranges::equal(label_set1.names(), *encoding_table_.begin()));
 }
 
+TEST_F(LabelNameSetEncodingBimapTest, CreateViewFromEncodingBimap) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
+  const LabelViewSet label_set3 = {{"d", "4"}, {"e", "5"}, {"f", "6"}};
+  encoding_table_.find_or_emplace(label_set1.names());
+  encoding_table_.find_or_emplace(label_set2.names());
+  encoding_table_.find_or_emplace(label_set3.names());
+
+  // Act
+  const auto symbols = encoding_table_.data_view().symbols();
+
+  // Assert
+  EXPECT_EQ(6U, symbols.size());
+  EXPECT_TRUE(std::ranges::equal(symbols, std::initializer_list{"a", "b", "c", "d", "e", "f"}));
+}
+
+TEST_F(LabelNameSetEncodingBimapTest, EncodingBimapViewIteratorId) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
+  const LabelViewSet label_set3 = {{"d", "4"}, {"e", "5"}, {"f", "6"}};
+
+  const auto id1 = encoding_table_.find_or_emplace(label_set1.names());
+  const auto id2 = encoding_table_.find_or_emplace(label_set2.names());
+  const auto id3 = encoding_table_.find_or_emplace(label_set3.names());
+
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  std::vector<uint32_t> view_ids;
+  view_ids.reserve(view.size());
+  for (auto it = view.begin(), e = view.end(); it != e; ++it) {
+    view_ids.push_back(it.id());
+  }
+  EXPECT_TRUE(std::ranges::equal(view_ids, std::initializer_list{id1, id2, id3}));
+}
+
 class LabelNameSetDecodingTableTest : public testing::Test {
  protected:
   PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector> encoding_table_;
@@ -319,23 +353,6 @@ TEST_F(LabelNameSetDecodingTableTest, IterateOverDecodingTable) {
       std::ranges::equal(decoding_table_, std::initializer_list{label_set1.names(), label_set2.names()}, [](const auto& a, const auto& b) { return a == b; }));
 }
 
-TEST_F(LabelNameSetDecodingTableTest, CreateViewFromEncodingBimap) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"a", "1"}};
-  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
-  const LabelViewSet label_set3 = {{"d", "4"}, {"e", "5"}, {"f", "6"}};
-  encoding_table_.find_or_emplace(label_set1.names());
-  encoding_table_.find_or_emplace(label_set2.names());
-  encoding_table_.find_or_emplace(label_set3.names());
-
-  // Act
-  const auto symbols = encoding_table_.data_view().symbols();
-
-  // Assert
-  EXPECT_EQ(6U, symbols.size());
-  EXPECT_TRUE(std::ranges::equal(symbols, std::initializer_list{"a", "b", "c", "d", "e", "f"}));
-}
-
 class LabelSetEncodingBimapTest : public testing::Test {
  protected:
   PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_table_;
@@ -413,6 +430,74 @@ TEST_F(LabelSetEncodingBimapTest, CheckpointAndRollback) {
   EXPECT_FALSE(encoding_table_.find(label_set2).has_value());
 }
 
+TEST_F(LabelSetEncodingBimapTest, CreateViewFromEncodingBimap) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"job", "1"}};
+  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
+  const LabelViewSet label_set3 = {{"job", "3"}, {"run", "first"}, {"pod", "b"}};
+
+  encoding_table_.find_or_emplace(label_set1);
+  encoding_table_.find_or_emplace(label_set2);
+  encoding_table_.find_or_emplace(label_set3);
+
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  EXPECT_EQ(3U, view.size());
+  EXPECT_EQ(3U, view.labels_keys().size());
+  EXPECT_TRUE(std::ranges::equal(view.labels_keys(), std::initializer_list{"job", "pod", "run"}));
+  EXPECT_TRUE(std::ranges::equal(view.labels_values(), std::initializer_list{"1", "2", "3", "a", "b", "first"}));
+}
+
+TEST_F(LabelSetEncodingBimapTest, EncodingBimapViewCheckId) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"job", "1"}};
+  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
+  const LabelViewSet label_set3 = {{"job", "3"}, {"run", "first"}, {"pod", "b"}};
+  const auto id1 = encoding_table_.find_or_emplace(label_set1);
+  const auto id2 = encoding_table_.find_or_emplace(label_set2);
+  const auto id3 = encoding_table_.find_or_emplace(label_set3);
+
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  std::vector<uint32_t> view_ids;
+  view_ids.reserve(view.size());
+  for (auto it = view.begin(), e = view.end(); it != e; ++it) {
+    view_ids.push_back(it.id());
+  }
+  EXPECT_TRUE(std::ranges::equal(view_ids, std::initializer_list{id1, id2, id3}));
+}
+
+TEST_F(LabelSetEncodingBimapTest, EncodingBimapViewCheckKeyId) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"job", "1"}};
+  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
+  const LabelViewSet label_set3 = {{"job", "3"}, {"run", "first"}, {"pod", "b"}};
+
+  encoding_table_.find_or_emplace(label_set1);
+  encoding_table_.find_or_emplace(label_set2);
+  encoding_table_.find_or_emplace(label_set3);
+
+  const auto view = encoding_table_.data_view();
+
+  auto k_it = view.labels_keys().begin();
+  const auto job_id = (k_it++).id();
+  const auto pod_id = (k_it++).id();
+  const auto run_id = (k_it++).id();
+
+  // Act
+  std::vector<uint32_t> view_value_symbols_ids;
+  for (auto it = view.labels_values().begin(), e = view.labels_values().end(); it != e; ++it) {
+    view_value_symbols_ids.push_back(it.key_id());
+  }
+
+  // Assert
+  EXPECT_TRUE(std::ranges::equal(view_value_symbols_ids, std::initializer_list{job_id, job_id, job_id, pod_id, pod_id, run_id}));
+}
+
 class LabelSetDecodingTableTest : public testing::Test {
  protected:
   PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_table_;
@@ -456,61 +541,6 @@ TEST_F(LabelSetDecodingTableTest, IterateOverDecodingTable) {
   EXPECT_TRUE(std::ranges::equal(decoding_table_, std::initializer_list{label_set1, label_set2}, [](const auto& a, const auto& b) { return a == b; }));
 }
 
-class LabelSetViewTest : public testing::Test {
- protected:
-  using LabelSetEncodingBimap = PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<SharedVector>;
-  using LabelSetDecodingTable = PromPP::Primitives::SnugComposites::LabelSet::DecodingTable<SharedSpan>;
-};
-
-TEST_F(LabelSetViewTest, CreateViewFromEncodingBimap) {
-  // Arrange
-  LabelSetEncodingBimap source;
-  const LabelViewSet source_data = {{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
-  source.find_or_emplace(source_data);
-
-  // Act
-  const LabelSetDecodingTable view(source);
-  source.find_or_emplace(LabelViewSet{{"name4", "value4"}});
-
-  // Assert
-  EXPECT_EQ(1U, view.size());
-  EXPECT_TRUE(std::ranges::equal(source_data, view[0], [](const auto& a, const auto& b) { return a == b; }));
-}
-
-TEST_F(LabelSetViewTest, ViewRemainsValidAfterSourceModification) {
-  // Arrange
-  auto source = std::make_unique<LabelSetEncodingBimap>();
-  const LabelViewSet source_data = {{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
-  source->find_or_emplace(source_data);
-
-  // Act
-  const LabelSetDecodingTable view(*source);
-  source.reset();
-
-  // Assert
-  EXPECT_EQ(1U, view.size());
-  EXPECT_TRUE(std::ranges::equal(source_data, view[0], [](const auto& a, const auto& b) { return a == b; }));
-}
-
-TEST_F(LabelSetViewTest, AccessViewDataView) {
-  // Arrange
-  LabelSetEncodingBimap source;
-  const LabelViewSet label_set1 = {{"a", "1"}};
-  const LabelViewSet label_set2 = {{"b", "2"}};
-  source.find_or_emplace(label_set1);
-  source.find_or_emplace(label_set2);
-  const LabelSetDecodingTable view(source);
-
-  // Act
-  const auto data_view = view.data_view();
-
-  // Assert
-  EXPECT_EQ(2U, data_view.size());
-  auto it = data_view.begin();
-  EXPECT_TRUE(std::ranges::equal(label_set1, *it++, [](const auto& a, const auto& b) { return a == b; }));
-  EXPECT_TRUE(std::ranges::equal(label_set2, *it++, [](const auto& a, const auto& b) { return a == b; }));
-}
-
 class SymbolDeltaCheckpointTest : public testing::Test {
  protected:
   PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_table_;
@@ -558,23 +588,12 @@ class ShrinkableEncodingBimapLabelSetFixture : public testing::Test {
 
   void check_decoding_table() const {
     ASSERT_EQ(3U, decoding_table_.size());
-    {
-      auto composite = decoding_table_[0];
-      ASSERT_EQ(2U, composite.size());
-      auto it = composite.begin();
-      EXPECT_EQ((std::pair<std::string_view, std::string_view>("1", "1")), *it++);
-      EXPECT_EQ((std::pair<std::string_view, std::string_view>("2", "2")), *it);
-    }
-    {
-      auto composite = decoding_table_[1];
-      ASSERT_EQ(1U, composite.size());
-      EXPECT_EQ((std::pair<std::string_view, std::string_view>("3", "3")), *composite.begin());
-    }
-    {
-      auto composite = decoding_table_[2];
-      ASSERT_EQ(1U, composite.size());
-      EXPECT_EQ((std::pair<std::string_view, std::string_view>("4", "4")), *composite.begin());
-    }
+    const LabelViewSet expected_label_set0{{"1", "1"}, {"2", "2"}};
+    const LabelViewSet expected_label_set1{{"3", "3"}};
+    const LabelViewSet expected_label_set2{{"4", "4"}};
+    EXPECT_TRUE(std::ranges::equal(expected_label_set0, decoding_table_[0]));
+    EXPECT_TRUE(std::ranges::equal(expected_label_set1, decoding_table_[1]));
+    EXPECT_TRUE(std::ranges::equal(expected_label_set2, decoding_table_[2]));
   }
 };
 
@@ -620,21 +639,21 @@ TEST_F(ShrinkableEncodingBimapLabelSetFixture, LoadWithoutShrink) {
 
 TEST_F(ShrinkableEncodingBimapLabelSetFixture, LoadFromNonShrinkableTable) {
   // Arrange
-  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> lss;
+  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> non_shrinkable_encoding_bimap;
   std::stringstream stream;
 
   // Act
-  lss.find_or_emplace(LabelViewSet{{"process", "php"}});
-  lss.find_or_emplace(LabelViewSet{{"process", "nodejs"}});
-  lss.find_or_emplace(LabelViewSet{{"process", "python"}});
-  const auto checkpoint = lss.checkpoint();
+  non_shrinkable_encoding_bimap.find_or_emplace(LabelViewSet{{"process", "php"}});
+  non_shrinkable_encoding_bimap.find_or_emplace(LabelViewSet{{"process", "nodejs"}});
+  non_shrinkable_encoding_bimap.find_or_emplace(LabelViewSet{{"process", "python"}});
+  const auto checkpoint = non_shrinkable_encoding_bimap.checkpoint();
   stream << checkpoint;
   stream >> encoding_table_;
   encoding_table_.shrink_to_checkpoint_size(encoding_table_.checkpoint());
 
-  const auto nginx_id = lss.find_or_emplace(LabelViewSet{{"process", "nginx"}});
-  const auto apache_id = lss.find_or_emplace(LabelViewSet{{"process", "apache"}});
-  stream << lss.checkpoint() - checkpoint;
+  const auto nginx_id = non_shrinkable_encoding_bimap.find_or_emplace(LabelViewSet{{"process", "nginx"}});
+  const auto apache_id = non_shrinkable_encoding_bimap.find_or_emplace(LabelViewSet{{"process", "apache"}});
+  stream << non_shrinkable_encoding_bimap.checkpoint() - checkpoint;
   stream >> encoding_table_;
 
   // Assert
@@ -710,4 +729,82 @@ TEST_F(ShrinkableEncodingBimapLabelSetFixture, CheckSaveSize) {
   EXPECT_EQ(ss.view().size(), save_size);
 }
 
+class SharedDataFixture : public testing::Test {
+ protected:
+  template <class T>
+  using SharedVector = BareBones::SharedVector<T, BareBones::DefaultReallocator>;
+
+  template <class T>
+  using SharedSpan = BareBones::SharedSpan<T, BareBones::DefaultReallocator>;
+
+  using SymbolEncodingBimap = PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<SharedVector>;
+  using SymbolDecodingTable = PromPP::Primitives::SnugComposites::Symbol::DecodingTable<SharedSpan>;
+
+  using LabelNameSetEncodingBimap = PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<SharedVector>;
+  using LabelNameSetDecodingTable = PromPP::Primitives::SnugComposites::LabelNameSet::DecodingTable<SharedSpan>;
+
+  using LabelSetEncodingBimap = PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<SharedVector>;
+  using LabelSetDecodingTable = PromPP::Primitives::SnugComposites::LabelSet::DecodingTable<SharedSpan>;
+};
+
+TEST_F(SharedDataFixture, CopySymbol) {
+  // Arrange
+  SymbolEncodingBimap encoding_bimap;
+  constexpr auto symbol = "string1"sv;
+  encoding_bimap.find_or_emplace(symbol);
+
+  // Act
+  const SymbolDecodingTable decoding_table(encoding_bimap);
+  encoding_bimap.find_or_emplace("string2"sv);
+
+  // Assert
+  EXPECT_EQ(1U, decoding_table.size());
+  EXPECT_EQ(symbol, decoding_table[0]);
+}
+
+TEST_F(SharedDataFixture, CopyLabelNameSet) {
+  // Arrange
+  LabelNameSetEncodingBimap encoding_bimap;
+  const LabelViewSet label_set{{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
+  encoding_bimap.find_or_emplace(label_set.names());
+
+  // Act
+  const LabelNameSetDecodingTable decoding_table(encoding_bimap);
+  encoding_bimap.find_or_emplace(LabelViewSet{{"name4", "value4"}}.names());
+
+  // Assert
+  EXPECT_EQ(1U, decoding_table.size());
+  EXPECT_TRUE(std::ranges::equal(label_set.names(), decoding_table[0]));
+}
+
+TEST_F(SharedDataFixture, CopyLabelSet) {
+  // Arrange
+  LabelSetEncodingBimap encoding_bimap;
+  const LabelViewSet label_set{{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
+  encoding_bimap.find_or_emplace(label_set);
+
+  // Act
+  const LabelSetDecodingTable decoding_table(encoding_bimap);
+  encoding_bimap.find_or_emplace(LabelViewSet{{"name4", "value4"}});
+
+  // Assert
+  EXPECT_EQ(1U, decoding_table.size());
+  EXPECT_TRUE(std::ranges::equal(label_set, decoding_table[0]));
+}
+
+TEST_F(SharedDataFixture, UseCopyLabelSetAfterFreeSourceLabelSet) {
+  // Arrange
+  auto encoding_bimap = std::make_unique<LabelSetEncodingBimap>();
+  const LabelViewSet label_set{{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
+  encoding_bimap->find_or_emplace(label_set);
+
+  // Act
+  const LabelSetDecodingTable decoding_table(*encoding_bimap);
+  encoding_bimap.reset();
+
+  // Assert
+  EXPECT_EQ(1U, decoding_table.size());
+  EXPECT_TRUE(std::ranges::equal(label_set, decoding_table[0]));
+}
+
 }  // namespace

From 8aac165e64d5a54956e20449cfc300f763c390ad Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Thu, 18 Dec 2025 15:13:20 +0300
Subject: [PATCH 24/34] test fixes

---
 pp/primitives/tests/snug_composites_tests.cpp | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/pp/primitives/tests/snug_composites_tests.cpp b/pp/primitives/tests/snug_composites_tests.cpp
index d8c7df721..3eddb0031 100644
--- a/pp/primitives/tests/snug_composites_tests.cpp
+++ b/pp/primitives/tests/snug_composites_tests.cpp
@@ -548,12 +548,66 @@ class SymbolDeltaCheckpointTest : public testing::Test {
 
 TEST_F(SymbolDeltaCheckpointTest, DeltaCheckpointSaveSize) {
   // Arrange
+  BareBones::ShrinkedToFitOStringStream ss;
+
   encoding_table_.find_or_emplace("first"sv);
   const auto base_checkpoint = encoding_table_.checkpoint();
   encoding_table_.find_or_emplace("second"sv);
+
+  const auto checkpoint = encoding_table_.checkpoint();
+  const auto delta = checkpoint - base_checkpoint;
+
+  // Act
+  ss << delta;
+  const auto save_size = delta.save_size();
+
+  // Assert
+  EXPECT_EQ(ss.view().size(), save_size);
+}
+
+class LabelNameSetDeltaCheckpointTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector> encoding_table_;
+};
+
+TEST_F(LabelNameSetDeltaCheckpointTest, DeltaCheckpointSaveSize) {
+  // Arrange
+  BareBones::ShrinkedToFitOStringStream ss;
+
+  const LabelViewSet label_set1 = {{"name1", "value1"}};
+  const LabelViewSet label_set2 = {{"name2", "value2"}, {"name3", "value3"}};
+
+  encoding_table_.find_or_emplace(label_set1.names());
+  const auto base_checkpoint = encoding_table_.checkpoint();
+  encoding_table_.find_or_emplace(label_set2.names());
   const auto checkpoint = encoding_table_.checkpoint();
   const auto delta = checkpoint - base_checkpoint;
+
+  // Act
+  ss << delta;
+  const auto save_size = delta.save_size();
+
+  // Assert
+  EXPECT_EQ(ss.view().size(), save_size);
+}
+
+class LabelSetDeltaCheckpointTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_table_;
+};
+
+TEST_F(LabelSetDeltaCheckpointTest, DeltaCheckpointSaveSize) {
+  // Arrange
   BareBones::ShrinkedToFitOStringStream ss;
+  const LabelViewSet label_set1 = {{"name1", "value1"}};
+  const LabelViewSet label_set2 = {{"name2", "value2"}, {"name3", "value3"}};
+
+  encoding_table_.find_or_emplace(label_set1);
+  const auto base_checkpoint = encoding_table_.checkpoint();
+  encoding_table_.find_or_emplace(label_set2);
+
+  const auto checkpoint = encoding_table_.checkpoint();
+  const auto delta = checkpoint - base_checkpoint;
 
   // Act
   ss << delta;

From 429150a2da76eac5d54b6c3a05e249e09a25b303 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Thu, 18 Dec 2025 15:22:50 +0300
Subject: [PATCH 25/34] delta tests

---
 pp/primitives/tests/snug_composites_tests.cpp | 78 +++++++++++++++++++
 1 file changed, 78 insertions(+)

diff --git a/pp/primitives/tests/snug_composites_tests.cpp b/pp/primitives/tests/snug_composites_tests.cpp
index 3eddb0031..541595875 100644
--- a/pp/primitives/tests/snug_composites_tests.cpp
+++ b/pp/primitives/tests/snug_composites_tests.cpp
@@ -544,6 +544,7 @@ TEST_F(LabelSetDecodingTableTest, IterateOverDecodingTable) {
 class SymbolDeltaCheckpointTest : public testing::Test {
  protected:
   PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_table_;
+  PromPP::Primitives::SnugComposites::Symbol::DecodingTable<Vector> decoding_table_;
 };
 
 TEST_F(SymbolDeltaCheckpointTest, DeltaCheckpointSaveSize) {
@@ -565,9 +566,35 @@ TEST_F(SymbolDeltaCheckpointTest, DeltaCheckpointSaveSize) {
   EXPECT_EQ(ss.view().size(), save_size);
 }
 
+TEST_F(SymbolDeltaCheckpointTest, LoadFromBaseCheckpointAndDelta) {
+  // Arrange
+  std::stringstream ss;
+  const std::string symbol1 = "first";
+  const std::string symbol2 = "second";
+
+  const auto id1 = encoding_table_.find_or_emplace(symbol1);
+  const auto base_checkpoint = encoding_table_.checkpoint();
+  const auto id2 = encoding_table_.find_or_emplace(symbol2);
+  const auto checkpoint = encoding_table_.checkpoint();
+  const auto delta = checkpoint - base_checkpoint;
+
+  base_checkpoint.save(ss);
+  ss << delta;
+
+  // Act
+  decoding_table_.load(ss);
+  decoding_table_.load(ss);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_EQ(symbol1, decoding_table_[id1]);
+  EXPECT_EQ(symbol2, decoding_table_[id2]);
+}
+
 class LabelNameSetDeltaCheckpointTest : public testing::Test {
  protected:
   PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector> encoding_table_;
+  PromPP::Primitives::SnugComposites::LabelNameSet::DecodingTable<Vector> decoding_table_;
 };
 
 TEST_F(LabelNameSetDeltaCheckpointTest, DeltaCheckpointSaveSize) {
@@ -591,9 +618,34 @@ TEST_F(LabelNameSetDeltaCheckpointTest, DeltaCheckpointSaveSize) {
   EXPECT_EQ(ss.view().size(), save_size);
 }
 
+TEST_F(LabelNameSetDeltaCheckpointTest, LoadFromBaseCheckpointAndDelta) {
+  // Arrange
+  std::stringstream ss;
+  const LabelViewSet label_set1 = {{"name1", "value1"}};
+  const LabelViewSet label_set2 = {{"name2", "value2"}, {"name3", "value3"}};
+  const auto id1 = encoding_table_.find_or_emplace(label_set1.names());
+  const auto base_checkpoint = encoding_table_.checkpoint();
+  const auto id2 = encoding_table_.find_or_emplace(label_set2.names());
+  const auto checkpoint = encoding_table_.checkpoint();
+  const auto delta = checkpoint - base_checkpoint;
+
+  base_checkpoint.save(ss);
+  ss << delta;
+
+  // Act
+  decoding_table_.load(ss);
+  decoding_table_.load(ss);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1.names(), decoding_table_[id1]));
+  EXPECT_TRUE(std::ranges::equal(label_set2.names(), decoding_table_[id2]));
+}
+
 class LabelSetDeltaCheckpointTest : public testing::Test {
  protected:
   PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_table_;
+  PromPP::Primitives::SnugComposites::LabelSet::DecodingTable<Vector> decoding_table_;
 };
 
 TEST_F(LabelSetDeltaCheckpointTest, DeltaCheckpointSaveSize) {
@@ -617,6 +669,32 @@ TEST_F(LabelSetDeltaCheckpointTest, DeltaCheckpointSaveSize) {
   EXPECT_EQ(ss.view().size(), save_size);
 }
 
+TEST_F(LabelSetDeltaCheckpointTest, LoadFromBaseCheckpointAndDelta) {
+  // Arrange
+  std::stringstream ss;
+  const LabelViewSet label_set1 = {{"name1", "value1"}};
+  const LabelViewSet label_set2 = {{"name2", "value2"}, {"name3", "value3"}};
+
+  const auto id1 = encoding_table_.find_or_emplace(label_set1);
+  const auto base_checkpoint = encoding_table_.checkpoint();
+  const auto id2 = encoding_table_.find_or_emplace(label_set2);
+  const auto checkpoint = encoding_table_.checkpoint();
+  const auto delta = checkpoint - base_checkpoint;
+
+  base_checkpoint.save(ss);
+  ss << delta;
+
+  // Act
+  std::stringstream read_stream(ss.str());
+  decoding_table_.load(read_stream);
+  decoding_table_.load(read_stream);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1, decoding_table_[id1]));
+  EXPECT_TRUE(std::ranges::equal(label_set2, decoding_table_[id2]));
+}
+
 class ShrinkableEncodingBimapLabelSetFixture : public testing::Test {
  protected:
   PromPP::Primitives::SnugComposites::LabelSet::ShrinkableEncodingBimap<Vector> encoding_table_;

From c07961d9b9df78883a85c977f0e88bd5af88bd66 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Thu, 18 Dec 2025 15:38:43 +0300
Subject: [PATCH 26/34] tests decomposition

---
 pp/primitives/tests/label_name_set_tests.cpp  | 228 ++++++
 pp/primitives/tests/label_set_tests.cpp       | 256 +++++++
 pp/primitives/tests/snug_composites_tests.cpp | 684 ------------------
 pp/primitives/tests/symbol_tests.cpp          | 241 ++++++
 4 files changed, 725 insertions(+), 684 deletions(-)
 create mode 100644 pp/primitives/tests/label_name_set_tests.cpp
 create mode 100644 pp/primitives/tests/label_set_tests.cpp
 create mode 100644 pp/primitives/tests/symbol_tests.cpp

diff --git a/pp/primitives/tests/label_name_set_tests.cpp b/pp/primitives/tests/label_name_set_tests.cpp
new file mode 100644
index 000000000..9f878fa2e
--- /dev/null
+++ b/pp/primitives/tests/label_name_set_tests.cpp
@@ -0,0 +1,228 @@
+#include <sstream>
+
+#include "gtest/gtest.h"
+
+#include "bare_bones/streams.h"
+#include "primitives/label_set.h"
+#include "primitives/snug_composites.h"
+
+namespace {
+using BareBones::Vector;
+using PromPP::Primitives::LabelViewSet;
+using std::operator""sv;
+using std::string_literals::operator""s;
+
+class LabelNameSetEncodingBimapTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector> encoding_table_;
+};
+
+TEST_F(LabelNameSetEncodingBimapTest, StoreAndRetrieveLabelNameSet) {
+  // Arrange
+  const LabelViewSet label_set = {{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
+
+  // Act
+  const auto id = encoding_table_.find_or_emplace(label_set.names());
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  const auto retrieved = encoding_table_[id];
+  EXPECT_TRUE(std::ranges::equal(label_set.names(), retrieved));
+}
+
+TEST_F(LabelNameSetEncodingBimapTest, StoreMultipleLabelNameSets) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}, {"b", "2"}};
+  const LabelViewSet label_set2 = {{"c", "3"}, {"d", "4"}, {"e", "5"}};
+
+  // Act
+  const auto id1 = encoding_table_.find_or_emplace(label_set1.names());
+  const auto id2 = encoding_table_.find_or_emplace(label_set2.names());
+
+  // Assert
+  EXPECT_EQ(2U, encoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1.names(), encoding_table_[id1]));
+  EXPECT_TRUE(std::ranges::equal(label_set2.names(), encoding_table_[id2]));
+}
+
+TEST_F(LabelNameSetEncodingBimapTest, FindOrEmplaceReturnsSameIdForDuplicate) {
+  // Arrange
+  const LabelViewSet label_set = {{"duplicate", "value1"}, {"set", "value2"}};
+
+  // Act
+  const auto id1 = encoding_table_.find_or_emplace(label_set.names());
+  const auto id2 = encoding_table_.find_or_emplace(label_set.names());
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_EQ(id1, id2);
+}
+
+TEST_F(LabelNameSetEncodingBimapTest, IterateOverLabelNameSets) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
+
+  // Act
+  encoding_table_.find_or_emplace(label_set1.names());
+  encoding_table_.find_or_emplace(label_set2.names());
+
+  // Assert
+  EXPECT_EQ(2U, encoding_table_.size());
+  auto it = encoding_table_.begin();
+  EXPECT_TRUE(std::ranges::equal(label_set1.names(), *it++));
+  EXPECT_TRUE(std::ranges::equal(label_set2.names(), *it++));
+  EXPECT_EQ(encoding_table_.end(), it);
+}
+
+TEST_F(LabelNameSetEncodingBimapTest, CheckpointAndRollback) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"before", "checkpoint"}};
+  const LabelViewSet label_set2 = {{"after", "checkpoint"}};
+
+  // Act
+  encoding_table_.find_or_emplace(label_set1.names());
+  const auto checkpoint = encoding_table_.checkpoint();
+  encoding_table_.find_or_emplace(label_set2.names());
+  encoding_table_.rollback(checkpoint);
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1.names(), *encoding_table_.begin()));
+}
+
+TEST_F(LabelNameSetEncodingBimapTest, CreateViewFromEncodingBimap) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
+  const LabelViewSet label_set3 = {{"d", "4"}, {"e", "5"}, {"f", "6"}};
+  encoding_table_.find_or_emplace(label_set1.names());
+  encoding_table_.find_or_emplace(label_set2.names());
+  encoding_table_.find_or_emplace(label_set3.names());
+
+  // Act
+  const auto symbols = encoding_table_.data_view().symbols();
+
+  // Assert
+  EXPECT_EQ(6U, symbols.size());
+  EXPECT_TRUE(std::ranges::equal(symbols, std::initializer_list{"a", "b", "c", "d", "e", "f"}));
+}
+
+TEST_F(LabelNameSetEncodingBimapTest, EncodingBimapViewIteratorId) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
+  const LabelViewSet label_set3 = {{"d", "4"}, {"e", "5"}, {"f", "6"}};
+
+  const auto id1 = encoding_table_.find_or_emplace(label_set1.names());
+  const auto id2 = encoding_table_.find_or_emplace(label_set2.names());
+  const auto id3 = encoding_table_.find_or_emplace(label_set3.names());
+
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  std::vector<uint32_t> view_ids;
+  view_ids.reserve(view.size());
+  for (auto it = view.begin(), e = view.end(); it != e; ++it) {
+    view_ids.push_back(it.id());
+  }
+  EXPECT_TRUE(std::ranges::equal(view_ids, std::initializer_list{id1, id2, id3}));
+}
+
+class LabelNameSetDecodingTableTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector> encoding_table_;
+  PromPP::Primitives::SnugComposites::LabelNameSet::DecodingTable<Vector> decoding_table_;
+};
+
+TEST_F(LabelNameSetDecodingTableTest, LoadFromCheckpoint) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"first", "1"}};
+  const LabelViewSet label_set2 = {{"second", "2"}, {"third", "3"}};
+  const auto id1 = encoding_table_.find_or_emplace(label_set1.names());
+  const auto id2 = encoding_table_.find_or_emplace(label_set2.names());
+  const auto checkpoint = encoding_table_.checkpoint();
+
+  // Act
+  std::stringstream ss;
+  checkpoint.save(ss);
+  decoding_table_.load(ss);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1.names(), decoding_table_[id1]));
+  EXPECT_TRUE(std::ranges::equal(label_set2.names(), decoding_table_[id2]));
+}
+
+TEST_F(LabelNameSetDecodingTableTest, IterateOverDecodingTable) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
+  encoding_table_.find_or_emplace(label_set1.names());
+  encoding_table_.find_or_emplace(label_set2.names());
+  const auto checkpoint = encoding_table_.checkpoint();
+
+  // Act
+  std::stringstream ss;
+  checkpoint.save(ss);
+  decoding_table_.load(ss);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_TRUE(
+      std::ranges::equal(decoding_table_, std::initializer_list{label_set1.names(), label_set2.names()}, [](const auto& a, const auto& b) { return a == b; }));
+}
+
+class LabelNameSetDeltaCheckpointTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector> encoding_table_;
+  PromPP::Primitives::SnugComposites::LabelNameSet::DecodingTable<Vector> decoding_table_;
+};
+
+TEST_F(LabelNameSetDeltaCheckpointTest, DeltaCheckpointSaveSize) {
+  // Arrange
+  BareBones::ShrinkedToFitOStringStream ss;
+
+  const LabelViewSet label_set1 = {{"name1", "value1"}};
+  const LabelViewSet label_set2 = {{"name2", "value2"}, {"name3", "value3"}};
+
+  encoding_table_.find_or_emplace(label_set1.names());
+  const auto base_checkpoint = encoding_table_.checkpoint();
+  encoding_table_.find_or_emplace(label_set2.names());
+  const auto checkpoint = encoding_table_.checkpoint();
+  const auto delta = checkpoint - base_checkpoint;
+
+  // Act
+  ss << delta;
+  const auto save_size = delta.save_size();
+
+  // Assert
+  EXPECT_EQ(ss.view().size(), save_size);
+}
+
+TEST_F(LabelNameSetDeltaCheckpointTest, LoadFromBaseCheckpointAndDelta) {
+  // Arrange
+  std::stringstream ss;
+  const LabelViewSet label_set1 = {{"name1", "value1"}};
+  const LabelViewSet label_set2 = {{"name2", "value2"}, {"name3", "value3"}};
+  const auto id1 = encoding_table_.find_or_emplace(label_set1.names());
+  const auto base_checkpoint = encoding_table_.checkpoint();
+  const auto id2 = encoding_table_.find_or_emplace(label_set2.names());
+  const auto checkpoint = encoding_table_.checkpoint();
+  const auto delta = checkpoint - base_checkpoint;
+
+  base_checkpoint.save(ss);
+  ss << delta;
+
+  // Act
+  decoding_table_.load(ss);
+  decoding_table_.load(ss);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1.names(), decoding_table_[id1]));
+  EXPECT_TRUE(std::ranges::equal(label_set2.names(), decoding_table_[id2]));
+}
+
+}  // namespace
diff --git a/pp/primitives/tests/label_set_tests.cpp b/pp/primitives/tests/label_set_tests.cpp
new file mode 100644
index 000000000..53f662e17
--- /dev/null
+++ b/pp/primitives/tests/label_set_tests.cpp
@@ -0,0 +1,256 @@
+#include <sstream>
+
+#include "gtest/gtest.h"
+
+#include "bare_bones/streams.h"
+#include "primitives/label_set.h"
+#include "primitives/snug_composites.h"
+
+namespace {
+using BareBones::Vector;
+using PromPP::Primitives::LabelViewSet;
+using std::operator""sv;
+using std::string_literals::operator""s;
+
+class LabelSetEncodingBimapTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_table_;
+};
+
+TEST_F(LabelSetEncodingBimapTest, StoreAndRetrieveLabelSet) {
+  // Arrange
+  const LabelViewSet label_set = {{"name1", "value1"}, {"name2", "value2"}};
+
+  // Act
+  const auto id = encoding_table_.find_or_emplace(label_set);
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  const auto retrieved = encoding_table_[id];
+  EXPECT_TRUE(std::ranges::equal(label_set, retrieved));
+}
+
+TEST_F(LabelSetEncodingBimapTest, StoreMultipleLabelSets) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
+
+  // Act
+  const auto id1 = encoding_table_.find_or_emplace(label_set1);
+  const auto id2 = encoding_table_.find_or_emplace(label_set2);
+
+  // Assert
+  EXPECT_EQ(2U, encoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1, encoding_table_[id1]));
+  EXPECT_TRUE(std::ranges::equal(label_set2, encoding_table_[id2]));
+}
+
+TEST_F(LabelSetEncodingBimapTest, FindOrEmplaceReturnsSameIdForDuplicate) {
+  // Arrange
+  const LabelViewSet label_set = {{"duplicate", "set"}};
+
+  // Act
+  const auto id1 = encoding_table_.find_or_emplace(label_set);
+  const auto id2 = encoding_table_.find_or_emplace(label_set);
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_EQ(id1, id2);
+}
+
+TEST_F(LabelSetEncodingBimapTest, IterateOverLabelSets) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
+
+  // Act
+  encoding_table_.find_or_emplace(label_set1);
+  encoding_table_.find_or_emplace(label_set2);
+
+  // Assert
+  EXPECT_EQ(2U, encoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(encoding_table_, std::initializer_list{label_set1, label_set2}, [](const auto& a, const auto& b) { return a == b; }));
+}
+
+TEST_F(LabelSetEncodingBimapTest, CheckpointAndRollback) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"before", "checkpoint"}};
+  const LabelViewSet label_set2 = {{"after", "checkpoint"}};
+
+  // Act
+  const auto id1 = encoding_table_.find_or_emplace(label_set1);
+  const auto checkpoint = encoding_table_.checkpoint();
+  encoding_table_.find_or_emplace(label_set2);
+  encoding_table_.rollback(checkpoint);
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_EQ(id1, encoding_table_.find(label_set1).value());
+  EXPECT_FALSE(encoding_table_.find(label_set2).has_value());
+}
+
+TEST_F(LabelSetEncodingBimapTest, CreateViewFromEncodingBimap) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"job", "1"}};
+  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
+  const LabelViewSet label_set3 = {{"job", "3"}, {"run", "first"}, {"pod", "b"}};
+
+  encoding_table_.find_or_emplace(label_set1);
+  encoding_table_.find_or_emplace(label_set2);
+  encoding_table_.find_or_emplace(label_set3);
+
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  EXPECT_EQ(3U, view.size());
+  EXPECT_EQ(3U, view.labels_keys().size());
+  EXPECT_TRUE(std::ranges::equal(view.labels_keys(), std::initializer_list{"job", "pod", "run"}));
+  EXPECT_TRUE(std::ranges::equal(view.labels_values(), std::initializer_list{"1", "2", "3", "a", "b", "first"}));
+}
+
+TEST_F(LabelSetEncodingBimapTest, EncodingBimapViewCheckId) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"job", "1"}};
+  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
+  const LabelViewSet label_set3 = {{"job", "3"}, {"run", "first"}, {"pod", "b"}};
+  const auto id1 = encoding_table_.find_or_emplace(label_set1);
+  const auto id2 = encoding_table_.find_or_emplace(label_set2);
+  const auto id3 = encoding_table_.find_or_emplace(label_set3);
+
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  std::vector<uint32_t> view_ids;
+  view_ids.reserve(view.size());
+  for (auto it = view.begin(), e = view.end(); it != e; ++it) {
+    view_ids.push_back(it.id());
+  }
+  EXPECT_TRUE(std::ranges::equal(view_ids, std::initializer_list{id1, id2, id3}));
+}
+
+TEST_F(LabelSetEncodingBimapTest, EncodingBimapViewCheckKeyId) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"job", "1"}};
+  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
+  const LabelViewSet label_set3 = {{"job", "3"}, {"run", "first"}, {"pod", "b"}};
+
+  encoding_table_.find_or_emplace(label_set1);
+  encoding_table_.find_or_emplace(label_set2);
+  encoding_table_.find_or_emplace(label_set3);
+
+  const auto view = encoding_table_.data_view();
+
+  auto k_it = view.labels_keys().begin();
+  const auto job_id = (k_it++).id();
+  const auto pod_id = (k_it++).id();
+  const auto run_id = (k_it++).id();
+
+  // Act
+  std::vector<uint32_t> view_value_symbols_ids;
+  for (auto it = view.labels_values().begin(), e = view.labels_values().end(); it != e; ++it) {
+    view_value_symbols_ids.push_back(it.key_id());
+  }
+
+  // Assert
+  EXPECT_TRUE(std::ranges::equal(view_value_symbols_ids, std::initializer_list{job_id, job_id, job_id, pod_id, pod_id, run_id}));
+}
+
+class LabelSetDecodingTableTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_table_;
+  PromPP::Primitives::SnugComposites::LabelSet::DecodingTable<Vector> decoding_table_;
+};
+
+TEST_F(LabelSetDecodingTableTest, LoadFromCheckpoint) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"first", "1"}};
+  const LabelViewSet label_set2 = {{"second", "2"}, {"third", "3"}};
+  const auto id1 = encoding_table_.find_or_emplace(label_set1);
+  const auto id2 = encoding_table_.find_or_emplace(label_set2);
+  const auto checkpoint = encoding_table_.checkpoint();
+
+  // Act
+  std::stringstream ss;
+  checkpoint.save(ss);
+  decoding_table_.load(ss);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1, decoding_table_[id1]));
+  EXPECT_TRUE(std::ranges::equal(label_set2, decoding_table_[id2]));
+}
+
+TEST_F(LabelSetDecodingTableTest, IterateOverDecodingTable) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}};
+  encoding_table_.find_or_emplace(label_set1);
+  encoding_table_.find_or_emplace(label_set2);
+  const auto checkpoint = encoding_table_.checkpoint();
+
+  // Act
+  std::stringstream ss;
+  checkpoint.save(ss);
+  decoding_table_.load(ss);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(decoding_table_, std::initializer_list{label_set1, label_set2}, [](const auto& a, const auto& b) { return a == b; }));
+}
+
+class LabelSetDeltaCheckpointTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_table_;
+  PromPP::Primitives::SnugComposites::LabelSet::DecodingTable<Vector> decoding_table_;
+};
+
+TEST_F(LabelSetDeltaCheckpointTest, DeltaCheckpointSaveSize) {
+  // Arrange
+  BareBones::ShrinkedToFitOStringStream ss;
+  const LabelViewSet label_set1 = {{"name1", "value1"}};
+  const LabelViewSet label_set2 = {{"name2", "value2"}, {"name3", "value3"}};
+
+  encoding_table_.find_or_emplace(label_set1);
+  const auto base_checkpoint = encoding_table_.checkpoint();
+  encoding_table_.find_or_emplace(label_set2);
+
+  const auto checkpoint = encoding_table_.checkpoint();
+  const auto delta = checkpoint - base_checkpoint;
+
+  // Act
+  ss << delta;
+  const auto save_size = delta.save_size();
+
+  // Assert
+  EXPECT_EQ(ss.view().size(), save_size);
+}
+
+TEST_F(LabelSetDeltaCheckpointTest, LoadFromBaseCheckpointAndDelta) {
+  // Arrange
+  std::stringstream ss;
+  const LabelViewSet label_set1 = {{"name1", "value1"}};
+  const LabelViewSet label_set2 = {{"name2", "value2"}, {"name3", "value3"}};
+
+  const auto id1 = encoding_table_.find_or_emplace(label_set1);
+  const auto base_checkpoint = encoding_table_.checkpoint();
+  const auto id2 = encoding_table_.find_or_emplace(label_set2);
+  const auto checkpoint = encoding_table_.checkpoint();
+  const auto delta = checkpoint - base_checkpoint;
+
+  base_checkpoint.save(ss);
+  ss << delta;
+
+  // Act
+  std::stringstream read_stream(ss.str());
+  decoding_table_.load(read_stream);
+  decoding_table_.load(read_stream);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(label_set1, decoding_table_[id1]));
+  EXPECT_TRUE(std::ranges::equal(label_set2, decoding_table_[id2]));
+}
+
+}  // namespace
diff --git a/pp/primitives/tests/snug_composites_tests.cpp b/pp/primitives/tests/snug_composites_tests.cpp
index 541595875..0a40be7df 100644
--- a/pp/primitives/tests/snug_composites_tests.cpp
+++ b/pp/primitives/tests/snug_composites_tests.cpp
@@ -5,695 +5,11 @@
 #include "bare_bones/streams.h"
 #include "primitives/label_set.h"
 #include "primitives/snug_composites.h"
-#include "primitives/snug_composites_filaments.h"
 
 namespace {
 using BareBones::Vector;
 using PromPP::Primitives::LabelViewSet;
 using std::operator""sv;
-using std::string_literals::operator""s;
-
-class SymbolEncodingBimapTest : public testing::Test {
- protected:
-  PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_table_;
-};
-
-TEST_F(SymbolEncodingBimapTest, StoreAndRetrieveSymbol) {
-  // Arrange
-  const std::string symbol = "test_symbol";
-
-  // Act
-  const auto id = encoding_table_.find_or_emplace(symbol);
-
-  // Assert
-  EXPECT_EQ(1U, encoding_table_.size());
-  EXPECT_EQ(symbol, encoding_table_[id]);
-  EXPECT_EQ(id, encoding_table_.find(symbol));
-}
-
-TEST_F(SymbolEncodingBimapTest, StoreMultipleSymbols) {
-  // Arrange
-  const std::string symbol1 = "first";
-  const std::string symbol2 = "second";
-  const std::string symbol3 = "third";
-
-  // Act
-  const auto id1 = encoding_table_.find_or_emplace(symbol1);
-  const auto id2 = encoding_table_.find_or_emplace(symbol2);
-  const auto id3 = encoding_table_.find_or_emplace(symbol3);
-
-  // Assert
-  EXPECT_EQ(3U, encoding_table_.size());
-
-  EXPECT_EQ(symbol1, encoding_table_[id1]);
-  EXPECT_EQ(symbol2, encoding_table_[id2]);
-  EXPECT_EQ(symbol3, encoding_table_[id3]);
-
-  EXPECT_EQ(id1, encoding_table_.find(symbol1));
-  EXPECT_EQ(id2, encoding_table_.find(symbol2));
-  EXPECT_EQ(id3, encoding_table_.find(symbol3));
-}
-
-TEST_F(SymbolEncodingBimapTest, FindOrEmplaceReturnsSameIdForDuplicate) {
-  // Arrange
-  const std::string symbol = "duplicate";
-
-  // Act
-  const auto id1 = encoding_table_.find_or_emplace(symbol);
-  const auto id2 = encoding_table_.find_or_emplace(symbol);
-
-  // Assert
-  EXPECT_EQ(1U, encoding_table_.size());
-  EXPECT_EQ(id1, id2);
-}
-
-TEST_F(SymbolEncodingBimapTest, IterateOverSymbols) {
-  // Arrange
-  const std::string symbol1 = "a";
-  const std::string symbol2 = "b";
-  const std::string symbol3 = "c";
-
-  // Act
-  encoding_table_.find_or_emplace(symbol1);
-  encoding_table_.find_or_emplace(symbol2);
-  encoding_table_.find_or_emplace(symbol3);
-
-  // Assert
-  EXPECT_EQ(3U, encoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(encoding_table_, std::initializer_list{"a"s, "b"s, "c"s}));
-}
-
-TEST_F(SymbolEncodingBimapTest, CheckpointAndRollback) {
-  // Arrange
-  const std::string symbol1 = "before_checkpoint";
-  const std::string symbol2 = "after_checkpoint";
-
-  // Act
-  encoding_table_.find_or_emplace(symbol1);
-  const auto checkpoint = encoding_table_.checkpoint();
-  encoding_table_.find_or_emplace(symbol2);
-  encoding_table_.rollback(checkpoint);
-
-  // Assert
-  EXPECT_EQ(1U, encoding_table_.size());
-  EXPECT_TRUE(encoding_table_.find(symbol1).has_value());
-  EXPECT_FALSE(encoding_table_.find(symbol2).has_value());
-}
-
-TEST_F(SymbolEncodingBimapTest, CreateViewFromEncodingBimap) {
-  // Arrange
-  encoding_table_.find_or_emplace("lol"s);
-  encoding_table_.find_or_emplace("kek"s);
-  encoding_table_.find_or_emplace("pod"s);
-  encoding_table_.find_or_emplace("job"s);
-
-  // Act
-  const auto view = encoding_table_.data_view();
-
-  // Assert
-  EXPECT_EQ(4U, view.size());
-  EXPECT_TRUE(std::ranges::equal(view, encoding_table_));
-}
-
-TEST_F(SymbolEncodingBimapTest, EncodingBimapViewIteratorId) {
-  // Arrange
-  const auto id1 = encoding_table_.find_or_emplace("lol"s);
-  const auto id2 = encoding_table_.find_or_emplace("kek"s);
-  const auto id3 = encoding_table_.find_or_emplace("pod"s);
-  const auto id4 = encoding_table_.find_or_emplace("job"s);
-
-  // Act
-  const auto view = encoding_table_.data_view();
-
-  // Assert
-  std::vector<uint32_t> view_ids;
-  view_ids.reserve(view.size());
-  for (auto it = view.begin(), e = view.end(); it != e; ++it) {
-    view_ids.push_back(it.id());
-  }
-  EXPECT_TRUE(std::ranges::equal(view_ids, std::initializer_list{id1, id2, id3, id4}));
-}
-
-class SymbolDecodingTableTest : public testing::Test {
- protected:
-  PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_table_;
-  PromPP::Primitives::SnugComposites::Symbol::DecodingTable<Vector> decoding_table_;
-};
-
-TEST_F(SymbolDecodingTableTest, LoadFromCheckpoint) {
-  // Arrange
-  const std::string symbol1 = "first";
-  const std::string symbol2 = "second";
-  const auto id1 = encoding_table_.find_or_emplace(symbol1);
-  const auto id2 = encoding_table_.find_or_emplace(symbol2);
-  const auto checkpoint = encoding_table_.checkpoint();
-
-  // Act
-  std::stringstream ss;
-  checkpoint.save(ss);
-  decoding_table_.load(ss);
-
-  // Assert
-  EXPECT_EQ(2U, decoding_table_.size());
-  EXPECT_EQ(symbol1, decoding_table_[id1]);
-  EXPECT_EQ(symbol2, decoding_table_[id2]);
-}
-
-TEST_F(SymbolDecodingTableTest, IterateOverDecodingTable) {
-  // Arrange
-  const std::string symbol1 = "a";
-  const std::string symbol2 = "b";
-  encoding_table_.find_or_emplace(symbol1);
-  encoding_table_.find_or_emplace(symbol2);
-  const auto checkpoint = encoding_table_.checkpoint();
-
-  // Act
-  std::stringstream ss;
-  checkpoint.save(ss);
-  decoding_table_.load(ss);
-
-  // Assert
-  EXPECT_EQ(2U, decoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(decoding_table_, std::initializer_list{"a"s, "b"s}));
-}
-
-TEST_F(SymbolDecodingTableTest, CheckpointSaveSizeMatchesActualSize) {
-  // Arrange
-  encoding_table_.find_or_emplace("test"sv);
-  const auto checkpoint = encoding_table_.checkpoint();
-  BareBones::ShrinkedToFitOStringStream ss;
-
-  // Act
-  checkpoint.save(ss);
-  const auto save_size = checkpoint.save_size();
-
-  // Assert
-  EXPECT_EQ(ss.view().size(), save_size);
-}
-
-class LabelNameSetEncodingBimapTest : public testing::Test {
- protected:
-  PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector> encoding_table_;
-};
-
-TEST_F(LabelNameSetEncodingBimapTest, StoreAndRetrieveLabelNameSet) {
-  // Arrange
-  const LabelViewSet label_set = {{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
-
-  // Act
-  const auto id = encoding_table_.find_or_emplace(label_set.names());
-
-  // Assert
-  EXPECT_EQ(1U, encoding_table_.size());
-  const auto retrieved = encoding_table_[id];
-  EXPECT_TRUE(std::ranges::equal(label_set.names(), retrieved));
-}
-
-TEST_F(LabelNameSetEncodingBimapTest, StoreMultipleLabelNameSets) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"a", "1"}, {"b", "2"}};
-  const LabelViewSet label_set2 = {{"c", "3"}, {"d", "4"}, {"e", "5"}};
-
-  // Act
-  const auto id1 = encoding_table_.find_or_emplace(label_set1.names());
-  const auto id2 = encoding_table_.find_or_emplace(label_set2.names());
-
-  // Assert
-  EXPECT_EQ(2U, encoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(label_set1.names(), encoding_table_[id1]));
-  EXPECT_TRUE(std::ranges::equal(label_set2.names(), encoding_table_[id2]));
-}
-
-TEST_F(LabelNameSetEncodingBimapTest, FindOrEmplaceReturnsSameIdForDuplicate) {
-  // Arrange
-  const LabelViewSet label_set = {{"duplicate", "value1"}, {"set", "value2"}};
-
-  // Act
-  const auto id1 = encoding_table_.find_or_emplace(label_set.names());
-  const auto id2 = encoding_table_.find_or_emplace(label_set.names());
-
-  // Assert
-  EXPECT_EQ(1U, encoding_table_.size());
-  EXPECT_EQ(id1, id2);
-}
-
-TEST_F(LabelNameSetEncodingBimapTest, IterateOverLabelNameSets) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"a", "1"}};
-  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
-
-  // Act
-  encoding_table_.find_or_emplace(label_set1.names());
-  encoding_table_.find_or_emplace(label_set2.names());
-
-  // Assert
-  EXPECT_EQ(2U, encoding_table_.size());
-  auto it = encoding_table_.begin();
-  EXPECT_TRUE(std::ranges::equal(label_set1.names(), *it++));
-  EXPECT_TRUE(std::ranges::equal(label_set2.names(), *it++));
-  EXPECT_EQ(encoding_table_.end(), it);
-}
-
-TEST_F(LabelNameSetEncodingBimapTest, CheckpointAndRollback) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"before", "checkpoint"}};
-  const LabelViewSet label_set2 = {{"after", "checkpoint"}};
-
-  // Act
-  encoding_table_.find_or_emplace(label_set1.names());
-  const auto checkpoint = encoding_table_.checkpoint();
-  encoding_table_.find_or_emplace(label_set2.names());
-  encoding_table_.rollback(checkpoint);
-
-  // Assert
-  EXPECT_EQ(1U, encoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(label_set1.names(), *encoding_table_.begin()));
-}
-
-TEST_F(LabelNameSetEncodingBimapTest, CreateViewFromEncodingBimap) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"a", "1"}};
-  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
-  const LabelViewSet label_set3 = {{"d", "4"}, {"e", "5"}, {"f", "6"}};
-  encoding_table_.find_or_emplace(label_set1.names());
-  encoding_table_.find_or_emplace(label_set2.names());
-  encoding_table_.find_or_emplace(label_set3.names());
-
-  // Act
-  const auto symbols = encoding_table_.data_view().symbols();
-
-  // Assert
-  EXPECT_EQ(6U, symbols.size());
-  EXPECT_TRUE(std::ranges::equal(symbols, std::initializer_list{"a", "b", "c", "d", "e", "f"}));
-}
-
-TEST_F(LabelNameSetEncodingBimapTest, EncodingBimapViewIteratorId) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"a", "1"}};
-  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
-  const LabelViewSet label_set3 = {{"d", "4"}, {"e", "5"}, {"f", "6"}};
-
-  const auto id1 = encoding_table_.find_or_emplace(label_set1.names());
-  const auto id2 = encoding_table_.find_or_emplace(label_set2.names());
-  const auto id3 = encoding_table_.find_or_emplace(label_set3.names());
-
-  // Act
-  const auto view = encoding_table_.data_view();
-
-  // Assert
-  std::vector<uint32_t> view_ids;
-  view_ids.reserve(view.size());
-  for (auto it = view.begin(), e = view.end(); it != e; ++it) {
-    view_ids.push_back(it.id());
-  }
-  EXPECT_TRUE(std::ranges::equal(view_ids, std::initializer_list{id1, id2, id3}));
-}
-
-class LabelNameSetDecodingTableTest : public testing::Test {
- protected:
-  PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector> encoding_table_;
-  PromPP::Primitives::SnugComposites::LabelNameSet::DecodingTable<Vector> decoding_table_;
-};
-
-TEST_F(LabelNameSetDecodingTableTest, LoadFromCheckpoint) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"first", "1"}};
-  const LabelViewSet label_set2 = {{"second", "2"}, {"third", "3"}};
-  const auto id1 = encoding_table_.find_or_emplace(label_set1.names());
-  const auto id2 = encoding_table_.find_or_emplace(label_set2.names());
-  const auto checkpoint = encoding_table_.checkpoint();
-
-  // Act
-  std::stringstream ss;
-  checkpoint.save(ss);
-  decoding_table_.load(ss);
-
-  // Assert
-  EXPECT_EQ(2U, decoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(label_set1.names(), decoding_table_[id1]));
-  EXPECT_TRUE(std::ranges::equal(label_set2.names(), decoding_table_[id2]));
-}
-
-TEST_F(LabelNameSetDecodingTableTest, IterateOverDecodingTable) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"a", "1"}};
-  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
-  encoding_table_.find_or_emplace(label_set1.names());
-  encoding_table_.find_or_emplace(label_set2.names());
-  const auto checkpoint = encoding_table_.checkpoint();
-
-  // Act
-  std::stringstream ss;
-  checkpoint.save(ss);
-  decoding_table_.load(ss);
-
-  // Assert
-  EXPECT_EQ(2U, decoding_table_.size());
-  EXPECT_TRUE(
-      std::ranges::equal(decoding_table_, std::initializer_list{label_set1.names(), label_set2.names()}, [](const auto& a, const auto& b) { return a == b; }));
-}
-
-class LabelSetEncodingBimapTest : public testing::Test {
- protected:
-  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_table_;
-};
-
-TEST_F(LabelSetEncodingBimapTest, StoreAndRetrieveLabelSet) {
-  // Arrange
-  const LabelViewSet label_set = {{"name1", "value1"}, {"name2", "value2"}};
-
-  // Act
-  const auto id = encoding_table_.find_or_emplace(label_set);
-
-  // Assert
-  EXPECT_EQ(1U, encoding_table_.size());
-  const auto retrieved = encoding_table_[id];
-  EXPECT_TRUE(std::ranges::equal(label_set, retrieved));
-}
-
-TEST_F(LabelSetEncodingBimapTest, StoreMultipleLabelSets) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"a", "1"}};
-  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
-
-  // Act
-  const auto id1 = encoding_table_.find_or_emplace(label_set1);
-  const auto id2 = encoding_table_.find_or_emplace(label_set2);
-
-  // Assert
-  EXPECT_EQ(2U, encoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(label_set1, encoding_table_[id1]));
-  EXPECT_TRUE(std::ranges::equal(label_set2, encoding_table_[id2]));
-}
-
-TEST_F(LabelSetEncodingBimapTest, FindOrEmplaceReturnsSameIdForDuplicate) {
-  // Arrange
-  const LabelViewSet label_set = {{"duplicate", "set"}};
-
-  // Act
-  const auto id1 = encoding_table_.find_or_emplace(label_set);
-  const auto id2 = encoding_table_.find_or_emplace(label_set);
-
-  // Assert
-  EXPECT_EQ(1U, encoding_table_.size());
-  EXPECT_EQ(id1, id2);
-}
-
-TEST_F(LabelSetEncodingBimapTest, IterateOverLabelSets) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"a", "1"}};
-  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
-
-  // Act
-  encoding_table_.find_or_emplace(label_set1);
-  encoding_table_.find_or_emplace(label_set2);
-
-  // Assert
-  EXPECT_EQ(2U, encoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(encoding_table_, std::initializer_list{label_set1, label_set2}, [](const auto& a, const auto& b) { return a == b; }));
-}
-
-TEST_F(LabelSetEncodingBimapTest, CheckpointAndRollback) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"before", "checkpoint"}};
-  const LabelViewSet label_set2 = {{"after", "checkpoint"}};
-
-  // Act
-  const auto id1 = encoding_table_.find_or_emplace(label_set1);
-  const auto checkpoint = encoding_table_.checkpoint();
-  encoding_table_.find_or_emplace(label_set2);
-  encoding_table_.rollback(checkpoint);
-
-  // Assert
-  EXPECT_EQ(1U, encoding_table_.size());
-  EXPECT_EQ(id1, encoding_table_.find(label_set1).value());
-  EXPECT_FALSE(encoding_table_.find(label_set2).has_value());
-}
-
-TEST_F(LabelSetEncodingBimapTest, CreateViewFromEncodingBimap) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"job", "1"}};
-  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
-  const LabelViewSet label_set3 = {{"job", "3"}, {"run", "first"}, {"pod", "b"}};
-
-  encoding_table_.find_or_emplace(label_set1);
-  encoding_table_.find_or_emplace(label_set2);
-  encoding_table_.find_or_emplace(label_set3);
-
-  // Act
-  const auto view = encoding_table_.data_view();
-
-  // Assert
-  EXPECT_EQ(3U, view.size());
-  EXPECT_EQ(3U, view.labels_keys().size());
-  EXPECT_TRUE(std::ranges::equal(view.labels_keys(), std::initializer_list{"job", "pod", "run"}));
-  EXPECT_TRUE(std::ranges::equal(view.labels_values(), std::initializer_list{"1", "2", "3", "a", "b", "first"}));
-}
-
-TEST_F(LabelSetEncodingBimapTest, EncodingBimapViewCheckId) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"job", "1"}};
-  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
-  const LabelViewSet label_set3 = {{"job", "3"}, {"run", "first"}, {"pod", "b"}};
-  const auto id1 = encoding_table_.find_or_emplace(label_set1);
-  const auto id2 = encoding_table_.find_or_emplace(label_set2);
-  const auto id3 = encoding_table_.find_or_emplace(label_set3);
-
-  // Act
-  const auto view = encoding_table_.data_view();
-
-  // Assert
-  std::vector<uint32_t> view_ids;
-  view_ids.reserve(view.size());
-  for (auto it = view.begin(), e = view.end(); it != e; ++it) {
-    view_ids.push_back(it.id());
-  }
-  EXPECT_TRUE(std::ranges::equal(view_ids, std::initializer_list{id1, id2, id3}));
-}
-
-TEST_F(LabelSetEncodingBimapTest, EncodingBimapViewCheckKeyId) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"job", "1"}};
-  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
-  const LabelViewSet label_set3 = {{"job", "3"}, {"run", "first"}, {"pod", "b"}};
-
-  encoding_table_.find_or_emplace(label_set1);
-  encoding_table_.find_or_emplace(label_set2);
-  encoding_table_.find_or_emplace(label_set3);
-
-  const auto view = encoding_table_.data_view();
-
-  auto k_it = view.labels_keys().begin();
-  const auto job_id = (k_it++).id();
-  const auto pod_id = (k_it++).id();
-  const auto run_id = (k_it++).id();
-
-  // Act
-  std::vector<uint32_t> view_value_symbols_ids;
-  for (auto it = view.labels_values().begin(), e = view.labels_values().end(); it != e; ++it) {
-    view_value_symbols_ids.push_back(it.key_id());
-  }
-
-  // Assert
-  EXPECT_TRUE(std::ranges::equal(view_value_symbols_ids, std::initializer_list{job_id, job_id, job_id, pod_id, pod_id, run_id}));
-}
-
-class LabelSetDecodingTableTest : public testing::Test {
- protected:
-  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_table_;
-  PromPP::Primitives::SnugComposites::LabelSet::DecodingTable<Vector> decoding_table_;
-};
-
-TEST_F(LabelSetDecodingTableTest, LoadFromCheckpoint) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"first", "1"}};
-  const LabelViewSet label_set2 = {{"second", "2"}, {"third", "3"}};
-  const auto id1 = encoding_table_.find_or_emplace(label_set1);
-  const auto id2 = encoding_table_.find_or_emplace(label_set2);
-  const auto checkpoint = encoding_table_.checkpoint();
-
-  // Act
-  std::stringstream ss;
-  checkpoint.save(ss);
-  decoding_table_.load(ss);
-
-  // Assert
-  EXPECT_EQ(2U, decoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(label_set1, decoding_table_[id1]));
-  EXPECT_TRUE(std::ranges::equal(label_set2, decoding_table_[id2]));
-}
-
-TEST_F(LabelSetDecodingTableTest, IterateOverDecodingTable) {
-  // Arrange
-  const LabelViewSet label_set1 = {{"a", "1"}};
-  const LabelViewSet label_set2 = {{"b", "2"}};
-  encoding_table_.find_or_emplace(label_set1);
-  encoding_table_.find_or_emplace(label_set2);
-  const auto checkpoint = encoding_table_.checkpoint();
-
-  // Act
-  std::stringstream ss;
-  checkpoint.save(ss);
-  decoding_table_.load(ss);
-
-  // Assert
-  EXPECT_EQ(2U, decoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(decoding_table_, std::initializer_list{label_set1, label_set2}, [](const auto& a, const auto& b) { return a == b; }));
-}
-
-class SymbolDeltaCheckpointTest : public testing::Test {
- protected:
-  PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_table_;
-  PromPP::Primitives::SnugComposites::Symbol::DecodingTable<Vector> decoding_table_;
-};
-
-TEST_F(SymbolDeltaCheckpointTest, DeltaCheckpointSaveSize) {
-  // Arrange
-  BareBones::ShrinkedToFitOStringStream ss;
-
-  encoding_table_.find_or_emplace("first"sv);
-  const auto base_checkpoint = encoding_table_.checkpoint();
-  encoding_table_.find_or_emplace("second"sv);
-
-  const auto checkpoint = encoding_table_.checkpoint();
-  const auto delta = checkpoint - base_checkpoint;
-
-  // Act
-  ss << delta;
-  const auto save_size = delta.save_size();
-
-  // Assert
-  EXPECT_EQ(ss.view().size(), save_size);
-}
-
-TEST_F(SymbolDeltaCheckpointTest, LoadFromBaseCheckpointAndDelta) {
-  // Arrange
-  std::stringstream ss;
-  const std::string symbol1 = "first";
-  const std::string symbol2 = "second";
-
-  const auto id1 = encoding_table_.find_or_emplace(symbol1);
-  const auto base_checkpoint = encoding_table_.checkpoint();
-  const auto id2 = encoding_table_.find_or_emplace(symbol2);
-  const auto checkpoint = encoding_table_.checkpoint();
-  const auto delta = checkpoint - base_checkpoint;
-
-  base_checkpoint.save(ss);
-  ss << delta;
-
-  // Act
-  decoding_table_.load(ss);
-  decoding_table_.load(ss);
-
-  // Assert
-  EXPECT_EQ(2U, decoding_table_.size());
-  EXPECT_EQ(symbol1, decoding_table_[id1]);
-  EXPECT_EQ(symbol2, decoding_table_[id2]);
-}
-
-class LabelNameSetDeltaCheckpointTest : public testing::Test {
- protected:
-  PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<Vector> encoding_table_;
-  PromPP::Primitives::SnugComposites::LabelNameSet::DecodingTable<Vector> decoding_table_;
-};
-
-TEST_F(LabelNameSetDeltaCheckpointTest, DeltaCheckpointSaveSize) {
-  // Arrange
-  BareBones::ShrinkedToFitOStringStream ss;
-
-  const LabelViewSet label_set1 = {{"name1", "value1"}};
-  const LabelViewSet label_set2 = {{"name2", "value2"}, {"name3", "value3"}};
-
-  encoding_table_.find_or_emplace(label_set1.names());
-  const auto base_checkpoint = encoding_table_.checkpoint();
-  encoding_table_.find_or_emplace(label_set2.names());
-  const auto checkpoint = encoding_table_.checkpoint();
-  const auto delta = checkpoint - base_checkpoint;
-
-  // Act
-  ss << delta;
-  const auto save_size = delta.save_size();
-
-  // Assert
-  EXPECT_EQ(ss.view().size(), save_size);
-}
-
-TEST_F(LabelNameSetDeltaCheckpointTest, LoadFromBaseCheckpointAndDelta) {
-  // Arrange
-  std::stringstream ss;
-  const LabelViewSet label_set1 = {{"name1", "value1"}};
-  const LabelViewSet label_set2 = {{"name2", "value2"}, {"name3", "value3"}};
-  const auto id1 = encoding_table_.find_or_emplace(label_set1.names());
-  const auto base_checkpoint = encoding_table_.checkpoint();
-  const auto id2 = encoding_table_.find_or_emplace(label_set2.names());
-  const auto checkpoint = encoding_table_.checkpoint();
-  const auto delta = checkpoint - base_checkpoint;
-
-  base_checkpoint.save(ss);
-  ss << delta;
-
-  // Act
-  decoding_table_.load(ss);
-  decoding_table_.load(ss);
-
-  // Assert
-  EXPECT_EQ(2U, decoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(label_set1.names(), decoding_table_[id1]));
-  EXPECT_TRUE(std::ranges::equal(label_set2.names(), decoding_table_[id2]));
-}
-
-class LabelSetDeltaCheckpointTest : public testing::Test {
- protected:
-  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_table_;
-  PromPP::Primitives::SnugComposites::LabelSet::DecodingTable<Vector> decoding_table_;
-};
-
-TEST_F(LabelSetDeltaCheckpointTest, DeltaCheckpointSaveSize) {
-  // Arrange
-  BareBones::ShrinkedToFitOStringStream ss;
-  const LabelViewSet label_set1 = {{"name1", "value1"}};
-  const LabelViewSet label_set2 = {{"name2", "value2"}, {"name3", "value3"}};
-
-  encoding_table_.find_or_emplace(label_set1);
-  const auto base_checkpoint = encoding_table_.checkpoint();
-  encoding_table_.find_or_emplace(label_set2);
-
-  const auto checkpoint = encoding_table_.checkpoint();
-  const auto delta = checkpoint - base_checkpoint;
-
-  // Act
-  ss << delta;
-  const auto save_size = delta.save_size();
-
-  // Assert
-  EXPECT_EQ(ss.view().size(), save_size);
-}
-
-TEST_F(LabelSetDeltaCheckpointTest, LoadFromBaseCheckpointAndDelta) {
-  // Arrange
-  std::stringstream ss;
-  const LabelViewSet label_set1 = {{"name1", "value1"}};
-  const LabelViewSet label_set2 = {{"name2", "value2"}, {"name3", "value3"}};
-
-  const auto id1 = encoding_table_.find_or_emplace(label_set1);
-  const auto base_checkpoint = encoding_table_.checkpoint();
-  const auto id2 = encoding_table_.find_or_emplace(label_set2);
-  const auto checkpoint = encoding_table_.checkpoint();
-  const auto delta = checkpoint - base_checkpoint;
-
-  base_checkpoint.save(ss);
-  ss << delta;
-
-  // Act
-  std::stringstream read_stream(ss.str());
-  decoding_table_.load(read_stream);
-  decoding_table_.load(read_stream);
-
-  // Assert
-  EXPECT_EQ(2U, decoding_table_.size());
-  EXPECT_TRUE(std::ranges::equal(label_set1, decoding_table_[id1]));
-  EXPECT_TRUE(std::ranges::equal(label_set2, decoding_table_[id2]));
-}
 
 class ShrinkableEncodingBimapLabelSetFixture : public testing::Test {
  protected:
diff --git a/pp/primitives/tests/symbol_tests.cpp b/pp/primitives/tests/symbol_tests.cpp
new file mode 100644
index 000000000..55e199df9
--- /dev/null
+++ b/pp/primitives/tests/symbol_tests.cpp
@@ -0,0 +1,241 @@
+#include <sstream>
+
+#include "gtest/gtest.h"
+
+#include "bare_bones/streams.h"
+#include "primitives/snug_composites.h"
+
+namespace {
+using BareBones::Vector;
+using std::operator""sv;
+using std::string_literals::operator""s;
+
+class SymbolEncodingBimapTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_table_;
+};
+
+TEST_F(SymbolEncodingBimapTest, StoreAndRetrieveSymbol) {
+  // Arrange
+  const std::string symbol = "test_symbol";
+
+  // Act
+  const auto id = encoding_table_.find_or_emplace(symbol);
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_EQ(symbol, encoding_table_[id]);
+  EXPECT_EQ(id, encoding_table_.find(symbol));
+}
+
+TEST_F(SymbolEncodingBimapTest, StoreMultipleSymbols) {
+  // Arrange
+  const std::string symbol1 = "first";
+  const std::string symbol2 = "second";
+  const std::string symbol3 = "third";
+
+  // Act
+  const auto id1 = encoding_table_.find_or_emplace(symbol1);
+  const auto id2 = encoding_table_.find_or_emplace(symbol2);
+  const auto id3 = encoding_table_.find_or_emplace(symbol3);
+
+  // Assert
+  EXPECT_EQ(3U, encoding_table_.size());
+
+  EXPECT_EQ(symbol1, encoding_table_[id1]);
+  EXPECT_EQ(symbol2, encoding_table_[id2]);
+  EXPECT_EQ(symbol3, encoding_table_[id3]);
+
+  EXPECT_EQ(id1, encoding_table_.find(symbol1));
+  EXPECT_EQ(id2, encoding_table_.find(symbol2));
+  EXPECT_EQ(id3, encoding_table_.find(symbol3));
+}
+
+TEST_F(SymbolEncodingBimapTest, FindOrEmplaceReturnsSameIdForDuplicate) {
+  // Arrange
+  const std::string symbol = "duplicate";
+
+  // Act
+  const auto id1 = encoding_table_.find_or_emplace(symbol);
+  const auto id2 = encoding_table_.find_or_emplace(symbol);
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_EQ(id1, id2);
+}
+
+TEST_F(SymbolEncodingBimapTest, IterateOverSymbols) {
+  // Arrange
+  const std::string symbol1 = "a";
+  const std::string symbol2 = "b";
+  const std::string symbol3 = "c";
+
+  // Act
+  encoding_table_.find_or_emplace(symbol1);
+  encoding_table_.find_or_emplace(symbol2);
+  encoding_table_.find_or_emplace(symbol3);
+
+  // Assert
+  EXPECT_EQ(3U, encoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(encoding_table_, std::initializer_list{"a"s, "b"s, "c"s}));
+}
+
+TEST_F(SymbolEncodingBimapTest, CheckpointAndRollback) {
+  // Arrange
+  const std::string symbol1 = "before_checkpoint";
+  const std::string symbol2 = "after_checkpoint";
+
+  // Act
+  encoding_table_.find_or_emplace(symbol1);
+  const auto checkpoint = encoding_table_.checkpoint();
+  encoding_table_.find_or_emplace(symbol2);
+  encoding_table_.rollback(checkpoint);
+
+  // Assert
+  EXPECT_EQ(1U, encoding_table_.size());
+  EXPECT_TRUE(encoding_table_.find(symbol1).has_value());
+  EXPECT_FALSE(encoding_table_.find(symbol2).has_value());
+}
+
+TEST_F(SymbolEncodingBimapTest, CreateViewFromEncodingBimap) {
+  // Arrange
+  encoding_table_.find_or_emplace("lol"s);
+  encoding_table_.find_or_emplace("kek"s);
+  encoding_table_.find_or_emplace("pod"s);
+  encoding_table_.find_or_emplace("job"s);
+
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  EXPECT_EQ(4U, view.size());
+  EXPECT_TRUE(std::ranges::equal(view, encoding_table_));
+}
+
+TEST_F(SymbolEncodingBimapTest, EncodingBimapViewIteratorId) {
+  // Arrange
+  const auto id1 = encoding_table_.find_or_emplace("lol"s);
+  const auto id2 = encoding_table_.find_or_emplace("kek"s);
+  const auto id3 = encoding_table_.find_or_emplace("pod"s);
+  const auto id4 = encoding_table_.find_or_emplace("job"s);
+
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  std::vector<uint32_t> view_ids;
+  view_ids.reserve(view.size());
+  for (auto it = view.begin(), e = view.end(); it != e; ++it) {
+    view_ids.push_back(it.id());
+  }
+  EXPECT_TRUE(std::ranges::equal(view_ids, std::initializer_list{id1, id2, id3, id4}));
+}
+
+class SymbolDecodingTableTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_table_;
+  PromPP::Primitives::SnugComposites::Symbol::DecodingTable<Vector> decoding_table_;
+};
+
+TEST_F(SymbolDecodingTableTest, LoadFromCheckpoint) {
+  // Arrange
+  const std::string symbol1 = "first";
+  const std::string symbol2 = "second";
+  const auto id1 = encoding_table_.find_or_emplace(symbol1);
+  const auto id2 = encoding_table_.find_or_emplace(symbol2);
+  const auto checkpoint = encoding_table_.checkpoint();
+
+  // Act
+  std::stringstream ss;
+  checkpoint.save(ss);
+  decoding_table_.load(ss);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_EQ(symbol1, decoding_table_[id1]);
+  EXPECT_EQ(symbol2, decoding_table_[id2]);
+}
+
+TEST_F(SymbolDecodingTableTest, IterateOverDecodingTable) {
+  // Arrange
+  const std::string symbol1 = "a";
+  const std::string symbol2 = "b";
+  encoding_table_.find_or_emplace(symbol1);
+  encoding_table_.find_or_emplace(symbol2);
+  const auto checkpoint = encoding_table_.checkpoint();
+
+  // Act
+  std::stringstream ss;
+  checkpoint.save(ss);
+  decoding_table_.load(ss);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_TRUE(std::ranges::equal(decoding_table_, std::initializer_list{"a"s, "b"s}));
+}
+
+TEST_F(SymbolDecodingTableTest, CheckpointSaveSizeMatchesActualSize) {
+  // Arrange
+  encoding_table_.find_or_emplace("test"sv);
+  const auto checkpoint = encoding_table_.checkpoint();
+  BareBones::ShrinkedToFitOStringStream ss;
+
+  // Act
+  checkpoint.save(ss);
+  const auto save_size = checkpoint.save_size();
+
+  // Assert
+  EXPECT_EQ(ss.view().size(), save_size);
+}
+
+class SymbolDeltaCheckpointTest : public testing::Test {
+ protected:
+  PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_table_;
+  PromPP::Primitives::SnugComposites::Symbol::DecodingTable<Vector> decoding_table_;
+};
+
+TEST_F(SymbolDeltaCheckpointTest, DeltaCheckpointSaveSize) {
+  // Arrange
+  BareBones::ShrinkedToFitOStringStream ss;
+
+  encoding_table_.find_or_emplace("first"sv);
+  const auto base_checkpoint = encoding_table_.checkpoint();
+  encoding_table_.find_or_emplace("second"sv);
+
+  const auto checkpoint = encoding_table_.checkpoint();
+  const auto delta = checkpoint - base_checkpoint;
+
+  // Act
+  ss << delta;
+  const auto save_size = delta.save_size();
+
+  // Assert
+  EXPECT_EQ(ss.view().size(), save_size);
+}
+
+TEST_F(SymbolDeltaCheckpointTest, LoadFromBaseCheckpointAndDelta) {
+  // Arrange
+  std::stringstream ss;
+  const std::string symbol1 = "first";
+  const std::string symbol2 = "second";
+
+  const auto id1 = encoding_table_.find_or_emplace(symbol1);
+  const auto base_checkpoint = encoding_table_.checkpoint();
+  const auto id2 = encoding_table_.find_or_emplace(symbol2);
+  const auto checkpoint = encoding_table_.checkpoint();
+  const auto delta = checkpoint - base_checkpoint;
+
+  base_checkpoint.save(ss);
+  ss << delta;
+
+  // Act
+  decoding_table_.load(ss);
+  decoding_table_.load(ss);
+
+  // Assert
+  EXPECT_EQ(2U, decoding_table_.size());
+  EXPECT_EQ(symbol1, decoding_table_[id1]);
+  EXPECT_EQ(symbol2, decoding_table_[id2]);
+}
+
+}  // namespace

From 05ba6d6fbdad6a223d810040311c797927c8bfb4 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Thu, 18 Dec 2025 17:30:00 +0300
Subject: [PATCH 27/34] filaments update

---
 pp/primitives/snug_composites_filaments.h | 38 +++++++++++++++++++++++
 pp/primitives/tests/label_set_tests.cpp   |  2 ++
 2 files changed, 40 insertions(+)

diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index ade029010..a89f6196d 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -127,6 +127,8 @@ struct Symbol {
 
       [[nodiscard]] size_t size() const noexcept { return storage_ptr->count(); }
       [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
+
+      [[nodiscard]] composite_type operator[](uint32_t id) const noexcept { return storage_ptr->composite(id); }
     };
 
     using view_type = symbols_view;
@@ -977,6 +979,28 @@ struct LabelSet {
         return iterator_type{storage_ptr->symbols_tables, storage_ptr->label_name_sets_table.data_view().symbols().end(),
                              storage_ptr->label_name_sets_table.data_view().symbols().end()};
       }
+
+      [[nodiscard]] size_t size() const noexcept {
+        size_t total_size = 0;
+        const auto keys_view = storage_ptr->label_name_sets_table.data_view().symbols();
+        for (auto key_it = keys_view.begin(); key_it != keys_view.end(); ++key_it) {
+          const uint32_t key_id = key_it.id();
+          if constexpr (BareBones::concepts::is_dereferenceable<typename symbols_tables_type::value_type>) {
+            total_size += (*storage_ptr->symbols_tables[key_id]).data_view().size();
+          } else {
+            total_size += storage_ptr->symbols_tables[key_id].data_view().size();
+          }
+        }
+        return total_size;
+      }
+
+      [[nodiscard]] iterator_type::value_type get_by_id(uint32_t name_id, uint32_t value_id) const noexcept {
+        if constexpr (BareBones::concepts::is_dereferenceable<typename symbols_tables_type::value_type>) {
+          return (*storage_ptr->symbols_tables[name_id])[value_id];
+        } else {
+          return storage_ptr->symbols_tables[name_id][value_id];
+        }
+      }
     };
 
     struct label_set_view {
@@ -1024,6 +1048,20 @@ struct LabelSet {
 
       keys_view_type labels_keys() const noexcept { return storage_ptr->label_name_sets_table.data_view().symbols(); }
       values_view_type labels_values() const noexcept { return label_sets_values_view{.storage_ptr = storage_ptr}; }
+
+      // Get symbol by name_id and optional value_id
+      // If value_id == std::numeric_limits<uint32_t>::max(), returns name symbol
+      // Otherwise returns value symbol for the given name_id and value_id
+      [[nodiscard]] PROMPP_ALWAYS_INLINE std::string_view get_symbol(uint32_t name_id,
+                                                                     uint32_t value_id = std::numeric_limits<uint32_t>::max()) const noexcept {
+        if (value_id == std::numeric_limits<uint32_t>::max()) {
+          // Return name symbol
+          return labels_keys()[name_id];
+        } else {
+          // Return value symbol
+          return labels_values().get_by_id(name_id, value_id);
+        }
+      }
     };
 
     using view_type = label_set_view;
diff --git a/pp/primitives/tests/label_set_tests.cpp b/pp/primitives/tests/label_set_tests.cpp
index 53f662e17..69d3d222c 100644
--- a/pp/primitives/tests/label_set_tests.cpp
+++ b/pp/primitives/tests/label_set_tests.cpp
@@ -105,6 +105,7 @@ TEST_F(LabelSetEncodingBimapTest, CreateViewFromEncodingBimap) {
   // Assert
   EXPECT_EQ(3U, view.size());
   EXPECT_EQ(3U, view.labels_keys().size());
+  EXPECT_EQ(6U, view.labels_values().size());
   EXPECT_TRUE(std::ranges::equal(view.labels_keys(), std::initializer_list{"job", "pod", "run"}));
   EXPECT_TRUE(std::ranges::equal(view.labels_values(), std::initializer_list{"1", "2", "3", "a", "b", "first"}));
 }
@@ -114,6 +115,7 @@ TEST_F(LabelSetEncodingBimapTest, EncodingBimapViewCheckId) {
   const LabelViewSet label_set1 = {{"job", "1"}};
   const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
   const LabelViewSet label_set3 = {{"job", "3"}, {"run", "first"}, {"pod", "b"}};
+
   const auto id1 = encoding_table_.find_or_emplace(label_set1);
   const auto id2 = encoding_table_.find_or_emplace(label_set2);
   const auto id3 = encoding_table_.find_or_emplace(label_set3);

From 92fdd198ad73907f764584195cbdf51de60092cc Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Thu, 18 Dec 2025 18:22:52 +0300
Subject: [PATCH 28/34] series index tests fix

---
 pp/primitives/snug_composites_filaments.h     |  6 ++--
 .../index/section_writer/symbols_writer.h     | 35 +++++++++----------
 pp/series_index/querier/label_names_querier.h |  4 +--
 .../querier/label_values_querier.h            |  4 +--
 pp/series_index/queryable_encoding_bimap.h    | 28 +++++++++------
 pp/wal/wal.h                                  |  2 +-
 6 files changed, 41 insertions(+), 38 deletions(-)

diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index a89f6196d..6c0f33a6e 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -170,7 +170,7 @@ struct Symbol {
 
     [[nodiscard]] uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
 
-    [[nodiscard]] uint32_t emplace_back(composite_type str) noexcept {
+    uint32_t emplace_back(composite_type str) noexcept {
       const uint32_t id = items.size();
       items.emplace_back(data.size(), str.length());
       data.push_back(str.begin(), str.end());
@@ -522,7 +522,7 @@ struct LabelNameSet {
     [[nodiscard]] uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
 
     template <class OtherLabelNameSet, class Cache = NoCache>
-    [[nodiscard]] uint32_t emplace_back(const OtherLabelNameSet& label_name_set, Cache&& cache = {}) noexcept {
+    uint32_t emplace_back(const OtherLabelNameSet& label_name_set, Cache&& cache = {}) noexcept {
       const uint32_t id = items.size();
 
       uint32_t pos = symbols_ids_sequences.size();
@@ -1167,7 +1167,7 @@ struct LabelSet {
     [[nodiscard]] uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
 
     template <class OtherLabelSet, class Cache = NoCache>
-    [[nodiscard]] uint32_t emplace_back(const OtherLabelSet& label_set, Cache&& cache = {}) noexcept {
+    uint32_t emplace_back(const OtherLabelSet& label_set, Cache&& cache = {}) noexcept {
       const uint32_t id = items.size();
 
       const uint32_t lns_id = find_or_emplace_label_names_set(label_set, std::forward<Cache>(cache));
diff --git a/pp/series_index/prometheus/tsdb/index/section_writer/symbols_writer.h b/pp/series_index/prometheus/tsdb/index/section_writer/symbols_writer.h
index 030f2e5e0..5a2a88297 100644
--- a/pp/series_index/prometheus/tsdb/index/section_writer/symbols_writer.h
+++ b/pp/series_index/prometheus/tsdb/index/section_writer/symbols_writer.h
@@ -36,14 +36,15 @@ class SymbolsWriter {
     symbol_ids_.reserve(get_symbols_count() + 1);
     symbol_ids_.emplace_back(kEmptySymbol);
 
-    auto& names = lss_.data().label_name_sets_table.data().symbols_table;
-    for (uint32_t name_id = 0; name_id < names.size(); ++name_id) {
-      symbol_ids_.emplace_back(name_id);
+    const auto names = lss_.data_view().labels_keys();
+    const auto values = lss_.data_view().labels_values();
 
-      auto& values = *lss_.data().symbols_tables[name_id];
-      for (uint32_t value_id = 0; value_id < values.size(); ++value_id) {
-        symbol_ids_.emplace_back(name_id, value_id);
-      }
+    for (auto it = names.begin(), e = names.end(); it != e; ++it) {
+      symbol_ids_.emplace_back(it.id());
+    }
+
+    for (auto it = values.begin(), e = values.end(); it != e; ++it) {
+      symbol_ids_.emplace_back(it.key_id(), it.value_id());
     }
 
     std::ranges::sort(symbol_ids_, [this](SymbolLssId a, SymbolLssId b) PROMPP_LAMBDA_INLINE { return get_symbol(a) < get_symbol(b); });
@@ -65,13 +66,7 @@ class SymbolsWriter {
   }
 
   [[nodiscard]] uint32_t get_symbols_count() const noexcept {
-    auto& names = lss_.data().label_name_sets_table.data().symbols_table;
-    uint32_t count = names.size();
-    for (uint32_t name_id = 0; name_id < names.size(); ++name_id) {
-      count += lss_.data().symbols_tables[name_id]->size();
-    }
-
-    return count;
+    return lss_.data_view().labels_keys().size() + lss_.data_view().labels_values().size();
   }
 
   [[nodiscard]] PROMPP_ALWAYS_INLINE static uint32_t serialized_string_length(const std::string_view& str) noexcept {
@@ -79,14 +74,16 @@ class SymbolsWriter {
   }
 
   [[nodiscard]] PROMPP_ALWAYS_INLINE std::string_view get_symbol(SymbolLssId symbol_id) const noexcept {
-    if (symbol_id.is_empty()) {
-      [[unlikely]];
+    if (symbol_id.is_empty()) [[unlikely]] {
       return {};
-    } else if (symbol_id.is_name()) {
-      return lss_.data().label_name_sets_table.data().symbols_table[symbol_id.name_id];
     }
 
-    return lss_.data().symbols_tables[symbol_id.name_id]->operator[](symbol_id.value_id);
+    const auto view = lss_.data_view();
+    if (symbol_id.is_name()) {
+      return view.labels_keys()[symbol_id.name_id];
+    }
+
+    return view.labels_values().get_by_id(symbol_id.name_id, symbol_id.value_id);
   }
 
   void write_symbols() noexcept {
diff --git a/pp/series_index/querier/label_names_querier.h b/pp/series_index/querier/label_names_querier.h
index cccd3b8d2..92a6ff6de 100644
--- a/pp/series_index/querier/label_names_querier.h
+++ b/pp/series_index/querier/label_names_querier.h
@@ -36,11 +36,11 @@ class LabelNamesQuerier {
 
   template <class NameHandler, class Filter>
   void enumerate_label_names(NameHandler&& name_handler, Filter&& filter) const {
-    auto& names_table = index_.data().label_name_sets_table.data().symbols_table;
+    const auto names = index_.data_view().labels_keys();
     auto& names_trie = index_.trie_index().names_trie();
     for (auto it = names_trie.make_enumerative_iterator(); it.is_valid(); it.next()) {
       if (filter(it.value())) {
-        name_handler(names_table[it.value()]);
+        name_handler(names[it.value()]);
       }
     }
   }
diff --git a/pp/series_index/querier/label_values_querier.h b/pp/series_index/querier/label_values_querier.h
index 0a8a4e86d..3377b6e7e 100644
--- a/pp/series_index/querier/label_values_querier.h
+++ b/pp/series_index/querier/label_values_querier.h
@@ -41,10 +41,10 @@ class LabelValuesQuerier {
 
   template <class Trie, class ValueHandler, class Filter>
   void enumerate_label_values(uint32_t name_id, const Trie& trie, ValueHandler&& value_handler, Filter&& filter) const {
-    auto& values_table = *index_.data().symbols_tables[name_id];
+    const auto values = index_.data_view().labels_values();
     for (auto it = trie.make_enumerative_iterator(); it.is_valid(); it.next()) {
       if (filter(it.value())) {
-        value_handler(values_table[it.value()]);
+        value_handler(values.get_by_id(name_id, it.value()));
       }
     }
   }
diff --git a/pp/series_index/queryable_encoding_bimap.h b/pp/series_index/queryable_encoding_bimap.h
index 65de0ee4c..fb98b402a 100644
--- a/pp/series_index/queryable_encoding_bimap.h
+++ b/pp/series_index/queryable_encoding_bimap.h
@@ -51,9 +51,9 @@ class QueryableEncodingBimap final : public BareBones::SnugComposite::GenericDec
   PROMPP_ALWAYS_INLINE uint32_t find_or_emplace(const LabelSet& label_set, size_t hash) noexcept {
     hash = phmap_hash(hash);
     const auto ls_id = *ls_id_hash_set_.lazy_emplace_with_hash(label_set, hash, [&](const auto& ctor) {
-      auto new_ls_id = Base::items_.size();
+      auto new_ls_id = Base::storage_.emplace_back(label_set);
+      const auto composite_label_set = Base::storage_.composite(new_ls_id);
       ctor(typename Base::Proxy(new_ls_id));
-      auto composite_label_set = Base::items_.emplace_back(Base::data_, label_set).composite(Base::data());
       update_indexes(new_ls_id, composite_label_set);
       return new_ls_id;
     });
@@ -194,7 +194,7 @@ class QueryableEncodingBimapCopier {
     old_new_ids_.reserve(source_.size());
 
     Cache<uint32_t> cache;
-    cache.reserve(source_.data().label_name_sets_table.size(), source_.data().label_name_sets_table.data().symbols_table.size(), source_.data().symbols_tables);
+    cache.reserve(source_.storage_.label_name_sets_table.size(), source_.data_view().labels_keys().size(), source_.storage_.symbols_tables);
 
     destination_.reserve(source_);
 
@@ -204,7 +204,7 @@ class QueryableEncodingBimapCopier {
     for (const auto ls_id : ls_id_range_) {
       old_new_ids_.emplace_back(ls_id, destination_.next_item_index());
       dst_src_ids_mapping_.emplace_back(ls_id);
-      destination_.items_.emplace_back(destination_.data_, source_[ls_id], cache);
+      destination_.storage_.emplace_back(source_[ls_id], cache);
     }
 
     const auto cmp = sorting_index_.get_comparator();
@@ -221,7 +221,8 @@ class QueryableEncodingBimapCopier {
 
   void build_reverse_index() {
     const auto size = destination_.size();
-    destination_.reverse_index_.reserve(destination_.data_.label_name_sets_table.data().symbols_table.size());
+    const auto names_view = destination_.data_view().labels_keys();
+    destination_.reverse_index_.reserve(names_view.size());
 
     for (uint32_t ls_id = 0; ls_id < size; ++ls_id) {
       auto label_set = destination_[ls_id];
@@ -243,12 +244,17 @@ class QueryableEncodingBimapCopier {
   }
 
   void build_trie_index() {
-    const auto& names = destination_.data_.label_name_sets_table.data().symbols_table;
-    destination_.trie_index_.reserve(names.size());
-
-    for (uint32_t name_id = 0; name_id < names.size(); ++name_id) {
-      destination_.trie_index_.insert_name(names[name_id], name_id);
-      destination_.trie_index_.insert_values(name_id, *destination_.data_.symbols_tables[name_id]);
+    const auto names_view = destination_.data_view().labels_keys();
+    destination_.trie_index_.reserve(names_view.size());
+
+    for (auto name_it = names_view.begin(); name_it != names_view.end(); ++name_it) {
+      const uint32_t name_id = name_it.id();
+      destination_.trie_index_.insert_name(*name_it, name_id);
+      if constexpr (BareBones::concepts::is_dereferenceable<decltype(destination_.storage_.symbols_tables[name_id])>) {
+        destination_.trie_index_.insert_values(name_id, (*destination_.storage_.symbols_tables[name_id]).data_view());
+      } else {
+        destination_.trie_index_.insert_values(name_id, destination_.storage_.symbols_tables[name_id].data_view());
+      }
     }
   }
 
diff --git a/pp/wal/wal.h b/pp/wal/wal.h
index af2c58f58..2a2474115 100644
--- a/pp/wal/wal.h
+++ b/pp/wal/wal.h
@@ -446,7 +446,7 @@ class BasicEncoder {
 
   inline __attribute__((always_inline)) uint64_t total_bytes() const { return metadata_bytes_ + label_sets_bytes_ + ls_id_bytes_ + ts_bytes_ + v_bytes_; }
 
-  inline __attribute__((always_inline)) size_t remainder_size() const noexcept { return label_sets_.data().remainder_size(); }
+  inline __attribute__((always_inline)) size_t remainder_size() const noexcept { return label_sets_.remainder_size(); }
 
   inline __attribute__((always_inline)) size_t allocated_memory() const noexcept { return label_sets_.allocated_memory() + gorilla_.allocated_memory(); }
 

From fb4a4fe5bf118d6f5ee24cc7fbf498b668f63497 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Fri, 19 Dec 2025 13:39:21 +0300
Subject: [PATCH 29/34] wal tests update

---
 pp/wal/tests/wal_tests.cpp | 408 +++++++++++++++++++------------------
 1 file changed, 205 insertions(+), 203 deletions(-)

diff --git a/pp/wal/tests/wal_tests.cpp b/pp/wal/tests/wal_tests.cpp
index a0785e14e..ea96874a4 100644
--- a/pp/wal/tests/wal_tests.cpp
+++ b/pp/wal/tests/wal_tests.cpp
@@ -1,6 +1,11 @@
 #include <gtest/gtest.h>
 
+#include <ranges>
 #include <spanstream>
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <vector>
 
 #include "wal/wal.h"
 
@@ -14,99 +19,6 @@ using PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap;
 using PromPP::WAL::BasicDecoder;
 using PromPP::WAL::BasicEncoder;
 
-class NamesSetForTest : public std::vector<std::string> {
-  using Base = std::vector<std::string>;
-
- public:
-  using Base::Base;
-
-  friend size_t hash_value(const NamesSetForTest& lns) { return PromPP::Primitives::hash::hash_of_string_list(lns); }
-};
-
-class LabelSetForTest : public std::vector<std::pair<std::string, std::string>> {
-  using Base = std::vector<std::pair<std::string, std::string>>;
-
- public:
-  using Base::Base;
-
-  NamesSetForTest names() const {
-    NamesSetForTest tns;
-
-    for (const auto& [label_name, _] : *this) {
-      tns.push_back(label_name);
-    }
-
-    return tns;
-  }
-};
-
-class TimeSeriesForTest {
- public:
-  using PrimaryLS = PromPP::Primitives::SnugComposites::Filaments::
-      LabelSet<PromPP::Primitives::SnugComposites::Symbol::EncodingBimap, PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap, BareBones::Vector>;
-  using PrimaryCompositeType = PrimaryLS::composite_type;
-
- private:
-  PrimaryCompositeType label_set_;
-  std::vector<Sample> samples_;
-  PrimaryLS::data_type data_;
-
- public:
-  TimeSeriesForTest() = default;
-  TimeSeriesForTest(const LabelSetForTest& label_set, const std::vector<Sample>& samples) : samples_(samples) {
-    label_set_ = PrimaryLS(data_, label_set).composite(data_);
-  }
-
-  const auto& label_set() const { return label_set_; }
-  auto& label_set() { return label_set_; }
-
-  const auto& samples() const { return samples_; }
-  auto& samples() { return samples_; }
-
-  const auto& data() const { return data_; }
-  auto& data() { return data_; }
-};
-
-using samples_sequence_type = std::vector<Sample>;
-const size_t NUM_VALUES = 10;
-const uint64_t START_TS = 1660828400000;
-const char SYMBOLS_DATA[89] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-+=/|.,\\?<>!@#$%^&*()\"':;";
-
-samples_sequence_type generate_samples(uint64_t ts_step, double v) {
-  samples_sequence_type samples;
-
-  for (size_t i = 0; i < NUM_VALUES; ++i) {
-    samples.push_back({
-        static_cast<PromPP::Primitives::Timestamp>(START_TS + (ts_step * (i + 1))),
-        v * (i + 1),
-    });
-  }
-
-  return samples;
-};
-
-std::string generate_str(int seed) {
-  std::mt19937 gen32(seed);
-  std::string word;
-  int maxlen = 4 + (gen32() % 28);
-  word.resize(maxlen);
-  for (int i = 0; i < maxlen; i++) {
-    word[i] = SYMBOLS_DATA[gen32() % 89];
-  }
-
-  return word;
-};
-
-LabelSetForTest generate_label_set() {
-  LabelSetForTest lst;
-
-  for (size_t i = 0; i < NUM_VALUES; ++i) {
-    lst.push_back({generate_str(i), generate_str(i + NUM_VALUES)});
-  }
-
-  return lst;
-};
-
 struct SeriesSample {
   Sample sample;
   LabelSetID ls_id;
@@ -125,7 +37,7 @@ struct WalBufferAddCase {
 
 class WalBufferAddFixture : public testing::TestWithParam<WalBufferAddCase> {
  protected:
-  PromPP::WAL::BasicEncoder<PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<BareBones::Vector>>::Buffer buffer_;
+  BasicEncoder<PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<BareBones::Vector>>::Buffer buffer_;
 
   void add() {
     for (auto& series_sample : GetParam().samples) {
@@ -158,11 +70,11 @@ TEST_P(WalBufferAddFixture, TestAdd) {
 
 TEST_F(WalBufferAddFixture, TestFillFirstSampleAddedAtTsNs) {
   // Arrange
-  auto start = buffer_.first_sample_added_at_ts_ns();
+  const auto start = buffer_.first_sample_added_at_ts_ns();
 
   // Act
   buffer_.add(0, Sample{101, 1.0});
-  auto filled = buffer_.first_sample_added_at_ts_ns();
+  const auto filled = buffer_.first_sample_added_at_ts_ns();
   buffer_.add(0, Sample{102, 1.0});
 
   // Assert
@@ -304,136 +216,225 @@ INSTANTIATE_TEST_SUITE_P(
             .latest_sample = 102,
         }));
 
-class WalFixture : public testing::Test {};
-
-TEST_F(WalFixture, BasicEncoderBasicDecoder) {
-  PromPP::WAL::BasicEncoder<PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<BareBones::Vector>> writer;
-
-  const LabelSetForTest etalons_label_set = generate_label_set();
-  const samples_sequence_type etalons_samples = generate_samples(1000, 1.123);
-  const TimeSeriesForTest etalons_timeseries = TimeSeriesForTest(etalons_label_set, etalons_samples);
+class WalEncoderDecoderFixture : public testing::Test {
+ protected:
+  using WALEncoder = BasicEncoder<>;
+  using WALDecoder = BasicDecoder<EncodingBimap<BareBones::Vector>>;
 
-  writer.add(etalons_timeseries);
+  struct DecodedSample {
+    uint32_t ls_id;
+    Timestamp timestamp;
+    double value;
 
-  EXPECT_EQ(writer.buffer().latest_sample(), (*(etalons_samples.end() - 1)).timestamp());
+    bool operator==(const DecodedSample& other) const noexcept {
+      return ls_id == other.ls_id && timestamp == other.timestamp && std::bit_cast<uint64_t>(value) == std::bit_cast<uint64_t>(other.value);
+    }
+  };
 
-  // check writer label_set
-  auto outcomes_writer = writer.label_sets().items()[0].composite(etalons_timeseries.data());
-  auto outcome_label_set_writer = outcomes_writer.begin();
-  auto etalon_label_set_writer = etalons_label_set.begin();
+  static PromPP::Primitives::Timeseries create_timeseries(const LabelSet& label_set, const std::vector<Sample>& samples) {
+    PromPP::Primitives::Timeseries timeseries;
+    timeseries.label_set().add(label_set);
+    for (const auto& sample : samples) {
+      timeseries.samples().emplace_back(sample);
+    }
+    return timeseries;
+  }
 
-  while (etalon_label_set_writer != etalons_label_set.end() && outcome_label_set_writer != outcomes_writer.end()) {
-    EXPECT_EQ((*outcome_label_set_writer).first, (*etalon_label_set_writer).first);
-    EXPECT_EQ((*outcome_label_set_writer).second, (*etalon_label_set_writer).second);
-    ++etalon_label_set_writer;
-    ++outcome_label_set_writer;
+  static std::vector<DecodedSample> collect_samples_from_buffer(const WALEncoder::Buffer& buffer) {
+    std::vector<DecodedSample> samples;
+    buffer.for_each([&](uint32_t ls_id, Timestamp timestamp, double value) { samples.emplace_back(DecodedSample{ls_id, timestamp, value}); });
+    return samples;
   }
 
-  EXPECT_EQ(writer.samples(), 0);
-  auto writer_earliest_sample = writer.buffer().earliest_sample();
-  auto writer_latest_sample = writer.buffer().latest_sample();
-
-  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<BareBones::Vector> encoding_bimap;
-  PromPP::WAL::BasicDecoder<PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<BareBones::Vector>> reader{encoding_bimap,
-                                                                                                                   PromPP::WAL::BasicEncoderVersion::kV3};
-  std::stringstream stream_buffer;
-
-  // save wal
-  stream_buffer << writer;
-  EXPECT_EQ(writer.samples(), NUM_VALUES);
-
-  // read wal
-  stream_buffer >> reader;
-
-  // check reader label_set
-  auto outcomes_reader = reader.label_sets().items()[0].composite(etalons_timeseries.data());
-  auto outcome_label_set_reader = outcomes_reader.begin();
-  etalon_label_set_writer = etalons_label_set.begin();
-  while (etalon_label_set_writer != etalons_label_set.end() && outcome_label_set_reader != outcomes_reader.end()) {
-    EXPECT_EQ((*outcome_label_set_reader).first, (*etalon_label_set_writer).first);
-    EXPECT_EQ((*outcome_label_set_reader).second, (*etalon_label_set_writer).second);
-    ++etalon_label_set_writer;
-    ++outcome_label_set_reader;
+  static bool contains_sample(const std::vector<DecodedSample>& samples, uint32_t ls_id, Timestamp timestamp, double value) {
+    const DecodedSample expected{.ls_id = ls_id, .timestamp = timestamp, .value = value};
+    return std::ranges::find(samples, expected) != samples.end();
   }
 
-  // check reader samples
-  samples_sequence_type outcomes_reader_samples;
-  reader.process_segment([&](uint32_t, uint64_t ts, double v) { outcomes_reader_samples.push_back(Sample(ts, v)); });
-
-  auto etalon_sample_reader = etalons_samples.begin();
-  auto outcome_sample_reader = outcomes_reader_samples.begin();
-  while (etalon_sample_reader != etalons_samples.end() && outcome_sample_reader != outcomes_reader_samples.end()) {
-    EXPECT_EQ((*outcome_sample_reader).timestamp(), (*etalon_sample_reader).timestamp());
-    EXPECT_EQ((*outcome_sample_reader).value(), (*etalon_sample_reader).value());
-    ++etalon_sample_reader;
-    ++outcome_sample_reader;
+  static bool contains_stale_nan_sample(const std::vector<DecodedSample>& samples, uint32_t ls_id, Timestamp timestamp) {
+    const auto stale_nan = std::bit_cast<uint64_t>(BareBones::Encoding::Gorilla::STALE_NAN);
+    return std::ranges::find_if(samples, [=](const DecodedSample& s) {
+             return s.ls_id == ls_id && s.timestamp == timestamp && std::bit_cast<uint64_t>(s.value) == stale_nan;
+           }) != samples.end();
   }
+};
+
+TEST_F(WalEncoderDecoderFixture, AddTimeseriesToEncoder) {
+  // Arrange
+  const LabelSet label_set{{"metric", "cpu_usage"}, {"instance", "server1"}};
+  const std::vector<Sample> samples{{1000, 1.5}, {2000, 2.0}, {3000, 1.8}};
+  const auto timeseries = create_timeseries(label_set, samples);
+  WALEncoder encoder;
+
+  // Act
+  encoder.add(timeseries);
 
-  EXPECT_EQ(outcome_sample_reader == outcomes_reader_samples.end(), etalon_sample_reader == etalons_samples.end());
-  EXPECT_EQ(outcomes_reader_samples.size(), etalons_samples.size());
+  // Assert
+  EXPECT_EQ(encoder.buffer().samples_count(), 3U);
+  EXPECT_EQ(encoder.buffer().series_count(), 1U);
+  EXPECT_EQ(encoder.buffer().earliest_sample(), 1000);
+  EXPECT_EQ(encoder.buffer().latest_sample(), 3000);
+  EXPECT_EQ(encoder.samples(), 0U);
+}
+
+TEST_F(WalEncoderDecoderFixture, EncoderStoresLabelSet) {
+  // Arrange
+  const LabelSet label_set{{"metric", "cpu_usage"}, {"instance", "server1"}};
+  const std::vector<Sample> samples{{1000, 1.5}, {2000, 2.0}};
+  const auto timeseries = create_timeseries(label_set, samples);
+  WALEncoder encoder;
 
-  EXPECT_EQ(reader.samples(), NUM_VALUES);
-  EXPECT_EQ(writer_earliest_sample, reader.earliest_sample());
-  EXPECT_EQ(writer_latest_sample, reader.latest_sample());
+  // Act
+  encoder.add(timeseries);
+
+  // Assert
+  ASSERT_EQ(encoder.label_sets().size(), 1U);
+  EXPECT_TRUE(std::ranges::equal(label_set, encoder.label_sets()[0]));
 }
 
-TEST_F(WalFixture, BasicEncoderMany) {
-  using WALEncoder = PromPP::WAL::BasicEncoder<PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<BareBones::Vector>>;
+TEST_F(WalEncoderDecoderFixture, EncodeDecodeLabelSet) {
+  // Arrange
+  const LabelSet label_set{{"metric", "cpu_usage"}, {"instance", "server1"}};
+  const std::vector<Sample> samples{{1000, 1.5}, {2000, 2.0}, {3000, 1.8}};
+  const auto timeseries = create_timeseries(label_set, samples);
+  WALEncoder encoder;
+  encoder.add(timeseries);
+
+  EncodingBimap<BareBones::Vector> encoding_bimap;
+  WALDecoder decoder{encoding_bimap, PromPP::WAL::BasicEncoderVersion::kV3};
+  std::stringstream stream;
+
+  // Act
+  stream << encoder;
+  stream >> decoder;
+
+  // Assert
+  EXPECT_EQ(encoder.samples(), 3U);
+  ASSERT_EQ(decoder.label_sets().size(), 1U);
+  EXPECT_TRUE(std::ranges::equal(label_set, decoder.label_sets()[0]));
+}
+
+TEST_F(WalEncoderDecoderFixture, EncodeDecodeSamples) {
+  // Arrange
+  const LabelSet label_set{{"metric", "cpu_usage"}};
+  const std::vector<Sample> samples{{1000, 1.5}, {2000, 2.0}, {3000, 1.8}};
+  const auto timeseries = create_timeseries(label_set, samples);
+  WALEncoder encoder;
+  encoder.add(timeseries);
+
+  EncodingBimap<BareBones::Vector> encoding_bimap;
+  WALDecoder decoder{encoding_bimap, PromPP::WAL::BasicEncoderVersion::kV3};
+  std::stringstream stream;
+
+  // Act
+  stream << encoder;
+  stream >> decoder;
+
+  std::vector<Sample> decoded_samples;
+  decoder.process_segment([&](uint32_t, uint64_t ts, double v) { decoded_samples.emplace_back(ts, v); });
+
+  // Assert
+  ASSERT_EQ(decoded_samples, samples);
+}
+
+TEST_F(WalEncoderDecoderFixture, EncodeDecodePreservesEarliestLatestSamples) {
+  // Arrange
+  const LabelSet label_set{{"metric", "cpu_usage"}};
+  const std::vector<Sample> samples{{1000, 1.5}, {2000, 2.0}, {3000, 1.8}};
+  const auto timeseries = create_timeseries(label_set, samples);
+
+  WALEncoder encoder;
+  encoder.add(timeseries);
+
+  const auto earliest_before = encoder.buffer().earliest_sample();
+  const auto latest_before = encoder.buffer().latest_sample();
+
+  EncodingBimap<BareBones::Vector> encoding_bimap;
+  WALDecoder decoder{encoding_bimap, PromPP::WAL::BasicEncoderVersion::kV3};
+  std::stringstream stream;
+
+  // Act
+  stream << encoder;
+  stream >> decoder;
+  // Process segment to update earliest/latest
+  decoder.process_segment([](uint32_t, uint64_t, double) {});
+
+  // Assert
+  EXPECT_EQ(decoder.earliest_sample(), earliest_before);
+  EXPECT_EQ(decoder.latest_sample(), latest_before);
+  EXPECT_EQ(decoder.samples(), 3U);
+}
+
+TEST_F(WalEncoderDecoderFixture, AddManyAddsAllTimeseries) {
+  // Arrange
   using AddManyCallbackType = WALEncoder::add_many_generator_callback_type;
   using enum AddManyCallbackType;
   WALEncoder encoder(2, 3);
 
-  const LabelSetForTest ls1{{"LS", "1"}};
-  const LabelSetForTest ls2{{"LS", "2"}};
-  const LabelSetForTest ls3{{"LS", "3"}};
-  const LabelSetForTest ls4{{"LS", "4"}};
+  const LabelSet ls1{{"metric", "cpu"}};
+  const LabelSet ls2{{"metric", "memory"}};
+  const LabelSet ls3{{"metric", "disk"}};
 
-  const PromPP::Primitives::Timestamp ts[]{1000, 2000};
+  const auto timeseries1 = create_timeseries(ls1, {{1000, 1.0}});
+  const auto timeseries2 = create_timeseries(ls2, {{1000, 2.0}});
+  const auto timeseries3 = create_timeseries(ls3, {{1000, 3.0}});
 
   auto generator = [&](auto add_cb) {
-    add_cb(TimeSeriesForTest(ls1, {{1000, 1}}));
-    add_cb(TimeSeriesForTest(ls2, {{1000, 0}}));
-    add_cb(TimeSeriesForTest(ls3, {{1000, 2}}));
+    add_cb(timeseries1);
+    add_cb(timeseries2);
+    add_cb(timeseries3);
   };
 
-  auto generator_2 = [&](auto add_cb) {
-    add_cb(TimeSeriesForTest(ls1, {{2000, 2}}));
-    add_cb(TimeSeriesForTest(ls3, {{2000, 2}}));
-    add_cb(TimeSeriesForTest(ls4, {{2000, 2}}));
+  // Act
+  const auto state = encoder.add_many<without_hash_value, PromPP::Primitives::Timeseries>(nullptr, 1000, generator);
+  WALEncoder::DestroySourceState(state);
+
+  // Assert
+  EXPECT_EQ(encoder.buffer().samples_count(), 3U);
+  EXPECT_EQ(encoder.buffer().series_count(), 3U);
+}
+
+TEST_F(WalEncoderDecoderFixture, AddManyFillsMissingSeriesWithStaleNaN) {
+  // Arrange
+  using AddManyCallbackType = WALEncoder::add_many_generator_callback_type;
+  using enum AddManyCallbackType;
+  WALEncoder encoder(2, 3);
+
+  const LabelSet ls1{{"metric", "cpu"}};
+  const LabelSet ls2{{"metric", "memory"}};
+  const LabelSet ls3{{"metric", "disk"}};
+
+  // first batch: add ls1 and ls2
+  auto generator1 = [&](auto add_cb) {
+    add_cb(create_timeseries(ls1, {{1000, 1.0}}));
+    add_cb(create_timeseries(ls2, {{1000, 2.0}}));
   };
 
-  //
-  decltype(encoder)::SourceState state = encoder.add_many<without_hash_value, TimeSeriesForTest>(0, ts[0], generator);
-  state = encoder.add_many<without_hash_value, TimeSeriesForTest>(state, ts[1], generator_2);
+  // second batch: add ls1 and ls3 (ls2 is missing, should get StaleNaN)
+  auto generator2 = [&](auto add_cb) {
+    add_cb(create_timeseries(ls1, {{2000, 1.5}}));
+    add_cb(create_timeseries(ls3, {{2000, 3.0}}));
+  };
+
+  // Act
+  auto state = encoder.add_many<without_hash_value, PromPP::Primitives::Timeseries>(nullptr, 1000, generator1);
+  state = encoder.add_many<without_hash_value, PromPP::Primitives::Timeseries>(state, 2000, generator2);
   decltype(encoder)::DestroySourceState(state);
 
-  struct Item {
-    uint32_t ls_id;
-    Sample sample;
-    Item(uint32_t id, PromPP::Primitives::Timestamp ts, double v) : ls_id(id), sample(ts, v) {}
-  };
+  // Assert
+  const auto samples = collect_samples_from_buffer(encoder.buffer());
+  ASSERT_EQ(samples.size(), 5U);
 
-  // clang-format off
-  Item expected_items[]{
-    {0, 1000, 1.0},
-    {0, 2000, 2.0},
-    {1, 1000, 0},
-    {1, 2000, BareBones::Encoding::Gorilla::STALE_NAN},
-    {2, 1000, 2},
-    {2, 2000, 2},
-    {3, 2000, 2},
-};
-  // clang-format on
+  // ls1: present in both batches
+  EXPECT_TRUE(contains_sample(samples, 0, 1000, 1.0));
+  EXPECT_TRUE(contains_sample(samples, 0, 2000, 1.5));
 
-  size_t ind = 0;
+  // ls2: present in first batch, StaleNaN in second batch
+  EXPECT_TRUE(contains_sample(samples, 1, 1000, 2.0));
+  EXPECT_TRUE(contains_stale_nan_sample(samples, 1, 2000));
 
-  encoder.buffer().for_each([&](auto ls_id, auto timestamp, double v) {
-    EXPECT_TRUE(ind < std::size(expected_items));
-    EXPECT_EQ(expected_items[ind].ls_id, ls_id);
-    EXPECT_EQ(expected_items[ind].sample.timestamp(), timestamp);
-    EXPECT_EQ(std::bit_cast<uint64_t>(expected_items[ind].sample.value()), std::bit_cast<uint64_t>(v));
-    ++ind;
-  });
+  // ls3: present only in second batch
+  EXPECT_TRUE(contains_sample(samples, 2, 2000, 3.0));
 }
 
 class CreateBasicEncoderFromBasicDecoderFixture : public ::testing::Test {
@@ -478,8 +479,9 @@ class CreateBasicEncoderFromBasicDecoderFixture : public ::testing::Test {
     encoder.add(timeseries);
     stream << encoder;
 
+    const std::string stream_data = stream.str();
     for (const auto decoder : decoders) {
-      EXPECT_NO_THROW(std::ispanstream(stream.view()) >> *decoder);
+      EXPECT_NO_THROW(std::ispanstream(std::string_view(stream_data)) >> *decoder);
       EXPECT_NO_THROW(decoder->process_segment(segment_handler));
     }
   };
@@ -488,20 +490,20 @@ class CreateBasicEncoderFromBasicDecoderFixture : public ::testing::Test {
 TEST_F(CreateBasicEncoderFromBasicDecoderFixture, Test) {
   // Arrange
   static constexpr auto nop_handler = [](uint32_t, int64_t, double) {};
+  static const Sample kThirdSample(3, 3.0);
+  static const Sample kFourthSample(3, 3.0);
 
-  // Arrange
   encode_decode_segment(Sample(1, 1.0), kLabelSet1, encoder1_, {&decoder1_, &decoder2_}, nop_handler);
   encode_decode_segment(Sample(2, 2.0), kLabelSet1, encoder1_, {&decoder1_, &decoder2_}, nop_handler);
 
   Encoder encoder2(decoder1_.sample_decoder().gorilla(), decoder_lss1_, decoder1_.shard_id(), decoder1_.pow_two_of_total_shards(),
                    decoder1_.last_processed_segment() + 1, decoder1_.sample_decoder().timestamp_base);
 
-  static const Sample kThirdSample(3, 3.0);
   DecodedPoint third_point{};
-  encode_decode_segment(kThirdSample, kLabelSet1, encoder2, {&decoder2_}, create_point_decoder(third_point));
-
-  static const Sample kFourthSample(3, 3.0);
   DecodedPoint fourth_point{};
+
+  // Act
+  encode_decode_segment(kThirdSample, kLabelSet1, encoder2, {&decoder2_}, create_point_decoder(third_point));
   encode_decode_segment(kFourthSample, kLabelSet2, encoder2, {&decoder2_}, create_point_decoder(fourth_point));
 
   // Assert

From fc98e7a519f29178c341f7a916ac0b2da4c11fa3 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Fri, 19 Dec 2025 13:44:52 +0300
Subject: [PATCH 30/34] wal tests fix

---
 pp/wal/tests/wal_tests.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/pp/wal/tests/wal_tests.cpp b/pp/wal/tests/wal_tests.cpp
index ea96874a4..d75897e92 100644
--- a/pp/wal/tests/wal_tests.cpp
+++ b/pp/wal/tests/wal_tests.cpp
@@ -242,7 +242,9 @@ class WalEncoderDecoderFixture : public testing::Test {
 
   static std::vector<DecodedSample> collect_samples_from_buffer(const WALEncoder::Buffer& buffer) {
     std::vector<DecodedSample> samples;
-    buffer.for_each([&](uint32_t ls_id, Timestamp timestamp, double value) { samples.emplace_back(DecodedSample{ls_id, timestamp, value}); });
+    buffer.for_each([&](uint32_t ls_id, Timestamp timestamp, double value) {
+      samples.emplace_back(DecodedSample{.ls_id = ls_id, .timestamp = timestamp, .value = value});
+    });
     return samples;
   }
 

From b3d2680fef4bd2ed15e4eccf62c2b3b2c23b2f42 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Fri, 19 Dec 2025 15:02:20 +0300
Subject: [PATCH 31/34] label set view interface update + test coverage

---
 pp/primitives/snug_composites_filaments.h    |  32 ++---
 pp/primitives/tests/label_name_set_tests.cpp |  17 +++
 pp/primitives/tests/label_set_tests.cpp      | 134 +++++++++++++++++--
 pp/primitives/tests/symbol_tests.cpp         |  15 +++
 4 files changed, 169 insertions(+), 29 deletions(-)

diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index 6c0f33a6e..85ad7f28a 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -993,14 +993,6 @@ struct LabelSet {
         }
         return total_size;
       }
-
-      [[nodiscard]] iterator_type::value_type get_by_id(uint32_t name_id, uint32_t value_id) const noexcept {
-        if constexpr (BareBones::concepts::is_dereferenceable<typename symbols_tables_type::value_type>) {
-          return (*storage_ptr->symbols_tables[name_id])[value_id];
-        } else {
-          return storage_ptr->symbols_tables[name_id][value_id];
-        }
-      }
     };
 
     struct label_set_view {
@@ -1046,22 +1038,20 @@ struct LabelSet {
       [[nodiscard]] size_t size() const noexcept { return storage_ptr->count(); }
       [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
 
-      keys_view_type labels_keys() const noexcept { return storage_ptr->label_name_sets_table.data_view().symbols(); }
-      values_view_type labels_values() const noexcept { return label_sets_values_view{.storage_ptr = storage_ptr}; }
-
-      // Get symbol by name_id and optional value_id
-      // If value_id == std::numeric_limits<uint32_t>::max(), returns name symbol
-      // Otherwise returns value symbol for the given name_id and value_id
-      [[nodiscard]] PROMPP_ALWAYS_INLINE std::string_view get_symbol(uint32_t name_id,
-                                                                     uint32_t value_id = std::numeric_limits<uint32_t>::max()) const noexcept {
-        if (value_id == std::numeric_limits<uint32_t>::max()) {
-          // Return name symbol
-          return labels_keys()[name_id];
+      keys_view_type keys() const noexcept { return storage_ptr->label_name_sets_table.data_view().symbols(); }
+      values_view_type values() const noexcept { return label_sets_values_view{.storage_ptr = storage_ptr}; }
+      values_view_type::values_view_type values(uint32_t key_id) const noexcept {
+        if constexpr (BareBones::concepts::is_dereferenceable<typename symbols_tables_type::value_type>) {
+          return (*storage_ptr->symbols_tables[key_id]).data_view();
         } else {
-          // Return value symbol
-          return labels_values().get_by_id(name_id, value_id);
+          return storage_ptr->symbols_tables[key_id].data_view();
         }
       }
+
+      [[nodiscard]] values_view_type::iterator_type::value_type key_symbol(uint32_t key_id) const noexcept { return keys()[key_id]; }
+      [[nodiscard]] values_view_type::iterator_type::value_type value_symbol(uint32_t key_id, uint32_t value_id) const noexcept {
+        return values(key_id)[value_id];
+      }
     };
 
     using view_type = label_set_view;
diff --git a/pp/primitives/tests/label_name_set_tests.cpp b/pp/primitives/tests/label_name_set_tests.cpp
index 9f878fa2e..464f6bc8a 100644
--- a/pp/primitives/tests/label_name_set_tests.cpp
+++ b/pp/primitives/tests/label_name_set_tests.cpp
@@ -100,6 +100,23 @@ TEST_F(LabelNameSetEncodingBimapTest, CreateViewFromEncodingBimap) {
   encoding_table_.find_or_emplace(label_set2.names());
   encoding_table_.find_or_emplace(label_set3.names());
 
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  EXPECT_EQ(encoding_table_.size(), view.size());
+  EXPECT_TRUE(std::ranges::equal(encoding_table_, view));
+}
+
+TEST_F(LabelNameSetEncodingBimapTest, CreateViewSymbolsFromEncodingBimap) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"a", "1"}};
+  const LabelViewSet label_set2 = {{"b", "2"}, {"c", "3"}};
+  const LabelViewSet label_set3 = {{"d", "4"}, {"e", "5"}, {"f", "6"}};
+  encoding_table_.find_or_emplace(label_set1.names());
+  encoding_table_.find_or_emplace(label_set2.names());
+  encoding_table_.find_or_emplace(label_set3.names());
+
   // Act
   const auto symbols = encoding_table_.data_view().symbols();
 
diff --git a/pp/primitives/tests/label_set_tests.cpp b/pp/primitives/tests/label_set_tests.cpp
index 69d3d222c..4679b8b0e 100644
--- a/pp/primitives/tests/label_set_tests.cpp
+++ b/pp/primitives/tests/label_set_tests.cpp
@@ -104,10 +104,10 @@ TEST_F(LabelSetEncodingBimapTest, CreateViewFromEncodingBimap) {
 
   // Assert
   EXPECT_EQ(3U, view.size());
-  EXPECT_EQ(3U, view.labels_keys().size());
-  EXPECT_EQ(6U, view.labels_values().size());
-  EXPECT_TRUE(std::ranges::equal(view.labels_keys(), std::initializer_list{"job", "pod", "run"}));
-  EXPECT_TRUE(std::ranges::equal(view.labels_values(), std::initializer_list{"1", "2", "3", "a", "b", "first"}));
+  EXPECT_EQ(3U, view.keys().size());
+  EXPECT_EQ(6U, view.values().size());
+  EXPECT_TRUE(std::ranges::equal(view.keys(), std::initializer_list{"job", "pod", "run"}));
+  EXPECT_TRUE(std::ranges::equal(view.values(), std::initializer_list{"1", "2", "3", "a", "b", "first"}));
 }
 
 TEST_F(LabelSetEncodingBimapTest, EncodingBimapViewCheckId) {
@@ -142,23 +142,141 @@ TEST_F(LabelSetEncodingBimapTest, EncodingBimapViewCheckKeyId) {
   encoding_table_.find_or_emplace(label_set2);
   encoding_table_.find_or_emplace(label_set3);
 
+  // Act
   const auto view = encoding_table_.data_view();
+  auto k_it = view.keys().begin();
 
-  auto k_it = view.labels_keys().begin();
   const auto job_id = (k_it++).id();
   const auto pod_id = (k_it++).id();
   const auto run_id = (k_it++).id();
 
-  // Act
+  // Assert
   std::vector<uint32_t> view_value_symbols_ids;
-  for (auto it = view.labels_values().begin(), e = view.labels_values().end(); it != e; ++it) {
+  for (auto it = view.values().begin(), e = view.values().end(); it != e; ++it) {
     view_value_symbols_ids.push_back(it.key_id());
   }
 
-  // Assert
   EXPECT_TRUE(std::ranges::equal(view_value_symbols_ids, std::initializer_list{job_id, job_id, job_id, pod_id, pod_id, run_id}));
 }
 
+TEST_F(LabelSetEncodingBimapTest, ViewValuesForKeyId) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"job", "1"}};
+  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
+  const LabelViewSet label_set3 = {{"job", "3"}, {"run", "first"}, {"pod", "b"}};
+
+  encoding_table_.find_or_emplace(label_set1);
+  encoding_table_.find_or_emplace(label_set2);
+  encoding_table_.find_or_emplace(label_set3);
+
+  const auto view = encoding_table_.data_view();
+  auto k_it = view.keys().begin();
+  const auto job_id = (k_it++).id();
+  const auto pod_id = (k_it++).id();
+  const auto run_id = (k_it++).id();
+
+  // Act
+  const auto job_values = view.values(job_id);
+  const auto pod_values = view.values(pod_id);
+  const auto run_values = view.values(run_id);
+
+  // Assert
+  EXPECT_EQ(3U, job_values.size());
+  EXPECT_TRUE(std::ranges::equal(job_values, std::initializer_list{"1", "2", "3"}));
+
+  EXPECT_EQ(2U, pod_values.size());
+  EXPECT_TRUE(std::ranges::equal(pod_values, std::initializer_list{"a", "b"}));
+
+  EXPECT_EQ(1U, run_values.size());
+  EXPECT_TRUE(std::ranges::equal(run_values, std::initializer_list{"first"}));
+}
+
+TEST_F(LabelSetEncodingBimapTest, ViewKeySymbol) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"job", "1"}};
+  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
+  const LabelViewSet label_set3 = {{"job", "3"}, {"run", "first"}, {"pod", "b"}};
+
+  encoding_table_.find_or_emplace(label_set1);
+  encoding_table_.find_or_emplace(label_set2);
+  encoding_table_.find_or_emplace(label_set3);
+
+  // Act
+  const auto view = encoding_table_.data_view();
+  auto k_it = view.keys().begin();
+
+  const auto job_id = (k_it++).id();
+  const auto pod_id = (k_it++).id();
+  const auto run_id = (k_it++).id();
+
+  // Assert
+  EXPECT_EQ("job"sv, view.key_symbol(job_id));
+  EXPECT_EQ("pod"sv, view.key_symbol(pod_id));
+  EXPECT_EQ("run"sv, view.key_symbol(run_id));
+}
+
+TEST_F(LabelSetEncodingBimapTest, ViewValueSymbol) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"job", "1"}};
+  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
+  const LabelViewSet label_set3 = {{"job", "3"}, {"run", "first"}, {"pod", "b"}};
+
+  encoding_table_.find_or_emplace(label_set1);
+  encoding_table_.find_or_emplace(label_set2);
+  encoding_table_.find_or_emplace(label_set3);
+
+  // Act
+  const auto view = encoding_table_.data_view();
+  auto v_it = view.values().begin();
+
+  // Assert
+  EXPECT_EQ("1"sv, view.value_symbol(v_it.key_id(), v_it.value_id()));
+  ++v_it;
+  EXPECT_EQ("2"sv, view.value_symbol(v_it.key_id(), v_it.value_id()));
+  ++v_it;
+  EXPECT_EQ("3"sv, view.value_symbol(v_it.key_id(), v_it.value_id()));
+  ++v_it;
+  EXPECT_EQ("a"sv, view.value_symbol(v_it.key_id(), v_it.value_id()));
+  ++v_it;
+  EXPECT_EQ("b"sv, view.value_symbol(v_it.key_id(), v_it.value_id()));
+  ++v_it;
+  EXPECT_EQ("first"sv, view.value_symbol(v_it.key_id(), v_it.value_id()));
+}
+
+TEST_F(LabelSetEncodingBimapTest, ViewNextItemIndex) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"job", "1"}};
+  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
+
+  encoding_table_.find_or_emplace(label_set1);
+  encoding_table_.find_or_emplace(label_set2);
+
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  EXPECT_EQ(2U, view.next_item_index());
+  EXPECT_EQ(2U, view.size());
+}
+
+TEST_F(LabelSetEncodingBimapTest, ViewNextItemIndexAfterEmplace) {
+  // Arrange
+  const LabelViewSet label_set1 = {{"job", "1"}};
+  const LabelViewSet label_set2 = {{"job", "2"}, {"pod", "a"}};
+
+  encoding_table_.find_or_emplace(label_set1);
+  const auto view1 = encoding_table_.data_view();
+  EXPECT_EQ(1U, view1.next_item_index());
+
+  // Act
+  encoding_table_.find_or_emplace(label_set2);
+  const auto view2 = encoding_table_.data_view();
+
+  // Assert
+  EXPECT_EQ(2U, view2.next_item_index());
+  EXPECT_EQ(2U, view2.size());
+}
+
 class LabelSetDecodingTableTest : public testing::Test {
  protected:
   PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_table_;
diff --git a/pp/primitives/tests/symbol_tests.cpp b/pp/primitives/tests/symbol_tests.cpp
index 55e199df9..d75f23eba 100644
--- a/pp/primitives/tests/symbol_tests.cpp
+++ b/pp/primitives/tests/symbol_tests.cpp
@@ -131,6 +131,21 @@ TEST_F(SymbolEncodingBimapTest, EncodingBimapViewIteratorId) {
   EXPECT_TRUE(std::ranges::equal(view_ids, std::initializer_list{id1, id2, id3, id4}));
 }
 
+TEST_F(SymbolEncodingBimapTest, ViewIndexOperator) {
+  // Arrange
+  const auto id1 = encoding_table_.find_or_emplace("lol"s);
+  const auto id2 = encoding_table_.find_or_emplace("kek"s);
+  const auto id3 = encoding_table_.find_or_emplace("pod"s);
+
+  // Act
+  const auto view = encoding_table_.data_view();
+
+  // Assert
+  EXPECT_EQ("lol"sv, view[id1]);
+  EXPECT_EQ("kek"sv, view[id2]);
+  EXPECT_EQ("pod"sv, view[id3]);
+}
+
 class SymbolDecodingTableTest : public testing::Test {
  protected:
   PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_table_;

From c3c5c8bea8c60abf6d6d9d9e1cdda02035e49d59 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Fri, 19 Dec 2025 15:36:58 +0300
Subject: [PATCH 32/34] fixed other tests

---
 pp/primitives/snug_composites_filaments.h     | 14 ++++---
 pp/primitives/tests/label_set_tests.cpp       |  1 +
 .../index/section_writer/symbols_writer.h     | 12 +++---
 pp/series_index/querier/label_names_querier.h |  4 +-
 .../querier/label_values_querier.h            |  4 +-
 pp/series_index/queryable_encoding_bimap.h    | 38 ++++++++++---------
 6 files changed, 39 insertions(+), 34 deletions(-)

diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index 85ad7f28a..4616af795 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -1032,15 +1032,19 @@ struct LabelSet {
         const storage_type* storage_ptr_;
       };
 
-      auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
-      auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
+      [[nodiscard]] auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
+      [[nodiscard]] auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
 
       [[nodiscard]] size_t size() const noexcept { return storage_ptr->count(); }
       [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
 
-      keys_view_type keys() const noexcept { return storage_ptr->label_name_sets_table.data_view().symbols(); }
-      values_view_type values() const noexcept { return label_sets_values_view{.storage_ptr = storage_ptr}; }
-      values_view_type::values_view_type values(uint32_t key_id) const noexcept {
+      [[nodiscard]] label_name_sets_table_type::storage_type::view_type label_name_sets() const noexcept {
+        return storage_ptr->label_name_sets_table.data_view();
+      }
+
+      [[nodiscard]] keys_view_type keys() const noexcept { return storage_ptr->label_name_sets_table.data_view().symbols(); }
+      [[nodiscard]] values_view_type values() const noexcept { return label_sets_values_view{.storage_ptr = storage_ptr}; }
+      [[nodiscard]] values_view_type::values_view_type values(uint32_t key_id) const noexcept {
         if constexpr (BareBones::concepts::is_dereferenceable<typename symbols_tables_type::value_type>) {
           return (*storage_ptr->symbols_tables[key_id]).data_view();
         } else {
diff --git a/pp/primitives/tests/label_set_tests.cpp b/pp/primitives/tests/label_set_tests.cpp
index 4679b8b0e..34ac311f4 100644
--- a/pp/primitives/tests/label_set_tests.cpp
+++ b/pp/primitives/tests/label_set_tests.cpp
@@ -104,6 +104,7 @@ TEST_F(LabelSetEncodingBimapTest, CreateViewFromEncodingBimap) {
 
   // Assert
   EXPECT_EQ(3U, view.size());
+  EXPECT_EQ(3U, view.label_name_sets().size());
   EXPECT_EQ(3U, view.keys().size());
   EXPECT_EQ(6U, view.values().size());
   EXPECT_TRUE(std::ranges::equal(view.keys(), std::initializer_list{"job", "pod", "run"}));
diff --git a/pp/series_index/prometheus/tsdb/index/section_writer/symbols_writer.h b/pp/series_index/prometheus/tsdb/index/section_writer/symbols_writer.h
index 5a2a88297..e806f46a8 100644
--- a/pp/series_index/prometheus/tsdb/index/section_writer/symbols_writer.h
+++ b/pp/series_index/prometheus/tsdb/index/section_writer/symbols_writer.h
@@ -36,8 +36,8 @@ class SymbolsWriter {
     symbol_ids_.reserve(get_symbols_count() + 1);
     symbol_ids_.emplace_back(kEmptySymbol);
 
-    const auto names = lss_.data_view().labels_keys();
-    const auto values = lss_.data_view().labels_values();
+    const auto names = lss_.data_view().keys();
+    const auto values = lss_.data_view().values();
 
     for (auto it = names.begin(), e = names.end(); it != e; ++it) {
       symbol_ids_.emplace_back(it.id());
@@ -65,9 +65,7 @@ class SymbolsWriter {
     }
   }
 
-  [[nodiscard]] uint32_t get_symbols_count() const noexcept {
-    return lss_.data_view().labels_keys().size() + lss_.data_view().labels_values().size();
-  }
+  [[nodiscard]] uint32_t get_symbols_count() const noexcept { return lss_.data_view().keys().size() + lss_.data_view().values().size(); }
 
   [[nodiscard]] PROMPP_ALWAYS_INLINE static uint32_t serialized_string_length(const std::string_view& str) noexcept {
     return BareBones::Encoding::VarInt::length(str.length()) + str.length();
@@ -80,10 +78,10 @@ class SymbolsWriter {
 
     const auto view = lss_.data_view();
     if (symbol_id.is_name()) {
-      return view.labels_keys()[symbol_id.name_id];
+      return view.key_symbol(symbol_id.name_id);
     }
 
-    return view.labels_values().get_by_id(symbol_id.name_id, symbol_id.value_id);
+    return view.value_symbol(symbol_id.name_id, symbol_id.value_id);
   }
 
   void write_symbols() noexcept {
diff --git a/pp/series_index/querier/label_names_querier.h b/pp/series_index/querier/label_names_querier.h
index 92a6ff6de..e2a909375 100644
--- a/pp/series_index/querier/label_names_querier.h
+++ b/pp/series_index/querier/label_names_querier.h
@@ -36,11 +36,11 @@ class LabelNamesQuerier {
 
   template <class NameHandler, class Filter>
   void enumerate_label_names(NameHandler&& name_handler, Filter&& filter) const {
-    const auto names = index_.data_view().labels_keys();
+    const auto view = index_.data_view();
     auto& names_trie = index_.trie_index().names_trie();
     for (auto it = names_trie.make_enumerative_iterator(); it.is_valid(); it.next()) {
       if (filter(it.value())) {
-        name_handler(names[it.value()]);
+        name_handler(view.key_symbol(it.value()));
       }
     }
   }
diff --git a/pp/series_index/querier/label_values_querier.h b/pp/series_index/querier/label_values_querier.h
index 3377b6e7e..1cb8d26ef 100644
--- a/pp/series_index/querier/label_values_querier.h
+++ b/pp/series_index/querier/label_values_querier.h
@@ -41,10 +41,10 @@ class LabelValuesQuerier {
 
   template <class Trie, class ValueHandler, class Filter>
   void enumerate_label_values(uint32_t name_id, const Trie& trie, ValueHandler&& value_handler, Filter&& filter) const {
-    const auto values = index_.data_view().labels_values();
+    const auto view = index_.data_view();
     for (auto it = trie.make_enumerative_iterator(); it.is_valid(); it.next()) {
       if (filter(it.value())) {
-        value_handler(values.get_by_id(name_id, it.value()));
+        value_handler(view.value_symbol(name_id, it.value()));
       }
     }
   }
diff --git a/pp/series_index/queryable_encoding_bimap.h b/pp/series_index/queryable_encoding_bimap.h
index fb98b402a..914c27aba 100644
--- a/pp/series_index/queryable_encoding_bimap.h
+++ b/pp/series_index/queryable_encoding_bimap.h
@@ -52,7 +52,7 @@ class QueryableEncodingBimap final : public BareBones::SnugComposite::GenericDec
     hash = phmap_hash(hash);
     const auto ls_id = *ls_id_hash_set_.lazy_emplace_with_hash(label_set, hash, [&](const auto& ctor) {
       auto new_ls_id = Base::storage_.emplace_back(label_set);
-      const auto composite_label_set = Base::storage_.composite(new_ls_id);
+      const auto composite_label_set = Base::operator[](new_ls_id);
       ctor(typename Base::Proxy(new_ls_id));
       update_indexes(new_ls_id, composite_label_set);
       return new_ls_id;
@@ -159,19 +159,19 @@ class QueryableEncodingBimapCopier {
     using Item = ItemType;
     using ItemList = BareBones::Vector<ItemType>;
 
-    template <class SymbolsTables>
-    void reserve(uint32_t name_sets_count, uint32_t names_count, const SymbolsTables& symbols_tables) {
-      resize_and_fill_ids_list(name_sets, name_sets_count);
+    void reserve(const auto source_view) {
+      const auto names_count = source_view.keys().size();
+
+      resize_and_fill_ids_list(name_sets, source_view.label_name_sets().size());
       resize_and_fill_ids_list(names, names_count);
 
       values.resize(names_count);
 
-      for (auto [value_cache, symbol_table] : std::ranges::views::zip(values, symbols_tables)) {
-        if constexpr (BareBones::concepts::is_dereferenceable<decltype(symbol_table)>) {
-          resize_and_fill_ids_list(value_cache, symbol_table->size());
-        } else {
-          resize_and_fill_ids_list(value_cache, symbol_table.size());
-        }
+      uint32_t v_id = 0;
+      for (auto it = source_view.keys().begin(), e = source_view.keys().end(); it != e; ++it, ++v_id) {
+        auto& value_cache = values[v_id];
+
+        resize_and_fill_ids_list(value_cache, source_view.values(it.id()).size());
       }
     }
 
@@ -194,7 +194,7 @@ class QueryableEncodingBimapCopier {
     old_new_ids_.reserve(source_.size());
 
     Cache<uint32_t> cache;
-    cache.reserve(source_.storage_.label_name_sets_table.size(), source_.data_view().labels_keys().size(), source_.storage_.symbols_tables);
+    cache.reserve(source_.data_view());
 
     destination_.reserve(source_);
 
@@ -221,7 +221,7 @@ class QueryableEncodingBimapCopier {
 
   void build_reverse_index() {
     const auto size = destination_.size();
-    const auto names_view = destination_.data_view().labels_keys();
+    const auto names_view = destination_.data_view().keys();
     destination_.reverse_index_.reserve(names_view.size());
 
     for (uint32_t ls_id = 0; ls_id < size; ++ls_id) {
@@ -244,17 +244,19 @@ class QueryableEncodingBimapCopier {
   }
 
   void build_trie_index() {
-    const auto names_view = destination_.data_view().labels_keys();
+    const auto view = destination_.data_view();
+    const auto names_view = destination_.data_view().keys();
     destination_.trie_index_.reserve(names_view.size());
 
     for (auto name_it = names_view.begin(); name_it != names_view.end(); ++name_it) {
       const uint32_t name_id = name_it.id();
       destination_.trie_index_.insert_name(*name_it, name_id);
-      if constexpr (BareBones::concepts::is_dereferenceable<decltype(destination_.storage_.symbols_tables[name_id])>) {
-        destination_.trie_index_.insert_values(name_id, (*destination_.storage_.symbols_tables[name_id]).data_view());
-      } else {
-        destination_.trie_index_.insert_values(name_id, destination_.storage_.symbols_tables[name_id].data_view());
-      }
+      destination_.trie_index_.insert_values(name_id, view.values(name_id));
+      // if constexpr (BareBones::concepts::is_dereferenceable<decltype(destination_.storage_.symbols_tables[name_id])>) {
+      //   destination_.trie_index_.insert_values(name_id, (*destination_.storage_.symbols_tables[name_id]).data_view());
+      // } else {
+      //   destination_.trie_index_.insert_values(name_id, destination_.storage_.symbols_tables[name_id].data_view());
+      // }
     }
   }
 

From 18a740fd849956bd83772d5e4597b6302c1be6c0 Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Fri, 19 Dec 2025 16:05:40 +0300
Subject: [PATCH 33/34] all tests pass + entrypoint builds

---
 pp/head/status.h                              | 15 +++----
 ...load_gorilla_from_wal_and_process_data.cpp |  4 +-
 .../load_lss_from_wal_test.cpp                |  4 +-
 .../save_gorilla_to_wal_test.cpp              |  4 +-
 pp/performance_tests/save_lss_to_wal_test.cpp |  4 +-
 pp/primitives/snug_composites_filaments.h     | 41 ++++++++++---------
 pp/series_index/queryable_encoding_bimap.h    |  1 -
 7 files changed, 35 insertions(+), 38 deletions(-)

diff --git a/pp/head/status.h b/pp/head/status.h
index 20dbe6720..3c02651be 100644
--- a/pp/head/status.h
+++ b/pp/head/status.h
@@ -140,13 +140,12 @@ class StatusGetterLSS {
   }
 
   void fill_lss_statistic() noexcept {
-    auto& names = lss_.data().label_name_sets_table.data().symbols_table;
-    for (uint32_t name_id = 0; name_id < names.size(); ++name_id) {
-      auto count = lss_.data().symbols_tables[name_id]->size();
+    const auto view = lss_.data_view();
+    for (auto k_it = view.keys().begin(), k_e = view.keys().end(); k_it != k_e; ++k_it) {
+      const auto count = view.values(k_it.id()).size();
 
       label_count_ += count;
-      top_label_value_count_by_name_.add(count,
-                                         [&] PROMPP_LAMBDA_INLINE { return StringCountItem<StringType>{.name = StringType(names[name_id]), .count = count}; });
+      top_label_value_count_by_name_.add(count, [&] PROMPP_LAMBDA_INLINE { return StringCountItem<StringType>{.name = StringType(*k_it), .count = count}; });
     }
 
     top_label_value_count_by_name_.sort();
@@ -196,11 +195,9 @@ class StatusGetterLSS {
     }
   }
 
-  [[nodiscard]] PROMPP_ALWAYS_INLINE StringType get_label_name(uint32_t name_id) const noexcept {
-    return StringType(lss_.data().label_name_sets_table.data().symbols_table[name_id]);
-  }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE StringType get_label_name(uint32_t name_id) const noexcept { return StringType(lss_.data_view().key_symbol(name_id)); }
   [[nodiscard]] PROMPP_ALWAYS_INLINE StringType get_label_value(uint32_t name_id, uint32_t value_id) const noexcept {
-    return StringType(lss_.data().symbols_tables[name_id]->operator[](value_id));
+    return StringType(lss_.data_view().value_symbol(name_id, value_id));
   }
 };
 
diff --git a/pp/performance_tests/load_gorilla_from_wal_and_process_data.cpp b/pp/performance_tests/load_gorilla_from_wal_and_process_data.cpp
index 313055bcc..1e39ca6fb 100644
--- a/pp/performance_tests/load_gorilla_from_wal_and_process_data.cpp
+++ b/pp/performance_tests/load_gorilla_from_wal_and_process_data.cpp
@@ -27,8 +27,8 @@ void load_gorilla_from_wal_and_process_data::execute(const Config& config, Metri
     period += time_to_process_data + (end - start);
 
     log() << "Loaded label sets: " << (wal.series() - series) << std::endl;
-    log() << "Number of label name symbols: " << wal.label_sets().data().label_name_sets_table.data().symbols_table.size() << std::endl;
-    log() << "Number of label name sets: " << wal.label_sets().data().label_name_sets_table.size() << std::endl;
+    log() << "Number of label name symbols: " << wal.label_sets().data_view().keys().size() << std::endl;
+    log() << "Number of label name sets: " << wal.label_sets().data_view().label_name_sets().size() << std::endl;
     log() << "Number of label sets: " << wal.label_sets().size() << std::endl;
     log() << "Loaded samples: " << (wal.samples() - samples) << std::endl;
     log() << "Number of samples processed: " << wal.samples() << std::endl;
diff --git a/pp/performance_tests/load_lss_from_wal_test.cpp b/pp/performance_tests/load_lss_from_wal_test.cpp
index 364ad4721..591b8d0f1 100644
--- a/pp/performance_tests/load_lss_from_wal_test.cpp
+++ b/pp/performance_tests/load_lss_from_wal_test.cpp
@@ -26,8 +26,8 @@ void load_lss_from_wal::execute(const Config& config, Metrics& metrics) const {
     log() << "Loaded label sets: " << (lss.size() - old_size) << std::endl;
     log() << "Load time per label set (overall avg): " << (std::chrono::duration_cast<std::chrono::nanoseconds>(now - start).count() / lss.size()) << " ns"
           << std::endl;
-    log() << "Number of label name symbols: " << lss.data().label_name_sets_table.data().symbols_table.size() << std::endl;
-    log() << "Number of label name sets: " << lss.data().label_name_sets_table.size() << std::endl;
+    log() << "Number of label name symbols: " << lss.data_view().keys().size() << std::endl;
+    log() << "Number of label name sets: " << lss.data_view().label_name_sets().size() << std::endl;
     log() << "Number of label sets: " << lss.size() << std::endl;
     log() << std::endl;
   }
diff --git a/pp/performance_tests/save_gorilla_to_wal_test.cpp b/pp/performance_tests/save_gorilla_to_wal_test.cpp
index 0d4b6da8c..77f4f8a97 100644
--- a/pp/performance_tests/save_gorilla_to_wal_test.cpp
+++ b/pp/performance_tests/save_gorilla_to_wal_test.cpp
@@ -34,8 +34,8 @@ void save_gorilla_to_wal::execute(const Config& config, Metrics& metrics) const
       ++count;
 
       if (dummy_wal.cnt() % 1000000 == 0) {
-        log() << "Number of label name symbols: " << wal.label_sets().data().label_name_sets_table.data().symbols_table.size() << std::endl;
-        log() << "Number of label name sets: " << wal.label_sets().data().label_name_sets_table.size() << std::endl;
+        log() << "Number of label name symbols: " << wal.label_sets().data_view().keys().size() << std::endl;
+        log() << "Number of label name sets: " << wal.label_sets().data_view().label_name_sets().size() << std::endl;
         log() << "Number of label sets: " << wal.label_sets().size() << std::endl;
         ppp("label_sets", wal.label_sets_bytes(), wal.samples());
         ppp("ls_id", wal.ls_id_bytes(), wal.samples());
diff --git a/pp/performance_tests/save_lss_to_wal_test.cpp b/pp/performance_tests/save_lss_to_wal_test.cpp
index ccc6fc53b..eadf8b23b 100644
--- a/pp/performance_tests/save_lss_to_wal_test.cpp
+++ b/pp/performance_tests/save_lss_to_wal_test.cpp
@@ -27,8 +27,8 @@ void save_lss_to_wal::execute(const Config& config, Metrics& metrics) const {
         auto now = std::chrono::steady_clock::now();
         log() << "Processed: " << dummy_wal.cnt()
               << " Time per sample: " << (std::chrono::duration_cast<std::chrono::nanoseconds>(now - start).count() / dummy_wal.cnt()) << " ns" << std::endl;
-        log() << "Number of label name symbols: " << lss.data().label_name_sets_table.data().symbols_table.size() << std::endl;
-        log() << "Number of label name sets: " << lss.data().label_name_sets_table.size() << std::endl;
+        log() << "Number of label name symbols: " << lss.data_view().keys().size() << std::endl;
+        log() << "Number of label name sets: " << lss.data_view().label_name_sets().size() << std::endl;
         log() << "Number of label sets: " << lss.size() << std::endl;
         log() << std::endl;
       }
diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index 4616af795..da08b4239 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -122,10 +122,10 @@ struct Symbol {
         const storage_type* storage_ptr_;
       };
 
-      auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
-      auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
+      [[nodiscard]] auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
+      [[nodiscard]] auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
 
-      [[nodiscard]] size_t size() const noexcept { return storage_ptr->count(); }
+      [[nodiscard]] uint32_t size() const noexcept { return storage_ptr->count(); }
       [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
 
       [[nodiscard]] composite_type operator[](uint32_t id) const noexcept { return storage_ptr->composite(id); }
@@ -143,8 +143,8 @@ struct Symbol {
 
     [[nodiscard]] uint32_t count() const noexcept { return items.size(); }
 
-    [[nodiscard]] size_t remainder_size() const noexcept {
-      constexpr size_t max_ui32 = std::numeric_limits<uint32_t>::max();
+    [[nodiscard]] uint32_t remainder_size() const noexcept {
+      constexpr uint32_t max_ui32 = std::numeric_limits<uint32_t>::max();
       assert(data.size() <= max_ui32);
       return max_ui32 - data.size();
     }
@@ -321,7 +321,8 @@ struct LabelNameSet {
 
       auto begin() const noexcept { return iterator_type{symbols_table_ptr_, symbols_ids_it_}; }
       auto end() const noexcept { return iterator_type{symbols_table_ptr_, symbols_ids_it_ + size()}; }
-      [[nodiscard]] size_t size() const noexcept { return size_; }
+
+      [[nodiscard]] uint32_t size() const noexcept { return size_; }
 
       template <class T>
       bool operator==(const T& other) const noexcept {
@@ -455,13 +456,13 @@ struct LabelNameSet {
         const storage_type* storage_ptr_;
       };
 
-      auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
-      auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
+      [[nodiscard]] auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
+      [[nodiscard]] auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
 
-      [[nodiscard]] size_t size() const noexcept { return storage_ptr->count(); }
+      [[nodiscard]] uint32_t size() const noexcept { return storage_ptr->count(); }
       [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
 
-      symbols_view_type symbols() const noexcept { return storage_ptr->symbols_table.data_view(); }
+      [[nodiscard]] symbols_view_type symbols() const noexcept { return storage_ptr->symbols_table.data_view(); }
     };
 
     using view_type = label_name_set_view;
@@ -478,11 +479,11 @@ struct LabelNameSet {
 
     [[nodiscard]] uint32_t count() const noexcept { return items.size(); }
 
-    [[nodiscard]] size_t remainder_size() const noexcept {
-      constexpr size_t max_ui32 = std::numeric_limits<uint32_t>::max();
+    [[nodiscard]] uint32_t remainder_size() const noexcept {
+      constexpr uint32_t max_ui32 = std::numeric_limits<uint32_t>::max();
       assert(symbols_ids_sequences.size() <= max_ui32);
 
-      const size_t remainder_for_symbols = max_ui32 - symbols_ids_sequences.size();
+      const uint32_t remainder_for_symbols = max_ui32 - symbols_ids_sequences.size();
       return std::min(symbols_table.remainder_size(), remainder_for_symbols);
     }
 
@@ -1035,7 +1036,7 @@ struct LabelSet {
       [[nodiscard]] auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
       [[nodiscard]] auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
 
-      [[nodiscard]] size_t size() const noexcept { return storage_ptr->count(); }
+      [[nodiscard]] uint32_t size() const noexcept { return storage_ptr->count(); }
       [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
 
       [[nodiscard]] label_name_sets_table_type::storage_type::view_type label_name_sets() const noexcept {
@@ -1086,16 +1087,16 @@ struct LabelSet {
 
     [[nodiscard]] uint32_t count() const noexcept { return items.size(); }
 
-    [[nodiscard]] size_t remainder_size() const noexcept {
-      constexpr size_t max_ui32 = std::numeric_limits<uint32_t>::max();
+    [[nodiscard]] uint32_t remainder_size() const noexcept {
+      constexpr uint32_t max_ui32 = std::numeric_limits<uint32_t>::max();
 
       assert(symbols_ids_sequences.size() <= max_ui32);
 
-      size_t remainder_for_label_sets_table = label_name_sets_table.remainder_size();
-      size_t remainder_for_symbols_ids_sequences = max_ui32 - symbols_ids_sequences.size();
-      size_t remainder_for_symbol_table = std::numeric_limits<uint32_t>::max();
+      uint32_t remainder_for_label_sets_table = label_name_sets_table.remainder_size();
+      uint32_t remainder_for_symbols_ids_sequences = max_ui32 - symbols_ids_sequences.size();
+      uint32_t remainder_for_symbol_table = std::numeric_limits<uint32_t>::max();
       for (const auto& table : symbols_tables) {
-        if (const size_t n = table->remainder_size(); n < remainder_for_symbol_table) {
+        if (const uint32_t n = table->remainder_size(); n < remainder_for_symbol_table) {
           remainder_for_symbol_table = n;
         }
       }
diff --git a/pp/series_index/queryable_encoding_bimap.h b/pp/series_index/queryable_encoding_bimap.h
index 914c27aba..45338626b 100644
--- a/pp/series_index/queryable_encoding_bimap.h
+++ b/pp/series_index/queryable_encoding_bimap.h
@@ -77,7 +77,6 @@ class QueryableEncodingBimap final : public BareBones::SnugComposite::GenericDec
 
   using Base::reserve;
   PROMPP_ALWAYS_INLINE void reserve(uint32_t count) {
-    Base::items_.reserve(count);
     ls_id_hash_set_.reserve(count);
     added_series_.reserve(count);
   }

From 68b7e777ade95b1b0c2cea86eb3a0efe58a41a9e Mon Sep 17 00:00:00 2001
From: Gleb Shigin <gleb.shigin@gmail.com>
Date: Fri, 19 Dec 2025 16:23:31 +0300
Subject: [PATCH 34/34] consistent inline

---
 pp/primitives/snug_composites_filaments.h | 192 ++++++++++++----------
 1 file changed, 101 insertions(+), 91 deletions(-)

diff --git a/pp/primitives/snug_composites_filaments.h b/pp/primitives/snug_composites_filaments.h
index da08b4239..aaeda31ef 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -5,6 +5,7 @@
 #include "bare_bones/exception.h"
 #include "bare_bones/iterator.h"
 #include "bare_bones/memory.h"
+#include "bare_bones/preprocess.h"
 #include "bare_bones/snug_composite.h"
 #include "bare_bones/stream_v_byte.h"
 #include "hash.h"
@@ -122,13 +123,13 @@ struct Symbol {
         const storage_type* storage_ptr_;
       };
 
-      [[nodiscard]] auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
-      [[nodiscard]] auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
 
-      [[nodiscard]] uint32_t size() const noexcept { return storage_ptr->count(); }
-      [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return storage_ptr->count(); }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
 
-      [[nodiscard]] composite_type operator[](uint32_t id) const noexcept { return storage_ptr->composite(id); }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE composite_type operator[](uint32_t id) const noexcept { return storage_ptr->composite(id); }
     };
 
     using view_type = symbols_view;
@@ -141,21 +142,21 @@ struct Symbol {
     Vector<char> data;
     Vector<item_type> items;
 
-    [[nodiscard]] uint32_t count() const noexcept { return items.size(); }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t count() const noexcept { return static_cast<uint32_t>(items.size()); }
 
-    [[nodiscard]] uint32_t remainder_size() const noexcept {
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t remainder_size() const noexcept {
       constexpr uint32_t max_ui32 = std::numeric_limits<uint32_t>::max();
       assert(data.size() <= max_ui32);
-      return max_ui32 - data.size();
+      return max_ui32 - static_cast<uint32_t>(data.size());
     }
 
     template <class AnotherStorageType>
-    void reserve(const AnotherStorageType& other) noexcept {
+    PROMPP_ALWAYS_INLINE void reserve(const AnotherStorageType& other) noexcept {
       items.reserve(other.items.size());
       data.reserve(other.data.size());
     }
 
-    [[nodiscard]] composite_type composite(uint32_t id) const noexcept {
+    [[nodiscard]] PROMPP_ALWAYS_INLINE composite_type composite(uint32_t id) const noexcept {
       const auto item = items[id];
       return std::string_view(data.data() + item.pos, item.length);
     }
@@ -166,19 +167,23 @@ struct Symbol {
       }
     }
 
-    [[nodiscard]] uint32_t allocated_memory() const noexcept { return BareBones::mem::allocated_memory(data) + BareBones::mem::allocated_memory(items); }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t allocated_memory() const noexcept {
+      return BareBones::mem::allocated_memory(data) + BareBones::mem::allocated_memory(items);
+    }
 
-    [[nodiscard]] uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
 
-    uint32_t emplace_back(composite_type str) noexcept {
-      const uint32_t id = items.size();
-      items.emplace_back(data.size(), str.length());
+    PROMPP_ALWAYS_INLINE uint32_t emplace_back(composite_type str) noexcept {
+      const uint32_t id = static_cast<uint32_t>(items.size());
+      items.emplace_back(static_cast<uint32_t>(data.size()), static_cast<uint32_t>(str.length()));
       data.push_back(str.begin(), str.end());
       return id;
     }
 
-    [[nodiscard]] checkpoint_type checkpoint() const noexcept { return {data.size(), items.size()}; }
-    void rollback(const checkpoint_type& checkpoint) noexcept {
+    [[nodiscard]] PROMPP_ALWAYS_INLINE checkpoint_type checkpoint() const noexcept {
+      return {static_cast<uint32_t>(data.size()), static_cast<uint32_t>(items.size())};
+    }
+    PROMPP_ALWAYS_INLINE void rollback(const checkpoint_type& checkpoint) noexcept {
       assert(checkpoint.data_size <= data.size());
       assert(checkpoint.items_size <= items.size());
       data.resize(checkpoint.data_size);
@@ -230,7 +235,7 @@ struct Symbol {
       return std::views::iota(original_size, items.size());
     }
 
-    view_type view() const noexcept { return {.storage_ptr = this}; }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE view_type view() const noexcept { return {.storage_ptr = this}; }
   };
 };
 
@@ -291,23 +296,23 @@ struct LabelNameSet {
         explicit iterator_type(const symbols_table_type* symbols_table_ptr, symbols_ids_sequences_type::const_iterator it) noexcept
             : symbols_table_ptr_{symbols_table_ptr}, symbols_ids_it_{it} {}
 
-        iterator_type& operator++() noexcept {
+        PROMPP_ALWAYS_INLINE iterator_type& operator++() noexcept {
           ++symbols_ids_it_;
           return *this;
         }
 
-        iterator_type operator++(int) noexcept {
+        PROMPP_ALWAYS_INLINE iterator_type operator++(int) noexcept {
           iterator_type retval = *this;
           ++(*this);
           return retval;
         }
-        bool operator==(const iterator_type& other) const noexcept {
+        PROMPP_ALWAYS_INLINE bool operator==(const iterator_type& other) const noexcept {
           return symbols_table_ptr_ == other.symbols_table_ptr_ && symbols_ids_it_ == other.symbols_ids_it_;
         }
 
-        value_type operator*() const noexcept { return symbols_table_ptr_->operator[](*symbols_ids_it_); }
+        [[nodiscard]] PROMPP_ALWAYS_INLINE value_type operator*() const noexcept { return symbols_table_ptr_->operator[](*symbols_ids_it_); }
 
-        [[nodiscard]] uint32_t id() const noexcept { return *symbols_ids_it_; }
+        [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t id() const noexcept { return *symbols_ids_it_; }
 
        private:
         const symbols_table_type* symbols_table_ptr_;
@@ -319,18 +324,18 @@ struct LabelNameSet {
       explicit composite_type(const symbols_table_type* symbols_table_ptr, symbols_ids_sequences_type::const_iterator symbols_ids_it, uint32_t size)
           : symbols_table_ptr_{symbols_table_ptr}, symbols_ids_it_{symbols_ids_it}, size_{size} {}
 
-      auto begin() const noexcept { return iterator_type{symbols_table_ptr_, symbols_ids_it_}; }
-      auto end() const noexcept { return iterator_type{symbols_table_ptr_, symbols_ids_it_ + size()}; }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE auto begin() const noexcept { return iterator_type{symbols_table_ptr_, symbols_ids_it_}; }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE auto end() const noexcept { return iterator_type{symbols_table_ptr_, symbols_ids_it_ + size()}; }
 
-      [[nodiscard]] uint32_t size() const noexcept { return size_; }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return size_; }
 
       template <class T>
-      bool operator==(const T& other) const noexcept {
+      PROMPP_ALWAYS_INLINE bool operator==(const T& other) const noexcept {
         return std::ranges::equal(begin(), end(), other.begin(), other.end());
       }
 
       template <class T>
-      bool operator<(const T& other) const noexcept {
+      PROMPP_ALWAYS_INLINE bool operator<(const T& other) const noexcept {
         return std::ranges::lexicographical_compare(begin(), end(), other.begin(), other.end());
       }
 
@@ -434,35 +439,35 @@ struct LabelNameSet {
         iterator_type() = default;
         explicit iterator_type(const storage_type& storage, uint32_t id) noexcept : id_{id}, storage_ptr_(&storage) {}
 
-        iterator_type& operator++() noexcept {
+        PROMPP_ALWAYS_INLINE iterator_type& operator++() noexcept {
           ++id_;
           return *this;
         }
 
-        iterator_type operator++(int) noexcept {
+        PROMPP_ALWAYS_INLINE iterator_type operator++(int) noexcept {
           iterator_type retval = *this;
           ++(*this);
           return retval;
         }
-        bool operator==(const iterator_type& other) const noexcept { return id_ == other.id_ && storage_ptr_ == other.storage_ptr_; }
-        bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept { return id_ == storage_ptr_->items.size(); }
+        PROMPP_ALWAYS_INLINE bool operator==(const iterator_type& other) const noexcept { return id_ == other.id_ && storage_ptr_ == other.storage_ptr_; }
+        PROMPP_ALWAYS_INLINE bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept { return id_ == storage_ptr_->items.size(); }
 
-        value_type operator*() const noexcept { return storage_ptr_->composite(id_); }
+        [[nodiscard]] PROMPP_ALWAYS_INLINE value_type operator*() const noexcept { return storage_ptr_->composite(id_); }
 
-        [[nodiscard]] uint32_t id() const noexcept { return id_; }
+        [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t id() const noexcept { return id_; }
 
        private:
         uint32_t id_{0};
         const storage_type* storage_ptr_;
       };
 
-      [[nodiscard]] auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
-      [[nodiscard]] auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
 
-      [[nodiscard]] uint32_t size() const noexcept { return storage_ptr->count(); }
-      [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return storage_ptr->count(); }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
 
-      [[nodiscard]] symbols_view_type symbols() const noexcept { return storage_ptr->symbols_table.data_view(); }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE symbols_view_type symbols() const noexcept { return storage_ptr->symbols_table.data_view(); }
     };
 
     using view_type = label_name_set_view;
@@ -477,24 +482,24 @@ struct LabelNameSet {
     symbols_ids_sequences_type symbols_ids_sequences;
     Vector<item_type> items;
 
-    [[nodiscard]] uint32_t count() const noexcept { return items.size(); }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t count() const noexcept { return static_cast<uint32_t>(items.size()); }
 
-    [[nodiscard]] uint32_t remainder_size() const noexcept {
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t remainder_size() const noexcept {
       constexpr uint32_t max_ui32 = std::numeric_limits<uint32_t>::max();
       assert(symbols_ids_sequences.size() <= max_ui32);
 
-      const uint32_t remainder_for_symbols = max_ui32 - symbols_ids_sequences.size();
+      const uint32_t remainder_for_symbols = max_ui32 - static_cast<uint32_t>(symbols_ids_sequences.size());
       return std::min(symbols_table.remainder_size(), remainder_for_symbols);
     }
 
     template <class AnotherStorageType>
-    void reserve(const AnotherStorageType& other) noexcept {
+    PROMPP_ALWAYS_INLINE void reserve(const AnotherStorageType& other) noexcept {
       symbols_table.reserve(other.symbols_table);
       symbols_ids_sequences.reserve(other.symbols_ids_sequences.size());
       items.reserve(other.items.size());
     }
 
-    [[nodiscard]] composite_type composite(uint32_t id) const noexcept {
+    [[nodiscard]] PROMPP_ALWAYS_INLINE composite_type composite(uint32_t id) const noexcept {
       const auto item = items[id];
       const auto begin = symbols_ids_sequences.begin() + item.pos;
       return composite_type(&symbols_table, begin, item.size);
@@ -515,18 +520,18 @@ struct LabelNameSet {
       }
     }
 
-    [[nodiscard]] uint32_t allocated_memory() const noexcept {
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t allocated_memory() const noexcept {
       return BareBones::mem::allocated_memory(symbols_table) + BareBones::mem::allocated_memory(symbols_ids_sequences) +
              BareBones::mem::allocated_memory(items);
     }
 
-    [[nodiscard]] uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
 
     template <class OtherLabelNameSet, class Cache = NoCache>
-    uint32_t emplace_back(const OtherLabelNameSet& label_name_set, Cache&& cache = {}) noexcept {
-      const uint32_t id = items.size();
+    PROMPP_ALWAYS_INLINE uint32_t emplace_back(const OtherLabelNameSet& label_name_set, Cache&& cache = {}) noexcept {
+      const uint32_t id = static_cast<uint32_t>(items.size());
 
-      uint32_t pos = symbols_ids_sequences.size();
+      uint32_t pos = static_cast<uint32_t>(symbols_ids_sequences.size());
       uint32_t size = 0;
 
       if constexpr (BareBones::concepts::has_size<OtherLabelNameSet>) {
@@ -534,7 +539,7 @@ struct LabelNameSet {
       }
 
       if constexpr (BareBones::concepts::has_size<OtherLabelNameSet>) {
-        symbols_ids_sequences.reserve(symbols_ids_sequences.size() + size);
+        symbols_ids_sequences.reserve(static_cast<size_t>(symbols_ids_sequences.size()) + size);
       }
 
       const auto end = label_name_set.end();
@@ -550,8 +555,10 @@ struct LabelNameSet {
       return id;
     }
 
-    [[nodiscard]] checkpoint_type checkpoint() const noexcept { return {symbols_ids_sequences.size(), symbols_table.checkpoint(), items.size()}; }
-    void rollback(const checkpoint_type& checkpoint) noexcept {
+    [[nodiscard]] PROMPP_ALWAYS_INLINE checkpoint_type checkpoint() const noexcept {
+      return {static_cast<uint32_t>(symbols_ids_sequences.size()), symbols_table.checkpoint(), static_cast<uint32_t>(items.size())};
+    }
+    PROMPP_ALWAYS_INLINE void rollback(const checkpoint_type& checkpoint) noexcept {
       assert(checkpoint.symbols_ids_size <= symbols_ids_sequences.size());
       assert(checkpoint.items_size <= items.size());
 
@@ -610,11 +617,11 @@ struct LabelNameSet {
       return std::views::iota(items_original_size, items.size());
     }
 
-    view_type view() const noexcept { return {.storage_ptr = this}; }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE view_type view() const noexcept { return {.storage_ptr = this}; }
 
    private:
     template <class LabelNameIterator, class Cache>
-    uint32_t find_or_emplace_label_name(const LabelNameIterator& label_name, Cache&& cache) {
+    PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_label_name(const LabelNameIterator& label_name, Cache&& cache) {
       if constexpr (use_find_or_emplace_with_cache<Cache, LabelNameIterator, symbols_table_type, decltype(*label_name)>) {
         symbols_table.find_or_emplace_with_cache(*label_name, label_name.id(), cache.names);
       }
@@ -701,7 +708,7 @@ struct LabelSet {
           return lnsi_ == other.lnsi_ && vi_ == other.vi_;
         }
 
-        PROMPP_ALWAYS_INLINE value_type operator*() const noexcept {
+        [[nodiscard]] PROMPP_ALWAYS_INLINE value_type operator*() const noexcept {
           if constexpr (BareBones::concepts::is_dereferenceable<decltype(data_->symbols_tables[lnsi_.id()])>) {
             const auto& smbl_tbl = *data_->symbols_tables[lnsi_.id()];
             return make_pair(*lnsi_, smbl_tbl[*vi_]);
@@ -719,11 +726,11 @@ struct LabelSet {
       using iterator = Iterator<decltype(label_name_set_.begin()), decltype(values_begin_)>;
       using end_iterator = Iterator<decltype(label_name_set_.end()), decltype(values_end_)>;
 
-      PROMPP_ALWAYS_INLINE auto begin() const noexcept {
+      [[nodiscard]] PROMPP_ALWAYS_INLINE auto begin() const noexcept {
         return Iterator<decltype(label_name_set_.begin()), decltype(values_begin_)>(data_, label_name_set_.begin(), values_begin_);
       }
 
-      PROMPP_ALWAYS_INLINE auto end() const noexcept {
+      [[nodiscard]] PROMPP_ALWAYS_INLINE auto end() const noexcept {
         return Iterator<decltype(label_name_set_.end()), decltype(values_end_)>(data_, label_name_set_.end(), values_end_);
       }
 
@@ -918,7 +925,7 @@ struct LabelSet {
           get_values_range();
         }
 
-        iterator_type& operator++() noexcept {
+        PROMPP_ALWAYS_INLINE iterator_type& operator++() noexcept {
           ++value_it_;
           if (value_it_ == value_it_end_) {
             ++key_it_;
@@ -927,19 +934,21 @@ struct LabelSet {
           return *this;
         }
 
-        iterator_type operator++(int) noexcept {
+        PROMPP_ALWAYS_INLINE iterator_type operator++(int) noexcept {
           iterator_type retval = *this;
           ++(*this);
           return retval;
         }
 
-        bool operator==(const iterator_type& other) const = default;
-        bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept { return key_it_ == key_it_end_ && value_it_ == value_it_end_; }
+        PROMPP_ALWAYS_INLINE bool operator==(const iterator_type& other) const = default;
+        PROMPP_ALWAYS_INLINE bool operator==(BareBones::iterator::IteratorSentinelType) const noexcept {
+          return key_it_ == key_it_end_ && value_it_ == value_it_end_;
+        }
 
-        value_type operator*() const noexcept { return *value_it_; }
+        [[nodiscard]] PROMPP_ALWAYS_INLINE value_type operator*() const noexcept { return *value_it_; }
 
-        [[nodiscard]] uint32_t key_id() const noexcept { return key_it_.id(); }
-        [[nodiscard]] uint32_t value_id() const noexcept { return value_it_.id(); }
+        [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t key_id() const noexcept { return key_it_.id(); }
+        [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t value_id() const noexcept { return value_it_.id(); }
 
        private:
         void get_values_range() noexcept {
@@ -972,16 +981,16 @@ struct LabelSet {
         values_view_type::iterator_type value_it_end_;
       };
 
-      auto begin() const noexcept {
+      [[nodiscard]] PROMPP_ALWAYS_INLINE auto begin() const noexcept {
         return iterator_type{storage_ptr->symbols_tables, storage_ptr->label_name_sets_table.data_view().symbols().begin(),
                              storage_ptr->label_name_sets_table.data_view().symbols().end()};
       }
-      auto end() const noexcept {
+      [[nodiscard]] PROMPP_ALWAYS_INLINE auto end() const noexcept {
         return iterator_type{storage_ptr->symbols_tables, storage_ptr->label_name_sets_table.data_view().symbols().end(),
                              storage_ptr->label_name_sets_table.data_view().symbols().end()};
       }
 
-      [[nodiscard]] size_t size() const noexcept {
+      [[nodiscard]] PROMPP_ALWAYS_INLINE size_t size() const noexcept {
         size_t total_size = 0;
         const auto keys_view = storage_ptr->label_name_sets_table.data_view().symbols();
         for (auto key_it = keys_view.begin(); key_it != keys_view.end(); ++key_it) {
@@ -1033,19 +1042,19 @@ struct LabelSet {
         const storage_type* storage_ptr_;
       };
 
-      [[nodiscard]] auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
-      [[nodiscard]] auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE auto begin() const noexcept { return iterator_type{*storage_ptr, 0}; }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE auto end() const noexcept { return iterator_type{*storage_ptr, storage_ptr->items.size()}; }
 
-      [[nodiscard]] uint32_t size() const noexcept { return storage_ptr->count(); }
-      [[nodiscard]] uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return storage_ptr->count(); }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return storage_ptr->next_item_index(); }
 
-      [[nodiscard]] label_name_sets_table_type::storage_type::view_type label_name_sets() const noexcept {
+      [[nodiscard]] PROMPP_ALWAYS_INLINE label_name_sets_table_type::storage_type::view_type label_name_sets() const noexcept {
         return storage_ptr->label_name_sets_table.data_view();
       }
 
-      [[nodiscard]] keys_view_type keys() const noexcept { return storage_ptr->label_name_sets_table.data_view().symbols(); }
-      [[nodiscard]] values_view_type values() const noexcept { return label_sets_values_view{.storage_ptr = storage_ptr}; }
-      [[nodiscard]] values_view_type::values_view_type values(uint32_t key_id) const noexcept {
+      [[nodiscard]] PROMPP_ALWAYS_INLINE keys_view_type keys() const noexcept { return storage_ptr->label_name_sets_table.data_view().symbols(); }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE values_view_type values() const noexcept { return label_sets_values_view{.storage_ptr = storage_ptr}; }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE values_view_type::values_view_type values(uint32_t key_id) const noexcept {
         if constexpr (BareBones::concepts::is_dereferenceable<typename symbols_tables_type::value_type>) {
           return (*storage_ptr->symbols_tables[key_id]).data_view();
         } else {
@@ -1053,8 +1062,8 @@ struct LabelSet {
         }
       }
 
-      [[nodiscard]] values_view_type::iterator_type::value_type key_symbol(uint32_t key_id) const noexcept { return keys()[key_id]; }
-      [[nodiscard]] values_view_type::iterator_type::value_type value_symbol(uint32_t key_id, uint32_t value_id) const noexcept {
+      [[nodiscard]] PROMPP_ALWAYS_INLINE values_view_type::iterator_type::value_type key_symbol(uint32_t key_id) const noexcept { return keys()[key_id]; }
+      [[nodiscard]] PROMPP_ALWAYS_INLINE values_view_type::iterator_type::value_type value_symbol(uint32_t key_id, uint32_t value_id) const noexcept {
         return values(key_id)[value_id];
       }
     };
@@ -1085,15 +1094,15 @@ struct LabelSet {
     uint32_t shrinked_size{};
     Vector<item_type> items;
 
-    [[nodiscard]] uint32_t count() const noexcept { return items.size(); }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t count() const noexcept { return static_cast<uint32_t>(items.size()); }
 
-    [[nodiscard]] uint32_t remainder_size() const noexcept {
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t remainder_size() const noexcept {
       constexpr uint32_t max_ui32 = std::numeric_limits<uint32_t>::max();
 
       assert(symbols_ids_sequences.size() <= max_ui32);
 
       uint32_t remainder_for_label_sets_table = label_name_sets_table.remainder_size();
-      uint32_t remainder_for_symbols_ids_sequences = max_ui32 - symbols_ids_sequences.size();
+      uint32_t remainder_for_symbols_ids_sequences = max_ui32 - static_cast<uint32_t>(symbols_ids_sequences.size());
       uint32_t remainder_for_symbol_table = std::numeric_limits<uint32_t>::max();
       for (const auto& table : symbols_tables) {
         if (const uint32_t n = table->remainder_size(); n < remainder_for_symbol_table) {
@@ -1104,14 +1113,14 @@ struct LabelSet {
     }
 
     template <class AnotherStorageType>
-    void reserve(const AnotherStorageType& other) noexcept {
+    PROMPP_ALWAYS_INLINE void reserve(const AnotherStorageType& other) noexcept {
       symbols_ids_sequences.reserve(other.symbols_ids_sequences.size());
       symbols_tables.reserve(other.symbols_tables.size());
       label_name_sets_table.reserve(other.label_name_sets_table);
       items.reserve(other.items.size());
     }
 
-    [[nodiscard]] composite_type composite(uint32_t id) const noexcept {
+    [[nodiscard]] PROMPP_ALWAYS_INLINE composite_type composite(uint32_t id) const noexcept {
       const auto [lns_id, pos] = items[id];
 
       auto lns = label_name_sets_table[lns_id];
@@ -1154,15 +1163,15 @@ struct LabelSet {
       }
     }
 
-    [[nodiscard]] uint32_t allocated_memory() const noexcept {
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t allocated_memory() const noexcept {
       return BareBones::mem::allocated_memory(symbols_tables) + BareBones::mem::allocated_memory(symbols_ids_sequences) +
              BareBones::mem::allocated_memory(label_name_sets_table) + BareBones::mem::allocated_memory(items);
     }
 
-    [[nodiscard]] uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
 
     template <class OtherLabelSet, class Cache = NoCache>
-    uint32_t emplace_back(const OtherLabelSet& label_set, Cache&& cache = {}) noexcept {
+    PROMPP_ALWAYS_INLINE uint32_t emplace_back(const OtherLabelSet& label_set, Cache&& cache = {}) noexcept {
       const uint32_t id = items.size();
 
       const uint32_t lns_id = find_or_emplace_label_names_set(label_set, std::forward<Cache>(cache));
@@ -1198,8 +1207,9 @@ struct LabelSet {
       symbols_ids_sequences.shrink_to_fit();
     }
 
-    [[nodiscard]] checkpoint_type checkpoint() const noexcept {
-      auto checkpoint = checkpoint_type{next_item_index_, symbols_ids_sequences.size(), items.size(), label_name_sets_table.checkpoint(), {}};
+    [[nodiscard]] PROMPP_ALWAYS_INLINE checkpoint_type checkpoint() const noexcept {
+      auto checkpoint = checkpoint_type{
+          next_item_index_, static_cast<uint32_t>(symbols_ids_sequences.size()), static_cast<uint32_t>(items.size()), label_name_sets_table.checkpoint(), {}};
       checkpoint.symbols_tables_checkpoints_.reserve_and_write(symbols_tables.size(), [this](auto memory, uint32_t size) {
         for (auto& symbol_table : this->symbols_tables) {
           std::construct_at(memory++, symbol_table->checkpoint());
@@ -1209,7 +1219,7 @@ struct LabelSet {
       return checkpoint;
     }
 
-    void rollback(const checkpoint_type& checkpoint) noexcept {
+    PROMPP_ALWAYS_INLINE void rollback(const checkpoint_type& checkpoint) noexcept {
       assert(checkpoint.size_ <= symbols_ids_sequences.size());
       symbols_ids_sequences.resize(checkpoint.size_);
 
@@ -1326,11 +1336,11 @@ struct LabelSet {
       return std::views::iota(items_original_size, items.size());
     }
 
-    view_type view() const noexcept { return {.storage_ptr = this}; }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE view_type view() const noexcept { return {.storage_ptr = this}; }
 
    private:
     template <class LabelSet, class Cache>
-    uint32_t find_or_emplace_label_names_set(LabelSet& label_set, Cache&& cache) {
+    PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_label_names_set(LabelSet& label_set, Cache&& cache) {
       if constexpr (use_find_or_emplace_with_cache<Cache, LabelSet, decltype(label_name_sets_table), decltype(label_set.names())>) {
         return label_name_sets_table.find_or_emplace_with_cache(label_set.names(), label_set.id(), cache.name_sets, cache);
       }
@@ -1339,7 +1349,7 @@ struct LabelSet {
     }
 
     template <class LabelIterator, class Cache>
-    uint32_t find_or_emplace_symbol(uint32_t lns_id, const LabelIterator& label, Cache&& cache) {
+    PROMPP_ALWAYS_INLINE uint32_t find_or_emplace_symbol(uint32_t lns_id, const LabelIterator& label, Cache&& cache) {
       if constexpr (use_find_or_emplace_with_cache<Cache, LabelIterator, decltype(*symbols_tables[0]), decltype((*label).second)>) {
         const auto name_id = label.name_id();
         return symbols_tables[lns_id]->find_or_emplace_with_cache((*label).second, label.value_id(), cache.values[name_id]);