com.wallstop-studios.dxmessaging 2.1.1 → 2.1.3

package/Runtime/Unity/Integrations/Reflex/ReflexRegistrationInstaller.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Unity.Integrations.Reflex
 {
 #if REFLEX_PRESENT
@@ -10,6 +11,10 @@ namespace DxMessaging.Unity.Integrations.Reflex
     /// </summary>
     public sealed class DxMessagingRegistrationInstaller : IInstaller
     {
+        /// <summary>
+        /// Registers the DxMessaging builder services within the Reflex container.
+        /// </summary>
+        /// <param name="containerBuilder">Container builder receiving the registrations.</param>
         public void InstallBindings(ContainerBuilder containerBuilder)
         {
             containerBuilder.AddSingleton(
@@ -24,6 +29,11 @@ namespace DxMessaging.Unity.Integrations.Reflex
             [Inject]
             private Container _container;
 
+            /// <summary>
+            /// Builds a leasing wrapper using the container-aware provider resolution logic.
+            /// </summary>
+            /// <param name="options">Build options provided by the caller.</param>
+            /// <returns>Lease produced by the underlying <see cref="MessageRegistrationBuilder"/>.</returns>
             public MessageRegistrationLease Build(MessageRegistrationBuildOptions options)
             {
                 MessageRegistrationBuilder innerBuilder = ResolveInnerBuilder();
@@ -58,11 +68,19 @@ namespace DxMessaging.Unity.Integrations.Reflex
         {
             private readonly Container _container;
 
+            /// <summary>
+            /// Wraps a Reflex container as an <see cref="IMessageBusProvider"/>.
+            /// </summary>
+            /// <param name="container">Container used to resolve <see cref="IMessageBus"/> instances.</param>
             public ContainerMessageBusProvider(Container container)
             {
                 _container = container;
             }
 
+            /// <summary>
+            /// Resolves an <see cref="IMessageBus"/> from the underlying container.
+            /// </summary>
+            /// <returns>Message bus resolved from Reflex.</returns>
             public IMessageBus Resolve()
             {
                 return _container.Resolve<IMessageBus>();
@@ -71,3 +89,4 @@ namespace DxMessaging.Unity.Integrations.Reflex
     }
 #endif
 }
+#endif

package/Runtime/Unity/Integrations/VContainer/VContainerRegistrationExtensions.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Unity.Integrations.VContainer
 {
 #if VCONTAINER_PRESENT
@@ -31,11 +32,19 @@ namespace DxMessaging.Unity.Integrations.VContainer
         {
             private readonly IObjectResolver _resolver;
 
+            /// <summary>
+            /// Wraps a VContainer resolver as an <see cref="IMessageBusProvider"/>.
+            /// </summary>
+            /// <param name="resolver">Resolver used to obtain <see cref="IMessageBus"/> instances.</param>
             public ResolverMessageBusProvider(IObjectResolver resolver)
             {
                 _resolver = resolver;
             }
 
+            /// <summary>
+            /// Resolves an <see cref="IMessageBus"/> from the current VContainer scope.
+            /// </summary>
+            /// <returns>Scoped message bus.</returns>
             public IMessageBus Resolve()
             {
                 return _resolver.Resolve<IMessageBus>();
@@ -44,3 +53,4 @@ namespace DxMessaging.Unity.Integrations.VContainer
     }
 #endif
 }
+#endif

package/Runtime/Unity/Integrations/Zenject/ZenjectRegistrationInstaller.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Unity.Integrations.Zenject
 {
 #if ZENJECT_PRESENT
@@ -15,6 +16,9 @@ namespace DxMessaging.Unity.Integrations.Zenject
             InstallBindings();
         }
 
+        /// <summary>
+        /// Registers the DxMessaging builder within the Zenject container.
+        /// </summary>
         public override void InstallBindings()
         {
             Container.Bind<IMessageRegistrationBuilder>().FromMethod(CreateBuilder).AsTransient();
@@ -39,12 +43,21 @@ namespace DxMessaging.Unity.Integrations.Zenject
             private readonly DiContainer _container;
             private readonly IMessageBus _cachedBus;
 
+            /// <summary>
+            /// Creates a provider that uses the container-supplied bus, falling back to resolving on demand.
+            /// </summary>
+            /// <param name="container">Zenject container used to resolve services.</param>
+            /// <param name="cachedBus">Cached bus instance to return if available.</param>
             public ContainerMessageBusProvider(DiContainer container, IMessageBus cachedBus)
             {
                 _container = container;
                 _cachedBus = cachedBus;
             }
 
+            /// <summary>
+            /// Resolves the message bus for the current scope.
+            /// </summary>
+            /// <returns>Cached bus if provided; otherwise resolves from the container.</returns>
             public IMessageBus Resolve()
             {
                 return _cachedBus ?? _container.Resolve<IMessageBus>();
@@ -53,3 +66,4 @@ namespace DxMessaging.Unity.Integrations.Zenject
     }
 #endif
 }
+#endif

package/Runtime/Unity/MessageAwareComponent.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Unity
 {
     using Core;
@@ -273,3 +274,4 @@ namespace DxMessaging.Unity
         }
     }
 }
+#endif

package/Runtime/Unity/MessageBusProviderHandle.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Unity
 {
     using System;
@@ -18,6 +19,8 @@ namespace DxMessaging.Unity
         [NonSerialized]
         private IMessageBusProvider _runtimeProvider;
 
+        internal ScriptableMessageBusProvider SerializedProvider => _provider;
+
         /// <summary>
         /// Initializes a new instance referencing the supplied provider asset.
         /// </summary>
@@ -95,3 +98,4 @@ namespace DxMessaging.Unity
         }
     }
 }
+#endif

package/Runtime/Unity/MessagingComponent.cs

@@ -1,7 +1,9 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Unity
 {
     using System;
     using System.Collections.Generic;
+    using System.Linq;
     using Core;
     using Core.MessageBus;
     using UnityEngine;
@@ -44,6 +46,20 @@ namespace DxMessaging.Unity
         internal readonly Dictionary<MonoBehaviour, MessageRegistrationToken> _registeredListeners =
             new();
 
+        internal bool AutoConfigureSerializedProviderOnAwake =>
+            autoConfigureSerializedProviderOnAwake;
+
+        internal bool HasRuntimeProvider => _messageBusProvider != null;
+
+        internal bool HasMessageBusOverride => _messageBusOverride != null;
+
+        internal bool HasSerializedProvider => _serializedProviderHandle.TryGetProvider(out _);
+
+        internal MessageBusProviderHandle SerializedProviderHandle => _serializedProviderHandle;
+
+        internal ScriptableMessageBusProvider SerializedProviderAsset =>
+            _serializedProviderHandle.SerializedProvider;
+
         /// <summary>
         /// Creates a <see cref="IMessageRegistrationBuilder"/> aligned with this component's configured bus or provider.
         /// </summary>
@@ -311,5 +327,98 @@ namespace DxMessaging.Unity
 
             return null;
         }
+
+#if UNITY_EDITOR
+        [ContextMenu("DxMessaging/Dump Registrations")]
+        private void ContextDumpRegistrations()
+        {
+            DumpRegistrations();
+        }
+
+        internal void DumpRegistrations()
+        {
+            if (_registeredListeners.Count == 0)
+            {
+                Debug.Log($"[DxMessaging] {name} has no registered listeners.");
+                return;
+            }
+
+            foreach (
+                KeyValuePair<MonoBehaviour, MessageRegistrationToken> pair in _registeredListeners
+            )
+            {
+                MonoBehaviour listener = pair.Key;
+                MessageRegistrationToken token = pair.Value;
+                Debug.Log(
+                    $"[DxMessaging] Listener '{listener}' (Enabled: {token.Enabled}, Diagnostic: {token.DiagnosticMode}) "
+                        + $"with {token._metadata.Count} registrations on '{name}'."
+                );
+            }
+        }
+
+        [ContextMenu("DxMessaging/Reset Runtime State")]
+        private void ContextResetRuntimeState()
+        {
+            if (EditorResetRuntimeState())
+            {
+                Debug.Log($"[DxMessaging] Cleared runtime state for '{name}'.");
+            }
+            else
+            {
+                Debug.Log($"[DxMessaging] No runtime state to clear on '{name}'.");
+            }
+        }
+
+        internal bool EditorResetRuntimeState()
+        {
+            bool cleared = false;
+
+            if (_registeredListeners.Count > 0)
+            {
+                foreach (MessageRegistrationToken token in _registeredListeners.Values.ToArray())
+                {
+                    try
+                    {
+                        if (token.Enabled)
+                        {
+                            token.Disable();
+                        }
+
+                        token.Dispose();
+                    }
+                    catch (Exception exception)
+                    {
+                        Debug.LogWarning(
+                            $"[DxMessaging] Disposing stale token on {name} failed. {exception}"
+                        );
+                    }
+                }
+
+                _registeredListeners.Clear();
+                cleared = true;
+            }
+
+            if (_messageHandler != null)
+            {
+                _messageHandler = null;
+                cleared = true;
+            }
+
+            if (_messageBusOverride != null)
+            {
+                _messageBusOverride = null;
+                cleared = true;
+            }
+
+            if (_messageBusProvider != null)
+            {
+                _messageBusProvider = null;
+                cleared = true;
+            }
+
+            return cleared;
+        }
+#endif
     }
 }
