@rovq/react-native 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,194 @@
+package com.rovq.engine
+
+import java.io.File
+import java.io.IOException
+import java.io.RandomAccessFile
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+private const val END_OF_DIRECTORY_SIGNATURE = 0x06054b50L
+private const val CENTRAL_HEADER_SIGNATURE = 0x02014b50L
+private const val LOCAL_HEADER_SIGNATURE = 0x04034b50L
+private const val END_OF_DIRECTORY_SIZE = 22
+private const val CENTRAL_HEADER_SIZE = 46
+private const val LOCAL_HEADER_SIZE = 30
+private const val MAX_COMMENT_SIZE = 65_535
+private const val MAX_DIRECTORY_SIZE = 64L * 1024 * 1024
+private const val FLAG_ENCRYPTED = 0x1
+private const val FLAG_UTF8_NAME = 0x800
+private const val UNICODE_PATH_EXTRA_FIELD = 0x7075
+private const val FILE_TYPE_MASK = 0xF000
+private const val REGULAR_FILE = 0x8000
+private const val FOLDER = 0x4000
+private const val MAX_16_BITS = 0xFFFF
+private const val MAX_32_BITS = 0xFFFFFFFFL
+
+/**
+ * Checks the structure of a ZIP file, which Java's ZipFile reads but does not question. These are
+ * the same rules as the iOS reader, so both platforms refuse the same files.
+ */
+internal object ZipStructureCheck {
+    private class Header(val name: String, val offset: Long, val compressedSize: Long)
+
+    /** @throws RovqException with INVALID_PACKAGE if anything is wrong. */
+    fun check(file: File) {
+        try {
+            RandomAccessFile(file, "r").use { zip ->
+                val headers = readDirectory(zip)
+                checkNoOverlap(zip, headers)
+            }
+        } catch (error: IOException) {
+            throw invalid("Could not read the ZIP file", error)
+        }
+    }
+
+    private fun readDirectory(zip: RandomAccessFile): List<Header> {
+        val end = findEndOfDirectory(zip)
+        if (end.u16(4) != 0 || end.u16(6) != 0 || end.u16(8) != end.u16(10)) {
+            throw invalid("Split ZIP files are not supported")
+        }
+        val count = end.u16(10)
+        val directorySize = end.u32(12)
+        val directoryOffset = end.u32(16)
+        if (count == MAX_16_BITS || directorySize == MAX_32_BITS || directoryOffset == MAX_32_BITS) {
+            throw invalid("ZIP64 files are not supported")
+        }
+        if (directoryOffset + directorySize > zip.length()) {
+            throw invalid("The directory is outside the file")
+        }
+        if (directorySize > MAX_DIRECTORY_SIZE) throw invalid("The directory is too large")
+
+        val directory = read(zip, directoryOffset, directorySize.toInt())
+        val headers = ArrayList<Header>(minOf(count, PackageRules.MAX_ENTRIES))
+        var position = 0
+        repeat(count) {
+            if (position + CENTRAL_HEADER_SIZE > directory.capacity() ||
+                directory.u32(position) != CENTRAL_HEADER_SIGNATURE
+            ) {
+                throw invalid("The directory is malformed")
+            }
+            val flags = directory.u16(position + 8)
+            val nameLength = directory.u16(position + 28)
+            val extraLength = directory.u16(position + 30)
+            val commentLength = directory.u16(position + 32)
+            val attributes = directory.u32(position + 38)
+            val total = CENTRAL_HEADER_SIZE + nameLength + extraLength + commentLength
+            if (position + total > directory.capacity()) throw invalid("The directory is malformed")
+            if (flags and FLAG_ENCRYPTED != 0) throw invalid("A file is encrypted")
+
+            val nameBytes = directory.bytes(position + CENTRAL_HEADER_SIZE, nameLength)
+            val name = decodeName(nameBytes, flags)
+            checkExtraFields(directory.bytes(position + CENTRAL_HEADER_SIZE + nameLength, extraLength))
+
+            // Symbolic links could point outside the package folder after extraction.
+            val fileType = ((attributes shr 16) and FILE_TYPE_MASK.toLong()).toInt()
+            if (fileType != 0 && fileType != REGULAR_FILE && fileType != FOLDER) {
+                throw invalid("The file $name is not a regular file")
+            }
+            headers += Header(name, directory.u32(position + 42), directory.u32(position + 20))
+            position += total
+        }
+        if (position != directory.capacity()) throw invalid("The directory has extra data")
+        return headers
+    }
+
+    /**
+     * Rejects names that different ZIP readers would decode differently. Otherwise the server
+     * could approve one path while this device writes to another.
+     */
+    private fun decodeName(bytes: ByteBuffer, flags: Int): String {
+        val raw = ByteArray(bytes.remaining()).also { bytes.duplicate().get(it) }
+        if (flags and FLAG_UTF8_NAME == 0 && raw.any { it < 0x20 || it >= 0x7F }) {
+            throw invalid("A file name is not ASCII and is not marked as UTF-8")
+        }
+        val name = String(raw, Charsets.UTF_8)
+        if (!name.toByteArray(Charsets.UTF_8).contentEquals(raw)) {
+            throw invalid("A file name is not valid UTF-8")
+        }
+        return name
+    }
+
+    private fun checkExtraFields(extra: ByteBuffer) {
+        var position = 0
+        while (position + 4 <= extra.capacity()) {
+            if (extra.u16(position) == UNICODE_PATH_EXTRA_FIELD) {
+                throw invalid("A file has an alternative name, which is not allowed")
+            }
+            position += 4 + extra.u16(position + 2)
+        }
+    }
+
+    private fun findEndOfDirectory(zip: RandomAccessFile): ByteBuffer {
+        val size = zip.length()
+        if (size < END_OF_DIRECTORY_SIZE) throw invalid("Not a ZIP file")
+        val tailSize = minOf(size, (END_OF_DIRECTORY_SIZE + MAX_COMMENT_SIZE).toLong()).toInt()
+        val tail = read(zip, size - tailSize, tailSize)
+        var position = tailSize - END_OF_DIRECTORY_SIZE
+        while (position >= 0) {
+            // The comment length must reach exactly to the end, so comment bytes that merely look
+            // like this record are not mistaken for it.
+            if (tail.u32(position) == END_OF_DIRECTORY_SIGNATURE &&
+                position + END_OF_DIRECTORY_SIZE + tail.u16(position + 20) == tailSize
+            ) {
+                return tail.bytes(position, END_OF_DIRECTORY_SIZE)
+            }
+            position -= 1
+        }
+        throw invalid("Not a ZIP file")
+    }
+
+    /** Entries that share bytes let a tiny file expand enormously, so each must have its own. */
+    private fun checkNoOverlap(zip: RandomAccessFile, headers: List<Header>) {
+        val ranges = headers.map { it.offset to dataEnd(zip, it) }.sortedBy { it.first }
+        ranges.zipWithNext { previous, next ->
+            if (next.first < previous.second) throw invalid("Files in the ZIP overlap")
+        }
+    }
+
+    /**
+     * The local header must name the same file as the directory, because other readers trust the
+     * local header instead.
+     */
+    private fun dataEnd(zip: RandomAccessFile, entry: Header): Long {
+        if (entry.offset + LOCAL_HEADER_SIZE > zip.length()) {
+            throw invalid("A file is outside the ZIP file")
+        }
+        val header = read(zip, entry.offset, LOCAL_HEADER_SIZE)
+        if (header.u32(0) != LOCAL_HEADER_SIGNATURE) throw invalid("A file header is malformed")
+        val nameLength = header.u16(26)
+        val extraLength = header.u16(28)
+        if (entry.offset + LOCAL_HEADER_SIZE + nameLength > zip.length()) {
+            throw invalid("A file is outside the ZIP file")
+        }
+        val name = read(zip, entry.offset + LOCAL_HEADER_SIZE, nameLength)
+        val nameBytes = ByteArray(nameLength).also { name.get(it) }
+        if (!nameBytes.contentEquals(entry.name.toByteArray(Charsets.UTF_8))) {
+            throw invalid("The file ${entry.name} has a different name in its local header")
+        }
+        val end = entry.offset + LOCAL_HEADER_SIZE + nameLength + extraLength + entry.compressedSize
+        if (end > zip.length()) throw invalid("The file ${entry.name} is outside the ZIP file")
+        return end
+    }
+
+    private fun read(zip: RandomAccessFile, offset: Long, count: Int): ByteBuffer {
+        val bytes = ByteArray(count)
+        zip.seek(offset)
+        zip.readFully(bytes)
+        return ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN)
+    }
+
+    private fun ByteBuffer.u16(position: Int): Int = getShort(position).toInt() and 0xFFFF
+
+    private fun ByteBuffer.u32(position: Int): Long = getInt(position).toLong() and MAX_32_BITS
+
+    private fun ByteBuffer.bytes(position: Int, count: Int): ByteBuffer {
+        val copy = ByteArray(count)
+        val view = duplicate()
+        view.position(position)
+        view.get(copy)
+        return ByteBuffer.wrap(copy).order(ByteOrder.LITTLE_ENDIAN)
+    }
+
+    private fun invalid(message: String, cause: Throwable? = null) =
+        RovqException(RovqErrorCode.INVALID_PACKAGE, message, cause)
+}

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

