@scalebun-release/react-native 2.5.0

package/android/src/main/java/com/scalebun/replaysdk/transport/ReplayTransport.kt

@@ -0,0 +1,99 @@
+package com.scalebun.replaysdk.transport
+
+import com.scalebun.replaysdk.core.ReplayLogger
+import kotlinx.coroutines.*
+import org.json.JSONObject
+import java.io.OutputStreamWriter
+import java.net.HttpURLConnection
+import java.net.URL
+
+/**
+ * HTTP transport for uploading session replay data.
+ * Uses HttpURLConnection (no external dependencies).
+ * Runs on IO dispatcher.
+ */
+class ReplayTransport(
+    private var endpoint: String,
+    private var apiKey: String,
+    private var maxRetries: Int = 3
+) {
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+
+    data class UploadResult(
+        val success: Boolean,
+        val statusCode: Int,
+        val retryable: Boolean,
+        val error: String? = null
+    )
+
+    /**
+     * Upload a JSON payload to the specified path.
+     */
+    suspend fun upload(path: String, payload: String): UploadResult = withContext(Dispatchers.IO) {
+        var lastResult = UploadResult(false, 0, false, "No attempts made")
+
+        for (attempt in 0 until maxRetries) {
+            lastResult = attemptUpload(path, payload)
+
+            if (lastResult.success || !lastResult.retryable) {
+                return@withContext lastResult
+            }
+
+            // Exponential backoff with jitter
+            val delay = (1000L * (1 shl attempt)) + (Math.random() * 500).toLong()
+            ReplayLogger.debug("Upload retry $attempt/${maxRetries} in ${delay}ms")
+            delay(delay)
+        }
+
+        return@withContext lastResult
+    }
+
+    private fun attemptUpload(path: String, payload: String): UploadResult {
+        var connection: HttpURLConnection? = null
+        return try {
+            val url = URL("$endpoint$path")
+            connection = url.openConnection() as HttpURLConnection
+            connection.requestMethod = "POST"
+            connection.setRequestProperty("Content-Type", "application/json")
+            connection.setRequestProperty("X-API-Key", apiKey)
+            connection.setRequestProperty("User-Agent", "ReplaySdk-Android/0.1.0")
+            connection.connectTimeout = 30_000
+            connection.readTimeout = 30_000
+            connection.doOutput = true
+
+            OutputStreamWriter(connection.outputStream).use { writer ->
+                writer.write(payload)
+                writer.flush()
+            }
+
+            val statusCode = connection.responseCode
+
+            UploadResult(
+                success = statusCode in 200..299,
+                statusCode = statusCode,
+                retryable = statusCode >= 500 || statusCode == 429,
+                error = if (statusCode !in 200..299) "HTTP $statusCode" else null
+            )
+        } catch (e: Exception) {
+            ReplayLogger.error("Upload error: ${e.message}", e)
+            UploadResult(
+                success = false,
+                statusCode = 0,
+                retryable = true,
+                error = e.message
+            )
+        } finally {
+            connection?.disconnect()
+        }
+    }
+
+    fun updateConfig(endpoint: String, apiKey: String, maxRetries: Int) {
+        this.endpoint = endpoint
+        this.apiKey = apiKey
+        this.maxRetries = maxRetries
+    }
+
+    fun destroy() {
+        scope.cancel()
+    }
+}

package/android/src/main/java/com/scalebun/replaysdk/voice/VoiceRecorder.kt

