com.wallstop-studios.dxmessaging 3.0.1 → 3.2.0

package/Runtime/Core/Internal/TypedSlots.cs

@@ -28,10 +28,9 @@ namespace DxMessaging.Core.Internal
     /// surface picks up no new members from the interface retrofit.
     /// </para>
     /// <para>
-    /// Deliberately a thin, marker-style surface: only the six members that
+    /// Deliberately a thin, marker-style surface: only the five members that
     /// staged dispatch (<see cref="Version"/>, <see cref="LastSeenVersion"/>,
-    /// <see cref="LastSeenEmissionId"/>,
-    /// <see cref="PrefreezeInvocationCount"/>) and eviction
+    /// <see cref="LastSeenEmissionId"/>) and eviction
     /// (<see cref="IsEmpty"/>, <see cref="Reset"/>) require. The
     /// <c>entries</c> dictionary and <c>cache</c> list are NOT exposed
     /// because their generic shape is the very thing this interface erases;
@@ -67,15 +66,6 @@ namespace DxMessaging.Core.Internal
         /// </summary>
         long LastSeenEmissionId { get; set; }
 
-        /// <summary>
-        /// Number of invocations observed during the prefreeze window for
-        /// the most recent dispatch. Mirrors
-        /// <c>HandlerActionCache&lt;TDelegate&gt;.prefreezeInvocationCount</c>.
-        /// Read-only on this surface; the cache's own dispatchers maintain
-        /// the value.
-        /// </summary>
-        int PrefreezeInvocationCount { get; }
-
         /// <summary>
         /// True iff the cache currently retains zero entries. Cheap (single
         /// integer compare against <c>entries.Count</c>); used by the
@@ -87,12 +77,54 @@ namespace DxMessaging.Core.Internal
         /// <summary>
         /// Eviction-driven full clear. Empties the entries dictionary and
         /// the flat cache list, resets <see cref="LastSeenVersion"/> /
-        /// <see cref="LastSeenEmissionId"/> / <c>prefreezeInvocationCount</c>,
+        /// <see cref="LastSeenEmissionId"/>,
         /// and bumps <see cref="Version"/> as the LAST step so any captured
         /// dispatch closure that observed the prior version detects
         /// invalidation. Idempotent.
         /// </summary>
         void Reset();
+
+        /// <summary>
+        /// Non-generic membership probe over the cache's entries map. The
+        /// per-handle teardown object (which carries no delegate-shape type
+        /// argument) uses this instead of a typed
+        /// <c>entries.ContainsKey</c> so it can decide whether the
+        /// over-deregistration silent-no-op guard fires without down-casting
+        /// to the concrete <c>HandlerActionCache&lt;TDelegate&gt;</c>.
+        /// </summary>
+        /// <param name="originalHandler">
+        /// The dedup/identity key (boxed delegate) the teardown captured at
+        /// registration time; cast back to the cache's delegate shape by the
+        /// implementation.
+        /// </param>
+        /// <returns>True iff an entry exists for the handler.</returns>
+        bool ContainsEntry(object originalHandler);
+
+        /// <summary>
+        /// Bumps <see cref="Version"/> by one. Mirrors the explicit
+        /// <c>version++</c> the legacy deregistration closure performed at the
+        /// top of its body (before the bus deregister call) so any in-flight
+        /// dispatch snapshot detects invalidation at the same point.
+        /// </summary>
+        void BumpVersion();
+
+        /// <summary>
+        /// Non-generic decrement-or-remove for the captured handler entry.
+        /// Mirrors the EXACT refcount logic the legacy deregistration closure
+        /// used: if the entry's refcount is at or below one, removes it from
+        /// both the entries map and the insertion-order list and bumps
+        /// <see cref="Version"/> a second time (reporting
+        /// <paramref name="wasLastForEntry"/> = true so the caller can
+        /// decrement the owning slot's live count); otherwise decrements the
+        /// refcount in place, preserving the first registration's handler /
+        /// flat invoker.
+        /// </summary>
+        /// <param name="originalHandler">The dedup/identity key (boxed delegate).</param>
+        /// <param name="wasLastForEntry">
+        /// True iff this call removed the entry (the refcount reached zero).
+        /// </param>
+        /// <returns>True iff an entry existed for the handler.</returns>
+        bool DeregisterEntry(object originalHandler, out bool wasLastForEntry);
     }
 
     /// <summary>
@@ -109,8 +141,8 @@ namespace DxMessaging.Core.Internal
         int MessageTypeIndex { get; }
 
         /// <summary>
-        /// True when the last sweep found no live typed slots or dispatch links
-        /// worth retaining and the owning <c>MessageCache</c> entry can be
+        /// True when the last sweep found no live typed slots worth
+        /// retaining and the owning <c>MessageCache</c> entry can be
         /// removed.
         /// </summary>
         bool MarkedForOuterRemoval { get; }
@@ -169,12 +201,6 @@ namespace DxMessaging.Core.Internal
     /// <c>_slots[<see cref="TypedSlotIndex.Length"/>]</c> array the
     /// storage owner.
     /// </para>
-    /// <para>
-    /// <see cref="TypedHandler{T}"/> owns a
-    /// <c>_dispatchLinks[<see cref="TypedDispatchLinkIndex.Length"/>]</c>
-    /// array as a plain <c>object[]</c> field. It is not a slot type; the
-    /// legacy named dispatch-link fields were removed.
-    /// </para>
     /// </remarks>
     /// <typeparam name="T">
     /// The strongly-typed message contract this slot's parent

package/Runtime/Core/MessageBus/DiagnosticsTarget.cs.meta

@@ -6,6 +6,6 @@ MonoImporter:
   defaultReferences: []
   executionOrder: 0
   icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/MessageBus/GlobalMessageBusProvider.cs.meta

@@ -6,6 +6,6 @@ MonoImporter:
   defaultReferences: []
   executionOrder: 0
   icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/MessageBus/IMessageBus.cs

@@ -109,23 +109,23 @@ namespace DxMessaging.Core.MessageBus
 
         internal static bool ShouldEnableDiagnostics()
         {
-            DiagnosticsTarget targets = GlobalDiagnosticsTargets;
+#if UNITY_2021_3_OR_NEWER
+            return ShouldEnableDiagnostics(GlobalDiagnosticsTargets, Application.isEditor);
+#else
+            return ShouldEnableDiagnostics(GlobalDiagnosticsTargets, isEditor: false);
+#endif
+        }
+
+        internal static bool ShouldEnableDiagnostics(DiagnosticsTarget targets, bool isEditor)
+        {
             if (targets == DiagnosticsTarget.Off)
             {
                 return false;
             }
 
-#if UNITY_2021_3_OR_NEWER
-            if (Application.isEditor)
-            {
-                return targets.HasFlagNoAlloc(DiagnosticsTarget.Editor)
-                    || targets.HasFlagNoAlloc(DiagnosticsTarget.Runtime);
-            }
-
-            return targets.HasFlagNoAlloc(DiagnosticsTarget.Editor);
-#else
-            return targets.HasFlagNoAlloc(DiagnosticsTarget.Runtime);
-#endif
+            return isEditor
+                ? targets.HasFlagNoAlloc(DiagnosticsTarget.Editor)
+                : targets.HasFlagNoAlloc(DiagnosticsTarget.Runtime);
         }
 
         /// <summary>
@@ -297,8 +297,11 @@ namespace DxMessaging.Core.MessageBus
         /// <typeparam name="T">Specific type of UntargetedMessages to register for.</typeparam>
         /// <param name="messageHandler">MessageHandler to register to accept UntargetedMessages of the specified type.</param>
         /// <param name="priority">Priority at which to run; lower runs earlier.</param>
-        /// <returns>The deregistration action. Invoke when the handler no longer wants to receive messages.</returns>
-        Action RegisterUntargeted<T>(MessageHandler messageHandler, int priority = 0)
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop receiving messages.</returns>
+        MessageBusRegistration RegisterUntargeted<T>(
+            MessageHandler messageHandler,
+            int priority = 0
+        )
             where T : IUntargetedMessage;
 
         /// <summary>
