Hexagonal architecture. Beyond your own code.

1. 01Implement
   Keep the same contract

   Build a second adapter that exports the same capability, with the behavior consumers expect.

   construct() · in each adapter

   // @example/payment-stripe
   ImplementInterface(
     await import("@example/interface-payment"),
     await import("./stripe"),
   );
    
   // @example/email-brevo
   ImplementInterface(
     await import("@example/interface-email"),
     await import("./brevo"),
   );
   

2. 02Select
   Change application assembly

   Select the new provider package and supply its required configuration before running the application.

   antelope.config.ts · excerpt

   payment: {
     source: { type: "package",
       // Was: @example/payment-checkout
       package: "@example/payment-stripe" },
   },
   email: {
     source: { type: "package",
       // Was: @example/email-smtp
       package: "@example/email-brevo" },
   },
   

3. 03VerifyUnchanged
   Leave the consumer alone

   Verify the new provider against the contract and your integration tests. The consumer keeps its original import and call.

   modules/checkout/place-order.ts · unchanged

   import { charge } from
     "@example/interface-payment";
   import { sendEmail } from
     "@example/interface-email";
    
   export async function place(order: Order) {
     await charge({
       amount: order.total,
       reference: order.id,
     });
     await sendEmail({
       to: order.email,
       subject: "Order confirmed",
     });
   }
   

A replacement must respect the same contract and its behavior, not just its types. Provider configuration, credentials and any data migrations remain your responsibility. Antelope supplies the binding mechanisms; your code must still respect the boundaries.