com.wallstop-studios.dxmessaging 2.2.0 → 3.0.1

package/README.md.meta

@@ -1,7 +1,7 @@
-fileFormatVersion: 2
-guid: 4c1ffc4b35b01f34f81f0399aa77b4d0
-TextScriptImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 4c1ffc4b35b01f34f81f0399aa77b4d0
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/AssemblyInfo.cs

@@ -5,8 +5,12 @@ using System.Runtime.CompilerServices;
     AllInternalsVisible = true
 )]
 [assembly: InternalsVisibleTo("WallstopStudios.DxMessaging.Editor")]
+[assembly: InternalsVisibleTo("WallstopStudios.DxMessaging.Reflex")]
+[assembly: InternalsVisibleTo("WallstopStudios.DxMessaging.VContainer")]
+[assembly: InternalsVisibleTo("WallstopStudios.DxMessaging.Zenject")]
 [assembly: InternalsVisibleTo("WallstopStudios.DxMessaging.Tests.Runtime")]
 [assembly: InternalsVisibleTo("WallstopStudios.DxMessaging.Tests.Runtime.Reflex")]
 [assembly: InternalsVisibleTo("WallstopStudios.DxMessaging.Tests.Runtime.VContainer")]
 [assembly: InternalsVisibleTo("WallstopStudios.DxMessaging.Tests.Runtime.Zenject")]
 [assembly: InternalsVisibleTo("WallstopStudios.DxMessaging.Tests.Editor")]
+[assembly: InternalsVisibleTo("WallstopStudios.DxMessaging.Tests.Editor.Allocations")]

package/Runtime/AssemblyInfo.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 83aab80bf265483fb08c5f884e4b24fc
+fileFormatVersion: 2
+guid: 83aab80bf265483fb08c5f884e4b24fc
 timeCreated: 1759525804

package/Runtime/Core/Attributes/DxAutoConstructorAttribute.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: bef6adb9baf545129cb9a841b13da451
+fileFormatVersion: 2
+guid: bef6adb9baf545129cb9a841b13da451
 timeCreated: 1749776355

package/Runtime/Core/Attributes/DxBroadcastMessageAttribute.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 73fd653a34be4f36b5773dce342ae9fa
+fileFormatVersion: 2
+guid: 73fd653a34be4f36b5773dce342ae9fa
 timeCreated: 1730779174

package/Runtime/Core/Attributes/DxIgnoreMissingBaseCallAttribute.cs

@@ -0,0 +1,26 @@
+namespace DxMessaging.Core.Attributes
+{
+    using System;
+
+    /// <summary>
+    /// Suppresses the <c>MessageAwareComponentBaseCallAnalyzer</c> (DXMSG006/DXMSG007/DXMSG009/DXMSG010)
+    /// for the annotated class or method.
+    /// </summary>
+    /// <remarks>
+    /// Applying this attribute is the source-level opt-out for the base-call analyzer. When applied to
+    /// a class, every guarded lifecycle method on that class (<c>Awake</c>, <c>OnEnable</c>,
+    /// <c>OnDisable</c>, <c>OnDestroy</c>, <c>RegisterMessageHandlers</c>) is exempt. When applied to a
+    /// single method, only that method is exempt. The analyzer still emits an Info-level
+    /// <c>DXMSG008</c> at the suppression site so the opt-out is auditable.
+    /// <para>
+    /// <c>Inherited = false</c>: a base class's <c>[DxIgnoreMissingBaseCall]</c> does NOT silently
+    /// suppress derived classes. Each subclass must opt out explicitly.
+    /// </para>
+    /// </remarks>
+    [AttributeUsage(
+        AttributeTargets.Class | AttributeTargets.Method,
+        Inherited = false,
+        AllowMultiple = false
+    )]
+    public sealed class DxIgnoreMissingBaseCallAttribute : Attribute { }
+}

package/Runtime/Core/Attributes/DxIgnoreMissingBaseCallAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5c8950d6fd6b4d409d59ff68e1eba46f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Attributes/DxOptionalParameterAttribute.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 87d96cdf2fc74f40ba77ae0d157be964
+fileFormatVersion: 2
+guid: 87d96cdf2fc74f40ba77ae0d157be964
 timeCreated: 1749850608

