diff --git a/Include/Misc/PipeDebug.h b/Include/Misc/PipeDebug.h
index 4a9e9fa5..6cf49c36 100644
--- a/Include/Misc/PipeDebug.h
+++ b/Include/Misc/PipeDebug.h
@@ -176,14 +176,14 @@ namespace p
 		DebugECSContext ecs;
 		DebugReflectContext reflect;
 
-		EntityContext* ctx = nullptr;
+		IdContext* ctx = nullptr;
 
 		bool initialized  = false;
 		bool isFirstDebug = true;
 
 
 		DebugContext() = default;
-		DebugContext(EntityContext& ctx) : ctx{&ctx} {}
+		DebugContext(IdContext& ctx) : ctx{&ctx} {}
 	};
 
 	bool BeginDebug(DebugContext& Context);
@@ -221,7 +221,7 @@ namespace p
 
 
 	// For internal use only
-	EntityContext& GetDebugCtx()
+	IdContext& GetDebugCtx()
 	{
 		return *currentContext->ctx;
 	}
@@ -552,7 +552,7 @@ namespace p
 	#pragma region ECS
 	i32 DebugECSInspector::uniqueIdCounter = 0;
 
-	using DrawNodeAccess = TAccessRef<CParent, CChild>;
+	using DrawNodeAccess = TIdScopeRef<CParent, CChild>;
 	namespace details
 	{
 		bool ChooseTypePopup(const char* label, ImGuiTextFilter& filter, TypeId& selectedTypeId)
@@ -1282,7 +1282,7 @@ namespace p
 			return false;
 		}
 
-		if (!P_EnsureMsg(context.ctx, "Debug Context does not contain a valid EntityContext."))
+		if (!P_EnsureMsg(context.ctx, "Debug Context does not contain a valid IdContext."))
 		{
 			return false;
 		}
diff --git a/Include/Pipe/Core/EnumFlags.h b/Include/Pipe/Core/EnumFlags.h
index 04a8e358..e0c01399 100644
--- a/Include/Pipe/Core/EnumFlags.h
+++ b/Include/Pipe/Core/EnumFlags.h
@@ -7,73 +7,91 @@
 
 namespace p
 {
+	template<Integral I>
+	constexpr bool HasAllFlags(I value, I flags) noexcept
+	{
+		return (value & flags) == flags;
+	}
+
+	template<Integral I>
+	constexpr bool HasAnyFlags(I value, I flags) noexcept
+	{
+		return (value & flags) != 0;
+	}
+
+	template<Integral I>
+	constexpr bool HasFlag(I value, I flag) noexcept
+	{
+		return HasAllFlags(value, flag);
+	}
+
 	namespace EnumOperators
 	{
 		// Bitwise operators: ~, |, &, ^, |=, &=, ^=
 		using namespace magic_enum::bitwise_operators;
 
-		template<typename E>
-		constexpr UnderlyingType<E> operator*(E value) noexcept requires(IsEnum<E>)
+		template<IsEnum E>
+		constexpr UnderlyingType<E> operator*(E value) noexcept
 		{
 			return static_cast<UnderlyingType<E>>(value);
 		}
 
-		template<typename E>
-		constexpr E operator|(E lhs, E rhs) noexcept requires(IsEnum<E>)
+		template<IsEnum E>
+		constexpr E operator|(E lhs, E rhs) noexcept
 		{
 			return static_cast<E>(
 			    static_cast<UnderlyingType<E>>(lhs) | static_cast<UnderlyingType<E>>(rhs));
 		}
 	}    // namespace EnumOperators
 
-	template<typename E>
-	constexpr bool HasAllFlags(E value, E flags) noexcept requires(IsEnum<E>)
+	template<IsEnum E>
+	constexpr bool HasAllFlags(E value, E flags) noexcept
 	{
 		return (static_cast<UnderlyingType<E>>(value) & static_cast<UnderlyingType<E>>(flags))
 		    == static_cast<UnderlyingType<E>>(flags);
 	}
 
-	template<typename E>
-	constexpr bool HasAnyFlags(E value, E flags) noexcept requires(IsEnum<E>)
+	template<IsEnum E>
+	constexpr bool HasAnyFlags(E value, E flags) noexcept
 	{
 		return (static_cast<UnderlyingType<E>>(value) & static_cast<UnderlyingType<E>>(flags)) != 0;
 	}
 
-	template<typename E, typename R = UnderlyingType<E>>
-	constexpr bool HasAllFlags(R value, E flags) noexcept requires(IsEnum<E>)
+	template<IsEnum E, typename R = UnderlyingType<E>>
+	constexpr bool HasAllFlags(R value, E flags) noexcept
 	{
 		return (static_cast<R>(value) & static_cast<UnderlyingType<E>>(flags))
 		    == static_cast<UnderlyingType<E>>(flags);
 	}
 
-	template<typename E, typename R = UnderlyingType<E>>
-	constexpr bool HasAnyFlags(R value, E flags) noexcept requires(IsEnum<E>)
+	template<IsEnum E, typename R = UnderlyingType<E>>
+	constexpr bool HasAnyFlags(R value, E flags) noexcept
 	{
 		return (static_cast<R>(value) & static_cast<UnderlyingType<E>>(flags)) != 0;
 	}
 
-	template<typename E>
-	constexpr bool HasFlag(E value, E flag) noexcept requires(IsEnum<E>)
+	template<IsEnum E>
+	constexpr bool HasFlag(E value, E flag) noexcept
 	{
 		return HasAllFlags(value, flag);
 	}
 
-	template<typename E, typename R = UnderlyingType<E>>
-	constexpr bool HasFlag(R value, E flag) noexcept requires(IsEnum<E>)
+	template<IsEnum E, typename R = UnderlyingType<E>>
+	constexpr bool HasFlag(R value, E flag) noexcept
 	{
 		return HasAllFlags(value, flag);
 	}
 
-	template<typename E>
-	void AddFlags(E& value, E flags) noexcept requires(IsEnum<E>)
+	template<IsEnum E>
+	void AddFlags(E& value, E flags) noexcept
 	{
 		auto rawValue = static_cast<UnderlyingType<E>>(value);
 		rawValue |= static_cast<UnderlyingType<E>>(flags);
 		value = static_cast<E>(rawValue);
 	}
 
-	template<typename E>
-	void RemoveFlags(E& value, E flags) noexcept requires(IsEnum<E>)
+	template<IsEnum E>
+	void RemoveFlags(E& value, E flags) noexcept
 	{
 		auto rawValue = static_cast<UnderlyingType<E>>(value);
 		rawValue &= ~static_cast<UnderlyingType<E>>(flags);
diff --git a/Include/Pipe/Core/Templates.h b/Include/Pipe/Core/Templates.h
index a67f6fb9..2cf537d1 100644
--- a/Include/Pipe/Core/Templates.h
+++ b/Include/Pipe/Core/Templates.h
@@ -11,85 +11,6 @@
 
 namespace p
 {
-	template<typename... Type>
-	struct TTypeList
-	{
-		using type = TTypeList;
-
-		static constexpr auto size = sizeof...(Type);
-	};
-
-	template<typename... Type, typename... Other>
-	constexpr TTypeList<Type..., Other...> operator+(TTypeList<Type...>, TTypeList<Other...>)
-	{
-		return {};
-	}
-
-	template<std::size_t, typename>
-	struct TTypeListIterator;
-
-	template<std::size_t index, typename Type, typename... Other>
-	struct TTypeListIterator<index, TTypeList<Type, Other...>>
-	    : TTypeListIterator<index - 1u, TTypeList<Other...>>
-	{};
-
-	template<typename Type, typename... Other>
-	struct TTypeListIterator<0u, TTypeList<Type, Other...>>
-	{
-		/*! @brief Searched type. */
-		using type = Type;
-	};
-
-	template<typename... T>
-	struct TJoinList;
-
-	template<typename... ATypes, typename... BTypes>
-	struct TJoinList<TTypeList<ATypes...>, TTypeList<BTypes...>>
-	{
-		using Type = TTypeList<ATypes..., BTypes...>;
-	};
-
-	template<typename... ATypes, typename... BTypes>
-	struct TJoinList<TTypeList<ATypes...>, BTypes...>
-	{
-		using Type = TTypeList<ATypes..., BTypes...>;
-	};
-
-	template<typename... T>
-	using JoinList = TJoinList<T...>;
-
-
-	/**
-	 * @brief Helper type.
-	 * @tparam Index Index of the type to return.
-	 * @tparam List Type list to search into.
-	 */
-	template<std::size_t index, typename List>
-	using TTypeListIndex = typename TTypeListIterator<index, List>::type;
-
-
-	namespace Internal
-	{
-		template<typename T, typename List>
-		struct TTypeListContains;
-
-		template<typename T, typename... Us>
-		struct TTypeListContains<T, const TTypeList<Us...>>
-		    : std::disjunction<std::is_same<T, Us>...>
-		{};
-
-		template<typename T, typename... Us>
-		struct TTypeListContains<T, TTypeList<Us...>> : std::disjunction<std::is_same<T, Us>...>
-		{};
-	}    // namespace Internal
-
-	template<typename List, typename T>
-	constexpr bool ListContains()
-	{
-		return Internal::TTypeListContains<T, List>::value;
-	}
-
-
 	template<typename T1, typename T2>
 	struct TPair
 	{
@@ -198,7 +119,7 @@ namespace p
 	using TTuple = std::tuple<T...>;
 
 
-	namespace Internal
+	namespace Detail
 	{
 		template<typename T, typename Tuple>
 		struct TTupleContains;
@@ -210,11 +131,209 @@ namespace p
 		template<typename T, typename... Us>
 		struct TTupleContains<T, TTuple<Us...>> : std::disjunction<std::is_same<T, Us>...>
 		{};
-	}    // namespace Internal
+	}    // namespace Detail
 
 	template<typename Tuple, typename T>
 	constexpr bool TupleContains()
 	{
-		return Internal::TTupleContains<T, Tuple>::value;
+		return Detail::TTupleContains<T, Tuple>::value;
+	}
+
+
+	template<typename... T>
+	struct TTypeList;
+
+	namespace Detail
+	{
+		template<typename T>
+		struct TIsTypeList : FalseType
+		{};
+		template<typename... T>
+		struct TIsTypeList<TTypeList<T...>> : TrueType
+		{};
+
+		template<typename ResultList, typename... Remaining>
+		struct TTypeListUnique
+		{
+			using Type = ResultList;
+		};
+
+		template<typename ResultList, typename First, typename... Rest>
+		struct TTypeListUnique<ResultList, First, Rest...>
+		{
+			using NextList = Select<ResultList::template Contains<First>(), ResultList,
+			    typename ResultList::template Append<First>>;
+			using Type     = typename TTypeListUnique<NextList, Rest...>::Type;
+		};
+
+		template<typename List, template<typename> typename Predicate>
+		struct TFilter;
+
+		template<template<typename> typename Predicate>
+		struct TFilter<TTypeList<>, Predicate>
+		{
+			using Type = TTypeList<>;    // Empty result
+		};
+
+		template<typename Head, typename... Tail, template<typename> typename Predicate>
+		struct TFilter<TTypeList<Head, Tail...>, Predicate>
+		{
+			// Filter the remaining types (Tail...)
+			using FilteredTail = typename TFilter<TTypeList<Tail...>, Predicate>::Type;
+			// Include Head if predicate is true; otherwise, use FilteredTail directly
+			using Type = Select<Predicate<Head>::value,
+			    typename FilteredTail::template Prepend<Head>,    // Prepend Head to FilteredTail
+			    FilteredTail                                      // Skip Head
+			    >;
+		};
+	};    // namespace Detail
+
+
+	template<typename T>
+	concept IsTypeList = Detail::TIsTypeList<T>::value;
+
+
+	template<typename... T>
+	struct TTypeList
+	{
+		using type = TTypeList;
+
+		static constexpr auto size = sizeof...(T);
+
+
+		template<typename U>
+		static consteval bool Contains()
+		{
+			return (std::is_same_v<T, U> || ...);
+		}
+
+	private:
+		template<typename... S>
+		struct TAppend
+		{
+			using Type = TTypeList<T..., S...>;
+		};
+		template<typename... S>
+		struct TAppend<TTypeList<S...>>
+		{
+			using Type = TTypeList<T..., S...>;
+		};
+		template<typename... S>
+		struct TPrepend
+		{
+			using Type = TTypeList<S..., T...>;
+		};
+		template<typename... S>
+		struct TPrepend<TTypeList<S...>>
+		{
+			using Type = TTypeList<S..., T...>;
+		};
+
+		template<typename... S>
+		struct TAppendUnique : public Detail::TTypeListUnique<TTypeList<T...>, S...>
+		{};
+		template<typename... S>
+		struct TAppendUnique<TTypeList<S...>>
+		    : public Detail::TTypeListUnique<TTypeList<T...>, S...>
+		{};
+
+		template<typename... S>
+		struct TPrependUnique : public Detail::TTypeListUnique<TTypeList<S...>, T...>
+		{};
+		template<typename... S>
+		struct TPrependUnique<TTypeList<S...>>
+		    : public Detail::TTypeListUnique<TTypeList<S...>, T...>
+		{};
+
+		template<typename... Args>
+		struct TFirst : TypeIdentity<void>
+		{};
+		template<typename First, typename... Rest>
+		struct TFirst<First, Rest...> : TypeIdentity<First>
+		{};
+
+
+	public:
+		template<template<typename> class W>
+		using Wrap = TTypeList<W<T>...>;
+
+		template<template<typename> class W>
+		using WrapPtr = TTypeList<W<T>*...>;
+
+		template<template<typename> class W>
+		using WrapConstPtr = TTypeList<const W<T>*...>;
+
+		template<template<typename> class W>
+		using WrapRef = TTypeList<W<T>&...>;
+
+		template<template<typename> class W>
+		using WrapConstRef = TTypeList<const W<T>&...>;
+
+		template<template<typename> class M>
+		using Map = TTypeList<typename M<T>::Type...>;
+
+		template<typename... S>
+		using Append = TAppend<S...>::Type;
+
+		template<typename... S>
+		using Prepend = TPrepend<S...>::Type;
+
+		template<typename... S>
+		using AppendUnique = TAppendUnique<S...>::Type;
+
+		template<typename... S>
+		using PrependUnique = TPrependUnique<S...>::Type;
+
+		using Deduplicate = typename Detail::template TTypeListUnique<TTypeList<>, T...>::Type;
+
+		// Conversion
+		template<template<typename...> class U>
+		using To = U<T...>;
+
+		template<typename Default = void>
+		using First = typename TFirst<Default>::Type;
+
+		template<template<typename> typename Predicate>
+		using Filter = Detail::TFilter<TTypeList<T...>, Predicate>::Type;
+
+		static constexpr auto Call(auto predicate)
+		{
+			return predicate.template operator()<T...>();
+		}
+		static constexpr void ForEach(auto predicate)
+		{
+			(predicate.template operator()<T>(), ...);
+		}
+	};
+
+	template<typename... T, typename... Other>
+	constexpr TTypeList<T..., Other...> operator+(TTypeList<T...>, TTypeList<Other...>)
+	{
+		return {};
 	}
+
+
+	template<std::size_t, typename>
+	struct TTypeListIterator;
+
+	template<std::size_t index, typename T, typename... Other>
+	struct TTypeListIterator<index, TTypeList<T, Other...>>
+	    : TTypeListIterator<index - 1u, TTypeList<Other...>>
+	{};
+
+	template<typename T, typename... Other>
+	struct TTypeListIterator<0u, TTypeList<T, Other...>>
+	{
+		/*! @brief Searched type. */
+		using Type = T;
+	};
+
+
+	/**
+	 * @brief Helper type.
+	 * @tparam Index Index of the type to return.
+	 * @tparam List Type list to search into.
+	 */
+	template<std::size_t index, typename List>
+	using TTypeListIndex = typename TTypeListIterator<index, List>::Type;
 }    // namespace p
diff --git a/Include/Pipe/Core/TypeTraits.h b/Include/Pipe/Core/TypeTraits.h
index 52ec43fa..3cbafb2f 100644
--- a/Include/Pipe/Core/TypeTraits.h
+++ b/Include/Pipe/Core/TypeTraits.h
@@ -9,41 +9,61 @@
 
 namespace p
 {
+	template<class T>
+	struct TypeIdentity
+	{
+		using Type = T;
+	};
+
+	template<typename T, T v>
+	struct Constant
+	{
+		static constexpr T value = v;
+		using ValueType          = T;
+		using Type               = Constant;
+		constexpr operator T() const noexcept
+		{
+			return value;
+		}
+	};
+	using TrueType  = Constant<bool, true>;
+	using FalseType = Constant<bool, false>;
+
 	namespace details
 	{
 		template<class T>
-		struct TIsRValueReference : std::false_type
+		struct TIsRValueReference : FalseType
 		{};
 		template<class T>
-		struct TIsRValueReference<T&&> : std::true_type
+		struct TIsRValueReference<T&&> : TrueType
 		{};
 
 		template<class T>
-		struct TIsLValueReference : std::false_type
+		struct TIsLValueReference : FalseType
 		{};
 		template<class T>
-		struct TIsLValueReference<T&> : std::true_type
+		struct TIsLValueReference<T&> : TrueType
 		{};
 
 		template<typename T>
-		struct TIsChar : std::false_type
+		struct TIsChar : FalseType
 		{};
 		template<>
-		struct TIsChar<AnsiChar> : std::true_type
+		struct TIsChar<AnsiChar> : TrueType
 		{};
 		template<>
-		struct TIsChar<WideChar> : std::true_type
+		struct TIsChar<WideChar> : TrueType
 		{};
 		template<>
-		struct TIsChar<const AnsiChar> : std::true_type
+		struct TIsChar<const AnsiChar> : TrueType
 		{};
 		template<>
-		struct TIsChar<const WideChar> : std::true_type
+		struct TIsChar<const WideChar> : TrueType
 		{};
 
 		// determine whether _Ty can be copy-initialized with {}
 		template<typename T, typename = void>
-		struct TIsImplicitlyDefaultConstructible : std::false_type
+		struct TIsImplicitlyDefaultConstructible : FalseType
 		{};
 
 		template<typename T>
@@ -51,7 +71,7 @@ namespace p
 
 		template<typename T>
 		struct TIsImplicitlyDefaultConstructible<T,
-		    std::void_t<decltype(ImplicitlyDefaultConstruct<T>({}))>> : std::true_type
+		    std::void_t<decltype(ImplicitlyDefaultConstruct<T>({}))>> : TrueType
 		{};
 	}    // namespace details
 
@@ -294,10 +314,10 @@ namespace p
 
 
 	template<typename T, typename = int>
-	struct HasInlineCapacityMember : std::false_type
+	struct HasInlineCapacityMember : FalseType
 	{};
 	template<typename T>
-	struct HasInlineCapacityMember<T, decltype((void)T::inlineCapacity, 0)> : std::true_type
+	struct HasInlineCapacityMember<T, decltype((void)T::inlineCapacity, 0)> : TrueType
 	{};
 
 	template<typename T>
diff --git a/Include/PipeECS.h b/Include/PipeECS.h
index dab482c1..377ec8fe 100644
--- a/Include/PipeECS.h
+++ b/Include/PipeECS.h
@@ -1,7 +1,6 @@
 // Copyright 2015-2026 Piperift. All Rights Reserved.
 #pragma once
 
-#include "Pipe/Core/Broadcast.h"
 #include "Pipe/Core/Map.h"
 #include "Pipe/Core/PageBuffer.h"
 #include "Pipe/Core/Templates.h"
@@ -24,7 +23,7 @@ namespace p
 	////////////////////////////////
 	// FORWARD DECLARATIONS
 	//
-	struct EntityContext;
+	struct IdContext;
 
 
 	////////////////////////////////
@@ -162,25 +161,56 @@ namespace p
 	/**
 	 * Resolve an entity id from an string.
 	 * The expected format is {}:{} where first is the index and second is the version.
-	 * If a context is provided, providing the index alone as a number will resolve it slast
+	 * If a context is provided, providing the index alone as a number will resolve its last
 	 * valid version
 	 */
-	P_API Id IdFromString(String str, EntityContext* context);
+	P_API Id IdFromString(String str, IdContext* context);
 #pragma endregion Ids
 
 
 #pragma region Components
+	// clang-format off
+	template<typename T>
+	concept StoresLastModified = !IsEmpty<T> && HasAnyTypeStaticFlags<T>(TF_ECS_StoreLastModified)
+	    && (IsCopyConstructible<T> || IsMoveConstructible<T>);
+	// clang-format on
+
+	template<typename T>
+	struct CMdfdWithLast
+	{
+		P_STRUCT(CMdfdWithLast, TF_NotSerialized)
+
+		P_PROP(Last)
+		T Last;
+	};
+
+	struct CMdfdWithoutLast
+	{};
+
 	/**
 	 * Modified component
 	 * Optionally, a component can be marked modified when written. This can be used when
 	 * filtering.
 	 */
 	template<typename T>
-	struct CMdfd
+	struct CMdfd : public Select<StoresLastModified<T>, CMdfdWithLast<T>, CMdfdWithoutLast>
 	{
 		P_STRUCT(CMdfd, TF_NotSerialized)
+
+		using Type = T;
 	};
 
+	template<typename Component>
+	static constexpr bool IsMdfdType() requires(!HasTypeMember<Component>)
+	{
+		return false;
+	}
+	template<typename Component>
+	static constexpr bool IsMdfdType() requires(HasTypeMember<Component>)
+	{
+		return IsSame<CMdfd<typename Component::Type>, Component>;
+	}
+
 	/**
 	 * Removed component
 	 * Optionally, an entity can be marked removed instead of actually removed and then flushed
@@ -282,7 +312,7 @@ namespace p
 		using Super = Reader;
 		P_STRUCT(EntityReader)
 
-		EntityContext& context;
+		IdContext& context;
 
 		// While serializing we create ids as Ids appear and link them.
 		TArray<Id> ids;
@@ -290,8 +320,7 @@ namespace p
 
 
 	public:
-		EntityReader(const p::Reader& parent, EntityContext& context)
-		    : Reader(parent), context{context}
+		EntityReader(const p::Reader& parent, IdContext& context) : Reader(parent), context{context}
 		{}
 
 		void SerializeEntities(p::TArray<Id>& entities, TFunction<void(EntityReader&)> onReadPools);
@@ -308,7 +337,7 @@ namespace p
 		}
 
 		const TArray<Id>& GetIds() const;
-		EntityContext& GetContext();
+		IdContext& GetContext();
 
 	protected:
 		TypeId ProvideTypeId() const override
@@ -323,7 +352,7 @@ namespace p
 		using Super = Writer;
 		P_STRUCT(EntityWriter)
 
-		EntityContext& context;
+		IdContext& context;
 
 		// While serializing we create ids as Ids appear and link them.
 		TArray<Id> ids;
@@ -332,9 +361,7 @@ namespace p
 
 
 	public:
-		EntityWriter(const Writer& parent, EntityContext& context)
-		    : Writer(parent), context{context}
-		{}
+		EntityWriter(const Writer& parent, IdContext& context) : Writer(parent), context{context} {}
 
 		void SerializeEntities(const TArray<Id>& entities,
 		    TFunction<void(EntityWriter&)> onWritePools, bool includeChildren = true);
@@ -544,9 +571,6 @@ namespace p
 		i32 lastRemovedIndex = NO_INDEX;
 		PoolRemovePolicy removePolicy;
 
-		TBroadcast<TView<const Id>> onAdd;
-		TBroadcast<TView<const Id>> onRemove;
-
 
 		ComponentPool(TypeId typeId, PoolRemovePolicy removePolicy, Arena& arena);
 		ComponentPool(const ComponentPool& other);
@@ -554,21 +578,6 @@ namespace p
 		ComponentPool& operator=(const ComponentPool& other) noexcept;
 		ComponentPool& operator=(ComponentPool&& other) noexcept;
 
-		void OnAdded(TView<const Id> ids)
-		{
-			if (!ids.IsEmpty())
-			{
-				onAdd.Broadcast(ids);
-			}
-		}
-
-		void OnRemoved(TView<const Id> ids)
-		{
-			if (!ids.IsEmpty())
-			{
-				onRemove.Broadcast(ids);
-			}
-		}
 
 	public:
 		virtual ~ComponentPool() {}
@@ -614,16 +623,6 @@ namespace p
 			return idList;
 		}
 
-		TBroadcast<TView<const Id>>& OnAdd()
-		{
-			return onAdd;
-		}
-
-		TBroadcast<TView<const Id>>& OnRemove()
-		{
-			return onRemove;
-		}
-
 	protected:
 
 		Index EmplaceId(const Id id, bool forceBack);
@@ -648,7 +647,7 @@ namespace p
 
 
 	public:
-		TPool(p::EntityContext& ctx, Arena& arena = GetCurrentArena())
+		TPool(p::IdContext& ctx, Arena& arena = GetCurrentArena())
 		    : ComponentPool(p::GetTypeId<T>(), PoolRemovePolicy::InPlace, arena), data{arena}
 		{}
 		TPool(const TPool& other) : ComponentPool(other), data{*other.arena}
@@ -736,10 +735,8 @@ namespace p
 				{
 					data.Reserve(index + 1u);
 					T* const value = data.Insert(index, p::Forward<Args>(args)...);
-					OnAdded({id});
 					return *value;
 				}
-				OnAdded({id});
 			}
 		}
 
@@ -777,7 +774,6 @@ namespace p
 					}
 				}
 			}
-			OnAdded(ids);
 		}
 
 		template<typename It, typename CIt>
@@ -826,12 +822,6 @@ namespace p
 				}
 				++from;
 			}
-			OnAdded(ids);
-		}
-
-		T& GetOrAdd(const Id id) requires(!p::IsEmpty<T>)
-		{
-			return Has(id) ? Get(id) : Add(id);
 		}
 
 		bool Remove(Id id) override
@@ -847,7 +837,6 @@ namespace p
 		void RemoveUnsafe(Id id) override
 		{
 			P_Check(Has(id));
-			OnRemoved({id});
 			if (removePolicy == PoolRemovePolicy::InPlace)
 			{
 				Pop(id);
@@ -860,7 +849,6 @@ namespace p
 
 		i32 Remove(TView<const Id> ids) override
 		{
-			OnRemoved(ids);
 			i32 removed = 0;
 			if (removePolicy == PoolRemovePolicy::InPlace)
 			{
@@ -889,7 +877,6 @@ namespace p
 
 		void RemoveUnsafe(TView<const Id> ids) override
 		{
-			OnRemoved(ids);
 			if (removePolicy == PoolRemovePolicy::InPlace)
 			{
 				for (Id id : ids)
@@ -960,12 +947,20 @@ namespace p
 		void Reserve(sizet size)
 		{
 			idList.Reserve(size);
-			if (size > Size())
+			if constexpr (!p::IsEmpty<T>)
 			{
-				data.Reserve(size);
+				if (size > Size())
+				{
+					data.Reserve(size);
+				}
 			}
 		}
 
+		void ReserveMore(sizet size)
+		{
+			Reserve(Size() + size);
+		}
+
 		void Shrink()
 		{
 			idList.Shrink();
@@ -1059,13 +1054,13 @@ namespace p
 	template<>
 	struct P_API TPool<CRemoved> : public IPool
 	{
-		friend EntityContext;
+		friend IdContext;
 		using T = CRemoved;
 
 		p::IdRegistry* idRegistry = nullptr;
 
 	public:
-		TPool(p::EntityContext& ctx, Arena& arena = GetCurrentArena());
+		TPool(p::IdContext& ctx, Arena& arena = GetCurrentArena());
 		TPool(const TPool& other) = delete;
 		TPool(TPool&& other)      = delete;
 		TPool& operator=(const TPool& other)
@@ -1160,175 +1155,319 @@ namespace p
 
 
 ////////////////////////////////
-// CONTEXT
+// OPERATIONS
 //
-#pragma region Context
-	enum class IdRemovePolicy : u8
+#pragma region Operations
+	/**
+	 * IdOperations contains shared logic to view and edit components and statics in Contexts and
+	 * Scopes This class assumes GetPool and AssurePool are present in Parent
+	 */
+	template<typename Parent>
+	struct TIdOperations
 	{
-		Instant,
-		Deferred
-	};
+		const Parent& AsParent() const
+		{
+			return *static_cast<const Parent*>(this);
+		}
 
-	struct P_API SortLessStatics
-	{
-		bool operator()(const OwnPtr& a, const OwnPtr& b) const
+		template<typename Component>
+		CopyConst<TPool<Mut<Component>>, Component>& AssurePool() const
 		{
-			return a.GetId() < b.GetId();
-		}    // namespace p
+			return AsParent().template AssurePool<Component>();
+		}
 
-		bool operator()(TypeId a, const OwnPtr& b) const
+		template<typename Component>
+		CopyConst<TPool<Mut<Component>>, Component>* GetPool() const
 		{
-			return a < b.GetId();
+			return AsParent().template GetPool<Component>();
 		}
 
-		bool operator()(const OwnPtr& a, TypeId b) const
+		IdContext& GetContext() const
 		{
-			return a.GetId() < b;
+			return AsParent().GetContext();
 		}
-	};
 
-	struct P_API EntityContext
-	{
-	private:
-		IdRegistry idRegistry;
-		mutable TArray<PoolInstance> pools;
-		TArray<OwnPtr> statics;
-		IdRemovePolicy removePolicy = IdRemovePolicy::Instant;
+		template<typename Component>
+		i32 Size() const
+		{
+			return GetPool<const Component>()->Size();
+		}
 
+		bool IsValid(Id id) const
+		{
+			return GetContext().IsValid(id);
+		}
 
-	public:
-		EntityContext();
-		~EntityContext()
+		template<typename Component>
+		bool Has(Id id) const
 		{
-			Reset();
+			const auto* pool = GetPool<const Component>();
+			return pool && pool->Has(id);
+		}
+		template<typename... Component>
+		bool Has(Id id) const requires(sizeof...(Component) > 1)
+		{
+			return (Has<Component>(id) && ...);
 		}
-		explicit EntityContext(const EntityContext& other) noexcept;
-		explicit EntityContext(EntityContext&& other) noexcept;
-		EntityContext& operator=(const EntityContext& other) noexcept;
-		EntityContext& operator=(EntityContext&& other) noexcept;
 
-#pragma region Entities
-		// Reflection helpers
-		void* AddDefault(TypeId typeId, Id id);
-		void Remove(TypeId typeId, Id id);
+		template<typename Component>
+		void Modify(TView<const Id> ids, TPool<Component>* pool = nullptr) const
+		{
+			auto& mdfdPool = AssurePool<CMdfd<Component>>();
+			if constexpr (StoresLastModified<Component>)
+			{
+				if (!pool)
+				{
+					pool = GetPool<Component>();
+					if (!pool)
+					{
+						return;
+					}
+				}
+
+				mdfdPool.ReserveMore(ids.Size());
+				for (Id id : ids)
+				{
+					if (!mdfdPool.Has(id))    // If we store value, we only add if it it wasn't
+					                          // modified already
+					{
+						Component* comp = pool->TryGet(id);
+						if constexpr (IsMoveConstructible<Component>)
+						{
+							mdfdPool.Add(
+							    id, comp ? CMdfd<Component>{p::Move(*comp)} : CMdfd<Component>{});
+						}
+						else
+						{
+							mdfdPool.Add(id, comp ? CMdfd<Component>{*comp} : CMdfd<Component>{});
+						}
+					}
+				}
+			}
+			else
+			{
+				mdfdPool.Add(ids.begin(), ids.end(), CMdfd<Component>{});
+			}
+		}
 
-		// Adds Component to an entity (if the entity doesnt have it already)
-		template<typename C>
-		decltype(auto) Add(Id id, C&& value = {}) const requires(IsSame<C, Mut<C>>)
+		template<typename Component>
+		bool IsModified(Id id) const
 		{
-			P_Check(IsValid(id));
-			return AssurePool<C>().Add(id, p::Forward<C>(value));
+			return Has<CMdfd<Mut<Component>>>(id);
 		}
-		template<typename C>
-		decltype(auto) Add(Id id, const C& value) const requires(IsSame<C, Mut<C>>)
+
+		template<typename Component>
+		decltype(auto) Add(Id id, Component&& value = {}) const requires(IsMutable<Component>)
 		{
 			P_Check(IsValid(id));
-			return AssurePool<C>().Add(id, value);
+			auto& pool = AssurePool<Component>();
+			if constexpr (HasAnyTypeStaticFlags<Component>(TF_ECS_ModifyOnAdd))
+			{
+				Modify<Component>(id, &pool);
+			}
+			return pool.Add(id, p::Forward<Component>(value));
 		}
-		// Adds Component to an entity (if the entity doesnt have it already)
-		template<typename... Component>
-		void Add(Id id) requires(sizeof...(Component) > 1)
+		template<typename Component>
+		decltype(auto) Add(Id id, const Component& value) const requires(IsMutable<Component>)
 		{
 			P_Check(IsValid(id));
-			(Add<Component>(id), ...);
+			auto& pool = AssurePool<Component>();
+			if constexpr (HasAnyTypeStaticFlags<Component>(TF_ECS_ModifyOnAdd))
+			{
+				Modify<Component>(id, &pool);
+			}
+			return pool.Add(id, value);
 		}
 
-		// Add Component to many entities (if they dont have it already)
-		template<typename Component>
-		decltype(auto) AddN(TView<const Id> ids, const Component& value = {})
+		// Add component to an entities (if they dont have it already)
+		template<typename... Component>
+		void Add(Id id) const requires((IsMutable<Component> && ...) && sizeof...(Component) > 1)
 		{
-			return AssurePool<Component>().Add(ids.begin(), ids.end(), value);
+			(Add<Component>(id), ...);
 		}
 
-		// Add Components to many entities (if they don't have it already)
-		template<typename... Component>
-		void AddN(TView<const Id> ids) requires(sizeof...(Component) > 1)
+		// Add component to many entities (if they dont have it already)
+		template<typename Component>
+		decltype(auto) AddN(TView<const Id> ids, const Component& value = {}) const
 		{
-			(Add<Component>(ids), ...);
+			auto& pool = AssurePool<Component>();
+			if constexpr (HasAnyTypeStaticFlags<Component>(TF_ECS_ModifyOnAdd))
+			{
+				Modify<Component>(ids, &pool);
+			}
+			return pool.Add(ids.begin(), ids.end(), value);
 		}
 
 		template<typename Component>
 		void AddN(TView<const Id> ids, const TView<const Component>& values)
 		{
 			P_Check(ids.Size() == values.Size());
-			AssurePool<Component>().Add(ids.begin(), ids.end(), values.begin());
+			auto& pool = AssurePool<Component>();
+			if constexpr (HasAnyTypeStaticFlags<Component>(TF_ECS_ModifyOnAdd))
+			{
+				Modify<Component>(ids, &pool);
+			}
+			pool.Add(ids.begin(), ids.end(), values.begin());
+		}
+
+		// Add components to many entities (if they dont have it already)
+		template<typename... Component>
+		void AddN(TView<const Id> ids) const
+		    requires((IsMutable<Component> && ...) && sizeof...(Component) > 1)
+		{
+			(AddN<Component>(ids), ...);
 		}
 
 
 		template<typename Component>
-		void Remove(const Id id)
+		void Remove(const Id id) const requires(IsMutable<Component>)
 		{
 			if (auto* pool = GetPool<Component>())
 			{
+				if constexpr (HasAnyTypeStaticFlags<Component>(TF_ECS_ModifyOnRm))
+				{
+					Modify<Component>(id, pool);
+				}
 				pool->Remove(id);
 			}
 		}
 		template<typename... Component>
-		void Remove(const Id id) requires(sizeof...(Component) > 1)
+		void Remove(const Id id) const requires(sizeof...(Component) > 1)
 		{
 			(Remove<Component>(id), ...);
 		}
 		template<typename Component>
-		void Remove(TView<const Id> ids)
+		void Remove(TView<const Id> ids) const requires(IsMutable<Component>)
 		{
 			if (auto* pool = GetPool<Component>())
 			{
+				if constexpr (HasAnyTypeStaticFlags<Component>(TF_ECS_ModifyOnRm))
+				{
+					Modify<Component>(ids, pool);
+				}
 				pool->Remove(ids);
 			}
-
-			if constexpr (HasAnyTypeStaticFlags<Component>(TF_ECS_AutoModify))
-			{
-				AssurePool<CMdfd<Component>>().Add(ids.begin(), ids.end(), {});
-			}
 		}
 		template<typename... Component>
-		void Remove(TView<const Id> ids) requires(sizeof...(Component) > 1)
+		void Remove(TView<const Id> ids) const requires(sizeof...(Component) > 1)
 		{
 			(Remove<Component>(ids), ...);
 		}
 
 		template<typename Component>
-		Component& Get(const Id id) const
+		Component& Get(Id id) const
 		{
 			auto* const pool = GetPool<Component>();
 			P_Check(pool);
+			if constexpr (IsMutable<Component>
+			              && HasAnyTypeStaticFlags<Component>(TF_ECS_ModifyOnGet))
+			{
+				Modify<Component>(id, pool);
+			}
 			return pool->Get(id);
 		}
-		template<typename... Component>
-		TTuple<Component&...> Get(const Id id) const requires(sizeof...(Component) > 1)
+
+		template<typename Component>
+		Component* TryGet(Id id) const
 		{
-			return std::forward_as_tuple(Get<Component>(id)...);
+			auto* const pool = GetPool<Component>();
+			P_Check(pool);
+			Component* value = pool->TryGet(id);
+			if constexpr (IsMutable<Component>
+			              && HasAnyTypeStaticFlags<Component>(TF_ECS_ModifyOnGet))
+			{
+				if (value)
+				{
+					Modify<Component>(id, pool);
+				}
+			}
+			return value;
 		}
+
 		template<typename Component>
-		Component* TryGet(const Id id) const
+		Component& GetOrAdd(Id id) const requires(IsMutable<Component>)
 		{
-			auto* const pool = GetPool<Component>();
-			return pool ? pool->TryGet(id) : nullptr;
+			auto& pool = AssurePool<Component>();
+
+			if (pool.Has(id))
+			{
+				if constexpr (HasAnyTypeStaticFlags<Component>(TF_ECS_ModifyOnGet))
+				{
+					Modify<Component>(id, *pool);
+				}
+				return pool.Get(id);
+			}
+			else
+			{
+				if constexpr (HasAnyTypeStaticFlags<Component>(TF_ECS_ModifyOnAdd))
+				{
+					Modify<Component>(id, *pool);
+				}
+				return pool.Add(id);
+			}
 		}
+
 		template<typename... Component>
-		TTuple<Component*...> TryGet(const Id id) const requires(sizeof...(Component) > 1)
+		void ClearPool() const
 		{
-			return std::forward_as_tuple(TryGet<Component>(id)...);
+			(GetPool<Component>()->Clear(), ...);
 		}
+	};
+#pragma endregion Operations
 
-		template<typename Component>
-		Component& GetOrAdd(Id id)
+
+////////////////////////////////
+// CONTEXT
+//
+#pragma region Context
+	enum class IdRemovePolicy : u8
+	{
+		Instant,
+		Deferred
+	};
+
+	struct P_API SortLessStatics
+	{
+		bool operator()(const OwnPtr& a, const OwnPtr& b) const
+		{
+			return a.GetId() < b.GetId();
+		}    // namespace p
+
+		bool operator()(TypeId a, const OwnPtr& b) const
 		{
-			return AssurePool<Component>().GetOrAdd(id);
+			return a < b.GetId();
 		}
 
-		template<typename Component>
-		bool Has(Id id) const
+		bool operator()(const OwnPtr& a, TypeId b) const
 		{
-			const auto* pool = GetPool<Component>();
-			return pool && pool->Has(id);
+			return a.GetId() < b;
 		}
+	};
 
-		template<typename... Component>
-		bool Has(Id id) const requires(sizeof...(Component) >= 2)
+	struct P_API IdContext : public TIdOperations<IdContext>
+	{
+	private:
+		IdRegistry idRegistry;
+		mutable TArray<PoolInstance> pools;
+		TArray<OwnPtr> statics;
+		IdRemovePolicy removePolicy = IdRemovePolicy::Instant;
+
+
+	public:
+		IdContext();
+		~IdContext()
 		{
-			return (Has<const Component>(id) && ...);
+			Reset();
 		}
+		explicit IdContext(const IdContext& other) noexcept;
+		explicit IdContext(IdContext&& other) noexcept;
+		IdContext& operator=(const IdContext& other) noexcept;
+		IdContext& operator=(IdContext&& other) noexcept;
+
+#pragma region Entities
+		// Reflection helpers
+		void* AddByTypeId(TypeId typeId, Id id);
+		void RemoveByTypeId(TypeId typeId, Id id);
 
 		const IdRegistry& GetIdRegistry() const
 		{
@@ -1381,27 +1520,20 @@ namespace p
 
 		void Reset(bool keepStatics = false);
 
-		template<typename Component>
-		TBroadcast<TView<const Id>>& OnAdd()
+		IdContext& GetContext() const
 		{
-			return AssurePool<Component>().OnAdd();
-		}
-
-		template<typename Component>
-		TBroadcast<TView<const Id>>& OnRemove()
-		{
-			return AssurePool<Component>().OnRemove();
+			return *const_cast<IdContext*>(this);
 		}
 
 		// Finds or creates a pool
 		template<typename T>
 		TPool<Mut<T>>& AssurePool() const;
 
-		IPool* GetPool(TypeId componentId) const;
-		void GetPools(TView<const TypeId> componentIds, TArray<IPool*>& outPools) const;
-		void GetPools(TView<const TypeId> componentIds, TArray<const IPool*>& outPools) const
+		IPool* GetPool(TypeId typeId) const;
+		void GetPools(TView<const TypeId> typeIds, TArray<IPool*>& outPools) const;
+		void GetPools(TView<const TypeId> typeIds, TArray<const IPool*>& outPools) const
 		{
-			GetPools(componentIds, reinterpret_cast<TArray<IPool*>&>(outPools));
+			GetPools(typeIds, reinterpret_cast<TArray<IPool*>&>(outPools));
 		}
 
 		template<typename T>
@@ -1467,8 +1599,8 @@ namespace p
 #pragma endregion Statics
 
 	private:
-		void CopyFrom(const EntityContext& other);
-		void MoveFrom(EntityContext&& other);
+		void CopyFrom(const IdContext& other);
+		void MoveFrom(IdContext&& other);
 
 		static OwnPtr& FindOrAddStaticPtr(
 		    TArray<OwnPtr>& statics, const TypeId typeId, bool* bAdded = nullptr);
@@ -1480,105 +1612,83 @@ namespace p
 
 
 ////////////////////////////////
-// ACCESSES
+// ID SCOPES
 //
-#pragma region Accesses
-	enum class AccessMode : u8
-	{
-		Read,
-		Write
-	};
-
-	struct TypeAccess
-	{
-		TypeId typeId   = TypeId::None();
-		AccessMode mode = AccessMode::Read;
-
-		constexpr TypeAccess() = default;
-		constexpr TypeAccess(TypeId typeId, AccessMode mode) : typeId{typeId}, mode{mode} {}
-	};
-
-	template<typename T, AccessMode inMode>
-	struct TTypeAccess : TypeAccess
-	{
-		using Type = Mut<T>;
-
-		constexpr TTypeAccess() : TypeAccess(GetTypeId<T>(), inMode) {}
-	};
-
+#pragma region IdScopes
 	template<typename T>
-	struct TRead : public TTypeAccess<T, AccessMode::Read>
-	{};
-
-	template<typename T>
-	struct TWrite : public TTypeAccess<T, AccessMode::Write>
-	{};
-
-	template<typename T>
-	struct TTypeAccessInfo
-	{
-		using Type                       = Mut<T>;
-		static constexpr AccessMode mode = AccessMode::Read;
-	};
-	template<typename T>
-	requires Derived<T, TypeAccess>
-	struct TTypeAccessInfo<T>
+	struct TIsAutoModified
 	{
-		using Type                       = typename T::Type;
-		static constexpr AccessMode mode = T().mode;
+		static constexpr bool value = HasAnyTypeStaticFlags<T>(TF_ECS_ModifyOnEdit);
 	};
-	template<typename T>
-	using AsComponent = typename TTypeAccessInfo<T>::Type;
 
 
-	template<typename... T>
-	struct TAccess
+	// Base for TIdScope. Assumes all types are mutable (not const)
+	template<typename W, typename... R>
+	struct TIdScopeBase : public TIdOperations<TIdScopeBase<W, R...>>
 	{
-		template<typename... K>
-		friend struct TAccess;
-
-		using Components    = TTypeList<T...>;
-		using RawComponents = TTypeList<AsComponent<T>...>;
+		template<typename W2, typename... R2>
+		friend struct TIdScopeBase;
 
 	private:
-		TypeId typeId;
-		EntityContext& context;
-		TTuple<TPool<AsComponent<T>>*...> pools;
+		using ModifyWrites = W::template Filter<TIsAutoModified>::template Wrap<CMdfd>;
+		using ModifyReads = TTypeList<R...>::template Filter<TIsAutoModified>::template Wrap<CMdfd>;
 
+	public:
+		using WDependencies  = W::template Append<ModifyWrites>;
+		using RDependencies  = TTypeList<R...>::template Append<ModifyReads>;
+		using RWDependencies = RDependencies::template Append<WDependencies>::Deduplicate;
+		using Pools          = RWDependencies::template WrapPtr<TPool>;
+		using Tuple          = Pools::template To<std::tuple>;
+
+	protected:
+		IdContext& context;
+		Tuple pools;
 
 	public:
-		TAccess(EntityContext& context)
-		    : context{context}, pools{&context.AssurePool<AsComponent<T>>()...}
+		TIdScopeBase(IdContext& context)
+		    : context{context}, pools(RWDependencies::Call([&context]<typename... T> {
+			    return Tuple{&context.AssurePool<T>()...};
+		    }))
 		{}
-		TAccess(const TAccess& other) : context{other.context}, pools{other.pools} {}
+		TIdScopeBase(const TIdScopeBase& other) : context{other.context}, pools{other.pools} {}
 
-		// Construct a child access (super-set) from another access
+		// Construct a child scope (super-set) from another scope
 		template<typename... T2>
-		TAccess(const TAccess<T2...>& other) : context{other.context}
+		TIdScopeBase(const TIdScopeBase<T2...>& other) : context{other.context}
 		{
-			using Other = TAccess<T2...>;
+			using Other = TIdScopeBase<T2...>;
+
+			constexpr bool validReads = RWDependencies::Call([]<typename... T>() {
+				return (Other::template IsReadable<T>() && ...);
+			});
+
+			constexpr bool validWrites = WDependencies::Call([]<typename... T>() {
+				return (Other::template IsWritable<T>() && ...);
+			});
 
-			constexpr bool validConstants = (Other::template HasType<T>() && ...);
-			constexpr bool validMutables =
-			    ((Other::template IsWritable<T>() || TTypeAccessInfo<T>::mode != AccessMode::Write)
-			        && ...);
-			static_assert(validConstants, "Parent access lacks dependencies from this access.");
 			static_assert(
-			    validMutables, "Parent access lacks *mutable* dependencies from this access.");
+			    validReads, "Parent scope lacks read dependencies required by this scope.");
+			static_assert(
+			    validWrites, "Parent scope lacks *write* dependencies required by this scope.");
 
-			if constexpr (validConstants && validMutables)
+			// Prevent compiler errors, we already have static_asserts
+			if constexpr (validReads && validWrites)
 			{
-				pools = {std::get<TPool<AsComponent<T>>*>(other.pools)...};
+				pools = RWDependencies::Call([&other]<typename... T> {
+					return Tuple{std::get<TPool<T>*>(other.pools)...};
+				});
 			}
 		}
 
-		template<typename C>
-		TPool<Mut<C>>* GetPool() const requires(IsMutable<C>)
+
+		template<typename Component>
+		TPool<Mut<Component>>* GetPool() const requires(IsMutable<Component>)
 		{
-			static_assert(IsWritable<C>(), "Can't modify components of this type");
-			if constexpr (IsWritable<C>())    // Prevent missleading errors if condition fails
+			static_assert(IsWritable<Component>(), "Can't modify components of this type");
+			if constexpr (IsWritable<Component>())    // Prevent missleading errors if condition
+			                                          // fails
 			{
-				return std::get<TPool<Mut<C>>*>(pools);
+				return std::get<TPool<Mut<Component>>*>(pools);
 			}
 			else
 			{
@@ -1586,13 +1696,14 @@ namespace p
 			}
 		}
 
-		template<typename C>
-		const TPool<Mut<C>>* GetPool() const requires(IsConst<C>)
+		template<typename Component>
+		const TPool<Mut<Component>>* GetPool() const requires(IsConst<Component>)
 		{
-			static_assert(IsReadable<C>(), "Can't read components of this type");
-			if constexpr (IsReadable<C>())    // Prevent missleading errors if condition fails
+			static_assert(IsReadable<Component>(), "Can't read components of this type");
+			if constexpr (IsReadable<Component>())    // Prevent missleading errors if condition
+			                                          // fails
 			{
-				return std::get<TPool<Mut<C>>*>(pools);
+				return std::get<TPool<Mut<Component>>*>(pools);
 			}
 			else
 			{
@@ -1600,184 +1711,93 @@ namespace p
 			}
 		}
 
-		template<typename C>
-		TPool<Mut<C>>& AssurePool() const requires(IsMutable<C>)
-		{
-			return *GetPool<C>();
-		}
-
-		template<typename C>
-		const TPool<Mut<C>>& AssurePool() const requires(IsConst<C>)
-		{
-			return *GetPool<C>();
-		}
-
-		bool IsValid(Id id) const
-		{
-			return context.IsValid(id);
-		}
-
-		template<typename... C>
-		bool Has(Id id) const requires(sizeof...(C) >= 1)
-		{
-			return (GetPool<const C>()->Has(id) && ...);
-		}
-
-		template<typename C>
-		decltype(auto) Add(Id id, C&& value = {}) const requires(IsSame<C, Mut<C>>)
-		{
-			return GetPool<C>()->Add(id, p::Forward<C>(value));
-		}
-		template<typename C>
-		decltype(auto) Add(Id id, const C& value) const requires(IsSame<C, Mut<C>>)
-		{
-			return GetPool<C>()->Add(id, value);
-		}
-
-		// Add component to an entities (if they dont have it already)
-		template<typename... C>
-		void Add(Id id) const requires((IsSame<C, Mut<C>> && ...) && sizeof...(C) > 1)
-		{
-			(Add<C>(id), ...);
-		}
-
-		// Add component to many entities (if they dont have it already)
-		template<typename C>
-		decltype(auto) AddN(TView<const Id> ids, const C& value = {}) const
-		{
-			return GetPool<C>()->Add(ids.begin(), ids.end(), value);
-		}
-
-		// Add components to many entities (if they dont have it already)
-		template<typename... C>
-		void AddN(TView<const Id> ids) const
-		    requires((IsSame<C, Mut<C>> && ...) && sizeof...(C) > 1)
-		{
-			(AddN<C>(ids), ...);
-		}
-
-
-		template<typename C>
-		void Remove(const Id id) const requires(IsSame<C, Mut<C>>)
-		{
-			if (auto* pool = GetPool<C>())
-			{
-				pool->Remove(id);
-			}
-		}
-		template<typename... C>
-		void Remove(const Id id) const requires(sizeof...(C) > 1)
-		{
-			(Remove<C>(id), ...);
-		}
-		template<typename C>
-		void Remove(TView<const Id> ids) const requires(IsSame<C, Mut<C>>)
-		{
-			if (auto* pool = GetPool<C>())
-			{
-				pool->Remove(ids);
-			}
-		}
-		template<typename... C>
-		void Remove(TView<const Id> ids) const requires(sizeof...(C) > 1)
+		template<typename Component>
+		TPool<Component>& AssurePool() const requires(IsMutable<Component>)
 		{
-			(Remove<C>(ids), ...);
+			return *GetPool<Component>();
 		}
 
-		template<typename C>
-		C& Get(Id id) const
+		template<typename Component>
+		const TPool<Mut<Component>>& AssurePool() const requires(IsConst<Component>)
 		{
-			return GetPool<C>()->Get(id);
+			return *GetPool<Component>();
 		}
 
-		template<typename C>
-		C* TryGet(Id id) const
-		{
-			return GetPool<C>()->TryGet(id);
-		}
 
-		template<typename C>
-		C& GetOrAdd(Id id) const requires(IsMutable<C>)
+		IdContext& GetContext() const
 		{
-			return GetPool<C>()->GetOrAdd(id);
-		}
-
-		i32 Size() const
-		{
-			static_assert(sizeof...(T) == 1, "Can only get the size of single component accesses");
-			return GetPool<T...>()->Size();
+			return context;
 		}
 
-		template<typename C>
-		i32 Size() const
+		template<typename Component>
+		static constexpr bool IsMdfdType() requires(!HasTypeMember<Component>)
 		{
-			return GetPool<const C>()->Size();
+			return false;
 		}
-
-		template<typename C>
-		void ClearPool() const
+		template<typename Component>
+		static constexpr bool IsMdfdType() requires(HasTypeMember<Component>)
 		{
-			GetPool<C>()->Clear();
+			return IsSame<CMdfd<typename Component::Type>, Component>;
 		}
 
-		template<typename... C>
-		void ClearPool() const requires(sizeof...(C) > 1)
+		template<typename Component>
+		static constexpr bool IsReadable()
 		{
-			(ClearPool<C>(), ...);
+			return RWDependencies::template Contains<Mut<Component>>();
 		}
 
-		EntityContext& GetContext() const
+		template<typename Component>
+		static constexpr bool IsWritable()
 		{
-			return context;
+			return IsMutable<Component> && WDependencies::template Contains<Component>();
 		}
+	};
 
 
-		template<typename C>
-		static constexpr bool HasType()
-		{
-			return ListContains<RawComponents, AsComponent<C>>();
-		}
+	template<typename... T>
+	struct Writes : public TTypeList<T...>
+	{};
 
-		template<typename C>
-		static constexpr bool IsReadable()
-		{
-			return HasType<C>();
-		}
+	template<typename... R>
+	struct TIdScope : public TIdScopeBase<Writes<>, Mut<R>...>
+	{
+		using TIdScopeBase<Writes<>, Mut<R>...>::TIdScopeBase;
+	};
 
-		template<typename C>
-		static constexpr bool IsWritable()
-		{
-			return IsMutable<C> && ListContains<Components, TWrite<AsComponent<C>>>();
-		}
+	template<typename... W, typename... R>
+	struct TIdScope<Writes<W...>, R...> : public TIdScopeBase<Writes<Mut<W>...>, Mut<R>...>
+	{
+		using TIdScopeBase<Writes<Mut<W>...>, Mut<R>...>::TIdScopeBase;
 	};
 
+
 	template<typename... T>
-	using TAccessRef = const TAccess<T...>&;
+	using TIdScopeRef = const TIdScope<T...>&;
 
-	struct Access
+	struct IdScope : public TIdOperations<IdScope>
 	{
 	protected:
 
-		EntityContext& ast;
-		TArray<TypeAccess> types;
+		IdContext& context;
+		// TArray<TypeAccess> types;
 		TArray<IPool*> pools;
 
 
 	public:
-		Access(EntityContext& ast, const TArray<TypeId>& types) : ast{ast} {}
+		IdScope(IdContext& ctx, const TArray<TypeId>& types) : context{ctx} {}
 
 		template<typename... T>
-		Access(TAccessRef<T...> access) : ast{access.ast}
+		IdScope(TIdScopeRef<T...> scope) : context{scope.context}
 		{}
 
-		template<typename C>
-		TPool<Mut<C>>* GetPool() const requires(IsMutable<C>)
+		template<typename Component>
+		TPool<Mut<Component>>* GetPool() const requires(IsMutable<Component>)
 		{
 			return nullptr;
 		}
 
-		template<typename C>
-		const TPool<Mut<C>>* GetPool() const requires(IsConst<C>)
+		template<typename Component>
+		const TPool<Mut<Component>>* GetPool() const requires(IsConst<Component>)
 		{
 			return nullptr;
 		}
@@ -1789,7 +1809,7 @@ namespace p
 			return 0;
 		}
 	};
-#pragma endregion Accesses
+#pragma endregion IdScopees
 
 
 ////////////////////////////////
@@ -1868,21 +1888,21 @@ namespace p
 	/**
 	 * Remove ids containing a component from 'ids'. Does not guarantee order.
 	 *
-	 * @param access from where to access pools
+	 * @param scope from where to scope pools
 	 * @param ids array that will be modified
 	 * @param shouldShrink if true, the ids array will be shrink at the end
 	 * @see ExcludeIdsWithStable(), ExcludeIdsWithout()
 	 */
-	template<typename C, typename AccessType>
-	void ExcludeIdsWith(const AccessType& access, TArray<Id>& ids, const bool shouldShrink = true)
+	template<typename Component, typename Scope>
+	void ExcludeIdsWith(const Scope& scope, TArray<Id>& ids, const bool shouldShrink = true)
 	{
-		ExcludeIdsWith(&access.template AssurePool<const C>(), ids, shouldShrink);
+		ExcludeIdsWith(&scope.template AssurePool<const Component>(), ids, shouldShrink);
 	}
-	template<typename... C, typename AccessType>
-	void ExcludeIdsWith(const AccessType& access, TArray<Id>& ids, const bool shouldShrink = true)
-	    requires(sizeof...(C) > 1)
+	template<typename... Component, typename Scope>
+	void ExcludeIdsWith(const Scope& scope, TArray<Id>& ids, const bool shouldShrink = true)
+	    requires(sizeof...(Component) > 1)
 	{
-		(ExcludeIdsWith<C>(access, ids, shouldShrink), ...);
+		(ExcludeIdsWith<Component>(scope, ids, shouldShrink), ...);
 	}
 
 	template<typename Predicate>
@@ -1904,82 +1924,79 @@ namespace p
 	/**
 	 * Remove ids containing a component from 'ids'. Guarantees order.
 	 *
-	 * @param access from where to access pools
+	 * @param scope from where to scope pools
 	 * @param ids array that will be modified
 	 * @param shouldShrink if true, the ids array will be shrink at the end
 	 * @see ExcludeIdsWith(), ExcludeIdsWithoutStable()
 	 */
-	template<typename C, typename AccessType>
-	void ExcludeIdsWithStable(
-	    const AccessType& access, TArray<Id>& ids, const bool shouldShrink = true)
+	template<typename Component, typename Scope>
+	void ExcludeIdsWithStable(const Scope& scope, TArray<Id>& ids, const bool shouldShrink = true)
 	{
-		ExcludeIdsWithStable(&access.template AssurePool<const C>(), ids, shouldShrink);
+		ExcludeIdsWithStable(&scope.template AssurePool<const Component>(), ids, shouldShrink);
 	}
-	template<typename... C, typename AccessType>
-	void ExcludeIdsWithStable(const AccessType& access, TArray<Id>& ids,
-	    const bool shouldShrink = true) requires(sizeof...(C) > 1)
+	template<typename... Component, typename Scope>
+	void ExcludeIdsWithStable(const Scope& scope, TArray<Id>& ids, const bool shouldShrink = true)
+	    requires(sizeof...(Component) > 1)
 	{
-		(ExcludeIdsWithStable<C>(access, ids, shouldShrink), ...);
+		(ExcludeIdsWithStable<Component>(scope, ids, shouldShrink), ...);
 	}
 
 	/**
 	 * Remove ids NOT containing a component from 'ids'. Does not guarantee order.
 	 *
-	 * @param access from where to access pools
+	 * @param scope from where to scope pools
 	 * @param ids array that will be modified
 	 * @param shouldShrink if true, the ids array will be shrink at the end
 	 * @see ExcludeIdsWithoutStable(), ExcludeIdsWith()
 	 */
-	template<typename C, typename AccessType>
-	void ExcludeIdsWithout(
-	    const AccessType& access, TArray<Id>& ids, const bool shouldShrink = true)
+	template<typename Component, typename Scope>
+	void ExcludeIdsWithout(const Scope& scope, TArray<Id>& ids, const bool shouldShrink = true)
 	{
-		ExcludeIdsWithout(&access.template AssurePool<const C>(), ids, shouldShrink);
+		ExcludeIdsWithout(&scope.template AssurePool<const Component>(), ids, shouldShrink);
 	}
 
-	template<typename... C, typename AccessType>
-	void ExcludeIdsWithout(const AccessType& access, TArray<Id>& ids,
-	    const bool shouldShrink = true) requires(sizeof...(C) > 1)
+	template<typename... Component, typename Scope>
+	void ExcludeIdsWithout(const Scope& scope, TArray<Id>& ids, const bool shouldShrink = true)
+	    requires(sizeof...(Component) > 1)
 	{
-		(ExcludeIdsWithout<C>(access, ids, shouldShrink), ...);
+		(ExcludeIdsWithout<Component>(scope, ids, shouldShrink), ...);
 	}
 
 	/**
 	 * Remove ids NOT containing a component from 'ids'. Guarantees order.
 	 *
-	 * @param access from where to access pools
+	 * @param scope from where to scope pools
 	 * @param ids array that will be modified
 	 * @param shouldShrink if true, the ids array will be shrink at the end
 	 * @see ExcludeIdsWithout(), ExcludeIdsWithStable()
 	 */
-	template<typename C, typename AccessType>
+	template<typename Component, typename Scope>
 	void ExcludeIdsWithoutStable(
-	    const AccessType& access, TArray<Id>& ids, const bool shouldShrink = true)
+	    const Scope& scope, TArray<Id>& ids, const bool shouldShrink = true)
 	{
-		ExcludeIdsWithoutStable(&access.template AssurePool<const C>(), ids, shouldShrink);
+		ExcludeIdsWithoutStable(&scope.template AssurePool<const Component>(), ids, shouldShrink);
 	}
-	template<typename... C, typename AccessType>
-	void ExcludeIdsWithoutStable(const AccessType& access, TArray<Id>& ids,
-	    const bool shouldShrink = true) requires(sizeof...(C) > 1)
+	template<typename... Component, typename Scope>
+	void ExcludeIdsWithoutStable(const Scope& scope, TArray<Id>& ids,
+	    const bool shouldShrink = true) requires(sizeof...(Component) > 1)
 	{
-		(ExcludeIdsWithoutStable<C>(access, ids, shouldShrink), ...);
+		(ExcludeIdsWithoutStable<Component>(scope, ids, shouldShrink), ...);
 	}
 
 	/**
 	 * Remove ids that are invalid.
 	 *
-	 * @param access
+	 * @param scope
 	 * @param ids array that will be modified
 	 * @param shouldShrink if true, the ids array will be shrink at the end
 	 * @see ExcludeIdsInvalidStable()
 	 */
-	template<typename AccessType>
-	void ExcludeIdsInvalid(
-	    const AccessType& access, TArray<Id>& ids, const bool shouldShrink = true)
+	template<typename Scope>
+	void ExcludeIdsInvalid(const Scope& scope, TArray<Id>& ids, const bool shouldShrink = true)
 	{
 		ids.RemoveIfSwap(
-		    [&access](Id id) {
-			return !access.IsValid(id);
+		    [&scope](Id id) {
+			return !scope.IsValid(id);
 		    },
 		    shouldShrink);
 	}
@@ -1987,55 +2004,55 @@ namespace p
 	/**
 	 * Remove ids that are invalid. Guarantees order.
 	 *
-	 * @param access
+	 * @param scope
 	 * @param ids array that will be modified
 	 * @param shouldShrink if true, the ids array will be shrink at the end
 	 * @see ExcludeIdsInvalid()
 	 */
-	template<typename AccessType>
+	template<typename Scope>
 	void ExcludeIdsInvalidStable(
-	    const AccessType& access, TArray<Id>& ids, const bool shouldShrink = true)
+	    const Scope& scope, TArray<Id>& ids, const bool shouldShrink = true)
 	{
 		ids.RemoveIf(
-		    [&access](Id id) {
-			return !access.IsValid(id);
+		    [&scope](Id id) {
+			return !scope.IsValid(id);
 		    },
 		    shouldShrink);
 	}
 
 
 	/** Find ids containing a component from a list 'source' into 'results'. */
-	template<typename C, typename AccessType>
-	void FindIdsWith(const AccessType& access, const TView<Id>& source, TArray<Id>& results)
+	template<typename Component, typename Scope>
+	void FindIdsWith(const Scope& scope, const TView<Id>& source, TArray<Id>& results)
 	{
-		FindIdsWith(&access.template AssurePool<const C>(), source, results);
+		FindIdsWith(&scope.template AssurePool<const Component>(), source, results);
 	}
-	template<typename... C, typename AccessType>
-	void FindIdsWith(const AccessType& access, const TView<Id>& source, TArray<Id>& results)
-	    requires(sizeof...(C) > 1)
+	template<typename... Component, typename Scope>
+	void FindIdsWith(const Scope& scope, const TView<Id>& source, TArray<Id>& results)
+	    requires(sizeof...(Component) > 1)
 	{
-		FindIdsWith({&access.template AssurePool<const C>()...}, source, results);
+		FindIdsWith({&scope.template AssurePool<const Component>()...}, source, results);
 	}
 
-	template<typename... C, typename AccessType>
-	TArray<Id> FindIdsWith(const AccessType& access, const TView<Id>& source)
+	template<typename... Component, typename Scope>
+	TArray<Id> FindIdsWith(const Scope& scope, const TView<Id>& source)
 	{
 		TArray<Id> results;
-		FindIdsWith<C...>(access, source, results);
+		FindIdsWith<Component...>(scope, source, results);
 		return Move(results);
 	}
 
 	/** Find ids NOT containing a component from a list 'source' into 'results'. */
-	template<typename C, typename AccessType>
-	void FindIdsWithout(const AccessType& access, const TArray<Id>& source, TArray<Id>& results)
+	template<typename Component, typename Scope>
+	void FindIdsWithout(const Scope& scope, const TArray<Id>& source, TArray<Id>& results)
 	{
-		FindIdsWithout(&access.template AssurePool<const C>(), source, results);
+		FindIdsWithout(&scope.template AssurePool<const Component>(), source, results);
 	}
-	template<typename C, typename AccessType>
-	TArray<Id> FindIdsWithout(const AccessType& access, const TArray<Id>& source)
+	template<typename Component, typename Scope>
+	TArray<Id> FindIdsWithout(const Scope& scope, const TArray<Id>& source)
 	{
 		TArray<Id> results;
-		FindIdsWithout<C>(access, source, results);
+		FindIdsWithout<Component>(scope, source, results);
 		return Move(results);
 	}
 
@@ -2043,18 +2060,18 @@ namespace p
 	 * Find and remove ids containing a component from list 'source' into 'results'.
 	 * Does not guarantee order.
 	 */
-	template<typename C, typename AccessType>
-	void ExtractIdsWith(const AccessType& access, TArray<Id>& source, TArray<Id>& results,
-	    const bool shouldShrink = true)
+	template<typename Component, typename Scope>
+	void ExtractIdsWith(
+	    const Scope& scope, TArray<Id>& source, TArray<Id>& results, const bool shouldShrink = true)
 	{
-		ExtractIdsWith(&access.template AssurePool<const C>(), source, results);
+		ExtractIdsWith(&scope.template AssurePool<const Component>(), source, results);
 	}
-	template<typename C, typename AccessType>
+	template<typename Component, typename Scope>
 	TArray<Id> ExtractIdsWith(
-	    const AccessType& access, TArray<Id>& source, const bool shouldShrink = true)
+	    const Scope& scope, TArray<Id>& source, const bool shouldShrink = true)
 	{
 		TArray<Id> results;
-		ExtractIdsWith<C>(access, source, results);
+		ExtractIdsWith<Component>(scope, source, results);
 		return Move(results);
 	}
 
@@ -2062,18 +2079,18 @@ namespace p
 	 * Find and remove ids containing a component from list 'source' into 'results'.
 	 * Guarantees order.
 	 */
-	template<typename C, typename AccessType>
-	void ExtractIdsWithStable(const AccessType& access, TArray<Id>& source, TArray<Id>& results,
-	    const bool shouldShrink = true)
+	template<typename Component, typename Scope>
+	void ExtractIdsWithStable(
+	    const Scope& scope, TArray<Id>& source, TArray<Id>& results, const bool shouldShrink = true)
 	{
-		ExtractIdsWithStable(&access.template AssurePool<const C>(), source, results);
+		ExtractIdsWithStable(&scope.template AssurePool<const Component>(), source, results);
 	}
-	template<typename C, typename AccessType>
+	template<typename Component, typename Scope>
 	TArray<Id> ExtractIdsWithStable(
-	    const AccessType& access, TArray<Id>& source, const bool shouldShrink = true)
+	    const Scope& scope, TArray<Id>& source, const bool shouldShrink = true)
 	{
 		TArray<Id> results;
-		ExtractIdsWithStable<C>(access, source, results);
+		ExtractIdsWithStable<Component>(scope, source, results);
 		return Move(results);
 	}
 
