com.wallstop-studios.dxmessaging 2.1.4 → 2.1.5

package/Runtime/Core/MessageBus/MessageRegistrationBuilder.cs

@@ -319,8 +319,10 @@ namespace DxMessaging.Core.MessageBus
 
             IMessageBus messageBus = ResolveMessageBus(options);
             InstanceId owner = ResolveOwner(options);
-            MessageHandler messageHandler = new MessageHandler(owner, messageBus);
-            messageHandler.active = options.HandlerStartsActive;
+            MessageHandler messageHandler = new MessageHandler(owner, messageBus)
+            {
+                active = options.HandlerStartsActive,
+            };
             MessageRegistrationToken token = MessageRegistrationToken.Create(
                 messageHandler,
                 messageBus

package/Runtime/Core/MessageHandler.cs

@@ -359,7 +359,7 @@ namespace DxMessaging.Core
         /// </summary>
         /// <remarks>
         /// This mirrors the legacy singleton so existing code continues to function. Use
-        /// <see cref="SetGlobalMessageBus(MessageBus.MessageBus)"/> to replace the instance (for example from a DI container) and
+        /// <see cref="SetGlobalMessageBus(Core.MessageBus.MessageBus)"/> to replace the instance (for example from a DI container) and
         /// <see cref="ResetGlobalMessageBus"/> to restore the stock configuration afterwards.
         /// </remarks>
         public static IMessageBus MessageBus => _globalMessageBus;
@@ -379,7 +379,7 @@ namespace DxMessaging.Core
         }
 
         /// <summary>
-        /// Replaces the global <see cref="MessageBus.MessageBus"/> instance returned by <see cref="MessageBus"/>.
+        /// Replaces the global <see cref="Core.MessageBus.MessageBus"/> instance returned by <see cref="MessageBus"/>.
         /// </summary>
         /// <param name="messageBus">Instance to expose globally.</param>
         /// <exception cref="ArgumentNullException">
@@ -417,7 +417,7 @@ namespace DxMessaging.Core
         }
 
         /// <summary>
-        /// Restores the global <see cref="MessageBus.MessageBus"/> to the built-in default instance.
+        /// Restores the global <see cref="Core.MessageBus.MessageBus"/> to the built-in default instance.
         /// </summary>
         /// <remarks>
         /// The default instance is recreated by <see cref="ResetStatics"/> when the static state reset utility runs.
@@ -441,7 +441,7 @@ namespace DxMessaging.Core
         }
 
         /// <summary>
-        /// Recreates the built-in global <see cref="MessageBus.MessageBus"/> and assigns it as the active global bus.
+        /// Recreates the built-in global <see cref="Core.MessageBus.MessageBus"/> and assigns it as the active global bus.
         /// </summary>
         /// <remarks>
         /// Invoked by <see cref="DxMessagingStaticState.Reset"/> to provide a clean slate when domain reloads are disabled.
@@ -2023,7 +2023,105 @@ namespace DxMessaging.Core
             return 0;
         }
 
