@onekeyfe/react-native-split-bundle-loader 0.1.1 → 1.1.51

package/android/src/main/java/com/splitbundleloader/SplitBundleLoaderModule.kt

@@ -9,6 +9,7 @@ import com.facebook.react.module.annotations.ReactModule
 import java.io.File
 import java.io.FileOutputStream
 import java.io.IOException
+import java.util.concurrent.Semaphore
 
 /**
  * TurboModule entry point for SplitBundleLoader.
@@ -26,6 +27,9 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
     companion object {
         const val NAME = "SplitBundleLoader"
         private const val BUILTIN_EXTRACT_DIR = "onekey-builtin-segments"
+        // #18: Limit concurrent asset extractions to avoid I/O contention
+        private const val MAX_CONCURRENT_EXTRACTS = 2
+        private val extractSemaphore = Semaphore(MAX_CONCURRENT_EXTRACTS)
     }
 
     override fun getName(): String = NAME
@@ -73,11 +77,34 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
             result.putString("bundleVersion", bundleVersion)
 
             promise.resolve(result)
+
+            // #17: Clean up old version extract directories asynchronously
+            cleanupOldExtractDirs(context, nativeVersion)
         } catch (e: Exception) {
             promise.reject("SPLIT_BUNDLE_CONTEXT_ERROR", e.message, e)
         }
     }
 
+    // -----------------------------------------------------------------------
+    // resolveSegmentPath (Phase 3)
+    // -----------------------------------------------------------------------
+
+    override fun resolveSegmentPath(relativePath: String, sha256: String, promise: Promise) {
+        try {
+            val absolutePath = resolveSegmentPath(relativePath, sha256)
+            if (absolutePath != null) {
+                promise.resolve(absolutePath)
+            } else {
+                promise.reject(
+                    "SPLIT_BUNDLE_NOT_FOUND",
+                    "Segment file not found: $relativePath"
+                )
+            }
+        } catch (e: Exception) {
+            promise.reject("SPLIT_BUNDLE_RESOLVE_ERROR", e.message, e)
+        }
+    }
+
     // -----------------------------------------------------------------------
     // loadSegment
     // -----------------------------------------------------------------------
@@ -89,10 +116,14 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
         sha256: String,
         promise: Promise
     ) {
+        // NOTE (#44): sha256 param is not verified at load time by design.
+        // Per §6.4.1, runtime trusts that OTA install has already verified
+        // segment integrity. Builtin segments are signed as part of the APK/IPA.
+        // If runtime SHA-256 verification is needed, add it here.
         try {
             val segId = segmentId.toInt()
 
-            val absolutePath = resolveSegmentPath(relativePath)
+            val absolutePath = resolveSegmentPath(relativePath, sha256)
             if (absolutePath == null) {
                 promise.reject(
                     "SPLIT_BUNDLE_NOT_FOUND",
@@ -101,49 +132,95 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
                 return
             }
 
-            // Register segment via CatalystInstance
+            // #19: Try CatalystInstance first (bridge mode), fall back to
+            // ReactHost registerSegment if available (bridgeless / new arch).
             val reactContext = reactApplicationContext
             if (reactContext.hasCatalystInstance()) {
                 reactContext.catalystInstance.registerSegment(segId, absolutePath)
                 SBLLogger.info("Loaded segment $segmentKey (id=$segId)")
                 promise.resolve(null)
             } else {
-                promise.reject(
-                    "SPLIT_BUNDLE_NO_INSTANCE",
-                    "CatalystInstance not available"
-                )
+                // Bridgeless: try ReactHost via reflection
+                val registered = tryRegisterViaBridgeless(segId, absolutePath)
+                if (registered) {
+                    SBLLogger.info("Loaded segment $segmentKey (id=$segId) via bridgeless")
+                    promise.resolve(null)
+                } else {
+                    promise.reject(
+                        "SPLIT_BUNDLE_NO_INSTANCE",
+                        "Neither CatalystInstance nor ReactHost available"
+                    )
+                }
             }
         } catch (e: Exception) {
             promise.reject("SPLIT_BUNDLE_LOAD_ERROR", e.message, e)
         }
     }
 
+    // -----------------------------------------------------------------------
+    // Bridgeless support (#19)
+    // -----------------------------------------------------------------------
+
+    private fun tryRegisterViaBridgeless(segmentId: Int, path: String): Boolean {
+        return try {
+            val appContext = reactApplicationContext.applicationContext
+            val appClass = appContext.javaClass
+            val hostMethod = appClass.getMethod("getReactHost")
+            val host = hostMethod.invoke(appContext) ?: return false
+            val registerMethod = host.javaClass.getMethod(
+                "registerSegment", Int::class.java, String::class.java
+            )
+            registerMethod.invoke(host, segmentId, path)
+            true
+        } catch (_: Exception) {
+            false
+        }
+    }
+
     // -----------------------------------------------------------------------
     // Path resolution helpers
     // -----------------------------------------------------------------------
 
-    private fun resolveSegmentPath(relativePath: String): String? {
+    /**
+     * Verify resolved path stays within the expected root directory (#45).
+     * Prevents path traversal via ".." components in relativePath.
+     */
+    private fun isPathWithinRoot(root: File, resolved: File): Boolean {
+        return resolved.canonicalPath.startsWith(root.canonicalPath + File.separator) ||
+            resolved.canonicalPath == root.canonicalPath
+    }
+
+    private fun resolveSegmentPath(relativePath: String, expectedSha256: String): String? {
+        // Path traversal guard (#45)
+        if (relativePath.contains("..")) {
+            SBLLogger.warn("Path traversal rejected: $relativePath")
+            return null
+        }
+
         // 1. Try OTA bundle directory first
         val otaBundlePath = getOtaBundlePath()
         if (!otaBundlePath.isNullOrEmpty()) {
             val otaRoot = File(otaBundlePath).parentFile
             if (otaRoot != null) {
                 val candidate = File(otaRoot, relativePath)
-                if (candidate.exists()) {
+                if (candidate.exists() && isPathWithinRoot(otaRoot, candidate)) {
                     return candidate.absolutePath
                 }
             }
         }
 
         // 2. Try builtin: extract from assets if needed
-        return extractBuiltinSegmentIfNeeded(relativePath)
+        return extractBuiltinSegmentIfNeeded(relativePath, expectedSha256)
     }
 
     /**
      * For Android builtin segments, APK assets can't be passed directly as file paths.
      * Extract the asset to the extract cache directory on first access.
+     *
+     * #16: Validates extracted file size against the asset to detect truncated extractions.
+     * #18: Uses semaphore to limit concurrent extractions.
      */
-    private fun extractBuiltinSegmentIfNeeded(relativePath: String): String? {
+    private fun extractBuiltinSegmentIfNeeded(relativePath: String, expectedSha256: String): String? {
         val context = reactApplicationContext
         val nativeVersion = try {
             context.packageManager
@@ -155,32 +232,101 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
         val extractDir = File(context.filesDir, "$BUILTIN_EXTRACT_DIR/$nativeVersion")
         val extractedFile = File(extractDir, relativePath)
 
-        // Already extracted
+        // #16: If file exists, verify it's not truncated by checking size against asset
         if (extractedFile.exists()) {
-            return extractedFile.absolutePath
+            val assetSize = getAssetSize(context.assets, relativePath)
+            if (assetSize >= 0 && extractedFile.length() == assetSize) {
+                return extractedFile.absolutePath
+            }
+            // Truncated or size mismatch — delete and re-extract
+            SBLLogger.warn("Extracted file size mismatch for $relativePath, re-extracting")
+            extractedFile.delete()
         }
 
-        // Extract from assets
-        val assets: AssetManager = context.assets
-        return try {
-            assets.open(relativePath).use { input ->
-                extractedFile.parentFile?.let { parent ->
-                    if (!parent.exists()) parent.mkdirs()
+        // #18: Limit concurrent extractions
+        extractSemaphore.acquire()
+        try {
+            // Double-check after acquiring semaphore (another thread may have extracted)
+            if (extractedFile.exists()) {
+                return extractedFile.absolutePath
+            }
+
+            val assets: AssetManager = context.assets
+            return try {
+                // Extract to temp file first, then atomically rename
+                val tempFile = File(extractedFile.parentFile, "${extractedFile.name}.tmp")
+                assets.open(relativePath).use { input ->
+                    extractedFile.parentFile?.let { parent ->
+                        if (!parent.exists()) parent.mkdirs()
+                    }
+                    FileOutputStream(tempFile).use { output ->
+                        val buffer = ByteArray(8192)
+                        var len: Int
+                        while (input.read(buffer).also { len = it } != -1) {
+                            output.write(buffer, 0, len)
+                        }
+                    }
+                }
+                // Atomic rename prevents partial file observation
+                if (tempFile.renameTo(extractedFile)) {
+                    extractedFile.absolutePath
+                } else {
+                    tempFile.delete()
+                    null
                 }
-                FileOutputStream(extractedFile).use { output ->
+            } catch (_: IOException) {
+                null
+            }
+        } finally {
+            extractSemaphore.release()
+        }
+    }
+
+    /**
+     * Returns the size of an asset file, or -1 if it can't be determined.
+     */
+    private fun getAssetSize(assets: AssetManager, assetPath: String): Long {
+        return try {
+            assets.openFd(assetPath).use { it.length }
+        } catch (_: IOException) {
+            // Asset may be compressed; fall back to reading the stream
+            try {
+                assets.open(assetPath).use { input ->
+                    var size = 0L
                     val buffer = ByteArray(8192)
                     var len: Int
                     while (input.read(buffer).also { len = it } != -1) {
-                        output.write(buffer, 0, len)
+                        size += len
                     }
+                    size
                 }
+            } catch (_: IOException) {
+                -1
             }
-            extractedFile.absolutePath
-        } catch (_: IOException) {
-            null
         }
     }
 
+    /**
+     * #17: Asynchronously clean up extract directories from previous native versions.
+     */
+    private fun cleanupOldExtractDirs(context: Context, currentVersion: String) {
+        Thread {
+            try {
+                val baseDir = File(context.filesDir, BUILTIN_EXTRACT_DIR)
+                if (!baseDir.exists() || !baseDir.isDirectory) return@Thread
+                val dirs = baseDir.listFiles() ?: return@Thread
+                for (dir in dirs) {
+                    if (dir.isDirectory && dir.name != currentVersion) {
+                        SBLLogger.info("Cleaning up old extract dir: ${dir.name}")
+                        dir.deleteRecursively()
+                    }
+                }
+            } catch (e: Exception) {
+                SBLLogger.warn("Failed to cleanup old extract dirs: ${e.message}")
+            }
+        }.start()
+    }
+
     private fun getOtaBundlePath(): String? {
         return try {
             val bundleUpdateStore = Class.forName(

package/ios/SplitBundleLoader.h

@@ -10,5 +10,9 @@
              sha256:(NSString *)sha256
             resolve:(RCTPromiseResolveBlock)resolve
              reject:(RCTPromiseRejectBlock)reject;
+- (void)resolveSegmentPath:(NSString *)relativePath
+                    sha256:(NSString *)sha256
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject;
 
 @end

package/ios/SplitBundleLoader.mm

@@ -2,6 +2,11 @@
 #import "SBLLogger.h"
 #import <React/RCTBridge.h>
 
+// Bridgeless (New Architecture) support: RCTHost segment registration
+@interface RCTHost (SplitBundle)
+- (void)registerSegmentWithId:(NSNumber *)segmentId path:(NSString *)path;
+@end
+
 @implementation SplitBundleLoader
 
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
@@ -21,6 +26,78 @@
     return NO;
 }
 
+// MARK: - OTA bundle path helper
+
+/// Safely retrieves the OTA bundle path via typed NSInvocation to avoid
+/// performSelector ARC/signature issues (#15).
++ (nullable NSString *)otaBundlePath
+{
+    Class cls = NSClassFromString(@"ReactNativeBundleUpdate.BundleUpdateStore");
+    if (!cls) return nil;
+
+    SEL sel = NSSelectorFromString(@"currentBundleMainJSBundle");
+    if (![cls respondsToSelector:sel]) return nil;
+
+    NSMethodSignature *sig = [cls methodSignatureForSelector:sel];
+    if (!sig || strcmp(sig.methodReturnType, @encode(id)) != 0) {
+        [SBLLogger warn:@"OTA method signature mismatch — skipping"];
+        return nil;
+    }
+
+    NSInvocation *inv = [NSInvocation invocationWithMethodSignature:sig];
+    inv.target = cls;
+    inv.selector = sel;
+    [inv invoke];
+
+    __unsafe_unretained id rawResult = nil;
+    [inv getReturnValue:&rawResult];
+    if (![rawResult isKindOfClass:[NSString class]]) return nil;
+
+    NSString *result = (NSString *)rawResult;
+    if (result.length == 0) return nil;
+
+    if ([result hasPrefix:@"file://"]) {
+        result = [[NSURL URLWithString:result] path];
+    }
+    return result;
+}
+
+// MARK: - Segment registration helper
+
+/// Registers a segment with the current runtime, supporting both legacy bridge
+/// and bridgeless (RCTHost) architectures (#13).
+///
+/// Thread safety (#57): This method is called from the TurboModule (JS thread).
+/// RCTBridge.registerSegmentWithId:path: internally registers the segment with
+/// the Hermes runtime on the JS thread, which is the correct calling context.
+/// No queue dispatch is needed.
++ (BOOL)registerSegment:(int)segmentId path:(NSString *)path error:(NSError **)outError
+{
+    // Try legacy bridge first
+    RCTBridge *bridge = [RCTBridge currentBridge];
+    if (bridge && [bridge respondsToSelector:@selector(registerSegmentWithId:path:)]) {
+        [bridge registerSegmentWithId:@(segmentId) path:path];
+        return YES;
+    }
+
+    // Try bridgeless RCTHost via AppDelegate
+    id<UIApplicationDelegate> appDelegate = [UIApplication sharedApplication].delegate;
+    if ([appDelegate respondsToSelector:NSSelectorFromString(@"reactHost")]) {
+        id host = [appDelegate performSelector:NSSelectorFromString(@"reactHost")];
+        if (host && [host respondsToSelector:@selector(registerSegmentWithId:path:)]) {
+            [host registerSegmentWithId:@(segmentId) path:path];
+            return YES;
+        }
+    }
+
+    if (outError) {
+        *outError = [NSError errorWithDomain:@"SplitBundleLoader"
+                                        code:1
+                                    userInfo:@{NSLocalizedDescriptionKey: @"Neither RCTBridge nor RCTHost available for segment registration"}];
+    }
+    return NO;
+}
+
 // MARK: - getRuntimeBundleContext
 
 - (void)getRuntimeBundleContext:(RCTPromiseResolveBlock)resolve
@@ -33,31 +110,12 @@
         NSString *nativeVersion = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleShortVersionString"] ?: @"";
         NSString *bundleVersion = @"";
 
-        // Check if OTA bundle is active via BundleUpdateStore
-        Class bundleUpdateStoreClass = NSClassFromString(@"ReactNativeBundleUpdate.BundleUpdateStore");
-        if (bundleUpdateStoreClass) {
-            NSString *otaBundlePath = nil;
-            SEL sel = NSSelectorFromString(@"currentBundleMainJSBundle");
-            if ([bundleUpdateStoreClass respondsToSelector:sel]) {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
-                id result = [bundleUpdateStoreClass performSelector:sel];
-#pragma clang diagnostic pop
-                otaBundlePath = [result isKindOfClass:[NSString class]] ? (NSString *)result : nil;
-            }
-            if (otaBundlePath && otaBundlePath.length > 0) {
-                NSString *filePath = otaBundlePath;
-                if ([otaBundlePath hasPrefix:@"file://"]) {
-                    filePath = [[NSURL URLWithString:otaBundlePath] path];
-                }
-                if ([[NSFileManager defaultManager] fileExistsAtPath:filePath]) {
-                    sourceKind = @"ota";
-                    bundleRoot = [filePath stringByDeletingLastPathComponent];
-                }
-            }
+        NSString *otaPath = [SplitBundleLoader otaBundlePath];
+        if (otaPath && [[NSFileManager defaultManager] fileExistsAtPath:otaPath]) {
+            sourceKind = @"ota";
+            bundleRoot = [otaPath stringByDeletingLastPathComponent];
         }
 
-        // Builtin: use main bundle resource path
         if ([sourceKind isEqualToString:@"builtin"]) {
             bundleRoot = [[NSBundle mainBundle] resourcePath] ?: @"";
         }
@@ -74,6 +132,62 @@
     }
 }
 
+// MARK: - Path resolution helper
+
+/// Resolves a relative segment path to an absolute path, checking OTA then builtin.
+/// Returns nil if the segment file is not found.
++ (nullable NSString *)resolveAbsolutePath:(NSString *)relativePath
+{
+    // 1. Try OTA bundle root first
+    NSString *otaPath = [SplitBundleLoader otaBundlePath];
+    if (otaPath) {
+        NSString *otaRoot = [otaPath stringByDeletingLastPathComponent];
+        NSString *candidate = [[otaRoot stringByAppendingPathComponent:relativePath] stringByStandardizingPath];
+        if ([candidate hasPrefix:otaRoot] &&
+            [[NSFileManager defaultManager] fileExistsAtPath:candidate]) {
+            return candidate;
+        }
+    }
+
+    // 2. Fallback to builtin resource path
+    NSString *builtinRoot = [[NSBundle mainBundle] resourcePath];
+    NSString *candidate = [[builtinRoot stringByAppendingPathComponent:relativePath] stringByStandardizingPath];
+    if ([candidate hasPrefix:builtinRoot] &&
+        [[NSFileManager defaultManager] fileExistsAtPath:candidate]) {
+        return candidate;
+    }
+
+    return nil;
+}
+
+// MARK: - resolveSegmentPath (Phase 3)
+
+- (void)resolveSegmentPath:(NSString *)relativePath
+                    sha256:(NSString *)sha256
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject
+{
+    @try {
+        if ([relativePath containsString:@".."]) {
+            reject(@"SPLIT_BUNDLE_INVALID_PATH",
+                   [NSString stringWithFormat:@"Path traversal rejected: %@", relativePath],
+                   nil);
+            return;
+        }
+
+        NSString *absolutePath = [SplitBundleLoader resolveAbsolutePath:relativePath];
+        if (absolutePath) {
+            resolve(absolutePath);
+        } else {
+            reject(@"SPLIT_BUNDLE_NOT_FOUND",
+                   [NSString stringWithFormat:@"Segment file not found: %@", relativePath],
+                   nil);
+        }
+    } @catch (NSException *exception) {
+        reject(@"SPLIT_BUNDLE_RESOLVE_ERROR", exception.reason, nil);
+    }
+}
+
 // MARK: - loadSegment
 
 - (void)loadSegment:(double)segmentId
@@ -86,42 +200,15 @@
     @try {
         int segId = (int)segmentId;
 
-        // Resolve absolute path
-        NSString *absolutePath = nil;
-
-        // 1. Try OTA bundle root first
-        Class bundleUpdateStoreClass = NSClassFromString(@"ReactNativeBundleUpdate.BundleUpdateStore");
-        if (bundleUpdateStoreClass) {
-            NSString *otaBundlePath = nil;
-            SEL sel = NSSelectorFromString(@"currentBundleMainJSBundle");
-            if ([bundleUpdateStoreClass respondsToSelector:sel]) {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
-                id result = [bundleUpdateStoreClass performSelector:sel];
-#pragma clang diagnostic pop
-                otaBundlePath = [result isKindOfClass:[NSString class]] ? (NSString *)result : nil;
-            }
-            if (otaBundlePath && otaBundlePath.length > 0) {
-                NSString *filePath = otaBundlePath;
-                if ([otaBundlePath hasPrefix:@"file://"]) {
-                    filePath = [[NSURL URLWithString:otaBundlePath] path];
-                }
-                NSString *otaRoot = [filePath stringByDeletingLastPathComponent];
-                NSString *candidate = [otaRoot stringByAppendingPathComponent:relativePath];
-                if ([[NSFileManager defaultManager] fileExistsAtPath:candidate]) {
-                    absolutePath = candidate;
-                }
-            }
+        // Path traversal guard (#45)
+        if ([relativePath containsString:@".."]) {
+            reject(@"SPLIT_BUNDLE_INVALID_PATH",
+                   [NSString stringWithFormat:@"Path traversal rejected: %@", relativePath],
+                   nil);
+            return;
         }
 
-        // 2. Fallback to builtin resource path
-        if (!absolutePath) {
-            NSString *builtinRoot = [[NSBundle mainBundle] resourcePath];
-            NSString *candidate = [builtinRoot stringByAppendingPathComponent:relativePath];
-            if ([[NSFileManager defaultManager] fileExistsAtPath:candidate]) {
-                absolutePath = candidate;
-            }
-        }
+        NSString *absolutePath = [SplitBundleLoader resolveAbsolutePath:relativePath];
 
         if (!absolutePath) {
             reject(@"SPLIT_BUNDLE_NOT_FOUND",
@@ -130,14 +217,15 @@
             return;
         }
 
-        // Register segment via RCTBridge
-        RCTBridge *bridge = [RCTBridge currentBridge];
-        if (bridge) {
-            [bridge registerSegmentWithId:@(segId) path:absolutePath];
+        // Register segment (#13: supports both bridge and bridgeless)
+        NSError *regError = nil;
+        if ([SplitBundleLoader registerSegment:segId path:absolutePath error:&regError]) {
             [SBLLogger info:[NSString stringWithFormat:@"Loaded segment %@ (id=%d)", segmentKey, segId]];
             resolve(nil);
         } else {
-            reject(@"SPLIT_BUNDLE_NO_BRIDGE", @"RCTBridge not available", nil);
+            reject(@"SPLIT_BUNDLE_NO_RUNTIME",
+                   regError.localizedDescription ?: @"Runtime not available",
+                   regError);
         }
     } @catch (NSException *exception) {
         reject(@"SPLIT_BUNDLE_LOAD_ERROR",

package/lib/module/NativeSplitBundleLoader.js.map

@@ -1 +1 @@
-{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeSplitBundleLoader.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAAQ,cAAc;AAqBlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,mBAAmB,CAAC","ignoreList":[]}
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeSplitBundleLoader.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAAQ,cAAc;AAsBlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,mBAAmB,CAAC","ignoreList":[]}

package/lib/typescript/src/NativeSplitBundleLoader.d.ts

@@ -9,6 +9,7 @@ export interface Spec extends TurboModule {
         bundleVersion?: string;
     }>;
     loadSegment(segmentId: number, segmentKey: string, relativePath: string, sha256: string): Promise<void>;
+    resolveSegmentPath(relativePath: string, sha256: string): Promise<string>;
 }
 declare const _default: Spec;
 export default _default;

package/lib/typescript/src/NativeSplitBundleLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeSplitBundleLoader.d.ts","sourceRoot":"","sources":["../../../src/NativeSplitBundleLoader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,uBAAuB,IAAI,OAAO,CAAC;QACjC,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC,CAAC;IACH,WAAW,CACT,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB;;AAED,wBAA2E"}
+{"version":3,"file":"NativeSplitBundleLoader.d.ts","sourceRoot":"","sources":["../../../src/NativeSplitBundleLoader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,uBAAuB,IAAI,OAAO,CAAC;QACjC,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC,CAAC;IACH,WAAW,CACT,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC3E;;AAED,wBAA2E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-split-bundle-loader",
-  "version": "0.1.1",
+  "version": "1.1.51",
   "description": "react-native-split-bundle-loader",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/NativeSplitBundleLoader.ts

@@ -17,6 +17,7 @@ export interface Spec extends TurboModule {
     relativePath: string,
     sha256: string,
   ): Promise<void>;
+  resolveSegmentPath(relativePath: string, sha256: string): Promise<string>;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('SplitBundleLoader');