package/Runtime/Core/Attributes/DxTargetedMessageAttribute.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: ab2509dd51f5467d95b4fca1cb794b29
+fileFormatVersion: 2
+guid: ab2509dd51f5467d95b4fca1cb794b29
 timeCreated: 1730779159

package/Runtime/Core/Attributes/DxUntargetedMessageAttribute.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 418b461df3764ef6896dc86524a00132
+fileFormatVersion: 2
+guid: 418b461df3764ef6896dc86524a00132
 timeCreated: 1730779131

package/Runtime/Core/Attributes.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: e2cb23a56cf1416ba06dccca58c8297f
+fileFormatVersion: 2
+guid: e2cb23a56cf1416ba06dccca58c8297f
 timeCreated: 1730779055

package/Runtime/Core/Configuration/DxMessagingRuntimeSettings.cs

@@ -0,0 +1,195 @@
+namespace DxMessaging.Core.Configuration
+{
+    using System;
+    using MessageBus;
+#if UNITY_2021_3_OR_NEWER
+    using UnityEngine;
+
+    /// <summary>
+    /// Runtime-loaded settings asset that controls memory-reclamation policy and
+    /// pool sizing for DxMessaging. Loaded at first bus construction via
+    /// <c>Resources.Load&lt;DxMessagingRuntimeSettings&gt;("DxMessagingRuntimeSettings")</c>;
+    /// when the asset is absent a defaulted instance is used so the package works
+    /// out-of-the-box.
+    /// </summary>
+    /// <remarks>
+    /// To customize, create the asset via <c>Assets &gt; Create &gt; Wallstop Studios &gt;
+    /// DxMessaging &gt; Runtime Settings</c> and place it under any
+    /// <c>Resources/</c> folder named <c>DxMessagingRuntimeSettings.asset</c>.
+    /// Field changes raise <see cref="SettingsChanged"/>; consumers should
+    /// re-read derived state on the event.
+    /// </remarks>
+    [CreateAssetMenu(
+        fileName = ResourceName,
+        menuName = "Wallstop Studios/DxMessaging/Runtime Settings"
+    )]
+    public sealed class DxMessagingRuntimeSettings : ScriptableObject
+    {
+        /// <summary>Resource name (no extension) used by <c>Resources.Load</c>.</summary>
+        public const string ResourceName = "DxMessagingRuntimeSettings";
+
+        /// <summary>Default soft cap on per-pool retained entries.</summary>
+        public const int DefaultBufferMaxDistinctEntries = 512;
+
+        /// <summary>Default idle threshold in seconds before an empty slot is eligible for eviction.</summary>
+        public const float DefaultIdleEvictionSeconds = 30f;
+
+        /// <summary>Default minimum interval between idle sweeps, in seconds.</summary>
+        public const float DefaultEvictionTickIntervalSeconds = 5f;
+
+        [SerializeField]
+        [Tooltip(
+            "Idle threshold in seconds. Empty per-message-type slots are evicted only after going at least this long without a register/deregister/dispatch touch. See IdleEvictionSeconds."
+        )]
+        [Min(0f)]
+        internal float _idleEvictionSeconds = DefaultIdleEvictionSeconds;
+
+        [SerializeField]
+        [Tooltip(
+            "Soft cap on the number of distinct entries each shared collection pool will retain. Excess entries are evicted (LRU or LIFO depending on BufferUseLruEviction)."
+        )]
+        [Min(0)]
+        internal int _bufferMaxDistinctEntries = DefaultBufferMaxDistinctEntries;
+
+        [SerializeField]
+        [Tooltip(
+            "When true, shared collection pools use LRU eviction; otherwise pools behave as a bounded LIFO stack. See BufferUseLruEviction."
+        )]
+        internal bool _bufferUseLruEviction = true;
+
+        [SerializeField]
+        [Tooltip(
+            "When true, IMessageBus.Trim performs its work; when false it is a no-op returning default. Lets shipped titles disable on-demand reclamation. See EnableTrimApi."
+        )]
+        internal bool _enableTrimApi = true;
+
+        [SerializeField]
+        [Tooltip(
+            "Minimum interval in seconds between idle sweeps. Emit-time idle eviction samples the clock periodically instead of at the top of every Emit, and sweeps only when this much wall time has elapsed since the last sweep. See EvictionTickIntervalSeconds."
+        )]
+        [Min(0f)]
+        internal float _evictionTickIntervalSeconds = DefaultEvictionTickIntervalSeconds;
+
+        [SerializeField]
+        [Tooltip(
+            "Master switch for idle-time eviction. When false neither inline emit-time sweeps nor PlayerLoop sweeps run; explicit Trim still works (gated by EnableTrimApi). See EvictionEnabled."
+        )]
+        internal bool _evictionEnabled = true;
+
+        [SerializeField]
+        [Tooltip(
+            "Diagnostic message buffer size used when the bus is constructed. Mirrors IMessageBus.DefaultMessageBufferSize so the runtime asset can override the global default without touching code. See MessageBufferSize."
+        )]
+        [Min(0)]
+        internal int _messageBufferSize = IMessageBus.DefaultMessageBufferSize;
+
+        private bool _isFallbackInstance;
+
+        /// <summary>Idle threshold in seconds. See <c>_idleEvictionSeconds</c>.</summary>
+        public float IdleEvictionSeconds => _idleEvictionSeconds;
+
+        /// <summary>Per-pool retained-entry cap. See <c>_bufferMaxDistinctEntries</c>.</summary>
+        public int BufferMaxDistinctEntries => _bufferMaxDistinctEntries;
+
+        /// <summary>True when shared pools use LRU eviction.</summary>
+        public bool BufferUseLruEviction => _bufferUseLruEviction;
+
+        /// <summary>True when explicit Trim APIs perform work.</summary>
+        public bool EnableTrimApi => _enableTrimApi;
+
+        /// <summary>Minimum interval between idle sweeps, in seconds.</summary>
+        public float EvictionTickIntervalSeconds => _evictionTickIntervalSeconds;
+
+        /// <summary>Master switch for idle-time eviction.</summary>
+        public bool EvictionEnabled => _evictionEnabled;
+
+        /// <summary>Diagnostic message buffer size.</summary>
+        public int MessageBufferSize => _messageBufferSize;
+
+        internal bool IsFallbackInstance => _isFallbackInstance;
+
+        /// <summary>
+        /// Raised when this asset is mutated in the editor or via test-only override.
+        /// Subscribers should be small and re-entrancy-safe; the event is invoked
+        /// synchronously from <c>OnValidate</c>.
+        /// </summary>
+        public static event Action<DxMessagingRuntimeSettings> SettingsChanged;
+
+        /// <summary>
+        /// Used by <see cref="DxMessagingRuntimeSettingsProvider.Override"/> to push
+        /// a test-supplied override and notify subscribers.
+        /// </summary>
+        internal static void RaiseSettingsChanged(DxMessagingRuntimeSettings settings)
+        {
+            SettingsChanged?.Invoke(settings);
+        }
+
+        internal void MarkAsFallbackInstance()
+        {
+            _isFallbackInstance = true;
+        }
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+        private static void ClearSubscribersOnLoad()
+        {
+            SettingsChanged = null;
+        }
+
+#if UNITY_EDITOR
+        private const string ResourceFolder = "Assets/Resources";
+        private const string ResourceAssetPath = ResourceFolder + "/" + ResourceName + ".asset";
+
+        [UnityEditor.MenuItem(
+            "Assets/Create/Wallstop Studios/DxMessaging/Runtime Settings (in Resources)"
+        )]
+        private static void CreateAssetInResources()
+        {
+            if (!UnityEditor.AssetDatabase.IsValidFolder(ResourceFolder))
+            {
+                UnityEditor.AssetDatabase.CreateFolder("Assets", "Resources");
+            }
+            string targetPath = UnityEditor.AssetDatabase.GenerateUniqueAssetPath(
+                ResourceAssetPath
+            );
+            DxMessagingRuntimeSettings asset =
+                ScriptableObject.CreateInstance<DxMessagingRuntimeSettings>();
+            UnityEditor.AssetDatabase.CreateAsset(asset, targetPath);
+            UnityEditor.AssetDatabase.SaveAssets();
+            UnityEditor.EditorGUIUtility.PingObject(asset);
+        }
+
+        private void OnValidate()
+        {
+            if (_idleEvictionSeconds < 0f)
+            {
+                _idleEvictionSeconds = 0f;
+            }
+            if (_bufferMaxDistinctEntries < 0)
+            {
+                _bufferMaxDistinctEntries = 0;
+            }
+            if (_evictionTickIntervalSeconds < 0f)
+            {
+                _evictionTickIntervalSeconds = 0f;
+            }
+            if (_messageBufferSize < 0)
+            {
+                _messageBufferSize = 0;
+            }
+            string assetPath = UnityEditor.AssetDatabase.GetAssetPath(this);
+            if (
+                !string.IsNullOrEmpty(assetPath)
+                && assetPath.IndexOf("/Resources/", StringComparison.OrdinalIgnoreCase) < 0
+            )
+            {
+                Debug.LogWarning(
+                    "[DxMessaging] Runtime settings asset is not under a Resources/ folder; Resources.Load will not find it. Move it under Assets/Resources/ or use the 'Assets/Create/Wallstop Studios/DxMessaging/Runtime Settings (in Resources)' menu.",
+                    this
+                );
+            }
+            RaiseSettingsChanged(this);
+        }
+#endif
+    }
+#endif
+}

package/Runtime/Core/Configuration/DxMessagingRuntimeSettings.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2f98fd11ff90d4d813cabc6bc2a77a72
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/Configuration/DxMessagingRuntimeSettingsProvider.cs

@@ -0,0 +1,179 @@
+namespace DxMessaging.Core.Configuration
+{
+    using System;
+    using System.Threading;
+    using MessageBus;
+#if UNITY_2021_3_OR_NEWER
+    using UnityEngine;
+#endif
+
+#if UNITY_2021_3_OR_NEWER
+    /// <summary>
+    /// Lazy provider that hands out the active <see cref="DxMessagingRuntimeSettings"/>
+    /// instance. Tries <c>Resources.Load&lt;DxMessagingRuntimeSettings&gt;("DxMessagingRuntimeSettings")</c>
+    /// once per AppDomain; on miss, returns a defaulted in-memory instance so the
+    /// runtime always has a usable settings object.
+    /// </summary>
+    /// <remarks>
+    /// Tests inject a fake via <see cref="Override"/>, which returns an
+    /// <see cref="IDisposable"/> that restores the prior current settings. Override
+    /// raises <see cref="DxMessagingRuntimeSettings.SettingsChanged"/> on push and
+    /// pop so subscribed buses re-apply caps.
+    /// </remarks>
+    public static class DxMessagingRuntimeSettingsProvider
+    {
+        private static DxMessagingRuntimeSettings _cached;
+        private static readonly object _gate = new();
+
+        /// <summary>
+        /// Returns the active settings instance. Loads the asset on first call;
+        /// subsequent calls return the cached reference (or a test override if
+        /// <see cref="Override"/> is active).
+        /// </summary>
+        /// <remarks>
+        /// In non-Unity builds (where <c>UNITY_2021_3_OR_NEWER</c> is not defined)
+        /// this property returns <c>null</c> because <c>ScriptableObject</c> is
+        /// unavailable. Callers must tolerate a <c>null</c> result outside Unity.
+        /// </remarks>
+        public static DxMessagingRuntimeSettings Current
+        {
+            get
+            {
+                DxMessagingRuntimeSettings local = Volatile.Read(ref _cached);
+                if (local != null)
+                {
+                    return local;
+                }
+                lock (_gate)
+                {
+                    local = _cached;
+                    if (local != null)
+                    {
+                        return local;
+                    }
+                    local = LoadOrCreate();
+                    Volatile.Write(ref _cached, local);
+                    return local;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Pushes a test-supplied settings instance as the active <see cref="Current"/>
+        /// value and raises <see cref="DxMessagingRuntimeSettings.SettingsChanged"/>.
+        /// Disposing the returned token restores the previous instance and raises
+        /// the event again so subscribers re-apply the original caps.
+        /// </summary>
+        public static IDisposable Override(DxMessagingRuntimeSettings settings)
+        {
+            if (settings == null)
+            {
+                throw new ArgumentNullException(nameof(settings));
+            }
+            DxMessagingRuntimeSettings previous;
+            int previousGlobalMessageBufferSize = IMessageBus.GlobalMessageBufferSize;
+            lock (_gate)
+            {
+                previous = _cached;
+                _cached = settings;
+            }
+            DxMessagingRuntimeSettings.RaiseSettingsChanged(settings);
+            return new OverrideToken(settings, previous, previousGlobalMessageBufferSize);
+        }
+
+        /// <summary>
+        /// Clears the cached reference, forcing the next <see cref="Current"/>
+        /// access to reload from <c>Resources</c>. Test-only.
+        /// </summary>
+        internal static void ResetForTests()
+        {
+            lock (_gate)
+            {
+                _cached = null;
+            }
+        }
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+        private static void OnSubsystemRegistration()
+        {
+            ResetForTests();
+        }
+
+        private static DxMessagingRuntimeSettings LoadOrCreate()
+        {
+            DxMessagingRuntimeSettings asset = null;
+            try
+            {
+                asset = Resources.Load<DxMessagingRuntimeSettings>(
+                    DxMessagingRuntimeSettings.ResourceName
+                );
+            }
+            catch
+            {
+                asset = null;
+            }
+            if (asset != null)
+            {
+                return asset;
+            }
+            DxMessagingRuntimeSettings fallback =
+                ScriptableObject.CreateInstance<DxMessagingRuntimeSettings>();
+            fallback.MarkAsFallbackInstance();
+            fallback.hideFlags = HideFlags.HideAndDontSave;
+            fallback.name = DxMessagingRuntimeSettings.ResourceName + " (Default)";
+            return fallback;
+        }
+
+        private sealed class OverrideToken : IDisposable
+        {
+            private readonly DxMessagingRuntimeSettings _installed;
+            private readonly int _previousGlobalMessageBufferSize;
+            private DxMessagingRuntimeSettings _previous;
+            private bool _disposed;
+
+            public OverrideToken(
+                DxMessagingRuntimeSettings installed,
+                DxMessagingRuntimeSettings previous,
+                int previousGlobalMessageBufferSize
+            )
+            {
+                _installed = installed;
+                _previous = previous;
+                _previousGlobalMessageBufferSize = previousGlobalMessageBufferSize;
+            }
+
+            public void Dispose()
+            {
+                if (_disposed)
+                {
+                    return;
+                }
+                _disposed = true;
+                DxMessagingRuntimeSettings restored = null;
+                bool didRestore = false;
+                lock (_gate)
+                {
+                    // Only restore if our install is still the active one.
+                    // If a deeper Override was pushed on top, this Dispose is a no-op
+                    // so the LIFO stack is honored.
+                    if (ReferenceEquals(_cached, _installed))
+                    {
+                        _cached = _previous;
+                        restored = _previous;
+                        didRestore = true;
+                    }
+                    _previous = null;
+                }
+                if (didRestore)
+                {
+                    if (restored == null || restored.IsFallbackInstance)
+                    {
+                        IMessageBus.GlobalMessageBufferSize = _previousGlobalMessageBufferSize;
+                    }
+                    DxMessagingRuntimeSettings.RaiseSettingsChanged(restored);
+                }
+            }
+        }
+    }
+#endif
+}

package/Runtime/Core/Configuration/DxMessagingRuntimeSettingsProvider.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b242396a6d286a776885179f9908a593
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/Configuration.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 0c5cb60b0129e6df3a4455a62ec7ffb9
+timeCreated: 1777840186
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -15,7 +15,7 @@ namespace DxMessaging.Core.DataStructure
     [Serializable]
     internal sealed class CyclicBuffer<T> : IReadOnlyList<T>
     {
-        public struct CyclicBufferEnumerator : IEnumerator<T>
+        internal struct CyclicBufferEnumerator : IEnumerator<T>
         {
             private readonly CyclicBuffer<T> _buffer;
 
@@ -70,7 +70,7 @@ namespace DxMessaging.Core.DataStructure
         /// <summary>Maximum number of elements retained in the buffer.</summary>
         public int Capacity { get; private set; }
 
-        /// <summary>Current number of elements stored (≤ <see cref="Capacity"/>).</summary>
+        /// <summary>Current number of elements stored (<= <see cref="Capacity"/>).</summary>
         public int Count { get; private set; }
 
         private readonly List<T> _buffer;

package/Runtime/Core/DataStructure/CyclicBuffer.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 7d8dbf8640e24846bf35fb18a1b7c504
+fileFormatVersion: 2
+guid: 7d8dbf8640e24846bf35fb18a1b7c504
 timeCreated: 1749671893

package/Runtime/Core/DataStructure.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 9862044472704c86ade5612ddcdfd5b5
+fileFormatVersion: 2
+guid: 9862044472704c86ade5612ddcdfd5b5
 timeCreated: 1749671887

package/Runtime/Core/Diagnostics/MessageEmissionData.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 8eafaabae0f549ec82f67ea18be788e1
+fileFormatVersion: 2
+guid: 8eafaabae0f549ec82f67ea18be788e1
 timeCreated: 1749672335

package/Runtime/Core/Diagnostics/MessageRegistrationData.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 01598791b01241caabfecea4c1f5880d
+fileFormatVersion: 2
+guid: 01598791b01241caabfecea4c1f5880d
 timeCreated: 1749672447

package/Runtime/Core/Diagnostics/MessageRegistrationType.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 7d393cfbb3c8429d83af17a737fdaf0e
+fileFormatVersion: 2
+guid: 7d393cfbb3c8429d83af17a737fdaf0e
 timeCreated: 1749672471

package/Runtime/Core/Diagnostics.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 9606a03ced274c3888a4d993309786a4
+fileFormatVersion: 2
+guid: 9606a03ced274c3888a4d993309786a4
 timeCreated: 1749672323

package/Runtime/Core/DxMessagingStaticState.cs

@@ -50,7 +50,26 @@ namespace DxMessaging.Core
                 MessageRegistrationHandle.SetIdSeed(Baseline.MessageRegistrationHandleSeed);
                 MessageRegistrationBuilder.SetSyntheticOwnerCounter(Baseline.SyntheticOwnerCounter);
 
+                // Capture the active global bus before ResetStatics swaps it back to the default
+                // instance. If a user installed a custom global bus via SetGlobalMessageBus, we
+                // also bump that bus's reset generation so deregister closures captured against
+                // it (e.g. a deferred Object.Destroy that lands after Reset) silently no-op
+                // instead of logging spurious over-deregistration errors. We deliberately do NOT
+                // call ResetState() on the custom bus -- that would clear its sinks, which the
+                // user may have intentionally preserved.
+                IMessageBus activeBus = MessageHandler.MessageBus;
+                IMessageBus defaultBus = MessageHandler.InitialGlobalMessageBus;
+
                 MessageHandler.ResetStatics();
+                MessageBus.MessageBus.ResetStaticPools();
+
+                if (
+                    !ReferenceEquals(activeBus, defaultBus)
+                    && activeBus is MessageBus.MessageBus customConcrete
+                )
+                {
+                    customConcrete.BumpResetGeneration();
+                }
             }
         }
 

package/Runtime/Core/DxMessagingStaticState.cs.meta

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: 2fbeee7b1ae4484f978aba9de68b3d1d
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 2fbeee7b1ae4484f978aba9de68b3d1d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Extensions/EnumExtensions.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: f01ee914d7634a69a85f86bb02f2f07e
+fileFormatVersion: 2
+guid: f01ee914d7634a69a85f86bb02f2f07e
 timeCreated: 1745162639

package/Runtime/Core/Extensions/IListExtensions.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: f6956caef19744a0b0d96215d4e5154a
+fileFormatVersion: 2
+guid: f6956caef19744a0b0d96215d4e5154a
 timeCreated: 1749671953