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

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/CustomWebviewTest.kt

@@ -85,7 +85,7 @@ class CustomWebviewTest {
             setProperty("accessControl.allowedUrls", "https://example.com,https://api.example.com")
         }
 
-        val enabled = properties.getProperty("accessControl.enabled", "true").equals("true", ignoreCase = true)
+        val enabled = properties.getProperty("accessControl.enabled", "false").equals("true", ignoreCase = true)
         assertTrue("Access control should be enabled", enabled)
 
         val allowedUrls = properties.getProperty("accessControl.allowedUrls", "")
@@ -101,8 +101,13 @@ class CustomWebviewTest {
         val disabledProps = Properties().apply {
             setProperty("accessControl.enabled", "false")
         }
-        val disabled = disabledProps.getProperty("accessControl.enabled", "true").equals("true", ignoreCase = true)
+        val disabled = disabledProps.getProperty("accessControl.enabled", "false").equals("true", ignoreCase = true)
         assertFalse("Access control should be disabled", disabled)
+
+        // Test missing config defaults to disabled
+        val missingProps = Properties()
+        val missing = missingProps.getProperty("accessControl.enabled", "false").equals("true", ignoreCase = true)
+        assertFalse("Missing access control config should default to disabled", missing)
     }
 
     @Test

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))
+    }
+}

package/dist/native/bridge/WebBridge.js

