Merge remote-tracking branch 'origin/main' into agent-3/issue-32-implement-heartbeat-and-watchdog

# Conflicts: # src/MxGateway.Worker/Ipc/WorkerPipeSession.cs # src/MxGateway.Worker/MxAccess/MxAccessStaSession.cs
2026-04-26 19:16:42 -04:00
parent 4a3560c7ee 95e71cd819
commit 7d67313a7d
70 changed files with 3195 additions and 364 deletions
@@ -100,6 +100,7 @@ public sealed class WorkerPipeClientTests
    private sealed class FakeRuntimeSession : IWorkerRuntimeSession
    {
        public Task<WorkerReady> StartAsync(
+            string sessionId,
            int workerProcessId,
            CancellationToken cancellationToken = default)
        {
@@ -490,6 +490,7 @@ public sealed class WorkerPipeSessionTests
        public bool BlockDispatch { get; set; }

        public Task<WorkerReady> StartAsync(
+            string sessionId,
            int workerProcessId,
            CancellationToken cancellationToken = default)
        {
@@ -177,6 +177,30 @@ public sealed class MxAccessCommandExecutorTests
        Assert.Empty(await session.GetRegisteredItemHandlesAsync());
    }

+    [Fact]
+    public async Task DispatchAsync_RemoveItemWithAdvisedHandle_RemovesTrackedAdviceAfterMxAccessSucceeds()
+    {
+        FakeMxAccessComObject fakeComObject = new(
+            registerHandle: 148,
+            addItemHandle: 603);
+        FakeMxAccessComObjectFactory factory = new(fakeComObject);
+        using StaRuntime runtime = CreateRuntime();
+        using MxAccessStaSession session = new(runtime, factory, new NoopEventSink());
+        await session.StartAsync(workerProcessId: 1234);
+        await session.DispatchAsync(CreateRegisterCommand("register-before-advised-remove", "client-a"));
+        await session.DispatchAsync(CreateAddItemCommand("add-before-advised-remove", 148, "Galaxy.Tag.Value"));
+        await session.DispatchAsync(CreateAdviseCommand("advise-before-remove", 148, 603));
+
+        MxCommandReply reply = await session.DispatchAsync(CreateRemoveItemCommand(
+            "remove-advised-item",
+            148,
+            603));
+
+        Assert.Equal(ProtocolStatusCode.Ok, reply.ProtocolStatus.Code);
+        Assert.Empty(await session.GetRegisteredItemHandlesAsync());
+        Assert.Empty(await session.GetRegisteredAdviceHandlesAsync());
+    }
+
    [Fact]
    public async Task DispatchAsync_RemoveItemWithCrossServerHandle_PreservesHResultAndKeepsTrackedItemHandle()
    {
@@ -238,6 +262,158 @@ public sealed class MxAccessCommandExecutorTests
        Assert.Empty(await session.GetRegisteredItemHandlesAsync());
    }

+    [Fact]
+    public async Task DispatchAsync_Advise_CallsMxAccessOnStaAndTracksPlainAdvice()
+    {
+        FakeMxAccessComObject fakeComObject = new(
+            registerHandle: 52,
+            addItemHandle: 505);
+        FakeMxAccessComObjectFactory factory = new(fakeComObject);
+        using StaRuntime runtime = CreateRuntime();
+        using MxAccessStaSession session = new(runtime, factory, new NoopEventSink());
+        await session.StartAsync(workerProcessId: 1234);
+        await session.DispatchAsync(CreateRegisterCommand("register-before-advise", "client-a"));
+        await session.DispatchAsync(CreateAddItemCommand("add-before-advise", 52, "Galaxy.Tag.Value"));
+
+        MxCommandReply reply = await session.DispatchAsync(CreateAdviseCommand(
+            "advise",
+            52,
+            505));
+
+        Assert.Equal(ProtocolStatusCode.Ok, reply.ProtocolStatus.Code);
+        Assert.True(reply.HasHresult);
+        Assert.Equal(0, reply.Hresult);
+        Assert.Equal(52, fakeComObject.AdviseServerHandle);
+        Assert.Equal(505, fakeComObject.AdvisedItemHandle);
+        Assert.Equal(runtime.StaThreadId, fakeComObject.AdviseThreadId);
+
+        RegisteredAdviceHandle adviceHandle = Assert.Single(
+            await session.GetRegisteredAdviceHandlesAsync());
+        Assert.Equal(52, adviceHandle.ServerHandle);
+        Assert.Equal(505, adviceHandle.ItemHandle);
+        Assert.Equal(MxAccessAdviceKind.Plain, adviceHandle.AdviceKind);
+    }
+
+    [Fact]
+    public async Task DispatchAsync_AdviseSupervisory_CallsDistinctMxAccessMethodAndTracksSupervisoryAdvice()
+    {
+        FakeMxAccessComObject fakeComObject = new(
+            registerHandle: 53,
+            addItemHandle: 506);
+        FakeMxAccessComObjectFactory factory = new(fakeComObject);
+        using StaRuntime runtime = CreateRuntime();
+        using MxAccessStaSession session = new(runtime, factory, new NoopEventSink());
+        await session.StartAsync(workerProcessId: 1234);
+        await session.DispatchAsync(CreateRegisterCommand("register-before-supervisory", "client-a"));
+        await session.DispatchAsync(CreateAddItemCommand("add-before-supervisory", 53, "Galaxy.Tag.Value"));
+
+        MxCommandReply reply = await session.DispatchAsync(CreateAdviseSupervisoryCommand(
+            "advise-supervisory",
+            53,
+            506));
+
+        Assert.Equal(ProtocolStatusCode.Ok, reply.ProtocolStatus.Code);
+        Assert.Equal(53, fakeComObject.AdviseSupervisoryServerHandle);
+        Assert.Equal(506, fakeComObject.AdviseSupervisoryItemHandle);
+        Assert.Equal(runtime.StaThreadId, fakeComObject.AdviseSupervisoryThreadId);
+        Assert.Null(fakeComObject.AdviseServerHandle);
+
+        RegisteredAdviceHandle adviceHandle = Assert.Single(
+            await session.GetRegisteredAdviceHandlesAsync());
+        Assert.Equal(53, adviceHandle.ServerHandle);
+        Assert.Equal(506, adviceHandle.ItemHandle);
+        Assert.Equal(MxAccessAdviceKind.Supervisory, adviceHandle.AdviceKind);
+    }
+
+    [Fact]
+    public async Task DispatchAsync_UnAdvise_CallsMxAccessOnStaAndRemovesTrackedAdvice()
+    {
+        FakeMxAccessComObject fakeComObject = new(
+            registerHandle: 54,
+            addItemHandle: 507);
+        FakeMxAccessComObjectFactory factory = new(fakeComObject);
+        using StaRuntime runtime = CreateRuntime();
+        using MxAccessStaSession session = new(runtime, factory, new NoopEventSink());
+        await session.StartAsync(workerProcessId: 1234);
+        await session.DispatchAsync(CreateRegisterCommand("register-before-unadvise", "client-a"));
+        await session.DispatchAsync(CreateAddItemCommand("add-before-unadvise", 54, "Galaxy.Tag.Value"));
+        await session.DispatchAsync(CreateAdviseCommand("advise-before-unadvise", 54, 507));
+        await session.DispatchAsync(CreateAdviseSupervisoryCommand("supervisory-before-unadvise", 54, 507));
+
+        MxCommandReply reply = await session.DispatchAsync(CreateUnAdviseCommand(
+            "unadvise",
+            54,
+            507));
+
+        Assert.Equal(ProtocolStatusCode.Ok, reply.ProtocolStatus.Code);
+        Assert.Equal(54, fakeComObject.UnAdviseServerHandle);
+        Assert.Equal(507, fakeComObject.UnAdvisedItemHandle);
+        Assert.Equal(runtime.StaThreadId, fakeComObject.UnAdviseThreadId);
+        Assert.Empty(await session.GetRegisteredAdviceHandlesAsync());
+    }
+
+    [Fact]
+    public async Task DispatchAsync_AdviseWhenMxAccessThrows_PreservesHResultAndDoesNotTrackAdvice()
+    {
+        const int hresult = unchecked((int)0x80070057);
+        FakeMxAccessComObject fakeComObject = new(
+            registerHandle: 55,
+            addItemHandle: 508,
+            adviseException: new COMException("Invalid item handle.", hresult));
+        FakeMxAccessComObjectFactory factory = new(fakeComObject);
+        using StaRuntime runtime = CreateRuntime();
+        using MxAccessStaSession session = new(runtime, factory, new NoopEventSink());
+        await session.StartAsync(workerProcessId: 1234);
+        await session.DispatchAsync(CreateRegisterCommand("register-before-advise-failure", "client-a"));
+        await session.DispatchAsync(CreateAddItemCommand("add-before-advise-failure", 55, "Galaxy.Tag.Value"));
+
+        MxCommandReply reply = await session.DispatchAsync(CreateAdviseCommand(
+            "advise-failure",
+            55,
+            999));
+
+        Assert.Equal(ProtocolStatusCode.MxaccessFailure, reply.ProtocolStatus.Code);
+        Assert.True(reply.HasHresult);
+        Assert.Equal(hresult, reply.Hresult);
+        Assert.Contains("0x80070057", reply.DiagnosticMessage);
+        Assert.Equal(55, fakeComObject.AdviseServerHandle);
+        Assert.Equal(999, fakeComObject.AdvisedItemHandle);
+        Assert.Empty(await session.GetRegisteredAdviceHandlesAsync());
+    }
+
+    [Fact]
+    public async Task DispatchAsync_UnAdviseWhenMxAccessThrows_PreservesHResultAndKeepsTrackedAdvice()
+    {
+        const int hresult = unchecked((int)0x80070057);
+        FakeMxAccessComObject fakeComObject = new(
+            registerHandle: 56,
+            addItemHandle: 509,
+            unAdviseException: new COMException("Invalid item handle.", hresult));
+        FakeMxAccessComObjectFactory factory = new(fakeComObject);
+        using StaRuntime runtime = CreateRuntime();
+        using MxAccessStaSession session = new(runtime, factory, new NoopEventSink());
+        await session.StartAsync(workerProcessId: 1234);
+        await session.DispatchAsync(CreateRegisterCommand("register-before-unadvise-failure", "client-a"));
+        await session.DispatchAsync(CreateAddItemCommand("add-before-unadvise-failure", 56, "Galaxy.Tag.Value"));
+        await session.DispatchAsync(CreateAdviseCommand("advise-before-unadvise-failure", 56, 509));
+
+        MxCommandReply reply = await session.DispatchAsync(CreateUnAdviseCommand(
+            "unadvise-failure",
+            56,
+            509));
+
+        Assert.Equal(ProtocolStatusCode.MxaccessFailure, reply.ProtocolStatus.Code);
+        Assert.True(reply.HasHresult);
+        Assert.Equal(hresult, reply.Hresult);
+        Assert.Contains("0x80070057", reply.DiagnosticMessage);
+        Assert.Equal(56, fakeComObject.UnAdviseServerHandle);
+        Assert.Equal(509, fakeComObject.UnAdvisedItemHandle);
+
+        RegisteredAdviceHandle adviceHandle = Assert.Single(
+            await session.GetRegisteredAdviceHandlesAsync());
+        Assert.Equal(MxAccessAdviceKind.Plain, adviceHandle.AdviceKind);
+    }
+
    [Fact]
    public async Task DispatchAsync_RegisterWithoutPayload_ReturnsInvalidRequest()
    {
@@ -278,6 +454,26 @@ public sealed class MxAccessCommandExecutorTests
        Assert.Null(factory.FakeComObject.AddItemDefinition);
    }

+    [Fact]
+    public async Task DispatchAsync_AdviseWithoutPayload_ReturnsInvalidRequest()
+    {
+        FakeMxAccessComObjectFactory factory = new(new FakeMxAccessComObject(registerHandle: 57));
+        using StaRuntime runtime = CreateRuntime();
+        using MxAccessStaSession session = new(runtime, factory, new NoopEventSink());
+        await session.StartAsync(workerProcessId: 1234);
+
+        MxCommandReply reply = await session.DispatchAsync(new StaCommand(
+            "session-1",
+            "missing-advise-payload",
+            new MxCommand
+            {
+                Kind = MxCommandKind.Advise,
+            }));
+
+        Assert.Equal(ProtocolStatusCode.InvalidRequest, reply.ProtocolStatus.Code);
+        Assert.Null(factory.FakeComObject.AdviseServerHandle);
+    }
+
    private static StaCommand CreateRegisterCommand(
        string correlationId,
        string clientName)
@@ -371,6 +567,63 @@ public sealed class MxAccessCommandExecutorTests
            });
    }

