diff --git a/pp/bare_bones/iterator.h b/pp/bare_bones/iterator.h
index 6b6c0cedf7..a26c30e514 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.h b/pp/bare_bones/snug_composite.h
index e8526fe41b..9e80021d41 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"
@@ -18,15 +20,18 @@ 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
- * as delta from init (zero) state.
+ * 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 a delta from the init (zero) state.
  */
 enum class SerializationMode : char { SNAPSHOT = 1, DELTA = 2 };
 
-template <class FilamentDataType>
-concept is_shrinkable = requires(FilamentDataType& data_type) {
-  { data_type.shrink_to(uint32_t()) };
+template <class Range>
+concept ls_id_range = std::ranges::range<Range> && std::same_as<std::ranges::range_value_t<Range>, uint32_t>;
+
+template <class FilamentStorageType>
+concept is_shrinkable = requires(FilamentStorageType& storage) {
+  { storage.shrink() };
 };
 
 template <class Derived>
@@ -39,21 +44,20 @@ 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 {
-  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;
 
  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;
 
@@ -65,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 {
@@ -87,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;
     }
   };
 
@@ -113,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 {
@@ -156,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
+      // write a version
       out.put(1);
 
       // 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 +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);
       }
     }
 
@@ -202,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_;
@@ -217,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(); }
 
@@ -259,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;
@@ -271,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());
     }
   }
 
@@ -322,9 +308,10 @@ 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) {
@@ -338,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));
@@ -346,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);
       }
     }
 
@@ -359,31 +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);
-
-    // 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_);
-    }
+    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>) {
-      static_assert(noexcept(static_cast<Derived*>(this)->after_items_load_impl(original_size)));
-      static_cast<Derived*>(this)->after_items_load_impl(original_size);
+    // 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);
     }
   }
 
@@ -399,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;
-    }
+  PROMPP_ALWAYS_INLINE auto begin() const noexcept { return storage_.view().begin(); }
+  PROMPP_ALWAYS_INLINE auto end() const noexcept { return storage_.view().end(); }
 
-    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_;
-
-   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>
@@ -527,18 +389,17 @@ 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>;
-  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>;
@@ -546,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_;
   }
 
@@ -575,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();
   }
 
@@ -613,11 +470,14 @@ 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(); }
 
-  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 +491,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));
     }
   }
@@ -648,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);
     });
   }
@@ -657,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);
     });
   }
@@ -670,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;
     });
@@ -696,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/tests/snug_composite_tests.cpp b/pp/bare_bones/tests/snug_composite_tests.cpp
index 49f8b51ffa..5cd6c7ddeb 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,501 @@ 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_; }
 
-   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());
+        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}, 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(); }
+
+    [[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 {
+      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");
+      }
     }
 
-    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]] 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();
+      const uint32_t pos = data.size();
+      items.emplace_back(pos, 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 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");
+      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 < 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)",
+                                     next_item_index, 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}; }
+
+    void shrink() noexcept {
+      shrinked_size += items.size();
+      items.clear();
+    }
   };
 
-  using composite_type = std::string_view;
+  using data_type = storage_type;
+};
 
-  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 EncodingBimap = BareBones::SnugComposite::EncodingBimap<TestStringFilament, Vector>;
+using ShrinkableEncodingBimap = BareBones::SnugComposite::ShrinkableEncodingBimap<TestStringFilament, Vector>;
 
-  const std::string_view composite(const data_type& data) const { return std::string_view(data.begin() + pos_ - data.shift(), len_); }
+class EncodingBimapFixture : public testing::Test {
+ protected:
+  EncodingBimap table_;
 
-  void validate(const data_type& data) const {
-    if (pos_ + len_ > data.size() + data.shift())
-      throw std::runtime_error("something went wrong");
-  }
+  static constexpr auto kInvalidId = std::numeric_limits<uint32_t>::max();
 };
 
-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);
+
+  // Act
+  const auto id1 = table_.find_or_emplace(value, hash_val);
+  const auto id2 = table_.find_or_emplace(value, hash_val);
 
-TYPED_TEST_SUITE(SnugComposite, SnugCompositesBimapTypes);
+  // 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;
 
-  std::string v = "12";
-  auto hash_val = BareBones::XXHash::hash(v);
-  auto id = outcomes.find_or_emplace(v, hash_val);
+  // Act
+  const auto found_id = table_.find(value);
 
-  EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
-  EXPECT_EQ(id, outcomes.find_or_emplace(v));
+  // Assert
+  EXPECT_FALSE(found_id.has_value());
+  EXPECT_EQ(kInvalidId, table_.find(value).value_or(kInvalidId));
+}
 
-  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));
+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);
 
-  v = "21";
-  hash_val = BareBones::XXHash::hash(v);
-  id = outcomes.find_or_emplace(v);
+  // Act
+  const auto found_id = table_.find(value, hash_val);
 
-  EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
-  EXPECT_EQ(id, outcomes.find_or_emplace(v));
+  // Assert
+  ASSERT_TRUE(found_id.has_value());
+  EXPECT_EQ(id, found_id.value());
+}
 
-  EXPECT_EQ(outcomes.find_or_emplace(v), outcomes.find(v));
-  EXPECT_EQ(outcomes.find_or_emplace(v), outcomes.find(v, hash_val));
+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);
+
+  // Act
+  const auto composite = table_[id];
+
+  // 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);
 
-  std::string v = "12";
-  size_t hash_val = std::hash<std::string>()(v);
-  auto id = outcomes.find_or_emplace(v, hash_val);
+  // Act
+  table_.rollback(checkpoint);
 
