com.artromskiy.deltaecs.unity 0.0.64 → 0.0.66

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.0.66
+
+- Published with the matching DeltaECS NuGet packages.
+
+## 0.0.65
+
+- Published with the matching DeltaECS NuGet packages.
+
 ## 0.0.64
 
 - Published with the matching DeltaECS NuGet packages.

package/Editor/HierarchyNodeHandler.cs

@@ -19,25 +19,31 @@ namespace Delta.ECS.Unity.Editor
     internal sealed class HierarchyNodeHandler : HierarchyNodeTypeHandler
     {
         private const double RuntimeHierarchyRefreshInterval = 0.5d;
-        private static readonly ComponentId[] NoRequiredComponents = Array.Empty<ComponentId>();
         private static readonly SchemaId HiddenEntitySchema = new(ViewComponentSchemaIds.HideFromEntityHierarchy);
         private static double _nextRuntimeHierarchyRefresh;
         private static bool _wasPlaying;
+        private static bool _authoringsDirty = true;
+        private static SceneAuthoring[] _authorings = Array.Empty<SceneAuthoring>();
         private static readonly HashSet<HierarchyNodeHandler> Instances = new();
 
         private readonly Dictionary<EntityKey, EntityNode> _entityNodes = new();
+        private readonly Dictionary<SceneAuthoring, RuntimeHierarchyState> _runtimeStates = new();
         private readonly HashSet<EntityKey> _activeEntityKeys = new();
         private readonly List<EntityKey> _removedEntityKeys = new();
         private readonly Dictionary<HierarchyNode, NodeReference> _nodes = new();
         private readonly HashSet<HierarchyView> _boundViews = new();
         private readonly Dictionary<HierarchyView, BlockedDrag> _blockedDrags = new();
         private readonly Dictionary<SceneAuthoring, Action<SceneDataChange>> _sceneDataSubscriptions = new();
+        private readonly HashSet<SceneAuthoring> _loadedAuthorings = new();
+        private readonly List<SceneAuthoring> _removedAuthorings = new();
 
         static HierarchyNodeHandler()
         {
             HierarchyWindow.BindView += BindHierarchyView;
             EditorApplication.delayCall += BindExistingHierarchyViews;
             EditorApplication.update += UpdateRuntimeHierarchy;
+            SceneAuthoring.HierarchyChanged += InvalidateAuthorings;
+            SceneWorld.LiveWorldsChanged += InvalidateAuthorings;
         }
 
         public override string GetNodeTypeName() => nameof(HierarchyNodeHandler);
@@ -97,7 +103,14 @@ namespace Delta.ECS.Unity.Editor
                     pair.Key.SceneData.Changed -= pair.Value;
                 }
             }
+            foreach (RuntimeHierarchyState state in _runtimeStates.Values)
+            {
+                state.Dispose();
+            }
+            _runtimeStates.Clear();
             _sceneDataSubscriptions.Clear();
+            _loadedAuthorings.Clear();
+            _removedAuthorings.Clear();
             _entityNodes.Clear();
             _activeEntityKeys.Clear();
             _removedEntityKeys.Clear();
@@ -147,6 +160,8 @@ namespace Delta.ECS.Unity.Editor
 
         internal static void RefreshAll()
         {
+            InvalidateAuthorings();
+            GetAuthorings();
             var changed = false;
             foreach (var instance in Instances)
             {
@@ -203,7 +218,22 @@ namespace Delta.ECS.Unity.Editor
                 }
 
                 _nextRuntimeHierarchyRefresh = EditorApplication.timeSinceStartup + RuntimeHierarchyRefreshInterval;
-                RefreshAll();
+                if (_authoringsDirty)
+                {
+                    RefreshAll();
+                }
+                else
+                {
+                    bool changed = false;
+                    foreach (HierarchyNodeHandler instance in Instances)
+                    {
+                        changed |= instance.RefreshRuntimeChanges();
+                    }
+                    if (changed)
+                    {
+                        EditorApplication.RepaintHierarchyWindow();
+                    }
+                }
                 return;
             }
 
@@ -214,6 +244,18 @@ namespace Delta.ECS.Unity.Editor
             }
         }
 
+        private static void InvalidateAuthorings() => _authoringsDirty = true;
+
+        private static SceneAuthoring[] GetAuthorings()
+        {
+            if (_authoringsDirty)
+            {
+                _authorings = Resources.FindObjectsOfTypeAll<SceneAuthoring>();
+                _authoringsDirty = false;
+            }
+            return _authorings;
+        }
+
         private static void BindHierarchyView(HierarchyWindow window, HierarchyView view)
         {
             if (view == null)
@@ -429,19 +471,46 @@ namespace Delta.ECS.Unity.Editor
             }
         }
 
-        private bool Reconcile()
+        private bool Reconcile(bool changed = false)
         {
             if (!Hierarchy.IsCreated)
             {
                 return false;
             }
 
-            var changed = false;
             _activeEntityKeys.Clear();
 
             var sceneHandler = Hierarchy.GetNodeTypeHandler<HierarchySceneHandler>();
-            var authoringsInScenes = Resources.FindObjectsOfTypeAll<SceneAuthoring>();
+            var authoringsInScenes = GetAuthorings();
             SynchronizeSceneSubscriptions(authoringsInScenes);
+            foreach (var pair in _runtimeStates)
+            {
+                if (!EditorApplication.isPlaying || !pair.Value.World.IsBound
+                    || !SceneWorld.TryFindLiveWorld(pair.Key.SceneData, out SceneWorld liveWorld)
+                    || !ReferenceEquals(liveWorld, pair.Value.World))
+                {
+                    _removedAuthorings.Add(pair.Key);
+                }
+            }
+            foreach (SceneAuthoring authoring in _removedAuthorings)
+            {
+                _runtimeStates[authoring].Dispose();
+                _runtimeStates.Remove(authoring);
+            }
+            _removedAuthorings.Clear();
+            // Runtime nodes survive authored-data reconciliation. Their own dirty queue
+            // removes destroyed, hidden or newly bound entities below.
+            foreach (var pair in _entityNodes)
+            {
+                NodeReference reference = pair.Value.Reference;
+                if (reference.IsRuntimeOnly && reference.RuntimeWorld.IsBound
+                    && _loadedAuthorings.Contains(reference.Authoring)
+                    && _runtimeStates.TryGetValue(reference.Authoring, out RuntimeHierarchyState state)
+                    && ReferenceEquals(state.World, reference.RuntimeWorld))
+                {
+                    _activeEntityKeys.Add(pair.Key);
+                }
+            }
             for (var i = 0; i < authoringsInScenes.Length; i++)
             {
                 var authoringHost = authoringsInScenes[i];
@@ -461,6 +530,7 @@ namespace Delta.ECS.Unity.Editor
                 {
                     SceneWorld.TryFindLiveWorld(authoringHost.SceneData, out runtimeWorld);
                 }
+                runtimeWorld?.RefreshDestroyedViews();
 
                 var entities = authoringHost.SceneData.Entities;
                 for (var entityIndex = 0; entityIndex < entities.Count; entityIndex++)
@@ -481,8 +551,7 @@ namespace Delta.ECS.Unity.Editor
                         : default;
                     bool hasView = authoringHost.TryGetView(authoring.StableId, out _)
                         || (runtimeWorld != null
-                            && runtimeWorld.World.IsAlive(runtimeEntity)
-                            && runtimeWorld.TryGetView(runtimeEntity, out _));
+                            && runtimeWorld.HasRuntimeView(runtimeEntity));
                     if (hasView || IsHiddenFromHierarchy(authoring, runtimeWorld, runtimeEntity))
                     {
                         continue;
@@ -553,27 +622,7 @@ namespace Delta.ECS.Unity.Editor
 
             for (var i = 0; i < _removedEntityKeys.Count; i++)
             {
-                var key = _removedEntityKeys[i];
-                var entityNode = _entityNodes[key];
-                if (entityNode.Reference.IsRuntimeOnly)
-                {
-                    HierarchySelection.ClearIfSelected(
-                        entityNode.Reference.RuntimeWorld,
-                        entityNode.Reference.RuntimeEntity);
-                }
-                else
-                {
-                    HierarchySelection.ClearIfSelected(this, entityNode.Reference.Authoring, entityNode.Reference.StableId);
-                }
-                if (Hierarchy.Exists(entityNode.Node))
-                {
-                    CommandList.Remove(entityNode.Node);
-                }
-
-                SelectionProxyBridge.Remove(this, entityNode.Node);
-                _nodes.Remove(entityNode.Node);
-                _entityNodes.Remove(key);
-                changed = true;
+                changed |= RemoveEntityNode(_removedEntityKeys[i]);
             }
 
             if (CommandList.Size > 0)
@@ -594,54 +643,108 @@ namespace Delta.ECS.Unity.Editor
             HierarchyNode sceneNode,
             SceneWorld runtimeWorld)
         {
-            Query query = runtimeWorld.World.WhereNone(runtimeWorld.HiddenEntityHierarchyComponentId)
-                .WhereAll(NoRequiredComponents);
+            if (!_runtimeStates.TryGetValue(authoring, out RuntimeHierarchyState state)
+                || !ReferenceEquals(state.World, runtimeWorld))
+            {
+                state?.Dispose();
+                state = new RuntimeHierarchyState(runtimeWorld);
+                _runtimeStates[authoring] = state;
+            }
+            state.PrepareChanges();
+            return state.Synchronize(this, authoring, sceneNode, out _);
+        }
+
+        private bool RefreshRuntimeChanges()
+        {
+            if (!Hierarchy.IsCreated)
+            {
+                return false;
+            }
             bool changed = false;
-            runtimeWorld.World.ForEachEntity(in query, entity =>
+            bool authoredChanged = false;
+            foreach (var pair in _runtimeStates)
             {
-                if (runtimeWorld.TryGetStableId(entity, out _) || runtimeWorld.TryGetView(entity, out _))
+                RuntimeHierarchyState state = pair.Value;
+                if (!state.World.IsBound || !state.PrepareChanges())
                 {
-                    return;
+                    continue;
                 }
-
-                var key = new EntityKey(runtimeWorld, entity);
-                _activeEntityKeys.Add(key);
-                string name = $"ECS Entity {entity.Index}:{entity.Generation}";
-                var reference = new NodeReference(authoring, null, runtimeWorld, entity);
-                if (_entityNodes.TryGetValue(key, out EntityNode entityNode))
+                var sceneHandler = Hierarchy.GetNodeTypeHandler<HierarchySceneHandler>();
+                HierarchyNode sceneNode = sceneHandler.GetOrCreateNode(pair.Key.gameObject.scene);
+                if (sceneNode != HierarchyNode.Null)
                 {
-                    if (entityNode.Reference.RuntimeWorld != reference.RuntimeWorld
-                        || entityNode.Reference.RuntimeEntity != reference.RuntimeEntity)
-                    {
-                        entityNode.Reference = reference;
-                        changed = true;
-                    }
-
-                    if (!string.Equals(entityNode.Name, name, StringComparison.Ordinal))
-                    {
-                        CommandList.SetName(entityNode.Node, name);
-                        entityNode.Name = name;
-                        changed = true;
-                    }
-
-                    _entityNodes[key] = entityNode;
-                    _nodes[entityNode.Node] = reference;
-                    return;
+                    changed |= state.Synchronize(this, pair.Key, sceneNode, out bool dirtyAuthoring);
+                    authoredChanged |= dirtyAuthoring;
                 }
+            }
+            if (authoredChanged)
+            {
+                return Reconcile(changed);
+            }
+            if (!changed)
+            {
+                return false;
+            }
+            if (CommandList.Size > 0)
+            {
+                CommandList.Execute();
+            }
+            Hierarchy.Update();
+            return true;
+        }
 
-                CommandList.Add(sceneNode, out HierarchyNode node);
-                CommandList.SetName(node, name);
-                _entityNodes.Add(key, new EntityNode(node, reference, name));
-                _nodes.Add(node, reference);
-                changed = true;
-            }).Invoke();
+        private bool SynchronizeRuntimeEntity(SceneAuthoring authoring, HierarchyNode sceneNode,
+            SceneWorld runtimeWorld, Entity entity)
+        {
+            var key = new EntityKey(runtimeWorld, entity);
+            if (!runtimeWorld.World.IsAlive(entity)
+                || runtimeWorld.HasRuntimeView(entity)
+                || runtimeWorld.World.Has(entity, runtimeWorld.HiddenEntityHierarchyComponentId))
+            {
+                _activeEntityKeys.Remove(key);
+                return RemoveEntityNode(key);
+            }
+            _activeEntityKeys.Add(key);
+            if (_entityNodes.TryGetValue(key, out _))
+            {
+                return false;
+            }
+            string name = $"ECS Entity {entity.Index}:{entity.Generation}";
+            var reference = new NodeReference(authoring, null, runtimeWorld, entity);
+            CommandList.Add(sceneNode, out HierarchyNode node);
+            CommandList.SetName(node, name);
+            _entityNodes.Add(key, new EntityNode(node, reference, name));
+            _nodes.Add(node, reference);
+            return true;
+        }
 
