@hexar/biometric-identity-sdk-core 1.0.13 → 1.0.15

package/dist/BiometricIdentitySDK.d.ts

@@ -79,6 +79,16 @@ export declare class BiometricIdentitySDK {
      * Convert Blob to base64
      */
     private blobToBase64;
+    /**
+     * Compress base64 image - simplified version that works in all environments
+     * For React Native, images should be compressed at capture time
+     * This is a no-op for now - compression should happen at capture time in React Native
+     */
+    private compressImage;
+    /**
+     * Compress image in browser environment using Canvas API
+     */
+    private compressImageBrowser;
     /**
      * Get current SDK state
      */

package/dist/BiometricIdentitySDK.js

@@ -299,7 +299,7 @@ class BiometricIdentitySDK {
                     minimumRequired: 10
                 });
             }
-            const MAX_FRAMES = 30;
+            const MAX_FRAMES = 20;
             if (videoFrames.length > MAX_FRAMES) {
                 const step = Math.floor(videoFrames.length / MAX_FRAMES);
                 videoFrames = videoFrames.filter((_, index) => index % step === 0).slice(0, MAX_FRAMES);
@@ -308,17 +308,25 @@ class BiometricIdentitySDK {
                     sampledCount: videoFrames.length
                 });
             }
+            const compressedFrontImage = await this.compressImage(this.state.frontID.data);
+            const compressedBackImage = this.state.backID?.data
+                ? await this.compressImage(this.state.backID.data)
+                : undefined;
+            const compressedFrames = await Promise.all(videoFrames.map(frame => this.compressImage(frame)));
             logger_1.logger.info('Sending validation request to backend', {
-                framesCount: videoFrames.length,
+                framesCount: compressedFrames.length,
                 duration: this.state.videoData.duration,
                 challengesCount: this.state.videoData.challengesCompleted?.length || 0,
-                frontImageSize: this.state.frontID.data?.length || 0,
-                backImageSize: this.state.backID?.data?.length || 0
+                frontImageSize: compressedFrontImage.length,
+                backImageSize: compressedBackImage?.length || 0,
+                originalFrontSize: this.state.frontID.data?.length || 0,
+                originalBackSize: this.state.backID?.data?.length || 0,
+                compressionRatio: compressedFrontImage.length / (this.state.frontID.data?.length || 1)
             });
             const response = await this.backendClient.fullValidation({
-                frontIdImage: this.state.frontID.data,
-                backIdImage: this.state.backID?.data,
-                videoFrames: videoFrames,
+                frontIdImage: compressedFrontImage,
+                backIdImage: compressedBackImage,
+                videoFrames: compressedFrames,
                 videoDurationMs: this.state.videoData.duration,
                 challengesCompleted: this.state.videoData.challengesCompleted || [],
             });
