@rovq/react-native 0.2.1 → 0.3.0

package/LICENSE

@@ -1,21 +1,44 @@
-MIT License
-
-Copyright (c) 2026 moatazMahdi
-
-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.
+ROVQ Software License
+
+Copyright (c) 2026 moatazMahdi. All rights reserved.
+
+This software and its source code are the property of the copyright holder.
+They are licensed, not sold.
+
+1. Permission. You may install and use this software, without changes, only
+   to add over-the-air updates to your own applications through a ROVQ server
+   that the copyright holder operates or has authorized. You may include it,
+   as part of your compiled application, in the copies of that application
+   you distribute to your users.
+
+2. Restrictions. Except as section 1 allows, you may not:
+   a. copy, modify, translate, or create derivative works of this software;
+   b. distribute, sublicense, sell, rent, or publish this software, or any
+      part of it, on its own or as part of another library, tool, or service;
+   c. use this software, or any part of it, to build or operate a product or
+      service that provides over-the-air updates, or that competes with ROVQ;
+   d. use this software with a server that the copyright holder neither
+      operates nor has authorized;
+   e. remove or change this license or any copyright notice.
+
+3. Ownership. The copyright holder keeps all rights not expressly granted
+   here. Nothing in this license grants any right to the ROVQ name or logo.
+
+4. Termination. This license ends automatically if you break any of its
+   terms. You must then stop using this software and delete every copy of it.
+
+5. No warranty. THIS 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.
+
+6. Limitation of liability. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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.
+
+Versions of this software published under the MIT License before this license
+was adopted remain available under the MIT License. This license applies to
+every later version.
+
+For any use this license does not allow, contact the copyright holder
+through https://rovq-dashboard.onrender.com.

package/README.md

