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

package/dist/BiometricIdentitySDK.d.ts

@@ -82,13 +82,21 @@ export declare 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
+     * This reduces large images by skipping compression if already small enough
      */
     private compressImage;
     /**
      * Compress image in browser environment using Canvas API
      */
     private compressImageBrowser;
+    /**
+     * Fix base64 padding issues
+     */
+    private fixBase64Padding;
+    /**
+     * Validate if string is valid base64
+     */
+    private isValidBase64;
     /**
      * Get current SDK state
      */

package/dist/BiometricIdentitySDK.js

@@ -299,7 +299,7 @@ class BiometricIdentitySDK {
                     minimumRequired: 10
                 });
             }
-            const MAX_FRAMES = 20;
+            const MAX_FRAMES = 15;
             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,13 +308,34 @@ class BiometricIdentitySDK {
                     sampledCount: videoFrames.length
                 });
             }
-            const compressedFrontImage = await this.compressImage(this.state.frontID.data);
+            const compressedFrontImage = this.fixBase64Padding(await this.compressImage(this.state.frontID.data));
             const compressedBackImage = this.state.backID?.data
-                ? await this.compressImage(this.state.backID.data)
+                ? this.fixBase64Padding(await this.compressImage(this.state.backID.data))
                 : undefined;
-            const compressedFrames = await Promise.all(videoFrames.map(frame => this.compressImage(frame)));
+            const validFrames = [];
+            for (let i = 0; i < videoFrames.length; i++) {
+                const frame = videoFrames[i];
+                if (!frame || typeof frame !== 'string') {
+                    logger_1.logger.warn(`Skipping invalid frame ${i}: not a string`);
+                    continue;
+                }
+                if (frame.length < 100) {
+                    logger_1.logger.warn(`Skipping invalid frame ${i}: too short (${frame.length} chars), likely a file path`);
+                    continue;
+                }
+                if (!this.isValidBase64(frame)) {
+                    logger_1.logger.warn(`Skipping invalid frame ${i}: not valid base64`);
+                    continue;
+                }
+                const compressedFrame = this.fixBase64Padding(await this.compressImage(frame));
+                validFrames.push(compressedFrame);
+            }
+            if (validFrames.length < 10) {
+                logger_1.logger.error(`Insufficient valid frames: ${validFrames.length} < 10`);
+                throw new Error(`Insufficient valid video frames: ${validFrames.length} frames available, minimum 10 required`);
+            }
             logger_1.logger.info('Sending validation request to backend', {
-                framesCount: compressedFrames.length,
+                framesCount: validFrames.length,
                 duration: this.state.videoData.duration,
                 challengesCount: this.state.videoData.challengesCompleted?.length || 0,
                 frontImageSize: compressedFrontImage.length,
@@ -326,7 +347,7 @@ class BiometricIdentitySDK {
             const response = await this.backendClient.fullValidation({
                 frontIdImage: compressedFrontImage,
                 backIdImage: compressedBackImage,
-                videoFrames: compressedFrames,
+                videoFrames: validFrames,
                 videoDurationMs: this.state.videoData.duration,
                 challengesCompleted: this.state.videoData.challengesCompleted || [],
             });
@@ -398,13 +419,13 @@ 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
+     * This reduces large images by skipping compression if already small enough
      */
     async compressImage(base64Image) {
         if (!base64Image || base64Image.length === 0) {
             return base64Image;
         }
-        const MAX_SIZE = 1024 * 1024;
+        const MAX_SIZE = 500 * 1024;
         if (base64Image.length < MAX_SIZE) {
             return base64Image;
         }
@@ -417,6 +438,7 @@ class BiometricIdentitySDK {
         catch (error) {
             logger_1.logger.warn('Image compression not available, using original', error);
         }
+        logger_1.logger.warn(`Image too large (${Math.round(base64Image.length / 1024)}KB) but compression not available`);
         return base64Image;
     }
     /**
@@ -452,6 +474,35 @@ class BiometricIdentitySDK {
             img.src = `data:image/jpeg;base64,${base64Image}`;
         });
     }
+    /**
+     * Fix base64 padding issues
+     */
+    fixBase64Padding(base64) {
+        if (!base64)
+            return base64;
+        let cleaned = base64.replace(/\s/g, '');
+        if (cleaned.includes(',')) {
+            cleaned = cleaned.split(',')[1] || cleaned;
+        }
+        const padding = cleaned.length % 4;
+        if (padding > 0) {
+            cleaned += '='.repeat(4 - padding);
+        }
+        return cleaned;
+    }
+    /**
+     * Validate if string is valid base64
+     */
+    isValidBase64(str) {
+        if (!str || typeof str !== 'string')
+            return false;
+        const cleaned = str.replace(/\s/g, '');
+        if (cleaned.includes(',')) {
+            return true;
+        }
+        const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+        return base64Regex.test(cleaned) && cleaned.length > 100;
+    }
     /**
      * Get current SDK state
      */

package/dist/api/BackendClient.js

@@ -16,7 +16,7 @@ class BackendClient {
         this.config = {
             apiEndpoint: config.apiEndpoint.replace(/\/$/, ''),
             apiKey: config.apiKey,
-            timeout: config.timeout || 60000,
+            timeout: config.timeout || 120000,
         };
         this.sdkSessionId = this.generateSDKSessionId();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hexar/biometric-identity-sdk-core",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "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 = 20;
+      const MAX_FRAMES = 15;
       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,16 +391,40 @@ export class BiometricIdentitySDK {
         });
       }
       
-      const compressedFrontImage = await this.compressImage(this.state.frontID.data);
+      const compressedFrontImage = this.fixBase64Padding(await this.compressImage(this.state.frontID.data));
       const compressedBackImage = this.state.backID?.data 
-        ? await this.compressImage(this.state.backID.data)
+        ? this.fixBase64Padding(await this.compressImage(this.state.backID.data))
         : undefined;
-      const compressedFrames = await Promise.all(
-        videoFrames.map(frame => this.compressImage(frame))
-      );
+      
+      const validFrames: string[] = [];
+      for (let i = 0; i < videoFrames.length; i++) {
+        const frame = videoFrames[i];
+        if (!frame || typeof frame !== 'string') {
+          logger.warn(`Skipping invalid frame ${i}: not a string`);
+          continue;
+        }
+        
+        if (frame.length < 100) {
+          logger.warn(`Skipping invalid frame ${i}: too short (${frame.length} chars), likely a file path`);
+          continue;
+        }
+        
+        if (!this.isValidBase64(frame)) {
+          logger.warn(`Skipping invalid frame ${i}: not valid base64`);
+          continue;
+        }
+        
+        const compressedFrame = this.fixBase64Padding(await this.compressImage(frame));
+        validFrames.push(compressedFrame);
+      }
+
+      if (validFrames.length < 10) {
+        logger.error(`Insufficient valid frames: ${validFrames.length} < 10`);
+        throw new Error(`Insufficient valid video frames: ${validFrames.length} frames available, minimum 10 required`);
+      }
 
       logger.info('Sending validation request to backend', {
-        framesCount: compressedFrames.length,
+        framesCount: validFrames.length,
         duration: this.state.videoData.duration,
         challengesCount: this.state.videoData.challengesCompleted?.length || 0,
         frontImageSize: compressedFrontImage.length,
@@ -413,7 +437,7 @@ export class BiometricIdentitySDK {
       const response = await this.backendClient.fullValidation({
         frontIdImage: compressedFrontImage,
         backIdImage: compressedBackImage,
-        videoFrames: compressedFrames,
+        videoFrames: validFrames,
         videoDurationMs: this.state.videoData.duration,
         challengesCompleted: this.state.videoData.challengesCompleted || [],
       });
@@ -500,14 +524,14 @@ 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
+   * This reduces large images by skipping compression if already small enough
    */
   private async compressImage(base64Image: string): Promise<string> {
     if (!base64Image || base64Image.length === 0) {
       return base64Image;
     }
 
-    const MAX_SIZE = 1024 * 1024;
+    const MAX_SIZE = 500 * 1024;
     if (base64Image.length < MAX_SIZE) {
       return base64Image;
     }
@@ -521,6 +545,7 @@ export class BiometricIdentitySDK {
       logger.warn('Image compression not available, using original', error);
     }
 
+    logger.warn(`Image too large (${Math.round(base64Image.length / 1024)}KB) but compression not available`);
     return base64Image;
   }
 
@@ -563,6 +588,41 @@ export class BiometricIdentitySDK {
     });
   }
 
+  /**
+   * Fix base64 padding issues
+   */
+  private fixBase64Padding(base64: string): string {
+    if (!base64) return base64;
+    
+    let cleaned = base64.replace(/\s/g, '');
+    
+    if (cleaned.includes(',')) {
+      cleaned = cleaned.split(',')[1] || cleaned;
+    }
+    
+    const padding = cleaned.length % 4;
+    if (padding > 0) {
+      cleaned += '='.repeat(4 - padding);
+    }
+    
+    return cleaned;
+  }
+
+  /**
+   * Validate if string is valid base64
+   */
+  private isValidBase64(str: string): boolean {
+    if (!str || typeof str !== 'string') return false;
+    
+    const cleaned = str.replace(/\s/g, '');
+    if (cleaned.includes(',')) {
+      return true;
+    }
+    
+    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+    return base64Regex.test(cleaned) && cleaned.length > 100;
+  }
+
   /**
    * Get current SDK state
    */

package/src/api/BackendClient.ts

@@ -141,7 +141,7 @@ export class BackendClient {
     this.config = {
       apiEndpoint: config.apiEndpoint.replace(/\/$/, ''),
       apiKey: config.apiKey,
-      timeout: config.timeout || 60000,
+      timeout: config.timeout || 120000,
     };
     this.sdkSessionId = this.generateSDKSessionId();
   }