feat(twincat): BOOL-within-word writes via driver-level parent-word RMW

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.TwinCAT/AdsTwinCATClient.cs

@@ -175,7 +175,9 @@ internal sealed class AdsTwinCATClient : ITwinCATClient
     /// </summary>
     /// <param name="symbolPath">The ADS symbol path to write to.</param>
     /// <param name="type">The TwinCAT data type.</param>
-    /// <param name="bitIndex">Optional bit index for BOOL values (not supported for writes).</param>
+    /// <param name="bitIndex">Optional bit index for BOOL values. BOOL-within-word writes are handled
+    ///     upstream by <see cref="TwinCATDriver.WriteAsync"/> as a parent-word read-modify-write, so a
+    ///     bit index does not reach this method on the write path.</param>
     /// <param name="value">The value to write.</param>
     /// <param name="cancellationToken">The cancellation token.</param>
     /// <returns>The OPC UA status code of the write operation.</returns>
@@ -186,10 +188,6 @@ internal sealed class AdsTwinCATClient : ITwinCATClient
         object? value,
         CancellationToken cancellationToken)
     {
-        if (bitIndex is int && type == TwinCATDataType.Bool)
-            throw new NotSupportedException(
-                "BOOL-within-word writes require read-modify-write; tracked in task #181.");
-
         try
         {
             var converted = ConvertForWrite(type, value);

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.TwinCAT/TwinCATDriver.cs

@@ -28,6 +28,14 @@ public sealed class TwinCATDriver : IDriver, IReadable, IWritable, ITagDiscovery
     private readonly ConcurrentDictionary<string, TwinCATTagDefinition> _tagsByName =
         new(StringComparer.OrdinalIgnoreCase);
 
+    // Per-parent-word RMW gate for BOOL-within-word writes: a single-bit write is a
+    // read-modify-write of the parent word (TwinCAT's symbol table doesn't expose "Word.N"),
+    // so concurrent bit-writers to the same word must serialise or they lose each other's
+    // updates. Keyed by device + parent symbol. (Cannot guard against the PLC program writing
+    // the word between our read and write — inherent to RMW.)
+    private readonly ConcurrentDictionary<string, SemaphoreSlim> _bitRmwLocks =
+        new(StringComparer.OrdinalIgnoreCase);
+
     // Resolves a read/write/subscribe fullReference to a tag definition, bridging the two
     // authoring models: an authored tag-table entry (by name) OR an equipment tag whose
     // reference is its raw TagConfig JSON (parsed once via TwinCATEquipmentTagParser, cached).
@@ -293,6 +301,40 @@ public sealed class TwinCATDriver : IDriver, IReadable, IWritable, ITagDiscovery
             {
                 var client = await EnsureConnectedAsync(device, cancellationToken).ConfigureAwait(false);
                 var parsed = TwinCATSymbolPath.TryParse(def.SymbolPath);
+
+                // BOOL-within-word write — read-modify-write of the parent word. Mirrors the bit-read
+                // (AdsTwinCATClient.ReadValueAsync) which reads the parent as uint: read the parent as
+                // UDInt (-> uint), flip the bit, write it back, all under a per-parent lock.
+                if (def.DataType == TwinCATDataType.Bool && parsed?.BitIndex is int bit)
+                {
+                    var parentPath = (parsed with { BitIndex = null }).ToAdsSymbolName();
+                    var gate = _bitRmwLocks.GetOrAdd(
+                        $"{def.DeviceHostAddress}|{parentPath}", static _ => new SemaphoreSlim(1, 1));
+                    await gate.WaitAsync(cancellationToken).ConfigureAwait(false);
+                    try
+                    {
+                        var (parentValue, readStatus) = await client.ReadValueAsync(
+                            parentPath, TwinCATDataType.UDInt, null, null, cancellationToken).ConfigureAwait(false);
+                        if (readStatus != TwinCATStatusMapper.Good)
+                        {
+                            results[i] = new WriteResult(readStatus);
+                        }
+                        else
+                        {
+                            var word = Convert.ToUInt32(parentValue ?? 0u);
+                            var updated = Convert.ToBoolean(w.Value) ? word | (1u << bit) : word & ~(1u << bit);
+                            var writeStatus = await client.WriteValueAsync(
+                                parentPath, TwinCATDataType.UDInt, null, updated, cancellationToken).ConfigureAwait(false);
+                            results[i] = new WriteResult(writeStatus);
+                        }
+                    }
+                    finally
+                    {
+                        gate.Release();
+                    }
+                    continue;
+                }
+
                 var symbolName = parsed?.ToAdsSymbolName() ?? def.SymbolPath;
                 var status = await client.WriteValueAsync(
                     symbolName, def.DataType, parsed?.BitIndex, w.Value, cancellationToken).ConfigureAwait(false);