@bravemobile/react-native-code-push 13.1.0-beta.3 → 13.1.0-beta.5

package/src/CodePush.js

@@ -189,9 +189,16 @@ async function checkForUpdate(handleBinaryVersionMismatchCallback = null) {
           download_url: latestReleaseInfo.downloadUrl,
           /**
            * Only released updates that were published with a binary patch carry this.
-           * When it is missing, the update is downloaded in full from `download_url`.
+           * A release offering neither this nor a diff is downloaded in full from
+           * `download_url`.
            */
-          binary_patch_download_url: diffPackageDownloadUrl || latestReleaseInfo.binaryPatchDownloadUrl,
+          binary_patch_download_url: latestReleaseInfo.binaryPatchDownloadUrl,
+          /**
+           * The diff stands next to the patch url rather than in its place, so that the
+           * native side can try the diff first and still hold the patch archive to fall
+           * back on when the diff fails on its asset side.
+           */
+          asset_diff_download_url: diffPackageDownloadUrl,
           // (`enabled` will always be true in the release information obtained from the previous process.)
           is_available: latestReleaseInfo.enabled,
           package_hash: latestReleaseInfo.packageHash,
@@ -293,11 +300,14 @@ function mapToRemotePackageMetadata(updateInfo) {
     packageHash: updateInfo.package_hash ?? '',
     packageSize: updateInfo.package_size ?? 0,
     downloadUrl: updateInfo.download_url ?? '',
-    // The field stays out of the package unless the update really has a binary patch,
+    // The fields stay out of the package unless the update really has these archives,
     // so that the native side sees exactly what it saw before patches existed.
     ...(updateInfo.binary_patch_download_url
       ? { binaryPatchDownloadUrl: updateInfo.binary_patch_download_url }
       : {}),
+    ...(updateInfo.asset_diff_download_url
+      ? { assetDiffDownloadUrl: updateInfo.asset_diff_download_url }
+      : {}),
   };
 }
 
@@ -551,20 +561,20 @@ async function syncInternal(options = {}, syncStatusChangeCallback, downloadProg
     updateDialog: null,
     // The callback registered on the decorator is the default for every sync, including a
     // manual one; a callback passed to this call overrides it for this call.
-    onBinaryPatchResult: sharedCodePushOptions.onBinaryPatchResult ?? null,
+    onUpdateArchiveResult: sharedCodePushOptions.onUpdateArchiveResult ?? null,
     ...options,
   };
 
   /*
-   * A callback an app registered to observe how a binary patch went must not be able to
-   * cost it an update, so it is isolated the way the other sync callbacks are: whatever it
-   * throws is logged and the install carries on. An app that registered none leaves the
+   * A callback an app registered to observe how the update archives went must not be able
+   * to cost it an update, so it is isolated the way the other sync callbacks are: whatever
+   * it throws is logged and the install carries on. An app that registered none leaves the
    * download exactly as it was before this option existed.
    */
