com.wallstop-studios.dxmessaging 3.1.0 → 3.2.0

package/Runtime/Core/MessageHandler.cs

@@ -769,6 +769,99 @@ namespace DxMessaging.Core
             }
         }
 
+        /// <summary>
+        /// Per-handle teardown object returned by the
+        /// <see cref="MessageHandler"/> registration entry points, replacing the
+        /// per-registration deregistration <see cref="Action"/> closure (the
+        /// closure's display class + delegate are folded into this object's
+        /// fields, saving one managed allocation per registration). The
+        /// concrete subclasses re-express the exact body of the closure they
+        /// replace; <see cref="Deregister"/> is idempotent-friendly under the
+        /// same generation / slot-version guards.
+        /// </summary>
+        /// <remarks>
+        /// The implicit conversion to <see cref="Action"/> exists so the
+        /// handful of internal callers (contract tests through the
+        /// bus&lt;-&gt;handler boundary) that stored the old <see cref="Action"/>
+        /// continue to compile unchanged; it allocates a single delegate ONLY
+        /// when a caller explicitly requests the <see cref="Action"/> form, and
+        /// is never used on the token's common storage path (which holds this
+        /// object directly).
+        /// </remarks>
+        internal abstract class HandlerDeregistration
+        {
+            internal abstract void Deregister();
+
+            public static implicit operator Action(HandlerDeregistration deregistration)
+            {
+                return deregistration == null ? null : deregistration.Deregister;
+            }
+        }
+
+        /// <summary>
+        /// Teardown for the interceptor facades: the bus-side registration is
+        /// the only thing to undo (there is no typed-handler cache entry).
+        /// Mirrors the old <c>() =&gt; messageBus.Deregister&lt;T&gt;(in registration)</c>.
+        /// </summary>
+        internal sealed class InterceptorDeregistration<T> : HandlerDeregistration
+            where T : IMessage
+        {
+            private readonly IMessageBus _messageBus;
+            private readonly MessageBusRegistration _registration;
+
+            internal InterceptorDeregistration(
+                IMessageBus messageBus,
+                in MessageBusRegistration registration
+            )
+            {
+                _messageBus = messageBus;
+                _registration = registration;
+            }
+
+            internal override void Deregister()
+            {
+                _messageBus.Deregister<T>(in _registration);
+            }
+        }
+
+        /// <summary>
+        /// Composite teardown for the global accept-all registration: undoes the
+        /// bus-side global registration then the three typed sub-handler
+        /// deregistrations, preserving the exact order of the old closure
+        /// (<c>messageBus.Deregister&lt;IMessage&gt;(...); untargeted(); targeted(); broadcast();</c>).
+        /// </summary>
+        internal sealed class GlobalAcceptAllDeregistration : HandlerDeregistration
+        {
+            private readonly IMessageBus _messageBus;
+            private readonly MessageBusRegistration _messageBusRegistration;
+            private readonly Action _untargetedDeregistration;
+            private readonly Action _targetedDeregistration;
+            private readonly Action _broadcastDeregistration;
+
+            internal GlobalAcceptAllDeregistration(
+                IMessageBus messageBus,
+                in MessageBusRegistration messageBusRegistration,
+                Action untargetedDeregistration,
+                Action targetedDeregistration,
+                Action broadcastDeregistration
+            )
+            {
+                _messageBus = messageBus;
+                _messageBusRegistration = messageBusRegistration;
+                _untargetedDeregistration = untargetedDeregistration;
+                _targetedDeregistration = targetedDeregistration;
+                _broadcastDeregistration = broadcastDeregistration;
+            }
+
+            internal override void Deregister()
+            {
+                _messageBus.Deregister<IMessage>(in _messageBusRegistration);
+                _untargetedDeregistration();
+                _targetedDeregistration();
+                _broadcastDeregistration();
+            }
+        }
+
         /// <summary>
         /// Registers this MessageHandler to Globally Accept All Messages via the MessageBus, properly handling deregistration.
         /// </summary>
@@ -777,7 +870,7 @@ namespace DxMessaging.Core
         /// <param name="targetedMessageHandler">MessageHandler to accept all BroadcastMessages for all entities.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterGlobalAcceptAll(
+        internal HandlerDeregistration RegisterGlobalAcceptAll(
             Action<IUntargetedMessage> originalUntargetedMessageHandler,
             Action<IUntargetedMessage> untargetedMessageHandler,
             Action<InstanceId, ITargetedMessage> originalTargetedMessageHandler,
@@ -788,7 +881,9 @@ namespace DxMessaging.Core
         )
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterGlobalAcceptAll(this);
+            MessageBusRegistration messageBusDeregistration = messageBus.RegisterGlobalAcceptAll(
+                this
+            );
             TypedHandler<IMessage> typedHandler = GetOrCreateHandlerForType<IMessage>(messageBus);
 
             Action untargetedDeregistration = typedHandler.AddGlobalUntargetedHandler(
@@ -810,13 +905,13 @@ namespace DxMessaging.Core
                 messageBus
             );
 