-  v = "21";
-  hash_val = std::hash<std::string>()(v);
+  // Assert
+  EXPECT_EQ(1U, table_.size());
+  EXPECT_TRUE(table_.find("test1"s).has_value());
+  EXPECT_FALSE(table_.find("test2"s).has_value());
+}
 
-  EXPECT_NE(id, outcomes.find_or_emplace(v, hash_val));
-  EXPECT_NE(id, outcomes.find_or_emplace(v));
+TEST_F(EncodingBimapFixture, RollbackToEmpty) {
+  // Arrange
+  const auto checkpoint = table_.checkpoint();
+  table_.find_or_emplace("test1"s);
 
-  v = "13";
-  id = outcomes.find_or_emplace(v);
+  // Act
+  table_.rollback(checkpoint);
 
-  v = "31";
-  hash_val = std::hash<std::string>()(v);
+  // Assert
+  EXPECT_EQ(0U, table_.size());
+}
+
+TEST_F(EncodingBimapFixture, SerializeDeserializeSnapshot) {
+  // Arrange
+  table_.find_or_emplace("test1"s);
+  table_.find_or_emplace("test2"s);
+  std::stringstream stream;
+
+  // 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 +516,108 @@ 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());
+
+  EXPECT_EQ("test1"s, table_[id_after]);
 }
 
-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();
+  table_.shrink_to_checkpoint_size(checkpoint);
+
+  table_.find_or_emplace("test2"s);
 
   // Act
-  table_.shrink_to_checkpoint_size(checkpoint);
-  table_.find_or_emplace("2"s);
 
   // 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);
+  const auto checkpoint = table_.checkpoint();
   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;
+  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
+  ShrinkableEncodingBimap table2;
+  std::stringstream snapshot_stream;
+
+  table_.find_or_emplace("test1"s);
+  table_.find_or_emplace("test2"s);
+  const auto initial_checkpoint = table_.checkpoint();
+
+  snapshot_stream << initial_checkpoint;
+  snapshot_stream >> table2;
   table2.shrink_to_checkpoint_size(table2.checkpoint());
 
-  table_.find_or_emplace("41"s);
-  table_.find_or_emplace("51"s);
-  stream << table_.checkpoint() - checkpoint;
-  stream >> table2;
+  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;
+
+  // Act
+  std::stringstream delta_stream;
+  delta_stream << delta;
+  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(2U, table2.size());
+
+  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
diff --git a/pp/head/status.h b/pp/head/status.h
index 20dbe67201..3c02651be5 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 313055bcc5..1e39ca6fb4 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 364ad47215..591b8d0f1d 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 0d4b6da8cb..77f4f8a974 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 ccc6fc53bc..eadf8b23b6 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 b2f7421f63..aaeda31ef1 100644
--- a/pp/primitives/snug_composites_filaments.h
+++ b/pp/primitives/snug_composites_filaments.h
@@ -3,6 +3,9 @@
 #include <scope_exit.h>
 
 #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"
@@ -10,54 +13,57 @@
 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;
+struct Symbol {
+  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;
+      uint32_t length;
+    };
 
- public:
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  class data_type : public Vector<char> {
-    class Checkpoint {
-      uint32_t size_;
+    struct checkpoint_type {
+      uint32_t data_size;
+      uint32_t items_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
+      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 first seq in the portion, if we are writing delta
+        // 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));
         }
 
-        // write  size
-        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));
 
         // write data
         if (size_to_save > 0) {
-          out.write(&data[first_to_save], size_to_save);
+          out.write(&storage.data[first_to_save], size_to_save);
         }
       }
 
-      PROMPP_ALWAYS_INLINE uint32_t save_size(data_type const&, Checkpoint 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;
 
+        // items
+        res += sizeof(item_type) * id_count;
+
         // version
         ++res;
 
@@ -67,12 +73,12 @@ class Symbol {
         // 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
         }
 
         // size
-        const uint32_t size_to_save = size_ - first_to_save;
+        const uint32_t size_to_save = data_size - first_to_save;
         res += sizeof(uint32_t);
 
         // data
@@ -82,26 +88,115 @@ class Symbol {
       }
     };
 
-   public:
-    using checkpoint_type = Checkpoint;
+    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_;
+      };
+
+      [[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]] 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(); }
 
-    data_type() noexcept = default;
-    data_type(const data_type&) = delete;
-    template <class AnotherDataType>
+      [[nodiscard]] PROMPP_ALWAYS_INLINE composite_type operator[](uint32_t id) const noexcept { return storage_ptr->composite(id); }
+    };
+
+    using view_type = symbols_view;
+
+    storage_type() noexcept = default;
+    template <class AnotherStorageType>
       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;
+    explicit storage_type(const AnotherStorageType& other) : data{other.data}, items{other.items} {}
+
+    Vector<char> data;
+    Vector<item_type> items;
+
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t count() const noexcept { return static_cast<uint32_t>(items.size()); }
+
+    [[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 - static_cast<uint32_t>(data.size());
+    }
+
+    template <class AnotherStorageType>
+    PROMPP_ALWAYS_INLINE void reserve(const AnotherStorageType& other) noexcept {
+      items.reserve(other.items.size());
+      data.reserve(other.data.size());
+    }
+
+    [[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);
+    }
 
-    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());
+    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]] PROMPP_ALWAYS_INLINE uint32_t allocated_memory() const noexcept {
+      return BareBones::mem::allocated_memory(data) + BareBones::mem::allocated_memory(items);
+    }
+
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
+
+    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]] 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);
+      items.resize(checkpoint.items_size);
     }
 
     template <class InputStream>