@@ -0,0 +1,52 @@
+package com.rovq.engine.react
+
+import android.content.Context
+import android.util.TypedValue
+import com.rovq.engine.BuiltInFiles
+import java.io.InputStream
+
+// The densities react-native bundle writes drawables for, in dots per inch.
+private val DENSITIES = mapOf(
+    "ldpi" to 120,
+    "mdpi" to 160,
+    "hdpi" to 240,
+    "xhdpi" to 320,
+    "xxhdpi" to 480,
+    "xxxhdpi" to 640,
+)
+
+/**
+ * Reads the app's own copy of a package file, so a release made of files can reuse it instead
+ * of downloading it again. In an APK, react-native bundle's files are resources: a path such as
+ * raw/src_assets_audio_1.mp3 is the raw resource src_assets_audio_1, and drawable-xhdpi/x.png is
+ * the drawable x at 320 dpi.
+ *
+ * Whatever this returns is hashed and compared with the signed hash, so a resource that the
+ * build changed, such as a PNG that was compressed again, is simply downloaded instead.
+ */
+internal class ResourceFiles(private val context: Context) : BuiltInFiles {
+    override fun open(path: String): InputStream? {
+        val segments = path.split('/')
+        if (segments.size != 2) return null
+        val (folder, fileName) = segments
+        val type = folder.substringBefore('-')
+        val name = fileName.substringBeforeLast('.')
+        val resources = context.resources
+        // The only way to find a resource by the name a package uses.
+        @Suppress("DiscouragedApi")
+        val id = resources.getIdentifier(name, type, context.packageName)
+        if (id == 0) return null
+        return when (type) {
+            "raw" -> resources.openRawResource(id)
+            "drawable" -> {
+                val density = DENSITIES[folder.substringAfter('-', "")] ?: return null
+                val value = TypedValue()
+                resources.getValueForDensity(id, density, value, true)
+                val file = value.string?.toString() ?: return null
+                // Works for files stored uncompressed in the APK, which images and audio are.
+                resources.assets.openNonAssetFd(value.assetCookie, file).createInputStream()
+            }
+            else -> null
+        }
+    }
+}

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

@@ -0,0 +1,102 @@
+package com.rovq.engine.react
+
+import android.app.Activity
+import android.app.Application
+import android.content.pm.PackageInfo
+import android.os.Build
+import android.os.Bundle
+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(
+    val apiUrl: String,
+    val deploymentKey: String,
+    /** Change this whenever native code changes. */
+    val runtimeVersion: String,
+    /** Key IDs and their Base64 Ed25519 public keys. */
+    val trustedKeys: Map<String, String>,
+    /** Allows http:// for local development only. */
+    val allowInsecureUrls: Boolean = false,
+)
+
+/** Holds the one engine of this process. Call [initialize] first, in Application.onCreate. */
+object Rovq {
+    @Volatile
+    private var instance: RovqEngine? = null
+
+    val engine: RovqEngine
+        get() = instance ?: error("Call Rovq.initialize in Application.onCreate first")
+
+    /** For JavaScript, where a missing engine should be an error it can handle, not a crash. */
+    val engineOrNull: RovqEngine?
+        get() = instance
+
+    @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),
+        )
+        instance = engine
+        application.registerActivityLifecycleCallbacks(BackgroundWatcher(engine))
+        watchForCrashes(engine)
+    }
+
+    private fun watchForCrashes(engine: RovqEngine) {
+        val previous = Thread.getDefaultUncaughtExceptionHandler()
+        Thread.setDefaultUncaughtExceptionHandler { thread, error ->
+            try {
+                engine.noteCrashed()
+            } finally {
+                // The app's own crash handling must always run, whatever happens above.
+                previous?.uncaughtException(thread, error)
+            }
+        }
+    }
+
+    /** Tells the engine when no activity is visible, which is what closing an app looks like. */
+    private class BackgroundWatcher(private val engine: RovqEngine) :
+        Application.ActivityLifecycleCallbacks {
+        private var visible = 0
+
+        override fun onActivityStarted(activity: Activity) {
+            visible += 1
+        }
+
+        override fun onActivityStopped(activity: Activity) {
+            visible -= 1
+            // Rotating the screen also stops the activity, but nobody left the app.
+            if (visible == 0 && !activity.isChangingConfigurations) engine.noteBackgrounded()
+        }
+
+        override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
+        override fun onActivityResumed(activity: Activity) = Unit
+        override fun onActivityPaused(activity: Activity) = Unit
+        override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
+        override fun onActivityDestroyed(activity: Activity) = Unit
+    }
+
+    /** The install time changes with every update of the app itself, even at the same version. */
+    private fun binaryIdOf(info: PackageInfo): String {
+        val versionCode = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            info.longVersionCode
+        } else {
+            @Suppress("DEPRECATION")
+            info.versionCode.toLong()
+        }
+        return "$versionCode:${info.lastUpdateTime}"
+    }
+}

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

