@cimplify/sdk 0.101.1 → 0.103.0

package/dist/{chunk-Z3K2D3TE.mjs → chunk-J6PNHDHL.mjs}

@@ -1,5 +1,6 @@
-import { isPaymentStatusRequiresAction, normalizeStatusResponse, isPaymentStatusSuccess, isPaymentStatusFailure } from './chunk-DLW3RWRK.mjs';
-import { CimplifyError, ErrorCode, currencyCode, enrichError, getErrorHint } from './chunk-O3YUHLZL.mjs';
+import { MOBILE_MONEY_PROVIDER, PAYMENT_METHOD, MAX_PAYMENT_AUTHORIZATION_STEPS } from './chunk-GOHSXBKW.mjs';
+import { normalizeStatusResponse, paymentAuthorizationUrl, isPaymentStatusSuccess, isPaymentStatusFailure, isPaymentStatusRequiresAction } from './chunk-M4URVKHE.mjs';
+import { CimplifyError, isSupportedCurrency, ErrorCode, enrichError, getErrorHint } from './chunk-VNPEYLB2.mjs';
 
 // src/types/result.ts
 function ok(value) {
@@ -784,222 +785,15 @@ var CartOperations = class {
   }
 };
 
-// src/constants.ts
-var CHECKOUT_MODE = {
-  LINK: "link",
-  GUEST: "guest"
-};
-var ORDER_TYPE = {
-  DELIVERY: "delivery",
-  PICKUP: "pickup",
-  DINE_IN: "dine-in",
-  WALK_IN: "walk-in"
-};
-var PAYMENT_METHOD = {
-  MOBILE_MONEY: "mobile_money",
-  CARD: "card"
-};
-var CHECKOUT_STEP = {
-  AUTHENTICATION: "authentication",
-  ORDER_DETAILS: "order_details",
-  PAYMENT_METHOD: "payment_method",
-  PAYMENT: "payment",
-  CONFIRMATION: "confirmation"
-};
-var PAYMENT_STATE = {
-  INITIAL: "initial",
-  PREPARING: "preparing",
-  PROCESSING: "processing",
-  VERIFYING: "verifying",
-  AWAITING_AUTHORIZATION: "awaiting_authorization",
-  SUCCESS: "success",
-  ERROR: "error",
-  TIMEOUT: "timeout"
-};
-var PICKUP_TIME_TYPE = {
-  ASAP: "asap",
-  SCHEDULED: "scheduled"
-};
-var MOBILE_MONEY_PROVIDER = {
-  MTN: "mtn",
-  VODAFONE: "vodafone",
-  TELECEL: "telecel",
-  AIRTEL: "airtel",
-  AIRTELTIGO: "airteltigo",
-  MPESA: "mpesa"
-};
-var AUTHORIZATION_TYPE = {
-  OTP: "otp",
-  PIN: "pin",
-  PHONE: "phone",
-  BIRTHDAY: "birthday",
-  ADDRESS: "address"
-};
-var DEVICE_TYPE = {
-  MOBILE: "mobile",
-  DESKTOP: "desktop",
-  TABLET: "tablet",
-  UNKNOWN: "unknown"
-};
-var CONTACT_TYPE = {
-  PHONE: "phone",
-  EMAIL: "email"
-};
-var LINK_QUERY = {
-  DATA: "link.data",
-  ADDRESSES: "link.addresses",
-  MOBILE_MONEY: "link.mobile_money",
-  PREFERENCES: "link.preferences",
-  SESSIONS: "link.sessions"
-};
-var LINK_MUTATION = {
-  CHECK_STATUS: "link.check_status",
-  ENROLL: "link.enroll",
-  ENROLL_AND_LINK_ORDER: "link.enroll_and_link_order",
-  UPDATE_PREFERENCES: "link.update_preferences",
-  CREATE_ADDRESS: "link.create_address",
-  UPDATE_ADDRESS: "link.update_address",
-  DELETE_ADDRESS: "link.delete_address",
-  SET_DEFAULT_ADDRESS: "link.set_default_address",
-  TRACK_ADDRESS_USAGE: "link.track_address_usage",
-  CREATE_MOBILE_MONEY: "link.create_mobile_money",
-  DELETE_MOBILE_MONEY: "link.delete_mobile_money",
-  SET_DEFAULT_MOBILE_MONEY: "link.set_default_mobile_money",
-  TRACK_MOBILE_MONEY_USAGE: "link.track_mobile_money_usage",
-  VERIFY_MOBILE_MONEY: "link.verify_mobile_money",
-  REVOKE_SESSION: "link.revoke_session",
-  REVOKE_ALL_SESSIONS: "link.revoke_all_sessions"
-};
-var AUTH_MUTATION = {
-  REQUEST_OTP: "auth.request_otp",
-  VERIFY_OTP: "auth.verify_otp"
-};
-var CHECKOUT_MUTATION = {
-  PROCESS: "checkout.process"
-};
-var PAYMENT_MUTATION = {
-  SUBMIT_AUTHORIZATION: "payment.submit_authorization",
-  CHECK_STATUS: "order.poll_payment_status"
-};
-var ORDER_MUTATION = {
-  UPDATE_CUSTOMER: "order.update_order_customer"
-};
-var DEFAULT_CURRENCY = "GHS";
-var DEFAULT_COUNTRY = "GHA";
-
-// src/utils/paystack.ts
-async function openPaystackPopup(options, signal) {
-  if (typeof window === "undefined") {
-    return { success: false, error: "PROVIDER_UNAVAILABLE" };
-  }
-  let PaystackPop;
-  try {
-    const specifier = "@paystack/inline-js";
-    const imported = await import(
-      /* webpackIgnore: true */
-      /* @vite-ignore */
-      specifier
-    );
-    PaystackPop = imported.default;
-  } catch {
-    return { success: false, error: "PROVIDER_UNAVAILABLE" };
-  }
-  return new Promise((resolve) => {
-    let settled = false;
-    const resolveOnce = (result) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      if (signal) {
-        signal.removeEventListener("abort", onAbort);
-      }
-      resolve(result);
-    };
-    const onAbort = () => {
-      resolveOnce({ success: false, error: "CANCELLED" });
-    };
-    if (signal?.aborted) {
-      resolveOnce({ success: false, error: "CANCELLED" });
-      return;
-    }
-    if (signal) {
-      signal.addEventListener("abort", onAbort, { once: true });
-    }
-    try {
-      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: "PAYMENT_CANCELLED" });
-        },
-        onError: (error) => {
-          resolveOnce({
-            success: false,
-            error: error?.message || "PAYMENT_FAILED"
-          });
-        }
-      });
-    } catch {
-      resolveOnce({ success: false, error: "POPUP_BLOCKED" });
-    }
-  });
-}
-
 // src/utils/checkout-resolver.ts
 var DEFAULT_POLL_INTERVAL_MS = 3e3;
 var DEFAULT_MAX_POLL_ATTEMPTS = 60;
 var MAX_CONSECUTIVE_NETWORK_ERRORS = 5;