-    void load(InputStream& in) {
+    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) {
@@ -112,20 +207,20 @@ class Symbol {
       // 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
+      // 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 (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);
         }
       }
 
@@ -134,39 +229,14 @@ class Symbol {
       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);
-    }
+      data.resize(data.size() + size_to_load);
+      in.read(data.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();
+      return std::views::iota(original_size, items.size());
     }
 
-    template <class DataType>
-    PROMPP_ALWAYS_INLINE void reserve(const DataType& other) {
-      Vector<char>::reserve(other.size());
-    }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE view_type view() const noexcept { return {.storage_ptr = this}; }
   };
-
-  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_; }
 };
 
 }  // namespace PromPP::Primitives::SnugComposites::Filaments
@@ -202,67 +272,129 @@ 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_;
+struct LabelNameSet {
+  struct storage_type {
+    static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
 
-  static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
+    using symbols_table_type = SymbolsTableType<Vector>;
+    using symbols_ids_sequences_type = Vector<uint32_t>;
 
- public:
-  using symbols_table_type = SymbolsTableType<Vector>;
-  using symbols_ids_sequences_type = Vector<uint32_t>;
+    struct item_type {
+      uint32_t pos;
+      uint32_t size;
+    };
 
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  struct data_type {
-   private:
-    class Checkpoint {
-      using SerializationMode = BareBones::SnugComposite::SerializationMode;
+    class composite_type {
+     public:
+      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} {}
+
+        PROMPP_ALWAYS_INLINE iterator_type& operator++() noexcept {
+          ++symbols_ids_it_;
+          return *this;
+        }
 
-      uint32_t size_;
-      typename symbols_table_type::checkpoint_type symbols_table_checkpoint_;
+        PROMPP_ALWAYS_INLINE iterator_type operator++(int) noexcept {
+          iterator_type retval = *this;
+          ++(*this);
+          return retval;
+        }
+        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_;
+        }
 
-     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 value_type operator*() const noexcept { return symbols_table_ptr_->operator[](*symbols_ids_it_); }
+
+        [[nodiscard]] PROMPP_ALWAYS_INLINE 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} {}
+
+      [[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]] 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 <class T>
+      PROMPP_ALWAYS_INLINE 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& other) const noexcept {
+        return std::ranges::lexicographical_compare(begin(), end(), other.begin(), other.end());
+      }
+
+      friend size_t hash_value(const composite_type& lns) noexcept { return hash::hash_of_string_list(lns); }
+
+     private:
+      const symbols_table_type* symbols_table_ptr_;
+      symbols_ids_sequences_type::const_iterator symbols_ids_it_;
+      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>
-      PROMPP_ALWAYS_INLINE void save(S& out, data_type const& data, Checkpoint const* from = nullptr) const {
-        // write version
+      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 first seq in the portion, if we are writing delta
+        // 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->symbols_ids_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;
+        // 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 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 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_);
+          symbols_table_checkpoint.save(out, &from->symbols_table_checkpoint);
         } else {
-          symbols_table_checkpoint_.save(out);
+          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 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;
 
@@ -272,52 +404,176 @@ class LabelNameSet {
         // 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->symbols_ids_size;
           res += sizeof(uint32_t);
         }
 
         // size
-        const uint32_t size_to_save = size_ - first_to_save;
+        const uint32_t size_to_save = symbols_ids_size - first_to_save;
         res += sizeof(uint32_t);
 
         // data
-        res += sizeof(data.symbols_ids_sequences[first_to_save]) * size_to_save;
+        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_);
+          res += symbols_table_checkpoint.save_size(&from->symbols_table_checkpoint);
         } else {
-          res += symbols_table_checkpoint_.save_size();
+          res += symbols_table_checkpoint.save_size();
         }
 
         return res;
       }
     };
 
-   public:
+    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) {}
+
+        PROMPP_ALWAYS_INLINE iterator_type& operator++() noexcept {
+          ++id_;
+          return *this;
+        }
+
+        PROMPP_ALWAYS_INLINE iterator_type operator++(int) noexcept {
+          iterator_type retval = *this;
+          ++(*this);
+          return retval;
+        }
+        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(); }
+
+        [[nodiscard]] PROMPP_ALWAYS_INLINE value_type operator*() const noexcept { return storage_ptr_->composite(id_); }
+
+        [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t id() const noexcept { return id_; }
+
+       private:
+        uint32_t id_{0};
+        const storage_type* storage_ptr_;
+      };
+
+      [[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]] 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]] PROMPP_ALWAYS_INLINE 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
+    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;
-    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;
+    Vector<item_type> items;
+
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t count() const noexcept { return static_cast<uint32_t>(items.size()); }
 
-    using checkpoint_type = Checkpoint;
+    [[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);
 
-    PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return Checkpoint(*this); }
+      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);
+    }
 
-    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 AnotherStorageType>
+    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]] 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);
+    }
+
+    void validate(uint32_t id) const {
+      const auto [pos, size] = items[id];
+
+      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() + 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");
+        }
+      }
+    }
+
+    [[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]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
+
+    template <class OtherLabelNameSet, class Cache = NoCache>
+    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 = static_cast<uint32_t>(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(static_cast<size_t>(symbols_ids_sequences.size()) + size);
+      }
+
+      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;
+        }
+      }
+
+      items.emplace_back(pos, size);
+
+      return id;
+    }
+
+    [[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());
+
+      symbols_ids_sequences.resize(checkpoint.symbols_ids_size);
+      symbols_table.rollback(checkpoint.symbols_table_checkpoint);
+      items.resize(checkpoint.items_size);
     }
 
     template <class InputStream>
-    void load(InputStream& in) {
+    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) {
@@ -328,7 +584,7 @@ class LabelNameSet {
       // 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
+      // 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));
@@ -357,153 +613,160 @@ class LabelNameSet {
 
       // read symbols table
       symbols_table.load(in);
+
+      return std::views::iota(items_original_size, items.size());
     }
 
-    [[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);
+    [[nodiscard]] PROMPP_ALWAYS_INLINE view_type view() const noexcept { return {.storage_ptr = this}; }
 
-      size_t remainder_for_symbols = max_ui32 - this->symbols_ids_sequences.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 std::min(this->symbols_table.remainder_size(), remainder_for_symbols);
+      return symbols_table.find_or_emplace(*label_name);
     }
+  };
+};
 
-    [[nodiscard]] PROMPP_ALWAYS_INLINE size_t allocated_memory() const noexcept {
-      return symbols_table.allocated_memory() + BareBones::mem::allocated_memory(symbols_ids_sequences);
-    }
+template <template <template <class> class> class SymbolsTableType,
+          template <template <class> class> class LabelNameSetsTableType,
+          template <class> class Vector>
+struct LabelSet {
+  struct storage_type {
+    static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
 
-    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());
-    }
-  };
+    using label_values_symbols_table_type = SymbolsTableType<Vector>;
+    using label_name_sets_table_type = LabelNameSetsTableType<Vector>;
 
-  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;
-    }
+    using symbols_tables_type =
+        std::conditional_t<kIsReadOnly, BareBones::Vector<label_values_symbols_table_type>, Vector<std::unique_ptr<label_values_symbols_table_type>>>;
 
-    if constexpr (BareBones::concepts::has_size<OtherLabelNameSet>) {
-      data.symbols_ids_sequences.reserve(data.symbols_ids_sequences.size() + size_);
-    }
+    using symbol_ids_codec_type = BareBones::StreamVByte::Codec1234;
+    using symbols_ids_sequences_type = Vector<uint8_t>;
 
-    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_;
-      }
-    }
-  }
+    class composite_type {
+      using label_name_set_type = typename LabelNameSetsTableType<Vector>::value_type;
+      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;
 
-  [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t size() const noexcept { return size_; }
+      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_;
 
-  // 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:
+      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>::storage_type::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;
+        }
 
-   public:
-    using Base::Base;
+        PROMPP_ALWAYS_INLINE Iterator operator++(int) noexcept {
+          Iterator retval = *this;
+          ++(*this);
+          return retval;
+        }
 
-    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 OtherIteratorType>
+        PROMPP_ALWAYS_INLINE bool operator==(const OtherIteratorType& other) const noexcept {
+          return lnsi_ == other.lnsi_ && vi_ == other.vi_;
+        }
 
-    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());
-    }
+        [[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_]);
+          } else {
+            const auto& smbl_tbl = data_->symbols_tables[lnsi_.id()];
+            return make_pair(*lnsi_, smbl_tbl[*vi_]);
+          }
+        }
 
-    PROMPP_ALWAYS_INLINE friend size_t hash_value(const composite_type& lns) noexcept { return hash::hash_of_string_list(lns); }
-  };
+        [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t name_id() const noexcept { return lnsi_.id(); }
 
-  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_);
-  }
+        [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t value_id() const noexcept { return *vi_; }
+      };
 
-  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");
-    }
+      using iterator = Iterator<decltype(label_name_set_.begin()), decltype(values_begin_)>;
+      using end_iterator = Iterator<decltype(label_name_set_.end()), decltype(values_end_)>;
 
-    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");
+      [[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_);
       }
-    }
-  }
 
- 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);
-  }
-};
+      [[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_);
+      }
 
-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_;
+      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; });
+      }
 
-  static constexpr bool kIsReadOnly = BareBones::IsSharedSpan<Vector<uint8_t>>::value;
+      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; });
+      }
 
- public:
-  using symbols_tables_type = std::conditional_t<kIsReadOnly, BareBones::Vector<SymbolsTableType<Vector>>, Vector<std::unique_ptr<SymbolsTableType<Vector>>>>;
+      PROMPP_ALWAYS_INLINE friend size_t hash_value(const composite_type& ls) noexcept { return hash::hash_of_label_set(ls); }
+    };
 