@@ -0,0 +1,121 @@
+package com.scalebun.replaysdk.voice
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.media.MediaRecorder
+import android.os.Build
+import android.util.Base64
+import java.io.File
+
+/**
+ * ScaleBun SDK — voice-note recorder (Slice D).
+ *
+ * Records a short feedback voice note to a compressed AAC/.m4a file (modest
+ * bitrate so a 30s clip stays small — the backend just stores it, no heavy
+ * processing). The recorded bytes upload via the SAME engage presign→PUT→metadata
+ * pipeline used by screenshots — we never fork a second transport.
+ *
+ * 30s is hard-capped in three places (recorder UI, SDK, backend). This native
+ * layer is the SDK-side cap: MediaRecorder.setMaxDuration stops the mic at the
+ * limit so we can never produce an over-length clip on device.
+ */
+class VoiceRecorder(private val context: Context) {
+
+    companion object {
+        const val MAX_DURATION_MS = 30_000
+        // Stop slightly under the cap so the emitted clip is always < 30s.
+        private const val HARD_STOP_MS = MAX_DURATION_MS - 100
+        private const val SAMPLE_RATE = 44_100
+        private const val BIT_RATE = 64_000 // modest — keeps a 30s clip tiny
+    }
+
+    private var recorder: MediaRecorder? = null
+    private var outputFile: File? = null
+    private var startedAtMs: Long = 0L
+
+    fun isRecording(): Boolean = recorder != null
+
+    fun hasMicPermission(): Boolean =
+        context.checkSelfPermission(Manifest.permission.RECORD_AUDIO) ==
+            PackageManager.PERMISSION_GRANTED
+
+    /** Begin recording. Throws on failure (no mic, perm missing, busy). */
+    fun start() {
+        if (recorder != null) throw IllegalStateException("already recording")
+        if (!hasMicPermission()) throw SecurityException("RECORD_AUDIO not granted")
+
+        val file = File.createTempFile("scalebun_voice_", ".m4a", context.cacheDir)
+        val rec = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            MediaRecorder(context)
+        } else {
+            @Suppress("DEPRECATION")
+            MediaRecorder()
+        }
+        rec.setAudioSource(MediaRecorder.AudioSource.MIC)
+        rec.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
+        rec.setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
+        rec.setAudioSamplingRate(SAMPLE_RATE)
+        rec.setAudioEncodingBitRate(BIT_RATE)
+        rec.setMaxDuration(HARD_STOP_MS)
+        rec.setOutputFile(file.absolutePath)
+        rec.prepare()
+        rec.start()
+
+        recorder = rec
+        outputFile = file
+        startedAtMs = System.currentTimeMillis()
+    }
+
+    /**
+     * Stop recording and return the clip. durationMs is the real elapsed time,
+     * clamped under the hard cap. Returns null if nothing was recorded.
+     */
+    fun stop(): Result? {
+        val rec = recorder ?: return null
+        val file = outputFile
+        val elapsed = (System.currentTimeMillis() - startedAtMs).toInt()
+        try {
+            rec.stop()
+        } catch (_: Exception) {
+            // stop() throws if stopped before any frame was written — discard.
+            cleanup()
+            return null
+        } finally {
+            rec.release()
+            recorder = null
+        }
+        if (file == null || !file.exists() || file.length() == 0L) {
+            cleanup()
+            return null
+        }
+        val bytes = file.readBytes()
+        val base64 = Base64.encodeToString(bytes, Base64.NO_WRAP)
+        val durationMs = elapsed.coerceIn(0, HARD_STOP_MS)
+        val path = file.absolutePath
+        return Result(base64, durationMs, file.length().toInt(), path)
+    }
+
+    fun cancel() {
+        try {
+            recorder?.stop()
+        } catch (_: Exception) {
+        }
+        recorder?.release()
+        recorder = null
+        cleanup()
+    }
+
+    private fun cleanup() {
+        outputFile?.delete()
+        outputFile = null
+    }
+
+    data class Result(
+        val base64: String,
+        val durationMs: Int,
+        val byteSize: Int,
+        /** Local file path retained for on-device transcription, deleted after. */
+        val filePath: String,
+    )
+}

package/android/src/main/java/com/scalebun/replaysdk/voice/VoiceTranscriber.kt