+    private static StaCommand CreateAdviseCommand(
+        string correlationId,
+        int serverHandle,
+        int itemHandle)
+    {
+        return new StaCommand(
+            "session-1",
+            correlationId,
+            new MxCommand
+            {
+                Kind = MxCommandKind.Advise,
+                Advise = new AdviseCommand
+                {
+                    ServerHandle = serverHandle,
+                    ItemHandle = itemHandle,
+                },
+            });
+    }
+
+    private static StaCommand CreateUnAdviseCommand(
+        string correlationId,
+        int serverHandle,
+        int itemHandle)
+    {
+        return new StaCommand(
+            "session-1",
+            correlationId,
+            new MxCommand
+            {
+                Kind = MxCommandKind.UnAdvise,
+                UnAdvise = new UnAdviseCommand
+                {
+                    ServerHandle = serverHandle,
+                    ItemHandle = itemHandle,
+                },
+            });
+    }
+
+    private static StaCommand CreateAdviseSupervisoryCommand(
+        string correlationId,
+        int serverHandle,
+        int itemHandle)
+    {
+        return new StaCommand(
+            "session-1",
+            correlationId,
+            new MxCommand
+            {
+                Kind = MxCommandKind.AdviseSupervisory,
+                AdviseSupervisory = new AdviseSupervisoryCommand
+                {
+                    ServerHandle = serverHandle,
+                    ItemHandle = itemHandle,
+                },
+            });
+    }
+
    private static StaRuntime CreateRuntime()
    {
        return new StaRuntime(
@@ -388,6 +641,9 @@ public sealed class MxAccessCommandExecutorTests
        private readonly Exception? addItemException;
        private readonly Exception? addItem2Exception;
        private readonly Exception? removeItemException;
+        private readonly Exception? adviseException;
+        private readonly Exception? unAdviseException;
+        private readonly Exception? adviseSupervisoryException;

        public FakeMxAccessComObject(
            int registerHandle,
@@ -396,7 +652,10 @@ public sealed class MxAccessCommandExecutorTests
            Exception? unregisterException = null,
            Exception? addItemException = null,
            Exception? addItem2Exception = null,
-            Exception? removeItemException = null)
+            Exception? removeItemException = null,
+            Exception? adviseException = null,
+            Exception? unAdviseException = null,
+            Exception? adviseSupervisoryException = null)
        {
            this.registerHandle = registerHandle;
            this.addItemHandle = addItemHandle;
@@ -405,6 +664,9 @@ public sealed class MxAccessCommandExecutorTests
            this.addItemException = addItemException;
            this.addItem2Exception = addItem2Exception;
            this.removeItemException = removeItemException;
+            this.adviseException = adviseException;
+            this.unAdviseException = unAdviseException;
+            this.adviseSupervisoryException = adviseSupervisoryException;
        }

        public string? RegisteredClientName { get; private set; }
@@ -435,6 +697,24 @@ public sealed class MxAccessCommandExecutorTests

        public int? RemoveItemThreadId { get; private set; }

+        public int? AdviseServerHandle { get; private set; }
+
+        public int? AdvisedItemHandle { get; private set; }
+
+        public int? AdviseThreadId { get; private set; }
+
+        public int? UnAdviseServerHandle { get; private set; }
+
+        public int? UnAdvisedItemHandle { get; private set; }
+
+        public int? UnAdviseThreadId { get; private set; }
+
+        public int? AdviseSupervisoryServerHandle { get; private set; }
+
+        public int? AdviseSupervisoryItemHandle { get; private set; }
+
+        public int? AdviseSupervisoryThreadId { get; private set; }
+
        public int Register(string clientName)
        {
            RegisteredClientName = clientName;
@@ -501,6 +781,48 @@ public sealed class MxAccessCommandExecutorTests
                throw removeItemException;
            }
        }
