### Order Saga with Start and Handle Methods

Source: https://wolverinefx.net/guide/durability/sagas.html

An example of an Order saga demonstrating the use of StartAsync and HandleAsync methods for managing the saga lifecycle.

```csharp
public class OrderSaga : Saga
{
    public Guid Id { get; set; }

    public Task StartAsync(StartOrder command)
    {
        Id = command.Id;
        return Task.CompletedTask;
    }

    public Task HandleAsync(CompleteOrder command)
    {
        MarkCompleted();
        return Task.CompletedTask;
    }
}
```

--------------------------------

### Wolverine Test Setup with IAsyncLifetime

Source: https://wolverinefx.net/guide/testing.html

Sets up a Wolverine host for testing, configures services, and starts the host. Implements IAsyncLifetime for managing test host lifecycle.

```csharp
public class When_message_is_sent : IAsyncLifetime
{
    private IHost _host = null!;

    public async Task InitializeAsync()
    {
        var hostBuilder = Host.CreateDefaultBuilder();
        hostBuilder.ConfigureServices(
            services => { services.AddSingleton<RandomFileChange>(); }
        );
        hostBuilder.UseWolverine();

        _host = await hostBuilder.StartAsync();
    }
    
    [Fact]
    public async Task should_be_in_session_using_service_provider()
    {
        var randomFileChange = _host.Services.GetRequiredService<RandomFileChange>();

        var session = await _host.Services
            .TrackActivity()
            .Timeout(2.Seconds())
            .ExecuteAndWaitAsync(
                (Func<IMessageContext, Task>)(
                    async (
                        _ 
                    ) => await randomFileChange.SimulateRandomFileChange()
                )
            );

        session
            .Sent
            .AllMessages()
            .Count()
            .ShouldBe(1);
        
        session
            .Sent
            .AllMessages()
            .First()
            .ShouldBeOfType<FileAdded>();
    }

    [Fact]
    public async Task should_be_in_session()
    {
        var randomFileChange = _host.Services.GetRequiredService<RandomFileChange>();

        var session = await _host
            .TrackActivity()
            .Timeout(2.Seconds())
            .ExecuteAndWaitAsync(
                (Func<IMessageContext, Task>)(
                    async (
                        _ 
                    ) => await randomFileChange.SimulateRandomFileChange()
                )
            );

        session
            .Sent
            .AllMessages()
            .Count()
            .ShouldBe(1);
        
        session
            .Sent
            .AllMessages()
            .First()
            .ShouldBeOfType<FileAdded>();
    }

    public async Task DisposeAsync() => await _host.StopAsync();
}
```

--------------------------------

### Customized AWS SNS Setup with Configuration

Source: https://wolverinefx.net/guide/messaging/transports/sns

This example demonstrates a more customized setup for Wolverine's Amazon SNS transport, allowing configuration of the service URL and other SNS settings via application configuration. It also includes auto-provisioning.

```csharp
var builder = Host.CreateApplicationBuilder();
    builder.UseWolverine(opts =>
    {
        var config = builder.Configuration;

        opts.UseAmazonSnsTransport(snsConfig =>
            {
                snsConfig.ServiceURL = config["AwsUrl"];
                // And any other elements of the SNS AmazonSimpleNotificationServiceConfig
                // that you may need to configure
            })

            // Let Wolverine create missing topics and subscriptions as necessary
            .AutoProvision();
    });
    
    using var host = builder.Build();
    await host.StartAsync();
```

--------------------------------

### Enable Automatic Database Schema Setup on Startup

Source: https://wolverinefx.net/guide/durability/managing.html

Configure your application to automatically build missing database schema objects when the application starts.

```csharp
    // This is rebuilding the persistent storage database schema on startup
    builder.Host.UseResourceSetupOnStartup();
```

--------------------------------

### Install Wolverine.Mqtt Package

Source: https://wolverinefx.net/guide/messaging/transports/mqtt.html

Install the WolverineFx.Mqtt NuGet package to enable MQTT transport support.

```bash
dotnet add package WolverineFx.Mqtt
```

--------------------------------

### Multi-tenanted PostgreSQL Storage with EF Core

Source: https://wolverinefx.net/guide/durability/efcore/multi-tenancy

Example configuration for using EF Core with multi-tenanted PostgreSQL storage. This setup assumes distinct databases for each tenant.

```csharp
public class MyDbContext : DbContext
{
    public MyDbContext(DbContextOptions<MyDbContext> options) : base(options) { }

    // Add your DbSets here
    public DbSet<Order> Orders { get; set; }
}

public class MyPostgresqlTenantDatabase : ITenantDatabase
{
    public string Name => "my-tenant-db";

    public string ConnectionString { get; }

    public MyPostgresqlTenantDatabase(string connectionString)
    {
        ConnectionString = connectionString;
    }

    public void Configure(WolverineOptions options)
    {
        options.Services.AddDbContext<MyDbContext>(opts => opts.UseNpgsql(ConnectionString));
    }
}

public class MultiTenancySetup : WolverineOptions
{
    public MultiTenancySetup()
    {
        // Assuming you have a way to get these connection strings
        var tenant1ConnectionString = "Host=localhost;Database=tenant1;";
        var tenant2ConnectionString = "Host=localhost;Database=tenant2;";
        var tenant3ConnectionString = "Host=localhost;Database=tenant3;";

        // Registering the tenant databases
        this.UseMultiTenancy()
            .AddDatabase<MyPostgresqlTenantDatabase>(new MyPostgresqlTenantDatabase(tenant1ConnectionString))
            .AddDatabase<MyPostgresqlTenantDatabase>(new MyPostgresqlTenantDatabase(tenant2ConnectionString))
            .AddDatabase<MyPostgresqlTenantDatabase>(new MyPostgresqlTenantDatabase(tenant3ConnectionString));
    }
}
```

--------------------------------

### Install Entity Framework Core Package

Source: https://wolverinefx.net/guide/durability/efcore

Install the WolverineFx.EntityFrameworkCore Nuget package to enable EF Core integration.

```bash
dotnet add package WolverineFx.EntityFrameworkCore
```

--------------------------------

### Example Concrete Event Subscription URI

Source: https://wolverinefx.net/guide/durability/polecat/distribution

A specific example of an event subscription URI, showing how to define the event store, database, and shard path.

```text
event-subscriptions://polecat/main/localhost.mydb/day/all
```

--------------------------------

### Example of CustomizedHandler with Configure Method

Source: https://wolverinefx.net/guide/handlers/middleware

An example demonstrating the use of a static Configure method to customize a HandlerChain, including adding middleware and adjusting log levels.

```csharp
public class CustomizedHandler
{
    public void Handle(SpecialMessage message)
    {
        // actually handle the SpecialMessage
    }

    public static void Configure(HandlerChain chain)
    {
        chain.Middleware.Add(new CustomFrame());

        // Turning off all execution tracking logging
        // from Wolverine for just this message type
        // Error logging will still be enabled on failures
        chain.SuccessLogLevel = LogLevel.None;
        chain.ProcessingLogLevel = LogLevel.None;
    }
}
```

--------------------------------

### Application Bootstrapping Example

Source: https://wolverinefx.net/guide/http/integration

Demonstrates the application bootstrapping process for an ASP.NET Core project using WolverineFx.HTTP, inspired by the Minimal API 'Todo' project and utilizing Marten for persistence.

```cs
// This is a placeholder for the actual C# code example from the source.
// The source text provided did not contain a complete C# code block for bootstrapping.
// Please refer to the original documentation for the full code.
```

--------------------------------

### Minimal API Basic GET Endpoint

Source: https://wolverinefx.net/llms-full.txt

Example of a basic GET endpoint using ASP.NET Core Minimal APIs.

```csharp
app.MapGet("/api/orders/{id}", async (int id, IOrderRepository repo) =>
{
    var order = await repo.GetByIdAsync(id);
    return order is not null ? Results.Ok(order) : Results.NotFound();
});
```

--------------------------------

### Start a New Event Stream with PolecatOps.StartStream

Source: https://wolverinefx.net/llms-full.txt

Example of starting a new event stream for a TodoList using PolecatOps.StartStream, returning both a response and the stream operation.

```cs
public static class TodoListEndpoint
{
    [WolverinePost("/api/todo-lists")]
    public static (TodoCreationResponse, IStartStream) CreateTodoList(
        CreateTodoListRequest request
    )
    {
        var listId = CombGuidIdGeneration.NewGuid();
        var result = new TodoListCreated(listId, request.Title);
        var startStream = PolecatOps.StartStream<TodoList>(listId, result);

        return (new TodoCreationResponse(listId), startStream);
    }
}
```

--------------------------------

### Add Resource Setup on Startup

Source: https://wolverinefx.net/guide/durability/marten/multi-tenancy

Ensures that message storage is set up in all databases upfront, which is necessary for multi-tenancy.

```csharp
builder.Services.AddResourceSetupOnStartup();
```

--------------------------------

### Running the OrderChainWithGrpc Sample

Source: https://wolverinefx.net/llms-full.txt

Instructions to run the InventoryServer, OrderServer, and OrderClient in separate terminals to observe the gRPC chain.

```bash
# Three terminals, bottom-up:
dotnet run --project src/Samples/OrderChainWithGrpc/InventoryServer
dotnet run --project src/Samples/OrderChainWithGrpc/OrderServer
dotnet run --project src/Samples/OrderChainWithGrpc/OrderClient
```

--------------------------------

### Starting a Saga with Identity Assignment

Source: https://wolverinefx.net/guide/durability/sagas.html

When starting a new saga by returning a Saga object from a handler, ensure the identity is set. This example shows a static `Start` method that creates an Order saga and assigns its identity.

```csharp
// This method would be called when a StartOrder message arrives
// to start a new Order
public static (Order, OrderTimeout) Start(StartOrder order, ILogger<Order> logger)
{
    logger.LogInformation("Got a new order with id {Id}", order.OrderId);

    // creating a timeout message for the saga
    return (new Order{Id = order.OrderId}, new OrderTimeout(order.OrderId));
}
```

--------------------------------

### Basic Saga Test Setup with Host

Source: https://wolverinefx.net/guide/durability/sagas.html

Set up a test host for saga testing by registering saga types and using InvokeMessageAndWaitAsync or SendMessageAndWaitAsync to drive the saga.

```csharp
using var host = await Host.CreateDefaultBuilder()
    .UseWolverine(opts =>
    {
        // Register your saga and any related handler types
        opts.Discovery.DisableConventionalDiscovery()
            .IncludeType(typeof(Order));
    }).StartAsync();
```

--------------------------------

### GET Endpoint with [FromQuery] Binding

Source: https://wolverinefx.net/llms-full.txt

An example of a GET endpoint that uses the [FromQuery] attribute to bind query string parameters to an OrderQuery object. This object is then used to filter and paginate orders.

```csharp
// If you want every value to be optional, use public, settable
// properties and a no-arg public constructor
public class OrderQuery
{
    public int PageSize { get; set; } = 10;
    public int PageNumber { get; set; } = 1;
    public bool? HasShipped { get; set; }
}

// Or -- and I'm not sure how useful this really is, use a record:
public record OrderQueryAlternative(int PageSize, int PageNumber, bool HasShipped);

public static class QueryOrdersEndpoint
{
    [WolverineGet("/api/orders/query")]
    public static Task<IPagedList<Order>> Query(
        // This will be bound from query string values in the HTTP request
        [FromQuery] OrderQuery query, 
        IQuerySession session,
        CancellationToken token)
    {
        IQueryable<Order> queryable = session.Query<Order>()
            // Just to make the paging deterministic
            .OrderBy(x => x.Id);

        if (query.HasShipped.HasValue)
        {
            queryable = query.HasShipped.Value 
                ? queryable.Where(x => x.Shipped.HasValue) 
                : queryable.Where(x => !x.Shipped.HasValue);
        }

        // Marten specific Linq helper
        return queryable.ToPagedListAsync(query.PageNumber, query.PageSize, token);
    }
}
```

--------------------------------

### Setup Resources

Source: https://wolverinefx.net/guide/durability/managing

Sets up Marten database objects and any known Wolverine transport objects like Rabbit MQ, Azure Service Bus, or AWS SQS queues.