@@ -0,0 +1,170 @@
+package com.scalebun.replaysdk.voice
+
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.speech.RecognitionListener
+import android.speech.RecognizerIntent
+import android.speech.SpeechRecognizer
+
+/**
+ * ScaleBun SDK — on-device voice transcription (Slice D).
+ *
+ * This is the Android implementation behind the SDK's TranscriptionProvider
+ * abstraction: on-device STT only (no network, no creds). It runs a live
+ * SpeechRecognizer session concurrently with the recorder and accumulates the
+ * best transcript, returned when recording stops.
+ *
+ * The transcript is a best-effort PREFILL — the user always edits and explicitly
+ * approves the final wording in the prompt before anything is sent, so an empty
+ * result here (no STT engine, no mic input on a headless emulator) is non-fatal:
+ * the editable field is the source of truth. The interface is platform-neutral so
+ * a backend engine could replace this later without touching callers.
+ */
+class VoiceTranscriber(private val context: Context) {
+
+    private var recognizer: SpeechRecognizer? = null
+    private val main = Handler(Looper.getMainLooper())
+    @Volatile private var transcript: String = ""
+    @Volatile private var available: Boolean = false
+
+    companion object {
+        /** How long stop() waits for the engine's final onResults before giving up. */
+        private const val FINAL_RESULT_GRACE_MS = 700L
+    }
+
+    /** Start a live on-device recognition session. Best-effort — never throws. */
+    fun start() {
+        main.post {
+            try {
+                if (!SpeechRecognizer.isRecognitionAvailable(context)) return@post
+                val rec = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S &&
+                    SpeechRecognizer.isOnDeviceRecognitionAvailable(context)
+                ) {
+                    SpeechRecognizer.createOnDeviceSpeechRecognizer(context)
+                } else {
+                    SpeechRecognizer.createSpeechRecognizer(context)
+                }
+                rec.setRecognitionListener(listener)
+                val intent = Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
+                    putExtra(
+                        RecognizerIntent.EXTRA_LANGUAGE_MODEL,
+                        RecognizerIntent.LANGUAGE_MODEL_FREE_FORM,
+                    )
+                    putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true)
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                        putExtra(RecognizerIntent.EXTRA_PREFER_OFFLINE, true)
+                    }
+                }
+                recognizer = rec
+                available = true
+                rec.startListening(intent)
+            } catch (_: Exception) {
+                available = false
+            }
+        }
+    }
+
+    /**
+     * Stop the session and return the accumulated transcript (may be empty).
+     *
+     * Kept for binary compatibility; prefer [stop] with a callback — this sync
+     * form returns BEFORE the recognizer's final onResults can arrive, so it only
+     * ever sees partials.
+     */
+    fun stop(): TranscriptResult {
+        main.post {
+            try {
+                recognizer?.stopListening()
+                recognizer?.destroy()
+            } catch (_: Exception) {
+            }
+            recognizer = null
+        }
+        return TranscriptResult(transcript.trim(), available)
+    }
+
+    /**
+     * Stop the session and deliver the transcript AFTER the engine has had a
+     * chance to emit its final result. stopListening() → onResults is
+     * asynchronous; the sync stop() raced it and returned partials-only (or
+     * nothing). We wait up to [FINAL_RESULT_GRACE_MS], completing early when
+     * onResults lands.
+     */
+    fun stop(onDone: (TranscriptResult) -> Unit) {
+        main.post {
+            val rec = recognizer
+            recognizer = null
+            if (rec == null || !available) {
+                onDone(TranscriptResult(transcript.trim(), available))
+                return@post
+            }
+            var completed = false
+            val finish = {
+                if (!completed) {
+                    completed = true
+                    try {
+                        rec.destroy()
+                    } catch (_: Exception) {
+                    }
+                    onDone(TranscriptResult(transcript.trim(), available))
+                }
+            }
+            pendingFinish = finish
+            try {
+                rec.stopListening()
+            } catch (_: Exception) {
+                finish()
+                return@post
+            }
+            main.postDelayed({ finish() }, FINAL_RESULT_GRACE_MS)
+        }
+    }
+
+    @Volatile private var pendingFinish: (() -> Unit)? = null
+
+    private val listener = object : RecognitionListener {
+        override fun onResults(results: Bundle?) {
+            results
+                ?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)
+                ?.firstOrNull()
+                ?.let { if (it.isNotBlank()) transcript = it }
+            // Final result is in — no reason to sit out the rest of the grace window.
+            main.post { pendingFinish?.invoke() }
+        }
+
+        override fun onPartialResults(partial: Bundle?) {
+            partial
+                ?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)
+                ?.firstOrNull()
+                ?.let { if (it.isNotBlank()) transcript = it }
+        }
+
+        override fun onError(error: Int) {
+            // The errors this swallowed are exactly the ones that explain an empty
+            // transcript in the field: ERROR_AUDIO(3)/ERROR_RECOGNIZER_BUSY(8) mean
+            // the mic was contended (a concurrent MediaRecorder usually wins and the
+            // engine hears silence); ERROR_NO_MATCH(7) means it heard but understood
+            // nothing. Keep them visible.
+            android.util.Log.i("ScaleBunVoice", "SpeechRecognizer error=$error (transcript so far: ${transcript.length} chars)")
+            if (error == SpeechRecognizer.ERROR_AUDIO ||
+                error == SpeechRecognizer.ERROR_RECOGNIZER_BUSY ||
+                error == SpeechRecognizer.ERROR_INSUFFICIENT_PERMISSIONS
+            ) {
+                available = false
+            }
+            main.post { pendingFinish?.invoke() }
+        }
+        override fun onReadyForSpeech(params: Bundle?) {}
+        override fun onBeginningOfSpeech() {}
+        override fun onRmsChanged(rmsdB: Float) {}
+        override fun onBufferReceived(buffer: ByteArray?) {}
+        override fun onEndOfSpeech() {}
+        override fun onEvent(eventType: Int, params: Bundle?) {}
+    }
+
+    data class TranscriptResult(val text: String, val available: Boolean)
+}

