[yallie]

1. Hidden system services shouldn't be remotely callable:

var proxy = client.CreateProxy<IDelegateProxyFactory>();
proxy.Create(typeof(Action), null)); // throws RemoteInvocationException: service is hidden

2. IDependencyInjectionContainer should be resolvable:

public class MyCustomService(IDependencyInjectionContainer container)
{
     // container can be used to resolve other services on demand
}

3. Added a hidden server-side service for invoking events:

// server component can relay other service's events
eventDispatcher.Invoke<ITestService>(s => nameof(s.ServiceEvent), EventArgs.Empty);

4. Added reverse index to ClientDelegateRegistry for faster lookup by delegate + proxy pair:

var indexKey = (clientDelegate, serviceProxy); // key is allocated on stack, not heap

if (_reverseIndex.TryGetValue(indexKey, out var existing)) // O(1) lookup
    return existing;

This change fixes bug #244.

5. Implemented event subscription tracker, to compare active subscriptions on client and server:

var proxy = client.CreateProxy<ITestService>();
proxy.ServiceEvent += eventHandler;

Assert.Equal(1, client.SubscriptionTracker.Count); // SubscriptionTracker is internal, not a public API
Assert.Equal(client.SubscriptionTracker.Checksum, serverTracker.Checksum);

6. BeforeCall event handler can cancel method invocation:

server.BeforeCall += (sender, ctx)
{
    if (ctx.MethodCallMessage.MethodName == "ProtectedMethod")
        ctx.Cancel = true; // throws RemoteInvocationException on client
}

7. Added ServerRpcContext.ReturnValue property which can be changed in AfterCall event handler:

server.AfterCall += (s, ctx) => ctx.ReturnValue = newReturnValue;

8. Added proxiless ServiceInvoker for internal/private interfaces that Castle cannot proxy:

using var invoker = client.CreateInvoker<IPrivateEchoService>();
invoker.Invoke(s => s.Echo("test")));

9. Renamed EventStub → ServiceEventHub to reflect its role.
10. DelegateProxyFactory now caches dynamic methods for the delegates of the same type.
11. Disconnecting a client removes all its subscriptions on server.
12. Fixed a deadlock between RemotingSession's "goodbye" message handler and DisposeAsync.
13. Added AtomicBool primitive to use instead of bool flags to guard DisposeAsync methods.
14. Added internal IServerSubscriptionService to cleanup client delegates on proxy shutdown.
15. Added deterministic ShutdownProxyAsync that unsubscribes from all server events:

var proxy = client.CreateProxy<IMyService>();
proxy.Event1 += handler1;
proxy.Event2 += handler2;
await client.ShutdownProxyAsync(proxy); // notify server to drop both subscriptions

16. Added IDelegateProxy.IsDisposed and delegate.IsDisposed() extension method for server components:

private readonly List<Action<string>> _callbacks = new();

public void RegisterCallback(Action<string> callback) => _callbacks.Add(callback);

private void Tick()
{
    foreach (var cb in _callbacks)
        cb("hello");  // dead callback → silent no-op

    _callbacks.RemoveAll(cb => cb.IsDisposed());  // cleanup outdated callbacks
}