+
+        public void Advise(
+            int serverHandle,
+            int itemHandle)
+        {
+            AdviseServerHandle = serverHandle;
+            AdvisedItemHandle = itemHandle;
+            AdviseThreadId = Environment.CurrentManagedThreadId;
+
+            if (adviseException is not null)
+            {
+                throw adviseException;
+            }
+        }
+
+        public void UnAdvise(
+            int serverHandle,
+            int itemHandle)
+        {
+            UnAdviseServerHandle = serverHandle;
+            UnAdvisedItemHandle = itemHandle;
+            UnAdviseThreadId = Environment.CurrentManagedThreadId;
+
+            if (unAdviseException is not null)
+            {
+                throw unAdviseException;
+            }
+        }
+
+        public void AdviseSupervisory(
+            int serverHandle,
+            int itemHandle)
+        {
+            AdviseSupervisoryServerHandle = serverHandle;
+            AdviseSupervisoryItemHandle = itemHandle;
+            AdviseSupervisoryThreadId = Environment.CurrentManagedThreadId;
+
+            if (adviseSupervisoryException is not null)
+            {
+                throw adviseSupervisoryException;
+            }
+        }
    }

    private sealed class FakeMxAccessComObjectFactory : IMxAccessComObjectFactory
@@ -520,7 +842,9 @@ public sealed class MxAccessCommandExecutorTests

    private sealed class NoopEventSink : IMxAccessEventSink
    {
-        public void Attach(object mxAccessComObject)
+        public void Attach(
+            object mxAccessComObject,
+            string sessionId)
        {
        }

@@ -0,0 +1,117 @@
+using System;
+using MxGateway.Contracts.Proto;
+using MxGateway.Worker.MxAccess;
+
+namespace MxGateway.Worker.Tests.MxAccess;
+
+public sealed class MxAccessEventMapperTests
+{
+    private readonly MxAccessEventMapper mapper = new();
+
+    [Fact]
+    public void CreateOnDataChange_ConvertsValueTimestampQualityAndStatuses()
+    {
+        DateTime timestamp = new(2026, 4, 26, 12, 30, 0, DateTimeKind.Utc);
+        FakeStatus[] statuses =
+        {
+            new()
+            {
+                success = -1,
+                category = 0,
+                detectedBy = 5,
+                detail = 0,
+            },
+        };
+
+        MxEvent mxEvent = mapper.CreateOnDataChange(
+            "session-1",
+            serverHandle: 12,
+            itemHandle: 34,
+            value: 42,
+            quality: 192,
+            timestamp: timestamp,
+            statuses: statuses);
+
+        Assert.Equal(MxEventFamily.OnDataChange, mxEvent.Family);
+        Assert.Equal("session-1", mxEvent.SessionId);
+        Assert.Equal(12, mxEvent.ServerHandle);
+        Assert.Equal(34, mxEvent.ItemHandle);
+        Assert.Equal(42, mxEvent.Value.Int32Value);
+        Assert.Equal(192, mxEvent.Quality);
+        Assert.Equal(timestamp, mxEvent.SourceTimestamp.ToDateTime());
+        Assert.Equal(MxEvent.BodyOneofCase.OnDataChange, mxEvent.BodyCase);
+
+        MxStatusProxy status = Assert.Single(mxEvent.Statuses);
+        Assert.Equal(-1, status.Success);
+        Assert.Equal(MxStatusCategory.Ok, status.Category);
+        Assert.Equal(MxStatusSource.RespondingAutomationObject, status.DetectedBy);
+    }
+
+    [Fact]
+    public void CreateOnWriteCompleteAndOperationComplete_PreservesDistinctFamilies()
+    {
+        MxEvent writeComplete = mapper.CreateOnWriteComplete(
+            "session-1",
+            serverHandle: 1,
+            itemHandle: 2,
+            statuses: Array.Empty<FakeStatus>());
+        MxEvent operationComplete = mapper.CreateOperationComplete(
+            "session-1",
+            serverHandle: 1,
+            itemHandle: 2,
+            statuses: Array.Empty<FakeStatus>());
+
+        Assert.Equal(MxEventFamily.OnWriteComplete, writeComplete.Family);
+        Assert.Equal(MxEvent.BodyOneofCase.OnWriteComplete, writeComplete.BodyCase);
+        Assert.Equal(MxEventFamily.OperationComplete, operationComplete.Family);
+        Assert.Equal(MxEvent.BodyOneofCase.OperationComplete, operationComplete.BodyCase);
+    }
+
+    [Fact]
+    public void CreateOnBufferedDataChange_PreservesRawDataTypeAndArrayMetadata()
+    {
+        DateTime firstTimestamp = new(2026, 4, 26, 13, 0, 0, DateTimeKind.Utc);
+        DateTime secondTimestamp = new(2026, 4, 26, 13, 1, 0, DateTimeKind.Utc);
+
+        MxEvent mxEvent = mapper.CreateOnBufferedDataChange(
+            "session-1",
+            serverHandle: 10,
+            itemHandle: 20,
+            rawDataType: 2,
+            value: new[] { 7, 8 },
+            quality: new[] { 192, 0 },
+            timestamp: new[] { firstTimestamp, secondTimestamp },
+            statuses: null);
+
+        Assert.Equal(MxEventFamily.OnBufferedDataChange, mxEvent.Family);
+        Assert.Equal(MxDataType.Integer, mxEvent.OnBufferedDataChange.DataType);
+        Assert.Equal(2, mxEvent.OnBufferedDataChange.RawDataType);
+        Assert.Equal(MxDataType.Integer, mxEvent.Value.ArrayValue.ElementDataType);
+        Assert.Equal(new[] { 7, 8 }, mxEvent.Value.ArrayValue.Int32Values.Values);
+        Assert.Equal(new[] { 192, 0 }, mxEvent.OnBufferedDataChange.QualityValues.Int32Values.Values);
+        Assert.Equal(2, mxEvent.OnBufferedDataChange.TimestampValues.TimestampValues.Values.Count);
+    }
+
+    [Theory]
+    [InlineData(-1, MxDataType.Unknown)]
+    [InlineData(0, MxDataType.NoData)]
+    [InlineData(1, MxDataType.Boolean)]
+    [InlineData(2, MxDataType.Integer)]
+    [InlineData(6, MxDataType.Time)]
+    [InlineData(15, MxDataType.InternationalizedString)]
+    [InlineData(999, MxDataType.Unknown)]
+    public void MapMxDataType_MapsInstalledMxAccessValues(
+        int rawDataType,
+        MxDataType expectedDataType)
+    {
+        Assert.Equal(expectedDataType, MxAccessEventMapper.MapMxDataType(rawDataType));
+    }
+
+    private sealed class FakeStatus
+    {
+        public int success;
+        public int category;
+        public int detectedBy;
+        public int detail;
+    }
+}
@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using MxGateway.Contracts.Proto;
+using MxGateway.Worker.MxAccess;
+
+namespace MxGateway.Worker.Tests.MxAccess;
+
+public sealed class MxAccessEventQueueTests
+{
+    [Fact]
+    public void Enqueue_AssignsMonotonicWorkerSequencesAndPreservesOrder()
+    {
+        MxAccessEventQueue queue = new(capacity: 4);
+
+        WorkerEvent first = queue.Enqueue(CreateEvent(MxEventFamily.OnDataChange, itemHandle: 10));
+        WorkerEvent second = queue.Enqueue(CreateEvent(MxEventFamily.OnWriteComplete, itemHandle: 11));
+
+        Assert.Equal(1UL, first.Event.WorkerSequence);
+        Assert.Equal(2UL, second.Event.WorkerSequence);
+        Assert.NotNull(first.Event.WorkerTimestamp);
+        Assert.Equal(2, queue.Count);
+        Assert.Equal(2UL, queue.LastEventSequence);
+
+        Assert.True(queue.TryDequeue(out WorkerEvent? dequeuedFirst));
+        Assert.True(queue.TryDequeue(out WorkerEvent? dequeuedSecond));
+        Assert.Equal(10, dequeuedFirst?.Event.ItemHandle);
+        Assert.Equal(11, dequeuedSecond?.Event.ItemHandle);
+        Assert.False(queue.TryDequeue(out _));
+    }
+
+    [Fact]
+    public void Drain_RemovesAtMostRequestedEvents()
+    {
+        MxAccessEventQueue queue = new(capacity: 4);
+        queue.Enqueue(CreateEvent(MxEventFamily.OnDataChange, itemHandle: 10));
+        queue.Enqueue(CreateEvent(MxEventFamily.OnDataChange, itemHandle: 11));
+        queue.Enqueue(CreateEvent(MxEventFamily.OnDataChange, itemHandle: 12));
+
+        IReadOnlyList<WorkerEvent> drained = queue.Drain(maxEvents: 2);
+
+        Assert.Equal(2, drained.Count);
+        Assert.Equal(10, drained[0].Event.ItemHandle);
+        Assert.Equal(11, drained[1].Event.ItemHandle);
+        Assert.Equal(1, queue.Count);
+    }
+
+    [Fact]
+    public void Enqueue_WhenCapacityIsExceeded_RecordsOverflowFaultAndRejectsNewEvents()
+    {
+        MxAccessEventQueue queue = new(capacity: 1);
+        queue.Enqueue(CreateEvent(MxEventFamily.OnDataChange, itemHandle: 10));
+
+        MxAccessEventQueueOverflowException overflow = Assert.Throws<MxAccessEventQueueOverflowException>(
+            () => queue.Enqueue(CreateEvent(MxEventFamily.OnDataChange, itemHandle: 11)));
+
+        Assert.Equal(1, overflow.Capacity);
+        Assert.True(queue.IsFaulted);
+        Assert.Equal(WorkerFaultCategory.QueueOverflow, queue.Fault?.Category);
+        Assert.Equal(ProtocolStatusCode.WorkerUnavailable, queue.Fault?.ProtocolStatus.Code);
+        Assert.Throws<InvalidOperationException>(
+            () => queue.Enqueue(CreateEvent(MxEventFamily.OnDataChange, itemHandle: 12)));
+    }
+
+    [Fact]
+    public void RecordFault_KeepsFirstFault()
+    {
+        MxAccessEventQueue queue = new(capacity: 1);
+        queue.RecordFault(new WorkerFault
+        {
+            Category = WorkerFaultCategory.MxaccessEventConversionFailed,
+        });
+        queue.RecordFault(new WorkerFault
+        {
+            Category = WorkerFaultCategory.QueueOverflow,
+        });
+
+        Assert.True(queue.IsFaulted);
+        Assert.Equal(WorkerFaultCategory.MxaccessEventConversionFailed, queue.Fault?.Category);
+    }
+
+    private static MxEvent CreateEvent(
+        MxEventFamily family,
+        int itemHandle)
+    {
+        MxEvent mxEvent = new()
+        {
+            Family = family,
+            SessionId = "session-1",
+            ServerHandle = 1,
+            ItemHandle = itemHandle,
+        };
+
+        switch (family)
+        {
+            case MxEventFamily.OnWriteComplete:
+                mxEvent.OnWriteComplete = new OnWriteCompleteEvent();
+                break;
+
+            default:
+                mxEvent.OnDataChange = new OnDataChangeEvent();
+                break;
+        }
+
+        return mxEvent;
+    }
+}
@@ -215,6 +215,127 @@ public sealed class MxAccessLiveComCreationTests
        }
    }