package/android/src/main/java/com/scalebun/rn/ScaleBunPackage.kt

@@ -0,0 +1,113 @@
+package com.scalebun.rn
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.scalebun.profiler.ProfilerModule
+import com.scalebun.replaysdk.ReplaySdkModule
+import com.scalebun.rn.crash.ScaleBunCrashModule
+import com.scalebun.rn.engage.ScaleBunEngageModule
+import com.scalebun.rn.performance.PerformanceModule
+import com.scalebun.rn.referrer.ScaleBunInstallReferrerModule
+import com.scalebun.rn.ota.ScaleBunOtaModule
+import com.scalebun.rn.storage.ScaleBunStorageModule
+import com.scalebun.sdk.BuildConfig
+
+/**
+ * Single autolink entry point for the ScaleBun SDK on Android.
+ *
+ * React Native autolinking registers exactly **one** package per dependency, so
+ * this aggregator owns every ScaleBun native module and is wired in
+ * `react-native.config.js` — consumers add **nothing** to `MainApplication.kt`.
+ *
+ * It is a [BaseReactPackage] (the modern, both-architecture base) so modules can
+ * be exposed as real **TurboModules** on the New Architecture and classic
+ * NativeModules on the Old Architecture, lazily (one instance per requested
+ * name). Per-module migration status:
+ *  - `ScaleBunCrash`        → backward-compatible TurboModule (Phase 2)
+ *  - `ScaleBunProfiler`     → backward-compatible TurboModule (Phase 2; events via emitter)
+ *  - `ScaleBunPerformance`  → backward-compatible TurboModule (Phase 2; events via emitter)
+ *  - `ReplaySdk`       → backward-compatible TurboModule (Phase 3; events via emitter)
+ *
+ * NOTE (migration): consumers who previously added a ScaleBun package to
+ * `MainApplication` manually must **remove** it, or RN throws on the duplicate
+ * native-module name.
+ */
+class ScaleBunPackage : BaseReactPackage() {
+
+    override fun getModule(
+        name: String,
+        reactContext: ReactApplicationContext,
+    ): NativeModule? = when (name) {
+        ScaleBunCrashModule.NAME -> ScaleBunCrashModule(reactContext)
+        PROFILER -> ProfilerModule(reactContext)
+        REPLAY -> ReplaySdkModule(reactContext)
+        PERFORMANCE -> PerformanceModule(reactContext)
+        ENGAGE -> ScaleBunEngageModule(reactContext)
+        ScaleBunStorageModule.NAME -> ScaleBunStorageModule(reactContext)
+        ScaleBunInstallReferrerModule.NAME -> ScaleBunInstallReferrerModule(reactContext)
+        ScaleBunOtaModule.NAME -> ScaleBunOtaModule(reactContext)
+        else -> null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        val isNewArch = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+        return ReactModuleInfoProvider {
+            mapOf(
+                // Crash is a real TurboModule on New Arch (codegen-backed),
+                // a legacy NativeModule on Old Arch.
+                ScaleBunCrashModule.NAME to info(
+                    ScaleBunCrashModule.NAME, ScaleBunCrashModule::class.java.name, isTurbo = isNewArch,
+                ),
+                // Profiler is a backward-compatible TurboModule on New Arch (events
+                // still flow via the device event emitter, independent of this).
+                PROFILER to info(PROFILER, ProfilerModule::class.java.name, isTurbo = isNewArch),
+                PERFORMANCE to info(PERFORMANCE, PerformanceModule::class.java.name, isTurbo = isNewArch),
+                REPLAY to info(REPLAY, ReplaySdkModule::class.java.name, isTurbo = isNewArch),
+                // Engage is a classic NativeModule (no codegen spec), so it is NEVER
+                // a TurboModule — isTurbo MUST be false or the New-Arch TurboModule
+                // system would look for a non-existent JSI spec. It resolves via the
+                // interop layer on New Arch and as a plain NativeModule on Old Arch.
+                ENGAGE to info(ENGAGE, ScaleBunEngageModule::class.java.name, isTurbo = false),
+                // Storage is the SDK's first-party durable KV store. It HAS a codegen
+                // spec (src/specs/NativeScaleBunStorage.ts), so it is a real TurboModule on
+                // New Arch (with a synchronous getAllSync JSI method) and a classic
+                // NativeModule on Old Arch.
+                ScaleBunStorageModule.NAME to info(
+                    ScaleBunStorageModule.NAME, ScaleBunStorageModule::class.java.name, isTurbo = isNewArch,
+                ),
+                // Install Referrer (Android-only) HAS a codegen spec
+                // (src/specs/NativeScaleBunInstallReferrer.ts) → real TurboModule on
+                // New Arch, classic NativeModule on Old Arch.
+                ScaleBunInstallReferrerModule.NAME to info(
+                    ScaleBunInstallReferrerModule.NAME, ScaleBunInstallReferrerModule::class.java.name, isTurbo = isNewArch,
+                ),
+                // OTA bundle management HAS a codegen spec
+                // (src/specs/NativeScaleBunOta.ts) → real TurboModule on
+                // New Arch, classic NativeModule on Old Arch.
+                ScaleBunOtaModule.NAME to info(
+                    ScaleBunOtaModule.NAME, ScaleBunOtaModule::class.java.name, isTurbo = isNewArch,
+                ),
+            )
+        }
+    }
+
+    private fun info(name: String, className: String, isTurbo: Boolean) =
+        ReactModuleInfo(
+            name,
+            className,
+            /* canOverrideExistingModule = */ false,
+            /* needsEagerInit = */ false,
+            /* isCxxModule = */ false,
+            /* isTurboModule = */ isTurbo,
+        )
+
+    private companion object {
+        const val PROFILER = "ScaleBunProfiler"
+        const val REPLAY = "ReplaySdk"
+        const val PERFORMANCE = "ScaleBunPerformance"
+        const val ENGAGE = "ScaleBunEngage"
+    }
+}

