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

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

@@ -5,7 +5,9 @@ import android.util.Log
 import android.util.LruCache
 import android.webkit.WebResourceResponse
 import io.yourname.androidproject.BuildConfig
+import io.yourname.androidproject.utils.PerfEventBuffer
 import kotlinx.coroutines.*
+import org.json.JSONObject
 import java.io.*
 import java.net.HttpURLConnection
 import java.net.URL
@@ -36,6 +38,24 @@ class WebCacheManager(private val context: Context, private val properties: java
         (Runtime.getRuntime().maxMemory() / 1024 / memoryFraction).toInt()
     )
 
+    private fun emitCachePerfEvent(type: String, url: String, startMs: Long, statusCode: Int? = null) {
+        if (!BuildConfig.DEBUG) return
+        PerfEventBuffer.add(JSONObject().apply {
+            put("type", type)
+            put("url", url)
+            put("nativeStartMs", startMs)
+            put("durationMs", android.os.SystemClock.elapsedRealtime() - startMs)
+            put("resourceType", when {
+                url.endsWith(".js") -> "script"
+                url.endsWith(".css") -> "stylesheet"
+                url.endsWith(".png") || url.endsWith(".jpg") || url.endsWith(".jpeg") || url.endsWith(".svg") -> "image"
+                else -> "other"
+            })
+            put("thread", Thread.currentThread().name)
+            statusCode?.let { put("statusCode", it) }
+        })
+    }
+
     init {
         try {
             cacheDir.mkdirs()
@@ -81,6 +101,7 @@ class WebCacheManager(private val context: Context, private val properties: java
     @Suppress("UNUSED_PARAMETER")
     fun getCachedResponseSync(url: String, headers: Map<String, String>): WebResourceResponse? {
         return try {
+            val startMs = android.os.SystemClock.elapsedRealtime()
             val cacheKey = generateCacheKey(url)
             val currentTime = System.currentTimeMillis()
 
@@ -94,6 +115,7 @@ class WebCacheManager(private val context: Context, private val properties: java
                         Log.d(TAG, "✅ Serving from memory cache (sync): $url")
                         Log.d(FLOW_TAG, "ASSET cache-hit source=memory ageMs=$age url=$url")
                     }
+                    emitCachePerfEvent("cache-hit-memory", url, startMs)
                     return memoryCacheEntry.toResponse()
                 }
                 if (BuildConfig.DEBUG) {
@@ -113,6 +135,7 @@ class WebCacheManager(private val context: Context, private val properties: java
                         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")
                     }
+                    emitCachePerfEvent("cache-hit-disk", url, startMs)
                     return response
                 }
                 if (BuildConfig.DEBUG) {
@@ -125,6 +148,7 @@ class WebCacheManager(private val context: Context, private val properties: java
                 Log.d(TAG, "❌ No valid cache available (sync): $url")
                 Log.d(FLOW_TAG, "ASSET cache-miss url=$url")
             }
+            emitCachePerfEvent("cache-miss-fetch", url, startMs)
             null
         } catch (e: Exception) {
             Log.e(TAG, "Error in getCachedResponseSync for URL: $url: ${e.message}")
@@ -357,6 +381,7 @@ class WebCacheManager(private val context: Context, private val properties: java
         cacheKey: String
     ): WebResourceResponse? {
         var connection: HttpURLConnection? = null
+        val startMs = android.os.SystemClock.elapsedRealtime()
         try {
             connection = URL(url).openConnection() as HttpURLConnection
             headers.forEach { (key, value) ->
@@ -440,6 +465,7 @@ class WebCacheManager(private val context: Context, private val properties: java
                 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")
                 }
+                emitCachePerfEvent("network-fetch-complete", url, startMs, connection.responseCode)
                 return response
             }
             if (BuildConfig.DEBUG) {

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

@@ -5,6 +5,8 @@ import android.webkit.WebView
 import io.yourname.androidproject.CatalystConstants
 import org.json.JSONObject
 import android.os.Looper
+import android.os.SystemClock
+import io.yourname.androidproject.BuildConfig
 
 /**
  * Common utilities for native bridge operations
@@ -95,11 +97,64 @@ object BridgeUtils {
         ON_TRANSITION_CANCELLED("ON_TRANSITION_CANCELLED"),
         ON_TRANSITION_TIMEOUT("ON_TRANSITION_TIMEOUT"),
 
+        // Perf telemetry
+        CATALYST_PERF_EVENT("CATALYST_PERF_EVENT"),
     }
     
+    /**
+     * Emit a performance event directly to WebPerfCollector via
+     * window.__catalystPerfEvent(). Bypasses the WebBridge callback system
+     * to keep perf overhead minimal — no JS parsing, no handler lookup.
+     *
+     * Must be called from any thread — posts to main thread automatically.
+     *
+     * @param webView The WebView instance
+     * @param payload JSONObject with at minimum a "type" field
+     */
+    fun emitPerfEvent(webView: WebView, payload: JSONObject) {
+        if (!PerfEventBuffer.isEnabled()) return
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            // Capture caller thread name before marshalling to main thread
+            if (!payload.has("emitThread")) {
+                payload.put("emitThread", Thread.currentThread().name)
+            }
+            webView.post { emitPerfEvent(webView, payload) }
+            return
+        }
+        try {
+            // Use JSON.parse inside the JS call so we never deal with quote escaping
+            val jsonStr = payload.toString().replace("\\", "\\\\").replace("'", "\\'")
+            webView.evaluateJavascript("window.__catalystPerfEvent && window.__catalystPerfEvent('$jsonStr')", null)
+        } catch (e: Exception) {
+            Log.e(TAG, "emitPerfEvent failed: ${e.message}")
+        }
+    }
+
+    /**
+     * Record that a @JavascriptInterface method was invoked (t0).
+     * Pair with bridgeCallDispatched() at notifyWeb() call site.
+     * No-op in release builds.
+     *
+     * @param callId  Unique identifier for this call (e.g. "getDeviceInfo:<timestamp>")
+     * @param method  Human-readable method name for ApiCollector.js
+     */
+    fun bridgeCallReceived(callId: String, method: String) {
+        if (!BuildConfig.DEBUG) return
+        PerfEventBuffer.bridgeCallReceived(callId, method)
+    }
+
+    /**
+     * Record that native dispatched the callback back to JS (t1).
+     * Must be called just before (or just after) notifyWeb().
+     */
+    fun bridgeCallDispatched(callId: String) {
+        if (!BuildConfig.DEBUG) return
+        PerfEventBuffer.bridgeCallDispatched(callId)
+    }
+
     /**
      * Send a callback to the web layer
-     * 
+     *
      * @param webView The WebView instance
      * @param event The web event to send
      * @param data The data to send (can be null)

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

@@ -2,27 +2,34 @@ package io.yourname.androidproject.utils
 
 import android.app.Activity
 import android.graphics.Rect
+import android.os.SystemClock
 import android.util.TypedValue
 import android.view.View
 import android.view.ViewGroup
 import android.view.ViewTreeObserver
+import android.webkit.WebView
 import androidx.constraintlayout.widget.ConstraintLayout
+import org.json.JSONObject
 
 class KeyboardUtil(
     private val activity: Activity,
-    private val webViewContainer: View
+    private val webViewContainer: View,
+    private val webView: WebView? = null,
 ) {
     private var originalHeight: Int = 0
     private var listener: ViewTreeObserver.OnGlobalLayoutListener? = null
-    
+
     // Keyboard detection threshold in dp - commonly used values are 120-150dp
     private val keyboardThresholdDp = 120f
-    
+
     // Calculate minimum keyboard height in pixels based on device density
     private val keyboardThresholdPx: Int by lazy {
         dpToPx(keyboardThresholdDp)
     }
-    
+
+    // Track keyboard state to avoid spamming events on every layout pass
+    private var keyboardVisible = false
+
     /**
      * Convert density-independent pixels to pixels
      */
@@ -33,7 +40,7 @@ class KeyboardUtil(
             activity.resources.displayMetrics
         ).toInt()
     }
-    
+
     /**
      * Convert pixels to density-independent pixels
      */
@@ -43,7 +50,7 @@ class KeyboardUtil(
 
     fun initialize() {
         val rootView = activity.findViewById<ViewGroup>(android.R.id.content)
-        
+
         webViewContainer.post {
             originalHeight = webViewContainer.height
         }
@@ -53,21 +60,33 @@ class KeyboardUtil(
             val screenHeight = activity.resources.displayMetrics.heightPixels
             val visibleHeight = rect.height()
             val keyboardHeight = screenHeight - visibleHeight
-            
+
             // Use density-independent threshold and consider screen size
             // Also add a minimum percentage of screen height as additional validation
             val minScreenPercentage = (screenHeight * 0.15).toInt() // 15% of screen height
             val effectiveThreshold = maxOf(keyboardThresholdPx, minScreenPercentage)
-            if (keyboardHeight > effectiveThreshold) {
+            val isNowVisible = keyboardHeight > effectiveThreshold
+
+            if (isNowVisible) {
                 // Keyboard visible - resize
                 val params = webViewContainer.layoutParams as ConstraintLayout.LayoutParams
                 params.height = originalHeight - keyboardHeight
                 webViewContainer.layoutParams = params
+
+                if (!keyboardVisible) {
+                    keyboardVisible = true
+                    emitKeyboardEvent("keyboard-show", keyboardHeight)
+                }
             } else {
                 // Keyboard hidden - restore
                 val params = webViewContainer.layoutParams as ConstraintLayout.LayoutParams
                 params.height = originalHeight
                 webViewContainer.layoutParams = params
+
+                if (keyboardVisible) {
+                    keyboardVisible = false
+                    emitKeyboardEvent("keyboard-hide", 0)
+                }
             }
         }
         rootView.viewTreeObserver.addOnGlobalLayoutListener(listener)
@@ -79,4 +98,25 @@ class KeyboardUtil(
             rootView.viewTreeObserver.removeOnGlobalLayoutListener(it)
         }
     }
+
+    // ─── Perf telemetry ──────────────────────────────────────────────────────
+
+    /**
+     * Emit keyboard show/hide event to WebPerfCollector.
+     * Uses SystemClock.elapsedRealtime() so the timestamp is alignable with
+     * native Perfetto traces via window.__NATIVE_TIME_OFFSET.
+     */
+    private fun emitKeyboardEvent(type: String, keyboardHeight: Int) {
+        val wv = webView ?: return
+        try {
+            val payload = JSONObject().apply {
+                put("type", type)
+                put("nativeTime", SystemClock.elapsedRealtime())
+                put("keyboardHeight", keyboardHeight)
+            }
+            BridgeUtils.emitPerfEvent(wv, payload)
+        } catch (e: Exception) {
+            // Non-critical — swallow silently
+        }
+    }
 }

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

@@ -0,0 +1,36 @@
+package io.yourname.androidproject.utils
+
+internal class PerfDeliveryState<T> {
+    data class Batch<T>(val id: String, val payload: T, val generation: Long, val retryCount: Int = 0)
+
+    private var generation = 0L
+    private var sequence = 0L
+    private var inFlight: Batch<T>? = null
+
+    fun hasInFlight(): Boolean = inFlight != null
+
+    fun current(): Batch<T>? = inFlight
+
+    fun begin(payload: T): Batch<T>? {
+        if (inFlight != null) return null
+        return Batch("catalyst-${++sequence}", payload, generation).also { inFlight = it }
+    }
+
+    fun isCurrent(batch: Batch<T>): Boolean = inFlight?.id == batch.id && batch.generation == generation
+
+    fun acknowledge(batch: Batch<T>): Boolean {
+        if (!isCurrent(batch)) return false
+        inFlight = null
+        return true
+    }
+
+    fun retry(batch: Batch<T>, maxRetries: Int): Batch<T>? {
+        if (!isCurrent(batch) || batch.retryCount >= maxRetries) return null
+        return batch.copy(retryCount = batch.retryCount + 1).also { inFlight = it }
+    }
+
+    fun reset() {
+        generation++
+        inFlight = null
+    }
+}

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

@@ -0,0 +1,289 @@
+package io.yourname.androidproject.utils
+
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+import android.webkit.WebView
+import io.yourname.androidproject.BuildConfig
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.concurrent.ConcurrentLinkedQueue
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * PerfEventBuffer — native ring buffer for Catalyst profiler events.
+ *
+ * Collects all events from onCreate (boot timing, cache, API calls) and flushes
+ * them as a single JSON array to the web layer after onPageFinished.
+ *
+ * Design:
+ *   - add() is safe from any thread (ConcurrentLinkedQueue)
+ *   - scheduleFlush() called from onPageFinished — posts to main thread after 250ms
+ *     so the JS environment is ready to receive events
+ *   - flush() serialises all events to JSON array, calls window.__catalystPerfBatch()
+ *   - CacheSummarizer: running tally of hit/miss/fetch + top-5 min-heap for InsightsCollector
+ *   - Max ring buffer size: 500 events (oldest dropped if exceeded)
+ *
+ * API call timing:
+ *   - bridgeCallReceived(callId, method) → stamps t0, stores in pendingCalls map
+ *   - bridgeCallDispatched(callId) → stamps t1, computes durationMs, adds api-call event to buffer
+ */
+object PerfEventBuffer {
+
+    private const val TAG = "PerfEventBuffer"
+    private const val MAX_BUFFER_SIZE = 500
+    private const val FLUSH_DELAY_MS = 250L
+    private const val FLUSH_RETRY_DELAY_MS = 250L
+    private const val MAX_FLUSH_RETRIES = 5
+    private const val PERIODIC_FLUSH_INTERVAL_MS = 4000L
+
+    private val buffer = ConcurrentLinkedQueue<JSONObject>()
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private val flushed = AtomicBoolean(false)
+    @Volatile private var profilerEnabled = false
+    private val deliveryState = PerfDeliveryState<JSONArray>()
+
+    // Periodic flush state
+    @Volatile private var periodicWebView: WebView? = null
+    private var lastFlushedSize = 0
+    private val periodicRunnable: Runnable = object : Runnable {
+        override fun run() {
+            if (!isEnabled()) return
+            val wv = periodicWebView ?: return
+            val pendingBatch = deliveryState.current()
+            if (pendingBatch != null) {
+                deliver(wv, pendingBatch)
+            } else if (buffer.size > lastFlushedSize) {
+                val currentSize = buffer.size
+                android.util.Log.d(TAG, "[PerfBuffer] periodicFlush() — $currentSize events since last flush")
+                beginFlush(wv, includeCacheSummary = false)
+            }
+            mainHandler.postDelayed(this, PERIODIC_FLUSH_INTERVAL_MS)
+        }
+    }
+
+    // Pending API call timing: callId → t0 nativeMs + method
+    private val pendingCalls = java.util.concurrent.ConcurrentHashMap<String, Pair<Long, String>>()
+
+    // ─── CacheSummarizer ─────────────────────────────────────────────────────
+
+    private var cacheHits   = 0
+    private var cacheMisses = 0
+    private var cacheFetches = 0
+    private var cacheTotalMs = 0L
+    // top-5 slowest: list of Pair(durationMs, filename)
+    private val cacheTopSlow = java.util.PriorityQueue<Pair<Long, String>>(
+        6, compareBy { it.first }
+    )
+
+    private fun updateCacheSummary(type: String, durationMs: Long, url: String) {
+        val filename = try {
+            val path = java.net.URI(url).path
+            path.split("/").filter { it.isNotEmpty() }.lastOrNull()?.take(40) ?: url.take(40)
+        } catch (e: Exception) { url.take(40) }
+
+        when (type) {
+            "cache-hit-memory", "cache-hit-disk" -> cacheHits++
+            "cache-miss-fetch"                   -> cacheMisses++
+            "network-fetch-complete"             -> {
+                cacheFetches++
+                cacheTotalMs += durationMs
+                cacheTopSlow.add(Pair(durationMs, filename))
+                if (cacheTopSlow.size > 5) cacheTopSlow.poll() // remove smallest
+            }
+        }
+    }
+
+    private fun buildCacheSummaryEvent(): JSONObject? {
+        val total = cacheHits + cacheMisses
+        if (total == 0) return null
+        val hitRate = if (total > 0) (cacheHits * 100.0 / total) else 0.0
+        val avgFetchMs = if (cacheFetches > 0) cacheTotalMs / cacheFetches else 0L
+        val topSlow = JSONArray()
+        cacheTopSlow.sortedByDescending { it.first }.forEach { (ms, name) ->
+            topSlow.put(JSONObject().apply {
+                put("filename", name)
+                put("durationMs", ms)
+            })
+        }
+        return JSONObject().apply {
+            put("type", "cache-summary")
+            put("hits", cacheHits)
+            put("misses", cacheMisses)
+            put("fetches", cacheFetches)
+            put("total", total)
+            put("hitRatePct", Math.round(hitRate * 10) / 10.0)
+            put("avgFetchMs", avgFetchMs)
+            put("topSlowest", topSlow)
+            put("nativeTime", SystemClock.elapsedRealtime())
+        }
+    }
+
+    // ─── Public API ──────────────────────────────────────────────────────────
+
+    fun configure(enabled: Boolean) {
+        profilerEnabled = BuildConfig.DEBUG && enabled
+        if (!profilerEnabled) reset()
+    }
+
+    fun isEnabled(): Boolean = profilerEnabled
+
+    /** Add a perf event to the buffer. Safe from any thread. */
+    fun add(event: JSONObject) {
+        if (!isEnabled()) return
+        if (buffer.size >= MAX_BUFFER_SIZE) {
+            buffer.poll() // drop oldest
+        }
+        // Update cache summary tally
+        val type = event.optString("type")
+        if (type.startsWith("cache-") || type == "network-fetch-complete") {
+            updateCacheSummary(type, event.optLong("durationMs", 0), event.optString("url"))
+        }
+        buffer.add(event)
+        android.util.Log.d(TAG, "[PerfBuffer] add() type=$type bufferSize=${buffer.size}")
+    }
+
+    /**
+     * Record start of an @JavascriptInterface bridge call.
+     * Call this immediately when the method is invoked on the JavascriptInterface.
+     */
+    fun bridgeCallReceived(callId: String, method: String) {
+        if (!isEnabled()) return
+        pendingCalls[callId] = Pair(SystemClock.elapsedRealtime(), method)
+    }
+
+    /**
+     * Record the end of immediate native bridge-handler work and add an api-call event.
+     */
+    fun bridgeCallDispatched(callId: String) {
+        if (!isEnabled()) return
+        val pending = pendingCalls.remove(callId) ?: return
+        val (t0, method) = pending
+        val t1 = SystemClock.elapsedRealtime()
+        val durationMs = t1 - t0
+        add(JSONObject().apply {
+            put("type", "api-call")
+            put("callId", callId)
+            put("method", method)
+            put("nativeStartMs", t0)
+            put("nativeEndMs", t1)
+            put("durationMs", durationMs)
+            put("thread", Thread.currentThread().name)
+        })
+    }
+
+    /**
+     * Schedule a flush after onPageFinished (initial/full page load).
+     * Also starts the periodic flush loop for subsequent SPA navigations.
+     */
+    fun scheduleFlush(webView: WebView) {
+        if (!isEnabled()) return
+        if (flushed.getAndSet(true)) {
+            android.util.Log.d(TAG, "[PerfBuffer] scheduleFlush() skipped — already flushed")
+            return
+        }
+        android.util.Log.d(TAG, "[PerfBuffer] scheduleFlush() scheduled in ${FLUSH_DELAY_MS}ms, bufferSize=${buffer.size}")
+        mainHandler.postDelayed({
+            beginFlush(webView, includeCacheSummary = true)
+            // Start periodic flush loop for SPA navigations after initial load
+            startPeriodicFlush(webView)
+        }, FLUSH_DELAY_MS)
+    }
+
+    /**
+     * Flush any pending events immediately (e.g. before a full URL navigation).
+     * Does NOT reset the buffer — only drains buffered events up to this point.
+     */
+    fun flushNow(webView: WebView) {
+        if (!isEnabled()) return
+        mainHandler.post { beginFlush(webView, includeCacheSummary = false) }
+    }
+
+    /**
+     * Start periodic flush loop — fires every 4s and flushes only if new events exist.
+     * Call after onPageFinished so the JS receiver is registered.
+     */
+    fun startPeriodicFlush(webView: WebView) {
+        if (!isEnabled()) return
+        mainHandler.removeCallbacks(periodicRunnable)
+        periodicWebView = webView
+        lastFlushedSize = 0
+        mainHandler.postDelayed(periodicRunnable, PERIODIC_FLUSH_INTERVAL_MS)
+        android.util.Log.d(TAG, "[PerfBuffer] startPeriodicFlush() — interval=${PERIODIC_FLUSH_INTERVAL_MS}ms")
+    }
+
+    /** Stop periodic flush (call on destroy / loadUrl reset). */
+    fun stopPeriodicFlush() {
+        mainHandler.removeCallbacks(periodicRunnable)
+        periodicWebView = null
+    }
+
+    /**
+     * Reset the buffer for the next page load.
+     * Call this from loadUrl so boot timing events for the new page are captured.
+     */
+    fun reset() {
+        stopPeriodicFlush()
+        buffer.clear()
+        deliveryState.reset()
+        pendingCalls.clear()
+        flushed.set(false)
+        lastFlushedSize = 0
+        cacheHits = 0
+        cacheMisses = 0
+        cacheFetches = 0
+        cacheTotalMs = 0L
+        cacheTopSlow.clear()
+    }
+
+    // ─── Flush ───────────────────────────────────────────────────────────────
+
+    /** Moves the current queue into an immutable in-flight batch until JS acknowledges it. */
+    private fun beginFlush(webView: WebView, includeCacheSummary: Boolean) {
+        if (!isEnabled()) return
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            mainHandler.post { beginFlush(webView, includeCacheSummary) }
+            return
+        }
+        if (deliveryState.hasInFlight()) return
+        val events = JSONArray()
+        while (buffer.isNotEmpty()) {
+            buffer.poll()?.let { events.put(it) }
+        }
+        if (includeCacheSummary) buildCacheSummaryEvent()?.let { events.put(it) }
+        if (events.length() == 0) return
+
+        val batch = deliveryState.begin(events) ?: return
+        deliver(webView, batch)
+    }
+
+    private fun deliver(webView: WebView, batch: PerfDeliveryState.Batch<JSONArray>) {
+        if (!isEnabled() || !deliveryState.isCurrent(batch)) return
+        try {
+            val json = batch.payload.toString().replace("\\", "\\\\").replace("'", "\\'")
+            val batchId = JSONObject.quote(batch.id)
+            webView.evaluateJavascript(
+                "window.__catalystPerfBatch ? window.__catalystPerfBatch($batchId, '$json') : false",
+            ) { result ->
+                if (result == "true") acknowledge(batch) else retry(webView, batch)
+            }
+        } catch (_: Exception) {
+            retry(webView, batch)
+        }
+    }
+
+    private fun acknowledge(batch: PerfDeliveryState.Batch<JSONArray>) {
+        if (deliveryState.acknowledge(batch)) {
+            lastFlushedSize = 0
+        }
+    }
+
+    private fun retry(webView: WebView, batch: PerfDeliveryState.Batch<JSONArray>) {
+        val retry = deliveryState.retry(batch, MAX_FLUSH_RETRIES)
+        if (retry == null) {
+            android.util.Log.w(TAG, "[PerfBuffer] batch ${batch.id} was not acknowledged; retaining until reset")
+            return
+        }
+        mainHandler.postDelayed({ deliver(webView, retry) }, FLUSH_RETRY_DELAY_MS)
+    }
+}

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

@@ -0,0 +1,13 @@
+package io.yourname.androidproject.utils
+
+internal class ProfilerNavigationState {
+    private var isInitialNavigation = true
+
+    data class Navigation(val url: String, val shouldReset: Boolean)
+
+    fun begin(url: String): Navigation {
+        val shouldReset = !isInitialNavigation
+        isInitialNavigation = false
+        return Navigation(url, shouldReset)
+    }
+}

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/ProfilerLifecycleTest.kt

@@ -0,0 +1,51 @@
+package io.yourname.androidproject
+
+import io.yourname.androidproject.utils.PerfDeliveryState
+import io.yourname.androidproject.utils.ProfilerNavigationState
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ProfilerLifecycleTest {
+    @Test
+    fun `offline startup and retry navigation record separate page lifecycles`() {
+        val state = ProfilerNavigationState()
+        val offlineStart = state.begin("file:///android_asset/offline/offline.html")
+        val retry = state.begin("https://example.com")
+
+        assertFalse(offlineStart.shouldReset)
+        assertEquals("file:///android_asset/offline/offline.html", offlineStart.url)
+        assertTrue(retry.shouldReset)
+        assertEquals("https://example.com", retry.url)
+    }
+
+    @Test
+    fun `batch remains in flight until acknowledged and retries retain its id`() {
+        val state = PerfDeliveryState<List<String>>()
+        val batch = state.begin(listOf("boot-activity-created"))
+
+        assertNotNull(batch)
+        assertNull(state.begin(listOf("boot-page-started")))
+
+        val retry = state.retry(batch!!, maxRetries = 2)
+        assertNotNull(retry)
+        assertEquals(batch.id, retry!!.id)
+        assertEquals(1, retry.retryCount)
+        assertTrue(state.acknowledge(retry))
+        assertNotNull(state.begin(listOf("boot-page-started")))
+    }
+
+    @Test
+    fun `reset invalidates stale delivery callbacks`() {
+        val state = PerfDeliveryState<List<String>>()
+        val batch = state.begin(listOf("boot-load-url"))!!
+
+        state.reset()
+
+        assertFalse(state.acknowledge(batch))
+        assertNull(state.retry(batch, maxRetries = 2))
+    }
+}