@glideidentity/web-client-sdk 4.4.8-beta.3 → 4.4.9

package/dist/core/phone-auth/client.js

@@ -206,6 +206,10 @@ class PhoneAuthClient {
                 }
                 // Step 3: Process the response through appropriate endpoint
                 const credential = credentialResponse;
+                // Validate use_case is provided for endpoint selection
+                if (!options.use_case) {
+                    throw this.createError(error_utils_1.PhoneAuthErrorCode.MISSING_PARAMETERS, 'use_case is required', { field: 'use_case' });
+                }
                 const result = options.use_case === API.USE_CASE.GET_PHONE_NUMBER
                     ? yield this.getPhoneNumber(credential, preparedRequest.session)
                     : yield this.verifyPhoneNumber(credential, preparedRequest.session);
@@ -314,16 +318,7 @@ class PhoneAuthClient {
      */
     preparePhoneRequest(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Validate use case requirements first
-            // const useCaseValidation = validateUseCaseRequirements(options.use_case, options.phone_number);
-            // if (!useCaseValidation.valid) {
-            //   throw this.createError(
-            //     PhoneAuthErrorCode.BAD_REQUEST,
-            //     useCaseValidation.error!,
-            //     { field: 'use_case' }
-            //   );
-            // }
-            var _a, _b;
+            var _a, _b, _c;
             // Validate phone number if provided
             if (options.phone_number) {
                 const phoneValidation = (0, validation_utils_1.validatePhoneNumber)(options.phone_number);
@@ -345,8 +340,12 @@ class PhoneAuthClient {
                     throw this.createError(error_utils_1.PhoneAuthErrorCode.BAD_REQUEST, consentValidation.error, { field: 'consent_data' });
                 }
             }
+            // Validate use_case is provided (unless only parent_session_id is given)
+            if (!options.use_case && !(((_a = options.options) === null || _a === void 0 ? void 0 : _a.parent_session_id) && !options.phone_number && !options.plmn)) {
+                throw this.createError(error_utils_1.PhoneAuthErrorCode.MISSING_PARAMETERS, 'use_case is required', { field: 'use_case' });
+            }
             // Validate required parameters based on use case
-            if (!options.phone_number && !options.plmn && !((_a = options.options) === null || _a === void 0 ? void 0 : _a.parent_session_id)) {
+            if (!options.phone_number && !options.plmn && !((_b = options.options) === null || _b === void 0 ? void 0 : _b.parent_session_id)) {
                 // Provide specific error message based on use case
                 if (options.use_case === API.USE_CASE.GET_PHONE_NUMBER) {
                     throw this.createError(error_utils_1.PhoneAuthErrorCode.MISSING_PARAMETERS, 'PLMN (MCC/MNC) is required for GetPhoneNumber. Please provide carrier network information.', { field: 'plmn', useCase: 'GetPhoneNumber' });
@@ -354,19 +353,15 @@ class PhoneAuthClient {
                 else if (options.use_case === API.USE_CASE.VERIFY_PHONE_NUMBER) {
                     throw this.createError(error_utils_1.PhoneAuthErrorCode.MISSING_PARAMETERS, 'Phone number is required for VerifyPhoneNumber', { field: 'phoneNumber', useCase: 'VerifyPhoneNumber' });
                 }
-                else if (!options.use_case) {
-                    // If no use case, that's an error
-                    throw this.createError(error_utils_1.PhoneAuthErrorCode.MISSING_PARAMETERS, 'use_case is required', { field: 'use_case' });
-                }
                 else {
                     // Fallback for other use cases
                     throw this.createError(error_utils_1.PhoneAuthErrorCode.MISSING_PARAMETERS, 'Either phone number or PLMN (MCC/MNC) must be provided', { field: 'phoneNumber,plmn' });
                 }
             }
-            // If only parent_session_id is provided, use_case is optional (will be inherited)
-            if (((_b = options.options) === null || _b === void 0 ? void 0 : _b.parent_session_id) && !options.phone_number && !options.plmn && !options.use_case) {
+            // Log parent session usage
+            if (((_c = options.options) === null || _c === void 0 ? void 0 : _c.parent_session_id) && !options.phone_number && !options.plmn) {
                 if (this.debug) {
-                    console.log('[PhoneAuth] Using parent_session_id only - all fields will be inherited from parent session');
+                    console.log('[PhoneAuth] Using parent_session_id: %s, use_case: %s', options.options.parent_session_id, options.use_case || 'not provided');
                 }
             }
             const requestId = `web-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
@@ -381,11 +376,13 @@ class PhoneAuthClient {
                 throw this.createError(error_utils_1.PhoneAuthErrorCode.INTERNAL_SERVER_ERROR, 'Failed to generate valid nonce', { field: 'nonce' });
             }
             // Build properly typed request body according to API specification
+            // Be permissive - backend will ignore extra fields if not needed
             const requestBody = {
-                // Required fields
+                // Include use_case if provided (optional when parent_session_id is given)
                 use_case: options.use_case,
-                // One of these is required
+                // Include phone_number if provided (backend ignores if not needed)
                 phone_number: options.phone_number,
+                // Include PLMN if provided
                 plmn: options.plmn ? {
                     mcc: options.plmn.mcc,
                     mnc: options.plmn.mnc
@@ -417,7 +414,7 @@ class PhoneAuthClient {
                         // Always include the HTTP status from the response
                         errorDetails = Object.assign(Object.assign({}, errorDetails), { status: response.status });
                     }
-                    catch (_c) {
+                    catch (_d) {
                         // If JSON parsing fails, use status text
                         errorDetails = { status: response.status, statusText: response.statusText };
                     }
@@ -685,12 +682,15 @@ class PhoneAuthClient {
                 });
                 // TS43 always auto-triggers (no SDK UI ever)
                 // The Digital Credentials API provides its own OS-level UI
-                let credentialPromise;
+                // Use a wrapper object to allow updating the promise reference
+                const credentialWrapper = {
+                    promise: null
+                };
                 try {
                     // Always try to trigger immediately
                     const vpToken = yield enhancedTriggerTS43();
                     // Convert to AuthCredential format
-                    credentialPromise = Promise.resolve({
+                    credentialWrapper.promise = Promise.resolve({
                         credential: typeof vpToken === 'string' ? vpToken : Object.values(vpToken)[0],
                         session: plainResponse.session,
                         authenticated: true
@@ -698,36 +698,46 @@ class PhoneAuthClient {
                 }
                 catch (error) {
                     // If auto-trigger fails, create a rejected promise
-                    credentialPromise = Promise.reject(error);
+                    credentialWrapper.promise = Promise.reject(error);
                 }
                 // Handle based on execution mode
                 if (executionMode === 'extended') {
                     // Extended mode - return control methods
-                    return {
+                    const response = {
                         strategy: 'ts43',
                         session: plainResponse.session,
-                        credential: credentialPromise,
+                        credential: credentialWrapper.promise, // Initial value
                         // Re-trigger credential request
                         trigger: () => __awaiter(this, void 0, void 0, function* () {
                             const vpToken = yield enhancedTriggerTS43();
-                            // Update the credential promise
-                            credentialPromise = Promise.resolve({
+                            // Update the credential promise in the wrapper
+                            credentialWrapper.promise = Promise.resolve({
                                 credential: typeof vpToken === 'string' ? vpToken : Object.values(vpToken)[0],
                                 session: plainResponse.session,
                                 authenticated: true
                             });
+                            // Return void as per interface
                         }),
                         cancel: () => {
                             // TS43 doesn't have a way to cancel once triggered
                             // but we can reject the promise
-                            credentialPromise = Promise.reject(this.createError(error_utils_1.PhoneAuthErrorCode.USER_DENIED, 'Authentication cancelled'));
+                            credentialWrapper.promise = Promise.reject(this.createError(error_utils_1.PhoneAuthErrorCode.USER_DENIED, 'Authentication cancelled'));
                         }
                     };
+                    // Define credential as a getter that always returns the current promise
+                    Object.defineProperty(response, 'credential', {
+                        get() {
+                            return credentialWrapper.promise;
+                        },
+                        enumerable: true,
+                        configurable: true
+                    });
+                    return response;
                 }
                 else {
                     // Standard mode - just return credential
                     // Wait for and return the credential
-                    const credential = yield credentialPromise;
+                    const credential = yield credentialWrapper.promise;
                     // Return in standard format
                     return {
                         [plainResponse.session.session_key]: credential.credential
@@ -757,7 +767,7 @@ class PhoneAuthClient {
                 const pollingEndpointToUse = (invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.pollingEndpoint) ||
                     (desktopOptions === null || desktopOptions === void 0 ? void 0 : desktopOptions.pollingEndpoint) ||
                     ((_m = this.config.endpoints) === null || _m === void 0 ? void 0 : _m.polling);
-                const pollingOptions = Object.assign(Object.assign({}, desktopOptions), { pollingEndpoint: pollingEndpointToUse, pollingInterval: (invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.pollingInterval) || (desktopOptions === null || desktopOptions === void 0 ? void 0 : desktopOptions.pollingInterval) || this.config.pollingInterval || 2000, maxPollingAttempts: (invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.maxPollingAttempts) || (desktopOptions === null || desktopOptions === void 0 ? void 0 : desktopOptions.maxPollingAttempts) || this.config.maxPollingAttempts || 150, onQRCodeReady: undefined, onStatusUpdate: undefined });
+                const pollingOptions = Object.assign(Object.assign({}, desktopOptions), { pollingEndpoint: pollingEndpointToUse, pollingInterval: (invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.pollingInterval) || (desktopOptions === null || desktopOptions === void 0 ? void 0 : desktopOptions.pollingInterval) || this.config.pollingInterval || 2000, maxPollingAttempts: (invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.maxPollingAttempts) || (desktopOptions === null || desktopOptions === void 0 ? void 0 : desktopOptions.maxPollingAttempts) || this.config.maxPollingAttempts || 30, onQRCodeReady: undefined, onStatusUpdate: undefined });
                 // Decide whether to show modal based on preventDefaultUI
                 const showModal = !preventDefaultUI;
                 let modal;
@@ -820,31 +830,79 @@ class PhoneAuthClient {
                 // Handle based on execution mode
                 if (executionMode === 'extended') {
                     // Extended mode - return control methods
-                    const credentialPromise = showModal ? startPolling() : Promise.resolve({
-                        credential: '',
-                        session: plainResponse.session,
-                        authenticated: false
+                    let credentialResolve = null;
+                    let credentialReject = null;
+                    let pollingStarted = false;
+                    // Create a promise that will remain pending until polling starts
+                    const credentialPromise = new Promise((resolve, reject) => {
+                        credentialResolve = resolve;
+                        credentialReject = reject;
+                        // If modal is shown, start polling immediately
+                        if (showModal) {
+                            pollingStarted = true;
+                            startPolling()
+                                .then(resolve)
+                                .catch(reject);
+                        }
+                        // Otherwise, promise remains pending until start_polling() is called
                     });
-                    return {
+                    // Create wrapped functions
+                    const wrappedStartPolling = () => __awaiter(this, void 0, void 0, function* () {
+                        if (pollingStarted) {
+                            throw this.createError(error_utils_1.PhoneAuthErrorCode.INVALID_SESSION_STATE, 'Polling has already been started');
+                        }
+                        pollingStarted = true;
+                        try {
+                            const result = yield startPolling();
+                            if (credentialResolve) {
+                                credentialResolve(result);
+                            }
+                            return result;
+                        }
+                        catch (err) {
+                            if (credentialReject) {
+                                credentialReject(err);
+                            }
+                            throw err;
+                        }
+                    });
+                    const wrappedStopPolling = () => {
+                        handler.cleanup();
+                        if (modal)
+                            modal.close();
+                    };
+                    const wrappedCancel = () => {
+                        handler.cancel();
+                        handler.cleanup();
+                        if (modal)
+                            modal.close();
+                        // Reject the credential promise if it's still pending
+                        if (!pollingStarted && credentialReject) {
+                            credentialReject(this.createError(error_utils_1.PhoneAuthErrorCode.USER_DENIED, 'Desktop authentication cancelled by user'));
+                        }
+                    };
+                    // Create the response object with a getter for is_polling
+                    const response = {
                         strategy: 'desktop',
                         session: plainResponse.session,
                         credential: credentialPromise,
                         qr_code_data: qrCodeDataSnakeCase,
                         modal_ref: modalRef,
-                        start_polling: startPolling,
-                        stop_polling: () => {
-                            handler.cleanup();
-                            if (modal)
-                                modal.close();
-                        },
-                        cancel: () => {
-                            handler.cancel();
-                            handler.cleanup();
-                            if (modal)
-                                modal.close();
-                        },
-                        is_polling: showModal // If modal shown, polling already started
+                        start_polling: wrappedStartPolling,
+                        stop_polling: wrappedStopPolling,
+                        cancel: wrappedCancel,
+                        // This will be replaced with a getter
+                        is_polling: false // Initial value, will be overridden by getter
                     };
+                    // Define is_polling as a getter that returns current state
+                    Object.defineProperty(response, 'is_polling', {
+                        get() {
+                            return handler.isPolling();
+                        },
+                        enumerable: true,
+                        configurable: true
+                    });
+                    return response;
                 }
                 else {
                     // Standard mode - return credential when complete
@@ -908,28 +966,66 @@ class PhoneAuthClient {
                 const pollingOptions = {
                     pollingEndpoint: (invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.pollingEndpoint) || ((_q = this.config.endpoints) === null || _q === void 0 ? void 0 : _q.polling),
                     pollingInterval: (invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.pollingInterval) || this.config.pollingInterval || 2000,
-                    maxPollingAttempts: (invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.maxPollingAttempts) || this.config.maxPollingAttempts || 150,
+                    maxPollingAttempts: (invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.maxPollingAttempts) || this.config.maxPollingAttempts || 30,
                     onLinkOpened: undefined,
                     onStatusUpdate: undefined
                 };
                 console.log('[PhoneAuth Client] Final Link polling options:', pollingOptions);
-                // Create credential promise
-                const credentialPromise = handler.invoke(plainResponse, pollingOptions).then(result => {
-                    if (result.authenticated && result.credential) {
-                        return {
-                            credential: result.credential,
-                            session: plainResponse.session,
-                            authenticated: true
-                        };
-                    }
-                    else {
-                        throw this.createError(error_utils_1.PhoneAuthErrorCode.USER_DENIED, result.error || 'Link authentication failed');
-                    }
-                });
                 // Handle based on execution mode
                 if (executionMode === 'extended') {
-                    // Extended mode - return control methods
-                    return {
+                    // Extended mode - return control methods and start polling immediately
+                    let pollingStarted = false;
+                    let pollingPromise = null;
+                    // Start polling immediately (Link always polls automatically unlike Desktop)
+                    pollingPromise = handler.invoke(plainResponse, pollingOptions);
+                    pollingStarted = true;
+                    // Create credential promise from the polling result
+                    const credentialPromise = pollingPromise.then(result => {
+                        if (result.authenticated && result.credential) {
+                            return {
+                                credential: result.credential,
+                                session: plainResponse.session,
+                                authenticated: true
+                            };
+                        }
+                        else {
+                            throw this.createError(error_utils_1.PhoneAuthErrorCode.USER_DENIED, result.error || 'Link authentication failed');
+                        }
+                    });
+                    // Function to restart polling (for retry scenarios)
+                    const startPolling = () => __awaiter(this, void 0, void 0, function* () {
+                        if (!pollingStarted) {
+                            // This is here for API consistency, but for Link it's already polling
+                            pollingStarted = true;
+                            if (!pollingPromise) {
+                                pollingPromise = handler.invoke(plainResponse, pollingOptions);
+                            }
+                            const result = yield pollingPromise;
+                            if (result.authenticated && result.credential) {
+                                return {
+                                    credential: result.credential,
+                                    session: plainResponse.session,
+                                    authenticated: true
+                                };
+                            }
+                            else {
+                                throw this.createError(error_utils_1.PhoneAuthErrorCode.USER_DENIED, result.error || 'Link authentication failed');
+                            }
+                        }
+                        // If already polling, just return the existing promise result
+                        const result = yield pollingPromise;
+                        if (result.authenticated && result.credential) {
+                            return {
+                                credential: result.credential,
+                                session: plainResponse.session,
+                                authenticated: true
+                            };
+                        }
+                        else {
+                            throw this.createError(error_utils_1.PhoneAuthErrorCode.USER_DENIED, result.error || 'Link authentication failed');
+                        }
+                    });
+                    const response = {
                         strategy: 'link',
                         session: plainResponse.session,
                         credential: credentialPromise,
@@ -938,22 +1034,42 @@ class PhoneAuthClient {
                         },
                         // Re-open the app link
                         trigger: triggerLink,
-                        // Polling control
-                        start_polling: () => handler.invoke(plainResponse, pollingOptions).then(result => ({
-                            credential: result.credential || '',
-                            session: plainResponse.session,
-                            authenticated: result.authenticated
-                        })),
+                        // Polling control - now prevents double polling
+                        start_polling: startPolling,
                         stop_polling: () => handler.cleanup(),
                         cancel: () => {
                             handler.cancel();
                             handler.cleanup();
+                            // Note: For Link, polling is already started, so the promise 
+                            // will be rejected by the handler.cancel() call
                         },
-                        is_polling: true
+                        // This will be replaced with a getter
+                        is_polling: false // Initial value, will be overridden by getter
                     };
+                    // Define is_polling as a getter that returns current state
+                    Object.defineProperty(response, 'is_polling', {
+                        get() {
+                            return handler.isPolling();
+                        },
+                        enumerable: true,
+                        configurable: true
+                    });
+                    return response;
                 }
                 else {
-                    // Standard mode - return credential when complete
+                    // Standard mode - start polling immediately and wait for completion
+                    const credentialPromise = handler.invoke(plainResponse, pollingOptions).then(result => {
+                        if (result.authenticated && result.credential) {
+                            return {
+                                credential: result.credential,
+                                session: plainResponse.session,
+                                authenticated: true
+                            };
+                        }
+                        else {
+                            throw this.createError(error_utils_1.PhoneAuthErrorCode.USER_DENIED, result.error || 'Link authentication failed');
+                        }
+                    });
                     // Wait for credential and return in standard format
                     const credential = yield credentialPromise;
                     const aggregatorId = this.config.aggregatorId || 'default';

package/dist/core/phone-auth/strategies/desktop.d.ts

@@ -17,7 +17,7 @@ export interface QRCodeData {
 export interface DesktopAuthOptions {
     /** Custom polling interval in milliseconds (overrides server-provided value) */
     pollingInterval?: number;
-    /** Maximum polling attempts before timeout (default: 150 = 5 minutes with 2s interval) */
+    /** Maximum polling attempts before timeout (default: 30 = 1 minute with 2s interval) */
     maxPollingAttempts?: number;
     /** Custom polling endpoint (overrides backend-provided or uses configured endpoint) */
     pollingEndpoint?: string;
@@ -56,6 +56,7 @@ export declare class DesktopHandler implements StrategyHandler {
     private isCancelled;
     private onCancel?;
     private pollingReject?;
+    private isPollingInProgress;
     /**
      * Maps backend HTTP status codes to client status
      * @param httpStatus HTTP status code from backend
@@ -76,6 +77,10 @@ export declare class DesktopHandler implements StrategyHandler {
      * Stop polling
      */
     private stopPolling;
+    /**
+     * Check if polling is currently active
+     */
+    isPolling(): boolean;
     /**
      * Format response for backend processing
      * Desktop strategy typically returns the credential from mobile authentication
@@ -98,7 +103,7 @@ export declare class DesktopHandler implements StrategyHandler {
 /**
  * Helper function to display QR code in a modal or inline
  */
-export declare function createQRCodeDisplay(qrCodeData: string, options?: {
+export declare function createQRCodeDisplay(qrCodeData: string | QRCodeData, options?: {
     container?: HTMLElement;
     size?: number;
     title?: string;
@@ -106,8 +111,9 @@ export declare function createQRCodeDisplay(qrCodeData: string, options?: {
 }): HTMLElement;
 /**
  * Helper function to create a modal for QR code display
+ * Supports both string QR codes and QRCodeData objects for dual-platform support
  */
-export declare function showQRCodeModal(qrCodeData: string, options?: {
+export declare function showQRCodeModal(qrCodeData: string | QRCodeData, options?: {
     title?: string;
     description?: string;
     onClose?: () => void;

package/dist/core/phone-auth/strategies/desktop.js

@@ -21,6 +21,7 @@ class DesktopHandler {
     constructor() {
         this.pollingAttempts = 0;
         this.isCancelled = false;
+        this.isPollingInProgress = false;
     }
     /**
      * Maps backend HTTP status codes to client status
@@ -63,8 +64,8 @@ class DesktopHandler {
                 const innerData = desktopData.data;
                 // Try to extract from inner data
                 // Support both single QR (qr_code_image) and dual-platform QR (ios/android)
-                if (innerData.ios_qr_image || innerData.android_qr_image) {
-                    // Dual-platform QR format
+                if (innerData.ios_qr_image && innerData.android_qr_image) {
+                    // Dual-platform QR format - both must be present
                     qrCode = {
                         iosQRCode: innerData.ios_qr_image,
                         androidQRCode: innerData.android_qr_image,
@@ -72,6 +73,10 @@ class DesktopHandler {
                         androidUrl: innerData.android_url
                     };
                 }
+                else if (innerData.ios_qr_image || innerData.android_qr_image) {
+                    // Only one platform QR - use as single QR format
+                    qrCode = innerData.ios_qr_image || innerData.android_qr_image;
+                }
                 else {
                     // Single QR format (legacy)
                     qrCode = innerData.qr_code_image || innerData.qr_code;
@@ -122,7 +127,7 @@ class DesktopHandler {
             console.log('[Desktop QR] Selected endpoint:', finalPollingEndpoint, 'from source:', endpointSource);
             // Start polling for authentication status
             const finalPollingInterval = (options === null || options === void 0 ? void 0 : options.pollingInterval) || pollingInterval || 2000;
-            const maxAttempts = (options === null || options === void 0 ? void 0 : options.maxPollingAttempts) || 150; // Default to 5 minutes
+            const maxAttempts = (options === null || options === void 0 ? void 0 : options.maxPollingAttempts) || 30; // Default to 1 minute
             console.log(`[Desktop QR] Starting polling - endpoint source: ${endpointSource}, interval: ${finalPollingInterval}ms, max attempts: ${maxAttempts}`);
             return this.startPolling(finalPollingEndpoint || '', // Pass empty string if undefined, will use fallback
             sessionId, finalPollingInterval, maxAttempts, expiresIn || 300, // Default 5 minutes expiry
@@ -141,7 +146,12 @@ class DesktopHandler {
                 // Store the reject function so we can call it from cancel()
                 this.pollingReject = reject;
                 const poll = () => __awaiter(this, void 0, void 0, function* () {
+                    // Skip if another poll is already in progress
+                    if (this.isPollingInProgress) {
+                        return;
+                    }
                     try {
+                        this.isPollingInProgress = true;
                         // Check if cancelled
                         if (this.isCancelled) {
                             this.stopPolling();
@@ -365,6 +375,10 @@ class DesktopHandler {
                             });
                         }
                     }
+                    finally {
+                        // Always clear the polling flag when done
+                        this.isPollingInProgress = false;
+                    }
                 });
                 // Start initial poll
                 poll();
@@ -383,8 +397,15 @@ class DesktopHandler {
             this.pollingIntervalId = undefined;
         }
         this.pollingAttempts = 0;
+        this.isPollingInProgress = false;
         // Don't clear pollingReject here - it's needed by cancel()
     }
+    /**
+     * Check if polling is currently active
+     */
+    isPolling() {
+        return this.pollingIntervalId !== undefined;
+    }
     /**
      * Format response for backend processing
      * Desktop strategy typically returns the credential from mobile authentication
@@ -443,9 +464,30 @@ exports.DesktopHandler = DesktopHandler;
 function createQRCodeDisplay(qrCodeData, options) {
     const container = (options === null || options === void 0 ? void 0 : options.container) || document.createElement('div');
     container.className = 'phone-auth-qr-container';
+    // Determine QR code to display
+    let qrCodeSrc;
+    if (typeof qrCodeData === 'string') {
+        // Simple string QR code
+        qrCodeSrc = qrCodeData;
+    }
+    else if (qrCodeData && typeof qrCodeData === 'object') {
+        // QRCodeData object - prefer iOS QR if available
+        if (qrCodeData.iosQRCode) {
+            qrCodeSrc = qrCodeData.iosQRCode;
+        }
+        else if (qrCodeData.androidQRCode) {
+            qrCodeSrc = qrCodeData.androidQRCode;
+        }
+        else {
+            throw new Error('Invalid QRCodeData: missing QR code images');
+        }
+    }
+    else {
+        throw new Error('Invalid qrCodeData: must be string or QRCodeData object');
+    }
     // Create QR code image
     const img = document.createElement('img');
-    img.src = qrCodeData;
+    img.src = qrCodeSrc;
     img.alt = 'QR Code for authentication';
     img.style.width = `${(options === null || options === void 0 ? void 0 : options.size) || 256}px`;
     img.style.height = `${(options === null || options === void 0 ? void 0 : options.size) || 256}px`;
@@ -473,6 +515,7 @@ function createQRCodeDisplay(qrCodeData, options) {
 }
 /**
  * Helper function to create a modal for QR code display
+ * Supports both string QR codes and QRCodeData objects for dual-platform support
  */
 function showQRCodeModal(qrCodeData, options) {
     // Create modal overlay

package/dist/core/phone-auth/strategies/link.d.ts

@@ -8,7 +8,7 @@ import type { PrepareResponse } from '../types';
 export interface LinkAuthOptions {
     /** Fixed polling interval in milliseconds (default: 2000) */
     pollingInterval?: number;
-    /** Maximum polling attempts before timeout (default: 150 = 5 minutes with 2s interval) */
+    /** Maximum polling attempts before timeout (default: 30 = 1 minute with 2s interval) */
     maxPollingAttempts?: number;
     /** Custom polling endpoint (overrides backend-provided or configured endpoint) */
     pollingEndpoint?: string;
@@ -41,9 +41,11 @@ export interface LinkAuthResult {
 }
 export declare class LinkHandler implements StrategyHandler {
     private pollingInterval?;
-    private isPolling;
+    private isPollingActive;
     private isCancelled;
     private onCancel?;
+    private pollingReject?;
+    private isPollingInProgress;
     /**
      * Invoke link-based authentication
      * Opens authentication app while keeping user on current page
@@ -74,6 +76,10 @@ export declare class LinkHandler implements StrategyHandler {
      * Clean up resources (stop polling if active)
      */
     cleanup(): void;
+    /**
+     * Check if polling is currently active
+     */
+    isPolling(): boolean;
     /**
      * Cancel the ongoing authentication
      */