crates/core-invoice/src/models/error.rs:239

• CreateSmtpTransportError’s #[error(...)] already adds the "Failed to create SMTP transport" context, but create_smtp_transport_error also prepends that text into the underlying field. This will lead to duplicated phrasing in the final error message; consider storing only the debug-formatted source error in underlying.

    pub fn create_smtp_transport_error(underlying: impl std::fmt::Debug) -> Self {
        Self::CreateSmtpTransportError {
            underlying: format!("Failed to create SMTP transport: {underlying:?}"),
        }

crates/core-invoice/src/models/error.rs:246

• SendEmailError’s #[error(...)] already adds the "Failed to send email" context, but send_email_error also prepends that text into underlying. This duplicates wording in the rendered error; consider formatting underlying as just the debug-formatted source error.

    pub fn send_email_error(underlying: impl std::fmt::Debug) -> Self {
        Self::SendEmailError {
            underlying: format!("Failed to send email: {underlying:?}"),
        }

crates/core-invoice/src/models/error.rs:313

• parse_error eagerly converts context into a String before returning the closure (let context = context.into();). When called with &str, that allocates even on the success path. Consider accepting &str (or impl Display + 'a) and doing the format!/to_string() inside the returned closure so allocation only happens when an error actually occurs.

    pub fn parse_error<E: std::fmt::Display>(context: impl Into<String>) -> impl FnOnce(E) -> Self {
        let context = context.into();
        move |error| Self::ParseError {
            underlying: format!("{context}: {error}"),
        }

crates/core-invoice/src/models/error.rs:333

• invalid_expense_item converts inputs into owned Strings when constructing the map_err closure (e.g. let invalid_string = invalid_string.into();), so allocations happen even when parsing succeeds. Consider capturing &str/&'static str (or other non-allocating inputs) in the returned closure and only allocating/building the strings if the error path is taken.

        invalid_string: impl Into<String>,
        field: impl Into<String>,
    ) -> impl FnOnce(E) -> Self {
        let invalid_string = invalid_string.into();
        let field = field.into();

crates/core-invoice/src/models/error.rs:321

• network_error eagerly converts context into a String before returning the closure (let context = context.into();), which allocates even when the network request succeeds. Consider capturing context as &str/impl Display + 'a and only formatting/allocating the final String inside the closure when an error occurs.

    pub fn network_error<E: std::fmt::Display>(
        context: impl Into<String>,
    ) -> impl FnOnce(E) -> Self {
        let context = context.into();
        move |error| Self::NetworkError {

crates/core-invoice/src/models/error.rs:293

• file_not_found eagerly converts path into a String before returning the closure (let path = path.into();), so callers that pass path.display().to_string() (or even a &str) will pay that allocation even when the read succeeds. Consider taking path: impl Display + 'a (or &Path) and constructing the String inside the returned closure so it only allocates on the error path.

    pub fn file_not_found<E: std::fmt::Debug>(path: impl Into<String>) -> impl FnOnce(E) -> Self {
        let path = path.into();
        move |error| Self::FileNotFound {
            path,
            underlying: format!("{error:?}"),

crates/core-invoice/src/models/error.rs:282

• failed_to_ron_serialize_data converts type_name into an owned String before returning the closure (let type_name = type_name.into();), which can move work (and allocation) from the error path to the success path at callsites. If keeping this helper, consider capturing a non-allocating value (e.g. &'static str from std::any::type_name::<T>()) and only allocating/formatting the String inside the closure when serialization actually fails.

    pub fn failed_to_ron_serialize_data<E: std::fmt::Debug>(
        type_name: impl Into<String>,
    ) -> impl FnOnce(E) -> Self {
        let type_name = type_name.into();
        move |error| Self::FailedToRonSerializeData {