+#endif

package/Runtime/Unity/MessagingComponentInstaller.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Unity
 {
     using System.Collections.Generic;
@@ -118,3 +119,4 @@ namespace DxMessaging.Unity
         }
     }
 }
+#endif

package/Runtime/Unity/ScriptableMessageBusProvider.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Unity
 {
     using DxMessaging.Core.MessageBus;
@@ -12,3 +13,4 @@ namespace DxMessaging.Unity
         public abstract IMessageBus Resolve();
     }
 }
+#endif

package/Samples~/DI/README.md

@@ -13,18 +13,18 @@ These snippets illustrate how to consume `IMessageRegistrationBuilder` inside co
 
 Each sample shows:
 
-- Registering `IMessageRegistrationBuilder` via the provided shim under `Runtime/Unity/Integrations/`.
+- Registering `IMessageRegistrationBuilder` via the provided shim under [Runtime/Unity/Integrations](../../Runtime/Unity/Integrations/).
 - Constructing a `MessageRegistrationLease` in a container-managed service.
 - Activating/deactivating the lease using the container lifecycle.
 
 ### Structure
 
-- `Zenject/SampleInstaller.cs`
-- `VContainer/SampleLifetimeScope.cs`
-- `Reflex/SampleInstaller.cs`
-- `Providers/CurrentGlobalMessageBusProvider.asset` — ScriptableObject that resolves whichever bus is currently configured as global.
-- `Providers/InitialGlobalMessageBusProvider.asset` — ScriptableObject that always returns the original startup global bus, ignoring later overrides.
-- `Prefabs/MessagingInstallerSample.prefab` — ready-to-use hierarchy with `MessagingComponentInstaller` configuring a child `MessagingComponent` using the provider asset. Drop it into a scene to see provider-driven wiring without writing setup code.
+- Zenject sample installer: [SampleInstaller.cs](./Zenject/SampleInstaller.cs)
+- VContainer sample lifetime scope: [SampleLifetimeScope.cs](./VContainer/SampleLifetimeScope.cs)
+- Reflex sample installer: [SampleInstaller.cs](./Reflex/SampleInstaller.cs)
+- Current global message bus provider asset: [CurrentGlobalMessageBusProvider.asset](./Providers/CurrentGlobalMessageBusProvider.asset) — ScriptableObject that resolves whichever bus is currently configured as global.
+- Initial global message bus provider asset: [InitialGlobalMessageBusProvider.asset](./Providers/InitialGlobalMessageBusProvider.asset) — ScriptableObject that always returns the original startup global bus, ignoring later overrides.
+- Prefab setup: [MessagingInstallerSample.prefab](./Prefabs/MessagingInstallerSample.prefab) — ready-to-use hierarchy with `MessagingComponentInstaller` configuring a child `MessagingComponent` using the provider asset. Drop it into a scene to see provider-driven wiring without writing setup code.
 
 ## Walkthrough
 
