com.wallstop-studios.dxmessaging 3.2.0 → 3.2.1

package/CHANGELOG.md

@@ -7,6 +7,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.2.1]
+
+### Changed
+
+- Removed the dead typed `MessageHandler.Handle*` callback methods and internalized the
+  three global callbacks still used by the message bus. These methods were nominally
+  public plumbing rather than supported registration APIs; bus dispatch and token
+  registration behavior are unchanged.
+- Refreshed the README banner (`docs/images/DxMessaging-banner.svg`): added
+  vertical separation between the tagline and the badge row, replaced the badges
+  with **Simple**, **MIT**, and the synced version, and re-drew the right panel
+  as one bus spine dispatching three aligned, color-coded message dots along
+  routes to labeled **Untargeted**, **Targeted**, and **Broadcast** destinations.
+- Simplified banner sync (`scripts/sync-banner-version.js`) to track only the
+  package version; the auto-derived test-count badge and its file-walking logic
+  were removed, along with the now-unneeded test-source triggers in the CI banner
+  gate and the pre-commit hook.
+
+### Added
+
+- Added a **Diagnostics Tooling Exerciser** sample scene that deterministically
+  drives Message Monitor, Flow Graph, Inspector diagnostics, and Project
+  Settings with untargeted, targeted, broadcast, exact-source broadcast,
+  broadcast-without-source, and `RegisterGlobalAcceptAll` routes.
+- Project Settings now exposes the **Ignored Base-Call Types** list under
+  Inspector Checks, so project-level base-call suppressions can be reviewed and
+  edited from the same settings page as the overlay toggles.
+- Flow Graph now includes visible trace-id lanes and visible trace route-kind
+  lanes over visible trace paths, reporting path-membership breadth or
+  route-kind delivery breadth plus message, target, and context details without
+  changing export schema v5.
+- Message Monitor now includes visible message-type and context lanes over the
+  current filter, reporting entry counts, distinct context/message breadth,
+  entry share, context lists, message lists, and row-level Filter shortcuts,
+  including exact quoted context shortcuts, without changing JSON export.
+- Message Monitor filtering now supports typed `type:`, `message:`,
+  `context:`, and `stack:` facets over captured entry fields while preserving
+  existing plain text matching, supports quoted typed values with spaces, and
+  displays the active typed or plain filter with a Clear action.
+
 ## [3.2.0]
 
 ### Added

package/Editor/Analyzers/DxMessagingConsoleHarvester.cs

@@ -84,13 +84,13 @@ namespace DxMessaging.Editor.Analyzers
     /// </para>
     /// <para>
     /// The inspector overlay reads its snapshot from the unified per-FQN map populated here on
-    /// every rescan. Use the menu <c>Tools > DxMessaging > Rescan Base-Call Warnings</c> for a
+    /// every rescan. Use the menu <c>Tools > Wallstop Studios > DxMessaging > Rescan Base-Call Warnings</c> for a
     /// manual force-rescan.
     /// </para>
     /// <para>
     /// <see cref="IsAvailable"/> stays <c>true</c> as long as the static constructor itself does
     /// not throw -- the IL scanner is always wired, so the overlay never falls back to its
-    /// degraded "harvester unavailable" HelpBox in normal operation. <see cref="LogEntriesAvailable"/>
+    /// degraded "harvester unavailable" warning surface in normal operation. <see cref="LogEntriesAvailable"/>
     /// continues to report whether the legacy reflection layer is bindable, for diagnostics only.
     /// </para>
     /// </remarks>
@@ -187,7 +187,7 @@ namespace DxMessaging.Editor.Analyzers
         // or whether it was loaded eagerly from `Library/DxMessaging/baseCallReport.json` in the
         // static ctor and has not yet been overwritten. The inspector overlay reads this to
         // distinguish "fresh-this-session" warnings from cached-from-previous-session warnings;
-        // when the cache is showing, we annotate the HelpBox with a small suffix so the user
+        // when the cache is showing, we annotate the warning surface so the user
         // understands the data may be stale until the first post-reload scan completes.
         //
         // Default `false`: the static ctor's `LoadFromDisk` runs first, so by the time anything
@@ -241,7 +241,7 @@ namespace DxMessaging.Editor.Analyzers
         /// constructor itself throws (a hard initialization failure). The LogEntries reflection
         /// layer is the optional source -- see <see cref="LogEntriesAvailable"/> for that flag.
         /// The inspector overlay reads this property to decide whether to render its degraded
-        /// HelpBox, so the contract here is "should the overlay attempt to render at all".
+        /// warning surface, so the contract here is "should the overlay attempt to render at all".
         /// </remarks>
         public static bool IsAvailable { get; private set; } = true;
 
@@ -259,11 +259,11 @@ namespace DxMessaging.Editor.Analyzers
         /// loaded eagerly by the static constructor.
         /// </summary>
         /// <remarks>
