fix: underwater-lab monument icons never rendered (path-qualified tokens) (#61)

* fix: map path-qualified underwater-lab/swamp prefab tokens to monument icons

Rust+ sends full prefab paths (assets/.../underwater_lab_d.prefab) for the
swamp and underwater-lab families, but MonumentTokenMap matched by bare-name
prefix, so lab icons never rendered and every render logged an unknown token.
TypeFor now reduces a token to its bare prefab name before lookup, and the
underwater-lab-base interior-module family (moonpools, corridors) is
deliberately skipped without the unknown-token log via IsIgnored.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* docs: state PrefabName's actual reduction behavior in its returns doc

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: HandyS11

src/RustPlusBot.Features.Map/Assets/MonumentIconSource.cs

@@ -33,7 +33,11 @@ public sealed partial class MonumentIconSource(IMonumentAssetSource assets, ILog
         var type = MonumentTokenMap.TypeFor(token);
         if (type is null)
         {
-            ReportOnce(token, type: null);
+            if (!MonumentTokenMap.IsIgnored(token))
+            {
+                ReportOnce(token, type: null);
+            }
+
             return null;
         }
 

src/RustPlusBot.Features.Map/Assets/MonumentTokenMap.cs

@@ -59,27 +59,53 @@ public static class MonumentTokenMap
     /// <summary>All exactly-mapped tokens (excludes the prefix families); exposed for drift-guard tests.</summary>
     internal static IReadOnlyCollection<string> KnownTokens => Map.Keys;
 
+    /// <summary>Indicates whether a token is a known non-monument that should be skipped silently.</summary>
+    /// <param name="token">The Rust+ monument protobuf token (or prefab name).</param>
+    /// <returns>True when the token is deliberately iconless; false otherwise.</returns>
+    /// <remarks>
+    /// Underwater labs are assembled from interior module prefabs (moonpools, corridors, …) that
+    /// Rust+ lists alongside the lab itself; only the lab warrants an icon, so the module family is
+    /// skipped without the unknown-token log.
+    /// </remarks>
+    public static bool IsIgnored(string? token) =>
+        token?.Contains("underwater-lab-base/", StringComparison.Ordinal) == true;
+
     /// <summary>Gets the RustMaps monument type for a Rust+ token, or null when unmapped.</summary>
     /// <param name="token">The Rust+ monument protobuf token (or prefab name).</param>
     /// <returns>The monument type whose asset represents the token, or null.</returns>
     public static MonumentType? TypeFor(string? token)
     {
-        if (string.IsNullOrEmpty(token))
+        var name = PrefabName(token);
+        if (string.IsNullOrEmpty(name))
         {
             return null;
         }
 
-        if (Map.TryGetValue(token, out var type))
+        if (Map.TryGetValue(name, out var type))
         {
             return type;
         }
 
         // Rust+ sends prefab names (not fixed tokens) for these families.
-        if (token.StartsWith("swamp", StringComparison.Ordinal))
+        if (name.StartsWith("swamp", StringComparison.Ordinal))
         {
             return MonumentType.SwampC;
         }
 
-        return token.StartsWith("underwater_lab", StringComparison.Ordinal) ? MonumentType.UnderwaterA : null;
+        return name.StartsWith("underwater_lab", StringComparison.Ordinal) ? MonumentType.UnderwaterA : null;
+    }
+
+    /// <summary>Reduces a path-qualified prefab token ("assets/.../swamp_a.prefab") to its bare name.</summary>
+    /// <param name="token">The raw Rust+ token: a bare display-name token or a full prefab path.</param>
+    /// <returns>The last path segment with any ".prefab" suffix removed; bare tokens come back unchanged.</returns>
+    private static string? PrefabName(string? token)
+    {
+        if (string.IsNullOrEmpty(token))
+        {
+            return token;
+        }
+
+        var name = token[(token.LastIndexOf('/') + 1)..];
+        return name.EndsWith(".prefab", StringComparison.Ordinal) ? name[..^".prefab".Length] : name;
     }
 }

tests/RustPlusBot.Features.Map.Tests/MonumentIconSourceTests.cs

@@ -46,6 +46,18 @@ public void Monument_returns_null_and_logs_once_for_unknown_token()
         Assert.Equal(1, logger.Count(LogLevel.Information));
     }
 
+    [Fact]
+    public void Monument_returns_null_silently_for_ignored_lab_module_tokens()
+    {
+        var logger = new RecordingLogger<MonumentIconSource>();
+        var source = new MonumentIconSource(new MonumentAssetSource(), logger);
+
+        Assert.Null(source.Monument(
+            "assets/bundled/prefabs/autospawn/underwater-lab-base/module_900x900_2way_moonpool.prefab", 30));
+
+        Assert.Equal(0, logger.Count(LogLevel.Information));
+    }
+
     [Theory]
     [InlineData(RigKind.Small)]
     [InlineData(RigKind.Large)]

tests/RustPlusBot.Features.Map.Tests/MonumentTokenMapTests.cs

@@ -40,13 +40,31 @@ public void TypeFor_matches_swamps_by_prefix(string token) =>
     public void TypeFor_matches_underwater_labs_by_prefix(string token) =>
         Assert.Equal(MonumentType.UnderwaterA, MonumentTokenMap.TypeFor(token));
 
+    [Theory]
+    [InlineData("assets/bundled/prefabs/autospawn/monument/underwater_lab/underwater_lab_d.prefab",
+        MonumentType.UnderwaterA)]
+    [InlineData("assets/bundled/prefabs/autospawn/monument/medium/swamp_a.prefab", MonumentType.SwampC)]
+    public void TypeFor_maps_path_qualified_prefab_tokens(string token, MonumentType expected) =>
+        Assert.Equal(expected, MonumentTokenMap.TypeFor(token));
+
     [Theory]
     [InlineData("definitely_not_a_monument")]
+    [InlineData("assets/bundled/prefabs/autospawn/underwater-lab-base/module_900x900_2way_moonpool.prefab")]
     [InlineData("")]
     [InlineData(null)]
     public void TypeFor_returns_null_for_unknown_or_empty(string? token) =>
         Assert.Null(MonumentTokenMap.TypeFor(token));
 
+    [Theory]
+    [InlineData("assets/bundled/prefabs/autospawn/underwater-lab-base/module_900x900_2way_moonpool.prefab", true)]
+    [InlineData("assets/bundled/prefabs/autospawn/underwater-lab-base/module_1200x1200_a.prefab", true)]
+    [InlineData("assets/bundled/prefabs/autospawn/monument/underwater_lab/underwater_lab_d.prefab", false)]
+    [InlineData("definitely_not_a_monument", false)]
+    [InlineData("", false)]
+    [InlineData(null, false)]
+    public void IsIgnored_flags_only_underwater_lab_interior_modules(string? token, bool expected) =>
+        Assert.Equal(expected, MonumentTokenMap.IsIgnored(token));
+
     [Fact]
     public void Every_mapped_type_has_a_package_asset()
     {