```bash
dotnet run -- resources setup
```

--------------------------------

### Implement a Resequencer Saga

Source: https://wolverinefx.net/guide/durability/sagas.html

Subclass ResequencerSaga to handle sequenced messages. This example shows how to start the saga and handle incoming sequenced commands.

```csharp
public record StartMyWorkflow(Guid Id);

public record MySequencedCommand(Guid SagaId, int? Order) : SequencedMessage;

public class MyWorkflowSaga : ResequencerSaga<MySequencedCommand>
{
    public Guid Id { get; set; }

    public static MyWorkflowSaga Start(StartMyWorkflow cmd)
    {
        return new MyWorkflowSaga { Id = cmd.Id };
    }

    public void Handle(MySequencedCommand cmd)
    {
        // This will only be called when messages arrive in the correct order,
        // or when out-of-order messages are replayed after gaps are filled
    }
```

--------------------------------

### Define Shipping and Billing Sagas

Source: https://wolverinefx.net/guide/durability/sagas.html

Example of two independent sagas, ShippingSaga and BillingSaga, both starting from an OrderPlaced message and handling their own completion messages.

```csharp
// Shared message that both sagas react to
public record OrderPlaced(Guid OrderPlacedId, string ProductName);

// Messages specific to each saga
public record OrderShipped(Guid ShippingSagaId);
public record PaymentReceived(Guid BillingSagaId);

public class ShippingSaga : Saga
{
    public Guid Id { get; set; }
    public string ProductName { get; set; } = string.Empty;

    public static ShippingSaga Start(OrderPlaced message)
    {
        return new ShippingSaga
        {
            Id = message.OrderPlacedId,
            ProductName = message.ProductName
        };
    }

    public void Handle(OrderShipped message)
    {
        MarkCompleted();
    }
}

public class BillingSaga : Saga
{
    public Guid Id { get; set; }
    public string ProductName { get; set; } = string.Empty;

    public static BillingSaga Start(OrderPlaced message)
    {
        return new BillingSaga
        {
            Id = message.OrderPlacedId,
            ProductName = message.ProductName
        };
    }

    public void Handle(PaymentReceived message)
    {
        MarkCompleted();
    }
}
```

--------------------------------

### Basic AWS SQS Setup

Source: https://wolverinefx.net/guide/messaging/transports/sqs

Connects to AWS SQS using default shared configuration files. Enables auto-provisioning of queues and auto-purging on startup.

```csharp
var host = await Host.CreateDefaultBuilder()
    .UseWolverine(opts =>
    {
        // This does depend on the server having an AWS credentials file
        // See https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html for more information
        opts.UseAmazonSqsTransport()

            // Let Wolverine create missing queues as necessary
            .AutoProvision()

            // Optionally purge all queues on application startup.
            // Warning though, this is potentially slow
            .AutoPurgeOnStartup();
    }).StartAsync();
```

--------------------------------

### Building Storage on Startup

Source: https://wolverinefx.net/guide/durability/managing

Configure your application to automatically build any missing database schema objects when the application starts.

```csharp
// This is rebuilding the persistent storage database schema on startup
builder.Host.UseResourceSetupOnStartup();
```

--------------------------------

### Complete WolverineFX NATS Integration Example

Source: https://wolverinefx.net/llms-full.txt

This comprehensive example demonstrates configuring WolverineFX with NATS, including JetStream setup, message publishing and listening, and resource provisioning. It shows how to set up durable streams, configure message acknowledgments, and define specific subjects for message types.

```csharp
using var host = await Host.CreateDefaultBuilder()
    .UseWolverine(opts =>
    {
        opts.UseNats("nats://localhost:4222")
            .AutoProvision()
            .WithCredentials("user", "pass")
            .UseJetStream(js =>
            {
                js.MaxDeliver = 5;
                js.AckWait = TimeSpan.FromSeconds(30);
            })
            .DefineWorkQueueStream("ORDERS", 
                s => s.EnableScheduledDelivery(), 
                "orders.>");

        // Listen to orders with JetStream durability
        opts.ListenToNatsSubject("orders.received")
            .UseJetStream("ORDERS", "order-processor")
            .Named("order-listener");

        // Publish order events
        opts.PublishMessage<OrderCreated>()
            .ToNatsSubject("orders.created");

        opts.PublishMessage<OrderShipped>()
            .ToNatsSubject("orders.shipped");

        opts.Services.AddResourceSetupOnStartup();
    }).StartAsync();
```

