com.wallstop-studios.dxmessaging 3.1.0 → 3.2.1

package/Runtime/Core/MessageBus/MessageBus.cs

@@ -59,6 +59,7 @@ namespace DxMessaging.Core.MessageBus
         /// </summary>
         public long EmissionId => 0 < _dispatchDepth ? _scopedEmissionId : _emissionId;
         internal long TickCounter => _tickCounter;
+        internal bool IsDispatching => _dispatchDepth > 0;
 
         private const long DefaultIdleEvictionTicks = 30;
         private const double DefaultEvictionTickIntervalSeconds = 5d;
@@ -173,18 +174,74 @@ namespace DxMessaging.Core.MessageBus
 
         private static CollectionPool<
             Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
-        > ContextHandlerByTargetDicts => ContextHandlerByTargetDictPoolHolder.Instance;
+        > ContextHandlerByTargetDictsOverride;
+
+        private static CollectionPool<
+            Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
+        > ContextHandlerByTargetDicts =>
+            ContextHandlerByTargetDictsOverride ?? ContextHandlerByTargetDictPoolHolder.Instance;
+
+        private static CollectionPool<
+            Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
+        > CreateContextHandlerByTargetPool(int maxRetained, bool useLru)
+        {
+            return new CollectionPool<Dictionary<InstanceId, HandlerCache<int, HandlerCache>>>(
+                maxRetained,
+                useLru,
+                factory: static () => CreateFreshContextHandlerMap(),
+                onRecycled: static dict => dict.Clear()
+            );
+        }
+
+        private static Dictionary<
+            InstanceId,
+            HandlerCache<int, HandlerCache>
+        > CreateFreshContextHandlerMap()
+        {
+            return new Dictionary<InstanceId, HandlerCache<int, HandlerCache>>();
+        }
+
+        internal static object CreateContextMapSeedForBenchmark()
+        {
+            return new HandlerCache<int, HandlerCache>();
+        }
+
+        internal static object CreatePopulatedContextMapForBenchmark(InstanceId[] keys, object seed)
+        {
+            if (keys == null)
+            {
+                throw new ArgumentNullException(nameof(keys));
+            }
+            HandlerCache<int, HandlerCache> typedSeed =
+                seed as HandlerCache<int, HandlerCache>
+                ?? throw new ArgumentException("Unexpected context-map seed type.", nameof(seed));
+            Dictionary<InstanceId, HandlerCache<int, HandlerCache>> map =
+                CreateFreshContextHandlerMap();
+            for (int index = 0; index < keys.Length; ++index)
+            {
+                map[keys[index]] = typedSeed;
+            }
+            return map;
+        }
+
+        internal static void ObserveContextMapForBenchmark(
+            object opaqueMap,
+            out int count,
+            out int capacity
+        )
+        {
+            Dictionary<InstanceId, HandlerCache<int, HandlerCache>> map =
+                opaqueMap as Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
+                ?? throw new ArgumentException("Unexpected context-map type.", nameof(opaqueMap));
+            count = map.Count;
+            capacity = map.EnsureCapacity(0);
+        }
 
         private static class ContextHandlerByTargetDictPoolHolder
         {
             public static readonly CollectionPool<
                 Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
-            > Instance = new(
-                maxRetained: 512,
-                useLru: true,
-                factory: static () => new Dictionary<InstanceId, HandlerCache<int, HandlerCache>>(),
-                onRecycled: static dict => dict.Clear()
-            );
+            > Instance = CreateContextHandlerByTargetPool(maxRetained: 512, useLru: true);
         }
 
         internal static int ResetStaticPools()
@@ -192,11 +249,10 @@ namespace DxMessaging.Core.MessageBus
             return ContextHandlerByTargetDicts.Trim(0);
         }
 
-        // One bucket entry per registered MessageHandler. Entry arrays are
-        // populated only for the GLOBAL accept-all snapshots (the only
-        // remaining bucket-walking dispatch path); non-global snapshots carry
-        // count-only buckets (see BuildDispatchSnapshot) because their
-        // dispatch happens exclusively through the resolved flat arrays.
+        // One bucket entry per registered MessageHandler. Bucket arrays are
+        // populated only for GLOBAL accept-all snapshots (the only remaining
+        // bucket-walking dispatch path). Non-global snapshots carry a resolved
+        // flat array and its entry count directly.
         internal readonly struct DispatchEntry
         {
             public DispatchEntry(MessageHandler handler)
@@ -227,11 +283,6 @@ namespace DxMessaging.Core.MessageBus
             public int entryCount;
             public bool pooledEntries;
 
-            public static DispatchBucket CreateEmpty(int priority)
-            {
-                return new DispatchBucket(priority, Array.Empty<DispatchEntry>(), 0, false);
-            }
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public void ReleaseEntries()
             {
@@ -253,18 +304,42 @@ namespace DxMessaging.Core.MessageBus
             public static readonly DispatchSnapshot Empty = new DispatchSnapshot(
                 Array.Empty<DispatchBucket>(),
                 0,
+                0,
+                false,
                 false
             );
 
-            public DispatchSnapshot(DispatchBucket[] buckets, int count, bool pooled)
+            public DispatchSnapshot(
+                DispatchBucket[] buckets,
+                int bucketCount,
+                int entryCount,
+                bool hasRegistrations,
+                bool pooled
+            )
             {
                 this.buckets = buckets;
-                bucketCount = count;
+                this.bucketCount = bucketCount;
+                this.entryCount = entryCount;
+                this.hasRegistrations = hasRegistrations;
                 _pooled = pooled;
+                _pooledBuckets = pooled;
+            }
+
+            public DispatchSnapshot(FlatDispatchArray flat, bool hasRegistrations)
+            {
+                buckets = Array.Empty<DispatchBucket>();
+                bucketCount = 0;
+                entryCount = flat?.Count ?? 0;
+                this.hasRegistrations = hasRegistrations;
+                this.flat = flat;
+                _pooled = true;
+                _pooledBuckets = false;
             }
 
             public DispatchBucket[] buckets;
             public int bucketCount;
+            public int entryCount;
+            public bool hasRegistrations;
 
             // Resolved flat dispatch entries for every flattened slot kind:
             // untargeted handle/post, targeted/broadcast Default handle/post
@@ -278,8 +353,9 @@ namespace DxMessaging.Core.MessageBus
             // Release().
             public FlatDispatchArray flat;
             private bool _pooled;
+            private readonly bool _pooledBuckets;
 
-            public bool IsEmpty => bucketCount == 0;
+            public bool IsInitialized => !ReferenceEquals(this, Empty);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public void Release()
@@ -292,15 +368,21 @@ namespace DxMessaging.Core.MessageBus
                 flat?.Release();
                 flat = null;
 
-                for (int i = 0; i < bucketCount; ++i)
+                if (_pooledBuckets)
                 {
-                    buckets[i].ReleaseEntries();
+                    for (int i = 0; i < bucketCount; ++i)
+                    {
+                        buckets[i].ReleaseEntries();
+                    }
+
+                    Array.Clear(buckets, 0, bucketCount);
+                    DispatchBucketPool.Return(buckets);
                 }
 
-                Array.Clear(buckets, 0, bucketCount);
-                DispatchBucketPool.Return(buckets);
                 buckets = Array.Empty<DispatchBucket>();
                 bucketCount = 0;
+                entryCount = 0;
+                hasRegistrations = false;
                 _pooled = false;
             }
         }
@@ -375,15 +457,12 @@ namespace DxMessaging.Core.MessageBus
         {
             public readonly Dictionary<TKey, TValue> handlers = new();
             public readonly List<TKey> order = new();
-            public readonly List<KeyValuePair<TKey, TValue>> cache = new();
             public long version;
-            public long lastSeenVersion = -1;
-            public long lastSeenEmissionId = -1;
             public long lastTouchTicks;
             public DispatchState dispatchState;
 
             /// <summary>
-            /// Clears all cached handler references and resets the version tracking metadata.
+            /// Clears all handler references and resets the mutation version.
             /// </summary>
             public void Clear()
             {
@@ -392,10 +471,7 @@ namespace DxMessaging.Core.MessageBus
                 // is handled by sweep-driven slot reset paths.
                 handlers.Clear();
                 order.Clear();
-                cache.Clear();
                 version = 0;
-                lastSeenVersion = -1;
-                lastSeenEmissionId = -1;
                 dispatchState?.Reset();
                 dispatchState = null;
             }
@@ -404,13 +480,11 @@ namespace DxMessaging.Core.MessageBus
         private sealed class InterceptorCache<TValue>
         {
             public readonly SortedList<int, List<TValue>> handlers = new();
-            public long lastSeenEmissionId = -1;
             public long lastTouchTicks;
 
             public void Clear()
             {
                 handlers.Clear();
-                lastSeenEmissionId = -1;
                 lastTouchTicks = 0;
             }
         }
@@ -489,16 +563,14 @@ namespace DxMessaging.Core.MessageBus
             // across components. Invariants: contains exactly the keys of
             // <see cref="handlers"/>; a key is appended on its FIRST
             // registration only (refcount increments do not move it) and
-            // removed when its refcount drops to zero. Mirrors the
-            // MessageHandler-side HandlerActionCache.insertionOrder design.
+            // removed when its refcount drops to zero. The MessageHandler-side
+            // cache keeps this invariant inside one ordered container; the
+            // bus-side map remains a separate candidate.
             public readonly List<MessageHandler> insertionOrder = new();
-            public readonly List<MessageHandler> cache = new();
             public long version;
-            public long lastSeenVersion = -1;
-            public long lastSeenEmissionId = -1;
 
             /// <summary>
-            /// Clears all cached handler references and resets the version tracking metadata.
+            /// Clears all handler references and resets the mutation version.
             /// </summary>
             public void Clear()
             {
@@ -507,10 +579,7 @@ namespace DxMessaging.Core.MessageBus
                 // is handled by sweep-driven slot reset paths.
                 handlers.Clear();
                 insertionOrder.Clear();
-                cache.Clear();
                 version = 0;
-                lastSeenVersion = -1;
-                lastSeenEmissionId = -1;
             }
         }
 
@@ -784,7 +853,7 @@ namespace DxMessaging.Core.MessageBus
             public static bool SourcedRegistered;
         }
 
-        public RegistrationLog Log => _log;
+        public RegistrationLog Log => _log ??= new RegistrationLog();
 
         // Storage trio for typed and global dispatch. _scalarSinks and
         // _contextSinks are SlotKey-indexed arrays of MessageCache (call sites
@@ -829,6 +898,127 @@ namespace DxMessaging.Core.MessageBus
         private readonly MessageCache<DispatchPlan> _targetedDispatchPlans = new();
         private readonly MessageCache<DispatchPlan> _broadcastDispatchPlans = new();
 
