// <auto-generated/>
public sealed class CreateProductCommandHandler
    : ICommandHandler<CreateProductCommand, Result<Product>>
{
    private readonly IProductRepository _repository;

    public async Task<Result<Product>> HandleAsync(
        CreateProductCommand command, CancellationToken ct)
    {
        var product = new Product.Builder()
            .WithName(command.Name)
            .WithPrice(command.Price)
            .WithSlug(command.Slug)
            .Build();

        await _repository.SaveAsync(product, ct);
        return Result<Product>.Success(product);
    }
}

[AggregateRoot("Order", BoundedContext = "Ordering")]
[HasWorkflow("Fulfillment")]
public partial class Order
{
    [EntityId] public partial OrderId Id { get; }
    [Property("PlacedAt", Required = true)] public partial DateTime PlacedAt { get; }
    [Property("Status", Required = true)]   public partial OrderStatus Status { get; }
    [Composition] public partial IReadOnlyList<OrderLine> Lines { get; }
    [Composition] public partial ShippingAddress ShippingAddress { get; }
    [Association] public partial CustomerId CustomerId { get; }

    [Invariant("OrderMustHaveAtLeastOneLine")]
    private Result EnsureHasLines() =>
        Lines.Any() ? Result.Success() : Result.Failure("ORD-001: Order must have at least one line");
}

generated/Ordering/
├── Order.Implementation.g.cs            (entity backing fields, invariant runner)
├── Order.Builder.g.cs                   (fluent builder with Result<Order>)
├── OrderId.g.cs                         (typed ID value object + JSON converter)
├── OrderLine.Implementation.g.cs        (composed entity, owned-type)
├── ShippingAddress.g.cs                 (value object, IEquatable, ToString)
├── OrderConfiguration.g.cs              (IEntityTypeConfiguration<Order>)
├── OrderLineConfiguration.g.cs          (owned-type configuration)
├── OrderRepository.g.cs                 (IOrderRepository + EF implementation)
├── OrderingDbContext.Order.g.cs         (DbSet partial, model registration)
├── CreateOrderCommand.g.cs              (record + handler + validator)
└── OrderStatusChangedEvent.g.cs         (domain event for the workflow)

// Order.Implementation.g.cs (excerpt)
public sealed partial class Order
{
    private readonly List<OrderLine> _lines = new();
    public IReadOnlyList<OrderLine> Lines => _lines;

    private Result CheckInvariants()
    {
        var r = EnsureHasLines();
        if (!r.IsSuccess) return r;
        // ...other invariants chained here
        return Result.Success();
    }

    internal Result MutateAndCheck(Action mutation)
    {
        mutation();
        return CheckInvariants();
    }
}

// OrderConfiguration.g.cs
internal sealed class OrderConfiguration : IEntityTypeConfiguration<Order>
{
    public void Configure(EntityTypeBuilder<Order> b)
    {
        b.HasKey("_id");
        b.Property<OrderId>("_id").HasConversion(v => v.Value, v => new OrderId(v));
        b.Property<DateTime>("_placedAt").HasColumnName("PlacedAt").IsRequired();
        b.Property<OrderStatus>("_status").HasColumnName("Status").HasConversion<string>().IsRequired();
        b.OwnsMany<OrderLine>("_lines", o => { /* configured by OrderLineConfiguration */ });
        b.OwnsOne<ShippingAddress>("_shippingAddress");
        b.Property<Guid>("_customerId").HasColumnName("CustomerId");
    }
}

// CreateOrderCommand.g.cs
public sealed record CreateOrderCommand(
    DateTime PlacedAt,
    OrderStatus Status,
    IReadOnlyList<CreateOrderLineDto> Lines,
    ShippingAddress ShippingAddress,
    CustomerId CustomerId);

public sealed class CreateOrderCommandHandler
    : ICommandHandler<CreateOrderCommand, Result<Order>>
{
    private readonly IOrderRepository _repo;
    private readonly IEventBus _events;

    public CreateOrderCommandHandler(IOrderRepository repo, IEventBus events)
    { _repo = repo; _events = events; }

    public async Task<Result<Order>> HandleAsync(CreateOrderCommand cmd, CancellationToken ct)
    {
        var built = new Order.Builder()
            .WithPlacedAt(cmd.PlacedAt)
            .WithStatus(cmd.Status)
            .WithShippingAddress(cmd.ShippingAddress)
            .WithCustomerId(cmd.CustomerId)
            .WithLines(cmd.Lines.Select(l => l.ToEntity()))
            .Build();
        if (!built.IsSuccess) return built;

        await _repo.SaveAsync(built.Value, ct);
        await _events.PublishAsync(new OrderPlacedEvent(built.Value.Id), ct);
        return built;
    }
}

[AdminModule("Orders", Aggregate = "Order", Icon = "shopping-bag", MenuGroup = "Sales")]
[AdminAction("MarkShipped", Command = "MarkOrderShipped", RequiresRole = "Fulfillment")]
public partial class OrderAdminModule { }

[PageWidget("OrderConfirmation", Module = "Order",
    DisplayType = DisplayType.Show, HasPage = true)]
public partial class OrderConfirmationWidget { }

generated/Ordering/
├── OrderList.razor.g.cs                 (paginated list with filters)
├── OrderForm.razor.g.cs                 (auto-generated form, grouped fields)
├── OrderDetail.razor.g.cs               (detail view + action buttons)
├── OrderAdminMenu.g.cs                  (menu entry with icon, group, role)
├── OrderConfirmationWidget.razor.g.cs   (Blazor WASM component)
├── OrdersController.g.cs                (REST controller: GET/POST/PUT/DELETE)
├── OrdersGraphQLType.g.cs               (HotChocolate ObjectType + Query field)
└── OrdersOpenApi.g.cs                   (Swashbuckle filter with [Implements] tags)

[ApiController]
[Route("api/orders")]
public sealed partial class OrdersController : ControllerBase
{
    private readonly ICommandBus _commands;
    private readonly IQueryBus _queries;

    public OrdersController(ICommandBus commands, IQueryBus queries)
    { _commands = commands; _queries = queries; }

    [HttpGet("{id:guid}")]
    [ProducesResponseType(typeof(OrderDto), 200)]
    public async Task<IActionResult> Get(Guid id, CancellationToken ct)
    {
        var result = await _queries.AskAsync(new GetOrderQuery(new OrderId(id)), ct);
        return result.Match<IActionResult>(Ok, NotFound);
    }

    [HttpPost]
    [ProducesResponseType(typeof(OrderDto), 201)]
    [ProducesResponseType(typeof(ProblemDetails), 400)]
    public async Task<IActionResult> Create([FromBody] CreateOrderCommand cmd, CancellationToken ct)
    {
        var result = await _commands.SendAsync(cmd, ct);
        return result.Match<IActionResult>(
            order => CreatedAtAction(nameof(Get), new { id = order.Id.Value }, OrderDto.From(order)),
            failure => Problem(failure.Message, statusCode: 400));
    }
}

hand-written:    35 lines  ████
generated:    1,445 lines  ████████████████████████████████████████████████████████████