saddle-framework 0.3.15

//! The only Saddle crate that business applications directly depend on.
//!
//! Pool construction and Service registry assembly remain framework-owned:
//!
//! ```compile_fail
//! let _ = saddle::db::Database::connect;
//! ```
//!
//! ```compile_fail
//! let _ = saddle::service::ServiceRegistryBuilder::new();
//! ```
//!
//! The old static/three-argument launcher is not a public surface:
//!
//! ```compile_fail
//! let _ = saddle::Saddle::run;
//! ```

mod application;
mod database_capability;
mod database_rows;
mod database_uid;
#[cfg(all(target_arch = "x86_64", target_os = "linux"))]
mod http1;
mod process;
mod profusegw_http;
mod profusegw_response;
mod programming;
mod startup_candidate;
mod testing_harness;

pub use application::ProductionLauncher;
pub use application::SaddleConfig;
pub use application::{
    ApprovedBundleNonceReservation, ApprovedExternalBundle,
    ApprovedExternalBundleApplicabilityFailure, ApprovedExternalBundleSeal,
    ApprovedExternalBundleVerification, ListenerAuthorityProvider, ListenerAuthoritySeal,
    VerifiedListenerAuthority,
};
#[doc(hidden)]
pub use application::{
    GeneratedApplicationBindingError, GeneratedApplicationConsumer, GeneratedApplicationOwner,
    GeneratedApplicationParts, GeneratedApplicationSeal, GeneratedBoundApplicationParts,
    GeneratedProductionBootstrap,
};
/// Framework/Skill assembly handshake. This is not a business API.
#[doc(hidden)]
#[cfg(all(target_arch = "x86_64", target_os = "linux"))]
pub mod internal {
    pub use crate::http1::bootstrap::{
        ApprovedGeneratedHttp1Facts, GeneratedApplicationBootstrap, GeneratedBootstrapError,
        GeneratedBootstrapToken, GeneratedCompiledAdapter, GeneratedContextFactory,
        GeneratedHttp1StaticFacts, GeneratedRoute, generated_bootstrap_type_identity,
        generated_http1_framing_identity,
    };
}

pub use process::{BusinessConfig, ProcessConfig};
pub use saddle_core::{ErrorKind, Result, SaddleError};

// Macro plumbing for `business_types!`. These names are not a supported
// general-purpose protobuf API; generated message implementations require
// exactly this trait/encoding surface.
#[doc(hidden)]
pub use prost::{DecodeError, Message, alloc, bytes, encoding};

#[doc(hidden)]
pub mod __private {
    pub use crate::database_capability::DatabaseRequest;
    pub use crate::database_capability::DatabaseTarget;
    pub use crate::database_capability::GeneratedOwnedWrite;
    pub use crate::database_capability::TransactionSession;
    pub use crate::database_capability::named_write_failure;
    pub use crate::database_capability::{
        GeneratedNamedQuery, GeneratedNamedWrite, GeneratedOffsetPageQuery, GeneratedOwnedQuery,
        GeneratedPageQuery,
    };
    pub use crate::database_capability::{
        transaction_optional, transaction_probe, transaction_rows,
    };
    pub use crate::database_rows::page_filter_fingerprint;
    pub use crate::process::{
        coordinate_profusegw_process, process_bootstrap_error, process_contract_error,
        process_dispatch_error,
    };
    pub use crate::profusegw_http::encode_profusegw_http1;
    pub use crate::profusegw_response::assert_unique_code_registries;
    pub use crate::programming::{
        ProfuseContractDeployment, ProfuseGwDispatchError, decode_accepted_profusegw,
        ingress_matches_contract,
    };
    pub use crate::testing_harness::{accept_test_request, dispatch_error, execution};
    pub use prost;
    pub use prost::Message;
    pub use saddle_boundary::ingress::{AcceptedIngress, ProfuseGwListenerAdapter};
    pub use saddle_core::{BootstrapRendezvousIssuer, GeneratedApplicationFreezeSource};
    pub use saddle_db::internal::{
        LogicalRelation, OwnedQueryKind, QueryOptionalOperationProof, StaticOwnedQuery,
        StaticQueryOptionalOperation, StaticWriteOperation, WriteOperationProof,
    };
    pub use saddle_db::internal::{OwnedWriteProof, StaticOwnedWrite};
    pub use saddle_macros::contract_dir;
    pub use saddle_macros::database_operations;
    pub use serde;
    pub use serde::Serializer;
    pub use serde::{Deserialize, Serialize};
    pub use serde_json;
}

/// Generates typed database operations from logical tables and static bindings.
/// Expansion runs as part of ordinary Cargo compilation; no deployment codegen
/// or business-authored SQL is required.
#[macro_export]
macro_rules! database_operations {
    ($($declarations:tt)*) => {
        $crate::__private::database_operations! { $crate; $($declarations)* }
    };
}

