com.wallstop-studios.dxmessaging 2.1.7 → 2.1.9

package/docs/concepts/message-types.md

@@ -1,218 +0,0 @@
-# Message Types: When and How to Use
-
-[← Back to Index](../getting-started/index.md) | [Getting Started](../getting-started/getting-started.md) | [Patterns](../guides/patterns.md) | [Visual Guide](../getting-started/visual-guide.md)
-
----
-
-This guide introduces the three message categories in DxMessaging with concepts, when to use them, and practical code.
-
-## Overview
-
-- Untargeted: global notifications anyone can listen to (e.g., world regenerated).
-- Targeted: directed at one recipient (e.g., heal Player by 10).
-- Broadcast: emitted from a source for anyone to observe (e.g., Enemy took 5 damage).
-
-### Quick Decision Guide
-
-```mermaid
-flowchart TD
-    Start([Choose Message Type])
-
-    Start --> Q1{Is it a global<br/>announcement?}
-
-    Q1 -->|Yes<br/>e.g., game paused,<br/>settings changed| Untargeted[✅ Use UNTARGETED<br/>Everyone listens]
-
-    Q1 -->|No| Q2{Are you commanding<br/>a specific entity?}
-
-    Q2 -->|Yes<br/>e.g., heal Player,<br/>open Chest #3| Targeted[✅ Use TARGETED<br/>One recipient]
-
-    Q2 -->|No| Q3{Is an entity announcing<br/>something happened?}
-
-    Q3 -->|Yes<br/>e.g., Enemy died,<br/>Chest opened| Broadcast[✅ Use BROADCAST<br/>Anyone can observe]
-
-    Q3 -->|No| Rethink[🤔 Rethink your<br/>message design]
-
-    classDef primary stroke-width:3px
-    class Untargeted primary
-    classDef warning stroke-width:3px
-    class Targeted warning
-    classDef success stroke-width:3px
-    class Broadcast success
-    classDef danger stroke-width:2px
-    class Rethink danger
-    classDef neutral stroke-width:2px
-    class Start,Q1,Q2,Q3 neutral
-```
-
-## Untargeted Messages
-
-- Use for cross‑cutting notifications: settings changed, scene loaded, world regenerated.
-- Any listener can subscribe; no specific sender/recipient required.
-- Define as immutable structs; prefer generic interface for zero‑boxing.
-
-```csharp
-using DxMessaging.Core.Messages;
-using DxMessaging.Core.Attributes;
-using DxMessaging.Core.Extensions;
-
-[DxUntargetedMessage]
-[DxAutoConstructor]
-public readonly partial struct SceneLoaded
-{
-    public readonly int buildIndex;
-}
-
-// Emit (bind struct to a variable)
-var sceneLoaded = new SceneLoaded(UnityEngine.SceneManagement.SceneManager.GetActiveScene().buildIndex);
-sceneLoaded.Emit();
-```
-
-## Targeted Messages
-
-- Use for commands/events directed at one entity: Heal, EquipWeapon, OpenDoor.
-- You address a specific `InstanceId` (e.g., a player GameObject/component).
-- Ideal when only one recipient should act.
-
-```csharp
-using DxMessaging.Core.Messages;
-using DxMessaging.Core.Attributes;
-using DxMessaging.Core.Extensions;
-using UnityEngine;
-
-[DxTargetedMessage]
-[DxAutoConstructor]
-public readonly partial struct Heal
-{
-    public readonly int amount;
-}
-
-// Emit to one target (GameObject)
-var heal = new Heal(10);
-heal.EmitGameObjectTargeted(playerGameObject);
-```
-
-## Broadcast Messages
-
-- Use for reactionary “facts” about a specific source: TookDamage, PickedUpItem.
-- Many systems can observe and react independently.
-- Distinct from targeted: the source is the sender; listeners decide if they care.
-
-```csharp
-using DxMessaging.Core.Messages;
-using DxMessaging.Core.Attributes;
-using DxMessaging.Core.Extensions;
-using UnityEngine;
-
-[DxBroadcastMessage]
-[DxAutoConstructor]
-public readonly partial struct TookDamage
-{
-    public readonly int amount;
-}
-
-// Emit from a source (GameObject)
-var hit = new TookDamage(5);
-hit.EmitGameObjectBroadcast(enemyGameObject);
-```
-
-## Organizing Messages with Nested Types
-
-Group related messages inside a container class for better organization:
-
-```csharp
-using DxMessaging.Core.Attributes;
-
-public partial class CombatEvents
-{
-    [DxTargetedMessage]
-    [DxAutoConstructor]
-    public readonly partial struct Heal
-    {
-        public readonly int amount;
-        [DxOptionalParameter(false)]  // Custom default value
-        public readonly bool showEffect;
-    }
-
-    [DxBroadcastMessage]
-    [DxAutoConstructor]
-    public readonly partial struct TookDamage
-    {
-        public readonly int amount;
-        [DxOptionalParameter(Expression = "DamageType.Physical")]  // Enum default
-        public readonly DamageType type;
-    }
-}
-
-// Usage:
-var heal = new CombatEvents.Heal(10, showEffect: true);
-heal.EmitComponentTargeted(player);
-
-var damage = new CombatEvents.TookDamage(5);  // Uses DamageType.Physical
-damage.EmitGameObjectBroadcast(enemy);
-```
-
-### Benefits
-
-- Reduces namespace pollution
-- Makes message relationships clear
-- Works with all message types (Untargeted, Targeted, Broadcast)
-- Full source generator support
-
-## Listening to everything in a category
-
-- All targeted of a type (any target): `RegisterTargetedWithoutTargeting<T>` or post‑process with `RegisterTargetedWithoutTargetingPostProcessor<T>`.
-- All broadcast of a type (any source): `RegisterBroadcastWithoutSource<T>` or post‑process with `RegisterBroadcastWithoutSourcePostProcessor<T>`.
-
-```csharp
-using DxMessaging.Core;
-using DxMessaging.Core.Messages;
-
-// Observe every Heal regardless of target
-_ = token.RegisterTargetedWithoutTargeting<Heal>(OnAnyHeal);
-void OnAnyHeal(ref InstanceId target, ref Heal m) => Audit(target, m);
-
-// Observe every TookDamage regardless of source
-_ = token.RegisterBroadcastWithoutSource<TookDamage>(OnAnyTookDamage);
-void OnAnyTookDamage(ref InstanceId source, ref TookDamage m) => Track(source, m);
-```
-
-## Choosing the right type
-
-- Start with Broadcast for “X happened at Y” facts others may observe.
-- Use Targeted when one specific recipient must act.
-- Use Untargeted for global state changes anyone might care about.
-
-## Do's
-
-- Keep messages small, immutable, and specific.
-- Use attributes + `DxAutoConstructor` for clarity and onboarding.
-- Use GameObject/Component helpers (`EmitGameObject*`/`EmitComponent*`) instead of manual `InstanceId` casts.
-- Organize related messages using nested types for better structure.
-- Use internal visibility for implementation-only messages.
-
-## Don’ts
-
-- Don’t use Untargeted for per‑entity commands; prefer Targeted.
-- Don’t overload Broadcast for commands; commands need a recipient (Targeted).
-- Avoid deep inheritance trees; messages should be small, flat data.
-- Don’t emit from temporaries; bind structs to a variable before `Emit*`.
-
----
-
-## Related Documentation
-
-### Prerequisites
-
-- → [Getting Started](../getting-started/getting-started.md) — Understand the basics first
-- → [Visual Guide](../getting-started/visual-guide.md) — See the 3 types visualized
-
-#### Next Steps
-
-- → [Patterns](../guides/patterns.md) — Real-world examples of each type
-- → [Listening Patterns](listening-patterns.md) — All the ways to receive messages
-- → [Interceptors & Ordering](interceptors-and-ordering.md) — Control message flow
-
-##### Try It
-
-- → [Quick Start](../getting-started/quick-start.md) — Working example
-- → [Mini Combat sample](https://github.com/wallstop/DxMessaging/blob/master/Samples~/Mini%20Combat/README.md) — See all 3 types in action

package/docs/concepts/message-types.md.meta

@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: c60a113c88b589949addd17450bbacef
-TextScriptImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

package/docs/concepts/targeting-and-context.md

@@ -1,451 +0,0 @@
-# Targeting and Context (Component vs GameObject)
-
-**Critical Unity concept:** Understanding GameObject vs Component targeting is essential for using DxMessaging effectively.
-
-## Overview
-
-Targeted and broadcast messages carry context: an `InstanceId` for the target (targeted) or source (broadcast). In Unity, `InstanceId` can represent either a `GameObject` or a specific `Component`. **These are completely separate channels** — mixing them is the #1 cause of "why isn't my handler firing?" bugs.
-
-## Key Concepts
-
-### InstanceId
-
-- **Implicit conversion:** Automatically converts from both `GameObject` and `Component`
-- **Equality:** Based on Unity's instance ID (internally stored as an `int`)
-- **Matching:** The bus compares `InstanceId` values for exact matches
-- **Separate channels:** GameObject and Component are distinct addresses
-
-### Matching Rules
-
-- A handler registered for a `GameObject` **only** receives messages emitted to that `GameObject`
-- A handler registered for a `Component` **only** receives messages emitted to that `Component`
-- Emitting to a `GameObject` does **not** reach Component-registered handlers (and vice versa)
-- This applies to **both** targeted and broadcast messages
-
-## Understanding GameObject vs Component Targeting
-
-### What GameObject Targeting Means
-
-When you emit to a **GameObject**, you're saying: "This message is for whatever is attached to this GameObject."
-
-```csharp
-[DxTargetedMessage]
-[DxAutoConstructor]
-public readonly partial struct Heal { public readonly int amount; }
-
-// Emit to GameObject
-var heal = new Heal(10);
-heal.EmitGameObjectTargeted(playerGameObject);
-```
-
-#### Who receives it?
-
-- Any Component on that GameObject that registered with `RegisterGameObjectTargeted`
-- Multiple components on the same GameObject can all receive it
-- Components on child/parent GameObjects will NOT receive it
-
-##### Use when
-
-- You don't care which specific component handles it
-- You want flexibility (multiple components can respond)
-- You're commanding "the player" or "the enemy" as a conceptual unit
-
-### What Component Targeting Means
-
-When you emit to a **Component**, you're saying: "This message is specifically for this one Component instance."
-
-```csharp
-// Emit to specific Component
-var heal = new Heal(10);
-heal.EmitComponentTargeted(playerHealthComponent);
-```
-
-#### Who receives it?
-
-- ONLY that specific Component instance
-- Other components on the same GameObject will NOT receive it
-- This is a direct, pinpoint message
-
-##### Use when
-
-- You have a reference to the exact component you want to message
-- You need precise control (only this component, not its siblings)
-- You're working with component-specific logic
-
-## Visual Comparison: Targeted Messages
-
-```csharp
-// Setup: Player GameObject with multiple components
-GameObject player = /* ... */;
-HealthComponent health = player.GetComponent<HealthComponent>();
-UIComponent ui = player.GetComponent<UIComponent>();
-
-// Both components register for Heal on the GameObject
-_ = healthToken.RegisterGameObjectTargeted<Heal>(player, health.OnHeal);
-_ = uiToken.RegisterGameObjectTargeted<Heal>(player, ui.OnHeal);
-
-// Scenario 1: Target the GameObject
-heal.EmitGameObjectTargeted(player);
-// ✅ health.OnHeal() fires
-// ✅ ui.OnHeal() fires
-// Both components receive it!
-
-// Scenario 2: Target a Component (but registered for GameObject)
-heal.EmitComponentTargeted(health);
-// ❌ health.OnHeal() does NOT fire (registered for GameObject, not Component)
-// ❌ ui.OnHeal() does NOT fire
-// Nothing happens! Wrong channel!
-
-// Scenario 3: Register for Component, emit to Component
-_ = healthToken.RegisterComponentTargeted<Heal>(health, health.OnHeal);
-heal.EmitComponentTargeted(health);
-// ✅ health.OnHeal() fires
-// ❌ ui.OnHeal() does NOT fire (different component)
-```
-
-## Broadcast Messages: Same Rules Apply
-
-Broadcast messages follow the exact same GameObject vs Component rules:
-
-```csharp
-[DxBroadcastMessage]
-[DxAutoConstructor]
-public readonly partial struct TookDamage { public readonly int amount; }
-
-// Broadcast from GameObject
-var damage = new TookDamage(5);
-damage.EmitGameObjectBroadcast(enemyGameObject);
-
-// Register for broadcasts from this GameObject
-_ = token.RegisterGameObjectBroadcast<TookDamage>(enemyGameObject, OnEnemyDamage);
-// ✅ OnEnemyDamage fires when damage.EmitGameObjectBroadcast(enemyGameObject) is called
-
-// Register for broadcasts from this Component
-_ = token.RegisterComponentBroadcast<TookDamage>(enemyComponent, OnComponentDamage);
-// ❌ OnComponentDamage does NOT fire (registered for Component, but emitted from GameObject)
-```
-
-## The `this` Trap
-
-**Most common mistake:** Using `this` in a MonoBehaviour and forgetting it's a Component, not a GameObject.
-
-```csharp
-public class Enemy : MonoBehaviour
-{
-    void Start()
-    {
-        // ❌ WRONG: Registered for GameObject
-        _ = token.RegisterGameObjectTargeted<TakeDamage>(gameObject, OnDamage);
-    }
-
-    void TakeDamageFrom(GameObject attacker)
-    {
-        var damage = new TakeDamage(10);
-        // ❌ WRONG: Emitting to Component (this)
-        damage.EmitAt(this);  // WON'T BE RECEIVED!
-    }
-
-    void OnDamage(ref TakeDamage msg) { }
-}
-
-// FIX 1: Both use GameObject
-_ = token.RegisterGameObjectTargeted<TakeDamage>(gameObject, OnDamage);
-damage.EmitAt(gameObject);  // ✅ Works!
-
-// FIX 2: Both use Component
-_ = token.RegisterComponentTargeted<TakeDamage>(this, OnDamage);
-damage.EmitAt(this);  // ✅ Works!
-```
-
-**Remember:** In Unity, `this` inside a `MonoBehaviour` is **always** a Component, never a GameObject!
-
-## Listening to ALL Events (Global Observers)
-
-**Feature:** DxMessaging allows listening to all targeted or broadcast messages **without knowing the specific target or source**.
-
-This is useful for:
-
-- **Analytics** — Track every action in your game without coupling to individual objects
-- **Debugging** — See all events of a type in one place
-- **Cross-cutting concerns** — Achievements, logging, VFX that respond to any entity's events
-
-### Why this is different from classic event buses
-
-| Approach                 | Classic Event Bus             | DxMessaging Global Observers       |
-| ------------------------ | ----------------------------- | ---------------------------------- |
-| **Subscriptions needed** | One per entity type           | One for ALL entities               |
-| **Coupling**             | Tight (know all entity types) | Zero (no knowledge needed)         |
-| **New entity types**     | Update all subscribers        | Zero changes needed                |
-| **Context**              | Lost (who was damaged?)       | Provided (source/target parameter) |
-
-### Classic Event Bus Anti-Pattern
-
-```csharp
-// ❌ Traditional approach: Tight coupling, multiple subscriptions
-EventBus.PlayerDamaged += OnPlayerDamaged;
-EventBus.EnemyDamaged += OnEnemyDamaged;
-EventBus.NPCDamaged += OnNPCDamaged;
-EventBus.BossDamaged += OnBossDamaged;
-// Add new entity? Update EVERY analytics/logging system!
-
-void OnPlayerDamaged(int amount) { RecordDamage("Player", amount); }
-void OnEnemyDamaged(int amount) { RecordDamage("Enemy", amount); }
-void OnNPCDamaged(int amount) { RecordDamage("NPC", amount); }
-void OnBossDamaged(int amount) { RecordDamage("Boss", amount); }
-```
-
-### DxMessaging Global Observer Pattern
-
-```csharp
-// ✅ DxMessaging: One subscription, zero coupling
-_ = token.RegisterBroadcastWithoutSource<TookDamage>(OnAnyDamage);
-
-void OnAnyDamage(ref InstanceId source, ref TookDamage msg)
-{
-    // Works for Player, Enemy, NPC, Boss, and any future entity type!
-    RecordDamage(source, msg.amount);
-}
-// Add new entity? Zero changes needed.
-```
-
-### Listening to All Targeted Messages
-
-Use `RegisterTargetedWithoutTargeting` to receive ALL targeted messages of a type, regardless of target:
-
-```csharp
-[DxTargetedMessage]
-[DxAutoConstructor]
-public readonly partial struct Heal { public readonly int amount; }
-
-// Listen to ALL heal messages, no matter who they're targeted at
-_ = token.RegisterTargetedWithoutTargeting<Heal>(OnAnyHeal);
-
-void OnAnyHeal(ref InstanceId target, ref Heal msg)
-{
-    Debug.Log($"Someone healed {target} for {msg.amount}");
-    // You get the target as a parameter so you know WHO was healed
-}
-
-// Now when ANYONE emits a heal...
-heal.EmitAt(player);    // OnAnyHeal fires with target = player
-heal.EmitAt(enemy);     // OnAnyHeal fires with target = enemy
-heal.EmitAt(npc);       // OnAnyHeal fires with target = npc
-```
-
-#### Use cases
-
-- Analytics ("track all damage dealt")
-- Debugging ("log every heal in the game")
-- Achievements ("count total kills")
-- Global UI updates ("show floating damage numbers for any entity")
-
-### Listening to All Broadcast Messages
-
-Use `RegisterBroadcastWithoutSource` to receive ALL broadcast messages of a type, regardless of source:
-
-```csharp
-[DxBroadcastMessage]
-[DxAutoConstructor]
-public readonly partial struct TookDamage { public readonly int amount; }
-
-// Listen to ALL damage events from any source
-_ = token.RegisterBroadcastWithoutSource<TookDamage>(OnAnyDamage);
-
-void OnAnyDamage(ref InstanceId source, ref TookDamage msg)
-{
-    Debug.Log($"{source} took {msg.amount} damage");
-    // You get the source as a parameter so you know WHO took damage
-}
-
-// Now when ANYONE broadcasts damage...
-damage.EmitFrom(enemy);     // OnAnyDamage fires with source = enemy
-damage.EmitFrom(player);    // OnAnyDamage fires with source = player
-damage.EmitFrom(boss);      // OnAnyDamage fires with source = boss
-```
-
-#### Use cases
-
-- Combat logs ("record all damage in the scene")
-- Particle effects ("spawn blood VFX for any damage")
-- Achievement tracking ("count enemy deaths")
-- Analytics dashboards ("total damage per second")
-
-### Specific vs Global Listeners: Both Can Coexist
-
-You can have BOTH specific listeners AND global listeners for the same message:
-
-```csharp
-// Specific listener: only cares about player damage
-_ = playerToken.RegisterGameObjectBroadcast<TookDamage>(playerGameObject, OnPlayerDamage);
-
-// Global listener: cares about ALL damage
-_ = analyticsToken.RegisterBroadcastWithoutSource<TookDamage>(OnAnyDamage);
-
-// When player takes damage
-damage.EmitFrom(playerGameObject);
-// ✅ OnPlayerDamage fires (specific listener)
-// ✅ OnAnyDamage fires (global listener)
-// Both fire!
-
-// When enemy takes damage
-damage.EmitFrom(enemyGameObject);
-// ❌ OnPlayerDamage does NOT fire (wrong source)
-// ✅ OnAnyDamage fires (global listener catches everything)
-```
-
-### Real-World Example: Combat System
-
-Here's how to combine specific and global listeners in a combat system:
-
-```csharp
-public class Player : MessageAwareComponent
-{
-    protected override void RegisterMessageHandlers()
-    {
-        // Listen only to damage targeting THIS player
-        _ = Token.RegisterGameObjectBroadcast<TookDamage>(gameObject, OnPlayerTookDamage);
-    }
-
-    void OnPlayerTookDamage(ref TookDamage msg)
-    {
-        // Player-specific logic: update health bar, play hurt sound
-        health -= msg.amount;
-        PlayHurtSound();
-    }
-}
-
-public class CombatLog : MessageAwareComponent
-{
-    protected override void RegisterMessageHandlers()
-    {
-        // Listen to ALL damage from ANY source (global observer)
-        _ = Token.RegisterBroadcastWithoutSource<TookDamage>(OnAnyDamage);
-    }
-
-    void OnAnyDamage(ref InstanceId source, ref TookDamage msg)
-    {
-        // Global combat logging
-        LogToFile($"{Time.time}: {source} took {msg.amount} damage");
-    }
-}
-
-public class AchievementSystem : MessageAwareComponent
-{
-    protected override void RegisterMessageHandlers()
-    {
-        // Listen to ALL damage targeting ANY entity (global observer)
-        _ = Token.RegisterTargetedWithoutTargeting<DealDamage>(OnAnyDamageDealt);
-    }
-
-    void OnAnyDamageDealt(ref InstanceId target, ref DealDamage msg)
-    {
-        // Track total damage dealt for achievements
-        totalDamageDealt += msg.amount;
-        CheckDamageAchievements();
-    }
-}
-```
-
-### Performance Note
-
-Global listeners (`RegisterTargetedWithoutTargeting` / `RegisterBroadcastWithoutSource`) are **slightly slower** than specific listeners because they receive every message of that type. This is usually negligible, but avoid them in hot paths if you're emitting thousands of messages per frame.
-
-#### Rule of thumb
-
-- For gameplay (< 100 messages/frame): Use freely
-- For analytics/debugging: Perfect use case
-- For tight loops (> 1000 messages/frame): Prefer specific listeners
-
-## When to Use Which
-
-### GameObject Context
-
-#### Use when
-
-- The whole object is the logical target/source (e.g., "Player was healed", "Enemy took damage")
-- Multiple components should coordinate under the same address
-- You don't care which specific component handles it
-- You want flexibility for future refactoring (adding/removing components)
-
-##### Examples
-
-- Combat: "Deal damage to this enemy"
-- UI: "Update all panels related to this character"
-- State: "Notify all systems that this entity died"
-
-### Component Context
-
-#### Use when
-
-- The message is explicitly for one component's responsibility (e.g., "open JUST this DoorController")
-- Multiple components on the same GameObject must be independently addressable
-- You need pinpoint precision
-- You have a direct reference to the target component
-
-##### Examples
-
-- UI: "Update this specific health bar, not the mana bar"
-- Animation: "Tell this animator to play a clip"
-- Physics: "Toggle this specific collider"
-
-## Best Practices
-
-### Do's
-
-✅ **Pick a context and be consistent** across emitters and listeners for that message type
-✅ **Prefer GameObject when in doubt** — easier coordination among components on the same object
-✅ **Use explicit helpers** (`EmitGameObjectTargeted`, `RegisterGameObjectTargeted`) to make intent clear
-✅ **Document** which context your message types use (add it to your message comments)
-✅ **Use global listeners** for analytics, debugging, and cross-cutting concerns
-
-### Don'ts
-
-❌ **Don't emit to GameObject** and expect Component-registered handlers to receive it (and vice versa)
-❌ **Don't assume `this` means GameObject** — it's always a Component in Unity
-❌ **Don't mix GameObject/Component** for the same message type across your codebase
-❌ **Don't register the same handler under both** unless you intend to handle both contexts
-❌ **Don't use global listeners** in performance-critical tight loops (thousands of messages/frame)
-
-## Troubleshooting
-
-### "My handler isn't firing!"
-
-**Most likely cause:** GameObject/Component mismatch
-
-```csharp
-// Check 1: Are you emitting and registering on the same type?
-// ❌ WRONG
-_ = token.RegisterGameObjectTargeted<Heal>(gameObject, OnHeal);
-heal.EmitAt(this);  // Component, not GameObject!
-
-// ✅ CORRECT
-_ = token.RegisterGameObjectTargeted<Heal>(gameObject, OnHeal);
-heal.EmitAt(gameObject);  // Both GameObject
-```
-
-#### Other causes
-
-1. Handler not enabled (call `token.Enable()` in `OnEnable`)
-1. Registration happened after emission
-1. Using wrong bus (local vs global)
-
-See [Troubleshooting](../reference/troubleshooting.md) for more debugging tips.
-
-## Quick Reference
-
-| Operation              | GameObject Variant                             | Component Variant                              |
-| ---------------------- | ---------------------------------------------- | ---------------------------------------------- |
-| **Emit Targeted**      | `msg.EmitGameObjectTargeted(go)`               | `msg.EmitComponentTargeted(comp)`              |
-| **Emit Broadcast**     | `msg.EmitGameObjectBroadcast(go)`              | `msg.EmitComponentBroadcast(comp)`             |
-| **Register Targeted**  | `RegisterGameObjectTargeted<T>(go, handler)`   | `RegisterComponentTargeted<T>(comp, handler)`  |
-| **Register Broadcast** | `RegisterGameObjectBroadcast<T>(go, handler)`  | `RegisterComponentBroadcast<T>(comp, handler)` |
-| **Global Targeted**    | `RegisterTargetedWithoutTargeting<T>(handler)` | (Same — no distinction)                        |
-| **Global Broadcast**   | `RegisterBroadcastWithoutSource<T>(handler)`   | (Same — no distinction)                        |
-
-## See Also
-
-- **[Emit Shorthands](../advanced/emit-shorthands.md)** — Concise ways to emit messages
-- **[Message Types](message-types.md)** — Understanding Untargeted, Targeted, and Broadcast
-- **[Unity Integration](../guides/unity-integration.md)** — MessageAwareComponent and lifecycle
-- **[Quick Reference](../reference/quick-reference.md)** — API cheat sheet
-- **[Troubleshooting](../reference/troubleshooting.md)** — Solving common issues

package/docs/concepts/targeting-and-context.md.meta

@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: f0c2c3d64071ab54fbf7b63ad29ee73c
-TextScriptImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

package/docs/concepts.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: e56d6159c592de94e93c4f017c76b4c0
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: