fix(2a): address Copilot review on PR #13

- EventEmbedRenderer + EventsCommandHandler: throw ArgumentOutOfRangeException
  on an unknown MapEventKind instead of silently falling back to the chinook
  key (fail-fast if a future kind is added).
- IRustServerConnection.GetMapMarkersAsync: correct the stale "all kinds /
  MarkerKind.Other" XML doc — the mapped facade only surfaces cargo/heli/chinook.
- RustPlusSocketSource.AddMarkers: skip markers with null X/Y instead of
  substituting (0,0), which would diff as a phantom spawn/despawn at the origin.
- DiscordEventChannelPoster: forward the CancellationToken via
  RequestOptions.CancelToken (and rethrow OperationCanceledException so a
  shutdown cancel isn't logged as a post failure).
- running-locally.md: chinook only alerts on spawn (cargo/heli on enter+leave) —
  reword the #events description to match actual behavior.
- EventStateStoreTests: rename the un-alerted-removal test for clarity
  (behavior was already correct).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: HandyS11

docs/development/running-locally.md

@@ -64,7 +64,8 @@ overwritten on every startup, so a normal run after the reset leaves only the cu
    `/workspace simulate-server name:<n> ip:<host> port:<port>` to create a server category, and
    `/workspace reset` to delete the whole workspace.
 
-Each provisioned server category also includes an `#events` channel, which receives live alerts for
-**cargo ship, patrol helicopter, and chinook** arrivals and departures. No new Discord gateway intent
-is required — event markers are detected by polling the Rust+ socket, not the Discord gateway; only the
-existing **Send Messages** and **Embed Links** permissions on the provisioned channel are used.
+Each provisioned server category also includes an `#events` channel, which receives live alerts when a
+**cargo ship** or **patrol helicopter** enters or leaves the map and when a **chinook** spawns. No new
+Discord gateway intent is required — event markers are detected by polling the Rust+ socket, not the
+Discord gateway; only the existing **Send Messages** and **Embed Links** permissions on the provisioned
+channel are used.

src/RustPlusBot.Features.Commands/Handlers/EventsCommandHandler.cs

@@ -15,6 +15,7 @@ internal sealed class EventsCommandHandler(IEventState state, ICommandLocalizer
     public string Name => "events";
 
     /// <inheritdoc />
+    /// <exception cref="ArgumentOutOfRangeException">A recent event has an unsupported <see cref="MapEventKind"/>.</exception>
     public Task<string?> ExecuteAsync(CommandContext context, CancellationToken cancellationToken)
     {
         ArgumentNullException.ThrowIfNull(context);
@@ -34,7 +35,7 @@ internal sealed class EventsCommandHandler(IEventState state, ICommandLocalizer
                 MapEventKind.HeliEntered => "command.event.helientered",
                 MapEventKind.HeliLeft => "command.event.helileft",
                 MapEventKind.ChinookSpawned => "command.event.chinookspawned",
-                _ => "command.event.chinookspawned",
+                _ => throw new ArgumentOutOfRangeException(nameof(e), e.Kind, "Unsupported map event kind."),
             };
             return localizer.Get(key, context.Culture, grid);
         });

src/RustPlusBot.Features.Connections/Listening/IRustServerConnection.cs

@@ -47,10 +47,10 @@ internal interface IRustServerConnection : IAsyncDisposable
     /// <returns>True if the promotion succeeded; false on failure/timeout.</returns>
     Task<bool> PromoteToLeaderAsync(ulong steamId, TimeSpan timeout, CancellationToken cancellationToken);
 
-    /// <summary>Polls the current map markers (all kinds; the caller diffs by id). Throws on failure.</summary>
+    /// <summary>Polls the current map markers the bot tracks (cargo ship, patrol helicopter, chinook), for diffing by id. Throws on failure.</summary>
     /// <param name="timeout">How long to wait for the response.</param>
     /// <param name="cancellationToken">A cancellation token.</param>
-    /// <returns>The current markers (every kind, unclassified ones as <see cref="MarkerKind.Other"/>).</returns>
+    /// <returns>The current cargo-ship / patrol-helicopter / chinook markers. Other marker types are not surfaced (the mapped RustPlusApi facade exposes no others the bot reasons about; crates are no longer sent by the game).</returns>
     Task<IReadOnlyList<MapMarkerSnapshot>> GetMapMarkersAsync(TimeSpan timeout,
         CancellationToken cancellationToken = default);
 

src/RustPlusBot.Features.Connections/Listening/RustPlusSocketSource.cs

@@ -399,7 +399,14 @@ private static void AddMarkers<TMarker>(
         {
             foreach (var (id, marker) in source)
             {
-                into.Add(new MapMarkerSnapshot(id, kind, marker.X ?? 0f, marker.Y ?? 0f, Name: null));
+                // Skip markers with incomplete coordinates rather than placing a phantom at the origin,
+                // which would otherwise diff as a spurious spawn/despawn at (0, 0).
+                if (marker.X is not { } x || marker.Y is not { } y)
+                {
+                    continue;
+                }
+
+                into.Add(new MapMarkerSnapshot(id, kind, x, y, Name: null));
             }
         }
 

src/RustPlusBot.Features.Events/Posting/DiscordEventChannelPoster.cs

@@ -17,12 +17,20 @@ public async Task PostAsync(ulong channelId, Embed embed, CancellationToken canc
     {
         try
         {
-            if (await client.GetChannelAsync(channelId).ConfigureAwait(false) is not ITextChannel channel)
+            var options = new RequestOptions
+            {
+                CancelToken = cancellationToken
+            };
+            if (await client.GetChannelAsync(channelId, options).ConfigureAwait(false) is not ITextChannel channel)
             {
                 return;
             }
 
-            await channel.SendMessageAsync(embed: embed).ConfigureAwait(false);
+            await channel.SendMessageAsync(embed: embed, options: options).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException)
+        {
+            throw; // Cancellation (shutdown) is not a post failure; let the relay loop unwind cleanly.
         }
 #pragma warning disable CA1031 // Broad catch: a Discord hiccup must not crash the relay.
         catch (Exception ex)

src/RustPlusBot.Features.Events/Rendering/EventEmbedRenderer.cs

@@ -12,6 +12,7 @@ internal sealed class EventEmbedRenderer(IEventLocalizer localizer)
     /// <param name="evt">The event to render.</param>
     /// <param name="culture">The guild culture ("en"/"fr").</param>
     /// <returns>The built embed.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">The event kind is not a supported <see cref="MapEventKind"/>.</exception>
     public Embed Render(RustMapEvent evt, string culture)
     {
         ArgumentNullException.ThrowIfNull(evt);
@@ -23,7 +24,7 @@ public Embed Render(RustMapEvent evt, string culture)
             MapEventKind.HeliEntered => "event.heli.entered",
             MapEventKind.HeliLeft => "event.heli.left",
             MapEventKind.ChinookSpawned => "event.chinook.spawned",
-            _ => "event.chinook.spawned",
+            _ => throw new ArgumentOutOfRangeException(nameof(evt), evt.Kind, "Unsupported map event kind."),
         };
 
         return new EmbedBuilder()

tests/RustPlusBot.Features.Events.Tests/State/EventStateStoreTests.cs

@@ -48,7 +48,7 @@ public void Added_marker_becomes_active_and_carries_dimensions()
     }
 
     [Fact]
-    public void Removed_marker_leaves_active_even_when_unalerted()
+    public void Removed_marker_is_cleared_from_active_even_when_unalerted()
     {
         var store = Build();
         // A Crate marker produces NO classified event (core-3), but is still tracked in the active set...