@@ -308,7 +311,7 @@ namespace DxMessaging.Core.MessageBus
         /// <param name="target">Target of messages to listen for.</param>
         /// <param name="messageHandler">MessageHandler to register the TargetedMessages of the specified type.</param>
         /// <param name="priority">Priority at which to run; lower runs earlier.</param>
-        /// <returns>The deregistration action. Invoke when the handler no longer wants to receive the messages.</returns>
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop receiving the messages.</returns>
         /// <remarks>
         /// To preserve frozen dispatch snapshots during in-flight emissions, the per-MessageHandler
         /// typed-cache for <c>(target, priority)</c> is NOT removed when the last registration at
@@ -319,7 +322,7 @@ namespace DxMessaging.Core.MessageBus
         /// at every spawned GameObject) should prefer <see cref="RegisterTargetedWithoutTargeting{T}"/>
         /// or recycle MessageHandlers to avoid unbounded inner-dictionary growth.
         /// </remarks>
-        Action RegisterTargeted<T>(
+        MessageBusRegistration RegisterTargeted<T>(
             InstanceId target,
             MessageHandler messageHandler,
             int priority = 0
@@ -333,8 +336,11 @@ namespace DxMessaging.Core.MessageBus
         /// <typeparam name="T">Specific type of TargetedMessages to register for.</typeparam>
         /// <param name="messageHandler">MessageHandler to register to accept all TargetedMessages of the specified type.</param>
         /// <param name="priority">Priority at which to run; lower runs earlier.</param>
-        /// <returns>The deregistration action. Invoke when the handler no longer wants to receive messages.</returns>
-        Action RegisterTargetedWithoutTargeting<T>(MessageHandler messageHandler, int priority = 0)
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop receiving messages.</returns>
+        MessageBusRegistration RegisterTargetedWithoutTargeting<T>(
+            MessageHandler messageHandler,
+            int priority = 0
+        )
             where T : ITargetedMessage;
 
         /// <summary>
@@ -344,7 +350,7 @@ namespace DxMessaging.Core.MessageBus
         /// <param name="source">InstanceId of the source for BroadcastMessages to listen to.</param>
         /// <param name="messageHandler">MessageHandler to register to accept BroadcastMessages.</param>
         /// <param name="priority"></param>
-        /// <returns>The deregistration action. Should be invoked when the handler no longer wants to receive messages.</returns>
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop receiving messages.</returns>
         /// <remarks>
         /// To preserve frozen dispatch snapshots during in-flight emissions, the per-MessageHandler
         /// typed-cache for <c>(source, priority)</c> is NOT removed when the last registration at
@@ -355,7 +361,7 @@ namespace DxMessaging.Core.MessageBus
         /// every spawned GameObject) should prefer <see cref="RegisterSourcedBroadcastWithoutSource{T}"/>
         /// or recycle MessageHandlers to avoid unbounded inner-dictionary growth.
         /// </remarks>
-        Action RegisterSourcedBroadcast<T>(
+        MessageBusRegistration RegisterSourcedBroadcast<T>(
             InstanceId source,
             MessageHandler messageHandler,
             int priority = 0
@@ -369,8 +375,8 @@ namespace DxMessaging.Core.MessageBus
         /// <typeparam name="T">Type of the BroadcastMessage to register.</typeparam>
         /// <param name="messageHandler">MessageHandler to register to accept BroadcastMessages.</param>
         /// <param name="priority"></param>
-        /// <returns>The deregistration action. Should be invoked when the handler no longer wants to receive messages.</returns>
-        Action RegisterSourcedBroadcastWithoutSource<T>(
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop receiving messages.</returns>
+        MessageBusRegistration RegisterSourcedBroadcastWithoutSource<T>(
             MessageHandler messageHandler,
             int priority = 0
         )
@@ -381,8 +387,8 @@ namespace DxMessaging.Core.MessageBus
         /// It doesn't matter if the message is Targeted or Untargeted, this MessageHandler will be invoked for it.
         /// </summary>
         /// <param name="messageHandler">MessageHandler to register to accept all messages.</param>
-        /// <returns>The deregistration action. Should be invoked when the handler no longer wants to receive messages.</returns>
-        Action RegisterGlobalAcceptAll(MessageHandler messageHandler);
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop receiving messages.</returns>
+        MessageBusRegistration RegisterGlobalAcceptAll(MessageHandler messageHandler);
 
         /// <summary>
         /// Registers the specified MessageHandler and transformer function as an interceptor for Messages of type T.
@@ -407,8 +413,8 @@ namespace DxMessaging.Core.MessageBus
         /// Calling the returned deregistration action removes the interceptor from dispatch, but
         /// the delegate reference may remain until the final deregistration of that interceptor.
         /// </remarks>
-        /// <returns>The deregistration action. Should be invoked when the handler no longer wants to intercept messages.</returns>
-        Action RegisterUntargetedInterceptor<T>(
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop intercepting messages.</returns>
+        MessageBusRegistration RegisterUntargetedInterceptor<T>(
             UntargetedInterceptor<T> interceptor,
             int priority = 0
         )
@@ -437,8 +443,11 @@ namespace DxMessaging.Core.MessageBus
         /// Calling the returned deregistration action removes the interceptor from dispatch, but
         /// the delegate reference may remain until the final deregistration of that interceptor.
         /// </remarks>
-        /// <returns>The deregistration action. Should be invoked when the handler no longer wants to intercept messages.</returns>
-        Action RegisterTargetedInterceptor<T>(TargetedInterceptor<T> interceptor, int priority = 0)
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop intercepting messages.</returns>
+        MessageBusRegistration RegisterTargetedInterceptor<T>(
+            TargetedInterceptor<T> interceptor,
+            int priority = 0
+        )
             where T : ITargetedMessage;
 
         /// <summary>
@@ -464,8 +473,8 @@ namespace DxMessaging.Core.MessageBus
         /// Calling the returned deregistration action removes the interceptor from dispatch, but
         /// the delegate reference may remain until the final deregistration of that interceptor.
         /// </remarks>
-        /// <returns>The deregistration action. Should be invoked when the handler no longer wants to intercept messages.</returns>
-        Action RegisterBroadcastInterceptor<T>(
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop intercepting messages.</returns>
+        MessageBusRegistration RegisterBroadcastInterceptor<T>(
             BroadcastInterceptor<T> interceptor,
             int priority = 0
         )
@@ -478,8 +487,11 @@ namespace DxMessaging.Core.MessageBus
         /// <typeparam name="T">Type of UntargetedMessage to post-process.</typeparam>
         /// <param name="messageHandler">MessageHandler to post-process messages for.</param>
         /// <param name="priority">Priority of the interceptor to run at. Handlers run in order of priority from low -> high.</param>
-        /// <returns>The deregistration action. Should be invoked when the handler no longer wants to post-process messages.</returns>
-        Action RegisterUntargetedPostProcessor<T>(MessageHandler messageHandler, int priority = 0)
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop post-processing messages.</returns>
+        MessageBusRegistration RegisterUntargetedPostProcessor<T>(
+            MessageHandler messageHandler,
+            int priority = 0
+        )
             where T : IUntargetedMessage;
 
         /// <summary>
@@ -490,8 +502,8 @@ namespace DxMessaging.Core.MessageBus
         /// <param name="target">Target of messages to listen for.</param>
         /// <param name="messageHandler">MessageHandler to post-process messages for.</param>
         /// <param name="priority">Priority of the interceptor to run at. Handlers run in order of priority from low -> high.</param>
-        /// <returns>The deregistration action. Should be invoked when the handler no longer wants to post-process messages.</returns>
-        Action RegisterTargetedPostProcessor<T>(
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop post-processing messages.</returns>
+        MessageBusRegistration RegisterTargetedPostProcessor<T>(
             InstanceId target,
             MessageHandler messageHandler,
             int priority = 0
@@ -505,8 +517,8 @@ namespace DxMessaging.Core.MessageBus
         /// <typeparam name="T">Type of TargetedMessage to post-process.</typeparam>
         /// <param name="messageHandler">MessageHandler to post-process messages for.</param>
         /// <param name="priority">Priority of the interceptor to run at. Handlers run in order of priority from low -> high.</param>
-        /// <returns>The deregistration action. Should be invoked when the handler no longer wants to post-process messages.</returns>
-        Action RegisterTargetedWithoutTargetingPostProcessor<T>(
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop post-processing messages.</returns>
+        MessageBusRegistration RegisterTargetedWithoutTargetingPostProcessor<T>(
             MessageHandler messageHandler,
             int priority = 0
         )
@@ -520,8 +532,8 @@ namespace DxMessaging.Core.MessageBus
         /// <param name="source">Source of messages to listen for.</param>
         /// <param name="messageHandler">MessageHandler to post-process messages for.</param>
         /// <param name="priority">Priority of the interceptor to run at. Handlers run in order of priority from low -> high.</param>
-        /// <returns>The deregistration action. Should be invoked when the handler no longer wants to post-process messages.</returns>
-        Action RegisterBroadcastPostProcessor<T>(
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop post-processing messages.</returns>
+        MessageBusRegistration RegisterBroadcastPostProcessor<T>(
             InstanceId source,
             MessageHandler messageHandler,
             int priority = 0
@@ -535,13 +547,36 @@ namespace DxMessaging.Core.MessageBus
         /// <typeparam name="T">Type of TargetedMessage to post-process.</typeparam>
         /// <param name="messageHandler">MessageHandler to post-process messages for.</param>
         /// <param name="priority">Priority of the interceptor to run at. Handlers run in order of priority from low -> high.</param>
-        /// <returns>The deregistration action. Should be invoked when the handler no longer wants to post-process messages.</returns>
-        Action RegisterBroadcastWithoutSourcePostProcessor<T>(
+        /// <returns>An opaque registration handle. Pass it to <see cref="Deregister{T}"/> with the same T to stop post-processing messages.</returns>
+        MessageBusRegistration RegisterBroadcastWithoutSourcePostProcessor<T>(
             MessageHandler messageHandler,
             int priority = 0
         )
             where T : IBroadcastMessage;
 
+        /// <summary>
+        /// Undoes a registration produced by any of the <c>Register*</c> methods.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// Pass the <see cref="MessageBusRegistration"/> returned by the matching
+        /// <c>Register*</c> call, using the SAME <typeparamref name="T"/> you registered with
+        /// (for <see cref="RegisterGlobalAcceptAll"/>, any <c>T : IMessage</c> such as
+        /// <see cref="Messages.IMessage"/> is accepted, since the global slot is not type-keyed).
+        /// </para>
+        /// <para>
+        /// Deregistration is idempotent at the handle level only in the sense that a handle that
+        /// has outlived a reset/domain-reload, or a <see cref="MessageBusRegistration.None"/> /
+        /// foreign handle, is a silent no-op. Calling it twice for the same live registration is a
+        /// genuine over-deregistration and is logged (matching the pre-v4 behaviour of invoking
+        /// the returned deregistration action twice).
+        /// </para>
+        /// </remarks>
+        /// <typeparam name="T">The message type the registration was created for.</typeparam>
+        /// <param name="registration">The handle returned by the originating <c>Register*</c> call.</param>
+        void Deregister<T>(in MessageBusRegistration registration)
+            where T : IMessage;
+
         /// <summary>
         /// Broadcasts an Untargeted message to all listeners registered to this bus.
         /// </summary>

package/Runtime/Core/MessageBus/IMessageBus.cs.meta

@@ -6,6 +6,6 @@ MonoImporter:
   defaultReferences: []
   executionOrder: 0
   icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/MessageBus/IMessageBusProvider.cs.meta

@@ -6,6 +6,6 @@ MonoImporter:
   defaultReferences: []
   executionOrder: 0
   icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/MessageBus/IMessageRegistrationBuilder.cs

@@ -13,6 +13,7 @@ namespace DxMessaging.Core.MessageBus
         /// <param name="options">Build configuration describing ownership, message bus preference, and lifecycle hooks.</param>
         /// <returns>Lease that exposes the constructed <see cref="MessageRegistrationToken"/>.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="options"/> is <see langword="null"/>.</exception>
+        /// <exception cref="MessageRegistrationBuildException">ActivateOnBuild activation failed and automatic cleanup remains retryable.</exception>
         MessageRegistrationLease Build(MessageRegistrationBuildOptions options);
     }
 }

package/Runtime/Core/MessageBus/IMessageRegistrationBuilder.cs.meta

@@ -6,6 +6,6 @@ MonoImporter:
   defaultReferences: []
   executionOrder: 0
   icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/MessageBus/Internal/BusSlots.cs

@@ -4,6 +4,7 @@ namespace DxMessaging.Core.MessageBus.Internal
     using System.Diagnostics;
     using System.Runtime.CompilerServices;
     using DxMessaging.Core;
+    using DxMessaging.Core.Internal;
     using DxMessaging.Core.Pooling;
 
     /// <summary>
@@ -277,7 +278,7 @@ namespace DxMessaging.Core.MessageBus.Internal
     /// <c>Dictionary&lt;InstanceId, object&gt;</c> -- generic-erased to share a
     /// single pool across every message-type instantiation. Each value is a
     /// <see cref="BusSinkSlot"/>, accessed via
-    /// <see cref="Unsafe.As{T}(object)"/>; the class is sealed and only inserted
+    /// <see cref="DxUnsafe.As{T}(object)"/>; the class is sealed and only inserted
     /// from this type's own methods, so the cast cannot encounter a foreign
     /// runtime type. <c>DEBUG</c> builds verify the invariant at every
     /// cast site.
@@ -378,7 +379,7 @@ namespace DxMessaging.Core.MessageBus.Internal
                 return false;
             }
             DebugAssertSlot(boxed);
-            slot = Unsafe.As<BusSinkSlot>(boxed);
+            slot = DxUnsafe.As<BusSinkSlot>(boxed);
             return true;
         }
 
@@ -403,7 +404,7 @@ namespace DxMessaging.Core.MessageBus.Internal
             if (map.TryGetValue(context, out object boxed))
             {
                 DebugAssertSlot(boxed);
-                return Unsafe.As<BusSinkSlot>(boxed);
+                return DxUnsafe.As<BusSinkSlot>(boxed);
             }
             BusSinkSlot slot = new BusSinkSlot();
             map[context] = slot;
@@ -463,7 +464,7 @@ namespace DxMessaging.Core.MessageBus.Internal
                         continue;
                     }
                     DebugAssertSlot(boxed);
-                    Unsafe.As<BusSinkSlot>(boxed).Clear();
+                    DxUnsafe.As<BusSinkSlot>(boxed).Clear();
                 }
                 map.Clear();
             }
@@ -494,7 +495,7 @@ namespace DxMessaging.Core.MessageBus.Internal
                         continue;
                     }
                     DebugAssertSlot(boxed);
-                    Unsafe.As<BusSinkSlot>(boxed).Reset();
+                    DxUnsafe.As<BusSinkSlot>(boxed).Reset();
                 }
                 // Pool's onRecycled callback clears the dictionary before re-use.
                 DxPools.InstanceIdDicts.Return(map);
@@ -513,7 +514,7 @@ namespace DxMessaging.Core.MessageBus.Internal
             Debug.Assert(
                 boxed is BusSinkSlot,
                 "BusContextSlot.byContext must only contain BusSinkSlot values; "
-                    + "Unsafe.As<BusSinkSlot> would otherwise produce undefined behavior."
+                    + "DxUnsafe.As<BusSinkSlot> would otherwise produce undefined behavior."
             );
         }
     }