react-native-bspatch 2.0.0 → 3.0.0

package/lib/module/ota/otaAssetResolver.js.map

@@ -1 +1 @@
-{"version":3,"names":["Image","Platform","ReactNativeBlobUtil","NativeBsPatch","ASSET_STORE_DIR","fs","dirs","DocumentDir","assetManifest","assetMap","Map","assetList","assetLookupCache","isPatched","log","msg","formatted","console","logNative","initOtaAssetResolver","version","otaDir","versionDir","manifestPath","exists","content","readFile","JSON","parse","map","list","assets","forEach","a","normPath","originalPath","toLowerCase","replace","_normPath","set","length","patchAssetResolver","e","message","resolveAssetSource","setCustomSourceTransformer","resolver","res","defaultAsset","uri","startsWith","normUri","cached","get","found","undefined","find","endsWith","isBase","OS","finalUri","MainBundleDir","resName","split","pop","localPath","hash","ext","includes","resetOtaAssetResolver"],"sourceRoot":"../../../src","sources":["ota/otaAssetResolver.ts"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["Image","ReactNativeBlobUtil","NativeBsPatch","ASSET_STORE_DIR","fs","dirs","DocumentDir","assetManifest","assetMap","Map","assetList","assetLookupCache","isPatched","log","msg","formatted","console","logNative","initOtaAssetResolver","version","otaDir","versionDir","manifestPath","exists","content","readFile","JSON","parse","map","list","assets","forEach","a","normPath","originalPath","toLowerCase","replace","_normPath","set","length","patchAssetResolver","e","message","resolveAssetSource","setCustomSourceTransformer","resolver","res","defaultAsset","uri","startsWith","normUri","cached","get","found","undefined","find","endsWith","localPath","hash","ext","finalUri","includes","resetOtaAssetResolver"],"sourceRoot":"../../../src","sources":["ota/otaAssetResolver.ts"],"mappings":";;AAAA,SAASA,KAAK,QAAQ,cAAc;AACpC,OAAOC,mBAAmB,MAAM,wBAAwB;AACxD,OAAOC,aAAa,MAAM,kBAAkB;AAE5C,MAAMC,eAAe,GAAG,GAAGF,mBAAmB,CAACG,EAAE,CAACC,IAAI,CAACC,WAAW,aAAa;AAa/E,IAAIC,aAAmC,GAAG,IAAI;AAC9C,IAAIC,QAAoC,GAAG,IAAIC,GAAG,CAAC,CAAC;AACpD,IAAIC,SAA0B,GAAG,EAAE;AACnC,IAAIC,gBAAmD,GAAG,IAAIF,GAAG,CAAC,CAAC;AACnE,IAAIG,SAAS,GAAG,KAAK;;AAErB;AACA;AACA;AACA,MAAMC,GAAG,GAAIC,GAAW,IAAW;EAC/B,MAAMC,SAAS,GAAG,sBAAsBD,GAAG,EAAE;EAC7CE,OAAO,CAACH,GAAG,CAACE,SAAS,CAAC;EACtB,IAAIb,aAAa,EAAEe,SAAS,EAAE;IAC1Bf,aAAa,CAACe,SAAS,CAACF,SAAS,CAAC;EACtC;AACJ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMG,oBAAoB,GAAG,MAAOC,OAAe,IAAoB;EAC1E,MAAMC,MAAM,GAAG,GAAGnB,mBAAmB,CAACG,EAAE,CAACC,IAAI,CAACC,WAAW,MAAM;EAC/D,MAAMe,UAAU,GAAG,GAAGD,MAAM,KAAKD,OAAO,EAAE;EAC1C,MAAMG,YAAY,GAAG,GAAGD,UAAU,oBAAoBF,OAAO,OAAO;EAEpE,IAAI;IACA,IAAI,MAAMlB,mBAAmB,CAACG,EAAE,CAACmB,MAAM,CAACD,YAAY,CAAC,EAAE;MACnD,MAAME,OAAO,GAAG,MAAMvB,mBAAmB,CAACG,EAAE,CAACqB,QAAQ,CACjDH,YAAY,EACZ,MACJ,CAAC;MACDf,aAAa,GAAGmB,IAAI,CAACC,KAAK,CAACH,OAAO,CAAkB;;MAEpD;MACA,MAAMI,GAAG,GAAG,IAAInB,GAAG,CAAwB,CAAC;MAC5C,MAAMoB,IAAI,GAAGtB,aAAa,CAACuB,MAAM,IAAI,EAAE;MACvCD,IAAI,CAACE,OAAO,CAAEC,CAAgB,IAAK;QAC/B,MAAMC,QAAQ,GAAGD,CAAC,CAACE,YAAY,CAC1BC,WAAW,CAAC,CAAC,CACbC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CACnBA,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC;QAC/BJ,CAAC,CAACK,SAAS,GAAGJ,QAAQ,CAAC,CAAC;QACxBL,GAAG,CAACU,GAAG,CAACL,QAAQ,EAAED,CAAC,CAAC;MACxB,CAAC,CAAC;MACFxB,QAAQ,GAAGoB,GAAG;MACdlB,SAAS,GAAGmB,IAAI;MAChBlB,gBAAgB,GAAG,IAAIF,GAAG,CAAC,CAAC;MAE5BI,GAAG,CACC,uBAAuBM,OAAO,KAAKU,IAAI,CAACU,MAAM,kCAClD,CAAC;MACDC,kBAAkB,CAAC,CAAC;IACxB,CAAC,MAAM;MACH3B,GAAG,CAAC,0BAA0BS,YAAY,EAAE,CAAC;IACjD;EACJ,CAAC,CAAC,OAAOmB,CAAC,EAAE;IACR5B,GAAG,CAAC,4BAA6B4B,CAAC,CAAWC,OAAO,EAAE,CAAC;EAC3D;AACJ,CAAC;;AAID;AACA;AACA;AACA;AACA,MAAMF,kBAAkB,GAAGA,CAAA,KAAY;EACnC,IAAI5B,SAAS,EAAE;EACfA,SAAS,GAAG,IAAI;EAEhB,MAAM+B,kBAAkB,GAAI3C,KAAK,CAQ9B2C,kBAAkB;EAErB,IACIA,kBAAkB,IAClB,OAAOA,kBAAkB,CAACC,0BAA0B,KAAK,UAAU,EACrE;IACED,kBAAkB,CAACC,0BAA0B,CAAEC,QAAQ,IAAK;MACxD;MACA,MAAMC,GAAG,GAAGD,QAAQ,CAACE,YAAY,CAAC,CAAC;MACnC,IAAI,CAACD,GAAG,IAAI,CAACvC,aAAa,EAAE,OAAOuC,GAAG;MAEtC,MAAME,GAAG,GAAGF,GAAG,CAACE,GAAG;;MAEnB;MACA;MACA,IAAI,CAACA,GAAG,IAAIA,GAAG,CAACC,UAAU,CAAC,MAAM,CAAC,IAAID,GAAG,CAACC,UAAU,CAAC,MAAM,CAAC,EAAE;QAC1D,OAAOH,GAAG;MACd;MAEA,MAAMI,OAAO,GAAGF,GAAG,CACdb,WAAW,CAAC,CAAC,CACbC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CACnBA,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC;MAE/B,MAAMe,MAAM,GAAGxC,gBAAgB,CAACyC,GAAG,CAACF,OAAO,CAAC;;MAE5C;MACA,IAAIG,KAAK,GAAGF,MAAM,KAAKG,SAAS,GAAGA,SAAS,GAAGH,MAAM;;MAErD;MACA,IAAIE,KAAK,KAAKC,SAAS,EAAE;QACrBD,KAAK,GAAG7C,QAAQ,CAAC4C,GAAG,CAACF,OAAO,CAAC,IAAII,SAAS;MAC9C;;MAEA;MACA,IAAID,KAAK,KAAKC,SAAS,EAAE;QACrBD,KAAK,GAAG3C,SAAS,CAAC6C,IAAI,CAAEvB,CAAgB,IAAK;UACzC,OACIA,CAAC,CAACK,SAAS,CAACmB,QAAQ,CAACN,OAAO,CAAC,IAC7BA,OAAO,CAACM,QAAQ,CAACxB,CAAC,CAACK,SAAS,CAAC;QAErC,CAAC,CAAC;QACF1B,gBAAgB,CAAC2B,GAAG,CAACY,OAAO,EAAEG,KAAK,IAAI,IAAI,CAAC;MAChD;MAEA,IAAIA,KAAK,EAAE;QACP,MAAMI,SAAS,GAAG,GAAGtD,eAAe,IAAIkD,KAAK,CAACK,IAAI,IAAIL,KAAK,CAACM,GAAG,EAAE;QACjE;QACA,MAAMC,QAAQ,GAAG,UAAUH,SAAS,EAAE;QACtC5C,GAAG,CAAC,eAAemC,GAAG,OAAOK,KAAK,CAACK,IAAI,YAAYE,QAAQ,GAAG,CAAC;QAC/D,OAAO;UAAE,GAAGd,GAAG;UAAEE,GAAG,EAAEY;QAAS,CAAC;MACpC;;MAEA;MACA,IAAIZ,GAAG,CAACa,QAAQ,CAAC,QAAQ,CAAC,EAAE;QACxBhD,GAAG,CAAC,SAASmC,GAAG,0BAA0B,CAAC;MAC/C;MAEA,OAAOF,GAAG;IACd,CAAC,CAAC;IACFjC,GAAG,CAAC,gDAAgD,CAAC;EACzD,CAAC,MAAM;IACHA,GAAG,CACC,kFACJ,CAAC;EACL;AACJ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMiD,qBAAqB,GAAGA,CAAA,KAAY;EAC7CvD,aAAa,GAAG,IAAI;EACpBC,QAAQ,GAAG,IAAIC,GAAG,CAAC,CAAC;EACpBC,SAAS,GAAG,EAAE;EACdC,gBAAgB,GAAG,IAAIF,GAAG,CAAC,CAAC;EAC5BG,SAAS,GAAG,KAAK;AACrB,CAAC","ignoreList":[]}

package/lib/module/ota/otaCore.js

@@ -7,9 +7,9 @@
  *  - Download patches with retry
  *  - Verify integrity (SHA-256 hash)
  *  - Verify security (RSA/ECDSA signature)
- *  - Apply binary patch (bsdiff)
+ *  - Apply binary patch (bsdiff) from the installed OTA bundle
+ *  - Full bundle download (first OTA after a store install, or patch failure)
  *  - Atomic bundle swap
- *  - Full bundle fallback on failure
  *  - Structured telemetry logging
  */
 
@@ -17,7 +17,7 @@ import { Platform } from 'react-native';
 import ReactNativeBlobUtil from 'react-native-blob-util';
 import NativeBsPatch from '../NativeBsPatch';
 import { createOtaLogger, OtaEvent } from './otaLogger';
-import { ensureOtaDir, getBundlePath, loadMetadata, registerNewVersion, saveMetadata } from './otaMetadata';
+import { ensureOtaDir, getBundlePath, loadMetadata, registerNewVersion, updateMetadata } from './otaMetadata';
 import { GitHubRawStorageProvider } from './storage/GitHubRawStorage';
 import { OtaStatus } from './types';
 const OTA_DIR = `${ReactNativeBlobUtil.fs.dirs.DocumentDir}/ota`;
@@ -26,9 +26,28 @@ const OTA_DIR = `${ReactNativeBlobUtil.fs.dirs.DocumentDir}/ota`;
 
 const DEFAULT_STORAGE = new GitHubRawStorageProvider();
 
-/** Explicit `config.storage` (e.g. a future Cloudflare provider) or GitHub raw. */
+/** Explicit `config.storage` or the default static-host provider (GitHub raw, R2, CDN...). */
 const getStorage = config => config.storage ?? DEFAULT_STORAGE;
 
+/**
+ * Returns a message for config the default provider can't work with, else null.
+ * No fallbacks: a missing env value must surface, not silently point somewhere else.
+ */
+export const validateOtaConfig = config => {
+  if (config.storage) return null;
+  const {
+    baseUrl,
+    channel
+  } = config.customServer ?? {};
+  if (!baseUrl || !/^https?:\/\//.test(baseUrl)) {
+    return `customServer.baseUrl must be an http(s) URL, got ${JSON.stringify(baseUrl)}`;
+  }
+  if (!channel) {
+    return `customServer.channel is required, got ${JSON.stringify(channel)}`;
+  }
+  return null;
+};
+
 // ─── Helpers ──────────────────────────────────────────────────────────
 
 /**
@@ -145,17 +164,9 @@ const downloadWithRetry = async (url, destPath, config, onProgress, headers = {}
  * the app can still apply updates that were bundled at build time.
  *
  * @param config - OTA configuration containing storage provider and fallback patches
- * @returns Array of available patches, or bundled patches if remote fetch fails
+ * @returns Patches for this app version + channel; rejects if the registry can't be read
  */
-export const fetchOtaManifest = async config => {
-  try {
-    const storage = getStorage(config);
-    return await storage.fetchManifest(config);
-  } catch (error) {
-    console.warn('[otaCore] Manifest fetch error:', error.message);
-    return config.bundledPatches || [];
-  }
-};
+export const fetchOtaManifest = config => getStorage(config).fetchManifest(config);
 
 // ─── Hashed Asset Store ───────────────────────────────────────────────
 
@@ -206,9 +217,8 @@ const downloadAndSyncAssets = async (assetManifestUrl, version, config, log, onS
       console.log(`[otaCore] Saved asset manifest to: ${manifestPath}`);
     }
     const manifest = JSON.parse(manifestData);
-    // Filter out base assets, we don't need to download them
     // Hash/ext become file names: reject anything that isn't a plain sha256 + extension
-    assets = (manifest.assets || []).filter(a => !a.isBase && /^[a-f0-9]{64}$/i.test(a.hash) && /^[a-z0-9]+$/i.test(a.ext));
+    assets = (manifest.assets || []).filter(a => /^[a-f0-9]{64}$/i.test(a.hash) && /^[a-z0-9]+$/i.test(a.ext));
   } catch (e) {
     // Fatal: activating the bundle without its manifest leaves images unresolved
     throw new Error(`Failed to fetch asset manifest: ${e.message}`);
@@ -316,24 +326,28 @@ export const getLocalAssetPath = (hash, ext) => `${ASSET_STORE_DIR}/${hash}.${ex
  */
 export const getLocalPatchPath = (patch, docDir) => `${docDir}/ota/patch-${patch.appVersion}-${patch.id}.patch`;
 
+/**
+ * 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).
+ */
+export const selectUpdate = (patchList, localV, targetV) => {
+  const forTarget = patchList.filter(p => p.toVersion === targetV && (!p.platform || p.platform === Platform.OS));
+  return forTarget.find(p => p.filename && p.fromVersion === localV) ?? forTarget.find(p => !p.filename);
+};
+
 // ─── Main Update Pipeline ─────────────────────────────────────────────
 
 /**
- * Applies a single patch and reloads the bundle.
+ * Installs one OTA version.
  *
- * Pipeline:
- *  1. Version compatibility check
- *  2. Download patch (with retry)
- *  4. Security signature check
- *  5. Resolve source bundle
- *  6. Verify source hash
- *  7. Apply binary patch
- *  8. Verify result hash
- *  9. Atomic commit (mv)
- * 10. Update metadata
- * 11. Reload bundle
+ * Patch path (an OTA bundle for `patch.fromVersion` is on disk):
+ *   download patch → signature → source hash → bspatch → result hash/signature
+ * Full path (store build, no patch, or patch path failed):
+ *   download full bundle → hash → signature
+ * Both then: sync assets → atomic commit → metadata → mark healthy → reload.
  *
- * On failure → fallback to full bundle download if URL available.
+ * The store build's bundle is never used as a patch source: it can't be
+ * reproduced byte-for-byte at build time, so the first OTA is always a full download.
  */
 let updateInFlight = false;
 
@@ -359,195 +373,135 @@ const runUpdatePipeline = async (patch, config, onStatus, onProgress, options =
   const log = createOtaLogger(config.onEvent);
   await ensureOtaDir();
   const totalStart = Date.now();
+  const fs = ReactNativeBlobUtil.fs;
   const finalBundlePath = getBundlePath(patch.toVersion, config.baseAppVersion) || '';
   const tempBundle = `${finalBundlePath}.tmp`;
-  const localPatchPath = getLocalPatchPath(patch, ReactNativeBlobUtil.fs.dirs.DocumentDir);
-
-  // Cached per asset hash, so calling it again in the fallback is cheap
-  const syncAssets = async () => {
-    if (!patch.assetManifestUrl) return;
-    const manifestUrl = await getStorage(config).getUpdateFileUrl(patch.assetManifestUrl, config);
-    await downloadAndSyncAssets(manifestUrl, patch.toVersion, config, log, onStatus, onProgress);
-  };
-  try {
-    // ── Step 1: Version Compatibility ──
-    if (patch.minAppVersion) {
-      let currentAppVer = config.appVersion;
-      if (!currentAppVer && typeof NativeBsPatch.getAppVersion === 'function') {
-        try {
-          currentAppVer = await NativeBsPatch.getAppVersion();
-        } catch {
-          currentAppVer = undefined;
-        }
-      }
-      if (!currentAppVer) {
-        throw new Error(`[otaCore] Cannot verify minAppVersion: Native App Version could not be determined.`);
-      }
-      if (!semverGte(currentAppVer, patch.minAppVersion)) {
-        log.emit(OtaEvent.VERSION_INCOMPATIBLE, {
-          message: `App ${currentAppVer} < required ${patch.minAppVersion}`,
-          version: patch.toVersion
-        });
-        throw new Error(`Native app ${currentAppVer} is too old. Update to ${patch.minAppVersion}+ first.`);
-      }
+  const versionDir = `${OTA_DIR}/v${patch.toVersion}`;
+  const localPatchPath = getLocalPatchPath(patch, fs.dirs.DocumentDir);
+
+  // ── Version Compatibility ──
+  // Checked before anything else so an incompatible update can't reach the full-bundle path
+  if (patch.minAppVersion) {
+    let currentAppVer = config.appVersion;
+    if (!currentAppVer) {
+      currentAppVer = await NativeBsPatch.getAppVersion().catch(() => undefined);
     }
-
-    // ── Step 2: Download ──
-    let downloadMs = 0;
-    let patchSizeBytes = 0;
-    let fromCache = false;
-    if (await ReactNativeBlobUtil.fs.exists(localPatchPath)) {
-      const stat = await ReactNativeBlobUtil.fs.stat(localPatchPath);
-      patchSizeBytes = Number(stat.size);
-      fromCache = true;
-      onProgress(100);
-    } else {
-      log.emit(OtaEvent.DOWNLOAD_START, {
+    if (!currentAppVer) {
+      throw new Error('[otaCore] Cannot verify minAppVersion: Native App Version could not be determined.');
+    }
+    if (!semverGte(currentAppVer, patch.minAppVersion)) {
+      log.emit(OtaEvent.VERSION_INCOMPATIBLE, {
+        message: `App ${currentAppVer} < required ${patch.minAppVersion}`,
         version: patch.toVersion
       });
-      onStatus(OtaStatus.DOWNLOADING, `Downloading V${patch.toVersion}...`);
-      const dlStart = Date.now();
-      try {
-        const storage = getStorage(config);
-        const url = await storage.getUpdateFileUrl(patch.filename, config);
-        await downloadWithRetry(url, localPatchPath, config, onProgress, {});
-        downloadMs = Date.now() - dlStart;
-        const stat = await ReactNativeBlobUtil.fs.stat(localPatchPath);
-        patchSizeBytes = Number(stat.size);
-        log.emit(OtaEvent.DOWNLOAD_SUCCESS, {
-          version: patch.toVersion,
-          durationMs: downloadMs,
-          sizeKB: patchSizeBytes / 1024
-        });
-      } catch (dlError) {
-        log.emit(OtaEvent.DOWNLOAD_FAIL, {
-          error: dlError.message,
-          version: patch.toVersion
-        });
-        throw dlError;
-      }
+      throw new Error(`Native app ${currentAppVer} is too old. Update to ${patch.minAppVersion}+ first.`);
     }
-
-    // ── Step 4: Signature Verification ──
-    // Verify before feeding the patch to native bspatch
-    if (config.publicKey) {
-      onStatus(OtaStatus.APPLYING, 'Verifying signature...');
-      try {
-        await assertSigned(localPatchPath, patch.signature, config, 'Patch');
-      } catch (sigError) {
-        log.emit(OtaEvent.SIGNATURE_INVALID, {
-          version: patch.toVersion
-        });
-        throw sigError;
-      }
+  }
+  if (!(await fs.exists(versionDir))) {
+    await fs.mkdir(versionDir);
+  }
+  const download = async (remoteName, dest) => {
+    log.emit(OtaEvent.DOWNLOAD_START, {
+      version: patch.toVersion
+    });
+    const dlStart = Date.now();
+    try {
+      const url = await getStorage(config).getUpdateFileUrl(remoteName, config);
+      await downloadWithRetry(url, dest, config, onProgress);
+    } catch (dlError) {
+      log.emit(OtaEvent.DOWNLOAD_FAIL, {
+        error: dlError.message,
+        version: patch.toVersion
+      });
+      throw dlError;
     }
-
-    // ── Step 4.2: Download & Sync Assets ──
-    await syncAssets();
-
-    // ── Step 5: Resolve Source Bundle ──
-    onStatus(OtaStatus.APPLYING, 'Preparing source...');
-    const metadata = await loadMetadata(config.baseAppVersion);
-    const oldBundlePath = getBundlePath(metadata.currentVersion, config.baseAppVersion);
-
-    // ── Resolve the actual old bundle path ──────────────────────────────
-    // getBundlePath returns null when currentVersion == baseAppVersion, meaning
-    // "use the APK's baked-in bundle". However, if BASE_APP_VERSION was bumped
-    // to match a version that was applied via OTA (not actually baked into the
-    // installed APK), direct APK extraction would produce a DIFFERENT file than
-    // what the build script recorded as the baseHash for the next patch.
-    //
-    // Strategy (in order of precedence):
-    //   1. Use the explicit OTA bundle path from getBundlePath (version > base) ✓
-    //   2. If null (version == base), check for a previously OTA-stored bundle
-    //      at ota/v{currentVersion}/ — its hash matches the server registry.
-    //   3. Fall back to APK extraction only if no OTA bundle exists on disk.
-    const bundleFilename = Platform.OS === 'android' ? 'index.android.bundle' : 'main.jsbundle';
-    let actualOldPath = '';
-    if (!oldBundlePath) {
-      // currentVersion == baseAppVersion: prefer OTA-stored bundle for this
-      // version over APK extraction (handles BASE_APP_VERSION bump scenarios).
-      const otaStoredPath = `${OTA_DIR}/v${metadata.currentVersion}/${bundleFilename}`;
-      if (await ReactNativeBlobUtil.fs.exists(otaStoredPath)) {
-        if (__DEV__) {
-          console.log(`[otaCore] Source: OTA-stored bundle for V${metadata.currentVersion} (BASE_APP_VERSION match)`);
-        }
-        actualOldPath = otaStoredPath;
-      } else {
-        // True base: extract byte-for-byte from APK assets.
-        // RNFS.copyFileAssets is known to produce inconsistent bytes in some
-        // APK configurations (e.g., release signing + resource shrinking).
-        // Re-extract every time: a cached copy can be partial or left over
-        // from the previous store build. It's one local copy per update.
-        actualOldPath = `${OTA_DIR}/base.hbc`;
-        await NativeBsPatch.extractBundleFromAssets(bundleFilename, actualOldPath);
+    const downloadMs = Date.now() - dlStart;
+    const sizeBytes = Number((await fs.stat(dest)).size);
+    log.emit(OtaEvent.DOWNLOAD_SUCCESS, {
+      version: patch.toVersion,
+      durationMs: downloadMs,
+      sizeKB: sizeBytes / 1024
+    });
+    return {
+      downloadMs,
+      sizeBytes
+    };
+  };
+  const assertHash = async (path, expected, what) => {
+    if (!expected || (await verifyHash(path, expected))) return;
+    const actual = await fs.hash(path, 'sha256').catch(() => '');
+    log.emit(OtaEvent.HASH_MISMATCH, {
+      message: `${what} hash mismatch`,
+      version: patch.toVersion,
+      metadata: {
+        expected,
+        actual,
+        path
       }
-    } else {
-      actualOldPath = oldBundlePath;
-    }
+    });
+    throw new Error(`${what} hash mismatch`);
+  };
 
-    // ── Debug: log file sizes for diagnostic ──
-    try {
-      const oldStat = await ReactNativeBlobUtil.fs.stat(actualOldPath);
-      const patchStat = await ReactNativeBlobUtil.fs.stat(localPatchPath);
-      if (__DEV__) {
-        console.log(`[otaCore] DEBUG old bundle size=${oldStat.size} path=${actualOldPath}`);
-        console.log(`[otaCore] DEBUG patch size=${patchStat.size} path=${localPatchPath}`);
-        console.log(`[otaCore] DEBUG baseHash expected=${patch.baseHash}`);
-      }
-    } catch {
-      // Non-fatal: stat is for diagnostic only
+  /** tempBundle is verified: sync assets, swap it in, record the version, reload. */
+  const commit = async metrics => {
+    if (patch.assetManifestUrl) {
+      const manifestUrl = await getStorage(config).getUpdateFileUrl(patch.assetManifestUrl, config);
+      await downloadAndSyncAssets(manifestUrl, patch.toVersion, config, log, onStatus, onProgress);
     }
+    if (await fs.exists(finalBundlePath)) {
+      await fs.unlink(finalBundlePath);
+    }
+    await fs.mv(tempBundle, finalBundlePath);
 
-    // ── Step 6: Verify Source Integrity ──
-    if (patch.baseHash) {
-      log.emit(OtaEvent.HASH_VERIFY_START, {
-        message: 'Verifying source bundle'
-      });
-      onStatus(OtaStatus.APPLYING, 'Verifying source integrity...');
-      const isValid = await verifyHash(actualOldPath, patch.baseHash);
-      if (!isValid) {
-        // Re-hash only for the diagnostic log (verifyHash doesn't return the actual hash)
-        let actualSourceHash = '';
-        let srcSize = 'unknown';
-        try {
-          actualSourceHash = await ReactNativeBlobUtil.fs.hash(actualOldPath, 'sha256');
-          const srcStat = await ReactNativeBlobUtil.fs.stat(actualOldPath);
-          srcSize = `${srcStat.size} bytes`;
-        } catch {
-          // stat failure is non-fatal for the error message
-        }
-        if (__DEV__) {
-          console.error('[otaCore] SOURCE HASH MISMATCH\n' + `  path:     ${actualOldPath}\n` + `  size:     ${srcSize}\n` + `  expected: ${patch.baseHash}\n` + `  actual:   ${actualSourceHash}\n` + `  patch.id: ${patch.id} (v${patch.fromVersion}→v${patch.toVersion})`);
-        }
-        log.emit(OtaEvent.HASH_MISMATCH, {
-          version: metadata.currentVersion,
-          message: 'Source bundle hash mismatch',
-          metadata: {
-            expected: patch.baseHash,
-            actual: actualSourceHash,
-            path: actualOldPath
-          }
-        });
-        throw new Error('Source bundle hash mismatch. Fallback required.');
-      }
-      log.emit(OtaEvent.HASH_VERIFY_SUCCESS, {
-        message: 'Source bundle verified'
-      });
+    // Native version, not config.appVersion: the native resolver compares against it on boot
+    const nativeAppVersion = await NativeBsPatch.getAppVersion().catch(() => config.appVersion);
+    await updateMetadata(config.baseAppVersion, metadata => registerNewVersion(metadata, patch.toVersion, nativeAppVersion));
+    const totalMs = Date.now() - totalStart;
+    log.emit(OtaEvent.PATCH_SUCCESS, {
+      version: patch.toVersion,
+      durationMs: totalMs,
+      sizeKB: metrics.patchSizeKB
+    });
+    onStatus(OtaStatus.SUCCESS, `Update V${patch.toVersion} Successful!`, {
+      ...metrics,
+      totalMs,
+      fromCache: false
+    });
+
+    // registerNewVersion left lastLaunchSuccessful=true: the native resolver marks the
+    // first launch of the new version pending, and JS marks it healthy once it renders.
+    if (options.autoReload !== false) {
+      NativeBsPatch.reloadBundle();
+    } else if (__DEV__) {
+      console.log(`[otaCore] V${patch.toVersion} prepared in background — applies on next launch.`);
     }
+  };
+  const applyPatchFile = async sourcePath => {
+    onStatus(OtaStatus.DOWNLOADING, `Downloading V${patch.toVersion}...`);
+    const {
+      downloadMs,
+      sizeBytes
+    } = await download(patch.filename, localPatchPath);
 
-    // ── Step 7: Apply Patch ──
-    const versionDir = `${OTA_DIR}/v${patch.toVersion}`;
-    if (!(await ReactNativeBlobUtil.fs.exists(versionDir))) {
-      await ReactNativeBlobUtil.fs.mkdir(versionDir);
+    // Verify before feeding the patch to native bspatch
+    onStatus(OtaStatus.APPLYING, 'Verifying...');
+    try {
+      await assertSigned(localPatchPath, patch.signature, config, 'Patch');
+    } catch (sigError) {
+      log.emit(OtaEvent.SIGNATURE_INVALID, {
+        version: patch.toVersion
+      });
+      throw sigError;
     }
+    await assertHash(sourcePath, patch.baseHash, 'Source bundle');
     log.emit(OtaEvent.PATCH_START, {
       version: patch.toVersion
     });
     onStatus(OtaStatus.APPLYING, 'Applying binary patch...');
     const applyStart = Date.now();
-    const success = await NativeBsPatch.applyPatch(actualOldPath, tempBundle, localPatchPath);
+    const success = await NativeBsPatch.applyPatch(sourcePath, tempBundle, localPatchPath);
     const applyMs = Date.now() - applyStart;
+    await fs.unlink(localPatchPath).catch(() => {});
     if (!success) {
       log.emit(OtaEvent.PATCH_FAIL, {
         message: 'BsPatch returned false',
@@ -555,148 +509,62 @@ const runUpdatePipeline = async (patch, config, onStatus, onProgress, options =
       });
       throw new Error('BsPatch application failed');
     }
-
-    // ── Step 8: Verify Result Integrity ──
-    if (patch.bundleHash) {
-      log.emit(OtaEvent.HASH_VERIFY_START, {
-        message: 'Verifying result bundle'
-      });
-      onStatus(OtaStatus.APPLYING, 'Verifying integrity...');
-      const isValid = await verifyHash(tempBundle, patch.bundleHash);
-      if (!isValid) {
-        console.error('[otaCore] Result bundle hash mismatch | expected:', patch.bundleHash, 'path:', tempBundle);
-        log.emit(OtaEvent.HASH_MISMATCH, {
-          message: 'Result bundle hash mismatch',
-          version: patch.toVersion,
-          metadata: {
-            expected: patch.bundleHash,
-            path: tempBundle
-          }
-        });
-        throw new Error('Result bundle hash mismatch');
-      }
-      log.emit(OtaEvent.HASH_VERIFY_SUCCESS, {
-        message: 'Result bundle verified'
-      });
-    }
+    await assertHash(tempBundle, patch.bundleHash, 'Result bundle');
     await assertSigned(tempBundle, patch.bundleSignature, config, 'Bundle');
-
-    // ── Step 9: Atomic Commit ──
-    if (await ReactNativeBlobUtil.fs.exists(finalBundlePath)) {
-      await ReactNativeBlobUtil.fs.unlink(finalBundlePath);
+    await commit({
+      patchSizeKB: sizeBytes / 1024,
+      downloadMs,
+      applyMs
+    });
+  };
+  const installFullBundle = async () => {
+    if (!patch.fullBundleUrl) {
+      throw new Error(`No full bundle for V${patch.toVersion}`);
     }
-    await ReactNativeBlobUtil.fs.mv(tempBundle, finalBundlePath);
-    await ReactNativeBlobUtil.fs.unlink(localPatchPath).catch(() => {});
-
-    // ── Step 10: Update Metadata ──
-    const newMetadata = registerNewVersion(metadata, patch.toVersion, config.appVersion);
-    await saveMetadata(newMetadata);
-    const totalMs = Date.now() - totalStart;
-    log.emit(OtaEvent.PATCH_SUCCESS, {
-      version: patch.toVersion,
-      durationMs: totalMs,
-      sizeKB: patchSizeBytes / 1024
+    log.emit(OtaEvent.FALLBACK_FULL_BUNDLE, {
+      version: patch.toVersion
     });
-    onStatus(OtaStatus.SUCCESS, `Update V${patch.toVersion} Successful!`, {
-      patchSizeKB: patchSizeBytes / 1024,
+    onStatus(OtaStatus.DOWNLOADING, `Downloading V${patch.toVersion} (full bundle)...`);
+    const {
       downloadMs,
-      applyMs,
-      totalMs,
-      fromCache
+      sizeBytes
+    } = await download(patch.fullBundleUrl, tempBundle);
+    await assertHash(tempBundle, patch.bundleHash, 'Full bundle');
+    await assertSigned(tempBundle, patch.bundleSignature, config, 'Full bundle');
+    await commit({
+      patchSizeKB: sizeBytes / 1024,
+      downloadMs,
+      applyMs: 0
     });
+  };
+  const cleanup = async () => {
+    await fs.unlink(localPatchPath).catch(() => {});
+    await fs.unlink(tempBundle).catch(() => {});
+  };
 
-    // ── Step 11: Reload ──
-    // Mark healthy BEFORE reload — reloadBundle() calls Runtime.exit(0)
-    NativeBsPatch.markAsHealthy();
-    if (options.autoReload !== false) {
+  // Patch only from an OTA bundle we installed ourselves (byte-identical to the build output)
+  const metadata = await loadMetadata(config.baseAppVersion);
+  const sourcePath = getBundlePath(metadata.currentVersion, config.baseAppVersion);
+  const canPatch = !!patch.filename && patch.fromVersion === metadata.currentVersion && !!sourcePath && (await fs.exists(sourcePath));
+  if (canPatch) {
+    try {
+      await applyPatchFile(sourcePath);
+      return;
+    } catch (error) {
+      await cleanup();
       if (__DEV__) {
-        console.log(`[otaCore] V${patch.toVersion} marked healthy — reloading.`);
+        console.warn('[otaCore] Patch failed, falling back to full bundle:', error);
       }
-      NativeBsPatch.reloadBundle();
-    } else {
-      if (__DEV__) {
-        console.log(`[otaCore] V${patch.toVersion} prepared silently in background — will apply on next launch.`);
+      if (!patch.fullBundleUrl) {
+        onStatus(OtaStatus.ERROR, `Error: ${error.message}`);
+        throw error;
       }
     }
+  }
+  try {
+    await installFullBundle();
   } catch (error) {
-    if (__DEV__) {
-      console.error('[otaCore] Pipeline failed:', error);
-    }
-    await ReactNativeBlobUtil.fs.unlink(localPatchPath).catch(() => {});
-    await ReactNativeBlobUtil.fs.unlink(tempBundle).catch(() => {});
-
-    // ── Fallback: Full Bundle Download ──
-    if (patch.fullBundleUrl) {
-      try {
-        onStatus(OtaStatus.DOWNLOADING, 'Fallback: Downloading full bundle...');
-        const storage = getStorage(config);
-        const url = await storage.getUpdateFileUrl(patch.fullBundleUrl || patch.filename, config);
-        const versionDir = `${OTA_DIR}/v${patch.toVersion}`;
-        if (!(await ReactNativeBlobUtil.fs.exists(versionDir))) {
-          await ReactNativeBlobUtil.fs.mkdir(versionDir);
-        }
-        await downloadWithRetry(url, tempBundle, config, onProgress, {});
-
-        // Verify full bundle hash
-        if (patch.bundleHash) {
-          const isValid = await verifyHash(tempBundle, patch.bundleHash);
-          if (!isValid) {
-            let actualHash = '';
-            let size;
-            try {
-              actualHash = await ReactNativeBlobUtil.fs.hash(tempBundle, 'sha256');
-              const stat = await ReactNativeBlobUtil.fs.stat(tempBundle);
-              size = stat.size;
-            } catch {
-              // stat failure is non-fatal
-            }
-            if (__DEV__) {
-              console.error('[otaCore] Full bundle hash mismatch | expected:', patch.bundleHash, 'actual:', actualHash);
-            }
-            log.emit(OtaEvent.HASH_MISMATCH, {
-              message: 'Full bundle hash mismatch',
-              metadata: {
-                expected: patch.bundleHash,
-                actual: actualHash,
-                size
-              }
-            });
-            throw new Error('Full bundle hash mismatch after fallback');
-          }
-        }
-        await assertSigned(tempBundle, patch.bundleSignature, config, 'Full bundle');
-        await syncAssets();
-
-        // Atomic swap
-        if (await ReactNativeBlobUtil.fs.exists(finalBundlePath)) {
-          await ReactNativeBlobUtil.fs.unlink(finalBundlePath);
-        }
-        await ReactNativeBlobUtil.fs.mv(tempBundle, finalBundlePath);
-        const metadata = await loadMetadata(config.baseAppVersion);
-        const newMetadata = registerNewVersion(metadata, patch.toVersion, config.appVersion);
-        await saveMetadata(newMetadata);
-
-        // ── CRITICAL: Mark healthy BEFORE reload so native OtaBundleResolver
-        // does NOT see lastLaunchSuccessful=false on the very next boot and
-        // immediately rollback the version we just successfully downloaded.
-        // (reloadBundle() calls Runtime.exit(0) — JS won't run again before restart)
-        NativeBsPatch.markAsHealthy();
-        if (__DEV__) {
-          console.log(`[otaCore] Fallback V${patch.toVersion} marked healthy — reloading.`);
-        }
-        if (options.autoReload !== false) {
-          onStatus(OtaStatus.SUCCESS, `Fallback successful! Reloading...`);
-          NativeBsPatch.reloadBundle();
-        } else {
-          onStatus(OtaStatus.SUCCESS, `Fallback bundle prepared silently in background.`);
-        }
-        return;
-      } catch (fallbackError) {
-        if (__DEV__) {
-          console.error('[otaCore] Full bundle fallback also failed:', fallbackError);
-        }
-      }
-    }
+    await cleanup();
     onStatus(OtaStatus.ERROR, `Error: ${error.message}`);
     throw error;
   }