package/android/src/main/java/com/scalebun/rn/crash/ScaleBunCrashModule.kt

@@ -0,0 +1,188 @@
+package com.scalebun.rn.crash
+
+import com.facebook.react.bridge.*
+import com.scalebun.core.crash.CrashStorage
+import com.scalebun.core.crash.NativeCrashHandler
+import org.json.JSONObject
+
+/**
+ * React Native bridge for native crash capture.
+ *
+ * Backward-compatible across architectures: extends [ScaleBunCrashSpec], which is the
+ * codegen TurboModule base on New Arch (`src/newarch`) and a classic
+ * NativeModule base on Old Arch (`src/oldarch`). All capture logic stays in
+ * `com.scalebun.core.crash` — this is thin glue only.
+ *
+ * Methods:
+ *   install()            — installs Thread.UncaughtExceptionHandler
+ *   drainPendingCrash()  — returns crash from previous run (or null), then clears it
+ *   crashNow()           — DEV/TEST: throws on a background thread so the
+ *                          installed handler captures + persists it, then dies
+ */
+class ScaleBunCrashModule(reactContext: ReactApplicationContext) :
+    ScaleBunCrashSpec(reactContext) {
+
+    companion object {
+        const val NAME = "ScaleBunCrash"
+    }
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    override fun crashNow(promise: Promise) {
+        // Resolve first — the JS side won't get a chance once the process dies.
+        promise.resolve(true)
+        // Throw on a fresh thread; the installed default UncaughtExceptionHandler
+        // persists the crash and the process terminates (real native crash).
+        Thread {
+            throw RuntimeException("ScaleBun test native crash (Android)")
+        }.start()
+    }
+
+    @ReactMethod
+    override fun install(promise: Promise) {
+        try {
+            NativeCrashHandler.install(reactApplicationContext.applicationContext)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("CRASH_INSTALL_ERROR", e.message, e)
+        }
+    }
+
+    /**
+     * Record which session is live, so a crash can name it.
+     *
+     * Called once when a session starts — never per event. The write is small and synchronous
+     * because it has to be durable before the next line of app code runs, and the next line of app
+     * code is exactly what might crash.
+     */
+    @ReactMethod
+    override fun setActiveSessionId(sessionId: String?, promise: Promise) {
+        try {
+            CrashStorage.setActiveSessionId(reactApplicationContext.applicationContext, sessionId)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            // Attribution is best-effort; never fail the caller over it.
+            promise.resolve(false)
+        }
+    }
+
+    /**
+     * Delete one crash AFTER the backend has accepted it.
+     *
+     * Separating deletion from the read is the whole of at-least-once: the durable copy outlives
+     * every failed attempt and disappears only once the crash is known to be recorded.
+     */
+    @ReactMethod
+    override fun clearPendingCrash(crashId: String?, promise: Promise) {
+        try {
+            CrashStorage.clearCrash(reactApplicationContext.applicationContext, crashId ?: "")
+            promise.resolve(true)
+        } catch (e: Exception) {
+            // Failing to delete is harmless — the crash is already recorded, and the backend dedupes
+            // on crashId, so a redelivery produces no second row.
+            promise.resolve(false)
+        }
+    }
+
+    @ReactMethod
+    override fun drainPendingCrash(promise: Promise) {
+        try {
+            val context = reactApplicationContext.applicationContext
+            /**
+             * NON-DESTRUCTIVE.
+             *
+             * This used to clear the record the moment it was read, so a failed upload destroyed the
+             * only durable copy and the crash was gone forever — the app had proof of a crash,
+             * deleted it, and then failed to deliver it. Deletion is now `clearPendingCrash`, called
+             * by JS only after the backend has accepted.
+             *
+             * Oldest first: if several are pending, the earliest crash is the one that has been
+             * waiting longest and is most at risk of being aged out.
+             */
+            val crash = CrashStorage.readAll(context).firstOrNull() ?: CrashStorage.read(context)
+            if (crash == null) {
+                promise.resolve(null)
+                return
+            }
+
+            val result = Arguments.createMap()
+            result.putString("name", crash.optString("name", "crash.native"))
+            result.putString("exceptionType", crash.optString("exceptionType"))
+            result.putString("message", crash.optString("message"))
+            result.putString("threadName", crash.optString("threadName"))
+            result.putDouble("timestamp", crash.optDouble("timestamp"))
+            result.putString("platform", "android")
+
+            /**
+             * The session the crash belonged to — the whole point of the fix, and this mapper
+             * ENUMERATES its fields, so a value not named here is silently dropped no matter how
+             * carefully it was written on the crash path.
+             *
+             * Absent on records written before this shipped, and on a crash that happened before
+             * any session started. Left unset in both cases rather than defaulted, so the JS side
+             * can tell "unknown" from a real id and fall back deliberately.
+             */
+            val sid = crash.optString("sessionId", "")
+            if (sid.isNotEmpty()) result.putString("sessionId", sid)
+
+            // The STABLE id. It is what the backend dedupes on, and what JS hands back to
+            // clearPendingCrash once delivery succeeds — so it has to survive this enumerating
+            // mapper as well.
+            val cid = crash.optString("crashId", "")
+            if (cid.isNotEmpty()) result.putString("crashId", cid)
+
+            val stackJson = crash.optJSONArray("stackTrace")
+            if (stackJson != null) {
+                val frames = Arguments.createArray()
+                for (i in 0 until stackJson.length()) {
+                    frames.pushString(stackJson.optString(i))
+                }
+                result.putArray("stackTrace", frames)
+            }
+
+            val causeJson = crash.optJSONObject("cause")
+            if (causeJson != null) {
+                val cause = Arguments.createMap()
+                cause.putString("exceptionType", causeJson.optString("exceptionType"))
+                cause.putString("message", causeJson.optString("message"))
+                val causeStack = causeJson.optJSONArray("stackTrace")
+                if (causeStack != null) {
+                    val frames = Arguments.createArray()
+                    for (i in 0 until causeStack.length()) {
+                        frames.pushString(causeStack.optString(i))
+                    }
+                    cause.putArray("stackTrace", frames)
+                }
+                result.putMap("cause", cause)
+            }
+
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.reject("CRASH_DRAIN_ERROR", e.message, e)
+        }
+    }
+
+    /**
+     * Persist a FATAL JS crash to the same store native crashes use.
+     *
+     * BLOCKING SYNCHRONOUS on purpose. A fatal JS error unwinds the process, and
+     * an async promise call would return before the write ran — losing the crash,
+     * which is exactly the bug this closes. A synchronous write finishes on disk
+     * before the JS handler returns, so the next launch drains it via
+     * drainPendingCrash like any native crash.
+     *
+     * Never throws: it runs while the app is already dying, and the crashId in the
+     * record makes the eventual delivery idempotent.
+     */
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun persistJsCrash(recordJson: String?): Boolean {
+        return try {
+            if (recordJson.isNullOrEmpty()) return false
+            CrashStorage.write(reactApplicationContext.applicationContext, JSONObject(recordJson))
+            true
+        } catch (e: Exception) {
+            false
+        }
+    }
+}