-  using symbols_ids_sequences_type = Vector<uint8_t>;
+    struct item_type {
+      uint32_t lns_id;
+      uint32_t pos;
+    };
 
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  struct data_type {
-   private:
-    class Checkpoint {
+    struct checkpoint_type {
       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_;
+      uint32_t items_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 {
+      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);
 
@@ -517,7 +780,7 @@ class LabelSet {
           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();
+        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
@@ -525,8 +788,8 @@ class LabelSet {
         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);
+        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) {
@@ -577,9 +840,12 @@ class LabelSet {
         }
       }
 
-      PROMPP_ALWAYS_INLINE uint32_t save_size([[maybe_unused]] data_type const& data, Checkpoint const* from = nullptr) const {
+      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;
 
@@ -598,7 +864,7 @@ class LabelSet {
         res += sizeof(uint32_t);
 
         // data
-        res += sizeof(data.symbols_ids_sequences[0]) * size_to_save;
+        res += sizeof(storage.symbols_ids_sequences[0]) * size_to_save;
 
         // label name sets table
         if (from != nullptr) {
@@ -639,24 +905,180 @@ class LabelSet {
       }
     };
 
-   public:
-    using SymbolIdsCodec = BareBones::StreamVByte::Codec1234;
+    struct label_sets_values_view {
+      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;
 
-    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_{};
-    data_type() noexcept = default;
-    data_type(const data_type&) = delete;
+      const storage_type* storage_ptr;
+
+      class iterator_type {
+       public:
+        using iterator_category = std::input_iterator_tag;
+        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) {
+          get_values_range();
+        }
+
+        PROMPP_ALWAYS_INLINE iterator_type& operator++() noexcept {
+          ++value_it_;
+          if (value_it_ == value_it_end_) {
+            ++key_it_;
+            get_values_range();
+          }
+          return *this;
+        }
+
+        PROMPP_ALWAYS_INLINE iterator_type operator++(int) noexcept {
+          iterator_type retval = *this;
+          ++(*this);
+          return retval;
+        }
+
+        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_;
+        }
+
+        [[nodiscard]] PROMPP_ALWAYS_INLINE value_type operator*() const noexcept { return *value_it_; }
+
+        [[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 {
+          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()]).data_view();
+              value_it_ = values_view.begin();
+              value_it_end_ = values_view.end();
+            } else {
+              const auto values_view = (*symbols_tables_ptr_)[key_it_.id()].data_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_;
+
+        keys_view_type::iterator_type key_it_;
+        keys_view_type::iterator_type key_it_end_;
+
+        values_view_type::iterator_type value_it_;
+        values_view_type::iterator_type value_it_end_;
+      };
+
+      [[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()};
+      }
+      [[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]] 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) {
+          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;
+      }
+    };
+
+    struct label_set_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;
+
+      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_); }
 
-    template <class AnotherDataType>
+        [[nodiscard]] uint32_t id() const noexcept { return id_; }
+
+       private:
+        uint32_t id_{0};
+        const storage_type* storage_ptr_;
+      };
+
+      [[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]] 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]] 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]] 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 {
+          return storage_ptr->symbols_tables[key_id].data_view();
+        }
+      }
+
+      [[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];
+      }
+    };
+
+    using view_type = label_set_view;
+
+    storage_type() noexcept = default;
+    template <class AnotherStorageType>
       requires kIsReadOnly
-    explicit data_type(const AnotherDataType& other)
+    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_) {
+          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);
@@ -665,45 +1087,160 @@ class LabelSet {
       });
     }
 
-    data_type(data_type&&) noexcept = delete;
-    data_type& operator=(const data_type&) = delete;
-    data_type& operator=(data_type&&) noexcept = delete;
+    symbols_tables_type symbols_tables;
+    symbols_ids_sequences_type symbols_ids_sequences;
+    label_name_sets_table_type label_name_sets_table;
+    uint32_t next_item_index_{};
+    uint32_t shrinked_size{};
+    Vector<item_type> items;
+
+    [[nodiscard]] PROMPP_ALWAYS_INLINE uint32_t count() const noexcept { return static_cast<uint32_t>(items.size()); }
+
+    [[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 - 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) {
+          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>
+    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]] 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];
+      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);
+    }
+
+    void validate(uint32_t id) const {
+      const auto [lns_id, pos] = items[id];
 
-    using checkpoint_type = Checkpoint;
+      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[lns_id];
 
-    PROMPP_ALWAYS_INLINE void shrink_to(uint32_t size) {
-      assert(size <= symbols_ids_sequences.size());
+      // check that streamvbyte keys are in range
+      auto keys_size = BareBones::StreamVByte::keys_size(lns.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");
+      }
 
-      shrinked_size_ += symbols_ids_sequences.size() - size;
-      symbols_ids_sequences.resize(size);
+      // 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() + 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() + 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]] 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]] PROMPP_ALWAYS_INLINE uint32_t next_item_index() const noexcept { return static_cast<uint32_t>(items.size()); }
+
+    template <class OtherLabelSet, class Cache = NoCache>
+    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));
+      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());
+      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<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;
+      }
+
+      next_item_index_ += symbols_ids_sequences.size() - size_before;
+
+      items.emplace_back(lns_id, pos);
+
+      return id;
+    }
+
+    void shrink() noexcept {
+      shrinked_size += symbols_ids_sequences.size();
+
+      items.resize(0);
+      items.shrink_to_fit();
+      symbols_ids_sequences.resize(0);
       symbols_ids_sequences.shrink_to_fit();
     }
 
-    PROMPP_ALWAYS_INLINE auto checkpoint() const noexcept { return Checkpoint(*this); }
+    [[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());
+        }
+        return size;
+      });
+      return checkpoint;
+    }
 
-    PROMPP_ALWAYS_INLINE void rollback(const checkpoint_type& s) noexcept {
-      assert(s.size() <= symbols_ids_sequences.size());
-      symbols_ids_sequences.resize(s.size());
+    PROMPP_ALWAYS_INLINE 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(s.label_name_sets());
+      label_name_sets_table.rollback(checkpoint.label_name_sets_table_checkpoint_);
 
-      auto symbols_tables_checkpoints = s.symbols();
+      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());
-    }
-
-    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);
+      items.resize(checkpoint.items_size);
     }
 
     template <class InputStream>
-    void load(InputStream& in) {
+    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) {
@@ -738,7 +1275,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;
       });
@@ -788,9 +1325,6 @@ class LabelSet {
           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
@@ -799,221 +1333,31 @@ class LabelSet {
         symbols_tables[id]->load(in);
       }
 
-      // just to be 100% sure
-      assert(label_name_sets_table.data().symbols_table.size() == symbols_tables.size());
+      return std::views::iota(items_original_size, items.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();
+    [[nodiscard]] PROMPP_ALWAYS_INLINE view_type view() const noexcept { return {.storage_ptr = this}; }
 
-      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;
-        }
+   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 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>>());
+      return label_name_sets_table.find_or_emplace(label_set.names());
     }
 
