fix(plugins): close LA5 host lifecycle review

src/AcDream.Core/Plugins/ScopedPluginHost.cs

@@ -0,0 +1,171 @@
+using AcDream.Plugin.Abstractions;
+
+namespace AcDream.Core.Plugins;
+
+/// <summary>
+/// Per-plugin host view that owns every registration made through the public
+/// event/UI surfaces. Disposal is the host's rollback boundary: it removes
+/// registrations even when plugin Initialize/Enable/Disable code throws.
+/// </summary>
+internal sealed class ScopedPluginHost : IPluginHost, IDisposable
+{
+    private readonly IPluginHost _inner;
+    private readonly ScopedEvents _events;
+    private readonly ScopedUiRegistry _ui;
+    private bool _disposed;
+
+    internal ScopedPluginHost(IPluginHost inner)
+    {
+        _inner = inner ?? throw new ArgumentNullException(nameof(inner));
+        _events = new ScopedEvents(inner.Events);
+        _ui = new ScopedUiRegistry(inner.Ui);
+    }
+
+    public bool HasUi => _inner.HasUi;
+    public IPluginLogger Log => _inner.Log;
+    public IGameState State => _inner.State;
+    public IEvents Events => _events;
+    public ISelectionService Selection => _inner.Selection;
+    public IUiRegistry Ui => _ui;
+
+    public void Dispose()
+    {
+        if (_disposed)
+            return;
+        _disposed = true;
+        _events.Dispose();
+        _ui.Dispose();
+    }
+
+    private sealed class ScopedEvents(IEvents inner) : IEvents, IDisposable
+    {
+        private readonly object _gate = new();
+        private readonly List<Action<WorldEntitySnapshot>> _registrations = [];
+        private bool _disposed;
+
+        public event Action<WorldEntitySnapshot> EntitySpawned
+        {
+            add
+            {
+                ArgumentNullException.ThrowIfNull(value);
+                try
+                {
+                    inner.EntitySpawned += value;
+                }
+                catch
+                {
+                    // A custom event source may mutate before its add accessor
+                    // faults. Best-effort removal keeps the scope transactional.
+                    try { inner.EntitySpawned -= value; }
+                    catch { }
+                    throw;
+                }
+                lock (_gate)
+                {
+                    if (!_disposed)
+                    {
+                        _registrations.Add(value);
+                        return;
+                    }
+                }
+
+                // Disposal may race the host subscription call. In that case
+                // the disposal snapshot could not see this registration, so
+                // the attaching thread must roll it back before returning.
+                try { inner.EntitySpawned -= value; }
+                catch { }
+                throw new ObjectDisposedException(nameof(ScopedEvents));
+            }
+            remove
+            {
+                if (value is null)
+                    return;
+                inner.EntitySpawned -= value;
+                lock (_gate)
+                    RemoveLast(value);
+            }
+        }
+
+        public void Dispose()
+        {
+            Action<WorldEntitySnapshot>[] registrations;
+            lock (_gate)
+            {
+                if (_disposed)
+                    return;
+                _disposed = true;
+                registrations = _registrations.ToArray();
+                _registrations.Clear();
+            }
+
+            for (int index = registrations.Length - 1; index >= 0; index--)
+            {
+                try { inner.EntitySpawned -= registrations[index]; }
+                catch { }
+            }
+        }
+
+        private void RemoveLast(Action<WorldEntitySnapshot> handler)
+        {
+            for (int index = _registrations.Count - 1; index >= 0; index--)
+            {
+                if (_registrations[index] != handler)
+                    continue;
+                _registrations.RemoveAt(index);
+                return;
+            }
+        }
+    }
+
+    private sealed class ScopedUiRegistry : IUiRegistry, IDisposable
+    {
+        private readonly IScopedUiRegistry _inner;
+        private readonly object _gate = new();
+        private readonly List<IDisposable> _registrations = [];
+        private bool _disposed;
+
+        internal ScopedUiRegistry(IUiRegistry inner)
+        {
+            _inner = inner as IScopedUiRegistry
+                ?? throw new InvalidOperationException(
+                    "Plugin hosts must expose an IScopedUiRegistry so UI registrations can be rolled back.");
+        }
+
+        public void AddMarkupPanel(string markupPath, object binding)
+        {
+            IDisposable registration = _inner.RegisterMarkupPanel(
+                markupPath,
+                binding);
+            lock (_gate)
+            {
+                if (!_disposed)
+                {
+                    _registrations.Add(registration);
+                    return;
+                }
+            }
+
+            registration.Dispose();
+            throw new ObjectDisposedException(nameof(ScopedUiRegistry));
+        }
+
+        public void Dispose()
+        {
+            IDisposable[] registrations;
+            lock (_gate)
+            {
+                if (_disposed)
+                    return;
+                _disposed = true;
+                registrations = _registrations.ToArray();
+                _registrations.Clear();
+            }
+
+            for (int index = registrations.Length - 1; index >= 0; index--)
+            {
+                try { registrations[index].Dispose(); }
+                catch { }
+            }
+        }
+    }
+}