@cimplify/sdk 0.104.0 → 0.105.0

package/dist/{chunk-OCCNG6MO.mjs → chunk-X7RPMALQ.mjs}

@@ -1,6 +1,6 @@
-import { MOBILE_MONEY_PROVIDER, PAYMENT_METHOD, MAX_PAYMENT_AUTHORIZATION_STEPS } from './chunk-GOHSXBKW.mjs';
-import { normalizeStatusResponse, paymentAuthorizationUrl, isPaymentStatusSuccess, isPaymentStatusFailure, isPaymentStatusRequiresAction } from './chunk-DYIAX3WI.mjs';
-import { CimplifyError, isSupportedCurrency, ErrorCode, enrichError, getErrorHint } from './chunk-H3RATH4B.mjs';
+import { CHECKOUT_STATUS, PAYMENT_METHOD, CHECKOUT_NEXT_ACTION, CHECKOUT_ORDER_RESULT_STATUS, ORDER_TYPE, AUTHORIZATION_TYPE } from './chunk-33VCYWVL.mjs';
+import { paymentAuthorizationUrl, purchaseIntentMobileMoneyNetwork } from './chunk-NYDVVNZI.mjs';
+import { ErrorCode, PURCHASE_INTENT_RESOLVE_STATUS, CimplifyError, PAYMENT_OPTION_STATUS, isSupportedCurrency, PURCHASE_INTENT_CONFIRM_STATUS, PURCHASE_INTENT_ACTION_DECISION, PURCHASE_INTENT_RESOLUTION_KIND, PURCHASE_INTENT_ERROR_CODE, enrichError, LEGACY_CHECKOUT_PAYMENT_METHOD_ALIAS, PURCHASE_INTENT_PAYMENT_METHOD, PURCHASE_INTENT_SOURCE_KIND, LEGACY_CHECKOUT_PAYMENT_STATUS, getErrorHint, MOBILE_MONEY_TENDER_AUTHORITY_KIND } from './chunk-NJYR6GGM.mjs';
 
 // src/types/result.ts
 function ok(value) {
@@ -785,703 +785,796 @@ var CartOperations = class {
   }
 };
 
