Using MapDiscoveredCommands with multiple aggregates results in error 'No handler found for command Object ' about eventuous HOT 16 CLOSED

void MapAssemblyCommands(Assembly assembly) {
    var decoratedTypes = assembly.DefinedTypes.Where(
        x => x.IsClass && x.CustomAttributes.Any(a => a.AttributeType == attributeType)
    );

    var method = typeof(RouteBuilderExtensions).GetMethod(nameof(Map), BindingFlags.Static | BindingFlags.NonPublic)!;

    foreach (var type in decoratedTypes) {
        var attr = type.GetAttribute<HttpCommandAttribute>()!;

        if (attr.AggregateType != null && attr.AggregateType != typeof(TAggregate))
            throw new InvalidOperationException(
                $"Command aggregate is {attr.AggregateType.Name} but expected to be {typeof(TAggregate).Name}"
            );

        var genericMethod = method.MakeGenericMethod(typeof(TAggregate), type, type);
        genericMethod.Invoke(null, new object?[] { builder, attr.Route, null, attr.PolicyName });
    }
}

void LocalMap(Type aggregateType, Type type, string? route, string? policyName) {
    var appServiceBase = typeof(ICommandService<>);
    var appServiceType = appServiceBase.MakeGenericType(aggregateType);

    var routeBuilder = builder
        .MapPost(
            GetRoute(type, route),
            async Task<IResult> (HttpContext context) => {
                var cmd = await context.Request.ReadFromJsonAsync(type, context.RequestAborted);

                if (cmd == null) throw new InvalidOperationException("Failed to deserialize the command");

                if (context.RequestServices.GetRequiredService(appServiceType) is not ICommandService
                    service) throw new InvalidOperationException("Unable to resolve the application service");

                var result = await service.Handle(cmd, context.RequestAborted);

                return result.AsResult();
            }
        )

[AggregateCommands<Booking>]
static class NestedCommands {
    [HttpCommand(Route = "nested-book")]
    internal record NestedBookRoom(string BookingId, string RoomId, LocalDate CheckIn, LocalDate CheckOut, float Price, string? GuestId);
}

[Fact]
public void RegisterAggregatesCommands() {
    var builder = WebApplication.CreateBuilder();

    using var app = builder.Build();

    var b = app.MapDiscoveredCommands(typeof(NestedCommands).Assembly);

    b.DataSources.First().Endpoints[0].DisplayName.Should().Be("HTTP: POST nested-book");
}

[Fact]
public async Task MapDiscoveredCommand() {
    using var fixture = new ServerFixture(
        output,
        _ => { },
        app => app.MapDiscoveredCommands(typeof(NestedCommands).Assembly)
    );

    using var client = fixture.GetClient();

    var cmd = fixture.GetNestedBookRoom();

    var response = await client.PostJsonAsync("/nested-book", cmd);
    response.Should().Be(HttpStatusCode.OK);
}

void BuildHandlers() {
    lock (_handlersLock) {
        foreach (var commandType in _builders.Keys) {
            var builder = _builders[commandType];
            var handler = builder.Build();
            _handlers.AddHandlerUntyped(commandType, handler);
        }

        _initialized = true;
    }
}

public async Task<Result<TState>> Handle<TCommand>(TCommand command, CancellationToken cancellationToken) where TCommand : class {
    if (!_initialized) BuildHandlers();

    if (!_handlers.TryGet<TCommand>(out var registeredHandler)) {
        Log.CommandHandlerNotFound<TCommand>();
...

static readonly MethodInfo TryGetInternalMethod =
    typeof(HandlersMap<TAggregate, TId>).GetMethod(nameof(TryGetInternal), BindingFlags.NonPublic | BindingFlags.Instance)!;

...

internal bool TryGetUntyped(Type command, [NotNullWhen(true)] out RegisteredHandler<TAggregate, TId>? handler) {
    var parameters = new object?[] { null };
    bool tryGet = (bool)TryGetInternalMethod.MakeGenericMethod(command).Invoke(this, parameters)!;
    handler = tryGet ? (RegisteredHandler<TAggregate, TId>?)parameters[0] : null;
    return tryGet;

Log.CommandHandlerNotFound<TCommand>();
...
Log.CommandHandled<TCommand>();
...
Log.ErrorHandlingCommand<TCommand>(e);
...
return new ErrorResult<TState>($"Error handling command {typeof(TCommand).Name}", e);

    [NonEvent]
    public void CommandHandlerNotFound<TCommand>() => CommandHandlerNotFound(typeof(TCommand).Name);

    [NonEvent]
    public void CommandHandlerNotFoundUntyped(Type commandType) => CommandHandlerNotFound(commandType.Name);

    [NonEvent]
    public void ErrorHandlingCommand<TCommand>(Exception e) => ErrorHandlingCommand(typeof(TCommand).Name, e.ToString());

    [NonEvent]
    public void ErrorHandlingCommandUntyped(Type commandType, Exception e) => ErrorHandlingCommand(commandType.Name, e.ToString());

    [NonEvent]
    public void CommandHandled<TCommand>() {
        if (IsEnabled(EventLevel.Verbose, EventKeywords.All)) CommandHandled(typeof(TCommand).Name);
    }

    [NonEvent]
    public void CommandHandledUntyped(Type commandType) {
        if (IsEnabled(EventLevel.Verbose, EventKeywords.All)) CommandHandled(commandType.Name);
    }