catalyst-core 0.2.0-beta.1 → 0.2.0-beta.2

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/OfflineCacheService.kt

@@ -0,0 +1,374 @@
+package io.yourname.androidproject
+
+import android.content.Context
+import android.net.Uri
+import android.util.Log
+import android.webkit.CookieManager
+import android.webkit.WebResourceResponse
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import org.json.JSONObject
+import java.io.BufferedInputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.net.HttpURLConnection
+import java.net.URL
+import java.security.MessageDigest
+
+class OfflineCacheService(
+    context: Context
+) {
+    companion object {
+        private const val SNAPSHOT_MAX_AGE_MS = 24 * 60 * 60 * 1000L
+        private val ASSET_EXTENSIONS = setOf(
+            ".js",
+            ".mjs",
+            ".css",
+            ".png",
+            ".jpg",
+            ".jpeg",
+            ".gif",
+            ".svg",
+            ".webp",
+            ".ico",
+            ".woff",
+            ".woff2",
+            ".ttf",
+            ".eot"
+        )
+    }
+
+    private val TAG = "OfflineCacheService"
+    private val FLOW_TAG = "CatalystOfflineFlow"
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private val rootDir = File(context.cacheDir, "catalyst_offline")
+    private val routeRootDir = File(rootDir, "routes")
+    private val manifestFile = File(rootDir, "manifest.json")
+    private val ongoingSnapshots = mutableSetOf<String>()
+
+    @Volatile
+    private var manifest: OfflineManifest? = loadCachedManifest()
+
+    data class OfflineManifest(
+        val buildId: String,
+        val routes: List<OfflineRoute>
+    )
+
+    data class OfflineRoute(
+        val pattern: String,
+        val regex: String
+    )
+
+    init {
+        rootDir.mkdirs()
+        routeRootDir.mkdirs()
+        if (BuildConfig.DEBUG) {
+            Log.d(FLOW_TAG, "OFFLINE_SERVICE init cacheDir=${rootDir.absolutePath} manifestBuildId=${manifest?.buildId ?: "none"} routes=${manifest?.routes?.size ?: 0}")
+        }
+    }
+
+    fun refreshManifestAsync(url: String, headers: Map<String, String> = emptyMap()) {
+        if (!isHttpUrl(url)) return
+
+        if (BuildConfig.DEBUG) {
+            Log.d(FLOW_TAG, "MANIFEST refresh-async requested url=$url")
+        }
+        scope.launch {
+            refreshManifestBlocking(url, headers)
+        }
+    }
+
+    fun refreshManifestIfMissing(url: String, headers: Map<String, String> = emptyMap()) {
+        if (!isHttpUrl(url) || manifest != null) return
+        if (BuildConfig.DEBUG) {
+            Log.d(FLOW_TAG, "MANIFEST refresh-blocking reason=missing url=$url")
+        }
+        refreshManifestBlocking(url, headers)
+    }
+
+    fun storeRouteSnapshotAsync(url: String, headers: Map<String, String> = emptyMap()) {
+        if (!isHttpUrl(url)) return
+        val key = normalizeSnapshotUrl(url)
+
+        val shouldFetch = synchronized(ongoingSnapshots) {
+            ongoingSnapshots.add(key)
+        }
+
+        if (!shouldFetch) {
+            if (BuildConfig.DEBUG) {
+                Log.d(FLOW_TAG, "SNAPSHOT skip reason=already-in-flight url=$key")
+            }
+            return
+        }
+
+        if (BuildConfig.DEBUG) {
+            Log.d(FLOW_TAG, "SNAPSHOT store-requested url=$key")
+        }
+
+        scope.launch {
+            try {
+                refreshManifestBlocking(url, headers)
+                if (!isOfflineRouteUrl(url)) {
+                    if (BuildConfig.DEBUG) {
+                        Log.d(FLOW_TAG, "SNAPSHOT skip reason=route-not-eligible url=$url manifestBuildId=${manifest?.buildId ?: "none"} routes=${manifest?.routes?.size ?: 0}")
+                    }
+                    return@launch
+                }
+
+                val file = snapshotFileForUrl(key)
+                if (isFreshSnapshot(file)) {
+                    if (BuildConfig.DEBUG) {
+                        Log.d(FLOW_TAG, "SNAPSHOT skip reason=fresh-existing ageMs=${System.currentTimeMillis() - file.lastModified()} bytes=${file.length()} url=$key path=${file.absolutePath}")
+                    }
+                    return@launch
+                }
+
+                val connection = URL(key).openConnection() as HttpURLConnection
+                connection.requestMethod = "GET"
+                connection.connectTimeout = 15000
+                connection.readTimeout = 15000
+                connection.setRequestProperty("X-Catalyst-Offline-Snapshot-Fetch", "1")
+                headers.forEach { (header, value) ->
+                    if (shouldForwardHeader(header)) connection.setRequestProperty(header, value)
+                }
+                CookieManager.getInstance().getCookie(key)?.takeIf { it.isNotBlank() }?.let {
+                    connection.setRequestProperty("Cookie", it)
+                }
+
+                connection.connect()
+                val contentType = connection.contentType ?: ""
+                if (BuildConfig.DEBUG) {
+                    Log.d(FLOW_TAG, "SNAPSHOT fetch-response status=${connection.responseCode} contentType=$contentType url=$key")
+                }
+
+                if (connection.responseCode == HttpURLConnection.HTTP_OK &&
+                    contentType.contains("text/html", ignoreCase = true)
+                ) {
+                    val bytes = connection.inputStream.use { it.readBytes() }
+                    if (bytes.isNotEmpty()) {
+                        file.parentFile?.mkdirs()
+                        FileOutputStream(file).use { it.write(bytes) }
+                        if (BuildConfig.DEBUG) {
+                            Log.d(TAG, "Stored route snapshot: $key")
+                            Log.d(FLOW_TAG, "SNAPSHOT stored bytes=${bytes.size} url=$key path=${file.absolutePath}")
+                        }
+                    }
+                } else if (BuildConfig.DEBUG) {
+                    Log.w(FLOW_TAG, "SNAPSHOT not-stored reason=non-html-or-non-200 status=${connection.responseCode} contentType=$contentType url=$key")
+                }
+                connection.disconnect()
+            } catch (e: Exception) {
+                if (BuildConfig.DEBUG) {
+                    Log.w(TAG, "Unable to store route snapshot for $url: ${e.message}")
+                    Log.w(FLOW_TAG, "SNAPSHOT error phase=store url=$url error=${e.message}", e)
+                }
+            } finally {
+                synchronized(ongoingSnapshots) {
+                    ongoingSnapshots.remove(key)
+                }
+            }
+        }
+    }
+
+    fun getRouteSnapshotResponse(url: String): WebResourceResponse? {
+        if (!isOfflineRouteUrl(url)) {
+            if (BuildConfig.DEBUG) {
+                Log.d(FLOW_TAG, "SNAPSHOT miss reason=route-not-eligible url=$url")
+            }
+            return null
+        }
+        val file = snapshotFileForUrl(url)
+        if (!file.exists()) {
+            if (BuildConfig.DEBUG) {
+                Log.d(FLOW_TAG, "SNAPSHOT miss reason=file-missing url=$url path=${file.absolutePath}")
+            }
+            return null
+        }
+
+        if (BuildConfig.DEBUG) {
+            Log.d(FLOW_TAG, "SNAPSHOT hit bytes=${file.length()} url=$url path=${file.absolutePath}")
+        }
+        return WebResourceResponse(
+            "text/html",
+            "utf-8",
+            200,
+            "OK",
+            mapOf("X-Catalyst-Offline-Snapshot" to "hit"),
+            BufferedInputStream(FileInputStream(file))
+        )
+    }
+
+    fun hasRouteSnapshot(url: String): Boolean {
+        val eligible = isOfflineRouteUrl(url)
+        val file = snapshotFileForUrl(url)
+        val exists = eligible && file.exists()
+        if (BuildConfig.DEBUG) {
+            Log.d(FLOW_TAG, "SNAPSHOT exists-check eligible=$eligible exists=$exists bytes=${if (file.exists()) file.length() else 0} url=$url path=${file.absolutePath}")
+        }
+        return exists
+    }
+
+    fun isOfflineRouteUrl(url: String): Boolean {
+        if (!isHttpUrl(url)) return false
+        val currentManifest = manifest ?: return false
+        val path = Uri.parse(url).path ?: "/"
+
+        val matchedRoute = currentManifest.routes.firstOrNull { route ->
+            try {
+                Regex(route.regex, RegexOption.IGNORE_CASE).matches(path)
+            } catch (_: Exception) {
+                false
+            }
+        }
+        if (BuildConfig.DEBUG) {
+            Log.d(FLOW_TAG, "ROUTE match=${matchedRoute != null} path=$path pattern=${matchedRoute?.pattern ?: "none"} regex=${matchedRoute?.regex ?: "none"} buildId=${currentManifest.buildId} url=$url")
+        }
+        return matchedRoute != null
+    }
+
+    fun shouldCacheAssetUrl(url: String): Boolean {
+        if (!isHttpUrl(url)) return false
+        val path = Uri.parse(url).path?.lowercase() ?: return false
+        return ASSET_EXTENSIONS.any { path.endsWith(it) }
+    }
+
+    fun clearAll() {
+        try {
+            deleteRecursively(rootDir)
+            rootDir.mkdirs()
+            routeRootDir.mkdirs()
+            manifest = null
+            if (BuildConfig.DEBUG) {
+                Log.d(TAG, "Offline route snapshots cleared")
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Unable to clear offline cache: ${e.message}")
+        }
+    }
+
+    private fun refreshManifestBlocking(url: String, headers: Map<String, String>): OfflineManifest? {
+        return try {
+            val manifestUrl = manifestUrlFor(url)
+            val connection = URL(manifestUrl).openConnection() as HttpURLConnection
+            connection.requestMethod = "GET"
+            connection.connectTimeout = 10000
+            connection.readTimeout = 10000
+            headers.forEach { (header, value) ->
+                if (shouldForwardHeader(header)) connection.setRequestProperty(header, value)
+            }
+            CookieManager.getInstance().getCookie(manifestUrl)?.takeIf { it.isNotBlank() }?.let {
+                connection.setRequestProperty("Cookie", it)
+            }
+            connection.connect()
+
+            if (connection.responseCode != HttpURLConnection.HTTP_OK) {
+                if (BuildConfig.DEBUG) {
+                    Log.w(FLOW_TAG, "MANIFEST refresh-response status=${connection.responseCode} url=$manifestUrl keepingBuildId=${manifest?.buildId ?: "none"}")
+                }
+                connection.disconnect()
+                return manifest
+            }
+
+            val body = connection.inputStream.use { it.readBytes().toString(Charsets.UTF_8) }
+            connection.disconnect()
+            val parsed = parseManifest(body)
+            manifestFile.writeText(body)
+            manifest = parsed
+            if (BuildConfig.DEBUG) {
+                Log.d(FLOW_TAG, "MANIFEST refreshed buildId=${parsed.buildId} routes=${parsed.routes.size} url=$manifestUrl")
+                parsed.routes.forEach { route ->
+                    Log.d(FLOW_TAG, "MANIFEST route pattern=${route.pattern} regex=${route.regex}")
+                }
+            }
+            parsed
+        } catch (e: Exception) {
+            if (BuildConfig.DEBUG) {
+                Log.w(TAG, "Unable to refresh offline manifest: ${e.message}")
+                Log.w(FLOW_TAG, "MANIFEST refresh-error url=$url error=${e.message}", e)
+            }
+            manifest
+        }
+    }
+
+    private fun loadCachedManifest(): OfflineManifest? {
+        return try {
+            if (!manifestFile.exists()) return null
+            parseManifest(manifestFile.readText())
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    private fun parseManifest(raw: String): OfflineManifest {
+        val json = JSONObject(raw)
+        val buildId = json.optString("buildId", "unknown")
+        val routesJson = json.optJSONArray("routes")
+        val routes = mutableListOf<OfflineRoute>()
+        if (routesJson != null) {
+            for (index in 0 until routesJson.length()) {
+                val route = routesJson.optJSONObject(index) ?: continue
+                val pattern = route.optString("pattern")
+                val regex = route.optString("regex")
+                if (pattern.isNotBlank() && regex.isNotBlank()) {
+                    routes.add(OfflineRoute(pattern, regex))
+                }
+            }
+        }
+
+        return OfflineManifest(buildId, routes)
+    }
+
+    private fun snapshotFileForUrl(url: String): File {
+        val normalizedUrl = normalizeSnapshotUrl(url)
+        val namespace = manifest?.let { "${originFor(normalizedUrl)}:${it.buildId}" } ?: originFor(normalizedUrl)
+        val namespaceDir = File(routeRootDir, hash(namespace))
+        return File(namespaceDir, "${hash(normalizedUrl)}.html")
+    }
+
+    private fun manifestUrlFor(url: String): String {
+        val uri = Uri.parse(url)
+        return "${uri.scheme}://${uri.authority}/catalyst-offline-manifest.json"
+    }
+
+    private fun originFor(url: String): String {
+        val uri = Uri.parse(url)
+        return "${uri.scheme}://${uri.authority}"
+    }
+
+    private fun normalizeSnapshotUrl(url: String): String {
+        val uri = Uri.parse(url)
+        return uri.buildUpon().fragment(null).build().toString()
+    }
+
+    private fun isHttpUrl(url: String): Boolean {
+        val scheme = Uri.parse(url).scheme?.lowercase()
+        return scheme == "http" || scheme == "https"
+    }
+
+    private fun shouldForwardHeader(header: String): Boolean {
+        return !header.equals("Cookie", ignoreCase = true) &&
+            !header.equals("Host", ignoreCase = true) &&
+            !header.equals("Cache-Control", ignoreCase = true) &&
+            !header.equals("Pragma", ignoreCase = true)
+    }
+
+    private fun isFreshSnapshot(file: File): Boolean {
+        return file.exists() && System.currentTimeMillis() - file.lastModified() < SNAPSHOT_MAX_AGE_MS
+    }
+
+    private fun hash(value: String): String {
+        val digest = MessageDigest.getInstance("SHA-256").digest(value.toByteArray())
+        return digest.joinToString("") { "%02x".format(it) }
+    }
+
+    private fun deleteRecursively(file: File) {
+        if (!file.exists()) return
+        if (file.isDirectory) {
+            file.listFiles()?.forEach { deleteRecursively(it) }
+        }
+        file.delete()
+    }
+}

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/WebCacheManager.kt

@@ -14,6 +14,7 @@ import java.util.concurrent.TimeUnit
 
 class WebCacheManager(private val context: Context, private val properties: java.util.Properties? = null) {
     private val TAG = "WebCacheManager"
+    private val FLOW_TAG = "CatalystOfflineFlow"
     private val cacheDir = File(context.cacheDir, "webview_cache")
     private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     private val BUFFER_SIZE = 32 * 1024 
@@ -51,18 +52,33 @@ class WebCacheManager(private val context: Context, private val properties: java
         }
     }
 
-    data class CacheEntry(
-        val response: WebResourceResponse,
+    private data class CacheEntry(
+        val data: ByteArray,
+        val mimeType: String,
+        val encoding: String,
+        val responseHeaders: Map<String, String> = emptyMap(),
         val timestamp: Long = System.currentTimeMillis(),
         val eTag: String? = null,
         val lastModified: String? = null
-    )
+    ) {
+        fun toResponse(): WebResourceResponse {
+            return WebResourceResponse(
+                mimeType,
+                encoding,
+                200,
+                "OK",
+                responseHeaders.ifEmpty { null },
+                ByteArrayInputStream(data)
+            )
+        }
+    }
 
     /**
      * Synchronous cache check - only returns cached content if immediately available
      * Does not perform network requests or background revalidation
      * Used by ServiceWorker to avoid blocking
      */
+    @Suppress("UNUSED_PARAMETER")
     fun getCachedResponseSync(url: String, headers: Map<String, String>): WebResourceResponse? {
         return try {
             val cacheKey = generateCacheKey(url)
@@ -76,8 +92,12 @@ class WebCacheManager(private val context: Context, private val properties: java
                 if (age <= maxAge + staleWhileRevalidate) {
                     if (BuildConfig.DEBUG) {
                         Log.d(TAG, "✅ Serving from memory cache (sync): $url")
+                        Log.d(FLOW_TAG, "ASSET cache-hit source=memory ageMs=$age url=$url")
                     }
-                    return memoryCacheEntry.response
+                    return memoryCacheEntry.toResponse()
+                }
+                if (BuildConfig.DEBUG) {
+                    Log.d(FLOW_TAG, "ASSET cache-expired source=memory ageMs=$age url=$url")
                 }
             }
 
@@ -88,20 +108,48 @@ class WebCacheManager(private val context: Context, private val properties: java
                 if (fileAge <= maxAge + staleWhileRevalidate) {
                     val metadata = loadMetadata(cacheKey)
                     val response = createResponseFromCache(cacheFile, metadata)
+                    memoryCache.put(cacheKey, createEntryFromCache(cacheFile, metadata, cacheFile.lastModified()))
                     if (BuildConfig.DEBUG) {
                         Log.d(TAG, "✅ Serving from disk cache (sync): $url")
+                        Log.d(FLOW_TAG, "ASSET cache-hit source=disk ageMs=$fileAge bytes=${cacheFile.length()} mime=${metadata.mimeType} encoding=${metadata.encoding} url=$url")
                     }
                     return response
                 }
+                if (BuildConfig.DEBUG) {
+                    Log.d(FLOW_TAG, "ASSET cache-expired source=disk ageMs=$fileAge bytes=${cacheFile.length()} url=$url")
+                }
             }
 
             // No valid cache available
             if (BuildConfig.DEBUG) {
                 Log.d(TAG, "❌ No valid cache available (sync): $url")
+                Log.d(FLOW_TAG, "ASSET cache-miss url=$url")
             }
             null
         } catch (e: Exception) {
             Log.e(TAG, "Error in getCachedResponseSync for URL: $url: ${e.message}")
+            if (BuildConfig.DEBUG) {
+                Log.e(FLOW_TAG, "ASSET cache-error phase=read url=$url error=${e.message}", e)
+            }
+            null
+        }
+    }
+
+    /**
+     * Synchronous cache-or-network path for WebView interception.
+     *
+     * shouldInterceptRequest runs off the UI thread, so it is safe to block here.
+     * Returning the fetched response from this method guarantees that the same
+     * request which populated the cache also succeeds in the WebView.
+     */
+    fun getCachedResponseOrFetchSync(url: String, headers: Map<String, String>): WebResourceResponse? {
+        return try {
+            getCachedResponseSync(url, headers) ?: fetchAndCacheResourceBlocking(url, headers, generateCacheKey(url))
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in getCachedResponseOrFetchSync for URL: $url: ${e.message}")
+            if (BuildConfig.DEBUG) {
+                Log.e(FLOW_TAG, "ASSET cache-error phase=cache-or-fetch url=$url error=${e.message}", e)
+            }
             null
         }
     }
@@ -123,7 +171,7 @@ class WebCacheManager(private val context: Context, private val properties: java
                             if (BuildConfig.DEBUG) {
                                 Log.d(TAG, "Serving fresh content from memory cache: $url")
                             }
-                            return@withContext memoryCacheEntry.response
+                            return@withContext memoryCacheEntry.toResponse()
                         }
                         age <= maxAge + staleWhileRevalidate -> {
                             // Stale content, but within revalidate window
@@ -131,7 +179,7 @@ class WebCacheManager(private val context: Context, private val properties: java
                                 Log.d(TAG, "Serving stale content while revalidating: $url")
                             }
                             revalidateInBackground(url, headers, cacheKey, memoryCacheEntry)
-                            return@withContext memoryCacheEntry.response
+                            return@withContext memoryCacheEntry.toResponse()
                         }
                     }
                 }
@@ -146,18 +194,13 @@ class WebCacheManager(private val context: Context, private val properties: java
                         fileAge <= maxAge -> {
                             // Fresh content from disk
                             val response = createResponseFromCache(cacheFile, metadata)
-                            memoryCache.put(cacheKey, CacheEntry(response))
+                            memoryCache.put(cacheKey, createEntryFromCache(cacheFile, metadata, cacheFile.lastModified()))
                             return@withContext response
                         }
                         fileAge <= maxAge + staleWhileRevalidate -> {
                             // Stale content from disk, revalidate in background
                             val response = createResponseFromCache(cacheFile, metadata)
-                            val cacheEntry = CacheEntry(
-                                response = response,
-                                timestamp = cacheFile.lastModified(),
-                                eTag = metadata.eTag,
-                                lastModified = metadata.lastModified
-                            )
+                            val cacheEntry = createEntryFromCache(cacheFile, metadata, cacheFile.lastModified())
                             revalidateInBackground(url, headers, cacheKey, cacheEntry)
                             return@withContext response
                         }
@@ -168,7 +211,7 @@ class WebCacheManager(private val context: Context, private val properties: java
                 if (BuildConfig.DEBUG) {
                     Log.d(TAG, "❌ Cache miss, fetching fresh content: $url")
                 }
-                fetchAndCacheResource(url, headers, cacheKey)
+                fetchAndCacheResourceBlocking(url, headers, cacheKey)
             } catch (e: Exception) {
                 Log.e(TAG, "Error in getCachedResponse for URL: $url: ${e.message}")
                 if (BuildConfig.DEBUG) {
@@ -282,7 +325,7 @@ class WebCacheManager(private val context: Context, private val properties: java
                         if (BuildConfig.DEBUG) {
                             Log.d(TAG, "⚡ Content changed, updating cache: $url")
                         }
-                        fetchAndCacheResource(url, headers, cacheKey)
+                        fetchAndCacheResourceBlocking(url, headers, cacheKey)
                     }
                 }
             } catch (e: Exception) {
@@ -308,25 +351,32 @@ class WebCacheManager(private val context: Context, private val properties: java
         }
     }
 
-    private suspend fun fetchAndCacheResource(
+    private fun fetchAndCacheResourceBlocking(
         url: String,
         headers: Map<String, String>,
         cacheKey: String
-    ): WebResourceResponse? = withContext(Dispatchers.IO) {
+    ): WebResourceResponse? {
         var connection: HttpURLConnection? = null
         try {
             connection = URL(url).openConnection() as HttpURLConnection
             headers.forEach { (key, value) ->
-                connection.setRequestProperty(key, value)
+                if (!key.equals("Accept-Encoding", ignoreCase = true)) {
+                    connection.setRequestProperty(key, value)
+                }
             }
+            connection.setRequestProperty("Accept-Encoding", "identity")
 
             connection.connectTimeout = 15000
             connection.readTimeout = 15000
+            if (BuildConfig.DEBUG) {
+                Log.d(FLOW_TAG, "ASSET network-fetch start url=$url headers=${headers.keys.sorted()}")
+            }
             connection.connect()
 
             if (connection.responseCode == HttpURLConnection.HTTP_OK) {
-                val mimeType = connection.contentType ?: "application/octet-stream"
-                val encoding = connection.contentEncoding ?: "utf-8"
+                val contentType = connection.contentType ?: "application/octet-stream"
+                val mimeType = mimeTypeFromContentType(contentType)
+                val encoding = charsetFromContentType(contentType)
                 val eTag = connection.getHeaderField("ETag")
                 val lastModified = connection.getHeaderField("Last-Modified")
 
@@ -336,13 +386,17 @@ class WebCacheManager(private val context: Context, private val properties: java
                 while (true) {
                     val key = connection.getHeaderFieldKey(i) ?: break
                     val value = connection.getHeaderField(i)
-                    if (key.isNotEmpty()) savedHeaders[key] = value
+                    if (key.isNotEmpty() && shouldReplayHeader(key)) savedHeaders[key] = value
                     i++
                 }
+                savedHeaders["Content-Type"] = contentType
 
                 val responseBytes = connection.inputStream.use { it.readBytes() }
                 if (!isValidResponse(mimeType, responseBytes)) {
-                    return@withContext null
+                    if (BuildConfig.DEBUG) {
+                        Log.w(FLOW_TAG, "ASSET network-fetch invalid-response status=${connection.responseCode} contentType=$contentType bytes=${responseBytes.size} url=$url")
+                    }
+                    return null
                 }
 
                 // Create response for immediate use
@@ -350,7 +404,10 @@ class WebCacheManager(private val context: Context, private val properties: java
 
                 // Cache the response
                 val cacheEntry = CacheEntry(
-                    response = WebResourceResponse(mimeType, encoding, 200, "OK", savedHeaders, ByteArrayInputStream(responseBytes.copyOf())),
+                    data = responseBytes.copyOf(),
+                    mimeType = mimeType,
+                    encoding = encoding,
+                    responseHeaders = savedHeaders,
                     eTag = eTag,
                     lastModified = lastModified
                 )
@@ -370,21 +427,34 @@ class WebCacheManager(private val context: Context, private val properties: java
                         ))
                         if (BuildConfig.DEBUG) {
                             Log.d(TAG, "✅ Successfully cached response for: $url")
+                            Log.d(FLOW_TAG, "ASSET stored bytes=${responseBytes.size} mime=$mimeType encoding=$encoding url=$url")
                         }
                     } catch (e: Exception) {
                         Log.e(TAG, "Error saving to disk cache for URL: $url: ${e.message}")
+                        if (BuildConfig.DEBUG) {
+                            Log.e(FLOW_TAG, "ASSET store-error url=$url error=${e.message}", e)
+                        }
                     }
                 }
 
-                return@withContext response
+                if (BuildConfig.DEBUG) {
+                    Log.d(FLOW_TAG, "ASSET network-fetch success status=${connection.responseCode} bytes=${responseBytes.size} contentType=$contentType replayMime=$mimeType replayEncoding=$encoding url=$url")
+                }
+                return response
+            }
+            if (BuildConfig.DEBUG) {
+                Log.w(FLOW_TAG, "ASSET network-fetch non-200 status=${connection.responseCode} contentType=${connection.contentType} url=$url")
             }
-            return@withContext null
+            return null
         } catch (e: Exception) {
             Log.e(TAG, "Error fetching resource: ${e.message}")
+            if (BuildConfig.DEBUG) {
+                Log.e(FLOW_TAG, "ASSET network-fetch error url=$url error=${e.message}", e)
+            }
             if (BuildConfig.DEBUG) {
                 e.printStackTrace()
             }
-            return@withContext null
+            return null
         } finally {
             connection?.disconnect()
         }
@@ -409,6 +479,46 @@ class WebCacheManager(private val context: Context, private val properties: java
         )
     }
 
+    private fun mimeTypeFromContentType(contentType: String): String {
+        return contentType.substringBefore(";").trim().ifEmpty { "application/octet-stream" }
+    }
+
+    private fun charsetFromContentType(contentType: String): String {
+        val charsetPart = contentType
+            .split(";")
+            .map { it.trim() }
+            .firstOrNull { it.startsWith("charset=", ignoreCase = true) }
+        return charsetPart
+            ?.substringAfter("=")
+            ?.trim()
+            ?.trim('"')
+            ?.ifEmpty { null }
+            ?: "utf-8"
+    }
+
+    private fun shouldReplayHeader(header: String): Boolean {
+        return !header.equals("Content-Encoding", ignoreCase = true) &&
+            !header.equals("Transfer-Encoding", ignoreCase = true) &&
+            !header.equals("Content-Length", ignoreCase = true) &&
+            !header.equals("Connection", ignoreCase = true)
+    }
+
+    private fun createEntryFromCache(
+        cacheFile: File,
+        metadata: CacheMetadata,
+        timestamp: Long
+    ): CacheEntry {
+        return CacheEntry(
+            data = cacheFile.readBytes(),
+            mimeType = metadata.mimeType,
+            encoding = metadata.encoding,
+            responseHeaders = metadata.responseHeaders,
+            timestamp = timestamp,
+            eTag = metadata.eTag,
+            lastModified = metadata.lastModified
+        )
+    }
+
     private fun generateCacheKey(url: String): String {
         try {
             val md = MessageDigest.getInstance("SHA-256")