com.wallstop-studios.dxmessaging 3.0.1 → 3.2.0

package/Runtime/Core/DataStructure/CyclicBuffer.cs.meta

@@ -1,3 +1,11 @@
 fileFormatVersion: 2
 guid: 7d8dbf8640e24846bf35fb18a1b7c504
-timeCreated: 1749671893
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/Diagnostics/MessageEmissionData.cs.meta

@@ -1,3 +1,11 @@
 fileFormatVersion: 2
 guid: 8eafaabae0f549ec82f67ea18be788e1
-timeCreated: 1749672335
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/Diagnostics/MessageRegistrationData.cs.meta

@@ -1,3 +1,11 @@
 fileFormatVersion: 2
 guid: 01598791b01241caabfecea4c1f5880d
-timeCreated: 1749672447
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/Diagnostics/MessageRegistrationType.cs.meta

@@ -1,3 +1,11 @@
 fileFormatVersion: 2
 guid: 7d393cfbb3c8429d83af17a737fdaf0e
-timeCreated: 1749672471
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/DxMessagingStaticState.cs.meta

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

package/Runtime/Core/Extensions/EnumExtensions.cs

@@ -2,6 +2,7 @@ namespace DxMessaging.Core.Extensions
 {
     using System;
     using System.Runtime.CompilerServices;
+    using DxMessaging.Core.Internal;
 
     internal static class EnumExtensions
     {
@@ -26,12 +27,12 @@ namespace DxMessaging.Core.Extensions
         {
             try
             {
-                return Unsafe.SizeOf<T>() switch
+                return DxUnsafe.SizeOf<T>() switch
                 {
-                    1 => Unsafe.As<T, byte>(ref value),
-                    2 => Unsafe.As<T, ushort>(ref value),
-                    4 => Unsafe.As<T, uint>(ref value),
-                    8 => Unsafe.As<T, ulong>(ref value),
+                    1 => DxUnsafe.As<T, byte>(ref value),
+                    2 => DxUnsafe.As<T, ushort>(ref value),
+                    4 => DxUnsafe.As<T, uint>(ref value),
+                    8 => DxUnsafe.As<T, ulong>(ref value),
                     _ => null,
                 };
             }

package/Runtime/Core/Extensions/EnumExtensions.cs.meta

@@ -1,3 +1,11 @@
 fileFormatVersion: 2
 guid: f01ee914d7634a69a85f86bb02f2f07e
-timeCreated: 1745162639
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/Extensions/IListExtensions.cs.meta

@@ -1,3 +1,11 @@
 fileFormatVersion: 2
 guid: f6956caef19744a0b0d96215d4e5154a
-timeCreated: 1749671953
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/Extensions/MessageBusExtensions.cs.meta

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

package/Runtime/Core/Extensions/MessageExtensions.cs

@@ -79,12 +79,6 @@ namespace DxMessaging.Core.Extensions
         {
             InstanceId targetId = target;
             IMessageBus resolvedBus = ResolveMessageBus(messageBus, messageBusProvider);
-            if (typeof(TMessage) == typeof(ITargetedMessage))
-            {
-                resolvedBus.UntypedTargetedBroadcast(targetId, message);
-                return;
-            }
-
             resolvedBus.TargetedBroadcast(ref targetId, ref message);
         }
 
@@ -129,12 +123,6 @@ namespace DxMessaging.Core.Extensions
         {
             InstanceId targetId = target;
             IMessageBus resolvedBus = ResolveMessageBus(messageBus, messageBusProvider);
-            if (typeof(TMessage) == typeof(ITargetedMessage))
-            {
-                resolvedBus.UntypedTargetedBroadcast(targetId, message);
-                return;
-            }
-
             resolvedBus.TargetedBroadcast(ref targetId, ref message);
         }
 #endif
@@ -178,12 +166,6 @@ namespace DxMessaging.Core.Extensions
             where TMessage : struct, ITargetedMessage
         {
             IMessageBus resolvedBus = ResolveMessageBus(messageBus, messageBusProvider);
-            if (typeof(TMessage) == typeof(ITargetedMessage))
-            {
-                resolvedBus.UntypedTargetedBroadcast(target, message);
-                return;
-            }
-
             resolvedBus.TargetedBroadcast(ref target, ref message);
         }
 
@@ -259,12 +241,6 @@ namespace DxMessaging.Core.Extensions
             where TMessage : struct, IUntargetedMessage
         {
             IMessageBus resolvedBus = ResolveMessageBus(messageBus, messageBusProvider);
-            if (typeof(TMessage) == typeof(IUntargetedMessage))
-            {
-                resolvedBus.UntypedUntargetedBroadcast(message);
-                return;
-            }
-
             resolvedBus.UntargetedBroadcast(ref message);
         }
 
@@ -296,12 +272,6 @@ namespace DxMessaging.Core.Extensions
             where TMessage : struct, IUntargetedMessage
         {
             IMessageBus resolvedBus = ResolveMessageBus(messageBus, messageBusProvider);
-            if (typeof(TMessage) == typeof(IUntargetedMessage))
-            {
-                resolvedBus.UntypedUntargetedBroadcast(message);
-                return;
-            }
-
             resolvedBus.UntargetedBroadcast(ref message);
         }
 
@@ -341,12 +311,6 @@ namespace DxMessaging.Core.Extensions
             where TMessage : struct, ITargetedMessage
         {
             IMessageBus resolvedBus = ResolveMessageBus(messageBus, messageBusProvider);
-            if (typeof(TMessage) == typeof(ITargetedMessage))
-            {
-                resolvedBus.UntypedTargetedBroadcast(target, message);
-                return;
-            }
-
             resolvedBus.TargetedBroadcast(ref target, ref message);
         }
 
@@ -386,12 +350,6 @@ namespace DxMessaging.Core.Extensions
             where TMessage : struct, IBroadcastMessage
         {
             IMessageBus resolvedBus = ResolveMessageBus(messageBus, messageBusProvider);
-            if (typeof(TMessage) == typeof(ITargetedMessage))
-            {
-                resolvedBus.UntypedSourcedBroadcast(source, message);
-                return;
-            }
-
             resolvedBus.SourcedBroadcast(ref source, ref message);
         }
 
@@ -437,12 +395,6 @@ namespace DxMessaging.Core.Extensions
         {
             InstanceId sourceId = source;
             IMessageBus resolvedBus = ResolveMessageBus(messageBus, messageBusProvider);
-            if (typeof(TMessage) == typeof(IBroadcastMessage))
-            {
-                resolvedBus.UntypedSourcedBroadcast(sourceId, message);
-                return;
-            }
-
             resolvedBus.SourcedBroadcast(ref sourceId, ref message);
         }
 
@@ -487,12 +439,6 @@ namespace DxMessaging.Core.Extensions
         {
             InstanceId sourceId = source;
             IMessageBus resolvedBus = ResolveMessageBus(messageBus, messageBusProvider);
-            if (typeof(TMessage) == typeof(IBroadcastMessage))
-            {
-                resolvedBus.UntypedSourcedBroadcast(sourceId, message);
-                return;
-            }
-
             resolvedBus.SourcedBroadcast(ref sourceId, ref message);
         }
 #endif
@@ -536,12 +482,6 @@ namespace DxMessaging.Core.Extensions
             where TMessage : struct, IBroadcastMessage
         {
             IMessageBus resolvedBus = ResolveMessageBus(messageBus, messageBusProvider);
-            if (typeof(TMessage) == typeof(IBroadcastMessage))
-            {
-                resolvedBus.UntypedSourcedBroadcast(source, message);
-                return;
-            }
-
             resolvedBus.SourcedBroadcast(ref source, ref message);
         }
 

package/Runtime/Core/Extensions/MessageExtensions.cs.meta

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

package/Runtime/Core/Helper/MessageCache.cs.meta

@@ -1,3 +1,11 @@
 fileFormatVersion: 2
 guid: 23cb3bf7f25d479c862736482ee96fa7
-timeCreated: 1745102344
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/Helper/MessageHelperIndexer.cs.meta

@@ -1,3 +1,11 @@
 fileFormatVersion: 2
 guid: 612c352c3d984a3486ac4b19bb69fa37
-timeCreated: 1745101032
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/IMessage.cs.meta

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

package/Runtime/Core/InstanceId.cs

@@ -50,10 +50,34 @@ namespace DxMessaging.Core
 #if UNITY_2021_3_OR_NEWER
         private InstanceId(UnityEngine.Object unityObject)
         {
-            _id = unityObject.GetInstanceID();
+            _id = StableId(unityObject);
             Object = unityObject;
         }
 
+        /// <summary>
+        /// Returns the stable per-object integer identity used as the dispatch key.
+        /// Unity 6 is migrating object identity to the 64-bit <c>EntityId</c>:
+        /// <c>GetInstanceID()</c> is deprecated and becomes a compile error in Unity 6.5,
+        /// and successive raw accessors (the <c>EntityId</c>-to-<c>int</c> cast, then
+        /// <c>GetRawData()</c>) have each been deprecated in turn. On Unity 6.4+ this reads
+        /// the non-deprecated <c>EntityId.ToULong(...)</c> and keeps its low 32 bits --
+        /// exactly the integer the legacy <c>GetInstanceID()</c> returned (verified on 6.4
+        /// across GameObject/Component/ScriptableObject). Older Unity keeps
+        /// <c>GetInstanceID()</c> (valid, warning-only there, never the 6.5 error). The
+        /// 32-bit dispatch key is identical either way; only the (non-deprecated) source
+        /// differs. The gate is the host-verified 6.4 rather than 6.2 because the exact
+        /// accessor that is non-deprecated has shifted across Unity 6 minors.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static int StableId(UnityEngine.Object unityObject)
+        {
+#if UNITY_6000_4_OR_NEWER
+            return unchecked((int)UnityEngine.EntityId.ToULong(unityObject.GetEntityId()));
+#else
+            return unityObject.GetInstanceID();
+#endif
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         /// <summary>
         /// Converts a <see cref="UnityEngine.GameObject"/> reference into an <see cref="InstanceId"/>.

package/Runtime/Core/InstanceId.cs.meta

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

package/Runtime/Core/Internal/DxUnsafe.cs

@@ -0,0 +1,60 @@
+namespace DxMessaging.Core.Internal
+{
+    using System.Runtime.CompilerServices;
+    // Qualified with global:: because this assembly also declares a DxMessaging.Unity
+    // namespace; an unqualified "using Unity.Collections..." would bind to
+    // DxMessaging.Unity.Collections and fail to resolve.
+    using global::Unity.Collections.LowLevel.Unsafe;
+
+    /// <summary>
+    /// Reinterpret-cast helpers used by the hot dispatch path. Each method wraps a Unity
+    /// <see cref="UnsafeUtility"/> intrinsic, which resolves in both the Editor and every
+    /// player build (Mono and IL2CPP, including the .NET Standard 2.0 profile) without an
+    /// external precompiled assembly.
+    /// </summary>
+    /// <remarks>
+    /// These are drop-in replacements for the corresponding
+    /// <c>System.Runtime.CompilerServices.Unsafe</c> members. That type is supplied by the
+    /// Editor but is absent from player builds, so referencing it compiled in the Editor yet
+    /// failed standalone IL2CPP compilation. <see cref="UnsafeUtility"/> ships inside
+    /// <c>UnityEngine.CoreModule</c> on every supported platform, so routing through it keeps
+    /// the zero-allocation reinterpret behavior while removing the unresolved dependency.
+    /// The wrapped intrinsics are pure IL (no internal-call transition), so this indirection
+    /// is free once inlined.
+    /// </remarks>
+    internal static class DxUnsafe
+    {
+        /// <summary>
+        /// Reinterprets a managed reference to <typeparamref name="TFrom"/> as a reference to
+        /// <typeparamref name="TTo"/> in place, without copying or boxing. Callers guarantee the
+        /// reinterpretation is valid for the concrete runtime layout.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static ref TTo As<TFrom, TTo>(ref TFrom source)
+        {
+            return ref UnsafeUtility.As<TFrom, TTo>(ref source);
+        }
+
+        /// <summary>
+        /// Reinterprets a reference-typed instance as <typeparamref name="TTo"/> without a type
+        /// check. Callers guarantee the runtime type, mirroring the prior unchecked
+        /// <c>Unsafe.As&lt;T&gt;(object)</c> usage.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static TTo As<TTo>(object value)
+            where TTo : class
+        {
+            return UnsafeUtility.As<object, TTo>(ref value);
+        }
+
+        /// <summary>
+        /// Returns the size in bytes of <typeparamref name="T"/>.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static int SizeOf<T>()
+            where T : struct
+        {
+            return UnsafeUtility.SizeOf<T>();
+        }
+    }
+}

package/Runtime/Core/Internal/DxUnsafe.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ee766f9071484d4296892a84523a9aaa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/Core/Internal/FlatDispatch.cs

@@ -0,0 +1,198 @@
+namespace DxMessaging.Core.Internal
+{
+    using System;
+    using System.Buffers;
+    using System.Collections.Generic;
+    using DxMessaging.Core;
+
+    /// <summary>
+    /// One fully-resolved dispatch entry for slots whose delegates do NOT
+    /// receive the routing context (untargeted handle/post, and the
+    /// context-keyed Default-variant targeted/broadcast slots, where the
+    /// target/source is the routing key rather than a delegate parameter):
+    /// the owning <see cref="MessageHandler"/> (for the single live
+    /// <c>active</c> check) plus the final invocable delegate, resolved at
+    /// snapshot-build time. Steady-state dispatch over an array of these is
+    /// a single field read, one branch, and a direct delegate invocation per
+    /// entry - no dispatch link, no generation guard, no per-priority
+    /// dictionary lookup, and no type test.
+    /// </summary>
+    /// <typeparam name="TMessage">Concrete message type of the dispatch slot.</typeparam>
+    internal readonly struct FlatDispatchEntry<TMessage>
+        where TMessage : IMessage
+    {
+        public FlatDispatchEntry(
+            MessageHandler handler,
+            MessageHandler.FastHandler<TMessage> invoker
+        )
+        {
+            this.handler = handler;
+            this.invoker = invoker;
+        }
+
+        public readonly MessageHandler handler;
+        public readonly MessageHandler.FastHandler<TMessage> invoker;
+    }
+
+    /// <summary>
+    /// One fully-resolved dispatch entry for the WithoutContext
+    /// targeted/broadcast slots, whose delegates DO receive the routing
+    /// context (target/source <see cref="InstanceId"/>) as a parameter.
+    /// Mirrors <see cref="FlatDispatchEntry{TMessage}"/> with the
+    /// context-carrying delegate shape.
+    /// </summary>
+    /// <typeparam name="TMessage">Concrete message type of the dispatch slot.</typeparam>
+    internal readonly struct ContextFlatDispatchEntry<TMessage>
+        where TMessage : IMessage
+    {
+        public ContextFlatDispatchEntry(
+            MessageHandler handler,
+            MessageHandler.FastHandlerWithContext<TMessage> invoker
+        )
+        {
+            this.handler = handler;
+            this.invoker = invoker;
+        }
+
+        public readonly MessageHandler handler;
+        public readonly MessageHandler.FastHandlerWithContext<TMessage> invoker;
+    }
+
+    /// <summary>
+    /// Non-generic erasure base so the non-generic
+    /// <c>MessageBus.DispatchSnapshot</c> can carry and release a typed flat
+    /// entry array without knowing the closed message type (or the entry
+    /// shape). The snapshot's pooled-release path calls <see cref="Release"/>
+    /// exactly once per snapshot teardown; the typed holder returns its array
+    /// to the per-closed-generic pool.
+    /// </summary>
+    internal abstract class FlatDispatchArray
+    {
+        internal abstract void Release();
+    }
+
+    /// <summary>
+    /// Shared pooled-holder implementation for flat dispatch arrays: a pooled
+    /// entry array (rented from <see cref="ArrayPool{T}"/>) plus a small
+    /// per-closed-generic holder stack so registration-churn rebuilds
+    /// allocate nothing in steady state. Concrete holders
+    /// (<see cref="FlatDispatch{TMessage}"/>,
+    /// <see cref="ContextFlatDispatch{TMessage}"/>) only pick the entry
+    /// shape; all lifecycle logic lives here so the pool/lock/cap/released
+    /// pattern exists exactly once.
+    /// </summary>
+    /// <remarks>
+    /// Lifecycle mirrors the snapshot that owns the holder: the array is
+    /// frozen for the duration of any emission that acquired it (mutations
+    /// mark the owning DispatchState dirty and are observed by the NEXT
+    /// emission's rebuild), and it is released back to the pool only through
+    /// <c>DispatchSnapshot.Release()</c>. The <c>_released</c> flag guards
+    /// the holder against double-release (which would seat the same holder
+    /// in the pool twice and corrupt later rents): DEBUG builds assert,
+    /// release builds no-op the second call.
+    /// </remarks>
+    /// <typeparam name="TEntry">Resolved entry struct stored in the array.</typeparam>
+    /// <typeparam name="THolder">Concrete holder type (CRTP, for typed pooling).</typeparam>
+    internal abstract class PooledFlatDispatch<TEntry, THolder> : FlatDispatchArray
+        where THolder : PooledFlatDispatch<TEntry, THolder>, new()
+    {
+        private static readonly ArrayPool<TEntry> EntryPool = ArrayPool<TEntry>.Shared;
+
+        // Cold-path pool (rebuild/teardown only); the lock is uncontended in
+        // practice but keeps the holder pool safe if multiple buses are ever
+        // driven from different threads.
+        private static readonly Stack<THolder> HolderPool = new();
+        private static readonly object HolderPoolLock = new();
+        private const int MaxRetainedHolders = 64;
+
+        internal TEntry[] entries = Array.Empty<TEntry>();
+        internal int count;
+
+        // True while the holder is parked in (or eligible for) the pool;
+        // false while it is owned by a live DispatchSnapshot. Guards the
+        // rent/release lifecycle against double-release and rent-of-live.
+        private bool _released = true;
+
+        internal static THolder Rent(int capacity)
+        {
+            THolder holder = null;
+            lock (HolderPoolLock)
+            {
+                if (0 < HolderPool.Count)
+                {
+                    holder = HolderPool.Pop();
+                }
+            }
+
+            holder ??= new THolder();
+            System.Diagnostics.Debug.Assert(
+                holder._released,
+                "PooledFlatDispatch.Rent returned a holder that is still owned by a live "
+                    + "snapshot; a Release() was skipped or the pool was corrupted."
+            );
+            holder._released = false;
+            holder.entries = 0 < capacity ? EntryPool.Rent(capacity) : Array.Empty<TEntry>();
+            holder.count = 0;
+            return holder;
+        }
+
+        internal sealed override void Release()
+        {
+            if (_released)
+            {
+                System.Diagnostics.Debug.Assert(
+                    false,
+                    "PooledFlatDispatch.Release called twice on the same holder; the owning "
+                        + "DispatchSnapshot must release its flat array exactly once."
+                );
+                return;
+            }
+
+            _released = true;
+            TEntry[] localEntries = entries;
+            int localCount = count;
+            entries = Array.Empty<TEntry>();
+            count = 0;
+            if (0 < localEntries.Length)
+            {
+                Array.Clear(localEntries, 0, localCount);
+                EntryPool.Return(localEntries);
+            }
+
+            lock (HolderPoolLock)
+            {
+                if (HolderPool.Count < MaxRetainedHolders)
+                {
+                    HolderPool.Push((THolder)this);
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Pooled flat array of resolved entries for one
+    /// (bus, message-type[, context], phase) dispatch snapshot whose
+    /// delegates take only the message: untargeted handle/post and the
+    /// context-keyed (Default variant) targeted/broadcast handle/post slots.
+    /// Built at snapshot-build time by walking the bus priority buckets
+    /// ascending, then each bucket's MessageHandlers in bus insertion order,
+    /// then each handler's fast entries followed by its default entries
+    /// (both in first-registration order), so a plain forward iteration
+    /// reproduces the documented dispatch order exactly.
+    /// </summary>
+    /// <typeparam name="TMessage">Concrete message type of the dispatch slot.</typeparam>
+    internal sealed class FlatDispatch<TMessage>
+        : PooledFlatDispatch<FlatDispatchEntry<TMessage>, FlatDispatch<TMessage>>
+        where TMessage : IMessage { }
+
+    /// <summary>
+    /// Pooled flat array of resolved entries for one (bus, message-type,
+    /// phase) dispatch snapshot of a WithoutContext targeted/broadcast slot,
+    /// whose delegates receive the routing <see cref="InstanceId"/> alongside
+    /// the message. Build order matches <see cref="FlatDispatch{TMessage}"/>.
+    /// </summary>
+    /// <typeparam name="TMessage">Concrete message type of the dispatch slot.</typeparam>
+    internal sealed class ContextFlatDispatch<TMessage>
+        : PooledFlatDispatch<ContextFlatDispatchEntry<TMessage>, ContextFlatDispatch<TMessage>>
+        where TMessage : IMessage { }
+}

package/Runtime/Core/Internal/FlatDispatch.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a21a4ac4e7dd4fd4839dc6de875e24d8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant: