refactor: bundle cohesive dependencies to satisfy S107 parameter limit

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

Author: HandyS11

src/RustPlusBot.Features.Alarms/AlarmServiceCollectionExtensions.cs

@@ -23,6 +23,7 @@ public static IServiceCollection AddAlarms(this IServiceCollection services)
         services.AddSingleton<IAlarmChannelPoster, DiscordAlarmChannelPoster>();
         services.AddSingleton<IAlarmRefresher, AlarmRefresher>();
         services.AddSingleton<AlarmPairingCoordinator>();
+        services.AddSingleton<AlarmRelayChannels>();
         services.AddSingleton<AlarmStateRelay>();
         services.AddHostedService<AlarmsHostedService>();
 

src/RustPlusBot.Features.Alarms/Relaying/AlarmStateRelay.cs

@@ -13,24 +13,29 @@
 
 namespace RustPlusBot.Features.Alarms.Relaying;
 
+/// <summary>Bundles the channel/chat collaborators injected into <see cref="AlarmStateRelay"/>.</summary>
+/// <param name="Locator">Resolves the #alarms channel id.</param>
+/// <param name="Poster">Posts/edits alarm embeds and sends @everyone pings.</param>
+/// <param name="TeamChatSender">Relays messages into in-game team chat.</param>
+internal sealed record AlarmRelayChannels(
+    IAlarmChannelLocator Locator,
+    IAlarmChannelPoster Poster,
+    ITeamChatSender TeamChatSender);
+
 /// <summary>
 /// Keeps alarm embeds in sync with live socket events: updates state and re-renders on trigger; marks
 /// alarms unreachable when the server goes non-Connected.
 /// </summary>
 /// <param name="scopeFactory">Opens scopes for the scoped stores.</param>
 /// <param name="refresher">Re-renders a single alarm embed on demand.</param>
-/// <param name="locator">Resolves the #alarms channel id.</param>
-/// <param name="poster">Posts/edits alarm embeds and sends @everyone pings.</param>
-/// <param name="teamChatSender">Relays messages into in-game team chat.</param>
+/// <param name="channels">Bundles the channel/chat collaborators.</param>
 /// <param name="localizer">Resolves localized alarm strings.</param>
 /// <param name="clock">Provides the current UTC time.</param>
 /// <param name="logger">The logger.</param>
 internal sealed partial class AlarmStateRelay(
     IServiceScopeFactory scopeFactory,
     IAlarmRefresher refresher,
-    IAlarmChannelLocator locator,
-    IAlarmChannelPoster poster,
-    ITeamChatSender teamChatSender,
+    AlarmRelayChannels channels,
     IAlarmLocalizer localizer,
     IClock clock,
     ILogger<AlarmStateRelay> logger)
