Declaring by hand

const PRICE: Input<i64> = Input::new("price");
const DISCOUNT: OptionalInput<i64> = OptionalInput::new("discount");

/// Works out what an order costs, for one attempt: its price, less its discount if it has one,
/// given back as the amount to charge.
struct Price<'a> {
    price: i64,
    discount: Option<i64>,
    contributor: Contributor<'a>,
}

impl Step for Price<'_> {
    fn run(mut self) -> Result<Outcome, Error> {
        let amount = self.price - self.discount.unwrap_or(0);
        self.contributor.contribute("amount", amount);
        Ok(Outcome::success())
    }
}

/// Builds the pricing for each attempt, from what it needs.
struct Pricing;

impl StepFactory for Pricing {
    type Step<'a> = Price<'a>;

    fn needs(&self) -> StepNeeds {
        StepNeeds::new()
            .input(&PRICE)
            .optional_input(&DISCOUNT)
            .contributor()
    }

    fn build<'a>(&'a self, got: &mut Resolved<'a>) -> Result<Price<'a>, Error> {
        Ok(Price {
            price: got.input(&PRICE)?,
            discount: got.optional_input(&DISCOUNT)?,
            contributor: got.contributor()?,
        })
    }
}

const AMOUNT: Input<i64> = Input::new("amount");
const RECEIPT: Input<String> = Input::new("receipt");

/// Writes an audit line for every step it is attached to that succeeds: the journey, the attempt
/// that took the money, the amount the order was charged, and the receipt the step gave back.
struct Audit;

impl OnStepSuccess<Orders> for Audit {
    fn needs() -> HookNeeds<StepSuccess> {
        HookNeeds::new()
            .from_workflow(&AMOUNT)
            .from_step(&RECEIPT)
            .contributor()
    }

    fn on_step_success(
        &self,
        mut got: Requested<'_, Orders, StepSuccess>,
    ) -> Result<Option<OnSuccess>, Error> {
        let journey = got.journey_id();
        let step = got.step_name();
        let attempt = got.attempt();
        let amount = got.from_workflow(&AMOUNT)?;
        let receipt = got.from_step(&RECEIPT)?;
        got.contributor()?.contribute(
            "audit",
            format!("{journey}: {step} took {amount} on attempt {attempt}, receipt {receipt}"),
        );
        Ok(None)
    }
}

/// The shop's workflow, whose own value is the channel the shop tells its customers through.
struct Orders {
    channel: &'static str,
}

impl Refunds for Orders {
    fn refund(&self, receipt: &str, amount: i64) {
        println!("the bank gives {amount} back on receipt {receipt}");
    }
}

impl Provides<dyn Refunds> for Orders {
    fn role(&self) -> &(dyn Refunds + 'static) {
        self
    }
}

impl Messages for Orders {
    fn tell(&self, customer: &str, message: &str) {
        println!("{} to {customer}: {message}", self.channel);
    }
}

impl Provides<dyn Messages> for Orders {
    fn role(&self) -> &(dyn Messages + 'static) {
        self
    }
}

const PARCEL: Input<Parcel> = Input::new("parcel");

impl Orders {
    /// Names each journey after its order.
    fn order_number(&self, data: &DataBag) -> Result<String, Error> {
        Ok(data.required("order")?)
    }

    /// Gives the shipping the weight of the order's parcel, as the warehouse describes it. Every
    /// other input of the shipping is read from the data bag.
    fn parcels(
        &self,
        mut got: Requested<'_, Self, InputAdapter>,
    ) -> Result<Option<AnyValue>, Error> {
        if got.key() != "weight" {
            return Ok(None);
        }
        let parcel = got.from_workflow(&PARCEL)?;
        Ok(Some(AnyValue::new(parcel.weight)))
    }

    /// The order book, which has the orders completed before today.
    fn ledger(
        &self,
        _: Requested<'_, Self, Provider<PerJourney>>,
    ) -> Result<Provided<dyn OrderBook>, Error> {
        Ok(provide!(Ledger {
            completed: vec!["A-13"],
        }))
    }

    /// The bank, as the payment client of the journey.
    fn bank(
        &self,
        _: Requested<'_, Self, Provider<PerJourney>>,
    ) -> Result<Provided<dyn Payments>, Error> {
        Ok(provide!(Bank { this_year: 2026 }))
    }

    /// The bank's card registry in Europe, for the charge's rescue step only.
    fn cards(
        &self,
        _: Requested<'_, Self, Provider<PerJourney>>,
    ) -> Result<Provided<dyn Cards>, Error> {
        Ok(Provided::from_box(card_registry("eu")).with_data("eu".to_owned()))
    }

    /// A carrier for every attempt of a step: the main carrier first, the backup carrier after.
    fn carriers(
        &self,
        got: Requested<'_, Self, Provider<PerAttempt>>,
    ) -> Result<Provided<dyn Carrier>, Error> {
        if got.attempt() == NonZeroU32::MIN {
            return Ok(provide!(MainCarrier));
        }
        Ok(provide!(BackupCarrier))
    }
}

const ORDER_BOOK: Service<dyn OrderBook> = Service::new("order_book");
const PAYMENTS: Service<dyn Payments> = Service::new("payments");
const CARDS: Service<dyn Cards> = Service::new("cards");
const CARRIER: Service<dyn Carrier> = Service::new("carrier");