+        internal readonly struct FlatSnapshotStorageObservation
+        {
+            internal FlatSnapshotStorageObservation(
+                int entryCount,
+                int arrayCapacity,
+                int emptyHolderPoolCount
+            )
+            {
+                EntryCount = entryCount;
+                ArrayCapacity = arrayCapacity;
+                EmptyHolderPoolCount = emptyHolderPoolCount;
+            }
+
+            internal int EntryCount { get; }
+
+            internal int ArrayCapacity { get; }
+
+            /// <summary>
+            /// Released holder objects currently pooled with empty entry arrays. This does not
+            /// measure arrays or retained bytes; ArrayPool memory retention requires an external
+            /// memory measurement.
+            /// </summary>
+            internal int EmptyHolderPoolCount { get; }
+        }
+
+        internal readonly struct PriorityStorageObservation
+        {
+            internal PriorityStorageObservation(int entries, int mapCapacity, int orderCapacity)
+            {
+                Entries = entries;
+                MapCapacity = mapCapacity;
+                OrderCapacity = orderCapacity;
+            }
+
+            internal int Entries { get; }
+
+            internal int MapCapacity { get; }
+
+            internal int OrderCapacity { get; }
+        }
+
+        internal bool TryObserveUntargetedPriorityStorageForBenchmark<TMessage>(
+            out PriorityStorageObservation observation
+        )
+            where TMessage : IUntargetedMessage
+        {
+            if (
+                !_scalarSinks[BusSinkIndex.UntargetedHandleDefault]
+                    .TryGetValue<TMessage>(out HandlerCache<int, HandlerCache> handlers)
+            )
+            {
+                observation = default;
+                return false;
+            }
+
+            observation = ObservePriorityStorage(handlers);
+            return true;
+        }
+
+        internal static object CreatePriorityStorageOwnerForBenchmark()
+        {
+            return new HandlerCache<int, HandlerCache>();
+        }
+
+        internal static bool TryObservePriorityStorageOwnerForBenchmark(
+            object owner,
+            out PriorityStorageObservation observation
+        )
+        {
+            if (owner is not HandlerCache<int, HandlerCache> handlers)
+            {
+                observation = default;
+                return false;
+            }
+
+            observation = ObservePriorityStorage(handlers);
+            return true;
+        }
+
+        private static PriorityStorageObservation ObservePriorityStorage(
+            HandlerCache<int, HandlerCache> handlers
+        )
+        {
+            return new PriorityStorageObservation(
+                handlers.handlers.Count,
+                handlers.handlers.EnsureCapacity(0),
+                handlers.order.Capacity
+            );
+        }
+
+        /// <summary>
+        /// Read-only benchmark telemetry for the active untargeted flat snapshot of
+        /// <typeparamref name="TMessage"/>. This method does not acquire, build, or mutate a
+        /// snapshot, so observing storage cannot alter the path being measured.
+        /// </summary>
+        internal bool TryObserveUntargetedFlatSnapshotStorageForBenchmark<TMessage>(
+            out FlatSnapshotStorageObservation observation
+        )
+            where TMessage : IUntargetedMessage
+        {
+            if (
+                !_scalarSinks[BusSinkIndex.UntargetedHandleDefault]
+                    .TryGetValue<TMessage>(out HandlerCache<int, HandlerCache> handlers)
+                || handlers.dispatchState == null
+                || ReferenceEquals(handlers.dispatchState.active, DispatchSnapshot.Empty)
+                || handlers.dispatchState.active.flat == null
+            )
+            {
+                observation = default;
+                return false;
+            }
+
+            FlatDispatchArray flat = handlers.dispatchState.active.flat;
+            observation = new FlatSnapshotStorageObservation(
+                flat.Count,
+                flat.Capacity,
+                flat.EmptyHolderPoolCount
+            );
+            return true;
+        }
+
         // Bumped by every mutation that can change what a DispatchPlan
         // caches or decides. Plans compare their stamp against this value at
         // every emission; the emit shells also re-compare mid-emission to
@@ -923,7 +1113,9 @@ namespace DxMessaging.Core.MessageBus
         }
 
 #if UNITY_2021_3_OR_NEWER
-        private static readonly List<WeakReference<MessageBus>> IdleSweepBuses = new();
+        private static List<WeakReference<MessageBus>> IdleSweepBuses = new();
+        private static IdleSweepRegistryBenchmarkScope ActiveIdleSweepRegistryBenchmarkScope;
+        private static ContextMapPoolBenchmarkScope ActiveContextMapPoolBenchmarkScope;
         private static bool RuntimeSettingsSubscribed;
 
         private static void RegisterForIdleSweeps(MessageBus bus)
@@ -997,6 +1189,206 @@ namespace DxMessaging.Core.MessageBus
             ResetStaticPools();
         }
 
