com.wallstop-studios.dxmessaging 2.2.0 → 3.1.0

package/Runtime/Core/MessageHandler.cs

@@ -2,10 +2,13 @@ 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.
@@ -34,302 +37,6 @@ namespace DxMessaging.Core
             IComparable,
             IComparable<MessageHandler>
     {
-        /// <summary>
-        /// Pre-freezes this handler's broadcast post-processor caches for the given message type, source, and priority
-        /// for the specified emission id, so registrations during the same emission are not observed.
-        /// </summary>
-        /// <typeparam name="T">Broadcast message type.</typeparam>
-        /// <param name="source">Source instance id.</param>
-        /// <param name="priority">Priority bucket to freeze.</param>
-        /// <param name="emissionId">Current emission id.</param>
-        /// <param name="messageBus">Bus whose typed handler mapping to use.</param>
-        internal void PrefreezeBroadcastPostProcessorsForEmission<T>(
-            InstanceId source,
-            int priority,
-            long emissionId,
-            IMessageBus messageBus
-        )
-            where T : IBroadcastMessage
-        {
-            if (!GetHandlerForType(messageBus, out TypedHandler<T> handler))
-            {
-                return;
-            }
-
-            if (
-                handler._broadcastPostProcessingFastHandlers != null
-                && handler._broadcastPostProcessingFastHandlers.TryGetValue(
-                    source,
-                    out Dictionary<int, HandlerActionCache<FastHandler<T>>> fastByPriority
-                )
-                && fastByPriority.TryGetValue(
-                    priority,
-                    out HandlerActionCache<FastHandler<T>> fastCache
-                )
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(fastCache, emissionId);
-            }
-
-            if (
-                handler._broadcastPostProcessingHandlers != null
-                && handler._broadcastPostProcessingHandlers.TryGetValue(
-                    source,
-                    out Dictionary<int, HandlerActionCache<Action<T>>> byPriority
-                )
-                && byPriority.TryGetValue(priority, out HandlerActionCache<Action<T>> cache)
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(cache, emissionId);
-            }
-        }
-
-        /// <summary>
-        /// Pre-freezes this handler's targeted post-processor caches for the given message type, target, and priority
-        /// for the specified emission id, so registrations during the same emission are not observed.
-        /// </summary>
-        /// <typeparam name="T">Targeted message type.</typeparam>
-        /// <param name="target">Target instance id.</param>
-        /// <param name="priority">Priority bucket to freeze.</param>
-        /// <param name="emissionId">Current emission id.</param>
-        /// <param name="messageBus">Bus whose typed handler mapping to use.</param>
-        internal void PrefreezeTargetedPostProcessorsForEmission<T>(
-            InstanceId target,
-            int priority,
-            long emissionId,
-            IMessageBus messageBus
-        )
-            where T : ITargetedMessage
-        {
-            if (!GetHandlerForType(messageBus, out TypedHandler<T> handler))
-            {
-                return;
-            }
-
-            if (
-                handler._targetedPostProcessingFastHandlers != null
-                && handler._targetedPostProcessingFastHandlers.TryGetValue(
-                    target,
-                    out Dictionary<int, HandlerActionCache<FastHandler<T>>> fastByPriority
-                )
-                && fastByPriority.TryGetValue(
-                    priority,
-                    out HandlerActionCache<FastHandler<T>> fastCache
-                )
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(fastCache, emissionId);
-            }
-
-            if (
-                handler._targetedPostProcessingHandlers != null
-                && handler._targetedPostProcessingHandlers.TryGetValue(
-                    target,
-                    out Dictionary<int, HandlerActionCache<Action<T>>> byPriority
-                )
-                && byPriority.TryGetValue(priority, out HandlerActionCache<Action<T>> cache)
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(cache, emissionId);
-            }
-        }
-
-        /// <summary>
-        /// Pre-freezes this handler's targeted-without-targeting handler caches for the given message type and priority
-        /// so that removals/additions during the same emission are not observed.
-        /// </summary>
-        internal void PrefreezeTargetedWithoutTargetingHandlersForEmission<T>(
-            int priority,
-            long emissionId,
-            IMessageBus messageBus
-        )
-            where T : ITargetedMessage
-        {
-            if (!GetHandlerForType(messageBus, out TypedHandler<T> handler))
-            {
-                return;
-            }
-
-            if (
-                handler._fastTargetedWithoutTargetingHandlers != null
-                && handler._fastTargetedWithoutTargetingHandlers.TryGetValue(
-                    priority,
-                    out HandlerActionCache<FastHandlerWithContext<T>> fastCache
-                )
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(fastCache, emissionId);
-            }
-
-            if (
-                handler._targetedWithoutTargetingHandlers != null
-                && handler._targetedWithoutTargetingHandlers.TryGetValue(
-                    priority,
-                    out HandlerActionCache<Action<InstanceId, T>> cache
-                )
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(cache, emissionId);
-            }
-        }
-
-        /// <summary>
-        /// Pre-freezes this handler's targeted-without-targeting post-processor caches for a given priority.
-        /// </summary>
-        internal void PrefreezeTargetedWithoutTargetingPostProcessorsForEmission<T>(
-            int priority,
-            long emissionId,
-            IMessageBus messageBus
-        )
-            where T : ITargetedMessage
-        {
-            if (!GetHandlerForType(messageBus, out TypedHandler<T> handler))
-            {
-                return;
-            }
-
-            if (
-                handler._fastTargetedWithoutTargetingPostProcessingHandlers != null
-                && handler._fastTargetedWithoutTargetingPostProcessingHandlers.TryGetValue(
-                    priority,
-                    out HandlerActionCache<FastHandlerWithContext<T>> fastCache
-                )
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(fastCache, emissionId);
-            }
-
-            if (
-                handler._targetedWithoutTargetingPostProcessingHandlers != null
-                && handler._targetedWithoutTargetingPostProcessingHandlers.TryGetValue(
-                    priority,
-                    out HandlerActionCache<Action<InstanceId, T>> cache
-                )
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(cache, emissionId);
-            }
-        }
-
-        /// <summary>
-        /// Pre-freezes this handler's untargeted post-processor caches for a given priority.
-        /// </summary>
-        internal void PrefreezeUntargetedPostProcessorsForEmission<T>(
-            int priority,
-            long emissionId,
-            IMessageBus messageBus
-        )
-            where T : IUntargetedMessage
-        {
-            if (!GetHandlerForType(messageBus, out TypedHandler<T> handler))
-            {
-                return;
-            }
-
-            if (
-                handler._untargetedPostProcessingFastHandlers != null
-                && handler._untargetedPostProcessingFastHandlers.TryGetValue(
-                    priority,
-                    out HandlerActionCache<FastHandler<T>> fastCache
-                )
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(fastCache, emissionId);
-            }
-
-            if (
-                handler._untargetedPostProcessingHandlers != null
-                && handler._untargetedPostProcessingHandlers.TryGetValue(
-                    priority,
-                    out HandlerActionCache<Action<T>> cache
-                )
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(cache, emissionId);
-            }
-        }
-
-        /// <summary>
-        /// Pre-freezes this handler's broadcast-without-source post-processor caches for a given priority.
-        /// </summary>
-        internal void PrefreezeBroadcastWithoutSourcePostProcessorsForEmission<T>(
-            int priority,
-            long emissionId,
-            IMessageBus messageBus
-        )
-            where T : IBroadcastMessage
-        {
-            if (!GetHandlerForType(messageBus, out TypedHandler<T> handler))
-            {
-                return;
-            }
-
-            if (
-                handler._fastBroadcastWithoutSourcePostProcessingHandlers != null
-                && handler._fastBroadcastWithoutSourcePostProcessingHandlers.TryGetValue(
-                    priority,
-                    out HandlerActionCache<FastHandlerWithContext<T>> fastCache
-                )
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(fastCache, emissionId);
-            }
-
-            if (
-                handler._broadcastWithoutSourcePostProcessingHandlers != null
-                && handler._broadcastWithoutSourcePostProcessingHandlers.TryGetValue(
-                    priority,
-                    out HandlerActionCache<Action<InstanceId, T>> cache
-                )
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(cache, emissionId);
-            }
-        }
-
-        /// <summary>
-        /// Pre-freezes this handler's broadcast-without-source handler caches for the given message type and priority
-        /// for the specified emission id, so removals during the same emission are not observed.
-        /// </summary>
-        /// <typeparam name="T">Broadcast message type.</typeparam>
-        /// <param name="priority">Priority bucket to freeze.</param>
-        /// <param name="emissionId">Current emission id.</param>
-        /// <param name="messageBus">Bus whose typed handler mapping to use.</param>
-        internal void PrefreezeBroadcastWithoutSourceHandlersForEmission<T>(
-            int priority,
-            long emissionId,
-            IMessageBus messageBus
-        )
-            where T : IBroadcastMessage
-        {
-            if (!GetHandlerForType(messageBus, out TypedHandler<T> handler))
-            {
-                return;
-            }
-
-            if (
-                handler._fastBroadcastWithoutSourceHandlers != null
-                && handler._fastBroadcastWithoutSourceHandlers.TryGetValue(
-                    priority,
-                    out HandlerActionCache<FastHandlerWithContext<T>> fastCache
-                )
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(fastCache, emissionId);
-            }
-
-            if (
-                handler._broadcastWithoutSourceHandlers != null
-                && handler._broadcastWithoutSourceHandlers.TryGetValue(
-                    priority,
-                    out HandlerActionCache<Action<InstanceId, T>> cache
-                )
-            )
-            {
-                _ = TypedHandler<T>.GetOrAddNewHandlerStack(cache, emissionId);
-            }
-        }
-
         /// <summary>
         /// High-performance handler that receives the message by reference (no boxing/copies).
         /// </summary>
@@ -378,6 +85,19 @@ namespace DxMessaging.Core
             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>
@@ -928,19 +648,19 @@ namespace DxMessaging.Core
                 return;
             }
 
-            if (handler._globalUntargetedFastHandlers != null)
+            HandlerActionCache<FastHandler<IUntargetedMessage>> fastCache = handler.GetGlobalCache<
+                FastHandler<IUntargetedMessage>
+            >(TypedGlobalSlotIndex.UntargetedFast);
+            if (fastCache != null)
             {
-                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(
-                    handler._globalUntargetedFastHandlers,
-                    emissionId
-                );
+                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(fastCache, emissionId);
             }
-            if (handler._globalUntargetedHandlers != null)
+            HandlerActionCache<Action<IUntargetedMessage>> cache = handler.GetGlobalCache<
+                Action<IUntargetedMessage>
+            >(TypedGlobalSlotIndex.UntargetedDefault);
+            if (cache != null)
             {
-                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(
-                    handler._globalUntargetedHandlers,
-                    emissionId
-                );
+                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(cache, emissionId);
             }
         }
 
@@ -954,19 +674,20 @@ namespace DxMessaging.Core
                 return;
             }
 
-            if (handler._globalTargetedFastHandlers != null)
-            {
-                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(
-                    handler._globalTargetedFastHandlers,
-                    emissionId
+            HandlerActionCache<FastHandlerWithContext<ITargetedMessage>> fastCache =
+                handler.GetGlobalCache<FastHandlerWithContext<ITargetedMessage>>(
+                    TypedGlobalSlotIndex.TargetedFast
                 );
+            if (fastCache != null)
+            {
+                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(fastCache, emissionId);
             }
-            if (handler._globalTargetedHandlers != null)
+            HandlerActionCache<Action<InstanceId, ITargetedMessage>> cache = handler.GetGlobalCache<
+                Action<InstanceId, ITargetedMessage>
+            >(TypedGlobalSlotIndex.TargetedDefault);
+            if (cache != null)
             {
-                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(
-                    handler._globalTargetedHandlers,
-                    emissionId
-                );
+                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(cache, emissionId);
             }
         }
 
@@ -980,19 +701,21 @@ namespace DxMessaging.Core
                 return;
             }
 
-            if (handler._globalBroadcastFastHandlers != null)
-            {
-                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(
-                    handler._globalBroadcastFastHandlers,
-                    emissionId
+            HandlerActionCache<FastHandlerWithContext<IBroadcastMessage>> fastCache =
+                handler.GetGlobalCache<FastHandlerWithContext<IBroadcastMessage>>(
+                    TypedGlobalSlotIndex.BroadcastFast
                 );
-            }
-            if (handler._globalBroadcastHandlers != null)
+            if (fastCache != null)
             {
-                _ = TypedHandler<IMessage>.GetOrAddNewHandlerStack(
-                    handler._globalBroadcastHandlers,
-                    emissionId
+                _ = 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);
             }
         }
 
@@ -1071,25 +794,28 @@ namespace DxMessaging.Core
             Action untargetedDeregistration = typedHandler.AddGlobalUntargetedHandler(
                 originalUntargetedMessageHandler,
                 untargetedMessageHandler,
-                NullDeregistration
+                NullDeregistration,
+                messageBus
             );
             Action targetedDeregistration = typedHandler.AddGlobalTargetedHandler(
                 originalTargetedMessageHandler,
                 targetedMessageHandler,
-                NullDeregistration
+                NullDeregistration,
+                messageBus
             );
             Action broadcastDeregistration = typedHandler.AddGlobalBroadcastHandler(
                 originalBroadcastMessageHandler,
                 broadcastMessageHandler,
-                NullDeregistration
+                NullDeregistration,
+                messageBus
             );
 
             return () =>
             {
+                messageBusDeregistration?.Invoke();
                 untargetedDeregistration();
                 targetedDeregistration();
                 broadcastDeregistration();
-                messageBusDeregistration?.Invoke();
             };
 
             void NullDeregistration()
@@ -1123,25 +849,28 @@ namespace DxMessaging.Core
             Action untargetedDeregistration = typedHandler.AddGlobalUntargetedHandler(
                 originalUntargetedMessageHandler,
                 untargetedMessageHandler,
-                NullDeregistration
+                NullDeregistration,
+                messageBus
             );
             Action targetedDeregistration = typedHandler.AddGlobalTargetedHandler(
                 originalTargetedMessageHandler,
                 targetedMessageHandler,
-                NullDeregistration
+                NullDeregistration,
+                messageBus
             );
             Action broadcastDeregistration = typedHandler.AddGlobalBroadcastHandler(
                 originalBroadcastMessageHandler,
                 broadcastMessageHandler,
-                NullDeregistration
+                NullDeregistration,
+                messageBus
             );
 
             return () =>
             {
+                messageBusDeregistration?.Invoke();
                 untargetedDeregistration();
                 targetedDeregistration();
                 broadcastDeregistration();
-                messageBusDeregistration?.Invoke();
             };
 
             void NullDeregistration()
@@ -1181,7 +910,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1216,7 +945,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1251,7 +980,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1286,7 +1015,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1318,7 +1047,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1350,7 +1079,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1381,7 +1110,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1412,7 +1141,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1443,7 +1172,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1474,7 +1203,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1505,7 +1234,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1536,7 +1265,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1572,7 +1301,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1607,7 +1336,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1638,7 +1367,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1669,7 +1398,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1704,7 +1433,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1739,7 +1468,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1771,7 +1500,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1803,7 +1532,7 @@ namespace DxMessaging.Core
                 messageHandler,
                 messageBusDeregistration,
                 priority,
-                messageBus.EmissionId
+                messageBus
             );
         }
 
@@ -1956,7 +1685,7 @@ namespace DxMessaging.Core
             MessageCache<object> handlersByType = _handlersByTypeByMessageBus[messageBusIndex];
             if (handlersByType.TryGetValue<T>(out object untypedHandler))
             {
-                return Unsafe.As<TypedHandler<T>>(untypedHandler);
+                return DxUnsafe.As<TypedHandler<T>>(untypedHandler);
             }
 
             TypedHandler<T> typedHandler = new();
@@ -1988,7 +1717,7 @@ namespace DxMessaging.Core
                     .TryGetValue<T>(out object untypedHandler)
             )
             {
-                existingTypedHandler = Unsafe.As<TypedHandler<T>>(untypedHandler);
+                existingTypedHandler = DxUnsafe.As<TypedHandler<T>>(untypedHandler);
                 return true;
             }
 
@@ -1996,675 +1725,931 @@ namespace DxMessaging.Core
             return false;
         }
 
-        internal int GetUntargetedPostProcessingPrefreezeCount<T>(
-            IMessageBus messageBus,
-            int priority
-        )
-            where T : IMessage
+        /// <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)
         {
-            if (
-                !GetHandlerForType(messageBus, out TypedHandler<T> handler)
-                || handler._untargetedPostProcessingFastHandlers == null
-            )
+            messageBus = ResolveMessageBus(messageBus);
+            int messageBusIndex = messageBus.RegisteredGlobalSequentialIndex;
+            if (messageBusIndex < 0 || _handlersByTypeByMessageBus.Count <= messageBusIndex)
             {
                 return 0;
             }
 
-            if (
-                handler._untargetedPostProcessingFastHandlers.TryGetValue(
-                    priority,
-                    out HandlerActionCache<FastHandler<T>> cache
-                )
-            )
+            int resetCount = 0;
+            MessageCache<object> handlersByType = _handlersByTypeByMessageBus[messageBusIndex];
+            foreach (object untypedHandler in _handlersByTypeByMessageBus[messageBusIndex])
             {
-                return cache.prefreezeInvocationCount;
+                if (untypedHandler is ITypedHandlerSlotSweeper sweeper)
+                {
+                    resetCount += sweeper.ResetEmptySlotsForSweep();
+                    if (sweeper.MarkedForOuterRemoval)
+                    {
+                        handlersByType.RemoveAtIndex(sweeper.MessageTypeIndex);
+                    }
+                }
             }
 
-            return 0;
+            return resetCount;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal UntargetedDispatchLink<T> GetOrCreateUntargetedDispatchLink<T>(
-            IMessageBus messageBus
-        )
-            where T : IMessage
+        internal int ResetAllTypedSlotsForBusReset(IMessageBus messageBus = null)
         {
-            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
-            return typedHandler.GetOrCreateUntargetedLink();
+            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;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal UntargetedPostDispatchLink<T> GetOrCreateUntargetedPostDispatchLink<T>(
-            IMessageBus messageBus
-        )
-            where T : IMessage
+        internal int CountEmptyTypedSlotsForSweep(IMessageBus messageBus = null)
         {
-            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
-            return typedHandler.GetOrCreateUntargetedPostLink();
+            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;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal TargetedDispatchLink<T> GetOrCreateTargetedDispatchLink<T>(IMessageBus messageBus)
-            where T : IMessage
+        internal bool HasTypedHandlersForBus(IMessageBus messageBus = null)
         {
-            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
-            return typedHandler.GetOrCreateTargetedLink();
+            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;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal TargetedPostDispatchLink<T> GetOrCreateTargetedPostDispatchLink<T>(
-            IMessageBus messageBus
+        /// <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
         {
-            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
-            return typedHandler.GetOrCreateTargetedPostLink();
+            if (!GetHandlerForType(messageBus, out TypedHandler<T> typedHandler))
+            {
+                return 0;
+            }
+
+            return CountFlatDelegates<FastHandler<T>>(
+                    typedHandler.GetPriorityHandlers(fastIndex),
+                    priority
+                )
+                + CountFlatDelegates<Action<T>>(
+                    typedHandler.GetPriorityHandlers(defaultIndex),
+                    priority
+                );
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal TargetedWithoutTargetingDispatchLink<T> GetOrCreateTargetedWithoutTargetingDispatchLink<T>(
-            IMessageBus messageBus
+        /// <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
         {
-            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
-            return typedHandler.GetOrCreateTargetedWithoutTargetingLink();
+            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
+                );
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal TargetedWithoutTargetingPostDispatchLink<T> GetOrCreateTargetedWithoutTargetingPostDispatchLink<T>(
-            IMessageBus messageBus
+        /// <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
         {
-            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
-            return typedHandler.GetOrCreateTargetedWithoutTargetingPostLink();
+            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
+                );
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal BroadcastDispatchLink<T> GetOrCreateBroadcastDispatchLink<T>(
-            IMessageBus messageBus
+        /// <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
         {
-            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
-            return typedHandler.GetOrCreateBroadcastLink();
+            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
+            );
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal BroadcastPostDispatchLink<T> GetOrCreateBroadcastPostDispatchLink<T>(
-            IMessageBus messageBus
+        /// <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
         {
-            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
-            return typedHandler.GetOrCreateBroadcastPostLink();
+            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
+            );
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal BroadcastWithoutSourceDispatchLink<T> GetOrCreateBroadcastWithoutSourceDispatchLink<T>(
-            IMessageBus messageBus
+        /// <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
         {
-            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
-            return typedHandler.GetOrCreateBroadcastWithoutSourceLink();
+            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)]
-        internal BroadcastWithoutSourcePostDispatchLink<T> GetOrCreateBroadcastWithoutSourcePostDispatchLink<T>(
-            IMessageBus messageBus
+        private static Dictionary<int, IHandlerActionCache> GetContextPriorityHandlers<T>(
+            TypedHandler<T> typedHandler,
+            int slotIndex,
+            InstanceId context
         )
             where T : IMessage
         {
-            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
-            return typedHandler.GetOrCreateBroadcastWithoutSourcePostLink();
+            Dictionary<InstanceId, Dictionary<int, IHandlerActionCache>> byContext =
+                typedHandler.GetContextHandlers(slotIndex);
+            if (
+                byContext != null
+                && byContext.TryGetValue(
+                    context,
+                    out Dictionary<int, IHandlerActionCache> byPriority
+                )
+            )
+            {
+                return byPriority;
+            }
+
+            return null;
         }
 
-        internal sealed class HandlerActionCache<T>
+        private static int CountFlatDelegates<TDelegate>(
+            Dictionary<int, IHandlerActionCache> byPriority,
+            int priority
+        )
         {
-            internal readonly struct Entry
+            if (
+                byPriority != null
+                && byPriority.TryGetValue(priority, out IHandlerActionCache erased)
+                && erased is HandlerActionCache<TDelegate> cache
+            )
             {
-                /// <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 = handler;
-                    this.count = count;
-                }
-
-                public readonly T handler;
-                public readonly int count;
+                return cache.insertionOrder.Count;
             }
 
-            public readonly Dictionary<T, Entry> entries = new();
-            public readonly List<T> cache = new();
-            public long version;
-            public long lastSeenVersion = -1;
-            public long lastSeenEmissionId;
-            internal int prefreezeInvocationCount;
+            return 0;
         }
 
-        internal sealed class UntargetedDispatchLink<T>
+        private int FillFastFlatEntries<T>(
+            Dictionary<int, IHandlerActionCache> byPriority,
+            int priority,
+            FlatDispatchEntry<T>[] target,
+            int writeIndex
+        )
             where T : IMessage
         {
-            private readonly TypedHandler<T> typedHandler;
-
-            internal UntargetedDispatchLink(TypedHandler<T> typedHandler)
+            if (
+                byPriority == null
+                || !byPriority.TryGetValue(priority, out IHandlerActionCache erased)
+                || erased is not HandlerActionCache<FastHandler<T>> cache
+            )
             {
-                this.typedHandler = typedHandler;
+                return writeIndex;
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal void Invoke(
-                MessageHandler messageHandler,
-                ref T message,
-                int priority,
-                long emissionId
-            )
+            List<FastHandler<T>> ordered = cache.insertionOrder;
+            int orderedCount = ordered.Count;
+            for (int i = 0; i < orderedCount; ++i)
             {
-                if (!messageHandler.active)
+                if (
+                    cache.entries.TryGetValue(
+                        ordered[i],
+                        out HandlerActionCache<FastHandler<T>>.Entry entry
+                    )
+                )
                 {
-                    return;
+                    target[writeIndex++] = new FlatDispatchEntry<T>(this, entry.handler);
                 }
-
-                typedHandler.HandleUntargeted(ref message, priority, emissionId);
             }
+
+            return writeIndex;
         }
 
-        internal sealed class UntargetedPostDispatchLink<TMessage>
-            where TMessage : IMessage
+        private int FillDefaultFlatEntries<T>(
+            Dictionary<int, IHandlerActionCache> byPriority,
+            int priority,
+            FlatDispatchEntry<T>[] target,
+            int writeIndex
+        )
+            where T : IMessage
         {
-            private readonly TypedHandler<TMessage> typedHandler;
-
-            internal UntargetedPostDispatchLink(TypedHandler<TMessage> typedHandler)
+            if (
+                byPriority == null
+                || !byPriority.TryGetValue(priority, out IHandlerActionCache erased)
+                || erased is not HandlerActionCache<Action<T>> cache
+            )
             {
-                this.typedHandler = typedHandler;
+                return writeIndex;
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal void Invoke(
-                MessageHandler messageHandler,
-                ref TMessage message,
-                int priority,
-                long emissionId
-            )
+            List<Action<T>> ordered = cache.insertionOrder;
+            int orderedCount = ordered.Count;
+            for (int i = 0; i < orderedCount; ++i)
             {
-                if (!messageHandler.active)
+                if (
+                    !cache.entries.TryGetValue(
+                        ordered[i],
+                        out HandlerActionCache<Action<T>>.Entry entry
+                    )
+                )
                 {
-                    return;
+                    continue;
                 }
 
-                typedHandler.HandleUntargetedPostProcessing(ref message, priority, emissionId);
+                // 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.
+                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;
         }
 
-        internal sealed class TargetedDispatchLink<TMessage>
-            where TMessage : IMessage
+        private int FillFastWithContextFlatEntries<T>(
+            Dictionary<int, IHandlerActionCache> byPriority,
+            int priority,
+            ContextFlatDispatchEntry<T>[] target,
+            int writeIndex
+        )
+            where T : IMessage
         {
-            private readonly TypedHandler<TMessage> typedHandler;
-
-            internal TargetedDispatchLink(TypedHandler<TMessage> typedHandler)
+            if (
+                byPriority == null
+                || !byPriority.TryGetValue(priority, out IHandlerActionCache erased)
+                || erased is not HandlerActionCache<FastHandlerWithContext<T>> cache
+            )
             {
-                this.typedHandler = typedHandler;
+                return writeIndex;
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal void Invoke(
-                MessageHandler messageHandler,
-                ref InstanceId target,
-                ref TMessage message,
-                int priority,
-                long emissionId
-            )
+            List<FastHandlerWithContext<T>> ordered = cache.insertionOrder;
+            int orderedCount = ordered.Count;
+            for (int i = 0; i < orderedCount; ++i)
             {
-                typedHandler.HandleTargeted(ref target, ref message, priority, emissionId);
+                if (
+                    cache.entries.TryGetValue(
+                        ordered[i],
+                        out HandlerActionCache<FastHandlerWithContext<T>>.Entry entry
+                    )
+                )
+                {
+                    target[writeIndex++] = new ContextFlatDispatchEntry<T>(this, entry.handler);
+                }
             }
+
+            return writeIndex;
         }
 
-        internal sealed class TargetedPostDispatchLink<TMessage>
-            where TMessage : IMessage
+        private int FillDefaultWithContextFlatEntries<T>(
+            Dictionary<int, IHandlerActionCache> byPriority,
+            int priority,
+            ContextFlatDispatchEntry<T>[] target,
+            int writeIndex
+        )
+            where T : IMessage
         {
-            private readonly TypedHandler<TMessage> typedHandler;
-
-            internal TargetedPostDispatchLink(TypedHandler<TMessage> typedHandler)
+            if (
+                byPriority == null
+                || !byPriority.TryGetValue(priority, out IHandlerActionCache erased)
+                || erased is not HandlerActionCache<Action<InstanceId, T>> cache
+            )
             {
-                this.typedHandler = typedHandler;
+                return writeIndex;
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal void Invoke(
-                MessageHandler messageHandler,
-                ref InstanceId target,
-                ref TMessage message,
-                int priority,
-                long emissionId
-            )
+            List<Action<InstanceId, T>> ordered = cache.insertionOrder;
+            int orderedCount = ordered.Count;
+            for (int i = 0; i < orderedCount; ++i)
             {
-                typedHandler.HandleTargetedPostProcessing(
-                    ref target,
-                    ref message,
-                    priority,
-                    emissionId
-                );
+                if (
+                    !cache.entries.TryGetValue(
+                        ordered[i],
+                        out HandlerActionCache<Action<InstanceId, T>>.Entry entry
+                    )
+                )
+                {
+                    continue;
+                }
+
+                // 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 TargetedWithoutTargetingDispatchLink<TMessage>
-            where TMessage : IMessage
+        internal sealed class HandlerActionCache<T> : DxMessaging.Core.Internal.IHandlerActionCache
         {
-            private readonly TypedHandler<TMessage> typedHandler;
-
-            internal TargetedWithoutTargetingDispatchLink(TypedHandler<TMessage> typedHandler)
+            // 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
             {
-                this.typedHandler = typedHandler;
-            }
+                /// <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) { }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal void Invoke(
-                MessageHandler messageHandler,
-                ref InstanceId target,
-                ref TMessage message,
-                int priority,
-                long emissionId
-            )
-            {
-                typedHandler.HandleTargetedWithoutTargeting(
-                    ref target,
-                    ref message,
-                    priority,
-                    emissionId
-                );
+                /// <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;
+                }
+
+                public readonly T handler;
+                public readonly int count;
+
+                // Pre-resolved invoker consumed by the bus-side flat dispatch
+                // snapshot (MessageBus.BuildMessageFlatDispatch). For
+                // default Action<TMessage> registrations this holds a
+                // FastHandler<TMessage> adapter wrapping the AUGMENTED
+                // handler, created exactly ONCE at registration time so
+                // snapshot rebuilds never allocate closures. For delegate
+                // shapes the flat path does not consume (fast handlers, which
+                // already ARE the invoker, and every targeted/broadcast
+                // shape) this stays null. Refcount increments and decrements
+                // preserve the first registration's invoker, mirroring the
+                // first-augmented-handler-wins semantics of `handler`.
+                public readonly object flatInvoker;
             }
-        }
 
-        internal sealed class TargetedWithoutTargetingPostDispatchLink<TMessage>
-            where TMessage : IMessage
-        {
-            private readonly TypedHandler<TMessage> typedHandler;
+            public readonly Dictionary<T, Entry> entries = new();
 
-            internal TargetedWithoutTargetingPostDispatchLink(TypedHandler<TMessage> typedHandler)
+            // Original-handler keys in first-registration order. Dictionary
+            // enumeration order is NOT stable across Remove/Add churn (.NET
+            // reuses freed slots LIFO), so dispatch snapshots are rebuilt from
+            // this list instead of from <see cref="entries"/> to honor the
+            // documented "same priority uses registration order" contract.
+            // Invariants: contains exactly the keys of <see cref="entries"/>;
+            // a key is appended on its FIRST registration only (refcount
+            // increments do not move it) and removed when its refcount drops
+            // to zero. Maintained exclusively by the AddHandler* family and
+            // <see cref="DxMessaging.Core.Internal.IHandlerActionCache.Reset"/>.
+            public readonly List<T> insertionOrder = new();
+            public readonly List<T> cache = new();
+            public long version;
+            public long lastSeenVersion = -1;
+            public long lastSeenEmissionId = -1;
+
+            /// <summary>Monotonic version field, read-only on the interface surface.</summary>
+            long DxMessaging.Core.Internal.IHandlerActionCache.Version
             {
-                this.typedHandler = typedHandler;
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => version;
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal void Invoke(
-                MessageHandler messageHandler,
-                ref InstanceId target,
-                ref TMessage message,
-                int priority,
-                long emissionId
-            )
+            /// <summary>Most recent dispatcher-observed version; mutable through the staged dispatch path.</summary>
+            long DxMessaging.Core.Internal.IHandlerActionCache.LastSeenVersion
             {
-                typedHandler.HandleTargetedWithoutTargetingPostProcessing(
-                    ref target,
-                    ref message,
-                    priority,
-                    emissionId
-                );
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => lastSeenVersion;
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                set => lastSeenVersion = value;
             }
-        }
-
-        internal sealed class BroadcastDispatchLink<TMessage>
-            where TMessage : IMessage
-        {
-            private readonly TypedHandler<TMessage> typedHandler;
 
-            internal BroadcastDispatchLink(TypedHandler<TMessage> typedHandler)
+            /// <summary>Most recent dispatcher-observed bus emission id.</summary>
+            long DxMessaging.Core.Internal.IHandlerActionCache.LastSeenEmissionId
             {
-                this.typedHandler = typedHandler;
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => lastSeenEmissionId;
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                set => lastSeenEmissionId = value;
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal void Invoke(
-                MessageHandler messageHandler,
-                ref InstanceId source,
-                ref TMessage message,
-                int priority,
-                long emissionId
-            )
+            /// <summary>True iff the entries dictionary holds zero handlers.</summary>
+            bool DxMessaging.Core.Internal.IHandlerActionCache.IsEmpty
             {
-                typedHandler.HandleSourcedBroadcast(ref source, ref message, priority, emissionId);
+                [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();
+                insertionOrder.Clear();
+                cache.Clear();
+                lastSeenVersion = -1;
+                lastSeenEmissionId = -1;
+                unchecked
+                {
+                    ++version;
+                }
             }
         }
 
-        internal sealed class BroadcastPostDispatchLink<TMessage>
-            where TMessage : IMessage
+        /// <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
         {
-            private readonly TypedHandler<TMessage> typedHandler;
+            // 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
+            ];
 
-            internal BroadcastPostDispatchLink(TypedHandler<TMessage> typedHandler)
+            // 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()
             {
-                this.typedHandler = typedHandler;
+                ValidateSlotArrays();
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal void Invoke(
-                MessageHandler messageHandler,
-                ref InstanceId source,
-                ref TMessage message,
-                int priority,
-                long emissionId
-            )
+            internal bool _markedForOuterRemoval;
+
+            int ITypedHandlerSlotSweeper.MessageTypeIndex
             {
-                typedHandler.HandleSourcedBroadcastPostProcessing(
-                    ref source,
-                    ref message,
-                    priority,
-                    emissionId
-                );
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => MessageHelperIndexer<T>.SequentialId;
             }
-        }
 
-        internal sealed class BroadcastWithoutSourceDispatchLink<TMessage>
-            where TMessage : IMessage
-        {
-            private readonly TypedHandler<TMessage> typedHandler;
+            bool ITypedHandlerSlotSweeper.MarkedForOuterRemoval
+            {
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => _markedForOuterRemoval;
+            }
 
-            internal BroadcastWithoutSourceDispatchLink(TypedHandler<TMessage> typedHandler)
+            [Conditional("DEBUG")]
+            private void ValidateSlotArrays()
             {
-                this.typedHandler = typedHandler;
+                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)]
-            internal void Invoke(
-                MessageHandler messageHandler,
-                ref InstanceId source,
-                ref TMessage message,
-                int priority,
-                long emissionId
-            )
+            private TypedSlot<T> GetOrCreateSlot(int index, bool requiresContext)
             {
-                typedHandler.HandleSourcedBroadcastWithoutSource(
-                    ref source,
-                    ref message,
-                    priority,
-                    emissionId
-                );
-            }
-        }
+                TypedSlot<T> slot = _slots[index];
+                if (slot == null)
+                {
+                    slot = new TypedSlot<T>(requiresContext);
+                    _slots[index] = slot;
+                }
 
-        internal sealed class BroadcastWithoutSourcePostDispatchLink<TMessage>
-            where TMessage : IMessage
-        {
-            private readonly TypedHandler<TMessage> typedHandler;
+                return slot;
+            }
 
-            internal BroadcastWithoutSourcePostDispatchLink(TypedHandler<TMessage> typedHandler)
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal Dictionary<int, IHandlerActionCache> GetOrCreatePriorityHandlers(
+                int index,
+                bool requiresContext
+            )
             {
-                this.typedHandler = typedHandler;
+                return GetOrCreateSlot(index, requiresContext).byPriority;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal void Invoke(
-                MessageHandler messageHandler,
-                ref InstanceId source,
-                ref TMessage message,
-                int priority,
-                long emissionId
-            )
+            internal Dictionary<int, IHandlerActionCache> GetPriorityHandlers(int index)
             {
-                typedHandler.HandleBroadcastWithoutSourcePostProcessing(
-                    ref source,
-                    ref message,
-                    priority,
-                    emissionId
-                );
+                return _slots[index]?.byPriority;
             }
-        }
 
-        /// <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>
-            where T : IMessage
-        {
-            internal Dictionary<
-                InstanceId,
-                Dictionary<int, HandlerActionCache<Action<T>>>
-            > _targetedHandlers;
-            internal Dictionary<int, HandlerActionCache<Action<T>>> _untargetedHandlers;
-            internal Dictionary<
-                InstanceId,
-                Dictionary<int, HandlerActionCache<Action<T>>>
-            > _broadcastHandlers;
-            internal Dictionary<
-                InstanceId,
-                Dictionary<int, HandlerActionCache<Action<T>>>
-            > _targetedPostProcessingHandlers;
-            internal Dictionary<
-                int,
-                HandlerActionCache<Action<T>>
-            > _untargetedPostProcessingHandlers;
-            internal Dictionary<
-                InstanceId,
-                Dictionary<int, HandlerActionCache<Action<T>>>
-            > _broadcastPostProcessingHandlers;
-            internal Dictionary<
-                InstanceId,
-                Dictionary<int, HandlerActionCache<FastHandler<T>>>
-            > _targetedFastHandlers;
-            internal Dictionary<int, HandlerActionCache<FastHandler<T>>> _untargetedFastHandlers;
-            internal Dictionary<
-                InstanceId,
-                Dictionary<int, HandlerActionCache<FastHandler<T>>>
-            > _broadcastFastHandlers;
-            internal Dictionary<
-                InstanceId,
-                Dictionary<int, HandlerActionCache<FastHandler<T>>>
-            > _targetedPostProcessingFastHandlers;
-            internal Dictionary<
-                int,
-                HandlerActionCache<FastHandler<T>>
-            > _untargetedPostProcessingFastHandlers;
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             internal Dictionary<
                 InstanceId,
-                Dictionary<int, HandlerActionCache<FastHandler<T>>>
-            > _broadcastPostProcessingFastHandlers;
-
-            internal HandlerActionCache<Action<IUntargetedMessage>> _globalUntargetedHandlers;
-
-            internal HandlerActionCache<
-                Action<InstanceId, ITargetedMessage>
-            > _globalTargetedHandlers;
-
-            internal HandlerActionCache<
-                Action<InstanceId, IBroadcastMessage>
-            > _globalBroadcastHandlers;
-
-            internal HandlerActionCache<
-                FastHandler<IUntargetedMessage>
-            > _globalUntargetedFastHandlers;
-
-            internal HandlerActionCache<
-                FastHandlerWithContext<ITargetedMessage>
-            > _globalTargetedFastHandlers;
+                Dictionary<int, IHandlerActionCache>
+            > GetOrCreateContextHandlers(int index)
+            {
+                TypedSlot<T> slot = GetOrCreateSlot(index, requiresContext: true);
+                slot.byContext ??= DxPools.TypedHandlerContextDicts.Rent();
+                return slot.byContext;
+            }
 
-            internal HandlerActionCache<
-                FastHandlerWithContext<IBroadcastMessage>
-            > _globalBroadcastFastHandlers;
-            internal Dictionary<
-                int,
-                HandlerActionCache<Action<InstanceId, T>>
-            > _targetedWithoutTargetingHandlers;
-            internal Dictionary<
-                int,
-                HandlerActionCache<FastHandlerWithContext<T>>
-            > _fastTargetedWithoutTargetingHandlers;
-            internal Dictionary<
-                int,
-                HandlerActionCache<Action<InstanceId, T>>
-            > _broadcastWithoutSourceHandlers;
-            internal Dictionary<
-                int,
-                HandlerActionCache<FastHandlerWithContext<T>>
-            > _fastBroadcastWithoutSourceHandlers;
-            internal Dictionary<
-                int,
-                HandlerActionCache<Action<InstanceId, T>>
-            > _targetedWithoutTargetingPostProcessingHandlers;
-            internal Dictionary<
-                int,
-                HandlerActionCache<FastHandlerWithContext<T>>
-            > _fastTargetedWithoutTargetingPostProcessingHandlers;
-            internal Dictionary<
-                int,
-                HandlerActionCache<Action<InstanceId, T>>
-            > _broadcastWithoutSourcePostProcessingHandlers;
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             internal Dictionary<
-                int,
-                HandlerActionCache<FastHandlerWithContext<T>>
-            > _fastBroadcastWithoutSourcePostProcessingHandlers;
-            private UntargetedDispatchLink<T> _untargetedLink;
-            private object _untargetedPostLink;
-            private object _targetedLink;
-            private object _targetedPostLink;
-            private object _targetedWithoutTargetingLink;
-            private object _targetedWithoutTargetingPostLink;
-            private object _broadcastLink;
-            private object _broadcastPostLink;
-            private object _broadcastWithoutSourceLink;
-            private object _broadcastWithoutSourcePostLink;
+                InstanceId,
+                Dictionary<int, IHandlerActionCache>
+            > GetContextHandlers(int index)
+            {
+                return _slots[index]?.byContext;
+            }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal UntargetedDispatchLink<T> GetOrCreateUntargetedLink()
+            internal TypedGlobalSlot GetOrCreateGlobalSlot(int index)
             {
-                UntargetedDispatchLink<T> link = _untargetedLink;
-                if (link == null)
+                TypedGlobalSlot slot = _globalSlots[index];
+                if (slot == null)
                 {
-                    link = new UntargetedDispatchLink<T>(this);
-                    _untargetedLink = link;
+                    slot = new TypedGlobalSlot();
+                    _globalSlots[index] = slot;
                 }
 
-                return link;
+                return slot;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal UntargetedPostDispatchLink<T> GetOrCreateUntargetedPostLink()
+            internal HandlerActionCache<TU> GetGlobalCache<TU>(int index)
             {
-                UntargetedPostDispatchLink<T> link =
-                    _untargetedPostLink as UntargetedPostDispatchLink<T>;
-                if (link == null)
-                {
-                    link = new UntargetedPostDispatchLink<T>(this);
-                    _untargetedPostLink = link;
-                }
-
-                return link;
+                return _globalSlots[index]?.cache as HandlerActionCache<TU>;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal TargetedDispatchLink<T> GetOrCreateTargetedLink()
+            private TypedSlot<T> FindPrioritySlot(Dictionary<int, IHandlerActionCache> handlers)
             {
-                TargetedDispatchLink<T> link = _targetedLink as TargetedDispatchLink<T>;
-                if (link == null)
+                for (int i = 0; i < _slots.Length; ++i)
                 {
-                    link = new TargetedDispatchLink<T>(this);
-                    _targetedLink = link;
+                    TypedSlot<T> slot = _slots[i];
+                    if (slot != null && ReferenceEquals(slot.byPriority, handlers))
+                    {
+                        return slot;
+                    }
                 }
 
-                return link;
+                return null;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal TargetedPostDispatchLink<T> GetOrCreateTargetedPostLink()
+            private TypedSlot<T> FindContextSlot(
+                Dictionary<InstanceId, Dictionary<int, IHandlerActionCache>> handlersByContext
+            )
             {
-                TargetedPostDispatchLink<T> link = _targetedPostLink as TargetedPostDispatchLink<T>;
-                if (link == null)
+                for (int i = 0; i < _slots.Length; ++i)
                 {
-                    link = new TargetedPostDispatchLink<T>(this);
-                    _targetedPostLink = link;
+                    TypedSlot<T> slot = _slots[i];
+                    if (slot != null && ReferenceEquals(slot.byContext, handlersByContext))
+                    {
+                        return slot;
+                    }
                 }
 
-                return link;
+                return null;
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal TargetedWithoutTargetingDispatchLink<T> GetOrCreateTargetedWithoutTargetingLink()
+            int ITypedHandlerSlotSweeper.ResetEmptySlotsForSweep()
             {
-                TargetedWithoutTargetingDispatchLink<T> link =
-                    _targetedWithoutTargetingLink as TargetedWithoutTargetingDispatchLink<T>;
-                if (link == null)
+                _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)
                 {
-                    link = new TargetedWithoutTargetingDispatchLink<T>(this);
-                    _targetedWithoutTargetingLink = link;
+                    TypedGlobalSlot slot = _globalSlots[i];
+                    if (slot != null && slot.IsEmpty)
+                    {
+                        slot.Reset();
+                        _globalSlots[i] = null;
+                        resetCount++;
+                    }
                 }
 
-                return link;
+                MarkForOuterRemovalIfEmpty();
+                return resetCount;
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal TargetedWithoutTargetingPostDispatchLink<T> GetOrCreateTargetedWithoutTargetingPostLink()
+            int ITypedHandlerSlotSweeper.ResetAllSlotsForBusReset()
             {
-                TargetedWithoutTargetingPostDispatchLink<T> link =
-                    _targetedWithoutTargetingPostLink
-                    as TargetedWithoutTargetingPostDispatchLink<T>;
-                if (link == null)
+                _markedForOuterRemoval = false;
+                int resetCount = 0;
+                for (int i = 0; i < _slots.Length; ++i)
                 {
-                    link = new TargetedWithoutTargetingPostDispatchLink<T>(this);
-                    _targetedWithoutTargetingPostLink = link;
+                    TypedSlot<T> slot = _slots[i];
+                    if (slot != null)
+                    {
+                        slot.Reset();
+                        _slots[i] = null;
+                        resetCount++;
+                    }
                 }
 
-                return link;
+                for (int i = 0; i < _globalSlots.Length; ++i)
+                {
+                    TypedGlobalSlot slot = _globalSlots[i];
+                    if (slot != null)
+                    {
+                        slot.Reset();
+                        _globalSlots[i] = null;
+                        resetCount++;
+                    }
+                }
+
+                return resetCount;
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal BroadcastDispatchLink<T> GetOrCreateBroadcastLink()
+            int ITypedHandlerSlotSweeper.CountEmptySlotsForSweep()
             {
-                BroadcastDispatchLink<T> link = _broadcastLink as BroadcastDispatchLink<T>;
-                if (link == null)
+                int count = 0;
+                for (int i = 0; i < _slots.Length; ++i)
                 {
-                    link = new BroadcastDispatchLink<T>(this);
-                    _broadcastLink = link;
+                    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 link;
+                return count;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal BroadcastPostDispatchLink<T> GetOrCreateBroadcastPostLink()
+            private void MarkForOuterRemovalIfEmpty()
             {
-                BroadcastPostDispatchLink<T> link =
-                    _broadcastPostLink as BroadcastPostDispatchLink<T>;
-                if (link == null)
+                if (HasLiveSlots())
                 {
-                    link = new BroadcastPostDispatchLink<T>(this);
-                    _broadcastPostLink = link;
+                    return;
                 }
 
-                return link;
+                _markedForOuterRemoval = true;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal BroadcastWithoutSourceDispatchLink<T> GetOrCreateBroadcastWithoutSourceLink()
+            private bool HasLiveSlots()
             {
-                BroadcastWithoutSourceDispatchLink<T> link =
-                    _broadcastWithoutSourceLink as BroadcastWithoutSourceDispatchLink<T>;
-                if (link == null)
+                for (int i = 0; i < _slots.Length; ++i)
                 {
-                    link = new BroadcastWithoutSourceDispatchLink<T>(this);
-                    _broadcastWithoutSourceLink = link;
+                    if (_slots[i] != null)
+                    {
+                        return true;
+                    }
                 }
 
-                return link;
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal BroadcastWithoutSourcePostDispatchLink<T> GetOrCreateBroadcastWithoutSourcePostLink()
-            {
-                BroadcastWithoutSourcePostDispatchLink<T> link =
-                    _broadcastWithoutSourcePostLink as BroadcastWithoutSourcePostDispatchLink<T>;
-                if (link == null)
+                for (int i = 0; i < _globalSlots.Length; ++i)
                 {
-                    link = new BroadcastWithoutSourcePostDispatchLink<T>(this);
-                    _broadcastWithoutSourcePostLink = link;
+                    if (_globalSlots[i] != null)
+                    {
+                        return true;
+                    }
                 }
 
-                return link;
+                return false;
             }
 
             /// <summary>
@@ -2674,19 +2659,18 @@ namespace DxMessaging.Core
             /// <param name="priority">Priority at which to run the handlers.</param>
             public void HandleUntargeted(ref T message, int priority, long emissionId)
             {
-                PrefreezeHandlersForEmission(
-                    _untargetedPostProcessingFastHandlers,
+                RunFastHandlers(
+                    GetPriorityHandlers(TypedSlotIndex.UntargetedHandleFast),
+                    ref message,
                     priority,
                     emissionId
                 );
-                PrefreezeHandlersForEmission(
-                    _untargetedPostProcessingHandlers,
+                RunHandlers(
+                    GetPriorityHandlers(TypedSlotIndex.UntargetedHandleDefault),
+                    ref message,
                     priority,
                     emissionId
                 );
-
-                RunFastHandlers(_untargetedFastHandlers, ref message, priority, emissionId);
-                RunHandlers(_untargetedHandlers, ref message, priority, emissionId);
             }
 
             /// <summary>
@@ -2704,14 +2688,14 @@ namespace DxMessaging.Core
             {
                 RunFastHandlersWithContext(
                     ref target,
-                    _targetedFastHandlers,
+                    GetContextHandlers(TypedSlotIndex.TargetedHandleFast),
                     ref message,
                     priority,
                     emissionId
                 );
                 RunHandlersWithContext(
                     ref target,
-                    _targetedHandlers,
+                    GetContextHandlers(TypedSlotIndex.TargetedHandleDefault),
                     ref message,
                     priority,
                     emissionId
@@ -2733,14 +2717,14 @@ namespace DxMessaging.Core
             {
                 RunFastHandlers(
                     ref target,
-                    _fastTargetedWithoutTargetingHandlers,
+                    GetPriorityHandlers(TypedSlotIndex.TargetedHandleWithoutContextFast),
                     ref message,
                     priority,
                     emissionId
                 );
                 RunHandlers(
                     ref target,
-                    _targetedWithoutTargetingHandlers,
+                    GetPriorityHandlers(TypedSlotIndex.TargetedHandleWithoutContext),
                     ref message,
                     priority,
                     emissionId
@@ -2762,14 +2746,14 @@ namespace DxMessaging.Core
             {
                 RunFastHandlersWithContext(
                     ref source,
-                    _broadcastFastHandlers,
+                    GetContextHandlers(TypedSlotIndex.BroadcastHandleFast),
                     ref message,
                     priority,
                     emissionId
                 );
                 RunHandlersWithContext(
                     ref source,
-                    _broadcastHandlers,
+                    GetContextHandlers(TypedSlotIndex.BroadcastHandleDefault),
                     ref message,
                     priority,
                     emissionId
@@ -2791,14 +2775,14 @@ namespace DxMessaging.Core
             {
                 RunFastHandlers(
                     ref source,
-                    _fastBroadcastWithoutSourceHandlers,
+                    GetPriorityHandlers(TypedSlotIndex.BroadcastHandleWithoutContextFast),
                     ref message,
                     priority,
                     emissionId
                 );
                 RunHandlers(
                     ref source,
-                    _broadcastWithoutSourceHandlers,
+                    GetPriorityHandlers(TypedSlotIndex.BroadcastHandleWithoutContext),
                     ref message,
                     priority,
                     emissionId
@@ -2811,18 +2795,36 @@ namespace DxMessaging.Core
             /// <param name="message">Message to emit.</param>
             public void HandleGlobalUntargeted(ref IUntargetedMessage message, long emissionId)
             {
-                RunFastHandlers(_globalUntargetedFastHandlers, ref message, emissionId);
-                if (_globalUntargetedHandlers?.entries is not { Count: > 0 })
+                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(
-                    _globalUntargetedHandlers,
+                    cache,
                     emissionId
                 );
                 int handlersCount = handlers.Count;
-                for (int i = 0; i < handlersCount; ++i)
+                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                 {
                     handlers[i](message);
                 }
@@ -2839,19 +2841,29 @@ namespace DxMessaging.Core
                 long emissionId
             )
             {
-                RunFastHandlers(ref target, _globalTargetedFastHandlers, ref message, emissionId);
-
-                if (_globalTargetedHandlers?.entries is not { Count: > 0 })
+                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(
-                    _globalTargetedHandlers,
+                    cache,
                     emissionId
                 );
                 int handlersCount = handlers.Count;
-                for (int i = 0; i < handlersCount; ++i)
+                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                 {
                     handlers[i](target, message);
                 }
@@ -2868,15 +2880,25 @@ namespace DxMessaging.Core
                 long emissionId
             )
             {
-                RunFastHandlers(ref source, _globalBroadcastFastHandlers, ref message, emissionId);
-
-                if (_globalBroadcastHandlers?.entries is not { Count: > 0 })
+                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(
-                    _globalBroadcastHandlers,
+                    cache,
                     emissionId
                 );
                 int handlersCount = handlers.Count;
@@ -2890,36 +2912,76 @@ namespace DxMessaging.Core
                     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)
+                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                 {
                     handlers[i](source, message);
                 }
@@ -2934,12 +2996,17 @@ namespace DxMessaging.Core
             public void HandleUntargetedPostProcessing(ref T message, int priority, long emissionId)
             {
                 RunFastHandlers(
-                    _untargetedPostProcessingFastHandlers,
+                    GetPriorityHandlers(TypedSlotIndex.UntargetedPostProcessFast),
+                    ref message,
+                    priority,
+                    emissionId
+                );
+                RunHandlers(
+                    GetPriorityHandlers(TypedSlotIndex.UntargetedPostProcessDefault),
                     ref message,
                     priority,
                     emissionId
                 );
-                RunHandlers(_untargetedPostProcessingHandlers, ref message, priority, emissionId);
             }
 
             /// <summary>
@@ -2958,14 +3025,14 @@ namespace DxMessaging.Core
             {
                 RunFastHandlersWithContext(
                     ref target,
-                    _targetedPostProcessingFastHandlers,
+                    GetContextHandlers(TypedSlotIndex.TargetedPostProcessFast),
                     ref message,
                     priority,
                     emissionId
                 );
                 RunHandlersWithContext(
                     ref target,
-                    _targetedPostProcessingHandlers,
+                    GetContextHandlers(TypedSlotIndex.TargetedPostProcessDefault),
                     ref message,
                     priority,
                     emissionId
@@ -2988,14 +3055,14 @@ namespace DxMessaging.Core
             {
                 RunFastHandlersWithContext(
                     ref target,
-                    _fastTargetedWithoutTargetingPostProcessingHandlers,
+                    GetPriorityHandlers(TypedSlotIndex.TargetedPostProcessWithoutContextFast),
                     ref message,
                     priority,
                     emissionId
                 );
                 RunHandlers(
                     ref target,
-                    _targetedWithoutTargetingPostProcessingHandlers,
+                    GetPriorityHandlers(TypedSlotIndex.TargetedPostProcessWithoutContext),
                     ref message,
                     priority,
                     emissionId
@@ -3018,14 +3085,14 @@ namespace DxMessaging.Core
             {
                 RunFastHandlersWithContext(
                     ref source,
-                    _broadcastPostProcessingFastHandlers,
+                    GetContextHandlers(TypedSlotIndex.BroadcastPostProcessFast),
                     ref message,
                     priority,
                     emissionId
                 );
                 RunHandlersWithContext(
                     ref source,
-                    _broadcastPostProcessingHandlers,
+                    GetContextHandlers(TypedSlotIndex.BroadcastPostProcessDefault),
                     ref message,
                     priority,
                     emissionId
@@ -3048,14 +3115,14 @@ namespace DxMessaging.Core
             {
                 RunFastHandlersWithContext(
                     ref source,
-                    _fastBroadcastWithoutSourcePostProcessingHandlers,
+                    GetPriorityHandlers(TypedSlotIndex.BroadcastPostProcessWithoutContextFast),
                     ref message,
                     priority,
                     emissionId
                 );
                 RunHandlers(
                     ref source,
-                    _broadcastWithoutSourcePostProcessingHandlers,
+                    GetPriorityHandlers(TypedSlotIndex.BroadcastPostProcessWithoutContext),
                     ref message,
                     priority,
                     emissionId
@@ -3076,17 +3143,22 @@ namespace DxMessaging.Core
                 Action<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
-                return AddHandler(
+                // 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,
-                    ref _targetedHandlers,
+                    GetOrCreateContextHandlers(TypedSlotIndex.TargetedHandleDefault),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus,
+                    flatInvoker
                 );
             }
 
@@ -3104,17 +3176,17 @@ namespace DxMessaging.Core
                 FastHandler<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
-                return AddHandler(
+                return AddHandlerPreservingPriorityKey(
                     target,
-                    ref _targetedFastHandlers,
+                    GetOrCreateContextHandlers(TypedSlotIndex.TargetedHandleFast),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus
                 );
             }
 
@@ -3130,16 +3202,26 @@ namespace DxMessaging.Core
                 Action<InstanceId, T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                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(
-                    ref _targetedWithoutTargetingHandlers,
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.TargetedHandleWithoutContext,
+                        requiresContext: false
+                    ),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus,
+                    flatInvoker
                 );
             }
 
@@ -3155,16 +3237,19 @@ namespace DxMessaging.Core
                 FastHandlerWithContext<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
                 return AddHandlerPreservingPriorityKey(
-                    ref _fastTargetedWithoutTargetingHandlers,
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.TargetedHandleWithoutContextFast,
+                        requiresContext: false
+                    ),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus
                 );
             }
 
@@ -3180,16 +3265,24 @@ namespace DxMessaging.Core
                 Action<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
-                return AddHandler(
-                    ref _untargetedHandlers,
+                // 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,
-                    emissionId
+                    messageBus,
+                    flatInvoker
                 );
             }
 
@@ -3205,16 +3298,19 @@ namespace DxMessaging.Core
                 FastHandler<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
-                return AddHandler(
-                    ref _untargetedFastHandlers,
+                return AddHandlerPreservingPriorityKey(
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.UntargetedHandleFast,
+                        requiresContext: false
+                    ),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus
                 );
             }
 
@@ -3232,17 +3328,22 @@ namespace DxMessaging.Core
                 Action<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
-                return AddHandler(
+                // 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,
-                    ref _broadcastHandlers,
+                    GetOrCreateContextHandlers(TypedSlotIndex.BroadcastHandleDefault),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus,
+                    flatInvoker
                 );
             }
 
@@ -3260,17 +3361,17 @@ namespace DxMessaging.Core
                 FastHandler<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
-                return AddHandler(
+                return AddHandlerPreservingPriorityKey(
                     source,
-                    ref _broadcastFastHandlers,
+                    GetOrCreateContextHandlers(TypedSlotIndex.BroadcastHandleFast),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus
                 );
             }
 
@@ -3286,17 +3387,27 @@ namespace DxMessaging.Core
                 Action<InstanceId, T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                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(
-                    ref _broadcastWithoutSourceHandlers,
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.BroadcastHandleWithoutContext,
+                        requiresContext: false
+                    ),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus,
+                    flatInvoker
                 );
             }
 
@@ -3312,17 +3423,20 @@ namespace DxMessaging.Core
                 FastHandlerWithContext<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
                 // Preserve the priority bucket during the current emission so frozen snapshots remain valid
                 return AddHandlerPreservingPriorityKey(
-                    ref _fastBroadcastWithoutSourceHandlers,
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.BroadcastHandleWithoutContextFast,
+                        requiresContext: false
+                    ),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus
                 );
             }
 
@@ -3335,14 +3449,16 @@ namespace DxMessaging.Core
             public Action AddGlobalUntargetedHandler(
                 Action<IUntargetedMessage> originalHandler,
                 Action<IUntargetedMessage> handler,
-                Action deregistration
+                Action deregistration,
+                IMessageBus messageBus
             )
             {
                 return AddHandler(
-                    ref _globalUntargetedHandlers,
+                    GetOrCreateGlobalSlot(TypedGlobalSlotIndex.UntargetedDefault),
                     originalHandler,
                     handler,
-                    deregistration
+                    deregistration,
+                    messageBus
                 );
             }
 
@@ -3355,14 +3471,16 @@ namespace DxMessaging.Core
             public Action AddGlobalUntargetedHandler(
                 FastHandler<IUntargetedMessage> originalHandler,
                 FastHandler<IUntargetedMessage> handler,
-                Action deregistration
+                Action deregistration,
+                IMessageBus messageBus
             )
             {
                 return AddHandler(
-                    ref _globalUntargetedFastHandlers,
+                    GetOrCreateGlobalSlot(TypedGlobalSlotIndex.UntargetedFast),
                     originalHandler,
                     handler,
-                    deregistration
+                    deregistration,
+                    messageBus
                 );
             }
 
@@ -3375,14 +3493,16 @@ namespace DxMessaging.Core
             public Action AddGlobalTargetedHandler(
                 Action<InstanceId, ITargetedMessage> originalHandler,
                 Action<InstanceId, ITargetedMessage> handler,
-                Action deregistration
+                Action deregistration,
+                IMessageBus messageBus
             )
             {
                 return AddHandler(
-                    ref _globalTargetedHandlers,
+                    GetOrCreateGlobalSlot(TypedGlobalSlotIndex.TargetedDefault),
                     originalHandler,
                     handler,
-                    deregistration
+                    deregistration,
+                    messageBus
                 );
             }
 
@@ -3395,14 +3515,16 @@ namespace DxMessaging.Core
             public Action AddGlobalTargetedHandler(
                 FastHandlerWithContext<ITargetedMessage> originalHandler,
                 FastHandlerWithContext<ITargetedMessage> handler,
-                Action deregistration
+                Action deregistration,
+                IMessageBus messageBus
             )
             {
                 return AddHandler(
-                    ref _globalTargetedFastHandlers,
+                    GetOrCreateGlobalSlot(TypedGlobalSlotIndex.TargetedFast),
                     originalHandler,
                     handler,
-                    deregistration
+                    deregistration,
+                    messageBus
                 );
             }
 
@@ -3415,14 +3537,16 @@ namespace DxMessaging.Core
             public Action AddGlobalBroadcastHandler(
                 Action<InstanceId, IBroadcastMessage> originalHandler,
                 Action<InstanceId, IBroadcastMessage> handler,
-                Action deregistration
+                Action deregistration,
+                IMessageBus messageBus
             )
             {
                 return AddHandler(
-                    ref _globalBroadcastHandlers,
+                    GetOrCreateGlobalSlot(TypedGlobalSlotIndex.BroadcastDefault),
                     originalHandler,
                     handler,
-                    deregistration
+                    deregistration,
+                    messageBus
                 );
             }
 
@@ -3435,14 +3559,16 @@ namespace DxMessaging.Core
             public Action AddGlobalBroadcastHandler(
                 FastHandlerWithContext<IBroadcastMessage> originalHandler,
                 FastHandlerWithContext<IBroadcastMessage> handler,
-                Action deregistration
+                Action deregistration,
+                IMessageBus messageBus
             )
             {
                 return AddHandler(
-                    ref _globalBroadcastFastHandlers,
+                    GetOrCreateGlobalSlot(TypedGlobalSlotIndex.BroadcastFast),
                     originalHandler,
                     handler,
-                    deregistration
+                    deregistration,
+                    messageBus
                 );
             }
 
@@ -3458,16 +3584,24 @@ namespace DxMessaging.Core
                 Action<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                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(
-                    ref _untargetedPostProcessingHandlers,
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.UntargetedPostProcessDefault,
+                        requiresContext: false
+                    ),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus,
+                    flatInvoker
                 );
             }
 
@@ -3483,16 +3617,19 @@ namespace DxMessaging.Core
                 FastHandler<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
                 return AddHandlerPreservingPriorityKey(
-                    ref _untargetedPostProcessingFastHandlers,
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.UntargetedPostProcessFast,
+                        requiresContext: false
+                    ),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus
                 );
             }
 
@@ -3510,17 +3647,22 @@ namespace DxMessaging.Core
                 Action<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                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,
-                    ref _targetedPostProcessingHandlers,
+                    GetOrCreateContextHandlers(TypedSlotIndex.TargetedPostProcessDefault),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus,
+                    flatInvoker
                 );
             }
 
@@ -3538,17 +3680,17 @@ namespace DxMessaging.Core
                 FastHandler<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
                 return AddHandlerPreservingPriorityKey(
                     target,
-                    ref _targetedPostProcessingFastHandlers,
+                    GetOrCreateContextHandlers(TypedSlotIndex.TargetedPostProcessFast),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus
                 );
             }
 
@@ -3564,16 +3706,26 @@ namespace DxMessaging.Core
                 Action<InstanceId, T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                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(
-                    ref _targetedWithoutTargetingPostProcessingHandlers,
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.TargetedPostProcessWithoutContext,
+                        requiresContext: false
+                    ),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus,
+                    flatInvoker
                 );
             }
 
@@ -3589,16 +3741,19 @@ namespace DxMessaging.Core
                 FastHandlerWithContext<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
                 return AddHandlerPreservingPriorityKey(
-                    ref _fastTargetedWithoutTargetingPostProcessingHandlers,
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.TargetedPostProcessWithoutContextFast,
+                        requiresContext: false
+                    ),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus
                 );
             }
 
@@ -3616,17 +3771,22 @@ namespace DxMessaging.Core
                 Action<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                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,
-                    ref _broadcastPostProcessingHandlers,
+                    GetOrCreateContextHandlers(TypedSlotIndex.BroadcastPostProcessDefault),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus,
+                    flatInvoker
                 );
             }
 
@@ -3644,17 +3804,17 @@ namespace DxMessaging.Core
                 FastHandler<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
                 return AddHandlerPreservingPriorityKey(
                     source,
-                    ref _broadcastPostProcessingFastHandlers,
+                    GetOrCreateContextHandlers(TypedSlotIndex.BroadcastPostProcessFast),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus
                 );
             }
 
@@ -3670,16 +3830,26 @@ namespace DxMessaging.Core
                 Action<InstanceId, T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                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(
-                    ref _broadcastWithoutSourcePostProcessingHandlers,
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.BroadcastPostProcessWithoutContext,
+                        requiresContext: false
+                    ),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus,
+                    flatInvoker
                 );
             }
 
@@ -3695,20 +3865,204 @@ namespace DxMessaging.Core
                 FastHandlerWithContext<T> handler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
                 return AddHandlerPreservingPriorityKey(
-                    ref _fastBroadcastWithoutSourcePostProcessingHandlers,
+                    GetOrCreatePriorityHandlers(
+                        TypedSlotIndex.BroadcastPostProcessWithoutContextFast,
+                        requiresContext: false
+                    ),
                     originalHandler,
                     handler,
                     deregistration,
                     priority,
-                    emissionId
+                    messageBus
                 );
             }
 
-            // Context-aware variant that preserves the priority key mapping on deregistration for the current emission.
+            // 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 Action AddHandlerPreservingPriorityKey<TU>(
+                InstanceId context,
+                Dictionary<InstanceId, Dictionary<int, IHandlerActionCache>> handlersByContext,
+                TU originalHandler,
+                TU augmentedHandler,
+                Action deregistration,
+                int priority,
+                IMessageBus messageBus,
+                object flatInvoker = null
+            )
+            {
+                if (
+                    !handlersByContext.TryGetValue(
+                        context,
+                        out Dictionary<int, IHandlerActionCache> sortedHandlers
+                    )
+                )
+                {
+                    sortedHandlers = DxPools.TypedHandlerPriorityDicts.Rent();
+                    handlersByContext[context] = sortedHandlers;
+                }
+
+                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;
+                if (firstRegistration)
+                {
+                    cache.insertionOrder.Add(originalHandler);
+                }
+                cache.version++;
+                TypedSlot<T> slot = FindContextSlot(handlersByContext);
+                if (slot != null)
+                {
+                    slot.lastTouchTicks =
+                        global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(
+                            messageBus
+                        );
+                }
+                if (firstRegistration && slot != null)
+                {
+                    slot.liveCount++;
+                }
+
+                Dictionary<
+                    InstanceId,
+                    Dictionary<int, IHandlerActionCache>
+                > localHandlersByContext = handlersByContext;
+                TypedSlot<T> localSlot = slot;
+                long localSlotVersion = slot?.version ?? 0;
+                long localResetGeneration =
+                    global::DxMessaging.Core.MessageBus.MessageBus.GetResetGeneration(messageBus);
+
+                return () =>
+                {
+                    if (
+                        !global::DxMessaging.Core.MessageBus.MessageBus.IsResetGenerationCurrent(
+                            messageBus,
+                            localResetGeneration
+                        )
+                    )
+                    {
+                        return;
+                    }
+
+                    if (localSlot != null && localSlot.version != localSlotVersion)
+                    {
+                        return;
+                    }
+
+                    if (!localHandlersByContext.TryGetValue(context, out sortedHandlers))
+                    {
+                        return;
+                    }
+
+                    if (
+                        !sortedHandlers.TryGetValue(
+                            priority,
+                            out IHandlerActionCache localErasedCache
+                        ) || localErasedCache is not HandlerActionCache<TU> localCache
+                    )
+                    {
+                        return;
+                    }
+
+                    if (
+                        !localCache.entries.TryGetValue(
+                            originalHandler,
+                            out HandlerActionCache<TU>.Entry localEntry
+                        )
+                    )
+                    {
+                        return;
+                    }
+
+                    localCache.version++;
+
+                    deregistration?.Invoke();
+                    if (localSlot != null)
+                    {
+                        localSlot.lastTouchTicks =
+                            global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(
+                                messageBus
+                            );
+                    }
+
+                    if (localEntry.count <= 1)
+                    {
+                        _ = localCache.entries.Remove(originalHandler);
+                        // List.Remove is O(n) over the same-priority bucket.
+                        // Accepted tradeoff (here and at every sibling
+                        // deregistration site): buckets are small in practice,
+                        // removal is a cold churn path, and the list keeps
+                        // steady-state dispatch allocation-free while
+                        // preserving first-registration order, unlike
+                        // Dictionary enumeration whose freed slots are reused
+                        // LIFO.
+                        _ = localCache.insertionOrder.Remove(originalHandler);
+                        localCache.version++;
+                        if (localSlot != null)
+                        {
+                            localSlot.liveCount--;
+                        }
+                        // Deliberately keep the priority and context mappings to preserve
+                        // frozen snapshots for the current emission.
+                        return;
+                    }
+
+                    localEntry = new HandlerActionCache<TU>.Entry(
+                        localEntry.handler,
+                        localEntry.count - 1,
+                        localEntry.flatInvoker
+                    );
+
+                    localCache.entries[originalHandler] = localEntry;
+                };
+            }
+
             private static Action AddHandlerPreservingPriorityKey<TU>(
                 InstanceId context,
                 ref Dictionary<
@@ -3719,7 +4073,7 @@ namespace DxMessaging.Core
                 TU augmentedHandler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
                 handlersByContext ??=
@@ -3758,6 +4112,10 @@ namespace DxMessaging.Core
                     : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
 
                 cache.entries[originalHandler] = entry;
+                if (firstRegistration)
+                {
+                    cache.insertionOrder.Add(originalHandler);
+                }
                 cache.version++;
 
                 Dictionary<
@@ -3796,6 +4154,7 @@ namespace DxMessaging.Core
                     if (localEntry.count <= 1)
                     {
                         _ = localCache.entries.Remove(originalHandler);
+                        _ = localCache.insertionOrder.Remove(originalHandler);
                         localCache.version++;
                         // Deliberately keep the priority and context mappings to preserve
                         // frozen snapshots for the current emission.
@@ -3807,8 +4166,43 @@ namespace DxMessaging.Core
                         localEntry.count - 1
                     );
 
-                    localCache.entries[originalHandler] = localEntry;
-                };
+                    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>(
@@ -3863,6 +4257,115 @@ namespace DxMessaging.Core
                 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,
@@ -3886,7 +4389,7 @@ namespace DxMessaging.Core
                     return;
                 }
 
-                ref T typedMessage = ref Unsafe.As<TMessage, T>(ref message);
+                ref T typedMessage = ref DxUnsafe.As<TMessage, T>(ref message);
                 List<FastHandler<T>> handlers = GetOrAddNewHandlerStack(cache, emissionId);
                 int handlersCount = handlers.Count;
                 switch (handlersCount)
@@ -3899,36 +4402,76 @@ namespace DxMessaging.Core
                     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)
+                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                 {
                     handlers[i](ref typedMessage);
                 }
@@ -3942,14 +4485,33 @@ namespace DxMessaging.Core
                 where TMessage : IMessage
                 where TU : IMessage
             {
-                if (cache?.entries is not { Count: > 0 })
+                // Snapshot semantics: do not bail on the live entries dictionary
+                // 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 dictionary
+                // emission-id/version compare and -- only when the per-emission
+                // snapshot has not been pinned yet -- a single pass over
+                // cache.entries to materialise an empty list. The win is
+                // correctness across cross-handler mid-emit removals where the
+                // pinned snapshot in cache.cache still holds handlers the live
+                // entries dictionary no longer reaches.
+                if (cache == null)
                 {
                     return;
                 }
 
-                ref TU typedMessage = ref Unsafe.As<TMessage, TU>(ref message);
+                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:
@@ -3960,56 +4522,270 @@ namespace DxMessaging.Core
                     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)
+                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 entries dictionary 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
+                )
                 {
-                    handlers[i](ref typedMessage);
+                    return;
                 }
+
+                RunFastHandlers(ref context, cache, ref message, emissionId);
             }
 
             private static void RunFastHandlers<TMessage, TU>(
                 ref InstanceId context,
-                HandlerActionCache<FastHandlerWithContext<TU>> cache,
+                Dictionary<int, HandlerActionCache<FastHandlerWithContext<TU>>> fastHandlers,
                 ref TMessage message,
+                int priority,
                 long emissionId
             )
                 where TMessage : IMessage
                 where TU : IMessage
             {
-                if (cache?.entries is not { Count: > 0 })
+                if (fastHandlers is not { Count: > 0 })
+                {
+                    return;
+                }
+
+                if (
+                    !fastHandlers.TryGetValue(
+                        priority,
+                        out HandlerActionCache<FastHandlerWithContext<TU>> cache
+                    )
+                )
                 {
                     return;
                 }
 
-                ref TU typedMessage = ref Unsafe.As<TMessage, TU>(ref message);
+                ref TU typedMessage = ref DxUnsafe.As<TMessage, TU>(ref message);
                 List<FastHandlerWithContext<TU>> handlers = GetOrAddNewHandlerStack(
                     cache,
                     emissionId
@@ -4025,206 +4801,455 @@ namespace DxMessaging.Core
                     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)
+                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                 {
                     handlers[i](ref context, ref typedMessage);
                 }
             }
 
-            private static void RunFastHandlers<TMessage, TU>(
+            private static void RunHandlersWithContext<TMessage>(
                 ref InstanceId context,
-                Dictionary<int, HandlerActionCache<FastHandlerWithContext<TU>>> fastHandlers,
+                Dictionary<InstanceId, Dictionary<int, IHandlerActionCache>> handlersByContext,
                 ref TMessage message,
                 int priority,
                 long emissionId
             )
                 where TMessage : IMessage
-                where TU : IMessage
             {
-                if (fastHandlers is not { Count: > 0 })
+                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 (
-                    !fastHandlers.TryGetValue(
-                        priority,
-                        out HandlerActionCache<FastHandlerWithContext<TU>> cache
+                    handlersByContext is not { Count: > 0 }
+                    || !handlersByContext.TryGetValue(
+                        context,
+                        out Dictionary<int, HandlerActionCache<Action<T>>> cache
                     )
                 )
                 {
                     return;
                 }
 
-                ref TU typedMessage = ref Unsafe.As<TMessage, TU>(ref message);
-                List<FastHandlerWithContext<TU>> handlers = GetOrAddNewHandlerStack(
-                    cache,
-                    emissionId
-                );
+                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<Action<T>> handlers = GetOrAddNewHandlerStack(cache, emissionId);
+                ref T typedMessage = ref DxUnsafe.As<TMessage, T>(ref message);
                 int handlersCount = handlers.Count;
                 switch (handlersCount)
                 {
                     case 1:
                     {
-                        handlers[0](ref context, ref typedMessage);
+                        handlers[0](typedMessage);
                         return;
                     }
                     case 2:
                     {
-                        handlers[0](ref context, ref typedMessage);
-                        handlers[1](ref context, ref typedMessage);
+                        handlers[0](typedMessage);
+                        if (handlers.Count < 2)
+                        {
+                            return;
+                        }
+                        handlers[1](typedMessage);
                         return;
                     }
                     case 3:
                     {
-                        handlers[0](ref context, ref typedMessage);
-                        handlers[1](ref context, ref typedMessage);
-                        handlers[2](ref context, ref typedMessage);
+                        handlers[0](typedMessage);
+                        if (handlers.Count < 2)
+                        {
+                            return;
+                        }
+                        handlers[1](typedMessage);
+                        if (handlers.Count < 3)
+                        {
+                            return;
+                        }
+                        handlers[2](typedMessage);
                         return;
                     }
                     case 4:
                     {
-                        handlers[0](ref context, ref typedMessage);
-                        handlers[1](ref context, ref typedMessage);
-                        handlers[2](ref context, ref typedMessage);
-                        handlers[3](ref context, ref typedMessage);
+                        handlers[0](typedMessage);
+                        if (handlers.Count < 2)
+                        {
+                            return;
+                        }
+                        handlers[1](typedMessage);
+                        if (handlers.Count < 3)
+                        {
+                            return;
+                        }
+                        handlers[2](typedMessage);
+                        if (handlers.Count < 4)
+                        {
+                            return;
+                        }
+                        handlers[3](typedMessage);
                         return;
                     }
                     case 5:
                     {
-                        handlers[0](ref context, ref typedMessage);
-                        handlers[1](ref context, ref typedMessage);
-                        handlers[2](ref context, ref typedMessage);
-                        handlers[3](ref context, ref typedMessage);
-                        handlers[4](ref context, ref typedMessage);
+                        handlers[0](typedMessage);
+                        if (handlers.Count < 2)
+                        {
+                            return;
+                        }
+                        handlers[1](typedMessage);
+                        if (handlers.Count < 3)
+                        {
+                            return;
+                        }
+                        handlers[2](typedMessage);
+                        if (handlers.Count < 4)
+                        {
+                            return;
+                        }
+                        handlers[3](typedMessage);
+                        if (handlers.Count < 5)
+                        {
+                            return;
+                        }
+                        handlers[4](typedMessage);
                         return;
                     }
                 }
 
-                for (int i = 0; i < handlersCount; ++i)
+                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
                 {
-                    handlers[i](ref context, ref typedMessage);
+                    handlers[i](typedMessage);
                 }
             }
 
-            private static void RunHandlersWithContext<TMessage>(
-                ref InstanceId context,
-                Dictionary<
-                    InstanceId,
-                    Dictionary<int, HandlerActionCache<Action<T>>>
-                > handlersByContext,
+            private static void RunHandlers<TMessage>(
+                Dictionary<int, HandlerActionCache<Action<T>>> sortedHandlers,
                 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
-                    )
-                )
+                if (sortedHandlers is not { Count: > 0 })
                 {
                     return;
                 }
 
-                RunHandlers(cache, ref message, priority, emissionId);
+                if (!sortedHandlers.TryGetValue(priority, out HandlerActionCache<Action<T>> cache))
+                {
+                    return;
+                }
+
+                List<Action<T>> handlers = GetOrAddNewHandlerStack(cache, emissionId);
+                ref T typedMessage = ref DxUnsafe.As<TMessage, T>(ref message);
+                int handlersCount = handlers.Count;
+                switch (handlersCount)
+                {
+                    case 1:
+                    {
+                        handlers[0](typedMessage);
+                        return;
+                    }
+                    case 2:
+                    {
+                        handlers[0](typedMessage);
+                        if (handlers.Count < 2)
+                        {
+                            return;
+                        }
+                        handlers[1](typedMessage);
+                        return;
+                    }
+                    case 3:
+                    {
+                        handlers[0](typedMessage);
+                        if (handlers.Count < 2)
+                        {
+                            return;
+                        }
+                        handlers[1](typedMessage);
+                        if (handlers.Count < 3)
+                        {
+                            return;
+                        }
+                        handlers[2](typedMessage);
+                        return;
+                    }
+                    case 4:
+                    {
+                        handlers[0](typedMessage);
+                        if (handlers.Count < 2)
+                        {
+                            return;
+                        }
+                        handlers[1](typedMessage);
+                        if (handlers.Count < 3)
+                        {
+                            return;
+                        }
+                        handlers[2](typedMessage);
+                        if (handlers.Count < 4)
+                        {
+                            return;
+                        }
+                        handlers[3](typedMessage);
+                        return;
+                    }
+                    case 5:
+                    {
+                        handlers[0](typedMessage);
+                        if (handlers.Count < 2)
+                        {
+                            return;
+                        }
+                        handlers[1](typedMessage);
+                        if (handlers.Count < 3)
+                        {
+                            return;
+                        }
+                        handlers[2](typedMessage);
+                        if (handlers.Count < 4)
+                        {
+                            return;
+                        }
+                        handlers[3](typedMessage);
+                        if (handlers.Count < 5)
+                        {
+                            return;
+                        }
+                        handlers[4](typedMessage);
+                        return;
+                    }
+                }
+
+                for (int i = 0; i < handlersCount && i < handlers.Count; ++i)
+                {
+                    handlers[i](typedMessage);
+                }
             }
 
             private static void RunHandlers<TMessage>(
-                Dictionary<int, HandlerActionCache<Action<T>>> sortedHandlers,
+                ref InstanceId context,
+                Dictionary<int, IHandlerActionCache> handlers,
                 ref TMessage message,
                 int priority,
                 long emissionId
             )
                 where TMessage : IMessage
             {
-                if (sortedHandlers is not { Count: > 0 })
+                if (handlers is not { Count: > 0 })
                 {
                     return;
                 }
 
-                if (!sortedHandlers.TryGetValue(priority, out HandlerActionCache<Action<T>> cache))
+                if (
+                    !handlers.TryGetValue(priority, out IHandlerActionCache erasedCache)
+                    || erasedCache is not HandlerActionCache<Action<InstanceId, T>> cache
+                )
                 {
                     return;
                 }
 
-                List<Action<T>> handlers = GetOrAddNewHandlerStack(cache, emissionId);
-                ref T typedMessage = ref Unsafe.As<TMessage, T>(ref message);
-                int handlersCount = handlers.Count;
+                List<Action<InstanceId, T>> typedHandlers = GetOrAddNewHandlerStack(
+                    cache,
+                    emissionId
+                );
+                ref T typedMessage = ref DxUnsafe.As<TMessage, T>(ref message);
+                int handlersCount = typedHandlers.Count;
                 switch (handlersCount)
                 {
                     case 1:
                     {
-                        handlers[0](typedMessage);
+                        typedHandlers[0](context, typedMessage);
                         return;
                     }
                     case 2:
                     {
-                        handlers[0](typedMessage);
-                        handlers[1](typedMessage);
+                        typedHandlers[0](context, typedMessage);
+                        if (typedHandlers.Count < 2)
+                        {
+                            return;
+                        }
+                        typedHandlers[1](context, typedMessage);
                         return;
                     }
                     case 3:
                     {
-                        handlers[0](typedMessage);
-                        handlers[1](typedMessage);
-                        handlers[2](typedMessage);
+                        typedHandlers[0](context, typedMessage);
+                        if (typedHandlers.Count < 2)
+                        {
+                            return;
+                        }
+                        typedHandlers[1](context, typedMessage);
+                        if (typedHandlers.Count < 3)
+                        {
+                            return;
+                        }
+                        typedHandlers[2](context, typedMessage);
                         return;
                     }
                     case 4:
                     {
-                        handlers[0](typedMessage);
-                        handlers[1](typedMessage);
-                        handlers[2](typedMessage);
-                        handlers[3](typedMessage);
+                        typedHandlers[0](context, typedMessage);
+                        if (typedHandlers.Count < 2)
+                        {
+                            return;
+                        }
+                        typedHandlers[1](context, typedMessage);
+                        if (typedHandlers.Count < 3)
+                        {
+                            return;
+                        }
+                        typedHandlers[2](context, typedMessage);
+                        if (typedHandlers.Count < 4)
+                        {
+                            return;
+                        }
+                        typedHandlers[3](context, typedMessage);
                         return;
                     }
                     case 5:
                     {
-                        handlers[0](typedMessage);
-                        handlers[1](typedMessage);
-                        handlers[2](typedMessage);
-                        handlers[3](typedMessage);
-                        handlers[4](typedMessage);
+                        typedHandlers[0](context, typedMessage);
+                        if (typedHandlers.Count < 2)
+                        {
+                            return;
+                        }
+                        typedHandlers[1](context, typedMessage);
+                        if (typedHandlers.Count < 3)
+                        {
+                            return;
+                        }
+                        typedHandlers[2](context, typedMessage);
+                        if (typedHandlers.Count < 4)
+                        {
+                            return;
+                        }
+                        typedHandlers[3](context, typedMessage);
+                        if (typedHandlers.Count < 5)
+                        {
+                            return;
+                        }
+                        typedHandlers[4](context, typedMessage);
                         return;
                     }
                 }
 
-                for (int i = 0; i < handlersCount; ++i)
+                for (int i = 0; i < handlersCount && i < typedHandlers.Count; ++i)
                 {
-                    handlers[i](typedMessage);
+                    typedHandlers[i](context, typedMessage);
                 }
             }
 
@@ -4256,7 +5281,7 @@ namespace DxMessaging.Core
                     cache,
                     emissionId
                 );
-                ref T typedMessage = ref Unsafe.As<TMessage, T>(ref message);
+                ref T typedMessage = ref DxUnsafe.As<TMessage, T>(ref message);
                 int handlersCount = typedHandlers.Count;
                 switch (handlersCount)
                 {
@@ -4268,60 +5293,124 @@ namespace DxMessaging.Core
                     case 2:
                     {
                         typedHandlers[0](context, typedMessage);
+                        if (typedHandlers.Count < 2)
+                        {
+                            return;
+                        }
                         typedHandlers[1](context, typedMessage);
                         return;
                     }
                     case 3:
                     {
                         typedHandlers[0](context, typedMessage);
+                        if (typedHandlers.Count < 2)
+                        {
+                            return;
+                        }
                         typedHandlers[1](context, typedMessage);
+                        if (typedHandlers.Count < 3)
+                        {
+                            return;
+                        }
                         typedHandlers[2](context, typedMessage);
                         return;
                     }
                     case 4:
                     {
                         typedHandlers[0](context, typedMessage);
+                        if (typedHandlers.Count < 2)
+                        {
+                            return;
+                        }
                         typedHandlers[1](context, typedMessage);
+                        if (typedHandlers.Count < 3)
+                        {
+                            return;
+                        }
                         typedHandlers[2](context, typedMessage);
+                        if (typedHandlers.Count < 4)
+                        {
+                            return;
+                        }
                         typedHandlers[3](context, typedMessage);
                         return;
                     }
                     case 5:
                     {
                         typedHandlers[0](context, typedMessage);
+                        if (typedHandlers.Count < 2)
+                        {
+                            return;
+                        }
                         typedHandlers[1](context, typedMessage);
+                        if (typedHandlers.Count < 3)
+                        {
+                            return;
+                        }
                         typedHandlers[2](context, typedMessage);
+                        if (typedHandlers.Count < 4)
+                        {
+                            return;
+                        }
                         typedHandlers[3](context, typedMessage);
+                        if (typedHandlers.Count < 5)
+                        {
+                            return;
+                        }
                         typedHandlers[4](context, typedMessage);
                         return;
                     }
                 }
 
-                for (int i = 0; i < handlersCount; ++i)
+                for (int i = 0; i < handlersCount && i < typedHandlers.Count; ++i)
                 {
                     typedHandlers[i](context, 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
             )
             {
+                DebugAssertInsertionOrderInSync(actionCache);
                 if (actionCache.lastSeenEmissionId != emissionId)
                 {
                     if (actionCache.version != actionCache.lastSeenVersion)
                     {
+                        // Rebuild the dispatch snapshot from insertionOrder, NOT from
+                        // the entries dictionary: dictionary enumeration order permutes
+                        // after Remove/Add churn (freed slots are reused LIFO), while
+                        // insertionOrder preserves the documented first-registration
+                        // order for equal-priority handlers. This branch only runs on
+                        // registration churn (version bump), never on steady-state
+                        // dispatch, and allocates nothing (the pooled cache list is
+                        // cleared and refilled in place).
                         List<TU> list = actionCache.cache;
                         list.Clear();
-                        foreach (
-                            KeyValuePair<
-                                TU,
-                                HandlerActionCache<TU>.Entry
-                            > kvp in actionCache.entries
-                        )
+                        List<TU> orderedHandlers = actionCache.insertionOrder;
+                        int orderedCount = orderedHandlers.Count;
+                        for (int i = 0; i < orderedCount; ++i)
                         {
-                            list.Add(kvp.Value.handler);
+                            if (
+                                actionCache.entries.TryGetValue(
+                                    orderedHandlers[i],
+                                    out HandlerActionCache<TU>.Entry entry
+                                )
+                            )
+                            {
+                                list.Add(entry.handler);
+                            }
                         }
                         actionCache.lastSeenVersion = actionCache.version;
                     }
@@ -4330,20 +5419,126 @@ namespace DxMessaging.Core
                 return actionCache.cache;
             }
 
-            private static void PrefreezeHandlersForEmission<THandler>(
-                Dictionary<int, HandlerActionCache<THandler>> handlers,
-                int priority,
-                long emissionId
+            // Asserts insertionOrder stays in lockstep with the entries
+            // dictionary at every dispatch-snapshot read. Drift indicates a
+            // mutation site of HandlerActionCache.entries that forgot to
+            // mirror the change into insertionOrder (AddHandler* family,
+            // deregistration closures, IHandlerActionCache.Reset). Stripped
+            // in Release builds via [Conditional("DEBUG")] -- zero hot-path
+            // cost.
+            [Conditional("DEBUG")]
+            private static void DebugAssertInsertionOrderInSync<TU>(
+                HandlerActionCache<TU> actionCache
+            )
+            {
+                System.Diagnostics.Debug.Assert(
+                    actionCache.insertionOrder.Count == actionCache.entries.Count,
+                    "HandlerActionCache.insertionOrder must mirror entries: every first "
+                        + "registration appends and every final deregistration removes. A "
+                        + "count mismatch means a mutation site skipped the insertionOrder "
+                        + "update and same-priority dispatch order is no longer trustworthy."
+                );
+            }
+
+            private static Action AddHandler<TU>(
+                TypedGlobalSlot slot,
+                TU originalHandler,
+                TU augmentedHandler,
+                Action deregistration,
+                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 (
-                    handlers != null
-                    && handlers.TryGetValue(priority, out HandlerActionCache<THandler> cache)
+                    !cache.entries.TryGetValue(
+                        originalHandler,
+                        out HandlerActionCache<TU>.Entry entry
+                    )
                 )
                 {
-                    cache.prefreezeInvocationCount++;
-                    _ = GetOrAddNewHandlerStack(cache, emissionId);
+                    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;
+                if (firstRegistration)
+                {
+                    cache.insertionOrder.Add(originalHandler);
                 }
+                cache.version++;
+                if (firstRegistration)
+                {
+                    slot.liveCount++;
+                }
+
+                HandlerActionCache<TU> localCache = cache;
+                TypedGlobalSlot localSlot = slot;
+                long localSlotVersion = slot.version;
+                long localResetGeneration =
+                    global::DxMessaging.Core.MessageBus.MessageBus.GetResetGeneration(messageBus);
+
+                return () =>
+                {
+                    if (
+                        !global::DxMessaging.Core.MessageBus.MessageBus.IsResetGenerationCurrent(
+                            messageBus,
+                            localResetGeneration
+                        )
+                    )
+                    {
+                        return;
+                    }
+
+                    if (localSlot.version != localSlotVersion)
+                    {
+                        return;
+                    }
+
+                    if (
+                        !localCache.entries.TryGetValue(
+                            originalHandler,
+                            out HandlerActionCache<TU>.Entry localEntry
+                        )
+                    )
+                    {
+                        return;
+                    }
+
+                    localCache.version++;
+
+                    deregistration?.Invoke();
+                    localSlot.lastTouchTicks =
+                        global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(
+                            messageBus
+                        );
+
+                    if (localEntry.count <= 1)
+                    {
+                        _ = localCache.entries.Remove(originalHandler);
+                        _ = localCache.insertionOrder.Remove(originalHandler);
+                        localCache.version++;
+                        localSlot.liveCount--;
+                        return;
+                    }
+
+                    localEntry = new HandlerActionCache<TU>.Entry(
+                        localEntry.handler,
+                        localEntry.count - 1
+                    );
+                    localCache.entries[originalHandler] = localEntry;
+                };
             }
 
             private static Action AddHandler<TU>(
@@ -4356,7 +5551,7 @@ namespace DxMessaging.Core
                 TU augmentedHandler,
                 Action deregistration,
                 int priority,
-                long emissionId
+                IMessageBus messageBus
             )
             {
                 handlersByContext ??=
@@ -4395,6 +5590,10 @@ namespace DxMessaging.Core
                     : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
 
                 cache.entries[originalHandler] = entry;
+                if (firstRegistration)
+                {
+                    cache.insertionOrder.Add(originalHandler);
+                }
                 cache.version++;
 
                 Dictionary<
@@ -4433,6 +5632,7 @@ namespace DxMessaging.Core
                     if (localEntry.count <= 1)
                     {
                         _ = localCache.entries.Remove(originalHandler);
+                        _ = localCache.insertionOrder.Remove(originalHandler);
                         localCache.version++;
                         if (localCache.entries.Count == 0)
                         {
@@ -4480,6 +5680,10 @@ namespace DxMessaging.Core
                     : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
 
                 cache.entries[originalHandler] = entry;
+                if (firstRegistration)
+                {
+                    cache.insertionOrder.Add(originalHandler);
+                }
                 cache.version++;
 
                 HandlerActionCache<TU> localCache = cache;
@@ -4503,6 +5707,7 @@ namespace DxMessaging.Core
                     if (localEntry.count <= 1)
                     {
                         _ = localCache.entries.Remove(originalHandler);
+                        _ = localCache.insertionOrder.Remove(originalHandler);
                         localCache.version++;
                         return;
                     }
@@ -4548,6 +5753,10 @@ namespace DxMessaging.Core
                     : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
 
                 cache.entries[originalHandler] = entry;
+                if (firstRegistration)
+                {
+                    cache.insertionOrder.Add(originalHandler);
+                }
                 cache.version++;
 
                 Dictionary<int, HandlerActionCache<TU>> localHandlers = handlers;
@@ -4576,6 +5785,7 @@ namespace DxMessaging.Core
                     if (localEntry.count <= 1)
                     {
                         _ = localCache.entries.Remove(originalHandler);
+                        _ = localCache.insertionOrder.Remove(originalHandler);
                         localCache.version++;
                         if (localCache.entries.Count == 0)
                         {
@@ -4597,6 +5807,148 @@ namespace DxMessaging.Core
             // 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 Action AddHandlerPreservingPriorityKey<TU>(
+                Dictionary<int, IHandlerActionCache> handlers,
+                TU originalHandler,
+                TU augmentedHandler,
+                Action 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;
+                if (firstRegistration)
+                {
+                    cache.insertionOrder.Add(originalHandler);
+                }
+                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++;
+                }
+
+                Dictionary<int, IHandlerActionCache> localHandlers = handlers;
+                TypedSlot<T> localSlot = slot;
+                long localSlotVersion = slot?.version ?? 0;
+                long localResetGeneration =
+                    global::DxMessaging.Core.MessageBus.MessageBus.GetResetGeneration(messageBus);
+
+                return () =>
+                {
+                    if (
+                        !global::DxMessaging.Core.MessageBus.MessageBus.IsResetGenerationCurrent(
+                            messageBus,
+                            localResetGeneration
+                        )
+                    )
+                    {
+                        return;
+                    }
+
+                    if (localSlot != null && localSlot.version != localSlotVersion)
+                    {
+                        return;
+                    }
+
+                    if (
+                        !localHandlers.TryGetValue(
+                            priority,
+                            out IHandlerActionCache localErasedCache
+                        ) || localErasedCache is not HandlerActionCache<TU> localCache
+                    )
+                    {
+                        return;
+                    }
+
+                    if (
+                        !localCache.entries.TryGetValue(
+                            originalHandler,
+                            out HandlerActionCache<TU>.Entry localEntry
+                        )
+                    )
+                    {
+                        return;
+                    }
+
+                    localCache.version++;
+
+                    deregistration?.Invoke();
+                    if (localSlot != null)
+                    {
+                        localSlot.lastTouchTicks =
+                            global::DxMessaging.Core.MessageBus.MessageBus.GetCurrentTouchTick(
+                                messageBus
+                            );
+                    }
+
+                    if (localEntry.count <= 1)
+                    {
+                        _ = localCache.entries.Remove(originalHandler);
+                        _ = localCache.insertionOrder.Remove(originalHandler);
+                        localCache.version++;
+                        if (localSlot != null)
+                        {
+                            localSlot.liveCount--;
+                        }
+                        // Intentionally DO NOT remove the priority key here to preserve
+                        // the cache handle during an in-flight emission.
+                        return;
+                    }
+
+                    localEntry = new HandlerActionCache<TU>.Entry(
+                        localEntry.handler,
+                        localEntry.count - 1,
+                        localEntry.flatInvoker
+                    );
+
+                    localCache.entries[originalHandler] = localEntry;
+                };
+            }
+
             private static Action AddHandlerPreservingPriorityKey<TU>(
                 ref Dictionary<int, HandlerActionCache<TU>> handlers,
                 TU originalHandler,
@@ -4630,6 +5982,10 @@ namespace DxMessaging.Core
                     : new HandlerActionCache<TU>.Entry(entry.handler, entry.count + 1);
 
                 cache.entries[originalHandler] = entry;
+                if (firstRegistration)
+                {
+                    cache.insertionOrder.Add(originalHandler);
+                }
                 cache.version++;
 
                 Dictionary<int, HandlerActionCache<TU>> localHandlers = handlers;
@@ -4658,6 +6014,7 @@ namespace DxMessaging.Core
                     if (localEntry.count <= 1)
                     {
                         _ = localCache.entries.Remove(originalHandler);
+                        _ = localCache.insertionOrder.Remove(originalHandler);
                         localCache.version++;
                         // Intentionally DO NOT remove the priority key here to preserve
                         // the cache handle during an in-flight emission.