-  const onBinaryPatchResult = typeof syncOptions.onBinaryPatchResult === "function"
+  const onUpdateArchiveResult = typeof syncOptions.onUpdateArchiveResult === "function"
     ? (label, result) => {
       try {
-        syncOptions.onBinaryPatchResult(label, result);
+        syncOptions.onUpdateArchiveResult(label, result);
       } catch (error) {
         log(`An error has occurred : ${error.stack}`);
       }
@@ -624,7 +634,7 @@ async function syncInternal(options = {}, syncStatusChangeCallback, downloadProg
 
       const localPackage = await remotePackage.download(
         downloadProgressCallback,
-        onBinaryPatchResult && ((result) => onBinaryPatchResult(remotePackageLabel, result)),
+        onUpdateArchiveResult && ((result) => onUpdateArchiveResult(remotePackageLabel, result)),
       );
 
       sharedCodePushOptions.onDownloadSuccess?.(remotePackageLabel);
@@ -760,8 +770,8 @@ let CodePush;
  *   onRolloutSkipped: (label: string, error: Error) => void | undefined,
  *   setOnRolloutSkipped(onRolloutSkippedFunction: (label: string, error: Error) => void | undefined): void,
  *
- *   onBinaryPatchResult: (label: string, result: object) => void | undefined,
- *   setOnBinaryPatchResult(onBinaryPatchResultFunction: (label: string, result: object) => void | undefined): void,
+ *   onUpdateArchiveResult: (label: string, result: object) => void | undefined,
+ *   setOnUpdateArchiveResult(onUpdateArchiveResultFunction: (label: string, result: object) => void | undefined): void,
  * }}
  */
 const sharedCodePushOptions = {
@@ -812,11 +822,11 @@ const sharedCodePushOptions = {
     if (typeof onRolloutSkippedFunction !== 'function') throw new Error('Please pass a function to onRolloutSkipped');
     this.onRolloutSkipped = onRolloutSkippedFunction;
   },
-  onBinaryPatchResult: undefined,
-  setOnBinaryPatchResult(onBinaryPatchResultFunction) {
-    if (!onBinaryPatchResultFunction) return;
-    if (typeof onBinaryPatchResultFunction !== 'function') throw new Error('Please pass a function to onBinaryPatchResult');
-    this.onBinaryPatchResult = onBinaryPatchResultFunction;
+  onUpdateArchiveResult: undefined,
+  setOnUpdateArchiveResult(onUpdateArchiveResultFunction) {
+    if (!onUpdateArchiveResultFunction) return;
+    if (typeof onUpdateArchiveResultFunction !== 'function') throw new Error('Please pass a function to onUpdateArchiveResult');
+    this.onUpdateArchiveResult = onUpdateArchiveResultFunction;
   },
 }
 
@@ -854,7 +864,7 @@ function codePushify(options = {}) {
   sharedCodePushOptions.setOnDownloadSuccess(options.onDownloadSuccess);
   sharedCodePushOptions.setOnSyncError(options.onSyncError);
   sharedCodePushOptions.setOnRolloutSkipped(options.onRolloutSkipped);
-  sharedCodePushOptions.setOnBinaryPatchResult(options.onBinaryPatchResult);
+  sharedCodePushOptions.setOnUpdateArchiveResult(options.onUpdateArchiveResult);
 
   const decorator = (RootComponent) => {
     class CodePushComponent extends React.Component {

package/src/CodePush.test.js

@@ -60,16 +60,16 @@ function diffRelease() {
 }
 
 /**
- * @param binaryPatchResult what the native side reports the patch attempt ended in, which
- *        only a download that had a patch to try comes back with.
+ * @param updateArchiveResult what the native side reports the archive attempts ended in,
+ *        which only a download that had an archive to try comes back with.
  * @param installedPackage the CodePush update the app is running, if any.
  */
-function createNativeBridge({ binaryPatchResult, installedPackage } = {}) {
+function createNativeBridge({ updateArchiveResult, installedPackage } = {}) {
   return {
     addDownloadProgressListener: jest.fn(() => ({ remove: jest.fn() })),
     downloadUpdate: jest.fn(async (updatePackage) => ({
       ...updatePackage,
-      ...(binaryPatchResult ? { binaryPatchResult } : {}),
+      ...(updateArchiveResult ? { updateArchiveResult } : {}),
     })),
     // Without an installed CodePush update, the app runs the bundle of its binary.
     getUpdateMetadata: jest.fn(async () => installedPackage ?? null),
@@ -89,13 +89,13 @@ function createNativeBridge({ binaryPatchResult, installedPackage } = {}) {
  * native bridge live on the module itself - configured the way an app configures it: the
  * decorator registers the app-wide options, and every sync below is one the app asks for.
  *
- * @param onBinaryPatchResult a callback the app registers on the decorator, as opposed to
+ * @param onUpdateArchiveResult a callback the app registers on the decorator, as opposed to
  *        one it passes to a single `sync()` call.
  */
-function loadCodePush({ releaseHistory = {}, updateChecker, binaryPatchResult, onBinaryPatchResult, installedPackage } = {}) {
+function loadCodePush({ releaseHistory = {}, updateChecker, updateArchiveResult, onUpdateArchiveResult, installedPackage } = {}) {
   jest.resetModules();
   const CodePush = require('./CodePush');
-  const nativeBridge = createNativeBridge({ binaryPatchResult, installedPackage });
+  const nativeBridge = createNativeBridge({ updateArchiveResult, installedPackage });
 
   CodePush.setUpTestDependencies(
     null,
@@ -106,7 +106,7 @@ function loadCodePush({ releaseHistory = {}, updateChecker, binaryPatchResult, o
     checkFrequency: CodePush.CheckFrequency.MANUAL,
     releaseHistoryFetcher: async () => releaseHistory,
     updateChecker,
-    onBinaryPatchResult,
+    onUpdateArchiveResult,
   });
 
   return { CodePush, nativeBridge };
@@ -211,11 +211,13 @@ describe('checkForUpdate without a binary patch in the release history', () => {
 });
 
 /**
- * A diff archive only applies to the one release it was computed against, so which of the
- * two patch urls of a release is downloaded depends on what the app is running right now.
+ * A diff archive only applies to the one release it was computed against, so whether the
+ * diff url is handed to the native side at all depends on what the app is running right
+ * now. The patch url is always handed over with it, because the diff falling back to the
+ * patch archive is the native side's decision to make.
  */
 describe('checkForUpdate with asset diff packages in the release history', () => {
-  it('downloads the diff archive when the installed update matches a diff base', async () => {
+  it('carries the diff url next to the patch url when the installed update matches a diff base', async () => {
     const { CodePush, nativeBridge } = loadCodePush({
       releaseHistory: diffRelease(),
       installedPackage: { packageHash: INSTALLED_HASH },
@@ -226,11 +228,12 @@ describe('checkForUpdate with asset diff packages in the release history', () =>
 
     expect(downloadedPackageMetadata(nativeBridge)).toMatchObject({
       downloadUrl: DOWNLOAD_URL,
-      binaryPatchDownloadUrl: DIFF_URL,
+      binaryPatchDownloadUrl: BINARY_PATCH_DOWNLOAD_URL,
+      assetDiffDownloadUrl: DIFF_URL,
     });
   });
 
-  it('downloads the plain patch archive when the installed update matches no diff base', async () => {
+  it('leaves the diff url out when the installed update matches no diff base', async () => {
     const { CodePush, nativeBridge } = loadCodePush({
       releaseHistory: diffRelease(),
       installedPackage: { packageHash: 'other-hash' },
@@ -239,20 +242,20 @@ describe('checkForUpdate with asset diff packages in the release history', () =>
     const remotePackage = await CodePush.checkForUpdate();
     await remotePackage.download();
 
-    expect(downloadedPackageMetadata(nativeBridge)).toMatchObject({
-      binaryPatchDownloadUrl: BINARY_PATCH_DOWNLOAD_URL,
-    });
+    const metadata = downloadedPackageMetadata(nativeBridge);
+    expect(metadata).toMatchObject({ binaryPatchDownloadUrl: BINARY_PATCH_DOWNLOAD_URL });
+    expect(metadata).not.toHaveProperty('assetDiffDownloadUrl');
   });
 
-  it('downloads the plain patch archive when no update is installed', async () => {
+  it('leaves the diff url out when no update is installed', async () => {
     const { CodePush, nativeBridge } = loadCodePush({ releaseHistory: diffRelease() });
 
     const remotePackage = await CodePush.checkForUpdate();
     await remotePackage.download();
 
-    expect(downloadedPackageMetadata(nativeBridge)).toMatchObject({
-      binaryPatchDownloadUrl: BINARY_PATCH_DOWNLOAD_URL,
-    });
+    const metadata = downloadedPackageMetadata(nativeBridge);
+    expect(metadata).toMatchObject({ binaryPatchDownloadUrl: BINARY_PATCH_DOWNLOAD_URL });
+    expect(metadata).not.toHaveProperty('assetDiffDownloadUrl');
   });
 
   it('does not send the diff package map across the bridge', async () => {
@@ -310,13 +313,33 @@ describe('checkForUpdate through the deprecated updateChecker', () => {
 });
 
 /**
- * How a patch attempt went is reported to the app that asked to hear about it, and to
+ * How the archive attempts went is reported to the app that asked to hear about it, and to
  * nobody else: it is not part of the update, and an app that asked for nothing gets the
  * install it always got.
  */
-describe('the binary patch result of a sync', () => {
-  const APPLIED = { status: 'applied', applyDurationMs: 812 };
-  const FELL_BACK = { status: 'fallback', fallbackReason: 'base_hash_mismatch', applyDurationMs: 1503 };
+describe('the update archive result of a sync', () => {
+  const APPLIED = {
+    status: 'applied',
+    archive: 'binary-patch',
+    totalDurationMs: 812,
+    attempts: [{ archive: 'binary-patch', durationMs: 812, applyDurationMs: 64 }],
+  };
+  const FELL_BACK = {
+    status: 'fallback',
+    archive: 'binary-patch',
+    fallbackReason: 'base_hash_mismatch',
+    totalDurationMs: 1503,
+    attempts: [{ archive: 'binary-patch', fallbackReason: 'base_hash_mismatch', durationMs: 1503 }],
+  };
+  const APPLIED_AFTER_DIFF_FELL_BACK = {
+    status: 'applied',
+    archive: 'binary-patch',
+    totalDurationMs: 1503,
+    attempts: [
+      { archive: 'asset-diff', fallbackReason: 'asset_merge_failed', durationMs: 690, applyDurationMs: 41 },
+      { archive: 'binary-patch', durationMs: 813, applyDurationMs: 58 },
+    ],
+  };
 
   /** The metadata the update is installed from, as the native module is given it. */
   function installedPackageMetadata(nativeBridge) {
@@ -327,46 +350,62 @@ describe('the binary patch result of a sync', () => {
   it('tells the app the update was installed from its patch, and how long that took', async () => {
     const { CodePush, nativeBridge } = loadCodePush({
       releaseHistory: patchedRelease(),
-      binaryPatchResult: APPLIED,
+      updateArchiveResult: APPLIED,
     });
-    const onBinaryPatchResult = jest.fn();
+    const onUpdateArchiveResult = jest.fn();
 
-    const syncStatus = await CodePush.sync({ onBinaryPatchResult });
+    const syncStatus = await CodePush.sync({ onUpdateArchiveResult });
 
     expect(syncStatus).toBe(CodePush.SyncStatus.UPDATE_INSTALLED);
-    expect(onBinaryPatchResult).toHaveBeenCalledTimes(1);
-    expect(onBinaryPatchResult).toHaveBeenCalledWith(LABEL, APPLIED);
+    expect(onUpdateArchiveResult).toHaveBeenCalledTimes(1);
+    expect(onUpdateArchiveResult).toHaveBeenCalledWith(LABEL, APPLIED);
     expect(nativeBridge.installUpdate).toHaveBeenCalledTimes(1);
   });
 
   it('tells the app why the update came from the full archive instead', async () => {
     const { CodePush } = loadCodePush({
       releaseHistory: patchedRelease(),
-      binaryPatchResult: FELL_BACK,
+      updateArchiveResult: FELL_BACK,
     });
-    const onBinaryPatchResult = jest.fn();
+    const onUpdateArchiveResult = jest.fn();
 
     // A patch that could not be applied is not a failed update: the full archive installs.
-    const syncStatus = await CodePush.sync({ onBinaryPatchResult });
+    const syncStatus = await CodePush.sync({ onUpdateArchiveResult });
 
     expect(syncStatus).toBe(CodePush.SyncStatus.UPDATE_INSTALLED);
-    expect(onBinaryPatchResult).toHaveBeenCalledWith(LABEL, FELL_BACK);
+    expect(onUpdateArchiveResult).toHaveBeenCalledWith(LABEL, FELL_BACK);
+  });
+
+  it("the app is handed each archive's apply time and the whole path's total", async () => {
+    const { CodePush } = loadCodePush({
+      releaseHistory: diffRelease(),
+      installedPackage: { packageHash: INSTALLED_HASH },
+      updateArchiveResult: APPLIED_AFTER_DIFF_FELL_BACK,
+    });
+    const onUpdateArchiveResult = jest.fn();
+
+    await CodePush.sync({ onUpdateArchiveResult });
+
+    expect(onUpdateArchiveResult).toHaveBeenCalledWith(LABEL, APPLIED_AFTER_DIFF_FELL_BACK);
+    const [, result] = onUpdateArchiveResult.mock.calls[0];
+    expect(result.totalDurationMs).toBe(1503);
+    expect(result.attempts.map((attempt) => attempt.applyDurationMs)).toEqual([41, 58]);
   });
 
   it('tells the app that registered the callback on the decorator, even about a sync it asked for itself', async () => {
-    const onBinaryPatchResult = jest.fn();
+    const onUpdateArchiveResult = jest.fn();
     const { CodePush } = loadCodePush({
       releaseHistory: patchedRelease(),
-      binaryPatchResult: APPLIED,
-      onBinaryPatchResult,
+      updateArchiveResult: APPLIED,
+      onUpdateArchiveResult,
     });
 
     // The decorator checks nothing on its own, so this sync is the app's own call.
     const syncStatus = await CodePush.sync();
 
     expect(syncStatus).toBe(CodePush.SyncStatus.UPDATE_INSTALLED);
-    expect(onBinaryPatchResult).toHaveBeenCalledTimes(1);
-    expect(onBinaryPatchResult).toHaveBeenCalledWith(LABEL, APPLIED);
+    expect(onUpdateArchiveResult).toHaveBeenCalledTimes(1);
+    expect(onUpdateArchiveResult).toHaveBeenCalledWith(LABEL, APPLIED);
   });
 
   it('tells only the callback of the sync call when one was passed to it', async () => {
@@ -374,11 +413,11 @@ describe('the binary patch result of a sync', () => {
     const passedToTheSyncCall = jest.fn();
     const { CodePush } = loadCodePush({
       releaseHistory: patchedRelease(),
-      binaryPatchResult: APPLIED,
-      onBinaryPatchResult: registeredOnTheDecorator,
+      updateArchiveResult: APPLIED,
+      onUpdateArchiveResult: registeredOnTheDecorator,
     });
 
-    const syncStatus = await CodePush.sync({ onBinaryPatchResult: passedToTheSyncCall });
+    const syncStatus = await CodePush.sync({ onUpdateArchiveResult: passedToTheSyncCall });
 
     expect(syncStatus).toBe(CodePush.SyncStatus.UPDATE_INSTALLED);
     expect(passedToTheSyncCall).toHaveBeenCalledTimes(1);
@@ -388,65 +427,81 @@ describe('the binary patch result of a sync', () => {
 
   it('says nothing about a download that had no patch to try', async () => {
     const { CodePush } = loadCodePush({ releaseHistory: fullOnlyRelease() });
-    const onBinaryPatchResult = jest.fn();
+    const onUpdateArchiveResult = jest.fn();
 
-    const syncStatus = await CodePush.sync({ onBinaryPatchResult });
+    const syncStatus = await CodePush.sync({ onUpdateArchiveResult });
 
     expect(syncStatus).toBe(CodePush.SyncStatus.UPDATE_INSTALLED);
-    expect(onBinaryPatchResult).not.toHaveBeenCalled();
+    expect(onUpdateArchiveResult).not.toHaveBeenCalled();
   });
 
   it('installs the update even when the callback throws', async () => {
     const { CodePush, nativeBridge } = loadCodePush({
       releaseHistory: patchedRelease(),
-      binaryPatchResult: APPLIED,
+      updateArchiveResult: APPLIED,
     });
-    const onBinaryPatchResult = jest.fn(() => {
+    const onUpdateArchiveResult = jest.fn(() => {
       throw new Error('the telemetry the app sends the result to is down');
     });
 
-    const syncStatus = await CodePush.sync({ onBinaryPatchResult });
+    const syncStatus = await CodePush.sync({ onUpdateArchiveResult });
 
     expect(syncStatus).toBe(CodePush.SyncStatus.UPDATE_INSTALLED);
-    expect(onBinaryPatchResult).toHaveBeenCalledTimes(1);
+    expect(onUpdateArchiveResult).toHaveBeenCalledTimes(1);
     expect(nativeBridge.installUpdate).toHaveBeenCalledTimes(1);
   });
 
   it('keeps the result out of the package the update is installed from', async () => {
     const { CodePush, nativeBridge } = loadCodePush({
       releaseHistory: patchedRelease(),
-      binaryPatchResult: APPLIED,
+      updateArchiveResult: APPLIED,
     });
 
-    await CodePush.sync({ onBinaryPatchResult: jest.fn() });
+    await CodePush.sync({ onUpdateArchiveResult: jest.fn() });
 
     const installedPackage = installedPackageMetadata(nativeBridge);
     expect(installedPackage).toMatchObject({ label: LABEL, packageHash: PACKAGE_HASH });
-    expect(installedPackage).not.toHaveProperty('binaryPatchResult');
+    expect(installedPackage).not.toHaveProperty('updateArchiveResult');
   });
 
   it('installs the same update, without the result, when no callback is registered', async () => {
     const { CodePush, nativeBridge } = loadCodePush({
       releaseHistory: patchedRelease(),
-      binaryPatchResult: FELL_BACK,
+      updateArchiveResult: FELL_BACK,
     });
 
     const syncStatus = await CodePush.sync();
 
     expect(syncStatus).toBe(CodePush.SyncStatus.UPDATE_INSTALLED);
-    expect(installedPackageMetadata(nativeBridge)).not.toHaveProperty('binaryPatchResult');
+    expect(installedPackageMetadata(nativeBridge)).not.toHaveProperty('updateArchiveResult');
+  });
+
+  it('resolves a direct download even when the callback passed to it throws', async () => {
+    const { CodePush } = loadCodePush({
+      releaseHistory: patchedRelease(),
+      updateArchiveResult: APPLIED,
+    });
+    const onUpdateArchiveResult = jest.fn(() => {
+      throw new Error('the telemetry the app sends the result to is down');
+    });
+
+    const remotePackage = await CodePush.checkForUpdate();
+    const localPackage = await remotePackage.download(undefined, onUpdateArchiveResult);
+
+    expect(onUpdateArchiveResult).toHaveBeenCalledTimes(1);
+    expect(localPackage).toMatchObject({ label: LABEL, packageHash: PACKAGE_HASH });
   });
 
   it('leaves the result off the package a download resolves with', async () => {
     const { CodePush } = loadCodePush({
       releaseHistory: patchedRelease(),
-      binaryPatchResult: APPLIED,
+      updateArchiveResult: APPLIED,
     });
 
     const remotePackage = await CodePush.checkForUpdate();
     const localPackage = await remotePackage.download();
 
     expect(localPackage).toMatchObject({ label: LABEL, packageHash: PACKAGE_HASH });
-    expect(localPackage).not.toHaveProperty('binaryPatchResult');
+    expect(localPackage).not.toHaveProperty('updateArchiveResult');
   });
 });

package/src/package-mixins.js

@@ -1,3 +1,5 @@
+const log = require("./logging");
+
 // This function is used to augment remote and local
 // package objects with additional functionality/properties
 // beyond what is included in the metadata sent by the server.
@@ -6,13 +8,14 @@ module.exports = (NativeCodePush) => {
     return {
       /**
        * @param downloadProgressCallback Called as the archive is received.
-       * @param binaryPatchResultCallback Called with `{ status, fallbackReason?, applyDurationMs }`
-       *        when the update was published with a binary patch, so that the app can observe
-       *        how the patch went. It says nothing about whether the download succeeded - a
-       *        patch that could not be applied is reported here and the update is downloaded
-       *        in full - and it is the only place the result is ever available.
+       * @param updateArchiveResultCallback Called with `{ status, archive, fallbackReason?,
+       *        totalDurationMs, attempts }` when the update was published with a binary patch,
+       *        so that the app can observe how the archives went. It says nothing about whether
+       *        the download succeeded - archives that could not be applied are reported here
+       *        and the update is downloaded in full - and it is the only place the result is
+       *        ever available.
        */
-      async download(downloadProgressCallback, binaryPatchResultCallback) {
+      async download(downloadProgressCallback, updateArchiveResultCallback) {
         if (!this.downloadUrl) {
           throw new Error("Cannot download an update without a download url");
         }
@@ -33,14 +36,20 @@ module.exports = (NativeCodePush) => {
 
           const downloadResult = await NativeCodePush.downloadUpdate(updatePackageCopy, !!downloadProgressCallback);
 
-          // The patch result describes the download that just happened, not the update it
+          // The archive result describes the download that just happened, not the update it
           // delivered, and the package is handed around as the update's metadata from here
           // on - it is even written back to the native side on install. So the result is
           // taken off the package and reported on its own, leaving the package exactly what
           // the native side saved.
-          const { binaryPatchResult, ...downloadedPackage } = downloadResult ?? {};
-          if (binaryPatchResult) {
-            binaryPatchResultCallback?.(binaryPatchResult);
+          const { updateArchiveResult, ...downloadedPackage } = downloadResult ?? {};
+          if (updateArchiveResult && updateArchiveResultCallback) {
+            // The result is an observation, so an observer that throws must not turn a
+            // downloaded update into a failed one.
+            try {
+              updateArchiveResultCallback(updateArchiveResult);
+            } catch (error) {
+              log(`The update archive result callback threw: ${error?.message ?? error}`);
+            }
           }
 
           return { ...downloadedPackage, ...local };