--------------------------------

### Bootstrap IHost with SignalR Client for Mimicking Clients

Source: https://wolverinefx.net/llms-full.txt

Demonstrates bootstrapping `IHost` instances with the SignalR Client to simulate browser client communication within a test harness. It configures message publishing to SignalR clients.

```csharp
var host = await Host.CreateDefaultBuilder()
    .UseWolverine(opts =>
    {
        opts.ServiceName = serviceName;

        opts.UseClientToSignalR(Port);

        opts.PublishMessage<ToFirst>().ToSignalRWithClient(Port);

        opts.PublishMessage<RequiresResponse>().ToSignalRWithClient(Port);

        opts.Publish(x =>
        {
            x.MessagesImplementing<WebSocketMessage>();
            x.ToSignalRWithClient(Port);
        });
    }).StartAsync();
```

--------------------------------

### Sample Extension Implementation

Source: https://wolverinefx.net/guide/extensions

A sample implementation of the IWolverineExtension interface. This extension demonstrates adding service registrations and altering serialization settings.

```csharp
public class SampleExtension : IWolverineExtension
{
    public void Configure(WolverineOptions options)
    {
        // Add service registrations
        options.Services.AddTransient<IFoo, Foo>();

        // Alter settings within the application
        options
            .UseNewtonsoftForSerialization(settings => settings.TypeNameHandling = TypeNameHandling.None);
    }
}
```

--------------------------------

### Stopwatch Middleware Example

Source: https://wolverinefx.net/guide/handlers/middleware

A middleware class that uses a Stopwatch to measure the execution time of message handlers. It starts the stopwatch before execution and logs the duration in a finally block.

```csharp
public class StopwatchMiddleware
{
    private readonly Stopwatch _stopwatch = new();

    public void Before()
    {
        _stopwatch.Start();
    }

    public void Finally(ILogger logger, Envelope envelope)
    {
        _stopwatch.Stop();
        logger.LogDebug("Envelope {Id} / {MessageType} ran in {Duration} milliseconds",
            envelope.Id, envelope.MessageType, _stopwatch.ElapsedMilliseconds);
    }
}
```

--------------------------------

### Signup Endpoint Example

Source: https://wolverinefx.net/llms-full.txt

This example demonstrates how ASP.NET Core attributes like [Tags], [ProducesResponseType], and Wolverine's [WolverinePost] can be used to define OpenAPI metadata for an endpoint.

```APIDOC
## POST /users/sign-up

### Description
Registers a new user.

### Method
POST

### Endpoint
/users/sign-up

### Parameters
#### Request Body
- **request** (SignUpRequest) - Required - The request object containing signup details.

### Response
#### Success Response (204)
No content is returned upon successful signup.
```

--------------------------------

### HTTP Stopwatch Middleware Example

Source: https://wolverinefx.net/guide/http/middleware

A sample middleware class designed to measure the execution time of HTTP requests. It uses Before and Finally methods to start and stop a stopwatch, logging the duration.

```csharp
public class StopwatchMiddleware
    {
        private readonly Stopwatch _stopwatch = new();
    
        public void Before()
        {
            _stopwatch.Start();
        }
    
        public void Finally(ILogger logger, HttpContext context)
        {
            _stopwatch.Stop();
            logger.LogDebug("Request for route {Route} ran in {Duration} milliseconds",
                context.Request.Path, _stopwatch.ElapsedMilliseconds);
        }
    }
```

--------------------------------

### Simple Hello World Endpoint Returning String

Source: https://wolverinefx.net/guide/http/endpoints

Creates an endpoint that returns a plain text string with a 'text/plain' content type.

```csharp
public class HelloEndpoint
{
    [WolverineGet("/")]
    public string Get() => "Hello.";
}
```

--------------------------------

### Create New Web API Project

