react-native-bspatch 3.1.2 → 4.0.1

package/src/index.ts

@@ -20,13 +20,6 @@ export * from './ota/otaLogger';
 export * from './ota/OtaProvider';
 export * from './ota/types';
 
-/**
- * @deprecated No-ops since 3.1: OTA assets are placed next to the bundle, where React
- * Native resolves them by default, so no source transformer is needed.
- */
-export const initOtaAssetResolver = async (_version: number): Promise<void> => {};
-/** @deprecated No-op since 3.1, see initOtaAssetResolver. */
-export const resetOtaAssetResolver = (): void => {};
 export { GitHubRawStorageProvider } from './ota/storage/GitHubRawStorage';
 
 export default {

package/src/ota/OtaProvider.tsx

@@ -16,11 +16,10 @@ import {
   Text,
   View,
 } from 'react-native';
-import ReactNativeBlobUtil from 'react-native-blob-util';
 import NativeBsPatch from '../NativeBsPatch';
 import { applyOtaPatchInternal, fetchOtaManifest, selectUpdate, validateOtaConfig } from './otaCore';
 import { createOtaLogger, OtaEvent } from './otaLogger';
-import { loadMetadata, markHealthy } from './otaMetadata';
+import { DOCUMENT_DIR, loadMetadata, markHealthy, OTA_DIR } from './otaMetadata';
 import {
   OtaConfig,
   OtaMetrics,
@@ -109,11 +108,12 @@ export function OtaProvider({
    */
   const executeApplyUpdate = useCallback(
     async (patchList: OtaPatch[], currentVer: number, targetVer: number) => {
-      console.log('[OtaProvider] executeApplyUpdate | targetV:', targetVer, 'currentV:', currentVer);
       const directPatch = selectUpdate(patchList, currentVer, targetVer);
 
       if (!directPatch) {
-        console.warn('[OtaProvider] No update entry found for', currentVer, '->', targetVer);
+        if (__DEV__) {
+          console.warn('[OtaProvider] No update entry found for', currentVer, '->', targetVer);
+        }
         setStatus(OtaStatus.ERROR);
         setMessage('No upgrade path found.');
         return;
@@ -137,7 +137,9 @@ export function OtaProvider({
           },
         );
       } catch (error) {
-        console.error('[OtaProvider] Update error:', error);
+        if (__DEV__) {
+          console.error('[OtaProvider] Update error:', error);
+        }
         setStatus(OtaStatus.ERROR);
         setMessage(`Update failed: ${(error as Error).message}`);
       }
@@ -223,21 +225,20 @@ export function OtaProvider({
       const remotePatches = await fetchOtaManifest(effectiveConfig);
       const metadata = await loadMetadata(config.baseAppVersion);
       const localV = metadata.currentVersion;
-      console.log('[OtaProvider] checkUpdates | localV:', localV, 'remotePatches count:', remotePatches.length);
 
-      // Skip versions that crashed on boot and were rolled back by the native resolver
+      // The one platform filter (storage providers return every platform).
+      // Also skips versions that crashed on boot and were rolled back natively.
       const failed = metadata.failedVersions ?? [];
       const platformPatches = remotePatches.filter(
-        p => (!p.platform || p.platform === Platform.OS) && !failed.includes(p.toVersion),
+        p =>
+          (!p.platform || p.platform.toLowerCase() === Platform.OS) &&
+          !failed.includes(p.toVersion),
       );
-      console.log('[OtaProvider] platformPatches count:', platformPatches.length);
 
       const maxV =
         platformPatches.length > 0
           ? Math.max(...platformPatches.map(p => p.toVersion))
           : localV;
-      
-      console.log('[OtaProvider] latestV determined:', maxV);
 
       setPatches(platformPatches);
       setCurrentVersion(localV);
@@ -286,10 +287,10 @@ export function OtaProvider({
   useEffect(() => {
     const bootstrap = async () => {
       // Clean up any pending trash directories from previous resets (non-blocking)
-      ReactNativeBlobUtil.fs.ls(ReactNativeBlobUtil.fs.dirs.DocumentDir).then(dirs => {
+      NativeBsPatch.readDir(DOCUMENT_DIR).then(dirs => {
         for (const dir of dirs) {
           if (dir.startsWith('ota_trash_')) {
-            ReactNativeBlobUtil.fs.unlink(`${ReactNativeBlobUtil.fs.dirs.DocumentDir}/${dir}`).catch(() => {});
+            NativeBsPatch.removePath(`${DOCUMENT_DIR}/${dir}`).catch(() => {});
           }
         }
       }).catch(() => {});
@@ -367,24 +368,22 @@ export function OtaProvider({
     };
   }, [config.updateMode, checkUpdates]);
 
-  const markAsHealthy = async () => {
+  const markAsHealthy = useCallback(async () => {
     const log = createOtaLogger(config.onEvent);
     log.emit(OtaEvent.MARK_HEALTHY);
     const appVersion = await NativeBsPatch.getAppVersion().catch(() => config.appVersion);
     await markHealthy(config.baseAppVersion, runningVersionRef.current, appVersion);
-  };
+  }, [config]);
 
-  const resetToFactory = async () => {
+  const resetToFactory = useCallback(async () => {
     const log = createOtaLogger(config.onEvent);
     try {
       setStatus(OtaStatus.APPLYING);
       setMessage('Executing system wipe...');
       log.emit(OtaEvent.RESET_FACTORY);
-      const otaDir = `${ReactNativeBlobUtil.fs.dirs.DocumentDir}/ota`;
-      if (await ReactNativeBlobUtil.fs.exists(otaDir)) {
+      if (await NativeBsPatch.exists(OTA_DIR)) {
         // Fast atomic rename to prevent blocking the JS thread during deletion of potentially 1000s of files
-        const trashDir = `${ReactNativeBlobUtil.fs.dirs.DocumentDir}/ota_trash_${Date.now()}`;
-        await ReactNativeBlobUtil.fs.mv(otaDir, trashDir);
+        await NativeBsPatch.moveFile(OTA_DIR, `${DOCUMENT_DIR}/ota_trash_${Date.now()}`);
         // Deletion is deferred to the next app bootstrap to prevent blocking the bridge before reload
       }
       setMessage('Reset complete. Core reload initiated...');
@@ -393,9 +392,10 @@ export function OtaProvider({
       setStatus(OtaStatus.ERROR);
       setMessage(`Reset failed: ${(error as Error).message}`);
     }
-  };
+  }, [config]);
 
-  const value: OtaState = {
+  // Memoized: consumers re-render only when something they can see changes
+  const value = useMemo<OtaState>(() => ({
     status,
     message,
     progress,
@@ -410,7 +410,21 @@ export function OtaProvider({
     markAsHealthy,
     checkUpdate: checkUpdates,
     reloadBundle: () => NativeBsPatch.reloadBundle(),
-  };
+  }), [
+    status,
+    message,
+    progress,
+    currentVersion,
+    latestVersion,
+    pendingCount,
+    isChecking,
+    metrics,
+    isUpdateReady,
+    applyUpdate,
+    resetToFactory,
+    markAsHealthy,
+    checkUpdates,
+  ]);
 
   // Logic to determine if we should block the UI
   const isBlocking = useMemo(() => {

package/src/ota/otaCore.ts

@@ -11,18 +11,19 @@
  *  - Structured telemetry logging
  */
 
-import { Platform } from 'react-native';
-import ReactNativeBlobUtil from 'react-native-blob-util';
 import NativeBsPatch from '../NativeBsPatch';
 import { createOtaLogger, OtaEvent } from './otaLogger';
 import {
+    ASSET_LIST_FILE,
+    DOCUMENT_DIR,
     ensureOtaDir,
+    OTA_DIR,
     getBundlePath,
     loadMetadata,
     registerNewVersion,
     updateMetadata,
 } from './otaMetadata';
-import { GitHubRawStorageProvider } from './storage/GitHubRawStorage';
+import { fetchJson, GitHubRawStorageProvider } from './storage/GitHubRawStorage';
 import {
     OtaStatus,
     type OtaAsset,
@@ -32,8 +33,6 @@ import {
     type OtaStorageProvider,
 } from './types';
 
-const OTA_DIR = `${ReactNativeBlobUtil.fs.dirs.DocumentDir}/ota`;
-
 // ─── Storage Provider Factory ──────────────────────────────────────────
 
 const DEFAULT_STORAGE = new GitHubRawStorageProvider();
@@ -97,7 +96,7 @@ export const verifyHash = async (
 ): Promise<boolean> => {
     if (!expectedHash) return true;
     try {
-        const hash = await ReactNativeBlobUtil.fs.hash(path, 'sha256');
+        const hash = await NativeBsPatch.hashFile(path);
         return hash.toLowerCase() === expectedHash.toLowerCase();
     } catch {
         return false;
@@ -125,66 +124,40 @@ const assertSigned = async (
 
 /**
  * Download a file with retry logic using exponential backoff.
- * Cancels any in-flight request before retrying to avoid resource leaks.
+ * Native streams to `${destPath}.part` and renames only on a 2xx response, so a
+ * cut-off download or an error page never sits at destPath looking complete.
+ * @returns Size of the downloaded file in bytes
  */
 const downloadWithRetry = async (
     url: string,
     destPath: string,
     config: OtaConfig,
     onProgress: (percent: number) => void,
-    headers: Record<string, string> = {},
-): Promise<void> => {
-    const retryLimit = config.network?.retry ?? 3;
+): Promise<number> => {
+    const retryLimit = Math.max(1, config.network?.retry ?? 3);
     const timeout = config.network?.timeoutMs ?? 30000;
+    const subscription = NativeBsPatch.onDownloadProgress(e => {
+        // total is -1 without a Content-Length
+        if (e.path === destPath && e.total > 0) {
+            onProgress(Math.min(100, Math.floor((e.received / e.total) * 100)));
+        }
+    });
 
-    for (let i = 0; i < retryLimit; i++) {
-        let taskRef: { cancel: () => void } | null = null;
-        // Download to .part and rename only on a 2xx response, so a cut-off
-        // download or an error page never sits at destPath looking complete.
-        const partPath = `${destPath}.part`;
-        try {
-            const task = ReactNativeBlobUtil.config({
-                fileCache: true,
-                path: partPath,
-                followRedirect: true,
-                timeout,
-            })
-                .fetch('GET', url, {
-                    'Cache-Control': 'no-cache',
-                    ...headers,
-                })
-                .progress((received: any, total: any) => {
-                    const percent = Math.floor(
-                        (Number(received) / Number(total)) * 100,
-                    );
-                    onProgress(percent);
-                });
-            taskRef = { cancel: () => task.cancel() };
-            const resp = await task;
-            const status = resp.respInfo.status;
-            if (status < 200 || status >= 300) {
-                throw new Error(`HTTP ${status} for ${url}`);
-            }
-            if (await ReactNativeBlobUtil.fs.exists(destPath)) {
-                await ReactNativeBlobUtil.fs.unlink(destPath);
-            }
-            await ReactNativeBlobUtil.fs.mv(partPath, destPath);
-            return;
-        } catch (e) {
-            // Cancel any lingering request before retrying
-            taskRef?.cancel();
-            await ReactNativeBlobUtil.fs.unlink(partPath).catch(() => {});
-            if (i === retryLimit - 1) throw e;
-            const delay = Math.pow(2, i) * 1000; // Exponential backoff: 1s, 2s, 4s...
-            if (__DEV__) {
-                console.warn(
-                    `[otaCore] Download attempt ${
-                        i + 1
-                    } failed. Retrying in ${delay}ms...`,
-                );
+    try {
+        for (let i = 0; ; i++) {
+            try {
+                return await NativeBsPatch.downloadFile(url, destPath, timeout);
+            } catch (e) {
+                if (i >= retryLimit - 1) throw e;
+                const delay = Math.pow(2, i) * 1000; // Exponential backoff: 1s, 2s, 4s...
+                if (__DEV__) {
+                    console.warn(`[otaCore] Download attempt ${i + 1} failed. Retrying in ${delay}ms...`);
+                }
+                await new Promise<void>(resolve => setTimeout(resolve, delay));
             }
-            await new Promise<void>(resolve => setTimeout(resolve, delay));
         }
+    } finally {
+        subscription.remove();
     }
 };
 
@@ -204,7 +177,7 @@ export const fetchOtaManifest = (config: OtaConfig): Promise<OtaPatch[]> =>
 
 // ─── Hashed Asset Store ───────────────────────────────────────────────
 
-const ASSET_STORE_DIR = `${ReactNativeBlobUtil.fs.dirs.DocumentDir}/ota/assets`;
+const ASSET_STORE_DIR = `${OTA_DIR}/assets`;
 
 /** Relative path inside the version dir: no absolute paths, no `..` segments. */
 const isSafeRelativePath = (p: string): boolean =>
@@ -231,20 +204,13 @@ const downloadAndSyncAssets = async (
     ) => void,
     onProgress: (percent: number) => void,
 ): Promise<void> => {
-    const fs = ReactNativeBlobUtil.fs;
+    const fs = NativeBsPatch;
     onStatus(OtaStatus.SYNCING_ASSETS, 'Syncing assets...');
     const versionDir = `${OTA_DIR}/v${version}`;
 
     let assets: OtaAsset[] = [];
     try {
-        const resp = await ReactNativeBlobUtil.config({
-            followRedirect: true,
-            timeout: 10000,
-        }).fetch('GET', assetManifestUrl, { 'Cache-Control': 'no-cache' });
-        if (resp.respInfo.status !== 200) {
-            throw new Error(`status ${resp.respInfo.status}`);
-        }
-        const manifest = typeof resp.data === 'string' ? JSON.parse(resp.data) : resp.data;
+        const manifest = await fetchJson(assetManifestUrl, 10000);
         // Hash/ext/path become file names: reject anything unexpected
         assets = (manifest.assets || []).filter(
             (a: any) =>
@@ -258,13 +224,18 @@ const downloadAndSyncAssets = async (
         throw new Error(`Failed to fetch asset manifest: ${(e as Error).message}`);
     }
     if (assets.length === 0) return;
+    // Lets cleanupOldVersions keep the store files that retained versions use
+    await fs.writeFile(
+        `${versionDir}/${ASSET_LIST_FILE}`,
+        JSON.stringify(assets.map(a => `${a.hash}.${a.ext}`)),
+    );
 
     onStatus(OtaStatus.SYNCING_ASSETS, `Syncing ${assets.length} asset(s)...`);
-    // One promise per dir: parallel workers would otherwise race mkdir (EEXIST)
+    // Native mkdir creates parents and tolerates an existing dir; this just skips repeats
     const dirs = new Map<string, Promise<void>>();
     const ensureDir = (dir: string): Promise<void> => {
         if (!dirs.has(dir)) {
-            dirs.set(dir, fs.exists(dir).then(ok => (ok ? undefined : fs.mkdir(dir))));
+            dirs.set(dir, fs.mkdir(dir));
         }
         return dirs.get(dir)!;
     };
@@ -285,18 +256,14 @@ const downloadAndSyncAssets = async (
                     if (!url) throw new Error('no URL');
                     await downloadWithRetry(url, storePath, config, () => {});
                     if (!(await verifyHash(storePath, asset.hash))) {
-                        await fs.unlink(storePath).catch(() => {});
+                        await fs.removePath(storePath).catch(() => {});
                         throw new Error('hash mismatch');
                     }
                     downloaded++;
                 }
                 const dest = `${versionDir}/${asset.originalPath}`;
-                const parts = asset.originalPath.split('/').slice(0, -1);
-                for (let i = 1; i <= parts.length; i++) {
-                    await ensureDir(`${versionDir}/${parts.slice(0, i).join('/')}`);
-                }
-                if (await fs.exists(dest)) await fs.unlink(dest);
-                await fs.cp(storePath, dest);
+                await ensureDir(dest.slice(0, dest.lastIndexOf('/')));
+                await fs.copyFile(storePath, dest);
             } catch (e) {
                 if (__DEV__) {
                     console.warn(`[otaCore] Asset ${asset.originalPath} failed:`, e);
@@ -342,7 +309,7 @@ export const getLocalAssetPath = (hash: string, ext: string): string =>
  * Gets the local filesystem path for a downloaded patch file.
  *
  * @param patch - Patch metadata object
- * @param docDir - Document directory path (use `ReactNativeBlobUtil.fs.dirs.DocumentDir`)
+ * @param docDir - Document directory path (`DOCUMENT_DIR`)
  * @returns Absolute path to the patch file
  */
 export const getLocalPatchPath = (patch: OtaPatch, docDir: string): string =>
@@ -351,15 +318,14 @@ export const getLocalPatchPath = (patch: OtaPatch, docDir: string): string =>
 /**
  * Picks the registry entry for `localV → targetV`: a patch from the OTA bundle
  * already on disk, else the full-bundle entry (store build, or outside the patch window).
+ * `patchList` is already filtered to this platform (checkUpdates).
  */
 export const selectUpdate = (
     patchList: OtaPatch[],
     localV: number,
     targetV: number,
 ): OtaPatch | undefined => {
-    const forTarget = patchList.filter(
-        p => p.toVersion === targetV && (!p.platform || p.platform === Platform.OS),
-    );
+    const forTarget = patchList.filter(p => p.toVersion === targetV);
     return (
         forTarget.find(p => p.filename && p.fromVersion === localV) ??
         forTarget.find(p => !p.filename)
@@ -417,13 +383,13 @@ const runUpdatePipeline = async (
     const log = createOtaLogger(config.onEvent);
     await ensureOtaDir();
     const totalStart = Date.now();
-    const fs = ReactNativeBlobUtil.fs;
+    const fs = NativeBsPatch;
 
     const finalBundlePath =
         getBundlePath(patch.toVersion, config.baseAppVersion) || '';
     const tempBundle = `${finalBundlePath}.tmp`;
     const versionDir = `${OTA_DIR}/v${patch.toVersion}`;
-    const localPatchPath = getLocalPatchPath(patch, fs.dirs.DocumentDir);
+    const localPatchPath = getLocalPatchPath(patch, DOCUMENT_DIR);
 
     // ── Version Compatibility ──
     // Checked before anything else so an incompatible update can't reach the full-bundle path
@@ -448,16 +414,15 @@ const runUpdatePipeline = async (
         }
     }
 
-    if (!(await fs.exists(versionDir))) {
-        await fs.mkdir(versionDir);
-    }
+    await fs.mkdir(versionDir);
 
     const download = async (remoteName: string, dest: string) => {
         log.emit(OtaEvent.DOWNLOAD_START, { version: patch.toVersion });
         const dlStart = Date.now();
+        let sizeBytes: number;
         try {
             const url = await getStorage(config).getUpdateFileUrl(remoteName, config);
-            await downloadWithRetry(url, dest, config, onProgress);
+            sizeBytes = await downloadWithRetry(url, dest, config, onProgress);
         } catch (dlError) {
             log.emit(OtaEvent.DOWNLOAD_FAIL, {
                 error: (dlError as Error).message,
@@ -466,7 +431,6 @@ const runUpdatePipeline = async (
             throw dlError;
         }
         const downloadMs = Date.now() - dlStart;
-        const sizeBytes = Number((await fs.stat(dest)).size);
         log.emit(OtaEvent.DOWNLOAD_SUCCESS, {
             version: patch.toVersion,
             durationMs: downloadMs,
@@ -477,7 +441,7 @@ const runUpdatePipeline = async (
 
     const assertHash = async (path: string, expected: string | undefined, what: string) => {
         if (!expected || (await verifyHash(path, expected))) return;
-        const actual = await fs.hash(path, 'sha256').catch(() => '');
+        const actual = await fs.hashFile(path).catch(() => '');
         log.emit(OtaEvent.HASH_MISMATCH, {
             message: `${what} hash mismatch`,
             version: patch.toVersion,
@@ -503,10 +467,7 @@ const runUpdatePipeline = async (
             );
         }
 
-        if (await fs.exists(finalBundlePath)) {
-            await fs.unlink(finalBundlePath);
-        }
-        await fs.mv(tempBundle, finalBundlePath);
+        await fs.moveFile(tempBundle, finalBundlePath);
 
         // Native version, not config.appVersion: the native resolver compares against it on boot
         const nativeAppVersion = await NativeBsPatch.getAppVersion().catch(() => config.appVersion);
@@ -556,7 +517,7 @@ const runUpdatePipeline = async (
         const applyStart = Date.now();
         const success = await NativeBsPatch.applyPatch(sourcePath, tempBundle, localPatchPath);
         const applyMs = Date.now() - applyStart;
-        await fs.unlink(localPatchPath).catch(() => {});
+        await fs.removePath(localPatchPath).catch(() => {});
         if (!success) {
             log.emit(OtaEvent.PATCH_FAIL, {
                 message: 'BsPatch returned false',
@@ -583,8 +544,8 @@ const runUpdatePipeline = async (
     };
 
     const cleanup = async () => {
-        await fs.unlink(localPatchPath).catch(() => {});
-        await fs.unlink(tempBundle).catch(() => {});
+        await fs.removePath(localPatchPath).catch(() => {});
+        await fs.removePath(tempBundle).catch(() => {});
     };
 
     // Patch only from an OTA bundle we installed ourselves (byte-identical to the build output)

package/src/ota/otaMetadata.ts

@@ -1,10 +1,15 @@
 import { Platform } from 'react-native';
-import ReactNativeBlobUtil from 'react-native-blob-util';
+import NativeBsPatch from '../NativeBsPatch';
 import { OtaMetadata } from './types';
 
-const OTA_DIR = `${ReactNativeBlobUtil.fs.dirs.DocumentDir}/ota`;
+/** Same directory the native resolver reads `ota/` from */
+export const DOCUMENT_DIR = NativeBsPatch.getDocumentDir();
+export const OTA_DIR = `${DOCUMENT_DIR}/ota`;
 const METADATA_PATH = `${OTA_DIR}/metadata.json`;
 const METADATA_TMP_PATH = `${METADATA_PATH}.tmp`;
+const ASSET_STORE_DIR = `${OTA_DIR}/assets`;
+/** Per-version list of `hash.ext` store files the version uses (written by otaCore) */
+export const ASSET_LIST_FILE = 'assets.json';
 
 /** Serializes metadata updates (see updateMetadata). */
 let saveLock: Promise<void> = Promise.resolve();
@@ -12,11 +17,7 @@ let saveLock: Promise<void> = Promise.resolve();
 /**
  * Ensures the OTA root directory exists.
  */
-export const ensureOtaDir = async (): Promise<void> => {
-    if (!(await ReactNativeBlobUtil.fs.exists(OTA_DIR))) {
-        await ReactNativeBlobUtil.fs.mkdir(OTA_DIR);
-    }
-};
+export const ensureOtaDir = (): Promise<void> => NativeBsPatch.mkdir(OTA_DIR);
 
 /**
  * Loads the current OTA metadata from the local filesystem.
@@ -28,10 +29,10 @@ export const loadMetadata = async (
     defaultVersion: number,
 ): Promise<OtaMetadata> => {
     try {
-        // A crash between unlink and rename in saveMetadata leaves only the .tmp copy
+        // Versions before 4.0 could crash between unlink and rename, leaving only the .tmp copy
         for (const path of [METADATA_PATH, METADATA_TMP_PATH]) {
-            if (await ReactNativeBlobUtil.fs.exists(path)) {
-                return JSON.parse(await ReactNativeBlobUtil.fs.readFile(path, 'utf8'));
+            if (await NativeBsPatch.exists(path)) {
+                return JSON.parse(await NativeBsPatch.readFile(path));
             }
         }
     } catch (e) {
@@ -62,16 +63,8 @@ export const updateMetadata = async (
         await prevLock;
         const metadata = fn(await loadMetadata(defaultVersion));
         await ensureOtaDir();
-        // Write-then-rename so a kill mid-write never leaves truncated JSON
-        await ReactNativeBlobUtil.fs.writeFile(
-            METADATA_TMP_PATH,
-            JSON.stringify(metadata, null, 2),
-            'utf8',
-        );
-        if (await ReactNativeBlobUtil.fs.exists(METADATA_PATH)) {
-            await ReactNativeBlobUtil.fs.unlink(METADATA_PATH);
-        }
-        await ReactNativeBlobUtil.fs.mv(METADATA_TMP_PATH, METADATA_PATH);
+        // Native writeFile is atomic: a kill mid-write never leaves truncated JSON
+        await NativeBsPatch.writeFile(METADATA_PATH, JSON.stringify(metadata, null, 2));
         return metadata;
     } catch (e) {
         console.error('[otaMetadata] Failed to save metadata:', e);
@@ -125,8 +118,8 @@ export const cleanupOldVersions = async (
     baseVersion: number,
 ): Promise<void> => {
     try {
-        if (!(await ReactNativeBlobUtil.fs.exists(OTA_DIR))) return;
-        const items = await ReactNativeBlobUtil.fs.ls(OTA_DIR);
+        if (!(await NativeBsPatch.exists(OTA_DIR))) return;
+        const items = await NativeBsPatch.readDir(OTA_DIR);
 
         // Retain current active version and rollback versions
         const retainedVersions = new Set<number>([
@@ -139,9 +132,10 @@ export const cleanupOldVersions = async (
             const versionMatch = item.match(/^v(\d+)$/);
             if (versionMatch) {
                 const ver = parseInt(versionMatch[1], 10);
-                if (!retainedVersions.has(ver) && ver !== baseVersion) {
+                // Higher than current: may be an install in progress, not yet in metadata
+                if (!retainedVersions.has(ver) && ver !== baseVersion && ver < metadata.currentVersion) {
                     const dirPath = `${OTA_DIR}/${item}`;
-                    await ReactNativeBlobUtil.fs.unlink(dirPath).catch(() => {});
+                    await NativeBsPatch.removePath(dirPath).catch(() => {});
                     if (__DEV__) {
                         console.log(`[otaMetadata] Cleaned up obsolete OTA version: ${item}`);
                     }
@@ -149,14 +143,39 @@ export const cleanupOldVersions = async (
             }
             // Clean up leftover temporary bundle files (.tmp)
             if (item.endsWith('.tmp') && item !== 'metadata.json.tmp') {
-                await ReactNativeBlobUtil.fs.unlink(`${OTA_DIR}/${item}`).catch(() => {});
+                await NativeBsPatch.removePath(`${OTA_DIR}/${item}`).catch(() => {});
             }
         }
+        await cleanupAssetStore();
     } catch (e) {
         console.warn('[otaMetadata] Cleanup old versions failed:', e);
     }
 };
 
+/**
+ * Deletes store files no remaining version lists. The store is only a download
+ * cache (each version holds its own copies), so this never breaks a version.
+ * ponytail: an install that reuses a store file between our read of its list and
+ * the unlink fails its asset sync; it is retried on the next check.
+ */
+const cleanupAssetStore = async (): Promise<void> => {
+    const fs = NativeBsPatch;
+    if (!(await fs.exists(ASSET_STORE_DIR))) return;
+    const keep = new Set<string>();
+    for (const item of await fs.readDir(OTA_DIR)) {
+        const list = `${OTA_DIR}/${item}/${ASSET_LIST_FILE}`;
+        if (/^v\d+$/.test(item) && (await fs.exists(list))) {
+            const files: string[] = JSON.parse(await fs.readFile(list));
+            files.forEach(f => keep.add(f));
+        }
+    }
+    for (const file of await fs.readDir(ASSET_STORE_DIR)) {
+        if (!keep.has(file)) {
+            await fs.removePath(`${ASSET_STORE_DIR}/${file}`).catch(() => {});
+        }
+    }
+};
+
 /**
  * Marks the running version healthy: the native resolver stops treating its
  * launches as pending, so it is never rolled back afterwards (crash on first

package/src/ota/storage/GitHubRawStorage.ts

@@ -1,5 +1,3 @@
-import { Platform } from 'react-native';
-import ReactNativeBlobUtil from 'react-native-blob-util';
 import type { OtaConfig, OtaPatch, OtaStorageProvider } from '../types';
 
 /**
@@ -19,6 +17,21 @@ import type { OtaConfig, OtaPatch, OtaStorageProvider } from '../types';
 /** Headers to bypass GitHub CDN cache on mutable files (registry, manifests) */
 const NO_CACHE_HEADERS = { 'Cache-Control': 'no-cache' };
 
+/** GET + JSON.parse with a timeout (fetch has none of its own); rejects on non-2xx. */
+export const fetchJson = async (url: string, timeoutMs: number): Promise<any> => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, { headers: NO_CACHE_HEADERS, signal: controller.signal });
+        if (!res.ok) {
+            throw new Error(`HTTP ${res.status} for ${url}`);
+        }
+        return await res.json();
+    } finally {
+        clearTimeout(timer);
+    }
+};
+
 /** Append a timestamp query param to defeat CDN caches on mutable URLs */
 const bustCache = (url: string): string =>
     `${url}?cb=${Date.now()}`;
@@ -47,21 +60,7 @@ export class GitHubRawStorageProvider implements OtaStorageProvider {
         );
 
         try {
-            const res = await ReactNativeBlobUtil.config({ timeout: 15000 }).fetch(
-                'GET',
-                registryUrl,
-                NO_CACHE_HEADERS,
-            );
-            if (res.respInfo.status !== 200) {
-                throw new Error(
-                    `Registry fetch failed with status ${res.respInfo.status}`,
-                );
-            }
-
-            const registry =
-                typeof res.data === 'string'
-                    ? JSON.parse(res.data)
-                    : res.data;
+            const registry = await fetchJson(registryUrl, 15000);
 
             if (!config.appVersion) {
                 throw new Error(
@@ -71,11 +70,7 @@ export class GitHubRawStorageProvider implements OtaStorageProvider {
             const appGroup = registry?.apps?.[config.appVersion];
             const flavorGroup = appGroup?.flavors?.[channelName];
 
-            return (flavorGroup?.patches ?? []).filter(
-                (p: OtaPatch) =>
-                    !p.platform ||
-                    p.platform.toLowerCase() === Platform.OS.toLowerCase(),
-            );
+            return flavorGroup?.patches ?? [];
         } catch (error) {
             // Surface it: "no patches" would report a broken registry as up to date
             throw new Error(`[GitHubRawStorage] Manifest fetch error: ${(error as Error).message}`);