@souscheflabs/ml-vision 0.1.0

package/dist/hooks/useProductDetector.js

@@ -0,0 +1,679 @@
+"use strict";
+/**
+ * useProductDetector Hook
+ *
+ * React hook for visual product detection using TFLite models.
+ * Detects products in photos or camera frames using YOLOv8.
+ *
+ * @example
+ * ```typescript
+ * import { useProductDetector } from '@souschef/ml-vision';
+ *
+ * function FridgeScanner() {
+ *   const {
+ *     isModelLoaded,
+ *     isDetecting,
+ *     detections,
+ *     detectProducts,
+ *   } = useProductDetector({
+ *     minConfidence: 0.5,
+ *     onDetected: (products) => console.log('Found:', products),
+ *   });
+ *
+ *   const handleCapture = async (photoUri: string) => {
+ *     const results = await detectProducts(photoUri);
+ *     // results contain detected products with bounding boxes
+ *   };
+ *
+ *   return (
+ *     // Your camera UI
+ *   );
+ * }
+ * ```
+ */
+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.useProductDetector = useProductDetector;
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const MLVisionProvider_1 = require("../core/MLVisionProvider");
+const classLabels_1 = require("./classLabels");
+const classLabelsCoco_1 = require("./classLabelsCoco");
+const imagePreprocessor_1 = require("../utils/imagePreprocessor");
+const yoloProcessor_1 = require("../utils/yoloProcessor");
+// ============================================================================
+// TFLite Model Loading
+// ============================================================================
+// Dynamic import of react-native-fast-tflite to handle cases where it's not installed
+let TFLite = null;
+let loadedModel = null;
+async function loadTFLiteModule() {
+    if (TFLite)
+        return TFLite;
+    try {
+        TFLite = await Promise.resolve().then(() => __importStar(require('react-native-fast-tflite')));
+        return TFLite;
+    }
+    catch (error) {
+        console.error('[useProductDetector] Failed to load react-native-fast-tflite:', error);
+        return null;
+    }
+}
+// ============================================================================
+// Constants
+// ============================================================================
+/** Model input size (must match training config) */
+const MODEL_INPUT_SIZE = 640;
+/**
+ * Model asset - loaded via Metro bundler
+ * The require() returns an asset ID that react-native-fast-tflite can resolve
+ *
+ * Using SousChef fine-tuned model (233 food classes)
+ */
+const MODEL_ASSET = require('../../models/souschef_v1_int8.tflite');
+/** Whether we're using the COCO model (80 classes) or custom food model (233 classes) */
+const USE_COCO_MODEL = false;
+/** Get the appropriate number of classes based on model */
+const getNumClasses = () => USE_COCO_MODEL ? classLabelsCoco_1.NUM_CLASSES_COCO : classLabels_1.NUM_CLASSES;
+/** Model version identifier */
+const MODEL_VERSION = '1.0.0';
+/**
+ * Simple hash function for image URIs
+ * For a real implementation, use a perceptual hash or file content hash
+ */
+function simpleHash(str) {
+    let hash = 5381;
+    for (let i = 0; i < str.length; i++) {
+        hash = (hash * 33 + str.charCodeAt(i)) % 2147483647;
+    }
+    return `img_${Math.abs(hash).toString(36)}`;
+}
+/**
+ * Process YOLOv8 output tensor to get detections
+ *
+ * YOLOv8 output format: [1, 34, 8400] where:
+ * - 34 = 4 (bbox) + 30 (class scores)
+ * - 8400 = number of anchor boxes (80x80 + 40x40 + 20x20)
+ *
+ * @deprecated Use processYoloOutput from utils/yoloProcessor instead
+ */
+function _processYoloOutput(output, numClasses = classLabels_1.NUM_CLASSES, confThreshold = 0.25, iouThreshold = 0.45) {
+    const numAnchors = 8400;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const numOutputs = 4 + numClasses; // x, y, w, h + class scores
+    const detections = [];
+    // Process each anchor
+    for (let i = 0; i < numAnchors; i++) {
+        // Extract bbox: [x_center, y_center, width, height] (normalized 0-1)
+        const x = output[0 * numAnchors + i];
+        const y = output[1 * numAnchors + i];
+        const w = output[2 * numAnchors + i];
+        const h = output[3 * numAnchors + i];
+        // Find max class score and index
+        let maxScore = 0;
+        let maxClassIndex = 0;
+        for (let c = 0; c < numClasses; c++) {
+            const score = output[(4 + c) * numAnchors + i];
+            if (score > maxScore) {
+                maxScore = score;
+                maxClassIndex = c;
+            }
+        }
+        // Filter by confidence
+        if (maxScore >= confThreshold) {
+            detections.push({
+                x: x - w / 2, // Convert from center to top-left
+                y: y - h / 2,
+                width: w,
+                height: h,
+                classIndex: maxClassIndex,
+                confidence: maxScore,
+            });
+        }
+    }
+    // Apply Non-Maximum Suppression (NMS)
+    return applyNMS(detections, iouThreshold);
+}
+/**
+ * Non-Maximum Suppression to remove overlapping detections
+ */
+function applyNMS(detections, iouThreshold) {
+    if (detections.length === 0)
+        return [];
+    // Sort by confidence (descending)
+    const sorted = [...detections].sort((a, b) => b.confidence - a.confidence);
+    const kept = [];
+    while (sorted.length > 0) {
+        const best = sorted.shift();
+        kept.push(best);
+        // Remove overlapping detections of same class
+        for (let i = sorted.length - 1; i >= 0; i--) {
+            if (sorted[i].classIndex === best.classIndex) {
+                const iou = calculateIoU(best, sorted[i]);
+                if (iou > iouThreshold) {
+                    sorted.splice(i, 1);
+                }
+            }
+        }
+    }
+    return kept;
+}
+/**
+ * Calculate Intersection over Union (IoU) between two boxes
+ */
+function calculateIoU(box1, box2) {
+    const x1 = Math.max(box1.x, box2.x);
+    const y1 = Math.max(box1.y, box2.y);
+    const x2 = Math.min(box1.x + box1.width, box2.x + box2.width);
+    const y2 = Math.min(box1.y + box1.height, box2.y + box2.height);
+    const intersection = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
+    const area1 = box1.width * box1.height;
+    const area2 = box2.width * box2.height;
+    const union = area1 + area2 - intersection;
+    return union > 0 ? intersection / union : 0;
+}
+// ============================================================================
+// Hook Implementation
+// ============================================================================
+/**
+ * Hook for visual product detection using TFLite
+ */
+function useProductDetector(options = {}) {
+    const { model: modelType = 'fast', maxDetections = 20, minConfidence = 0.5, categories, serverFallback = true, serverFallbackThreshold = 0.4, serverUrl, onDetected, onError, hapticFeedback = true, } = options;
+    // Context
+    const context = (0, MLVisionProvider_1.useMLVisionContext)();
+    const { serverClient, serverAvailable, config, cacheManager } = context;
+    // State
+    const [isModelLoaded, setIsModelLoaded] = (0, react_1.useState)(false);
+    const [isDetecting, setIsDetecting] = (0, react_1.useState)(false);
+    const [detections, setDetections] = (0, react_1.useState)([]);
+    const [error, setError] = (0, react_1.useState)(null);
+    // Refs
+    const modelRef = (0, react_1.useRef)(null);
+    const mountedRef = (0, react_1.useRef)(true);
+    // Computed server URL
+    const effectiveServerUrl = serverUrl || config.serverUrl;
+    // ============================================================================
+    // Model Loading
+    // ============================================================================
+    (0, react_1.useEffect)(() => {
+        mountedRef.current = true;
+        async function loadModel() {
+            if (modelType !== 'fast') {
+                // Server-only mode
+                setIsModelLoaded(true);
+                return;
+            }
+            try {
+                console.log('[useProductDetector] Step 1: Loading TFLite module...');
+                const tflite = await loadTFLiteModule();
+                if (!tflite) {
+                    throw new Error('react-native-fast-tflite is not available');
+                }
+                console.log('[useProductDetector] Step 2: TFLite module loaded');
+                // Check if model is already loaded
+                if (loadedModel) {
+                    console.log('[useProductDetector] Model already loaded, reusing...');
+                    modelRef.current = loadedModel;
+                    if (mountedRef.current) {
+                        setIsModelLoaded(true);
+                    }
+                    return;
+                }
+                // Load the model from assets folder
+                console.log('[useProductDetector] Step 3: Loading TFLite model...');
+                console.log('[useProductDetector] MODEL_ASSET value:', MODEL_ASSET);
+                console.log('[useProductDetector] MODEL_ASSET type:', typeof MODEL_ASSET);
+                // CoreML is iOS-only, use default CPU delegate on Android for stability
+                const delegate = config.enableGPUDelegate && react_native_1.Platform.OS === 'ios'
+                    ? 'core-ml'
+                    : 'default';
+                console.log('[useProductDetector] Step 4: Using delegate:', delegate);
+                // Load model via require() which Metro resolves to an asset ID
+                console.log('[useProductDetector] Step 5: Calling loadTensorflowModel...');
+                let model;
+                try {
+                    // Try loading with the bundled asset first
+                    model = await tflite.loadTensorflowModel(MODEL_ASSET, delegate);
+                }
+                catch (loadErr) {
+                    console.error('[useProductDetector] Primary load failed:', loadErr.message);
+                    // Fallback: try file:// URL for Android assets
+                    if (react_native_1.Platform.OS === 'android') {
+                        console.log('[useProductDetector] Trying fallback: file:///android_asset/...');
+                        try {
+                            model = await tflite.loadTensorflowModel({ url: 'file:///android_asset/souschef_v1_int8.tflite' }, delegate);
+                            console.log('[useProductDetector] Fallback succeeded!');
+                        }
+                        catch (fallbackErr) {
+                            console.error('[useProductDetector] Fallback also failed:', fallbackErr.message);
+                            throw loadErr; // Throw original error
+                        }
+                    }
+                    else {
+                        throw loadErr;
+                    }
+                }
+                console.log('[useProductDetector] Step 6: Model loaded successfully');
+                console.log('[useProductDetector] Model inputs:', JSON.stringify(model.inputs));
+                console.log('[useProductDetector] Model outputs:', JSON.stringify(model.outputs));
+                loadedModel = model;
+                modelRef.current = model;
+                if (mountedRef.current) {
+                    setIsModelLoaded(true);
+                    console.log('[useProductDetector] Model loaded successfully');
+                }
+            }
+            catch (err) {
+                const loadError = err instanceof Error ? err : new Error('Failed to load model');
+                console.error('[useProductDetector] Model loading error:', loadError);
+                if (mountedRef.current) {
+                    setError(loadError);
+                    onError?.(loadError);
+                }
+            }
+        }
+        loadModel();
+        return () => {
+            mountedRef.current = false;
+        };
+    }, [modelType, config.enableGPUDelegate, onError]);
+    // ============================================================================
+    // Detection Functions
+    // ============================================================================
+    /**
+     * Detect products in a photo
+     */
+    const detectProducts = (0, react_1.useCallback)(async (uri) => {
+        if (isDetecting) {
+            console.warn('[useProductDetector] Detection already in progress');
+            return [];
+        }
+        setIsDetecting(true);
+        setError(null);
+        try {
+            let results = [];
+            const imageHash = simpleHash(uri);
+            // Check cache first
+            if (cacheManager) {
+                const cached = cacheManager.getProductRecognition(imageHash);
+                if (cached && cached.modelVersion === MODEL_VERSION) {
+                    console.log('[useProductDetector] Using cached results');
+                    // Convert cached data to ProductDetectionResult format
+                    results = cached.detections.map((det, idx) => ({
+                        id: `cached_${imageHash}_${idx}`,
+                        type: 'product',
+                        confidence: det.confidence,
+                        boundingBox: det.boundingBox,
+                        data: {
+                            category: (0, classLabels_1.getClassInfo)(parseInt(Object.entries(classLabels_1.CLASS_LABELS).find(([, v]) => v.label === det.classLabel)?.[0] ?? '0', 10)).category,
+                            classLabel: det.classLabel,
+                            classIndex: parseInt(Object.entries(classLabels_1.CLASS_LABELS).find(([, v]) => v.label === det.classLabel)?.[0] ?? '0', 10),
+                            name: det.classLabel.replace(/_/g, ' '),
+                        },
+                        source: 'on_device',
+                        processingTimeMs: 0, // Cached, no processing time
+                        timestamp: Date.now(),
+                    }));
+                    if (mountedRef.current) {
+                        setDetections(results);
+                        setIsDetecting(false);
+                    }
+                    onDetected?.(results);
+                    return results;
+                }
+            }
+            // Get image dimensions
+            const imageSize = await new Promise((resolve, reject) => {
+                react_native_1.Image.getSize(uri, (width, height) => resolve({ width, height }), reject);
+            });
+            // Try on-device detection first
+            if (modelType === 'fast' && modelRef.current) {
+                try {
+                    results = await runOnDeviceDetection(uri, imageSize.width, imageSize.height);
+                }
+                catch {
+                    // On-device detection failed (e.g., preprocessing not implemented)
+                    // This is expected for photo-based detection - silently fall back to server
+                    console.log('[useProductDetector] On-device detection unavailable, will use server');
+                }
+            }
+            // Server fallback for:
+            // - Server-only mode (modelType === 'accurate')
+            // - On-device detection failed or returned no results
+            // - Low confidence results
+            const shouldFallback = modelType === 'accurate' ||
+                (serverFallback &&
+                    effectiveServerUrl &&
+                    serverAvailable &&
+                    (results.length === 0 ||
+                        results.every((r) => r.confidence < serverFallbackThreshold)));
+            if (shouldFallback && serverClient) {
+                console.log('[useProductDetector] Using server detection');
+                try {
+                    const serverResults = await runServerDetection(uri);
+                    // Merge results, preferring server for duplicates
+                    results = mergeDetections(results, serverResults);
+                }
+                catch (serverErr) {
+                    console.error('[useProductDetector] Server detection failed:', serverErr);
+                    // If server fails too, we have no results - throw the error
+                    if (results.length === 0) {
+                        throw new Error('Detection failed: Server unavailable and on-device preprocessing not implemented');
+                    }
+                }
+            }
+            // Filter by confidence and categories
+            results = results
+                .filter((r) => r.confidence >= minConfidence)
+                .filter((r) => !categories || categories.includes(r.data.category))
+                .slice(0, maxDetections);
+            // Update state
+            if (mountedRef.current) {
+                setDetections(results);
+            }
+            // Cache results
+            if (cacheManager && results.length > 0) {
+                const cacheData = {
+                    imageHash,
+                    detections: results.map((r) => ({
+                        classLabel: r.data.classLabel,
+                        confidence: r.confidence,
+                        boundingBox: r.boundingBox,
+                    })),
+                    modelVersion: MODEL_VERSION,
+                };
+                cacheManager.setProductRecognition(imageHash, cacheData);
+            }
+            // Callbacks
+            if (results.length > 0) {
+                onDetected?.(results);
+                if (hapticFeedback) {
+                    // Trigger haptic feedback (implement based on your haptic service)
+                    // HapticService.success();
+                }
+            }
+            return results;
+        }
+        catch (err) {
+            const detectError = err instanceof Error ? err : new Error('Detection failed');
+            console.error('[useProductDetector] Detection error:', detectError);
+            if (mountedRef.current) {
+                setError(detectError);
+            }
+            onError?.(detectError);
+            return [];
+        }
+        finally {
+            if (mountedRef.current) {
+                setIsDetecting(false);
+            }
+        }
+    }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+        isDetecting,
+        modelType,
+        serverFallback,
+        serverFallbackThreshold,
+        effectiveServerUrl,
+        serverAvailable,
+        serverClient,
+        cacheManager,
+        minConfidence,
+        categories,
+        maxDetections,
+        onDetected,
+        onError,
+        hapticFeedback,
+        // Note: runOnDeviceDetection and runServerDetection are intentionally excluded
+        // They are stable helper functions defined within this hook
+    ]);
+    /**
+     * Run detection on device using TFLite
+     *
+     * Requires @shopify/react-native-skia for image preprocessing.
+     * Install with: npm install @shopify/react-native-skia
+     *
+     * For real-time detection (VisionCamera frame processor), use the
+     * vision-camera-resize-plugin which provides direct pixel access.
+     */
+    async function runOnDeviceDetection(uri, imageWidth, imageHeight) {
+        const model = modelRef.current;
+        if (!model) {
+            throw new Error('Model not loaded');
+        }
+        const startTime = Date.now();
+        // Try to initialize Skia for preprocessing
+        await (0, imagePreprocessor_1.initSkia)();
+        if (!(0, imagePreprocessor_1.isSkiaAvailable)()) {
+            console.log('[useProductDetector] On-device detection requires @shopify/react-native-skia');
+            console.log('[useProductDetector] Install with: npm install @shopify/react-native-skia');
+            console.log('[useProductDetector] Falling back to server detection...');
+            throw new Error('On-device photo detection requires @shopify/react-native-skia. ' +
+                'Install it or use server fallback.');
+        }
+        console.log('[useProductDetector] Running on-device detection...');
+        console.log('[useProductDetector] Image:', imageWidth, 'x', imageHeight);
+        try {
+            // Preprocess image: resize to 640x640 and normalize to [0, 1]
+            const preprocessed = await (0, imagePreprocessor_1.preprocessImage)(uri, {
+                width: MODEL_INPUT_SIZE,
+                height: MODEL_INPUT_SIZE,
+                normalize: true,
+                letterbox: true,
+            });
+            console.log('[useProductDetector] Preprocessed image, running inference...');
+            // Run TFLite inference
+            const output = await model.run([preprocessed.data]);
+            const rawOutput = output[0];
+            const inferenceTime = Date.now() - startTime;
+            console.log('[useProductDetector] Inference complete:', inferenceTime, 'ms');
+            // Process YOLO output
+            const numClasses = getNumClasses();
+            const rawDetections = (0, yoloProcessor_1.processYoloOutput)(rawOutput, numClasses, 0.25, 0.45);
+            // Scale detections back to original image coordinates
+            const scaledDetections = (0, yoloProcessor_1.scaleDetections)(rawDetections, MODEL_INPUT_SIZE, imageWidth, imageHeight);
+            console.log('[useProductDetector] Found', scaledDetections.length, 'detections');
+            // Convert to ProductDetectionResult format
+            const processingTimeMs = Date.now() - startTime;
+            return scaledDetections.map((det) => toProductDetectionResult(det, imageWidth, imageHeight, processingTimeMs));
+        }
+        catch (preprocessError) {
+            console.error('[useProductDetector] On-device detection failed:', preprocessError);
+            throw preprocessError;
+        }
+    }
+    /**
+     * Convert raw detection to ProductDetectionResult
+     */
+    function toProductDetectionResult(det, imageWidth, imageHeight, processingTimeMs) {
+        // Get class info based on model type
+        const classInfo = USE_COCO_MODEL
+            ? (0, classLabelsCoco_1.getCocoClassInfo)(det.classIndex)
+            : (0, classLabels_1.getClassInfo)(det.classIndex);
+        return {
+            id: `det_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            type: 'product',
+            confidence: det.confidence,
+            boundingBox: {
+                x: det.x,
+                y: det.y,
+                width: det.width,
+                height: det.height,
+            },
+            data: {
+                category: classInfo.category,
+                classLabel: classInfo.label,
+                classIndex: det.classIndex,
+                name: classInfo.label.replace(/_/g, ' '),
+            },
+            source: 'on_device',
+            processingTimeMs,
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Run detection on server
+     */
+    async function runServerDetection(uri) {
+        console.log('[useProductDetector] runServerDetection called');
+        console.log('[useProductDetector] Server client available:', !!serverClient);
+        console.log('[useProductDetector] Server URL:', effectiveServerUrl);
+        console.log('[useProductDetector] Image URI:', uri);
+        if (!serverClient) {
+            console.error('[useProductDetector] Server client not available!');
+            throw new Error('Server client not available');
+        }
+        // Convert URI to ImageUploadData format
+        const imageData = {
+            image: uri,
+            isBase64: false,
+        };
+        console.log('[useProductDetector] Calling serverClient.detectProducts...');
+        try {
+            const results = await serverClient.detectProducts(imageData, {
+                maxDetections,
+                minConfidence: minConfidence * 0.8, // Slightly lower threshold for server
+            });
+            console.log('[useProductDetector] Server returned', results?.length || 0, 'detections');
+            console.log('[useProductDetector] Server results:', JSON.stringify(results));
+            // Server already returns ProductDetectionResult[] with all required fields
+            return results;
+        }
+        catch (serverErr) {
+            console.error('[useProductDetector] Server request failed:', serverErr);
+            throw serverErr;
+        }
+    }
+    /**
+     * Merge on-device and server detections
+     */
+    function mergeDetections(onDevice, server) {
+        // Simple merge: include all server detections, add on-device only if no overlap
+        const merged = [...server];
+        for (const det of onDevice) {
+            const overlaps = server.some((s) => s.data.classLabel === det.data.classLabel &&
+                calculateIoU({
+                    x: det.boundingBox.x,
+                    y: det.boundingBox.y,
+                    width: det.boundingBox.width,
+                    height: det.boundingBox.height,
+                    classIndex: det.data.classIndex,
+                    confidence: det.confidence,
+                }, {
+                    x: s.boundingBox.x,
+                    y: s.boundingBox.y,
+                    width: s.boundingBox.width,
+                    height: s.boundingBox.height,
+                    classIndex: s.data.classIndex,
+                    confidence: s.confidence,
+                }) > 0.5);
+            if (!overlaps) {
+                merged.push(det);
+            }
+        }
+        return merged;
+    }
+    /**
+     * Detect products in current camera frame (placeholder)
+     */
+    const detectInFrame = (0, react_1.useCallback)(async () => {
+        // This would be called from a frame processor
+        // For now, return current detections
+        return detections;
+    }, [detections]);
+    /**
+     * Update model (check for new version)
+     */
+    const updateModel = (0, react_1.useCallback)(async () => {
+        // TODO: Implement model update checking
+        console.log('[useProductDetector] Model update check not implemented');
+    }, []);
+    /**
+     * Clear all detections
+     */
+    const clearDetections = (0, react_1.useCallback)(() => {
+        setDetections([]);
+        setError(null);
+    }, []);
+    // ============================================================================
+    // Frame Processor (placeholder)
+    // ============================================================================
+    // Frame processor for real-time detection would be implemented here
+    // This requires worklet functions from react-native-vision-camera
+    const frameProcessor = (0, react_1.useMemo)(() => {
+        // Placeholder - actual implementation needs VisionCamera worklets
+        return null;
+    }, []);
+    // ============================================================================
+    // Model Info
+    // ============================================================================
+    const modelInfo = (0, react_1.useMemo)(() => {
+        if (!isModelLoaded)
+            return null;
+        return {
+            name: 'souschef_v1_int8',
+            version: MODEL_VERSION,
+            sizeBytes: 3737994, // ~3.6 MB (233 food classes)
+            lastUpdated: new Date('2026-01-16'),
+            type: 'detection',
+            isLoaded: isModelLoaded,
+        };
+    }, [isModelLoaded]);
+    // ============================================================================
+    // Return Value
+    // ============================================================================
+    return {
+        // State
+        isModelLoaded,
+        isDetecting,
+        detections,
+        error,
+        modelVersion: MODEL_VERSION,
+        // Model (for frame processor use)
+        model: modelRef.current,
+        // Actions
+        detectProducts,
+        detectInFrame,
+        updateModel,
+        clearDetections,
+        // Frame processor
+        frameProcessor,
+        // Model info
+        modelInfo,
+    };
+}
+exports.default = useProductDetector;