@rejourneyco/react-native 1.0.14 → 1.0.16

package/android/src/main/java/com/rejourney/RejourneyModuleImpl.kt

@@ -44,6 +44,7 @@ import com.facebook.react.modules.network.NetworkingModule
 import okhttp3.OkHttpClient
 import com.rejourney.engine.DeviceRegistrar
 import com.rejourney.engine.DiagnosticLog
+import com.rejourney.engine.RejourneyImpl
 
 import com.rejourney.platform.OEMDetector
 import com.rejourney.platform.SessionLifecycleService
@@ -400,8 +401,13 @@ class RejourneyModuleImpl(
         waitForSessionReady(savedUserId, 0)
     }
 
-    private fun waitForSessionReady(savedUserId: String?, attempts: Int) {
-        val maxAttempts = 30 // 3 seconds max
+    private fun waitForSessionReady(
+        savedUserId: String?,
+        attempts: Int,
+        onReady: ((String) -> Unit)? = null,
+        onTimeout: (() -> Unit)? = null
+    ) {
+        val maxAttempts = 50 // 5 seconds max
 
         mainHandler.postDelayed({
             val newSid = ReplayOrchestrator.shared?.replayId
@@ -420,10 +426,12 @@ class RejourneyModuleImpl(
 
                 DiagnosticLog.replayBegan(newSid)
                 DiagnosticLog.notice("[Rejourney] ✅ New session started: $newSid")
+                onReady?.invoke(newSid)
             } else if (attempts < maxAttempts) {
-                waitForSessionReady(savedUserId, attempts + 1)
+                waitForSessionReady(savedUserId, attempts + 1, onReady, onTimeout)
             } else {
                 DiagnosticLog.caution("[Rejourney] ⚠️ Timeout waiting for new session to initialize")
+                onTimeout?.invoke()
             }
         }, 100)
     }
@@ -495,7 +503,12 @@ class RejourneyModuleImpl(
                         return@post
                     }
                     is SessionState.Starting -> {
-                        promise.resolve(createResultMap(true, currentState.sessionId))
+                        val activeSid = ReplayOrchestrator.shared?.replayId
+                        if (!activeSid.isNullOrEmpty()) {
+                            promise.resolve(createResultMap(true, activeSid))
+                        } else {
+                            promise.resolve(createResultMap(false, "", "Session is still starting"))
+                        }
                         return@post
                     }
                     else -> Unit
@@ -545,22 +558,22 @@ class RejourneyModuleImpl(
             // Android-specific: Start SessionLifecycleService for task removal detection
             startSessionLifecycleService()
 
-            // Allow orchestrator time to spin up
-            mainHandler.postDelayed({
-                val sid = ReplayOrchestrator.shared?.replayId ?: pendingSessionId
-                stateLock.withLock {
-                    state = SessionState.Active(sid, System.currentTimeMillis())
-                }
-
-                ReplayOrchestrator.shared?.activateGestureRecording()
-
-                if (!userId.isNullOrBlank() && userId != "anonymous" && !userId.startsWith("anon_")) {
-                    ReplayOrchestrator.shared?.associateUser(userId)
+            waitForSessionReady(
+                savedUserId = userId,
+                attempts = 0,
+                onReady = { sid ->
+                    promise.resolve(createResultMap(true, sid))
+                },
+                onTimeout = {
+                    stateLock.withLock {
+                        if (state is SessionState.Starting) {
+                            state = SessionState.Idle
+                        }
+                    }
+                    stopSessionLifecycleService()
+                    promise.resolve(createResultMap(false, "", "Timed out waiting for replay session to initialize"))
                 }
-
-                DiagnosticLog.replayBegan(sid)
-                promise.resolve(createResultMap(true, sid))
-            }, 300)
+            )
         }
     }
     
@@ -844,6 +857,7 @@ class RejourneyModuleImpl(
 
     fun setSDKVersion(version: String) {
         sdkVersion = version
+        RejourneyImpl.sdkVersion = version
     }
 
     fun getSDKVersion(promise: Promise) {

package/android/src/main/java/com/rejourney/engine/RejourneyImpl.kt

@@ -39,6 +39,7 @@ import kotlin.concurrent.withLock
  */
 sealed class SessionState {
     object Idle : SessionState()
+    data class Starting(val sessionId: String, val startTimeMs: Long) : SessionState()
     data class Active(val sessionId: String, val startTimeMs: Long) : SessionState()
     data class Paused(val sessionId: String, val startTimeMs: Long) : SessionState()
     object Terminated : SessionState()
@@ -250,8 +251,13 @@ class RejourneyImpl private constructor(private val context: Context) :
         }
     }
 
-    private fun waitForSessionReady(savedUserId: String?, attempts: Int) {
-        val maxAttempts = 30 // 3 seconds max
+    private fun waitForSessionReady(
+        savedUserId: String?,
+        attempts: Int,
+        onReady: ((String) -> Unit)? = null,
+        onTimeout: (() -> Unit)? = null
+    ) {
+        val maxAttempts = 50 // 5 seconds max
 
         mainHandler.postDelayed({
             val newSid = ReplayOrchestrator.shared?.replayId
@@ -270,10 +276,12 @@ class RejourneyImpl private constructor(private val context: Context) :
 
                 DiagnosticLog.replayBegan(newSid)
                 DiagnosticLog.notice("[Rejourney] ✅ New session started: $newSid")
+                onReady?.invoke(newSid)
             } else if (attempts < maxAttempts) {
-                waitForSessionReady(savedUserId, attempts + 1)
+                waitForSessionReady(savedUserId, attempts + 1, onReady, onTimeout)
             } else {
                 DiagnosticLog.caution("[Rejourney] ⚠️ Timeout waiting for new session to initialize")
+                onTimeout?.invoke()
             }
         }, 100)
     }
@@ -299,9 +307,17 @@ class RejourneyImpl private constructor(private val context: Context) :
             // Check if already active
             stateLock.withLock {
                 val currentState = state
-                if (currentState is SessionState.Active) {
-                    callback?.invoke(true, currentState.sessionId)
-                    return@post
+                when (currentState) {
+                    is SessionState.Active -> {
+                        callback?.invoke(true, currentState.sessionId)
+                        return@post
+                    }
+                    is SessionState.Starting -> {
+                        val activeSid = ReplayOrchestrator.shared?.replayId
+                        callback?.invoke(!activeSid.isNullOrEmpty(), activeSid ?: "")
+                        return@post
+                    }
+                    else -> Unit
                 }
             }
 
@@ -317,9 +333,10 @@ class RejourneyImpl private constructor(private val context: Context) :
             SegmentDispatcher.shared.endpoint = apiUrl
             DeviceRegistrar.shared?.endpoint = apiUrl
 
-            // Pre-generate session ID
-            val sid = "session_${System.currentTimeMillis()}_${java.util.UUID.randomUUID().toString().replace("-", "").lowercase()}"
-            ReplayOrchestrator.shared?.replayId = sid
+            val pendingSessionId = "session_${System.currentTimeMillis()}_${java.util.UUID.randomUUID().toString().replace("-", "").lowercase()}"
+            stateLock.withLock {
+                state = SessionState.Starting(pendingSessionId, System.currentTimeMillis())
+            }
 
             // Begin replay
             ReplayOrchestrator.shared?.beginReplay(
@@ -328,21 +345,21 @@ class RejourneyImpl private constructor(private val context: Context) :
                 captureSettings = config
             )
 
-            // Allow orchestrator time to spin up
-            mainHandler.postDelayed({
-                stateLock.withLock {
-                    state = SessionState.Active(sid, System.currentTimeMillis())
-                }
-
-                ReplayOrchestrator.shared?.activateGestureRecording()
-
-                if (userId != "anonymous") {
-                    ReplayOrchestrator.shared?.associateUser(userId)
+            waitForSessionReady(
+                savedUserId = userId,
+                attempts = 0,
+                onReady = { sid ->
+                    callback?.invoke(true, sid)
+                },
+                onTimeout = {
+                    stateLock.withLock {
+                        if (state is SessionState.Starting) {
+                            state = SessionState.Idle
+                        }
+                    }
+                    callback?.invoke(false, "")
                 }
-
-                DiagnosticLog.replayBegan(sid)
-                callback?.invoke(true, sid)
-            }, 300)
+            )
         }
     }
 

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

@@ -78,7 +78,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
     var replayId: String? = null
     var replayStartMs: Long = 0
     var deferredUploadMode = false
-    var frameBundleSize: Int = 5
+    var frameBundleSize: Int = 3
 
     var serverEndpoint: String
         get() = TelemetryPipeline.shared?.endpoint ?: "https://api.rejourney.co"
@@ -222,7 +222,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         val renderCfg = computeRender(1, "standard")
 
         if (visualCaptureEnabled) {
-            VisualCapture.shared?.configure(renderCfg.first, renderCfg.second)
+            VisualCapture.shared?.configure(renderCfg.first, renderCfg.second, frameBundleSize)
             VisualCapture.shared?.beginCapture(replayStartMs)
             VisualCapture.shared?.activateDeferredMode()
         }
@@ -285,8 +285,8 @@ class ReplayOrchestrator private constructor(private val context: Context) {
 
         // Do local teardown immediately so lifecycle rollover never depends on network latency.
         mainHandler.post {
-            TelemetryPipeline.shared?.shutdown()
             VisualCapture.shared?.halt(haltGeneration)
+            TelemetryPipeline.shared?.shutdown()
             InteractionRecorder.shared?.deactivate()
             StabilityMonitor.shared?.deactivate()
             AnrSentinel.shared?.deactivate()
@@ -302,19 +302,17 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         }
         finalized = true
 
-        SegmentDispatcher.shared.evaluateReplayRetention(sid, metrics) { _, _ ->
-            SegmentDispatcher.shared.concludeReplay(
-                sid,
-                termMs,
-                bgTimeMs,
-                metrics,
-                queueDepthAtFinalize,
-                endReason = endReason,
-                lifecycleVersion = lifecycleContractVersion
-            ) { ok ->
-                if (ok) clearRecovery()
-                completion?.invoke(true, ok)
-            }
+        SegmentDispatcher.shared.concludeReplay(
+            sid,
+            termMs,
+            bgTimeMs,
+            metrics,
+            queueDepthAtFinalize,
+            endReason = endReason,
+            lifecycleVersion = lifecycleContractVersion
+        ) { ok ->
+            if (ok) clearRecovery()
+            completion?.invoke(true, ok)
         }
 
         replayId = null
@@ -546,7 +544,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         responsivenessCaptureEnabled = (cfg["captureANR"] as? Boolean) ?: true
         consoleCaptureEnabled = (cfg["captureLogs"] as? Boolean) ?: true
         wifiRequired = (cfg["wifiOnly"] as? Boolean) ?: false
-        frameBundleSize = (cfg["screenshotBatchSize"] as? Int) ?: 5
+        frameBundleSize = (cfg["screenshotBatchSize"] as? Int) ?: 3
     }
 
     private fun monitorNetwork(token: String) {
@@ -643,7 +641,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
 
         val renderCfg = computeRender(1, "standard")
         DiagnosticLog.trace("[ReplayOrchestrator] VisualCapture.shared=${VisualCapture.shared != null}, visualCaptureEnabled=$visualCaptureEnabled")
-        VisualCapture.shared?.configure(renderCfg.first, renderCfg.second)
+        VisualCapture.shared?.configure(renderCfg.first, renderCfg.second, frameBundleSize)
 
         if (visualCaptureEnabled) {
             DiagnosticLog.trace("[ReplayOrchestrator] Starting VisualCapture")

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

@@ -17,6 +17,7 @@
 package com.rejourney.recording
 
 import com.rejourney.engine.DiagnosticLog
+import com.rejourney.engine.RejourneyImpl
 import kotlinx.coroutines.*
 import okhttp3.*
 import com.rejourney.recording.RejourneyNetworkInterceptor
@@ -173,7 +174,18 @@ class SegmentDispatcher private constructor() {
         frameCount: Int,
         completion: ((Boolean) -> Unit)? = null
     ) {
-        val sid = currentReplayId
+        transmitFrameBundleForSession(currentReplayId, payload, startMs, endMs, frameCount, completion)
+    }
+
+    fun transmitFrameBundleForSession(
+        sessionId: String?,
+        payload: ByteArray,
+        startMs: Long,
+        endMs: Long,
+        frameCount: Int,
+        completion: ((Boolean) -> Unit)? = null
+    ) {
+        val sid = sessionId
         val canUpload = canUploadNow()
         DiagnosticLog.trace("[SegmentDispatcher] transmitFrameBundle: sid=${sid?.take(12) ?: "null"}, canUpload=$canUpload, frames=$frameCount, bytes=${payload.size}")
         
@@ -274,6 +286,7 @@ class SegmentDispatcher private constructor() {
         val body = JSONObject().apply {
             put("sessionId", replayId)
             put("endedAt", concludedAt)
+            put("sdkVersion", RejourneyImpl.sdkVersion)
             if (backgroundDurationMs > 0) put("totalBackgroundTimeMs", backgroundDurationMs)
             metrics?.let { put("metrics", JSONObject(it)) }
             put("sdkTelemetry", buildSdkTelemetry(currentQueueDepth))
@@ -293,39 +306,6 @@ class SegmentDispatcher private constructor() {
         }
     }
     
-    fun evaluateReplayRetention(
-        replayId: String,
-        metrics: Map<String, Any>,
-        completion: (Boolean, String) -> Unit
-    ) {
-        val url = "$endpoint/api/ingest/replay/evaluate"
-        
-        val body = JSONObject().apply {
-            put("sessionId", replayId)
-            metrics.forEach { (key, value) -> put(key, value) }
-        }
-        
-        val request = buildRequest(url, body)
-        
-        scope.launch {
-            try {
-                val response = httpClient.newCall(request).execute()
-                val responseBody = response.body?.string()
-                
-                if (response.code == 200 && responseBody != null) {
-                    val json = JSONObject(responseBody)
-                    val retained = json.optBoolean("promoted", false)
-                    val reason = json.optString("reason", "unknown")
-                    completion(retained, reason)
-                } else {
-                    completion(false, "request_failed")
-                }
-            } catch (e: Exception) {
-                completion(false, "request_failed")
-            }
-        }
-    }
-    
     @Synchronized
     private fun canUploadNow(): Boolean {
         if (billingBlocked) return false
@@ -390,6 +370,12 @@ class SegmentDispatcher private constructor() {
             scheduleRetryIfNeeded(upload, completion)
             return
         }
+
+        if (presignResponse.skipUpload) {
+            registerSuccess()
+            completion?.invoke(true)
+            return
+        }
         
         val s3ok = uploadToS3(presignResponse.presignedUrl, upload.payload)
         if (!s3ok) {
@@ -444,6 +430,7 @@ class SegmentDispatcher private constructor() {
         val body = JSONObject().apply {
             put("sessionId", upload.sessionId)
             put("sizeBytes", upload.payload.size)
+            put("sdkVersion", RejourneyImpl.sdkVersion)
             
             if (upload.contentType == "events") {
                 put("contentType", "events")
@@ -483,7 +470,7 @@ class SegmentDispatcher private constructor() {
             val json = JSONObject(responseBody)
             
             if (json.optBoolean("skipUpload", false)) {
-                return null
+                return PresignResponse(skipUpload = true)
             }
             
             val presignedUrl = json.optString("presignedUrl", null) ?: return null
@@ -758,8 +745,9 @@ private data class PendingUpload(
 )
 
 private data class PresignResponse(
-    val presignedUrl: String,
-    val batchId: String
+    val presignedUrl: String = "",
+    val batchId: String = "",
+    val skipUpload: Boolean = false
 )
 
 private data class TelemetrySnapshot(

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

@@ -22,12 +22,15 @@ import android.os.Handler
 import android.os.Looper
 import com.rejourney.engine.DiagnosticLog
 import com.rejourney.engine.DeviceRegistrar
+import com.rejourney.engine.RejourneyImpl
 import com.rejourney.utility.gzipCompress
 import org.json.JSONArray
 import org.json.JSONObject
 import java.util.*
+import java.util.concurrent.CountDownLatch
 import java.util.concurrent.CopyOnWriteArrayList
 import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
 
@@ -160,11 +163,7 @@ class TelemetryPipeline private constructor(private val context: Context) {
         heartbeatRunnable?.let { mainHandler.removeCallbacks(it) }
         heartbeatRunnable = null
 
-        SegmentDispatcher.shared.halt()
-        appSuspending()
-
-        // Clear pending frame bundles so they don't leak into the next session
-        frameQueue.clear()
+        drainPendingDataForShutdown()
     }
     
     fun finalizeAndShip() {
@@ -205,6 +204,31 @@ class TelemetryPipeline private constructor(private val context: Context) {
     fun getQueueDepth(): Int {
         return eventRing.size() + frameQueue.size()
     }
+
+    private fun drainPendingDataForShutdown() {
+        if (draining) return
+        draining = true
+
+        // Force any in-memory frames into the upload pipeline before session
+        // teardown clears the active replay ID.
+        VisualCapture.shared?.flushToDisk()
+        VisualCapture.shared?.flushBufferToNetwork()
+
+        val latch = CountDownLatch(1)
+        serialWorker.execute {
+            try {
+                shipPendingEvents()
+                shipPendingFrames()
+            } finally {
+                draining = false
+                latch.countDown()
+            }
+        }
+
+        if (!latch.await(1, TimeUnit.SECONDS)) {
+            DiagnosticLog.trace("[TelemetryPipeline] shutdown drain timed out before upload queue kick-off completed")
+        }
+    }
     
     private fun appSuspending() {
         if (draining) return
@@ -249,17 +273,14 @@ class TelemetryPipeline private constructor(private val context: Context) {
             return
         }
 
-        // Drop frames that belong to a session that is no longer active —
-        // they would be uploaded under the wrong session and cause flickering.
-        if (next.sessionId != null && next.sessionId != currentReplayId && currentReplayId != null) {
-            DiagnosticLog.trace("[TelemetryPipeline] shipPendingFrames: dropping ${next.count} stale frames from session ${next.sessionId} (current=${currentReplayId})")
-            serialWorker.execute { shipPendingFrames() }
-            return
+        if (next.sessionId != null && next.sessionId != currentReplayId) {
+            DiagnosticLog.trace("[TelemetryPipeline] shipPendingFrames: routing ${next.count} frames to captured session ${next.sessionId} (current=${currentReplayId})")
         }
         
         DiagnosticLog.trace("[TelemetryPipeline] shipPendingFrames: transmitting ${next.count} frames to SegmentDispatcher")
         
-        SegmentDispatcher.shared.transmitFrameBundle(
+        SegmentDispatcher.shared.transmitFrameBundleForSession(
+            sessionId = targetSession,
             payload = next.payload,
             startMs = next.rangeStart,
             endMs = next.rangeEnd,
@@ -320,6 +341,7 @@ class TelemetryPipeline private constructor(private val context: Context) {
             put("isConstrained", orchestrator?.networkIsConstrained ?: false)
             put("isExpensive", orchestrator?.networkIsExpensive ?: false)
             put("appVersion", getAppVersion())
+            put("sdkVersion", RejourneyImpl.sdkVersion)
             put("appId", context.packageName)
             put("screenWidth", displayMetrics.widthPixels)
             put("screenHeight", displayMetrics.heightPixels)

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

@@ -91,8 +91,8 @@ class VisualCapture private constructor(private val context: Context) {
     private val maxPendingBatches = 50
     private val maxBufferedScreenshots = 500
     
-    // Industry standard batch size (20 frames per batch)
-    private val batchSize = 20
+    /** Flush to the network after this many frames (smaller = more frequent uploads). */
+    private var uploadBatchSize = 3
     
     // Current activity reference
     private var currentActivity: WeakReference<Activity>? = null
@@ -208,9 +208,10 @@ class VisualCapture private constructor(private val context: Context) {
         redactionMask.invalidateCache()
     }
     
-    fun configure(snapshotInterval: Double, jpegQuality: Double) {
+    fun configure(snapshotInterval: Double, jpegQuality: Double, uploadBatchSize: Int = 3) {
         this.snapshotInterval = snapshotInterval
         this.quality = jpegQuality.toFloat()
+        this.uploadBatchSize = uploadBatchSize.coerceIn(1, 100)
         if (stateMachine.currentState == CaptureState.CAPTURING) {
             stopCaptureTimer()
             startCaptureTimer()
@@ -404,7 +405,7 @@ class VisualCapture private constructor(private val context: Context) {
         stateLock.withLock {
             screenshots.add(Pair(data, captureTs))
             enforceScreenshotCaps()
-            val shouldSend = !deferredUntilCommit && screenshots.size >= batchSize
+            val shouldSend = !deferredUntilCommit && screenshots.size >= uploadBatchSize
             
             if (shouldSend) {
                 sendScreenshots()

package/ios/Engine/RejourneyImpl.swift

@@ -78,6 +78,7 @@ public final class RejourneyImpl: NSObject {
         NotificationCenter.default.removeObserver(self)
     }
 
+    //NOTE: iOS cannot detect reliably app kill so we depend server side with the session reconciliation logic 
     private func setupLifecycleListeners() {
         let center = NotificationCenter.default
         center.addObserver(self, selector: #selector(handleTermination), name: UIApplication.willTerminateNotification, object: nil)
@@ -251,8 +252,13 @@ public final class RejourneyImpl: NSObject {
         }
     }
 
-    private func _waitForSessionReady(savedUserId: String?, attempts: Int) {
-        let maxAttempts = 30 // 3 seconds max (30 * 100ms)
+    private func _waitForSessionReady(
+        savedUserId: String?,
+        attempts: Int,
+        onReady: ((String) -> Void)? = nil,
+        onTimeout: (() -> Void)? = nil
+    ) {
+        let maxAttempts = 50 // 5 seconds max (50 * 100ms)
 
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
             guard let self else { return }
@@ -275,11 +281,13 @@ public final class RejourneyImpl: NSObject {
 
                 DiagnosticLog.replayBegan(newSid)
                 DiagnosticLog.notice("[Rejourney] ✅ New session started: \(newSid)")
+                onReady?(newSid)
             } else if attempts < maxAttempts {
                 // Keep polling
-                self._waitForSessionReady(savedUserId: savedUserId, attempts: attempts + 1)
+                self._waitForSessionReady(savedUserId: savedUserId, attempts: attempts + 1, onReady: onReady, onTimeout: onTimeout)
             } else {
                 DiagnosticLog.caution("[Rejourney] ⚠️ Timeout waiting for new session to initialize")
+                onTimeout?()
             }
         }
     }
@@ -355,10 +363,19 @@ public final class RejourneyImpl: NSObject {
 
             self.stateLock.lock()
             switch self.state {
-            case .active(let sid, _), .starting(let sid, _):
+            case .active(let sid, _):
                 self.stateLock.unlock()
                 resolve(["success": true, "sessionId": sid])
                 return
+            case .starting(_, _):
+                let activeSid = ReplayOrchestrator.shared.replayId
+                self.stateLock.unlock()
+                if let activeSid, !activeSid.isEmpty {
+                    resolve(["success": true, "sessionId": activeSid])
+                } else {
+                    resolve(["success": false, "sessionId": "", "error": "Session is still starting"])
+                }
+                return
             default:
                 self.stateLock.unlock()
             }
@@ -387,24 +404,22 @@ public final class RejourneyImpl: NSObject {
 
             ReplayOrchestrator.shared.beginReplay(apiToken: publicKey, serverEndpoint: apiUrl, captureSettings: config)
 
-            // Allow orchestrator time to spin up
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
-                let sid = ReplayOrchestrator.shared.replayId ?? pendingSessionId
-                let start = Date().timeIntervalSince1970
-
-                self.stateLock.lock()
-                self.state = .active(sessionId: sid, startTime: start)
-                self.stateLock.unlock()
-
-                ReplayOrchestrator.shared.activateGestureRecording()
-
-                if userId != "anonymous" && !userId.hasPrefix("anon_") {
-                    ReplayOrchestrator.shared.associateUser(userId)
+            self._waitForSessionReady(
+                savedUserId: userId,
+                attempts: 0,
+                onReady: { sid in
+                    resolve(["success": true, "sessionId": sid])
+                },
+                onTimeout: { [weak self] in
+                    guard let self else { return }
+                    self.stateLock.lock()
+                    if case .starting(_, _) = self.state {
+                        self.state = .idle
+                    }
+                    self.stateLock.unlock()
+                    resolve(["success": false, "sessionId": "", "error": "Timed out waiting for replay session to initialize"])
                 }
-
-                DiagnosticLog.replayBegan(sid)
-                resolve(["success": true, "sessionId": sid])
-            }
+            )
         }
     }
 

package/ios/Recording/ReplayOrchestrator.swift

@@ -27,7 +27,7 @@ public final class ReplayOrchestrator: NSObject {
     @objc public var replayId: String?
     @objc public var replayStartMs: UInt64 = 0
     @objc public var deferredUploadMode = false
-    @objc public var frameBundleSize: Int = 5
+    @objc public var frameBundleSize: Int = 3
 
     public var serverEndpoint: String {
         get { TelemetryPipeline.shared.endpoint }
@@ -172,7 +172,7 @@ public final class ReplayOrchestrator: NSObject {
         let renderCfg = _computeRender(fps: 1, tier: "standard")
 
         if visualCaptureEnabled {
-            VisualCapture.shared.configure(snapshotInterval: renderCfg.interval, jpegQuality: renderCfg.quality)
+            VisualCapture.shared.configure(snapshotInterval: renderCfg.interval, jpegQuality: renderCfg.quality, uploadBatchSize: frameBundleSize)
             VisualCapture.shared.beginCapture(sessionOrigin: replayStartMs)
             VisualCapture.shared.activateDeferredMode()
         }
@@ -241,8 +241,8 @@ public final class ReplayOrchestrator: NSObject {
 
         // Do local teardown immediately so lifecycle rollover never depends on network latency.
         DispatchQueue.main.async {
-            TelemetryPipeline.shared.shutdown()
             VisualCapture.shared.halt(expectedGeneration: haltGeneration)
+            TelemetryPipeline.shared.shutdown()
             InteractionRecorder.shared.deactivate()
             FaultTracker.shared.deactivate()
             ResponsivenessWatcher.shared.halt()
@@ -258,20 +258,17 @@ public final class ReplayOrchestrator: NSObject {
         }
         _finalized = true
 
-        SegmentDispatcher.shared.evaluateReplayRetention(replayId: sid, metrics: metrics) { [weak self] _, _ in
-            guard let self else { return }
-            SegmentDispatcher.shared.concludeReplay(
-                replayId: sid,
-                concludedAt: termMs,
-                backgroundDurationMs: self._bgTimeMs,
-                metrics: metrics,
-                currentQueueDepth: queueDepthAtFinalize,
-                endReason: endReason,
-                lifecycleVersion: self.lifecycleContractVersion
-            ) { [weak self] ok in
-                if ok { self?._clearRecovery() }
-                completion?(true, ok)
-            }
+        SegmentDispatcher.shared.concludeReplay(
+            replayId: sid,
+            concludedAt: termMs,
+            backgroundDurationMs: _bgTimeMs,
+            metrics: metrics,
+            currentQueueDepth: queueDepthAtFinalize,
+            endReason: endReason,
+            lifecycleVersion: lifecycleContractVersion
+        ) { [weak self] ok in
+            if ok { self?._clearRecovery() }
+            completion?(true, ok)
         }
 
         replayId = nil
@@ -491,7 +488,7 @@ public final class ReplayOrchestrator: NSObject {
         responsivenessCaptureEnabled = cfg["captureANR"] as? Bool ?? true
         consoleCaptureEnabled = cfg["captureLogs"] as? Bool ?? true
         wifiRequired = cfg["wifiOnly"] as? Bool ?? false
-        frameBundleSize = cfg["screenshotBatchSize"] as? Int ?? 5
+        frameBundleSize = cfg["screenshotBatchSize"] as? Int ?? 3
     }
 
     private func _monitorNetwork(token: String) {
@@ -559,7 +556,7 @@ public final class ReplayOrchestrator: NSObject {
         TelemetryPipeline.shared.activate()
 
         let renderCfg = _computeRender(fps: 1, tier: "standard")
-        VisualCapture.shared.configure(snapshotInterval: renderCfg.interval, jpegQuality: renderCfg.quality)
+        VisualCapture.shared.configure(snapshotInterval: renderCfg.interval, jpegQuality: renderCfg.quality, uploadBatchSize: frameBundleSize)
 
         if visualCaptureEnabled { VisualCapture.shared.beginCapture(sessionOrigin: replayStartMs) }
         if interactionCaptureEnabled { InteractionRecorder.shared.activate() }

package/ios/Recording/SegmentDispatcher.swift

@@ -100,7 +100,6 @@ final class SegmentDispatcher {
     
     func halt() {
         active = false
-        workerQueue.cancelAllOperations()
     }
     
     func shipPending() {
@@ -109,7 +108,11 @@ final class SegmentDispatcher {
     }
     
     func transmitFrameBundle(payload: Data, startMs: UInt64, endMs: UInt64, frameCount: Int, completion: ((Bool) -> Void)? = nil) {
-        guard let sid = currentReplayId, canUploadNow() else {
+        transmitFrameBundle(for: currentReplayId, payload: payload, startMs: startMs, endMs: endMs, frameCount: frameCount, completion: completion)
+    }
+
+    func transmitFrameBundle(for sessionId: String?, payload: Data, startMs: UInt64, endMs: UInt64, frameCount: Int, completion: ((Bool) -> Void)? = nil) {
+        guard let sid = sessionId, canUploadNow() else {
             completion?(false)
             return
         }
@@ -192,7 +195,11 @@ final class SegmentDispatcher {
         req.setValue("application/json", forHTTPHeaderField: "Content-Type")
         applyAuthHeaders(&req)
         
-        var body: [String: Any] = ["sessionId": replayId, "endedAt": concludedAt]
+        var body: [String: Any] = [
+            "sessionId": replayId,
+            "endedAt": concludedAt,
+            "sdkVersion": RejourneyImpl.sdkVersion
+        ]
         if backgroundDurationMs > 0 { body["totalBackgroundTimeMs"] = backgroundDurationMs }
         if let m = metrics { body["metrics"] = m }
         body["sdkTelemetry"] = sdkTelemetrySnapshot(currentQueueDepth: currentQueueDepth)
@@ -215,39 +222,6 @@ final class SegmentDispatcher {
         }.resume()
     }
     
-    func evaluateReplayRetention(replayId: String, metrics: [String: Any], completion: @escaping (Bool, String) -> Void) {
-        guard let url = URL(string: "\(endpoint)/api/ingest/replay/evaluate") else {
-            completion(false, "bad_url")
-            return
-        }
-        
-        var req = URLRequest(url: url)
-        req.httpMethod = "POST"
-        req.setValue("application/json", forHTTPHeaderField: "Content-Type")
-        applyAuthHeaders(&req)
-        
-        var body: [String: Any] = ["sessionId": replayId]
-        metrics.forEach { body[$0.key] = $0.value }
-        
-        do {
-            req.httpBody = try JSONSerialization.data(withJSONObject: body)
-        } catch {
-            completion(false, "serialize_error")
-            return
-        }
-        
-        httpSession.dataTask(with: req) { data, resp, _ in
-            guard let data, (resp as? HTTPURLResponse)?.statusCode == 200,
-                  let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
-                completion(false, "request_failed")
-                return
-            }
-            let retained = json["promoted"] as? Bool ?? false
-            let reason = json["reason"] as? String ?? "unknown"
-            completion(retained, reason)
-        }.resume()
-    }
-    
     private func canUploadNow() -> Bool {
         if billingBlocked { return false }
         if circuitOpen {
@@ -313,6 +287,12 @@ final class SegmentDispatcher {
                 self.scheduleRetryIfNeeded(upload, completion: completion)
                 return
             }
+
+            if presign.skipUpload {
+                self.registerSuccess()
+                completion?(true)
+                return
+            }
             
             self.uploadToS3(url: presign.presignedUrl, payload: upload.payload) { s3ok in
                 guard s3ok else {
@@ -373,7 +353,8 @@ final class SegmentDispatcher {
         
         var body: [String: Any] = [
             "sessionId": upload.sessionId,
-            "sizeBytes": upload.payload.count
+            "sizeBytes": upload.payload.count,
+            "sdkVersion": RejourneyImpl.sdkVersion
         ]
         
         if upload.contentType == "events" {
@@ -415,7 +396,7 @@ final class SegmentDispatcher {
             }
             
             if json["skipUpload"] as? Bool == true {
-                completion(nil)
+                completion(PresignResponse(presignedUrl: "", batchId: "", skipUpload: true))
                 return
             }
             
@@ -426,7 +407,7 @@ final class SegmentDispatcher {
             
             let batchId = json["batchId"] as? String ?? json["segmentId"] as? String ?? ""
             
-            completion(PresignResponse(presignedUrl: presignedUrl, batchId: batchId))
+            completion(PresignResponse(presignedUrl: presignedUrl, batchId: batchId, skipUpload: false))
         }.resume()
     }
     
@@ -638,4 +619,5 @@ private struct PendingUpload {
 private struct PresignResponse {
     let presignedUrl: String
     let batchId: String
+    let skipUpload: Bool
 }

package/ios/Recording/TelemetryPipeline.swift

@@ -125,11 +125,7 @@ public final class TelemetryPipeline: NSObject {
         _heartbeat = nil
         NotificationCenter.default.removeObserver(self)
         
-        SegmentDispatcher.shared.halt()
-        _appSuspending()
-
-        // Clear pending frame bundles so they don't leak into the next session
-        _frameQueue.clear()
+        _drainPendingDataForShutdown()
     }
     
     @objc public func finalizeAndShip() {
@@ -169,6 +165,35 @@ public final class TelemetryPipeline: NSObject {
     @objc public func getQueueDepth() -> Int {
         _eventRing.count + _frameQueue.count
     }
+
+    private func _drainPendingDataForShutdown() {
+        guard !_draining else { return }
+        _draining = true
+
+        _backgroundTaskId = UIApplication.shared.beginBackgroundTask(withName: "RejourneyShutdownFlush") { [weak self] in
+            self?._endBackgroundTask()
+        }
+
+        // Force any in-memory frames into the upload pipeline before session
+        // teardown clears the active replay ID.
+        VisualCapture.shared.flushToDisk()
+        VisualCapture.shared.flushBufferToNetwork()
+
+        let group = DispatchGroup()
+        group.enter()
+        _serialWorker.async { [weak self] in
+            defer { group.leave() }
+            self?._shipPendingEvents()
+            self?._shipPendingFrames()
+        }
+
+        if group.wait(timeout: .now() + 1.0) == .timedOut {
+            DiagnosticLog.trace("[TelemetryPipeline] shutdown drain timed out before upload queue kick-off completed")
+        }
+
+        _endBackgroundTask()
+        _draining = false
+    }
     
     @objc private func _appSuspending() {
         guard !_draining else { return }
@@ -254,19 +279,18 @@ public final class TelemetryPipeline: NSObject {
     private func _shipPendingFrames() {
         guard !_deferredMode, let next = _frameQueue.dequeue() else { return }
 
-        guard currentReplayId != nil else {
+        let targetSession = next.sessionId ?? currentReplayId
+        guard let targetSession else {
             _frameQueue.requeue(next)
             return
         }
 
-        // Drop frames that belong to a session that is no longer active
         if let bundleSession = next.sessionId, bundleSession != currentReplayId {
-            DiagnosticLog.trace("[TelemetryPipeline] Dropping \(next.count) stale frames from session \(bundleSession)")
-            _shipPendingFrames()
-            return
+            DiagnosticLog.trace("[TelemetryPipeline] Routing \(next.count) frames to captured session \(bundleSession) (current=\(currentReplayId ?? "nil"))")
         }
         
         SegmentDispatcher.shared.transmitFrameBundle(
+            for: targetSession,
             payload: next.payload,
             startMs: next.rangeStart,
             endMs: next.rangeEnd,
@@ -330,6 +354,7 @@ public final class TelemetryPipeline: NSObject {
             "isConstrained": isConstrained,
             "isExpensive": isExpensive,
             "appVersion": appVersion,
+            "sdkVersion": RejourneyImpl.sdkVersion,
             "appId": appId,
             "screenWidth": Int(bounds.width),
             "screenHeight": Int(bounds.height),

package/ios/Recording/VisualCapture.swift

@@ -59,8 +59,8 @@ public final class VisualCapture: NSObject {
     private let _maxPendingBatches = 50
     private let _maxBufferedScreenshots = 500
     
-    // Industry standard batch size (20 frames per batch, not 5)
-    private let _batchSize = 20
+    /// Flush to the network after this many frames (smaller = more frequent uploads).
+    private var _uploadBatchSize = 3
 
     
     private override init() {
@@ -195,10 +195,11 @@ public final class VisualCapture: NSObject {
     }
 
     
-    @objc public func configure(snapshotInterval: Double, jpegQuality: Double, captureScale: CGFloat = 1.25) {
+    @objc public func configure(snapshotInterval: Double, jpegQuality: Double, captureScale: CGFloat = 1.25, uploadBatchSize: Int = 3) {
         self.snapshotInterval = snapshotInterval
         self.quality = CGFloat(jpegQuality)
         self.captureScale = max(1.0, captureScale)
+        _uploadBatchSize = max(1, min(uploadBatchSize, 100))
         if _stateMachine.currentState == .capturing {
             _stopCaptureTimer()
             _startCaptureTimer()
@@ -325,7 +326,7 @@ public final class VisualCapture: NSObject {
                 self._stateLock.lock()
                 self._screenshots.append((data, captureTs))
                 self._enforceScreenshotCaps()
-                let shouldSend = !self._deferredUntilCommit && self._screenshots.count >= self._batchSize
+                let shouldSend = !self._deferredUntilCommit && self._screenshots.count >= self._uploadBatchSize
                 self._stateLock.unlock()
                 
                 if shouldSend {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rejourneyco/react-native",
-    "version": "1.0.14",
+    "version": "1.0.16",
     "description": "Rejourney Session Recording SDK for React Native",
     "main": "lib/commonjs/index.js",
     "module": "lib/module/index.js",