/// Framework-owned typed Database values used by generated application
/// capabilities. No pool, connection, SQL, or transaction boundary is exposed.
pub mod database {
    pub use crate::database_capability::QueryFailure;
    pub use crate::database_rows::{IntoRows, Page, PageCursor, PageRequest, Rows};
    pub use crate::database_uid::{GeneratedParameterError, ParameterFactory};
    pub use saddle_db::internal::OwnedDbList as List;
    pub use saddle_db::internal::ParameterConstructionError;
    pub use saddle_db::internal::TimestampTargetError;
    pub use saddle_db::internal::TransactionIsolation;
    pub use saddle_db::internal::{DbDate as Date, DbTime as Time, DbUtcDatetime as UtcDatetime};
    pub use saddle_db::internal::{DbDecimal as Decimal, DbUuid as Uuid, OwnedDbJson as Json};
    pub use saddle_db::internal::{DbF32 as F32, DbF64 as F64};
    pub type TimestampUtc<const F: usize> = saddle_db::internal::DbTimestamp<F>;
    pub use saddle_db::internal::{OwnedDbBytes as Bytes, OwnedDbText as Text};
    /// Business-visible cardinality of a bounded matching-row probe.
    /// `Many` carries no selected row and does not claim an exact total.
    /// A result says nothing about concurrent uniqueness or transaction isolation.
    pub enum MatchCardinality<Row> {
        Zero,
        One(Row),
        Many,
    }

    pub use saddle_db::internal::{
        DbBool, DbI64, DbPair, DbU64, FixedDbBytes, GuardedQueryRow, ManagedOptionalRow,
        ManagedQueryParameters, ManagedQueryRow, ManagedWriteResult, QueryOptionalExecutionError,
        WriteExecutionError,
    };
    pub use saddle_db::internal::{
        ScopeDatabaseError as DatabaseFailure, ScopeTransactionAbort as TransactionAbort,
        ScopeTransactionFuture as TransactionFuture, ScopeTransactionOutcome as TransactionOutcome,
    };
}

/// Declares application-owned protobuf and JSON carrier types without adding
/// serde or prost as direct application dependencies.
///
/// The macro deliberately exposes only declarations. Encoding, decoding and
/// the test runtime remain controlled by the generated application surface.
#[macro_export]
macro_rules! business_types {
    ($($item:item)*) => {
        #[allow(unused_extern_crates)]
        extern crate saddle as prost;
        #[doc(hidden)]
        mod serde {
            pub use $crate::__private::serde::*;
        }
        #[allow(unused_imports)]
        use $crate::__private::{Deserialize, Message, Serialize};
        $($item)*
    };
}

/// Fixed profusegw handler context.
pub mod ingress {
    pub use crate::profusegw_response::{
        FailureMessage, FailureMessageError, MAX_FAILURE_MESSAGE_BYTES, ProfuseGwCode,
        ProfuseGwFailure, ProfuseGwResponse,
    };
    pub use crate::programming::{
        LdcInfo, MAX_PROFUSE_GW_USER_ID_BYTES, ProfuseGwContext, ProfuseGwDispatchError, TraceInfo,
    };
}

/// Business-facing tests that exercise the same generated Profusegw dispatch.
pub mod testing {
    pub use crate::programming::{
        FakeExecutionCertainty, FakeProfuseContractBoundary, FakeStep, FakeTechnicalCode,
    };
    pub use crate::testing_harness::{
        PROFUSEGW_MEDIA_TYPE, PROFUSEGW_METHOD, PROFUSEGW_PATH, ProfuseGwTestAttempt,
        ProfuseGwTestError, ProfuseGwTestExecution, ProfuseGwTestHarness, ProfuseGwTestRequest,
        TestIngressIdentity,
    };
}

/// Application-facing, strongly typed profusecontract programming surface.
pub mod profusecontract {
    #[doc(hidden)]
    pub use crate::programming::ApplicationContractSeal;
    pub use crate::programming::{
        DeclaredExternalFunctionCall, ExecutionCertainty, ExternalFunctionResult, TechnicalFailure,
        TechnicalFailureCode,
    };

    /// Deterministic alpha.1 consumer harness. Production assembly does not
    /// consume this harness, and Transport's raw boundary types remain hidden.
    pub mod testing {
        pub use crate::programming::{
            FakeApplicationBinding, FakeAttempt, FakeExecutionCertainty,
            FakeProfuseContractBoundary, FakeStep, FakeTechnicalCode,
        };
    }
}

/// The complete stable set of business-owned values accepted by generated
/// Saddle 0.2 handlers.
pub mod managed {
    pub use saddle_db::internal::ManagedWriteResult as WriteResult;
    pub use saddle_service::internal::{
        ManagedBool as Bool, ManagedPair as Pair, ManagedU64 as U64,
    };

    /// A fixed optional value delivered to a `query_optional` handler.
    #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
    pub struct Optional<T>(Option<T>);

    impl<T> Optional<T> {
        #[doc(hidden)]
        pub const fn from_generated(value: Option<T>) -> Self {
            Self(value)
        }

        pub fn into_option(self) -> Option<T> {
            self.0
        }

        pub const fn as_ref(&self) -> Option<&T> {
            self.0.as_ref()
        }
    }
}