-            return changed;
+        private bool RemoveEntityNode(EntityKey key)
+        {
+            if (!_entityNodes.Remove(key, out EntityNode entityNode))
+            {
+                return false;
+            }
+            NodeReference reference = entityNode.Reference;
+            if (reference.IsRuntimeOnly)
+            {
+                HierarchySelection.ClearIfSelected(reference.RuntimeWorld, reference.RuntimeEntity);
+            }
+            else
+            {
+                HierarchySelection.ClearIfSelected(this, reference.Authoring, reference.StableId);
+            }
+            if (Hierarchy.Exists(entityNode.Node))
+            {
+                CommandList.Remove(entityNode.Node);
+            }
+            SelectionProxyBridge.Remove(this, entityNode.Node);
+            _nodes.Remove(entityNode.Node);
+            return true;
         }
 
         private void SynchronizeSceneSubscriptions(SceneAuthoring[] authorings)
         {
-            var loadedAuthorings = new HashSet<SceneAuthoring>();
+            _loadedAuthorings.Clear();
             for (var i = 0; i < authorings.Length; i++)
             {
                 var authoring = authorings[i];
@@ -650,7 +753,7 @@ namespace Delta.ECS.Unity.Editor
                     continue;
                 }
 
-                loadedAuthorings.Add(authoring);
+                _loadedAuthorings.Add(authoring);
                 if (!_sceneDataSubscriptions.ContainsKey(authoring))
                 {
                     var capturedAuthoring = authoring;
@@ -660,29 +763,35 @@ namespace Delta.ECS.Unity.Editor
                 }
             }
 
-            if (_sceneDataSubscriptions.Count == loadedAuthorings.Count)
+            if (_sceneDataSubscriptions.Count == _loadedAuthorings.Count)
             {
                 return;
             }
 
-            var removed = new List<SceneAuthoring>();
+            _removedAuthorings.Clear();
             foreach (var authoring in _sceneDataSubscriptions.Keys)
             {
-                if (!loadedAuthorings.Contains(authoring))
+                if (!_loadedAuthorings.Contains(authoring))
                 {
-                    removed.Add(authoring);
+                    _removedAuthorings.Add(authoring);
                 }
             }
 
-            for (var i = 0; i < removed.Count; i++)
+            for (var i = 0; i < _removedAuthorings.Count; i++)
             {
-                var authoring = removed[i];
+                var authoring = _removedAuthorings[i];
                 if (authoring != null)
                 {
                     authoring.SceneData.Changed -= _sceneDataSubscriptions[authoring];
                 }
                 _sceneDataSubscriptions.Remove(authoring);
+                if (_runtimeStates.Remove(authoring, out RuntimeHierarchyState state))
+                {
+                    state.Dispose();
+                }
             }
+
+            _removedAuthorings.Clear();
         }
 
         private void OnSceneDataChanged(SceneAuthoring authoring, SceneDataChange change)
