MessageHandler.cs

namespace DxMessaging.Core
{
    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Runtime.CompilerServices;
    using DxMessaging.Core.Internal;
    using Helper;
    using MessageBus;
    using Messages;
    using Pooling;

    /// <summary>
    /// Per-owner handler that executes registered message callbacks.
    /// </summary>
    /// <remarks>
    /// A <see cref="MessageHandler"/> is typically created and managed by <see cref="Unity.MessagingComponent"/> in Unity.
    /// Most user code interacts with the handler through <see cref="MessageRegistrationToken"/>, which stages
    /// registrations and ensures correct enable/disable lifecycles.
    /// </remarks>
    /// <example>
    /// <code>
    /// // Plain .NET usage without Unity
    /// var owner = new DxMessaging.Core.InstanceId(1);
    /// var handler = new DxMessaging.Core.MessageHandler(owner) { active = true };
    /// var token = DxMessaging.Core.MessageRegistrationToken.Create(handler);
    /// _ = token.RegisterUntargeted&lt;WorldRegenerated&gt;((ref WorldRegenerated m) =&gt; Console.WriteLine(m.seed));
    /// token.Enable();
    ///
    /// var bus = DxMessaging.Core.MessageHandler.MessageBus;
    /// var msg = new WorldRegenerated(42);
    /// bus.UntargetedBroadcast(ref msg);
    /// </code>
    /// </example>
    public sealed class MessageHandler
        : IEquatable<MessageHandler>,
            IComparable,
            IComparable<MessageHandler>
    {
        /// <summary>
        /// High-performance handler that receives the message by reference (no boxing/copies).
        /// </summary>
        public delegate void FastHandler<TMessage>(ref TMessage message)
            where TMessage : IMessage;

        /// <summary>
        /// High-performance handler with an additional context value (e.g., target/source) by reference.
        /// </summary>
        public delegate void FastHandlerWithContext<TMessage>(
            ref InstanceId context,
            ref TMessage message
        )
            where TMessage : IMessage;

        private static readonly object GlobalResetLock = new object();

        /// <summary>
        /// Global message bus used when no explicit bus is provided.
        /// </summary>
        private static IMessageBus _globalMessageBus;

        private static MessageBus.MessageBus _defaultGlobalMessageBus = new MessageBus.MessageBus();

        /// <summary>
        /// Gets the process-wide <see cref="IMessageBus"/> used when no explicit bus is supplied.
        /// </summary>
        /// <remarks>
        /// This mirrors the legacy singleton so existing code continues to function. Use
        /// <see cref="SetGlobalMessageBus(Core.MessageBus.MessageBus)"/> to replace the instance (for example from a DI container) and
        /// <see cref="ResetGlobalMessageBus"/> to restore the stock configuration afterwards.
        /// </remarks>
        public static IMessageBus MessageBus => _globalMessageBus;

        /// <summary>
        /// Gets the baseline global <see cref="IMessageBus"/> instance used when no custom bus is configured.
        /// </summary>
        /// <remarks>
        /// The instance is recreated when <see cref="DxMessagingStaticState.Reset"/> runs so that domain-reload-disabled
        /// environments can obtain a clean slate.
        /// </remarks>
        public static IMessageBus InitialGlobalMessageBus => _defaultGlobalMessageBus;

        static MessageHandler()
        {
            ResetStatics();
        }

        /// <summary>
        /// Reclaims empty slots and pooled collections owned by the current global message bus.
        /// </summary>
        /// <param name="force">
        /// When true, ignores idle-age thresholds and drains shared pools to zero.
        /// When false, only slots past the configured idle threshold are eligible.
        /// </param>
        /// <returns>Counts describing what was reclaimed.</returns>
        public static IMessageBus.TrimResult TrimAll(bool force = false)
        {
            return MessageBus.Trim(force);
        }

        /// <summary>
        /// Replaces the global <see cref="Core.MessageBus.MessageBus"/> instance returned by <see cref="MessageBus"/>.
        /// </summary>
        /// <param name="messageBus">Instance to expose globally.</param>
        /// <exception cref="ArgumentNullException">
        /// Thrown when <paramref name="messageBus"/> is <see langword="null"/>.
        /// </exception>
        /// <remarks>
        /// This is primarily intended for integration tests or dependency injection bootstrap code. Invoke
        /// <see cref="ResetGlobalMessageBus"/> when the customisation is no longer required.
        /// </remarks>
        public static void SetGlobalMessageBus(MessageBus.MessageBus messageBus)
        {
            if (messageBus == null)
            {
                throw new ArgumentNullException(nameof(messageBus));
            }

            _globalMessageBus = messageBus;
        }

        /// <summary>
        /// Replaces the global message bus with an arbitrary <see cref="IMessageBus"/> implementation.
        /// </summary>
        /// <param name="messageBus">Instance to expose globally.</param>
        /// <exception cref="ArgumentNullException">
        /// Thrown when <paramref name="messageBus"/> is <see langword="null"/>.
        /// </exception>
        public static void SetGlobalMessageBus(IMessageBus messageBus)
        {
            if (messageBus == null)
            {
                throw new ArgumentNullException(nameof(messageBus));
            }

            _globalMessageBus = messageBus;
        }

        /// <summary>
        /// Restores the global <see cref="Core.MessageBus.MessageBus"/> to the built-in default instance.
        /// </summary>
        /// <remarks>
        /// The default instance is recreated by <see cref="ResetStatics"/> when the static state reset utility runs.
        /// </remarks>
        public static void ResetGlobalMessageBus()
        {
            lock (GlobalResetLock)
            {
                _globalMessageBus = _defaultGlobalMessageBus;
            }
        }

        /// <summary>
        /// Temporarily overrides the global message bus until the returned scope is disposed.
        /// </summary>
        /// <param name="messageBus">Message bus to expose for the duration of the scope.</param>
        /// <returns>An <see cref="IDisposable"/> scope that restores the previous bus on dispose.</returns>
        public static GlobalMessageBusScope OverrideGlobalMessageBus(IMessageBus messageBus)
        {
            return new GlobalMessageBusScope(messageBus);
        }

        /// <summary>
        /// Recreates the built-in global <see cref="Core.MessageBus.MessageBus"/> and assigns it as the active global bus.
        /// </summary>
        /// <remarks>
        /// Invoked by <see cref="DxMessagingStaticState.Reset"/> to provide a clean slate when domain reloads are disabled.
        /// </remarks>
        internal static void ResetStatics()
        {
            lock (GlobalResetLock)
            {
                _defaultGlobalMessageBus.ResetState();
                _globalMessageBus = _defaultGlobalMessageBus;
            }
        }

        /// <summary>
        /// Represents a disposable override scope for the global message bus.
        /// </summary>
        public struct GlobalMessageBusScope : IDisposable
        {
            private readonly IMessageBus _previous;
            private bool _disposed;

            internal GlobalMessageBusScope(IMessageBus messageBus)
            {
                if (messageBus == null)
                {
                    throw new ArgumentNullException(nameof(messageBus));
                }

                _previous = MessageBus;
                _disposed = false;

                if (messageBus is MessageBus.MessageBus concrete)
                {
                    SetGlobalMessageBus(concrete);
                }
                else
                {
                    SetGlobalMessageBus(messageBus);
                }
            }

            /// <summary>
            /// Restores the previously active global message bus when the scope ends.
            /// </summary>
            public void Dispose()
            {
                if (_disposed)
                {
                    return;
                }

                if (_previous is MessageBus.MessageBus concrete)
                {
                    SetGlobalMessageBus(concrete);
                }
                else if (_previous != null)
                {
                    SetGlobalMessageBus(_previous);
                }
                else
                {
                    ResetGlobalMessageBus();
                }

                _disposed = true;
            }
        }

        /// <summary>
        /// Whether this MessageHandler will process messages.
        /// </summary>
        public bool active;

        /// <summary>
        /// The Id of the GameObject that owns us.
        /// </summary>
        public readonly InstanceId owner;

        /// <summary>
        /// Maps Types to the corresponding Handler of that type.
        /// </summary>
        /// <note>
        /// Ideally, this would be something like a Dictionary[T, Handler[T]], but that can't be done with C#s type system.
        /// </note>
        internal readonly List<MessageCache<object>> _handlersByTypeByMessageBus;
        private IMessageBus _defaultMessageBus;

        /// <summary>
        /// Gets the <see cref="IMessageBus"/> that will be used when a registration does not specify one explicitly.
        /// </summary>
        /// <remarks>
        /// When no override has been provided via <see cref="SetDefaultMessageBus"/>, this value defers to the global
        /// <see cref="MessageBus"/> singleton.
        /// </remarks>
        public IMessageBus DefaultMessageBus => _defaultMessageBus ?? MessageBus;

        /// <summary>
        /// Initializes a message handler bound to the specified owner and optional default bus.
        /// </summary>
        /// <param name="owner">Identity of the object that owns this handler.</param>
        /// <param name="defaultMessageBus">
        /// Preferred bus to use when registrations do not specify one. Falls back to
        /// <see cref="MessageBus"/> if omitted.
        /// </param>
        public MessageHandler(InstanceId owner, IMessageBus defaultMessageBus = null)
        {
            this.owner = owner;
            _handlersByTypeByMessageBus = new List<MessageCache<object>>();
            _defaultMessageBus = defaultMessageBus;
        }

        /// <summary>
        /// Assigns an <see cref="IMessageBus"/> for registrations that omit an explicit bus parameter.
        /// </summary>
        /// <param name="messageBus">
        /// Bus to use; pass <see langword="null"/> to revert to the global <see cref="MessageBus"/> singleton.
        /// </param>
        /// <remarks>
        /// This allows a handler to participate in dependency injection scenarios without forcing every caller to supply
        /// a bus manually.
        /// </remarks>
        public void SetDefaultMessageBus(IMessageBus messageBus)
        {
            _defaultMessageBus = messageBus;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private IMessageBus ResolveMessageBus(IMessageBus messageBus)
        {
            return messageBus ?? _defaultMessageBus ?? MessageBus;
        }

        /// <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="message">Message to handle.</param>
        /// <param name="messageBus">The specific MessageBus to use.</param>
        internal void HandleGlobalUntargetedMessage(
            ref IUntargetedMessage message,
            IMessageBus messageBus
        )
        {
            if (!active)
            {
                return;
            }

            // 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.HandleGlobalUntargeted(ref message, emissionId);
            }
        }

        /// <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))
            {
                return;
            }

            HandlerActionCache<FastHandler<IUntargetedMessage>> fastCache = handler.GetGlobalCache<
                FastHandler<IUntargetedMessage>
            >(TypedGlobalSlotIndex.UntargetedFast);
            if (fastCache != null)
            {
                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(fastCache, emissionId);
            }
            HandlerActionCache<Action<IUntargetedMessage>> cache = handler.GetGlobalCache<
                Action<IUntargetedMessage>
            >(TypedGlobalSlotIndex.UntargetedDefault);
            if (cache != null)
            {
                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(cache, emissionId);
            }
        }

        /// <summary>
        /// Pre-freezes this handler's GlobalAcceptAll targeted caches for this emission.
        /// </summary>
        internal void PrefreezeGlobalTargetedForEmission(long emissionId, IMessageBus messageBus)
        {
            if (!GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
            {
                return;
            }

            HandlerActionCache<FastHandlerWithContext<ITargetedMessage>> fastCache =
                handler.GetGlobalCache<FastHandlerWithContext<ITargetedMessage>>(
                    TypedGlobalSlotIndex.TargetedFast
                );
            if (fastCache != null)
            {
                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(fastCache, emissionId);
            }
            HandlerActionCache<Action<InstanceId, ITargetedMessage>> cache = handler.GetGlobalCache<
                Action<InstanceId, ITargetedMessage>
            >(TypedGlobalSlotIndex.TargetedDefault);
            if (cache != null)
            {
                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(cache, emissionId);
            }
        }

        /// <summary>
        /// Pre-freezes this handler's GlobalAcceptAll broadcast caches for this emission.
        /// </summary>
        internal void PrefreezeGlobalBroadcastForEmission(long emissionId, IMessageBus messageBus)
        {
            if (!GetHandlerForType(messageBus, out TypedHandler<IMessage> handler))
            {
                return;
            }

            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)
            {
                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(cache, emissionId);
            }
        }