-    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_]);
-        }
+    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]);
       }
 
-      [[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; });
+      return symbols_tables[lns_id]->find_or_emplace((*label).second);
     }
-
-    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);
-  }
 };
 
 }  // namespace PromPP::Primitives::SnugComposites::Filaments
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 0000000000..464f6bc8a2
--- /dev/null
+++ b/pp/primitives/tests/label_name_set_tests.cpp
@@ -0,0 +1,245 @@
+#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 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();
+
+  // 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 0000000000..34ac311f43
--- /dev/null
+++ b/pp/primitives/tests/label_set_tests.cpp
@@ -0,0 +1,377 @@
+#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.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"}));
+  EXPECT_TRUE(std::ranges::equal(view.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);
+
+  // 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
+  std::vector<uint32_t> view_value_symbols_ids;
+  for (auto it = view.values().begin(), e = view.values().end(); it != e; ++it) {
+    view_value_symbols_ids.push_back(it.key_id());
+  }
+
+  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_;
+  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_filaments_tests.cpp b/pp/primitives/tests/snug_composites_filaments_tests.cpp
deleted file mode 100644
index a57b3b538c..0000000000
--- a/pp/primitives/tests/snug_composites_filaments_tests.cpp
+++ /dev/null
@@ -1,336 +0,0 @@
-#include <random>
-
-#include "gtest/gtest.h"
-
-#include "primitives/label_set.h"
-#include "primitives/snug_composites_filaments.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);
-}
-
-}  // namespace
diff --git a/pp/primitives/tests/snug_composites_tests.cpp b/pp/primitives/tests/snug_composites_tests.cpp
index 870f472ca7..0a40be7dfd 100644
--- a/pp/primitives/tests/snug_composites_tests.cpp
+++ b/pp/primitives/tests/snug_composites_tests.cpp
@@ -1,303 +1,183 @@
 #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;
 using BareBones::Vector;
 using PromPP::Primitives::LabelViewSet;
 using std::operator""sv;
 
-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); }
-};
-
-using NamesSetForTest = GenericNamesSetForTest<std::vector>;
-
-template <template <class> class Vector>
-class GenericLabelSetForTest : public Vector<std::pair<std::string, std::string>> {
-  using Base = Vector<std::pair<std::string, std::string>>;
-
- public:
-  using Base::Base;
-
-  GenericNamesSetForTest<Vector> names() const {
-    GenericNamesSetForTest<Vector> tns;
-
-    for (const auto& [label_name, _] : *this) {
-      tns.push_back(label_name);
-    }
-
-    return tns;
+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"}};
   }
-};
-
-using LabelSetForTest = GenericLabelSetForTest<std::vector>;
-
-template <template <class> class Vector>
-using SymbolFilament = BareBones::SnugComposite::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 = BareBones::SnugComposite::EncodingBimap<LabelNameSetFilament, Vector>;
 
-template <template <class> class Vector>
-using GenericLabelSet = PromPP::Primitives::SnugComposites::Filaments::LabelSet<SymbolFilament, LabelSetFilament, Vector>;
-
-using LabelSet = GenericLabelSet<Vector>;
-
-struct SnugComposites : public testing::Test {};
-
-TEST(SnugComposites, SnapshotRollbackSymbolEncodingBimap) {
-  PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_bimap;
-
-  const std::vector<std::string> etalons_rollback = {"11111", "22222", "33333"};
-  const std::vector<std::string> etalons = {"44444", "55555", "66666"};
-  const auto first_element = "xxxxx";
-
-  // 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);
+  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;
   }
 
-  // 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++);
+  void check_decoding_table() const {
+    ASSERT_EQ(3U, decoding_table_.size());
+    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]));
   }
+};
 
-  // rollback
-  encoding_bimap.rollback(checkpoint);
+TEST_F(ShrinkableEncodingBimapLabelSetFixture, ShrinkAndLoad) {
+  // Arrange
 
-  // add new elements
-  for (const auto& str : etalons) {
-    encoding_bimap.find_or_emplace(str);
+  // 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);
   }
-
-  // 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++);
+  {
+    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);
   }
-}
-
-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();
+  // Assert
+  check_decoding_table();
+}
 
-  // add elements
-  for (const auto& etalon : etalons_rollback) {
-    encoding_bimap.find_or_emplace(etalon);
-  }
+TEST_F(ShrinkableEncodingBimapLabelSetFixture, LoadWithoutShrink) {
+  // Arrange
 
-  // 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++);
+  // Act
+  {
+    encoding_table_.find_or_emplace(ls_[0]);
+    encoding_table_.find_or_emplace(ls_[1]);
+    create_and_load_checkpoint(nullptr);
   }
-
-  // rollback
-  encoding_bimap.rollback(checkpoint);
-
-  // add new elements
-  for (const auto& etalon : etalons) {
-    encoding_bimap.find_or_emplace(etalon);
+  {
+    const auto empty_checkpoint = encoding_table_.checkpoint();
+    encoding_table_.find_or_emplace(ls_[2]);
+    create_and_load_checkpoint(&empty_checkpoint);
   }
 
-  // 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
+  check_decoding_table();
 }
 
-TEST(SnugComposites, SnapshotRollbackLabelSetEncodingBimap) {
-  LabelSet::data_type data;
-  auto data_checkpoint = data.checkpoint();
+TEST_F(ShrinkableEncodingBimapLabelSetFixture, LoadFromNonShrinkableTable) {
+  // Arrange
+  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> non_shrinkable_encoding_bimap;
+  std::stringstream stream;
+
+  // Act
+  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());
 
-  PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<Vector> encoding_bimap;
+  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_;
 
-  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"}};
+  // 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());
+}
 
-  // 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();
+TEST_F(ShrinkableEncodingBimapLabelSetFixture, EmptyCheckpointWithShrink) {
+  // Arrange
 
-  // 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));
+  // 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);
   }
-
-  // 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;
+  {
+    const auto empty_checkpoint = encoding_table_.checkpoint();
+    create_and_load_checkpoint(&empty_checkpoint);
   }
 
-  outcome++;
-  while (etalon != etalons_rollback.end() && outcome != encoding_bimap.end()) {
-    auto etalon_another = (*etalon).begin();
-    auto outcome_another = (*outcome).begin();
+  // Assert
+  check_decoding_table();
+}
 
-    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;
-    }
+TEST_F(ShrinkableEncodingBimapLabelSetFixture, EmptyCheckpointWithoutShrink) {
+  // Arrange
 
-    etalon++;
-    outcome++;
+  // 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);
   }
-
-  // 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));
+  {
+    const auto empty_checkpoint = encoding_table_.checkpoint();
+    create_and_load_checkpoint(&empty_checkpoint);
   }
 
-  // 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;
-  }
+  // Assert
+  check_decoding_table();
+}
 
-  outcome++;
-  while (etalon != etalons.end() && outcome != encoding_bimap.end()) {
-    auto etalon_another = (*etalon).begin();
-    auto outcome_another = (*outcome).begin();
+TEST_F(ShrinkableEncodingBimapLabelSetFixture, CheckSaveSize) {
+  // Arrange
+  encoding_table_.find_or_emplace(ls_[0]);
+  encoding_table_.find_or_emplace(ls_[1]);
 
-    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;
-    }
+  auto checkpoint = encoding_table_.checkpoint();
 
-    etalon++;
-    outcome++;
-  }
-}
+  encoding_table_.shrink_to_checkpoint_size(checkpoint);
 
-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));
-  };
-};
+  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]);
 
-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);
+  auto checkpoint2 = encoding_table_.checkpoint();
 
-TYPED_TEST(EncodingBimap, SaveSizeFULL) {
-  TypeParam encoding_bimap;
-  std::ostringstream stream;
+  auto delta = checkpoint2 - checkpoint;
+  BareBones::ShrinkedToFitOStringStream ss;
+  ss << delta;
 
-  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);
-}
+  // Act
+  const auto save_size = delta.save_size();
 
-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);
+  // Assert
+  EXPECT_EQ(ss.view().size(), save_size);
 }
 
-class LssViewFixture : public testing::Test {
+class SharedDataFixture : public testing::Test {
  protected:
   template <class T>
   using SharedVector = BareBones::SharedVector<T, BareBones::DefaultReallocator>;
@@ -305,74 +185,74 @@ class LssViewFixture : public testing::Test {
   template <class T>
   using SharedSpan = BareBones::SharedSpan<T, BareBones::DefaultReallocator>;
 
-  using Symbol = PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<SharedVector>;
-  using SymbolView = PromPP::Primitives::SnugComposites::Symbol::DecodingTable<SharedSpan>;
+  using SymbolEncodingBimap = PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<SharedVector>;
+  using SymbolDecodingTable = PromPP::Primitives::SnugComposites::Symbol::DecodingTable<SharedSpan>;
 
-  using LabelNameSet = PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<SharedVector>;
-  using LabelNameSetView = PromPP::Primitives::SnugComposites::LabelNameSet::DecodingTable<SharedSpan>;
+  using LabelNameSetEncodingBimap = PromPP::Primitives::SnugComposites::LabelNameSet::EncodingBimap<SharedVector>;
+  using LabelNameSetDecodingTable = PromPP::Primitives::SnugComposites::LabelNameSet::DecodingTable<SharedSpan>;
 
-  using LabelSet = PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<SharedVector>;
-  using LabelSetView = PromPP::Primitives::SnugComposites::LabelSet::DecodingTable<SharedSpan>;
+  using LabelSetEncodingBimap = PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<SharedVector>;
+  using LabelSetDecodingTable = PromPP::Primitives::SnugComposites::LabelSet::DecodingTable<SharedSpan>;
 };
 
-TEST_F(LssViewFixture, CopySymbol) {
+TEST_F(SharedDataFixture, CopySymbol) {
   // Arrange
-  Symbol source;
-  constexpr auto source_data = "string1"sv;
-  source.find_or_emplace(source_data);
+  SymbolEncodingBimap encoding_bimap;
+  constexpr auto symbol = "string1"sv;
+  encoding_bimap.find_or_emplace(symbol);
 
   // Act
-  const SymbolView view(source);
-  source.find_or_emplace("string2"sv);
+  const SymbolDecodingTable decoding_table(encoding_bimap);
+  encoding_bimap.find_or_emplace("string2"sv);
 
   // Assert
-  EXPECT_EQ(1U, view.size());
-  EXPECT_EQ(source_data, view[0]);
+  EXPECT_EQ(1U, decoding_table.size());
+  EXPECT_EQ(symbol, decoding_table[0]);
 }
 
-TEST_F(LssViewFixture, CopyLabelNameSet) {
+TEST_F(SharedDataFixture, CopyLabelNameSet) {
   // Arrange
-  LabelNameSet source;
-  const NamesSetForTest source_data{"name1", "name2", "name3"};
-  source.find_or_emplace(source_data);
+  LabelNameSetEncodingBimap encoding_bimap;
+  const LabelViewSet label_set{{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
+  encoding_bimap.find_or_emplace(label_set.names());
 
   // Act
-  const LabelNameSetView view(source);
-  source.find_or_emplace(NamesSetForTest{"name4", "name5"});
+  const LabelNameSetDecodingTable decoding_table(encoding_bimap);
+  encoding_bimap.find_or_emplace(LabelViewSet{{"name4", "value4"}}.names());
 
   // Assert
-  EXPECT_EQ(1U, view.size());
-  EXPECT_EQ(source_data, view[0]);
+  EXPECT_EQ(1U, decoding_table.size());
+  EXPECT_TRUE(std::ranges::equal(label_set.names(), decoding_table[0]));
 }
 
-TEST_F(LssViewFixture, CopyLabelSet) {
+TEST_F(SharedDataFixture, CopyLabelSet) {
   // Arrange
-  LabelSet source;
-  const LabelViewSet source_data{{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
-  source.find_or_emplace(source_data);
+  LabelSetEncodingBimap encoding_bimap;
+  const LabelViewSet label_set{{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
+  encoding_bimap.find_or_emplace(label_set);
 
   // Act
-  const LabelSetView view(source);
-  source.find_or_emplace(LabelViewSet{{"name4", "value4"}});
+  const LabelSetDecodingTable decoding_table(encoding_bimap);
+  encoding_bimap.find_or_emplace(LabelViewSet{{"name4", "value4"}});
 
   // Assert
-  EXPECT_EQ(1U, view.size());
-  EXPECT_EQ(source_data, view[0]);
+  EXPECT_EQ(1U, decoding_table.size());
+  EXPECT_TRUE(std::ranges::equal(label_set, decoding_table[0]));
 }
 
-TEST_F(LssViewFixture, UseCopyLabelSetAfterFreeSourceLabelSet) {
+TEST_F(SharedDataFixture, UseCopyLabelSetAfterFreeSourceLabelSet) {
   // Arrange
-  auto source = std::make_unique<LabelSet>();
-  const LabelViewSet source_data{{"name1", "value1"}, {"name2", "value2"}, {"name3", "value3"}};
-  source->find_or_emplace(source_data);
+  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 LabelSetView view(*source);
-  source.reset();
+  const LabelSetDecodingTable decoding_table(*encoding_bimap);
+  encoding_bimap.reset();
 
   // Assert
-  EXPECT_EQ(1U, view.size());
-  EXPECT_EQ(source_data, view[0]);
+  EXPECT_EQ(1U, decoding_table.size());
+  EXPECT_TRUE(std::ranges::equal(label_set, decoding_table[0]));
 }
 
 }  // namespace
diff --git a/pp/primitives/tests/symbol_tests.cpp b/pp/primitives/tests/symbol_tests.cpp
new file mode 100644
index 0000000000..d75f23eba3
--- /dev/null
+++ b/pp/primitives/tests/symbol_tests.cpp
@@ -0,0 +1,256 @@
+#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}));
+}
+
+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_;
+  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
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 030f2e5e0e..e806f46a85 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().keys();
+    const auto values = lss_.data_view().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); });
@@ -64,29 +65,23 @@ 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;
-  }
+  [[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();
   }
 
   [[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.key_symbol(symbol_id.name_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 cccd3b8d2b..e2a9093757 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 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_table[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 0a8a4e86d7..1cb8d26ef1 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 view = index_.data_view();
     for (auto it = trie.make_enumerative_iterator(); it.is_valid(); it.next()) {
       if (filter(it.value())) {
-        value_handler(values_table[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 4346589a99..45338626bb 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::operator[](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;
     });
@@ -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);
   }
@@ -101,11 +100,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);
       ls_id_hash_set_.emplace_with_hash(phmap_hash(hasher(label_set)), typename Base::Proxy(ls_id));
       update_indexes(ls_id, label_set);
@@ -156,19 +158,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());
       }
     }
 
@@ -191,7 +193,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_.data_view());
 
     destination_.reserve(source_);
 
@@ -201,7 +203,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();
@@ -218,7 +220,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().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];
@@ -240,12 +243,19 @@ 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 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);
+      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());
+      // }
     }
   }
 
diff --git a/pp/series_index/sorting_index.h b/pp/series_index/sorting_index.h
index 6906e22ce3..a5c7047523 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 04be0d3fac..2c9892a635 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_};
diff --git a/pp/wal/tests/wal_tests.cpp b/pp/wal/tests/wal_tests.cpp
index a0785e14e6..d75897e928 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,227 @@ 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 = ls_id, .timestamp = timestamp, .value = 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);
+
+  // 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;
+
+  // Act
+  encoder.add(timeseries);
+
+  // Assert
+  ASSERT_EQ(encoder.label_sets().size(), 1U);
+  EXPECT_TRUE(std::ranges::equal(label_set, encoder.label_sets()[0]));
+}
 
-  EXPECT_EQ(outcome_sample_reader == outcomes_reader_samples.end(), etalon_sample_reader == etalons_samples.end());
-  EXPECT_EQ(outcomes_reader_samples.size(), etalons_samples.size());
+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;
 
-  EXPECT_EQ(reader.samples(), NUM_VALUES);
-  EXPECT_EQ(writer_earliest_sample, reader.earliest_sample());
-  EXPECT_EQ(writer_latest_sample, reader.latest_sample());
+  // 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(WalFixture, BasicEncoderMany) {
-  using WALEncoder = PromPP::WAL::BasicEncoder<PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap<BareBones::Vector>>;
+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 +481,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 +492,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
diff --git a/pp/wal/wal.h b/pp/wal/wal.h
index af2c58f58d..2a24741153 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(); }