diff --git a/documentation/NEXT_RELEASENOTES.txt b/documentation/NEXT_RELEASENOTES.txt
index e3ad3b4..b304ef2 100644
--- a/documentation/NEXT_RELEASENOTES.txt
+++ b/documentation/NEXT_RELEASENOTES.txt
@@ -1,6 +1,11 @@
 ## Breaking changes
 
 - Entity.Set, EntitySetSameAs and EntitySetSameAsWorld will now reenable the component if it was disabled
+- renamed World.SubscribeComponentAdded to World.SubscribeEntityComponentAdded
+- renamed World.SubscribeComponentChanged to World.SubscribeEntityComponentChanged
+- renamed World.SubscribeComponentRemoved to World.SubscribeEntityComponentRemoved
+- renamed World.SubscribeComponentEnabled to World.SubscribeEntityComponentEnabled
+- renamed World.SubscribeComponentDisabled to World.SubscribeEntityComponentDisabled
 
 ## New features
 
diff --git a/source/DefaultEcs.Extension/Hierarchy/HierarchyLevelSetter.cs b/source/DefaultEcs.Extension/Hierarchy/HierarchyLevelSetter.cs
index 6c5113c..026b060 100644
--- a/source/DefaultEcs.Extension/Hierarchy/HierarchyLevelSetter.cs
+++ b/source/DefaultEcs.Extension/Hierarchy/HierarchyLevelSetter.cs
@@ -16,9 +16,9 @@ private HierarchyLevelSetter(World world)
         {
             _map = world.GetEntities().AsMultiMap<Parent>();
 
-            _addedSubscription = world.SubscribeComponentAdded<Parent>(OnAdded);
-            _changedSubscription = world.SubscribeComponentChanged<Parent>(OnChanged);
-            _removedSubscription = world.SubscribeComponentRemoved<Parent>(OnRemoved);
+            _addedSubscription = world.SubscribeEntityComponentAdded<Parent>(OnAdded);
+            _changedSubscription = world.SubscribeEntityComponentChanged<Parent>(OnChanged);
+            _removedSubscription = world.SubscribeEntityComponentRemoved<Parent>(OnRemoved);
 
             using EntitySet entities = world.GetEntities().With<Parent>().AsSet();
 
diff --git a/source/DefaultEcs.Test/Command/EntityCommandRecorderTest.cs b/source/DefaultEcs.Test/Command/EntityCommandRecorderTest.cs
index d6d19ab..8e7d7d6 100644
--- a/source/DefaultEcs.Test/Command/EntityCommandRecorderTest.cs
+++ b/source/DefaultEcs.Test/Command/EntityCommandRecorderTest.cs
@@ -374,7 +374,7 @@ public void NotifyChanged_Should_change_component_on_recorded_entity()
             Entity entity = world.CreateEntity();
             entity.Set(true);
 
-            using IDisposable changed = world.SubscribeComponentChanged((in Entity e, in bool _, in bool _) => result = e);
+            using IDisposable changed = world.SubscribeEntityComponentChanged((in Entity e, in bool _, in bool _) => result = e);
 
             recorder.Record(entity).NotifyChanged<bool>();
 
@@ -390,7 +390,7 @@ public void NotifyChanged_Should_change_component_on_created_entity()
 
             using EntityCommandRecorder recorder = new(1024);
             using World world = new();
-            using IDisposable changed = world.SubscribeComponentChanged((in Entity e, in bool _, in bool _) => result = e);
+            using IDisposable changed = world.SubscribeEntityComponentChanged((in Entity e, in bool _, in bool _) => result = e);
 
             EntityRecord record = recorder.Record(world).CreateEntity();
             record.Set(true);
diff --git a/source/DefaultEcs.Test/WorldTest.cs b/source/DefaultEcs.Test/WorldTest.cs
index b3115e5..a18a440 100644
--- a/source/DefaultEcs.Test/WorldTest.cs
+++ b/source/DefaultEcs.Test/WorldTest.cs
@@ -525,56 +525,56 @@ public void SubscribeEntityDisposed_Should_call_handler_When_world_disposed()
         }
 
         [Fact]
-        public void SubscribeComponentAdded_Should_throw_When_action_is_null()
+        public void SubscribeEntityComponentAdded_Should_throw_When_action_is_null()
         {
             using World world = new();
 
             Check
-                .ThatCode(() => world.SubscribeComponentAdded<bool>(null))
+                .ThatCode(() => world.SubscribeEntityComponentAdded<bool>(null))
                 .Throws<ArgumentNullException>()
                 .WithProperty(e => e.ParamName, "action");
         }
 
         [Fact]
-        public void SubscribeComponentChanged_Should_throw_When_action_is_null()
+        public void SubscribeEntityComponentChanged_Should_throw_When_action_is_null()
         {
             using World world = new();
 
             Check
-                .ThatCode(() => world.SubscribeComponentChanged<bool>(null))
+                .ThatCode(() => world.SubscribeEntityComponentChanged<bool>(null))
                 .Throws<ArgumentNullException>()
                 .WithProperty(e => e.ParamName, "action");
         }
 
         [Fact]
-        public void SubscribeComponentRemoved_Should_throw_When_action_is_null()
+        public void SubscribeEntityComponentRemoved_Should_throw_When_action_is_null()
         {
             using World world = new();
 
             Check
-                .ThatCode(() => world.SubscribeComponentRemoved<bool>(null))
+                .ThatCode(() => world.SubscribeEntityComponentRemoved<bool>(null))
                 .Throws<ArgumentNullException>()
                 .WithProperty(e => e.ParamName, "action");
         }
 
         [Fact]
-        public void SubscribeComponentEnabled_Should_throw_When_action_is_null()
+        public void SubscribeEntityComponentEnabled_Should_throw_When_action_is_null()
         {
             using World world = new();
 
             Check
-                .ThatCode(() => world.SubscribeComponentEnabled<bool>(null))
+                .ThatCode(() => world.SubscribeEntityComponentEnabled<bool>(null))
                 .Throws<ArgumentNullException>()
                 .WithProperty(e => e.ParamName, "action");
         }
 
         [Fact]
-        public void SubscribeComponentDisabled_Should_throw_When_action_is_null()
+        public void SubscribeEntityComponentDisabled_Should_throw_When_action_is_null()
         {
             using World world = new();
 
             Check
-                .ThatCode(() => world.SubscribeComponentDisabled<bool>(null))
+                .ThatCode(() => world.SubscribeEntityComponentDisabled<bool>(null))
                 .Throws<ArgumentNullException>()
                 .WithProperty(e => e.ParamName, "action");
         }
@@ -613,12 +613,12 @@ public void SubscribeWorldComponentRemoved_Should_throw_When_action_is_null()
         }
 
         [Fact]
-        public void SubscribeComponentAdded_Should_call_handler_When_component_added()
+        public void SubscribeEntityComponentAdded_Should_call_handler_When_component_added()
         {
             using World world = new();
             Entity entity = world.CreateEntity();
             bool called = false;
-            using IDisposable subscription = world.SubscribeComponentAdded((in Entity e, in bool v) =>
+            using IDisposable subscription = world.SubscribeEntityComponentAdded((in Entity e, in bool v) =>
             {
                 Check.That(e).IsEqualTo(entity);
                 Check.That(v).IsTrue();
@@ -630,25 +630,25 @@ public void SubscribeComponentAdded_Should_call_handler_When_component_added()
         }
 
         [Fact]
-        public void SubscribeComponentAdded_Should_not_throw_When_removing_component()
+        public void SubscribeEntityComponentAdded_Should_not_throw_When_removing_component()
         {
             using World world = new();
             Entity entity = world.CreateEntity();
-            using IDisposable subscription1 = world.SubscribeComponentChanged((in Entity _, in bool _, in bool _) => { });
-            using IDisposable subscription2 = world.SubscribeComponentAdded((in Entity e, in bool _) => e.Remove<bool>());
+            using IDisposable subscription1 = world.SubscribeEntityComponentChanged((in Entity _, in bool _, in bool _) => { });
+            using IDisposable subscription2 = world.SubscribeEntityComponentAdded((in Entity e, in bool _) => e.Remove<bool>());
 
             Check.ThatCode(() => entity.Set(true)).DoesNotThrow();
         }
 
         [Fact]
-        public void SubscribeComponentEnabled_Should_call_handler_When_component_enabled()
+        public void SubscribeEntityComponentEnabled_Should_call_handler_When_component_enabled()
         {
             using World world = new();
             Entity entity = world.CreateEntity();
             entity.Set(true);
             entity.Disable<bool>();
             bool called = false;
-            using IDisposable subscription = world.SubscribeComponentEnabled((in Entity e, in bool v) =>
+            using IDisposable subscription = world.SubscribeEntityComponentEnabled((in Entity e, in bool v) =>
             {
                 Check.That(e).IsEqualTo(entity);
                 Check.That(v).IsTrue();
@@ -660,13 +660,13 @@ public void SubscribeComponentEnabled_Should_call_handler_When_component_enabled
         }
 
         [Fact]
-        public void SubscribeComponentDisabled_Should_call_handler_When_component_disabled()
+        public void SubscribeEntityComponentDisabled_Should_call_handler_When_component_disabled()
         {
             using World world = new();
             Entity entity = world.CreateEntity();
             entity.Set(true);
             bool called = false;
-            using IDisposable subscription = world.SubscribeComponentDisabled((in Entity e, in bool v) =>
+            using IDisposable subscription = world.SubscribeEntityComponentDisabled((in Entity e, in bool v) =>
             {
                 Check.That(e).IsEqualTo(entity);
                 Check.That(v).IsTrue();
@@ -678,12 +678,12 @@ public void SubscribeComponentDisabled_Should_call_handler_When_component_disabl
         }
 
         [Fact]
-        public void SubscribeComponentRemoved_Should_call_handler_When_component_removed()
+        public void SubscribeEntityComponentRemoved_Should_call_handler_When_component_removed()
         {
             using World world = new();
             Entity entity = world.CreateEntity();
             bool called = false;
-            using IDisposable subscription = world.SubscribeComponentRemoved((in Entity e, in bool v) =>
+            using IDisposable subscription = world.SubscribeEntityComponentRemoved((in Entity e, in bool v) =>
             {
                 Check.That(e).IsEqualTo(entity);
                 Check.That(v).IsTrue();
@@ -696,13 +696,13 @@ public void SubscribeComponentRemoved_Should_call_handler_When_component_removed
         }
 
         [Fact]
-        public void SubscribeComponentRemoved_Should_call_handler_When_entity_disposed()
+        public void SubscribeEntityComponentRemoved_Should_call_handler_When_entity_disposed()
         {
             using World world = new();
             Entity entity = world.CreateEntity();
             entity.Set(true);
             bool called = false;
-            using IDisposable subscription = world.SubscribeComponentRemoved((in Entity e, in bool v) =>
+            using IDisposable subscription = world.SubscribeEntityComponentRemoved((in Entity e, in bool v) =>
             {
                 Check.That(e).IsEqualTo(entity);
                 Check.That(v).IsTrue();
@@ -714,13 +714,13 @@ public void SubscribeComponentRemoved_Should_call_handler_When_entity_disposed()
         }
 
         [Fact]
-        public void SubscribeComponentRemoved_Should_call_handler_When_world_disposed()
+        public void SubscribeEntityComponentRemoved_Should_call_handler_When_world_disposed()
         {
             World world = new();
             Entity entity = world.CreateEntity();
             entity.Set(true);
             bool called = false;
-            using IDisposable subscription = world.SubscribeComponentRemoved((in Entity e, in bool v) =>
+            using IDisposable subscription = world.SubscribeEntityComponentRemoved((in Entity e, in bool v) =>
             {
                 Check.That(e).IsEqualTo(entity);
                 Check.That(v).IsTrue();
@@ -732,13 +732,13 @@ public void SubscribeComponentRemoved_Should_call_handler_When_world_disposed()
         }
 
         [Fact]
-        public void SubscribeComponentChanged_Should_call_handler_When_component_changed()
+        public void SubscribeEntityComponentChanged_Should_call_handler_When_component_changed()
         {
             using World world = new();
             Entity entity = world.CreateEntity();
             entity.Set(false);
             bool called = false;
-            using IDisposable subscription = world.SubscribeComponentChanged((in Entity e, in bool ov, in bool nv) =>
+            using IDisposable subscription = world.SubscribeEntityComponentChanged((in Entity e, in bool ov, in bool nv) =>
             {
                 Check.That(e).IsEqualTo(entity);
                 Check.That(ov).IsFalse();
@@ -751,43 +751,43 @@ public void SubscribeComponentChanged_Should_call_handler_When_component_changed
         }
 
         [Fact]
-        public void SubscribeComponent_Should_do_nothing_When_entity_disposed_without_component()
+        public void SubscribeEntityComponent_Should_do_nothing_When_entity_disposed_without_component()
         {
             using World world = new();
             Entity entity = world.CreateEntity();
-            using IDisposable added = world.SubscribeComponentAdded((in Entity _, in bool _) => throw new Exception());
-            using IDisposable changed = world.SubscribeComponentChanged((in Entity _, in bool _, in bool _) => throw new Exception());
-            using IDisposable removed = world.SubscribeComponentRemoved((in Entity _, in bool _) => throw new Exception());
-            using IDisposable enabled = world.SubscribeComponentEnabled((in Entity _, in bool _) => throw new Exception());
-            using IDisposable disabled = world.SubscribeComponentDisabled((in Entity _, in bool _) => throw new Exception());
+            using IDisposable added = world.SubscribeEntityComponentAdded((in Entity _, in bool _) => throw new Exception());
+            using IDisposable changed = world.SubscribeEntityComponentChanged((in Entity _, in bool _, in bool _) => throw new Exception());
+            using IDisposable removed = world.SubscribeEntityComponentRemoved((in Entity _, in bool _) => throw new Exception());
+            using IDisposable enabled = world.SubscribeEntityComponentEnabled((in Entity _, in bool _) => throw new Exception());
+            using IDisposable disabled = world.SubscribeEntityComponentDisabled((in Entity _, in bool _) => throw new Exception());
 
             Check.ThatCode(entity.Dispose).DoesNotThrow();
         }
 
         [Fact]
-        public void SubscribeComponent_Should_do_nothing_When_world_disposed_without_component()
+        public void SubscribeEntityComponent_Should_do_nothing_When_world_disposed_without_component()
         {
             World world = new();
             Entity entity = world.CreateEntity();
-            using IDisposable added = world.SubscribeComponentAdded((in Entity _, in bool _) => throw new Exception());
-            using IDisposable changed = world.SubscribeComponentChanged((in Entity _, in bool _, in bool _) => throw new Exception());
-            using IDisposable removed = world.SubscribeComponentRemoved((in Entity _, in bool _) => throw new Exception());
-            using IDisposable enabled = world.SubscribeComponentEnabled((in Entity _, in bool _) => throw new Exception());
-            using IDisposable disabled = world.SubscribeComponentDisabled((in Entity _, in bool _) => throw new Exception());
+            using IDisposable added = world.SubscribeEntityComponentAdded((in Entity _, in bool _) => throw new Exception());
+            using IDisposable changed = world.SubscribeEntityComponentChanged((in Entity _, in bool _, in bool _) => throw new Exception());
+            using IDisposable removed = world.SubscribeEntityComponentRemoved((in Entity _, in bool _) => throw new Exception());
+            using IDisposable enabled = world.SubscribeEntityComponentEnabled((in Entity _, in bool _) => throw new Exception());
+            using IDisposable disabled = world.SubscribeEntityComponentDisabled((in Entity _, in bool _) => throw new Exception());
 
             Check.ThatCode(world.Dispose).DoesNotThrow();
         }
 
         [Fact]
-        public void SubscribeComponent_Should_do_nothing_When_subscription_disposed()
+        public void SubscribeEntityComponent_Should_do_nothing_When_subscription_disposed()
         {
             using World world = new();
             Entity entity = world.CreateEntity();
-            world.SubscribeComponentAdded((in Entity _, in bool _) => throw new Exception()).Dispose();
-            world.SubscribeComponentChanged((in Entity _, in bool _, in bool _) => throw new Exception()).Dispose();
-            world.SubscribeComponentRemoved((in Entity _, in bool _) => throw new Exception()).Dispose();
-            world.SubscribeComponentEnabled((in Entity _, in bool _) => throw new Exception()).Dispose();
-            world.SubscribeComponentDisabled((in Entity _, in bool _) => throw new Exception()).Dispose();
+            world.SubscribeEntityComponentAdded((in Entity _, in bool _) => throw new Exception()).Dispose();
+            world.SubscribeEntityComponentChanged((in Entity _, in bool _, in bool _) => throw new Exception()).Dispose();
+            world.SubscribeEntityComponentRemoved((in Entity _, in bool _) => throw new Exception()).Dispose();
+            world.SubscribeEntityComponentEnabled((in Entity _, in bool _) => throw new Exception()).Dispose();
+            world.SubscribeEntityComponentDisabled((in Entity _, in bool _) => throw new Exception()).Dispose();
 
             Check.ThatCode(() => entity.Set(true)).DoesNotThrow();
         }
@@ -891,7 +891,7 @@ public void TrimExcess_Should_fit_storage_of_component()
             Entity entity = world.CreateEntity();
             entity.Set(42);
             entity.Dispose();
-            world.SubscribeComponentChanged((in Entity _, in int __, in int ___) => { });
+            world.SubscribeEntityComponentChanged((in Entity _, in int __, in int ___) => { });
 
             world.TrimExcess<int>();
 
diff --git a/source/DefaultEcs/Delegates.Entity.cs b/source/DefaultEcs/Delegates.Entity.cs
new file mode 100644
index 0000000..4b23f74
--- /dev/null
+++ b/source/DefaultEcs/Delegates.Entity.cs
@@ -0,0 +1,79 @@
+namespace DefaultEcs
+{
+    /// <summary>
+    /// Represents the method that will called when an <see cref="Entity"/> is created.
+    /// </summary>
+    /// <param name="entity">The created <see cref="Entity"/>.</param>
+    public delegate void EntityCreatedHandler(in Entity entity);
+
+    /// <summary>
+    /// Represents the method that will called when an <see cref="Entity"/> is enabled.
+    /// </summary>
+    /// <param name="entity">The enabled <see cref="Entity"/>.</param>
+    public delegate void EntityEnabledHandler(in Entity entity);
+
+    /// <summary>
+    /// Represents the method that will called when an <see cref="Entity"/> is disabled.
+    /// </summary>
+    /// <param name="entity">The disabled <see cref="Entity"/>.</param>
+    public delegate void EntityDisabledHandler(in Entity entity);
+
+    /// <summary>
+    /// Represents the method that will called when an <see cref="Entity"/> is disposed.
+    /// </summary>
+    /// <param name="entity">The disposed <see cref="Entity"/>.</param>
+    public delegate void EntityDisposedHandler(in Entity entity);
+
+    /// <summary>
+    /// Represents the method that will called when a component of type <typeparamref name="T"/> is added on an <see cref="Entity"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the component added.</typeparam>
+    /// <param name="entity">The <see cref="Entity"/> on which the component was added.</param>
+    /// <param name="value">The value of the component.</param>
+    public delegate void EntityComponentAddedHandler<T>(in Entity entity, in T value);
+
+    /// <summary>
+    /// Represents the method that will called when a component of type <typeparamref name="T"/> is changed on an <see cref="Entity"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the component removed.</typeparam>
+    /// <param name="entity">The <see cref="Entity"/> on which the component was changed.</param>
+    /// <param name="oldValue">The previous value of the component.</param>
+    /// <param name="newValue">The new value of the component.</param>
+    public delegate void EntityComponentChangedHandler<T>(in Entity entity, in T oldValue, in T newValue);
+
+    /// <summary>
+    /// Represents the method that will called when a component of type <typeparamref name="T"/> is removed from an <see cref="Entity"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the component removed.</typeparam>
+    /// <param name="entity">The <see cref="Entity"/> on which the component was removed.</param>
+    /// <param name="value">The value of the component.</param>
+    public delegate void EntityComponentRemovedHandler<T>(in Entity entity, in T value);
+
+    /// <summary>
+    /// Represents the method that will called when a component of type <typeparamref name="T"/> is enabled on an <see cref="Entity"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the component enabled.</typeparam>
+    /// <param name="entity">The <see cref="Entity"/> on which the component was enabled.</param>
+    /// <param name="value">The value of the component.</param>
+    public delegate void EntityComponentEnabledHandler<T>(in Entity entity, in T value);
+
+    /// <summary>
+    /// Represents the method that will called when a component of type <typeparamref name="T"/> is disabled on an <see cref="Entity"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the component disabled.</typeparam>
+    /// <param name="entity">The <see cref="Entity"/> on which the component was disabled.</param>
+    /// <param name="value">The value of the component.</param>
+    public delegate void EntityComponentDisabledHandler<T>(in Entity entity, in T value);
+
+    /// <summary>
+    /// Represents the method that will called when an <see cref="Entity"/> is added to a container.
+    /// </summary>
+    /// <param name="entity">The added <see cref="Entity"/>.</param>
+    public delegate void EntityAddedHandler(in Entity entity);
+
+    /// <summary>
+    /// Represents the method that will called when an <see cref="Entity"/> is removed from a container.
+    /// </summary>
+    /// <param name="entity">The removed <see cref="Entity"/>.</param>
+    public delegate void EntityRemovedHandler(in Entity entity);
+}
diff --git a/source/DefaultEcs/Delegates.World.cs b/source/DefaultEcs/Delegates.World.cs
new file mode 100644
index 0000000..b666622
--- /dev/null
+++ b/source/DefaultEcs/Delegates.World.cs
@@ -0,0 +1,33 @@
+namespace DefaultEcs
+{
+    /// <summary>
+    /// Represents the method that will called when a <see cref="World"/> is created.
+    /// </summary>
+    /// <param name="world">The dusposed <see cref="World"/>.</param>
+    public delegate void WorldDisposedHandler(World world);
+
+    /// <summary>
+    /// Represents the method that will called when a component of type <typeparamref name="T"/> is added on a <see cref="World"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the component added.</typeparam>
+    /// <param name="world">The <see cref="World"/> on which the component was added.</param>
+    /// <param name="value">The value of the component.</param>
+    public delegate void WorldComponentAddedHandler<T>(World world, in T value);
+
+    /// <summary>
+    /// Represents the method that will called when a component of type <typeparamref name="T"/> is changed on a <see cref="World"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the component removed.</typeparam>
+    /// <param name="world">The <see cref="World"/> on which the component was changed.</param>
+    /// <param name="oldValue">The previous value of the component.</param>
+    /// <param name="newValue">The new value of the component.</param>
+    public delegate void WorldComponentChangedHandler<T>(World world, in T oldValue, in T newValue);
+
+    /// <summary>
+    /// Represents the method that will called when a component of type <typeparamref name="T"/> is removed from a <see cref="World"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the component removed.</typeparam>
+    /// <param name="world">The <see cref="World"/> on which the component was removed.</param>
+    /// <param name="value">The value of the component.</param>
+    public delegate void WorldComponentRemovedHandler<T>(World world, in T value);
+}
diff --git a/source/DefaultEcs/Delegates.cs b/source/DefaultEcs/Delegates.cs
index 4793c2c..60c32c1 100644
--- a/source/DefaultEcs/Delegates.cs
+++ b/source/DefaultEcs/Delegates.cs
@@ -7,102 +7,6 @@
     /// <param name="message">The parameter of the method that this delegate encapsulates.</param>
     public delegate void MessageHandler<T>(in T message);
 
-    /// <summary>
-    /// Represents the method that will called when a <see cref="World"/> is created.
-    /// </summary>
-    /// <param name="world">The dusposed <see cref="World"/>.</param>
-    public delegate void WorldDisposedHandler(World world);
-
-    /// <summary>
-    /// Represents the method that will called when an <see cref="Entity"/> is created.
-    /// </summary>
-    /// <param name="entity">The created <see cref="Entity"/>.</param>
-    public delegate void EntityCreatedHandler(in Entity entity);
-
-    /// <summary>
-    /// Represents the method that will called when an <see cref="Entity"/> is enabled.
-    /// </summary>
-    /// <param name="entity">The enabled <see cref="Entity"/>.</param>
-    public delegate void EntityEnabledHandler(in Entity entity);
-
-    /// <summary>
-    /// Represents the method that will called when an <see cref="Entity"/> is disabled.
-    /// </summary>
-    /// <param name="entity">The disabled <see cref="Entity"/>.</param>
-    public delegate void EntityDisabledHandler(in Entity entity);
-
-    /// <summary>
-    /// Represents the method that will called when an <see cref="Entity"/> is disposed.
-    /// </summary>
-    /// <param name="entity">The disposed <see cref="Entity"/>.</param>
-    public delegate void EntityDisposedHandler(in Entity entity);
-
-    /// <summary>
-    /// Represents the method that will called when a component of type <typeparamref name="T"/> is added on an <see cref="Entity"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the component added.</typeparam>
-    /// <param name="entity">The <see cref="Entity"/> on which the component was added.</param>
-    /// <param name="value">The value of the component.</param>
-    public delegate void ComponentAddedHandler<T>(in Entity entity, in T value);
-
-    /// <summary>
-    /// Represents the method that will called when a component of type <typeparamref name="T"/> is changed on an <see cref="Entity"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the component removed.</typeparam>
-    /// <param name="entity">The <see cref="Entity"/> on which the component was changed.</param>
-    /// <param name="oldValue">The previous value of the component.</param>
-    /// <param name="newValue">The new value of the component.</param>
-    public delegate void ComponentChangedHandler<T>(in Entity entity, in T oldValue, in T newValue);
-
-    /// <summary>
-    /// Represents the method that will called when a component of type <typeparamref name="T"/> is removed from an <see cref="Entity"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the component removed.</typeparam>
-    /// <param name="entity">The <see cref="Entity"/> on which the component was removed.</param>
-    /// <param name="value">The value of the component.</param>
-    public delegate void ComponentRemovedHandler<T>(in Entity entity, in T value);
-
-    /// <summary>
-    /// Represents the method that will called when a component of type <typeparamref name="T"/> is added on a <see cref="World"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the component added.</typeparam>
-    /// <param name="world">The <see cref="World"/> on which the component was added.</param>
-    /// <param name="value">The value of the component.</param>
-    public delegate void WorldComponentAddedHandler<T>(World world, in T value);
-
-    /// <summary>
-    /// Represents the method that will called when a component of type <typeparamref name="T"/> is changed on a <see cref="World"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the component removed.</typeparam>
-    /// <param name="world">The <see cref="World"/> on which the component was changed.</param>
-    /// <param name="oldValue">The previous value of the component.</param>
-    /// <param name="newValue">The new value of the component.</param>
-    public delegate void WorldComponentChangedHandler<T>(World world, in T oldValue, in T newValue);
-
-    /// <summary>
-    /// Represents the method that will called when a component of type <typeparamref name="T"/> is removed from a <see cref="World"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the component removed.</typeparam>
-    /// <param name="world">The <see cref="World"/> on which the component was removed.</param>
-    /// <param name="value">The value of the component.</param>
-    public delegate void WorldComponentRemovedHandler<T>(World world, in T value);
-
-    /// <summary>
-    /// Represents the method that will called when a component of type <typeparamref name="T"/> is enabled on an <see cref="Entity"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the component enabled.</typeparam>
-    /// <param name="entity">The <see cref="Entity"/> on which the component was enabled.</param>
-    /// <param name="value">The value of the component.</param>
-    public delegate void ComponentEnabledHandler<T>(in Entity entity, in T value);
-
-    /// <summary>
-    /// Represents the method that will called when a component of type <typeparamref name="T"/> is disabled on an <see cref="Entity"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the component disabled.</typeparam>
-    /// <param name="entity">The <see cref="Entity"/> on which the component was disabled.</param>
-    /// <param name="value">The value of the component.</param>
-    public delegate void ComponentDisabledHandler<T>(in Entity entity, in T value);
-
     /// <summary>
     /// Represents the method that defines a set of criteria and determines whether the specified component meets those criteria.
     /// </summary>
@@ -110,16 +14,4 @@
     /// <param name="value">The component value.</param>
     /// <returns>true if the component meets the criteria; otherwise, false.</returns>
     public delegate bool ComponentPredicate<T>(in T value);
-
-    /// <summary>
-    /// Represents the method that will called when an <see cref="Entity"/> is added to a container.
-    /// </summary>
-    /// <param name="entity">The added <see cref="Entity"/>.</param>
-    public delegate void EntityAddedHandler(in Entity entity);
-
-    /// <summary>
-    /// Represents the method that will called when an <see cref="Entity"/> is removed from a container.
-    /// </summary>
-    /// <param name="entity">The removed <see cref="Entity"/>.</param>
-    public delegate void EntityRemovedHandler(in Entity entity);
 }
diff --git a/source/DefaultEcs/Entity.cs b/source/DefaultEcs/Entity.cs
index 6f9a725..fd4691c 100644
--- a/source/DefaultEcs/Entity.cs
+++ b/source/DefaultEcs/Entity.cs
@@ -86,16 +86,13 @@ private void InnerSet<T>(bool isNew)
             if (isNew)
             {
                 components[ComponentManager<T>.Flag] = true;
-                Publisher.Publish(WorldId, new ComponentAddedMessage<T>(EntityId, components));
-            }
-            else if (components[ComponentManager<T>.Flag])
-            {
-                Publisher.Publish(WorldId, new ComponentChangedMessage<T>(EntityId, components));
+                Publisher.Publish(WorldId, new EntityComponentAddedMessage<T>(EntityId, components));
             }
             else
             {
-                components[ComponentManager<T>.Flag] = true;
-                Publisher.Publish(WorldId, new ComponentEnabledMessage<T>(EntityId, components));
+                Publisher.Publish(WorldId, new EntityComponentChangedMessage<T>(EntityId, components));
+
+                Enable<T>();
             }
 
             if (ComponentManager<T>.GetPrevious(WorldId) is ComponentPool<T> previousPool && Has<T>())
@@ -170,7 +167,7 @@ public void Enable<T>()
                 if (!components[ComponentManager<T>.Flag])
                 {
                     components[ComponentManager<T>.Flag] = true;
-                    Publisher.Publish(WorldId, new ComponentEnabledMessage<T>(EntityId, components));
+                    Publisher.Publish(WorldId, new EntityComponentEnabledMessage<T>(EntityId, components));
                 }
             }
         }
@@ -190,7 +187,7 @@ public void Disable<T>()
             if (components[ComponentManager<T>.Flag])
             {
                 components[ComponentManager<T>.Flag] = false;
-                Publisher.Publish(WorldId, new ComponentDisabledMessage<T>(EntityId, components));
+                Publisher.Publish(WorldId, new EntityComponentDisabledMessage<T>(EntityId, components));
             }
         }
 
@@ -266,7 +263,7 @@ public void Remove<T>()
             {
                 ref ComponentEnum components = ref Components;
                 components[ComponentManager<T>.Flag] = false;
-                Publisher.Publish(WorldId, new ComponentRemovedMessage<T>(EntityId, components));
+                Publisher.Publish(WorldId, new EntityComponentRemovedMessage<T>(EntityId, components));
                 ComponentManager<T>.GetPrevious(WorldId)?.Remove(EntityId);
             }
         }
@@ -283,8 +280,12 @@ public void NotifyChanged<T>()
             ThrowIf(WorldId == 0, "Entity was not created from a World");
             ThrowIf(!Has<T>(), $"Entity does not have a component of type {nameof(T)}");
 
-            Publisher.Publish(WorldId, new ComponentChangedMessage<T>(EntityId, Components));
-            ComponentManager<T>.GetPrevious(WorldId)?.Set(EntityId, Get<T>());
+            Publisher.Publish(WorldId, new EntityComponentChangedMessage<T>(EntityId, Components));
+
+            if (ComponentManager<T>.GetPrevious(WorldId) is ComponentPool<T> previousPool && Has<T>())
+            {
+                previousPool.Set(EntityId, Get<T>());
+            }
         }
 
         /// <summary>
diff --git a/source/DefaultEcs/EntityMap.cs b/source/DefaultEcs/EntityMap.cs
index 77df17d..f77cd18 100644
--- a/source/DefaultEcs/EntityMap.cs
+++ b/source/DefaultEcs/EntityMap.cs
@@ -142,7 +142,7 @@ internal EntityMap(
             _worldMaxCapacity = world.MaxCapacity == int.MaxValue ? int.MaxValue : (world.MaxCapacity + 1);
             EntityContainerWatcher container = new(this, filter, predicate);
             _subscriptions = Enumerable
-                .Repeat(world.Subscribe<ComponentChangedMessage<TKey>>(On), 1)
+                .Repeat(world.Subscribe<EntityComponentChangedMessage<TKey>>(On), 1)
                 .Concat(subscriptions.Select(s => s(container, world)))
                 .Merge();
             _previousComponents = ComponentManager<TKey>.GetOrCreatePrevious(_worldId);
@@ -168,7 +168,7 @@ internal EntityMap(
 
         #region Callbacks
 
-        private void On(in ComponentChangedMessage<TKey> message)
+        private void On(in EntityComponentChangedMessage<TKey> message)
         {
             if (message.EntityId < _entityIds.Length && _entityIds[message.EntityId] && _entities.Remove(_previousComponents.Get(message.EntityId)))
             {
diff --git a/source/DefaultEcs/EntityMultiMap.cs b/source/DefaultEcs/EntityMultiMap.cs
index 2c9a415..4e1ea86 100644
--- a/source/DefaultEcs/EntityMultiMap.cs
+++ b/source/DefaultEcs/EntityMultiMap.cs
@@ -249,7 +249,7 @@ internal EntityMultiMap(
             _worldMaxCapacity = world.MaxCapacity == int.MaxValue ? int.MaxValue : (world.MaxCapacity + 1);
             EntityContainerWatcher container = new(this, filter, predicate);
             _subscriptions = Enumerable
-                .Repeat(world.Subscribe<ComponentChangedMessage<TKey>>(On), 1)
+                .Repeat(world.Subscribe<EntityComponentChangedMessage<TKey>>(On), 1)
                 .Concat(subscriptions.Select(s => s(container, world)))
                 .Merge();
             _components = ComponentManager<TKey>.GetOrCreate(_worldId);
@@ -281,7 +281,7 @@ internal EntityMultiMap(
 
         #region Callbacks
 
-        private void On(in ComponentChangedMessage<TKey> message)
+        private void On(in EntityComponentChangedMessage<TKey> message)
         {
             if (message.EntityId < _mapping.Length)
             {
diff --git a/source/DefaultEcs/EntityQueryBuilder.cs b/source/DefaultEcs/EntityQueryBuilder.cs
index 1160280..38c61fb 100644
--- a/source/DefaultEcs/EntityQueryBuilder.cs
+++ b/source/DefaultEcs/EntityQueryBuilder.cs
@@ -59,10 +59,10 @@ private EitherBuilder OrWith<T>()
                     if (!_builder._withEitherFilter[flag])
                     {
                         _builder._withEitherFilter[flag] = true;
-                        _builder._nonReactSubscriptions.Add((s, w) => w.Subscribe<ComponentAddedMessage<T>>(s.CheckedAdd));
-                        _builder._nonReactSubscriptions.Add((s, w) => w.Subscribe<ComponentEnabledMessage<T>>(s.CheckedAdd));
-                        _builder._subscriptions.Add((s, w) => w.Subscribe<ComponentRemovedMessage<T>>(s.CheckedRemove));
-                        _builder._subscriptions.Add((s, w) => w.Subscribe<ComponentDisabledMessage<T>>(s.CheckedRemove));
+                        _builder._nonReactSubscriptions.Add((s, w) => w.Subscribe<EntityComponentAddedMessage<T>>(s.CheckedAdd));
+                        _builder._nonReactSubscriptions.Add((s, w) => w.Subscribe<EntityComponentEnabledMessage<T>>(s.CheckedAdd));
+                        _builder._subscriptions.Add((s, w) => w.Subscribe<EntityComponentRemovedMessage<T>>(s.CheckedRemove));
+                        _builder._subscriptions.Add((s, w) => w.Subscribe<EntityComponentDisabledMessage<T>>(s.CheckedRemove));
                     }
                 }
 
@@ -78,10 +78,10 @@ private EitherBuilder OrWithout<T>()
                     if (!_builder._withoutEitherFilter[flag])
                     {
                         _builder._withoutEitherFilter[flag] = true;
-                        _builder._nonReactSubscriptions.Add((s, w) => w.Subscribe<ComponentRemovedMessage<T>>(s.CheckedAdd));
-                        _builder._nonReactSubscriptions.Add((s, w) => w.Subscribe<ComponentDisabledMessage<T>>(s.CheckedAdd));
-                        _builder._subscriptions.Add((s, w) => w.Subscribe<ComponentAddedMessage<T>>(s.CheckedRemove));
-                        _builder._subscriptions.Add((s, w) => w.Subscribe<ComponentEnabledMessage<T>>(s.CheckedRemove));
+                        _builder._nonReactSubscriptions.Add((s, w) => w.Subscribe<EntityComponentRemovedMessage<T>>(s.CheckedAdd));
+                        _builder._nonReactSubscriptions.Add((s, w) => w.Subscribe<EntityComponentDisabledMessage<T>>(s.CheckedAdd));
+                        _builder._subscriptions.Add((s, w) => w.Subscribe<EntityComponentAddedMessage<T>>(s.CheckedRemove));
+                        _builder._subscriptions.Add((s, w) => w.Subscribe<EntityComponentEnabledMessage<T>>(s.CheckedRemove));
                     }
                 }
 
@@ -93,8 +93,8 @@ private EitherBuilder OrWhenAdded<T>()
                 if (!_builder._whenAddedFilter[ComponentManager<T>.Flag])
                 {
                     _builder._whenAddedFilter[ComponentManager<T>.Flag] = true;
-                    _builder._subscriptions.Add((s, w) => w.Subscribe<ComponentAddedMessage<T>>(s.CheckedAdd));
-                    _builder._subscriptions.Add((s, w) => w.Subscribe<ComponentEnabledMessage<T>>(s.CheckedAdd));
+                    _builder._subscriptions.Add((s, w) => w.Subscribe<EntityComponentAddedMessage<T>>(s.CheckedAdd));
+                    _builder._subscriptions.Add((s, w) => w.Subscribe<EntityComponentEnabledMessage<T>>(s.CheckedAdd));
                 }
 
                 return OrWith<T>();
@@ -107,7 +107,7 @@ private EitherBuilder OrWhenChanged<T>()
                     _builder._whenChangedFilter[ComponentManager<T>.Flag] = true;
                     if (!_builder._predicateFilter[ComponentManager<T>.Flag])
                     {
-                        _builder._subscriptions.Add((s, w) => w.Subscribe<ComponentChangedMessage<T>>(s.CheckedAdd));
+                        _builder._subscriptions.Add((s, w) => w.Subscribe<EntityComponentChangedMessage<T>>(s.CheckedAdd));
                     }
                 }
 
@@ -119,8 +119,8 @@ private EitherBuilder OrWhenRemoved<T>()
                 if (!_builder._whenRemovedFilter[ComponentManager<T>.Flag])
                 {
                     _builder._whenRemovedFilter[ComponentManager<T>.Flag] = true;
-                    _builder._subscriptions.Add((s, w) => w.Subscribe<ComponentRemovedMessage<T>>(s.CheckedAdd));
-                    _builder._subscriptions.Add((s, w) => w.Subscribe<ComponentDisabledMessage<T>>(s.CheckedAdd));
+                    _builder._subscriptions.Add((s, w) => w.Subscribe<EntityComponentRemovedMessage<T>>(s.CheckedAdd));
+                    _builder._subscriptions.Add((s, w) => w.Subscribe<EntityComponentDisabledMessage<T>>(s.CheckedAdd));
                 }
 
                 return OrWithout<T>();
@@ -386,10 +386,10 @@ public EntityQueryBuilder With<T>()
             if (!_withFilter[ComponentManager<T>.Flag])
             {
                 _withFilter[ComponentManager<T>.Flag] = true;
-                _nonReactSubscriptions.Add((s, w) => w.Subscribe<ComponentAddedMessage<T>>(s.CheckedAdd));
-                _nonReactSubscriptions.Add((s, w) => w.Subscribe<ComponentEnabledMessage<T>>(s.CheckedAdd));
-                _subscriptions.Add((s, w) => w.Subscribe<ComponentRemovedMessage<T>>(s.Remove));
-                _subscriptions.Add((s, w) => w.Subscribe<ComponentDisabledMessage<T>>(s.Remove));
+                _nonReactSubscriptions.Add((s, w) => w.Subscribe<EntityComponentAddedMessage<T>>(s.CheckedAdd));
+                _nonReactSubscriptions.Add((s, w) => w.Subscribe<EntityComponentEnabledMessage<T>>(s.CheckedAdd));
+                _subscriptions.Add((s, w) => w.Subscribe<EntityComponentRemovedMessage<T>>(s.Remove));
+                _subscriptions.Add((s, w) => w.Subscribe<EntityComponentDisabledMessage<T>>(s.Remove));
             }
 
             return this;
@@ -410,7 +410,7 @@ public EntityQueryBuilder With<T>(ComponentPredicate<T> predicate)
                 _predicateFilter[ComponentManager<T>.Flag] = true;
                 if (!_whenChangedFilter[ComponentManager<T>.Flag])
                 {
-                    _subscriptions.Add((s, w) => w.Subscribe<ComponentChangedMessage<T>>(s.AddOrRemove));
+                    _subscriptions.Add((s, w) => w.Subscribe<EntityComponentChangedMessage<T>>(s.AddOrRemove));
                 }
             }
 
@@ -429,10 +429,10 @@ public EntityQueryBuilder Without<T>()
             if (!_withoutFilter[ComponentManager<T>.Flag])
             {
                 _withoutFilter[ComponentManager<T>.Flag] = true;
-                _nonReactSubscriptions.Add((s, w) => w.Subscribe<ComponentRemovedMessage<T>>(s.CheckedAdd));
-                _nonReactSubscriptions.Add((s, w) => w.Subscribe<ComponentDisabledMessage<T>>(s.CheckedAdd));
-                _subscriptions.Add((s, w) => w.Subscribe<ComponentAddedMessage<T>>(s.Remove));
-                _subscriptions.Add((s, w) => w.Subscribe<ComponentEnabledMessage<T>>(s.Remove));
+                _nonReactSubscriptions.Add((s, w) => w.Subscribe<EntityComponentRemovedMessage<T>>(s.CheckedAdd));
+                _nonReactSubscriptions.Add((s, w) => w.Subscribe<EntityComponentDisabledMessage<T>>(s.CheckedAdd));
+                _subscriptions.Add((s, w) => w.Subscribe<EntityComponentAddedMessage<T>>(s.Remove));
+                _subscriptions.Add((s, w) => w.Subscribe<EntityComponentEnabledMessage<T>>(s.Remove));
             }
 
             return this;
@@ -448,8 +448,8 @@ public EntityQueryBuilder WhenAdded<T>()
             if (!_whenAddedFilter[ComponentManager<T>.Flag])
             {
                 _whenAddedFilter[ComponentManager<T>.Flag] = true;
-                _subscriptions.Add((s, w) => w.Subscribe<ComponentAddedMessage<T>>(s.CheckedAdd));
-                _subscriptions.Add((s, w) => w.Subscribe<ComponentEnabledMessage<T>>(s.CheckedAdd));
+                _subscriptions.Add((s, w) => w.Subscribe<EntityComponentAddedMessage<T>>(s.CheckedAdd));
+                _subscriptions.Add((s, w) => w.Subscribe<EntityComponentEnabledMessage<T>>(s.CheckedAdd));
             }
 
             return With<T>();
@@ -467,7 +467,7 @@ public EntityQueryBuilder WhenChanged<T>()
                 _whenChangedFilter[ComponentManager<T>.Flag] = true;
                 if (!_predicateFilter[ComponentManager<T>.Flag])
                 {
-                    _subscriptions.Add((s, w) => w.Subscribe<ComponentChangedMessage<T>>(s.CheckedAdd));
+                    _subscriptions.Add((s, w) => w.Subscribe<EntityComponentChangedMessage<T>>(s.CheckedAdd));
                 }
             }
 
@@ -484,8 +484,8 @@ public EntityQueryBuilder WhenRemoved<T>()
             if (!_whenRemovedFilter[ComponentManager<T>.Flag])
             {
                 _whenRemovedFilter[ComponentManager<T>.Flag] = true;
-                _subscriptions.Add((s, w) => w.Subscribe<ComponentRemovedMessage<T>>(s.CheckedAdd));
-                _subscriptions.Add((s, w) => w.Subscribe<ComponentDisabledMessage<T>>(s.CheckedAdd));
+                _subscriptions.Add((s, w) => w.Subscribe<EntityComponentRemovedMessage<T>>(s.CheckedAdd));
+                _subscriptions.Add((s, w) => w.Subscribe<EntityComponentDisabledMessage<T>>(s.CheckedAdd));
             }
 
             return Without<T>();
diff --git a/source/DefaultEcs/EntitySortedSet.cs b/source/DefaultEcs/EntitySortedSet.cs
index fa1697d..975a6c5 100644
--- a/source/DefaultEcs/EntitySortedSet.cs
+++ b/source/DefaultEcs/EntitySortedSet.cs
@@ -58,7 +58,7 @@ internal EntitySortedSet(
             _worldMaxCapacity = world.MaxCapacity == int.MaxValue ? int.MaxValue : (world.MaxCapacity + 1);
             EntityContainerWatcher container = new(this, filter, predicate);
             _subscriptions = Enumerable
-                .Repeat(world.Subscribe<ComponentChangedMessage<TComponent>>(On), 1)
+                .Repeat(world.Subscribe<EntityComponentChangedMessage<TComponent>>(On), 1)
                 .Concat(subscriptions.Select(s => s(container, world)))
                 .Merge();
             comparer ??= Comparer<TComponent>.Default;
@@ -86,7 +86,7 @@ internal EntitySortedSet(
 
         #region Callbacks
 
-        private void On(in ComponentChangedMessage<TComponent> message)
+        private void On(in EntityComponentChangedMessage<TComponent> message)
         {
             if (message.EntityId < _mapping.Length && _mapping[message.EntityId] != -1)
             {
diff --git a/source/DefaultEcs/Internal/EntityContainerWatcher.cs b/source/DefaultEcs/Internal/EntityContainerWatcher.cs
index c3e0309..f537734 100644
--- a/source/DefaultEcs/Internal/EntityContainerWatcher.cs
+++ b/source/DefaultEcs/Internal/EntityContainerWatcher.cs
@@ -30,7 +30,7 @@ public EntityContainerWatcher(DefaultEcs.IEntityContainer container, Predicate<C
 
         public void Add(in EntityCreatedMessage message) => _container.Add(message.EntityId);
 
-        public void AddOrRemove<T>(in ComponentChangedMessage<T> message)
+        public void AddOrRemove<T>(in EntityComponentChangedMessage<T> message)
         {
             if (_filter(message.Components))
             {
@@ -61,7 +61,7 @@ public void CheckedAdd(in EntityDisabledMessage message)
             }
         }
 
-        public void CheckedAdd<T>(in ComponentAddedMessage<T> message)
+        public void CheckedAdd<T>(in EntityComponentAddedMessage<T> message)
         {
             if (_filter(message.Components) && _predicate(message.EntityId))
             {
@@ -69,7 +69,7 @@ public void CheckedAdd<T>(in ComponentAddedMessage<T> message)
             }
         }
 
-        public void CheckedAdd<T>(in ComponentChangedMessage<T> message)
+        public void CheckedAdd<T>(in EntityComponentChangedMessage<T> message)
         {
             if (_filter(message.Components) && _predicate(message.EntityId))
             {
@@ -77,7 +77,7 @@ public void CheckedAdd<T>(in ComponentChangedMessage<T> message)
             }
         }
 
-        public void CheckedAdd<T>(in ComponentRemovedMessage<T> message)
+        public void CheckedAdd<T>(in EntityComponentRemovedMessage<T> message)
         {
             if (_filter(message.Components) && _predicate(message.EntityId))
             {
@@ -85,7 +85,7 @@ public void CheckedAdd<T>(in ComponentRemovedMessage<T> message)
             }
         }
 
-        public void CheckedAdd<T>(in ComponentEnabledMessage<T> message)
+        public void CheckedAdd<T>(in EntityComponentEnabledMessage<T> message)
         {
             if (_filter(message.Components) && _predicate(message.EntityId))
             {
@@ -93,7 +93,7 @@ public void CheckedAdd<T>(in ComponentEnabledMessage<T> message)
             }
         }
 
-        public void CheckedAdd<T>(in ComponentDisabledMessage<T> message)
+        public void CheckedAdd<T>(in EntityComponentDisabledMessage<T> message)
         {
             if (_filter(message.Components) && _predicate(message.EntityId))
             {
@@ -107,15 +107,15 @@ public void CheckedAdd<T>(in ComponentDisabledMessage<T> message)
 
         public void Remove(in EntityDisabledMessage message) => _container.Remove(message.EntityId);
 
-        public void Remove<T>(in ComponentAddedMessage<T> message) => _container.Remove(message.EntityId);
+        public void Remove<T>(in EntityComponentAddedMessage<T> message) => _container.Remove(message.EntityId);
 
-        public void Remove<T>(in ComponentRemovedMessage<T> message) => _container.Remove(message.EntityId);
+        public void Remove<T>(in EntityComponentRemovedMessage<T> message) => _container.Remove(message.EntityId);
 
-        public void Remove<T>(in ComponentEnabledMessage<T> message) => _container.Remove(message.EntityId);
+        public void Remove<T>(in EntityComponentEnabledMessage<T> message) => _container.Remove(message.EntityId);
 
-        public void Remove<T>(in ComponentDisabledMessage<T> message) => _container.Remove(message.EntityId);
+        public void Remove<T>(in EntityComponentDisabledMessage<T> message) => _container.Remove(message.EntityId);
 
-        public void CheckedRemove<T>(in ComponentAddedMessage<T> message)
+        public void CheckedRemove<T>(in EntityComponentAddedMessage<T> message)
         {
             if (!_filter(message.Components))
             {
@@ -123,7 +123,7 @@ public void CheckedRemove<T>(in ComponentAddedMessage<T> message)
             }
         }
 
-        public void CheckedRemove<T>(in ComponentRemovedMessage<T> message)
+        public void CheckedRemove<T>(in EntityComponentRemovedMessage<T> message)
         {
             if (!_filter(message.Components))
             {
@@ -131,7 +131,7 @@ public void CheckedRemove<T>(in ComponentRemovedMessage<T> message)
             }
         }
 
-        public void CheckedRemove<T>(in ComponentEnabledMessage<T> message)
+        public void CheckedRemove<T>(in EntityComponentEnabledMessage<T> message)
         {
             if (!_filter(message.Components))
             {
@@ -139,7 +139,7 @@ public void CheckedRemove<T>(in ComponentEnabledMessage<T> message)
             }
         }
 
-        public void CheckedRemove<T>(in ComponentDisabledMessage<T> message)
+        public void CheckedRemove<T>(in EntityComponentDisabledMessage<T> message)
         {
             if (!_filter(message.Components))
             {
diff --git a/source/DefaultEcs/Internal/Messages/ComponentAddedMessage.cs b/source/DefaultEcs/Internal/Messages/ComponentAddedMessage.cs
deleted file mode 100644
index 48fb480..0000000
--- a/source/DefaultEcs/Internal/Messages/ComponentAddedMessage.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct ComponentAddedMessage<T>(
-        int EntityId,
-        ComponentEnum Components);
-}
diff --git a/source/DefaultEcs/Internal/Messages/ComponentChangedMessage.cs b/source/DefaultEcs/Internal/Messages/ComponentChangedMessage.cs
deleted file mode 100644
index 01b7d3b..0000000
--- a/source/DefaultEcs/Internal/Messages/ComponentChangedMessage.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct ComponentChangedMessage<T>(
-        int EntityId,
-        ComponentEnum Components);
-}
diff --git a/source/DefaultEcs/Internal/Messages/ComponentDisabledMessage.cs b/source/DefaultEcs/Internal/Messages/ComponentDisabledMessage.cs
deleted file mode 100644
index 594d91e..0000000
--- a/source/DefaultEcs/Internal/Messages/ComponentDisabledMessage.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct ComponentDisabledMessage<T>(
-        int EntityId,
-        ComponentEnum Components);
-}
diff --git a/source/DefaultEcs/Internal/Messages/ComponentEnabledMessage.cs b/source/DefaultEcs/Internal/Messages/ComponentEnabledMessage.cs
deleted file mode 100644
index cf8f42d..0000000
--- a/source/DefaultEcs/Internal/Messages/ComponentEnabledMessage.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct ComponentEnabledMessage<T>(
-        int EntityId,
-        ComponentEnum Components);
-}
diff --git a/source/DefaultEcs/Internal/Messages/ComponentRemovedMessage.cs b/source/DefaultEcs/Internal/Messages/ComponentRemovedMessage.cs
deleted file mode 100644
index 6a7c0ab..0000000
--- a/source/DefaultEcs/Internal/Messages/ComponentRemovedMessage.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct ComponentRemovedMessage<T>(
-        int EntityId,
-        ComponentEnum Components);
-}
diff --git a/source/DefaultEcs/Internal/Messages/EntityCreatedMessage .cs b/source/DefaultEcs/Internal/Messages/EntityCreatedMessage .cs
deleted file mode 100644
index 780ce34..0000000
--- a/source/DefaultEcs/Internal/Messages/EntityCreatedMessage .cs	
+++ /dev/null
@@ -1,5 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct EntityCreatedMessage(
-        int EntityId);
-}
diff --git a/source/DefaultEcs/Internal/Messages/EntityDisabledMessage.cs b/source/DefaultEcs/Internal/Messages/EntityDisabledMessage.cs
deleted file mode 100644
index 438b649..0000000
--- a/source/DefaultEcs/Internal/Messages/EntityDisabledMessage.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct EntityDisabledMessage(
-        int EntityId,
-        ComponentEnum Components);
-}
diff --git a/source/DefaultEcs/Internal/Messages/EntityDisposedMessage.cs b/source/DefaultEcs/Internal/Messages/EntityDisposedMessage.cs
deleted file mode 100644
index efa31e0..0000000
--- a/source/DefaultEcs/Internal/Messages/EntityDisposedMessage.cs
+++ /dev/null
@@ -1,5 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct EntityDisposedMessage(
-        int EntityId);
-}
diff --git a/source/DefaultEcs/Internal/Messages/EntityDisposingMessage.cs b/source/DefaultEcs/Internal/Messages/EntityDisposingMessage.cs
deleted file mode 100644
index 0e29db0..0000000
--- a/source/DefaultEcs/Internal/Messages/EntityDisposingMessage.cs
+++ /dev/null
@@ -1,5 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct EntityDisposingMessage(
-        int EntityId);
-}
diff --git a/source/DefaultEcs/Internal/Messages/EntityEnabledMessage.cs b/source/DefaultEcs/Internal/Messages/EntityEnabledMessage.cs
deleted file mode 100644
index 74f660d..0000000
--- a/source/DefaultEcs/Internal/Messages/EntityEnabledMessage.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct EntityEnabledMessage(
-        int EntityId,
-        ComponentEnum Components);
-}
diff --git a/source/DefaultEcs/Internal/Messages/EntityMessages.cs b/source/DefaultEcs/Internal/Messages/EntityMessages.cs
new file mode 100644
index 0000000..a2c1b37
--- /dev/null
+++ b/source/DefaultEcs/Internal/Messages/EntityMessages.cs
@@ -0,0 +1,39 @@
+namespace DefaultEcs.Internal.Messages
+{
+    internal readonly record struct EntityCreatedMessage(
+        int EntityId);
+
+    internal readonly record struct EntityEnabledMessage(
+        int EntityId,
+        ComponentEnum Components);
+
+    internal readonly record struct EntityDisabledMessage(
+        int EntityId,
+        ComponentEnum Components);
+
+    internal readonly record struct EntityDisposingMessage(
+        int EntityId);
+
+    internal readonly record struct EntityDisposedMessage(
+        int EntityId);
+
+    internal readonly record struct EntityComponentAddedMessage<T>(
+        int EntityId,
+        ComponentEnum Components);
+
+    internal readonly record struct EntityComponentChangedMessage<T>(
+        int EntityId,
+        ComponentEnum Components);
+
+    internal readonly record struct EntityComponentRemovedMessage<T>(
+        int EntityId,
+        ComponentEnum Components);
+
+    internal readonly record struct EntityComponentEnabledMessage<T>(
+        int EntityId,
+        ComponentEnum Components);
+
+    internal readonly record struct EntityComponentDisabledMessage<T>(
+        int EntityId,
+        ComponentEnum Components);
+}
diff --git a/source/DefaultEcs/Internal/Messages/WorldComponentAddedMessage.cs b/source/DefaultEcs/Internal/Messages/WorldComponentAddedMessage.cs
deleted file mode 100644
index 21964c2..0000000
--- a/source/DefaultEcs/Internal/Messages/WorldComponentAddedMessage.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct WorldComponentAddedMessage<T>;
-}
diff --git a/source/DefaultEcs/Internal/Messages/WorldComponentChangedMessage.cs b/source/DefaultEcs/Internal/Messages/WorldComponentChangedMessage.cs
deleted file mode 100644
index 2a4d000..0000000
--- a/source/DefaultEcs/Internal/Messages/WorldComponentChangedMessage.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct WorldComponentChangedMessage<T>;
-}
diff --git a/source/DefaultEcs/Internal/Messages/WorldComponentRemovedMessage.cs b/source/DefaultEcs/Internal/Messages/WorldComponentRemovedMessage.cs
deleted file mode 100644
index 67eb0be..0000000
--- a/source/DefaultEcs/Internal/Messages/WorldComponentRemovedMessage.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct WorldComponentRemovedMessage<T>;
-}
diff --git a/source/DefaultEcs/Internal/Messages/WorldDisposedMessage.cs b/source/DefaultEcs/Internal/Messages/WorldDisposedMessage.cs
deleted file mode 100644
index 5c49b54..0000000
--- a/source/DefaultEcs/Internal/Messages/WorldDisposedMessage.cs
+++ /dev/null
@@ -1,5 +0,0 @@
-namespace DefaultEcs.Internal.Messages
-{
-    internal readonly record struct WorldDisposedMessage(
-        int WorldId);
-}
diff --git a/source/DefaultEcs/Internal/Messages/WorldMessages.cs b/source/DefaultEcs/Internal/Messages/WorldMessages.cs
new file mode 100644
index 0000000..336c632
--- /dev/null
+++ b/source/DefaultEcs/Internal/Messages/WorldMessages.cs
@@ -0,0 +1,11 @@
+namespace DefaultEcs.Internal.Messages
+{
+    internal readonly record struct WorldComponentAddedMessage<T>;
+
+    internal readonly record struct WorldComponentChangedMessage<T>;
+
+    internal readonly record struct WorldComponentRemovedMessage<T>;
+
+    internal readonly record struct WorldDisposedMessage(
+        int WorldId);
+}
diff --git a/source/DefaultEcs/Resource/AResourceManager.cs b/source/DefaultEcs/Resource/AResourceManager.cs
index 04a9013..3f66e83 100644
--- a/source/DefaultEcs/Resource/AResourceManager.cs
+++ b/source/DefaultEcs/Resource/AResourceManager.cs
@@ -274,12 +274,12 @@ public IDisposable Manage(World world)
         {
             IEnumerable<IDisposable> GetSubscriptions(World w)
             {
-                yield return w.SubscribeComponentAdded<ManagedResource<TInfo, TResource>>(OnAdded);
-                yield return w.SubscribeComponentChanged<ManagedResource<TInfo, TResource>>(OnChanged);
-                yield return w.SubscribeComponentRemoved<ManagedResource<TInfo, TResource>>(OnRemoved);
-                yield return w.SubscribeComponentAdded<ManagedResource<TInfo[], TResource>>(OnAdded);
-                yield return w.SubscribeComponentChanged<ManagedResource<TInfo[], TResource>>(OnChanged);
-                yield return w.SubscribeComponentRemoved<ManagedResource<TInfo[], TResource>>(OnRemoved);
+                yield return w.SubscribeEntityComponentAdded<ManagedResource<TInfo, TResource>>(OnAdded);
+                yield return w.SubscribeEntityComponentChanged<ManagedResource<TInfo, TResource>>(OnChanged);
+                yield return w.SubscribeEntityComponentRemoved<ManagedResource<TInfo, TResource>>(OnRemoved);
+                yield return w.SubscribeEntityComponentAdded<ManagedResource<TInfo[], TResource>>(OnAdded);
+                yield return w.SubscribeEntityComponentChanged<ManagedResource<TInfo[], TResource>>(OnChanged);
+                yield return w.SubscribeEntityComponentRemoved<ManagedResource<TInfo[], TResource>>(OnRemoved);
             }
 
             world.ThrowIfNull();
diff --git a/source/DefaultEcs/World.cs b/source/DefaultEcs/World.cs
index b246ae1..2ed3142 100644
--- a/source/DefaultEcs/World.cs
+++ b/source/DefaultEcs/World.cs
@@ -530,52 +530,52 @@ IEnumerable<IDisposable> GetSubscriptions(EntityDisposedHandler a)
         }
 
         /// <summary>
-        /// Subscribes a <see cref="ComponentAddedHandler{T}"/> on the current <see cref="World"/> to be called when a component of type <typeparamref name="T"/> is added.
+        /// Subscribes a <see cref="EntityComponentAddedHandler{T}"/> on the current <see cref="World"/> to be called when a component of type <typeparamref name="T"/> is added.
         /// </summary>
         /// <typeparam name="T">The type of the component.</typeparam>
-        /// <param name="action">The <see cref="ComponentAddedHandler{T}"/> to be called.</param>
+        /// <param name="action">The <see cref="EntityComponentAddedHandler{T}"/> to be called.</param>
         /// <returns>An <see cref="IDisposable"/> object used to unsubscribe.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
-        public IDisposable SubscribeComponentAdded<T>(ComponentAddedHandler<T> action)
+        public IDisposable SubscribeEntityComponentAdded<T>(EntityComponentAddedHandler<T> action)
         {
             action.ThrowIfNull();
 
-            return Subscribe((in ComponentAddedMessage<T> message) => action(
+            return Subscribe((in EntityComponentAddedMessage<T> message) => action(
                 new Entity(WorldId, message.EntityId),
                 ComponentManager<T>.Get(WorldId).Get(message.EntityId)));
         }
 
         /// <summary>
-        /// Subscribes a <see cref="ComponentChangedHandler{T}"/> on the current <see cref="World"/> to be called when a component of type <typeparamref name="T"/> is changed.
+        /// Subscribes a <see cref="EntityComponentChangedHandler{T}"/> on the current <see cref="World"/> to be called when a component of type <typeparamref name="T"/> is changed.
         /// </summary>
         /// <typeparam name="T">The type of the component.</typeparam>
-        /// <param name="action">The <see cref="ComponentChangedHandler{T}"/> to be called.</param>
+        /// <param name="action">The <see cref="EntityComponentChangedHandler{T}"/> to be called.</param>
         /// <returns>An <see cref="IDisposable"/> object used to unsubscribe.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
-        public IDisposable SubscribeComponentChanged<T>(ComponentChangedHandler<T> action)
+        public IDisposable SubscribeEntityComponentChanged<T>(EntityComponentChangedHandler<T> action)
         {
             action.ThrowIfNull();
 
             ComponentManager<T>.GetOrCreatePrevious(WorldId);
 
-            return Subscribe((in ComponentChangedMessage<T> message) => action(
+            return Subscribe((in EntityComponentChangedMessage<T> message) => action(
                 new Entity(WorldId, message.EntityId),
                 ComponentManager<T>.GetPrevious(WorldId).Get(message.EntityId),
                 ComponentManager<T>.Get(WorldId).Get(message.EntityId)));
         }
 
         /// <summary>
-        /// Subscribes an <see cref="ComponentRemovedHandler{T}"/> on the current <see cref="World"/> to be called when a component of type <typeparamref name="T"/> is removed.
+        /// Subscribes an <see cref="EntityComponentRemovedHandler{T}"/> on the current <see cref="World"/> to be called when a component of type <typeparamref name="T"/> is removed.
         /// </summary>
         /// <typeparam name="T">The type of the component.</typeparam>
-        /// <param name="action">The <see cref="ComponentRemovedHandler{T}"/> to be called.</param>
+        /// <param name="action">The <see cref="EntityComponentRemovedHandler{T}"/> to be called.</param>
         /// <returns>An <see cref="IDisposable"/> object used to unsubscribe.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
-        public IDisposable SubscribeComponentRemoved<T>(ComponentRemovedHandler<T> action)
+        public IDisposable SubscribeEntityComponentRemoved<T>(EntityComponentRemovedHandler<T> action)
         {
-            IEnumerable<IDisposable> GetSubscriptions(ComponentRemovedHandler<T> a)
+            IEnumerable<IDisposable> GetSubscriptions(EntityComponentRemovedHandler<T> a)
             {
-                yield return Subscribe((in ComponentRemovedMessage<T> message) => a(
+                yield return Subscribe((in EntityComponentRemovedMessage<T> message) => a(
                     new Entity(WorldId, message.EntityId),
                     ComponentManager<T>.GetPrevious(WorldId).Get(message.EntityId)));
                 yield return Subscribe((in EntityDisposingMessage message) =>
@@ -607,33 +607,33 @@ IEnumerable<IDisposable> GetSubscriptions(ComponentRemovedHandler<T> a)
         }
 
         /// <summary>
-        /// Subscribes a <see cref="ComponentEnabledHandler{T}"/> on the current <see cref="World"/> to be called when a component of type <typeparamref name="T"/> is enabled.
+        /// Subscribes a <see cref="EntityComponentEnabledHandler{T}"/> on the current <see cref="World"/> to be called when a component of type <typeparamref name="T"/> is enabled.
         /// </summary>
         /// <typeparam name="T">The type of the component.</typeparam>
-        /// <param name="action">The <see cref="ComponentEnabledHandler{T}"/> to be called.</param>
+        /// <param name="action">The <see cref="EntityComponentEnabledHandler{T}"/> to be called.</param>
         /// <returns>An <see cref="IDisposable"/> object used to unsubscribe.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
-        public IDisposable SubscribeComponentEnabled<T>(ComponentEnabledHandler<T> action)
+        public IDisposable SubscribeEntityComponentEnabled<T>(EntityComponentEnabledHandler<T> action)
         {
             action.ThrowIfNull();
 
-            return Subscribe((in ComponentEnabledMessage<T> message) => action(
+            return Subscribe((in EntityComponentEnabledMessage<T> message) => action(
                 new Entity(WorldId, message.EntityId),
                 ComponentManager<T>.Get(WorldId).Get(message.EntityId)));
         }
 
         /// <summary>
-        /// Subscribes a <see cref="ComponentDisabledHandler{T}"/> on the current <see cref="World"/> to be called when a component of type <typeparamref name="T"/> is disabled.
+        /// Subscribes a <see cref="EntityComponentDisabledHandler{T}"/> on the current <see cref="World"/> to be called when a component of type <typeparamref name="T"/> is disabled.
         /// </summary>
         /// <typeparam name="T">The type of the component.</typeparam>
-        /// <param name="action">The <see cref="ComponentDisabledHandler{T}"/> to be called.</param>
+        /// <param name="action">The <see cref="EntityComponentDisabledHandler{T}"/> to be called.</param>
         /// <returns>An <see cref="IDisposable"/> object used to unsubscribe.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
-        public IDisposable SubscribeComponentDisabled<T>(ComponentDisabledHandler<T> action)
+        public IDisposable SubscribeEntityComponentDisabled<T>(EntityComponentDisabledHandler<T> action)
         {
             action.ThrowIfNull();
 
-            return Subscribe((in ComponentDisabledMessage<T> message) => action(
+            return Subscribe((in EntityComponentDisabledMessage<T> message) => action(
                 new Entity(WorldId, message.EntityId),
                 ComponentManager<T>.Get(WorldId).Get(message.EntityId)));
         }