@jupitermetalabs/face-zk-sdk 0.3.4 → 0.3.7

package/dist/react-native/components/ZkProofWebView.js

@@ -0,0 +1,297 @@
+"use strict";
+/**
+ * Copyright 2026 JupiterMeta Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZkProofWebView = exports.ZkProofBridge = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const react_native_webview_1 = require("react-native-webview");
+// ZkProofBridge class - Placeholder for Plonky integration
+class ZkProofBridge {
+    webViewRef;
+    messageCallbacks;
+    status = 'idle';
+    constructor(webViewRef) {
+        this.webViewRef = webViewRef;
+        console.log('█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█');
+        console.log('█  ZK PROOF WEBVIEW - UPDATED  █');
+        console.log('█  Version: Plonky3 Fix v2     █');
+        console.log('█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█');
+        this.messageCallbacks = new Map();
+    }
+    handleMessage(event) {
+        try {
+            const message = JSON.parse(event.nativeEvent.data);
+            if (message.type === "wasm_initialized") {
+                this.status = "ready";
+            }
+            const callback = this.messageCallbacks.get(message.type);
+            if (callback) {
+                callback(message);
+            }
+        }
+        catch (error) {
+            console.error('[ZkProofBridge] Message parse error:', error);
+        }
+    }
+    async loadWasmModule() {
+        // NOTE:
+        // ZK WASM initialization is driven by `ZkProofWebView`:
+        // - WebView sends `ready`
+        // - RN sends `init_wasm` with base64 wasm
+        // - Worker sends `wasm_initialized`
+        //
+        // Therefore, `loadWasmModule()` should act as "wait until initialized",
+        // not try to perform initialization itself.
+        console.log('[ZkProofBridge] loadWasmModule - waiting for wasm_initialized');
+        if (this.status === 'ready')
+            return;
+        this.status = 'loading';
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.status = 'error';
+                this.messageCallbacks.delete('wasm_initialized');
+                this.messageCallbacks.delete('INIT_ERROR');
+                reject(new Error('WASM load timeout'));
+            }, 30000);
+            // Preferred signal from worker
+            this.messageCallbacks.set('wasm_initialized', () => {
+                clearTimeout(timeout);
+                this.status = 'ready';
+                this.messageCallbacks.delete('wasm_initialized');
+                this.messageCallbacks.delete('INIT_ERROR');
+                resolve();
+            });
+            // Backwards compatible error signal (if worker ever emits it)
+            this.messageCallbacks.set('INIT_ERROR', (data) => {
+                clearTimeout(timeout);
+                this.status = 'error';
+                this.messageCallbacks.delete('wasm_initialized');
+                this.messageCallbacks.delete('INIT_ERROR');
+                reject(new Error(data.error || 'WASM init failed'));
+            });
+        });
+    }
+    async generateProof(embedding1, embedding2, nonce) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('Proof generation timeout'));
+            }, 120000);
+            this.messageCallbacks.set('proof_result', (data) => {
+                clearTimeout(timeout);
+                this.messageCallbacks.delete('proof_result');
+                this.messageCallbacks.delete('error');
+                const payload = data?.data;
+                if (!payload) {
+                    reject(new Error('Malformed WebView response: missing data'));
+                    return;
+                }
+                resolve({
+                    proof: payload.proof || '',
+                    publicInputs: payload.public_inputs || []
+                });
+            });
+            this.messageCallbacks.set('error', (data) => {
+                clearTimeout(timeout);
+                this.messageCallbacks.delete('proof_result');
+                this.messageCallbacks.delete('error');
+                reject(new Error(data.error || 'Proof generation failed'));
+            });
+            this.sendMessage('generate_proof', {
+                storedEmbedding: embedding1,
+                capturedEmbedding: embedding2,
+                nonce
+            });
+        });
+    }
+    async verifyProof(proof, publicInputs, vk) {
+        console.log('[ZkProofBridge] verifyProof - calling WASM');
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('Proof verification timeout'));
+            }, 30000);
+            this.messageCallbacks.set('verify_result', (data) => {
+                clearTimeout(timeout);
+                this.messageCallbacks.delete('verify_result');
+                this.messageCallbacks.delete('error');
+                const payload = data?.data;
+                if (!payload) {
+                    reject(new Error('Malformed WebView response: missing data'));
+                    return;
+                }
+                // Result structure from WASM: { "verified": true/false, "error": null }
+                resolve(payload.verified === true);
+            });
+            this.messageCallbacks.set('error', (data) => {
+                clearTimeout(timeout);
+                this.messageCallbacks.delete('verify_result');
+                this.messageCallbacks.delete('error');
+                reject(new Error(data.error || 'Proof verification failed'));
+            });
+            this.sendMessage('verify_proof', {
+                proof,
+                public_inputs: publicInputs,
+                vk
+            });
+        });
+    }
+    async getProofHash(proof) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('Hash generation timeout'));
+            }, 5000);
+            this.messageCallbacks.set('hash_result', (data) => {
+                clearTimeout(timeout);
+                this.messageCallbacks.delete('hash_result');
+                this.messageCallbacks.delete('error');
+                resolve(data.hash);
+            });
+            this.messageCallbacks.set('error', (data) => {
+                clearTimeout(timeout);
+                this.messageCallbacks.delete('hash_result');
+                this.messageCallbacks.delete('error');
+                reject(new Error(data.error || 'Hash generation failed'));
+            });
+            this.sendMessage('get_proof_hash', { proof });
+        });
+    }
+    sendMessage(type, payload) {
+        const message = JSON.stringify({ type, payload });
+        if (this.webViewRef.current) {
+            this.webViewRef.current.postMessage(message);
+        }
+    }
+}
+exports.ZkProofBridge = ZkProofBridge;
+/**
+ * ZkProofWebView - Plonky3 WASM WebView Bridge
+ *
+ * Loads the zk-worker.html containing full WASM bindings and message handlers.
+ * Injects WASM binary as base64 for initialization.
+ */
+const ZkProofWebView = ({ onReady, onError, wasmData }) => {
+    const webViewRef = (0, react_1.useRef)(null);
+    const bridgeRef = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        console.log('[ZkProofWebView] Component mounted');
+        return () => console.log('[ZkProofWebView] Component unmounted');
+    }, []);
+    const handleMessage = (event) => {
+        if (bridgeRef.current) {
+            bridgeRef.current.handleMessage(event);
+        }
+        try {
+            const message = JSON.parse(event.nativeEvent.data);
+            if (message.type === 'LOG') {
+                console.log('[ZkProofWebView]', message.message);
+            }
+            else if (message.type === 'ready') {
+                console.log('[ZkProofWebView] Worker ready signal received. Sending WASM binary...');
+                if (bridgeRef.current && wasmData) {
+                    bridgeRef.current.sendMessage('init_wasm', {
+                        wasmBase64: wasmData.wasmBase64
+                    });
+                }
+            }
+            else if (message.type === 'wasm_initialized') {
+                console.log('[ZkProofWebView] WASM fully initialized! Bridge is ready.');
+                if (bridgeRef.current) {
+                    bridgeRef.current.status = "ready";
+                    onReady(bridgeRef.current);
+                }
+            }
+        }
+        catch (e) {
+            console.error('[ZkProofWebView] Message parse error:', e);
+        }
+    };
+    const handleWebViewLoad = () => {
+        console.log('[ZkProofWebView] WebView loaded');
+        if (!bridgeRef.current) {
+            const bridge = new ZkProofBridge(webViewRef);
+            bridgeRef.current = bridge;
+        }
+        // Don't call onReady here anymore. Wait for 'wasm_initialized'.
+    };
+    // Don't render until we have WASM data
+    if (!wasmData) {
+        return null;
+    }
+    return (<react_native_1.View style={styles.hidden}>
+            <react_native_webview_1.WebView ref={webViewRef} 
+    // CRITICAL: baseUrl must be https://localhost to provide a Secure Context for WebAssembly logic.
+    // It does NOT make actual network requests, but prevents the WebView from throwing security errors.
+    source={{ html: wasmData.workerHtml, baseUrl: 'https://localhost' }} onMessage={handleMessage} onLoad={handleWebViewLoad} onError={(syntheticEvent) => {
+            const { nativeEvent } = syntheticEvent;
+            console.error('[ZkProofWebView] WebView error:', nativeEvent);
+            onError(nativeEvent.description || 'WebView load error');
+        }} javaScriptEnabled={true} injectedJavaScriptBeforeContentLoaded={`
+                    const originalLog = console.log;
+                    console.log = function(...args) {
+                        originalLog.apply(console, args);
+                        if (window.ReactNativeWebView) {
+                            window.ReactNativeWebView.postMessage(JSON.stringify({
+                                type: 'LOG',
+                                message: args.join(' ')
+                            }));
+                        }
+                    };
+                `}/>
+        </react_native_1.View>);
+};
+exports.ZkProofWebView = ZkProofWebView;
+const styles = react_native_1.StyleSheet.create({
+    hidden: {
+        position: 'absolute',
+        width: 0,
+        height: 0,
+        opacity: 0
+    }
+});
+exports.default = exports.ZkProofWebView;

package/dist/react-native/dependencies.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Copyright 2026 JupiterMeta Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * SDK Dependencies - Dependency Injection
+ *
+ * This module provides a dependency injection system for external dependencies
+ * that the SDK needs but should not directly import from the host app.
+ *
+ * This allows the SDK to be published as a standalone package while still
+ * integrating with platform-specific implementations.
+ */
+import type React from "react";
+/**
+ * External dependencies that must be provided by the host application.
+ * These are platform-specific implementations that the SDK uses but doesn't own.
+ */
+export interface SdkDependencies {
+    OnnxRuntimeWebView: React.ComponentType<{
+        onReady: (bridge: any) => void;
+        onError: (error: string) => void;
+    }>;
+    OnnxRuntimeBridge: new (webViewRef: any) => any;
+    ZkProofWebView: React.ComponentType<{
+        onReady: (bridge: any) => void;
+        onError: (error: string) => void;
+        wasmData: any;
+    }>;
+    ZkProofBridge: new (webViewRef: any) => any;
+    ZkFaceAuth: React.ComponentType<{
+        onSuccess: (imageUri: string, metadata?: any) => void;
+        onError: (message: string) => void;
+        manualTargetPose?: {
+            yaw: number;
+            pitch: number;
+            roll: number;
+        };
+        referenceImageUri?: string;
+        renderOverlay?: (state: any) => React.ReactNode;
+        headless?: boolean;
+    }>;
+    FacePoseGuidanceWebView: React.ComponentType<{
+        referenceImageUri?: string;
+        headless?: boolean;
+        onSuccess: (imageUri: string, metadata?: any) => void;
+        onError: (message: string) => void;
+        onCancel?: () => void;
+        manualTargetPose?: {
+            yaw: number;
+            pitch: number;
+            roll: number;
+        };
+    }>;
+    faceRecognitionService: {
+        setBridge(bridge: any): void;
+        isBridgeSet(): boolean;
+        loadModels(): Promise<void>;
+        processImageForEmbedding(imageUri: string): Promise<{
+            status: "ok" | "no_face" | "multiple_faces" | "error";
+            embedding?: number[];
+            pose?: {
+                yaw: number;
+                pitch: number;
+                roll: number;
+            };
+            message?: string;
+        }>;
+    };
+    useWasmLoader: () => {
+        wasmData: any;
+        error: string | null;
+        isLoading: boolean;
+    };
+}
+/**
+ * Initialize SDK dependencies.
+ * This must be called once at app startup before using any SDK UI components.
+ *
+ * @param deps Platform-specific dependency implementations
+ *
+ * @example
+ * ```typescript
+ * import { initializeSdkDependencies } from './sdk/react-native/dependencies';
+ * import { OnnxRuntimeWebView, OnnxRuntimeBridge } from './src/components/OnnxRuntimeWebView';
+ * import { ZkProofWebView, ZkProofBridge } from './src/components/ZkProofWebView';
+ * import { ZkFaceAuth } from './src/components/face-verification/LivenessWebView';
+ * import { FacePoseGuidanceWebView } from './src/components/face-verification/FacePoseGuidanceWebView';
+ * import { faceRecognitionService } from './src/services/FaceRecognition';
+ * import { useWasmLoader } from './src/hooks/useWasmLoader';
+ *
+ * initializeSdkDependencies({
+ *   OnnxRuntimeWebView,
+ *   OnnxRuntimeBridge,
+ *   ZkProofWebView,
+ *   ZkProofBridge,
+ *   ZkFaceAuth,
+ *   FacePoseGuidanceWebView,
+ *   faceRecognitionService,
+ *   useWasmLoader,
+ * });
+ * ```
+ */
+export declare function initializeSdkDependencies(deps: SdkDependencies): void;
+/**
+ * Get SDK dependencies.
+ * Throws an error if dependencies haven't been initialized.
+ *
+ * @returns SdkDependencies
+ * @throws Error if dependencies not initialized
+ */
+export declare function getSdkDependencies(): SdkDependencies;
+/**
+ * Check if SDK dependencies are initialized.
+ *
+ * @returns true if initialized, false otherwise
+ */
+export declare function areSdkDependenciesInitialized(): boolean;
+/**
+ * Clear SDK dependencies (for testing or cleanup).
+ */
+export declare function clearSdkDependencies(): void;
+/**
+ * Returns the SDK's built-in default dependencies.
+ * Pass the result to `initializeSdkDependencies()` to make the initialization
+ * explicit in your app (recommended), while still using the SDK's own components.
+ *
+ * @example
+ * ```ts
+ * initializeSdkDependencies(getDefaultSdkDependencies());
+ * ```
+ */
+export declare function getDefaultSdkDependencies(): SdkDependencies;

