@scalebun-release/react-native 2.5.0

package/android/src/main/java/com/scalebun/rn/ota/TlsPinning.kt

@@ -0,0 +1,118 @@
+package com.scalebun.rn.ota
+
+import android.content.Context
+import android.util.Base64
+import android.util.Log
+import java.security.MessageDigest
+import java.security.cert.X509Certificate
+import javax.net.ssl.HttpsURLConnection
+import org.json.JSONObject
+
+/**
+ * Optional certificate pinning for the OTA artifact download.
+ *
+ * Pins are **SPKI SHA-256 hashes**, not certificates. Pinning a certificate
+ * breaks on every renewal even when the key is unchanged, which is how pinning
+ * earns its reputation for bricking apps; pinning the public key survives
+ * renewal and only needs rotating when the key itself rotates.
+ *
+ * Configuration is a native asset, `scalebun_tls_pins.json`, alongside the
+ * trusted-key registry — JavaScript must not be able to introduce or remove a
+ * pin, for the same reason it cannot introduce a signing key:
+ *
+ *   { "pins": {
+ *       "api.scalebun.com": ["sha256/AAAA…", "sha256/BBBB…"]
+ *   }}
+ *
+ * **Absent asset = pinning disabled.** That is deliberate. A pin that ships
+ * wrong cannot be fixed over the air — it takes a store release — so this is
+ * opt-in, and refuses to arm with fewer than two pins for a host: one live, one
+ * backup. An operator who pins a single key has built a single point of failure
+ * that a routine key rotation will detonate.
+ */
+object TlsPinning {
+
+    private const val TAG = "ScaleBunOta"
+    private const val ASSET = "scalebun_tls_pins.json"
+    private const val MIN_PINS = 2
+
+    private var loaded = false
+    private var pinsByHost: Map<String, Set<String>> = emptyMap()
+
+    @Synchronized
+    private fun load(context: Context) {
+        if (loaded) return
+        loaded = true
+        try {
+            val json = context.assets.open(ASSET).use {
+                it.readBytes().toString(Charsets.UTF_8)
+            }
+            val root = JSONObject(json).optJSONObject("pins") ?: return
+            val map = mutableMapOf<String, Set<String>>()
+            for (host in root.keys()) {
+                val arr = root.optJSONArray(host) ?: continue
+                val set = (0 until arr.length()).mapNotNull { arr.optString(it, null) }.toSet()
+                if (set.size < MIN_PINS) {
+                    Log.e(
+                        TAG,
+                        "TLS pinning NOT armed for $host — ${set.size} pin(s) configured, " +
+                            "at least $MIN_PINS required (a live pin and a backup). " +
+                            "Shipping one pin means the next key rotation bricks the app.",
+                    )
+                    continue
+                }
+                map[host.lowercase()] = set
+            }
+            pinsByHost = map
+            if (map.isNotEmpty()) {
+                Log.i(TAG, "TLS pinning armed for: ${map.keys.joinToString(", ")}")
+            }
+        } catch (_: Exception) {
+            // No asset shipped: pinning is simply not in use.
+            pinsByHost = emptyMap()
+        }
+    }
+
+    /** True when this host has pins configured, so callers can log honestly. */
+    fun isPinned(context: Context, host: String): Boolean {
+        load(context)
+        return pinsByHost.containsKey(host.lowercase())
+    }
+
+    /**
+     * Verify an established HTTPS connection against the pins for its host.
+     *
+     * Returns true when the connection is acceptable — either because no pins
+     * are configured for that host, or because one of the certificates in the
+     * presented chain matches a pin. Returns false ONLY when pins exist and none
+     * matched, which is a hard failure the caller must treat as a failed
+     * download rather than retrying against the same endpoint.
+     */
+    fun verify(context: Context, connection: HttpsURLConnection, host: String): Boolean {
+        load(context)
+        val expected = pinsByHost[host.lowercase()] ?: return true
+
+        val chain = try {
+            connection.serverCertificates
+        } catch (e: Exception) {
+            Log.e(TAG, "TLS pin check could not read the certificate chain for $host", e)
+            return false
+        }
+
+        for (cert in chain) {
+            val x509 = cert as? X509Certificate ?: continue
+            val spki = x509.publicKey.encoded ?: continue
+            val digest = MessageDigest.getInstance("SHA-256").digest(spki)
+            val pin = "sha256/" + Base64.encodeToString(digest, Base64.NO_WRAP)
+            if (expected.contains(pin)) return true
+        }
+
+        Log.e(
+            TAG,
+            "TLS PIN MISMATCH for $host — the presented certificate chain matches none " +
+                "of the ${expected.size} configured pins. Refusing the download. This is " +
+                "either an interception attempt or a rotated key whose pin was never shipped.",
+        )
+        return false
+    }
+}

