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.

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Drivers/DeploymentArtifactTests.cs

@@ -8,18 +8,21 @@ namespace ZB.MOM.WW.OtOpcUa.Runtime.Tests.Drivers;
 
 public sealed class DeploymentArtifactTests
 {
+    /// <summary>Verifies that empty blob returns empty list.</summary>
     [Fact]
     public void Empty_blob_returns_empty_list()
     {
         DeploymentArtifact.ParseDriverInstances(ReadOnlySpan<byte>.Empty).ShouldBeEmpty();
     }
 
+    /// <summary>Verifies that malformed JSON returns empty list.</summary>
     [Fact]
     public void Malformed_json_returns_empty_list()
     {
         DeploymentArtifact.ParseDriverInstances(Encoding.UTF8.GetBytes("not json")).ShouldBeEmpty();
     }
 
+    /// <summary>Verifies that snapshot without DriverInstances returns empty.</summary>
     [Fact]
     public void Snapshot_without_DriverInstances_returns_empty()
     {
@@ -27,6 +30,7 @@ public sealed class DeploymentArtifactTests
         DeploymentArtifact.ParseDriverInstances(blob).ShouldBeEmpty();
     }
 
+    /// <summary>Verifies that driver instances are parsed from composer-shaped blob.</summary>
     [Fact]
     public void Parses_driver_instances_from_composer_shaped_blob()
     {
@@ -69,6 +73,7 @@ public sealed class DeploymentArtifactTests
         specs[1].Enabled.ShouldBeFalse();
     }
 
+    /// <summary>Verifies that ParseComposition returns empty for empty blob.</summary>
     [Fact]
     public void ParseComposition_returns_empty_for_empty_blob()
     {
@@ -78,6 +83,7 @@ public sealed class DeploymentArtifactTests
         c.ScriptedAlarmPlans.ShouldBeEmpty();
     }
 
+    /// <summary>Verifies that ParseComposition reads all three entity classes sorted by ID.</summary>
     [Fact]
     public void ParseComposition_reads_all_three_entity_classes_sorted_by_id()
     {
@@ -111,6 +117,7 @@ public sealed class DeploymentArtifactTests
         c.ScriptedAlarmPlans.Single().ScriptedAlarmId.ShouldBe("alarm-1");
     }
 
+    /// <summary>Verifies that specs missing required fields are dropped.</summary>
     [Fact]
     public void Spec_missing_required_fields_is_dropped()
     {

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Drivers/DriverHostActorReconcileTests.cs

@@ -21,6 +21,7 @@ public sealed class DriverHostActorReconcileTests : RuntimeActorTestBase
     private static readonly RevisionHash RevA = RevisionHash.Parse(new string('a', 64));
     private static readonly RevisionHash RevB = RevisionHash.Parse(new string('b', 64));
 
+    /// <summary>Verifies that applying a deployment with driver instances spawns one child per enabled row.</summary>
     [Fact]
     public void Apply_with_driver_instances_in_artifact_spawns_one_child_per_enabled_row()
     {
@@ -43,6 +44,7 @@ public sealed class DriverHostActorReconcileTests : RuntimeActorTestBase
         AwaitAssert(() => factory.CreateCount.ShouldBe(2), duration: TimeSpan.FromSeconds(3));
     }
 
+    /// <summary>Verifies that applying a deployment with unsupported driver type falls back to stub.</summary>
     [Fact]
     public void Apply_with_unsupported_driver_type_falls_back_to_stub()
     {
@@ -72,6 +74,7 @@ public sealed class DriverHostActorReconcileTests : RuntimeActorTestBase
         snap.Drivers[0].State.ShouldBe("Stubbed");
     }
 
+    /// <summary>Verifies that Galaxy driver on non-Windows is stubbed by ShouldStub check.</summary>
     [Fact]
     public void Galaxy_on_non_windows_is_stubbed_by_ShouldStub_check()
     {
@@ -102,6 +105,7 @@ public sealed class DriverHostActorReconcileTests : RuntimeActorTestBase
         }
     }
 
+    /// <summary>Verifies that a second apply with removed driver stops the child.</summary>
     [Fact]
     public void Second_apply_with_removed_driver_stops_the_child()
     {
@@ -161,12 +165,20 @@ public sealed class DriverHostActorReconcileTests : RuntimeActorTestBase
         return id;
     }
 
+    /// <summary>Test double for IDriverFactory that counts driver creation attempts.</summary>
     private sealed class CountingDriverFactory : IDriverFactory
     {
         private readonly string _supportedType;
+        /// <summary>Gets the number of times TryCreate was called and returned a driver.</summary>
         public int CreateCount;
+        /// <summary>Initializes a new instance with the specified supported driver type.</summary>
+        /// <param name="supportedType">The driver type this factory supports.</param>
         public CountingDriverFactory(string supportedType) { _supportedType = supportedType; }
 
+        /// <summary>Attempts to create a driver if the type is supported.</summary>
+        /// <param name="driverType">The driver type to create.</param>
+        /// <param name="driverInstanceId">The unique identifier for the driver instance.</param>
+        /// <param name="driverConfigJson">The driver configuration in JSON format.</param>
         public IDriver? TryCreate(string driverType, string driverInstanceId, string driverConfigJson)
         {
             if (!string.Equals(driverType, _supportedType, StringComparison.Ordinal)) return null;
@@ -174,19 +186,32 @@ public sealed class DriverHostActorReconcileTests : RuntimeActorTestBase
             return new TestDriver(driverInstanceId, driverType);
         }
 
+        /// <inheritdoc />
         public IReadOnlyCollection<string> SupportedTypes => new[] { _supportedType };
     }
 
+    /// <summary>Test double for IDriver with minimal implementation.</summary>
     private sealed class TestDriver : IDriver
     {
+        /// <inheritdoc />
         public string DriverInstanceId { get; }
+        /// <inheritdoc />
         public string DriverType { get; }
+        /// <summary>Initializes a new test driver with the specified ID and type.</summary>
+        /// <param name="id">The driver instance ID.</param>
+        /// <param name="type">The driver type.</param>
         public TestDriver(string id, string type) { DriverInstanceId = id; DriverType = type; }
+        /// <inheritdoc />
         public Task InitializeAsync(string driverConfigJson, CancellationToken cancellationToken) => Task.CompletedTask;
+        /// <inheritdoc />
         public Task ReinitializeAsync(string driverConfigJson, CancellationToken cancellationToken) => Task.CompletedTask;
+        /// <inheritdoc />
         public Task ShutdownAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+        /// <inheritdoc />
         public DriverHealth GetHealth() => new(DriverState.Healthy, DateTime.UtcNow, LastError: null);
+        /// <inheritdoc />
         public long GetMemoryFootprint() => 0;
+        /// <inheritdoc />
         public Task FlushOptionalCachesAsync(CancellationToken cancellationToken) => Task.CompletedTask;
     }
 }

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Drivers/DriverHostActorTests.cs

@@ -17,6 +17,7 @@ public sealed class DriverHostActorTests : RuntimeActorTestBase
     private static readonly RevisionHash RevA = RevisionHash.Parse(new string('a', 64));
     private static readonly RevisionHash RevB = RevisionHash.Parse(new string('b', 64));
 
+    /// <summary>Verifies that bootstrap with no prior state enters the Steady state.</summary>
     [Fact]
     public void Bootstrap_with_no_prior_state_enters_Steady()
     {
@@ -33,6 +34,7 @@ public sealed class DriverHostActorTests : RuntimeActorTestBase
         ack.NodeId.ShouldBe(TestNode);
     }
 
+    /// <summary>Verifies that dispatching the same revision is acked immediately without apply work.</summary>
     [Fact]
     public void Same_revision_dispatch_is_acked_immediately_with_no_apply_work()
     {
@@ -66,6 +68,7 @@ public sealed class DriverHostActorTests : RuntimeActorTestBase
         verify.NodeDeploymentStates.Count(s => s.NodeId == TestNode.Value).ShouldBe(1);
     }
 
+    /// <summary>Verifies that a new revision dispatch writes an Applied NodeDeploymentState.</summary>
     [Fact]
     public void New_revision_dispatch_writes_Applied_NodeDeploymentState()
     {
@@ -89,6 +92,7 @@ public sealed class DriverHostActorTests : RuntimeActorTestBase
         }, duration: TimeSpan.FromSeconds(3));
     }
 
+    /// <summary>Verifies that an orphaned Applying row on bootstrap is replayed.</summary>
     [Fact]
     public void Orphan_Applying_row_on_bootstrap_replays_apply()
     {

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Drivers/DriverInstanceActorTests.cs

@@ -11,6 +11,7 @@ namespace ZB.MOM.WW.OtOpcUa.Runtime.Tests.Drivers;
 
 public sealed class DriverInstanceActorTests : RuntimeActorTestBase
 {
+    /// <summary>Verifies that ApplyDelta calls ReinitializeAsync when connected and replies success.</summary>
     [Fact]
     public async Task ApplyDelta_when_Connected_calls_ReinitializeAsync_and_replies_success()
     {
@@ -32,6 +33,7 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
         driver.ReinitializeCount.ShouldBe(1);
     }
 
+    /// <summary>Verifies that initialize failure keeps the actor in Reconnecting state.</summary>
     [Fact]
     public void Initialize_failure_keeps_actor_in_Reconnecting_state()
     {
@@ -45,6 +47,7 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
         AwaitCondition(() => driver.InitializeCount >= 3, TimeSpan.FromSeconds(2));
     }
 
+    /// <summary>Verifies that writing to a non-IWritable driver returns failure.</summary>
     [Fact]
     public async Task Write_against_non_IWritable_driver_returns_failure()
     {
@@ -62,6 +65,7 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
         reply.Reason!.ShouldContain("IWritable");
     }
 
+    /// <summary>Verifies that writing to an IWritable driver returns success when status is Good.</summary>
     [Fact]
     public async Task Write_against_IWritable_returns_success_when_status_is_Good()
     {
@@ -80,6 +84,7 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
         driver.Writes.Single().Value.ShouldBe(42);
     }
 
+    /// <summary>Verifies that write propagates status code on Bad result.</summary>
     [Fact]
     public async Task Write_propagates_status_code_on_Bad_result()
     {
@@ -98,6 +103,7 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
         reply.Reason!.ShouldContain("80340000");
     }
 
+    /// <summary>Verifies that subscribing to an ISubscribable driver forwards OnDataChange to parent.</summary>
     [Fact]
     public async Task Subscribe_against_ISubscribable_forwards_OnDataChange_to_parent()
     {
@@ -122,6 +128,7 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
         published.Quality.ShouldBe(OpcUaQuality.Good);
     }
 
+    /// <summary>Verifies that subscribe translates OPC UA status severity bits to OpcUaQuality.</summary>
     [Fact]
     public async Task Subscribe_translates_OPC_UA_status_severity_bits_to_OpcUaQuality()
     {
@@ -145,6 +152,7 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
         parent.ExpectMsg<DriverInstanceActor.AttributeValuePublished>().Quality.ShouldBe(OpcUaQuality.Bad);
     }
 
+    /// <summary>Verifies that subscribing to a non-ISubscribable driver replies with failure.</summary>
     [Fact]
     public async Task Subscribe_against_non_ISubscribable_replies_with_failure()
     {
@@ -161,6 +169,7 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
         reply.Reason.ShouldContain("ISubscribable");
     }
 
+    /// <summary>Verifies that DisconnectObserved detaches subscription handler so late events are dropped.</summary>
     [Fact]
     public async Task DisconnectObserved_detaches_subscription_handler_so_late_events_are_dropped()
     {
@@ -185,13 +194,21 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
 
     private class StubDriver : IDriver
     {
+        /// <summary>Gets or sets a value indicating whether initialization should throw.</summary>
         public bool InitializeShouldThrow { get; set; }
+        /// <summary>Gets the number of times initialization was called.</summary>
         public int InitializeCount;
+        /// <summary>Gets the number of times reinitialization was called.</summary>
         public int ReinitializeCount;
 
+        /// <summary>Gets the driver instance ID.</summary>
         public string DriverInstanceId => "stub-driver-1";
+        /// <summary>Gets the driver type.</summary>
         public string DriverType => "Stub";
 
+        /// <summary>Initializes the driver with the specified configuration JSON.</summary>
+        /// <param name="driverConfigJson">The driver configuration JSON.</param>
+        /// <param name="cancellationToken">Cancellation token for the operation.</param>
         public Task InitializeAsync(string driverConfigJson, CancellationToken cancellationToken)
         {
             Interlocked.Increment(ref InitializeCount);
@@ -199,23 +216,37 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
             return Task.CompletedTask;
         }
 
+        /// <summary>Reinitializes the driver with the specified configuration JSON.</summary>
+        /// <param name="driverConfigJson">The driver configuration JSON.</param>
+        /// <param name="cancellationToken">Cancellation token for the operation.</param>
         public Task ReinitializeAsync(string driverConfigJson, CancellationToken cancellationToken)
         {
             Interlocked.Increment(ref ReinitializeCount);
             return Task.CompletedTask;
         }
 
+        /// <summary>Shuts down the driver.</summary>
+        /// <param name="cancellationToken">Cancellation token for the operation.</param>
         public Task ShutdownAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+        /// <summary>Gets the health status of the driver.</summary>
         public DriverHealth GetHealth() => new(DriverState.Healthy, DateTime.UtcNow, null);
+        /// <summary>Gets the memory footprint of the driver.</summary>
         public long GetMemoryFootprint() => 0;
+        /// <summary>Flushes optional caches in the driver.</summary>
+        /// <param name="cancellationToken">Cancellation token for the operation.</param>
         public Task FlushOptionalCachesAsync(CancellationToken cancellationToken) => Task.CompletedTask;
     }
 
     private sealed class WritableStubDriver : StubDriver, IWritable
     {
+        /// <summary>Gets or sets the next status code to return from write operations.</summary>
         public uint NextStatusCode { get; set; } = 0u;
+        /// <summary>Gets the list of write requests received.</summary>
         public List<WriteRequest> Writes { get; } = new();
 
+        /// <summary>Writes the specified requests.</summary>
+        /// <param name="writes">The write requests.</param>
+        /// <param name="cancellationToken">Cancellation token for the operation.</param>
         public Task<IReadOnlyList<WriteResult>> WriteAsync(
             IReadOnlyList<WriteRequest> writes, CancellationToken cancellationToken)
         {
@@ -227,19 +258,32 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
 
     private sealed class SubscribableStubDriver : StubDriver, ISubscribable
     {
+        /// <summary>Occurs when data changes.</summary>
         public event EventHandler<DataChangeEventArgs>? OnDataChange;
 
         private readonly StubHandle _handle = new();
 
+        /// <summary>Gets the number of subscribers to OnDataChange.</summary>
         public int OnDataChangeSubscriberCount => OnDataChange?.GetInvocationList().Length ?? 0;
 
+        /// <summary>Subscribes to the specified full references.</summary>
+        /// <param name="fullReferences">The full references to subscribe to.</param>
+        /// <param name="publishingInterval">The publishing interval.</param>
+        /// <param name="cancellationToken">Cancellation token for the operation.</param>
         public Task<ISubscriptionHandle> SubscribeAsync(
             IReadOnlyList<string> fullReferences, TimeSpan publishingInterval, CancellationToken cancellationToken)
             => Task.FromResult<ISubscriptionHandle>(_handle);
 
+        /// <summary>Unsubscribes from the specified subscription handle.</summary>
+        /// <param name="handle">The subscription handle.</param>
+        /// <param name="cancellationToken">Cancellation token for the operation.</param>
         public Task UnsubscribeAsync(ISubscriptionHandle handle, CancellationToken cancellationToken)
             => Task.CompletedTask;
 
+        /// <summary>Fires a data change event with the specified parameters.</summary>
+        /// <param name="fullRef">The full reference of the data that changed.</param>
+        /// <param name="value">The new value.</param>
+        /// <param name="statusCode">The OPC UA status code.</param>
         public void FireDataChange(string fullRef, object? value, uint statusCode)
         {
             var snapshot = new DataValueSnapshot(value, statusCode, DateTime.UtcNow, DateTime.UtcNow);
@@ -248,6 +292,7 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
 
         private sealed class StubHandle : ISubscriptionHandle
         {
+            /// <summary>Gets the diagnostic ID of the subscription.</summary>
             public string DiagnosticId => "stub-sub";
         }
     }

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Drivers/DriverSpawnPlannerTests.cs

@@ -9,6 +9,7 @@ public sealed class DriverSpawnPlannerTests
     private static DriverInstanceSpec Spec(string id, string type = "Modbus", string config = "{\"host\":\"127.0.0.1\"}", bool enabled = true) =>
         new(Guid.NewGuid(), id, id, type, enabled, config);
 
+    /// <summary>Verifies that all new drivers are placed in ToSpawn when current is empty.</summary>
     [Fact]
     public void All_new_drivers_go_into_ToSpawn_when_current_is_empty()
     {
@@ -22,6 +23,7 @@ public sealed class DriverSpawnPlannerTests
         plan.ToStop.ShouldBeEmpty();
     }
 
+    /// <summary>Verifies that the same configuration yields an empty plan.</summary>
     [Fact]
     public void Same_config_yields_empty_plan()
     {
@@ -38,6 +40,7 @@ public sealed class DriverSpawnPlannerTests
         plan.ToStop.ShouldBeEmpty();
     }
 
+    /// <summary>Verifies that different configuration is routed to ApplyDelta.</summary>
     [Fact]
     public void Different_config_routes_to_ApplyDelta()
     {
@@ -54,6 +57,7 @@ public sealed class DriverSpawnPlannerTests
         plan.ToStop.ShouldBeEmpty();
     }
 
+    /// <summary>Verifies that removed drivers are routed to ToStop.</summary>
     [Fact]
     public void Removed_driver_routes_to_ToStop()
     {
@@ -71,6 +75,7 @@ public sealed class DriverSpawnPlannerTests
         plan.ToApplyDelta.ShouldBeEmpty();
     }
 
+    /// <summary>Verifies that disabled drivers with running children are routed to ToStop.</summary>
     [Fact]
     public void Disabled_driver_with_running_child_routes_to_ToStop()
     {
@@ -87,6 +92,7 @@ public sealed class DriverSpawnPlannerTests
         plan.ToApplyDelta.ShouldBeEmpty();
     }
 
+    /// <summary>Verifies that disabled new drivers are not spawned.</summary>
     [Fact]
     public void Disabled_new_driver_is_not_spawned()
     {
@@ -100,6 +106,7 @@ public sealed class DriverSpawnPlannerTests
         plan.ToStop.ShouldBeEmpty();
     }
 
+    /// <summary>Verifies that driver type changes trigger stop followed by respawn.</summary>
     [Fact]
     public void Driver_type_change_triggers_stop_plus_respawn()
     {