com.wallstop-studios.dxmessaging 3.1.0 → 3.2.1

package/Runtime/Core/MessageHandler.cs

@@ -295,477 +295,356 @@ namespace DxMessaging.Core
         }
 
         /// <summary>
-        /// Callback from the MessageBus for handling UntargetedMessages - user code should generally never use this.
+        /// Callback from the MessageBus for handling Messages when this MessageHandler has subscribed to GlobalAcceptAll - user code should generally never use this.
         /// </summary>
-        /// <note>
-        /// In this case, "UntargetedMessage" refers to Targeted without targeting, and UntargetedMessages, hence T : IMessage.
-        /// </note>
         /// <param name="message">Message to handle.</param>
         /// <param name="messageBus">The specific MessageBus to use.</param>
-        /// <param name="priority">Priority at which to run the handlers.</param>
-        public void HandleUntargetedMessage<TMessage>(
-            ref TMessage message,
-            IMessageBus messageBus,
-            int priority
+        internal void HandleGlobalUntargetedMessage(
+            ref IUntargetedMessage message,
+            IMessageBus messageBus
         )
-            where TMessage : IMessage
         {
             if (!active)
             {
                 return;
             }
 
-            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
+            // Use the "IMessage" explicitly to indicate global messages, allowing us to multipurpose a single dictionary
+            if (GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
             {
                 long emissionId = messageBus.EmissionId;
-                handler.HandleUntargeted(ref message, priority, emissionId);
+                handler.HandleGlobalUntargeted(ref message, emissionId);
             }
         }
 
         /// <summary>
-        /// Callback from the MessageBus for handling UntargetedMessages - user code should generally never use this.
+        /// Pre-freezes this handler's GlobalAcceptAll untargeted caches for this emission.
         /// </summary>
-        /// <note>
-        /// In this case, "UntargetedMessage" refers to Targeted without targeting, and UntargetedMessages, hence T : IUntargetedMessage.
-        /// </note>
-        /// <param name="message">Message to handle.</param>
-        /// <param name="messageBus">The specific MessageBus to use.</param>
-        /// <param name="priority">Priority at which to run the handlers.</param>
-        public void HandleUntargetedPostProcessing<TMessage>(
-            ref TMessage message,
-            IMessageBus messageBus,
-            int priority
-        )
-            where TMessage : IUntargetedMessage
+        internal void PrefreezeGlobalUntargetedForEmission(long emissionId, IMessageBus messageBus)
         {
-            if (!active)
+            if (!GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
             {
                 return;
             }
 
-            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
-            {
-                long emissionId = messageBus.EmissionId;
-                handler.HandleUntargetedPostProcessing(ref message, priority, emissionId);
-            }
-        }
-
-        /// <summary>
-        /// Callback from the MessageBus for handling TargetedMessages when this MessageHandler has subscribed - user code should generally never use this.
-        /// </summary>
-        /// <note>
-        /// TargetedMessage refers to those that are intended for the GameObject that owns this MessageHandler.
-        /// </note>
-        /// <param name="target">Target Id the message is for.</param>
-        /// <param name="message">Message to handle.</param>
-        /// <param name="messageBus">The specific MessageBus to use.</param>
-        /// <param name="priority">Priority at which to run the handlers.</param>
-        public void HandleTargeted<TMessage>(
-            ref InstanceId target,
-            ref TMessage message,
-            IMessageBus messageBus,
-            int priority
-        )
-            where TMessage : ITargetedMessage
-        {
-            if (!active)
+            HandlerActionCache<FastHandler<IUntargetedMessage>> fastCache = handler.GetGlobalCache<
+                FastHandler<IUntargetedMessage>
+            >(TypedGlobalSlotIndex.UntargetedFast);
+            if (fastCache != null)
             {
-                return;
+                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(fastCache, emissionId);
             }
-
-            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
+            HandlerActionCache<Action<IUntargetedMessage>> cache = handler.GetGlobalCache<
+                Action<IUntargetedMessage>
+            >(TypedGlobalSlotIndex.UntargetedDefault);
+            if (cache != null)
             {
-                long emissionId = messageBus.EmissionId;
-                handler.HandleTargeted(ref target, ref message, priority, emissionId);
+                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(cache, emissionId);
             }
         }
 
         /// <summary>
-        /// Callback from the MessageBus for handling TargetedMessages without targeting when this MessageHandler has subscribed - user code should generally never use this.
+        /// Pre-freezes this handler's GlobalAcceptAll targeted caches for this emission.
         /// </summary>
-        /// <note>
-        /// Any TargetedMessage.
-        /// </note>
-        /// <param name="target">Target Id the message is for.</param>
-        /// <param name="message">Message to handle.</param>
-        /// <param name="messageBus">The specific MessageBus to use.</param>
-        /// <param name="priority">Priority at which to run the handlers.</param>
-        public void HandleTargetedWithoutTargeting<TMessage>(
-            ref InstanceId target,
-            ref TMessage message,
-            IMessageBus messageBus,
-            int priority
-        )
-            where TMessage : ITargetedMessage
+        internal void PrefreezeGlobalTargetedForEmission(long emissionId, IMessageBus messageBus)
         {
-            if (!active)
+            if (!GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
             {
                 return;
             }
 
-            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
-            {
-                long emissionId = messageBus.EmissionId;
-                handler.HandleTargetedWithoutTargeting(
-                    ref target,
-                    ref message,
-                    priority,
-                    emissionId
+            HandlerActionCache<FastHandlerWithContext<ITargetedMessage>> fastCache =
+                handler.GetGlobalCache<FastHandlerWithContext<ITargetedMessage>>(
+                    TypedGlobalSlotIndex.TargetedFast
                 );
-            }
-        }
-
-        /// <summary>
-        /// Callback from the MessageBus for post-processing TargetedMessages when this MessageHandler has subscribed - user code should generally never use this.
-        /// </summary>
-        /// <note>
-        /// TargetedMessage refers to those that are intended for the GameObject that owns this MessageHandler.
-        /// </note>
-        /// <param name="target">Target Id the message is for.</param>
-        /// <param name="message">Message to handle.</param>
-        /// <param name="messageBus">The specific MessageBus to use.</param>
-        /// <param name="priority">Priority at which to run the handlers.</param>
-        public void HandleTargetedPostProcessing<TMessage>(
-            ref InstanceId target,
-            ref TMessage message,
-            IMessageBus messageBus,
-            int priority
-        )
-            where TMessage : ITargetedMessage
-        {
-            if (!active)
+            if (fastCache != null)
             {
-                return;
+                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(fastCache, emissionId);
             }
-
-            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
+            HandlerActionCache<Action<InstanceId, ITargetedMessage>> cache = handler.GetGlobalCache<
+                Action<InstanceId, ITargetedMessage>
+            >(TypedGlobalSlotIndex.TargetedDefault);
+            if (cache != null)
             {
-                long emissionId = messageBus.EmissionId;
-                handler.HandleTargetedPostProcessing(ref target, ref message, priority, emissionId);
+                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(cache, emissionId);
             }
         }
 
         /// <summary>
-        /// Callback from the MessageBus for post-processing TargetedMessages when this MessageHandler has subscribed - user code should generally never use this.
+        /// Pre-freezes this handler's GlobalAcceptAll broadcast caches for this emission.
         /// </summary>
-        /// <note>
-        /// TargetedMessage refers to those that are intended for the GameObject that owns this MessageHandler.
-        /// </note>
-        /// <param name="target">Target Id the message is for.</param>
-        /// <param name="message">Message to handle.</param>
-        /// <param name="messageBus">The specific MessageBus to use.</param>
-        /// <param name="priority">Priority at which to run the handlers.</param>
-        public void HandleTargetedWithoutTargetingPostProcessing<TMessage>(
-            ref InstanceId target,
-            ref TMessage message,
-            IMessageBus messageBus,
-            int priority
-        )
-            where TMessage : ITargetedMessage
+        internal void PrefreezeGlobalBroadcastForEmission(long emissionId, IMessageBus messageBus)
         {
-            if (!active)
+            if (!GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
             {
                 return;
             }
 
-            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
-            {
-                long emissionId = messageBus.EmissionId;
-                handler.HandleTargetedWithoutTargetingPostProcessing(
-                    ref target,
-                    ref message,
-                    priority,
-                    emissionId
+            HandlerActionCache<FastHandlerWithContext<IBroadcastMessage>> fastCache =
+                handler.GetGlobalCache<FastHandlerWithContext<IBroadcastMessage>>(
+                    TypedGlobalSlotIndex.BroadcastFast
                 );
-            }
-        }
-
-        /// <summary>
-        /// Callback from the MessageBus for handling SourcedBroadcastMessages - user code should generally never use this.
-        /// </summary>
-        /// <note>
-        /// SourcedBroadcastMessages generally refer to those that are sourced from the GameObject that owns this MessageHandler.
-        /// </note>
-        /// <param name="source">Source Id the broadcast message is from.</param>
-        /// <param name="message">Message to handle</param>
-        /// <param name="messageBus">The specific MessageBus to use.</param>
-        /// <param name="priority">Priority at which to run the handlers.</param>
-        public void HandleSourcedBroadcast<TMessage>(
-            ref InstanceId source,
-            ref TMessage message,
-            IMessageBus messageBus,
-            int priority
-        )
-            where TMessage : IBroadcastMessage
-        {
-            if (!active)
+            if (fastCache != null)
             {
-                return;
+                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(fastCache, emissionId);
             }
-
-            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
+            HandlerActionCache<Action<InstanceId, IBroadcastMessage>> cache =
+                handler.GetGlobalCache<Action<InstanceId, IBroadcastMessage>>(
+                    TypedGlobalSlotIndex.BroadcastDefault
+                );
+            if (cache != null)
             {
-                long emissionId = messageBus.EmissionId;
-                handler.HandleSourcedBroadcast(ref source, ref message, priority, emissionId);
+                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(cache, emissionId);
             }
         }
 
         /// <summary>
-        /// Callback from the MessageBus for handling SourcedBroadcastMessages without source - user code should generally never use this.
+        /// Callback from the MessageBus for handling Messages when this MessageHandler has subscribed to GlobalAcceptAll - user code should generally never use this.
         /// </summary>
-        /// <note>
-        /// Any SourcedBroadcastMessages.
-        /// </note>
-        /// <param name="source">Source Id the broadcast message is from.</param>
-        /// <param name="message">Message to handle</param>
+        /// <param name="target">Target of the message.</param>
+        /// <param name="message">Message to handle.</param>
         /// <param name="messageBus">The specific MessageBus to use.</param>
-        /// <param name="priority">Priority at which to run the handlers.</param>
-        public void HandleSourcedBroadcastWithoutSource<TMessage>(
-            ref InstanceId source,
-            ref TMessage message,
-            IMessageBus messageBus,
-            int priority
+        internal void HandleGlobalTargetedMessage(
+            ref InstanceId target,
+            ref ITargetedMessage message,
+            IMessageBus messageBus
         )
-            where TMessage : IBroadcastMessage
         {
             if (!active)
             {
                 return;
             }
 
-            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
+            // Use the "IMessage" explicitly to indicate global messages, allowing us to multipurpose a single dictionary
+            if (GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
             {
                 long emissionId = messageBus.EmissionId;
-                handler.HandleSourcedBroadcastWithoutSource(
-                    ref source,
-                    ref message,
-                    priority,
-                    emissionId
-                );
+                handler.HandleGlobalTargeted(ref target, ref message, emissionId);
             }
         }
 
         /// <summary>
-        /// Callback from the MessageBus for handling SourcedBroadcastPostProcessing - user code should generally never use this.
+        /// Callback from the MessageBus for handling Messages when this MessageHandler has subscribed to GlobalAcceptAll - user code should generally never use this.
         /// </summary>
-        /// <note>
-        /// SourcedBroadcastMessages generally refer to those that are sourced from the GameObject that owns this MessageHandler.
-        /// </note>
-        /// <param name="source">Source Id the broadcast message is from.</param>
-        /// <param name="message">Message to handle</param>
+        /// <param name="source">Source that this message is from.</param>
+        /// <param name="message">Message to handle.</param>
         /// <param name="messageBus">The specific MessageBus to use.</param>
-        /// <param name="priority">Priority at which to run the handlers.</param>
-        public void HandleSourcedBroadcastPostProcessing<TMessage>(
+        internal void HandleGlobalSourcedBroadcastMessage(
             ref InstanceId source,
-            ref TMessage message,
-            IMessageBus messageBus,
-            int priority
+            ref IBroadcastMessage message,
+            IMessageBus messageBus
         )
-            where TMessage : IBroadcastMessage
         {
             if (!active)
             {
                 return;
             }
 
-            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
+            // Use the "IMessage" explicitly to indicate global messages, allowing us to multipurpose a single dictionary
+            if (GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
             {
                 long emissionId = messageBus.EmissionId;
-                handler.HandleSourcedBroadcastPostProcessing(
-                    ref source,
-                    ref message,
-                    priority,
-                    emissionId
-                );
+                handler.HandleGlobalBroadcast(ref source, ref message, emissionId);
             }
         }
 
         /// <summary>
-        /// Callback from the MessageBus for handling SourcedBroadcastPostProcessing - user code should generally never use this.
+        /// Reference-identity teardown base used by token lifecycle queues. The common
+        /// token path is implemented by the token's existing Registration object with
+        /// value-type state returned from MessageHandler; concrete wrappers below are
+        /// reserved for direct handler compatibility and overlapping retry spills.
         /// </summary>
-        /// <note>
-        /// SourcedBroadcastMessages generally refer to those that are sourced from the GameObject that owns this MessageHandler.
-        /// </note>
-        /// <param name="source">Source Id the broadcast message is from.</param>
-        /// <param name="message">Message to handle</param>
-        /// <param name="messageBus">The specific MessageBus to use.</param>
-        /// <param name="priority">Priority at which to run the handlers.</param>
-        public void HandleSourcedBroadcastWithoutSourcePostProcessing<TMessage>(
-            ref InstanceId source,
-            ref TMessage message,
-            IMessageBus messageBus,
-            int priority
-        )
-            where TMessage : IBroadcastMessage
+        /// <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.
+        /// </remarks>
+        internal abstract class HandlerDeregistration
         {
-            if (!active)
-            {
-                return;
-            }
+            internal abstract void Deregister();
 
-            if (GetHandlerForType(messageBus, out TypedHandler<TMessage> handler))
+            public static implicit operator Action(HandlerDeregistration deregistration)
             {
-                long emissionId = messageBus.EmissionId;
-                handler.HandleBroadcastWithoutSourcePostProcessing(
-                    ref source,
-                    ref message,
-                    priority,
-                    emissionId
-                );
+                return deregistration == null ? null : deregistration.Deregister;
             }
         }
 
         /// <summary>
-        /// Callback from the MessageBus for handling Messages when this MessageHandler has subscribed to GlobalAcceptAll - user code should generally never use this.
+        /// 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>
-        /// <param name="message">Message to handle.</param>
-        /// <param name="messageBus">The specific MessageBus to use.</param>
-        public void HandleGlobalUntargetedMessage(
-            ref IUntargetedMessage message,
-            IMessageBus messageBus
-        )
+        internal readonly struct InterceptorDeregistrationState<T>
+            where T : IMessage
         {
-            if (!active)
-            {
-                return;
-            }
+            private readonly IMessageBus _messageBus;
+            private readonly MessageBusRegistration _registration;
 
-            // Use the "IMessage" explicitly to indicate global messages, allowing us to multipurpose a single dictionary
-            if (GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
+            internal InterceptorDeregistrationState(
+                IMessageBus messageBus,
+                in MessageBusRegistration registration
+            )
             {
-                long emissionId = messageBus.EmissionId;
-                handler.HandleGlobalUntargeted(ref message, emissionId);
+                _messageBus = messageBus;
+                _registration = registration;
             }
-        }
 
-        /// <summary>
-        /// Pre-freezes this handler's GlobalAcceptAll untargeted caches for this emission.
-        /// </summary>
-        internal void PrefreezeGlobalUntargetedForEmission(long emissionId, IMessageBus messageBus)
-        {
-            if (!GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
+            internal void Deregister()
             {
-                return;
+                _messageBus.Deregister<T>(in _registration);
             }
 
-            HandlerActionCache<FastHandler<IUntargetedMessage>> fastCache = handler.GetGlobalCache<
-                FastHandler<IUntargetedMessage>
-            >(TypedGlobalSlotIndex.UntargetedFast);
-            if (fastCache != null)
+            public static implicit operator HandlerDeregistration(
+                InterceptorDeregistrationState<T> state
+            )
             {
-                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(fastCache, emissionId);
+                return new InterceptorDeregistration<T>(state);
             }
-            HandlerActionCache<Action<IUntargetedMessage>> cache = handler.GetGlobalCache<
-                Action<IUntargetedMessage>
-            >(TypedGlobalSlotIndex.UntargetedDefault);
-            if (cache != null)
+
+            public static implicit operator Action(InterceptorDeregistrationState<T> state)
             {
-                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(cache, emissionId);
+                InterceptorDeregistration<T> deregistration = new(state);
+                return deregistration.Deregister;
             }
         }
 
-        /// <summary>
-        /// Pre-freezes this handler's GlobalAcceptAll targeted caches for this emission.
-        /// </summary>
-        internal void PrefreezeGlobalTargetedForEmission(long emissionId, IMessageBus messageBus)
+        internal sealed class InterceptorDeregistration<T> : HandlerDeregistration
+            where T : IMessage
         {
-            if (!GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
-            {
-                return;
-            }
+            private readonly InterceptorDeregistrationState<T> _state;
 
-            HandlerActionCache<FastHandlerWithContext<ITargetedMessage>> fastCache =
-                handler.GetGlobalCache<FastHandlerWithContext<ITargetedMessage>>(
-                    TypedGlobalSlotIndex.TargetedFast
-                );
-            if (fastCache != null)
+            internal InterceptorDeregistration(InterceptorDeregistrationState<T> state)
             {
-                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(fastCache, emissionId);
+                _state = state;
             }
-            HandlerActionCache<Action<InstanceId, ITargetedMessage>> cache = handler.GetGlobalCache<
-                Action<InstanceId, ITargetedMessage>
-            >(TypedGlobalSlotIndex.TargetedDefault);
-            if (cache != null)
+
+            internal override void Deregister()
             {
-                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(cache, emissionId);
+                _state.Deregister();
             }
         }
 
         /// <summary>
-        /// Pre-freezes this handler's GlobalAcceptAll broadcast caches for this emission.
+        /// Value teardown for one typed global handler slot. Captures the old closure's
+        /// reset/slot guards, erased cache identity, refcount key, and touch/live-count state.
         /// </summary>
-        internal void PrefreezeGlobalBroadcastForEmission(long emissionId, IMessageBus messageBus)
+        internal readonly struct GlobalHandlerDeregistrationState
         {
-            if (!GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
+            private readonly IMessageBus _messageBus;
+            private readonly long _resetGeneration;
+            private readonly TypedGlobalSlot _slot;
+            private readonly long _slotVersion;
+            private readonly IHandlerActionCache _cache;
+            private readonly object _originalHandler;
+
+            internal GlobalHandlerDeregistrationState(
+                IMessageBus messageBus,
+                long resetGeneration,
+                TypedGlobalSlot slot,
+                long slotVersion,
+                IHandlerActionCache cache,
+                object originalHandler
+            )
             {
-                return;
+                _messageBus = messageBus;
+                _resetGeneration = resetGeneration;
+                _slot = slot;
+                _slotVersion = slotVersion;
+                _cache = cache;
+                _originalHandler = originalHandler;
             }
 
-            HandlerActionCache<FastHandlerWithContext<IBroadcastMessage>> fastCache =
-                handler.GetGlobalCache<FastHandlerWithContext<IBroadcastMessage>>(
-                    TypedGlobalSlotIndex.BroadcastFast
-                );
-            if (fastCache != null)
-            {
-                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(fastCache, emissionId);
-            }
-            HandlerActionCache<Action<InstanceId, IBroadcastMessage>> cache =
-                handler.GetGlobalCache<Action<InstanceId, IBroadcastMessage>>(
-                    TypedGlobalSlotIndex.BroadcastDefault
-                );
-            if (cache != null)
+            internal void Deregister()
             {
-                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(cache, emissionId);
+                if (
+                    !global::DxMessaging.Core.MessageBus.MessageBus.IsResetGenerationCurrent(
+                        _messageBus,
+                        _resetGeneration
+                    )
+                    || _slot.version != _slotVersion
+                    || !_cache.ContainsEntry(_originalHandler)
+                )
+                {
+                    return;
+                }
+
+                _cache.BumpVersion();
+                _slot.lastTouchTicks =
+                    global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(_messageBus);
+                _ = _cache.DeregisterEntry(_originalHandler, out bool wasLastForEntry);
+                if (wasLastForEntry)
+                {
+                    _slot.liveCount--;
+                }
             }
         }
 
         /// <summary>
-        /// Callback from the MessageBus for handling Messages when this MessageHandler has subscribed to GlobalAcceptAll - user code should generally never use this.
+        /// 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>
-        /// <param name="target">Target of the message.</param>
-        /// <param name="message">Message to handle.</param>
-        /// <param name="messageBus">The specific MessageBus to use.</param>
-        public void HandleGlobalTargetedMessage(
-            ref InstanceId target,
-            ref ITargetedMessage message,
-            IMessageBus messageBus
-        )
+        internal readonly struct GlobalAcceptAllDeregistrationState
         {
-            if (!active)
+            private readonly IMessageBus _messageBus;
+            private readonly MessageBusRegistration _messageBusRegistration;
+            private readonly GlobalHandlerDeregistrationState _untargetedDeregistration;
+            private readonly GlobalHandlerDeregistrationState _targetedDeregistration;
+            private readonly GlobalHandlerDeregistrationState _broadcastDeregistration;
+
+            internal GlobalAcceptAllDeregistrationState(
+                IMessageBus messageBus,
+                in MessageBusRegistration messageBusRegistration,
+                GlobalHandlerDeregistrationState untargetedDeregistration,
+                GlobalHandlerDeregistrationState targetedDeregistration,
+                GlobalHandlerDeregistrationState broadcastDeregistration
+            )
             {
-                return;
+                _messageBus = messageBus;
+                _messageBusRegistration = messageBusRegistration;
+                _untargetedDeregistration = untargetedDeregistration;
+                _targetedDeregistration = targetedDeregistration;
+                _broadcastDeregistration = broadcastDeregistration;
             }
 
-            // Use the "IMessage" explicitly to indicate global messages, allowing us to multipurpose a single dictionary
-            if (GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
+            internal void Deregister()
             {
-                long emissionId = messageBus.EmissionId;
-                handler.HandleGlobalTargeted(ref target, ref message, emissionId);
+                _messageBus.Deregister<IMessage>(in _messageBusRegistration);
+                _untargetedDeregistration.Deregister();
+                _targetedDeregistration.Deregister();
+                _broadcastDeregistration.Deregister();
             }
-        }
 
-        /// <summary>
-        /// Callback from the MessageBus for handling Messages when this MessageHandler has subscribed to GlobalAcceptAll - user code should generally never use this.
-        /// </summary>
-        /// <param name="source">Source that this message is from.</param>
-        /// <param name="message">Message to handle.</param>
-        /// <param name="messageBus">The specific MessageBus to use.</param>
-        public void HandleGlobalSourcedBroadcastMessage(
-            ref InstanceId source,
-            ref IBroadcastMessage message,
-            IMessageBus messageBus
-        )
+            public static implicit operator HandlerDeregistration(
+                GlobalAcceptAllDeregistrationState state
+            )
+            {
+                return new GlobalAcceptAllDeregistration(state);
+            }
+
+            public static implicit operator Action(GlobalAcceptAllDeregistrationState state)
+            {
+                GlobalAcceptAllDeregistration deregistration = new(state);
+                return deregistration.Deregister;
+            }
+        }
+
+        internal sealed class GlobalAcceptAllDeregistration : HandlerDeregistration
         {
-            if (!active)
+            private readonly GlobalAcceptAllDeregistrationState _state;
+
+            internal GlobalAcceptAllDeregistration(GlobalAcceptAllDeregistrationState state)
             {
-                return;
+                _state = state;
             }
 
-            // Use the "IMessage" explicitly to indicate global messages, allowing us to multipurpose a single dictionary
-            if (GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
+            internal override void Deregister()
             {
-                long emissionId = messageBus.EmissionId;
-                handler.HandleGlobalBroadcast(ref source, ref message, emissionId);
+                _state.Deregister();
             }
         }
 
@@ -777,7 +656,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 GlobalAcceptAllDeregistrationState RegisterGlobalAcceptAll(
             Action<IUntargetedMessage> originalUntargetedMessageHandler,
             Action<IUntargetedMessage> untargetedMessageHandler,
             Action<InstanceId, ITargetedMessage> originalTargetedMessageHandler,
@@ -788,40 +667,37 @@ namespace DxMessaging.Core
         )
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterGlobalAcceptAll(this);
-            TypedHandler<IMessage> typedHandler = GetOrCreateHandlerForType<IMessage>(messageBus);
-
-            Action untargetedDeregistration = typedHandler.AddGlobalUntargetedHandler(
-                originalUntargetedMessageHandler,
-                untargetedMessageHandler,
-                NullDeregistration,
-                messageBus
-            );
-            Action targetedDeregistration = typedHandler.AddGlobalTargetedHandler(
-                originalTargetedMessageHandler,
-                targetedMessageHandler,
-                NullDeregistration,
-                messageBus
-            );
-            Action broadcastDeregistration = typedHandler.AddGlobalBroadcastHandler(
-                originalBroadcastMessageHandler,
-                broadcastMessageHandler,
-                NullDeregistration,
-                messageBus
+            MessageBusRegistration messageBusDeregistration = messageBus.RegisterGlobalAcceptAll(
+                this
             );
+            TypedHandler<IMessage> typedHandler = GetOrCreateHandlerForType<IMessage>(messageBus);
 
-            return () =>
-            {
-                messageBusDeregistration?.Invoke();
-                untargetedDeregistration();
-                targetedDeregistration();
-                broadcastDeregistration();
-            };
+            GlobalHandlerDeregistrationState untargetedDeregistration =
+                typedHandler.AddGlobalUntargetedHandler(
+                    originalUntargetedMessageHandler,
+                    untargetedMessageHandler,
+                    messageBus
+                );
+            GlobalHandlerDeregistrationState targetedDeregistration =
+                typedHandler.AddGlobalTargetedHandler(
+                    originalTargetedMessageHandler,
+                    targetedMessageHandler,
+                    messageBus
+                );
+            GlobalHandlerDeregistrationState broadcastDeregistration =
+                typedHandler.AddGlobalBroadcastHandler(
+                    originalBroadcastMessageHandler,
+                    broadcastMessageHandler,
+                    messageBus
+                );
 
-            void NullDeregistration()
-            {
-                // No-op
-            }
+            return new GlobalAcceptAllDeregistrationState(
+                messageBus,
+                in messageBusDeregistration,
+                untargetedDeregistration,
+                targetedDeregistration,
+                broadcastDeregistration
+            );
         }
 
         /// <summary>
@@ -832,7 +708,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 GlobalAcceptAllDeregistrationState RegisterGlobalAcceptAll(
             FastHandler<IUntargetedMessage> originalUntargetedMessageHandler,
             FastHandler<IUntargetedMessage> untargetedMessageHandler,
             FastHandlerWithContext<ITargetedMessage> originalTargetedMessageHandler,
@@ -843,40 +719,37 @@ namespace DxMessaging.Core
         )
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterGlobalAcceptAll(this);
-            TypedHandler<IMessage> typedHandler = GetOrCreateHandlerForType<IMessage>(messageBus);
-
-            Action untargetedDeregistration = typedHandler.AddGlobalUntargetedHandler(
-                originalUntargetedMessageHandler,
-                untargetedMessageHandler,
-                NullDeregistration,
-                messageBus
-            );
-            Action targetedDeregistration = typedHandler.AddGlobalTargetedHandler(
-                originalTargetedMessageHandler,
-                targetedMessageHandler,
-                NullDeregistration,
-                messageBus
-            );
-            Action broadcastDeregistration = typedHandler.AddGlobalBroadcastHandler(
-                originalBroadcastMessageHandler,
-                broadcastMessageHandler,
-                NullDeregistration,
-                messageBus
+            MessageBusRegistration messageBusDeregistration = messageBus.RegisterGlobalAcceptAll(
+                this
             );
+            TypedHandler<IMessage> typedHandler = GetOrCreateHandlerForType<IMessage>(messageBus);
 
-            return () =>
-            {
-                messageBusDeregistration?.Invoke();
-                untargetedDeregistration();
-                targetedDeregistration();
-                broadcastDeregistration();
-            };
+            GlobalHandlerDeregistrationState untargetedDeregistration =
+                typedHandler.AddGlobalUntargetedHandler(
+                    originalUntargetedMessageHandler,
+                    untargetedMessageHandler,
+                    messageBus
+                );
+            GlobalHandlerDeregistrationState targetedDeregistration =
+                typedHandler.AddGlobalTargetedHandler(
+                    originalTargetedMessageHandler,
+                    targetedMessageHandler,
+                    messageBus
+                );
+            GlobalHandlerDeregistrationState broadcastDeregistration =
+                typedHandler.AddGlobalBroadcastHandler(
+                    originalBroadcastMessageHandler,
+                    broadcastMessageHandler,
+                    messageBus
+                );
 
-            void NullDeregistration()
-            {
-                // No-op
-            }
+            return new GlobalAcceptAllDeregistrationState(
+                messageBus,
+                in messageBusDeregistration,
+                untargetedDeregistration,
+                targetedDeregistration,
+                broadcastDeregistration
+            );
         }
 
         /// <summary>
@@ -888,7 +761,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterTargetedMessageHandler<T>(
             InstanceId target,
             Action<T> originalHandler,
             Action<T> messageHandler,
@@ -898,7 +771,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 +787,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 TypedHandler<T>.TypedHandlerDeregistrationState 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 +829,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterTargetedMessageHandler<T>(
             InstanceId target,
             FastHandler<T> originalHandler,
             FastHandler<T> messageHandler,
@@ -933,7 +839,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 +864,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterTargetedPostProcessor<T>(
             InstanceId target,
             Action<T> originalHandler,
             Action<T> messageHandler,
@@ -968,11 +874,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 +896,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterTargetedPostProcessor<T>(
             InstanceId target,
             FastHandler<T> originalHandler,
             FastHandler<T> messageHandler,
@@ -1003,16 +906,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 TypedHandler<T>.TypedHandlerDeregistrationState 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 +957,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterTargetedWithoutTargetingPostProcessor<T>(
             Action<InstanceId, T> originalHandler,
             Action<InstanceId, T> messageHandler,
             int priority = 0,
@@ -1036,7 +966,7 @@ namespace DxMessaging.Core
             where T : ITargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration =
+            MessageBusRegistration messageBusDeregistration =
                 messageBus.RegisterTargetedWithoutTargetingPostProcessor<T>(
                     priority: priority,
                     messageHandler: this
@@ -1059,7 +989,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterTargetedWithoutTargetingPostProcessor<T>(
             FastHandlerWithContext<T> originalHandler,
             FastHandlerWithContext<T> messageHandler,
             int priority = 0,
@@ -1068,7 +998,7 @@ namespace DxMessaging.Core
             where T : ITargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration =
+            MessageBusRegistration messageBusDeregistration =
                 messageBus.RegisterTargetedWithoutTargetingPostProcessor<T>(
                     priority: priority,
                     messageHandler: this
@@ -1083,6 +1013,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 TypedHandler<T>.TypedHandlerDeregistrationState 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 +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 RegisterTargetedWithoutTargeting<T>(
+        internal TypedHandler<T>.TypedHandlerDeregistrationState RegisterTargetedWithoutTargeting<T>(
             Action<InstanceId, T> originalHandler,
             Action<InstanceId, T> messageHandler,
             int priority = 0,
@@ -1100,10 +1062,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 +1074,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 TypedHandler<T>.TypedHandlerDeregistrationState 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 +1111,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterTargetedWithoutTargeting<T>(
             FastHandlerWithContext<T> originalHandler,
             FastHandlerWithContext<T> messageHandler,
             int priority = 0,
@@ -1131,10 +1120,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 +1140,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterUntargetedMessageHandler<T>(
             Action<T> originalHandler,
             Action<T> messageHandler,
             int priority = 0,
@@ -1162,7 +1149,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 +1163,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 TypedHandler<T>.TypedHandlerDeregistrationState 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 +1201,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterUntargetedMessageHandler<T>(
             FastHandler<T> originalHandler,
             FastHandler<T> messageHandler,
             int priority = 0,
@@ -1193,7 +1210,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 +1232,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterUntargetedPostProcessor<T>(
             Action<T> originalHandler,
             Action<T> messageHandler,
             int priority = 0,
@@ -1224,10 +1241,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 +1264,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterUntargetedPostProcessor<T>(
             FastHandler<T> originalHandler,
             FastHandler<T> messageHandler,
             int priority = 0,
@@ -1255,10 +1273,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 +1297,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterSourcedBroadcastMessageHandler<T>(
             InstanceId source,
             Action<T> originalHandler,
             Action<T> messageHandler,
@@ -1288,11 +1307,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 +1321,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 TypedHandler<T>.TypedHandlerDeregistrationState 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 +1360,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterSourcedBroadcastMessageHandler<T>(
             InstanceId source,
             FastHandler<T> originalHandler,
             FastHandler<T> messageHandler,
@@ -1324,11 +1370,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 +1391,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterSourcedBroadcastWithoutSource<T>(
             Action<InstanceId, T> originalHandler,
             Action<InstanceId, T> messageHandler,
             int priority = 0,
@@ -1357,10 +1400,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 +1412,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 TypedHandler<T>.TypedHandlerDeregistrationState 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 +1449,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterSourcedBroadcastWithoutSource<T>(
             FastHandlerWithContext<T> originalHandler,
             FastHandlerWithContext<T> messageHandler,
             int priority = 0,
@@ -1388,10 +1458,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,21 +1479,58 @@ 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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterSourcedBroadcastPostProcessor<T>(
+            InstanceId source,
+            Action<T> originalHandler,
+            Action<T> messageHandler,
+            int priority = 0,
+            IMessageBus messageBus = null
+        )
+            where T : IBroadcastMessage
+        {
+            messageBus = ResolveMessageBus(messageBus);
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterBroadcastPostProcessor<T>(
+                    source,
+                    messageHandler: this,
+                    priority: priority
+                );
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.AddBroadcastPostProcessor(
+                source,
+                originalHandler,
+                messageHandler,
+                messageBusDeregistration,
+                priority,
+                messageBus
+            );
+        }
+
+        /// <summary>
+        /// Registers this MessageHandler to post processes fast BroadcastMessage messages.
+        /// </summary>
+        /// <typeparam name="T">Type of Message to be handled.</typeparam>
+        /// <param name="source">Source object to listen for BroadcastMessages on.</param>
+        /// <param name="messageHandler">Function that actually handles the message.</param>
+        /// <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>
+        internal TypedHandler<T>.TypedHandlerDeregistrationState RegisterSourcedBroadcastPostProcessor<T>(
             InstanceId source,
-            Action<T> originalHandler,
-            Action<T> messageHandler,
+            FastHandler<T> originalHandler,
+            FastHandler<T> messageHandler,
             int priority = 0,
             IMessageBus messageBus = null
         )
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterBroadcastPostProcessor<T>(
-                source,
-                messageHandler: this,
-                priority: priority
-            );
+            MessageBusRegistration messageBusDeregistration =
+                messageBus.RegisterBroadcastPostProcessor<T>(
+                    source,
+                    priority: priority,
+                    messageHandler: this
+                );
             TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
             return typedHandler.AddBroadcastPostProcessor(
                 source,
@@ -1438,34 +1543,33 @@ namespace DxMessaging.Core
         }
 
         /// <summary>
-        /// Registers this MessageHandler to post processes fast BroadcastMessage messages.
+        /// 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>
-        /// <typeparam name="T">Type of Message to be handled.</typeparam>
-        /// <param name="source">Source object to listen for BroadcastMessages on.</param>
-        /// <param name="messageHandler">Function that actually handles the message.</param>
-        /// <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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterSourcedBroadcastPostProcessor<T>(
             InstanceId source,
-            FastHandler<T> originalHandler,
-            FastHandler<T> messageHandler,
+            Action<T> originalHandler,
+            FastHandler<T> flatInvoker,
             int priority = 0,
             IMessageBus messageBus = null
         )
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration = messageBus.RegisterBroadcastPostProcessor<T>(
-                source,
-                priority: priority,
-                messageHandler: this
-            );
+            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 +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 RegisterSourcedBroadcastWithoutSourcePostProcessor<T>(
+        internal TypedHandler<T>.TypedHandlerDeregistrationState RegisterSourcedBroadcastWithoutSourcePostProcessor<T>(
             Action<InstanceId, T> originalHandler,
             Action<InstanceId, T> messageHandler,
             int priority = 0,
@@ -1489,7 +1593,7 @@ namespace DxMessaging.Core
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration =
+            MessageBusRegistration messageBusDeregistration =
                 messageBus.RegisterBroadcastWithoutSourcePostProcessor<T>(
                     priority: priority,
                     messageHandler: this
@@ -1512,7 +1616,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 TypedHandler<T>.TypedHandlerDeregistrationState RegisterSourcedBroadcastWithoutSourcePostProcessor<T>(
             FastHandlerWithContext<T> originalHandler,
             FastHandlerWithContext<T> messageHandler,
             int priority = 0,
@@ -1521,7 +1625,7 @@ namespace DxMessaging.Core
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            Action messageBusDeregistration =
+            MessageBusRegistration messageBusDeregistration =
                 messageBus.RegisterBroadcastWithoutSourcePostProcessor<T>(
                     priority: priority,
                     messageHandler: this
@@ -1536,6 +1640,38 @@ namespace DxMessaging.Core
             );
         }
 
+        /// <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 TypedHandler<T>.TypedHandlerDeregistrationState 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
+                );
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.AddBroadcastWithoutSourcePostProcessor(
+                originalHandler,
+                flatInvoker,
+                messageBusDeregistration,
+                priority,
+                messageBus
+            );
+        }
+
         /// <summary>
         /// Registers an UntargetedInterceptor for messages of the provided type at the provided priority.
         /// </summary>
@@ -1544,7 +1680,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 InterceptorDeregistrationState<T> RegisterUntargetedInterceptor<T>(
             IMessageBus.UntargetedInterceptor<T> interceptor,
             int priority = 0,
             IMessageBus messageBus = null
@@ -1552,7 +1688,11 @@ namespace DxMessaging.Core
             where T : IUntargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            return messageBus.RegisterUntargetedInterceptor(interceptor, priority);
+            MessageBusRegistration registration = messageBus.RegisterUntargetedInterceptor(
+                interceptor,
+                priority
+            );
+            return new InterceptorDeregistrationState<T>(messageBus, in registration);
         }
 
         /// <summary>
@@ -1563,7 +1703,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 InterceptorDeregistrationState<T> RegisterBroadcastInterceptor<T>(
             IMessageBus.BroadcastInterceptor<T> interceptor,
             int priority = 0,
             IMessageBus messageBus = null
@@ -1571,7 +1711,11 @@ namespace DxMessaging.Core
             where T : IBroadcastMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            return messageBus.RegisterBroadcastInterceptor(interceptor, priority);
+            MessageBusRegistration registration = messageBus.RegisterBroadcastInterceptor(
+                interceptor,
+                priority
+            );
+            return new InterceptorDeregistrationState<T>(messageBus, in registration);
         }
 
         /// <summary>
@@ -1582,7 +1726,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 InterceptorDeregistrationState<T> RegisterTargetedInterceptor<T>(
             IMessageBus.TargetedInterceptor<T> interceptor,
             int priority = 0,
             IMessageBus messageBus = null
@@ -1590,7 +1734,11 @@ namespace DxMessaging.Core
             where T : ITargetedMessage
         {
             messageBus = ResolveMessageBus(messageBus);
-            return messageBus.RegisterTargetedInterceptor(interceptor, priority);
+            MessageBusRegistration registration = messageBus.RegisterTargetedInterceptor(
+                interceptor,
+                priority
+            );
+            return new InterceptorDeregistrationState<T>(messageBus, in registration);
         }
 
         /// <summary>
@@ -1725,6 +1873,94 @@ namespace DxMessaging.Core
             return false;
         }
 
+        internal bool TryObserveFastPriorityHandlerStorage<T>(
+            IMessageBus messageBus,
+            int slotIndex,
+            int priority,
+            out HandlerCacheStorageObservation observation
+        )
+            where T : IMessage
+        {
+            if (!GetHandlerForType(messageBus, out TypedHandler<T> typedHandler))
+            {
+                observation = default;
+                return false;
+            }
+
+            TypedSlot<T> slot = typedHandler._slots[slotIndex];
+            if (
+                slot == null
+                || !slot.byPriority.TryGetValue(priority, out IHandlerActionCache erased)
+                || erased is not HandlerActionCache<FastHandler<T>> cache
+            )
+            {
+                observation = default;
+                return false;
+            }
+
+            observation = new HandlerCacheStorageObservation(
+                slot.byPriority.Count,
+                0,
+                slot.byPriority.EnsureCapacity(0),
+                slot.orderedPriorities.Capacity,
+                true,
+                cache.entries.Count,
+                cache.entries.InlineCapacity,
+                cache.entries.MapCapacity,
+                cache.entries.OrderCapacity,
+                cache.entries.UsesSpillStorage
+            );
+            return true;
+        }
+
+        internal readonly struct HandlerCacheStorageObservation
+        {
+            internal HandlerCacheStorageObservation(
+                int priorityEntries,
+                int priorityInlineCapacity,
+                int priorityMapCapacity,
+                int priorityOrderCapacity,
+                bool priorityUsesSpillStorage,
+                int handlerEntries,
+                int handlerInlineCapacity,
+                int handlerMapCapacity,
+                int handlerOrderCapacity,
+                bool handlerUsesSpillStorage
+            )
+            {
+                PriorityEntries = priorityEntries;
+                PriorityInlineCapacity = priorityInlineCapacity;
+                PriorityMapCapacity = priorityMapCapacity;
+                PriorityOrderCapacity = priorityOrderCapacity;
+                PriorityUsesSpillStorage = priorityUsesSpillStorage;
+                HandlerEntries = handlerEntries;
+                HandlerInlineCapacity = handlerInlineCapacity;
+                HandlerMapCapacity = handlerMapCapacity;
+                HandlerOrderCapacity = handlerOrderCapacity;
+                HandlerUsesSpillStorage = handlerUsesSpillStorage;
+            }
+
+            internal int PriorityEntries { get; }
+
+            internal int PriorityInlineCapacity { get; }
+
+            internal int PriorityMapCapacity { get; }
+
+            internal int PriorityOrderCapacity { get; }
+
+            internal bool PriorityUsesSpillStorage { get; }
+
+            internal int HandlerEntries { get; }
+
+            internal int HandlerInlineCapacity { get; }
+
+            internal int HandlerMapCapacity { get; }
+
+            internal int HandlerOrderCapacity { get; }
+
+            internal bool HandlerUsesSpillStorage { get; }
+        }
+
         /// <summary>
         /// Resets empty typed-handler slots associated with
         /// <paramref name="messageBus"/>. The eviction layer calls through
@@ -2058,7 +2294,7 @@ namespace DxMessaging.Core
                 && erased is HandlerActionCache<TDelegate> cache
             )
             {
-                return cache.insertionOrder.Count;
+                return cache.entries.Count;
             }
 
             return 0;
@@ -2081,19 +2317,11 @@ namespace DxMessaging.Core
                 return writeIndex;
             }
 
-            List<FastHandler<T>> ordered = cache.insertionOrder;
-            int orderedCount = ordered.Count;
+            int orderedCount = cache.entries.Count;
             for (int i = 0; i < orderedCount; ++i)
             {
-                if (
-                    cache.entries.TryGetValue(
-                        ordered[i],
-                        out HandlerActionCache<FastHandler<T>>.Entry entry
-                    )
-                )
-                {
-                    target[writeIndex++] = new FlatDispatchEntry<T>(this, entry.handler);
-                }
+                HandlerActionCache<FastHandler<T>>.Entry entry = cache.entries.ValueAt(i);
+                target[writeIndex++] = new FlatDispatchEntry<T>(this, entry.handler);
             }
 
             return writeIndex;
@@ -2116,19 +2344,10 @@ namespace DxMessaging.Core
                 return writeIndex;
             }
 
-            List<Action<T>> ordered = cache.insertionOrder;
-            int orderedCount = ordered.Count;
+            int orderedCount = cache.entries.Count;
             for (int i = 0; i < orderedCount; ++i)
             {
-                if (
-                    !cache.entries.TryGetValue(
-                        ordered[i],
-                        out HandlerActionCache<Action<T>>.Entry entry
-                    )
-                )
-                {
-                    continue;
-                }
+                HandlerActionCache<Action<T>>.Entry entry = cache.entries.ValueAt(i);
 
                 // Every default registration path for the flattened slots
                 // supplies the adapter at registration time (AddUntargetedHandler,
@@ -2136,6 +2355,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);
@@ -2171,80 +2396,342 @@ namespace DxMessaging.Core
                 return writeIndex;
             }
 
-            List<FastHandlerWithContext<T>> ordered = cache.insertionOrder;
-            int orderedCount = ordered.Count;
-            for (int i = 0; i < orderedCount; ++i)
-            {
-                if (
-                    cache.entries.TryGetValue(
-                        ordered[i],
-                        out HandlerActionCache<FastHandlerWithContext<T>>.Entry entry
-                    )
-                )
+            int orderedCount = cache.entries.Count;
+            for (int i = 0; i < orderedCount; ++i)
+            {
+                HandlerActionCache<FastHandlerWithContext<T>>.Entry entry = cache.entries.ValueAt(
+                    i
+                );
+                target[writeIndex++] = new ContextFlatDispatchEntry<T>(this, entry.handler);
+            }
+
+            return writeIndex;
+        }
+
+        private int FillDefaultWithContextFlatEntries<T>(
+            Dictionary<int, IHandlerActionCache> byPriority,
+            int priority,
+            ContextFlatDispatchEntry<T>[] target,
+            int writeIndex
+        )
+            where T : IMessage
+        {
+            if (
+                byPriority == null
+                || !byPriority.TryGetValue(priority, out IHandlerActionCache erased)
+                || erased is not HandlerActionCache<Action<InstanceId, T>> cache
+            )
+            {
+                return writeIndex;
+            }
+
+            int orderedCount = cache.entries.Count;
+            for (int i = 0; i < orderedCount; ++i)
+            {
+                HandlerActionCache<Action<InstanceId, T>>.Entry entry = cache.entries.ValueAt(i);
+
+                // See FillDefaultFlatEntries: the adapter is created once at
+                // registration time (AddTargetedWithoutTargetingHandler,
+                // AddSourcedBroadcastWithoutSourceHandler, and their
+                // post-processor siblings).
+                if (entry.flatInvoker is FastHandlerWithContext<T> invoker)
+                {
+                    target[writeIndex++] = new ContextFlatDispatchEntry<T>(this, invoker);
+                }
+                else
+                {
+                    System.Diagnostics.Debug.Assert(
+                        false,
+                        "Default with-context registration is missing its "
+                            + "FastHandlerWithContext flat invoker; every without-context "
+                            + "Add* default path must adapt the augmented handler at "
+                            + "registration time."
+                    );
+                }
+            }
+
+            return writeIndex;
+        }
+
+        internal sealed class HandlerActionCache<T> : DxMessaging.Core.Internal.IHandlerActionCache
+        {
+            internal struct OrderedEntries
+            {
+                private const int PhysicalInlineCapacity = 2;
+                private static readonly EqualityComparer<T> s_comparer =
+                    EqualityComparer<T>.Default;
+
+                private int _inlineCount;
+                private T _key0;
+                private T _key1;
+                private Entry _value0;
+                private Entry _value1;
+                private Dictionary<T, Entry> _spillMap;
+                private List<T> _spillOrder;
+
+                public int Count
+                {
+                    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                    get => _spillMap?.Count ?? _inlineCount;
+                }
+
+                public int InlineCapacity
+                {
+                    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                    get => PhysicalInlineCapacity;
+                }
+
+                public int MapCapacity
+                {
+                    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                    get => _spillMap?.EnsureCapacity(0) ?? 0;
+                }
+
+                public int OrderCapacity
+                {
+                    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                    get => _spillOrder?.Capacity ?? 0;
+                }
+
+                public bool UsesSpillStorage
+                {
+                    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                    get => _spillMap != null;
+                }
+
+                public Entry this[T key]
+                {
+                    set
+                    {
+                        ThrowIfNull(key);
+                        if (_spillMap != null)
+                        {
+                            if (!_spillMap.ContainsKey(key))
+                            {
+                                _spillMap.Add(key, value);
+                                try
+                                {
+                                    _spillOrder.Add(key);
+                                }
+                                catch
+                                {
+                                    _ = _spillMap.Remove(key);
+                                    throw;
+                                }
+                                return;
+                            }
+                            _spillMap[key] = value;
+                            return;
+                        }
+
+                        int index = FindInlineIndex(key);
+                        if (index >= 0)
+                        {
+                            SetInlineValue(index, value);
+                            return;
+                        }
+                        if (_inlineCount < PhysicalInlineCapacity)
+                        {
+                            SetInline(_inlineCount, key, value);
+                            ++_inlineCount;
+                            return;
+                        }
+
+                        Spill();
+                        _spillMap.Add(key, value);
+                        try
+                        {
+                            _spillOrder.Add(key);
+                        }
+                        catch
+                        {
+                            _ = _spillMap.Remove(key);
+                            throw;
+                        }
+                    }
+                }
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                public bool ContainsKey(T key)
+                {
+                    ThrowIfNull(key);
+                    return _spillMap?.ContainsKey(key) ?? FindInlineIndex(key) >= 0;
+                }
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                public bool TryGetValue(T key, out Entry value)
+                {
+                    ThrowIfNull(key);
+                    if (_spillMap != null)
+                    {
+                        return _spillMap.TryGetValue(key, out value);
+                    }
+                    int index = FindInlineIndex(key);
+                    if (index >= 0)
+                    {
+                        value = GetInlineValue(index);
+                        return true;
+                    }
+                    value = default;
+                    return false;
+                }
+
+                public bool Remove(T key)
+                {
+                    ThrowIfNull(key);
+                    if (_spillMap != null)
+                    {
+                        if (!_spillMap.Remove(key))
+                        {
+                            return false;
+                        }
+                        _ = _spillOrder.Remove(key);
+                        return true;
+                    }
+                    int index = FindInlineIndex(key);
+                    if (index < 0)
+                    {
+                        return false;
+                    }
+                    int lastIndex = _inlineCount - 1;
+                    for (int moveIndex = index; moveIndex < lastIndex; ++moveIndex)
+                    {
+                        SetInline(
+                            moveIndex,
+                            GetInlineKey(moveIndex + 1),
+                            GetInlineValue(moveIndex + 1)
+                        );
+                    }
+                    ClearInline(lastIndex);
+                    --_inlineCount;
+                    return true;
+                }
+
+                public void Clear()
+                {
+                    if (_spillMap != null)
+                    {
+                        _spillMap.Clear();
+                        _spillOrder.Clear();
+                        return;
+                    }
+                    for (int index = 0; index < _inlineCount; ++index)
+                    {
+                        ClearInline(index);
+                    }
+                    _inlineCount = 0;
+                }
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                public T KeyAt(int index)
+                {
+                    if (_spillOrder != null)
+                    {
+                        return _spillOrder[index];
+                    }
+                    if ((uint)index >= (uint)_inlineCount)
+                    {
+                        throw new ArgumentOutOfRangeException(nameof(index));
+                    }
+                    return GetInlineKey(index);
+                }
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                public Entry ValueAt(int index)
+                {
+                    if (_spillOrder != null)
+                    {
+                        return _spillMap[_spillOrder[index]];
+                    }
+                    if ((uint)index >= (uint)_inlineCount)
+                    {
+                        throw new ArgumentOutOfRangeException(nameof(index));
+                    }
+                    return GetInlineValue(index);
+                }
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                private int FindInlineIndex(T key)
+                {
+                    if (_inlineCount > 0 && s_comparer.Equals(_key0, key))
+                    {
+                        return 0;
+                    }
+                    if (_inlineCount > 1 && s_comparer.Equals(_key1, key))
+                    {
+                        return 1;
+                    }
+                    return -1;
+                }
+
+                private void Spill()
                 {
-                    target[writeIndex++] = new ContextFlatDispatchEntry<T>(this, entry.handler);
+                    Dictionary<T, Entry> map = new(PhysicalInlineCapacity * 2);
+                    List<T> order = new(PhysicalInlineCapacity * 2);
+                    for (int index = 0; index < _inlineCount; ++index)
+                    {
+                        T key = GetInlineKey(index);
+                        map.Add(key, GetInlineValue(index));
+                        order.Add(key);
+                    }
+                    for (int index = 0; index < _inlineCount; ++index)
+                    {
+                        ClearInline(index);
+                    }
+                    _inlineCount = 0;
+                    _spillMap = map;
+                    _spillOrder = order;
                 }
-            }
 
-            return writeIndex;
-        }
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                private T GetInlineKey(int index)
+                {
+                    return index == 0 ? _key0 : _key1;
+                }
 
-        private int FillDefaultWithContextFlatEntries<T>(
-            Dictionary<int, IHandlerActionCache> byPriority,
-            int priority,
-            ContextFlatDispatchEntry<T>[] target,
-            int writeIndex
-        )
-            where T : IMessage
-        {
-            if (
-                byPriority == null
-                || !byPriority.TryGetValue(priority, out IHandlerActionCache erased)
-                || erased is not HandlerActionCache<Action<InstanceId, T>> cache
-            )
-            {
-                return writeIndex;
-            }
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                private Entry GetInlineValue(int index)
+                {
+                    return index == 0 ? _value0 : _value1;
+                }
 
-            List<Action<InstanceId, T>> ordered = cache.insertionOrder;
-            int orderedCount = ordered.Count;
-            for (int i = 0; i < orderedCount; ++i)
-            {
-                if (
-                    !cache.entries.TryGetValue(
-                        ordered[i],
-                        out HandlerActionCache<Action<InstanceId, T>>.Entry entry
-                    )
-                )
+                private void SetInline(int index, T key, Entry value)
                 {
-                    continue;
+                    if (index == 0)
+                    {
+                        _key0 = key;
+                        _value0 = value;
+                        return;
+                    }
+                    _key1 = key;
+                    _value1 = value;
                 }
 
-                // See FillDefaultFlatEntries: the adapter is created once at
-                // registration time (AddTargetedWithoutTargetingHandler,
-                // AddSourcedBroadcastWithoutSourceHandler, and their
-                // post-processor siblings).
-                if (entry.flatInvoker is FastHandlerWithContext<T> invoker)
+                private void SetInlineValue(int index, Entry value)
                 {
-                    target[writeIndex++] = new ContextFlatDispatchEntry<T>(this, invoker);
+                    if (index == 0)
+                    {
+                        _value0 = value;
+                        return;
+                    }
+                    _value1 = value;
                 }
-                else
+
+                private void ClearInline(int index)
                 {
-                    System.Diagnostics.Debug.Assert(
-                        false,
-                        "Default with-context registration is missing its "
-                            + "FastHandlerWithContext flat invoker; every without-context "
-                            + "Add* default path must adapt the augmented handler at "
-                            + "registration time."
-                    );
+                    SetInline(index, default, default);
                 }
-            }
 
-            return writeIndex;
-        }
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                private static void ThrowIfNull(T key)
+                {
+                    if (key is null)
+                    {
+                        throw new ArgumentNullException(nameof(key));
+                    }
+                }
+            }
 
-        internal sealed class HandlerActionCache<T> : DxMessaging.Core.Internal.IHandlerActionCache
-        {
             // Uses outer T as a field type -- reflection callers must close
             // via MakeGenericType(outer.GetGenericArguments()) before passing
             // this type to Activator.CreateInstance. See
@@ -2273,40 +2760,48 @@ 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;
             }
 
-            public readonly Dictionary<T, Entry> entries = new();
-
-            // Original-handler keys in first-registration order. Dictionary
-            // enumeration order is NOT stable across Remove/Add churn (.NET
-            // reuses freed slots LIFO), so dispatch snapshots are rebuilt from
-            // this list instead of from <see cref="entries"/> to honor the
-            // documented "same priority uses registration order" contract.
-            // Invariants: contains exactly the keys of <see cref="entries"/>;
-            // a key is appended on its FIRST registration only (refcount
-            // increments do not move it) and removed when its refcount drops
-            // to zero. Maintained exclusively by the AddHandler* family and
-            // <see cref="DxMessaging.Core.Internal.IHandlerActionCache.Reset"/>.
-            public readonly List<T> insertionOrder = new();
+            // The first two distinct handlers live directly in this object.
+            // The third materializes a dictionary plus an ordered key list;
+            // that spill remains allocated for reuse after removal or reset.
+            // Both representations preserve first-registration order and make
+            // entry/order drift structurally impossible.
+            public OrderedEntries entries;
             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
@@ -2333,7 +2828,7 @@ namespace DxMessaging.Core
                 set => lastSeenEmissionId = value;
             }
 
-            /// <summary>True iff the entries dictionary holds zero handlers.</summary>
+            /// <summary>True iff the ordered entry storage holds zero handlers.</summary>
             bool DxMessaging.Core.Internal.IHandlerActionCache.IsEmpty
             {
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -2347,15 +2842,75 @@ namespace DxMessaging.Core
             void DxMessaging.Core.Internal.IHandlerActionCache.Reset()
             {
                 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);
+                    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 +2941,197 @@ namespace DxMessaging.Core
 
             internal bool _markedForOuterRemoval;
 
+            /// <summary>
+            /// Reusable teardown state 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. Tokens embed this value
+            /// in their existing Registration object; compatibility callers can
+            /// convert it to an allocation-backed wrapper or <see cref="Action"/>.
+            /// </summary>
+            internal readonly struct TypedHandlerDeregistrationState
+            {
+                // 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 TypedHandlerDeregistrationState(
+                    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 TypedHandlerDeregistrationState(
+                    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 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.
+                }
+
+                public static implicit operator HandlerDeregistration(
+                    TypedHandlerDeregistrationState state
+                )
+                {
+                    return new TypedHandlerDeregistration(state);
+                }
+
+                public static implicit operator Action(TypedHandlerDeregistrationState state)
+                {
+                    TypedHandlerDeregistration deregistration = new(state);
+                    return deregistration.Deregister;
+                }
+            }
+
+            /// <summary>
+            /// Allocation-backed compatibility/spill wrapper. Token registrations keep
+            /// <see cref="TypedHandlerDeregistrationState"/> inline on their existing
+            /// registration object; direct handler callers and overlapping retry state
+            /// use this wrapper only when independent object identity is required.
+            /// </summary>
+            internal sealed class TypedHandlerDeregistration : HandlerDeregistration
+            {
+                private readonly TypedHandlerDeregistrationState _state;
+
+                internal TypedHandlerDeregistration(TypedHandlerDeregistrationState state)
+                {
+                    _state = state;
+                }
+
+                internal override void Deregister()
+                {
+                    _state.Deregister();
+                }
+            }
+
             int ITypedHandlerSlotSweeper.MessageTypeIndex
             {
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -3137,11 +3883,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 TypedHandlerDeregistrationState AddTargetedHandler(
                 InstanceId target,
                 Action<T> originalHandler,
                 Action<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3162,6 +3908,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 TypedHandlerDeregistrationState 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 +3945,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 TypedHandlerDeregistrationState AddTargetedHandler(
                 InstanceId target,
                 FastHandler<T> originalHandler,
                 FastHandler<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3197,10 +3972,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 TypedHandlerDeregistrationState AddTargetedWithoutTargetingHandler(
                 Action<InstanceId, T> originalHandler,
                 Action<InstanceId, T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3225,6 +4000,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 TypedHandlerDeregistrationState 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 +4037,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 TypedHandlerDeregistrationState AddTargetedWithoutTargetingHandler(
                 FastHandlerWithContext<T> originalHandler,
                 FastHandlerWithContext<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3254,31 +4059,63 @@ namespace DxMessaging.Core
             }
 
             /// <summary>
-            /// Adds a UntargetedHandler to listen to Messages of the given type, returning a deregistration action.
+            /// Adds a UntargetedHandler to listen to Messages of the given type, returning a deregistration action.
+            /// </summary>
+            /// <param name="handler">Relevant MessageHandler.</param>
+            /// <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 TypedHandlerDeregistrationState AddUntargetedHandler(
+                Action<T> originalHandler,
+                Action<T> handler,
+                MessageBusRegistration deregistration,
+                int priority,
+                IMessageBus messageBus
+            )
+            {
+                // Adapt the AUGMENTED handler to FastHandler form exactly once,
+                // at registration time, so bus-side flat snapshot rebuilds
+                // resolve default registrations without allocating closures.
+                FastHandler<T> flatInvoker = (ref T message) => handler(message);
+                return AddHandlerPreservingPriorityKey(
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.UntargetedHandleDefault,
+                        requiresContext: false
+                    ),
+                    originalHandler,
+                    handler,
+                    deregistration,
+                    priority,
+                    messageBus,
+                    flatInvoker
+                );
+            }
+
+            /// <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>
-            /// <param name="handler">Relevant MessageHandler.</param>
-            /// <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(
+            internal TypedHandlerDeregistrationState AddUntargetedHandler(
                 Action<T> originalHandler,
-                Action<T> handler,
-                Action deregistration,
+                FastHandler<T> flatInvoker,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
             {
-                // Adapt the AUGMENTED handler to FastHandler form exactly once,
-                // at registration time, so bus-side flat snapshot rebuilds
-                // resolve default registrations without allocating closures.
-                FastHandler<T> flatInvoker = (ref T message) => handler(message);
                 return AddHandlerPreservingPriorityKey(
                     GetOrCreatePriorityHandlers(
                         TypedSlotIndex.UntargetedHandleDefault,
                         requiresContext: false
                     ),
                     originalHandler,
-                    handler,
+                    originalHandler,
                     deregistration,
                     priority,
                     messageBus,
@@ -3293,10 +4130,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 TypedHandlerDeregistrationState AddUntargetedHandler(
                 FastHandler<T> originalHandler,
                 FastHandler<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3322,11 +4159,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 TypedHandlerDeregistrationState AddSourcedBroadcastHandler(
                 InstanceId source,
                 Action<T> originalHandler,
                 Action<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3347,6 +4184,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 TypedHandlerDeregistrationState 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 +4220,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 TypedHandlerDeregistrationState AddSourcedBroadcastHandler(
                 InstanceId source,
                 FastHandler<T> originalHandler,
                 FastHandler<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3382,10 +4247,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 TypedHandlerDeregistrationState AddSourcedBroadcastWithoutSourceHandler(
                 Action<InstanceId, T> originalHandler,
                 Action<InstanceId, T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3411,6 +4276,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 TypedHandlerDeregistrationState 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 +4314,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 TypedHandlerDeregistrationState AddSourcedBroadcastWithoutSourceHandler(
                 FastHandlerWithContext<T> originalHandler,
                 FastHandlerWithContext<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3444,12 +4340,10 @@ namespace DxMessaging.Core
             /// Adds a Global UntargetedHandler to listen to all Untargeted Messages of all types, returning the deregistration action.
             /// </summary>
             /// <param name="handler">Relevant MessageHandler.</param>
-            /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddGlobalUntargetedHandler(
+            public GlobalHandlerDeregistrationState AddGlobalUntargetedHandler(
                 Action<IUntargetedMessage> originalHandler,
                 Action<IUntargetedMessage> handler,
-                Action deregistration,
                 IMessageBus messageBus
             )
             {
@@ -3457,7 +4351,6 @@ namespace DxMessaging.Core
                     GetOrCreateGlobalSlot(TypedGlobalSlotIndex.UntargetedDefault),
                     originalHandler,
                     handler,
-                    deregistration,
                     messageBus
                 );
             }
@@ -3466,12 +4359,10 @@ namespace DxMessaging.Core
             /// Adds a Global fast UntargetedHandler to listen to all Untargeted Messages of all types, returning the deregistration action.
             /// </summary>
             /// <param name="handler">Relevant MessageHandler.</param>
-            /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddGlobalUntargetedHandler(
+            public GlobalHandlerDeregistrationState AddGlobalUntargetedHandler(
                 FastHandler<IUntargetedMessage> originalHandler,
                 FastHandler<IUntargetedMessage> handler,
-                Action deregistration,
                 IMessageBus messageBus
             )
             {
@@ -3479,7 +4370,6 @@ namespace DxMessaging.Core
                     GetOrCreateGlobalSlot(TypedGlobalSlotIndex.UntargetedFast),
                     originalHandler,
                     handler,
-                    deregistration,
                     messageBus
                 );
             }
@@ -3488,12 +4378,10 @@ namespace DxMessaging.Core
             /// Adds a Global TargetedHandler to listen to all Targeted Messages of all types for all entities, returning the deregistration action.
             /// </summary>
             /// <param name="handler">Relevant MessageHandler.</param>
-            /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddGlobalTargetedHandler(
+            public GlobalHandlerDeregistrationState AddGlobalTargetedHandler(
                 Action<InstanceId, ITargetedMessage> originalHandler,
                 Action<InstanceId, ITargetedMessage> handler,
-                Action deregistration,
                 IMessageBus messageBus
             )
             {
@@ -3501,7 +4389,6 @@ namespace DxMessaging.Core
                     GetOrCreateGlobalSlot(TypedGlobalSlotIndex.TargetedDefault),
                     originalHandler,
                     handler,
-                    deregistration,
                     messageBus
                 );
             }
@@ -3510,12 +4397,10 @@ namespace DxMessaging.Core
             /// Adds a Global fast TargetedHandler to listen to all Targeted Messages of all types for all entities (along with the target instance id), returning the deregistration action.
             /// </summary>
             /// <param name="handler">Relevant MessageHandler.</param>
-            /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddGlobalTargetedHandler(
+            public GlobalHandlerDeregistrationState AddGlobalTargetedHandler(
                 FastHandlerWithContext<ITargetedMessage> originalHandler,
                 FastHandlerWithContext<ITargetedMessage> handler,
-                Action deregistration,
                 IMessageBus messageBus
             )
             {
@@ -3523,7 +4408,6 @@ namespace DxMessaging.Core
                     GetOrCreateGlobalSlot(TypedGlobalSlotIndex.TargetedFast),
                     originalHandler,
                     handler,
-                    deregistration,
                     messageBus
                 );
             }
@@ -3532,12 +4416,10 @@ namespace DxMessaging.Core
             /// Adds a Global BroadcastHandler to listen to all Targeted Messages of all types for all entities, returning the deregistration action.
             /// </summary>
             /// <param name="handler">Relevant MessageHandler.</param>
-            /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddGlobalBroadcastHandler(
+            public GlobalHandlerDeregistrationState AddGlobalBroadcastHandler(
                 Action<InstanceId, IBroadcastMessage> originalHandler,
                 Action<InstanceId, IBroadcastMessage> handler,
-                Action deregistration,
                 IMessageBus messageBus
             )
             {
@@ -3545,7 +4427,6 @@ namespace DxMessaging.Core
                     GetOrCreateGlobalSlot(TypedGlobalSlotIndex.BroadcastDefault),
                     originalHandler,
                     handler,
-                    deregistration,
                     messageBus
                 );
             }
@@ -3554,12 +4435,10 @@ namespace DxMessaging.Core
             /// Adds a Global fast BroadcastHandler to listen to all Targeted Messages of all types for all entities (along with the source instance id), returning the deregistration action.
             /// </summary>
             /// <param name="handler">Relevant MessageHandler.</param>
-            /// <param name="deregistration">Deregistration action for the handler.</param>
             /// <returns>De-registration action to unregister the handler.</returns>
-            public Action AddGlobalBroadcastHandler(
+            public GlobalHandlerDeregistrationState AddGlobalBroadcastHandler(
                 FastHandlerWithContext<IBroadcastMessage> originalHandler,
                 FastHandlerWithContext<IBroadcastMessage> handler,
-                Action deregistration,
                 IMessageBus messageBus
             )
             {
@@ -3567,7 +4446,6 @@ namespace DxMessaging.Core
                     GetOrCreateGlobalSlot(TypedGlobalSlotIndex.BroadcastFast),
                     originalHandler,
                     handler,
-                    deregistration,
                     messageBus
                 );
             }
@@ -3579,10 +4457,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 TypedHandlerDeregistrationState AddUntargetedPostProcessor(
                 Action<T> originalHandler,
                 Action<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3612,10 +4490,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 TypedHandlerDeregistrationState AddUntargetedPostProcessor(
                 FastHandler<T> originalHandler,
                 FastHandler<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3641,11 +4519,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 TypedHandlerDeregistrationState AddTargetedPostProcessor(
                 InstanceId target,
                 Action<T> originalHandler,
                 Action<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3666,6 +4544,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 TypedHandlerDeregistrationState 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 +4581,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 TypedHandlerDeregistrationState AddTargetedPostProcessor(
                 InstanceId target,
                 FastHandler<T> originalHandler,
                 FastHandler<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3701,10 +4608,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 TypedHandlerDeregistrationState AddTargetedWithoutTargetingPostProcessor(
                 Action<InstanceId, T> originalHandler,
                 Action<InstanceId, T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3729,6 +4636,38 @@ namespace DxMessaging.Core
                 );
             }
 
+            /// <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 TypedHandlerDeregistrationState 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,
+                    flatInvoker
+                );
+            }
+
             /// <summary>
             /// Adds a Targeted post-processor to be called after all other handlers have been called after every message of the given type.
             /// </summary>
@@ -3736,10 +4675,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 TypedHandlerDeregistrationState AddTargetedWithoutTargetingPostProcessor(
                 FastHandlerWithContext<T> originalHandler,
                 FastHandlerWithContext<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3765,11 +4704,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 TypedHandlerDeregistrationState AddBroadcastPostProcessor(
                 InstanceId source,
                 Action<T> originalHandler,
                 Action<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3790,6 +4729,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 TypedHandlerDeregistrationState 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 +4766,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 TypedHandlerDeregistrationState AddBroadcastPostProcessor(
                 InstanceId source,
                 FastHandler<T> originalHandler,
                 FastHandler<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3825,10 +4793,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 TypedHandlerDeregistrationState AddBroadcastWithoutSourcePostProcessor(
                 Action<InstanceId, T> originalHandler,
                 Action<InstanceId, T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3853,6 +4821,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 TypedHandlerDeregistrationState 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 +4859,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 TypedHandlerDeregistrationState AddBroadcastWithoutSourcePostProcessor(
                 FastHandlerWithContext<T> originalHandler,
                 FastHandlerWithContext<T> handler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus
             )
@@ -3900,12 +4899,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 TypedHandlerDeregistrationState 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
@@ -3926,141 +4925,67 @@ namespace DxMessaging.Core
                     !sortedHandlers.TryGetValue(priority, out IHandlerActionCache erasedCache)
                     || erasedCache is not HandlerActionCache<TU> cache
                 )
-                {
-                    cache = new HandlerActionCache<TU>();
-                    sortedHandlers[priority] = cache;
-                }
-
-                if (
-                    !cache.entries.TryGetValue(
-                        originalHandler,
-                        out HandlerActionCache<TU>.Entry entry
-                    )
-                )
-                {
-                    entry = new HandlerActionCache<TU>.Entry(augmentedHandler, 0);
-                }
-
-                bool firstRegistration = entry.count == 0;
-                entry = firstRegistration
-                    ? new HandlerActionCache<TU>.Entry(augmentedHandler, 1, flatInvoker)
-                    : new HandlerActionCache<TU>.Entry(
-                        entry.handler,
-                        entry.count + 1,
-                        entry.flatInvoker
-                    );
-
-                cache.entries[originalHandler] = entry;
-                if (firstRegistration)
-                {
-                    cache.insertionOrder.Add(originalHandler);
-                }
-                cache.version++;
-                TypedSlot<T> slot = FindContextSlot(handlersByContext);
-                if (slot != null)
-                {
-                    slot.lastTouchTicks =
-                        global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(
-                            messageBus
-                        );
-                }
-                if (firstRegistration && slot != null)
-                {
-                    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;
-                    }
+                {
+                    cache = new HandlerActionCache<TU>();
+                    sortedHandlers[priority] = cache;
+                }
 
-                    localCache.version++;
+                if (
+                    !cache.entries.TryGetValue(
+                        originalHandler,
+                        out HandlerActionCache<TU>.Entry entry
+                    )
+                )
+                {
+                    entry = new HandlerActionCache<TU>.Entry(augmentedHandler, 0);
+                }
 
-                    deregistration?.Invoke();
-                    if (localSlot != null)
-                    {
-                        localSlot.lastTouchTicks =
-                            global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(
-                                messageBus
-                            );
-                    }
+                bool firstRegistration = entry.count == 0;
+                entry = firstRegistration
+                    ? new HandlerActionCache<TU>.Entry(augmentedHandler, 1, flatInvoker)
+                    : new HandlerActionCache<TU>.Entry(
+                        entry.handler,
+                        entry.count + 1,
+                        entry.flatInvoker
+                    );
 
-                    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;
-                    }
+                cache.entries[originalHandler] = entry;
+                cache.version++;
+                TypedSlot<T> slot = FindContextSlot(handlersByContext);
+                if (slot != null)
+                {
+                    slot.lastTouchTicks =
+                        global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(
+                            messageBus
+                        );
+                }
+                if (firstRegistration && slot != null)
+                {
+                    slot.liveCount++;
+                }
 
-                    localEntry = new HandlerActionCache<TU>.Entry(
-                        localEntry.handler,
-                        localEntry.count - 1,
-                        localEntry.flatInvoker
-                    );
+                long localSlotVersion = slot?.version ?? 0;
+                long localResetGeneration =
+                    global::DxMessaging.Core.MessageBus.MessageBus.GetResetGeneration(messageBus);
 
-                    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 TypedHandlerDeregistrationState(
+                    messageBus,
+                    localResetGeneration,
+                    slot,
+                    localSlotVersion,
+                    handlersByContext,
+                    context,
+                    originalHandler,
+                    priority,
+                    in deregistration
+                );
             }
 
             private static Action AddHandlerPreservingPriorityKey<TU>(
@@ -4112,10 +5037,6 @@ namespace DxMessaging.Core
                     : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
 
                 cache.entries[originalHandler] = entry;
-                if (firstRegistration)
-                {
-                    cache.insertionOrder.Add(originalHandler);
-                }
                 cache.version++;
 
                 Dictionary<
@@ -4154,7 +5075,6 @@ namespace DxMessaging.Core
                     if (localEntry.count <= 1)
                     {
                         _ = localCache.entries.Remove(originalHandler);
-                        _ = localCache.insertionOrder.Remove(originalHandler);
                         localCache.version++;
                         // Deliberately keep the priority and context mappings to preserve
                         // frozen snapshots for the current emission.
@@ -4485,7 +5405,7 @@ namespace DxMessaging.Core
                 where TMessage : IMessage
                 where TU : IMessage
             {
-                // Snapshot semantics: do not bail on the live entries dictionary
+                // Snapshot semantics: do not bail on the live entry storage
                 // count. A mid-emit removal can drain entries while the pinned
                 // emission snapshot in cache.cache still holds the handlers we
                 // must invoke. Read the snapshot first and bail only if the
@@ -4493,13 +5413,13 @@ namespace DxMessaging.Core
                 //
                 // Perf note: GetOrAddNewHandlerStack is now invoked on every
                 // call (including for empty caches that the previous fast-path
-                // would have skipped). The cost is one dictionary
+                // would have skipped). The cost is one
                 // emission-id/version compare and -- only when the per-emission
                 // snapshot has not been pinned yet -- a single pass over
                 // cache.entries to materialise an empty list. The win is
                 // correctness across cross-handler mid-emit removals where the
                 // pinned snapshot in cache.cache still holds handlers the live
-                // entries dictionary no longer reaches.
+                // entry storage no longer reaches.
                 if (cache == null)
                 {
                     return;
@@ -4608,7 +5528,7 @@ namespace DxMessaging.Core
             {
                 // Snapshot semantics: see comment on the FastHandler<TU> overload.
                 // The pinned emission snapshot may still hold handlers even when
-                // the live entries dictionary has been drained mid-emit.
+                // the live entry storage has been drained mid-emit.
                 if (cache == null)
                 {
                     return;
@@ -4946,91 +5866,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 +5975,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 +6088,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 +6203,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);
                 }
             }
 
@@ -5383,34 +6309,19 @@ namespace DxMessaging.Core
                 long emissionId
             )
             {
-                DebugAssertInsertionOrderInSync(actionCache);
                 if (actionCache.lastSeenEmissionId != emissionId)
                 {
                     if (actionCache.version != actionCache.lastSeenVersion)
                     {
-                        // Rebuild the dispatch snapshot from insertionOrder, NOT from
-                        // the entries dictionary: dictionary enumeration order permutes
-                        // after Remove/Add churn (freed slots are reused LIFO), while
-                        // insertionOrder preserves the documented first-registration
-                        // order for equal-priority handlers. This branch only runs on
-                        // registration churn (version bump), never on steady-state
-                        // dispatch, and allocates nothing (the pooled cache list is
-                        // cleared and refilled in place).
+                        // Rebuild in the ordered map's first-registration order.
+                        // This branch only runs on registration churn, never on
+                        // steady-state dispatch, and reuses the snapshot list.
                         List<TU> list = actionCache.cache;
                         list.Clear();
-                        List<TU> orderedHandlers = actionCache.insertionOrder;
-                        int orderedCount = orderedHandlers.Count;
+                        int orderedCount = actionCache.entries.Count;
                         for (int i = 0; i < orderedCount; ++i)
                         {
-                            if (
-                                actionCache.entries.TryGetValue(
-                                    orderedHandlers[i],
-                                    out HandlerActionCache<TU>.Entry entry
-                                )
-                            )
-                            {
-                                list.Add(entry.handler);
-                            }
+                            list.Add(actionCache.entries.ValueAt(i).handler);
                         }
                         actionCache.lastSeenVersion = actionCache.version;
                     }
@@ -5419,32 +6330,57 @@ namespace DxMessaging.Core
                 return actionCache.cache;
             }
 
-            // 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
-            // mirror the change into insertionOrder (AddHandler* family,
-            // deregistration closures, IHandlerActionCache.Reset). Stripped
-            // in Release builds via [Conditional("DEBUG")] -- zero hot-path
-            // cost.
-            [Conditional("DEBUG")]
-            private static void DebugAssertInsertionOrderInSync<TU>(
-                HandlerActionCache<TU> actionCache
+            // 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
             {
-                System.Diagnostics.Debug.Assert(
-                    actionCache.insertionOrder.Count == actionCache.entries.Count,
-                    "HandlerActionCache.insertionOrder must mirror entries: every first "
-                        + "registration appends and every final deregistration removes. A "
-                        + "count mismatch means a mutation site skipped the insertionOrder "
-                        + "update and same-priority dispatch order is no longer trustworthy."
-                );
+                if (actionCache.flatInvokerLastSeenEmissionId != emissionId)
+                {
+                    if (actionCache.version != actionCache.flatInvokerLastSeenVersion)
+                    {
+                        List<TInvoker> list = actionCache.GetOrCreateFlatInvokerCache<TInvoker>();
+                        list.Clear();
+                        int orderedCount = actionCache.entries.Count;
+                        for (int i = 0; i < orderedCount; ++i)
+                        {
+                            HandlerActionCache<TU>.Entry entry = actionCache.entries.ValueAt(i);
+
+                            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>();
             }
 
-            private static Action AddHandler<TU>(
+            private static GlobalHandlerDeregistrationState AddHandler<TU>(
                 TypedGlobalSlot slot,
                 TU originalHandler,
                 TU augmentedHandler,
-                Action deregistration,
                 IMessageBus messageBus
             )
             {
@@ -5473,72 +6409,24 @@ namespace DxMessaging.Core
                     : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
 
                 cache.entries[originalHandler] = entry;
-                if (firstRegistration)
-                {
-                    cache.insertionOrder.Add(originalHandler);
-                }
                 cache.version++;
                 if (firstRegistration)
                 {
                     slot.liveCount++;
                 }
 
-                HandlerActionCache<TU> localCache = cache;
-                TypedGlobalSlot localSlot = slot;
                 long localSlotVersion = slot.version;
                 long localResetGeneration =
                     global::DxMessaging.Core.MessageBus.MessageBus.GetResetGeneration(messageBus);
 
-                return () =>
-                {
-                    if (
-                        !global::DxMessaging.Core.MessageBus.MessageBus.IsResetGenerationCurrent(
-                            messageBus,
-                            localResetGeneration
-                        )
-                    )
-                    {
-                        return;
-                    }
-
-                    if (localSlot.version != localSlotVersion)
-                    {
-                        return;
-                    }
-
-                    if (
-                        !localCache.entries.TryGetValue(
-                            originalHandler,
-                            out HandlerActionCache<TU>.Entry localEntry
-                        )
-                    )
-                    {
-                        return;
-                    }
-
-                    localCache.version++;
-
-                    deregistration?.Invoke();
-                    localSlot.lastTouchTicks =
-                        global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(
-                            messageBus
-                        );
-
-                    if (localEntry.count <= 1)
-                    {
-                        _ = localCache.entries.Remove(originalHandler);
-                        _ = localCache.insertionOrder.Remove(originalHandler);
-                        localCache.version++;
-                        localSlot.liveCount--;
-                        return;
-                    }
-
-                    localEntry = new HandlerActionCache<TU>.Entry(
-                        localEntry.handler,
-                        localEntry.count - 1
-                    );
-                    localCache.entries[originalHandler] = localEntry;
-                };
+                return new GlobalHandlerDeregistrationState(
+                    messageBus,
+                    localResetGeneration,
+                    slot,
+                    localSlotVersion,
+                    cache,
+                    originalHandler
+                );
             }
 
             private static Action AddHandler<TU>(
@@ -5590,10 +6478,6 @@ namespace DxMessaging.Core
                     : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
 
                 cache.entries[originalHandler] = entry;
-                if (firstRegistration)
-                {
-                    cache.insertionOrder.Add(originalHandler);
-                }
                 cache.version++;
 
                 Dictionary<
@@ -5632,7 +6516,6 @@ namespace DxMessaging.Core
                     if (localEntry.count <= 1)
                     {
                         _ = localCache.entries.Remove(originalHandler);
-                        _ = localCache.insertionOrder.Remove(originalHandler);
                         localCache.version++;
                         if (localCache.entries.Count == 0)
                         {
@@ -5680,10 +6563,6 @@ namespace DxMessaging.Core
                     : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
 
                 cache.entries[originalHandler] = entry;
-                if (firstRegistration)
-                {
-                    cache.insertionOrder.Add(originalHandler);
-                }
                 cache.version++;
 
                 HandlerActionCache<TU> localCache = cache;
@@ -5707,7 +6586,6 @@ namespace DxMessaging.Core
                     if (localEntry.count <= 1)
                     {
                         _ = localCache.entries.Remove(originalHandler);
-                        _ = localCache.insertionOrder.Remove(originalHandler);
                         localCache.version++;
                         return;
                     }
@@ -5753,10 +6631,6 @@ namespace DxMessaging.Core
                     : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
 
                 cache.entries[originalHandler] = entry;
-                if (firstRegistration)
-                {
-                    cache.insertionOrder.Add(originalHandler);
-                }
                 cache.version++;
 
                 Dictionary<int, HandlerActionCache<TU>> localHandlers = handlers;
@@ -5785,7 +6659,6 @@ namespace DxMessaging.Core
                     if (localEntry.count <= 1)
                     {
                         _ = localCache.entries.Remove(originalHandler);
-                        _ = localCache.insertionOrder.Remove(originalHandler);
                         localCache.version++;
                         if (localCache.entries.Count == 0)
                         {
@@ -5810,11 +6683,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 TypedHandlerDeregistrationState AddHandlerPreservingPriorityKey<TU>(
                 Dictionary<int, IHandlerActionCache> handlers,
                 TU originalHandler,
                 TU augmentedHandler,
-                Action deregistration,
+                MessageBusRegistration deregistration,
                 int priority,
                 IMessageBus messageBus,
                 object flatInvoker = null
@@ -5849,10 +6722,6 @@ namespace DxMessaging.Core
                     );
 
                 cache.entries[originalHandler] = entry;
-                if (firstRegistration)
-                {
-                    cache.insertionOrder.Add(originalHandler);
-                }
                 cache.version++;
                 TypedSlot<T> slot = FindPrioritySlot(handlers);
                 if (slot != null)
@@ -5871,82 +6740,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 TypedHandlerDeregistrationState(
+                    messageBus,
+                    localResetGeneration,
+                    slot,
+                    localSlotVersion,
+                    handlers,
+                    originalHandler,
+                    priority,
+                    in deregistration
+                );
             }
 
             private static Action AddHandlerPreservingPriorityKey<TU>(
@@ -5982,10 +6791,6 @@ namespace DxMessaging.Core
                     : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
 
                 cache.entries[originalHandler] = entry;
-                if (firstRegistration)
-                {
-                    cache.insertionOrder.Add(originalHandler);
-                }
                 cache.version++;
 
                 Dictionary<int, HandlerActionCache<TU>> localHandlers = handlers;
@@ -6014,7 +6819,6 @@ namespace DxMessaging.Core
                     if (localEntry.count <= 1)
                     {
                         _ = localCache.entries.Remove(originalHandler);
-                        _ = localCache.insertionOrder.Remove(originalHandler);
                         localCache.version++;
                         // Intentionally DO NOT remove the priority key here to preserve
                         // the cache handle during an in-flight emission.