@rejourneyco/react-native 1.0.14 → 1.0.15

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

@@ -400,8 +400,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 +425,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 +502,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 +557,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)
+            )
         }
     }
     

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()
@@ -546,7 +546,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 +643,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

@@ -173,7 +173,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}")
         
@@ -390,6 +401,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) {
@@ -483,7 +500,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 +775,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

@@ -26,8 +26,10 @@ 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 +162,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 +203,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 +272,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,

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

@@ -251,8 +251,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 +280,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 +362,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 +403,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()
@@ -491,7 +491,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 +559,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
         }
@@ -313,6 +316,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 {
@@ -415,7 +424,7 @@ final class SegmentDispatcher {
             }
             
             if json["skipUpload"] as? Bool == true {
-                completion(nil)
+                completion(PresignResponse(presignedUrl: "", batchId: "", skipUpload: true))
                 return
             }
             
@@ -426,7 +435,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 +647,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,

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.15",
     "description": "Rejourney Session Recording SDK for React Native",
     "main": "lib/commonjs/index.js",
     "module": "lib/module/index.js",