/// Declares the shop's workflow, part by part, and checks it. It looks the order up, and finishes
/// an order already completed. Otherwise it works out what the order costs, then charges it,
/// repairing a charge that fails and auditing one that succeeds, then ships, and shipping may be
/// tried once more, its charge refunded if it is given up. Once a journey has ended, the customer
/// is told.
fn orders() -> Result<WorkflowDescriptor<Orders>, Violations> {
    let audit = StepPolicyDescriptor::new("audit", || Audit).on_step_success();
    let parcels = InputAdapterDescriptor::new("parcels", step_name!("ship"), Orders::parcels)
        .needing(HookNeeds::new().from_workflow(&PARCEL));
    let cards = ServiceProviderDescriptor::new("cards", &CARDS, Orders::cards)
        .step(step_name!("charge_rescue"));
    WorkflowDescriptor::builder("orders")
        .step(Lookup::descriptor(step_name!("lookup")).policy(AlreadyCompleted::descriptor()))
        .step(StepDescriptor::new(step_name!("price"), Pricing))
        .step(
            Charge::descriptor(step_name!("charge"))
                .policy(audit)
                .policy(Outage::descriptor())
                .rescued_by::<RenewCard>(),
        )
        .step(
            Ship::descriptor(step_name!("ship"))
                .retry_budget(1)
                .policy(FailedShipping::descriptor()),
        )
        .policy(Notify::descriptor())
        .reporter::<Log>()
        .reporter::<Desk>()
        .id_generator(Orders::order_number)
        .input_adapter(parcels)
        .provider(ServiceProviderDescriptor::new(
            "ledger",
            &ORDER_BOOK,
            Orders::ledger,
        ))
        .provider(ServiceProviderDescriptor::new(
            "bank",
            &PAYMENTS,
            Orders::bank,
        ))
        .provider(cards)
        .provider(ServiceProviderDescriptor::per_attempt(
            "carriers",
            &CARRIER,
            Orders::carriers,
        ))
        .build()
}

let created = orders
    .instance(Orders { channel: "email" })
    .reporters_global_metadata("customer", customer.to_owned())
    .initial_data(NewOrder {
        order: order.map(str::to_owned),
        customer: customer.to_owned(),
        price,
        discount,
        parcel: Parcel { weight, size },
        card: card.map(str::to_owned),
        gift_card,
    })
    .create();

/// Charges an order's price.
#[derive(Step)]
struct Charge {
    #[input]
    price: i64,
}

#[step]
impl Charge {
    fn run(self, #[contributor] mut contributor: Contributor<'_>) -> Result<Outcome, Error> {
        if self.price <= 0 {
            return Self::fail("nothing-to-charge");
        }
        contributor.contribute("charged", self.price);
        Self::succeed()
    }
}

/// Ships an order's parcel, of this weight in kg, through the carrier.
#[derive(Step)]
struct Ship {
    #[input]
    #[expect(dead_code, reason = "the shipping is declared, never run")]
    weight: i64,
}

#[step]
impl Ship {
    fn run(self) -> Result<Outcome, Error> {
        Self::succeed()
    }
}

/// Audits every successful charge.
#[derive(Default)]
struct Audit;

#[step_policy(name = "audit")]
impl Audit {
    #[on_step_success]
    fn audited(
        &self,
        #[from_step] charged: i64,
        #[contributor] mut contributor: Contributor<'_>,
    ) -> Result<Option<OnSuccess>, Error> {
        contributor.contribute("audit", format!("charged {charged}"));
        Self::carry_on()
    }
}

/// Writes a receipt for every successful charge.
#[derive(Default)]
struct Receipts;

#[step_policy(name = "receipts")]
impl Receipts {
    #[on_step_success]
    fn written(
        &self,
        #[from_step] charged: i64,
        #[contributor] mut contributor: Contributor<'_>,
    ) -> Result<Option<OnSuccess>, Error> {
        contributor.contribute("receipt", format!("R-{charged}"));
        Self::carry_on()
    }
}

/// The shop's workflow, which holds nothing of its own.
struct Orders;

/// How the warehouse describes an order's parcel: its weight in kg, and its size in cm.
#[derive(Clone, Serialize, Deserialize)]
struct Parcel {
    weight: i64,
    size: [i64; 3],
}

const PARCEL: Input<Parcel> = Input::new("parcel");

/// Gives the shipping the weight of the order's parcel. Every other input is read from the data
/// bag.
fn parcels(
    _: &Orders,
    mut got: Requested<'_, Orders, InputAdapter>,
) -> Result<Option<AnyValue>, Error> {
    if got.key() != "weight" {
        return Ok(None);
    }
    Ok(Some(AnyValue::new(got.from_workflow(&PARCEL)?.weight)))
}

/// Declares the parcels adapter, attached to the step of this name.
fn parcels_for(step: StepName) -> InputAdapterDescriptor<Orders> {
    InputAdapterDescriptor::new("parcels", step, parcels)
        .needing(HookNeeds::new().from_workflow(&PARCEL))
}

let refused = WorkflowDescriptor::builder("orders")
    .step(
        Charge::descriptor(step_name!("charge"))
            .policy(Audit::descriptor())
            .policy(Receipts::descriptor()),
    )
    .step(Ship::descriptor(step_name!("ship")))
    .step(Ship::descriptor(step_name!("ship")).retry_budget(1))
    .input_adapter(parcels_for(step_name!("shipping")))
    .build();

match refused {
    Ok(_) => println!("the workflow was built"),
    Err(violations) => {
        println!("the workflow was refused:");
        for violation in &violations {
            println!("  {violation}");
        }
    }
}

let built = WorkflowDescriptor::builder("orders")
    .step(Charge::descriptor(step_name!("charge")).policy(Audit::descriptor()))
    .step(Ship::descriptor(step_name!("ship")).retry_budget(1))
    .input_adapter(parcels_for(step_name!("ship")))
    .build();
match built {
    Ok(orders) => {
        println!("the fixed workflow was built:");
        for listed in orders.listing() {
            println!("  {}. {}", listed.position, listed.step);
        }
    }
    Err(violations) => println!("still refused: {violations}"),
}