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/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Modbus/ModbusDriver.cs

@@ -77,7 +77,9 @@ public sealed class ModbusDriver
     // and the Volatile API is the documented portable form).
     private DriverHealth _health = new(DriverState.Unknown, null, null);
 
+    /// <summary>Occurs when a subscribed tag value changes.</summary>
     public event EventHandler<DataChangeEventArgs>? OnDataChange;
+    /// <summary>Occurs when host connectivity status changes.</summary>
     public event EventHandler<HostStatusChangedEventArgs>? OnHostStatusChanged;
 
     // ---- nested types ----
@@ -96,6 +98,11 @@ public sealed class ModbusDriver
 
     // ---- ctor + identity ----
 
+    /// <summary>Initializes a new Modbus TCP driver with the specified options and transport factory.</summary>
+    /// <param name="options">Driver configuration options.</param>
+    /// <param name="driverInstanceId">Unique identifier for this driver instance.</param>
+    /// <param name="transportFactory">Factory to create the Modbus transport; defaults to ModbusTcpTransport.</param>
+    /// <param name="logger">Logger instance; defaults to null logger if not provided.</param>
     public ModbusDriver(ModbusDriverOptions options, string driverInstanceId,
         Func<ModbusDriverOptions, IModbusTransport>? transportFactory = null,
         ILogger<ModbusDriver>? logger = null)
@@ -127,6 +134,7 @@ public sealed class ModbusDriver
     ///     returned host string, so a dead RTU slave behind an Ethernet gateway opens its own
     ///     breaker without tripping siblings on the same TCP socket.
     /// </summary>
+    /// <param name="fullReference">Tag reference to resolve the host for.</param>
     public string ResolveHost(string fullReference)
     {
         if (_tagsByName.TryGetValue(fullReference, out var tag))
@@ -163,9 +171,14 @@ public sealed class ModbusDriver
         return true;
     }
 
+    /// <summary>Gets the unique identifier of this driver instance.</summary>
     public string DriverInstanceId => _driverInstanceId;
+    /// <summary>Gets the driver type name.</summary>
     public string DriverType => "Modbus";
 
+    /// <summary>Initializes the driver with the specified configuration JSON.</summary>
+    /// <param name="driverConfigJson">JSON configuration string.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
     public async Task InitializeAsync(string driverConfigJson, CancellationToken cancellationToken)
     {
         WriteHealth(new DriverHealth(DriverState.Initializing, null, null));
@@ -199,12 +212,17 @@ public sealed class ModbusDriver
         }
     }
 
+    /// <summary>Reinitializes the driver with new configuration.</summary>
+    /// <param name="driverConfigJson">New JSON configuration string.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
     public async Task ReinitializeAsync(string driverConfigJson, CancellationToken cancellationToken)
     {
         await ShutdownAsync(cancellationToken);
         await InitializeAsync(driverConfigJson, cancellationToken);
     }
 
+    /// <summary>Shuts down the driver and releases resources.</summary>
+    /// <param name="cancellationToken">Cancellation token.</param>
     public async Task ShutdownAsync(CancellationToken cancellationToken)
     {
         var lastRead = ReadHealth().LastSuccessfulRead;
@@ -212,6 +230,7 @@ public sealed class ModbusDriver
         WriteHealth(new DriverHealth(DriverState.Unknown, lastRead, null));
     }
 
+    /// <summary>Gets the current driver health status.</summary>
     public DriverHealth GetHealth() => ReadHealth();
 
     /// <summary>
@@ -226,11 +245,17 @@ public sealed class ModbusDriver
     ///     Driver.Modbus-003: barrier-protected publish of a new <c>_health</c> snapshot.
     /// </summary>
     private void WriteHealth(DriverHealth value) => Volatile.Write(ref _health, value);
+    /// <summary>Gets the memory footprint of the driver.</summary>
     public long GetMemoryFootprint() => 0;
+    /// <summary>Flushes optional caches to free memory.</summary>
+    /// <param name="cancellationToken">Cancellation token.</param>
     public Task FlushOptionalCachesAsync(CancellationToken cancellationToken) => Task.CompletedTask;
 
     // ---- ITagDiscovery ----
 
