@switchlabs/verify-ai-react-native 1.1.0 → 1.1.2

package/lib/ml/inferenceEngine.js

@@ -0,0 +1,156 @@
+/**
+ * On-device inference engine for React Native.
+ * Uses react-native-fast-tflite for TFLite inference (uses CoreML delegate on iOS).
+ */
+import { Platform } from 'react-native';
+import { MODEL_OUTPUT_CLASS_IDS } from './featureExtractor';
+export class InferenceEngine {
+    constructor() {
+        this.model = null;
+        this._isLoaded = false;
+        this.classIds = MODEL_OUTPUT_CLASS_IDS;
+    }
+    get isLoaded() {
+        return this._isLoaded;
+    }
+    /** Load the model from a cached bundle artifact. */
+    async loadModel(bundle) {
+        const artifact = bundle.artifacts.find((a) => a.format === 'tflite');
+        if (!artifact?.localPath) {
+            throw new Error('No TFLite artifact with local path in bundle');
+        }
+        try {
+            const tfliteModule = await import('react-native-fast-tflite');
+            const { loadTensorflowModel } = tfliteModule;
+            const preferredDelegate = Platform.OS === 'ios' ? 'core-ml' : undefined;
+            try {
+                this.model = await loadTensorflowModel({ url: artifact.localPath }, preferredDelegate);
+            }
+            catch {
+                this.model = await loadTensorflowModel({ url: artifact.localPath });
+            }
+            this.classIds = bundle.classIds.length > 0 ? bundle.classIds : MODEL_OUTPUT_CLASS_IDS;
+            this._isLoaded = true;
+        }
+        catch (err) {
+            this._isLoaded = false;
+            throw new Error(`Failed to load TFLite model: ${err}`);
+        }
+    }
+    /** Run inference on preprocessed image data. */
+    runInference(input, threshold = 0.3) {
+        if (!this._isLoaded || !this.model) {
+            throw new Error('Model not loaded');
+        }
+        // Run inference
+        const outputs = this.model.runSync([input]);
+        return this.parseDetections(outputs, threshold);
+    }
+    parseDetections(outputs, threshold) {
+        const detections = [];
+        if (!outputs || outputs.length === 0)
+            return detections;
+        if (outputs.length === 1) {
+            // Single combined output: [1, N, 4+num_classes]
+            const output = extractMatrix(outputs[0]);
+            const numDetections = output.length;
+            for (let i = 0; i < numDetections; i++) {
+                const det = output[i];
+                if (det.length < 5)
+                    continue;
+                const bbox = det.slice(0, 4);
+                const scores = det.slice(4);
+                let maxScore = 0;
+                let classIndex = 0;
+                for (let j = 0; j < scores.length; j++) {
+                    if (scores[j] > maxScore) {
+                        maxScore = scores[j];
+                        classIndex = j;
+                    }
+                }
+                if (maxScore >= threshold) {
+                    detections.push({
+                        classId: this.resolveClassId(classIndex),
+                        confidence: maxScore,
+                        bbox,
+                    });
+                }
+            }
+        }
+        else if (outputs.length >= 2) {
+            // Separate boxes and scores
+            const boxes = extractMatrix(outputs[0]);
+            const scoreMatrix = extractMatrix(outputs[1]);
+            const scoreVector = extractVector(outputs[1]);
+            for (let i = 0; i < boxes.length; i++) {
+                const box = boxes[i];
+                let maxScore = 0;
+                let classIndex = 0;
+                const scoreRow = scoreMatrix[i];
+                if (scoreRow) {
+                    for (let j = 0; j < scoreRow.length; j++) {
+                        if (scoreRow[j] > maxScore) {
+                            maxScore = scoreRow[j];
+                            classIndex = j;
+                        }
+                    }
+                }
+                else {
+                    const scalarScore = scoreVector[i] ?? null;
+                    if (scalarScore === null)
+                        continue;
+                    maxScore = scalarScore;
+                }
+                if (maxScore >= threshold) {
+                    detections.push({
+                        classId: this.resolveClassId(classIndex),
+                        confidence: maxScore,
+                        bbox: box,
+                    });
+                }
+            }
+        }
+        return detections;
+    }
+    resolveClassId(classIndex) {
+        return this.classIds[classIndex] ?? classIndex;
+    }
+    dispose() {
+        this.model = null;
+        this._isLoaded = false;
+        this.classIds = MODEL_OUTPUT_CLASS_IDS;
+    }
+}
+function extractMatrix(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    if (value.length === 0) {
+        return [];
+    }
+    const first = value[0];
+    if (Array.isArray(first) && (first.length === 0 || typeof first[0] === 'number')) {
+        return value
+            .filter(Array.isArray)
+            .map((row) => row.map((entry) => Number(entry)));
+    }
+    if (Array.isArray(first)) {
+        return extractMatrix(first);
+    }
+    return [];
+}
+function extractVector(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    if (value.length === 0) {
+        return [];
+    }
+    if (typeof value[0] === 'number') {
+        return value.map((entry) => Number(entry));
+    }
+    if (Array.isArray(value[0])) {
+        return extractVector(value[0]);
+    }
+    return [];
+}

package/lib/ml/modelManager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Model Manager for React Native SDK.
+ * Downloads, caches, and version-checks model bundles.
+ */
+import type { BundleManifest, ModelArtifact } from './types';
+export type { BundleManifest, ModelArtifact };
+interface ModelManagerConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+export declare class ModelManager {
+    private apiKey;
+    private baseUrl;
+    private cachedETag;
+    private _currentBundle;
+    constructor(config: ModelManagerConfig);
+    get currentBundle(): BundleManifest | null;
+    /** Check for bundle updates from the server. */
+    checkForUpdates(policyId: string, platform: 'ios' | 'android'): Promise<BundleManifest | null>;
+    /** Download model artifacts and verify integrity. */
+    private downloadArtifacts;
+    private readFileSha256;
+    private saveBundleManifest;
+    /** Load a cached bundle from disk on startup. */
+    loadCachedBundle(policyId: string): Promise<BundleManifest | null>;
+}

package/lib/ml/modelManager.js

@@ -0,0 +1,207 @@
+/**
+ * Model Manager for React Native SDK.
+ * Downloads, caches, and version-checks model bundles.
+ */
+import { Buffer } from 'buffer';
+import { sha256 } from '@noble/hashes/sha2.js';
+async function loadFileSystem() {
+    try {
+        return await import('expo-file-system');
+    }
+    catch {
+        return null;
+    }
+}
+function bytesToSha256Hex(bytes) {
+    return Buffer.from(sha256(bytes)).toString('hex');
+}
+export class ModelManager {
+    constructor(config) {
+        this.cachedETag = null;
+        this._currentBundle = null;
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl || 'https://verify.switchlabs.dev/api/v1';
+    }
+    get currentBundle() {
+        return this._currentBundle;
+    }
+    /** Check for bundle updates from the server. */
+    async checkForUpdates(policyId, platform) {
+        try {
+            const headers = {
+                'X-API-Key': this.apiKey,
+                'Accept': 'application/json',
+            };
+            if (this.cachedETag) {
+                headers['If-None-Match'] = this.cachedETag;
+            }
+            const url = `${this.baseUrl}/models/latest?policy=${policyId}&platform=${platform}`;
+            const response = await fetch(url, { headers });
+            if (response.status === 304) {
+                return this._currentBundle;
+            }
+            if (!response.ok) {
+                return this._currentBundle;
+            }
+            this.cachedETag = response.headers.get('etag');
+            const body = (await response.json());
+            const bundles = body.bundles;
+            if (!bundles || bundles.length === 0) {
+                return null;
+            }
+            const bundleJson = bundles.find((bundle) => bundle.policy_id === policyId) || bundles[0];
+            const manifest = parseBundleManifest(bundleJson);
+            if (this._currentBundle?.bundleVersion === manifest.bundleVersion) {
+                return this._currentBundle;
+            }
+            // Download artifacts
+            await this.downloadArtifacts(manifest, policyId);
+            await this.saveBundleManifest(policyId, manifest);
+            this._currentBundle = manifest;
+            return manifest;
+        }
+        catch {
+            return this._currentBundle;
+        }
+    }
+    /** Download model artifacts and verify integrity. */
+    async downloadArtifacts(manifest, policyId) {
+        const fileSystem = await loadFileSystem();
+        if (!fileSystem || !fileSystem.documentDirectory) {
+            console.warn('[VerifyAI] expo-file-system not available, skipping download');
+            return;
+        }
+        const cacheDir = `${fileSystem.documentDirectory}verify-ai/bundles/${policyId}/`;
+        await fileSystem.makeDirectoryAsync(cacheDir, { intermediates: true }).catch(() => { });
+        for (const artifact of manifest.artifacts) {
+            if (!artifact.downloadUrl)
+                continue;
+            const ext = artifact.format === 'coreml' ? 'mlpackage.zip' : artifact.format;
+            const localPath = `${cacheDir}${artifact.format}_v${artifact.version}.${ext}`;
+            // Check if already downloaded and intact
+            const info = await fileSystem.getInfoAsync(localPath).catch(() => ({ exists: false }));
+            if (info.exists) {
+                const existingHash = await this.readFileSha256(fileSystem, localPath);
+                if (existingHash === artifact.sha256) {
+                    artifact.localPath = localPath;
+                    continue;
+                }
+                await fileSystem.deleteAsync(localPath, { idempotent: true }).catch(() => { });
+            }
+            // Download
+            try {
+                const download = await fileSystem.downloadAsync(artifact.downloadUrl, localPath);
+                if (download.status === 200) {
+                    const downloadedHash = await this.readFileSha256(fileSystem, localPath);
+                    if (downloadedHash === artifact.sha256) {
+                        artifact.localPath = localPath;
+                    }
+                    else {
+                        await fileSystem.deleteAsync(localPath, { idempotent: true }).catch(() => { });
+                    }
+                }
+                else {
+                    await fileSystem.deleteAsync(localPath, { idempotent: true }).catch(() => { });
+                }
+            }
+            catch {
+                await fileSystem.deleteAsync(localPath, { idempotent: true }).catch(() => { });
+            }
+        }
+    }
+    async readFileSha256(fileSystem, localPath) {
+        try {
+            const base64 = await fileSystem.readAsStringAsync(localPath, {
+                encoding: fileSystem.EncodingType.Base64,
+            });
+            return bytesToSha256Hex(Uint8Array.from(Buffer.from(base64, 'base64')));
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveBundleManifest(policyId, manifest) {
+        const fileSystem = await loadFileSystem();
+        if (!fileSystem || !fileSystem.documentDirectory) {
+            return;
+        }
+        const cacheDir = `${fileSystem.documentDirectory}verify-ai/bundles/${policyId}/`;
+        const manifestPath = `${cacheDir}manifest.json`;
+        await fileSystem.makeDirectoryAsync(cacheDir, { intermediates: true }).catch(() => { });
+        await fileSystem.writeAsStringAsync(manifestPath, JSON.stringify(serializeBundleManifest(manifest)));
+    }
+    /** Load a cached bundle from disk on startup. */
+    async loadCachedBundle(policyId) {
+        const fileSystem = await loadFileSystem();
+        if (!fileSystem || !fileSystem.documentDirectory) {
+            return null;
+        }
+        try {
+            const cacheDir = `${fileSystem.documentDirectory}verify-ai/bundles/${policyId}/`;
+            const manifestPath = `${cacheDir}manifest.json`;
+            const info = await fileSystem.getInfoAsync(manifestPath);
+            if (!info.exists)
+                return null;
+            const content = await fileSystem.readAsStringAsync(manifestPath);
+            const manifest = parseBundleManifest(JSON.parse(content));
+            // Verify local paths exist
+            for (const artifact of manifest.artifacts) {
+                const ext = artifact.format === 'coreml' ? 'mlpackage.zip' : artifact.format;
+                const localPath = `${cacheDir}${artifact.format}_v${artifact.version}.${ext}`;
+                const fileInfo = await fileSystem.getInfoAsync(localPath).catch(() => ({ exists: false }));
+                if (fileInfo.exists) {
+                    artifact.localPath = localPath;
+                }
+            }
+            if (manifest.artifacts.some((a) => a.localPath)) {
+                this._currentBundle = manifest;
+                return manifest;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function parseBundleManifest(json) {
+    return {
+        bundleVersion: json.bundle_version,
+        ontologyVersion: json.ontology_version,
+        schemaVersion: json.schema_version,
+        policyId: json.policy_id,
+        classIds: json.class_ids || [],
+        artifacts: (json.artifacts || []).map((artifact) => ({
+            role: artifact.role,
+            architecture: artifact.architecture,
+            version: artifact.version,
+            format: artifact.format,
+            storagePath: artifact.storage_path,
+            sizeBytes: artifact.size_bytes,
+            sha256: artifact.sha256,
+            downloadUrl: artifact.download_url,
+            localPath: undefined,
+        })),
+        policyAst: json.policy_ast,
+    };
+}
+function serializeBundleManifest(manifest) {
+    return {
+        bundle_version: manifest.bundleVersion,
+        ontology_version: manifest.ontologyVersion,
+        schema_version: manifest.schemaVersion,
+        policy_id: manifest.policyId,
+        class_ids: manifest.classIds,
+        artifacts: manifest.artifacts.map((artifact) => ({
+            role: artifact.role,
+            architecture: artifact.architecture,
+            version: artifact.version,
+            format: artifact.format,
+            storage_path: artifact.storagePath,
+            size_bytes: artifact.sizeBytes,
+            sha256: artifact.sha256,
+            download_url: artifact.downloadUrl,
+        })),
+        policy_ast: manifest.policyAst,
+    };
+}

package/lib/ml/policyEngine.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Deterministic policy engine for React Native SDK.
+ * MUST produce identical output to the server TypeScript and Dart implementations.
+ *
+ * This file shares the same logic as lib/verify-ai/ml/policy-engine.ts
+ * but is self-contained for the SDK package.
+ */
+import type { FeatureVector, PolicyAST, PolicyResult } from './types';
+/**
+ * Evaluate a PolicyAST against a FeatureVector.
+ * Pure function — no side effects.
+ * Must produce identical output to server TS and Dart implementations.
+ */
+export declare function evaluatePolicy(ast: PolicyAST, features: FeatureVector): PolicyResult;

package/lib/ml/policyEngine.js

@@ -0,0 +1,161 @@
+/**
+ * Deterministic policy engine for React Native SDK.
+ * MUST produce identical output to the server TypeScript and Dart implementations.
+ *
+ * This file shares the same logic as lib/verify-ai/ml/policy-engine.ts
+ * but is self-contained for the SDK package.
+ */
+// ─── Field Resolution ───
+function resolveField(features, field) {
+    const parts = field.split('.');
+    let current = features;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return undefined;
+        if (typeof current !== 'object')
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+// ─── Condition Evaluation ───
+function applyOperator(fieldValue, operator, value) {
+    switch (operator) {
+        case 'exists':
+            return fieldValue !== null && fieldValue !== undefined;
+        case 'not_exists':
+            return fieldValue === null || fieldValue === undefined;
+        case 'eq':
+            return fieldValue === value;
+        case 'neq':
+            return fieldValue !== value;
+        case 'gt':
+            return typeof fieldValue === 'number' && typeof value === 'number' && fieldValue > value;
+        case 'gte':
+            return typeof fieldValue === 'number' && typeof value === 'number' && fieldValue >= value;
+        case 'lt':
+            return typeof fieldValue === 'number' && typeof value === 'number' && fieldValue < value;
+        case 'lte':
+            return typeof fieldValue === 'number' && typeof value === 'number' && fieldValue <= value;
+        case 'contains':
+            if (Array.isArray(fieldValue))
+                return fieldValue.includes(value);
+            if (typeof fieldValue === 'string' && typeof value === 'string')
+                return fieldValue.includes(value);
+            return false;
+        case 'not_contains':
+            if (Array.isArray(fieldValue))
+                return !fieldValue.includes(value);
+            if (typeof fieldValue === 'string' && typeof value === 'string')
+                return !fieldValue.includes(value);
+            return true;
+        case 'in':
+            if (Array.isArray(value))
+                return value.includes(fieldValue);
+            return false;
+        case 'not_in':
+            if (Array.isArray(value))
+                return !value.includes(fieldValue);
+            return true;
+        case 'overlaps':
+            if (Array.isArray(fieldValue) && Array.isArray(value)) {
+                return fieldValue.some((v) => value.includes(v));
+            }
+            return false;
+        default:
+            return false;
+    }
+}
+function evaluateCondition(features, condition) {
+    const fieldValue = resolveField(features, condition.field);
+    return applyOperator(fieldValue, condition.operator, condition.value);
+}
+function evaluateRule(features, rule) {
+    const passed = rule.conditions.every((c) => evaluateCondition(features, c));
+    return {
+        rule_id: rule.id,
+        passed,
+        severity: rule.severity,
+        required: rule.required,
+    };
+}
+function resolveCategory(features, categories, ruleResults) {
+    const failedCritical = ruleResults.some((r) => !r.passed && r.required && r.severity === 'critical');
+    for (const cat of categories) {
+        const matches = cat.conditions.every((c) => {
+            if (c.field === '_has_critical_failure') {
+                return applyOperator(failedCritical, c.operator, c.value);
+            }
+            if (c.field === '_failed_rule_count') {
+                const failedCount = ruleResults.filter((r) => !r.passed && r.required).length;
+                return applyOperator(failedCount, c.operator, c.value);
+            }
+            if (c.field === '_warning_count') {
+                const warnCount = ruleResults.filter((r) => !r.passed && r.severity === 'warning').length;
+                return applyOperator(warnCount, c.operator, c.value);
+            }
+            return evaluateCondition(features, c);
+        });
+        if (matches) {
+            return {
+                category_id: cat.category_id,
+                category_label: cat.label,
+                is_compliant: cat.is_compliant,
+            };
+        }
+    }
+    // Fallback
+    if (failedCritical) {
+        return { category_id: 'unsafe', category_label: 'Unsafe', is_compliant: false };
+    }
+    const hasFailedRequired = ruleResults.some((r) => !r.passed && r.required);
+    if (hasFailedRequired) {
+        return { category_id: 'improvable', category_label: 'Improvable', is_compliant: false };
+    }
+    return { category_id: 'compliant', category_label: 'Compliant', is_compliant: true };
+}
+function generateFeedback(isCompliant, violationReasons, ruleResults) {
+    if (isCompliant) {
+        const warnings = ruleResults.filter((r) => !r.passed && r.severity === 'warning');
+        if (warnings.length > 0) {
+            return `Parking is compliant with ${warnings.length} minor suggestion(s).`;
+        }
+        return 'Parking meets all requirements.';
+    }
+    if (violationReasons.length === 0) {
+        return 'Unable to determine compliance.';
+    }
+    if (violationReasons.length === 1) {
+        return `Issue detected: ${violationReasons[0]}.`;
+    }
+    return `${violationReasons.length} issues detected: ${violationReasons.join(', ')}.`;
+}
+// ─── Main Evaluator ───
+/**
+ * Evaluate a PolicyAST against a FeatureVector.
+ * Pure function — no side effects.
+ * Must produce identical output to server TS and Dart implementations.
+ */
+export function evaluatePolicy(ast, features) {
+    const ruleResults = ast.rules.map((rule) => evaluateRule(features, rule));
+    const { category_id, category_label, is_compliant } = resolveCategory(features, ast.categories, ruleResults);
+    const violationReasons = [];
+    for (let i = 0; i < ast.rules.length; i++) {
+        if (!ruleResults[i].passed && ast.rules[i].required) {
+            violationReasons.push(ast.rules[i].label);
+        }
+    }
+    const totalRules = ruleResults.length;
+    const passedRules = ruleResults.filter((r) => r.passed).length;
+    const confidence = totalRules > 0 ? passedRules / totalRules : 0;
+    const feedback = generateFeedback(is_compliant, violationReasons, ruleResults);
+    return {
+        category_id,
+        category_label,
+        is_compliant,
+        confidence: Math.round(confidence * 100) / 100,
+        violation_reasons: violationReasons,
+        rule_results: ruleResults,
+        feedback,
+    };
+}

package/lib/ml/types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * On-device ML types for React Native SDK.
+ */
+export interface ModelArtifact {
+    role: 'detector' | 'segmenter' | 'classifier';
+    architecture: string;
+    version: number;
+    format: 'coreml' | 'tflite' | 'onnx';
+    storagePath: string;
+    sizeBytes: number;
+    sha256: string;
+    downloadUrl?: string;
+    localPath?: string;
+}
+export interface BundleManifest {
+    bundleVersion: number;
+    ontologyVersion: string;
+    schemaVersion: string;
+    policyId: string;
+    classIds: number[];
+    artifacts: ModelArtifact[];
+    policyAst: PolicyAST;
+}
+export interface Detection {
+    class_id: number;
+    class_name: string;
+    confidence: number;
+    bbox: [number, number, number, number];
+}
+export interface ImageQuality {
+    is_blurry: boolean;
+    is_dark: boolean;
+    has_vehicle: boolean;
+}
+export interface FeatureVector {
+    schema_version: string;
+    detections: Detection[];
+    primary_vehicle: Detection | null;
+    image_quality: ImageQuality;
+    vehicle_on_surface: string | null;
+    vehicle_near: string[];
+}
+export type ComparisonOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains' | 'not_contains' | 'exists' | 'not_exists' | 'in' | 'not_in' | 'overlaps';
+export interface Condition {
+    field: string;
+    operator: ComparisonOperator;
+    value?: unknown;
+}
+export interface Rule {
+    id: string;
+    label: string;
+    severity: 'critical' | 'warning' | 'info';
+    required: boolean;
+    conditions: Condition[];
+}
+export interface CategoryPredicate {
+    category_id: string;
+    label: string;
+    is_compliant: boolean;
+    conditions: Condition[];
+}
+export interface PolicyAST {
+    ast_version: string;
+    policy_id: string;
+    ontology_version: string;
+    schema_version: string;
+    rules: Rule[];
+    categories: CategoryPredicate[];
+}
+export interface RuleResult {
+    rule_id: string;
+    passed: boolean;
+    severity: 'critical' | 'warning' | 'info';
+    required: boolean;
+}
+export interface PolicyResult {
+    category_id: string;
+    category_label: string;
+    is_compliant: boolean;
+    confidence: number;
+    violation_reasons: string[];
+    rule_results: RuleResult[];
+    feedback: string;
+}

package/lib/ml/types.js

@@ -0,0 +1,4 @@
+/**
+ * On-device ML types for React Native SDK.
+ */
+export {};

package/lib/storage/offlineQueue.js

@@ -153,7 +153,7 @@ export class OfflineQueue {
                     continue;
                 }
                 try {
-                    const result = await this.client.verify(item.request);
+                    const result = await this.client.verify(item.request, { idempotencyKey: item.id });
                     processed++;
                     await AsyncStorage.removeItem(`${ITEM_PREFIX}${id}`);
                     onResult?.(item.id, result);

package/lib/telemetry/TelemetryContext.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { TelemetryReporter } from './TelemetryReporter';
+export declare const TelemetryContext: React.Context<TelemetryReporter | null>;
+export declare function useTelemetry(): TelemetryReporter | null;

package/lib/telemetry/TelemetryContext.js

@@ -0,0 +1,5 @@
+import { createContext, useContext } from 'react';
+export const TelemetryContext = createContext(null);
+export function useTelemetry() {
+    return useContext(TelemetryContext);
+}