world.h

#pragma once
#include "gaia/config/config.h"
 
#include <cstdarg>
#include <cstdint>
#include <type_traits>
 
#include "gaia/cnt/darray.h"
#include "gaia/cnt/darray_ext.h"
#include "gaia/cnt/map.h"
#include "gaia/cnt/sarray_ext.h"
#include "gaia/cnt/set.h"
#include "gaia/config/profiler.h"
#include "gaia/core/hashing_policy.h"
#include "gaia/core/hashing_string.h"
#include "gaia/core/span.h"
#include "gaia/core/string.h"
#include "gaia/core/utility.h"
#include "gaia/ecs/api.h"
#include "gaia/ecs/archetype.h"
#include "gaia/ecs/archetype_common.h"
#include "gaia/ecs/archetype_graph.h"
#include "gaia/ecs/chunk.h"
#include "gaia/ecs/chunk_allocator.h"
#include "gaia/ecs/command_buffer_fwd.h"
#include "gaia/ecs/common.h"
#include "gaia/ecs/component.h"
#include "gaia/ecs/component_cache.h"
#include "gaia/ecs/component_cache_item.h"
#include "gaia/ecs/component_getter.h"
#include "gaia/ecs/component_setter.h"
#include "gaia/ecs/entity_container.h"
#include "gaia/ecs/id.h"
#include "gaia/ecs/query.h"
#include "gaia/ecs/query_cache.h"
#include "gaia/ecs/query_common.h"
#include "gaia/ecs/query_info.h"
#include "gaia/ecs/ser_binary.h"
#include "gaia/mem/mem_alloc.h"
#include "gaia/ser/ser_rt.h"
#include "gaia/util/logging.h"
 
namespace gaia {
  namespace ecs {
    class SystemBuilder;
    class World;
 
    class GAIA_API World final {
      friend class ECSSystem;
      friend class ECSSystemManager;
      friend CommandBufferST;
      friend CommandBufferMT;
      friend void lock(World&);
      friend void unlock(World&);
 
      BinarySerializer m_binarySerializer;
      ser::ISerializer* m_pSerializer{};
 
      using TFunc_Void_With_Entity = void(Entity);
      static void func_void_with_entity([[maybe_unused]] Entity entity) {}
 
      using EntityNameLookupKey = core::StringLookupKey<256>;
      using PairMap = cnt::map<EntityLookupKey, cnt::set<EntityLookupKey>>;
 
      ComponentCache m_compCache;
      QueryCache m_queryCache;
      QuerySerMap m_querySerMap;
      uint32_t m_nextQuerySerId = 0;
 
      EntityToArchetypeMap m_entityToArchetypeMap;
      PairMap m_entityToAsTargets;
      PairMap m_entityToAsRelations;
      PairMap m_relationsToTargets;
      PairMap m_targetsToRelations;
 
      ArchetypeDArray m_archetypes;
      ArchetypeMapByHash m_archetypesByHash;
      ArchetypeMapById m_archetypesById;
 
      Archetype* m_pRootArchetype = nullptr;
      Archetype* m_pEntityArchetype = nullptr;
      Archetype* m_pCompArchetype = nullptr;
      ArchetypeId m_nextArchetypeId = 0;
 
      EntityContainers m_recs;
 
      cnt::map<EntityNameLookupKey, Entity> m_nameToEntity;
 
      cnt::set<ArchetypeLookupKey> m_reqArchetypesToDel;
      cnt::set<EntityLookupKey> m_reqEntitiesToDel;
 
      CommandBufferST* m_pCmdBufferST;
      CommandBufferMT* m_pCmdBufferMT;
      ecs::Query m_systemsQuery;
 
      cnt::set<EntityLookupKey> m_entitiesToDel;
      cnt::darray<ArchetypeChunkPair> m_chunksToDel;
      ArchetypeDArray m_archetypesToDel;
      uint32_t m_defragLastArchetypeIdx = 0;
      uint32_t m_defragEntitiesPerTick = 100;
 
      uint32_t m_worldVersion = 0;
 
      uint32_t m_structuralChangesLocked = 0;
 
    public:
      World():
          // Command buffer for the main thread
          m_pCmdBufferST(cmd_buffer_st_create(*this)),
          // Command buffer safe for concurrent access
          m_pCmdBufferMT(cmd_buffer_mt_create(*this)) {
        init();
      }
 
      ~World() {
        done();
        cmd_buffer_destroy(*m_pCmdBufferST);
        cmd_buffer_destroy(*m_pCmdBufferMT);
      }
 
      World(World&&) = delete;
      World(const World&) = delete;
      World& operator=(World&&) = delete;
      World& operator=(const World&) = delete;
 
      //----------------------------------------------------------------------
 
      template <bool UseCache = true>
      auto query() {
        if constexpr (UseCache) {
          Query q(
              *const_cast<World*>(this), m_queryCache,
              //
              m_nextArchetypeId, m_worldVersion, m_archetypesById, m_entityToArchetypeMap, m_archetypes);
          return q;
        } else {
          QueryUncached q(
              *const_cast<World*>(this),
              //
              m_nextArchetypeId, m_worldVersion, m_archetypesById, m_entityToArchetypeMap, m_archetypes);
          return q;
        }
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD EntityContainer& fetch(Entity entity) {
        // Valid entity
        GAIA_ASSERT(valid(entity));
        // Wildcard pairs are not a real entity so we can't accept them
        GAIA_ASSERT(!entity.pair() || !is_wildcard(entity));
        return m_recs[entity];
      }
 
      GAIA_NODISCARD const EntityContainer& fetch(Entity entity) const {
        // Valid entity
        GAIA_ASSERT(valid(entity));
        // Wildcard pairs are not a real entity so we can't accept them
        GAIA_ASSERT(!entity.pair() || !is_wildcard(entity));
        return m_recs[entity];
      }
 
      GAIA_NODISCARD static bool is_req_del(const EntityContainer& ec) {
        if ((ec.flags & EntityContainerFlags::DeleteRequested) != 0)
          return true;
        if (ec.pArchetype != nullptr && ec.pArchetype->is_req_del())
          return true;
 
        return false;
      }
 
      //----------------------------------------------------------------------
 
      void set_serializer(ser::ISerializer* pSerializer) {
        if (pSerializer == nullptr) {
          // Always use the binary serializer as the default
          m_pSerializer = &m_binarySerializer;
          return;
        }
 
        m_pSerializer = pSerializer;
      }
 
      ser::ISerializer* get_serializer() const {
        return m_pSerializer;
      }
 
      //----------------------------------------------------------------------
 
      struct EntityBuilder final {
        friend class World;
 
        World& m_world;
        Archetype* m_pArchetypeSrc;
        Chunk* m_pChunkSrc;
        uint32_t m_rowSrc;
        Archetype* m_pArchetype;
        EntityNameLookupKey m_targetNameKey;
        Entity m_entity;
 
        cnt::sarray_ext<Entity, 32> tl_new_comps;
        cnt::sarray_ext<Entity, 32> tl_del_comps;
 
        EntityBuilder(World& world, Entity entity, EntityContainer& ec):
            m_world(world), m_pArchetypeSrc(ec.pArchetype), m_pChunkSrc(ec.pChunk), m_rowSrc(ec.row),
            m_pArchetype(ec.pArchetype), m_entity(entity) {
          // Make sure entity matches the provided entity container record
          GAIA_ASSERT(ec.pChunk->entity_view()[ec.row] == entity);
        }
 
        EntityBuilder(World& world, Entity entity): m_world(world), m_entity(entity) {
          const auto& ec = world.fetch(entity);
          m_pArchetypeSrc = ec.pArchetype;
          m_pChunkSrc = ec.pChunk;
          m_rowSrc = ec.row;
 
          m_pArchetype = ec.pArchetype;
        }
 
        EntityBuilder(const EntityBuilder&) = default;
        EntityBuilder(EntityBuilder&&) = delete;
        EntityBuilder& operator=(const EntityBuilder&) = delete;
        EntityBuilder& operator=(EntityBuilder&&) = delete;
 
        ~EntityBuilder() {
          commit();
        }
 
        void commit() {
          // No requests to change the archetype were made
          if (m_pArchetype == nullptr)
            return;
 
          // Change in archetype detected
          if (m_pArchetypeSrc != m_pArchetype) {
            auto& ec = m_world.fetch(m_entity);
            GAIA_ASSERT(ec.pArchetype == m_pArchetypeSrc);
 
            // Trigger remove hooks if there are any
            trigger_del_hooks();
 
            // Now that we have the final archetype move the entity to it
            m_world.move_entity_raw(m_entity, ec, *m_pArchetype);
 
            // Update the entity string pointer if necessary
            if (m_targetNameKey.str() != nullptr) {
              const auto compIdx = ec.pChunk->comp_idx(GAIA_ID(EntityDesc));
              // No need to update version, entity move did it already.
              auto* pDesc = reinterpret_cast<EntityDesc*>(ec.pChunk->comp_ptr_mut_gen<false>(compIdx, ec.row));
              GAIA_ASSERT(core::check_alignment(pDesc));
              *pDesc = {m_targetNameKey.str(), m_targetNameKey.len()};
            }
 
            // Trigger add hooks if there are any
            trigger_add_hooks();
 
            m_pArchetypeSrc = ec.pArchetype;
            m_pChunkSrc = ec.pChunk;
            m_rowSrc = ec.row;
          }
          // Archetype is still the same. Make sure no chunk movement has happened.
          else {
#if GAIA_ASSERT_ENABLED
            auto& ec = m_world.fetch(m_entity);
            GAIA_ASSERT(ec.pChunk == m_pChunkSrc);
#endif
 
            // Update the entity string pointer if necessary
            if (m_targetNameKey.str() != nullptr) {
              const auto compIdx = m_pChunkSrc->comp_idx(GAIA_ID(EntityDesc));
              auto* pDesc = reinterpret_cast<EntityDesc*>(m_pChunkSrc->comp_ptr_mut_gen<true>(compIdx, m_rowSrc));
              GAIA_ASSERT(core::check_alignment(pDesc));
              *pDesc = {m_targetNameKey.str(), m_targetNameKey.len()};
            }
          }
 
          // Finalize the builder by reseting the archetype pointer
          m_pArchetype = nullptr;
          m_targetNameKey = {};
        }
 
        void name(const char* name, uint32_t len = 0) {
          name_inter<true>(name, len);
        }
 
        void name_raw(const char* name, uint32_t len = 0) {
          name_inter<false>(name, len);
        }
 
        void del_name() {
          if (m_entity.pair())
            return;
 
          const auto compIdx = core::get_index(m_pArchetypeSrc->ids_view(), GAIA_ID(EntityDesc));
          if (compIdx == BadIndex)
            return;
 
          {
            const auto* pDesc = reinterpret_cast<const EntityDesc*>(m_pChunkSrc->comp_ptr(compIdx, m_rowSrc));
            GAIA_ASSERT(core::check_alignment(pDesc));
            if (pDesc->name == nullptr)
              return;
          }
 
          // No need to update version, commit() will do it
          auto* pDesc = reinterpret_cast<EntityDesc*>(m_pChunkSrc->comp_ptr_mut_gen<false>(compIdx, m_rowSrc));
          del_inter(EntityNameLookupKey(pDesc->name, pDesc->len, 0));
 
          del_inter(GAIA_ID(EntityDesc));
          m_targetNameKey = {};
        }
 
        EntityBuilder& add(Entity entity) {
          GAIA_PROF_SCOPE(EntityBuilder::add);
          GAIA_ASSERT(m_world.valid(m_entity));
          GAIA_ASSERT(m_world.valid(entity));
 
          add_inter(entity);
          return *this;
        }
 
        EntityBuilder& add(Pair pair) {
          GAIA_PROF_SCOPE(EntityBuilder::add);
          GAIA_ASSERT(m_world.valid(m_entity));
          GAIA_ASSERT(m_world.valid(pair.first()));
          GAIA_ASSERT(m_world.valid(pair.second()));
 
          add_inter(pair);
          return *this;
        }
 
        EntityBuilder& as(Entity entityBase) {
          return add(Pair(Is, entityBase));
        }
 
        GAIA_NODISCARD bool as(Entity entity, Entity entityBase) const {
          return static_cast<const World&>(m_world).is(entity, entityBase);
        }
 
        EntityBuilder& child(Entity parent) {
          return add(Pair(ChildOf, parent));
        }
 
        template <typename T>
        Entity register_component() {
          if constexpr (is_pair<T>::value) {
            const auto rel = m_world.add<typename T::rel>().entity;
            const auto tgt = m_world.add<typename T::tgt>().entity;
            const Entity ent = Pair(rel, tgt);
            add_inter(ent);
            return ent;
          } else {
            return m_world.add<T>().entity;
          }
        }
 
#if GAIA_USE_VARIADIC_API
        template <typename... T>
        EntityBuilder& add() {
          (verify_comp<T>(), ...);
          (add(register_component<T>()), ...);
          return *this;
        }
#else
        template <typename T>
        EntityBuilder& add() {
          verify_comp<T>();
          add(register_component<T>());
          return *this;
        }
#endif
 
        EntityBuilder& del(Entity entity) {
          GAIA_PROF_SCOPE(EntityBuilder::del);
          GAIA_ASSERT(m_world.valid(m_entity));
          GAIA_ASSERT(m_world.valid(entity));
          del_inter(entity);
          return *this;
        }
 
        EntityBuilder& del(Pair pair) {
          GAIA_PROF_SCOPE(EntityBuilder::add);
          GAIA_ASSERT(m_world.valid(m_entity));
          GAIA_ASSERT(m_world.valid(pair.first()));
          GAIA_ASSERT(m_world.valid(pair.second()));
          del_inter(pair);
          return *this;
        }
 
#if GAIA_USE_VARIADIC_API
        template <typename... T>
        EntityBuilder& del() {
          (verify_comp<T>(), ...);
          (del(register_component<T>()), ...);
          return *this;
        }
#else
        template <typename T>
        EntityBuilder& del() {
          verify_comp<T>();
          del(register_component<T>());
          return *this;
        }
#endif
 
      private:
        void trigger_add_hooks() {
#if GAIA_ENABLE_ADD_DEL_HOOKS
          m_world.lock();
 
          for (auto entity: tl_new_comps) {
            const auto& item = m_world.comp_cache().get(entity);
            const auto& hooks = ComponentCache::hooks(item);
            if (hooks.func_add != nullptr)
              hooks.func_add(m_world, item, m_entity);
          }
          tl_new_comps.clear();
 
          m_world.unlock();
#endif
        }
 
        void trigger_del_hooks() {
#if GAIA_ENABLE_ADD_DEL_HOOKS
          m_world.lock();
 
          for (auto entity: tl_del_comps) {
            const auto& item = m_world.comp_cache().get(entity);
            const auto& hooks = ComponentCache::hooks(item);
            if (hooks.func_del != nullptr)
              hooks.func_del(m_world, item, m_entity);
          }
          tl_del_comps.clear();
 
          m_world.unlock();
#endif
        }
 
        bool handle_add_entity(Entity entity) {
          cnt::sarray_ext<Entity, ChunkHeader::MAX_COMPONENTS> targets;
 
          const auto& ecMain = m_world.fetch(entity);
 
          // Handle entity combinations that can't be together
          if ((ecMain.flags & EntityContainerFlags::HasCantCombine) != 0) {
            m_world.targets(entity, CantCombine, [&targets](Entity target) {
              targets.push_back(target);
            });
            for (auto e: targets) {
              if (m_pArchetype->has(e)) {
#if GAIA_ASSERT_ENABLED
                GAIA_ASSERT2(false, "Trying to add an entity which can't be combined with the source");
                print_archetype_entities(m_world, *m_pArchetype, entity, true);
#endif
                return false;
              }
            }
          }
 
          // Handle exclusivity
          if (entity.pair()) {
            // Check if (rel, tgt)'s rel part is exclusive
            const auto& ecRel = m_world.m_recs.entities[entity.id()];
            if ((ecRel.flags & EntityContainerFlags::IsExclusive) != 0) {
              auto rel = Entity(
                  entity.id(), ecRel.data.gen, (bool)ecRel.data.ent, (bool)ecRel.data.pair,
                  (EntityKind)ecRel.data.kind);
              auto tgt = m_world.get(entity.gen());
 
              // Make sure to remove the (rel, tgt0) so only the new (rel, tgt1) remains.
              // However, before that we need to make sure there only exists one target at most.
              targets.clear();
              m_world.targets_if(m_entity, rel, [&targets](Entity target) {
                targets.push_back(target);
                // Stop the moment we have more than 1 target. This kind of scenario is not supported
                // and can happen only if Exclusive is added after multiple relationships already exist.
                return targets.size() < 2;
              });
 
              const auto targetsCnt = targets.size();
              if (targetsCnt > 1) {
#if GAIA_ASSERT_ENABLED
                GAIA_ASSERT2(
                    false, "Trying to add a pair with exclusive relationship but there are multiple targets present. "
                           "Make sure to add the Exclusive property before any relationships with it are created.");
                print_archetype_entities(m_world, *m_pArchetype, entity, true);
#endif
                return false;
              }
 
              // Remove the previous relationship if possible.
              // We avoid self-removal.
              const auto tgtNew = *targets.begin();
              if (targetsCnt == 1 && tgt != tgtNew) {
                // Exclusive relationship replaces the previous one.
                // We need to check if the old one can be removed.
                // This is what del_inter does on the inside.
                // It first checks if entity can be deleted and calls handle_del afterwards.
                if (!can_del(entity)) {
#if GAIA_ASSERT_ENABLED
                  GAIA_ASSERT2(
                      false, "Trying to replace an exclusive relationship but the entity which is getting removed has "
                             "dependencies.");
                  print_archetype_entities(m_world, *m_pArchetype, entity, true);
#endif
                  return false;
                }
 
                handle_del(ecs::Pair(rel, tgtNew));
              }
            }
          }
 
          // Handle requirements
          {
            targets.clear();
            m_world.targets(entity, Requires, [&targets](Entity target) {
              targets.push_back(target);
            });
 
            for (auto e: targets) {
              auto* pArchetype = m_pArchetype;
              handle_add<false>(e);
              if (m_pArchetype != pArchetype)
                handle_add_entity(e);
            }
          }
 
          return true;
        }
 
        GAIA_NODISCARD bool has_Requires_tgt(Entity entity) const {
          // Don't allow to delete entity if something in the archetype requires it
          auto ids = m_pArchetype->ids_view();
          for (auto e: ids) {
            if (m_world.has(e, Pair(Requires, entity)))
              return true;
          }
 
          return false;
        }
 
        static void set_flag(EntityContainerFlagsType& flags, EntityContainerFlags flag, bool enable) {
          if (enable)
            flags |= flag;
          else
            flags &= ~flag;
        }
 
        void set_flag(Entity entity, EntityContainerFlags flag, bool enable) {
          auto& ec = m_world.fetch(entity);
          set_flag(ec.flags, flag, enable);
        }
 
        void try_set_flags(Entity entity, bool enable) {
          auto& ecMain = m_world.fetch(m_entity);
          try_set_CantCombine(ecMain, entity, enable);
 
          auto& ec = m_world.fetch(entity);
          try_set_Is(ec, entity, enable);
          try_set_IsExclusive(ecMain, entity, enable);
          try_set_IsSingleton(ecMain, entity, enable);
          try_set_OnDelete(ecMain, entity, enable);
          try_set_OnDeleteTarget(entity, enable);
        }
 
        void try_set_Is(EntityContainer& ec, Entity entity, bool enable) {
          if (!entity.pair() || entity.id() != Is.id())
            return;
 
          set_flag(ec.flags, EntityContainerFlags::HasAliasOf, enable);
        }
 
        void try_set_CantCombine(EntityContainer& ec, Entity entity, bool enable) {
          if (!entity.pair() || entity.id() != CantCombine.id())
            return;
 
          GAIA_ASSERT(entity != m_entity);
 
          // Setting the flag can be done right away.
          // One bit can only contain information about one pair but there
          // can be any amount of CanCombine pairs formed with an entity.
          // Therefore, when resetting the flag, we first need to check if there
          // are any other targets with this flag set and only reset the flag
          // if there is only one present.
          if (enable)
            set_flag(ec.flags, EntityContainerFlags::HasCantCombine, true);
          else if ((ec.flags & EntityContainerFlags::HasCantCombine) != 0) {
            uint32_t targets = 0;
            m_world.targets(m_entity, CantCombine, [&targets]([[maybe_unused]] Entity entity) {
              ++targets;
            });
            if (targets == 1)
              set_flag(ec.flags, EntityContainerFlags::HasCantCombine, false);
          }
        }
 
        void try_set_IsExclusive(EntityContainer& ec, Entity entity, bool enable) {
          if (entity.pair() || entity.id() != Exclusive.id())
            return;
 
          set_flag(ec.flags, EntityContainerFlags::IsExclusive, enable);
        }
 
        void try_set_OnDeleteTarget(Entity entity, bool enable) {
          if (!entity.pair())
            return;
 
          const auto rel = m_world.get(entity.id());
          const auto tgt = m_world.get(entity.gen());
 
          // Adding a pair to an entity with OnDeleteTarget relationship.
          // We need to update the target entity's flags.
          if (m_world.has(rel, Pair(OnDeleteTarget, Delete)))
            set_flag(tgt, EntityContainerFlags::OnDeleteTarget_Delete, enable);
          else if (m_world.has(rel, Pair(OnDeleteTarget, Remove)))
            set_flag(tgt, EntityContainerFlags::OnDeleteTarget_Remove, enable);
          else if (m_world.has(rel, Pair(OnDeleteTarget, Error)))
            set_flag(tgt, EntityContainerFlags::OnDeleteTarget_Error, enable);
        }
 
        void try_set_OnDelete(EntityContainer& ec, Entity entity, bool enable) {
          if (entity == Pair(OnDelete, Delete))
            set_flag(ec.flags, EntityContainerFlags::OnDelete_Delete, enable);
          else if (entity == Pair(OnDelete, Remove))
            set_flag(ec.flags, EntityContainerFlags::OnDelete_Remove, enable);
          else if (entity == Pair(OnDelete, Error))
            set_flag(ec.flags, EntityContainerFlags::OnDelete_Error, enable);
        }
 
        void try_set_IsSingleton(EntityContainer& ec, Entity entity, bool enable) {
          const bool isSingleton = enable && m_entity == entity;
          set_flag(ec.flags, EntityContainerFlags::IsSingleton, isSingleton);
        }
 
        void handle_DependsOn(Entity entity, bool enable) {
          (void)entity;
          (void)enable;
          // auto& ec = m_world.fetch(entity);
          // if (enable) {
          //  // Calculate the depth in the dependency tree
          //  uint32_t depth = 1;
 
          //  auto e = entity;
          //  if (m_world.valid(e)) {
          //    while (true) {
          //      auto tgt = m_world.target(e, DependsOn);
          //      if (tgt == EntityBad)
          //        break;
 
          //      ++depth;
          //      e = tgt;
          //    }
          //  }
          //  ec.depthDependsOn = (uint8_t)depth;
 
          //  // Update depth for all entities depending on this one
          //  auto q = m_world.query<false>();
          //  q.all(ecs::Pair(DependsOn, m_entity)) //
          //      .each([&](Entity dependingEntity) {
          //        auto& ecDependingEntity = m_world.fetch(dependingEntity);
          //        ecDependingEntity.depthDependsOn += (uint8_t)depth;
          //      });
          // } else {
          //  // Update depth for all entities depending on this one
          //  auto q = m_world.query<false>();
          //  q.all(ecs::Pair(DependsOn, m_entity)) //
          //      .each([&](Entity dependingEntity) {
          //        auto& ecDependingEntity = m_world.fetch(dependingEntity);
          //        ecDependingEntity.depthDependsOn -= ec.depthDependsOn;
          //      });
 
          //  // Reset the depth
          //  ec.depthDependsOn = 0;
          // }
        }
 
        template <bool IsBootstrap>
        bool handle_add(Entity entity) {
#if GAIA_ASSERT_ENABLED
          World::verify_add(m_world, *m_pArchetype, m_entity, entity);
#endif
 
          // Don't add the same entity twice
          if (m_pArchetype->has(entity))
            return false;
 
          try_set_flags(entity, true);
 
          // Update the Is relationship base counter if necessary
          if (entity.pair() && entity.id() == Is.id()) {
            auto e = m_world.get(entity.gen());
 
            EntityLookupKey entityKey(m_entity);
            EntityLookupKey eKey(e);
 
            // m_entity -> {..., e}
            auto& entity_to_e = m_world.m_entityToAsTargets[entityKey];
            entity_to_e.insert(eKey);
            // e -> {..., m_entity}
            auto& e_to_entity = m_world.m_entityToAsRelations[eKey];
            e_to_entity.insert(entityKey);
 
            // Make sure the relation entity is registered as archetype so queries can find it
            // auto& ec = m_world.fetch(tgt);
            // m_world.add_entity_archetype_pair(m_entity, ec.pArchetype);
 
            // Cached queries might need to be invalidated.
            m_world.invalidate_queries_for_entity({Is, e});
          }
 
          m_pArchetype = m_world.foc_archetype_add(m_pArchetype, entity);
 
          if constexpr (!IsBootstrap) {
            handle_DependsOn(entity, true);
            if (entity.comp())
              tl_new_comps.push_back(entity);
          }
 
          return true;
        }
 
        void handle_del(Entity entity) {
#if GAIA_ASSERT_ENABLED
          World::verify_del(m_world, *m_pArchetype, m_entity, entity);
#endif
 
          // Don't delete what has not beed added
          if (!m_pArchetype->has(entity))
            return;
 
          try_set_flags(entity, false);
          handle_DependsOn(entity, false);
 
          // Update the Is relationship base counter if necessary
          if (entity.pair() && entity.id() == Is.id()) {
            auto e = m_world.get(entity.gen());
 
            EntityLookupKey entityKey(m_entity);
            EntityLookupKey eKey(e);
 
            // Cached queries might need to be invalidated.
            m_world.invalidate_queries_for_entity({Is, e});
 
            // m_entity -> {..., e}
            {
              const auto it = m_world.m_entityToAsTargets.find(entityKey);
              GAIA_ASSERT(it != m_world.m_entityToAsTargets.end());
              auto& set = it->second;
              GAIA_ASSERT(!set.empty());
              set.erase(eKey);
 
              // Remove the record if it is not referenced anymore
              if (set.empty())
                m_world.m_entityToAsTargets.erase(it);
            }
 
            // e -> {..., m_entity}
            {
              const auto it = m_world.m_entityToAsRelations.find(eKey);
              GAIA_ASSERT(it != m_world.m_entityToAsRelations.end());
              auto& set = it->second;
              GAIA_ASSERT(!set.empty());
              set.erase(entityKey);
 
              // Remove the record if it is not referenced anymore
              if (set.empty())
                m_world.m_entityToAsRelations.erase(it);
            }
          }
 
          m_pArchetype = m_world.foc_archetype_del(m_pArchetype, entity);
 
          if (entity.comp())
            tl_del_comps.push_back(entity);
        }
 
        void add_inter(Entity entity) {
          GAIA_ASSERT(!is_wildcard(entity));
 
          if (entity.pair()) {
            // Make sure the entity container record exists if it is a pair
            m_world.assign_pair(entity, *m_world.m_pEntityArchetype);
          }
 
          if (!handle_add_entity(entity))
            return;
 
          handle_add<false>(entity);
        }
 
        void add_inter_init(Entity entity) {
          GAIA_ASSERT(!is_wildcard(entity));
 
          if (entity.pair()) {
            // Make sure the entity container record exists if it is a pair
            m_world.assign_pair(entity, *m_world.m_pEntityArchetype);
          }
 
          if (!handle_add_entity(entity))
            return;
 
          handle_add<true>(entity);
        }
 
        GAIA_NODISCARD bool can_del(Entity entity) const noexcept {
          if (has_Requires_tgt(entity))
            return false;
 
          return true;
        }
 
        bool del_inter(Entity entity) {
          if (!can_del(entity))
            return false;
 
          handle_del(entity);
          return true;
        }
 
        void del_inter(EntityNameLookupKey key) {
          const auto it = m_world.m_nameToEntity.find(key);
          // If the assert is hit it means the pointer to the name string was invalidated or became dangling.
          // That should not be possible for strings managed internally so the only other option is user-managed
          // strings are broken.
          GAIA_ASSERT(it != m_world.m_nameToEntity.end());
          if (it != m_world.m_nameToEntity.end()) {
            // Release memory allocated for the string if we own it
            if (it->first.owned())
              mem::mem_free((void*)key.str());
 
            m_world.m_nameToEntity.erase(it);
          }
        }
 
        template <bool IsOwned>
        void name_inter(const char* name, uint32_t len) {
          GAIA_ASSERT(!m_entity.pair());
          if (m_entity.pair())
            return;
 
          // When nullptr is passed for the name it means the user wants to delete the current name
          if (name == nullptr) {
            GAIA_ASSERT(len == 0);
            del_name();
            return;
          }
 
          GAIA_ASSERT(len < ComponentCacheItem::MaxNameLength);
 
          // Make sure the name does not contain a dot because this character is reserved for
          // hierarchical lookups, e.g. "parent.child.subchild".
#if GAIA_ASSERT_ENABLED
          GAIA_FOR(len) {
            const bool hasInvalidCharacter = name[i] == '.';
            GAIA_ASSERT(!hasInvalidCharacter && "Character '.' can't be used in entity names");
            if (hasInvalidCharacter)
              return;
          }
#endif
 
          EntityNameLookupKey key(
              name, len == 0 ? (uint32_t)GAIA_STRLEN(name, ComponentCacheItem::MaxNameLength) : len, IsOwned);
 
          // Make sure the name is unique. Ignore setting the same name twice on the same entity.
          // If it is not, there is nothing to do.
          auto it = m_world.m_nameToEntity.find(key);
          if (it == m_world.m_nameToEntity.end()) {
            // If we already had some name, remove the pair from the map first.
            if (m_targetNameKey.str() != nullptr) {
              del_inter(m_targetNameKey);
            } else {
              const auto compIdx = core::get_index(m_pArchetypeSrc->ids_view(), GAIA_ID(EntityDesc));
              if (compIdx != BadIndex) {
                auto* pDesc = reinterpret_cast<EntityDesc*>(m_pChunkSrc->comp_ptr_mut(compIdx, m_rowSrc));
                GAIA_ASSERT(core::check_alignment(pDesc));
                if (pDesc->name != nullptr) {
                  del_inter(EntityNameLookupKey(pDesc->name, pDesc->len, 0));
                  pDesc->name = nullptr;
                }
              } else {
                // Make sure EntityDesc is added to the entity.
                add_inter(GAIA_ID(EntityDesc));
              }
            }
 
            // Insert the new pair
            it = m_world.m_nameToEntity.emplace(key, m_entity).first;
          } else {
#if GAIA_ASSERT_ENABLED
            if (it->second != m_entity)
              GAIA_ASSERT(false && "Trying to set non-unique name for an entity");
#endif
 
            // Attempts to set the same name again, or not a unique name, will be dropped.
            return;
          }
 
          if constexpr (IsOwned) {
            // Allocate enough storage for the name
            char* entityStr = (char*)mem::mem_alloc(key.len() + 1);
            memcpy((void*)entityStr, (const void*)name, key.len() + 1);
            entityStr[key.len()] = 0;
 
            m_targetNameKey = EntityNameLookupKey(entityStr, key.len(), 1, {key.hash()});
 
            // Update the map so it points to the newly allocated string.
            // We replace the pointer we provided in try_emplace with an internally allocated string.
            auto p = robin_hood::pair(std::make_pair(m_targetNameKey, m_entity));
            it->swap(p);
          } else {
            m_targetNameKey = key;
 
            // We tell the map the string is non-owned.
            auto p = robin_hood::pair(std::make_pair(key, m_entity));
            it->swap(p);
          }
        }
      };
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD ComponentCache& comp_cache_mut() {
        return m_compCache;
      }
      GAIA_NODISCARD const ComponentCache& comp_cache() const {
        return m_compCache;
      }
 
      GAIA_NODISCARD QuerySerMap& query_ser_map() {
        return m_querySerMap;
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD bool valid(Entity entity) const {
        return entity.pair() //
                   ? valid_pair(entity)
                   : valid_entity(entity);
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD Entity get(EntityId id) const {
        GAIA_ASSERT(valid_entity_id(id));
 
        const auto& ec = m_recs.entities[id];
        return Entity(id, ec.data.gen, (bool)ec.data.ent, (bool)ec.data.pair, (EntityKind)ec.data.kind);
      }
 
      template <typename T>
      GAIA_NODISCARD Entity get() const {
        static_assert(!is_pair<T>::value, "Pairs can't be registered as components");
 
        using CT = component_type_t<T>;
        using FT = typename CT::TypeFull;
 
        const auto* pItem = comp_cache().find<FT>();
        GAIA_ASSERT(pItem != nullptr);
        return pItem->entity;
      }
 
      //----------------------------------------------------------------------
 
      EntityBuilder build(Entity entity) {
        return EntityBuilder(*this, entity);
      }
 
      GAIA_NODISCARD Entity add(EntityKind kind = EntityKind::EK_Gen) {
        return add(*m_pEntityArchetype, true, false, kind);
      }
 
      template <typename Func = TFunc_Void_With_Entity>
      void add_n(uint32_t count, Func func = func_void_with_entity) {
        add_entity_n(*m_pEntityArchetype, count, func);
      }
 
      template <typename Func = TFunc_Void_With_Entity>
      void add_n(Entity entity, uint32_t count, Func func = func_void_with_entity) {
        auto& ec = m_recs.entities[entity.id()];
 
        GAIA_ASSERT(ec.pArchetype != nullptr);
        GAIA_ASSERT(ec.pChunk != nullptr);
 
        add_entity_n(*ec.pArchetype, count, func);
      }
 
      template <typename T>
      GAIA_NODISCARD const ComponentCacheItem& add() {
        static_assert(!is_pair<T>::value, "Pairs can't be registered as components");
 
        using CT = component_type_t<T>;
        using FT = typename CT::TypeFull;
        constexpr auto kind = CT::Kind;
 
        const auto* pItem = comp_cache().find<FT>();
        if (pItem != nullptr)
          return *pItem;
 
        const auto entity = add(*m_pCompArchetype, false, false, kind);
 
        const auto& item = comp_cache_mut().add<FT>(entity);
        sset<Component>(item.entity) = item.comp;
 
        // Make sure the default component entity name points to the cache item name.
        // The name is deleted when the component cache item is deleted.
        name_raw(item.entity, item.name.str(), item.name.len());
 
        return item;
      }
 
      void add(Entity entity, Entity object) {
        EntityBuilder(*this, entity).add(object);
      }
 
      void add(Entity entity, Pair pair) {
        EntityBuilder(*this, entity).add(pair);
      }
 
      template <typename T>
      void add(Entity entity) {
        EntityBuilder(*this, entity).add<T>();
      }
 
      template <typename T>
      void add(Entity entity, Entity object, T&& value) {
        static_assert(core::is_raw_v<T>);
 
        EntityBuilder(*this, entity).add(object);
 
        const auto& ec = fetch(entity);
        // Make sure the idx is 0 for unique entities
        const auto idx = uint16_t(ec.row * (1U - (uint32_t)object.kind()));
        ComponentSetter{{ec.pChunk, idx}}.set(object, GAIA_FWD(value));
      }
 
      template <typename T, typename U = typename actual_type_t<T>::Type>
      void add(Entity entity, U&& value) {
        EntityBuilder builder(*this, entity);
        auto object = builder.register_component<T>();
        builder.add(object);
        builder.commit();
 
        const auto& ec = m_recs.entities[entity.id()];
        // Make sure the idx is 0 for unique entities
        const auto idx = uint16_t(ec.row * (1U - (uint32_t)object.kind()));
        ComponentSetter{{ec.pChunk, idx}}.set<T>(GAIA_FWD(value));
      }
 
      //----------------------------------------------------------------------
 
      void clear(Entity entity) {
        GAIA_ASSERT(!entity.pair());
        GAIA_ASSERT(valid(entity));
 
        EntityBuilder eb(*this, entity);
 
        // Remove back to front because it's better for the archetype graph
        auto ids = eb.m_pArchetype->ids_view();
        for (uint32_t i = (uint32_t)ids.size() - 1; i != (uint32_t)-1; --i)
          eb.del(ids[i]);
 
        eb.commit();
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD Entity copy(Entity srcEntity) {
        GAIA_ASSERT(!srcEntity.pair());
        GAIA_ASSERT(valid(srcEntity));
 
        auto& ec = m_recs.entities[srcEntity.id()];
        GAIA_ASSERT(ec.pArchetype != nullptr);
        GAIA_ASSERT(ec.pChunk != nullptr);
 
        auto* pDstArchetype = ec.pArchetype;
 
        // Names have to be unique so if we see that EntityDesc is present during copy
        // we navigate towards a version of the archetype without the EntityDesc.
        if (pDstArchetype->has<EntityDesc>()) {
          pDstArchetype = foc_archetype_del(pDstArchetype, GAIA_ID(EntityDesc));
 
          const auto dstEntity = add(*pDstArchetype, srcEntity.entity(), srcEntity.pair(), srcEntity.kind());
          auto& ecDst = m_recs.entities[dstEntity.id()];
 
          Chunk::copy_foreign_entity_data(ec.pChunk, ec.row, ecDst.pChunk, ecDst.row);
          return dstEntity;
        }
 
        // No description associated with the entity, direct copy is possible
        const auto dstEntity = add(*pDstArchetype, srcEntity.entity(), srcEntity.pair(), srcEntity.kind());
        Chunk::copy_entity_data(srcEntity, dstEntity, m_recs);
        return dstEntity;
      }
 
      template <typename Func = TFunc_Void_With_Entity>
      void copy_n(Entity entity, uint32_t count, Func func = func_void_with_entity) {
        GAIA_ASSERT(!entity.pair());
        GAIA_ASSERT(valid(entity));
 
        auto& ec = m_recs.entities[entity.id()];
 
        GAIA_ASSERT(ec.pChunk != nullptr);
        GAIA_ASSERT(ec.pArchetype != nullptr);
 
        auto* pSrcChunk = ec.pChunk;
 
        auto* pDstArchetype = ec.pArchetype;
        if (pDstArchetype->has<EntityDesc>()) {
          pDstArchetype = foc_archetype_del(pDstArchetype, GAIA_ID(EntityDesc));
 
          // Entities array might get reallocated after m_recs.entities.alloc
          // so instead of fetching the container again we simply cache the row
          // of our source entity.
          const auto srcRow = ec.row;
 
          EntityContainerCtx ctx{true, false, EntityKind::EK_Gen};
 
          uint32_t left = count;
          do {
            auto* pDstChunk = pDstArchetype->foc_free_chunk();
            const uint32_t originalChunkSize = pDstChunk->size();
            const uint32_t freeSlotsInChunk = pDstChunk->capacity() - originalChunkSize;
            const uint32_t toCreate = core::get_min(freeSlotsInChunk, left);
 
            GAIA_FOR(toCreate) {
              const auto entityNew = m_recs.entities.alloc(&ctx);
              auto& ecNew = m_recs.entities[entityNew.id()];
              store_entity(ecNew, entityNew, pDstArchetype, pDstChunk);
 
#if GAIA_ASSERT_ENABLED
              GAIA_ASSERT(ecNew.pChunk == pDstChunk);
              auto entityExpected = pDstChunk->entity_view()[ecNew.row];
              GAIA_ASSERT(entityExpected == entityNew);
#endif
 
              Chunk::copy_foreign_entity_data(pSrcChunk, srcRow, pDstChunk, ecNew.row);
            }
 
            // Call functors
            if constexpr (std::is_invocable_v<Func, CopyIter&>) {
              CopyIter it;
              it.set_world(this);
              it.set_archetype(pDstArchetype);
              it.set_chunk(pDstChunk);
              it.set_range((uint16_t)originalChunkSize, (uint16_t)toCreate);
              func(it);
            } else {
              auto entities = pDstChunk->entity_view();
              GAIA_FOR2(originalChunkSize, pDstChunk->size()) func(entities[i]);
            }
 
            pDstChunk->update_versions();
 
            left -= toCreate;
          } while (left > 0);
        } else {
          pDstArchetype = ec.pArchetype;
 
          // Entities array might get reallocated after m_recs.entities.alloc
          // so instead of fetching the container again we simply cache the row
          // of our source entity.
          const auto srcRow = ec.row;
 
          EntityContainerCtx ctx{true, false, EntityKind::EK_Gen};
 
          uint32_t left = count;
          do {
            auto* pDstChunk = pDstArchetype->foc_free_chunk();
            const uint32_t originalChunkSize = pDstChunk->size();
            const uint32_t freeSlotsInChunk = pDstChunk->capacity() - originalChunkSize;
            const uint32_t toCreate = core::get_min(freeSlotsInChunk, left);
 
            GAIA_FOR(toCreate) {
              const auto entityNew = m_recs.entities.alloc(&ctx);
              auto& ecNew = m_recs.entities[entityNew.id()];
              store_entity(ecNew, entityNew, pDstArchetype, pDstChunk);
 
#if GAIA_ASSERT_ENABLED
              GAIA_ASSERT(ecNew.pChunk == pDstChunk);
              auto entityExpected = pDstChunk->entity_view()[ecNew.row];
              GAIA_ASSERT(entityExpected == entityNew);
#endif
            }
 
            // New entities were added, try updating the free chunk index
            pDstArchetype->try_update_free_chunk_idx();
 
            // Call constructors for the generic components on the newly added entity if necessary
            pDstChunk->call_gen_ctors(originalChunkSize, toCreate);
 
            // Copy data
            {
              GAIA_PROF_SCOPE(World::copy_n_entity_data);
 
              auto srcRecs = pSrcChunk->comp_rec_view();
 
              // Copy generic component data from reference entity to our new entity
              GAIA_FOR(pSrcChunk->size_generic()) {
                const auto& rec = srcRecs[i];
                if (rec.comp.size() == 0U)
                  continue;
 
                const auto* pSrc = (const void*)pSrcChunk->comp_ptr(i);
                GAIA_FOR_(toCreate, rowOffset) {
                  auto* pDst = (void*)pDstChunk->comp_ptr_mut(i);
                  rec.pItem->copy(
                      pDst, pSrc, originalChunkSize + rowOffset, srcRow, pDstChunk->capacity(), pSrcChunk->capacity());
                }
              }
            }
 
            // Call functors
            if constexpr (std::is_invocable_v<Func, CopyIter&>) {
              CopyIter it;
              it.set_world(this);
              it.set_archetype(pDstArchetype);
              it.set_chunk(pDstChunk);
              it.set_range((uint16_t)originalChunkSize, (uint16_t)toCreate);
              func(it);
            } else {
              auto entities = pDstChunk->entity_view();
              GAIA_FOR2(originalChunkSize, pDstChunk->size()) func(entities[i]);
            }
 
            pDstChunk->update_versions();
 
            left -= toCreate;
          } while (left > 0);
        }
      }
 
      //----------------------------------------------------------------------
 
      void del(Entity entity) {
        if (!entity.pair()) {
          // Delete all relationships associated with this entity (if any)
          del_inter(Pair(entity, All));
          del_inter(Pair(All, entity));
        }
 
        del_inter(entity);
      }
 
      void del(Entity entity, Entity object) {
        EntityBuilder(*this, entity).del(object);
      }
 
      void del(Entity entity, Pair pair) {
        EntityBuilder(*this, entity).del(pair);
      }
 
      template <typename T>
      void del(Entity entity) {
        using CT = component_type_t<T>;
        using FT = typename CT::TypeFull;
        EntityBuilder(*this, entity).del<FT>();
      }
 
      //----------------------------------------------------------------------
 
      void as(Entity entity, Entity entityBase) {
        // Make sure entityBase has an archetype of its own
        add(entityBase, entityBase);
        // Form the relationship
        add(entity, Pair(Is, entityBase));
      }
 
      GAIA_NODISCARD bool is(Entity entity, Entity entityBase) const {
        return is_inter<false>(entity, entityBase);
      }
 
      GAIA_NODISCARD bool in(Entity entity, Entity entityBase) const {
        return is_inter<true>(entity, entityBase);
      }
 
      GAIA_NODISCARD bool is_base(Entity target) const {
        GAIA_ASSERT(valid_entity(target));
 
        // Pairs are not supported
        if (target.pair())
          return false;
 
        const auto it = m_entityToAsRelations.find(EntityLookupKey(target));
        return it != m_entityToAsRelations.end();
      }
 
      //----------------------------------------------------------------------
 
      void child(Entity entity, Entity parent) {
        add(entity, Pair(ChildOf, parent));
      }
 
      GAIA_NODISCARD bool child(Entity entity, Entity parent) const {
        return has(entity, Pair(ChildOf, parent));
      }
 
      //----------------------------------------------------------------------
 
      template <
          typename T
#if GAIA_ENABLE_HOOKS
          ,
          bool TriggerHooks
#endif
          >
      void modify(Entity entity) {
        GAIA_ASSERT(valid(entity));
 
        auto& ec = m_recs.entities[entity.id()];
        ec.pChunk->template modify<
            T
#if GAIA_ENABLE_HOOKS
            ,
            TriggerHooks
#endif
            >();
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD ComponentSetter acc_mut(Entity entity) {
        GAIA_ASSERT(valid(entity));
 
        const auto& ec = m_recs.entities[entity.id()];
        return ComponentSetter{{ec.pChunk, ec.row}};
      }
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) set(Entity entity) {
        static_assert(!is_pair<T>::value);
        return acc_mut(entity).mut<T>();
      }
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) sset(Entity entity) {
        static_assert(!is_pair<T>::value);
        return acc_mut(entity).smut<T>();
      }
 
      //----------------------------------------------------------------------
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) mut(Entity entity) {
        static_assert(!is_pair<T>::value);
        return acc_mut(entity).mut<T>();
      }
 
      //----------------------------------------------------------------------
 
      ComponentGetter acc(Entity entity) const {
        GAIA_ASSERT(valid(entity));
 
        const auto& ec = m_recs.entities[entity.id()];
        return ComponentGetter{ec.pChunk, ec.row};
      }
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) get(Entity entity) const {
        return acc(entity).get<T>();
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD bool has(Entity entity) const {
        // Pair
        if (entity.pair()) {
          if (entity == Pair(All, All))
            return true;
 
          if (is_wildcard(entity)) {
            if (!m_entityToArchetypeMap.contains(EntityLookupKey(entity)))
              return false;
 
            // If the pair is found, both entities forming it need to be found as well
            GAIA_ASSERT(has(get(entity.id())) && has(get(entity.gen())));
 
            return true;
          }
 
          const auto it = m_recs.pairs.find(EntityLookupKey(entity));
          if (it == m_recs.pairs.end())
            return false;
 
          const auto& ec = it->second;
          if (is_req_del(ec))
            return false;
 
#if GAIA_ASSERT_ENABLED
          // If the pair is found, both entities forming it need to be found as well
          GAIA_ASSERT(has(get(entity.id())) && has(get(entity.gen())));
 
          // Index of the entity must fit inside the chunk
          auto* pChunk = ec.pChunk;
          GAIA_ASSERT(pChunk != nullptr && ec.row < pChunk->size());
#endif
 
          return true;
        }
 
        // Regular entity
        {
          // Entity ID has to fit inside the entity array
          if (entity.id() >= m_recs.entities.size())
            return false;
 
          // Index of the entity must fit inside the chunk
          const auto& ec = m_recs.entities[entity.id()];
          if (is_req_del(ec))
            return false;
 
          auto* pChunk = ec.pChunk;
          return pChunk != nullptr && ec.row < pChunk->size();
        }
      }
 
      GAIA_NODISCARD bool has(Pair pair) const {
        return has((Entity)pair);
      }
 
      GAIA_NODISCARD bool has(Entity entity, Entity object) const {
        const auto& ec = fetch(entity);
        if (is_req_del(ec))
          return false;
 
        const auto* pArchetype = ec.pArchetype;
 
        if (object.pair()) {
          // Early exit if there are no pairs on the archetype
          if (pArchetype->pairs() == 0)
            return false;
 
          EntityId rel = object.id();
          EntityId tgt = object.gen();
 
          // (*,*)
          if (rel == All.id() && tgt == All.id())
            return true;
 
          // (X,*)
          if (rel != All.id() && tgt == All.id()) {
            auto ids = pArchetype->ids_view();
            for (auto id: ids) {
              if (!id.pair())
                continue;
              if (id.id() == rel)
                return true;
            }
 
            return false;
          }
 
          // (*,X)
          if (rel == All.id() && tgt != All.id()) {
            auto ids = pArchetype->ids_view();
            for (auto id: ids) {
              if (!id.pair())
                continue;
              if (id.gen() == tgt)
                return true;
            }
 
            return false;
          }
        }
 
        return pArchetype->has(object);
      }
 
      GAIA_NODISCARD bool has(Entity entity, Pair pair) const {
        return has(entity, (Entity)pair);
      }
 
      template <typename T>
      GAIA_NODISCARD bool has(Entity entity) const {
        GAIA_ASSERT(valid(entity));
 
        const auto& ec = m_recs.entities[entity.id()];
        if (is_req_del(ec))
          return false;
 
        return ec.pArchetype->has<T>();
      }
 
      //----------------------------------------------------------------------
 
      void name(Entity entity, const char* name, uint32_t len = 0) {
        EntityBuilder(*this, entity).name(name, len);
      }
 
      void name_raw(Entity entity, const char* name, uint32_t len = 0) {
        EntityBuilder(*this, entity).name_raw(name, len);
      }
 
      GAIA_NODISCARD const char* name(Entity entity) const {
        if (entity.pair())
          return nullptr;
 
        const auto& ec = m_recs.entities[entity.id()];
        const auto compIdx = core::get_index(ec.pChunk->ids_view(), GAIA_ID(EntityDesc));
        if (compIdx == BadIndex) {
          // If no EntityDesc is assigned it is still possible to extract a name from
          // the entity. Components always come with a compile-time string associated
          // with them.
          if (!entity.entity())
            return m_compCache.get(entity).name.str();
 
          return nullptr;
        }
 
        const auto* pDesc = reinterpret_cast<const EntityDesc*>(ec.pChunk->comp_ptr(compIdx, ec.row));
        GAIA_ASSERT(core::check_alignment(pDesc));
        return pDesc->name;
      }
 
      GAIA_NODISCARD const char* name(EntityId entityId) const {
        auto entity = get(entityId);
        return name(entity);
      }
 
      GAIA_NODISCARD Entity get(const char* name, uint32_t len = 0) const {
        if (name == nullptr || name[0] == 0)
          return EntityBad;
 
        Entity parent = EntityBad;
        Entity child = EntityBad;
        uint32_t posDot = 0;
 
        // If no length was given, we have to find it ourselves
        if (len == 0) {
          while (name[len] != '\0')
            ++len;
        }
        std::span<const char> str(name, len);
 
        // Localize a dot in the string. If not present, use the entire string.
        {
          posDot = core::get_index(str, '.');
          if (posDot == BadIndex)
            return name_to_entity(str);
 
          if (posDot == 0)
            return EntityBad;
 
          parent = name_to_entity(str.subspan(0, posDot));
          if (parent == EntityBad)
            return EntityBad;
        }
 
        str = str.subspan(posDot + 1);
        while (!str.empty()) {
          posDot = core::get_index(str, '.');
 
          // A) No more dots in the string, use the entire substring.
          if (posDot == BadIndex) {
            child = name_to_entity(str);
 
            // If the entity is not found, there is nothing for us to do anymore.
            // If the parent-child relationship does not exist there is nothing for us to do anymore.
            if (child == EntityBad || !this->child(child, parent))
              return EntityBad;
 
            return child;
          }
 
          if (posDot == 0)
            return EntityBad;
 
          // B) More dots in the string
          child = name_to_entity(str.subspan(0, posDot));
 
          // If the entity is not found, there is nothing for us to do anymore.
          // If the parent-child relationship does not exist there is nothing for us to do anymore.
          if (child == EntityBad || !this->child(child, parent))
            return EntityBad;
 
          // Current child becomes the parent for the next step
          parent = child;
 
          str = str.subspan(posDot + 1);
        }
 
        return parent;
      }
 
      GAIA_NODISCARD Entity get_inter(const char* name, uint32_t len = 0) const {
        if (name == nullptr || name[0] == 0)
          return EntityBad;
 
        auto key = EntityNameLookupKey(name, len, 0);
 
        const auto it = m_nameToEntity.find(key);
        if (it != m_nameToEntity.end())
          return it->second;
 
        // Name not found. This might be a component so check the component cache
        const auto* pItem = m_compCache.find(name, len);
        if (pItem != nullptr)
          return pItem->entity;
 
        // No entity with the given name exists. Return a bad entity
        return EntityBad;
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD const cnt::set<EntityLookupKey>* relations(Entity target) const {
        const auto it = m_targetsToRelations.find(EntityLookupKey(target));
        if (it == m_targetsToRelations.end())
          return nullptr;
 
        return &it->second;
      }
 
      GAIA_NODISCARD Entity relation(Entity entity, Entity target) const {
        GAIA_ASSERT(valid(entity));
        if (!valid(target))
          return EntityBad;
 
        const auto& ec = fetch(entity);
        const auto* pArchetype = ec.pArchetype;
 
        // Early exit if there are no pairs on the archetype
        if (pArchetype->pairs() == 0)
          return EntityBad;
 
        auto ids = pArchetype->ids_view();
        for (auto e: ids) {
          if (!e.pair())
            continue;
          if (e.gen() != target.id())
            continue;
 
          const auto& ecRel = m_recs.entities[e.id()];
          auto relation = ecRel.pChunk->entity_view()[ecRel.row];
          return relation;
        }
 
        return EntityBad;
      }
 
      template <typename Func>
      void relations(Entity entity, Entity target, Func func) const {
        GAIA_ASSERT(valid(entity));
        if (!valid(target))
          return;
 
        const auto& ec = fetch(entity);
        const auto* pArchetype = ec.pArchetype;
 
        // Early exit if there are no pairs on the archetype
        if (pArchetype->pairs() == 0)
          return;
 
        auto ids = pArchetype->ids_view();
        for (auto e: ids) {
          if (!e.pair())
            continue;
          if (e.gen() != target.id())
            continue;
 
          const auto& ecRel = m_recs.entities[e.id()];
          auto relation = ecRel.pChunk->entity_view()[ecRel.row];
          func(relation);
        }
      }
 
      template <typename Func>
      void relations_if(Entity entity, Entity target, Func func) const {
        GAIA_ASSERT(valid(entity));
        if (!valid(target))
          return;
 
        const auto& ec = fetch(entity);
        const auto* pArchetype = ec.pArchetype;
 
        // Early exit if there are no pairs on the archetype
        if (pArchetype->pairs() == 0)
          return;
 
        auto ids = pArchetype->ids_view();
        for (auto e: ids) {
          if (!e.pair())
            continue;
          if (e.gen() != target.id())
            continue;
 
          const auto& ecRel = m_recs.entities[e.id()];
          auto relation = ecRel.pChunk->entity_view()[ecRel.row];
          if (!func(relation))
            return;
        }
      }
 
      template <typename Func>
      void as_relations_trav(Entity target, Func func) const {
        GAIA_ASSERT(valid(target));
        if (!valid(target))
          return;
 
        const auto it = m_entityToAsRelations.find(EntityLookupKey(target));
        if (it == m_entityToAsRelations.end())
          return;
 
        const auto& set = it->second;
        for (auto relation: set) {
          func(relation.entity());
          as_relations_trav(relation.entity(), func);
        }
      }
 
      template <typename Func>
      GAIA_NODISCARD bool as_relations_trav_if(Entity target, Func func) const {
        GAIA_ASSERT(valid(target));
        if (!valid(target))
          return false;
 
        const auto it = m_entityToAsRelations.find(EntityLookupKey(target));
        if (it == m_entityToAsRelations.end())
          return false;
 
        const auto& set = it->second;
        for (auto relation: set) {
          if (func(relation.entity()))
            return true;
          if (as_relations_trav_if(relation.entity(), func))
            return true;
        }
 
        return false;
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD const cnt::set<EntityLookupKey>* targets(Entity relation) const {
        const auto it = m_relationsToTargets.find(EntityLookupKey(relation));
        if (it == m_relationsToTargets.end())
          return nullptr;
 
        return &it->second;
      }
 
      GAIA_NODISCARD Entity target(Entity entity, Entity relation) const {
        GAIA_ASSERT(valid(entity));
        if (!valid(relation))
          return EntityBad;
 
        const auto& ec = fetch(entity);
        const auto* pArchetype = ec.pArchetype;
 
        // Early exit if there are no pairs on the archetype
        if (pArchetype->pairs() == 0)
          return EntityBad;
 
        auto ids = pArchetype->ids_view();
        for (auto e: ids) {
          if (!e.pair())
            continue;
          if (e.id() != relation.id())
            continue;
 
          const auto& ecTarget = m_recs.entities[e.gen()];
          auto target = ecTarget.pChunk->entity_view()[ecTarget.row];
          return target;
        }
 
        return EntityBad;
      }
 
      template <typename Func>
      void targets(Entity entity, Entity relation, Func func) const {
        GAIA_ASSERT(valid(entity));
        if (!valid(relation))
          return;
 
        const auto& ec = fetch(entity);
        const auto* pArchetype = ec.pArchetype;
 
        // Early exit if there are no pairs on the archetype
        if (pArchetype->pairs() == 0)
          return;
 
        auto ids = pArchetype->ids_view();
        for (auto e: ids) {
          if (!e.pair())
            continue;
          if (e.id() != relation.id())
            continue;
 
          const auto& ecTarget = m_recs.entities[e.gen()];
          auto target = ecTarget.pChunk->entity_view()[ecTarget.row];
          func(target);
        }
      }
 
      template <typename Func>
      void targets_if(Entity entity, Entity relation, Func func) const {
        GAIA_ASSERT(valid(entity));
        if (!valid(relation))
          return;
 
        const auto& ec = fetch(entity);
        const auto* pArchetype = ec.pArchetype;
 
        // Early exit if there are no pairs on the archetype
        if (pArchetype->pairs() == 0)
          return;
 
        auto ids = pArchetype->ids_view();
        for (auto e: ids) {
          if (!e.pair())
            continue;
          if (e.id() != relation.id())
            continue;
 
          const auto& ecTarget = m_recs.entities[e.gen()];
          auto target = ecTarget.pChunk->entity_view()[ecTarget.row];
          if (!func(target))
            return;
        }
      }
 
      template <typename Func>
      void as_targets_trav(Entity relation, Func func) const {
        GAIA_ASSERT(valid(relation));
        if (!valid(relation))
          return;
 
        const auto it = m_entityToAsTargets.find(EntityLookupKey(relation));
        if (it == m_entityToAsTargets.end())
          return;
 
        const auto& set = it->second;
        for (auto target: set) {
          func(target.entity());
          as_targets_trav(target.entity(), func);
        }
      }
 
      template <typename Func>
      bool as_targets_trav_if(Entity relation, Func func) const {
        GAIA_ASSERT(valid(relation));
        if (!valid(relation))
          return false;
 
        const auto it = m_entityToAsTargets.find(EntityLookupKey(relation));
        if (it == m_entityToAsTargets.end())
          return false;
 
        const auto& set = it->second;
        for (auto target: set) {
          if (func(target.entity()))
            return true;
          if (as_targets_trav(target.entity(), func))
            return true;
        }
 
        return false;
      }
 
      //----------------------------------------------------------------------
 
      CommandBufferST& cmd_buffer_st() const {
        return *m_pCmdBufferST;
      }
 
      CommandBufferMT& cmd_buffer_mt() const {
        return *m_pCmdBufferMT;
      }
 
      //----------------------------------------------------------------------
 
#if GAIA_SYSTEMS_ENABLED
 
      void systems_init();
 
      void systems_run();
 
      SystemBuilder system();
 
#endif
 
      //----------------------------------------------------------------------
 
      void enable(Entity entity, bool enable) {
        GAIA_ASSERT(valid(entity));
 
        auto& ec = m_recs.entities[entity.id()];
        auto& archetype = *ec.pArchetype;
#if GAIA_ASSERT_ENABLED
        verify_enable(*this, archetype, entity);
#endif
        archetype.enable_entity(ec.pChunk, ec.row, enable, m_recs);
      }
 
      GAIA_NODISCARD bool enabled(Entity entity) const {
        GAIA_ASSERT(valid(entity));
 
        const auto& ec = m_recs.entities[entity.id()];
        const bool entityStateInContainer = !ec.data.dis;
#if GAIA_ASSERT_ENABLED
        const bool entityStateInChunk = ec.pChunk->enabled(ec.row);
        GAIA_ASSERT(entityStateInChunk == entityStateInContainer);
#endif
        return entityStateInContainer;
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD Chunk* get_chunk(Entity entity) const {
        GAIA_ASSERT(entity.id() < m_recs.entities.size());
        const auto& ec = m_recs.entities[entity.id()];
        return ec.pChunk;
      }
 
      GAIA_NODISCARD Chunk* get_chunk(Entity entity, uint32_t& row) const {
        GAIA_ASSERT(entity.id() < m_recs.entities.size());
        const auto& ec = m_recs.entities[entity.id()];
        row = ec.row;
        return ec.pChunk;
      }
 
      GAIA_NODISCARD uint32_t size() const {
        return m_recs.entities.item_count();
      }
 
      GAIA_NODISCARD uint32_t& world_version() {
        return m_worldVersion;
      }
 
      void set_max_lifespan(Entity entity, uint32_t lifespan = Archetype::MAX_ARCHETYPE_LIFESPAN) {
        if (!valid(entity))
          return;
 
        auto& ec = fetch(entity);
        const auto prevLifespan = ec.pArchetype->max_lifespan();
        ec.pArchetype->set_max_lifespan(lifespan);
 
        if (prevLifespan == 0) {
          // The archetype used to be immortal but not anymore
          try_enqueue_archetype_for_deletion(*ec.pArchetype);
        }
      }
 
      //----------------------------------------------------------------------
 
      void update() {
        systems_run();
 
        // Finish deleting entities
        del_finalize();
 
        // Run garbage collector
        gc();
 
        util::log_flush();
 
        // Signal the end of the frame
        GAIA_PROF_FRAME();
      }
 
      void cleanup() {
        cleanup_inter();
 
        // Reinit
        m_pRootArchetype = nullptr;
        m_pEntityArchetype = nullptr;
        m_pCompArchetype = nullptr;
        m_nextArchetypeId = 0;
        m_defragLastArchetypeIdx = 0;
        m_worldVersion = 0;
        init();
      }
 
      void defrag_entities_per_tick(uint32_t value) {
        m_defragEntitiesPerTick = value;
      }
 
      //--------------------------------------------------------------------------------
 
      void diag_archetypes() const {
        GAIA_LOG_N("Archetypes:%u", (uint32_t)m_archetypes.size());
        for (auto* pArchetype: m_archetypes)
          Archetype::diag(*this, *pArchetype);
      }
 
      void diag_components() const {
        comp_cache().diag();
      }
 
      void diag_entities() const {
        validate_entities();
 
        GAIA_LOG_N("Deleted entities: %u", (uint32_t)m_recs.entities.get_free_items());
        if (m_recs.entities.get_free_items() != 0U) {
          GAIA_LOG_N("  --> %u", (uint32_t)m_recs.entities.get_next_free_item());
 
          uint32_t iters = 0;
          auto fe = m_recs.entities[m_recs.entities.get_next_free_item()].idx;
          while (fe != IdentifierIdBad) {
            GAIA_LOG_N("  --> %u", m_recs.entities[fe].idx);
            fe = m_recs.entities[fe].idx;
            ++iters;
            if (iters > m_recs.entities.get_free_items())
              break;
          }
 
          if ((iters == 0U) || iters > m_recs.entities.get_free_items())
            GAIA_LOG_E("  Entities recycle list contains inconsistent data!");
        }
      }
 
      void diag() const {
        diag_archetypes();
        diag_components();
        diag_entities();
      }
 
    private:
      void cleanup_inter() {
        GAIA_PROF_SCOPE(World::cleanup_inter);
 
        // Clear entities
        m_recs.entities = {};
        m_recs.pairs = {};
 
        // Clear archetypes
        {
          // Delete all allocated chunks and their parent archetypes
          for (auto* pArchetype: m_archetypes)
            Archetype::destroy(pArchetype);
 
          m_entityToAsRelations = {};
          m_entityToAsTargets = {};
          m_targetsToRelations = {};
          m_relationsToTargets = {};
 
          m_archetypes = {};
          m_archetypesById = {};
          m_archetypesByHash = {};
 
          m_reqArchetypesToDel = {};
          m_reqEntitiesToDel = {};
 
          m_entitiesToDel = {};
          m_chunksToDel = {};
          m_archetypesToDel = {};
        }
 
        // Clear caches
        {
          m_entityToArchetypeMap = {};
          m_queryCache.clear();
        }
 
        // Clear entity names
        {
          for (auto& pair: m_nameToEntity) {
            if (!pair.first.owned())
              continue;
            // Release any memory allocated for owned names
            mem::mem_free((void*)pair.first.str());
          }
          m_nameToEntity = {};
        }
 
        // Clear component cache
        m_compCache.clear();
      }
 
      GAIA_NODISCARD static bool valid(const EntityContainer& ec, [[maybe_unused]] Entity entityExpected) {
        if (is_req_del(ec))
          return false;
 
        // The entity in the chunk must match the index in the entity container
        auto* pChunk = ec.pChunk;
        if (pChunk == nullptr || ec.row >= pChunk->size())
          return false;
 
#if GAIA_ASSERT_ENABLED
        const auto entityPresent = ec.pChunk->entity_view()[ec.row];
        GAIA_ASSERT(entityExpected == entityPresent);
        if (entityExpected != entityPresent)
          return false;
#endif
 
        return true;
      }
 
      GAIA_NODISCARD bool valid_pair(Entity entity) const {
        if (entity == EntityBad)
          return false;
 
        GAIA_ASSERT(entity.pair());
        if (!entity.pair())
          return false;
 
        // Ignore wildcards because they can't be attached to entities
        if (is_wildcard(entity))
          return true;
 
        const auto it = m_recs.pairs.find(EntityLookupKey(entity));
        if (it == m_recs.pairs.end())
          return false;
 
        const auto& ec = it->second;
        return valid(ec, entity);
      }
 
      GAIA_NODISCARD bool valid_entity(Entity entity) const {
        if (entity == EntityBad)
          return false;
 
        GAIA_ASSERT(!entity.pair());
        if (entity.pair())
          return false;
 
        // Entity ID has to fit inside the entity array
        if (entity.id() >= m_recs.entities.size())
          return false;
 
        const auto& ec = m_recs.entities[entity.id()];
        return valid(ec, entity);
      }
 
      GAIA_NODISCARD bool valid_entity_id(EntityId entityId) const {
        if (entityId == EntityBad.id())
          return false;
 
        // Entity ID has to fit inside the entity array
        if (entityId >= m_recs.entities.size())
          return false;
 
        const auto& ec = m_recs.entities[entityId];
        if (ec.data.pair != 0)
          return false;
 
        return valid(
            ec, Entity(entityId, ec.data.gen, (bool)ec.data.ent, (bool)ec.data.pair, (EntityKind)ec.data.kind));
      }
 
      void lock() {
        GAIA_ASSERT(m_structuralChangesLocked != (uint32_t)-1);
        ++m_structuralChangesLocked;
      }
 
      void unlock() {
        GAIA_ASSERT(m_structuralChangesLocked > 0);
        --m_structuralChangesLocked;
      }
 
    public:
      GAIA_NODISCARD bool locked() const {
        return m_structuralChangesLocked != 0;
      }
 
      void save() {
        auto& s = *m_pSerializer;
 
        s.reset();
 
        // Version number, currently unused
        s.save((uint32_t)0);
 
        // Store the index of the last core component.
        // TODO: As this changes, we will have to modify entity ids accordingly.
        const auto lastCoreComponentId = GAIA_ID(LastCoreComponent).id();
        s.save(lastCoreComponentId);
 
        // Entities
        {
          auto saveEntityContainer = [&](const EntityContainer& ec) {
            s.save(ec.idx);
            s.save(ec.dataRaw);
            s.save(ec.row);
            GAIA_ASSERT((ec.flags & EntityContainerFlags::Load) == 0);
            s.save(ec.flags); // ignore Load
 
#if GAIA_USE_SAFE_ENTITY
            s.save(ec.refCnt);
#else
            s.save((uint32_t)0);
#endif
 
            uint32_t archetypeIdx = ec.pArchetype->list_idx();
            s.save(archetypeIdx);
            uint32_t chunkIdx = ec.pChunk->idx();
            s.save(chunkIdx);
          };
 
          const auto recEntities = (uint32_t)m_recs.entities.size();
          const auto newEntities = recEntities - lastCoreComponentId;
          s.save(newEntities);
          GAIA_FOR2(lastCoreComponentId, recEntities) {
            const auto& ec = m_recs.entities[i];
            saveEntityContainer(ec);
          }
 
          {
            uint32_t pairsCnt = 0;
            for (const auto& pair: m_recs.pairs) {
              // Skip core pairs
              if (pair.first.entity().id() < lastCoreComponentId && pair.first.entity().gen() < lastCoreComponentId)
                continue;
 
              ++pairsCnt;
            }
            s.save(pairsCnt);
          }
          {
            for (const auto& pair: m_recs.pairs) {
              // Skip core pairs
              if (pair.first.entity().id() < lastCoreComponentId && pair.first.entity().gen() < lastCoreComponentId)
                continue;
 
              saveEntityContainer(pair.second);
            }
          }
 
          s.save(m_recs.entities.m_nextFreeIdx);
          s.save(m_recs.entities.m_freeItems);
        }
 
        // World
        {
          s.save((uint32_t)m_archetypes.size());
          for (auto* pArchetype: m_archetypes) {
            s.save((uint32_t)pArchetype->ids_view().size());
            for (auto e: pArchetype->ids_view())
              s.save(e);
 
            pArchetype->save(*m_pSerializer);
          }
 
          s.save(m_worldVersion);
        }
 
        // Entity names
        {
          s.save((uint32_t)m_nameToEntity.size());
          for (const auto& pair: m_nameToEntity) {
            s.save(pair.second);
            const bool isOwnedStr = pair.first.owned();
            s.save(isOwnedStr);
 
            // For owner string we copy the entire string into the buffer
            if (isOwnedStr) {
              const auto* str = pair.first.str();
              const uint32_t len = pair.first.len();
              s.save(len);
              s.save_raw(str, len, ser::serialization_type_id::c8);
            }
            // Non-owned strings will only store the pointer.
            // However, if it is a component, we do not store anything at all because we can reconstruct
            // the name from our component cache.
            else if (!pair.second.comp()) {
              const auto* str = pair.first.str();
              const uint32_t len = pair.first.len();
              s.save(len);
              const auto ptr_val = (uint64_t)str;
              s.save_raw(&ptr_val, sizeof(ptr_val), ser::serialization_type_id::u64);
            }
          }
        }
      }
 
      bool load(ser::ISerializer* pOutputSerializer = nullptr) {
        auto& s = (pOutputSerializer == nullptr) ? m_binarySerializer : *pOutputSerializer;
 
        // Move back to the beginning of the stream
        s.seek(0);
 
        // Version number, currently unused
        uint32_t version = 0;
        s.load(version);
        if (version != 0) {
          GAIA_LOG_E("Unsupported world version %u. Expected 0.", version);
          return false;
        }
 
        // Store the index of the last core component. As they change, we will have to modify entity ids accordingly.
        uint32_t lastCoreComponentId = 0;
        s.load(lastCoreComponentId);
 
        // Entities
        {
          auto loadEntityContainer = [&](EntityContainer& ec) {
            s.load(ec.idx);
            s.load(ec.dataRaw);
            s.load(ec.row);
            s.load(ec.flags);
            ec.flags |= EntityContainerFlags::Load;
 
#if GAIA_USE_SAFE_ENTITY
            s.load(ec.refCnt);
#else
            s.load(ec.unused);
            // if this value is different from zero, it means we are trying to load data
            // that was previously saved with GAIA_USE_SAFE_ENTITY. It's probably not a good idea
            // because if your program used reference counting it probably won't work correctly.
            GAIA_ASSERT(ec.unused == 0);
#endif
 
            // Store the archetype idx inside the pointer. We will decode this once archetypes are created.
            uint32_t archetypeIdx = 0;
            s.load(archetypeIdx);
            ec.pArchetype = (Archetype*)((uintptr_t)archetypeIdx);
            // Store the chunk idx inside the pointer. We will decode this once chunks are created.
            uint32_t chunkIdx = 0;
            s.load(chunkIdx);
            ec.pChunk = (Chunk*)((uintptr_t)chunkIdx);
          };
 
          uint32_t newEntities = 0;
          s.load(newEntities);
          GAIA_FOR(newEntities) {
            EntityContainer ec;
            loadEntityContainer(ec);
 
            m_recs.entities.m_items.add_item(GAIA_MOV(ec));
          }
 
          uint32_t pairsCnt = 0;
          s.load(pairsCnt);
          GAIA_FOR(pairsCnt) {
            EntityContainer ec{};
            loadEntityContainer(ec);
            Entity pair(ec.idx, ec.data.gen);
            m_recs.pairs.emplace(EntityLookupKey(pair), GAIA_MOV(ec));
          }
 
          s.load(m_recs.entities.m_nextFreeIdx);
          s.load(m_recs.entities.m_freeItems);
        }
 
        // World
        {
          uint32_t archetypesSize = 0;
          s.load(archetypesSize);
          m_archetypes.reserve(archetypesSize);
          GAIA_FOR(archetypesSize) {
            uint32_t idsSize = 0;
            s.load(idsSize);
            Entity ids[ChunkHeader::MAX_COMPONENTS];
            GAIA_FOR_(idsSize, j) {
              s.load(ids[j]);
            }
 
            // Calculate the lookup hash
            const auto hashLookup = calc_lookup_hash({&ids[0], idsSize}).hash;
 
            auto* pArchetype = find_archetype({hashLookup}, {&ids[0], idsSize});
            if (pArchetype == nullptr) {
              // Create the archetype
              pArchetype = create_archetype({&ids[0], idsSize});
              pArchetype->set_hashes({hashLookup});
 
              // No need to do anything with the archetype graph. It will build itself naturally.
              // pArchetype->build_graph_edges(pArchetypeRight, entity);
 
              // Register the archetype in the world
              reg_archetype(pArchetype);
            }
 
            // Load archetype data
            pArchetype->load(s);
          }
 
          s.load(m_worldVersion);
        }
 
        // Update entity records.
        // We previously encoded the archetype id into refCnt.
        // Now we need to convert it back to the pointer.
        {
          for (auto& ec: m_recs.entities) {
            if ((ec.flags & EntityContainerFlags::Load) == 0)
              continue;
            ec.flags &= ~EntityContainerFlags::Load; // Clear the load flag
 
            const auto archetypeIdx = (ArchetypeId)((uintptr_t)ec.pArchetype); // Decode the archetype idx
            ec.pArchetype = m_archetypes[archetypeIdx];
            const uint32_t chunkIdx = (uint32_t)((uintptr_t)ec.pChunk); // Decode the chunk idx
            ec.pChunk = ec.pArchetype->chunks()[chunkIdx];
          }
          for (auto& pair: m_recs.pairs) {
            auto& ec = pair.second;
 
            if ((ec.flags & EntityContainerFlags::Load) == 0)
              continue;
            ec.flags &= ~EntityContainerFlags::Load; // Clear the load flag
 
            const auto archetypeIdx = (ArchetypeId)((uintptr_t)ec.pArchetype); // Decode the archetype idx
            ec.pArchetype = m_archetypes[archetypeIdx];
            const uint32_t chunkIdx = (uint32_t)((uintptr_t)ec.pChunk); // Decode the chunk idx
            ec.pChunk = ec.pArchetype->chunks()[chunkIdx];
          }
        }
 
        // Entity names
        {
          uint32_t cnt = 0;
          s.load(cnt);
          GAIA_FOR(cnt) {
            Entity entity;
            s.load(entity);
            // entity.data.gen = 0; // Reset generation to zero
 
            const auto& ec = fetch(entity);
            const auto compIdx = core::get_index(ec.pChunk->ids_view(), GAIA_ID(EntityDesc));
            auto* pDesc = reinterpret_cast<EntityDesc*>(ec.pChunk->comp_ptr_mut(compIdx, ec.row));
            GAIA_ASSERT(core::check_alignment(pDesc));
 
            bool isOwned = false;
            s.load(isOwned);
            if (!isOwned) {
              if (entity.comp()) {
                // Make components point back to their component cache record because if we save the world and load
                // it back in runtime, EntityDesc would still point to the old pointers to component names.
                const auto& ci = comp_cache().get(entity);
                pDesc->name = ci.name.str();
                // Length should still be the same. Only the pointer has changed.
                GAIA_ASSERT(pDesc->len == ci.name.len());
                m_nameToEntity.try_emplace(EntityNameLookupKey(pDesc->name, pDesc->len, 0), entity);
              } else {
                uint32_t len = 0;
                s.load(len);
                uint64_t ptr_val = 0;
                s.load_raw(&ptr_val, sizeof(ptr_val), ser::serialization_type_id::u64);
 
                // Simply point to whereever the original pointer pointed to
                pDesc->name = (const char*)ptr_val;
                pDesc->len = len;
                m_nameToEntity.try_emplace(EntityNameLookupKey(pDesc->name, pDesc->len, 0), entity);
              }
 
              continue;
            }
 
            uint32_t len = 0;
            s.load(len);
 
            // Get a pointer to where the string begins and seek to the end of the string
            const char* entityStr = (const char*)(s.data() + s.tell());
            s.seek(s.tell() + len);
 
            // Make sure EntityDesc does not point anywhere right now.
            {
              pDesc->name = nullptr;
              pDesc->len = 0;
            }
 
            // Name the entity using an owned string
            name(entity, entityStr, len);
          }
        }
 
        return false;
      }
 
    private:
      void sort_archetypes() {
        struct sort_cond {
          bool operator()(const Archetype* a, const Archetype* b) const {
            return a->id() < b->id();
          }
        };
 
        core::sort(m_archetypes, sort_cond{}, [&](uint32_t left, uint32_t right) {
          Archetype* tmp = m_archetypes[left];
 
          m_archetypes[right]->list_idx(left);
          m_archetypes[left]->list_idx(right);
 
          m_archetypes.data()[left] = (Archetype*)m_archetypes[right];
          m_archetypes.data()[right] = tmp;
        });
      }
 
      void remove_chunk(Archetype& archetype, Chunk& chunk) {
        archetype.del(&chunk);
        try_enqueue_archetype_for_deletion(archetype);
      }
 
      void remove_entity(Archetype& archetype, Chunk& chunk, uint16_t row) {
        archetype.remove_entity(chunk, row, m_recs);
        try_enqueue_chunk_for_deletion(archetype, chunk);
      }
 
      void del_empty_chunks() {
        GAIA_PROF_SCOPE(World::del_empty_chunks);
 
        for (uint32_t i = 0; i < m_chunksToDel.size();) {
          auto* pArchetype = m_chunksToDel[i].pArchetype;
          auto* pChunk = m_chunksToDel[i].pChunk;
 
          // Revive reclaimed chunks
          if (!pChunk->empty()) {
            pChunk->revive();
            revive_archetype(*pArchetype);
            core::swap_erase(m_chunksToDel, i);
            continue;
          }
 
          // Skip chunks which still have some lifespan left
          if (pChunk->progress_death()) {
            ++i;
            continue;
          }
 
          // Delete unused chunks that are past their lifespan
          remove_chunk(*pArchetype, *pChunk);
          core::swap_erase(m_chunksToDel, i);
        }
      }
 
      void del_empty_archetype(Archetype* pArchetype) {
        GAIA_PROF_SCOPE(World::del_empty_archetype);
 
        GAIA_ASSERT(pArchetype != nullptr);
        GAIA_ASSERT(pArchetype->empty() || pArchetype->is_req_del());
        GAIA_ASSERT(!pArchetype->dying() || pArchetype->is_req_del());
 
        unreg_archetype(pArchetype);
        Archetype::destroy(pArchetype);
      }
 
      void del_empty_archetypes() {
        GAIA_PROF_SCOPE(World::del_empty_archetypes);
 
        cnt::sarray_ext<Archetype*, 512> tmp;
 
        // Remove all dead archetypes from query caches.
        // Because the number of cached queries is way higher than the number of archetypes
        // we want to remove, we flip the logic around and iterate over all query caches
        // and match against our lists.
        // Note, all archetype pointers in the tmp array are invalid at this point and can
        // be used only for comparison. They can't be dereferenced.
        auto remove_from_queries = [&]() {
          if (tmp.empty())
            return;
 
          // TODO: How to speed this up? If there are 1k cached queries is it still going to
          //       be fast enough or do we get spikes? Probably a linked list for query cache
          //       would be a way to go.
          for (auto& info: m_queryCache) {
            for (auto* pArchetype: tmp)
              info.remove(pArchetype);
          }
 
          for (auto* pArchetype: tmp)
            del_empty_archetype(pArchetype);
          tmp.clear();
        };
 
        for (uint32_t i = 0; i < m_archetypesToDel.size();) {
          auto* pArchetype = m_archetypesToDel[i];
 
          // Skip reclaimed archetypes or archetypes that became immortal
          if (!pArchetype->empty() || pArchetype->max_lifespan() == 0) {
            revive_archetype(*pArchetype);
            core::swap_erase(m_archetypesToDel, i);
            continue;
          }
 
          // Skip archetypes which still have some lifespan left unless
          // they are force-deleted.
          if (!pArchetype->is_req_del() && pArchetype->progress_death()) {
            ++i;
            continue;
          }
 
          tmp.push_back(pArchetype);
 
          // Remove the unused archetypes
          core::swap_erase(m_archetypesToDel, i);
 
          // Clear what we have once the capacity is reached
          if (tmp.size() == tmp.max_size())
            remove_from_queries();
        }
 
        remove_from_queries();
      }
 
      void revive_archetype(Archetype& archetype) {
        archetype.revive();
        m_reqArchetypesToDel.erase(ArchetypeLookupKey(archetype.lookup_hash(), &archetype));
      }
 
      void try_enqueue_chunk_for_deletion(Archetype& archetype, Chunk& chunk) {
        if (chunk.dying() || !chunk.empty())
          return;
 
        // When the chunk is emptied we want it to be removed. We can't do it
        // rowB away and need to wait for world::gc() to be called.
        //
        // However, we need to prevent the following:
        //    1) chunk is emptied, add it to some removal list
        //    2) chunk is reclaimed
        //    3) chunk is emptied, add it to some removal list again
        //
        // Therefore, we have a flag telling us the chunk is already waiting to
        // be removed. The chunk might be reclaimed before garbage collection happens
        // but it simply ignores such requests. This way we always have at most one
        // record for removal for any given chunk.
        chunk.start_dying();
 
        m_chunksToDel.push_back({&archetype, &chunk});
      }
 
      void try_enqueue_archetype_for_deletion(Archetype& archetype) {
        if (!archetype.ready_to_die())
          return;
 
        // When the chunk is emptied we want it to be removed. We can't do it
        // rowB away and need to wait for world::gc() to be called.
        //
        // However, we need to prevent the following:
        //    1) archetype is emptied, add it to some removal list
        //    2) archetype is reclaimed
        //    3) archetype is emptied, add it to some removal list again
        //
        // Therefore, we have a flag telling us the chunk is already waiting to
        // be removed. The archetype might be reclaimed before garbage collection happens
        // but it simply ignores such requests. This way we always have at most one
        // record for removal for any given chunk.
        archetype.start_dying();
 
        m_archetypesToDel.push_back(&archetype);
      }
 
      void defrag_chunks(uint32_t maxEntities) {
        GAIA_PROF_SCOPE(World::defrag_chunks);
 
        const auto maxIters = m_archetypes.size();
        // There has to be at least the root archetype present
        GAIA_ASSERT(maxIters > 0);
 
        GAIA_FOR(maxIters) {
          const auto idx = (m_defragLastArchetypeIdx + 1) % maxIters;
          auto* pArchetype = m_archetypes[idx];
          defrag_archetype(*pArchetype, maxEntities);
          if (maxEntities == 0)
            return;
 
          m_defragLastArchetypeIdx = idx;
        }
      }
 
      void defrag_archetype(Archetype& archetype, uint32_t& maxEntities) {
        // Assuming the following chunk layout:
        //   Chunk_1: 10/10
        //   Chunk_2:  1/10
        //   Chunk_3:  7/10
        //   Chunk_4: 10/10
        //   Chunk_5:  9/10
        // After full defragmentation we end up with:
        //   Chunk_1: 10/10
        //   Chunk_2: 10/10 (7 entities from Chunk_3 + 2 entities from Chunk_5)
        //   Chunk_3:  0/10 (empty, ready for removal)
        //   Chunk_4: 10/10
        //   Chunk_5:  7/10
        // TODO: Implement mask of semi-full chunks so we can pick one easily when searching
        //       for a chunk to fill with a new entity and when defragmenting.
        // NOTE 1:
        // Even though entity movement might be present during defragmentation, we do
        // not update the world version here because no real structural changes happen.
        // All entities and components remain intact, they just move to a different place.
        // NOTE 2:
        // Entities belonging to chunks with uni components are locked to their chunk.
        // Therefore, we won't defragment them unless their uni components contain matching
        // values.
 
        if (maxEntities == 0)
          return;
 
        const auto& chunks = archetype.chunks();
        if (chunks.size() < 2)
          return;
 
        uint32_t front = 0;
        uint32_t back = chunks.size() - 1;
 
        auto* pDstChunk = chunks[front];
        auto* pSrcChunk = chunks[back];
 
        // Find the first semi-full chunk in the front
        while (front < back && (pDstChunk->full() || !pDstChunk->is_semi()))
          pDstChunk = chunks[++front];
        // Find the last semi-full chunk in the back
        while (front < back && (pSrcChunk->empty() || !pSrcChunk->is_semi()))
          pSrcChunk = chunks[--back];
 
        const auto& props = archetype.props();
        const bool hasUniEnts =
            props.cntEntities > 0 && archetype.ids_view()[props.cntEntities - 1].kind() == EntityKind::EK_Uni;
 
        // Find the first semi-empty chunk in the back
        while (front < back) {
          pDstChunk = chunks[front];
          pSrcChunk = chunks[back];
 
          const uint32_t entitiesInSrcChunk = pSrcChunk->size();
          const uint32_t spaceInDstChunk = pDstChunk->capacity() - pDstChunk->size();
          const uint32_t entitiesToMoveSrc = core::get_min(entitiesInSrcChunk, maxEntities);
          const uint32_t entitiesToMove = core::get_min(entitiesToMoveSrc, spaceInDstChunk);
 
          // Make sure uni components have matching values
          if (hasUniEnts) {
            auto rec = pSrcChunk->comp_rec_view();
            bool res = true;
            GAIA_FOR2(props.genEntities, props.cntEntities) {
              const auto* pSrcVal = (const void*)pSrcChunk->comp_ptr(i, 0);
              const auto* pDstVal = (const void*)pDstChunk->comp_ptr(i, 0);
              if (rec[i].pItem->cmp(pSrcVal, pDstVal)) {
                res = false;
                break;
              }
            }
 
            // When there is not a match we move to the next chunk
            if (!res) {
              pDstChunk = chunks[++front];
              goto next_iteration;
            }
          }
 
          GAIA_FOR(entitiesToMove) {
            const auto lastSrcEntityIdx = entitiesInSrcChunk - i - 1;
            const auto entity = pSrcChunk->entity_view()[lastSrcEntityIdx];
 
            auto& ec = m_recs[entity];
 
            const auto srcRow = ec.row;
            const auto dstRow = pDstChunk->add_entity(entity);
            const bool wasEnabled = !ec.data.dis;
 
            // Make sure the old entity becomes enabled now
            archetype.enable_entity(pSrcChunk, srcRow, true, m_recs);
            // We go back-to-front in the chunk so enabling the entity is not expected to change its row
            GAIA_ASSERT(srcRow == ec.row);
 
            // Move data from the old chunk to the new one
            pDstChunk->move_entity_data(entity, dstRow, m_recs);
 
            // Remove the entity record from the old chunk.
            // Normally we'd call remove_entity but we don't want to trigger world
            // version updated all the time. It's enough to do it just once at the
            // end of defragmentation.
            // remove_entity(archetype, *pSrcChunk, srcRow);
            archetype.remove_entity_raw(*pSrcChunk, srcRow, m_recs);
            try_enqueue_chunk_for_deletion(archetype, *pSrcChunk);
 
            // Bring the entity container record up-to-date
            ec.pChunk = pDstChunk;
            ec.row = (uint16_t)dstRow;
 
            // Transfer the original enabled state to the new chunk
            archetype.enable_entity(pDstChunk, dstRow, wasEnabled, m_recs);
          }
 
          // Update world versions
          if (entitiesToMove > 0) {
            pSrcChunk->update_world_version();
            pDstChunk->update_world_version();
            update_version(m_worldVersion);
          }
 
          maxEntities -= entitiesToMove;
          if (maxEntities == 0)
            return;
 
          // The source is empty, find another semi-empty source
          if (pSrcChunk->empty()) {
            while (front < back) {
              if (chunks[--back]->is_semi())
                break;
            }
          }
 
        next_iteration:
          // The destination chunk is full, we need to move to the next one.
          // The idea is to fill the destination as much as possible.
          while (front < back && pDstChunk->full())
            pDstChunk = chunks[++front];
        }
      }
 
      GAIA_NODISCARD Archetype* find_archetype(Archetype::LookupHash hashLookup, EntitySpan ids) {
        auto tmpArchetype = ArchetypeLookupChecker(ids);
        ArchetypeLookupKey key(hashLookup, &tmpArchetype);
 
        // Search for the archetype in the map
        const auto it = m_archetypesByHash.find(key);
        if (it == m_archetypesByHash.end())
          return nullptr;
 
        auto* pArchetype = it->second;
        return pArchetype;
      }
 
      void add_entity_archetype_pair(Entity entity, Archetype* pArchetype) {
        GAIA_ASSERT(entity != Pair(All, All));
 
        EntityLookupKey entityKey(entity);
        const auto it = m_entityToArchetypeMap.find(entityKey);
        if (it == m_entityToArchetypeMap.end()) {
          m_entityToArchetypeMap.try_emplace(entityKey, ArchetypeDArray{pArchetype});
          return;
        }
 
        auto& archetypes = it->second;
        if (!core::has(archetypes, pArchetype))
          archetypes.push_back(pArchetype);
      }
 
      void del_entity_archetype_pair(Pair pair, Entity entityToRemove) {
        GAIA_ASSERT(pair != Pair(All, All));
 
        auto it = m_entityToArchetypeMap.find(EntityLookupKey(pair));
        auto& archetypes = it->second;
 
        // Remove any reference to the found archetype from the array.
        // We don't know the archetype so we remove any archetype that contains our entity.
        for (uint32_t i = archetypes.size() - 1; i != (uint32_t)-1; --i) {
          const auto* pArchetype = archetypes[i];
          if (!pArchetype->has(entityToRemove))
            continue;
 
          core::swap_erase_unsafe(archetypes, i);
        }
 
        // NOTE: No need to delete keys with empty archetype arrays.
        //       There are only 2 such keys: (*, tgt), (src, *).
        // If no more items are present in the array, remove the map key.
        // if (archetypes.empty())
        //  m_entityToArchetypeMap.erase(it); DON'T
      }
 
      void del_entity_archetype_pairs(Entity entity) {
        // TODO: Optimize. Either switch to an array or add an index to the map value.
        //       Otherwise all these lookups make deleting entities slow.
 
        GAIA_ASSERT(entity != Pair(All, All));
 
        m_entityToArchetypeMap.erase(EntityLookupKey(entity));
 
        if (entity.pair()) {
          const auto first = get(entity.id());
          const auto second = get(entity.gen());
 
          // (*, tgt)
          del_entity_archetype_pair(Pair(All, second), entity);
          // (src, *)
          del_entity_archetype_pair(Pair(first, All), entity);
        }
      }
 
      GAIA_NODISCARD Archetype* create_archetype(EntitySpan entities) {
        GAIA_ASSERT(m_nextArchetypeId < (decltype(m_nextArchetypeId))-1);
        auto* pArchetype = Archetype::create(*this, m_nextArchetypeId++, m_worldVersion, entities);
 
        for (auto entity: entities) {
          add_entity_archetype_pair(entity, pArchetype);
 
          // If the entity is a pair, make sure to create special wildcard records for it
          // as well so wildcard queries can find the archetype.
          if (entity.pair()) {
            const auto first = get(entity.id());
            const auto second = get(entity.gen());
 
            // (*, tgt)
            add_entity_archetype_pair(Pair(All, second), pArchetype);
            // (src, *)
            add_entity_archetype_pair(Pair(first, All), pArchetype);
          }
        }
 
        return pArchetype;
      }
 
      void reg_archetype(Archetype* pArchetype) {
        GAIA_ASSERT(pArchetype != nullptr);
 
        // // Make sure hashes were set already
        // GAIA_ASSERT(
        //    (m_archetypesById.empty() || pArchetype == m_pRootArchetype) || (pArchetype->lookup_hash().hash != 0));
 
        // Make sure the archetype is not registered yet
        GAIA_ASSERT(pArchetype->list_idx() == BadIndex);
 
        // Register the archetype
        [[maybe_unused]] const auto it0 =
            m_archetypesById.emplace(ArchetypeIdLookupKey(pArchetype->id(), pArchetype->id_hash()), pArchetype);
        [[maybe_unused]] const auto it1 =
            m_archetypesByHash.emplace(ArchetypeLookupKey(pArchetype->lookup_hash(), pArchetype), pArchetype);
 
        GAIA_ASSERT(it0.second);
        GAIA_ASSERT(it1.second);
 
        pArchetype->list_idx(m_archetypes.size());
        m_archetypes.emplace_back(pArchetype);
      }
 
      void unreg_archetype(Archetype* pArchetype) {
        GAIA_ASSERT(pArchetype != nullptr);
 
        // Make sure hashes were set already
        GAIA_ASSERT(
            (m_archetypesById.empty() || pArchetype == m_pRootArchetype) || (pArchetype->lookup_hash().hash != 0));
 
        // Make sure the archetype was registered already
        GAIA_ASSERT(pArchetype->list_idx() != BadIndex);
 
        // Break graph connections
        {
          auto& edgeLefts = pArchetype->left_edges();
          for (auto& itLeft: edgeLefts)
            remove_edge_from_archetype(pArchetype, itLeft.second, itLeft.first.entity());
        }
 
        auto tmpArchetype = ArchetypeLookupChecker(pArchetype->ids_view());
        [[maybe_unused]] const auto res0 =
            m_archetypesById.erase(ArchetypeIdLookupKey(pArchetype->id(), pArchetype->id_hash()));
        [[maybe_unused]] const auto res1 =
            m_archetypesByHash.erase(ArchetypeLookupKey(pArchetype->lookup_hash(), &tmpArchetype));
        GAIA_ASSERT(res0 != 0);
        GAIA_ASSERT(res1 != 0);
 
        const auto idx = pArchetype->list_idx();
        GAIA_ASSERT(idx == core::get_index(m_archetypes, pArchetype));
        core::swap_erase(m_archetypes, idx);
        if (!m_archetypes.empty() && idx != m_archetypes.size())
          m_archetypes[idx]->list_idx(idx);
      }
 
#if GAIA_ASSERT_ENABLED
      static void print_archetype_entities(const World& world, const Archetype& archetype, Entity entity, bool adding) {
        auto ids = archetype.ids_view();
 
        GAIA_LOG_W("Currently present:");
        GAIA_EACH(ids) {
          GAIA_LOG_W("> [%u] %s [%s]", i, entity_name(world, ids[i]), EntityKindString[(uint32_t)ids[i].kind()]);
        }
 
        GAIA_LOG_W("Trying to %s:", adding ? "add" : "del");
        GAIA_LOG_W("> %s [%s]", entity_name(world, entity), EntityKindString[(uint32_t)entity.kind()]);
      }
 
      static void verify_add(const World& world, Archetype& archetype, Entity entity, Entity addEntity) {
        // Make sure the world is not locked
        if (world.locked()) {
          GAIA_ASSERT2(false, "Trying to add an entity while the world is locked");
          GAIA_LOG_W("Trying to add an entity [%u:%u] while the world is locked", entity.id(), entity.gen());
          print_archetype_entities(world, archetype, entity, false);
          return;
        }
 
        // Makes sure no wildcard entities are added
        if (is_wildcard(addEntity)) {
          GAIA_ASSERT2(false, "Adding wildcard pairs is not supported");
          print_archetype_entities(world, archetype, addEntity, true);
          return;
        }
 
        // Make sure not to add too many entities/components
        auto ids = archetype.ids_view();
        if GAIA_UNLIKELY (ids.size() + 1 >= ChunkHeader::MAX_COMPONENTS) {
          GAIA_ASSERT2(false, "Trying to add too many entities to entity!");
          GAIA_LOG_W("Trying to add an entity to entity [%u:%u] but there's no space left!", entity.id(), entity.gen());
          print_archetype_entities(world, archetype, addEntity, true);
          return;
        }
      }
 
      static void verify_del(const World& world, Archetype& archetype, Entity entity, Entity delEntity) {
        // Make sure the world is not locked
        if (world.locked()) {
          GAIA_ASSERT2(false, "Trying to delete an entity while the world is locked");
          GAIA_LOG_W("Trying to delete an entity [%u:%u] while the world is locked", entity.id(), entity.gen());
          print_archetype_entities(world, archetype, entity, false);
          return;
        }
 
        // Make sure the entity is present on the archetype
        if GAIA_UNLIKELY (!archetype.has(delEntity)) {
          GAIA_ASSERT2(false, "Trying to remove an entity which wasn't added");
          GAIA_LOG_W("Trying to del an entity from entity [%u:%u] but it was never added", entity.id(), entity.gen());
          print_archetype_entities(world, archetype, delEntity, false);
          return;
        }
      }
 
      static void verify_enable(const World& world, Archetype& archetype, Entity entity) {
        if (world.locked()) {
          GAIA_ASSERT2(false, "Trying to enable/disable an entity while the world is locked");
          GAIA_LOG_W("Trying to enable/disable an entity [%u:%u] while the world is locked", entity.id(), entity.gen());
          print_archetype_entities(world, archetype, entity, false);
        }
      }
 
      static void verify_move(const World& world, Archetype& archetype, Entity entity) {
        if (world.locked()) {
          GAIA_ASSERT2(false, "Trying to move an entity while the world is locked");
          GAIA_LOG_W("Trying to move an entity [%u:%u] while the world is locked", entity.id(), entity.gen());
          print_archetype_entities(world, archetype, entity, false);
        }
      }
#endif
 
      GAIA_NODISCARD Archetype* foc_archetype_add(Archetype* pArchetypeLeft, Entity entity) {
        // Check if the component is found when following the "add" edges
        {
          const auto edge = pArchetypeLeft->find_edge_right(entity);
          if (edge != ArchetypeIdHashPairBad) {
            auto it = m_archetypesById.find(ArchetypeIdLookupKey(edge.id, edge.hash));
            // The edge must exist at this point
            GAIA_ASSERT(it != m_archetypesById.end());
 
            auto* pArchetypeRight = it->second;
            GAIA_ASSERT(pArchetypeRight != nullptr);
            return pArchetypeRight;
          }
        }
 
        // Prepare a joint array of components of old + the newly added component
        cnt::sarray_ext<Entity, ChunkHeader::MAX_COMPONENTS> entsNew;
        {
          auto entsOld = pArchetypeLeft->ids_view();
          const auto entsOldCnt = entsOld.size();
          entsNew.resize((uint32_t)entsOld.size() + 1);
          GAIA_FOR(entsOldCnt) entsNew[i] = entsOld[i];
          entsNew[(uint32_t)entsOld.size()] = entity;
        }
 
        // Make sure to sort the components so we receive the same hash no matter the order in which components
        // are provided Bubble sort is okay. We're dealing with at most ChunkHeader::MAX_COMPONENTS items.
        sort(entsNew, SortComponentCond{});
 
        // Once sorted we can calculate the hashes
        const auto hashLookup = calc_lookup_hash({entsNew.data(), entsNew.size()}).hash;
        auto* pArchetypeRight = find_archetype({hashLookup}, {entsNew.data(), entsNew.size()});
        if (pArchetypeRight == nullptr) {
          pArchetypeRight = create_archetype({entsNew.data(), entsNew.size()});
          pArchetypeRight->set_hashes({hashLookup});
          pArchetypeLeft->build_graph_edges(pArchetypeRight, entity);
          reg_archetype(pArchetypeRight);
        }
 
        return pArchetypeRight;
      }
 
      GAIA_NODISCARD Archetype* foc_archetype_del(Archetype* pArchetypeRight, Entity entity) {
        // Check if the component is found when following the "del" edges
        {
          const auto edge = pArchetypeRight->find_edge_left(entity);
          if (edge != ArchetypeIdHashPairBad)
            return m_archetypesById[edge];
        }
 
        cnt::sarray_ext<Entity, ChunkHeader::MAX_COMPONENTS> entsNew;
        auto entsOld = pArchetypeRight->ids_view();
 
        // Find the intersection
        for (const auto e: entsOld) {
          if (e == entity)
            continue;
 
          entsNew.push_back(e);
        }
 
        // Verify there was a change
        GAIA_ASSERT(entsNew.size() != entsOld.size());
 
        // Calculate the hashes
        const auto hashLookup = calc_lookup_hash({entsNew.data(), entsNew.size()}).hash;
        auto* pArchetype = find_archetype({hashLookup}, {entsNew.data(), entsNew.size()});
        if (pArchetype == nullptr) {
          pArchetype = create_archetype({entsNew.data(), entsNew.size()});
          pArchetype->set_hashes({hashLookup});
          pArchetype->build_graph_edges(pArchetypeRight, entity);
          reg_archetype(pArchetype);
        }
 
        return pArchetype;
      }
 
      GAIA_NODISCARD const auto& archetypes() const {
        return m_archetypesById;
      }
 
      GAIA_NODISCARD Archetype& archetype(Entity entity) {
        const auto& ec = fetch(entity);
        return *ec.pArchetype;
      }
 
      void del_name(EntityContainer& ec, Entity entity) {
        EntityBuilder(*this, entity, ec).del_name();
      }
 
      void del_name(Entity entity) {
        EntityBuilder(*this, entity).del_name();
      }
 
      void del_entity(Entity entity, bool invalidate) {
        if (entity.pair() || entity == EntityBad)
          return;
 
        auto& ec = fetch(entity);
        del_entity_inter(ec, entity, invalidate);
      }
 
      void del_entity(EntityContainer& ec, Entity entity, bool invalidate) {
        if (entity.pair() || entity == EntityBad)
          return;
 
        del_entity_inter(ec, entity, invalidate);
      }
 
      void del_entity_inter(EntityContainer& ec, Entity entity, bool invalidate) {
        GAIA_ASSERT(entity.id() > GAIA_ID(LastCoreComponent).id());
 
        // if (!is_req_del(ec))
        {
          if (m_recs.entities.item_count() == 0)
            return;
 
#if GAIA_ASSERT_ENABLED
          auto* pChunk = ec.pChunk;
          GAIA_ASSERT(pChunk != nullptr);
#endif
 
          // Remove the entity from its chunk.
          // We call del_name first because remove_entity calls component destructors.
          // If the call was made inside invalidate_entity we would access a memory location
          // which has already been destructed which is not nice.
          del_name(ec, entity);
          remove_entity(*ec.pArchetype, *ec.pChunk, ec.row);
        }
 
        // Invalidate on-demand.
        // We delete as a separate step in the delayed deletion.
        if (invalidate)
          invalidate_entity(entity);
      }
 
      void del_entities(Archetype& archetype) {
        for (auto* pChunk: archetype.chunks()) {
          auto ids = pChunk->entity_view();
          for (auto e: ids) {
            if (!valid(e))
              continue;
 
#if GAIA_ASSERT_ENABLED
            const auto& ec = fetch(e);
 
            // We should never end up trying to delete a forbidden-to-delete entity
            GAIA_ASSERT((ec.flags & EntityContainerFlags::OnDeleteTarget_Error) == 0);
#endif
 
            del_entity(e, true);
          }
 
          validate_chunk(pChunk);
 
          // If the chunk was already dying we need to remove it from the delete list
          // because we can delete it right away.
          // TODO: Instead of searching for it we could store a delete index in the chunk
          //       header. This way the lookup is O(1) instead of O(N) and it will help
          //       with edge-cases (tons of chunks removed at the same time).
          if (pChunk->dying()) {
            const auto idx = core::get_index(m_chunksToDel, {&archetype, pChunk});
            if (idx != BadIndex)
              core::swap_erase(m_chunksToDel, idx);
          }
 
          remove_chunk(archetype, *pChunk);
        }
 
        validate_entities();
      }
 
      void del_inter(Entity entity) {
        auto on_delete = [this](Entity entityToDel) {
          auto& ec = fetch(entityToDel);
          handle_del_entity(ec, entityToDel);
        };
 
        if (is_wildcard(entity)) {
          const auto rel = get(entity.id());
          const auto tgt = get(entity.gen());
 
          // (*,*)
          if (rel == All && tgt == All) {
            GAIA_ASSERT2(false, "Not supported yet");
          }
          // (*,X)
          else if (rel == All) {
            if (const auto* pTargets = relations(tgt)) {
              // handle_del might invalidate the targets map so we need to make a copy
              // TODO: this is suboptimal at best, needs to be optimized
              cnt::darray_ext<Entity, 64> tmp;
              for (auto key: *pTargets)
                tmp.push_back(key.entity());
              for (auto e: tmp)
                on_delete(Pair(e, tgt));
            }
          }
          // (X,*)
          else if (tgt == All) {
            if (const auto* pRelations = targets(rel)) {
              // handle_del might invalidate the targets map so we need to make a copy
              // TODO: this is suboptimal at best, needs to be optimized
              cnt::darray_ext<Entity, 64> tmp;
              for (auto key: *pRelations)
                tmp.push_back(key.entity());
              for (auto e: tmp)
                on_delete(Pair(rel, e));
            }
          }
        } else {
          on_delete(entity);
        }
      }
 
      // Force-delete all entities from the requested archetypes along with the archetype itself
      void del_finalize_archetypes() {
        GAIA_PROF_SCOPE(World::del_finalize_archetypes);
 
        for (auto& key: m_reqArchetypesToDel) {
          auto* pArchetype = key.archetype();
          if (pArchetype == nullptr)
            continue;
 
          del_entities(*pArchetype);
 
          // Now that all entities are deleted, all their chunks are requested to get deleted
          // and in turn the archetype itself as well. Therefore, it is added to the archetype
          // delete list and picked up by del_empty_archetypes. No need to call deletion from here.
          // > del_empty_archetype(pArchetype);
        }
        m_reqArchetypesToDel.clear();
      }
 
      void del_finalize_entities() {
        GAIA_PROF_SCOPE(World::del_finalize_entities);
 
        for (auto it = m_reqEntitiesToDel.begin(); it != m_reqEntitiesToDel.end();) {
          const auto e = it->entity();
 
          // Entities that form archetypes need to stay until the archetype itself is gone
          if (m_entityToArchetypeMap.contains(*it)) {
            ++it;
            continue;
          }
 
          // Requested entities are partially deleted. We only need to invalidate them.
          invalidate_entity(e);
 
          it = m_reqEntitiesToDel.erase(it);
        }
      }
 
      void del_finalize() {
        GAIA_PROF_SCOPE(World::del_finalize);
 
        del_finalize_archetypes();
        del_finalize_entities();
      }
 
      GAIA_NODISCARD bool archetype_cond_match(Archetype& archetype, Pair cond, Entity target) const {
        // E.g.:
        //   target = (All, entity)
        //   cond = (OnDeleteTarget, delete)
        // Delete the entity if it matches the cond
        auto ids = archetype.ids_view();
 
        if (target.pair()) {
          for (auto e: ids) {
            // Find the pair which matches (All, entity)
            if (!e.pair())
              continue;
            if (e.gen() != target.gen())
              continue;
 
            const auto& ec = m_recs.entities[e.id()];
            const auto entity = ec.pChunk->entity_view()[ec.row];
            if (!has(entity, cond))
              continue;
 
            return true;
          }
        } else {
          for (auto e: ids) {
            if (e.pair())
              continue;
            if (!has(e, cond))
              continue;
 
            return true;
          }
        }
 
        return false;
      }
 
      void move_to_archetype(Archetype& srcArchetype, Archetype& dstArchetype) {
        GAIA_ASSERT(&srcArchetype != &dstArchetype);
 
        bool updated = false;
 
        for (auto* pSrcChunk: srcArchetype.chunks()) {
          auto srcEnts = pSrcChunk->entity_view();
          if (srcEnts.empty())
            continue;
 
          // Copy entities back-to-front to avoid unnecessary data movements.
          // TODO: Handle disabled entities efficiently.
          //       If there are disabled entities, we still do data movements if there already
          //       are enabled entities in the chunk.
          // TODO: If the header was of some fixed size, e.g. if we always acted as if we had
          //       ChunkHeader::MAX_COMPONENTS, certain data movements could be done pretty much instantly.
          //       E.g. when removing tags or pairs, we would simply replace the chunk pointer
          //       with a pointer to another one. The same goes for archetypes. Component data
          //       would not have to move at all internal chunk header pointers would remain unchanged.
 
          uint32_t i = (uint32_t)srcEnts.size();
          while (i != 0) {
            auto* pDstChunk = dstArchetype.foc_free_chunk();
            const uint32_t dstSpaceLeft = pDstChunk->capacity() - pDstChunk->size();
            const uint32_t cnt = core::get_min(dstSpaceLeft, i);
            for (uint32_t j = 0; j < cnt; ++j) {
              auto e = srcEnts[i - j - 1];
              move_entity(e, fetch(e), dstArchetype, *pDstChunk);
            }
 
            pDstChunk->update_world_version();
 
            GAIA_ASSERT(cnt <= i);
            i -= cnt;
          }
 
          pSrcChunk->update_world_version();
          updated = true;
        }
 
        if (updated)
          update_version(m_worldVersion);
      }
 
      GAIA_NODISCARD Archetype* calc_dst_archetype_ent(Archetype* pArchetype, Entity entity) {
        GAIA_ASSERT(!is_wildcard(entity));
 
        auto ids = pArchetype->ids_view();
        for (auto id: ids) {
          if (id != entity)
            continue;
 
          return foc_archetype_del(pArchetype, id);
        }
 
        return nullptr;
      }
 
      GAIA_NODISCARD Archetype* calc_dst_archetype_all_ent(Archetype* pArchetype, Entity entity) {
        GAIA_ASSERT(is_wildcard(entity));
 
        Archetype* pDstArchetype = pArchetype;
 
        auto ids = pArchetype->ids_view();
        for (auto id: ids) {
          if (!id.pair() || id.gen() != entity.gen())
            continue;
 
          pDstArchetype = foc_archetype_del(pDstArchetype, id);
        }
 
        return pArchetype != pDstArchetype ? pDstArchetype : nullptr;
      }
 
      GAIA_NODISCARD Archetype* calc_dst_archetype_ent_all(Archetype* pArchetype, Entity entity) {
        GAIA_ASSERT(is_wildcard(entity));
 
        Archetype* pDstArchetype = pArchetype;
 
        auto ids = pArchetype->ids_view();
        for (auto id: ids) {
          if (!id.pair() || id.id() != entity.id())
            continue;
 
          pDstArchetype = foc_archetype_del(pDstArchetype, id);
        }
 
        return pArchetype != pDstArchetype ? pDstArchetype : nullptr;
      }
 
      GAIA_NODISCARD Archetype* calc_dst_archetype_all_all(Archetype* pArchetype, [[maybe_unused]] Entity entity) {
        GAIA_ASSERT(is_wildcard(entity));
 
        Archetype* pDstArchetype = pArchetype;
        bool found = false;
 
        auto ids = pArchetype->ids_view();
        for (auto id: ids) {
          if (!id.pair())
            continue;
 
          pDstArchetype = foc_archetype_del(pDstArchetype, id);
          found = true;
        }
 
        return found ? pDstArchetype : nullptr;
      }
 
      GAIA_NODISCARD Archetype* calc_dst_archetype(Archetype* pArchetype, Entity entity) {
        if (entity.pair()) {
          auto rel = entity.id();
          auto tgt = entity.gen();
 
          // Removing a wildcard pair. We need to find all pairs matching it.
          if (rel == All.id() || tgt == All.id()) {
            // (first, All) means we need to match (first, A), (first, B), ...
            if (rel != All.id() && tgt == All.id())
              return calc_dst_archetype_ent_all(pArchetype, entity);
 
            // (All, second) means we need to match (A, second), (B, second), ...
            if (rel == All.id() && tgt != All.id())
              return calc_dst_archetype_all_ent(pArchetype, entity);
 
            // (All, All) means we need to match all relationships
            return calc_dst_archetype_all_all(pArchetype, EntityBad);
          }
        }
 
        // Non-wildcard pair or entity
        return calc_dst_archetype_ent(pArchetype, entity);
      }
 
      void req_del(Archetype& archetype) {
        if (archetype.is_req_del())
          return;
 
        archetype.req_del();
        m_reqArchetypesToDel.insert(ArchetypeLookupKey(archetype.lookup_hash(), &archetype));
      }
 
      void req_del(EntityContainer& ec, Entity entity) {
        if (is_req_del(ec))
          return;
 
        del_entity(ec, entity, false);
 
        ec.req_del();
        m_reqEntitiesToDel.insert(EntityLookupKey(entity));
      }
 
      void req_del_entities_with(Entity entity) {
        GAIA_PROF_SCOPE(World::req_del_entities_with);
 
        GAIA_ASSERT(entity != Pair(All, All));
 
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(entity));
        if (it == m_entityToArchetypeMap.end())
          return;
 
        const auto& archetypes = it->second;
        for (auto* pArchetype: archetypes)
          req_del(*pArchetype);
      }
 
      void req_del_entities_with(Entity entity, Pair cond) {
        GAIA_PROF_SCOPE(World::req_del_entities_with);
 
        GAIA_ASSERT(entity != Pair(All, All));
 
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(entity));
        if (it == m_entityToArchetypeMap.end())
          return;
 
        const auto& archetypes = it->second;
        for (auto* pArchetype: archetypes) {
          // Evaluate the condition if a valid pair is given
          if (!archetype_cond_match(*pArchetype, cond, entity))
            continue;
 
          req_del(*pArchetype);
        }
      }
 
      void rem_from_entities(Entity entity) {
        GAIA_PROF_SCOPE(World::rem_from_entities);
 
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(entity));
        if (it == m_entityToArchetypeMap.end())
          return;
 
        // Invalidate the singleton status if necessary
        if (!entity.pair()) {
          auto& ec = fetch(entity);
          if ((ec.flags & EntityContainerFlags::IsSingleton) != 0) {
            auto ids = ec.pArchetype->ids_view();
            const auto idx = core::get_index(ids, entity);
            if (idx != BadIndex)
              EntityBuilder::set_flag(ec.flags, EntityContainerFlags::IsSingleton, false);
          }
        }
 
        // Update archetypes of all affected entities
        const auto& archetypes = it->second;
        for (auto* pArchetype: archetypes) {
          if (pArchetype->is_req_del())
            continue;
 
          auto* pDstArchetype = calc_dst_archetype(pArchetype, entity);
          if (pDstArchetype != nullptr)
            move_to_archetype(*pArchetype, *pDstArchetype);
        }
      }
 
      void rem_from_entities(Entity entity, Pair cond) {
        GAIA_PROF_SCOPE(World::rem_from_entities);
 
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(entity));
        if (it == m_entityToArchetypeMap.end())
          return;
 
        // Invalidate the singleton status if necessary
        if (!entity.pair()) {
          auto& ec = fetch(entity);
          if ((ec.flags & EntityContainerFlags::IsSingleton) != 0) {
            auto ids = ec.pArchetype->ids_view();
            const auto idx = core::get_index(ids, entity);
            if (idx != BadIndex)
              EntityBuilder::set_flag(ec.flags, EntityContainerFlags::IsSingleton, false);
          }
        }
 
        const auto& archetypes = it->second;
        for (auto* pArchetype: archetypes) {
          if (pArchetype->is_req_del())
            continue;
 
          // Evaluate the condition if a valid pair is given
          if (!archetype_cond_match(*pArchetype, cond, entity))
            continue;
 
          auto* pDstArchetype = calc_dst_archetype(pArchetype, entity);
          if (pDstArchetype != nullptr)
            move_to_archetype(*pArchetype, *pDstArchetype);
        }
      }
 
      void handle_del_entity(EntityContainer& ec, Entity entity) {
        GAIA_PROF_SCOPE(World::handle_del_entity);
 
        GAIA_ASSERT(!is_wildcard(entity));
 
        if (entity.pair()) {
          if ((ec.flags & EntityContainerFlags::OnDelete_Error) != 0) {
            GAIA_ASSERT2(false, "Trying to delete an entity that is forbidden from being deleted");
            GAIA_LOG_E(
                "Trying to delete a pair [%u.%u] %s [%s] that is forbidden from being deleted", entity.id(),
                entity.gen(), name(entity), EntityKindString[entity.kind()]);
            return;
          }
 
          const auto tgt = get(entity.gen());
          const auto& ecTgt = fetch(tgt);
          if ((ecTgt.flags & EntityContainerFlags::OnDeleteTarget_Error) != 0) {
            GAIA_ASSERT2(false, "Trying to delete an entity that is forbidden from being deleted (target restriction)");
            GAIA_LOG_E(
                "Trying to delete a pair [%u.%u] %s [%s] that is forbidden from being deleted (target restriction)",
                entity.id(), entity.gen(), name(entity), EntityKindString[entity.kind()]);
            return;
          }
 
#if GAIA_USE_SAFE_ENTITY
          // Decrement the ref count at this point.
          if ((ec.flags & EntityContainerFlags::RefDecreased) == 0) {
            --ec.refCnt;
            ec.flags |= EntityContainerFlags::RefDecreased;
          }
 
          // Don't delete so long something still references us
          if (ec.refCnt != 0)
            return;
#endif
 
          if ((ecTgt.flags & EntityContainerFlags::OnDeleteTarget_Delete) != 0) {
            // Delete all entities referencing this one as a relationship pair's target
            req_del_entities_with(Pair(All, tgt), Pair(OnDeleteTarget, Delete));
          } else {
            // Remove from all entities referencing this one as a relationship pair's target
            rem_from_entities(Pair(All, tgt));
          }
 
          // This entity has been requested to be deleted already. Nothing more for us to do here
          if (is_req_del(ec))
            return;
 
          if ((ec.flags & EntityContainerFlags::OnDelete_Delete) != 0) {
            // Delete all references to the entity
            req_del_entities_with(entity);
          } else {
            // Entities are only removed by default
            rem_from_entities(entity);
          }
        } else {
          if ((ec.flags & EntityContainerFlags::OnDelete_Error) != 0) {
            GAIA_ASSERT2(false, "Trying to delete an entity that is forbidden from being deleted");
            GAIA_LOG_E(
                "Trying to delete an entity [%u.%u] %s [%s] that is forbidden from being deleted", entity.id(),
                entity.gen(), name(entity), EntityKindString[entity.kind()]);
            return;
          }
 
          if ((ec.flags & EntityContainerFlags::OnDeleteTarget_Error) != 0) {
            GAIA_ASSERT2(false, "Trying to delete an entity that is forbidden from being deleted (a pair's target)");
            GAIA_LOG_E(
                "Trying to delete an entity [%u.%u] %s [%s] that is forbidden from being deleted (a pair's target)",
                entity.id(), entity.gen(), name(entity), EntityKindString[entity.kind()]);
            return;
          }
 
#if GAIA_USE_SAFE_ENTITY
          // Decrement the ref count at this point.
          if ((ec.flags & EntityContainerFlags::RefDecreased) == 0) {
            --ec.refCnt;
            ec.flags |= EntityContainerFlags::RefDecreased;
          }
 
          // Don't delete so long something still references us
          if (ec.refCnt != 0)
            return;
#endif
 
          if ((ec.flags & EntityContainerFlags::OnDeleteTarget_Delete) != 0) {
            // Delete all entities referencing this one as a relationship pair's target
            req_del_entities_with(Pair(All, entity), Pair(OnDeleteTarget, Delete));
          } else {
            // Remove from all entities referencing this one as a relationship pair's target
            rem_from_entities(Pair(All, entity));
          }
 
          // This entity is has been requested to be deleted already. Nothing more for us to do here
          if (is_req_del(ec))
            return;
 
          if ((ec.flags & EntityContainerFlags::OnDelete_Delete) != 0) {
            // Delete all references to the entity
            req_del_entities_with(entity);
          } else {
            // Entities are only removed by default
            rem_from_entities(entity);
          }
        }
 
        // Mark the entity with the "delete requested" flag
        req_del(ec, entity);
 
#if GAIA_USE_WEAK_ENTITY
        auto invalidateWeakEntity = [](WeakEntityTracker* pTracker) {
          GAIA_ASSERT(pTracker->pWeakEntity->m_pTracker == pTracker);
          pTracker->pWeakEntity->m_pTracker = nullptr;
          pTracker->pWeakEntity->m_entity = EntityBad;
          delete pTracker;
        };
 
        // Invalidate WeakEntities
        if (ec.pWeakTracker != nullptr) {
          auto* pTracker = ec.pWeakTracker->next;
          while (pTracker != nullptr) {
            invalidateWeakEntity(pTracker);
            pTracker = pTracker->next;
          }
          pTracker = ec.pWeakTracker->prev;
          while (pTracker != nullptr) {
            invalidateWeakEntity(pTracker);
            pTracker = pTracker->prev;
          }
          invalidateWeakEntity(ec.pWeakTracker);
        }
#endif
      }
 
      void remove_edge_from_archetype(Archetype* pArchetype, ArchetypeGraphEdge edgeLeft, Entity edgeEntity) {
        GAIA_ASSERT(pArchetype != nullptr);
 
        const auto edgeLeftIt = m_archetypesById.find(ArchetypeIdLookupKey(edgeLeft.id, edgeLeft.hash));
        if (edgeLeftIt == m_archetypesById.end())
          return;
 
        auto* pArchetypeLeft = edgeLeftIt->second;
        GAIA_ASSERT(pArchetypeLeft != nullptr);
 
        // Remove the connection with the current archetype
        pArchetypeLeft->del_graph_edges(pArchetype, edgeEntity);
 
        // Traverse all archetypes on the right
        auto& archetypesRight = pArchetype->right_edges();
        for (auto& it: archetypesRight) {
          const auto& edgeRight = it.second;
          const auto edgeRightIt = m_archetypesById.find(ArchetypeIdLookupKey(edgeRight.id, edgeRight.hash));
          if (edgeRightIt == m_archetypesById.end())
            continue;
 
          auto* pArchetypeRight = edgeRightIt->second;
 
          // Remove the connection with the current archetype
          pArchetype->del_graph_edges(pArchetypeRight, it.first.entity());
        }
      }
 
      void remove_edges(Entity entityToRemove) {
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(entityToRemove));
        if (it == m_entityToArchetypeMap.end())
          return;
 
        const auto& archetypes = it->second;
        for (auto* pArchetype: archetypes)
          remove_edge_from_archetype(pArchetype, pArchetype->find_edge_left(entityToRemove), entityToRemove);
      }
 
      void remove_edges_from_pairs(Entity entity) {
        if (entity.pair())
          return;
 
        // Make sure to remove all pairs containing the entity
        // (X, something)
        const auto* tgts = targets(entity);
        if (tgts != nullptr) {
          for (auto target: *tgts)
            remove_edges(Pair(entity, target.entity()));
        }
        // (something, X)
        const auto* rels = relations(entity);
        if (rels != nullptr) {
          for (auto relation: *rels)
            remove_edges(Pair(relation.entity(), entity));
        }
      }
 
      void del_graph_edges(Entity entity) {
        remove_edges(entity);
        remove_edges_from_pairs(entity);
      }
 
      void del_reltgt_tgtrel_pairs(Entity entity) {
        auto delPair = [](PairMap& map, Entity source, Entity remove) {
          auto itTargets = map.find(EntityLookupKey(source));
          if (itTargets != map.end()) {
            auto& targets = itTargets->second;
            targets.erase(EntityLookupKey(remove));
          }
        };
 
        if (entity.pair()) {
          const auto it = m_recs.pairs.find(EntityLookupKey(entity));
          if (it != m_recs.pairs.end()) {
            // Delete the container record
            m_recs.pairs.erase(it);
 
            // Update pairs
            auto rel = get(entity.id());
            auto tgt = get(entity.gen());
 
            delPair(m_relationsToTargets, rel, tgt);
            delPair(m_relationsToTargets, All, tgt);
            delPair(m_targetsToRelations, tgt, rel);
            delPair(m_targetsToRelations, All, rel);
          }
        } else {
          // Update the container record
          auto& ec = m_recs.entities.free(entity);
 
          // If this is a singleton entity its archetype needs to be deleted
          if ((ec.flags & EntityContainerFlags::IsSingleton) != 0)
            req_del(*ec.pArchetype);
 
          ec.pArchetype = nullptr;
          ec.pChunk = nullptr;
          EntityBuilder::set_flag(ec.flags, EntityContainerFlags::DeleteRequested, false);
 
          // Update pairs
          delPair(m_relationsToTargets, All, entity);
          delPair(m_targetsToRelations, All, entity);
          m_relationsToTargets.erase(EntityLookupKey(entity));
          m_targetsToRelations.erase(EntityLookupKey(entity));
        }
      }
 