package/android/src/main/java/com/scalebun/rn/performance/PerformanceModule.kt

@@ -0,0 +1,217 @@
+package com.scalebun.rn.performance
+
+import android.app.Application
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.scalebun.core.performance.AppStartCollector
+import com.scalebun.core.performance.ANRWatchdog
+import com.scalebun.core.performance.FrameMetricsCollector
+import com.scalebun.core.performance.PerformanceCore
+
+/**
+ * React Native bridge module for native performance capture.
+ *
+ * ARCHITECTURE:
+ * This is a THIN BINDING — it delegates all work to [PerformanceCore]
+ * (in `com.scalebun.core.performance`) and bridges its callbacks to
+ * RCTDeviceEventEmitter events.
+ *
+ * The core performance logic has zero React Native dependencies.
+ * This module only handles:
+ * 1. RN bridge method annotations (@ReactMethod)
+ * 2. Promise resolution/rejection
+ * 3. WritableMap construction for RN event emission
+ * 4. Wiring PerformanceCore.Listener → RCTDeviceEventEmitter
+ *
+ * Emitted events (unchanged from previous implementation):
+ * - "ScaleBunPerformance_FrameMetrics" — periodic frame metrics snapshot
+ * - "ScaleBunPerformance_UiHang"      — main-thread hang detected
+ *
+ * All methods are safe — catch and reject on error.
+ */
+class PerformanceModule(reactContext: ReactApplicationContext) : PerformanceSpec(reactContext) {
+
+    companion object {
+        const val NAME = "ScaleBunPerformance"
+        private const val TAG = "ScaleBunPerformance"
+    }
+
+    override fun getName(): String = NAME
+
+    private var core: PerformanceCore? = null
+
+    // ─── Event Emission ─────────────────────────────────────────────────
+
+    private fun emit(eventName: String, params: WritableMap) {
+        try {
+            reactApplicationContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(eventName, params)
+        } catch (_: Exception) {}
+    }
+
+    // ─── Core Listener → RN Events ──────────────────────────────────────
+
+    private val coreListener = object : PerformanceCore.Listener {
+        override fun onAppStart(info: AppStartCollector.AppStartInfo) {
+            // App start info is captured — will be returned on query via getAppStartInfo()
+        }
+
+        override fun onFrameMetrics(snapshot: FrameMetricsCollector.FrameMetricsSnapshot) {
+            val params = Arguments.createMap().apply {
+                putInt("totalFrames", snapshot.totalFrames)
+                putInt("droppedFrames", snapshot.droppedFrames)
+                putInt("slowFrames", snapshot.slowFrames)
+                putInt("frozenFrames", snapshot.frozenFrames)
+                putDouble("maxFrameTimeMs", snapshot.maxFrameTimeMs)
+                putDouble("windowMs", snapshot.windowMs.toDouble())
+            }
+            Log.i(TAG, "emit FrameMetrics: totalFrames=${snapshot.totalFrames} dropped=${snapshot.droppedFrames}")
+            emit("ScaleBunPerformance_FrameMetrics", params)
+        }
+
+        override fun onHangDetected(info: ANRWatchdog.HangInfo) {
+            val params = Arguments.createMap().apply {
+                putDouble("durationMs", info.durationMs.toDouble())
+                putDouble("timestamp", info.timestamp.toDouble())
+            }
+            Log.i(TAG, "emit UiHang: durationMs=${info.durationMs}")
+            emit("ScaleBunPerformance_UiHang", params)
+        }
+    }
+
+    // ─── Initialize ─────────────────────────────────────────────────────
+
+    @ReactMethod
+    override fun initialize(promise: Promise) {
+        try {
+            if (core?.isInitialized == true) {
+                Log.i(TAG, "initialize() — already initialized, no-op")
+                promise.resolve(true)
+                return
+            }
+
+            val app = reactApplicationContext.applicationContext as? Application
+            if (app == null) {
+                Log.w(TAG, "initialize() — Application context not available")
+                promise.reject("PERF_INIT_ERROR", "Application context not available")
+                return
+            }
+
+            val performanceCore = PerformanceCore(app)
+            performanceCore.listener = coreListener
+            performanceCore.initialize()
+            core = performanceCore
+
+            Log.i(TAG, "initialize() — native performance core started")
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.w(TAG, "initialize() — failed: ${e.message}")
+            promise.reject("PERF_INIT_ERROR", e.message, e)
+        }
+    }
+
+    // ─── App Start ──────────────────────────────────────────────────────
+
+    @ReactMethod
+    override fun getAppStartInfo(promise: Promise) {
+        try {
+            val info = core?.getAppStartInfo()
+            if (info != null) {
+                Log.i(TAG, "getAppStartInfo() — launchType=${info.launchType} durationMs=${info.durationMs} inferred=${info.inferred}")
+                val result = Arguments.createMap().apply {
+                    putString("launchType", info.launchType)
+                    putDouble("durationMs", info.durationMs.toDouble())
+                    putBoolean("inferred", info.inferred)
+                    info.breakdown?.let { breakdown ->
+                        val breakdownMap = Arguments.createMap().apply {
+                            breakdown.processStartMs?.let { putDouble("processStartMs", it.toDouble()) }
+                            breakdown.activityCreateMs?.let { putDouble("activityCreateMs", it.toDouble()) }
+                            breakdown.firstFrameMs?.let { putDouble("firstFrameMs", it.toDouble()) }
+                        }
+                        putMap("breakdown", breakdownMap)
+                    }
+                }
+                promise.resolve(result)
+            } else {
+                Log.w(TAG, "getAppStartInfo() — no info available (core=${if (core == null) "null" else "present"})")
+                promise.resolve(null)
+            }
+        } catch (e: Exception) {
+            promise.reject("PERF_ERROR", e.message, e)
+        }
+    }
+
+    // ─── Frame Metrics ──────────────────────────────────────────────────
+
+    @ReactMethod
+    override fun startFrameMetrics(intervalMs: Double, promise: Promise) {
+        try {
+            core?.startFrameMetrics(
+                intervalMs = intervalMs.toLong(),
+                activity = reactApplicationContext.currentActivity
+            )
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("PERF_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    override fun stopFrameMetrics(promise: Promise) {
+        try {
+            core?.stopFrameMetrics()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("PERF_ERROR", e.message, e)
+        }
+    }
+
+    // ─── ANR / Hang Detection ───────────────────────────────────────────
+
+    @ReactMethod
+    override fun startHangDetection(thresholdMs: Double, promise: Promise) {
+        try {
+            core?.startHangDetection(thresholdMs = thresholdMs.toLong())
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("PERF_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    override fun stopHangDetection(promise: Promise) {
+        try {
+            core?.stopHangDetection()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("PERF_ERROR", e.message, e)
+        }
+    }
+
+    // ─── Cleanup ────────────────────────────────────────────────────────
+
+    @ReactMethod
+    override fun destroy(promise: Promise) {
+        try {
+            core?.destroy()
+            core = null
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("PERF_ERROR", e.message, e)
+        }
+    }
+
+    // ─── Event Emitter Support ──────────────────────────────────────────
+
+    @ReactMethod
+    override fun addListener(eventName: String) {
+        // Required for RN NativeEventEmitter
+    }
+
+    @ReactMethod
+    override fun removeListeners(count: Double) {
+        // Required for RN NativeEventEmitter
+    }
+}

package/android/src/main/java/com/scalebun/rn/referrer/ScaleBunInstallReferrerModule.kt

@@ -0,0 +1,77 @@
+package com.scalebun.rn.referrer
+
+import com.android.installreferrer.api.InstallReferrerClient
+import com.android.installreferrer.api.InstallReferrerStateListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * React Native bridge for Google Play's Install Referrer API (`ScaleBunInstallReferrer`).
+ *
+ * Android-only (iOS attribution is SKAdNetwork). Reads the `referrer` string the
+ * Play Store recorded at install time — e.g. `scalebun_click_id=...&utm_source=...`
+ * — which the JS layer parses for deterministic install attribution.
+ *
+ * Backward-compatible across architectures: extends [ScaleBunInstallReferrerSpec],
+ * the codegen TurboModule base on New Arch (`src/newarch`) and a classic
+ * NativeModule base on Old Arch (`src/oldarch`). Thin glue only.
+ *
+ * The Play Install Referrer service is a short-lived async IPC connection; we open
+ * it per call, settle the promise exactly once, and always close the connection.
+ */
+class ScaleBunInstallReferrerModule(reactContext: ReactApplicationContext) :
+    ScaleBunInstallReferrerSpec(reactContext) {
+
+    companion object {
+        const val NAME = "ScaleBunInstallReferrer"
+    }
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    override fun getInstallReferrer(promise: Promise) {
+        val settled = AtomicBoolean(false)
+        val client = InstallReferrerClient.newBuilder(reactApplicationContext).build()
+
+        fun rejectOnce(code: String, message: String) {
+            if (settled.compareAndSet(false, true)) promise.reject(code, message)
+            try { client.endConnection() } catch (_: Exception) {}
+        }
+
+        try {
+            client.startConnection(object : InstallReferrerStateListener {
+                override fun onInstallReferrerSetupFinished(responseCode: Int) {
+                    when (responseCode) {
+                        InstallReferrerClient.InstallReferrerResponse.OK -> {
+                            if (!settled.compareAndSet(false, true)) return
+                            try {
+                                // Resolve the raw referrer ("" for an organic install).
+                                val referrer = client.installReferrer.installReferrer ?: ""
+                                promise.resolve(referrer)
+                            } catch (e: Exception) {
+                                promise.reject("SCALEBUN_INSTALL_REFERRER_ERROR", e.message, e)
+                            } finally {
+                                try { client.endConnection() } catch (_: Exception) {}
+                            }
+                        }
+                        // FEATURE_NOT_SUPPORTED / SERVICE_UNAVAILABLE / DEVELOPER_ERROR:
+                        // reject so JS returns null and may retry on a later launch.
+                        else -> rejectOnce(
+                            "SCALEBUN_INSTALL_REFERRER_UNAVAILABLE",
+                            "responseCode=$responseCode",
+                        )
+                    }
+                }
+
+                override fun onInstallReferrerServiceDisconnected() {
+                    rejectOnce("SCALEBUN_INSTALL_REFERRER_DISCONNECTED", "service disconnected")
+                }
+            })
+        } catch (e: Exception) {
+            // SecurityException / Play services missing, etc.
+            rejectOnce("SCALEBUN_INSTALL_REFERRER_ERROR", e.message ?: "start failed")
+        }
+    }
+}

package/android/src/main/java/com/scalebun/rn/storage/ScaleBunStorageModule.kt

@@ -0,0 +1,68 @@
+package com.scalebun.rn.storage
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.scalebun.storage.KvFileStore
+
+/**
+ * React Native bridge for the SDK's first-party durable key-value store
+ * (`ScaleBunStorage`). Requires NO third-party storage dependency.
+ *
+ * Backward-compatible across architectures: extends [ScaleBunStorageSpec], which is the
+ * codegen TurboModule base on New Arch (`src/newarch`) and a classic NativeModule
+ * base on Old Arch (`src/oldarch`). All persistence logic lives in
+ * [com.scalebun.storage.KvFileStore] (atomic, app-private file) — this is thin glue.
+ *
+ * Methods:
+ *   getAllSync()              — SYNC: returns all entries as a JSON object string
+ *                               (used once by JS to hydrate its in-memory mirror)
+ *   setItems(entriesJson)     — async write-through of a JSON object of entries
+ *   removeItems(keysJson)     — async delete of a JSON array of keys
+ *   clear()                   — async wipe of the store + backing file
+ */
+class ScaleBunStorageModule(reactContext: ReactApplicationContext) :
+    ScaleBunStorageSpec(reactContext) {
+
+    private val store = KvFileStore(reactContext.applicationContext)
+
+    companion object {
+        const val NAME = "ScaleBunStorage"
+    }
+
+    override fun getName(): String = NAME
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun getAllSync(): String =
+        try { store.getAllJson() } catch (_: Exception) { "{}" }
+
+    @ReactMethod
+    override fun setItems(entriesJson: String, promise: Promise) {
+        try {
+            store.setItems(entriesJson)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("SCALEBUN_STORAGE_SET_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    override fun removeItems(keysJson: String, promise: Promise) {
+        try {
+            store.removeItems(keysJson)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("SCALEBUN_STORAGE_REMOVE_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    override fun clear(promise: Promise) {
+        try {
+            store.clear()
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("SCALEBUN_STORAGE_CLEAR_ERROR", e.message, e)
+        }
+    }
+}

package/android/src/main/java/com/scalebun/storage/KvFileStore.kt

@@ -0,0 +1,174 @@
+package com.scalebun.storage
+
+import android.content.Context
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.ScheduledFuture
+import java.util.concurrent.TimeUnit
+
+/**
+ * First-party, app-private durable key-value store for the ScaleBun SDK.
+ *
+ * This is the SDK's OWN persistence — it requires NO third-party storage library.
+ * It backs the JS `StorageBackend` (event outbox, retry/batch metadata, engage
+ * throttle state, device/installation identifiers).
+ *
+ * Storage layout:
+ *   <filesDir>/scalebun_kv.json   — a single JSON object { "<key>": "<value>", ... }
+ *
+ * Durability rules:
+ *  - In-memory authoritative map, loaded once from disk on first access.
+ *  - Atomic writes only: serialize to `scalebun_kv.json.tmp`, fsync, then rename onto
+ *    `scalebun_kv.json`. A process kill therefore never leaves a half-written file —
+ *    on the next launch either the previous complete file or the new complete
+ *    file is present, never a corrupt mix.
+ *  - Writes are coalesced: many `setItems`/`removeItems` calls in a burst (e.g. a
+ *    50-event flush) collapse into a single debounced disk write off the caller's
+ *    thread, so the JS/bridge thread is never blocked on file IO.
+ *
+ * Thread-safety: the map and dirty flag are guarded by [lock]; disk writes run on
+ * a single-thread scheduled executor that snapshots the map under the lock.
+ */
+internal class KvFileStore(context: Context) {
+
+    private val file = File(context.filesDir, FILE_NAME)
+    private val tmpFile = File(context.filesDir, "$FILE_NAME.tmp")
+
+    private val lock = Any()
+    private val map = HashMap<String, String>()
+    private var loaded = false
+
+    private val writer: ScheduledExecutorService =
+        Executors.newSingleThreadScheduledExecutor { r ->
+            Thread(r, "scalebun-kv-writer").apply { isDaemon = true }
+        }
+    private var pendingFlush: ScheduledFuture<*>? = null
+
+    companion object {
+        private const val FILE_NAME = "scalebun_kv.json"
+        private const val FLUSH_DEBOUNCE_MS = 150L
+    }
+
+    /** Load the backing file into [map] exactly once. No-throw. */
+    private fun ensureLoaded() {
+        if (loaded) return
+        synchronized(lock) {
+            if (loaded) return
+            try {
+                if (file.exists()) {
+                    val obj = JSONObject(file.readText())
+                    val keys = obj.keys()
+                    while (keys.hasNext()) {
+                        val k = keys.next()
+                        val v = obj.opt(k)
+                        if (v is String) map[k] = v
+                    }
+                }
+            } catch (_: Exception) {
+                // Corrupt/unreadable file: start empty; the next atomic flush
+                // overwrites it with a valid document. Never throw on load.
+                map.clear()
+            }
+            loaded = true
+        }
+    }
+
+    /** Synchronously return ALL entries as a JSON object string. Never throws. */
+    fun getAllJson(): String {
+        ensureLoaded()
+        return synchronized(lock) {
+            try {
+                JSONObject(map as Map<*, *>).toString()
+            } catch (_: Exception) {
+                "{}"
+            }
+        }
+    }
+
+    /** Merge a JSON object string of entries into the store, then schedule a flush. */
+    fun setItems(entriesJson: String) {
+        ensureLoaded()
+        synchronized(lock) {
+            try {
+                val obj = JSONObject(entriesJson)
+                val keys = obj.keys()
+                while (keys.hasNext()) {
+                    val k = keys.next()
+                    val v = obj.opt(k)
+                    if (v is String) map[k] = v
+                }
+            } catch (_: Exception) {
+                // Ignore a malformed batch rather than corrupt the store.
+            }
+        }
+        scheduleFlush()
+    }
+
+    /** Delete a JSON array string of keys from the store, then schedule a flush. */
+    fun removeItems(keysJson: String) {
+        ensureLoaded()
+        synchronized(lock) {
+            try {
+                val arr = JSONArray(keysJson)
+                for (i in 0 until arr.length()) {
+                    val k = arr.optString(i, null) ?: continue
+                    map.remove(k)
+                }
+            } catch (_: Exception) {
+                // Ignore a malformed batch.
+            }
+        }
+        scheduleFlush()
+    }
+
+    /** Remove every entry and delete the backing file. */
+    fun clear() {
+        synchronized(lock) {
+            map.clear()
+            loaded = true
+        }
+        // Cancel any pending write and delete both files immediately.
+        synchronized(lock) { pendingFlush?.cancel(false); pendingFlush = null }
+        writer.execute {
+            try { if (file.exists()) file.delete() } catch (_: Exception) {}
+            try { if (tmpFile.exists()) tmpFile.delete() } catch (_: Exception) {}
+        }
+    }
+
+    /** Coalesce bursty writes into one debounced atomic disk write. */
+    private fun scheduleFlush() {
+        synchronized(lock) {
+            pendingFlush?.cancel(false)
+            pendingFlush = writer.schedule({ flushToDisk() }, FLUSH_DEBOUNCE_MS, TimeUnit.MILLISECONDS)
+        }
+    }
+
+    /** Snapshot the map under the lock and atomically write it to disk. No-throw. */
+    private fun flushToDisk() {
+        val snapshot: String = synchronized(lock) {
+            try {
+                JSONObject(map as Map<*, *>).toString()
+            } catch (_: Exception) {
+                return
+            }
+        }
+        try {
+            tmpFile.outputStream().use { out ->
+                out.write(snapshot.toByteArray(Charsets.UTF_8))
+                out.flush()
+                try { out.fd.sync() } catch (_: Exception) {}
+            }
+            if (!tmpFile.renameTo(file)) {
+                // Fallback if atomic rename is unavailable on this fs: copy then delete.
+                file.writeText(snapshot)
+                tmpFile.delete()
+            }
+        } catch (_: Exception) {
+            // Disk write failure is non-fatal — the in-memory map stays correct and
+            // the next mutation reschedules a flush.
+        }
+    }
+}

package/android/src/newarch/java/com/scalebun/profiler/ProfilerSpec.kt

@@ -0,0 +1,12 @@
+package com.scalebun.profiler
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.scalebun.spec.NativeScaleBunProfilerSpec
+
+/**
+ * New Architecture base for [ProfilerModule] — delegates to the React Native
+ * Codegen-generated TurboModule spec (`com.scalebun.spec.NativeScaleBunProfilerSpec`),
+ * generated from `src/specs/NativeScaleBunProfiler.ts`.
+ */
+abstract class ProfilerSpec(reactContext: ReactApplicationContext) :
+    NativeScaleBunProfilerSpec(reactContext)

package/android/src/newarch/java/com/scalebun/replaysdk/ReplaySdkSpec.kt

@@ -0,0 +1,12 @@
+package com.scalebun.replaysdk
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.scalebun.spec.NativeReplaySdkSpec
+
+/**
+ * New Architecture base for [ReplaySdkModule] — delegates to the React Native
+ * Codegen-generated TurboModule spec (`com.scalebun.spec.NativeReplaySdkSpec`),
+ * generated from `src/specs/NativeReplaySdk.ts`.
+ */
+abstract class ReplaySdkSpec(reactContext: ReactApplicationContext) :
+    NativeReplaySdkSpec(reactContext)