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

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

@@ -54,7 +54,7 @@ const link_1 = require("./strategies/link");
 const modal_1 = require("./ui/modal");
 class PhoneAuthClient {
     constructor(config = {}) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         this.crossDeviceActive = false;
         this.retryCount = 0;
         this.sessionCache = new Map();
@@ -64,7 +64,8 @@ class PhoneAuthClient {
         this.config = {
             endpoints: {
                 prepare: ((_a = config.endpoints) === null || _a === void 0 ? void 0 : _a.prepare) || '/api/magic-auth/prepare',
-                process: ((_b = config.endpoints) === null || _b === void 0 ? void 0 : _b.process) || '/api/magic-auth/process'
+                process: ((_b = config.endpoints) === null || _b === void 0 ? void 0 : _b.process) || '/api/magic-auth/process',
+                polling: (_c = config.endpoints) === null || _c === void 0 ? void 0 : _c.polling // Pass through the polling endpoint
             },
             timeout: config.timeout || 30000,
             pollingInterval: config.pollingInterval || 2000, // Default 2 seconds
@@ -87,7 +88,7 @@ class PhoneAuthClient {
             custom: config.logger
         });
         // Initialize developer tools if configured
-        if (((_c = config.devtools) === null || _c === void 0 ? void 0 : _c.showMobileConsole) && typeof window !== 'undefined') {
+        if (((_d = config.devtools) === null || _d === void 0 ? void 0 : _d.showMobileConsole) && typeof window !== 'undefined') {
             Promise.resolve().then(() => __importStar(require('./ui/mobile-debug-console'))).then(({ MobileDebugConsole }) => {
                 MobileDebugConsole.init();
                 console.log('[PhoneAuth] Mobile debug console enabled');
@@ -487,23 +488,25 @@ class PhoneAuthClient {
      * });
      * ```
      *
-     * @example Headless Mode (returns data)
+     * @example Extended Mode (returns control methods)
      * ```typescript
-     * // Get raw data without showing UI
+     * // Get control methods for custom implementation
      * const result = await phoneAuth.invokeSecurePrompt(prepareResult, {
-     *   headless: true
+     *   executionMode: 'extended',
+     *   preventDefaultUI: true  // Desktop: no modal
      * });
      *
-     * if (result.strategy === 'link') {
-     *   // Open URL yourself
-     *   window.open(result.url);
-     *   await result.pollingPromise; // Wait for completion
+     * if (result.strategy === 'desktop') {
+     *   // Show custom QR UI
+     *   showCustomQR(result.qr_code_data);
+     *   // Start polling
+     *   await result.start_polling();
      * }
      * ```
      *
      * @param prepareResponse - Response from prepare() with strategy and data
-     * @param options - Control UI behavior or enable headless mode
-     * @returns Credential or HeadlessResult based on mode
+     * @param options - Control UI behavior and response type
+     * @returns Credential or ExtendedResponse based on executionMode
      */
     invokeSecurePrompt(prepareResponse, options) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -511,7 +514,7 @@ class PhoneAuthClient {
             // This ensures we work with plain objects for browser APIs
             // Vue's reactivity system wraps objects in Proxies which can interfere
             // with browser APIs like Digital Credentials API that expect plain objects
-            var _a, _b, _c;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
             // Try structuredClone first (modern browsers), but catch errors and fallback to JSON method
             let plainResponse;
             try {
@@ -531,16 +534,17 @@ class PhoneAuthClient {
             console.log('[PhoneAuth] Session cache size:', this.sessionCache.size);
             console.log('[PhoneAuth] Retry count:', this.retryCount);
             console.log('[PhoneAuth] PrepareResponse received:', JSON.stringify(plainResponse, null, 2));
-            // Check if we're in headless mode (new InvokeOptions format)
+            // Check if we're using new InvokeOptions format
             // Properly detect InvokeOptions by checking for any of its properties
-            const invokeOptions = options && ('headless' in options ||
+            const invokeOptions = options && ('preventDefaultUI' in options ||
+                'executionMode' in options ||
                 'theme' in options ||
                 'modalOptions' in options ||
                 'callbacks' in options) ? options : undefined;
-            // Smart defaults: Link and TS43 default to headless, Desktop defaults to UI mode
+            // Get configuration from options
             const strategy = plainResponse.authentication_strategy;
-            const defaultHeadless = strategy === 'link' || strategy === 'ts43' ? true : false;
-            const isHeadless = (_a = invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.headless) !== null && _a !== void 0 ? _a : defaultHeadless;
+            const preventDefaultUI = (_a = invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.preventDefaultUI) !== null && _a !== void 0 ? _a : false;
+            const executionMode = (_b = invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.executionMode) !== null && _b !== void 0 ? _b : 'standard';
             // DesktopAuthOptions is only used if not InvokeOptions
             const desktopOptions = options && !invokeOptions ? options : undefined;
             // Handle based on authentication strategy
@@ -679,270 +683,281 @@ class PhoneAuthClient {
                         throw error;
                     }
                 });
-                // Headless mode for TS43 still returns the trigger function for custom UI
-                // This allows developers to control WHEN to trigger, but not HOW
-                if (isHeadless) {
-                    // Auto-trigger for TS43 if enabled (may fail due to browser restrictions)
-                    if ((invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.autoTrigger) !== false) {
-                        try {
-                            // Try to trigger immediately if we have user gesture context
-                            const result = yield enhancedTriggerTS43();
-                            // If successful, return the result directly
-                            return result;
-                        }
-                        catch (error) {
-                            // If auto-trigger fails, continue to return HeadlessResult with trigger
-                            if (this.debug) {
-                                console.log('[TS43] Auto-trigger failed, returning trigger function:', error);
-                            }
-                        }
-                    }
-                    // Return trigger function for developers who want to control timing
+                // TS43 always auto-triggers (no SDK UI ever)
+                // The Digital Credentials API provides its own OS-level UI
+                let credentialPromise;
+                try {
+                    // Always try to trigger immediately
+                    const vpToken = yield enhancedTriggerTS43();
+                    // Convert to AuthCredential format
+                    credentialPromise = Promise.resolve({
+                        credential: typeof vpToken === 'string' ? vpToken : Object.values(vpToken)[0],
+                        session: plainResponse.session,
+                        authenticated: true
+                    });
+                }
+                catch (error) {
+                    // If auto-trigger fails, create a rejected promise
+                    credentialPromise = Promise.reject(error);
+                }
+                // Handle based on execution mode
+                if (executionMode === 'extended') {
+                    // Extended mode - return control methods
                     return {
-                        strategy: API.AUTHENTICATION_STRATEGY.TS43,
-                        credentialRequest: secureCredentialRequest,
-                        trigger: enhancedTriggerTS43,
-                        session: plainResponse.session
+                        strategy: 'ts43',
+                        session: plainResponse.session,
+                        credential: credentialPromise,
+                        // Re-trigger credential request
+                        trigger: () => __awaiter(this, void 0, void 0, function* () {
+                            const vpToken = yield enhancedTriggerTS43();
+                            // Update the credential promise
+                            credentialPromise = Promise.resolve({
+                                credential: typeof vpToken === 'string' ? vpToken : Object.values(vpToken)[0],
+                                session: plainResponse.session,
+                                authenticated: true
+                            });
+                        }),
+                        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'));
+                        }
                     };
                 }
                 else {
-                    // In UI mode, directly invoke the Digital Credentials API
-                    // No modal needed - the OS provides its own UI
-                    return yield enhancedTriggerTS43();
+                    // Standard mode - just return credential
+                    // Wait for and return the credential
+                    const credential = yield credentialPromise;
+                    // Return in standard format
+                    return {
+                        [plainResponse.session.session_key]: credential.credential
+                    };
                 }
             }
             else if (plainResponse.authentication_strategy === API.AUTHENTICATION_STRATEGY.DESKTOP) {
                 // Desktop strategy - QR code based authentication
                 const desktopData = plainResponse.data;
-                // Check if headless mode is requested
-                if (isHeadless) {
-                    // Return raw data for custom UI implementation
-                    const handler = new desktop_1.DesktopHandler();
-                    // Start polling in the background
-                    const pollingPromise = handler.invoke(plainResponse, Object.assign(Object.assign({}, desktopOptions), { 
-                        // Don't pass config.endpoints.polling - let backend-provided status_url take priority
-                        pollingInterval: this.config.pollingInterval || 2000, maxPollingAttempts: this.config.maxPollingAttempts || 150, 
-                        // No UI callbacks in headless mode
-                        onQRCodeReady: undefined, onStatusUpdate: undefined })).then(result => {
-                        if (result.authenticated && result.credential) {
-                            // Extract session ID from nested or flat structure
-                            let sessionId = 'default';
-                            // Check if desktopData has nested structure
-                            if (desktopData && typeof desktopData === 'object') {
-                                if (desktopData.data && typeof desktopData.data === 'object') {
-                                    // Nested structure: data.data.session_id
-                                    sessionId = desktopData.data.session_id || sessionId;
-                                }
-                                // Also check flat structure
-                                if (!sessionId || sessionId === 'default') {
-                                    sessionId = desktopData.session_id || sessionId;
-                                }
-                            }
-                            // Return credential in expected format for subsequent API calls
-                            return {
-                                [sessionId]: result.credential
-                            };
+                const handler = new desktop_1.DesktopHandler();
+                // Extract QR code data - convert to QRCodeData format for modal
+                const qrCodeData = {
+                    iosQRCode: ((_c = desktopData.data) === null || _c === void 0 ? void 0 : _c.ios_qr_image) || desktopData.ios_qr_image ||
+                        ((_d = desktopData.data) === null || _d === void 0 ? void 0 : _d.qr_code_image) || desktopData.qr_code_image || desktopData.qr_code || '',
+                    androidQRCode: ((_e = desktopData.data) === null || _e === void 0 ? void 0 : _e.android_qr_image) || desktopData.android_qr_image,
+                    iosUrl: ((_f = desktopData.data) === null || _f === void 0 ? void 0 : _f.ios_url) || desktopData.ios_url,
+                    androidUrl: ((_g = desktopData.data) === null || _g === void 0 ? void 0 : _g.android_url) || desktopData.android_url
+                };
+                // Also keep snake_case format for extended response
+                const qrCodeDataSnakeCase = {
+                    ios_qr_image: ((_h = desktopData.data) === null || _h === void 0 ? void 0 : _h.ios_qr_image) || desktopData.ios_qr_image,
+                    android_qr_image: ((_j = desktopData.data) === null || _j === void 0 ? void 0 : _j.android_qr_image) || desktopData.android_qr_image,
+                    qr_code: ((_k = desktopData.data) === null || _k === void 0 ? void 0 : _k.qr_code_image) || desktopData.qr_code_image || desktopData.qr_code,
+                    challenge: (_l = desktopData.data) === null || _l === void 0 ? void 0 : _l.challenge
+                };
+                // Polling options
+                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 });
+                // Decide whether to show modal based on preventDefaultUI
+                const showModal = !preventDefaultUI;
+                let modal;
+                let modalRef = undefined;
+                console.log('[Desktop] Modal decision:', {
+                    preventDefaultUI,
+                    showModal,
+                    executionMode,
+                    hasInvokeOptions: !!invokeOptions,
+                    hasDesktopOptions: !!desktopOptions
+                });
+                if (showModal) {
+                    console.log('[Desktop] Creating modal with QR data:', qrCodeData);
+                    // Create and setup modal
+                    modal = new modal_1.AuthModal(invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.modalOptions, invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.callbacks);
+                    modal.setCloseCallback(() => {
+                        this.log('Desktop QR modal closed by user, cancelling polling');
+                        handler.cancel();
+                    });
+                    // Add UI callbacks to polling options
+                    pollingOptions.onQRCodeReady = (qrData) => {
+                        console.log('[Desktop] onQRCodeReady callback triggered:', qrData);
+                        modal.showQRCode(qrData, 'Scan with your mobile device');
+                    };
+                    pollingOptions.onStatusUpdate = (status) => {
+                        if (status.status === 'pending') {
+                            modal.updateStatus('Waiting for authentication...');
+                        }
+                        else if (status.status === 'authenticated') {
+                            modal.updateStatus('Authentication successful!');
+                            setTimeout(() => modal.close(), 1500);
                         }
-                        else {
-                            throw this.createError(error_utils_1.PhoneAuthErrorCode.USER_DENIED, result.error || 'Desktop authentication failed');
+                        else if (status.status === 'expired') {
+                            modal.updateStatus('QR code expired', true);
                         }
+                        else if (status.status === 'error') {
+                            modal.updateStatus('Authentication failed', true);
+                        }
+                    };
+                    // Note: We don't show the QR code here. It will be shown by the onQRCodeReady callback
+                    // that gets triggered immediately when handler.invoke() is called
+                    modalRef = modal;
+                }
+                else {
+                    console.log('[Desktop] Modal not shown - preventDefaultUI is true');
+                }
+                // Create credential promise
+                const startPolling = () => 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 || 'Desktop authentication failed');
+                    }
+                });
+                // 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
                     });
                     return {
-                        strategy: API.AUTHENTICATION_STRATEGY.DESKTOP,
-                        qrCode: (_b = desktopData.data) === null || _b === void 0 ? void 0 : _b.qr_code_image, // data.data.qr_code_image
-                        pollingPromise,
-                        session: plainResponse.session
+                        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
                     };
                 }
                 else {
-                    // UI mode - show QR code modal
-                    const handler = new desktop_1.DesktopHandler();
-                    const modal = new modal_1.AuthModal(invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.modalOptions, invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.callbacks);
-                    // Default options with modal display
-                    const options = Object.assign(Object.assign({}, desktopOptions), { 
-                        // Don't pass config.endpoints.polling - let backend-provided status_url take priority
-                        // Only explicit desktopOptions.pollingEndpoint will override backend URL
-                        pollingInterval: (desktopOptions === null || desktopOptions === void 0 ? void 0 : desktopOptions.pollingInterval) || this.config.pollingInterval || 2000, maxPollingAttempts: (desktopOptions === null || desktopOptions === void 0 ? void 0 : desktopOptions.maxPollingAttempts) || this.config.maxPollingAttempts || 150, onQRCodeReady: (qrCodeData) => {
-                            // Show QR code in modal (supports both single and dual-platform)
-                            modal.showQRCode(qrCodeData, 'Scan with your mobile device');
-                        }, onStatusUpdate: (status) => {
-                            // Update status in modal
-                            if (status.status === 'pending') {
-                                modal.updateStatus('Waiting for authentication...');
-                            }
-                            else if (status.status === 'authenticated') {
-                                modal.updateStatus('Authentication successful!');
-                                setTimeout(() => modal.close(), 1500);
-                            }
-                            else if (status.status === 'expired') {
-                                modal.updateStatus('QR code expired', true);
-                            }
-                            else if (status.status === 'error') {
-                                modal.updateStatus('Authentication failed', true);
-                            }
-                        } });
+                    // Standard mode - return credential when complete
+                    // Start polling and wait for result
                     try {
-                        const result = yield handler.invoke(plainResponse, options);
-                        if (result.authenticated && result.credential) {
-                            // Extract session ID from nested or flat structure
-                            let sessionId = 'default';
-                            // Check if desktopData has nested structure
-                            if (desktopData && typeof desktopData === 'object') {
-                                if (desktopData.data && typeof desktopData.data === 'object') {
-                                    // Nested structure: data.data.session_id
-                                    sessionId = desktopData.data.session_id || sessionId;
-                                }
-                                // Also check flat structure
-                                if (!sessionId || sessionId === 'default') {
-                                    sessionId = desktopData.session_id || sessionId;
-                                }
+                        const credential = yield startPolling();
+                        // Extract session ID for compatibility
+                        let sessionId = 'default';
+                        if (desktopData && typeof desktopData === 'object') {
+                            if (desktopData.data && typeof desktopData.data === 'object') {
+                                sessionId = desktopData.data.session_id || sessionId;
+                            }
+                            if (!sessionId || sessionId === 'default') {
+                                sessionId = desktopData.session_id || sessionId;
                             }
-                            // Return credential in expected format for subsequent API calls
-                            return {
-                                [sessionId]: result.credential
-                            };
-                        }
-                        else {
-                            throw this.createError(error_utils_1.PhoneAuthErrorCode.USER_DENIED, result.error || 'Desktop authentication failed');
-                        }
-                    }
-                    catch (error) {
-                        if (error instanceof Error && error.name === 'PhoneAuthError') {
-                            throw error;
                         }
-                        throw this.createError(error_utils_1.PhoneAuthErrorCode.INTERNAL_SERVER_ERROR, `Desktop authentication error: ${error instanceof Error ? error.message : 'Unknown error'}`, { originalError: error });
+                        return { [sessionId]: credential.credential };
                     }
                     finally {
-                        // Ensure handler cleanup
                         handler.cleanup();
-                        modal.close();
+                        if (modal)
+                            modal.close();
                     }
                 }
             }
             else if (plainResponse.authentication_strategy === API.AUTHENTICATION_STRATEGY.LINK) {
                 // Link strategy - app-based authentication (iOS/Android)
                 const linkData = plainResponse.data;
-                // Check if headless mode is requested
-                if (isHeadless) {
-                    // Return raw data for custom UI implementation
-                    const handler = new link_1.LinkHandler();
-                    // Create reusable trigger function that ONLY opens the App Clip
-                    // This can be called multiple times without restarting polling
-                    const triggerLink = () => {
-                        var _a, _b;
-                        try {
-                            window.open(linkData.url, '_blank');
-                            (_a = invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.onTriggerAttempt) === null || _a === void 0 ? void 0 : _a.call(invokeOptions, {
-                                strategy: API.AUTHENTICATION_STRATEGY.LINK,
-                                url: linkData.url,
-                                success: true
-                            });
-                        }
-                        catch (error) {
-                            (_b = invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.onTriggerAttempt) === null || _b === void 0 ? void 0 : _b.call(invokeOptions, {
-                                strategy: API.AUTHENTICATION_STRATEGY.LINK,
-                                url: linkData.url,
-                                success: false,
-                                error
-                            });
-                        }
-                    };
-                    // Auto-trigger by default for Link strategy
-                    // This opens the App Clip immediately while preserving user gesture context
-                    if ((invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.autoTrigger) !== false) {
-                        triggerLink();
+                const handler = new link_1.LinkHandler();
+                // Create reusable trigger function that ONLY opens the App Clip
+                const triggerLink = () => {
+                    var _a, _b;
+                    try {
+                        window.open(linkData.url, '_blank');
+                        (_a = invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.onTriggerAttempt) === null || _a === void 0 ? void 0 : _a.call(invokeOptions, {
+                            strategy: API.AUTHENTICATION_STRATEGY.LINK,
+                            url: linkData.url,
+                            success: true
+                        });
                     }
-                    // Start polling in the background (independent of trigger)
-                    const pollingPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                        var _a;
-                        try {
-                            const result = yield handler.invoke(plainResponse, {
-                                pollingEndpoint: (_a = this.config.endpoints) === null || _a === void 0 ? void 0 : _a.polling,
-                                pollingInterval: this.config.pollingInterval || 2000,
-                                maxPollingAttempts: this.config.maxPollingAttempts || 150,
-                                // openMethod removed - always uses window.open()
-                                onLinkOpened: undefined,
-                                onStatusUpdate: undefined
-                            });
-                            if (result.authenticated && result.credential) {
-                                // Return credential in the expected format
-                                const aggregatorId = this.config.aggregatorId || 'default';
-                                resolve({ [aggregatorId]: result.credential });
-                            }
-                            else {
-                                reject(this.createError(error_utils_1.PhoneAuthErrorCode.USER_DENIED, result.error || 'Link authentication failed'));
-                            }
-                        }
-                        catch (error) {
-                            reject(error);
-                        }
-                    }));
+                    catch (error) {
+                        (_b = invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.onTriggerAttempt) === null || _b === void 0 ? void 0 : _b.call(invokeOptions, {
+                            strategy: API.AUTHENTICATION_STRATEGY.LINK,
+                            url: linkData.url,
+                            success: false,
+                            error
+                        });
+                    }
+                };
+                // Link always auto-opens the app (no SDK UI by default)
+                // Open immediately to preserve user gesture context
+                if ((invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.autoTrigger) !== false) {
+                    triggerLink();
+                }
+                // Start polling in the background
+                console.log('[PhoneAuth Client] Link polling config:', {
+                    fromInvokeOptions: invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.pollingEndpoint,
+                    fromClientConfig: (_o = this.config.endpoints) === null || _o === void 0 ? void 0 : _o.polling,
+                    finalPollingEndpoint: (invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.pollingEndpoint) || ((_p = this.config.endpoints) === null || _p === void 0 ? void 0 : _p.polling)
+                });
+                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,
+                    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 {
-                        strategy: API.AUTHENTICATION_STRATEGY.LINK,
-                        url: linkData.url,
-                        pollingPromise,
+                        strategy: 'link',
                         session: plainResponse.session,
-                        // Trigger function to open App Clip (can be called multiple times)
-                        // Does NOT restart polling - just opens the URL
-                        trigger: triggerLink
-                    };
-                }
-                else {
-                    // UI mode - show button to open app link
-                    const modal = new modal_1.AuthModal(invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.modalOptions, invokeOptions === null || invokeOptions === void 0 ? void 0 : invokeOptions.callbacks);
-                    const handler = new link_1.LinkHandler();
-                    // Show link button in modal - user MUST click the button to open the app link
-                    // This is critical for iOS to recognize the app link (requires user interaction)
-                    yield modal.showLinkButton(linkData.url);
-                    // Link options - the app link will be opened by user clicking the modal button
-                    const options = {
-                        // Use configured polling endpoint if available
-                        pollingEndpoint: (_c = this.config.endpoints) === null || _c === void 0 ? void 0 : _c.polling,
-                        pollingInterval: this.config.pollingInterval || 2000, // Default 2 second interval
-                        maxPollingAttempts: this.config.maxPollingAttempts || 150, // Default 5 minutes total
-                        onLinkOpened: () => {
-                            this.log('Authentication app link opened');
-                            modal.updateStatus('Waiting for app authentication...');
+                        credential: credentialPromise,
+                        data: {
+                            app_url: linkData.url
                         },
-                        onStatusUpdate: (status) => {
-                            this.log('Link authentication status update:', status);
-                            if (status.status === 'authenticated') {
-                                modal.updateStatus('Authentication successful!');
-                                setTimeout(() => modal.close(), 1500);
-                            }
-                            else if (status.status === 'error') {
-                                modal.updateStatus('Authentication failed', true);
-                            }
+                        // 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
+                        })),
+                        stop_polling: () => handler.cleanup(),
+                        cancel: () => {
+                            handler.cancel();
+                            handler.cleanup();
                         },
-                        onTimeout: () => {
-                            this.log('Link authentication timed out');
-                            modal.updateStatus('Authentication timed out', true);
-                        }
+                        is_polling: true
                     };
-                    try {
-                        const result = yield handler.invoke(plainResponse, options);
-                        if (result.authenticated && result.credential) {
-                            // Return the credential for further processing
-                            // The credential is typically the session key
-                            const aggregatorId = this.config.aggregatorId || 'default';
-                            modal.close();
-                            return { [aggregatorId]: result.credential };
-                        }
-                        else {
-                            throw this.createError(error_utils_1.PhoneAuthErrorCode.VERIFICATION_FAILED, result.error || 'Link authentication failed');
-                        }
-                    }
-                    catch (error) {
-                        modal.close();
-                        if (error instanceof Error && error.name === 'PhoneAuthError') {
-                            throw error;
-                        }
-                        throw this.createError(error_utils_1.PhoneAuthErrorCode.INTERNAL_SERVER_ERROR, `Link authentication error: ${error instanceof Error ? error.message : 'Unknown error'}`, { originalError: error });
-                    }
-                    finally {
-                        // Ensure handler cleanup
-                        handler.cleanup();
-                    }
+                }
+                else {
+                    // Standard mode - return credential when complete
+                    // Wait for credential and return in standard format
+                    const credential = yield credentialPromise;
+                    const aggregatorId = this.config.aggregatorId || 'default';
+                    return { [aggregatorId]: credential.credential };
                 }
             }
             else {

package/dist/core/phone-auth/index.d.ts

@@ -4,4 +4,4 @@ export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isEr
 export type { PhoneAuthErrorCode as PhoneAuthErrorCodeType } from './error-utils';
 export { validatePhoneNumber, validatePlmn, validateUseCaseRequirements, validateConsentData, validateNonce } from './validation-utils';
 export { MobileDebugConsole } from './ui/mobile-debug-console';
-export { isHeadlessResult, isCredential, isLinkStrategy, isTS43Strategy, isDesktopStrategy, getStrategy, requiresPolling, requiresUserAction } from './type-guards';
+export { isExtendedResponse, isCredential, isAuthCredential, isLinkStrategy, isTS43Strategy, isDesktopStrategy, getStrategy, hasPollingControls, hasTrigger, isHeadlessResult, requiresPolling, requiresUserAction } from './type-guards';