docs: backfill XML documentation across 756 files

Adds <summary>, <param>, <typeparam>, and <inheritdoc/> tags to public
members surfaced by commentchecker — resolves 5,847 of 5,869 issues
(99.6%) across three /fixdocs passes.

src/Server/ZB.MOM.WW.OtOpcUa.Host/Drivers/DriverFactoryBootstrap.cs

@@ -22,6 +22,7 @@ public static class DriverFactoryBootstrap
     ///     Must be called BEFORE <c>services.AddAkka</c> so the runtime extension can resolve
     ///     <see cref="IDriverFactory"/> from DI when spawning <c>DriverHostActor</c>.
     /// </summary>
+    /// <param name="services">The service collection to register driver factories with.</param>
     public static IServiceCollection AddOtOpcUaDriverFactories(this IServiceCollection services)
     {
         services.AddSingleton<DriverFactoryRegistry>(sp =>

src/Server/ZB.MOM.WW.OtOpcUa.Host/Engines/RoslynScriptedAlarmEvaluator.cs

@@ -30,12 +30,20 @@ public sealed class RoslynScriptedAlarmEvaluator : IScriptedAlarmEvaluator, IDis
     private readonly TimeSpan _runTimeout;
     private bool _disposed;
 
+    /// <summary>Initializes a new instance of the Roslyn scripted alarm evaluator.</summary>
+    /// <param name="logger">Logger for diagnostic messages.</param>
+    /// <param name="runTimeout">Optional timeout for script evaluation; defaults to 2 seconds.</param>
     public RoslynScriptedAlarmEvaluator(ILogger<RoslynScriptedAlarmEvaluator> logger, TimeSpan? runTimeout = null)
     {
         _logger = logger;
         _runTimeout = runTimeout ?? TimeSpan.FromSeconds(2);
     }
 
+    /// <summary>Evaluates a scripted alarm predicate against provided dependencies.</summary>
+    /// <param name="alarmId">The alarm identifier for logging purposes.</param>
+    /// <param name="predicate">The predicate expression to evaluate.</param>
+    /// <param name="dependencies">Variables available to the predicate expression.</param>
+    /// <returns>Evaluation result with success flag and active state or failure reason.</returns>
     public ScriptedAlarmEvalResult Evaluate(string alarmId, string predicate, IReadOnlyDictionary<string, object?> dependencies)
     {
         if (_disposed) return ScriptedAlarmEvalResult.Failure("evaluator disposed");
@@ -94,6 +102,7 @@ public sealed class RoslynScriptedAlarmEvaluator : IScriptedAlarmEvaluator, IDis
         return cache;
     }
 
+    /// <summary>Disposes the evaluator and all cached script evaluators.</summary>
     public void Dispose()
     {
         if (_disposed) return;

src/Server/ZB.MOM.WW.OtOpcUa.Host/Engines/RoslynVirtualTagEvaluator.cs

@@ -31,12 +31,20 @@ public sealed class RoslynVirtualTagEvaluator : IVirtualTagEvaluator, IDisposabl
     private readonly TimeSpan _runTimeout;
     private bool _disposed;
 
+    /// <summary>Initializes a new RoslynVirtualTagEvaluator with the given logger and optional timeout.</summary>
+    /// <param name="logger">Logger for recording compilation and execution errors.</param>
+    /// <param name="runTimeout">Maximum execution time for each script; defaults to 2 seconds if not specified.</param>
     public RoslynVirtualTagEvaluator(ILogger<RoslynVirtualTagEvaluator> logger, TimeSpan? runTimeout = null)
     {
         _logger = logger;
         _runTimeout = runTimeout ?? TimeSpan.FromSeconds(2);
     }
 
+    /// <summary>Evaluates a virtual tag expression against a set of dependencies.</summary>
+    /// <param name="virtualTagId">The virtual tag identifier, used for logging.</param>
+    /// <param name="expression">The C# expression to evaluate.</param>
+    /// <param name="dependencies">Dictionary of tag names to values available in the expression context.</param>
+    /// <returns>The evaluation result, either successful with a value or failed with an error message.</returns>
     public VirtualTagEvalResult Evaluate(string virtualTagId, string expression, IReadOnlyDictionary<string, object?> dependencies)
     {
         if (_disposed) return VirtualTagEvalResult.Failure("evaluator disposed");
@@ -103,6 +111,7 @@ public sealed class RoslynVirtualTagEvaluator : IVirtualTagEvaluator, IDisposabl
         return cache;
     }
 
+    /// <summary>Disposes the evaluator and cleans up all cached script evaluators.</summary>
     public void Dispose()
     {
         if (_disposed) return;

src/Server/ZB.MOM.WW.OtOpcUa.Host/Health/AdminRoleLeaderHealthCheck.cs

@@ -13,11 +13,17 @@ public sealed class AdminRoleLeaderHealthCheck : IHealthCheck
 {
     private readonly IClusterRoleInfo _roleInfo;
 
+    /// <summary>Initializes a new instance of the AdminRoleLeaderHealthCheck class.</summary>
+    /// <param name="roleInfo">The cluster role information provider.</param>
     public AdminRoleLeaderHealthCheck(IClusterRoleInfo roleInfo)
     {
         _roleInfo = roleInfo;
     }
 
+    /// <summary>Checks the health status of the admin role leader.</summary>
+    /// <param name="context">The health check context.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>A task representing the health check operation.</returns>
     public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
     {
         if (!_roleInfo.HasRole("admin"))

src/Server/ZB.MOM.WW.OtOpcUa.Host/Health/AkkaClusterHealthCheck.cs

@@ -8,11 +8,20 @@ public sealed class AkkaClusterHealthCheck : IHealthCheck
 {
     private readonly ActorSystem _system;
 
+    /// <summary>
+    /// Initializes a new instance of the AkkaClusterHealthCheck class.
+    /// </summary>
+    /// <param name="system">The Akka actor system to check cluster health for.</param>
     public AkkaClusterHealthCheck(ActorSystem system)
     {
         _system = system;
     }
 
+    /// <summary>
+    /// Checks the health of the Akka cluster asynchronously.
+    /// </summary>
+    /// <param name="context">The health check context.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
     public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
     {
         var cluster = Akka.Cluster.Cluster.Get(_system);

src/Server/ZB.MOM.WW.OtOpcUa.Host/Health/DatabaseHealthCheck.cs

@@ -8,11 +8,20 @@ public sealed class DatabaseHealthCheck : IHealthCheck
 {
     private readonly IDbContextFactory<OtOpcUaConfigDbContext> _dbFactory;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DatabaseHealthCheck"/> class.
+    /// </summary>
+    /// <param name="dbFactory">The database context factory for the config database.</param>
     public DatabaseHealthCheck(IDbContextFactory<OtOpcUaConfigDbContext> dbFactory)
     {
         _dbFactory = dbFactory;
     }
 
+    /// <summary>
+    /// Checks the health of the configuration database.
+    /// </summary>
+    /// <param name="context">The health check context.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
     public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
     {
         try

src/Server/ZB.MOM.WW.OtOpcUa.Host/Health/HealthEndpoints.cs

@@ -13,6 +13,7 @@ public static class HealthEndpoints
     /// probes. Mirrors ScadaLink's three-tier pattern: <c>ready</c> = boot ok; <c>active</c> =
     /// fully serving traffic; <c>healthz</c> = bare process liveness.
     /// </summary>
+    /// <param name="services">The service collection to register health checks with.</param>
     public static IServiceCollection AddOtOpcUaHealth(this IServiceCollection services)
     {
         services.AddHealthChecks()
@@ -22,6 +23,8 @@ public static class HealthEndpoints
         return services;
     }
 
+    /// <summary>Maps the OtOpcUa health check endpoints to the route builder.</summary>
+    /// <param name="app">The endpoint route builder.</param>
     public static IEndpointRouteBuilder MapOtOpcUaHealth(this IEndpointRouteBuilder app)
     {
         // AllowAnonymous on all three — Traefik / k8s liveness probes / load-balancers

src/Server/ZB.MOM.WW.OtOpcUa.Host/Observability/ObservabilityExtensions.cs

@@ -13,6 +13,8 @@ namespace ZB.MOM.WW.OtOpcUa.Host.Observability;
 /// </summary>
 public static class ObservabilityExtensions
 {
+    /// <summary>Adds OtOpcUa observability (metrics and tracing) to the service collection.</summary>
+    /// <param name="services">The service collection to add observability services to.</param>
     public static IServiceCollection AddOtOpcUaObservability(this IServiceCollection services)
     {
         services.AddOpenTelemetry()
@@ -30,6 +32,7 @@ public static class ObservabilityExtensions
     /// <c>app.UseAuthentication/UseAuthorization</c> if metrics access should require auth;
     /// the default leaves it unauthenticated for local Prometheus scrapes.
     /// </summary>
+    /// <param name="app">The endpoint route builder.</param>
     public static IEndpointRouteBuilder MapOtOpcUaMetrics(this IEndpointRouteBuilder app)
     {
         app.MapPrometheusScrapingEndpoint("/metrics");

src/Server/ZB.MOM.WW.OtOpcUa.Host/OpcUa/LdapOpcUaUserAuthenticator.cs

@@ -16,6 +16,10 @@ public sealed class LdapOpcUaUserAuthenticator(
     ILogger<LdapOpcUaUserAuthenticator> logger)
     : IOpcUaUserAuthenticator
 {
+    /// <summary>Authenticates an OPC UA UserName token via LDAP.</summary>
+    /// <param name="username">The username to authenticate.</param>
+    /// <param name="password">The password to authenticate.</param>
+    /// <param name="ct">Cancellation token.</param>
     public async Task<OpcUaUserAuthResult> AuthenticateUserNameAsync(string username, string password, CancellationToken ct)
     {
         try

src/Server/ZB.MOM.WW.OtOpcUa.Host/OpcUa/OtOpcUaServerHostedService.cs

@@ -30,6 +30,14 @@ public sealed class OtOpcUaServerHostedService : IHostedService, IAsyncDisposabl
     private OpcUaApplicationHost? _appHost;
     private OtOpcUaSdkServer? _server;
 
+    /// <summary>
+    /// Initializes a new instance of the OtOpcUaServerHostedService class.
+    /// </summary>
+    /// <param name="configuration">The application configuration.</param>
+    /// <param name="deferredSink">The deferred address space sink that receives the real sink once the server is ready.</param>
+    /// <param name="deferredServiceLevel">The deferred service level publisher that receives the real publisher once the server is ready.</param>
+    /// <param name="userAuthenticator">The OPC UA user authenticator.</param>
+    /// <param name="loggerFactory">The logger factory for creating loggers.</param>
     public OtOpcUaServerHostedService(
         IConfiguration configuration,
         DeferredAddressSpaceSink deferredSink,
@@ -45,6 +53,10 @@ public sealed class OtOpcUaServerHostedService : IHostedService, IAsyncDisposabl
         _logger = loggerFactory.CreateLogger<OtOpcUaServerHostedService>();
     }
 
+    /// <summary>
+    /// Starts the OPC UA server asynchronously.
+    /// </summary>
+    /// <param name="cancellationToken">Cancellation token.</param>
     public async Task StartAsync(CancellationToken cancellationToken)
     {
         var options = new OpcUaApplicationHostOptions();
@@ -90,6 +102,10 @@ public sealed class OtOpcUaServerHostedService : IHostedService, IAsyncDisposabl
         _logger.LogInformation("OtOpcUaServerHostedService: SDK started, address-space + ServiceLevel sinks bound");
     }
 
+    /// <summary>
+    /// Stops the OPC UA server asynchronously.
+    /// </summary>
+    /// <param name="cancellationToken">Cancellation token.</param>
     public Task StopAsync(CancellationToken cancellationToken)
     {
         // Revert to Null adapters so any in-flight writes from a poison-pilled actor don't hit a
@@ -99,6 +115,9 @@ public sealed class OtOpcUaServerHostedService : IHostedService, IAsyncDisposabl
         return Task.CompletedTask;
     }
 
+    /// <summary>
+    /// Disposes the hosted service and its resources asynchronously.
+    /// </summary>
     public async ValueTask DisposeAsync()
     {
         if (_appHost is not null) await _appHost.DisposeAsync();