@glideidentity/web-client-sdk 5.0.1 → 5.1.1-beta.1

package/dist/core/phone-auth/validation-utils.d.ts

@@ -42,12 +42,3 @@ export declare function createValidationError(code: PhoneAuthErrorCode, message:
     code: PhoneAuthErrorCode;
     field?: string;
 };
-/**
- * Validates nonce format
- * @param nonce - Nonce string to validate
- * @returns Validation result
- */
-export declare function validateNonce(nonce: string): {
-    valid: boolean;
-    error?: string;
-};

package/dist/core/phone-auth/validation-utils.js

@@ -1,15 +1,23 @@
 "use strict";
+/**
+ * Validation utilities for phone authentication
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validatePhoneNumber = validatePhoneNumber;
 exports.validatePlmn = validatePlmn;
 exports.validateUseCaseRequirements = validateUseCaseRequirements;
 exports.createValidationError = createValidationError;
-exports.validateNonce = validateNonce;
 const api_types_1 = require("./api-types");
+/**
+ * Validates E.164 phone number format
+ * @param phoneNumber - Phone number to validate
+ * @returns Validation result with error if invalid
+ */
 function validatePhoneNumber(phoneNumber) {
     if (!phoneNumber) {
-        return { valid: true };
+        return { valid: true }; // Phone number is optional for GetPhoneNumber
     }
+    // E.164 format validation - strict, no cleaning
     const e164Regex = /^\+[1-9]\d{1,14}$/;
     if (!phoneNumber.startsWith('+')) {
         return {
@@ -29,6 +37,7 @@ function validatePhoneNumber(phoneNumber) {
             error: 'Phone number too long for E.164 format (maximum 15 digits after +)'
         };
     }
+    // Check for any invalid characters (spaces, dashes, parentheses, etc.)
     if (!/^\+\d+$/.test(phoneNumber)) {
         return {
             valid: false,
@@ -43,26 +52,42 @@ function validatePhoneNumber(phoneNumber) {
     }
     return { valid: true };
 }
+/**
+ * Validates PLMN (MCC/MNC) values
+ * @param plmn - PLMN object with MCC and MNC
+ * @returns Validation result
+ */
 function validatePlmn(plmn) {
     if (!plmn) {
-        return { valid: true };
+        return { valid: true }; // PLMN is optional
     }
     const { mcc, mnc } = plmn;
+    // MCC validation (3 digits) - no range check for telco labs
     if (!mcc || !/^\d{3}$/.test(mcc)) {
         return {
             valid: false,
             error: 'MCC must be exactly 3 digits'
         };
     }
+    // MNC validation (2 or 3 digits)
     if (!mnc || !/^\d{2,3}$/.test(mnc)) {
         return {
             valid: false,
             error: 'MNC must be 2 or 3 digits'
         };
     }
+    // No range validation - allowing unofficial MCCs for telco labs
     return { valid: true };
 }
+/**
+ * Validates use case and phone number combination
+ * @param useCase - The use case
+ * @param phoneNumber - The phone number (required for VerifyPhoneNumber)
+ * @param hasParentSessionId - Whether parent_session_id is provided (allows skipping normal validation)
+ * @returns Validation result
+ */
 function validateUseCaseRequirements(useCase, phoneNumber, hasParentSessionId) {
+    // VerifyPhoneNumber requires a phone number (unless parent_session_id is provided)
     if (useCase === api_types_1.USE_CASE.VERIFY_PHONE_NUMBER && !phoneNumber && !hasParentSessionId) {
         return {
             valid: false,
@@ -71,6 +96,12 @@ function validateUseCaseRequirements(useCase, phoneNumber, hasParentSessionId) {
     }
     return { valid: true };
 }
+/**
+ * Creates a validation error
+ * @param code - Error code
+ * @param message - Error message
+ * @param field - Field that failed validation
+ */
 function createValidationError(code, message, field) {
     const error = new Error(message);
     error.code = code;
@@ -79,25 +110,3 @@ function createValidationError(code, message, field) {
     }
     return error;
 }
-function validateNonce(nonce) {
-    const base64urlRegex = /^[A-Za-z0-9_-]+$/;
-    if (!nonce || nonce.length === 0) {
-        return {
-            valid: false,
-            error: 'Nonce is required'
-        };
-    }
-    if (!base64urlRegex.test(nonce)) {
-        return {
-            valid: false,
-            error: 'Nonce must be base64url encoded'
-        };
-    }
-    if (nonce.length < 32 || nonce.length > 128) {
-        return {
-            valid: false,
-            error: 'Nonce must be between 32 and 128 characters'
-        };
-    }
-    return { valid: true };
-}

package/dist/core/version.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = '5.0.1';
+// SDK version - injected at build time
+exports.SDK_VERSION = '5.1.1-beta.1';

package/dist/esm/adapters/angular/index.js

@@ -1,3 +1,4 @@
 export { ClientService } from './client.service';
 export { PhoneAuthService } from './phone-auth.service';
+// Export error utilities
 export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from '../../core/phone-auth';

package/dist/esm/adapters/angular/phone-auth.service.d.ts

@@ -11,10 +11,28 @@ export declare class PhoneAuthService {
     result$: Observable<PhoneAuthResult | null>;
     currentStep$: Observable<AuthStep>;
     constructor();
+    /**
+     * Configure the phone auth client
+     */
     configure(config: AuthConfig): void;
+    /**
+     * Check if browser supports secure phone authentication
+     */
     isSupported(): boolean;
+    /**
+     * Verify phone number
+     */
     verify(options: PhoneAuthOptions): Promise<PhoneAuthResult>;
+    /**
+     * Get phone number
+     */
     getPhoneNumber(options?: Omit<PhoneAuthOptions, 'use_case' | 'phone_number'>): Promise<PhoneAuthResult>;
+    /**
+     * Verify specific phone number
+     */
     verifyPhoneNumber(phoneNumber: string, options?: Omit<PhoneAuthOptions, 'use_case' | 'phone_number'>): Promise<PhoneAuthResult>;
+    /**
+     * Reset state
+     */
     reset(): void;
 }

package/dist/esm/adapters/angular/phone-auth.service.js

@@ -21,22 +21,33 @@ import { PhoneAuthClient } from '../../core/phone-auth';
 import { BehaviorSubject } from 'rxjs';
 let PhoneAuthService = class PhoneAuthService {
     constructor() {
+        // State subjects
         this.isLoadingSubject = new BehaviorSubject(false);
         this.errorSubject = new BehaviorSubject(null);
         this.resultSubject = new BehaviorSubject(null);
         this.currentStepSubject = new BehaviorSubject('idle');
+        // Public observables
         this.isLoading$ = this.isLoadingSubject.asObservable();
         this.error$ = this.errorSubject.asObservable();
         this.result$ = this.resultSubject.asObservable();
         this.currentStep$ = this.currentStepSubject.asObservable();
         this.client = new PhoneAuthClient();
     }
+    /**
+     * Configure the phone auth client
+     */
     configure(config) {
         this.client = new PhoneAuthClient(config);
     }
+    /**
+     * Check if browser supports secure phone authentication
+     */
     isSupported() {
         return this.client.isSupported();
     }
+    /**
+     * Verify phone number
+     */
     verify(options) {
         return __awaiter(this, void 0, void 0, function* () {
             this.isLoadingSubject.next(true);
@@ -44,14 +55,19 @@ let PhoneAuthService = class PhoneAuthService {
             this.resultSubject.next(null);
             this.currentStepSubject.next('requesting');
             try {
+                // Step 1: Prepare request
                 const preparedRequest = yield this.client.preparePhoneRequest(options);
+                // Step 2: Show authenticating state
                 this.currentStepSubject.next('authenticating');
                 const credentialResponse = yield this.client.invokeSecurePrompt(preparedRequest);
+                // Step 3: Process response through appropriate endpoint
                 this.currentStepSubject.next('processing');
+                // Cast to credential type - adapters never use headless mode
                 const credential = credentialResponse;
                 const processedResult = options.use_case === 'GetPhoneNumber'
                     ? yield this.client.getPhoneNumber(credential, preparedRequest.session)
                     : yield this.client.verifyPhoneNumber(credential, preparedRequest.session);
+                // Create final result
                 const isVerifyResponse = 'verified' in processedResult;
                 const result = processedResult;
                 this.resultSubject.next(result);
@@ -59,6 +75,7 @@ let PhoneAuthService = class PhoneAuthService {
                 return result;
             }
             catch (error) {
+                // Enhance error with context
                 const authError = error;
                 const enhancedError = Object.assign(Object.assign({}, authError), { context: authError.context || {
                         useCase: options.use_case,
@@ -75,16 +92,25 @@ let PhoneAuthService = class PhoneAuthService {
             }
         });
     }
+    /**
+     * Get phone number
+     */
     getPhoneNumber(options) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.verify(Object.assign({ use_case: 'GetPhoneNumber' }, options));
         });
     }
+    /**
+     * Verify specific phone number
+     */
     verifyPhoneNumber(phoneNumber, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.verify(Object.assign({ use_case: 'VerifyPhoneNumber', phone_number: phoneNumber }, options));
         });
     }
+    /**
+     * Reset state
+     */
     reset() {
         this.isLoadingSubject.next(false);
         this.errorSubject.next(null);

package/dist/esm/adapters/react/index.js

@@ -1,5 +1,8 @@
 export { usePhoneAuth } from './usePhoneAuth';
 export { useClient } from './useClient';
+// Export error utilities
 export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from '../../core/phone-auth';
+// Export constants for use case and strategy
 export { USE_CASE as UseCase, AUTHENTICATION_STRATEGY as AuthenticationStrategy, BrowserError, BrowserErrorCode, BrowserName } from '../../core/phone-auth/types';
+// Export the PhoneAuthClient class for direct use
 export { PhoneAuthClient } from '../../core/phone-auth';

package/dist/esm/adapters/react/useClient.js

@@ -27,6 +27,7 @@ export function useClient(config) {
         };
     }, []);
     const authenticate = (authUrl, options) => __awaiter(this, void 0, void 0, function* () {
+        // Legacy authentication removed - use setToken directly
         const error = new Error('authenticate method is deprecated. Use client.setToken() directly.');
         setError(error);
         setLoading(false);

package/dist/esm/adapters/react/usePhoneAuth.js

@@ -15,8 +15,13 @@ export function usePhoneAuth(config = {}) {
     const [result, setResult] = useState(null);
     const [currentStep, setCurrentStep] = useState('idle');
     const lastRequestRef = useRef(null);
-    const client = useMemo(() => new PhoneAuthClient(Object.assign(Object.assign({}, config), { onCrossDeviceDetected: config.onCrossDeviceDetected, onRetryAttempt: config.onRetryAttempt })), [JSON.stringify(config)]);
+    // Create client instance with callbacks
+    const client = useMemo(() => new PhoneAuthClient(Object.assign(Object.assign({}, config), { 
+        // Pass through callbacks if provided
+        onCrossDeviceDetected: config.onCrossDeviceDetected, onRetryAttempt: config.onRetryAttempt })), [JSON.stringify(config)]);
+    // Check browser support
     const isSupported = useMemo(() => client.isSupported(), [client]);
+    // Verify method with silent retry support
     const verify = useCallback((options) => __awaiter(this, void 0, void 0, function* () {
         setIsLoading(true);
         setError(null);
@@ -24,12 +29,14 @@ export function usePhoneAuth(config = {}) {
         setCurrentStep('requesting');
         lastRequestRef.current = options;
         try {
+            // Use the client's verify method which includes retry logic
             const verificationResult = yield client.verify(options);
             setResult(verificationResult);
             setCurrentStep('complete');
             return verificationResult;
         }
         catch (err) {
+            // Error is only set after all retries are exhausted
             const authError = err;
             setError(authError);
             setCurrentStep('idle');
@@ -39,39 +46,47 @@ export function usePhoneAuth(config = {}) {
             setIsLoading(false);
         }
     }), [client]);
+    // Manual retry method
     const retryLastRequest = useCallback(() => __awaiter(this, void 0, void 0, function* () {
         if (!lastRequestRef.current) {
             throw new Error('No previous request to retry');
         }
         return verify(lastRequestRef.current);
     }), [verify]);
+    // Convenience methods
     const getPhoneNumber = useCallback((options) => verify(Object.assign({ use_case: 'GetPhoneNumber' }, options)), [verify]);
     const verifyPhoneNumber = useCallback((phoneNumber, options) => verify(Object.assign({ use_case: 'VerifyPhoneNumber', phone_number: phoneNumber }, options)), [verify]);
+    // Reset state
     const reset = useCallback(() => {
         setIsLoading(false);
         setError(null);
         setResult(null);
         setCurrentStep('idle');
     }, []);
+    // Expose granular methods directly from client for better discoverability
     const preparePhoneRequest = useCallback((options) => client.preparePhoneRequest(options), [client]);
     const invokeSecurePrompt = useCallback((prepareResponse) => client.invokeSecurePrompt(prepareResponse), [client]);
     const getPhoneNumberCredential = useCallback((credentialResponse, session) => client.getPhoneNumber(credentialResponse, session), [client]);
     const verifyPhoneNumberCredential = useCallback((credentialResponse, session) => client.verifyPhoneNumber(credentialResponse, session), [client]);
     return {
+        // State
         isLoading,
         error,
         result,
         currentStep,
         isSupported,
+        // High-level methods
         verify,
         getPhoneNumber,
         verifyPhoneNumber,
         retryLastRequest,
         reset,
+        // Granular methods (directly exposed for better discoverability)
         preparePhoneRequest,
         invokeSecurePrompt,
         getPhoneNumberCredential,
         verifyPhoneNumberCredential,
+        // Client instance (still available for advanced usage)
         client
     };
 }

package/dist/esm/adapters/vanilla/client.js

@@ -14,6 +14,7 @@ export class VanillaClient {
     }
     authenticate(authUrl, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Legacy authentication removed - use setToken directly
             throw new Error('authenticate method is deprecated. Use client.setToken() directly.');
         });
     }

package/dist/esm/adapters/vanilla/index.js

@@ -1,3 +1,4 @@
 export { VanillaClient as ClientManager } from './client';
 export { PhoneAuthManager } from './phone-auth';
+// Export error utilities
 export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from '../../core/phone-auth';

package/dist/esm/adapters/vanilla/phone-auth.d.ts

@@ -11,12 +11,36 @@ export declare class PhoneAuthManager {
     private state;
     private listeners;
     constructor(config?: AuthConfig);
+    /**
+     * Get current state
+     */
     getState(): PhoneAuthState;
+    /**
+     * Subscribe to state changes
+     */
     subscribe(listener: (state: PhoneAuthState) => void): () => void;
+    /**
+     * Update state and notify listeners
+     */
     private updateState;
+    /**
+     * Verify phone number
+     */
     verify(options: PhoneAuthOptions): Promise<PhoneAuthResult>;
+    /**
+     * Get phone number
+     */
     getPhoneNumber(options?: Omit<PhoneAuthOptions, 'use_case' | 'phone_number'>): Promise<PhoneAuthResult>;
+    /**
+     * Verify specific phone number
+     */
     verifyPhoneNumber(phoneNumber: string, options?: Omit<PhoneAuthOptions, 'use_case' | 'phone_number'>): Promise<PhoneAuthResult>;
+    /**
+     * Reset state
+     */
     reset(): void;
+    /**
+     * Check if browser supports secure phone authentication
+     */
     isSupported(): boolean;
 }

package/dist/esm/adapters/vanilla/phone-auth.js

@@ -20,11 +20,18 @@ export class PhoneAuthManager {
             isSupported: this.client.isSupported()
         };
     }
+    /**
+     * Get current state
+     */
     getState() {
         return Object.assign({}, this.state);
     }
+    /**
+     * Subscribe to state changes
+     */
     subscribe(listener) {
         this.listeners.push(listener);
+        // Return unsubscribe function
         return () => {
             const index = this.listeners.indexOf(listener);
             if (index !== -1) {
@@ -32,10 +39,16 @@ export class PhoneAuthManager {
             }
         };
     }
+    /**
+     * Update state and notify listeners
+     */
     updateState(updates) {
         this.state = Object.assign(Object.assign({}, this.state), updates);
         this.listeners.forEach(listener => listener(this.getState()));
     }
+    /**
+     * Verify phone number
+     */
     verify(options) {
         return __awaiter(this, void 0, void 0, function* () {
             this.updateState({
@@ -45,14 +58,19 @@ export class PhoneAuthManager {
                 currentStep: 'requesting'
             });
             try {
+                // Step 1: Prepare request
                 const preparedRequest = yield this.client.preparePhoneRequest(options);
+                // Step 2: Show authenticating state
                 this.updateState({ currentStep: 'authenticating' });
                 const credentialResponse = yield this.client.invokeSecurePrompt(preparedRequest);
+                // Step 3: Process response through appropriate endpoint
                 this.updateState({ currentStep: 'processing' });
+                // Cast to credential type - adapters never use headless mode
                 const credential = credentialResponse;
                 const processedResult = options.use_case === 'GetPhoneNumber'
                     ? yield this.client.getPhoneNumber(credential, preparedRequest.session)
                     : yield this.client.verifyPhoneNumber(credential, preparedRequest.session);
+                // Create final result
                 const isVerifyResponse = 'verified' in processedResult;
                 const result = processedResult;
                 this.updateState({
@@ -63,6 +81,7 @@ export class PhoneAuthManager {
                 return result;
             }
             catch (error) {
+                // Enhance error with context
                 const authError = error;
                 const enhancedError = Object.assign(Object.assign({}, authError), { context: authError.context || {
                         useCase: options.use_case,
@@ -79,16 +98,25 @@ export class PhoneAuthManager {
             }
         });
     }
+    /**
+     * Get phone number
+     */
     getPhoneNumber(options) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.verify(Object.assign({ use_case: 'GetPhoneNumber' }, options));
         });
     }
+    /**
+     * Verify specific phone number
+     */
     verifyPhoneNumber(phoneNumber, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.verify(Object.assign({ use_case: 'VerifyPhoneNumber', phone_number: phoneNumber }, options));
         });
     }
+    /**
+     * Reset state
+     */
     reset() {
         this.updateState({
             isLoading: false,
@@ -97,6 +125,9 @@ export class PhoneAuthManager {
             currentStep: 'idle'
         });
     }
+    /**
+     * Check if browser supports secure phone authentication
+     */
     isSupported() {
         return this.state.isSupported;
     }

package/dist/esm/adapters/vue/index.js

@@ -2,6 +2,10 @@ export { usePhoneAuth } from './usePhoneAuth';
 export { useClient } from './useClient';
 export { SDKClient } from '../../core/client';
 export { PhoneAuthClient } from '../../core/phone-auth';
+// API response types are already exported via core/phone-auth/types
+// Export error utilities
 export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from '../../core/phone-auth';
+// Export constants for use case and strategy
 export { USE_CASE as UseCase, AUTHENTICATION_STRATEGY as AuthenticationStrategy, BrowserError, BrowserErrorCode, BrowserName } from '../../core/phone-auth/types';
+// Export API constants from api-types
 export { USE_CASE, ERROR_CODE, ERROR_MESSAGES, ERROR_STATUS_CODES } from '../../core/phone-auth/api-types';

package/dist/esm/adapters/vue/useClient.js

@@ -40,14 +40,17 @@ export function useClient(config) {
             const authenticate = (authUrl) => __awaiter(this, void 0, void 0, function* () {
                 loading.value = true;
                 error.value = null;
+                // Clean up previous authentication if exists
                 if (cleanup) {
                     cleanup();
                     cleanup = null;
                 }
+                // Legacy authentication removed - use setToken directly
                 error.value = new Error('authenticate method is deprecated. Use client.setToken() directly.');
                 loading.value = false;
                 throw error.value;
             });
+            // Cleanup on component unmount
             onUnmounted(() => {
                 if (cleanup) {
                     cleanup();
@@ -100,6 +103,7 @@ export function useClient(config) {
                     loading.value = false;
                 }
             });
+            // Low-level methods for advanced control
             const preparePhoneRequest = (options) => __awaiter(this, void 0, void 0, function* () {
                 return client.value.phoneAuth.preparePhoneRequest(options);
             });
@@ -113,6 +117,7 @@ export function useClient(config) {
                 isSupported,
                 getPhoneNumber,
                 verifyPhoneNumber,
+                // Low-level API for advanced usage
                 preparePhoneRequest,
                 invokeSecurePrompt
             };

package/dist/esm/adapters/vue/usePhoneAuth.js

@@ -10,31 +10,43 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { ref, computed, readonly } from 'vue';
 import { PhoneAuthClient } from '../../core/phone-auth';
 export function usePhoneAuth(config = {}) {
+    // State management
     const isLoading = ref(false);
     const error = ref(null);
     const result = ref(null);
     const currentStep = ref('idle');
-    const client = new PhoneAuthClient(Object.assign(Object.assign({}, config), { onCrossDeviceDetected: config.onCrossDeviceDetected, onRetryAttempt: config.onRetryAttempt }));
+    // Create client instance with callbacks
+    const client = new PhoneAuthClient(Object.assign(Object.assign({}, config), { 
+        // Callbacks are now properly typed through AuthConfig
+        onCrossDeviceDetected: config.onCrossDeviceDetected, onRetryAttempt: config.onRetryAttempt }));
+    // Check browser support
     const isSupported = computed(() => client.isSupported());
+    // Verify method - internal wrapper that converts to API format
     const verify = (options) => __awaiter(this, void 0, void 0, function* () {
         isLoading.value = true;
         error.value = null;
         result.value = null;
         currentStep.value = 'requesting';
         try {
+            // Step 1: Prepare the request
             const preparedRequest = yield client.preparePhoneRequest(options);
+            // Step 2: User authentication
             currentStep.value = 'authenticating';
             const credentialResponse = yield client.invokeSecurePrompt(preparedRequest);
+            // Step 3: Process the response through appropriate endpoint
             currentStep.value = 'processing';
+            // Cast to credential type - adapters never use headless mode
             const credential = credentialResponse;
             const verificationResult = options.use_case === 'GetPhoneNumber'
                 ? yield client.getPhoneNumber(credential, preparedRequest.session)
                 : yield client.verifyPhoneNumber(credential, preparedRequest.session);
+            // Use the result directly - it's already the correct type
             result.value = verificationResult;
             currentStep.value = 'complete';
             return result.value;
         }
         catch (err) {
+            // Enhance error with context if it's an AuthError
             const authError = err;
             const enhancedError = Object.assign(Object.assign({}, authError), { context: authError.context || {
                     useCase: options.use_case,
@@ -50,32 +62,39 @@ export function usePhoneAuth(config = {}) {
             isLoading.value = false;
         }
     });
+    // Convenience methods
     const getPhoneNumber = (options) => verify(Object.assign({ use_case: 'GetPhoneNumber' }, options));
     const verifyPhoneNumber = (phoneNumber, options) => verify(Object.assign({ use_case: 'VerifyPhoneNumber', phone_number: phoneNumber }, options));
+    // Reset state
     const reset = () => {
         isLoading.value = false;
         error.value = null;
         result.value = null;
         currentStep.value = 'idle';
     };
+    // Expose granular methods directly from client for better discoverability
     const preparePhoneRequest = client.preparePhoneRequest.bind(client);
     const invokeSecurePrompt = client.invokeSecurePrompt.bind(client);
     const getPhoneNumberCredential = client.getPhoneNumber.bind(client);
     const verifyPhoneNumberCredential = client.verifyPhoneNumber.bind(client);
     return {
+        // State (readonly)
         isLoading: readonly(isLoading),
         error: readonly(error),
         result: readonly(result),
         currentStep: readonly(currentStep),
         isSupported: readonly(isSupported),
+        // High-level methods
         verify,
         getPhoneNumber,
         verifyPhoneNumber,
         reset,
+        // Granular methods (directly exposed for better discoverability)
         preparePhoneRequest,
         invokeSecurePrompt,
         getPhoneNumberCredential,
         verifyPhoneNumberCredential,
+        // Client instance (still available for advanced usage)
         client
     };
 }

package/dist/esm/browser.js

@@ -1,5 +1,11 @@
+// Browser-specific entry point for vanilla JavaScript usage
+// This excludes framework-specific adapters that require Angular/React/Vue
+// Phone Authentication - Core client
 export { PhoneAuthClient } from './core/phone-auth';
+// Phone Auth Error Utilities
 export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from './core/phone-auth';
+// Export constants for use case and strategy
 export { USE_CASE as UseCase, AUTHENTICATION_STRATEGY as AuthenticationStrategy, BrowserError, BrowserErrorCode, BrowserName } from './core/phone-auth/types';
+// Vanilla adapters ONLY (no framework dependencies)
 export { VanillaClient as ClientManager } from './adapters/vanilla/client';
 export { PhoneAuthManager } from './adapters/vanilla/phone-auth';

package/dist/esm/core/client.d.ts

@@ -6,7 +6,17 @@ export declare class SDKClient {
     private token?;
     phoneAuth: PhoneAuthClient;
     constructor(config: ClientConfig);
+    /**
+     * Set authentication token for API requests
+     */
     setToken(token: string): void;
+    /**
+     * Clear authentication token
+     */
     clearToken(): void;
+    /**
+     * Make a GET request to the API
+     * Note: Requires baseURL to be set in the config
+     */
     get<T = any>(path: string, options?: RequestOptions): Promise<ClientResponse<T>>;
 }