Learn by example.

Minimal Flat API example — chain transitions to build and transform a greeting.

#[transition]
async fn greet(input: String) -> Outcome<String, String> {
    Outcome::Next(format!("Hello, {input}!"))
}

Type-safe decision flows using Rust enums with Axon, Transition, and Outcome.

let flow = Axon::new("flow")
    .then(validate)
    .then(process);

Axon flow visualization with schematic extraction for debugging and documentation.

Outcome::Branch for prefix-based path routing with nested decision trees.

Domain-driven workflow: validation, payment, inventory reservation, and shipping.

Axon::new("order")
    .then(validate_order)
    .then(process_payment)
    .then(reserve_inventory)
    .then(arrange_shipping)

Declarative allow/deny access control via @transition bus attributes.

#[transition(bus_allow = "db,cache")]
async fn fetch(input: Req) -> Outcome<Resp, String> { .. }

Type-safe extraction of path, query, and body parameters in HTTP handlers.

@transition and @ranvier_router macros for concise route definitions.

#[ranvier_router]
fn routes() -> Router {
    route!(GET "/users" => list_users);
    route!(POST "/users" => create_user);
}

Advanced session lifecycle patterns: creation, validation, expiration, and cleanup.

File upload handling with multipart/form-data extraction and validation.

WebSocket connections with event-based messaging and session context.

Bidirectional WebSocket communication with echo loop and connection lifecycle.

Server-Sent Events for real-time streaming responses to clients.

Auto-generated OpenAPI/Swagger docs with schema validation via schemars.

Serve static files and build assets from configurable directories.

Single-page application hosting with fallback routing and asset serving.

HTTP security pipeline using CorsGuard, RateLimitGuard, SecurityHeadersGuard, and IpFilterGuard as visible Transition nodes.

Axon::new("Guarded API")
    .then(CorsGuard::new(cors_config))
    .then(RateLimitGuard::new(100, 60_000))
    .then(SecurityHeadersGuard::new(policy))
    .then(IpFilterGuard::allow_list(["127.0.0.1"]))
    .then(HelloHandler)

IamVerifier implementation with HS256 JWT, IamPolicy::RequireRole, and Axon::with_iam() boundary verification.

let admin_circuit = Axon::new("admin-dashboard")
    .with_iam(
        IamPolicy::RequireRole("admin".into()),
        JwtVerifier,
    )
    .then(AdminDashboard);

Workflow crash recovery, checkpointing, and compensation hooks.

Axon::new("resilient")
    .then(step_a)
    .then(step_b)
    .with_persistence(store)
    .with_compensation(rollback);

Redis for session storage and caching with async ConnectionManager.

Sea ORM for database operations with migrations and active models.

SQLx pool injected via Bus with Transition-based queries using in-memory SQLite.

let db = DbPool(pool);
let insert_axon = Axon::new("insert-user")
    .then(InsertUser);
insert_axon.execute(req, &db, &mut bus).await;

Automatic span generation in transitions with Traced wrapper and ConnectionBus.

Core Synapse trait for type-safe external service calls (DB, API, messaging).

ranvier.toml config, environment overrides, profiles, structured logging, and graceful shutdown.

Built-in transitions: FilterNode, SwitchNode, LogNode for pipeline composition.

Tenant isolation patterns with Bus-injected TenantId and scoped data access.

Unit and integration testing strategies for Transitions and Axon chains.

Domain-specific error enums with thiserror for type-safe error handling.

DLQ retry with exponential backoff, timeout patterns, and circuit breaker.

let axon = Axon::new("payment")
    .then(gateway)
    .with_dlq_policy(DlqPolicy::RetryThenDlq {
        max_attempts: 5,
        backoff_ms: 100,
    })
    .with_dlq_sink(dlq);

Durable workflow execution with fault recovery, checkpointing, and compensation.

3-stage LLM pipeline: content extraction, AI classification, and policy enforcement.

// ExtractContent → ModerateContent → ApplyPolicy
Axon::new("moderate")
    .then(extract_content)
    .then(moderate_content)
    .then(apply_policy)

Complete Saga pipeline with compensation, audit trail, multi-tenancy, and RFC 7807 errors.

// Saga: CreateOrder → ProcessPayment → ReserveInventory → ScheduleShipping
//          ↓ (comp)          ↓ (comp)
//      RefundPayment    ReleaseInventory

Multi-room WebSocket chat with JWT auth, REST + WS hybrid routing, and message persistence.

Complete CRUD application with JWT authentication, Bus dependency injection, HTTP routing, and collection-based testing.

// Single-transition Axon circuits per endpoint
POST /login   -> [login]       -> JWT token
GET  /todos   -> [list_todos]  -> Vec<Todo>
POST /todos   -> [create_todo] -> Todo
PUT  /todos/:id  -> [update_todo] -> Todo
DELETE /todos/:id -> [delete_todo] -> { deleted }