@@ -83,10 +88,11 @@ await refresher.RefreshAsync(evt.GuildId, evt.ServerId, evt.EntityId, unreachabl
 
         if (ping)
         {
-            var channelId = await locator.GetChannelIdAsync(evt.GuildId, evt.ServerId, ct).ConfigureAwait(false);
+            var channelId = await channels.Locator.GetChannelIdAsync(evt.GuildId, evt.ServerId, ct)
+                .ConfigureAwait(false);
             if (channelId is { } channel)
             {
-                await poster.SendEveryonePingAsync(channel, $"@everyone {name}", ct).ConfigureAwait(false);
+                await channels.Poster.SendEveryonePingAsync(channel, $"@everyone {name}", ct).ConfigureAwait(false);
             }
         }
 
@@ -140,7 +146,7 @@ private async Task RelayToTeamChatSafeAsync(SmartDeviceTriggeredEvent evt, strin
             }
 
             var line = localizer.Get("alarm.triggered.teamchat", culture, name);
-            _ = await teamChatSender.SendAsync(evt.GuildId, evt.ServerId, line, ct).ConfigureAwait(false);
+            _ = await channels.TeamChatSender.SendAsync(evt.GuildId, evt.ServerId, line, ct).ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {

src/RustPlusBot.Features.Connections/ConnectionServiceCollectionExtensions.cs

@@ -19,6 +19,7 @@ public static IServiceCollection AddConnections(this IServiceCollection services
         ArgumentNullException.ThrowIfNull(services);
 
         services.AddSingleton<IRustSocketSource, RustPlusSocketSource>();
+        services.AddSingleton<ConnectionSecurity>();
         services.AddSingleton<ConnectionSupervisor>();
         services.AddSingleton<IConnectionSupervisor>(sp => sp.GetRequiredService<ConnectionSupervisor>());
         services.AddSingleton<ITeamChatSender>(sp => sp.GetRequiredService<ConnectionSupervisor>());

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

@@ -3,6 +3,13 @@
 
 namespace RustPlusBot.Features.Connections.Listening;
 
+/// <summary>Bundles the polling parameters passed to the <c>UpdateAfk</c> private method in <see cref="TeamStateTracker"/>.</summary>
+/// <param name="Clock">The current wall-clock time.</param>
+/// <param name="Threshold">How long a member must be still before being flagged AFK.</param>
+/// <param name="Epsilon">Movement tolerance (world units) below which a member is considered still.</param>
+/// <param name="DiedThisPoll">Whether the member died during this poll.</param>
+internal sealed record AfkPollContext(DateTimeOffset Clock, TimeSpan Threshold, float Epsilon, bool DiedThisPoll);
+
 /// <summary>Diffs successive team snapshots into presence transitions. One instance per connected window.</summary>
 internal sealed class TeamStateTracker
 {
@@ -54,7 +61,8 @@ public IReadOnlyList<PlayerTransition> Diff(
 
                 AddPresenceTransitions(transitions, id, was, nowMember, snapshot);
                 var diedThisPoll = nowMember.LastDeathTimeUtc > was.LastDeathTimeUtc;
-                UpdateAfk(transitions, id, was, nowMember, now, afkThreshold, afkEpsilon, diedThisPoll);
+                UpdateAfk(transitions, id, was, nowMember,
+                    new AfkPollContext(now, afkThreshold, afkEpsilon, diedThisPoll));
             }
 
             PruneDepartedMembers(current);
@@ -96,30 +104,27 @@ private void UpdateAfk(
         ulong id,
         TeamMemberSnapshot was,
         TeamMemberSnapshot now,
-        DateTimeOffset clock,
-        TimeSpan threshold,
-        float epsilon,
-        bool diedThisPoll)
+        AfkPollContext context)
     {
         // A member who goes offline, is dead, or died this poll (even if a slow poll already shows them
         // respawned) can no longer be AFK. Clear the AFK latch SILENTLY — the disconnect/death transition
         // already speaks for them, and a "back" line alongside "disconnected"/"died" would contradict it —
         // and reset the stillness clock so AFK must be re-earned after the state change.
-        if (!now.IsOnline || !now.IsAlive || diedThisPoll)
+        if (!now.IsOnline || !now.IsAlive || context.DiedThisPoll)
         {
             _afk.Remove(id);
-            _stillSince[id] = clock;
+            _stillSince[id] = context.Clock;
             return;
         }
 
         // Squared-distance check so epsilon is a true movement radius (per-axis would treat diagonal
         // movement of dx=dy=0.8, epsilon=1 — distance ≈ 1.13 — as still).
         var dx = now.X - was.X;
         var dy = now.Y - was.Y;
-        var moved = (dx * dx) + (dy * dy) > epsilon * epsilon;
+        var moved = (dx * dx) + (dy * dy) > context.Epsilon * context.Epsilon;
         if (moved)
         {
-            _stillSince[id] = clock;
+            _stillSince[id] = context.Clock;
             if (_afk.Remove(id))
             {
                 transitions.Add(new PlayerTransition(PlayerTransitionKind.ReturnedFromAfk, id, now.Name, null));
@@ -128,9 +133,9 @@ private void UpdateAfk(
             return;
         }
 
-        var since = _stillSince.TryGetValue(id, out var s) ? s : clock;
+        var since = _stillSince.TryGetValue(id, out var s) ? s : context.Clock;
         _stillSince.TryAdd(id, since);
-        if (clock - since >= threshold && _afk.Add(id))
+        if (context.Clock - since >= context.Threshold && _afk.Add(id))
         {
             transitions.Add(new PlayerTransition(PlayerTransitionKind.BecameAfk, id, now.Name, (now.X, now.Y)));
         }

src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs

@@ -18,20 +18,23 @@
 
 namespace RustPlusBot.Features.Connections.Supervisor;
 
+/// <summary>Bundles the security/notification collaborators injected into <see cref="ConnectionSupervisor"/>.</summary>
+/// <param name="DmSender">DMs an owner when their credential is rejected.</param>
+/// <param name="Protector">Unprotects stored tokens before connecting.</param>
+internal sealed record ConnectionSecurity(IUserDmSender DmSender, ICredentialProtector Protector);
+
 /// <summary>Default <see cref="IConnectionSupervisor"/>: one connect->heartbeat->failover loop per (guild, server).</summary>
 /// <param name="source">Creates sockets (RustPlusApi in production, a fake in tests).</param>
 /// <param name="scopeFactory">Opens scopes for the scoped stores.</param>
-/// <param name="dmSender">DMs an owner when their credential is rejected.</param>
-/// <param name="protector">Unprotects stored tokens before connecting.</param>
+/// <param name="security">Bundles the security/notification collaborators.</param>
 /// <param name="eventBus">Publishes ConnectionStatusChangedEvent on state changes.</param>
 /// <param name="clock">Wall-clock source used for AFK hysteresis timestamps.</param>
 /// <param name="options">Timeouts/backoff/heartbeat settings.</param>
 /// <param name="logger">The logger.</param>
 internal sealed partial class ConnectionSupervisor(
     IRustSocketSource source,
     IServiceScopeFactory scopeFactory,
-    IUserDmSender dmSender,
-    ICredentialProtector protector,
+    ConnectionSecurity security,
     IEventBus eventBus,
     IClock clock,
     IOptions<ConnectionOptions> options,
@@ -706,13 +709,13 @@ private async Task<IReadOnlyList<RigPosition>> GetRigPositionsAsync(
                 string token;
                 try
                 {
-                    token = protector.Unprotect(active.ProtectedPlayerToken);
+                    token = security.Protector.Unprotect(active.ProtectedPlayerToken);
                 }
                 catch (CryptographicException ex)
                 {
                     LogUnreadableToken(logger, ex, active.Id);
                     await store.MarkInvalidAsync(active.Id, ct).ConfigureAwait(false);
-                    await dmSender.SendAsync(
+                    await security.DmSender.SendAsync(
                             active.OwnerUserId,
                             $"Your Rust+ credential for **{server.Name}** could not be read — reconnect in #setup.",
                             ct)
@@ -737,7 +740,7 @@ private async Task FailoverAsync(Guid credentialId, ulong ownerUserId, string se
             await store.MarkInvalidAsync(credentialId, ct).ConfigureAwait(false);
         }
 
-        await dmSender.SendAsync(
+        await security.DmSender.SendAsync(
                 ownerUserId,
                 $"Your Rust+ credential for **{serverName}** was rejected — reconnect in #setup to keep it in the pool.",
                 ct)

src/RustPlusBot.Features.Events/EventServiceCollectionExtensions.cs

@@ -27,7 +27,9 @@ public static IServiceCollection AddEvents(this IServiceCollection services)
         services.AddSingleton<MarkerEventClassifier>();
         services.AddSingleton<EventEmbedRenderer>();
         services.AddSingleton<IEventChannelPoster, DiscordEventChannelPoster>();
+        services.AddSingleton<EventRelayChannels>();
         services.AddSingleton<EventRelay>();
+        services.AddSingleton<EventStores>();
         services.AddHostedService<EventsHostedService>();
 
         return services;

src/RustPlusBot.Features.Events/Hosting/EventsHostedService.cs

@@ -12,20 +12,23 @@
 
 namespace RustPlusBot.Features.Events.Hosting;
 
+/// <summary>Bundles the state-store collaborators injected into <see cref="EventsHostedService"/>.</summary>
+/// <param name="Store">The marker state store, cleared on disconnect.</param>
+/// <param name="RigStore">The rig state store, advanced by the tick and cleared on disconnect.</param>
+internal sealed record EventStores(EventStateStore Store, RigStateStore RigStore);
+
 /// <summary>Runs the marker relay loop, the rig-event relay loop, the rig-timer tick, and the disconnect-clear loop.</summary>
 /// <param name="eventBus">The in-process event bus.</param>
 /// <param name="relay">Relays marker + rig events into Discord #events and in-game chat.</param>
-/// <param name="store">The marker state store, cleared on disconnect.</param>
-/// <param name="rigStore">The rig state store, advanced by the tick and cleared on disconnect.</param>
+/// <param name="stores">Bundles the marker and rig state stores.</param>
 /// <param name="clock">Supplies the current time for the tick.</param>
 /// <param name="options">Supplies the rig-tick interval.</param>
 /// <param name="scopeFactory">Opens scopes to read connection state.</param>
 /// <param name="logger">The logger.</param>
 internal sealed partial class EventsHostedService(
     IEventBus eventBus,
     EventRelay relay,
-    EventStateStore store,
-    RigStateStore rigStore,
+    EventStores stores,
     IClock clock,
     IOptions<ConnectionOptions> options,
     IServiceScopeFactory scopeFactory,
@@ -77,7 +80,7 @@ public async Task StopAsync(CancellationToken cancellationToken)
     /// <returns>A task that completes when the tick has published all crossings.</returns>
     internal async Task TickOnceAsync(CancellationToken cancellationToken)
     {
-        foreach (var c in rigStore.Advance(clock.UtcNow))
+        foreach (var c in stores.RigStore.Advance(clock.UtcNow))
         {
             await eventBus.PublishAsync(
                     new RigStateChangedEvent(c.GuildId, c.ServerId, c.Rig, c.Kind, c.X, c.Y, c.Dimensions),
@@ -184,8 +187,8 @@ private async Task ClearIfDisconnectedAsync(ConnectionStatusChangedEvent evt, Ca
                 .ConfigureAwait(false);
             if (state is null || state.Status != ConnectionStatus.Connected)
             {
-                store.Clear(evt.GuildId, evt.ServerId);
-                rigStore.Clear(evt.GuildId, evt.ServerId);
+                stores.Store.Clear(evt.GuildId, evt.ServerId);
+                stores.RigStore.Clear(evt.GuildId, evt.ServerId);
             }
         }
     }

src/RustPlusBot.Features.Events/Relaying/EventRelay.cs

@@ -10,22 +10,27 @@
 
 namespace RustPlusBot.Features.Events.Relaying;
 
+/// <summary>Bundles the channel/chat collaborators injected into <see cref="EventRelay"/>.</summary>
+/// <param name="Locator">Resolves the #events Discord channel id.</param>
+/// <param name="Poster">Posts embeds to the Discord channel.</param>
+/// <param name="TeamChatSender">Broadcasts the in-game team-chat line.</param>
+internal sealed record EventRelayChannels(
+    IEventChannelLocator Locator,
+    IEventChannelPoster Poster,
+    ITeamChatSender TeamChatSender);
+
 /// <summary>Posts every live event to #events AND in-game team chat; tracks rig state.</summary>
 /// <param name="classifier">Classifies raw marker deltas into domain events.</param>
 /// <param name="state">Tracks active markers and recent events per server.</param>
 /// <param name="renderer">Renders events as embeds and in-game lines.</param>
-/// <param name="locator">Resolves the #events Discord channel id.</param>
-/// <param name="poster">Posts embeds to the Discord channel.</param>
-/// <param name="teamChatSender">Broadcasts the in-game team-chat line.</param>
+/// <param name="channels">Bundles the channel/chat collaborators.</param>
 /// <param name="rigStore">Tracks oil-rig state (Apply on Activated).</param>
 /// <param name="scopeFactory">Opens scopes to read guild culture.</param>
 internal sealed class EventRelay(
     MarkerEventClassifier classifier,
     EventStateStore state,
     EventEmbedRenderer renderer,
-    IEventChannelLocator locator,
-    IEventChannelPoster poster,
-    ITeamChatSender teamChatSender,
+    EventRelayChannels channels,
     RigStateStore rigStore,
     IServiceScopeFactory scopeFactory)
 {
@@ -44,17 +49,18 @@ public async Task RelayAsync(MapMarkersChangedEvent evt, CancellationToken cance
         }
 
         var culture = await GetCultureAsync(evt.GuildId, cancellationToken).ConfigureAwait(false);
-        var channelId = await locator.GetChannelIdAsync(evt.GuildId, evt.ServerId, cancellationToken)
+        var channelId = await channels.Locator.GetChannelIdAsync(evt.GuildId, evt.ServerId, cancellationToken)
             .ConfigureAwait(false);
 
         foreach (var e in events)
         {
-            await teamChatSender
+            await channels.TeamChatSender
                 .SendAsync(evt.GuildId, evt.ServerId, renderer.RenderLine(e, culture), cancellationToken)
                 .ConfigureAwait(false);
             if (channelId is { } id)
             {
-                await poster.PostAsync(id, renderer.Render(e, culture), cancellationToken).ConfigureAwait(false);
+                await channels.Poster.PostAsync(id, renderer.Render(e, culture), cancellationToken)
+                    .ConfigureAwait(false);
             }
         }
     }
@@ -72,15 +78,16 @@ public async Task RelayRigAsync(RigStateChangedEvent evt, CancellationToken canc
         }
 
         var culture = await GetCultureAsync(evt.GuildId, cancellationToken).ConfigureAwait(false);
-        await teamChatSender
+        await channels.TeamChatSender
             .SendAsync(evt.GuildId, evt.ServerId, renderer.RenderRigLine(evt, culture), cancellationToken)
             .ConfigureAwait(false);
 
-        var channelId = await locator.GetChannelIdAsync(evt.GuildId, evt.ServerId, cancellationToken)
+        var channelId = await channels.Locator.GetChannelIdAsync(evt.GuildId, evt.ServerId, cancellationToken)
             .ConfigureAwait(false);
         if (channelId is { } id)
         {
-            await poster.PostAsync(id, renderer.RenderRig(evt, culture), cancellationToken).ConfigureAwait(false);
+            await channels.Poster.PostAsync(id, renderer.RenderRig(evt, culture), cancellationToken)
+                .ConfigureAwait(false);
         }
     }