+    [Fact]
+    public async Task AdviseAndUnAdvise_WhenOptedIn_RoundTripsInstalledMxAccessSubscription()
+    {
+        if (!RunLiveMxAccessTests())
+        {
+            return;
+        }
+
+        using MxAccessStaSession session = new();
+        await session.StartAsync(workerProcessId: 1234);
+
+        MxCommandReply registerReply = await RegisterLiveSessionAsync(session, "live-advise-register");
+        int serverHandle = registerReply.Register.ServerHandle;
+        int itemHandle = 0;
+        bool advised = false;
+
+        try
+        {
+            MxCommandReply addItemReply = await session.DispatchAsync(new StaCommand(
+                "session-1",
+                "live-advise-add-item",
+                new MxCommand
+                {
+                    Kind = MxCommandKind.AddItem,
+                    AddItem = new AddItemCommand
+                    {
+                        ServerHandle = serverHandle,
+                        ItemDefinition = GetLiveAddItemReference(),
+                    },
+                }));
+
+            Assert.Equal(ProtocolStatusCode.Ok, addItemReply.ProtocolStatus.Code);
+            Assert.True(addItemReply.AddItem.ItemHandle > 0);
+            itemHandle = addItemReply.AddItem.ItemHandle;
+
+            MxCommandReply adviseReply = await session.DispatchAsync(new StaCommand(
+                "session-1",
+                "live-advise",
+                new MxCommand
+                {
+                    Kind = MxCommandKind.Advise,
+                    Advise = new AdviseCommand
+                    {
+                        ServerHandle = serverHandle,
+                        ItemHandle = itemHandle,
+                    },
+                }));
+
+            Assert.Equal(ProtocolStatusCode.Ok, adviseReply.ProtocolStatus.Code);
+            advised = true;
+
+            MxCommandReply unAdviseReply = await session.DispatchAsync(new StaCommand(
+                "session-1",
+                "live-unadvise",
+                new MxCommand
+                {
+                    Kind = MxCommandKind.UnAdvise,
+                    UnAdvise = new UnAdviseCommand
+                    {
+                        ServerHandle = serverHandle,
+                        ItemHandle = itemHandle,
+                    },
+                }));
+
+            Assert.Equal(ProtocolStatusCode.Ok, unAdviseReply.ProtocolStatus.Code);
+            advised = false;
+
+            MxCommandReply removeItemReply = await session.DispatchAsync(new StaCommand(
+                "session-1",
+                "live-advise-remove-item",
+                new MxCommand
+                {
+                    Kind = MxCommandKind.RemoveItem,
+                    RemoveItem = new RemoveItemCommand
+                    {
+                        ServerHandle = serverHandle,
+                        ItemHandle = itemHandle,
+                    },
+                }));
+
+            Assert.Equal(ProtocolStatusCode.Ok, removeItemReply.ProtocolStatus.Code);
+            itemHandle = 0;
+        }
+        finally
+        {
+            if (advised && itemHandle > 0)
+            {
+                await session.DispatchAsync(new StaCommand(
+                    "session-1",
+                    "live-unadvise-cleanup",
+                    new MxCommand
+                    {
+                        Kind = MxCommandKind.UnAdvise,
+                        UnAdvise = new UnAdviseCommand
+                        {
+                            ServerHandle = serverHandle,
+                            ItemHandle = itemHandle,
+                        },
+                    }));
+            }
+
+            if (itemHandle > 0)
+            {
+                await session.DispatchAsync(new StaCommand(
+                    "session-1",
+                    "live-advise-remove-item-cleanup",
+                    new MxCommand
+                    {
+                        Kind = MxCommandKind.RemoveItem,
+                        RemoveItem = new RemoveItemCommand
+                        {
+                            ServerHandle = serverHandle,
+                            ItemHandle = itemHandle,
+                        },
+                    }));
+            }
+
+            await UnregisterLiveSessionAsync(session, serverHandle, "live-advise-unregister");
+        }
+    }
+
    private static bool RunLiveMxAccessTests()
    {
        return string.Equals(
@@ -18,7 +18,7 @@ public sealed class MxAccessStaSessionTests
        using StaRuntime runtime = CreateRuntime();
        using MxAccessStaSession session = new(runtime, factory, eventSink);

-        WorkerReady ready = await session.StartAsync(workerProcessId: 1234);
+        WorkerReady ready = await session.StartAsync("session-1", workerProcessId: 1234);

        Assert.Equal(1234, ready.WorkerProcessId);
        Assert.Equal(MxAccessInteropInfo.ProgId, ready.MxaccessProgid);
@@ -28,6 +28,7 @@ public sealed class MxAccessStaSessionTests
        Assert.Equal(runtime.StaThreadId, eventSink.AttachThreadId);
        Assert.Equal(ApartmentState.STA, factory.CreateApartmentState);
        Assert.Same(factory.CreatedObject, eventSink.AttachedObject);
+        Assert.Equal("session-1", eventSink.SessionId);
    }

    [Fact]
@@ -107,10 +108,15 @@ public sealed class MxAccessStaSessionTests

        public int? DetachThreadId { get; private set; }

-        public void Attach(object mxAccessComObject)
+        public string? SessionId { get; private set; }
+
+        public void Attach(
+            object mxAccessComObject,
+            string sessionId)
        {
            AttachedObject = mxAccessComObject;
            AttachThreadId = Thread.CurrentThread.ManagedThreadId;
+            SessionId = sessionId;
        }

        public void Detach()