Source: https://wolverinefx.net/guide/http/integration

Starts a new ASP.NET Core Web API project. This is the initial step before adding WolverineFx.HTTP.

```bash
dotnet new webapi
```

--------------------------------

### Invoking Command Handler to Get Latest Aggregate State

Source: https://wolverinefx.net/llms-full.txt

Example of how to invoke a command handler using IMessageBus and expect the latest version of the Order aggregate as the response. This demonstrates the mediator usage pattern with Wolverine.

```csharp
public static Task<Order> update_and_get_latest(IMessageBus bus, MarkItemReady command)
{
    // This will return the updated version of the Order
    // aggregate that incorporates whatever events were appended
    // in the course of processing the command
    return bus.InvokeAsync<Order>(command);
}
```

--------------------------------

### Describe Handlers via Command Line

Source: https://wolverinefx.net/guide/diagnostics

Uses the 'wolverine-diagnostics describe-handlers' command to get a report on handler discovery for a specified message type. This command builds the host and handler graph without starting the application.

```bash
dotnet run -- wolverine-diagnostics describe-handlers MyMissingMessageHandler
```

--------------------------------

### Install Wolverine.Http.Polecat

Source: https://wolverinefx.net/guide/http/polecat

Use the dotnet CLI to add the WolverineFx.Http.Polecat package to your project.

```bash
dotnet add package WolverineFx.Http.Polecat
```

--------------------------------

### Install Wolverine.Http.Marten Library

Source: https://wolverinefx.net/guide/http/marten

Use this command to add the Wolverine.Http.Marten integration library to your project. This enables the enhanced Marten integration features within Wolverine.HTTP.

```bash
dotnet add package WolverineFx.Http.Marten
```

--------------------------------

### Start Order Fulfillment Handler

Source: https://wolverinefx.net/llms-full.txt

Handles the `StartOrderFulfillment` command. It initiates a new order fulfillment stream using Marten and schedules a `PaymentTimeout` message with a configurable delay. This handler is responsible for the initial setup of the process.

```csharp
using Wolverine;
using Wolverine.Marten;

namespace ProcessManagerViaHandlers.OrderFulfillment.Handlers;

public static class StartOrderFulfillmentHandler
{
    public static readonly TimeSpan DefaultPaymentTimeoutWindow = TimeSpan.FromMinutes(15);

    public static (IStartStream, OutgoingMessages) Handle(StartOrderFulfillment command)
    {
        var started = new OrderFulfillmentStarted(
            command.OrderFulfillmentStateId,
            command.CustomerId,
            command.TotalAmount);

        var outgoing = new OutgoingMessages();
        outgoing.Delay(
            new PaymentTimeout(command.OrderFulfillmentStateId),
            command.PaymentTimeoutWindow ?? DefaultPaymentTimeoutWindow);

        return (
            MartenOps.StartStream<OrderFulfillmentState>(command.OrderFulfillmentStateId, started),
            outgoing);
    }
}
```

--------------------------------

### Opt-in to Newtonsoft.Json for Wolverine HTTP

Source: https://wolverinefx.net/llms-full.txt

This C# snippet demonstrates how to opt into using Newtonsoft.Json for JSON serialization specifically for Wolverine HTTP routes. It requires installing the `WolverineFx.Http.Newtonsoft` NuGet package and configuring it during application setup.

```csharp
var builder = WebApplication.CreateBuilder([]);
builder.Services.AddScoped<IUserService, UserService>();

builder.Services.AddMarten(Servers.PostgresConnectionString)
    .IntegrateWithWolverine();

builder.Host.UseWolverine(opts =>
{
    opts.Discovery.IncludeAssembly(GetType().Assembly);
});

builder.Services.AddWolverineHttp();
// As of Wolverine 6.0, Newtonsoft.Json HTTP support lives in the
// separate WolverineFx.Http.Newtonsoft package — register its
// services here, then opt in via UseNewtonsoftJsonForSerialization() 
// below.
builder.Services.AddWolverineHttpNewtonsoft();

await using var host = await AlbaHost.For(builder, app =>
{
    app.MapWolverineEndpoints(opts =>
    {
        // Opt into using Newtonsoft.Json for JSON serialization just with Wolverine.HTTP routes
        // Configuring the JSON serialization is optional. This extension method comes from
        // the WolverineFx.Http.Newtonsoft package (using Wolverine.Http.Newtonsoft;).
        opts.UseNewtonsoftJsonForSerialization(settings => settings.TypeNameHandling = TypeNameHandling.All);
    });
});
```

