Report only the interface the game declares for a block

The terminal page derived a list of interfaces from the type hierarchy, which
put IMyFunctionalBlock on 79 of 85 blocks and read as though every block could
be fetched through it. It now shows the interface only where the game declares
one, and nothing where it does not, rather than presenting a derived answer as
an authoritative one.

The sampled subtype is not shown either. A type id covers many subtypes and the
extractor reads actions and properties off whichever one it happened to spawn,
so naming it would suggest the entry applied to that subtype alone.

Also fixes the terminal page never regenerating after a generator change: the
staleness check compared the output against the data file only, so a fix
produced no output at all until the data happened to change. It now considers
DocGen's own build time as well.

Author: malware-dev

Source/DocGen/Services/Terminals.cs

@@ -22,11 +22,27 @@ public class Terminals
 
         public static async Task Update(string fileName, string output, Action<string> updateStatusFn)
         {
-            // Check if regeneration is needed (simple timestamp check)
-            if (File.Exists(output) && File.GetLastWriteTimeUtc(output) >= File.GetLastWriteTimeUtc(fileName))
+            // Regenerate when either the data or this generator is newer than the output. Comparing against the
+            // data alone meant a fix to the generator produced nothing at all until the data happened to change,
+            // which is silent and very easy to mistake for the fix not working.
+            if (File.Exists(output))
             {
-                updateStatusFn?.Invoke("Skipping (output up-to-date)");
-                return;
+                var outputWritten = File.GetLastWriteTimeUtc(output);
+                var newestInput = File.GetLastWriteTimeUtc(fileName);
+
+                var generator = typeof(Terminals).Assembly.Location;
+                if (!string.IsNullOrEmpty(generator) && File.Exists(generator))
+                {
+                    var generatorBuilt = File.GetLastWriteTimeUtc(generator);
+                    if (generatorBuilt > newestInput)
+                        newestInput = generatorBuilt;
+                }
+
+                if (outputWritten >= newestInput)
+                {
+                    updateStatusFn?.Invoke("Skipping (output up-to-date)");
+                    return;
+                }
             }
 
             updateStatusFn?.Invoke("Loading cache...");
@@ -67,10 +83,16 @@ public void Save(string fileName)
                 document.AppendLine($"## {GetDisplayName(block)}");
                 document.AppendLine();
 
-                var interfaces = GetFetchableAs(block);
-                if (interfaces.Any())
+                // Only what the game itself states. The interface is reported when the game declares one for the
+                // block and left out otherwise: a dozen blocks carry no such declaration, and working one out
+                // from the type hierarchy produced answers that looked authoritative without being so.
+                //
+                // The sampled subtype is deliberately not shown. A type id covers many subtypes and the extractor
+                // reads the actions and properties off whichever one it happened to spawn, so naming it would
+                // suggest the entry applies to that subtype alone when it applies to all of them.
+                if (!string.IsNullOrEmpty(block.BlockInterfaceType))
                 {
-                    document.AppendLine("Available as: " + string.Join(", ", interfaces.Select(i => $"`{i}`")));
+                    document.AppendLine($"Interface: `{GetBlockName(block.BlockInterfaceType)}`");
                     document.AppendLine();
                 }
 
@@ -158,27 +180,6 @@ string GetBlockName(string name)
             return name;
         }
 
-        const string TerminalBlockInterface = "IMyTerminalBlock";
-
-        /// <summary>
-        ///     The interfaces worth telling someone about: the ones they can actually fetch the block through.
-        /// </summary>
-        /// <remarks>
-        ///     Only interfaces descending from <c>IMyTerminalBlock</c> qualify, which drops the cross-cutting ones
-        ///     such as <c>IMyCubeBlock</c>, <c>IMyEntity</c> and <c>IMyInventoryOwner</c> that every block carries
-        ///     and none of which help you find it. <c>IMyTerminalBlock</c> itself is left out because it is true of
-        ///     everything, unless a block has nothing else, in which case it is the honest answer.
-        /// </remarks>
-        List<string> GetFetchableAs(BlockInfo block)
-        {
-            var interfaces = block.TerminalInterfaces
-                .Select(GetBlockName)
-                .Where(name => name != TerminalBlockInterface)
-                .ToList();
-
-            return interfaces.Count > 0 ? interfaces : new List<string> { TerminalBlockInterface };
-        }
-
         /// <summary>
         ///     What a block is listed under. The type definition, because it is the one thing every block has:
         ///     a dozen block classes carry no terminal interface attribute, so the interface name is blank for

docs/spaceengineers/modapi/.mdkapigen

@@ -1,5 +1,5 @@
 {
-  "Generated": "2026-08-03T18:57:42.1048033Z",
+  "Generated": "2026-08-03T19:09:29.2055736Z",
   "Files": [
     "api-index.js",
     "build-info.json",