@@ -2081,18 +2098,18 @@ namespace p
 	 * Find and remove ids containing a component from list 'source' into 'results'.
 	 * Does not guarantee order.
 	 */
-	template<typename C, typename AccessType>
-	void ExtractIdsWithout(const AccessType& access, TArray<Id>& source, TArray<Id>& results,
-	    const bool shouldShrink = true)
+	template<typename Component, typename Scope>
+	void ExtractIdsWithout(
+	    const Scope& scope, TArray<Id>& source, TArray<Id>& results, const bool shouldShrink = true)
 	{
-		ExtractIdsWithout(&access.template AssurePool<const C>(), source, results);
+		ExtractIdsWithout(&scope.template AssurePool<const Component>(), source, results);
 	}
-	template<typename C, typename AccessType>
+	template<typename Component, typename Scope>
 	TArray<Id> ExtractIdsWithout(
-	    const AccessType& access, TArray<Id>& source, const bool shouldShrink = true)
+	    const Scope& scope, TArray<Id>& source, const bool shouldShrink = true)
 	{
 		TArray<Id> results;
-		ExtractIdsWithout<C>(access, source, results);
+		ExtractIdsWithout<Component>(scope, source, results);
 		return Move(results);
 	}
 
@@ -2100,18 +2117,18 @@ namespace p
 	 * Find and remove ids not containing a component from list 'source' into 'results'.
 	 * Guarantees order.
 	 */
