com.wallstop-studios.dxmessaging 2.1.0 → 2.1.2

package/Editor/SetupCscRsp.cs

@@ -6,6 +6,7 @@ namespace DxMessaging.Editor
     using System.Collections.Generic;
     using System.IO;
     using System.Linq;
+    using System.Security.Cryptography;
     using UnityEditor;
     using UnityEngine;
     using Object = UnityEngine.Object;
@@ -20,11 +21,11 @@ namespace DxMessaging.Editor
             )
             .Replace("\\", "/");
 
-        private static readonly string AnalyzerPathRelative =
-            "Packages/com.wallstop-studios.dxmessaging/Editor/Analyzers/";
-
-        private static readonly string LibraryPathRelative =
-            "Library/PackageCache/com.wallstop-studios.dxmessaging/Editor/Analyzers/";
+        private static readonly string[] AnalyzerDirectories =
+        {
+            "Packages/com.wallstop-studios.dxmessaging/Editor/Analyzers/",
+            "Library/PackageCache/com.wallstop-studios.dxmessaging/Editor/Analyzers/",
+        };
 
         private static readonly string SourceGeneratorDllName =
             "WallstopStudios.DxMessaging.SourceGenerators.dll";
@@ -34,13 +35,18 @@ namespace DxMessaging.Editor
             SourceGeneratorDllName,
             "Microsoft.CodeAnalysis.dll",
             "Microsoft.CodeAnalysis.CSharp.dll",
+            "System.Text.Encodings.Web.dll",
             "System.Reflection.Metadata.dll",
             "System.Runtime.CompilerServices.Unsafe.dll",
             "System.Collections.Immutable.dll",
+            "System.Memory.dll",
+            "System.Buffers.dll",
+            "System.Threading.Tasks.Extensions.dll",
+            "System.Numerics.Vectors.dll",
+            "System.Text.Encoding.CodePages.dll",
+            "Microsoft.Bcl.AsyncInterfaces.dll",
         };
 
-        private static readonly string LibraryArgument = $"-a:\"{LibraryPathRelative}\"";
-
         private static readonly HashSet<string> DllNames = new(StringComparer.OrdinalIgnoreCase);
 
         static SetupCscRsp()
@@ -69,17 +75,14 @@ namespace DxMessaging.Editor
                 }
             }
 
-            string[] dllRelativeDirectories = { LibraryPathRelative, AnalyzerPathRelative };
-
-            bool anyFound = false;
-            foreach (
-                string requiredDllName in RequiredDllNames.Where(dllName =>
-                    !DllNames.Contains(dllName)
-                )
-            )
+            foreach (string requiredDllName in RequiredDllNames)
             {
-                bool found = false;
-                foreach (string relativeDirectory in dllRelativeDirectories)
+                if (DllNames.Contains(requiredDllName))
+                {
+                    continue;
+                }
+
+                foreach (string relativeDirectory in AnalyzerDirectories)
                 {
                     try
                     {
@@ -92,52 +95,62 @@ namespace DxMessaging.Editor
                         const string pluginsDirectory =
                             "Assets/Plugins/Editor/WallstopStudios.DxMessaging/";
                         string outputAsset = $"{pluginsDirectory}{requiredDllName}";
-                        string sourceAsset = $"{relativeDirectory}{requiredDllName}";
                         if (!Directory.Exists(pluginsDirectory))
                         {
                             Directory.CreateDirectory(pluginsDirectory);
                             AssetDatabase.Refresh();
                         }
-                        if (!File.Exists(outputAsset))
+                        bool needsCopy = FilesDiffer(sourceFile, outputAsset);
+                        if (needsCopy)
                         {
-                            File.Copy(sourceAsset, outputAsset);
+                            File.Copy(sourceFile, outputAsset, true);
                             AssetDatabase.ImportAsset(outputAsset);
-                            found = true;
                         }
-                        else
+
+                        if (requiredDllName == SourceGeneratorDllName)
+                        {
+                            Object loadedDll = AssetDatabase.LoadMainAssetAtPath(outputAsset);
+                            if (loadedDll != null)
+                            {
+                                string[] existingLabels = AssetDatabase.GetLabels(loadedDll);
+                                if (!existingLabels.Contains("RoslynAnalyzer"))
+                                {
+                                    List<string> newLabels = existingLabels.ToList();
+                                    newLabels.Add("RoslynAnalyzer");
+                                    AssetDatabase.SetLabels(loadedDll, newLabels.ToArray());
+                                }
+                            }
+                        }
+
+                        if (AssetImporter.GetAtPath(outputAsset) is PluginImporter importer)
                         {
-                            FileInfo sourceInfo = new(sourceAsset);
-                            FileInfo destInfo = new(outputAsset);
+                            bool importerDirty = false;
 
-                            if (destInfo.LastWriteTime < sourceInfo.LastWriteTime)
+                            if (importer.GetCompatibleWithAnyPlatform())
                             {
-                                // Source file is newer, so copy the file (overwrite destination)
-                                File.Copy(sourceAsset, outputAsset, true);
-                                AssetDatabase.ImportAsset(outputAsset);
-                                found = true;
+                                importer.SetCompatibleWithAnyPlatform(false);
+                                importerDirty = true;
                             }
-                            else
+
+                            if (importer.GetExcludeFromAnyPlatform("Editor"))
                             {
-                                continue;
+                                importer.SetExcludeFromAnyPlatform("Editor", false);
+                                importerDirty = true;
                             }
-                        }
 
-                        if (requiredDllName == SourceGeneratorDllName)
-                        {
-                            Object loadedDll = AssetDatabase.LoadMainAssetAtPath(outputAsset);
-                            AssetDatabase.SetLabels(loadedDll, new[] { "RoslynAnalyzer" });
-                        }
+                            if (!importer.GetExcludeFromAnyPlatform("Standalone"))
+                            {
+                                importer.SetExcludeFromAnyPlatform("Standalone", true);
+                                importerDirty = true;
+                            }
 
-                        PluginImporter importer =
-                            AssetImporter.GetAtPath(outputAsset) as PluginImporter;
-                        if (importer != null)
-                        {
-                            importer.SetCompatibleWithAnyPlatform(false);
-                            importer.SetExcludeFromAnyPlatform("Editor", false);
-                            importer.SetExcludeFromAnyPlatform("Standalone", false);
-                            importer.SaveAndReimport();
+                            if (importerDirty || needsCopy)
+                            {
+                                importer.SaveAndReimport();
+                            }
                         }
 
+                        DllNames.Add(requiredDllName);
                         break;
                     }
                     catch (Exception e)
@@ -147,16 +160,36 @@ namespace DxMessaging.Editor
                         );
                     }
                 }
-
-                anyFound |= found;
             }
 
-            if (anyFound)
+            if (DllNames.Count > 0)
             {
                 AssetDatabase.Refresh();
             }
         }
 
+        private static bool FilesDiffer(string sourcePath, string destinationPath)
+        {
+            if (!File.Exists(destinationPath))
+            {
+                return true;
+            }
+
+            FileInfo sourceInfo = new(sourcePath);
+            FileInfo destinationInfo = new(destinationPath);
+            if (sourceInfo.Length != destinationInfo.Length)
+            {
+                return true;
+            }
+
+            using FileStream sourceStream = File.OpenRead(sourcePath);
+            using FileStream destinationStream = File.OpenRead(destinationPath);
+            using SHA256 sha256 = SHA256.Create();
+            byte[] sourceHash = sha256.ComputeHash(sourceStream);
+            byte[] destinationHash = sha256.ComputeHash(destinationStream);
+            return !sourceHash.AsSpan().SequenceEqual(destinationHash);
+        }
+
         private static void EnsureCscRsp()
         {
             try
@@ -168,20 +201,67 @@ namespace DxMessaging.Editor
                 }
 
                 string rspContent = File.ReadAllText(RspFilePath);
-                if (rspContent.Contains(LibraryArgument, StringComparison.OrdinalIgnoreCase))
+                bool modified = false;
+                foreach (string analyzerArgument in GetAnalyzerArguments())
                 {
-                    return;
+                    if (rspContent.Contains(analyzerArgument, StringComparison.OrdinalIgnoreCase))
+                    {
+                        continue;
+                    }
+
+                    File.AppendAllText(RspFilePath, analyzerArgument + Environment.NewLine);
+                    modified = true;
                 }
 
