@switchlabs/verify-ai-react-native 1.0.0 → 1.1.1

package/lib/hooks/useVerifyAI.js

@@ -1,7 +1,8 @@
-import { useMemo, useCallback, useState, useEffect } from 'react';
-import { AppState } from 'react-native';
+import React, { useMemo, useCallback, useState, useEffect, useRef } from 'react';
+import { AppState, Platform } from 'react-native';
 import { VerifyAIClient, VerifyAIRequestError } from '../client';
 import { OfflineQueue } from '../storage/offlineQueue';
+import { TelemetryContext } from '../telemetry/TelemetryContext';
 function isQueueableError(error) {
     if (error instanceof VerifyAIRequestError) {
         return error.isRetryable;
@@ -15,35 +16,84 @@ function isQueueableError(error) {
         message.includes('timed out') ||
         message.includes('failed to fetch'));
 }
+function isOfflineError(error) {
+    const message = error.message.toLowerCase();
+    return (message.includes('network') ||
+        message.includes('failed to fetch') ||
+        message.includes('no internet'));
+}
 /**
- * React hook for Verify AI. Provides verification methods,
- * loading/error state, and optional offline queue management.
+ * React hook for Verify AI with optional on-device ML inference.
  *
  * @example
  * ```tsx
- * const { verify, loading, lastResult, error } = useVerifyAI({
+ * const { verify, loading, lastResult, mlModelReady, initializeMLModel } = useVerifyAI({
  *   apiKey: 'vai_your_api_key',
  *   offlineMode: true,
+ *   enableOnDeviceML: true,
  * });
  *
+ * // Initialize ML model on mount
+ * useEffect(() => {
+ *   initializeMLModel('scooter_parking');
+ * }, []);
+ *
  * const handleCapture = async (base64Image: string) => {
  *   const result = await verify({
  *     image: base64Image,
  *     policy: 'scooter_parking',
  *   });
- *   if (result?.is_compliant) {
- *     // Success
- *   }
  * };
  * ```
  */
 export function useVerifyAI(config) {
-    const client = useMemo(() => new VerifyAIClient(config), [config.apiKey, config.baseUrl, config.timeout]);
-    const offlineQueue = useMemo(() => (config.offlineMode ? new OfflineQueue(client) : null), [client, config.offlineMode]);
+    const { enableOnDeviceML = false, onDeviceConfidenceThreshold = 0.7, ...baseConfig } = config;
+    const client = useMemo(() => new VerifyAIClient({
+        apiKey: baseConfig.apiKey,
+        baseUrl: baseConfig.baseUrl,
+        timeout: baseConfig.timeout,
+        offlineMode: baseConfig.offlineMode,
+        telemetry: baseConfig.telemetry,
+    }), [baseConfig.apiKey, baseConfig.baseUrl, baseConfig.timeout, baseConfig.offlineMode, baseConfig.telemetry]);
+    const offlineQueue = useMemo(() => (baseConfig.offlineMode ? new OfflineQueue(client) : null), [client, baseConfig.offlineMode]);
+    // ML components — lazily loaded to avoid requiring ML deps when not enabled
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const modelManagerRef = useRef(null);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const inferenceEngineRef = useRef(null);
     const [loading, setLoading] = useState(false);
     const [error, setError] = useState(null);
     const [lastResult, setLastResult] = useState(null);
     const [queueSize, setQueueSize] = useState(0);
+    const [mlModelReady, setMlModelReady] = useState(false);
+    // Initialize ML components lazily via dynamic import
+    useEffect(() => {
+        if (!enableOnDeviceML || !baseConfig.apiKey)
+            return;
+        let disposed = false;
+        (async () => {
+            try {
+                const [{ ModelManager }, { InferenceEngine }] = await Promise.all([
+                    import('../ml/modelManager'),
+                    import('../ml/inferenceEngine'),
+                ]);
+                if (disposed)
+                    return;
+                modelManagerRef.current = new ModelManager({
+                    apiKey: baseConfig.apiKey,
+                    baseUrl: baseConfig.baseUrl,
+                });
+                inferenceEngineRef.current = new InferenceEngine();
+            }
+            catch (err) {
+                console.warn('[VerifyAI] Failed to load ML modules:', err);
+            }
+        })();
+        return () => {
+            disposed = true;
+            inferenceEngineRef.current?.dispose();
+        };
+    }, [enableOnDeviceML, baseConfig.apiKey, baseConfig.baseUrl]);
     // Refresh queue size
     const refreshQueueSize = useCallback(async () => {
         if (offlineQueue) {
@@ -64,18 +114,141 @@ export function useVerifyAI(config) {
         const subscription = AppState.addEventListener('change', handleAppState);
         return () => subscription.remove();
     }, [offlineQueue, refreshQueueSize]);
-    const verify = useCallback(async (request) => {
+    /** Initialize or update the on-device ML model for a policy. */
+    const initializeMLModel = useCallback(async (policyId) => {
+        if (!enableOnDeviceML || !modelManagerRef.current || !inferenceEngineRef.current)
+            return;
+        try {
+            // Load cached bundle first
+            const bundle = await modelManagerRef.current.loadCachedBundle(policyId);
+            if (bundle) {
+                await inferenceEngineRef.current.loadModel(bundle);
+                setMlModelReady(true);
+            }
+            // Check for updates in background
+            const platform = Platform.OS === 'ios' ? 'ios' : 'android';
+            const updatedBundle = await modelManagerRef.current.checkForUpdates(policyId, platform);
+            if (updatedBundle && updatedBundle.bundleVersion !== bundle?.bundleVersion) {
+                await inferenceEngineRef.current.loadModel(updatedBundle);
+                setMlModelReady(true);
+            }
+        }
+        catch (err) {
+            setMlModelReady(false);
+            client.telemetry?.track('ml_model_load_failure', {
+                component: 'useVerifyAI',
+                error: err,
+            });
+        }
+    }, [enableOnDeviceML, client.telemetry]);
+    /** Try on-device verification. Returns null if inference fails or low confidence. */
+    const tryOnDeviceVerification = useCallback(async (params, ignoreThreshold = false) => {
+        try {
+            const modelManager = modelManagerRef.current;
+            const inferenceEngine = inferenceEngineRef.current;
+            const bundle = modelManager?.currentBundle;
+            if (!inferenceEngine?.isLoaded || !bundle)
+                return null;
+            // Lazily import ML modules
+            const [{ extractFeatures }, { evaluatePolicy }] = await Promise.all([
+                import('../ml/featureExtractor'),
+                import('../ml/policyEngine'),
+            ]);
+            // Run inference
+            const rawDetections = inferenceEngine.runInference(params.preprocessedInput);
+            // Extract features
+            const features = extractFeatures(rawDetections);
+            // Evaluate policy
+            const policyResult = evaluatePolicy(bundle.policyAst, features);
+            // Check confidence threshold
+            if (!ignoreThreshold && policyResult.confidence < onDeviceConfidenceThreshold) {
+                return null;
+            }
+            return {
+                id: `local_${Date.now()}`,
+                created_at: new Date().toISOString(),
+                status: 'success',
+                is_compliant: policyResult.is_compliant,
+                confidence: policyResult.confidence,
+                policy: params.policy,
+                violation_reasons: policyResult.violation_reasons,
+                feedback: policyResult.feedback,
+                metadata: {
+                    ...params.metadata,
+                    evaluation_source: 'on_device',
+                    bundle_version: bundle.bundleVersion,
+                    category: policyResult.category_id,
+                },
+                image_url: null,
+            };
+        }
+        catch (err) {
+            client.telemetry?.track('ml_inference_failure', {
+                component: 'useVerifyAI',
+                error: err,
+            });
+            return null;
+        }
+    }, [onDeviceConfidenceThreshold, client.telemetry]);
+    const tryOnDeviceBase64Verification = useCallback(async (request, ignoreThreshold = false) => {
+        try {
+            const { preprocessImageBase64 } = await import('../ml/imagePreprocessor');
+            const preprocessedInput = preprocessImageBase64(request.image);
+            return tryOnDeviceVerification({
+                policy: request.policy,
+                metadata: request.metadata,
+                preprocessedInput,
+            }, ignoreThreshold);
+        }
+        catch {
+            return null;
+        }
+    }, [tryOnDeviceVerification]);
+    const tryOnDeviceMultipartVerification = useCallback(async (request, ignoreThreshold = false) => {
+        try {
+            const { preprocessImageUri } = await import('../ml/imagePreprocessor');
+            const preprocessedInput = await preprocessImageUri(request.imageUri);
+            return tryOnDeviceVerification({
+                policy: request.policy,
+                metadata: request.metadata,
+                preprocessedInput,
+            }, ignoreThreshold);
+        }
+        catch {
+            return null;
+        }
+    }, [tryOnDeviceVerification]);
+    const verify = useCallback(async (request, options) => {
         setLoading(true);
         setError(null);
         try {
-            const result = await client.verify(request);
+            // Try on-device inference first
+            if (enableOnDeviceML && mlModelReady) {
+                const localResult = await tryOnDeviceBase64Verification(request);
+                if (localResult) {
+                    setLastResult(localResult);
+                    setLoading(false);
+                    return localResult;
+                }
+                // Fall through to cloud
+            }
+            const result = await client.verify(request, options);
             setLastResult(result);
             return result;
         }
         catch (err) {
             const error = err instanceof Error ? err : new Error(String(err));
             setError(error);
-            // Queue only transient failures so invalid requests are surfaced immediately.
+            // If offline and we have a model, try on-device regardless of confidence
+            if (enableOnDeviceML && mlModelReady && isOfflineError(error)) {
+                const localResult = await tryOnDeviceBase64Verification(request, true);
+                if (localResult) {
+                    setLastResult(localResult);
+                    setLoading(false);
+                    return localResult;
+                }
+            }
+            // Queue only transient failures
             if (offlineQueue && isQueueableError(error)) {
                 await offlineQueue.enqueue(request);
                 await refreshQueueSize();
@@ -86,7 +259,38 @@ export function useVerifyAI(config) {
         finally {
             setLoading(false);
         }
-    }, [client, offlineQueue, refreshQueueSize]);
+    }, [client, offlineQueue, refreshQueueSize, enableOnDeviceML, mlModelReady, tryOnDeviceBase64Verification]);
+    const verifyMultipart = useCallback(async (request, options) => {
+        setLoading(true);
+        setError(null);
+        try {
+            if (enableOnDeviceML && mlModelReady) {
+                const localResult = await tryOnDeviceMultipartVerification(request);
+                if (localResult) {
+                    setLastResult(localResult);
+                    return localResult;
+                }
+            }
+            const result = await client.verifyMultipart(request, options);
+            setLastResult(result);
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            setError(error);
+            if (enableOnDeviceML && mlModelReady && isOfflineError(error)) {
+                const localResult = await tryOnDeviceMultipartVerification(request, true);
+                if (localResult) {
+                    setLastResult(localResult);
+                    return localResult;
+                }
+            }
+            throw error;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client, enableOnDeviceML, mlModelReady, tryOnDeviceMultipartVerification]);
     const listVerifications = useCallback((params) => client.listVerifications(params), [client]);
     const getVerification = useCallback((id) => client.getVerification(id), [client]);
     const processQueue = useCallback(async () => {
@@ -95,8 +299,32 @@ export function useVerifyAI(config) {
         await offlineQueue.processQueue((_, result) => setLastResult(result));
         await refreshQueueSize();
     }, [offlineQueue, refreshQueueSize]);
+    // Flush telemetry on app background, dispose on unmount
+    useEffect(() => {
+        const reporter = client.telemetry;
+        if (!reporter)
+            return;
+        const handleAppState = (state) => {
+            if (state === 'background' || state === 'inactive') {
+                reporter.flush();
+            }
+        };
+        const subscription = AppState.addEventListener('change', handleAppState);
+        return () => {
+            subscription.remove();
+            reporter.dispose();
+        };
+    }, [client.telemetry]);
+    // Memoized TelemetryProvider component
+    const TelemetryProvider = useMemo(() => {
+        const reporter = client.telemetry;
+        const Provider = ({ children }) => React.createElement(TelemetryContext.Provider, { value: reporter }, children);
+        Provider.displayName = 'TelemetryProvider';
+        return Provider;
+    }, [client.telemetry]);
     return {
         verify,
+        verifyMultipart,
         listVerifications,
         getVerification,
         loading,
@@ -106,5 +334,9 @@ export function useVerifyAI(config) {
         processQueue,
         client,
         offlineQueue,
+        mlModelReady,
+        initializeMLModel,
+        telemetry: client.telemetry,
+        TelemetryProvider,
     };
 }

package/lib/index.d.ts

@@ -1,7 +1,10 @@
 export { VerifyAIClient, VerifyAIRequestError } from './client';
 export { useVerifyAI } from './hooks/useVerifyAI';
-export type { UseVerifyAIReturn } from './hooks/useVerifyAI';
+export type { UseVerifyAIReturn, UseVerifyAIConfig } from './hooks/useVerifyAI';
 export { VerifyAIScanner } from './components/VerifyAIScanner';
 export type { VerifyAIScannerProps } from './components/VerifyAIScanner';
+export { TelemetryReporter } from './telemetry/TelemetryReporter';
+export { TelemetryContext } from './telemetry/TelemetryContext';
 export { OfflineQueue } from './storage/offlineQueue';
-export type { VerifyAIConfig, VerificationRequest, VerificationResult, VerificationListResponse, VerificationListParams, QueueItem, VerifyAIError, ScannerStatus, ScannerOverlayConfig, PolicyConfigResponse, } from './types';
+export type { BundleManifest, ModelArtifact, FeatureVector, Detection as MLDetection, PolicyAST, PolicyResult, RuleResult, } from './ml/types';
+export type { VerifyAIConfig, VerificationRequest, MultipartVerificationRequest, VerificationResult, VerificationListResponse, VerificationListParams, QueueItem, VerifyAIError, ScannerStatus, ScannerOverlayConfig, PolicyConfigResponse, } from './types';

package/lib/index.js

@@ -4,5 +4,8 @@ export { VerifyAIClient, VerifyAIRequestError } from './client';
 export { useVerifyAI } from './hooks/useVerifyAI';
 // Components
 export { VerifyAIScanner } from './components/VerifyAIScanner';
+// Telemetry
+export { TelemetryReporter } from './telemetry/TelemetryReporter';
+export { TelemetryContext } from './telemetry/TelemetryContext';
 // Offline Queue
 export { OfflineQueue } from './storage/offlineQueue';

package/lib/ml/featureExtractor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Feature extractor — converts raw detections into a structured FeatureVector.
+ * Must produce identical output to the Dart and server TypeScript implementations.
+ */
+import type { FeatureVector } from './types';
+/** Ontology class name mapping (must match ontology.ts) */
+export declare const ONTOLOGY_CLASS_NAMES: Record<number, string>;
+/** Detection model class index -> ontology class ID mapping. */
+export declare const MODEL_OUTPUT_CLASS_IDS: readonly [1, 2, 3, 4, 5, 20, 21, 22, 23, 24, 40, 41, 42, 43, 44, 45, 46, 47, 48, 60, 61, 62, 63, 64, 65, 66, 80, 81, 82, 83, 84, 85, 86, 87];
+interface RawDetection {
+    classId: number;
+    confidence: number;
+    bbox: [number, number, number, number];
+}
+export declare function extractFeatures(rawDetections: RawDetection[]): FeatureVector;
+export {};

package/lib/ml/featureExtractor.js

@@ -0,0 +1,123 @@
+/**
+ * Feature extractor — converts raw detections into a structured FeatureVector.
+ * Must produce identical output to the Dart and server TypeScript implementations.
+ */
+const SCHEMA_VERSION = '1.0.0';
+/** Vehicle class IDs (must match ontology.ts) */
+const VEHICLE_CLASS_IDS = new Set([1, 2, 3, 4, 5]);
+/** Surface class IDs */
+const SURFACE_CLASS_IDS = new Set([60, 61, 62, 63, 64, 65, 66]);
+/** Ontology class name mapping (must match ontology.ts) */
+export const ONTOLOGY_CLASS_NAMES = {
+    1: 'scooter', 2: 'bicycle', 3: 'ebike', 4: 'moped', 5: 'motorcycle',
+    20: 'kickstand', 21: 'handlebar', 22: 'wheel', 23: 'saddle', 24: 'basket',
+    40: 'bike_rack', 41: 'curb', 42: 'parking_bay', 43: 'green_bay',
+    44: 'tactile_paving', 45: 'bollard', 46: 'fence', 47: 'pole', 48: 'yellow_lines',
+    60: 'sidewalk', 61: 'road', 62: 'grass', 63: 'crosswalk',
+    64: 'dirt', 65: 'gravel', 66: 'parking_lot',
+    80: 'person', 81: 'entrance', 82: 'obstruction', 83: 'bench',
+    84: 'garbage_bin', 85: 'fire_escape', 86: 'ramp', 87: 'driveway',
+};
+/** Detection model class index -> ontology class ID mapping. */
+export const MODEL_OUTPUT_CLASS_IDS = [
+    1, 2, 3, 4, 5,
+    20, 21, 22, 23, 24,
+    40, 41, 42, 43, 44, 45, 46, 47, 48,
+    60, 61, 62, 63, 64, 65, 66,
+    80, 81, 82, 83, 84, 85, 86, 87,
+];
+export function extractFeatures(rawDetections) {
+    // Convert raw detections to typed detections
+    const detections = rawDetections.map((raw) => ({
+        class_id: raw.classId,
+        class_name: ONTOLOGY_CLASS_NAMES[raw.classId] || `unknown_${raw.classId}`,
+        confidence: raw.confidence,
+        bbox: raw.bbox,
+    }));
+    // Find primary vehicle (highest confidence)
+    let primaryVehicle = null;
+    for (const det of detections) {
+        if (VEHICLE_CLASS_IDS.has(det.class_id)) {
+            if (!primaryVehicle || det.confidence > primaryVehicle.confidence) {
+                primaryVehicle = det;
+            }
+        }
+    }
+    // Determine surface under vehicle
+    let vehicleOnSurface = null;
+    if (primaryVehicle) {
+        vehicleOnSurface = findSurfaceUnderVehicle(primaryVehicle, detections);
+    }
+    // Find objects near the vehicle
+    const vehicleNear = [];
+    if (primaryVehicle) {
+        vehicleNear.push(...findObjectsNearVehicle(primaryVehicle, detections));
+    }
+    // Assess image quality
+    const imageQuality = {
+        is_blurry: false,
+        is_dark: false,
+        has_vehicle: primaryVehicle !== null,
+    };
+    return {
+        schema_version: SCHEMA_VERSION,
+        detections,
+        primary_vehicle: primaryVehicle,
+        image_quality: imageQuality,
+        vehicle_on_surface: vehicleOnSurface,
+        vehicle_near: vehicleNear,
+    };
+}
+function findSurfaceUnderVehicle(vehicle, allDetections) {
+    const surfaces = allDetections.filter((d) => SURFACE_CLASS_IDS.has(d.class_id));
+    let bestSurface = null;
+    let bestOverlap = 0;
+    for (const surface of surfaces) {
+        // Check overlap with vehicle bottom half
+        const vehicleBottom = [
+            vehicle.bbox[0],
+            (vehicle.bbox[1] + vehicle.bbox[3]) / 2,
+            vehicle.bbox[2],
+            vehicle.bbox[3],
+        ];
+        const overlap = computeIoU(vehicleBottom, surface.bbox);
+        if (overlap > bestOverlap) {
+            bestOverlap = overlap;
+            bestSurface = surface.class_name;
+        }
+    }
+    return bestOverlap > 0.1 ? bestSurface : null;
+}
+function findObjectsNearVehicle(vehicle, allDetections) {
+    const nearObjects = new Set();
+    for (const det of allDetections) {
+        if (VEHICLE_CLASS_IDS.has(det.class_id))
+            continue;
+        if (SURFACE_CLASS_IDS.has(det.class_id))
+            continue;
+        if (isNearby(vehicle.bbox, det.bbox, 0.2)) {
+            nearObjects.add(det.class_name);
+        }
+    }
+    return Array.from(nearObjects);
+}
+function isNearby(bboxA, bboxB, threshold) {
+    const centerAx = (bboxA[0] + bboxA[2]) / 2;
+    const centerAy = (bboxA[1] + bboxA[3]) / 2;
+    const centerBx = (bboxB[0] + bboxB[2]) / 2;
+    const centerBy = (bboxB[1] + bboxB[3]) / 2;
+    return Math.abs(centerAx - centerBx) < threshold || Math.abs(centerAy - centerBy) < threshold;
+}
+function computeIoU(a, b) {
+    const x1 = Math.max(a[0], b[0]);
+    const y1 = Math.max(a[1], b[1]);
+    const x2 = Math.min(a[2], b[2]);
+    const y2 = Math.min(a[3], b[3]);
+    if (x2 <= x1 || y2 <= y1)
+        return 0;
+    const intersection = (x2 - x1) * (y2 - y1);
+    const areaA = (a[2] - a[0]) * (a[3] - a[1]);
+    const areaB = (b[2] - b[0]) * (b[3] - b[1]);
+    const union = areaA + areaB - intersection;
+    return union > 0 ? intersection / union : 0;
+}

package/lib/ml/imagePreprocessor.d.ts

@@ -0,0 +1,2 @@
+export declare function preprocessImageBase64(base64: string, inputSize?: number): Float32Array;
+export declare function preprocessImageUri(imageUri: string, inputSize?: number): Promise<Float32Array>;

package/lib/ml/imagePreprocessor.js

@@ -0,0 +1,48 @@
+import { Buffer } from 'buffer';
+import { decode as decodeJpeg } from 'jpeg-js';
+const DEFAULT_INPUT_SIZE = 640;
+function stripDataUriPrefix(base64) {
+    const marker = 'base64,';
+    const markerIndex = base64.indexOf(marker);
+    return markerIndex >= 0 ? base64.slice(markerIndex + marker.length) : base64;
+}
+function isJpeg(bytes) {
+    return bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xd8;
+}
+function decodeBase64(base64) {
+    return Uint8Array.from(Buffer.from(stripDataUriPrefix(base64), 'base64'));
+}
+function resizeRgbaToChw(rgba, sourceWidth, sourceHeight, inputSize) {
+    const totalPixels = inputSize * inputSize;
+    const tensor = new Float32Array(3 * totalPixels);
+    for (let y = 0; y < inputSize; y++) {
+        const sourceY = Math.min(sourceHeight - 1, Math.floor((y * sourceHeight) / inputSize));
+        for (let x = 0; x < inputSize; x++) {
+            const sourceX = Math.min(sourceWidth - 1, Math.floor((x * sourceWidth) / inputSize));
+            const sourceOffset = (sourceY * sourceWidth + sourceX) * 4;
+            const outputIndex = y * inputSize + x;
+            tensor[outputIndex] = rgba[sourceOffset] / 255;
+            tensor[totalPixels + outputIndex] = rgba[sourceOffset + 1] / 255;
+            tensor[2 * totalPixels + outputIndex] = rgba[sourceOffset + 2] / 255;
+        }
+    }
+    return tensor;
+}
+export function preprocessImageBase64(base64, inputSize = DEFAULT_INPUT_SIZE) {
+    const bytes = decodeBase64(base64);
+    if (!isJpeg(bytes)) {
+        throw new Error('On-device inference currently supports JPEG inputs only');
+    }
+    const decoded = decodeJpeg(bytes, { useTArray: true, tolerantDecoding: true });
+    if (!decoded.width || !decoded.height) {
+        throw new Error('Failed to decode JPEG for on-device inference');
+    }
+    return resizeRgbaToChw(decoded.data, decoded.width, decoded.height, inputSize);
+}
+export async function preprocessImageUri(imageUri, inputSize = DEFAULT_INPUT_SIZE) {
+    const fileSystem = await import('expo-file-system');
+    const base64 = await fileSystem.readAsStringAsync(imageUri, {
+        encoding: fileSystem.EncodingType.Base64,
+    });
+    return preprocessImageBase64(base64, inputSize);
+}

package/lib/ml/index.d.ts

@@ -0,0 +1,5 @@
+export { ModelManager } from './modelManager';
+export { InferenceEngine } from './inferenceEngine';
+export { extractFeatures, ONTOLOGY_CLASS_NAMES } from './featureExtractor';
+export { evaluatePolicy } from './policyEngine';
+export type { BundleManifest, ModelArtifact, FeatureVector, Detection, ImageQuality, PolicyAST, PolicyResult, RuleResult, } from './types';

package/lib/ml/index.js

@@ -0,0 +1,4 @@
+export { ModelManager } from './modelManager';
+export { InferenceEngine } from './inferenceEngine';
+export { extractFeatures, ONTOLOGY_CLASS_NAMES } from './featureExtractor';
+export { evaluatePolicy } from './policyEngine';

package/lib/ml/inferenceEngine.d.ts

@@ -0,0 +1,24 @@
+/**
+ * On-device inference engine for React Native.
+ * Uses react-native-fast-tflite for TFLite inference (uses CoreML delegate on iOS).
+ */
+import type { BundleManifest } from './types';
+interface RawDetection {
+    classId: number;
+    confidence: number;
+    bbox: [number, number, number, number];
+}
+export declare class InferenceEngine {
+    private model;
+    private _isLoaded;
+    private classIds;
+    get isLoaded(): boolean;
+    /** Load the model from a cached bundle artifact. */
+    loadModel(bundle: BundleManifest): Promise<void>;
+    /** Run inference on preprocessed image data. */
+    runInference(input: Float32Array, threshold?: number): RawDetection[];
+    private parseDetections;
+    private resolveClassId;
+    dispose(): void;
+}
+export {};