com.wallstop-studios.dxmessaging 2.2.0 → 3.1.0

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

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

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

@@ -0,0 +1,38 @@
+namespace DxMessaging.Core.MessageBus.Internal
+{
+    /// <summary>
+    /// First axis of the dispatch slot key. Identifies the structural shape of a
+    /// registration: untargeted scalar, targeted (per-recipient), broadcast
+    /// (per-source), or global (catch-all that subscribes to every emit of a
+    /// registered base shape).
+    /// </summary>
+    /// <remarks>
+    /// Encoded into <see cref="SlotKey.Packed"/> in the high nibble (bits 4-7).
+    /// Packed value range is 0..3, leaving room for two additional kinds before
+    /// the nibble overflows.
+    /// </remarks>
+    internal enum DispatchKind : byte
+    {
+        /// <summary>
+        /// Untargeted dispatch. No <see cref="InstanceId"/> recipient or source
+        /// carried; the message itself is the entire payload.
+        /// </summary>
+        Untargeted = 0,
+
+        /// <summary>Targeted dispatch. Message carries an <see cref="InstanceId"/> recipient.</summary>
+        Targeted = 1,
+
+        /// <summary>Broadcast dispatch. Message carries an <see cref="InstanceId"/> source.</summary>
+        Broadcast = 2,
+
+        /// <summary>
+        /// Reserved for the global-dispatch axis. Currently unreferenced -- the
+        /// global dispatch path uses <see cref="BusGlobalSlot"/> directly with the
+        /// per-message-shape <see cref="DispatchKind"/> (<see cref="Untargeted"/>,
+        /// <see cref="Targeted"/>, or <see cref="Broadcast"/>) rather than this
+        /// value. Kept to lock the bit-packing contract documented on
+        /// <see cref="SlotKey"/>.
+        /// </summary>
+        Global = 3,
+    }
+}

package/Runtime/Core/MessageBus/Internal/DispatchKind.cs.meta

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

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

@@ -0,0 +1,20 @@
+namespace DxMessaging.Core.MessageBus.Internal
+{
+    /// <summary>
+    /// Second axis of the dispatch slot key. Distinguishes the two phases of
+    /// message processing: the primary handle phase and the post-process phase
+    /// that runs after every primary handler has returned.
+    /// </summary>
+    /// <remarks>
+    /// Encoded into <see cref="SlotKey.Packed"/> at bit 3. Packed value range is
+    /// 0..1.
+    /// </remarks>
+    internal enum DispatchPhase : byte
+    {
+        /// <summary>Primary handler phase.</summary>
+        Handle = 0,
+
+        /// <summary>Post-processor phase. Runs after the handle phase completes.</summary>
+        PostProcess = 1,
+    }
+}

package/Runtime/Core/MessageBus/Internal/DispatchPhase.cs.meta

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

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

@@ -0,0 +1,28 @@
+namespace DxMessaging.Core.MessageBus.Internal
+{
+    /// <summary>
+    /// Third axis of the dispatch slot key. Captures handler-shape variants that
+    /// share a <see cref="DispatchKind"/> but differ in delegate signature or
+    /// fast-path eligibility.
+    /// </summary>
+    /// <remarks>
+    /// Encoded into <see cref="SlotKey.Packed"/> in the low three bits (bits
+    /// 0-2). Packed value range is 0..3 in current usage; the three-bit slot
+    /// leaves room for four additional variants without disturbing the packed
+    /// layout.
+    /// </remarks>
+    internal enum DispatchVariant : byte
+    {
+        /// <summary>Default handler shape (full delegate signature with context).</summary>
+        Default = 0,
+
+        /// <summary>Fast-path handler shape (specialized signature).</summary>
+        Fast = 1,
+
+        /// <summary>Handler shape that elides the context argument.</summary>
+        WithoutContext = 2,
+
+        /// <summary>Fast-path handler shape that elides the context argument.</summary>
+        WithoutContextFast = 3,
+    }
+}

package/Runtime/Core/MessageBus/Internal/DispatchVariant.cs.meta

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

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

@@ -0,0 +1,48 @@
+namespace DxMessaging.Core.MessageBus.Internal
+{
+    /// <summary>
+    /// Marker interface for bus-level slot containers that the eviction layer
+    /// can sweep. Each slot tracks its last-touch tick so the sweep can decide
+    /// whether to reclaim it, and exposes a monotonic
+    /// <see cref="Version"/> so that staged dispatch closures captured before
+    /// eviction can detect they have been invalidated.
+    /// </summary>
+    /// <remarks>
+    /// <see cref="Reset"/> returns inner pooled collections to
+    /// <c>DxMessaging.Core.Pooling.DxPools</c>. The sweep policy calls
+    /// <see cref="Reset"/> on idle empty slots.
+    /// </remarks>
+    internal interface IEvictableSlot
+    {
+        /// <summary>
+        /// The bus tick counter value at the most recent register / deregister /
+        /// emit operation that touched this slot. Used by the sweep to decide
+        /// whether the slot has been idle for long enough to evict.
+        /// </summary>
+        long LastTouchTicks { get; }
+
+        /// <summary>
+        /// True iff the slot currently retains zero live registrations. Cheap
+        /// (single integer compare); maintained at register / deregister sites.
+        /// Stale-but-non-empty slots are NOT eviction candidates -- only
+        /// idle AND empty slots are reclaimed.
+        /// </summary>
+        bool IsEmpty { get; }
+
+        /// <summary>
+        /// Strictly monotonic version counter. Bumped by <see cref="Reset"/>
+        /// (and by registration-time mutations on the slot). Allows captured
+        /// dispatch closures to detect post-eviction invalidation.
+        /// </summary>
+        long Version { get; }
+
+        /// <summary>
+        /// Reclaim this slot: clear inner state, return any pooled inner
+        /// collections to <c>DxPools</c>, and bump <see cref="Version"/>.
+        /// Idempotent. <see cref="LastTouchTicks"/> is intentionally preserved
+        /// across <see cref="Reset"/> so the sweep can distinguish freshly-reset
+        /// slots from never-touched ones.
+        /// </summary>
+        void Reset();
+    }
+}

package/Runtime/Core/MessageBus/Internal/IEvictableSlot.cs.meta

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

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

@@ -0,0 +1,15 @@
+namespace DxMessaging.Core.MessageBus.Internal
+{
+    using System;
+
+    /// <summary>
+    /// Describes a <see cref="DxMessaging.Core.MessageBus.MessageBus"/> cache storage field that
+    /// participates in explicit or idle sweep coverage.
+    /// </summary>
+    internal interface ISweepable
+    {
+        string StorageFieldName { get; }
+        Type StorageFieldType { get; }
+        int Sweep(DxMessaging.Core.MessageBus.MessageBus bus, bool force);
+    }
+}

package/Runtime/Core/MessageBus/Internal/ISweepable.cs.meta

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

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

@@ -0,0 +1,222 @@
+namespace DxMessaging.Core.MessageBus.Internal
+{
+    using System;
+    using System.Runtime.CompilerServices;
+
+    /// <summary>
+    /// Static lookup that translates a <see cref="RegistrationMethod"/> enum
+    /// value into the <see cref="SlotKey"/> coordinate that identifies the
+    /// dispatch slot it targets. Replaces the legacy 14-case category switch
+    /// with a data-driven table.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Two registration methods --
+    /// <see cref="RegistrationMethod.Interceptor"/> and
+    /// <see cref="RegistrationMethod.GlobalAcceptAll"/> -- map to
+    /// <see cref="SlotKey.None"/>. Interceptor caches are deliberately out of
+    /// scope for the slot grid (their machinery is separate); global accept-all
+    /// is structurally a multi-slot registration handled by dedicated bus
+    /// state.
+    /// </para>
+    /// <para>
+    /// The table is validated once at type-init: every value of
+    /// <see cref="RegistrationMethod"/> must have an entry, otherwise an
+    /// <see cref="InvalidOperationException"/> is thrown. This guarantees that
+    /// adding a new registration method without wiring its axis is a
+    /// load-time failure, not a silent dispatch hole.
+    /// </para>
+    /// </remarks>
+    internal static class RegistrationMethodAxes
+    {
+        private static readonly SlotKey[] Table = BuildAndValidateTable();
+
+        /// <summary>
+        /// Returns the <see cref="SlotKey"/> for the supplied registration
+        /// method. Returns <see cref="SlotKey.None"/> when the method is
+        /// out-of-range or maps to the multi-slot / out-of-scope sentinel.
+        /// </summary>
+        /// <param name="method">The registration method to translate.</param>
+        /// <returns>
+        /// The mapped <see cref="SlotKey"/>, or <see cref="SlotKey.None"/> when
+        /// the method has no single-slot mapping.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static SlotKey GetSlotKey(RegistrationMethod method)
+        {
+            uint index = (uint)(int)method;
+            if (index >= (uint)Table.Length)
+            {
+                return SlotKey.None;
+            }
+            return Table[index];
+        }
+
+        private static SlotKey[] BuildAndValidateTable()
+        {
+            Array values = Enum.GetValues(typeof(RegistrationMethod));
+            int max = -1;
+            for (int i = 0; i < values.Length; i++)
+            {
+                int raw = (int)values.GetValue(i);
+                if (raw < 0)
+                {
+                    throw new InvalidOperationException(
+                        "RegistrationMethod enum contains a negative value: "
+                            + values.GetValue(i)
+                            + ". RegistrationMethodAxes assumes non-negative ordinals."
+                    );
+                }
+                if (raw > max)
+                {
+                    max = raw;
+                }
+            }
+
+            SlotKey[] table = new SlotKey[max + 1];
+            for (int i = 0; i <= max; i++)
+            {
+                table[i] = SlotKey.None;
+            }
+            bool[] assigned = new bool[max + 1];
+
+            void Assign(RegistrationMethod method, SlotKey key)
+            {
+                int idx = (int)method;
+                if (assigned[idx])
+                {
+                    throw new InvalidOperationException(
+                        "RegistrationMethodAxes table assigned twice for "
+                            + method
+                            + ". Mapping must be unique."
+                    );
+                }
+                table[idx] = key;
+                assigned[idx] = true;
+            }
+
+            // Handle phase, default variant.
+            Assign(
+                RegistrationMethod.Targeted,
+                new SlotKey(DispatchKind.Targeted, DispatchPhase.Handle, DispatchVariant.Default)
+            );
+            Assign(
+                RegistrationMethod.Untargeted,
+                new SlotKey(DispatchKind.Untargeted, DispatchPhase.Handle, DispatchVariant.Default)
+            );
+            Assign(
+                RegistrationMethod.Broadcast,
+                new SlotKey(DispatchKind.Broadcast, DispatchPhase.Handle, DispatchVariant.Default)
+            );
+
+            // Handle phase, without-context variant.
+            Assign(
+                RegistrationMethod.BroadcastWithoutSource,
+                new SlotKey(
+                    DispatchKind.Broadcast,
+                    DispatchPhase.Handle,
+                    DispatchVariant.WithoutContext
+                )
+            );
+            Assign(
+                RegistrationMethod.TargetedWithoutTargeting,
+                new SlotKey(
+                    DispatchKind.Targeted,
+                    DispatchPhase.Handle,
+                    DispatchVariant.WithoutContext
+                )
+            );
+
+            // Sentinel mappings: multi-slot / out-of-scope.
+            Assign(RegistrationMethod.GlobalAcceptAll, SlotKey.None);
+            Assign(RegistrationMethod.Interceptor, SlotKey.None);
+
+            // Post-process phase, default variant.
+            Assign(
+                RegistrationMethod.UntargetedPostProcessor,
+                new SlotKey(
+                    DispatchKind.Untargeted,
+                    DispatchPhase.PostProcess,
+                    DispatchVariant.Default
+                )
+            );
+            Assign(
+                RegistrationMethod.TargetedPostProcessor,
+                new SlotKey(
+                    DispatchKind.Targeted,
+                    DispatchPhase.PostProcess,
+                    DispatchVariant.Default
+                )
+            );
+            Assign(
+                RegistrationMethod.BroadcastPostProcessor,
+                new SlotKey(
+                    DispatchKind.Broadcast,
+                    DispatchPhase.PostProcess,
+                    DispatchVariant.Default
+                )
+            );
+
+            // Post-process phase, without-context variant.
+            Assign(
+                RegistrationMethod.TargetedWithoutTargetingPostProcessor,
+                new SlotKey(
+                    DispatchKind.Targeted,
+                    DispatchPhase.PostProcess,
+                    DispatchVariant.WithoutContext
+                )
+            );
+            Assign(
+                RegistrationMethod.BroadcastWithoutSourcePostProcessor,
+                new SlotKey(
+                    DispatchKind.Broadcast,
+                    DispatchPhase.PostProcess,
+                    DispatchVariant.WithoutContext
+                )
+            );
+
+            // Validate that every enum value received an explicit mapping.
+            for (int i = 0; i < values.Length; i++)
+            {
+                int raw = (int)values.GetValue(i);
+                if (!assigned[raw])
+                {
+                    throw new InvalidOperationException(
+                        "RegistrationMethodAxes is missing a mapping for "
+                            + (RegistrationMethod)raw
+                            + " (ordinal "
+                            + raw
+                            + "). Every RegistrationMethod must map to a SlotKey or SlotKey.None."
+                    );
+                }
+            }
+
+            // Tighten validation: walk every ordinal in [0..max]. Any unassigned
+            // index that does NOT correspond to a defined enum value is a gap
+            // (e.g. left behind by an [Obsolete]-removed member or sparse enum
+            // numbering) and would otherwise silently route into the Untargeted
+            // slot via default(SlotKey). SlotKey.None is the only safe sentinel
+            // for unmapped ordinals; gap ordinals must fail at type-init.
+            bool[] defined = new bool[max + 1];
+            for (int i = 0; i < values.Length; i++)
+            {
+                defined[(int)values.GetValue(i)] = true;
+            }
+            for (int i = 0; i <= max; i++)
+            {
+                if (!assigned[i] && !defined[i])
+                {
+                    throw new InvalidOperationException(
+                        "RegistrationMethodAxes ordinal "
+                            + i
+                            + " between defined values is unassigned. "
+                            + "Sparse RegistrationMethod ordinals are not supported; "
+                            + "every ordinal in [0..max] must map to a SlotKey or SlotKey.None."
+                    );
+                }
+            }
+
+            return table;
+        }
+    }
+}