+        internal static IDisposable IsolateIdleSweepRegistryForBenchmark()
+        {
+            return new IdleSweepRegistryBenchmarkScope();
+        }
+
+        internal static int IdleSweepRegistryCountForBenchmark => IdleSweepBuses.Count;
+
+        internal static object IdleSweepRegistryIdentityForBenchmark => IdleSweepBuses;
+
+        internal static IDisposable IsolateContextMapPoolForBenchmark()
+        {
+            return new ContextMapPoolBenchmarkScope();
+        }
+
+        internal static bool ContextMapPoolOverrideActiveForBenchmark =>
+            ContextHandlerByTargetDictsOverride != null;
+
+        internal static ContextMapPoolBenchmarkObservation ObserveContextMapPoolForBenchmark()
+        {
+            CollectionPool<Dictionary<InstanceId, HandlerCache<int, HandlerCache>>> current =
+                ContextHandlerByTargetDicts;
+            return new ContextMapPoolBenchmarkObservation(
+                current,
+                current.UseLru,
+                current.MaxRetained
+            );
+        }
+
+        internal static void ConfigureContextMapPoolForBenchmark(bool useLru, int maxRetained)
+        {
+            ContextHandlerByTargetDicts.UseLru = useLru;
+            ContextHandlerByTargetDicts.MaxRetained = maxRetained;
+        }
+
+        private sealed class IdleSweepRegistryBenchmarkScope : IDisposable
+        {
+            private readonly List<WeakReference<MessageBus>> _saved;
+            private readonly IdleSweepRegistryBenchmarkScope _parent;
+            private readonly int _ownerThreadId;
+            private bool _disposed;
+
+            internal IdleSweepRegistryBenchmarkScope()
+            {
+                _ownerThreadId = Environment.CurrentManagedThreadId;
+                lock (typeof(IdleSweepRegistryBenchmarkScope))
+                {
+                    if (
+                        ActiveIdleSweepRegistryBenchmarkScope != null
+                        && ActiveIdleSweepRegistryBenchmarkScope._ownerThreadId != _ownerThreadId
+                    )
+                    {
+                        throw new InvalidOperationException(
+                            "Nested idle-sweep benchmark scopes must share one owning thread."
+                        );
+                    }
+
+                    _parent = ActiveIdleSweepRegistryBenchmarkScope;
+                    _saved = IdleSweepBuses;
+                    ActiveIdleSweepRegistryBenchmarkScope = this;
+                    IdleSweepBuses = new List<WeakReference<MessageBus>>();
+                }
+            }
+
+            public void Dispose()
+            {
+                lock (typeof(IdleSweepRegistryBenchmarkScope))
+                {
+                    if (_disposed)
+                    {
+                        return;
+                    }
+                    if (Environment.CurrentManagedThreadId != _ownerThreadId)
+                    {
+                        throw new InvalidOperationException(
+                            "Idle-sweep benchmark scopes must be disposed on their owning thread."
+                        );
+                    }
+
+                    _disposed = true;
+                    while (
+                        ActiveIdleSweepRegistryBenchmarkScope != null
+                        && ActiveIdleSweepRegistryBenchmarkScope._disposed
+                    )
+                    {
+                        IdleSweepRegistryBenchmarkScope completed =
+                            ActiveIdleSweepRegistryBenchmarkScope;
+                        IdleSweepBuses = completed._saved;
+                        ActiveIdleSweepRegistryBenchmarkScope = completed._parent;
+                    }
+                }
+            }
+        }
+
+        private sealed class ContextMapPoolBenchmarkScope : IDisposable
+        {
+            private readonly CollectionPool<
+                Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
+            > _savedOverride;
+            private readonly CollectionPool<
+                Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
+            > _savedPool;
+            private readonly CollectionPool<
+                Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
+            > _isolated;
+            private readonly ContextMapPoolBenchmarkScope _parent;
+            private readonly int _ownerThreadId;
+            private readonly bool _initialUseLru;
+            private readonly int _initialMaxRetained;
+            private bool _disposed;
+
+            internal ContextMapPoolBenchmarkScope()
+            {
+                _ownerThreadId = Environment.CurrentManagedThreadId;
+                lock (typeof(ContextMapPoolBenchmarkScope))
+                {
+                    if (
+                        ActiveContextMapPoolBenchmarkScope != null
+                        && ActiveContextMapPoolBenchmarkScope._ownerThreadId != _ownerThreadId
+                    )
+                    {
+                        throw new InvalidOperationException(
+                            "Nested context-map benchmark scopes must share one owning thread."
+                        );
+                    }
+
+                    _parent = ActiveContextMapPoolBenchmarkScope;
+                    _savedOverride = ContextHandlerByTargetDictsOverride;
+                    _savedPool = ContextHandlerByTargetDicts;
+                    _initialUseLru = _savedPool.UseLru;
+                    _initialMaxRetained = _savedPool.MaxRetained;
+                    _isolated = CreateContextHandlerByTargetPool(
+                        _initialMaxRetained,
+                        _initialUseLru
+                    );
+                    ActiveContextMapPoolBenchmarkScope = this;
+                    ContextHandlerByTargetDictsOverride = _isolated;
+                }
+            }
+
+            public void Dispose()
+            {
+                lock (typeof(ContextMapPoolBenchmarkScope))
+                {
+                    if (_disposed)
+                    {
+                        return;
+                    }
+
+                    if (Environment.CurrentManagedThreadId != _ownerThreadId)
+                    {
+                        throw new InvalidOperationException(
+                            "Context-map benchmark scopes must be disposed on their owning thread."
+                        );
+                    }
+                    if (!ReferenceEquals(ActiveContextMapPoolBenchmarkScope, this))
+                    {
+                        throw new InvalidOperationException(
+                            "Context-map benchmark scopes must be disposed in strict LIFO order."
+                        );
+                    }
+
+                    bool effectiveUseLru = _isolated.UseLru;
+                    int effectiveMaxRetained = _isolated.MaxRetained;
+                    if (effectiveUseLru != _initialUseLru)
+                    {
+                        _savedPool.UseLru = effectiveUseLru;
+                    }
+                    if (effectiveMaxRetained != _initialMaxRetained)
+                    {
+                        _savedPool.MaxRetained = effectiveMaxRetained;
+                    }
+
+                    _disposed = true;
+                    _ = _isolated.Trim(0);
+                    ContextHandlerByTargetDictsOverride = _savedOverride;
+                    ActiveContextMapPoolBenchmarkScope = _parent;
+                }
+            }
+        }
+
+        internal readonly struct ContextMapPoolBenchmarkObservation
+        {
+            internal ContextMapPoolBenchmarkObservation(
+                object identity,
+                bool useLru,
+                int maxRetained
+            )
+            {
+                Identity = identity;
+                UseLru = useLru;
+                MaxRetained = maxRetained;
+            }
+
+            internal object Identity { get; }
+
+            internal bool UseLru { get; }
+
+            internal int MaxRetained { get; }
+        }
+
         private void ApplyRuntimeSettings(DxMessagingRuntimeSettings settings)
         {
             if (settings == null)
@@ -1011,7 +1403,8 @@ namespace DxMessaging.Core.MessageBus
             {
                 IMessageBus.GlobalMessageBufferSize = Math.Max(0, settings.MessageBufferSize);
             }
-            _emissionBuffer.Resize(Math.Max(0, IMessageBus.GlobalMessageBufferSize));
+            _emissionBufferCapacity = Math.Max(0, IMessageBus.GlobalMessageBufferSize);
+            _emissionBufferBacking?.Resize(_emissionBufferCapacity);
             _idleEvictionTicks = ComputeIdleEvictionTicks(settings.IdleEvictionSeconds);
             _evictionTickIntervalSeconds = Math.Max(0d, settings.EvictionTickIntervalSeconds);
             _idleEvictionEnabled = settings.EvictionEnabled;
@@ -1169,10 +1562,13 @@ namespace DxMessaging.Core.MessageBus
         private readonly List<MonoBehaviour> _componentCache = new();
 #endif
 
-        private readonly RegistrationLog _log = new();
-        internal readonly CyclicBuffer<MessageEmissionData> _emissionBuffer = new(
-            GlobalMessageBufferSize
-        );
+        private RegistrationLog _log;
+        private CyclicBuffer<MessageEmissionData> _emissionBufferBacking;
+        private int _emissionBufferCapacity = GlobalMessageBufferSize;
+        internal CyclicBuffer<MessageEmissionData> _emissionBuffer =>
+            _emissionBufferBacking ??= new CyclicBuffer<MessageEmissionData>(
+                _emissionBufferCapacity
+            );
 
         private bool _diagnosticsMode = ShouldEnableDiagnostics();
         private bool _loggedReflexiveWarning;
@@ -1696,7 +2092,7 @@ namespace DxMessaging.Core.MessageBus
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private bool HasActiveDispatchSnapshot(DispatchState state)
         {
-            return _dispatchDepth > 0 && state != null && !state.active.IsEmpty;
+            return _dispatchDepth > 0 && state != null && state.active.IsInitialized;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1966,24 +2362,105 @@ namespace DxMessaging.Core.MessageBus
             return ContextHandlerByTargetDicts.Snapshot();
         }
 
-        private Dictionary<InstanceId, HandlerCache<int, HandlerCache>> GetOrRentContextMap<T>(
-            MessageCache<Dictionary<InstanceId, HandlerCache<int, HandlerCache>>> sinks
-        )
-            where T : IMessage
+        internal int SweepDirtyTargetSlotForBenchmark<TMessage>(InstanceId target)
+            where TMessage : IMessage
         {
-            if (
-                sinks.TryGetValue<T>(
-                    out Dictionary<InstanceId, HandlerCache<int, HandlerCache>> handlersByTarget
+            int typeIndex = MessageHelperIndexer<TMessage>.SequentialId;
+            int evicted = 0;
+            for (int sinkIndex = 0; sinkIndex < _contextSinks.Length; ++sinkIndex)
+            {
+                MessageCache<Dictionary<InstanceId, HandlerCache<int, HandlerCache>>> sink =
+                    _contextSinks[sinkIndex];
+                if (
+                    sink == null
+                    || !sink.TryGetValueAtIndex(
+                        typeIndex,
+                        out Dictionary<InstanceId, HandlerCache<int, HandlerCache>> handlersByTarget
+                    )
+                    || !handlersByTarget.TryGetValue(
+                        target,
+                        out HandlerCache<int, HandlerCache> handlers
+                    )
+                    || handlers.handlers.Count != 0
+                    || HasActiveDispatchSnapshot(handlers.dispatchState)
                 )
+                {
+                    continue;
+                }
+
+                handlers.Clear();
+                _ = handlersByTarget.Remove(target);
+                evicted++;
+            }
+
+            if (
+                _dirtyTargets.TryGetValue(typeIndex, out List<InstanceId> targets)
+                && _dirtyTargetSets.TryGetValue(typeIndex, out HashSet<InstanceId> targetSet)
+                && targetSet.Remove(target)
             )
             {
-                return handlersByTarget;
+                for (int index = targets.Count - 1; index >= 0; --index)
+                {
+                    if (targets[index] != target)
+                    {
+                        continue;
+                    }
+
+                    int lastIndex = targets.Count - 1;
+                    targets[index] = targets[lastIndex];
+                    targets.RemoveAt(lastIndex);
+                    break;
+                }
             }
 
-            handlersByTarget = ContextHandlerByTargetDicts.Rent();
-            _contextMapHighWaterCounts[handlersByTarget] = handlersByTarget.Count;
-            sinks.Set<T>(handlersByTarget);
-            return handlersByTarget;
+            // Deliberately retain the empty per-type context map and dirty-candidate
+            // collections. Returning and immediately renting them would make this row measure
+            // shared pools in addition to the target map. ResetState returns them at teardown.
+            return evicted;
+        }
+
+        internal bool TryObserveTargetedHandleMapStorageForBenchmark<TMessage>(
+            out int entries,
+            out int capacity
+        )
+            where TMessage : IMessage
+        {
+            MessageCache<Dictionary<InstanceId, HandlerCache<int, HandlerCache>>> sink =
+                _contextSinks[BusContextIndex.TargetedHandleDefault];
+            if (
+                !sink.TryGetValue<TMessage>(
+                    out Dictionary<InstanceId, HandlerCache<int, HandlerCache>> handlersByTarget
+                )
+            )
+            {
+                entries = 0;
+                capacity = 0;
+                return false;
+            }
+
+            entries = handlersByTarget.Count;
+            capacity = handlersByTarget.EnsureCapacity(0);
+            return true;
+        }
+
+        private Dictionary<InstanceId, HandlerCache<int, HandlerCache>> GetOrRentContextMap<T>(
+            MessageCache<Dictionary<InstanceId, HandlerCache<int, HandlerCache>>> sinks
+        )
+            where T : IMessage
+        {
+            if (
+                sinks.TryGetValue<T>(
+                    out Dictionary<InstanceId, HandlerCache<int, HandlerCache>> handlersByTarget
+                )
+            )
+            {
+                return handlersByTarget;
+            }
+
+            handlersByTarget = ContextHandlerByTargetDicts.Rent();
+            _contextMapHighWaterCounts[handlersByTarget] = handlersByTarget.Count;
+            sinks.Set<T>(handlersByTarget);
+            return handlersByTarget;
         }
 
         private void RemoveAndReturnContextMap(
@@ -2130,7 +2607,7 @@ namespace DxMessaging.Core.MessageBus
         {
             DispatchSnapshot displaced = snapshot;
             snapshot = DispatchSnapshot.Empty;
-            if (displaced == null || displaced.IsEmpty)
+            if (displaced == null || !displaced.IsInitialized)
             {
                 return;
             }
@@ -2474,11 +2951,10 @@ namespace DxMessaging.Core.MessageBus
             _componentCache.Clear();
 #endif
 
-            bool enabled = _log.Enabled;
-            _log.Clear();
-            _log.Enabled = enabled;
-            _emissionBuffer.Resize(GlobalMessageBufferSize);
-            _emissionBuffer.Clear();
+            _log?.Clear();
+            _emissionBufferCapacity = GlobalMessageBufferSize;
+            _emissionBufferBacking?.Resize(_emissionBufferCapacity);
+            _emissionBufferBacking?.Clear();
         }
 
         private void ResetTypedSlotsForReferencedHandlers()
@@ -2562,7 +3038,10 @@ namespace DxMessaging.Core.MessageBus
         }
 
         /// <inheritdoc />
-        public Action RegisterUntargeted<T>(MessageHandler messageHandler, int priority = 0)
+        public MessageBusRegistration RegisterUntargeted<T>(
+            MessageHandler messageHandler,
+            int priority = 0
+        )
             where T : IUntargetedMessage
         {
             EnsureAotUntargetedBridge<T>();
@@ -2575,7 +3054,7 @@ namespace DxMessaging.Core.MessageBus
         }
 
         /// <inheritdoc />
-        public Action RegisterTargeted<T>(
+        public MessageBusRegistration RegisterTargeted<T>(
             InstanceId target,
             MessageHandler messageHandler,
             int priority = 0
@@ -2593,7 +3072,7 @@ namespace DxMessaging.Core.MessageBus
         }
 
         /// <inheritdoc />
-        public Action RegisterSourcedBroadcast<T>(
+        public MessageBusRegistration RegisterSourcedBroadcast<T>(
             InstanceId source,
             MessageHandler messageHandler,
             int priority = 0
@@ -2611,7 +3090,7 @@ namespace DxMessaging.Core.MessageBus
         }
 
         /// <inheritdoc />
-        public Action RegisterSourcedBroadcastWithoutSource<T>(
+        public MessageBusRegistration RegisterSourcedBroadcastWithoutSource<T>(
             MessageHandler messageHandler,
             int priority = 0
         )
@@ -2627,7 +3106,7 @@ namespace DxMessaging.Core.MessageBus
         }
 
         /// <inheritdoc />
-        public Action RegisterTargetedWithoutTargeting<T>(
+        public MessageBusRegistration RegisterTargetedWithoutTargeting<T>(
             MessageHandler messageHandler,
             int priority = 0
         )
@@ -2643,7 +3122,7 @@ namespace DxMessaging.Core.MessageBus
         }
 
         /// <inheritdoc />
-        public Action RegisterGlobalAcceptAll(MessageHandler messageHandler)
+        public MessageBusRegistration RegisterGlobalAcceptAll(MessageHandler messageHandler)
         {
             long touchTick = AdvanceTick();
             InvalidateDispatchPlans();
@@ -2661,7 +3140,7 @@ namespace DxMessaging.Core.MessageBus
             {
                 _globalSlots.liveCount++;
             }
-            _log.Log(
+            _log?.Log(
                 new MessagingRegistration(
                     messageHandler.owner,
                     type,
@@ -2689,88 +3168,107 @@ namespace DxMessaging.Core.MessageBus
 
             long capturedGeneration = _resetGeneration;
             long capturedSweepGeneration = _globalSlotSweepGeneration;
-            return () =>
+            return new MessageBusRegistration(
+                MessageBusRegistration.Kind.GlobalAcceptAll,
+                RegistrationMethod.GlobalAcceptAll,
+                0,
+                capturedGeneration,
+                capturedSweepGeneration,
+                touchTick,
+                null,
+                null,
+                messageHandler,
+                default
+            );
+        }
+
+        /// <summary>
+        /// Re-expression of the former <see cref="RegisterGlobalAcceptAll"/> closure body: the
+        /// global accept-all deregistration. Behaviour and both generation guards are unchanged.
+        /// </summary>
+        private void DeregisterGlobalAcceptAll(in MessageBusRegistration reg)
+        {
+            // Generation guard: see DeregisterScalarHandler. The global slot guards on BOTH the
+            // reset generation and the global-slot sweep generation.
+            if (
+                reg.generation != _resetGeneration
+                || reg.sweepGeneration != _globalSlotSweepGeneration
+            )
             {
-                // Generation guard: see InternalRegisterUntargeted for the
-                // rationale. Skip silently when the closure outlived a Reset.
-                if (
-                    capturedGeneration != _resetGeneration
-                    || capturedSweepGeneration != _globalSlotSweepGeneration
+                return;
+            }
+
+            MessageHandler messageHandler = (MessageHandler)reg.payload;
+            Type type = typeof(IMessage);
+
+            long deregisterTouchTick = AdvanceTick();
+            InvalidateDispatchPlans();
+            _globalSlots.version++;
+            _log?.Log(
+                new MessagingRegistration(
+                    messageHandler.owner,
+                    type,
+                    RegistrationType.Deregister,
+                    RegistrationMethod.GlobalAcceptAll
                 )
+            );
+            if (!_globalSlots.sharedHandlers.TryGetValue(messageHandler, out int count))
+            {
+                if (MessagingDebug.enabled)
                 {
-                    return;
+                    MessagingDebug.Log(
+                        LogLevel.Error,
+                        "Received over-deregistration of GlobalAcceptAll for MessageHandler {0}. Check to make sure you're not calling (de)registration multiple times.",
+                        messageHandler
+                    );
                 }
 
-                long deregisterTouchTick = AdvanceTick();
-                InvalidateDispatchPlans();
-                _globalSlots.version++;
-                _log.Log(
-                    new MessagingRegistration(
-                        messageHandler.owner,
-                        type,
-                        RegistrationType.Deregister,
-                        RegistrationMethod.GlobalAcceptAll
-                    )
-                );
-                if (!_globalSlots.sharedHandlers.TryGetValue(messageHandler, out count))
-                {
-                    if (MessagingDebug.enabled)
-                    {
-                        MessagingDebug.Log(
-                            LogLevel.Error,
-                            "Received over-deregistration of GlobalAcceptAll for MessageHandler {0}. Check to make sure you're not calling (de)registration multiple times.",
-                            messageHandler
-                        );
-                    }
-
-                    return;
-                }
+                return;
+            }
 
-                _globalSlots.lastTouchTicks = deregisterTouchTick;
-                if (count <= 1)
-                {
-                    _ = _globalSlots.sharedHandlers.Remove(messageHandler);
-                    MarkDirtyHandler(messageHandler);
-                    _globalSlotSweepCandidate = true;
-                    // Final-removal of this handler from sharedHandlers is the
-                    // 1 -> 0 transition that mirrors back into liveCount.
-                    // Partial deregistration (count > 1) leaves liveCount
-                    // alone -- the dictionary entry is still present.
-                    _globalSlots.liveCount--;
-                }
-                else
-                {
-                    _globalSlots.sharedHandlers[messageHandler] = count - 1;
-                }
+            _globalSlots.lastTouchTicks = deregisterTouchTick;
+            if (count <= 1)
+            {
+                _ = _globalSlots.sharedHandlers.Remove(messageHandler);
+                MarkDirtyHandler(messageHandler);
+                _globalSlotSweepCandidate = true;
+                // Final-removal of this handler from sharedHandlers is the 1 -> 0 transition that
+                // mirrors back into liveCount. Partial deregistration (count > 1) leaves liveCount
+                // alone -- the dictionary entry is still present.
+                _globalSlots.liveCount--;
+            }
+            else
+            {
+                _globalSlots.sharedHandlers[messageHandler] = count - 1;
+            }
 
-                StageGlobalDispatchSnapshot<IUntargetedMessage>(
-                    this,
-                    _globalSlots,
-                    DispatchKind.Untargeted
-                );
-                StageGlobalDispatchSnapshot<ITargetedMessage>(
-                    this,
-                    _globalSlots,
-                    DispatchKind.Targeted
-                );
-                StageGlobalDispatchSnapshot<IBroadcastMessage>(
-                    this,
-                    _globalSlots,
-                    DispatchKind.Broadcast
-                );
-                DebugAssertGlobalLiveCount();
-            };
+            StageGlobalDispatchSnapshot<IUntargetedMessage>(
+                this,
+                _globalSlots,
+                DispatchKind.Untargeted
+            );
+            StageGlobalDispatchSnapshot<ITargetedMessage>(
+                this,
+                _globalSlots,
+                DispatchKind.Targeted
+            );
+            StageGlobalDispatchSnapshot<IBroadcastMessage>(
+                this,
+                _globalSlots,
+                DispatchKind.Broadcast
+            );
+            DebugAssertGlobalLiveCount();
         }
 
         /// <inheritdoc />
-        public Action RegisterUntargetedInterceptor<T>(
+        public MessageBusRegistration RegisterUntargetedInterceptor<T>(
             UntargetedInterceptor<T> interceptor,
             int priority = 0
         )
             where T : IUntargetedMessage
         {
             EnsureAotUntargetedBridge<T>();
-            _ = AdvanceTick();
+            long touchTick = AdvanceTick();
             InvalidateDispatchPlans();
             InterceptorCache<object> prioritizedInterceptors =
                 _untargetedInterceptsByType.GetOrAdd<T>();
@@ -2809,7 +3307,7 @@ namespace DxMessaging.Core.MessageBus
             priorityCount[priority] = count + 1;
 
             Type type = typeof(T);
-            _log.Log(
+            _log?.Log(
                 new MessagingRegistration(
                     InstanceId.EmptyId,
                     type,
@@ -2819,107 +3317,29 @@ namespace DxMessaging.Core.MessageBus
             );
 
             long capturedGeneration = _resetGeneration;
-            return () =>
-            {
-                // Generation guard: see InternalRegisterUntargeted for the
-                // rationale. Skip silently when the closure outlived a Reset.
-                if (capturedGeneration != _resetGeneration)
-                {
-                    return;
-                }
-                if (
-                    IsStaleInterceptorDeregisterAfterSweep<T>(
-                        _untargetedInterceptsByType,
-                        capturedInterceptors
-                    )
-                )
-                {
-                    return;
-                }
-
-                _ = AdvanceTick();
-                InvalidateDispatchPlans();
-                prioritizedInterceptors.lastTouchTicks = _tickCounter;
-                MarkDirtyType<T>();
-                _log.Log(
-                    new MessagingRegistration(
-                        InstanceId.EmptyId,
-                        type,
-                        RegistrationType.Deregister,
-                        RegistrationMethod.Interceptor
-                    )
-                );
-                bool removed = false;
-                if (_uniqueInterceptorsAndPriorities.TryGetValue(interceptor, out priorityCount))
-                {
-                    if (priorityCount.TryGetValue(priority, out count))
-                    {
-                        if (1 < count)
-                        {
-                            priorityCount[priority] = count - 1;
-                        }
-                        else
-                        {
-                            removed = true;
-                            _ = priorityCount.Remove(priority);
-                        }
-                    }
-
-                    if (priorityCount.Count == 0)
-                    {
-                        _uniqueInterceptorsAndPriorities.Remove(interceptor);
-                    }
-                }
-                else if (MessagingDebug.enabled)
-                {
-                    MessagingDebug.Log(
-                        LogLevel.Error,
-                        "Received over-deregistration of Interceptor {0}. Check to make sure you're not calling (de)registration multiple times.",
-                        interceptor
-                    );
-                }
-
-                bool complete = false;
-                if (removed)
-                {
-                    if (_untargetedInterceptsByType.TryGetValue<T>(out prioritizedInterceptors))
-                    {
-                        if (
-                            prioritizedInterceptors.handlers.TryGetValue(
-                                priority,
-                                out List<object> interceptors
-                            )
-                        )
-                        {
-                            complete = interceptors.Remove(interceptor);
-                            if (interceptors.Count == 0)
-                            {
-                                _ = prioritizedInterceptors.handlers.Remove(priority);
-                            }
-                        }
-                    }
-
-                    if (!complete && MessagingDebug.enabled)
-                    {
-                        MessagingDebug.Log(
-                            LogLevel.Error,
-                            "Received over-deregistration of Interceptor {0}. Check to make sure you're not calling (de)registration multiple times.",
-                            interceptor
-                        );
-                    }
-                }
-            };
+            return new MessageBusRegistration(
+                MessageBusRegistration.Kind.UntargetedInterceptor,
+                RegistrationMethod.Interceptor,
+                priority,
+                capturedGeneration,
+                0L,
+                touchTick,
+                capturedInterceptors,
+                null,
+                interceptor,
+                default
+            );
         }
 
         /// <inheritdoc />
-        public Action RegisterTargetedInterceptor<T>(
+        public MessageBusRegistration RegisterTargetedInterceptor<T>(
             TargetedInterceptor<T> interceptor,
             int priority = 0
         )
             where T : ITargetedMessage
         {
             EnsureAotTargetedBridge<T>();
-            _ = AdvanceTick();
+            long touchTick = AdvanceTick();
             InvalidateDispatchPlans();
             InterceptorCache<object> prioritizedInterceptors =
                 _targetedInterceptsByType.GetOrAdd<T>();
@@ -2958,7 +3378,7 @@ namespace DxMessaging.Core.MessageBus
             priorityCount[priority] = count + 1;
 
             Type type = typeof(T);
-            _log.Log(
+            _log?.Log(
                 new MessagingRegistration(
                     InstanceId.EmptyId,
                     type,
@@ -2968,107 +3388,29 @@ namespace DxMessaging.Core.MessageBus
             );
 
             long capturedGeneration = _resetGeneration;
-            return () =>
-            {
-                // Generation guard: see InternalRegisterUntargeted for the
-                // rationale. Skip silently when the closure outlived a Reset.
-                if (capturedGeneration != _resetGeneration)
-                {
-                    return;
-                }
-                if (
-                    IsStaleInterceptorDeregisterAfterSweep<T>(
-                        _targetedInterceptsByType,
-                        capturedInterceptors
-                    )
-                )
-                {
-                    return;
-                }
-
-                _ = AdvanceTick();
-                InvalidateDispatchPlans();
-                prioritizedInterceptors.lastTouchTicks = _tickCounter;
-                MarkDirtyType<T>();
-                _log.Log(
-                    new MessagingRegistration(
-                        InstanceId.EmptyId,
-                        type,
-                        RegistrationType.Deregister,
-                        RegistrationMethod.Interceptor
-                    )
-                );
-                bool removed = false;
-                if (_uniqueInterceptorsAndPriorities.TryGetValue(interceptor, out priorityCount))
-                {
-                    if (priorityCount.TryGetValue(priority, out count))
-                    {
-                        if (1 < count)
-                        {
-                            priorityCount[priority] = count - 1;
-                        }
-                        else
-                        {
-                            removed = true;
-                            _ = priorityCount.Remove(priority);
-                        }
-                    }
-
-                    if (priorityCount.Count == 0)
-                    {
-                        _uniqueInterceptorsAndPriorities.Remove(interceptor);
-                    }
-                }
-                else if (MessagingDebug.enabled)
-                {
-                    MessagingDebug.Log(
-                        LogLevel.Error,
-                        "Received over-deregistration of Interceptor {0}. Check to make sure you're not calling (de)registration multiple times.",
-                        interceptor
-                    );
-                }
-
-                bool complete = false;
-                if (removed)
-                {
-                    if (_targetedInterceptsByType.TryGetValue<T>(out prioritizedInterceptors))
-                    {
-                        if (
-                            prioritizedInterceptors.handlers.TryGetValue(
-                                priority,
-                                out List<object> interceptors
-                            )
-                        )
-                        {
-                            complete = interceptors.Remove(interceptor);
-                            if (interceptors.Count == 0)
-                            {
-                                _ = prioritizedInterceptors.handlers.Remove(priority);
-                            }
-                        }
-                    }
-
-                    if (!complete && MessagingDebug.enabled)
-                    {
-                        MessagingDebug.Log(
-                            LogLevel.Error,
-                            "Received over-deregistration of Interceptor {0}. Check to make sure you're not calling (de)registration multiple times.",
-                            interceptor
-                        );
-                    }
-                }
-            };
+            return new MessageBusRegistration(
+                MessageBusRegistration.Kind.TargetedInterceptor,
+                RegistrationMethod.Interceptor,
+                priority,
+                capturedGeneration,
+                0L,
+                touchTick,
+                capturedInterceptors,
+                null,
+                interceptor,
+                default
+            );
         }
 
         /// <inheritdoc />
-        public Action RegisterBroadcastInterceptor<T>(
+        public MessageBusRegistration RegisterBroadcastInterceptor<T>(
             BroadcastInterceptor<T> interceptor,
             int priority = 0
         )
             where T : IBroadcastMessage
         {
             EnsureAotSourcedBridge<T>();
-            _ = AdvanceTick();
+            long touchTick = AdvanceTick();
             InvalidateDispatchPlans();
             InterceptorCache<object> prioritizedInterceptors =
                 _broadcastInterceptsByType.GetOrAdd<T>();
@@ -3107,7 +3449,7 @@ namespace DxMessaging.Core.MessageBus
             priorityCount[priority] = count + 1;
 
             Type type = typeof(T);
-            _log.Log(
+            _log?.Log(
                 new MessagingRegistration(
                     InstanceId.EmptyId,
                     type,
@@ -3117,96 +3459,18 @@ namespace DxMessaging.Core.MessageBus
             );
 
             long capturedGeneration = _resetGeneration;
-            return () =>
-            {
-                // Generation guard: see InternalRegisterUntargeted for the
-                // rationale. Skip silently when the closure outlived a Reset.
-                if (capturedGeneration != _resetGeneration)
-                {
-                    return;
-                }
-                if (
-                    IsStaleInterceptorDeregisterAfterSweep<T>(
-                        _broadcastInterceptsByType,
-                        capturedInterceptors
-                    )
-                )
-                {
-                    return;
-                }
-
-                _ = AdvanceTick();
-                InvalidateDispatchPlans();
-                prioritizedInterceptors.lastTouchTicks = _tickCounter;
-                MarkDirtyType<T>();
-                _log.Log(
-                    new MessagingRegistration(
-                        InstanceId.EmptyId,
-                        type,
-                        RegistrationType.Deregister,
-                        RegistrationMethod.Interceptor
-                    )
-                );
-                bool removed = false;
-                if (_uniqueInterceptorsAndPriorities.TryGetValue(interceptor, out priorityCount))
-                {
-                    if (priorityCount.TryGetValue(priority, out count))
-                    {
-                        if (1 < count)
-                        {
-                            priorityCount[priority] = count - 1;
-                        }
-                        else
-                        {
-                            removed = true;
-                            _ = priorityCount.Remove(priority);
-                        }
-                    }
-
-                    if (priorityCount.Count == 0)
-                    {
-                        _uniqueInterceptorsAndPriorities.Remove(interceptor);
-                    }
-                }
-                else if (MessagingDebug.enabled)
-                {
-                    MessagingDebug.Log(
-                        LogLevel.Error,
-                        "Received over-deregistration of Interceptor {0}. Check to make sure you're not calling (de)registration multiple times.",
-                        interceptor
-                    );
-                }
-
-                bool complete = false;
-                if (removed)
-                {
-                    if (_broadcastInterceptsByType.TryGetValue<T>(out prioritizedInterceptors))
-                    {
-                        if (
-                            prioritizedInterceptors.handlers.TryGetValue(
-                                priority,
-                                out List<object> interceptors
-                            )
-                        )
-                        {
-                            complete = interceptors.Remove(interceptor);
-                            if (interceptors.Count == 0)
-                            {
-                                _ = prioritizedInterceptors.handlers.Remove(priority);
-                            }
-                        }
-                    }
-
-                    if (!complete && MessagingDebug.enabled)
-                    {
-                        MessagingDebug.Log(
-                            LogLevel.Error,
-                            "Received over-deregistration of Interceptor {0}. Check to make sure you're not calling (de)registration multiple times.",
-                            interceptor
-                        );
-                    }
-                }
-            };
+            return new MessageBusRegistration(
+                MessageBusRegistration.Kind.BroadcastInterceptor,
+                RegistrationMethod.Interceptor,
+                priority,
+                capturedGeneration,
+                0L,
+                touchTick,
+                capturedInterceptors,
+                null,
+                interceptor,
+                default
+            );
         }
 
         private bool IsStaleInterceptorDeregisterAfterSweep<T>(
@@ -3221,7 +3485,7 @@ namespace DxMessaging.Core.MessageBus
         }
 
         /// <inheritdoc />
-        public Action RegisterUntargetedPostProcessor<T>(
+        public MessageBusRegistration RegisterUntargetedPostProcessor<T>(
             MessageHandler messageHandler,
             int priority = 0
         )
@@ -3237,7 +3501,7 @@ namespace DxMessaging.Core.MessageBus
         }
 
         /// <inheritdoc />
-        public Action RegisterTargetedPostProcessor<T>(
+        public MessageBusRegistration RegisterTargetedPostProcessor<T>(
             InstanceId target,
             MessageHandler messageHandler,
             int priority = 0
@@ -3255,7 +3519,7 @@ namespace DxMessaging.Core.MessageBus
         }
 
         /// <inheritdoc />
-        public Action RegisterTargetedWithoutTargetingPostProcessor<T>(
+        public MessageBusRegistration RegisterTargetedWithoutTargetingPostProcessor<T>(
             MessageHandler messageHandler,
             int priority = 0
         )
@@ -3271,7 +3535,7 @@ namespace DxMessaging.Core.MessageBus
         }
 
         /// <inheritdoc />
-        public Action RegisterBroadcastPostProcessor<T>(
+        public MessageBusRegistration RegisterBroadcastPostProcessor<T>(
             InstanceId source,
             MessageHandler messageHandler,
             int priority = 0
@@ -3289,7 +3553,7 @@ namespace DxMessaging.Core.MessageBus
         }
 
         /// <inheritdoc />
-        public Action RegisterBroadcastWithoutSourcePostProcessor<T>(
+        public MessageBusRegistration RegisterBroadcastWithoutSourcePostProcessor<T>(
             MessageHandler messageHandler,
             int priority = 0
         )
@@ -3382,7 +3646,7 @@ namespace DxMessaging.Core.MessageBus
             long touchTick = AdvanceTick();
             if (_diagnosticsMode)
             {
-                _emissionBuffer.Add(new MessageEmissionData(typedMessage));
+                _emissionBuffer.Add(new MessageEmissionData(typedMessage, emissionId));
             }
 
             if (plan.fastPath)
@@ -3517,7 +3781,7 @@ namespace DxMessaging.Core.MessageBus
             }
 
             Touch(sortedHandlers, touchTick);
-            DispatchSnapshot snapshot = prefrozenSnapshot.IsEmpty
+            DispatchSnapshot snapshot = !prefrozenSnapshot.IsInitialized
                 ? AcquireDispatchSnapshotFast<TMessage>(
                     this,
                     sortedHandlers,
@@ -3624,7 +3888,7 @@ namespace DxMessaging.Core.MessageBus
             long touchTick = AdvanceTick();
             if (_diagnosticsMode)
             {
-                _emissionBuffer.Add(new MessageEmissionData(typedMessage, target));
+                _emissionBuffer.Add(new MessageEmissionData(typedMessage, target, emissionId));
             }
 
             // Fast lane: no interceptors, no global accept-all, no
@@ -4105,7 +4369,7 @@ namespace DxMessaging.Core.MessageBus
                         target
                     );
                 }
-                else if (targetedPostSnapshot.IsEmpty)
+                else if (!targetedPostSnapshot.IsInitialized)
                 {
                     snapshot = AcquireDispatchSnapshotFast<TMessage>(
                         this,
@@ -4131,7 +4395,7 @@ namespace DxMessaging.Core.MessageBus
                 && postTwt.handlers.Count > 0
             )
             {
-                DispatchSnapshot snapshot = targetedWithoutTargetingPostSnapshot.IsEmpty
+                DispatchSnapshot snapshot = !targetedWithoutTargetingPostSnapshot.IsInitialized
                     ? AcquireDispatchSnapshotFast<TMessage>(
                         this,
                         postTwt,
@@ -4253,7 +4517,7 @@ namespace DxMessaging.Core.MessageBus
             long touchTick = AdvanceTick();
             if (_diagnosticsMode)
             {
-                _emissionBuffer.Add(new MessageEmissionData(typedMessage, source));
+                _emissionBuffer.Add(new MessageEmissionData(typedMessage, source, emissionId));
             }
 
             // Fast lane: no interceptors, no global accept-all, no
@@ -4510,15 +4774,15 @@ namespace DxMessaging.Core.MessageBus
                 }
             }
 
-            if (!broadcastPostSnapshot.IsEmpty)
+            if (broadcastPostSnapshot.IsInitialized)
             {
-                // Legacy reporting: a non-empty pre-frozen snapshot counts as
-                // "found" even if every frozen delegate is skipped below.
+                // Legacy reporting: an initialized pre-frozen snapshot counts as
+                // "found" even when it owns zero resolved delegates.
                 foundAnyHandlers = true;
                 _ = DispatchFlatSnapshot(broadcastPostSnapshot, ref typedMessage);
             }
 
-            if (!broadcastWithoutSourcePostSnapshot.IsEmpty)
+            if (broadcastWithoutSourcePostSnapshot.IsInitialized)
             {
                 if (
                     DispatchContextFlatSnapshot(
@@ -5107,7 +5371,7 @@ namespace DxMessaging.Core.MessageBus
             // Empty), acquire lazily here: the legacy path took its first
             // freeze at this point in that case, so a registration made
             // earlier in this emission into a previously-empty sink fires.
-            DispatchSnapshot snapshot = prefrozenSnapshot.IsEmpty
+            DispatchSnapshot snapshot = !prefrozenSnapshot.IsInitialized
                 ? AcquireDispatchSnapshotFast<TMessage>(
                     this,
                     sortedHandlers,
@@ -5122,7 +5386,7 @@ namespace DxMessaging.Core.MessageBus
             return true;
         }
 
-        private Action InternalRegisterUntargeted<T>(
+        private MessageBusRegistration InternalRegisterUntargeted<T>(
             MessageHandler messageHandler,
             MessageCache<HandlerCache<int, HandlerCache>> sinks,
             RegistrationMethod registrationMethod,
@@ -5172,7 +5436,7 @@ namespace DxMessaging.Core.MessageBus
             }
             StageDispatchSnapshot<T>(this, capturedHandlers, slotKey);
             Type type = typeof(T);
-            _log.Log(
+            _log?.Log(
                 new MessagingRegistration(
                     handlerOwnerId,
                     type,
@@ -5182,49 +5446,66 @@ namespace DxMessaging.Core.MessageBus
             );
 
             long capturedGeneration = _resetGeneration;
-            return () =>
-            {
-                // Generation guard: if ResetState() ran after this closure was
-                // captured (e.g. a deferred Object.Destroy fires after a
-                // domain-reload-style reset), silently no-op rather than
-                // logging a misleading over-deregistration error.
-                if (capturedGeneration != _resetGeneration)
-                {
-                    return;
-                }
+            return new MessageBusRegistration(
+                MessageBusRegistration.Kind.Handler,
+                registrationMethod,
+                priority,
+                capturedGeneration,
+                0L,
+                touchTick,
+                capturedHandlers,
+                null,
+                messageHandler,
+                default
+            );
+        }
 
-                long deregisterTouchTick = AdvanceTick();
-                InvalidateDispatchPlans();
-                cache.version++;
-                if (
-                    !sinks.TryGetValue<T>(out handlers)
-                    || !ReferenceEquals(handlers, capturedHandlers)
-                    || !handlers.handlers.TryGetValue(priority, out cache)
-                    || !cache.handlers.TryGetValue(messageHandler, out count)
-                )
-                {
-                    if (
-                        capturedHandlers.handlers.Count == 0
-                        && !ReferenceEquals(handlers, capturedHandlers)
-                    )
-                    {
-                        return;
-                    }
+        /// <summary>
+        /// Re-expression of the former <see cref="InternalRegisterUntargeted{T}"/> closure body:
+        /// the scalar (untargeted / without-context) handler deregistration. Behaviour and the
+        /// four reentrancy invariants are unchanged; the closure's captured locals are read from
+        /// <paramref name="reg"/>'s fields instead, and the sink is re-resolved from the method.
+        /// </summary>
+        private void DeregisterScalarHandler<T>(in MessageBusRegistration reg)
+            where T : IMessage
+        {
+            // Generation guard: if ResetState() ran after this handle was captured (e.g. a
+            // deferred Object.Destroy fires after a domain-reload-style reset), silently no-op
+            // rather than logging a misleading over-deregistration error.
+            if (reg.generation != _resetGeneration)
+            {
+                return;
+            }
 
-                    if (MessagingDebug.enabled)
-                    {
-                        MessagingDebug.Log(
-                            LogLevel.Error,
-                            "Received over-deregistration of {0} for {1}. Check to make sure you're not calling (de)registration multiple times.",
-                            type,
-                            messageHandler
-                        );
-                    }
+            MessageHandler messageHandler = (MessageHandler)reg.payload;
+            HandlerCache<int, HandlerCache> capturedHandlers =
+                (HandlerCache<int, HandlerCache>)reg.capturedPrimary;
+            int priority = reg.priority;
+            RegistrationMethod registrationMethod = reg.method;
+            SlotKey slotKey = RegistrationMethodAxes.GetSlotKey(registrationMethod);
+            Type type = typeof(T);
+            InstanceId handlerOwnerId = messageHandler.owner;
 
-                    return;
-                }
+            long deregisterTouchTick = AdvanceTick();
+            InvalidateDispatchPlans();
 
-                _log.Log(
+            // FAST PATH: operate on the captured leaf handler-cache (already pinned on the
+            // handle at registration time) DIRECTLY, without re-resolving the sink from the
+            // method (ScalarSinkForMethod) or re-walking sinks->type->priority->handler. When
+            // the generation guard above has passed and the captured bucket still holds this
+            // handler, the captured leaf IS the live sink entry (handles are unique and never
+            // reused), so the re-resolution + ReferenceEquals identity check is redundant. The
+            // sweep-staleness / over-deregistration classification only matters when the handler
+            // is NOT found, so it is deferred to the cold fallback below. This removes the
+            // per-deregistration sink re-resolution (the measured cold-path regression source)
+            // while preserving every guard and the throw-safe ordering (this method performs no
+            // user callback; the throwing IMessageBus.Deregister boundary is the caller's).
+            if (
+                capturedHandlers.handlers.TryGetValue(priority, out HandlerCache cache)
+                && cache.handlers.TryGetValue(messageHandler, out int count)
+            )
+            {
+                _log?.Log(
                     new MessagingRegistration(
                         handlerOwnerId,
                         type,
@@ -5232,30 +5513,27 @@ namespace DxMessaging.Core.MessageBus
                         registrationMethod
                     )
                 );
-                Touch(handlers, deregisterTouchTick);
-                handlers.version++;
-                handler = cache.handlers;
+                Touch(capturedHandlers, deregisterTouchTick);
+                capturedHandlers.version++;
+                cache.version++;
+                Dictionary<MessageHandler, int> handler = cache.handlers;
                 if (count <= 1)
                 {
-                    bool complete = handler.Remove(messageHandler);
-                    // List.Remove is O(n) over the same-priority bucket.
-                    // Accepted tradeoff (here and at the context-path sibling
-                    // site): buckets are small in practice, removal is a cold
-                    // churn path, and the list keeps dispatch-order rebuilds
-                    // allocation-free while preserving first-registration
-                    // order, unlike Dictionary enumeration whose freed slots
-                    // are reused LIFO. Mirrors the MessageHandler-side
+                    _ = handler.Remove(messageHandler);
+                    // List.Remove is O(n) over the same-priority bucket. Accepted tradeoff (here
+                    // and at the context-path sibling site): buckets are small in practice,
+                    // removal is a cold churn path, and the list keeps dispatch-order rebuilds
+                    // allocation-free while preserving first-registration order, unlike Dictionary
+                    // enumeration whose freed slots are reused LIFO. Mirrors the MessageHandler-side
                     // insertionOrder tradeoff.
                     _ = cache.insertionOrder.Remove(messageHandler);
                     MarkDirtyHandler(messageHandler);
-                    cache.version++;
-                    // do not mutate cache.cache here; let next read rebuild from handlers
 
                     if (handler.Count == 0)
                     {
-                        _ = handlers.handlers.Remove(priority);
+                        _ = capturedHandlers.handlers.Remove(priority);
                         // remove priority from order
-                        List<int> order = handlers.order;
+                        List<int> order = capturedHandlers.order;
                         int removeIdx = order.IndexOf(priority);
                         if (removeIdx >= 0)
                         {
@@ -5263,30 +5541,51 @@ namespace DxMessaging.Core.MessageBus
                         }
                     }
 
-                    if (handlers.handlers.Count == 0)
+                    if (capturedHandlers.handlers.Count == 0)
                     {
                         MarkDirtyType<T>();
                     }
-
-                    if (!complete && MessagingDebug.enabled)
-                    {
-                        MessagingDebug.Log(
-                            LogLevel.Error,
-                            "Received over-deregistration of {0} for {1}. Check to make sure you're not calling (de)registration multiple times.",
-                            type,
-                            messageHandler
-                        );
-                    }
                 }
                 else
                 {
                     handler[messageHandler] = count - 1;
                 }
-                StageDispatchSnapshot<T>(this, handlers, slotKey);
-            };
+                StageDispatchSnapshot<T>(this, capturedHandlers, slotKey);
+                return;
+            }
+
+            // COLD FALLBACK: the handler was not found in the captured bucket, so this is a no-op
+            // deregistration (post-sweep, or a genuine over-deregistration) -- nothing is removed,
+            // so NO version bump / snapshot invalidation is performed. Bumping here would
+            // spuriously rebuild whichever bucket currently occupies this priority, which after a
+            // full deregister + re-registration at the same priority is the NEW live bucket (the
+            // stale handle must not touch it). Re-resolve the live sink only to CLASSIFY this as a
+            // silent stale-after-sweep no-op versus a genuine over-deregistration. Rare path; not
+            // on the steady deregistration cost.
+            MessageCache<HandlerCache<int, HandlerCache>> sinks = ScalarSinkForMethod(
+                registrationMethod
+            );
+            _ = sinks.TryGetValue<T>(out HandlerCache<int, HandlerCache> handlers);
+            if (
+                capturedHandlers.handlers.Count == 0
+                && !ReferenceEquals(handlers, capturedHandlers)
+            )
+            {
+                return;
+            }
+
+            if (MessagingDebug.enabled)
+            {
+                MessagingDebug.Log(
+                    LogLevel.Error,
+                    "Received over-deregistration of {0} for {1}. Check to make sure you're not calling (de)registration multiple times.",
+                    type,
+                    messageHandler
+                );
+            }
         }
 
-        private Action InternalRegisterWithContext<T>(
+        private MessageBusRegistration InternalRegisterWithContext<T>(
             InstanceId context,
             MessageHandler messageHandler,
             MessageCache<Dictionary<InstanceId, HandlerCache<int, HandlerCache>>> sinks,
@@ -5351,7 +5650,7 @@ namespace DxMessaging.Core.MessageBus
             }
 
             Type type = typeof(T);
-            _log.Log(
+            _log?.Log(
                 new MessagingRegistration(
                     context,
                     type,
@@ -5362,46 +5661,60 @@ namespace DxMessaging.Core.MessageBus
             StageDispatchSnapshot<T>(this, handlers, slotKey);
 
             long capturedGeneration = _resetGeneration;
-            return () =>
-            {
-                // Generation guard: see InternalRegisterUntargeted for the
-                // rationale. Skip silently when the closure outlived a Reset.
-                if (capturedGeneration != _resetGeneration)
-                {
-                    return;
-                }
+            return new MessageBusRegistration(
+                MessageBusRegistration.Kind.Handler,
+                registrationMethod,
+                priority,
+                capturedGeneration,
+                0L,
+                touchTick,
+                capturedHandlers,
+                capturedBroadcastHandlers,
+                messageHandler,
+                context
+            );
+        }
 
-                long deregisterTouchTick = AdvanceTick();
-                InvalidateDispatchPlans();
-                cache.version++;
-                if (
-                    !sinks.TryGetValue<T>(out broadcastHandlers)
-                    || !ReferenceEquals(broadcastHandlers, capturedBroadcastHandlers)
-                    || !broadcastHandlers.TryGetValue(context, out handlers)
-                    || !ReferenceEquals(handlers, capturedHandlers)
-                    || !handlers.handlers.TryGetValue(priority, out cache)
-                    || !cache.handlers.TryGetValue(messageHandler, out count)
-                )
-                {
-                    if (IsStaleContextDeregisterAfterSweep<T>(sinks, context, capturedHandlers))
-                    {
-                        return;
-                    }
+        /// <summary>
+        /// Re-expression of the former <see cref="InternalRegisterWithContext{T}"/> closure body:
+        /// the keyed (targeted / sourced-broadcast) handler deregistration. Behaviour and the four
+        /// reentrancy invariants are unchanged; the closure's captured locals are read from
+        /// <paramref name="reg"/>'s fields, and the sink is re-resolved from the method.
+        /// </summary>
+        private void DeregisterContextHandler<T>(in MessageBusRegistration reg)
+            where T : IMessage
+        {
+            // Generation guard: see DeregisterScalarHandler for the rationale. Skip silently when
+            // the handle outlived a Reset.
+            if (reg.generation != _resetGeneration)
+            {
+                return;
+            }
 
-                    if (MessagingDebug.enabled)
-                    {
-                        MessagingDebug.Log(
-                            LogLevel.Error,
-                            "Received over-deregistration of {0} for {1}. Check to make sure you're not calling (de)registration multiple times.",
-                            type,
-                            messageHandler
-                        );
-                    }
+            MessageHandler messageHandler = (MessageHandler)reg.payload;
+            HandlerCache<int, HandlerCache> capturedHandlers =
+                (HandlerCache<int, HandlerCache>)reg.capturedPrimary;
+            InstanceId context = reg.context;
+            int priority = reg.priority;
+            RegistrationMethod registrationMethod = reg.method;
+            SlotKey slotKey = RegistrationMethodAxes.GetSlotKey(registrationMethod);
+            Type type = typeof(T);
 
-                    return;
-                }
+            long deregisterTouchTick = AdvanceTick();
+            InvalidateDispatchPlans();
 
-                _log.Log(
+            // FAST PATH: operate on the captured per-context leaf handler-cache directly, without
+            // re-resolving the sink (ContextSinkForMethod) or re-walking sinks->type->context->
+            // priority->handler. See DeregisterScalarHandler for the full rationale and the
+            // sweep-staleness argument (the context sweep, like the scalar sweep, only evicts
+            // EMPTY caches, so a found handler is never in a swept/detached cache). Throw-safe:
+            // no user callback runs here.
+            if (
+                capturedHandlers.handlers.TryGetValue(priority, out HandlerCache cache)
+                && cache.handlers.TryGetValue(messageHandler, out int count)
+            )
+            {
+                _log?.Log(
                     new MessagingRegistration(
                         context,
                         type,
@@ -5409,23 +5722,22 @@ namespace DxMessaging.Core.MessageBus
                         registrationMethod
                     )
                 );
-                Touch(handlers, deregisterTouchTick);
-                handler = cache.handlers;
+                Touch(capturedHandlers, deregisterTouchTick);
+                cache.version++;
+                Dictionary<MessageHandler, int> handler = cache.handlers;
                 if (count <= 1)
                 {
-                    bool complete = handler.Remove(messageHandler);
-                    // O(n) List.Remove: see the tradeoff comment at the
-                    // scalar-path sibling site in InternalRegisterUntargeted.
+                    _ = handler.Remove(messageHandler);
+                    // O(n) List.Remove: see the tradeoff comment at the scalar-path sibling site in
+                    // DeregisterScalarHandler.
                     _ = cache.insertionOrder.Remove(messageHandler);
                     MarkDirtyHandler(messageHandler);
-                    cache.version++;
-                    // do not mutate cache.cache here; let next read rebuild from handlers
                     if (handler.Count == 0)
                     {
-                        handlers.version++;
-                        _ = handlers.handlers.Remove(priority);
+                        capturedHandlers.version++;
+                        _ = capturedHandlers.handlers.Remove(priority);
                         // remove priority from order
-                        List<int> order = handlers.order;
+                        List<int> order = capturedHandlers.order;
                         int removeIdx = order.IndexOf(priority);
                         if (removeIdx >= 0)
                         {
@@ -5433,29 +5745,265 @@ namespace DxMessaging.Core.MessageBus
                         }
                     }
 
-                    if (handlers.handlers.Count == 0)
+                    if (capturedHandlers.handlers.Count == 0)
                     {
                         MarkDirtyTarget<T>(context);
                     }
-
-                    if (!complete && MessagingDebug.enabled)
-                    {
-                        MessagingDebug.Log(
-                            LogLevel.Error,
-                            "Received over-deregistration of {0} for {1}. Check to make sure you're not calling (de)registration multiple times.",
-                            type,
-                            messageHandler
-                        );
-                    }
                 }
                 else
                 {
                     handler[messageHandler] = count - 1;
                 }
-                StageDispatchSnapshot<T>(this, handlers, slotKey);
+                StageDispatchSnapshot<T>(this, capturedHandlers, slotKey);
+                return;
+            }
+
+            // COLD FALLBACK: handler not found in the captured bucket -> a no-op deregistration
+            // (nothing removed), so NO version bump is performed (it would spuriously rebuild the
+            // bucket currently at this priority -- the NEW live bucket after a full deregister +
+            // re-registration). Re-resolve only to CLASSIFY stale-after-sweep (silent) versus
+            // over-deregistration (error). Rare path; not on the steady deregistration cost.
+            MessageCache<Dictionary<InstanceId, HandlerCache<int, HandlerCache>>> sinks =
+                ContextSinkForMethod(registrationMethod);
+            if (IsStaleContextDeregisterAfterSweep<T>(sinks, context, capturedHandlers))
+            {
+                return;
+            }
+
+            if (MessagingDebug.enabled)
+            {
+                MessagingDebug.Log(
+                    LogLevel.Error,
+                    "Received over-deregistration of {0} for {1}. Check to make sure you're not calling (de)registration multiple times.",
+                    type,
+                    messageHandler
+                );
+            }
+        }
+
+        /// <inheritdoc />
+        public void Deregister<T>(in MessageBusRegistration registration)
+            where T : IMessage
+        {
+            switch (registration.kind)
+            {
+                case MessageBusRegistration.Kind.Handler:
+                    if (IsContextMethod(registration.method))
+                    {
+                        DeregisterContextHandler<T>(in registration);
+                    }
+                    else
+                    {
+                        DeregisterScalarHandler<T>(in registration);
+                    }
+                    break;
+                case MessageBusRegistration.Kind.UntargetedInterceptor:
+                case MessageBusRegistration.Kind.TargetedInterceptor:
+                case MessageBusRegistration.Kind.BroadcastInterceptor:
+                    DeregisterInterceptor<T>(in registration);
+                    break;
+                case MessageBusRegistration.Kind.GlobalAcceptAll:
+                    DeregisterGlobalAcceptAll(in registration);
+                    break;
+                default:
+                    // Kind.None is the empty/sentinel handle (no-op); Kind.External handles are
+                    // minted by a foreign IMessageBus implementation and own no store here.
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Re-expression of the former interceptor closure body. The interceptor store is selected
+        /// by <see cref="MessageBusRegistration.kind"/> (all three interceptor registrars log the
+        /// single <see cref="RegistrationMethod.Interceptor"/>, so the method cannot discriminate).
+        /// </summary>
+        private void DeregisterInterceptor<T>(in MessageBusRegistration reg)
+            where T : IMessage
+        {
+            // Generation guard: see DeregisterScalarHandler.
+            if (reg.generation != _resetGeneration)
+            {
+                return;
+            }
+
+            MessageCache<InterceptorCache<object>> interceptsByType = reg.kind switch
+            {
+                MessageBusRegistration.Kind.UntargetedInterceptor => _untargetedInterceptsByType,
+                MessageBusRegistration.Kind.TargetedInterceptor => _targetedInterceptsByType,
+                MessageBusRegistration.Kind.BroadcastInterceptor => _broadcastInterceptsByType,
+                _ => null,
             };
+            if (interceptsByType == null)
+            {
+                return;
+            }
+
+            InterceptorCache<object> capturedInterceptors =
+                (InterceptorCache<object>)reg.capturedPrimary;
+            object interceptor = reg.payload;
+            int priority = reg.priority;
+
+            if (IsStaleInterceptorDeregisterAfterSweep<T>(interceptsByType, capturedInterceptors))
+            {
+                return;
+            }
+
+            _ = AdvanceTick();
+            InvalidateDispatchPlans();
+            capturedInterceptors.lastTouchTicks = _tickCounter;
+            MarkDirtyType<T>();
+            _log?.Log(
+                new MessagingRegistration(
+                    InstanceId.EmptyId,
+                    typeof(T),
+                    RegistrationType.Deregister,
+                    RegistrationMethod.Interceptor
+                )
+            );
+            bool removed = false;
+            if (
+                _uniqueInterceptorsAndPriorities.TryGetValue(
+                    interceptor,
+                    out Dictionary<int, int> priorityCount
+                )
+            )
+            {
+                if (priorityCount.TryGetValue(priority, out int count))
+                {
+                    if (1 < count)
+                    {
+                        priorityCount[priority] = count - 1;
+                    }
+                    else
+                    {
+                        removed = true;
+                        _ = priorityCount.Remove(priority);
+                    }
+                }
+
+                if (priorityCount.Count == 0)
+                {
+                    _uniqueInterceptorsAndPriorities.Remove(interceptor);
+                }
+            }
+            else if (MessagingDebug.enabled)
+            {
+                MessagingDebug.Log(
+                    LogLevel.Error,
+                    "Received over-deregistration of Interceptor {0}. Check to make sure you're not calling (de)registration multiple times.",
+                    interceptor
+                );
+            }
+
+            bool complete = false;
+            if (removed)
+            {
+                if (
+                    interceptsByType.TryGetValue<T>(
+                        out InterceptorCache<object> prioritizedInterceptors
+                    )
+                )
+                {
+                    if (
+                        prioritizedInterceptors.handlers.TryGetValue(
+                            priority,
+                            out List<object> interceptors
+                        )
+                    )
+                    {
+                        complete = interceptors.Remove(interceptor);
+                        if (interceptors.Count == 0)
+                        {
+                            _ = prioritizedInterceptors.handlers.Remove(priority);
+                        }
+                    }
+                }
+
+                if (!complete && MessagingDebug.enabled)
+                {
+                    MessagingDebug.Log(
+                        LogLevel.Error,
+                        "Received over-deregistration of Interceptor {0}. Check to make sure you're not calling (de)registration multiple times.",
+                        interceptor
+                    );
+                }
+            }
         }
 
+        /// <summary>
+        /// True for the keyed (targeted / sourced-broadcast) handler registration methods, whose
+        /// deregistration runs <see cref="DeregisterContextHandler{T}"/>; false for the scalar
+        /// (untargeted / without-context) methods. Mirrors the register-side sink routing.
+        /// </summary>
+        private static bool IsContextMethod(RegistrationMethod method) =>
+            method switch
+            {
+                RegistrationMethod.Targeted
+                or RegistrationMethod.Broadcast
+                or RegistrationMethod.TargetedPostProcessor
+                or RegistrationMethod.BroadcastPostProcessor => true,
+                _ => false,
+            };
+
+        /// <summary>
+        /// Reverse of the register-side hardcoded scalar-sink selection (e.g.
+        /// <c>_scalarSinks[BusSinkIndex.UntargetedHandleDefault]</c>): maps a scalar handler method
+        /// back to its sink so <see cref="DeregisterScalarHandler{T}"/> can re-resolve it.
+        /// </summary>
+        private MessageCache<HandlerCache<int, HandlerCache>> ScalarSinkForMethod(
+            RegistrationMethod method
+        ) =>
+            method switch
+            {
+                RegistrationMethod.Untargeted => _scalarSinks[BusSinkIndex.UntargetedHandleDefault],
+                RegistrationMethod.BroadcastWithoutSource => _scalarSinks[
+                    BusSinkIndex.BroadcastHandleWithoutContext
+                ],
+                RegistrationMethod.TargetedWithoutTargeting => _scalarSinks[
+                    BusSinkIndex.TargetedHandleWithoutContext
+                ],
+                RegistrationMethod.UntargetedPostProcessor => _scalarSinks[
+                    BusSinkIndex.UntargetedPostProcessDefault
+                ],
+                RegistrationMethod.TargetedWithoutTargetingPostProcessor => _scalarSinks[
+                    BusSinkIndex.TargetedPostProcessWithoutContext
+                ],
+                RegistrationMethod.BroadcastWithoutSourcePostProcessor => _scalarSinks[
+                    BusSinkIndex.BroadcastPostProcessWithoutContext
+                ],
+                _ => throw new ArgumentOutOfRangeException(
+                    nameof(method),
+                    method,
+                    "Not a scalar handler registration method."
+                ),
+            };
+
+        /// <summary>
+        /// Reverse of the register-side hardcoded context-sink selection: maps a keyed handler
+        /// method back to its sink so <see cref="DeregisterContextHandler{T}"/> can re-resolve it.
+        /// </summary>
+        private MessageCache<
+            Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
+        > ContextSinkForMethod(RegistrationMethod method) =>
+            method switch
+            {
+                RegistrationMethod.Targeted => _contextSinks[BusContextIndex.TargetedHandleDefault],
+                RegistrationMethod.Broadcast => _contextSinks[
+                    BusContextIndex.BroadcastHandleDefault
+                ],
+                RegistrationMethod.TargetedPostProcessor => _contextSinks[
+                    BusContextIndex.TargetedPostProcessDefault
+                ],
+                RegistrationMethod.BroadcastPostProcessor => _contextSinks[
+                    BusContextIndex.BroadcastPostProcessDefault
+                ],
+                _ => throw new ArgumentOutOfRangeException(
+                    nameof(method),
+                    method,
+                    "Not a context handler registration method."
+                ),
+            };
+
         private static bool IsStaleContextDeregisterAfterSweep<T>(
             MessageCache<Dictionary<InstanceId, HandlerCache<int, HandlerCache>>> sinks,
             InstanceId context,
@@ -5587,7 +6135,7 @@ namespace DxMessaging.Core.MessageBus
         {
             DebugAssertAcquireFastPrecondition(handlers);
             DispatchState state = handlers.dispatchState;
-            if (state != null && !state.hasPending && !state.active.IsEmpty)
+            if (state != null && !state.hasPending && state.active.IsInitialized)
             {
                 handlers.lastTouchTicks = messageBus._tickCounter;
                 state.snapshotEmissionId = emissionId;
@@ -5645,7 +6193,7 @@ namespace DxMessaging.Core.MessageBus
 
             if (state.hasPending)
             {
-                if (state.pendingDirty || (hasHandlers && state.pending.IsEmpty))
+                if (state.pendingDirty || (hasHandlers && !state.pending.IsInitialized))
                 {
                     ReleaseSnapshot(ref state.pending);
                     state.pending = hasHandlers
@@ -5655,7 +6203,7 @@ namespace DxMessaging.Core.MessageBus
                     state.pendingDirty = false;
                 }
             }
-            else if (state.active.IsEmpty && hasHandlers)
+            else if (!state.active.IsInitialized && hasHandlers)
             {
                 ReleaseSnapshot(ref state.pending);
                 state.pending = BuildDispatchSnapshot<TMessage>(
@@ -5678,7 +6226,7 @@ namespace DxMessaging.Core.MessageBus
                     // ReleaseDisplacedSnapshot defers the release to the
                     // outermost dispatch-lease exit when one is in flight.
                     messageBus.ReleaseDisplacedSnapshot(ref state.active);
-                    if (state.pendingDirty || (hasHandlers && state.pending.IsEmpty))
+                    if (state.pendingDirty || (hasHandlers && !state.pending.IsInitialized))
                     {
                         ReleaseSnapshot(ref state.pending);
                         state.pending = hasHandlers
@@ -5698,7 +6246,7 @@ namespace DxMessaging.Core.MessageBus
                     state.hasPending = false;
                     state.pendingDirty = false;
                 }
-                else if (!hasHandlers && !state.active.IsEmpty)
+                else if (!hasHandlers && state.active.IsInitialized)
                 {
                     messageBus.ReleaseDisplacedSnapshot(ref state.active);
                 }
@@ -5722,46 +6270,13 @@ namespace DxMessaging.Core.MessageBus
                 return DispatchSnapshot.Empty;
             }
 
-            List<int> orderedPriorities = handlers.order;
-            int priorityCount = orderedPriorities.Count;
-            DispatchBucket[] buckets = DispatchBucketPool.Rent(priorityCount);
-
-            for (int i = 0; i < priorityCount; ++i)
-            {
-                int priority = orderedPriorities[i];
-                if (
-                    !handlers.handlers.TryGetValue(priority, out HandlerCache cache)
-                    || cache == null
-                )
-                {
-                    buckets[i] = DispatchBucket.CreateEmpty(priority);
-                    continue;
-                }
-
-                Dictionary<MessageHandler, int> handlerLookup = cache.handlers;
-                if (handlerLookup == null || handlerLookup.Count == 0)
-                {
-                    buckets[i] = DispatchBucket.CreateEmpty(priority);
-                    continue;
-                }
-
-                // Count-only bucket: non-global dispatch walks the resolved
-                // flat array exclusively, so the bucket carries the handler
-                // count (consumed by IsEmpty / HasAnyDispatchEntries for the
-                // legacy "found any handlers" reporting) without renting or
-                // filling a DispatchEntry array.
-                DebugAssertBusInsertionOrderInSync(cache);
-                buckets[i] = new DispatchBucket(
-                    priority,
-                    Array.Empty<DispatchEntry>(),
-                    handlerLookup.Count,
-                    pooledEntries: false
-                );
-            }
-
-            DispatchSnapshot snapshot = new DispatchSnapshot(buckets, priorityCount, pooled: true);
-            snapshot.flat = BuildFlatDispatch<TMessage>(messageBus, handlers, slotKey, context);
-            return snapshot;
+            FlatDispatchArray flat = BuildFlatDispatch<TMessage>(
+                messageBus,
+                handlers,
+                slotKey,
+                context
+            );
+            return new DispatchSnapshot(flat, hasRegistrations: true);
         }
 
         /// <summary>
@@ -6288,24 +6803,12 @@ namespace DxMessaging.Core.MessageBus
             );
         }
 
-        // IL2CPP check elision: buckets[0..bucketCount) is non-null by snapshot
-        // construction; same justification as DispatchFlatSnapshot.
         [Il2CppSetOption(Option.NullChecks, false)]
         [Il2CppSetOption(Option.ArrayBoundsChecks, false)]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static bool HasAnyDispatchEntries(DispatchSnapshot snapshot)
         {
-            DispatchBucket[] buckets = snapshot.buckets;
-            int bucketCount = snapshot.bucketCount;
-            for (int i = 0; i < bucketCount; ++i)
-            {
-                if (0 < buckets[i].entryCount)
-                {
-                    return true;
-                }
-            }
-
-            return false;
+            return snapshot.hasRegistrations;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -6330,7 +6833,7 @@ namespace DxMessaging.Core.MessageBus
 
             if (state.hasPending)
             {
-                if (state.pendingDirty || (hasHandlers && state.pending.IsEmpty))
+                if (state.pendingDirty || (hasHandlers && !state.pending.IsInitialized))
                 {
                     ReleaseSnapshot(ref state.pending);
                     if (hasHandlers)
@@ -6349,7 +6852,7 @@ namespace DxMessaging.Core.MessageBus
                     state.pendingDirty = false;
                 }
             }
-            else if (state.active.IsEmpty && hasHandlers)
+            else if (!state.active.IsInitialized && hasHandlers)
             {
                 ReleaseSnapshot(ref state.pending);
                 state.pending = BuildGlobalDispatchSnapshot<TMessage>(messageBus, handlers, kind);
@@ -6365,7 +6868,7 @@ namespace DxMessaging.Core.MessageBus
                     // snapshot may still be iterated by an outer emission, so
                     // its release is deferred while a dispatch lease is live.
                     messageBus.ReleaseDisplacedSnapshot(ref state.active);
-                    if (state.pendingDirty || (hasHandlers && state.pending.IsEmpty))
+                    if (state.pendingDirty || (hasHandlers && !state.pending.IsInitialized))
                     {
                         ReleaseSnapshot(ref state.pending);
                         state.pending = hasHandlers
@@ -6380,7 +6883,7 @@ namespace DxMessaging.Core.MessageBus
                     state.hasPending = false;
                     state.pendingDirty = false;
                 }
-                else if (!hasHandlers && !state.active.IsEmpty)
+                else if (!hasHandlers && state.active.IsInitialized)
                 {
                     messageBus.ReleaseDisplacedSnapshot(ref state.active);
                 }
@@ -6414,7 +6917,13 @@ namespace DxMessaging.Core.MessageBus
             }
 
             buckets[0] = new DispatchBucket(0, entries, entryCount, pooledEntries: true);
-            return new DispatchSnapshot(buckets, 1, pooled: true);
+            return new DispatchSnapshot(
+                buckets,
+                1,
+                entryCount,
+                hasRegistrations: true,
+                pooled: true
+            );
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]