@tagadapay/plugin-sdk 3.1.25 → 4.0.2

package/dist/v2/react/components/StripeExpressButton.d.ts

@@ -8,6 +8,14 @@ export interface StripeExpressButtonProps {
     }) => void;
     onError?: (error: string) => void;
     onCancel?: () => void;
+    /**
+     * Locale forwarded to Stripe Elements. Controls the wording inside
+     * sheet-based wallets like PayPal, Klarna, and Link (Apple Pay /
+     * Google Pay are localized by the OS and ignore this value).
+     * Pass a 2-letter or BCP47 code (e.g. 'fr', 'pt-BR'); defaults to
+     * 'auto' which uses the visitor's browser language.
+     */
+    locale?: string;
 }
 export declare const StripeExpressButton: React.FC<StripeExpressButtonProps>;
 export default StripeExpressButton;

package/dist/v2/react/components/StripeExpressButton.js

@@ -1,10 +1,11 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Elements, ExpressCheckoutElement, useElements, useStripe } from '@stripe/react-stripe-js';
 import { loadStripe } from '@stripe/stripe-js';
-import { useMemo, useRef, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { PaymentsResource } from '../../core/resources/payments';
 import { useExpressPaymentMethods } from '../hooks/useExpressPaymentMethods';
 import { usePaymentPolling } from '../hooks/usePaymentPolling';
+import { useStepConfig } from '../hooks/useStepConfig';
 import { getGlobalApiClient } from '../hooks/useApiQuery';
 // Express method keys — drives processorGroup detection and ECE paymentMethods options.
 // 'klarna_express' is the CRM config key for Klarna via ECE, distinct from 'klarna' (redirect flow).
@@ -18,7 +19,26 @@ function StripeExpressButtonInner({ checkout, processorId, enabledExpressMethods
     const { startPolling } = usePaymentPolling();
     const isProcessingRef = useRef(false);
     const [visible, setVisible] = useState(false);
+    // Per-step country allow-list (CRM-injected stepConfig). Empty/missing = all allowed.
+    const { stepConfig } = useStepConfig();
+    const countryAllowlist = useMemo(() => {
+        const list = stepConfig?.addressSettings?.countryAllowlist;
+        if (!list || list.length === 0)
+            return undefined;
+        return list.map((c) => c.toUpperCase());
+    }, [stepConfig]);
     const paymentsResource = useMemo(() => new PaymentsResource(getGlobalApiClient()), []);
+    // Push amount/currency changes (e.g. shipping cost added once address resolved,
+    // promo applied, quantity changed) to the mounted ExpressCheckoutElement.
+    // Re-rendering <Elements> with new options does not update the underlying
+    // element — Stripe requires elements.update() for live updates.
+    const liveAmount = Math.round(checkout.summary?.totalAdjustedAmount ?? 0);
+    const liveCurrency = (checkout.summary?.currency || 'usd').toLowerCase();
+    useEffect(() => {
+        if (!elements)
+            return;
+        elements.update({ amount: liveAmount, currency: liveCurrency });
+    }, [elements, liveAmount, liveCurrency]);
     const onConfirm = async (event) => {
         if (!stripe || !elements || isProcessingRef.current)
             return;
@@ -30,6 +50,7 @@ function StripeExpressButtonInner({ checkout, processorId, enabledExpressMethods
             // This mirrors what ApplePayButton and GooglePayButton do before processing payment,
             // and ensures customer.email is present for the backend email validation.
             const billing = event.billingDetails;
+            const eventShipping = event.shippingAddress;
             if (billing) {
                 const nameParts = (billing.name ?? '').trim().split(/\s+/);
                 const firstName = nameParts[0] ?? '';
@@ -46,9 +67,33 @@ function StripeExpressButtonInner({ checkout, processorId, enabledExpressMethods
                     phone: billing.phone ?? '',
                     email: billing.email ?? '',
                 };
+                // When shippingAddressRequired is true, Stripe provides event.shippingAddress.
+                // Otherwise the billing address is used as the shipping address (legacy behavior).
+                const shippingFromEvent = eventShipping?.address
+                    ? {
+                        firstName: (eventShipping.name ?? '').trim().split(/\s+/)[0] ?? '',
+                        lastName: (eventShipping.name ?? '').trim().split(/\s+/).slice(1).join(' '),
+                        address1: eventShipping.address.line1 ?? '',
+                        address2: eventShipping.address.line2 ?? '',
+                        city: eventShipping.address.city ?? '',
+                        state: eventShipping.address.state ?? '',
+                        country: eventShipping.address.country ?? '',
+                        postal: eventShipping.address.postal_code ?? '',
+                        phone: billing.phone ?? '',
+                        email: billing.email ?? '',
+                    }
+                    : billingAddress;
+                // Defense-in-depth: reject if wallet-returned country isn't in allowlist
+                const shippingCountry = shippingFromEvent.country.toUpperCase();
+                if (countryAllowlist && shippingCountry && !countryAllowlist.includes(shippingCountry)) {
+                    console.error('[StripeExpress] Shipping country not in allowlist:', shippingCountry);
+                    onError?.('Shipping to this country is not supported');
+                    isProcessingRef.current = false;
+                    return;
+                }
                 await updateCheckoutSessionValues({
                     data: {
-                        shippingAddress: billingAddress,
+                        shippingAddress: shippingFromEvent,
                         billingAddress,
                     },
                 });
@@ -65,11 +110,16 @@ function StripeExpressButtonInner({ checkout, processorId, enabledExpressMethods
             }
             // Step 3: call backend via existing APM path
             // paymentsResource.processPaymentDirect returns the raw PaymentResponse (no action routing)
+            // Forward the session's selected shipping rate so the order is created
+            // with shipping even if the session lookup is racing with this request.
+            const shippingRateId = checkout.checkoutSession.shippingRateId
+                || checkout.checkoutSession.shippingRate?.id;
             const response = await paymentsResource.processPaymentDirect(checkout.checkoutSession.id, '', // empty — backend identifies via processorId + paymentMethod
             undefined, {
                 processorId,
                 paymentMethod,
                 isExpress: true,
+                shippingRateId,
             });
             const clientSecret = response?.payment?.requireActionData?.metadata?.stripeExpressCheckout?.clientSecret;
             if (!clientSecret) {
@@ -123,7 +173,16 @@ function StripeExpressButtonInner({ checkout, processorId, enabledExpressMethods
             onError?.(msg);
         }
     };
-    return (_jsx("div", { style: { visibility: visible ? 'visible' : 'hidden' }, children: _jsx(ExpressCheckoutElement, { onReady: ({ availablePaymentMethods }) => {
+    // When ECE has no available wallets, keep the element mounted (so onReady can still
+    // fire if the browser later exposes one) but pull it off-screen so it doesn't reserve
+    // an empty slot. Off-screen rather than zero-size so the iframe still gets layout.
+    const hiddenStyle = {
+        position: 'absolute',
+        left: '-9999px',
+        top: '-9999px',
+        pointerEvents: 'none',
+    };
+    return (_jsx("div", { style: visible ? undefined : hiddenStyle, children: _jsx(ExpressCheckoutElement, { onReady: ({ availablePaymentMethods }) => {
                 if (availablePaymentMethods) {
                     setVisible(true);
                     handleAddExpressId('stripe_express_checkout');
@@ -145,6 +204,15 @@ function StripeExpressButtonInner({ checkout, processorId, enabledExpressMethods
                 },
                 emailRequired: true,
                 billingAddressRequired: true,
+                // When an allow-list is configured, collect shipping via the wallet sheet so Stripe
+                // can enforce country restrictions natively. allowedShippingCountries requires
+                // shippingAddressRequired: true.
+                ...(countryAllowlist
+                    ? {
+                        shippingAddressRequired: true,
+                        allowedShippingCountries: countryAllowlist,
+                    }
+                    : {}),
             } }) }));
 }
 // Outer component — resolves Stripe instance and provides <Elements> context
@@ -164,6 +232,11 @@ export const StripeExpressButton = (props) => {
         mode: 'payment',
         amount,
         currency,
+        // 'auto' lets Stripe Elements derive the locale from navigator.language;
+        // an explicit code (e.g. 'fr', 'pt-BR') forces a specific translation
+        // for PayPal / Klarna / Link sheets. Stripe filters unsupported codes
+        // back to English internally, so it's safe to forward any string.
+        locale: (props.locale ?? 'auto'),
     };
     return (_jsx(Elements, { stripe: stripePromise, options: elementsOptions, children: _jsx(StripeExpressButtonInner, { ...props, processorId: processorId, enabledExpressMethods: enabledExpressMethods }) }));
 };

package/dist/v2/react/hooks/payment-actions/useNgeniusThreedsAction.d.ts

@@ -0,0 +1,15 @@
+import type { Payment, PaymentOptions } from '../../../core/resources/payments';
+import type { PaymentsResource } from '../../../core/resources/payments';
+import type { UsePaymentOptions } from '../usePaymentQuery';
+export declare const NGENIUS_3DS_CONTAINER_ID = "ngenius-3ds-container";
+interface UseNgeniusThreedsActionParams {
+    paymentsResource: PaymentsResource;
+    startPolling: any;
+    setError: (error: string | null) => void;
+    setIsLoading: (loading: boolean) => void;
+    hookOptionsRef: React.MutableRefObject<UsePaymentOptions | undefined>;
+}
+export declare function useNgeniusThreedsAction({ paymentsResource, startPolling, setError, setIsLoading, hookOptionsRef, }: UseNgeniusThreedsActionParams): {
+    handleNgeniusThreeds: (payment: Payment, actionData: any, options?: PaymentOptions) => Promise<void>;
+};
+export {};

package/dist/v2/react/hooks/payment-actions/useNgeniusThreedsAction.js

@@ -0,0 +1,166 @@
+/**
+ * Hook for handling N-Genius 3DS authentication via the N-Genius WebSDK.
+ *
+ * The WebSDK mounts a challenge iframe into a DOM element identified by
+ * NGENIUS_3DS_CONTAINER_ID and exposes `window.NI.handlePaymentResponse`,
+ * which returns a Promise that resolves once 3DS completes. After completion,
+ * we poll the Ngenius API (every 3 seconds, up to 10 times) to verify payment status.
+ */
+import { useCallback } from 'react';
+export const NGENIUS_3DS_CONTAINER_ID = 'ngenius-3ds-container';
+const NGENIUS_SDK_URL_SANDBOX = 'https://paypage.sandbox.ngenius-payments.com/hosted-sessions/sdk.js';
+const NGENIUS_SDK_URL_PRODUCTION = 'https://paypage.ngenius-payments.com/hosted-sessions/sdk.js';
+const NGENIUS_SDK_SCRIPT_ID = 'ngenius-websdk';
+function ensureNgeniusContainer() {
+    let container = document.getElementById(NGENIUS_3DS_CONTAINER_ID);
+    if (!container) {
+        container = document.createElement('div');
+        container.id = NGENIUS_3DS_CONTAINER_ID;
+        container.style.cssText = `
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background-color: rgba(0, 0, 0, 0.5);
+            z-index: 9999;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        `;
+        document.body.appendChild(container);
+        console.log('[N-Genius 3DS] Container created and appended to body');
+    }
+    return container;
+}
+function loadNgeniusSdk(isSandboxed) {
+    return new Promise((resolve, reject) => {
+        if (document.getElementById(NGENIUS_SDK_SCRIPT_ID)) {
+            resolve();
+            return;
+        }
+        const script = document.createElement('script');
+        script.id = NGENIUS_SDK_SCRIPT_ID;
+        script.src = isSandboxed ? NGENIUS_SDK_URL_SANDBOX : NGENIUS_SDK_URL_PRODUCTION;
+        script.onload = () => resolve();
+        script.onerror = () => reject(new Error('Failed to load N-Genius WebSDK'));
+        document.head.appendChild(script);
+    });
+}
+export function useNgeniusThreedsAction({ paymentsResource, startPolling, setError, setIsLoading, hookOptionsRef, }) {
+    const handleNgeniusThreeds = useCallback(async (payment, actionData, options = {}) => {
+        const sdk = actionData.metadata?.sdk;
+        if (!sdk?.paymentResponse || !sdk.orderReference || !sdk.paymentReference) {
+            const msg = 'N-Genius 3DS: missing SDK metadata in requireAction';
+            console.error(msg, actionData);
+            setError(msg);
+            setIsLoading(false);
+            options.onFailure?.(msg);
+            return;
+        }
+        try {
+            // Ensure the container exists in the DOM
+            ensureNgeniusContainer();
+            await loadNgeniusSdk(sdk.isSandboxed);
+            const NI = window.NI;
+            if (!NI?.handlePaymentResponse) {
+                throw new Error('N-Genius WebSDK did not expose window.NI.handlePaymentResponse');
+            }
+            console.log('[N-Genius 3DS] Starting WebSDK challenge flow');
+            // Turn off checkout loading overlay - the 3DS modal will be the only overlay
+            setIsLoading(false);
+            const outcome = await NI.handlePaymentResponse(sdk.paymentResponse, {
+                mountId: NGENIUS_3DS_CONTAINER_ID,
+                style: { width: '100%', height: 500 },
+            });
+            console.log('[N-Genius 3DS] WebSDK outcome:', outcome.status);
+            console.log('[N-Genius 3DS] 3DS complete - polling Ngenius API for status');
+            // Clean up the 3DS container
+            const container = document.getElementById(NGENIUS_3DS_CONTAINER_ID);
+            if (container) {
+                container.style.display = 'none';
+                container.innerHTML = '';
+                console.log('[N-Genius 3DS] Container hidden and cleared');
+            }
+            // Turn loading back on while we poll the Ngenius API
+            setIsLoading(true);
+            // Poll Ngenius API until payment is no longer pending
+            const maxAttempts = 10; // 10 attempts
+            const pollInterval = 3000; // 3 seconds
+            let attempts = 0;
+            const pollNgeniusStatus = async () => {
+                attempts++;
+                console.log(`[N-Genius 3DS] Polling Ngenius API - attempt ${attempts}/${maxAttempts}`);
+                try {
+                    const completedPayment = await paymentsResource.ngeniusThreedsComplete({
+                        paymentId: payment.id,
+                        orderReference: sdk.orderReference,
+                        paymentReference: sdk.paymentReference,
+                    });
+                    console.log('[N-Genius 3DS] Ngenius API response:', {
+                        status: completedPayment.status,
+                        subStatus: completedPayment.subStatus,
+                    });
+                    // If payment succeeded
+                    if (completedPayment.status === 'succeeded') {
+                        setIsLoading(false);
+                        const response = { paymentId: completedPayment.id, payment: completedPayment, order: completedPayment.order };
+                        await hookOptionsRef.current?.onPaymentCompleted?.(completedPayment, { isRedirectReturn: false, order: response.order });
+                        options.onSuccess?.(response);
+                        options.onPaymentSuccess?.(response);
+                        return;
+                    }
+                    // If payment failed
+                    if (completedPayment.status === 'declined' || completedPayment.status === 'failed') {
+                        const errorMsg = completedPayment.error?.message || 'Payment failed';
+                        setError(errorMsg);
+                        setIsLoading(false);
+                        await hookOptionsRef.current?.onPaymentFailed?.(errorMsg, { isRedirectReturn: false });
+                        options.onFailure?.(errorMsg);
+                        options.onPaymentFailed?.({ code: 'PAYMENT_FAILED', message: errorMsg, payment: completedPayment });
+                        return;
+                    }
+                    // If still pending and we haven't exceeded max attempts, poll again
+                    if (attempts < maxAttempts) {
+                        setTimeout(() => pollNgeniusStatus(), pollInterval);
+                    }
+                    else {
+                        // Max attempts reached
+                        const errorMsg = 'Payment verification timeout - please check your order status';
+                        setError(errorMsg);
+                        setIsLoading(false);
+                        await hookOptionsRef.current?.onPaymentFailed?.(errorMsg, { isRedirectReturn: false });
+                        options.onFailure?.(errorMsg);
+                        options.onPaymentFailed?.({ code: 'PAYMENT_TIMEOUT', message: errorMsg, payment: completedPayment });
+                    }
+                }
+                catch (error) {
+                    console.error('[N-Genius 3DS] Error polling Ngenius API:', error);
+                    const errorMsg = error instanceof Error ? error.message : 'Failed to verify payment status';
+                    setError(errorMsg);
+                    setIsLoading(false);
+                    await hookOptionsRef.current?.onPaymentFailed?.(errorMsg, { isRedirectReturn: false });
+                    options.onFailure?.(errorMsg);
+                    options.onPaymentFailed?.({ code: 'NGENIUS_POLL_ERROR', message: errorMsg, payment });
+                }
+            };
+            // Start polling
+            await pollNgeniusStatus();
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : 'N-Genius 3DS failed';
+            console.error('[N-Genius 3DS] Error:', err);
+            // Clean up container on error
+            const container = document.getElementById(NGENIUS_3DS_CONTAINER_ID);
+            if (container) {
+                container.style.display = 'none';
+                container.innerHTML = '';
+            }
+            setError(errorMsg);
+            setIsLoading(false);
+            options.onFailure?.(errorMsg);
+            options.onPaymentFailed?.({ code: 'NGENIUS_3DS_ERROR', message: errorMsg, payment });
+        }
+    }, [paymentsResource, startPolling, setError, setIsLoading, hookOptionsRef]);
+    return { handleNgeniusThreeds };
+}

package/dist/v2/react/hooks/payment-actions/usePaymentActionHandler.js

@@ -12,6 +12,7 @@ import { useStripeRadarAction } from './useStripeRadarAction';
 import { useKessPayAction } from './useKessPayAction';
 import { useTrustFlowAction } from './useTrustFlowAction';
 import { useMasterCardAction } from './useMasterCardAction';
+import { useNgeniusThreedsAction } from './useNgeniusThreedsAction';
 export function usePaymentActionHandler({ paymentsResource, startChallenge, startPolling, setIsLoading, setError, hookOptionsRef, }) {
     // Track challenge in progress to prevent multiple challenges
     const challengeInProgressRef = useRef(false);
@@ -71,6 +72,13 @@ export function usePaymentActionHandler({ paymentsResource, startChallenge, star
         setIsLoading,
         hookOptionsRef,
     });
+    const { handleNgeniusThreeds } = useNgeniusThreedsAction({
+        paymentsResource,
+        startPolling,
+        setError,
+        setIsLoading,
+        hookOptionsRef,
+    });
     // Main handler that routes to specific action handlers
     const handlePaymentAction = useCallback(async (payment, options = {}) => {
         if (payment.requireAction === 'none')
@@ -123,6 +131,9 @@ export function usePaymentActionHandler({ paymentsResource, startChallenge, star
                     await handleAirwallexRadar(payment, actionData, options, handlePaymentAction);
                 }
                 break;
+            case 'ngenius_3ds':
+                await handleNgeniusThreeds(payment, actionData, options);
+                break;
         }
         options.onRequireAction?.(payment);
     }, [
@@ -137,6 +148,7 @@ export function usePaymentActionHandler({ paymentsResource, startChallenge, star
         handleKessPayAuth,
         handleTrustFlowAuth,
         handleMasterCardAuth,
+        handleNgeniusThreeds,
     ]);
     return { handlePaymentAction };
 }

package/dist/v2/react/hooks/payment-processing/usePaymentProcessors.js

@@ -14,6 +14,7 @@ export function usePaymentProcessors({ paymentsResource, createCardPaymentInstru
                 paymentFlowId,
                 processorId: options.processorId,
                 paymentMethod: options.paymentMethod,
+                shippingRateId: options.shippingRateId,
             });
             setCurrentPaymentId(response.payment?.id);
             if (response.payment.requireAction !== 'none') {

package/dist/v2/react/hooks/useCheckoutQuery.js

@@ -21,7 +21,7 @@ export function useCheckoutQuery(options = {}) {
     const { storeId } = usePluginConfig();
     const currency = useCurrency();
     const queryClient = useQueryClient();
-    const { isSessionInitialized, session } = useTagadaContext();
+    const { isSessionInitialized, session, client } = useTagadaContext();
     // Track pending session promises to avoid creating multiple promises
     const pendingSessionPromise = useRef(null);
     const sessionResolvers = useRef(new Set());
@@ -64,12 +64,12 @@ export function useCheckoutQuery(options = {}) {
     // Create checkout resource client
     const checkoutResource = useMemo(() => {
         try {
-            return new CheckoutResource(getGlobalApiClient());
+            return new CheckoutResource(getGlobalApiClient(), client.bus);
         }
         catch (error) {
             throw new Error(messages.initFailed + ': ' + (error instanceof Error ? error.message : 'Unknown error'));
         }
-    }, []);
+    }, [client.bus]);
     // Internal token state that can be updated after init
     const [internalToken, setInternalToken] = useState(providedToken);
     // Update internal token when provided token changes
@@ -304,6 +304,32 @@ export function useCheckoutQuery(options = {}) {
             promotionIds,
         }),
     });
+    // Stable mutator wrappers. Returning inline arrows each render produced new
+    // refs on every checkout state change (mutation success → query invalidate
+    // → refetch → re-render), which propagated instability into consumer
+    // useCallback/useEffect deps and broke debounced auto-update (the timer in
+    // the shared RHF watch listener kept getting cleared mid-debounce, so the
+    // customer-and-session-info call never fired for email-only typing).
+    const init = useCallback(async (params) => {
+        await waitForSession();
+        const result = await initMutation.mutateAsync(params);
+        setInternalToken(result.checkoutToken);
+        return {
+            checkoutSession: checkout?.checkoutSession ?? {},
+            checkoutToken: result.checkoutToken,
+        };
+    }, [waitForSession, initMutation.mutateAsync, checkout?.checkoutSession]);
+    const replaceSessionLineItems = useCallback((lineItems) => replaceSessionLineItemsMutation.mutateAsync({ lineItems }), [replaceSessionLineItemsMutation.mutateAsync]);
+    const updateLineItems = useCallback((lineItems) => lineItemsMutation.mutateAsync({ lineItems }), [lineItemsMutation.mutateAsync]);
+    const updateLineItemsOptimistic = useCallback((lineItems) => lineItemsMutation.mutate({ lineItems }), [lineItemsMutation.mutate]);
+    const addLineItems = useCallback((lineItems) => addLineItemsMutation.mutateAsync({ lineItems }), [addLineItemsMutation.mutateAsync]);
+    const removeLineItems = useCallback((lineItems) => removeLineItemsMutation.mutateAsync({ lineItems }), [removeLineItemsMutation.mutateAsync]);
+    const setItemQuantity = useCallback((variantId, quantity, priceId) => quantityMutation.mutateAsync({ variantId, quantity, priceId }), [quantityMutation.mutateAsync]);
+    const updateCustomer = useCallback((data) => customerMutation.mutateAsync(data), [customerMutation.mutateAsync]);
+    const updateCustomerAndSessionInfo = useCallback((data) => customerAndSessionMutation.mutateAsync(data), [customerAndSessionMutation.mutateAsync]);
+    const applyPromotionCode = useCallback((code) => promotionMutation.mutateAsync({ code }), [promotionMutation.mutateAsync]);
+    const removePromotion = useCallback((promotionId) => removePromotionMutation.mutateAsync({ promotionId }), [removePromotionMutation.mutateAsync]);
+    const previewCheckoutSession = useCallback((lineItems, promotionIds) => previewCheckoutSessionMutation.mutateAsync({ lineItems, promotionIds }), [previewCheckoutSessionMutation.mutateAsync]);
     return {
         // Query data
         checkout,
@@ -311,33 +337,19 @@ export function useCheckoutQuery(options = {}) {
         error,
         isSuccess,
         // Actions
-        init: async (params) => {
-            // Wait for session to be initialized to ensure we have customerId
-            await waitForSession();
-            const result = await initMutation.mutateAsync(params);
-            // Update internal token state so the query can fetch the checkout data
-            // The query will automatically refetch when token changes, and getCheckout()
-            // will automatically wait for async completion (via SDK skipAsyncWait=false)
-            setInternalToken(result.checkoutToken);
-            // Return immediately with token
-            // checkoutSession will be populated by the query once background processing completes
-            return {
-                checkoutSession: checkout?.checkoutSession ?? {},
-                checkoutToken: result.checkoutToken,
-            };
-        },
+        init,
         refresh,
         // Checkout operations
-        replaceSessionLineItems: (lineItems) => replaceSessionLineItemsMutation.mutateAsync({ lineItems }),
-        updateLineItems: (lineItems) => lineItemsMutation.mutateAsync({ lineItems }),
-        updateLineItemsOptimistic: (lineItems) => lineItemsMutation.mutate({ lineItems }),
-        addLineItems: (lineItems) => addLineItemsMutation.mutateAsync({ lineItems }),
-        removeLineItems: (lineItems) => removeLineItemsMutation.mutateAsync({ lineItems }),
-        setItemQuantity: (variantId, quantity, priceId) => quantityMutation.mutateAsync({ variantId, quantity, priceId }),
-        updateCustomer: (data) => customerMutation.mutateAsync(data),
-        updateCustomerAndSessionInfo: (data) => customerAndSessionMutation.mutateAsync(data),
-        applyPromotionCode: (code) => promotionMutation.mutateAsync({ code }),
-        removePromotion: (promotionId) => removePromotionMutation.mutateAsync({ promotionId }),
-        previewCheckoutSession: (lineItems, promotionIds) => previewCheckoutSessionMutation.mutateAsync({ lineItems, promotionIds }),
+        replaceSessionLineItems,
+        updateLineItems,
+        updateLineItemsOptimistic,
+        addLineItems,
+        removeLineItems,
+        setItemQuantity,
+        updateCustomer,
+        updateCustomerAndSessionInfo,
+        applyPromotionCode,
+        removePromotion,
+        previewCheckoutSession,
     };
 }

package/dist/v2/react/hooks/useDiscountsQuery.js

@@ -45,6 +45,8 @@ export function useDiscountsQuery(options = {}) {
                     await Promise.all([
                         queryClient.invalidateQueries({ queryKey: ['discounts', sessionId] }),
                         queryClient.invalidateQueries({ queryKey: ['checkout'] }),
+                        queryClient.invalidateQueries({ queryKey: ['shipping-rates', sessionId] }),
+                        queryClient.invalidateQueries({ queryKey: ['shipping-rates-preview', sessionId] }),
                     ]);
                 }
                 // Call onSuccess callback if provided
@@ -72,6 +74,8 @@ export function useDiscountsQuery(options = {}) {
                     await Promise.all([
                         queryClient.invalidateQueries({ queryKey: ['discounts', sessionId] }),
                         queryClient.invalidateQueries({ queryKey: ['checkout'] }),
+                        queryClient.invalidateQueries({ queryKey: ['shipping-rates', sessionId] }),
+                        queryClient.invalidateQueries({ queryKey: ['shipping-rates-preview', sessionId] }),
                     ]);
                 }
                 // Call onSuccess callback if provided

package/dist/v2/react/hooks/useFunnel.d.ts

@@ -65,6 +65,13 @@ export interface StepConfigValue {
      * undefined = inherit all store upsells, string[] = only these IDs.
      */
     upsellOfferIds: string[] | undefined;
+    /**
+     * Payment initiator override for this step's offer/upsell charge.
+     * 'merchant' = MIT (off-session, no 3DS). 'customer' = CIT (may trigger 3DS).
+     * undefined = use SDK default (merchant).
+     * usePreviewOffer auto-applies this value; consumers usually don't need to read it.
+     */
+    paymentInitiator: 'merchant' | 'customer' | undefined;
 }
 export interface FunnelContextValue extends FunnelState {
     currentStep: {

package/dist/v2/react/hooks/useFunnel.js

@@ -20,7 +20,7 @@
  * ```
  */
 import { useMemo } from 'react';
-import { TrackingProvider, getAssignedOrderBumpOfferIds, getAssignedPaymentFlowId, getAssignedPixels, getAssignedResources, getAssignedScripts, getAssignedStepConfig, getAssignedUpsellOfferIds, } from '../../core/funnelClient';
+import { TrackingProvider, getAssignedOrderBumpOfferIds, getAssignedPaymentFlowId, getAssignedPaymentInitiator, getAssignedPixels, getAssignedResources, getAssignedScripts, getAssignedStepConfig, getAssignedUpsellOfferIds, } from '../../core/funnelClient';
 import { useTagadaContext } from '../providers/TagadaProvider';
 /**
  * Hook to access funnel state and methods
@@ -45,6 +45,7 @@ export function useFunnel() {
             getScripts: (position) => getAssignedScripts(position),
             orderBumpOfferIds: getAssignedOrderBumpOfferIds(),
             upsellOfferIds: getAssignedUpsellOfferIds(),
+            paymentInitiator: getAssignedPaymentInitiator(),
         };
     }, []);
     return {

package/dist/v2/react/hooks/useISOData.js

@@ -1,16 +1,21 @@
 import { useMemo, useEffect, useState, useCallback } from 'react';
-import { getCountries, getStatesForCountry, ensureGeoDataLoaded, importLanguage, isLanguageRegistered, getRegisteredLanguages } from '../../../data/iso3166';
+import { getCountries, getStatesForCountry, ensureGeoDataLoaded, AVAILABLE_LANGUAGES, importLanguage, isLanguageRegistered, getRegisteredLanguages } from '../../../data/iso3166';
 /**
  * React hook for accessing ISO3166 countries and regions data.
  * Fetches slim JSON from CDN on first use, then caches in memory.
  */
 export function useISOData(language = 'en', autoImport = true, disputeSetting = 'UN') {
-    const [isLanguageLoaded, setIsLanguageLoaded] = useState(isLanguageRegistered(language));
+    // Normalize: if the caller passed an unsupported locale (e.g. 'nl'),
+    // silently fall back to English so the country dropdown still renders.
+    // The CDN only hosts languages listed in AVAILABLE_LANGUAGES; any other
+    // value would 404 and leave `isLanguageLoaded` stuck on false.
+    const effectiveLanguage = AVAILABLE_LANGUAGES.includes(language) ? language : 'en';
+    const [isLanguageLoaded, setIsLanguageLoaded] = useState(isLanguageRegistered(effectiveLanguage));
     const [registeredLanguages, setRegisteredLanguages] = useState(getRegisteredLanguages);
     // Fetch geodata from CDN (countries + regions) for the requested language
     useEffect(() => {
         let cancelled = false;
-        ensureGeoDataLoaded(language)
+        ensureGeoDataLoaded(effectiveLanguage)
             .then(() => {
             if (!cancelled) {
                 setIsLanguageLoaded(true);
@@ -19,9 +24,22 @@ export function useISOData(language = 'en', autoImport = true, disputeSetting =
         })
             .catch((err) => {
             console.error('[SDK] Failed to load geodata from CDN:', err);
+            if (cancelled)
+                return;
+            // English is prefetched on module load (iso3166.ts). If it
+            // landed, unblock the UI — getCountriesCached() falls back to 'en'.
+            if (isLanguageRegistered('en')) {
+                setIsLanguageLoaded(true);
+                return;
+            }
+            // Otherwise try one last English fetch as ultimate fallback.
+            ensureGeoDataLoaded('en')
+                .then(() => { if (!cancelled)
+                setIsLanguageLoaded(true); })
+                .catch(() => { });
         });
         return () => { cancelled = true; };
-    }, [language, autoImport]);
+    }, [effectiveLanguage, autoImport]);
     const data = useMemo(() => {
         if (!isLanguageLoaded) {
             return {
@@ -34,7 +52,7 @@ export function useISOData(language = 'en', autoImport = true, disputeSetting =
             };
         }
         try {
-            const countriesArray = getCountries(language);
+            const countriesArray = getCountries(effectiveLanguage);
             const countries = {};
             countriesArray.forEach((country) => {
                 countries[country.code] = {
@@ -46,7 +64,7 @@ export function useISOData(language = 'en', autoImport = true, disputeSetting =
             });
             const getRegions = (countryCode) => {
                 try {
-                    const states = getStatesForCountry(countryCode, language);
+                    const states = getStatesForCountry(countryCode, effectiveLanguage);
                     return states.map((state) => ({
                         iso: state.code,
                         name: state.name,
@@ -97,7 +115,7 @@ export function useISOData(language = 'en', autoImport = true, disputeSetting =
                 registeredLanguages,
             };
         }
-    }, [language, disputeSetting, isLanguageLoaded, registeredLanguages]);
+    }, [effectiveLanguage, disputeSetting, isLanguageLoaded, registeredLanguages]);
     return data;
 }
 /**

package/dist/v2/react/hooks/usePaymentPolling.d.ts

@@ -4,7 +4,7 @@ export interface Payment {
     subStatus: string;
     requireAction: 'none' | 'redirect' | 'redirect_to_payment' | 'error' | 'radar' | 'stripe_express_checkout';
     requireActionData?: {
-        type: 'redirect' | 'redirect_to_payment' | 'threeds_auth' | 'processor_auth' | 'error' | 'stripe_radar' | 'finix_radar' | 'radar' | 'kesspay_auth' | 'trustflow_auth' | 'mastercard_auth' | 'stripe_express_checkout';
+        type: 'redirect' | 'redirect_to_payment' | 'threeds_auth' | 'processor_auth' | 'error' | 'stripe_radar' | 'finix_radar' | 'radar' | 'kesspay_auth' | 'trustflow_auth' | 'mastercard_auth' | 'ngenius_3ds' | 'stripe_express_checkout';
         url?: string;
         processed: boolean;
         processorId?: string;