@@ -33,19 +33,19 @@ Each sample shows:
 
 2. **Hook up the container**  
    - **Zenject**:  
-     - Add `DxMessagingRegistrationInstaller` (from `Runtime/Unity/Integrations/`) to your ProjectContext or scene installer list.  
-     - Drop `Zenject/SampleInstaller.cs` into your project and register it alongside other installers. When the scene runs, the installer resolves `IMessageRegistrationBuilder`, stages a `PlayerSpawned` listener, and activates via the Zenject lifecycle.
+     - Add `DxMessagingRegistrationInstaller` (from [Runtime/Unity/Integrations](../../Runtime/Unity/Integrations/)) to your ProjectContext or scene installer list.  
+     - Drop [SampleInstaller.cs](./Zenject/SampleInstaller.cs) into your project and register it alongside other installers. When the scene runs, the installer resolves `IMessageRegistrationBuilder`, stages a `PlayerSpawned` listener, and activates via the Zenject lifecycle.
    - **VContainer**:  
-     - Define `VCONTAINER_PRESENT` and reference the optional extension under `Runtime/Unity/Integrations/VContainerRegistrationExtensions.cs`.  
-     - Add `VContainer/SampleLifetimeScope` to the scene (or derive from it); the sample scope registers the builder and an entry point that emits/consumes `ScoreUpdated` messages each tick.
+     - Define `VCONTAINER_PRESENT` and reference the optional extension under [VContainerRegistrationExtensions.cs](../../Runtime/Unity/Integrations/VContainerRegistrationExtensions.cs).  
+     - Add [SampleLifetimeScope.cs](./VContainer/SampleLifetimeScope.cs) to the scene (or derive from it); the sample scope registers the builder and an entry point that emits/consumes `ScoreUpdated` messages each tick.
    - **Reflex**:  
      - Enable `REFLEX_PRESENT` and install `DxMessagingRegistrationInstaller` into your container bootstrap.  
