com.wallstop-studios.dxmessaging 2.2.0 → 3.1.0

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,11 @@
-fileFormatVersion: 2
-guid: 83aab80bf265483fb08c5f884e4b24fc
-timeCreated: 1759525804
+fileFormatVersion: 2
+guid: 83aab80bf265483fb08c5f884e4b24fc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

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

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

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

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

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

@@ -8,6 +8,8 @@ namespace DxMessaging.Core.Attributes
     /// <remarks>
     /// The source generator will emit a constructor parameter with a default value for fields annotated
     /// with this attribute. This is helpful for messages with sensible defaults.
+    /// Overloads accepting explicit default values require compile-time constants and are validated by
+    /// the source generator against the field type.
     /// </remarks>
     /// <example>
     /// <code>
@@ -27,10 +29,6 @@ namespace DxMessaging.Core.Attributes
         /// </summary>
         public DxOptionalParameterAttribute() { }
 
-        /// <summary>
-        /// Optional default value overloads. Values must be compile-time constants and
-        /// will be validated by the source generator against the field type.
-        /// </summary>
         /// <summary>
         /// Initializes the attribute with the specified default boolean value.
         /// </summary>

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

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

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

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

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

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

package/Runtime/Core/Attributes/Il2CppSetOptionAttribute.cs

@@ -0,0 +1,56 @@
+// Vendored copy of Unity's Il2CppSetOption attribute. The IL2CPP code
+// generator (il2cpp.exe) matches this attribute by its FULL NAME
+// (Unity.IL2CPP.CompilerServices.Il2CppSetOptionAttribute), not by assembly,
+// so an internal per-assembly copy is the sanctioned way for a package to opt
+// hot methods out of generated null/bounds checks (the same pattern UniTask
+// and other performance-focused packages use). The shape below mirrors the
+// attribute source Unity publishes in the IL2CPP documentation; do not add
+// members or change the namespace. Under Mono (editor, Mono players) the
+// attribute is inert.
+namespace Unity.IL2CPP.CompilerServices
+{
+    using System;
+
+    /// <summary>
+    /// Runtime checks that il2cpp.exe can omit for an annotated scope.
+    /// </summary>
+    internal enum Option
+    {
+        /// <summary>Implicit null checks before member access.</summary>
+        NullChecks = 1,
+
+        /// <summary>Array bounds checks on element access.</summary>
+        ArrayBoundsChecks = 2,
+
+        /// <summary>Integer divide-by-zero checks.</summary>
+        DivideByZeroChecks = 3,
+    }
+
+    /// <summary>
+    /// Instructs the IL2CPP code generator to enable or disable a runtime
+    /// check for the annotated type, method, or property.
+    /// </summary>
+    /// <remarks>
+    /// Only apply with <c>false</c> to code whose safety invariants are
+    /// guaranteed by construction and covered by tests: with checks disabled,
+    /// a violated invariant is memory corruption instead of a managed
+    /// exception.
+    /// </remarks>
+    [AttributeUsage(
+        AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property,
+        Inherited = false,
+        AllowMultiple = true
+    )]
+    internal sealed class Il2CppSetOptionAttribute : Attribute
+    {
+        public Option Option { get; private set; }
+
+        public object Value { get; private set; }
+
+        public Il2CppSetOptionAttribute(Option option, object value)
+        {
+            Option = option;
+            Value = value;
+        }
+    }
+}

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

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

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: