com.wallstop-studios.dxmessaging 2.0.0-rc16 → 2.0.0-rc17

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxMessageIdGenerator.cs

@@ -0,0 +1,445 @@
+namespace WallstopStudios.DxMessaging.SourceGenerators;
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+
+[Generator(LanguageNames.CSharp)]
+public sealed class DxMessageIdGenerator : IIncrementalGenerator
+{
+    // --- Constants for Attributes and Interfaces ---
+    private const string BaseInterfaceFullName = "DxMessaging.Core.IMessage"; // Base interface
+
+    private const string BroadcastAttrFullName =
+        "DxMessaging.Core.Attributes.DxBroadcastMessageAttribute";
+    private const string TargetedAttrFullName =
+        "DxMessaging.Core.Attributes.DxTargetedMessageAttribute";
+    private const string UntargetedAttrFullName =
+        "DxMessaging.Core.Attributes.DxUntargetedMessageAttribute";
+
+    private const string BroadcastInterfaceFullName = "DxMessaging.Core.Messages.IBroadcastMessage";
+    private const string TargetedInterfaceFullName = "DxMessaging.Core.Messages.ITargetedMessage";
+    private const string UntargetedInterfaceFullName =
+        "DxMessaging.Core.Messages.IUntargetedMessage";
+
+    // --- Diagnostics ---
+    private static readonly DiagnosticDescriptor CollisionError = new DiagnosticDescriptor(
+        id: "DXMSG001",
+        title: "Message ID Collision",
+        messageFormat: "OptimizedMessageId collision detected across different message types. The generated ID '{0}' is shared by the following types: {1}. Please rename one or more types slightly to resolve the hash collision.",
+        category: "DxMessaging",
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true
+    );
+
+    private static readonly DiagnosticDescriptor CollisionWarning = new DiagnosticDescriptor(
+        id: "DXMSG003", // New ID
+        title: "Message ID Collision Fallback",
+        messageFormat: "OptimizedMessageId collision detected for ID '{0}'. The following types will use a fallback implementation (HasOptimizedId = false): {1}.",
+        category: "DxMessaging",
+        defaultSeverity: DiagnosticSeverity.Warning, // Set severity to Warning
+        isEnabledByDefault: true
+    );
+
+    private static readonly DiagnosticDescriptor MultipleAttributesError = new DiagnosticDescriptor(
+        id: "DXMSG002",
+        title: "Multiple Message Attributes",
+        messageFormat: "Type '{0}' cannot have more than one Dx message attribute ([DxBroadcastMessage], [DxTargetedMessage], [DxUntargetedMessage]).",
+        category: "DxMessaging",
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true
+    );
+
+    // Helper record to pass data through the pipeline
+    private record struct SemanticTargetInfo(
+        INamedTypeSymbol TypeSymbol,
+        TypeDeclarationSyntax DeclarationSyntax,
+        string TargetInterfaceFullName
+    );
+
+    // Helper record for final processing stage
+    private record struct MessageInfo(
+        INamedTypeSymbol TypeSymbol,
+        TypeDeclarationSyntax DeclarationSyntax,
+        string TargetInterfaceFullName,
+        int GeneratedId
+    );
+
+    // Helper record for final assignment stage
+    private record struct FinalMessageInfo(
+        INamedTypeSymbol TypeSymbol,
+        TypeDeclarationSyntax DeclarationSyntax,
+        string TargetInterfaceFullName,
+        int FinalId, // The ID actually assigned (hash or fallback)
+        bool WasCollision
+    ); // Flag indicating if it was part of a collision
+
+    public void Initialize(IncrementalGeneratorInitializationContext context)
+    {
+        // --- Step 1: Find all classes/structs with attribute lists (Potential Candidates) ---
+        IncrementalValuesProvider<TypeDeclarationSyntax> potentialTypeDeclarations =
+            context.SyntaxProvider.CreateSyntaxProvider(
+                predicate: static (node, _) => IsSyntaxTargetForGeneration(node), // Quick syntax filter
+                transform: static (ctx, ct) => (TypeDeclarationSyntax)ctx.Node
+            ); // Just pass the node
+
+        // --- Step 2: Get Semantic Info and Filter by Attributes ---
+        IncrementalValuesProvider<SemanticTargetInfo?> semanticTargets = potentialTypeDeclarations
+            .Select(static (typeDecl, ct) => new { typeDecl, ct }) // Combine with CancellationToken if needed implicitly by GetSemanticTargetForGeneration
+            .Combine(context.CompilationProvider)
+            .Select(
+                static (data, ct) =>
+                    GetSemanticTargetForGeneration(data.Left.typeDecl, data.Right, ct)
+            );
+
+        // --- Step 3: Filter out invalid targets ---
+        IncrementalValuesProvider<SemanticTargetInfo> validSemanticTargets = semanticTargets
+            .Where(static target => target.HasValue)
+            .Select(static (target, _) => target!.Value); // Use non-null assertion or keep filtering
+
+        // --- Step 4: Calculate Hash IDs ---
+        IncrementalValuesProvider<MessageInfo> typesWithIds = validSemanticTargets.Select(
+            static (target, ct) =>
+            {
+                string fullyQualifiedName = target.TypeSymbol.ToDisplayString(
+                    SymbolDisplayFormat.FullyQualifiedFormat
+                );
+                int generatedId = ComputeStableHashCode(fullyQualifiedName);
+                return new MessageInfo(
+                    target.TypeSymbol,
+                    target.DeclarationSyntax,
+                    target.TargetInterfaceFullName,
+                    generatedId
+                );
+            }
+        );
+
+        // --- Step 5: Collect all valid types with IDs ---
+        IncrementalValueProvider<(Compilation, ImmutableArray<MessageInfo>)> compilationAndTypes =
+            context.CompilationProvider.Combine(typesWithIds.Collect());
+
+        // --- Step 6: Generate source or diagnostics ---
+        context.RegisterSourceOutput(
+            compilationAndTypes,
+            static (spc, source) => Execute(source.Item1, source.Item2, spc)
+        );
+    }
+
+    // Quick syntax filter: Checks if the node is a class or struct with any attributes
+    private static bool IsSyntaxTargetForGeneration(SyntaxNode node) =>
+        node is TypeDeclarationSyntax { AttributeLists.Count: > 0 } typeDecl
+        && (
+            typeDecl.IsKind(SyntaxKind.ClassDeclaration)
+            || typeDecl.IsKind(SyntaxKind.StructDeclaration)
+        );
+
+    // Semantic filter: Checks if the type has exactly one of the target attributes
+    private static SemanticTargetInfo? GetSemanticTargetForGeneration(
+        TypeDeclarationSyntax typeDeclarationSyntax,
+        Compilation compilation,
+        CancellationToken cancellationToken
+    )
+    {
+        SemanticModel semanticModel = compilation.GetSemanticModel(
+            typeDeclarationSyntax.SyntaxTree
+        );
+        if (
+            semanticModel.GetDeclaredSymbol(typeDeclarationSyntax, cancellationToken)
+            is not INamedTypeSymbol typeSymbol
+        )
+        {
+            return null;
+        }
+
+        string? foundTargetInterface = null;
+        bool multipleAttributes = false;
+
+        foreach (AttributeData attributeData in typeSymbol.GetAttributes())
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (attributeData.AttributeClass == null)
+                continue;
+
+            string currentAttributeFullName = attributeData.AttributeClass.ToDisplayString();
+            string? targetInterfaceForThisAttribute = null;
+
+            switch (currentAttributeFullName)
+            {
+                case BroadcastAttrFullName:
+                    targetInterfaceForThisAttribute = BroadcastInterfaceFullName;
+                    break;
+                case TargetedAttrFullName:
+                    targetInterfaceForThisAttribute = TargetedInterfaceFullName;
+                    break;
+                case UntargetedAttrFullName:
+                    targetInterfaceForThisAttribute = UntargetedInterfaceFullName;
+                    break;
+            }
+
+            if (targetInterfaceForThisAttribute != null)
+            {
+                if (foundTargetInterface != null)
+                {
+                    // Found more than one relevant attribute!
+                    multipleAttributes = true;
+                    break; // No need to check further attributes
+                }
+                foundTargetInterface = targetInterfaceForThisAttribute;
+            }
+        }
+
+        if (multipleAttributes || foundTargetInterface == null)
+        {
+            // Report error for multiple attributes later in Execute if needed,
+            // but don't consider this a valid target for generation now.
+            // If foundTargetInterface is null, it didn't have any relevant attribute.
+            return null;
+        }
+
+        // Found exactly one relevant attribute
+        return new SemanticTargetInfo(typeSymbol, typeDeclarationSyntax, foundTargetInterface);
+    }
+
+    // --- Main execution logic: collision check, warning, and source generation ---
+    private static void Execute(
+        Compilation compilation,
+        ImmutableArray<MessageInfo> typesToGenerate,
+        SourceProductionContext context
+    )
+    {
+        if (typesToGenerate.IsDefaultOrEmpty)
+        {
+            return; // Nothing to do
+        }
+
+        var validTypes = new List<MessageInfo>(typesToGenerate.Length);
+        var typesWithMultipleAttributes = new HashSet<ISymbol>(SymbolEqualityComparer.Default);
+        var generatedIds = new HashSet<int>();
+
+        // --- Step 1: Check for Multiple Attributes on the same type ---
+        var groupedByType = typesToGenerate.GroupBy(
+            m => m.TypeSymbol,
+            SymbolEqualityComparer.Default
+        );
+
+        foreach (var group in groupedByType)
+        {
+            if (group.Count() > 1)
+            {
+                ISymbol collidingSymbol = group.Key;
+                typesWithMultipleAttributes.Add(collidingSymbol);
+                context.ReportDiagnostic(
+                    Diagnostic.Create(
+                        MultipleAttributesError,
+                        collidingSymbol.Locations.FirstOrDefault() ?? Location.None,
+                        collidingSymbol.ToDisplayString()
+                    )
+                );
+            }
+            else
+            {
+                // Add types with only one attribute to the list for further processing
+                validTypes.Add(group.First());
+            }
+        }
+
+        // If no types remain after filtering multi-attribute ones, exit
+        if (validTypes.Count == 0)
+        {
+            return;
+        }
+
+        // --- Step 2: Assign Final IDs (Handling Collisions) ---
+        var finalAssignments = new List<FinalMessageInfo>(validTypes.Count);
+        var collisionWarnings = new List<Diagnostic>(); // Collect warnings
+        int fallbackIdCounter = -1; // Start fallback IDs from -1 and go down
+
+        // Group by the initial hash ID to find collisions
+        var groupedByHash = validTypes.GroupBy(m => m.GeneratedId);
+
+        foreach (var group in groupedByHash)
+        {
+            if (group.Count() == 1)
+            {
+                // No collision for this hash ID
+                var info = group.First();
+                generatedIds.Add(info.GeneratedId);
+                finalAssignments.Add(
+                    new FinalMessageInfo(
+                        info.TypeSymbol,
+                        info.DeclarationSyntax,
+                        info.TargetInterfaceFullName,
+                        info.GeneratedId,
+                        false
+                    )
+                );
+            }
+            else
+            {
+                // Collision detected for this hash ID!
+                // Sort colliding types deterministically (e.g., by fully qualified name)
+                var sortedCollidingTypes = group
+                    .OrderBy(
+                        m => m.TypeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat),
+                        StringComparer.Ordinal
+                    )
+                    .ToList();
+
+                // The first type keeps the original hash ID (arbitrary but deterministic choice)
+                var firstInfo = sortedCollidingTypes[0];
+                generatedIds.Add(firstInfo.GeneratedId);
+                finalAssignments.Add(
+                    new FinalMessageInfo(
+                        firstInfo.TypeSymbol,
+                        firstInfo.DeclarationSyntax,
+                        firstInfo.TargetInterfaceFullName,
+                        firstInfo.GeneratedId,
+                        true
+                    )
+                ); // Mark as part of collision
+                // Prepare warning for this type (kept original ID but was part of collision)
+                collisionWarnings.Add(
+                    Diagnostic.Create(
+                        CollisionWarning,
+                        firstInfo.DeclarationSyntax.Identifier.GetLocation(),
+                        firstInfo.TypeSymbol.ToDisplayString(),
+                        firstInfo.GeneratedId,
+                        group.Key
+                    )
+                );
+
+                // Assign sequential fallback IDs (negative numbers) to the rest
+                for (int i = 1; i < sortedCollidingTypes.Count; i++)
+                {
+                    var fallbackInfo = sortedCollidingTypes[i];
+                    int assignedFallbackId = fallbackIdCounter--; // Assign next negative ID
+                    while (!generatedIds.Add(assignedFallbackId))
+                    {
+                        assignedFallbackId--;
+                    }
+                    finalAssignments.Add(
+                        new FinalMessageInfo(
+                            fallbackInfo.TypeSymbol,
+                            fallbackInfo.DeclarationSyntax,
+                            fallbackInfo.TargetInterfaceFullName,
+                            assignedFallbackId,
+                            true
+                        )
+                    ); // Mark as part of collision, use new ID
+                    // Prepare warning for this type (received fallback ID)
+                    collisionWarnings.Add(
+                        Diagnostic.Create(
+                            CollisionWarning,
+                            fallbackInfo.DeclarationSyntax.Identifier.GetLocation(),
+                            fallbackInfo.TypeSymbol.ToDisplayString(),
+                            assignedFallbackId,
+                            group.Key
+                        )
+                    );
+                }
+            }
+        }
+
+        // --- Step 3: Report all collected warnings ---
+        foreach (var warning in collisionWarnings)
+        {
+            context.ReportDiagnostic(warning);
+        }
+
+        // --- Step 4: Generate Source using the final assigned IDs ---
+        foreach (var finalInfo in finalAssignments)
+        {
+            context.CancellationToken.ThrowIfCancellationRequested();
+
+            // Generate source using the final ID (hash or fallback)
+            string source = GenerateSource( // Call simplified GenerateSource
+                finalInfo.TargetInterfaceFullName,
+                finalInfo.TypeSymbol,
+                finalInfo.FinalId
+            ); // Pass the FINAL ID
+
+            context.AddSource(
+                $"{finalInfo.TypeSymbol.Name}_{finalInfo.TargetInterfaceFullName.Split('.').Last()}.g.cs",
+                SourceText.From(source, Encoding.UTF8)
+            );
+        }
+    }
+
+    // --- Stable Hash Function (FNV-1a - remains the same) ---
+    private static int ComputeStableHashCode(string text)
+    {
+        unchecked
+        {
+            uint hash = 2166136261;
+            foreach (char c in text)
+            {
+                hash = (hash ^ c) * 16777619;
+            }
+            return (int)hash;
+        }
+    }
+
+    // --- Source Generation Logic (Takes target interface name AND optimization flag) ---
+    private static string GenerateSource(
+        string targetInterfaceFullName,
+        INamedTypeSymbol typeSymbol,
+        int finalAssignedId
+    ) // Now takes the final assigned ID
+    {
+        string namespaceName = typeSymbol.ContainingNamespace.IsGlobalNamespace
+            ? string.Empty
+            : typeSymbol.ContainingNamespace.ToDisplayString();
+
+        string typeNameWithGenerics = typeSymbol.ToDisplayString(
+            SymbolDisplayFormat.MinimallyQualifiedFormat
+        );
+        string fullyQualifiedName = typeSymbol.ToDisplayString(
+            SymbolDisplayFormat.FullyQualifiedFormat
+        );
+
+        string typeKind = typeSymbol.TypeKind switch
+        {
+            TypeKind.Class => "class",
+            TypeKind.Struct => "struct",
+            _ => throw new InvalidOperationException(
+                "Unsupported type kind for message generation"
+            ),
+        };
+
+        bool alreadyDeclaresInterface = typeSymbol.Interfaces.Any(iface =>
+            iface.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)
+            == targetInterfaceFullName
+        );
+
+        string interfaceDeclaration = alreadyDeclaresInterface
+            ? ""
+            : $": {targetInterfaceFullName}";
+
+        return $$"""
+            // <auto-generated by DxMessageIdGenerator/>
+            #pragma warning disable
+            #nullable enable annotations
+
+            namespace {{namespaceName}}
+            {
+                partial {{typeKind}} {{typeNameWithGenerics}} {{interfaceDeclaration}}
+                {
+                    // Explicitly implement IMessage members using the base interface name
+
+                    /// <inheritdoc/>
+                    System.Type {{BaseInterfaceFullName}}.MessageType => typeof({{fullyQualifiedName}});
+
+                    /// <inheritdoc/>
+                    int? {{BaseInterfaceFullName}}.OptimizedMessageId => {{finalAssignedId}};
+                }
+            }
+            """;
+    }
+}

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxMessageIdGenerator.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8525b467bd2c430a90ccee97f321a845
+timeCreated: 1744403125

package/Tests/Runtime/Benchmarks/PerformanceTests.cs

@@ -17,12 +17,14 @@
 
     public sealed class PerformanceTests : MessagingTestBase
     {
+        private const int NumInvocationsPerIteration = 250;
+
         protected override bool MessagingDebugEnabled => false;
 
         [Test]
         public void Benchmark()
         {
-            TimeSpan timeout = TimeSpan.FromSeconds(2);
+            TimeSpan timeout = TimeSpan.FromSeconds(5);
 
             Debug.Log("| Message Tech | Operations / Second | Allocations? |");
             Debug.Log("| ------------ | ------------------- | ------------ | ");
@@ -190,10 +192,13 @@
             timer.Restart();
             do
             {
-                target.SendMessage(
-                    nameof(SimpleMessageAwareComponent.HandleSlowComplexTargetedMessage),
-                    message
-                );
+                for (int i = 0; i < NumInvocationsPerIteration; ++i)
+                {
+                    target.SendMessage(
+                        nameof(SimpleMessageAwareComponent.HandleSlowComplexTargetedMessage),
+                        message
+                    );
+                }
             } while (timer.Elapsed < timeout);
 
             bool allocating;
@@ -227,19 +232,23 @@
             var token = GetToken(component);
 
             GameObject go = component.gameObject;
+            InstanceId target = go;
             token.RegisterGameObjectTargeted<ComplexTargetedMessage>(go, Handle);
             // Pre-warm
-            message.EmitGameObjectTargeted(go);
+            message.EmitTargeted(target);
 
             timer.Restart();
             do
             {
-                message.EmitGameObjectTargeted(go);
+                for (int i = 0; i < NumInvocationsPerIteration; ++i)
+                {
+                    message.EmitTargeted(target);
+                }
             } while (timer.Elapsed < timeout);
             bool allocating;
             try
             {
-                Assert.That(() => message.EmitGameObjectTargeted(go), Is.Not.AllocatingGCMemory());
+                Assert.That(() => message.EmitTargeted(target), Is.Not.AllocatingGCMemory());
                 allocating = false;
             }
             catch
@@ -265,24 +274,25 @@
         {
             int count = 0;
             var token = GetToken(component);
+            InstanceId target = component;
 
             token.RegisterComponentTargeted<ComplexTargetedMessage>(component, Handle);
             // Pre-warm
-            message.EmitComponentTargeted(component);
+            message.EmitTargeted(target);
 
             timer.Restart();
             do
             {
-                message.EmitComponentTargeted(component);
+                for (int i = 0; i < NumInvocationsPerIteration; ++i)
+                {
+                    message.EmitTargeted(target);
+                }
             } while (timer.Elapsed < timeout);
 
             bool allocating;
             try
             {
-                Assert.That(
-                    () => message.EmitComponentTargeted(component),
-                    Is.Not.AllocatingGCMemory()
-                );
+                Assert.That(() => message.EmitTargeted(target), Is.Not.AllocatingGCMemory());
                 allocating = false;
             }
             catch
@@ -309,22 +319,23 @@
             var token = GetToken(component);
 
             GameObject go = component.gameObject;
+            InstanceId target = go;
             token.RegisterGameObjectTargeted<ComplexTargetedMessage>(go, Handle);
             // Pre-warm
-            message.EmitGameObjectTargeted(component.gameObject);
+            message.EmitTargeted(target);
 
             timer.Restart();
             do
             {
-                message.EmitGameObjectTargeted(component.gameObject);
+                for (int i = 0; i < NumInvocationsPerIteration; ++i)
+                {
+                    message.EmitTargeted(target);
+                }
             } while (timer.Elapsed < timeout);
             bool allocating;
             try
             {
-                Assert.That(
-                    () => message.EmitGameObjectTargeted(component.gameObject),
-                    Is.Not.AllocatingGCMemory()
-                );
+                Assert.That(() => message.EmitTargeted(target), Is.Not.AllocatingGCMemory());
                 allocating = false;
             }
             catch
@@ -349,6 +360,7 @@
         {
             int count = 0;
             var token = GetToken(component);
+            InstanceId target = component;
 
             token.RegisterComponentTargeted<ComplexTargetedMessage>(component, Handle);
             // Pre-warm
@@ -357,16 +369,16 @@
             timer.Restart();
             do
             {
-                message.EmitComponentTargeted(component);
+                for (int i = 0; i < NumInvocationsPerIteration; ++i)
+                {
+                    message.EmitTargeted(target);
+                }
             } while (timer.Elapsed < timeout);
 
             bool allocating;
             try
             {
-                Assert.That(
-                    () => message.EmitComponentTargeted(component),
-                    Is.Not.AllocatingGCMemory()
-                );
+                Assert.That(() => message.EmitTargeted(target), Is.Not.AllocatingGCMemory());
                 allocating = false;
             }
             catch
@@ -399,7 +411,10 @@
             timer.Restart();
             do
             {
-                message.EmitUntargeted();
+                for (int i = 0; i < NumInvocationsPerIteration; ++i)
+                {
+                    message.EmitUntargeted();
+                }
             } while (timer.Elapsed < timeout);
 
             bool allocating;

package/Tests/Runtime/Scripts/Components/GenericMessageAwareComponent.cs

@@ -0,0 +1,19 @@
+namespace DxMessaging.Tests.Runtime.Scripts.Components
+{
+    using Messages;
+    using Unity;
+    using UnityEngine;
+
+    [DisallowMultipleComponent]
+    public sealed class GenericMessageAwareComponent : MessageAwareComponent
+    {
+        protected override void RegisterMessageHandlers()
+        {
+            base.RegisterMessageHandlers();
+            _ = _messageRegistrationToken.RegisterUntargeted(
+                (ref GenericUntargetedMessage<int> message) =>
+                    Debug.Log("Received generic int message.")
+            );
+        }
+    }
+}

package/Tests/Runtime/Scripts/Components/GenericMessageAwareComponent.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3b5b962e8c244838be18e01d1a47542c
+timeCreated: 1744426157

package/Tests/Runtime/Scripts/Messages/GenericUntargetedMessage.cs

@@ -0,0 +1,7 @@
+namespace DxMessaging.Tests.Runtime.Scripts.Messages
+{
+    using DxMessaging.Core.Attributes;
+
+    [DxUntargetedMessage]
+    public readonly partial struct GenericUntargetedMessage<T> { }
+}

package/Tests/Runtime/Scripts/Messages/GenericUntargetedMessage.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f1e39abb3eaa468daa20f7d3d50052d1
+timeCreated: 1744425432

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "com.wallstop-studios.dxmessaging",
-  "version": "2.0.0-rc16",
+  "version": "2.0.0-rc17",
   "displayName": "DxMessaging",
   "description": "Synchronous Event Bus for Unity",
   "unity": "2021.3",
   "dependencies": {
-    "com.wallstop-studios.unity-helpers" : "2.0.0-rc50"
+    "com.wallstop-studios.unity-helpers" : "2.0.0-rc58"
   },
   "keywords": [
     "messaging",

package/Runtime/Core/Attributes/DxAutoMessageTypeAttribute.cs

@@ -1,7 +0,0 @@
-namespace DxMessaging.Core.Attributes
-{
-    using System;
-
-    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)]
-    public sealed class DxAutoMessageTypeAttribute : Attribute { }
-}

package/Runtime/Core/Attributes/DxAutoMessageTypeAttribute.cs.meta

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: 01e2bf7a935a4389be6e63a79b36723e
-timeCreated: 1730779085