/// Declares the sole generated Saddle application in a business crate.
///
/// The Skill emits a private `__saddle_generated` module beside this
/// invocation. Only the generated application marker can move that module's
/// bootstrap owner into the facade.
#[doc(hidden)]
#[macro_export]
macro_rules! __saddle_business_config_type {
    () => {
        ()
    };
    ($business_config:ty) => {
        $business_config
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __saddle_route_capability {
    ($capability:expr, $route:ty) => {
        $capability
    };
    ($capability:expr, $route:ty, $kind:ident) => {
        $capability.__for_route::<$route>()
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __saddle_route_capability_type {
    ($route:ty) => {
        ()
    };
    ($route:ty, $kind:ident) => {
        $route
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __saddle_register_database_operation {
    ($config:expr) => {
        $config
    };
    ($config:expr, query_optional, $operation:ty, $capability:ty) => {
        $config.__register_database_query::<$operation, $capability>()
    };
    ($config:expr, write, $operation:ty, $capability:ty) => {
        $config.__register_database_write::<$operation, $capability>()
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __saddle_register_route_database {
    ($config:expr, locked_rows, ($op:ty), $cap:ty) => {
        $crate::__saddle_register_scoped_operation!($config, rows, $op, $cap)
    };
    ($config:expr, locked_probe, ($op:ty), $cap:ty) => {
        $crate::__saddle_register_scoped_operation!($config, probe, $op, $cap)
    };
    ($config:expr, page, ($op:ty), $cap:ty) => {
        $crate::__saddle_register_route_database!($config, rows, ($op), $cap)
    };
    ($config:expr, rows, ($op:ty), $cap:ty) => {{
        const { assert!(!<$op as $crate::__private::StaticOwnedQuery>::LOCKING, "locking read requires transaction scope"); }
        $config.__register_owned_database_query::<$op, $cap>()
    }};
    ($config:expr, probe, ($op:ty), $cap:ty) => {
        $crate::__saddle_register_route_database!($config, rows, ($op), $cap)
    };
    ($config:expr, optional, ($op:ty), $cap:ty) => {
        $crate::__saddle_register_route_database!($config, rows, ($op), $cap)
    };
    ($config:expr, module, ($module:ident), $cap:ty) => {
        $module::__register::<$cap>($config)
    };
    ($config:expr, operations, {$($kind:ident $method:ident ($op:ty);)+}, $cap:ty) => {{
        let config = $config;
        $(let config = $crate::__saddle_register_route_database!(config, $kind, ($op), $cap);)+
        config
    }};
    ($config:expr, transaction, {$($kind:ident $method:ident ($op:ty);)+}, $cap:ty) => {{
        let config = $config;
        $(let config = $crate::__saddle_register_scoped_operation!(config, $kind, $op, $cap);)+
        config
    }};
    ($config:expr, query_optional, ($op:ty), $cap:ty) => {{
        const { assert!(!<$op as $crate::__private::GeneratedNamedQuery>::REQUIRES_TRANSACTION, "locking read requires transaction scope"); }
        $crate::__saddle_register_database_operation!($config, query_optional, $op, $cap)
    }};
    ($config:expr, write, ($op:ty), $cap:ty) => {
        $crate::__saddle_register_database_operation!($config, write, $op, $cap)
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __saddle_register_scoped_operation {
    ($config:expr, rows, $op:ty, $cap:ty) => {
        $config.__register_scoped_owned_query::<$op, $cap>()
    };
    ($config:expr, probe, $op:ty, $cap:ty) => {
        $config.__register_scoped_owned_query::<$op, $cap>()
    };
    ($config:expr, optional, $op:ty, $cap:ty) => {
        $config.__register_scoped_owned_query::<$op, $cap>()
    };
    ($config:expr, query_optional, $op:ty, $cap:ty) => {
        $config.__register_scoped_query::<$op, $cap>()
    };
    ($config:expr, write, $op:ty, $cap:ty) => {
        $config.__register_scoped_write::<$op, $cap>()
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __saddle_transaction_step {
    ($route:ty, page, $method:ident, $op:ty) => {};
    ($route:ty, locked_rows, $method:ident, $op:ty) => {
        $crate::__saddle_transaction_step!($route, rows, $method, $op);
    };
    ($route:ty, locked_probe, $method:ident, $op:ty) => {
        $crate::__saddle_transaction_step!($route, probe, $method, $op);
    };
    ($route:ty, rows, $method:ident, $op:ty) => {
        impl DatabaseTransaction<'_, '_, '_, $route> {
            pub async fn $method(
                &mut self,
                parameters: <$op as $crate::__private::GeneratedOwnedQuery>::NamedParameters,
            ) -> Result<
                $crate::database::Rows<
                    <$op as $crate::__private::StaticOwnedQuery>::Row,
                    <$op as $crate::__private::GeneratedOwnedQuery>::NamedRow,
                >,
                $crate::database::QueryFailure<
                    <$op as $crate::__private::GeneratedOwnedQuery>::NamedParameters,
                >,
            > {
                if let Err(error) =
                    <$op as $crate::__private::GeneratedOwnedQuery>::validate_parameters(
                        &parameters,
                        &self.__target,
                    )
                {
                    return Err($crate::database::QueryFailure::Target { parameters, error });
                }
                $crate::__private::transaction_rows::<$op>(self.__session, parameters).await
            }
        }
    };
    ($route:ty, optional, $method:ident, $op:ty) => {
        impl DatabaseTransaction<'_, '_, '_, $route> {
            pub async fn $method(
                &mut self,
                parameters: <$op as $crate::__private::GeneratedOwnedQuery>::NamedParameters,
            ) -> Result<
                Option<<$op as $crate::__private::GeneratedOwnedQuery>::NamedRow>,
                $crate::database::QueryFailure<
                    <$op as $crate::__private::GeneratedOwnedQuery>::NamedParameters,
                >,
            > {
                if let Err(error) =
                    <$op as $crate::__private::GeneratedOwnedQuery>::validate_parameters(
                        &parameters,
                        &self.__target,
                    )
                {
                    return Err($crate::database::QueryFailure::Target { parameters, error });
                }
                $crate::__private::transaction_optional::<$op>(self.__session, parameters).await
            }
        }
    };
    ($route:ty, probe, $method:ident, $op:ty) => {
        impl DatabaseTransaction<'_, '_, '_, $route> {
            pub async fn $method(
                &mut self,
                parameters: <$op as $crate::__private::GeneratedOwnedQuery>::NamedParameters,
            ) -> Result<
                $crate::database::MatchCardinality<
                    <$op as $crate::__private::GeneratedOwnedQuery>::NamedRow,
                >,
                $crate::database::QueryFailure<
                    <$op as $crate::__private::GeneratedOwnedQuery>::NamedParameters,
                >,
            > {
                if let Err(error) =
                    <$op as $crate::__private::GeneratedOwnedQuery>::validate_parameters(
                        &parameters,
                        &self.__target,
                    )
                {
                    return Err($crate::database::QueryFailure::Target { parameters, error });
                }
                $crate::__private::transaction_probe::<$op>(self.__session, parameters).await
            }
        }
    };
    ($route:ty, query_optional, $method:ident, $op:ty) => {
        impl DatabaseTransaction<'_, '_, '_, $route> {
            pub async fn $method(
                &mut self,
                parameters: <$op as $crate::__private::GeneratedNamedQuery>::NamedParameters,
            ) -> Result<
                Option<<$op as $crate::__private::GeneratedNamedQuery>::NamedRow>,
                $crate::database::DatabaseFailure,
            > {
                let proof = $crate::__private::QueryOptionalOperationProof::<$op>::bind()
                    .map_err(|_| $crate::database::DatabaseFailure::Mapping)?;
                let row = self
                    .__session
                    .query_optional(proof.invocation(
                        <$op as $crate::__private::GeneratedNamedQuery>::parameters(parameters),
                    ))
                    .await?;
                Ok(<$op as $crate::__private::GeneratedNamedQuery>::row(row))
            }
        }
    };
    ($route:ty, write, $method:ident, $op:ty) => {
        impl DatabaseTransaction<'_, '_, '_, $route> {
            pub async fn $method(
                &mut self,
                parameters: <$op as $crate::__private::GeneratedOwnedWrite>::NamedParameters,
            ) -> Result<
                $crate::database::ManagedWriteResult,
                $crate::database::QueryFailure<
                    <$op as $crate::__private::GeneratedOwnedWrite>::NamedParameters,
                >,
            > {
                let proof = $crate::__private::OwnedWriteProof::<$op>::bind()
                    .map_err($crate::database::QueryFailure::Database)?;
                if let Err(error) =
                    <$op as $crate::__private::GeneratedOwnedWrite>::validate_parameters(
                        &parameters,
                        &self.__target,
                    )
                {
                    return Err($crate::database::QueryFailure::Target { parameters, error });
                }
                self.__session
                    .owned_write(proof.invocation(
                        <$op as $crate::__private::GeneratedOwnedWrite>::parameters(parameters),
                    ))
                    .await
                    .map_err($crate::__private::named_write_failure::<$op>)
            }
        }
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __saddle_route_database_method {
    ($cap:ident, $route:ty, module, $method:ident, ($module:ident)) => {
        impl $cap<$route> {
            pub fn $method(&mut self) -> DatabaseOperations<'_, $module> {
                DatabaseOperations {
                    __request: self.__database.as_mut().expect("generated module route carries its request"),
                    __route: ::core::marker::PhantomData,
                }
            }
        }
    };
    ($cap:ident, $route:ty, operations, $method:ident, {$($kind:ident $step:ident ($op:ty);)+}) => {
        $($crate::__saddle_ordinary_step!($route, $kind, $step, $op);)+
        $($crate::__saddle_transaction_step!($route, $kind, $step, $op);)+
        impl $cap<$route> {
            pub fn $method(&mut self) -> DatabaseOperations<'_, $route> {
                DatabaseOperations {
                    __request: self.__database.as_mut().expect("generated database route carries its request"),
                    __route: ::core::marker::PhantomData,
                }
            }
        }
    };
    ($cap:ident, $route:ty, transaction, $method:ident, {$($kind:ident $step:ident ($op:ty);)+}) => {
        $($crate::__saddle_transaction_step!($route, $kind, $step, $op);)+
        impl $cap<$route> {
            pub async fn $method<T: Send + 'static, E: Send + 'static, B>(&mut self, isolation: $crate::database::TransactionIsolation, body: B)
                -> $crate::database::TransactionOutcome<T, E>
            where B: for<'tx, 's, 'r, 'v> FnOnce(&'tx mut DatabaseTransaction<'v, 's, 'r, $route>)
                -> $crate::database::TransactionFuture<'tx, T, E> + Send + 'static {
                let target=self.__database.as_ref().expect("generated transaction route carries database").target();
                self.__database.as_mut().expect("generated transaction route carries database")
                    .scoped_transaction(isolation, move |session| Box::pin(async move {
                        let mut view = DatabaseTransaction { __session: session, __target:target, __route: ::core::marker::PhantomData };
                        body(&mut view).await
                    })).await
            }
        }
    };
    ($cap:ident, $route:ty, query_optional, $method:ident, ($op:ty)) => {
        $crate::__saddle_database_method!($cap, $route, query_optional, $method, $op);
    };
    ($cap:ident, $route:ty, write, $method:ident, ($op:ty)) => {
        $crate::__saddle_database_method!($cap, $route, write, $method, $op);
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __saddle_database_method {
    ($capability:ident, $route:ty, query_optional, $method:ident, $operation:ty) => {
        impl $capability<$route> {
            pub async fn $method(
                &mut self,
                parameters: <$operation as $crate::__private::StaticQueryOptionalOperation>::Parameters,
            ) -> ::core::result::Result<
                $crate::database::ManagedOptionalRow<<$operation as $crate::__private::StaticQueryOptionalOperation>::Row>,
                $crate::database::DatabaseFailure,
            > {
                self.__database.as_mut().expect("generated DB route carries its request capability")
                    .query_optional::<$operation>(parameters).await
            }
        }
    };
    ($capability:ident, $route:ty, write, $method:ident, $operation:ty) => {
        impl $capability<$route> {
            pub async fn $method(
                &mut self,
                parameters: <$operation as $crate::__private::StaticWriteOperation>::Parameters,
            ) -> ::core::result::Result<$crate::database::ManagedWriteResult, $crate::database::DatabaseFailure> {
                self.__database.as_mut().expect("generated DB route carries its request capability")
                    .write::<$operation>(parameters).await
            }
        }
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __saddle_ordinary_step {
    ($route:ty, locked_rows, $method:ident, $op:ty) => {};
    ($route:ty, locked_probe, $method:ident, $op:ty) => {};
    ($route:ty, page, $method:ident, $op:ty) => {
        impl DatabaseOperations<'_, $route> {
            pub async fn $method(
                &mut self,
                request: $crate::database::PageRequest<$op>,
            ) -> Result<
                $crate::database::Page<$op>,
                $crate::database::QueryFailure<$crate::database::PageRequest<$op>>,
            > {
                self.__request.named_page::<$op>(request).await
            }
        }
    };
    ($route:ty, rows, $method:ident, $op:ty) => {
        impl DatabaseOperations<'_, $route> {
            pub async fn $method(
                &mut self,
                parameters: <$op as $crate::__private::GeneratedOwnedQuery>::NamedParameters,
            ) -> Result<
                $crate::database::Rows<
                    <$op as $crate::__private::StaticOwnedQuery>::Row,
                    <$op as $crate::__private::GeneratedOwnedQuery>::NamedRow,
                >,
                $crate::database::QueryFailure<
                    <$op as $crate::__private::GeneratedOwnedQuery>::NamedParameters,
                >,
            > {
                self.__request.named_rows::<$op>(parameters).await
            }
        }
    };
    ($route:ty, probe, $method:ident, $op:ty) => {
        impl DatabaseOperations<'_, $route> {
            pub async fn $method(
                &mut self,
                parameters: <$op as $crate::__private::GeneratedOwnedQuery>::NamedParameters,
            ) -> Result<
                $crate::database::MatchCardinality<
                    <$op as $crate::__private::GeneratedOwnedQuery>::NamedRow,
                >,
                $crate::database::QueryFailure<
                    <$op as $crate::__private::GeneratedOwnedQuery>::NamedParameters,
                >,
            > {
                self.__request.named_probe::<$op>(parameters).await
            }
        }
    };
    ($route:ty, optional, $method:ident, $op:ty) => {
        impl DatabaseOperations<'_, $route> {
            pub async fn $method(
                &mut self,
                parameters: <$op as $crate::__private::GeneratedOwnedQuery>::NamedParameters,
            ) -> Result<
                Option<<$op as $crate::__private::GeneratedOwnedQuery>::NamedRow>,
                $crate::database::QueryFailure<
                    <$op as $crate::__private::GeneratedOwnedQuery>::NamedParameters,
                >,
            > {
                self.__request.named_optional::<$op>(parameters).await
            }
        }
    };
    ($route:ty, query_optional, $method:ident, $op:ty) => {
        impl DatabaseOperations<'_, $route> {
            pub async fn $method(
                &mut self,
                parameters: <$op as $crate::__private::GeneratedNamedQuery>::NamedParameters,
            ) -> Result<
                Option<<$op as $crate::__private::GeneratedNamedQuery>::NamedRow>,
                $crate::database::DatabaseFailure,
            > {
                let row = self
                    .__request
                    .query_optional::<$op>(
                        <$op as $crate::__private::GeneratedNamedQuery>::parameters(parameters),
                    )
                    .await?;
                Ok(<$op as $crate::__private::GeneratedNamedQuery>::row(row))
            }
        }
    };
    ($route:ty, write, $method:ident, $op:ty) => {
        impl DatabaseOperations<'_, $route> {
            pub async fn $method(
                &mut self,
                parameters: <$op as $crate::__private::GeneratedOwnedWrite>::NamedParameters,
            ) -> Result<
                $crate::database::ManagedWriteResult,
                $crate::database::QueryFailure<
                    <$op as $crate::__private::GeneratedOwnedWrite>::NamedParameters,
                >,
            > {
                self.__request.named_write::<$op>(parameters).await
            }
        }
    };
}

#[macro_export]
macro_rules! application {
    (
        schema "saddle-application/1";
        application $application:ident;
        $($declaration:tt)*
    ) => {
        pub struct $application;

    };
    (
        schema "saddle-application/2";
        application $application:ident;
        deployment_app $deployment_app:literal;
        business_config $business_config:ty;
        profusecontract {
            contract_dir $contract_dir:literal;
            capability $capability:ident;
            response_code $result_code:ty;
            functions {
                $(
                    $function:ident => $method:ident {
                        business_unit $business_unit:literal;
                        function $function_name:literal;
                    } (
                        $function_request:ty
                    ) -> $function_result:ty;
                )*
            }
        }
        $(database_modules {
            $($db_module:ident { $($module_kind:ident $module_method:ident ($module_op:ty);)+ })+
        })?
        $(
            service $service:ident {
                ingress profusegw;
                operation_type $operation_type:literal;
                request $request:ty;
                response $response:ty;
                handler $handler:path;
                $(uses $uses:ident;)*
                $(database $db_kind:ident $db_method:ident $db_spec:tt $(;)? )?
            }
        )+
    ) => {
        const __SADDLE_ONLY_APPLICATION: () = ();
        $crate::__private::contract_dir!(
            $contract_dir;
            declarations {
                $(($function, $business_unit, $function_name, $function_request, $function_result);)*
            }
            uses {
                $($($uses;)*)+
            }
        );

        pub struct $application;

        trait __SaddleDeclaredExternalFunction {}

        pub struct DatabaseTransaction<'tx, 'session, 'request, R> {
            __session: &'tx mut $crate::__private::TransactionSession<'session, 'request>,
            __target: $crate::__private::DatabaseTarget,
            __route: ::core::marker::PhantomData<fn() -> R>,
        }

        pub struct DatabaseOperations<'request, R> {
            __request: &'request mut $crate::__private::DatabaseRequest,
            __route: ::core::marker::PhantomData<fn() -> R>,
        }
        impl<R> DatabaseOperations<'_,R> {
            pub fn parameters(&mut self)->$crate::database::ParameterFactory<'_> {
                self.__request.parameter_factory()
            }
            pub async fn transaction<T: Send + 'static, E: Send + 'static, B>(&mut self, isolation: $crate::database::TransactionIsolation, body: B)
                -> $crate::database::TransactionOutcome<T,E>
            where R:'static, B: for<'tx,'s,'r,'v> FnOnce(&'tx mut DatabaseTransaction<'v,'s,'r,R>)
                -> $crate::database::TransactionFuture<'tx,T,E> + Send + 'static {
                let target=self.__request.target();
                self.__request.scoped_transaction(isolation, move |session| Box::pin(async move {
                    let mut view=DatabaseTransaction{__session:session,__target:target,__route: ::core::marker::PhantomData};
                    body(&mut view).await
                })).await
            }
            pub async fn i8s(&mut self, source:&[i8])->Result<$crate::database::List<i8>,$crate::database::ParameterConstructionError> {self.__request.parameter_i8s(source).await}
            pub async fn optional_i8s(&mut self, source:&[Option<i8>])->Result<$crate::database::List<Option<i8>>,$crate::database::ParameterConstructionError> {self.__request.parameter_optional_i8s(source).await}
            pub async fn i16s(&mut self, source:&[i16])->Result<$crate::database::List<i16>,$crate::database::ParameterConstructionError> {self.__request.parameter_i16s(source).await}
            pub async fn optional_i16s(&mut self, source:&[Option<i16>])->Result<$crate::database::List<Option<i16>>,$crate::database::ParameterConstructionError> {self.__request.parameter_optional_i16s(source).await}
            pub async fn i32s(&mut self, source:&[i32])->Result<$crate::database::List<i32>,$crate::database::ParameterConstructionError> {self.__request.parameter_i32s(source).await}
            pub async fn optional_i32s(&mut self, source:&[Option<i32>])->Result<$crate::database::List<Option<i32>>,$crate::database::ParameterConstructionError> {self.__request.parameter_optional_i32s(source).await}
            pub async fn i64s(&mut self, source:&[i64])->Result<$crate::database::List<i64>,$crate::database::ParameterConstructionError> {self.__request.parameter_i64s(source).await}
            pub async fn optional_i64s(&mut self, source:&[Option<i64>])->Result<$crate::database::List<Option<i64>>,$crate::database::ParameterConstructionError> {self.__request.parameter_optional_i64s(source).await}
            pub async fn u8s(&mut self, source:&[u8])->Result<$crate::database::List<u8>,$crate::database::ParameterConstructionError> {self.__request.parameter_u8s(source).await}
            pub async fn optional_u8s(&mut self, source:&[Option<u8>])->Result<$crate::database::List<Option<u8>>,$crate::database::ParameterConstructionError> {self.__request.parameter_optional_u8s(source).await}
            pub async fn u16s(&mut self, source:&[u16])->Result<$crate::database::List<u16>,$crate::database::ParameterConstructionError> {self.__request.parameter_u16s(source).await}
            pub async fn optional_u16s(&mut self, source:&[Option<u16>])->Result<$crate::database::List<Option<u16>>,$crate::database::ParameterConstructionError> {self.__request.parameter_optional_u16s(source).await}
            pub async fn u32s(&mut self, source:&[u32])->Result<$crate::database::List<u32>,$crate::database::ParameterConstructionError> {self.__request.parameter_u32s(source).await}
            pub async fn optional_u32s(&mut self, source:&[Option<u32>])->Result<$crate::database::List<Option<u32>>,$crate::database::ParameterConstructionError> {self.__request.parameter_optional_u32s(source).await}
            pub async fn u64s(&mut self, source:&[u64])->Result<$crate::database::List<u64>,$crate::database::ParameterConstructionError> {self.__request.parameter_u64s(source).await}
            pub async fn optional_u64s(&mut self, source:&[Option<u64>])->Result<$crate::database::List<Option<u64>>,$crate::database::ParameterConstructionError> {self.__request.parameter_optional_u64s(source).await}
            pub async fn bools(&mut self, source:&[bool])->Result<$crate::database::List<bool>,$crate::database::ParameterConstructionError> {self.__request.parameter_bools(source).await}
            pub async fn optional_bools(&mut self, source:&[Option<bool>])->Result<$crate::database::List<Option<bool>>,$crate::database::ParameterConstructionError> {self.__request.parameter_optional_bools(source).await}
            pub async fn json(&mut self, source:&str)->Result<$crate::database::Json,$crate::database::ParameterConstructionError> {self.__request.parameter_json(source).await}
            pub async fn text(&mut self, source:&str)->Result<$crate::database::Text,$crate::database::ParameterConstructionError> {self.__request.parameter_text(source).await}
            pub async fn bytes(&mut self, source:&[u8])->Result<$crate::database::Bytes,$crate::database::ParameterConstructionError> {self.__request.parameter_bytes(source).await}
            pub async fn texts(&mut self, source:&[Option<&str>])->Result<$crate::database::List<Option<$crate::database::Text>>,$crate::database::ParameterConstructionError> {self.__request.parameter_texts(source).await}
            pub async fn byte_list(&mut self, source:&[Option<&[u8]>])->Result<$crate::database::List<Option<$crate::database::Bytes>>,$crate::database::ParameterConstructionError> {self.__request.parameter_byte_list(source).await}
        }

        $($(
            pub struct $db_module;
            impl $db_module {
                fn __register<C>(config: $crate::ProcessConfig<$business_config>) -> $crate::ProcessConfig<$business_config> {
                    $(let config = $crate::__saddle_register_route_database!(config, $module_kind, ($module_op), C);)+
                    config
                }
            }
            $($crate::__saddle_ordinary_step!($db_module, $module_kind, $module_method, $module_op);)+
            $($crate::__saddle_transaction_step!($db_module, $module_kind, $module_method, $module_op);)+
        )+)?

        $(
            pub struct $function;
            impl __SaddleDeclaredExternalFunction for $function {}
        )*

        pub struct $capability<__Route = ()> {
            __seal: $crate::profusecontract::ApplicationContractSeal,
            __database: ::core::option::Option<$crate::__private::DatabaseRequest>,
            __route: ::core::marker::PhantomData<fn() -> __Route>,
        }

        impl<__Route> $capability<__Route> {
            #[doc(hidden)]
            pub fn __from_framework(
                seal: $crate::profusecontract::ApplicationContractSeal,
            ) -> Self {
                Self { __seal: seal, __database: None, __route: ::core::marker::PhantomData }
            }

            #[doc(hidden)]
            pub fn __from_framework_database(
                seal: $crate::profusecontract::ApplicationContractSeal,
                database: $crate::__private::DatabaseRequest,
            ) -> Self {
                Self { __seal: seal, __database: Some(database), __route: ::core::marker::PhantomData }
            }

            fn __for_route<__Next>(self) -> $capability<__Next> {
                $capability {
                    __seal: self.__seal,
                    __database: self.__database,
                    __route: ::core::marker::PhantomData,
                }
            }

            $(
                pub fn $method(
                    &self,
                    request: $function_request,
                ) -> $crate::profusecontract::DeclaredExternalFunctionCall<
                    $application,
                    $function,
                    $function_request,
                    $function_result,
                > {
                    $crate::profusecontract::DeclaredExternalFunctionCall::from_declared(
                        request,
                        &self.__seal,
                        $business_unit,
                        $function_name,
                    )
                    .with_database_request(self.__database.as_ref())
                }
            )*
        }

        impl $application {
            pub const PROFUSECONTRACT_DIR: &'static str = $contract_dir;

            #[doc(hidden)]
            pub const __PROFUSECONTRACT_DESCRIPTOR: &'static [u8] =
                __SADDLE_CONTRACT_DESCRIPTOR;

            /// Starts the sole generated application process. Configuration,
            /// listener, Runtime and shutdown ownership remain in the facade.
            pub fn run() -> $crate::Result<()> {
                let (application_half, listener_issuer) =
                    $crate::__private::BootstrapRendezvousIssuer::issue()
                        .freeze_application(
                            $crate::__private::GeneratedApplicationFreezeSource::new(
                                $deployment_app,
                                Self::__PROFUSECONTRACT_DESCRIPTOR,
                                &[
                                    $(concat!(
                                        $operation_type,
                                        "|",
                                        stringify!($request),
                                        "|",
                                        stringify!($response),
                                        "|",
                                        stringify!($handler)
                                    ),)+
                                ],
                            ),
                        )
                        .map_err(|_| $crate::__private::process_bootstrap_error())?;
                let config = $crate::ProcessConfig::<$business_config>::from_args()?;
                $(
                    $(let config = $crate::__saddle_register_route_database!(config, $db_kind, $db_spec, $capability);)?
                )+
                $crate::__private::coordinate_profusegw_process(
                    config,
                    Self::__profusegw_listener_adapter(),
                    application_half,
                    listener_issuer,
                    |authority_template| async move {
                        Ok($crate::__private::ProfuseContractDeployment::routed(
                            authority_template,
                        ))
                    },
                    |accepted, deployment, _business, database| async move {
                        let encoding=database.response_encoding_context();
                        let capability = Self::__bind_profusecontract(&deployment, &accepted, database);
                        let response=Self::__dispatch_accepted_profusegw(
                            accepted,
                            capability,
                            _business,
                        )
                            .await
                            .map_err(|_| $crate::__private::process_dispatch_error())?;
                        encoding.encode(move || response.__encode_profusegw_http1().map_err(|_| $crate::__private::process_dispatch_error())).await
                    },
                )
            }

            /// Resolves the MobileGW operation name against the sole static
            /// application graph. Business handlers never perform dispatch.
            pub fn dispatch_profusegw_operation(
                operation_type: &str,
            ) -> Option<ProfuseGwDispatch> {
                match operation_type {
                    $(
                        $operation_type => Some(ProfuseGwDispatch::$service),
                    )+
                    _ => None,
                }
            }

            #[doc(hidden)]
            pub fn __profusegw_listener_adapter(
            ) -> $crate::__private::ProfuseGwListenerAdapter {
                $crate::__private::ProfuseGwListenerAdapter::new($deployment_app)
                    .expect("generated deployment application identity is valid")
            }

            #[doc(hidden)]
            pub fn __bind_profusecontract(
                deployment: &$crate::__private::ProfuseContractDeployment,
                accepted: &$crate::__private::AcceptedIngress,
                database: $crate::__private::DatabaseRequest,
            ) -> $capability {
                $capability::__from_framework_database(deployment.bind_accepted(accepted), database)
            }

            /// Runs the generated Profusegw ingress and handler graph through
            /// the controlled framework fake without exposing hidden ingress.
            pub fn profusegw_test_harness(
                fake: $crate::testing::FakeProfuseContractBoundary,
                business: $crate::BusinessConfig<$business_config>,
            ) -> $crate::testing::ProfuseGwTestHarness<ProfuseGwResponse> {
                $crate::testing::ProfuseGwTestHarness::from_executor(move |request| {
                    ::std::boxed::Box::pin(async move {
                        let observed = fake.clone();
                        let accepted = $crate::__private::accept_test_request(
                            &Self::__profusegw_listener_adapter(),
                            request,
                        )?;
                        let binding = fake
                            .bind_accepted(&accepted)
                            .map_err($crate::__private::dispatch_error)?;
                        let response = Self::__dispatch_accepted_profusegw(
                            accepted,
                            $capability::__from_framework(binding.into_contract_seal()),
                            business.clone(),
                        )
                        .await
                        .map_err($crate::__private::dispatch_error)?;
                        Ok($crate::__private::execution(response, &observed))
                    })
                })
            }

            #[doc(hidden)]
            pub async fn __dispatch_accepted_profusegw(
                accepted: $crate::__private::AcceptedIngress,
                contract: $capability,
                business: $crate::BusinessConfig<$business_config>,
            ) -> ::core::result::Result<ProfuseGwResponse, $crate::__private::ProfuseGwDispatchError> {
                if !$crate::__private::ingress_matches_contract(&accepted, &contract.__seal) {
                    return Err($crate::__private::ProfuseGwDispatchError::IdentityMismatch);
                }
                match accepted.interface_id.as_str() {
                    $(
                        $operation_type => {
                            let (request, context) =
                                $crate::__private::decode_accepted_profusegw::<$request>(accepted)?;
                            let contract = $crate::__saddle_route_capability!(
                                contract,
                                $service
                                $(, $db_kind)?
                            );
                            Ok(ProfuseGwResponse::$service(
                                $handler(request, context, contract, business.clone()).await,
                            ))
                        }
                    )+
                    _ => Err($crate::__private::ProfuseGwDispatchError::InterfaceNotFound),
                }
            }
        }

        pub enum ProfuseGwResponse {
            $($service($crate::ingress::ProfuseGwResponse<$response, $result_code>)),+
        }

        impl $crate::__private::Serialize for ProfuseGwResponse {
            fn serialize<S>(&self, serializer: S) -> ::core::result::Result<S::Ok, S::Error>
            where
                S: $crate::__private::Serializer,
            {
                match self {
                    $(Self::$service(response) => $crate::__private::Serialize::serialize(response, serializer)),+
                }
            }
        }

        impl ProfuseGwResponse {
            /// The sole production HTTP adapter projection. The core response
            /// remains transport-independent and supplies only `Serialize`.
            #[doc(hidden)]
            pub fn __encode_profusegw_http1(
                &self,
            ) -> ::core::result::Result<
                ::std::vec::Vec<u8>,
                $crate::__private::serde_json::Error,
            > {
                match self {
                    $(Self::$service(response) => $crate::__private::encode_profusegw_http1(response)),+
                }
            }
        }

        const _: () = $crate::__private::assert_unique_code_registries(&[
            <$result_code as $crate::ingress::ProfuseGwCode>::REGISTERED_CODES,
        ]);

        #[derive(Clone, Copy, Debug, Eq, PartialEq)]
        pub enum ProfuseGwDispatch {
            $($service),+
        }

        $(
            pub struct $service;
            $($crate::__saddle_route_database_method!($capability, $service, $db_kind, $db_method, $db_spec);)?
            impl $service {
                pub const OPERATION_TYPE: &'static str = $operation_type;
            }

            const _: fn() = || {
                fn handler_shape<F, Fut>(_: F)
                where
                    F: Fn(
                        $request,
                        $crate::ingress::ProfuseGwContext,
                        $capability<$crate::__saddle_route_capability_type!($service $(, $db_kind)?)>,
                        $crate::BusinessConfig<$business_config>,
                    ) -> Fut,
                    Fut: ::core::future::Future<
                        Output = $crate::ingress::ProfuseGwResponse<$response, $result_code>,
                    >,
                {}
                handler_shape($handler);

                fn declared_use<F>()
                where
                    F: __SaddleDeclaredExternalFunction,
                {}
                $(declared_use::<$uses>();)*
            };
        )+
    };
    ($($invalid:tt)*) => {
        compile_error!("skill.schema.unsupported");
    };
}