@hot-updater/react-native 0.29.4 → 0.29.6

package/android/build.gradle

@@ -89,6 +89,10 @@ android {
     }
   }
 
+  testOptions {
+    unitTests.returnDefaultValues = true
+  }
+
   lintOptions {
     disable "GradleCompatible"
   }
@@ -132,11 +136,9 @@ dependencies {
   // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
   //noinspection GradleDynamicVersion
   if (project.ext.shouldConsumeReactNativeFromMavenCentral()) {
-    // noinspection GradleDynamicVersion
-    implementation 'com.facebook.react:react-android:+'
+    implementation "com.facebook.react:react-android:${project.ext.reactNativeVersion}"
   } else {
-    // noinspection GradleDynamicVersion
-    implementation 'com.facebook.react:react-native:+'
+    implementation "com.facebook.react:react-native:${project.ext.reactNativeVersion}"
   }
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.6.1"
@@ -144,6 +146,8 @@ dependencies {
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
   implementation "com.squareup.okhttp3:okhttp:4.12.0"
   implementation files('libs/org.brotli.dec-1.2.0.jar')
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "org.json:json:20240303"
 }
 
 if (isNewArchitectureEnabled()) {

package/android/gradle.properties

@@ -1,5 +1,6 @@
-HotUpdater_kotlinVersion=1.7.0
+HotUpdater_kotlinVersion=2.0.21
 HotUpdater_minSdkVersion=21
 HotUpdater_targetSdkVersion=35
 HotUpdater_compileSdkVersion=35
 HotUpdater_ndkversion=21.4.7075529
+android.useAndroidX=true

package/android/react-native-helpers.gradle

@@ -33,10 +33,13 @@ file("$reactNativeRootDir/ReactAndroid/gradle.properties").withInputStream { rea
 def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME")
 def REACT_NATIVE_MINOR_VERSION = REACT_NATIVE_VERSION.startsWith("0.0.0-") ? 1000 : REACT_NATIVE_VERSION.split("\\.")[1].toInteger()
 
+project.ext.reactNativeVersion = REACT_NATIVE_VERSION
+project.ext.reactNativeMinorVersion = REACT_NATIVE_MINOR_VERSION
+
 project.ext.resolveReactNativeDirectory = { ->
   return resolveReactNativeDirectory()
 }
 
 project.ext.shouldConsumeReactNativeFromMavenCentral = { ->
   return REACT_NATIVE_MINOR_VERSION >= 71
-}
+}

package/android/src/main/java/com/hotupdater/BundleFileStorageService.kt

@@ -191,9 +191,42 @@ class BundleFileStorageService(
         return regex.find(currentUrl)?.groupValues?.get(1)
     }
 
+    private fun resolveBundleFile(bundleDir: File): File? {
+        val manifest = readManifestFromBundleDir(bundleDir)
+        val manifestBundlePath =
+            (manifest?.get("assets") as? Map<*, *>)
+                ?.keys
+                ?.mapNotNull { key ->
+                    (key as? String)
+                        ?.trim()
+                        ?.takeIf { it.isNotEmpty() }
+                        ?.takeIf { File(it).name.endsWith(".android.bundle") }
+                }?.singleOrNull()
+
+        if (manifestBundlePath != null) {
+            try {
+                val canonicalBundleDir = bundleDir.canonicalFile
+                val canonicalBundleFile = File(bundleDir, manifestBundlePath).canonicalFile
+                val canonicalBundleDirPath = canonicalBundleDir.path
+                val canonicalBundleFilePath = canonicalBundleFile.path
+                val isWithinBundleDir =
+                    canonicalBundleFilePath == canonicalBundleDirPath ||
+                        canonicalBundleFilePath.startsWith("$canonicalBundleDirPath${File.separator}")
+
+                if (isWithinBundleDir && canonicalBundleFile.isFile) {
+                    return canonicalBundleFile
+                }
+            } catch (e: Exception) {
+                Log.w(TAG, "Failed to resolve manifest bundle file from ${bundleDir.absolutePath}: ${e.message}")
+            }
+        }
+
+        return File(bundleDir, "index.android.bundle").absoluteFile.takeIf { it.isFile }
+    }
+
     private fun findBundleFile(bundleId: String): File? {
         val bundleDir = File(getBundleStoreDir(), bundleId)
-        return bundleDir.walk().find { it.name == "index.android.bundle" && it.exists() }
+        return resolveBundleFile(bundleDir)
     }
 
     private fun getBundleUrlForId(bundleId: String): String? = findBundleFile(bundleId)?.absolutePath
@@ -637,8 +670,8 @@ class BundleFileStorageService(
         val finalBundleDir = File(bundleStoreDir, bundleId)
         if (finalBundleDir.exists()) {
             Log.d(TAG, "Bundle for bundleId $bundleId already exists. Using cached bundle.")
-            val existingIndexFile = finalBundleDir.walk().find { it.name == "index.android.bundle" }
-            if (existingIndexFile != null) {
+            val existingBundleFile = resolveBundleFile(finalBundleDir)
+            if (existingBundleFile != null) {
                 // Update last modified time
                 finalBundleDir.setLastModified(System.currentTimeMillis())
 
@@ -648,7 +681,7 @@ class BundleFileStorageService(
                 saveMetadata(updatedMetadata)
 
                 // Set bundle URL for backwards compatibility
-                setBundleURL(existingIndexFile.absolutePath)
+                setBundleURL(existingBundleFile.absolutePath)
 
                 // Keep the current verified bundle as a fallback if one exists.
                 cleanupOldBundles(bundleStoreDir, updatedMetadata.stableBundleId, bundleId)
@@ -776,17 +809,17 @@ class BundleFileStorageService(
                         throw HotUpdaterException.extractionFormatError()
                     }
 
-                    // 4) Find index.android.bundle inside tmpDir
-                    val extractedIndex = tmpDir.walk().find { it.name == "index.android.bundle" }
-                    if (extractedIndex == null) {
-                        Log.d("BundleStorage", "index.android.bundle not found in tmpDir.")
+                    // 4) Resolve the extracted Android bundle file.
+                    val extractedBundleFile = resolveBundleFile(tmpDir)
+                    if (extractedBundleFile == null) {
+                        Log.d("BundleStorage", "Android bundle file could not be resolved in tmpDir.")
                         tempDir.deleteRecursively()
                         tmpDir.deleteRecursively()
                         throw HotUpdaterException.invalidBundle()
                     }
 
                     // 5) Log extracted bundle file size
-                    val bundleSize = extractedIndex.length()
+                    val bundleSize = extractedBundleFile.length()
                     Log.d("BundleStorage", "Extracted bundle size: $bundleSize bytes")
 
                     // 6) If the realDir (bundle-store/<bundleId>) exists, delete it
@@ -815,10 +848,10 @@ class BundleFileStorageService(
                         }
                     }
 
-                    // 8) Verify index.android.bundle exists inside finalBundleDir
-                    val finalIndexFile = finalBundleDir.walk().find { it.name == "index.android.bundle" }
-                    if (finalIndexFile == null) {
-                        Log.d("BundleStorage", "index.android.bundle not found in realDir.")
+                    // 8) Verify the Android bundle file exists inside finalBundleDir.
+                    val finalBundleFile = resolveBundleFile(finalBundleDir)
+                    if (finalBundleFile == null) {
+                        Log.d("BundleStorage", "Android bundle file could not be resolved in realDir.")
                         tempDir.deleteRecursively()
                         finalBundleDir.deleteRecursively()
                         throw HotUpdaterException.invalidBundle()
@@ -828,7 +861,7 @@ class BundleFileStorageService(
                     finalBundleDir.setLastModified(System.currentTimeMillis())
 
                     // 10) Save the new bundle as STAGING with verification pending
-                    val bundlePath = finalIndexFile.absolutePath
+                    val bundlePath = finalBundleFile.absolutePath
                     Log.d(TAG, "Setting bundle as staging: $bundlePath")
 
                     // Update metadata: set new bundle as staging

package/android/src/test/java/com/hotupdater/BundleFileStorageServiceTest.kt

@@ -0,0 +1,329 @@
+package com.hotupdater
+
+import android.content.ContextWrapper
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+import java.net.URL
+
+class BundleFileStorageServiceTest {
+    @get:Rule
+    val temporaryFolder = TemporaryFolder()
+
+    @Test
+    fun `resolveBundleFile uses single manifest bundle at root`() {
+        val rootDir = temporaryFolder.newFolder("root-manifest-bundle")
+        val service = createService(rootDir)
+        val bundleDir = createBundleDir(rootDir, "bundle-root")
+        val expectedBundleFile = writeFile(bundleDir, "foo.android.bundle")
+
+        writeManifest(bundleDir, listOf("foo.android.bundle"))
+
+        assertResolvedBundlePath(service, bundleDir, expectedBundleFile)
+    }
+
+    @Test
+    fun `resolveBundleFile uses single nested manifest bundle`() {
+        val rootDir = temporaryFolder.newFolder("nested-manifest-bundle")
+        val service = createService(rootDir)
+        val bundleDir = createBundleDir(rootDir, "bundle-nested")
+        val expectedBundleFile = writeFile(bundleDir, "dist/foo.android.bundle")
+
+        writeManifest(bundleDir, listOf("dist/foo.android.bundle"))
+
+        assertResolvedBundlePath(service, bundleDir, expectedBundleFile)
+    }
+
+    @Test
+    fun `resolveBundleFile falls back to root index when manifest has no android bundle candidate`() {
+        val rootDir = temporaryFolder.newFolder("no-android-candidate")
+        val service = createService(rootDir)
+        val bundleDir = createBundleDir(rootDir, "bundle-no-candidate")
+        val fallbackBundleFile = writeFile(bundleDir, "index.android.bundle")
+
+        writeManifest(bundleDir, listOf("index.ios.bundle", "assets/image.png"))
+
+        assertResolvedBundlePath(service, bundleDir, fallbackBundleFile)
+    }
+
+    @Test
+    fun `resolveBundleFile falls back to root index when manifest has multiple android bundle candidates`() {
+        val rootDir = temporaryFolder.newFolder("multiple-android-candidates")
+        val service = createService(rootDir)
+        val bundleDir = createBundleDir(rootDir, "bundle-multiple-candidates")
+        val fallbackBundleFile = writeFile(bundleDir, "index.android.bundle")
+
+        writeFile(bundleDir, "foo.android.bundle")
+        writeFile(bundleDir, "dist/bar.android.bundle")
+        writeManifest(bundleDir, listOf("foo.android.bundle", "dist/bar.android.bundle"))
+
+        assertResolvedBundlePath(service, bundleDir, fallbackBundleFile)
+    }
+
+    @Test
+    fun `resolveBundleFile returns null when manifest escapes root and no fallback exists`() {
+        val rootDir = temporaryFolder.newFolder("escaped-manifest-path")
+        val service = createService(rootDir)
+        val bundleDir = createBundleDir(rootDir, "bundle-escaped-path")
+
+        writeFile(bundleStoreDir(rootDir), "outside.android.bundle")
+        writeManifest(bundleDir, listOf("../outside.android.bundle"))
+
+        assertNull(invokeResolveBundleFile(service, bundleDir))
+    }
+
+    @Test
+    fun `resolveBundleFile returns null when manifest target is missing and no fallback exists`() {
+        val rootDir = temporaryFolder.newFolder("missing-manifest-target")
+        val service = createService(rootDir)
+        val bundleDir = createBundleDir(rootDir, "bundle-missing-target")
+
+        writeManifest(bundleDir, listOf("dist/missing.android.bundle"))
+
+        assertNull(invokeResolveBundleFile(service, bundleDir))
+    }
+
+    @Test
+    fun `resolveBundleFile allows legacy root index without manifest`() {
+        val rootDir = temporaryFolder.newFolder("legacy-root-index")
+        val service = createService(rootDir)
+        val bundleDir = createBundleDir(rootDir, "bundle-legacy")
+        val fallbackBundleFile = writeFile(bundleDir, "index.android.bundle")
+
+        assertResolvedBundlePath(service, bundleDir, fallbackBundleFile)
+    }
+
+    @Test
+    fun `resolveBundleFile returns null when manifest and root index are both missing`() {
+        val rootDir = temporaryFolder.newFolder("missing-everything")
+        val service = createService(rootDir)
+        val bundleDir = createBundleDir(rootDir, "bundle-invalid")
+
+        assertNull(invokeResolveBundleFile(service, bundleDir))
+    }
+
+    @Test
+    fun `prepareLaunch rolls back invalid staging and selects stable bundle`() {
+        val rootDir = temporaryFolder.newFolder("rollback-to-stable")
+        val preferences = InMemoryPreferencesService()
+        val service = createService(rootDir, preferences)
+
+        val stagingDir = createBundleDir(rootDir, "staging-bundle")
+        writeManifest(stagingDir, listOf("dist/missing.android.bundle"))
+
+        val stableDir = createBundleDir(rootDir, "stable-bundle")
+        val stableBundleFile = writeFile(stableDir, "dist/stable.android.bundle")
+        writeManifest(stableDir, listOf("dist/stable.android.bundle"))
+
+        writeMetadata(
+            rootDir,
+            BundleMetadata(
+                isolationKey = TEST_ISOLATION_KEY,
+                stableBundleId = stableDir.name,
+                stagingBundleId = stagingDir.name,
+                verificationPending = true,
+            ),
+        )
+
+        val selection = service.prepareLaunch(null)
+        val report = service.notifyAppReady()
+
+        assertEquals(stableBundleFile.canonicalFile.absolutePath, selection.bundleUrl)
+        assertEquals(stableDir.name, selection.launchedBundleId)
+        assertFalse(selection.shouldRollbackOnCrash)
+        assertFalse(stagingDir.exists())
+        assertEquals("RECOVERED", report["status"])
+        assertEquals(stagingDir.name, report["crashedBundleId"])
+
+        val metadata = loadMetadata(rootDir)
+        assertNotNull(metadata)
+        assertEquals(stableDir.name, metadata?.stagingBundleId)
+        assertNull(metadata?.stableBundleId)
+        assertFalse(metadata?.verificationPending ?: true)
+        assertEquals(stableBundleFile.canonicalFile.absolutePath, preferences.getItem("HotUpdaterBundleURL"))
+    }
+
+    @Test
+    fun `prepareLaunch falls back to built in bundle when staging and stable are both invalid`() {
+        val rootDir = temporaryFolder.newFolder("fallback-to-built-in")
+        val service = createService(rootDir)
+
+        val stagingDir = createBundleDir(rootDir, "staging-bundle")
+        writeManifest(stagingDir, listOf("dist/missing.android.bundle"))
+
+        val stableDir = createBundleDir(rootDir, "stable-bundle")
+        writeManifest(stableDir, listOf("../outside.android.bundle"))
+
+        writeMetadata(
+            rootDir,
+            BundleMetadata(
+                isolationKey = TEST_ISOLATION_KEY,
+                stableBundleId = stableDir.name,
+                stagingBundleId = stagingDir.name,
+                verificationPending = true,
+            ),
+        )
+
+        val selection = service.prepareLaunch(null)
+        val report = service.notifyAppReady()
+
+        assertEquals("assets://index.android.bundle", selection.bundleUrl)
+        assertNull(selection.launchedBundleId)
+        assertFalse(selection.shouldRollbackOnCrash)
+        assertFalse(stagingDir.exists())
+        assertEquals("RECOVERED", report["status"])
+        assertEquals(stagingDir.name, report["crashedBundleId"])
+    }
+
+    private fun createService(
+        rootDir: File,
+        preferences: InMemoryPreferencesService = InMemoryPreferencesService(),
+    ): BundleFileStorageService =
+        BundleFileStorageService(
+            ContextWrapper(null),
+            TestFileSystemService(rootDir),
+            UnusedDownloadService,
+            DecompressService(),
+            preferences,
+            TEST_ISOLATION_KEY,
+        )
+
+    private fun createBundleDir(
+        rootDir: File,
+        bundleId: String,
+    ): File = File(bundleStoreDir(rootDir), bundleId).apply { mkdirs() }
+
+    private fun writeManifest(
+        bundleDir: File,
+        assetPaths: List<String>,
+    ) {
+        val assets =
+            JSONObject().apply {
+                assetPaths.forEach { assetPath ->
+                    put(assetPath, JSONObject().put("fileHash", "$assetPath-hash"))
+                }
+            }
+
+        File(bundleDir, "manifest.json").writeText(
+            JSONObject()
+                .put("bundleId", bundleDir.name)
+                .put("assets", assets)
+                .toString(),
+        )
+    }
+
+    private fun writeMetadata(
+        rootDir: File,
+        metadata: BundleMetadata,
+    ) {
+        assertTrue(metadata.saveToFile(File(bundleStoreDir(rootDir), BundleMetadata.METADATA_FILENAME)))
+    }
+
+    private fun loadMetadata(rootDir: File): BundleMetadata? =
+        BundleMetadata.loadFromFile(
+            File(bundleStoreDir(rootDir), BundleMetadata.METADATA_FILENAME),
+            TEST_ISOLATION_KEY,
+        )
+
+    private fun writeFile(
+        rootDir: File,
+        relativePath: String,
+        content: String = "bundle-content",
+    ): File =
+        File(rootDir, relativePath).apply {
+            parentFile?.mkdirs()
+            writeText(content)
+        }
+
+    private fun bundleStoreDir(rootDir: File): File = File(rootDir, "bundle-store").apply { mkdirs() }
+
+    private fun invokeResolveBundleFile(
+        service: BundleFileStorageService,
+        bundleDir: File,
+    ): File? {
+        val method =
+            BundleFileStorageService::class.java.getDeclaredMethod(
+                "resolveBundleFile",
+                File::class.java,
+            )
+        method.isAccessible = true
+        return method.invoke(service, bundleDir) as File?
+    }
+
+    private fun assertResolvedBundlePath(
+        service: BundleFileStorageService,
+        bundleDir: File,
+        expected: File,
+    ) {
+        val resolved = invokeResolveBundleFile(service, bundleDir)
+
+        assertNotNull(resolved)
+        assertEquals(expected.canonicalFile.absolutePath, resolved?.canonicalFile?.absolutePath)
+    }
+
+    private class TestFileSystemService(
+        private val externalFilesDir: File,
+    ) : FileSystemService {
+        override fun fileExists(path: String): Boolean = File(path).exists()
+
+        override fun createDirectory(path: String): Boolean = File(path).mkdirs()
+
+        override fun removeItem(path: String): Boolean = File(path).deleteRecursively()
+
+        override fun moveItem(
+            sourcePath: String,
+            destinationPath: String,
+        ): Boolean = File(sourcePath).renameTo(File(destinationPath))
+
+        override fun copyItem(
+            sourcePath: String,
+            destinationPath: String,
+        ): Boolean =
+            try {
+                File(sourcePath).copyRecursively(File(destinationPath), overwrite = true)
+            } catch (_: Exception) {
+                false
+            }
+
+        override fun contentsOfDirectory(path: String): List<String> = File(path).list()?.toList() ?: emptyList()
+
+        override fun getExternalFilesDir(): File = externalFilesDir
+    }
+
+    private class InMemoryPreferencesService : PreferencesService {
+        private val values = mutableMapOf<String, String?>()
+
+        override fun getItem(key: String): String? = values[key]
+
+        override fun setItem(
+            key: String,
+            value: String?,
+        ) {
+            if (value == null) {
+                values.remove(key)
+            } else {
+                values[key] = value
+            }
+        }
+    }
+
+    private object UnusedDownloadService : DownloadService {
+        override suspend fun downloadFile(
+            fileUrl: URL,
+            destination: File,
+            fileSizeCallback: ((Long) -> Unit)?,
+            progressCallback: (Double) -> Unit,
+        ): DownloadResult = error("downloadFile should not be called in these tests")
+    }
+
+    companion object {
+        private const val TEST_ISOLATION_KEY = "test-isolation-key"
+    }
+}

package/ios/HotUpdater/Internal/HotUpdater-Bridging-Header.h

@@ -7,7 +7,6 @@
 #import "React/RCTConstants.h"
 #import "React/RCTRootView.h"
 #import "React/RCTUtils.h" // Needed for RCTPromiseResolveBlock/RejectBlock in Swift
-#import <SSZipArchive/SSZipArchive.h>
 
 @interface HotUpdaterRecoverySignalBridge : NSObject
 + (void)installSignalHandlers:(NSString *)crashMarkerPath;

package/ios/HotUpdater/Internal/ZipArchiveExtractor.swift

@@ -249,6 +249,7 @@ enum ZipArchiveExtractor {
             extractionResult = try extractDeflatedEntry(
                 from: handle,
                 compressedSize: entry.compressedSize,
+                path: entry.path,
                 to: outputHandle
             )
         default:
@@ -300,6 +301,7 @@ enum ZipArchiveExtractor {
     private static func extractDeflatedEntry(
         from handle: FileHandle,
         compressedSize: UInt64,
+        path: String,
         to outputHandle: FileHandle
     ) throws -> (writtenSize: UInt64, checksum: UInt32) {
         let outputBuffer = UnsafeMutablePointer<UInt8>.allocate(capacity: ArchiveExtractionUtilities.bufferSize)
@@ -345,22 +347,23 @@ enum ZipArchiveExtractor {
 
                 stream.next_in = UnsafeMutablePointer(mutating: baseAddress)
                 stream.avail_in = uInt(chunk.count)
+                var needsMoreInput = false
 
                 repeat {
                     stream.next_out = outputBuffer
                     stream.avail_out = uInt(ArchiveExtractionUtilities.bufferSize)
 
                     let status = inflate(&stream, Z_NO_FLUSH)
+                    let producedBytes = ArchiveExtractionUtilities.bufferSize - Int(stream.avail_out)
+                    if producedBytes > 0 {
+                        let outputData = Data(bytes: outputBuffer, count: producedBytes)
+                        outputHandle.write(outputData)
+                        totalWritten += UInt64(producedBytes)
+                        checksum = updateCRC32(checksum, with: outputData)
+                    }
+
                     switch status {
                     case Z_OK, Z_STREAM_END:
-                        let producedBytes = ArchiveExtractionUtilities.bufferSize - Int(stream.avail_out)
-                        if producedBytes > 0 {
-                            let outputData = Data(bytes: outputBuffer, count: producedBytes)
-                            outputHandle.write(outputData)
-                            totalWritten += UInt64(producedBytes)
-                            checksum = updateCRC32(checksum, with: outputData)
-                        }
-
                         if status == Z_STREAM_END {
                             guard stream.avail_in == 0, remainingBytes == 0 else {
                                 throw NSError(
@@ -372,16 +375,33 @@ enum ZipArchiveExtractor {
 
                             reachedStreamEnd = true
                         }
+                    case Z_BUF_ERROR:
+                        guard stream.avail_in == 0, remainingBytes > 0 else {
+                            let message = stream.msg.map { String(cString: $0) } ?? "Unknown zlib error"
+                            throw NSError(
+                                domain: "ZipArchiveExtractor",
+                                code: 13,
+                                userInfo: [
+                                    NSLocalizedDescriptionKey:
+                                        "ZIP deflate failed for \(path): status=\(status) totalIn=\(stream.total_in) totalOut=\(stream.total_out) \(message)"
+                                ]
+                            )
+                        }
+
+                        needsMoreInput = true
 
                     default:
                         let message = stream.msg.map { String(cString: $0) } ?? "Unknown zlib error"
                         throw NSError(
                             domain: "ZipArchiveExtractor",
                             code: 13,
-                            userInfo: [NSLocalizedDescriptionKey: "ZIP deflate failed: \(message)"]
+                            userInfo: [
+                                NSLocalizedDescriptionKey:
+                                    "ZIP deflate failed for \(path): status=\(status) totalIn=\(stream.total_in) totalOut=\(stream.total_out) \(message)"
+                            ]
                         )
                     }
-                } while stream.avail_in > 0 || stream.avail_out == 0
+                } while (stream.avail_in > 0 || stream.avail_out == 0) && !needsMoreInput && !reachedStreamEnd
             }
 
             if reachedStreamEnd {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/react-native",
-  "version": "0.29.4",
+  "version": "0.29.6",
   "description": "React Native OTA solution for self-hosted",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -120,14 +120,14 @@
     "react-native": "0.79.1",
     "react-native-builder-bob": "^0.40.10",
     "typescript": "^6.0.2",
-    "hot-updater": "0.29.4"
+    "hot-updater": "0.29.6"
   },
   "dependencies": {
     "use-sync-external-store": "1.5.0",
-    "@hot-updater/js": "0.29.4",
-    "@hot-updater/cli-tools": "0.29.4",
-    "@hot-updater/plugin-core": "0.29.4",
-    "@hot-updater/core": "0.29.4"
+    "@hot-updater/cli-tools": "0.29.6",
+    "@hot-updater/plugin-core": "0.29.6",
+    "@hot-updater/js": "0.29.6",
+    "@hot-updater/core": "0.29.6"
   },
   "scripts": {
     "build": "bob build && tsc -p plugin/tsconfig.build.json",