-// src/utils/checkout-resolver.ts
-var DEFAULT_POLL_INTERVAL_MS = 3e3;
-var DEFAULT_MAX_POLL_ATTEMPTS = 60;
-var MAX_CONSECUTIVE_NETWORK_ERRORS = 5;
-var NEXT_ACTION_NONE = "none";
-var NEXT_ACTION_CARD_POPUP = "card_popup";
-var NEXT_ACTION_REDIRECT = "redirect";
-var NEXT_ACTION_AUTHORIZATION = "authorization";
-var NEXT_ACTION_POLL = "poll";
-var VALID_MOBILE_MONEY_PROVIDERS = new Set(Object.values(MOBILE_MONEY_PROVIDER));
-function isValidMobileMoneyProvider(value) {
-  return VALID_MOBILE_MONEY_PROVIDERS.has(value);
-}
-function normalizeAuthorizationType(value) {
-  if (value && typeof value === "object" && "address" in value) {
-    return "address";
-  }
-  if (typeof value !== "string") return void 0;
-  const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
-  if (normalized === "otp" || normalized === "pin") return normalized;
-  if (normalized === "phone" || normalized === "birthday" || normalized === "address") {
-    return normalized;
+// src/payment-authorization/types.ts
+var PAYMENT_AUTHORIZATION_OUTCOME_STATUS = {
+  SUBMITTED: "submitted",
+  CANCELLED: "cancelled",
+  FAILED: "failed"
+};
+var PAYMENT_AUTHORIZATION_PROVIDER = {
+  PAYSTACK: "paystack",
+  STRIPE: "stripe"
+};
+
+// src/payment-authorization/providers/paystack.ts
+var PAYSTACK_POPUP_ERROR = {
+  PROVIDER_UNAVAILABLE: ErrorCode.PROVIDER_UNAVAILABLE,
+  SUBMISSION_UNKNOWN: "SUBMISSION_UNKNOWN",
+  CANCELLED: "CANCELLED",
+  PAYMENT_CANCELLED: ErrorCode.PAYMENT_CANCELLED,
+  PAYMENT_FAILED: ErrorCode.PAYMENT_FAILED,
+  POPUP_BLOCKED: ErrorCode.POPUP_BLOCKED
+};
+async function openPaystackPopup(options, signal) {
+  if (typeof window === "undefined") {
+    return { success: false, error: PAYSTACK_POPUP_ERROR.PROVIDER_UNAVAILABLE };
   }
-  return void 0;
-}
-function normalizeAuthorizationSubmission(expectedType, submission) {
-  if (!submission || submission.type !== expectedType) {
-    throw new Error(`Expected ${expectedType} authorization details.`);
+  let PaystackPop;
+  try {
+    const imported = await import('@paystack/inline-js');
+    PaystackPop = imported.default;
+  } catch {
+    return { success: false, error: PAYSTACK_POPUP_ERROR.PROVIDER_UNAVAILABLE };
   }
-  if (submission.type === "address") {
-    const address = submission.address.trim();
-    const city = submission.city.trim();
-    const state = submission.state.trim();
-    const zipCode = submission.zip_code.trim();
-    if (!address || !city || !state || !zipCode) {
-      throw new Error("Complete all authorization address fields.");
-    }
-    return {
-      type: "address",
-      address,
-      city,
-      state,
-      zip_code: zipCode
+  return new Promise((resolve) => {
+    let settled = false;
+    let providerStarted = false;
+    const resolveOnce = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (signal) {
+        signal.removeEventListener("abort", onAbort);
+      }
+      resolve(result);
     };
-  }
-  const value = submission.value.trim();
-  if (!value) {
-    throw new Error("Authorization value is required.");
-  }
-  return { type: submission.type, value };
-}
-function formatMoney(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value.toFixed(2);
-  }
-  if (typeof value === "string" && value.trim().length > 0) {
-    return value;
-  }
-  return "0.00";
-}
-function createAbortError() {
-  const error = new Error("CANCELLED");
-  error.name = "AbortError";
-  return error;
-}
-function isAbortError(error) {
-  if (error instanceof DOMException && error.name === "AbortError") {
-    return true;
-  }
-  return error instanceof Error && (error.name === "AbortError" || error.message === "CANCELLED");
-}
-function waitForAbortable(promise, signal) {
-  if (!signal) return promise;
-  if (signal.aborted) return Promise.reject(createAbortError());
-  return new Promise((resolve, reject) => {
     const onAbort = () => {
-      signal.removeEventListener("abort", onAbort);
-      reject(createAbortError());
+      resolveOnce({
+        success: false,
+        // Once Paystack owns the transaction, cancellation is ambiguous. The
+        // adapter converts this into submitted so Cimplify polling decides.
+        error: providerStarted ? PAYSTACK_POPUP_ERROR.SUBMISSION_UNKNOWN : PAYSTACK_POPUP_ERROR.CANCELLED
+      });
     };
-    signal.addEventListener("abort", onAbort, { once: true });
-    promise.then(
-      (value) => {
-        signal.removeEventListener("abort", onAbort);
-        resolve(value);
-      },
-      (error) => {
-        signal.removeEventListener("abort", onAbort);
-        reject(error);
-      }
-    );
-  });
-}
-var CheckoutResolver = class {
-  constructor(options) {
-    this.client = options.client;
-    this.checkoutData = options.checkoutData;
-    this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-    this.maxPollAttempts = options.maxPollAttempts ?? DEFAULT_MAX_POLL_ATTEMPTS;
-    this.onStatusChange = options.onStatusChange;
-    this.onAuthorizationUiChange = options.onAuthorizationUiChange;
-    this.onAuthorizationRequired = options.onAuthorizationRequired;
-    this.signal = options.signal;
-    this.returnUrl = options.returnUrl;
-    this.enrollInLink = options.enrollInLink !== false;
-    this.businessId = options.businessId;
-    this.addressData = options.addressData;
-    this.paymentData = options.paymentData;
-    this.orderType = options.orderType;
-    this.cartTotal = options.cartTotal;
-    this.cartCurrency = options.cartCurrency;
-    this.allowPopups = options.allowPopups ?? typeof window !== "undefined";
-  }
-  async resolve(checkoutResult) {
+    if (signal?.aborted) {
+      resolveOnce({ success: false, error: PAYSTACK_POPUP_ERROR.CANCELLED });
+      return;
+    }
+    if (signal) {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
     try {
-      this.ensureNotAborted();
-      if (!checkoutResult.order_id) {
-        return this.fail("CHECKOUT_FAILED", "Checkout did not return an order ID.", false);
-      }
-      if (this.isSuccessfulStatus(checkoutResult.payment_status)) {
-        return this.finalizeSuccess(checkoutResult);
-      }
-      if (this.isFailureStatus(checkoutResult.payment_status)) {
-        const normalized = normalizeStatusResponse({
-          status: checkoutResult.payment_status,
-          paid: false
-        });
-        return this.fail(
-          normalized.status.toUpperCase(),
-          checkoutResult.display_text || "Payment failed before confirmation.",
-          false
-        );
-      }
-      const nextAction = checkoutResult.next_action ?? this.deriveLegacyNextAction(checkoutResult);
-      return this.resolveNextAction({ ...checkoutResult, next_action: nextAction });
-    } catch (error) {
-      if (isAbortError(error)) {
-        return this.fail("CANCELLED", "Checkout was cancelled.", true);
-      }
-      const message = error instanceof Error ? error.message : "Checkout failed unexpectedly.";
-      return this.fail("CHECKOUT_FAILED", message, true);
+      const popup = new PaystackPop();
+      popup.newTransaction({
+        key: options.key,
+        email: options.email,
+        amount: options.amount,
+        currency: options.currency,
+        reference: options.reference,
+        accessCode: options.accessCode,
+        onSuccess: (transaction) => {
+          resolveOnce({
+            success: true,
+            reference: transaction.reference ?? options.reference
+          });
+        },
+        onCancel: () => {
+          resolveOnce({ success: false, error: PAYSTACK_POPUP_ERROR.PAYMENT_CANCELLED });
+        },
+        onError: (error) => {
+          resolveOnce({
+            success: false,
+            error: error?.message || PAYSTACK_POPUP_ERROR.PAYMENT_FAILED
+          });
+        }
+      });
+      providerStarted = true;
+    } catch {
+      resolveOnce({ success: false, error: PAYSTACK_POPUP_ERROR.POPUP_BLOCKED });
     }
+  });
+}
+var PaystackAuthorizationAdapter = class {
+  constructor(openPopup = openPaystackPopup) {
+    this.openPopup = openPopup;
+    this.provider = PAYMENT_AUTHORIZATION_PROVIDER.PAYSTACK;
   }
-  deriveLegacyNextAction(checkoutResult) {
-    if (checkoutResult.client_secret && checkoutResult.public_key) {
+  async authorize(context) {
+    const result = await this.openPopup(
+      {
+        key: context.action.public_key,
+        email: context.email,
+        accessCode: context.action.client_secret,
+        reference: context.reference || context.action.client_secret,
+        currency: context.currency
+      },
+      context.signal
+    );
+    if (result.success) {
       return {
-        type: NEXT_ACTION_CARD_POPUP,
-        provider: checkoutResult.provider?.trim().toLowerCase() || "",
-        client_secret: checkoutResult.client_secret,
-        public_key: checkoutResult.public_key
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
+        reference: result.reference || context.reference
       };
     }
-    if (checkoutResult.authorization_url) {
+    if (result.error === PAYSTACK_POPUP_ERROR.SUBMISSION_UNKNOWN) {
+      return {
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
+        reference: context.reference
+      };
+    }
+    if (!result.error || result.error === PAYSTACK_POPUP_ERROR.CANCELLED || result.error === PAYSTACK_POPUP_ERROR.PAYMENT_CANCELLED) {
+      return { status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED };
+    }
+    if (result.error === PAYSTACK_POPUP_ERROR.POPUP_BLOCKED) {
       return {
-        type: NEXT_ACTION_REDIRECT,
-        authorization_url: checkoutResult.authorization_url
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: ErrorCode.POPUP_BLOCKED,
+        message: "Unable to open the Paystack payment popup. Please allow popups and try again.",
+        recoverable: true
       };
     }
-    if (checkoutResult.requires_authorization && checkoutResult.authorization_type) {
+    if (result.error === PAYSTACK_POPUP_ERROR.PROVIDER_UNAVAILABLE) {
       return {
-        type: NEXT_ACTION_AUTHORIZATION,
-        authorization_type: checkoutResult.authorization_type,
-        display_text: checkoutResult.display_text
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: ErrorCode.PROVIDER_UNAVAILABLE,
+        message: "Paystack is unavailable in this environment.",
+        recoverable: false
       };
     }
-    return { type: NEXT_ACTION_POLL };
+    return {
+      status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+      code: ErrorCode.PAYMENT_FAILED,
+      message: result.error || "Paystack payment could not be submitted.",
+      recoverable: true
+    };
+  }
+};
+
+// src/payment-authorization/providers/stripe.ts
+var STRIPE_REDIRECT_MODE = "if_required";
+var STRIPE_PAYMENT_ELEMENT_TYPE = "payment";
+async function loadStripeFromPeer(publicKey, options) {
+  try {
+    const imported = await import('@stripe/stripe-js');
+    return imported.loadStripe ? imported.loadStripe(publicKey, options) : null;
+  } catch {
+    return null;
   }
-  async runCardPopup(action, checkoutResult) {
-    if (typeof action.provider !== "string" || !action.provider.trim() || typeof action.client_secret !== "string" || !action.client_secret.trim() || typeof action.public_key !== "string" || !action.public_key.trim()) {
+}
+function createStripeModal() {
+  if (typeof document === "undefined" || !document.body) return null;
+  const previousFocus = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+  const root = document.createElement("div");
+  root.setAttribute("role", "dialog");
+  root.setAttribute("aria-modal", "true");
+  root.setAttribute("aria-label", "Secure card payment");
+  Object.assign(root.style, {
+    position: "fixed",
+    inset: "0",
+    zIndex: "2147483647",
+    display: "grid",
+    placeItems: "center",
+    padding: "16px",
+    background: "rgba(15, 23, 42, 0.58)"
+  });
+  const form = document.createElement("form");
+  Object.assign(form.style, {
+    width: "min(100%, 480px)",
+    maxHeight: "calc(100vh - 32px)",
+    overflow: "auto",
+    borderRadius: "12px",
+    padding: "24px",
+    background: "#fff",
+    boxShadow: "0 24px 80px rgba(15, 23, 42, 0.32)"
+  });
+  const title = document.createElement("h2");
+  title.textContent = "Complete card payment";
+  Object.assign(title.style, { margin: "0 0 18px", font: "600 18px/1.4 system-ui" });
+  const paymentMount = document.createElement("div");
+  paymentMount.setAttribute("data-cimplify-stripe-payment-element", "");
+  const error = document.createElement("p");
+  error.setAttribute("role", "alert");
+  Object.assign(error.style, {
+    minHeight: "20px",
+    margin: "14px 0 0",
+    color: "#b91c1c",
+    font: "14px/1.4 system-ui"
+  });
+  const actions = document.createElement("div");
+  Object.assign(actions.style, {
+    display: "flex",
+    justifyContent: "flex-end",
+    gap: "10px",
+    marginTop: "18px"
+  });
+  const cancelButton = document.createElement("button");
+  cancelButton.type = "button";
+  cancelButton.textContent = "Cancel";
+  Object.assign(cancelButton.style, {
+    border: "1px solid #cbd5e1",
+    borderRadius: "8px",
+    padding: "10px 16px",
+    background: "#fff",
+    color: "#0f172a",
+    cursor: "pointer"
+  });
+  const submitButton = document.createElement("button");
+  submitButton.type = "submit";
+  submitButton.textContent = "Pay securely";
+  Object.assign(submitButton.style, {
+    border: "0",
+    borderRadius: "8px",
+    padding: "10px 16px",
+    background: "#0f172a",
+    color: "#fff",
+    cursor: "pointer"
+  });
+  actions.append(cancelButton, submitButton);
+  form.append(title, paymentMount, error, actions);
+  root.append(form);
+  document.body.append(root);
+  cancelButton.focus();
+  return { root, form, paymentMount, submitButton, cancelButton, error, previousFocus };
+}
+function stripeFailure(error) {
+  const message = error?.message || "Stripe could not authorize this payment.";
+  if (error?.code === "payment_intent_authentication_failure" || error?.type === "invalid_request_error") {
+    return {
+      status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+      code: ErrorCode.AUTHORIZATION_FAILED,
+      message,
+      recoverable: true
+    };
+  }
+  return {
+    status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+    code: ErrorCode.PAYMENT_FAILED,
+    message,
+    recoverable: true
+  };
+}
+var StripeAuthorizationAdapter = class {
+  constructor(loadStripe = loadStripeFromPeer) {
+    this.loadStripe = loadStripe;
+    this.provider = PAYMENT_AUTHORIZATION_PROVIDER.STRIPE;
+  }
+  async authorize(context) {
+    if (typeof window === "undefined" || typeof document === "undefined" || context.signal?.aborted) {
+      return context.signal?.aborted ? { status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED } : {
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: ErrorCode.PROVIDER_UNAVAILABLE,
+        message: "Stripe Payment Element is unavailable in this environment.",
+        recoverable: false
+      };
+    }
+    let stripe;
+    try {
+      stripe = await this.loadStripe(
+        context.action.public_key,
+        context.action.provider_account_id ? { stripeAccount: context.action.provider_account_id } : void 0
+      );
+    } catch (error) {
       return {
-        ok: false,
-        result: this.fail(
-          "INVALID_CARD_AUTHORIZATION",
-          "The payment provider returned an incomplete card authorization response.",
-          false
-        )
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: ErrorCode.PROVIDER_UNAVAILABLE,
+        message: error instanceof Error ? error.message : "Stripe.js could not be loaded.",
+        recoverable: true
       };
     }
-    this.emit("awaiting_authorization", {
-      display_text: "Complete payment in the card authorization window.",
-      order_id: checkoutResult.order_id,
-      order_number: checkoutResult.order_number,
-      provider: action.provider
-    });
-    if (!this.allowPopups) {
+    if (context.signal?.aborted) {
+      return { status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED };
+    }
+    if (!stripe) {
       return {
-        ok: false,
-        result: this.fail(
-          "PROVIDER_UNAVAILABLE",
-          "Card authorization UI is unavailable in this environment.",
-          false
-        )
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: ErrorCode.PROVIDER_UNAVAILABLE,
+        message: "Stripe.js could not be loaded.",
+        recoverable: false
       };
     }
-    const currency = this.getOrderCurrency(checkoutResult);
-    if (!currency) {
+    const modal = createStripeModal();
+    if (!modal) {
       return {
-        ok: false,
-        result: this.fail("INVALID_CURRENCY", "Payment currency is missing or unsupported.", false)
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: ErrorCode.PROVIDER_UNAVAILABLE,
+        message: "Stripe Payment Element could not be mounted.",
+        recoverable: false
       };
     }
-    let outcome;
+    let paymentElement;
+    let elements;
     try {
-      this.notifyAuthorizationUiChange(true);
-      outcome = await this.client.checkout.authorizeCardPopup(action, {
-        email: this.checkoutData.customer.email || "customer@cimplify.io",
-        currency,
-        reference: checkoutResult.payment_reference,
-        returnUrl: this.returnUrl,
-        signal: this.signal
-      });
-    } finally {
-      this.notifyAuthorizationUiChange(false);
-    }
-    if (outcome.status === "submitted") {
-      return { ok: true, reference: outcome.reference };
-    }
-    if (outcome.status === "cancelled") {
+      elements = stripe.elements({ clientSecret: context.action.client_secret });
+      paymentElement = elements.create(STRIPE_PAYMENT_ELEMENT_TYPE);
+      paymentElement.mount(modal.paymentMount);
+    } catch {
+      modal.root.remove();
+      modal.previousFocus?.focus();
       return {
-        ok: false,
-        result: this.fail(
-          "PAYMENT_CANCELLED",
-          "Card payment was cancelled before submission.",
-          true
-        )
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: ErrorCode.PROVIDER_UNAVAILABLE,
+        message: "Stripe Payment Element could not be initialized.",
+        recoverable: false
       };
     }
-    return {
-      ok: false,
-      result: this.fail(outcome.code, outcome.message, outcome.recoverable)
-    };
-  }
-  async resolveNextAction(checkoutResult, resolutionState = {
-    authorizationSteps: 0,
-    pollAttempts: 0,
-    consecutivePollErrors: 0
-  }) {
-    if (this.isSuccessfulStatus(checkoutResult.payment_status)) {
-      return this.finalizeSuccess(checkoutResult);
-    }
-    let latestCheckoutResult = checkoutResult;
-    let paymentReference = checkoutResult.payment_reference;
-    let action = checkoutResult.next_action;
-    actionLoop: while (true) {
-      this.ensureNotAborted();
-      switch (action.type) {
-        case NEXT_ACTION_NONE:
-          break actionLoop;
-        case NEXT_ACTION_CARD_POPUP: {
-          const limitFailure = this.consumeAuthorizationStep(resolutionState);
-          if (limitFailure) return limitFailure;
-          const popup = await this.runCardPopup(action, latestCheckoutResult);
-          if (!popup.ok) return popup.result;
-          paymentReference = popup.reference || paymentReference;
-          break actionLoop;
+    if (context.signal?.aborted) {
+      if (paymentElement.destroy) paymentElement.destroy();
+      else paymentElement.unmount?.();
+      modal.root.remove();
+      modal.previousFocus?.focus();
+      return { status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED };
+    }
+    return new Promise((resolve) => {
+      let settled = false;
+      let submitting = false;
+      let confirmationStarted = false;
+      const cleanup = () => {
+        context.signal?.removeEventListener("abort", onAbort);
+        modal.form.removeEventListener("submit", onSubmit);
+        modal.cancelButton.removeEventListener("click", onCancel);
+        if (paymentElement.destroy) paymentElement.destroy();
+        else paymentElement.unmount?.();
+        modal.root.remove();
+        modal.previousFocus?.focus();
+      };
+      const settle = (outcome) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve(outcome);
+      };
+      const onAbort = () => {
+        if (confirmationStarted) {
+          settle({
+            status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
+            reference: context.reference
+          });
+          return;
         }
-        case NEXT_ACTION_REDIRECT: {
-          const limitFailure = this.consumeAuthorizationStep(resolutionState);
-          if (limitFailure) return limitFailure;
-          const authorizationUrl = paymentAuthorizationUrl(action.authorization_url);
-          if (!authorizationUrl) {
-            return this.fail(
-              "INVALID_REDIRECT_AUTHORIZATION",
-              "The payment provider returned an invalid authorization URL.",
-              false
-            );
-          }
-          if (typeof window !== "undefined" && this.returnUrl) {
-            window.location.assign(authorizationUrl);
-            return this.fail(
-              "REDIRECT_REQUIRED",
-              "Redirecting to complete payment authorization.",
-              true
-            );
-          }
-          if (typeof window !== "undefined") {
-            const popup = window.open(
-              authorizationUrl,
-              "cimplify-auth",
-              "width=520,height=760,noopener,noreferrer"
-            );
-            if (!popup) {
-              return this.fail(
-                "POPUP_BLOCKED",
-                "Authorization popup was blocked. Please allow popups and retry.",
-                true
-              );
-            }
-          }
-          break actionLoop;
+        settle({ status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED });
+      };
+      const onCancel = () => {
+        if (!confirmationStarted) {
+          settle({ status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED });
         }
-        case NEXT_ACTION_AUTHORIZATION: {
-          const limitFailure = this.consumeAuthorizationStep(resolutionState);
-          if (limitFailure) return limitFailure;
-          const authType = normalizeAuthorizationType(action.authorization_type);
-          const authorization = await this.handleAuthorization({
-            authorizationType: authType,
-            paymentId: latestCheckoutResult.payment_id,
-            displayText: action.display_text,
-            provider: latestCheckoutResult.provider,
-            orderId: latestCheckoutResult.order_id,
-            orderNumber: latestCheckoutResult.order_number
-          });
-          if (!authorization.ok) {
-            return authorization.result;
+      };
+      const onSubmit = async (event) => {
+        event.preventDefault();
+        if (submitting || settled) return;
+        submitting = true;
+        modal.submitButton.disabled = true;
+        modal.error.textContent = "";
+        try {
+          const validation = elements.submit ? await elements.submit() : {};
+          if (validation.error) {
+            modal.error.textContent = validation.error.message || "Check your payment details.";
+            submitting = false;
+            modal.submitButton.disabled = false;
+            return;
           }
-          if (!authorization.value) {
-            break actionLoop;
+          if (settled || context.signal?.aborted) {
+            settle({ status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED });
+            return;
           }
-          latestCheckoutResult = authorization.value;
-          paymentReference = authorization.value.payment_reference || paymentReference;
-          if (this.isSuccessfulStatus(authorization.value.payment_status)) {
-            return this.finalizeSuccess(authorization.value);
+          confirmationStarted = true;
+          modal.cancelButton.disabled = true;
+          const confirmation = await stripe.confirmPayment({
+            elements,
+            confirmParams: { return_url: context.returnUrl || window.location.href },
+            redirect: STRIPE_REDIRECT_MODE
+          });
+          if (settled) return;
+          if (confirmation.error) {
+            settle(stripeFailure(confirmation.error));
+            return;
           }
-          if (this.isFailureStatus(authorization.value.payment_status)) {
-            return this.fail(
-              "AUTHORIZATION_FAILED",
-              authorization.value.display_text || "Payment authorization failed.",
-              false
-            );
+          settle({
+            status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
+            reference: confirmation.paymentIntent?.id || context.reference
+          });
+        } catch (error) {
+          if (confirmationStarted) {
+            settle({
+              status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
+              reference: context.reference
+            });
+            return;
           }
-          action = authorization.value.next_action ?? this.deriveLegacyNextAction(authorization.value);
-          continue actionLoop;
-        }
-        case NEXT_ACTION_POLL:
-          break actionLoop;
-        default:
-          return this.fail(
-            "UNSUPPORTED_NEXT_ACTION",
-            "The payment provider requested an unsupported authorization action.",
-            false
+          settle(
+            stripeFailure({
+              message: error instanceof Error ? error.message : "Stripe confirmation failed."
+            })
           );
-      }
-    }
-    return this.pollUntilTerminal({
-      orderId: latestCheckoutResult.order_id,
-      latestCheckoutResult,
-      paymentReference,
-      resolutionState
+        }
+      };
+      modal.form.addEventListener("submit", onSubmit);
+      modal.cancelButton.addEventListener("click", onCancel);
+      context.signal?.addEventListener("abort", onAbort, { once: true });
+      paymentElement.on?.("escape", onCancel);
+      paymentElement.on?.("loaderror", (event) => {
+        if (confirmationStarted) return;
+        settle({
+          status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+          code: ErrorCode.PROVIDER_UNAVAILABLE,
+          message: event?.error?.message || "Stripe Payment Element failed to load.",
+          recoverable: true
+        });
+      });
     });
   }
-  consumeAuthorizationStep(resolutionState) {
-    if (resolutionState.authorizationSteps >= MAX_PAYMENT_AUTHORIZATION_STEPS) {
-      return this.fail(
-        "AUTHORIZATION_LIMIT_EXCEEDED",
-        "The payment provider requested too many authorization steps.",
-        false
-      );
+};
+
+// src/payment-authorization/registry.ts
+function normalizeProvider(provider) {
+  return typeof provider === "string" ? provider.trim().toLowerCase() : "";
+}
+var PaymentAuthorizationAdapterRegistry = class {
+  constructor(adapters = []) {
+    this.adapters = /* @__PURE__ */ new Map();
+    for (const adapter of adapters) {
+      this.register(adapter);
     }
-    resolutionState.authorizationSteps += 1;
-    return void 0;
   }
-  async pollUntilTerminal(input) {
-    const latestCheckoutResult = input.latestCheckoutResult;
-    let paymentReference = input.paymentReference;
-    const { resolutionState } = input;
-    while (resolutionState.pollAttempts < this.maxPollAttempts) {
-      this.ensureNotAborted();
-      const attempt = resolutionState.pollAttempts;
-      resolutionState.pollAttempts += 1;
-      this.emit("polling", {
-        poll_attempt: attempt,
-        max_poll_attempts: this.maxPollAttempts,
-        order_id: input.orderId,
-        order_number: latestCheckoutResult.order_number
-      });
-      const statusResult = await this.client.checkout.pollPaymentStatus(input.orderId);
-      if (!statusResult.ok) {
-        resolutionState.consecutivePollErrors += 1;
-        if (resolutionState.consecutivePollErrors >= MAX_CONSECUTIVE_NETWORK_ERRORS) {
-          return this.fail(
-            "NETWORK_ERROR",
-            "Unable to confirm payment due to repeated network errors.",
-            true
-          );
-        }
-        await this.wait(this.pollIntervalMs);
-        continue;
-      }
-      resolutionState.consecutivePollErrors = 0;
-      if (statusResult.value.reference) {
-        paymentReference = statusResult.value.reference;
-      }
-      const normalized = normalizeStatusResponse(statusResult.value);
-      if (normalized.paid || isPaymentStatusSuccess(normalized.status)) {
-        return this.finalizeSuccess({
-          ...latestCheckoutResult,
-          payment_status: normalized.status,
-          payment_reference: paymentReference || latestCheckoutResult.payment_reference
-        });
-      }
-      if (isPaymentStatusFailure(normalized.status)) {
-        return this.fail(
-          normalized.status ? normalized.status.toUpperCase() : "PAYMENT_FAILED",
-          normalized.message || "Payment failed during confirmation.",
-          false
-        );
-      }
-      if (isPaymentStatusRequiresAction(normalized.status)) {
-        const authorizationType = latestCheckoutResult.authorization_type;
-        const paymentId = latestCheckoutResult.payment_id;
-        if (!authorizationType || !normalizeAuthorizationType(authorizationType) || !paymentId) {
-          return this.fail(
-            "INVALID_AUTHORIZATION_RESPONSE",
-            "The payment provider returned an incomplete authorization response.",
-            false
-          );
-        }
-        return this.resolveNextAction(
-          {
-            ...latestCheckoutResult,
-            payment_status: normalized.status,
-            payment_reference: paymentReference,
-            display_text: normalized.message || latestCheckoutResult.display_text,
-            next_action: {
-              type: NEXT_ACTION_AUTHORIZATION,
-              authorization_type: authorizationType,
-              display_text: normalized.message || latestCheckoutResult.display_text
-            }
-          },
-          resolutionState
-        );
-      }
-      await this.wait(this.pollIntervalMs);
+  register(adapter) {
+    const provider = normalizeProvider(adapter.provider);
+    if (!provider) {
+      throw new TypeError("Payment authorization adapter provider cannot be empty.");
     }
-    return this.fail(
-      "PAYMENT_TIMEOUT",
-      "Payment confirmation timed out. Please retry checkout.",
-      true
-    );
+    this.adapters.set(provider, adapter);
+    return this;
   }
-  async handleAuthorization(input) {
-    const authorizationType = input.authorizationType;
-    const paymentId = input.paymentId;
-    if (!authorizationType || !paymentId) {
-      return {
-        ok: false,
-        result: this.fail(
-          "INVALID_AUTHORIZATION_RESPONSE",
-          "The payment provider returned an incomplete authorization response.",
-          false
-        )
-      };
-    }
-    this.emit("awaiting_authorization", {
-      authorization_type: authorizationType,
-      display_text: input.displayText,
-      provider: input.provider,
-      order_id: input.orderId,
-      order_number: input.orderNumber
-    });
-    let authorizationRequest;
-    const submit = (authorization) => {
-      this.ensureNotAborted();
-      let normalizedAuthorization;
-      try {
-        normalizedAuthorization = normalizeAuthorizationSubmission(
-          authorizationType,
-          authorization
-        );
-      } catch (error) {
-        return Promise.reject(error);
-      }
-      if (!authorizationRequest) {
-        const request = this.client.checkout.submitAuthorization({
-          payment_id: paymentId,
-          authorization: normalizedAuthorization
-        }).then((submitResult) => {
-          if (!submitResult.ok) {
-            throw new Error(submitResult.error.message || "Authorization failed.");
-          }
-          return submitResult.value;
-        });
-        authorizationRequest = request;
-        void request.catch(() => {
-          if (authorizationRequest === request) {
-            authorizationRequest = void 0;
-          }
-        });
-      }
-      return authorizationRequest.then(() => void 0);
-    };
-    try {
-      if (this.onAuthorizationRequired) {
-        await waitForAbortable(
-          Promise.resolve(this.onAuthorizationRequired(authorizationType, submit)),
-          this.signal
-        );
-      } else {
-        return {
-          ok: false,
-          result: this.fail(
-            "AUTHORIZATION_REQUIRED",
-            "Authorization callback is required in headless checkout mode.",
-            false
-          )
-        };
-      }
-      if (!authorizationRequest) {
-        return {
-          ok: false,
-          result: this.fail(
-            "AUTHORIZATION_NOT_SUBMITTED",
-            "The authorization callback returned without submitting a value.",
-            true
-          )
-        };
-      }
-      return {
-        ok: true,
-        value: await waitForAbortable(authorizationRequest, this.signal)
-      };
-    } catch (error) {
-      if (isAbortError(error)) {
-        return {
-          ok: false,
-          result: this.fail("CANCELLED", "Checkout was cancelled.", true)
-        };
-      }
-      const message = error instanceof Error ? error.message : "Payment authorization failed.";
-      return {
-        ok: false,
-        result: this.fail("AUTHORIZATION_FAILED", message, true)
-      };
-    }
+  unregister(provider) {
+    return this.adapters.delete(normalizeProvider(provider));
   }
-  async finalizeSuccess(checkoutResult) {
-    const currency = this.getOrderCurrency(checkoutResult);
-    if (!currency) {
-      return this.fail("INVALID_CURRENCY", "Payment currency is missing or unsupported.", false);
-    }
-    this.emit("finalizing", {
-      order_id: checkoutResult.order_id,
-      order_number: checkoutResult.order_number
-    });
-    const enrolledInLink = await this.maybeEnrollInLink(checkoutResult.order_id);
-    this.emit("success", {
-      order_id: checkoutResult.order_id,
-      order_number: checkoutResult.order_number
-    });
-    return {
-      success: true,
-      order: {
-        id: checkoutResult.order_id,
-        order_number: checkoutResult.order_number || checkoutResult.order_id,
-        status: checkoutResult.payment_status || "paid",
-        total: this.getOrderTotal(checkoutResult),
-        currency
-      },
-      enrolled_in_link: enrolledInLink
-    };
+  get(provider) {
+    return this.adapters.get(normalizeProvider(provider));
   }
-  async maybeEnrollInLink(orderId) {
-    if (!this.enrollInLink || !orderId) {
-      return false;
-    }
-    let businessId = this.businessId;
-    if (!businessId) {
-      const businessResult = await this.client.business.getInfo();
-      if (!businessResult.ok || !businessResult.value?.id) {
-        return false;
-      }
-      businessId = businessResult.value.id;
-    }
-    const address = this.getEnrollmentAddress();
-    const mobileMoney = this.getEnrollmentMobileMoney();
-    try {
-      const enrollment = await this.client.link.enrollAndLinkOrder({
-        order_id: orderId,
-        business_id: businessId,
-        order_type: this.orderType || this.checkoutData.order_type,
-        address,
-        mobile_money: mobileMoney
-      });
-      return enrollment.ok && enrollment.value.success;
-    } catch {
-      return false;
-    }
+  supports(provider) {
+    return this.adapters.has(normalizeProvider(provider));
   }
-  getEnrollmentAddress() {
-    const source = this.addressData ?? this.checkoutData.address_info;
-    if (!source?.street_address) {
-      return void 0;
-    }
-    return {
-      label: "Default",
-      street_address: source.street_address,
-      apartment: source.apartment || void 0,
-      city: source.city || "",
-      region: source.region || "",
-      postal_code: source.postal_code || void 0,
-      country: source.country || void 0,
-      delivery_instructions: source.delivery_instructions || void 0,
-      phone_for_delivery: source.phone_for_delivery || void 0,
-      latitude: source.latitude,
-      longitude: source.longitude
-    };
+  providers() {
+    return [...this.adapters.keys()];
   }
-  getEnrollmentMobileMoney() {
-    if (this.paymentData?.type === PAYMENT_METHOD.MOBILE_MONEY && this.paymentData.phone_number && this.paymentData.provider && isValidMobileMoneyProvider(this.paymentData.provider)) {
+  async authorize(action, options) {
+    const provider = normalizeProvider(action.provider);
+    if (!provider) {
       return {
-        phone_number: this.paymentData.phone_number,
-        provider: this.paymentData.provider,
-        label: this.paymentData.label || "Mobile Money"
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: ErrorCode.PROVIDER_UNAVAILABLE,
+        message: "Card authorization response did not identify a payment provider.",
+        recoverable: false
       };
     }
-    if (this.checkoutData.mobile_money_details?.phone_number) {
+    const adapter = this.adapters.get(provider);
+    if (!adapter) {
       return {
-        phone_number: this.checkoutData.mobile_money_details.phone_number,
-        provider: this.checkoutData.mobile_money_details.provider,
-        label: "Mobile Money"
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: ErrorCode.PROVIDER_UNAVAILABLE,
+        message: `Card authorization provider '${provider}' is not supported by this SDK client.`,
+        recoverable: false
       };
     }
-    return void 0;
-  }
-  getOrderTotal(checkoutResult) {
-    if (checkoutResult.fx?.pay_amount !== void 0) {
-      return formatMoney(checkoutResult.fx.pay_amount);
-    }
-    if (this.cartTotal !== void 0) {
-      return formatMoney(this.cartTotal);
+    try {
+      const normalizedAction = action.provider === provider ? action : { ...action, provider };
+      return await adapter.authorize({ ...options, action: normalizedAction });
+    } catch (error) {
+      return {
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: ErrorCode.PAYMENT_FAILED,
+        message: error instanceof Error ? error.message : `Card authorization provider '${provider}' failed unexpectedly.`,
+        recoverable: true
+      };
     }
-    return "0.00";
   }
-  getOrderCurrency(checkoutResult) {
-    if (checkoutResult.fx?.pay_currency) {
-      const currency2 = checkoutResult.fx.pay_currency.trim().toUpperCase();
-      return isSupportedCurrency(currency2) ? currency2 : void 0;
-    }
-    if (this.checkoutData.pay_currency) {
-      const currency2 = this.checkoutData.pay_currency.trim().toUpperCase();
-      return isSupportedCurrency(currency2) ? currency2 : void 0;
-    }
-    const currency = this.cartCurrency.trim().toUpperCase();
-    return isSupportedCurrency(currency) ? currency : void 0;
+};
+function createDefaultPaymentAuthorizationAdapterRegistry() {
+  return new PaymentAuthorizationAdapterRegistry([
+    new PaystackAuthorizationAdapter(),
+    new StripeAuthorizationAdapter()
+  ]);
+}
+
+// src/utils/purchase-intent-confirmation.ts
+var EXACT_ZERO_MONEY = /^[+-]?0+(?:\.0+)?(?:[eE][+-]?\d+)?$/;
+function isExactlyZeroMoney(value) {
+  if (typeof value === "number") return Object.is(value, 0) || Object.is(value, -0);
+  return EXACT_ZERO_MONEY.test(value.trim());
+}
+function selectPurchaseIntentPaymentOption(terms, selection) {
+  return terms.payment_options.filter((option) => option.status === PAYMENT_OPTION_STATUS.ELIGIBLE).sort((left, right) => left.rank - right.rank).find(
+    (option) => option.method_kind === selection.method_kind && (selection.payment_option_id === void 0 || option.id === selection.payment_option_id)
+  );
+}
+function createPurchaseIntentConfirmation(terms, paymentOption, idempotencyKey) {
+  const normalizedKey = idempotencyKey.trim();
+  if (!normalizedKey) throw new TypeError("idempotencyKey must not be empty");
+  const requiresOption = purchaseIntentRequiresPaymentOption(terms);
+  if (!paymentOption && requiresOption) {
+    throw new TypeError("Nonzero rail terms require an eligible payment option");
+  }
+  if (paymentOption && !requiresOption) {
+    throw new TypeError("Zero-rail terms must not name a payment option");
+  }
+  const authoritativeOption = paymentOption ? terms.payment_options.find(
+    (candidate) => candidate.id === paymentOption.id && candidate.status === PAYMENT_OPTION_STATUS.ELIGIBLE
+  ) : void 0;
+  if (paymentOption && !authoritativeOption) {
+    throw new TypeError("Payment option is not eligible for these checkout terms");
   }
-  emit(status, context = {}) {
-    if (!this.onStatusChange) {
-      return;
+  return {
+    accepted_intent_revision: terms.intent_revision,
+    accepted_terms_version: terms.terms_version,
+    accepted_due_now: terms.money.due_now,
+    // Rail fees and routes may differ by option. Consent is to the exact
+    // server-issued buyer debit, never an ambiguous principal/fee aggregate.
+    accepted_customer_debit_amount: authoritativeOption?.customer_debit_amount ?? terms.money.rail_amount,
+    currency: terms.money.currency,
+    payment_option_id: authoritativeOption?.id ?? null,
+    idempotency_key: normalizedKey
+  };
+}
+function purchaseIntentRequiresPaymentOption(terms) {
+  return terms.payment_options.length > 0 || !isExactlyZeroMoney(terms.money.rail_amount);
+}
+
+// src/utils/purchase-intent-adapter.ts
+function tenderPreference(form) {
+  if (form.payment_method === PURCHASE_INTENT_PAYMENT_METHOD.MOBILE_MONEY) {
+    if (form.link_payment_method_id) {
+      return {
+        method_kind: PURCHASE_INTENT_PAYMENT_METHOD.MOBILE_MONEY,
+        authority: {
+          authority_kind: MOBILE_MONEY_TENDER_AUTHORITY_KIND.SAVED_REFERENCE,
+          stored_instrument_id: form.link_payment_method_id
+        }
+      };
     }
-    try {
-      this.onStatusChange(status, context);
-    } catch {
+    const details = form.mobile_money_details;
+    if (!details?.phone_number || !details.provider) {
+      throw new CimplifyError(
+        ErrorCode.INVALID_PAYMENT_METHOD,
+        "Mobile money requires a phone number and network.",
+        false
+      );
     }
-  }
-  notifyAuthorizationUiChange(open) {
-    try {
-      this.onAuthorizationUiChange?.(open);
-    } catch {
+    const network = purchaseIntentMobileMoneyNetwork(details.provider);
+    if (!network) {
+      throw new CimplifyError(
+        ErrorCode.INVALID_PAYMENT_METHOD,
+        "That mobile money network is not available for PurchaseIntent checkout.",
+        false
+      );
     }
-  }
-  fail(code, message, recoverable) {
-    this.emit("failed", {
-      display_text: message
-    });
     return {
-      success: false,
-      error: {
-        code,
-        message,
-        recoverable
+      method_kind: PURCHASE_INTENT_PAYMENT_METHOD.MOBILE_MONEY,
+      authority: {
+        authority_kind: MOBILE_MONEY_TENDER_AUTHORITY_KIND.TRANSIENT,
+        phone_number: details.phone_number,
+        network
       }
     };
   }
-  isSuccessfulStatus(status) {
-    const normalized = normalizeStatusResponse({ status, paid: false });
-    return normalized.paid || isPaymentStatusSuccess(normalized.status);
+  if (form.payment_method === LEGACY_CHECKOUT_PAYMENT_METHOD_ALIAS.CASH || form.payment_method === PURCHASE_INTENT_PAYMENT_METHOD.OFFLINE) {
+    throw new CimplifyError(
+      ErrorCode.INVALID_PAYMENT_METHOD,
+      "Offline tender requires an authenticated staff checkout.",
+      false
+    );
   }
-  isFailureStatus(status) {
-    const normalized = normalizeStatusResponse({ status, paid: false });
-    return isPaymentStatusFailure(normalized.status);
+  if (form.payment_method === PURCHASE_INTENT_PAYMENT_METHOD.CARD) {
+    return {
+      method_kind: PURCHASE_INTENT_PAYMENT_METHOD.CARD,
+      stored_instrument_id: form.link_payment_method_id
+    };
   }
-  ensureNotAborted() {
-    if (this.signal?.aborted) {
-      throw createAbortError();
-    }
+  if (form.payment_method === LEGACY_CHECKOUT_PAYMENT_METHOD_ALIAS.STORE_CREDIT) {
+    return void 0;
   }
-  wait(ms) {
-    this.ensureNotAborted();
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        if (this.signal) {
-          this.signal.removeEventListener("abort", onAbort);
+  throw new CimplifyError(
+    ErrorCode.INVALID_PAYMENT_METHOD,
+    "Checkout payment method is not supported.",
+    false
+  );
+}
+function checkoutFormToIntentRequest(form, clientIntentKey) {
+  return {
+    client_intent_key: clientIntentKey,
+    source: { kind: PURCHASE_INTENT_SOURCE_KIND.CART, cart_id: form.cart_id },
+    checkout: {
+      customer: form.customer,
+      order_type: form.order_type,
+      address_info: form.address_info,
+      location_id: form.location_id,
+      delivery_rate_id: form.delivery_rate_id,
+      special_instructions: form.special_instructions,
+      link_address_id: form.link_address_id,
+      metadata: form.metadata,
+      pay_currency: form.pay_currency,
+      fx_quote_id: form.fx_quote_id,
+      use_store_credit: form.use_store_credit || form.payment_method === LEGACY_CHECKOUT_PAYMENT_METHOD_ALIAS.STORE_CREDIT,
+      voucher_code: form.voucher_code,
+      pay_deposit: form.pay_deposit,
+      tender_preference: tenderPreference(form)
+    }
+  };
+}
+function selectCheckoutPaymentOption(terms, form) {
+  const preference = tenderPreference(form);
+  if (!preference) return void 0;
+  return terms.payment_options.filter((option) => option.status === PAYMENT_OPTION_STATUS.ELIGIBLE).sort((left, right) => left.rank - right.rank).find((option) => option.method_kind === preference.method_kind);
+}
+function checkoutFormToConfirmation(_form, terms, paymentOption, idempotencyKey) {
+  return createPurchaseIntentConfirmation(terms, paymentOption, idempotencyKey);
+}
+function committedBase(response) {
+  return {
+    intent_id: response.intent_id,
+    attempt_id: response.attempt_id,
+    order_id: response.order_id,
+    order_number: response.order_number || response.order_id,
+    payment_id: response.payment_id
+  };
+}
+function confirmationToCheckoutResult(response) {
+  switch (response.status) {
+    case PURCHASE_INTENT_CONFIRM_STATUS.ORDER_CREATED:
+      return ok({
+        ...committedBase(response),
+        payment_status: LEGACY_CHECKOUT_PAYMENT_STATUS.SUCCEEDED,
+        requires_authorization: false,
+        next_action: { type: CHECKOUT_NEXT_ACTION.NONE }
+      });
+    case PURCHASE_INTENT_CONFIRM_STATUS.COLLECTION_PROCESSING:
+      return ok({
+        ...committedBase(response),
+        payment_status: LEGACY_CHECKOUT_PAYMENT_STATUS.PROCESSING,
+        requires_authorization: false,
+        next_action: { type: CHECKOUT_NEXT_ACTION.POLL }
+      });
+    case PURCHASE_INTENT_CONFIRM_STATUS.PAYMENT_OUTCOME_UNKNOWN:
+      return ok({
+        ...committedBase(response),
+        payment_status: LEGACY_CHECKOUT_PAYMENT_STATUS.UNKNOWN,
+        requires_authorization: false,
+        next_action: { type: CHECKOUT_NEXT_ACTION.POLL }
+      });
+    case PURCHASE_INTENT_CONFIRM_STATUS.PAYMENT_FAILED:
+      return err(
+        new CimplifyError(
+          PURCHASE_INTENT_ERROR_CODE.PAYMENT_FAILED,
+          "Payment failed. The order remains recorded, but collection did not succeed.",
+          true
+        )
+      );
+    case PURCHASE_INTENT_CONFIRM_STATUS.REDIRECT_REQUIRED:
+      return ok({
+        ...committedBase(response),
+        payment_status: LEGACY_CHECKOUT_PAYMENT_STATUS.REQUIRES_ACTION,
+        requires_authorization: false,
+        authorization_url: response.authorization_url,
+        next_action: {
+          type: CHECKOUT_NEXT_ACTION.REDIRECT,
+          authorization_url: response.authorization_url
         }
-        resolve();
-      }, ms);
-      const onAbort = () => {
-        clearTimeout(timer);
-        reject(createAbortError());
-      };
-      if (this.signal) {
-        this.signal.addEventListener("abort", onAbort, { once: true });
-      }
-    });
+      });
+    case PURCHASE_INTENT_CONFIRM_STATUS.CARD_POPUP_REQUIRED:
+      return ok({
+        ...committedBase(response),
+        payment_status: LEGACY_CHECKOUT_PAYMENT_STATUS.REQUIRES_ACTION,
+        requires_authorization: false,
+        provider: response.provider,
+        client_secret: response.client_secret,
+        public_key: response.public_key,
+        next_action: {
+          type: CHECKOUT_NEXT_ACTION.CARD_POPUP,
+          provider: response.provider,
+          client_secret: response.client_secret,
+          public_key: response.public_key,
+          provider_account_id: response.provider_account_id ?? void 0
+        }
+      });
+    case PURCHASE_INTENT_CONFIRM_STATUS.AUTHORIZATION_REQUIRED:
+      return ok({
+        ...committedBase(response),
+        payment_status: LEGACY_CHECKOUT_PAYMENT_STATUS.REQUIRES_ACTION,
+        requires_authorization: true,
+        authorization_type: response.authorization_type,
+        display_text: response.display_text,
+        next_action: {
+          type: CHECKOUT_NEXT_ACTION.AUTHORIZATION,
+          authorization_type: response.authorization_type,
+          display_text: response.display_text
+        }
+      });
+    case PURCHASE_INTENT_CONFIRM_STATUS.TERMS_CHANGED:
+      return err(
+        new CimplifyError(
+          PURCHASE_INTENT_ERROR_CODE.TERMS_CHANGED,
+          "Checkout terms changed. Review the replacement terms before confirming again.",
+          true
+        )
+      );
+    case PURCHASE_INTENT_CONFIRM_STATUS.SELECTION_UNAVAILABLE:
+      return err(
+        new CimplifyError(
+          PURCHASE_INTENT_ERROR_CODE.SELECTION_UNAVAILABLE,
+          "One or more checkout selections are no longer available.",
+          true
+        )
+      );
+    case PURCHASE_INTENT_CONFIRM_STATUS.OFFER_ENDED:
+      return err(
+        new CimplifyError(
+          PURCHASE_INTENT_ERROR_CODE.OFFER_ENDED,
+          "This offer has ended.",
+          false
+        )
+      );
+    case PURCHASE_INTENT_CONFIRM_STATUS.SOURCE_UNAVAILABLE:
+      return err(
+        new CimplifyError(
+          PURCHASE_INTENT_ERROR_CODE.SOURCE_UNAVAILABLE,
+          "This purchase source is unavailable.",
+          false
+        )
+      );
   }
-};
+}
 
 // src/checkout.ts
+function checkoutActionAuthority(response) {
+  if (response.status !== PURCHASE_INTENT_CONFIRM_STATUS.CARD_POPUP_REQUIRED && response.status !== PURCHASE_INTENT_CONFIRM_STATUS.AUTHORIZATION_REQUIRED) {
+    return null;
+  }
+  const paymentId = response.payment_id?.trim();
+  return paymentId ? {
+    intentId: response.intent_id,
+    attemptId: response.attempt_id,
+    paymentId
+  } : null;
+}
+function isAmbiguousCheckoutError(error) {
+  return error.code === ErrorCode.NETWORK_ERROR || error.code === ErrorCode.TIMEOUT;
+}
+function authorizationKind(value) {
+  if (value && typeof value === "object" && AUTHORIZATION_TYPE.ADDRESS in value) {
+    return AUTHORIZATION_TYPE.ADDRESS;
+  }
+  if (value === AUTHORIZATION_TYPE.OTP || value === AUTHORIZATION_TYPE.PIN || value === AUTHORIZATION_TYPE.PHONE || value === AUTHORIZATION_TYPE.BIRTHDAY) {
+    return value;
+  }
+  return void 0;
+}
+function normalizeAuthorizationSubmission(expected, submission) {
+  if (submission.type !== expected) throw new Error(`Expected ${expected} authorization details.`);
+  if (submission.type === AUTHORIZATION_TYPE.ADDRESS) {
+    const address = submission.address.trim();
+    const city = submission.city.trim();
+    const state = submission.state.trim();
+    const zipCode = submission.zip_code.trim();
+    if (!address || !city || !state || !zipCode) {
+      throw new Error("Complete all authorization address fields.");
+    }
+    return { type: AUTHORIZATION_TYPE.ADDRESS, address, city, state, zip_code: zipCode };
+  }
+  const value = submission.value.trim();
+  if (!value) throw new Error("Authorization value is required.");
+  return { type: submission.type, value };
+}
+var DECIMAL_WIRE_VALUE = /^([+-]?)(\d+)(?:\.(\d+))?(?:[eE][+-]?\d+)?$/;
+function decimalSign(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return null;
+    if (Object.is(value, 0) || Object.is(value, -0)) return 0;
+    return value > 0 ? 1 : -1;
+  }
+  const match = DECIMAL_WIRE_VALUE.exec(value.trim());
+  if (!match) return null;
+  const nonzero = [...match[2], ...match[3] ?? ""].some((digit) => digit !== "0");
+  if (!nonzero) return 0;
+  return match[1] === "-" ? -1 : 1;
+}
 function toTerminalFailure(code, message, recoverable) {
   return {
     success: false,
@@ -1497,7 +1590,7 @@ function isValidCustomerName(name) {
   return trimmed.length >= 2 && /\p{L}/u.test(trimmed);
 }
 function isOfflinePaymentMethod(method) {
-  return method === "cash" || method === "offline";
+  return method === LEGACY_CHECKOUT_PAYMENT_METHOD_ALIAS.CASH || method === PURCHASE_INTENT_PAYMENT_METHOD.OFFLINE;
 }
 function notifyCheckoutStatus(observer, status, context = {}) {
   try {
@@ -1505,7 +1598,35 @@ function notifyCheckoutStatus(observer, status, context = {}) {
   } catch {
   }
 }
+function notifyAuthorizationUi(observer, open) {
+  try {
+    observer?.(open);
+  } catch {
+  }
+}
 var MAX_STOREFRONT_COLLECTION_OPTIONS = 32;
+var CHECKOUT_INTENT_SCOPE_PREFIX = "checkout:";
+var CHECKOUT_CONFIRMATION_SCOPE_PREFIX = "checkout-confirm:";
+var CHECKOUT_INTENT_RECOVERY_FINGERPRINT = "cart-intent-v1";
+var ABORT_ERROR_NAME = "AbortError";
+var AUTHORIZATION_POPUP_NAME = "cimplify-auth";
+var AUTHORIZATION_POPUP_FEATURES = "width=520,height=760,noopener,noreferrer";
+var ORDER_TOKEN_QUERY_PARAMETER = "token";
+var CHECKOUT_API_ROUTE = {
+  COLLECTION_OPTIONS: "/api/v1/payments/collection-options",
+  paymentStatus: (orderId) => `/api/v1/orders/${orderId}/payment-status`,
+  updateCustomer: (orderId) => `/api/v1/orders/${orderId}/customer`,
+  verifyPayment: (orderId) => `/api/v1/orders/${orderId}/verify-payment`
+};
+var CHECKOUT_STATUS_BY_PURCHASE_INTENT_RESOLVE_STATUS = {
+  [PURCHASE_INTENT_RESOLVE_STATUS.CONFIRMING]: CHECKOUT_STATUS.PROCESSING,
+  [PURCHASE_INTENT_RESOLVE_STATUS.POLLING]: CHECKOUT_STATUS.POLLING,
+  [PURCHASE_INTENT_RESOLVE_STATUS.AWAITING_ACTION]: CHECKOUT_STATUS.AWAITING_AUTHORIZATION,
+  [PURCHASE_INTENT_RESOLVE_STATUS.REVIEWING_TERMS]: CHECKOUT_STATUS.REVIEWING_TERMS,
+  [PURCHASE_INTENT_RESOLVE_STATUS.COMPLETED]: CHECKOUT_STATUS.FINALIZING,
+  [PURCHASE_INTENT_RESOLVE_STATUS.FAILED]: CHECKOUT_STATUS.FAILED,
+  [PURCHASE_INTENT_RESOLVE_STATUS.OUTCOME_UNKNOWN]: CHECKOUT_STATUS.RECOVERING
+};
 function normalizeCollectionOptions(value, expectedCurrency) {
   if (!value || typeof value !== "object") return null;
   const response = value;
@@ -1528,7 +1649,8 @@ function normalizeCollectionOptions(value, expectedCurrency) {
     if (option.method !== PAYMENT_METHOD.MOBILE_MONEY || typeof option.network !== "string" || !option.network.trim()) {
       continue;
     }
-    const network = option.network.trim().toLowerCase();
+    const network = purchaseIntentMobileMoneyNetwork(option.network);
+    if (!network) continue;
     const key = `${PAYMENT_METHOD.MOBILE_MONEY}:${network}`;
     if (seen.has(key)) continue;
     seen.add(key);
@@ -1539,18 +1661,22 @@ function normalizeCollectionOptions(value, expectedCurrency) {
 var CheckoutService = class {
   constructor(client) {
     this.client = client;
+    /** Raw checkout material is component-lifetime only, never browser storage. */
+    this.intentCommands = /* @__PURE__ */ new Map();
+    /** Opaque owner/attempt authority for deprecated action submission. */
+    this.actionAuthorities = /* @__PURE__ */ new Map();
   }
   validateCheckoutData(data) {
     if (isOfflinePaymentMethod(data.payment_method)) {
       return new CimplifyError(
-        "INVALID_PAYMENT_METHOD",
+        ErrorCode.INVALID_PAYMENT_METHOD,
         "Offline payment isn't available for online checkout. Please pay by card or mobile money.",
         false
       );
     }
     if (!isValidCustomerName(data.customer?.name)) {
       return new CimplifyError(
-        "INVALID_CUSTOMER_NAME",
+        ErrorCode.INVALID_CUSTOMER_NAME,
         "Enter your name, not a phone number.",
         false
       );
@@ -1559,7 +1685,7 @@ var CheckoutService = class {
   }
   orderTokenParam(orderId) {
     const token = this.client.getOrderToken(orderId);
-    return token ? `?token=${encodeURIComponent(token)}` : "";
+    return token ? `?${ORDER_TOKEN_QUERY_PARAMETER}=${encodeURIComponent(token)}` : "";
   }
   /** Available storefront collection methods for one presentment currency. */
   async collectionOptions(currency) {
@@ -1575,7 +1701,7 @@ var CheckoutService = class {
     }
     const response = await safe(
       this.client.get(
-        `/api/v1/payments/collection-options?currency=${encodeURIComponent(normalized)}`
+        `${CHECKOUT_API_ROUTE.COLLECTION_OPTIONS}?currency=${encodeURIComponent(normalized)}`
       )
     );
     if (!response.ok) return response;
@@ -1595,52 +1721,181 @@ var CheckoutService = class {
   authorizeCardPopup(action, options) {
     return this.client.authorizationAdapters.authorize(action, options);
   }
-  async process(data) {
+  async startIntentCheckout(data, options) {
     const invalid = this.validateCheckoutData(data);
-    if (invalid) {
-      return err(invalid);
-    }
-    const intentScope = `checkout:${data.cart_id}`;
-    const intentFingerprint = JSON.stringify([
-      data.payment_method,
-      data.mobile_money_details,
-      data.pay_currency,
-      data.voucher_code,
-      data.pay_deposit
-    ]);
-    const checkoutData = {
-      ...data,
-      idempotency_key: data.idempotency_key || intentIdempotencyKey(intentScope, intentFingerprint)
-    };
-    const result = await safe(this.client.post("/api/v1/checkout", checkoutData));
-    if (result.ok) {
+    if (invalid) return err(invalid);
+    const intentScope = `${CHECKOUT_INTENT_SCOPE_PREFIX}${data.cart_id}`;
+    const inMemoryCommand = JSON.stringify(data);
+    const previousCommand = this.intentCommands.get(intentScope);
+    if (previousCommand !== void 0 && previousCommand !== inMemoryCommand) {
+      clearIntentIdempotencyKey(intentScope);
+    }
+    this.intentCommands.set(intentScope, inMemoryCommand);
+    const clientIntentKey = data.idempotency_key || intentIdempotencyKey(intentScope, CHECKOUT_INTENT_RECOVERY_FINGERPRINT);
+    const checkoutData = { ...data, idempotency_key: clientIntentKey };
+    let mintRequest;
+    try {
+      mintRequest = checkoutFormToIntentRequest(checkoutData, clientIntentKey);
+    } catch (error) {
       clearIntentIdempotencyKey(intentScope);
-      if (result.value.bill_token) {
-        this.client.setOrderToken(result.value.order_id, result.value.bill_token);
+      this.intentCommands.delete(intentScope);
+      return err(
+        error instanceof CimplifyError ? error : new CimplifyError(
+          ErrorCode.CHECKOUT_VALIDATION_FAILED,
+          "Checkout details are invalid.",
+          false
+        )
+      );
+    }
+    const minted = await this.client.purchaseIntents.mint(mintRequest, options);
+    if (!minted.ok) {
+      if (!isAmbiguousCheckoutError(minted.error)) {
+        clearIntentIdempotencyKey(intentScope);
+        this.intentCommands.delete(intentScope);
       }
-    } else if (result.error.code !== ErrorCode.NETWORK_ERROR && result.error.code !== ErrorCode.TIMEOUT) {
+      return minted;
+    }
+    const terms = minted.value.current_terms;
+    if (!terms) {
       clearIntentIdempotencyKey(intentScope);
+      this.intentCommands.delete(intentScope);
+      return err(
+        new CimplifyError(
+          ErrorCode.CHECKOUT_TERMS_UNAVAILABLE,
+          "Checkout terms are not available for this purchase intent.",
+          true
+        )
+      );
+    }
+    let paymentOption;
+    try {
+      paymentOption = selectCheckoutPaymentOption(terms, checkoutData);
+    } catch (error) {
+      return err(
+        error instanceof CimplifyError ? error : new CimplifyError(
+          ErrorCode.INVALID_PAYMENT_METHOD,
+          "Payment details are invalid.",
+          false
+        )
+      );
+    }
+    if (!paymentOption && purchaseIntentRequiresPaymentOption(terms)) {
+      return err(
+        new CimplifyError(
+          ErrorCode.PAYMENT_CAPABILITY_MISMATCH,
+          "The selected payment method is not eligible for these checkout terms.",
+          true
+        )
+      );
+    }
+    const confirmationScope = `${CHECKOUT_CONFIRMATION_SCOPE_PREFIX}${minted.value.id}`;
+    const confirmationFingerprint = JSON.stringify([
+      terms.intent_revision,
+      terms.terms_version,
+      terms.terms_digest,
+      paymentOption?.id ?? null,
+      terms.money.due_now,
+      paymentOption?.customer_debit_amount ?? terms.money.rail_amount,
+      terms.money.currency
+    ]);
+    const confirmationKey = intentIdempotencyKey(
+      confirmationScope,
+      confirmationFingerprint
+    );
+    const confirmation = checkoutFormToConfirmation(
+      checkoutData,
+      terms,
+      paymentOption,
+      confirmationKey
+    );
+    const confirmed = await this.client.purchaseIntents.confirm(
+      minted.value.id,
+      confirmation,
+      options
+    );
+    if (!confirmed.ok) {
+      if (!isAmbiguousCheckoutError(confirmed.error)) {
+        clearIntentIdempotencyKey(confirmationScope);
+      }
+      return confirmed;
+    }
+    return ok({
+      intentId: minted.value.id,
+      intentScope,
+      confirmationScope,
+      confirmation,
+      initialResponse: confirmed.value,
+      terms
+    });
+  }
+  /** @deprecated Use `client.purchaseIntents.mint()` then `confirm()`. */
+  async process(data, options) {
+    const started = await this.startIntentCheckout(data, options);
+    if (!started.ok) return started;
+    this.reconcileActionAuthority(started.value.initialResponse);
+    const result = confirmationToCheckoutResult(started.value.initialResponse);
+    if (started.value.initialResponse.status === PURCHASE_INTENT_CONFIRM_STATUS.ORDER_CREATED || started.value.initialResponse.status === PURCHASE_INTENT_CONFIRM_STATUS.PAYMENT_FAILED) {
+      clearIntentIdempotencyKey(started.value.intentScope);
+      clearIntentIdempotencyKey(started.value.confirmationScope);
+      this.intentCommands.delete(started.value.intentScope);
     }
     return result;
   }
   async initializePayment(_orderId, _method) {
     return err(
       new CimplifyError(
-        "NOT_IMPLEMENTED",
+        ErrorCode.NOT_IMPLEMENTED,
         "initializePayment is not available in REST mode.",
         false
       )
     );
   }
-  async submitAuthorization(input) {
-    return safe(this.client.post("/api/v1/payments/authorization", input));
+  /**
+   * @deprecated Use `client.purchaseIntents.submitAction()`. This adapter works
+   * only while this CheckoutService instance retains the opaque authority
+   * returned by its own `process()` call; it never falls back to a payment-id
+   * mutation.
+   */
+  async submitAuthorization(input, options) {
+    const paymentId = input.payment_id.trim();
+    const authority = this.actionAuthorities.get(paymentId);
+    if (!authority) {
+      return err(
+        new CimplifyError(
+          ErrorCode.CHECKOUT_AUTHORITY_REQUIRED,
+          "The purchase-intent action authority is unavailable. Restart checkout before submitting authorization.",
+          false
+        )
+      );
+    }
+    const submitted = await this.client.purchaseIntents.submitAction(
+      authority.intentId,
+      authority.attemptId,
+      { authorization: input.authorization },
+      {
+        signal: options?.signal,
+        timeoutMs: options?.timeoutMs
+      }
+    );
+    if (!submitted.ok) return submitted;
+    this.reconcileActionAuthority(submitted.value, paymentId);
+    return confirmationToCheckoutResult(submitted.value);
+  }
+  reconcileActionAuthority(response, previousPaymentId) {
+    if (previousPaymentId) this.actionAuthorities.delete(previousPaymentId);
+    if ("payment_id" in response && typeof response.payment_id === "string" && response.payment_id.trim()) {
+      this.actionAuthorities.delete(response.payment_id.trim());
+    }
+    const authority = checkoutActionAuthority(response);
+    if (authority) this.actionAuthorities.set(authority.paymentId, authority);
   }
-  async pollPaymentStatus(orderId) {
+  async pollPaymentStatus(orderId, options) {
     const encodedId = encodeURIComponent(orderId);
     const tokenParam = this.orderTokenParam(orderId);
     return safe(
       this.client.get(
-        `/api/v1/orders/${encodedId}/payment-status${tokenParam}`
+        `${CHECKOUT_API_ROUTE.paymentStatus(encodedId)}${tokenParam}`,
+        options
       )
     );
   }
@@ -1648,20 +1903,58 @@ var CheckoutService = class {
     const encodedId = encodeURIComponent(orderId);
     const tokenParam = this.orderTokenParam(orderId);
     return safe(
-      this.client.post(`/api/v1/orders/${encodedId}/customer${tokenParam}`, customer)
+      this.client.post(`${CHECKOUT_API_ROUTE.updateCustomer(encodedId)}${tokenParam}`, customer)
     );
   }
   async verifyPayment(orderId) {
     const encodedId = encodeURIComponent(orderId);
     const tokenParam = this.orderTokenParam(orderId);
-    return safe(this.client.post(`/api/v1/orders/${encodedId}/verify-payment${tokenParam}`));
+    return safe(
+      this.client.post(`${CHECKOUT_API_ROUTE.verifyPayment(encodedId)}${tokenParam}`)
+    );
   }
+  async maybeEnrollResolvedOrder(orderId, data) {
+    if (data.enroll_in_link === false) return false;
+    const business = await safe(this.client.resolveBusinessId());
+    if (!business.ok) return false;
+    const address = data.address_info.street_address ? {
+      label: "Default",
+      street_address: data.address_info.street_address,
+      apartment: data.address_info.apartment,
+      city: data.address_info.city ?? "",
+      region: data.address_info.region ?? "",
+      postal_code: data.address_info.postal_code,
+      country: data.address_info.country,
+      delivery_instructions: data.address_info.delivery_instructions,
+      phone_for_delivery: data.address_info.phone_for_delivery,
+      latitude: data.address_info.latitude,
+      longitude: data.address_info.longitude
+    } : void 0;
+    const mobileMoney = data.payment_method === PAYMENT_METHOD.MOBILE_MONEY && data.mobile_money_details ? {
+      phone_number: data.mobile_money_details.phone_number,
+      provider: data.mobile_money_details.provider,
+      label: "Mobile Money"
+    } : void 0;
+    try {
+      const enrollment = await this.client.link.enrollAndLinkOrder({
+        order_id: orderId,
+        business_id: business.value,
+        order_type: data.order_type,
+        address,
+        mobile_money: mobileMoney
+      });
+      return enrollment.ok && enrollment.value.success;
+    } catch {
+      return false;
+    }
+  }
+  /** @deprecated Use `client.purchaseIntents.resolve()`. */
   async processAndResolve(data) {
-    notifyCheckoutStatus(data.on_status_change, "preparing");
+    notifyCheckoutStatus(data.on_status_change, CHECKOUT_STATUS.PREPARING);
     if (!data.cart_id) {
       return ok(
         toTerminalFailure(
-          "INVALID_CART",
+          ErrorCode.INVALID_CART,
           "A valid cart is required before checkout can start.",
           false
         )
@@ -1669,13 +1962,19 @@ var CheckoutService = class {
     }
     const cartResult = await this.client.cart.get();
     if (!cartResult.ok || !cartResult.value?.id) {
-      return ok(toTerminalFailure("INVALID_CART", "Unable to load cart for checkout.", false));
+      return ok(
+        toTerminalFailure(
+          ErrorCode.INVALID_CART,
+          "Unable to load cart for checkout.",
+          false
+        )
+      );
     }
     const cart = cartResult.value;
     if (cart.id !== data.cart_id || cart.items.length === 0) {
       return ok(
         toTerminalFailure(
-          "INVALID_CART",
+          ErrorCode.INVALID_CART,
           "Cart is empty or no longer valid. Please refresh and try again.",
           false
         )
@@ -1705,7 +2004,7 @@ var CheckoutService = class {
     if (!isSupportedCurrency(rawBaseCurrency)) {
       return ok(
         toTerminalFailure(
-          "INVALID_CURRENCY",
+          ErrorCode.UNSUPPORTED_CURRENCY,
           "Cart currency is missing or unsupported. Refresh the cart before checkout.",
           false
         )
@@ -1716,15 +2015,24 @@ var CheckoutService = class {
     if (payCurrency && !isSupportedCurrency(payCurrency)) {
       return ok(
         toTerminalFailure(
-          "INVALID_CURRENCY",
+          ErrorCode.UNSUPPORTED_CURRENCY,
           "Payment currency is unsupported for checkout.",
           false
         )
       );
     }
     const payCurrencyCode = payCurrency && isSupportedCurrency(payCurrency) ? payCurrency : void 0;
-    const cartTotalAmount = typeof cart.pricing.total_price === "number" ? cart.pricing.total_price : Number.parseFloat(cart.pricing.total_price || "0");
-    if (payCurrencyCode && payCurrencyCode !== baseCurrency && !checkoutData.fx_quote_id && Number.isFinite(cartTotalAmount) && cartTotalAmount > 0) {
+    const cartTotalSign = decimalSign(cart.pricing.total_price);
+    if (cartTotalSign === null || cartTotalSign < 0) {
+      return ok(
+        toTerminalFailure(
+          ErrorCode.CHECKOUT_VALIDATION_FAILED,
+          "Cart total is not a valid non-negative decimal amount.",
+          false
+        )
+      );
+    }
+    if (payCurrencyCode && payCurrencyCode !== baseCurrency && !checkoutData.fx_quote_id && cartTotalSign > 0) {
       const fxQuoteResult = await this.client.fx.lockQuote({
         from: baseCurrency,
         to: payCurrencyCode,
@@ -1733,7 +2041,7 @@ var CheckoutService = class {
       if (!fxQuoteResult.ok) {
         return ok(
           toTerminalFailure(
-            "FX_QUOTE_FAILED",
+            ErrorCode.FX_QUOTE_FAILED,
             fxQuoteResult.error.message || "Unable to lock FX quote for checkout.",
             true
           )
@@ -1742,35 +2050,266 @@ var CheckoutService = class {
       checkoutData.pay_currency = payCurrencyCode;
       checkoutData.fx_quote_id = fxQuoteResult.value.id;
     }
-    notifyCheckoutStatus(data.on_status_change, "processing");
-    const processResult = await this.process(checkoutData);
-    if (!processResult.ok) {
+    notifyCheckoutStatus(data.on_status_change, CHECKOUT_STATUS.PROCESSING);
+    const started = await this.startIntentCheckout(checkoutData, { signal: data.signal });
+    if (!started.ok) {
       return ok(
         toTerminalFailure(
-          processResult.error.code || "CHECKOUT_FAILED",
-          processResult.error.message || "Unable to process checkout.",
-          processResult.error.retryable ?? true
+          started.error.code || ErrorCode.CHECKOUT_FAILED,
+          started.error.message || "Unable to process checkout.",
+          started.error.retryable ?? true
+        )
+      );
+    }
+    let actionFailure;
+    try {
+      const resolved = await this.client.purchaseIntents.resolve(started.value.intentId, {
+        confirmation: started.value.confirmation,
+        initialResponse: started.value.initialResponse,
+        pollIntervalMs: data.poll_interval_ms,
+        maxPollAttempts: data.max_poll_attempts,
+        signal: data.signal,
+        onStatusChange: (status, response) => {
+          const context = {};
+          if (response && "order_id" in response) context.order_id = response.order_id;
+          if (response?.status === PURCHASE_INTENT_CONFIRM_STATUS.TERMS_CHANGED) {
+            context.replacement_terms = response.replacement;
+            context.terms_deltas = response.deltas;
+          }
+          if (response?.status === PURCHASE_INTENT_CONFIRM_STATUS.SELECTION_UNAVAILABLE) {
+            context.unavailable_lines = response.lines;
+          }
+          const checkoutStatus = CHECKOUT_STATUS_BY_PURCHASE_INTENT_RESOLVE_STATUS[status];
+          notifyCheckoutStatus(data.on_status_change, checkoutStatus, context);
+        },
+        onActionRequired: async (action) => {
+          switch (action.status) {
+            case PURCHASE_INTENT_CONFIRM_STATUS.CARD_POPUP_REQUIRED: {
+              const allowPopups = data.allow_popups ?? typeof window !== "undefined";
+              if (!allowPopups) {
+                actionFailure = {
+                  code: ErrorCode.PROVIDER_UNAVAILABLE,
+                  message: "Card authorization UI is unavailable in this environment.",
+                  recoverable: false
+                };
+                return PURCHASE_INTENT_ACTION_DECISION.STOP;
+              }
+              let outcome;
+              try {
+                notifyAuthorizationUi(data.on_authorization_ui_change, true);
+                outcome = await this.authorizeCardPopup(
+                  {
+                    type: CHECKOUT_NEXT_ACTION.CARD_POPUP,
+                    provider: action.provider,
+                    client_secret: action.client_secret,
+                    public_key: action.public_key,
+                    provider_account_id: action.provider_account_id ?? void 0
+                  },
+                  {
+                    email: checkoutData.customer.email,
+                    currency: started.value.terms.money.currency,
+                    returnUrl: data.return_url,
+                    signal: data.signal
+                  }
+                );
+              } finally {
+                notifyAuthorizationUi(data.on_authorization_ui_change, false);
+              }
+              if (outcome.status === PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED) {
+                return PURCHASE_INTENT_ACTION_DECISION.CONTINUE;
+              }
+              actionFailure = outcome.status === PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED ? {
+                code: ErrorCode.PAYMENT_CANCELLED,
+                message: "Card payment was cancelled before submission.",
+                recoverable: true
+              } : {
+                code: outcome.code,
+                message: outcome.message,
+                recoverable: outcome.recoverable
+              };
+              return PURCHASE_INTENT_ACTION_DECISION.STOP;
+            }
+            case PURCHASE_INTENT_CONFIRM_STATUS.REDIRECT_REQUIRED: {
+              const authorizationUrl = paymentAuthorizationUrl(action.authorization_url);
+              if (!authorizationUrl) {
+                actionFailure = {
+                  code: ErrorCode.AUTHORIZATION_FAILED,
+                  message: "The provider returned an invalid authorization URL.",
+                  recoverable: false
+                };
+                return PURCHASE_INTENT_ACTION_DECISION.STOP;
+              }
+              if (typeof window !== "undefined") {
+                if (data.allow_popups === false) {
+                  window.location.assign(authorizationUrl);
+                } else {
+                  const popup = window.open(
+                    authorizationUrl,
+                    AUTHORIZATION_POPUP_NAME,
+                    AUTHORIZATION_POPUP_FEATURES
+                  );
+                  if (!popup) {
+                    actionFailure = {
+                      code: ErrorCode.POPUP_BLOCKED,
+                      message: "Authorization popup was blocked.",
+                      recoverable: true
+                    };
+                    return PURCHASE_INTENT_ACTION_DECISION.STOP;
+                  }
+                }
+              }
+              actionFailure = {
+                code: ErrorCode.REDIRECT_REQUIRED,
+                message: "Complete authorization at the payment provider, then resume checkout.",
+                recoverable: true
+              };
+              return PURCHASE_INTENT_ACTION_DECISION.STOP;
+            }
+            case PURCHASE_INTENT_CONFIRM_STATUS.AUTHORIZATION_REQUIRED: {
+              const expected = authorizationKind(action.authorization_type);
+              if (!expected || !data.on_authorization_required) {
+                actionFailure = {
+                  code: ErrorCode.AUTHORIZATION_REQUIRED,
+                  message: "Additional payment authorization is required.",
+                  recoverable: true
+                };
+                return PURCHASE_INTENT_ACTION_DECISION.STOP;
+              }
+              let submission;
+              await data.on_authorization_required(expected, async (candidate) => {
+                if (submission) throw new Error("Authorization was already submitted.");
+                submission = normalizeAuthorizationSubmission(expected, candidate);
+              });
+              if (!submission) {
+                actionFailure = {
+                  code: ErrorCode.AUTHORIZATION_REQUIRED,
+                  message: "Payment authorization was not submitted.",
+                  recoverable: true
+                };
+                return PURCHASE_INTENT_ACTION_DECISION.STOP;
+              }
+              return {
+                kind: PURCHASE_INTENT_ACTION_DECISION.SUBMIT,
+                request: { authorization: submission }
+              };
+            }
+          }
+        }
+      });
+      if (!resolved.ok) {
+        return ok(
+          toTerminalFailure(
+            resolved.error.code || ErrorCode.CHECKOUT_FAILED,
+            resolved.error.message || "Unable to resolve checkout.",
+            resolved.error.retryable ?? true
+          )
+        );
+      }
+      switch (resolved.value.kind) {
+        case PURCHASE_INTENT_RESOLUTION_KIND.COMPLETED: {
+          clearIntentIdempotencyKey(started.value.intentScope);
+          clearIntentIdempotencyKey(started.value.confirmationScope);
+          const response = resolved.value.response;
+          notifyCheckoutStatus(data.on_status_change, CHECKOUT_STATUS.FINALIZING, {
+            order_id: response.order_id
+          });
+          const enrolledInLink = await this.maybeEnrollResolvedOrder(response.order_id, data);
+          notifyCheckoutStatus(data.on_status_change, CHECKOUT_STATUS.SUCCESS, {
+            order_id: response.order_id
+          });
+          return ok({
+            success: true,
+            order: {
+              id: response.order_id,
+              order_number: response.order_number ?? response.order_id,
+              status: CHECKOUT_ORDER_RESULT_STATUS.CONFIRMED,
+              total: String(cart.pricing.total_price),
+              currency: started.value.terms.money.currency
+            },
+            enrolled_in_link: enrolledInLink
+          });
+        }
+        case PURCHASE_INTENT_RESOLUTION_KIND.FAILED:
+          clearIntentIdempotencyKey(started.value.confirmationScope);
+          return ok(
+            toTerminalFailure(
+              PURCHASE_INTENT_ERROR_CODE.PAYMENT_FAILED,
+              "Payment failed. Choose another method or retry collection.",
+              true
+            )
+          );
+        case PURCHASE_INTENT_RESOLUTION_KIND.OUTCOME_UNKNOWN:
+          return ok(
+            toTerminalFailure(
+              ErrorCode.PAYMENT_OUTCOME_UNKNOWN,
+              "Payment outcome is still unknown. Resume this intent before retrying.",
+              true
+            )
+          );
+        case PURCHASE_INTENT_RESOLUTION_KIND.TIMED_OUT:
+          return ok(
+            toTerminalFailure(
+              ErrorCode.TIMEOUT,
+              "Payment is still processing. Resume this intent to continue polling.",
+              true
+            )
+          );
+        case PURCHASE_INTENT_RESOLUTION_KIND.ACTION_REQUIRED:
+          return ok(
+            toTerminalFailure(
+              actionFailure?.code ?? ErrorCode.AUTHORIZATION_REQUIRED,
+              actionFailure?.message ?? "Checkout requires additional authorization.",
+              actionFailure?.recoverable ?? true
+            )
+          );
+        case PURCHASE_INTENT_RESOLUTION_KIND.REVIEW_REQUIRED: {
+          const response = resolved.value.response;
+          switch (response.status) {
+            case PURCHASE_INTENT_CONFIRM_STATUS.TERMS_CHANGED:
+              return ok(
+                toTerminalFailure(
+                  PURCHASE_INTENT_ERROR_CODE.TERMS_CHANGED,
+                  "Checkout terms changed and require explicit review.",
+                  true
+                )
+              );
+            case PURCHASE_INTENT_CONFIRM_STATUS.SELECTION_UNAVAILABLE:
+              return ok(
+                toTerminalFailure(
+                  PURCHASE_INTENT_ERROR_CODE.SELECTION_UNAVAILABLE,
+                  "One or more checkout selections are unavailable.",
+                  true
+                )
+              );
+            case PURCHASE_INTENT_CONFIRM_STATUS.OFFER_ENDED:
+              return ok(
+                toTerminalFailure(
+                  PURCHASE_INTENT_ERROR_CODE.OFFER_ENDED,
+                  "This offer has ended.",
+                  false
+                )
+              );
+            case PURCHASE_INTENT_CONFIRM_STATUS.SOURCE_UNAVAILABLE:
+              return ok(
+                toTerminalFailure(
+                  PURCHASE_INTENT_ERROR_CODE.SOURCE_UNAVAILABLE,
+                  "This purchase source is unavailable.",
+                  false
+                )
+              );
+          }
+        }
+      }
+    } catch (error) {
+      const cancelled = data.signal?.aborted || error instanceof Error && error.name === ABORT_ERROR_NAME;
+      return ok(
+        toTerminalFailure(
+          cancelled ? ErrorCode.CANCELLED : ErrorCode.AUTHORIZATION_FAILED,
+          cancelled ? "Checkout was cancelled." : error instanceof Error ? error.message : "Checkout authorization failed.",
+          true
         )
       );
     }
-    const resolver = new CheckoutResolver({
-      client: this.client,
-      checkoutData,
-      pollIntervalMs: data.poll_interval_ms,
-      maxPollAttempts: data.max_poll_attempts,
-      onStatusChange: data.on_status_change,
-      onAuthorizationUiChange: data.on_authorization_ui_change,
-      onAuthorizationRequired: data.on_authorization_required,
-      signal: data.signal,
-      returnUrl: data.return_url,
-      enrollInLink: data.enroll_in_link,
-      cartTotal: cart.pricing.total_price,
-      cartCurrency: checkoutData.pay_currency || baseCurrency,
-      orderType: checkoutData.order_type,
-      allowPopups: data.allow_popups
-    });
-    const resolved = await resolver.resolve(processResult.value);
-    return ok(resolved);
   }
 };
 
@@ -2405,6 +2944,8 @@ var MESSAGE_TYPES = {
   CONTACT_PROVIDED: "contact_provided",
   CHECKOUT_STATUS: "checkout_status",
   CHECKOUT_COMPLETE: "checkout_complete",
+  TERMS_CHANGED: "terms_changed",
+  SELECTION_UNAVAILABLE: "selection_unavailable",
   ORDER_TYPE_CHANGED: "order_type_changed",
   REQUEST_SUBMIT: "request_submit"
 };
@@ -2825,6 +3366,8 @@ var KNOWN_IFRAME_TYPES = /* @__PURE__ */ new Set([
   MESSAGE_TYPES.LOGOUT_COMPLETE,
   MESSAGE_TYPES.CHECKOUT_STATUS,
   MESSAGE_TYPES.CHECKOUT_COMPLETE,
+  MESSAGE_TYPES.TERMS_CHANGED,
+  MESSAGE_TYPES.SELECTION_UNAVAILABLE,
   MESSAGE_TYPES.ORDER_TYPE_CHANGED,
   MESSAGE_TYPES.REQUEST_SUBMIT
 ]);
@@ -2874,6 +3417,13 @@ function parseIframeMessage(data) {
       if (typeof record.status !== "string" || !record.context || typeof record.context !== "object")
         return null;
       break;
+    case MESSAGE_TYPES.TERMS_CHANGED:
+      if (typeof record.intent_id !== "string" || !record.replacement || typeof record.replacement !== "object" || !Array.isArray(record.deltas))
+        return null;
+      break;
+    case MESSAGE_TYPES.SELECTION_UNAVAILABLE:
+      if (typeof record.intent_id !== "string" || !Array.isArray(record.lines)) return null;
+      break;
     case MESSAGE_TYPES.READY:
     case MESSAGE_TYPES.HEIGHT_CHANGE:
       if (typeof record.height !== "number") return null;
@@ -2946,7 +3496,10 @@ var CimplifyElements = class {
   async submitCheckout(data) {
     const result = await this.processCheckout({
       cart_id: data.cart_id,
-      order_type: data.order_type ?? "delivery",
+      intent_id: data.intent_id,
+      hosted_session_id: data.hosted_session_id,
+      initial_terms: data.initial_terms,
+      order_type: data.order_type ?? ORDER_TYPE.DELIVERY,
       location_id: data.location_id,
       notes: data.notes,
       scheduled_time: data.scheduled_time,
@@ -2958,7 +3511,7 @@ var CimplifyElements = class {
         success: true,
         order: {
           id: result.order?.id || "",
-          status: result.order?.status || "unknown",
+          status: result.order?.status || CHECKOUT_ORDER_RESULT_STATUS.UNKNOWN,
           total: result.order?.total || ""
         }
       };
@@ -2966,7 +3519,7 @@ var CimplifyElements = class {
     return {
       success: false,
       error: {
-        code: result.error?.code || "CHECKOUT_FAILED",
+        code: result.error?.code || ErrorCode.CHECKOUT_FAILED,
         message: result.error?.message || "Checkout failed"
       }
     };
@@ -2976,12 +3529,18 @@ var CimplifyElements = class {
     const task = (async () => {
       this.debug("[cimplify:checkout] processCheckout called", {
         cart_id: options.cart_id,
+        intent_id: options.intent_id,
+        hosted_session_id: options.hosted_session_id,
         order_type: options.order_type,
         location_id: options.location_id
       });
       if (this.checkoutInProgress) {
         this.debug("[cimplify:checkout] BLOCKED: already processing");
-        return toCheckoutError("ALREADY_PROCESSING", "Checkout is already in progress.", false);
+        return toCheckoutError(
+          ErrorCode.ALREADY_PROCESSING,
+          "Checkout is already in progress.",
+          false
+        );
       }
       this.checkoutInProgress = true;
       if (this.authEstablishmentInProgress) {
@@ -2989,18 +3548,18 @@ var CimplifyElements = class {
         if (this.authEstablishmentInProgress) {
           this.checkoutInProgress = false;
           return toCheckoutError(
-            "AUTH_INCOMPLETE",
+            ErrorCode.AUTH_INCOMPLETE,
             "Authentication must finish establishing the checkout session.",
             true
           );
         }
       }
-      if (!options.cart_id) {
-        this.debug("[cimplify:checkout] BLOCKED: no cart_id");
+      if (!options.cart_id && !options.intent_id) {
+        this.debug("[cimplify:checkout] BLOCKED: no cart_id or intent_id");
         this.checkoutInProgress = false;
         return toCheckoutError(
-          "INVALID_CART",
-          "A valid cart is required before checkout can start.",
+          ErrorCode.CHECKOUT_AUTHORITY_REQUIRED,
+          "A cart or existing purchase intent is required before checkout can start.",
           false
         );
       }
@@ -3008,7 +3567,7 @@ var CimplifyElements = class {
         this.debug("[cimplify:checkout] BLOCKED: no order_type");
         this.checkoutInProgress = false;
         return toCheckoutError(
-          "ORDER_TYPE_REQUIRED",
+          ErrorCode.ORDER_TYPE_REQUIRED,
           "Order type is required before checkout can start.",
           false
         );
@@ -3018,7 +3577,7 @@ var CimplifyElements = class {
         this.debug("[cimplify:checkout] BLOCKED: no checkout element");
         this.checkoutInProgress = false;
         return toCheckoutError(
-          "NO_PAYMENT_ELEMENT",
+          ErrorCode.NO_PAYMENT_ELEMENT,
           "Checkout element must be mounted before checkout.",
           false
         );
@@ -3027,7 +3586,7 @@ var CimplifyElements = class {
         this.debug("[cimplify:checkout] BLOCKED: checkout element not mounted");
         this.checkoutInProgress = false;
         return toCheckoutError(
-          "PAYMENT_NOT_MOUNTED",
+          ErrorCode.PAYMENT_NOT_MOUNTED,
           "Checkout element must be mounted before checkout.",
           false
         );
@@ -3039,7 +3598,7 @@ var CimplifyElements = class {
           this.debug("[cimplify:checkout] BLOCKED: auth incomplete");
           this.checkoutInProgress = false;
           return toCheckoutError(
-            "AUTH_INCOMPLETE",
+            ErrorCode.AUTH_INCOMPLETE,
             "Authentication must complete before checkout can start.",
             true
           );
@@ -3059,7 +3618,12 @@ var CimplifyElements = class {
       });
       const processMessage = {
         type: MESSAGE_TYPES.PROCESS_CHECKOUT,
-        cart_id: options.cart_id,
+        // Existing intent authority wins if a compatibility caller supplied
+        // both values; the iframe must never mint a replacement.
+        cart_id: options.intent_id ? void 0 : options.cart_id,
+        intent_id: options.intent_id,
+        hosted_session_id: options.hosted_session_id,
+        initial_terms: options.intent_id ? options.initial_terms : void 0,
         order_type: options.order_type,
         location_id: options.location_id,
         notes: options.notes,
@@ -3098,7 +3662,7 @@ var CimplifyElements = class {
         const timeout = setTimeout(() => {
           settle(
             toCheckoutError(
-              "TIMEOUT",
+              ErrorCode.TIMEOUT,
               "Checkout timed out before receiving a terminal response.",
               true
             )
@@ -3119,6 +3683,21 @@ var CimplifyElements = class {
             options.on_status_change?.(message.status, message.context);
             return;
           }
+          if (message.type === MESSAGE_TYPES.TERMS_CHANGED) {
+            options.on_status_change?.(CHECKOUT_STATUS.REVIEWING_TERMS, {
+              intent_id: message.intent_id,
+              replacement_terms: message.replacement,
+              terms_deltas: message.deltas
+            });
+            return;
+          }
+          if (message.type === MESSAGE_TYPES.SELECTION_UNAVAILABLE) {
+            options.on_status_change?.(CHECKOUT_STATUS.REVIEWING_TERMS, {
+              intent_id: message.intent_id,
+              unavailable_lines: message.lines
+            });
+            return;
+          }
           if (message.type === MESSAGE_TYPES.CHECKOUT_COMPLETE) {
             this.debug("[cimplify:checkout] received checkout_complete", {
               success: message.success,
@@ -3134,7 +3713,11 @@ var CimplifyElements = class {
           if (message.type === MESSAGE_TYPES.LOGOUT_COMPLETE) {
             checkoutElement.sendMessage({ type: MESSAGE_TYPES.ABORT_CHECKOUT });
             settle(
-              toCheckoutError("AUTH_LOST", "Authentication was cleared during checkout.", true)
+              toCheckoutError(
+                ErrorCode.AUTH_LOST,
+                "Authentication was cleared during checkout.",
+                true
+              )
             );
           }
         };
@@ -3143,11 +3726,13 @@ var CimplifyElements = class {
         }
         abortFn = () => {
           checkoutElement.sendMessage({ type: MESSAGE_TYPES.ABORT_CHECKOUT });
-          settle(toCheckoutError("CANCELLED", "Checkout was cancelled.", true));
+          settle(toCheckoutError(ErrorCode.CANCELLED, "Checkout was cancelled.", true));
         };
         this.activeCheckoutAbort = abortFn;
         this.debug("[cimplify:checkout] sending process_checkout to checkout iframe", {
           cart_id: processMessage.cart_id,
+          intent_id: processMessage.intent_id,
+          hosted_session_id: processMessage.hosted_session_id,
           order_type: processMessage.order_type,
           hasCustomer: !!processMessage.customer,
           hasAddress: !!processMessage.address,
@@ -3380,7 +3965,7 @@ var CimplifyElements = class {
     const redirectUri = auth.redirectUri ?? readPublicEnv("NEXT_PUBLIC_CIMPLIFY_REDIRECT_URI");
     if (!clientId || !redirectUri) {
       sourceElement._emitError({
-        code: "AUTH_CONFIG_REQUIRED",
+        code: ErrorCode.AUTH_CONFIG_REQUIRED,
         message: "Cimplify OAuth clientId and redirectUri are required."
       });
       return;
@@ -3404,7 +3989,7 @@ var CimplifyElements = class {
         this.authInProgress = false;
         if (!accessToken) {
           sourceElement._emitError({
-            code: "AUTH_CALLBACK_MISSING_TOKEN",
+            code: ErrorCode.AUTH_CALLBACK_MISSING_TOKEN,
             message: "Sign-in callback did not return an access token."
           });
           return;
@@ -3431,7 +4016,7 @@ var CimplifyElements = class {
       if (this.authGeneration !== generation) return;
       this.authInProgress = false;
       sourceElement._emitError({
-        code: "AUTH_START_FAILED",
+        code: ErrorCode.AUTH_START_FAILED,
         message: error instanceof Error ? error.message : "Unable to start sign-in."
       });
     });
@@ -3484,7 +4069,7 @@ var CimplifyElements = class {
         if (!this.customerData) {
           this.customerData = { name: "", email: null, phone: null };
         }
-        if (message.contactType === "email") {
+        if (message.contactType === ELEMENTS_AUTH_CONTACT_TYPES.EMAIL) {
           this.customerData.email = message.contact;
         } else {
           this.customerData.phone = message.contact;
@@ -3508,7 +4093,7 @@ var CimplifyElements = class {
           this.client.setAccessToken(null);
         }
         this.broadcastClearedSession();
-        if (message.contactType === "email") {
+        if (message.contactType === ELEMENTS_AUTH_CONTACT_TYPES.EMAIL) {
           this.customerData.email = message.contact;
         } else {
           this.customerData.phone = message.contact;
@@ -3544,7 +4129,7 @@ var CimplifyElements = class {
     if (!this.customerData) {
       this.customerData = { name: "", email: null, phone: null };
     }
-    if (contactType === "email") {
+    if (contactType === ELEMENTS_AUTH_CONTACT_TYPES.EMAIL) {
       this.customerData.email = contact;
     } else {
       this.customerData.phone = contact;
@@ -3707,7 +4292,7 @@ var CimplifyElement = class {
     if (!resolvedBusinessId || !this.container || !this.mounted) {
       console.error("Unable to mount element without a resolved business ID");
       this.emit(EVENT_TYPES.ERROR, {
-        code: "BUSINESS_ID_REQUIRED",
+        code: ErrorCode.BUSINESS_ID_REQUIRED,
         message: "Unable to initialize checkout without a business ID."
       });
       return;
@@ -3762,7 +4347,10 @@ var CimplifyElement = class {
             orderTypes: this.options.orderTypes,
             defaultOrderType: this.options.defaultOrderType,
             renderSubmitButton: true,
-            submitLabel: this.options.submitLabel
+            submitLabel: this.options.submitLabel,
+            intentId: this.options.intentId,
+            hostedSessionId: this.options.hostedSessionId,
+            initialTerms: this.options.initialTerms
           });
           const token = this.parent.getAccessToken();
           const sessionToken = this.parent.getSessionToken();
@@ -3820,4 +4408,4 @@ function createElements(client, businessId, options) {
   return new CimplifyElements(client, businessId, options);
 }
 
-export { AuthService, BusinessService, CartOperations, CatalogueQueries, CheckoutService, CimplifyElement, CimplifyElements, DEFAULT_ISSUER, ELEMENTS_AUTH_CONTACT_TYPES, ELEMENTS_AUTH_MODES, ELEMENTS_AUTH_PROMPTS, ELEMENT_TYPES, EVENT_TYPES, FxService, InventoryService, LinkService, LiteService, MESSAGE_TYPES, OrderQueries, PKCE_COOKIE, PKCE_COOKIE_PATH, SchedulingService, combine, combineObject, createElements, decodePkceState, err, flatMap, fromPromise, generateIdempotencyKey, generatePkce, generateState, getAuthorizationEndpoint, getOrElse, isErr, isOk, mapError, mapResult, ok, safe, startSignIn, toNullable, tryCatch, unwrap };
+export { AuthService, BusinessService, CartOperations, CatalogueQueries, CheckoutService, CimplifyElement, CimplifyElements, DEFAULT_ISSUER, ELEMENTS_AUTH_CONTACT_TYPES, ELEMENTS_AUTH_MODES, ELEMENTS_AUTH_PROMPTS, ELEMENT_TYPES, EVENT_TYPES, FxService, InventoryService, LinkService, LiteService, MESSAGE_TYPES, OrderQueries, PAYMENT_AUTHORIZATION_OUTCOME_STATUS, PAYMENT_AUTHORIZATION_PROVIDER, PKCE_COOKIE, PKCE_COOKIE_PATH, PaymentAuthorizationAdapterRegistry, PaystackAuthorizationAdapter, SchedulingService, StripeAuthorizationAdapter, clearIntentIdempotencyKey, combine, combineObject, createDefaultPaymentAuthorizationAdapterRegistry, createElements, createPurchaseIntentConfirmation, decodePkceState, err, flatMap, fromPromise, generateIdempotencyKey, generatePkce, generateState, getAuthorizationEndpoint, getOrElse, intentIdempotencyKey, isErr, isOk, mapError, mapResult, ok, purchaseIntentRequiresPaymentOption, safe, selectPurchaseIntentPaymentOption, startSignIn, toNullable, tryCatch, unwrap };