@@ -880,6 +989,64 @@ namespace Delta.ECS.Unity.Editor
             }
         }
 
+        private sealed class RuntimeHierarchyState : IDisposable
+        {
+            private readonly HashSet<Entity> _dirtyEntities = new();
+            private readonly ComponentChangeOperation<HideFromEntityHierarchy> _hiddenChanges;
+            internal SceneWorld World { get; }
+
+            internal RuntimeHierarchyState(SceneWorld world)
+            {
+                World = world;
+                world.HierarchyEntitiesChanged += Queue;
+                _hiddenChanges = world.World.ForEachChange<HideFromEntityHierarchy>(
+                    world.HiddenEntityHierarchyComponentId, OnHiddenChanged);
+                // One snapshot, without tag-slot cache or repeated per-refresh operations.
+                Query query = world.World.WhereNone(ReadOnlySpan<ComponentId>.Empty);
+                world.World.ForEachEntity(in query, QueueInitialEntity).Invoke();
+            }
+
+            public void Dispose() => World.HierarchyEntitiesChanged -= Queue;
+
+            internal bool PrepareChanges()
+            {
+                World.RefreshDestroyedViews();
+                _hiddenChanges.Invoke();
+                return _dirtyEntities.Count != 0;
+            }
+
+            internal bool Synchronize(HierarchyNodeHandler handler, SceneAuthoring authoring,
+                HierarchyNode sceneNode, out bool authoredChanged)
+            {
+                bool changed = false;
+                authoredChanged = false;
+                foreach (Entity entity in _dirtyEntities)
+                {
+                    if (World.TryGetStableId(entity, out _))
+                    {
+                        authoredChanged = true;
+                    }
+                    else
+                    {
+                        changed |= handler.SynchronizeRuntimeEntity(authoring, sceneNode, World, entity);
+                    }
+                }
+                _dirtyEntities.Clear();
+                return changed;
+            }
+
+            private void QueueInitialEntity(EntityRef entity) => _dirtyEntities.Add(entity);
+            private void OnHiddenChanged(Entity entity, ChangeKind kind, ref HideFromEntityHierarchy value)
+                => _dirtyEntities.Add(entity);
+            private void Queue(ReadOnlySpan<Entity> entities)
+            {
+                foreach (Entity entity in entities)
+                {
+                    _dirtyEntities.Add(entity);
+                }
+            }
+        }
+
         private struct BlockedDrag
         {
             public readonly int PointerId;

package/README.md

@@ -18,7 +18,7 @@ Add the npm-compatible registry and package to the Unity project's
     }
   ],
   "dependencies": {
-    "com.artromskiy.deltaecs.unity": "0.0.64"
+    "com.artromskiy.deltaecs.unity": "0.0.66"
   }
 }
 ```

package/Runtime/SceneAuthoring.cs

@@ -24,6 +24,8 @@ namespace Delta.ECS.Unity
         [NonSerialized] private Dictionary<string, GameObject> _viewsByStableId;
         [NonSerialized] private Dictionary<UnityEngine.EntityId, string> _stableIdsByView;
 
+        internal static event Action HierarchyChanged;
+
         internal SceneData SceneData => _sceneData ??= new SceneData();
 
         internal static SceneAuthoring FindForScene(Scene scene)
@@ -120,15 +122,36 @@ namespace Delta.ECS.Unity
 
             InvalidateBindingIndex();
             EnsureBindingIndex();
+            HierarchyChanged?.Invoke();
             return true;
         }
 
         internal bool RemoveView(string stableId) => SetView(stableId, null);
 
+        internal void CollectDestroyedViews(List<string> stableIds)
+        {
+            EnsureBindingIndex();
+            foreach (var pair in _viewsByStableId)
+            {
+                if (pair.Value == null)
+                {
+                    stableIds.Add(pair.Key);
+                }
+            }
+            foreach (string stableId in stableIds)
+            {
+                if (_viewsByStableId.Remove(stableId, out GameObject view) && view is not null)
+                {
+                    _stableIdsByView.Remove(view.GetEntityId());
+                }
+            }
+        }
+
         private void OnValidate()
         {
             SceneData.EnsureStableIds();
             InvalidateBindingIndex();
+            HierarchyChanged?.Invoke();
         }
 
         private void OnEnable()
@@ -136,6 +159,7 @@ namespace Delta.ECS.Unity
             SceneData.Changed -= OnSceneDataChanged;
             SceneData.Changed += OnSceneDataChanged;
             InvalidateBindingIndex();
+            HierarchyChanged?.Invoke();
         }
 
         private void OnDisable()
@@ -144,6 +168,7 @@ namespace Delta.ECS.Unity
             {
                 _sceneData.Changed -= OnSceneDataChanged;
             }
+            HierarchyChanged?.Invoke();
         }
 
         private void OnSceneDataChanged(SceneDataChange change)

package/Runtime/SceneWorld.cs

@@ -28,6 +28,9 @@ namespace Delta.ECS.Unity
         private readonly SceneAuthoring _authoring;
         private readonly bool _ownsWorld;
         private readonly ComponentId _hiddenEntityHierarchyComponentId;
+        private readonly List<Entity> _destroyedViews = new();
+        private readonly List<string> _destroyedAuthoredViews = new();
+        private RuntimeEntityChangeHandler _hierarchyEntitiesChanged;
         private bool _disposed;
 
         public World World => _world;
@@ -41,6 +44,26 @@ namespace Delta.ECS.Unity
                 return entities;
             }
         }
+        internal static event Action LiveWorldsChanged;
+        internal event RuntimeEntityChangeHandler HierarchyEntitiesChanged
+        {
+            add
+            {
+                if (_hierarchyEntitiesChanged == null)
+                {
+                    _world.EntityMembershipChanged += OnEntityMembershipChanged;
+                }
+                _hierarchyEntitiesChanged += value;
+            }
+            remove
+            {
+                _hierarchyEntitiesChanged -= value;
+                if (_hierarchyEntitiesChanged == null)
+                {
+                    _world.EntityMembershipChanged -= OnEntityMembershipChanged;
+                }
+            }
+        }
         internal ComponentId HiddenEntityHierarchyComponentId => _hiddenEntityHierarchyComponentId;
         internal SceneData SceneData => _sceneData;
         internal Scene UnityScene => _authoring != null ? _authoring.gameObject.scene : default;
@@ -60,6 +83,7 @@ namespace Delta.ECS.Unity
             if (registerLiveWorld)
             {
                 LiveWorlds.Add(this);
+                LiveWorldsChanged?.Invoke();
             }
         }
 
@@ -91,24 +115,35 @@ namespace Delta.ECS.Unity
             UnityEngine.EntityId viewId = view.GetEntityId();
             if (_entitiesByView.TryGetValue(viewId, out Entity previousEntity))
             {
+                if (previousEntity == entity)
+                {
+                    return true;
+                }
                 _viewsByEntity.Remove(previousEntity);
+                NotifyHierarchyEntityChanged(previousEntity);
             }
 
-            if (_viewsByEntity.TryGetValue(entity, out GameObject previousView) && previousView != null)
+            if (_viewsByEntity.TryGetValue(entity, out GameObject previousView) && previousView is not null)
             {
                 _entitiesByView.Remove(previousView.GetEntityId());
             }
 
             _viewsByEntity[entity] = view;
             _entitiesByView[viewId] = entity;
+            NotifyHierarchyEntityChanged(entity);
             return true;
         }
 
         public void UnbindView(Entity entity)
         {
-            if (_viewsByEntity.Remove(entity, out GameObject view) && view != null)
+            if (_viewsByEntity.Remove(entity, out GameObject view))
             {
-                _entitiesByView.Remove(view.GetEntityId());
+                // The managed wrapper retains its ID even after Unity destroys the native object.
+                if (view is not null)
+                {
+                    _entitiesByView.Remove(view.GetEntityId());
+                }
+                NotifyHierarchyEntityChanged(entity);
             }
         }
 
@@ -143,7 +178,12 @@ namespace Delta.ECS.Unity
             }
 
             _disposed = true;
-            LiveWorlds.Remove(this);
+            _world.EntityMembershipChanged -= OnEntityMembershipChanged;
+            if (LiveWorlds.Remove(this))
+            {
+                LiveWorldsChanged?.Invoke();
+            }
+            _hierarchyEntitiesChanged = null;
             DestroyCurrentAuthoringEntities();
             _entitiesByStableId.Clear();
             _stableIdsByEntity.Clear();
@@ -159,14 +199,13 @@ namespace Delta.ECS.Unity
         /// <summary>Resolves the runtime view first, then the scene-authored stable-ID binding.</summary>
         public bool TryGetView(Entity entity, [NotNullWhen(true)] out GameObject view)
         {
-            if (_viewsByEntity.TryGetValue(entity, out view) && view != null)
+            if (_viewsByEntity.TryGetValue(entity, out view))
             {
-                return true;
-            }
-
-            if (_viewsByEntity.ContainsKey(entity))
-            {
-                _viewsByEntity.Remove(entity);
+                if (view != null)
+                {
+                    return true;
+                }
+                UnbindView(entity);
             }
 
             return _authoring != null
@@ -262,6 +301,36 @@ namespace Delta.ECS.Unity
             }
         }
 
+        internal bool HasRuntimeView(Entity entity) => _viewsByEntity.ContainsKey(entity);
+
+        internal void RefreshDestroyedViews()
+        {
+            foreach (var pair in _viewsByEntity)
+            {
+                if (pair.Value == null || !_world.IsAlive(pair.Key))
+                {
+                    _destroyedViews.Add(pair.Key);
+                }
+            }
+            foreach (Entity entity in _destroyedViews)
+            {
+                UnbindView(entity);
+            }
+            _destroyedViews.Clear();
+            if (_authoring != null)
+            {
+                _authoring.CollectDestroyedViews(_destroyedAuthoredViews);
+                foreach (string stableId in _destroyedAuthoredViews)
+                {
+                    if (_entitiesByStableId.TryGetValue(stableId, out Entity entity))
+                    {
+                        NotifyHierarchyEntityChanged(entity);
+                    }
+                }
+                _destroyedAuthoredViews.Clear();
+            }
+        }
+
         internal void RebuildAuthoringEntities()
         {
             ThrowIfDisposed();
@@ -521,6 +590,15 @@ namespace Delta.ECS.Unity
             return new World(layouts, initialEntityCapacity);
         }
 
+        private void OnEntityMembershipChanged(ReadOnlySpan<Entity> entities)
+            => _hierarchyEntitiesChanged?.Invoke(entities);
+
+        private void NotifyHierarchyEntityChanged(Entity entity)
+        {
+            ReadOnlySpan<Entity> entities = stackalloc Entity[] { entity };
+            _hierarchyEntitiesChanged?.Invoke(entities);
+        }
+
         private void DestroyCurrentAuthoringEntities()
         {
             foreach (Entity entity in _entitiesByStableId.Values)
@@ -544,6 +622,8 @@ namespace Delta.ECS.Unity
         }
     }
 
+    internal delegate void RuntimeEntityChangeHandler(ReadOnlySpan<Entity> entities);
+
     /// <summary>Owns runtime world creation and teardown for loaded Unity scenes.</summary>
     internal static class SceneWorldRuntime
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.artromskiy.deltaecs.unity",
-  "version": "0.0.64",
+  "version": "0.0.66",
   "displayName": "DeltaECS Unity",
   "description": "Unity scene authoring and editor integration for DeltaECS.",
   "unity": "6000.7",