@@ -0,0 +1,164 @@
+package com.rovq.engine.react
+
+import android.util.Log
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.rovq.engine.CheckResult
+import com.rovq.engine.DownloadResult
+import com.rovq.engine.InstallResult
+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.util.concurrent.Executors
+
+@ReactModule(name = RovqModule.NAME)
+class RovqModule(context: ReactApplicationContext) : NativeRovqSpec(context) {
+    // Network and disk work must stay off the JavaScript thread.
+    private val worker = Executors.newSingleThreadExecutor()
+
+    // A download keeps running through a reload, when this module's JavaScript has gone.
+    @Volatile
+    private var invalidated = false
+
+    override fun getName(): String = NAME
+
+    override fun checkForUpdate(promise: Promise) = run(promise) { engine ->
+        when (val result = engine.checkForUpdate()) {
+            CheckResult.UpToDate -> outcome("UP_TO_DATE")
+            CheckResult.RolledBack -> outcome("ROLLED_BACK")
+            is CheckResult.UpdateAvailable -> outcome("UPDATE_AVAILABLE").apply {
+                putMap("update", toMap(result.update))
+                putBoolean("alreadyDownloaded", result.alreadyDownloaded)
+            }
+            is CheckResult.Failed -> failure(result.code, result.message)
+        }
+    }
+
+    override 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 ->
+        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 ->
+        when (val result = engine.sync(progressReporter())) {
+            SyncResult.UpToDate -> outcome("UP_TO_DATE")
+            SyncResult.RolledBack -> outcome("ROLLED_BACK")
+            is SyncResult.UpdateReady -> outcome("UPDATE_READY").apply {
+                putString("releaseId", result.releaseId)
+                putBoolean("mandatory", result.mandatory)
+            }
+            is SyncResult.Failed -> failure(result.code, result.message)
+        }
+    }
+
+    override fun notifyApplicationReady() {
+        Rovq.engineOrNull?.notifyReady()
+    }
+
+    override fun restartApp() {
+        UiThreadUtil.runOnUiThread {
+            val application = reactApplicationContext.applicationContext as ReactApplication
+            application.reactHost?.reload("ROVQ restart")
+        }
+    }
+
+    override fun rollback(promise: Promise) {
+        worker.execute {
+            try {
+                promise.resolve(Rovq.engineOrNull?.rollback() ?: false)
+            } catch (error: Exception) {
+                promise.reject("UNKNOWN", error)
+            }
+        }
+    }
+
+    override fun getStatus(promise: Promise) {
+        val status = Rovq.engineOrNull?.status()
+        promise.resolve(
+            Arguments.createMap().apply {
+                if (status != null) {
+                    putString("deviceId", status.deviceId)
+                    putString("currentReleaseId", status.currentReleaseId)
+                    putString("downloadedReleaseId", status.downloadedReleaseId)
+                    putString("pendingReleaseId", status.pendingReleaseId)
+                    putString("tryingReleaseId", status.tryingReleaseId)
+                    putDouble("highestSequence", status.highestSequence.toDouble())
+                }
+            },
+        )
+    }
+
+    private fun run(promise: Promise, work: (RovqEngine) -> WritableMap) {
+        worker.execute {
+            try {
+                val engine = Rovq.engineOrNull
+                promise.resolve(
+                    if (engine != null) {
+                        work(engine)
+                    } else {
+                        failure(RovqErrorCode.ENGINE_UNAVAILABLE, "Rovq.initialize was not called")
+                    },
+                )
+            } catch (error: Exception) {
+                promise.reject("UNKNOWN", error)
+            }
+        }
+    }
+
+    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())
+                    },
+                )
+            }
+        }
+        return throttle::report
+    }
+
+    private fun outcome(name: String): WritableMap = Arguments.createMap().apply { putString("result", name) }
+
+    private fun failure(code: RovqErrorCode, message: String): WritableMap {
+        Log.w(NAME, "Failed with $code: $message")
+        return outcome("FAILED").apply {
+            putString("code", code.name)
+            putString("message", message)
+        }
+    }
+
+    private fun toMap(update: UpdateInfo): WritableMap = Arguments.createMap().apply {
+        putString("releaseId", update.releaseId)
+        putDouble("sequence", update.sequence.toDouble())
+        putBoolean("mandatory", update.mandatory)
+        putDouble("packageSize", update.packageSize.toDouble())
+    }
+
+    override fun invalidate() {
+        invalidated = true
+        worker.shutdown()
+        super.invalidate()
+    }
+
+    companion object {
+        const val NAME = "Rovq"
+    }
+}

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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,74 @@
+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,
+        )
+    }
+}