@rejourneyco/react-native 1.0.7 → 1.0.8

package/android/src/main/java/com/rejourney/recording/VisualCapture.kt

@@ -26,7 +26,9 @@ import android.graphics.Rect
 import android.os.Handler
 import android.os.Looper
 import android.os.SystemClock
+import android.view.TextureView
 import android.view.View
+import android.view.ViewGroup
 import android.view.WindowManager
 import com.rejourney.engine.DiagnosticLog
 import com.rejourney.utility.gzipCompress
@@ -60,7 +62,7 @@ class VisualCapture private constructor(private val context: Context) {
             get() = instance
     }
     
-    var snapshotInterval: Double = 0.5
+    var snapshotInterval: Double = 1.0
     var quality: Float = 0.5f
     
     val isCapturing: Boolean
@@ -91,18 +93,17 @@ class VisualCapture private constructor(private val context: Context) {
     
     // Current activity reference
     private var currentActivity: WeakReference<Activity>? = null
+
     
     fun setCurrentActivity(activity: Activity?) {
         currentActivity = if (activity != null) WeakReference(activity) else null
-        DiagnosticLog.notice("[VisualCapture] setCurrentActivity: ${activity?.javaClass?.simpleName ?: "null"}")
+        DiagnosticLog.trace("[VisualCapture] setCurrentActivity: ${activity?.javaClass?.simpleName ?: "null"}")
     }
     
     fun beginCapture(sessionOrigin: Long) {
-        DiagnosticLog.notice("[VisualCapture] beginCapture called, currentActivity=${currentActivity?.get()?.javaClass?.simpleName ?: "null"}, state=${stateMachine.currentState}")
-        DiagnosticLog.trace("[VisualCapture] beginCapture called, currentActivity=${currentActivity?.get()?.javaClass?.simpleName ?: "null"}")
+        DiagnosticLog.trace("[VisualCapture] beginCapture called, currentActivity=${currentActivity?.get()?.javaClass?.simpleName ?: "null"}, state=${stateMachine.currentState}")
         if (!stateMachine.transition(CaptureState.CAPTURING)) {
-            DiagnosticLog.notice("[VisualCapture] beginCapture REJECTED - state transition failed from ${stateMachine.currentState}")
-            DiagnosticLog.trace("[VisualCapture] beginCapture failed - state transition rejected")
+            DiagnosticLog.trace("[VisualCapture] beginCapture REJECTED - state transition failed from ${stateMachine.currentState}")
             return
         }
         sessionEpoch = sessionOrigin
@@ -116,7 +117,6 @@ class VisualCapture private constructor(private val context: Context) {
             }
         }
         
-        DiagnosticLog.notice("[VisualCapture] Starting capture timer with interval=${snapshotInterval}s")
         DiagnosticLog.trace("[VisualCapture] Starting capture timer with interval=${snapshotInterval}s")
         startCaptureTimer()
     }
@@ -138,6 +138,21 @@ class VisualCapture private constructor(private val context: Context) {
         flushBufferToDisk()
     }
     
+    /** Submit any buffered frames to the upload pipeline immediately
+     *  (regardless of batch size threshold). Packages synchronously to
+     *  avoid race conditions during backgrounding. */
+    fun flushBufferToNetwork() {
+        // Take frames from buffer synchronously (not via async sendScreenshots)
+        val images = stateLock.withLock {
+            val copy = screenshots.toList()
+            screenshots.clear()
+            copy
+        }
+        if (images.isEmpty()) return
+        // Package and submit synchronously on this thread
+        packageAndShip(images, sessionEpoch)
+    }
+    
     fun activateDeferredMode() {
         deferredUntilCommit = true
     }