-        private sealed class HandlerActionCache<T>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal UntargetedDispatchLink<T> GetOrCreateUntargetedDispatchLink<T>(
+            IMessageBus messageBus
+        )
+            where T : IMessage
+        {
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.GetOrCreateUntargetedLink();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal UntargetedPostDispatchLink<T> GetOrCreateUntargetedPostDispatchLink<T>(
+            IMessageBus messageBus
+        )
+            where T : IMessage
+        {
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.GetOrCreateUntargetedPostLink();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal TargetedDispatchLink<T> GetOrCreateTargetedDispatchLink<T>(IMessageBus messageBus)
+            where T : IMessage
+        {
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.GetOrCreateTargetedLink();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal TargetedPostDispatchLink<T> GetOrCreateTargetedPostDispatchLink<T>(
+            IMessageBus messageBus
+        )
+            where T : IMessage
+        {
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.GetOrCreateTargetedPostLink();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal TargetedWithoutTargetingDispatchLink<T> GetOrCreateTargetedWithoutTargetingDispatchLink<T>(
+            IMessageBus messageBus
+        )
+            where T : IMessage
+        {
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.GetOrCreateTargetedWithoutTargetingLink();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal TargetedWithoutTargetingPostDispatchLink<T> GetOrCreateTargetedWithoutTargetingPostDispatchLink<T>(
+            IMessageBus messageBus
+        )
+            where T : IMessage
+        {
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.GetOrCreateTargetedWithoutTargetingPostLink();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal BroadcastDispatchLink<T> GetOrCreateBroadcastDispatchLink<T>(
+            IMessageBus messageBus
+        )
+            where T : IMessage
+        {
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.GetOrCreateBroadcastLink();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal BroadcastPostDispatchLink<T> GetOrCreateBroadcastPostDispatchLink<T>(
+            IMessageBus messageBus
+        )
+            where T : IMessage
+        {
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.GetOrCreateBroadcastPostLink();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal BroadcastWithoutSourceDispatchLink<T> GetOrCreateBroadcastWithoutSourceDispatchLink<T>(
+            IMessageBus messageBus
+        )
+            where T : IMessage
+        {
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.GetOrCreateBroadcastWithoutSourceLink();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal BroadcastWithoutSourcePostDispatchLink<T> GetOrCreateBroadcastWithoutSourcePostDispatchLink<T>(
+            IMessageBus messageBus
+        )
+            where T : IMessage
+        {
+            TypedHandler<T> typedHandler = GetOrCreateHandlerForType<T>(messageBus);
+            return typedHandler.GetOrCreateBroadcastWithoutSourcePostLink();
+        }
+
+        internal sealed class HandlerActionCache<T>
         {
             internal readonly struct Entry
             {
@@ -2050,11 +2148,279 @@ namespace DxMessaging.Core
             internal int prefreezeInvocationCount;
         }
 
+        internal sealed class UntargetedDispatchLink<T>
+            where T : IMessage
+        {
+            private readonly TypedHandler<T> typedHandler;
+
+            internal UntargetedDispatchLink(TypedHandler<T> typedHandler)
+            {
+                this.typedHandler = typedHandler;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal void Invoke(
+                MessageHandler messageHandler,
+                ref T message,
+                int priority,
+                long emissionId
+            )
+            {
+                if (!messageHandler.active)
+                {
+                    return;
+                }
+
+                typedHandler.HandleUntargeted(ref message, priority, emissionId);
+            }
+        }
+
+        internal sealed class UntargetedPostDispatchLink<TMessage>
+            where TMessage : IMessage
+        {
+            private readonly TypedHandler<TMessage> typedHandler;
+
+            internal UntargetedPostDispatchLink(TypedHandler<TMessage> typedHandler)
+            {
+                this.typedHandler = typedHandler;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal void Invoke(
+                MessageHandler messageHandler,
+                ref TMessage message,
+                int priority,
+                long emissionId
+            )
+            {
+                if (!messageHandler.active)
+                {
+                    return;
+                }
+
+                typedHandler.HandleUntargetedPostProcessing(ref message, priority, emissionId);
+            }
+        }
+
+        internal sealed class TargetedDispatchLink<TMessage>
+            where TMessage : IMessage
+        {
+            private readonly TypedHandler<TMessage> typedHandler;
+
+            internal TargetedDispatchLink(TypedHandler<TMessage> typedHandler)
+            {
+                this.typedHandler = typedHandler;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal void Invoke(
+                MessageHandler messageHandler,
+                ref InstanceId target,
+                ref TMessage message,
+                int priority,
+                long emissionId
+            )
+            {
+                typedHandler.HandleTargeted(ref target, ref message, priority, emissionId);
+            }
+        }
+
+        internal sealed class TargetedPostDispatchLink<TMessage>
+            where TMessage : IMessage
+        {
+            private readonly TypedHandler<TMessage> typedHandler;
+
+            internal TargetedPostDispatchLink(TypedHandler<TMessage> typedHandler)
+            {
+                this.typedHandler = typedHandler;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal void Invoke(
+                MessageHandler messageHandler,
+                ref InstanceId target,
+                ref TMessage message,
+                int priority,
+                long emissionId
+            )
+            {
+                typedHandler.HandleTargetedPostProcessing(
+                    ref target,
+                    ref message,
+                    priority,
+                    emissionId
+                );
+            }
+        }
+
+        internal sealed class TargetedWithoutTargetingDispatchLink<TMessage>
+            where TMessage : IMessage
+        {
+            private readonly TypedHandler<TMessage> typedHandler;
+
+            internal TargetedWithoutTargetingDispatchLink(TypedHandler<TMessage> typedHandler)
+            {
+                this.typedHandler = typedHandler;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal void Invoke(
+                MessageHandler messageHandler,
+                ref InstanceId target,
+                ref TMessage message,
+                int priority,
+                long emissionId
+            )
+            {
+                typedHandler.HandleTargetedWithoutTargeting(
+                    ref target,
+                    ref message,
+                    priority,
+                    emissionId
+                );
+            }
+        }
+
+        internal sealed class TargetedWithoutTargetingPostDispatchLink<TMessage>
+            where TMessage : IMessage
+        {
+            private readonly TypedHandler<TMessage> typedHandler;
+
+            internal TargetedWithoutTargetingPostDispatchLink(TypedHandler<TMessage> typedHandler)
+            {
+                this.typedHandler = typedHandler;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal void Invoke(
+                MessageHandler messageHandler,
+                ref InstanceId target,
+                ref TMessage message,
+                int priority,
+                long emissionId
+            )
+            {
+                typedHandler.HandleTargetedWithoutTargetingPostProcessing(
+                    ref target,
+                    ref message,
+                    priority,
+                    emissionId
+                );
+            }
+        }
+
+        internal sealed class BroadcastDispatchLink<TMessage>
+            where TMessage : IMessage
+        {
+            private readonly TypedHandler<TMessage> typedHandler;
+
+            internal BroadcastDispatchLink(TypedHandler<TMessage> typedHandler)
+            {
+                this.typedHandler = typedHandler;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal void Invoke(
+                MessageHandler messageHandler,
+                ref InstanceId source,
+                ref TMessage message,
+                int priority,
+                long emissionId
+            )
+            {
+                typedHandler.HandleSourcedBroadcast(ref source, ref message, priority, emissionId);
+            }
+        }
+
+        internal sealed class BroadcastPostDispatchLink<TMessage>
+            where TMessage : IMessage
+        {
+            private readonly TypedHandler<TMessage> typedHandler;
+
+            internal BroadcastPostDispatchLink(TypedHandler<TMessage> typedHandler)
+            {
+                this.typedHandler = typedHandler;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal void Invoke(
+                MessageHandler messageHandler,
+                ref InstanceId source,
+                ref TMessage message,
+                int priority,
+                long emissionId
+            )
+            {
+                typedHandler.HandleSourcedBroadcastPostProcessing(
+                    ref source,
+                    ref message,
+                    priority,
+                    emissionId
+                );
+            }
+        }
+
+        internal sealed class BroadcastWithoutSourceDispatchLink<TMessage>
+            where TMessage : IMessage
+        {
+            private readonly TypedHandler<TMessage> typedHandler;
+
+            internal BroadcastWithoutSourceDispatchLink(TypedHandler<TMessage> typedHandler)
+            {
+                this.typedHandler = typedHandler;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal void Invoke(
+                MessageHandler messageHandler,
+                ref InstanceId source,
+                ref TMessage message,
+                int priority,
+                long emissionId
+            )
+            {
+                typedHandler.HandleSourcedBroadcastWithoutSource(
+                    ref source,
+                    ref message,
+                    priority,
+                    emissionId
+                );
+            }
+        }
+
+        internal sealed class BroadcastWithoutSourcePostDispatchLink<TMessage>
+            where TMessage : IMessage
+        {
+            private readonly TypedHandler<TMessage> typedHandler;
+
+            internal BroadcastWithoutSourcePostDispatchLink(TypedHandler<TMessage> typedHandler)
+            {
+                this.typedHandler = typedHandler;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal void Invoke(
+                MessageHandler messageHandler,
+                ref InstanceId source,
+                ref TMessage message,
+                int priority,
+                long emissionId
+            )
+            {
+                typedHandler.HandleBroadcastWithoutSourcePostProcessing(
+                    ref source,
+                    ref message,
+                    priority,
+                    emissionId
+                );
+            }
+        }
+
         /// <summary>
         /// One-size-fits-all wrapper around all possible Messaging sinks for a particular MessageHandler & MessageType.
         /// </summary>
         /// <typeparam name="T">Message type that this Handler exists to serve.</typeparam>
-        private sealed class TypedHandler<T>
+        internal sealed class TypedHandler<T>
             where T : IMessage
         {
             internal Dictionary<
@@ -2153,6 +2519,153 @@ namespace DxMessaging.Core
                 int,
                 HandlerActionCache<FastHandlerWithContext<T>>
             > _fastBroadcastWithoutSourcePostProcessingHandlers;
+            private UntargetedDispatchLink<T> _untargetedLink;
+            private object _untargetedPostLink;
+            private object _targetedLink;
+            private object _targetedPostLink;
+            private object _targetedWithoutTargetingLink;
+            private object _targetedWithoutTargetingPostLink;
+            private object _broadcastLink;
+            private object _broadcastPostLink;
+            private object _broadcastWithoutSourceLink;
+            private object _broadcastWithoutSourcePostLink;
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal UntargetedDispatchLink<T> GetOrCreateUntargetedLink()
+            {
+                UntargetedDispatchLink<T> link = _untargetedLink;
+                if (link == null)
+                {
+                    link = new UntargetedDispatchLink<T>(this);
+                    _untargetedLink = link;
+                }
+
+                return link;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal UntargetedPostDispatchLink<T> GetOrCreateUntargetedPostLink()
+            {
+                UntargetedPostDispatchLink<T> link =
+                    _untargetedPostLink as UntargetedPostDispatchLink<T>;
+                if (link == null)
+                {
+                    link = new UntargetedPostDispatchLink<T>(this);
+                    _untargetedPostLink = link;
+                }
+
+                return link;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal TargetedDispatchLink<T> GetOrCreateTargetedLink()
+            {
+                TargetedDispatchLink<T> link = _targetedLink as TargetedDispatchLink<T>;
+                if (link == null)
+                {
+                    link = new TargetedDispatchLink<T>(this);
+                    _targetedLink = link;
+                }
+
+                return link;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal TargetedPostDispatchLink<T> GetOrCreateTargetedPostLink()
+            {
+                TargetedPostDispatchLink<T> link = _targetedPostLink as TargetedPostDispatchLink<T>;
+                if (link == null)
+                {
+                    link = new TargetedPostDispatchLink<T>(this);
+                    _targetedPostLink = link;
+                }
+
+                return link;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal TargetedWithoutTargetingDispatchLink<T> GetOrCreateTargetedWithoutTargetingLink()
+            {
+                TargetedWithoutTargetingDispatchLink<T> link =
+                    _targetedWithoutTargetingLink as TargetedWithoutTargetingDispatchLink<T>;
+                if (link == null)
+                {
+                    link = new TargetedWithoutTargetingDispatchLink<T>(this);
+                    _targetedWithoutTargetingLink = link;
+                }
+
+                return link;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal TargetedWithoutTargetingPostDispatchLink<T> GetOrCreateTargetedWithoutTargetingPostLink()
+            {
+                TargetedWithoutTargetingPostDispatchLink<T> link =
+                    _targetedWithoutTargetingPostLink
+                    as TargetedWithoutTargetingPostDispatchLink<T>;
+                if (link == null)
+                {
+                    link = new TargetedWithoutTargetingPostDispatchLink<T>(this);
+                    _targetedWithoutTargetingPostLink = link;
+                }
+
+                return link;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal BroadcastDispatchLink<T> GetOrCreateBroadcastLink()
+            {
+                BroadcastDispatchLink<T> link = _broadcastLink as BroadcastDispatchLink<T>;
+                if (link == null)
+                {
+                    link = new BroadcastDispatchLink<T>(this);
+                    _broadcastLink = link;
+                }
+
+                return link;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal BroadcastPostDispatchLink<T> GetOrCreateBroadcastPostLink()
+            {
+                BroadcastPostDispatchLink<T> link =
+                    _broadcastPostLink as BroadcastPostDispatchLink<T>;
+                if (link == null)
+                {
+                    link = new BroadcastPostDispatchLink<T>(this);
+                    _broadcastPostLink = link;
+                }
+
+                return link;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal BroadcastWithoutSourceDispatchLink<T> GetOrCreateBroadcastWithoutSourceLink()
+            {
+                BroadcastWithoutSourceDispatchLink<T> link =
+                    _broadcastWithoutSourceLink as BroadcastWithoutSourceDispatchLink<T>;
+                if (link == null)
+                {
+                    link = new BroadcastWithoutSourceDispatchLink<T>(this);
+                    _broadcastWithoutSourceLink = link;
+                }
+
+                return link;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal BroadcastWithoutSourcePostDispatchLink<T> GetOrCreateBroadcastWithoutSourcePostLink()
+            {
+                BroadcastWithoutSourcePostDispatchLink<T> link =
+                    _broadcastWithoutSourcePostLink as BroadcastWithoutSourcePostDispatchLink<T>;
+                if (link == null)
+                {
+                    link = new BroadcastWithoutSourcePostDispatchLink<T>(this);
+                    _broadcastWithoutSourcePostLink = link;
+                }
+
+                return link;
+            }
 
             /// <summary>
             /// Emits the UntargetedMessage to all subscribed listeners.

package/Samples~/DI/README.md

@@ -22,7 +22,7 @@ Each sample shows:
 - 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.
+- Current global message bus provider asset: [GlobalMessageBusProvider.asset](./Providers/GlobalMessageBusProvider.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.
 
@@ -46,6 +46,6 @@ Each sample shows:
    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 [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.
+   Duplicate [GlobalMessageBusProvider.asset](./Providers/GlobalMessageBusProvider.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

@@ -1,10 +1,10 @@
 # Mini Combat Sample
 
-> **Perfect for:** First-time users who want to see messaging in action with a working combat example
+> **Ideal for:** First-time users who want to see messaging in action with a working combat example
 
 ## What You'll Learn in 10 Minutes
 
-**Stop reading documentation and start seeing it work!** This sample shows:
+**This sample demonstrates messaging concepts through a functional example.** It shows:
 
 1. How Player heals without UI knowing about Player (**zero coupling**)
 2. How Enemy broadcasts damage without knowing who cares (**observer pattern**)
@@ -45,7 +45,7 @@ public class Player : MessageAwareComponent {
 }
 ```
 
-###### Zero coupling. Zero manual wiring. That's the power of messaging.
+###### This decouples systems and removes manual wiring.
 
 ---
 
@@ -104,7 +104,7 @@ Here's what each script does:
 5. **Open the scene**
 6. **Press Play** 🎮
 
-**That's it!** Watch the Console logs as messages flow.
+Watch the Console logs as messages flow.
 
 **Pro tip:** Enable diagnostics in the Inspector (MessagingComponent → Enable Diagnostics) to see message traffic in real-time.
 
@@ -247,9 +247,9 @@ Ready to understand the implementation details?
 
 ### Need Help
 
-- **New to messaging patterns?** Check the main [Getting Started Guide](../../Docs/GettingStarted.md)
-- **Want more examples?** See [Patterns Documentation](../../Docs/Patterns.md)
-- **Having issues?** Visit [Troubleshooting Guide](../../Docs/Troubleshooting.md)
+- **New to messaging patterns?** Check the main [Getting Started Guide](../../docs/getting-started/getting-started.md)
+- **Want more examples?** See [Patterns Documentation](../../docs/guides/patterns.md)
+- **Having issues?** Visit [Troubleshooting Guide](../../docs/reference/troubleshooting.md)
 
 ---