fix(cmp-remote-config): non-blocking render + last-good cache that respects cooldown (#139)

The host previously blocked on a fresh Supabase fetch (no timeout, no cache)
every time a config flag fired, so on a slow/blocked network the dialog hung
blank or was auto-dismissed.

- RemoteConfigLocalStore: persist the last-good active config (getCachedConfig /
  cacheConfig) so the host can render instantly.
- RemoteConfigViewModel.fetchAndEvaluate: bound the fetch with withTimeout(2500ms);
  on timeout fall back to the cached config — but ONLY if it still passes the SAME
  eligibility rules (impression cap / cooldown / dismissed) via the evaluator, so a
  cooldown-gated dialog (e.g. once-per-day "Rate Us") is never re-shown from cache.

The evaluator remains authoritative for what shows; the cache is a network
fallback, not a bypass of the server rules.

Co-authored-by: Mobile Byte Labs <mobilebytelabs@gmail.com>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 3 people

cmp-remote-config/src/commonMain/kotlin/com/mobilebytelabs/remoteconfig/local/RemoteConfigLocalStore.kt

@@ -1,6 +1,10 @@
 package com.mobilebytelabs.remoteconfig.local
 
+import com.mobilebytelabs.remoteconfig.model.RemoteConfig
 import com.russhwolf.settings.Settings
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
 
 class RemoteConfigLocalStore(private val settings: Settings = Settings()) {
     fun getImpressions(configId: String): Int = settings.getInt("rc_${configId}_impressions", 0)
@@ -29,4 +33,28 @@ class RemoteConfigLocalStore(private val settings: Settings = Settings()) {
         settings.remove("rc_${configId}_last_shown")
         settings.remove("rc_${configId}_dismissed")
     }
+
+    // --- Last-good config cache -------------------------------------------------
+    // Persists the most recent active config so the host can render INSTANTLY from
+    // cache while a fresh fetch runs in the background (or the network is slow/blocked).
+
+    fun getCachedConfig(): RemoteConfig? = settings.getStringOrNull(KEY_LAST_CONFIG)?.let { raw ->
+        runCatching { json.decodeFromString<RemoteConfig>(raw) }.getOrNull()
+    }
+
+    fun cacheConfig(config: RemoteConfig) {
+        runCatching { settings.putString(KEY_LAST_CONFIG, json.encodeToString(config)) }
+    }
+
+    fun clearCachedConfig() {
+        settings.remove(KEY_LAST_CONFIG)
+    }
+
+    companion object {
+        private const val KEY_LAST_CONFIG = "rc_last_config"
+        private val json = Json {
+            ignoreUnknownKeys = true
+            encodeDefaults = true
+        }
+    }
 }

cmp-remote-config/src/commonMain/kotlin/com/mobilebytelabs/remoteconfig/ui/RemoteConfigViewModel.kt

@@ -14,6 +14,7 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeoutOrNull
 
 data class RemoteConfigState(val activeConfig: RemoteConfig? = null, val isLoading: Boolean = true)
 
@@ -33,21 +34,40 @@ class RemoteConfigViewModel(
         viewModelScope.launch {
             _state.update { it.copy(isLoading = true) }
 
-            val configs = service.getActiveConfigs()
-
-            // Fetch server impressions (survives reinstall)
-            val serverImpressions = try {
-                service.getDeviceImpressions(deviceId)
-                    .associateBy { it.configId }
-            } catch (_: Exception) {
-                emptyMap<String, DeviceImpression>()
+            // Hard timeout so a slow/blocked network can't hang the dialog.
+            val configs = withTimeoutOrNull(FETCH_TIMEOUT_MS) { service.getActiveConfigs() }
+            if (configs == null) {
+                // Slow/blocked network — fall back to the last-good cached config, but
+                // ONLY if it still passes the SAME eligibility rules (impression cap /
+                // cooldown / dismissed). This never re-shows a cooldown-gated dialog
+                // (e.g. a once-per-day "Rate Us"); the cache is a network fallback, not
+                // a bypass of the server rules.
+                val cachedEligible = localStore.getCachedConfig()?.let { evaluator.evaluate(listOf(it)) }
+                _state.update { it.copy(activeConfig = cachedEligible ?: it.activeConfig, isLoading = false) }
+                return@launch
             }
 
+            // Fetch server impressions (survives reinstall), also bounded.
+            val serverImpressions = withTimeoutOrNull(FETCH_TIMEOUT_MS) {
+                try {
+                    service.getDeviceImpressions(deviceId).associateBy { it.configId }
+                } catch (_: Exception) {
+                    emptyMap<String, DeviceImpression>()
+                }
+            } ?: emptyMap()
+
+            // The evaluator is authoritative — it applies the impression/cooldown/dismiss
+            // rules. Cache the eligible result only as a network fallback for next time.
             val active = evaluator.evaluate(configs, serverImpressions)
+            active?.let { localStore.cacheConfig(it) }
             _state.update { it.copy(activeConfig = active, isLoading = false) }
         }
     }
 
+    private companion object {
+        const val FETCH_TIMEOUT_MS = 2500L
+    }
+
     fun onConfigShown(configId: String) {
         val now = GMTDate().timestamp
         localStore.incrementImpressions(configId, now)