feat(offline): offline scan queue and service worker background sync (#2)

backend/main.py

@@ -299,7 +299,7 @@ def _row_to_payload(row: dict) -> dict:
         "confidence": round((row.get("confidence_score") or 0) * 100, 1),
         "classification": "FRESH" if is_fresh else "SPOILED",
         "is_fresh": is_fresh,
-        "uncertain_flag": False,
+        "uncertain_flag": (row.get("confidence_score") or 1.0) < 0.70,
         "species": {
             "common_name": "Rohu Carp",
             "scientific_name": "Labeo rohita",
@@ -528,12 +528,59 @@ async def process_scan(
 async def scan_auto(
     request: Request,
     image: UploadFile = File(...),
+    freshness_label: Optional[str] = Form(None),
+    fused_score: Optional[float] = Form(None),
+    source: Optional[str] = Form(None),
+    confidence_score: Optional[float] = Form(None),
+    species_detected: Optional[str] = Form(None),
     current_user=Depends(get_current_user),
 ):
     image_bytes = await image.read()
     scan_id = str(uuid.uuid4())
     display_id = _generate_display_id()
 
+    # If edge_onnx path is used, save directly and bypass server inference
+    if source == "edge_onnx" and fused_score is not None:
+        freshness = int(fused_score * 100)
+        conf = confidence_score or 0.85
+        edge_fusion = {
+            "final_score_percent": freshness,
+            "final_grade": _to_db_grade(freshness_label or "C"),
+            "confidence_score": conf,
+            "uncertain_prediction_flag": conf < 0.70,
+            "regional_breakdown": {
+                "gill_freshness_score": fused_score,
+                "eye_freshness_score": fused_score,
+                "body_freshness_score": fused_score,
+            },
+        }
+        photo_url = await _upload_image(image_bytes, str(current_user.id), scan_id)
+        payload = _build_scan_payload(edge_fusion, scan_id, display_id, photo_url)
+        if species_detected:
+            payload["species"]["common_name"] = species_detected
+
+        try:
+            _db().table("scans").insert(
+                {
+                    "id": scan_id,
+                    "user_id": str(current_user.id),
+                    "final_grade": _to_db_grade(payload["grade"]),
+                    "confidence_score": conf,
+                    "image_type": "BODY",
+                    "freshness_index": payload["freshness_index"],
+                    "scan_display_id": display_id,
+                    "species_detected": species_detected or "Rohu Carp",
+                    "biomarker_json": payload["biomarkers"],
+                    "storage_hours": payload["recommendations"]["consume_within_hours"],
+                    "alert_flags": payload["recommendations"]["alert_flags"],
+                    "photo_urls": [photo_url] if photo_url else [],
+                }
+            ).execute()
+        except Exception as exc:
+            print(f"DB write failed (edge_onnx): {exc}")
+
+        return {"success": True, "scan": payload}
+
     # ── Demo mode: models not loaded (PyTorch not installed) ─────────────────
     if not _models_loaded:
         gill = random.randint(68, 96)

src/fusionInference.js

@@ -256,6 +256,15 @@ function extractGillScore(logitsB, temperature) {
  * @param {number[]} gillProbs   [P(Fresh_Gills), P(Nonfresh_Gills)]
  * @returns {{ fusedScore: number, label: string, confidence: string }}
  */
+function calculateConfidence(bodyProbs, eyeProbs, gillProbs) {
+  const bodyConf = Math.max(...bodyProbs);
+  const eyeSubSum = (eyeProbs[0] + eyeProbs[2]) || 1e-7;
+  const gillSubSum = (gillProbs[1] + gillProbs[3]) || 1e-7;
+  const eyeConf = Math.max(eyeProbs[0] / eyeSubSum, eyeProbs[2] / eyeSubSum);
+  const gillConf = Math.max(gillProbs[1] / gillSubSum, gillProbs[3] / gillSubSum);
+  return (0.5 * bodyConf) + (0.25 * eyeConf) + (0.25 * gillConf);
+}
+
 function processAndFuse(bodyProbs, eyeProbs, gillProbs) {
   const bodyFresh = bodyProbs[0];   // P(C1 = Fresh)
   const eyeFresh  = eyeProbs[0];    // P(Fresh_Eyes)
@@ -274,10 +283,14 @@ function processAndFuse(bodyProbs, eyeProbs, gillProbs) {
     label = 'Spoiled';
   }
 
+  const systemConfidence = calculateConfidence(bodyProbs, eyeProbs, gillProbs);
+  const isUncertain = systemConfidence < 0.70;
+
   return {
     fusedScore,
     label,
-    confidence: (fusedScore * 100).toFixed(1) + '%',
+    confidence: systemConfidence,
+    uncertain_flag: isUncertain
   };
 }
 

src/i18n/locales/bn.json

@@ -108,7 +108,12 @@
     "notFishDetected": "মাছ নয়: কোনো মাছ সনাক্ত করা হয়নি। একটি মাছের ছবি আপলোড করুন।",
     "inferenceFailed": "অনুমান ব্যর্থ।",
     "capturedAlt": "ক্যাপচার করা হয়েছে",
-    "rejectedUploadAlt": "আপলোড প্রত্যাখ্যাত করা হয়েছে"
+    "rejectedUploadAlt": "আপলোড প্রত্যাখ্যাত করা হয়েছে",
+    "syncingScans": "ব্যাকগ্রাউন্ডে অফলাইন স্ক্যান সিঙ্ক হচ্ছে...",
+    "syncSuccess": "অফলাইন স্ক্যানগুলি সফলভাবে সিঙ্ক হয়েছে!",
+    "savedOffline": "অফলাইন মোডে স্থানীয়ভাবে স্ক্যান সংরক্ষিত হয়েছে",
+    "pendingSyncScans": "অফলাইন স্ক্যান সিঙ্ক পেন্ডিং রয়েছে",
+    "syncNowButton": "এখন সিঙ্ক করুন"
   },
   "dashboard": {
     "loadingAnalysis": "বিশ্লেষণ লোড হচ্ছে...",
@@ -144,7 +149,11 @@
     "storageTemp": "সঞ্চয় তাপমাত্রা",
     "alertLabel": "সতর্কতা",
     "newScanButton": "নতুন স্ক্যান",
-    "viewHistoryButton": "ইতিহাস দেখুন"
+    "viewHistoryButton": "ইতিহাস দেখুন",
+    "uncertainWarningTitle": "এআই পূর্বাভাস অনিশ্চিত",
+    "uncertainWarningDesc": "মডেলটি ইনপুট মানের মধ্যে উচ্চ বৈচিত্র্য সনাক্ত করেছে (যেমন আলোর ছায়া বা বন্ধ কোণ)। তাজা সূচক স্বাভাবিকের চেয়ে কম নির্ভরযোগ্য হতে পারে।",
+    "suggestRescan": "→ নমুনাটি পুনরায় স্ক্যান করার পরামর্শ দিন",
+    "uncertaintyMargin": "ত্রুটি মার্জিন:"
   },
   "auth": {
     "authInitiated": "প্রমাণীকরণ শুরু করা হয়েছে",

src/i18n/locales/en.json

@@ -108,7 +108,12 @@
     "notFishDetected": "NOT A FISH: No fish detected. Please photograph a fish.",
     "inferenceFailed": "Inference failed.",
     "capturedAlt": "Captured",
-    "rejectedUploadAlt": "Rejected upload"
+    "rejectedUploadAlt": "Rejected upload",
+    "syncingScans": "Syncing offline scans in background...",
+    "syncSuccess": "Successfully synchronized offline scans!",
+    "savedOffline": "Saved scan locally (offline mode)",
+    "pendingSyncScans": "OFFLINE SCANS PENDING SYNC",
+    "syncNowButton": "SYNC NOW"
   },
   "dashboard": {
     "loadingAnalysis": "LOADING ANALYSIS...",
@@ -144,7 +149,11 @@
     "storageTemp": "STORAGE TEMP",
     "alertLabel": "ALERT",
     "newScanButton": "NEW SCAN",
-    "viewHistoryButton": "VIEW HISTORY"
+    "viewHistoryButton": "VIEW HISTORY",
+    "uncertainWarningTitle": "AI Prediction Uncertain",
+    "uncertainWarningDesc": "The model detected high variance in input quality (e.g. lighting shadows or off-angles). The freshness index might be less reliable than usual.",
+    "suggestRescan": "→ Suggest Rescanning specimen",
+    "uncertaintyMargin": "Margin of Error:"
   },
   "auth": {
     "authInitiated": "AUTH INITIATED",

src/i18n/locales/hi.json

@@ -108,7 +108,12 @@
     "notFishDetected": "मछली नहीं: कोई मछली नहीं मिली। कृपया एक मछली की तस्वीर अपलोड करें।",
     "inferenceFailed": "अनुमान विफल।",
     "capturedAlt": "कैप्चर किया गया",
-    "rejectedUploadAlt": "अपलोड अस्वीकार किया गया"
+    "rejectedUploadAlt": "अपलोड अस्वीकार किया गया",
+    "syncingScans": "पृष्ठभूमि में ऑफ़लाइन स्कैन सिंक किए जा रहे हैं...",
+    "syncSuccess": "ऑफ़लाइन स्कैन सफलतापूर्वक सिंक किए गए!",
+    "savedOffline": "ऑफ़लाइन मोड में स्थानीय रूप से स्कैन सहेजा गया",
+    "pendingSyncScans": "ऑफ़लाइन स्कैन सिंक होना बाकी है",
+    "syncNowButton": "अभी सिंक करें"
   },
   "dashboard": {
     "loadingAnalysis": "विश्लेषण लोड हो रहा है...",
@@ -144,7 +149,11 @@
     "storageTemp": "भंडारण तापमान",
     "alertLabel": "सतर्कता",
     "newScanButton": "नया स्कैन",
-    "viewHistoryButton": "इतिहास देखें"
+    "viewHistoryButton": "इतिहास देखें",
+    "uncertainWarningTitle": "एआई भविष्यवाणी अनिश्चित",
+    "uncertainWarningDesc": "मॉडल ने इनपुट गुणवत्ता में उच्च भिन्नता का पता लगाया (जैसे प्रकाश छाया या बंद कोण)। ताजगी सूचकांक सामान्य से कम विश्वसनीय हो सकता है।",
+    "suggestRescan": "→ नमूने को फिर से स्कैन करने का सुझाव दें",
+    "uncertaintyMargin": "त्रुटि मार्जिन:"
   },
   "auth": {
     "authInitiated": "प्रमाणीकरण शुरू किया गया",

src/lib/api.ts

@@ -120,12 +120,12 @@ export interface GradcamResponse {
   mode: "real" | "demo";
 }
 
-// Metadata sent alongside edge-inference results so the backend can store them
-// without re-running the ML pipeline on the server.
 export interface EdgeInferenceMeta {
   freshness_label?: string;
   fused_score?: number;
   source?: "edge_onnx" | "server";
+  confidence_score?: number;
+  species_detected?: string;
 }
 
 // ── API surface ───────────────────────────────────────────────────────────────
@@ -165,6 +165,10 @@ export const api = {
     if (meta?.fused_score !== undefined)
       form.append("fused_score", String(meta.fused_score));
     if (meta?.source) form.append("source", meta.source);
+    if (meta?.confidence_score !== undefined)
+      form.append("confidence_score", String(meta.confidence_score));
+    if (meta?.species_detected)
+      form.append("species_detected", meta.species_detected);
 
     const validRes = await safeFetch(
       `${API_BASE}/api/v1/scan-auto`,

src/lib/offlineDb.ts

@@ -0,0 +1,106 @@
+// Simple offline IndexedDB manager for FreshScan AI scans queue
+// Zero external dependencies to prevent compilation or bundle size overhead
+
+const DB_NAME = 'freshscan_offline_db';
+const DB_VERSION = 1;
+const STORE_NAME = 'scans_queue';
+
+export interface OfflineScan {
+  id: string;
+  image: Blob;
+  metadata: {
+    freshness_index: number;
+    grade: string;
+    label: string;
+    confidence: number;
+    timestamp: string;
+    species_detected: string;
+  };
+  status: 'pending' | 'synced' | 'failed';
+  error?: string;
+}
+
+function openDB(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+
+    request.onupgradeneeded = (event) => {
+      const db = (event.target as IDBOpenDBRequest).result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: 'id' });
+      }
+    };
+
+    request.onsuccess = (event) => {
+      resolve((event.target as IDBOpenDBRequest).result);
+    };
+
+    request.onerror = (event) => {
+      reject((event.target as IDBOpenDBRequest).error);
+    };
+  });
+}
+
+export const offlineDb = {
+  async addScan(scan: OfflineScan): Promise<void> {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(STORE_NAME, 'readwrite');
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.put(scan);
+
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  },
+
+  async getPendingScans(): Promise<OfflineScan[]> {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(STORE_NAME, 'readonly');
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.getAll();
+
+      request.onsuccess = () => {
+        const scans = request.result as OfflineScan[];
+        resolve(scans.filter(s => s.status === 'pending' || s.status === 'failed'));
+      };
+      request.onerror = () => reject(request.error);
+    });
+  },
+
+  async updateScanStatus(id: string, status: OfflineScan['status'], error?: string): Promise<void> {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(STORE_NAME, 'readwrite');
+      const store = transaction.objectStore(STORE_NAME);
+
+      const getReq = store.get(id);
+      getReq.onsuccess = () => {
+        const data = getReq.result as OfflineScan;
+        if (data) {
+          data.status = status;
+          if (error) data.error = error;
+          const updateReq = store.put(data);
+          updateReq.onsuccess = () => resolve();
+          updateReq.onerror = () => reject(updateReq.error);
+        } else {
+          resolve();
+        }
+      };
+      getReq.onerror = () => reject(getReq.error);
+    });
+  },
+
+  async deleteScan(id: string): Promise<void> {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(STORE_NAME, 'readwrite');
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.delete(id);
+
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+};