diff --git a/.clang-tidy b/.clang-tidy
index c4373515..d65343dd 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -22,6 +22,7 @@ Checks:
   - -misc-non-private-member-variables-in-classes
   - -misc-use-internal-linkage
   - -misc-use-anonymous-namespace
+  - -misc-include-cleaner
   - -cppcoreguidelines-pro-type-vararg
   - -cppcoreguidelines-non-private-member-variables-in-classes
   - -cppcoreguidelines-special-member-functions
diff --git a/AGENTS.md b/AGENTS.md
index b61a5ac8..9050466f 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -10,9 +10,11 @@
 - Initialize variables and objects using `{}` to distinguish from function call.
   - *Exception vector initialization*: In case vector must be created with size use `()` initialization to distinguish from initializer_list constructor.
 - Use `auto` whenever possible for variables with respect for references `auto&` and pointers `auto*`.
-- Check if pointer is null by comparing it to `nullptr` instead of using implicit conversion to `bool`.
+- Check if raw pointer is null by comparing it to `nullptr` instead of using implicit conversion to `bool`. Smart pointers could be check with implicit bool conversion.
 - If a function argument is not used, there are two options. If it's never used, just ommit the argument name. If it's used on some configurations use `[[maybe_unused]]` attribute.
 - Immediate lambda call pattern should be implemented by using `std::invoke`.
+- For each assert add comment like `assert(condition && "Comment")`.
+- For *internal* namespaces use `file_name_internal` format.
 
 ## Architecture & Object System
 
@@ -90,6 +92,13 @@
  Project build configured in `build-clang` (`<build-dir>`) with ninja.
  To build the project go into `<build-dir>/` and run `cmake --build . --parallel` or `ninja`.
 
+ ### Clang-tidy
+
+ - Use `build-clang/compile_commands.json` for `clang-tidy`.
+ - If `build-clang` exists but `compile_commands.json` is missing, report `clang-tidy` skipped because the compile database is missing, not because the build directory is missing.
+ - Do not claim the build directory is missing when `build-clang` exists.
+ - `compile_commands.json` may require configuring with `CMAKE_EXPORT_COMPILE_COMMANDS=ON`.
+
  To run tests, go into `<build-dir>` and run `ctest . --progress -j -E "((sodium)|(hydro)|(bcrypt)).*" --output-on-failure`.
  Or run specific test by name from `<build-dir>/tests/run/<test-name>`.
 
diff --git a/aether/ae_actions/ping.h b/aether/ae_actions/ping.h
index f7665a65..411deec6 100644
--- a/aether/ae_actions/ping.h
+++ b/aether/ae_actions/ping.h
@@ -27,6 +27,7 @@
 
 #  include "aether/ae_context.h"
 #  include "aether/api_protocol/request_id.h"
+#  include "aether/clock.h"
 #  include "aether/events/event_subscription.h"
 #  include "aether/events/events.h"
 #  include "aether/tasks/details/task_subsctiption.h"
diff --git a/aether/aether_app.cpp b/aether/aether_app.cpp
index ef3f084a..00ff8031 100644
--- a/aether/aether_app.cpp
+++ b/aether/aether_app.cpp
@@ -323,11 +323,11 @@ void AetherAppContext::InitComponentContext() {
 #endif  //  AE_DISTILLATION
 }
 
-RcPtr<AetherApp> AetherApp::Construct(AetherAppContext context) {
+std::unique_ptr<AetherApp> AetherApp::Construct(AetherAppContext context) {
   // init all the components in context
   context.InitComponentContext();
 
-  auto app = MakeRcPtr<AetherApp>();
+  auto app = std::unique_ptr<AetherApp>{new AetherApp()};
   app->aether_ = context.aether();
 #if AE_DISTILLATION
   app->aether_->tele_statistics = context.tele_statistics_.Resolve(context);
diff --git a/aether/aether_app.h b/aether/aether_app.h
index d6e70f25..9c84f84a 100644
--- a/aether/aether_app.h
+++ b/aether/aether_app.h
@@ -24,9 +24,9 @@
 
 #include "aether/common.h"
 #include "aether/config.h"
+#include "aether/memory.h"
 #include "aether/obj/domain.h"
 #include "aether/ptr/ptr.h"
-#include "aether/ptr/rc_ptr.h"
 
 #include "aether/actions/action.h"  // IWYU pragma: keep
 #include "aether/events/events.h"   // IWYU pragma: keep
@@ -145,10 +145,8 @@ class AetherAppContext {
  * \brief The enter point to the Aethernet application world
  */
 class AetherApp {
-  friend auto MakeRcPtr<AetherApp>() noexcept;
-
  public:
-  static RcPtr<AetherApp> Construct(AetherAppContext context);
+  static std::unique_ptr<AetherApp> Construct(AetherAppContext context);
 
   ~AetherApp();
 
diff --git a/aether/aether_c/aether_capi.cpp b/aether/aether_c/aether_capi.cpp
index fd3fbbe0..f5d6ca80 100644
--- a/aether/aether_c/aether_capi.cpp
+++ b/aether/aether_c/aether_capi.cpp
@@ -21,36 +21,36 @@
 
 #include <string_view>
 
-#include "aether/aether_c/extern_c.h"
 #include "aether/aether_c/c_errors.h"
+#include "aether/aether_c/extern_c.h"
 
+#include "aether/actions/actions_queue.h"
 #include "aether/memory.h"
-#include "aether/ptr/ptr.h"
 #include "aether/obj/obj_ptr.h"
+#include "aether/ptr/ptr.h"
 #include "aether/types/data_buffer.h"
-#include "aether/actions/actions_queue.h"
 
-#include "aether/client.h"
 #include "aether/aether_app.h"
+#include "aether/client.h"
 
 // IWYU pragma: begin_keeps
 #include "aether/wifi/wifi_driver_types.h"
 
 #include "aether/domain_storage/domain_storage_factory.h"
+#include "aether/domain_storage/file_system_std_storage.h"
 #include "aether/domain_storage/ram_domain_storage.h"
 #include "aether/domain_storage/spifs_domain_storage.h"
-#include "aether/domain_storage/file_system_std_storage.h"
 
 #include "aether/adapter_registry.h"
 #include "aether/adapters/ethernet.h"
-#include "aether/adapters/wifi_adapter.h"
 #include "aether/adapters/modem_adapter.h"
+#include "aether/adapters/wifi_adapter.h"
 
 #include "aether/client_messages/p2p_message_stream.h"
 #include "aether/client_messages/p2p_message_stream_manager.h"
 // IWYU pragma: end_keeps
 
-static ae::RcPtr<ae::AetherApp> aether_app;
+static std::shared_ptr<ae::AetherApp> aether_app;
 
 struct AetherClient {
   ClientConfig config{};
@@ -81,7 +81,7 @@ ae::SelectClientAction& SelectClientImpl(AetherClient* client,
     void* user_data;
   };
 
-  auto select_context = ae::MakeRcPtr<SelectContext>(
+  auto select_context = std::make_shared<SelectContext>(
       SelectContext{client, config->client_selected_cb,
                     config->message_received_cb, config->user_data});
 
@@ -310,7 +310,7 @@ int AetherEnd() {
     default_client.reset();
   }
   int exit_code = aether_app->IsExited() ? aether_app->ExitCode() : 0;
-  aether_app.Reset();
+  aether_app.reset();
   return exit_code;
 }
 
diff --git a/aether/all.h b/aether/all.h
index 6309df8f..20f5be39 100644
--- a/aether/all.h
+++ b/aether/all.h
@@ -41,7 +41,6 @@
 #include "aether/obj/registry.h"
 #include "aether/ptr/ptr.h"
 #include "aether/ptr/ptr_view.h"
-#include "aether/ptr/rc_ptr.h"
 
 #include "aether/domain_storage/domain_storage_factory.h"
 #include "aether/domain_storage/file_system_std_storage.h"
diff --git a/aether/cloud_connections/cloud_server_connection.cpp b/aether/cloud_connections/cloud_server_connection.cpp
index 422758b3..4cccca6c 100644
--- a/aether/cloud_connections/cloud_server_connection.cpp
+++ b/aether/cloud_connections/cloud_server_connection.cpp
@@ -33,7 +33,7 @@ void CloudServerConnection::SetPriority(std::size_t priority) {
 }
 
 void CloudServerConnection::Restream() {
-  if (client_connection_.get() != nullptr) {
+  if (client_connection_) {
     client_connection_->Restream();
   }
 }
@@ -44,15 +44,15 @@ void CloudServerConnection::SetQuarantine(bool value) {
 }
 
 bool CloudServerConnection::Connect() {
-  client_connection_.Reset();
+  client_connection_.reset();
   client_connection_ = connection_factory_->CreateConnection(server());
-  return client_connection_.get() != nullptr;
+  return static_cast<bool>(client_connection_);
 }
 
-void CloudServerConnection::Disconnect() { client_connection_.Reset(); }
+void CloudServerConnection::Disconnect() { client_connection_.reset(); }
 
 ClientServerConnection* CloudServerConnection::client_connection() {
-  if (client_connection_.get() != nullptr) {
+  if (client_connection_) {
     return client_connection_.get();
   }
   return nullptr;
diff --git a/aether/cloud_connections/cloud_server_connection.h b/aether/cloud_connections/cloud_server_connection.h
index 338583cc..1cfa4d18 100644
--- a/aether/cloud_connections/cloud_server_connection.h
+++ b/aether/cloud_connections/cloud_server_connection.h
@@ -17,8 +17,9 @@
 #ifndef AETHER_CLOUD_CONNECTIONS_CLOUD_SERVER_CONNECTION_H_
 #define AETHER_CLOUD_CONNECTIONS_CLOUD_SERVER_CONNECTION_H_
 
+#include <memory>
+
 #include "aether/ptr/ptr_view.h"
-#include "aether/ptr/rc_ptr.h"
 
 #include "aether/server_connections/client_server_connection.h"
 #include "aether/server_connections/iserver_connection_factory.h"
@@ -49,7 +50,7 @@ class CloudServerConnection {
  private:
   PtrView<Server> server_;
   IServerConnectionFactory* connection_factory_;
-  RcPtr<ClientServerConnection> client_connection_;
+  std::shared_ptr<ClientServerConnection> client_connection_;
   std::size_t priority_;
   bool is_quarantined_;
 };
diff --git a/aether/config.h b/aether/config.h
index 21a5605b..f9ef0d3c 100644
--- a/aether/config.h
+++ b/aether/config.h
@@ -56,7 +56,7 @@
 
 // Maximum size in bytes for a single pending response pool element.
 #ifndef AE_API_PROTOCOL_PENDING_RESPONSE_MAX_SIZE
-#  define AE_API_PROTOCOL_PENDING_RESPONSE_MAX_SIZE 2 * sizeof(void*)
+#  define AE_API_PROTOCOL_PENDING_RESPONSE_MAX_SIZE 4 * sizeof(void*)
 #endif
 
 #ifndef AE_API_PROTOCOL_PENDING_RESPONSE_ALIGN
diff --git a/aether/connection_manager/server_connection_manager.cpp b/aether/connection_manager/server_connection_manager.cpp
index db1e713d..ff63c88d 100644
--- a/aether/connection_manager/server_connection_manager.cpp
+++ b/aether/connection_manager/server_connection_manager.cpp
@@ -24,9 +24,8 @@ ServerConnectionManager::ServerConnectionFactory::ServerConnectionFactory(
     ServerConnectionManager& server_connection_manager)
     : server_connection_manager_{&server_connection_manager} {}
 
-RcPtr<ClientServerConnection>
-ServerConnectionManager::ServerConnectionFactory::CreateConnection(
-    Ptr<Server> const& server) {
+auto ServerConnectionManager::ServerConnectionFactory::CreateConnection(
+    Ptr<Server> const& server) -> std::shared_ptr<ClientServerConnection> {
   return server_connection_manager_->CreateConnection(server);
 }
 
@@ -39,8 +38,8 @@ ServerConnectionManager::GetServerConnectionFactory() {
   return std::make_unique<ServerConnectionFactory>(*this);
 }
 
-RcPtr<ClientServerConnection> ServerConnectionManager::CreateConnection(
-    Ptr<Server> const& server) {
+auto ServerConnectionManager::CreateConnection(Ptr<Server> const& server)
+    -> std::shared_ptr<ClientServerConnection> {
   auto in_cache = FindInCache(server->server_id);
   if (in_cache) {
     return in_cache;
@@ -51,7 +50,7 @@ RcPtr<ClientServerConnection> ServerConnectionManager::CreateConnection(
   assert(client);
 
   auto connection =
-      MakeRcPtr<ClientServerConnection>(ae_context_, client, server);
+      std::make_shared<ClientServerConnection>(ae_context_, client, server);
 
   // check updates
   server_update_subs_ += connection->stream_update_event().Subscribe(
@@ -62,7 +61,7 @@ RcPtr<ClientServerConnection> ServerConnectionManager::CreateConnection(
   return connection;
 }
 
-RcPtr<ClientServerConnection> ServerConnectionManager::FindInCache(
+std::shared_ptr<ClientServerConnection> ServerConnectionManager::FindInCache(
     ServerId server_id) const {
   auto it = cached_connections_.find(server_id);
   if (it != cached_connections_.end()) {
diff --git a/aether/connection_manager/server_connection_manager.h b/aether/connection_manager/server_connection_manager.h
index d4976402..53d8a816 100644
--- a/aether/connection_manager/server_connection_manager.h
+++ b/aether/connection_manager/server_connection_manager.h
@@ -18,10 +18,10 @@
 #define AETHER_CONNECTION_MANAGER_SERVER_CONNECTION_MANAGER_H_
 
 #include <map>
+#include <memory>
 
-#include "aether/ptr/ptr.h"
-#include "aether/ptr/rc_ptr.h"
 #include "aether/ae_context.h"
+#include "aether/ptr/ptr.h"
 #include "aether/ptr/ptr_view.h"
 #include "aether/server_connections/client_server_connection.h"
 #include "aether/server_connections/iserver_connection_factory.h"
@@ -35,7 +35,7 @@ class ServerConnectionManager {
     explicit ServerConnectionFactory(
         ServerConnectionManager& server_connection_manager);
 
-    RcPtr<ClientServerConnection> CreateConnection(
+    std::shared_ptr<ClientServerConnection> CreateConnection(
         Ptr<Server> const& server) override;
 
    private:
@@ -48,16 +48,17 @@ class ServerConnectionManager {
 
   std::unique_ptr<IServerConnectionFactory> GetServerConnectionFactory();
 
-  RcPtr<ClientServerConnection> CreateConnection(Ptr<Server> const& server);
+  std::shared_ptr<ClientServerConnection> CreateConnection(
+      Ptr<Server> const& server);
 
-  RcPtr<ClientServerConnection> FindInCache(ServerId server_id) const;
+  std::shared_ptr<ClientServerConnection> FindInCache(ServerId server_id) const;
 
  private:
   void ServerUpdate(ServerId server_id);
 
   AeContext ae_context_;
   PtrView<Client> client_;
-  std::map<ServerId, RcPtrView<ClientServerConnection>> cached_connections_;
+  std::map<ServerId, std::weak_ptr<ClientServerConnection>> cached_connections_;
   MultiSubscription server_update_subs_;
 };
 }  // namespace ae
diff --git a/aether/domain_storage/file_system_std_storage.cpp b/aether/domain_storage/file_system_std_storage.cpp
index bb69443e..3ce2071e 100644
--- a/aether/domain_storage/file_system_std_storage.cpp
+++ b/aether/domain_storage/file_system_std_storage.cpp
@@ -18,11 +18,11 @@
 
 #if defined AE_FILE_SYSTEM_STD_ENABLED
 
+#  include <filesystem>
+#  include <fstream>
 #  include <ios>
 #  include <set>
 #  include <string>
-#  include <fstream>
-#  include <filesystem>
 #  include <system_error>
 
 #  include "aether/domain_storage/domain_storage_tele.h"
@@ -38,8 +38,8 @@ class FstreamStorageWriter final : public IDomainStorageWriter {
     file.close();
     AE_TELE_DEBUG(kFileSystemDsObjSaved,
                   "Saved object id={}, class id={}, version={}, size={}",
-                  query.id.ToString(), query.class_id,
-                  static_cast<int>(query.version), written_size);
+                  query.id, query.class_id, static_cast<int>(query.version),
+                  written_size);
   }
 
   void write(void const* data, std::size_t size) override {
@@ -77,7 +77,8 @@ FileSystemStdStorage::~FileSystemStdStorage() = default;
 
 std::unique_ptr<IDomainStorageWriter> FileSystemStdStorage::Store(
     DomainQuery const& query) {
-  auto class_dir = std::filesystem::path("state") / query.id.ToString() /
+  auto class_dir = std::filesystem::path("state") /
+                   std::to_string(query.id.id()) /
                    std::to_string(query.class_id);
 
   std::filesystem::create_directories(class_dir);
@@ -94,7 +95,7 @@ ClassList FileSystemStdStorage::Enumerate(const ae::ObjId& obj_id) {
 
   auto state_dir = std::filesystem::path{"state"};
   auto ec = std::error_code{};
-  auto obj_dir = state_dir / obj_id.ToString();
+  auto obj_dir = state_dir / std::to_string(obj_id.id());
   for (auto const& class_dir :
        std::filesystem::directory_iterator(obj_dir, ec)) {
     auto file_name = class_dir.path().filename().string();
@@ -111,7 +112,8 @@ ClassList FileSystemStdStorage::Enumerate(const ae::ObjId& obj_id) {
 }
 
 DomainLoad FileSystemStdStorage::Load(DomainQuery const& query) {
-  auto object_dir = std::filesystem::path("state") / query.id.ToString();
+  auto object_dir =
+      std::filesystem::path("state") / std::to_string(query.id.id());
   auto ec = std::error_code{};
   if (!std::filesystem::exists(object_dir, ec)) {
     return {DomainLoadResult::kEmpty, {}};
@@ -134,16 +136,17 @@ DomainLoad FileSystemStdStorage::Load(DomainQuery const& query) {
     return DomainLoad{DomainLoadResult::kEmpty, {}};
   }
 
-  AE_TELE_DEBUG(
-      kFileSystemDsObjLoaded, "Loaded object id={}, class id={}, version={}",
-      query.id.ToString(), query.class_id, static_cast<int>(query.version));
+  AE_TELE_DEBUG(kFileSystemDsObjLoaded,
+                "Loaded object id={}, class id={}, version={}", query.id,
+                query.class_id, static_cast<int>(query.version));
 
   return {DomainLoadResult::kLoaded,
           std::make_unique<FstreamStorageReader>(std::move(f))};
 }
 
 void FileSystemStdStorage::Remove(ae::ObjId const& obj_id) {
-  auto object_dir = std::filesystem::path("state") / obj_id.ToString();
+  auto object_dir =
+      std::filesystem::path("state") / std::to_string(obj_id.id());
   auto ec = std::error_code{};
   if (!std::filesystem::exists(object_dir, ec)) {
     std::filesystem::create_directory(object_dir);
@@ -164,8 +167,7 @@ void FileSystemStdStorage::Remove(ae::ObjId const& obj_id) {
                      class_dir.path().string(), ec2.message());
       continue;
     }
-    AE_TELE_DEBUG(kFileSystemDsObjRemoved, "Object removed {}",
-                  obj_id.ToString());
+    AE_TELE_DEBUG(kFileSystemDsObjRemoved, "Object removed {}", obj_id);
   }
   if (ec) {
     AE_TELE_ERROR(kFileSystemDsRemoveObjError,
diff --git a/aether/domain_storage/ram_domain_storage.cpp b/aether/domain_storage/ram_domain_storage.cpp
index 38e934cf..0c4c7d50 100644
--- a/aether/domain_storage/ram_domain_storage.cpp
+++ b/aether/domain_storage/ram_domain_storage.cpp
@@ -20,8 +20,8 @@
 
 #  include <cassert>
 
-#  include "aether/mstream_buffers.h"
 #  include "aether/domain_storage/domain_storage_tele.h"
+#  include "aether/mstream_buffers.h"
 
 namespace ae {
 class RamDomainStorageWriter final : public IDomainStorageWriter {
@@ -74,8 +74,7 @@ std::unique_ptr<IDomainStorageWriter> RamDomainStorage::Store(
 ClassList RamDomainStorage::Enumerate(ObjId const& obj_id) {
   auto obj_map_it = state.find(obj_id);
   if (obj_map_it == std::end(state)) {
-    AE_TELE_INFO(kRamDsEnumObjIdNotFound, "Obj not found {}",
-                 obj_id.ToString());
+    AE_TELE_INFO(kRamDsEnumObjIdNotFound, "Obj not found {}", obj_id);
     return {};
   }
   if (!obj_map_it->second) {
@@ -87,8 +86,8 @@ ClassList RamDomainStorage::Enumerate(ObjId const& obj_id) {
   for (auto& [cls, _] : *obj_map_it->second) {
     classes.emplace_back(cls);
   }
-  AE_TELE_DEBUG(kRamDsEnumerated, "Enumerated for obj {} classes {}",
-                obj_id.ToString(), classes);
+  AE_TELE_DEBUG(kRamDsEnumerated, "Enumerated for obj {} classes {}", obj_id,
+                classes);
   return classes;
 }
 
@@ -97,8 +96,7 @@ DomainLoad RamDomainStorage::Load(DomainQuery const& query) {
   if (obj_map_it == std::end(state)) {
     AE_TELE_INFO(kRamDsLoadObjIdNoFound,
                  "Unable to find object id={}, class id={}, version={}",
-                 query.id.ToString(), query.class_id,
-                 static_cast<int>(query.version));
+                 query.id, query.class_id, static_cast<int>(query.version));
     return {DomainLoadResult::kEmpty, {}};
   }
   if (!obj_map_it->second) {
@@ -109,23 +107,21 @@ DomainLoad RamDomainStorage::Load(DomainQuery const& query) {
   if (class_map_it == std::end(*obj_map_it->second)) {
     AE_TELE_INFO(kRamDsLoadObjClassIdNotFound,
                  "Unable to find object id={}, class id={}, version={}",
-                 query.id.ToString(), query.class_id,
-                 static_cast<int>(query.version));
+                 query.id, query.class_id, static_cast<int>(query.version));
     return {DomainLoadResult::kEmpty, {}};
   }
   auto version_it = class_map_it->second.find(query.version);
   if (version_it == std::end(class_map_it->second)) {
     AE_TELE_INFO(kRamDsLoadObjVersionNotFound,
                  "Unable to find object id={}, class id={}, version={}",
-                 query.id.ToString(), query.class_id,
-                 static_cast<int>(query.version));
+                 query.id, query.class_id, static_cast<int>(query.version));
     return {DomainLoadResult::kEmpty, {}};
   }
 
   AE_TELE_DEBUG(kRamDsObjLoaded,
                 "Loaded object id={}, class id={}, version={}, size={}",
-                query.id.ToString(), query.class_id,
-                static_cast<int>(query.version), version_it->second.size());
+                query.id, query.class_id, static_cast<int>(query.version),
+                version_it->second.size());
 
   return {DomainLoadResult::kLoaded,
           std::make_unique<RamDomainStorageReader>(version_it->second, *this)};
@@ -139,7 +135,7 @@ void RamDomainStorage::Remove(ObjId const& obj_id) {
   }
 
   obj_map_it->second.reset();
-  AE_TELE_DEBUG(kRamDsObjRemoved, "Removed object {}", obj_id.ToString());
+  AE_TELE_DEBUG(kRamDsObjRemoved, "Removed object {}", obj_id);
 }
 
 void RamDomainStorage::CleanUp() { state.clear(); }
@@ -151,10 +147,9 @@ void RamDomainStorage::SaveData(DomainQuery const& query, ObjectData&& data) {
   }
   auto& saved = (*objcect_classes)[query.class_id][query.version];
   saved = std::move(data);
-  AE_TELE_DEBUG(kRamDsObjSaved,
-                "Saved object id={}, class id={}, version={}, size={}",
-                query.id.ToString(), query.class_id,
-                std::to_string(query.version), saved.size());
+  AE_TELE_DEBUG(
+      kRamDsObjSaved, "Saved object id={}, class id={}, version={}, size={}",
+      query.id, query.class_id, std::to_string(query.version), saved.size());
 }
 
 }  // namespace ae
diff --git a/aether/domain_storage/registrar_domain_storage.cpp b/aether/domain_storage/registrar_domain_storage.cpp
index 576283b6..377ee9f5 100644
--- a/aether/domain_storage/registrar_domain_storage.cpp
+++ b/aether/domain_storage/registrar_domain_storage.cpp
@@ -83,7 +83,7 @@ void RegistrarDomainStorage::SaveState() {
     Format(file,
            "static constexpr auto class_array_{} = "
            "std::array<std::uint32_t, {}>{",
-           obj_id.ToString(), obj_data->size());
+           obj_id, obj_data->size());
     PrintMapKeysAsData(file, *obj_data);
     file << "};\n";
   }
@@ -99,8 +99,7 @@ void RegistrarDomainStorage::SaveState() {
         Format(file,
                "static constexpr auto data_array_{}_{}_{} = "
                "std::array<std::uint8_t, {}>{",
-               obj_id.ToString(), class_id, static_cast<int>(version),
-               data.size());
+               obj_id, class_id, static_cast<int>(version), data.size());
         PrintData(file, data);
         file << "};\n";
       }
@@ -113,8 +112,8 @@ void RegistrarDomainStorage::SaveState() {
   // write object map
   file << "  ae::StaticMap{{\n";
   for (auto const& [obj_id, obj_data] : ram_storage.state) {
-    file << "    std::pair{ std::uint32_t{ " << obj_id.ToString()
-         << " } , ae::Span{ class_array_" << obj_id.ToString() << " }},\n";
+    file << "    std::pair{ std::uint32_t{ " << obj_id.id()
+         << " } , ae::Span{ class_array_" << obj_id.id() << " }},\n";
   }
   file << "  }},\n";
 
@@ -128,10 +127,9 @@ void RegistrarDomainStorage::SaveState() {
     for (auto const& [class_id, class_data] : *obj_data) {
       for (auto const& [version, _] : class_data) {
         file << "    std::pair{ ae::ObjectPathKey{ ";
-        Format(file, "{}, {}, {}", obj_id.ToString(), class_id,
-               static_cast<int>(version));
+        Format(file, "{}, {}, {}", obj_id, class_id, static_cast<int>(version));
         file << " }, ae::Span{ ";
-        Format(file, "data_array_{}_{}_{}", obj_id.ToString(), class_id,
+        Format(file, "data_array_{}_{}_{}", obj_id, class_id,
                static_cast<int>(version));
         file << " }},\n";
       }
diff --git a/aether/domain_storage/spifs_domain_storage.cpp b/aether/domain_storage/spifs_domain_storage.cpp
index 9eee07b5..f98cea17 100644
--- a/aether/domain_storage/spifs_domain_storage.cpp
+++ b/aether/domain_storage/spifs_domain_storage.cpp
@@ -124,16 +124,15 @@ SpiFsDomainStorage::~SpiFsDomainStorage() { DeInitFs(); }
 std::unique_ptr<IDomainStorageWriter> SpiFsDomainStorage::Store(
     DomainQuery const& query) {
   // open file
-  auto file_path = Format("{}/{}/{}/{}", kBasePath, query.id.ToString(),
-                          query.class_id, static_cast<int>(query.version));
+  auto file_path = Format("{}/{}/{}/{}", kBasePath, query.id, query.class_id,
+                          static_cast<int>(query.version));
   return std::make_unique<SpiFsSotorageWriter>(*this, file_path, query);
 }
 
 ClassList SpiFsDomainStorage::Enumerate(ObjId const& obj_id) {
   auto obj_it = object_map_.find(obj_id);
   if (obj_it == std::end(object_map_)) {
-    AE_TELE_INFO(kSpifsDsEnumObjIdNotFound, "Obj not found {}",
-                 obj_id.ToString());
+    AE_TELE_INFO(kSpifsDsEnumObjIdNotFound, "Obj not found {}", obj_id);
     return {};
   }
 
@@ -141,8 +140,8 @@ ClassList SpiFsDomainStorage::Enumerate(ObjId const& obj_id) {
   for (auto const& [class_id, _] : obj_it->second) {
     classes.emplace_back(class_id);
   }
-  AE_TELE_DEBUG(kSpifsDsEnumerated, "Enumerated for obj {} classes {}",
-                obj_id.ToString(), classes);
+  AE_TELE_DEBUG(kSpifsDsEnumerated, "Enumerated for obj {} classes {}", obj_id,
+                classes);
   return classes;
 }
 
@@ -151,8 +150,7 @@ DomainLoad SpiFsDomainStorage::Load(DomainQuery const& query) {
   if (obj_map_it == std::end(object_map_)) {
     AE_TELE_INFO(kSpifsDsLoadObjIdNoFound,
                  "Unable to find object id={}, class id={}, version={}",
-                 query.id.ToString(), query.class_id,
-                 static_cast<int>(query.version));
+                 query.id, query.class_id, static_cast<int>(query.version));
     return {DomainLoadResult::kEmpty, {}};
   }
   if (obj_map_it->second.empty()) {
@@ -163,31 +161,29 @@ DomainLoad SpiFsDomainStorage::Load(DomainQuery const& query) {
   if (class_map_it == std::end(obj_map_it->second)) {
     AE_TELE_INFO(kSpifsDsLoadObjClassIdNotFound,
                  "Unable to find object id={}, class id={}, version={}",
-                 query.id.ToString(), query.class_id,
-                 static_cast<int>(query.version));
+                 query.id, query.class_id, static_cast<int>(query.version));
     return {DomainLoadResult::kEmpty, {}};
   }
   auto version_it = class_map_it->second.find(query.version);
   if (version_it == std::end(class_map_it->second)) {
     AE_TELE_INFO(kSpifsDsLoadObjVersionNotFound,
                  "Unable to find object id={}, class id={}, version={}",
-                 query.id.ToString(), query.class_id,
-                 static_cast<int>(query.version));
+                 query.id, query.class_id, static_cast<int>(query.version));
     return {DomainLoadResult::kEmpty, {}};
   }
 
   // open file
-  auto file_path = Format("{}/{}/{}/{}", kBasePath, query.id.ToString(),
-                          query.class_id, static_cast<int>(query.version));
+  auto file_path = Format("{}/{}/{}/{}", kBasePath, query.id, query.class_id,
+                          static_cast<int>(query.version));
   FILE* file = fopen(file_path.c_str(), "r");
   if (file == nullptr) {
     AE_TELED_ERROR("Failed to open file {} for reading.", file_path);
     return {};
   }
 
-  AE_TELE_DEBUG(
-      kSpifsDsObjLoaded, "Loaded object id={}, class id={}, version={}",
-      query.id.ToString(), query.class_id, static_cast<int>(query.version));
+  AE_TELE_DEBUG(kSpifsDsObjLoaded,
+                "Loaded object id={}, class id={}, version={}", query.id,
+                query.class_id, static_cast<int>(query.version));
 
   return {DomainLoadResult::kLoaded,
           std::make_unique<SpiFsSotorageReader>(file)};
@@ -203,13 +199,13 @@ void SpiFsDomainStorage::Remove(const ae::ObjId& obj_id) {
   for (auto& [class_id, class_data] : obj_map_it->second) {
     for (auto version : class_data) {
       // remove the file
-      auto file_path = Format("{}/{}/{}/{}", kBasePath, obj_id.ToString(),
-                              class_id, static_cast<int>(version.first));
+      auto file_path = Format("{}/{}/{}/{}", kBasePath, obj_id, class_id,
+                              static_cast<int>(version.first));
       unlink(file_path.c_str());
     }
   }
   obj_map_it->second.clear();
-  AE_TELE_DEBUG(kSpifsDsObjRemoved, "Removed object {}", obj_id.ToString());
+  AE_TELE_DEBUG(kSpifsDsObjRemoved, "Removed object {}", obj_id);
   SyncState();
 }
 
@@ -218,8 +214,8 @@ void SpiFsDomainStorage::CleanUp() {
     for (auto const& [class_id, class_data] : obj_map_data) {
       for (auto version : class_data) {
         // remove the file
-        auto file_path = Format("{}/{}/{}/{}", kBasePath, obj_id.ToString(),
-                                class_id, static_cast<int>(version.first));
+        auto file_path = Format("{}/{}/{}/{}", kBasePath, obj_id, class_id,
+                                static_cast<int>(version.first));
         unlink(file_path.c_str());
       }
     }
diff --git a/aether/domain_storage/static_domain_storage.h b/aether/domain_storage/static_domain_storage.h
index 43c986c4..013f76c9 100644
--- a/aether/domain_storage/static_domain_storage.h
+++ b/aether/domain_storage/static_domain_storage.h
@@ -54,11 +54,10 @@ class StaticDomainStorage final : public IDomainStorage {
     // object_map is defined in FS_INIT
     auto const classes = static_domain_data_->object_map.find(obj_id.id());
     if (classes == std::end(static_domain_data_->object_map)) {
-      AE_TELED_ERROR("Obj not found {}", obj_id.ToString());
+      AE_TELED_ERROR("Obj not found {}", obj_id);
       return {};
     }
-    AE_TELED_DEBUG("Enumerated for obj {} classes {}", obj_id.ToString(),
-                   classes->second);
+    AE_TELED_DEBUG("Enumerated for obj {} classes {}", obj_id, classes->second);
     return ClassList{std::begin(classes->second), std::end(classes->second)};
   }
 
@@ -68,13 +67,12 @@ class StaticDomainStorage final : public IDomainStorage {
     auto const data = static_domain_data_->state_map.find(obj_path);
     if (data == std::end(static_domain_data_->state_map)) {
       AE_TELED_ERROR("Unable to find object id={}, class id={}, version={}",
-                     query.id.ToString(), query.class_id,
-                     static_cast<int>(query.version));
+                     query.id, query.class_id, static_cast<int>(query.version));
       return {DomainLoadResult::kEmpty, {}};
     }
     AE_TELED_DEBUG("Loaded object id={}, class id={}, version={}, size={}",
-                   query.id.ToString(), query.class_id,
-                   static_cast<int>(query.version), data->second.size());
+                   query.id, query.class_id, static_cast<int>(query.version),
+                   data->second.size());
 
     return DomainLoad{
         DomainLoadResult::kLoaded,
diff --git a/aether/events/event_deleter.cpp b/aether/events/event_deleter.cpp
index 19d27c2f..ba82aad8 100644
--- a/aether/events/event_deleter.cpp
+++ b/aether/events/event_deleter.cpp
@@ -18,7 +18,7 @@
 
 namespace ae {
 EventHandlerDeleter::EventHandlerDeleter(
-    RcPtr<EventHandlersList> const& event_handlers,
+    std::shared_ptr<EventHandlersList> const& event_handlers,
     EventHandlersList::Index index)
     : event_handlers_{event_handlers}, index_{index} {}
 
diff --git a/aether/events/event_deleter.h b/aether/events/event_deleter.h
index 0dedf691..f799a74e 100644
--- a/aether/events/event_deleter.h
+++ b/aether/events/event_deleter.h
@@ -17,8 +17,9 @@
 #ifndef AETHER_EVENTS_EVENT_DELETER_H_
 #define AETHER_EVENTS_EVENT_DELETER_H_
 
+#include <memory>
+
 #include "aether/common.h"
-#include "aether/ptr/rc_ptr.h"
 #include "aether/events/event_list.h"
 
 namespace ae {
@@ -28,7 +29,7 @@ namespace ae {
  */
 class EventHandlerDeleter {
  public:
-  EventHandlerDeleter(RcPtr<EventHandlersList> const& event_handlers,
+  EventHandlerDeleter(std::shared_ptr<EventHandlersList> const& event_handlers,
                       EventHandlersList::Index index);
   AE_CLASS_COPY_MOVE(EventHandlerDeleter)
 
@@ -37,7 +38,7 @@ class EventHandlerDeleter {
   bool alive() const;
 
  private:
-  RcPtrView<EventHandlersList> event_handlers_;
+  std::weak_ptr<EventHandlersList> event_handlers_;
   typename EventHandlersList::Index index_;
 };
 
diff --git a/aether/events/events.h b/aether/events/events.h
index 4922c232..0abe0060 100644
--- a/aether/events/events.h
+++ b/aether/events/events.h
@@ -17,16 +17,16 @@
 #ifndef AETHER_EVENTS_EVENTS_H_
 #define AETHER_EVENTS_EVENTS_H_
 
-#include <utility>
-#include <cassert>
 #include <algorithm>
+#include <cassert>
+#include <memory>
 #include <type_traits>
+#include <utility>
 
-#include "aether/ptr/rc_ptr.h"
-#include "aether/events/event_list.h"
-#include "aether/events/event_handler.h"
-#include "aether/events/event_deleter.h"
 #include "aether-miscpp/types/small_function.h"
+#include "aether/events/event_deleter.h"
+#include "aether/events/event_handler.h"
+#include "aether/events/event_list.h"
 #include "aether/events/event_subscription.h"
 
 namespace ae {
@@ -46,7 +46,7 @@ class Event<void(TArgs...)> {
   using Subscriber = EventSubscriber<CallbackSignature>;
   using List = EventHandlersList;
 
-  explicit Event() : events_list_{MakeRcPtr<List>()} {}
+  explicit Event() : events_list_{std::make_shared<List>()} {}
 
   ~Event() = default;
 
@@ -58,7 +58,8 @@ class Event<void(TArgs...)> {
    * subscriptions.
    */
   void Emit(TArgs... args) {
-    EmitImpl(events_list_, std::forward<TArgs>(args)...);
+    std::shared_ptr<List> list_life_extander = events_list_;
+    EmitImpl(list_life_extander, std::forward<TArgs>(args)...);
   }
 
   /**
@@ -77,7 +78,8 @@ class Event<void(TArgs...)> {
    * Separate static emitter is used to handle self destruction while handler
    * invoking.
    */
-  static void EmitImpl(RcPtr<List> events_list, TArgs&&... args) {
+  static void EmitImpl(std::shared_ptr<List> const& events_list,
+                       TArgs&&... args) {
     auto iterate_list = events_list->Iterator();
     for (auto it = std::begin(iterate_list); it != std::end(iterate_list);
          ++it) {
@@ -87,7 +89,7 @@ class Event<void(TArgs...)> {
     }
   }
 
-  RcPtr<List> events_list_;
+  std::shared_ptr<List> events_list_;
 };
 
 /**
diff --git a/aether/mstream.h b/aether/mstream.h
index 4a7d6b64..d6b26a5f 100644
--- a/aether/mstream.h
+++ b/aether/mstream.h
@@ -30,14 +30,14 @@
 #define AETHER_MSTREAM_H_
 
 #include <chrono>
-#include <functional>
 #include <cstdint>
 #include <cstring>
 #include <deque>
+#include <functional>
+#include <limits>
 #include <list>
 #include <map>
 #include <memory>
-#include <limits>
 #include <optional>
 #include <string>
 #include <type_traits>
@@ -48,7 +48,6 @@
 
 #include "aether-miscpp/reflect/domain_visitor.h"  // IWYU pragma: keep
 #include "aether-miscpp/reflect/reflect.h"
-#include "aether/clock.h"
 #include "aether/types/nullable_type.h"
 
 namespace ae {
@@ -75,7 +74,7 @@ class omstream : public ostream {
   void write(const void* data, size_t size) { ob_.write(data, size); }
 };
 
-enum class ReadResult {
+enum class ReadResult : char {
   kNo,
   kYes,
 };
@@ -527,8 +526,10 @@ imstream<Ib>& operator>>(imstream<Ib>& s, std::optional<T>& v) {
 
 template <typename... Ts, typename Ob>
 omstream<Ob>& operator<<(omstream<Ob>& s, std::variant<Ts...> const& v) {
-  static_assert(sizeof...(Ts) <= std::numeric_limits<std::uint8_t>::max(),
-                "std::variant mstream serialization supports at most 255 alternatives (indices 0..254; tag 255 is reserved as the valueless sentinel)");
+  static_assert(
+      sizeof...(Ts) <= std::numeric_limits<std::uint8_t>::max(),
+      "std::variant mstream serialization supports at most 255 alternatives "
+      "(indices 0..254; tag 255 is reserved as the valueless sentinel)");
   if (v.valueless_by_exception()) {
     auto const tag = std::numeric_limits<std::uint8_t>::max();
     s << tag;
@@ -542,8 +543,10 @@ omstream<Ob>& operator<<(omstream<Ob>& s, std::variant<Ts...> const& v) {
 
 template <typename... Ts, typename Ib>
 imstream<Ib>& operator>>(imstream<Ib>& s, std::variant<Ts...>& v) {
-  static_assert(sizeof...(Ts) <= std::numeric_limits<std::uint8_t>::max(),
-                "std::variant mstream serialization supports at most 255 alternatives (indices 0..254; tag 255 is reserved as the valueless sentinel)");
+  static_assert(
+      sizeof...(Ts) <= std::numeric_limits<std::uint8_t>::max(),
+      "std::variant mstream serialization supports at most 255 alternatives "
+      "(indices 0..254; tag 255 is reserved as the valueless sentinel)");
   std::uint8_t tag{};
   s >> tag;
   if (!data_was_read(s)) {
diff --git a/aether/obj/domain.cpp b/aether/obj/domain.cpp
index ab064f50..6b3db271 100644
--- a/aether/obj/domain.cpp
+++ b/aether/obj/domain.cpp
@@ -26,7 +26,7 @@ namespace ae {
 DomainGraph::DomainGraph(Domain* domain) : domain(domain) { assert(domain); }
 
 Ptr<Obj> DomainGraph::LoadRootImpl(ObjId obj_id) {
-  if (!obj_id.IsValid()) {
+  if (!obj_id.is_valid()) {
     return {};
   }
   // if already loaded
@@ -45,7 +45,7 @@ Ptr<Obj> DomainGraph::LoadRootImpl(ObjId obj_id) {
 }
 
 Ptr<Obj> DomainGraph::LoadCopyImpl(ObjId ref_id, ObjId copy_id) {
-  if (!ref_id.IsValid() || !copy_id.IsValid()) {
+  if (!ref_id.is_valid() || !copy_id.is_valid()) {
     return {};
   }
   // if already loaded
diff --git a/aether/obj/domain.h b/aether/obj/domain.h
index ec06cf75..c9422afa 100644
--- a/aether/obj/domain.h
+++ b/aether/obj/domain.h
@@ -17,24 +17,24 @@
 #ifndef AETHER_OBJ_DOMAIN_H_
 #define AETHER_OBJ_DOMAIN_H_
 
+#include <cassert>
+#include <cstdint>
 #include <map>
 #include <set>
-#include <cstdint>
-#include <cassert>
-#include <utility>
 #include <type_traits>
+#include <utility>
 
 #include "aether/clock.h"
 
 #include "aether/mstream.h"
 
-#include "aether/ptr/ptr_view.h"
-#include "aether-miscpp/reflect/reflect.h"
 #include "aether-miscpp/reflect/domain_visitor.h"
+#include "aether-miscpp/reflect/reflect.h"
+#include "aether/ptr/ptr_view.h"
 
+#include "aether/obj/idomain_storage.h"
 #include "aether/obj/obj_id.h"
 #include "aether/obj/registry.h"
-#include "aether/obj/idomain_storage.h"
 #include "aether/obj/version_iterator.h"
 
 namespace ae {
@@ -183,9 +183,7 @@ void DomainGraph::Load(T& obj, ObjId obj_id) {
   }
 
   if constexpr (HasAnyVersionedLoad<T>::value) {
-    constexpr auto version_bounds = VersionedLoadMinMax<T>::value;
-    IterateVersions<HasVersionedLoad, version_bounds.first,
-                    version_bounds.second>(
+    version_iterator<VersionLoadTrait>(
         obj, [this, obj_id](auto version, auto& obj) {
           this->LoadVersion(version, obj, obj_id);
         });
@@ -222,9 +220,7 @@ void DomainGraph::Save(T const& obj, ObjId obj_id) {
   }
 
   if constexpr (HasAnyVersionedSave<T>::value) {
-    constexpr auto version_bounds = VersionedSaveMinMax<T>::value;
-    IterateVersions<HasVersionedSave, version_bounds.second,
-                    version_bounds.first>(
+    version_iterator<VersionSaveTrait>(
         obj, [this, obj_id](auto version, auto& obj) {
           this->SaveVersion(version, obj, obj_id);
         });
diff --git a/aether/obj/idomain_storage.h b/aether/obj/idomain_storage.h
index 9dce73f5..e448cd31 100644
--- a/aether/obj/idomain_storage.h
+++ b/aether/obj/idomain_storage.h
@@ -17,10 +17,11 @@
 #ifndef AETHER_OBJ_IDOMAIN_STORAGE_H_
 #define AETHER_OBJ_IDOMAIN_STORAGE_H_
 
-#include <vector>
-#include <memory>
 #include <cstdint>
+#include <memory>
+#include <vector>
 
+#include "aether/mstream.h"
 #include "aether/obj/obj_id.h"
 
 namespace ae {
diff --git a/aether/obj/obj.h b/aether/obj/obj.h
index 6b622d24..bf35079b 100644
--- a/aether/obj/obj.h
+++ b/aether/obj/obj.h
@@ -32,12 +32,12 @@
 #include "aether/config.h"
 
 #include "aether-miscpp/crc.h"
+#include "aether-miscpp/reflect/reflect.h"
+#include "aether/obj/domain.h"
 #include "aether/obj/obj_id.h"
 #include "aether/obj/obj_ptr.h"
-#include "aether/obj/domain.h"
-#include "aether/obj/registry.h"
 #include "aether/obj/registrar.h"  // IWYU pragma:  export
-#include "aether-miscpp/reflect/reflect.h"
+#include "aether/obj/registry.h"
 
 namespace ae {
 /**
diff --git a/aether/obj/obj_id.cpp b/aether/obj/obj_id.cpp
index b2ddc6a3..7f07948c 100644
--- a/aether/obj/obj_id.cpp
+++ b/aether/obj/obj_id.cpp
@@ -16,8 +16,8 @@
 
 #include "aether/obj/obj_id.h"
 
-#include <random>
 #include <limits>
+#include <random>
 
 namespace ae {
 ObjId ObjId::GenerateUnique() {
diff --git a/aether/obj/obj_id.h b/aether/obj/obj_id.h
index 40f8cdcf..a7c0923f 100644
--- a/aether/obj/obj_id.h
+++ b/aether/obj/obj_id.h
@@ -18,9 +18,9 @@
 #define AETHER_OBJ_OBJ_ID_H_
 
 #include <cstdint>
-#include <string>
 
-#include "aether/mstream.h"
+#include "aether-miscpp/format/format.h"
+#include "aether-miscpp/reflect/reflect.h"
 
 namespace ae {
 
@@ -30,64 +30,80 @@ class ObjId {
 
   static ObjId GenerateUnique();
 
-  ObjId() { Invalidate(); }
+  constexpr ObjId() noexcept = default;
+  // NOLINTNEXTLINE(*explicit*)
+  constexpr ObjId(Type i) noexcept : id_{i} {}
 
-  constexpr ObjId(Type i) : id_{i} {}
+  AE_REFLECT_MEMBERS(id_)
 
-  constexpr Type id() const { return id_; }
+  constexpr Type id() const noexcept { return id_; }
+  constexpr bool is_valid() const noexcept { return id_ != 0; }
 
-  void Invalidate() { id_ = 0; }
-  constexpr bool IsValid() const { return id_ != 0; }
-  constexpr bool operator<(const ObjId& i) const { return id_ < i.id_; }
-  constexpr bool operator!=(const ObjId& i) const { return id_ != i.id_; }
-  constexpr bool operator==(const ObjId& i) const { return id_ == i.id_; }
+  constexpr bool operator<(ObjId const& i) const noexcept {
+    return id_ < i.id_;
+  }
+  constexpr bool operator!=(ObjId const& i) const noexcept {
+    return id_ != i.id_;
+  }
+  constexpr bool operator==(ObjId const& i) const noexcept {
+    return id_ == i.id_;
+  }
 
-  ObjId& operator+=(Type i) {
+  constexpr ObjId& operator+=(Type i) noexcept {
     id_ += i;
     return *this;
   }
-  constexpr ObjId operator+(Type i) const { return ObjId{id_ + i}; }
-
-  template <typename Ob>
-  friend omstream<Ob>& operator<<(omstream<Ob>& s, const ObjId& i) {
-    return s << i.id_;
-  }
-  template <typename Ib>
-  friend imstream<Ib>& operator>>(imstream<Ib>& s, ObjId& i) {
-    return s >> i.id_;
-  }
+  constexpr ObjId operator+(Type i) const noexcept { return ObjId{id_ + i}; }
 
-  std::string ToString() const { return std::to_string(id_); }
+ private:
+  Type id_{0};
+};
 
- protected:
-  Type id_;
+template <>
+struct Formatter<ObjId> : public Formatter<typename ObjId::Type> {
+  template <typename TStream>
+  void Format(ObjId value, FormatContext<TStream>& ctx) const {
+    Formatter<typename ObjId::Type>::Format(value.id(), ctx);
+  }
 };
 
 class ObjFlags {
  public:
-  enum {
-    // The object is not loaded with deserialization. Load method must be
-    // used for loading.
-    kUnloadedByDefault = 1,
-    kUnloaded = 2,
-  };
+  using Type = std::uint8_t;
+  // defines for flag values
+  // none value
+  static constexpr Type kNone = 0x0;
+  // The object is not loaded with deserialization. Load method must be
+  // used for loading.
+  static constexpr Type kUnloadedByDefault = 0x1;
+  // current state the object is unloaded
+  static constexpr Type kUnloaded = 0x2;
+
+  constexpr ObjFlags() noexcept = default;
+  // NOLINTNEXTLINE(*explicit*)
+  constexpr ObjFlags(Type v) noexcept : value_(v) {}
+
+  AE_REFLECT_MEMBERS(value_)
+
+  ObjFlags& operator=(Type v) noexcept {
+    value_ = v;
+    return *this;
+  }
 
-  ObjFlags(uint8_t v) : value_(v) {}
-  ObjFlags() = default;
+  // NOLINTNEXTLINE(*explicit*)
+  constexpr operator Type() const noexcept { return value_; }
 
-  operator std::uint8_t&() { return value_; }
+ private:
+  Type value_ = kNone;
+};
 
-  template <typename Ob>
-  friend omstream<Ob>& operator<<(omstream<Ob>& s, const ObjFlags& i) {
-    return s << i.value_;
-  }
-  template <typename Ib>
-  friend imstream<Ib>& operator>>(imstream<Ib>& s, ObjFlags& i) {
-    return s >> i.value_;
+template <>
+struct Formatter<ObjFlags> : public Formatter<typename ObjFlags::Type> {
+  template <typename TStream>
+  void Format(ObjFlags value, FormatContext<TStream>& ctx) const {
+    Formatter<typename ObjFlags::Type>::Format(
+        static_cast<typename ObjFlags::Type>(value), ctx);
   }
-
- private:
-  std::uint8_t value_ = 0;
 };
 
 }  // namespace ae
diff --git a/aether/obj/obj_ptr.h b/aether/obj/obj_ptr.h
index 396435ab..5a736d9d 100644
--- a/aether/obj/obj_ptr.h
+++ b/aether/obj/obj_ptr.h
@@ -196,7 +196,7 @@ ObjPtr<T> ObjPtr<T>::MakeFromThis(T* self) {
                 "T Must be an object type");
   auto id = self->obj_id;
   auto* domain = self->domain;
-  assert(id.IsValid() && (domain != nullptr) && "Object must be in domain");
+  assert(id.is_valid() && (domain != nullptr) && "Object must be in domain");
   auto ptr = MakePtrFromThis(self);
   assert(ptr && "Object must be valid");
   return ObjPtr<T>(domain, id, {}, std::move(ptr));
@@ -232,7 +232,7 @@ T const& ObjPtr<T>::operator*() const {
 
 template <typename T>
 bool ObjPtr<T>::is_valid() const {
-  return id().IsValid();
+  return id().is_valid();
 }
 template <typename T>
 bool ObjPtr<T>::is_loaded() const {
@@ -277,7 +277,7 @@ ObjPtr<T> ObjPtr<T>::Clone() const {
 template <typename T>
 ObjPtr<T> ObjPtr<T>::Clone(ObjId obj_id) const {
   assert(is_valid() && "Invalid clone ptr");
-  assert(obj_id.IsValid() && "Invalid object ID");
+  assert(obj_id.is_valid() && "Invalid object ID");
   auto ptr = DomainGraph{domain()}.template LoadCopy<T>(id(), obj_id);
   return ObjPtr<T>{domain(), obj_id,
                    static_cast<std::uint8_t>(flags() & ~ObjFlags::kUnloaded),
diff --git a/aether/obj/registrar.h b/aether/obj/registrar.h
index 7a06ad10..efe6752c 100644
--- a/aether/obj/registrar.h
+++ b/aether/obj/registrar.h
@@ -19,10 +19,11 @@
 
 #include <type_traits>
 
+#include "aether-miscpp/reflect/type_index.h"
+
 #include "aether/ptr/ptr.h"
 #include "aether/obj/domain.h"
 #include "aether/obj/registry.h"
-#include "aether-miscpp/reflect/type_index.h"
 
 namespace ae {
 template <class T>
@@ -64,12 +65,12 @@ class Registrar {
   }
 
   static void Load(DomainGraph* domain_graph, Ptr<Obj>& obj, ObjId obj_id) {
-    auto self_ptr = static_cast<T*>(obj.get());
+    auto* self_ptr = static_cast<T*>(obj.get());
     domain_graph->Load(*self_ptr, obj_id);
   }
 
   static void Save(DomainGraph* domain_graph, Ptr<Obj> const& obj, ObjId id) {
-    auto self_ptr = static_cast<T*>(obj.get());
+    auto const* self_ptr = static_cast<T const*>(obj.get());
     domain_graph->Save(*self_ptr, id);
   }
 };
diff --git a/aether/obj/registry.cpp b/aether/obj/registry.cpp
index 792edc3c..6f4cf980 100644
--- a/aether/obj/registry.cpp
+++ b/aether/obj/registry.cpp
@@ -29,7 +29,7 @@ Registry& Registry::GetRegistry() {
 
 void Registry::RegisterClass(uint32_t cls_id, std::uint32_t base_id,
                              Factory&& factory) {
-#ifdef DEBUG
+#if DEBUG
   // Fixme: Commented out to fix the build crash in MinGW
   /*std::cout << "Registering class " << factory.class_name << " id " << cls_id
             << " with base " << base_id << std::endl;*/
@@ -100,7 +100,7 @@ Factory* Registry::FindFactory(std::uint32_t base_id) {
   return &it->second;
 }
 
-#ifdef DEBUG
+#if DEBUG
 std::string_view Registry::ClassName(std::uint32_t class_id) {
   if (class_id == crc32::from_literal("Obj").value) {
     return "ae::Obj";
@@ -114,7 +114,7 @@ std::string_view Registry::ClassName(std::uint32_t class_id) {
 #endif  // DEBUG
 
 void Registry::Log() {
-#ifdef DEBUG
+#if DEBUG
   for (const auto& c : factories) {
     AE_TELE_DEBUG(ObjectRegistryLog, "name {}, id {}, base_id {}",
                   c.second.class_name, c.second.cls_id, c.second.base_id);
diff --git a/aether/obj/registry.h b/aether/obj/registry.h
index f8d2ee7b..c44e654d 100644
--- a/aether/obj/registry.h
+++ b/aether/obj/registry.h
@@ -40,7 +40,7 @@ struct Factory {
   CreateFunc create;
   LoadFunc load;
   SaveFunc save;
-#ifdef DEBUG
+#if DEBUG
   std::string class_name{};
   std::uint32_t cls_id{};
   std::uint32_t base_id{};
@@ -49,14 +49,14 @@ struct Factory {
 
 class Registry {
  public:
-  using Relations = std::unordered_map<uint32_t, std::vector<uint32_t>>;
-  using Factories = std::unordered_map<uint32_t, Factory>;
+  using Relations = std::unordered_map<std::uint32_t, std::vector<uint32_t>>;
+  using Factories = std::unordered_map<std::uint32_t, Factory>;
 
   static Registry& GetRegistry();
 
-  void RegisterClass(uint32_t cls_id, std::uint32_t base_id, Factory&& factory);
+  void RegisterClass(std::uint32_t cls_id, std::uint32_t base_id, Factory&& factory);
   void Log();
-  bool IsExisting(uint32_t class_id);
+  bool IsExisting(std::uint32_t class_id);
 
   int GenerationDistanceInternal(std::uint32_t base_id,
                                  std::uint32_t derived_id);
@@ -66,9 +66,9 @@ class Registry {
   //  class doesn't exist.
   int GenerationDistance(std::uint32_t base_id, std::uint32_t derived_id);
 
-  Factory* FindFactory(uint32_t base_id);
+  Factory* FindFactory(std::uint32_t base_id);
 
-#ifdef DEBUG
+#if DEBUG
   std::string_view ClassName(std::uint32_t class_id);
 #endif  // DEBUG
 
diff --git a/aether/obj/version_iterator.h b/aether/obj/version_iterator.h
index aee7d940..0cec501a 100644
--- a/aether/obj/version_iterator.h
+++ b/aether/obj/version_iterator.h
@@ -17,147 +17,127 @@
 #ifndef AETHER_OBJ_VERSION_ITERATOR_H_
 #define AETHER_OBJ_VERSION_ITERATOR_H_
 
-#include <type_traits>
+#include <array>
 #include <cstdint>
+#include <type_traits>
 #include <utility>
-#include <array>
 
-#include "aether/type_traits.h"
+#include "aether-miscpp/meta/index_sequence.h"
 
 namespace ae {
+using VersionValueType = std::uint8_t;
+
 // use max version for compilation time optimization
 // increase max version count if required
-#if defined(MAX_OBJECT_VERSION)
-inline constexpr std::uint8_t MAX_VERSION = MAX_OBJECT_VERSION;
+#ifdef MAX_OBJECT_VERSION
+inline constexpr VersionValueType kMaxVersion = MAX_OBJECT_VERSION;
 #else
-inline constexpr std::uint8_t MAX_VERSION = 24;
+inline constexpr VersionValueType kMaxVersion = 24;
 #endif
 
 // Helper version tag for versioned function overloading
-template <std::uint8_t V, typename T = void>
-struct Version;
-
-template <std::uint8_t V>
-struct Version<V, std::enable_if_t<(V <= MAX_VERSION)>> {
-  static constexpr std::uint8_t value = V;
-};
+template <VersionValueType V>
+  requires(V <= kMaxVersion)
+struct Version : public std::integral_constant<VersionValueType, V> {};
 
 // Traits for check supported versioned functionality
 
 struct Dnv;
 
-template <typename T, std::uint8_t V, typename _ = void>
-struct HasVersionedLoad : std::false_type {};
+template <typename T, VersionValueType V>
+struct VersionLoadTrait {
+  template <typename U, typename _ = void>
+  struct Has : std::false_type {};
+  template <typename U>
+  struct Has<U, std::void_t<decltype(std::declval<U&>().Load(
+                    Version<V>{}, std::declval<Dnv&>()))>> : std::true_type {};
 
-template <typename T, std::uint8_t V>
-struct HasVersionedLoad<T, V,
-                        std::void_t<decltype(std::declval<T>().Load(
-                            Version<V>{}, std::declval<Dnv&>()))>>
-    : std::true_type {};
+  static constexpr bool value = Has<T>::value;
+};
 
-template <typename T, std::uint8_t V, typename _ = void>
-struct HasVersionedSave : std::false_type {};
+template <typename T, VersionValueType V>
+struct VersionSaveTrait {
+  template <typename U, typename _ = void>
+  struct Has : std::false_type {};
+  template <typename U>
+  struct Has<U, std::void_t<decltype(std::declval<U const&>().Save(
+                    Version<V>{}, std::declval<Dnv&>()))>> : std::true_type {};
 
-template <typename T, std::uint8_t V>
-struct HasVersionedSave<T, V,
-                        std::void_t<decltype(std::declval<T>().Save(
-                            Version<V>{}, std::declval<Dnv&>()))>>
-    : std::true_type {};
+  static constexpr bool value = Has<T>::value;
+};
 
 /**
  * \brief Calculate min and max version supported by T and tested with
  * VersionTrait
  */
 template <typename T,
-          template <typename, std::uint8_t, typename...> typename VersionTrait>
+          template <typename, VersionValueType> typename VersionTrait>
 struct VersionBounds {
-  template <std::uint8_t... Vs>
-  static constexpr std::pair<std::uint8_t, std::uint8_t> CalcVersionBounds(
-      std::integer_sequence<std::uint8_t, Vs...> const&) {
+  template <VersionValueType... Vs>
+  using i_seq = std::integer_sequence<VersionValueType, Vs...>;
+
+  template <VersionValueType... Vs>
+  static consteval auto CalcVersionBounds(i_seq<Vs...>)
+      -> std::pair<VersionValueType, VersionValueType> {
     constexpr auto arr = std::array{VersionTrait<T, Vs>::value...};
-    std::uint8_t min{};
-    std::uint8_t max{};
+    VersionValueType min{};
+    VersionValueType max{};
     std::size_t i = 0;
     for (; i < arr.size(); ++i) {
       if (arr[i]) {
         break;
       }
     }
-    min = static_cast<std::uint8_t>(i);
+    if (i == arr.size()) {
+      return {0, 0};
+    }
+
+    min = static_cast<VersionValueType>(i);
 
     for (; i < arr.size(); ++i) {
       if (!arr[i]) {
         break;
       }
     }
-    max = static_cast<std::uint8_t>(i - 1);
+    max = static_cast<VersionValueType>(i - 1);
     return {min, max};
   }
 
   static constexpr auto value = CalcVersionBounds(
-      std::make_integer_sequence<std::uint8_t, MAX_VERSION + 1>());
+      std::make_integer_sequence<VersionValueType, kMaxVersion + 1>());
 };
 
-/**
- * \brief Min and max versions supported by T to Load
- */
-template <typename T>
-using VersionedLoadMinMax = VersionBounds<T, HasVersionedLoad>;
-
-/**
- * \brief Min and max versions supported by T to Save
- */
-template <typename T>
-using VersionedSaveMinMax = VersionBounds<T, HasVersionedSave>;
-
-template <typename T>
-struct HasAnyVersionedLoad {
-  template <uint8_t... Vs>
-  static constexpr bool TestAny(std::integer_sequence<uint8_t, Vs...> const&) {
-    return (HasVersionedLoad<T, Vs>::value || ...);
+template <typename T,
+          template <typename, VersionValueType> typename VersionTrait>
+struct HasAnyVersioned {
+  template <VersionValueType... Vs>
+  static consteval bool TestAny(
+      std::integer_sequence<VersionValueType, Vs...> const&) {
+    return (VersionTrait<T, Vs>::value || ...);
   }
 
-  static constexpr auto version_bounds = VersionedLoadMinMax<T>::value;
+  static constexpr auto version_bounds = VersionBounds<T, VersionTrait>::value;
   static constexpr bool value =
       TestAny(make_range_sequence<std::uint8_t, version_bounds.first,
                                   version_bounds.second>());
 };
 
 template <typename T>
-struct HasAnyVersionedSave {
-  template <uint8_t... Vs>
-  static constexpr bool TestAny(std::integer_sequence<uint8_t, Vs...> const&) {
-    return (HasVersionedSave<T, Vs>::value || ...);
-  }
-
-  static constexpr auto version_bounds = VersionedSaveMinMax<T>::value;
-  static constexpr bool value =
-      TestAny(make_range_sequence<std::uint8_t, version_bounds.first,
-                                  version_bounds.second>());
-};
-
-template <template <typename, std::uint8_t, typename...> typename VersionTrait,
-          std::uint8_t Vs, typename T, typename TFunc>
-constexpr void IterateVersionsImplApply(T& t, TFunc&& func) {
-  if constexpr (VersionTrait<std::decay_t<T>, Vs>::value) {
-    func(Version<Vs>{}, t);
-  }
-}
+struct HasAnyVersionedLoad : public HasAnyVersioned<T, VersionLoadTrait> {};
+template <typename T>
+static constexpr inline bool HasAnyVersionedLoad_v =
+    HasAnyVersionedLoad<T>::value;
 
-template <template <typename, std::uint8_t, typename...> typename VersionTrait,
-          typename T, typename TFunc, std::uint8_t... Vs>
-constexpr void IterateVersionsImpl(
-    T& t, TFunc&& func, std::integer_sequence<std::uint8_t, Vs...> const&) {
-  (IterateVersionsImplApply<VersionTrait, Vs>(t, std::forward<TFunc>(func)),
-   ...);
-}
+template <typename T>
+struct HasAnyVersionedSave : public HasAnyVersioned<T, VersionSaveTrait> {};
+template <typename T>
+static constexpr inline bool HasAnyVersionedSave_v =
+    HasAnyVersionedSave<T>::value;
 
 /**
  * \brief Iterate for each version of the object for that VersionTrait returns
  * true
  * \tparam VersionTrait Trait to check if version is supported
- * \tparam version_min Minimum version to iterate from
- * \tparam version_max Maximum version to iterate to
  * \tparam T Object type
  * \tparam TFunc Function to call for each version with signature
  * void(Version<V>, T&)
@@ -173,10 +153,38 @@ constexpr void IterateVersions(T& t, TFunc&& func) {
       make_range_sequence<std::uint8_t, version_min, version_max>());
 }
 
+template <template <typename, VersionValueType> typename VersionTrait>
+struct VersionIterator {
+ private:
+  template <typename T, typename TFunc, VersionValueType V>
+  static void ImplApply(T& t, TFunc&& func, Version<V> v) {
+    if constexpr (VersionTrait<T, V>::value) {
+      std::forward<TFunc>(func)(v, t);
+    }
+  }
+
+  template <typename T, typename TFunc, VersionValueType... Vs>
+  static void Impl(T& t, TFunc&& func,
+                   std::integer_sequence<VersionValueType, Vs...>) {
+    (ImplApply(t, std::forward<TFunc>(func), Version<Vs>{}), ...);
+  }
+
+ public:
+  template <typename T, typename TFunc>
+  constexpr void operator()(T& t, TFunc&& func) const {
+    constexpr auto bounds = VersionBounds<T, VersionTrait>::value;
+    Impl(t, std::forward<TFunc>(func),
+         make_range_sequence<VersionValueType, bounds.first, bounds.second>());
+  }
+};
+
+template <template <typename, VersionValueType> typename VersionTrait>
+static constexpr inline auto version_iterator = VersionIterator<VersionTrait>{};
+
 template <typename Visitor>
 struct VersionNodeVisitor {
-  constexpr explicit VersionNodeVisitor(Visitor vis)
-      : visitor{std::forward<Visitor>(vis)} {}
+  constexpr explicit VersionNodeVisitor(Visitor&& vis)
+      : visitor{std::move(vis)} {}
 
   template <typename... U>
   void operator()(U&&... vals) {
@@ -186,5 +194,8 @@ struct VersionNodeVisitor {
   Visitor visitor;
 };
 
+template <typename V>
+VersionNodeVisitor(V&&) -> VersionNodeVisitor<V>;
+
 }  // namespace ae
 #endif  // AETHER_OBJ_VERSION_ITERATOR_H_
diff --git a/aether/ptr/ptr.cpp b/aether/ptr/ptr.cpp
index 50eeac73..bd9b32f3 100644
--- a/aether/ptr/ptr.cpp
+++ b/aether/ptr/ptr.cpp
@@ -76,6 +76,12 @@ void PtrBase::Increment() {
   if (ptr_storage_ == nullptr) {
     return;
   }
+  assert((ptr_storage_->ref_counters.main_refs <
+          std::numeric_limits<std::uint16_t>::max()) &&
+         "Increment would overflow main_refs");
+  assert((ptr_storage_->ref_counters.weak_refs <
+          std::numeric_limits<std::uint16_t>::max()) &&
+         "Increment would overflow weak_refs");
   ptr_storage_->ref_counters.main_refs += 1;
   ptr_storage_->ref_counters.weak_refs += 1;
 }
@@ -92,21 +98,30 @@ void PtrBase::Decrement() {
   }
 }
 
-void PtrBase::DecrementRef(std::uint8_t count) {
+void PtrBase::DecrementRef(std::uint16_t count) {
+  assert((ptr_storage_ != nullptr) && "DecrementRef but ptr_storage_ is null");
+  assert((count <= ptr_storage_->ref_counters.main_refs) &&
+         "DecrementRef main_refs underflow");
+  assert((count <= ptr_storage_->ref_counters.weak_refs) &&
+         "DecrementRef weak_refs underflow");
   ptr_storage_->ref_counters.main_refs -= count;
   ptr_storage_->ref_counters.weak_refs -= count;
 }
 
-std::uint8_t PtrBase::DecrementGraphCount() {
+std::uint16_t PtrBase::DecrementGraphCount() {
   assert((ptr_storage_ != nullptr) &&
          "DecrementGraphCount but ptr_storage_ is nullptr");
 
-  auto ref_tree = BuildDecrementGraph();
+  RefTree ref_tree{};
+  BuildDecrementGraph(ref_tree);
 
   // Check if current obj has no external references
   // External references may be direct or by children objects
 
   auto& self_node = ref_tree.get(0);
+  assert((self_node.value.reachable_ref_count <
+          std::numeric_limits<std::uint16_t>::max()) &&
+         "reachable_ref_count overflow");
   // there is direct external references
   if (self_node.value.ref_count != self_node.value.reachable_ref_count) {
     // is not safe to delete completely
@@ -116,7 +131,7 @@ std::uint8_t PtrBase::DecrementGraphCount() {
   bool safe_to_delete = true;
   self_node.ForEach([&safe_to_delete](RefTree::Node& node) {
     // that node has external references
-    // check if head not is reachable
+    // check if head is not reachable
     if (node.value.ref_count != node.value.reachable_ref_count) {
       if (node.IsReachable(0)) {
         safe_to_delete = false;
@@ -132,55 +147,64 @@ std::uint8_t PtrBase::DecrementGraphCount() {
   return 1;
 }
 
-RefTree PtrBase::BuildDecrementGraph() {
-  RefTree tree;
-  auto& node = tree.Emplace(reinterpret_cast<std::uintptr_t>(ptr_storage_),
-                            ptr_storage_->ref_counters.main_refs);
-  node.value.reachable_ref_count++;
-  std::set<std::uintptr_t> visited;
-  visited.insert(reinterpret_cast<std::uintptr_t>(ptr_storage_));
-  BuildDecrementGraphImpl(tree, node.index, Children(), visited);
-  return tree;
-}
-
-void PtrBase::BuildDecrementGraphImpl(
-    RefTree& tree, RefTree::Index head_index,
-    std::vector<PtrBase const*> const& children,
-    std::set<std::uintptr_t>& visited) {
-  for (auto const* child : children) {
-    auto& node =
-        tree.Emplace(reinterpret_cast<std::uintptr_t>(child->ptr_storage_),
-                     child->ptr_storage_->ref_counters.main_refs);
-    node.value.reachable_ref_count++;
-    tree.get(head_index).children_indices.push_back(node.index);
-
-    // cycle detection
-    auto [_, not_visited] =
-        visited.emplace(reinterpret_cast<std::uintptr_t>(child->ptr_storage_));
-    if (not_visited) {
-      BuildDecrementGraphImpl(tree, node.index, child->Children(), visited);
-    }
-  }
+void PtrBase::BuildDecrementGraph(RefTree& ref_tree) {
+  auto& root = ref_tree.Emplace(reinterpret_cast<std::uintptr_t>(ptr_storage_),
+                                ptr_storage_->ref_counters.main_refs);
+  assert((root.value.reachable_ref_count <
+          std::numeric_limits<std::uint16_t>::max()) &&
+         "reachable_ref_count overflow");
+  root.value.reachable_ref_count++;
+  auto const root_index = root.index;
+  BuildDecrementGraphImpl(this, ref_tree, root_index);
 }
 
-std::vector<PtrBase const*> PtrBase::Children() const {
-  if (ptr_storage_ == nullptr) {
-    return {};
-  }
-  if (ptr_storage_->ref_counters.main_refs == 0) {
-    return {};
+void PtrBase::BuildDecrementGraphImpl(PtrBase const* ptr, RefTree& tree,
+                                      RefTree::Index head_index) {
+  auto& head = tree.get(head_index);
+  if (head.children_expanded) {
+    return;
   }
-  return ptr_storage_->manage_table->child_ptrs(this);
+  head.children_expanded = true;
+
+  struct Arg {
+    RefTree& tree;
+    RefTree::Index head_index;
+  };
+
+  auto visit_children = [](void* arg, PtrBase const* child) {
+    auto [tree, head_index] = *static_cast<Arg*>(arg);
+    auto const pointer = reinterpret_cast<std::uintptr_t>(child->ptr_storage_);
+    auto const ref_count = child->ptr_storage_->ref_counters.main_refs;
+    auto& node = tree.Emplace(pointer, ref_count);
+    assert((node.value.reachable_ref_count <
+            std::numeric_limits<std::uint16_t>::max()) &&
+           "reachable_ref_count overflow");
+    node.value.reachable_ref_count++;
+    auto const child_index = node.index;
+    tree.get(head_index).PushChild(child_index);
+    if (!node.children_expanded) {
+      BuildDecrementGraphImpl(child, tree, child_index);
+    }
+  };
+
+  auto arg = Arg{tree, head_index};
+
+  ptr->ptr_storage_->manage_table->visit_children(ptr, &arg, visit_children);
 }
 
 void PtrBase::Destroy() {
   assert((ptr_storage_ != nullptr) && "Destroy but ptr_storage_ is nullptr");
   // prevent cycled ptrviews delete ptr_storage
+  assert((ptr_storage_->ref_counters.weak_refs <
+          std::numeric_limits<std::uint16_t>::max()) &&
+         "Destroy would overflow weak_refs");
   ptr_storage_->ref_counters.weak_refs += 1;
   // call the destructor on pointer
   // Note if T is derived from Base, Base must have virtual ~Base to prevent
   // memory leaks
   ptr_storage_->manage_table->destroy(this);
+  assert((ptr_storage_->ref_counters.weak_refs > 0) &&
+         "Destroy would underflow weak_refs");
   ptr_storage_->ref_counters.weak_refs -= 1;
 }
 
diff --git a/aether/ptr/ptr.h b/aether/ptr/ptr.h
index 789872eb..7a307ebd 100644
--- a/aether/ptr/ptr.h
+++ b/aether/ptr/ptr.h
@@ -18,16 +18,19 @@
 #define AETHER_PTR_PTR_H_
 
 #include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <new>
 #include <utility>
 
 // IWYU pragma: begin_keeps
-#include "aether/common.h"
 #include "aether/type_traits.h"
 
-#include "aether/ptr/rc_ptr.h"
-#include "aether/ptr/ref_tree.h"
-#include "aether/ptr/ptr_management.h"
 #include "aether-miscpp/reflect/domain_visitor.h"
+#include "aether/ptr/ptr_management.h"
+#include "aether/ptr/ref_tree.h"
 // IWYU pragma: end_keeps
 
 namespace ae {
@@ -44,7 +47,7 @@ class PtrBase {
   PtrBase();
   PtrBase(PtrBase const& other);
   PtrBase(PtrBase&& other) noexcept;
-  PtrBase(PtrStorageBase* ptr_storage);
+  explicit PtrBase(PtrStorageBase* ptr_storage);
   PtrBase(MoveTag, PtrStorageBase* ptr_storage);
 
   PtrBase& operator=(PtrBase const& other);
@@ -57,13 +60,11 @@ class PtrBase {
 
   void Increment();
   void Decrement();
-  void DecrementRef(std::uint8_t count = 1);
-  std::uint8_t DecrementGraphCount();
-  RefTree BuildDecrementGraph();
-  void BuildDecrementGraphImpl(RefTree& tree, RefTree::Index head_index,
-                               std::vector<PtrBase const*> const& children,
-                               std::set<std::uintptr_t>& visited);
-  std::vector<PtrBase const*> Children() const;
+  void DecrementRef(std::uint16_t count = 1);
+  std::uint16_t DecrementGraphCount();
+  void BuildDecrementGraph(RefTree& ref_tree);
+  static void BuildDecrementGraphImpl(PtrBase const* ptr, RefTree& tree,
+                                      RefTree::Index head_index);
   void Destroy();
   void Free();
 
@@ -75,8 +76,6 @@ bool operator!=(PtrBase const& left, PtrBase const& right);
 
 template <typename T>
 static void PtrDestroy(PtrBase*);
-template <typename T>
-std::vector<PtrBase const*> PtrChildren(PtrBase*);
 
 /**
  * \brief Pointer - like shared pointer but with ability to create object
@@ -92,7 +91,6 @@ class Ptr : public PtrBase {
   friend class ObjPtr;
 
   friend void PtrDestroy<T>(PtrBase*);
-  friend std::vector<PtrBase const*> PtrChildren<T>(PtrBase*);
 
  public:
   Ptr() noexcept : PtrBase() {}
@@ -106,16 +104,17 @@ class Ptr : public PtrBase {
         ptr_{ptr_storage->ptr()} {}
 
   // construction of Ptr \see MakePtr
-  explicit Ptr(MoveTag, PtrStorage<T>* ptr_sotorage) noexcept
-      : PtrBase{MoveTag{}, reinterpret_cast<PtrStorageBase*>(ptr_sotorage)},
-        ptr_{ptr_sotorage->ptr()} {}
+  explicit Ptr(MoveTag, PtrStorage<T>* ptr_storage) noexcept
+      : PtrBase{MoveTag{}, reinterpret_cast<PtrStorageBase*>(ptr_storage)},
+        ptr_{ptr_storage->ptr()} {}
 
   // Copying
   Ptr(Ptr const& other) noexcept
       : PtrBase{other.ptr_storage_}, ptr_{other.ptr_} {}
 
   template <typename U>
-  Ptr(Ptr<U> const& other) noexcept
+  Ptr(Ptr<U> const& other) noexcept  // NOLINT(google-explicit-constructor)
+                                     // intentional implicit pointer-like upcast
       : PtrBase{other.ptr_storage_}, ptr_{static_cast<T*>(other.ptr_)} {}
 
   Ptr& operator=(Ptr const& other) noexcept {
@@ -137,7 +136,8 @@ class Ptr : public PtrBase {
   Ptr(Ptr&& other) noexcept : PtrBase{std::move(other)}, ptr_{other.ptr_} {}
 
   template <typename U>
-  Ptr(Ptr<U>&& other) noexcept
+  Ptr(Ptr<U>&& other) noexcept  // NOLINT(google-explicit-constructor)
+                                // intentional implicit pointer-like upcast
       : PtrBase{std::move(other)}, ptr_{static_cast<T*>(other.ptr_)} {}
 
   Ptr& operator=(Ptr&& other) noexcept {
@@ -159,7 +159,7 @@ class Ptr : public PtrBase {
   using PtrBase::operator bool;
 
   [[nodiscard]] T* get() const {
-    if (ptr_storage_ == nullptr) {
+    if (!operator bool()) {
       return nullptr;
     }
     assert((ptr_ != nullptr) && "Ptr is not initialized");
@@ -201,28 +201,48 @@ class Ptr : public PtrBase {
   T* ptr_;
 };
 
+template <typename T>
+bool operator==(Ptr<T> const& ptr, std::nullptr_t) noexcept {
+  return !ptr;
+}
+
+template <typename T>
+bool operator==(std::nullptr_t, Ptr<T> const& ptr) noexcept {
+  return !ptr;
+}
+
+template <typename T>
+bool operator!=(Ptr<T> const& ptr, std::nullptr_t) noexcept {
+  return static_cast<bool>(ptr);
+}
+
+template <typename T>
+bool operator!=(std::nullptr_t, Ptr<T> const& ptr) noexcept {
+  return static_cast<bool>(ptr);
+}
+
 template <typename T>
 static void PtrDestroy(PtrBase* self) {
   auto* _this = reinterpret_cast<Ptr<T>*>(self);
-  auto* obj = _this->get();
+  auto* obj = _this->ptr_;
   obj->~T();
 }
 
 template <typename T>
-std::vector<PtrBase const*> PtrChildren(PtrBase const* self) {
+void PtrVisitChildren(PtrBase const* self, void* arg,
+                      void (*cb)(void* arg, PtrBase const* child)) {
   auto const* _this = reinterpret_cast<Ptr<T> const*>(self);
   auto const* obj = _this->get();
   assert(obj != nullptr && "Ptr is not initialized");
 
-  auto ref_visitor = RefVisitor{};
+  auto ref_visitor = RefVisitor{.arg = arg, .cb = cb};
   reflect::DomainVisit(*obj, PtrRefDnv{ref_visitor});
-  return ref_visitor.children;
 }
 
 template <typename T>
 static constexpr auto kManageTableForT = ManageTable{
     PtrDestroy<T>,
-    PtrChildren<T>,
+    PtrVisitChildren<T>,
 };
 
 /**
@@ -261,7 +281,7 @@ Ptr<T> MakePtr(TArgs&&... args) {
   [[maybe_unused]] auto* ptr =
       new (storage->ptr()) T(std::forward<TArgs>(args)...);
   assert((ptr != nullptr) && "Construction failed!");
-  return Ptr<T>{typename PtrBase::MoveTag{}, storage};
+  return Ptr<T>{PtrBase::MoveTag{}, storage};
 }
 
 template <template <typename...> typename T, typename... TArgs>
diff --git a/aether/ptr/ptr_management.h b/aether/ptr/ptr_management.h
index bc0215af..2502e062 100644
--- a/aether/ptr/ptr_management.h
+++ b/aether/ptr/ptr_management.h
@@ -17,17 +17,18 @@
 #ifndef AETHER_PTR_PTR_MANAGEMENT_H_
 #define AETHER_PTR_PTR_MANAGEMENT_H_
 
-#include <cstdint>
 #include <cassert>
+#include <cstdint>
+#include <functional>
 #include <type_traits>
 
-#include "aether-miscpp/types/aligned_storage.h"
 #include "aether-miscpp/reflect/domain_visitor.h"
+#include "aether-miscpp/types/aligned_storage.h"
 
 namespace ae {
 struct PtrRefcounters {
-  std::uint8_t main_refs = 0;
-  std::uint8_t weak_refs = 0;
+  std::uint16_t main_refs = 0;
+  std::uint16_t weak_refs = 0;
 };
 
 class PtrBase;
@@ -35,14 +36,15 @@ class PtrBase;
 // function table for managing Ptr<T> from PtrBase
 struct ManageTable {
   void (*destroy)(PtrBase* self);
-  std::vector<PtrBase const*> (*child_ptrs)(PtrBase const* self);
+  void (*visit_children)(PtrBase const* self, void* arg,
+                         void (*cb)(void* arg, PtrBase const* child));
 };
 
 // PtrStorageBase* is used in general case, but PtrStorage<T>* in case there T
 // is known
 struct PtrStorageBase {
   PtrRefcounters ref_counters;
-  std::uint16_t alloc_size;
+  std::size_t alloc_size;
   ManageTable const* manage_table;
 };
 
@@ -53,7 +55,7 @@ class PtrStorage {
   [[nodiscard]] auto* ptr() const noexcept { return storage.ptr(); }
 
   PtrRefcounters ref_counters;
-  std::uint16_t alloc_size;
+  std::size_t alloc_size;
   ManageTable const* manage_table;
   Storage<T> storage;
 };
@@ -70,28 +72,30 @@ struct IsPtr<UPtr<T>, std::enable_if_t<std::is_base_of_v<Ptr<T>, UPtr<T>>>>
     : std::true_type {};
 }  // namespace ptr_management_internal
 
+template <typename T>
+static constexpr inline auto IsPtr_v = ptr_management_internal::IsPtr<T>::value;
+
 struct RefVisitor {
   template <typename U>
-  std::enable_if_t<ptr_management_internal::IsPtr<U>::value, bool> operator()(
-      U const& obj) {
+    requires(IsPtr_v<U>)
+  bool operator()(U const& obj) {
+    // always return false to prevent go into the obj itself
+
     auto const* obj_ptr = static_cast<void const*>(obj.get());
-    if (!obj_ptr) {
-      return false;
-    }
-    auto const& refs = obj.ptr_storage_->ref_counters;
-    if (refs.main_refs == 0) {
+    if (obj_ptr == nullptr) {
       return false;
     }
 
-    children.push_back(&obj);
+    std::invoke(cb, arg, &obj);
     return false;
   }
 
   template <typename U>
-  std::enable_if_t<!ptr_management_internal::IsPtr<U>::value> operator()(
-      U const& /* obj */) {}
+    requires(!IsPtr_v<U>)
+  void operator()(U const& /* obj */) {}
 
-  std::vector<PtrBase const*> children;
+  void* arg;
+  void (*cb)(void* arg, PtrBase const* child);
 };
 
 using PtrRefDnv =
diff --git a/aether/ptr/rc_ptr.h b/aether/ptr/rc_ptr.h
deleted file mode 100644
index d5cb12f7..00000000
--- a/aether/ptr/rc_ptr.h
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
- * Copyright 2024 Aethernet Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef AETHER_PTR_RC_PTR_H_
-#define AETHER_PTR_RC_PTR_H_
-
-#include <memory>
-#include <cstdint>
-#include <cassert>
-#include <utility>
-#include <atomic>
-
-#include "aether/mstream.h"
-#include "aether-miscpp/types/aligned_storage.h"
-
-namespace ae {
-// for most cases 2*uint8_t should be more than enough
-// saving more space is impossible due to alignment in RcStorage
-struct RefCounters {
-  std::atomic<std::uint8_t> main_refs;
-  std::atomic<std::uint8_t> weak_refs;
-};
-
-template <typename T>
-struct RcStorage {
- public:
-  [[nodiscard]] auto* ptr() noexcept { return storage.ptr(); }
-  [[nodiscard]] auto* ptr() const noexcept { return storage.ptr(); }
-
-  RefCounters ref_counters;
-  Storage<T> storage;
-};
-
-template <typename T>
-class RcPtr {
-  template <typename U>
-  friend class RcPtr;
-
-  template <typename U>
-  friend class RcPtrView;
-
- public:
-  RcPtr() noexcept = default;
-  RcPtr(std::nullptr_t) noexcept : RcPtr() {}  // NOLINT
-  explicit RcPtr(RcStorage<T>* rc_storage) noexcept : rc_storage_{rc_storage} {
-    Increment();
-  }
-  ~RcPtr() { Reset(); }
-
-  // Copying
-  RcPtr(RcPtr const& other) noexcept : RcPtr{other.rc_storage_} {}
-
-  auto& operator=(RcPtr const& other) noexcept {
-    if (this != &other) {
-      Reset();
-      rc_storage_ = other.rc_storage_;
-      Increment();
-    }
-    return *this;
-  }
-
-  // Moving
-  RcPtr(RcPtr&& other) noexcept : rc_storage_{other.rc_storage_} {
-    other.rc_storage_ = nullptr;
-  }
-
-  auto& operator=(RcPtr&& other) noexcept {
-    if (this != &other) {
-      Reset();
-      std::swap(rc_storage_, other.rc_storage_);
-    }
-    return *this;
-  }
-
-  // Access
-  [[nodiscard]] T* get() {
-    return (rc_storage_ != nullptr) ? rc_storage_->ptr() : nullptr;
-  }
-  [[nodiscard]] T* get() const {
-    return (rc_storage_ != nullptr) ? rc_storage_->ptr() : nullptr;
-  }
-
-  [[nodiscard]] T* operator->() noexcept {
-    assert((rc_storage_ != nullptr) && "Dereferencing a null pointer");
-    return get();
-  }
-  [[nodiscard]] T* operator->() const noexcept {
-    assert((rc_storage_ != nullptr) && "Dereferencing a null pointer");
-    return get();
-  }
-  [[nodiscard]] T& operator*() noexcept {
-    assert((rc_storage_ != nullptr) && "Dereferencing a null pointer");
-    return *get();
-  }
-  [[nodiscard]] T& operator*() const noexcept {
-    assert((rc_storage_ != nullptr) && "Dereferencing a null pointer");
-    return *get();
-  }
-
-  explicit operator bool() const noexcept { return rc_storage_ != nullptr; }
-
-  // Modifying
-  void Reset() {
-    if (rc_storage_ == nullptr) {
-      return;
-    }
-
-    Decrement();
-    if (rc_storage_->ref_counters.main_refs == 0) {
-      Destroy();
-      if (rc_storage_->ref_counters.weak_refs == 0) {
-        Free();
-      }
-    }
-    rc_storage_ = nullptr;
-  }
-
- private:
-  void Decrement() noexcept { rc_storage_->ref_counters.main_refs -= 1; }
-  void Increment() noexcept {
-    if (rc_storage_ == nullptr) {
-      return;
-    }
-    rc_storage_->ref_counters.main_refs += 1;
-  }
-
-  void Destroy() {
-    // prevent cycled rcptrviews delete rc_storage
-    rc_storage_->ref_counters.weak_refs += 1;
-    // Call destructor on T
-    rc_storage_->ptr()->~T();
-    rc_storage_->ref_counters.weak_refs -= 1;
-  }
-
-  void Free() noexcept {
-    auto alloc = std::allocator<RcStorage<T>>{};
-    alloc.deallocate(rc_storage_, std::size_t{1});
-  }
-
-  RcStorage<T>* rc_storage_{nullptr};
-};
-
-/**
- * \brief Construct an RcPtr
- */
-template <typename T, typename... TArgs>
-auto MakeRcPtr(TArgs&&... args) noexcept {
-  auto alloc = std::allocator<RcStorage<T>>{};
-  auto* rc_storage = alloc.allocate(std::size_t{1});
-  assert((rc_storage != nullptr) && "Bad alloc!");
-  [[maybe_unused]] auto* constructed =
-      new (rc_storage->ptr()) T{std::forward<TArgs>(args)...};
-  assert(constructed != nullptr && "Construction failed!");
-  rc_storage->ref_counters.main_refs = 0;
-  rc_storage->ref_counters.weak_refs = 0;
-  return RcPtr<T>{rc_storage};
-}
-
-template <template <typename...> typename T, typename... TArgs>
-auto MakeRcPtr(TArgs&&... args) noexcept {
-  using DeducedT = decltype(T{std::forward<TArgs>(args)...});
-  return MakeRcPtr<DeducedT>(std::forward<TArgs>(args)...);
-}
-
-template <typename T>
-class RcPtrView {
-  template <typename U>
-  friend class RcPtrView;
-
-  using OurRcPtr = RcPtr<T>;
-
- public:
-  RcPtrView() noexcept = default;
-  ~RcPtrView() noexcept { Reset(); }
-
-  RcPtrView(OurRcPtr const& rpc_ptr) noexcept  // NOLINT
-      : RcPtrView{rpc_ptr.rc_storage_} {}
-
-  // Copying
-  RcPtrView(RcPtrView const& other) noexcept : RcPtrView{other.rc_storage_} {}
-
-  RcPtrView& operator=(RcPtrView const& other) noexcept {
-    if (this != &other) {
-      Reset();
-      rc_storage_ = other.rc_storage_;
-      Increment();
-    }
-    return *this;
-  }
-
-  // Moving
-  RcPtrView(RcPtrView&& other) noexcept : rc_storage_{other.rc_storage_} {
-    other.rc_storage_ = nullptr;
-  }
-
-  RcPtrView& operator=(RcPtrView&& other) noexcept {
-    if (this != &other) {
-      Reset();
-      std::swap(rc_storage_, other.rc_storage_);
-    }
-    return *this;
-  }
-
-  // Access
-  [[nodiscard]] OurRcPtr lock() noexcept {
-    if (rc_storage_ != nullptr) {
-      if (rc_storage_->ref_counters.main_refs != 0) {
-        return OurRcPtr{rc_storage_};
-      }
-    }
-    return OurRcPtr{};
-  }
-
-  [[nodiscard]] OurRcPtr lock() const noexcept {
-    if (rc_storage_ != nullptr) {
-      if (rc_storage_->ref_counters.main_refs != 0) {
-        return OurRcPtr{rc_storage_};
-      }
-    }
-    return OurRcPtr{};
-  }
-
-  explicit operator bool() const noexcept {
-    return (rc_storage_ != nullptr) &&
-           (rc_storage_->ref_counters.main_refs != 0);
-  }
-
-  // Modifying
-  void Reset() noexcept {
-    if (rc_storage_ == nullptr) {
-      return;
-    }
-
-    Decrement();
-    if ((rc_storage_->ref_counters.main_refs == 0) &&
-        (rc_storage_->ref_counters.weak_refs == 0)) {
-      Free();
-    }
-    rc_storage_ = nullptr;
-  }
-
- private:
-  explicit RcPtrView(RcStorage<T>* rc_storage) noexcept
-      : rc_storage_{rc_storage} {
-    Increment();
-  }
-
-  void Decrement() noexcept { rc_storage_->ref_counters.weak_refs -= 1; }
-  void Increment() noexcept {
-    if (rc_storage_ == nullptr) {
-      return;
-    }
-    rc_storage_->ref_counters.weak_refs += 1;
-  }
-  void Free() noexcept {
-    auto alloc = std::allocator<RcStorage<T>>{};
-    alloc.deallocate(rc_storage_, std::size_t{1});
-  }
-
-  RcStorage<T>* rc_storage_{nullptr};
-};
-
-template <typename T, typename Ob>
-omstream<Ob>& operator<<(omstream<Ob>& s, RcPtr<T> const& v) {
-  if (v) {
-    s << true;
-    s << *v;
-  } else {
-    s << false;
-  }
-  return s;
-}
-
-template <typename T, typename Ib>
-imstream<Ib>& operator>>(imstream<Ib>& s, RcPtr<T>& v) {
-  bool has_value{};
-  s >> has_value;
-  if (!data_was_read(s)) {
-    return s;
-  }
-  if (has_value) {
-    auto temp = MakeRcPtr<T>();
-    s >> *temp;
-    if (data_was_read(s)) {
-      v = std::move(temp);
-    }
-  }
-  return s;
-}
-
-}  // namespace ae
-
-#endif  // AETHER_PTR_RC_PTR_H_
diff --git a/aether/ptr/ref_tree.cpp b/aether/ptr/ref_tree.cpp
index d1af19ac..ac9dc5f3 100644
--- a/aether/ptr/ref_tree.cpp
+++ b/aether/ptr/ref_tree.cpp
@@ -16,55 +16,128 @@
 
 #include "aether/ptr/ref_tree.h"
 
-#include <cstddef>
 #include <cassert>
-#include <algorithm>
 
 namespace ae {
 
-// rvalue std::set<std::size_t>&& is used here to avoid copies and has interface
-// with default value. Nobody except first function call owns the visited set.
-bool RefTree::Node::IsReachable(Index i,
-                                std::set<Index>&& visited) const noexcept {
-  visited.insert(index);
-  if (index == i) {
-    return true;
-  }
-
-  bool res = false;
-  for (auto const& child_index : children_indices) {
-    if (auto it = visited.find(child_index); it != visited.end()) {
-      // already visited
-      continue;
-    }
-    res = res || tree->get(child_index).IsReachable(i, std::move(visited));
+void ref_tree_internal::Node::PushChild(Index i) {
+  assert((tree_ != nullptr) && "Node tree is null");
+  assert((i < tree_->nodes_.Size()) && "Child index is out of range");
+  auto const edge_index = tree_->EmplaceEdge(i);
+  assert((child_count < std::numeric_limits<std::uint16_t>::max()) &&
+         "Child count overflow");
+  if (child_count == 0) {
+    first_edge_index_ = edge_index;
+  } else {
+    tree_->edge(last_edge_index_).next_edge_index = edge_index;
   }
+  last_edge_index_ = edge_index;
+  ++child_count;
+}
 
-  return res;
+bool ref_tree_internal::Node::IsReachable(Index i) const {
+  assert((tree_ != nullptr) && "Node tree is null");
+  auto const visit_index = tree_->NextReachableVisitIndex();
+  return tree_->IsReachableFrom(*this, i, visit_index);
 }
 
 RefTree::Node& RefTree::Emplace(std::uintptr_t pointer,
-                                std::uint8_t ref_count) {
-  auto it =
-      std::find_if(std::begin(nodes_), std::end(nodes_),
-                   [&](Node const& n) { return n.value.pointer == pointer; });
-  if (it != std::end(nodes_)) {
-    return *it;
+                                std::uint16_t ref_count) {
+  if (auto* node = FindNode(pointer); node != nullptr) {
+    node->tree_ = this;
+    return *node;
   }
+  auto const size = nodes_.Size();
+  assert((size <= std::numeric_limits<Index>::max()) && "Node index overflow");
+  auto node = Node{};
+  node.value = Value{pointer, ref_count, 0};
+  node.index = static_cast<Index>(size);
+  node.tree_ = this;
+  auto& inserted = nodes_.PushBack(node);
+  inserted.tree_ = this;
+  return inserted;
+}
+
+RefTree::EdgeIndex RefTree::EmplaceEdge(Index child_index) {
+  auto const size = edges_.Size();
+  assert((size < kInvalidEdgeIndex) && "Edge index overflow");
+  edges_.PushBack(Edge{child_index, kInvalidEdgeIndex});
+  return static_cast<EdgeIndex>(size);
+}
+
+RefTree::Edge& RefTree::edge(EdgeIndex index) {
+  assert((index != kInvalidEdgeIndex) && "Invalid edge index");
+  return edges_.At(static_cast<std::size_t>(index));
+}
+
+RefTree::Edge const& RefTree::edge(EdgeIndex index) const {
+  assert((index != kInvalidEdgeIndex) && "Invalid edge index");
+  return edges_.At(static_cast<std::size_t>(index));
+}
+
+std::size_t RefTree::NextForEachVisitIndex() noexcept {
+  return next_for_each_visit_index_++;
+}
+
+std::size_t RefTree::NextReachableVisitIndex() noexcept {
+  return next_reachable_visit_index_++;
+}
 
-  return nodes_.emplace_back(Node{
-      Value{pointer, ref_count, {}},
-      static_cast<Index>(nodes_.size()),
-      {},
-      this,
-  });
+bool RefTree::IsReachableFrom(RefTree::Node const& node, Index target,
+                              std::size_t visit_index) {
+  if (node.reachable_visit_index_ == visit_index) {
+    return false;
+  }
+  node.reachable_visit_index_ = visit_index;
+  if (node.index == target) {
+    return true;
+  }
+  auto edge_index = node.first_edge_index_;
+  std::vector<EdgeIndex> stack{};
+  while (edge_index != kInvalidEdgeIndex || !stack.empty()) {
+    if (edge_index == kInvalidEdgeIndex) {
+      edge_index = stack.back();
+      stack.pop_back();
+      continue;
+    }
+    auto const current_edge = edge(edge_index);
+    auto const child_index = current_edge.child_index;
+    auto const next_edge_index = current_edge.next_edge_index;
+    edge_index = next_edge_index;
+    if (child_index == target) {
+      return true;
+    }
+    auto& child = get(child_index);
+    if (child.reachable_visit_index_ == visit_index) {
+      continue;
+    }
+    child.reachable_visit_index_ = visit_index;
+    if (child.index == target) {
+      return true;
+    }
+    if (child.first_edge_index_ != kInvalidEdgeIndex) {
+      if (edge_index != kInvalidEdgeIndex) {
+        stack.push_back(edge_index);
+      }
+      edge_index = child.first_edge_index_;
+    }
+  }
+  return false;
 }
 
 RefTree::Node& RefTree::get(Index index) {
-  assert((static_cast<std::size_t>(index) < nodes_.size()) &&
-         "Index out of bounds");
-  auto& node = nodes_[static_cast<std::size_t>(index)];
-  node.tree = this;
+  auto& node = nodes_.At(static_cast<std::size_t>(index));
+  node.tree_ = this;
   return node;
 }
+
+RefTree::Node* RefTree::FindNode(std::uintptr_t pointer) noexcept {
+  for (std::size_t i = 0; i < nodes_.Size(); ++i) {
+    auto& node = nodes_.At(i);
+    if (node.value.pointer == pointer) {
+      return &node;
+    }
+  }
+  return nullptr;
+}
 }  // namespace ae
diff --git a/aether/ptr/ref_tree.h b/aether/ptr/ref_tree.h
index ea8dae49..dde858d4 100644
--- a/aether/ptr/ref_tree.h
+++ b/aether/ptr/ref_tree.h
@@ -17,65 +17,251 @@
 #ifndef AETHER_PTR_REF_TREE_H_
 #define AETHER_PTR_REF_TREE_H_
 
-#include <set>
-#include <vector>
+#include <array>
+#include <cassert>
+#include <cstddef>
 #include <cstdint>
+#include <limits>
+#include <type_traits>
 #include <utility>
+#include <variant>
+#include <vector>
 
 namespace ae {
 
-class RefTree {
+class RefTree;
+
+namespace ref_tree_internal {
+
+using Index = std::uint16_t;
+using EdgeIndex = std::uint16_t;
+inline constexpr EdgeIndex kInvalidEdgeIndex{
+    std::numeric_limits<EdgeIndex>::max()};
+inline constexpr std::size_t kRefTreeLocalNodeCapacity{32};
+inline constexpr std::size_t kRefTreeLocalEdgeCapacity{32};
+
+struct Value {
+  std::uintptr_t pointer{};
+  std::uint16_t ref_count{};
+  std::uint16_t reachable_ref_count{};
+};
+
+struct Edge {
+  Index child_index{};
+  EdgeIndex next_edge_index{kInvalidEdgeIndex};
+};
+
+class Node {
  public:
-  using Index = std::uint8_t;
+  void PushChild(Index i);
 
-  struct Value {
-    std::uintptr_t pointer;
-    std::uint8_t ref_count;
-    std::uint8_t reachable_ref_count;
-  };
+  template <typename TFunc>
+  bool ForEach(TFunc& func);
 
-  struct Node {
-    // apply func to each child node
-    template <typename TFunc>
-    bool ForEach(TFunc&& func, std::set<Index>&& visited = {}) noexcept {
-      visited.insert(index);
-      for (auto const& child_index : children_indices) {
-        if (auto next = func(tree->get(child_index)); !next) {
-          break;
-        }
-      }
+  template <typename TFunc>
+    requires(!std::is_lvalue_reference_v<TFunc>)
+  bool ForEach(TFunc&& func);
+  bool IsReachable(Index i) const;
 
-      for (auto const& child_index : children_indices) {
-        if (auto it = visited.find(child_index); it != visited.end()) {
-          // already visited
-          continue;
-        }
-        if (auto next =
-                tree->get(child_index)
-                    .ForEach(std::forward<TFunc>(func), std::move(visited));
-            !next) {
-          return false;
-        }
-      }
-      return true;
-    }
+  Value value{};
+  Index index{};
+  std::uint16_t child_count{};
+  bool children_expanded{false};
+
+ private:
+  // Outgoing edges are stored in RefTree's centralized linked list; tail keeps
+  // append order stable.
+  EdgeIndex first_edge_index_{kInvalidEdgeIndex};
+  EdgeIndex last_edge_index_{kInvalidEdgeIndex};
+  ae::RefTree* tree_{};
+  mutable std::size_t for_each_visit_index_{0};
+  mutable std::size_t reachable_visit_index_{0};
+
+  template <typename TFunc>
+  bool ForEachImpl(TFunc& func);
+
+  friend class ae::RefTree;
+};
 
-    // Check if the index is reachable from the node
-    bool IsReachable(Index i, std::set<Index>&& visited = {}) const noexcept;
+template <typename T, std::size_t kLocalCapacity>
+class Storage {
+ public:
+  std::size_t Size() const noexcept;
+  T& At(std::size_t index) noexcept;
+  T const& At(std::size_t index) const noexcept;
+  T& PushBack(T const& value);
 
-    Value value;
-    Index index;
-    std::vector<Index> children_indices;
-    RefTree* tree;
+ private:
+  struct LocalStorage {
+    std::array<T, kLocalCapacity> values{};
+    std::size_t size{};
   };
+  using DynamicStorage = std::vector<T>;
+
+  void MoveLocalToDynamic();
+
+  std::variant<LocalStorage, DynamicStorage> storage_{LocalStorage{}};
+};
 
-  Node& Emplace(std::uintptr_t pointer, std::uint8_t ref_count);
+using NodeStorage = Storage<Node, kRefTreeLocalNodeCapacity>;
+using EdgeStorage = Storage<Edge, kRefTreeLocalEdgeCapacity>;
+
+}  // namespace ref_tree_internal
+
+class RefTree {
+ public:
+  ~RefTree() = default;
+  RefTree() = default;
+  RefTree(RefTree const&) = delete;
+  RefTree& operator=(RefTree const&) = delete;
+  RefTree(RefTree&& other) noexcept = delete;
+  RefTree& operator=(RefTree&& other) noexcept = delete;
+
+  using Index = ref_tree_internal::Index;
+  using Value = ref_tree_internal::Value;
+  using Node = ref_tree_internal::Node;
+
+  friend class ref_tree_internal::Node;
+
+  Node& Emplace(std::uintptr_t pointer, std::uint16_t ref_count);
   Node& get(Index index);
 
  private:
-  // list of nodes, head is always 0
-  std::vector<Node> nodes_;
+  using Edge = ref_tree_internal::Edge;
+  using EdgeIndex = ref_tree_internal::EdgeIndex;
+  static constexpr EdgeIndex kInvalidEdgeIndex =
+      ref_tree_internal::kInvalidEdgeIndex;
+
+  EdgeIndex EmplaceEdge(Index child_index);
+  Edge& edge(EdgeIndex index);
+  Edge const& edge(EdgeIndex index) const;
+  std::size_t NextForEachVisitIndex() noexcept;
+  std::size_t NextReachableVisitIndex() noexcept;
+  template <typename TFunc>
+  bool ForEachChildren(Node& parent, TFunc& func, std::size_t visit_index);
+  bool IsReachableFrom(Node const& node, Index target, std::size_t visit_index);
+  Node* FindNode(std::uintptr_t pointer) noexcept;
+
+  ref_tree_internal::NodeStorage nodes_{};
+  ref_tree_internal::EdgeStorage edges_{};
+  std::size_t next_for_each_visit_index_{1};
+  std::size_t next_reachable_visit_index_{1};
 };
+
+template <typename TFunc>
+bool ref_tree_internal::Node::ForEach(TFunc& func) {
+  assert((tree_ != nullptr) && "Node tree is null");
+  return ForEachImpl(func);
+}
+
+template <typename TFunc>
+  requires(!std::is_lvalue_reference_v<TFunc>)
+bool ref_tree_internal::Node::ForEach(TFunc&& func) {
+  auto callback = std::forward<TFunc>(func);
+  return ForEachImpl(callback);
+}
+
+template <typename TFunc>
+bool ref_tree_internal::Node::ForEachImpl(TFunc& func) {
+  assert((tree_ != nullptr) && "Node tree is null");
+  auto const visit_index = tree_->NextForEachVisitIndex();
+  for_each_visit_index_ = visit_index;
+  return tree_->ForEachChildren(*this, func, visit_index);
+}
+
+template <typename TFunc>
+bool RefTree::ForEachChildren(Node& parent, TFunc& func,
+                              std::size_t visit_index) {
+  auto edge_index = parent.first_edge_index_;
+  std::vector<EdgeIndex> stack{};
+  while (edge_index != kInvalidEdgeIndex || !stack.empty()) {
+    if (edge_index == kInvalidEdgeIndex) {
+      edge_index = stack.back();
+      stack.pop_back();
+      continue;
+    }
+    auto const current_edge = edge(edge_index);
+    auto const child_index = current_edge.child_index;
+    auto const next_edge_index = current_edge.next_edge_index;
+    edge_index = next_edge_index;
+    auto& child = get(child_index);
+    if (child.for_each_visit_index_ == visit_index) {
+      continue;
+    }
+    child.for_each_visit_index_ = visit_index;
+    if (!func(child)) {
+      return false;
+    }
+    if (child.first_edge_index_ != kInvalidEdgeIndex) {
+      if (edge_index != kInvalidEdgeIndex) {
+        stack.push_back(edge_index);
+      }
+      edge_index = child.first_edge_index_;
+    }
+  }
+  return true;
+}
+
+template <typename T, std::size_t kLocalCapacity>
+std::size_t ref_tree_internal::Storage<T, kLocalCapacity>::Size()
+    const noexcept {
+  if (auto const* dynamic = std::get_if<DynamicStorage>(&storage_);
+      dynamic != nullptr) {
+    return dynamic->size();
+  }
+  return std::get<LocalStorage>(storage_).size;
+}
+
+template <typename T, std::size_t kLocalCapacity>
+T& ref_tree_internal::Storage<T, kLocalCapacity>::At(
+    std::size_t index) noexcept {
+  assert((index < Size()) && "Storage index out of range");
+  if (auto* dynamic = std::get_if<DynamicStorage>(&storage_);
+      dynamic != nullptr) {
+    return (*dynamic)[index];
+  }
+  return std::get<LocalStorage>(storage_).values[index];
+}
+
+template <typename T, std::size_t kLocalCapacity>
+T const& ref_tree_internal::Storage<T, kLocalCapacity>::At(
+    std::size_t index) const noexcept {
+  assert((index < Size()) && "Storage index out of range");
+  if (auto const* dynamic = std::get_if<DynamicStorage>(&storage_);
+      dynamic != nullptr) {
+    return (*dynamic)[index];
+  }
+  return std::get<LocalStorage>(storage_).values[index];
+}
+
+template <typename T, std::size_t kLocalCapacity>
+void ref_tree_internal::Storage<T, kLocalCapacity>::MoveLocalToDynamic() {
+  auto& local = std::get<LocalStorage>(storage_);
+  auto dynamic =
+      DynamicStorage(local.values.begin(), local.values.begin() + local.size);
+  storage_.template emplace<DynamicStorage>(std::move(dynamic));
+}
+
+template <typename T, std::size_t kLocalCapacity>
+T& ref_tree_internal::Storage<T, kLocalCapacity>::PushBack(T const& value) {
+  if (auto* dynamic = std::get_if<DynamicStorage>(&storage_);
+      dynamic != nullptr) {
+    dynamic->push_back(value);
+    return dynamic->back();
+  }
+  auto& local = std::get<LocalStorage>(storage_);
+  if (local.size < kLocalCapacity) {
+    local.values[local.size] = value;
+    ++local.size;
+    return local.values[local.size - 1];
+  }
+  MoveLocalToDynamic();
+  auto* dynamic = std::get_if<DynamicStorage>(&storage_);
+  assert((dynamic != nullptr) && "Dynamic storage missing after move");
+  dynamic->push_back(value);
+  return dynamic->back();
+}
+
 }  // namespace ae
 
 #endif  // AETHER_PTR_REF_TREE_H_
diff --git a/aether/server_connections/iserver_connection_factory.h b/aether/server_connections/iserver_connection_factory.h
index fe371a41..6668143b 100644
--- a/aether/server_connections/iserver_connection_factory.h
+++ b/aether/server_connections/iserver_connection_factory.h
@@ -17,8 +17,9 @@
 #ifndef AETHER_SERVER_CONNECTIONS_ISERVER_CONNECTION_FACTORY_H_
 #define AETHER_SERVER_CONNECTIONS_ISERVER_CONNECTION_FACTORY_H_
 
+#include <memory>
+
 #include "aether/ptr/ptr.h"
-#include "aether/ptr/rc_ptr.h"
 #include "aether/server_connections/client_server_connection.h"
 
 namespace ae {
@@ -27,7 +28,7 @@ class IServerConnectionFactory {
  public:
   virtual ~IServerConnectionFactory() = default;
 
-  virtual RcPtr<ClientServerConnection> CreateConnection(
+  virtual std::shared_ptr<ClientServerConnection> CreateConnection(
       Ptr<Server> const& server) = 0;
 };
 }  // namespace ae
diff --git a/examples/a_b_message_exchange/a_b_message_exchange.cpp b/examples/a_b_message_exchange/a_b_message_exchange.cpp
index cbaffc51..e6032266 100644
--- a/examples/a_b_message_exchange/a_b_message_exchange.cpp
+++ b/examples/a_b_message_exchange/a_b_message_exchange.cpp
@@ -50,7 +50,7 @@ static std::string_view ToString(ae::DataBuffer const& data) {
 }
 
 struct State {
-  explicit State(ae::RcPtr<ae::AetherApp> const& app) : aether{app->aether()} {}
+  explicit State(ae::AetherApp& app) : aether{app.aether()} {}
 
   ae::Aether::ptr aether;
   ae::Client::ptr client_a;
@@ -177,7 +177,7 @@ int AetherABMessageExchangeExample() {
   auto aether_app = ae::examples::construct_aether_app();
   Log("app.create.done");
 
-  State state{aether_app};
+  State state{*aether_app};
 
   auto pipeline = ae::ex::just() |
                   SelectClientSender(&state, "A", &State::client_a) |
diff --git a/examples/benches/send_message_delays/main.cpp b/examples/benches/send_message_delays/main.cpp
index 2e963cdd..c38fb479 100644
--- a/examples/benches/send_message_delays/main.cpp
+++ b/examples/benches/send_message_delays/main.cpp
@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 
+#include <filesystem>
 #include <fstream>
 #include <iostream>
-#include <filesystem>
 
 #include "aether/all.h"
 
 #include "send_message_delays/receiver.h"
+#include "send_message_delays/send_message_delays_manager.h"
 #include "send_message_delays/sender.h"
 #include "send_message_delays/statistics_write.h"
-#include "send_message_delays/send_message_delays_manager.h"
 
 namespace ae::bench {
 static constexpr auto kTestUid =
@@ -33,10 +33,10 @@ class TestSendMessageDelays {
  public:
   using TestFinishedEvent = Event<void(std::optional<Result<Ignore, int>>)>;
 
-  TestSendMessageDelays(RcPtr<AetherApp> const& aether_app,
+  TestSendMessageDelays(AetherApp& aether_app,
                         std::ostream& write_results_stream)
-      : ae_context_{*aether_app},
-        aether_{aether_app->aether()},
+      : ae_context_{aether_app},
+        aether_{aether_app.aether()},
         write_results_stream_{write_results_stream} {
     TestPipeline();
   }
@@ -165,7 +165,7 @@ class TestSendMessageDelays {
 int test_send_message_delays(std::ostream& result_stream) {
   auto aether_app = AetherApp::Construct(AetherAppContext{});
 
-  auto test = TestSendMessageDelays{aether_app, result_stream};
+  auto test = TestSendMessageDelays{*aether_app, result_stream};
   test.test_finished().Subscribe([&](auto res) {
     if (res && res->IsOk()) {
       aether_app->Exit(0);
diff --git a/examples/common/aether_construct.h b/examples/common/aether_construct.h
index 47f7f2af..e3cfae5f 100644
--- a/examples/common/aether_construct.h
+++ b/examples/common/aether_construct.h
@@ -30,10 +30,12 @@
 #  define AE_EXAMPLE_MODEM 0
 #endif
 
+#include <memory>
+
 #include "aether/all.h"
 
 namespace ae::examples {
-static RcPtr<AetherApp> construct_aether_app();
+static std::unique_ptr<AetherApp> construct_aether_app();
 }
 
 #endif  // EXAMPLES_COMMON_AETHER_CONSTRUCT_H_
diff --git a/examples/common/aether_construct_esp_wifi.h b/examples/common/aether_construct_esp_wifi.h
index 27a9ad84..c01599c3 100644
--- a/examples/common/aether_construct_esp_wifi.h
+++ b/examples/common/aether_construct_esp_wifi.h
@@ -37,7 +37,7 @@ static IpV6Addr my_static_ip_v6{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00,
                                 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34};
 
 WiFiIP wifi_ip{{my_static_ip_v4}, {my_gateway_ip_v4}, {my_netmask_ip_v4},
-               {my_dns1_ip_v4}, {my_dns2_ip_v4}, {my_static_ip_v6}};
+               {my_dns1_ip_v4},   {my_dns2_ip_v4},    {my_static_ip_v6}};
 
 static WifiCreds my_wifi1{kWifi1Ssid, kWifi1Pass};
 static WifiCreds my_wifi2{kWifi2Ssid, kWifi2Pass};
@@ -47,15 +47,19 @@ ae::WiFiAp wifi2_ap{my_wifi2, {} /*wifi_ip*/};
 
 std::vector<ae::WiFiAp> wifi_ap_vec{wifi1_ap, wifi2_ap};
 
-static WiFiPowerSaveParam wifi_psp{AE_WIFI_PS_MAX_MODEM,
-                                   AE_WIFI_PROTOCOL_11B |
-                                       AE_WIFI_PROTOCOL_11G |
-                                       AE_WIFI_PROTOCOL_11N,
-                                   3, 500, 0, 3, 3, 8};
+static WiFiPowerSaveParam wifi_psp{
+    AE_WIFI_PS_MAX_MODEM,
+    AE_WIFI_PROTOCOL_11B | AE_WIFI_PROTOCOL_11G | AE_WIFI_PROTOCOL_11N,
+    3,
+    500,
+    0,
+    3,
+    3,
+    8};
 
 WiFiInit wifi_init{wifi_ap_vec, {}};
 
-RcPtr<AetherApp> construct_aether_app() {
+std::unique_ptr<AetherApp> construct_aether_app() {
   return AetherApp::Construct(
       AetherAppContext{}
 #  if defined AE_DISTILLATION
diff --git a/examples/common/aether_construct_ethernet.h b/examples/common/aether_construct_ethernet.h
index bb7b1603..8fcf1df1 100644
--- a/examples/common/aether_construct_ethernet.h
+++ b/examples/common/aether_construct_ethernet.h
@@ -21,7 +21,7 @@
 
 #if AE_EXAMPLE_ETHERNET
 namespace ae::examples {
-static RcPtr<AetherApp> construct_aether_app() {
+static std::unique_ptr<AetherApp> construct_aether_app() {
   return AetherApp::Construct(
       AetherAppContext{}
 #  if AE_DISTILLATION
diff --git a/examples/common/aether_construct_lora_module.h b/examples/common/aether_construct_lora_module.h
index 0917d95a..b2c0c3bc 100644
--- a/examples/common/aether_construct_lora_module.h
+++ b/examples/common/aether_construct_lora_module.h
@@ -17,8 +17,8 @@
 #ifndef EXAMPLES_COMMON_AETHER_CONSTRUCT_LORA_MODULE_H_
 #define EXAMPLES_COMMON_AETHER_CONSTRUCT_LORA_MODULE_H_
 
-#include "aether_construct.h"
 #include "aether/config.h"
+#include "aether_construct.h"
 
 #if AE_EXAMPLE_LORA_MODULE
 #  if !AE_SUPPORT_LORA
@@ -31,24 +31,29 @@ SerialInit serial_init_lora_module = {std::string(kSerialPortLoraModule),
                                       kBaudRate::kBaudRate9600};
 
 LoraPowerSaveParam psp{kLoraModuleMode::kTransparentTransmission,
-                       kLoraModuleLevel::kLevel0, kLoraModulePower::kPower22,
+                       kLoraModuleLevel::kLevel0,
+                       kLoraModulePower::kPower22,
                        kLoraModuleBandWidth::kBandWidth125K,
                        kLoraModuleCodingRate::kCR4_6,
                        kLoraModuleSpreadingFactor::kSF12};
 
-ae::LoraModuleInit const lora_module_init{serial_init_lora_module, psp,
+ae::LoraModuleInit const lora_module_init{serial_init_lora_module,
+                                          psp,
                                           kLoraModuleFreqRange::kFREUndef,
-                                          0, 0, 0,
+                                          0,
+                                          0,
+                                          0,
                                           kLoraModuleCRCCheck::kCRCOff,
                                           kLoraModuleIQSignalInversion::kIQoff};
 
-static RcPtr<AetherApp> construct_aether_app() {
+static std::unique_ptr<AetherApp> construct_aether_app() {
   return AetherApp::Construct(
       AetherAppContext{}
 #    if defined AE_DISTILLATION
           .AddAdapterFactory([](AetherAppContext const& context) {
             return LoraModuleAdapter::ptr::Create(
-                CreateWith{context.domain()}.with_id(ae::GlobalId::kLoraModuleAdapter),
+                CreateWith{context.domain()}.with_id(
+                    ae::GlobalId::kLoraModuleAdapter),
                 context.aether(), context.poller(), lora_module_init);
           })
 #    endif
diff --git a/examples/common/aether_construct_modem.h b/examples/common/aether_construct_modem.h
index 2b297d05..e5770545 100644
--- a/examples/common/aether_construct_modem.h
+++ b/examples/common/aether_construct_modem.h
@@ -29,19 +29,32 @@ static constexpr std::string_view kSerialPortModem = "COM1";
 SerialInit serial_init_modem = {std::string(kSerialPortModem),
                                 kBaudRate::kBaudRate115200};
 
-static ae::ModemInit const modem_init{serial_init_modem, {}, {}, 1111, false,
-                                      ae::kModemMode::kModeNbIot, "00001", "",
-                                      "internet", "user", "password",
-                                      ae::kAuthType::kAuthTypeNone, false, "", "",
-                                      "", false};
+static ae::ModemInit const modem_init{serial_init_modem,
+                                      {},
+                                      {},
+                                      1111,
+                                      false,
+                                      ae::kModemMode::kModeNbIot,
+                                      "00001",
+                                      "",
+                                      "internet",
+                                      "user",
+                                      "password",
+                                      ae::kAuthType::kAuthTypeNone,
+                                      false,
+                                      "",
+                                      "",
+                                      "",
+                                      false};
 
-static RcPtr<AetherApp> construct_aether_app() {
+static std::unique_ptr<AetherApp> construct_aether_app() {
   return AetherApp::Construct(
       AetherAppContext{}
 #    if defined AE_DISTILLATION
           .AddAdapterFactory([](AetherAppContext const& context) {
             return ModemAdapter::ptr::Create(
-                CreateWith{context.domain()}.with_id(ae::GlobalId::kModemAdapter),
+                CreateWith{context.domain()}.with_id(
+                    ae::GlobalId::kModemAdapter),
                 context.aether(), context.poller(), modem_init);
           })
 #    endif
diff --git a/tests/test-object-system/test-version-iterator.cpp b/tests/test-object-system/test-version-iterator.cpp
index 79384167..70031a7d 100644
--- a/tests/test-object-system/test-version-iterator.cpp
+++ b/tests/test-object-system/test-version-iterator.cpp
@@ -31,14 +31,14 @@ void test_MaxVersion() {
   // test if possible to create a Version objects
   // cppcheck-suppress-begin unreadVariable
   Version<0> v{};                      // ok!
-  Version<MAX_VERSION> max_version{};  // ok!
+  Version<kMaxVersion> max_version{};  // ok!
   // cppcheck-suppress-end unreadVariable
   // Version<MAX_VERSION + 1> to_big_version;  // not ok!
 
   static_assert(VersionAllowed<0>::value, "Version<0> must be allowed");
-  static_assert(VersionAllowed<MAX_VERSION>::value,
+  static_assert(VersionAllowed<kMaxVersion>::value,
                 "Version<MAX_VERSION> must be allowed");
-  static_assert(!VersionAllowed<MAX_VERSION + 1>::value,
+  static_assert(!VersionAllowed<kMaxVersion + 1>::value,
                 "Version<MAX_VERSION + 1> must not be allowed");
 }
 
@@ -61,17 +61,17 @@ struct TestObject {
 
   // saves
   template <typename Dnv>
-  void Save(Version<0> v, Dnv& dnv) {
+  void Save(Version<0> v, Dnv& dnv) const {
     dnv(v);
   }
 
   template <typename Dnv>
-  void Save(Version<1> v, Dnv& dnv) {
+  void Save(Version<1> v, Dnv& dnv) const {
     dnv(v);
   }
 
   template <typename Dnv>
-  void Save(Version<2> v, Dnv& dnv) {
+  void Save(Version<2> v, Dnv& dnv) const {
     dnv(v);
   }
 };
@@ -79,67 +79,71 @@ struct TestObject {
 struct TestObject2 {
   // loads
   template <typename Dnv>
-  void Load(Version<MAX_VERSION - 3> v, Dnv& dnv) {
+  void Load(Version<kMaxVersion - 3> v, Dnv& dnv) {
     dnv(v);
   }
 
   template <typename Dnv>
-  void Load(Version<MAX_VERSION - 2> v, Dnv& dnv) {
+  void Load(Version<kMaxVersion - 2> v, Dnv& dnv) {
     dnv(v);
   }
 
   template <typename Dnv>
-  void Load(Version<MAX_VERSION - 1> v, Dnv& dnv) {
+  void Load(Version<kMaxVersion - 1> v, Dnv& dnv) {
     dnv(v);
   }
 
   // saves
   template <typename Dnv>
-  void Save(Version<MAX_VERSION - 2> v, Dnv& dnv) {
+  void Save(Version<kMaxVersion - 2> v, Dnv& dnv) const {
     dnv(v);
   }
 
   template <typename Dnv>
-  void Save(Version<MAX_VERSION - 1> v, Dnv& dnv) {
+  void Save(Version<kMaxVersion - 1> v, Dnv& dnv) const {
     dnv(v);
   }
 
   template <typename Dnv>
-  void Save(Version<MAX_VERSION> v, Dnv& dnv) {
+  void Save(Version<kMaxVersion> v, Dnv& dnv) const {
     dnv(v);
   }
 };
 
 void test_HasVersionedTraits() {
   static_assert(HasAnyVersionedLoad<TestObject>::value, "Load(Version)");
-  static_assert(HasVersionedLoad<TestObject, 0>::value, "Load(Version<0>)");
-  static_assert(HasVersionedLoad<TestObject, 1>::value, "Load(Version<1>)");
-  static_assert(HasVersionedLoad<TestObject, 2>::value, "Load(Version<2>)");
-  static_assert(!HasVersionedLoad<TestObject, 3>::value, "!Load(Version<3>)");
+  static_assert(VersionLoadTrait<TestObject, 0>::value, "Load(Version<0>)");
+  static_assert(VersionLoadTrait<TestObject, 1>::value, "Load(Version<1>)");
+  static_assert(VersionLoadTrait<TestObject, 2>::value, "Load(Version<2>)");
+  static_assert(!VersionLoadTrait<TestObject, 3>::value, "!Load(Version<3>)");
 
   static_assert(HasAnyVersionedSave<TestObject>::value, "Save(Version)");
-  static_assert(HasVersionedSave<TestObject, 0>::value, "Save(Version<0>)");
-  static_assert(HasVersionedSave<TestObject, 1>::value, "Save(Version<1>)");
-  static_assert(HasVersionedSave<TestObject, 2>::value, "Save(Version<2>)");
-  static_assert(!HasVersionedSave<TestObject, 3>::value, "!Save(Version<3>)");
+  static_assert(VersionSaveTrait<TestObject, 0>::value, "Save(Version<0>)");
+  static_assert(VersionSaveTrait<TestObject, 1>::value, "Save(Version<1>)");
+  static_assert(VersionSaveTrait<TestObject, 2>::value, "Save(Version<2>)");
+  static_assert(!VersionSaveTrait<TestObject, 3>::value, "!Save(Version<3>)");
 }
 
 void test_ObjectVersionBounds() {
-  constexpr auto object1_load_bounds = VersionedLoadMinMax<TestObject>::value;
+  constexpr auto object1_load_bounds =
+      VersionBounds<TestObject, VersionLoadTrait>::value;
   static_assert(0 == object1_load_bounds.first);
   static_assert(2 == object1_load_bounds.second);
 
-  constexpr auto object1_save_bounds = VersionedSaveMinMax<TestObject>::value;
+  constexpr auto object1_save_bounds =
+      VersionBounds<TestObject, VersionSaveTrait>::value;
   static_assert(0 == object1_save_bounds.first);
   static_assert(2 == object1_save_bounds.second);
 
-  constexpr auto object2_load_bounds = VersionedLoadMinMax<TestObject2>::value;
-  static_assert(MAX_VERSION - 3 == object2_load_bounds.first);
-  static_assert(MAX_VERSION - 1 == object2_load_bounds.second);
+  constexpr auto object2_load_bounds =
+      VersionBounds<TestObject2, VersionLoadTrait>::value;
+  static_assert(kMaxVersion - 3 == object2_load_bounds.first);
+  static_assert(kMaxVersion - 1 == object2_load_bounds.second);
 
-  constexpr auto object2_save_bounds = VersionedSaveMinMax<TestObject2>::value;
-  static_assert(MAX_VERSION - 2 == object2_save_bounds.first);
-  static_assert(MAX_VERSION == object2_save_bounds.second);
+  constexpr auto object2_save_bounds =
+      VersionBounds<TestObject2, VersionSaveTrait>::value;
+  static_assert(kMaxVersion - 2 == object2_save_bounds.first);
+  static_assert(kMaxVersion == object2_save_bounds.second);
 }
 
 template <typename TFactory>
@@ -149,9 +153,7 @@ void VersionIteratorLoadTestFunc(TFactory factory) {
   using ObjectType = std::decay_t<decltype(obj)>;
 
   int visit_count = 0;
-  constexpr auto version_bounds = VersionedLoadMinMax<ObjectType>::value;
-  IterateVersions<HasVersionedLoad, version_bounds.first,
-                  version_bounds.second>(
+  version_iterator<VersionLoadTrait>(
       obj, [&visit_count](auto, auto const&) { ++visit_count; });
 
   TEST_ASSERT_EQUAL(expected_count, visit_count);
@@ -164,9 +166,7 @@ void VersionIteratorSaveTestFunc(TFactory factory) {
   using ObjectType = std::decay_t<decltype(obj)>;
 
   int visit_count = 0;
-  constexpr auto version_bounds = VersionedSaveMinMax<ObjectType>::value;
-  IterateVersions<HasVersionedSave, version_bounds.first,
-                  version_bounds.second>(
+  version_iterator<VersionSaveTrait>(
       obj, [&visit_count](auto, auto const&) { ++visit_count; });
 
   TEST_ASSERT_EQUAL(expected_count, visit_count);
diff --git a/tests/test-ptr/CMakeLists.txt b/tests/test-ptr/CMakeLists.txt
index 5a30c01f..8a87adfb 100644
--- a/tests/test-ptr/CMakeLists.txt
+++ b/tests/test-ptr/CMakeLists.txt
@@ -22,13 +22,11 @@ list(APPEND test_srcs
     ${ROOT_DIR}/aether/ptr/ref_tree.cpp
 
     main.cpp
-    test-rc-ptr.cpp
-    test-rc-ptr-bench.cpp
-    test-shared-ptr-bench.cpp
     test-ptr.cpp
     test-ptr-inheritance.cpp
     test-ptr-view.cpp
     test-ptr-cycles.cpp
+    test-ref-tree.cpp
 )
 
 if(NOT CM_PLATFORM)
diff --git a/tests/test-ptr/main.cpp b/tests/test-ptr/main.cpp
index 1bcef0ba..5b61ddd0 100644
--- a/tests/test-ptr/main.cpp
+++ b/tests/test-ptr/main.cpp
@@ -19,27 +19,19 @@
 void setUp() {}
 void tearDown() {}
 
-extern int test_rc_ptr();
-extern int test_rc_ptr_bench();
-extern int test_shared_ptr_bench();
-
 extern int run_test_ptr();
 extern int test_ptr_cycles();
 extern int test_ptr_view();
 extern int test_ptr_inheritance();
+extern int test_ref_tree();
 
 int main() {
   int res = 0;
 
-  res += test_rc_ptr();
+  res += test_ref_tree();
   res += run_test_ptr();
   res += test_ptr_cycles();
   res += test_ptr_view();
   res += test_ptr_inheritance();
-
-#if defined AE_RC_PTR_BENCH
-  res += test_rc_ptr_bench();
-  res += test_shared_ptr_bench();
-#endif
   return res;
 }
diff --git a/tests/test-ptr/test-ptr.cpp b/tests/test-ptr/test-ptr.cpp
index 31a9e36a..275e78e6 100644
--- a/tests/test-ptr/test-ptr.cpp
+++ b/tests/test-ptr/test-ptr.cpp
@@ -187,6 +187,10 @@ void test_ptrCompare() {
     TEST_ASSERT(!a);
     Ptr<A> a1 = a;
     TEST_ASSERT(!a1);
+    TEST_ASSERT(a == nullptr);
+    TEST_ASSERT(nullptr == a);
+    TEST_ASSERT(!(a != nullptr));
+    TEST_ASSERT(!(nullptr != a));
   }
 
   {
@@ -202,6 +206,29 @@ void test_ptrCompare() {
     Ptr<B> b{MakePtr<B>()};
     TEST_ASSERT(a != b);
   }
+
+  {
+    Ptr<A> a{MakePtr<A>()};
+    TEST_ASSERT(a);
+    TEST_ASSERT(a != nullptr);
+    TEST_ASSERT(nullptr != a);
+    TEST_ASSERT(!(a == nullptr));
+    TEST_ASSERT(!(nullptr == a));
+  }
+
+  {
+    Ptr<A> a{MakePtr<A>()};
+    Ptr<A> moved{std::move(a)};
+    TEST_ASSERT(!a);
+    TEST_ASSERT(a == nullptr);
+    TEST_ASSERT(nullptr == a);
+    TEST_ASSERT(!(a != nullptr));
+    TEST_ASSERT(!(nullptr != a));
+    TEST_ASSERT(moved != nullptr);
+    TEST_ASSERT(nullptr != moved);
+    TEST_ASSERT(!(moved == nullptr));
+    TEST_ASSERT(!(nullptr == moved));
+  }
 }
 
 struct MakeYourSelf {
diff --git a/tests/test-ptr/test-rc-ptr-bench.cpp b/tests/test-ptr/test-rc-ptr-bench.cpp
deleted file mode 100644
index 53a46666..00000000
--- a/tests/test-ptr/test-rc-ptr-bench.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright 2024 Aethernet Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <unity.h>
-
-#include <vector>
-
-#include "aether/ptr/rc_ptr.h"
-
-#include "tests/benchmarking.h"
-
-namespace ae::test_rc_ptr_bench {
-#if !defined NDEBUG
-static constexpr std::size_t kBenchCount = 10'000'000;
-#else
-static constexpr std::size_t kBenchCount = 100'000'000;
-#endif
-
-struct Rabbit {
-  Rabbit(int y) { x = y * y; }
-  ~Rabbit() { x = x - x / 2; }
-  int x{0};
-};
-
-void test_rc_ptr_CreationBench() {
-  tests::BenchmarkFunc(
-      [](auto i) {
-        auto rabbit_ptr = MakeRcPtr<Rabbit>(static_cast<int>(i));
-        rabbit_ptr->x += static_cast<int>(i) % 100;
-        rabbit_ptr.Reset();
-      },
-      kBenchCount, "create and destroy ");
-
-  std::vector<RcPtr<Rabbit>> rabbits1;
-  rabbits1.reserve(1000);
-  tests::BenchmarkFunc(
-      [&](auto i) {
-        for (auto j = 0; j < rabbits1.capacity(); j++) {
-          rabbits1.push_back(MakeRcPtr<Rabbit>(static_cast<int>(i + j)));
-          rabbits1.back()->x += static_cast<int>(i) % 100;
-        }
-        rabbits1.clear();
-      },
-      kBenchCount / rabbits1.capacity(), "create a bunch size ",
-      rabbits1.capacity(), " and destroy all after");
-}
-
-std::vector<RcPtr<Rabbit>> rabbits2;
-void test_rc_ptr_CopyingBench() {
-  tests::BenchmarkFunc(
-      [&](auto i) {
-        rabbits2.push_back(MakeRcPtr<Rabbit>(static_cast<int>(i % 10'000)));
-        if (((i + 1) % 10'000) == 0) {
-          rabbits2.clear();
-          rabbits2.shrink_to_fit();
-        }
-      },
-      kBenchCount, "moving inside the vector while it grows max ", 10'000,
-      " elements");
-
-  std::vector<RcPtr<Rabbit>> rabbits3;
-  rabbits3.reserve(1000);
-  for (std::size_t j = 0; j < rabbits3.capacity(); j++) {
-    rabbits3.push_back(MakeRcPtr<Rabbit>(static_cast<int>(j)));
-  }
-  tests::BenchmarkFunc(
-      [&](auto i) {
-        auto copy_rabbits = rabbits3;
-        for (auto& r : copy_rabbits) {
-          r->x += i % 100;
-        }
-      },
-      kBenchCount / 100, "copying the vector size: ", rabbits3.capacity());
-}
-
-}  // namespace ae::test_rc_ptr_bench
-
-int test_rc_ptr_bench() {
-  UNITY_BEGIN();
-  RUN_TEST(ae::test_rc_ptr_bench::test_rc_ptr_CreationBench);
-  RUN_TEST(ae::test_rc_ptr_bench::test_rc_ptr_CopyingBench);
-  return UNITY_END();
-}
diff --git a/tests/test-ptr/test-rc-ptr.cpp b/tests/test-ptr/test-rc-ptr.cpp
deleted file mode 100644
index 928e3826..00000000
--- a/tests/test-ptr/test-rc-ptr.cpp
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright 2024 Aethernet Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <unity.h>
-
-#include <vector>
-
-#include "aether/ptr/rc_ptr.h"
-
-#include "tests/test-ptr/pipe_there_they_are_sitting.h"
-
-namespace ae::test_rc_ptr {
-using test_ptr::A;
-using test_ptr::B;
-
-void test_createPtr() {
-  {
-    RcPtr<A> a;
-    RcPtr<A> a1{nullptr};
-  }
-  {
-    RcPtr<A> a{MakeRcPtr<A>()};
-    TEST_ASSERT(a);
-  }
-  {
-    RcPtr<A> a{MakeRcPtr<A>()};
-    RcPtr<A> a1{a};
-    TEST_ASSERT(a);
-    TEST_ASSERT(a1);
-  }
-  {
-    RcPtr<A> a{MakeRcPtr<A>()};
-    RcPtr<A> a1{std::move(a)};
-    TEST_ASSERT(!a);
-    TEST_ASSERT(a1);
-  }
-  {
-    RcPtr<A> a{MakeRcPtr<A>()};
-    RcPtr<A> a1{std::move(a)};
-    TEST_ASSERT(!a);
-    TEST_ASSERT(a1);
-  }
-}
-
-void test_ptrAssignment() {
-  A::a_destroyed = 0;
-  {
-    RcPtr<A> a{MakeRcPtr<A>()};
-    RcPtr<A> a1{};
-    a1 = a;
-    TEST_ASSERT(a);
-    TEST_ASSERT(a1);
-  }
-  TEST_ASSERT_EQUAL(1, A::a_destroyed);
-
-  A::a_destroyed = 0;
-  {
-    RcPtr<A> a{MakeRcPtr<A>()};
-    RcPtr<A> a1;
-    a1 = std::move(a);
-    TEST_ASSERT(!a);
-    TEST_ASSERT(a1);
-  }
-  TEST_ASSERT_EQUAL(1, A::a_destroyed);
-
-  A::a_destroyed = 0;
-  B::b_destroyed = 0;
-}
-
-void test_ptrAccess() {
-  A::a_destroyed = 0;
-  {
-    RcPtr<A> a{MakeRcPtr<A>()};
-    a->x = 1;
-    A& aref = *a;
-    aref.x = 2;
-    TEST_ASSERT(!!a);
-    TEST_ASSERT_EQUAL(a->x, (*a).x);
-  }
-  {
-    RcPtr<A> const a{MakeRcPtr<A>()};
-    a->x = 1;
-    A& aref = *a;
-    aref.x = 2;
-    TEST_ASSERT(!!a);
-    TEST_ASSERT_EQUAL(a->x, (*a).x);
-  }
-}
-
-void test_ptrLifeTime() {
-  A::a_destroyed = 0;
-  {
-    RcPtr<A> a{MakeRcPtr<A>()};
-    RcPtr<A> a1{MakeRcPtr<A>()};
-  }
-  TEST_ASSERT_EQUAL(2, A::a_destroyed);
-
-  A::a_destroyed = 0;
-  B::b_destroyed = 0;
-  {
-    // check if parent destructor is called too
-    RcPtr<B> b{MakeRcPtr<B>()};
-  }
-  TEST_ASSERT_EQUAL(1, A::a_destroyed);
-  TEST_ASSERT_EQUAL(1, B::b_destroyed);
-
-  A::a_destroyed = 0;
-  B::b_destroyed = 0;
-}
-
-void test_ptrView() {
-  {
-    RcPtrView<A> a_view{};
-    TEST_ASSERT(!a_view);
-  }
-  A::a_destroyed = 0;
-  {
-    RcPtr<A> a{MakeRcPtr<A>()};
-    RcPtrView<A> a_view{a};
-    TEST_ASSERT(!!a_view);
-    a.Reset();
-    TEST_ASSERT(!a_view);
-    TEST_ASSERT_EQUAL(1, A::a_destroyed);
-  }
-
-  A::a_destroyed = 0;
-  {
-    RcPtr<A> a{MakeRcPtr<A>()};
-    RcPtrView<A> a_view{a};
-    auto a1 = a_view.lock();
-    TEST_ASSERT(!!a1);
-    a.Reset();
-    TEST_ASSERT_EQUAL(0, A::a_destroyed);
-    a1.Reset();
-    TEST_ASSERT_EQUAL(1, A::a_destroyed);
-    auto a2 = a_view.lock();
-    TEST_ASSERT(!a2);
-  }
-
-  A::a_destroyed = 0;
-  {
-    RcPtr<A> a{MakeRcPtr<A>()};
-    std::vector<RcPtrView<A>> views;
-    for (std::size_t i = 0; i < 10; ++i) {
-      views.emplace_back(a);
-    }
-    for (auto& v : views) {
-      v.Reset();
-    }
-    TEST_ASSERT_EQUAL(0, A::a_destroyed);
-    a.Reset();
-    TEST_ASSERT_EQUAL(1, A::a_destroyed);
-  }
-  {
-    RcPtr<A> a{MakeRcPtr<A>()};
-    RcPtrView<A> a_view;
-    TEST_ASSERT(!a_view);
-    a_view = a;
-    TEST_ASSERT(!!a_view);
-    RcPtrView<A> a_view1{std::move(a_view)};
-    TEST_ASSERT(!a_view);
-    TEST_ASSERT(!!a_view1);
-    RcPtrView<A> a_view2;
-    TEST_ASSERT(!a_view2);
-    a_view2 = std::move(a_view1);
-    TEST_ASSERT(!a_view1);
-    TEST_ASSERT(!!a_view2);
-  }
-}
-
-}  // namespace ae::test_rc_ptr
-
-int test_rc_ptr() {
-  UNITY_BEGIN();
-  RUN_TEST(ae::test_rc_ptr::test_createPtr);
-  RUN_TEST(ae::test_rc_ptr::test_ptrAssignment);
-  RUN_TEST(ae::test_rc_ptr::test_ptrAccess);
-  RUN_TEST(ae::test_rc_ptr::test_ptrLifeTime);
-  RUN_TEST(ae::test_rc_ptr::test_ptrView);
-  return UNITY_END();
-}
diff --git a/tests/test-ptr/test-ref-tree.cpp b/tests/test-ptr/test-ref-tree.cpp
new file mode 100644
index 00000000..fa8c2a46
--- /dev/null
+++ b/tests/test-ptr/test-ref-tree.cpp
@@ -0,0 +1,335 @@
+/*
+ * Copyright 2025 Aethernet Inc.
+ */
+
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <unity.h>
+
+#include "aether/ptr/ref_tree.h"
+
+namespace ae::test_ref_tree {
+
+std::uintptr_t MakePointer(std::size_t offset) noexcept {
+  return static_cast<std::uintptr_t>(0x1000u + offset);
+}
+
+bool ContainsIndex(std::vector<RefTree::Index> const& values,
+                   RefTree::Index index) noexcept {
+  for (auto const value : values) {
+    if (value == index) {
+      return true;
+    }
+  }
+  return false;
+}
+
+struct MoveOnlyVisitor {
+  explicit MoveOnlyVisitor(std::vector<RefTree::Index>& visited) noexcept
+      : visited{&visited} {}
+  MoveOnlyVisitor(MoveOnlyVisitor const&) = delete;
+  MoveOnlyVisitor& operator=(MoveOnlyVisitor const&) = delete;
+  MoveOnlyVisitor(MoveOnlyVisitor&&) noexcept = default;
+  MoveOnlyVisitor& operator=(MoveOnlyVisitor&&) noexcept = default;
+  bool operator()(RefTree::Node& node) noexcept {
+    visited->push_back(node.index);
+    return true;
+  }
+  std::vector<RefTree::Index>* visited{};
+};
+
+static_assert(!std::is_copy_constructible_v<RefTree>);
+static_assert(!std::is_copy_assignable_v<RefTree>);
+static_assert(!std::is_nothrow_move_constructible_v<RefTree>);
+static_assert(!std::is_nothrow_move_assignable_v<RefTree>);
+static_assert(!noexcept(
+    std::declval<RefTree::Node&>().ForEach(std::declval<MoveOnlyVisitor&>())));
+static_assert(!noexcept(std::declval<RefTree::Node&>().IsReachable(
+    std::declval<RefTree::Index>())));
+
+void test_RefTreeEmplaceDeduplicatesAndPreservesNodeData() {
+  auto tree = RefTree{};
+  auto& first = tree.Emplace(MakePointer(0), 2);
+  auto& second = tree.Emplace(MakePointer(1), 3);
+
+  TEST_ASSERT_EQUAL_UINT16(0, first.index);
+  TEST_ASSERT_EQUAL(static_cast<std::uint64_t>(MakePointer(0)),
+                    static_cast<std::uint64_t>(first.value.pointer));
+  TEST_ASSERT_EQUAL_UINT16(2, first.value.ref_count);
+  TEST_ASSERT_EQUAL_UINT16(0, first.value.reachable_ref_count);
+  TEST_ASSERT_EQUAL_UINT16(0, first.child_count);
+
+  TEST_ASSERT_EQUAL_UINT16(1, second.index);
+  TEST_ASSERT_EQUAL(static_cast<std::uint64_t>(MakePointer(1)),
+                    static_cast<std::uint64_t>(second.value.pointer));
+  TEST_ASSERT_EQUAL_UINT16(3, second.value.ref_count);
+  TEST_ASSERT_EQUAL_UINT16(0, second.value.reachable_ref_count);
+  TEST_ASSERT_EQUAL_UINT16(0, second.child_count);
+
+  first.PushChild(second.index);
+  first.value.reachable_ref_count = 1;
+
+  auto& duplicate = tree.Emplace(MakePointer(0), 9);
+  TEST_ASSERT_EQUAL_PTR(&first, &duplicate);
+  TEST_ASSERT_EQUAL_UINT16(2, duplicate.value.ref_count);
+  TEST_ASSERT_EQUAL_UINT16(1, duplicate.value.reachable_ref_count);
+  TEST_ASSERT_EQUAL_UINT16(1, duplicate.child_count);
+
+  auto& fetched_second = tree.get(second.index);
+  TEST_ASSERT_EQUAL_PTR(&second, &fetched_second);
+}
+
+void test_RefTreeLocalArrayToVectorTransitionKeepsNodes() {
+  auto tree = RefTree{};
+  for (std::size_t i = 0; i < 33; ++i) {
+    auto& node =
+        tree.Emplace(MakePointer(i), static_cast<std::uint16_t>(i + 1));
+    TEST_ASSERT_EQUAL_UINT16(static_cast<std::uint16_t>(i), node.index);
+  }
+
+  for (std::size_t i = 0; i < 33; ++i) {
+    auto& node = tree.get(static_cast<RefTree::Index>(i));
+    TEST_ASSERT_EQUAL_UINT16(static_cast<std::uint16_t>(i), node.index);
+    TEST_ASSERT_EQUAL(static_cast<std::uint64_t>(MakePointer(i)),
+                      static_cast<std::uint64_t>(node.value.pointer));
+  }
+
+  auto& duplicate = tree.Emplace(MakePointer(5), 99);
+  TEST_ASSERT_EQUAL_UINT16(5, duplicate.index);
+  auto& unique = tree.Emplace(MakePointer(33), 34);
+  TEST_ASSERT_EQUAL_UINT16(33, unique.index);
+}
+
+void test_RefTreeForEachTraversesSimpleTreeOnce() {
+  auto tree = RefTree{};
+  auto& root = tree.Emplace(MakePointer(0), 1);
+  auto& child1 = tree.Emplace(MakePointer(1), 1);
+  auto& child2 = tree.Emplace(MakePointer(2), 1);
+  auto& grandchild = tree.Emplace(MakePointer(3), 1);
+
+  root.PushChild(child1.index);
+  root.PushChild(child2.index);
+  child1.PushChild(grandchild.index);
+
+  std::vector<RefTree::Index> visited;
+  auto result = root.ForEach([&](auto& node) {
+    visited.push_back(node.index);
+    return true;
+  });
+
+  TEST_ASSERT(result);
+  TEST_ASSERT_EQUAL_UINT32(3, visited.size());
+  TEST_ASSERT(ContainsIndex(visited, child1.index));
+  TEST_ASSERT(ContainsIndex(visited, child2.index));
+  TEST_ASSERT(ContainsIndex(visited, grandchild.index));
+  TEST_ASSERT_FALSE(ContainsIndex(visited, root.index));
+}
+
+void test_RefTreeForEachStopsInvokingCallbackAfterFalse() {
+  auto tree = RefTree{};
+  auto& root = tree.Emplace(MakePointer(0), 1);
+  auto& first = tree.Emplace(MakePointer(1), 1);
+  auto& later = tree.Emplace(MakePointer(2), 1);
+  auto& later_child = tree.Emplace(MakePointer(3), 1);
+
+  root.PushChild(first.index);
+  root.PushChild(later.index);
+  later.PushChild(later_child.index);
+
+  std::vector<RefTree::Index> visited;
+  auto result = root.ForEach([&](auto& node) {
+    visited.push_back(node.index);
+    return false;
+  });
+
+  TEST_ASSERT_FALSE(result);
+  TEST_ASSERT_EQUAL_UINT32(1, visited.size());
+  TEST_ASSERT_EQUAL_UINT16(first.index, visited[0]);
+  TEST_ASSERT_FALSE(ContainsIndex(visited, later_child.index));
+}
+
+void test_RefTreeForEachTerminatesWithCycle() {
+  auto tree = RefTree{};
+  auto& node0 = tree.Emplace(MakePointer(0), 1);
+  auto& node1 = tree.Emplace(MakePointer(1), 1);
+  auto& node2 = tree.Emplace(MakePointer(2), 1);
+
+  node0.PushChild(node1.index);
+  node1.PushChild(node2.index);
+  node2.PushChild(node1.index);
+
+  std::vector<RefTree::Index> visited;
+  auto result = node0.ForEach([&](auto& node) {
+    visited.push_back(node.index);
+    return true;
+  });
+
+  TEST_ASSERT(result);
+  TEST_ASSERT(ContainsIndex(visited, node1.index));
+  TEST_ASSERT(ContainsIndex(visited, node2.index));
+  TEST_ASSERT_FALSE(ContainsIndex(visited, node0.index));
+}
+
+void test_RefTreeForEachSkipsRootInBackEdgeCycle() {
+  auto tree = RefTree{};
+  auto& root = tree.Emplace(MakePointer(0), 1);
+  auto& child = tree.Emplace(MakePointer(1), 1);
+
+  root.PushChild(child.index);
+  child.PushChild(root.index);
+
+  std::vector<RefTree::Index> visited;
+  auto result = root.ForEach([&](auto& node) {
+    visited.push_back(node.index);
+    return true;
+  });
+
+  TEST_ASSERT(result);
+  TEST_ASSERT_EQUAL_UINT32(1, visited.size());
+  TEST_ASSERT_EQUAL_UINT16(child.index, visited[0]);
+  TEST_ASSERT_FALSE(ContainsIndex(visited, root.index));
+}
+
+void test_RefTreeForEachAcceptsMoveOnlyTemporaryCallback() {
+  auto tree = RefTree{};
+  auto& root = tree.Emplace(MakePointer(0), 1);
+  auto& child = tree.Emplace(MakePointer(1), 1);
+
+  root.PushChild(child.index);
+
+  std::vector<RefTree::Index> visited;
+  auto result = root.ForEach(MoveOnlyVisitor{visited});
+
+  // cppcheck-suppress-begin *
+  // false positive
+  TEST_ASSERT(result);
+  TEST_ASSERT_EQUAL_UINT32(1, visited.size());
+  TEST_ASSERT_EQUAL_UINT16(child.index, visited[0]);
+  // cppcheck-suppress-end *
+}
+
+void test_RefTreeForEachAcceptsMoveOnlyLValueCallback() {
+  auto tree = RefTree{};
+  auto& root = tree.Emplace(MakePointer(0), 1);
+  auto& child = tree.Emplace(MakePointer(1), 1);
+
+  root.PushChild(child.index);
+
+  std::vector<RefTree::Index> visited;
+  auto visitor = MoveOnlyVisitor{visited};
+  auto result = root.ForEach(visitor);
+
+  // cppcheck-suppress-begin *
+  // false positive
+  TEST_ASSERT(result);
+  TEST_ASSERT_EQUAL_UINT32(1, visited.size());
+  TEST_ASSERT_EQUAL_UINT16(child.index, visited[0]);
+  // cppcheck-suppress-end *
+}
+
+void test_RefTreeIsReachableHandlesTrueFalseAndCycles() {
+  auto tree = RefTree{};
+  auto& node0 = tree.Emplace(MakePointer(0), 1);
+  auto& node1 = tree.Emplace(MakePointer(1), 1);
+  auto& node2 = tree.Emplace(MakePointer(2), 1);
+  auto& node3 = tree.Emplace(MakePointer(3), 1);
+  auto& node4 = tree.Emplace(MakePointer(4), 1);
+  auto& node5 = tree.Emplace(MakePointer(5), 1);
+
+  node0.PushChild(node1.index);
+  node0.PushChild(node2.index);
+  node1.PushChild(node3.index);
+  node3.PushChild(node1.index);
+  node5.PushChild(node5.index);
+
+  TEST_ASSERT(node0.IsReachable(node3.index));
+  TEST_ASSERT(node3.IsReachable(node1.index));
+  TEST_ASSERT_FALSE(node1.IsReachable(node2.index));
+  TEST_ASSERT_FALSE(node0.IsReachable(node4.index));
+  TEST_ASSERT(node5.IsReachable(node5.index));
+  TEST_ASSERT_FALSE(node5.IsReachable(node0.index));
+}
+
+void test_RefTreeEdgeTransitionAndOrderPastLocalCapacity() {
+  auto tree = RefTree{};
+  auto const root_index = tree.Emplace(MakePointer(0), 1).index;
+  for (std::size_t i = 1; i <= 70; ++i) {
+    auto& child = tree.Emplace(MakePointer(i), 1);
+    tree.get(root_index).PushChild(child.index);
+  }
+
+  auto& root = tree.get(root_index);
+  TEST_ASSERT_EQUAL_UINT16(70, root.child_count);
+  std::vector<RefTree::Index> visited;
+  auto result = root.ForEach([&](auto& node) {
+    visited.push_back(node.index);
+    return true;
+  });
+  TEST_ASSERT(result);
+  TEST_ASSERT_EQUAL_UINT32(70, visited.size());
+  for (std::size_t i = 1; i <= 70; ++i) {
+    TEST_ASSERT_EQUAL_UINT16(static_cast<std::uint16_t>(i), visited[i - 1]);
+  }
+}
+
+void test_RefTreeDuplicateEdgesArePreserved() {
+  auto tree = RefTree{};
+  auto& root = tree.Emplace(MakePointer(0), 1);
+  auto& child = tree.Emplace(MakePointer(1), 1);
+
+  root.PushChild(child.index);
+  root.PushChild(child.index);
+
+  TEST_ASSERT_EQUAL_UINT16(2, root.child_count);
+  std::vector<RefTree::Index> visited;
+  root.ForEach([&](auto& node) {
+    visited.push_back(node.index);
+    return true;
+  });
+  TEST_ASSERT_EQUAL_UINT32(1, visited.size());
+  TEST_ASSERT_EQUAL_UINT16(child.index, visited[0]);
+}
+
+void test_RefTreeIsReachableInsideForEach() {
+  auto tree = RefTree{};
+  auto& root = tree.Emplace(MakePointer(0), 1);
+  auto& child = tree.Emplace(MakePointer(1), 1);
+  auto& grandchild = tree.Emplace(MakePointer(2), 1);
+
+  root.PushChild(child.index);
+  child.PushChild(grandchild.index);
+
+  auto result = root.ForEach([&](auto& node) {
+    TEST_ASSERT(node.IsReachable(grandchild.index) ||
+                (node.index == grandchild.index));
+    return true;
+  });
+  TEST_ASSERT(result);
+}
+}  // namespace ae::test_ref_tree
+
+int test_ref_tree() {
+  UNITY_BEGIN();
+  RUN_TEST(
+      ae::test_ref_tree::test_RefTreeEmplaceDeduplicatesAndPreservesNodeData);
+  RUN_TEST(
+      ae::test_ref_tree::test_RefTreeLocalArrayToVectorTransitionKeepsNodes);
+  RUN_TEST(ae::test_ref_tree::test_RefTreeForEachTraversesSimpleTreeOnce);
+  RUN_TEST(
+      ae::test_ref_tree::test_RefTreeForEachStopsInvokingCallbackAfterFalse);
+  RUN_TEST(ae::test_ref_tree::test_RefTreeForEachTerminatesWithCycle);
+  RUN_TEST(ae::test_ref_tree::test_RefTreeForEachSkipsRootInBackEdgeCycle);
+  RUN_TEST(
+      ae::test_ref_tree::test_RefTreeForEachAcceptsMoveOnlyTemporaryCallback);
+  RUN_TEST(ae::test_ref_tree::test_RefTreeForEachAcceptsMoveOnlyLValueCallback);
+  RUN_TEST(ae::test_ref_tree::test_RefTreeIsReachableHandlesTrueFalseAndCycles);
+  RUN_TEST(
+      ae::test_ref_tree::test_RefTreeEdgeTransitionAndOrderPastLocalCapacity);
+  RUN_TEST(ae::test_ref_tree::test_RefTreeDuplicateEdgesArePreserved);
+  RUN_TEST(ae::test_ref_tree::test_RefTreeIsReachableInsideForEach);
+  return UNITY_END();
+}
diff --git a/tests/test-ptr/test-shared-ptr-bench.cpp b/tests/test-ptr/test-shared-ptr-bench.cpp
deleted file mode 100644
index 6bea0a87..00000000
--- a/tests/test-ptr/test-shared-ptr-bench.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright 2024 Aethernet Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <unity.h>
-
-#include <vector>
-#include <memory>
-
-#include "tests/benchmarking.h"
-
-namespace ae::test_shared_ptr_bench {
-#if !defined NDEBUG
-static constexpr std::size_t kBenchCount = 10'000'000;
-#else
-static constexpr std::size_t kBenchCount = 100'000'000;
-#endif
-
-struct Rabbit {
-  explicit Rabbit(int y) : x{y * y} {}
-  ~Rabbit() { x = x - (x / 2); }
-  int x{0};
-};
-
-void test_shared_ptr_CreationBench() {
-  tests::BenchmarkFunc(
-      [](auto i) {
-        auto rabbit_ptr = std::make_shared<Rabbit>(i);
-        rabbit_ptr->x += static_cast<int>(i) % 100;
-        rabbit_ptr.reset();
-      },
-      kBenchCount, "create and destroy");
-
-  std::vector<std::shared_ptr<Rabbit>> rabbits1;
-  rabbits1.reserve(1000);
-  tests::BenchmarkFunc(
-      [&](auto i) {
-        for (auto j = 0; j < rabbits1.capacity(); j++) {
-          rabbits1.push_back(std::make_shared<Rabbit>(i + j));
-          rabbits1.back()->x += static_cast<int>(i) % 100;
-        }
-        rabbits1.clear();
-      },
-      kBenchCount / rabbits1.capacity(), "create a bunch size ",
-      rabbits1.capacity(), " and destroy all after");
-}
-
-std::vector<std::shared_ptr<Rabbit>> rabbits2;
-void test_shared_ptr_CopyingBench() {
-  tests::BenchmarkFunc(
-      [&](auto i) {
-        rabbits2.push_back(std::make_shared<Rabbit>(i % 1000));
-
-        if (((i + 1) % 10'000) == 0) {
-          rabbits2.clear();
-          rabbits2.shrink_to_fit();
-        }
-      },
-      kBenchCount, "moving inside the vector while it grows max ", 10'000,
-      " elements");
-
-  std::vector<std::shared_ptr<Rabbit>> rabbits3;
-  rabbits3.reserve(1000);
-  for (std::size_t j = 0; j < rabbits3.capacity(); j++) {
-    rabbits3.push_back(std::make_shared<Rabbit>(j));
-  }
-  tests::BenchmarkFunc(
-      [&](auto i) {
-        auto copy_rabbits = rabbits3;
-        for (auto const& r : copy_rabbits) {
-          r->x += i % 100;
-        }
-      },
-      kBenchCount / 100, "copying the vector size: ", rabbits3.capacity());
-}
-
-}  // namespace ae::test_shared_ptr_bench
-
-int test_shared_ptr_bench() {
-  UNITY_BEGIN();
-  RUN_TEST(ae::test_shared_ptr_bench::test_shared_ptr_CreationBench);
-  RUN_TEST(ae::test_shared_ptr_bench::test_shared_ptr_CopyingBench);
-  return UNITY_END();
-}
diff --git a/tests/test-safe-stream/mock_bad_streams.h b/tests/test-safe-stream/mock_bad_streams.h
index c4ac3d96..1b1abe36 100644
--- a/tests/test-safe-stream/mock_bad_streams.h
+++ b/tests/test-safe-stream/mock_bad_streams.h
@@ -17,10 +17,11 @@
 #ifndef TESTS_TEST_STREAM_MOCK_BAD_STREAMS_H_
 #define TESTS_TEST_STREAM_MOCK_BAD_STREAMS_H_
 
-#include <queue>
 #include <optional>
+#include <queue>
 
 #include "aether/ae_context.h"
+#include "aether/clock.h"
 #include "aether/stream_api/istream.h"
 
 namespace ae {
diff --git a/tests/test-serial-port/test-at-request.cpp b/tests/test-serial-port/test-at-request.cpp
index 90147d77..44a609d2 100644
--- a/tests/test-serial-port/test-at-request.cpp
+++ b/tests/test-serial-port/test-at-request.cpp
@@ -16,15 +16,16 @@
 
 #include <unity.h>
 
-#include <string>
-#include <iterator>
 #include <algorithm>
+#include <iterator>
+#include <string>
 
+#include "aether/clock.h"
 #include "aether/executors/executors.h"
 #include "aether/tasks/manual_task_scheduler.h"
 
-#include "aether/serial_ports/at_support/at_support.h"
 #include "aether/serial_ports/at_support/at_request.h"
+#include "aether/serial_ports/at_support/at_support.h"
 
 #include "tests/test-serial-port/mock-serial-port.h"
 
diff --git a/tests/test-serial-port/test-at-stages.cpp b/tests/test-serial-port/test-at-stages.cpp
index 02356ec9..069226d4 100644
--- a/tests/test-serial-port/test-at-stages.cpp
+++ b/tests/test-serial-port/test-at-stages.cpp
@@ -16,10 +16,11 @@
 
 #include <unity.h>
 
-#include "aether/ae_context.h"
 #include "aether/actions/actions_queue.h"
-#include "aether/serial_ports/at_support/at_stage.h"
+#include "aether/ae_context.h"
+#include "aether/clock.h"
 #include "aether/serial_ports/at_support/at_request.h"
+#include "aether/serial_ports/at_support/at_stage.h"
 #include "aether/serial_ports/at_support/at_support.h"
 
 #include "tests/test-serial-port/mock-serial-port.h"
@@ -149,7 +150,6 @@ void test_RunMultipleStagesWithWait() {
   TEST_ASSERT_FALSE(executed1);
   TEST_ASSERT_FALSE(pre_executed2);
 
-
   std::string_view ok_line{"OK\r\n"};
   mock_serial.WriteOut(std::span<std::uint8_t const>{
       reinterpret_cast<std::uint8_t const*>(ok_line.data()), ok_line.size()});
diff --git a/tools/registrator/registrator.cpp b/tools/registrator/registrator.cpp
index 31dabe83..f00d4c81 100644
--- a/tools/registrator/registrator.cpp
+++ b/tools/registrator/registrator.cpp
@@ -163,7 +163,7 @@ int AetherRegistrator(const std::string& ini_file,
   }
 
   auto registrator_action = ae::reg::RegistratorAction{
-      ae::AeContext{*aether_app}, aether_app, registrator_config.clients()};
+      ae::AeContext{*aether_app}, *aether_app, registrator_config.clients()};
 
   registrator_action.registered_event().Subscribe([&](auto const& clients) {
     constexpr auto format_client = ae::FormatScheme{"\nclient={},\n{}\n"};
diff --git a/tools/registrator/registrator_action.cpp b/tools/registrator/registrator_action.cpp
index b5643558..333e645f 100644
--- a/tools/registrator/registrator_action.cpp
+++ b/tools/registrator/registrator_action.cpp
@@ -16,17 +16,15 @@
 
 #include "registrator/registrator_action.h"
 
-#include "aether/actions/action_context.h"
-
 #include "aether/registration/registration.h"
 
 namespace ae::reg {
 RegistratorAction::RegistratorAction(
-    ae::AeContext const& ae_context, RcPtr<AetherApp> const& aether_app,
+    ae::AeContext const& ae_context, ae::AetherApp& aether_app,
     std::vector<reg::ClientConfig> const& client_configs)
     : ae_context_{ae_context} {
   AE_TELED_INFO("RegistratorAction");
-  RegisterClients(aether_app->aether(), client_configs);
+  RegisterClients(aether_app.aether(), client_configs);
 }
 
 RegistratorAction::RegisteredEvent::Subscriber
diff --git a/tools/registrator/registrator_action.h b/tools/registrator/registrator_action.h
index 57b0a90f..be17fe8e 100644
--- a/tools/registrator/registrator_action.h
+++ b/tools/registrator/registrator_action.h
@@ -17,15 +17,14 @@
 #ifndef TOOLS_REGISTRATOR_REGISTRATOR_ACTION_H_
 #define TOOLS_REGISTRATOR_REGISTRATOR_ACTION_H_
 
-#include <vector>
 #include <string>
-#include <cstdint>
+#include <vector>
 
+#include "aether/actions/action.h"
 #include "aether/aether.h"
 #include "aether/aether_app.h"
 #include "aether/events/events.h"
 #include "aether/events/multi_subscription.h"
-#include "aether/actions/action.h"
 
 #include "registrator/registrator_config.h"
 
@@ -41,7 +40,7 @@ class RegistratorAction : public Action {
   using FailedEvent = Event<void()>;
 
   explicit RegistratorAction(
-      ae::AeContext const& ae_context, RcPtr<ae::AetherApp> const& aether_app,
+      ae::AeContext const& ae_context, ae::AetherApp& aether_app,
       std::vector<reg::ClientConfig> const& client_configs);
 
   RegisteredEvent::Subscriber registered_event();