-var CARD_PROVIDER_PAYSTACK = "paystack";
 var NEXT_ACTION_NONE = "none";
 var NEXT_ACTION_CARD_POPUP = "card_popup";
 var NEXT_ACTION_REDIRECT = "redirect";
 var NEXT_ACTION_AUTHORIZATION = "authorization";
-function normalizeCardPopupError(error) {
-  if (!error || error === "PAYMENT_CANCELLED" || error === "CANCELLED") {
-    return "PAYMENT_CANCELLED";
-  }
-  if (error === "PROVIDER_UNAVAILABLE") {
-    return "PROVIDER_UNAVAILABLE";
-  }
-  if (error === "POPUP_BLOCKED") {
-    return "POPUP_BLOCKED";
-  }
-  return "PAYMENT_FAILED";
-}
-function normalizeCardProvider(value) {
-  const normalized = value?.trim().toLowerCase();
-  return normalized && normalized.length > 0 ? normalized : CARD_PROVIDER_PAYSTACK;
-}
-async function openCardPopup(provider, checkoutResult, email, currency, signal) {
-  if (typeof window === "undefined") {
-    return { success: false, error: "PROVIDER_UNAVAILABLE" };
-  }
-  if (provider === CARD_PROVIDER_PAYSTACK) {
-    return openPaystackPopup(
-      {
-        key: checkoutResult.public_key || "",
-        email,
-        accessCode: checkoutResult.client_secret,
-        reference: checkoutResult.payment_reference || checkoutResult.client_secret,
-        currency
-      },
-      signal
-    );
-  }
-  return { success: false, error: "PROVIDER_UNAVAILABLE" };
-}
+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);
@@ -1016,6 +810,32 @@ function normalizeAuthorizationType(value) {
   }
   return void 0;
 }
