com.wallstop-studios.dxmessaging 2.1.2 → 2.1.4

package/Runtime/Core/Extensions/MessageBusExtensions.cs

@@ -13,6 +13,13 @@ namespace DxMessaging.Core.Extensions
     /// </summary>
     public static class MessageBusExtensions
     {
+        /// <summary>
+        /// Emits an untargeted message instance through the provided message bus.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="IUntargetedMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="message">Message instance to send.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitUntargeted<TMessage>(this IMessageBus messageBus, TMessage message)
             where TMessage : class, IUntargetedMessage
         {
@@ -24,6 +31,13 @@ namespace DxMessaging.Core.Extensions
             message.EmitUntargeted(messageBus);
         }
 
+        /// <summary>
+        /// Emits an untargeted struct message through the provided message bus without copying the payload.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="IUntargetedMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="message">Reference to the struct message to send.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitUntargeted<TMessage>(
             this IMessageBus messageBus,
             ref TMessage message
@@ -38,6 +52,21 @@ namespace DxMessaging.Core.Extensions
             message.EmitUntargeted(messageBus);
         }
 
+        /// <summary>
+        /// Emits a targeted message to the specified recipient.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="ITargetedMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="target">Recipient of the message.</param>
+        /// <param name="message">Message instance to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
+        /// <example>
+        /// <code>
+        /// InstanceId playerId = GetPlayerId();
+        /// var change = new HealthChanged(5);
+        /// bus.EmitTargeted(playerId, change);
+        /// </code>
+        /// </example>
         public static void EmitTargeted<TMessage>(
             this IMessageBus messageBus,
             InstanceId target,
@@ -53,6 +82,14 @@ namespace DxMessaging.Core.Extensions
             message.EmitTargeted(target, messageBus);
         }
 
+        /// <summary>
+        /// Emits a targeted struct message to the specified recipient without copying the payload.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="ITargetedMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="target">Recipient of the message.</param>
+        /// <param name="message">Reference to the struct message to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitTargeted<TMessage>(
             this IMessageBus messageBus,
             InstanceId target,
@@ -68,6 +105,14 @@ namespace DxMessaging.Core.Extensions
             message.EmitTargeted(target, messageBus);
         }
 
+        /// <summary>
+        /// Emits a broadcast message sourced from the specified instance.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="IBroadcastMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="source">Originating instance for the broadcast.</param>
+        /// <param name="message">Message instance to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitBroadcast<TMessage>(
             this IMessageBus messageBus,
             InstanceId source,
@@ -83,6 +128,14 @@ namespace DxMessaging.Core.Extensions
             message.EmitBroadcast(source, messageBus);
         }
 
+        /// <summary>
+        /// Emits a broadcast struct message sourced from the specified instance without copying the payload.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="IBroadcastMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="source">Originating instance for the broadcast.</param>
+        /// <param name="message">Reference to the struct message to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitBroadcast<TMessage>(
             this IMessageBus messageBus,
             InstanceId source,
@@ -99,6 +152,14 @@ namespace DxMessaging.Core.Extensions
         }
 
 #if UNITY_2021_3_OR_NEWER
+        /// <summary>
+        /// Emits a targeted message to the specified Unity <see cref="GameObject"/>.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="ITargetedMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="target">Unity object that will receive the message.</param>
+        /// <param name="message">Message instance to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitGameObjectTargeted<TMessage>(
             this IMessageBus messageBus,
             GameObject target,
@@ -114,6 +175,14 @@ namespace DxMessaging.Core.Extensions
             message.EmitGameObjectTargeted(target, messageBus);
         }
 
+        /// <summary>
+        /// Emits a targeted struct message to the specified Unity <see cref="GameObject"/> without copying the payload.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="ITargetedMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="target">Unity object that will receive the message.</param>
+        /// <param name="message">Reference to the struct message to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitGameObjectTargeted<TMessage>(
             this IMessageBus messageBus,
             GameObject target,
@@ -129,6 +198,14 @@ namespace DxMessaging.Core.Extensions
             message.EmitGameObjectTargeted(target, messageBus);
         }
 
+        /// <summary>
+        /// Emits a targeted message to the specified Unity <see cref="Component"/>.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="ITargetedMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="target">Unity component that will receive the message.</param>
+        /// <param name="message">Message instance to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitComponentTargeted<TMessage>(
             this IMessageBus messageBus,
             Component target,
@@ -144,6 +221,14 @@ namespace DxMessaging.Core.Extensions
             message.EmitComponentTargeted(target, messageBus);
         }
 
+        /// <summary>
+        /// Emits a targeted struct message to the specified Unity <see cref="Component"/> without copying the payload.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="ITargetedMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="target">Unity component that will receive the message.</param>
+        /// <param name="message">Reference to the struct message to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitComponentTargeted<TMessage>(
             this IMessageBus messageBus,
             Component target,
@@ -159,6 +244,14 @@ namespace DxMessaging.Core.Extensions
             message.EmitComponentTargeted(target, messageBus);
         }
 
+        /// <summary>
+        /// Emits a broadcast message from the specified Unity <see cref="GameObject"/>.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="IBroadcastMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="source">Unity object that is broadcasting the message.</param>
+        /// <param name="message">Message instance to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitGameObjectBroadcast<TMessage>(
             this IMessageBus messageBus,
             GameObject source,
@@ -174,6 +267,14 @@ namespace DxMessaging.Core.Extensions
             message.EmitGameObjectBroadcast(source, messageBus);
         }
 
+        /// <summary>
+        /// Emits a broadcast struct message from the specified Unity <see cref="GameObject"/> without copying the payload.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="IBroadcastMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="source">Unity object that is broadcasting the message.</param>
+        /// <param name="message">Reference to the struct message to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitGameObjectBroadcast<TMessage>(
             this IMessageBus messageBus,
             GameObject source,
@@ -189,6 +290,14 @@ namespace DxMessaging.Core.Extensions
             message.EmitGameObjectBroadcast(source, messageBus);
         }
 
+        /// <summary>
+        /// Emits a broadcast message from the specified Unity <see cref="Component"/>.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="IBroadcastMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="source">Unity component that is broadcasting the message.</param>
+        /// <param name="message">Message instance to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitComponentBroadcast<TMessage>(
             this IMessageBus messageBus,
             Component source,
@@ -204,6 +313,14 @@ namespace DxMessaging.Core.Extensions
             message.EmitComponentBroadcast(source, messageBus);
         }
 
+        /// <summary>
+        /// Emits a broadcast struct message from the specified Unity <see cref="Component"/> without copying the payload.
+        /// </summary>
+        /// <typeparam name="TMessage">Concrete message type implementing <see cref="IBroadcastMessage"/>.</typeparam>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="source">Unity component that is broadcasting the message.</param>
+        /// <param name="message">Reference to the struct message to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitComponentBroadcast<TMessage>(
             this IMessageBus messageBus,
             Component source,
@@ -220,6 +337,17 @@ namespace DxMessaging.Core.Extensions
         }
 #endif
 
+        /// <summary>
+        /// Emits a string payload using the string-message utility channel.
+        /// </summary>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="payload">Message text to broadcast globally.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
+        /// <example>
+        /// <code>
+        /// bus.Emit("PlayerJoined");
+        /// </code>
+        /// </example>
         public static void Emit(this IMessageBus messageBus, string payload)
         {
             if (messageBus == null)
@@ -230,6 +358,13 @@ namespace DxMessaging.Core.Extensions
             payload.Emit(messageBus);
         }
 
+        /// <summary>
+        /// Emits a string payload targeted at the specified instance.
+        /// </summary>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="target">Intended recipient of the payload.</param>
+        /// <param name="payload">Message text to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitAt(this IMessageBus messageBus, InstanceId target, string payload)
         {
             if (messageBus == null)
@@ -240,6 +375,13 @@ namespace DxMessaging.Core.Extensions
             payload.Emit(target, messageBus);
         }
 
+        /// <summary>
+        /// Emits a string payload broadcast from the specified instance.
+        /// </summary>
+        /// <param name="messageBus">Bus that should dispatch the message.</param>
+        /// <param name="source">Origin of the payload.</param>
+        /// <param name="payload">Message text to deliver.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="messageBus"/> is null.</exception>
         public static void EmitFrom(this IMessageBus messageBus, InstanceId source, string payload)
         {
             if (messageBus == null)

package/Runtime/Core/Helper/MessageCache.cs

@@ -33,6 +33,10 @@ namespace DxMessaging.Core.Helper
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            /// <summary>
+            /// Advances the enumerator to the next cached value.
+            /// </summary>
+            /// <returns><c>true</c> if another non-null value exists; otherwise <c>false</c>.</returns>
             public bool MoveNext()
             {
                 List<TValue> values = _cache._values;
@@ -55,12 +59,18 @@ namespace DxMessaging.Core.Helper
             object IEnumerator.Current => Current;
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            /// <summary>
+            /// Resets the enumerator to the position before the first element.
+            /// </summary>
             public void Reset()
             {
                 _index = -1;
                 _current = default;
             }
 
+            /// <summary>
+            /// Releases resources held by the enumerator.
+            /// </summary>
             public void Dispose() { }
         }
 
@@ -179,6 +189,12 @@ namespace DxMessaging.Core.Helper
             return GetEnumerator();
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void Clear()
+        {
+            _values.Clear();
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void FillToIndex(int index)
         {

package/Runtime/Core/Helper/MessageHelperIndexer.cs

@@ -1,8 +1,80 @@
 namespace DxMessaging.Core.Helper
 {
+    using System;
+    using System.Collections.Generic;
+
     public static class MessageHelperIndexer
     {
+        internal readonly struct MessageHelperIndexerState
+        {
+            internal readonly int _totalMessages;
+
+            internal readonly Dictionary<Type, int> _sequentialIds;
+
+            internal MessageHelperIndexerState(
+                int totalMessages,
+                Dictionary<Type, int> sequentialIds
+            )
+            {
+                _totalMessages = totalMessages;
+                _sequentialIds = sequentialIds;
+            }
+        }
+
+        private static readonly object ResetLock = new();
+        private static readonly HashSet<Type> RegisteredTypes = new();
+        private static readonly Dictionary<Type, Func<int, int>> StateManipulationByType = new();
+
         internal static int TotalMessages = 0;
+
+        internal static void RegisterType(Type messageType, Func<int, int> idProducer)
+        {
+            if (messageType == null)
+            {
+                return;
+            }
+
+            lock (ResetLock)
+            {
+                if (!RegisteredTypes.Add(messageType))
+                {
+                    return;
+                }
+
+                StateManipulationByType[messageType] = idProducer;
+            }
+        }
+
+        internal static MessageHelperIndexerState CaptureState()
+        {
+            lock (ResetLock)
+            {
+                Dictionary<Type, int> snapshot = new(RegisteredTypes.Count);
+                return new MessageHelperIndexerState(TotalMessages, snapshot);
+            }
+        }
+
+        internal static void RestoreState(MessageHelperIndexerState state)
+        {
+            lock (ResetLock)
+            {
+                TotalMessages = state._totalMessages;
+                foreach (KeyValuePair<Type, Func<int, int>> entry in StateManipulationByType)
+                {
+                    Type type = entry.Key;
+                    Func<int, int> manipulationAction = entry.Value;
+                    if (
+                        state._sequentialIds == null
+                        || !state._sequentialIds.TryGetValue(type, out int value)
+                    )
+                    {
+                        value = -1;
+                    }
+
+                    manipulationAction(value);
+                }
+            }
+        }
     }
 
     public static class MessageHelperIndexer<TMessage>
@@ -10,5 +82,10 @@ namespace DxMessaging.Core.Helper
     {
         // ReSharper disable once StaticMemberInGenericType
         internal static int SequentialId = -1;
+
+        static MessageHelperIndexer()
+        {
+            MessageHelperIndexer.RegisterType(typeof(TMessage), value => SequentialId = value);
+        }
     }
 }

package/Runtime/Core/InstanceId.cs

@@ -35,6 +35,10 @@ namespace DxMessaging.Core
         public readonly UnityEngine.Object Object;
 #endif
 
+        /// <summary>
+        /// Creates an identifier that wraps the provided Unity instance ID.
+        /// </summary>
+        /// <param name="id">Unity instance ID to wrap.</param>
         public InstanceId(int id)
         {
             _id = id;
@@ -51,12 +55,22 @@ namespace DxMessaging.Core
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        /// <summary>
+        /// Converts a <see cref="UnityEngine.GameObject"/> reference into an <see cref="InstanceId"/>.
+        /// </summary>
+        /// <param name="gameObject">GameObject to wrap.</param>
+        /// <returns>Instance identifier representing <paramref name="gameObject"/>.</returns>
         public static implicit operator InstanceId(UnityEngine.GameObject gameObject)
         {
             return new InstanceId(gameObject);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        /// <summary>
+        /// Converts a <see cref="UnityEngine.Component"/> reference into an <see cref="InstanceId"/>.
+        /// </summary>
+        /// <param name="component">Component to wrap.</param>
+        /// <returns>Instance identifier representing <paramref name="component"/>.</returns>
         public static implicit operator InstanceId(UnityEngine.Component component)
         {
             return new InstanceId(component);
@@ -64,23 +78,43 @@ namespace DxMessaging.Core
 #endif
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        /// <summary>
+        /// Checks for equality with another <see cref="InstanceId"/>.
+        /// </summary>
+        /// <param name="other">Other instance identifier.</param>
+        /// <returns><c>true</c> when both identifiers refer to the same Unity instance.</returns>
         public bool Equals(InstanceId other)
         {
             return _id == other._id;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        /// <summary>
+        /// Checks for equality with an arbitrary object.
+        /// </summary>
+        /// <param name="other">Object to compare.</param>
+        /// <returns>
+        /// <c>true</c> when <paramref name="other"/> is an <see cref="InstanceId"/> representing the same Unity instance.
+        /// </returns>
         public override bool Equals(object other)
         {
             return other is InstanceId id && Equals(id);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        /// <summary>
+        /// Gets a hash code suitable for dictionary or set lookups.
+        /// </summary>
+        /// <returns>Hash code derived from the underlying Unity instance ID.</returns>
         public override int GetHashCode()
         {
             return _id;
         }
 
+        /// <summary>
+        /// Returns a string representation that includes the Unity instance ID and, when available, the object name.
+        /// </summary>
+        /// <returns>Human-readable description of the identifier.</returns>
         public override string ToString()
         {
 #if UNITY_2021_3_OR_NEWER
@@ -93,48 +127,100 @@ namespace DxMessaging.Core
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        /// <summary>
+        /// Determines whether two identifiers refer to the same Unity instance.
+        /// </summary>
+        /// <param name="lhs">Left-hand identifier.</param>
+        /// <param name="rhs">Right-hand identifier.</param>
+        /// <returns><c>true</c> when both identifiers represent the same value.</returns>
         public static bool operator ==(InstanceId lhs, InstanceId rhs)
         {
             return lhs._id == rhs._id;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        /// <summary>
+        /// Determines whether two identifiers refer to different Unity instances.
+        /// </summary>
+        /// <param name="lhs">Left-hand identifier.</param>
+        /// <param name="rhs">Right-hand identifier.</param>
+        /// <returns><c>true</c> when the identifiers represent different values.</returns>
         public static bool operator !=(InstanceId lhs, InstanceId rhs)
         {
             return lhs._id != rhs._id;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        /// <summary>
+        /// Compares two identifiers for ascending ordering.
+        /// </summary>
+        /// <param name="lhs">Left-hand identifier.</param>
+        /// <param name="rhs">Right-hand identifier.</param>
+        /// <returns><c>true</c> when <paramref name="lhs"/> precedes <paramref name="rhs"/>.</returns>
         public static bool operator <(InstanceId lhs, InstanceId rhs)
         {
             return lhs._id.CompareTo(rhs._id) < 0;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        /// <summary>
+        /// Compares two identifiers for ascending ordering with equality.
+        /// </summary>
+        /// <param name="lhs">Left-hand identifier.</param>
+        /// <param name="rhs">Right-hand identifier.</param>
+        /// <returns>
+        /// <c>true</c> when <paramref name="lhs"/> precedes <paramref name="rhs"/> or both identifiers are equal.
+        /// </returns>
         public static bool operator <=(InstanceId lhs, InstanceId rhs)
         {
             return lhs._id.CompareTo(rhs._id) <= 0;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        /// <summary>
+        /// Compares two identifiers for descending ordering.
+        /// </summary>
+        /// <param name="lhs">Left-hand identifier.</param>
+        /// <param name="rhs">Right-hand identifier.</param>
+        /// <returns><c>true</c> when <paramref name="lhs"/> follows <paramref name="rhs"/>.</returns>
         public static bool operator >(InstanceId lhs, InstanceId rhs)
         {
             return lhs._id.CompareTo(rhs._id) > 0;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        /// <summary>
+        /// Compares two identifiers for descending ordering with equality.
+        /// </summary>
+        /// <param name="lhs">Left-hand identifier.</param>
+        /// <param name="rhs">Right-hand identifier.</param>
+        /// <returns>
+        /// <c>true</c> when <paramref name="lhs"/> follows <paramref name="rhs"/> or both identifiers are equal.
+        /// </returns>
         public static bool operator >=(InstanceId lhs, InstanceId rhs)
         {
             return lhs._id.CompareTo(rhs._id) >= 0;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        /// <summary>
+        /// Compares this identifier with another identifier for ordering.
+        /// </summary>
+        /// <param name="other">Identifier to compare with.</param>
+        /// <returns>Relative ordering as defined by <see cref="IComparable{T}.CompareTo(T)"/>.</returns>
         public int CompareTo(InstanceId other)
         {
             return _id.CompareTo(other._id);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        /// <summary>
+        /// Compares this identifier with an arbitrary object for ordering.
+        /// </summary>
+        /// <param name="rhs">Object to compare with.</param>
+        /// <returns>
+        /// Relative ordering when <paramref name="rhs"/> is an <see cref="InstanceId"/>; otherwise <c>-1</c>.
+        /// </returns>
         public int CompareTo(object rhs)
         {
             if (rhs is InstanceId other)

package/Runtime/Core/MessageBus/DiagnosticsTarget.cs

@@ -0,0 +1,31 @@
+namespace DxMessaging.Core.MessageBus
+{
+    using System;
+
+    /// <summary>
+    /// Flags describing which execution targets should enable diagnostics by default.
+    /// </summary>
+    [Flags]
+    public enum DiagnosticsTarget
+    {
+        /// <summary>
+        /// Diagnostics are disabled.
+        /// </summary>
+        Off = 0,
+
+        /// <summary>
+        /// Diagnostics should run while in the Unity editor.
+        /// </summary>
+        Editor = 1,
+
+        /// <summary>
+        /// Diagnostics should run while in player/runtime builds.
+        /// </summary>
+        Runtime = 2,
+
+        /// <summary>
+        /// Diagnostics should run in both editor and runtime environments.
+        /// </summary>
+        All = Editor | Runtime,
+    }
+}

package/Runtime/Core/MessageBus/DiagnosticsTarget.cs.meta

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