pouryanf 

The plain types an aggregate is written with: Result and Error, typed IDs, aggregates and entities, Domain Events and business rules, with no dependencies.

Small helpers the Kit's packages share: predicate composition a LINQ provider can translate, the implementing-type lookup and a synchronization-context scope.

Commands and queries that run as Operations through one fixed pipeline, each Feature with one handler that returns a Result.

The repository and Unit of Work contracts Feature code is written against, with their Errors, so a handler never saves or commits.

The contracts Feature code reacts and publishes with: Notification Handlers, Integration Events and their handlers, Snapshot mappers and wire names.

The EF Core Unit of Work: a DbContext per Module that saves and commits each Operation once, with the repository, audit, soft delete and conflicts as Errors.

Durable deliveries on Wolverine with the message store in PostgreSQL: Notifications, Integration Events, Snapshots, delayed and recurring commands, each retried on its own.

Modules for a Host: each Module's Composition Root declares what it needs and offers, and its Gateway runs every Operation from outside in a scope of its own.

ASP.NET Core endpoints beside each Feature: authenticated access by default, one problem response for every failure and outgoing HTTP that carries the Operation Context.

Each Module's EF Core data in its own PostgreSQL schema on Npgsql, with unique-value Errors and gap-free number sequences.

One file storage contract for Feature code: upload, download, delete and presigned links, each returning a Result, with no cloud SDK in a Module.

dotnet new templates that generate a monolith, a modular monolith or a service of one Module from the Proving Sample's business code, on the Kit's packages of the same version.

Permissions on commands and queries, checked in the pipeline against your application's own source, and PBKDF2 password hashing.

Every EF Core Module's Outbox and Receipts on Wolverine: what a Module publishes is written in the commit of its change, in PostgreSQL.

FluentValidation validators for commands and queries, run as one step of the Kit's pipeline, so invalid input comes back as Errors before a handler runs.

The Host's one chat client for OpenAI, Azure OpenAI or Ollama, a Module's commands and queries as Gateway tools that run as Operations, and agents and workflows over that client.

An activity and a duration metric for every command and query through System.Diagnostics, and one trace from an Operation into every delivery it causes.

A Module's report laid out once and rendered in memory to a PDF, a CSV file or a spreadsheet, with a logo, an accent colour and an embedded font.

Streams on Marten over PostgreSQL: aggregates stored as the events they appended, loaded by folding them, with a Unit of Work of their own.

Plain-SQL reads with Dapper on a pooled PostgreSQL connection: typed IDs as parameters and results, and a Page helper that never turns input into SQL.