      void invalidate_entity(Entity entity) {
        del_graph_edges(entity);
        del_reltgt_tgtrel_pairs(entity);
        del_entity_archetype_pairs(entity);
      }
 
      void store_entity(EntityContainer& ec, Entity entity, Archetype* pArchetype, Chunk* pChunk) {
        GAIA_ASSERT(pArchetype != nullptr);
        GAIA_ASSERT(pChunk != nullptr);
        GAIA_ASSERT(
            !locked() && "Entities can't be stored while the world is locked "
                         "(structural changes are forbidden during this time!)");
 
        ec.pArchetype = pArchetype;
        ec.pChunk = pChunk;
        ec.row = pChunk->add_entity(entity);
        GAIA_ASSERT(entity.pair() || ec.data.gen == entity.gen());
        ec.data.dis = 0;
      }
 
      void move_entity(Entity entity, EntityContainer& ec, Archetype& dstArchetype, Chunk& dstChunk) {
        GAIA_PROF_SCOPE(World::move_entity);
 
        auto* pDstChunk = &dstChunk;
        auto* pSrcChunk = ec.pChunk;
 
        GAIA_ASSERT(pDstChunk != pSrcChunk);
 
        const auto srcRow0 = ec.row;
        const auto dstRow = pDstChunk->add_entity(entity);
        const bool wasEnabled = !ec.data.dis;
 
        auto& srcArchetype = *ec.pArchetype;
#if GAIA_ASSERT_ENABLED
        verify_move(*this, srcArchetype, entity);
#endif
 
        // Make sure the old entity becomes enabled now
        srcArchetype.enable_entity(pSrcChunk, srcRow0, true, m_recs);
        // Enabling the entity might have changed its chunk index so fetch it again
        const auto srcRow = ec.row;
 
        // Move data from the old chunk to the new one
        if (dstArchetype.id() == srcArchetype.id()) {
          pDstChunk->move_entity_data(entity, dstRow, m_recs);
        } else {
          pDstChunk->move_foreign_entity_data(pSrcChunk, srcRow, pDstChunk, dstRow);
        }
 
        // Remove the entity record from the old chunk
        remove_entity(srcArchetype, *pSrcChunk, srcRow);
 
        // An entity might have moved, try updating the free chunk index
        dstArchetype.try_update_free_chunk_idx();
 
        // Bring the entity container record up-to-date
        ec.pArchetype = &dstArchetype;
        ec.pChunk = pDstChunk;
        ec.row = (uint16_t)dstRow;
 
        // Make the enabled state in the new chunk match the original state
        dstArchetype.enable_entity(pDstChunk, dstRow, wasEnabled, m_recs);
 
        // End-state validation
        GAIA_ASSERT(valid(entity));
        validate_chunk(pSrcChunk);
        validate_chunk(pDstChunk);
        validate_entities();
      }
 
