world.h

#pragma once
#include "gaia/config/config.h"
 
#include <cctype>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#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/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/chunk_header.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_cursor.h"
#include "gaia/ecs/component_getter.h"
#include "gaia/ecs/component_setter.h"
#include "gaia/ecs/copy_scratch.h"
#include "gaia/ecs/entity_container.h"
#include "gaia/ecs/id.h"
#include "gaia/ecs/nonfragmenting_relation_store.h"
#include "gaia/ecs/observer.h"
#include "gaia/ecs/observer_registry.h"
#include "gaia/ecs/pair_lookup.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/relation_mutation_path.h"
#include "gaia/ecs/sparse_component_store.h"
#include "gaia/ecs/system.h"
#include "gaia/ecs/system_schedule_scratch.h"
#include "gaia/mem/mem_alloc.h"
#include "gaia/ser/ser_binary.h"
#if GAIA_JSON_ENABLED
  #include "gaia/ser/ser_json.h"
#endif
#include "gaia/ser/ser_rt.h"
#include "gaia/util/logging.h"
#include "gaia/util/str.h"
 
namespace gaia {
  namespace ecs {
#if GAIA_SYSTEMS_ENABLED
    class SystemBuilder;
#endif
#if GAIA_OBSERVERS_ENABLED
    class ObserverBuilder;
    class ObserverRegistry;
#endif
    class World;
 
    void world_notify_on_set_entity(World& world, Entity term, Entity entity);
    template <typename T>
    decltype(auto) world_direct_entity_arg_raw(World& world, Entity entity);
    template <typename T>
    decltype(auto) world_query_entity_arg_by_id_raw(World& world, Entity entity, Entity id);
 
    class GAIA_API World final {
    public:
      inline static bool s_enableUniqueNameDuplicateAssert = true;
 
    private:
      friend CommandBufferST;
      friend CommandBufferMT;
#if GAIA_OBSERVERS_ENABLED
      friend class ObserverRegistry;
      friend struct ObserverRuntimeData;
      friend struct ObserverRegistry::DiffDispatcher;
      friend struct ObserverRegistry::DirectDispatcher;
      friend struct ObserverRegistry::SharedDispatch;
#endif
      friend struct ComponentGetter;
      friend struct ComponentSetter;
      friend void lock(World&);
      friend void unlock(World&);
      friend QueryMatchScratch& query_match_scratch_acquire(World&);
      friend void query_match_scratch_release(World&, bool);
      friend uint32_t world_component_index_bucket_size(const World&, Entity);
      friend uint32_t world_component_index_comp_idx(const World&, const Archetype&, Entity);
      friend uint32_t world_component_index_match_count(const World&, const Archetype&, Entity);
      template <typename T>
      friend decltype(auto) world_direct_entity_arg(World& world, Entity entity);
      template <typename T>
      friend decltype(auto) world_direct_entity_arg_raw(World& world, Entity entity);
      template <typename T>
      friend decltype(auto) world_query_entity_arg_by_id(World& world, Entity entity, Entity id);
      template <typename T>
      friend decltype(auto) world_query_entity_arg_by_id_raw(World& world, Entity entity, Entity id);
      friend void world_finish_write(World& world, Entity term, Entity entity);
 
      ser::bin_stream m_stream;
      ser::serializer m_serializer{};
 
      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>>;
      using EntityArrayMap = cnt::map<EntityLookupKey, cnt::darray<Entity>>;
 
      using NonFragmentingRelationStore = detail::NonFragmentingRelationStore;
      using SparseComponentStoreErased = detail::SparseComponentStoreErased;
      using RuntimeSparseComponentStore = detail::RuntimeSparseComponentStore;
      template <typename T>
      using SparseComponentStore = detail::SparseComponentStore<T>;
      using CopyIterGroupState = detail::CopyIterGroupState;
      using PrefabChildEdge = detail::PrefabChildEdge;
      using PrefabInstantiatePlanNode = detail::PrefabInstantiatePlanNode;
 
      template <
          typename TApi, typename TValue, bool DeriveFromValue = std::is_class_v<TValue> && !std::is_final_v<TValue>>
      class SetWriteProxyTyped;
 
      template <typename TApi, typename TValue>
      class SetWriteProxyTyped<TApi, TValue, true>: public TValue {
        World* m_pWorld = nullptr;
        Entity m_entity = EntityBad;
        Entity m_term = EntityBad;
 
        void commit() {
          if (m_pWorld == nullptr)
            return;
 
          m_pWorld->template write_back_set_typed<TApi, TValue>(m_entity, m_term, static_cast<const TValue&>(*this));
          m_pWorld = nullptr;
        }
 
      public:
        SetWriteProxyTyped(World& world, Entity entity, Entity term, const TValue& value):
            TValue(value), m_pWorld(&world), m_entity(entity), m_term(term) {}
 
        SetWriteProxyTyped(World& world, Entity entity, Entity term, TValue&& value):
            TValue(GAIA_MOV(value)), m_pWorld(&world), m_entity(entity), m_term(term) {}
 
        SetWriteProxyTyped(const SetWriteProxyTyped&) = delete;
        SetWriteProxyTyped& operator=(const SetWriteProxyTyped&) = delete;
 
        SetWriteProxyTyped(SetWriteProxyTyped&& other) noexcept:
            TValue(static_cast<TValue&&>(other)), m_pWorld(other.m_pWorld), m_entity(other.m_entity),
            m_term(other.m_term) {
          other.m_pWorld = nullptr;
        }
 
        ~SetWriteProxyTyped() {
          commit();
        }
 
        SetWriteProxyTyped& operator=(const TValue& value) {
          static_cast<TValue&>(*this) = value;
          return *this;
        }
 
        SetWriteProxyTyped& operator=(TValue&& value) {
          static_cast<TValue&>(*this) = GAIA_MOV(value);
          return *this;
        }
 
        GAIA_NODISCARD operator TValue&() {
          return *this;
        }
 
        GAIA_NODISCARD operator const TValue&() const {
          return *this;
        }
      };
 
      template <typename TApi, typename TValue>
      class SetWriteProxyTyped<TApi, TValue, false> {
        World* m_pWorld = nullptr;
        Entity m_entity = EntityBad;
        Entity m_term = EntityBad;
        TValue m_value{};
 
        void commit() {
          if (m_pWorld == nullptr)
            return;
 
          m_pWorld->template write_back_set_typed<TApi, TValue>(m_entity, m_term, m_value);
          m_pWorld = nullptr;
        }
 
      public:
        SetWriteProxyTyped(World& world, Entity entity, Entity term, const TValue& value):
            m_pWorld(&world), m_entity(entity), m_term(term), m_value(value) {}
 
        SetWriteProxyTyped(World& world, Entity entity, Entity term, TValue&& value):
            m_pWorld(&world), m_entity(entity), m_term(term), m_value(GAIA_MOV(value)) {}
 
        SetWriteProxyTyped(const SetWriteProxyTyped&) = delete;
        SetWriteProxyTyped& operator=(const SetWriteProxyTyped&) = delete;
 
        SetWriteProxyTyped(SetWriteProxyTyped&& other) noexcept:
            m_pWorld(other.m_pWorld), m_entity(other.m_entity), m_term(other.m_term), m_value(GAIA_MOV(other.m_value)) {
          other.m_pWorld = nullptr;
        }
 
        ~SetWriteProxyTyped() {
          commit();
        }
 
        SetWriteProxyTyped& operator=(const TValue& value) {
          m_value = value;
          return *this;
        }
 
        SetWriteProxyTyped& operator=(TValue&& value) {
          m_value = GAIA_MOV(value);
          return *this;
        }
 
        GAIA_NODISCARD operator TValue&() {
          return m_value;
        }
 
        GAIA_NODISCARD operator const TValue&() const {
          return m_value;
        }
 
        GAIA_NODISCARD TValue* operator->() {
          return &m_value;
        }
 
        GAIA_NODISCARD const TValue* operator->() const {
          return &m_value;
        }
      };
 
      template <typename TValue, bool DeriveFromValue = std::is_class_v<TValue> && !std::is_final_v<TValue>>
      class SetWriteProxyObject;
 
      template <typename TValue>
      class SetWriteProxyObject<TValue, true>: public TValue {
        World* m_pWorld = nullptr;
        Entity m_entity = EntityBad;
        Entity m_term = EntityBad;
 
        void commit() {
          if (m_pWorld == nullptr)
            return;
 
          m_pWorld->template write_back_set_object<TValue>(m_entity, m_term, static_cast<const TValue&>(*this));
          m_pWorld = nullptr;
        }
 
      public:
        SetWriteProxyObject(World& world, Entity entity, Entity term, const TValue& value):
            TValue(value), m_pWorld(&world), m_entity(entity), m_term(term) {}
 
        SetWriteProxyObject(World& world, Entity entity, Entity term, TValue&& value):
            TValue(GAIA_MOV(value)), m_pWorld(&world), m_entity(entity), m_term(term) {}
 
        SetWriteProxyObject(const SetWriteProxyObject&) = delete;
        SetWriteProxyObject& operator=(const SetWriteProxyObject&) = delete;
 
        SetWriteProxyObject(SetWriteProxyObject&& other) noexcept:
            TValue(static_cast<TValue&&>(other)), m_pWorld(other.m_pWorld), m_entity(other.m_entity),
            m_term(other.m_term) {
          other.m_pWorld = nullptr;
        }
 
        ~SetWriteProxyObject() {
          commit();
        }
 
        SetWriteProxyObject& operator=(const TValue& value) {
          static_cast<TValue&>(*this) = value;
          return *this;
        }
 
        SetWriteProxyObject& operator=(TValue&& value) {
          static_cast<TValue&>(*this) = GAIA_MOV(value);
          return *this;
        }
 
        GAIA_NODISCARD operator TValue&() {
          return *this;
        }
 
        GAIA_NODISCARD operator const TValue&() const {
          return *this;
        }
      };
 
      template <typename TValue>
      class SetWriteProxyObject<TValue, false> {
        World* m_pWorld = nullptr;
        Entity m_entity = EntityBad;
        Entity m_term = EntityBad;
        TValue m_value{};
 
        void commit() {
          if (m_pWorld == nullptr)
            return;
 
          m_pWorld->template write_back_set_object<TValue>(m_entity, m_term, m_value);
          m_pWorld = nullptr;
        }
 
      public:
        SetWriteProxyObject(World& world, Entity entity, Entity term, const TValue& value):
            m_pWorld(&world), m_entity(entity), m_term(term), m_value(value) {}
 
        SetWriteProxyObject(World& world, Entity entity, Entity term, TValue&& value):
            m_pWorld(&world), m_entity(entity), m_term(term), m_value(GAIA_MOV(value)) {}
 
        SetWriteProxyObject(const SetWriteProxyObject&) = delete;
        SetWriteProxyObject& operator=(const SetWriteProxyObject&) = delete;
 
        SetWriteProxyObject(SetWriteProxyObject&& other) noexcept:
            m_pWorld(other.m_pWorld), m_entity(other.m_entity), m_term(other.m_term), m_value(GAIA_MOV(other.m_value)) {
          other.m_pWorld = nullptr;
        }
 
        ~SetWriteProxyObject() {
          commit();
        }
 
        SetWriteProxyObject& operator=(const TValue& value) {
          m_value = value;
          return *this;
        }
 
        SetWriteProxyObject& operator=(TValue&& value) {
          m_value = GAIA_MOV(value);
          return *this;
        }
 
        GAIA_NODISCARD operator TValue&() {
          return m_value;
        }
 
        GAIA_NODISCARD operator const TValue&() const {
          return m_value;
        }
 
        GAIA_NODISCARD TValue* operator->() {
          return &m_value;
        }
 
        GAIA_NODISCARD const TValue* operator->() const {
          return &m_value;
        }
      };
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) mut_im(Entity entity) {
        static_assert(!is_pair<T>::value);
        using FT = typename component_type_t<T>::TypeFull;
        const auto& item = add<FT>();
        if constexpr (uses_compile_time_sparse_storage<FT>())
          return sparse_component_store_mut<FT>(item.entity).mut(entity);
 
        const auto& ec = m_recs.entities[entity.id()];
        if constexpr (entity_kind_v<T> == EntityKind::EK_Gen)
          return ec.pChunk->template set<T>(ec.row);
        else
          return ec.pChunk->template set<T>();
      }
 
      GAIA_NODISCARD const ComponentCacheItem* component_item(Entity entity, Entity component) const {
        if (!component.pair())
          return comp_cache().find(component);
 
        const auto& ec = fetch(entity);
        const auto compIdx = core::get_index(ec.pChunk->ids_view(), component);
        return compIdx != BadIndex ? ec.pChunk->comp_rec_view()[compIdx].pItem : nullptr;
      }
 
      GAIA_NODISCARD static bool raw_component_supported(const ComponentCacheItem& item) noexcept {
        return item.comp.soa() == 0;
      }
 
      GAIA_NODISCARD static bool soa_field_supported(const ComponentCacheItem& item) noexcept {
        return item.comp.soa() != 0 && item.comp.storage_type() == DataStorageType::Table;
      }
 
      GAIA_NODISCARD static bool
      raw_component_payload_args_valid(const ComponentCacheItem& item, const void* data, uint32_t size) noexcept {
        if (!raw_component_supported(item))
          return false;
        if (size != item.comp.size())
          return false;
        return size == 0 || data != nullptr;
      }
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) mut_im(Entity entity, Entity object) {
        static_assert(!is_pair<T>::value);
        using FT = typename component_type_t<T>::TypeFull;
        if constexpr (supports_sparse_component_storage<FT>()) {
          if (can_use_sparse_component_storage<FT>(object))
            return sparse_component_mut_value<FT>(object, entity);
        }
 
        const auto& ec = m_recs.entities[entity.id()];
        return ec.pChunk->template set<T>(ec.row, object);
      }
 
      void finish_write(Entity entity, Entity term) {
        if (tearing_down() || !valid(entity))
          return;
 
        if (sparse_storage_mode(term) != SparseStorageMode::None) {
          world_notify_on_set_entity(*this, term, entity);
          return;
        }
 
        auto compIdx = uint32_t(BadIndex);
        {
          const auto& ec = fetch(entity);
          compIdx = world_component_index_comp_idx(*this, *ec.pArchetype, term);
        }
 
        if (compIdx == BadIndex) {
          (void) override(entity, term);
          const auto& ec = fetch(entity);
          compIdx = world_component_index_comp_idx(*this, *ec.pArchetype, term);
          if (compIdx == BadIndex)
            return;
        }
 
        const auto& ec = fetch(entity);
        const auto row = uint16_t(ec.row * (1U - (uint32_t)term.kind()));
        (void)ec.pChunk->comp_ptr_mut_gen<true>(compIdx, row);
        world_notify_on_set_entity(*this, term, entity);
      }
 
      template <typename TApi, typename TValue>
      void write_back_set_typed(Entity entity, Entity term, const TValue& value) {
        using FT = typename component_type_t<TApi>::TypeFull;
        ::gaia::ecs::update_version(m_worldVersion);
 
        if constexpr (uses_compile_time_sparse_storage<FT>()) {
          sparse_component_store_mut<FT>(term).add(entity) = value;
          world_notify_on_set_entity(*this, term, entity);
          return;
        }
 
        const auto& ec = fetch(entity);
        const auto row = uint16_t(ec.row * (1U - (uint32_t)term.kind()));
        ComponentSetter{*this, ec.pChunk, entity, row}.sset<TApi>(value);
        finish_write(entity, term);
      }
 
      template <typename TValue>
      void write_back_set_object(Entity entity, Entity term, const TValue& value) {
        using FT = typename component_type_t<TValue>::TypeFull;
        ::gaia::ecs::update_version(m_worldVersion);
        if constexpr (supports_sparse_component_storage<FT>()) {
          if (can_use_sparse_component_storage<FT>(term)) {
            sparse_component_add_value<FT>(term, entity) = value;
            finish_write(entity, term);
            return;
          }
        }
 
        const auto& ec = fetch(entity);
        const auto row = uint16_t(ec.row * (1U - (uint32_t)term.kind()));
        ComponentSetter{*this, ec.pChunk, entity, row}.template smut<TValue>(term) = value;
        finish_write(entity, term);
      }
 
      //----------------------------------------------------------------------
 
      //----------------------------------------------------------------------
 
      ComponentCache m_compCache;
      QueryCache m_queryCache;
      cnt::darray<QueryMatchScratch*> m_queryMatchScratchStack;
      uint32_t m_queryMatchScratchDepth = 0;
      QuerySerMap m_querySerMap;
      uint32_t m_nextQuerySerId = 0;
 
#if GAIA_OBSERVERS_ENABLED && GAIA_ASSERT_ENABLED
      uint32_t m_observerCallbackDepth = 0;
#endif
 
      EntityToArchetypeMap m_entityToArchetypeMap;
      EntityToArchetypeVersionMap m_entityToArchetypeMapVersions;
      PairMap m_entityToAsTargets;
      mutable cnt::map<EntityLookupKey, cnt::darray<Entity>> m_entityToAsTargetsTravCache;
      PairMap m_entityToAsRelations;
      mutable cnt::map<EntityLookupKey, cnt::darray<Entity>> m_entityToAsRelationsTravCache;
      mutable cnt::map<EntityLookupKey, cnt::darray<Entity>> m_targetsTravCache;
      mutable cnt::map<EntityLookupKey, cnt::darray<Entity>> m_srcBfsTravCache;
      mutable cnt::map<EntityLookupKey, uint32_t> m_depthOrderCache;
      mutable cnt::map<EntityLookupKey, cnt::darray<Entity>> m_sourcesAllCache;
      mutable cnt::map<EntityLookupKey, cnt::darray<Entity>> m_targetsAllCache;
      mutable bool m_relationCachesPopulated = false;
      bool m_hasOnDeleteTargetPolicy = false;
      bool m_hasCantCombinePolicy = false;
      bool m_hasRequiresPolicy = false;
      PairLookup m_pairLookup;
      cnt::map<EntityLookupKey, NonFragmentingRelationStore> m_nonFragmentingRelationsByRel;
      cnt::map<EntityLookupKey, SparseComponentStoreErased> m_sparseComponentsByComp;
      cnt::map<EntityLookupKey, uint32_t> m_relationVersions;
      Entity m_lastRelationVersionRelation = EntityBad;
      uint32_t* m_pLastRelationVersion = nullptr;
      mutable cnt::map<EntityLookupKey, uint32_t> m_srcEntityVersions;
 
      enum class SparseStorageMode : uint8_t { None, Fragmenting, NonFragmenting };
 
      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;
 
      uint32_t m_emptySpace1 = 0;
 
      EntityContainers m_recs;
      cnt::map<EntityNameLookupKey, Entity> m_nameToEntity;
      cnt::map<EntityNameLookupKey, Entity> m_aliasToEntity;
      Entity m_componentScope = EntityBad;
      cnt::darray<Entity> m_componentLookupPath;
      mutable util::str m_componentScopePathCache;
      mutable Entity m_componentScopePathCacheEntity = EntityBad;
      mutable bool m_componentScopePathCacheValid = false;
 
      cnt::set<ArchetypeLookupKey> m_reqArchetypesToDel;
      cnt::set<EntityLookupKey> m_reqEntitiesToDel;
 
#if GAIA_OBSERVERS_ENABLED
      ObserverRegistry m_observers;
 
      struct DeferredOnSet {
        Entity term;
        Entity entity;
      };
 
      cnt::darray<cnt::darray<DeferredOnSet>> m_deferredOnSet;
      uint32_t m_deferOnSetDepth = 0;
#endif
 
      struct DeferredSortInv {
        Entity entity;
      };
 
      cnt::darray<cnt::darray<DeferredSortInv>> m_deferredSortInv;
      uint32_t m_deferSortInvDepth = 0;
 
#if GAIA_SYSTEMS_ENABLED
      SystemRegistry m_systems;
#endif
 
      CommandBufferST* m_pCmdBufferST;
      CommandBufferMT* m_pCmdBufferMT;
      bool m_teardownActive = false;
      Query m_systemsQuery;
      detail::SystemScheduleScratch m_systemScheduleScratch;
      Sched m_sched{};
      mutable cnt::darray<uint64_t> m_entityVisitStamps;
      mutable uint64_t m_entityVisitStamp = 0;
 
#if GAIA_OBSERVERS_ENABLED
      cnt::darray_ext<Entity, 16> m_entitiesDeleting;
#endif
      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_enabledHierarchyVersion = 0;
      uint32_t m_archetypeDeleteVersion = 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() {
        teardown();
        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;
 
      //----------------------------------------------------------------------
 
      Query query() {
        return Query(
            *const_cast<World*>(this), m_queryCache,
            //
            m_nextArchetypeId, m_worldVersion, m_entityToArchetypeMap, m_entityToArchetypeMapVersions, m_archetypes);
      }
 
      Query uquery() {
        auto q = query();
        q.kind(QueryCacheKind::None);
        return q;
      }
 
#if GAIA_ECS_TEST_HOOKS
      GAIA_NODISCARD bool verify_query_cache() const {
        return m_queryCache.verify_archetype_tracking();
      }
 
      GAIA_NODISCARD uint32_t test_query_cache_count() const {
        return m_queryCache.test_query_count();
      }
#endif
 
      //----------------------------------------------------------------------
 
      void set_sched(const Sched& sched) {
        m_sched = sched;
      }
 
      void reset_sched() {
        m_sched = {};
      }
 
      GAIA_NODISCARD const Sched& sched() const {
        return sched_resolve(m_sched);
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD EntityContainer& fetch(Entity entity) {
#if GAIA_ASSERT_ENABLED
        // Wildcard pairs are not a real entity so we can't accept them
        GAIA_ASSERT(!entity.pair() || !is_wildcard(entity));
        if (!valid(entity)) {
          // Delete-time cleanup can still reference an exact pair record after one endpoint
          // has already become invalid. Delete-time observer diffs can also still reference
          // a delete-requested, queued-for-delete, or stale removed entity record before it
          // is invalidated. Allow these forms so cleanup and observer dispatch can finish.
          const bool allowStaleExactPair = entity.pair() && m_recs.pair_record_contains(entity);
          const bool allowDeleteRequestedEntity =
              !entity.pair() && entity.id() < m_recs.entities.size() &&
              m_recs.entities[entity.id()].data.gen == entity.gen() &&
              (m_recs.entities[entity.id()].flags & EntityContainerFlags::DeleteRequested) != 0;
          const bool allowQueuedDeleteEntity = !entity.pair() && m_reqEntitiesToDel.contains(EntityLookupKey(entity));
          const bool allowStaleEntityRecord = !entity.pair() && entity.id() < m_recs.entities.size() &&
                                              m_recs.entities[entity.id()].data.gen == entity.gen() &&
                                              m_recs.entities[entity.id()].pArchetype != nullptr &&
                                              m_recs.entities[entity.id()].pChunk != nullptr;
          GAIA_ASSERT(
              allowStaleExactPair || allowDeleteRequestedEntity || allowQueuedDeleteEntity || allowStaleEntityRecord);
        }
#endif
        return m_recs[entity];
      }
 
      GAIA_NODISCARD const EntityContainer& fetch(Entity entity) const {
#if GAIA_ASSERT_ENABLED
        // Wildcard pairs are not a real entity so we can't accept them
        GAIA_ASSERT(!entity.pair() || !is_wildcard(entity));
        if (!valid(entity)) {
          // Delete-time cleanup can still reference an exact pair record after one endpoint
          // has already become invalid. Delete-time observer diffs can also still reference
          // a delete-requested, queued-for-delete, or stale removed entity record before it
          // is invalidated. Allow these forms so cleanup and observer dispatch can finish.
          const bool allowStaleExactPair = entity.pair() && m_recs.pair_record_contains(entity);
          const bool allowDeleteRequestedEntity =
              !entity.pair() && entity.id() < m_recs.entities.size() &&
              m_recs.entities[entity.id()].data.gen == entity.gen() &&
              (m_recs.entities[entity.id()].flags & EntityContainerFlags::DeleteRequested) != 0;
          const bool allowQueuedDeleteEntity = !entity.pair() && m_reqEntitiesToDel.contains(EntityLookupKey(entity));
          const bool allowStaleEntityRecord = !entity.pair() && entity.id() < m_recs.entities.size() &&
                                              m_recs.entities[entity.id()].data.gen == entity.gen() &&
                                              m_recs.entities[entity.id()].pArchetype != nullptr &&
                                              m_recs.entities[entity.id()].pChunk != nullptr;
          GAIA_ASSERT(
              allowStaleExactPair || allowDeleteRequestedEntity || allowQueuedDeleteEntity || allowStaleEntityRecord);
        }
#endif
        return m_recs[entity];
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD static bool is_req_del(const EntityContainer& ec) {
        if ((ec.flags & EntityContainerFlags::DeleteRequested) != 0)
          return true;
        GAIA_ASSERT((ec.flags & EntityContainerFlags::Load) == 0);
        return ec.pArchetype != nullptr && ec.pArchetype->is_req_del();
      }
 
#if GAIA_OBSERVERS_ENABLED
  #if GAIA_ASSERT_ENABLED
      void observer_callback_enter() {
        ++m_observerCallbackDepth;
      }
 
      void observer_callback_leave() {
        GAIA_ASSERT(m_observerCallbackDepth != 0);
        --m_observerCallbackDepth;
      }
 
      GAIA_NODISCARD bool observer_callback_active() const {
        return m_observerCallbackDepth != 0;
      }
  #endif
 
      GAIA_NODISCARD bool entity_deletion_active(Entity entity) const {
        for (auto deleting: m_entitiesDeleting) {
          if (deleting == entity)
            return true;
        }
        return false;
      }
 
      void entity_deletion_enter(Entity entity) {
        GAIA_ASSERT(!entity_deletion_active(entity));
        m_entitiesDeleting.push_back(entity);
      }
 
      void entity_deletion_leave(Entity entity) {
        GAIA_ASSERT(!m_entitiesDeleting.empty());
        GAIA_ASSERT(m_entitiesDeleting.back() == entity);
        m_entitiesDeleting.pop_back();
      }
#endif
 
      GAIA_NODISCARD bool is_dont_fragment(Entity entity) const {
        return (fetch(entity).flags & EntityContainerFlags::IsDontFragment) != 0;
      }
 
      GAIA_NODISCARD bool relation_is_non_fragmenting(Entity relation) const {
        return valid(relation) && !relation.pair() && is_dont_fragment(relation);
      }
 
      GAIA_NODISCARD bool relation_uses_non_fragmenting_storage(Entity relation) const {
        if (!valid(relation) || relation.pair())
          return false;
 
        const auto& ec = fetch(relation);
        return (ec.flags & EntityContainerFlags::IsExclusive) != 0 &&
               (ec.flags & EntityContainerFlags::IsDontFragment) != 0;
      }
 
      GAIA_NODISCARD bool relation_is_hierarchy(Entity relation) const {
        if (!valid(relation) || relation.pair())
          return false;
 
        return has(relation, Exclusive) && has(relation, Traversable);
      }
 
      GAIA_NODISCARD bool relation_is_fragmenting(Entity relation) const {
        return valid(relation) && !relation.pair() && !is_dont_fragment(relation);
      }
 
      GAIA_NODISCARD bool relation_is_fragmenting_hierarchy(Entity relation) const {
        return relation_is_hierarchy(relation) && relation_is_fragmenting(relation);
      }
 
      GAIA_NODISCARD bool relation_supports_depth_order(Entity relation) const {
        return relation_is_fragmenting(relation);
      }
 
      GAIA_NODISCARD bool relation_depth_order_prunes_disabled_subtrees(Entity relation) const {
        return relation_is_fragmenting_hierarchy(relation);
      }
 
      GAIA_NODISCARD bool component_uses_sparse_storage(Entity component) const {
        if (!valid(component) || component.pair() || component.entity())
          return false;
 
        const auto* pItem = comp_cache().find(component);
        if (pItem == nullptr || component.kind() != EntityKind::EK_Gen || pItem->comp.soa() != 0)
          return false;
 
        return gaia::ecs::component_uses_sparse_storage(pItem->comp);
      }
 
      GAIA_NODISCARD bool component_is_non_fragmenting(Entity component) const {
        if (!component_uses_sparse_storage(component))
          return false;
 
        return (fetch(component).flags & EntityContainerFlags::IsDontFragment) != 0;
      }
 
      GAIA_NODISCARD SparseStorageMode sparse_storage_mode(Entity component) const {
        if (!valid(component) || component.pair() || component.entity())
          return SparseStorageMode::None;
 
        const auto* pItem = comp_cache().find(component);
        if (pItem == nullptr || component.kind() != EntityKind::EK_Gen || pItem->comp.soa() != 0 ||
            !gaia::ecs::component_uses_sparse_storage(pItem->comp))
          return SparseStorageMode::None;
 
        if ((fetch(component).flags & EntityContainerFlags::IsDontFragment) != 0)
          return SparseStorageMode::NonFragmenting;
 
        return SparseStorageMode::Fragmenting;
      }
 
      GAIA_NODISCARD bool
      copies_sparse_payload_inter(Entity comp, Entity srcEntity, const SparseComponentStoreErased& store) const {
        return store.func_has(store.pStore, srcEntity) && sparse_storage_mode(comp) != SparseStorageMode::None;
      }
 
      GAIA_NODISCARD bool copies_non_frag_sparse_payload_inter(
          Entity comp, Entity srcEntity, const SparseComponentStoreErased& store) const {
        return copies_sparse_payload_inter(comp, srcEntity, store) &&
               sparse_storage_mode(comp) == SparseStorageMode::NonFragmenting;
      }
 
      GAIA_NODISCARD bool sparse_copy_adds_id_inter(Entity comp) const {
        return sparse_storage_mode(comp) == SparseStorageMode::NonFragmenting;
      }
 
      //----------------------------------------------------------------------
 
      void sync_component_record(Entity component, Component comp) {
        auto& item = comp_cache_mut().get(component);
        item.comp = comp;
 
        auto& ec = m_recs.entities[component.id()];
        if (ec.pArchetype == nullptr || ec.pChunk == nullptr)
          return;
 
        const auto compIdx = core::get_index(ec.pArchetype->ids_view(), GAIA_ID(Component));
        if (compIdx == BadIndex)
          return;
 
        auto* pComp = reinterpret_cast<Component*>(ec.pChunk->comp_ptr_mut(compIdx, ec.row));
        *pComp = comp;
      }
 
      void validate_runtime_semantics(const RuntimeTypeDesc& runtimeType) const {
#if GAIA_ASSERT_ENABLED
        auto validate = [&](Entity semantic) {
          if (semantic == EntityBad)
            return;
          util::str path;
          GAIA_ASSERT(build_scope_path(semantic, path));
        };
        validate(runtimeType.semantic);
        GAIA_FOR(runtimeType.fieldCount)
        validate(runtimeType.fields[i].semantic);
#else
        (void)runtimeType;
#endif
      }
 
#if GAIA_JSON_ENABLED
      bool write_runtime_schema_json(ser::ser_json& writer, const char* schemaHash, bool includeRuntimeEntities) const;
#endif
 
      void finalize_component_registration(const ComponentCacheItem& item, bool addSparseTrait) {
        sync_component_record(item.entity, item.comp);
        const auto symbol = item.symbol_name();
        name_raw(item.entity, symbol.data(), symbol.size());
        if (addSparseTrait && item.comp.storage_type() == DataStorageType::Sparse)
          add(item.entity, Sparse);
      }
 
      void set_component_dont_fragment(Entity component, EntityContainer& ec) {
        if (component.comp())
          set_component_sparse_storage(component);
 
        if ((ec.flags & EntityContainerFlags::IsDontFragment) != 0)
          return;
 
        ec.flags |= EntityContainerFlags::IsDontFragment;
      }
 
      void set_component_sparse_storage(Entity component) {
        GAIA_ASSERT(valid(component));
        GAIA_ASSERT(component.comp());
        GAIA_ASSERT(!component.pair());
        GAIA_ASSERT(!component.entity());
        GAIA_ASSERT(component.kind() == EntityKind::EK_Gen);
 
        const auto& item = comp_cache().get(component);
        GAIA_ASSERT(item.entity == component);
 
        if (item.comp.storage_type() == DataStorageType::Sparse)
          return;
 
        GAIA_ASSERT(item.comp.soa() == 0);
        if (item.comp.soa() != 0)
          return;
 
        const auto directTermEntityCnt = count_direct_term_entities_direct(component);
        GAIA_ASSERT(directTermEntityCnt == 0);
        if (directTermEntityCnt != 0)
          return;
 
        auto comp = item.comp;
        comp.data.storage = (IdentifierData)DataStorageType::Sparse;
        sync_component_record(component, comp);
      }
 
      GAIA_NODISCARD bool can_add_component_storage_trait(Entity component) const {
        if (!component.comp())
          return true;
 
        const auto& item = comp_cache().get(component);
        return item.func_create_sparse_store == nullptr || item.comp.storage_type() == DataStorageType::Sparse;
      }
 
      template <typename T>
      GAIA_NODISCARD static constexpr bool supports_sparse_component_storage() {
        using U = typename actual_type_t<T>::Type;
        return !is_pair<T>::value && entity_kind_v<T> == EntityKind::EK_Gen && !mem::is_soa_layout_v<U>;
      }
 
      template <typename T>
      GAIA_NODISCARD static constexpr bool uses_compile_time_sparse_storage() {
        using U = typename actual_type_t<T>::Type;
        return auto_storage_policy_v<U> == DataStorageType::Sparse;
      }
 
      GAIA_NODISCARD SparseStorageMode compile_time_sparse_storage_mode(Entity component) const {
        return is_dont_fragment(component) ? SparseStorageMode::NonFragmenting : SparseStorageMode::Fragmenting;
      }
 
      template <typename T>
      GAIA_NODISCARD bool can_use_sparse_component_storage(Entity object) const {
        if constexpr (!supports_sparse_component_storage<T>())
          return false;
        else {
          if (!valid(object) || object.pair())
            return false;
 
          const auto* pItem = comp_cache().find(object);
          if (pItem == nullptr || pItem->entity != object || !gaia::ecs::component_uses_sparse_storage(pItem->comp))
            return false;
 
          using U = typename actual_type_t<T>::Type;
          return pItem->comp.size() == (uint32_t)sizeof(U) && pItem->comp.alig() == (uint32_t)alignof(U) &&
                 pItem->comp.soa() == 0 && object.kind() == entity_kind_v<T>;
        }
      }
 
      template <typename T>
      GAIA_NODISCARD SparseComponentStore<T>* sparse_component_store(Entity component) {
        const auto it = m_sparseComponentsByComp.find(EntityLookupKey(component));
        if (it == m_sparseComponentsByComp.end())
          return nullptr;
 
        return static_cast<SparseComponentStore<T>*>(it->second.pStore);
      }
 
      template <typename T>
      GAIA_NODISCARD const SparseComponentStore<T>* sparse_component_store(Entity component) const {
        const auto it = m_sparseComponentsByComp.find(EntityLookupKey(component));
        if (it == m_sparseComponentsByComp.end())
          return nullptr;
 
        return static_cast<const SparseComponentStore<T>*>(it->second.pStore);
      }
 
      template <typename T>
      GAIA_NODISCARD SparseComponentStore<T>& sparse_component_store_mut(Entity component) {
        const auto key = EntityLookupKey(component);
        const auto it = m_sparseComponentsByComp.find(key);
        if (it != m_sparseComponentsByComp.end())
          return *static_cast<SparseComponentStore<T>*>(it->second.pStore);
 
        auto* pStore = new SparseComponentStore<T>();
        m_sparseComponentsByComp.emplace(key, make_sparse_component_store_erased(pStore));
        return *pStore;
      }
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) sparse_component_add_value(Entity component, Entity entity) {
        using U = typename actual_type_t<T>::Type;
        const auto it = m_sparseComponentsByComp.find(EntityLookupKey(component));
        if (it == m_sparseComponentsByComp.end()) {
          const auto* pItem = comp_cache().find(component);
          GAIA_ASSERT(pItem != nullptr);
          auto& store = sparse_component_store_erased_mut(component, *pItem);
          return *(U*)store.func_add(store.pStore, entity);
        }
        return *(U*)it->second.func_add(it->second.pStore, entity);
      }
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) sparse_component_mut_value(Entity component, Entity entity) {
        using U = typename actual_type_t<T>::Type;
        const auto it = m_sparseComponentsByComp.find(EntityLookupKey(component));
        GAIA_ASSERT(it != m_sparseComponentsByComp.end());
        return *(U*)it->second.func_mut(it->second.pStore, entity);
      }
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) sparse_component_get_value(Entity component, Entity entity) const {
        using U = typename actual_type_t<T>::Type;
        const auto it = m_sparseComponentsByComp.find(EntityLookupKey(component));
        GAIA_ASSERT(it != m_sparseComponentsByComp.end());
        return *(const U*)it->second.func_get(it->second.pStore, entity);
      }
 
      GAIA_NODISCARD const SparseComponentStoreErased* sparse_component_store_erased(Entity component) const {
        const auto it = m_sparseComponentsByComp.find(EntityLookupKey(component));
        return it != m_sparseComponentsByComp.end() ? &it->second : nullptr;
      }
 
      GAIA_NODISCARD SparseComponentStoreErased&
      sparse_component_store_erased_mut(Entity component, const ComponentCacheItem& item) {
        const auto key = EntityLookupKey(component);
        const auto it = m_sparseComponentsByComp.find(key);
        if (it != m_sparseComponentsByComp.end())
          return it->second;
        if (item.func_create_sparse_store != nullptr) {
          item.func_create_sparse_store(*this, component);
          return m_sparseComponentsByComp.find(key)->second;
        }
 
        auto* pStore = new RuntimeSparseComponentStore(item);
        return m_sparseComponentsByComp.emplace(key, make_sparse_component_store_erased(pStore)).first->second;
      }
 
      void finish_sparse_component_add_inter(Entity entity, Entity object, SparseStorageMode mode) {
        GAIA_ASSERT(mode != SparseStorageMode::None);
 
#if GAIA_OBSERVERS_ENABLED
        auto ctx =
            m_observers.prepare_diff(*this, ObserverEvent::OnAdd, EntitySpan{&object, 1}, EntitySpan{&entity, 1});
#endif
        if (mode == SparseStorageMode::Fragmenting) {
          GAIA_ASSERT(!locked());
          EntityBuilder eb(*this, entity);
          eb.add_inter_init(object);
          eb.commit();
        }
 
        notify_add_single(entity, object);
#if GAIA_OBSERVERS_ENABLED
        m_observers.finish_diff(*this, GAIA_MOV(ctx));
#endif
      }
 
      void del_sparse_components(Entity entity) {
        for (auto& [compKey, store]: m_sparseComponentsByComp) {
          (void)compKey;
          store.func_del(store.pStore, entity);
        }
      }
 
      void del_sparse_component_store(Entity component) {
        const auto it = m_sparseComponentsByComp.find(EntityLookupKey(component));
        if (it == m_sparseComponentsByComp.end())
          return;
 
        it->second.func_clear_store(it->second.pStore);
        it->second.func_del_store(it->second.pStore);
        m_sparseComponentsByComp.erase(it);
      }
 
      GAIA_NODISCARD const NonFragmentingRelationStore* nonfragmenting_relation_store(Entity relation) const {
        const auto it = m_nonFragmentingRelationsByRel.find(EntityLookupKey(relation));
        if (it == m_nonFragmentingRelationsByRel.end())
          return nullptr;
 
        return &it->second;
      }
 
      GAIA_NODISCARD NonFragmentingRelationStore& nonfragmenting_relation_store_mut(Entity relation) {
        return m_nonFragmentingRelationsByRel[EntityLookupKey(relation)];
      }
 
      void
      nonfragmenting_relation_set(NonFragmentingRelationStore& store, Entity source, Entity relation, Entity target) {
        GAIA_ASSERT(relation_uses_non_fragmenting_storage(relation));
        if (store.set(source, target))
          invalidate_relation_caches(relation);
      }
 
      void nonfragmenting_relation_set(Entity source, Entity relation, Entity target) {
        auto& store = nonfragmenting_relation_store_mut(relation);
        nonfragmenting_relation_set(store, source, relation, target);
      }
 
      bool nonfragmenting_relation_del(Entity source, Entity relation, Entity target) {
        const auto itStore = m_nonFragmentingRelationsByRel.find(EntityLookupKey(relation));
        if (itStore == m_nonFragmentingRelationsByRel.end())
          return false;
 
        auto& store = itStore->second;
        if (!store.remove(source, target))
          return false;
 
        if (store.empty())
          m_nonFragmentingRelationsByRel.erase(itStore);
 
        invalidate_relation_caches(relation);
 
        return true;
      }
 
      GAIA_NODISCARD bool has_nonfragmenting_relation_pair(Entity source, Entity object) const {
        if (!object.pair())
          return false;
 
        const auto relId = object.id();
        const auto tgtId = object.gen();
 
        if (relId != All.id()) {
          const auto relation = get(relId);
          if (!relation_uses_non_fragmenting_storage(relation))
            return false;
 
          const auto* pStore = nonfragmenting_relation_store(relation);
          if (pStore == nullptr)
            return false;
 
          const auto target = pStore->target(source);
          if (target == EntityBad)
            return false;
 
          return tgtId == All.id() || target.id() == tgtId;
        }
 
        if (tgtId == All.id()) {
          for (const auto& it: m_nonFragmentingRelationsByRel) {
            if (it.second.target(source) != EntityBad)
              return true;
          }
          return false;
        }
 
        const auto target = get(tgtId);
        for (const auto& it: m_nonFragmentingRelationsByRel) {
          if (it.second.target(source) == target)
            return true;
        }
 
        return false;
      }
 
      void del_nonfragmenting_relation_source(Entity source) {
        cnt::darray<Entity> relations;
        for (const auto& it: m_nonFragmentingRelationsByRel) {
          const auto relation = it.first.entity();
          if (it.second.target(source) != EntityBad)
            relations.push_back(relation);
        }
        if (relations.empty())
          return;
 
        for (auto relation: relations) {
          touch_rel_version(relation);
          invalidate_queries_for_rel(relation);
          (void)nonfragmenting_relation_del(source, relation, EntityBad);
        }
        clear_relation_caches();
      }
 
#if GAIA_OBSERVERS_ENABLED
      void del_nonfragmenting_relation_source_observed(Entity source) {
        if (!m_observers.has_on_del_observers())
          return;
 
        cnt::darray<Entity> pairs;
        for (const auto& it: m_nonFragmentingRelationsByRel) {
          const auto relation = it.first.entity();
          const auto target = it.second.target(source);
          if (target != EntityBad)
            pairs.push_back(Pair(relation, target));
        }
        if (pairs.empty())
          return;
 
        const auto& ec = fetch(source);
        for (auto pair: pairs) {
          const auto relation = try_get(pair.id());
          const auto target = try_get(pair.gen());
          if (relation == EntityBad || target == EntityBad)
            continue;
 
          const Entity object = Pair(relation, target);
          auto delDiffCtx =
              m_observers.prepare_diff(*this, ObserverEvent::OnDel, EntitySpan{&object, 1}, EntitySpan{&source, 1});
          if (nonfragmenting_relation_del(source, relation, target))
            m_observers.on_del(*this, *ec.pArchetype, EntitySpan{&object, 1}, EntitySpan{&source, 1});
          m_observers.finish_diff(*this, GAIA_MOV(delDiffCtx));
        }
      }
#endif
 
      void del_nonfragmenting_relation(Entity relation) {
        const auto itStore = m_nonFragmentingRelationsByRel.find(EntityLookupKey(relation));
        if (itStore == m_nonFragmentingRelationsByRel.end())
          return;
 
        cnt::darray<EntityId> sourceIds;
        itStore->second.collect_source_ids(sourceIds);
 
        touch_rel_version(relation);
        invalidate_queries_for_rel(relation);
        for (auto sourceId: sourceIds)
          (void)nonfragmenting_relation_del(get(sourceId), relation, EntityBad);
        clear_relation_caches();
      }
 
      GAIA_NODISCARD bool has_nonfragmenting_relation_target_cond(Entity target, Pair cond) const {
        for (const auto& [relKey, store]: m_nonFragmentingRelationsByRel) {
          if (store.sources(target) == nullptr)
            continue;
 
          if (has(relKey.entity(), cond))
            return true;
        }
 
        return false;
      }
 
      //----------------------------------------------------------------------
 
      void set_serializer(std::nullptr_t) {
        // Always use the binary serializer as the default.
        m_serializer = ser::make_serializer(m_stream);
      }
 
      void set_serializer(ser::serializer serializer) {
        GAIA_ASSERT(serializer.valid());
        m_serializer = serializer;
      }
 
      template <typename TSerializer>
      void set_serializer(TSerializer& serializer) {
        set_serializer(ser::make_serializer(serializer));
      }
 
      ser::serializer get_serializer() const {
        return m_serializer;
      }
 
      //----------------------------------------------------------------------
 
      struct EntityBuilder final {
        friend class World;
 
        World& m_world;
        Archetype* m_pArchetypeSrc = nullptr;
        Chunk* m_pChunkSrc = nullptr;
        uint32_t m_rowSrc = 0;
        Archetype* m_pArchetype = nullptr;
        EntityNameLookupKey m_targetNameKey;
        EntityNameLookupKey m_targetAliasKey;
        Entity m_entity;
        using RelationMutationPath = detail::RelationMutationPath;
 
#if GAIA_ENABLE_ADD_DEL_HOOKS || GAIA_OBSERVERS_ENABLED
        static constexpr uint32_t MAX_TERMS = 32;
        static_assert(MAX_TERMS <= ChunkHeader::MAX_COMPONENTS);
 
        cnt::sarray_ext<Entity, MAX_TERMS> tl_new_comps;
        cnt::sarray_ext<Entity, MAX_TERMS> tl_del_comps;
#endif
 
#if GAIA_OBSERVERS_ENABLED
        cnt::sarray_ext<Entity, MAX_TERMS> tl_del_nonfragmenting_relations;
#endif
 
        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& 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);
#if GAIA_OBSERVERS_ENABLED
            const bool hasOnDelObservers = !tl_del_comps.empty() && m_world.m_observers.has_on_del_observers();
            const bool hasOnAddObservers = !tl_new_comps.empty() && m_world.m_observers.has_on_add_observers();
            auto delDiffCtx = !hasOnDelObservers ? ObserverRegistry::DiffDispatchCtx{}
                                                 : m_world.m_observers.prepare_diff(
                                                       m_world, ObserverEvent::OnDel, EntitySpan{tl_del_comps},
                                                       EntitySpan{&m_entity, 1});
            auto addDiffCtx = !hasOnAddObservers ? ObserverRegistry::DiffDispatchCtx{}
                                                 : m_world.m_observers.prepare_diff(
                                                       m_world, ObserverEvent::OnAdd, EntitySpan{tl_new_comps},
                                                       EntitySpan{&m_entity, 1});
#endif
 
#if GAIA_OBSERVERS_ENABLED
            if (hasOnDelObservers)
              flush_del_nonfragmenting_relations();
#endif
 
            // Trigger remove hooks if there are any
            trigger_del_hooks(*m_pArchetype);
 
            // Now that we have the final archetype move the entity to it
            m_world.move_entity_raw(m_entity, ec, *m_pArchetype);
 
            if (m_targetNameKey.str() != nullptr || m_targetAliasKey.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));
 
              // Update the entity name string pointers if necessary
              if (m_targetNameKey.str() != nullptr) {
                pDesc->name = m_targetNameKey.str();
                pDesc->name_len = m_targetNameKey.len();
              }
 
              // Update the entity alias string pointers if necessary
              if (m_targetAliasKey.str() != nullptr) {
                pDesc->alias = m_targetAliasKey.str();
                pDesc->alias_len = m_targetAliasKey.len();
              }
            }
 
            // Trigger add hooks if there are any
            trigger_add_hooks(*m_pArchetype);
#if GAIA_OBSERVERS_ENABLED
            if (hasOnDelObservers)
              m_world.m_observers.finish_diff(m_world, GAIA_MOV(delDiffCtx));
            if (hasOnAddObservers)
              m_world.m_observers.finish_diff(m_world, GAIA_MOV(addDiffCtx));
#endif
            cleanup_deleted_sparse_components();
 
            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
 
#if GAIA_OBSERVERS_ENABLED
            const bool hasOnDelObservers = !tl_del_comps.empty() && m_world.m_observers.has_on_del_observers();
            const bool hasOnAddObservers = !tl_new_comps.empty() && m_world.m_observers.has_on_add_observers();
            auto delDiffCtx = !hasOnDelObservers ? ObserverRegistry::DiffDispatchCtx{}
                                                 : m_world.m_observers.prepare_diff(
                                                       m_world, ObserverEvent::OnDel, EntitySpan{tl_del_comps},
                                                       EntitySpan{&m_entity, 1});
            auto addDiffCtx = !hasOnAddObservers ? ObserverRegistry::DiffDispatchCtx{}
                                                 : m_world.m_observers.prepare_diff(
                                                       m_world, ObserverEvent::OnAdd, EntitySpan{tl_new_comps},
                                                       EntitySpan{&m_entity, 1});
#endif
 
#if GAIA_OBSERVERS_ENABLED
            if (hasOnDelObservers)
              flush_del_nonfragmenting_relations();
#endif
 
            if (m_targetNameKey.str() != nullptr || m_targetAliasKey.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));
 
              // Update the entity name string pointers if necessary
              if (m_targetNameKey.str() != nullptr) {
                pDesc->name = m_targetNameKey.str();
                pDesc->name_len = m_targetNameKey.len();
              }
 
              // Update the entity alias string pointers if necessary
              if (m_targetAliasKey.str() != nullptr) {
                pDesc->alias = m_targetAliasKey.str();
                pDesc->alias_len = m_targetAliasKey.len();
              }
            }
 
#if GAIA_OBSERVERS_ENABLED
            if (hasOnDelObservers)
              m_world.m_observers.on_del(m_world, *m_pArchetypeSrc, EntitySpan{tl_del_comps}, EntitySpan{&m_entity, 1});
            if (hasOnAddObservers)
              m_world.m_observers.on_add(m_world, *m_pArchetypeSrc, EntitySpan{tl_new_comps}, EntitySpan{&m_entity, 1});
            if (hasOnDelObservers)
              m_world.m_observers.finish_diff(m_world, GAIA_MOV(delDiffCtx));
            if (hasOnAddObservers)
              m_world.m_observers.finish_diff(m_world, GAIA_MOV(addDiffCtx));
#endif
            cleanup_deleted_sparse_components();
          }
 
          // Finalize the builder by reseting the archetype pointer
          m_pArchetype = nullptr;
          m_targetNameKey = {};
          m_targetAliasKey = {};
        }
 
        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 alias(const char* alias, uint32_t len = 0) {
          alias_inter<true>(alias, len);
        }
 
        void alias_raw(const char* alias, uint32_t len = 0) {
          alias_inter<false>(alias, len);
        }
 
        void del_name() {
          if (m_entity.pair())
            return;
 
          // The following block is essentially the same as this but without the archetype pointer access:
          // const auto compIdx = core::get_index(m_pArchetypeSrc->ids_view(), GAIA_ID(EntityDesc));
          const auto compIdx = core::get_index(m_pChunkSrc->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;
          }
 
          // TODO: Trigger the hooks/observers manually here? I do not like essentially calling comp_ptr twice here.
          //       The second one could be replaced with const cast + emit.
          //  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_name_inter(EntityNameLookupKey(pDesc->name, pDesc->name_len, 0));
          m_world.invalidate_scope_path_cache();
 
          pDesc->name = nullptr;
          pDesc->name_len = 0;
          if (pDesc->alias == nullptr)
            del_inter(GAIA_ID(EntityDesc));
 
          m_targetNameKey = {};
        }
 
        void del_alias() {
          if (m_entity.pair())
            return;
 
          // The following block is essentially the same as this but without the archetype pointer access:
          // const auto compIdx = core::get_index(m_pArchetypeSrc->ids_view(), GAIA_ID(EntityDesc));
          const auto compIdx = core::get_index(m_pChunkSrc->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->alias == nullptr)
              return;
          }
 
          // TODO: Trigger the hooks/observers manually here? I do not like essentially calling comp_ptr twice here.
          //       The second one could be replaced with const cast + emit.
          //  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_alias_inter(EntityNameLookupKey(pDesc->alias, pDesc->alias_len, 0));
 
          pDesc->alias = nullptr;
          pDesc->alias_len = 0;
          if (pDesc->name == nullptr)
            del_inter(GAIA_ID(EntityDesc));
 
          m_targetAliasKey = {};
        }
 
        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));
        }
 
        EntityBuilder& prefab() {
          return add(Prefab);
        }
 
        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.template reg_comp<typename T::rel>().entity;
            const auto tgt = m_world.template reg_comp<typename T::tgt>().entity;
            const Entity ent = Pair(rel, tgt);
            add_inter(ent);
            return ent;
          } else {
            return m_world.template reg_comp<T>().entity;
          }
        }
 
        template <typename T>
        EntityBuilder& add() {
          verify_comp<T>();
          add(register_component<T>());
          return *this;
        }
 
        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;
        }
 
        template <typename T>
        EntityBuilder& del() {
          verify_comp<T>();
          del(register_component<T>());
          return *this;
        }
 
      private:
        void trigger_add_hooks(const Archetype& newArchetype) {
#if GAIA_ENABLE_ADD_DEL_HOOKS || GAIA_OBSERVERS_ENABLED
          if GAIA_UNLIKELY (m_world.tearing_down()) {
            tl_new_comps.clear();
            (void)newArchetype;
            return;
          }
 
          m_world.lock();
 
  #if GAIA_ENABLE_ADD_DEL_HOOKS
          // if (hookCnt > 0)
          {
            // Trigger component hooks first
            for (auto entity: tl_new_comps) {
              const auto* pItem = m_world.component_item(m_entity, entity);
              if (pItem == nullptr)
                continue;
              const auto& hooks = ComponentCache::hooks(*pItem);
              if (hooks.func_add != nullptr)
                hooks.func_add(m_world, *pItem, m_entity);
            }
          }
  #endif
 
  #if GAIA_OBSERVERS_ENABLED
          // Trigger observers second
          if (m_world.m_observers.has_on_add_observers())
            m_world.m_observers.on_add(m_world, newArchetype, std::span<Entity>{tl_new_comps}, {&m_entity, 1});
  #else
          (void)newArchetype;
  #endif
 
          tl_new_comps.clear();
 
          m_world.unlock();
#endif
        }
 
        void trigger_del_hooks(const Archetype& newArchetype) {
#if GAIA_ENABLE_ADD_DEL_HOOKS || GAIA_OBSERVERS_ENABLED
          if GAIA_UNLIKELY (m_world.tearing_down()) {
            tl_del_comps.clear();
            (void)newArchetype;
            return;
          }
 
          m_world.notify_inherited_del_dependents(m_entity, std::span<Entity>{tl_del_comps});
          m_world.lock();
 
  #if GAIA_OBSERVERS_ENABLED
          // Trigger observers first
          if (m_world.m_observers.has_on_del_observers())
            m_world.m_observers.on_del(m_world, newArchetype, std::span<Entity>{tl_del_comps}, {&m_entity, 1});
  #else
          (void)newArchetype;
  #endif
 
  #if GAIA_ENABLE_ADD_DEL_HOOKS
          // if (hookCnt > 0)
          {
            // Trigger component hooks second
            for (auto entity: tl_del_comps) {
              const auto* pItem = m_world.component_item(m_entity, entity);
              if (pItem == nullptr)
                continue;
              const auto& hooks = ComponentCache::hooks(*pItem);
              if (hooks.func_del != nullptr)
                hooks.func_del(m_world, *pItem, m_entity);
            }
          }
  #endif
 
          m_world.unlock();
#endif
        }
 
        void cleanup_deleted_sparse_components() {
          for (auto entity: tl_del_comps) {
            if (entity.pair() || !m_world.component_uses_sparse_storage(entity) ||
                m_world.component_is_non_fragmenting(entity))
              continue;
 
            const auto it = m_world.m_sparseComponentsByComp.find(EntityLookupKey(entity));
            if (it != m_world.m_sparseComponentsByComp.end())
              it->second.func_del(it->second.pStore, m_entity);
          }
 
          tl_del_comps.clear();
        }
 
#if GAIA_OBSERVERS_ENABLED
        void flush_del_nonfragmenting_relations() {
          for (auto entity: tl_del_nonfragmenting_relations)
            del_nonfragmenting_relation_id(entity);
          tl_del_nonfragmenting_relations.clear();
        }
#endif
 
        bool handle_add_entity(Entity entity, RelationMutationPath relationPath) {
          cnt::sarray_ext<Entity, ChunkHeader::MAX_COMPONENTS> targets;
          const bool isPair = entity.pair();
          GAIA_ASSERT(isPair || relationPath == RelationMutationPath::Fragmenting);
 
          if (isPair)
            m_world.invalidate_scope_path_cache();
 
          // Handle entity combinations that can't be together
          if (m_world.m_hasCantCombinePolicy) {
            const auto& ecMain = m_world.fetch(entity);
            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 archetype-backed exclusive pairs. Exclusive non-fragmenting relations replace their target in
          // non-fragmenting relation storage and never need archetype-pair replacement checks.
          if (isPair && relationPath != RelationMutationPath::NonFragmentingExclusive) {
            // 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 && m_pArchetype->pairs() != 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.try_get(entity.gen());
              if (tgt == EntityBad)
                return false;
 
              const auto targetsCntMax = m_pArchetype->pair_matches(Pair(rel, All));
              if (targetsCntMax > 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;
              }
 
              if (targetsCntMax == 1) {
                // Make sure to remove the (rel, tgt0) so only the new (rel, tgt1) remains.
                targets.clear();
                m_world.targets_if(m_entity, rel, [&targets](Entity target) {
                  targets.push_back(target);
                  return false;
                });
 
                GAIA_ASSERT(targets.size() <= 1);
                if (!targets.empty() && tgt != targets[0]) {
                  // 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, targets[0]));
                }
              }
            }
          }
 
          // Handle requirements
          if (m_world.m_hasRequiresPolicy) {
            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) {
                const auto requiredPath = e.pair() ? relation_mutation_path_add(e) : RelationMutationPath::Fragmenting;
                handle_add_entity(e, requiredPath);
              }
            }
          }
 
          return true;
        }
 
        GAIA_NODISCARD bool has_Requires_tgt(Entity entity) const {
          if (!m_world.m_hasRequiresPolicy)
            return false;
 
          // 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) {
          if (entity.pair()) {
            if (entity.id() == Is.id()) {
              auto& ec = m_world.fetch(entity);
              try_set_Is(ec, entity, enable);
            }
 
            if (entity.id() == CantCombine.id() || entity.id() == OnDelete.id() || entity.id() == OnDeleteTarget.id()) {
              auto& ecMain = m_world.fetch(m_entity);
              try_set_CantCombine(ecMain, entity, enable);
              try_set_OnDelete(ecMain, entity, enable);
              try_set_OnDeleteTargetPolicy(ecMain, entity, enable);
            }
            if (enable && entity.id() == Requires.id())
              m_world.m_hasRequiresPolicy = true;
 
            if (m_world.m_hasOnDeleteTargetPolicy)
              try_set_OnDeleteTarget(entity, enable);
            return;
          }
 
          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);
          if (enable)
            try_set_sticky_component_traits(ecMain, entity);
          try_set_IsSingleton(ecMain, entity, enable);
          try_set_OnDelete(ecMain, entity, enable);
          try_set_OnDeleteTargetPolicy(ecMain, 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) {
            m_world.m_hasCantCombinePolicy = true;
            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_sticky_component_traits(EntityContainer& ecMain, Entity entity) {
          if (entity.pair())
            return;
 
          if (entity.id() == DontFragment.id()) {
            m_world.set_component_dont_fragment(m_entity, ecMain);
            return;
          }
 
          if (entity.id() == Sparse.id())
            m_world.set_component_sparse_storage(m_entity);
        }
 
        GAIA_NODISCARD RelationMutationPath relation_mutation_path(Entity entity) const noexcept {
          GAIA_ASSERT(entity.pair());
 
          return relation_mutation_path_from_flags(m_world.fetch(m_world.get(entity.id())).flags);
        }
 
        GAIA_NODISCARD RelationMutationPath relation_mutation_path_add(Entity entity) const noexcept {
          GAIA_ASSERT(entity.pair());
 
          const auto& ecRel = m_world.m_recs.entities[entity.id()];
          return relation_mutation_path_from_flags(ecRel.flags);
        }
 
        GAIA_NODISCARD static RelationMutationPath
        relation_mutation_path_from_flags(EntityContainerFlagsType flags) noexcept {
          const auto nonFragmentingExclusiveFlags =
              EntityContainerFlags::IsExclusive | EntityContainerFlags::IsDontFragment;
          if ((flags & nonFragmentingExclusiveFlags) == nonFragmentingExclusiveFlags)
            return RelationMutationPath::NonFragmentingExclusive;
 
          if ((flags & EntityContainerFlags::IsDontFragment) == 0)
            return RelationMutationPath::Fragmenting;
 
          return RelationMutationPath::NonFragmentingArchetypePair;
        }
 
        GAIA_NODISCARD bool has_archetype_id(Entity entity) const {
          return m_pArchetype->has(entity);
        }
 
        GAIA_NODISCARD bool has_nonfragmenting_relation_id(Entity entity) const {
          GAIA_ASSERT(entity.pair());
          return m_world.has_nonfragmenting_relation_pair(m_entity, entity);
        }
 
        GAIA_NODISCARD bool has_nonfragmenting_archetype_pair_id(Entity entity) const {
          GAIA_ASSERT(entity.pair());
          return has_archetype_id(entity);
        }
 
        void add_archetype_id(Entity entity) {
          m_pArchetype = m_world.foc_archetype_add_no_graph(m_pArchetype, entity);
        }
 
        GAIA_NODISCARD bool add_id(Entity entity) {
          add_archetype_id(entity);
          return true;
        }
 
        void del_nonfragmenting_relation_id(Entity entity) {
          GAIA_ASSERT(entity.pair());
 
          const auto relation = m_world.try_get(entity.id());
          const auto target = m_world.try_get(entity.gen());
          if (relation != EntityBad && target != EntityBad)
            (void)m_world.nonfragmenting_relation_del(m_entity, relation, target);
        }
 
        void del_archetype_id(Entity entity) {
          m_pArchetype = m_world.foc_archetype_del_no_graph(m_pArchetype, entity);
        }
 
        void del_id(Entity entity) {
          del_archetype_id(entity);
        }
 
        void try_set_OnDeleteTargetPolicy(EntityContainer& ec, Entity entity, bool enable) {
          if (entity == Pair(OnDeleteTarget, Delete))
            set_flag(ec.flags, EntityContainerFlags::OnDeleteTarget_Delete, enable);
          else if (entity == Pair(OnDeleteTarget, Remove))
            set_flag(ec.flags, EntityContainerFlags::OnDeleteTarget_Remove, enable);
          else if (entity == Pair(OnDeleteTarget, Error))
            set_flag(ec.flags, EntityContainerFlags::OnDeleteTarget_Error, enable);
          else
            return;
 
          if (enable)
            m_world.m_hasOnDeleteTargetPolicy = true;
        }
 
        void try_set_OnDeleteTarget(Entity entity, bool enable) {
          if (!entity.pair())
            return;
 
          if (enable) {
            GAIA_ASSERT(m_world.valid(m_world.get(entity.id())));
            GAIA_ASSERT(m_world.valid(m_world.get(entity.gen())));
 
            const auto& ecRel = m_world.m_recs.entities[entity.id()];
            const auto policyFlags = ecRel.flags & (EntityContainerFlags::OnDeleteTarget_Delete |
                                                    EntityContainerFlags::OnDeleteTarget_Remove |
                                                    EntityContainerFlags::OnDeleteTarget_Error);
            if (policyFlags == 0)
              return;
 
            auto& ecTgt = m_world.m_recs.entities[entity.gen()];
            if ((policyFlags & EntityContainerFlags::OnDeleteTarget_Delete) != 0)
              set_flag(ecTgt.flags, EntityContainerFlags::OnDeleteTarget_Delete, true);
            else if ((policyFlags & EntityContainerFlags::OnDeleteTarget_Remove) != 0)
              set_flag(ecTgt.flags, EntityContainerFlags::OnDeleteTarget_Remove, true);
            else if ((policyFlags & EntityContainerFlags::OnDeleteTarget_Error) != 0)
              set_flag(ecTgt.flags, EntityContainerFlags::OnDeleteTarget_Error, true);
            return;
          }
 
          const auto rel = m_world.try_get(entity.id());
          if (rel == EntityBad)
            return;
 
          const auto& ecRel = m_world.fetch(rel);
          const auto policyFlags =
              ecRel.flags & (EntityContainerFlags::OnDeleteTarget_Delete | EntityContainerFlags::OnDeleteTarget_Remove |
                             EntityContainerFlags::OnDeleteTarget_Error);
          if (policyFlags == 0)
            return;
 
          const auto tgt = m_world.try_get(entity.gen());
          if (tgt == EntityBad)
            return;
 
          // Adding a pair to an entity with OnDeleteTarget relationship.
          // We need to update the target entity's flags.
          if ((policyFlags & EntityContainerFlags::OnDeleteTarget_Delete) != 0)
            set_flag(tgt, EntityContainerFlags::OnDeleteTarget_Delete, enable);
          else if ((policyFlags & EntityContainerFlags::OnDeleteTarget_Remove) != 0)
            set_flag(tgt, EntityContainerFlags::OnDeleteTarget_Remove, enable);
          else if ((policyFlags & EntityContainerFlags::OnDeleteTarget_Error) != 0)
            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.uquery();
          //  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.uquery();
          //  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;
          // }
        }
 
        void invalidate_relation_change(Entity entity) {
          GAIA_ASSERT(entity.pair());
 
          auto relation = m_world.m_recs.entities.handle(entity.id());
          m_world.invalidate_relation_caches(relation);
        }
 
        GAIA_NODISCARD bool link_is_relation(Entity entity) {
          GAIA_ASSERT(entity.pair());
 
          if (entity.id() != Is.id())
            return true;
 
          auto e = m_world.try_get(entity.gen());
          if (e == EntityBad)
            return false;
 
          EntityLookupKey entityKey(m_entity);
          EntityLookupKey eKey(e);
 
          // m_entity -> {..., e}
          auto& entity_to_e = m_world.m_entityToAsTargets[entityKey];
          entity_to_e.insert(eKey);
          m_world.m_entityToAsTargetsTravCache = {};
          // e -> {..., m_entity}
          auto& e_to_entity = m_world.m_entityToAsRelations[eKey];
          e_to_entity.insert(entityKey);
          m_world.m_entityToAsRelationsTravCache = {};
 
          // 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});
          return true;
        }
 
        void unlink_is_relation(Entity entity) {
          GAIA_ASSERT(entity.pair());
 
          if (entity.id() != Is.id())
            return;
 
          auto e = m_world.try_get(entity.gen());
          if (e != EntityBad)
            m_world.unlink_live_is_relation(m_entity, e);
        }
 
        template <bool IsBootstrap>
        void finish_add_id(Entity entity) {
          if constexpr (!IsBootstrap) {
            handle_DependsOn(entity, true);
 
#if GAIA_ENABLE_ADD_DEL_HOOKS || GAIA_OBSERVERS_ENABLED
            tl_new_comps.push_back(entity);
#endif
          }
        }
 
        void finish_del_id(Entity entity) {
#if GAIA_ENABLE_ADD_DEL_HOOKS || GAIA_OBSERVERS_ENABLED
          tl_del_comps.push_back(entity);
#endif
        }
 
        template <bool IsBootstrap>
        bool handle_add(Entity entity) {
          if (entity.pair()) {
            const auto relationPath = relation_mutation_path_add(entity);
            if (relationPath == RelationMutationPath::NonFragmentingExclusive)
              return handle_add_nonfragmenting_relation<IsBootstrap>(entity);
 
            return handle_add_archetype_relation<IsBootstrap>(entity);
          }
 
#if GAIA_ASSERT_ENABLED
          World::verify_add(m_world, *m_pArchetype, m_entity, entity);
#endif
 
          // Don't add the same entity twice
          if (has_archetype_id(entity))
            return false;
 
          if (is_component_storage_trait(entity) && !m_world.can_add_component_storage_trait(m_entity))
            return false;
 
          try_set_flags(entity, true);
 
          if (!add_id(entity))
            return false;
 
          finish_add_id<IsBootstrap>(entity);
 
          return true;
        }
 
        template <bool IsBootstrap>
        bool handle_add_archetype_relation(Entity entity) {
          GAIA_ASSERT(entity.pair());
 
#if GAIA_ASSERT_ENABLED
          World::verify_add(m_world, *m_pArchetype, m_entity, entity);
#endif
 
          // Don't add the same pair twice.
          if (has_archetype_id(entity))
            return false;
 
          invalidate_relation_change(entity);
 
          try_set_flags(entity, true);
          if (!link_is_relation(entity))
            return false;
 
          add_archetype_id(entity);
          finish_add_id<IsBootstrap>(entity);
          return true;
        }
 
        template <bool IsBootstrap>
        bool handle_add_nonfragmenting_relation(Entity entity) {
          GAIA_ASSERT(entity.pair());
 
          // Don't add the same pair twice.
          if (has_nonfragmenting_relation_id(entity))
            return false;
 
          const auto relation = m_world.try_get(entity.id());
          const auto target = m_world.try_get(entity.gen());
          if (relation == EntityBad || target == EntityBad)
            return false;
 
          const auto* pStore = m_world.nonfragmenting_relation_store(relation);
          const auto oldTarget = pStore != nullptr ? pStore->target(m_entity) : EntityBad;
          if (oldTarget != EntityBad && oldTarget != target) {
            const auto oldPair = Pair(relation, oldTarget);
            invalidate_relation_change(oldPair);
            try_set_flags(oldPair, false);
            handle_DependsOn(oldPair, false);
            unlink_is_relation(oldPair);
            finish_del_id(oldPair);
          }
 
          invalidate_relation_change(entity);
 
          try_set_flags(entity, true);
          if (!link_is_relation(entity))
            return false;
 
          m_world.nonfragmenting_relation_set(m_entity, relation, target);
 
          finish_add_id<IsBootstrap>(entity);
 
          return true;
        }
 
        void handle_del(Entity entity) {
          if (entity.pair() && !m_world.valid(entity)) {
            if (m_pArchetype->has(entity)) {
              const auto relation = m_world.try_get(entity.id());
              if (relation != EntityBad) {
                m_world.invalidate_relation_caches(relation);
              }
 
              if (entity.id() == Is.id())
                m_world.unlink_stale_is_relations_by_target_id(m_entity, entity.gen());
 
              m_pArchetype = m_world.foc_archetype_del_no_graph(m_pArchetype, entity);
            }
            return;
          }
 
          if (entity.pair()) {
            m_world.invalidate_scope_path_cache();
 
            const auto relationPath = relation_mutation_path(entity);
            if (relationPath == RelationMutationPath::NonFragmentingExclusive)
              handle_del_nonfragmenting_relation(entity);
            else
              handle_del_archetype_relation(entity);
            return;
          }
 
#if GAIA_ASSERT_ENABLED
          World::verify_del(m_world, *m_pArchetype, m_entity, entity);
#endif
 
          // Don't delete what has not beed added
          if (!has_archetype_id(entity))
            return;
 
          try_set_flags(entity, false);
          handle_DependsOn(entity, false);
 
          del_id(entity);
          finish_del_id(entity);
        }
 
        void handle_del_archetype_relation(Entity entity) {
          GAIA_ASSERT(entity.pair());
 
#if GAIA_ASSERT_ENABLED
          World::verify_del(m_world, *m_pArchetype, m_entity, entity);
#endif
 
          // Don't delete what has not been added.
          if (!has_archetype_id(entity))
            return;
 
          invalidate_relation_change(entity);
 
          try_set_flags(entity, false);
          handle_DependsOn(entity, false);
          unlink_is_relation(entity);
 
          del_archetype_id(entity);
          finish_del_id(entity);
        }
 
        void handle_del_nonfragmenting_relation(Entity entity) {
          GAIA_ASSERT(entity.pair());
 
          // Don't delete what has not been added.
          if (!has_nonfragmenting_relation_id(entity))
            return;
 
          invalidate_relation_change(entity);
 
          try_set_flags(entity, false);
          handle_DependsOn(entity, false);
          unlink_is_relation(entity);
 
#if GAIA_OBSERVERS_ENABLED
          if (m_world.m_observers.has_on_del_observers())
            tl_del_nonfragmenting_relations.push_back(entity);
          else
#endif
            del_nonfragmenting_relation_id(entity);
          finish_del_id(entity);
        }
 
        GAIA_NODISCARD bool prepare_pair_add(Entity entity, RelationMutationPath relationPath) {
          GAIA_ASSERT(entity.pair());
 
          if (relationPath == RelationMutationPath::NonFragmentingExclusive) {
            if (has_nonfragmenting_relation_id(entity))
              return false;
          } else if (relationPath == RelationMutationPath::NonFragmentingArchetypePair) {
            if (has_nonfragmenting_archetype_pair_id(entity))
              return false;
          }
 
          // Make sure the entity container record exists if it is a pair.
          m_world.assign_pair(entity, *m_world.m_pEntityArchetype);
          return true;
        }
 
        void add_inter(Entity entity) {
          GAIA_ASSERT(!is_wildcard(entity));
          const bool isPair = entity.pair();
          const auto relationPath = isPair ? relation_mutation_path_add(entity) : RelationMutationPath::Fragmenting;
 
          if (isPair && !prepare_pair_add(entity, relationPath))
            return;
 
          if (!handle_add_entity(entity, relationPath))
            return;
 
          if (isPair) {
            if (relationPath == RelationMutationPath::NonFragmentingExclusive)
              handle_add_nonfragmenting_relation<false>(entity);
            else
              handle_add_archetype_relation<false>(entity);
            return;
          }
 
          handle_add<false>(entity);
        }
 
        static void rebuild_graph_edge(Archetype* pArchetypeLeft, Archetype* pArchetypeRight, Entity entity) {
          pArchetypeLeft->del_graph_edge_right_local(entity);
          pArchetypeRight->del_graph_edge_left_local(entity);
          pArchetypeLeft->build_graph_edges(pArchetypeRight, entity);
        }
 
        static void ensure_graph_edge(Archetype* pArchetypeLeft, Archetype* pArchetypeRight, Entity entity) {
          const auto right = pArchetypeLeft->find_edge_right(entity);
          const auto left = pArchetypeRight->find_edge_left(entity);
          if (right.id == pArchetypeRight->id() && left.id == pArchetypeLeft->id())
            return;
 
          rebuild_graph_edge(pArchetypeLeft, pArchetypeRight, entity);
        }
 
        void add_inter_init(Entity entity) {
          GAIA_ASSERT(!is_wildcard(entity));
          const bool isPair = entity.pair();
          const auto relationPath = isPair ? relation_mutation_path_add(entity) : RelationMutationPath::Fragmenting;
 
          if (isPair && !prepare_pair_add(entity, relationPath))
            return;
 
          if (!handle_add_entity(entity, relationPath))
            return;
 
          if (isPair) {
            if (relationPath == RelationMutationPath::NonFragmentingExclusive)
              handle_add_nonfragmenting_relation<true>(entity);
            else
              handle_add_archetype_relation<true>(entity);
            return;
          }
 
          handle_add<true>(entity);
        }
 
        GAIA_NODISCARD static bool is_component_storage_trait(Entity entity) noexcept {
          return !entity.pair() && (entity.id() == DontFragment.id() || entity.id() == Sparse.id());
        }
 
        GAIA_NODISCARD bool can_del(Entity entity) const noexcept {
          if (!entity.pair() && m_world.has_direct(entity, Requires))
            return false;
          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_name_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);
          }
        }
 
        void del_alias_inter(EntityNameLookupKey key) {
          const auto it = m_world.m_aliasToEntity.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_aliasToEntity.end());
          if (it != m_world.m_aliasToEntity.end()) {
            // Release memory allocated for the string if we own it
            if (it->first.owned())
              mem::mem_free((void*)key.str());
 
            m_world.m_aliasToEntity.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 one
          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".
          GAIA_FOR(len) {
            const bool hasInvalidCharacter = name[i] == '.';
            GAIA_ASSERT(!hasInvalidCharacter && "Character '.' can't be used in entity names");
            if (hasInvalidCharacter)
              return;
          }
 
          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_name_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_name_inter(EntityNameLookupKey(pDesc->name, pDesc->name_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 && World::s_enableUniqueNameDuplicateAssert)
              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());
            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);
          }
 
          m_world.invalidate_scope_path_cache();
        }
 
        template <bool IsOwned>
        void alias_inter(const char* alias, uint32_t len) {
          GAIA_ASSERT(!m_entity.pair());
          if (m_entity.pair())
            return;
 
          // When nullptr is passed for the alias it means the user wants to delete the current one
          if (alias == nullptr) {
            GAIA_ASSERT(len == 0);
            del_alias();
            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".
          GAIA_FOR(len) {
            const bool hasInvalidCharacter = alias[i] == '.';
            GAIA_ASSERT(!hasInvalidCharacter && "Character '.' can't be used in entity aliases");
            if (hasInvalidCharacter)
              return;
          }
 
          EntityNameLookupKey key(
              alias, len == 0 ? (uint32_t)GAIA_STRLEN(alias, ComponentCacheItem::MaxNameLength) : len, IsOwned);
 
          auto it = m_world.m_aliasToEntity.find(key);
          if (it == m_world.m_aliasToEntity.end()) {
            // If we already had some alias, remove the pair from the map first.
            if (m_targetAliasKey.str() != nullptr) {
              del_alias_inter(m_targetAliasKey);
            } 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->alias != nullptr) {
                  del_alias_inter(EntityNameLookupKey(pDesc->alias, pDesc->alias_len, 0));
                  pDesc->alias = nullptr;
                }
              } else {
                // Make sure EntityDesc is added to the entity.
                add_inter(GAIA_ID(EntityDesc));
              }
            }
 
            it = m_world.m_aliasToEntity.emplace(key, m_entity).first;
          } else {
#if GAIA_ASSERT_ENABLED
            if (it->second != m_entity && World::s_enableUniqueNameDuplicateAssert)
              GAIA_ASSERT(false && "Trying to set non-unique alias for an entity");
#endif
 
            // Attempts to set the same alias again, or not a unique alias, will be dropped.
            return;
          }
 
          if constexpr (IsOwned) {
            // Allocate enough storage for the alias
            char* aliasStr = (char*)mem::mem_alloc(key.len() + 1);
            memcpy((void*)aliasStr, (const void*)alias, key.len());
            aliasStr[key.len()] = 0;
 
            m_targetAliasKey = EntityNameLookupKey(aliasStr, 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_targetAliasKey, m_entity));
            it->swap(p);
          } else {
            m_targetAliasKey = 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 Entity symbol(const char* symbol, uint32_t len = 0) const {
        if (symbol == nullptr || symbol[0] == 0)
          return EntityBad;
 
        const auto* pItem = comp_cache().symbol(symbol, len);
        return pItem != nullptr ? pItem->entity : EntityBad;
      }
 
      GAIA_NODISCARD util::str_view symbol(Entity component) const {
        const auto* pItem = comp_cache().find(component);
        return pItem != nullptr ? comp_cache().symbol_name(*pItem) : util::str_view{};
      }
 
      GAIA_NODISCARD Entity path(const char* path, uint32_t len = 0) const {
        if (path == nullptr || path[0] == 0)
          return EntityBad;
 
        const auto* pItem = comp_cache().path(path, len);
        return pItem != nullptr ? pItem->entity : EntityBad;
      }
 
      GAIA_NODISCARD util::str_view path(Entity component) const {
        const auto* pItem = comp_cache().find(component);
        return pItem != nullptr ? comp_cache().path_name(*pItem) : util::str_view{};
      }
 
      bool path(Entity component, const char* path, uint32_t len = 0) {
        auto* pItem = comp_cache_mut().find(component);
        return pItem != nullptr ? comp_cache_mut().path(*pItem, path, len) : false;
      }
 
      GAIA_NODISCARD Entity alias(const char* alias, uint32_t len = 0) const {
        if (alias == nullptr || alias[0] == 0)
          return EntityBad;
 
        const auto l = len == 0 ? (uint32_t)GAIA_STRLEN(alias, ComponentCacheItem::MaxNameLength) : len;
        GAIA_ASSERT(l < ComponentCacheItem::MaxNameLength);
        const auto it = m_aliasToEntity.find(EntityNameLookupKey(alias, l, 0));
        return it != m_aliasToEntity.end() ? it->second : EntityBad;
      }
 
      GAIA_NODISCARD util::str_view alias(Entity entity) const {
        if (entity.pair())
          return {};
 
        const auto& ec = m_recs.entities[entity.id()];
        const auto compIdx = core::get_index(ec.pChunk->ids_view(), GAIA_ID(EntityDesc));
        if (compIdx == BadIndex)
          return {};
 
        const auto* pDesc = reinterpret_cast<const EntityDesc*>(ec.pChunk->comp_ptr(compIdx, ec.row));
        GAIA_ASSERT(core::check_alignment(pDesc));
        return {pDesc->alias, pDesc->alias_len};
      }
 
      bool alias(Entity entity, const char* alias, uint32_t len = 0) {
        if (!valid(entity) || entity.pair())
          return false;
 
        const auto before = this->alias(entity);
        EntityBuilder(*this, entity).alias(alias, len);
        const auto after = this->alias(entity);
        if (alias == nullptr)
          return !before.empty() && after.empty();
 
        const auto l = len == 0 ? (uint32_t)GAIA_STRLEN(alias, ComponentCacheItem::MaxNameLength) : len;
        return after == util::str_view(alias, l);
      }
 
      bool alias_raw(Entity entity, const char* alias, uint32_t len = 0) {
        if (!valid(entity) || entity.pair())
          return false;
 
        const auto before = this->alias(entity);
        EntityBuilder(*this, entity).alias_raw(alias, len);
        const auto after = this->alias(entity);
        if (alias == nullptr)
          return !before.empty() && after.empty();
 
        const auto l = len == 0 ? (uint32_t)GAIA_STRLEN(alias, ComponentCacheItem::MaxNameLength) : len;
        return after == util::str_view(alias, l);
      }
 
      GAIA_NODISCARD util::str_view display_name(Entity entity) const {
        const auto* pItem = comp_cache().find(entity);
        if (pItem == nullptr)
          return {};
 
        const auto aliasValue = alias(entity);
        if (!aliasValue.empty())
          return aliasValue;
 
        const auto pathValue = path(entity);
        if (!pathValue.empty()) {
          const auto symbolEntity = symbol(pathValue.data(), pathValue.size());
          if (symbolEntity == EntityBad || symbolEntity == entity)
            return pathValue;
        }
 
        return symbol(entity);
      }
 
      //----------------------------------------------------------------------
 
    private:
      void invalidate_scope_path_cache() const {
        m_componentScopePathCache.clear();
        m_componentScopePathCacheEntity = EntityBad;
        m_componentScopePathCacheValid = false;
      }
 
      GAIA_NODISCARD bool build_scope_path(Entity scope, util::str& out) const {
        out.clear();
        if (!valid(scope) || scope.pair())
          return false;
 
        cnt::darray_ext<util::str_view, 16> segments;
        auto curr = scope;
        while (curr != EntityBad) {
          const auto currName = name(curr);
          if (currName.empty()) {
            out.clear();
            return false;
          }
 
          segments.push_back(currName);
          curr = target(curr, ChildOf);
        }
 
        if (segments.empty())
          return false;
 
        uint32_t totalLen = 0;
        for (auto segment: segments)
          totalLen += segment.size();
        totalLen += (uint32_t)segments.size() - 1;
 
        out.reserve(totalLen);
        for (uint32_t i = (uint32_t)segments.size(); i > 0; --i) {
          if (!out.empty())
            out.append('.');
          out.append(segments[i - 1]);
        }
 
        return true;
      }
 
      GAIA_NODISCARD bool current_scope_path(util::str& out) const {
        if (m_componentScope == EntityBad) {
          invalidate_scope_path_cache();
          out.clear();
          return false;
        }
 
        if (m_componentScopePathCacheValid && m_componentScopePathCacheEntity == m_componentScope) {
          out.assign(m_componentScopePathCache.view());
          return true;
        }
 
        if (!build_scope_path(m_componentScope, out)) {
          invalidate_scope_path_cache();
          return false;
        }
 
        m_componentScopePathCache.assign(out.view());
        m_componentScopePathCacheEntity = m_componentScope;
        m_componentScopePathCacheValid = true;
        return true;
      }
 
      GAIA_NODISCARD const ComponentCacheItem*
      find_comp_scope_chain_inter(Entity scopeEntity, const char* name, uint32_t len) const {
        if (scopeEntity == EntityBad)
          return nullptr;
 
        util::str scopePath;
        if (!build_scope_path(scopeEntity, scopePath))
          return nullptr;
 
        util::str scopedName;
        scopedName.reserve(scopePath.size() + 1 + len);
 
        while (!scopePath.empty()) {
          scopedName.clear();
          scopedName.append(scopePath.view());
          scopedName.append('.');
          scopedName.append(name, len);
 
          if (const auto* pItem = m_compCache.path(scopedName.data(), (uint32_t)scopedName.size()); pItem != nullptr)
            return pItem;
 
          const auto parentSepIdx = scopePath.view().find_last_of('.');
          if (parentSepIdx == BadIndex)
            break;
 
          scopePath.assign(util::str_view(scopePath.data(), parentSepIdx));
        }
 
        return nullptr;
      }
 
      void add_comp_scope_chain_hits_inter(
          cnt::darray<Entity>& out, Entity scopeEntity, const char* name, uint32_t len) const {
        if (scopeEntity == EntityBad)
          return;
 
        util::str scopePath;
        if (!build_scope_path(scopeEntity, scopePath))
          return;
 
        util::str scopedName;
        scopedName.reserve(scopePath.size() + 1 + len);
 
        while (!scopePath.empty()) {
          scopedName.clear();
          scopedName.append(scopePath.view());
          scopedName.append('.');
          scopedName.append(name, len);
 
          if (const auto* pItem = m_compCache.path(scopedName.data(), (uint32_t)scopedName.size()); pItem != nullptr)
            ComponentCache::push_unique_entity(out, pItem->entity);
 
          const auto parentSepIdx = scopePath.view().find_last_of('.');
          if (parentSepIdx == BadIndex)
            break;
 
          scopePath.assign(util::str_view(scopePath.data(), parentSepIdx));
        }
      }
 
      GAIA_NODISCARD const ComponentCacheItem* find_comp_lookup_inter(const char* name, uint32_t len) const {
        if (const auto* pItem = find_comp_scope_chain_inter(m_componentScope, name, len); pItem != nullptr)
          return pItem;
 
        for (const auto scopeEntity: m_componentLookupPath) {
          if (scopeEntity == m_componentScope)
            continue;
 
          if (const auto* pItem = find_comp_scope_chain_inter(scopeEntity, name, len); pItem != nullptr)
            return pItem;
        }
 
        return nullptr;
      }
 
      void add_comp_lookup_hits_inter(cnt::darray<Entity>& out, const char* name, uint32_t len) const {
        add_comp_scope_chain_hits_inter(out, m_componentScope, name, len);
        for (const auto scopeEntity: m_componentLookupPath) {
          if (scopeEntity == m_componentScope)
            continue;
 
          add_comp_scope_chain_hits_inter(out, scopeEntity, name, len);
        }
      }
 
      GAIA_NODISCARD const ComponentCacheItem*
      find_comp_exact_inter(const char* name, uint32_t len, bool isPath, bool isSymbol) const {
        if (const auto* pItem = m_compCache.symbol(name, len); pItem != nullptr)
          return pItem;
 
        if (!isPath) {
          if (const auto* pItem = m_compCache.path(name, len); pItem != nullptr)
            return pItem;
          if (!isSymbol) {
            if (const auto* pItem = m_compCache.short_symbol(name, len); pItem != nullptr)
              return pItem;
          }
        }
 
        return nullptr;
      }
 
      void add_comp_exact_hits_inter(
          cnt::darray<Entity>& out, const char* name, uint32_t len, bool isPath, bool isSymbol) const {
        if (const auto* pItem = m_compCache.symbol(name, len); pItem != nullptr)
          ComponentCache::push_unique_entity(out, pItem->entity);
 
        m_compCache.add_path_matches(out, util::str_view(name, len));
 
        if (out.empty() && !isPath && !isSymbol) {
          if (const auto* pItem = m_compCache.short_symbol(name, len); pItem != nullptr)
            ComponentCache::push_unique_entity(out, pItem->entity);
        }
      }
 
      GAIA_NODISCARD bool has_comp_lookup_ctx_inter() const noexcept {
        return m_componentScope != EntityBad || !m_componentLookupPath.empty();
      }
 
      GAIA_NODISCARD static bool is_unqualified_comp_name_inter(const char* name, uint32_t len) noexcept {
        return memchr(name, '.', len) == nullptr && memchr(name, ':', len) == nullptr;
      }
 
      GAIA_NODISCARD Entity pick_name_or_comp_inter(Entity namedEntity, const ComponentCacheItem* pCompItem) const {
        if (pCompItem == nullptr)
          return namedEntity;
 
        if (namedEntity == EntityBad)
          return pCompItem->entity;
 
        return m_compCache.find(namedEntity) != nullptr ? pCompItem->entity : namedEntity;
      }
 
      GAIA_NODISCARD const ComponentCacheItem* resolve_component_name_inter(const char* name, uint32_t len = 0) const {
        GAIA_ASSERT(name != nullptr);
 
        const auto l = len == 0 ? (uint32_t)GAIA_STRLEN(name, ComponentCacheItem::MaxNameLength) : len;
        GAIA_ASSERT(l < ComponentCacheItem::MaxNameLength);
        const bool isPath = memchr(name, '.', l) != nullptr;
        const bool isSymbol = memchr(name, ':', l) != nullptr;
 
        if (isPath) {
          if (const auto* pItem = m_compCache.path(name, l); pItem != nullptr)
            return pItem;
        }
 
        if (!isPath && !isSymbol) {
          if (const auto* pItem = find_comp_lookup_inter(name, l); pItem != nullptr)
            return pItem;
        }
 
        if (const auto* pItem = find_comp_exact_inter(name, l, isPath, isSymbol); pItem != nullptr)
          return pItem;
 
        const auto aliasEntity = alias(name, l);
        return aliasEntity != EntityBad ? m_compCache.find(aliasEntity) : nullptr;
      }
 
    public:
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD bool valid(Entity entity) const {
        return entity.pair() //
                   ? valid_pair(entity)
                   : valid_entity(entity);
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD Entity get(EntityId id) const {
        // Cleanup, observer propagation, and wildcard expansion can briefly encounter stale ids.
        // Treat those as absent instead of crashing the world.
        if (!valid_entity_id(id))
          return EntityBad;
 
        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);
      }
 
      GAIA_NODISCARD Entity try_get(EntityId id) const {
        return valid_entity_id(id) ? get(id) : EntityBad;
      }
 
      template <typename T>
      GAIA_NODISCARD Entity get() const {
        return comp_cache().get<T>().entity;
      }
 
      template <typename T>
      GAIA_NODISCARD const ComponentCacheItem& reg_comp() {
#if GAIA_ECS_AUTO_COMPONENT_REGISTRATION
        return add<T>();
#else
        return comp_cache().template get<T>();
#endif
      }
 
      //----------------------------------------------------------------------
 
      EntityBuilder build(Entity entity) {
        return EntityBuilder(*this, entity);
      }
 
      GAIA_NODISCARD Entity add(EntityKind kind = EntityKind::EK_Gen) {
        return add(*m_pEntityArchetype, true, false, kind);
      }
 
      GAIA_NODISCARD Entity prefab(EntityKind kind = EntityKind::EK_Gen) {
        const auto entity = add(kind);
        add(entity, Prefab);
        return entity;
      }
 
      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);
        util::str scopePath;
        (void)current_scope_path(scopePath);
 
        const auto& item = comp_cache_mut().add<FT>(entity, scopePath.view());
        item.func_create_sparse_store = [](World& world, Entity component) {
          (void)world.sparse_component_store_mut<FT>(component);
        };
        finalize_component_registration(item, item.comp.storage_type() == DataStorageType::Sparse);
        if constexpr (supports_sparse_component_storage<FT>()) {
          if (item.comp.storage_type() == DataStorageType::Sparse)
            (void)sparse_component_store_mut<FT>(item.entity);
        }
 
        return item;
      }
 
      template <typename T>
      GAIA_NODISCARD const ComponentCacheItem& add(const RuntimeTypeDesc& runtimeType) {
        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;
 
        validate_runtime_semantics(runtimeType);
        const auto entity = add(*m_pCompArchetype, false, false, kind);
        util::str scopePath;
        (void)current_scope_path(scopePath);
 
        const auto& item = comp_cache_mut().add<FT>(entity, runtimeType, scopePath.view());
        item.func_create_sparse_store = [](World& world, Entity component) {
          (void)world.sparse_component_store_mut<FT>(component);
        };
        finalize_component_registration(item, item.comp.storage_type() == DataStorageType::Sparse);
        if constexpr (supports_sparse_component_storage<FT>()) {
          if (item.comp.storage_type() == DataStorageType::Sparse)
            (void)sparse_component_store_mut<FT>(item.entity);
        }
 
        return item;
      }
 
      GAIA_NODISCARD ComponentCacheItem& add(const ComponentDesc& desc, EntityKind kind = EntityKind::EK_Gen) {
        GAIA_ASSERT(!desc.name.empty());
        GAIA_ASSERT(desc.name.size() < ComponentCacheItem::MaxNameLength);
 
        if (const auto* pItem = comp_cache().symbol(desc.name); pItem != nullptr)
          return *comp_cache_mut().find(pItem->entity);
 
        validate_runtime_semantics(desc.runtimeType);
        const auto entity = add(*m_pCompArchetype, false, false, kind);
        util::str scopePath;
        (void)current_scope_path(scopePath);
        auto& itemInfo = comp_cache_mut().add(entity, desc, scopePath.view());
        finalize_component_registration(itemInfo, true);
        return itemInfo;
      }
 
      void add(Entity entity, Entity object) {
#if GAIA_ASSERT_ENABLED
        if (!object.pair()) {
          const auto* pItem = comp_cache().find(object);
          if (pItem != nullptr && pItem->entity == object && component_uses_sparse_storage(object))
            GAIA_ASSERT2(
                false, "Out-of-line runtime components require an explicit typed value when added by entity id");
        }
#endif
        EntityBuilder(*this, entity).add(object);
      }
 
      void add(Entity entity, Pair pair) {
        auto& ec = m_recs.entities[entity.id()];
        EntityBuilder builder(*this, entity, ec);
        builder.add(pair);
        builder.commit();
      }
 
      template <typename T>
      void add(Entity entity) {
        using FT = typename component_type_t<T>::TypeFull;
        const auto& item = add<FT>();
        if constexpr (uses_compile_time_sparse_storage<FT>()) {
          (void)sparse_component_store_mut<FT>(item.entity).add(entity);
          finish_sparse_component_add_inter(entity, item.entity, compile_time_sparse_storage_mode(item.entity));
          return;
        }
 
        EntityBuilder(*this, entity).add<T>();
      }
 
      template <typename T>
      void add(Entity entity, Entity object, T&& value) {
        static_assert(core::is_raw_v<T>);
 
        if constexpr (supports_sparse_component_storage<typename component_type_t<T>::TypeFull>()) {
          using FT = typename component_type_t<T>::TypeFull;
          if (can_use_sparse_component_storage<FT>(object)) {
            const auto mode = sparse_storage_mode(object);
            if (mode != SparseStorageMode::None) {
              auto& data = sparse_component_add_value<FT>(object, entity);
              data = GAIA_FWD(value);
              finish_sparse_component_add_inter(entity, object, mode);
              return;
            }
          }
        }
 
        EntityBuilder eb(*this, entity);
#if GAIA_OBSERVERS_ENABLED
        auto addDiffCtx =
            m_observers.prepare_diff(*this, ObserverEvent::OnAdd, EntitySpan{&object, 1}, EntitySpan{&entity, 1});
#endif
        eb.add_inter_init(object);
        eb.commit();
 
        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{*this, ec.pChunk, entity, idx}.sset(object, GAIA_FWD(value));
        notify_add_single(entity, object);
#if GAIA_OBSERVERS_ENABLED
        m_observers.finish_diff(*this, GAIA_MOV(addDiffCtx));
#endif
      }
 
      template <typename T, typename U = typename actual_type_t<T>::Type>
      void add(Entity entity, U&& value) {
        using FT = typename component_type_t<T>::TypeFull;
        if constexpr (uses_compile_time_sparse_storage<FT>()) {
          const auto& item = add<FT>();
          auto& data = sparse_component_store_mut<FT>(item.entity).add(entity);
          data = GAIA_FWD(value);
          finish_sparse_component_add_inter(entity, item.entity, compile_time_sparse_storage_mode(item.entity));
          return;
        }
 
        EntityBuilder builder(*this, entity);
        auto object = builder.register_component<T>();
#if GAIA_OBSERVERS_ENABLED
        auto addDiffCtx =
            m_observers.prepare_diff(*this, ObserverEvent::OnAdd, EntitySpan{&object, 1}, EntitySpan{&entity, 1});
#endif
        // Materialize the component first, write the initial value, and only then dispatch OnAdd.
        // This keeps observer-visible state aligned with the final stored payload.
        builder.add_inter_init(object);
        builder.commit();
 
        const auto& ec = m_recs.entities[entity.id()];
        // Make sure the idx is 0 for unique payload storage.
        const auto idx = uint16_t(ec.row * (actual_type_t<T>::Kind == EntityKind::EK_Gen));
        ComponentSetter{*this, ec.pChunk, entity, idx}.sset<T>(GAIA_FWD(value));
        notify_add_single(entity, object);
#if GAIA_OBSERVERS_ENABLED
        m_observers.finish_diff(*this, GAIA_MOV(addDiffCtx));
#endif
      }
 
      GAIA_NODISCARD bool override(Entity entity, Entity object) {
        return override_inter(entity, object);
      }
 
      GAIA_NODISCARD bool override(Entity entity, Pair pair) {
        return override_inter(entity, (Entity)pair);
      }
 
      template <typename T>
      GAIA_NODISCARD bool override(Entity entity) {
        static_assert(!is_pair<T>::value);
        using FT = typename component_type_t<T>::TypeFull;
        const auto& item = add<FT>();
 
        if constexpr (uses_compile_time_sparse_storage<FT>())
          return override_sparse_component_inter(entity, item.entity);
 
        return override_inter(entity, item.entity);
      }
 
      template <typename T>
      GAIA_NODISCARD bool override(Entity entity, Entity object) {
        static_assert(!is_pair<T>::value);
        using FT = typename component_type_t<T>::TypeFull;
 
        if constexpr (supports_sparse_component_storage<FT>()) {
          if (can_use_sparse_component_storage<FT>(object))
            return override_sparse_component_inter(entity, object);
        }
 
        return override_inter(entity, object);
      }
 
      //----------------------------------------------------------------------
 
      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;
        Entity dstEntity;
 
        // 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));
 
          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);
        } else {
          // No description associated with the entity, direct copy is possible
          dstEntity = add(*pDstArchetype, srcEntity.entity(), srcEntity.pair(), srcEntity.kind());
          Chunk::copy_entity_data(srcEntity, dstEntity, m_recs);
        }
 
        copy_all_sparse_entity_data(srcEntity, dstEntity);
 
        return dstEntity;
      }
 
      template <typename Func = TFunc_Void_With_Entity>
      void copy_n(Entity entity, uint32_t count, Func func = func_void_with_entity) {
        copy_n_inter(entity, count, func, EntitySpan{});
      }
 
#if GAIA_OBSERVERS_ENABLED
      GAIA_NODISCARD Entity copy_ext(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.
        const bool hasEntityDesc = pDstArchetype->has<EntityDesc>();
        if (hasEntityDesc)
          pDstArchetype = foc_archetype_del(pDstArchetype, GAIA_ID(EntityDesc));
 
        const auto archetypeIdCount = (uint32_t)pDstArchetype->ids_view().size();
        const auto sparseIdCount = copied_non_frag_sparse_id_count(srcEntity);
        const auto addedIdCount = archetypeIdCount + sparseIdCount;
        auto* pAddedIds = addedIdCount != 0U ? (Entity*)alloca(sizeof(Entity) * addedIdCount) : nullptr;
        write_archetype_ids(*pDstArchetype, pAddedIds);
        write_copied_non_frag_sparse_ids(srcEntity, pAddedIds + archetypeIdCount);
  #if GAIA_OBSERVERS_ENABLED
        auto addDiffCtx = m_observers.prepare_diff_add_new(*this, EntitySpan{pAddedIds, addedIdCount});
  #endif
 
        Entity dstEntity;
        if (hasEntityDesc) {
          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);
        } else {
          // No description associated with the entity, direct copy is possible
          dstEntity = add(*pDstArchetype, srcEntity.entity(), srcEntity.pair(), srcEntity.kind());
          Chunk::copy_entity_data(srcEntity, dstEntity, m_recs);
        }
 
        (void)copy_all_sparse_entity_data(srcEntity, dstEntity);
        m_observers.add_diff_targets(*this, addDiffCtx, EntitySpan{&dstEntity, 1});
 
        m_observers.on_add(*this, *pDstArchetype, EntitySpan{pAddedIds, addedIdCount}, EntitySpan{&dstEntity, 1});
  #if GAIA_OBSERVERS_ENABLED
        m_observers.finish_diff(*this, GAIA_MOV(addDiffCtx));
  #endif
 
        return dstEntity;
      }
 
      template <typename Func = TFunc_Void_With_Entity>
      void copy_ext_n(Entity entity, uint32_t count, Func func = func_void_with_entity) {
        auto& ec = m_recs.entities[entity.id()];
        auto* pDstArchetype = ec.pArchetype;
        if (pDstArchetype->has<EntityDesc>())
          pDstArchetype = foc_archetype_del(pDstArchetype, GAIA_ID(EntityDesc));
 
        const auto archetypeIdCount = (uint32_t)pDstArchetype->ids_view().size();
        const auto sparseIdCount = copied_non_frag_sparse_id_count(entity);
        const auto addedIdCount = archetypeIdCount + sparseIdCount;
        auto* pAddedIds = addedIdCount != 0U ? (Entity*)alloca(sizeof(Entity) * addedIdCount) : nullptr;
        write_archetype_ids(*pDstArchetype, pAddedIds);
        write_copied_non_frag_sparse_ids(entity, pAddedIds + archetypeIdCount);
  #if GAIA_OBSERVERS_ENABLED
        auto addDiffCtx = m_observers.prepare_diff_add_new(*this, EntitySpan{pAddedIds, addedIdCount});
  #endif
        copy_n_inter(
            entity, count, func, EntitySpan{pAddedIds, addedIdCount}, EntityBad
  #if GAIA_OBSERVERS_ENABLED
            ,
            &addDiffCtx
  #endif
        );
  #if GAIA_OBSERVERS_ENABLED
        m_observers.finish_diff(*this, GAIA_MOV(addDiffCtx));
  #endif
      }
#endif
 
    private:
      template <typename Func>
      void invoke_copy_batch_callback(
          Func& func, Archetype* pDstArchetype, Chunk* pDstChunk, uint32_t originalChunkSize, uint32_t toCreate) {
        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]);
        }
      }
 
      template <typename Func>
      void flush_copy_iter_group(Func& func, CopyIterGroupState& group) {
        if (group.count == 0)
          return;
 
        CopyIter it;
        it.set_world(this);
        it.set_archetype(group.pArchetype);
        it.set_chunk(group.pChunk);
        it.set_range(group.startRow, group.count);
        func(it);
        group.count = 0;
      }
 
      template <typename Func>
      void push_copy_iter_group(Func& func, CopyIterGroupState& group, Entity instance) {
        const auto& ec = fetch(instance);
 
        if (group.count != 0 && ec.pArchetype == group.pArchetype && ec.pChunk == group.pChunk &&
            ec.row == uint16_t(group.startRow + group.count)) {
          ++group.count;
          return;
        }
 
        flush_copy_iter_group(func, group);
        group.pArchetype = ec.pArchetype;
        group.pChunk = ec.pChunk;
        group.startRow = ec.row;
        group.count = 1;
      }
 
      void prepare_parent_batch(Entity parentEntity, const NonFragmentingRelationStore& parentStore) {
        GAIA_ASSERT(valid(parentEntity));
        if (parentStore.sources(parentEntity) != nullptr)
          return;
 
        const auto parentPair = Pair(Parent, parentEntity);
        assign_pair(parentPair, *m_pEntityArchetype);
 
        auto& ecParent = fetch(parentEntity);
        EntityBuilder::set_flag(ecParent.flags, EntityContainerFlags::OnDeleteTarget_Delete, true);
      }
 
      void prepare_parent_batch(Entity parentEntity) {
        const auto* pStore = nonfragmenting_relation_store(Parent);
        if (pStore != nullptr) {
          prepare_parent_batch(parentEntity, *pStore);
          return;
        }
 
        GAIA_ASSERT(valid(parentEntity));
        const auto parentPair = Pair(Parent, parentEntity);
        assign_pair(parentPair, *m_pEntityArchetype);
 
        auto& ecParent = fetch(parentEntity);
        EntityBuilder::set_flag(ecParent.flags, EntityContainerFlags::OnDeleteTarget_Delete, true);
      }
 
      void parent_batch(
          Entity parentEntity, Archetype& archetype, Chunk& chunk, uint32_t originalChunkSize, uint32_t toCreate) {
        GAIA_ASSERT(valid(parentEntity));
 
        if (toCreate == 0)
          return;
 
        auto& parentStore = nonfragmenting_relation_store_mut(Parent);
        prepare_parent_batch(parentEntity, parentStore);
 
        auto entities = chunk.entity_view();
#if GAIA_OBSERVERS_ENABLED
        if (!m_observers.has_on_add_observers()) {
          GAIA_FOR2_(originalChunkSize, originalChunkSize + toCreate, rowIdx) {
            nonfragmenting_relation_set(parentStore, entities[rowIdx], Parent, parentEntity);
          }
          return;
        }
 
        const Entity parentPair = Pair(Parent, parentEntity);
        auto addDiffCtx = m_observers.prepare_diff(
            *this, ObserverEvent::OnAdd, EntitySpan{&parentPair, 1},
            EntitySpan{entities.data() + originalChunkSize, toCreate});
#endif
        GAIA_FOR2_(originalChunkSize, originalChunkSize + toCreate, rowIdx) {
          nonfragmenting_relation_set(parentStore, entities[rowIdx], Parent, parentEntity);
        }
 
#if GAIA_OBSERVERS_ENABLED
        m_observers.on_add(
            *this, archetype, EntitySpan{&parentPair, 1}, EntitySpan{entities.data() + originalChunkSize, toCreate});
        m_observers.finish_diff(*this, GAIA_MOV(addDiffCtx));
#endif
      }
 
      void parent_direct(Entity entity, Entity parentEntity) {
        GAIA_ASSERT(valid(entity));
        GAIA_ASSERT(valid(parentEntity));
        auto& parentStore = nonfragmenting_relation_store_mut(Parent);
        const auto oldParentEntity = parentStore.target(entity);
 
        if (oldParentEntity == parentEntity)
          return;
 
#if GAIA_OBSERVERS_ENABLED
        const bool hasOnDelObservers = oldParentEntity != EntityBad && m_observers.has_on_del_observers();
        const bool hasOnAddObservers = m_observers.has_on_add_observers();
        if (!hasOnDelObservers && !hasOnAddObservers) {
          prepare_parent_batch(parentEntity, parentStore);
          nonfragmenting_relation_set(parentStore, entity, Parent, parentEntity);
          return;
        }
 
        const Entity oldParentPair = hasOnDelObservers ? Pair(Parent, oldParentEntity) : EntityBad;
        const Entity parentPair = Pair(Parent, parentEntity);
        auto delDiffCtx = !hasOnDelObservers
                              ? ObserverRegistry::DiffDispatchCtx{}
                              : m_observers.prepare_diff(
                                    *this, ObserverEvent::OnDel, EntitySpan{&oldParentPair, 1}, EntitySpan{&entity, 1});
        auto addDiffCtx = !hasOnAddObservers
                              ? ObserverRegistry::DiffDispatchCtx{}
                              : m_observers.prepare_diff(
                                    *this, ObserverEvent::OnAdd, EntitySpan{&parentPair, 1}, EntitySpan{&entity, 1});
        prepare_parent_batch(parentEntity, parentStore);
#else
        prepare_parent_batch(parentEntity, parentStore);
#endif
        nonfragmenting_relation_set(parentStore, entity, Parent, parentEntity);
 
#if GAIA_OBSERVERS_ENABLED
        const auto& ec = fetch(entity);
        if (hasOnDelObservers)
          m_observers.on_del(*this, *ec.pArchetype, EntitySpan{&oldParentPair, 1}, EntitySpan{&entity, 1});
        if (hasOnAddObservers)
          m_observers.on_add(*this, *ec.pArchetype, EntitySpan{&parentPair, 1}, EntitySpan{&entity, 1});
        if (hasOnDelObservers)
          m_observers.finish_diff(*this, GAIA_MOV(delDiffCtx));
        if (hasOnAddObservers)
          m_observers.finish_diff(*this, GAIA_MOV(addDiffCtx));
#endif
      }
 
      void notify_add_single(Entity entity, Entity object) {
#if GAIA_ENABLE_ADD_DEL_HOOKS || GAIA_OBSERVERS_ENABLED
        if GAIA_UNLIKELY (tearing_down())
          return;
 
        const auto& ec = fetch(entity);
 
        lock();
 
  #if GAIA_ENABLE_ADD_DEL_HOOKS
        const auto* pItem = component_item(entity, object);
        if (pItem != nullptr) {
          const auto& hooks = ComponentCache::hooks(*pItem);
          if (hooks.func_add != nullptr)
            hooks.func_add(*this, *pItem, entity);
        }
  #endif
 
  #if GAIA_OBSERVERS_ENABLED
        m_observers.on_add(*this, *ec.pArchetype, EntitySpan{&object, 1}, EntitySpan{&entity, 1});
  #endif
 
        unlock();
#else
        (void)entity;
        (void)object;
#endif
      }
 
      void notify_del_single(Entity entity, Entity object) {
#if GAIA_ENABLE_ADD_DEL_HOOKS || GAIA_OBSERVERS_ENABLED
        if GAIA_UNLIKELY (tearing_down())
          return;
 
        const auto& ec = fetch(entity);
 
        lock();
 
  #if GAIA_OBSERVERS_ENABLED
        m_observers.on_del(*this, *ec.pArchetype, EntitySpan{&object, 1}, EntitySpan{&entity, 1});
  #endif
 
  #if GAIA_ENABLE_ADD_DEL_HOOKS
        const auto* pItem = component_item(entity, object);
        if (pItem != nullptr) {
          const auto& hooks = ComponentCache::hooks(*pItem);
          if (hooks.func_del != nullptr)
            hooks.func_del(*this, *pItem, entity);
        }
  #endif
 
        unlock();
#else
        (void)entity;
        (void)object;
#endif
      }
 
      GAIA_NODISCARD bool has_semantic_match_without_source(
          Entity entity, Entity object, Entity excludedSource, cnt::set<EntityLookupKey>& visited) const {
        const auto inserted = visited.insert(EntityLookupKey(entity));
        if (!inserted.second)
          return false;
 
        if (entity != excludedSource && has_direct(entity, object))
          return true;
 
        const auto it = m_entityToAsTargets.find(EntityLookupKey(entity));
        if (it == m_entityToAsTargets.end())
          return false;
 
        for (const auto baseKey: it->second) {
          if (has_semantic_match_without_source(baseKey.entity(), object, excludedSource, visited))
            return true;
        }
 
        return false;
      }
 
      void notify_inherited_del_dependents(Entity source, Entity object) {
#if GAIA_ENABLE_ADD_DEL_HOOKS || GAIA_OBSERVERS_ENABLED
        const auto& descendants = as_relations_trav_cache(source);
        for (const auto descendant: descendants) {
          if (descendant == source)
            continue;
          if (has_direct(descendant, object) || !has(descendant, object))
            continue;
 
          cnt::set<EntityLookupKey> visited;
          if (has_semantic_match_without_source(descendant, object, source, visited))
            continue;
 
          notify_del_single(descendant, object);
        }
#else
        (void)source;
        (void)object;
#endif
      }
 
      void notify_inherited_del_dependents(Entity source, EntitySpan removedObjects) {
        for (const auto object: removedObjects)
          notify_inherited_del_dependents(source, object);
      }
 
#if GAIA_OBSERVERS_ENABLED
#endif
      template <typename Func>
      void copy_n_inter(
          Entity entity, uint32_t count, Func& func, EntitySpan addedIds, Entity parentInstance = EntityBad
#if GAIA_OBSERVERS_ENABLED
          ,
          ObserverRegistry::DiffDispatchCtx* pAddDiffCtx = nullptr
#endif
      ) {
        GAIA_ASSERT(!entity.pair());
        GAIA_ASSERT(valid(entity));
        GAIA_ASSERT(parentInstance == EntityBad || valid(parentInstance));
 
        if (count == 0U)
          return;
 
#if GAIA_OBSERVERS_ENABLED
        const bool useLocalAddDiff = !addedIds.empty() && pAddDiffCtx == nullptr;
        ObserverRegistry::DiffDispatchCtx addDiffCtx{};
        if (useLocalAddDiff)
          addDiffCtx = m_observers.prepare_diff_add_new(*this, EntitySpan{addedIds});
#endif
 
        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;
        const auto hasEntityDesc = pDstArchetype->has<EntityDesc>();
        if (hasEntityDesc)
          pDstArchetype = foc_archetype_del(pDstArchetype, GAIA_ID(EntityDesc));
 
        if (parentInstance != EntityBad)
          prepare_parent_batch(parentInstance);
 
        // 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
 
            if (hasEntityDesc) {
              Chunk::copy_foreign_entity_data(pSrcChunk, srcRow, pDstChunk, ecNew.row);
            }
 
            copy_all_sparse_entity_data(entity, entityNew);
          }
 
          pDstArchetype->try_update_free_chunk_idx();
 
          if (!hasEntityDesc) {
            pDstChunk->call_gen_ctors(originalChunkSize, toCreate);
 
            {
              GAIA_PROF_SCOPE(World::copy_n_entity_data);
              Chunk::copy_entity_data_n_same_chunk(pSrcChunk, srcRow, pDstChunk, originalChunkSize, toCreate);
            }
          }
 
          pDstChunk->update_versions();
 
#if GAIA_OBSERVERS_ENABLED
          if (!addedIds.empty()) {
            auto entities = pDstChunk->entity_view();
            if (pAddDiffCtx != nullptr)
              m_observers.add_diff_targets(
                  *this, *pAddDiffCtx, EntitySpan{entities.data() + originalChunkSize, toCreate});
            else if (useLocalAddDiff)
              m_observers.add_diff_targets(
                  *this, addDiffCtx, EntitySpan{entities.data() + originalChunkSize, toCreate});
            m_observers.on_add(
                *this, *pDstArchetype, addedIds, EntitySpan{entities.data() + originalChunkSize, toCreate});
          }
#endif
 
          if (parentInstance != EntityBad)
            parent_batch(parentInstance, *pDstArchetype, *pDstChunk, originalChunkSize, toCreate);
 
          invoke_copy_batch_callback(func, pDstArchetype, pDstChunk, originalChunkSize, toCreate);
 
          left -= toCreate;
        } while (left > 0);
#if GAIA_OBSERVERS_ENABLED
        if (useLocalAddDiff)
          m_observers.finish_diff(*this, GAIA_MOV(addDiffCtx));
#endif
      }
 
      GAIA_NODISCARD bool id_uses_inherit_policy(Entity id) const {
        return !is_wildcard(id) && valid(id) && target(id, OnInstantiate) == Inherit;
      }
 
      GAIA_NODISCARD Entity inherited_id_owner(Entity entity, Entity id) const {
        if (!id_uses_inherit_policy(id))
          return EntityBad;
 
        const auto& targets = as_targets_trav_cache(entity);
        for (const auto target: targets) {
          if (has_inter(target, id, false))
            return target;
        }
 
        return EntityBad;
      }
 
      GAIA_NODISCARD bool has_direct_sparse_component_inter(Entity entity, Entity object) const {
        const auto itSparseStore = m_sparseComponentsByComp.find(EntityLookupKey(object));
        return itSparseStore != m_sparseComponentsByComp.end() &&
               itSparseStore->second.func_has(itSparseStore->second.pStore, entity);
      }
 
      GAIA_NODISCARD Entity id_owner_inter(Entity entity, Entity object) const {
        GAIA_ASSERT(valid(entity));
        GAIA_ASSERT(object != EntityBad);
        GAIA_ASSERT(!is_wildcard(object));
 
        const auto& ec = fetch(entity);
        if (is_req_del(ec))
          return EntityBad;
 
        if (object.pair()) {
          if (has_nonfragmenting_relation_pair(entity, object) || ec.pArchetype->has(object))
            return entity;
        } else {
          if (has_direct_sparse_component_inter(entity, object) || ec.pArchetype->has(object))
            return entity;
        }
 
        return inherited_id_owner(entity, object);
      }
 
      GAIA_NODISCARD bool instantiate_copies_id(Entity id) const {
        const auto policy = target(id, OnInstantiate);
        if (policy == EntityBad || policy == Override)
          return true;
        if (policy == DontInherit || policy == Inherit)
          return false;
        return true;
      }
 
      template <typename T>
      GAIA_NODISCARD bool prefab_child_edge_exists(const T& children, Entity childPrefab) const {
        for (const auto& child: children) {
          if (child.prefab == childPrefab)
            return true;
        }
 
        return false;
      }
 
      template <typename T>
      void gather_prefab_children_for_relation(Entity prefabEntity, Entity relation, T& outChildren) {
        sources(relation, prefabEntity, [&](Entity childPrefab) {
          if (!has_direct(childPrefab, Prefab) || prefab_child_edge_exists(outChildren, childPrefab))
            return;
 
          PrefabChildEdge edge{};
          edge.prefab = childPrefab;
          edge.relation = relation;
          outChildren.push_back(edge);
        });
      }
 
      template <typename T>
      void gather_sorted_prefab_children(Entity prefabEntity, T& outChildren) {
        gather_prefab_children_for_relation(prefabEntity, Parent, outChildren);
        gather_prefab_children_for_relation(prefabEntity, ChildOf, outChildren);
 
        core::sort(outChildren, [](const PrefabChildEdge& left, const PrefabChildEdge& right) {
          if (left.prefab.id() != right.prefab.id())
            return left.prefab.id() < right.prefab.id();
 
          return left.relation.id() < right.relation.id();
        });
      }
 
      GAIA_NODISCARD bool prefab_hierarchy_parent_id(Entity id) const {
        if (!id.pair() || id.id() != ChildOf.id())
          return false;
 
        const auto parentPrefab = pair_tgt(*this, id);
        return valid(parentPrefab) && has_direct(parentPrefab, Prefab);
      }
 
      void attach_prefab_child_instance(Entity instance, Entity relation, Entity parentInstance) {
        GAIA_ASSERT(valid(instance));
        GAIA_ASSERT(valid(relation));
        GAIA_ASSERT(valid(parentInstance));
 
        if (relation == Parent) {
          parent_direct(instance, parentInstance);
          return;
        }
 
        add(instance, Pair(relation, parentInstance));
      }
 
      GAIA_NODISCARD bool copy_sparse_store_inter(
          Entity srcEntity, Entity dstEntity, Entity comp, const SparseComponentStoreErased& store) {
        if (!copies_sparse_payload_inter(comp, srcEntity, store))
          return false;
 
        GAIA_ASSERT(store.func_copy_entity != nullptr);
        return store.func_copy_entity(store.pStore, dstEntity, srcEntity);
      }
 
      uint32_t copy_all_sparse_entity_data(Entity srcEntity, Entity dstEntity, Entity* pCopiedIds = nullptr) {
        uint32_t copiedCnt = 0;
        for (auto& [compKey, store]: m_sparseComponentsByComp) {
          const auto comp = compKey.entity();
          if (!copy_sparse_store_inter(srcEntity, dstEntity, comp, store))
            continue;
 
          if (pCopiedIds != nullptr)
            pCopiedIds[copiedCnt] = comp;
          ++copiedCnt;
        }
 
        return copiedCnt;
      }
 
      uint32_t copy_sparse_entity_data(
          Entity srcEntity, Entity dstEntity, EntitySpan copiedSparseIds, Entity* pCopiedIds = nullptr) {
        uint32_t copiedCnt = 0;
        for (const auto comp: copiedSparseIds) {
          auto it = m_sparseComponentsByComp.find(EntityLookupKey(comp));
          GAIA_ASSERT(it != m_sparseComponentsByComp.end());
 
          auto& store = it->second;
          if (!copy_sparse_store_inter(srcEntity, dstEntity, comp, store))
            continue;
 
          if (pCopiedIds != nullptr)
            pCopiedIds[copiedCnt] = comp;
          ++copiedCnt;
        }
 
        return copiedCnt;
      }
 
      void write_archetype_ids(const Archetype& dstArchetype, Entity* pDst) const {
        for (const auto id: dstArchetype.ids_view())
          *pDst++ = id;
      }
 
      GAIA_NODISCARD uint32_t copied_non_frag_sparse_id_count(Entity srcEntity) const {
        uint32_t count = 0;
        for (const auto& [compKey, store]: m_sparseComponentsByComp) {
          const auto comp = compKey.entity();
          if (!copies_non_frag_sparse_payload_inter(comp, srcEntity, store))
            continue;
          ++count;
        }
 
        return count;
      }
 
      void write_copied_non_frag_sparse_ids(Entity srcEntity, Entity* pDst) const {
        for (const auto& [compKey, store]: m_sparseComponentsByComp) {
          const auto comp = compKey.entity();
          if (!copies_non_frag_sparse_payload_inter(comp, srcEntity, store))
            continue;
          *pDst++ = comp;
        }
      }
 
      GAIA_NODISCARD bool copy_sparse_payload_inter(Entity dstEntity, Entity srcEntity, Entity object) {
        const auto mode = sparse_storage_mode(object);
        if (mode == SparseStorageMode::None)
          return false;
 
        const auto itSparseStore = m_sparseComponentsByComp.find(EntityLookupKey(object));
        if (itSparseStore == m_sparseComponentsByComp.end())
          return false;
 
        return copy_sparse_store_inter(srcEntity, dstEntity, object, itSparseStore->second);
      }
 
      GAIA_NODISCARD bool override_sparse_component_inter(Entity entity, Entity object) {
        GAIA_ASSERT(valid(entity));
        GAIA_ASSERT(valid(object));
        GAIA_ASSERT(sparse_storage_mode(object) != SparseStorageMode::None);
 
        if (has_direct(entity, object))
          return false;
 
        const auto inheritedOwner = inherited_id_owner(entity, object);
        if (inheritedOwner == EntityBad)
          return false;
 
        if (!copy_sparse_payload_inter(entity, inheritedOwner, object))
          return false;
 
        if (sparse_storage_mode(object) == SparseStorageMode::Fragmenting)
          make_sparse_copy_direct_inter(entity, object);
        return true;
      }
 
      GAIA_NODISCARD bool copy_owned_sparse_component_inter(Entity srcEntity, Entity dstEntity, Entity object) {
        GAIA_ASSERT(valid(srcEntity));
        GAIA_ASSERT(valid(dstEntity));
        GAIA_ASSERT(valid(object));
        GAIA_ASSERT(sparse_storage_mode(object) != SparseStorageMode::None);
 
        const auto mode = sparse_storage_mode(object);
        if (mode == SparseStorageMode::Fragmenting) {
          if (!copy_sparse_payload_inter(dstEntity, srcEntity, object))
            return false;
 
          make_sparse_copy_direct_inter(dstEntity, object);
          notify_add_single(dstEntity, object);
          return true;
        }
#if GAIA_OBSERVERS_ENABLED
        auto addDiffCtx =
            m_observers.prepare_diff(*this, ObserverEvent::OnAdd, EntitySpan{&object, 1}, EntitySpan{&dstEntity, 1});
#endif
        if (!copy_sparse_payload_inter(dstEntity, srcEntity, object))
          return false;
        notify_add_single(dstEntity, object);
#if GAIA_OBSERVERS_ENABLED
        m_observers.finish_diff(*this, GAIA_MOV(addDiffCtx));
#endif
        return true;
      }
 
      void make_sparse_copy_direct_inter(Entity entity, Entity object) {
        GAIA_ASSERT(sparse_storage_mode(object) == SparseStorageMode::Fragmenting);
        EntityBuilder eb(*this, entity);
        eb.add_inter_init(object);
        eb.commit();
      }
 
      void copy_direct_component_data_inter(
          Entity srcEntity, Entity dstEntity, Entity object, const ComponentCacheItem& item) {
        GAIA_ASSERT(valid(srcEntity));
        GAIA_ASSERT(valid(dstEntity));
        GAIA_ASSERT(valid(object));
        GAIA_ASSERT(item.entity == object);
        GAIA_ASSERT(item.comp.size() != 0U);
 
        const auto& ecDst = fetch(dstEntity);
        const auto& ecSrc = fetch(srcEntity);
        const auto compIdxDst = ecDst.pChunk->comp_idx(object);
        const auto compIdxSrc = ecSrc.pChunk->comp_idx(object);
        GAIA_ASSERT(compIdxDst != BadIndex && compIdxSrc != BadIndex);
 
        const auto idxDst = uint16_t(ecDst.row * (1U - (uint32_t)object.kind()));
        const auto idxSrc = uint16_t(ecSrc.row * (1U - (uint32_t)object.kind()));
        void* pDst = ecDst.pChunk->comp_ptr_mut(compIdxDst);
        const void* pSrc = ecSrc.pChunk->comp_ptr(compIdxSrc);
        item.copy(pDst, pSrc, idxDst, idxSrc, ecDst.pChunk->capacity(), ecSrc.pChunk->capacity());
      }
 
      GAIA_NODISCARD bool override_inter(Entity entity, Entity object) {
        GAIA_ASSERT(valid(entity));
        GAIA_ASSERT(object.pair() || valid(object));
 
        if (has_direct(entity, object))
          return false;
 
        const auto inheritedOwner = inherited_id_owner(entity, object);
        if (inheritedOwner == EntityBad)
          return false;
 
        if (!object.pair()) {
          const auto* pItem = comp_cache().find(object);
          if (pItem != nullptr && pItem->entity == object) {
            const auto mode = sparse_storage_mode(object);
            if (mode != SparseStorageMode::None)
              return override_sparse_component_inter(entity, object);
 
            if (pItem->comp.size() != 0U) {
              add(entity, object);
              copy_direct_component_data_inter(inheritedOwner, entity, object, *pItem);
              return true;
            }
          }
        }
 
        add(entity, object);
        return true;
      }
 
      GAIA_NODISCARD bool copy_owned_id_from_entity(Entity srcEntity, Entity dstEntity, Entity object) {
        GAIA_ASSERT(valid(srcEntity));
        GAIA_ASSERT(valid(dstEntity));
        GAIA_ASSERT(object.pair() || valid(object));
 
        if (has_direct(dstEntity, object))
          return false;
 
        if (!object.pair()) {
          const auto* pItem = comp_cache().find(object);
          if (pItem != nullptr && pItem->entity == object) {
            if (sparse_storage_mode(object) != SparseStorageMode::None)
              return copy_owned_sparse_component_inter(srcEntity, dstEntity, object);
 
            if (pItem->comp.size() != 0U) {
              EntityBuilder eb(*this, dstEntity);
              eb.add_inter_init(object);
              eb.commit();
              copy_direct_component_data_inter(srcEntity, dstEntity, object, *pItem);
              notify_add_single(dstEntity, object);
              return true;
            }
          }
        }
 
        add(dstEntity, object);
        return true;
      }
 
      GAIA_NODISCARD Archetype* instantiate_prefab_dst_archetype(Entity prefabEntity) {
        GAIA_ASSERT(!prefabEntity.pair());
        GAIA_ASSERT(valid(prefabEntity));
        GAIA_ASSERT(has_direct(prefabEntity, Prefab));
 
        if GAIA_UNLIKELY (!has_direct(prefabEntity, Prefab))
          return fetch(prefabEntity).pArchetype;
 
        auto& ecSrc = m_recs.entities[prefabEntity.id()];
        GAIA_ASSERT(ecSrc.pArchetype != nullptr);
 
        auto* pDstArchetype = ecSrc.pArchetype;
        if (pDstArchetype->has<EntityDesc>())
          pDstArchetype = foc_archetype_del(pDstArchetype, GAIA_ID(EntityDesc));
        if (pDstArchetype->has(Prefab))
          pDstArchetype = foc_archetype_del(pDstArchetype, Prefab);
 
        for (const auto id: ecSrc.pArchetype->ids_view()) {
          if (id.pair() && id.id() == Is.id()) {
            pDstArchetype = foc_archetype_del(pDstArchetype, id);
            continue;
          }
          if (prefab_hierarchy_parent_id(id)) {
            pDstArchetype = foc_archetype_del(pDstArchetype, id);
            continue;
          }
 
          if (!instantiate_copies_id(id))
            pDstArchetype = foc_archetype_del(pDstArchetype, id);
        }
 
        const auto isPair = Pair(Is, prefabEntity);
        assign_pair(isPair, *m_pEntityArchetype);
        pDstArchetype = foc_archetype_add(pDstArchetype, isPair);
 
        return pDstArchetype;
      }
 
      template <typename T>
      void collect_prefab_copied_sparse_ids(Entity prefabEntity, T& outCopiedSparseIds) {
        outCopiedSparseIds.clear();
        if (m_sparseComponentsByComp.empty())
          return;
 
        for (const auto& [compKey, store]: m_sparseComponentsByComp) {
          const auto comp = compKey.entity();
          if (!instantiate_copies_id(comp) || !copies_sparse_payload_inter(comp, prefabEntity, store))
            continue;
          outCopiedSparseIds.push_back(comp);
        }
      }
 
      template <typename T>
      void collect_prefab_added_ids(Archetype* pDstArchetype, EntitySpan copiedSparseIds, T& outAddedIds) {
        outAddedIds.clear();
        for (const auto id: pDstArchetype->ids_view())
          outAddedIds.push_back(id);
 
        for (const auto comp: copiedSparseIds) {
          if (sparse_copy_adds_id_inter(comp))
            outAddedIds.push_back(comp);
        }
      }
 
      template <typename T>
      void collect_prefab_add_hook_ids(EntitySpan addedIds, T& outHookIds) {
        outHookIds.clear();
        for (const auto id: addedIds) {
          if (!id.comp())
            continue;
 
          const auto& item = comp_cache().get(id);
          if (ComponentCache::hooks(item).func_add != nullptr)
            outHookIds.push_back(id);
        }
      }
 
      GAIA_NODISCARD Entity instantiate_prefab_node_inter(
          Entity prefabEntity, Archetype* pDstArchetype, Entity parentInstance, EntitySpan copiedSparseIds,
          EntitySpan addedIds, EntitySpan addHookIds) {
        GAIA_ASSERT(!prefabEntity.pair());
        GAIA_ASSERT(valid(prefabEntity));
        GAIA_ASSERT(has_direct(prefabEntity, Prefab));
        GAIA_ASSERT(pDstArchetype != nullptr);
#if GAIA_OBSERVERS_ENABLED
        auto addDiffCtx = m_observers.prepare_diff_add_new(*this, EntitySpan{addedIds});
#endif
 
        auto& ecSrc = m_recs.entities[prefabEntity.id()];
        GAIA_ASSERT(ecSrc.pArchetype != nullptr);
        GAIA_ASSERT(ecSrc.pChunk != nullptr);
 
        EntityContainerCtx ctx{true, false, prefabEntity.kind()};
        const auto instance = m_recs.entities.alloc(&ctx);
        auto& ecDst = m_recs.entities[instance.id()];
        auto* pDstChunk = pDstArchetype->foc_free_chunk();
        store_entity(ecDst, instance, pDstArchetype, pDstChunk);
        pDstArchetype->try_update_free_chunk_idx();
        Chunk::copy_foreign_entity_data(ecSrc.pChunk, ecSrc.row, pDstChunk, ecDst.row);
        pDstChunk->update_versions();
 
        ecDst.flags |= EntityContainerFlags::HasAliasOf;
 
        // Keep payload copy and observer/add-id reporting separate:
        // fragmenting sparse payloads must still be copied here even though their id is
        // already present in the destination archetype and therefore absent from addedIds tail.
        (void)copy_sparse_entity_data(prefabEntity, instance, copiedSparseIds);
#if GAIA_OBSERVERS_ENABLED
        m_observers.add_diff_targets(*this, addDiffCtx, EntitySpan{&instance, 1});
#endif
 
        invalidate_relation_caches(Is);
 
        const auto instanceKey = EntityLookupKey(instance);
        const auto prefabKey = EntityLookupKey(prefabEntity);
        m_entityToAsTargets[instanceKey].insert(prefabKey);
        m_entityToAsTargetsTravCache = {};
        m_entityToAsRelations[prefabKey].insert(instanceKey);
        m_entityToAsRelationsTravCache = {};
        invalidate_queries_for_entity({Is, prefabEntity});
 
#if GAIA_ENABLE_ADD_DEL_HOOKS || GAIA_OBSERVERS_ENABLED
        if GAIA_UNLIKELY (tearing_down()) {
          (void)pDstArchetype;
          (void)addedIds;
        } else {
          lock();
 
  #if GAIA_ENABLE_ADD_DEL_HOOKS
          for (const auto id: addHookIds) {
            const auto& item = comp_cache().get(id);
            const auto& hooks = ComponentCache::hooks(item);
            GAIA_ASSERT(hooks.func_add != nullptr);
            hooks.func_add(*this, item, instance);
          }
  #endif
 
  #if GAIA_OBSERVERS_ENABLED
          m_observers.on_add(*this, *pDstArchetype, addedIds, EntitySpan{&instance, 1});
  #endif
 
          unlock();
        }
#endif
 
#if GAIA_OBSERVERS_ENABLED
        m_observers.finish_diff(*this, GAIA_MOV(addDiffCtx));
#endif
 
        if (parentInstance != EntityBad)
          parent_direct(instance, parentInstance);
 
        return instance;
      }
 
      GAIA_NODISCARD Entity instantiate_prefab_node_inter(Entity prefabEntity, Entity parentInstance) {
        auto* pDstArchetype = instantiate_prefab_dst_archetype(prefabEntity);
        cnt::darray_ext<Entity, 16> copiedSparseIds;
        cnt::darray_ext<Entity, 16> addedIds;
        cnt::darray_ext<Entity, 16> addHookIds;
        collect_prefab_copied_sparse_ids(prefabEntity, copiedSparseIds);
        collect_prefab_added_ids(pDstArchetype, EntitySpan{copiedSparseIds}, addedIds);
        collect_prefab_add_hook_ids(EntitySpan{addedIds}, addHookIds);
        return instantiate_prefab_node_inter(
            prefabEntity, pDstArchetype, parentInstance, EntitySpan{copiedSparseIds}, EntitySpan{addedIds},
            EntitySpan{addHookIds});
      }
 
      template <typename Func>
      void instantiate_prefab_n_inter(
          const PrefabInstantiatePlanNode& node, Entity parentInstance, uint32_t count, Func& func) {
        GAIA_ASSERT(node.prefab != EntityBad);
        GAIA_ASSERT(node.pDstArchetype != nullptr);
 
        if (count == 0U)
          return;
#if GAIA_OBSERVERS_ENABLED
        auto addDiffCtx = m_observers.prepare_diff_add_new(*this, EntitySpan{node.addedIds});
#endif
 
        auto& ecSrc = m_recs.entities[node.prefab.id()];
        GAIA_ASSERT(ecSrc.pChunk != nullptr);
 
        if (parentInstance != EntityBad)
          prepare_parent_batch(parentInstance);
 
        const auto srcRow = ecSrc.row;
        auto* pSrcChunk = ecSrc.pChunk;
        auto* pDstArchetype = node.pDstArchetype;
        const auto prefabKey = EntityLookupKey(node.prefab);
        EntityContainerCtx ctx{true, false, node.prefab.kind()};
        auto& asRelations = m_entityToAsRelations[prefabKey];
        m_entityToAsTargets.reserve(m_entityToAsTargets.size() + count);
        asRelations.reserve(asRelations.size() + count);
 
        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, rowOffset) {
            const auto instance = m_recs.entities.alloc(&ctx);
            auto& ecDst = m_recs.entities[instance.id()];
            store_entity(ecDst, instance, pDstArchetype, pDstChunk);
            ecDst.flags |= EntityContainerFlags::HasAliasOf;
 
            (void)copy_sparse_entity_data(node.prefab, instance, EntitySpan{node.copiedSparseIds});
          }
 
          pDstArchetype->try_update_free_chunk_idx();
          Chunk::copy_foreign_entity_data_n(pSrcChunk, srcRow, pDstChunk, originalChunkSize, toCreate);
          pDstChunk->update_versions();
 
          invalidate_relation_caches(Is);
 
          auto entities = pDstChunk->entity_view();
          GAIA_FOR2_(originalChunkSize, originalChunkSize + toCreate, rowIdx) {
            const auto instance = entities[rowIdx];
            m_entityToAsTargets[EntityLookupKey(instance)].insert(prefabKey);
            asRelations.insert(EntityLookupKey(instance));
          }
          m_entityToAsTargetsTravCache = {};
          m_entityToAsRelationsTravCache = {};
          invalidate_queries_for_entity({Is, node.prefab});
 
#if GAIA_ENABLE_ADD_DEL_HOOKS || GAIA_OBSERVERS_ENABLED
          if GAIA_UNLIKELY (tearing_down()) {
            (void)entities;
            (void)originalChunkSize;
            (void)toCreate;
          } else {
            lock();
 
  #if GAIA_ENABLE_ADD_DEL_HOOKS
            for (const auto id: node.addHookIds) {
              const auto& item = comp_cache().get(id);
              const auto& hooks = ComponentCache::hooks(item);
              GAIA_ASSERT(hooks.func_add != nullptr);
 
              GAIA_FOR2_(originalChunkSize, originalChunkSize + toCreate, rowIdx) {
                hooks.func_add(*this, item, entities[rowIdx]);
              }
            }
  #endif
 
  #if GAIA_OBSERVERS_ENABLED
            m_observers.add_diff_targets(*this, addDiffCtx, EntitySpan{entities.data() + originalChunkSize, toCreate});
            m_observers.on_add(
                *this, *pDstArchetype, EntitySpan{node.addedIds},
                EntitySpan{entities.data() + originalChunkSize, toCreate});
  #endif
 
            unlock();
          }
#endif
 
          if (parentInstance != EntityBad)
            parent_batch(parentInstance, *pDstArchetype, *pDstChunk, originalChunkSize, toCreate);
 
          invoke_copy_batch_callback(func, pDstArchetype, pDstChunk, originalChunkSize, toCreate);
 
          left -= toCreate;
        } while (left > 0);
#if GAIA_OBSERVERS_ENABLED
        m_observers.finish_diff(*this, GAIA_MOV(addDiffCtx));
#endif
      }
 
      template <typename T>
      void build_prefab_instantiate_plan(Entity prefabEntity, uint32_t parentIdx, Entity parentRelation, T& plan) {
        PrefabInstantiatePlanNode node{};
        node.prefab = prefabEntity;
        node.parentIdx = parentIdx;
        node.parentRelation = parentRelation;
        node.pDstArchetype = instantiate_prefab_dst_archetype(prefabEntity);
        collect_prefab_copied_sparse_ids(prefabEntity, node.copiedSparseIds);
        collect_prefab_added_ids(node.pDstArchetype, EntitySpan{node.copiedSparseIds}, node.addedIds);
        collect_prefab_add_hook_ids(EntitySpan{node.addedIds}, node.addHookIds);
 
        const auto nodeIdx = (uint32_t)plan.size();
        plan.push_back(GAIA_MOV(node));
 
        cnt::darray_ext<PrefabChildEdge, 16> prefabChildren;
        gather_sorted_prefab_children(prefabEntity, prefabChildren);
 
        for (const auto& child: prefabChildren)
          build_prefab_instantiate_plan(child.prefab, nodeIdx, child.relation, plan);
      }
 
      GAIA_NODISCARD bool instance_has_prefab_child(Entity parentInstance, Entity relation, Entity childPrefab) const {
        bool found = false;
        sources(relation, parentInstance, [&](Entity child) {
          if (found)
            return;
          if (has_direct(child, Pair(Is, childPrefab)))
            found = true;
        });
        return found;
      }
 
      template <typename T>
      uint32_t sync_prefab_instance(
          Entity prefabEntity, Entity instance, const PrefabInstantiatePlanNode& node, const T& prefabChildren) {
        uint32_t changes = 0;
 
        const auto isPair = Pair(Is, prefabEntity);
        for (const auto id: node.pDstArchetype->ids_view()) {
          if (id == isPair || has_direct(instance, id))
            continue;
          if (copy_owned_id_from_entity(prefabEntity, instance, id))
            ++changes;
        }
 
        for (const auto comp: node.copiedSparseIds) {
          if (has_direct(instance, comp))
            continue;
          if (copy_owned_id_from_entity(prefabEntity, instance, comp))
            ++changes;
        }
 
        for (const auto& child: prefabChildren) {
          if (instance_has_prefab_child(instance, child.relation, child.prefab))
            continue;
          (void)instantiate_inter(child.prefab, instance, child.relation);
          ++changes;
        }
 
        return changes;
      }
 
      uint32_t sync_prefab_inter(Entity prefabEntity, cnt::set<EntityLookupKey>& visited) {
        GAIA_ASSERT(!prefabEntity.pair());
        GAIA_ASSERT(valid(prefabEntity));
 
        if (!has_direct(prefabEntity, Prefab))
          return 0;
 
        const auto ins = visited.insert(EntityLookupKey(prefabEntity));
        if (!ins.second)
          return 0;
 
        PrefabInstantiatePlanNode node{};
        node.prefab = prefabEntity;
        node.pDstArchetype = instantiate_prefab_dst_archetype(prefabEntity);
        collect_prefab_copied_sparse_ids(prefabEntity, node.copiedSparseIds);
        collect_prefab_added_ids(node.pDstArchetype, EntitySpan{node.copiedSparseIds}, node.addedIds);
        collect_prefab_add_hook_ids(EntitySpan{node.addedIds}, node.addHookIds);
 
        cnt::darray_ext<PrefabChildEdge, 16> prefabChildren;
        gather_sorted_prefab_children(prefabEntity, prefabChildren);
 
        uint32_t changes = 0;
        const auto& descendants = as_relations_trav_cache(prefabEntity);
        for (const auto entity: descendants) {
          if (has_direct(entity, Prefab))
            continue;
          changes += sync_prefab_instance(prefabEntity, entity, node, prefabChildren);
        }
 
        for (const auto& child: prefabChildren)
          changes += sync_prefab_inter(child.prefab, visited);
 
        return changes;
      }
 
      GAIA_NODISCARD Entity
      instantiate_inter(Entity prefabEntity, Entity parentInstance, Entity parentRelation = Parent) {
        const auto directParentInstance = parentRelation == Parent ? parentInstance : EntityBad;
        const auto instance = instantiate_prefab_node_inter(prefabEntity, directParentInstance);
        if (parentInstance != EntityBad && parentRelation != Parent)
          attach_prefab_child_instance(instance, parentRelation, parentInstance);
 
        cnt::darray_ext<PrefabChildEdge, 16> prefabChildren;
        gather_sorted_prefab_children(prefabEntity, prefabChildren);
 
        for (const auto& child: prefabChildren)
          (void)instantiate_inter(child.prefab, instance, child.relation);
 
        return instance;
      }
 
    public:
      GAIA_NODISCARD Entity instantiate(Entity prefabEntity) {
        GAIA_ASSERT(!prefabEntity.pair());
        GAIA_ASSERT(valid(prefabEntity));
 
        if GAIA_UNLIKELY (!has_direct(prefabEntity, Prefab))
          return copy(prefabEntity);
 
        return instantiate_inter(prefabEntity, EntityBad);
      }
 
      GAIA_NODISCARD Entity instantiate(Entity prefabEntity, Entity parentInstance) {
        GAIA_ASSERT(!prefabEntity.pair());
        GAIA_ASSERT(valid(prefabEntity));
        GAIA_ASSERT(valid(parentInstance));
 
        if GAIA_UNLIKELY (!has_direct(prefabEntity, Prefab)) {
          const auto instance = copy(prefabEntity);
          parent_direct(instance, parentInstance);
          return instance;
        }
 
        return instantiate_inter(prefabEntity, parentInstance);
      }
 
      template <typename Func = TFunc_Void_With_Entity>
      void instantiate_n(Entity prefabEntity, uint32_t count, Func func = func_void_with_entity) {
        instantiate_n(prefabEntity, EntityBad, count, func);
      }
 
      void instantiate_n(Entity prefabEntity, Entity parentInstance, uint32_t count) {
        instantiate_n(prefabEntity, parentInstance, count, func_void_with_entity);
      }
 
      template <typename Func>
      void instantiate_n(Entity prefabEntity, Entity parentInstance, uint32_t count, Func func) {
        GAIA_ASSERT(!prefabEntity.pair());
        GAIA_ASSERT(valid(prefabEntity));
        GAIA_ASSERT(parentInstance == EntityBad || valid(parentInstance));
 
        if (count == 0U)
          return;
 
        if GAIA_UNLIKELY (!has_direct(prefabEntity, Prefab)) {
          if (parentInstance == EntityBad) {
            copy_n(prefabEntity, count, func);
            return;
          }
 
          copy_n_inter(prefabEntity, count, func, EntitySpan{}, parentInstance);
          return;
        }
 
        cnt::darray_ext<PrefabInstantiatePlanNode, 16> plan;
        build_prefab_instantiate_plan(prefabEntity, BadIndex, EntityBad, plan);
        if (plan.size() == 1) {
          instantiate_prefab_n_inter(plan[0], parentInstance, count, func);
          return;
        }
 
        const auto planSize = (uint32_t)plan.size();
        GAIA_ASSERT(planSize <= uint32_t(-1) / count);
        cnt::darray<Entity> spawned;
        spawned.resize(planSize * count);
 
        uint32_t rootIdx = 0;
        auto collectRoot = [&](Entity instance) {
          spawned[rootIdx++] = instance;
        };
        instantiate_prefab_n_inter(plan[0], parentInstance, count, collectRoot);
 
        GAIA_FOR2_(1, planSize, planIdx) {
          uint32_t nodeIdx = 0;
          const auto nodeOffset = planIdx * count;
          auto collectNode = [&](Entity instance) {
            spawned[nodeOffset + nodeIdx++] = instance;
          };
          instantiate_prefab_n_inter(plan[planIdx], EntityBad, count, collectNode);
 
          const auto parentOffset = plan[planIdx].parentIdx * count;
          GAIA_FOR_(count, instanceIdx) {
            attach_prefab_child_instance(
                spawned[nodeOffset + instanceIdx], plan[planIdx].parentRelation, spawned[parentOffset + instanceIdx]);
          }
        }
 
        if constexpr (std::is_invocable_v<Func, CopyIter&>) {
          CopyIterGroupState group;
          GAIA_FOR_(count, idx) {
            push_copy_iter_group(func, group, spawned[idx]);
          }
          flush_copy_iter_group(func, group);
        } else {
          GAIA_FOR_(count, idx) {
            func(spawned[idx]);
          }
        }
      }
 
      GAIA_NODISCARD uint32_t sync(Entity prefabEntity) {
        GAIA_ASSERT(!prefabEntity.pair());
        GAIA_ASSERT(valid(prefabEntity));
 
        cnt::set<EntityLookupKey> visited;
        return sync_prefab_inter(prefabEntity, visited);
      }
 
      GAIA_NODISCARD Entity find_prefab_instance(Entity instanceRoot, Entity prefabEntity) const {
        if (!valid(instanceRoot) || !valid(prefabEntity))
          return EntityBad;
 
        const auto isPair = Pair(Is, prefabEntity);
        if (has_direct(instanceRoot, isPair))
          return instanceRoot;
 
        Entity found = EntityBad;
        cnt::darray_ext<Entity, 64> children;
        cnt::darray_ext<Entity, 32> queue;
        cnt::set<EntityLookupKey> visited;
        queue.push_back(instanceRoot);
        visited.insert(EntityLookupKey(instanceRoot));
 
        for (uint32_t i = 0; i < queue.size() && found == EntityBad; ++i) {
          children.clear();
          auto collectChild = [&](Entity child) {
            const auto key = EntityLookupKey(child);
            const auto ins = visited.insert(key);
            if (!ins.second)
              return;
 
            children.push_back(child);
          };
          sources(Parent, queue[i], collectChild);
          sources(ChildOf, queue[i], collectChild);
 
          core::sort(children, [](Entity left, Entity right) {
            return left.id() < right.id();
          });
 
          for (const auto child: children) {
            if (has_direct(child, isPair)) {
              found = child;
              break;
            }
 
            queue.push_back(child);
          }
        }
 
        return found;
      }
 
      //----------------------------------------------------------------------
 
      void del(Entity entity) {
#if GAIA_OBSERVERS_ENABLED
        if (entity_deletion_active(entity))
          return;
#endif
 
        if (!entity.pair()) {
          if (relation_uses_non_fragmenting_storage(entity)) {
            cnt::darray_ext<Entity, 64> pairEntities;
            if (const auto* pTargets = targets(entity)) {
              for (auto targetKey: *pTargets)
                pairEntities.push_back(Pair(entity, targetKey.entity()));
            }
            if (const auto* pRelations = relations(entity)) {
              for (auto relationKey: *pRelations) {
                const auto relation = relationKey.entity();
                if (relation != entity)
                  pairEntities.push_back(Pair(relation, entity));
              }
            }
 
            auto& ec = fetch(entity);
            handle_del_entity(ec, entity, EntitySpan{pairEntities.data(), pairEntities.size()});
            return;
          }
 
          // 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) {
        if (!object.pair()) {
          const auto itSparseStore = m_sparseComponentsByComp.find(EntityLookupKey(object));
          if (itSparseStore != m_sparseComponentsByComp.end()) {
            if (!component_is_non_fragmenting(object)) {
              {
                EntityBuilder eb(*this, entity);
                eb.del(object);
              }
              itSparseStore->second.func_del(itSparseStore->second.pStore, entity);
              return;
            }
#if GAIA_OBSERVERS_ENABLED
            auto delDiffCtx =
                m_observers.prepare_diff(*this, ObserverEvent::OnDel, EntitySpan{&object, 1}, EntitySpan{&entity, 1});
#endif
            notify_inherited_del_dependents(entity, object);
            notify_del_single(entity, object);
            itSparseStore->second.func_del(itSparseStore->second.pStore, entity);
#if GAIA_OBSERVERS_ENABLED
            m_observers.finish_diff(*this, GAIA_MOV(delDiffCtx));
#endif
            return;
          }
        }
        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;
 
        if constexpr (uses_compile_time_sparse_storage<FT>()) {
          const auto* pItem = comp_cache().template find<FT>();
          if (pItem != nullptr)
            del(entity, pItem->entity);
          return;
        }
 
        EntityBuilder(*this, entity).del<FT>();
      }
 
      //----------------------------------------------------------------------
 
      void as(Entity entity, Entity 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));
      }
 
      void parent(Entity entity, Entity parentEntity) {
        parent_direct(entity, parentEntity);
      }
 
      GAIA_NODISCARD bool parent(Entity entity, Entity parentEntity) const {
        return has_direct(entity, Pair(Parent, parentEntity));
      }
 
      //----------------------------------------------------------------------
 
      template <
          typename T
#if GAIA_ENABLE_HOOKS
          ,
          bool TriggerSetEffects
#endif
          >
      void modify(Entity entity) {
        GAIA_ASSERT(valid(entity));
 
        if constexpr (uses_compile_time_sparse_storage<T>()) {
          const auto* pItem = comp_cache().template find<T>();
          if (pItem != nullptr) {
#if GAIA_ASSERT_ENABLED
            auto* pStore = sparse_component_store_erased(pItem->entity);
            GAIA_ASSERT(pStore != nullptr);
            GAIA_ASSERT(has_direct_sparse_component_inter(entity, pItem->entity));
#endif
 
            ::gaia::ecs::update_version(m_worldVersion);
 
#if GAIA_OBSERVERS_ENABLED
            if constexpr (TriggerSetEffects)
              world_notify_on_set_entity(*this, pItem->entity, entity);
#endif
            return;
          }
        }
 
        auto& ec = m_recs.entities[entity.id()];
        ec.pChunk->template modify<
            T
#if GAIA_ENABLE_HOOKS
            ,
            TriggerSetEffects
#endif
            >();
 
#if GAIA_OBSERVERS_ENABLED
        if constexpr (TriggerSetEffects) {
          Entity term = EntityBad;
          if constexpr (is_pair<T>::value) {
            const auto rel = comp_cache().template get<typename T::rel>().entity;
            const auto tgt = comp_cache().template get<typename T::tgt>().entity;
            term = (Entity)Pair(rel, tgt);
          } else
            term = comp_cache().template get<T>().entity;
 
          world_notify_on_set(*this, term, *ec.pChunk, ec.row, (uint16_t)(ec.row + 1));
        }
#endif
      }
 
      template <
          typename T
#if GAIA_ENABLE_HOOKS
          ,
          bool TriggerSetEffects
#endif
          >
      void modify(Entity entity, Entity object) {
        GAIA_ASSERT(valid(entity));
        GAIA_ASSERT(valid(object));
 
        using FT = typename component_type_t<T>::TypeFull;
        if constexpr (supports_sparse_component_storage<FT>()) {
          if (can_use_sparse_component_storage<FT>(object)) {
#if GAIA_ASSERT_ENABLED
            auto* pStore = sparse_component_store_erased(object);
            GAIA_ASSERT(pStore != nullptr);
            GAIA_ASSERT(has_direct_sparse_component_inter(entity, object));
#endif
 
            ::gaia::ecs::update_version(m_worldVersion);
 
#if GAIA_OBSERVERS_ENABLED
            if constexpr (TriggerSetEffects)
              world_notify_on_set_entity(*this, object, entity);
#endif
            return;
          }
        }
 
        auto& ec = m_recs.entities[entity.id()];
        const auto compIdx = ec.pChunk->comp_idx(object);
        GAIA_ASSERT(compIdx != ComponentIndexBad);
 
        if constexpr (TriggerSetEffects)
          ec.pChunk->finish_write(compIdx, ec.row, (uint16_t)(ec.row + 1));
        else
          ec.pChunk->update_world_version(compIdx);
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD ComponentSetter acc_mut(Entity entity) {
        GAIA_ASSERT(valid(entity));
 
        const auto& ec = m_recs.entities[entity.id()];
        return ComponentSetter{*this, ec.pChunk, entity, ec.row};
      }
 
      template <typename T>
      GAIA_NODISCARD auto set(Entity entity) {
        static_assert(!is_pair<T>::value);
        using FT = typename component_type_t<T>::TypeFull;
        using ValueType = typename actual_type_t<T>::Type;
        const auto& item = add<FT>();
        return SetWriteProxyTyped<T, ValueType>{*this, entity, item.entity, get<T>(entity)};
      }
 
      template <typename T>
      GAIA_NODISCARD auto set(Entity entity, Entity object) {
        static_assert(!is_pair<T>::value);
        return SetWriteProxyObject<typename actual_type_t<T>::Type>{*this, entity, object, get<T>(entity, object)};
      }
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) sset(Entity entity) {
        static_assert(!is_pair<T>::value);
        using FT = typename component_type_t<T>::TypeFull;
        const auto& item = add<FT>();
        if constexpr (uses_compile_time_sparse_storage<FT>())
          return sparse_component_store_mut<FT>(item.entity).mut(entity);
        return acc_mut(entity).smut<T>();
      }
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) sset(Entity entity, Entity object) {
        static_assert(!is_pair<T>::value);
        using FT = typename component_type_t<T>::TypeFull;
        if constexpr (supports_sparse_component_storage<FT>()) {
          if (can_use_sparse_component_storage<FT>(object))
            return sparse_component_mut_value<FT>(object, entity);
        }
        return acc_mut(entity).smut<T>(object);
      }
 
      //----------------------------------------------------------------------
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) mut(Entity entity) {
        static_assert(!is_pair<T>::value);
        return sset<T>(entity);
      }
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) mut(Entity entity, Entity object) {
        static_assert(!is_pair<T>::value);
        return sset<T>(entity, object);
      }
 
      GAIA_NODISCARD ComponentRawView get_raw(Entity entity, Entity component) const {
        if (component == EntityBad || !valid(entity))
          return {};
 
        const auto owner = id_owner_inter(entity, component);
        if (owner == EntityBad)
          return {};
 
        const auto* pItem = component_item(owner, component);
        if (pItem == nullptr || !raw_component_supported(*pItem))
          return {};
        if (pItem->comp.storage_type() == DataStorageType::Sparse) {
          if (component.pair())
            return {};
          const auto* pStore = sparse_component_store_erased(component);
          if (pStore == nullptr || !pStore->func_has(pStore->pStore, owner))
            return {};
          return {pStore->func_get(pStore->pStore, owner), pItem->comp.size(), ComponentRawViewFlag_Valid};
        }
 
        const auto& ec = fetch(owner);
        const auto compIdx = ec.pChunk->comp_idx(component);
        if (compIdx == ComponentIndexBad)
          return {};
 
        const auto size = pItem->comp.size();
        if (size == 0)
          return {nullptr, 0, ComponentRawViewFlag_Valid};
 
        const auto row = uint32_t(ec.row * (1U - (uint32_t)component.kind()));
        return {ec.pChunk->comp_ptr(compIdx, row), size, ComponentRawViewFlag_Valid};
      }
 
      GAIA_NODISCARD ComponentRawMutView mut_raw(Entity entity, Entity component) {
        if (component == EntityBad || !valid(entity))
          return {};
 
        const auto& ec = fetch(entity);
        if (is_req_del(ec))
          return {};
 
        const auto* pItem = component_item(entity, component);
        if (pItem == nullptr || !raw_component_supported(*pItem))
          return {};
        if (pItem->comp.storage_type() == DataStorageType::Sparse) {
          if (component.pair())
            return {};
          const auto* pStore = sparse_component_store_erased(component);
          if (pStore == nullptr || !pStore->func_has(pStore->pStore, entity))
            return {};
          return {pStore->func_mut(pStore->pStore, entity), pItem->comp.size(), ComponentRawViewFlag_Valid};
        }
 
        const auto compIdx = core::get_index(ec.pChunk->ids_view(), component);
        if (compIdx == BadIndex)
          return {};
 
        const auto size = pItem->comp.size();
        if (size == 0)
          return {nullptr, 0, ComponentRawViewFlag_Valid};
 
        const auto row = uint32_t(ec.row * (1U - (uint32_t)component.kind()));
        return {ec.pChunk->comp_ptr_mut(compIdx, row), size, ComponentRawViewFlag_Valid};
      }
 
      GAIA_NODISCARD ComponentRawView get_raw_field(Entity entity, Entity component, uint32_t fieldIdx) const {
        if (component == EntityBad || !valid(entity))
          return {};
 
        const auto owner = id_owner_inter(entity, component);
        if (owner == EntityBad)
          return {};
 
        const auto* pItem = component_item(owner, component);
        if (pItem == nullptr || !soa_field_supported(*pItem) || fieldIdx >= pItem->comp.soa() ||
            pItem->soaSizes[fieldIdx] == 0)
          return {};
 
        const auto& ec = fetch(owner);
        const auto compIdx = ec.pChunk->comp_idx(component);
        if (compIdx == ComponentIndexBad)
          return {};
 
        const auto row = uint32_t(ec.row * (1U - (uint32_t)component.kind()));
        const auto capacity = pItem->entity.kind() == EntityKind::EK_Uni ? 1U : ec.pChunk->capacity();
        const std::span<const uint8_t> fieldSizes{pItem->soaSizes, pItem->comp.soa()};
        const auto* pData = mem::data_view_policy_soa_erased::get(
            ec.pChunk->comp_ptr(compIdx), pItem->comp.alig(), fieldSizes, fieldIdx, row, capacity);
        return {pData, pItem->soaSizes[fieldIdx], ComponentRawViewFlag_Valid};
      }
 
      GAIA_NODISCARD ComponentRawMutView mut_raw_field(Entity entity, Entity component, uint32_t fieldIdx) {
        if (component == EntityBad || !valid(entity))
          return {};
 
        const auto& ec = fetch(entity);
        if (is_req_del(ec))
          return {};
 
        const auto* pItem = component_item(entity, component);
        if (pItem == nullptr || !soa_field_supported(*pItem) || fieldIdx >= pItem->comp.soa() ||
            pItem->soaSizes[fieldIdx] == 0)
          return {};
 
        const auto compIdx = core::get_index(ec.pChunk->ids_view(), component);
        if (compIdx == BadIndex)
          return {};
 
        const auto row = uint32_t(ec.row * (1U - (uint32_t)component.kind()));
        const auto capacity = pItem->entity.kind() == EntityKind::EK_Uni ? 1U : ec.pChunk->capacity();
        const std::span<const uint8_t> fieldSizes{pItem->soaSizes, pItem->comp.soa()};
        auto* pData = mem::data_view_policy_soa_erased::set(
            ec.pChunk->comp_ptr_mut(compIdx), pItem->comp.alig(), fieldSizes, fieldIdx, row, capacity);
        return {pData, pItem->soaSizes[fieldIdx], ComponentRawViewFlag_Valid};
      }
 
      GAIA_NODISCARD ComponentCursor cursor(Entity entity, Entity component) const;
 
      GAIA_NODISCARD ComponentCursor cursor_mut(Entity entity, Entity component);
 
      bool add_raw(Entity entity, Entity component, const void* data, uint32_t size) {
        if (component == EntityBad || !valid(entity))
          return false;
 
        const auto* pItem = component.pair() ? comp_cache().find_pair_payload(component) : comp_cache().find(component);
        if (pItem == nullptr || !raw_component_payload_args_valid(*pItem, data, size))
          return false;
 
        if (has_direct(entity, component))
          return false;
        if (pItem->comp.storage_type() == DataStorageType::Sparse) {
          if (component.pair())
            return false;
          const auto mode = sparse_storage_mode(component);
          if (mode == SparseStorageMode::None)
            return false;
 
          auto& store = sparse_component_store_erased_mut(component, *pItem);
          auto* pPayload = store.func_add(store.pStore, entity);
          if (size != 0)
            memcpy(pPayload, data, size);
          finish_sparse_component_add_inter(entity, component, mode);
          return true;
        }
 
        EntityBuilder eb(*this, entity);
#if GAIA_OBSERVERS_ENABLED
        auto addDiffCtx =
            m_observers.prepare_diff(*this, ObserverEvent::OnAdd, EntitySpan{&component, 1}, EntitySpan{&entity, 1});
#endif
        eb.add_inter_init(component);
        eb.commit();
 
        const auto payload = mut_raw(entity, component);
        GAIA_ASSERT(payload.valid());
        if (payload.valid() && size != 0)
          memcpy(payload.data, data, size);
 
        notify_add_single(entity, component);
#if GAIA_OBSERVERS_ENABLED
        m_observers.finish_diff(*this, GAIA_MOV(addDiffCtx));
#endif
        return payload.valid();
      }
 
      bool set_raw(Entity entity, Entity component, const void* data, uint32_t size) {
        if (component == EntityBad)
          return false;
 
        const auto payload = mut_raw(entity, component);
        if (!payload.valid() || payload.size != size || (size != 0 && data == nullptr))
          return false;
        if (size != 0)
          memcpy(payload.data, data, size);
 
        finish_write(entity, component);
        return true;
      }
 
      void modify_raw(Entity entity, Entity component) {
        if (!mut_raw(entity, component).valid()) {
          if (component == EntityBad || !valid(entity))
            return;
 
          const auto& ec = fetch(entity);
          const auto* pItem = !is_req_del(ec) ? component_item(entity, component) : nullptr;
          if (pItem == nullptr || !soa_field_supported(*pItem) ||
              core::get_index(ec.pChunk->ids_view(), component) == BadIndex)
            return;
        }
        finish_write(entity, component);
      }
 
      //----------------------------------------------------------------------
 
      ComponentGetter acc(Entity entity) const {
        GAIA_ASSERT(valid(entity));
 
        const auto& ec = m_recs.entities[entity.id()];
        return ComponentGetter{*this, ec.pChunk, entity, ec.row};
      }
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) get(Entity entity) const {
        using FT = typename component_type_t<T>::TypeFull;
        const auto compEntity = [&]() {
          if constexpr (is_pair<FT>::value) {
            const auto rel = comp_cache().template get<typename FT::rel>().entity;
            const auto tgt = comp_cache().template get<typename FT::tgt>().entity;
            return (Entity)Pair(rel, tgt);
          } else {
            return comp_cache().template get<FT>().entity;
          }
        }();
        if constexpr (uses_compile_time_sparse_storage<FT>()) {
          const auto owner = id_owner_inter(entity, compEntity);
          GAIA_ASSERT(owner != EntityBad);
          const auto* pStore = sparse_component_store<FT>(compEntity);
          GAIA_ASSERT(pStore != nullptr);
          return pStore->get(owner);
        }
 
        const auto owner = id_owner_inter(entity, compEntity);
        GAIA_ASSERT(owner != EntityBad);
        return acc(owner).template get<T>();
      }
 
      template <typename T>
      GAIA_NODISCARD decltype(auto) get(Entity entity, Entity object) const {
        using FT = typename component_type_t<T>::TypeFull;
        if constexpr (supports_sparse_component_storage<FT>()) {
          if (can_use_sparse_component_storage<FT>(object)) {
            const auto owner = id_owner_inter(entity, object);
            GAIA_ASSERT(owner != EntityBad);
            return sparse_component_get_value<FT>(object, owner);
          }
        }
 
        const auto owner = id_owner_inter(entity, object);
        GAIA_ASSERT(owner != EntityBad);
        return acc(owner).template get<T>(object);
      }
 
      //----------------------------------------------------------------------
 
      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* pPair = m_recs.pair_record_find(entity);
          if (pPair == nullptr)
            return false;
 
          const auto& ec = *pPair;
          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() || !m_recs.entities.has(entity.id()))
            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 {
        return has_inter(entity, object, true);
      }
 
      GAIA_NODISCARD bool has_direct(Entity entity, Entity object) const {
        return has_inter(entity, object, false);
      }
 
      GAIA_NODISCARD bool has_direct(Entity entity, Pair pair) const {
        return has_inter(entity, (Entity)pair, false);
      }
 
    private:
      GAIA_NODISCARD bool has_inter(Entity entity, Entity object, bool allowSemanticIs) const {
        const auto& ec = fetch(entity);
        if (is_req_del(ec))
          return false;
 
        if (object.pair() && has_nonfragmenting_relation_pair(entity, object))
          return true;
        if (!object.pair()) {
          const auto itSparseStore = m_sparseComponentsByComp.find(EntityLookupKey(object));
          if (itSparseStore != m_sparseComponentsByComp.end())
            return has_direct_sparse_component_inter(entity, object) ||
                   (allowSemanticIs && inherited_id_owner(entity, object) != EntityBad);
        }
 
        const auto* pArchetype = ec.pArchetype;
 
        if (object.pair()) {
          if (allowSemanticIs && object.id() == Is.id() && !is_wildcard(object.gen())) {
            const auto target = get(object.gen());
            return valid(target) && is(entity, target);
          }
 
          // 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;
          }
        }
 
        if (pArchetype->has(object))
          return true;
 
        return allowSemanticIs && inherited_id_owner(entity, object) != EntityBad;
      }
 
    public:
      GAIA_NODISCARD std::span<const Entity> lookup_path() const {
        return {m_componentLookupPath.data(), m_componentLookupPath.size()};
      }
 
      void lookup_path(std::span<const Entity> scopes) {
        m_componentLookupPath.clear();
        m_componentLookupPath.reserve((uint32_t)scopes.size());
        for (const auto scopeEntity: scopes) {
          GAIA_ASSERT(scopeEntity != EntityBad && valid(scopeEntity) && !scopeEntity.pair());
          if (scopeEntity == EntityBad || !valid(scopeEntity) || scopeEntity.pair())
            continue;
 
          m_componentLookupPath.push_back(scopeEntity);
        }
      }
 
      GAIA_NODISCARD Entity scope() const {
        return m_componentScope;
      }
 
      Entity scope(Entity scope) {
        GAIA_ASSERT(scope == EntityBad || (valid(scope) && !scope.pair()));
        const auto prev = m_componentScope;
        if (scope == EntityBad || (valid(scope) && !scope.pair())) {
          m_componentScope = scope;
          invalidate_scope_path_cache();
        }
        return prev;
      }
 
      template <typename Func>
      void scope(Entity scopeEntity, Func&& func) {
        struct ComponentScopeRestore final {
          World& world;
          Entity prevScope;
          ~ComponentScopeRestore() {
            world.scope(prevScope);
          }
        };
 
        ComponentScopeRestore restore{*this, scope(scopeEntity)};
        func();
      }
 
      Entity module(const char* path, uint32_t len = 0) {
        if (path == nullptr || path[0] == 0)
          return EntityBad;
 
        const auto l = len == 0 ? (uint32_t)GAIA_STRLEN(path, ComponentCacheItem::MaxNameLength) : len;
        if (l == 0 || l >= ComponentCacheItem::MaxNameLength)
          return EntityBad;
        if (path[l - 1] == '.')
          return EntityBad;
 
        Entity parent = EntityBad;
        uint32_t partBeg = 0;
        while (partBeg < l) {
          uint32_t partEnd = partBeg;
          while (partEnd < l && path[partEnd] != '.')
            ++partEnd;
          if (partEnd == partBeg)
            return EntityBad;
 
          const auto partLen = partEnd - partBeg;
          const auto key = EntityNameLookupKey(path + partBeg, partLen, 0);
          const auto it = m_nameToEntity.find(key);
          Entity curr = EntityBad;
 
          if (it != m_nameToEntity.end()) {
            curr = it->second;
            if (parent != EntityBad && !static_cast<const World&>(*this).child(curr, parent)) {
              GAIA_ASSERT2(false, "Module path collides with an existing entity name outside the requested scope");
              return EntityBad;
            }
          } else {
            curr = add();
            name(curr, path + partBeg, partLen);
            if (parent != EntityBad)
              child(curr, parent);
          }
 
          parent = curr;
          partBeg = partEnd + 1;
        }
 
        return parent;
      }
 
      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));
 
        using FT = typename component_type_t<T>::TypeFull;
        const auto compEntity = [&]() {
          if constexpr (is_pair<FT>::value) {
            const auto* pRel = comp_cache().template find<typename FT::rel>();
            const auto* pTgt = comp_cache().template find<typename FT::tgt>();
            if (pRel == nullptr || pTgt == nullptr)
              return EntityBad;
 
            const auto rel = pRel->entity;
            const auto tgt = pTgt->entity;
            return (Entity)Pair(rel, tgt);
          } else {
            const auto* pItem = comp_cache().template find<FT>();
            return pItem != nullptr ? pItem->entity : EntityBad;
          }
        }();
        if (compEntity == EntityBad)
          return false;
 
        return id_owner_inter(entity, compEntity) != EntityBad;
      }
 
      //----------------------------------------------------------------------
 
      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 util::str_view name(Entity entity) const {
        if (entity.pair())
          return {};
 
        const auto& ec = m_recs.entities[entity.id()];
        const auto compIdx = core::get_index(ec.pChunk->ids_view(), GAIA_ID(EntityDesc));
        if (compIdx == BadIndex)
          return {};
 
        const auto* pDesc = reinterpret_cast<const EntityDesc*>(ec.pChunk->comp_ptr(compIdx, ec.row));
        GAIA_ASSERT(core::check_alignment(pDesc));
        return {pDesc->name, pDesc->name_len};
      }
 
      GAIA_NODISCARD util::str_view name(EntityId entityId) const {
        auto entity = get(entityId);
        return name(entity);
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD Entity resolve(const char* name, uint32_t len = 0) const {
        if (name == nullptr || name[0] == 0)
          return EntityBad;
 
        const auto l = len == 0 ? (uint32_t)GAIA_STRLEN(name, ComponentCacheItem::MaxNameLength) : len;
        GAIA_ASSERT(l < ComponentCacheItem::MaxNameLength);
 
        if (memchr(name, '.', l) != nullptr) {
          const auto entity = get_entity_inter(name, l);
          if (entity != EntityBad)
            return entity;
        }
 
        return get_inter(name, l);
      }
 
      void resolve(cnt::darray<Entity>& out, const char* name, uint32_t len = 0) const {
        out.clear();
        if (name == nullptr || name[0] == 0)
          return;
 
        const auto l = len == 0 ? (uint32_t)GAIA_STRLEN(name, ComponentCacheItem::MaxNameLength) : len;
        GAIA_ASSERT(l < ComponentCacheItem::MaxNameLength);
 
        auto push_unique = [&](Entity entity) {
          if (entity == EntityBad)
            return;
          for (const auto existing: out) {
            if (existing == entity)
              return;
          }
          out.push_back(entity);
        };
 
        push_unique(get_entity_inter(name, l));
 
        if (memchr(name, '.', l) == nullptr && memchr(name, ':', l) == nullptr)
          add_comp_lookup_hits_inter(out, name, l);
 
        const bool isPath = memchr(name, '.', l) != nullptr;
        const bool isSymbol = memchr(name, ':', l) != nullptr;
        add_comp_exact_hits_inter(out, name, l, isPath, isSymbol);
 
        push_unique(alias(name, l));
      }
 
      GAIA_NODISCARD Entity get(const char* name, uint32_t len = 0) const {
        return resolve(name, len);
      }
 
    private:
      GAIA_NODISCARD Entity find_named_entity_inter(const char* name, uint32_t len = 0) const {
        if (name == nullptr || name[0] == 0)
          return EntityBad;
 
        const auto key = EntityNameLookupKey(name, len, 0);
        const auto it = m_nameToEntity.find(key);
        return it != m_nameToEntity.end() ? it->second : EntityBad;
      }
 
      GAIA_NODISCARD bool hierarchy_child_matches_parent(Entity child, Entity parent) const {
        return this->child(child, parent) || this->parent(child, parent);
      }
 
      GAIA_NODISCARD Entity get_entity_inter(const char* name, uint32_t len = 0) const {
        if (name == nullptr || name[0] == 0)
          return EntityBad;
 
        if (len == 0) {
          while (name[len] != '\0')
            ++len;
        }
 
        Entity parent = EntityBad;
        Entity child = EntityBad;
        uint32_t posDot = 0;
        std::span<const char> str(name, len);
 
        posDot = core::get_index(str, '.');
        if (posDot == BadIndex)
          return find_named_entity_inter(str.data(), (uint32_t)str.size());
 
        if (posDot == 0)
          return EntityBad;
 
        parent = find_named_entity_inter(str.data(), posDot);
        if (parent == EntityBad)
          return EntityBad;
 
        str = str.subspan(posDot + 1);
        while (!str.empty()) {
          posDot = core::get_index(str, '.');
 
          if (posDot == BadIndex) {
            child = find_named_entity_inter(str.data(), (uint32_t)str.size());
            if (child == EntityBad || !hierarchy_child_matches_parent(child, parent))
              return EntityBad;
 
            return child;
          }
 
          if (posDot == 0)
            return EntityBad;
 
          child = find_named_entity_inter(str.data(), posDot);
          if (child == EntityBad || !hierarchy_child_matches_parent(child, parent))
            return EntityBad;
 
          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 l = key.len();
        const bool isUnqualifiedCompName = is_unqualified_comp_name_inter(name, l);
        const auto namedEntity = find_named_entity_inter(name, l);
 
        if (has_comp_lookup_ctx_inter() && isUnqualifiedCompName) {
          if (const auto* pScopedItem = resolve_component_name_inter(name, l); pScopedItem != nullptr)
            return pick_name_or_comp_inter(namedEntity, pScopedItem);
        }
 
        if (namedEntity != EntityBad)
          return namedEntity;
 
        if (const auto* pItem = resolve_component_name_inter(name, l); pItem != nullptr)
          return pItem->entity;
 
        const auto aliasEntity = alias(name, l);
        if (aliasEntity != EntityBad)
          return aliasEntity;
 
        // No entity with the given name exists. Return a bad entity
        return EntityBad;
      }
 
    public:
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD const cnt::set<EntityLookupKey>* relations(Entity target) const {
        return m_pairLookup.relations(target);
      }
 
      GAIA_NODISCARD Entity relation(Entity entity, Entity target) const {
        GAIA_ASSERT(valid(entity));
        if (!valid(target))
          return EntityBad;
 
        for (const auto& it: m_nonFragmentingRelationsByRel) {
          if (it.second.target(entity) == target)
            return it.first.entity();
        }
 
        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;
 
        const auto indices = pArchetype->pair_tgt_indices(target);
        if (indices.empty())
          return EntityBad;
 
        const auto ids = pArchetype->ids_view();
        const auto e = ids[indices[0]];
        const auto& ecRel = m_recs.entities[e.id()];
        return *ecRel.pEntity;
      }
 
      template <typename Func>
      void relations(Entity entity, Entity target, Func func) const {
        GAIA_ASSERT(valid(entity));
        if (!valid(target))
          return;
 
        for (const auto& it: m_nonFragmentingRelationsByRel) {
          if (it.second.target(entity) == target)
            func(it.first.entity());
        }
 
        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;
 
        const auto ids = pArchetype->ids_view();
        for (auto idsIdx: pArchetype->pair_tgt_indices(target)) {
          const auto e = ids[idsIdx];
 
          const auto& ecRel = m_recs.entities[e.id()];
          auto relation = *ecRel.pEntity;
          func(relation);
        }
      }
 
      template <typename Func>
      void relations_if(Entity entity, Entity target, Func func) const {
        GAIA_ASSERT(valid(entity));
        if (!valid(target))
          return;
 
        for (const auto& it: m_nonFragmentingRelationsByRel) {
          if (it.second.target(entity) == target && !func(it.first.entity()))
            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;
 
        const auto ids = pArchetype->ids_view();
        for (auto idsIdx: pArchetype->pair_tgt_indices(target)) {
          const auto e = ids[idsIdx];
 
          const auto& ecRel = m_recs.entities[e.id()];
          auto relation = *ecRel.pEntity;
          if (!func(relation))
            return;
        }
      }
 
      GAIA_NODISCARD const cnt::darray<Entity>& as_relations_trav_cache(Entity target) const {
        const auto key = EntityLookupKey(target);
        const auto itCache = m_entityToAsRelationsTravCache.find(key);
        if (itCache != m_entityToAsRelationsTravCache.end())
          return itCache->second;
 
        auto& cache = m_entityToAsRelationsTravCache[key];
        const auto it = m_entityToAsRelations.find(key);
        if (it == m_entityToAsRelations.end())
          return cache;
 
        cnt::darray_ext<EntityLookupKey, 32> stack;
        stack.reserve((uint32_t)it->second.size());
        for (auto relation: it->second)
          stack.push_back(relation);
 
        while (!stack.empty()) {
          const auto relationKey = stack.back();
          stack.pop_back();
 
          const auto relation = relationKey.entity();
          cache.push_back(relation);
 
          const auto itChild = m_entityToAsRelations.find(relationKey);
          if (itChild == m_entityToAsRelations.end())
            continue;
 
          for (auto childRelation: itChild->second)
            stack.push_back(childRelation);
        }
 
        return cache;
      }
 
      GAIA_NODISCARD const cnt::darray<Entity>& as_targets_trav_cache(Entity relation) const {
        const auto key = EntityLookupKey(relation);
        const auto itCache = m_entityToAsTargetsTravCache.find(key);
        if (itCache != m_entityToAsTargetsTravCache.end())
          return itCache->second;
 
        auto& cache = m_entityToAsTargetsTravCache[key];
        const auto it = m_entityToAsTargets.find(key);
        if (it == m_entityToAsTargets.end())
          return cache;
 
        cnt::darray_ext<EntityLookupKey, 16> stack;
        stack.reserve((uint32_t)it->second.size());
        for (auto target: it->second)
          stack.push_back(target);
 
        while (!stack.empty()) {
          const auto targetKey = stack.back();
          stack.pop_back();
 
          const auto target = targetKey.entity();
          cache.push_back(target);
 
          const auto itChild = m_entityToAsTargets.find(targetKey);
          if (itChild == m_entityToAsTargets.end())
            continue;
 
          for (auto childTarget: itChild->second)
            stack.push_back(childTarget);
        }
 
        return cache;
      }
 
      GAIA_NODISCARD const cnt::darray<Entity>& targets_trav_cache(Entity relation, Entity source) const {
        const auto key = EntityLookupKey(Pair(relation, source));
        const auto itCache = m_targetsTravCache.find(key);
        if (itCache != m_targetsTravCache.end())
          return itCache->second;
 
        auto& cache = m_targetsTravCache[key];
        m_relationCachesPopulated = true;
        if (!valid(relation) || !valid(source))
          return cache;
 
        auto curr = source;
        GAIA_FOR(MAX_TRAV_DEPTH) {
          const auto next = target(curr, relation);
          if (next == EntityBad || next == curr)
            break;
 
          cache.push_back(next);
          curr = next;
        }
 
        return cache;
      }
 
      GAIA_NODISCARD const cnt::darray<Entity>& targets_all_cache(Entity source) const {
        const auto key = EntityLookupKey(source);
        const auto itCache = m_targetsAllCache.find(key);
        if (itCache != m_targetsAllCache.end())
          return itCache->second;
 
        auto& cache = m_targetsAllCache[key];
        m_relationCachesPopulated = true;
        if (!valid(source))
          return cache;
 
        const auto visitStamp = next_entity_visit_stamp();
 
        for (const auto& it: m_nonFragmentingRelationsByRel) {
          const auto target = it.second.target(source);
          if (target != EntityBad && try_mark_entity_visited(target, visitStamp))
            cache.push_back(target);
        }
 
        const auto& ec = fetch(source);
        const auto* pArchetype = ec.pArchetype;
        if (pArchetype->pairs() == 0)
          return cache;
 
        const auto ids = pArchetype->ids_view();
        for (auto idsIdx: pArchetype->pair_indices()) {
          const auto id = ids[idsIdx];
          const auto target = pair_target_if_alive(id);
          if (target == EntityBad)
            continue;
          if (try_mark_entity_visited(target, visitStamp))
            cache.push_back(target);
        }
 
        return cache;
      }
 
      GAIA_NODISCARD const cnt::darray<Entity>& sources_all_cache(Entity target) const {
        const auto key = EntityLookupKey(target);
        const auto itCache = m_sourcesAllCache.find(key);
        if (itCache != m_sourcesAllCache.end())
          return itCache->second;
 
        auto& cache = m_sourcesAllCache[key];
        m_relationCachesPopulated = true;
        if (!valid(target))
          return cache;
 
        const auto visitStamp = next_entity_visit_stamp();
 
        for (const auto& [relKey, store]: m_nonFragmentingRelationsByRel) {
          (void)relKey;
          const auto* pSources = store.sources(target);
          if (pSources == nullptr)
            continue;
 
          for (auto source: *pSources) {
            if (valid(source) && try_mark_entity_visited(source, visitStamp))
              cache.push_back(source);
          }
        }
 
        const auto pair = Pair(All, target);
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(pair));
        if (it == m_entityToArchetypeMap.end())
          return cache;
 
        for (const auto& record: it->second) {
          const auto* pArchetype = record.pArchetype;
          if (pArchetype->is_req_del())
            continue;
 
          for (const auto* pChunk: pArchetype->chunks()) {
            const auto entities = pChunk->entity_view();
            GAIA_EACH(entities) {
              const auto source = entities[i];
              if (!valid(source))
                continue;
              if (try_mark_entity_visited(source, visitStamp))
                cache.push_back(source);
            }
          }
        }
 
        return cache;
      }
 
      template <typename Func>
      void targets_trav(Entity relation, Entity source, Func func) const {
        if (!valid(relation) || !valid(source))
          return;
 
        auto curr = source;
        GAIA_FOR(MAX_TRAV_DEPTH) {
          const auto next = target(curr, relation);
          if (next == EntityBad || next == curr)
            break;
          if (!enabled(next))
            break;
 
          func(next);
          curr = next;
        }
      }
 
      template <typename Func>
      GAIA_NODISCARD bool targets_trav_if(Entity relation, Entity source, Func func) const {
        if (!valid(relation) || !valid(source))
          return false;
 
        auto curr = source;
        GAIA_FOR(MAX_TRAV_DEPTH) {
          const auto next = target(curr, relation);
          if (next == EntityBad || next == curr)
            break;
          if (!enabled(next))
            break;
 
          if (!func(next))
            return true;
          curr = next;
        }
 
        return false;
      }
 
      GAIA_NODISCARD const cnt::darray<Entity>& sources_bfs_trav_cache(Entity relation, Entity rootTarget) const {
        const auto key = EntityLookupKey(Pair(relation, rootTarget));
        const auto itCache = m_srcBfsTravCache.find(key);
        if (itCache != m_srcBfsTravCache.end())
          return itCache->second;
 
        auto& cache = m_srcBfsTravCache[key];
        m_relationCachesPopulated = true;
        if (!valid(relation) || !valid(rootTarget))
          return cache;
 
        cnt::darray_ext<Entity, 64> children;
        cnt::darray_ext<Entity, 32> queue;
        queue.push_back(rootTarget);
 
        cnt::set<EntityLookupKey> visited;
        visited.insert(EntityLookupKey(rootTarget));
 
        for (uint32_t i = 0; i < queue.size(); ++i) {
          const auto currTarget = queue[i];
 
          children.clear();
          sources(relation, currTarget, [&](Entity source) {
            const auto keySource = EntityLookupKey(source);
            const auto& ins = visited.insert(keySource);
            if (!ins.second)
              return;
 
            children.push_back(source);
          });
 
          core::sort(children, [](Entity left, Entity right) {
            return left.id() < right.id();
          });
 
          for (auto child: children) {
            cache.push_back(child);
            queue.push_back(child);
          }
        }
 
        return cache;
      }
 
      GAIA_NODISCARD uint32_t depth_order_cache(Entity relation, Entity sourceTarget) const {
        const auto key = EntityLookupKey(Pair(relation, sourceTarget));
        const auto itCache = m_depthOrderCache.find(key);
        if (itCache != m_depthOrderCache.end()) {
          GAIA_ASSERT(itCache->second != GroupIdMax && "depth_order requires an acyclic relation graph");
          return itCache->second;
        }
 
        if (!valid(relation) || !valid(sourceTarget))
          return 0;
 
        // Mark this node as in-flight so cycles trip a debug assert instead of recursing forever.
        m_relationCachesPopulated = true;
        m_depthOrderCache[key] = GroupIdMax;
 
        uint32_t depth = 1;
        targets(sourceTarget, relation, [&](Entity next) {
          const auto nextDepth = depth_order_cache(relation, next);
          if (nextDepth == 0)
            return;
          const auto candidate = nextDepth + 1;
          if (candidate > depth)
            depth = candidate;
        });
 
        m_depthOrderCache[key] = depth;
        return depth;
      }
 
      template <typename Func>
      void as_relations_trav(Entity target, Func func) const {
        if (!valid(target))
          return;
 
        const auto& relations = as_relations_trav_cache(target);
        for (auto relation: relations)
          func(relation);
      }
 
      template <typename Func>
      GAIA_NODISCARD bool as_relations_trav_if(Entity target, Func func) const {
        if (!valid(target))
          return false;
 
        const auto& relations = as_relations_trav_cache(target);
        for (auto relation: relations) {
          if (func(relation))
            return true;
        }
 
        return false;
      }
 
      //----------------------------------------------------------------------
 
      GAIA_NODISCARD const cnt::set<EntityLookupKey>* targets(Entity relation) const {
        return m_pairLookup.targets(relation);
      }
 
      GAIA_NODISCARD Entity target(Entity entity, Entity relation) const {
        if (!valid(entity))
          return EntityBad;
        if (relation != All && !valid(relation))
          return EntityBad;
 
        if (relation == All) {
          const auto& targets = targets_all_cache(entity);
          return targets.empty() ? EntityBad : targets[0];
        }
 
        if (relation_uses_non_fragmenting_storage(relation)) {
          const auto* pStore = nonfragmenting_relation_store(relation);
          if (pStore == nullptr)
            return EntityBad;
 
          return pStore->target(entity);
        }
 
        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;
 
        const auto ids = pArchetype->ids_view();
        for (auto idsIdx: pArchetype->pair_rel_indices(relation)) {
          const auto e = ids[idsIdx];
          const auto target = pair_target_if_alive(e);
          if (target == EntityBad)
            continue;
          return target;
        }
 
        return EntityBad;
      }
 
      template <typename Func>
      void targets(Entity entity, Entity relation, Func func) const {
        if (!valid(entity))
          return;
        if (relation != All && !valid(relation))
          return;
 
        if (relation == All) {
          for (auto target: targets_all_cache(entity))
            func(target);
          return;
        }
 
        if (relation_uses_non_fragmenting_storage(relation)) {
          const auto target = this->target(entity, relation);
          if (target != EntityBad)
            func(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;
 
        const auto ids = pArchetype->ids_view();
        for (auto idsIdx: pArchetype->pair_rel_indices(relation)) {
          const auto e = ids[idsIdx];
          const auto target = pair_target_if_alive(e);
          if (target == EntityBad)
            continue;
          func(target);
        }
      }
 
      template <typename Func>
      void targets_if(Entity entity, Entity relation, Func func) const {
        GAIA_ASSERT(valid(entity));
        if (relation != All && !valid(relation))
          return;
 
        if (relation == All) {
          for (auto target: targets_all_cache(entity)) {
            if (!func(target))
              return;
          }
          return;
        }
 
        if (relation_uses_non_fragmenting_storage(relation)) {
          const auto target = this->target(entity, relation);
          if (target != EntityBad)
            (void)func(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;
 
        const auto ids = pArchetype->ids_view();
        for (auto idsIdx: pArchetype->pair_rel_indices(relation)) {
          const auto e = ids[idsIdx];
          const auto target = pair_target_if_alive(e);
          if (target == EntityBad)
            continue;
          if (!func(target))
            return;
        }
      }
 
      GAIA_NODISCARD Entity pair_target_if_alive(Entity pair) const {
        GAIA_ASSERT(pair.pair());
        if (!valid_entity_id((EntityId)pair.gen()))
          return EntityBad;
 
        const auto& ecTarget = m_recs.entities[pair.gen()];
        if (ecTarget.pEntity == nullptr)
          return EntityBad;
 
        const auto target = *ecTarget.pEntity;
        return valid(target) ? target : EntityBad;
      }
 
      template <typename Func>
      void sources(Entity relation, Entity target, Func func) const {
        if ((relation != All && !valid(relation)) || !valid(target))
          return;
 
        if (relation == All) {
          for (auto source: sources_all_cache(target))
            func(source);
          return;
        }
 
        if (relation_uses_non_fragmenting_storage(relation)) {
          const auto* pStore = nonfragmenting_relation_store(relation);
          if (pStore == nullptr)
            return;
 
          const auto* pSources = pStore->sources(target);
          if (pSources == nullptr)
            return;
 
          for (auto source: *pSources) {
            if (!valid(source))
              continue;
 
            func(source);
          }
          return;
        }
 
        const auto pair = Pair(relation, target);
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(pair));
        if (it == m_entityToArchetypeMap.end())
          return;
 
        for (const auto& record: it->second) {
          const auto* pArchetype = record.pArchetype;
          if (pArchetype->is_req_del())
            continue;
 
          for (const auto* pChunk: pArchetype->chunks()) {
            auto entities = pChunk->entity_view();
            GAIA_EACH(entities) {
              const auto source = entities[i];
              if (!valid(source))
                continue;
              func(source);
            }
          }
        }
      }
 
      template <typename Func>
      void sources_if(Entity relation, Entity target, Func func) const {
        if ((relation != All && !valid(relation)) || !valid(target))
          return;
 
        if (relation == All) {
          for (auto source: sources_all_cache(target)) {
            if (!func(source))
              return;
          }
          return;
        }
 
        if (relation_uses_non_fragmenting_storage(relation)) {
          const auto* pStore = nonfragmenting_relation_store(relation);
          if (pStore == nullptr)
            return;
 
          const auto* pSources = pStore->sources(target);
          if (pSources == nullptr)
            return;
 
          for (auto source: *pSources) {
            if (!valid(source))
              continue;
 
            if (!func(source))
              return;
          }
          return;
        }
 
        const auto pair = Pair(relation, target);
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(pair));
        if (it == m_entityToArchetypeMap.end())
          return;
 
        for (const auto& record: it->second) {
          const auto* pArchetype = record.pArchetype;
          if (pArchetype->is_req_del())
            continue;
 
          for (const auto* pChunk: pArchetype->chunks()) {
            auto entities = pChunk->entity_view();
            GAIA_EACH(entities) {
              const auto source = entities[i];
              if (!valid(source))
                continue;
              if (!func(source))
                return;
            }
          }
        }
      }
 
    private:
      GAIA_NODISCARD uint64_t next_entity_visit_stamp() const {
        ++m_entityVisitStamp;
        if (m_entityVisitStamp != 0)
          return m_entityVisitStamp;
 
        const auto cnt = (uint32_t)m_entityVisitStamps.size();
        GAIA_FOR(cnt) {
          m_entityVisitStamps[i] = 0;
        }
 
        m_entityVisitStamp = 1;
        return m_entityVisitStamp;
      }
 
      GAIA_NODISCARD bool try_mark_entity_visited(Entity entity, uint64_t stamp) const {
        GAIA_ASSERT(!entity.pair());
        if (entity.id() >= m_entityVisitStamps.size())
          m_entityVisitStamps.resize(m_recs.entities.size(), 0);
 
        auto& slot = m_entityVisitStamps[entity.id()];
        if (slot == stamp)
          return false;
 
        slot = stamp;
        return true;
      }
 
      template <typename Func>
      GAIA_NODISCARD bool for_each_inherited_term_entity(Entity term, Func&& func) const {
        cnt::set<EntityLookupKey> seen;
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(term));
        if (it == m_entityToArchetypeMap.end())
          return true;
 
        for (const auto& record: it->second) {
          const auto* pArchetype = record.pArchetype;
          if (pArchetype->is_req_del())
            continue;
 
          for (const auto* pChunk: pArchetype->chunks()) {
            const auto entities = pChunk->entity_view();
            GAIA_EACH(entities) {
              const auto entity = entities[i];
              GAIA_ASSERT(valid(entity));
              const auto entityKey = EntityLookupKey(entity);
              if (seen.contains(entityKey))
                continue;
              seen.insert(entityKey);
 
              if (!func(entity))
                return false;
 
              const auto& descendants = as_relations_trav_cache(entity);
              for (const auto descendant: descendants) {
                GAIA_ASSERT(valid(descendant));
                const auto descendantKey = EntityLookupKey(descendant);
                if (seen.contains(descendantKey))
                  continue;
                seen.insert(descendantKey);
 
                if (!func(descendant))
                  return false;
              }
            }
          }
        }
 
        return true;
      }
 
      GAIA_NODISCARD uint32_t count_direct_term_entities_inter(Entity term, bool allowSemanticIs) const {
        if (term == EntityBad)
          return 0;
 
        if (allowSemanticIs && term.pair() && term.id() == Is.id() && !is_wildcard(term.gen())) {
          const auto target = get(term.gen());
          if (!valid(target))
            return 0;
 
          return (uint32_t)as_relations_trav_cache(target).size() + 1;
        }
 
        if (allowSemanticIs && !is_wildcard(term) && valid(term) && target(term, OnInstantiate) == Inherit) {
          uint32_t cnt = 0;
          (void)for_each_inherited_term_entity(term, [&](Entity) {
            ++cnt;
            return true;
          });
          return cnt;
        }
 
        if (term.pair() && relation_uses_non_fragmenting_storage(pair_rel(*this, term))) {
          const auto relation = pair_rel(*this, term);
          const auto* pStore = nonfragmenting_relation_store(relation);
          if (pStore == nullptr)
            return 0;
 
          if (is_wildcard(term.gen()))
            return pStore->source_count();
 
          const auto* pSources = pStore->sources(pair_tgt(*this, term));
          return pSources != nullptr ? (uint32_t)pSources->size() : 0;
        }
 
        if (!term.pair() && component_is_non_fragmenting(term)) {
          const auto it = m_sparseComponentsByComp.find(EntityLookupKey(term));
          return it != m_sparseComponentsByComp.end() ? it->second.func_count(it->second.pStore) : 0;
        }
 
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(term));
        if (it == m_entityToArchetypeMap.end())
          return 0;
 
        uint32_t cnt = 0;
        for (const auto& record: it->second) {
          const auto* pArchetype = record.pArchetype;
          if (pArchetype->is_req_del())
            continue;
          for (const auto* pChunk: pArchetype->chunks())
            cnt += pChunk->size();
        }
 
        return cnt;
      }
 
      void collect_direct_term_entities_inter(Entity term, cnt::darray<Entity>& out, bool allowSemanticIs) const {
        if (term == EntityBad)
          return;
 
        if (allowSemanticIs && term.pair() && term.id() == Is.id() && !is_wildcard(term.gen())) {
          const auto target = get(term.gen());
          if (!valid(target))
            return;
 
          out.push_back(target);
          const auto& relations = as_relations_trav_cache(target);
          out.reserve(out.size() + (uint32_t)relations.size());
          for (auto relation: relations)
            out.push_back(relation);
          return;
        }
 
        if (allowSemanticIs && !is_wildcard(term) && valid(term) && target(term, OnInstantiate) == Inherit) {
          (void)for_each_inherited_term_entity(term, [&](Entity entity) {
            out.push_back(entity);
            return true;
          });
          return;
        }
 
        if (term.pair() && relation_uses_non_fragmenting_storage(pair_rel(*this, term))) {
          const auto relation = pair_rel(*this, term);
          const auto* pStore = nonfragmenting_relation_store(relation);
          if (pStore == nullptr)
            return;
 
          if (is_wildcard(term.gen())) {
            cnt::darray<EntityId> sourceIds;
            pStore->collect_source_ids(sourceIds);
            out.reserve(out.size() + pStore->source_count());
            for (auto sourceId: sourceIds) {
              if (!m_recs.entities.has(sourceId))
                continue;
              out.push_back(EntityContainer::handle(m_recs.entities[sourceId]));
            }
            return;
          }
 
          const auto* pSources = pStore->sources(pair_tgt(*this, term));
          if (pSources == nullptr)
            return;
 
          out.reserve(out.size() + (uint32_t)pSources->size());
          for (auto source: *pSources)
            out.push_back(source);
          return;
        }
 
        if (!term.pair() && component_is_non_fragmenting(term)) {
          const auto it = m_sparseComponentsByComp.find(EntityLookupKey(term));
          if (it != m_sparseComponentsByComp.end())
            it->second.func_collect_entities(it->second.pStore, out);
          return;
        }
 
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(term));
        if (it == m_entityToArchetypeMap.end())
          return;
 
        for (const auto& record: it->second) {
          const auto* pArchetype = record.pArchetype;
          if (pArchetype->is_req_del())
            continue;
 
          for (const auto* pChunk: pArchetype->chunks()) {
            const auto entities = pChunk->entity_view();
            out.reserve(out.size() + (uint32_t)entities.size());
            GAIA_EACH(entities)
            out.push_back(entities[i]);
          }
        }
      }
 
      GAIA_NODISCARD bool for_each_direct_term_entity_inter(
          Entity term, void* ctx, bool (*func)(void*, Entity), bool allowSemanticIs) const {
        if (term == EntityBad)
          return true;
 
        if (allowSemanticIs && term.pair() && term.id() == Is.id() && !is_wildcard(term.gen())) {
          const auto target = get(term.gen());
          if (!valid(target))
            return true;
 
          if (!func(ctx, target))
            return false;
 
          const auto& relations = as_relations_trav_cache(target);
          for (auto relation: relations) {
            if (!func(ctx, relation))
              return false;
          }
          return true;
        }
 
        if (allowSemanticIs && !is_wildcard(term) && valid(term) && target(term, OnInstantiate) == Inherit) {
          return for_each_inherited_term_entity(term, [&](Entity entity) {
            return func(ctx, entity);
          });
        }
 
        if (term.pair() && relation_uses_non_fragmenting_storage(pair_rel(*this, term))) {
          const auto relation = pair_rel(*this, term);
          const auto* pStore = nonfragmenting_relation_store(relation);
          if (pStore == nullptr)
            return true;
 
          if (is_wildcard(term.gen())) {
            cnt::darray<EntityId> sourceIds;
            pStore->collect_source_ids(sourceIds);
            for (auto sourceId: sourceIds) {
              if (!m_recs.entities.has(sourceId))
                continue;
              if (!func(ctx, EntityContainer::handle(m_recs.entities[sourceId])))
                return false;
            }
            return true;
          }
 
          const auto* pSources = pStore->sources(pair_tgt(*this, term));
          if (pSources == nullptr)
            return true;
 
          for (auto source: *pSources) {
            if (!func(ctx, source))
              return false;
          }
          return true;
        }
 
        if (!term.pair() && component_is_non_fragmenting(term)) {
          const auto it = m_sparseComponentsByComp.find(EntityLookupKey(term));
          if (it == m_sparseComponentsByComp.end())
            return true;
          return it->second.func_for_each_entity(it->second.pStore, ctx, func);
        }
 
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(term));
        if (it == m_entityToArchetypeMap.end())
          return true;
 
        for (const auto& record: it->second) {
          const auto* pArchetype = record.pArchetype;
          if (pArchetype->is_req_del())
            continue;
 
          for (const auto* pChunk: pArchetype->chunks()) {
            const auto entities = pChunk->entity_view();
            GAIA_EACH(entities) {
              if (!func(ctx, entities[i]))
                return false;
            }
          }
        }
 
        return true;
      }
 
    public:
      GAIA_NODISCARD uint32_t count_direct_term_entities(Entity term) const {
        return count_direct_term_entities_inter(term, true);
      }
 
      GAIA_NODISCARD uint32_t count_direct_term_entities_direct(Entity term) const {
        return count_direct_term_entities_inter(term, false);
      }
 
      void collect_direct_term_entities(Entity term, cnt::darray<Entity>& out) const {
        collect_direct_term_entities_inter(term, out, true);
      }
 
      void collect_direct_term_entities_direct(Entity term, cnt::darray<Entity>& out) const {
        collect_direct_term_entities_inter(term, out, false);
      }
 
      GAIA_NODISCARD bool for_each_direct_term_entity(Entity term, void* ctx, bool (*func)(void*, Entity)) const {
        return for_each_direct_term_entity_inter(term, ctx, func, true);
      }
 
      GAIA_NODISCARD bool
      for_each_direct_term_entity_direct(Entity term, void* ctx, bool (*func)(void*, Entity)) const {
        return for_each_direct_term_entity_inter(term, ctx, func, false);
      }
 
      template <typename Func>
      void sources_bfs(Entity relation, Entity rootTarget, Func func) const {
        if (!valid(relation) || !valid(rootTarget))
          return;
 
        if (m_enabledHierarchyVersion == 0) {
          const auto& cachedSources = sources_bfs_trav_cache(relation, rootTarget);
          for (auto source: cachedSources)
            func(source);
          return;
        }
 
        cnt::darray_ext<Entity, 64> children;
        cnt::darray_ext<Entity, 32> queue;
        queue.push_back(rootTarget);
 
        cnt::set<EntityLookupKey> visited;
        visited.insert(EntityLookupKey(rootTarget));
 
        for (uint32_t i = 0; i < queue.size(); ++i) {
          const auto currTarget = queue[i];
 
          children.clear();
          sources(relation, currTarget, [&](Entity source) {
            const auto key = EntityLookupKey(source);
            const auto ins = visited.insert(key);
            if (!ins.second)
              return;
 
            children.push_back(source);
          });
 
          core::sort(children, [](Entity left, Entity right) {
            return left.id() < right.id();
          });
 
          for (auto child: children) {
            if (!enabled(child))
              continue;
            func(child);
            queue.push_back(child);
          }
        }
      }
 
      template <typename Func>
      GAIA_NODISCARD bool sources_bfs_if(Entity relation, Entity rootTarget, Func func) const {
        if (!valid(relation) || !valid(rootTarget))
          return false;
 
        if (m_enabledHierarchyVersion == 0) {
          const auto& cachedSources = sources_bfs_trav_cache(relation, rootTarget);
          for (auto source: cachedSources) {
            if (func(source))
              return true;
          }
 
          return false;
        }
 
        cnt::darray_ext<Entity, 64> children;
        cnt::darray_ext<Entity, 32> queue;
        queue.push_back(rootTarget);
 
        cnt::set<EntityLookupKey> visited;
        visited.insert(EntityLookupKey(rootTarget));
 
        for (uint32_t i = 0; i < queue.size(); ++i) {
          const auto currTarget = queue[i];
 
          children.clear();
          sources(relation, currTarget, [&](Entity source) {
            const auto key = EntityLookupKey(source);
            const auto ins = visited.insert(key);
            if (!ins.second)
              return;
 
            children.push_back(source);
          });
 
          core::sort(children, [](Entity left, Entity right) {
            return left.id() < right.id();
          });
 
          for (auto child: children) {
            if (!enabled(child))
              continue;
            if (func(child))
              return true;
 
            queue.push_back(child);
          }
        }
 
        return false;
      }
 
      template <typename Func>
      void as_targets_trav(Entity relation, Func func) const {
        GAIA_ASSERT(valid(relation));
        if (!valid(relation))
          return;
 
        const auto& targets = as_targets_trav_cache(relation);
        for (auto target: targets)
          func(target);
      }
 
      template <typename Func>
      bool as_targets_trav_if(Entity relation, Func func) const {
        GAIA_ASSERT(valid(relation));
        if (!valid(relation))
          return false;
 
        const auto& targets = as_targets_trav_cache(relation);
        for (auto target: targets)
          if (func(target))
            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();
 
      SystemRegistry& systems() {
        return m_systems;
      }
 
      const SystemRegistry& systems() const {
        return m_systems;
      }
 
#endif
 
#if GAIA_OBSERVERS_ENABLED
 
      ObserverBuilder observer();
 
      ObserverRegistry& observers() {
        return m_observers;
      }
 
      const ObserverRegistry& observers() const {
        return m_observers;
      }
 
      void defer_on_set_begin(uint32_t slotCount) {
        GAIA_ASSERT(m_deferOnSetDepth != (uint32_t)-1);
        if (m_deferOnSetDepth++ != 0)
          return;
 
        // One queue per work item. Items are distributed to threads in disjoint ranges, so a
        // queue is only ever touched by the single thread processing that item and no
        // synchronization is needed while the region is open.
        m_deferredOnSet.resize(slotCount);
        for (auto& queue: m_deferredOnSet)
          queue.clear();
      }
 
      void defer_on_set_end() {
        GAIA_ASSERT(m_deferOnSetDepth > 0);
        if (--m_deferOnSetDepth != 0)
          return;
 
        // Observer callbacks may trigger writes of their own. Those are dispatched directly
        // because the recording region already ended, so move the queues aside before
        // walking them.
        auto pending = GAIA_MOV(m_deferredOnSet);
        m_deferredOnSet = {};
        for (const auto& queue: pending) {
          for (const auto& item: queue)
            world_notify_on_set_entity(*this, item.term, item.entity);
        }
      }
 
      GAIA_NODISCARD bool defer_on_set_active() const {
        return m_deferOnSetDepth != 0;
      }
 
      void defer_on_set_record(uint32_t slot, Entity term, Entity entity) {
        GAIA_ASSERT(slot < m_deferredOnSet.size());
        m_deferredOnSet[slot].push_back({term, entity});
      }
 
#endif
 
      void defer_sort_inv_begin(uint32_t slotCount) {
        GAIA_ASSERT(m_deferSortInvDepth != (uint32_t)-1);
        if (m_deferSortInvDepth++ != 0)
          return;
 
        // One queue per work item. Items are distributed to threads in disjoint ranges, so a
        // queue is only ever touched by the single thread processing that item and no
        // synchronization is needed while the region is open.
        m_deferredSortInv.resize(slotCount);
        for (auto& queue: m_deferredSortInv)
          queue.clear();
      }
 
      void defer_sort_inv_end() {
        GAIA_ASSERT(m_deferSortInvDepth > 0);
        if (--m_deferSortInvDepth != 0)
          return;
 
        // The coordinator may itself write during apply (e.g. through nested queries), so move
        // the queue aside before walking it, matching the observer path.
        auto pending = GAIA_MOV(m_deferredSortInv);
        m_deferredSortInv = {};
        for (const auto& queue: pending) {
          for (const auto& item: queue)
            invalidate_sorted_queries_for_entity(item.entity);
        }
      }
 
      GAIA_NODISCARD bool defer_sort_inv_active() const {
        return m_deferSortInvDepth != 0;
      }
 
      void defer_sort_inv_record(uint32_t slot, Entity entity) {
        GAIA_ASSERT(slot < m_deferredSortInv.size());
        m_deferredSortInv[slot].push_back({entity});
      }
 
      //----------------------------------------------------------------------
 
      void enable(Entity entity, bool enable) {
        GAIA_ASSERT(valid(entity));
 
        auto& ec = m_recs.entities[entity.id()];
        auto& archetype = *ec.pArchetype;
        auto* pChunk = ec.pChunk;
        const bool wasEnabled = !ec.data.dis;
#if GAIA_ASSERT_ENABLED
        verify_enable(*this, archetype, entity);
#endif
        archetype.enable_entity(ec.pChunk, ec.row, enable, m_recs);
 
        if (wasEnabled != enable) {
          pChunk->update_world_version();
          pChunk->update_entity_order_version();
          update_version(m_enabledHierarchyVersion);
          update_version(m_worldVersion);
        }
      }
 
      GAIA_NODISCARD bool enabled(const EntityContainer& ec) const {
        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 bool enabled(Entity entity) const {
        GAIA_ASSERT(valid(entity));
 
        const auto& ec = m_recs.entities[entity.id()];
        return enabled(ec);
      }
 
      GAIA_NODISCARD bool enabled_hierarchy(Entity entity, Entity relation) const {
        GAIA_ASSERT(valid(entity));
        GAIA_ASSERT(valid(relation));
        if (!valid(entity) || !valid(relation))
          return false;
        if (!enabled(entity))
          return false;
 
        auto curr = entity;
        GAIA_FOR(MAX_TRAV_DEPTH) {
          const auto next = target(curr, relation);
          if (next == EntityBad || next == curr)
            break;
          if (!enabled(next))
            return false;
          curr = next;
        }
 
        return true;
      }
 
      //----------------------------------------------------------------------
 
      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();
      }
 
      void runtime_counters(
          uint32_t& outArchetypes, uint32_t& outChunks, uint32_t& outEntitiesTotal, uint32_t& outEntitiesActive) const {
        outArchetypes = (uint32_t)m_archetypes.size();
        outChunks = 0;
        outEntitiesTotal = 0;
        outEntitiesActive = 0;
 
        for (const auto* pArchetype: m_archetypes) {
          if (pArchetype == nullptr)
            continue;
          const auto& chunks = pArchetype->chunks();
          outChunks += (uint32_t)chunks.size();
          for (const auto* pChunk: chunks) {
            if (pChunk == nullptr)
              continue;
            outEntitiesTotal += pChunk->size();
            outEntitiesActive += pChunk->size_enabled();
          }
        }
      }
 
      GAIA_NODISCARD uint32_t& world_version() {
        return m_worldVersion;
      }
 
      GAIA_NODISCARD uint32_t rel_version(Entity relation) const {
        const auto it = m_relationVersions.find(EntityLookupKey(relation));
        return it != m_relationVersions.end() ? it->second : 0;
      }
 
      GAIA_NODISCARD uint32_t enabled_hierarchy_version() const {
        return m_enabledHierarchyVersion;
      }
 
      GAIA_NODISCARD uint32_t archetype_delete_version() const {
        return m_archetypeDeleteVersion;
      }
 
      friend uint32_t world_rel_version(const World& world, Entity relation);
      friend uint32_t world_version(const World& world);
      friend uint32_t world_archetype_delete_version(const World& world);
      friend uint32_t world_entity_archetype_version(const World& world, Entity entity);
 
      void update_src_entity_version(Entity entity) {
        const auto key = EntityLookupKey(entity);
        const auto it = m_srcEntityVersions.find(key);
        if (it == m_srcEntityVersions.end())
          return;
 
        update_version(it->second);
      }
 
      void remove_src_entity_version(Entity entity) {
        m_srcEntityVersions.erase(EntityLookupKey(entity));
      }
 
      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 frame_cleanup() {
#if GAIA_OBSERVERS_ENABLED && GAIA_ASSERT_ENABLED
        GAIA_ASSERT(!observer_callback_active());
#endif
 
        // Finish deleting entities
        del_finalize();
 
        // Run garbage collector
        gc();
      }
 
      void frame_end() {
        util::log_flush();
 
        // Signal the end of the frame
        GAIA_PROF_FRAME();
      }
 
      void update() {
#if GAIA_OBSERVERS_ENABLED && GAIA_ASSERT_ENABLED
        GAIA_ASSERT(!observer_callback_active());
#endif
 
#if GAIA_SYSTEMS_ENABLED
        systems_run();
#endif
        frame_cleanup();
        frame_end();
      }
 
      void teardown() {
        if GAIA_UNLIKELY (m_teardownActive)
          return;
        m_teardownActive = true;
 
        GAIA_PROF_SCOPE(World::teardown);
 
#if GAIA_SYSTEMS_ENABLED
        systems_done();
        m_systems.teardown();
#endif
 
#if GAIA_OBSERVERS_ENABLED
        m_observers.teardown();
#endif
 
        for (;;) {
          const auto prevReqArchetypes = m_reqArchetypesToDel.size();
          const auto prevReqEntities = m_reqEntitiesToDel.size();
          const auto prevChunks = m_chunksToDel.size();
          const auto prevArchetypes = m_archetypesToDel.size();
 
          del_finalize();
          gc();
 
          if (m_reqArchetypesToDel.empty() && m_reqEntitiesToDel.empty() && m_chunksToDel.empty() &&
              m_archetypesToDel.empty())
            break;
 
          const bool madeProgress = m_reqArchetypesToDel.size() != prevReqArchetypes ||
                                    m_reqEntitiesToDel.size() != prevReqEntities ||
                                    m_chunksToDel.size() != prevChunks || m_archetypesToDel.size() != prevArchetypes;
          if (!madeProgress)
            break;
        }
 
        util::log_flush();
      }
 
      void cleanup() {
        cleanup_inter();
 
        // Reinit
        m_pRootArchetype = nullptr;
        m_pEntityArchetype = nullptr;
        m_pCompArchetype = nullptr;
        m_nextArchetypeId = 0;
        m_defragLastArchetypeIdx = 0;
        m_worldVersion = 0;
        m_enabledHierarchyVersion = 0;
        m_archetypeDeleteVersion = 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.next_free(m_recs.entities.get_next_free_item());
          while (fe != IdentifierIdBad) {
            GAIA_LOG_N("  --> %u", m_recs.entities.next_free(fe));
            fe = m_recs.entities.next_free(fe);
            ++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);
 
        // Shutdown bypasses the regular GC path, so clear raw-pointer tracking first.
        // Chunk/component dtors that run while archetypes are freed can still drop cached queries,
        // but after this point they must not touch stale archetype/chunk reverse indices.
        {
          m_queryCache.clear_archetype_tracking();
          m_reqArchetypesToDel = {};
          m_reqEntitiesToDel = {};
#if GAIA_OBSERVERS_ENABLED
          m_entitiesDeleting = {};
#endif
          m_chunksToDel = {};
          m_archetypesToDel = {};
        }
 
        // Clear entities
        m_recs.entities = {};
        m_recs.pair_records_clear();
 
        // Clear archetypes
        {
          // Delete all allocated chunks and their parent archetypes
          for (auto* pArchetype: m_archetypes)
            Archetype::destroy(pArchetype);
 
          m_entityToAsRelations = {};
          m_entityToAsRelationsTravCache = {};
          m_entityToAsTargets = {};
          m_entityToAsTargetsTravCache = {};
          m_targetsTravCache = {};
          m_srcBfsTravCache = {};
          m_depthOrderCache = {};
          m_sourcesAllCache = {};
          m_targetsAllCache = {};
          m_relationCachesPopulated = false;
          m_hasOnDeleteTargetPolicy = false;
          m_hasCantCombinePolicy = false;
          m_pairLookup.clear();
          m_nonFragmentingRelationsByRel = {};
          for (auto& [compKey, store]: m_sparseComponentsByComp) {
            (void)compKey;
            store.func_clear_store(store.pStore);
            store.func_del_store(store.pStore);
          }
          m_sparseComponentsByComp = {};
          m_relationVersions = {};
          m_lastRelationVersionRelation = EntityBad;
          m_pLastRelationVersion = nullptr;
          m_srcEntityVersions = {};
 
          m_archetypes = {};
          m_archetypesById = {};
          m_archetypesByHash = {};
        }
 
        // Clear caches
        {
          m_entityToArchetypeMap = {};
          m_entityToArchetypeMapVersions = {};
          m_queryCache.clear();
          for (auto* pScratch: m_queryMatchScratchStack)
            delete pScratch;
          m_queryMatchScratchStack = {};
          m_queryMatchScratchDepth = 0;
          m_querySerMap = {};
          m_nextQuerySerId = 0;
        }
 
        // Clear entity aliases
        {
          for (auto& pair: m_aliasToEntity) {
            if (!pair.first.owned())
              continue;
            // Release any memory allocated for owned names
            mem::mem_free((void*)pair.first.str());
          }
          m_aliasToEntity = {};
        }
 
        // 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 ((ec.flags & EntityContainerFlags::Load) != 0) {
          return entityExpected.id() == ec.idx && entityExpected.gen() == ec.data.gen &&
                 entityExpected.entity() == (bool)ec.data.ent && entityExpected.pair() == (bool)ec.data.pair &&
                 entityExpected.kind() == (EntityKind)ec.data.kind;
        }
 
        if (is_req_del(ec))
          return false;
 
        // The entity in the chunk must match the index in the entity container
        const auto* pChunk = ec.pChunk;
        if (pChunk == nullptr || ec.row >= pChunk->size())
          return false;
 
        const auto entityPresent = pChunk->entity_view()[ec.row];
        // Public validity checks can legitimately observe a recycled slot with a different generation.
        // Treat that as stale instead of aborting.
        return entityExpected == entityPresent;
      }
 
      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* pPair = m_recs.pair_record_find(entity);
        if (pPair == nullptr)
          return false;
 
        const auto& ec = *pPair;
        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* pEc = m_recs.entities.try_get(entity.id());
        if (pEc == nullptr)
          return false;
 
        return valid(*pEc, 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* pEc = m_recs.entities.try_get(entityId);
        if (pEc == nullptr)
          return false;
 
        const auto& ec = *pEc;
        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;
      }
 
#if GAIA_SYSTEMS_ENABLED
      void systems_done();
#endif
 
    public:
      GAIA_NODISCARD bool locked() const {
        return m_structuralChangesLocked != 0;
      }
 
      GAIA_NODISCARD bool tearing_down() const {
        return m_teardownActive;
      }
 
    private:
      static constexpr uint32_t WorldSerializerVersion = 4;
#if GAIA_JSON_ENABLED
      static constexpr uint32_t WorldSerializerJSONVersion = 1;
#endif
 
      void save_to(ser::serializer s) const {
        GAIA_ASSERT(s.valid());
 
        // Version number, currently unused
        s.save((uint32_t)WorldSerializerVersion);
 
        // 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 bool isAlive = m_recs.entities.has(i);
            s.save(isAlive);
            if (isAlive)
              saveEntityContainer(m_recs.entities[i]);
            else {
              s.save(m_recs.entities.handle(i).val);
              s.save(m_recs.entities.next_free(i));
            }
          }
 
          {
            uint32_t pairsCnt = 0;
            for (auto it = m_recs.pair_record_begin(); it != m_recs.pair_record_end(); ++it) {
              const auto& pair = *it;
              // Skip core pairs
              if (pair.first.entity().id() < lastCoreComponentId && pair.first.entity().gen() < lastCoreComponentId)
                continue;
 
              ++pairsCnt;
            }
            s.save(pairsCnt);
          }
          {
            for (auto it = m_recs.pair_record_begin(); it != m_recs.pair_record_end(); ++it) {
              const auto& pair = *it;
              // 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(s);
          }
 
          s.save(m_worldVersion);
        }
 
        // Non-fragmenting exclusive relation edges.
        {
          uint32_t edgeCnt = 0;
          for (const auto& [relKey, store]: m_nonFragmentingRelationsByRel) {
            (void)relKey;
            edgeCnt += store.source_count();
          }
          s.save(edgeCnt);
 
          for (const auto& [relKey, store]: m_nonFragmentingRelationsByRel) {
            const auto relation = relKey.entity();
            cnt::darray<EntityId> sourceIds;
            store.collect_source_ids(sourceIds);
            for (auto sourceId: sourceIds) {
              const auto source = get(sourceId);
              GAIA_ASSERT(valid(source));
              const auto target = store.target(source);
              GAIA_ASSERT(target != EntityBad);
              s.save(source);
              s.save(relation);
              s.save(target);
            }
          }
        }
 
        // 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);
            }
          }
        }
 
        // Entity aliases
        {
          uint32_t aliasCnt = 0;
          GAIA_FOR((uint32_t)m_recs.entities.size()) {
            const auto entity = get((EntityId)i);
            if (!valid(entity) || entity.pair())
              continue;
 
            const auto& ec = m_recs.entities[i];
            const auto compIdx = core::get_index(ec.pChunk->ids_view(), GAIA_ID(EntityDesc));
            if (compIdx == BadIndex)
              continue;
 
            const auto* pDesc = reinterpret_cast<const EntityDesc*>(ec.pChunk->comp_ptr(compIdx, ec.row));
            if (pDesc->alias != nullptr)
              ++aliasCnt;
          }
 
          s.save(aliasCnt);
          GAIA_FOR((uint32_t)m_recs.entities.size()) {
            const auto entity = get((EntityId)i);
            if (!valid(entity) || entity.pair())
              continue;
 
            const auto& ec = m_recs.entities[i];
            const auto compIdx = core::get_index(ec.pChunk->ids_view(), GAIA_ID(EntityDesc));
            if (compIdx == BadIndex)
              continue;
 
            const auto* pDesc = reinterpret_cast<const EntityDesc*>(ec.pChunk->comp_ptr(compIdx, ec.row));
            if (pDesc->alias == nullptr)
              continue;
 
            s.save(entity);
            s.save(pDesc->alias_len);
            s.save_raw(pDesc->alias, pDesc->alias_len, ser::serialization_type_id::c8);
          }
        }
      }
 
    public:
      void save() {
        auto s = m_serializer;
        GAIA_ASSERT(s.valid());
 
        s.reset();
        save_to(s);
      }
 
#if GAIA_JSON_ENABLED
      bool save_json(
          ser::ser_json& writer, ser::JsonSaveFlags flags = ser::JsonSaveFlags::Default,
          const ser::RuntimeJsonPolicy& policy = {}) const;
 
      ser::json_str save_json(bool& ok, ser::JsonSaveFlags flags = ser::JsonSaveFlags::Default) const;
 
      uint64_t runtime_schema_hash() const;
 
      bool save_runtime_schema_json(ser::ser_json& writer) const;
 
      ser::json_str save_runtime_schema_json() const;
 
      bool patch_comp_json(
          Entity entity, Entity component, ser::json_str_view pointer, ser::json_str_view value,
          ser::JsonDiagnostics& diagnostics, const ser::RuntimeJsonPolicy& policy = {},
          uint64_t expectedRuntimeSchemaHash = 0);
 
      bool load_json(
          const char* json, uint32_t len, ser::JsonDiagnostics& diagnostics, const ser::RuntimeJsonPolicy& policy = {});
      bool load_json(const char* json, uint32_t len);
 
      bool
      load_json(ser::json_str_view json, ser::JsonDiagnostics& diagnostics, const ser::RuntimeJsonPolicy& policy = {});
 
      bool load_json(ser::json_str_view json);
#endif
 
      bool load(ser::serializer inputSerializer = {}) {
        auto s = inputSerializer.valid() ? inputSerializer : m_serializer;
        GAIA_ASSERT(s.valid());
 
        // Move back to the beginning of the stream
        s.seek(0);
 
        // Version number, currently unused
        uint32_t version = 0;
        s.load(version);
        if (version < 2 || version > WorldSerializerVersion) {
          GAIA_LOG_E("Unsupported world version %u. Expected 2..%u.", version, WorldSerializerVersion);
          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);
 
        // Append-only core ids are handled via load-time entity remapping.
        // Snapshots from a runtime with a larger core-id boundary are not supported.
        const auto currLastCoreComponentId = GAIA_ID(LastCoreComponent).id();
        if (lastCoreComponentId > currLastCoreComponentId) {
          GAIA_LOG_E(
              "Unsupported world core boundary %u. Current runtime supports up to %u.", lastCoreComponentId,
              currLastCoreComponentId);
          return false;
        }
        // Install the append-only core-id remap for nested Entity::load() calls.
        // This keeps the serializer API unchanged, at the cost of relying on
        // scoped thread-local state instead of explicit serializer-local context.
        const detail::EntityLoadRemapGuard entityLoadRemapGuard(
            lastCoreComponentId, currLastCoreComponentId, version >= WorldSerializerVersion);
        auto remapLoadedEntityId = [&](uint32_t id) {
          return detail::remap_loaded_entity_id(id, lastCoreComponentId, currLastCoreComponentId);
        };
 
        // Entities
        {
          auto loadEntityContainer = [&](EntityContainer& ec) {
            s.load(ec.idx);
            s.load(ec.dataRaw);
            s.load(ec.row);
            s.load(ec.flags);
            if ((ec.flags & EntityContainerFlags::HasCantCombine) != 0)
              m_hasCantCombinePolicy = true;
            if ((ec.flags & (EntityContainerFlags::OnDeleteTarget_Delete | EntityContainerFlags::OnDeleteTarget_Remove |
                             EntityContainerFlags::OnDeleteTarget_Error)) != 0) {
              m_hasOnDeleteTargetPolicy = true;
            }
            ec.flags |= EntityContainerFlags::Load;
 
            ec.idx = remapLoadedEntityId(ec.idx);
            if (ec.data.pair != 0)
              ec.data.gen = remapLoadedEntityId(ec.data.gen);
 
#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) {
            bool isAlive = false;
            s.load(isAlive);
            if (isAlive) {
              EntityContainer ec{};
              loadEntityContainer(ec);
              m_recs.entities.add_live(GAIA_MOV(ec));
            } else {
              Identifier id = IdentifierBad;
              uint32_t nextFreeIdx = Entity::IdMask;
              s.load(id);
              s.load(nextFreeIdx);
              auto entity = Entity(id);
              entity = detail::remap_loaded_entity(entity, lastCoreComponentId, currLastCoreComponentId);
              nextFreeIdx = remapLoadedEntityId(nextFreeIdx);
              GAIA_ASSERT(entity.id() == remapLoadedEntityId(lastCoreComponentId + i));
              m_recs.entities.add_free(entity, nextFreeIdx);
            }
          }
 
          uint32_t pairsCnt = 0;
          s.load(pairsCnt);
          GAIA_FOR(pairsCnt) {
            EntityContainer ec{};
            loadEntityContainer(ec);
            const auto pair = EntityContainer::handle(ec);
            const bool added = m_recs.pair_record_try_add(pair, GAIA_MOV(ec));
            GAIA_ASSERT(added);
          }
 
          s.load(m_recs.entities.m_nextFreeIdx);
          m_recs.entities.m_nextFreeIdx = remapLoadedEntityId(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];
            ec.pEntity = &ec.pChunk->entity_view()[ec.row];
          }
 
          for (auto it = m_recs.pair_record_begin(); it != m_recs.pair_record_end(); ++it) {
            auto& pair = *it;
            auto& ec = pair.second;
 
            // Core pairs remain in-world during load and were not serialized into the stream.
            if ((ec.flags & EntityContainerFlags::Load) == 0)
              continue;
 
            GAIA_ASSERT((ec.flags & EntityContainerFlags::Load) != 0);
            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];
            ec.pEntity = &ec.pChunk->entity_view()[ec.row];
          }
        }
 
        if (version < WorldSerializerVersion) {
          for (const auto& [entityId, pItem]: m_compCache.m_compByEntityId) {
            (void)entityId;
            GAIA_ASSERT(pItem != nullptr);
            auto comp = pItem->comp;
            comp.data.id = pItem->entity.id();
            sync_component_record(pItem->entity, comp);
          }
        }
 
        if (version >= 4) {
          uint32_t edgeCnt = 0;
          s.load(edgeCnt);
          GAIA_FOR(edgeCnt) {
            Entity source;
            Entity relation;
            Entity target;
            s.load(source);
            s.load(relation);
            s.load(target);
 
            if (!valid(source) || !valid(relation) || !valid(target) ||
                !relation_uses_non_fragmenting_storage(relation))
              continue;
 
            assign_pair(Pair(relation, target), *m_pEntityArchetype);
            nonfragmenting_relation_set(source, relation, target);
          }
        }
 
#if GAIA_ASSERT_ENABLED
        for (const auto& ec: m_recs.entities) {
          GAIA_ASSERT(ec.idx < m_recs.entities.size());
          GAIA_ASSERT(m_recs.entities.handle(ec.idx) == EntityContainer::handle(ec));
          GAIA_ASSERT(ec.pArchetype != nullptr);
          GAIA_ASSERT(ec.pChunk != nullptr);
          GAIA_ASSERT(ec.pEntity != nullptr);
        }
#endif
        // Entity names
        {
          m_nameToEntity = {};
          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);
                const auto symbol = ci.symbol_name();
                pDesc->name = symbol.data();
                // Length should still be the same. Only the pointer has changed.
                GAIA_ASSERT(pDesc->name_len == symbol.size());
                m_nameToEntity.try_emplace(EntityNameLookupKey(pDesc->name, pDesc->name_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->name_len = len;
                m_nameToEntity.try_emplace(EntityNameLookupKey(pDesc->name, pDesc->name_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->name_len = 0;
            }
 
            // Name the entity using an owned string
            name(entity, entityStr, len);
          }
        }
 
        // Entity aliases
        {
          m_aliasToEntity = {};
          for (auto& ec: m_recs.entities) {
            const auto entity = EntityContainer::handle(ec);
            if (entity.pair())
              continue;
 
            const auto compIdx = core::get_index(ec.pChunk->ids_view(), GAIA_ID(EntityDesc));
            if (compIdx == BadIndex)
              continue;
 
            auto* pDesc = reinterpret_cast<EntityDesc*>(ec.pChunk->comp_ptr_mut(compIdx, ec.row));
            GAIA_ASSERT(core::check_alignment(pDesc));
            pDesc->alias = nullptr;
            pDesc->alias_len = 0;
          }
 
          uint32_t cnt = 0;
          s.load(cnt);
          GAIA_FOR(cnt) {
            Entity entity;
            s.load(entity);
 
            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));
 
            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* aliasStr = (const char*)(s.data() + s.tell());
            s.seek(s.tell() + len);
 
            pDesc->alias = nullptr;
            pDesc->alias_len = 0;
            alias(entity, aliasStr, len);
          }
        }
 
        return true;
      }
 
      template <typename TSerializer>
      bool load(TSerializer& inputSerializer) {
        return load(ser::make_serializer(inputSerializer));
      }
 
    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_chunk_from_delete_queue(uint32_t idx) {
        GAIA_ASSERT(idx < m_chunksToDel.size());
 
        auto* pChunk = m_chunksToDel[idx].pChunk;
        pChunk->clear_delete_queue_index();
 
        const auto lastIdx = (uint32_t)m_chunksToDel.size() - 1;
        if (idx != lastIdx) {
          auto* pMovedChunk = m_chunksToDel[lastIdx].pChunk;
          pMovedChunk->delete_queue_index(idx);
        }
 
        core::swap_erase(m_chunksToDel, idx);
      }
 
      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);
            remove_chunk_from_delete_queue(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_from_delete_queue(i);
          remove_chunk(*pArchetype, *pChunk);
        }
      }
 
      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);
        for (auto& ec: m_recs.entities) {
          if (ec.pArchetype != pArchetype)
            continue;
 
          ec.pArchetype = nullptr;
          ec.pChunk = nullptr;
          ec.pEntity = nullptr;
        }
        for (auto it = m_recs.pair_record_begin(); it != m_recs.pair_record_end(); ++it) {
          auto& ec = it->second;
          if (ec.pArchetype != pArchetype)
            continue;
 
          ec.pArchetype = nullptr;
          ec.pChunk = nullptr;
          ec.pEntity = nullptr;
        }
        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;
 
          for (auto* pArchetype: tmp) {
            m_queryCache.remove_archetype_from_queries(pArchetype);
            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) {
        const bool wasReqDel = archetype.is_req_del();
        archetype.revive();
        if (wasReqDel)
          update_version(m_archetypeDeleteVersion);
        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});
        chunk.delete_queue_index((uint32_t)m_chunksToDel.size() - 1);
      }
 
      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;
            ec.pEntity = &pDstChunk->entity_view()[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();
            pSrcChunk->update_entity_order_version();
            pDstChunk->update_entity_order_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;
      }
 
      GAIA_NODISCARD static auto
      find_component_index_record(ComponentIndexEntryArray& records, const Archetype* pArchetype) {
        return core::get_index_if(records, [&](const auto& record) {
          return record.matches(pArchetype);
        });
      }
 
      GAIA_NODISCARD static auto
      find_component_index_record(const ComponentIndexEntryArray& records, const Archetype* pArchetype) {
        return core::get_index_if(records, [&](const auto& record) {
          return record.matches(pArchetype);
        });
      }
 
      void update_entity_archetype_lookup_revision(EntityLookupKey entityKey) {
        auto [it, _] = m_entityToArchetypeMapVersions.try_emplace(entityKey, 0);
        (void)_;
        ++it->second;
        if (it->second == 0)
          it->second = 1;
      }
 
      void add_entity_archetype_pair(
          Entity entity, Archetype* pArchetype, uint16_t compIdx = ComponentIndexBad, uint16_t matchCount = 1) {
        GAIA_ASSERT(pArchetype != nullptr);
        GAIA_ASSERT(matchCount > 0);
 
        EntityLookupKey entityKey(entity);
        auto prepared = m_entityToArchetypeMap.prepare_insert(entityKey);
        if (!prepared.found()) {
          ComponentIndexEntryArray records;
          records.push_back(ComponentIndexEntry{pArchetype, compIdx, matchCount});
          m_entityToArchetypeMap.emplace_prepared(prepared, entityKey, GAIA_MOV(records));
          return;
        }
 
        auto it = m_entityToArchetypeMap.prepared_iterator(prepared);
        auto& records = it->second;
        const auto idx = find_component_index_record(records, pArchetype);
        if (idx == BadIndex) {
          records.push_back(ComponentIndexEntry{pArchetype, compIdx, matchCount});
          return;
        }
 
        auto& record = records[idx];
        record.matchCount = (uint16_t)(record.matchCount + matchCount);
        if (compIdx != ComponentIndexBad)
          record.compIdx = compIdx;
      }
 
      void add_new_entity_archetype_pair(
          Entity entity, Archetype* pArchetype, uint16_t compIdx = ComponentIndexBad, uint16_t matchCount = 1) {
        GAIA_ASSERT(pArchetype != nullptr);
        GAIA_ASSERT(matchCount > 0);
 
        EntityLookupKey entityKey(entity);
        auto prepared = m_entityToArchetypeMap.prepare_insert(entityKey);
        if (!prepared.found()) {
          ComponentIndexEntryArray records;
          records.push_back(ComponentIndexEntry{pArchetype, compIdx, matchCount});
          m_entityToArchetypeMap.emplace_prepared(prepared, entityKey, GAIA_MOV(records));
          return;
        }
 
        auto it = m_entityToArchetypeMap.prepared_iterator(prepared);
        auto& records = it->second;
        if (!records.empty()) {
          auto& record = records.back();
          if (record.matches(pArchetype)) {
            record.matchCount = (uint16_t)(record.matchCount + matchCount);
            if (compIdx != ComponentIndexBad)
              record.compIdx = compIdx;
            return;
          }
        }
 
        records.push_back(ComponentIndexEntry{pArchetype, compIdx, matchCount});
      }
 
      void add_pair_archetype_query_pairs(Entity pair, Archetype* pArchetype, uint16_t matchCount = 1) {
        GAIA_ASSERT(pair.pair());
        GAIA_ASSERT(pArchetype != nullptr);
        GAIA_ASSERT(matchCount > 0);
 
        const auto first = get(pair.id());
        const auto second = get(pair.gen());
 
        add_entity_archetype_pair(Pair(All, second), pArchetype, ComponentIndexBad, matchCount);
        add_entity_archetype_pair(Pair(first, All), pArchetype, ComponentIndexBad, matchCount);
        add_entity_archetype_pair(Pair(All, All), pArchetype, ComponentIndexBad, matchCount);
      }
 
      void add_new_pair_archetype_query_pairs(Entity pair, Archetype* pArchetype, uint16_t matchCount = 1) {
        GAIA_ASSERT(pair.pair());
        GAIA_ASSERT(pArchetype != nullptr);
        GAIA_ASSERT(matchCount > 0);
 
        const auto first = get(pair.id());
        const auto second = get(pair.gen());
 
        add_new_entity_archetype_pair(Pair(All, second), pArchetype, ComponentIndexBad, matchCount);
        add_new_entity_archetype_pair(Pair(first, All), pArchetype, ComponentIndexBad, matchCount);
        add_new_entity_archetype_pair(Pair(All, All), pArchetype, ComponentIndexBad, matchCount);
      }
 
      void del_entity_query_pair(Pair pair, Entity entityToRemove) {
        const auto entityKey = EntityLookupKey(pair);
        auto it = m_entityToArchetypeMap.find(entityKey);
        if (it == m_entityToArchetypeMap.end())
          return;
        auto& records = it->second;
        bool changed = false;
 
        // Remove any reference to the found archetype from the array.
        // We don't know the archetype so we remove/decrement any archetype record that contains our entity.
        for (uint32_t i = records.size() - 1; i != (uint32_t)-1; --i) {
          auto& record = records[i];
          const auto* pArchetype = record.pArchetype;
          if (!pArchetype->has(entityToRemove))
            continue;
 
          if ((!is_wildcard(pair.first()) && !is_wildcard(pair.second())) || record.matchCount <= 1)
            core::swap_erase_unsafe(records, i);
          else
            --record.matchCount;
          changed = true;
        }
 
        if (changed)
          update_entity_archetype_lookup_revision(entityKey);
 
        if (records.empty())
          m_entityToArchetypeMap.erase(it);
      }
 
      void del_entity_query_pair(Pair pair, Archetype* pArchetypeToRemove) {
        GAIA_ASSERT(pArchetypeToRemove != nullptr);
 
        const auto entityKey = EntityLookupKey(pair);
        auto it = m_entityToArchetypeMap.find(entityKey);
        if (it == m_entityToArchetypeMap.end())
          return;
 
        auto& records = it->second;
        const auto idx = find_component_index_record(records, pArchetypeToRemove);
        if (idx != BadIndex) {
          core::swap_erase_unsafe(records, idx);
          update_entity_archetype_lookup_revision(entityKey);
        }
 
        if (records.empty())
          m_entityToArchetypeMap.erase(it);
      }
 
      void del_pair_archetype_query_pairs(Entity pair, Archetype* pArchetypeToRemove) {
        GAIA_ASSERT(pair.pair());
        GAIA_ASSERT(pArchetypeToRemove != nullptr);
 
        GAIA_ASSERT(pair.id() < m_recs.entities.size());
        GAIA_ASSERT(pair.gen() < m_recs.entities.size());
        const auto first = m_recs.entities.handle(pair.id());
        const auto second = m_recs.entities.handle(pair.gen());
 
        del_entity_query_pair(Pair(All, second), pArchetypeToRemove);
        del_entity_query_pair(Pair(first, All), pArchetypeToRemove);
        del_entity_query_pair(Pair(All, All), pArchetypeToRemove);
      }
 
      void del_pair_archetype_query_pairs(Entity pair, Entity entityToRemove) {
        GAIA_ASSERT(pair.pair());
 
        GAIA_ASSERT(pair.id() < m_recs.entities.size());
        GAIA_ASSERT(pair.gen() < m_recs.entities.size());
        const auto first = m_recs.entities.handle(pair.id());
        const auto second = m_recs.entities.handle(pair.gen());
 
        del_entity_query_pair(Pair(All, second), entityToRemove);
        del_entity_query_pair(Pair(first, All), entityToRemove);
        del_entity_query_pair(Pair(All, All), entityToRemove);
      }
 
      void del_entity_archetype_pair(Entity entity, Archetype* pArchetypeToRemove) {
        GAIA_ASSERT(entity != Pair(All, All));
        GAIA_ASSERT(pArchetypeToRemove != nullptr);
 
        const auto entityKey = EntityLookupKey(entity);
        auto it = m_entityToArchetypeMap.find(entityKey);
        if (it == m_entityToArchetypeMap.end())
          return;
 
        auto& records = it->second;
        const auto idx = find_component_index_record(records, pArchetypeToRemove);
        if (idx != BadIndex) {
          core::swap_erase_unsafe(records, idx);
          update_entity_archetype_lookup_revision(entityKey);
        }
 
        if (records.empty())
          m_entityToArchetypeMap.erase(it);
      }
 
      void del_archetype_entity_pairs(Archetype* pArchetype) {
        GAIA_ASSERT(pArchetype != nullptr);
 
        for (const auto entity: pArchetype->ids_view()) {
          del_entity_archetype_pair(entity, pArchetype);
 
          if (!entity.pair())
            continue;
 
          // Archetype unregistration can run while the pair's relation or target entity is already
          // invalid. Rebuild wildcard pair lookup keys from the stored entity records instead of
          // calling get(), which asserts on invalidated ids.
          GAIA_ASSERT(entity.id() < m_recs.entities.size());
          GAIA_ASSERT(entity.gen() < m_recs.entities.size());
          del_pair_archetype_query_pairs(entity, pArchetype);
        }
      }
 
      void del_entity_archetype_pairs(Entity entity, Archetype* pArchetype) {
        GAIA_ASSERT(entity != Pair(All, All));
 
        const auto entityKey = EntityLookupKey(entity);
        if (m_entityToArchetypeMap.erase(entityKey) != 0)
          update_entity_archetype_lookup_revision(entityKey);
 
        if (entity.pair()) {
          if (pArchetype != nullptr) {
            del_pair_archetype_query_pairs(entity, pArchetype);
          } else {
            del_pair_archetype_query_pairs(entity, 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);
 
        const auto entityCnt = (uint32_t)entities.size();
        GAIA_FOR(entityCnt) {
          auto entity = entities[i];
          add_new_entity_archetype_pair(entity, pArchetype, (uint16_t)i);
 
#if GAIA_OBSERVERS_ENABLED
          auto& ec = fetch(entity);
          if ((ec.flags & EntityContainerFlags::IsObserved) != 0 || m_observers.has_observers(entity)) {
            ec.flags |= EntityContainerFlags::IsObserved;
            pArchetype->observed_terms_inc();
          }
#endif
 
          // 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()) {
            add_new_pair_archetype_query_pairs(entity, 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);
 
        m_queryCache.register_archetype_with_queries(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);
 
        // Query rematching uses the entity -> archetype lookup map as an input. Remove this
        // archetype from all of its lookup buckets before destroying it so dead archetype
        // pointers cannot be reintroduced into cached query state during the next rematch.
        del_archetype_entity_pairs(pArchetype);
 
        // 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);
        update_entity_archetype_lookup_revision(EntityBadLookupKey);
        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) {
          const auto name = entity_name(world, ids[i]);
          GAIA_LOG_W(
              "> [%u] %.*s [%s]", i, (int)name.size(), name.empty() ? "" : name.data(),
              EntityKindString[(uint32_t)ids[i].kind()]);
        }
 
        GAIA_LOG_W("Trying to %s:", adding ? "add" : "del");
        const auto name = entity_name(world, entity);
        GAIA_LOG_W(
            "> %.*s [%s]", (int)name.size(), name.empty() ? "" : name.data(),
            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 func_del) {
        // 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(func_del)) {
          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, func_del, 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
        bool edgeNeedsRebuild = false;
        {
          const auto edge = pArchetypeLeft->find_edge_right(entity);
          if (edge != ArchetypeIdHashPairBad) {
            auto it = m_archetypesById.find(ArchetypeIdLookupKey(edge.id, edge.hash));
            if (it != m_archetypesById.end() && it->second != nullptr)
              return it->second;
 
            // Drop stale local cache edge and rebuild it below.
            pArchetypeLeft->del_graph_edge_right_local(entity);
            edgeNeedsRebuild = true;
          }
        }
 
        // 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});
          reg_archetype(pArchetypeRight);
          edgeNeedsRebuild = true;
        }
 
        if (edgeNeedsRebuild)
          pArchetypeLeft->build_graph_edges(pArchetypeRight, entity);
 
        return pArchetypeRight;
      }
 
      GAIA_NODISCARD Archetype* foc_archetype_add_no_graph(Archetype* pArchetypeLeft, Entity entity) {
        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;
        }
 
        sort(entsNew, SortComponentCond{});
 
        const auto hashLookup = calc_lookup_hash({entsNew.data(), entsNew.size()}).hash;
        auto* pArchetypeRight = find_archetype({hashLookup}, {entsNew.data(), entsNew.size()});
        if (pArchetypeRight != nullptr)
          return pArchetypeRight;
 
        pArchetypeRight = create_archetype({entsNew.data(), entsNew.size()});
        pArchetypeRight->set_hashes({hashLookup});
        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
        bool edgeNeedsRebuild = false;
        {
          const auto edge = pArchetypeRight->find_edge_left(entity);
          if (edge != ArchetypeIdHashPairBad) {
            const auto it = m_archetypesById.find(ArchetypeIdLookupKey(edge.id, edge.hash));
            if (it != m_archetypesById.end()) {
              auto* pArchetypeLeft = it->second;
              if (pArchetypeLeft != nullptr)
                return pArchetypeLeft;
            }
 
            // Drop stale local cache edge and rebuild it below.
            pArchetypeRight->del_graph_edge_left_local(entity);
            edgeNeedsRebuild = true;
          }
        }
 
        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});
          reg_archetype(pArchetype);
          edgeNeedsRebuild = true;
        }
 
        if (edgeNeedsRebuild)
          pArchetype->build_graph_edges(pArchetypeRight, entity);
 
        return pArchetype;
      }
 
      GAIA_NODISCARD Archetype* foc_archetype_del_no_graph(Archetype* pArchetypeRight, Entity entity) {
        cnt::sarray_ext<Entity, ChunkHeader::MAX_COMPONENTS> entsNew;
        auto entsOld = pArchetypeRight->ids_view();
 
        for (const auto e: entsOld) {
          if (e == entity)
            continue;
 
          entsNew.push_back(e);
        }
 
        GAIA_ASSERT(entsNew.size() != entsOld.size());
 
        const auto hashLookup = calc_lookup_hash({entsNew.data(), entsNew.size()}).hash;
        auto* pArchetype = find_archetype({hashLookup}, {entsNew.data(), entsNew.size()});
        if (pArchetype != nullptr)
          return pArchetype;
 
        pArchetype = create_archetype({entsNew.data(), entsNew.size()});
        pArchetype->set_hashes({hashLookup});
        reg_archetype(pArchetype);
        return pArchetype;
      }
 
      GAIA_NODISCARD const auto& archetypes() const {
        return m_archetypes;
      }
 
      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);
          remove_src_entity_version(entity);
        }
 
        // 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.
          if (pChunk->queued_for_deletion())
            remove_chunk_from_delete_queue(pChunk->delete_queue_index());
 
          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, EntitySpan{});
        };
 
        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);
        }
      }
 
      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();
            pDstChunk->update_entity_order_version();
 
            GAIA_ASSERT(cnt <= i);
            i -= cnt;
          }
 
          pSrcChunk->update_world_version();
          pSrcChunk->update_entity_order_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();
        update_version(m_archetypeDeleteVersion);
        m_reqArchetypesToDel.insert(ArchetypeLookupKey(archetype.lookup_hash(), &archetype));
      }
 
      void req_del_inter(EntityContainer& ec, Entity entity) {
        if (is_req_del(ec))
          return;
 
        unlink_live_is_relations(entity);
#if GAIA_OBSERVERS_ENABLED
        del_nonfragmenting_relation_source_observed(entity);
        del_nonfragmenting_relation_source(entity);
        auto delDiffCtx =
            m_observers.prepare_diff(*this, ObserverEvent::OnDel, EntitySpan{&entity, 1}, EntitySpan{&entity, 1});
#else
        del_nonfragmenting_relation_source(entity);
#endif
        del_entity(ec, entity, false);
#if GAIA_OBSERVERS_ENABLED
        m_observers.finish_diff(*this, GAIA_MOV(delDiffCtx));
#endif
 
        ec.req_del();
        m_reqEntitiesToDel.insert(EntityLookupKey(entity));
      }
 
      void req_del(EntityContainer& ec, Entity entity) {
#if GAIA_OBSERVERS_ENABLED
        if (entity_deletion_active(entity))
          return;
 
        entity_deletion_enter(entity);
        req_del_inter(ec, entity);
        entity_deletion_leave(entity);
#else
        req_del_inter(ec, entity);
#endif
      }
 
      void invalidate_pair_removal_caches(Entity entity) {
        if (!entity.pair())
          return;
 
        auto invalidate_relation = [this](Entity relation) {
          if (relation == EntityBad)
            return;
          touch_rel_version(relation);
          invalidate_queries_for_rel(relation);
        };
 
        if (entity.id() != All.id()) {
          invalidate_relation(try_get(entity.id()));
        } else if (entity.gen() != All.id()) {
          const auto target = try_get(entity.gen());
          if (target != EntityBad) {
            if (const auto* pRelations = relations(target)) {
              for (auto relationKey: *pRelations)
                invalidate_relation(relationKey.entity());
            }
          }
        } else {
          for (auto it = m_pairLookup.relation_begin(); it != m_pairLookup.relation_end(); ++it)
            invalidate_relation(it->first.entity());
        }
 
        clear_relation_caches();
      }
 
      void unlink_live_is_relation(Entity source, Entity target) {
        const auto sourceKey = EntityLookupKey(source);
        const auto targetKey = EntityLookupKey(target);
 
        invalidate_queries_for_entity({Is, target});
 
        if (const auto itTargets = m_entityToAsTargets.find(sourceKey); itTargets != m_entityToAsTargets.end()) {
          itTargets->second.erase(targetKey);
          if (itTargets->second.empty())
            m_entityToAsTargets.erase(itTargets);
        }
        m_entityToAsTargetsTravCache = {};
 
        if (const auto itRelations = m_entityToAsRelations.find(targetKey);
            itRelations != m_entityToAsRelations.end()) {
          itRelations->second.erase(sourceKey);
          if (itRelations->second.empty())
            m_entityToAsRelations.erase(itRelations);
        }
        m_entityToAsRelationsTravCache = {};
      }
 
      void unlink_live_is_relations(Entity source) {
        const auto itTargets = m_entityToAsTargets.find(EntityLookupKey(source));
        if (itTargets == m_entityToAsTargets.end())
          return;
 
        cnt::darray_ext<Entity, 4> targets;
        for (auto targetKey: itTargets->second)
          targets.push_back(targetKey.entity());
 
        for (auto target: targets)
          unlink_live_is_relation(source, target);
      }
 
      void unlink_stale_is_relations_by_target_id(Entity source, EntityId targetId) {
        const auto sourceKey = EntityLookupKey(source);
        const auto itTargets = m_entityToAsTargets.find(sourceKey);
        if (itTargets == m_entityToAsTargets.end())
          return;
 
        cnt::darray_ext<EntityLookupKey, 4> removedTargets;
        for (auto targetKey: itTargets->second) {
          if (targetKey.entity().id() == targetId)
            removedTargets.push_back(targetKey);
        }
 
        for (auto targetKey: removedTargets) {
          invalidate_queries_for_structural_entity(EntityLookupKey(Pair{Is, targetKey.entity()}));
          itTargets->second.erase(targetKey);
 
          const auto itRelations = m_entityToAsRelations.find(targetKey);
          if (itRelations != m_entityToAsRelations.end()) {
            itRelations->second.erase(sourceKey);
            if (itRelations->second.empty())
              m_entityToAsRelations.erase(itRelations);
          }
        }
 
        if (itTargets->second.empty())
          m_entityToAsTargets.erase(itTargets);
 
        m_entityToAsTargetsTravCache = {};
        m_entityToAsRelationsTravCache = {};
      }
 
      template <typename Func>
      void each_delete_cascade_direct_source(Entity target, Pair cond, Func&& func) {
        GAIA_ASSERT(!target.pair());
 
        for (const auto& [relKey, store]: m_nonFragmentingRelationsByRel) {
          const auto relation = relKey.entity();
          if (!has(relation, cond))
            continue;
 
          const auto* pSources = store.sources(target);
          if (pSources == nullptr)
            continue;
 
          for (auto source: *pSources)
            func(source);
        }
 
        const auto pairEntity = Pair(All, target);
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(pairEntity));
        if (it != m_entityToArchetypeMap.end()) {
          for (const auto& record: it->second) {
            auto* pArchetype = record.pArchetype;
            if (pArchetype == nullptr || pArchetype->is_req_del())
              continue;
            if (!archetype_cond_match(*pArchetype, cond, pairEntity))
              continue;
 
            for (const auto* pChunk: pArchetype->chunks()) {
              const auto entities = pChunk->entity_view();
              GAIA_EACH(entities)
              func(entities[i]);
            }
          }
        }
      }
 
      GAIA_NODISCARD bool has_delete_cascade_direct_sources(Entity target, Pair cond) const {
        GAIA_ASSERT(!target.pair());
 
        for (const auto& [relKey, store]: m_nonFragmentingRelationsByRel) {
          if (store.sources(target) != nullptr && has(relKey.entity(), cond))
            return true;
        }
 
        const auto pairEntity = Pair(All, target);
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(pairEntity));
        if (it == m_entityToArchetypeMap.end())
          return false;
 
        for (const auto& record: it->second) {
          auto* pArchetype = record.pArchetype;
          if (pArchetype == nullptr || pArchetype->is_req_del())
            continue;
          if (!archetype_cond_match(*pArchetype, cond, pairEntity))
            continue;
 
          for (const auto* pChunk: pArchetype->chunks()) {
            if (!pChunk->empty())
              return true;
          }
        }
 
        return false;
      }
 
      void collect_delete_cascade_direct_sources(Entity target, Pair cond, cnt::darray<Entity>& out) {
        GAIA_ASSERT(!target.pair());
        const auto visitStamp = next_entity_visit_stamp();
        each_delete_cascade_direct_source(target, cond, [&](Entity source) {
          if (!valid(source))
            return;
          if (!try_mark_entity_visited(source, visitStamp))
            return;
          out.push_back(source);
        });
      }
 
      void collect_delete_cascade_sources(Entity target, Pair cond, cnt::darray<Entity>& out) {
        GAIA_ASSERT(!target.pair());
        const auto visitStamp = next_entity_visit_stamp();
        cnt::darray_ext<Entity, 32> targetsToVisit;
        (void)try_mark_entity_visited(target, visitStamp);
        targetsToVisit.push_back(target);
 
        for (uint32_t i = 0; i < targetsToVisit.size(); ++i) {
          const auto currTarget = targetsToVisit[i];
          each_delete_cascade_direct_source(currTarget, cond, [&](Entity source) {
            if (!valid(source))
              return;
            if (!try_mark_entity_visited(source, visitStamp))
              return;
 
            out.push_back(source);
            targetsToVisit.push_back(source);
          });
        }
      }
 
      void req_del_entities_with(Entity entity) {
        GAIA_PROF_SCOPE(World::req_del_entities_with);
 
        GAIA_ASSERT(entity != Pair(All, All));
 
        auto req_del_nonfragmenting_pair = [&](Entity relation, Entity target) {
          cnt::darray<Entity> sourcesToDel;
          sources(relation, target, [&](Entity source) {
            sourcesToDel.push_back(source);
          });
 
          for (auto source: sourcesToDel)
            req_del(fetch(source), source);
        };
 
        if (entity.pair()) {
          if (entity.id() != All.id()) {
            const auto relation = try_get(entity.id());
            const auto target = try_get(entity.gen());
            if (relation != EntityBad && target != EntityBad && relation_uses_non_fragmenting_storage(relation))
              req_del_nonfragmenting_pair(relation, target);
          } else {
            const auto target = try_get(entity.gen());
            if (target == EntityBad)
              goto skip_req_del_all_target;
            for (const auto& [relKey, store]: m_nonFragmentingRelationsByRel) {
              if (store.sources(target) == nullptr)
                continue;
 
              req_del_nonfragmenting_pair(relKey.entity(), target);
            }
          skip_req_del_all_target:;
          }
        } else if (relation_uses_non_fragmenting_storage(entity)) {
          if (const auto* pTargets = targets(entity)) {
            for (auto targetKey: *pTargets)
              req_del_nonfragmenting_pair(entity, targetKey.entity());
          }
        }
 
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(entity));
        if (it == m_entityToArchetypeMap.end())
          return;
 
        for (const auto& record: it->second)
          req_del(*record.pArchetype);
      }
 
      void req_del_entities_with(Entity entity, Pair cond) {
        cnt::set<EntityLookupKey> visited;
        req_del_entities_with(entity, cond, visited);
      }
 
      void req_del_entities_with(Entity entity, Pair cond, cnt::set<EntityLookupKey>& visited) {
        GAIA_PROF_SCOPE(World::req_del_entities_with);
 
        GAIA_ASSERT(entity != Pair(All, All));
        if (!visited.insert(EntityLookupKey(entity)).second)
          return;
 
        cnt::darray<Entity> cascadeTargets;
        if (entity.pair() && entity.id() == All.id()) {
          const auto target = try_get(entity.gen());
          if (target != EntityBad)
            collect_delete_cascade_direct_sources(target, cond, cascadeTargets);
        }
 
        auto req_del_nonfragmenting_pair = [&](Entity relation, Entity target) {
          if (!has(relation, cond))
            return;
 
          cnt::darray<Entity> sourcesToDel;
          sources(relation, target, [&](Entity source) {
            sourcesToDel.push_back(source);
          });
 
          for (auto source: sourcesToDel)
            req_del(fetch(source), source);
        };
 
        for (auto source: cascadeTargets) {
          if (has_delete_cascade_direct_sources(source, cond))
            req_del_entities_with(Pair(All, source), cond, visited);
        }
 
        if (entity.pair()) {
          if (entity.id() != All.id()) {
            const auto relation = try_get(entity.id());
            const auto target = try_get(entity.gen());
            if (relation != EntityBad && target != EntityBad && relation_uses_non_fragmenting_storage(relation))
              req_del_nonfragmenting_pair(relation, target);
          } else {
            const auto target = try_get(entity.gen());
            if (target == EntityBad)
              goto skip_req_del_all_target_cond;
            for (const auto& [relKey, store]: m_nonFragmentingRelationsByRel) {
              if (store.sources(target) == nullptr)
                continue;
 
              req_del_nonfragmenting_pair(relKey.entity(), target);
            }
          skip_req_del_all_target_cond:;
          }
        } else if (relation_uses_non_fragmenting_storage(entity)) {
          if (const auto* pTargets = targets(entity)) {
            for (auto targetKey: *pTargets)
              req_del_nonfragmenting_pair(entity, targetKey.entity());
          }
        }
 
        const auto it = m_entityToArchetypeMap.find(EntityLookupKey(entity));
        if (it == m_entityToArchetypeMap.end())
          return;
 
        for (const auto& record: it->second) {
          auto* pArchetype = record.pArchetype;
          // 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);
 
        invalidate_pair_removal_caches(entity);
 
        auto rem_nonfragmenting_pair = [&](Entity relation, Entity target) {
          cnt::darray<Entity> sourcesToRem;
          sources(relation, target, [&](Entity source) {
            sourcesToRem.push_back(source);
          });
 
          for (auto source: sourcesToRem)
            del(source, Pair(relation, target));
        };
 
        if (entity.pair()) {
          if (entity.id() != All.id()) {
            const auto relation = try_get(entity.id());
            const auto target = try_get(entity.gen());
            if (relation != EntityBad && target != EntityBad && relation_uses_non_fragmenting_storage(relation))
              rem_nonfragmenting_pair(relation, target);
          } else {
            const auto target = try_get(entity.gen());
            if (target == EntityBad)
              goto skip_rem_all_target;
            for (const auto& [relKey, store]: m_nonFragmentingRelationsByRel) {
              if (store.sources(target) == nullptr)
                continue;
 
              rem_nonfragmenting_pair(relKey.entity(), target);
            }
          skip_rem_all_target:;
          }
        } else if (relation_uses_non_fragmenting_storage(entity)) {
          if (const auto* pTargets = targets(entity)) {
            for (auto targetKey: *pTargets)
              rem_nonfragmenting_pair(entity, targetKey.entity());
          }
        }
 
        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);
          }
        }
 
#if GAIA_OBSERVERS_ENABLED
        cnt::set<EntityLookupKey> diffTermSet;
        cnt::darray<Entity> diffTerms;
        cnt::darray<Entity> diffTargets;
        for (const auto& record: it->second) {
          auto* pArchetype = record.pArchetype;
          if (pArchetype->is_req_del())
            continue;
 
          auto* pDstArchetype = calc_dst_archetype(pArchetype, entity);
          if (pDstArchetype == nullptr)
            continue;
 
          for (auto id: pArchetype->ids_view()) {
            bool matches = false;
            if (entity.pair()) {
              if (entity.id() == All.id() && entity.gen() == All.id())
                matches = id.pair();
              else if (entity.id() == All.id())
                matches = id.pair() && id.gen() == entity.gen();
              else if (entity.gen() == All.id())
                matches = id.pair() && id.id() == entity.id();
              else
                matches = id == entity;
            } else
              matches = id == entity;
 
            if (!matches)
              continue;
 
            if (diffTermSet.insert(EntityLookupKey(id)).second)
              diffTerms.push_back(id);
          }
 
          for (const auto* pChunk: pArchetype->chunks()) {
            const auto entities = pChunk->entity_view();
            GAIA_EACH(entities)
            diffTargets.push_back(entities[i]);
          }
        }
        auto delDiffCtx = diffTargets.empty() || diffTerms.empty()
                              ? ObserverRegistry::DiffDispatchCtx{}
                              : m_observers.prepare_diff(
                                    *this, ObserverEvent::OnDel, EntitySpan{diffTerms.data(), diffTerms.size()},
                                    EntitySpan{diffTargets.data(), diffTargets.size()});
#endif
 
        // Update archetypes of all affected entities
        for (const auto& record: it->second) {
          auto* pArchetype = record.pArchetype;
          if (pArchetype->is_req_del())
            continue;
 
          if (entity.pair()) {
            cnt::darray_ext<Entity, 16> removedIsTargets;
            for (auto id: pArchetype->ids_view()) {
              bool matches = false;
              if (entity.id() == All.id() && entity.gen() == All.id())
                matches = id.pair();
              else if (entity.id() == All.id())
                matches = id.pair() && id.gen() == entity.gen();
              else if (entity.gen() == All.id())
                matches = id.pair() && id.id() == entity.id();
              else
                matches = id == entity;
 
              if (!matches || !id.pair() || id.id() != Is.id())
                continue;
 
              const auto target = try_get(id.gen());
              if (target != EntityBad)
                removedIsTargets.push_back(target);
            }
 
            if (!removedIsTargets.empty()) {
              for (const auto* pChunk: pArchetype->chunks()) {
                auto entities = pChunk->entity_view();
                GAIA_EACH(entities) {
                  for (const auto target: removedIsTargets)
                    unlink_live_is_relation(entities[i], target);
                }
              }
            }
          }
 
          auto* pDstArchetype = calc_dst_archetype(pArchetype, entity);
          if (pDstArchetype != nullptr)
            move_to_archetype(*pArchetype, *pDstArchetype);
        }
 
#if GAIA_OBSERVERS_ENABLED
        m_observers.finish_diff(*this, GAIA_MOV(delDiffCtx));
#endif
      }
 
      void rem_from_entities(Entity entity, Pair cond) {
        GAIA_PROF_SCOPE(World::rem_from_entities);
 
        invalidate_pair_removal_caches(entity);
 
        auto rem_nonfragmenting_pair = [&](Entity relation, Entity target) {
          if (!has(relation, cond))
            return;
 
          cnt::darray<Entity> sourcesToRem;
          sources(relation, target, [&](Entity source) {
            sourcesToRem.push_back(source);
          });
 
          for (auto source: sourcesToRem)
            del(source, Pair(relation, target));
        };
 
        if (entity.pair()) {
          if (entity.id() != All.id()) {
            const auto relation = try_get(entity.id());
            const auto target = try_get(entity.gen());
            if (relation != EntityBad && target != EntityBad && relation_uses_non_fragmenting_storage(relation))
              rem_nonfragmenting_pair(relation, target);
          } else {
            const auto target = try_get(entity.gen());
            if (target == EntityBad)
              goto skip_rem_all_target_cond;
            for (const auto& [relKey, store]: m_nonFragmentingRelationsByRel) {
              if (store.sources(target) == nullptr)
                continue;
 
              rem_nonfragmenting_pair(relKey.entity(), target);
            }
          skip_rem_all_target_cond:;
          }
        } else if (relation_uses_non_fragmenting_storage(entity)) {
          if (const auto* pTargets = targets(entity)) {
            for (auto targetKey: *pTargets)
              rem_nonfragmenting_pair(entity, targetKey.entity());
          }
        }
 
        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);
          }
        }
 
#if GAIA_OBSERVERS_ENABLED
        cnt::set<EntityLookupKey> diffTermSet;
        cnt::darray<Entity> diffTerms;
        cnt::darray<Entity> diffTargets;
        for (const auto& record: it->second) {
          auto* pArchetype = record.pArchetype;
          if (pArchetype->is_req_del())
            continue;
 
          if (!archetype_cond_match(*pArchetype, cond, entity))
            continue;
 
          auto* pDstArchetype = calc_dst_archetype(pArchetype, entity);
          if (pDstArchetype == nullptr)
            continue;
 
          for (auto id: pArchetype->ids_view()) {
            bool matches = false;
            if (entity.pair()) {
              if (entity.id() == All.id() && entity.gen() == All.id())
                matches = id.pair();
              else if (entity.id() == All.id())
                matches = id.pair() && id.gen() == entity.gen();
              else if (entity.gen() == All.id())
                matches = id.pair() && id.id() == entity.id();
              else
                matches = id == entity;
            } else
              matches = id == entity;
 
            if (!matches)
              continue;
 
            if (diffTermSet.insert(EntityLookupKey(id)).second)
              diffTerms.push_back(id);
          }
 
          for (const auto* pChunk: pArchetype->chunks()) {
            const auto entities = pChunk->entity_view();
            GAIA_EACH(entities)
            diffTargets.push_back(entities[i]);
          }
        }
        auto delDiffCtx = diffTargets.empty() || diffTerms.empty()
                              ? ObserverRegistry::DiffDispatchCtx{}
                              : m_observers.prepare_diff(
                                    *this, ObserverEvent::OnDel, EntitySpan{diffTerms.data(), diffTerms.size()},
                                    EntitySpan{diffTargets.data(), diffTargets.size()});
#endif
 
        for (const auto& record: it->second) {
          auto* pArchetype = record.pArchetype;
          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);
        }
 
#if GAIA_OBSERVERS_ENABLED
        m_observers.finish_diff(*this, GAIA_MOV(delDiffCtx));
#endif
      }
 
      void del_pair_entities(EntitySpan pairEntities) {
        for (auto pair: pairEntities) {
          if (valid(pair))
            del_inter(pair);
        }
      }
 
      void handle_del_entity(EntityContainer& ec, Entity entity, EntitySpan pairEntities) {
        GAIA_PROF_SCOPE(World::handle_del_entity);
 
        GAIA_ASSERT(!is_wildcard(entity));
#if GAIA_OBSERVERS_ENABLED
        if (entity_deletion_active(entity))
          return;
#endif
 
        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 = try_get(entity.gen());
          const bool hasLiveTarget = tgt != EntityBad;
          if (hasLiveTarget) {
            const auto& ecTgt = fetch(tgt);
            if ((ecTgt.flags & EntityContainerFlags::OnDeleteTarget_Error) != 0 ||
                has_nonfragmenting_relation_target_cond(tgt, Pair(OnDeleteTarget, Error))) {
              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 GAIA_OBSERVERS_ENABLED
          entity_deletion_enter(entity);
#endif
 
          if (hasLiveTarget) {
            const auto& ecTgt = fetch(tgt);
            if ((ecTgt.flags & EntityContainerFlags::OnDeleteTarget_Delete) != 0 ||
                has_nonfragmenting_relation_target_cond(tgt, Pair(OnDeleteTarget, Delete))) {
#if GAIA_OBSERVERS_ENABLED
              cnt::darray<Entity> cascadeTargets;
              collect_delete_cascade_sources(tgt, Pair(OnDeleteTarget, Delete), cascadeTargets);
              auto cascadeDelDiffCtx =
                  cascadeTargets.empty()
                      ? ObserverRegistry::DiffDispatchCtx{}
                      : m_observers.prepare_diff(
                            *this, ObserverEvent::OnDel, EntitySpan{cascadeTargets.data(), cascadeTargets.size()},
                            EntitySpan{cascadeTargets.data(), cascadeTargets.size()});
#endif
              // Delete all entities referencing this one as a relationship pair's target
              req_del_entities_with(Pair(All, tgt), Pair(OnDeleteTarget, Delete));
#if GAIA_OBSERVERS_ENABLED
              m_observers.finish_diff(*this, GAIA_MOV(cascadeDelDiffCtx));
#endif
            } 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)) {
#if GAIA_OBSERVERS_ENABLED
            entity_deletion_leave(entity);
#endif
            return;
          }
 
#if GAIA_OBSERVERS_ENABLED
          observers().del(*this, entity);
#endif
#if GAIA_SYSTEMS_ENABLED
          systems().del(entity);
#endif
 
          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 ||
              has_nonfragmenting_relation_target_cond(entity, Pair(OnDeleteTarget, Error))) {
            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 GAIA_OBSERVERS_ENABLED
          entity_deletion_enter(entity);
#endif
 
          const bool deleteTargets = (ec.flags & EntityContainerFlags::OnDeleteTarget_Delete) != 0 ||
                                     has_nonfragmenting_relation_target_cond(entity, Pair(OnDeleteTarget, Delete));
          cnt::darray<Entity> cascadeTargets;
          if (deleteTargets)
            collect_delete_cascade_sources(entity, Pair(OnDeleteTarget, Delete), cascadeTargets);
#if GAIA_OBSERVERS_ENABLED
          auto cascadeDelDiffCtx = ObserverRegistry::DiffDispatchCtx{};
          if (!cascadeTargets.empty()) {
            cascadeDelDiffCtx = m_observers.prepare_diff(
                *this, ObserverEvent::OnDel, EntitySpan{cascadeTargets.data(), cascadeTargets.size()},
                EntitySpan{cascadeTargets.data(), cascadeTargets.size()});
          }
#endif
 
          if (deleteTargets) {
            // 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));
          }
 
#if GAIA_OBSERVERS_ENABLED
          m_observers.finish_diff(*this, GAIA_MOV(cascadeDelDiffCtx));
#endif
 
          // This entity is has been requested to be deleted already. Nothing more for us to do here
          if (is_req_del(ec)) {
            del_pair_entities(pairEntities);
#if GAIA_OBSERVERS_ENABLED
            entity_deletion_leave(entity);
#endif
            return;
          }
 
#if GAIA_OBSERVERS_ENABLED
          observers().del(*this, entity);
#endif
#if GAIA_SYSTEMS_ENABLED
          systems().del(entity);
#endif
 
          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);
          }
        }
 
        del_pair_entities(pairEntities);
 
        // Mark the entity with the "delete requested" flag
        req_del_inter(ec, entity);
 
#if GAIA_USE_WEAK_ENTITY
        // Invalidate WeakEntities
        while (ec.pWeakTracker != nullptr) {
          auto* pTracker = ec.pWeakTracker;
          ec.pWeakTracker = pTracker->next;
          if (ec.pWeakTracker != nullptr)
            ec.pWeakTracker->prev = nullptr;
 
          auto* pWeakEntity = pTracker->pWeakEntity;
          GAIA_ASSERT(pWeakEntity != nullptr);
          GAIA_ASSERT(pWeakEntity->m_pTracker == pTracker);
          pWeakEntity->m_pTracker = nullptr;
          pWeakEntity->m_entity = EntityBad;
          delete pTracker;
        }
#endif
#if GAIA_OBSERVERS_ENABLED
        entity_deletion_leave(entity);
#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;
 
        for (const auto& record: it->second) {
          auto* pArchetype = record.pArchetype;
          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 touch_rel_version(Entity relation) {
        if (m_pLastRelationVersion != nullptr && m_lastRelationVersionRelation == relation) {
          ++*m_pLastRelationVersion;
          if (*m_pLastRelationVersion == 0)
            *m_pLastRelationVersion = 1;
          return;
        }
 
        const EntityLookupKey key(relation);
        const auto ret = m_relationVersions.try_emplace(key, 1);
        auto it = ret.first;
        if (!ret.second) {
          ++it->second;
          if (it->second == 0)
            it->second = 1;
        }
 
        m_lastRelationVersionRelation = relation;
        m_pLastRelationVersion = &it->second;
      }
 
      void clear_relation_caches() {
        if (!m_relationCachesPopulated)
          return;
        m_relationCachesPopulated = false;
 
        m_targetsTravCache = {};
        m_srcBfsTravCache = {};
        m_depthOrderCache = {};
        m_sourcesAllCache = {};
        m_targetsAllCache = {};
      }
 
      void invalidate_relation_caches(Entity relation) {
        touch_rel_version(relation);
        invalidate_queries_for_rel(relation);
        clear_relation_caches();
      }
 
      bool del_pair_record(Entity entity, Archetype*& pArchetype, Entity& rel, Entity& tgt) {
        GAIA_ASSERT(entity.pair());
 
        EntityContainer ec{};
        if (!m_recs.pair_record_remove(entity, ec))
          return false;
 
        pArchetype = ec.pArchetype;
 
        // The relation or target entity may already be invalid at this point. Rebuild the
        // lookup keys from the stored entity records instead of calling get().
        GAIA_ASSERT(entity.id() < m_recs.entities.size());
        GAIA_ASSERT(entity.gen() < m_recs.entities.size());
        rel = m_recs.entities.handle(entity.id());
        tgt = m_recs.entities.handle(entity.gen());
        return true;
      }
 
      void del_pair_lookup(Entity rel, Entity tgt) {
        m_pairLookup.del_pair(rel, tgt);
      }
 
      void del_entity_pair_lookup(Entity entity) {
        m_pairLookup.del_entity_pairs(entity);
      }
 
      void del_pair_data_for_entity(Entity entity) {
        Archetype* pArchetype = nullptr;
 
        if (entity.pair()) {
          Entity rel;
          Entity tgt;
          if (del_pair_record(entity, pArchetype, rel, tgt))
            del_pair_lookup(rel, tgt);
        } else {
          // Update the container record
          auto ec = m_recs.entities[entity.id()];
          m_recs.entities.free(entity);
 
          // Remove all sparse-storage components from this entity.
          del_sparse_components(entity);
          // Remove all outgoing non-fragmenting exclusive relations from this source entity.
          del_nonfragmenting_relation_source(entity);
          // If the deleted entity is itself a non-fragmenting exclusive relation, drop its store.
          del_nonfragmenting_relation(entity);
          // If the deleted entity is itself a sparse-storage component, drop its store.
          del_sparse_component_store(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;
          ec.pEntity = nullptr;
          EntityBuilder::set_flag(ec.flags, EntityContainerFlags::DeleteRequested, false);
 
          // Update pair lookup entries.
          del_entity_pair_lookup(entity);
        }
 
        del_entity_archetype_pairs(entity, pArchetype);
      }
 
      void invalidate_entity(Entity entity) {
        del_graph_edges(entity);
        del_pair_data_for_entity(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);
        ec.pEntity = &pChunk->entity_view()[ec.row];
        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;
        const bool archetypeChanged = srcArchetype.id() != dstArchetype.id();
#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;
        ec.pEntity = &pDstChunk->entity_view()[dstRow];
        if (archetypeChanged)
          update_src_entity_version(entity);
 
        // 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();
        ec.pChunk->update_entity_order_version();
 
        auto* pDstChunk = dstArchetype.foc_free_chunk();
        move_entity(entity, ec, dstArchetype, *pDstChunk);
 
        // Update world versions
        pDstChunk->update_world_version();
        pDstChunk->update_entity_order_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();
        ec.pChunk->update_entity_order_version();
 
        auto* pDstChunk = dstArchetype.foc_free_chunk();
        move_entity(entity, ec, dstArchetype, *pDstChunk);
 
        // Update world versions
        pDstChunk->update_world_version();
        pDstChunk->update_entity_order_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);
 
        const auto entities = pChunk->entity_view();
        for (uint16_t row = 0; row < entities.size(); ++row) {
          const auto entity = entities[row];
          const EntityContainer* pEc = nullptr;
          if (entity.pair()) {
            pEc = m_recs.pair_record_find(entity);
          } else if (entity.id() < m_recs.entities.size()) {
            pEc = &m_recs.entities[entity.id()];
          }
 
          if (pEc == nullptr) {
            GAIA_ASSERT(!valid(entity));
            continue;
          }
          if (!valid(entity)) {
            GAIA_ASSERT(is_req_del(*pEc));
            continue;
          }
          GAIA_ASSERT(pEc->pChunk == pChunk);
          GAIA_ASSERT(pEc->row == row);
          GAIA_ASSERT(pEc->pEntity == &entities[row]);
        }
 
        for (const auto& ec: m_recs.entities) {
          if (ec.pChunk != pChunk)
            continue;
          const Entity entity(ec.idx, ec.data.gen, ec.data.ent != 0, false, (EntityKind)ec.data.kind);
          if (!valid(entity)) {
            GAIA_ASSERT(is_req_del(ec));
            continue;
          }
          GAIA_ASSERT(ec.row < entities.size());
          GAIA_ASSERT(entities[ec.row] == entity);
          GAIA_ASSERT(ec.pEntity == &entities[ec.row]);
        }
 
        for (auto it = m_recs.pair_record_begin(); it != m_recs.pair_record_end(); ++it) {
          const auto& pair = *it;
          const auto& ec = pair.second;
          if (ec.pChunk != pChunk)
            continue;
          const auto entity = pair.first.entity();
          if (!valid(entity)) {
            GAIA_ASSERT(is_req_del(ec));
            continue;
          }
          GAIA_ASSERT(ec.row < entities.size());
          GAIA_ASSERT(entities[ec.row] == entity);
          GAIA_ASSERT(ec.pEntity == &entities[ec.row]);
        }
#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& targets = as_targets_trav_cache(entity);
        for (auto target: targets) {
          if (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.pEntity;
          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);
      }
 
      static ComponentDesc primitive_type_desc(const char* name, uint32_t nameLen, uint32_t size) {
        ComponentDesc desc{};
        desc.name = util::str_view(name, nameLen);
        desc.size = size;
        desc.alig = size;
        desc.storageType = DataStorageType::Table;
        desc.runtimeType.typeKind = RuntimeTypeKind::Primitive;
        return desc;
      }
 
      const ComponentCacheItem& reg_core_primitive_type(Entity id, const char* name, uint32_t nameLen, uint32_t size) {
        auto comp = add(*m_pCompArchetype, id.entity(), id.pair(), id.kind());
        const auto desc = primitive_type_desc(name, nameLen, size);
        const auto& ci = comp_cache_mut().add(id, desc);
        GAIA_ASSERT(ci.entity == id);
        GAIA_ASSERT(comp == id);
        (void)comp;
        finalize_component_registration(ci, false);
        return ci;
      }
 
      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
      }
 
      bool assign_pair_record(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);
 
        if (m_recs.pair_record_contains(entity))
          return false;
 
        // 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.pair_record_add(entity, GAIA_MOV(ec));
        return true;
      }
 
      void add_pair_lookup(Entity entity) {
        GAIA_ASSERT(entity.pair());
 
        const auto rel = get(entity.id());
        const auto tgt = get(entity.gen());
        m_pairLookup.add_pair(rel, tgt);
      }
 
      void assign_pair(Entity entity, Archetype& archetype) {
        if (!assign_pair_record(entity, archetype))
          return;
 
        add_pair_lookup(entity);
 
#if GAIA_OBSERVERS_ENABLED
        m_observers.try_mark_term_observed(*this, entity);
#endif
      }
 
      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};
#if GAIA_OBSERVERS_ENABLED
        const auto addedIds = EntitySpan{archetype.ids_view()};
        ObserverRegistry::DiffDispatchCtx addDiffCtx{};
        if (!addedIds.empty())
          addDiffCtx = m_observers.prepare_diff_add_new(*this, addedIds);
#endif
 
        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();
 
#if GAIA_OBSERVERS_ENABLED
          if (!addedIds.empty()) {
            auto entities = pChunk->entity_view();
            const auto targets = EntitySpan{entities.data() + originalChunkSize, toCreate};
            m_observers.add_diff_targets(*this, addDiffCtx, targets);
            m_observers.on_add(*this, archetype, addedIds, targets);
          }
#endif
 
          left -= toCreate;
        } while (left > 0);
 
#if GAIA_OBSERVERS_ENABLED
        if (!addedIds.empty())
          m_observers.finish_diff(*this, GAIA_MOV(addDiffCtx));
#endif
      }
 
      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_structural_entity(EntityLookupKey entityKey) {
        m_queryCache.invalidate_queries_for_entity(entityKey, QueryCache::ChangeKind::Structural);
      }
 
      void invalidate_queries_for_rel(Entity relation) {
        if (!m_queryCache.has_relation_query_dependencies())
          return;
 
        m_queryCache.invalidate_queries_for_rel(relation, QueryCache::ChangeKind::DynamicResult);
      }
 
      GAIA_NODISCARD bool has_sorted_queries() const {
        return m_queryCache.has_sorted_queries();
      }
 
      GAIA_NODISCARD bool has_sorted_queries_for_entity(Entity entity) const {
        return m_queryCache.has_sorted_queries_for_entity(entity);
      }
 
      void invalidate_sorted_queries_for_entity(Entity entity) {
        m_queryCache.invalidate_sorted_queries_for_entity(entity);
      }
 
      void invalidate_sorted_queries() {
        m_queryCache.invalidate_sorted_queries();
      }
 
      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.
          invalidate_queries_for_structural_entity(EntityLookupKey(Pair{Is, target}));
        });
      }
 
      Entity name_to_entity(std::span<const char> exprRaw) const {
        auto expr = util::trim(exprRaw);
        if (expr.empty())
          return EntityBad;
 
        if (expr[0] == '(') {
          if (expr.size() < 5 || expr.back() != ')')
            return EntityBad;
 
          const auto idStr = expr.subspan(1, expr.size() - 2);
          const auto commaIdx = core::get_index(idStr, ',');
          if (commaIdx == BadIndex)
            return EntityBad;
 
          const auto first = name_to_entity(idStr.subspan(0, commaIdx));
          if (first == EntityBad || first.pair())
            return EntityBad;
          const auto second = name_to_entity(idStr.subspan(commaIdx + 1));
          if (second == EntityBad || second.pair())
            return EntityBad;
 
          return ecs::Pair(first, second);
        }
 
        // Wildcard character
        if (expr.size() == 1 && expr[0] == '*')
          return All;
 
        return get_inter(expr.data(), (uint32_t)expr.size());
      }
 
      Entity expr_to_entity(va_list& args, std::span<const char> exprRaw) const {
        auto expr = util::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 = util::trim(expr);
 
          // Wildcard character
          if (idStr.size() == 1 && idStr[0] == '*')
            return All;
 
          // Anything else is a component name
          const auto* pItem = resolve_component_name_inter(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;
        }
      }
    };
 
    inline ComponentRawView world_get_raw(const World& world, Entity entity, Entity component) {
      return world.get_raw(entity, component);
    }
 
    inline bool world_bind_raw_sparse_store(const World& world, Entity component, RawSparseStoreOps& ops) {
      const auto* pStore = world.sparse_component_store_erased(component);
      if (pStore == nullptr)
        return false;
 
      const auto* pItem = world.comp_cache().find(component);
      GAIA_ASSERT(pItem != nullptr);
      ops = {pStore->pStore, pStore->func_get, pStore->func_mut, pStore->func_has, pItem->comp.size()};
      return true;
    }
 
    inline ComponentRawMutView world_mut_raw(World& world, Entity entity, Entity component) {
      return world.mut_raw(entity, component);
    }
 
    inline ComponentRawView
    world_get_raw_field(const World& world, Entity entity, Entity component, uint32_t fieldIdx) {
      return world.get_raw_field(entity, component, fieldIdx);
    }
 
    inline ComponentRawMutView world_mut_raw_field(World& world, Entity entity, Entity component, uint32_t fieldIdx) {
      return world.mut_raw_field(entity, component, fieldIdx);
    }
 
    inline ComponentCursor World::cursor(Entity entity, Entity component) const {
      if (component != EntityBad && valid(entity)) {
        const auto owner = id_owner_inter(entity, component);
        if (owner != EntityBad) {
          const auto* pItem = component_item(owner, component);
          if (pItem != nullptr && soa_field_supported(*pItem)) {
            const auto& ec = fetch(owner);
            if (ec.pChunk->comp_idx(component) != ComponentIndexBad)
              return ComponentCursor::from_soa(*this, comp_cache(), owner, component, pItem->comp.size());
          }
        }
      }
 
      return ComponentCursor::from_raw(comp_cache(), component, get_raw(entity, component));
    }
 
    inline ComponentCursor World::cursor_mut(Entity entity, Entity component) {
      if (component != EntityBad && valid(entity)) {
        const auto& ec = fetch(entity);
        const auto* pItem = !is_req_del(ec) ? component_item(entity, component) : nullptr;
        if (pItem != nullptr && soa_field_supported(*pItem) &&
            core::get_index(ec.pChunk->ids_view(), component) != BadIndex)
          return ComponentCursor::from_soa(*this, comp_cache(), entity, component, pItem->comp.size());
      }
 
      return ComponentCursor::from_raw(*this, comp_cache(), entity, component, mut_raw(entity, component));
    }
 
    using EntityBuilder = World::EntityBuilder;
  } // namespace ecs
} // namespace gaia
 
#include "api.inl"
#if GAIA_OBSERVERS_ENABLED
  #include "observer_registry.inl"
#endif
 
#include "observer.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);
          const auto symbol = ci.symbol_name();
          sset<EntityDesc>(id) = {symbol.data(), symbol.size(), nullptr, 0};
          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);
          const auto symbol = ci.symbol_name();
          acc_mut(id)
              // Entity descriptor
              .sset<EntityDesc>({symbol.data(), symbol.size(), nullptr, 0})
              // 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<DontFragment_>(DontFragment);
        (void)reg_core_entity<Sparse_>(Sparse);
        (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<Parent_>(Parent);
        (void)reg_core_entity<Is_>(Is);
        (void)reg_core_entity<Prefab_>(Prefab);
        (void)reg_core_entity<OnInstantiate_>(OnInstantiate);
        (void)reg_core_entity<Override_>(Override);
        (void)reg_core_entity<Inherit_>(Inherit);
        (void)reg_core_entity<DontInherit_>(DontInherit);
        (void)reg_core_entity<System_>(System);
        (void)reg_core_entity<DependsOn_>(DependsOn);
        (void)reg_core_entity<Observer_>(Observer);
 
        (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);
 
        (void)reg_core_primitive_type(S8, "gaia::ecs::S8", 13, 1);
        (void)reg_core_primitive_type(U8, "gaia::ecs::U8", 13, 1);
        (void)reg_core_primitive_type(S16, "gaia::ecs::S16", 14, 2);
        (void)reg_core_primitive_type(U16, "gaia::ecs::U16", 14, 2);
        (void)reg_core_primitive_type(S32, "gaia::ecs::S32", 14, 4);
        (void)reg_core_primitive_type(U32, "gaia::ecs::U32", 14, 4);
        (void)reg_core_primitive_type(S64, "gaia::ecs::S64", 14, 8);
        (void)reg_core_primitive_type(U64, "gaia::ecs::U64", 14, 8);
        (void)reg_core_primitive_type(Bool, "gaia::ecs::Bool", 15, 1);
        (void)reg_core_primitive_type(Char8, "gaia::ecs::Char8", 16, 1);
        (void)reg_core_primitive_type(Char16, "gaia::ecs::Char16", 17, 2);
        (void)reg_core_primitive_type(Char32, "gaia::ecs::Char32", 17, 4);
        (void)reg_core_primitive_type(F8, "gaia::ecs::F8", 13, 1);
        (void)reg_core_primitive_type(F16, "gaia::ecs::F16", 14, 2);
        (void)reg_core_primitive_type(F32, "gaia::ecs::F32", 14, 4);
        (void)reg_core_primitive_type(F64, "gaia::ecs::F64", 14, 8);
      }
 
      // 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, DontFragment) //
            .add(Core)
            .add(Requires)
            .add(Pair(OnDelete, Error))
            .add(Acyclic);
        EntityBuilder(*this, Sparse) //
            .add(Core)
            .add(Requires)
            .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, Parent) //
            .add(Core)
            .add(Acyclic)
            .add(Exclusive)
            .add(DontFragment)
            .add(Traversable)
            .add(Pair(OnDelete, Error))
            .add(Pair(OnDeleteTarget, Delete));
        EntityBuilder(*this, Is) //
            .add(Core)
            .add(Acyclic)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Prefab) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, OnInstantiate) //
            .add(Core)
            .add(Acyclic)
            .add(Exclusive)
            .add(DontFragment)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Override) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Inherit) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, DontInherit) //
            .add(Core)
            .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, Observer) //
            .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));
 
        EntityBuilder(*this, S8) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, U8) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, S16) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, U16) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, S32) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, U32) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, S64) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, U64) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Bool) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Char8) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Char16) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, Char32) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, F8) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, F16) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, F32) //
            .add(Core)
            .add(Pair(OnDelete, Error));
        EntityBuilder(*this, F64) //
            .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;
    }
 
    inline GroupId group_by_func_depth_order(const World& world, const Archetype& archetype, Entity relation) {
      GAIA_ASSERT(!relation.pair());
 
      // Depth ordering only makes sense for fragmenting relations whose target participates in archetype identity.
      // Non-fragmenting relations such as Parent must stay on per-entity traversal, because their targets vary per
      // entity and cannot be represented by one cached archetype depth. The level is derived from the cached upward
      // traversal chain so normal query iteration can stay cheap.
      if (!world.relation_supports_depth_order(relation) || archetype.pairs() == 0)
        return 0;
 
      auto ids = archetype.ids_view();
      GroupId maxDepth = 0;
      bool found = false;
 
      for (auto idsIdx: archetype.pair_rel_indices(relation)) {
        const auto pair = ids[idsIdx];
        const auto target = world.pair_target_if_alive(pair);
        if (target == EntityBad)
          continue;
 
        const GroupId depth = GroupId(world.depth_order_cache(relation, target));
 
        if (!found || depth > maxDepth) {
          maxDepth = depth;
          found = true;
        }
      }
 
      return found ? maxDepth : 0;
    }
  } // namespace ecs
} // namespace gaia
 
#if GAIA_JSON_ENABLED
  #include "gaia/ecs/impl/world_json.h"
  #include "gaia/ecs/impl/world_json_patch.h"
  #include "gaia/ecs/impl/world_schema_json.h"
#endif
 
#if GAIA_SYSTEMS_ENABLED
namespace gaia {
  namespace ecs {
    namespace detail {
      GAIA_NODISCARD inline bool entity_schedule_less(Entity lhs, Entity rhs) {
        if (lhs.id() != rhs.id())
          return lhs.id() < rhs.id();
        return lhs.gen() < rhs.gen();
      }
 
      GAIA_NODISCARD inline bool system_schedule_stack_contains(const cnt::darray<Entity>& stack, Entity entity) {
        for (auto item: stack) {
          if (item == entity)
            return true;
        }
        return false;
      }
 
      GAIA_NODISCARD inline uint32_t
      system_schedule_dep_depth(World& world, Entity entity, Entity skipTarget, cnt::darray<Entity>& stack) {
        if (entity == EntityBad || system_schedule_stack_contains(stack, entity))
          return 0;
 
        stack.push_back(entity);
        uint32_t depth = 0;
        world.targets(entity, DependsOn, [&](Entity target) {
          if (target == skipTarget)
            return;
          const auto targetDepth = system_schedule_dep_depth(world, target, EntityBad, stack) + 1;
          if (targetDepth > depth)
            depth = targetDepth;
        });
        stack.pop_back();
        return depth;
      }
 
      GAIA_NODISCARD inline Entity system_phase(World& world, Entity systemEntity) {
        const auto phase = world.target(systemEntity, ChildOf);
        if (phase == EntityBad)
          return EntityBad;
        if (!world.has(systemEntity, Pair(DependsOn, phase)))
          return EntityBad;
        return phase;
      }
 
      GAIA_NODISCARD inline SystemScheduleItem system_schedule_item(World& world, Entity systemEntity) {
        SystemScheduleItem item{};
        item.entity = systemEntity;
        item.phase = system_phase(world, systemEntity);
        item.hasPhase = item.phase != EntityBad;
        return item;
      }
 
      inline void submit_pending_system_jobs(cnt::darray<PendingSystemJob>& pending) {
        for (auto& item: pending)
          item.job.submit();
      }
 
      inline void finish_pending_system_jobs(cnt::darray<PendingSystemJob>& pending) {
        for (auto& item: pending)
          item.job.wait();
        for (auto& item: pending)
          item.job.del();
        pending.clear();
      }
 
      inline void flush_pending_system_jobs(cnt::darray<PendingSystemJob>& pending) {
        submit_pending_system_jobs(pending);
        finish_pending_system_jobs(pending);
      }
 
      GAIA_NODISCARD inline bool sched_supports_deferred_system_jobs(const Sched& sched) {
        const auto& resolved = sched_resolve(sched);
        return resolved.add != nullptr && resolved.add_par != nullptr && resolved.submit != nullptr &&
               resolved.dep != nullptr && resolved.wait != nullptr && resolved.del != nullptr;
      }
 
      inline void
      system_schedule_entity_indices(const cnt::darray<SystemScheduleItem>& items, cnt::darray<uint32_t>& outIndices) {
        outIndices.clear();
        outIndices.reserve(items.size());
        for (uint32_t i = 0; i < items.size(); ++i)
          outIndices.push_back(i);
        core::sort(outIndices, [&](uint32_t lhs, uint32_t rhs) {
          return entity_schedule_less(items[lhs].entity, items[rhs].entity);
        });
      }
 
      GAIA_NODISCARD inline uint32_t system_schedule_find_item_by_entity(
          const cnt::darray<SystemScheduleItem>& items, const cnt::darray<uint32_t>& entityIndices, Entity entity) {
        uint32_t lo = 0;
        uint32_t hi = entityIndices.size();
        while (lo < hi) {
          const uint32_t mid = lo + (hi - lo) / 2;
          const auto midEntity = items[entityIndices[mid]].entity;
          if (midEntity == entity)
            return entityIndices[mid];
          if (entity_schedule_less(midEntity, entity))
            lo = mid + 1;
          else
            hi = mid;
        }
        return UINT32_MAX;
      }
 
      GAIA_NODISCARD inline bool
      system_schedule_same_group(const SystemScheduleItem& lhs, const SystemScheduleItem& rhs) {
        if (lhs.hasPhase != rhs.hasPhase)
          return false;
        if (!lhs.hasPhase)
          return true;
        return lhs.phase == rhs.phase;
      }
 
      GAIA_NODISCARD inline uint32_t system_schedule_primary_target_idx(
          World& world, const cnt::darray<SystemScheduleItem>& items, const cnt::darray<uint32_t>& entityIndices,
          uint32_t itemIdx) {
        uint32_t bestIdx = UINT32_MAX;
        uint32_t bestDepth = 0;
        const auto& item = items[itemIdx];
        world.targets(item.entity, DependsOn, [&](Entity target) {
          if (target == item.phase)
            return;
 
          const auto targetIdx = system_schedule_find_item_by_entity(items, entityIndices, target);
          if (targetIdx == UINT32_MAX)
            return;
          if (!system_schedule_same_group(item, items[targetIdx]))
            return;
 
          const auto targetDepth = items[targetIdx].systemDepth;
          if (bestIdx == UINT32_MAX || targetDepth > bestDepth ||
              (targetDepth == bestDepth && entity_schedule_less(items[targetIdx].entity, items[bestIdx].entity))) {
            bestIdx = targetIdx;
            bestDepth = targetDepth;
          }
        });
        return bestIdx;
      }
 
      inline void system_schedule_visit_primary_children(
          cnt::darray<SystemScheduleItem>& items, const cnt::darray<uint32_t>& firstChildren,
          const cnt::darray<uint32_t>& nextSiblings, cnt::darray<uint8_t>& states, uint32_t itemIdx, uint32_t& order) {
        if (states[itemIdx] != 0)
          return;
 
        states[itemIdx] = 1;
        for (uint32_t childIdx = firstChildren[itemIdx]; childIdx != UINT32_MAX; childIdx = nextSiblings[childIdx])
          system_schedule_visit_primary_children(items, firstChildren, nextSiblings, states, childIdx, order);
        items[itemIdx].systemOrder = order++;
        states[itemIdx] = 2;
      }
 
      inline void system_schedule_assign_group_orders(
          World& world, cnt::darray<SystemScheduleItem>& items, const cnt::darray<uint32_t>& groupIndices,
          const cnt::darray<uint32_t>& entityIndices, SystemScheduleScratch& scratch) {
        auto& sortedGroupIndices = scratch.sortedGroupIndices;
        auto& primaryTargets = scratch.primaryTargets;
        auto& firstChildren = scratch.firstChildren;
        auto& nextSiblings = scratch.nextSiblings;
        auto& states = scratch.states;
 
        sortedGroupIndices = groupIndices;
        core::sort(sortedGroupIndices, [&](uint32_t lhs, uint32_t rhs) {
          return entity_schedule_less(items[lhs].entity, items[rhs].entity);
        });
 
        primaryTargets.clear();
        primaryTargets.resize(items.size(), UINT32_MAX);
        for (auto itemIdx: groupIndices)
          primaryTargets[itemIdx] = system_schedule_primary_target_idx(world, items, entityIndices, itemIdx);
 
        firstChildren.clear();
        nextSiblings.clear();
        firstChildren.resize(items.size(), UINT32_MAX);
        nextSiblings.resize(items.size(), UINT32_MAX);
        for (uint32_t i = sortedGroupIndices.size(); i > 0; --i) {
          const auto itemIdx = sortedGroupIndices[i - 1];
          const auto targetIdx = primaryTargets[itemIdx];
          if (targetIdx == UINT32_MAX)
            continue;
          nextSiblings[itemIdx] = firstChildren[targetIdx];
          firstChildren[targetIdx] = itemIdx;
        }
 
        states.clear();
        states.resize(items.size(), 0);
 
        uint32_t order = 0;
        for (auto itemIdx: sortedGroupIndices) {
          if (states[itemIdx] == 0 && primaryTargets[itemIdx] == UINT32_MAX) {
            system_schedule_visit_primary_children(items, firstChildren, nextSiblings, states, itemIdx, order);
          }
        }
 
        // Remaining items are in a DependsOn cycle. The cycle is invalid, but the update stays deterministic.
        for (auto itemIdx: sortedGroupIndices) {
          if (states[itemIdx] == 0) {
            items[itemIdx].systemOrder = order++;
            states[itemIdx] = 2;
          }
        }
      }
 
      GAIA_NODISCARD inline uint32_t
      system_schedule_find_phase(const cnt::darray<SystemPhaseScheduleItem>& phases, Entity phase) {
        for (uint32_t i = 0; i < phases.size(); ++i) {
          if (phases[i].phase == phase)
            return i;
        }
        return UINT32_MAX;
      }
 
      GAIA_NODISCARD inline uint32_t system_schedule_primary_phase_idx(
          World& world, const cnt::darray<SystemPhaseScheduleItem>& phases, uint32_t phaseIdx) {
        uint32_t bestIdx = UINT32_MAX;
        uint32_t bestDepth = 0;
        world.targets(phases[phaseIdx].phase, DependsOn, [&](Entity target) {
          const auto targetIdx = system_schedule_find_phase(phases, target);
          if (targetIdx == UINT32_MAX)
            return;
 
          const auto targetDepth = phases[targetIdx].depth;
          if (bestIdx == UINT32_MAX || targetDepth > bestDepth ||
              (targetDepth == bestDepth && entity_schedule_less(phases[targetIdx].phase, phases[bestIdx].phase))) {
            bestIdx = targetIdx;
            bestDepth = targetDepth;
          }
        });
        return bestIdx;
      }
 
      inline void system_schedule_visit_phase_children(
          cnt::darray<SystemPhaseScheduleItem>& phases, const cnt::darray<uint32_t>& firstChildren,
          const cnt::darray<uint32_t>& nextSiblings, cnt::darray<uint8_t>& states, uint32_t phaseIdx, uint32_t& order) {
        if (states[phaseIdx] != 0)
          return;
 
        states[phaseIdx] = 1;
        for (uint32_t childIdx = firstChildren[phaseIdx]; childIdx != UINT32_MAX; childIdx = nextSiblings[childIdx])
          system_schedule_visit_phase_children(phases, firstChildren, nextSiblings, states, childIdx, order);
        phases[phaseIdx].order = order++;
        states[phaseIdx] = 2;
      }
 
      inline void system_schedule_assign_phase_orders(
          World& world, cnt::darray<SystemPhaseScheduleItem>& phases, SystemScheduleScratch& scratch) {
        // Phase ordering has two layers:
        // 1. A cheap DFS postorder over each phase's primary DependsOn target. This gives stable depth/path
        //    keys and a deterministic fallback for cycles.
        // 2. A direct DependsOn topological pass. This preserves all explicit phase targets, including
        //    multi-target dependencies that the primary-target path cannot represent by itself.
        auto& sortedPhases = scratch.sortedPhases;
        auto& primaryPhases = scratch.primaryPhases;
        auto& firstChildren = scratch.firstChildren;
        auto& nextSiblings = scratch.nextSiblings;
        auto& states = scratch.states;
 
        // Work in entity-id order whenever the graph does not force a different order. That keeps
        // independent phases deterministic and makes cycle fallback stable.
        sortedPhases.clear();
        sortedPhases.reserve(phases.size());
        for (uint32_t i = 0; i < phases.size(); ++i)
          sortedPhases.push_back(i);
        core::sort(sortedPhases, [&](uint32_t lhs, uint32_t rhs) {
          return entity_schedule_less(phases[lhs].phase, phases[rhs].phase);
        });
 
        // Collapse each phase's dependency path to one primary target for the DFS ordering key. Direct
        // multi-target dependencies are handled later by the topological pass.
        primaryPhases.clear();
        primaryPhases.resize(phases.size(), UINT32_MAX);
        for (uint32_t i = 0; i < phases.size(); ++i)
          primaryPhases[i] = system_schedule_primary_phase_idx(world, phases, i);
 
        // Build primary-target adjacency once, then walk it instead of repeatedly scanning all phases for
        // children. Reverse insertion preserves sorted child traversal.
        firstChildren.clear();
        nextSiblings.clear();
        firstChildren.resize(phases.size(), UINT32_MAX);
        nextSiblings.resize(phases.size(), UINT32_MAX);
        for (uint32_t i = sortedPhases.size(); i > 0; --i) {
          const auto phaseIdx = sortedPhases[i - 1];
          const auto targetIdx = primaryPhases[phaseIdx];
          if (targetIdx == UINT32_MAX)
            continue;
          nextSiblings[phaseIdx] = firstChildren[targetIdx];
          firstChildren[targetIdx] = phaseIdx;
        }
 
        states.clear();
        states.resize(phases.size(), 0);
 
        // Assign the primary DFS order from roots first. Any phase left unvisited participates in a
        // primary-target cycle, so it receives a deterministic entity-order fallback below.
        uint32_t order = 0;
        for (auto phaseIdx: sortedPhases) {
          if (states[phaseIdx] == 0 && primaryPhases[phaseIdx] == UINT32_MAX) {
            system_schedule_visit_phase_children(phases, firstChildren, nextSiblings, states, phaseIdx, order);
          }
        }
 
        // Remaining phases are in a DependsOn cycle. The cycle is invalid, but the update stays deterministic.
        for (auto phaseIdx: sortedPhases) {
          if (states[phaseIdx] == 0) {
            phases[phaseIdx].order = order++;
            states[phaseIdx] = 2;
          }
        }
 
        auto& edges = scratch.edges;
        auto& childCounts = scratch.childCounts;
        auto& firstEdges = scratch.firstEdges;
        auto& readyNext = scratch.readyNext;
        auto& ordered = scratch.sortedIndices;
        auto& visited = scratch.visited;
 
        edges.clear();
        childCounts.clear();
        childCounts.resize(phases.size(), 0);
 
        // Build explicit phase edges from the actual DependsOn pairs. We count incoming children per
        // target so a phase becomes ready only after all phases depending on it have been emitted.
        for (uint32_t phaseIdx = 0; phaseIdx < phases.size(); ++phaseIdx) {
          world.targets(phases[phaseIdx].phase, DependsOn, [&](Entity target) {
            const auto targetIdx = system_schedule_find_phase(phases, target);
            if (targetIdx == UINT32_MAX || targetIdx == phaseIdx)
              return;
 
            SystemScheduleEdge edge{};
            edge.child = phaseIdx;
            edge.target = targetIdx;
            edges.push_back(edge);
            ++childCounts[targetIdx];
          });
        }
        if (edges.empty())
          return;
 
        // Link outgoing edges per child phase. This lets the ready-list pass touch only edges affected by
        // the phase it just emitted.
        firstEdges.clear();
        firstEdges.resize(phases.size(), UINT32_MAX);
        for (uint32_t edgeIdx = edges.size(); edgeIdx > 0; --edgeIdx) {
          auto& edge = edges[edgeIdx - 1];
          edge.next = firstEdges[edge.child];
          firstEdges[edge.child] = edgeIdx - 1;
        }
 
        auto phase_less = [&](uint32_t lhs, uint32_t rhs) {
          const auto& lhsPhase = phases[lhs];
          const auto& rhsPhase = phases[rhs];
          if (lhsPhase.order != rhsPhase.order)
            return lhsPhase.order < rhsPhase.order;
          if (lhsPhase.depth != rhsPhase.depth)
            return lhsPhase.depth > rhsPhase.depth;
          return entity_schedule_less(lhsPhase.phase, rhsPhase.phase);
        };
        auto ready_insert = [&](uint32_t& readyHead, uint32_t phaseIdx) {
          uint32_t* ppCurr = &readyHead;
          while (*ppCurr != UINT32_MAX && phase_less(*ppCurr, phaseIdx))
            ppCurr = &readyNext[*ppCurr];
          readyNext[phaseIdx] = *ppCurr;
          *ppCurr = phaseIdx;
        };
 
        readyNext.clear();
        readyNext.resize(phases.size(), UINT32_MAX);
 
        // Kahn pass in Gaia's scheduler direction: children run before their DependsOn targets. The
        // ordered ready list preserves the primary DFS order whenever several phases are unblocked.
        uint32_t readyHead = UINT32_MAX;
        for (auto phaseIdx: sortedPhases) {
          if (childCounts[phaseIdx] == 0)
            ready_insert(readyHead, phaseIdx);
        }
 
        ordered.clear();
        ordered.reserve(phases.size());
        while (readyHead != UINT32_MAX) {
          const auto phaseIdx = readyHead;
          readyHead = readyNext[readyHead];
          ordered.push_back(phaseIdx);
 
          for (uint32_t edgeIdx = firstEdges[phaseIdx]; edgeIdx != UINT32_MAX; edgeIdx = edges[edgeIdx].next) {
            const auto targetIdx = edges[edgeIdx].target;
            GAIA_ASSERT(childCounts[targetIdx] > 0);
            --childCounts[targetIdx];
            if (childCounts[targetIdx] == 0)
              ready_insert(readyHead, targetIdx);
          }
        }
 
        if (ordered.size() != phases.size()) {
          // A direct phase dependency cycle cannot be topologically sorted. Keep the acyclic prefix and
          // append the remaining phases in entity order so execution is still deterministic.
          visited.clear();
          visited.resize(phases.size(), 0);
          for (auto phaseIdx: ordered)
            visited[phaseIdx] = 1;
          for (auto phaseIdx: sortedPhases) {
            if (visited[phaseIdx] == 0)
              ordered.push_back(phaseIdx);
          }
        }
 
        for (uint32_t i = 0; i < ordered.size(); ++i)
          phases[ordered[i]].order = i;
      }
 
      inline void system_schedule_assign_order_keys(
          World& world, cnt::darray<SystemScheduleItem>& items, const cnt::darray<uint32_t>& entityIndices,
          SystemScheduleScratch& scratch) {
        auto& stack = scratch.entityStack;
        auto& phases = scratch.phases;
        auto& groupIndices = scratch.groupIndices;
 
        for (auto& item: items) {
          stack.clear();
          item.systemDepth = system_schedule_dep_depth(world, item.entity, item.phase, stack);
        }
 
        phases.clear();
        for (auto& item: items) {
          if (!item.hasPhase || system_schedule_find_phase(phases, item.phase) != UINT32_MAX)
            continue;
          SystemPhaseScheduleItem phaseItem{};
          phaseItem.phase = item.phase;
          stack.clear();
          phaseItem.depth = system_schedule_dep_depth(world, phaseItem.phase, EntityBad, stack);
          phases.push_back(phaseItem);
        }
 
        system_schedule_assign_phase_orders(world, phases, scratch);
        for (auto& item: items) {
          if (!item.hasPhase)
            continue;
          const auto phaseIdx = system_schedule_find_phase(phases, item.phase);
          if (phaseIdx == UINT32_MAX)
            continue;
          item.phaseOrder = phases[phaseIdx].order;
          item.phaseDepth = phases[phaseIdx].depth;
        }
 
        groupIndices.clear();
        groupIndices.reserve(items.size());
        for (uint32_t i = 0; i < items.size(); ++i) {
          if (!items[i].hasPhase)
            groupIndices.push_back(i);
        }
        if (!groupIndices.empty())
          system_schedule_assign_group_orders(world, items, groupIndices, entityIndices, scratch);
 
        for (auto& phase: phases) {
          groupIndices.clear();
          for (uint32_t i = 0; i < items.size(); ++i) {
            if (items[i].phase == phase.phase)
              groupIndices.push_back(i);
          }
          if (!groupIndices.empty())
            system_schedule_assign_group_orders(world, items, groupIndices, entityIndices, scratch);
        }
      }
 
      GAIA_NODISCARD inline bool system_schedule_less(const SystemScheduleItem& lhs, const SystemScheduleItem& rhs) {
        if (lhs.hasPhase != rhs.hasPhase)
          return lhs.hasPhase;
 
        if (lhs.hasPhase && lhs.phase != rhs.phase) {
          if (lhs.phaseOrder != rhs.phaseOrder)
            return lhs.phaseOrder < rhs.phaseOrder;
          if (lhs.phaseDepth != rhs.phaseDepth)
            return lhs.phaseDepth > rhs.phaseDepth;
          return entity_schedule_less(lhs.phase, rhs.phase);
        }
 
        if (lhs.systemOrder != rhs.systemOrder)
          return lhs.systemOrder < rhs.systemOrder;
        if (lhs.systemDepth != rhs.systemDepth)
          return lhs.systemDepth > rhs.systemDepth;
        return entity_schedule_less(lhs.entity, rhs.entity);
      }
 
      inline void system_schedule_add_edge(
          cnt::darray<SystemScheduleEdge>& edges, cnt::darray<uint32_t>& childCounts, uint32_t childIdx,
          uint32_t targetIdx) {
        SystemScheduleEdge edge{};
        edge.child = childIdx;
        edge.target = targetIdx;
        edges.push_back(edge);
        ++childCounts[targetIdx];
      }
 
      inline void system_schedule_build_edges(
          World& world, const cnt::darray<SystemScheduleItem>& items, const cnt::darray<uint32_t>& entityIndices,
          cnt::darray<SystemScheduleEdge>& edges, cnt::darray<uint32_t>& childCounts) {
        childCounts.resize(items.size(), 0);
        for (uint32_t childIdx = 0; childIdx < items.size(); ++childIdx) {
          const auto& child = items[childIdx];
          world.targets(child.entity, DependsOn, [&](Entity target) {
            if (target == child.phase)
              return;
            const auto targetIdx = system_schedule_find_item_by_entity(items, entityIndices, target);
            if (targetIdx == UINT32_MAX || targetIdx == childIdx)
              return;
            if (!system_schedule_same_group(child, items[targetIdx]))
              return;
 
            system_schedule_add_edge(edges, childCounts, childIdx, targetIdx);
          });
        }
      }
 
      inline void system_schedule_ready_insert(
          const cnt::darray<SystemScheduleItem>& items, cnt::darray<uint32_t>& readyNext, uint32_t& readyHead,
          uint32_t itemIdx) {
        uint32_t* ppCurr = &readyHead;
        while (*ppCurr != UINT32_MAX && system_schedule_less(items[*ppCurr], items[itemIdx]))
          ppCurr = &readyNext[*ppCurr];
        readyNext[itemIdx] = *ppCurr;
        *ppCurr = itemIdx;
      }
 
      inline void order_system_schedule_items(
          World& world, cnt::darray<SystemScheduleItem>& items, SystemScheduleScratch& scratch) {
        auto& entityIndices = scratch.entityIndices;
        auto& edges = scratch.edges;
        auto& childCounts = scratch.childCounts;
        auto& sortedIndices = scratch.sortedIndices;
        auto& firstEdges = scratch.firstEdges;
        auto& ordered = scratch.ordered;
        auto& visited = scratch.visited;
        auto& readyNext = scratch.readyNext;
 
        system_schedule_entity_indices(items, entityIndices);
        system_schedule_assign_order_keys(world, items, entityIndices, scratch);
 
        edges.clear();
        childCounts.clear();
        edges.reserve(items.size());
        system_schedule_build_edges(world, items, entityIndices, edges, childCounts);
        if (edges.empty()) {
          core::sort(items, [](const SystemScheduleItem& lhs, const SystemScheduleItem& rhs) {
            return system_schedule_less(lhs, rhs);
          });
          return;
        }
 
        sortedIndices.clear();
        sortedIndices.reserve(items.size());
        for (uint32_t i = 0; i < items.size(); ++i)
          sortedIndices.push_back(i);
        core::sort(sortedIndices, [&](uint32_t lhs, uint32_t rhs) {
          return system_schedule_less(items[lhs], items[rhs]);
        });
 
        firstEdges.clear();
        firstEdges.resize(items.size(), UINT32_MAX);
        for (uint32_t i = edges.size(); i > 0; --i) {
          auto& edge = edges[i - 1];
          edge.next = firstEdges[edge.child];
          firstEdges[edge.child] = i - 1;
        }
 
        ordered.clear();
        ordered.reserve(items.size());
 
        visited.clear();
        visited.resize(items.size(), 0);
        readyNext.clear();
        readyNext.resize(items.size(), UINT32_MAX);
 
        uint32_t readyHead = UINT32_MAX;
        for (uint32_t i = sortedIndices.size(); i > 0; --i) {
          const auto itemIdx = sortedIndices[i - 1];
          if (childCounts[itemIdx] == 0) {
            readyNext[itemIdx] = readyHead;
            readyHead = itemIdx;
          }
        }
 
        while (ordered.size() < items.size()) {
          uint32_t bestIdx = readyHead;
          if (bestIdx != UINT32_MAX)
            readyHead = readyNext[bestIdx];
          if (bestIdx == UINT32_MAX) {
            for (auto itemIdx: sortedIndices) {
              if (visited[itemIdx] == 0) {
                bestIdx = itemIdx;
                break;
              }
            }
          }
 
          GAIA_ASSERT(bestIdx != UINT32_MAX);
          if (bestIdx == UINT32_MAX)
            break;
 
          visited[bestIdx] = 1;
          ordered.push_back(items[bestIdx]);
 
          for (uint32_t edgeIdx = firstEdges[bestIdx]; edgeIdx != UINT32_MAX; edgeIdx = edges[edgeIdx].next) {
            const auto targetIdx = edges[edgeIdx].target;
            if (visited[targetIdx] != 0)
              continue;
            GAIA_ASSERT(childCounts[targetIdx] > 0);
            if (childCounts[targetIdx] > 0) {
              --childCounts[targetIdx];
              if (childCounts[targetIdx] == 0)
                system_schedule_ready_insert(items, readyNext, readyHead, targetIdx);
            }
          }
        }
 
        items = ordered;
      }
 
      GAIA_NODISCARD inline bool
      system_schedule_batch_changed(const SystemScheduleItem& lhs, const SystemScheduleItem& rhs) {
        if (lhs.hasPhase != rhs.hasPhase)
          return true;
        if (lhs.hasPhase)
          return lhs.phase != rhs.phase || lhs.systemDepth != rhs.systemDepth;
        return lhs.systemDepth != rhs.systemDepth;
      }
 
      GAIA_NODISCARD inline bool system_exec_uses_scheduler(QueryExecType type) {
        return type == QueryExecType::Parallel || type == QueryExecType::ParallelPerf ||
               type == QueryExecType::ParallelEff;
      }
 
      inline void run_system_entity_erased(void* pCtx, const SystemScheduleItem& item) {
        auto& ctx = *static_cast<SystemRunCtx*>(pCtx);
        GAIA_ASSERT(ctx.pWorld != nullptr);
        GAIA_ASSERT(ctx.pPending != nullptr);
        if (ctx.pWorld == nullptr || ctx.pPending == nullptr)
          return;
 
        auto& world = *ctx.pWorld;
        auto& pending = *ctx.pPending;
        const auto systemEntity = item.entity;
        if (!world.valid(systemEntity) || !world.has(systemEntity, System))
          return;
        if (!world.enabled_hierarchy(systemEntity, ChildOf))
          return;
 
        if (!ctx.hasCurrent) {
          ctx.current = item;
          ctx.hasCurrent = true;
        } else if (system_schedule_batch_changed(ctx.current, item)) {
          flush_pending_system_jobs(pending);
          ctx.current = item;
        }
 
        auto ss = world.acc_mut(systemEntity);
        auto& sys = ss.smut<ecs::System_>();
        if (!ctx.canScheduleSystems || !system_exec_uses_scheduler(sys.execType) || sys.query.main_thread_required()) {
          flush_pending_system_jobs(pending);
          sys.exec(world);
          return;
        }
 
        auto job = sys.job(world);
        if (!job.valid())
          return;
 
        for (auto& pendingJob: pending) {
          if (!world.valid(pendingJob.entity) || !world.has(pendingJob.entity, System))
            continue;
 
          auto prevSs = world.acc_mut(pendingJob.entity);
          auto& prevSys = prevSs.smut<ecs::System_>();
          if (!prevSys.query.can_run_parallel(sys.query))
            job.dep(pendingJob.job);
        }
 
        pending.emplace_back(systemEntity, GAIA_MOV(job));
      }
 
      inline void collect_system_schedule_item_erased(void* pCtx, Entity systemEntity) {
        auto& ctx = *static_cast<SystemCollectCtx*>(pCtx);
        GAIA_ASSERT(ctx.pWorld != nullptr);
        GAIA_ASSERT(ctx.pItems != nullptr);
        if (ctx.pWorld == nullptr || ctx.pItems == nullptr)
          return;
        ctx.pItems->push_back(system_schedule_item(*ctx.pWorld, systemEntity));
      }
 
      inline void collect_system_entity_erased(void* pCtx, Entity systemEntity) {
        auto& out = *static_cast<cnt::darray<Entity>*>(pCtx);
        out.push_back(systemEntity);
      }
    } // namespace detail
 
    inline void World::systems_init() {
      m_systemsQuery = query().all(System);
    }
 
    inline void World::systems_run() {
      if GAIA_UNLIKELY (tearing_down())
        return;
 
      auto& items = m_systemScheduleScratch.items;
      items.clear();
 
      detail::SystemCollectCtx collectCtx{};
      collectCtx.pWorld = this;
      collectCtx.pItems = &items;
      m_systemsQuery.each_entity_enabled(&collectCtx, detail::collect_system_schedule_item_erased);
      detail::order_system_schedule_items(*this, items, m_systemScheduleScratch);
 
      cnt::darray<detail::PendingSystemJob> pending;
      detail::SystemRunCtx ctx{};
      ctx.pWorld = this;
      ctx.pPending = &pending;
      ctx.canScheduleSystems = detail::sched_supports_deferred_system_jobs(world_sched(*this));
 
      for (auto& item: items)
        detail::run_system_entity_erased(&ctx, item);
      detail::flush_pending_system_jobs(pending);
    }
 
    inline void World::systems_done() {
      cnt::darray<Entity> tmpEntities;
      m_systemsQuery.each_entity_enabled(&tmpEntities, detail::collect_system_entity_erased);
 
      // Wait for every outstanding system job before mutating any system runtime state.
      // This keeps dependency chains intact while jobs are still live.
      for (auto entity: tmpEntities) {
        if (!valid(entity) || !has(entity, System))
          continue;
 
        auto ss = acc_mut(entity);
        auto& sys = ss.smut<ecs::System_>();
        if (sys.jobHandle != (mt::JobHandle)mt::JobNull_t{}) {
          auto& tp = mt::ThreadPool::get();
          tp.wait(sys.jobHandle);
        }
      }
 
      // With all system jobs complete we can release their runtime state safely.
      for (auto entity: tmpEntities) {
        if (!valid(entity) || !has(entity, System))
          continue;
 
        auto ss = acc_mut(entity);
        auto& sys = ss.smut<ecs::System_>();
        if (sys.jobHandle != (mt::JobHandle)mt::JobNull_t{}) {
          auto& tp = mt::ThreadPool::get();
          tp.del(sys.jobHandle);
          sys.jobHandle = mt::JobNull;
        }
        sys.query = {};
      }
 
      m_systemsQuery = {};
      tmpEntities.clear();
    }
 
    inline SystemBuilder World::system() {
      // Create the system
      auto e = add();
      EntityBuilder(*this, e) //
          .add<System_>();
 
      auto ss = acc_mut(e);
      auto& sys = ss.smut<System_>();
      auto& sysRuntime = systems().data_add(e);
      {
        sys.entity = e;
        sys.query = query();
        sysRuntime.on_each_func = {};
      }
      return SystemBuilder(*this, e);
    }
  } // namespace ecs
} // namespace gaia
#endif
 
namespace gaia {
  namespace ecs {
    inline uint32_t world_version(const World& world) {
      return world.m_worldVersion;
    }
 
    inline uint32_t world_archetype_delete_version(const World& world) {
      return world.m_archetypeDeleteVersion;
    }
 
    inline const Sched& world_sched(const World& world) {
      return world.sched();
    }
 
    inline void
    world_for_each_target(const World& world, Entity entity, Entity relation, void* ctx, void (*func)(void*, Entity)) {
      world.targets(entity, relation, [ctx, func](Entity target) {
        func(ctx, target);
      });
    }
 
    inline QueryMatchScratch& query_match_scratch_acquire(World& world) {
      if (world.m_queryMatchScratchDepth == world.m_queryMatchScratchStack.size())
        world.m_queryMatchScratchStack.push_back(new QueryMatchScratch());
 
      auto& scratch = *world.m_queryMatchScratchStack[world.m_queryMatchScratchDepth++];
      scratch.clear_temporary_matches();
      return scratch;
    }
 
    inline void query_match_scratch_release(World& world, bool keepStamps) {
      GAIA_ASSERT(world.m_queryMatchScratchDepth > 0);
      auto& scratch = *world.m_queryMatchScratchStack[--world.m_queryMatchScratchDepth];
      if (keepStamps)
        scratch.clear_temporary_matches_keep_stamps();
      else
        scratch.clear_temporary_matches();
    }
 
    GAIA_FORCEINLINE void world_invalidate_sorted_queries_for_entity(World& world, Entity entity) {
      // Sorting is rarely used; one predictable branch keeps the hot write path free of the
      // invalidation machinery for both serial and parallel writes.
      if GAIA_LIKELY (!world.has_sorted_queries())
        return;
 
      if (world.defer_sort_inv_active()) {
        // Only record entities a sorted query actually depends on, so the defer queue stays
        // empty for the common case where no component carried a sorted query.
        if (!world.has_sorted_queries_for_entity(entity))
          return;
        const auto slot = defer_slot();
        GAIA_ASSERT(slot != BadDeferSlot);
        world.defer_sort_inv_record(slot, entity);
        return;
      }
      world.invalidate_sorted_queries_for_entity(entity);
    }
 
    inline void world_invalidate_sorted_queries(World& world) {
      world.invalidate_sorted_queries();
    }
 
    inline void world_defer_sort_inv_begin(World& world, uint32_t slotCount) {
      world.defer_sort_inv_begin(slotCount);
    }
 
    inline void world_defer_sort_inv_end(World& world) {
      world.defer_sort_inv_end();
    }
 
    inline void world_defer_parallel_begin(World& world, uint32_t itemCount) {
#if GAIA_OBSERVERS_ENABLED
      world_defer_on_set_begin(world, itemCount);
#endif
      world_defer_sort_inv_begin(world, itemCount);
    }
 
    inline void world_defer_parallel_end(World& world) {
      world_defer_sort_inv_end(world);
#if GAIA_OBSERVERS_ENABLED
      world_defer_on_set_end(world);
#endif
    }
 
#if GAIA_OBSERVERS_ENABLED
    inline void world_defer_on_set_begin(World& world, uint32_t slotCount) {
      world.defer_on_set_begin(slotCount);
    }
 
    inline void world_defer_on_set_end(World& world) {
      world.defer_on_set_end();
    }
#endif
 
    inline bool world_has_entity_term(const World& world, Entity entity, Entity term) {
      if (term.pair() && term.id() == Is.id() && !is_wildcard(term.gen())) {
        const auto target = world.get(term.gen());
        return world.valid(target) && world.is(entity, target);
      }
 
      return world.has(entity, term);
    }
 
    inline bool world_has_entity_term_in(const World& world, Entity entity, Entity term) {
      if (term.pair() && term.id() == Is.id() && !is_wildcard(term.gen())) {
        const auto target = world.get(term.gen());
        return world.valid(target) && world.in(entity, target);
      }
 
      return false;
    }
 
    inline bool world_term_uses_inherit_policy(const World& world, Entity term) {
      return !is_wildcard(term) && world.valid(term) && world.target(term, OnInstantiate) == Inherit;
    }
 
    inline bool world_has_entity_term_direct(const World& world, Entity entity, Entity term) {
      return world.has_direct(entity, term);
    }
 
    inline bool world_relation_uses_non_fragmenting_storage(const World& world, Entity relation) {
      return world.relation_uses_non_fragmenting_storage(relation);
    }
 
    inline bool world_relation_is_non_fragmenting(const World& world, Entity relation) {
      return world.relation_is_non_fragmenting(relation);
    }
 
    inline bool world_component_uses_sparse_storage(const World& world, Entity component) {
      return world.component_uses_sparse_storage(component);
    }
 
    inline bool world_component_is_non_fragmenting(const World& world, Entity component) {
      return world.component_is_non_fragmenting(component);
    }
 
    inline uint32_t world_count_direct_term_entities(const World& world, Entity term) {
      return world.count_direct_term_entities(term);
    }
 
    inline uint32_t world_count_in_term_entities(const World& world, Entity term) {
      if (!term.pair() || term.id() != Is.id() || is_wildcard(term.gen()))
        return 0;
 
      const auto target = world.get(term.gen());
      return world.valid(target) ? (uint32_t)world.as_relations_trav_cache(target).size() : 0U;
    }
 
    inline uint32_t world_count_direct_term_entities_direct(const World& world, Entity term) {
      return world.count_direct_term_entities_direct(term);
    }
 
    inline void world_collect_direct_term_entities(const World& world, Entity term, cnt::darray<Entity>& out) {
      world.collect_direct_term_entities(term, out);
    }
 
    inline void world_collect_in_term_entities(const World& world, Entity term, cnt::darray<Entity>& out) {
      if (!term.pair() || term.id() != Is.id() || is_wildcard(term.gen()))
        return;
 
      const auto target = world.get(term.gen());
      if (!world.valid(target))
        return;
 
      const auto& relations = world.as_relations_trav_cache(target);
      out.reserve(out.size() + (uint32_t)relations.size());
      for (auto relation: relations)
        out.push_back(relation);
    }
 
    inline void world_collect_direct_term_entities_direct(const World& world, Entity term, cnt::darray<Entity>& out) {
      world.collect_direct_term_entities_direct(term, out);
    }
 
    inline bool
    world_for_each_direct_term_entity(const World& world, Entity term, void* ctx, bool (*func)(void*, Entity)) {
      return world.for_each_direct_term_entity(term, ctx, func);
    }
 
    inline bool world_for_each_in_term_entity(const World& world, Entity term, void* ctx, bool (*func)(void*, Entity)) {
      if (!term.pair() || term.id() != Is.id() || is_wildcard(term.gen()))
        return true;
 
      const auto target = world.get(term.gen());
      if (!world.valid(target))
        return true;
 
      for (auto relation: world.as_relations_trav_cache(target)) {
        if (!func(ctx, relation))
          return false;
      }
 
      return true;
    }
 
    inline bool
    world_for_each_direct_term_entity_direct(const World& world, Entity term, void* ctx, bool (*func)(void*, Entity)) {
      return world.for_each_direct_term_entity_direct(term, ctx, func);
    }
 
    inline bool world_entity_enabled(const World& world, Entity entity) {
      return world.enabled(entity);
    }
 
    inline Entity world_pair_target_if_alive(const World& world, Entity pair) {
      return world.pair_target_if_alive(pair);
    }
 
    inline bool world_entity_enabled_hierarchy(const World& world, Entity entity, Entity relation) {
      return world.enabled_hierarchy(entity, relation);
    }
 
    inline uint32_t world_enabled_hierarchy_version(const World& world) {
      return world.enabled_hierarchy_version();
    }
 
    inline bool world_relation_is_hierarchy(const World& world, Entity relation) {
      return world.relation_is_hierarchy(relation);
    }
 
    inline bool world_relation_is_fragmenting(const World& world, Entity relation) {
      return world.relation_is_fragmenting(relation);
    }
 
    inline bool world_relation_is_fragmenting_hierarchy(const World& world, Entity relation) {
      return world.relation_is_fragmenting_hierarchy(relation);
    }
 
    inline bool world_relation_supports_depth_order(const World& world, Entity relation) {
      return world.relation_supports_depth_order(relation);
    }
 
    inline bool world_relation_depth_order_prunes_disabled_subtrees(const World& world, Entity relation) {
      return world.relation_depth_order_prunes_disabled_subtrees(relation);
    }
 
    inline bool world_entity_prefab(const World& world, Entity entity) {
      const auto& ec = world.fetch(entity);
      return ec.pArchetype != nullptr && ec.pArchetype->has(Prefab);
    }
 
    inline Entity world_query_first_inherited_owner(const World& world, const Archetype& archetype, Entity term) {
      const auto& chunks = archetype.chunks();
      const Chunk* pFirstChunk = nullptr;
      for (const auto* pChunk: chunks) {
        if (pChunk == nullptr || pChunk->size() == 0)
          continue;
        pFirstChunk = pChunk;
        break;
      }
 
      if (pFirstChunk == nullptr)
        return EntityBad;
 
      const auto firstEntity = pFirstChunk->entity_view()[0];
      for (const auto target: world.as_targets_trav_cache(firstEntity)) {
        if (!world.has_direct(target, term))
          continue;
        return target;
      }
 
      return EntityBad;
    }
 
    inline const Archetype* world_entity_archetype(const World& world, Entity entity) {
      return world.fetch(entity).pArchetype;
    }
 
    inline uint32_t world_component_index_bucket_size(const World& world, Entity term) {
      const auto it = world.m_entityToArchetypeMap.find(EntityLookupKey(term));
      if (it == world.m_entityToArchetypeMap.end())
        return 0;
 
      return (uint32_t)it->second.size();
    }
 
    inline uint32_t world_component_index_comp_idx(const World& world, const Archetype& archetype, Entity term) {
      if (is_wildcard(term))
        return BadIndex;
 
      const auto it = world.m_entityToArchetypeMap.find(EntityLookupKey(term));
      if (it == world.m_entityToArchetypeMap.end())
        return BadIndex;
 
      const auto idx = core::get_index_if(it->second, [&](const auto& entry) {
        return entry.matches(&archetype);
      });
      if (idx == BadIndex)
        return BadIndex;
 
      return it->second[idx].compIdx;
    }
 
    inline uint32_t world_component_index_match_count(const World& world, const Archetype& archetype, Entity term) {
      const auto it = world.m_entityToArchetypeMap.find(EntityLookupKey(term));
      if (it == world.m_entityToArchetypeMap.end())
        return 0;
 
      const auto idx = core::get_index_if(it->second, [&](const auto& entry) {
        return entry.matches(&archetype);
      });
      if (idx == BadIndex)
        return 0;
 
      return it->second[idx].matchCount;
    }
 
    template <typename T>
    inline const std::remove_cv_t<std::remove_reference_t<T>>*
    world_query_inherited_arg_data_const(World& world, Entity owner, Entity id) {
      using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
      return &world.template get<Arg>(owner, id);
    }
 
    inline const void* world_query_inherited_arg_data_const_ptr(const World& world, Entity owner, Entity id) {
      const auto& ec = world.fetch(owner);
      const auto row = id.kind() == EntityKind::EK_Gen ? ec.row : 0;
      return ec.pChunk->comp_ptr(ec.pChunk->comp_idx(id), row);
    }
 
    template <typename T>
    inline decltype(auto) world_direct_entity_arg(World& world, Entity entity) {
      using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
      if constexpr (std::is_same_v<Arg, Entity>)
        return entity;
      else if constexpr (std::is_lvalue_reference_v<T> && !std::is_const_v<std::remove_reference_t<T>>)
        return world.template mut_im<Arg>(entity);
      else
        return world.template get<Arg>(entity);
    }
 
    template <typename T>
    inline decltype(auto) world_direct_entity_arg_raw(World& world, Entity entity) {
      using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
      if constexpr (std::is_same_v<Arg, Entity>)
        return entity;
      else if constexpr (std::is_lvalue_reference_v<T> && !std::is_const_v<std::remove_reference_t<T>>)
        return world.template mut<Arg>(entity);
      else
        return world.template get<Arg>(entity);
    }
 
    template <typename T>
    inline void* world_typed_sparse_store_ptr(World& world, Entity component) {
      return &world.template sparse_component_store_mut<T>(component);
    }
 
    template <typename T>
    inline const T& world_typed_sparse_store_get(const void* pStore, Entity entity) {
      return static_cast<const detail::SparseComponentStore<T>*>(pStore)->get(entity);
    }
 
    template <typename T>
    inline T& world_typed_sparse_store_mut(void* pStore, Entity entity) {
      return static_cast<detail::SparseComponentStore<T>*>(pStore)->mut(entity);
    }
 
    template <typename T>
    inline bool world_typed_sparse_store_has(const void* pStore, Entity entity) {
      return static_cast<const detail::SparseComponentStore<T>*>(pStore)->has(entity);
    }
 
    template <typename T>
    inline Entity world_query_arg_id(World& world) {
      using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
      using FT = typename component_type_t<Arg>::TypeFull;
      if constexpr (is_pair<FT>::value) {
        const auto rel = comp_cache(world).template get<typename FT::rel>().entity;
        const auto tgt = comp_cache(world).template get<typename FT::tgt>().entity;
        return (Entity)Pair(rel, tgt);
      } else
        return comp_cache(world).template get<FT>().entity;
    }
 
    template <typename T>
    inline decltype(auto) world_query_entity_arg(World& world, Entity entity) {
      using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
      if constexpr (std::is_same_v<Arg, Entity>)
        return entity;
      else {
        const auto id = world_query_arg_id<Arg>(world);
        return world_query_entity_arg_by_id<T>(world, entity, id);
      }
    }
 
    template <typename T>
    inline decltype(auto) world_query_entity_arg_by_id(World& world, Entity entity, Entity id) {
      using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
      if constexpr (std::is_same_v<Arg, Entity>)
        return entity;
      const auto termId = id != EntityBad ? id : world_query_arg_id<Arg>(world);
      if constexpr (std::is_lvalue_reference_v<T> && !std::is_const_v<std::remove_reference_t<T>>) {
        if (!world.has_direct(entity, termId)) {
          if constexpr (is_pair<Arg>::value)
            (void)world.override(entity, termId);
          else
            (void)world.template override<Arg>(entity, termId);
        }
 
        return world.template mut_im<Arg>(entity, termId);
      } else
        return world.template get<Arg>(entity, termId);
    }
 
    template <typename T>
    inline decltype(auto) world_query_entity_arg_by_id_raw(World& world, Entity entity, Entity id) {
      using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
      if constexpr (std::is_same_v<Arg, Entity>)
        return entity;
 
      const auto termId = id != EntityBad ? id : world_query_arg_id<Arg>(world);
      if constexpr (std::is_lvalue_reference_v<T> && !std::is_const_v<std::remove_reference_t<T>>) {
        if (!world.has_direct(entity, termId)) {
          if constexpr (is_pair<Arg>::value)
            (void)world.override(entity, termId);
          else
            (void)world.template override<Arg>(entity, termId);
        }
 
        return world.template mut<Arg>(entity, termId);
      } else
        return world.template get<Arg>(entity, termId);
    }
 
    template <typename T>
    inline void world_init_query_entity_arg_by_id_chunk_stable_const(
        World& world, const Chunk& chunk, const Entity* pEntities, Entity id, bool& direct, uint32_t& compIdx,
        const std::remove_cv_t<std::remove_reference_t<T>>*& pDataInherited) {
      using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
      if constexpr (std::is_same_v<Arg, Entity>) {
        direct = false;
        compIdx = BadIndex;
        pDataInherited = nullptr;
        return;
      }
 
      const auto termId = id != EntityBad ? id : world_query_arg_id<Arg>(world);
      direct = chunk.has(termId);
      compIdx = BadIndex;
      pDataInherited = nullptr;
 
      if (direct) {
        compIdx = chunk.comp_idx(termId);
        GAIA_ASSERT(compIdx != BadIndex);
        return;
      }
 
      auto owner = EntityBad;
      const auto firstEntity = pEntities[0];
      for (const auto target: world.as_targets_trav_cache(firstEntity)) {
        if (!world.has_direct(target, termId))
          continue;
 
        owner = target;
        break;
      }
 
      GAIA_ASSERT(owner != EntityBad);
      pDataInherited = &world.template get<Arg>(owner, termId);
    }
 
    template <typename T>
    inline decltype(auto) world_query_entity_arg_by_id_cached_const(
        World& world, Entity entity, Entity id, const Archetype*& pLastArchetype, Entity& cachedOwner,
        bool& cachedDirect) {
      using Arg = std::remove_cv_t<std::remove_reference_t<T>>;
      if constexpr (std::is_same_v<Arg, Entity>)
        return entity;
 
      const auto termId = id != EntityBad ? id : world_query_arg_id<Arg>(world);
      const auto& ec = world.fetch(entity);
      if (ec.pArchetype != pLastArchetype) {
        pLastArchetype = ec.pArchetype;
        cachedDirect = ec.pArchetype->has(termId);
        cachedOwner = EntityBad;
 
        if (!cachedDirect) {
          for (const auto target: world.as_targets_trav_cache(entity)) {
            if (!world.has_direct(target, termId))
              continue;
 
            cachedOwner = target;
            break;
          }
 
          GAIA_ASSERT(cachedOwner != EntityBad);
        }
      }
 
      if (cachedDirect)
        return ComponentGetter{world, ec.pChunk, entity, ec.row}.template get<Arg>(termId);
 
      return world.template get<Arg>(cachedOwner, termId);
    }
 
    inline void world_notify_on_set(World& world, Entity term, Chunk& chunk, uint16_t from, uint16_t to) {
#if GAIA_OBSERVERS_ENABLED
      if (world.tearing_down())
        return;
      if (!world.observers().has_on_set_observers(term))
        return;
 
      auto entities = chunk.entity_view();
      if (from >= entities.size())
        return;
      if (to > entities.size())
        to = (uint16_t)entities.size();
      if (from >= to)
        return;
 
      // Observer dispatch mutates world-owned state and runs user code. Neither is safe from a
      // worker thread, so inside a deferring region the notification is only recorded here and
      // the coordinator dispatches it after the region joins.
      if (world.defer_on_set_active()) {
        const auto slot = defer_slot();
        GAIA_ASSERT(slot != BadDeferSlot);
        for (uint32_t row = from; row < to; ++row)
          world.defer_on_set_record(slot, term, entities[row]);
        return;
      }
 
      world.observers().on_set(world, term, EntitySpan{entities.data() + from, uint32_t(to - from)});
#else
      (void)world;
      (void)term;
      (void)chunk;
      (void)from;
      (void)to;
#endif
    }
 
    //----------------------------------------------------------------------
 
    inline ComponentRawView ComponentGetter::get_raw(Entity component) const {
      GAIA_ASSERT(m_pWorld != nullptr);
      GAIA_ASSERT(m_entity != EntityBad);
      return m_pWorld->get_raw(m_entity, component);
    }
 
    inline ComponentRawView ComponentGetter::get_raw_field(Entity component, uint32_t fieldIdx) const {
      GAIA_ASSERT(m_pWorld != nullptr);
      GAIA_ASSERT(m_entity != EntityBad);
      return m_pWorld->get_raw_field(m_entity, component, fieldIdx);
    }
 
    inline ComponentRawMutView ComponentSetter::mut_raw(Entity component) {
      GAIA_ASSERT(m_pWorld != nullptr);
      GAIA_ASSERT(m_entity != EntityBad);
      return const_cast<World*>(m_pWorld)->mut_raw(m_entity, component);
    }
 
    inline ComponentRawMutView ComponentSetter::mut_raw_field(Entity component, uint32_t fieldIdx) {
      GAIA_ASSERT(m_pWorld != nullptr);
      GAIA_ASSERT(m_entity != EntityBad);
      return const_cast<World*>(m_pWorld)->mut_raw_field(m_entity, component, fieldIdx);
    }
 
    inline ComponentSetter& ComponentSetter::set_raw(Entity component, const void* data, uint32_t size) {
      GAIA_ASSERT(m_pWorld != nullptr);
      GAIA_ASSERT(m_entity != EntityBad);
      const auto ok = const_cast<World*>(m_pWorld)->set_raw(m_entity, component, data, size);
      GAIA_ASSERT(ok);
      (void)ok;
      return *this;
    }
 
    inline ComponentSetter& ComponentSetter::modify_raw(Entity component) {
      GAIA_ASSERT(m_pWorld != nullptr);
      GAIA_ASSERT(m_entity != EntityBad);
      const_cast<World*>(m_pWorld)->modify_raw(m_entity, component);
      return *this;
    }
 
    template <typename T>
    GAIA_NODISCARD decltype(auto) ComponentGetter::get(Entity type) const {
      GAIA_ASSERT(m_pWorld != nullptr);
      GAIA_ASSERT(m_entity != EntityBad);
 
      using FT = typename component_type_t<T>::TypeFull;
      if constexpr (World::template supports_sparse_component_storage<FT>()) {
        if (m_pWorld->template can_use_sparse_component_storage<FT>(type)) {
          return m_pWorld->template sparse_component_get_value<FT>(type, m_entity);
        }
      }
 
      const auto row = (uint16_t)(m_row * (actual_type_t<T>::Kind == EntityKind::EK_Gen));
      return m_pChunk->template get<T>(row, type);
    }
 
    template <typename T>
    decltype(auto) ComponentSetter::mut(Entity type) {
      return smut<T>(type);
    }
 
    template <typename T>
    decltype(auto) ComponentSetter::smut(Entity type) {
      GAIA_ASSERT(m_pWorld != nullptr);
      GAIA_ASSERT(m_entity != EntityBad);
 
      using FT = typename component_type_t<T>::TypeFull;
      if constexpr (World::template supports_sparse_component_storage<FT>()) {
        auto& world = *const_cast<World*>(m_pWorld);
        if (world.template can_use_sparse_component_storage<FT>(type))
          return world.template sparse_component_mut_value<FT>(type, m_entity);
      }
 
      const auto row = (uint16_t)(m_row * (actual_type_t<T>::Kind == EntityKind::EK_Gen));
      return const_cast<Chunk*>(m_pChunk)->template sset<T>(row, type);
    }
 
    template <typename T>
    ComponentSetter& ComponentSetter::sset(Entity type, T&& value) {
      smut<T>(type) = GAIA_FWD(value);
      return *this;
    }
 
    template <typename T>
    ComponentSetter& ComponentSetter::set(Entity type, T&& value) {
      GAIA_ASSERT(m_pWorld != nullptr);
      GAIA_ASSERT(m_entity != EntityBad);
 
      smut<T>(type) = GAIA_FWD(value);
      using FT = typename component_type_t<T>::TypeFull;
      auto& world = *const_cast<World*>(m_pWorld);
 
      if constexpr (World::template supports_sparse_component_storage<FT>()) {
        if (world.template can_use_sparse_component_storage<FT>(type))
          ::gaia::ecs::update_version(world.m_worldVersion);
      }
 
      world.finish_write(m_entity, type);
      return *this;
    }
 
    //----------------------------------------------------------------------
 
    inline void world_notify_on_set_entity(World& world, Entity term, Entity entity) {
#if GAIA_OBSERVERS_ENABLED
      if (world.tearing_down())
        return;
      if (!world.valid(entity))
        return;
      if (!world.observers().has_on_set_observers(term))
        return;
 
      // See world_notify_on_set(): inside a deferring region the notification is recorded and
      // dispatched by the coordinator once the region joins.
      if (world.defer_on_set_active()) {
        const auto slot = defer_slot();
        GAIA_ASSERT(slot != BadDeferSlot);
        world.defer_on_set_record(slot, term, entity);
        return;
      }
 
      world.observers().on_set(world, term, EntitySpan{&entity, 1});
#else
      (void)world;
      (void)term;
      (void)entity;
#endif
    }
 
    inline void world_finish_write(World& world, Entity term, Entity entity) {
      world.finish_write(entity, term);
    }
 
  } // namespace ecs
} // namespace gaia
 
namespace gaia {
  namespace ecs {
    inline uint32_t world_rel_version(const World& world, Entity relation) {
      return world.rel_version(relation);
    }
 
    inline uint32_t world_entity_archetype_version(const World& world, Entity entity) {
      if (!world.valid(entity))
        return 0;
 
      const auto key = EntityLookupKey(entity);
      auto it = world.m_srcEntityVersions.find(key);
      if (it != world.m_srcEntityVersions.end())
        return it->second;
 
      it = world.m_srcEntityVersions.try_emplace(key, 1).first;
      return it->second;
    }
  } // namespace ecs
} // namespace gaia
 
#if GAIA_OBSERVERS_ENABLED
namespace gaia {
  namespace ecs {
    inline ObserverBuilder World::observer() {
      // Create the observer
      auto e = add();
      EntityBuilder(*this, e) //
          .add<Observer_>();
 
      auto ss = acc_mut(e);
      auto& hdr = ss.smut<Observer_>();
      auto& obs = observers().data_add(e);
      {
        hdr.entity = e;
        obs.entity = e;
        obs.query = query();
      }
      return ObserverBuilder(*this, e);
    }
  } // namespace ecs
} // namespace gaia
#endif