package/Runtime/Core/MessageBus/Internal/RegistrationMethodAxes.cs.meta

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

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

@@ -0,0 +1,192 @@
+namespace DxMessaging.Core.MessageBus.Internal
+{
+    using System;
+    using System.Runtime.CompilerServices;
+
+    /// <summary>
+    /// Bit-packed coordinate that identifies a single dispatch slot along three
+    /// axes: <see cref="DispatchKind"/>, <see cref="DispatchPhase"/>, and
+    /// <see cref="DispatchVariant"/>. The byte-sized layout lets the bus index
+    /// into a small fixed-size array of slots without per-axis branching on the
+    /// hot dispatch path.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Bit layout of <see cref="Packed"/>: <c>KKKK P VVV</c> where K is the
+    /// 4-bit <see cref="DispatchKind"/>, P is the 1-bit
+    /// <see cref="DispatchPhase"/>, and V is the 3-bit
+    /// <see cref="DispatchVariant"/>. The exact formula is
+    /// <c>packed = (kind &lt;&lt; 4) | (phase &lt;&lt; 3) | variant</c>.
+    /// </para>
+    /// <para>
+    /// The sentinel value <see cref="None"/> uses <c>packed = 0xFF</c> and
+    /// represents "no axis applies" -- it is returned for registration methods
+    /// (such as <see cref="DxMessaging.Core.MessageBus.RegistrationMethod.Interceptor"/>
+    /// and <see cref="DxMessaging.Core.MessageBus.RegistrationMethod.GlobalAcceptAll"/>)
+    /// whose dispatch is multi-slot or otherwise outside the axis grid.
+    /// </para>
+    /// <para>
+    /// <c>default(SlotKey)</c> is bit-identical to
+    /// <c>new SlotKey(DispatchKind.Untargeted, DispatchPhase.Handle, DispatchVariant.Default)</c>.
+    /// This is intentional -- uninitialized <see cref="SlotKey"/> fields decode
+    /// to a real, valid slot. Use <see cref="None"/> (packed = 0xFF) as the
+    /// sentinel for "no slot applies"; never use <c>default(SlotKey)</c> as a
+    /// sentinel.
+    /// </para>
+    /// </remarks>
+    internal readonly struct SlotKey : IEquatable<SlotKey>
+    {
+        private const int KindShift = 4;
+        private const int PhaseShift = 3;
+        private const byte KindMask = 0x0F;
+        private const byte PhaseMask = 0x01;
+        private const byte VariantMask = 0x07;
+
+        private const byte NonePacked = 0xFF;
+
+        /// <summary>
+        /// Sentinel slot key that represents "no axis applies". Distinct from
+        /// <c>default(SlotKey)</c>; equality with <c>default</c> is false.
+        /// </summary>
+        /// <remarks>
+        /// 0xFF is unreachable from the public ctor by construction; the ctor explicitly rejects the (15, 1, 7) triple.
+        /// </remarks>
+        public static readonly SlotKey None = new SlotKey(unpacked: NonePacked);
+
+        /// <summary>
+        /// The packed byte representation. Layout is
+        /// <c>(kind &lt;&lt; 4) | (phase &lt;&lt; 3) | variant</c>; the sentinel
+        /// <see cref="None"/> uses <c>0xFF</c>.
+        /// </summary>
+        public readonly byte Packed;
+
+        /// <summary>
+        /// Constructs a slot key from its three component axes.
+        /// </summary>
+        /// <param name="kind">Dispatch kind. Must fit in 4 bits (0..15).</param>
+        /// <param name="phase">Dispatch phase. Must fit in 1 bit (0..1).</param>
+        /// <param name="variant">Dispatch variant. Must fit in 3 bits (0..7).</param>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// Thrown when any axis exceeds the bits allotted for it.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        /// Thrown when the <c>(kind, phase, variant)</c> triple packs to the
+        /// reserved <see cref="None"/> sentinel bit pattern (<c>0xFF</c>),
+        /// i.e. <c>(15, 1, 7)</c>.
+        /// </exception>
+        public SlotKey(DispatchKind kind, DispatchPhase phase, DispatchVariant variant)
+        {
+            byte k = (byte)kind;
+            byte p = (byte)phase;
+            byte v = (byte)variant;
+            if (k > KindMask)
+            {
+                throw new ArgumentOutOfRangeException(
+                    nameof(kind),
+                    k,
+                    "DispatchKind must fit in 4 bits (0..15)."
+                );
+            }
+            if (p > PhaseMask)
+            {
+                throw new ArgumentOutOfRangeException(
+                    nameof(phase),
+                    p,
+                    "DispatchPhase must fit in 1 bit (0..1)."
+                );
+            }
+            if (v > VariantMask)
+            {
+                throw new ArgumentOutOfRangeException(
+                    nameof(variant),
+                    v,
+                    "DispatchVariant must fit in 3 bits (0..7)."
+                );
+            }
+            byte packed = (byte)((k << KindShift) | (p << PhaseShift) | v);
+            if (packed == NonePacked)
+            {
+                throw new ArgumentException(
+                    "(kind, phase, variant) triple packs to the SlotKey.None sentinel. "
+                        + "The bit pattern 0xFF is reserved for SlotKey.None and cannot be "
+                        + "constructed via the public ctor, i.e. (kind=15, phase=1, variant=7).",
+                    nameof(variant)
+                );
+            }
+            Packed = packed;
+        }
+
+        private SlotKey(byte unpacked)
+        {
+            Packed = unpacked;
+        }
+
+        /// <summary>The decoded <see cref="DispatchKind"/> axis.</summary>
+        public DispatchKind Kind
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => (DispatchKind)((Packed >> KindShift) & KindMask);
+        }
+
+        /// <summary>The decoded <see cref="DispatchPhase"/> axis.</summary>
+        public DispatchPhase Phase
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => (DispatchPhase)((Packed >> PhaseShift) & PhaseMask);
+        }
+
+        /// <summary>The decoded <see cref="DispatchVariant"/> axis.</summary>
+        public DispatchVariant Variant
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => (DispatchVariant)(Packed & VariantMask);
+        }
+
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(SlotKey other)
+        {
+            return Packed == other.Packed;
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            return obj is SlotKey other && Equals(other);
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return Packed;
+        }
+
+        /// <summary>Equality operator. Compares the packed byte value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool operator ==(SlotKey left, SlotKey right)
+        {
+            return left.Packed == right.Packed;
+        }
+
+        /// <summary>Inequality operator. Compares the packed byte value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool operator !=(SlotKey left, SlotKey right)
+        {
+            return left.Packed != right.Packed;
+        }
+
+        /// <summary>
+        /// Returns "None" for the <see cref="None"/> sentinel; otherwise
+        /// returns a slash-delimited triple of the form
+        /// <c>"{Kind}/{Phase}/{Variant}"</c>.
+        /// </summary>
+        public override string ToString()
+        {
+            if (Packed == NonePacked)
+            {
+                return "None";
+            }
+            return Kind + "/" + Phase + "/" + Variant;
+        }
+    }
+}

package/Runtime/Core/MessageBus/Internal/SlotKey.cs.meta

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