        /// <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="target">Target of the message.</param>
        /// <param name="message">Message to handle.</param>
        /// <param name="messageBus">The specific MessageBus to use.</param>
        internal void HandleGlobalTargetedMessage(
            ref InstanceId target,
            ref ITargetedMessage message,
            IMessageBus messageBus
        )
        {
            if (!active)
            {
                return;
            }

            // 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.HandleGlobalTargeted(ref target, ref message, emissionId);
            }
        }

        /// <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>
        internal void HandleGlobalSourcedBroadcastMessage(
            ref InstanceId source,
            ref IBroadcastMessage message,
            IMessageBus messageBus
        )
        {
            if (!active)
            {
                return;
            }

            // 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.HandleGlobalBroadcast(ref source, ref message, emissionId);
            }
        }

        /// <summary>
        /// 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>
        /// <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
        {
            internal abstract void Deregister();

            public static implicit operator Action(HandlerDeregistration deregistration)
            {
                return deregistration == null ? null : deregistration.Deregister;
            }
        }

        /// <summary>
        /// Teardown for the interceptor facades: the bus-side registration is
        /// the only thing to undo (there is no typed-handler cache entry).
        /// Mirrors the old <c>() =&gt; messageBus.Deregister&lt;T&gt;(in registration)</c>.
        /// </summary>
        internal readonly struct InterceptorDeregistrationState<T>
            where T : IMessage
        {
            private readonly IMessageBus _messageBus;
            private readonly MessageBusRegistration _registration;

            internal InterceptorDeregistrationState(
                IMessageBus messageBus,
                in MessageBusRegistration registration
            )
            {
                _messageBus = messageBus;
                _registration = registration;
            }

            internal void Deregister()
            {
                _messageBus.Deregister<T>(in _registration);
            }

            public static implicit operator HandlerDeregistration(
                InterceptorDeregistrationState<T> state
            )
            {
                return new InterceptorDeregistration<T>(state);
            }

            public static implicit operator Action(InterceptorDeregistrationState<T> state)
            {
                InterceptorDeregistration<T> deregistration = new(state);
                return deregistration.Deregister;
            }
        }

        internal sealed class InterceptorDeregistration<T> : HandlerDeregistration
            where T : IMessage
        {
            private readonly InterceptorDeregistrationState<T> _state;

            internal InterceptorDeregistration(InterceptorDeregistrationState<T> state)
            {
                _state = state;
            }

            internal override void Deregister()
            {
                _state.Deregister();
            }
        }

        /// <summary>
        /// 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 readonly struct GlobalHandlerDeregistrationState
        {
            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
            )
            {
                _messageBus = messageBus;
                _resetGeneration = resetGeneration;
                _slot = slot;
                _slotVersion = slotVersion;
                _cache = cache;
                _originalHandler = originalHandler;
            }

            internal void Deregister()
            {
                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>
        /// Composite teardown for the global accept-all registration: undoes the
        /// bus-side global registration then the three typed sub-handler
        /// deregistrations, preserving the exact order of the old closure
        /// (<c>messageBus.Deregister&lt;IMessage&gt;(...); untargeted(); targeted(); broadcast();</c>).
        /// </summary>
        internal readonly struct GlobalAcceptAllDeregistrationState
        {
            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
            )
            {
                _messageBus = messageBus;
                _messageBusRegistration = messageBusRegistration;
                _untargetedDeregistration = untargetedDeregistration;
                _targetedDeregistration = targetedDeregistration;
                _broadcastDeregistration = broadcastDeregistration;
            }

            internal void Deregister()
            {
                _messageBus.Deregister<IMessage>(in _messageBusRegistration);
                _untargetedDeregistration.Deregister();
                _targetedDeregistration.Deregister();
                _broadcastDeregistration.Deregister();
            }

            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
        {
            private readonly GlobalAcceptAllDeregistrationState _state;

            internal GlobalAcceptAllDeregistration(GlobalAcceptAllDeregistrationState state)
            {
                _state = state;
            }

            internal override void Deregister()
            {
                _state.Deregister();
            }
        }

        /// <summary>
        /// Registers this MessageHandler to Globally Accept All Messages via the MessageBus, properly handling deregistration.
        /// </summary>
        /// <param name="untargetedMessageHandler">MessageHandler to accept all UntargetedMessages.</param>
        /// <param name="broadcastMessageHandler">MessageHandler to accept all TargetedMessages for all entities.</param>
        /// <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>
        internal GlobalAcceptAllDeregistrationState RegisterGlobalAcceptAll(
            Action<IUntargetedMessage> originalUntargetedMessageHandler,
            Action<IUntargetedMessage> untargetedMessageHandler,
            Action<InstanceId, ITargetedMessage> originalTargetedMessageHandler,
            Action<InstanceId, ITargetedMessage> targetedMessageHandler,
            Action<InstanceId, IBroadcastMessage> originalBroadcastMessageHandler,
            Action<InstanceId, IBroadcastMessage> broadcastMessageHandler,
            IMessageBus messageBus = null
        )
        {
            messageBus = ResolveMessageBus(messageBus);
            MessageBusRegistration messageBusDeregistration = messageBus.RegisterGlobalAcceptAll(
                this
            );
            TypedHandler<IMessage> typedHandler = GetOrCreateHandlerForType<IMessage>(messageBus);

            GlobalHandlerDeregistrationState untargetedDeregistration =
                typedHandler.AddGlobalUntargetedHandler(
                    originalUntargetedMessageHandler,
                    untargetedMessageHandler,
                    messageBus
                );
            GlobalHandlerDeregistrationState targetedDeregistration =
                typedHandler.AddGlobalTargetedHandler(
                    originalTargetedMessageHandler,
                    targetedMessageHandler,
                    messageBus
                );
            GlobalHandlerDeregistrationState broadcastDeregistration =
                typedHandler.AddGlobalBroadcastHandler(
                    originalBroadcastMessageHandler,
                    broadcastMessageHandler,
                    messageBus
                );

            return new GlobalAcceptAllDeregistrationState(
                messageBus,
                in messageBusDeregistration,
                untargetedDeregistration,
                targetedDeregistration,
                broadcastDeregistration
            );
        }

        /// <summary>
        /// Registers this MessageHandler to Globally Accept All Messages via the MessageBus, properly handling deregistration.
        /// </summary>
        /// <param name="untargetedMessageHandler">MessageHandler to accept all UntargetedMessages.</param>
        /// <param name="broadcastMessageHandler">MessageHandler to accept all TargetedMessages for all entities.</param>
        /// <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>
        internal GlobalAcceptAllDeregistrationState RegisterGlobalAcceptAll(
            FastHandler<IUntargetedMessage> originalUntargetedMessageHandler,
            FastHandler<IUntargetedMessage> untargetedMessageHandler,
            FastHandlerWithContext<ITargetedMessage> originalTargetedMessageHandler,
            FastHandlerWithContext<ITargetedMessage> targetedMessageHandler,
            FastHandlerWithContext<IBroadcastMessage> originalBroadcastMessageHandler,
            FastHandlerWithContext<IBroadcastMessage> broadcastMessageHandler,
            IMessageBus messageBus = null
        )
        {
            messageBus = ResolveMessageBus(messageBus);
            MessageBusRegistration messageBusDeregistration = messageBus.RegisterGlobalAcceptAll(
                this
            );
            TypedHandler<IMessage> typedHandler = GetOrCreateHandlerForType<IMessage>(messageBus);

            GlobalHandlerDeregistrationState untargetedDeregistration =
                typedHandler.AddGlobalUntargetedHandler(
                    originalUntargetedMessageHandler,
                    untargetedMessageHandler,
                    messageBus
                );
            GlobalHandlerDeregistrationState targetedDeregistration =
                typedHandler.AddGlobalTargetedHandler(
                    originalTargetedMessageHandler,
                    targetedMessageHandler,
                    messageBus
                );
            GlobalHandlerDeregistrationState broadcastDeregistration =
                typedHandler.AddGlobalBroadcastHandler(
                    originalBroadcastMessageHandler,
                    broadcastMessageHandler,
                    messageBus
                );

            return new GlobalAcceptAllDeregistrationState(
                messageBus,
                in messageBusDeregistration,
                untargetedDeregistration,
                targetedDeregistration,
                broadcastDeregistration
            );
        }

        /// <summary>
        /// Registers this MessageHandler to accept TargetedMessages via the MessageBus, properly handling deregistration.
        /// </summary>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <param name="target">Target Id of TargetedMessages to listen for.</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 RegisterTargetedMessageHandler<T>(
            InstanceId target,
            Action<T> originalHandler,
            Action<T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <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>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <param name="target">Target Id of TargetedMessages to listen for.</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 RegisterTargetedMessageHandler<T>(
            InstanceId target,
            FastHandler<T> originalHandler,
            FastHandler<T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers this MessageHandler to post process TargetedMessages via the MessageBus, properly handling deregistration.
        /// </summary>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <param name="target">Target Id of TargetedMessages to listen for.</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 RegisterTargetedPostProcessor<T>(
            InstanceId target,
            Action<T> originalHandler,
            Action<T> messageHandler,
            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,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers this MessageHandler to post process fast TargetedMessages via the MessageBus, properly handling deregistration.
        /// </summary>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <param name="target">Target Id of TargetedMessages to listen for.</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 RegisterTargetedPostProcessor<T>(
            InstanceId target,
            FastHandler<T> originalHandler,
            FastHandler<T> messageHandler,
            int priority = 0,
            IMessageBus messageBus = null
        )
            where T : ITargetedMessage
        {
            messageBus = ResolveMessageBus(messageBus);
            MessageBusRegistration messageBusDeregistration =
                messageBus.RegisterTargetedPostProcessor<T>(target, this, priority: priority);
            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
            return typedHandler.AddTargetedPostProcessor(
                target,
                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,
                flatInvoker,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers this MessageHandler to post-process TargetedMessages for all messages of the provided type via the MessageBus, properly handling deregistration.
        /// </summary>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <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 RegisterTargetedWithoutTargetingPostProcessor<T>(
            Action<InstanceId, T> originalHandler,
            Action<InstanceId, T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers this MessageHandler to post process fast TargetedMessages for all messages of the provided type via the MessageBus, properly handling deregistration.
        /// </summary>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <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 RegisterTargetedWithoutTargetingPostProcessor<T>(
            FastHandlerWithContext<T> originalHandler,
            FastHandlerWithContext<T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <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>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <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 RegisterTargetedWithoutTargeting<T>(
            Action<InstanceId, T> originalHandler,
            Action<InstanceId, T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <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>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <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 RegisterTargetedWithoutTargeting<T>(
            FastHandlerWithContext<T> originalHandler,
            FastHandlerWithContext<T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers this MessageHandler to accept UntargetedMessages via the MessageBus, properly handling deregistration.
        /// </summary>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <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 RegisterUntargetedMessageHandler<T>(
            Action<T> originalHandler,
            Action<T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <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>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <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 RegisterUntargetedMessageHandler<T>(
            FastHandler<T> originalHandler,
            FastHandler<T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers this MessageHandler to post-process UntargetedMessages via the MessageBus, properly handling deregistration.
        /// </summary>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <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 RegisterUntargetedPostProcessor<T>(
            Action<T> originalHandler,
            Action<T> messageHandler,
            int priority = 0,
            IMessageBus messageBus = null
        )
            where T : IUntargetedMessage
        {
            messageBus = ResolveMessageBus(messageBus);
            MessageBusRegistration messageBusDeregistration =
                messageBus.RegisterUntargetedPostProcessor<T>(
                    priority: priority,
                    messageHandler: this
                );
            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
            return typedHandler.AddUntargetedPostProcessor(
                originalHandler,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers this MessageHandler to post process fast UntargetedMessages via the MessageBus, properly handling deregistration.
        /// </summary>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <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 RegisterUntargetedPostProcessor<T>(
            FastHandler<T> originalHandler,
            FastHandler<T> messageHandler,
            int priority = 0,
            IMessageBus messageBus = null
        )
            where T : IUntargetedMessage
        {
            messageBus = ResolveMessageBus(messageBus);
            MessageBusRegistration messageBusDeregistration =
                messageBus.RegisterUntargetedPostProcessor<T>(
                    priority: priority,
                    messageHandler: this
                );
            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
            return typedHandler.AddUntargetedPostProcessor(
                originalHandler,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers this MessageHandler to accept BroadcastMessages via their MessageBus, properly handling deregistration.
        /// </summary>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <param name="source">Source Id of BroadcastMessages to listen for.</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 RegisterSourcedBroadcastMessageHandler<T>(
            InstanceId source,
            Action<T> originalHandler,
            Action<T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <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>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <param name="source">Source Id of BroadcastMessages to listen for.</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 RegisterSourcedBroadcastMessageHandler<T>(
            InstanceId source,
            FastHandler<T> originalHandler,
            FastHandler<T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers this MessageHandler to accept BroadcastMessage regardless of source via their MessageBus, properly handling deregistration.
        /// </summary>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <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 RegisterSourcedBroadcastWithoutSource<T>(
            Action<InstanceId, T> originalHandler,
            Action<InstanceId, T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <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>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <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 RegisterSourcedBroadcastWithoutSource<T>(
            FastHandlerWithContext<T> originalHandler,
            FastHandlerWithContext<T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers this MessageHandler to post-processes 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,
            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,
            FastHandler<T> originalHandler,
            FastHandler<T> messageHandler,
            int priority = 0,
            IMessageBus messageBus = null
        )
            where T : IBroadcastMessage
        {
            messageBus = ResolveMessageBus(messageBus);
            MessageBusRegistration messageBusDeregistration =
                messageBus.RegisterBroadcastPostProcessor<T>(
                    source,
                    priority: priority,
                    messageHandler: this
                );
            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
            return typedHandler.AddBroadcastPostProcessor(
                source,
                originalHandler,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers a sourced-broadcast post-processor whose diagnostics-augmented
        /// by-ref flat invoker was already built by the caller (the registration
        /// token), so the default slot stores a single closure instead of an
        /// <see cref="Action{T}"/> wrapper plus a separately allocated FastHandler
        /// adapter. <paramref name="originalHandler"/> stays the dedup/identity key.
        /// </summary>
        internal TypedHandler<T>.TypedHandlerDeregistrationState RegisterSourcedBroadcastPostProcessor<T>(
            InstanceId source,
            Action<T> originalHandler,
            FastHandler<T> flatInvoker,
            int priority = 0,
            IMessageBus messageBus = null
        )
            where T : IBroadcastMessage
        {
            messageBus = ResolveMessageBus(messageBus);
            MessageBusRegistration messageBusDeregistration =
                messageBus.RegisterBroadcastPostProcessor<T>(
                    source,
                    priority: priority,
                    messageHandler: this
                );
            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
            return typedHandler.AddBroadcastPostProcessor(
                source,
                originalHandler,
                flatInvoker,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers this MessageHandler to post-processes BroadcastMessage messages for all messages of the provided type.
        /// </summary>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <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 RegisterSourcedBroadcastWithoutSourcePostProcessor<T>(
            Action<InstanceId, T> originalHandler,
            Action<InstanceId, T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers this MessageHandler to post processes fast BroadcastMessage messages for all messages of the provided type.
        /// </summary>
        /// <typeparam name="T">Type of Message to be handled.</typeparam>
        /// <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 RegisterSourcedBroadcastWithoutSourcePostProcessor<T>(
            FastHandlerWithContext<T> originalHandler,
            FastHandlerWithContext<T> messageHandler,
            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,
                messageHandler,
                messageBusDeregistration,
                priority,
                messageBus
            );
        }

        /// <summary>
        /// Registers a sourced-broadcast (without-source) post-processor whose
        /// diagnostics-augmented by-ref context flat invoker was already built by the
        /// caller (the registration token), so the default slot stores a single closure
        /// instead of an <see cref="Action{T1, T2}"/> wrapper plus a separately
        /// allocated FastHandlerWithContext adapter. <paramref name="originalHandler"/>
        /// stays the dedup/identity key.
        /// </summary>
        internal 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>
        /// <typeparam name="T">Type of the UntargetedMessage to intercept.</typeparam>
        /// <param name="interceptor">Interceptor to register.</param>
        /// <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>
        internal InterceptorDeregistrationState<T> RegisterUntargetedInterceptor<T>(
            IMessageBus.UntargetedInterceptor<T> interceptor,
            int priority = 0,
            IMessageBus messageBus = null
        )
            where T : IUntargetedMessage
        {
            messageBus = ResolveMessageBus(messageBus);
            MessageBusRegistration registration = messageBus.RegisterUntargetedInterceptor(
                interceptor,
                priority
            );
            return new InterceptorDeregistrationState<T>(messageBus, in registration);
        }

        /// <summary>
        /// Registers a BroadcastInterceptor for messages of the provided type at the provided priority.
        /// </summary>
        /// <typeparam name="T">Type of the BroadcastMessage to intercept.</typeparam>
        /// <param name="interceptor">Interceptor to register.</param>
        /// <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>
        internal InterceptorDeregistrationState<T> RegisterBroadcastInterceptor<T>(
            IMessageBus.BroadcastInterceptor<T> interceptor,
            int priority = 0,
            IMessageBus messageBus = null
        )
            where T : IBroadcastMessage
        {
            messageBus = ResolveMessageBus(messageBus);
            MessageBusRegistration registration = messageBus.RegisterBroadcastInterceptor(
                interceptor,
                priority
            );
            return new InterceptorDeregistrationState<T>(messageBus, in registration);
        }

        /// <summary>
        /// Registers a TargetedInterceptor for messages of the provided type at the provided priority.
        /// </summary>
        /// <typeparam name="T">Type of the TargetedMessage to intercept.</typeparam>
        /// <param name="interceptor">Interceptor to register.</param>
        /// <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>
        internal InterceptorDeregistrationState<T> RegisterTargetedInterceptor<T>(
            IMessageBus.TargetedInterceptor<T> interceptor,
            int priority = 0,
            IMessageBus messageBus = null
        )
            where T : ITargetedMessage
        {
            messageBus = ResolveMessageBus(messageBus);
            MessageBusRegistration registration = messageBus.RegisterTargetedInterceptor(
                interceptor,
                priority
            );
            return new InterceptorDeregistrationState<T>(messageBus, in registration);
        }

        /// <summary>
        /// Checks equality against another object.
        /// </summary>
        /// <param name="obj">Object to compare.</param>
        /// <returns><c>true</c> when <paramref name="obj"/> is a <see cref="MessageHandler"/> with the same owner.</returns>
        public override bool Equals(object obj)
        {
            return Equals(obj as MessageHandler);
        }

        /// <summary>
        /// Checks equality against another handler instance.
        /// </summary>
        /// <param name="other">Handler to compare.</param>
        /// <returns><c>true</c> when both handlers share the same <see cref="owner"/>.</returns>
        public bool Equals(MessageHandler other)
        {
            if (other == null)
            {
                return false;
            }

            if (ReferenceEquals(other, this))
            {
                return true;
            }

            return owner.Equals(other.owner);
        }

        /// <summary>
        /// Produces a hash code based on the owning instance.
        /// </summary>
        /// <returns>Hash code derived from <see cref="owner"/>.</returns>
        public override int GetHashCode()
        {
            return owner.GetHashCode();
        }

        /// <summary>
        /// Compares this handler with another handler for ordering.
        /// </summary>
        /// <param name="other">Handler to compare.</param>
        /// <returns>Relative ordering based on <see cref="owner"/>.</returns>
        public int CompareTo(MessageHandler other)
        {
            if (other == null)
            {
                return -1;
            }

            return owner.CompareTo(other.owner);
        }

        /// <summary>
        /// Compares this handler with an arbitrary object.
        /// </summary>
        /// <param name="obj">Object to compare.</param>
        /// <returns>
        /// Relative ordering when <paramref name="obj"/> is a <see cref="MessageHandler"/>; otherwise <c>-1</c>.
        /// </returns>
        public int CompareTo(object obj)
        {
            return CompareTo(obj as MessageHandler);
        }

        /// <summary>
        /// Returns a human-readable representation containing the owner identifier.
        /// </summary>
        /// <returns>String describing the handler.</returns>
        public override string ToString()
        {
            return new { OwnerId = owner }.ToString();
        }

        /// <summary>
        /// Retrieves an existing Handler for the specific type if it exists, or creates a new Handler if none exist.
        /// </summary>
        /// <typeparam name="T">Type of Message to retrieve a Handler for.</typeparam>
        /// <returns>Non-Null Handler for the specific type.</returns>
        private TypedHandler<T> GetOrCreateHandlerForType<T>(IMessageBus messageBus)
            where T : IMessage
        {
            int messageBusIndex = messageBus.RegisteredGlobalSequentialIndex;
            while (_handlersByTypeByMessageBus.Count <= messageBusIndex)
            {
                _handlersByTypeByMessageBus.Add(new MessageCache<object>());
            }

            MessageCache<object> handlersByType = _handlersByTypeByMessageBus[messageBusIndex];
            if (handlersByType.TryGetValue<T>(out object untypedHandler))
            {
                return DxUnsafe.As<TypedHandler<T>>(untypedHandler);
            }

            TypedHandler<T> typedHandler = new();
            handlersByType.Set<T>(typedHandler);
            return typedHandler;
        }

        /// <summary>
        /// Gets an existing Handler for the specific type if it exists.
        /// </summary>
        /// <param name="messageBus">The specific MessageBus to use.</param>
        /// <param name="existingTypedHandler">Existing typed message handler, if one exists.</param>
        /// <returns>Existing handler for the specific type, or null if none exists.</returns>
        private bool GetHandlerForType<T>(
            IMessageBus messageBus,
            out TypedHandler<T> existingTypedHandler
        )
            where T : IMessage
        {
            int messageBusIndex = messageBus.RegisteredGlobalSequentialIndex;
            if (_handlersByTypeByMessageBus.Count <= messageBusIndex)
            {
                existingTypedHandler = default;
                return false;
            }

            if (
                _handlersByTypeByMessageBus[messageBusIndex]
                    .TryGetValue<T>(out object untypedHandler)
            )
            {
                existingTypedHandler = DxUnsafe.As<TypedHandler<T>>(untypedHandler);
                return true;
            }

            existingTypedHandler = default;
            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
        /// this erased surface after bus-side slots prove idle and empty.
        /// </summary>
        /// <param name="messageBus">
        /// Bus whose typed-handler cache should be swept. Null resolves to
        /// this handler's default bus.
        /// </param>
        /// <returns>Number of typed or typed-global slots reset.</returns>
        internal int ResetEmptyTypedSlotsForSweep(IMessageBus messageBus = null)
        {
            messageBus = ResolveMessageBus(messageBus);
            int messageBusIndex = messageBus.RegisteredGlobalSequentialIndex;
            if (messageBusIndex < 0 || _handlersByTypeByMessageBus.Count <= messageBusIndex)
            {
                return 0;
            }

            int resetCount = 0;
            MessageCache<object> handlersByType = _handlersByTypeByMessageBus[messageBusIndex];
            foreach (object untypedHandler in _handlersByTypeByMessageBus[messageBusIndex])
            {
                if (untypedHandler is ITypedHandlerSlotSweeper sweeper)
                {
                    resetCount += sweeper.ResetEmptySlotsForSweep();
                    if (sweeper.MarkedForOuterRemoval)
                    {
                        handlersByType.RemoveAtIndex(sweeper.MessageTypeIndex);
                    }
                }
            }

            return resetCount;
        }

        internal int ResetAllTypedSlotsForBusReset(IMessageBus messageBus = null)
        {
            messageBus = ResolveMessageBus(messageBus);
            int messageBusIndex = messageBus.RegisteredGlobalSequentialIndex;
            if (messageBusIndex < 0 || _handlersByTypeByMessageBus.Count <= messageBusIndex)
            {
                return 0;
            }

            int resetCount = 0;
            foreach (object untypedHandler in _handlersByTypeByMessageBus[messageBusIndex])
            {
                if (untypedHandler is ITypedHandlerSlotSweeper sweeper)
                {
                    resetCount += sweeper.ResetAllSlotsForBusReset();
                }
            }

            return resetCount;
        }

        internal int CountEmptyTypedSlotsForSweep(IMessageBus messageBus = null)
        {
            messageBus = ResolveMessageBus(messageBus);
            int messageBusIndex = messageBus.RegisteredGlobalSequentialIndex;
            if (messageBusIndex < 0 || _handlersByTypeByMessageBus.Count <= messageBusIndex)
            {
                return 0;
            }

            int count = 0;
            foreach (object untypedHandler in _handlersByTypeByMessageBus[messageBusIndex])
            {
                if (untypedHandler is ITypedHandlerSlotSweeper sweeper)
                {
                    count += sweeper.CountEmptySlotsForSweep();
                }
            }

            return count;
        }

        internal bool HasTypedHandlersForBus(IMessageBus messageBus = null)
        {
            messageBus = ResolveMessageBus(messageBus);
            int messageBusIndex = messageBus.RegisteredGlobalSequentialIndex;
            if (messageBusIndex < 0 || _handlersByTypeByMessageBus.Count <= messageBusIndex)
            {
                return false;
            }

            foreach (object untypedHandler in _handlersByTypeByMessageBus[messageBusIndex])
            {
                if (untypedHandler != null)
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// Counts the flat-dispatch entries this handler contributes to a
        /// non-context-keyed slot (untargeted handle/post) at the given
        /// priority: one entry per unique registered delegate (fast plus
        /// default). Build-time only; called by MessageBus.BuildFlatDispatch.
        /// </summary>
        internal int CountFlatHandlers<T>(
            IMessageBus messageBus,
            int priority,
            int fastIndex,
            int defaultIndex
        )
            where T : IMessage
        {
            if (!GetHandlerForType(messageBus, out TypedHandler<T> typedHandler))
            {
                return 0;
            }

            return CountFlatDelegates<FastHandler<T>>(
                    typedHandler.GetPriorityHandlers(fastIndex),
                    priority
                )
                + CountFlatDelegates<Action<T>>(
                    typedHandler.GetPriorityHandlers(defaultIndex),
                    priority
                );
        }

        /// <summary>
        /// Counts the flat-dispatch entries this handler contributes to a
        /// context-keyed slot (Default-variant targeted/broadcast handle/post)
        /// for the given context and priority. Build-time only.
        /// </summary>
        internal int CountContextFlatHandlers<T>(
            IMessageBus messageBus,
            InstanceId context,
            int priority,
            int fastIndex,
            int defaultIndex
        )
            where T : IMessage
        {
            if (!GetHandlerForType(messageBus, out TypedHandler<T> typedHandler))
            {
                return 0;
            }

            return CountFlatDelegates<FastHandler<T>>(
                    GetContextPriorityHandlers(typedHandler, fastIndex, context),
                    priority
                )
                + CountFlatDelegates<Action<T>>(
                    GetContextPriorityHandlers(typedHandler, defaultIndex, context),
                    priority
                );
        }

        /// <summary>
        /// Counts the flat-dispatch entries this handler contributes to a
        /// WithoutContext targeted/broadcast slot (whose delegates receive the
        /// routing InstanceId) at the given priority. Build-time only.
        /// </summary>
        internal int CountWithContextFlatHandlers<T>(
            IMessageBus messageBus,
            int priority,
            int fastIndex,
            int defaultIndex
        )
            where T : IMessage
        {
            if (!GetHandlerForType(messageBus, out TypedHandler<T> typedHandler))
            {
                return 0;
            }

            return CountFlatDelegates<FastHandlerWithContext<T>>(
                    typedHandler.GetPriorityHandlers(fastIndex),
                    priority
                )
                + CountFlatDelegates<Action<InstanceId, T>>(
                    typedHandler.GetPriorityHandlers(defaultIndex),
                    priority
                );
        }

        /// <summary>
        /// Writes this handler's resolved flat-dispatch entries for a
        /// non-context-keyed FastHandler-shaped slot into
        /// <paramref name="target"/> starting at <paramref name="writeIndex"/>:
        /// all fast entries in registration order, then all default entries in
        /// registration order, matching the legacy link path's
        /// fast-before-default contract. Fast entries resolve to the augmented
        /// FastHandler delegate itself; default entries resolve to the
        /// FastHandler adapter created at registration time
        /// (Entry.flatInvoker), so this method allocates nothing.
        /// Returns the next write index.
        /// </summary>
        internal int FillFlatHandlers<T>(
            IMessageBus messageBus,
            int priority,
            int fastIndex,
            int defaultIndex,
            FlatDispatchEntry<T>[] target,
            int writeIndex
        )
            where T : IMessage
        {
            if (!GetHandlerForType(messageBus, out TypedHandler<T> typedHandler))
            {
                return writeIndex;
            }

            writeIndex = FillFastFlatEntries(
                typedHandler.GetPriorityHandlers(fastIndex),
                priority,
                target,
                writeIndex
            );
            return FillDefaultFlatEntries(
                typedHandler.GetPriorityHandlers(defaultIndex),
                priority,
                target,
                writeIndex
            );
        }

        /// <summary>
        /// Context-keyed sibling of <see cref="FillFlatHandlers{T}"/> for the
        /// Default-variant targeted/broadcast slots: resolves the per-context
        /// priority map first, then fills fast entries followed by default
        /// entries in registration order. Returns the next write index.
        /// </summary>
        internal int FillContextFlatHandlers<T>(
            IMessageBus messageBus,
            InstanceId context,
            int priority,
            int fastIndex,
            int defaultIndex,
            FlatDispatchEntry<T>[] target,
            int writeIndex
        )
            where T : IMessage
        {
            if (!GetHandlerForType(messageBus, out TypedHandler<T> typedHandler))
            {
                return writeIndex;
            }

            writeIndex = FillFastFlatEntries(
                GetContextPriorityHandlers(typedHandler, fastIndex, context),
                priority,
                target,
                writeIndex
            );
            return FillDefaultFlatEntries(
                GetContextPriorityHandlers(typedHandler, defaultIndex, context),
                priority,
                target,
                writeIndex
            );
        }

        /// <summary>
        /// WithoutContext sibling of <see cref="FillFlatHandlers{T}"/> for the
        /// targeted/broadcast slots whose delegates receive the routing
        /// InstanceId: fills fast (FastHandlerWithContext) entries followed by
        /// default (Action&lt;InstanceId, T&gt;, via the registration-time
        /// FastHandlerWithContext adapter) entries in registration order.
        /// Returns the next write index.
        /// </summary>
        internal int FillWithContextFlatHandlers<T>(
            IMessageBus messageBus,
            int priority,
            int fastIndex,
            int defaultIndex,
            ContextFlatDispatchEntry<T>[] target,
            int writeIndex
        )
            where T : IMessage
        {
            if (!GetHandlerForType(messageBus, out TypedHandler<T> typedHandler))
            {
                return writeIndex;
            }

            writeIndex = FillFastWithContextFlatEntries(
                typedHandler.GetPriorityHandlers(fastIndex),
                priority,
                target,
                writeIndex
            );
            return FillDefaultWithContextFlatEntries(
                typedHandler.GetPriorityHandlers(defaultIndex),
                priority,
                target,
                writeIndex
            );
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static Dictionary<int, IHandlerActionCache> GetContextPriorityHandlers<T>(
            TypedHandler<T> typedHandler,
            int slotIndex,
            InstanceId context
        )
            where T : IMessage
        {
            Dictionary<InstanceId, Dictionary<int, IHandlerActionCache>> byContext =
                typedHandler.GetContextHandlers(slotIndex);
            if (
                byContext != null
                && byContext.TryGetValue(
                    context,
                    out Dictionary<int, IHandlerActionCache> byPriority
                )
            )
            {
                return byPriority;
            }

            return null;
        }

        private static int CountFlatDelegates<TDelegate>(
            Dictionary<int, IHandlerActionCache> byPriority,
            int priority
        )
        {
            if (
                byPriority != null
                && byPriority.TryGetValue(priority, out IHandlerActionCache erased)
                && erased is HandlerActionCache<TDelegate> cache
            )
            {
                return cache.entries.Count;
            }

            return 0;
        }

        private int FillFastFlatEntries<T>(
            Dictionary<int, IHandlerActionCache> byPriority,
            int priority,
            FlatDispatchEntry<T>[] target,
            int writeIndex
        )
            where T : IMessage
        {
            if (
                byPriority == null
                || !byPriority.TryGetValue(priority, out IHandlerActionCache erased)
                || erased is not HandlerActionCache<FastHandler<T>> cache
            )
            {
                return writeIndex;
            }

            int orderedCount = cache.entries.Count;
            for (int i = 0; i < orderedCount; ++i)
            {
                HandlerActionCache<FastHandler<T>>.Entry entry = cache.entries.ValueAt(i);
                target[writeIndex++] = new FlatDispatchEntry<T>(this, entry.handler);
            }

            return writeIndex;
        }

        private int FillDefaultFlatEntries<T>(
            Dictionary<int, IHandlerActionCache> byPriority,
            int priority,
            FlatDispatchEntry<T>[] target,
            int writeIndex
        )
            where T : IMessage
        {
            if (
                byPriority == null
                || !byPriority.TryGetValue(priority, out IHandlerActionCache erased)
                || erased is not HandlerActionCache<Action<T>> cache
            )
            {
                return writeIndex;
            }

            int orderedCount = cache.entries.Count;
            for (int i = 0; i < orderedCount; ++i)
            {
                HandlerActionCache<Action<T>>.Entry entry = cache.entries.ValueAt(i);

                // Every default registration path for the flattened slots
                // supplies the adapter at registration time (AddUntargetedHandler,
                // AddTargetedHandler, AddSourcedBroadcastHandler, and their
                // 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);
                }
                else
                {
                    System.Diagnostics.Debug.Assert(
                        false,
                        "Default registration is missing its FastHandler flat invoker; "
                            + "every Add*Handler/Add*PostProcessor default path must adapt "
                            + "the augmented handler at registration time."
                    );
                }
            }

            return writeIndex;
        }

        private int FillFastWithContextFlatEntries<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<FastHandlerWithContext<T>> cache
            )
            {
                return writeIndex;
            }

            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()
                {
                    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;
                }

                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                private T GetInlineKey(int index)
                {
                    return index == 0 ? _key0 : _key1;
                }

                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                private Entry GetInlineValue(int index)
                {
                    return index == 0 ? _value0 : _value1;
                }

                private void SetInline(int index, T key, Entry value)
                {
                    if (index == 0)
                    {
                        _key0 = key;
                        _value0 = value;
                        return;
                    }
                    _key1 = key;
                    _value1 = value;
                }

                private void SetInlineValue(int index, Entry value)
                {
                    if (index == 0)
                    {
                        _value0 = value;
                        return;
                    }
                    _value1 = value;
                }

                private void ClearInline(int index)
                {
                    SetInline(index, default, default);
                }

                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                private static void ThrowIfNull(T key)
                {
                    if (key is null)
                    {
                        throw new ArgumentNullException(nameof(key));
                    }
                }
            }

            // Uses outer T as a field type -- reflection callers must close
            // via MakeGenericType(outer.GetGenericArguments()) before passing
            // this type to Activator.CreateInstance. See
            // Tests/Editor/Contract/ReflectionHelpers.cs::CloseNestedGeneric.
            internal readonly struct Entry
            {
                /// <summary>
                /// Initializes an entry used to track handler invocation counts.
                /// </summary>
                /// <param name="handler">Handler delegate being tracked.</param>
                /// <param name="count">Number of times the handler has been cached.</param>
                public Entry(T handler, int count)
                    : this(handler, count, null) { }

                /// <summary>
                /// Initializes an entry that additionally carries a pre-resolved
                /// flat-dispatch invoker (see <see cref="flatInvoker"/>).
                /// </summary>
                /// <param name="handler">Handler delegate being tracked.</param>
                /// <param name="count">Number of times the handler has been cached.</param>
                /// <param name="flatInvoker">Pre-resolved flat-dispatch invoker, if any.</param>
                public Entry(T handler, int count, object flatInvoker)
                {
                    this.handler = handler;
                    this.count = count;
                    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 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-registration-wins semantics of `handler`.
                public readonly object flatInvoker;
            }

            // 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
            {
                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                get => version;
            }

            /// <summary>Most recent dispatcher-observed version; mutable through the staged dispatch path.</summary>
            long DxMessaging.Core.Internal.IHandlerActionCache.LastSeenVersion
            {
                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                get => lastSeenVersion;
                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                set => lastSeenVersion = value;
            }

            /// <summary>Most recent dispatcher-observed bus emission id.</summary>
            long DxMessaging.Core.Internal.IHandlerActionCache.LastSeenEmissionId
            {
                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                get => lastSeenEmissionId;
                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                set => lastSeenEmissionId = value;
            }

            /// <summary>True iff the ordered entry storage holds zero handlers.</summary>
            bool DxMessaging.Core.Internal.IHandlerActionCache.IsEmpty
            {
                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                get => entries.Count == 0;
            }

            /// <summary>
            /// Eviction-driven full clear; bumps <see cref="version"/> as the LAST step
            /// so captured dispatch closures observe invalidation.
            /// </summary>
            void DxMessaging.Core.Internal.IHandlerActionCache.Reset()
            {
                entries.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>
        /// One-size-fits-all wrapper around all possible Messaging sinks for a particular MessageHandler & MessageType.
        /// </summary>
        /// <typeparam name="T">Message type that this Handler exists to serve.</typeparam>
        internal sealed class TypedHandler<T> : ITypedHandlerSlotSweeper
            where T : IMessage
        {
            // Typed storage: 20 typed slots + 6 global slots. The legacy
            // named fields were deleted so new handler variants must pick an
            // explicit axis-indexed slot.
            internal readonly TypedSlot<T>[] _slots = new TypedSlot<T>[TypedSlotIndex.Length];
            internal readonly TypedGlobalSlot[] _globalSlots = new TypedGlobalSlot[
                TypedGlobalSlotIndex.Length
            ];

            // Constructor exists solely so the [Conditional("DEBUG")]
            // validator below runs at construction time. In Release builds
            // the Conditional attribute strips the call site, leaving an
            // empty constructor body that the JIT collapses to the
            // equivalent of the implicit default. Mirrors the
            // MessageBus.ValidateSinkArrays() pattern.
            internal TypedHandler()
            {
                ValidateSlotArrays();
            }

            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)]
                get => MessageHelperIndexer<T>.SequentialId;
            }

            bool ITypedHandlerSlotSweeper.MarkedForOuterRemoval
            {
                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                get => _markedForOuterRemoval;
            }

            [Conditional("DEBUG")]
            private void ValidateSlotArrays()
            {
                if (_slots.Length != TypedSlotIndex.Length)
                {
                    throw new InvalidOperationException(
                        $"_slots length is {_slots.Length} but TypedSlotIndex.Length is {TypedSlotIndex.Length}."
                    );
                }
                if (_globalSlots.Length != TypedGlobalSlotIndex.Length)
                {
                    throw new InvalidOperationException(
                        $"_globalSlots length is {_globalSlots.Length} but TypedGlobalSlotIndex.Length is {TypedGlobalSlotIndex.Length}."
                    );
                }
                // Lazy registration writers update the slot arrays; this assertion still
                // holds at construction (slots populate on first register,
                // not on construction). The invariant flips meaning -- not
                // the message -- when writers land.
                for (int i = 0; i < _slots.Length; ++i)
                {
                    if (_slots[i] != null)
                    {
                        throw new InvalidOperationException(
                            $"_slots[{i}] is non-null at construction; expected null per TypedSlotIndex because slots populate lazily on first registration."
                        );
                    }
                }
                for (int i = 0; i < _globalSlots.Length; ++i)
                {
                    if (_globalSlots[i] != null)
                    {
                        throw new InvalidOperationException(
                            $"_globalSlots[{i}] is non-null at construction; expected null per TypedGlobalSlotIndex because slots populate lazily on first registration."
                        );
                    }
                }
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            private TypedSlot<T> GetOrCreateSlot(int index, bool requiresContext)
            {
                TypedSlot<T> slot = _slots[index];
                if (slot == null)
                {
                    slot = new TypedSlot<T>(requiresContext);
                    _slots[index] = slot;
                }

                return slot;
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal Dictionary<int, IHandlerActionCache> GetOrCreatePriorityHandlers(
                int index,
                bool requiresContext
            )
            {
                return GetOrCreateSlot(index, requiresContext).byPriority;
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal Dictionary<int, IHandlerActionCache> GetPriorityHandlers(int index)
            {
                return _slots[index]?.byPriority;
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal Dictionary<
                InstanceId,
                Dictionary<int, IHandlerActionCache>
            > GetOrCreateContextHandlers(int index)
            {
                TypedSlot<T> slot = GetOrCreateSlot(index, requiresContext: true);
                slot.byContext ??= DxPools.TypedHandlerContextDicts.Rent();
                return slot.byContext;
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal Dictionary<
                InstanceId,
                Dictionary<int, IHandlerActionCache>
            > GetContextHandlers(int index)
            {
                return _slots[index]?.byContext;
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal TypedGlobalSlot GetOrCreateGlobalSlot(int index)
            {
                TypedGlobalSlot slot = _globalSlots[index];
                if (slot == null)
                {
                    slot = new TypedGlobalSlot();
                    _globalSlots[index] = slot;
                }

                return slot;
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal HandlerActionCache<TU> GetGlobalCache<TU>(int index)
            {
                return _globalSlots[index]?.cache as HandlerActionCache<TU>;
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            private TypedSlot<T> FindPrioritySlot(Dictionary<int, IHandlerActionCache> handlers)
            {
                for (int i = 0; i < _slots.Length; ++i)
                {
                    TypedSlot<T> slot = _slots[i];
                    if (slot != null && ReferenceEquals(slot.byPriority, handlers))
                    {
                        return slot;
                    }
                }

                return null;
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            private TypedSlot<T> FindContextSlot(
                Dictionary<InstanceId, Dictionary<int, IHandlerActionCache>> handlersByContext
            )
            {
                for (int i = 0; i < _slots.Length; ++i)
                {
                    TypedSlot<T> slot = _slots[i];
                    if (slot != null && ReferenceEquals(slot.byContext, handlersByContext))
                    {
                        return slot;
                    }
                }

                return null;
            }

            int ITypedHandlerSlotSweeper.ResetEmptySlotsForSweep()
            {
                _markedForOuterRemoval = false;
                int resetCount = 0;
                for (int i = 0; i < _slots.Length; ++i)
                {
                    TypedSlot<T> slot = _slots[i];
                    if (slot != null && slot.IsEmpty)
                    {
                        slot.Reset();
                        _slots[i] = null;
                        resetCount++;
                    }
                }

                for (int i = 0; i < _globalSlots.Length; ++i)
                {
                    TypedGlobalSlot slot = _globalSlots[i];
                    if (slot != null && slot.IsEmpty)
                    {
                        slot.Reset();
                        _globalSlots[i] = null;
                        resetCount++;
                    }
                }

                MarkForOuterRemovalIfEmpty();
                return resetCount;
            }

            int ITypedHandlerSlotSweeper.ResetAllSlotsForBusReset()
            {
                _markedForOuterRemoval = false;
                int resetCount = 0;
                for (int i = 0; i < _slots.Length; ++i)
                {
                    TypedSlot<T> slot = _slots[i];
                    if (slot != null)
                    {
                        slot.Reset();
                        _slots[i] = null;
                        resetCount++;
                    }
                }

                for (int i = 0; i < _globalSlots.Length; ++i)
                {
                    TypedGlobalSlot slot = _globalSlots[i];
                    if (slot != null)
                    {
                        slot.Reset();
                        _globalSlots[i] = null;
                        resetCount++;
                    }
                }

                return resetCount;
            }

            int ITypedHandlerSlotSweeper.CountEmptySlotsForSweep()
            {
                int count = 0;
                for (int i = 0; i < _slots.Length; ++i)
                {
                    TypedSlot<T> slot = _slots[i];
                    if (slot != null && slot.IsEmpty)
                    {
                        count++;
                    }
                }

                for (int i = 0; i < _globalSlots.Length; ++i)
                {
                    TypedGlobalSlot slot = _globalSlots[i];
                    if (slot != null && slot.IsEmpty)
                    {
                        count++;
                    }
                }

                return count;
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            private void MarkForOuterRemovalIfEmpty()
            {
                if (HasLiveSlots())
                {
                    return;
                }

                _markedForOuterRemoval = true;
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            private bool HasLiveSlots()
            {
                for (int i = 0; i < _slots.Length; ++i)
                {
                    if (_slots[i] != null)
                    {
                        return true;
                    }
                }

                for (int i = 0; i < _globalSlots.Length; ++i)
                {
                    if (_globalSlots[i] != null)
                    {
                        return true;
                    }
                }

                return false;
            }

            /// <summary>
            /// Emits the UntargetedMessage to all subscribed listeners.
            /// </summary>
            /// <param name="message">Message to emit.</param>
            /// <param name="priority">Priority at which to run the handlers.</param>
            public void HandleUntargeted(ref T message, int priority, long emissionId)
            {
                RunFastHandlers(
                    GetPriorityHandlers(TypedSlotIndex.UntargetedHandleFast),
                    ref message,
                    priority,
                    emissionId
                );
                RunHandlers(
                    GetPriorityHandlers(TypedSlotIndex.UntargetedHandleDefault),
                    ref message,
                    priority,
                    emissionId
                );
            }

            /// <summary>
            /// Emits the TargetedMessage to all subscribed listeners.
            /// </summary>
            /// <param name="target">Target the message is for.</param>
            /// <param name="message">Message to emit.</param>
            /// <param name="priority">Priority at which to run the handlers.</param>
            public void HandleTargeted(
                ref InstanceId target,
                ref T message,
                int priority,
                long emissionId
            )
            {
                RunFastHandlersWithContext(
                    ref target,
                    GetContextHandlers(TypedSlotIndex.TargetedHandleFast),
                    ref message,
                    priority,
                    emissionId
                );
                RunHandlersWithContext(
                    ref target,
                    GetContextHandlers(TypedSlotIndex.TargetedHandleDefault),
                    ref message,
                    priority,
                    emissionId
                );
            }

            /// <summary>
            /// Emits the TargetedMessage without targeting to all subscribed listeners.
            /// </summary>
            /// <param name="target">Target the message is for.</param>
            /// <param name="message">Message to emit.</param>
            /// <param name="priority">Priority at which to run the handlers.</param>
            public void HandleTargetedWithoutTargeting(
                ref InstanceId target,
                ref T message,
                int priority,
                long emissionId
            )
            {
                RunFastHandlers(
                    ref target,
                    GetPriorityHandlers(TypedSlotIndex.TargetedHandleWithoutContextFast),
                    ref message,
                    priority,
                    emissionId
                );
                RunHandlers(
                    ref target,
                    GetPriorityHandlers(TypedSlotIndex.TargetedHandleWithoutContext),
                    ref message,
                    priority,
                    emissionId
                );
            }

            /// <summary>
            /// Emits the BroadcastMessage to all subscribed listeners.
            /// </summary>
            /// <param name="source">Source the message is from.</param>
            /// <param name="message">Message to emit.</param>
            /// <param name="priority">Priority at which to run the handlers.</param>
            public void HandleSourcedBroadcast(
                ref InstanceId source,
                ref T message,
                int priority,
                long emissionId
            )
            {
                RunFastHandlersWithContext(
                    ref source,
                    GetContextHandlers(TypedSlotIndex.BroadcastHandleFast),
                    ref message,
                    priority,
                    emissionId
                );
                RunHandlersWithContext(
                    ref source,
                    GetContextHandlers(TypedSlotIndex.BroadcastHandleDefault),
                    ref message,
                    priority,
                    emissionId
                );
            }

            /// <summary>
            /// Emits the BroadcastMessage without a source to all subscribed listeners.
            /// </summary>
            /// <param name="source">Source the message is from.</param>
            /// <param name="message">Message to emit.</param>
            /// <param name="priority">Priority at which to run the handlers.</param>
            public void HandleSourcedBroadcastWithoutSource(
                ref InstanceId source,
                ref T message,
                int priority,
                long emissionId
            )
            {
                RunFastHandlers(
                    ref source,
                    GetPriorityHandlers(TypedSlotIndex.BroadcastHandleWithoutContextFast),
                    ref message,
                    priority,
                    emissionId
                );
                RunHandlers(
                    ref source,
                    GetPriorityHandlers(TypedSlotIndex.BroadcastHandleWithoutContext),
                    ref message,
                    priority,
                    emissionId
                );
            }

            /// <summary>
            /// Emits the UntargetedMessage to all global listeners.
            /// </summary>
            /// <param name="message">Message to emit.</param>
            public void HandleGlobalUntargeted(ref IUntargetedMessage message, long emissionId)
            {
                HandlerActionCache<FastHandler<IUntargetedMessage>> fastCache = GetGlobalCache<
                    FastHandler<IUntargetedMessage>
                >(TypedGlobalSlotIndex.UntargetedFast);
                RunFastHandlers(fastCache, ref message, emissionId);
                HandlerActionCache<Action<IUntargetedMessage>> cache = GetGlobalCache<
                    Action<IUntargetedMessage>
                >(TypedGlobalSlotIndex.UntargetedDefault);
                // Live-count fast path. Cross-handler in-flight snapshot
                // semantics do not apply to the global accept-all path: the
                // bus dispatch loop calls PrefreezeGlobalUntargetedForEmission
                // lazily per-entry inside InvokeGlobalUntargetedEntry, after
                // earlier-priority handlers have already run. A sibling
                // MessageHandler that removes this handler's entry mid-emit
                // drains cache.entries before the lazy prefreeze can capture
                // a snapshot, so cache.cache rebuilds from the now-empty
                // entries. Bailing on cache.entries.Count == 0 is therefore
                // equivalent to bailing after GetOrAddNewHandlerStack would
                // return an empty list, and is documented behavior for the
                // global path.
                if (cache?.entries is not { Count: > 0 })
                {
                    return;
                }

                List<Action<IUntargetedMessage>> handlers = GetOrAddNewHandlerStack(
                    cache,
                    emissionId
                );
                int handlersCount = handlers.Count;
                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                {
                    handlers[i](message);
                }
            }

            /// <summary>
            /// Emits the TargetedMessage to all global listeners.
            /// </summary>
            /// <param name="target">Target that this message is intended for.</param>
            /// <param name="message">Message to emit.</param>
            public void HandleGlobalTargeted(
                ref InstanceId target,
                ref ITargetedMessage message,
                long emissionId
            )
            {
                HandlerActionCache<FastHandlerWithContext<ITargetedMessage>> fastCache =
                    GetGlobalCache<FastHandlerWithContext<ITargetedMessage>>(
                        TypedGlobalSlotIndex.TargetedFast
                    );
                RunFastHandlers(ref target, fastCache, ref message, emissionId);

                HandlerActionCache<Action<InstanceId, ITargetedMessage>> cache = GetGlobalCache<
                    Action<InstanceId, ITargetedMessage>
                >(TypedGlobalSlotIndex.TargetedDefault);
                // Live-count fast path. See comment in HandleGlobalUntargeted
                // for why the global accept-all path bails on
                // cache.entries.Count == 0 rather than reading the snapshot.
                if (cache?.entries is not { Count: > 0 })
                {
                    return;
                }

                List<Action<InstanceId, ITargetedMessage>> handlers = GetOrAddNewHandlerStack(
                    cache,
                    emissionId
                );
                int handlersCount = handlers.Count;
                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                {
                    handlers[i](target, message);
                }
            }

            /// <summary>
            /// Emits the BroadcastMessage to all global listeners.
            /// </summary>
            /// <param name="source">Source that this message is from.</param>
            /// <param name="message">Message to emit.</param>
            public void HandleGlobalBroadcast(
                ref InstanceId source,
                ref IBroadcastMessage message,
                long emissionId
            )
            {
                HandlerActionCache<FastHandlerWithContext<IBroadcastMessage>> fastCache =
                    GetGlobalCache<FastHandlerWithContext<IBroadcastMessage>>(
                        TypedGlobalSlotIndex.BroadcastFast
                    );
                RunFastHandlers(ref source, fastCache, ref message, emissionId);

                HandlerActionCache<Action<InstanceId, IBroadcastMessage>> cache = GetGlobalCache<
                    Action<InstanceId, IBroadcastMessage>
                >(TypedGlobalSlotIndex.BroadcastDefault);
                // Live-count fast path. See comment in HandleGlobalUntargeted
                // for why the global accept-all path bails on
                // cache.entries.Count == 0 rather than reading the snapshot.
                if (cache?.entries is not { Count: > 0 })
                {
                    return;
                }

                List<Action<InstanceId, IBroadcastMessage>> handlers = GetOrAddNewHandlerStack(
                    cache,
                    emissionId
                );
                int handlersCount = handlers.Count;
                switch (handlersCount)
                {
                    case 1:
                    {
                        handlers[0](source, message);
                        return;
                    }
                    case 2:
                    {
                        handlers[0](source, message);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](source, message);
                        return;
                    }
                    case 3:
                    {
                        handlers[0](source, message);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](source, message);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](source, message);
                        return;
                    }
                    case 4:
                    {
                        handlers[0](source, message);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](source, message);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](source, message);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](source, message);
                        return;
                    }
                    case 5:
                    {
                        handlers[0](source, message);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](source, message);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](source, message);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](source, message);
                        if (handlers.Count < 5)
                        {
                            return;
                        }
                        handlers[4](source, message);
                        return;
                    }
                }

                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                {
                    handlers[i](source, message);
                }
            }

            /// <summary>
            /// Runs untargeted post-processing handlers for the supplied message.
            /// </summary>
            /// <param name="message">Message being processed.</param>
            /// <param name="priority">Priority bucket currently executing.</param>
            /// <param name="emissionId">Emission identifier used to cache handler stacks.</param>
            public void HandleUntargetedPostProcessing(ref T message, int priority, long emissionId)
            {
                RunFastHandlers(
                    GetPriorityHandlers(TypedSlotIndex.UntargetedPostProcessFast),
                    ref message,
                    priority,
                    emissionId
                );
                RunHandlers(
                    GetPriorityHandlers(TypedSlotIndex.UntargetedPostProcessDefault),
                    ref message,
                    priority,
                    emissionId
                );
            }

            /// <summary>
            /// Runs targeted post-processing handlers for the supplied message and recipient.
            /// </summary>
            /// <param name="target">Recipient of the message.</param>
            /// <param name="message">Message being processed.</param>
            /// <param name="priority">Priority bucket currently executing.</param>
            /// <param name="emissionId">Emission identifier used to cache handler stacks.</param>
            public void HandleTargetedPostProcessing(
                ref InstanceId target,
                ref T message,
                int priority,
                long emissionId
            )
            {
                RunFastHandlersWithContext(
                    ref target,
                    GetContextHandlers(TypedSlotIndex.TargetedPostProcessFast),
                    ref message,
                    priority,
                    emissionId
                );
                RunHandlersWithContext(
                    ref target,
                    GetContextHandlers(TypedSlotIndex.TargetedPostProcessDefault),
                    ref message,
                    priority,
                    emissionId
                );
            }

            /// <summary>
            /// Runs targeted post-processing handlers that do not require a <see cref="InstanceId"/> target binding.
            /// </summary>
            /// <param name="target">Recipient of the message.</param>
            /// <param name="message">Message being processed.</param>
            /// <param name="priority">Priority bucket currently executing.</param>
            /// <param name="emissionId">Emission identifier used to cache handler stacks.</param>
            public void HandleTargetedWithoutTargetingPostProcessing(
                ref InstanceId target,
                ref T message,
                int priority,
                long emissionId
            )
            {
                RunFastHandlersWithContext(
                    ref target,
                    GetPriorityHandlers(TypedSlotIndex.TargetedPostProcessWithoutContextFast),
                    ref message,
                    priority,
                    emissionId
                );
                RunHandlers(
                    ref target,
                    GetPriorityHandlers(TypedSlotIndex.TargetedPostProcessWithoutContext),
                    ref message,
                    priority,
                    emissionId
                );
            }

            /// <summary>
            /// Runs broadcast post-processing handlers that expect a concrete source identifier.
            /// </summary>
            /// <param name="source">Origin of the message.</param>
            /// <param name="message">Message being processed.</param>
            /// <param name="priority">Priority bucket currently executing.</param>
            /// <param name="emissionId">Emission identifier used to cache handler stacks.</param>
            public void HandleSourcedBroadcastPostProcessing(
                ref InstanceId source,
                ref T message,
                int priority,
                long emissionId
            )
            {
                RunFastHandlersWithContext(
                    ref source,
                    GetContextHandlers(TypedSlotIndex.BroadcastPostProcessFast),
                    ref message,
                    priority,
                    emissionId
                );
                RunHandlersWithContext(
                    ref source,
                    GetContextHandlers(TypedSlotIndex.BroadcastPostProcessDefault),
                    ref message,
                    priority,
                    emissionId
                );
            }

            /// <summary>
            /// Runs broadcast post-processing handlers that do not rely on a specific source identifier.
            /// </summary>
            /// <param name="source">Origin of the message.</param>
            /// <param name="message">Message being processed.</param>
            /// <param name="priority">Priority bucket currently executing.</param>
            /// <param name="emissionId">Emission identifier used to cache handler stacks.</param>
            public void HandleBroadcastWithoutSourcePostProcessing(
                ref InstanceId source,
                ref T message,
                int priority,
                long emissionId
            )
            {
                RunFastHandlersWithContext(
                    ref source,
                    GetPriorityHandlers(TypedSlotIndex.BroadcastPostProcessWithoutContextFast),
                    ref message,
                    priority,
                    emissionId
                );
                RunHandlers(
                    ref source,
                    GetPriorityHandlers(TypedSlotIndex.BroadcastPostProcessWithoutContext),
                    ref message,
                    priority,
                    emissionId
                );
            }

            /// <summary>
            /// Adds a TargetedHandler to listen to Messages of the given type, returning a deregistration action.
            /// </summary>
            /// <param name="target">Target the handler is for.</param>
            /// <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 AddTargetedHandler(
                InstanceId target,
                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(
                    target,
                    GetOrCreateContextHandlers(TypedSlotIndex.TargetedHandleDefault),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus,
                    flatInvoker
                );
            }

            /// <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>
            /// <param name="target">Target the handler is for.</param>
            /// <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 AddTargetedHandler(
                InstanceId target,
                FastHandler<T> originalHandler,
                FastHandler<T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                return AddHandlerPreservingPriorityKey(
                    target,
                    GetOrCreateContextHandlers(TypedSlotIndex.TargetedHandleFast),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus
                );
            }

            /// <summary>
            /// Adds a TargetedWithoutTargetingHandler 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 AddTargetedWithoutTargetingHandler(
                Action<InstanceId, T> originalHandler,
                Action<InstanceId, T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                // Adapt the AUGMENTED handler to FastHandlerWithContext form
                // exactly once, at registration time, so bus-side flat snapshot
                // rebuilds resolve default registrations without allocating
                // closures.
                FastHandlerWithContext<T> flatInvoker = (ref InstanceId context, ref T message) =>
                    handler(context, message);
                return AddHandlerPreservingPriorityKey(
                    GetOrCreatePriorityHandlers(
                        TypedSlotIndex.TargetedHandleWithoutContext,
                        requiresContext: false
                    ),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus,
                    flatInvoker
                );
            }

            /// <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>
            /// <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 AddTargetedWithoutTargetingHandler(
                FastHandlerWithContext<T> originalHandler,
                FastHandlerWithContext<T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                return AddHandlerPreservingPriorityKey(
                    GetOrCreatePriorityHandlers(
                        TypedSlotIndex.TargetedHandleWithoutContextFast,
                        requiresContext: false
                    ),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus
                );
            }

            /// <summary>
            /// 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>
            internal TypedHandlerDeregistrationState AddUntargetedHandler(
                Action<T> originalHandler,
                FastHandler<T> flatInvoker,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                return AddHandlerPreservingPriorityKey(
                    GetOrCreatePriorityHandlers(
                        TypedSlotIndex.UntargetedHandleDefault,
                        requiresContext: false
                    ),
                    originalHandler,
                    originalHandler,
                    deregistration,
                    priority,
                    messageBus,
                    flatInvoker
                );
            }

            /// <summary>
            /// Adds a fast UntargetedHandler to listen to Messages of the given type, returning a deregistration action.
            /// </summary>
            /// <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(
                FastHandler<T> originalHandler,
                FastHandler<T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                return AddHandlerPreservingPriorityKey(
                    GetOrCreatePriorityHandlers(
                        TypedSlotIndex.UntargetedHandleFast,
                        requiresContext: false
                    ),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus
                );
            }

            /// <summary>
            /// Adds a SourcedBroadcastHandler to listen to Messages of the given type from an entity, returning a deregistration action.
            /// </summary>
            /// <param name="source">The Source of the handler is for.</param>
            /// <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 AddSourcedBroadcastHandler(
                InstanceId source,
                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(
                    source,
                    GetOrCreateContextHandlers(TypedSlotIndex.BroadcastHandleDefault),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus,
                    flatInvoker
                );
            }

            /// <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>
            /// <param name="source">The Source of the handler is for.</param>
            /// <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 AddSourcedBroadcastHandler(
                InstanceId source,
                FastHandler<T> originalHandler,
                FastHandler<T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                return AddHandlerPreservingPriorityKey(
                    source,
                    GetOrCreateContextHandlers(TypedSlotIndex.BroadcastHandleFast),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus
                );
            }

            /// <summary>
            /// Adds a SourcedBroadcastWithoutSourceHandler to listen to Messages of the given type from an entity, 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 AddSourcedBroadcastWithoutSourceHandler(
                Action<InstanceId, T> originalHandler,
                Action<InstanceId, T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                // Adapt the AUGMENTED handler to FastHandlerWithContext form
                // exactly once, at registration time, so bus-side flat snapshot
                // rebuilds resolve default registrations without allocating
                // closures.
                FastHandlerWithContext<T> flatInvoker = (ref InstanceId context, ref T message) =>
                    handler(context, message);
                // Preserve the priority bucket during the current emission so frozen snapshots remain valid
                return AddHandlerPreservingPriorityKey(
                    GetOrCreatePriorityHandlers(
                        TypedSlotIndex.BroadcastHandleWithoutContext,
                        requiresContext: false
                    ),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus,
                    flatInvoker
                );
            }

            /// <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>
            /// <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 AddSourcedBroadcastWithoutSourceHandler(
                FastHandlerWithContext<T> originalHandler,
                FastHandlerWithContext<T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                // Preserve the priority bucket during the current emission so frozen snapshots remain valid
                return AddHandlerPreservingPriorityKey(
                    GetOrCreatePriorityHandlers(
                        TypedSlotIndex.BroadcastHandleWithoutContextFast,
                        requiresContext: false
                    ),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus
                );
            }

            /// <summary>
            /// Adds a Global UntargetedHandler to listen to all Untargeted Messages of all types, returning the deregistration action.
            /// </summary>
            /// <param name="handler">Relevant MessageHandler.</param>
            /// <returns>De-registration action to unregister the handler.</returns>
            public GlobalHandlerDeregistrationState AddGlobalUntargetedHandler(
                Action<IUntargetedMessage> originalHandler,
                Action<IUntargetedMessage> handler,
                IMessageBus messageBus
            )
            {
                return AddHandler(
                    GetOrCreateGlobalSlot(TypedGlobalSlotIndex.UntargetedDefault),
                    originalHandler,
                    handler,
                    messageBus
                );
            }

            /// <summary>
            /// 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>
            /// <returns>De-registration action to unregister the handler.</returns>
            public GlobalHandlerDeregistrationState AddGlobalUntargetedHandler(
                FastHandler<IUntargetedMessage> originalHandler,
                FastHandler<IUntargetedMessage> handler,
                IMessageBus messageBus
            )
            {
                return AddHandler(
                    GetOrCreateGlobalSlot(TypedGlobalSlotIndex.UntargetedFast),
                    originalHandler,
                    handler,
                    messageBus
                );
            }

            /// <summary>
            /// 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>
            /// <returns>De-registration action to unregister the handler.</returns>
            public GlobalHandlerDeregistrationState AddGlobalTargetedHandler(
                Action<InstanceId, ITargetedMessage> originalHandler,
                Action<InstanceId, ITargetedMessage> handler,
                IMessageBus messageBus
            )
            {
                return AddHandler(
                    GetOrCreateGlobalSlot(TypedGlobalSlotIndex.TargetedDefault),
                    originalHandler,
                    handler,
                    messageBus
                );
            }

            /// <summary>
            /// 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>
            /// <returns>De-registration action to unregister the handler.</returns>
            public GlobalHandlerDeregistrationState AddGlobalTargetedHandler(
                FastHandlerWithContext<ITargetedMessage> originalHandler,
                FastHandlerWithContext<ITargetedMessage> handler,
                IMessageBus messageBus
            )
            {
                return AddHandler(
                    GetOrCreateGlobalSlot(TypedGlobalSlotIndex.TargetedFast),
                    originalHandler,
                    handler,
                    messageBus
                );
            }

            /// <summary>
            /// 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>
            /// <returns>De-registration action to unregister the handler.</returns>
            public GlobalHandlerDeregistrationState AddGlobalBroadcastHandler(
                Action<InstanceId, IBroadcastMessage> originalHandler,
                Action<InstanceId, IBroadcastMessage> handler,
                IMessageBus messageBus
            )
            {
                return AddHandler(
                    GetOrCreateGlobalSlot(TypedGlobalSlotIndex.BroadcastDefault),
                    originalHandler,
                    handler,
                    messageBus
                );
            }

            /// <summary>
            /// 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>
            /// <returns>De-registration action to unregister the handler.</returns>
            public GlobalHandlerDeregistrationState AddGlobalBroadcastHandler(
                FastHandlerWithContext<IBroadcastMessage> originalHandler,
                FastHandlerWithContext<IBroadcastMessage> handler,
                IMessageBus messageBus
            )
            {
                return AddHandler(
                    GetOrCreateGlobalSlot(TypedGlobalSlotIndex.BroadcastFast),
                    originalHandler,
                    handler,
                    messageBus
                );
            }

            /// <summary>
            /// Adds an Untargeted post-processor to be called after all other handlers have been called.
            /// </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 AddUntargetedPostProcessor(
                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.UntargetedPostProcessDefault,
                        requiresContext: false
                    ),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus,
                    flatInvoker
                );
            }

            /// <summary>
            /// Adds a fast Untargeted post-processor to be called after all other handlers have been called.
            /// </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 AddUntargetedPostProcessor(
                FastHandler<T> originalHandler,
                FastHandler<T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                return AddHandlerPreservingPriorityKey(
                    GetOrCreatePriorityHandlers(
                        TypedSlotIndex.UntargetedPostProcessFast,
                        requiresContext: false
                    ),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus
                );
            }

            /// <summary>
            /// Adds a Targeted post-processor to be called after all other handlers have been called.
            /// </summary>
            /// <param name="target">Target the handler is for.</param>
            /// <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 AddTargetedPostProcessor(
                InstanceId target,
                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(
                    target,
                    GetOrCreateContextHandlers(TypedSlotIndex.TargetedPostProcessDefault),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus,
                    flatInvoker
                );
            }

            /// <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>
            /// <param name="target">Target the handler is for.</param>
            /// <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 AddTargetedPostProcessor(
                InstanceId target,
                FastHandler<T> originalHandler,
                FastHandler<T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                return AddHandlerPreservingPriorityKey(
                    target,
                    GetOrCreateContextHandlers(TypedSlotIndex.TargetedPostProcessFast),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus
                );
            }

            /// <summary>
            /// Adds a Targeted post-processor to be called after all other handlers have been called after every message of the given type.
            /// </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 AddTargetedWithoutTargetingPostProcessor(
                Action<InstanceId, T> originalHandler,
                Action<InstanceId, T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                // Adapt the AUGMENTED handler to FastHandlerWithContext form
                // exactly once, at registration time, so bus-side flat snapshot
                // rebuilds resolve default registrations without allocating
                // closures.
                FastHandlerWithContext<T> flatInvoker = (ref InstanceId context, ref T message) =>
                    handler(context, message);
                return AddHandlerPreservingPriorityKey(
                    GetOrCreatePriorityHandlers(
                        TypedSlotIndex.TargetedPostProcessWithoutContext,
                        requiresContext: false
                    ),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus,
                    flatInvoker
                );
            }

            /// <summary>
            /// Adds a Targeted (without-targeting) post-processor whose by-ref
            /// context flat invoker was already built by the caller (the registration
            /// token folds diagnostics into one
            /// <see cref="FastHandlerWithContext{T}"/>), so the default slot stores a
            /// single closure instead of an <see cref="Action{T1, T2}"/> wrapper plus a
            /// separately allocated FastHandlerWithContext adapter.
            /// <paramref name="originalHandler"/> is the dedup/identity key and is never
            /// invoked for the default slot.
            /// </summary>
            internal 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>
            /// <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 AddTargetedWithoutTargetingPostProcessor(
                FastHandlerWithContext<T> originalHandler,
                FastHandlerWithContext<T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                return AddHandlerPreservingPriorityKey(
                    GetOrCreatePriorityHandlers(
                        TypedSlotIndex.TargetedPostProcessWithoutContextFast,
                        requiresContext: false
                    ),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus
                );
            }

            /// <summary>
            /// Adds a Broadcast post-processor to be called after all other handlers have been called.
            /// </summary>
            /// <param name="source">The Source the handler is for.</param>
            /// <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 AddBroadcastPostProcessor(
                InstanceId source,
                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(
                    source,
                    GetOrCreateContextHandlers(TypedSlotIndex.BroadcastPostProcessDefault),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus,
                    flatInvoker
                );
            }

            /// <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>
            /// <param name="source">The Source the handler is for.</param>
            /// <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 AddBroadcastPostProcessor(
                InstanceId source,
                FastHandler<T> originalHandler,
                FastHandler<T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                return AddHandlerPreservingPriorityKey(
                    source,
                    GetOrCreateContextHandlers(TypedSlotIndex.BroadcastPostProcessFast),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus
                );
            }

            /// <summary>
            /// Adds a Broadcast post-processor to be called after all other handlers have been called for every message of the given type.
            /// </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 AddBroadcastWithoutSourcePostProcessor(
                Action<InstanceId, T> originalHandler,
                Action<InstanceId, T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                // Adapt the AUGMENTED handler to FastHandlerWithContext form
                // exactly once, at registration time, so bus-side flat snapshot
                // rebuilds resolve default registrations without allocating
                // closures.
                FastHandlerWithContext<T> flatInvoker = (ref InstanceId context, ref T message) =>
                    handler(context, message);
                return AddHandlerPreservingPriorityKey(
                    GetOrCreatePriorityHandlers(
                        TypedSlotIndex.BroadcastPostProcessWithoutContext,
                        requiresContext: false
                    ),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus,
                    flatInvoker
                );
            }

            /// <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>
            /// <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 AddBroadcastWithoutSourcePostProcessor(
                FastHandlerWithContext<T> originalHandler,
                FastHandlerWithContext<T> handler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                return AddHandlerPreservingPriorityKey(
                    GetOrCreatePriorityHandlers(
                        TypedSlotIndex.BroadcastPostProcessWithoutContextFast,
                        requiresContext: false
                    ),
                    originalHandler,
                    handler,
                    deregistration,
                    priority,
                    messageBus
                );
            }

            // Context-aware variant that preserves the priority and context key
            // mappings on deregistration so frozen dispatch snapshots remain valid
            // for any in-flight emission. Trade-off: empty HandlerActionCache
            // entries (and their enclosing per-priority Dictionary) are not
            // reclaimed until either (a) a future registration at the same
            // (context, priority) pair reuses the cache, or (b) the owning
            // MessageHandler is destroyed. For typical Unity gameplay (a small
            // fixed set of priorities and a bounded set of long-lived target /
            // source InstanceIds) the residual footprint is on the order of
            // hundreds of bytes per MessageHandler. Code that interacts with
            // many transient InstanceIds (e.g. a global service that registers
            // handlers per ephemeral GameObject) should prefer recycling
            // MessageHandlers or routing through AddSourcedBroadcastWithoutSourceHandler /
            // AddTargetedWithoutTargetingHandler to avoid the per-(context,priority)
            // outer-dictionary growth.
            // `flatInvoker` carries the pre-resolved flat-dispatch invoker for
            // default-shape registrations the bus-side flat snapshot consumes
            // (FastHandler adapter wrapping the augmented handler); see
            // HandlerActionCache.Entry.flatInvoker.
            private TypedHandlerDeregistrationState AddHandlerPreservingPriorityKey<TU>(
                InstanceId context,
                Dictionary<InstanceId, Dictionary<int, IHandlerActionCache>> handlersByContext,
                TU originalHandler,
                TU augmentedHandler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus,
                object flatInvoker = null
            )
            {
                if (
                    !handlersByContext.TryGetValue(
                        context,
                        out Dictionary<int, IHandlerActionCache> sortedHandlers
                    )
                )
                {
                    sortedHandlers = DxPools.TypedHandlerPriorityDicts.RentAndAdd(
                        handlersByContext,
                        context
                    );
                }

                if (
                    !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;
                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++;
                }

                long localSlotVersion = slot?.version ?? 0;
                long localResetGeneration =
                    global::DxMessaging.Core.MessageBus.MessageBus.GetResetGeneration(messageBus);

                // 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>(
                InstanceId context,
                ref Dictionary<
                    InstanceId,
                    Dictionary<int, HandlerActionCache<TU>>
                > handlersByContext,
                TU originalHandler,
                TU augmentedHandler,
                Action deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                handlersByContext ??=
                    new Dictionary<InstanceId, Dictionary<int, HandlerActionCache<TU>>>();

                if (
                    !handlersByContext.TryGetValue(
                        context,
                        out Dictionary<int, HandlerActionCache<TU>> sortedHandlers
                    )
                )
                {
                    sortedHandlers = new Dictionary<int, HandlerActionCache<TU>>();
                    handlersByContext[context] = sortedHandlers;
                }

                if (!sortedHandlers.TryGetValue(priority, out 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)
                    : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);

                cache.entries[originalHandler] = entry;
                cache.version++;

                Dictionary<
                    InstanceId,
                    Dictionary<int, HandlerActionCache<TU>>
                > localHandlersByContext = handlersByContext;

                return () =>
                {
                    if (!localHandlersByContext.TryGetValue(context, out sortedHandlers))
                    {
                        return;
                    }

                    if (
                        !sortedHandlers.TryGetValue(priority, out HandlerActionCache<TU> localCache)
                    )
                    {
                        return;
                    }

                    if (
                        !localCache.entries.TryGetValue(
                            originalHandler,
                            out HandlerActionCache<TU>.Entry localEntry
                        )
                    )
                    {
                        return;
                    }

                    localCache.version++;

                    deregistration?.Invoke();

                    if (localEntry.count <= 1)
                    {
                        _ = localCache.entries.Remove(originalHandler);
                        localCache.version++;
                        // Deliberately keep the priority and context mappings to preserve
                        // frozen snapshots for the current emission.
                        return;
                    }

                    localEntry = new HandlerActionCache<TU>.Entry(
                        localEntry.handler,
                        localEntry.count - 1
                    );

                    localCache.entries[originalHandler] = localEntry;
                };
            }

            private static void RunFastHandlersWithContext<TMessage>(
                ref InstanceId context,
                Dictionary<int, IHandlerActionCache> fastHandlers,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
            {
                RunFastHandlers(ref context, fastHandlers, ref message, priority, emissionId);
            }

            private static void RunFastHandlersWithContext<TMessage>(
                ref InstanceId context,
                Dictionary<InstanceId, Dictionary<int, IHandlerActionCache>> fastHandlersByContext,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
            {
                if (
                    fastHandlersByContext is not { Count: > 0 }
                    || !fastHandlersByContext.TryGetValue(
                        context,
                        out Dictionary<int, IHandlerActionCache> cache
                    )
                )
                {
                    return;
                }

                RunFastHandlers(cache, ref message, priority, emissionId);
            }

            private static void RunFastHandlersWithContext<TMessage>(
                ref InstanceId context,
                Dictionary<
                    int,
                    HandlerActionCache<FastHandlerWithContext<T>>
                > fastHandlersByContext,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
            {
                if (fastHandlersByContext is not { Count: > 0 })
                {
                    return;
                }

                RunFastHandlers(
                    ref context,
                    fastHandlersByContext,
                    ref message,
                    priority,
                    emissionId
                );
            }

            private static void RunFastHandlersWithContext<TMessage>(
                ref InstanceId context,
                Dictionary<
                    InstanceId,
                    Dictionary<int, HandlerActionCache<FastHandler<T>>>
                > fastHandlersByContext,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
            {
                if (
                    fastHandlersByContext is not { Count: > 0 }
                    || !fastHandlersByContext.TryGetValue(
                        context,
                        out Dictionary<int, HandlerActionCache<FastHandler<T>>> cache
                    )
                )
                {
                    return;
                }

                RunFastHandlers(cache, ref message, priority, emissionId);
            }

            private static void RunFastHandlers<TMessage>(
                Dictionary<int, IHandlerActionCache> fastHandlers,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
            {
                if (fastHandlers is not { Count: > 0 })
                {
                    return;
                }

                if (
                    !fastHandlers.TryGetValue(priority, out IHandlerActionCache erasedCache)
                    || erasedCache is not HandlerActionCache<FastHandler<T>> cache
                )
                {
                    return;
                }

                ref T typedMessage = ref DxUnsafe.As<TMessage, T>(ref message);
                List<FastHandler<T>> handlers = GetOrAddNewHandlerStack(cache, emissionId);
                int handlersCount = handlers.Count;
                switch (handlersCount)
                {
                    case 1:
                    {
                        handlers[0](ref typedMessage);
                        return;
                    }
                    case 2:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        return;
                    }
                    case 3:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        return;
                    }
                    case 4:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref typedMessage);
                        return;
                    }
                    case 5:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref typedMessage);
                        if (handlers.Count < 5)
                        {
                            return;
                        }
                        handlers[4](ref typedMessage);
                        return;
                    }
                }

                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                {
                    handlers[i](ref typedMessage);
                }
            }

            private static void RunFastHandlers<TMessage>(
                Dictionary<int, HandlerActionCache<FastHandler<T>>> fastHandlers,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
            {
                if (fastHandlers is not { Count: > 0 })
                {
                    return;
                }

                if (
                    !fastHandlers.TryGetValue(
                        priority,
                        out HandlerActionCache<FastHandler<T>> cache
                    )
                )
                {
                    return;
                }

                ref T typedMessage = ref DxUnsafe.As<TMessage, T>(ref message);
                List<FastHandler<T>> handlers = GetOrAddNewHandlerStack(cache, emissionId);
                int handlersCount = handlers.Count;
                switch (handlersCount)
                {
                    case 1:
                    {
                        handlers[0](ref typedMessage);
                        return;
                    }
                    case 2:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        return;
                    }
                    case 3:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        return;
                    }
                    case 4:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref typedMessage);
                        return;
                    }
                    case 5:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref typedMessage);
                        if (handlers.Count < 5)
                        {
                            return;
                        }
                        handlers[4](ref typedMessage);
                        return;
                    }
                }

                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                {
                    handlers[i](ref typedMessage);
                }
            }

            private static void RunFastHandlers<TMessage, TU>(
                HandlerActionCache<FastHandler<TU>> cache,
                ref TMessage message,
                long emissionId
            )
                where TMessage : IMessage
                where TU : IMessage
            {
                // 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
                // snapshot itself is empty.
                //
                // 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
                // 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
                // entry storage no longer reaches.
                if (cache == null)
                {
                    return;
                }

                ref TU typedMessage = ref DxUnsafe.As<TMessage, TU>(ref message);
                List<FastHandler<TU>> handlers = GetOrAddNewHandlerStack(cache, emissionId);
                int handlersCount = handlers.Count;
                if (handlersCount == 0)
                {
                    return;
                }
                switch (handlersCount)
                {
                    case 1:
                    {
                        handlers[0](ref typedMessage);
                        return;
                    }
                    case 2:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        return;
                    }
                    case 3:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        return;
                    }
                    case 4:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref typedMessage);
                        return;
                    }
                    case 5:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref typedMessage);
                        if (handlers.Count < 5)
                        {
                            return;
                        }
                        handlers[4](ref typedMessage);
                        return;
                    }
                }

                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                {
                    handlers[i](ref typedMessage);
                }
            }

            private static void RunFastHandlers<TMessage, TU>(
                ref InstanceId context,
                HandlerActionCache<FastHandlerWithContext<TU>> cache,
                ref TMessage message,
                long emissionId
            )
                where TMessage : IMessage
                where TU : IMessage
            {
                // Snapshot semantics: see comment on the FastHandler<TU> overload.
                // The pinned emission snapshot may still hold handlers even when
                // the live entry storage has been drained mid-emit.
                if (cache == null)
                {
                    return;
                }

                ref TU typedMessage = ref DxUnsafe.As<TMessage, TU>(ref message);
                List<FastHandlerWithContext<TU>> handlers = GetOrAddNewHandlerStack(
                    cache,
                    emissionId
                );
                int handlersCount = handlers.Count;
                if (handlersCount == 0)
                {
                    return;
                }
                switch (handlersCount)
                {
                    case 1:
                    {
                        handlers[0](ref context, ref typedMessage);
                        return;
                    }
                    case 2:
                    {
                        handlers[0](ref context, ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref context, ref typedMessage);
                        return;
                    }
                    case 3:
                    {
                        handlers[0](ref context, ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref context, ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref context, ref typedMessage);
                        return;
                    }
                    case 4:
                    {
                        handlers[0](ref context, ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref context, ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref context, ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref context, ref typedMessage);
                        return;
                    }
                    case 5:
                    {
                        handlers[0](ref context, ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref context, ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref context, ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref context, ref typedMessage);
                        if (handlers.Count < 5)
                        {
                            return;
                        }
                        handlers[4](ref context, ref typedMessage);
                        return;
                    }
                }

                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                {
                    handlers[i](ref context, ref typedMessage);
                }
            }

            private static void RunFastHandlers<TMessage>(
                ref InstanceId context,
                Dictionary<int, IHandlerActionCache> fastHandlers,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
            {
                if (fastHandlers is not { Count: > 0 })
                {
                    return;
                }

                if (
                    !fastHandlers.TryGetValue(priority, out IHandlerActionCache erasedCache)
                    || erasedCache is not HandlerActionCache<FastHandlerWithContext<T>> cache
                )
                {
                    return;
                }

                RunFastHandlers(ref context, cache, ref message, emissionId);
            }

            private static void RunFastHandlers<TMessage, TU>(
                ref InstanceId context,
                Dictionary<int, IHandlerActionCache> fastHandlers,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
                where TU : IMessage
            {
                if (fastHandlers is not { Count: > 0 })
                {
                    return;
                }

                if (
                    !fastHandlers.TryGetValue(priority, out IHandlerActionCache erasedCache)
                    || erasedCache is not HandlerActionCache<FastHandlerWithContext<TU>> cache
                )
                {
                    return;
                }

                RunFastHandlers(ref context, cache, ref message, emissionId);
            }

            private static void RunFastHandlers<TMessage, TU>(
                ref InstanceId context,
                Dictionary<int, HandlerActionCache<FastHandlerWithContext<TU>>> fastHandlers,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
                where TU : IMessage
            {
                if (fastHandlers is not { Count: > 0 })
                {
                    return;
                }

                if (
                    !fastHandlers.TryGetValue(
                        priority,
                        out HandlerActionCache<FastHandlerWithContext<TU>> cache
                    )
                )
                {
                    return;
                }

                ref TU typedMessage = ref DxUnsafe.As<TMessage, TU>(ref message);
                List<FastHandlerWithContext<TU>> handlers = GetOrAddNewHandlerStack(
                    cache,
                    emissionId
                );
                int handlersCount = handlers.Count;
                switch (handlersCount)
                {
                    case 1:
                    {
                        handlers[0](ref context, ref typedMessage);
                        return;
                    }
                    case 2:
                    {
                        handlers[0](ref context, ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref context, ref typedMessage);
                        return;
                    }
                    case 3:
                    {
                        handlers[0](ref context, ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref context, ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref context, ref typedMessage);
                        return;
                    }
                    case 4:
                    {
                        handlers[0](ref context, ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref context, ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref context, ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref context, ref typedMessage);
                        return;
                    }
                    case 5:
                    {
                        handlers[0](ref context, ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref context, ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref context, ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref context, ref typedMessage);
                        if (handlers.Count < 5)
                        {
                            return;
                        }
                        handlers[4](ref context, ref typedMessage);
                        return;
                    }
                }

                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                {
                    handlers[i](ref context, ref typedMessage);
                }
            }

            private static void RunHandlersWithContext<TMessage>(
                ref InstanceId context,
                Dictionary<InstanceId, Dictionary<int, IHandlerActionCache>> handlersByContext,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
            {
                if (
                    handlersByContext is not { Count: > 0 }
                    || !handlersByContext.TryGetValue(
                        context,
                        out Dictionary<int, IHandlerActionCache> cache
                    )
                )
                {
                    return;
                }

                RunHandlers(cache, ref message, priority, emissionId);
            }

            private static void RunHandlersWithContext<TMessage>(
                ref InstanceId context,
                Dictionary<
                    InstanceId,
                    Dictionary<int, HandlerActionCache<Action<T>>>
                > handlersByContext,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
            {
                if (
                    handlersByContext is not { Count: > 0 }
                    || !handlersByContext.TryGetValue(
                        context,
                        out Dictionary<int, HandlerActionCache<Action<T>>> cache
                    )
                )
                {
                    return;
                }

                RunHandlers(cache, ref message, priority, emissionId);
            }

            private static void RunHandlers<TMessage>(
                Dictionary<int, IHandlerActionCache> sortedHandlers,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
            {
                if (sortedHandlers is not { Count: > 0 })
                {
                    return;
                }

                if (
                    !sortedHandlers.TryGetValue(priority, out IHandlerActionCache erasedCache)
                    || erasedCache is not HandlerActionCache<Action<T>> cache
                )
                {
                    return;
                }

                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](ref typedMessage);
                        return;
                    }
                    case 2:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        return;
                    }
                    case 3:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        return;
                    }
                    case 4:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref typedMessage);
                        return;
                    }
                    case 5:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref typedMessage);
                        if (handlers.Count < 5)
                        {
                            return;
                        }
                        handlers[4](ref typedMessage);
                        return;
                    }
                }

                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                {
                    handlers[i](ref typedMessage);
                }
            }

            private static void RunHandlers<TMessage>(
                Dictionary<int, HandlerActionCache<Action<T>>> sortedHandlers,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
            {
                if (sortedHandlers is not { Count: > 0 })
                {
                    return;
                }

                if (!sortedHandlers.TryGetValue(priority, out HandlerActionCache<Action<T>> cache))
                {
                    return;
                }

                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](ref typedMessage);
                        return;
                    }
                    case 2:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        return;
                    }
                    case 3:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        return;
                    }
                    case 4:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref typedMessage);
                        return;
                    }
                    case 5:
                    {
                        handlers[0](ref typedMessage);
                        if (handlers.Count < 2)
                        {
                            return;
                        }
                        handlers[1](ref typedMessage);
                        if (handlers.Count < 3)
                        {
                            return;
                        }
                        handlers[2](ref typedMessage);
                        if (handlers.Count < 4)
                        {
                            return;
                        }
                        handlers[3](ref typedMessage);
                        if (handlers.Count < 5)
                        {
                            return;
                        }
                        handlers[4](ref typedMessage);
                        return;
                    }
                }

                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                {
                    handlers[i](ref typedMessage);
                }
            }

            private static void RunHandlers<TMessage>(
                ref InstanceId context,
                Dictionary<int, IHandlerActionCache> handlers,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
            {
                if (handlers is not { Count: > 0 })
                {
                    return;
                }

                if (
                    !handlers.TryGetValue(priority, out IHandlerActionCache erasedCache)
                    || erasedCache is not HandlerActionCache<Action<InstanceId, T>> cache
                )
                {
                    return;
                }

                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](ref context, ref typedMessage);
                        return;
                    }
                    case 2:
                    {
                        typedHandlers[0](ref context, ref typedMessage);
                        if (typedHandlers.Count < 2)
                        {
                            return;
                        }
                        typedHandlers[1](ref context, ref typedMessage);
                        return;
                    }
                    case 3:
                    {
                        typedHandlers[0](ref context, ref typedMessage);
                        if (typedHandlers.Count < 2)
                        {
                            return;
                        }
                        typedHandlers[1](ref context, ref typedMessage);
                        if (typedHandlers.Count < 3)
                        {
                            return;
                        }
                        typedHandlers[2](ref context, ref typedMessage);
                        return;
                    }
                    case 4:
                    {
                        typedHandlers[0](ref context, ref typedMessage);
                        if (typedHandlers.Count < 2)
                        {
                            return;
                        }
                        typedHandlers[1](ref context, ref typedMessage);
                        if (typedHandlers.Count < 3)
                        {
                            return;
                        }
                        typedHandlers[2](ref context, ref typedMessage);
                        if (typedHandlers.Count < 4)
                        {
                            return;
                        }
                        typedHandlers[3](ref context, ref typedMessage);
                        return;
                    }
                    case 5:
                    {
                        typedHandlers[0](ref context, ref typedMessage);
                        if (typedHandlers.Count < 2)
                        {
                            return;
                        }
                        typedHandlers[1](ref context, ref typedMessage);
                        if (typedHandlers.Count < 3)
                        {
                            return;
                        }
                        typedHandlers[2](ref context, ref typedMessage);
                        if (typedHandlers.Count < 4)
                        {
                            return;
                        }
                        typedHandlers[3](ref context, ref typedMessage);
                        if (typedHandlers.Count < 5)
                        {
                            return;
                        }
                        typedHandlers[4](ref context, ref typedMessage);
                        return;
                    }
                }

                for (int i = 0; i < handlersCount && i < typedHandlers.Count; ++i)
                {
                    typedHandlers[i](ref context, ref typedMessage);
                }
            }

            private static void RunHandlers<TMessage>(
                ref InstanceId context,
                Dictionary<int, HandlerActionCache<Action<InstanceId, T>>> handlers,
                ref TMessage message,
                int priority,
                long emissionId
            )
                where TMessage : IMessage
            {
                if (handlers is not { Count: > 0 })
                {
                    return;
                }

                if (
                    !handlers.TryGetValue(
                        priority,
                        out HandlerActionCache<Action<InstanceId, T>> cache
                    )
                )
                {
                    return;
                }

                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](ref context, ref typedMessage);
                        return;
                    }
                    case 2:
                    {
                        typedHandlers[0](ref context, ref typedMessage);
                        if (typedHandlers.Count < 2)
                        {
                            return;
                        }
                        typedHandlers[1](ref context, ref typedMessage);
                        return;
                    }
                    case 3:
                    {
                        typedHandlers[0](ref context, ref typedMessage);
                        if (typedHandlers.Count < 2)
                        {
                            return;
                        }
                        typedHandlers[1](ref context, ref typedMessage);
                        if (typedHandlers.Count < 3)
                        {
                            return;
                        }
                        typedHandlers[2](ref context, ref typedMessage);
                        return;
                    }
                    case 4:
                    {
                        typedHandlers[0](ref context, ref typedMessage);
                        if (typedHandlers.Count < 2)
                        {
                            return;
                        }
                        typedHandlers[1](ref context, ref typedMessage);
                        if (typedHandlers.Count < 3)
                        {
                            return;
                        }
                        typedHandlers[2](ref context, ref typedMessage);
                        if (typedHandlers.Count < 4)
                        {
                            return;
                        }
                        typedHandlers[3](ref context, ref typedMessage);
                        return;
                    }
                    case 5:
                    {
                        typedHandlers[0](ref context, ref typedMessage);
                        if (typedHandlers.Count < 2)
                        {
                            return;
                        }
                        typedHandlers[1](ref context, ref typedMessage);
                        if (typedHandlers.Count < 3)
                        {
                            return;
                        }
                        typedHandlers[2](ref context, ref typedMessage);
                        if (typedHandlers.Count < 4)
                        {
                            return;
                        }
                        typedHandlers[3](ref context, ref typedMessage);
                        if (typedHandlers.Count < 5)
                        {
                            return;
                        }
                        typedHandlers[4](ref context, ref typedMessage);
                        return;
                    }
                }

                for (int i = 0; i < handlersCount && i < typedHandlers.Count; ++i)
                {
                    typedHandlers[i](ref context, ref typedMessage);
                }
            }

            // Mid-dispatch clear contract: the List returned here is the LIVE
            // cache.cache list, not a copy. IHandlerActionCache.Reset() (bus
            // reset / sweep eviction) clears it IN PLACE, so every dispatch
            // loop that indexes the returned list re-checks list.Count before
            // each invocation past the first (and the >5 fallback loops bound
            // on the live Count). A reset fired from inside a handler then
            // cleanly stops the in-flight bucket: no peer delegate runs and
            // nothing throws. The re-check is a single inlined List.Count
            // field read on data already in cache, so steady-state dispatch
            // cost is unchanged.
            internal static List<TU> GetOrAddNewHandlerStack<TU>(
                HandlerActionCache<TU> actionCache,
                long emissionId
            )
            {
                if (actionCache.lastSeenEmissionId != emissionId)
                {
                    if (actionCache.version != actionCache.lastSeenVersion)
                    {
                        // 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();
                        int orderedCount = actionCache.entries.Count;
                        for (int i = 0; i < orderedCount; ++i)
                        {
                            list.Add(actionCache.entries.ValueAt(i).handler);
                        }
                        actionCache.lastSeenVersion = actionCache.version;
                    }
                    actionCache.lastSeenEmissionId = emissionId;
                }
                return actionCache.cache;
            }

            // Default-slot registrations may store the raw user Action as the
            // identity key while carrying diagnostics in Entry.flatInvoker. The
            // legacy Handle* path must dispatch that same flat invoker snapshot,
            // not Entry.handler, so diagnostics semantics match bus-side flat
            // dispatch if the legacy callback path is used directly.
            internal static List<TInvoker> GetOrAddNewFlatInvokerStack<TU, TInvoker>(
                HandlerActionCache<TU> actionCache,
                long emissionId
            )
                where TInvoker : class
            {
                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 GlobalHandlerDeregistrationState AddHandler<TU>(
                TypedGlobalSlot slot,
                TU originalHandler,
                TU augmentedHandler,
                IMessageBus messageBus
            )
            {
                slot.lastTouchTicks =
                    global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(messageBus);
                HandlerActionCache<TU> cache = slot.cache as HandlerActionCache<TU>;
                if (cache == null)
                {
                    cache = new HandlerActionCache<TU>();
                    slot.cache = 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)
                    : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);

                cache.entries[originalHandler] = entry;
                cache.version++;
                if (firstRegistration)
                {
                    slot.liveCount++;
                }

                long localSlotVersion = slot.version;
                long localResetGeneration =
                    global::DxMessaging.Core.MessageBus.MessageBus.GetResetGeneration(messageBus);

                return new GlobalHandlerDeregistrationState(
                    messageBus,
                    localResetGeneration,
                    slot,
                    localSlotVersion,
                    cache,
                    originalHandler
                );
            }

            private static Action AddHandler<TU>(
                InstanceId context,
                ref Dictionary<
                    InstanceId,
                    Dictionary<int, HandlerActionCache<TU>>
                > handlersByContext,
                TU originalHandler,
                TU augmentedHandler,
                Action deregistration,
                int priority,
                IMessageBus messageBus
            )
            {
                handlersByContext ??=
                    new Dictionary<InstanceId, Dictionary<int, HandlerActionCache<TU>>>();

                if (
                    !handlersByContext.TryGetValue(
                        context,
                        out Dictionary<int, HandlerActionCache<TU>> sortedHandlers
                    )
                )
                {
                    sortedHandlers = new Dictionary<int, HandlerActionCache<TU>>();
                    handlersByContext[context] = sortedHandlers;
                }

                if (!sortedHandlers.TryGetValue(priority, out 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)
                    : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);

                cache.entries[originalHandler] = entry;
                cache.version++;

                Dictionary<
                    InstanceId,
                    Dictionary<int, HandlerActionCache<TU>>
                > localHandlersByContext = handlersByContext;

                return () =>
                {
                    if (!localHandlersByContext.TryGetValue(context, out sortedHandlers))
                    {
                        return;
                    }

                    if (
                        !sortedHandlers.TryGetValue(priority, out HandlerActionCache<TU> localCache)
                    )
                    {
                        return;
                    }

                    if (
                        !localCache.entries.TryGetValue(
                            originalHandler,
                            out HandlerActionCache<TU>.Entry localEntry
                        )
                    )
                    {
                        return;
                    }

                    localCache.version++;

                    deregistration?.Invoke();

                    if (localEntry.count <= 1)
                    {
                        _ = localCache.entries.Remove(originalHandler);
                        localCache.version++;
                        if (localCache.entries.Count == 0)
                        {
                            _ = sortedHandlers.Remove(priority);
                            if (sortedHandlers.Count == 0)
                            {
                                localHandlersByContext.Remove(context);
                            }
                        }

                        return;
                    }

                    localEntry = new HandlerActionCache<TU>.Entry(
                        localEntry.handler,
                        localEntry.count - 1
                    );

                    localCache.entries[originalHandler] = localEntry;
                };
            }

            private static Action AddHandler<TU>(
                ref HandlerActionCache<TU> cache,
                TU originalHandler,
                TU augmentedHandler,
                Action deregistration
            )
            {
                cache ??= new HandlerActionCache<TU>();

                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)
                    : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);

                cache.entries[originalHandler] = entry;
                cache.version++;

                HandlerActionCache<TU> localCache = cache;

                return () =>
                {
                    if (
                        !localCache.entries.TryGetValue(
                            originalHandler,
                            out HandlerActionCache<TU>.Entry localEntry
                        )
                    )
                    {
                        return;
                    }

                    localCache.version++;

                    deregistration?.Invoke();

                    if (localEntry.count <= 1)
                    {
                        _ = localCache.entries.Remove(originalHandler);
                        localCache.version++;
                        return;
                    }

                    localEntry = new HandlerActionCache<TU>.Entry(
                        localEntry.handler,
                        localEntry.count - 1
                    );
                    localCache.entries[originalHandler] = localEntry;
                };
            }

            private static Action AddHandler<TU>(
                ref Dictionary<int, HandlerActionCache<TU>> handlers,
                TU originalHandler,
                TU augmentedHandler,
                Action deregistration,
                int priority,
                long emissionId
            )
            {
                handlers ??= new Dictionary<int, HandlerActionCache<TU>>();

                if (!handlers.TryGetValue(priority, out HandlerActionCache<TU> cache))
                {
                    cache = new HandlerActionCache<TU>();
                    handlers[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)
                    : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);

                cache.entries[originalHandler] = entry;
                cache.version++;

                Dictionary<int, HandlerActionCache<TU>> localHandlers = handlers;

                return () =>
                {
                    if (!localHandlers.TryGetValue(priority, out HandlerActionCache<TU> localCache))
                    {
                        return;
                    }

                    if (
                        !localCache.entries.TryGetValue(
                            originalHandler,
                            out HandlerActionCache<TU>.Entry localEntry
                        )
                    )
                    {
                        return;
                    }

                    localCache.version++;

                    deregistration?.Invoke();

                    if (localEntry.count <= 1)
                    {
                        _ = localCache.entries.Remove(originalHandler);
                        localCache.version++;
                        if (localCache.entries.Count == 0)
                        {
                            _ = localHandlers.Remove(priority);
                        }

                        return;
                    }

                    localEntry = new HandlerActionCache<TU>.Entry(
                        localEntry.handler,
                        localEntry.count - 1
                    );

                    localCache.entries[originalHandler] = localEntry;
                };
            }

            // Variant of AddHandler that preserves the priority key in the dictionary when the last entry is removed.
            // This ensures that during an in-flight emission (where handler stacks are already frozen),
            // subsequent removals do not cause lookups to fail for the current pass.
            // `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 TypedHandlerDeregistrationState AddHandlerPreservingPriorityKey<TU>(
                Dictionary<int, IHandlerActionCache> handlers,
                TU originalHandler,
                TU augmentedHandler,
                MessageBusRegistration deregistration,
                int priority,
                IMessageBus messageBus,
                object flatInvoker = null
            )
            {
                if (
                    !handlers.TryGetValue(priority, out IHandlerActionCache erasedCache)
                    || erasedCache is not HandlerActionCache<TU> cache
                )
                {
                    cache = new HandlerActionCache<TU>();
                    handlers[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;
                cache.version++;
                TypedSlot<T> slot = FindPrioritySlot(handlers);
                if (slot != null)
                {
                    slot.lastTouchTicks =
                        global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(
                            messageBus
                        );
                }
                if (slot != null && !slot.orderedPriorities.Contains(priority))
                {
                    slot.orderedPriorities.Add(priority);
                }
                if (firstRegistration && slot != null)
                {
                    slot.liveCount++;
                }

                long localSlotVersion = slot?.version ?? 0;
                long localResetGeneration =
                    global::DxMessaging.Core.MessageBus.MessageBus.GetResetGeneration(messageBus);

                // 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>(
                ref Dictionary<int, HandlerActionCache<TU>> handlers,
                TU originalHandler,
                TU augmentedHandler,
                Action deregistration,
                int priority,
                long emissionId
            )
            {
                handlers ??= new Dictionary<int, HandlerActionCache<TU>>();

                if (!handlers.TryGetValue(priority, out HandlerActionCache<TU> cache))
                {
                    cache = new HandlerActionCache<TU>();
                    handlers[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)
                    : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);

                cache.entries[originalHandler] = entry;
                cache.version++;

                Dictionary<int, HandlerActionCache<TU>> localHandlers = handlers;

                return () =>
                {
                    if (!localHandlers.TryGetValue(priority, out HandlerActionCache<TU> localCache))
                    {
                        return;
                    }

                    if (
                        !localCache.entries.TryGetValue(
                            originalHandler,
                            out HandlerActionCache<TU>.Entry localEntry
                        )
                    )
                    {
                        return;
                    }

                    localCache.version++;

                    deregistration?.Invoke();

                    if (localEntry.count <= 1)
                    {
                        _ = localCache.entries.Remove(originalHandler);
                        localCache.version++;
                        // 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
                    );

                    localCache.entries[originalHandler] = localEntry;
                };
            }
        }
    }
}