      void move_entity_raw(Entity entity, EntityContainer& ec, Archetype& dstArchetype) {
        // Update the old chunk's world version first
        ec.pChunk->update_world_version();
 
        auto* pDstChunk = dstArchetype.foc_free_chunk();
        move_entity(entity, ec, dstArchetype, *pDstChunk);
 
        // Update world versions
        pDstChunk->update_world_version();
        update_version(m_worldVersion);
      }
 
      Chunk* move_entity(Entity entity, Archetype& dstArchetype) {
        // Archetypes need to be different
        auto& ec = fetch(entity);
        if (ec.pArchetype == &dstArchetype)
          return nullptr;
 
        // Update the old chunk's world version first
        ec.pChunk->update_world_version();
 
        auto* pDstChunk = dstArchetype.foc_free_chunk();
        move_entity(entity, ec, dstArchetype, *pDstChunk);
 
        // Update world versions
        pDstChunk->update_world_version();
        update_version(m_worldVersion);
 
        return pDstChunk;
      }
 
      void validate_archetype_edges([[maybe_unused]] const Archetype* pArchetype) const {
#if GAIA_ECS_VALIDATE_ARCHETYPE_GRAPH && GAIA_ASSERT_ENABLED
        GAIA_ASSERT(pArchetype != nullptr);
 
        // Validate left edges
        const auto& archetypesLeft = pArchetype->left_edges();
        for (const auto& it: archetypesLeft) {
          const auto& edge = it.second;
          const auto edgeIt = m_archetypesById.find(ArchetypeIdLookupKey(edge.id, edge.hash));
          if (edgeIt == m_archetypesById.end())
            continue;
 
          const auto entity = it.first.entity();
          const auto* pArchetypeRight = edgeIt->second;
 
          // Edge must be found
          const auto edgeRight = pArchetypeRight->find_edge_right(entity);
          GAIA_ASSERT(edgeRight != ArchetypeIdHashPairBad);
 
          // The edge must point to pArchetype
          const auto it2 = m_archetypesById.find(ArchetypeIdLookupKey(edgeRight.id, edgeRight.hash));
          GAIA_ASSERT(it2 != m_archetypesById.end());
          const auto* pArchetype2 = it2->second;
          GAIA_ASSERT(pArchetype2 == pArchetype);
        }
 
        // Validate right edges
        const auto& archetypesRight = pArchetype->right_edges();
        for (const auto& it: archetypesRight) {
          const auto& edge = it.second;
          const auto edgeIt = m_archetypesById.find(ArchetypeIdLookupKey(edge.id, edge.hash));
          if (edgeIt == m_archetypesById.end())
            continue;
 
          const auto entity = it.first.entity();
          const auto* pArchetypeRight = edgeIt->second;
 
          // Edge must be found
          const auto edgeLeft = pArchetypeRight->find_edge_left(entity);
          GAIA_ASSERT(edgeLeft != ArchetypeIdHashPairBad);
 
          // The edge must point to pArchetype
          const auto it2 = m_archetypesById.find(ArchetypeIdLookupKey(edgeLeft.id, edgeLeft.hash));
          GAIA_ASSERT(it2 != m_archetypesById.end());
          const auto* pArchetype2 = it2->second;
          GAIA_ASSERT(pArchetype2 == pArchetype);
        }
#endif
      }
 
      void validate_entities() const {
#if GAIA_ECS_VALIDATE_ENTITY_LIST
        m_recs.entities.validate();
#endif
      }
 
      void validate_chunk([[maybe_unused]] Chunk* pChunk) const {
#if GAIA_ECS_VALIDATE_CHUNKS && GAIA_ASSERT_ENABLED
        GAIA_ASSERT(pChunk != nullptr);
 
        if (!pChunk->empty()) {
          // Make sure a proper amount of entities reference the chunk
          uint32_t cnt = 0;
          for (const auto& ec: m_recs.entities) {
            if (ec.pChunk != pChunk)
              continue;
            ++cnt;
          }
          for (const auto& pair: m_recs.pairs) {
            if (pair.second.pChunk != pChunk)
              continue;
            ++cnt;
          }
          GAIA_ASSERT(cnt == pChunk->size());
        } else {
          // Make sure no entities reference the chunk
          for (const auto& ec: m_recs.entities) {
            GAIA_ASSERT(ec.pChunk != pChunk);
          }
          for (const auto& pair: m_recs.pairs) {
            GAIA_ASSERT(pair.second.pChunk != pChunk);
          }
        }
#endif
      }
 
      template <bool CheckIn>
      GAIA_NODISCARD bool is_inter(Entity entity, Entity entityBase) const {
        GAIA_ASSERT(valid_entity(entity));
        GAIA_ASSERT(valid_entity(entityBase));
 
        // Pairs are not supported
        if (entity.pair() || entityBase.pair())
          return false;
 
        if constexpr (!CheckIn) {
          if (entity == entityBase)
            return true;
        }
 
        const auto& ec = m_recs.entities[entity.id()];
        const auto* pArchetype = ec.pArchetype;
 
        // Early exit if there are no Is relationship pairs on the archetype
        if (pArchetype->pairs_is() == 0)
          return false;
 
        for (uint32_t i = 0; i < pArchetype->pairs_is(); ++i) {
          auto e = pArchetype->entity_from_pairs_as_idx(i);
          const auto& ecTarget = m_recs.entities[e.gen()];
          auto target = ecTarget.pChunk->entity_view()[ecTarget.row];
          if (target == entityBase)
            return true;
 
          if (is_inter<CheckIn>(target, entityBase))
            return true;
        }
 
        return false;
      }
 
      template <bool CheckIn, typename Func>
      void as_up_trav(Entity entity, Func func) {
        GAIA_ASSERT(valid_entity(entity));
 
        // Pairs are not supported
        if (entity.pair())
          return;
 
        if constexpr (!CheckIn) {
          func(entity);
        }
 
        const auto& ec = m_recs.entities[entity.id()];
        const auto* pArchetype = ec.pArchetype;
 
        // Early exit if there are no Is relationship pairs on the archetype
        if (pArchetype->pairs_is() == 0)
          return;
 
        for (uint32_t i = 0; i < pArchetype->pairs_is(); ++i) {
          auto e = pArchetype->entity_from_pairs_as_idx(i);
          const auto& ecTarget = m_recs.entities[e.gen()];
          auto target = ecTarget.pChunk->entity_view()[ecTarget.row];
          func(target);
 
          as_up_trav<CheckIn>(target, func);
        }
      }
 
      template <typename T>
      const ComponentCacheItem& reg_core_entity(Entity id, Archetype* pArchetype) {
        auto comp = add(*pArchetype, id.entity(), id.pair(), id.kind());
        const auto& ci = comp_cache_mut().add<T>(id);
        GAIA_ASSERT(ci.entity == id);
        GAIA_ASSERT(comp == id);
        (void)comp;
        return ci;
      }
 
      template <typename T>
      const ComponentCacheItem& reg_core_entity(Entity id) {
        return reg_core_entity<T>(id, m_pRootArchetype);
      }
 
      void init();
 
      void done() {
        cleanup_inter();
 
#if GAIA_ECS_CHUNK_ALLOCATOR
        ChunkAllocator::get().flush();
#endif
      }
 
      void assign_entity(Entity entity, Archetype& archetype) {
        GAIA_ASSERT(!entity.pair());
 
        auto* pChunk = archetype.foc_free_chunk();
        store_entity(m_recs.entities[entity.id()], entity, &archetype, pChunk);
        pChunk->update_versions();
        archetype.try_update_free_chunk_idx();
 
        // Call constructors for the generic components on the newly added entity if necessary
        pChunk->call_gen_ctors(pChunk->size() - 1, 1);
 
#if GAIA_ASSERT_ENABLED
        const auto& ec = m_recs.entities[entity.id()];
        GAIA_ASSERT(ec.pChunk == pChunk);
        auto entityExpected = pChunk->entity_view()[ec.row];
        GAIA_ASSERT(entityExpected == entity);
#endif
      }
 
      void assign_pair(Entity entity, Archetype& archetype) {
        GAIA_ASSERT(entity.pair());
 
        // Pairs are always added to m_pEntityArchetype initially and this can't change.
        GAIA_ASSERT(&archetype == m_pEntityArchetype);
 
        const auto it = m_recs.pairs.find(EntityLookupKey(entity));
        if (it != m_recs.pairs.end())
          return;
 
        // Update the container record
        EntityContainer ec{};
        ec.idx = entity.id();
        ec.data.gen = entity.gen();
        ec.data.pair = 1;
        ec.data.ent = 1;
        ec.data.kind = EntityKind::EK_Gen;
 
        auto* pChunk = archetype.foc_free_chunk();
        store_entity(ec, entity, &archetype, pChunk);
        pChunk->update_versions();
        archetype.try_update_free_chunk_idx();
 
        m_recs.pairs.emplace(EntityLookupKey(entity), GAIA_MOV(ec));
 
        // Update pair mappings
        const auto rel = get(entity.id());
        const auto tgt = get(entity.gen());
 
        auto addPair = [](PairMap& map, Entity source, Entity add) {
          auto& ents = map[EntityLookupKey(source)];
          ents.insert(EntityLookupKey(add));
        };
 
        addPair(m_relationsToTargets, rel, tgt);
        addPair(m_relationsToTargets, All, tgt);
        addPair(m_targetsToRelations, tgt, rel);
        addPair(m_targetsToRelations, All, rel);
      }
 
      GAIA_NODISCARD Entity add(Archetype& archetype, bool isEntity, bool isPair, EntityKind kind) {
        EntityContainerCtx ctx{isEntity, isPair, kind};
        const auto entity = m_recs.entities.alloc(&ctx);
        assign_entity(entity, archetype);
        return entity;
      }
 
      template <typename Func>
      void add_entity_n(Archetype& archetype, uint32_t count, Func func) {
        EntityContainerCtx ctx{true, false, EntityKind::EK_Gen};
 
        uint32_t left = count;
        do {
          auto* pChunk = archetype.foc_free_chunk();
          const uint32_t originalChunkSize = pChunk->size();
          const uint32_t freeSlotsInChunk = pChunk->capacity() - originalChunkSize;
          const uint32_t toCreate = core::get_min(freeSlotsInChunk, left);
 
          GAIA_FOR(toCreate) {
            const auto entityNew = m_recs.entities.alloc(&ctx);
            auto& ecNew = m_recs.entities[entityNew.id()];
            store_entity(ecNew, entityNew, &archetype, pChunk);
 
#if GAIA_ASSERT_ENABLED
            GAIA_ASSERT(ecNew.pChunk == pChunk);
            auto entityExpected = pChunk->entity_view()[ecNew.row];
            GAIA_ASSERT(entityExpected == entityNew);
#endif
          }
 
          // New entities were added, try updating the free chunk index
          archetype.try_update_free_chunk_idx();
 
          // Call constructors for the generic components on the newly added entity if necessary
          pChunk->call_gen_ctors(originalChunkSize, toCreate);
 
          // Call functors
          {
            auto entities = pChunk->entity_view();
            GAIA_FOR2(originalChunkSize, pChunk->size()) func(entities[i]);
          }
 
          pChunk->update_versions();
 
          left -= toCreate;
        } while (left > 0);
      }
 
      void gc() {
        GAIA_PROF_SCOPE(World::gc);
 
        del_empty_chunks();
        defrag_chunks(m_defragEntitiesPerTick);
        del_empty_archetypes();
      }
 
    public:
      QuerySerBuffer& query_buffer(QueryId& serId) {
        // No serialization id set on the query, try creating a new record
        if GAIA_UNLIKELY (serId == QueryIdBad) {
#if GAIA_ASSERT_ENABLED
          uint32_t safetyCounter = 0;
#endif
 
          while (true) {
#if GAIA_ASSERT_ENABLED
            // Make sure we don't cross some safety threshold
            ++safetyCounter;
            GAIA_ASSERT(safetyCounter < 100000);
#endif
 
            serId = ++m_nextQuerySerId;
            // Make sure we do not overflow
            GAIA_ASSERT(serId != 0);
 
            // If the id is already found, try again.
            // Note, this is essentially never going to repeat. We would have to prepare millions if
            // not billions of queries for which we only added inputs but never queried them.
            auto ret = m_querySerMap.try_emplace(serId);
            if (!ret.second)
              continue;
 
            return ret.first->second;
          };
        }
 
        return m_querySerMap[serId];
      }
 
      void query_buffer_reset(QueryId& serId) {
        auto it = m_querySerMap.find(serId);
        if (it == m_querySerMap.end())
          return;
 
        m_querySerMap.erase(it);
        serId = QueryIdBad;
      }
 
      void invalidate_queries_for_entity(Pair is_pair) {
        GAIA_ASSERT(is_pair.first() == Is);
 
        // We still need to handle invalidation "down-the-tree".
        // E.g. following setup:
        // q = w.query().all({Is,animal});
        // w.as(wolf, carnivore);
        // w.as(carnivore, animal);
        // q.each() ...; // animal, carnivore, wolf
        // w.del(wolf, {Is,carnivore}) // wolf is no longer a carnivore and thus no longer an animal
        // After this deletion, we need to invalidate "q" because wolf is no longer an animal
        // and we don't want q to include it.
        // q.each() ...; // animal
 
        auto e = is_pair.second();
        as_up_trav<false>(e, [&](Entity target) {
          // Invalidate all queries that contain  everything in our path.
          m_queryCache.invalidate_queries_for_entity(EntityLookupKey(Pair{Is, target}));
        });
      }
 
      Entity name_to_entity(std::span<const char> exprRaw) const {
        auto expr = core::trim(exprRaw);
 
        if (expr[0] == '(') {
          if (expr.back() != ')') {
            GAIA_ASSERT2(false, "Expression '(' not terminated");
            return EntityBad;
          }
 
          const auto idStr = expr.subspan(1, expr.size() - 2);
          const auto commaIdx = core::get_index(idStr, ',');
 
          const auto first = name_to_entity(idStr.subspan(0, commaIdx));
          if (first == EntityBad)
            return EntityBad;
          const auto second = name_to_entity(idStr.subspan(commaIdx + 1));
          if (second == EntityBad)
            return EntityBad;
 
          return ecs::Pair(first, second);
        }
 
        {
          auto idStr = core::trim(expr);
 
          // Wildcard character
          if (idStr.size() == 1 && idStr[0] == '*')
            return All;
 
          return get_inter(idStr.data(), (uint32_t)idStr.size());
        }
      }
 
      Entity expr_to_entity(va_list& args, std::span<const char> exprRaw) const {
        auto expr = core::trim(exprRaw);
 
        if (expr[0] == '%') {
          if (expr[1] != 'e') {
            GAIA_ASSERT2(false, "Expression '%' not terminated");
            return EntityBad;
          }
 
          auto id = (Identifier)va_arg(args, unsigned long long);
          return Entity(id);
        }
 
        if (expr[0] == '(') {
          if (expr.back() != ')') {
            GAIA_ASSERT2(false, "Expression '(' not terminated");
            return EntityBad;
          }
 
          const auto idStr = expr.subspan(1, expr.size() - 2);
          const auto commaIdx = core::get_index(idStr, ',');
 
          const auto first = expr_to_entity(args, idStr.subspan(0, commaIdx));
          if (first == EntityBad)
            return EntityBad;
          const auto second = expr_to_entity(args, idStr.subspan(commaIdx + 1));
          if (second == EntityBad)
            return EntityBad;
 
          return ecs::Pair(first, second);
        }
 
        {
          auto idStr = core::trim(expr);
 
          // Wildcard character
          if (idStr.size() == 1 && idStr[0] == '*')
            return All;
 
          // Anything else is a component name
          const auto* pItem = m_compCache.find(idStr.data(), (uint32_t)idStr.size());
          if (pItem == nullptr) {
            GAIA_ASSERT2(false, "Component not found");
            GAIA_LOG_W("Component '%.*s' not found", (uint32_t)idStr.size(), idStr.data());
            return EntityBad;
          }
 
          return pItem->entity;
        }
      }
    };
 
    using EntityBuilder = World::EntityBuilder;
  } // namespace ecs
} // namespace gaia
 
#include "api.inl"
#include "system.inl"
 
namespace gaia {
  namespace ecs {
    inline void World::init() {
      // Use the default serializer
      set_serializer(nullptr);
 
      // Register the root archetype
      {
        m_pRootArchetype = create_archetype({});
        m_pRootArchetype->set_hashes({calc_lookup_hash({})});
        reg_archetype(m_pRootArchetype);
      }
 
      (void)reg_core_entity<Core_>(Core);
 
      // Entity archetype matches the root archetype for now
      m_pEntityArchetype = m_pRootArchetype;
 
      // Register the component archetype (entity + EntityDesc + Component)
      {
        Archetype* pCompArchetype{};
        {
          const auto id = GAIA_ID(EntityDesc);
          const auto& ci = reg_core_entity<EntityDesc>(id);
          EntityBuilder(*this, id).add_inter_init(ci.entity);
          sset<EntityDesc>(id) = {ci.name.str(), ci.name.len()};
          pCompArchetype = m_recs.entities[id.id()].pArchetype;
        }
        {
          const auto id = GAIA_ID(Component);
          const auto& ci = reg_core_entity<Component>(id, pCompArchetype);
          EntityBuilder(*this, id).add_inter_init(ci.entity);
          acc_mut(id)
              // Entity descriptor
              .sset<EntityDesc>({ci.name.str(), ci.name.len()})
              // Component
              .sset<Component>(ci.comp);
          m_pCompArchetype = m_recs.entities[id.id()].pArchetype;
        }
      }
 
      // Core components.
      // Their order must correspond to the value sequence in id.h.
      {
        (void)reg_core_entity<OnDelete_>(OnDelete);
        (void)reg_core_entity<OnDeleteTarget_>(OnDeleteTarget);
        (void)reg_core_entity<Remove_>(Remove);
        (void)reg_core_entity<Delete_>(Delete);
        (void)reg_core_entity<Error_>(Error);
        (void)reg_core_entity<Requires_>(Requires);
        (void)reg_core_entity<CantCombine_>(CantCombine);
        (void)reg_core_entity<Exclusive_>(Exclusive);
        (void)reg_core_entity<Acyclic_>(Acyclic);
        (void)reg_core_entity<Traversable_>(Traversable);
        (void)reg_core_entity<All_>(All);
        (void)reg_core_entity<ChildOf_>(ChildOf);
        (void)reg_core_entity<Is_>(Is);
        (void)reg_core_entity<System_>(System);
        (void)reg_core_entity<DependsOn_>(DependsOn);
 
        (void)reg_core_entity<_Var0>(Var0);
        (void)reg_core_entity<_Var1>(Var1);
        (void)reg_core_entity<_Var2>(Var2);
        (void)reg_core_entity<_Var3>(Var3);
        (void)reg_core_entity<_Var4>(Var4);
        (void)reg_core_entity<_Var5>(Var5);
        (void)reg_core_entity<_Var6>(Var6);
        (void)reg_core_entity<_Var7>(Var7);
      }
 
      // Add special properties for core components.
      // Their order must correspond to the value sequence in id.h.
      {
        EntityBuilder(*this, Core) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, GAIA_ID(EntityDesc)) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, GAIA_ID(Component)) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, OnDelete) //
            .add(Core)
            .add(Exclusive)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, OnDeleteTarget) //
            .add(Core)
            .add(Exclusive)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Remove) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Delete) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Error) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, All) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Requires) //
            .add(Core)
            .add(Acyclic)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, CantCombine) //
            .add(Core)
            .add(Acyclic)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Exclusive) //
            .add(Core)
            .add(Pair(OnDelete, Error))
            .add(Acyclic);
        EntityBuilder(*this, Acyclic) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Traversable) //
            .add(Core)
            .add(Pair(OnDelete, Error));
 
        EntityBuilder(*this, ChildOf) //
            .add(Core)
            .add(Acyclic)
            .add(Exclusive)
            .add(Traversable)
            .add(Pair(OnDelete, Error))
            .add(Pair(OnDeleteTarget, Delete));
        EntityBuilder(*this, Is) //
            .add(Core)
            .add(Acyclic)
            .add(Pair(OnDelete, Error));
 
        EntityBuilder(*this, System) //
            .add(Core)
            .add(Acyclic)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, DependsOn) //
            .add(Core)
            .add(Acyclic)
            .add(Pair(OnDelete, Error));
 
        EntityBuilder(*this, Var0) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Var1) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Var2) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Var3) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Var4) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Var5) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Var6) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Var7) //
            .add(Core)
            .add(Pair(OnDelete, Error));
      }
 
      // Remove all archetypes with no chunks. We don't want any leftovers after
      // archetype movements.
      {
        for (uint32_t i = 1; i < m_archetypes.size(); ++i) {
          auto* pArchetype = m_archetypes[i];
          if (!pArchetype->chunks().empty())
            continue;
 
          // Request deletion the standard way.
          // We could simply add archetypes into m_archetypesToDel but this way
          // we can actually replicate what the system really does on the inside
          // and it will require more work at the cost of easier maintenance.
          // The amount of archetypes cleanup is very small after init and the code
          // only runs after the world is created so this is not a big deal.
          req_del(*pArchetype);
        }
 
        // Cleanup
        {
          del_finalize();
          while (!m_chunksToDel.empty() || !m_archetypesToDel.empty())
            gc();
 
          // Make sure everything has been cleared
          GAIA_ASSERT(m_reqArchetypesToDel.empty());
          GAIA_ASSERT(m_chunksToDel.empty());
          GAIA_ASSERT(m_archetypesToDel.empty());
        }
 
        sort_archetypes();
 
        // Make sure archetypes have valid graphs after the cleanup
        for (const auto* pArchetype: m_archetypes)
          validate_archetype_edges(pArchetype);
      }
 
      // Make sure archetype pointers are up-to-date
      m_pCompArchetype = m_recs.entities[GAIA_ID(Component).id()].pArchetype;
 
#if GAIA_SYSTEMS_ENABLED
      // Initialize the systems query
      systems_init();
#endif
    }
 
    inline GroupId
    group_by_func_default([[maybe_unused]] const World& world, const Archetype& archetype, Entity groupBy) {
      if (archetype.pairs() > 0) {
        auto ids = archetype.ids_view();
        for (auto id: ids) {
          if (!id.pair() || id.id() != groupBy.id())
            continue;
 
          // Consider the pair's target the groupId
          return id.gen();
        }
      }
 
      // No group
      return 0;
    }
  } // namespace ecs
} // namespace gaia
 
#if GAIA_SYSTEMS_ENABLED
namespace gaia {
  namespace ecs {
    inline void World::systems_init() {
      m_systemsQuery = query()
                           .all(System)
                           // sort systems by their dependencies
                           .sort_by(EntityBad, [](const World& world, const void* pData0, const void* pData1) {
                             const auto& entity0 = *(Entity*)pData0;
                             const auto& entity1 = *(Entity*)pData1;
                             if (world.has(entity0, ecs::Pair(DependsOn, entity1)))
                               return 1;
                             if (world.has(entity1, ecs::Pair(DependsOn, entity0)))
                               return -1;
 
                             return (int)entity0.id() - (int)entity1.id();
                           });
    }
 
    inline void World::systems_run() {
      m_systemsQuery.each([](ecs::Iter& it) {
        auto se_view = it.sview_mut<ecs::System_>(0);
        const auto cnt = se_view.size();
        GAIA_FOR(cnt) {
          auto& sys = se_view[i];
          sys.exec();
        }
      });
    }
 
    inline SystemBuilder World::system() {
      // Create the system
      auto sysEntity = add();
      EntityBuilder(*this, sysEntity) //
          .add<System_>();
 
      auto ss = acc_mut(sysEntity);
      auto& sys = ss.smut<System_>();
      {
        sys.entity = sysEntity;
        sys.query = query();
      }
      return SystemBuilder(*this, sysEntity);
    }
  } // namespace ecs
} // namespace gaia
#endif