Dependency Graph

LiteBus v6 splits packages by concern: runtime, messaging, semantic modules, durable orchestration, storage adapters, dispatch adapters, ingress adapters, and shared transport helpers. Applications reference only the packages they compose.

v6.0 rename tables (UseInProcessDispatch, *.AwsSqs package IDs, EF Core public surface, and others) are documented in Migration Guide v6.

The role table below is the normative dependency summary. Generated Package Inventory records every evaluated shipping project reference and direct package reference; documentation CI rejects stale inventory.

Dependency Roles

Roles describe dependency direction and package purpose. They are not numeric layers. Feature axes remain independent from the role assigned to a package.

ArchitectureDependencyPolicyTests parses every project under src/. It fails when a project has no role, a project reference points in a forbidden direction, a storage, dispatch, or ingress adapter crosses concerns, or a direct or transitive package reference is not approved for that role. Technology-family checks walk the complete project-reference closure, so a broker SDK cannot enter an adapter through a shared project. Update the matrix and the test together when introducing a new architectural role or SDK family.

Only the LiteBus aggregate meta-package bundles core mediators and durable messaging. Storage, dispatch, ingress, broker transports, and OpenTelemetry remain opt-in.

Role Map

Platform contracts
  Runtime.Abstractions
    -> Runtime
    -> Messaging.Abstractions -> Messaging
    -> DurableMessaging.Abstractions -> Inbox / Outbox / Saga
  Transport.Abstractions -> Transport

Technology adapters
  Storage.PostgreSql / Storage.EntityFrameworkCore
  Transport.Amqp / Transport.Kafka / Transport.AwsSqs / Transport.AzureServiceBus / Transport.InMemory

Feature bridges
  Inbox.Storage.* / Inbox.Dispatch.* / Inbox.Ingress.*
  Outbox.Storage.* / Outbox.Dispatch.*
  Saga.InboxIntegration / Saga.Storage.*

Host adapters
  Runtime.Extensions.* / *.Extensions.Microsoft.DependencyInjection / *.Extensions.Autofac
  *.Extensions.OpenTelemetry / Extensions.AspNetCore / Extensions.Diagnostics.HealthChecks

LiteBus.Runtime depends only on Runtime.Abstractions. ILiteBusBuilder lives in Runtime.Abstractions and exposes only Modules; feature packages add the normal AddMessaging, AddCommands, AddQueries, AddEvents, AddInbox, and AddOutbox extensions. The underlying IModuleRegistry remains available for advanced composition.

Shared transports are root modules. Dispatch and ingress modules declare IRequires<TTransportModule> and never create an implicit broker module. Storage, dispatch, and ingress modules also declare their parent inbox or outbox requirement where the type system permits it. The module registry validates the complete graph before any module builds.

Microsoft DI and Autofac adapters each register one IMessageDispatchScopeFactory. Core packages depend only on that contract and fail composition when no factory is present. A manual host can opt into RootMessageDispatchScopeFactory explicitly. EF Core storage uses IDbContextFactory<TContext> through adapter-owned operation factories and does not create container scopes inside stores.

v6 Package Table

Dependency Rules

Shared storage technology packages contain only invariants that are identical across durable axes. LiteBus.Storage.PostgreSql owns schema mechanics, database-clock access, and idempotency resolution; LiteBus.Storage.EntityFrameworkCore owns provider resolution, relational lease execution, and common durable operations. Inbox and outbox adapters retain their own tables, row mappings, lifecycle transitions, and public contracts. Similar-looking transition code remains axis-owned when sharing it would couple independent semantics or require a cross-axis abstraction.

Additional rules:

• Query packages do not depend on inbox or outbox packages.
• Core inbox and outbox modules register writers and processors only. They do not register dispatchers.
• Processor background services validate that exactly one dispatcher is registered.
• Stable contracts use names and versions, not assembly-qualified CLR names.
• Closed generic messages are supported when each closed type is registered. Open generic contracts are rejected.

Registration Reference

Naming Schemes (Folder, Namespace, NuGet)

Use* Extension to Package Map

Core Mediators (ILiteBusBuilder)

builder.Services.AddLiteBus(builder =>
{
    builder.AddMessaging(_ => { });
    builder.AddCommands(c => c.RegisterFromAssembly(typeof(Program).Assembly));
    builder.AddQueries(q => q.RegisterFromAssembly(typeof(Program).Assembly));
    builder.AddEvents(e => e.RegisterFromAssembly(typeof(Program).Assembly));
});

Inbox Composition

builder.Services.AddLiteBus(builder =>
{
    builder.AddMessaging(_ => { });
    builder.AddInbox(inbox =>
    {
        inbox.Contracts.Register<ProcessPaymentCommand>("payments.process-payment", 1);
        inbox.UseProcessorOptions(new InboxProcessorOptions { BatchSize = 50 });
        inbox.UsePostgreSqlStorage(pg => pg.UseDataSource(dataSource));
        inbox.UseInProcessDispatch();
        inbox.EnableInboxProcessor();
    });
});

Outbox Composition

builder.Services.AddLiteBus(builder =>
{
    builder.AddMessaging(_ => { });
    builder.AddOutbox(outbox =>
    {
        outbox.Contracts.Register<OrderSubmitted>("orders.order-submitted", 1);
        outbox.UsePostgreSqlStorage(pg => pg.UseDataSource(dataSource));
        outbox.UseInProcessDispatch();
        outbox.EnableOutboxProcessor();
    });
});

Transport Dispatch and Ingress

builder.Services.AddLiteBus(builder =>
{
    builder.AddAmqpTransport(new AmqpConnectionOptions
    {
        Uri = new Uri(configuration.GetConnectionString("Amqp")!)
    });
    builder.AddMessaging(_ => { });

    builder.AddOutbox(outbox =>
    {
        outbox.UseAmqpDispatch(options =>
        {
            options.DefaultDestination = "orders.events";
        });
    });

    builder.AddInbox(inbox =>
    {
        inbox.UseAmqpIngress(ingress =>
        {
            ingress.UseOptions(new AmqpInboxIngressOptions
            {
                QueueName = "commands.inbox"
            });
        });
    });
});

AddAmqpTransport owns the horizontal transport at the root. Dispatch and ingress modules require that root module and share its ITransportPublisher and IMessageConsumer. The same rule applies to Kafka, AWS SQS, Azure Service Bus, and in-memory transport modules.

Test Dependencies

Test-only packages live under tests/Directory.Packages.props.

PostgreSQL and AMQP integration tests require Docker. CI skips them gracefully when Docker is unavailable.

Next

See Architecture for Storage / Dispatch / Ingress flow diagrams, or Migration Guide v6 for v5 to v6 renames.