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

package/dist/BiometricIdentitySDK.d.ts

@@ -89,6 +89,14 @@ export declare class BiometricIdentitySDK {
      * 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

@@ -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 || [],
             });
@@ -452,6 +473,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/package.json

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

package/src/BiometricIdentitySDK.ts

@@ -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 || [],
       });
@@ -563,6 +587,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
    */