-            return () =>
-            {
-                messageBusDeregistration?.Invoke();
-                untargetedDeregistration();
-                targetedDeregistration();
-                broadcastDeregistration();
-            };
+            return new GlobalAcceptAllDeregistration(
+                messageBus,
+                in messageBusDeregistration,
+                untargetedDeregistration,
+                targetedDeregistration,
+                broadcastDeregistration
+            );
 
             void NullDeregistration()
             {
@@ -832,7 +927,7 @@ namespace DxMessaging.Core
         /// <param name="targetedMessageHandler">MessageHandler to accept all BroadcastMessages for all entities.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterGlobalAcceptAll(
+        internal HandlerDeregistration RegisterGlobalAcceptAll(
             FastHandler<IUntargetedMessage> originalUntargetedMessageHandler,
             FastHandler<IUntargetedMessage> untargetedMessageHandler,
             FastHandlerWithContext<ITargetedMessage> originalTargetedMessageHandler,
@@ -843,7 +938,9 @@ namespace DxMessaging.Core
         )
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterGlobalAcceptAll(this);
+            MessageBusRegistration messageBusDeregistration = messageBus.RegisterGlobalAcceptAll(
+                this
+            );
             TypedHandler<IMessage> typedHandler = GetOrCreateHandlerForType<IMessage>(messageBus);
 
             Action untargetedDeregistration = typedHandler.AddGlobalUntargetedHandler(
@@ -865,13 +962,13 @@ namespace DxMessaging.Core
                 messageBus
             );
 
-            return () =>
-            {
-                messageBusDeregistration?.Invoke();
-                untargetedDeregistration();
-                targetedDeregistration();
-                broadcastDeregistration();
-            };
+            return new GlobalAcceptAllDeregistration(
+                messageBus,
+                in messageBusDeregistration,
+                untargetedDeregistration,
+                targetedDeregistration,
+                broadcastDeregistration
+            );
 
             void NullDeregistration()
             {
@@ -888,7 +985,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterTargetedMessageHandler<T>(
+        internal HandlerDeregistration RegisterTargetedMessageHandler<T>(
             InstanceId target,
             Action<T> originalHandler,
             Action<T> messageHandler,
@@ -898,7 +995,7 @@ namespace DxMessaging.Core
             where T : ITargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterTargeted<T>(
+            MessageBusRegistration messageBusDeregistration = messageBus.RegisterTargeted<T>(
                 target,
                 this,
                 priority: priority
@@ -914,6 +1011,39 @@ namespace DxMessaging.Core
             );
         }
 
+        /// <summary>
+        /// Registers a targeted handler whose diagnostics-augmented by-ref flat
+        /// invoker was already built by the caller (the registration token), so the
+        /// default slot stores a single closure instead of an <see cref="Action{T}"/>
+        /// wrapper plus a separately allocated FastHandler adapter.
+        /// <paramref name="originalHandler"/> stays the dedup/identity key.
+        /// </summary>
+        internal HandlerDeregistration RegisterTargetedMessageHandler<T>(
+            InstanceId target,
+            Action<T> originalHandler,
+            FastHandler<T> flatInvoker,
+            int priority = 0,
+            IMessageBus messageBus = null
+        )
+            where T : ITargetedMessage
+        {
+            messageBus = ResolveMessageBus(messageBus);
+            MessageBusRegistration messageBusDeregistration = messageBus.RegisterTargeted<T>(
+                target,
+                this,
+                priority: priority
+            );
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.AddTargetedHandler(
+                target,
+                originalHandler,
+                flatInvoker,
+                messageBusDeregistration,
+                priority,
+                messageBus
+            );
+        }
+
         /// <summary>
         /// Registers this MessageHandler to accept fast TargetedMessages via the MessageBus, properly handling deregistration.
         /// </summary>
@@ -923,7 +1053,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterTargetedMessageHandler<T>(
+        internal HandlerDeregistration RegisterTargetedMessageHandler<T>(
             InstanceId target,
             FastHandler<T> originalHandler,
             FastHandler<T> messageHandler,
@@ -933,7 +1063,7 @@ namespace DxMessaging.Core
             where T : ITargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterTargeted<T>(
+            MessageBusRegistration messageBusDeregistration = messageBus.RegisterTargeted<T>(
                 target,
                 this,
                 priority: priority
@@ -958,7 +1088,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterTargetedPostProcessor<T>(
+        internal HandlerDeregistration RegisterTargetedPostProcessor<T>(
             InstanceId target,
             Action<T> originalHandler,
             Action<T> messageHandler,
@@ -968,11 +1098,8 @@ namespace DxMessaging.Core
             where T : ITargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterTargetedPostProcessor<T>(
-                target,
-                this,
-                priority
-            );
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterTargetedPostProcessor<T>(target, this, priority);
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
             return typedHandler.AddTargetedPostProcessor(
                 target,
@@ -993,7 +1120,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterTargetedPostProcessor<T>(
+        internal HandlerDeregistration RegisterTargetedPostProcessor<T>(
             InstanceId target,
             FastHandler<T> originalHandler,
             FastHandler<T> messageHandler,
@@ -1003,16 +1130,43 @@ namespace DxMessaging.Core
             where T : ITargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterTargetedPostProcessor<T>(
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterTargetedPostProcessor<T>(target, this, priority: priority);
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.AddTargetedPostProcessor(
                 target,
-                this,
-                priority: priority
+                originalHandler,
+                messageHandler,
+                messageBusDeregistration,
+                priority,
+                messageBus
             );
+        }
+
+        /// <summary>
+        /// Registers a targeted post-processor whose diagnostics-augmented by-ref flat
+        /// invoker was already built by the caller (the registration token), so the
+        /// default slot stores a single closure instead of an <see cref="Action{T}"/>
+        /// wrapper plus a separately allocated FastHandler adapter.
+        /// <paramref name="originalHandler"/> stays the dedup/identity key.
+        /// </summary>
+        internal HandlerDeregistration RegisterTargetedPostProcessor<T>(
+            InstanceId target,
+            Action<T> originalHandler,
+            FastHandler<T> flatInvoker,
+            int priority = 0,
+            IMessageBus messageBus = null
+        )
+            where T : ITargetedMessage
+        {
+            messageBus = ResolveMessageBus(messageBus);
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterTargetedPostProcessor<T>(target, this, priority);
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
             return typedHandler.AddTargetedPostProcessor(
                 target,
                 originalHandler,
-                messageHandler,
+                flatInvoker,
                 messageBusDeregistration,
                 priority,
                 messageBus
@@ -1027,7 +1181,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterTargetedWithoutTargetingPostProcessor<T>(
+        internal HandlerDeregistration RegisterTargetedWithoutTargetingPostProcessor<T>(
             Action<InstanceId, T> originalHandler,
             Action<InstanceId, T> messageHandler,
             int priority = 0,
@@ -1036,7 +1190,7 @@ namespace DxMessaging.Core
             where T : ITargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration =
+            MessageBusRegistration messageBusDeregistration =
                 messageBus.RegisterTargetedWithoutTargetingPostProcessor<T>(
                     priority: priority,
                     messageHandler: this
@@ -1059,7 +1213,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterTargetedWithoutTargetingPostProcessor<T>(
+        internal HandlerDeregistration RegisterTargetedWithoutTargetingPostProcessor<T>(
             FastHandlerWithContext<T> originalHandler,
             FastHandlerWithContext<T> messageHandler,
             int priority = 0,
@@ -1068,7 +1222,7 @@ namespace DxMessaging.Core
             where T : ITargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration =
+            MessageBusRegistration messageBusDeregistration =
                 messageBus.RegisterTargetedWithoutTargetingPostProcessor<T>(
                     priority: priority,
                     messageHandler: this
@@ -1083,6 +1237,38 @@ namespace DxMessaging.Core
             );
         }
 
+        /// <summary>
+        /// Registers a targeted (without-targeting) post-processor whose
+        /// diagnostics-augmented by-ref context flat invoker was already built by the
+        /// caller (the registration token), so the default slot stores a single closure
+        /// instead of an <see cref="Action{T1, T2}"/> wrapper plus a separately
+        /// allocated FastHandlerWithContext adapter. <paramref name="originalHandler"/>
+        /// stays the dedup/identity key.
+        /// </summary>
+        internal HandlerDeregistration RegisterTargetedWithoutTargetingPostProcessor<T>(
+            Action<InstanceId, T> originalHandler,
+            FastHandlerWithContext<T> flatInvoker,
+            int priority = 0,
+            IMessageBus messageBus = null
+        )
+            where T : ITargetedMessage
+        {
+            messageBus = ResolveMessageBus(messageBus);
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterTargetedWithoutTargetingPostProcessor<T>(
+                    priority: priority,
+                    messageHandler: this
+                );
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.AddTargetedWithoutTargetingPostProcessor(
+                originalHandler,
+                flatInvoker,
+                messageBusDeregistration,
+                priority,
+                messageBus
+            );
+        }
+
         /// <summary>
         /// Registers this MessageHandler to accept TargetedMessages without Targeting via the MessageBus, properly handling deregistration.
         /// </summary>
@@ -1091,7 +1277,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterTargetedWithoutTargeting<T>(
+        internal HandlerDeregistration RegisterTargetedWithoutTargeting<T>(
             Action<InstanceId, T> originalHandler,
             Action<InstanceId, T> messageHandler,
             int priority = 0,
@@ -1100,10 +1286,8 @@ namespace DxMessaging.Core
             where T : ITargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterTargetedWithoutTargeting<T>(
-                this,
-                priority: priority
-            );
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterTargetedWithoutTargeting<T>(this, priority: priority);
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
             return typedHandler.AddTargetedWithoutTargetingHandler(
                 originalHandler,
@@ -1114,6 +1298,35 @@ namespace DxMessaging.Core
             );
         }
 
+        /// <summary>
+        /// Registers a targeted-without-targeting handler whose diagnostics-augmented
+        /// by-ref-with-context flat invoker was already built by the caller, so the
+        /// default slot stores a single closure instead of an
+        /// <see cref="Action{InstanceId, T}"/> wrapper plus a separately allocated
+        /// FastHandlerWithContext adapter. <paramref name="originalHandler"/> stays
+        /// the dedup/identity key.
+        /// </summary>
+        internal HandlerDeregistration RegisterTargetedWithoutTargeting<T>(
+            Action<InstanceId, T> originalHandler,
+            FastHandlerWithContext<T> flatInvoker,
+            int priority = 0,
+            IMessageBus messageBus = null
+        )
+            where T : ITargetedMessage
+        {
+            messageBus = ResolveMessageBus(messageBus);
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterTargetedWithoutTargeting<T>(this, priority: priority);
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.AddTargetedWithoutTargetingHandler(
+                originalHandler,
+                flatInvoker,
+                messageBusDeregistration,
+                priority,
+                messageBus
+            );
+        }
+
         /// <summary>
         /// Registers this MessageHandler to accept fast TargetedMessages without Targeting via the MessageBus, properly handling deregistration.
         /// </summary>
@@ -1122,7 +1335,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterTargetedWithoutTargeting<T>(
+        internal HandlerDeregistration RegisterTargetedWithoutTargeting<T>(
             FastHandlerWithContext<T> originalHandler,
             FastHandlerWithContext<T> messageHandler,
             int priority = 0,
@@ -1131,10 +1344,8 @@ namespace DxMessaging.Core
             where T : ITargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterTargetedWithoutTargeting<T>(
-                this,
-                priority: priority
-            );
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterTargetedWithoutTargeting<T>(this, priority: priority);
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
             return typedHandler.AddTargetedWithoutTargetingHandler(
                 originalHandler,
@@ -1153,7 +1364,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterUntargetedMessageHandler<T>(
+        internal HandlerDeregistration RegisterUntargetedMessageHandler<T>(
             Action<T> originalHandler,
             Action<T> messageHandler,
             int priority = 0,
@@ -1162,7 +1373,7 @@ namespace DxMessaging.Core
             where T : IUntargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterUntargeted<T>(
+            MessageBusRegistration messageBusDeregistration = messageBus.RegisterUntargeted<T>(
                 this,
                 priority: priority
             );
@@ -1176,6 +1387,36 @@ namespace DxMessaging.Core
             );
         }
 
+        /// <summary>
+        /// Registers an untargeted handler whose diagnostics-augmented by-ref flat
+        /// invoker was already built by the caller (the registration token), so the
+        /// default slot stores a single closure instead of an <see cref="Action{T}"/>
+        /// wrapper plus a separately allocated FastHandler adapter.
+        /// <paramref name="originalHandler"/> stays the dedup/identity key.
+        /// </summary>
+        internal HandlerDeregistration RegisterUntargetedMessageHandler<T>(
+            Action<T> originalHandler,
+            FastHandler<T> flatInvoker,
+            int priority = 0,
+            IMessageBus messageBus = null
+        )
+            where T : IUntargetedMessage
+        {
+            messageBus = ResolveMessageBus(messageBus);
+            MessageBusRegistration messageBusDeregistration = messageBus.RegisterUntargeted<T>(
+                this,
+                priority: priority
+            );
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.AddUntargetedHandler(
+                originalHandler,
+                flatInvoker,
+                messageBusDeregistration,
+                priority,
+                messageBus
+            );
+        }
+
         /// <summary>
         /// Registers this MessageHandler to accept fast UntargetedMessages via the MessageBus, properly handling deregistration.
         /// </summary>
@@ -1184,7 +1425,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterUntargetedMessageHandler<T>(
+        internal HandlerDeregistration RegisterUntargetedMessageHandler<T>(
             FastHandler<T> originalHandler,
             FastHandler<T> messageHandler,
             int priority = 0,
@@ -1193,7 +1434,7 @@ namespace DxMessaging.Core
             where T : IUntargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterUntargeted<T>(
+            MessageBusRegistration messageBusDeregistration = messageBus.RegisterUntargeted<T>(
                 this,
                 priority: priority
             );
@@ -1215,7 +1456,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterUntargetedPostProcessor<T>(
+        internal HandlerDeregistration RegisterUntargetedPostProcessor<T>(
             Action<T> originalHandler,
             Action<T> messageHandler,
             int priority = 0,
@@ -1224,10 +1465,11 @@ namespace DxMessaging.Core
             where T : IUntargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterUntargetedPostProcessor<T>(
-                priority: priority,
-                messageHandler: this
-            );
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterUntargetedPostProcessor<T>(
+                    priority: priority,
+                    messageHandler: this
+                );
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
             return typedHandler.AddUntargetedPostProcessor(
                 originalHandler,
@@ -1246,7 +1488,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterUntargetedPostProcessor<T>(
+        internal HandlerDeregistration RegisterUntargetedPostProcessor<T>(
             FastHandler<T> originalHandler,
             FastHandler<T> messageHandler,
             int priority = 0,
@@ -1255,10 +1497,11 @@ namespace DxMessaging.Core
             where T : IUntargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterUntargetedPostProcessor<T>(
-                priority: priority,
-                messageHandler: this
-            );
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterUntargetedPostProcessor<T>(
+                    priority: priority,
+                    messageHandler: this
+                );
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
             return typedHandler.AddUntargetedPostProcessor(
                 originalHandler,
@@ -1278,7 +1521,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterSourcedBroadcastMessageHandler<T>(
+        internal HandlerDeregistration RegisterSourcedBroadcastMessageHandler<T>(
             InstanceId source,
             Action<T> originalHandler,
             Action<T> messageHandler,
@@ -1288,11 +1531,8 @@ namespace DxMessaging.Core
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterSourcedBroadcast<T>(
-                source,
-                this,
-                priority: priority
-            );
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterSourcedBroadcast<T>(source, this, priority: priority);
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
 
             return typedHandler.AddSourcedBroadcastHandler(
@@ -1305,6 +1545,36 @@ namespace DxMessaging.Core
             );
         }
 
+        /// <summary>
+        /// Registers a sourced-broadcast handler whose diagnostics-augmented by-ref
+        /// flat invoker was already built by the caller, so the default slot stores a
+        /// single closure instead of an <see cref="Action{T}"/> wrapper plus a
+        /// separately allocated FastHandler adapter.
+        /// <paramref name="originalHandler"/> stays the dedup/identity key.
+        /// </summary>
+        internal HandlerDeregistration RegisterSourcedBroadcastMessageHandler<T>(
+            InstanceId source,
+            Action<T> originalHandler,
+            FastHandler<T> flatInvoker,
+            int priority = 0,
+            IMessageBus messageBus = null
+        )
+            where T : IBroadcastMessage
+        {
+            messageBus = ResolveMessageBus(messageBus);
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterSourcedBroadcast<T>(source, this, priority: priority);
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.AddSourcedBroadcastHandler(
+                source,
+                originalHandler,
+                flatInvoker,
+                messageBusDeregistration,
+                priority,
+                messageBus
+            );
+        }
+
         /// <summary>
         /// Registers this MessageHandler to accept fast BroadcastMessages via their MessageBus, properly handling deregistration.
         /// </summary>
@@ -1314,7 +1584,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterSourcedBroadcastMessageHandler<T>(
+        internal HandlerDeregistration RegisterSourcedBroadcastMessageHandler<T>(
             InstanceId source,
             FastHandler<T> originalHandler,
             FastHandler<T> messageHandler,
@@ -1324,11 +1594,8 @@ namespace DxMessaging.Core
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterSourcedBroadcast<T>(
-                source,
-                this,
-                priority: priority
-            );
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterSourcedBroadcast<T>(source, this, priority: priority);
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
             return typedHandler.AddSourcedBroadcastHandler(
                 source,
@@ -1348,7 +1615,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterSourcedBroadcastWithoutSource<T>(
+        internal HandlerDeregistration RegisterSourcedBroadcastWithoutSource<T>(
             Action<InstanceId, T> originalHandler,
             Action<InstanceId, T> messageHandler,
             int priority = 0,
@@ -1357,10 +1624,8 @@ namespace DxMessaging.Core
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterSourcedBroadcastWithoutSource<T>(
-                this,
-                priority: priority
-            );
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterSourcedBroadcastWithoutSource<T>(this, priority: priority);
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
             return typedHandler.AddSourcedBroadcastWithoutSourceHandler(
                 originalHandler,
@@ -1371,6 +1636,35 @@ namespace DxMessaging.Core
             );
         }
 
+        /// <summary>
+        /// Registers a broadcast-without-source handler whose diagnostics-augmented
+        /// by-ref-with-context flat invoker was already built by the caller, so the
+        /// default slot stores a single closure instead of an
+        /// <see cref="Action{InstanceId, T}"/> wrapper plus a separately allocated
+        /// FastHandlerWithContext adapter. <paramref name="originalHandler"/> stays
+        /// the dedup/identity key.
+        /// </summary>
+        internal HandlerDeregistration RegisterSourcedBroadcastWithoutSource<T>(
+            Action<InstanceId, T> originalHandler,
+            FastHandlerWithContext<T> flatInvoker,
+            int priority = 0,
+            IMessageBus messageBus = null
+        )
+            where T : IBroadcastMessage
+        {
+            messageBus = ResolveMessageBus(messageBus);
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterSourcedBroadcastWithoutSource<T>(this, priority: priority);
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.AddSourcedBroadcastWithoutSourceHandler(
+                originalHandler,
+                flatInvoker,
+                messageBusDeregistration,
+                priority,
+                messageBus
+            );
+        }
+
         /// <summary>
         /// Registers this MessageHandler to accept fast BroadcastMessage regardless of source via their MessageBus, properly handling deregistration.
         /// </summary>
@@ -1379,7 +1673,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterSourcedBroadcastWithoutSource<T>(
+        internal HandlerDeregistration RegisterSourcedBroadcastWithoutSource<T>(
             FastHandlerWithContext<T> originalHandler,
             FastHandlerWithContext<T> messageHandler,
             int priority = 0,
@@ -1388,10 +1682,8 @@ namespace DxMessaging.Core
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterSourcedBroadcastWithoutSource<T>(
-                this,
-                priority: priority
-            );
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterSourcedBroadcastWithoutSource<T>(this, priority: priority);
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
             return typedHandler.AddSourcedBroadcastWithoutSourceHandler(
                 originalHandler,
@@ -1411,7 +1703,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterSourcedBroadcastPostProcessor<T>(
+        internal HandlerDeregistration RegisterSourcedBroadcastPostProcessor<T>(
             InstanceId source,
             Action<T> originalHandler,
             Action<T> messageHandler,
@@ -1421,11 +1713,12 @@ namespace DxMessaging.Core
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterBroadcastPostProcessor<T>(
-                source,
-                messageHandler: this,
-                priority: priority
-            );
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterBroadcastPostProcessor<T>(
+                    source,
+                    messageHandler: this,
+                    priority: priority
+                );
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
             return typedHandler.AddBroadcastPostProcessor(
                 source,
@@ -1446,7 +1739,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterSourcedBroadcastPostProcessor<T>(
+        internal HandlerDeregistration RegisterSourcedBroadcastPostProcessor<T>(
             InstanceId source,
             FastHandler<T> originalHandler,
             FastHandler<T> messageHandler,
@@ -1456,16 +1749,51 @@ namespace DxMessaging.Core
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterBroadcastPostProcessor<T>(
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterBroadcastPostProcessor<T>(
+                    source,
+                    priority: priority,
+                    messageHandler: this
+                );
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.AddBroadcastPostProcessor(
                 source,
-                priority: priority,
-                messageHandler: this
+                originalHandler,
+                messageHandler,
+                messageBusDeregistration,
+                priority,
+                messageBus
             );
+        }
+
+        /// <summary>
+        /// Registers a sourced-broadcast post-processor whose diagnostics-augmented
+        /// by-ref flat invoker was already built by the caller (the registration
+        /// token), so the default slot stores a single closure instead of an
+        /// <see cref="Action{T}"/> wrapper plus a separately allocated FastHandler
+        /// adapter. <paramref name="originalHandler"/> stays the dedup/identity key.
+        /// </summary>
+        internal HandlerDeregistration RegisterSourcedBroadcastPostProcessor<T>(
+            InstanceId source,
+            Action<T> originalHandler,
+            FastHandler<T> flatInvoker,
+            int priority = 0,
+            IMessageBus messageBus = null
+        )
+            where T : IBroadcastMessage
+        {
+            messageBus = ResolveMessageBus(messageBus);
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterBroadcastPostProcessor<T>(
+                    source,
+                    priority: priority,
+                    messageHandler: this
+                );
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
             return typedHandler.AddBroadcastPostProcessor(
                 source,
                 originalHandler,
-                messageHandler,
+                flatInvoker,
                 messageBusDeregistration,
                 priority,
                 messageBus
@@ -1480,7 +1808,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterSourcedBroadcastWithoutSourcePostProcessor<T>(
+        internal HandlerDeregistration RegisterSourcedBroadcastWithoutSourcePostProcessor<T>(
             Action<InstanceId, T> originalHandler,
             Action<InstanceId, T> messageHandler,
             int priority = 0,
@@ -1489,7 +1817,7 @@ namespace DxMessaging.Core
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration =
+            MessageBusRegistration messageBusDeregistration =
                 messageBus.RegisterBroadcastWithoutSourcePostProcessor<T>(
                     priority: priority,
                     messageHandler: this
@@ -1512,7 +1840,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <param name="messageBus">IMessageBus override to register with, if any. Null/not provided defaults to the GlobalMessageBus.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterSourcedBroadcastWithoutSourcePostProcessor<T>(
+        internal HandlerDeregistration RegisterSourcedBroadcastWithoutSourcePostProcessor<T>(
             FastHandlerWithContext<T> originalHandler,
             FastHandlerWithContext<T> messageHandler,
             int priority = 0,
@@ -1521,7 +1849,39 @@ namespace DxMessaging.Core
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration =
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterBroadcastWithoutSourcePostProcessor<T>(
+                    priority: priority,
+                    messageHandler: this
+                );
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.AddBroadcastWithoutSourcePostProcessor(
+                originalHandler,
+                messageHandler,
+                messageBusDeregistration,
+                priority,
+                messageBus
+            );
+        }
+
+        /// <summary>
+        /// Registers a sourced-broadcast (without-source) post-processor whose
+        /// diagnostics-augmented by-ref context flat invoker was already built by the
+        /// caller (the registration token), so the default slot stores a single closure
+        /// instead of an <see cref="Action{T1, T2}"/> wrapper plus a separately
+        /// allocated FastHandlerWithContext adapter. <paramref name="originalHandler"/>
+        /// stays the dedup/identity key.
+        /// </summary>
+        internal HandlerDeregistration RegisterSourcedBroadcastWithoutSourcePostProcessor<T>(
+            Action<InstanceId, T> originalHandler,
+            FastHandlerWithContext<T> flatInvoker,
+            int priority = 0,
+            IMessageBus messageBus = null
+        )
+            where T : IBroadcastMessage
+        {
+            messageBus = ResolveMessageBus(messageBus);
+            MessageBusRegistration messageBusDeregistration =
                 messageBus.RegisterBroadcastWithoutSourcePostProcessor<T>(
                     priority: priority,
                     messageHandler: this
@@ -1529,7 +1889,7 @@ namespace DxMessaging.Core
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
             return typedHandler.AddBroadcastWithoutSourcePostProcessor(
                 originalHandler,
-                messageHandler,
+                flatInvoker,
                 messageBusDeregistration,
                 priority,
                 messageBus
@@ -1544,7 +1904,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority to register the interceptor at (interceptors are run from low -> high priority)</param>
         /// <param name="messageBus">Message bus to register the interceptor on.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterUntargetedInterceptor<T>(
+        internal HandlerDeregistration RegisterUntargetedInterceptor<T>(
             IMessageBus.UntargetedInterceptor<T> interceptor,
             int priority = 0,
             IMessageBus messageBus = null
@@ -1552,7 +1912,11 @@ namespace DxMessaging.Core
             where T : IUntargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            return messageBus.RegisterUntargetedInterceptor(interceptor, priority);
+            MessageBusRegistration registration = messageBus.RegisterUntargetedInterceptor(
+                interceptor,
+                priority
+            );
+            return new InterceptorDeregistration<T>(messageBus, in registration);
         }
 
         /// <summary>
@@ -1563,7 +1927,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority to register the interceptor at (interceptors are run from low -> high priority)</param>
         /// <param name="messageBus">Message bus to register the interceptor on.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterBroadcastInterceptor<T>(
+        internal HandlerDeregistration RegisterBroadcastInterceptor<T>(
             IMessageBus.BroadcastInterceptor<T> interceptor,
             int priority = 0,
             IMessageBus messageBus = null
@@ -1571,7 +1935,11 @@ namespace DxMessaging.Core
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            return messageBus.RegisterBroadcastInterceptor(interceptor, priority);
+            MessageBusRegistration registration = messageBus.RegisterBroadcastInterceptor(
+                interceptor,
+                priority
+            );
+            return new InterceptorDeregistration<T>(messageBus, in registration);
         }
 
         /// <summary>
@@ -1582,7 +1950,7 @@ namespace DxMessaging.Core
         /// <param name="priority">Priority to register the interceptor at (interceptors are run from low -> high priority)</param>
         /// <param name="messageBus">Message bus to register the interceptor on.</param>
         /// <returns>The de-registration action.</returns>
-        public Action RegisterTargetedInterceptor<T>(
+        internal HandlerDeregistration RegisterTargetedInterceptor<T>(
             IMessageBus.TargetedInterceptor<T> interceptor,
             int priority = 0,
             IMessageBus messageBus = null
@@ -1590,7 +1958,11 @@ namespace DxMessaging.Core
             where T : ITargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            return messageBus.RegisterTargetedInterceptor(interceptor, priority);
+            MessageBusRegistration registration = messageBus.RegisterTargetedInterceptor(
+                interceptor,
+                priority
+            );
+            return new InterceptorDeregistration<T>(messageBus, in registration);
         }
 
         /// <summary>
@@ -2136,6 +2508,12 @@ namespace DxMessaging.Core
                 // post-processor siblings). The type test doubles as a null
                 // guard; a missing adapter would indicate a new registration
                 // path that forgot to provide one.
+                //
+                // INVARIANT: default-slot dispatch consumes entry.flatInvoker.
+                // entry.handler is not a safe dispatch target because
+                // diagnostics-folding Add* overloads may store the raw user
+                // Action there as the identity key. The legacy Handle*/RunHandlers
+                // path uses GetOrAddNewFlatInvokerStack for the same reason.
                 if (entry.flatInvoker is FastHandler<T> invoker)
                 {
                     target[writeIndex++] = new FlatDispatchEntry<T>(this, invoker);
@@ -2273,20 +2651,32 @@ namespace DxMessaging.Core
                     this.flatInvoker = flatInvoker;
                 }
 
+                // The stored handler delegate. For default Action<TMessage>
+                // slots this is the dedup/refcount delegate and is not the
+                // dispatch target; both bus-side flat dispatch and legacy
+                // Handle*/RunHandlers dispatch go through `flatInvoker`.
+                // Registration paths that pre-build the augmented invoker store
+                // the RAW user handler here (so no extra augmented Action wrapper
+                // is allocated); paths that adapt at registration time store the
+                // augmented handler. For fast/global slots, by contrast,
+                // `handler` IS the dispatched delegate.
                 public readonly T handler;
                 public readonly int count;
 
-                // Pre-resolved invoker consumed by the bus-side flat dispatch
-                // snapshot (MessageBus.BuildMessageFlatDispatch). For
-                // default Action<TMessage> registrations this holds a
-                // FastHandler<TMessage> adapter wrapping the AUGMENTED
-                // handler, created exactly ONCE at registration time so
-                // snapshot rebuilds never allocate closures. For delegate
-                // shapes the flat path does not consume (fast handlers, which
-                // already ARE the invoker, and every targeted/broadcast
-                // shape) this stays null. Refcount increments and decrements
+                // Pre-resolved invoker consumed by bus-side flat dispatch
+                // snapshots and legacy default-slot Handle*/RunHandlers
+                // snapshots. For default Action<TMessage> registrations this holds the
+                // diagnostics-AUGMENTED FastHandler<TMessage> closure (either a
+                // standalone adapter wrapping an augmented Action, or the single
+                // folded augmented closure the registration token now builds
+                // directly), created exactly ONCE at registration time so
+                // snapshot rebuilds never allocate closures. It -- not
+                // `handler` -- is the dispatch target for default slots.
+                // For delegate shapes the flat path does not consume (fast
+                // handlers, which already ARE the invoker, and global accept-all
+                // shapes) this stays null. Refcount increments and decrements
                 // preserve the first registration's invoker, mirroring the
-                // first-augmented-handler-wins semantics of `handler`.
+                // first-registration-wins semantics of `handler`.
                 public readonly object flatInvoker;
             }
 
@@ -2304,9 +2694,12 @@ namespace DxMessaging.Core
             // <see cref="DxMessaging.Core.Internal.IHandlerActionCache.Reset"/>.
             public readonly List<T> insertionOrder = new();
             public readonly List<T> cache = new();
+            private System.Collections.IList _flatInvokerCache;
             public long version;
             public long lastSeenVersion = -1;
             public long lastSeenEmissionId = -1;
+            public long flatInvokerLastSeenVersion = -1;
+            public long flatInvokerLastSeenEmissionId = -1;
 
             /// <summary>Monotonic version field, read-only on the interface surface.</summary>
             long DxMessaging.Core.Internal.IHandlerActionCache.Version
@@ -2349,13 +2742,77 @@ namespace DxMessaging.Core
                 entries.Clear();
                 insertionOrder.Clear();
                 cache.Clear();
+                _flatInvokerCache?.Clear();
                 lastSeenVersion = -1;
                 lastSeenEmissionId = -1;
+                flatInvokerLastSeenVersion = -1;
+                flatInvokerLastSeenEmissionId = -1;
                 unchecked
                 {
                     ++version;
                 }
             }
+
+            /// <summary>
+            /// Non-generic membership probe; casts the boxed key to the
+            /// cache's delegate shape. Mirrors
+            /// <c>entries.ContainsKey(originalHandler)</c>.
+            /// </summary>
+            bool DxMessaging.Core.Internal.IHandlerActionCache.ContainsEntry(object originalHandler)
+            {
+                return entries.ContainsKey((T)originalHandler);
+            }
+
+            /// <summary>Bumps <see cref="version"/> by one (the closure's top-of-body <c>version++</c>).</summary>
+            void DxMessaging.Core.Internal.IHandlerActionCache.BumpVersion()
+            {
+                version++;
+            }
+
+            /// <summary>
+            /// Non-generic decrement-or-remove mirroring the legacy
+            /// deregistration closure's refcount logic exactly.
+            /// </summary>
+            bool DxMessaging.Core.Internal.IHandlerActionCache.DeregisterEntry(
+                object originalHandler,
+                out bool wasLastForEntry
+            )
+            {
+                wasLastForEntry = false;
+                T key = (T)originalHandler;
+                if (!entries.TryGetValue(key, out Entry entry))
+                {
+                    return false;
+                }
+
+                if (entry.count <= 1)
+                {
+                    _ = entries.Remove(key);
+                    // List.Remove is O(n) over the same-priority bucket;
+                    // accepted (see AddHandlerPreservingPriorityKey).
+                    _ = insertionOrder.Remove(key);
+                    version++;
+                    wasLastForEntry = true;
+                    return true;
+                }
+
+                entries[key] = new Entry(entry.handler, entry.count - 1, entry.flatInvoker);
+                return true;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal List<TInvoker> GetOrCreateFlatInvokerCache<TInvoker>()
+                where TInvoker : class
+            {
+                if (_flatInvokerCache == null)
+                {
+                    List<TInvoker> typedCache = new();
+                    _flatInvokerCache = typedCache;
+                    return typedCache;
+                }
+
+                return (List<TInvoker>)_flatInvokerCache;
+            }
         }
 
         /// <summary>
@@ -2386,6 +2843,161 @@ namespace DxMessaging.Core
 
             internal bool _markedForOuterRemoval;
 
+            /// <summary>
+            /// Per-handle teardown object for the typed-handler registration
+            /// path, replacing the deregistration <see cref="Action"/> closure
+            /// the two instance <c>AddHandlerPreservingPriorityKey</c> overloads
+            /// used to build and return. All of the closure's captured locals
+            /// are stored as fields; <see cref="Deregister"/> re-expresses the
+            /// closure body verbatim, choosing the scalar or context cache
+            /// resolution by <see cref="_keyed"/> and using the non-generic
+            /// <see cref="IHandlerActionCache"/> teardown ops
+            /// (<c>ContainsEntry</c> / <c>BumpVersion</c> / <c>DeregisterEntry</c>)
+            /// so it needs no delegate-shape type argument.
+            /// </summary>
+            internal sealed class TypedHandlerDeregistration : HandlerDeregistration
+            {
+                // Captured state (was the closure's captures).
+                private readonly IMessageBus _messageBus;
+                private readonly long _resetGeneration;
+                private readonly TypedSlot<T> _slot;
+                private readonly long _slotVersion;
+
+                // Scalar path: priority -> cache. Null on the context path.
+                private readonly Dictionary<int, IHandlerActionCache> _handlers;
+
+                // Context path: context -> (priority -> cache). Null on the scalar path.
+                private readonly Dictionary<
+                    InstanceId,
+                    Dictionary<int, IHandlerActionCache>
+                > _handlersByContext;
+                private readonly InstanceId _context;
+
+                private readonly bool _keyed;
+                private readonly object _originalHandler;
+                private readonly int _priority;
+                private readonly MessageBusRegistration _busRegistration;
+
+                // Scalar constructor.
+                internal TypedHandlerDeregistration(
+                    IMessageBus messageBus,
+                    long resetGeneration,
+                    TypedSlot<T> slot,
+                    long slotVersion,
+                    Dictionary<int, IHandlerActionCache> handlers,
+                    object originalHandler,
+                    int priority,
+                    in MessageBusRegistration busRegistration
+                )
+                {
+                    _messageBus = messageBus;
+                    _resetGeneration = resetGeneration;
+                    _slot = slot;
+                    _slotVersion = slotVersion;
+                    _handlers = handlers;
+                    _handlersByContext = null;
+                    _context = default;
+                    _keyed = false;
+                    _originalHandler = originalHandler;
+                    _priority = priority;
+                    _busRegistration = busRegistration;
+                }
+
+                // Context constructor.
+                internal TypedHandlerDeregistration(
+                    IMessageBus messageBus,
+                    long resetGeneration,
+                    TypedSlot<T> slot,
+                    long slotVersion,
+                    Dictionary<InstanceId, Dictionary<int, IHandlerActionCache>> handlersByContext,
+                    InstanceId context,
+                    object originalHandler,
+                    int priority,
+                    in MessageBusRegistration busRegistration
+                )
+                {
+                    _messageBus = messageBus;
+                    _resetGeneration = resetGeneration;
+                    _slot = slot;
+                    _slotVersion = slotVersion;
+                    _handlers = null;
+                    _handlersByContext = handlersByContext;
+                    _context = context;
+                    _keyed = true;
+                    _originalHandler = originalHandler;
+                    _priority = priority;
+                    _busRegistration = busRegistration;
+                }
+
+                internal override void Deregister()
+                {
+                    if (
+                        !global::DxMessaging.Core.MessageBus.MessageBus.IsResetGenerationCurrent(
+                            _messageBus,
+                            _resetGeneration
+                        )
+                    )
+                    {
+                        return;
+                    }
+
+                    if (_slot != null && _slot.version != _slotVersion)
+                    {
+                        return;
+                    }
+
+                    IHandlerActionCache cache;
+                    if (_keyed)
+                    {
+                        if (
+                            !_handlersByContext.TryGetValue(
+                                _context,
+                                out Dictionary<int, IHandlerActionCache> sortedHandlers
+                            )
+                        )
+                        {
+                            return;
+                        }
+
+                        if (!sortedHandlers.TryGetValue(_priority, out cache) || cache == null)
+                        {
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        if (!_handlers.TryGetValue(_priority, out cache) || cache == null)
+                        {
+                            return;
+                        }
+                    }
+
+                    if (!cache.ContainsEntry(_originalHandler))
+                    {
+                        return;
+                    }
+
+                    cache.BumpVersion();
+
+                    _messageBus.Deregister<T>(in _busRegistration);
+                    if (_slot != null)
+                    {
+                        _slot.lastTouchTicks =
+                            global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(
+                                _messageBus
+                            );
+                    }
+
+                    _ = cache.DeregisterEntry(_originalHandler, out bool wasLastForEntry);
+                    if (wasLastForEntry && _slot != null)
+                    {
+                        _slot.liveCount--;
+                    }
+                    // Deliberately keep the priority and context mappings to
+                    // preserve frozen snapshots for the current emission.
+                }
+            }
+
             int ITypedHandlerSlotSweeper.MessageTypeIndex
             {
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -3137,11 +3749,11 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddTargetedHandler(
+            public HandlerDeregistration AddTargetedHandler(
                 InstanceId target,
                 Action<T> originalHandler,
                 Action<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3162,6 +3774,35 @@ namespace DxMessaging.Core
                 );
             }
 
+            /// <summary>
+            /// Adds a TargetedHandler whose by-ref flat invoker was already built
+            /// by the caller, so the default slot stores a single closure instead
+            /// of an <see cref="Action{T}"/> wrapper plus a separately allocated
+            /// FastHandler adapter (the registration token folds diagnostics into
+            /// one <see cref="FastHandler{T}"/>). <paramref name="originalHandler"/>
+            /// is the dedup/identity key and is never invoked for the default slot.
+            /// </summary>
+            internal HandlerDeregistration AddTargetedHandler(
+                InstanceId target,
+                Action<T> originalHandler,
+                FastHandler<T> flatInvoker,
+                MessageBusRegistration deregistration,
+                int priority,
+                IMessageBus messageBus
+            )
+            {
+                return AddHandlerPreservingPriorityKey(
+                    target,
+                    GetOrCreateContextHandlers(TypedSlotIndex.TargetedHandleDefault),
+                    originalHandler,
+                    originalHandler,
+                    deregistration,
+                    priority,
+                    messageBus,
+                    flatInvoker
+                );
+            }
+
             /// <summary>
             /// Adds a fast TargetedHandler to listen to Messages of the given type, returning a deregistration action.
             /// </summary>
@@ -3170,11 +3811,11 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddTargetedHandler(
+            public HandlerDeregistration AddTargetedHandler(
                 InstanceId target,
                 FastHandler<T> originalHandler,
                 FastHandler<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3197,10 +3838,10 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddTargetedWithoutTargetingHandler(
+            public HandlerDeregistration AddTargetedWithoutTargetingHandler(
                 Action<InstanceId, T> originalHandler,
                 Action<InstanceId, T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3225,6 +3866,36 @@ namespace DxMessaging.Core
                 );
             }
 
+            /// <summary>
+            /// Adds a TargetedWithoutTargetingHandler whose by-ref-with-context flat
+            /// invoker was already built by the caller, so the default slot stores a
+            /// single closure instead of an <see cref="Action{InstanceId, T}"/>
+            /// wrapper plus a separately allocated FastHandlerWithContext adapter.
+            /// <paramref name="originalHandler"/> is the dedup/identity key and is
+            /// never invoked for the default slot.
+            /// </summary>
+            internal HandlerDeregistration AddTargetedWithoutTargetingHandler(
+                Action<InstanceId, T> originalHandler,
+                FastHandlerWithContext<T> flatInvoker,
+                MessageBusRegistration deregistration,
+                int priority,
+                IMessageBus messageBus
+            )
+            {
+                return AddHandlerPreservingPriorityKey(
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.TargetedHandleWithoutContext,
+                        requiresContext: false
+                    ),
+                    originalHandler,
+                    originalHandler,
+                    deregistration,
+                    priority,
+                    messageBus,
+                    flatInvoker
+                );
+            }
+
             /// <summary>
             /// Adds a fast TargetedWithoutTargetingHandler to listen to Messages of the given type, returning a deregistration action.
             /// </summary>
@@ -3232,10 +3903,10 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddTargetedWithoutTargetingHandler(
+            public HandlerDeregistration AddTargetedWithoutTargetingHandler(
                 FastHandlerWithContext<T> originalHandler,
                 FastHandlerWithContext<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3260,10 +3931,10 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddUntargetedHandler(
+            public HandlerDeregistration AddUntargetedHandler(
                 Action<T> originalHandler,
                 Action<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3286,6 +3957,38 @@ namespace DxMessaging.Core
                 );
             }
 
+            /// <summary>
+            /// Adds an UntargetedHandler whose by-ref flat invoker was already
+            /// built by the caller, so the default slot stores a single closure
+            /// instead of an <see cref="Action{T}"/> wrapper plus a separately
+            /// allocated FastHandler adapter. The registration token uses this to
+            /// fold diagnostics into one <see cref="FastHandler{T}"/>.
+            /// <paramref name="originalHandler"/> is the dedup/identity key; it is
+            /// stored as the entry handler but is never invoked for the default
+            /// slot, which dispatches through <paramref name="flatInvoker"/>.
+            /// </summary>
+            internal HandlerDeregistration AddUntargetedHandler(
+                Action<T> originalHandler,
+                FastHandler<T> flatInvoker,
+                MessageBusRegistration deregistration,
+                int priority,
+                IMessageBus messageBus
+            )
+            {
+                return AddHandlerPreservingPriorityKey(
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.UntargetedHandleDefault,
+                        requiresContext: false
+                    ),
+                    originalHandler,
+                    originalHandler,
+                    deregistration,
+                    priority,
+                    messageBus,
+                    flatInvoker
+                );
+            }
+
             /// <summary>
             /// Adds a fast UntargetedHandler to listen to Messages of the given type, returning a deregistration action.
             /// </summary>
@@ -3293,10 +3996,10 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddUntargetedHandler(
+            public HandlerDeregistration AddUntargetedHandler(
                 FastHandler<T> originalHandler,
                 FastHandler<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3322,11 +4025,11 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddSourcedBroadcastHandler(
+            public HandlerDeregistration AddSourcedBroadcastHandler(
                 InstanceId source,
                 Action<T> originalHandler,
                 Action<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3347,6 +4050,34 @@ namespace DxMessaging.Core
                 );
             }
 
+            /// <summary>
+            /// Adds a SourcedBroadcastHandler whose by-ref flat invoker was already
+            /// built by the caller, so the default slot stores a single closure
+            /// instead of an <see cref="Action{T}"/> wrapper plus a separately
+            /// allocated FastHandler adapter. <paramref name="originalHandler"/> is
+            /// the dedup/identity key and is never invoked for the default slot.
+            /// </summary>
+            internal HandlerDeregistration AddSourcedBroadcastHandler(
+                InstanceId source,
+                Action<T> originalHandler,
+                FastHandler<T> flatInvoker,
+                MessageBusRegistration deregistration,
+                int priority,
+                IMessageBus messageBus
+            )
+            {
+                return AddHandlerPreservingPriorityKey(
+                    source,
+                    GetOrCreateContextHandlers(TypedSlotIndex.BroadcastHandleDefault),
+                    originalHandler,
+                    originalHandler,
+                    deregistration,
+                    priority,
+                    messageBus,
+                    flatInvoker
+                );
+            }
+
             /// <summary>
             /// Adds a fast SourcedBroadcastHandler to listen to Messages of the given type from an entity, returning a deregistration action.
             /// </summary>
@@ -3355,11 +4086,11 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddSourcedBroadcastHandler(
+            public HandlerDeregistration AddSourcedBroadcastHandler(
                 InstanceId source,
                 FastHandler<T> originalHandler,
                 FastHandler<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3382,10 +4113,10 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddSourcedBroadcastWithoutSourceHandler(
+            public HandlerDeregistration AddSourcedBroadcastWithoutSourceHandler(
                 Action<InstanceId, T> originalHandler,
                 Action<InstanceId, T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3411,6 +4142,37 @@ namespace DxMessaging.Core
                 );
             }
 
+            /// <summary>
+            /// Adds a SourcedBroadcastWithoutSourceHandler whose by-ref-with-context
+            /// flat invoker was already built by the caller, so the default slot
+            /// stores a single closure instead of an
+            /// <see cref="Action{InstanceId, T}"/> wrapper plus a separately
+            /// allocated FastHandlerWithContext adapter.
+            /// <paramref name="originalHandler"/> is the dedup/identity key and is
+            /// never invoked for the default slot.
+            /// </summary>
+            internal HandlerDeregistration AddSourcedBroadcastWithoutSourceHandler(
+                Action<InstanceId, T> originalHandler,
+                FastHandlerWithContext<T> flatInvoker,
+                MessageBusRegistration deregistration,
+                int priority,
+                IMessageBus messageBus
+            )
+            {
+                return AddHandlerPreservingPriorityKey(
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.BroadcastHandleWithoutContext,
+                        requiresContext: false
+                    ),
+                    originalHandler,
+                    originalHandler,
+                    deregistration,
+                    priority,
+                    messageBus,
+                    flatInvoker
+                );
+            }
+
             /// <summary>
             /// Adds a fast SourcedBroadcastWithoutSourceHandler to listen to Messages of the given type from an entity, returning a deregistration action.
             /// </summary>
@@ -3418,10 +4180,10 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddSourcedBroadcastWithoutSourceHandler(
+            public HandlerDeregistration AddSourcedBroadcastWithoutSourceHandler(
                 FastHandlerWithContext<T> originalHandler,
                 FastHandlerWithContext<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3579,10 +4341,10 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddUntargetedPostProcessor(
+            public HandlerDeregistration AddUntargetedPostProcessor(
                 Action<T> originalHandler,
                 Action<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3612,10 +4374,10 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddUntargetedPostProcessor(
+            public HandlerDeregistration AddUntargetedPostProcessor(
                 FastHandler<T> originalHandler,
                 FastHandler<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3641,11 +4403,11 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddTargetedPostProcessor(
+            public HandlerDeregistration AddTargetedPostProcessor(
                 InstanceId target,
                 Action<T> originalHandler,
                 Action<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3666,6 +4428,35 @@ namespace DxMessaging.Core
                 );
             }
 
+            /// <summary>
+            /// Adds a Targeted post-processor whose by-ref flat invoker was already
+            /// built by the caller (the registration token folds diagnostics into one
+            /// <see cref="FastHandler{T}"/>), so the default slot stores a single
+            /// closure instead of an <see cref="Action{T}"/> wrapper plus a separately
+            /// allocated FastHandler adapter. <paramref name="originalHandler"/> is the
+            /// dedup/identity key and is never invoked for the default slot.
+            /// </summary>
+            internal HandlerDeregistration AddTargetedPostProcessor(
+                InstanceId target,
+                Action<T> originalHandler,
+                FastHandler<T> flatInvoker,
+                MessageBusRegistration deregistration,
+                int priority,
+                IMessageBus messageBus
+            )
+            {
+                return AddHandlerPreservingPriorityKey(
+                    target,
+                    GetOrCreateContextHandlers(TypedSlotIndex.TargetedPostProcessDefault),
+                    originalHandler,
+                    originalHandler,
+                    deregistration,
+                    priority,
+                    messageBus,
+                    flatInvoker
+                );
+            }
+
             /// <summary>
             /// Adds a Targeted post-processor to be called after all other handlers have been called.
             /// </summary>
@@ -3674,11 +4465,11 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddTargetedPostProcessor(
+            public HandlerDeregistration AddTargetedPostProcessor(
                 InstanceId target,
                 FastHandler<T> originalHandler,
                 FastHandler<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3701,10 +4492,10 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddTargetedWithoutTargetingPostProcessor(
+            public HandlerDeregistration AddTargetedWithoutTargetingPostProcessor(
                 Action<InstanceId, T> originalHandler,
                 Action<InstanceId, T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3721,7 +4512,39 @@ namespace DxMessaging.Core
                         requiresContext: false
                     ),
                     originalHandler,
-                    handler,
+                    handler,
+                    deregistration,
+                    priority,
+                    messageBus,
+                    flatInvoker
+                );
+            }
+
+            /// <summary>
+            /// Adds a Targeted (without-targeting) post-processor whose by-ref
+            /// context flat invoker was already built by the caller (the registration
+            /// token folds diagnostics into one
+            /// <see cref="FastHandlerWithContext{T}"/>), so the default slot stores a
+            /// single closure instead of an <see cref="Action{T1, T2}"/> wrapper plus a
+            /// separately allocated FastHandlerWithContext adapter.
+            /// <paramref name="originalHandler"/> is the dedup/identity key and is never
+            /// invoked for the default slot.
+            /// </summary>
+            internal HandlerDeregistration AddTargetedWithoutTargetingPostProcessor(
+                Action<InstanceId, T> originalHandler,
+                FastHandlerWithContext<T> flatInvoker,
+                MessageBusRegistration deregistration,
+                int priority,
+                IMessageBus messageBus
+            )
+            {
+                return AddHandlerPreservingPriorityKey(
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.TargetedPostProcessWithoutContext,
+                        requiresContext: false
+                    ),
+                    originalHandler,
+                    originalHandler,
                     deregistration,
                     priority,
                     messageBus,
@@ -3736,10 +4559,10 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddTargetedWithoutTargetingPostProcessor(
+            public HandlerDeregistration AddTargetedWithoutTargetingPostProcessor(
                 FastHandlerWithContext<T> originalHandler,
                 FastHandlerWithContext<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3765,11 +4588,11 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddBroadcastPostProcessor(
+            public HandlerDeregistration AddBroadcastPostProcessor(
                 InstanceId source,
                 Action<T> originalHandler,
                 Action<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3790,6 +4613,35 @@ namespace DxMessaging.Core
                 );
             }
 
+            /// <summary>
+            /// Adds a Broadcast post-processor whose by-ref flat invoker was already
+            /// built by the caller (the registration token folds diagnostics into one
+            /// <see cref="FastHandler{T}"/>), so the default slot stores a single
+            /// closure instead of an <see cref="Action{T}"/> wrapper plus a separately
+            /// allocated FastHandler adapter. <paramref name="originalHandler"/> is the
+            /// dedup/identity key and is never invoked for the default slot.
+            /// </summary>
+            internal HandlerDeregistration AddBroadcastPostProcessor(
+                InstanceId source,
+                Action<T> originalHandler,
+                FastHandler<T> flatInvoker,
+                MessageBusRegistration deregistration,
+                int priority,
+                IMessageBus messageBus
+            )
+            {
+                return AddHandlerPreservingPriorityKey(
+                    source,
+                    GetOrCreateContextHandlers(TypedSlotIndex.BroadcastPostProcessDefault),
+                    originalHandler,
+                    originalHandler,
+                    deregistration,
+                    priority,
+                    messageBus,
+                    flatInvoker
+                );
+            }
+
             /// <summary>
             /// Adds a fast Broadcast post-processor to be called after all other handlers have been called.
             /// </summary>
@@ -3798,11 +4650,11 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddBroadcastPostProcessor(
+            public HandlerDeregistration AddBroadcastPostProcessor(
                 InstanceId source,
                 FastHandler<T> originalHandler,
                 FastHandler<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3825,10 +4677,10 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddBroadcastWithoutSourcePostProcessor(
+            public HandlerDeregistration AddBroadcastWithoutSourcePostProcessor(
                 Action<InstanceId, T> originalHandler,
                 Action<InstanceId, T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3853,6 +4705,37 @@ namespace DxMessaging.Core
                 );
             }
 
+            /// <summary>
+            /// Adds a Broadcast (without-source) post-processor whose by-ref context
+            /// flat invoker was already built by the caller (the registration token
+            /// folds diagnostics into one <see cref="FastHandlerWithContext{T}"/>), so
+            /// the default slot stores a single closure instead of an
+            /// <see cref="Action{T1, T2}"/> wrapper plus a separately allocated
+            /// FastHandlerWithContext adapter. <paramref name="originalHandler"/> is the
+            /// dedup/identity key and is never invoked for the default slot.
+            /// </summary>
+            internal HandlerDeregistration AddBroadcastWithoutSourcePostProcessor(
+                Action<InstanceId, T> originalHandler,
+                FastHandlerWithContext<T> flatInvoker,
+                MessageBusRegistration deregistration,
+                int priority,
+                IMessageBus messageBus
+            )
+            {
+                return AddHandlerPreservingPriorityKey(
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.BroadcastPostProcessWithoutContext,
+                        requiresContext: false
+                    ),
+                    originalHandler,
+                    originalHandler,
+                    deregistration,
+                    priority,
+                    messageBus,
+                    flatInvoker
+                );
+            }
+
             /// <summary>
             /// Adds a fast Broadcast post-processor to be called after all other handlers have been called.
             /// </summary>
@@ -3860,10 +4743,10 @@ namespace DxMessaging.Core
             /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <param name="priority">Priority at which to add the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddBroadcastWithoutSourcePostProcessor(
+            public HandlerDeregistration AddBroadcastWithoutSourcePostProcessor(
                 FastHandlerWithContext<T> originalHandler,
                 FastHandlerWithContext<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3900,12 +4783,12 @@ namespace DxMessaging.Core
             // default-shape registrations the bus-side flat snapshot consumes
             // (FastHandler adapter wrapping the augmented handler); see
             // HandlerActionCache.Entry.flatInvoker.
-            private Action AddHandlerPreservingPriorityKey<TU>(
+            private HandlerDeregistration AddHandlerPreservingPriorityKey<TU>(
                 InstanceId context,
                 Dictionary<InstanceId, Dictionary<int, IHandlerActionCache>> handlersByContext,
                 TU originalHandler,
                 TU augmentedHandler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus,
                 object flatInvoker = null
@@ -3969,98 +4852,28 @@ namespace DxMessaging.Core
                     slot.liveCount++;
                 }
 
-                Dictionary<
-                    InstanceId,
-                    Dictionary<int, IHandlerActionCache>
-                > localHandlersByContext = handlersByContext;
-                TypedSlot<T> localSlot = slot;
                 long localSlotVersion = slot?.version ?? 0;
                 long localResetGeneration =
                     global::DxMessaging.Core.MessageBus.MessageBus.GetResetGeneration(messageBus);
 
-                return () =>
-                {
-                    if (
-                        !global::DxMessaging.Core.MessageBus.MessageBus.IsResetGenerationCurrent(
-                            messageBus,
-                            localResetGeneration
-                        )
-                    )
-                    {
-                        return;
-                    }
-
-                    if (localSlot != null && localSlot.version != localSlotVersion)
-                    {
-                        return;
-                    }
-
-                    if (!localHandlersByContext.TryGetValue(context, out sortedHandlers))
-                    {
-                        return;
-                    }
-
-                    if (
-                        !sortedHandlers.TryGetValue(
-                            priority,
-                            out IHandlerActionCache localErasedCache
-                        ) || localErasedCache is not HandlerActionCache<TU> localCache
-                    )
-                    {
-                        return;
-                    }
-
-                    if (
-                        !localCache.entries.TryGetValue(
-                            originalHandler,
-                            out HandlerActionCache<TU>.Entry localEntry
-                        )
-                    )
-                    {
-                        return;
-                    }
-
-                    localCache.version++;
-
-                    deregistration?.Invoke();
-                    if (localSlot != null)
-                    {
-                        localSlot.lastTouchTicks =
-                            global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(
-                                messageBus
-                            );
-                    }
-
-                    if (localEntry.count <= 1)
-                    {
-                        _ = localCache.entries.Remove(originalHandler);
-                        // List.Remove is O(n) over the same-priority bucket.
-                        // Accepted tradeoff (here and at every sibling
-                        // deregistration site): buckets are small in practice,
-                        // removal is a cold churn path, and the list keeps
-                        // steady-state dispatch allocation-free while
-                        // preserving first-registration order, unlike
-                        // Dictionary enumeration whose freed slots are reused
-                        // LIFO.
-                        _ = localCache.insertionOrder.Remove(originalHandler);
-                        localCache.version++;
-                        if (localSlot != null)
-                        {
-                            localSlot.liveCount--;
-                        }
-                        // Deliberately keep the priority and context mappings to preserve
-                        // frozen snapshots for the current emission.
-                        return;
-                    }
-
-                    localEntry = new HandlerActionCache<TU>.Entry(
-                        localEntry.handler,
-                        localEntry.count - 1,
-                        localEntry.flatInvoker
-                    );
-
-                    localCache.entries[originalHandler] = localEntry;
-                };
+                // The per-handle teardown object re-expresses the old
+                // deregistration closure verbatim (generation + slot-version
+                // guards, cache resolution, version bumps, refcount
+                // decrement-or-remove, liveCount, keep-key-during-emission)
+                // using the non-generic IHandlerActionCache teardown ops, so it
+                // carries no TU type argument and replaces the closure's display
+                // class + delegate with this single object.
+                return new TypedHandlerDeregistration(
+                    messageBus,
+                    localResetGeneration,
+                    slot,
+                    localSlotVersion,
+                    handlersByContext,
+                    context,
+                    originalHandler,
+                    priority,
+                    in deregistration
+                );
             }
 
             private static Action AddHandlerPreservingPriorityKey<TU>(
@@ -4946,91 +5759,94 @@ namespace DxMessaging.Core
                     return;
                 }
 
-                List<Action<T>> handlers = GetOrAddNewHandlerStack(cache, emissionId);
+                List<FastHandler<T>> handlers = GetOrAddNewFlatInvokerStack<
+                    Action<T>,
+                    FastHandler<T>
+                >(cache, emissionId);
                 ref T typedMessage = ref DxUnsafe.As<TMessage, T>(ref message);
                 int handlersCount = handlers.Count;
                 switch (handlersCount)
                 {
                     case 1:
                     {
-                        handlers[0](typedMessage);
+                        handlers[0](ref typedMessage);
                         return;
                     }
                     case 2:
                     {
-                        handlers[0](typedMessage);
+                        handlers[0](ref typedMessage);
                         if (handlers.Count < 2)
                         {
                             return;
                         }
-                        handlers[1](typedMessage);
+                        handlers[1](ref typedMessage);
                         return;
                     }
                     case 3:
                     {
-                        handlers[0](typedMessage);
+                        handlers[0](ref typedMessage);
                         if (handlers.Count < 2)
                         {
                             return;
                         }
-                        handlers[1](typedMessage);
+                        handlers[1](ref typedMessage);
                         if (handlers.Count < 3)
                         {
                             return;
                         }
-                        handlers[2](typedMessage);
+                        handlers[2](ref typedMessage);
                         return;
                     }
                     case 4:
                     {
-                        handlers[0](typedMessage);
+                        handlers[0](ref typedMessage);
                         if (handlers.Count < 2)
                         {
                             return;
                         }
-                        handlers[1](typedMessage);
+                        handlers[1](ref typedMessage);
                         if (handlers.Count < 3)
                         {
                             return;
                         }
-                        handlers[2](typedMessage);
+                        handlers[2](ref typedMessage);
                         if (handlers.Count < 4)
                         {
                             return;
                         }
-                        handlers[3](typedMessage);
+                        handlers[3](ref typedMessage);
                         return;
                     }
                     case 5:
                     {
-                        handlers[0](typedMessage);
+                        handlers[0](ref typedMessage);
                         if (handlers.Count < 2)
                         {
                             return;
                         }
-                        handlers[1](typedMessage);
+                        handlers[1](ref typedMessage);
                         if (handlers.Count < 3)
                         {
                             return;
                         }
-                        handlers[2](typedMessage);
+                        handlers[2](ref typedMessage);
                         if (handlers.Count < 4)
                         {
                             return;
                         }
-                        handlers[3](typedMessage);
+                        handlers[3](ref typedMessage);
                         if (handlers.Count < 5)
                         {
                             return;
                         }
-                        handlers[4](typedMessage);
+                        handlers[4](ref typedMessage);
                         return;
                     }
                 }
 
                 for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                 {
-                    handlers[i](typedMessage);
+                    handlers[i](ref typedMessage);
                 }
             }
 
@@ -5052,91 +5868,94 @@ namespace DxMessaging.Core
                     return;
                 }
 
-                List<Action<T>> handlers = GetOrAddNewHandlerStack(cache, emissionId);
+                List<FastHandler<T>> handlers = GetOrAddNewFlatInvokerStack<
+                    Action<T>,
+                    FastHandler<T>
+                >(cache, emissionId);
                 ref T typedMessage = ref DxUnsafe.As<TMessage, T>(ref message);
                 int handlersCount = handlers.Count;
                 switch (handlersCount)
                 {
                     case 1:
                     {
-                        handlers[0](typedMessage);
+                        handlers[0](ref typedMessage);
                         return;
                     }
                     case 2:
                     {
-                        handlers[0](typedMessage);
+                        handlers[0](ref typedMessage);
                         if (handlers.Count < 2)
                         {
                             return;
                         }
-                        handlers[1](typedMessage);
+                        handlers[1](ref typedMessage);
                         return;
                     }
                     case 3:
                     {
-                        handlers[0](typedMessage);
+                        handlers[0](ref typedMessage);
                         if (handlers.Count < 2)
                         {
                             return;
                         }
-                        handlers[1](typedMessage);
+                        handlers[1](ref typedMessage);
                         if (handlers.Count < 3)
                         {
                             return;
                         }
-                        handlers[2](typedMessage);
+                        handlers[2](ref typedMessage);
                         return;
                     }
                     case 4:
                     {
-                        handlers[0](typedMessage);
+                        handlers[0](ref typedMessage);
                         if (handlers.Count < 2)
                         {
                             return;
                         }
-                        handlers[1](typedMessage);
+                        handlers[1](ref typedMessage);
                         if (handlers.Count < 3)
                         {
                             return;
                         }
-                        handlers[2](typedMessage);
+                        handlers[2](ref typedMessage);
                         if (handlers.Count < 4)
                         {
                             return;
                         }
-                        handlers[3](typedMessage);
+                        handlers[3](ref typedMessage);
                         return;
                     }
                     case 5:
                     {
-                        handlers[0](typedMessage);
+                        handlers[0](ref typedMessage);
                         if (handlers.Count < 2)
                         {
                             return;
                         }
-                        handlers[1](typedMessage);
+                        handlers[1](ref typedMessage);
                         if (handlers.Count < 3)
                         {
                             return;
                         }
-                        handlers[2](typedMessage);
+                        handlers[2](ref typedMessage);
                         if (handlers.Count < 4)
                         {
                             return;
                         }
-                        handlers[3](typedMessage);
+                        handlers[3](ref typedMessage);
                         if (handlers.Count < 5)
                         {
                             return;
                         }
-                        handlers[4](typedMessage);
+                        handlers[4](ref typedMessage);
                         return;
                     }
                 }
 
                 for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                 {
-                    handlers[i](typedMessage);
+                    handlers[i](ref typedMessage);
                 }
             }
 
@@ -5162,94 +5981,94 @@ namespace DxMessaging.Core
                     return;
                 }
 
-                List<Action<InstanceId, T>> typedHandlers = GetOrAddNewHandlerStack(
-                    cache,
-                    emissionId
-                );
+                List<FastHandlerWithContext<T>> typedHandlers = GetOrAddNewFlatInvokerStack<
+                    Action<InstanceId, T>,
+                    FastHandlerWithContext<T>
+                >(cache, emissionId);
                 ref T typedMessage = ref DxUnsafe.As<TMessage, T>(ref message);
                 int handlersCount = typedHandlers.Count;
                 switch (handlersCount)
                 {
                     case 1:
                     {
-                        typedHandlers[0](context, typedMessage);
+                        typedHandlers[0](ref context, ref typedMessage);
                         return;
                     }
                     case 2:
                     {
-                        typedHandlers[0](context, typedMessage);
+                        typedHandlers[0](ref context, ref typedMessage);
                         if (typedHandlers.Count < 2)
                         {
                             return;
                         }
-                        typedHandlers[1](context, typedMessage);
+                        typedHandlers[1](ref context, ref typedMessage);
                         return;
                     }
                     case 3:
                     {
-                        typedHandlers[0](context, typedMessage);
+                        typedHandlers[0](ref context, ref typedMessage);
                         if (typedHandlers.Count < 2)
                         {
                             return;
                         }
-                        typedHandlers[1](context, typedMessage);
+                        typedHandlers[1](ref context, ref typedMessage);
                         if (typedHandlers.Count < 3)
                         {
                             return;
                         }
-                        typedHandlers[2](context, typedMessage);
+                        typedHandlers[2](ref context, ref typedMessage);
                         return;
                     }
                     case 4:
                     {
-                        typedHandlers[0](context, typedMessage);
+                        typedHandlers[0](ref context, ref typedMessage);
                         if (typedHandlers.Count < 2)
                         {
                             return;
                         }
-                        typedHandlers[1](context, typedMessage);
+                        typedHandlers[1](ref context, ref typedMessage);
                         if (typedHandlers.Count < 3)
                         {
                             return;
                         }
-                        typedHandlers[2](context, typedMessage);
+                        typedHandlers[2](ref context, ref typedMessage);
                         if (typedHandlers.Count < 4)
                         {
                             return;
                         }
-                        typedHandlers[3](context, typedMessage);
+                        typedHandlers[3](ref context, ref typedMessage);
                         return;
                     }
                     case 5:
                     {
-                        typedHandlers[0](context, typedMessage);
+                        typedHandlers[0](ref context, ref typedMessage);
                         if (typedHandlers.Count < 2)
                         {
                             return;
                         }
-                        typedHandlers[1](context, typedMessage);
+                        typedHandlers[1](ref context, ref typedMessage);
                         if (typedHandlers.Count < 3)
                         {
                             return;
                         }
-                        typedHandlers[2](context, typedMessage);
+                        typedHandlers[2](ref context, ref typedMessage);
                         if (typedHandlers.Count < 4)
                         {
                             return;
                         }
-                        typedHandlers[3](context, typedMessage);
+                        typedHandlers[3](ref context, ref typedMessage);
                         if (typedHandlers.Count < 5)
                         {
                             return;
                         }
-                        typedHandlers[4](context, typedMessage);
+                        typedHandlers[4](ref context, ref typedMessage);
                         return;
                     }
                 }
 
                 for (int i = 0; i < handlersCount && i < typedHandlers.Count; ++i)
                 {
-                    typedHandlers[i](context, typedMessage);
+                    typedHandlers[i](ref context, ref typedMessage);
                 }
             }
 
@@ -5277,94 +6096,94 @@ namespace DxMessaging.Core
                     return;
                 }
 
-                List<Action<InstanceId, T>> typedHandlers = GetOrAddNewHandlerStack(
-                    cache,
-                    emissionId
-                );
+                List<FastHandlerWithContext<T>> typedHandlers = GetOrAddNewFlatInvokerStack<
+                    Action<InstanceId, T>,
+                    FastHandlerWithContext<T>
+                >(cache, emissionId);
                 ref T typedMessage = ref DxUnsafe.As<TMessage, T>(ref message);
                 int handlersCount = typedHandlers.Count;
                 switch (handlersCount)
                 {
                     case 1:
                     {
-                        typedHandlers[0](context, typedMessage);
+                        typedHandlers[0](ref context, ref typedMessage);
                         return;
                     }
                     case 2:
                     {
-                        typedHandlers[0](context, typedMessage);
+                        typedHandlers[0](ref context, ref typedMessage);
                         if (typedHandlers.Count < 2)
                         {
                             return;
                         }
-                        typedHandlers[1](context, typedMessage);
+                        typedHandlers[1](ref context, ref typedMessage);
                         return;
                     }
                     case 3:
                     {
-                        typedHandlers[0](context, typedMessage);
+                        typedHandlers[0](ref context, ref typedMessage);
                         if (typedHandlers.Count < 2)
                         {
                             return;
                         }
-                        typedHandlers[1](context, typedMessage);
+                        typedHandlers[1](ref context, ref typedMessage);
                         if (typedHandlers.Count < 3)
                         {
                             return;
                         }
-                        typedHandlers[2](context, typedMessage);
+                        typedHandlers[2](ref context, ref typedMessage);
                         return;
                     }
                     case 4:
                     {
-                        typedHandlers[0](context, typedMessage);
+                        typedHandlers[0](ref context, ref typedMessage);
                         if (typedHandlers.Count < 2)
                         {
                             return;
                         }
-                        typedHandlers[1](context, typedMessage);
+                        typedHandlers[1](ref context, ref typedMessage);
                         if (typedHandlers.Count < 3)
                         {
                             return;
                         }
-                        typedHandlers[2](context, typedMessage);
+                        typedHandlers[2](ref context, ref typedMessage);
                         if (typedHandlers.Count < 4)
                         {
                             return;
                         }
-                        typedHandlers[3](context, typedMessage);
+                        typedHandlers[3](ref context, ref typedMessage);
                         return;
                     }
                     case 5:
                     {
-                        typedHandlers[0](context, typedMessage);
+                        typedHandlers[0](ref context, ref typedMessage);
                         if (typedHandlers.Count < 2)
                         {
                             return;
                         }
-                        typedHandlers[1](context, typedMessage);
+                        typedHandlers[1](ref context, ref typedMessage);
                         if (typedHandlers.Count < 3)
                         {
                             return;
                         }
-                        typedHandlers[2](context, typedMessage);
+                        typedHandlers[2](ref context, ref typedMessage);
                         if (typedHandlers.Count < 4)
                         {
                             return;
                         }
-                        typedHandlers[3](context, typedMessage);
+                        typedHandlers[3](ref context, ref typedMessage);
                         if (typedHandlers.Count < 5)
                         {
                             return;
                         }
-                        typedHandlers[4](context, typedMessage);
+                        typedHandlers[4](ref context, ref typedMessage);
                         return;
                     }
                 }
 
                 for (int i = 0; i < handlersCount && i < typedHandlers.Count; ++i)
                 {
-                    typedHandlers[i](context, typedMessage);
+                    typedHandlers[i](ref context, ref typedMessage);
                 }
             }
 
@@ -5419,6 +6238,63 @@ namespace DxMessaging.Core
                 return actionCache.cache;
             }
 
+            // Default-slot registrations may store the raw user Action as the
+            // identity key while carrying diagnostics in Entry.flatInvoker. The
+            // legacy Handle* path must dispatch that same flat invoker snapshot,
+            // not Entry.handler, so diagnostics semantics match bus-side flat
+            // dispatch if the legacy callback path is used directly.
+            internal static List<TInvoker> GetOrAddNewFlatInvokerStack<TU, TInvoker>(
+                HandlerActionCache<TU> actionCache,
+                long emissionId
+            )
+                where TInvoker : class
+            {
+                DebugAssertInsertionOrderInSync(actionCache);
+                if (actionCache.flatInvokerLastSeenEmissionId != emissionId)
+                {
+                    if (actionCache.version != actionCache.flatInvokerLastSeenVersion)
+                    {
+                        List<TInvoker> list = actionCache.GetOrCreateFlatInvokerCache<TInvoker>();
+                        list.Clear();
+                        List<TU> orderedHandlers = actionCache.insertionOrder;
+                        int orderedCount = orderedHandlers.Count;
+                        for (int i = 0; i < orderedCount; ++i)
+                        {
+                            if (
+                                !actionCache.entries.TryGetValue(
+                                    orderedHandlers[i],
+                                    out HandlerActionCache<TU>.Entry entry
+                                )
+                            )
+                            {
+                                continue;
+                            }
+
+                            if (entry.flatInvoker is TInvoker invoker)
+                            {
+                                list.Add(invoker);
+                            }
+                            else
+                            {
+                                System.Diagnostics.Debug.Assert(
+                                    false,
+                                    "Default registration is missing the flat invoker required "
+                                        + "by legacy Handle* dispatch. Every default Add* path must "
+                                        + "store the diagnostics-augmented flat invoker in "
+                                        + "HandlerActionCache.Entry.flatInvoker."
+                                );
+                            }
+                        }
+
+                        actionCache.flatInvokerLastSeenVersion = actionCache.version;
+                    }
+
+                    actionCache.flatInvokerLastSeenEmissionId = emissionId;
+                }
+
+                return actionCache.GetOrCreateFlatInvokerCache<TInvoker>();
+            }
+
             // Asserts insertionOrder stays in lockstep with the entries
             // dictionary at every dispatch-snapshot read. Drift indicates a
             // mutation site of HandlerActionCache.entries that forgot to
@@ -5810,11 +6686,11 @@ namespace DxMessaging.Core
             // `flatInvoker` carries the pre-resolved flat-dispatch invoker for
             // registrations the bus-side flat snapshot consumes (untargeted
             // handle/post default handlers); see HandlerActionCache.Entry.flatInvoker.
-            private Action AddHandlerPreservingPriorityKey<TU>(
+            private HandlerDeregistration AddHandlerPreservingPriorityKey<TU>(
                 Dictionary<int, IHandlerActionCache> handlers,
                 TU originalHandler,
                 TU augmentedHandler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus,
                 object flatInvoker = null
@@ -5871,82 +6747,22 @@ namespace DxMessaging.Core
                     slot.liveCount++;
                 }
 
-                Dictionary<int, IHandlerActionCache> localHandlers = handlers;
-                TypedSlot<T> localSlot = slot;
                 long localSlotVersion = slot?.version ?? 0;
                 long localResetGeneration =
                     global::DxMessaging.Core.MessageBus.MessageBus.GetResetGeneration(messageBus);
 
-                return () =>
-                {
-                    if (
-                        !global::DxMessaging.Core.MessageBus.MessageBus.IsResetGenerationCurrent(
-                            messageBus,
-                            localResetGeneration
-                        )
-                    )
-                    {
-                        return;
-                    }
-
-                    if (localSlot != null && localSlot.version != localSlotVersion)
-                    {
-                        return;
-                    }
-
-                    if (
-                        !localHandlers.TryGetValue(
-                            priority,
-                            out IHandlerActionCache localErasedCache
-                        ) || localErasedCache is not HandlerActionCache<TU> localCache
-                    )
-                    {
-                        return;
-                    }
-
-                    if (
-                        !localCache.entries.TryGetValue(
-                            originalHandler,
-                            out HandlerActionCache<TU>.Entry localEntry
-                        )
-                    )
-                    {
-                        return;
-                    }
-
-                    localCache.version++;
-
-                    deregistration?.Invoke();
-                    if (localSlot != null)
-                    {
-                        localSlot.lastTouchTicks =
-                            global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(
-                                messageBus
-                            );
-                    }
-
-                    if (localEntry.count <= 1)
-                    {
-                        _ = localCache.entries.Remove(originalHandler);
-                        _ = localCache.insertionOrder.Remove(originalHandler);
-                        localCache.version++;
-                        if (localSlot != null)
-                        {
-                            localSlot.liveCount--;
-                        }
-                        // Intentionally DO NOT remove the priority key here to preserve
-                        // the cache handle during an in-flight emission.
-                        return;
-                    }
-
-                    localEntry = new HandlerActionCache<TU>.Entry(
-                        localEntry.handler,
-                        localEntry.count - 1,
-                        localEntry.flatInvoker
-                    );
-
-                    localCache.entries[originalHandler] = localEntry;
-                };
+                // See the context overload: this re-expresses the old scalar
+                // deregistration closure verbatim as a per-handle object.
+                return new TypedHandlerDeregistration(
+                    messageBus,
+                    localResetGeneration,
+                    slot,
+                    localSlotVersion,
+                    handlers,
+                    originalHandler,
+                    priority,
+                    in deregistration
+                );
             }
 
             private static Action AddHandlerPreservingPriorityKey<TU>(