@@ -4,23 +4,29 @@ Over-the-air updates for React Native apps, served by your own ROVQ server. Each
 
 **Dashboard and docs:** [rovq-dashboard.onrender.com](https://rovq-dashboard.onrender.com). Create an app there, and its page shows this setup with your own keys.
 
-Requires React Native 0.82 or newer, with the New Architecture.
+This is line 0.3, for React Native 0.72 to 0.81, with the New Architecture or without it. On React Native 0.82 and newer, install the newest line, `npm install @rovq/react-native@latest`, whose setup differs.
 
 ## Install
 
 ```sh
-npm install @rovq/react-native
+npm install @rovq/react-native@0.3
 cd ios && pod install
 ```
 
-Then connect the native side, which decides which bundle runs. The setup page of your app in the ROVQ dashboard shows this code with your app's real values.
+Keep the `0.3`: without it npm installs the newest line, which needs React Native 0.82. On React Native 0.72, also set `platform :ios, '13.4'` in the Podfile.
 
-### Android, in `MainApplication.kt`
+Then connect the native side, which decides which bundle runs. The docs in the ROVQ dashboard show the code for your React Native version, and your app's setup page fills in its real values.
+
+### Android
+
+Return the engine's choice from `getJSBundleFile()`, and start the engine first thing in `onCreate`. In `MainApplication.kt`, from React Native 0.73:
 
 ```kotlin
-override val reactHost: ReactHost by lazy {
-  RovqReactHost.create(this, PackageList(this).packages)
-}
+override val reactNativeHost: ReactNativeHost =
+    object : DefaultReactNativeHost(this) {
+      // ...what is already here, then:
+      override fun getJSBundleFile(): String? = Rovq.getJSBundleFile()
+    }
 
 override fun onCreate() {
   super.onCreate()
@@ -33,11 +39,13 @@ override fun onCreate() {
       trustedKeys = mapOf("2026-11" to "<public key>"),
     ),
   )
-  loadReactNative(this)
+  // ...what is already here.
 }
 ```
 
-### iOS, in `AppDelegate.swift` and `SceneDelegate.swift`
+On React Native 0.72, the same in `MainApplication.java`, with `protected String getJSBundleFile()` and `new RovqConfig(...)`.
+
+### iOS, from React Native 0.77, in `AppDelegate.swift`
 
 ```swift
 RovqHost.initialize(
@@ -49,6 +57,7 @@ RovqHost.initialize(
   )
 )
 
+// In the class that overrides bundleURL():
 override func bundleURL() -> URL? {
   #if DEBUG
   RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: "index")
@@ -58,6 +67,26 @@ override func bundleURL() -> URL? {
 }
 ```
 
+### iOS, on React Native 0.72 to 0.76, in `AppDelegate.mm`
+
+```objc
+#import <Rovq/RovqSetup.h>
+
+// First thing in didFinishLaunchingWithOptions:
+[RovqSetup initializeWithApiURL:@"https://your-server/api/v1"
+                  deploymentKey:@"rovq_dep_..."
+                 runtimeVersion:@"1"
+                    trustedKeys:@{@"2026-11" : @"<public key>"}
+              allowInsecureURLs:NO];
+
+// In bundleURL from 0.74, getBundleURL in 0.73, sourceURLForBridge: in 0.72:
+#if DEBUG
+  return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index"];
+#else
+  return [RovqSetup bundleURL] ?: [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
+#endif
+```
+
 ## Use
 
 ```ts
@@ -120,4 +149,4 @@ A release published by `@rovq/cli` 0.2 lists its files, and the SDK downloads on
 
 ## License
 
-MIT
+Proprietary. See [LICENSE](LICENSE).

package/Rovq.podspec

@@ -6,12 +6,16 @@ Pod::Spec.new do |s|
   s.name = 'Rovq'
   s.version = package['version']
   s.summary = package['description']
-  s.homepage = 'https://github.com/moatazMahdi/rovq'
-  s.license = 'MIT'
+  s.homepage = package['homepage']
+  s.license = { type: 'Proprietary', file: 'LICENSE' }
   s.authors = 'moatazMahdi'
-  s.platforms = { ios: min_ios_version_supported }
+  # The engine uses CryptoKit and FileHandle APIs from iOS 13.4, React Native 0.73's minimum. An
+  # app on 0.72, which allows 12.4, sets platform :ios, '13.4' in its Podfile.
+  s.platforms = { ios: '13.4' }
   s.source = { git: 'https://github.com/moatazMahdi/rovq.git', tag: s.version.to_s }
-  s.source_files = 'ios/Engine/**/*.swift', 'ios/React/**/*.{swift,mm}'
+  s.source_files = 'ios/Engine/**/*.swift', 'ios/React/**/*.{swift,h,mm}'
+  # Only this header is for apps. RovqHost reaches Swift apps through the module.
+  s.public_header_files = 'ios/React/RovqSetup.h'
   s.swift_version = '5.9'
   s.pod_target_xcconfig = { 'DEFINES_MODULE' => 'YES' }
 

package/android/build.gradle

@@ -1,13 +1,29 @@
+// The engine has no React Native code, so it can be built and tested on its own, in
+// seconds. Inside an app, the React Native integration is added on top of it.
+buildscript {
+    // An app on React Native 0.72 has no Kotlin plugin of its own, and apps from 0.73 have one.
+    // Two versions of it cannot share a build, so this uses the app's version when there is one.
+    if (rootProject.name != 'rovq-engine') {
+        def kotlinVersion = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : '1.8.22'
+        repositories {
+            google()
+            mavenCentral()
+        }
+        dependencies {
+            classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
+        }
+    }
+}
+
 plugins {
     id 'com.android.library'
 }
 
-// The engine has no React Native code, so it can be built and tested on its own, in
-// seconds. Inside an app, the React Native integration is added on top of it.
 def insideApp = rootProject.name != 'rovq-engine'
 
-// React Native's app template turns off the Kotlin support built into Android Gradle Plugin 9.
-def usesKotlinPlugin = insideApp && findProperty('android.builtInKotlin') == 'false'
+// React Native 0.72 to 0.81 build with Android Gradle Plugin 8, which compiles Kotlin only through
+// the Kotlin plugin. Without it, the Kotlin sources are left out and the app cannot find them.
+def usesKotlinPlugin = insideApp
 
 // Rebuilding only changed files fails with "Cannot access ... it is internal" when this package is
 // linked through a symbolic link, as npm's file: dependencies are. Compiling it fully each time
@@ -18,30 +34,29 @@ if (insideApp) {
 
 if (usesKotlinPlugin) {
     apply plugin: 'kotlin-android'
+    // Java compiles for 17 below, and Kotlin 1.8 stops the build when the two differ.
+    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
+        kotlinOptions.jvmTarget = '17'
+    }
 }
 
-// Keeps the two kinds of build from mixing outputs. The build inside an app stays in build/,
-// because React Native's autolinking expects the generated code there.
+// Keeps the two kinds of build from mixing outputs.
 if (!insideApp) {
     layout.buildDirectory = layout.projectDirectory.dir('build/standalone')
 }
 
-if (insideApp) {
-    apply plugin: 'com.facebook.react'
-
-    react {
-        // The app's install holds React Native, not this package's folder.
-        reactNativeDir = rootProject.file('../node_modules/react-native')
-        codegenDir = rootProject.file('../node_modules/@react-native/codegen')
-    }
+def appValue = { String name, Object fallback ->
+    rootProject.ext.has(name) ? rootProject.ext.get(name) : fallback
 }
 
 android {
     namespace = 'com.rovq.engine'
-    compileSdk = 37
+    // An app's own compileSdk, because older Android Gradle Plugins cannot read newer platforms.
+    compileSdk = insideApp ? appValue('compileSdkVersion', 36) : 37
 
     defaultConfig {
-        minSdk = 24
+        // React Native 0.72 to 0.75 apps start at API 21.
+        minSdk = 21
         testInstrumentationRunner = 'androidx.test.runner.AndroidJUnitRunner'
     }
 
@@ -53,8 +68,6 @@ android {
     sourceSets {
         if (usesKotlinPlugin) {
             main.java.srcDirs += 'src/react/java'
-        } else if (insideApp) {
-            main.kotlin.directories.add('src/react/java')
         } else {
             // Test helpers that run both on the computer and on a device.
             test.kotlin.directories.add('src/sharedTest/java')
@@ -69,11 +82,15 @@ android {
 }
 
 dependencies {
-    // Android includes Ed25519 only from API 33, and the engine supports API 24.
+    // Android includes Ed25519 only from API 33, and the engine supports API 21.
     implementation 'com.google.crypto.tink:tink-android:1.24.0'
+    // Tink brings androidx.annotation 1.8, which moved its classes to annotation-jvm, and React
+    // Native 0.72 brings 1.3. Asking for 1.8 here lifts the old one, so the classes are not twice
+    // in the app.
+    implementation 'androidx.annotation:annotation:1.8.2'
 
     if (insideApp) {
-        // The version is set by the React Native Gradle Plugin.
+        // The version is set by the React Native Gradle Plugin of the app.
         implementation 'com.facebook.react:react-android'
     }
 

package/android/src/main/java/com/rovq/engine/RovqEngine.kt

@@ -49,13 +49,13 @@ data class UpdateInfo(
 )
 
 sealed interface CheckResult {
-    data object UpToDate : CheckResult
+    object UpToDate : CheckResult
 
     /** @param alreadyDownloaded whether [RovqEngine.downloadUpdate] has nothing left to fetch. */
     data class UpdateAvailable(val update: UpdateInfo, val alreadyDownloaded: Boolean) : CheckResult
 
     /** The server asked to leave the current release. Restart to apply. */
-    data object RolledBack : CheckResult
+    object RolledBack : CheckResult
 
     data class Failed(val code: RovqErrorCode, val message: String) : CheckResult
 }
@@ -75,13 +75,13 @@ sealed interface InstallResult {
 }
 
 sealed interface SyncResult {
-    data object UpToDate : SyncResult
+    object UpToDate : SyncResult
 
     /** Installed, and loads on the next JavaScript start. */
     data class UpdateReady(val releaseId: String, val mandatory: Boolean) : SyncResult
 
     /** The server asked to leave the current release. Restart to apply. */
-    data object RolledBack : SyncResult
+    object RolledBack : SyncResult
 
     data class Failed(val code: RovqErrorCode, val message: String) : SyncResult
 }

package/android/src/main/java/com/rovq/engine/UpdateInstaller.kt

@@ -1,5 +1,6 @@
 package com.rovq.engine
 
+import android.annotation.SuppressLint
 import java.io.File
 import java.io.IOException
 import java.io.InputStream
@@ -328,6 +329,9 @@ class UpdateInstaller(
      * A hard link costs no space. Files in a release never change, so sharing them is safe.
      * Android before 8.0 has no java.nio.file, so it copies instead.
      */
+    // Lint wants a version check, but SDK_INT is 0 in unit tests on the computer, which would
+    // stop them testing the link. Before 8.0 the call throws a LinkageError, caught below.
+    @SuppressLint("NewApi")
     private fun link(source: File, target: File) {
         val linked = try {
             java.nio.file.Files.createLink(target.toPath(), source.toPath())

package/android/src/main/java/com/rovq/engine/UpdateService.kt

@@ -22,8 +22,8 @@ data class CheckRequest(
 
 /** The server's answer. It is advice only, because [OfferedUpdate] is verified before use. */
 sealed interface CheckResponse {
-    data object None : CheckResponse
-    data object Rollback : CheckResponse
+    object None : CheckResponse
+    object Rollback : CheckResponse
     data class Update(val offer: OfferedUpdate) : CheckResponse
 }
 

package/android/src/react/java/com/rovq/engine/react/Rovq.kt

@@ -5,12 +5,18 @@ import android.app.Application
 import android.content.pm.PackageInfo
 import android.os.Build
 import android.os.Bundle
+import android.util.Log
 import com.rovq.engine.EngineConfig
 import com.rovq.engine.RovqEngine
 import java.io.File
 
-/** What an app supplies. Everything here ships inside the app, so nothing here is secret. */
-data class RovqConfig(
+private const val LOG_TAG = "Rovq"
+
+/**
+ * What an app supplies. Everything here ships inside the app, so nothing here is secret.
+ * JvmOverloads lets an app written in Java leave out allowInsecureUrls.
+ */
+data class RovqConfig @JvmOverloads constructor(
     val apiUrl: String,
     val deploymentKey: String,
     /** Change this whenever native code changes. */
@@ -33,28 +39,84 @@ object Rovq {
     val engineOrNull: RovqEngine?
         get() = instance
 
+    /**
+     * If the settings are unusable, such as a public key in the wrong format, the app still
+     * starts, on the bundle inside it, and accepts no update. A typo must not crash every user's
+     * app. The reason is logged under the tag Rovq. iOS behaves the same.
+     */
+    @JvmStatic
     @Synchronized
     fun initialize(application: Application, config: RovqConfig) {
         if (instance != null) return
-        val info = application.packageManager.getPackageInfo(application.packageName, 0)
-        val engine = RovqEngine(
-            File(application.filesDir, "rovq"),
-            EngineConfig(
-                apiUrl = config.apiUrl,
-                deploymentKey = config.deploymentKey,
-                runtimeVersion = config.runtimeVersion,
-                binaryVersion = info.versionName ?: "0",
-                binaryId = binaryIdOf(info),
-                trustedKeys = config.trustedKeys,
-                allowInsecureUrls = config.allowInsecureUrls,
-            ),
-            builtInFiles = ResourceFiles(application),
-        )
+        val engine = try {
+            val info = application.packageManager.getPackageInfo(application.packageName, 0)
+            RovqEngine(
+                File(application.filesDir, "rovq"),
+                EngineConfig(
+                    apiUrl = config.apiUrl,
+                    deploymentKey = config.deploymentKey,
+                    runtimeVersion = config.runtimeVersion,
+                    binaryVersion = info.versionName ?: "0",
+                    binaryId = binaryIdOf(info),
+                    trustedKeys = config.trustedKeys,
+                    allowInsecureUrls = config.allowInsecureUrls,
+                ),
+                builtInFiles = ResourceFiles(application),
+            )
+        } catch (error: Exception) {
+            Log.e(LOG_TAG, "Could not start, so updates are off: ${error.message}", error)
+            return
+        }
         instance = engine
         application.registerActivityLifecycleCallbacks(BackgroundWatcher(engine))
         watchForCrashes(engine)
     }
 
+    /** What this JavaScript start runs. Unset until the first answer. */
+    private var chosen: Choice? = null
+
+    private class Choice(val path: String?)
+
+    /**
+     * Return this from ReactNativeHost.getJSBundleFile(). It is the update's bundle, or null for
+     * the bundle inside the app, which is what React Native loads when the answer is null.
+     *
+     * Choosing starts a pending update, so a second choice in the same start would count the
+     * first as failed and roll it back. The answer is therefore kept, because apps ask more than
+     * once: on React Native 0.76 and later, the template's reactHost getter asks on every read.
+     * Only [chooseAgain] chooses again, when RovqModule restarts JavaScript.
+     */
+    @JvmStatic
+    @Synchronized
+    fun getJSBundleFile(): String? {
+        chosen?.let { return it.path }
+        return chooseAgain()
+    }
+
+    /** Chooses the bundle for a new JavaScript start. */
+    @Synchronized
+    internal fun chooseAgain(): String? {
+        val path = choose()
+        chosen = Choice(path)
+        return path
+    }
+
+    private fun choose(): String? {
+        val file = try {
+            instance?.resolveBundle()
+        } catch (error: Throwable) {
+            // Whatever goes wrong in the engine, the app must still start.
+            Log.e(LOG_TAG, "Falling back to the bundle inside the app", error)
+            null
+        }
+        if (file == null) {
+            Log.i(LOG_TAG, "Loading the bundle inside the app")
+            return null
+        }
+        Log.i(LOG_TAG, "Loading ${file.absolutePath}")
+        return file.absolutePath
+    }
+
     private fun watchForCrashes(engine: RovqEngine) {
         val previous = Thread.getDefaultUncaughtExceptionHandler()
         Thread.setDefaultUncaughtExceptionHandler { thread, error ->

package/android/src/react/java/com/rovq/engine/react/RovqModule.kt

@@ -1,25 +1,34 @@
 package com.rovq.engine.react
 
+import android.content.Intent
 import android.util.Log
 import com.facebook.react.ReactApplication
+import com.facebook.react.ReactInstanceManager
 import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.JSBundleLoader
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.bridge.WritableMap
-import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.rovq.engine.CheckResult
 import com.rovq.engine.DownloadResult
 import com.rovq.engine.InstallResult
+import com.rovq.engine.ProgressThrottle
 import com.rovq.engine.RovqEngine
 import com.rovq.engine.RovqErrorCode
-import com.rovq.engine.ProgressThrottle
 import com.rovq.engine.SyncResult
 import com.rovq.engine.UpdateInfo
+import java.lang.reflect.Field
 import java.util.concurrent.Executors
 
-@ReactModule(name = RovqModule.NAME)
-class RovqModule(context: ReactApplicationContext) : NativeRovqSpec(context) {
+// What React Native loads when getJSBundleFile() returns null, unless an app renames it.
+private const val EMBEDDED_BUNDLE = "assets://index.android.bundle"
+
+/** A legacy native module, which React Native 0.72 to 0.81 all run. */
+class RovqModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
     // Network and disk work must stay off the JavaScript thread.
     private val worker = Executors.newSingleThreadExecutor()
 
@@ -29,7 +38,8 @@ class RovqModule(context: ReactApplicationContext) : NativeRovqSpec(context) {
 
     override fun getName(): String = NAME
 
-    override fun checkForUpdate(promise: Promise) = run(promise) { engine ->
+    @ReactMethod
+    fun checkForUpdate(promise: Promise) = run(promise) { engine ->
         when (val result = engine.checkForUpdate()) {
             CheckResult.UpToDate -> outcome("UP_TO_DATE")
             CheckResult.RolledBack -> outcome("ROLLED_BACK")
@@ -41,21 +51,24 @@ class RovqModule(context: ReactApplicationContext) : NativeRovqSpec(context) {
         }
     }
 
-    override fun downloadUpdate(promise: Promise) = run(promise) { engine ->
+    @ReactMethod
+    fun downloadUpdate(promise: Promise) = run(promise) { engine ->
         when (val result = engine.downloadUpdate(progressReporter())) {
             is DownloadResult.Downloaded -> outcome("DOWNLOADED").apply { putMap("update", toMap(result.update)) }
             is DownloadResult.Failed -> failure(result.code, result.message)
         }
     }
 
-    override fun installUpdate(promise: Promise) = run(promise) { engine ->
+    @ReactMethod
+    fun installUpdate(promise: Promise) = run(promise) { engine ->
         when (val result = engine.installUpdate()) {
             is InstallResult.Installed -> outcome("INSTALLED").apply { putString("releaseId", result.releaseId) }
             is InstallResult.Failed -> failure(result.code, result.message)
         }
     }
 
-    override fun sync(promise: Promise) = run(promise) { engine ->
+    @ReactMethod
+    fun sync(promise: Promise) = run(promise) { engine ->
         when (val result = engine.sync(progressReporter())) {
             SyncResult.UpToDate -> outcome("UP_TO_DATE")
             SyncResult.RolledBack -> outcome("ROLLED_BACK")
@@ -67,18 +80,114 @@ class RovqModule(context: ReactApplicationContext) : NativeRovqSpec(context) {
         }
     }
 
-    override fun notifyApplicationReady() {
+    @ReactMethod
+    fun notifyApplicationReady() {
         Rovq.engineOrNull?.notifyReady()
     }
 
-    override fun restartApp() {
+    @ReactMethod
+    fun restartApp() {
         UiThreadUtil.runOnUiThread {
-            val application = reactApplicationContext.applicationContext as ReactApplication
-            application.reactHost?.reload("ROVQ restart")
+            val bridgeless = reactApplicationContext.isBridgeless
+            // Found before the engine is asked, because asking starts trying the pending
+            // release. A process that ended then would count as a failed start, and the
+            // release would be abandoned, though it never ran.
+            val target = if (bridgeless) bridgelessTarget() else bridgeTarget()
+            if (target == null) {
+                restartProcess()
+                return@runOnUiThread
+            }
+            // Not getJSBundleFile(), which keeps the answer of the start that is ending.
+            val file = Rovq.chooseAgain()
+            val loader = if (file != null) {
+                JSBundleLoader.createFileLoader(file)
+            } else {
+                // Loaded the way each kind of host loads it by default.
+                JSBundleLoader.createAssetLoader(reactApplicationContext, EMBEDDED_BUNDLE, bridgeless)
+            }
+            try {
+                target.field.set(target.owner, loader)
+            } catch (error: Exception) {
+                // Unlikely once the field is accessible. The release then counts as a failed
+                // start, which is the safe way to lose it.
+                Log.w(NAME, "Could not replace the bundle loader, so the whole app restarts", error)
+                restartProcess()
+                return@runOnUiThread
+            }
+            target.reload()
+        }
+    }
+
+    /** Where a host keeps its bundle loader, and how it starts JavaScript again. */
+    private class LoaderTarget(val owner: Any, val field: Field, val reload: () -> Unit)
+
+    /**
+     * Without the New Architecture's bridgeless mode, ReactInstanceManager reads
+     * getJSBundleFile() once, when it is created, and keeps a loader in a private field.
+     * Recreating the context alone would load the old bundle again, so restartApp puts a loader
+     * for the bundle the engine chooses now in that field first, as CodePush did.
+     */
+    private fun bridgeTarget(): LoaderTarget? {
+        val manager = (reactApplicationContext.applicationContext as ReactApplication)
+            .reactNativeHost.reactInstanceManager
+        // The Java source names it mBundleLoader. A conversion to Kotlin would drop the m.
+        val field = findField(ReactInstanceManager::class.java, "mBundleLoader", "bundleLoader") ?: return null
+        return LoaderTarget(manager, field) { manager.recreateReactContextInBackground() }
+    }
+
+    /**
+     * Bridgeless mode, the default of the New Architecture from React Native 0.76, gives
+     * getJSBundleFile() to DefaultReactHostDelegate, which keeps a loader in a field. The host
+     * asks its delegate for that loader each time JavaScript starts, so replacing it before a
+     * reload is enough. Reflection throughout, because ReactApplication.getReactHost does not
+     * exist in React Native 0.72, and this file must compile there too.
+     */
+    private fun bridgelessTarget(): LoaderTarget? = try {
+        val application = reactApplicationContext.applicationContext
+        val host = application.javaClass.getMethod("getReactHost").invoke(application)
+        val delegate = host?.let { findField(it.javaClass, "mReactHostDelegate", "reactHostDelegate")?.get(it) }
+        val field = delegate?.let { findField(it.javaClass, "jsBundleLoader", "mJsBundleLoader") }
+        val reload = host?.javaClass?.getMethod("reload", String::class.java)
+        if (host == null || delegate == null || field == null || reload == null) {
+            null
+        } else {
+            LoaderTarget(delegate, field) { reload.invoke(host, "ROVQ restart") }
         }
+    } catch (error: Exception) {
+        Log.w(NAME, "Could not reach the React host, so the whole app restarts", error)
+        null
     }
 
-    override fun rollback(promise: Promise) {
+    /** Searches the class and its parents. Null if this React Native has no such field. */
+    private fun findField(type: Class<*>, vararg names: String): Field? {
+        var current: Class<*>? = type
+        while (current != null) {
+            for (name in names) {
+                try {
+                    return current.getDeclaredField(name).apply { isAccessible = true }
+                } catch (missing: NoSuchFieldException) {
+                    // Try the next name. Not `_`, which Kotlin 1.8 does not accept here.
+                }
+            }
+            current = current.superclass
+        }
+        Log.w(NAME, "${type.name} has no field ${names.joinToString(" or ")}, so the whole app restarts")
+        return null
+    }
+
+    /** Slower than a reload, but React Native creates everything again, so it always works. */
+    private fun restartProcess() {
+        val context = reactApplicationContext.applicationContext
+        val intent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+        if (intent != null) {
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+            context.startActivity(intent)
+        }
+        Runtime.getRuntime().exit(0)
+    }
+
+    @ReactMethod
+    fun rollback(promise: Promise) {
         worker.execute {
             try {
                 promise.resolve(Rovq.engineOrNull?.rollback() ?: false)
@@ -88,7 +197,8 @@ class RovqModule(context: ReactApplicationContext) : NativeRovqSpec(context) {
         }
     }
 
-    override fun getStatus(promise: Promise) {
+    @ReactMethod
+    fun getStatus(promise: Promise) {
         val status = Rovq.engineOrNull?.status()
         promise.resolve(
             Arguments.createMap().apply {
@@ -104,6 +214,13 @@ class RovqModule(context: ReactApplicationContext) : NativeRovqSpec(context) {
         )
     }
 
+    // NativeEventEmitter calls these. Events are sent whether anyone listens or not.
+    @ReactMethod
+    fun addListener(@Suppress("UNUSED_PARAMETER") eventName: String) = Unit
+
+    @ReactMethod
+    fun removeListeners(@Suppress("UNUSED_PARAMETER") count: Double) = Unit
+
     private fun run(promise: Promise, work: (RovqEngine) -> WritableMap) {
         worker.execute {
             try {
@@ -123,13 +240,16 @@ class RovqModule(context: ReactApplicationContext) : NativeRovqSpec(context) {
 
     private fun progressReporter(): (Long, Long) -> Unit {
         val throttle = ProgressThrottle { received, total ->
-            if (!invalidated) {
-                emitOnDownloadProgress(
-                    Arguments.createMap().apply {
-                        putDouble("receivedBytes", received.toDouble())
-                        putDouble("totalBytes", total.toDouble())
-                    },
-                )
+            if (!invalidated && reactApplicationContext.hasActiveReactInstance()) {
+                reactApplicationContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit(
+                        PROGRESS_EVENT,
+                        Arguments.createMap().apply {
+                            putDouble("receivedBytes", received.toDouble())
+                            putDouble("totalBytes", total.toDouble())
+                        },
+                    )
             }
         }
         return throttle::report
@@ -160,5 +280,8 @@ class RovqModule(context: ReactApplicationContext) : NativeRovqSpec(context) {
 
     companion object {
         const val NAME = "Rovq"
+
+        /** The same name as DOWNLOAD_PROGRESS_EVENT in src/NativeRovq.ts. */
+        const val PROGRESS_EVENT = "RovqDownloadProgress"
     }
 }

package/android/src/react/java/com/rovq/engine/react/RovqPackage.java

@@ -0,0 +1,25 @@
+package com.rovq.engine.react;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Found by React Native autolinking. Java, not Kotlin, because ReactPackage moved from Java to
+ * Kotlin within the versions this line supports, and only a Java class overrides both.
+ */
+public class RovqPackage implements ReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        return Collections.singletonList(new RovqModule(reactContext));
+    }
+
+    @Override
+    @SuppressWarnings("rawtypes")
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/ios/React/RovqHost.swift

@@ -65,6 +65,27 @@ public final class RovqHost: NSObject {
         }
     }
 
+    /// The same, for an AppDelegate written in Objective-C, as React Native's templates were until
+    /// 0.77. A Swift struct such as RovqConfig cannot cross into Objective-C.
+    @objc(initializeWithApiURL:deploymentKey:runtimeVersion:trustedKeys:allowInsecureURLs:)
+    public static func initialize(
+        apiURL: String,
+        deploymentKey: String,
+        runtimeVersion: String,
+        trustedKeys: [String: String],
+        allowInsecureURLs: Bool
+    ) {
+        initialize(
+            config: RovqConfig(
+                apiURL: apiURL,
+                deploymentKey: deploymentKey,
+                runtimeVersion: runtimeVersion,
+                trustedKeys: trustedKeys,
+                allowInsecureURLs: allowInsecureURLs
+            )
+        )
+    }
+
     /// An app with scenes gets the scene notification, and one without gets the app one. With
     /// several windows, only the last one leaving counts as leaving the app.
     private static func watchForBackground() {
@@ -82,9 +103,9 @@ public final class RovqHost: NSObject {
         ]
     }
 
-    /// React Native calls this each time JavaScript starts, including on reload. Returns nil
-    /// for the bundle inside the app.
-    public static func bundleURL() -> URL? {
+    /// Return this from sourceURLForBridge: or bundleURL, which React Native calls each time
+    /// JavaScript starts, including on reload. Returns nil for the bundle inside the app.
+    @objc public static func bundleURL() -> URL? {
         guard let engine else { return nil }
         let bundle = engine.resolveBundle()
         if engine.status().tryingReleaseId != nil {

package/ios/React/RovqModule.mm

@@ -1,8 +1,9 @@
-// Objective-C++ because a TurboModule must return a C++ object. The work happens in Swift.
+// A legacy native module, which React Native 0.72 to 0.81 all run, with or without the New
+// Architecture. The work happens in Swift.
 #import <Foundation/Foundation.h>
-#import <RovqSpec/RovqSpec.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
 #import <React/RCTReloadCommand.h>
-#import <React/RCTUtils.h>
 
 #if __has_include(<Rovq/Rovq-Swift.h>)
 #import <Rovq/Rovq-Swift.h>
@@ -10,47 +11,66 @@
 #import "Rovq-Swift.h"
 #endif
 
-@interface RovqModule : NativeRovqSpecBase <NativeRovqSpec>
+// The same name as DOWNLOAD_PROGRESS_EVENT in src/NativeRovq.ts.
+static NSString *const RovqDownloadProgressEvent = @"RovqDownloadProgress";
+
+@interface RovqModule : RCTEventEmitter <RCTBridgeModule>
 @end
 
-@implementation RovqModule
+@implementation RovqModule {
+  BOOL _hasListeners;
+}
 
 RCT_EXPORT_MODULE(Rovq)
 
-- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
-    (const facebook::react::ObjCTurboModule::InitParams &)params
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[ RovqDownloadProgressEvent ];
+}
+
+- (void)startObserving
+{
+  _hasListeners = YES;
+}
+
+- (void)stopObserving
 {
-  return std::make_shared<facebook::react::NativeRovqSpecJSI>(params);
+  _hasListeners = NO;
 }
 
-- (void)checkForUpdate:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(checkForUpdate : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
 {
   [RovqHost checkForUpdateWithCompletion:^(NSDictionary<NSString *, id> *result) {
     resolve(result);
   }];
 }
 
-- (void)downloadUpdate:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(downloadUpdate : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
 {
   [RovqHost downloadUpdateOnProgress:[self progressReporter]
-                              completion:^(NSDictionary<NSString *, id> *result) {
-                                resolve(result);
-                              }];
+                          completion:^(NSDictionary<NSString *, id> *result) {
+                            resolve(result);
+                          }];
 }
 
-- (void)installUpdate:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(installUpdate : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
 {
   [RovqHost installUpdateWithCompletion:^(NSDictionary<NSString *, id> *result) {
     resolve(result);
   }];
 }
 
-- (void)sync:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(sync : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
 {
   [RovqHost syncOnProgress:[self progressReporter]
-                    completion:^(NSDictionary<NSString *, id> *result) {
-                      resolve(result);
-                    }];
+                completion:^(NSDictionary<NSString *, id> *result) {
+                  resolve(result);
+                }];
 }
 
 // Weak, because a download keeps running through a reload, when this module has gone.
@@ -58,16 +78,22 @@ RCT_EXPORT_MODULE(Rovq)
 {
   __weak RovqModule *weakSelf = self;
   return ^(int64_t received, int64_t total) {
-    [weakSelf emitOnDownloadProgress:@{@"receivedBytes" : @(received), @"totalBytes" : @(total)}];
+    RovqModule *strongSelf = weakSelf;
+    // Sending with no listener only logs a warning, so it is skipped.
+    if (strongSelf == nil || !strongSelf->_hasListeners) {
+      return;
+    }
+    [strongSelf sendEventWithName:RovqDownloadProgressEvent
+                             body:@{@"receivedBytes" : @(received), @"totalBytes" : @(total)}];
   };
 }
 
-- (void)notifyApplicationReady
+RCT_EXPORT_METHOD(notifyApplicationReady)
 {
   [RovqHost notifyReady];
 }
 
-- (void)restartApp
+RCT_EXPORT_METHOD(restartApp)
 {
   // Always later, never at once: RCTExecuteOnMainQueue runs immediately when already on the main
   // thread, which reloads JavaScript while it is still inside this call.
@@ -76,14 +102,14 @@ RCT_EXPORT_MODULE(Rovq)
   });
 }
 
-- (void)rollback:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(rollback : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
 {
   [RovqHost rollbackWithCompletion:^(BOOL result) {
     resolve(@(result));
   }];
 }
 
-- (void)getStatus:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(getStatus : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
 {
   resolve([RovqHost status]);
 }

package/ios/React/RovqSetup.h

@@ -0,0 +1,27 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// For an AppDelegate written in Objective-C, as React Native's templates were until 0.77. Such a
+/// file cannot import the header Swift generates for this pod, so these call RovqHost for it.
+/// An AppDelegate written in Swift uses RovqHost directly.
+@interface RovqSetup : NSObject
+
+/// Must run before React Native starts. If the settings are unusable, the app still runs the
+/// bundle inside it, and no update is ever accepted.
++ (void)initializeWithApiURL:(NSString *)apiURL
+               deploymentKey:(NSString *)deploymentKey
+              runtimeVersion:(NSString *)runtimeVersion
+                 trustedKeys:(NSDictionary<NSString *, NSString *> *)trustedKeys
+           allowInsecureURLs:(BOOL)allowInsecureURLs;
+
+/// Return this from sourceURLForBridge: or bundleURL. Nil means the bundle inside the app.
++ (nullable NSURL *)bundleURL;
+
+/// Goes back one release, as rollback() does in JavaScript. The completion says whether there
+/// was one to leave, on a background queue. It applies when JavaScript next starts.
++ (void)rollbackWithCompletion:(void (^)(BOOL rolledBack))completion;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/React/RovqSetup.mm

@@ -0,0 +1,34 @@
+#import "RovqSetup.h"
+
+#if __has_include(<Rovq/Rovq-Swift.h>)
+#import <Rovq/Rovq-Swift.h>
+#else
+#import "Rovq-Swift.h"
+#endif
+
+@implementation RovqSetup
+
++ (void)initializeWithApiURL:(NSString *)apiURL
+               deploymentKey:(NSString *)deploymentKey
+              runtimeVersion:(NSString *)runtimeVersion
+                 trustedKeys:(NSDictionary<NSString *, NSString *> *)trustedKeys
+           allowInsecureURLs:(BOOL)allowInsecureURLs
+{
+  [RovqHost initializeWithApiURL:apiURL
+                   deploymentKey:deploymentKey
+                  runtimeVersion:runtimeVersion
+                     trustedKeys:trustedKeys
+               allowInsecureURLs:allowInsecureURLs];
+}
+
++ (nullable NSURL *)bundleURL
+{
+  return [RovqHost bundleURL];
+}
+
++ (void)rollbackWithCompletion:(void (^)(BOOL rolledBack))completion
+{
+  [RovqHost rollbackWithCompletion:completion];
+}
+
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rovq/react-native",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Over-the-air updates for React Native, with signed releases and automatic rollback",
   "keywords": [
     "react-native",
@@ -11,15 +11,9 @@
     "hot-update",
     "rollback"
   ],
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
   "author": "moatazMahdi",
   "homepage": "https://rovq-dashboard.onrender.com",
-  "bugs": "https://github.com/moatazMahdi/rovq/issues",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/moatazMahdi/rovq.git",
-    "directory": "packages/react-native"
-  },
   "main": "src/index.ts",
   "files": [
     "src",
@@ -35,7 +29,7 @@
   ],
   "peerDependencies": {
     "react": "*",
-    "react-native": ">=0.82"
+    "react-native": ">=0.72 <0.82"
   },
   "peerDependenciesMeta": {
     "react-native": {
@@ -45,18 +39,10 @@
       "optional": true
     }
   },
-  "codegenConfig": {
-    "name": "RovqSpec",
-    "type": "modules",
-    "jsSrcsDir": "src",
-    "android": {
-      "javaPackageName": "com.rovq.engine.react"
-    },
-    "ios": {
-      "modulesProvider": {
-        "Rovq": "RovqModule"
-      }
-    }
+  "scripts": {
+    "test": "jest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "node -e \"if (process.env.npm_config_tag !== 'rn-0.3') { console.error('Line 0.3 must not become latest. Publish with: npm publish --tag rn-0.3'); process.exit(1) }\""
   },
   "devDependencies": {
     "@swc/core": "1.16.22",
@@ -72,10 +58,7 @@
   "react-native": "src/index.ts",
   "types": "src/index.ts",
   "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "test": "jest",
-    "typecheck": "tsc --noEmit"
+    "access": "public",
+    "tag": "rn-0.3"
   }
-}
+}

package/src/NativeRovq.ts

@@ -1,9 +1,9 @@
-import type { CodegenTypes, TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
+import { NativeEventEmitter, NativeModules } from 'react-native';
+import type { EmitterSubscription } from 'react-native';
 
-// React Native generates the native base classes from this file, and its code generator cannot
-// express a union of object shapes. So these are flat, and index.ts turns them into the types
-// that apps use. Only `react-native` and this file's own types may appear here.
+// React Native 0.72 to 0.81 find this module through NativeModules, which works with or without
+// the New Architecture. The main line, for 0.82 and newer, generates a TurboModule instead.
+// These shapes are the same on both lines, so index.ts does not depend on which one it runs on.
 
 export interface NativeUpdate {
   releaseId: string;
@@ -57,7 +57,10 @@ export interface NativeDownloadProgress {
   totalBytes: number;
 }
 
-export interface Spec extends TurboModule {
+/** The name both native modules send download progress under. */
+export const DOWNLOAD_PROGRESS_EVENT = 'RovqDownloadProgress';
+
+interface LegacyModule {
   checkForUpdate(): Promise<NativeCheckResult>;
   downloadUpdate(): Promise<NativeDownloadResult>;
   installUpdate(): Promise<NativeInstallResult>;
@@ -66,7 +69,48 @@ export interface Spec extends TurboModule {
   restartApp(): void;
   rollback(): Promise<boolean>;
   getStatus(): Promise<NativeStatus>;
-  readonly onDownloadProgress: CodegenTypes.EventEmitter<NativeDownloadProgress>;
+  // NativeEventEmitter calls these to tell the native side when someone is listening.
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export interface Spec {
+  checkForUpdate(): Promise<NativeCheckResult>;
+  downloadUpdate(): Promise<NativeDownloadResult>;
+  installUpdate(): Promise<NativeInstallResult>;
+  sync(): Promise<NativeSyncResult>;
+  notifyApplicationReady(): void;
+  restartApp(): void;
+  rollback(): Promise<boolean>;
+  getStatus(): Promise<NativeStatus>;
+  onDownloadProgress(listener: (progress: NativeDownloadProgress) => void): EmitterSubscription;
+}
+
+function load(): Spec {
+  const module = (NativeModules as { Rovq?: LegacyModule }).Rovq;
+  // The same failure as TurboModuleRegistry.getEnforcing on the main line.
+  if (module === undefined) {
+    throw new Error(
+      "ROVQ: the native module 'Rovq' was not found. Rebuild the app after installing @rovq/react-native.",
+    );
+  }
+  const emitter = new NativeEventEmitter(module);
+  return {
+    checkForUpdate: () => module.checkForUpdate(),
+    downloadUpdate: () => module.downloadUpdate(),
+    installUpdate: () => module.installUpdate(),
+    sync: () => module.sync(),
+    notifyApplicationReady: () => module.notifyApplicationReady(),
+    restartApp: () => module.restartApp(),
+    rollback: () => module.rollback(),
+    getStatus: () => module.getStatus(),
+    // A cast, not a type argument: older versions of NativeEventEmitter take none, and apps
+    // type-check this file, because the package ships TypeScript.
+    onDownloadProgress: (listener) =>
+      emitter.addListener(DOWNLOAD_PROGRESS_EVENT, (progress) =>
+        listener(progress as NativeDownloadProgress),
+      ),
+  };
 }
 
-export default TurboModuleRegistry.getEnforcing<Spec>('Rovq');
+export default load();

package/android/src/react/java/com/rovq/engine/react/RovqPackage.kt

@@ -1,26 +0,0 @@
-package com.rovq.engine.react
-
-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
-
-/** Found by React Native autolinking. */
-class RovqPackage : BaseReactPackage() {
-    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
-        if (name == RovqModule.NAME) RovqModule(reactContext) else null
-
-    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
-        mapOf(
-            RovqModule.NAME to ReactModuleInfo(
-                RovqModule.NAME,
-                RovqModule::class.java.name,
-                false,
-                false,
-                false,
-                true,
-            ),
-        )
-    }
-}

package/android/src/react/java/com/rovq/engine/react/RovqReactHost.kt

@@ -1,74 +0,0 @@
-package com.rovq.engine.react
-
-import android.app.Application
-import android.util.Log
-import com.facebook.react.ReactHost
-import com.facebook.react.ReactPackage
-import com.facebook.react.bridge.JSBundleLoader
-import com.facebook.react.bridge.JSBundleLoaderDelegate
-import com.facebook.react.common.annotations.UnstableReactNativeAPI
-import com.facebook.react.common.build.ReactBuildConfig
-import com.facebook.react.defaults.DefaultComponentsRegistry
-import com.facebook.react.defaults.DefaultReactHostDelegate
-import com.facebook.react.defaults.DefaultTurboModuleManagerDelegate
-import com.facebook.react.fabric.ComponentFactory
-import com.facebook.react.runtime.ReactHostImpl
-import com.facebook.react.runtime.hermes.HermesInstance
-
-private const val TAG = "Rovq"
-private const val EMBEDDED_BUNDLE = "assets://index.android.bundle"
-
-/**
- * Chooses the bundle each time JavaScript starts, not once when the host is created.
- * This is what lets reload apply an update without killing the process.
- */
-private class RovqBundleLoader(private val application: Application) : JSBundleLoader() {
-    override fun loadScript(delegate: JSBundleLoaderDelegate): String {
-        val file = try {
-            Rovq.engine.resolveBundle()
-        } catch (error: Throwable) {
-            // Whatever goes wrong in the engine, the app must still start.
-            Log.e(TAG, "Falling back to the bundle inside the app", error)
-            null
-        }
-        if (file == null) {
-            Log.i(TAG, "Loading the bundle inside the app")
-            delegate.loadScriptFromAssets(application.assets, EMBEDDED_BUNDLE, true)
-            return EMBEDDED_BUNDLE
-        }
-        Log.i(TAG, "Loading ${file.absolutePath}")
-        delegate.loadScriptFromFile(file.absolutePath, file.absolutePath, false)
-        return file.absolutePath
-    }
-}
-
-/**
- * The only file that touches React Native's unstable host API. It does what
- * getDefaultReactHost does, with a different loader, so check it against that function
- * when upgrading React Native. See docs/android-bundle-loading.md.
- */
-@OptIn(UnstableReactNativeAPI::class)
-object RovqReactHost {
-    /** Use in place of getDefaultReactHost in MainApplication. */
-    fun create(application: Application, packages: List<ReactPackage>): ReactHost {
-        val componentFactory = ComponentFactory()
-        DefaultComponentsRegistry.register(componentFactory)
-        val delegate = DefaultReactHostDelegate(
-            jsMainModulePath = "index",
-            jsBundleLoader = RovqBundleLoader(application),
-            reactPackages = packages,
-            jsRuntimeFactory = HermesInstance(),
-            turboModuleManagerDelegateBuilder = DefaultTurboModuleManagerDelegate.Builder(),
-            // Letting a fatal JavaScript error kill the process is what makes rollback work:
-            // the release stays unconfirmed, so the next start abandons it.
-            exceptionHandler = { error -> throw error },
-        )
-        return ReactHostImpl(
-            application.applicationContext,
-            delegate,
-            componentFactory,
-            true,
-            ReactBuildConfig.DEBUG,
-        )
-    }
-}