-	template<typename C, typename AccessType>
-	void ExtractIdsWithoutStable(const AccessType& access, TArray<Id>& source, TArray<Id>& results,
-	    const bool shouldShrink = true)
+	template<typename Component, typename Scope>
+	void ExtractIdsWithoutStable(
+	    const Scope& scope, TArray<Id>& source, TArray<Id>& results, const bool shouldShrink = true)
 	{
-		ExtractIdsWithoutStable(&access.template AssurePool<const C>(), source, results);
+		ExtractIdsWithoutStable(&scope.template AssurePool<const Component>(), source, results);
 	}
-	template<typename C, typename AccessType>
+	template<typename Component, typename Scope>
 	TArray<Id> ExtractIdsWithoutStable(
-	    const AccessType& access, TArray<Id>& source, const bool shouldShrink = true)
+	    const Scope& scope, TArray<Id>& source, const bool shouldShrink = true)
 	{
 		TArray<Id> results;
-		ExtractIdsWithoutStable<C>(access, source, results);
+		ExtractIdsWithoutStable<Component>(scope, source, results);
 		return Move(results);
 	}
 
@@ -2119,29 +2136,29 @@ namespace p
 	/**
 	 * Find all ids containing all of the components
 	 *
-	 * @param access from where to access pools
+	 * @param scope from where to scope pools
 	 * @param ids array where matching ids will be added
 	 * @see FindAllIdsWithAny()
 	 */
-	template<typename... C, typename AccessType>
-	void FindAllIdsWith(const AccessType& access, TArray<Id>& ids) requires(sizeof...(C) >= 1)
+	template<typename... Component, typename Scope>
+	void FindAllIdsWith(const Scope& scope, TArray<Id>& ids) requires(sizeof...(Component) >= 1)
 	{
-		FindAllIdsWith({access.template GetPool<const C>()...}, ids);
+		FindAllIdsWith({scope.template GetPool<const Component>()...}, ids);
 	}
 
 
 	/**
 	 * Find all ids containing all of the components
 	 *
-	 * @param access from where to access pools
+	 * @param scope from where to scope pools
 	 * @return ids array with matching ids
 	 * @see FindAllIdsWithAny()
 	 */
-	template<typename... C, typename AccessType>
-	TArray<Id> FindAllIdsWith(const AccessType& access) requires(sizeof...(C) >= 1)
+	template<typename... Component, typename Scope>
+	TArray<Id> FindAllIdsWith(const Scope& scope) requires(sizeof...(Component) >= 1)
 	{
 		TArray<Id> ids;
-		FindAllIdsWith<C...>(access, ids);
+		FindAllIdsWith<Component...>(scope, ids);
 		return Move(ids);
 	}
 
@@ -2149,44 +2166,44 @@ namespace p
 	 * Find all ids containing any of the components.
 	 * Includes possible duplicates
 	 *
-	 * @param access from where to access pools
+	 * @param scope from where to scope pools
 	 * @param ids array where matching ids will be added
 	 * @see FindAllIdsWith()
 	 */
-	template<typename... C, typename AccessType>
-	void FindAllIdsWithAny(const AccessType& access, TArray<Id>& ids) requires(sizeof...(C) >= 1)
+	template<typename... Component, typename Scope>
+	void FindAllIdsWithAny(const Scope& scope, TArray<Id>& ids) requires(sizeof...(Component) >= 1)
 	{
-		FindAllIdsWithAny({access.template GetPool<const C>()...}, ids);
+		FindAllIdsWithAny({scope.template GetPool<const Component>()...}, ids);
 	}
 
 	/**
 	 * Find all ids containing any of the components.
 	 * Prevents duplicates
 	 *
-	 * @param access from where to access pools
+	 * @param scope from where to scope pools
 	 * @param ids array where matching ids will be added
 	 * @see FindAllIdsWithAnyUnique()
 	 */
-	template<typename... C, typename AccessType>
-	void FindAllIdsWithAnyUnique(const AccessType& access, TArray<Id>& ids)
-	    requires(sizeof...(C) >= 1)
+	template<typename... Component, typename Scope>
+	void FindAllIdsWithAnyUnique(const Scope& scope, TArray<Id>& ids)
+	    requires(sizeof...(Component) >= 1)
 	{
-		FindAllIdsWithAnyUnique({access.template GetPool<const C>()...}, ids);
+		FindAllIdsWithAnyUnique({scope.template GetPool<const Component>()...}, ids);
 	}
 
 	/**
 	 * Find all ids containing any of the components.
 	 * Includes possible duplicates
 	 *
-	 * @param access from where to access pools
+	 * @param scope from where to scope pools
 	 * @return ids array with matching ids
 	 * @see FindAllIdsWith()
 	 */
-	template<typename... C, typename AccessType>
-	TArray<Id> FindAllIdsWithAny(const AccessType& access) requires(sizeof...(C) >= 1)
+	template<typename... Component, typename Scope>
+	TArray<Id> FindAllIdsWithAny(const Scope& scope) requires(sizeof...(Component) >= 1)
 	{
 		TArray<Id> ids;
-		FindAllIdsWithAny<C...>(access, ids);
+		FindAllIdsWithAny<Component...>(scope, ids);
 		return Move(ids);
 	}
 
@@ -2194,22 +2211,22 @@ namespace p
 	 * Find all ids containing any of the components.
 	 * Prevents duplicates
 	 *
-	 * @param access from where to access pools
+	 * @param scope from where to scope pools
 	 * @return ids array with matching ids
 	 * @see FindAllIdsWithAny()
 	 */
-	template<typename... C, typename AccessType>
-	TArray<Id> FindAllIdsWithAnyUnique(const AccessType& access) requires(sizeof...(C) >= 1)
+	template<typename... Component, typename Scope>
+	TArray<Id> FindAllIdsWithAnyUnique(const Scope& scope) requires(sizeof...(Component) >= 1)
 	{
 		TArray<Id> ids;
-		FindAllIdsWithAnyUnique<C...>(access, ids);
+		FindAllIdsWithAnyUnique<Component...>(scope, ids);
 		return Move(ids);
 	}
 
-	template<typename... C, typename AccessType>
-	Id GetFirstIdWith(const AccessType& access)
+	template<typename... Component, typename Scope>
+	Id GetFirstIdWith(const Scope& scope)
 	{
-		return GetFirstIdWith({access.template GetPool<const C>()...});
+		return GetFirstIdWith({scope.template GetPool<const Component>()...});
 	}
 #pragma endregion Filtering
 
@@ -2220,12 +2237,12 @@ namespace p
 #pragma region Editing
 
 	// Create
-	P_API Id AddId(EntityContext& ctx);
-	P_API void AddId(EntityContext& ctx, TView<Id> Ids);
+	P_API Id AddId(IdContext& ctx);
+	P_API void AddId(IdContext& ctx, TView<Id> Ids);
 
 	// Remove
-	P_API bool RmId(EntityContext& ctx, TView<const Id> ids, RmIdFlags flags = RmIdFlags::None);
-	P_API bool FlushDeferredRemovals(EntityContext& ctx);
+	P_API bool RmId(IdContext& ctx, TView<const Id> ids, RmIdFlags flags = RmIdFlags::None);
+	P_API bool FlushDeferredRemovals(IdContext& ctx);
 #pragma endregion Editing
 
 
@@ -2236,23 +2253,23 @@ namespace p
 
 	// Link a list of nodes at the end of the parent children list
 	P_API void AttachId(
-	    TAccessRef<TWrite<CChild>, TWrite<CParent>> access, Id parent, TView<const Id> children);
+	    TIdScopeRef<Writes<CChild, CParent>> scope, Id parent, TView<const Id> children);
 	// Link a list of nodes after prevChild in the list of children nodes
-	P_API void AttachIdAfter(TAccessRef<TWrite<CChild>, TWrite<CParent>> access, Id parent,
-	    TView<Id> childrenIds, Id prevChild);
-	P_API void TransferIdChildren(TAccessRef<TWrite<CChild>, TWrite<CParent>> access,
-	    TView<const Id> childrenIds, Id destination);
-	// TODO: void TransferAllChildren(Tree& ast, Id origin, Id destination);
-	P_API void DetachIdParent(TAccessRef<TWrite<CParent>, TWrite<CChild>> access,
+	P_API void AttachIdAfter(
+	    TIdScopeRef<Writes<CChild, CParent>> scope, Id parent, TView<Id> childrenIds, Id prevChild);
+	P_API void TransferIdChildren(
+	    TIdScopeRef<Writes<CChild, CParent>> scope, TView<const Id> childrenIds, Id destination);
+	// TODO: void TransferAllChildren(IdContext& context, Id origin, Id destination);
+	P_API void DetachIdParent(TIdScopeRef<Writes<CParent, CChild>> scope,
 	    TView<const Id> childrenIds, bool keepComponents);
-	P_API void DetachIdChildren(TAccessRef<TWrite<CParent>, TWrite<CChild>> access,
-	    TView<const Id> parents, bool keepComponents = false);
+	P_API void DetachIdChildren(TIdScopeRef<Writes<CParent, CChild>> scope, TView<const Id> parents,
+	    bool keepComponents = false);
 
 	/** Obtain direct children ids from the provided parent Id. Examples:
 	 * - Children of A (where A->B->C) is B.
 	 * - Children of A (where A->B, A->C) are B and C.
 	 */
-	P_API const TArray<Id>* GetIdChildren(TAccessRef<CParent> access, Id node);
+	P_API const TArray<Id>* GetIdChildren(TIdScopeRef<CParent> scope, Id node);
 
 	/** Obtain direct children ids from the provided parent Ids. Examples:
 	 * - Children of A (where A->B->C) is B.
@@ -2260,7 +2277,7 @@ namespace p
 	 * - Children of A and B (where A->B->C) are B, C.
 	 */
 	P_API void GetIdChildren(
-	    TAccessRef<CParent> access, TView<const Id> nodes, TArray<Id>& outChildrenIds);
+	    TIdScopeRef<CParent> scope, TView<const Id> nodes, TArray<Id>& outChildrenIds);
 
 	/** Obtain all children ids from the provided parent Ids. Examples:
 	 * - All children of A (where A->B->C) are B and C.
@@ -2268,25 +2285,25 @@ namespace p
 	 * - All children of A and B (where A->B->C->D) are B, C, D, C, D (duplicates are not
 	 * handled).
 	 */
-	P_API void GetAllIdChildren(TAccessRef<CParent> access, TView<const Id> parentIds,
+	P_API void GetAllIdChildren(TIdScopeRef<CParent> scope, TView<const Id> parentIds,
 	    TArray<Id>& outChildrenIds, u32 depth = 1);
 
-	P_API Id GetIdParent(TAccessRef<CChild> access, Id childId);
+	P_API Id GetIdParent(TIdScopeRef<CChild> scope, Id childId);
 	P_API void GetIdParent(
-	    TAccessRef<CChild> access, TView<const Id> childrenIds, TArray<Id>& outParents);
+	    TIdScopeRef<CChild> scope, TView<const Id> childrenIds, TArray<Id>& outParents);
 	P_API void GetAllIdParents(
-	    TAccessRef<CChild> access, TView<const Id> childrenIds, TArray<Id>& outParents);
+	    TIdScopeRef<CChild> scope, TView<const Id> childrenIds, TArray<Id>& outParents);
 
 	/**
 	 * Find a parent id matching a delegate
 	 */
-	P_API Id FindIdParent(TAccessRef<CChild> access, Id child, const TFunction<bool(Id)>& callback);
-	P_API void FindIdParents(TAccessRef<CChild> access, TView<const Id> childrenIds,
+	P_API Id FindIdParent(TIdScopeRef<CChild> scope, Id child, const TFunction<bool(Id)>& callback);
+	P_API void FindIdParents(TIdScopeRef<CChild> scope, TView<const Id> childrenIds,
 	    TArray<Id>& outParents, const TFunction<bool(Id)>& callback);
 
-	// void Copy(Tree& ast, t TArray<Id>& nodes, TArray<Id>& outNewNodes);
-	// void CopyDeep(Tree& ast, const TArray<Id>& rootNodes, TArray<Id>& outNewRootNodes);
-	// void CopyAndTransferAllChildrenDeep(Tree& ast, Id root, Id otherRoot);
+	// void Copy(IdContext& context, t TArray<Id>& nodes, TArray<Id>& outNewNodes);
+	// void CopyDeep(IdContext& context, const TArray<Id>& rootNodes, TArray<Id>& outNewRootNodes);
+	// void CopyAndTransferAllChildrenDeep(IdContext& context, Id root, Id otherRoot);
 
 	/**
 	 * Iterates children nodes making sure child->parent links are correct or fixed
@@ -2295,7 +2312,7 @@ namespace p
 	 * @parents: where to look for children to fix up
 	 * @return true if an incorrect link was found and fixed
 	 */
-	P_API bool FixParentIdLinks(TAccessRef<TWrite<CChild>, CParent> access, TView<Id> parents);
+	P_API bool FixParentIdLinks(TIdScopeRef<Writes<CChild>, CParent> scope, TView<Id> parents);
 
 	/**
 	 * Iterates children nodes looking for invalid child->parent links
@@ -2304,9 +2321,9 @@ namespace p
 	 * @parents: where to look for children
 	 * @return true if an incorrect link was found
 	 */
-	P_API bool ValidateParentIdLinks(TAccessRef<CChild, CParent> access, TView<Id> parents);
+	P_API bool ValidateParentIdLinks(TIdScopeRef<CChild, CParent> scope, TView<Id> parents);
 
-	P_API void GetRootIds(TAccessRef<CChild, CParent> access, TArray<Id>& outRoots);
+	P_API void GetRootIds(TIdScopeRef<CChild, CParent> scope, TArray<Id>& outRoots);
 #pragma endregion Hierarchy
 
 
@@ -2352,7 +2369,7 @@ namespace p
 				BeginObject();
 				for (i32 i = 0; i < ids.Size(); ++i)
 				{
-					const Id node = ids[i];
+					const Id id = ids[i];
 					key.clear();
 					Strings::FormatTo(key, "{}", i);
 
@@ -2360,12 +2377,12 @@ namespace p
 					{
 						if constexpr (!IsEmpty<T>)
 						{
-							T& comp = pool.GetOrAdd(node);
+							T& comp = pool.Has(id) ? pool.Get(id) : pool.Add(id);
 							Serialize(comp);
 						}
 						else
 						{
-							pool.Add(node);
+							pool.Add(id);
 						}
 						Leave();
 					}
@@ -2375,7 +2392,8 @@ namespace p
 			{
 				if constexpr (!IsEmpty<T>)
 				{
-					T& comp = pool.GetOrAdd(ids[0]);
+					const Id id = ids[0];
+					T& comp     = pool.Has(id) ? pool.Get(id) : pool.Add(id);
 					Serialize(comp);
 				}
 				else
@@ -2390,23 +2408,23 @@ namespace p
 	template<typename T>
 	inline void EntityWriter::SerializePool()
 	{
-		TArray<TPair<i32, Id>> componentIds;    // TODO: Make sure this is needed
+		TArray<TPair<i32, Id>> typeIds;    // TODO: Make sure this is needed
 
 		auto* pool = context.GetPool<const T>();
 		if (pool)
 		{
-			componentIds.Reserve(Min(i32(pool->Size()), ids.Size()));
+			typeIds.Reserve(Min(i32(pool->Size()), ids.Size()));
 			for (i32 i = 0; i < ids.Size(); ++i)
 			{
 				const Id id = ids[i];
 				if (pool->Has(id))
 				{
-					componentIds.Add({i, id});
+					typeIds.Add({i, id});
 				}
 			}
 		}
 
-		if (componentIds.IsEmpty())
+		if (typeIds.IsEmpty())
 		{
 			return;
 		}
@@ -2420,7 +2438,7 @@ namespace p
 			{
 				String key;
 				BeginObject();
-				for (auto id : componentIds)
+				for (auto id : typeIds)
 				{
 					key.clear();
 					Strings::FormatTo(key, "{}", id.first);
@@ -2443,7 +2461,7 @@ namespace p
 				}
 				else
 				{
-					Serialize(pool->Get(componentIds.First().second));
+					Serialize(pool->Get(typeIds.First().second));
 				}
 			}
 			Leave();
@@ -2453,7 +2471,7 @@ namespace p
 
 
 	template<typename T>
-	inline TPool<Mut<T>>& EntityContext::AssurePool() const
+	inline TPool<Mut<T>>& IdContext::AssurePool() const
 	{
 		const TypeId componentId = RegisterTypeId<Mut<T>>();
 
@@ -2475,17 +2493,17 @@ namespace p
 	}
 
 	template<typename T>
-	inline PoolInstance EntityContext::CreatePoolInstance() const
+	inline PoolInstance IdContext::CreatePoolInstance() const
 	{
 		constexpr TypeId componentId = GetTypeId<Mut<T>>();
 
-		auto& self = const_cast<EntityContext&>(*this);
+		auto& self = const_cast<IdContext&>(*this);
 		PoolInstance instance{componentId, MakeUnique<TPool<Mut<T>>>(self)};
 		return Move(instance);
 	}
 
 	template<typename Static>
-	inline Static& EntityContext::SetStatic()
+	inline Static& IdContext::SetStatic()
 	{
 		OwnPtr& ptr = FindOrAddStaticPtr(statics, GetTypeId<Static>());
 		ptr         = MakeOwned<Static>();
@@ -2493,7 +2511,7 @@ namespace p
 	}
 
 	template<typename Static>
-	inline Static& EntityContext::SetStatic(Static&& value)
+	inline Static& IdContext::SetStatic(Static&& value)
 	{
 		OwnPtr& ptr = FindOrAddStaticPtr(statics, GetTypeId<Static>());
 		ptr         = MakeOwned<Static>(p::Forward<Static>(value));
@@ -2501,7 +2519,7 @@ namespace p
 	}
 
 	template<typename Static>
-	inline Static& EntityContext::SetStatic(const Static& value)
+	inline Static& IdContext::SetStatic(const Static& value)
 	{
 		OwnPtr& ptr = FindOrAddStaticPtr(statics, GetTypeId<Static>());
 		ptr         = MakeOwned<Static>(value);
@@ -2509,7 +2527,7 @@ namespace p
 	}
 
 	template<typename Static>
-	inline Static& EntityContext::GetOrSetStatic()
+	inline Static& IdContext::GetOrSetStatic()
 	{
 		bool bAdded = false;
 		OwnPtr& ptr = FindOrAddStaticPtr(statics, GetTypeId<Static>(), &bAdded);
@@ -2521,7 +2539,7 @@ namespace p
 	}
 
 	template<typename Static>
-	inline Static& EntityContext::GetOrSetStatic(Static&& value)
+	inline Static& IdContext::GetOrSetStatic(Static&& value)
 	{
 		bool bAdded = false;
 		OwnPtr& ptr = FindOrAddStaticPtr(statics, GetTypeId<Static>(), &bAdded);
@@ -2533,7 +2551,7 @@ namespace p
 	}
 
 	template<typename Static>
-	inline Static& EntityContext::GetOrSetStatic(const Static& value)
+	inline Static& IdContext::GetOrSetStatic(const Static& value)
 	{
 		bool bAdded = false;
 		OwnPtr& ptr = FindOrAddStaticPtr(statics, GetTypeId<Static>(), &bAdded);
diff --git a/Include/PipeECSFwd.h b/Include/PipeECSFwd.h
index 41df992f..ccb25959 100644
--- a/Include/PipeECSFwd.h
+++ b/Include/PipeECSFwd.h
@@ -25,23 +25,17 @@ namespace p::ecs
 
 
 	struct SortLessStatics;
-	struct EntityContext;
+	struct IdContext;
+
+	template<typename... T>
+	struct TTypeList;    // TODO: Move to a TemplatesFwd header
+
+	struct IdScope;
 
-	enum class AccessMode : u8;
-	struct TypeAccess;
-	template<typename T, AccessMode inMode>
-	struct TTypeAccess;
-	template<typename T>
-	struct TRead;
-	template<typename T>
-	struct TWrite;
-	template<typename T>
-	struct TTypeAccessInfo;
 	template<typename... T>
-	struct TAccess;
+	struct TIdScope;
 	template<typename... T>
-	using TAccessRef = const TAccess<T...>&;
-	struct Access;
+	using TIdScopeRef = const TIdScope<T...>&;
 
 	struct CChild;
 	struct CParent;
diff --git a/Include/PipeReflect.h b/Include/PipeReflect.h
index 61e3b51e..de637773 100644
--- a/Include/PipeReflect.h
+++ b/Include/PipeReflect.h
@@ -198,8 +198,17 @@ namespace p
 		TF_Object    = 1 << 4,
 		TF_Container = 1 << 6,
 
-		TF_ECS_AutoModify = 1 << 7    // -> In ECS, should this type be marked modified
-		                              // automatically when added, written or removed?
+		// -> In ECS, should this type's last value be stored in the CMdfd component before being
+		// removed?
+		TF_ECS_StoreLastModified = 1 << 7,
+		// -> In ECS, should this type be marked modified automatically on add?
+		TF_ECS_ModifyOnAdd = 1 << 8,
+		// -> In ECS, should this type be marked modified automatically on get?
+		TF_ECS_ModifyOnGet = 1 << 9,
+		// -> In ECS, should this type be marked modified automatically on remove?
+		TF_ECS_ModifyOnRm = 1 << 10,
+		// -> In ECS, should this type be marked modified automatically on add, get or remove?
+		TF_ECS_ModifyOnEdit = TF_ECS_ModifyOnAdd | TF_ECS_ModifyOnGet | TF_ECS_ModifyOnRm,
 
 		// Any other flags up to 64 bytes are available to the user
 	};
@@ -352,7 +361,7 @@ namespace p
 	{
 		if constexpr (HasStaticFlags<T>())
 		{
-			return (T::staticFlags & flags) == flags;
+			return HasAllFlags(T::staticFlags, flags);
 		}
 		return false;
 	}
@@ -361,7 +370,7 @@ namespace p
 	{
 		if constexpr (HasStaticFlags<T>())
 		{
-			return (T::staticFlags & flags) > 0;
+			return HasAnyFlags(T::staticFlags, flags);
 		}
 		return false;
 	}
diff --git a/Src/PipeECS.cpp b/Src/PipeECS.cpp
index 82dc04fa..e9a7347a 100644
--- a/Src/PipeECS.cpp
+++ b/Src/PipeECS.cpp
@@ -6,10 +6,12 @@
 #include "Pipe/Core/Limits.h"
 #include "Pipe/Core/Set.h"
 
+#include <mutex>
+
 
 namespace p
 {
-	Id IdFromString(String str, EntityContext* context)
+	Id IdFromString(String str, IdContext* context)
 	{
 		if (str == "NoId")
 		{
@@ -255,7 +257,7 @@ namespace p
 		return ids;
 	}
 
-	EntityContext& EntityReader::GetContext()
+	IdContext& EntityReader::GetContext()
 	{
 		return context;
 	}
@@ -326,7 +328,7 @@ namespace p
 
 	void EntityWriter::RemoveIgnoredEntities(TArray<Id>& entities)
 	{
-		TAccess<CNotSerialized> access{context};
+		TIdScope<CNotSerialized> access{context};
 		for (i32 i = 0; i < entities.Size(); ++i)
 		{
 			if (access.Has<CNotSerialized>(entities[i]))
@@ -547,7 +549,7 @@ namespace p
 		};
 	}
 
-	TPool<CRemoved>::TPool(p::EntityContext& ctx, Arena& arena)
+	TPool<CRemoved>::TPool(p::IdContext& ctx, Arena& arena)
 	    : IPool(p::GetTypeId<CRemoved>()), idRegistry{&ctx.GetIdRegistry()}
 	{}
 
@@ -638,33 +640,33 @@ namespace p
 	}
 
 
-	EntityContext::EntityContext()
+	IdContext::IdContext()
 	{
 		AssurePool<CRemoved>();
 	}
 
-	EntityContext::EntityContext(const EntityContext& other) noexcept
+	IdContext::IdContext(const IdContext& other) noexcept
 	{
 		CopyFrom(other);
 	}
-	EntityContext::EntityContext(EntityContext&& other) noexcept
+	IdContext::IdContext(IdContext&& other) noexcept
 	{
 		MoveFrom(Move(other));
 	}
-	EntityContext& EntityContext::operator=(const EntityContext& other) noexcept
+	IdContext& IdContext::operator=(const IdContext& other) noexcept
 	{
 		Reset();
 		CopyFrom(other);
 		return *this;
 	}
-	EntityContext& EntityContext::operator=(EntityContext&& other) noexcept
+	IdContext& IdContext::operator=(IdContext&& other) noexcept
 	{
 		Reset();
 		MoveFrom(Move(other));
 		return *this;
 	}
 
-	void* EntityContext::AddDefault(TypeId typeId, Id id)
+	void* IdContext::AddByTypeId(TypeId typeId, Id id)
 	{
 		if (IPool* pool = GetPool(typeId))
 		{
@@ -673,7 +675,7 @@ namespace p
 		return nullptr;
 	}
 
-	void EntityContext::Remove(TypeId typeId, Id id)
+	void IdContext::RemoveByTypeId(TypeId typeId, Id id)
 	{
 		if (IPool* pool = GetPool(typeId))
 		{
@@ -681,15 +683,15 @@ namespace p
 		}
 	}
 
-	IPool* EntityContext::GetPool(TypeId componentId) const
+	IPool* IdContext::GetPool(TypeId componentId) const
 	{
 		const i32 index = pools.FindSorted(PoolInstance{componentId, {}});
 		return index != NO_INDEX ? pools[index].GetPool() : nullptr;
 	}
 
-	void EntityContext::GetPools(TView<const TypeId> componentIds, TArray<IPool*>& outPools) const
+	void IdContext::GetPools(TView<const TypeId> typeIds, TArray<IPool*>& outPools) const
 	{
-		for (const TypeId componentId : componentIds)
+		for (const TypeId componentId : typeIds)
 		{
 			const i32 index = pools.FindSorted(PoolInstance{componentId, {}});
 			if (index != NO_INDEX)
@@ -699,7 +701,7 @@ namespace p
 		}
 	}
 
-	void EntityContext::CopyFrom(const EntityContext& other)
+	void IdContext::CopyFrom(const IdContext& other)
 	{
 		// Copy entities
 		idRegistry = other.idRegistry;
@@ -719,7 +721,7 @@ namespace p
 		// TODO: Cache pools
 	}
 
-	void EntityContext::MoveFrom(EntityContext&& other)
+	void IdContext::MoveFrom(IdContext&& other)
 	{
 		idRegistry = Move(other.idRegistry);
 		pools      = Move(other.pools);
@@ -731,17 +733,17 @@ namespace p
 		// TODO: Cache pools
 	}
 
-	bool EntityContext::IsValid(Id id) const
+	bool IdContext::IsValid(Id id) const
 	{
 		return idRegistry.IsValid(id);
 	}
 
-	bool EntityContext::WasRemoved(Id id) const
+	bool IdContext::WasRemoved(Id id) const
 	{
 		return idRegistry.WasRemoved(id);
 	}
 
-	bool EntityContext::IsOrphan(const Id id) const
+	bool IdContext::IsOrphan(const Id id) const
 	{
 		for (const auto& instance : pools)
 		{
@@ -753,21 +755,21 @@ namespace p
 		return true;
 	}
 
-	void* EntityContext::TryGetStatic(TypeId typeId)
+	void* IdContext::TryGetStatic(TypeId typeId)
 	{
 		const i32 index = statics.FindSorted<TypeId, SortLessStatics>(typeId);
 		return index != NO_INDEX ? statics[index].Get() : nullptr;
 	}
-	const void* EntityContext::TryGetStatic(TypeId typeId) const
+	const void* IdContext::TryGetStatic(TypeId typeId) const
 	{
 		const i32 index = statics.FindSorted<TypeId, SortLessStatics>(typeId);
 		return index != NO_INDEX ? statics[index].Get() : nullptr;
 	}
-	bool EntityContext::HasStatic(TypeId typeId) const
+	bool IdContext::HasStatic(TypeId typeId) const
 	{
 		return statics.FindSorted<TypeId, SortLessStatics>(typeId) != NO_INDEX;
 	}
-	bool EntityContext::RemoveStatic(TypeId typeId)
+	bool IdContext::RemoveStatic(TypeId typeId)
 	{
 		const i32 index = statics.FindSorted<TypeId, SortLessStatics>(typeId);
 		if (index != NO_INDEX)
@@ -778,7 +780,7 @@ namespace p
 		return false;
 	}
 
-	void EntityContext::Reset(bool keepStatics)
+	void IdContext::Reset(bool keepStatics)
 	{
 		idRegistry = {};
 		pools.Clear();
@@ -788,7 +790,7 @@ namespace p
 		}
 	}
 
-	OwnPtr& EntityContext::FindOrAddStaticPtr(
+	OwnPtr& IdContext::FindOrAddStaticPtr(
 	    TArray<OwnPtr>& statics, const TypeId typeId, bool* bAdded)
 	{
 		i32 index = statics.LowerBound<TypeId, SortLessStatics>(typeId);
@@ -1100,7 +1102,7 @@ namespace p
 	}
 
 
-	void RemoveChildFromCParent(TAccessRef<TWrite<CParent>> access, Id parent, Id child)
+	void RemoveChildFromCParent(TIdScopeRef<Writes<CParent>> access, Id parent, Id child)
 	{
 		if (auto* cParent = access.TryGet<CParent>(parent))
 		{
@@ -1113,16 +1115,16 @@ namespace p
 	}
 
 
-	Id AddId(EntityContext& ctx)
+	Id AddId(IdContext& ctx)
 	{
 		return ctx.GetIdRegistry().Create();
 	}
-	void AddId(EntityContext& ctx, TView<Id> ids)
+	void AddId(IdContext& ctx, TView<Id> ids)
 	{
 		ctx.GetIdRegistry().Create(ids);
 	}
 
-	bool RmId(EntityContext& ctx, TView<const Id> ids, RmIdFlags flags)
+	bool RmId(IdContext& ctx, TView<const Id> ids, RmIdFlags flags)
 	{
 		TArray<Id> allIds;    // Only used when removing children. Here for scope purposes.
 		if (!HasFlag(flags, p::RmIdFlags::KeepChildren))
@@ -1147,7 +1149,7 @@ namespace p
 		}
 	}
 
-	bool FlushDeferredRemovals(EntityContext& ctx)
+	bool FlushDeferredRemovals(IdContext& ctx)
 	{
 		TView<Id> ids = ctx.GetIdRegistry().GetDeferredRemovals();
 		for (auto& pool : ctx.GetPools())
@@ -1158,8 +1160,7 @@ namespace p
 	}
 
 
-	void AttachId(
-	    TAccessRef<TWrite<CChild>, TWrite<CParent>> access, Id parent, TView<const Id> children)
+	void AttachId(TIdScopeRef<Writes<CChild, CParent>> access, Id parent, TView<const Id> children)
 	{
 		children.Each([&access, parent](Id childId) {
 			if (auto* cChild = access.TryGet<CChild>(childId))
@@ -1181,8 +1182,8 @@ namespace p
 		access.GetOrAdd<CParent>(parent).children.Append(children);
 	}
 
-	void AttachIdAfter(TAccessRef<TWrite<CChild>, TWrite<CParent>> access, Id parent,
-	    TView<Id> childrenIds, Id prevChild)
+	void AttachIdAfter(
+	    TIdScopeRef<Writes<CChild, CParent>> access, Id parent, TView<Id> childrenIds, Id prevChild)
 	{
 		childrenIds.Each([&access, parent](Id child) {
 			if (auto* cChild = access.TryGet<CChild>(child))
@@ -1205,15 +1206,15 @@ namespace p
 		childrenList.Insert(prevIndex, childrenIds);
 	}
 
-	void TransferIdChildren(TAccessRef<TWrite<CChild>, TWrite<CParent>> access,
-	    TView<const Id> childrenIds, Id destination)
+	void TransferIdChildren(
+	    TIdScopeRef<Writes<CChild, CParent>> access, TView<const Id> childrenIds, Id destination)
 	{
 		DetachIdParent(access, childrenIds, true);
 		AttachId(access, destination, childrenIds);
 	}
 
-	void DetachIdParent(TAccessRef<TWrite<CParent>, TWrite<CChild>> access,
-	    TView<const Id> childrenIds, bool keepComponents)
+	void DetachIdParent(TIdScopeRef<Writes<CParent, CChild>> access, TView<const Id> childrenIds,
+	    bool keepComponents)
 	{
 		TArray<Id> parents;
 		parents.Reserve(childrenIds.Size());
@@ -1275,8 +1276,8 @@ namespace p
 		}
 	}
 
-	void DetachIdChildren(TAccessRef<TWrite<CParent>, TWrite<CChild>> access,
-	    TView<const Id> parents, bool keepComponents)
+	void DetachIdChildren(
+	    TIdScopeRef<Writes<CParent, CChild>> access, TView<const Id> parents, bool keepComponents)
 	{
 		if (keepComponents)
 		{
@@ -1306,14 +1307,14 @@ namespace p
 		}
 	}
 
-	const TArray<Id>* GetIdChildren(TAccessRef<CParent> access, Id node)
+	const TArray<Id>* GetIdChildren(TIdScopeRef<CParent> access, Id node)
 	{
 		auto* cParent = access.TryGet<const CParent>(node);
 		return cParent ? &cParent->children : nullptr;
 	}
 
 	void GetIdChildren(
-	    TAccessRef<CParent> access, TView<const Id> parentIds, TArray<Id>& outChildrenIds)
+	    TIdScopeRef<CParent> access, TView<const Id> parentIds, TArray<Id>& outChildrenIds)
 	{
 		parentIds.Each([&access, &outChildrenIds](Id id) {
 			if (const auto* cParent = access.TryGet<const CParent>(id))
@@ -1323,7 +1324,7 @@ namespace p
 		});
 	}
 
-	void GetAllIdChildren(TAccessRef<CParent> access, TView<const Id> parentIds,
+	void GetAllIdChildren(TIdScopeRef<CParent> access, TView<const Id> parentIds,
 	    TArray<Id>& outChildrenIds, u32 depth)
 	{
 		P_Check(depth > 0);
@@ -1339,7 +1340,7 @@ namespace p
 		}
 	}
 
-	Id GetIdParent(TAccessRef<CChild> access, Id childId)
+	Id GetIdParent(TIdScopeRef<CChild> access, Id childId)
 	{
 		if (const auto* cChild = access.TryGet<const CChild>(childId))
 		{
@@ -1348,7 +1349,8 @@ namespace p
 		return NoId;
 	}
 
-	void GetIdParent(TAccessRef<CChild> access, TView<const Id> childrenIds, TArray<Id>& outParents)
+	void GetIdParent(
+	    TIdScopeRef<CChild> access, TView<const Id> childrenIds, TArray<Id>& outParents)
 	{
 		outParents.Clear(false);
 		for (Id childId : childrenIds)
@@ -1361,7 +1363,7 @@ namespace p
 		}
 	}
 	void GetAllIdParents(
-	    TAccessRef<CChild> access, TView<const Id> childrenIds, TArray<Id>& outParents)
+	    TIdScopeRef<CChild> access, TView<const Id> childrenIds, TArray<Id>& outParents)
 	{
 		outParents.Clear(false);
 
@@ -1377,7 +1379,7 @@ namespace p
 		}
 	}
 
-	Id FindIdParent(TAccessRef<CChild> access, Id childId, const TFunction<bool(Id)>& callback)
+	Id FindIdParent(TIdScopeRef<CChild> access, Id childId, const TFunction<bool(Id)>& callback)
 	{
 		while (!IsNone(childId))
 		{
@@ -1389,7 +1391,7 @@ namespace p
 		}
 		return NoId;
 	}
-	void FindIdParents(TAccessRef<CChild> access, TView<const Id> childrenIds,
+	void FindIdParents(TIdScopeRef<CChild> access, TView<const Id> childrenIds,
 	    TArray<Id>& outParentIds, const TFunction<bool(Id)>& callback)
 	{
 		outParentIds.Clear(false);
@@ -1419,7 +1421,7 @@ namespace p
 	}
 
 
-	bool FixParentIdLinks(TAccessRef<TWrite<CChild>, CParent> access, TView<Id> parents)
+	bool FixParentIdLinks(TIdScopeRef<Writes<CChild>, CParent> access, TView<Id> parents)
 	{
 		bool fixed = false;
 		for (Id parentId : parents)
@@ -1447,7 +1449,7 @@ namespace p
 		return fixed;
 	}
 
-	bool ValidateParentIdLinks(TAccessRef<CChild, CParent> access, TView<Id> parents)
+	bool ValidateParentIdLinks(TIdScopeRef<CChild, CParent> access, TView<Id> parents)
 	{
 		for (Id parentId : parents)
 		{
@@ -1466,7 +1468,7 @@ namespace p
 		return true;
 	}
 
-	void GetRootIds(TAccessRef<CChild, CParent> access, TArray<Id>& outRoots)
+	void GetRootIds(TIdScopeRef<CChild, CParent> access, TArray<Id>& outRoots)
 	{
 		outRoots = FindAllIdsWith<CParent>(access);
 		ExcludeIdsWith<CChild>(access, outRoots);
diff --git a/Tests/Containers/Arrays.spec.cpp b/Tests/Containers/Arrays.spec.cpp
index d48954f6..b69e0f8f 100644
--- a/Tests/Containers/Arrays.spec.cpp
+++ b/Tests/Containers/Arrays.spec.cpp
@@ -319,6 +319,7 @@ go_bandit([]() {
 				AssertThat(data[0], Equals(0));
 			});
 		});
+
 		describe("Append", []() {
 			it("Can append defaulted", [&]() {
 				TInlineArray<i32, 0> data;
@@ -384,6 +385,7 @@ go_bandit([]() {
 				AssertThat(data.Data(), Equals(data.GetInlineBuffer()));
 			});
 		});
+
 		describe("Assign", []() {
 			it("Can assign defaulted", [&]() {
 				TInlineArray<i32, 0> data;
@@ -449,6 +451,7 @@ go_bandit([]() {
 				AssertThat(data.Data(), Equals(data.GetInlineBuffer()));
 			});
 		});
+
 		describe("Insert", []() {
 			it("Can insert at empty", [&]() {
 				TInlineArray<i32, 0> data;
@@ -585,6 +588,7 @@ go_bandit([]() {
 				AssertThat(data[11], Equals(3));
 			});
 		});
+
 		describe("Remove", []() {
 			it("Can remove at index", []() {
 				TInlineArray<i32, 0> data{1, 2, 3, 4};
@@ -659,54 +663,54 @@ go_bandit([]() {
 				AssertThat(data.RemoveAtSwap(0, 2), Equals(true));    // Remove first
 				AssertThat(data, Equals(TInlineArray<i32, 0>{6}));
 			});
-		});
 
-		it("Can RemoveLast", [&]() {
-			TArray<i32> data{1, 4, 6};
-			data.RemoveLast();
-			AssertThat(data.Size(), Equals(2));
-			AssertThat(data[0], Equals(1));
-			AssertThat(data[1], Equals(4));
-			AssertThat(data.Capacity(), Equals(2));
-		});
+			it("Can RemoveLast", [&]() {
+				TArray<i32> data{1, 4, 6};
+				data.RemoveLast();
+				AssertThat(data.Size(), Equals(2));
+				AssertThat(data[0], Equals(1));
+				AssertThat(data[1], Equals(4));
+				AssertThat(data.Capacity(), Equals(2));
+			});
 
-		it("Can RemoveLast N", [&]() {
-			TArray<i32> dataA{1, 4, 6};
-			dataA.RemoveLast(2);
-			AssertThat(dataA.Size(), Equals(1));
-			AssertThat(dataA[0], Equals(1));
-			AssertThat(dataA.Capacity(), Equals(1));
-
-			TArray<i32> dataB{1, 4, 6};
-			dataB.RemoveLast(3);
-			AssertThat(dataB.Size(), Equals(0));
-			AssertThat(dataB.Capacity(), Equals(0));
-		});
+			it("Can RemoveLast N", [&]() {
+				TArray<i32> dataA{1, 4, 6};
+				dataA.RemoveLast(2);
+				AssertThat(dataA.Size(), Equals(1));
+				AssertThat(dataA[0], Equals(1));
+				AssertThat(dataA.Capacity(), Equals(1));
 
-		it("Can RemoveIf", [&]() {
-			TArray<i32> data{1, 4, 5, 6};
+				TArray<i32> dataB{1, 4, 6};
+				dataB.RemoveLast(3);
+				AssertThat(dataB.Size(), Equals(0));
+				AssertThat(dataB.Capacity(), Equals(0));
+			});
 
-			AssertThat(data.Size(), Equals(4));
+			it("Can RemoveIf", [&]() {
+				TArray<i32> data{1, 4, 5, 6};
 
-			data.RemoveIf([](i32 v) {
-				return v == 1 || v == 6;
+				AssertThat(data.Size(), Equals(4));
+
+				data.RemoveIf([](i32 v) {
+					return v == 1 || v == 6;
+				});
+				AssertThat(data.Size(), Equals(2));
+				AssertThat(data[0], Equals(4));
+				AssertThat(data[1], Equals(5));
 			});
-			AssertThat(data.Size(), Equals(2));
-			AssertThat(data[0], Equals(4));
-			AssertThat(data[1], Equals(5));
-		});
 
-		it("Can RemoveIfSwap", [&]() {
-			TArray<i32> data{1, 4, 5, 6};
+			it("Can RemoveIfSwap", [&]() {
+				TArray<i32> data{1, 4, 5, 6};
 
-			AssertThat(data.Size(), Equals(4));
+				AssertThat(data.Size(), Equals(4));
 
-			data.RemoveIfSwap([](i32 v) {
-				return v == 1 || v == 6;
+				data.RemoveIfSwap([](i32 v) {
+					return v == 1 || v == 6;
+				});
+				AssertThat(data.Size(), Equals(2));
+				AssertThat(data[0], Equals(5));
+				AssertThat(data[1], Equals(4));
 			});
-			AssertThat(data.Size(), Equals(2));
-			AssertThat(data[0], Equals(5));
-			AssertThat(data[1], Equals(4));
 		});
 
 		it("Can Sort", [&]() {
@@ -744,5 +748,34 @@ go_bandit([]() {
 			AssertThat(data.AddUniqueSorted(36), Equals(6));
 			AssertThat(data.Size(), Equals(7));
 		});
+
+		describe("Iterate", []() {
+			it("Can iterate empty", [&]() {
+				TInlineArray<i32, 5> data1{};
+				i32 counter = 0;
+				for (i32 v : data1)
+				{
+					++counter;
+				}
+				AssertThat(counter, Equals(0));
+				TArray<i32> data2{};
+				counter = 0;
+				for (i32 v : data2)
+				{
+					++counter;
+				}
+				AssertThat(counter, Equals(0));
+			});
+
+			it("Can iterate empty", [&]() {
+				TInlineArray<i32, 5> data{};
+				i32 counter = 0;
+				for (i32 v : data)
+				{
+					++counter;
+				}
+				AssertThat(counter, Equals(0));
+			});
+		});
 	});
 });
diff --git a/Tests/ECS/Access.spec.cpp b/Tests/ECS/Access.spec.cpp
deleted file mode 100644
index a4ef8efe..00000000
--- a/Tests/ECS/Access.spec.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2015-2026 Piperift. All Rights Reserved.
-
-#include <bandit/bandit.h>
-#include <PipeECS.h>
-
-
-using namespace snowhouse;
-using namespace bandit;
-using namespace p;
-
-
-struct TypeA
-{};
-struct TypeB
-{};
-
-
-go_bandit([]() {
-	describe("ECS.Access", []() {
-		describe("Templated", []() {
-			it("Can cache pools", [&]() {
-				EntityContext ctx;
-				TAccess<TWrite<TypeA>, TypeB> access{ctx};
-
-				AssertThat(access.GetPool<TypeA>(), Equals(ctx.GetPool<TypeA>()));
-				AssertThat(access.GetPool<const TypeA>(), Equals(ctx.GetPool<TypeA>()));
-				AssertThat(access.GetPool<const TypeB>(), Equals(ctx.GetPool<TypeB>()));
-			});
-
-			it("Can check if contained", [&]() {
-				EntityContext ctx;
-				TPool<TypeA>& pool = ctx.AssurePool<TypeA>();
-				TAccess<TWrite<TypeA>> access{ctx};
-				TAccess<TypeA> accessConst{ctx};
-				Id id = NoId;
-				AssertThat(access.Has<TypeA>(id), Is().False());
-				AssertThat(accessConst.Has<TypeA>(id), Is().False());
-
-				id = AddId(ctx);
-				AssertThat(access.Has<TypeA>(id), Is().False());
-				AssertThat(accessConst.Has<TypeA>(id), Is().False());
-
-				ctx.Add<TypeA>(id);
-				AssertThat(access.Has<TypeA>(id), Is().True());
-				AssertThat(accessConst.Has<TypeA>(id), Is().True());
-
-				TAccess<TypeA, TypeB> access2{ctx};
-				ctx.Add<TypeB>(id);
-				AssertThat(access2.Has<TypeB>(id), Is().True());
-			});
-
-			it("Can initialize superset", [&]() {
-				EntityContext ctx;
-				TPool<TypeA>& typePool = ctx.AssurePool<TypeA>();
-
-				TAccess<TWrite<TypeA>, TWrite<TypeB>> access1{ctx};
-				TAccess<TWrite<TypeA>> superset1{access1};
-				AssertThat(superset1.GetPool<TypeA>(), Equals(&typePool));
-
-				TAccess<TWrite<TypeA>, TWrite<TypeB>> access2{ctx};
-				TAccess<TypeA> superset2{access2};
-				AssertThat(superset2.GetPool<const TypeA>(), Equals(&typePool));
-
-				TAccess<TWrite<TypeA>, TWrite<TypeB>> access3{ctx};
-				TAccess<TypeA> superset3{access3};
-				AssertThat(superset1.GetPool<TypeA>(), Equals(&typePool));
-			});
-		});
-	});
-});
diff --git a/Tests/ECS/Components.spec.cpp b/Tests/ECS/Components.spec.cpp
index 24e57cde..c511ecc7 100644
--- a/Tests/ECS/Components.spec.cpp
+++ b/Tests/ECS/Components.spec.cpp
@@ -63,7 +63,7 @@ u32 TestComponent::destructed = 0;
 go_bandit([]() {
 	describe("ECS.Components", []() {
 		it("Can add one component", [&]() {
-			EntityContext ctx;
+			IdContext ctx;
 			Id id = AddId(ctx);
 			AssertThat(ctx.Has<EmptyComponent>(id), Is().False());
 			AssertThat(ctx.TryGet<EmptyComponent>(id), Equals(nullptr));
@@ -79,7 +79,7 @@ go_bandit([]() {
 		});
 
 		it("Can remove one component", [&]() {
-			EntityContext ctx;
+			IdContext ctx;
 			Id id = AddId(ctx);
 			ctx.Add<EmptyComponent, NonEmptyComponent>(id);
 
@@ -95,7 +95,7 @@ go_bandit([]() {
 		});
 
 		it("Can add many components", [&]() {
-			EntityContext ctx;
+			IdContext ctx;
 			TArray<Id> ids{3};
 			AddId(ctx, ids);
 			ctx.AddN(ids, NonEmptyComponent{2});
@@ -109,7 +109,7 @@ go_bandit([]() {
 		});
 
 		it("Can remove many components", [&]() {
-			EntityContext ctx;
+			IdContext ctx;
 			TArray<Id> ids{3};
 			AddId(ctx, ids);
 			ctx.AddN(ids, NonEmptyComponent{2});
@@ -135,7 +135,7 @@ go_bandit([]() {
 		});
 
 		it("Components are removed after node is deleted", [&]() {
-			EntityContext ctx;
+			IdContext ctx;
 			Id id = AddId(ctx);
 			ctx.Add<EmptyComponent, NonEmptyComponent>(id);
 
@@ -149,7 +149,7 @@ go_bandit([]() {
 		});
 
 		it("Components are removed after node is deleted (deferred)", [&]() {
-			EntityContext ctx;
+			IdContext ctx;
 			Id id = AddId(ctx);
 			ctx.Add<EmptyComponent, NonEmptyComponent>(id);
 
@@ -169,7 +169,7 @@ go_bandit([]() {
 		});
 
 		it("Components keep state when added", [&]() {
-			EntityContext ctx;
+			IdContext ctx;
 			Id id = AddId(ctx);
 			ctx.AddN(id, NonEmptyComponent{2});
 			AssertThat(ctx.TryGet<NonEmptyComponent>(id), !Equals(nullptr));
@@ -177,14 +177,14 @@ go_bandit([]() {
 		});
 
 		it("Can copy registry", []() {
-			EntityContext ctxa;
+			IdContext ctxa;
 
 			Id id = AddId(ctxa);
 			ctxa.Add<EmptyComponent, NonEmptyComponent>(id);
 			Id id2 = AddId(ctxa);
 			ctxa.AddN(id2, NonEmptyComponent{2});
 
-			EntityContext ctxb{ctxa};
+			IdContext ctxb{ctxa};
 			AssertThat(ctxb.Has<EmptyComponent>(id), Is().True());
 			AssertThat(ctxb.Has<NonEmptyComponent>(id), Is().True());
 			AssertThat(ctxb.TryGet<NonEmptyComponent>(id), !Equals(nullptr));
@@ -195,7 +195,7 @@ go_bandit([]() {
 		});
 
 		it("Can check components", [&]() {
-			EntityContext ctx;
+			IdContext ctx;
 			Id id = NoId;
 			AssertThat(ctx.Has<EmptyComponent>(id), Is().False());
 			AssertThat(ctx.Has<NonEmptyComponent>(id), Is().False());
@@ -213,7 +213,7 @@ go_bandit([]() {
 			NonEmptyComponent::destructed = 0;
 			TestComponent::destructed     = 0;
 
-			EntityContext ctx;
+			IdContext ctx;
 			TArray<Id> ids{3};
 			AddId(ctx, ids);
 			ctx.AddN(ids, NonEmptyComponent{2});
@@ -234,7 +234,7 @@ go_bandit([]() {
 		});
 
 		it("Components are removed with the entity", [&]() {
-			EntityContext ctx;
+			IdContext ctx;
 			Id id = AddId(ctx);
 			ctx.Add<EmptyComponent, NonEmptyComponent>(id);
 			RmId(ctx, id, p::RmIdFlags::Instant);
@@ -247,7 +247,7 @@ go_bandit([]() {
 		});
 
 		it("Components are removed with the entity (deferred)", [&]() {
-			EntityContext ctx;
+			IdContext ctx;
 			Id id = AddId(ctx);
 			ctx.Add<EmptyComponent, NonEmptyComponent>(id);
 			RmId(ctx, id);
@@ -266,7 +266,7 @@ go_bandit([]() {
 		});
 
 		it("Can access components on recicled entities", [&]() {
-			EntityContext ctx;
+			IdContext ctx;
 			Id id = AddId(ctx);
 			ctx.Add<EmptyComponent, NonEmptyComponent>(id);
 			RmId(ctx, id);
@@ -279,7 +279,7 @@ go_bandit([]() {
 		});
 
 		it("Can access CRemoved", [&]() {
-			EntityContext ctx;
+			IdContext ctx;
 			Id id = AddId(ctx);
 			ctx.Add<EmptyComponent, NonEmptyComponent>(id);
 			RmId(ctx, id);
diff --git a/Tests/ECS/ECS.spec.cpp b/Tests/ECS/ECS.spec.cpp
index 9eec9d05..5dbb4e91 100644
--- a/Tests/ECS/ECS.spec.cpp
+++ b/Tests/ECS/ECS.spec.cpp
@@ -19,88 +19,49 @@ struct ATypeB
 
 go_bandit([]() {
 	describe("ECS", []() {
-		it("Can copy tree", [&]() {
-			static EntityContext* ctxPtr = nullptr;
-			static bool calledAdd;
+		it("Can copy context", [&]() {
+			static IdContext* ctxPtr = nullptr;
 
-			EntityContext origin;
+			IdContext origin;
 			Id id = AddId(origin);
 
-			calledAdd = false;
-			ctxPtr    = &origin;
-			origin.OnAdd<ATypeA>().Bind([&origin](auto ids) {
-				for (Id id : ids)
-				{
-					AssertThat(origin.Has<ATypeA>(id), Equals(true));
-				}
-				AssertThat(ctxPtr, Equals(&origin));
-				calledAdd = true;
-			});
+			ctxPtr = &origin;
 			origin.Add<ATypeA>(id);
-			AssertThat(calledAdd, Equals(true));
 
-			EntityContext target{origin};
+			IdContext target{origin};
 			AssertThat(origin.IsValid(id), Equals(true));
 			AssertThat(origin.Has<ATypeA>(id), Equals(true));
 			AssertThat(target.IsValid(id), Equals(true));
 			AssertThat(target.Has<ATypeA>(id), Equals(true));
 
-			calledAdd = false;
-			ctxPtr    = &target;
-			target.OnAdd<ATypeB>().Bind([&target](auto ids) {
-				for (Id id : ids)
-				{
-					AssertThat(target.Has<ATypeB>(id), Equals(true));
-				}
-				AssertThat(ctxPtr, Equals(&target));
-				calledAdd = true;
-			});
+			ctxPtr = &target;
 			target.Add<ATypeB>(id);
-			AssertThat(calledAdd, Equals(true));
+			AssertThat(target.Has<ATypeB>(id), Equals(true));
 		});
 
-		it("Can move tree", [&]() {
-			static EntityContext* ctxPtr = nullptr;
-			static bool calledAdd;
+		it("Can move context", [&]() {
+			static IdContext* ctxPtr = nullptr;
 
-			EntityContext origin;
+			IdContext origin;
 			Id id = AddId(origin);
 
-			calledAdd = false;
-			ctxPtr    = &origin;
-			origin.OnAdd<ATypeA>().Bind([&origin](auto ids) {
-				for (Id id : ids)
-				{
-					AssertThat(origin.Has<ATypeA>(id), Equals(true));
-				}
-				AssertThat(ctxPtr, Equals(&origin));
-				calledAdd = true;
-			});
+			ctxPtr = &origin;
 			origin.Add<ATypeA>(id);
-			AssertThat(calledAdd, Equals(true));
+			AssertThat(origin.Has<ATypeA>(id), Equals(true));
 
-			EntityContext target{Move(origin)};
+			IdContext target{Move(origin)};
 			AssertThat(origin.IsValid(id), Equals(false));
 
 			AssertThat(target.IsValid(id), Equals(true));
 			AssertThat(target.Has<ATypeA>(id), Equals(true));
 
-			calledAdd = false;
-			ctxPtr    = &target;
-			target.OnAdd<ATypeB>().Bind([&target](auto ids) {
-				for (Id id : ids)
-				{
-					AssertThat(target.Has<ATypeB>(id), Equals(true));
-				}
-				AssertThat(ctxPtr, Equals(&target));
-				calledAdd = true;
-			});
+			ctxPtr = &target;
 			target.Add<ATypeB>(id);
-			AssertThat(calledAdd, Equals(true));
+			AssertThat(target.Has<ATypeB>(id), Equals(true));
 		});
 
 		it("Can assure pool", [&]() {
-			EntityContext origin;
+			IdContext origin;
 			TPool<ATypeA>& pool = origin.AssurePool<ATypeA>();
 			AssertThat(pool.Size(), Equals(0));
 		});
diff --git a/Tests/ECS/Filtering.spec.cpp b/Tests/ECS/Filtering.spec.cpp
index 28c9c982..d56759bb 100644
--- a/Tests/ECS/Filtering.spec.cpp
+++ b/Tests/ECS/Filtering.spec.cpp
@@ -34,7 +34,7 @@ struct TypeC
 
 
 go_bandit([]() {
-	EntityContext ctx;
+	IdContext ctx;
 	Id id1;
 	Id id2;
 	Id id3;
@@ -57,7 +57,7 @@ go_bandit([]() {
 
 		describe("FindAllIdsWith/FindAllIdsWithAny", [&]() {
 			it("Can get list matching all", [&]() {
-				TAccess<TypeA, TypeB, TypeC> access{ctx};
+				TIdScope<TypeA, TypeB, TypeC> access{ctx};
 				TArray<Id> typeIds = FindAllIdsWith<TypeA>(access);
 				AssertThat(typeIds.Contains(id1), Is().True());
 				AssertThat(typeIds.Contains(id2), Is().True());
@@ -70,7 +70,7 @@ go_bandit([]() {
 			});
 
 			it("Can get list matching any", [&]() {
-				TAccess<TypeA, TypeB, TypeC> access{ctx};
+				TIdScope<TypeA, TypeB, TypeC> access{ctx};
 				TArray<Id> typeIds = FindAllIdsWithAny<TypeA>(access);
 				AssertThat(typeIds.Contains(id1), Is().True());
 				AssertThat(typeIds.Contains(id2), Is().True());
@@ -83,7 +83,7 @@ go_bandit([]() {
 			});
 
 			it("Doesn't list removed ids", [&]() {
-				TAccess<TypeB> access{ctx};
+				TIdScope<TypeB> access{ctx};
 				RmId(ctx, id2, RmIdFlags::Instant);    // Remove first in the pool
 				RmId(ctx, id3, RmIdFlags::Instant);    // Remove last in the pool
 				RmId(ctx, id4, RmIdFlags::Instant);    // Remove last in the pool
@@ -94,7 +94,7 @@ go_bandit([]() {
 			});
 
 			it("Doesn't list (deferred) removed ids", [&]() {
-				TAccess<TypeB> access{ctx};
+				TIdScope<TypeB> access{ctx};
 				RmId(ctx, id2);    // Remove first in the pool
 				RmId(ctx, id3);    // Remove last in the pool
 				RmId(ctx, id4);    // Remove last in the pool
@@ -109,7 +109,7 @@ go_bandit([]() {
 
 		describe("ExcludeIdsWith", [&]() {
 			it("Removes ids containing component", [&]() {
-				TAccess<TypeA, TypeB, TypeC> access{ctx};
+				TIdScope<TypeA, TypeB, TypeC> access{ctx};
 				TArray<Id> typeIds = FindAllIdsWithAny<TypeA>(access);
 
 				ExcludeIdsWith<TypeC>(access, typeIds);
@@ -119,7 +119,7 @@ go_bandit([]() {
 			});
 
 			it("Removes ids not containing component", [&]() {
-				TAccess<TypeA, TypeB, TypeC> access{ctx};
+				TIdScope<TypeA, TypeB, TypeC> access{ctx};
 				TArray<Id> typeIds = FindAllIdsWithAny<TypeA>(access);
 
 				ExcludeIdsWithout<TypeC>(access, typeIds);
@@ -129,7 +129,7 @@ go_bandit([]() {
 			});
 
 			it("Removes ids containing multiple component", [&]() {
-				TAccess<TypeA, TypeB, TypeC> access{ctx};
+				TIdScope<TypeA, TypeB, TypeC> access{ctx};
 				TArray<Id> typeIds = FindAllIdsWithAny<TypeA, TypeB, TypeC>(access);
 
 				ExcludeIdsWith<TypeB, TypeC>(access, typeIds);
@@ -143,7 +143,7 @@ go_bandit([]() {
 			it("Finds ids containing a component from a list", [&]() {
 				TArray<Id> source{id1, id2, id3};
 
-				TAccess<TypeA> access{ctx};
+				TIdScope<TypeA> access{ctx};
 				TArray<Id> typeIds = FindIdsWith<TypeA>(access, source);
 				AssertThat(typeIds.Contains(id1), Is().True());
 				AssertThat(typeIds.Contains(id2), Is().True());
@@ -153,7 +153,7 @@ go_bandit([]() {
 			it("Finds ids not containing a component from a list", [&]() {
 				TArray<Id> source{id1, id2, id3};
 
-				TAccess<TypeA> access{ctx};
+				TIdScope<TypeA> access{ctx};
 				TArray<Id> ids = FindIdsWithout<TypeA>(access, source);
 				AssertThat(ids.Contains(id1), Is().False());
 				AssertThat(ids.Contains(id2), Is().False());
@@ -165,7 +165,7 @@ go_bandit([]() {
 			it("Finds and removes ids containing a component from a list", [&]() {
 				TArray<Id> source{id1, id2, id3};
 
-				TAccess<TypeA> access{ctx};
+				TIdScope<TypeA> access{ctx};
 				TArray<Id> ids = ExtractIdsWith<TypeA>(access, source);
 				AssertThat(ids.Contains(id1), Is().True());
 				AssertThat(ids.Contains(id2), Is().True());
@@ -178,7 +178,7 @@ go_bandit([]() {
 			it("Finds and removes ids not containing a component from a list", [&]() {
 				TArray<Id> source{id1, id2, id3};
 
-				TAccess<TypeA> access{ctx};
+				TIdScope<TypeA> access{ctx};
 				TArray<Id> ids = ExtractIdsWithout<TypeA>(access, source);
 				AssertThat(ids.Contains(id1), Is().False());
 				AssertThat(ids.Contains(id2), Is().False());
diff --git a/Tests/ECS/IdScopes.spec.cpp b/Tests/ECS/IdScopes.spec.cpp
new file mode 100644
index 00000000..0fa8da0c
--- /dev/null
+++ b/Tests/ECS/IdScopes.spec.cpp
@@ -0,0 +1,135 @@
+// Copyright 2015-2026 Piperift. All Rights Reserved.
+
+#include <bandit/bandit.h>
+#include <PipeECS.h>
+
+
+using namespace snowhouse;
+using namespace bandit;
+using namespace p;
+
+
+struct TypeA
+{};
+struct TypeB
+{
+	bool data;    // Not empty type
+};
+struct TypeC
+{
+	P_STRUCT(TypeC, TF_ECS_ModifyOnEdit)
+
+	bool data;    // Not empty type
+};
+
+
+go_bandit([]() {
+	describe("ECS.IdScopes", []() {
+		describe("Templated", []() {
+			it("Can cache pools", [&]() {
+				IdContext ctx;
+				TIdScope<Writes<TypeA, TypeB>> scope{ctx};
+
+				AssertThat(scope.GetPool<TypeA>(), Equals(ctx.GetPool<TypeA>()));
+				AssertThat(scope.GetPool<const TypeA>(), Equals(ctx.GetPool<TypeA>()));
+				AssertThat(scope.GetPool<const TypeB>(), Equals(ctx.GetPool<TypeB>()));
+			});
+
+			it("Can check if contained", [&]() {
+				IdContext ctx;
+				TPool<TypeA>& pool = ctx.AssurePool<TypeA>();
+				TIdScope<Writes<TypeA>> scope{ctx};
+				TIdScope<TypeA> scopeConst{ctx};
+				Id id = NoId;
+				AssertThat(scope.Has<TypeA>(id), Is().False());
+				AssertThat(scopeConst.Has<TypeA>(id), Is().False());
+
+				id = AddId(ctx);
+				AssertThat(scope.Has<TypeA>(id), Is().False());
+				AssertThat(scopeConst.Has<TypeA>(id), Is().False());
+
+				ctx.Add<TypeA>(id);
+				AssertThat(scope.Has<TypeA>(id), Is().True());
+				AssertThat(scopeConst.Has<TypeA>(id), Is().True());
+
+				TIdScope<TypeA, TypeB> scope2{ctx};
+				ctx.Add<TypeB>(id);
+				AssertThat(scope2.Has<TypeB>(id), Is().True());
+			});
+
+			it("Can initialize superset", [&]() {
+				IdContext ctx;
+				TPool<TypeA>& typePool = ctx.AssurePool<TypeA>();
+
+				TIdScope<Writes<TypeA, TypeB>> scope1{ctx};
+				TIdScope<Writes<TypeA>> superset1{scope1};
+				AssertThat(superset1.GetPool<TypeA>(), Equals(&typePool));
+
+				TIdScope<Writes<TypeA, TypeB>> scope2{ctx};
+				TIdScope<TypeA> superset2{scope2};
+				AssertThat(superset2.GetPool<const TypeA>(), Equals(&typePool));
+
+				TIdScope<Writes<TypeA, TypeB>> scope3{ctx};
+				TIdScope<TypeA> superset3{scope3};
+				AssertThat(superset1.GetPool<TypeA>(), Equals(&typePool));
+			});
+
+			it("Can mark modify", [&]() {
+				IdContext ctx;
+				Id id = AddId(ctx);
+				TIdScope<Writes<CMdfd<TypeC>>> scope1{ctx};
+				AssertThat(scope1.Has<CMdfd<TypeC>>(id), Is().False());
+				scope1.Modify<TypeC>(id);
+				AssertThat(scope1.Has<CMdfd<TypeC>>(id), Is().True());
+				AssertThat(scope1.IsModified<TypeC>(id), Is().True());
+
+				scope1.Remove<CMdfd<TypeC>>(id);
+				AssertThat(scope1.Has<CMdfd<TypeC>>(id), Is().False());
+				AssertThat(scope1.IsModified<TypeC>(id), Is().False());
+
+				scope1.Modify<TypeC>(id);
+				AssertThat(scope1.Has<CMdfd<TypeC>>(id), Is().True());
+				AssertThat(scope1.IsModified<TypeC>(id), Is().True());
+			});
+
+			it("Can mark modify automatically", [&]() {
+				IdContext ctx;
+				Id id         = AddId(ctx);
+				using MyScope = TIdScope<Writes<TypeC, TypeB>, CMdfd<TypeB>>;
+				MyScope scope{ctx};
+				AssertThat(MyScope::WDependencies::Contains<CMdfd<TypeC>>(), Is().True());
+				AssertThat(MyScope::WDependencies::Contains<CMdfd<TypeB>>(), Is().False());
+				AssertThat(MyScope::RWDependencies::Contains<CMdfd<TypeC>>(), Is().True());
+				AssertThat(MyScope::RWDependencies::Contains<CMdfd<TypeB>>(), Is().True());
+
+				scope.Add<TypeC>(id);    // Type B should be auto modified
+				AssertThat(scope.IsModified<TypeC>(id), Is().True());
+				scope.Add<TypeB>(id);    // Type B should not be auto modified
+				AssertThat(scope.IsModified<TypeB>(id), Is().False());
+
+				scope.ClearPool<CMdfd<TypeC>>();
+				AssertThat(scope.IsModified<TypeC>(id), Is().False());
+
+				scope.Has<TypeC>(id);    // Has should never mark modify
+				AssertThat(scope.IsModified<TypeC>(id), Is().False());
+
+				scope.Get<const TypeC>(id);
+				AssertThat(scope.IsModified<TypeC>(id), Is().False());
+				scope.Get<TypeC>(id);
+				AssertThat(scope.IsModified<TypeC>(id), Is().True());
+				scope.Add<TypeB>(id);    // Type B should not be auto modified
+				AssertThat(scope.IsModified<TypeB>(id), Is().False());
+
+				scope.ClearPool<CMdfd<TypeC>>();
+
+				scope.Remove<TypeC>(id);
+				AssertThat(scope.Has<TypeC>(id), Is().False());
+				AssertThat(scope.IsModified<TypeC>(id), Is().True());
+
+				scope.Remove<TypeB>(id);    // Type B should not be auto modified
+				AssertThat(scope.Has<TypeB>(id), Is().False());
+				AssertThat(scope.IsModified<TypeB>(id), Is().False());
+			});
+		});
+	});
+});
diff --git a/Tests/ECS/Statics.spec.cpp b/Tests/ECS/Statics.spec.cpp
index 39d1f35e..8d8a3bb4 100644
--- a/Tests/ECS/Statics.spec.cpp
+++ b/Tests/ECS/Statics.spec.cpp
@@ -27,7 +27,7 @@ struct StaticTypeThree
 go_bandit([]() {
 	describe("ECS.Statics", []() {
 		it("Can set an static", [&]() {
-			EntityContext ast;
+			IdContext ast;
 			AssertThat(ast.HasStatic<StaticType>(), Equals(false));
 			auto& var = ast.SetStatic<StaticType>({4});
 			AssertThat(var.i, Equals(4));
@@ -35,7 +35,7 @@ go_bandit([]() {
 			AssertThat(ast.HasStatic<StaticTypeTwo>(), Equals(false));
 		});
 		it("Can set two statics", [&]() {
-			EntityContext ast;
+			IdContext ast;
 			AssertThat(ast.HasStatic<StaticType>(), Equals(false));
 			AssertThat(ast.HasStatic<StaticTypeTwo>(), Equals(false));
 			auto& var1 = ast.SetStatic<StaticType>({4});
@@ -46,7 +46,7 @@ go_bandit([]() {
 			AssertThat(ast.HasStatic<StaticTypeTwo>(), Equals(true));
 		});
 		it("Can replace an static", [&]() {
-			EntityContext ast;
+			IdContext ast;
 			AssertThat(ast.HasStatic<StaticType>(), Equals(false));
 			ast.SetStatic<StaticType>({4});
 			ast.SetStatic<StaticType>({2});
@@ -54,14 +54,14 @@ go_bandit([]() {
 			AssertThat(ast.HasStatic<StaticType>(), Equals(true));
 		});
 		it("Can get or set an static", [&]() {
-			EntityContext ast;
+			IdContext ast;
 			// Can set
 			AssertThat(ast.GetOrSetStatic<StaticType>({4}).i, Equals(4));
 			// Can get
 			AssertThat(ast.GetOrSetStatic<StaticType>({10}).i, Equals(4));
 		});
 		it("Can remove an static", [&]() {
-			EntityContext ast;
+			IdContext ast;
 			ast.SetStatic<StaticType>();
 			AssertThat(ast.HasStatic<StaticType>(), Equals(true));
 			AssertThat(ast.RemoveStatic<StaticType>(), Is().True());
@@ -71,7 +71,7 @@ go_bandit([]() {
 		});
 
 		it("Can get statics", [&]() {
-			EntityContext ast;
+			IdContext ast;
 			ast.SetStatic<StaticType>({4});
 			ast.SetStatic<StaticTypeTwo>({2});
 			AssertThat(ast.GetStatic<StaticType>().i, Equals(4));