Как правильно обрабатывать ошибки: ProblemDetails, middleware, ExceptionHandler?

HTTP/1.1 404 Not Found
Content-Type: application/problem+json

{
  "type": "https://api.example.uz/errors/order-not-found",
  "title": "Заказ не найден",
  "status": 404,
  "detail": "Заказ 1042 не существует или был удалён",
  "instance": "/api/orders/1042",
  "traceId": "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"
}

public sealed class DomainExceptionHandler(IProblemDetailsService problemDetails) : IExceptionHandler
{
    public async ValueTask<bool> TryHandleAsync(HttpContext ctx, Exception exception, CancellationToken ct)
    {
        (int status, string title)? mapped = exception switch
        {
            NotFoundException          => (404, "Ресурс не найден"),
            BusinessRuleException      => (422, "Нарушено бизнес-правило"),
            ConcurrencyConflictException => (409, "Данные были изменены другим пользователем"),
            _ => null
        };
        if (mapped is null) return false;                          // передать следующему обработчику

        ctx.Response.StatusCode = mapped.Value.status;
        return await problemDetails.TryWriteAsync(new ProblemDetailsContext
        {
            HttpContext = ctx,
            Exception = exception,
            ProblemDetails = { Title = mapped.Value.title, Detail = exception.Message, Status = mapped.Value.status }
        });
    }
}

public sealed class GlobalExceptionHandler(ILogger<GlobalExceptionHandler> logger, IProblemDetailsService problemDetails) : IExceptionHandler
{
    public async ValueTask<bool> TryHandleAsync(HttpContext ctx, Exception exception, CancellationToken ct)
    {
        logger.LogError(exception, "Необработанное исключение при {Method} {Path}", ctx.Request.Method, ctx.Request.Path);
        ctx.Response.StatusCode = StatusCodes.Status500InternalServerError;
        return await problemDetails.TryWriteAsync(new ProblemDetailsContext
        {
            HttpContext = ctx,
            ProblemDetails = { Title = "Внутренняя ошибка сервера", Status = 500 }   // без exception.Message!
        });
    }
}

builder.Services.AddProblemDetails(o => o.CustomizeProblemDetails = ctx =>
{
    ctx.ProblemDetails.Instance = $"{ctx.HttpContext.Request.Method} {ctx.HttpContext.Request.Path}";
    ctx.ProblemDetails.Extensions["traceId"] = Activity.Current?.Id ?? ctx.HttpContext.TraceIdentifier;
});
builder.Services.AddExceptionHandler<DomainExceptionHandler>();   // порядок регистрации = порядок вызова
builder.Services.AddExceptionHandler<GlobalExceptionHandler>();

var app = builder.Build();
app.UseExceptionHandler();        // первым в конвейере
app.UseStatusCodePages();         // ProblemDetails и для 404/405 без тела

public sealed record Error(string Code, string Message, ErrorType Type);
public enum ErrorType { Validation, NotFound, Conflict, BusinessRule }

public readonly record struct Result<T>(T? Value, Error? Error)
{
    public bool IsSuccess => Error is null;
    public static Result<T> Ok(T value) => new(value, null);
    public static Result<T> Fail(Error error) => new(default, error);
}

public async Task<Result<Guid>> PlaceOrderAsync(PlaceOrder cmd, CancellationToken ct)
{
    var customer = await _customers.FindAsync(cmd.CustomerId, ct);
    if (customer is null)
        return Result<Guid>.Fail(new("customer.not_found", "Покупатель не найден", ErrorType.NotFound));
    if (customer.Balance < cmd.Total)
        return Result<Guid>.Fail(new("balance.insufficient", "Недостаточно средств", ErrorType.BusinessRule));
    // ...
    return Result<Guid>.Ok(order.Id);
}

// Единый маппинг Result → HTTP
public static IResult ToHttp<T>(this Result<T> r) => r.IsSuccess
    ? TypedResults.Ok(r.Value)
    : TypedResults.Problem(title: r.Error!.Message, statusCode: r.Error.Type switch
      {
          ErrorType.Validation => 400, ErrorType.NotFound => 404,
          ErrorType.Conflict => 409, _ => 422
      }, extensions: new Dictionary<string, object?> { ["code"] = r.Error.Code });