-                File.AppendAllText(RspFilePath, $"{LibraryArgument}{Environment.NewLine}");
-                AssetDatabase.ImportAsset("csc.rsp");
-                Debug.Log("Updated csc.rsp.");
+                if (modified)
+                {
+                    AssetDatabase.ImportAsset("csc.rsp");
+                    Debug.Log("Updated csc.rsp.");
+                }
             }
             catch (IOException ex)
             {
                 Debug.LogError($"Failed to modify csc.rsp: {ex}");
             }
         }
+
+        private static IEnumerable<string> GetAnalyzerArguments()
+        {
+            HashSet<string> yielded = new(StringComparer.OrdinalIgnoreCase);
+            string projectRoot = Path.GetFullPath(Path.Combine(Application.dataPath, ".."));
+
+            foreach (string directory in AnalyzerDirectories)
+            {
+                foreach (string dllName in RequiredDllNames)
+                {
+                    string absoluteDirectory = Path.IsPathRooted(directory)
+                        ? directory
+                        : Path.GetFullPath(Path.Combine(projectRoot, directory));
+
+                    string absoluteAnalyzerPath = Path.Combine(absoluteDirectory, dllName);
+                    if (!File.Exists(absoluteAnalyzerPath))
+                    {
+                        continue;
+                    }
+
+                    string projectRelativePath = FileUtil.GetProjectRelativePath(
+                        absoluteAnalyzerPath
+                    );
+                    if (string.IsNullOrEmpty(projectRelativePath))
+                    {
+                        continue;
+                    }
+
+                    string normalizedRelativePath = projectRelativePath.Replace("\\", "/");
+                    if (!yielded.Add(normalizedRelativePath))
+                    {
+                        continue;
+                    }
+
+                    yield return $"-a:\"{normalizedRelativePath}\"";
+                }
+            }
+        }
     }
 }
 #endif

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)
@@ -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/DxAutoConstructorAttribute.cs

@@ -14,7 +14,7 @@ namespace DxMessaging.Core.Attributes
     /// <code>
     /// [DxMessaging.Core.Attributes.DxUntargetedMessage]
     /// [DxMessaging.Core.Attributes.DxAutoConstructor]
-    /// public readonly struct VideoSettingsChanged
+    /// public readonly partial struct VideoSettingsChanged
     /// {
     ///     public readonly int width;
     ///     public readonly int height;

package/Runtime/Core/Attributes/DxBroadcastMessageAttribute.cs

@@ -13,7 +13,7 @@ namespace DxMessaging.Core.Attributes
     /// <example>
     /// <code>
     /// [DxMessaging.Core.Attributes.DxBroadcastMessage]
-    /// public readonly struct TookDamage
+    /// public readonly partial struct TookDamage
     /// {
     ///     public readonly int amount;
     ///     public TookDamage(int amount) { this.amount = amount; }

package/Runtime/Core/Attributes/DxOptionalParameterAttribute.cs

@@ -12,7 +12,7 @@ namespace DxMessaging.Core.Attributes
     /// <example>
     /// <code>
     /// [DxAutoConstructor]
-    /// public readonly struct Example
+    /// public readonly partial struct Example
     /// {
     ///     public readonly int required;
     ///     [DxOptionalParameter] public readonly int optional; // defaults to 0

package/Runtime/Core/Attributes/DxTargetedMessageAttribute.cs

@@ -14,7 +14,7 @@ namespace DxMessaging.Core.Attributes
     /// <example>
     /// <code>
     /// [DxMessaging.Core.Attributes.DxTargetedMessage]
-    /// public readonly struct HealRequest
+    /// public readonly partial struct HealRequest
     /// {
     ///     public readonly int amount;
     ///     public HealRequest(int amount) { this.amount = amount; }

package/Runtime/Core/Attributes/DxUntargetedMessageAttribute.cs

@@ -14,7 +14,7 @@ namespace DxMessaging.Core.Attributes
     /// <example>
     /// <code>
     /// [DxMessaging.Core.Attributes.DxUntargetedMessage]
-    /// public readonly struct WorldRegenerated
+    /// public readonly partial struct WorldRegenerated
     /// {
     ///     public readonly int seed;
     ///     public WorldRegenerated(int seed) { this.seed = seed; }

package/Runtime/Core/Diagnostics/MessageEmissionData.cs

@@ -1,8 +1,11 @@
 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>
@@ -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);
         }
     }
 }