-     - Include `Reflex/SampleInstaller` in your installer chain. The sample service resolves `IMessageRegistrationBuilder`, subscribes to `PlayerAlert`, and can emit alerts via `EmitAlertFor`.
+     - Include [SampleInstaller.cs](./Reflex/SampleInstaller.cs) in your installer chain. The sample service resolves `IMessageRegistrationBuilder`, subscribes to `PlayerAlert`, and can emit alerts via `EmitAlertFor`.
 
 3. **Emit a message**  
    Use the service exposed by the container (e.g., call into `ScoreboardService` or `PlayerAlertService`) to emit a message. Because the prefab already configured `MessagingComponent` instances via the installer, the listeners run immediately.
 
 4. **Swap providers** (optional)  
-   Duplicate `Providers/CurrentGlobalMessageBusProvider.asset`, modify it to return a custom bus, assign it on the prefab root, and observe how builder-created leases now resolve that bus instead.
+   Duplicate [CurrentGlobalMessageBusProvider.asset](./Providers/CurrentGlobalMessageBusProvider.asset), modify it to return a custom bus, assign it on the prefab root, and observe how builder-created leases now resolve that bus instead.
 
 Feel free to duplicate these scripts into your own project and adjust lifecycles or message types as needed.

package/Samples~/Mini Combat/README.md

@@ -83,11 +83,11 @@ Here's what each script does:
 
 | File | Purpose | Message Type |
 |------|---------|--------------|
-| **Messages.cs** | Defines all message types | Contains `VideoSettingsChanged`, `Heal`, and `TookDamage` |
-| **Player.cs** | Handles receiving healing | Listens for `Heal` (Targeted) |
-| **Enemy.cs** | Announces when damaged | Emits `TookDamage` (Broadcast) |
-| **UIOverlay.cs** | Updates UI based on events | Listens to settings and `TookDamage` (Broadcast) |
-| **Boot.cs** | Starts the demo | Simulates message flow |
+| **[Messages.cs](./Messages.cs)** | Defines all message types | Contains `VideoSettingsChanged`, `Heal`, and `TookDamage` |
+| **[Player.cs](./Player.cs)** | Handles receiving healing | Listens for `Heal` (Targeted) |
+| **[Enemy.cs](./Enemy.cs)** | Announces when damaged | Emits `TookDamage` (Broadcast) |
+| **[UIOverlay.cs](./UIOverlay.cs)** | Updates UI based on events | Listens to settings and `TookDamage` (Broadcast) |
+| **[Boot.cs](./Boot.cs)** | Starts the demo | Simulates message flow |
 
 ---
 
@@ -126,10 +126,10 @@ For **each GameObject**, you need TWO components:
    - Click GameObject → Add Component → "MessagingComponent"
 
 1. **Add the sample script**:
-   - **Player** GameObject → Add `Player.cs` script
-   - **Enemy** GameObject → Add `Enemy.cs` script
-   - **UIOverlay** GameObject → Add `UIOverlay.cs` script
-   - **Boot** GameObject → Add `Boot.cs` script
+   - **Player** GameObject → Add [Player.cs](./Player.cs) script
+   - **Enemy** GameObject → Add [Enemy.cs](./Enemy.cs) script
+   - **UIOverlay** GameObject → Add [UIOverlay.cs](./UIOverlay.cs) script
+   - **Boot** GameObject → Add [Boot.cs](./Boot.cs) script
 
 #### Step 3: Run and Observe
 
@@ -147,11 +147,11 @@ Press Play! The Boot script will automatically:
 
 ### The Message Flow
 
-#### Boot.cs sends messages:
+#### [Boot.cs](./Boot.cs) sends messages:
 
-1. `VideoSettingsChanged` (Untargeted) → UIOverlay.cs receives
-2. `Heal` (Targeted to Player) → Player.cs receives
-3. `TookDamage` (Broadcast from Enemy) → UIOverlay.cs receives
+1. `VideoSettingsChanged` (Untargeted) → [UIOverlay.cs](./UIOverlay.cs) receives
+2. `Heal` (Targeted to Player) → [Player.cs](./Player.cs) receives
+3. `TookDamage` (Broadcast from Enemy) → [UIOverlay.cs](./UIOverlay.cs) receives
 
 ### Understanding Message Types
 
