com.wallstop-studios.dxmessaging 2.1.1 → 2.1.3

package/Editor/Testing/MessagingComponentEditorHarness.cs

@@ -0,0 +1,218 @@
+#if UNITY_EDITOR
+namespace DxMessaging.Editor.Testing
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Core;
+    using Core.Diagnostics;
+    using Core.MessageBus;
+    using Unity;
+    using UnityEngine;
+
+    /// <summary>
+    /// Captures inspector-oriented diagnostics for <see cref="MessagingComponent"/> instances without relying on GUI APIs.
+    /// Intended for automated editor tests that need to validate inspector state transitions.
+    /// </summary>
+    internal static class MessagingComponentEditorHarness
+    {
+        private static readonly MessageEmissionData[] EmptyEmissions =
+            Array.Empty<MessageEmissionData>();
+
+        internal static MessagingComponentInspectorState Capture(MessagingComponent component)
+        {
+            if (component == null)
+            {
+                throw new ArgumentNullException(nameof(component));
+            }
+
+            bool globalDiagnosticsEnabled = false;
+            IReadOnlyList<MessageEmissionData> globalHistory = EmptyEmissions;
+
+            if (MessageHandler.MessageBus is MessageBus concreteBus)
+            {
+                globalDiagnosticsEnabled = concreteBus.DiagnosticsMode;
+                if (globalDiagnosticsEnabled && concreteBus._emissionBuffer.Count > 0)
+                {
+                    globalHistory = concreteBus._emissionBuffer.ToArray();
+                }
+            }
+
+            List<ListenerDiagnosticsView> listenerViews = component
+                ._registeredListeners.OrderBy(pair => pair.Key.GetInstanceID())
+                .Select(pair => CreateListenerView(pair.Key, pair.Value))
+                .ToList();
+
+            ProviderDiagnosticsView providerDiagnostics = CreateProviderDiagnostics(component);
+
+            return new MessagingComponentInspectorState(
+                globalDiagnosticsEnabled,
+                globalHistory,
+                listenerViews,
+                providerDiagnostics
+            );
+        }
+
+        private static ListenerDiagnosticsView CreateListenerView(
+            MonoBehaviour listener,
+            MessageRegistrationToken token
+        )
+        {
+            MessageRegistrationView[] registrations = token
+                ._metadata.OrderBy(pair => pair.Key)
+                .Select(pair => new MessageRegistrationView(
+                    pair.Key,
+                    pair.Value,
+                    token._callCounts.TryGetValue(pair.Key, out int callCount) ? callCount : 0
+                ))
+                .ToArray();
+
+            IReadOnlyList<MessageEmissionData> emissionHistory =
+                token._emissionBuffer.Count > 0 ? token._emissionBuffer.ToArray() : EmptyEmissions;
+
+            return new ListenerDiagnosticsView(
+                listener,
+                token.DiagnosticMode,
+                token.Enabled,
+                registrations,
+                emissionHistory
+            );
+        }
+
+        internal static ProviderDiagnosticsView CreateProviderDiagnostics(
+            MessagingComponent component
+        )
+        {
+            bool autoConfigure = component.AutoConfigureSerializedProviderOnAwake;
+            bool hasSerializedProvider =
+                component.SerializedProviderAsset != null || component.HasSerializedProvider;
+            bool hasRuntimeProvider = component.HasRuntimeProvider;
+            bool hasMessageBusOverride = component.HasMessageBusOverride;
+            bool serializedProviderMissingWarning = autoConfigure && !hasSerializedProvider;
+
+            bool serializedProviderNullBusWarning = false;
+            if (hasSerializedProvider)
+            {
+                IMessageBus resolvedBus = component.SerializedProviderHandle.ResolveBus();
+                serializedProviderNullBusWarning = resolvedBus == null;
+            }
+
+            return new ProviderDiagnosticsView(
+                autoConfigure,
+                hasSerializedProvider,
+                hasRuntimeProvider,
+                hasMessageBusOverride,
+                serializedProviderMissingWarning,
+                serializedProviderNullBusWarning
+            );
+        }
+    }
+
+    internal sealed class MessagingComponentInspectorState
+    {
+        internal MessagingComponentInspectorState(
+            bool globalDiagnosticsEnabled,
+            IReadOnlyList<MessageEmissionData> globalEmissionHistory,
+            IReadOnlyList<ListenerDiagnosticsView> listeners,
+            ProviderDiagnosticsView providerDiagnostics
+        )
+        {
+            GlobalDiagnosticsEnabled = globalDiagnosticsEnabled;
+            GlobalEmissionHistory =
+                globalEmissionHistory
+                ?? throw new ArgumentNullException(nameof(globalEmissionHistory));
+            Listeners = listeners ?? throw new ArgumentNullException(nameof(listeners));
+            ProviderDiagnostics = providerDiagnostics;
+        }
+
+        internal bool GlobalDiagnosticsEnabled { get; }
+
+        internal IReadOnlyList<MessageEmissionData> GlobalEmissionHistory { get; }
+
+        internal IReadOnlyList<ListenerDiagnosticsView> Listeners { get; }
+
+        internal ProviderDiagnosticsView ProviderDiagnostics { get; }
+    }
+
+    internal sealed class ListenerDiagnosticsView
+    {
+        internal ListenerDiagnosticsView(
+            MonoBehaviour listener,
+            bool diagnosticsEnabled,
+            bool tokenEnabled,
+            IReadOnlyList<MessageRegistrationView> registrations,
+            IReadOnlyList<MessageEmissionData> emissionHistory
+        )
+        {
+            Listener = listener;
+            DiagnosticsEnabled = diagnosticsEnabled;
+            TokenEnabled = tokenEnabled;
+            Registrations = registrations ?? throw new ArgumentNullException(nameof(registrations));
+            EmissionHistory =
+                emissionHistory ?? throw new ArgumentNullException(nameof(emissionHistory));
+        }
+
+        internal MonoBehaviour Listener { get; }
+
+        internal bool DiagnosticsEnabled { get; }
+
+        internal bool TokenEnabled { get; }
+
+        internal IReadOnlyList<MessageRegistrationView> Registrations { get; }
+
+        internal IReadOnlyList<MessageEmissionData> EmissionHistory { get; }
+    }
+
+    internal readonly struct MessageRegistrationView
+    {
+        internal MessageRegistrationView(
+            MessageRegistrationHandle handle,
+            MessageRegistrationMetadata metadata,
+            int callCount
+        )
+        {
+            Handle = handle;
+            Metadata = metadata;
+            CallCount = callCount;
+        }
+
+        internal MessageRegistrationHandle Handle { get; }
+
+        internal MessageRegistrationMetadata Metadata { get; }
+
+        internal int CallCount { get; }
+    }
+
+    internal readonly struct ProviderDiagnosticsView
+    {
+        internal ProviderDiagnosticsView(
+            bool autoConfigureSerializedProviderOnAwake,
+            bool hasSerializedProvider,
+            bool hasRuntimeProvider,
+            bool hasMessageBusOverride,
+            bool serializedProviderMissingWarning,
+            bool serializedProviderNullBusWarning
+        )
+        {
+            AutoConfigureSerializedProviderOnAwake = autoConfigureSerializedProviderOnAwake;
+            HasSerializedProvider = hasSerializedProvider;
+            HasRuntimeProvider = hasRuntimeProvider;
+            HasMessageBusOverride = hasMessageBusOverride;
+            SerializedProviderMissingWarning = serializedProviderMissingWarning;
+            SerializedProviderNullBusWarning = serializedProviderNullBusWarning;
+        }
+
+        internal bool AutoConfigureSerializedProviderOnAwake { get; }
+
+        internal bool HasSerializedProvider { get; }
+
+        internal bool HasRuntimeProvider { get; }
+
+        internal bool HasMessageBusOverride { get; }
+
+        internal bool SerializedProviderMissingWarning { get; }
+
+        internal bool SerializedProviderNullBusWarning { get; }
+    }
+}
+#endif

package/Editor/Testing/MessagingComponentEditorHarness.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2624c9e8eb5243ebb71545774f411c2c
+timeCreated: 1761880591

package/Editor/Testing.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a61780c8ba084b29bb44fdefc9b7fcf2
+timeCreated: 1761880591

package/README.md

@@ -2,7 +2,7 @@
 
 [![Unity](https://img.shields.io/badge/Unity-2021.3+-black.svg)](https://unity.com/releases/editor)<br/>
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE.md)<br/>
-[![Version](https://img.shields.io/badge/version-2.0.0--rc27-green.svg)](package.json)<br/>
+[![Version](https://img.shields.io/npm/v/com.wallstop-studios.dxmessaging.svg)](https://www.npmjs.com/package/com.wallstop-studios.dxmessaging)<br/>
 [![Performance: OS-Specific Benchmarks](https://img.shields.io/badge/Performance-OS--specific-blueviolet.svg)](Docs/Performance.md)<br/>
 [![Markdown Link Validity](https://github.com/wallstop/DxMessaging/actions/workflows/markdown-link-validity.yml/badge.svg)](https://github.com/wallstop/DxMessaging/actions/workflows/markdown-link-validity.yml)<br/>
 [![Markdown Link Text Check](https://github.com/wallstop/DxMessaging/actions/workflows/markdown-link-text-check.yml/badge.svg)](https://github.com/wallstop/DxMessaging/actions/workflows/markdown-link-text-check.yml)
@@ -11,6 +11,8 @@
 
 Think of it as **the event system Unity should have built-in** — one that actually scales.
 
+Need install instructions for Git URLs, scoped registries, or tarballs? Jump to the [Install Guide](Docs/Install.md).
+
 ## Table of Contents
 
 - [30-Second Elevator Pitch](#30-second-elevator-pitch)
@@ -50,7 +52,7 @@ Think of it as **the event system Unity should have built-in** — one that actu
 
 1. **Untargeted** - "Everyone listen!" (pause game, settings changed)
 1. **Targeted** - "Tell Player to heal" (commands to specific entities)
-1. **Broadcast** - "Enemy took damage" (events others can observe)
+1. **Broadcast** - "I took damage" (things that happen to _you_ that others can observe)
 
 **One line:** It's the event system Unity should have shipped with - type-safe, leak-proof, and actually debuggable. 🚀
 
@@ -62,12 +64,15 @@ Think of it as **the event system Unity should have built-in** — one that actu
 
 ### 1. Install
 
-Via Unity Package Manager → Add package from git URL:
+Via Unity Package Manager → Add package from git URL (see the [Install Guide](Docs/Install.md) for scoped registry, tarball, and offline options):
 
-```text
+```bash
+# Unity Package Manager > Add package from git URL...
 https://github.com/wallstop/DxMessaging.git
 ```
 
+Prefer OpenUPM, scoped registries, or local tarballs? The [Install Guide](Docs/Install.md) covers every path in detail.
+
 ### 2. Define Your First Message
 
 ```csharp
@@ -632,6 +637,7 @@ See [full comparison](Docs/Comparisons.md) for detailed analysis with code examp
 
 ### 📖 Reference
 
+- [Install Guide](Docs/Install.md) — All install options (Git URL, scoped registry, tarball, manual copy)
 - [Glossary](Docs/Glossary.md) — All terms explained in plain English
 - [Quick Reference](Docs/QuickReference.md) — Cheat sheet
 - [API Reference](Docs/Reference.md) — Complete API

package/Runtime/AssemblyInfo.cs

@@ -9,3 +9,4 @@ using System.Runtime.CompilerServices;
 [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")]

package/Runtime/Core/Attributes/DxOptionalParameterAttribute.cs

@@ -31,30 +31,82 @@ namespace DxMessaging.Core.Attributes
         /// 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>
+        /// <param name="value">Default value used when the constructor parameter is omitted.</param>
         public DxOptionalParameterAttribute(bool value) { }
 
+        /// <summary>
+        /// Initializes the attribute with the specified default character value.
+        /// </summary>
+        /// <param name="value">Default value used when the constructor parameter is omitted.</param>
         public DxOptionalParameterAttribute(char value) { }
 
+        /// <summary>
+        /// Initializes the attribute with the specified default string value.
+        /// </summary>
+        /// <param name="value">Default value used when the constructor parameter is omitted.</param>
         public DxOptionalParameterAttribute(string value) { }
 
+        /// <summary>
+        /// Initializes the attribute with the specified default byte value.
+        /// </summary>
+        /// <param name="value">Default value used when the constructor parameter is omitted.</param>
         public DxOptionalParameterAttribute(byte value) { }
 
+        /// <summary>
+        /// Initializes the attribute with the specified default signed byte value.
+        /// </summary>
+        /// <param name="value">Default value used when the constructor parameter is omitted.</param>
         public DxOptionalParameterAttribute(sbyte value) { }
 
+        /// <summary>
+        /// Initializes the attribute with the specified default short value.
+        /// </summary>
+        /// <param name="value">Default value used when the constructor parameter is omitted.</param>
         public DxOptionalParameterAttribute(short value) { }
 
+        /// <summary>
+        /// Initializes the attribute with the specified default unsigned short value.
+        /// </summary>
+        /// <param name="value">Default value used when the constructor parameter is omitted.</param>
         public DxOptionalParameterAttribute(ushort value) { }
 
+        /// <summary>
+        /// Initializes the attribute with the specified default integer value.
+        /// </summary>
+        /// <param name="value">Default value used when the constructor parameter is omitted.</param>
         public DxOptionalParameterAttribute(int value) { }
 
+        /// <summary>
+        /// Initializes the attribute with the specified default unsigned integer value.
+        /// </summary>
+        /// <param name="value">Default value used when the constructor parameter is omitted.</param>
         public DxOptionalParameterAttribute(uint value) { }
 
+        /// <summary>
+        /// Initializes the attribute with the specified default long value.
+        /// </summary>
+        /// <param name="value">Default value used when the constructor parameter is omitted.</param>
         public DxOptionalParameterAttribute(long value) { }
 
+        /// <summary>
+        /// Initializes the attribute with the specified default unsigned long value.
+        /// </summary>
+        /// <param name="value">Default value used when the constructor parameter is omitted.</param>
         public DxOptionalParameterAttribute(ulong value) { }
 
+        /// <summary>
+        /// Initializes the attribute with the specified default single-precision floating point value.
+        /// </summary>
+        /// <param name="value">Default value used when the constructor parameter is omitted.</param>
         public DxOptionalParameterAttribute(float value) { }
 
+        /// <summary>
+        /// Initializes the attribute with the specified default double-precision floating point value.
+        /// </summary>
+        /// <param name="value">Default value used when the constructor parameter is omitted.</param>
         public DxOptionalParameterAttribute(double value) { }
 
         /// <summary>

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -29,6 +29,10 @@ namespace DxMessaging.Core.DataStructure
                 _current = default;
             }
 
+            /// <summary>
+            /// Advances the enumerator to the next element in chronological order.
+            /// </summary>
+            /// <returns><c>true</c> when another element is available; otherwise <c>false</c>.</returns>
             public bool MoveNext()
             {
                 if (++_index < _buffer.Count)
@@ -41,16 +45,25 @@ namespace DxMessaging.Core.DataStructure
                 return false;
             }
 
+            /// <summary>
+            /// Gets the element at the current enumerator position.
+            /// </summary>
             public T Current => _current;
 
             object IEnumerator.Current => Current;
 
+            /// <summary>
+            /// Resets the enumerator to its initial position before the first element.
+            /// </summary>
             public void Reset()
             {
                 _index = -1;
                 _current = default;
             }
 
+            /// <summary>
+            /// Releases resources held by the enumerator.
+            /// </summary>
             public void Dispose() { }
         }
 
@@ -107,6 +120,9 @@ namespace DxMessaging.Core.DataStructure
             }
         }
 
+        /// <summary>
+        /// Creates an enumerator that iterates from the oldest element to the most recently added.
+        /// </summary>
         public CyclicBufferEnumerator GetEnumerator()
         {
             return new CyclicBufferEnumerator(this);

package/Runtime/Core/Diagnostics/MessageEmissionData.cs

@@ -1,15 +1,18 @@
 namespace DxMessaging.Core.Diagnostics
 {
     using System;
-#if UNITY_2017_1_OR_NEWER
+    using System.Linq;
+#if UNITY_2021_3_OR_NEWER
     using UnityEngine;
+#else
+    using System.Diagnostics;
 #endif
 
     /// <summary>
     /// Captures a snapshot of a message emission for diagnostics.
     /// </summary>
     /// <remarks>
-    /// When diagnostics are enabled (see <see cref="MessageBus.IMessageBus.GlobalDiagnosticsMode"/>),
+    /// When diagnostics are enabled (see <see cref="MessageBus.IMessageBus.GlobalDiagnosticsTargets"/>),
     /// the bus and tokens record recent emissions in ring buffers along with a trimmed stack trace
     /// that excludes DxMessaging internals for easier debugging.
     ///
@@ -45,7 +48,7 @@ namespace DxMessaging.Core.Diagnostics
         private static string GetAccurateStackTrace()
         {
             string fullStackTrace;
-#if UNITY_2017_1_OR_NEWER
+#if UNITY_2021_3_OR_NEWER
             fullStackTrace = StackTraceUtility.ExtractStackTrace();
 #else
             fullStackTrace = new StackTrace(true).ToString();
@@ -57,18 +60,30 @@ namespace DxMessaging.Core.Diagnostics
 
             string[] lines = fullStackTrace.Split(NewlineSeparators, StringSplitOptions.None);
 
-            int startIndex = 1;
-            while (
-                startIndex < lines.Length
-                && lines[startIndex].Contains("DxMessaging", StringComparison.OrdinalIgnoreCase)
-            )
+            string[] trimmedLines = lines
+                .Where(line => !string.IsNullOrWhiteSpace(line) && !IsInternalFrame(line))
+                .ToArray();
+
+            return trimmedLines.Length == 0
+                ? string.Empty
+                : string.Join(JoinSeparator, trimmedLines);
+        }
+
+        private static bool IsInternalFrame(string line)
+        {
+            if (string.IsNullOrWhiteSpace(line))
             {
-                ++startIndex;
+                return false;
             }
 
-            return lines.Length <= startIndex
-                ? string.Empty
-                : string.Join(JoinSeparator, lines, startIndex, lines.Length - startIndex);
+            if (!line.Contains("DxMessaging.", StringComparison.Ordinal))
+            {
+                return false;
+            }
+
+            return line.Contains("DxMessaging.Core.", StringComparison.Ordinal)
+                || line.Contains("DxMessaging.Unity.", StringComparison.Ordinal)
+                || line.Contains("DxMessaging.Editor.", StringComparison.Ordinal);
         }
     }
 }

package/Runtime/Core/Diagnostics/MessageRegistrationType.cs

@@ -1,21 +1,83 @@
 namespace DxMessaging.Core.Diagnostics
 {
+    /// <summary>
+    /// Categories used when recording registrations in diagnostics logs.
+    /// </summary>
     public enum MessageRegistrationType
     {
+        /// <summary>
+        /// No registration type was captured.
+        /// </summary>
         None = 0,
+
+        /// <summary>
+        /// A targeted handler that listens for messages addressed to a specific <see cref="Core.InstanceId"/>.
+        /// </summary>
         Targeted = 1,
+
+        /// <summary>
+        /// A global untargeted handler that receives all messages of a given type.
+        /// </summary>
         Untargeted = 2,
+
+        /// <summary>
+        /// A broadcast handler that listens for messages emitted from a source <see cref="Core.InstanceId"/>.
+        /// </summary>
         Broadcast = 3,
+
+        /// <summary>
+        /// A broadcast post-processor that runs after broadcast handlers complete.
+        /// </summary>
         BroadcastPostProcessor = 4,
+
+        /// <summary>
+        /// A targeted post-processor that runs after targeted handlers complete.
+        /// </summary>
         TargetedPostProcessor = 5,
+
+        /// <summary>
+        /// A targeted handler that ignores the concrete target during invocation.
+        /// </summary>
         TargetedWithoutTargeting = 6,
+
+        /// <summary>
+        /// A post-processor for handlers registered without a concrete target.
+        /// </summary>
         TargetedWithoutTargetingPostProcessor = 7,
+
+        /// <summary>
+        /// A broadcast handler registered without an explicit source identity.
+        /// </summary>
         BroadcastWithoutSource = 8,
+
+        /// <summary>
+        /// A post-processor for broadcast handlers registered without an explicit source.
+        /// </summary>
         BroadcastWithoutSourcePostProcessor = 9,
+
+        /// <summary>
+        /// A post-processor that runs after untargeted handlers complete.
+        /// </summary>
         UntargetedPostProcessor = 10,
+
+        /// <summary>
+        /// A global catch-all registration that observes every message.
+        /// </summary>
         GlobalAcceptAll = 11,
+
+        /// <summary>
+        /// An untargeted interceptor that can mutate or cancel global messages.
+        /// </summary>
         UntargetedInterceptor = 12,
+
+        /// <summary>
+        /// A targeted interceptor that can mutate or cancel messages bound to a specific recipient.
+        /// </summary>
         TargetedInterceptor = 13,
+
+        /// <summary>
+        /// A broadcast interceptor that can mutate or cancel messages emitted from a source.
+        /// </summary>
         BroadcastInterceptor = 14,
     }
 }

package/Runtime/Core/DxMessagingStaticState.cs

@@ -0,0 +1,108 @@
+namespace DxMessaging.Core
+{
+    using System;
+    using Helper;
+    using MessageBus;
+
+    /// <summary>
+    /// Centralised utility for resetting DxMessaging static state when Domain Reload is disabled.
+    /// </summary>
+    public static class DxMessagingStaticState
+    {
+        private static readonly object ResetLock = new object();
+        private static readonly BaselineState Baseline;
+
+        static DxMessagingStaticState()
+        {
+            Baseline = CaptureBaseline();
+        }
+
+        /// <summary>
+        /// Resets all static variables in DxMessaging to their default values.
+        /// </summary>
+        public static void Reset()
+        {
+            lock (ResetLock)
+            {
+                MessagingDebug.enabled = Baseline.MessagingDebugEnabled;
+                MessagingDebug.LogFunction = Baseline.MessagingDebugLogFunction;
+
+                IMessageBus.GlobalDiagnosticsTargets = Baseline.GlobalDiagnosticsTargets;
+                IMessageBus.GlobalMessageBufferSize = Baseline.GlobalMessageBufferSize;
+                IMessageBus.GlobalSequentialIndex = Baseline.GlobalSequentialIndex;
+
+                MessageHelperIndexer.RestoreState(Baseline.HelperState);
+
+                MessageRegistrationHandle.SetIdSeed(Baseline.MessageRegistrationHandleSeed);
+                MessageRegistrationBuilder.SetSyntheticOwnerCounter(Baseline.SyntheticOwnerCounter);
+
+                MessageHandler.ResetStatics();
+                IMessageBus.GlobalSequentialIndex = Baseline.GlobalSequentialIndex;
+            }
+        }
+
+        private static BaselineState CaptureBaseline()
+        {
+            bool messagingDebugEnabled = MessagingDebug.enabled;
+            Action<LogLevel, string> messagingDebugLogFunction = MessagingDebug.LogFunction;
+            DiagnosticsTarget globalDiagnosticsTargets = IMessageBus.GlobalDiagnosticsTargets;
+            int globalMessageBufferSize = IMessageBus.GlobalMessageBufferSize;
+            int globalSequentialIndex = IMessageBus.GlobalSequentialIndex;
+            long messageRegistrationHandleSeed = MessageRegistrationHandle.GetCurrentIdSeed();
+            int syntheticOwnerCounter = MessageRegistrationBuilder.GetSyntheticOwnerCounter();
+            MessageHelperIndexer.MessageHelperIndexerState helperState =
+                MessageHelperIndexer.CaptureState();
+
+            return new BaselineState(
+                messagingDebugEnabled,
+                messagingDebugLogFunction,
+                globalDiagnosticsTargets,
+                globalMessageBufferSize,
+                globalSequentialIndex,
+                messageRegistrationHandleSeed,
+                syntheticOwnerCounter,
+                helperState
+            );
+        }
+
+        private sealed class BaselineState
+        {
+            internal BaselineState(
+                bool messagingDebugEnabled,
+                Action<LogLevel, string> messagingDebugLogFunction,
+                DiagnosticsTarget globalDiagnosticsTargets,
+                int globalMessageBufferSize,
+                int globalSequentialIndex,
+                long messageRegistrationHandleSeed,
+                int syntheticOwnerCounter,
+                MessageHelperIndexer.MessageHelperIndexerState helperState
+            )
+            {
+                MessagingDebugEnabled = messagingDebugEnabled;
+                MessagingDebugLogFunction = messagingDebugLogFunction;
+                GlobalDiagnosticsTargets = globalDiagnosticsTargets;
+                GlobalMessageBufferSize = globalMessageBufferSize;
+                GlobalSequentialIndex = globalSequentialIndex;
+                MessageRegistrationHandleSeed = messageRegistrationHandleSeed;
+                SyntheticOwnerCounter = syntheticOwnerCounter;
+                HelperState = helperState;
+            }
+
+            internal bool MessagingDebugEnabled { get; }
+
+            internal Action<LogLevel, string> MessagingDebugLogFunction { get; }
+
+            internal DiagnosticsTarget GlobalDiagnosticsTargets { get; }
+
+            internal int GlobalMessageBufferSize { get; }
+
+            internal int GlobalSequentialIndex { get; }
+
+            internal long MessageRegistrationHandleSeed { get; }
+
+            internal int SyntheticOwnerCounter { get; }
+
+            internal MessageHelperIndexer.MessageHelperIndexerState HelperState { get; }
+        }
+    }
+}