package/dist/react-native/dependencies.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Copyright 2026 JupiterMeta Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeSdkDependencies = initializeSdkDependencies;
+exports.getSdkDependencies = getSdkDependencies;
+exports.areSdkDependenciesInitialized = areSdkDependenciesInitialized;
+exports.clearSdkDependencies = clearSdkDependencies;
+exports.getDefaultSdkDependencies = getDefaultSdkDependencies;
+// Default (SDK-owned) implementations. These allow the SDK to work out-of-the-box
+// inside this repo (and in apps that bundle these SDK components directly),
+// while still supporting dependency injection for advanced customization.
+const OnnxRuntimeWebView_1 = require("./components/OnnxRuntimeWebView");
+const ZkProofWebView_1 = require("./components/ZkProofWebView");
+const LivenessWebView_1 = require("./components/LivenessWebView");
+const FacePoseGuidanceWebView_1 = require("./components/FacePoseGuidanceWebView");
+const FaceRecognition_1 = require("./services/FaceRecognition");
+const useWasmLoader_1 = require("./hooks/useWasmLoader");
+/**
+ * Global dependencies storage
+ */
+let dependencies = null;
+/**
+ * Initialize SDK dependencies.
+ * This must be called once at app startup before using any SDK UI components.
+ *
+ * @param deps Platform-specific dependency implementations
+ *
+ * @example
+ * ```typescript
+ * import { initializeSdkDependencies } from './sdk/react-native/dependencies';
+ * import { OnnxRuntimeWebView, OnnxRuntimeBridge } from './src/components/OnnxRuntimeWebView';
+ * import { ZkProofWebView, ZkProofBridge } from './src/components/ZkProofWebView';
+ * import { ZkFaceAuth } from './src/components/face-verification/LivenessWebView';
+ * import { FacePoseGuidanceWebView } from './src/components/face-verification/FacePoseGuidanceWebView';
+ * import { faceRecognitionService } from './src/services/FaceRecognition';
+ * import { useWasmLoader } from './src/hooks/useWasmLoader';
+ *
+ * initializeSdkDependencies({
+ *   OnnxRuntimeWebView,
+ *   OnnxRuntimeBridge,
+ *   ZkProofWebView,
+ *   ZkProofBridge,
+ *   ZkFaceAuth,
+ *   FacePoseGuidanceWebView,
+ *   faceRecognitionService,
+ *   useWasmLoader,
+ * });
+ * ```
+ */
+function initializeSdkDependencies(deps) {
+    dependencies = deps;
+    console.log("[SDK] Dependencies initialized successfully");
+}
+/**
+ * Get SDK dependencies.
+ * Throws an error if dependencies haven't been initialized.
+ *
+ * @returns SdkDependencies
+ * @throws Error if dependencies not initialized
+ */
+function getSdkDependencies() {
+    if (!dependencies) {
+        // Fall back to SDK-owned defaults.
+        // This keeps the SDK usable in this repo without requiring initialization plumbing.
+        dependencies = {
+            OnnxRuntimeWebView: OnnxRuntimeWebView_1.OnnxRuntimeWebView,
+            OnnxRuntimeBridge: OnnxRuntimeWebView_1.OnnxRuntimeBridge,
+            ZkProofWebView: ZkProofWebView_1.ZkProofWebView,
+            ZkProofBridge: ZkProofWebView_1.ZkProofBridge,
+            ZkFaceAuth: LivenessWebView_1.ZkFaceAuth,
+            FacePoseGuidanceWebView: FacePoseGuidanceWebView_1.FacePoseGuidanceWebView,
+            faceRecognitionService: FaceRecognition_1.faceRecognitionService,
+            useWasmLoader: useWasmLoader_1.useWasmLoader,
+        };
+        console.warn("[SDK] Dependencies not initialized. Falling back to SDK defaults. " +
+            "For custom implementations, call initializeSdkDependencies().");
+    }
+    return dependencies;
+}
+/**
+ * Check if SDK dependencies are initialized.
+ *
+ * @returns true if initialized, false otherwise
+ */
+function areSdkDependenciesInitialized() {
+    return dependencies !== null;
+}
+/**
+ * Clear SDK dependencies (for testing or cleanup).
+ */
+function clearSdkDependencies() {
+    dependencies = null;
+    console.log("[SDK] Dependencies cleared");
+}
+/**
+ * Returns the SDK's built-in default dependencies.
+ * Pass the result to `initializeSdkDependencies()` to make the initialization
+ * explicit in your app (recommended), while still using the SDK's own components.
+ *
+ * @example
+ * ```ts
+ * initializeSdkDependencies(getDefaultSdkDependencies());
+ * ```
+ */
+function getDefaultSdkDependencies() {
+    return {
+        OnnxRuntimeWebView: OnnxRuntimeWebView_1.OnnxRuntimeWebView,
+        OnnxRuntimeBridge: OnnxRuntimeWebView_1.OnnxRuntimeBridge,
+        ZkProofWebView: ZkProofWebView_1.ZkProofWebView,
+        ZkProofBridge: ZkProofWebView_1.ZkProofBridge,
+        ZkFaceAuth: LivenessWebView_1.ZkFaceAuth,
+        FacePoseGuidanceWebView: FacePoseGuidanceWebView_1.FacePoseGuidanceWebView,
+        faceRecognitionService: FaceRecognition_1.faceRecognitionService,
+        useWasmLoader: useWasmLoader_1.useWasmLoader,
+    };
+}