+    /// <summary>Discovers tags and builds the OPC UA address space.</summary>
+    /// <param name="builder">Address space builder.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
     public Task DiscoverAsync(IAddressSpaceBuilder builder, CancellationToken cancellationToken)
     {
         ArgumentNullException.ThrowIfNull(builder);
@@ -252,6 +277,9 @@ public sealed class ModbusDriver
 
     // ---- IReadable ----
 
+    /// <summary>Reads the specified tag references from the Modbus device.</summary>
+    /// <param name="fullReferences">Tag references to read.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
     public async Task<IReadOnlyList<DataValueSnapshot>> ReadAsync(
         IReadOnlyList<string> fullReferences, CancellationToken cancellationToken)
     {
@@ -558,6 +586,7 @@ public sealed class ModbusDriver
     ///     each entry decides between bisection (multi-register + SplitPending) or straight
     ///     retry (single-register or already-narrowed).
     /// </summary>
+    /// <param name="ct">Cancellation token.</param>
     internal async Task RunReprobeOnceForTestAsync(CancellationToken ct)
     {
         var transport = _transport ?? throw new InvalidOperationException("Transport not connected");
@@ -891,6 +920,9 @@ public sealed class ModbusDriver
 
     // ---- IWritable ----
 
+    /// <summary>Writes values to the specified tag references on the Modbus device.</summary>
+    /// <param name="writes">Write requests to execute.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
     public async Task<IReadOnlyList<WriteResult>> WriteAsync(
         IReadOnlyList<WriteRequest> writes, CancellationToken cancellationToken)
     {
@@ -1128,10 +1160,17 @@ public sealed class ModbusDriver
 
     // ---- ISubscribable (polling overlay via shared engine) ----
 
+    /// <summary>Subscribes to value changes on the specified tag references.</summary>
+    /// <param name="fullReferences">Tag references to subscribe to.</param>
+    /// <param name="publishingInterval">Interval for publishing changes.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
     public Task<ISubscriptionHandle> SubscribeAsync(
         IReadOnlyList<string> fullReferences, TimeSpan publishingInterval, CancellationToken cancellationToken) =>
         Task.FromResult(_poll.Subscribe(fullReferences, publishingInterval));
 
+    /// <summary>Unsubscribes from value changes using the specified handle.</summary>
+    /// <param name="handle">Subscription handle.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
     public Task UnsubscribeAsync(ISubscriptionHandle handle, CancellationToken cancellationToken)
     {
         _poll.Unsubscribe(handle);
@@ -1140,6 +1179,7 @@ public sealed class ModbusDriver
 
     // ---- IHostConnectivityProbe ----
 
+    /// <summary>Gets the current connectivity status for all hosts.</summary>
     public IReadOnlyList<HostConnectivityStatus> GetHostStatuses()
     {
         lock (_probeLock)
@@ -1205,6 +1245,7 @@ public sealed class ModbusDriver
     ///     types (Int32/Float32 = 2 regs, Int64/Float64 = 4 regs) and for strings (rounded up
     ///     from 2 chars per register).
     /// </summary>
+    /// <param name="tag">Tag definition to measure.</param>
     internal static ushort RegisterCount(ModbusTagDefinition tag) => tag.DataType switch
     {
         ModbusDataType.Int16 or ModbusDataType.UInt16 or ModbusDataType.BitInRegister or ModbusDataType.Bcd16 => 1,
@@ -1262,6 +1303,9 @@ public sealed class ModbusDriver
         return result;
     }
 
+    /// <summary>Decodes a register value according to the tag's data type.</summary>
+    /// <param name="data">Raw register bytes.</param>
+    /// <param name="tag">Tag definition specifying the data type.</param>
     internal static object DecodeRegister(ReadOnlySpan<byte> data, ModbusTagDefinition tag)
     {
         switch (tag.DataType)
@@ -1340,6 +1384,9 @@ public sealed class ModbusDriver
         }
     }
 
+    /// <summary>Encodes a value into register bytes according to the tag's data type.</summary>
+    /// <param name="value">Value to encode.</param>
+    /// <param name="tag">Tag definition specifying the data type.</param>
     internal static byte[] EncodeRegister(object? value, ModbusTagDefinition tag)
     {
         switch (tag.DataType)
@@ -1473,6 +1520,8 @@ public sealed class ModbusDriver
     ///     the hardware sometimes produces garbage during transitions and silent non-BCD reads
     ///     would quietly corrupt the caller's data.
     /// </summary>
+    /// <param name="raw">Raw BCD value.</param>
+    /// <param name="nibbles">Number of nibbles to decode.</param>
     internal static uint DecodeBcd(uint raw, int nibbles)
     {
         uint result = 0;
@@ -1491,6 +1540,8 @@ public sealed class ModbusDriver
     ///     Encode a decimal value as N-nibble BCD. Caller is responsible for range-checking
     ///     against the nibble capacity (10^nibbles - 1).
     /// </summary>
+    /// <param name="value">Decimal value to encode.</param>
+    /// <param name="nibbles">Number of nibbles to encode.</param>
     internal static uint EncodeBcd(uint value, int nibbles)
     {
         uint result = 0;
@@ -1524,6 +1575,7 @@ public sealed class ModbusDriver
     ///     <c>docs/v2/dl205.md</c>, DL205/DL260 returns only codes 01-04 — no proprietary
     ///     extensions.
     /// </summary>
+    /// <param name="exceptionCode">Modbus exception code.</param>
     internal static uint MapModbusExceptionToStatus(byte exceptionCode) => exceptionCode switch
     {
         0x01 => StatusBadNotSupported,     // Illegal Function — FC not in supported list
@@ -1535,6 +1587,7 @@ public sealed class ModbusDriver
         _ => StatusBadInternalError,
     };
 
+    /// <summary>Releases resources used by the driver.</summary>
     public void Dispose() => DisposeAsync().AsTask().GetAwaiter().GetResult();
 
     /// <summary>