@@ -329,9 +337,19 @@ class BiometricIdentitySDK {
             logger_1.logger.error('Backend validation failed', {
                 errorMessage: error?.message,
                 errorName: error?.name,
-                errorStack: error?.stack
+                status: error?.status,
+                statusText: error?.statusText,
+                errorData: error?.errorData,
+                errorStack: error?.stack?.substring(0, 500)
+            });
+            const errorMessage = error?.message ||
+                (error?.status ? `Backend request failed with status ${error.status}` : 'Backend validation failed');
+            throw this.createError(types_1.BiometricErrorCode.NETWORK_ERROR, errorMessage, {
+                status: error?.status,
+                statusText: error?.statusText,
+                errorData: error?.errorData,
+                originalError: error?.message
             });
-            throw this.createError(types_1.BiometricErrorCode.NETWORK_ERROR, error?.message || 'Backend validation failed', error);
         }
     }
     /**
@@ -377,6 +395,63 @@ class BiometricIdentitySDK {
             reader.readAsDataURL(blob);
         });
     }
+    /**
+     * Compress base64 image - simplified version that works in all environments
+     * For React Native, images should be compressed at capture time
+     * This is a no-op for now - compression should happen at capture time in React Native
+     */
+    async compressImage(base64Image) {
+        if (!base64Image || base64Image.length === 0) {
+            return base64Image;
+        }
+        const MAX_SIZE = 1024 * 1024;
+        if (base64Image.length < MAX_SIZE) {
+            return base64Image;
+        }
+        try {
+            const globalWindow = globalThis.window;
+            if (globalWindow && globalWindow.Image && globalWindow.document) {
+                return await this.compressImageBrowser(base64Image, globalWindow);
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn('Image compression not available, using original', error);
+        }
+        return base64Image;
+    }
+    /**
+     * Compress image in browser environment using Canvas API
+     */
+    async compressImageBrowser(base64Image, window) {
+        return new Promise((resolve, reject) => {
+            const img = new window.Image();
+            img.onload = () => {
+                const canvas = window.document.createElement('canvas');
+                const maxWidth = 1920;
+                const maxHeight = 1920;
+                let width = img.width;
+                let height = img.height;
+                if (width > maxWidth || height > maxHeight) {
+                    const ratio = Math.min(maxWidth / width, maxHeight / height);
+                    width = width * ratio;
+                    height = height * ratio;
+                }
+                canvas.width = width;
+                canvas.height = height;
+                const ctx = canvas.getContext('2d');
+                if (!ctx) {
+                    reject(new Error('Could not get canvas context'));
+                    return;
+                }
+                ctx.drawImage(img, 0, 0, width, height);
+                const compressedBase64 = canvas.toDataURL('image/jpeg', 0.85);
+                const base64 = compressedBase64.split(',')[1];
+                resolve(base64);
+            };
+            img.onerror = reject;
+            img.src = `data:image/jpeg;base64,${base64Image}`;
+        });
+    }
     /**
      * Get current SDK state
      */

package/dist/api/BackendClient.js

@@ -184,6 +184,12 @@ class BackendClient {
      */
     async request(endpoint, method, body) {
         const url = `${this.config.apiEndpoint}${endpoint}`;
+        logger_1.logger.info('Making backend request', {
+            url,
+            method,
+            hasBody: !!body,
+            bodySize: body ? JSON.stringify(body).length : 0
+        });
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
         const headers = {
@@ -200,33 +206,51 @@ class BackendClient {
                 body: body ? JSON.stringify(body) : undefined,
                 signal: controller.signal,
             });
+            logger_1.logger.info('Backend response received', {
+                url,
+                status: response.status,
+                statusText: response.statusText,
+                ok: response.ok
+            });
             clearTimeout(timeoutId);
             if (!response.ok) {
+                let errorText = '';
                 let errorData = {};
                 try {
-                    const text = await response.text();
-                    if (text) {
-                        errorData = JSON.parse(text);
+                    errorText = await response.text();
+                    if (errorText) {
+                        try {
+                            errorData = JSON.parse(errorText);
+                        }
+                        catch {
+                            errorData = { raw: errorText };
+                        }
                     }
                 }
-                catch {
-                    errorData = {};
+                catch (parseError) {
+                    logger_1.logger.warn('Could not parse error response', parseError);
                 }
                 const errorMessage = errorData?.error?.message ||
                     errorData?.detail ||
                     errorData?.message ||
-                    `Request failed with status ${response.status}`;
+                    errorData?.raw ||
+                    `Request failed with status ${response.status}: ${response.statusText}`;
                 logger_1.logger.error('Backend request failed', {
                     url,
                     method,
                     status: response.status,
                     statusText: response.statusText,
-                    errorData
+                    errorText: errorText.substring(0, 500),
+                    errorData: JSON.stringify(errorData).substring(0, 500)
                 });
+                const error = new Error(errorMessage);
+                error.status = response.status;
+                error.statusText = response.statusText;
+                error.errorData = errorData;
                 if (response.status === 413) {
                     throw new Error(`Payload too large (413). The request body exceeds the server's size limit. Try reducing the number of video frames or image sizes.`);
                 }
-                throw new Error(errorMessage);
+                throw error;
             }
             return await response.json();
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hexar/biometric-identity-sdk-core",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "Core AI engine for biometric identity verification",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/BiometricIdentitySDK.ts

@@ -381,7 +381,7 @@ export class BiometricIdentitySDK {
         });
       }
       
-      const MAX_FRAMES = 30;
+      const MAX_FRAMES = 20;
       if (videoFrames.length > MAX_FRAMES) {
         const step = Math.floor(videoFrames.length / MAX_FRAMES);
         videoFrames = videoFrames.filter((_, index) => index % step === 0).slice(0, MAX_FRAMES);
@@ -391,18 +391,29 @@ export class BiometricIdentitySDK {
         });
       }
       
+      const compressedFrontImage = await this.compressImage(this.state.frontID.data);
+      const compressedBackImage = this.state.backID?.data 
+        ? await this.compressImage(this.state.backID.data)
+        : undefined;
+      const compressedFrames = await Promise.all(
+        videoFrames.map(frame => this.compressImage(frame))
+      );
+
       logger.info('Sending validation request to backend', {
-        framesCount: videoFrames.length,
+        framesCount: compressedFrames.length,
         duration: this.state.videoData.duration,
         challengesCount: this.state.videoData.challengesCompleted?.length || 0,
-        frontImageSize: this.state.frontID.data?.length || 0,
-        backImageSize: this.state.backID?.data?.length || 0
+        frontImageSize: compressedFrontImage.length,
+        backImageSize: compressedBackImage?.length || 0,
+        originalFrontSize: this.state.frontID.data?.length || 0,
+        originalBackSize: this.state.backID?.data?.length || 0,
+        compressionRatio: compressedFrontImage.length / (this.state.frontID.data?.length || 1)
       });
 
       const response = await this.backendClient.fullValidation({
-        frontIdImage: this.state.frontID.data,
-        backIdImage: this.state.backID?.data,
-        videoFrames: videoFrames,
+        frontIdImage: compressedFrontImage,
+        backIdImage: compressedBackImage,
+        videoFrames: compressedFrames,
         videoDurationMs: this.state.videoData.duration,
         challengesCompleted: this.state.videoData.challengesCompleted || [],
       });
@@ -414,12 +425,24 @@ export class BiometricIdentitySDK {
       logger.error('Backend validation failed', {
         errorMessage: error?.message,
         errorName: error?.name,
-        errorStack: error?.stack
+        status: error?.status,
+        statusText: error?.statusText,
+        errorData: error?.errorData,
+        errorStack: error?.stack?.substring(0, 500)
       });
+      
+      const errorMessage = error?.message || 
+        (error?.status ? `Backend request failed with status ${error.status}` : 'Backend validation failed');
+      
       throw this.createError(
         BiometricErrorCode.NETWORK_ERROR,
-        error?.message || 'Backend validation failed',
-        error
+        errorMessage,
+        {
+          status: error?.status,
+          statusText: error?.statusText,
+          errorData: error?.errorData,
+          originalError: error?.message
+        }
       );
     }
   }
@@ -474,6 +497,72 @@ export class BiometricIdentitySDK {
     });
   }
 
+  /**
+   * Compress base64 image - simplified version that works in all environments
+   * For React Native, images should be compressed at capture time
+   * This is a no-op for now - compression should happen at capture time in React Native
+   */
+  private async compressImage(base64Image: string): Promise<string> {
+    if (!base64Image || base64Image.length === 0) {
+      return base64Image;
+    }
+
+    const MAX_SIZE = 1024 * 1024;
+    if (base64Image.length < MAX_SIZE) {
+      return base64Image;
+    }
+
+    try {
+      const globalWindow = (globalThis as any).window;
+      if (globalWindow && globalWindow.Image && globalWindow.document) {
+        return await this.compressImageBrowser(base64Image, globalWindow);
+      }
+    } catch (error) {
+      logger.warn('Image compression not available, using original', error);
+    }
+
+    return base64Image;
+  }
+
+  /**
+   * Compress image in browser environment using Canvas API
+   */
+  private async compressImageBrowser(base64Image: string, window: any): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const img = new window.Image();
+      img.onload = () => {
+        const canvas = window.document.createElement('canvas');
+        const maxWidth = 1920;
+        const maxHeight = 1920;
+        let width = img.width;
+        let height = img.height;
+
+        if (width > maxWidth || height > maxHeight) {
+          const ratio = Math.min(maxWidth / width, maxHeight / height);
+          width = width * ratio;
+          height = height * ratio;
+        }
+
+        canvas.width = width;
+        canvas.height = height;
+
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+          reject(new Error('Could not get canvas context'));
+          return;
+        }
+
+        ctx.drawImage(img, 0, 0, width, height);
+        
+        const compressedBase64 = canvas.toDataURL('image/jpeg', 0.85);
+        const base64 = compressedBase64.split(',')[1];
+        resolve(base64);
+      };
+      img.onerror = reject;
+      img.src = `data:image/jpeg;base64,${base64Image}`;
+    });
+  }
+
   /**
    * Get current SDK state
    */

package/src/api/BackendClient.ts

@@ -374,6 +374,13 @@ export class BackendClient {
   ): Promise<T> {
     const url = `${this.config.apiEndpoint}${endpoint}`;
     
+    logger.info('Making backend request', {
+      url,
+      method,
+      hasBody: !!body,
+      bodySize: body ? JSON.stringify(body).length : 0
+    });
+    
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
 
@@ -393,40 +400,60 @@ export class BackendClient {
         body: body ? JSON.stringify(body) : undefined,
         signal: controller.signal as RequestInit['signal'],
       });
+      
+      logger.info('Backend response received', {
+        url,
+        status: response.status,
+        statusText: response.statusText,
+        ok: response.ok
+      });
 
       clearTimeout(timeoutId);
 
       if (!response.ok) {
+        let errorText = '';
         let errorData: Record<string, any> = {};
+        
         try {
-          const text = await response.text();
-          if (text) {
-            errorData = JSON.parse(text);
+          errorText = await response.text();
+          if (errorText) {
+            try {
+              errorData = JSON.parse(errorText);
+            } catch {
+              errorData = { raw: errorText };
+            }
           }
-        } catch {
-          errorData = {};
+        } catch (parseError) {
+          logger.warn('Could not parse error response', parseError);
         }
 
         const errorMessage = errorData?.error?.message || 
           errorData?.detail ||
           errorData?.message ||
-          `Request failed with status ${response.status}`;
+          errorData?.raw ||
+          `Request failed with status ${response.status}: ${response.statusText}`;
 
         logger.error('Backend request failed', {
           url,
           method,
           status: response.status,
           statusText: response.statusText,
-          errorData
+          errorText: errorText.substring(0, 500),
+          errorData: JSON.stringify(errorData).substring(0, 500)
         });
 
+        const error = new Error(errorMessage);
+        (error as any).status = response.status;
+        (error as any).statusText = response.statusText;
+        (error as any).errorData = errorData;
+        
         if (response.status === 413) {
           throw new Error(
             `Payload too large (413). The request body exceeds the server's size limit. Try reducing the number of video frames or image sizes.`
           );
         }
         
-        throw new Error(errorMessage);
+        throw error;
       }
 
       return await response.json() as T;