package/dist/react-native/hooks/useOnnxLoader.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright 2026 JupiterMeta Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Data returned by useOnnxLoader, ready to pass to OnnxRuntimeWebView.
+ */
+export interface OnnxLoaderData {
+    /** Text content of ort.min.js — inlined in the WebView HTML. */
+    ortJsContent: string;
+    /** Base64-encoded ort-wasm-simd.wasm — sent to the WebView via postMessage after load. */
+    wasmBase64: string;
+}
+/**
+ * Hook for loading ONNX Runtime assets.
+ *
+ * Loads ort.min.js and ort-wasm-simd.wasm so the ONNX Runtime WebView can run
+ * fully offline. Sources are resolved from `FaceZkConfig.runtimeAssets` when
+ * the SDK is initialised; otherwise the SDK's bundled copies are used.
+ */
+export declare function useOnnxLoader(): {
+    isLoading: boolean;
+    error: string | null;
+    isReady: boolean;
+    onnxData: OnnxLoaderData | null;
+};

package/dist/react-native/hooks/useOnnxLoader.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Copyright 2026 JupiterMeta Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOnnxLoader = useOnnxLoader;
+const react_1 = require("react");
+const FaceZkSdk_1 = require("../../FaceZkSdk");
+const resolveRuntimeAsset_1 = require("../utils/resolveRuntimeAsset");
+/**
+ * Hook for loading ONNX Runtime assets.
+ *
+ * Loads ort.min.js and ort-wasm-simd.wasm so the ONNX Runtime WebView can run
+ * fully offline. Sources are resolved from `FaceZkConfig.runtimeAssets` when
+ * the SDK is initialised; otherwise the SDK's bundled copies are used.
+ */
+function useOnnxLoader() {
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [isReady, setIsReady] = (0, react_1.useState)(false);
+    const [onnxData, setOnnxData] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        let mounted = true;
+        async function loadOnnxResources() {
+            try {
+                setIsLoading(true);
+                setError(null);
+                console.log('[useOnnxLoader] Loading ONNX Runtime assets...');
+                const allowedDomains = FaceZkSdk_1.FaceZkSdk.isInitialized()
+                    ? FaceZkSdk_1.FaceZkSdk.getConfig().allowedDomains
+                    : undefined;
+                // Load ort.min.js as text
+                const ortJsContent = await (0, resolveRuntimeAsset_1.resolveRuntimeAsset)('ortJs', 'utf8', allowedDomains);
+                console.log('[useOnnxLoader] ORT JS loaded, size:', ortJsContent.length);
+                // Load ort-wasm-simd.wasm as base64
+                let wasmBase64 = await (0, resolveRuntimeAsset_1.resolveRuntimeAsset)('ortWasm', 'base64', allowedDomains);
+                // Strip any whitespace/newlines that may cause atob failure in the WebView
+                wasmBase64 = wasmBase64.replace(/\s/g, '');
+                console.log('[useOnnxLoader] ORT WASM base64 size:', wasmBase64.length);
+                if (mounted) {
+                    setOnnxData({ ortJsContent, wasmBase64 });
+                    setIsReady(true);
+                    setIsLoading(false);
+                    console.log('[useOnnxLoader] ✅ ONNX Runtime assets ready');
+                }
+            }
+            catch (err) {
+                console.error('[useOnnxLoader] Error loading ONNX assets:', err);
+                if (mounted) {
+                    setError(err.message || 'Failed to load ONNX Runtime assets');
+                    setIsLoading(false);
+                    setIsReady(false);
+                }
+            }
+        }
+        loadOnnxResources();
+        return () => {
+            mounted = false;
+        };
+    }, []);
+    return { isLoading, error, isReady, onnxData };
+}