@@ -318,6 +318,6 @@ protected override void OnEnable() {
 ## Quick Reference
 
 **Enable Diagnostics**: Select MessagingComponent in Inspector → Enable Diagnostics
-**Message Types**: See `Messages.cs` for all available messages
-**Modify Behavior**: Edit handler methods in Player.cs, Enemy.cs, or UIOverlay.cs
+**Message Types**: See [Messages.cs](./Messages.cs) for all available messages
+**Modify Behavior**: Edit handler methods in [Player.cs](./Player.cs), [Enemy.cs](./Enemy.cs), or [UIOverlay.cs](./UIOverlay.cs)
 **Extend Scripts**: Always call `base.RegisterMessageHandlers()` and other `base.*` methods

package/Samples~/Mini Combat/Walkthrough.md

@@ -17,7 +17,7 @@
 After reading this walkthrough, you'll know:
 
 1. **Why each message type was chosen** - the reasoning behind Untargeted vs Targeted vs Broadcast
-2. **How the code flows** - step-by-step from Boot.cs through every script
+2. **How the code flows** - step-by-step from [Boot.cs](./Boot.cs) through every script
 3. **Common patterns** - Observer, Broadcaster, Orchestrator, and more
 4. **Debugging strategies** - how to find and fix issues
 5. **How to extend it** - add your own messages and handlers
@@ -43,7 +43,7 @@ After reading this walkthrough, you'll know:
 
 Let's understand what each script does:
 
-### Messages.cs
+### [Messages.cs](./Messages.cs)
 
 **Purpose**: Defines all message types used in the sample
 
@@ -56,7 +56,7 @@ Let's understand what each script does:
 
 **Why separate file?** Keeping messages in one place makes them easy to find and prevents circular dependencies.
 
-### Player.cs
+### [Player.cs](./Player.cs)
 
 **What it does**: Listens for healing messages targeted specifically at this player
 
@@ -68,7 +68,7 @@ Let's understand what each script does:
 
 **Real-world analogy**: Like having your name called in a doctor's office—only you respond.
 
-### Enemy.cs
+### [Enemy.cs](./Enemy.cs)
 
 **What it does**: Broadcasts when it takes damage
 
@@ -80,7 +80,7 @@ Let's understand what each script does:
 
 **Real-world analogy**: Like ringing a bell—anyone nearby can hear it.
 
-### UIOverlay.cs
+### [UIOverlay.cs](./UIOverlay.cs)
 
 **What it does**: Monitors game events and updates the UI
 
@@ -92,7 +92,7 @@ Let's understand what each script does:
 
 **Real-world analogy**: Like a news reporter watching everything and reporting it.
 
-### Boot.cs
+### [Boot.cs](./Boot.cs)
 
 **What it does**: Starts the demo by simulating a sequence of events
 
@@ -141,8 +141,8 @@ Settings changes are **global events**—they don't target anyone specifically.
 
 ### The Code Flow
 
-1. **Boot.cs** calls: `MessageHub.Publish(new VideoSettingsChanged())`
-1. **UIOverlay.cs** receives it through its registered handler
+1. **[Boot.cs](./Boot.cs)** calls: `MessageHub.Publish(new VideoSettingsChanged())`
+1. **[UIOverlay.cs](./UIOverlay.cs)** receives it through its registered handler
 1. **UIOverlay** rebuilds the UI with new settings
 
 ### Developer Notes
@@ -178,9 +178,9 @@ We want to heal **one specific player**, not all players in the scene.
 
 ### The Code Flow
 
-1. **Boot.cs** finds the Player Component reference
-1. **Boot.cs** calls: `MessageHub.Publish(new Heal(amount), targetComponent)`
-1. **Only the targeted Player.cs** receives it through its handler
+1. **[Boot.cs](./Boot.cs)** finds the Player Component reference
+1. **[Boot.cs](./Boot.cs)** calls: `MessageHub.Publish(new Heal(amount), targetComponent)`
+1. **Only the targeted [Player.cs](./Player.cs)** receives it through its handler
 1. **Player** increases its HP
 
 ### Developer Notes
@@ -216,7 +216,7 @@ The Enemy doesn't know (or care) who needs to know about the damage. It just ann
 
 ### The Code Flow
 
-1. **Enemy.cs** detects it took damage
+1. **[Enemy.cs](./Enemy.cs)** detects it took damage
 1. **Enemy** calls: `this.EmitBroadcast(new TookDamage(amount))`
 1. **UIOverlay** receives it via `RegisterBroadcastWithoutSource`
 1. **UIOverlay** displays the damage event

package/Samples~/UI Buttons + Inspector/README.md

@@ -120,7 +120,7 @@ MessageHandler.MessageBus.DiagnosticsMode = true;
 
 - Multiple buttons: Add more UI Buttons, add more `UIButtonEmitter`s, and give each a unique `buttonId`.
 - Targeted vs. untargeted: Notice the sample also sends a targeted `StringMessage` to the emitter’s `gameObject`.
-- Your own message type: Open `Messages.cs` to see how `ButtonClicked` is declared using attributes:
+- Your own message type: Open [Messages.cs](./Messages.cs) to see how `ButtonClicked` is declared using attributes:
 
 ```csharp
 [DxUntargetedMessage]
@@ -202,8 +202,8 @@ public class MyObserver : MessageAwareComponent {
 
 ## Next Steps
 
-- Quick tour: `Docs/GettingStarted.md`
-- Patterns and recipes: `Docs/Patterns.md`
-- Explore another sample: `../Mini%20Combat/README.md`
+- Quick tour: [Getting Started guide](../../Docs/GettingStarted.md)
+- Patterns and recipes: [Common Patterns](../../Docs/Patterns.md)
+- Explore another sample: [Mini Combat sample](../Mini%20Combat/README.md)
 
 You now have an easy, inspector-first way to publish and observe messages. Build up from here by swapping in your own message types and listeners.

package/SourceGenerators/Directory.Build.props

@@ -0,0 +1,9 @@
+<Project>
+  <PropertyGroup Condition="'$(MSBuildProjectName)' == 'WallstopStudios.DxMessaging.SourceGenerators.Tests'">
+    <SolutionDir Condition="'$(SolutionDir)' == ''">$(MSBuildThisFileDirectory)..\</SolutionDir>
+    <ArtifactsRoot>$(SolutionDir).artifacts/SourceGenerators.Tests/</ArtifactsRoot>
+    <IntermediateOutputPath>$(ArtifactsRoot)obj/$(Configuration)/</IntermediateOutputPath>
+    <OutputPath>$(ArtifactsRoot)bin/$(Configuration)/</OutputPath>
+    <VSTestResultsDirectory>$(ArtifactsRoot)TestResults/</VSTestResultsDirectory>
+  </PropertyGroup>
+</Project>

package/{Tests/Runtime/WallstopStudios.DxMessaging.Tests.Runtime.csproj.meta → SourceGenerators/Directory.Build.props.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 939c668fdbd24a74591e482310e0e40f
+guid: 5b80e1cf4c3c72a43bbd48e4667f00f7
 DefaultImporter:
   externalObjects: {}
   userData: