Learn by example.

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

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

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

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

// Outcome<T, E> — control flow as data
Outcome::Next(value)       // linear progression
Outcome::Fault(err)        // error path
Outcome::Branch("name", v) // conditional routing
Outcome::Jump("node", v)   // goto / loop
Outcome::Emit(event)       // side-effect event

Axon::typed::<GreetRequest, String>("greet")
    .then_fn("validate", |req, _bus| {
        if req.name.is_empty() {
            Outcome::Fault("empty".into())
        } else {
            Outcome::Next(req.name)
        }
    })
    .then_fn("format", |name, _bus| {
        Outcome::Next(json!({"message": format!("Hello, {name}!")}))
    })

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

Ranvier::http()
    .get_json_out("/items", list_items_axon)
    .post_typed_json_out::<CreateItem, _, _>("/items", create_item_axon)
    .delete_json_out("/items/:id", delete_item_axon)

Ranvier::http()
    .post_typed_json_out("/login", login)
    .get_json_out("/users", list_users)
    .post_typed_json_out("/users", create_user)
    .put_typed_json_out("/users/:id", update_user)
    .delete_json_out("/users/:id", delete_user)

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)

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

Ranvier::http()
    .guard(CorsGuard::<()>::new(cors_config))
    .guard(CompressionGuard::<()>::new())
    .guard(AuthGuard::<()>::bearer(tokens))
    .get("/api/hello", hello_circuit)
    .post_with_guards("/api/orders", order_circuit, guards![
        TimeoutGuard::<()>::new(Duration::from_secs(30)),
        ContentTypeGuard::<()>::json(),
        IdempotencyGuard::<()>::ttl_5min(),
    ])

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

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

let config = try_outcome!(bus.get_cloned::<AppConfig>(), "AppConfig not in Bus");
let result = Outcome::from_result(service.call().await)
    .map_fault(|e| AppError::Service(e.to_string()));

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

let axon = Axon::simple::<String>("resilient-api")
    .then_with_retry(flaky_service, 3)
    .then_with_timeout(slow_service, Duration::from_secs(5));

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

Ranvier::http()
    .post_typed_json_out("/login", login)
    .post_typed_json_out("/requests", create_request)
    .get_with_error("/requests/:id", get_request, governance_error_response)
    .post_with_error("/requests/:id/approve", approve_request, governance_error_response)

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

Ranvier::http()
    .guard(CorsGuard::<AppState>::permissive())
    .post_typed_json_out("/login", login)
    .get_json_out("/dashboard", dashboard)
    .get_json_out("/users", list_users)

// 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 }

// Reserve → Charge → Ship (compensate in reverse on failure)
let saga = Axon::<Order, Order, String>::new("OrderSaga")
    .then(ReserveInventory)
    .then(ChargePayment)
    .then(ConfirmShipping);

// Sanctions → PEP → Risk Score → Documents
let screening = Axon::<Applicant, Applicant, String>::new("Screening")
    .then(SanctionsCheck)
    .then(PepCheck)
    .then(RiskScoring)
    .then(DocumentVerification);

// Query → ClassifiedQuery → ToolResult → Response
let pipeline = Axon::<Query, Query, String>::new("AgentPipeline")
    .then(ClassifyIntent)
    .then(ExecuteTool)
    .then(FormatResponse);

// SensorReading → EvaluatedReading → ActuatorCommand
let pipeline = Axon::<SensorReading, SensorReading, String>::new("SensorDecision")
    .then(EvaluateThresholds)
    .then(MakeDecision);

// Vitals → Severity → Department routing
let triage = Axon::<Patient, Patient, String>::new("PatientTriage")
    .then(AssessVitals)
    .then(ClassifySeverity)
    .then(RouteToDepartment);

// Age → Income → Residency → BenefitCap
let rules = Axon::<Applicant, Applicant, String>::new("Eligibility")
    .then(AgeRule)
    .then(IncomeRule)
    .then(ResidencyRule)
    .then(BenefitCapRule);