+function normalizeAuthorizationSubmission(expectedType, submission) {
+  if (!submission || submission.type !== expectedType) {
+    throw new Error(`Expected ${expectedType} authorization details.`);
+  }
+  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
+    };
+  }
+  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);
@@ -1036,6 +856,27 @@ function isAbortError(error) {
   }
   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());
+    };
+    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;
@@ -1043,6 +884,7 @@ var CheckoutResolver = class {
     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;
@@ -1061,116 +903,22 @@ var CheckoutResolver = class {
       if (!checkoutResult.order_id) {
         return this.fail("CHECKOUT_FAILED", "Checkout did not return an order ID.", false);
       }
-      if (checkoutResult.next_action) {
-        return this.resolveNextAction(checkoutResult);
-      }
-      let latestCheckoutResult = checkoutResult;
-      let authorizationType = normalizeAuthorizationType(checkoutResult.authorization_type);
-      let paymentReference = checkoutResult.payment_reference;
       if (this.isSuccessfulStatus(checkoutResult.payment_status)) {
         return this.finalizeSuccess(checkoutResult);
       }
-      if (checkoutResult.client_secret && checkoutResult.public_key) {
-        const provider = normalizeCardProvider(checkoutResult.provider);
-        this.emit("awaiting_authorization", {
-          display_text: "Complete payment in the card authorization popup.",
-          order_id: checkoutResult.order_id,
-          order_number: checkoutResult.order_number
+      if (this.isFailureStatus(checkoutResult.payment_status)) {
+        const normalized = normalizeStatusResponse({
+          status: checkoutResult.payment_status,
+          paid: false
         });
-        if (!this.allowPopups) {
-          return this.fail(
-            "PROVIDER_UNAVAILABLE",
-            "Card payment popup is unavailable in this environment.",
-            false
-          );
-        }
-        const popupResult = await openCardPopup(
-          provider,
-          checkoutResult,
-          this.checkoutData.customer.email || "customer@cimplify.io",
-          this.getOrderCurrency(checkoutResult),
-          this.signal
+        return this.fail(
+          normalized.status.toUpperCase(),
+          checkoutResult.display_text || "Payment failed before confirmation.",
+          false
         );
-        if (!popupResult.success) {
-          const popupError = normalizeCardPopupError(popupResult.error);
-          if (popupError === "POPUP_BLOCKED") {
-            return this.fail(
-              "POPUP_BLOCKED",
-              "Unable to open card payment popup. Please allow popups and try again.",
-              true
-            );
-          }
-          if (popupError === "PROVIDER_UNAVAILABLE") {
-            return this.fail(
-              "PROVIDER_UNAVAILABLE",
-              "Card payment provider is unavailable.",
-              false
-            );
-          }
-          return this.fail(
-            "PAYMENT_CANCELLED",
-            "Card payment was cancelled before completion.",
-            true
-          );
-        }
-        paymentReference = popupResult.reference || paymentReference;
-      }
-      if (checkoutResult.authorization_url) {
-        if (typeof window !== "undefined" && this.returnUrl) {
-          window.location.assign(checkoutResult.authorization_url);
-          return this.fail(
-            "REDIRECT_REQUIRED",
-            "Redirecting to complete payment authorization.",
-            true
-          );
-        }
-        if (typeof window !== "undefined") {
-          const popup = window.open(
-            checkoutResult.authorization_url,
-            "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
-            );
-          }
-        }
-      }
-      if (checkoutResult.requires_authorization || isPaymentStatusRequiresAction(checkoutResult.payment_status)) {
-        const authorization = await this.handleAuthorization({
-          authorizationType,
-          paymentReference,
-          displayText: checkoutResult.display_text,
-          provider: checkoutResult.provider
-        });
-        if (!authorization.ok) {
-          return authorization.result;
-        }
-        if (authorization.value) {
-          latestCheckoutResult = authorization.value;
-          paymentReference = authorization.value.payment_reference || paymentReference;
-          authorizationType = normalizeAuthorizationType(authorization.value.authorization_type) || authorizationType;
-          if (this.isSuccessfulStatus(authorization.value.payment_status)) {
-            return this.finalizeSuccess(authorization.value);
-          }
-          if (this.isFailureStatus(authorization.value.payment_status)) {
-            return this.fail(
-              "AUTHORIZATION_FAILED",
-              authorization.value.display_text || "Payment authorization failed.",
-              false
-            );
-          }
-        }
       }
-      return this.pollUntilTerminal({
-        orderId: checkoutResult.order_id,
-        latestCheckoutResult,
-        paymentReference,
-        authorizationType
-      });
+      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);
@@ -1179,99 +927,172 @@ var CheckoutResolver = class {
       return this.fail("CHECKOUT_FAILED", message, true);
     }
   }
-  async resolveNextAction(checkoutResult) {
-    const action = checkoutResult.next_action;
+  deriveLegacyNextAction(checkoutResult) {
+    if (checkoutResult.client_secret && checkoutResult.public_key) {
+      return {
+        type: NEXT_ACTION_CARD_POPUP,
+        provider: checkoutResult.provider?.trim().toLowerCase() || "",
+        client_secret: checkoutResult.client_secret,
+        public_key: checkoutResult.public_key
+      };
+    }
+    if (checkoutResult.authorization_url) {
+      return {
+        type: NEXT_ACTION_REDIRECT,
+        authorization_url: checkoutResult.authorization_url
+      };
+    }
+    if (checkoutResult.requires_authorization && checkoutResult.authorization_type) {
+      return {
+        type: NEXT_ACTION_AUTHORIZATION,
+        authorization_type: checkoutResult.authorization_type,
+        display_text: checkoutResult.display_text
+      };
+    }
+    return { type: NEXT_ACTION_POLL };
+  }
+  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()) {
+      return {
+        ok: false,
+        result: this.fail(
+          "INVALID_CARD_AUTHORIZATION",
+          "The payment provider returned an incomplete card authorization response.",
+          false
+        )
+      };
+    }
+    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) {
+      return {
+        ok: false,
+        result: this.fail(
+          "PROVIDER_UNAVAILABLE",
+          "Card authorization UI is unavailable in this environment.",
+          false
+        )
+      };
+    }
+    const currency = this.getOrderCurrency(checkoutResult);
+    if (!currency) {
+      return {
+        ok: false,
+        result: this.fail("INVALID_CURRENCY", "Payment currency is missing or unsupported.", false)
+      };
+    }
+    let outcome;
+    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") {
+      return {
+        ok: false,
+        result: this.fail(
+          "PAYMENT_CANCELLED",
+          "Card payment was cancelled before submission.",
+          true
+        )
+      };
+    }
+    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;
-    switch (action.type) {
-      case NEXT_ACTION_NONE:
-        return this.finalizeSuccess(checkoutResult);
-      case NEXT_ACTION_CARD_POPUP: {
-        const provider = normalizeCardProvider(action.provider);
-        this.emit("awaiting_authorization", {
-          display_text: "Complete payment in the card authorization popup.",
-          order_id: checkoutResult.order_id,
-          order_number: checkoutResult.order_number
-        });
-        if (!this.allowPopups) {
-          return this.fail(
-            "PROVIDER_UNAVAILABLE",
-            "Card payment popup is unavailable in this environment.",
-            false
-          );
+    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;
         }
-        const popupResult = await openCardPopup(
-          provider,
-          checkoutResult,
-          this.checkoutData.customer.email || "customer@cimplify.io",
-          this.getOrderCurrency(checkoutResult),
-          this.signal
-        );
-        if (!popupResult.success) {
-          const popupError = normalizeCardPopupError(popupResult.error);
-          if (popupError === "POPUP_BLOCKED") {
-            return this.fail(
-              "POPUP_BLOCKED",
-              "Unable to open card payment popup. Please allow popups and try again.",
-              true
-            );
-          }
-          if (popupError === "PROVIDER_UNAVAILABLE") {
+        case NEXT_ACTION_REDIRECT: {
+          const limitFailure = this.consumeAuthorizationStep(resolutionState);
+          if (limitFailure) return limitFailure;
+          const authorizationUrl = paymentAuthorizationUrl(action.authorization_url);
+          if (!authorizationUrl) {
             return this.fail(
-              "PROVIDER_UNAVAILABLE",
-              "Card payment provider is unavailable.",
+              "INVALID_REDIRECT_AUTHORIZATION",
+              "The payment provider returned an invalid authorization URL.",
               false
             );
           }
-          return this.fail(
-            "PAYMENT_CANCELLED",
-            "Card payment was cancelled before completion.",
-            true
-          );
-        }
-        paymentReference = popupResult.reference || paymentReference;
-        break;
-      }
-      case NEXT_ACTION_REDIRECT: {
-        if (typeof window !== "undefined" && this.returnUrl) {
-          window.location.assign(action.authorization_url);
-          return this.fail(
-            "REDIRECT_REQUIRED",
-            "Redirecting to complete payment authorization.",
-            true
-          );
-        }
-        if (typeof window !== "undefined") {
-          const popup = window.open(
-            action.authorization_url,
-            "cimplify-auth",
-            "width=520,height=760,noopener,noreferrer"
-          );
-          if (!popup) {
+          if (typeof window !== "undefined" && this.returnUrl) {
+            window.location.assign(authorizationUrl);
             return this.fail(
-              "POPUP_BLOCKED",
-              "Authorization popup was blocked. Please allow popups and retry.",
+              "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;
         }
-        break;
-      }
-      case NEXT_ACTION_AUTHORIZATION: {
-        const authType = normalizeAuthorizationType(action.authorization_type);
-        const authorization = await this.handleAuthorization({
-          authorizationType: authType,
-          paymentReference,
-          displayText: action.display_text,
-          provider: checkoutResult.provider
-        });
-        if (!authorization.ok) {
-          return authorization.result;
-        }
-        if (authorization.value) {
+        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;
+          }
+          if (!authorization.value) {
+            break actionLoop;
+          }
           latestCheckoutResult = authorization.value;
           paymentReference = authorization.value.payment_reference || paymentReference;
           if (this.isSuccessfulStatus(authorization.value.payment_status)) {
@@ -1284,24 +1105,45 @@ var CheckoutResolver = class {
               false
             );
           }
+          action = authorization.value.next_action ?? this.deriveLegacyNextAction(authorization.value);
+          continue actionLoop;
         }
-        break;
+        case NEXT_ACTION_POLL:
+          break actionLoop;
+        default:
+          return this.fail(
+            "UNSUPPORTED_NEXT_ACTION",
+            "The payment provider requested an unsupported authorization action.",
+            false
+          );
       }
     }
     return this.pollUntilTerminal({
-      orderId: checkoutResult.order_id,
+      orderId: latestCheckoutResult.order_id,
       latestCheckoutResult,
       paymentReference,
-      authorizationType: normalizeAuthorizationType(checkoutResult.authorization_type)
+      resolutionState
     });
   }
+  consumeAuthorizationStep(resolutionState) {
+    if (resolutionState.authorizationSteps >= MAX_PAYMENT_AUTHORIZATION_STEPS) {
+      return this.fail(
+        "AUTHORIZATION_LIMIT_EXCEEDED",
+        "The payment provider requested too many authorization steps.",
+        false
+      );
+    }
+    resolutionState.authorizationSteps += 1;
+    return void 0;
+  }
   async pollUntilTerminal(input) {
-    let consecutiveErrors = 0;
-    let latestCheckoutResult = input.latestCheckoutResult;
+    const latestCheckoutResult = input.latestCheckoutResult;
     let paymentReference = input.paymentReference;
-    let authorizationType = input.authorizationType;
-    for (let attempt = 0; attempt < this.maxPollAttempts; attempt++) {
+    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,
@@ -1310,8 +1152,8 @@ var CheckoutResolver = class {
       });
       const statusResult = await this.client.checkout.pollPaymentStatus(input.orderId);
       if (!statusResult.ok) {
-        consecutiveErrors += 1;
-        if (consecutiveErrors >= MAX_CONSECUTIVE_NETWORK_ERRORS) {
+        resolutionState.consecutivePollErrors += 1;
+        if (resolutionState.consecutivePollErrors >= MAX_CONSECUTIVE_NETWORK_ERRORS) {
           return this.fail(
             "NETWORK_ERROR",
             "Unable to confirm payment due to repeated network errors.",
@@ -1321,13 +1163,17 @@ var CheckoutResolver = class {
         await this.wait(this.pollIntervalMs);
         continue;
       }
-      consecutiveErrors = 0;
+      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);
+        return this.finalizeSuccess({
+          ...latestCheckoutResult,
+          payment_status: normalized.status,
+          payment_reference: paymentReference || latestCheckoutResult.payment_reference
+        });
       }
       if (isPaymentStatusFailure(normalized.status)) {
         return this.fail(
@@ -1337,43 +1183,32 @@ var CheckoutResolver = class {
         );
       }
       if (isPaymentStatusRequiresAction(normalized.status)) {
-        const authorization = await this.handleAuthorization({
-          authorizationType,
-          paymentReference,
-          displayText: normalized.message || latestCheckoutResult.display_text,
-          provider: latestCheckoutResult.provider
-        });
-        if (!authorization.ok) {
-          return authorization.result;
-        }
-        if (authorization.value) {
-          latestCheckoutResult = authorization.value;
-          paymentReference = authorization.value.payment_reference || paymentReference;
-          authorizationType = normalizeAuthorizationType(authorization.value.authorization_type) || authorizationType;
-          if (this.isSuccessfulStatus(authorization.value.payment_status)) {
-            return this.finalizeSuccess(authorization.value);
-          }
-          if (this.isFailureStatus(authorization.value.payment_status)) {
-            return this.fail(
-              "AUTHORIZATION_FAILED",
-              authorization.value.display_text || "Payment authorization failed.",
-              false
-            );
-          }
+        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);
     }
-    try {
-      const finalResult = await this.client.checkout.pollPaymentStatus(input.orderId);
-      if (finalResult.ok) {
-        const normalized = normalizeStatusResponse(finalResult.value);
-        if (normalized.paid || isPaymentStatusSuccess(normalized.status)) {
-          return this.finalizeSuccess(latestCheckoutResult);
-        }
-      }
-    } catch {
-    }
     return this.fail(
       "PAYMENT_TIMEOUT",
       "Payment confirmation timed out. Please retry checkout.",
@@ -1382,35 +1217,61 @@ var CheckoutResolver = class {
   }
   async handleAuthorization(input) {
     const authorizationType = input.authorizationType;
-    const paymentReference = input.paymentReference;
-    if (!authorizationType || !paymentReference) {
-      return { ok: true };
+    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
+      provider: input.provider,
+      order_id: input.orderId,
+      order_number: input.orderNumber
     });
-    let authorizationResult;
-    const submit = async (code) => {
+    let authorizationRequest;
+    const submit = (authorization) => {
       this.ensureNotAborted();
-      const trimmedCode = code.trim();
-      if (!trimmedCode) {
-        throw new Error("Authorization code is required.");
+      let normalizedAuthorization;
+      try {
+        normalizedAuthorization = normalizeAuthorizationSubmission(
+          authorizationType,
+          authorization
+        );
+      } catch (error) {
+        return Promise.reject(error);
       }
-      const submitResult = await this.client.checkout.submitAuthorization({
-        reference: paymentReference,
-        auth_type: authorizationType,
-        value: trimmedCode
-      });
-      if (!submitResult.ok) {
-        throw new Error(submitResult.error.message || "Authorization failed.");
+      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;
+          }
+        });
       }
-      authorizationResult = submitResult.value;
+      return authorizationRequest.then(() => void 0);
     };
     try {
       if (this.onAuthorizationRequired) {
-        await this.onAuthorizationRequired(authorizationType, submit);
+        await waitForAbortable(
+          Promise.resolve(this.onAuthorizationRequired(authorizationType, submit)),
+          this.signal
+        );
       } else {
         return {
           ok: false,
@@ -1421,6 +1282,20 @@ var CheckoutResolver = class {
           )
         };
       }
+      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 {
@@ -1434,12 +1309,12 @@ var CheckoutResolver = class {
         result: this.fail("AUTHORIZATION_FAILED", message, true)
       };
     }
-    return {
-      ok: true,
-      value: authorizationResult
-    };
   }
   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
@@ -1456,7 +1331,7 @@ var CheckoutResolver = class {
         order_number: checkoutResult.order_number || checkoutResult.order_id,
         status: checkoutResult.payment_status || "paid",
         total: this.getOrderTotal(checkoutResult),
-        currency: this.getOrderCurrency(checkoutResult)
+        currency
       },
       enrolled_in_link: enrolledInLink
     };
@@ -1508,7 +1383,7 @@ var CheckoutResolver = class {
     };
   }
   getEnrollmentMobileMoney() {
-    if (this.paymentData?.type === "mobile_money" && this.paymentData.phone_number && this.paymentData.provider && isValidMobileMoneyProvider(this.paymentData.provider)) {
+    if (this.paymentData?.type === PAYMENT_METHOD.MOBILE_MONEY && this.paymentData.phone_number && this.paymentData.provider && isValidMobileMoneyProvider(this.paymentData.provider)) {
       return {
         phone_number: this.paymentData.phone_number,
         provider: this.paymentData.provider,
@@ -1535,15 +1410,15 @@ var CheckoutResolver = class {
   }
   getOrderCurrency(checkoutResult) {
     if (checkoutResult.fx?.pay_currency) {
-      return checkoutResult.fx.pay_currency;
-    }
-    if (this.cartCurrency) {
-      return this.cartCurrency;
+      const currency2 = checkoutResult.fx.pay_currency.trim().toUpperCase();
+      return isSupportedCurrency(currency2) ? currency2 : void 0;
     }
     if (this.checkoutData.pay_currency) {
-      return this.checkoutData.pay_currency;
+      const currency2 = this.checkoutData.pay_currency.trim().toUpperCase();
+      return isSupportedCurrency(currency2) ? currency2 : void 0;
     }
-    return "GHS";
+    const currency = this.cartCurrency.trim().toUpperCase();
+    return isSupportedCurrency(currency) ? currency : void 0;
   }
   emit(status, context = {}) {
     if (!this.onStatusChange) {
@@ -1554,6 +1429,12 @@ var CheckoutResolver = class {
     } catch {
     }
   }
+  notifyAuthorizationUiChange(open) {
+    try {
+      this.onAuthorizationUiChange?.(open);
+    } catch {
+    }
+  }
   fail(code, message, recoverable) {
     this.emit("failed", {
       display_text: message
@@ -1618,6 +1499,43 @@ function isValidCustomerName(name) {
 function isOfflinePaymentMethod(method) {
   return method === "cash" || method === "offline";
 }
+function notifyCheckoutStatus(observer, status, context = {}) {
+  try {
+    observer?.(status, context);
+  } catch {
+  }
+}
+var MAX_STOREFRONT_COLLECTION_OPTIONS = 32;
+function normalizeCollectionOptions(value, expectedCurrency) {
+  if (!value || typeof value !== "object") return null;
+  const response = value;
+  if (response.presentment_currency !== expectedCurrency || !Array.isArray(response.options)) {
+    return null;
+  }
+  if (response.options.length > MAX_STOREFRONT_COLLECTION_OPTIONS) return null;
+  const options = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of response.options) {
+    if (!candidate || typeof candidate !== "object") continue;
+    const option = candidate;
+    if (option.method === PAYMENT_METHOD.CARD && option.network == null) {
+      if (!seen.has(PAYMENT_METHOD.CARD)) {
+        seen.add(PAYMENT_METHOD.CARD);
+        options.push({ method: PAYMENT_METHOD.CARD, network: null });
+      }
+      continue;
+    }
+    if (option.method !== PAYMENT_METHOD.MOBILE_MONEY || typeof option.network !== "string" || !option.network.trim()) {
+      continue;
+    }
+    const network = option.network.trim().toLowerCase();
+    const key = `${PAYMENT_METHOD.MOBILE_MONEY}:${network}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    options.push({ method: PAYMENT_METHOD.MOBILE_MONEY, network });
+  }
+  return { presentment_currency: expectedCurrency, options };
+}
 var CheckoutService = class {
   constructor(client) {
     this.client = client;
@@ -1643,6 +1561,40 @@ var CheckoutService = class {
     const token = this.client.getOrderToken(orderId);
     return token ? `?token=${encodeURIComponent(token)}` : "";
   }
+  /** Available storefront collection methods for one presentment currency. */
+  async collectionOptions(currency) {
+    const normalized = currency.trim().toUpperCase();
+    if (!isSupportedCurrency(normalized)) {
+      return err(
+        new CimplifyError(
+          ErrorCode.UNSUPPORTED_CURRENCY,
+          "No online payment method is available for this currency.",
+          false
+        )
+      );
+    }
+    const response = await safe(
+      this.client.get(
+        `/api/v1/payments/collection-options?currency=${encodeURIComponent(normalized)}`
+      )
+    );
+    if (!response.ok) return response;
+    const options = normalizeCollectionOptions(response.value, normalized);
+    return options ? ok(options) : err(
+      new CimplifyError(
+        ErrorCode.PAYMENT_CAPABILITY_MISMATCH,
+        "Payment methods could not be verified for this currency.",
+        false
+      )
+    );
+  }
+  /**
+   * Run provider-owned UI for a backend `card_popup` action. A submitted
+   * outcome is not proof of payment; callers must poll/verify with Cimplify.
+   */
+  authorizeCardPopup(action, options) {
+    return this.client.authorizationAdapters.authorize(action, options);
+  }
   async process(data) {
     const invalid = this.validateCheckoutData(data);
     if (invalid) {
@@ -1686,12 +1638,18 @@ var CheckoutService = class {
   async pollPaymentStatus(orderId) {
     const encodedId = encodeURIComponent(orderId);
     const tokenParam = this.orderTokenParam(orderId);
-    return safe(this.client.get(`/api/v1/orders/${encodedId}/payment-status${tokenParam}`));
+    return safe(
+      this.client.get(
+        `/api/v1/orders/${encodedId}/payment-status${tokenParam}`
+      )
+    );
   }
   async updateOrderCustomer(orderId, customer) {
     const encodedId = encodeURIComponent(orderId);
     const tokenParam = this.orderTokenParam(orderId);
-    return safe(this.client.post(`/api/v1/orders/${encodedId}/customer${tokenParam}`, customer));
+    return safe(
+      this.client.post(`/api/v1/orders/${encodedId}/customer${tokenParam}`, customer)
+    );
   }
   async verifyPayment(orderId) {
     const encodedId = encodeURIComponent(orderId);
@@ -1699,7 +1657,7 @@ var CheckoutService = class {
     return safe(this.client.post(`/api/v1/orders/${encodedId}/verify-payment${tokenParam}`));
   }
   async processAndResolve(data) {
-    data.on_status_change?.("preparing", {});
+    notifyCheckoutStatus(data.on_status_change, "preparing");
     if (!data.cart_id) {
       return ok(
         toTerminalFailure(
@@ -1711,13 +1669,7 @@ 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("INVALID_CART", "Unable to load cart for checkout.", false));
     }
     const cart = cartResult.value;
     if (cart.id !== data.cart_id || cart.items.length === 0) {
@@ -1749,11 +1701,28 @@ var CheckoutService = class {
       voucher_code: data.voucher_code,
       pay_deposit: data.pay_deposit
     };
-    const baseCurrency = currencyCode(
-      (cart.pricing.currency || checkoutData.pay_currency || "GHS").toUpperCase()
-    );
+    const rawBaseCurrency = typeof cart.pricing.currency === "string" ? cart.pricing.currency.trim().toUpperCase() : "";
+    if (!isSupportedCurrency(rawBaseCurrency)) {
+      return ok(
+        toTerminalFailure(
+          "INVALID_CURRENCY",
+          "Cart currency is missing or unsupported. Refresh the cart before checkout.",
+          false
+        )
+      );
+    }
+    const baseCurrency = rawBaseCurrency;
     const payCurrency = data.pay_currency?.trim().toUpperCase();
-    const payCurrencyCode = payCurrency ? currencyCode(payCurrency) : void 0;
+    if (payCurrency && !isSupportedCurrency(payCurrency)) {
+      return ok(
+        toTerminalFailure(
+          "INVALID_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 fxQuoteResult = await this.client.fx.lockQuote({
@@ -1773,7 +1742,7 @@ var CheckoutService = class {
       checkoutData.pay_currency = payCurrencyCode;
       checkoutData.fx_quote_id = fxQuoteResult.value.id;
     }
-    data.on_status_change?.("processing", {});
+    notifyCheckoutStatus(data.on_status_change, "processing");
     const processResult = await this.process(checkoutData);
     if (!processResult.ok) {
       return ok(
@@ -1790,12 +1759,13 @@ var CheckoutService = class {
       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 || cart.pricing.currency || "GHS",
+      cartCurrency: checkoutData.pay_currency || baseCurrency,
       orderType: checkoutData.order_type,
       allowPopups: data.allow_popups
     });
@@ -3643,4 +3613,4 @@ function createElements(client, businessId, options) {
   return new CimplifyElements(client, businessId, options);
 }
 
-export { AUTHORIZATION_TYPE, AUTH_MUTATION, AuthService, BusinessService, CHECKOUT_MODE, CHECKOUT_MUTATION, CHECKOUT_STEP, CONTACT_TYPE, CartOperations, CatalogueQueries, CheckoutService, CimplifyElement, CimplifyElements, DEFAULT_COUNTRY, DEFAULT_CURRENCY, DEFAULT_ISSUER, DEVICE_TYPE, ELEMENTS_AUTH_CONTACT_TYPES, ELEMENTS_AUTH_MODES, ELEMENTS_AUTH_PROMPTS, ELEMENT_TYPES, EVENT_TYPES, FxService, InventoryService, LINK_MUTATION, LINK_QUERY, LinkService, LiteService, MESSAGE_TYPES, MOBILE_MONEY_PROVIDER, ORDER_MUTATION, ORDER_TYPE, OrderQueries, PAYMENT_METHOD, PAYMENT_MUTATION, PAYMENT_STATE, PICKUP_TIME_TYPE, 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, 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 };