@mentra/engine 3.2.0-dev.195 → 3.2.0-dev.206

package/src/services/asg/gallerySyncService.ts

@@ -34,6 +34,83 @@ import {emitGalleryNotice} from "./galleryNotices"
 import {galleryTransferLedger} from "./galleryTransferLedger"
 import {cameraRollExportCoordinator} from "./cameraRollExportCoordinator"
 
+export type IosHotspotSsidVerification = {
+  status: "matched" | "mismatched" | "unavailable"
+  lastSeenSsid: string
+  /**
+   * Only true when reads hit a Location PERMISSION wall. `unavailable` alone is a weaker
+   * claim — it also covers "every read failed transiently" and "every read came back
+   * empty", which can happen with Location fully granted. Callers must not blame Location
+   * (or disable later SSID gates) on the strength of `status` alone.
+   */
+  permissionBlocked: boolean
+}
+
+/**
+ * react-native-wifi-reborn rejects SSID reads with a stable `code` from its CONNECT_ERRORS
+ * enum. Three DIFFERENT prose messages map to the same "this install will never be allowed
+ * to read the SSID" wall — "Cannot detect SSID because LocationPermission is Denied",
+ * "...is Restricted", and the bare "Permission not granted" from the not-determined path —
+ * so match the code, never the text.
+ */
+const SSID_PERMISSION_ERROR_CODES = new Set([
+  "locationPermissionDenied",
+  "locationPermissionRestricted",
+  "locationPermissionMissing",
+])
+
+export function isSsidPermissionError(error: unknown): boolean {
+  const code = (error as {code?: unknown} | null | undefined)?.code
+  // A bridged `code` is authoritative: `couldNotDetectSSID` is a transient read failure,
+  // NOT a permission wall, and must keep polling.
+  if (typeof code === "string") return SSID_PERMISSION_ERROR_CODES.has(code)
+
+  // Fallback for errors that reach us with only a message (older bridges, test doubles).
+  const message = error instanceof Error ? error.message : String(error)
+  return /location\s*permission/i.test(message) || /permission not granted/i.test(message)
+}
+
+export async function verifyIosHotspotSsid(
+  targetSsid: string,
+  readCurrentSsid: (attempt: number) => Promise<string>,
+  sleep: () => Promise<void>,
+  maxAttempts = 30,
+): Promise<IosHotspotSsidVerification> {
+  let lastSeenSsid = "unknown"
+  let observedSsid = false
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      const currentSsid = await readCurrentSsid(attempt + 1)
+      // Only a NON-EMPTY read proves we can see the network. An empty SSID is an
+      // "unknown", not a mismatch — reporting it as a mismatch would hard-fail the sync
+      // for the same reason this fallback exists.
+      if (currentSsid) {
+        observedSsid = true
+        lastSeenSsid = currentSsid
+      } else {
+        lastSeenSsid = "null"
+      }
+
+      if (currentSsid && currentSsid === targetSsid) {
+        return {status: "matched", lastSeenSsid, permissionBlocked: false}
+      }
+    } catch (error) {
+      lastSeenSsid = "error"
+      if (isSsidPermissionError(error)) {
+        return {status: "unavailable", lastSeenSsid, permissionBlocked: true}
+      }
+    }
+
+    if (attempt < maxAttempts - 1) await sleep()
+  }
+
+  // Falling out of the loop without a single legible SSID is "we never saw the network",
+  // NOT "we are not allowed to look" — transient read failures and empty reads land here
+  // with Location granted, so permissionBlocked stays false.
+  return {status: observedSsid ? "mismatched" : "unavailable", lastSeenSsid, permissionBlocked: false}
+}
+
 // Timing constants
 const TIMING = {
   HOTSPOT_CONNECT_DELAY_MS: 3000, // Increased from 1000ms - hotspot needs time to broadcast and become discoverable
@@ -79,6 +156,11 @@ class GallerySyncService {
   private wifiSettingsOpenedAt: number | null = null // Timestamp when user was sent to WiFi settings
   private syncStartPromise: Promise<void> | null = null
   private startAborted = false
+  // Authoritative answer to "can this run read the phone's WiFi SSID?", captured from the
+  // Location permission gate in pre-flight. Every SSID comparison below is advisory only:
+  // when this is false we skip the read entirely and lean on the glasses connectivity
+  // probe instead of failing the sync. Assume readable until pre-flight says otherwise.
+  private ssidReadable = true
 
   private constructor() {}
 
@@ -160,6 +242,7 @@ class GallerySyncService {
     this.waitingForWifiRetry = false
     this.wifiSettingsOpenedAt = null
     this.startAborted = false
+    this.ssidReadable = true
     this.isInitialized = false
     console.log("[GallerySyncService] Cleaned up")
   }
@@ -522,19 +605,23 @@ class GallerySyncService {
     }
     console.log("[GallerySyncService]   ✅ Notification permission handled")
 
-    // 2. Location permission (required to read WiFi SSID for hotspot verification)
+    // 2. Location permission (required to read WiFi SSID for hotspot verification).
+    // Sync does NOT block on this: record the answer once, here, and let every downstream
+    // SSID check consult `this.ssidReadable` instead of re-deriving it from a native error.
     console.log("[GallerySyncService]   📍 Checking location permission...")
     const hasLocationPermission = await permissions.check(PermissionFeatures.LOCATION)
     if (!hasLocationPermission) {
       console.log("[GallerySyncService]   ⚠️ Location permission not granted - requesting...")
       const granted = await permissions.request(PermissionFeatures.LOCATION)
+      this.ssidReadable = granted
       if (!granted) {
-        console.warn("[GallerySyncService]   ❌ Location permission denied - WiFi SSID verification may fail")
-        // Don't block sync - we'll try anyway and fall back to IP-based verification if needed
+        console.warn("[GallerySyncService]   ❌ Location permission denied - skipping all SSID verification")
+        console.warn("[GallerySyncService]   ➡️ Falling back to the glasses connectivity probe")
       } else {
         console.log("[GallerySyncService]   ✅ Location permission granted")
       }
     } else {
+      this.ssidReadable = true
       console.log("[GallerySyncService]   ✅ Location permission already granted")
     }
     if (this.shouldAbortPreFlight()) {
@@ -739,34 +826,51 @@ class GallerySyncService {
         : null
 
     let isAlreadyConnected = false
+    // Distinct from `!isAlreadyConnected`: we could not READ the SSID, so we know nothing
+    // about which network the phone is on. Re-requesting the hotspot in that state costs a
+    // pointless BLE round-trip on every sync, so route straight to the connect path instead.
+    let hotspotMembershipUnknown = false
     if (currentGlassesHotspot) {
       console.log("[GallerySyncService]   📊 Glasses hotspot status:")
       console.log("[GallerySyncService]      - Enabled: true")
       console.log(`[GallerySyncService]      - SSID: ${currentGlassesHotspot.ssid}`)
       console.log(`[GallerySyncService]      - IP: ${currentGlassesHotspot.ip}`)
 
-      try {
-        const currentSSID = await WifiManager.getCurrentWifiSSID()
-        if (this.shouldAbortPreFlight()) {
-          console.log("[GallerySyncService] Pre-flight aborted after SSID check")
-          return
-        }
-        console.log(`[GallerySyncService]   📱 Phone current WiFi SSID: "${currentSSID}"`)
-        console.log(`[GallerySyncService]   🔍 Comparing with glasses hotspot SSID: "${currentGlassesHotspot.ssid}"`)
-
-        isAlreadyConnected = currentSSID === currentGlassesHotspot.ssid
-        if (isAlreadyConnected) {
-          console.log("[GallerySyncService]   ✅ Phone is already connected to glasses hotspot!")
-        } else if (currentSSID) {
-          console.log(`[GallerySyncService]   ⚠️ Phone is on different network (${currentSSID})`)
-          console.log("[GallerySyncService]   ➡️ Will request hotspot connection")
-        } else {
-          console.log("[GallerySyncService]   ⚠️ Phone not connected to any WiFi network")
+      if (!this.ssidReadable) {
+        console.log("[GallerySyncService]   ⚠️ SSID unreadable (Location denied) - cannot tell if already joined")
+        console.log("[GallerySyncService]   ➡️ Will attempt the glasses WiFi connection directly")
+        hotspotMembershipUnknown = true
+      } else {
+        try {
+          const currentSSID = await WifiManager.getCurrentWifiSSID()
+          if (this.shouldAbortPreFlight()) {
+            console.log("[GallerySyncService] Pre-flight aborted after SSID check")
+            return
+          }
+          console.log(`[GallerySyncService]   📱 Phone current WiFi SSID: "${currentSSID}"`)
+          console.log(`[GallerySyncService]   🔍 Comparing with glasses hotspot SSID: "${currentGlassesHotspot.ssid}"`)
+
+          isAlreadyConnected = currentSSID === currentGlassesHotspot.ssid
+          if (isAlreadyConnected) {
+            console.log("[GallerySyncService]   ✅ Phone is already connected to glasses hotspot!")
+          } else if (currentSSID) {
+            console.log(`[GallerySyncService]   ⚠️ Phone is on different network (${currentSSID})`)
+            console.log("[GallerySyncService]   ➡️ Will request hotspot connection")
+          } else {
+            console.log("[GallerySyncService]   ⚠️ Phone not connected to any WiFi network")
+          }
+        } catch (error) {
+          console.warn("[GallerySyncService]   ⚠️ Could not verify current WiFi SSID:", error)
+          isAlreadyConnected = false
+          // Permission was granted at pre-flight but the read still hit a wall (revoked
+          // between the two, or a platform we mis-predicted). Latch it so the rest of this
+          // sync stops paying for reads that cannot succeed, and treat membership as
+          // unknown rather than "definitely not joined".
+          if (isSsidPermissionError(error)) {
+            this.ssidReadable = false
+            hotspotMembershipUnknown = true
+          }
         }
-      } catch (error) {
-        console.warn("[GallerySyncService]   ⚠️ Could not verify current WiFi SSID:", error)
-        // If we can't verify, don't assume we're connected - request hotspot
-        isAlreadyConnected = false
       }
     } else {
       console.log("[GallerySyncService]   ℹ️ Glasses hotspot not currently enabled")
@@ -777,6 +881,18 @@ class GallerySyncService {
     // in-memory queue; startFileDownload immediately recovers its durable ledger work.
     mediaProcessingQueue.reset()
 
+    // SSID unreadable + hotspot already up: connectToHotspotWifi handles BOTH "already
+    // joined" (the native connect resolves immediately) and "needs to join", and it still
+    // probes the glasses server before downloading. Skipping straight to startFileDownload
+    // would be unsafe here — nothing has proven connectivity yet.
+    if (hotspotMembershipUnknown && currentGlassesHotspot) {
+      const hotspotInfo: HotspotInfo = currentGlassesHotspot
+      store.setHotspotInfo(hotspotInfo)
+      store.setSyncState("connecting_wifi")
+      await this.connectToHotspotWifi(hotspotInfo)
+      return
+    }
+
     if (isAlreadyConnected && currentGlassesHotspot) {
       const hotspotInfo: HotspotInfo = currentGlassesHotspot
       store.setHotspotInfo(hotspotInfo)
@@ -936,30 +1052,38 @@ class GallerySyncService {
           console.log(`[GallerySyncService] ⏱️ Time since WiFi phase started: ${Date.now() - wifiConnectStartTime}ms`)
           console.log(`[GallerySyncService] 📱 App backgrounded during connection: ${appBackgrounded}`)
 
-          // Check current WiFi state before attempting connection
-          let preConnectSSID = "unknown"
-          try {
-            preConnectSSID = await WifiManager.getCurrentWifiSSID()
-            console.log(`[GallerySyncService] 📡 Current WiFi SSID: "${preConnectSSID}"`)
-
-            // Check if already connected (shouldn't happen, but good to verify)
-            if (!localNetworkTransport.supportsScopedConnection() && preConnectSSID === hotspotInfo.ssid) {
-              console.log("[GallerySyncService] ✅ Already connected to target SSID! Proceeding to download.")
-              appStateSubscription.remove()
-
-              const totalWifiDuration = Date.now() - wifiConnectStartTime
-              console.log("[GallerySyncService] ========================================")
-              console.log("[GallerySyncService] ✅ WIFI CONNECTION COMPLETE (already connected)")
-              console.log("[GallerySyncService] ========================================")
-              console.log(`[GallerySyncService] ⏱️ Total WiFi phase duration: ${totalWifiDuration}ms`)
-              console.log(`[GallerySyncService] 🚀 Proceeding to file download from ${hotspotInfo.ip}:8089`)
-
-              await this.startFileDownload(hotspotInfo)
-              return // Exit function successfully
+          // Check current WiFi state before attempting connection. This is a shortcut, not
+          // a gate — when the SSID is unreadable we simply fall through to the connect call,
+          // which is itself a no-op if the phone is already on the target network.
+          if (!this.ssidReadable) {
+            console.log("[GallerySyncService] 📡 Skipping pre-connect SSID read (Location denied)")
+          } else {
+            try {
+              const preConnectSSID = await WifiManager.getCurrentWifiSSID()
+              console.log(`[GallerySyncService] 📡 Current WiFi SSID: "${preConnectSSID}"`)
+
+              // Check if already connected (shouldn't happen, but good to verify)
+              if (!localNetworkTransport.supportsScopedConnection() && preConnectSSID === hotspotInfo.ssid) {
+                console.log("[GallerySyncService] ✅ Already connected to target SSID! Proceeding to download.")
+                appStateSubscription.remove()
+
+                const totalWifiDuration = Date.now() - wifiConnectStartTime
+                console.log("[GallerySyncService] ========================================")
+                console.log("[GallerySyncService] ✅ WIFI CONNECTION COMPLETE (already connected)")
+                console.log("[GallerySyncService] ========================================")
+                console.log(`[GallerySyncService] ⏱️ Total WiFi phase duration: ${totalWifiDuration}ms`)
+                console.log(`[GallerySyncService] 🚀 Proceeding to file download from ${hotspotInfo.ip}:8089`)
+
+                await this.startFileDownload(hotspotInfo)
+                return // Exit function successfully
+              }
+            } catch (preError: unknown) {
+              const message = preError instanceof Error ? preError.message : String(preError)
+              console.warn(`[GallerySyncService] ⚠️ Could not get current SSID: ${message}`)
+              console.warn("[GallerySyncService] ⚠️ Error code:", (preError as {code?: unknown} | null)?.code)
+              // A permission wall here applies to every later read too — stop paying for it.
+              if (isSsidPermissionError(preError)) this.ssidReadable = false
             }
-          } catch (preError: any) {
-            console.warn(`[GallerySyncService] ⚠️ Could not get current SSID: ${preError?.message}`)
-            console.warn("[GallerySyncService] ⚠️ Error code:", preError?.code)
           }
 
           console.log(`[GallerySyncService] 🔌 Connecting the glasses-local transport...`)
@@ -984,64 +1108,67 @@ class GallerySyncService {
               `[GallerySyncService] ⏱️ Time until backgrounding: ${appBackgroundTime - connectCallStartTime}ms`,
             )
           }
-          console.log(`[GallerySyncService] 📝 Note: On iOS, this does NOT guarantee actual connection!`)
+          // NOTE: react-native-wifi-reborn >= 4.x already polls the SSID natively inside
+          // connectToProtectedSSID (up to 20 x 500ms) and only resolves once it observes the
+          // target network, so reaching this line is itself decent evidence of a real join.
+          // The poll below is a second opinion, not the primary gate — never fail on it
+          // when the SSID simply cannot be read.
 
-          // iOS-specific: Verify actual WiFi connection by polling SSID
-          // The library promise resolves when iOS ACCEPTS the request, not when connection completes
-          if (Platform.OS === "ios") {
+          if (Platform.OS === "ios" && !this.ssidReadable) {
+            console.log(
+              `[GallerySyncService] 🍎 Skipping SSID verification (Location denied) - using glasses connectivity probe`,
+            )
+          } else if (Platform.OS === "ios") {
             console.log(`[GallerySyncService] 🍎 iOS: Starting connection verification...`)
             console.log(`[GallerySyncService] 🍎 Will poll getCurrentWifiSSID() for up to 15 seconds`)
 
             const maxVerifyAttempts = 30 // 30 × 500ms = 15 seconds
-            let connected = false
-            let lastSeenSSID = "unknown"
-
-            for (let i = 0; i < maxVerifyAttempts; i++) {
-              try {
-                const currentSSID = await WifiManager.getCurrentWifiSSID()
-                lastSeenSSID = currentSSID || "null"
-
-                console.log(
-                  `[GallerySyncService] 🍎 Verify poll ${
-                    i + 1
-                  }/${maxVerifyAttempts}: Current="${currentSSID}", Target="${hotspotInfo.ssid}"`,
-                )
-
-                if (currentSSID === hotspotInfo.ssid) {
-                  console.log(
-                    `[GallerySyncService] 🍎 ✅ VERIFICATION SUCCESS! Connected to target network after ${
-                      (i + 1) * 500
-                    }ms`,
-                  )
-                  connected = true
-                  break
-                } else if (i === 0 && currentSSID === lastSeenSSID) {
+            const verification = await verifyIosHotspotSsid(
+              hotspotInfo.ssid,
+              async (pollNumber) => {
+                try {
+                  const currentSsid = await WifiManager.getCurrentWifiSSID()
                   console.log(
-                    `[GallerySyncService] 🍎 ⚠️ Still on original network - iOS dialog may not have appeared yet`,
+                    `[GallerySyncService] 🍎 Verify poll ${pollNumber}/${maxVerifyAttempts}: Current="${currentSsid}", Target="${hotspotInfo.ssid}"`,
                   )
+                  return currentSsid
+                } catch (error: unknown) {
+                  const message = error instanceof Error ? error.message : String(error)
+                  console.log(`[GallerySyncService] 🍎 ⚠️ Poll ${pollNumber}: Could not check SSID: ${message}`)
+                  throw error
                 }
-              } catch (ssidError: any) {
-                console.log(`[GallerySyncService] 🍎 ⚠️ Poll ${i + 1}: Could not check SSID: ${ssidError?.message}`)
-                lastSeenSSID = "error"
-              }
-
-              // Don't wait after last attempt
-              if (i < maxVerifyAttempts - 1) {
-                await new Promise<void>((resolve) => BgTimer.setTimeout(() => resolve(), 500))
-              }
-            }
+              },
+              () => new Promise<void>((resolve) => BgTimer.setTimeout(() => resolve(), 500)),
+              maxVerifyAttempts,
+            )
 
-            if (!connected) {
+            if (verification.status === "mismatched") {
               console.error(`[GallerySyncService] 🍎 ❌ VERIFICATION FAILED after 15 seconds`)
-              console.error(`[GallerySyncService] 🍎 Last seen SSID: "${lastSeenSSID}"`)
+              console.error(`[GallerySyncService] 🍎 Last seen SSID: "${verification.lastSeenSsid}"`)
               console.error(`[GallerySyncService] 🍎 Expected SSID: "${hotspotInfo.ssid}"`)
               console.error(`[GallerySyncService] 🍎 Possible causes:`)
               console.error(`[GallerySyncService] 🍎   1. User did not tap "Join" on iOS WiFi dialog`)
-              console.error(`[GallerySyncService] 🍎   2. iOS dialog did not appear (permission issue?)`)
+              console.error(`[GallerySyncService] 🍎   2. iOS dialog did not appear`)
               console.error(`[GallerySyncService] 🍎   3. iOS refused to switch networks`)
               throw new Error(
-                `iOS WiFi verification failed - still on "${lastSeenSSID}", expected "${hotspotInfo.ssid}"`,
+                `iOS WiFi verification failed - still on "${verification.lastSeenSsid}", expected "${hotspotInfo.ssid}"`,
+              )
+            }
+
+            if (verification.status === "unavailable") {
+              console.warn(
+                `[GallerySyncService] 🍎 SSID inspection unavailable; using glasses connectivity probe instead`,
               )
+              // Latch ONLY on a real permission wall (revoked between pre-flight and now).
+              // A run of transient or empty reads must leave `ssidReadable` alone: killing
+              // it here would disable the readable-mismatch gate for the remaining retries
+              // and make a later failure blame Location while it is granted.
+              if (verification.permissionBlocked) {
+                console.warn(`[GallerySyncService] 🍎 Location permission was revoked mid-sync - skipping SSID gates`)
+                this.ssidReadable = false
+              }
+            } else {
+              console.log(`[GallerySyncService] 🍎 ✅ SSID verification succeeded`)
             }
           }
 
@@ -1054,25 +1181,35 @@ class GallerySyncService {
           appStateSubscription.remove()
           console.log("[GallerySyncService] 👂 App state listener removed")
 
-          // Final verification: Check SSID one more time before starting download
-          try {
-            const finalSSID = localNetworkTransport.isScopedConnectionActive()
-              ? hotspotInfo.ssid
-              : await WifiManager.getCurrentWifiSSID()
-            console.log(`[GallerySyncService] 📶 Final SSID check before download: "${finalSSID}"`)
-            if (Platform.OS === "android") {
-              // Some local builds can have stale generated typings for the Bluetooth SDK module.
-              ;(BluetoothSdk as any).logCurrentWifiFrequency?.()
-            }
-            if (finalSSID !== hotspotInfo.ssid) {
-              console.error(
-                `[GallerySyncService] ❌ SSID mismatch detected! Expected "${hotspotInfo.ssid}", got "${finalSSID}"`,
-              )
-              throw new Error(`WiFi SSID mismatch - connected to "${finalSSID}" instead of "${hotspotInfo.ssid}"`)
+          // Final verification: Check SSID one more time before starting download.
+          // Only the READ is allowed to fail softly. A readable SSID that does not match is
+          // a real "we are about to download from the wrong network" signal and must abort —
+          // previously the throw was inside the try, so its own catch swallowed it and the
+          // gate never actually stopped anything.
+          let finalSSID: string | null = null
+          if (!this.ssidReadable) {
+            console.log("[GallerySyncService] 📶 Skipping final SSID check (Location denied)")
+          } else {
+            try {
+              finalSSID = localNetworkTransport.isScopedConnectionActive()
+                ? hotspotInfo.ssid
+                : await WifiManager.getCurrentWifiSSID()
+              console.log(`[GallerySyncService] 📶 Final SSID check before download: "${finalSSID}"`)
+            } catch (finalError: unknown) {
+              const message = finalError instanceof Error ? finalError.message : String(finalError)
+              console.warn(`[GallerySyncService] ⚠️ Could not perform final SSID check: ${message}`)
+              // Continue anyway - we've done our best to verify
             }
-          } catch (finalError: any) {
-            console.warn(`[GallerySyncService] ⚠️ Could not perform final SSID check: ${finalError?.message}`)
-            // Continue anyway - we've done our best to verify
+          }
+          if (Platform.OS === "android") {
+            // Some local builds can have stale generated typings for the Bluetooth SDK module.
+            ;(BluetoothSdk as any).logCurrentWifiFrequency?.()
+          }
+          if (finalSSID && finalSSID !== hotspotInfo.ssid) {
+            console.error(
+              `[GallerySyncService] ❌ SSID mismatch detected! Expected "${hotspotInfo.ssid}", got "${finalSSID}"`,
+            )
+            throw new Error(`WiFi SSID mismatch - connected to "${finalSSID}" instead of "${hotspotInfo.ssid}"`)
           }
 
           // iOS-specific: Wait for actual network connectivity to glasses
@@ -1086,19 +1223,22 @@ class GallerySyncService {
             let networkReady = false
 
             for (let probeNum = 1; probeNum <= maxProbeAttempts; probeNum++) {
+              // Declared outside the try so the `finally` can always clear it — the fetch
+              // rejects on most early probes, and an un-cleared BgTimer is a live native
+              // timer (up to 20 per attempt, 100 per sync).
+              const probeController = new AbortController()
+              let probeTimeout: number | null = null
               try {
                 console.log(`[GallerySyncService] 🍎 Connectivity probe ${probeNum}/${maxProbeAttempts}...`)
 
                 // Try to reach the glasses health endpoint with a short timeout
-                const probeController = new AbortController()
-                const probeTimeout = BgTimer.setTimeout(() => probeController.abort(), 1000) // 1 second timeout per probe
+                probeTimeout = BgTimer.setTimeout(() => probeController.abort(), 1000) // 1 second timeout per probe
 
                 const probeStartTime = Date.now()
                 const probeResponse = await localNetworkTransport.fetch(`http://${hotspotInfo.ip}:8089/api/health`, {
                   method: "GET",
                   signal: probeController.signal,
                 })
-                BgTimer.clearTimeout(probeTimeout)
 
                 const probeDuration = Date.now() - probeStartTime
                 console.log(
@@ -1112,14 +1252,16 @@ class GallerySyncService {
                   networkReady = true
                   break
                 }
-              } catch (probeError: any) {
-                const errorMsg = probeError?.message || "unknown"
+              } catch (probeError: unknown) {
+                const errorMsg = probeError instanceof Error ? probeError.message : String(probeError)
                 console.log(
                   `[GallerySyncService] 🍎 Probe ${probeNum} failed: ${errorMsg.substring(0, 50)}${
                     errorMsg.length > 50 ? "..." : ""
                   }`,
                 )
                 // Continue to next probe
+              } finally {
+                if (probeTimeout !== null) BgTimer.clearTimeout(probeTimeout)
               }
 
               // Wait 500ms before next probe (unless this was the last attempt)
@@ -1288,6 +1430,12 @@ class GallerySyncService {
       } else if (lastError?.message?.includes("internal error")) {
         userErrorMessage =
           "Could not connect to glasses WiFi. Please ensure you accept the WiFi prompt when it appears."
+      } else if (!this.ssidReadable) {
+        // We fell back to the connectivity probe because Location was denied, and the probe
+        // did not reach the glasses either. Point the user at the actionable cause rather
+        // than a raw "could not reach 192.168.43.1:8089".
+        userErrorMessage = "Could not reach glasses over WiFi. Allow Location access so the app can verify the network."
+        emitGalleryNotice({code: "location_permission_required"})
       }
 
       store.setSyncError(userErrorMessage)

package/src/services/slimStreamStatus.ts

@@ -22,7 +22,16 @@ export function slimStreamStatusEvent(
     kind: event.kind,
     status: event.status,
   }
-  if (event.streamId) slim.streamId = event.streamId
+  if (event.streamId) slim.streamId = event.streamId
+  if (event.sid) slim.sid = event.sid
+  if (typeof event.revision === "number") slim.revision = event.revision
+  if (typeof event.terminal === "boolean") slim.terminal = event.terminal
+  if (event.errorDetails) slim.errorDetails = event.errorDetails
+  if (event.kind === "reconnect") {
+    if ("reason" in event) slim.reason = event.reason
+    if ("attempt" in event) slim.attempt = event.attempt
+    if ("maxAttempts" in event) slim.maxAttempts = event.maxAttempts
+  }
   const ts = event.timestamp
   if (typeof ts === "number" && Number.isFinite(ts)) slim.timestamp = ts
   if (options.includeResolvedConfig && event.resolvedConfig) {

package/build/services/StreamLifecycleController.d.ts

@@ -1,85 +0,0 @@
-/**
- * Drives stream liveliness checks via a keep-alive heartbeat:
- * `setActive(true)` starts the timer; each tick sends a keep-alive with a
- * fresh ackId; `maxMissedAcks` consecutive timeouts fire `onTimeout`.
- *
- * Phone-owned successor to the retired cloud stream lifecycle controller.
- * It uses the local `LifecycleLogger` interface because pino is not a phone
- * dependency.
- *
- * Timers MUST go through BgTimer. React Native pauses plain `setInterval`
- * while MentraOS is backgrounded; glasses WHIP then auto-stops after 60s
- * without `keep_stream_alive`, and Mentra Call recovers by restarting ingest.
- */
-export interface LifecycleLogger {
-    child(bindings: Record<string, unknown>): LifecycleLogger;
-    debug(...args: unknown[]): void;
-    warn(...args: unknown[]): void;
-    error(...args: unknown[]): void;
-}
-interface StreamLifecycleCallbacks {
-    sendKeepAlive: (ackId: string) => Promise<void> | void;
-    onTimeout: () => Promise<void> | void;
-    onKeepAliveSent?: (ackId: string) => void;
-    onKeepAliveAcked?: (ackId: string, ageMs: number) => void;
-    onKeepAliveMissed?: (ackId: string, ageMs: number, missedCount: number) => void;
-}
-export interface StreamLifecycleTimerApi {
-    setInterval: (callback: () => void, delay: number) => number;
-    clearInterval: (intervalId: number) => void;
-    setTimeout: (callback: () => void, delay: number) => number;
-    clearTimeout: (timeoutId: number) => void;
-}
-export interface StreamLifecycleOptions {
-    logger: LifecycleLogger;
-    streamId: string;
-    keepAliveIntervalMs: number;
-    ackTimeoutMs: number;
-    maxMissedAcks: number;
-    shouldSendKeepAlive?: () => boolean;
-    now?: () => number;
-    timers?: StreamLifecycleTimerApi;
-}
-/**
- * Keep-alive heartbeat. Activate to start ticks; each tick sends keep-alive
- * with a fresh ackId and arms a timeout. `maxMissedAcks` consecutive misses
- * fire `onTimeout`, and the caller is expected to tear the stream down.
- */
-export declare class StreamLifecycleController {
-    private readonly callbacks;
-    private keepAliveTimer?;
-    private pendingAcks;
-    private missedAcks;
-    private lastActivityMs;
-    private active;
-    private disposed;
-    private readonly logger;
-    private readonly streamId;
-    private readonly keepAliveIntervalMs;
-    private readonly ackTimeoutMs;
-    private readonly maxMissedAcks;
-    private readonly shouldSendKeepAlive?;
-    private readonly now;
-    private readonly timers;
-    constructor(options: StreamLifecycleOptions, callbacks: StreamLifecycleCallbacks);
-    setActive(active: boolean): void;
-    recordActivity(): void;
-    /**
-     * Send one keep-alive immediately instead of waiting for the next interval.
-     * Used when the BLE link comes back after a suspension: the glasses
-     * publisher's 60s watchdog has been running the whole time, so the first
-     * heartbeat after resume must not wait up to another full interval.
-     */
-    tickNow(): void;
-    handleAck(ackId: string): void;
-    dispose(): void;
-    getLastActivityMs(): number;
-    private startTimer;
-    private stopTimer;
-    private tick;
-    private onAckTimeout;
-    private clearPendingAcks;
-    private createAckId;
-}
-export {};
-//# sourceMappingURL=StreamLifecycleController.d.ts.map

package/build/services/StreamLifecycleController.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StreamLifecycleController.d.ts","sourceRoot":"","sources":["../../src/services/StreamLifecycleController.ts"],"names":[],"mappings":"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"}