@antprofuse/saddle-skill 0.2.0 → 0.3.0-alpha.2

package/assets/registry-consumer/src/generated_artifact.rs

@@ -1,858 +0,0 @@
-//! Registry-only consumer template: generator-owned private artifact.
-
-use core::future::Future;
-
-use saddle::internal::{
-    GeneratedApplicationBootstrap, GeneratedBootstrapError, GeneratedBootstrapToken,
-    GeneratedCompiledAdapter, GeneratedContextFactory, GeneratedHttp1StaticFacts,
-    generated_bootstrap_type_identity, generated_http1_framing_identity,
-};
-use saddle::{
-    ApprovedExternalBundle, GeneratedApplicationConsumer, GeneratedApplicationOwner,
-    GeneratedApplicationSeal, ProductionLauncher,
-};
-use saddle_admission::{
-    ManagedBytes, ManagedResponse, ManagedResponseBuilder, ServiceCapacitySourceLeaf,
-};
-use saddle_db::Database;
-use saddle_db::internal::{
-    DbBool, DbPair, DbU64, ManagedQueryParameters, ManagedQueryRow, QueryOptionalCreditDemand,
-    QueryOptionalExecutionError, QueryOptionalOperationProof, StaticQueryOptionalOperation,
-    StaticWriteOperation, TransactionDecision, TransactionExecutionError,
-    TransactionOperationProof, WriteCreditDemand, WriteExecutionError, WriteOperationProof,
-    write_transaction_finalization_proof,
-};
-use saddle_service::internal::{
-    CompiledDbPermit, CompiledExecutionBuilder, CompiledRouteExecutionProof,
-    CompiledServiceRegistry, CompiledServiceRegistryBuilder, EntryCapabilityLimits, EntryFraming,
-    ExecutionError, ExecutionLayoutProof, FixedManagedCodec, GeneratedServiceCapacityArtifactOwner,
-    InternalCallCapability, ManagedBool, ManagedCodec, ManagedPair, ManagedU64, ManagedValue,
-};
-use saddle_service::{Service, ServiceDescriptor};
-
-const BODY_BYTES: usize = 32;
-const OUTPUT_BYTES: usize = 64;
-const SERVICE_COUNT: usize = 6;
-const ROUTE_BYTES: usize = 128;
-const LOOKUP_USER_ORDINAL: usize = 0;
-const CREATE_ORDER_ORDINAL: usize = 1;
-const HEALTH_ORDINAL: usize = 2;
-const LINK_USER_ORDINAL: usize = 3;
-const TRANSFER_COMMIT_ORDINAL: usize = 4;
-const TRANSFER_ROLLBACK_ORDINAL: usize = 5;
-const OWNER_GENERATION: u64 = 1;
-const BUILD_IDENTITY: [u8; 32] = [0xb2; 32];
-const ARTIFACT_IDENTITY: [u8; 32] = [0xa2; 32];
-
-struct LookupUser;
-
-impl Service for LookupUser {
-    type Request = ManagedU64;
-    type Response = ManagedPair<ManagedU64, ManagedBool>;
-}
-
-struct CreateOrder;
-
-impl Service for CreateOrder {
-    type Request = ManagedPair<ManagedU64, ManagedU64>;
-    type Response = ManagedPair<ManagedU64, ManagedU64>;
-}
-
-struct Health;
-
-impl Service for Health {
-    type Request = ManagedU64;
-    type Response = ManagedU64;
-}
-
-struct LinkUserToOrderRoute;
-struct TransferOrderOwnerCommitRoute;
-struct TransferOrderOwnerRollbackRoute;
-
-type MutationRequest = ManagedPair<ManagedU64, ManagedU64>;
-type MutationResponse = ManagedPair<ManagedU64, ManagedU64>;
-
-impl Service for LinkUserToOrderRoute {
-    type Request = MutationRequest;
-    type Response = MutationResponse;
-}
-
-impl Service for TransferOrderOwnerCommitRoute {
-    type Request = MutationRequest;
-    type Response = MutationResponse;
-}
-
-impl Service for TransferOrderOwnerRollbackRoute {
-    type Request = MutationRequest;
-    type Response = MutationResponse;
-}
-
-type UserCodec =
-    FixedManagedCodec<<LookupUser as Service>::Request, <LookupUser as Service>::Response>;
-type OrderCodec =
-    FixedManagedCodec<<CreateOrder as Service>::Request, <CreateOrder as Service>::Response>;
-type HealthCodec = FixedManagedCodec<<Health as Service>::Request, <Health as Service>::Response>;
-type MutationCodec = FixedManagedCodec<MutationRequest, MutationResponse>;
-type CreateOrderToLookupUser = InternalCallCapability<CreateOrder, LookupUser>;
-
-struct FindUserOptional;
-
-impl StaticQueryOptionalOperation for FindUserOptional {
-    type Parameters = ManagedQueryParameters<DbU64>;
-    type Row = ManagedQueryRow<DbPair<DbU64, DbBool>>;
-
-    const OPERATION: &'static str = "users.find_optional";
-    const SQL: &'static str = "SELECT id, active FROM users WHERE id = ?";
-}
-
-struct FindOrderOptional;
-
-impl StaticQueryOptionalOperation for FindOrderOptional {
-    type Parameters = ManagedQueryParameters<DbU64>;
-    type Row = ManagedQueryRow<DbPair<DbU64, DbU64>>;
-
-    const OPERATION: &'static str = "orders.find_optional";
-    const SQL: &'static str = "SELECT id, amount FROM orders WHERE id = ?";
-}
-
-struct LinkUserToOrder;
-
-impl StaticWriteOperation for LinkUserToOrder {
-    type Parameters = ManagedQueryParameters<DbPair<DbU64, DbU64>>;
-
-    const OPERATION: &'static str = "user.link_order";
-    const SQL: &'static str = "UPDATE users SET order_id = ? WHERE id = ?";
-}
-
-struct TransferOrderOwner;
-
-impl StaticWriteOperation for TransferOrderOwner {
-    type Parameters = ManagedQueryParameters<DbPair<DbU64, DbU64>>;
-
-    const OPERATION: &'static str = "order.transfer_owner";
-    const SQL: &'static str = "UPDATE orders SET user_id = ? WHERE id = ?";
-}
-
-async fn lookup_user(
-    request: <LookupUser as Service>::Request,
-) -> Result<<LookupUser as Service>::Response, ExecutionError> {
-    core::future::ready(()).await;
-    Ok(ManagedPair(request, ManagedBool(true)))
-}
-
-async fn create_order(
-    request: <CreateOrder as Service>::Request,
-) -> Result<<CreateOrder as Service>::Response, ExecutionError> {
-    core::future::ready(()).await;
-    Ok(request)
-}
-
-async fn health(
-    request: <Health as Service>::Request,
-) -> Result<<Health as Service>::Response, ExecutionError> {
-    core::future::ready(()).await;
-    Ok(request)
-}
-
-async fn mutate(request: MutationRequest) -> Result<MutationResponse, ExecutionError> {
-    core::future::ready(()).await;
-    Ok(request)
-}
-
-fn bind_handler_layout<S, Request, Response, Codec, Handler, HandlerFuture>(
-    handler: Handler,
-) -> Result<ExecutionLayoutProof, ExecutionError>
-where
-    S: Service<Request = Request, Response = Response>,
-    Request: ManagedValue,
-    Response: ManagedValue,
-    Codec: ManagedCodec<Request, Response>,
-    Handler: FnOnce(Request) -> HandlerFuture,
-    HandlerFuture: Future<Output = Result<Response, ExecutionError>> + Send + 'static,
-{
-    let _ = handler;
-    ExecutionLayoutProof::bind::<S, BODY_BYTES, OUTPUT_BYTES, Request, Response, Codec, HandlerFuture>(
-    )
-}
-
-fn handler_layout(ordinal: usize) -> Option<ExecutionLayoutProof> {
-    match ordinal {
-        LOOKUP_USER_ORDINAL => {
-            bind_handler_layout::<LookupUser, _, _, UserCodec, _, _>(lookup_user).ok()
-        }
-        CREATE_ORDER_ORDINAL => {
-            bind_handler_layout::<CreateOrder, _, _, OrderCodec, _, _>(create_order).ok()
-        }
-        HEALTH_ORDINAL => bind_handler_layout::<Health, _, _, HealthCodec, _, _>(health).ok(),
-        LINK_USER_ORDINAL => {
-            bind_handler_layout::<LinkUserToOrderRoute, _, _, MutationCodec, _, _>(mutate).ok()
-        }
-        TRANSFER_COMMIT_ORDINAL => {
-            bind_handler_layout::<TransferOrderOwnerCommitRoute, _, _, MutationCodec, _, _>(mutate)
-                .ok()
-        }
-        TRANSFER_ROLLBACK_ORDINAL => {
-            bind_handler_layout::<TransferOrderOwnerRollbackRoute, _, _, MutationCodec, _, _>(
-                mutate,
-            )
-            .ok()
-        }
-        _ => None,
-    }
-}
-
-fn layout(ordinal: usize) -> Option<CompiledRouteExecutionProof> {
-    match ordinal {
-        LOOKUP_USER_ORDINAL => Some(
-            handler_layout(ordinal)?
-                .with_query_optional(QueryOptionalOperationProof::<FindUserOptional>::bind().ok()?),
-        ),
-        CREATE_ORDER_ORDINAL => {
-            Some(handler_layout(ordinal)?.with_query_optional(
-                QueryOptionalOperationProof::<FindOrderOptional>::bind().ok()?,
-            ))
-        }
-        HEALTH_ORDINAL => Some(handler_layout(ordinal)?.without_db()),
-        LINK_USER_ORDINAL => Some(
-            handler_layout(ordinal)?
-                .with_write(WriteOperationProof::<LinkUserToOrder>::bind().ok()?),
-        ),
-        TRANSFER_COMMIT_ORDINAL | TRANSFER_ROLLBACK_ORDINAL => Some(
-            handler_layout(ordinal)?
-                .with_transaction(TransactionOperationProof::<TransferOrderOwner>::bind().ok()?),
-        ),
-        _ => None,
-    }
-}
-
-fn compiled_registry() -> CompiledServiceRegistry {
-    let mut registry =
-        CompiledServiceRegistryBuilder::new(SERVICE_COUNT).expect("bounded generated registry");
-    registry
-        .register::<LookupUser>(ServiceDescriptor::new("users", "user", "lookup"))
-        .expect("generated user marker");
-    registry
-        .register::<CreateOrder>(ServiceDescriptor::new("orders", "order", "create"))
-        .expect("generated order marker");
-    registry
-        .register::<Health>(ServiceDescriptor::new("system", "health", "check"))
-        .expect("generated no-DB marker");
-    registry
-        .register::<LinkUserToOrderRoute>(ServiceDescriptor::new("users", "user", "link_order"))
-        .expect("generated standalone write marker");
-    registry
-        .register::<TransferOrderOwnerCommitRoute>(ServiceDescriptor::new(
-            "orders",
-            "order",
-            "transfer_owner_commit",
-        ))
-        .expect("generated transaction commit marker");
-    registry
-        .register::<TransferOrderOwnerRollbackRoute>(ServiceDescriptor::new(
-            "orders",
-            "order",
-            "transfer_owner_rollback",
-        ))
-        .expect("generated transaction rollback marker");
-    registry.freeze().expect("generated registry")
-}
-
-pub(crate) struct GeneratedRequestContext {
-    database: Database,
-    cancel: saddle_admission::RequestCancelFuture,
-    shutdown: saddle_admission::RequestShutdownFuture,
-}
-
-pub(crate) struct GeneratedRequestContextFactory;
-
-impl GeneratedContextFactory<GeneratedRequestContext> for GeneratedRequestContextFactory {
-    fn make_context(
-        &self,
-        memory: &saddle_admission::RequestMemory,
-        database: Option<&Database>,
-    ) -> GeneratedRequestContext {
-        GeneratedRequestContext {
-            database: database.expect("DB route has a managed database").clone(),
-            cancel: memory
-                .cancel_requested()
-                .expect("accepted generated request owns its cancel signal"),
-            shutdown: memory
-                .shutdown_requested()
-                .expect("accepted generated request owns its shutdown signal"),
-        }
-    }
-}
-
-fn decode_u64(body: &[u8]) -> Result<ManagedU64, ExecutionError> {
-    let bytes: [u8; 8] = body
-        .get(..8)
-        .ok_or(ExecutionError::InvalidInput)?
-        .try_into()
-        .map_err(|_| ExecutionError::InvalidInput)?;
-    Ok(ManagedU64(u64::from_le_bytes(bytes)))
-}
-
-fn encode_pair(
-    output: &mut ManagedResponseBuilder,
-    first: ManagedU64,
-    second: ManagedU64,
-) -> Result<(), ExecutionError> {
-    output
-        .try_extend_from_slice(&first.0.to_le_bytes())
-        .map_err(|_| ExecutionError::OutputTooLarge)?;
-    output
-        .try_extend_from_slice(&second.0.to_le_bytes())
-        .map_err(|_| ExecutionError::OutputTooLarge)
-}
-
-#[allow(clippy::manual_async_fn)]
-fn dispatch(
-    ordinal: usize,
-    context: GeneratedRequestContext,
-    body: ManagedBytes,
-    db: CompiledDbPermit,
-    mut output: ManagedResponseBuilder,
-) -> impl Future<Output = Result<ManagedResponse, ExecutionError>> + Send + 'static + use<> {
-    let decoded = match ordinal {
-        LOOKUP_USER_ORDINAL | HEALTH_ORDINAL => {
-            decode_u64(body.as_slice()).map(|first| (first, None))
-        }
-        CREATE_ORDER_ORDINAL
-        | LINK_USER_ORDINAL
-        | TRANSFER_COMMIT_ORDINAL
-        | TRANSFER_ROLLBACK_ORDINAL => decode_u64(body.as_slice()).and_then(|first| {
-            decode_u64(
-                body.as_slice()
-                    .get(8..)
-                    .ok_or(ExecutionError::InvalidInput)?,
-            )
-            .map(|second| (first, Some(second)))
-        }),
-        _ => Err(ExecutionError::UnknownExecution),
-    };
-    drop(body);
-
-    async move {
-        let GeneratedRequestContext {
-            database,
-            cancel,
-            shutdown,
-        } = context;
-        let (first, second) = decoded?;
-        match (ordinal, second) {
-            (LOOKUP_USER_ORDINAL, None) => {
-                let invocation = QueryOptionalOperationProof::<FindUserOptional>::bind()
-                    .map_err(|_| ExecutionError::Business)?
-                    .invocation(ManagedQueryParameters(DbU64(first.0)));
-                let execution = db.handoff_query_optional(invocation)?;
-                let row = database
-                    .execute_query_optional(execution, cancel, shutdown)
-                    .await
-                    .map_err(map_query_error)?
-                    .into_option()
-                    .ok_or(ExecutionError::Business)?;
-                let ManagedQueryRow(DbPair(id, active)) = row;
-                let response = lookup_user(ManagedU64(id.0)).await?;
-                encode_pair(&mut output, response.0, ManagedU64(u64::from(active.0)))?;
-            }
-            (CREATE_ORDER_ORDINAL, Some(_second)) => {
-                let invocation = QueryOptionalOperationProof::<FindOrderOptional>::bind()
-                    .map_err(|_| ExecutionError::Business)?
-                    .invocation(ManagedQueryParameters(DbU64(first.0)));
-                let execution = db.handoff_query_optional(invocation)?;
-                let row = database
-                    .execute_query_optional(execution, cancel, shutdown)
-                    .await
-                    .map_err(map_query_error)?
-                    .into_option()
-                    .ok_or(ExecutionError::Business)?;
-                let ManagedQueryRow(DbPair(id, amount)) = row;
-                let response =
-                    create_order(ManagedPair(ManagedU64(id.0), ManagedU64(amount.0))).await?;
-                encode_pair(&mut output, response.0, response.1)?;
-            }
-            (HEALTH_ORDINAL, None) => {
-                if !db.is_none() {
-                    return Err(ExecutionError::InvalidInput);
-                }
-                let response = health(first).await?;
-                encode_pair(&mut output, response, ManagedU64(0))?;
-            }
-            (LINK_USER_ORDINAL, Some(second)) => {
-                let parameters = ManagedQueryParameters(DbPair(DbU64(first.0), DbU64(second.0)));
-                let invocation = WriteOperationProof::<LinkUserToOrder>::bind()
-                    .map_err(|_| ExecutionError::Business)?
-                    .invocation(parameters);
-                let execution = db.handoff_write(invocation)?;
-                let result = database
-                    .execute_write(execution, cancel, shutdown)
-                    .await
-                    .map_err(map_write_error)?;
-                encode_pair(
-                    &mut output,
-                    ManagedU64(result.rows_affected()),
-                    ManagedU64(result.last_insert_id()),
-                )?;
-            }
-            (TRANSFER_COMMIT_ORDINAL | TRANSFER_ROLLBACK_ORDINAL, Some(second)) => {
-                let decision = if ordinal == TRANSFER_COMMIT_ORDINAL {
-                    TransactionDecision::Commit
-                } else {
-                    TransactionDecision::Rollback
-                };
-                let parameters = ManagedQueryParameters(DbPair(DbU64(first.0), DbU64(second.0)));
-                let invocation = TransactionOperationProof::<TransferOrderOwner>::bind()
-                    .map_err(|_| ExecutionError::Business)?
-                    .invocation(parameters, decision);
-                let execution = db.handoff_transaction(invocation)?;
-                let result = database
-                    .execute_transaction(execution, cancel, shutdown)
-                    .await
-                    .map_err(map_transaction_error)?;
-                encode_pair(
-                    &mut output,
-                    ManagedU64(result.rows_affected()),
-                    ManagedU64(result.last_insert_id()),
-                )?;
-            }
-            _ => return Err(ExecutionError::InvalidInput),
-        }
-        output
-            .finish()
-            .map_err(|_| ExecutionError::ResponseReservationFailed)
-    }
-}
-
-fn map_query_error(error: QueryOptionalExecutionError) -> ExecutionError {
-    match error {
-        QueryOptionalExecutionError::ConnectionUnavailable
-        | QueryOptionalExecutionError::QueryFailed
-        | QueryOptionalExecutionError::InvalidRow
-        | QueryOptionalExecutionError::FinalizerFailed => ExecutionError::DependencyExecutionFailed,
-        QueryOptionalExecutionError::Cancelled | QueryOptionalExecutionError::Shutdown => {
-            ExecutionError::DependencyUnavailable
-        }
-    }
-}
-
-fn map_write_error(error: WriteExecutionError) -> ExecutionError {
-    match error {
-        WriteExecutionError::ConnectionUnavailable
-        | WriteExecutionError::WriteFailed
-        | WriteExecutionError::FinalizerFailed => ExecutionError::DependencyExecutionFailed,
-        WriteExecutionError::Cancelled | WriteExecutionError::Shutdown => {
-            ExecutionError::DependencyUnavailable
-        }
-    }
-}
-
-fn map_transaction_error(error: TransactionExecutionError) -> ExecutionError {
-    match error {
-        TransactionExecutionError::BusinessRollback => ExecutionError::Business,
-        TransactionExecutionError::ConnectionUnavailable
-        | TransactionExecutionError::BeginFailed
-        | TransactionExecutionError::WriteFailed
-        | TransactionExecutionError::CommitFailed
-        | TransactionExecutionError::RollbackFailed
-        | TransactionExecutionError::FinalizerFailed => ExecutionError::DependencyExecutionFailed,
-        TransactionExecutionError::Cancelled | TransactionExecutionError::Shutdown => {
-            ExecutionError::DependencyUnavailable
-        }
-    }
-}
-
-macro_rules! generated_builder {
-    () => {{
-        let mut builder = CompiledExecutionBuilder::<_, _, _, _, BODY_BYTES, OUTPUT_BYTES>::new(
-            compiled_registry(),
-            dispatch,
-            layout,
-            EntryCapabilityLimits::new(
-                SERVICE_COUNT,
-                ROUTE_BYTES,
-                ROUTE_BYTES,
-                SERVICE_COUNT,
-                SERVICE_COUNT,
-            ),
-        )
-        .expect("single generated assembly");
-        builder
-            .expose::<LookupUser>(
-                b"/users/lookup",
-                EntryFraming::post_managed_content_length(),
-            )
-            .expect("generated user route");
-        builder
-            .expose::<CreateOrder>(
-                b"/orders/create",
-                EntryFraming::post_managed_content_length(),
-            )
-            .expect("generated order route");
-        builder
-            .expose::<Health>(b"/health", EntryFraming::post_managed_content_length())
-            .expect("generated no-DB route");
-        builder
-            .expose::<LinkUserToOrderRoute>(
-                b"/users/link-order",
-                EntryFraming::post_managed_content_length(),
-            )
-            .expect("generated standalone write route");
-        builder
-            .expose::<TransferOrderOwnerCommitRoute>(
-                b"/orders/transfer-owner/commit",
-                EntryFraming::post_managed_content_length(),
-            )
-            .expect("generated transaction commit route");
-        builder
-            .expose::<TransferOrderOwnerRollbackRoute>(
-                b"/orders/transfer-owner/rollback",
-                EntryFraming::post_managed_content_length(),
-            )
-            .expect("generated transaction rollback route");
-        let edge: CreateOrderToLookupUser = builder
-            .bind_internal_call::<CreateOrder, LookupUser>()
-            .expect("generated typed call edge");
-        (builder, edge)
-    }};
-}
-
-fn verify_static_inputs() {
-    let finalization = saddle_db::internal::query_optional_finalization_proof();
-    assert_eq!(finalization.cancel_external_io_awaits(), 0);
-    assert_eq!(finalization.shutdown_external_io_awaits(), 0);
-    assert_eq!(finalization.panic_external_io_awaits(), 0);
-    assert!(finalization.releases_pool_size_before_permit());
-    assert!(finalization.normal_return_requires_termination_bound());
-
-    let user_db = QueryOptionalOperationProof::<FindUserOptional>::bind()
-        .expect("generated user DB operation");
-    let user_db_layout = user_db.layout();
-    let user_invocation = user_db.invocation(ManagedQueryParameters(DbU64(7)));
-    assert_eq!(user_invocation.parameters().0, DbU64(7));
-
-    let order_db = QueryOptionalOperationProof::<FindOrderOptional>::bind()
-        .expect("generated order DB operation");
-    let order_db_layout = order_db.layout();
-    let order_invocation = order_db.invocation(ManagedQueryParameters(DbU64(11)));
-    assert_eq!(order_invocation.parameters().0, DbU64(11));
-
-    let user_route_db = user_db_layout.credits();
-    let order_route_db = order_db_layout
-        .credits()
-        .merge_route_max(user_db_layout.credits());
-    assert_route_credit(user_route_db);
-    assert_route_credit(order_route_db);
-
-    let write = WriteOperationProof::<LinkUserToOrder>::bind()
-        .expect("generated standalone write proof")
-        .layout();
-    let transaction = TransactionOperationProof::<TransferOrderOwner>::bind()
-        .expect("generated transaction proof")
-        .layout();
-    assert_eq!(write.parameter_bytes(), 16);
-    assert_eq!(transaction.parameter_bytes(), 16);
-    assert_write_route_credit(write.credits());
-    assert_write_route_credit(transaction.credits());
-
-    let write_finalization = write_transaction_finalization_proof();
-    assert_eq!(write_finalization.cancel_external_io_awaits(), 0);
-    assert_eq!(write_finalization.shutdown_external_io_awaits(), 0);
-    assert_eq!(write_finalization.panic_external_io_awaits(), 0);
-    assert!(write_finalization.single_connection());
-    assert!(!write_finalization.nested_transactions());
-    assert!(write_finalization.releases_pool_size_before_permit());
-    assert!(write_finalization.normal_return_requires_termination_bound());
-}
-
-struct GeneratedArtifactIdentity;
-
-impl GeneratedServiceCapacityArtifactOwner for GeneratedArtifactIdentity {
-    fn build_identity(&self) -> [u8; 32] {
-        BUILD_IDENTITY
-    }
-    fn artifact_identity(&self) -> [u8; 32] {
-        ARTIFACT_IDENTITY
-    }
-    fn owner_generation(&self) -> u64 {
-        OWNER_GENERATION
-    }
-}
-
-fn generated_bootstrap<A>(
-    token: GeneratedBootstrapToken,
-    capability: A,
-    common: [[u8; 32]; 3],
-) -> Result<
-    (
-        GeneratedApplicationBootstrap<A, GeneratedRequestContextFactory, SERVICE_COUNT>,
-        [u8; 32],
-    ),
-    GeneratedBootstrapError,
->
-where
-    A: GeneratedCompiledAdapter<Context = GeneratedRequestContext>,
-{
-    let user_route = token.bind_route(b"/users/lookup", 8)?;
-    let order_route = token.bind_route(b"/orders/create", 16)?;
-    let health_route = token.bind_route(b"/health", 8)?;
-    let write_route = token.bind_route(b"/users/link-order", 16)?;
-    let commit_route = token.bind_route(b"/orders/transfer-owner/commit", 16)?;
-    let rollback_route = token.bind_route(b"/orders/transfer-owner/rollback", 16)?;
-    let bootstrap_type =
-        generated_bootstrap_type_identity::<A, GeneratedRequestContextFactory, SERVICE_COUNT>();
-    let profile = token.approve_http1_facts(GeneratedHttp1StaticFacts {
-        route_count: SERVICE_COUNT,
-        route_set_identity: common[2],
-        framing_identity: generated_http1_framing_identity(),
-        static_layout_identity: bootstrap_type,
-        db_finalization_proof: saddle_db::internal::query_optional_finalization_proof(),
-    })?;
-    let bootstrap = token.consume(
-        capability,
-        GeneratedRequestContextFactory,
-        [
-            user_route,
-            order_route,
-            health_route,
-            write_route,
-            commit_route,
-            rollback_route,
-        ],
-        profile,
-    )?;
-    Ok((bootstrap, bootstrap_type))
-}
-
-pub(crate) struct GeneratedOwner;
-
-impl GeneratedApplicationOwner for GeneratedOwner {
-    fn consume<K>(self, seal: GeneratedApplicationSeal, consumer: K) -> saddle::Result<()>
-    where
-        K: GeneratedApplicationConsumer,
-    {
-        verify_static_inputs();
-        let (builder, _edge) = generated_builder!();
-        let bundle = builder
-            .freeze_with_capacity_leaf(GeneratedArtifactIdentity)
-            .expect("single generated freeze and capacity bundle");
-        let common = bundle.capacity_source().common_identities();
-        let (bootstrap, _bootstrap_type) =
-            generated_bootstrap(seal.preflight_token(), bundle, common)
-                .map_err(|_| generated_error("skill.generated_preflight"))?;
-        let parts = seal
-            .bind(bootstrap)
-            .map_err(|_| generated_error("skill.generated_binding"))?;
-        consumer.consume(parts)
-    }
-}
-
-fn generated_error(code: &'static str) -> saddle::SaddleError {
-    saddle::SaddleError::new(
-        saddle::ErrorKind::Infrastructure,
-        code,
-        "generated owner rejected",
-    )
-}
-
-impl crate::GeneratedProbe {
-    #[allow(dead_code)]
-    pub fn run<B>(bundle: B, config: saddle::SaddleConfig) -> saddle::Result<()>
-    where
-        B: ApprovedExternalBundle,
-    {
-        ProductionLauncher::verify(bundle)?.run(config, GeneratedOwner)
-    }
-}
-
-pub(crate) fn verify_startup() {
-    verify_static_inputs();
-    fn require_owner<T: GeneratedApplicationOwner>() {}
-    require_owner::<GeneratedOwner>();
-}
-
-pub(crate) struct MachineValues {
-    pub(crate) dispatcher_future: usize,
-    pub(crate) user_handler_future: usize,
-    pub(crate) order_handler_future: usize,
-    pub(crate) health_handler_future: usize,
-    pub(crate) user_commitment: usize,
-    pub(crate) order_commitment: usize,
-    pub(crate) health_commitment: usize,
-    pub(crate) user_db_parameter: usize,
-    pub(crate) user_db_optional_row: usize,
-    pub(crate) order_db_parameter: usize,
-    pub(crate) order_db_optional_row: usize,
-    pub(crate) user_route_connections: u32,
-    pub(crate) user_route_operations: u32,
-    pub(crate) order_route_connections: u32,
-    pub(crate) order_route_operations: u32,
-    pub(crate) health_route_connections: u32,
-    pub(crate) health_route_operations: u32,
-}
-
-fn assert_route_credit(credit: QueryOptionalCreditDemand) {
-    assert_eq!(credit.connections(), 1);
-    assert_eq!(credit.operations(), 1);
-}
-
-fn assert_write_route_credit(credit: WriteCreditDemand) {
-    assert_eq!(credit.connections(), 1);
-    assert_eq!(credit.operations(), 1);
-}
-
-fn dispatcher_future_bytes<Factory, DispatcherFuture>(factory: Factory) -> usize
-where
-    Factory: Fn(
-        usize,
-        GeneratedRequestContext,
-        ManagedBytes,
-        CompiledDbPermit,
-        ManagedResponseBuilder,
-    ) -> DispatcherFuture,
-    DispatcherFuture: Future<Output = Result<ManagedResponse, ExecutionError>> + Send + 'static,
-{
-    let _ = factory;
-    core::mem::size_of::<DispatcherFuture>()
-}
-
-pub(crate) fn machine_values() -> MachineValues {
-    let user = handler_layout(LOOKUP_USER_ORDINAL).expect("generated user layout");
-    let order = handler_layout(CREATE_ORDER_ORDINAL).expect("generated order layout");
-    let health = handler_layout(HEALTH_ORDINAL).expect("generated health layout");
-    let user_db = QueryOptionalOperationProof::<FindUserOptional>::bind()
-        .expect("generated user DB operation")
-        .layout();
-    let order_db = QueryOptionalOperationProof::<FindOrderOptional>::bind()
-        .expect("generated order DB operation")
-        .layout();
-    let user_route_db = user_db.credits();
-    let order_route_db = order_db.credits().merge_route_max(user_db.credits());
-    MachineValues {
-        dispatcher_future: dispatcher_future_bytes(dispatch),
-        user_handler_future: user.future_bytes(),
-        order_handler_future: order.future_bytes(),
-        health_handler_future: health.future_bytes(),
-        user_commitment: user.commitment().expect("generated user commitment"),
-        order_commitment: order.commitment().expect("generated order commitment"),
-        health_commitment: health.commitment().expect("generated health commitment"),
-        user_db_parameter: user_db.parameter_bytes(),
-        user_db_optional_row: user_db.optional_row_bytes(),
-        order_db_parameter: order_db.parameter_bytes(),
-        order_db_optional_row: order_db.optional_row_bytes(),
-        user_route_connections: user_route_db.connections(),
-        user_route_operations: user_route_db.operations(),
-        order_route_connections: order_route_db.connections(),
-        order_route_operations: order_route_db.operations(),
-        health_route_connections: 0,
-        health_route_operations: 0,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn swapped_layout(ordinal: usize) -> Option<CompiledRouteExecutionProof> {
-        match ordinal {
-            LOOKUP_USER_ORDINAL => layout(CREATE_ORDER_ORDINAL),
-            CREATE_ORDER_ORDINAL => layout(LOOKUP_USER_ORDINAL),
-            _ => None,
-        }
-    }
-
-    #[test]
-    fn generated_bootstrap_factory_typechecks() {
-        verify_startup();
-    }
-
-    #[test]
-    fn generated_health_route_has_no_db_resources() {
-        let (builder, _edge) = generated_builder!();
-        let capability = builder.freeze().expect("single generated freeze");
-        let health = capability
-            .lookup(
-                b"/health",
-                EntryFraming::post_managed_content_length(),
-                Some(8),
-            )
-            .expect("generated no-DB lookup");
-        assert!(health.db_demand().is_none());
-        assert_eq!(health.db_demand().connections(), 0);
-        assert_eq!(health.db_demand().operations(), 0);
-    }
-
-    #[test]
-    fn generated_write_and_transaction_routes_share_the_only_capability() {
-        let (builder, _edge) = generated_builder!();
-        let capability = builder.freeze().expect("single unified generated freeze");
-        for route in [
-            b"/users/link-order".as_slice(),
-            b"/orders/transfer-owner/commit".as_slice(),
-            b"/orders/transfer-owner/rollback".as_slice(),
-        ] {
-            let lookup = capability
-                .lookup(route, EntryFraming::post_managed_content_length(), Some(16))
-                .expect("generated unified C1 route lookup");
-            assert_eq!(lookup.db_demand().connections(), 1);
-            assert_eq!(lookup.db_demand().operations(), 1);
-        }
-    }
-
-    #[test]
-    fn swapped_layout_is_rejected() {
-        let mut builder = CompiledExecutionBuilder::<_, _, _, _, BODY_BYTES, OUTPUT_BYTES>::new(
-            compiled_registry(),
-            dispatch,
-            swapped_layout,
-            EntryCapabilityLimits::new(
-                SERVICE_COUNT,
-                ROUTE_BYTES,
-                ROUTE_BYTES,
-                SERVICE_COUNT,
-                SERVICE_COUNT,
-            ),
-        )
-        .expect("candidate assembly");
-        assert!(
-            builder
-                .expose::<LookupUser>(
-                    b"/users/lookup",
-                    EntryFraming::post_managed_content_length(),
-                )
-                .is_err()
-        );
-    }
-
-    #[test]
-    fn swapped_registry_ordinal_is_rejected() {
-        let mut registry =
-            CompiledServiceRegistryBuilder::new(SERVICE_COUNT).expect("bounded registry");
-        registry
-            .register::<CreateOrder>(ServiceDescriptor::new("orders", "order", "create"))
-            .expect("swapped order marker");
-        registry
-            .register::<LookupUser>(ServiceDescriptor::new("users", "user", "lookup"))
-            .expect("swapped user marker");
-        let mut builder = CompiledExecutionBuilder::<_, _, _, _, BODY_BYTES, OUTPUT_BYTES>::new(
-            registry.freeze().expect("swapped registry"),
-            dispatch,
-            layout,
-            EntryCapabilityLimits::new(
-                SERVICE_COUNT,
-                ROUTE_BYTES,
-                ROUTE_BYTES,
-                SERVICE_COUNT,
-                SERVICE_COUNT,
-            ),
-        )
-        .expect("candidate assembly");
-        assert!(
-            builder
-                .expose::<LookupUser>(
-                    b"/users/lookup",
-                    EntryFraming::post_managed_content_length(),
-                )
-                .is_err()
-        );
-    }
-}