-        /// The inspector overlay reads this to annotate its HelpBox: when <c>false</c> AND a
-        /// warning is being shown, the overlay appends a "(cached from previous session --
-        /// refreshing...)" suffix so the user knows the data is from yesterday's scan and a fresh
+        /// The inspector overlay reads this to annotate its warning surface: when <c>false</c> AND a
+        /// warning is being shown, the overlay adds a "Report is cached from previous session;
+        /// refreshing..." note so the user knows the data is from yesterday's scan and a fresh
         /// one is in flight. The flag is set inside <see cref="RescanNow"/> and never reset, so
-        /// the suffix disappears as soon as the first post-reload scan lands and stays gone for
+        /// the note disappears as soon as the first post-reload scan lands and stays gone for
         /// the rest of the session.
         /// </remarks>
         public static bool IsFreshThisSession => _isFreshThisSession;

package/Editor/CustomEditors/MessageAwareComponentFallbackEditor.cs

@@ -1,14 +1,17 @@
 namespace DxMessaging.Editor.CustomEditors
 {
 #if UNITY_EDITOR
+    using System;
+    using DxMessaging.Editor.Analyzers;
     using DxMessaging.Unity;
     using UnityEditor;
+    using UnityEditor.UIElements;
+    using UnityEngine.UIElements;
 
     /// <summary>
-    /// Primary CustomEditor for every <see cref="MessageAwareComponent"/> subclass. Renders the
-    /// DxMessaging warning HelpBox above an inspector body that is byte-for-byte identical to
-    /// Unity's default <c>GenericInspector</c> (achieved via
-    /// <see cref="Editor.DrawDefaultInspector"/>).
+    /// Primary CustomEditor for every <see cref="MessageAwareComponent"/> subclass. Hosts the
+    /// DxMessaging warning above a default inspector body that keeps Unity's serialized field
+    /// surface intact.
     /// </summary>
     /// <remarks>
     /// We register as a non-fallback (primary) editor with
@@ -33,20 +36,20 @@ namespace DxMessaging.Editor.CustomEditors
     /// </list>
     ///
     /// <para>
-    /// The current design is the simple one: be the primary editor, prepend the overlay's
-    /// HelpBox via <see cref="MessageAwareComponentInspectorOverlay.RenderInsideOnInspectorGUI"/>,
-    /// then call <see cref="Editor.DrawDefaultInspector"/>. The body therefore matches
-    /// <c>GenericInspector</c> exactly: no missing Script row, no extra vertical gap. To avoid
-    /// double-rendering when the header hook ALSO fires for our editor instance (Unity 2022+),
+    /// The current primary path is <see cref="CreateInspectorGUI"/>: it hosts the UI Toolkit
+    /// warning view, then fills Unity's default Inspector body through
+    /// <see cref="InspectorElement.FillDefaultInspector"/> so the disabled Script row and
+    /// serialized fields remain present. To avoid double-rendering when the header hook ALSO
+    /// fires for our editor instance (Unity 2022+),
     /// <see cref="MessageAwareComponentInspectorOverlay"/> unconditionally skips the header path
     /// for <see cref="MessageAwareComponentFallbackEditor"/> instances.
     /// </para>
     ///
     /// <para>
-    /// We do NOT short-circuit <see cref="OnInspectorGUI"/> on event type. Unity invokes
-    /// editors twice per frame (Layout + Repaint), and both passes MUST emit identical control
-    /// counts, otherwise the inspector window's layout cache is corrupted and adjacent
-    /// components fail to render. See
+    /// <see cref="OnInspectorGUI"/> remains as an IMGUI compatibility fallback. We do NOT
+    /// short-circuit it on event type. Unity invokes editors twice per frame (Layout + Repaint),
+    /// and both passes MUST emit identical control counts, otherwise the inspector window's layout
+    /// cache is corrupted and adjacent components fail to render. See
     /// <see cref="MessageAwareComponentInspectorOverlay.RenderInsideOnInspectorGUI"/> for the
     /// matching invariant on the overlay side.
     /// </para>
@@ -63,6 +66,23 @@ namespace DxMessaging.Editor.CustomEditors
     [CanEditMultipleObjects]
     public sealed class MessageAwareComponentFallbackEditor : Editor
     {
+        internal const string RootName = "dxmessaging-fallback-inspector";
+        internal const string RootClassName = "dxmessaging-fallback-inspector";
+        internal const string WarningHostName = "dxmessaging-fallback-inspector-warning-host";
+        internal const string WarningHostClassName = "dxmessaging-fallback-inspector-warning-host";
+        internal const string DefaultInspectorBodyName =
+            "dxmessaging-fallback-inspector-default-body";
+        internal const string DefaultInspectorBodyClassName =
+            "dxmessaging-fallback-inspector-default-body";
+
+        public override VisualElement CreateInspectorGUI()
+        {
+            return BuildInspectorGUI(
+                this,
+                () => MessageAwareComponentInspectorOverlay.ResolveInspectorState(target)
+            );
+        }
+
         public override void OnInspectorGUI()
         {
             // Render the overlay BEFORE the default body so the warning appears prominently at
@@ -76,6 +96,144 @@ namespace DxMessaging.Editor.CustomEditors
             // [SerializeField] fields.
             DrawDefaultInspector();
         }
+
+        internal static VisualElement BuildInspectorGUI(
+            Editor editor,
+            Func<MessageAwareComponentInspectorState> resolveState
+        )
+        {
+            if (editor == null)
+            {
+                throw new ArgumentNullException(nameof(editor));
+            }
+            if (resolveState == null)
+            {
+                throw new ArgumentNullException(nameof(resolveState));
+            }
+
+            VisualElement root = new() { name = RootName };
+            DxMessagingEditorTheme.Apply(root);
+            root.AddToClassList(RootClassName);
+
+            VisualElement warningHost = new() { name = WarningHostName };
+            warningHost.AddToClassList(WarningHostClassName);
+            root.Add(warningHost);
+
+            InspectorWarningBinding binding = new(warningHost, resolveState);
+            root.userData = binding;
+            binding.Refresh();
+
+            VisualElement defaultBody = new() { name = DefaultInspectorBodyName };
+            defaultBody.AddToClassList(DefaultInspectorBodyClassName);
+            InspectorElement.FillDefaultInspector(defaultBody, editor.serializedObject, editor);
+            root.Add(defaultBody);
+
+            root.RegisterCallback<AttachToPanelEvent>(_ => binding.Connect());
+            root.RegisterCallback<DetachFromPanelEvent>(_ => binding.Disconnect());
+
+            return root;
+        }
+
+        internal static void RefreshInspectorWarning(VisualElement root)
+        {
+            if (root == null)
+            {
+                throw new ArgumentNullException(nameof(root));
+            }
+            if (root.userData is not InspectorWarningBinding binding)
+            {
+                throw new InvalidOperationException(
+                    "Fallback inspector root is missing its warning binding."
+                );
+            }
+
+            binding.Refresh();
+        }
+
+        private sealed class InspectorWarningBinding
+        {
+            private readonly VisualElement _warningHost;
+            private readonly Func<MessageAwareComponentInspectorState> _resolveState;
+            private bool _connected;
+            private bool _refreshRetryScheduled;
+
+            internal InspectorWarningBinding(
+                VisualElement warningHost,
+                Func<MessageAwareComponentInspectorState> resolveState
+            )
+            {
+                _warningHost = warningHost ?? throw new ArgumentNullException(nameof(warningHost));
+                _resolveState =
+                    resolveState ?? throw new ArgumentNullException(nameof(resolveState));
+            }
+
+            internal void Connect()
+            {
+                if (_connected)
+                {
+                    return;
+                }
+
+                DxMessagingConsoleHarvester.ReportUpdated += Refresh;
+                MessageAwareComponentInspectorOverlay.InspectorStateInvalidated += Refresh;
+                _connected = true;
+                Refresh();
+            }
+
+            internal void Disconnect()
+            {
+                if (!_connected)
+                {
+                    return;
+                }
+
+                DxMessagingConsoleHarvester.ReportUpdated -= Refresh;
+                MessageAwareComponentInspectorOverlay.InspectorStateInvalidated -= Refresh;
+                _connected = false;
+            }
+
+            internal void Refresh()
+            {
+                MessageAwareComponentInspectorState state = _resolveState();
+                if (state.Kind == MessageAwareComponentInspectorStateKind.None)
+                {
+                    if (
+                        MessageAwareComponentInspectorOverlay.IsInspectorResolutionTransientlyBlocked()
+                    )
+                    {
+                        ScheduleRefreshRetry();
+                        return;
+                    }
+
+                    _warningHost.Clear();
+                    _warningHost.style.display = DisplayStyle.None;
+                    return;
+                }
+
+                _refreshRetryScheduled = false;
+                _warningHost.Clear();
+                _warningHost.style.display = DisplayStyle.Flex;
+                _warningHost.Add(MessageAwareComponentInspectorOverlay.CreateInspectorView(state));
+            }
+
+            private void ScheduleRefreshRetry()
+            {
+                if (_refreshRetryScheduled)
+                {
+                    return;
+                }
+
+                _refreshRetryScheduled = true;
+                System.Action<System.Action> schedule =
+                    MessageAwareComponentInspectorOverlay.TransientRefreshScheduler
+                    ?? DxMessagingEditorIdle.ScheduleAssetDatabaseMutation;
+                schedule(() =>
+                {
+                    _refreshRetryScheduled = false;
+                    Refresh();
+                });
+            }
+        }
     }
 #endif
 }