@@ -1,8 +1,8 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.default=void 0;var _NativeInterfaces=require("./constants/NativeInterfaces.js");var _NativeBridge=_interopRequireDefault(require("./utils/NativeBridge.js"));var _CameraUtils=_interopRequireDefault(require("./utils/CameraUtils.js"));var _PluginBridge=_interopRequireDefault(require("../plugin-bridge/PluginBridge.js"));function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e};}const DEVICE_INFO_PLUGIN={pluginId:"io.catalyst.device_info",command:"getDeviceInfo",successEvent:"onSuccess",errorEvent:"onError"};const DEVICE_INFO_REQUEST_TIMEOUT_MS=5000;const DEVICE_INFO_PLUGIN_FALLBACK_CODES=new Set(["PLUGIN_NOT_FOUND","COMMAND_NOT_SUPPORTED","PLUGIN_NOT_REGISTERED"]);const DEVICE_INFO_PLUGIN_FALLBACK_MESSAGES=["pluginbridge is not available in this environment","pluginbridge is not available","device info plugin request timed out"];const normalizeDeviceInfoPayload=payload=>{if(typeof payload!=="string"){return payload;}try{return JSON.parse(payload);}catch{return{message:payload};}};const createDeviceInfoError=(payload,fallbackMessage)=>{const parsed=normalizeDeviceInfoPayload(payload);const message=parsed?.message||parsed?.error||fallbackMessage;const error=new Error(message);if(parsed?.code){error.code=parsed.code;}if(parsed?.pluginId){error.pluginId=parsed.pluginId;}if(parsed?.command){error.command=parsed.command;}return error;};class WebBridge{constructor(){this.handlers=new Map();this.initialized=false;this._logInitialization();}/**
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.default=void 0;var _NativeInterfaces=require("./constants/NativeInterfaces.js");var _NativeBridge=_interopRequireDefault(require("./utils/NativeBridge.js"));var _CameraUtils=_interopRequireDefault(require("./utils/CameraUtils.js"));var _PluginBridge=_interopRequireDefault(require("../plugin-bridge/PluginBridge.js"));function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e};}function _interopRequireWildcard(e,t){if("function"==typeof WeakMap)var r=new WeakMap(),n=new WeakMap();return(_interopRequireWildcard=function(e,t){if(!t&&e&&e.__esModule)return e;var o,i,f={__proto__:null,default:e};if(null===e||"object"!=typeof e&&"function"!=typeof e)return f;if(o=t?n:r){if(o.has(e))return o.get(e);o.set(e,f);}for(const t in e)"default"!==t&&{}.hasOwnProperty.call(e,t)&&((i=(o=Object.defineProperty)&&Object.getOwnPropertyDescriptor(e,t))&&(i.get||i.set)?o(f,t,i):f[t]=e[t]);return f;})(e,t);}const DEVICE_INFO_PLUGIN={pluginId:"io.catalyst.device_info",command:"getDeviceInfo",successEvent:"onSuccess",errorEvent:"onError"};const DEVICE_INFO_REQUEST_TIMEOUT_MS=5000;const DEVICE_INFO_PLUGIN_FALLBACK_CODES=new Set(["PLUGIN_NOT_FOUND","COMMAND_NOT_SUPPORTED","PLUGIN_NOT_REGISTERED"]);const DEVICE_INFO_PLUGIN_FALLBACK_MESSAGES=["pluginbridge is not available in this environment","pluginbridge is not available","device info plugin request timed out"];const normalizeDeviceInfoPayload=payload=>{if(typeof payload!=="string"){return payload;}try{return JSON.parse(payload);}catch{return{message:payload};}};const createDeviceInfoError=(payload,fallbackMessage)=>{const parsed=normalizeDeviceInfoPayload(payload);const message=parsed?.message||parsed?.error||fallbackMessage;const error=new Error(message);if(parsed?.code){error.code=parsed.code;}if(parsed?.pluginId){error.pluginId=parsed.pluginId;}if(parsed?.command){error.command=parsed.command;}return error;};class WebBridge{constructor(){this.handlers=new Map();this.initialized=false;this._logInitialization();}/**
      * Log initialization info
      */_logInitialization(){console.log("🌉 WebBridge initialized");console.log("🌉 Available callback interfaces:",_NativeInterfaces.ALL_CALLBACKS.length);if(process.env.NODE_ENV==="development"){(0,_NativeInterfaces.debugInterfaces)();}}/**
      * Static method to initialize WebBridge on window object
-     */static init=()=>{if(typeof window==="undefined"){console.error("🌉 WebBridge cannot be initialized outside the browser!");return null;}if(window.WebBridge){console.warn("🌉 WebBridge already initialized!");return window.WebBridge;}const bridge=new WebBridge();window.WebBridge=bridge;bridge.initialized=true;const{platform}=_NativeBridge.default.getEnvironmentInfo();console.log("🌉 WebBridge created and attached to window");return{bridge,platform,getDeviceInfo:bridge.getDeviceInfo};};/**
+     */static init=()=>{if(typeof window==="undefined"){console.error("🌉 WebBridge cannot be initialized outside the browser!");return null;}if(window.WebBridge){console.warn("🌉 WebBridge already initialized!");return window.WebBridge;}const bridge=new WebBridge();window.WebBridge=bridge;bridge.initialized=true;const{platform}=_NativeBridge.default.getEnvironmentInfo();if(window.__CATALYST_PROFILER_ENABLED===true){Promise.resolve().then(()=>_interopRequireWildcard(require("./perf/index.js"))).then(({default:WebPerfCollector})=>{WebPerfCollector.init(bridge);});}console.log("🌉 WebBridge created and attached to window");return{bridge,platform,getDeviceInfo:bridge.getDeviceInfo};};/**
      * Main callback handler called by native platforms
      * @param {string} interfaceName - The callback interface name
      * @param {any} data - Data from native platform

package/dist/native/bridge/constants/NativeInterfaces.js

@@ -25,7 +25,8 @@ ON_GOOGLE_SIGN_IN_SUCCESS:"ON_GOOGLE_SIGN_IN_SUCCESS",ON_GOOGLE_SIGN_IN_ERROR:"O
 NETWORK_STATUS_CHANGED:"NETWORK_STATUS_CHANGED",// Safe area callbacks
 ON_SAFE_AREA_INSETS_UPDATED:"ON_SAFE_AREA_INSETS_UPDATED",// Transition callbacks
 ON_TRANSITION_COMMITTED:"ON_TRANSITION_COMMITTED",ON_TRANSITION_CANCELLED:"ON_TRANSITION_CANCELLED",ON_TRANSITION_TIMEOUT:"ON_TRANSITION_TIMEOUT",// Security callbacks
-ON_SCREEN_SECURE_SET:"ON_SCREEN_SECURE_SET",ON_SCREEN_SECURE_STATUS:"ON_SCREEN_SECURE_STATUS",ON_SCREEN_SECURE_ERROR:"ON_SCREEN_SECURE_ERROR",ON_WEB_DATA_CLEARED:"ON_WEB_DATA_CLEARED",ON_WEB_DATA_CLEAR_ERROR:"ON_WEB_DATA_CLEAR_ERROR"};// Interface Categories for easier management
+ON_SCREEN_SECURE_SET:"ON_SCREEN_SECURE_SET",ON_SCREEN_SECURE_STATUS:"ON_SCREEN_SECURE_STATUS",ON_SCREEN_SECURE_ERROR:"ON_SCREEN_SECURE_ERROR",ON_WEB_DATA_CLEARED:"ON_WEB_DATA_CLEARED",ON_WEB_DATA_CLEAR_ERROR:"ON_WEB_DATA_CLEAR_ERROR",// Perf telemetry callbacks (native → web)
+CATALYST_PERF_EVENT:"CATALYST_PERF_EVENT"};// Interface Categories for easier management
 const INTERFACE_CATEGORIES=exports.INTERFACE_CATEGORIES={CAMERA:{commands:[NATIVE_COMMANDS.OPEN_CAMERA,NATIVE_COMMANDS.REQUEST_CAMERA_PERMISSION],callbacks:[NATIVE_CALLBACKS.CAMERA_PERMISSION_STATUS,NATIVE_CALLBACKS.ON_CAMERA_CAPTURE,NATIVE_CALLBACKS.ON_CAMERA_ERROR]},FILE:{commands:[NATIVE_COMMANDS.PICK_FILE,NATIVE_COMMANDS.OPEN_FILE_WITH_INTENT],callbacks:[NATIVE_CALLBACKS.ON_FILE_PICKED,NATIVE_CALLBACKS.ON_FILE_PICK_ERROR,NATIVE_CALLBACKS.ON_FILE_PICK_CANCELLED,NATIVE_CALLBACKS.ON_FILE_PICK_STATE_UPDATE]},INTENT:{commands:[NATIVE_COMMANDS.OPEN_FILE_WITH_INTENT],callbacks:[NATIVE_CALLBACKS.ON_INTENT_SUCCESS,NATIVE_CALLBACKS.ON_INTENT_ERROR,NATIVE_CALLBACKS.ON_INTENT_CANCELLED]},HAPTIC:{commands:[NATIVE_COMMANDS.REQUEST_HAPTIC_FEEDBACK],callbacks:[NATIVE_CALLBACKS.HAPTIC_FEEDBACK]},NOTIFICATION:{commands:[NATIVE_COMMANDS.SCHEDULE_LOCAL_NOTIFICATION,NATIVE_COMMANDS.CANCEL_LOCAL_NOTIFICATION,NATIVE_COMMANDS.REQUEST_NOTIFICATION_PERMISSION,NATIVE_COMMANDS.REGISTER_FOR_PUSH_NOTIFICATIONS,NATIVE_COMMANDS.UPDATE_BADGE_COUNT,NATIVE_COMMANDS.SUBSCRIBE_TO_TOPIC,NATIVE_COMMANDS.UNSUBSCRIBE_FROM_TOPIC,NATIVE_COMMANDS.GET_SUBSCRIBED_TOPICS],callbacks:[NATIVE_CALLBACKS.NOTIFICATION_PERMISSION_STATUS,NATIVE_CALLBACKS.LOCAL_NOTIFICATION_SCHEDULED,NATIVE_CALLBACKS.LOCAL_NOTIFICATION_CANCELLED,NATIVE_CALLBACKS.PUSH_NOTIFICATION_TOKEN,NATIVE_CALLBACKS.NOTIFICATION_RECEIVED,NATIVE_CALLBACKS.NOTIFICATION_ACTION_PERFORMED,NATIVE_CALLBACKS.NOTIFICATION_TAPPED,NATIVE_CALLBACKS.TOPIC_SUBSCRIPTION_RESULT,NATIVE_CALLBACKS.SUBSCRIBED_TOPICS_RESULT]},DEVICE_INFO:{commands:[NATIVE_COMMANDS.GET_DEVICE_INFO],callbacks:[NATIVE_CALLBACKS.ON_DEVICE_INFO_SUCCESS,NATIVE_CALLBACKS.ON_DEVICE_INFO_ERROR]},AUTH:{commands:[NATIVE_COMMANDS.GOOGLE_SIGN_IN],callbacks:[NATIVE_CALLBACKS.ON_GOOGLE_SIGN_IN_SUCCESS,NATIVE_CALLBACKS.ON_GOOGLE_SIGN_IN_ERROR,NATIVE_CALLBACKS.ON_GOOGLE_SIGN_IN_CANCELLED]},NETWORK:{commands:[NATIVE_COMMANDS.GET_NETWORK_STATUS],callbacks:[NATIVE_CALLBACKS.NETWORK_STATUS_CHANGED]},SECURITY:{commands:[NATIVE_COMMANDS.SET_SCREEN_SECURE,NATIVE_COMMANDS.GET_SCREEN_SECURE,NATIVE_COMMANDS.CLEAR_WEB_DATA],callbacks:[NATIVE_CALLBACKS.ON_SCREEN_SECURE_SET,NATIVE_CALLBACKS.ON_SCREEN_SECURE_ERROR,NATIVE_CALLBACKS.ON_WEB_DATA_CLEARED,NATIVE_CALLBACKS.ON_WEB_DATA_CLEAR_ERROR]},TRANSITION:{commands:[NATIVE_COMMANDS.START_TRANSITION,NATIVE_COMMANDS.COMMIT_TRANSITION,NATIVE_COMMANDS.CANCEL_TRANSITION],callbacks:[NATIVE_CALLBACKS.ON_TRANSITION_COMMITTED,NATIVE_CALLBACKS.ON_TRANSITION_CANCELLED,NATIVE_CALLBACKS.ON_TRANSITION_TIMEOUT]}};// All available interfaces (for validation)
 const ALL_COMMANDS=exports.ALL_COMMANDS=Object.values(NATIVE_COMMANDS);const ALL_CALLBACKS=exports.ALL_CALLBACKS=Object.values(NATIVE_CALLBACKS);const ALL_INTERFACES=exports.ALL_INTERFACES=[...ALL_COMMANDS,...ALL_CALLBACKS];// Permission status constants
 const PERMISSION_STATUS=exports.PERMISSION_STATUS={GRANTED:"GRANTED",DENIED:"DENIED",NOT_DETERMINED:"NOT_DETERMINED",RESTRICTED:"RESTRICTED"};// Haptic feedback types (matching Android implementation)

package/dist/native/bridge/perf/collectors/ApiCollector.js

@@ -0,0 +1,22 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.ApiCollector=void 0;var _constants=require("../core/constants.js");/**
+ * ApiCollector.js
+ *
+ * Instruments native API call timing — how long each @JavascriptInterface
+ * method takes from native receipt until its immediate native handler work is
+ * dispatched. It does not measure JS-to-native transport, JS callback delivery,
+ * or UI completion.
+ *
+ * Native events received (via __catalystPerfBatch drain):
+ *   api-call { callId, method, nativeStartMs, nativeEndMs, durationMs, thread }
+ *
+ * Spans emitted (one per call, on Catalyst > Native API track):
+ *   catalyst:api/<method>  — nativeStart → nativeEnd
+ *                            color: primary-dark (<50ms), secondary (<200ms), error (>200ms)
+ *   properties: method, durationMs, callId, thread, simulatorValid: false
+ *
+ * Reading the track:
+ *   Blue  = fast native call (<50ms)   — expected for sync APIs (getDeviceInfo, haptic)
+ *   Grey  = medium native call (<200ms) — native work worth inspecting
+ *   Red   = slow native call (>200ms)  — native work worth inspecting
+ */class ApiCollector{constructor(measure,nativeToWeb){this._measure=measure;this._nativeToWeb=nativeToWeb;}init(){// No web-side observers — all events come from native buffer drain
+}/** Called by index.js to feed the normalized perf store. */setWaterfallSource(fn){this._notifyWaterfall=fn;}setInteractionSource(fn){this._getInteraction=fn;}onBatchEvent(event){if(event.type!=="api-call")return;const{method,callId,nativeStartMs,nativeEndMs,durationMs,thread}=event;const startTime=this._nativeToWeb(nativeStartMs);const endTime=this._nativeToWeb(nativeEndMs);const interactionId=this._getInteraction?.()?.interactionIdForRange(startTime,endTime)??null;const color=durationMs>200?_constants.COLOR.ERROR:durationMs>50?_constants.COLOR.SECONDARY:_constants.COLOR.PRIMARY_DARK;const startMark=`${_constants.PREFIX.NATIVE_API}:${method}:start:${Math.round(startTime)}`;performance.mark(startMark,{startTime});this._notifyWaterfall?.({method,durationMs,callId,thread:thread??null,startTime,endTime,sessionId:interactionId,parentOperation:`Native execution: ${method}`});this._measure.emit(`${interactionId?`[${interactionId}] `:""}Native API: ${method} - ${durationMs}ms`,startMark,endTime,{interactionId,parentOperation:`Native execution: ${method}`,method,durationMs,callId,thread:thread??null,simulatorValid:false},_constants.TRACK.NATIVE_API,color);}}exports.ApiCollector=ApiCollector;

package/dist/native/bridge/perf/collectors/CacheCollector.js

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.CacheCollector=void 0;var _constants=require("../core/constants.js");/**
+ * CacheCollector.js
+ *
+ * Instruments: bugs #1, #2, #10
+ *   #1  page slowness OTC pages     → cache miss → slow fetch → resource blocks render
+ *   #2  back-forward reloads screen → back navigation triggers a burst of cache misses
+ *   #10 footer flash on Drug/OTC    → cache miss for footer chunk → layout shift after load
+ *
+ * Native events received in two modes:
+ *
+ * 1. Live (legacy path — only used if buffer disabled):
+ *   cache-hit-memory / cache-hit-disk / cache-miss-fetch / network-fetch-complete
+ *   → Each emits immediately to Catalyst > Cache track via onNativeEvent()
+ *
+ * 2. Batched (primary path via __catalystPerfBatch drain in index.js):
+ *   Same event types arrive as part of the native buffer flush after onPageFinished.
+ *   JS drains via requestIdleCallback → onBatchEvent() → emits spans on Catalyst > Cache > Detail
+ *
+ *   cache-summary { hits, misses, fetches, total, hitRatePct, avgFetchMs, topSlowest[] }
+ *   → One summary span emitted on main Catalyst > Cache track for InsightsCollector
+ *
+ * Spans emitted:
+ *   Catalyst > Cache > Detail  individual spans (one per file) during idle drain
+ *   Catalyst > Cache           summary span (hit rate, avg fetch, top slowest)
+ *
+ * Reading the track:
+ *   Blue        = cache HIT memory — fastest path
+ *   Blue-light  = cache HIT disk   — good, slightly slower
+ *   Red         = cache MISS       — matched pattern but not cached
+ *   Yellow/Orange = network fetch  — orange if slow >300ms
+ */const TRACK_CACHE_DETAIL="Cache > Detail";class CacheCollector{constructor(measure,nativeToWeb){this._measure=measure;this._nativeToWeb=nativeToWeb;this._notifyInsights=null;// set by index.js after construction
+}/** Called by index.js to wire up insights notifications for cache-summary. */setInsightsSource(fn){this._notifyInsights=fn;}init(){// No web-side observers — all events come from native
+}// ── Live path (individual events routed from index.js) ──────────────────
+onNativeEvent(event){const{type}=event;if(!type?.startsWith("cache-")&&type!=="network-fetch-complete")return;this._emitCacheSpan(event,_constants.TRACK.CACHE);}// ── Batch path (native buffer flush) ────────────────────────────────────
+onBatchEvent(event){const{type}=event;if(type==="cache-summary"){this._emitSummarySpan(event);return;}if(!type?.startsWith("cache-")&&type!=="network-fetch-complete")return;// Individual cache spans go on the Detail sub-track
+this._emitCacheSpan(event,TRACK_CACHE_DETAIL);}// ── Internal ─────────────────────────────────────────────────────────────
+_emitCacheSpan(event,track){const{type,url,durationMs,nativeStartMs,resourceType,thread,statusCode}=event;const resType=resourceType??"other";const filename=this._filename(url);const endTime=nativeStartMs!=null?this._nativeToWeb(nativeStartMs)+(durationMs??0):performance.now();const startTime=endTime-(durationMs??0);let measureName,color,detail;const interceptThread=event.interceptThread??null;const emitThread=event.emitThread??null;if(type==="cache-hit-memory"){measureName=`${_constants.PREFIX.CACHE}/hit|memory|${resType}|${filename}`;color=_constants.COLOR.PRIMARY;detail={url,source:"memory",resourceType:resType,durationMs,thread:thread??null,interceptThread,emitThread,simulatorValid:false};}else if(type==="cache-hit-disk"){measureName=`${_constants.PREFIX.CACHE}/hit|disk|${resType}|${filename}`;color=_constants.COLOR.PRIMARY_LIGHT;detail={url,source:"disk",resourceType:resType,durationMs,thread:thread??null,interceptThread,emitThread,simulatorValid:false};}else if(type==="cache-miss-fetch"){measureName=`${_constants.PREFIX.CACHE}/miss|${resType}|${filename}`;color=_constants.COLOR.ERROR;detail={url,resourceType:resType,durationMs,thread:thread??null,interceptThread,emitThread,simulatorValid:false};}else if(type==="network-fetch-complete"){const slow=(durationMs??0)>_constants.THRESHOLD.FETCH_SLOW_MS;measureName=`${_constants.PREFIX.CACHE}/fetch|${resType}|${filename}`;color=slow?_constants.COLOR.TERTIARY_DARK:_constants.COLOR.TERTIARY;detail={url,resourceType:resType,durationMs,statusCode:statusCode??null,thread:thread??null,emitThread,slow,simulatorValid:false};}else{return;}const startMark=`${measureName}:start:${Math.round(startTime)}`;performance.mark(startMark,{startTime});this._measure.emit(measureName,startMark,endTime,detail,track,color);}_emitSummarySpan(event){const{hits,misses,fetches,total,hitRatePct,avgFetchMs,topSlowest,nativeTime}=event;if(total===0)return;// Place summary span at current time (post-load, idle phase)
+const startTime=this._nativeToWeb(nativeTime??0)||performance.now();const endTime=startTime+1;// point span
+const color=hitRatePct>=80?_constants.COLOR.PRIMARY_DARK:hitRatePct>=50?_constants.COLOR.SECONDARY:_constants.COLOR.ERROR;const topNames=Array.isArray(topSlowest)?topSlowest.map(e=>`${e.filename}(${e.durationMs}ms)`).join(", "):"";const measureName=`${_constants.PREFIX.CACHE}/summary`;const startMark=`${measureName}:start:${Math.round(startTime)}`;performance.mark(startMark,{startTime});this._measure.emit(measureName,startMark,endTime,{hits,misses,fetches,total,hitRatePct,avgFetchMs,topSlowest:topNames,simulatorValid:false},_constants.TRACK.CACHE,color);// Notify InsightsCollector so it can flag low hit rates
+this._notifyInsights?.({hitRatePct,total,avgFetchMs,startTime,endTime});}_filename(url){try{const path=new URL(url).pathname;const name=path.split("/").filter(Boolean).pop()??path;return name.slice(0,40);}catch{return String(url).slice(0,40);}}}exports.CacheCollector=CacheCollector;

package/dist/native/bridge/perf/collectors/HookCollector.js

@@ -0,0 +1,43 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.HookCollector=void 0;var _constants=require("../core/constants.js");/**
+ * HookCollector.js — Option A (symptom detection only)
+ *
+ * Instruments: bugs #13, #15, #16
+ *   #13 cart computation loop jank    → LoAF bursts sustained over time, not tied to a single interaction
+ *                                       detected as: LoAF count > threshold within a rolling window
+ *   #15 quantity selector slow first  → interaction → first LoAF burst → long gap → paint
+ *                                       detected as: LoAF fires within LAZY_LOAF_WINDOW_MS after tap
+ *   #16 prescription screen touch lag → same pattern as #15
+ *
+ * Option A strategy (no React hooks needed):
+ *   - Watch for LoAF bursts within 2s of a pointerdown (taps that might trigger lazy load)
+ *   - If LoAF count > 0 in that window → emit hook/lazy span showing the blocked period
+ *   - Sustained LoAF (3+ frames in 5s with no user interaction) → emit hook/mount span
+ *     flagging a background computation loop
+ *
+ * Spans emitted:
+ *   catalyst:hook/lazy|<label>    — LoAF burst after interaction (Track: Hook)
+ *                                   detail: loafCount, totalBlockingMs, triggerTarget
+ *   catalyst:hook/mount|loop      — sustained background LoAF (Track: Hook)
+ *                                   detail: loafCount, windowMs, likelyCause='computation-loop'
+ *
+ * TODO (Option B — future):
+ *   Expose window.catalyst.markComponentMount(name) / markComponentReady(name)
+ *   for precise hook-lifecycle spans without symptom inference.
+ */const LOOP_LOAF_COUNT=3;// ≥3 LoAFs in the loop window = computation loop
+const LOOP_WINDOW_MS=5000;// rolling window to count sustained LoAFs
+class HookCollector{constructor(measure){this._measure=measure;// Lazy-load detection state
+this._pendingLazy=null;// { startMark, startTime, target, loafCount, totalBlocking, timer }
+// Computation loop detection state
+this._loopLoafs=[];// [{ start, end }] in rolling LOOP_WINDOW_MS window
+}init(){// Watch for taps that might trigger lazy component loads
+document.addEventListener("pointerdown",this._onPointerDown.bind(this),{passive:true});}/** Called by index.js to feed the normalized perf store. */setWaterfallSource(fn){this._notifyWaterfall=fn;}// Called by RenderCollector via addLoafListener() on every LoAF
+onLoaf(start,end){// ── Lazy-load window ────────────────────────────────────────────────
+if(this._pendingLazy){const p=this._pendingLazy;p.loafCount++;p.totalBlocking+=end-start;// Reset the close timer — extend window on each LoAF
+clearTimeout(p.timer);p.timer=setTimeout(()=>this._closeLazySpan(),_constants.THRESHOLD.LAZY_LOAF_WINDOW_MS);}// ── Computation loop detection ───────────────────────────────────────
+const now=performance.now();this._loopLoafs.push({start,end});// Evict entries outside the rolling window
+this._loopLoafs=this._loopLoafs.filter(e=>now-e.start<LOOP_WINDOW_MS);if(this._loopLoafs.length>=LOOP_LOAF_COUNT){this._emitLoopSpan();this._loopLoafs=[];// reset after emitting to avoid duplicate spans
+}}// ─── Lazy-load span ───────────────────────────────────────────────────────
+_onPointerDown(e){// If a lazy span is already open, let it close naturally
+if(this._pendingLazy)return;const target=e.target?.tagName?.toLowerCase()??"unknown";const startTime=performance.now();const startMark=`${_constants.PREFIX.HOOK_LAZY}:start:${Math.round(startTime)}`;performance.mark(startMark,{startTime});const timer=setTimeout(()=>this._closeLazySpan(),_constants.THRESHOLD.LAZY_LOAF_WINDOW_MS);this._pendingLazy={startMark,startTime,target,loafCount:0,totalBlocking:0,timer};}_closeLazySpan(){const p=this._pendingLazy;if(!p)return;this._pendingLazy=null;clearTimeout(p.timer);// Only emit if LoAF actually fired — otherwise it was a clean interaction
+if(p.loafCount===0)return;const endTime=performance.now();this._measure.emit(`${_constants.PREFIX.HOOK_LAZY}|${p.target}`,p.startMark,endTime,{loafCount:p.loafCount,totalBlockingMs:Math.round(p.totalBlocking),triggerTarget:p.target,likelyCause:"lazy-load",simulatorValid:false},_constants.TRACK.HOOK);this._notifyWaterfall?.({hookType:"lazy-load",label:`Hook lazy-load ${p.target}`,startTime:p.startTime,endTime,durationMs:Math.round(endTime-p.startTime),loafCount:p.loafCount,totalBlockingMs:Math.round(p.totalBlocking),likelyCause:"lazy-load"});}// ─── Computation loop span ────────────────────────────────────────────────
+_emitLoopSpan(){const first=this._loopLoafs[0];const last=this._loopLoafs[this._loopLoafs.length-1];const markName=`${_constants.PREFIX.HOOK_MOUNT}:loop:${Math.round(first.start)}`;performance.mark(markName,{startTime:first.start});const totalBlocking=this._loopLoafs.reduce((sum,e)=>sum+(e.end-e.start),0);this._measure.emit(`${_constants.PREFIX.HOOK_MOUNT}|loop`,markName,last.end,{loafCount:this._loopLoafs.length,windowMs:Math.round(last.end-first.start),totalBlockingMs:Math.round(totalBlocking),likelyCause:"computation-loop",simulatorValid:false},_constants.TRACK.HOOK);this._notifyWaterfall?.({hookType:"computation-loop",label:"Hook computation loop",startTime:first.start,endTime:last.end,durationMs:Math.round(last.end-first.start),loafCount:this._loopLoafs.length,totalBlockingMs:Math.round(totalBlocking),likelyCause:"computation-loop"});}}exports.HookCollector=HookCollector;

package/dist/native/bridge/perf/collectors/InsightsCollector.js

@@ -0,0 +1,47 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.InsightsCollector=void 0;var _constants=require("../core/constants.js");/**
+ * InsightsCollector.js
+ *
+ * Watches accumulated perf data and emits actionable warnings to the
+ * Catalyst > Insights track in Chrome DevTools.
+ *
+ * Each insight is a point-in-time span with:
+ *   - severity: 'critical' | 'warning' | 'info'
+ *   - rule:     short machine-readable id (e.g. 'slow-page-load')
+ *   - message:  one-sentence human diagnosis
+ *   - fix:      immediate actionable recommendation
+ *   - evidence: the numbers that triggered the rule
+ *
+ * Insights are emitted in two modes:
+ *   1. Reactive — emitted immediately when a threshold breach is detected
+ *      (e.g. an fps-drop episode during interaction)
+ *   2. Summary — emitted once after SESSION_SUMMARY_DELAY_MS of inactivity
+ *      to give a rolled-up view of what happened in the last session
+ *
+ * How to read this in DevTools:
+ *   Performance tab → Catalyst > Insights track
+ *   Click any span → Tooltip shows: severity, rule, message, fix, evidence
+ *   Red spans = critical (user-visible jank/failure)
+ *   Yellow (tertiary) = warning
+ *   Blue (secondary) = info / optimization opportunity
+ */const SESSION_SUMMARY_DELAY_MS=3000;function round(value){return Number.isFinite(value)?Math.round(value):value;}class InsightsCollector{constructor(measure){this._measure=measure;this._summaryTimer=null;this._insightSeq=0;// Counters reset per session
+this._fpsDrops=[];// [{ minFps, durationMs }]
+this._slowLoads=[];// [{ url, durationMs }]
+this._loafsDuringNav=0;this._slowInteractions=[];// [{ target, responseMs }]
+this._highMemory=[];// [{ currentMb }]
+this._layoutShifts=[];// [{ value }]
+this._coldStartMs=null;// always attached to other insights once known
+}init(){// No web observers — fed via notify*() methods from index.js
+}setStoreSource(fn){this._notifyStore=fn;}// ─── Feed methods — called by index.js after routing native events ─────────
+notifyFpsDrop({minFps,avgFps,durationMs,duringInteraction,deltaFps,baselineFps,startTime,endTime,interactionId}){const source={startTime,endTime,related:{interactionId}};this._fpsDrops.push({minFps,durationMs});if(duringInteraction){this._emitReactive({severity:"critical",rule:"fps-drop-during-tap",message:`FPS dropped to ${minFps.toFixed(1)} for ${Math.round(durationMs)}ms right after a tap`,fix:"Heavy computation is blocking the render thread after interaction — compare spans with the same interaction ID",evidence:{minFps,avgFps,durationMs,deltaFps,baselineFps},...source});}else if(minFps<30){this._emitReactive({severity:"warning",rule:"severe-fps-drop",message:`Severe FPS drop: ${minFps.toFixed(1)}fps min for ${Math.round(durationMs)}ms`,fix:"Look for LoAF spans overlapping this window on the Render track — a long script or layout is stalling frames",evidence:{minFps,avgFps,durationMs,deltaFps,baselineFps},...source});}else if(deltaFps!=null&&deltaFps>=10){// Sudden spike: FPS fell sharply even if absolute value is not critical
+this._emitReactive({severity:"warning",rule:"fps-spike-drop",message:`Sudden FPS spike: dropped ${deltaFps.toFixed(1)}fps (${baselineFps?.toFixed(1)} → ${minFps.toFixed(1)}) in one frame window`,fix:"A sudden spike drop — often a one-off heavy layout or image decode. Check Render track for a LoAF aligned with this episode.",evidence:{minFps,avgFps,durationMs,deltaFps,baselineFps},...source});}this._scheduleSummary();}notifySlowLoad({url,durationMs,startTime,endTime}){this._slowLoads.push({url,durationMs});if(durationMs>4000){this._emitReactive({severity:"critical",rule:"page-load-too-slow",message:`Page load took ${Math.round(durationMs)}ms (${url.split("/").pop()||url})`,fix:"Check Cache track for cache-miss-fetch bursts; consider preloading route chunks or warming the WebView cache",evidence:{url,durationMs},startTime,endTime});}this._scheduleSummary();}notifyColdStart({durationMs,startTime,endTime}){this._coldStartMs=durationMs;// attach to all future insights automatically
+const severity=durationMs>3000?"critical":durationMs>1800?"warning":"info";const label=durationMs>3000?"slow":durationMs>1800?"acceptable":"fast";this._emitReactive({severity,rule:"cold-start-time",message:`Cold start: ${Math.round(durationMs)}ms (${label}) — app launched to first page finish`,fix:durationMs>3000?"Cold start >3s — check if WebView.loadUrl() is called before layout inflation completes; defer non-critical MainActivity init; consider prewarming WebView in Application.onCreate()":durationMs>1800?"Cold start >1.8s — consider moving WebView construction earlier (Application.onCreate vs MainActivity.onCreate); check if large local assets block onPageFinished":"Cold start within target (≤1.8s). No action needed.",evidence:{durationMs,targetMs:1800,acceptableMs:3000},startTime,endTime});}notifyLoafDuringNav({durationMs,startTime,endTime}){this._loafsDuringNav++;if(this._loafsDuringNav===1){this._emitReactive({severity:"warning",rule:"loaf-blocking-nav",message:`Long animation frame (${Math.round(durationMs)}ms) fired during navigation — may cause blank screen`,fix:"Defer non-critical JS execution after page-load-end; split large bundles with dynamic import()",evidence:{durationMs,loafsDuringNav:this._loafsDuringNav},startTime,endTime});}}notifySlowInteraction({target,responseMs,startTime,endTime,interactionId}){this._slowInteractions.push({target,responseMs});if(responseMs>300){this._emitReactive({severity:"critical",rule:"interaction-unresponsive",message:`Tap on '${target}' took ${responseMs}ms to paint (threshold ${_constants.THRESHOLD.INTERACTION_SLOW_MS}ms)`,fix:"A LoAF is delaying the paint — inspect work overlapping the interaction",evidence:{target,responseMs,thresholdMs:_constants.THRESHOLD.INTERACTION_SLOW_MS},startTime,endTime,related:{interactionId}});}this._scheduleSummary();}notifyHighMemory({currentMb,startTime,endTime,memoryId}){const source={startTime,endTime,related:{memoryId}};// currentMb is webviewMb (V8 + Blink + JNI PSS) — the WebView engine memory.
+// A healthy WebView app idles at 80-120MB. Growth beyond that signals
+// a real leak (un-released image bitmaps, accumulating JS closures, JNI objects).
+// Thresholds are intentionally higher than total-PSS thresholds used previously
+// because we now track the native slice, not the whole process.
+this._highMemory.push({currentMb});if(currentMb>120){this._emitReactive({severity:"critical",rule:"memory-critical",message:`WebView memory at ${Math.round(currentMb)}MB — above 120MB critical threshold (V8/Blink/JNI leak likely)`,fix:"Check for un-released image bitmaps, accumulating JS closures, or JNI objects not returned to GC. Compare WebView memory growth across snapshots on the Memory track.",evidence:{webviewMb:currentMb},...source});}else if(currentMb>80){this._emitReactive({severity:"warning",rule:"memory-high",message:`WebView memory at ${Math.round(currentMb)}MB — above 80MB warning threshold (healthy idle is <80MB)`,fix:"Monitor WebView memory on the Memory track — sustained growth = leak. Check image cache eviction and dispose WebView listeners on route unmount.",evidence:{webviewMb:currentMb},...source});}}notifyHwAccelDuringFrame({durationMs,thread,trigger,startTime,endTime}){this._emitReactive({severity:"critical",rule:"hw-accel-during-frame",message:`Software rendering was active for ${Math.round(durationMs)}ms during a dropped frame (hw-accel disabled by ${trigger??"cache-serve"})`,fix:"Cache serving on shouldInterceptRequest disables hardware acceleration — move cache I/O off the WebView thread or batch cache warming on app start to reduce mid-session hw-accel toggles",evidence:{durationMs,thread:thread??"unknown",trigger:trigger??"unknown"},startTime,endTime});}notifyLayoutShift({value,sessionContext,startTime,endTime}){this._layoutShifts.push({value});if(value>0.25){this._emitReactive({severity:"warning",rule:"large-layout-shift",message:`Large layout shift (CLS ${value.toFixed(3)}) during '${sessionContext}' phase`,fix:"Reserve space for async-loaded content (images, ads, banners) using explicit height; avoid injecting DOM above visible content",evidence:{value,sessionContext},startTime,endTime});}}notifyScrollJank({minFps,frameDropCount,startTime,endTime}){const severity=minFps<30?"critical":"warning";const rule=minFps<30?"scroll-jank-critical":"scroll-jank-warning";this._emitReactive({severity,rule,message:`Scroll jank: ${Math.round(frameDropCount)} frame drop(s), min ${minFps.toFixed(1)}fps during scroll`,fix:minFps<30?"Severe scroll jank — check for layout thrash triggered during scroll. Look for LoAF spans on Render track overlapping the Input track scroll session.":"Scroll dropped below 55fps — common causes: sticky header recalc, cart badge updates, or image decode on scroll. Check Render track LoAF spans inside the scroll session.",evidence:{minFps,frameDropCount},startTime,endTime});this._scheduleSummary();}notifyCacheSummary({hitRatePct,total,avgFetchMs,startTime,endTime}){if(total<5)return;// not enough data
+if(hitRatePct<50){this._emitReactive({severity:"warning",rule:"low-cache-hit-rate",message:`Cache hit rate ${hitRatePct}% (${total} resources) — majority served via network`,fix:"Add missed URLs to the allowedUrls cache list; check cache max-age and disk eviction policy",evidence:{hitRatePct,total,avgFetchMs},startTime,endTime});}}// ─── Reactive insight emission ─────────────────────────────────────────────
+_emitReactive({severity,rule,message,fix,evidence={},startTime,endTime,related={}}){const start=Number.isFinite(startTime)?startTime:performance.now();const end=Number.isFinite(endTime)?Math.max(start+1,endTime):start+2;const markName=`${_constants.PREFIX.INSIGHT}:${rule}:${Math.round(start)}:${++this._insightSeq}`;const color=severity==="critical"?"error":severity==="warning"?"tertiary":"secondary";const title=this._titleFor(rule,evidence,message);const category=this._categoryFor(rule);const detail={severity,rule,title,category,message,fix,...related,...(this._coldStartMs!=null?{"coldStart.ms":String(Math.round(this._coldStartMs))}:{}),...Object.fromEntries(Object.entries(evidence).filter(([,value])=>value!=null).map(([key,value])=>[`evidence.${key}`,String(value)]))};performance.mark(markName,{startTime:start});this._notifyStore?.({severity,rule,title,category,message,fix,evidence,...related,startTime:start,endTime:end,durationMs:end-start});this._measure.emit(`${related.interactionId?`[${related.interactionId}] `:""}Insight: ${title}`,markName,end,detail,_constants.TRACK.INSIGHTS,color);}_titleFor(rule,evidence,message){switch(rule){case"fps-drop-during-tap":return`FPS drop after tap: ${round(evidence.minFps)}fps`;case"severe-fps-drop":return`FPS drop: ${round(evidence.minFps)}fps for ${round(evidence.durationMs)}ms`;case"fps-spike-drop":return`FPS spike drop: -${round(evidence.deltaFps)}fps`;case"page-load-too-slow":return`Page load slow: ${round(evidence.durationMs)}ms`;case"cold-start-time":return`Cold start: ${round(evidence.durationMs)}ms`;case"loaf-blocking-nav":return`Render blocked during navigation: ${round(evidence.durationMs)}ms`;case"interaction-unresponsive":return`Slow tap: ${evidence.target??"unknown"} ${round(evidence.responseMs)}ms`;case"memory-critical":case"memory-high":return`Memory high: ${round(evidence.webviewMb)}MB`;case"hw-accel-during-frame":return`Software render window: ${round(evidence.durationMs)}ms`;case"large-layout-shift":return`Large layout shift: ${Number.isFinite(evidence.value)?evidence.value.toFixed(3):"unknown"}`;case"scroll-jank-critical":case"scroll-jank-warning":return`Scroll jank: ${round(evidence.minFps)}fps`;case"low-cache-hit-rate":return`Cache hit rate low: ${evidence.hitRatePct}%`;case"session-summary":return"Session issues";default:return message??rule;}}_categoryFor(rule){if(rule.includes("fps")||rule.includes("loaf")||rule.includes("layout"))return"render";if(rule.includes("page-load")||rule.includes("cold-start"))return"navigation";if(rule.includes("interaction")||rule.includes("tap"))return"interaction";if(rule.includes("memory"))return"memory";if(rule.includes("scroll"))return"scroll";if(rule.includes("cache"))return"cache";if(rule.includes("session"))return"session";return"general";}// ─── Session summary ───────────────────────────────────────────────────────
+// Emitted after SESSION_SUMMARY_DELAY_MS of quiet — a rolled-up health check.
+_scheduleSummary(){if(this._summaryTimer)clearTimeout(this._summaryTimer);this._summaryTimer=setTimeout(()=>this._emitSummary(),SESSION_SUMMARY_DELAY_MS);}_emitSummary(){this._summaryTimer=null;const problems=[];if(this._fpsDrops.length>0)problems.push(`${this._fpsDrops.length} fps-drop episode(s), min ${Math.min(...this._fpsDrops.map(f=>f.minFps)).toFixed(0)}fps`);if(this._slowLoads.length>0)problems.push(`${this._slowLoads.length} slow page load(s)`);if(this._slowInteractions.length>0)problems.push(`${this._slowInteractions.length} slow tap(s)`);if(this._highMemory.length>0)problems.push(`peak ${Math.max(...this._highMemory.map(m=>m.currentMb)).toFixed(0)}MB memory`);const severity=this._fpsDrops.some(f=>f.minFps<20)?"critical":problems.length>2?"warning":"info";const message=problems.length===0?"Session clean — no threshold breaches detected":`Session issues: ${problems.join(" · ")}`;const fix=problems.length===0?"No action needed":"Expand each red/yellow span above for per-issue fixes";this._emitReactive({severity:severity==="info"?"info":severity,rule:"session-summary",message,fix,evidence:{fpsDropEpisodes:this._fpsDrops.length,slowPageLoads:this._slowLoads.length,slowInteractions:this._slowInteractions.length,highMemoryReadings:this._highMemory.length,layoutShifts:this._layoutShifts.length}});// Reset counters for next session
+this._fpsDrops=[];this._slowLoads=[];this._loafsDuringNav=0;this._slowInteractions=[];this._highMemory=[];this._layoutShifts=[];}}exports.InsightsCollector=InsightsCollector;