@scalebun/react-native 1.0.2 → 1.0.4

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 ScaleBun
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 ScaleBun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,65 +1,65 @@
-# @scalebun/react-native
-
-Production-grade React Native SDK for [ScaleBun](https://scalebun.com) — error reporting, analytics, session replay, and in-app engagement for iOS and Android.
-
-## Installation
-
-```sh
-npm install @scalebun/react-native
-# or
-pnpm add @scalebun/react-native
-# or
-yarn add @scalebun/react-native
-```
-
-### iOS
-
-```sh
-cd ios && pod install
-```
-
-### Optional peer dependencies
-
-Some features activate only when their peer package is installed:
-
-| Feature            | Peer dependency               |
-| ------------------ | ----------------------------- |
-| Screenshot capture | `react-native-view-shot`      |
-| Push notifications | `@notifee/react-native`       |
-| Expo Router journey | `expo-router`                |
-
-## Quick start
-
-Wrap your app in the provider and pass your project credentials from the dashboard:
-
-```tsx
-import { ScaleBunProvider } from '@scalebun/react-native';
-
-export default function App() {
-  return (
-    <ScaleBunProvider
-      config={{
-        projectId: 'YOUR_PROJECT_ID',
-        publishableKey: 'YOUR_PUBLISHABLE_KEY',
-      }}
-    >
-      <RootNavigator />
-    </ScaleBunProvider>
-  );
-}
-```
-
-The default export exposes the imperative facade for use outside React (identifying users, capturing events, etc.):
-
-```ts
-import ScaleBun from '@scalebun/react-native';
-```
-
-## Requirements
-
-- React Native `>= 0.74`
-- React `>= 18`
-
-## License
-
-MIT © ScaleBun
+# @scalebun/react-native
+
+Production-grade React Native SDK for [ScaleBun](https://scalebun.dev) — error reporting, analytics, session replay, and in-app engagement for iOS and Android.
+
+## Installation
+
+```sh
+npm install @scalebun/react-native
+# or
+pnpm add @scalebun/react-native
+# or
+yarn add @scalebun/react-native
+```
+
+### iOS
+
+```sh
+cd ios && pod install
+```
+
+### Optional peer dependencies
+
+Some features activate only when their peer package is installed:
+
+| Feature            | Peer dependency               |
+| ------------------ | ----------------------------- |
+| Screenshot capture | `react-native-view-shot`      |
+| Push notifications | `@notifee/react-native`       |
+| Expo Router journey | `expo-router`                |
+
+## Quick start
+
+Wrap your app in the provider and pass your project credentials from the dashboard:
+
+```tsx
+import { ScaleBunProvider } from '@scalebun/react-native';
+
+export default function App() {
+  return (
+    <ScaleBunProvider
+      config={{
+        projectId: 'YOUR_PROJECT_ID',
+        publishableKey: 'YOUR_PUBLISHABLE_KEY',
+      }}
+    >
+      <RootNavigator />
+    </ScaleBunProvider>
+  );
+}
+```
+
+The default export exposes the imperative facade for use outside React (identifying users, capturing events, etc.):
+
+```ts
+import ScaleBun from '@scalebun/react-native';
+```
+
+## Requirements
+
+- React Native `>= 0.74`
+- React `>= 18`
+
+## License
+
+MIT © ScaleBun

package/android/build.gradle

@@ -1,86 +1,86 @@
-plugins {
-    id 'com.android.library'
-    id 'org.jetbrains.kotlin.android'
-}
-
-/**
- * Backward-compatible build for both React Native architectures.
- *
- * New Architecture: applies the React Native Gradle plugin (runs TurboModule
- * codegen from `codegenConfig` in package.json) and compiles the `src/newarch`
- * bridge wrappers, which implement the generated `Native*Spec` base classes.
- *
- * Old Architecture: compiles the `src/oldarch` wrappers (classic NativeModule).
- *
- * Either way the actual capture logic lives in `com.scalebun.core` (shared,
- * architecture-agnostic) — the wrappers are thin glue only.
- */
-def isNewArchitectureEnabled() {
-    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
-}
-
-if (isNewArchitectureEnabled()) {
-    apply plugin: 'com.facebook.react'
-}
-
-android {
-    namespace 'com.scalebun.sdk'
-    compileSdk 34
-
-    buildFeatures {
-        // Exposes BuildConfig.IS_NEW_ARCHITECTURE_ENABLED so the (shared, main
-        // source set) package can flag the Crash module as a TurboModule only
-        // on New Arch, while staying a legacy module on Old Arch.
-        buildConfig true
-    }
-
-    defaultConfig {
-        minSdk 24
-        targetSdk 34
-        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
-        // Ship R8 keep-rules to consumer apps so release minification doesn't
-        // strip the native modules / codegen TurboModule specs.
-        consumerProguardFiles "consumer-rules.pro"
-    }
-
-    sourceSets {
-        main {
-            java.srcDirs = ['src/main/java']
-            manifest.srcFile 'src/main/AndroidManifest.xml'
-
-            // Architecture-specific bridge wrappers (populated in Phase 2).
-            // Pointing at a not-yet-created dir is a harmless no-op until then.
-            if (isNewArchitectureEnabled()) {
-                java.srcDirs += ['src/newarch/java']
-            } else {
-                java.srcDirs += ['src/oldarch/java']
-            }
-        }
-    }
-
-    compileOptions {
-        sourceCompatibility JavaVersion.VERSION_17
-        targetCompatibility JavaVersion.VERSION_17
-    }
-
-    kotlinOptions {
-        jvmTarget = '17'
-    }
-}
-
-dependencies {
-    implementation 'com.facebook.react:react-android'
-    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
-
-    // Google Play Install Referrer — reads the install-time referrer string for
-    // deterministic Android attribution (ScaleBunInstallReferrerModule). Small,
-    // Play-only lib; degrades gracefully (the module rejects) where Play is absent.
-    implementation 'com.android.installreferrer:installreferrer:2.2'
-
-    // Engage push-token acquisition (FCM). Declared compileOnly so the SDK does
-    // NOT force Firebase onto host apps that don't use push: ScaleBunEngageModule reaches
-    // FirebaseMessaging purely via reflection and fails soft (logged skip) when the
-    // class is absent at runtime. Host apps that want push add the real
-    // firebase-messaging dependency in their own app module — additive, no break.
-    compileOnly 'com.google.firebase:firebase-messaging:23.4.1'
-}
+plugins {
+    id 'com.android.library'
+    id 'org.jetbrains.kotlin.android'
+}
+
+/**
+ * Backward-compatible build for both React Native architectures.
+ *
+ * New Architecture: applies the React Native Gradle plugin (runs TurboModule
+ * codegen from `codegenConfig` in package.json) and compiles the `src/newarch`
+ * bridge wrappers, which implement the generated `Native*Spec` base classes.
+ *
+ * Old Architecture: compiles the `src/oldarch` wrappers (classic NativeModule).
+ *
+ * Either way the actual capture logic lives in `com.scalebun.core` (shared,
+ * architecture-agnostic) — the wrappers are thin glue only.
+ */
+def isNewArchitectureEnabled() {
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+if (isNewArchitectureEnabled()) {
+    apply plugin: 'com.facebook.react'
+}
+
+android {
+    namespace 'com.scalebun.sdk'
+    compileSdk 34
+
+    buildFeatures {
+        // Exposes BuildConfig.IS_NEW_ARCHITECTURE_ENABLED so the (shared, main
+        // source set) package can flag the Crash module as a TurboModule only
+        // on New Arch, while staying a legacy module on Old Arch.
+        buildConfig true
+    }
+
+    defaultConfig {
+        minSdk 24
+        targetSdk 34
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+        // Ship R8 keep-rules to consumer apps so release minification doesn't
+        // strip the native modules / codegen TurboModule specs.
+        consumerProguardFiles "consumer-rules.pro"
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs = ['src/main/java']
+            manifest.srcFile 'src/main/AndroidManifest.xml'
+
+            // Architecture-specific bridge wrappers (populated in Phase 2).
+            // Pointing at a not-yet-created dir is a harmless no-op until then.
+            if (isNewArchitectureEnabled()) {
+                java.srcDirs += ['src/newarch/java']
+            } else {
+                java.srcDirs += ['src/oldarch/java']
+            }
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-android'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
+
+    // Google Play Install Referrer — reads the install-time referrer string for
+    // deterministic Android attribution (ScaleBunInstallReferrerModule). Small,
+    // Play-only lib; degrades gracefully (the module rejects) where Play is absent.
+    implementation 'com.android.installreferrer:installreferrer:2.2'
+
+    // Engage push-token acquisition (FCM). Declared compileOnly so the SDK does
+    // NOT force Firebase onto host apps that don't use push: ScaleBunEngageModule reaches
+    // FirebaseMessaging purely via reflection and fails soft (logged skip) when the
+    // class is absent at runtime. Host apps that want push add the real
+    // firebase-messaging dependency in their own app module — additive, no break.
+    compileOnly 'com.google.firebase:firebase-messaging:23.4.1'
+}

package/android/consumer-rules.pro

@@ -1,28 +1,28 @@
-# ScaleBun React Native SDK — R8/ProGuard consumer rules.
-#
-# Applied automatically to consumer apps (via `consumerProguardFiles` in
-# build.gradle). Without these, release builds with minification can strip the
-# native modules and the codegen TurboModule specs, causing "module not found"
-# at runtime on the New Architecture.
-
-# Keep all ScaleBun native classes. The SDK's native code is reflection- and
-# JNI-accessed (RN resolves modules by getName()/@ReactMethod; codegen specs are
-# referenced from generated C++/JNI), so it must not be renamed or removed.
--keep class com.scalebun.** { *; }
-
-# Codegen-generated TurboModule specs (com.scalebun.spec.NativeScaleBun*Spec / NativeReplaySdkSpec).
--keep class com.scalebun.spec.** { *; }
-
-# Google Play Install Referrer client — used by ScaleBunInstallReferrerModule for
-# deterministic Android acquisition attribution. Kept so release minification
-# doesn't strip the referrer client.
--keep class com.android.installreferrer.** { *; }
-
-# Defensive React Native bridge reflection (RN ships equivalents, kept here so the
-# SDK is self-contained even if app rules differ).
--keepclassmembers class * extends com.facebook.react.bridge.ReactContextBaseJavaModule {
-    @com.facebook.react.bridge.ReactMethod <methods>;
-}
--keep class * extends com.facebook.react.bridge.NativeModule { *; }
--keep class * extends com.facebook.react.BaseReactPackage { *; }
--keep class * extends com.facebook.react.turbomodule.core.interfaces.TurboModule { *; }
+# ScaleBun React Native SDK — R8/ProGuard consumer rules.
+#
+# Applied automatically to consumer apps (via `consumerProguardFiles` in
+# build.gradle). Without these, release builds with minification can strip the
+# native modules and the codegen TurboModule specs, causing "module not found"
+# at runtime on the New Architecture.
+
+# Keep all ScaleBun native classes. The SDK's native code is reflection- and
+# JNI-accessed (RN resolves modules by getName()/@ReactMethod; codegen specs are
+# referenced from generated C++/JNI), so it must not be renamed or removed.
+-keep class com.scalebun.** { *; }
+
+# Codegen-generated TurboModule specs (com.scalebun.spec.NativeScaleBun*Spec / NativeReplaySdkSpec).
+-keep class com.scalebun.spec.** { *; }
+
+# Google Play Install Referrer client — used by ScaleBunInstallReferrerModule for
+# deterministic Android acquisition attribution. Kept so release minification
+# doesn't strip the referrer client.
+-keep class com.android.installreferrer.** { *; }
+
+# Defensive React Native bridge reflection (RN ships equivalents, kept here so the
+# SDK is self-contained even if app rules differ).
+-keepclassmembers class * extends com.facebook.react.bridge.ReactContextBaseJavaModule {
+    @com.facebook.react.bridge.ReactMethod <methods>;
+}
+-keep class * extends com.facebook.react.bridge.NativeModule { *; }
+-keep class * extends com.facebook.react.BaseReactPackage { *; }
+-keep class * extends com.facebook.react.turbomodule.core.interfaces.TurboModule { *; }

package/android/src/main/AndroidManifest.xml

@@ -1,14 +1,14 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.scalebun.sdk">
-
-    <!-- The SDK uploads telemetry (crashes, replay frames, performance) over the
-         network. Host RN/Expo apps normally declare INTERNET already; declaring it
-         here ensures it is present via manifest merging. -->
-    <uses-permission android:name="android.permission.INTERNET" />
-
-    <!-- [Slice D] Engage feedback voice notes (opt-in; requested at runtime before record). -->
-    <uses-permission android:name="android.permission.RECORD_AUDIO" />
-
-    <!-- Screen capture for session replay uses PixelCopy against the Activity
-         window — no special permission required. -->
-</manifest>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.scalebun.sdk">
+
+    <!-- The SDK uploads telemetry (crashes, replay frames, performance) over the
+         network. Host RN/Expo apps normally declare INTERNET already; declaring it
+         here ensures it is present via manifest merging. -->
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <!-- [Slice D] Engage feedback voice notes (opt-in; requested at runtime before record). -->
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+
+    <!-- Screen capture for session replay uses PixelCopy against the Activity
+         window — no special permission required. -->
+</manifest>

package/android/src/main/java/com/scalebun/core/crash/CrashStorage.kt

@@ -1,41 +1,155 @@
-package com.scalebun.core.crash
-
-import android.content.Context
-import org.json.JSONObject
-import java.io.File
-
-/**
- * Persists a single crash record to internal storage.
- * Written synchronously in the UncaughtExceptionHandler before the process dies.
- * Read and cleared on next launch via ScaleBunCrashModule.drainPendingCrash().
- */
-internal object CrashStorage {
-
-    private const val FILE_NAME = "scalebun_native_crash.json"
-
-    fun write(context: Context, crashData: JSONObject) {
-        try {
-            File(context.filesDir, FILE_NAME).writeText(crashData.toString())
-        } catch (_: Exception) {
-            // Must not throw — called from uncaught exception handler
-        }
-    }
-
-    fun read(context: Context): JSONObject? {
-        return try {
-            val file = File(context.filesDir, FILE_NAME)
-            if (!file.exists()) null else JSONObject(file.readText())
-        } catch (_: Exception) {
-            null
-        }
-    }
-
-    fun clear(context: Context) {
-        try {
-            File(context.filesDir, FILE_NAME).delete()
-        } catch (_: Exception) {}
-    }
-
-    fun hasPending(context: Context): Boolean =
-        File(context.filesDir, FILE_NAME).exists()
-}
+package com.scalebun.core.crash
+
+import android.content.Context
+import org.json.JSONObject
+import java.io.File
+
+/**
+ * Persists a single crash record to internal storage.
+ * Written synchronously in the UncaughtExceptionHandler before the process dies.
+ * Read and cleared on next launch via ScaleBunCrashModule.drainPendingCrash().
+ */
+internal object CrashStorage {
+
+    private const val FILE_NAME = "scalebun_native_crash.json"
+
+    /**
+     * The session that is live RIGHT NOW, written once per session and read by the crash handler.
+     *
+     * WHY A SEPARATE FILE, AND WHY WRITTEN AHEAD OF TIME.
+     *
+     * A crash record survives the process; the JS session id did not, because it only ever existed
+     * in JS memory. So on the next launch there was nothing to attribute the crash to except
+     * whichever session had just been created — the crash from session A landed on session B.
+     *
+     * The fix is not to hand the id to the crash handler (a fatal handler cannot call into JS, and
+     * must not allocate or block), but to make sure it is ALREADY ON DISK before any crash can
+     * happen. This file is that guarantee: written once when a session starts, read synchronously
+     * inside `uncaughtException`.
+     *
+     * Kept separate from the crash record so a stale id can never resurrect a cleared crash, and so
+     * clearing a drained crash does not disturb the live session's identity.
+     */
+    private const val SESSION_FILE_NAME = "scalebun_active_session.txt"
+
+    /**
+     * Record the session that is now live. Called once per session from JS, never per event.
+     *
+     * Synchronous by design: it must be durable before the next line of app code runs, because the
+     * next line of app code is exactly what might crash. One small write per session is affordable;
+     * the same write per event would not be.
+     */
+    fun setActiveSessionId(context: Context, sessionId: String?) {
+        try {
+            val file = File(context.filesDir, SESSION_FILE_NAME)
+            if (sessionId.isNullOrEmpty()) file.delete() else file.writeText(sessionId)
+        } catch (_: Exception) {
+            // A missing session id degrades attribution; it must never break the app.
+        }
+    }
+
+    /**
+     * The live session id, or null.
+     *
+     * Called from the uncaught-exception handler, so it does exactly one thing: read a small file.
+     * No allocation beyond the string, no locks, no JS, no network.
+     */
+    fun activeSessionId(context: Context): String? {
+        return try {
+            val file = File(context.filesDir, SESSION_FILE_NAME)
+            if (!file.exists()) null else file.readText().trim().ifEmpty { null }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    /**
+     * How many undelivered crashes we keep.
+     *
+     * One process produces one fatal crash, so this is not about a burst — it is about a device
+     * that crashes, restarts offline, and crashes again before the first crash could be uploaded.
+     * With a single fixed filename the second crash silently overwrote the first.
+     *
+     * Three is deliberately small: crashes are only pending while delivery is failing, and an
+     * unbounded spool on a device that crashes in a loop is its own bug. When full, the OLDEST is
+     * dropped — a fresh crash is better evidence than a stale one, and the alternative (dropping the
+     * new one) would hide an ongoing crash loop behind the first crash of the day.
+     */
+    private const val MAX_PENDING = 3
+    private const val PREFIX = "scalebun_native_crash"
+
+    /** Every pending crash file, oldest first. */
+    private fun pendingFiles(context: Context): List<File> =
+        (context.filesDir.listFiles { f -> f.name.startsWith(PREFIX) && f.name.endsWith(".json") }
+            ?: emptyArray())
+            .sortedBy { it.lastModified() }
+
+    /**
+     * Persist a crash. Each gets its own file and its own STABLE id.
+     *
+     * The id is generated HERE, once, when the crash is first written — never at upload time. It is
+     * what makes retry safe: the backend dedupes on it, so the same crash delivered any number of
+     * times produces one record. An id minted per attempt would defeat that completely.
+     */
+    fun write(context: Context, crashData: JSONObject) {
+        try {
+            val crashId = crashData.optString("crashId", "").ifEmpty {
+                // Time + identity hash: unique in practice, and derivable without allocation-heavy
+                // APIs so the same scheme can be mirrored on the signal path.
+                "crash-${System.currentTimeMillis()}-${android.os.Process.myPid()}"
+            }
+            crashData.put("crashId", crashId)
+
+            val existing = pendingFiles(context)
+            if (existing.size >= MAX_PENDING) {
+                existing.take(existing.size - MAX_PENDING + 1).forEach { runCatching { it.delete() } }
+            }
+            File(context.filesDir, "$PREFIX-$crashId.json").writeText(crashData.toString())
+        } catch (_: Exception) {
+            // Must not throw — called from uncaught exception handler
+        }
+    }
+
+    /**
+     * Every pending crash, WITHOUT deleting anything.
+     *
+     * Read used to clear as a side effect, so a failed upload lost the crash permanently: the only
+     * durable copy was destroyed before anyone knew the network had worked. Deletion is now a
+     * separate, explicit act performed after the backend accepts — see [clearCrash].
+     */
+    fun readAll(context: Context): List<JSONObject> =
+        pendingFiles(context).mapNotNull { f ->
+            runCatching { JSONObject(f.readText()) }.getOrNull()
+        }
+
+    /** Drop one delivered crash by its stable id. Safe to call for an id that is already gone. */
+    fun clearCrash(context: Context, crashId: String) {
+        try {
+            File(context.filesDir, "$PREFIX-$crashId.json").delete()
+            // Legacy single-file record predating per-crash ids.
+            if (crashId.isEmpty()) File(context.filesDir, FILE_NAME).delete()
+        } catch (_: Exception) {}
+    }
+
+    /**
+     * The LEGACY single-file record, kept only so a crash written by a previous SDK version is not
+     * stranded on disk after an app update. Read non-destructively like everything else now.
+     */
+    fun read(context: Context): JSONObject? {
+        return try {
+            val file = File(context.filesDir, FILE_NAME)
+            if (!file.exists()) null else JSONObject(file.readText())
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    fun clear(context: Context) {
+        try {
+            File(context.filesDir, FILE_NAME).delete()
+        } catch (_: Exception) {}
+    }
+
+    fun hasPending(context: Context): Boolean =
+        File(context.filesDir, FILE_NAME).exists()
+}