--------------------------------

### Tuple Return Values for Saga and Cascading Messages

Source: https://wolverinefx.net/guide/handlers/return-values

This C# example demonstrates how a Wolverine handler can return a tuple containing a new saga state object and a cascading message. This is useful for starting a new saga and immediately publishing a related event.

```csharp
public static (Order, OrderTimeout) Start(StartOrder order, ILogger<Order> logger)
{
    logger.LogInformation("Got a new order with id {Id}", order.OrderId);

    // creating a timeout message for the saga
    return (new Order{Id = order.OrderId}, new OrderTimeout(order.OrderId));
}
```

--------------------------------

### Kafka Consumer Cold Start Options

Source: https://wolverinefx.net/guide/messaging/transports/kafka

Configure how a Kafka consumer starts when no committed offset exists for its group. Use `BeginAtEarliest()` to start from the beginning or `BeginAtLatest()` to start from the end of the topic.

```csharp
opts.ListenToKafkaTopic("orders").BeginAtEarliest();   // cold start from the beginning of the topic
    opts.ListenToKafkaTopic("orders").BeginAtLatest();     // cold start from the tail (skip the backlog)
```

--------------------------------

### Brighter RequestHandler Example

Source: https://wolverinefx.net/llms-full.txt

Example of inheriting from Brighter's RequestHandler base class.

```csharp
public class OrderHandler : RequestHandler<SubmitOrder>
{
    public override SubmitOrder Handle(SubmitOrder command)
    {
        // ... must call base.Handle(command) to continue pipeline
        return base.Handle(command);
    }
}
```

--------------------------------

### Wolverine Configuration Example

Source: https://wolverinefx.net/guide/migrating-to-wolverine

Shows Wolverine configuration using the .NET Generic Host, including RabbitMQ transport, PostgreSQL persistence, and message publishing/listening.

```csharp
builder.Host.UseWolverine(opts =>
{
    opts.UseRabbitMq(r => r.HostName = "localhost").AutoProvision();
    opts.PersistMessagesWithPostgresql(connectionString);
    opts.PublishMessage<PlaceOrder>().ToRabbitQueue("sales-orders");
    opts.ListenToRabbitQueue("sales-orders");
});
```

--------------------------------

### MassTransit Handler Example

Source: https://wolverinefx.net/guide/migrating-to-wolverine

Example of a MassTransit IConsumer<T> handler for processing SubmitOrder messages.

```csharp
public class SubmitOrderConsumer : IConsumer<SubmitOrder>
{
    private readonly IOrderRepository _repo;

    public SubmitOrderConsumer(IOrderRepository repo)
    {
        _repo = repo;
    }

    public async Task Consume(ConsumeContext<SubmitOrder> context)
    {
        await _repo.Save(new Order(context.Message.OrderId));
        await context.Publish(new OrderSubmitted { OrderId = context.Message.OrderId });
    }
}
```

--------------------------------

### Wolverine Command Line Help Output

Source: https://wolverinefx.net/llms-full.txt

Example output of available command-line options for a Wolverine application integrated with JasperFx.

```bash
The available commands are:
                                                                                                    
  Alias       Description                                                                           
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  check-env   Execute all environment checks against the application                                
  codegen     Utilities for working with JasperFx.CodeGeneration and JasperFx.RuntimeCompiler       
  describe    Writes out a description of your running application to either the console or a file  
  help        List all the available commands                                                       
  resources   Check, setup, or teardown stateful resources of this system                               
  run         Start and run this .Net application                                                   
  storage                Administer the Wolverine message storage
  wolverine-diagnostics  Wolverine diagnostics tools for inspecting generated code and runtime behavior


Use dotnet run -- ? [command name] or dotnet run -- help [command name] to see usage help about a specific command

```