@@ -165,14 +180,14 @@ class VisualCapture private constructor(private val context: Context) {
     }
     
     fun snapshotNow() {
-        mainHandler.post { captureFrame() }
+        mainHandler.post { captureFrame(force = true) }
     }
     
     private fun startCaptureTimer() {
         stopCaptureTimer()
         captureRunnable = object : Runnable {
             override fun run() {
-                captureFrame()
+                captureFrame(force = false)
                 mainHandler.postDelayed(this, (snapshotInterval * 1000).toLong())
             }
         }
@@ -184,32 +199,43 @@ class VisualCapture private constructor(private val context: Context) {
         captureRunnable = null
     }
     
-    private fun captureFrame() {
+    private fun captureFrame(force: Boolean = false) {
         val currentFrameNum = frameCounter.get()
-        // Log first 3 frames at notice level
         if (currentFrameNum < 3) {
-            DiagnosticLog.notice("[VisualCapture] captureFrame #$currentFrameNum, state=${stateMachine.currentState}, activity=${currentActivity?.get()?.javaClass?.simpleName ?: "null"}")
+            DiagnosticLog.trace("[VisualCapture] captureFrame #$currentFrameNum, state=${stateMachine.currentState}, activity=${currentActivity?.get()?.javaClass?.simpleName ?: "null"}")
         }
         
         if (stateMachine.currentState != CaptureState.CAPTURING) {
-            DiagnosticLog.notice("[VisualCapture] captureFrame skipped - state=${stateMachine.currentState}")
             DiagnosticLog.trace("[VisualCapture] captureFrame skipped - state=${stateMachine.currentState}")
             return
         }
         
         val activity = currentActivity?.get()
         if (activity == null) {
-            if (currentFrameNum < 3) {
-                DiagnosticLog.notice("[VisualCapture] captureFrame skipped - NO ACTIVITY")
-            }
             DiagnosticLog.trace("[VisualCapture] captureFrame skipped - no activity")
             return
         }
         
+        // Refresh map detection state (very cheap shallow walk)
+        SpecialCases.shared.refreshMapState(activity)
+        
+        // Map stutter prevention: when a map view is visible and its camera
+        // is still moving (user gesture or animation), skip decorView.draw()
+        // entirely — this call triggers GPU readback on SurfaceView/TextureView
+        // map tiles which causes visible stutter.  We resume capture at 1 FPS
+        // once the map SDK reports idle.
+        if (!force && SpecialCases.shared.mapVisible && !SpecialCases.shared.mapIdle) {
+            if (currentFrameNum < 3 || currentFrameNum % 30 == 0L) {
+                DiagnosticLog.trace("[VisualCapture] SKIPPING capture - map moving (mapIdle=false)")
+            }
+            return
+        }
+        
         val frameStart = SystemClock.elapsedRealtime()
         
         try {
-            val decorView = activity.window?.decorView ?: return
+            val window = activity.window ?: return
+            val decorView = window.decorView
             val bounds = Rect()
             decorView.getWindowVisibleDisplayFrame(bounds)
             
@@ -217,68 +243,134 @@ class VisualCapture private constructor(private val context: Context) {
             
             val redactRects = redactionMask.computeRects()
             
-            // Use lower scale to reduce encoding time significantly
             val screenScale = 1.25f
             val scaledWidth = (bounds.width() / screenScale).toInt()
             val scaledHeight = (bounds.height() / screenScale).toInt()
             
+            // 1. Draw the View tree (captures everything except GPU surfaces)
             val bitmap = Bitmap.createBitmap(scaledWidth, scaledHeight, Bitmap.Config.ARGB_8888)
             val canvas = Canvas(bitmap)
             canvas.scale(1f / screenScale, 1f / screenScale)
-            
             decorView.draw(canvas)
             
-            // Apply redactions
-            if (redactRects.isNotEmpty()) {
-                val paint = Paint().apply {
-                    color = Color.BLACK
-                    style = Paint.Style.FILL
-                }
-                for (rect in redactRects) {
-                    if (rect.width() > 0 && rect.height() > 0) {
-                        canvas.drawRect(
-                            rect.left / screenScale,
-                            rect.top / screenScale,
-                            rect.right / screenScale,
-                            rect.bottom / screenScale,
-                            paint
-                        )
-                    }
-                }
-            }
-            
-            // Compress to JPEG
-            val stream = ByteArrayOutputStream()
-            bitmap.compress(Bitmap.CompressFormat.JPEG, (quality * 100).toInt(), stream)
-            bitmap.recycle()
+            // 2. Composite GPU surfaces (TextureView/SurfaceView) on top.
+            //    decorView.draw() renders these as black; we grab their pixels
+            //    directly and paint them at the correct position.
+            compositeGpuSurfaces(decorView, canvas, screenScale)
             
-            val data = stream.toByteArray()
-            val captureTs = System.currentTimeMillis()
-            val frameNum = frameCounter.incrementAndGet()
+            processCapture(bitmap, redactRects, screenScale, frameStart, force)
             
-            // Log first frame and every 30 frames
-            if (frameNum == 1L) {
-                DiagnosticLog.notice("[VisualCapture] First frame captured! size=${data.size} bytes")
+        } catch (e: Exception) {
+            DiagnosticLog.fault("Frame capture failed: ${e.message}")
+        }
+    }
+    
+    /**
+     * Find all TextureView instances in the hierarchy and draw their GPU-rendered
+     * content onto the capture canvas at the correct position.  decorView.draw()
+     * renders TextureView/SurfaceView as black; this fills in the actual pixels.
+     *
+     * Mapbox uses SurfaceView by default, so we use MapView.snapshot() to capture
+     * the map and composite it at the correct position.
+     */
+    private fun compositeGpuSurfaces(root: View, canvas: Canvas, screenScale: Float) {
+        findTextureViews(root) { tv ->
+            try {
+                val tvBitmap = tv.bitmap ?: return@findTextureViews
+                val loc = IntArray(2)
+                tv.getLocationInWindow(loc)
+                canvas.drawBitmap(tvBitmap, loc[0].toFloat(), loc[1].toFloat(), null)
+                tvBitmap.recycle()
+            } catch (_: Exception) {
+                // Safety: never crash if TextureView.getBitmap() fails
+            }
+        }
+        compositeMapboxSnapshot(root, canvas)
+    }
+
+    /**
+     * Mapbox MapView uses SurfaceView; decorView.draw() renders it black.
+     * Use MapView.snapshot() (Mapbox SDK API) to capture the map and composite it.
+     */
+    private fun compositeMapboxSnapshot(root: View, canvas: Canvas) {
+        val mapView = SpecialCases.shared.getMapboxMapViewForSnapshot(root) ?: return
+        try {
+            val snapshot = mapView.javaClass.getMethod("snapshot").invoke(mapView)
+            val bitmap = snapshot as? Bitmap ?: return
+            val loc = IntArray(2)
+            mapView.getLocationInWindow(loc)
+            canvas.drawBitmap(bitmap, loc[0].toFloat(), loc[1].toFloat(), null)
+            bitmap.recycle()
+        } catch (e: Exception) {
+            DiagnosticLog.trace("[VisualCapture] Mapbox snapshot failed: ${e.message}")
+        }
+    }
+    
+    private fun findTextureViews(view: View, action: (TextureView) -> Unit) {
+        if (view is TextureView && view.isAvailable) {
+            action(view)
+        }
+        if (view is ViewGroup) {
+            for (i in 0 until view.childCount) {
+                findTextureViews(view.getChildAt(i), action)
             }
-            if (frameNum % 30 == 0L) {
-                val frameDurationMs = (SystemClock.elapsedRealtime() - frameStart).toDouble()
-                val isMainThread = Looper.myLooper() == Looper.getMainLooper()
-                DiagnosticLog.perfFrame("screenshot", frameDurationMs, frameNum.toInt(), isMainThread)
+        }
+    }
+    
+    private fun processCapture(
+        bitmap: Bitmap,
+        redactRects: List<Rect>,
+        screenScale: Float,
+        frameStart: Long,
+        force: Boolean
+    ) {
+        // Apply redactions
+        if (redactRects.isNotEmpty()) {
+            val canvas = Canvas(bitmap)
+            val paint = Paint().apply {
+                color = Color.BLACK
+                style = Paint.Style.FILL
             }
-            
-            // Store in buffer
-            stateLock.withLock {
-                screenshots.add(Pair(data, captureTs))
-                enforceScreenshotCaps()
-                val shouldSend = !deferredUntilCommit && screenshots.size >= batchSize
-                
-                if (shouldSend) {
-                    sendScreenshots()
+            for (rect in redactRects) {
+                if (rect.width() > 0 && rect.height() > 0) {
+                    canvas.drawRect(
+                        rect.left / screenScale,
+                        rect.top / screenScale,
+                        rect.right / screenScale,
+                        rect.bottom / screenScale,
+                        paint
+                    )
                 }
             }
+        }
+        
+        // Compress to JPEG
+        val stream = ByteArrayOutputStream()
+        bitmap.compress(Bitmap.CompressFormat.JPEG, (quality * 100).toInt(), stream)
+        bitmap.recycle()
+        
+        val data = stream.toByteArray()
+        val captureTs = System.currentTimeMillis()
+        val frameNum = frameCounter.incrementAndGet()
+        
+        if (frameNum == 1L) {
+            DiagnosticLog.trace("[VisualCapture] First frame captured! size=${data.size} bytes")
+        }
+        if (frameNum % 30 == 0L) {
+            val frameDurationMs = (SystemClock.elapsedRealtime() - frameStart).toDouble()
+            val isMainThread = Looper.myLooper() == Looper.getMainLooper()
+            DiagnosticLog.perfFrame("screenshot", frameDurationMs, frameNum.toInt(), isMainThread)
+        }
+        
+        // Store in buffer
+        stateLock.withLock {
+            screenshots.add(Pair(data, captureTs))
+            enforceScreenshotCaps()
+            val shouldSend = !deferredUntilCommit && screenshots.size >= batchSize
             
-        } catch (e: Exception) {
-            DiagnosticLog.fault("Frame capture failed: ${e.message}")
+            if (shouldSend) {
+                sendScreenshots()
+            }
         }
     }
     
@@ -302,7 +394,7 @@ class VisualCapture private constructor(private val context: Context) {
             return
         }
         
-        DiagnosticLog.notice("[VisualCapture] sendScreenshots: sending ${images.size} frames")
+        DiagnosticLog.trace("[VisualCapture] sendScreenshots: sending ${images.size} frames")
         
         // All heavy work happens in background
         encodeExecutor.execute {

package/ios/Engine/RejourneyImpl.swift

@@ -609,7 +609,7 @@ public final class RejourneyImpl: NSObject {
         resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
     ) {
-        DiagnosticLog.notice("[Rejourney] setRemoteConfig: rejourneyEnabled=\(rejourneyEnabled), recordingEnabled=\(recordingEnabled), sampleRate=\(sampleRate), maxRecording=\(maxRecordingMinutes)min")
+        DiagnosticLog.trace("[Rejourney] setRemoteConfig: rejourneyEnabled=\(rejourneyEnabled), recordingEnabled=\(recordingEnabled), sampleRate=\(sampleRate), maxRecording=\(maxRecordingMinutes)min")
         
         ReplayOrchestrator.shared.setRemoteConfig(
             rejourneyEnabled: rejourneyEnabled,
@@ -631,23 +631,8 @@ public final class RejourneyImpl: NSObject {
         resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
     ) {
-        resolve([
-            "uploadSuccessCount": 0,
-            "uploadFailureCount": 0,
-            "retryAttemptCount": 0,
-            "circuitBreakerOpenCount": 0,
-            "memoryEvictionCount": 0,
-            "offlinePersistCount": 0,
-            "sessionStartCount": (ReplayOrchestrator.shared.replayId != nil) ? 1 : 0,
-            "crashCount": 0,
-            "uploadSuccessRate": 1.0,
-            "avgUploadDurationMs": 0.0,
-            "currentQueueDepth": 0,
-            "lastUploadTime": NSNull(),
-            "lastRetryTime": NSNull(),
-            "totalBytesUploaded": 0,
-            "totalBytesEvicted": 0
-        ])
+        let queueDepth = TelemetryPipeline.shared.getQueueDepth()
+        resolve(SegmentDispatcher.shared.sdkTelemetrySnapshot(currentQueueDepth: queueDepth))
     }
     
     @objc(getDeviceInfo:reject:)

package/ios/Recording/InteractionRecorder.swift

@@ -28,6 +28,7 @@ public final class InteractionRecorder: NSObject {
     private var _inputObservers = NSMapTable<UITextField, AnyObject>.weakToStrongObjects()
     private var _navigationStack: [String] = []
     private let _coalesceWindow: TimeInterval = 0.3
+    private var _lastInteractionTimestampMs: UInt64 = 0
     
     private override init() {
         super.init()
@@ -48,6 +49,11 @@ public final class InteractionRecorder: NSObject {
         _gestureAggregator = nil
         _inputObservers.removeAllObjects()
         _navigationStack.removeAll()
+        _lastInteractionTimestampMs = 0
+    }
+    
+    @objc public func latestInteractionTimestampMs() -> UInt64 {
+        _lastInteractionTimestampMs
     }
     
     @objc public func observeTextField(_ field: UITextField) {
@@ -88,6 +94,21 @@ public final class InteractionRecorder: NSObject {
     @objc public func processRawTouches(_ event: UIEvent, in window: UIWindow) {
         guard isTracking, let agg = _gestureAggregator else { return }
         guard let touches = event.allTouches else { return }
+        _lastInteractionTimestampMs = UInt64(Date().timeIntervalSince1970 * 1000)
+
+        // Notify SpecialCases about touch phases for touch-based map idle detection
+        // (used by Mapbox v10+ where SDK idle callbacks can't be hooked).
+        for touch in touches {
+            switch touch.phase {
+            case .began:
+                SpecialCases.shared.notifyTouchBegan()
+            case .ended, .cancelled:
+                SpecialCases.shared.notifyTouchEnded()
+            default:
+                break
+            }
+        }
+
         for touch in touches {
             agg.processTouch(touch, in: window)
         }
@@ -304,6 +325,13 @@ private final class GestureAggregator: NSObject {
     }
     
     private func _resolveTarget(at point: CGPoint, in window: UIWindow) -> (label: String, isInteractive: Bool) {
+        // When a map view is visible, skip hitTest entirely — performing
+        // hitTest on a deep Metal/OpenGL map hierarchy is expensive and
+        // causes micro-stutter during pan/zoom gestures.
+        if SpecialCases.shared.mapVisible {
+            return ("map", false)
+        }
+        
         guard let hit = window.hitTest(point, with: nil) else { return ("window", false) }
         
         let label = hit.accessibilityIdentifier ?? hit.accessibilityLabel ?? String(describing: type(of: hit))

package/ios/Recording/ReplayOrchestrator.swift

@@ -38,7 +38,7 @@ public final class ReplayOrchestrator: NSObject {
         }
     }
     
-    @objc public var snapshotInterval: Double = 0.33
+    @objc public var snapshotInterval: Double = 1.0
     @objc public var compressionLevel: Double = 0.5
     @objc public var visualCaptureEnabled: Bool = true
     @objc public var interactionCaptureEnabled: Bool = true
@@ -168,7 +168,7 @@ public final class ReplayOrchestrator: NSObject {
         _initSession()
         TelemetryPipeline.shared.activateDeferredMode()
         
-        let renderCfg = _computeRender(fps: 3, tier: "standard")
+        let renderCfg = _computeRender(fps: 1, tier: "standard")
         
         if visualCaptureEnabled {
             VisualCapture.shared.configure(snapshotInterval: renderCfg.interval, jpegQuality: renderCfg.quality)
@@ -224,6 +224,7 @@ public final class ReplayOrchestrator: NSObject {
             "screensVisited": _visitedScreens,
             "screenCount": Set(_visitedScreens).count
         ]
+        let queueDepthAtFinalize = TelemetryPipeline.shared.getQueueDepth()
         
         SegmentDispatcher.shared.evaluateReplayRetention(replayId: sid, metrics: metrics) { [weak self] retain, reason in
             guard let self else { return }
@@ -246,7 +247,13 @@ public final class ReplayOrchestrator: NSObject {
             }
             self._finalized = true
             
-            SegmentDispatcher.shared.concludeReplay(replayId: sid, concludedAt: termMs, backgroundDurationMs: self._bgTimeMs, metrics: metrics) { [weak self] ok in
+            SegmentDispatcher.shared.concludeReplay(
+                replayId: sid,
+                concludedAt: termMs,
+                backgroundDurationMs: self._bgTimeMs,
+                metrics: metrics,
+                currentQueueDepth: queueDepthAtFinalize
+            ) { [weak self] ok in
                 if ok { self?._clearRecovery() }
                 completion?(true, ok)
             }
@@ -285,7 +292,7 @@ public final class ReplayOrchestrator: NSObject {
         // If recording is disabled, disable visual capture
         if !recordingEnabled {
             visualCaptureEnabled = false
-            DiagnosticLog.notice("[ReplayOrchestrator] Visual capture disabled by remote config (recordingEnabled=false)")
+            DiagnosticLog.trace("[ReplayOrchestrator] Visual capture disabled by remote config (recordingEnabled=false)")
         }
         
         // If already recording, restart the duration limit timer with updated config
@@ -293,7 +300,7 @@ public final class ReplayOrchestrator: NSObject {
             _startDurationLimitTimer()
         }
         
-        DiagnosticLog.notice("[ReplayOrchestrator] Remote config applied: rejourneyEnabled=\(rejourneyEnabled), recordingEnabled=\(recordingEnabled), sampleRate=\(sampleRate)%, maxRecording=\(maxRecordingMinutes)min, isSampledIn=\(recordingEnabled)")
+        DiagnosticLog.trace("[ReplayOrchestrator] Remote config applied: rejourneyEnabled=\(rejourneyEnabled), recordingEnabled=\(recordingEnabled), sampleRate=\(sampleRate)%, maxRecording=\(maxRecordingMinutes)min, isSampledIn=\(recordingEnabled)")
     }
     
     @objc public func attachAttribute(key: String, value: String) {
@@ -344,8 +351,15 @@ public final class ReplayOrchestrator: NSObject {
             "crashCount": 1,
             "durationSeconds": Int((nowMs - origStart) / 1000)
         ]
-        
-        SegmentDispatcher.shared.concludeReplay(replayId: recId, concludedAt: nowMs, backgroundDurationMs: 0, metrics: crashMetrics) { [weak self] ok in
+        let queueDepthAtFinalize = TelemetryPipeline.shared.getQueueDepth()
+        
+        SegmentDispatcher.shared.concludeReplay(
+            replayId: recId,
+            concludedAt: nowMs,
+            backgroundDurationMs: 0,
+            metrics: crashMetrics,
+            currentQueueDepth: queueDepthAtFinalize
+        ) { [weak self] ok in
             self?._clearRecovery()
             completion(ok ? recId : nil)
         }
@@ -483,7 +497,7 @@ public final class ReplayOrchestrator: NSObject {
         SegmentDispatcher.shared.activate()
         TelemetryPipeline.shared.activate()
         
-        let renderCfg = _computeRender(fps: 3, tier: "high")
+        let renderCfg = _computeRender(fps: 1, tier: "standard")
         VisualCapture.shared.configure(snapshotInterval: renderCfg.interval, jpegQuality: renderCfg.quality)
         
         if visualCaptureEnabled { VisualCapture.shared.beginCapture(sessionOrigin: replayStartMs) }
@@ -510,20 +524,20 @@ public final class ReplayOrchestrator: NSObject {
         let remaining = maxMs > elapsed ? maxMs - elapsed : 0
         
         guard remaining > 0 else {
-            DiagnosticLog.notice("[ReplayOrchestrator] Duration limit already exceeded, stopping session")
+            DiagnosticLog.trace("[ReplayOrchestrator] Duration limit already exceeded, stopping session")
             endReplay()
             return
         }
         
         let workItem = DispatchWorkItem { [weak self] in
             guard let self, self._live else { return }
-            DiagnosticLog.notice("[ReplayOrchestrator] Recording duration limit reached (\(maxMinutes)min), stopping session")
+            DiagnosticLog.trace("[ReplayOrchestrator] Recording duration limit reached (\(maxMinutes)min), stopping session")
             self.endReplay()
         }
         _durationLimitTimer = workItem
         DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(Int(remaining)), execute: workItem)
         
-        DiagnosticLog.notice("[ReplayOrchestrator] Duration limit timer set: \(remaining / 1000)s remaining (max \(maxMinutes)min)")
+        DiagnosticLog.trace("[ReplayOrchestrator] Duration limit timer set: \(remaining / 1000)s remaining (max \(maxMinutes)min)")
     }
     
     private func _stopDurationLimitTimer() {
@@ -585,6 +599,13 @@ public final class ReplayOrchestrator: NSObject {
             return
         }
         
+        // Throttle hierarchy capture when map is visible and animating —
+        // hierarchy scanning traverses the full view tree including the
+        // map's deep Metal/GL subviews, adding main-thread pressure.
+        if SpecialCases.shared.mapVisible && !SpecialCases.shared.mapIdle {
+            return
+        }
+        
         guard let hierarchy = ViewHierarchyScanner.shared.captureHierarchy() else { return }
         
         let hash = _hierarchyHash(hierarchy)
@@ -608,13 +629,25 @@ public final class ReplayOrchestrator: NSObject {
 }
 
 private func _computeRender(fps: Int, tier: String) -> (interval: Double, quality: Double) {
-    let interval = 1.0 / Double(max(1, min(fps, 99)))
+    let tierLower = tier.lowercased()
+    let interval: Double
     let quality: Double
-    switch tier.lowercased() {
-    case "low": quality = 0.4
-    case "standard": quality = 0.5
-    case "high": quality = 0.6
-    default: quality = 0.5
+    switch tierLower {
+    case "minimal":
+        interval = 2.0  // 0.5 fps for maximum size reduction
+        quality = 0.4
+    case "low":
+        interval = 1.0 / Double(max(1, min(fps, 99)))
+        quality = 0.4
+    case "standard":
+        interval = 1.0 / Double(max(1, min(fps, 99)))
+        quality = 0.5
+    case "high":
+        interval = 1.0 / Double(max(1, min(fps, 99)))
+        quality = 0.55
+    default:
+        interval = 1.0 / Double(max(1, min(fps, 99)))
+        quality = 0.5
     }
     return (interval, quality)
 }