expo-updates 0.24.9 → 0.24.10

package/CHANGELOG.md

@@ -10,6 +10,16 @@
 
 ### 💡 Others
 
+## 0.24.10 — 2024-02-06
+
+### 🎉 New features
+
+- Add assets:verify command to CLI. ([#26756](https://github.com/expo/expo/pull/26756) by [@douglowder](https://github.com/douglowder))
+
+### 🐛 Bug fixes
+
+- Fix assets:verify command for images with multiple scales. ([#26940](https://github.com/expo/expo/pull/26940) by [@douglowder](https://github.com/douglowder))
+
 ## 0.24.9 — 2024-01-26
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -4,7 +4,7 @@ apply plugin: 'kotlin-kapt'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '0.24.9'
+version = '0.24.10'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 if (expoModulesCorePlugin.exists()) {
@@ -122,7 +122,7 @@ android {
   namespace "expo.modules.updates"
   defaultConfig {
     versionCode 31
-    versionName '0.24.9'
+    versionName '0.24.10'
     consumerProguardFiles("proguard-rules.pro")
     testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 

package/build-cli/assetsVerify.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { Command } from './cli';
+export declare const expoAssetsVerify: Command;

package/build-cli/assetsVerify.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expoAssetsVerify = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const assetsVerifyAsync_1 = require("./assetsVerifyAsync");
+const assetsVerifyTypes_1 = require("./assetsVerifyTypes");
+const args_1 = require("./utils/args");
+const Log = tslib_1.__importStar(require("./utils/log"));
+const debug = require('debug')('expo-updates:assets:verify');
+const expoAssetsVerify = async (argv) => {
+    const args = (0, args_1.assertArgs)({
+        // Types
+        '--asset-map-path': String,
+        '--exported-manifest-path': String,
+        '--build-manifest-path': String,
+        '--platform': String,
+        '--help': Boolean,
+        // Aliases
+        '-a': '--asset-map-path',
+        '-e': '--exported-manifest-path',
+        '-b': '--build-manifest-path',
+        '-p': '--platform',
+        '-h': '--help',
+    }, argv !== null && argv !== void 0 ? argv : []);
+    if (args['--help']) {
+        Log.exit((0, chalk_1.default) `
+{bold Description}
+Verify that all static files in an exported bundle are in either the export or an embedded bundle
+
+{bold Usage}
+  {dim $} npx expo-updates assets:verify {dim <dir>}
+
+  Options
+  <dir>                                  Directory of the Expo project. Default: Current working directory
+  -a, --asset-map-path <path>            Path to the \`assetmap.json\` in an export produced by the command \`npx expo export --dump-assetmap\`
+  -e, --exported-manifest-path <path>    Path to the \`metadata.json\` in an export produced by the command \`npx expo export --dump-assetmap\`
+  -b, --build-manifest-path <path>       Path to the \`app.manifest\` file created by expo-updates in an Expo application build (either ios or android)
+  -p, --platform <platform>              Options: ${JSON.stringify(assetsVerifyTypes_1.validPlatforms)}
+  -h, --help                             Usage info
+  `, 0);
+    }
+    return (async () => {
+        const projectRoot = (0, args_1.getProjectRoot)(args);
+        const validatedArgs = resolveOptions(projectRoot, args);
+        debug(`Validated params: ${JSON.stringify(validatedArgs, null, 2)}`);
+        const { buildManifestPath, exportedManifestPath, assetMapPath, platform } = validatedArgs;
+        const missingAssets = await (0, assetsVerifyAsync_1.getMissingAssetsAsync)(buildManifestPath, exportedManifestPath, assetMapPath, platform);
+        if (missingAssets.length > 0) {
+            throw new Error(`${missingAssets.length} assets not found in either embedded manifest or in exported bundle:${JSON.stringify(missingAssets, null, 2)}`);
+        }
+        else {
+            Log.log(`All resolved assets found in either embedded manifest or in exported bundle.`);
+        }
+        process.exit(0);
+    })().catch((e) => {
+        Log.log(`${e}`);
+        process.exit(1);
+    });
+};
+exports.expoAssetsVerify = expoAssetsVerify;
+function resolveOptions(projectRoot, args) {
+    const exportedManifestPath = validatedPathFromArgument(projectRoot, args, '--exported-manifest-path');
+    const buildManifestPath = validatedPathFromArgument(projectRoot, args, '--build-manifest-path');
+    const assetMapPath = validatedPathFromArgument(projectRoot, args, '--asset-map-path');
+    const platform = args['--platform'];
+    if (!(0, assetsVerifyTypes_1.isValidPlatform)(platform)) {
+        throw new Error(`Platform must be one of ${JSON.stringify(assetsVerifyTypes_1.validPlatforms)}`);
+    }
+    return {
+        exportedManifestPath,
+        buildManifestPath,
+        assetMapPath,
+        platform,
+    };
+}
+function validatedPathFromArgument(projectRoot, args, key) {
+    const maybeRelativePath = args[key];
+    if (!maybeRelativePath) {
+        throw new Error(`No value for ${key}`);
+    }
+    if (maybeRelativePath.indexOf('/') === 0) {
+        return maybeRelativePath; // absolute path
+    }
+    return path_1.default.resolve(projectRoot, maybeRelativePath);
+}

package/build-cli/assetsVerifyAsync.d.ts

@@ -0,0 +1,59 @@
+import { BuildManifest, ExportedMetadata, FullAssetDump, FullAssetDumpEntry, MissingAsset, Platform } from './assetsVerifyTypes';
+/**
+ * Finds any assets that will be missing from an app given a build and an exported update bundle.
+ *
+ * @param buildManifestPath Path to the `app.manifest` file created by expo-updates in an Expo application build (either ios or android)
+ * @param exportMetadataPath Path to the `metadata.json` in an export produced by the command `npx expo export --dump-assetmap`
+ * @param assetMapPath Path to the `assetmap.json` in an export produced by the command `npx expo export --dump-assetmap`
+ * @param projectRoot The project root path
+ * @returns An array containing any assets that are found in the Metro asset dump, but not included in either app.manifest or the exported bundle
+ */
+export declare function getMissingAssetsAsync(buildManifestPath: string, exportMetadataPath: string, assetMapPath: string, platform: Platform): Promise<MissingAsset[]>;
+/**
+ * Reads and returns the embedded manifest (app.manifest) for a build.
+ *
+ * @param buildManifestPath Path to the build folder
+ * @param platform Either 'android' or 'ios'
+ * @param projectRoot The project root path
+ * @returns the JSON structure of the manifest
+ */
+export declare function getBuildManifestAsync(buildManifestPath: string): Promise<BuildManifest>;
+/**
+ * Extracts the set of asset hashes from a build manifest.
+ *
+ * @param buildManifest The build manifest
+ * @returns The set of asset hashes contained in the build manifest
+ */
+export declare function getBuildManifestHashSet(buildManifest: BuildManifest): Set<string>;
+/**
+ * Reads and extracts the asset dump for an exported bundle.
+ *
+ * @param assetMapPath The path to the exported assetmap.json.
+ * @returns The asset dump as an object.
+ */
+export declare function getFullAssetDumpAsync(assetMapPath: string): Promise<FullAssetDump>;
+/**
+ * Extracts the set of asset hashes from an asset dump.
+ *
+ * @param assetDump
+ * @returns The set of asset hashes in the asset dump, and a map of hash to asset
+ */
+export declare function getFullAssetDumpHashSet(assetDump: FullAssetDump): {
+    fullAssetHashSet: Set<string>;
+    fullAssetHashMap: Map<string, FullAssetDumpEntry>;
+};
+/**
+ * Reads and extracts the metadata.json from an exported bundle.
+ *
+ * @param exportedMetadataPath Path to the exported metadata.json.
+ * @returns The metadata of the bundle.
+ */
+export declare function getExportedMetadataAsync(exportedMetadataPath: string): Promise<ExportedMetadata>;
+/**
+ * Extracts the set of asset hashes from an exported bundle's metadata for a given platform.
+ *
+ * @param metadata The metadata from the exported bundle
+ * @param platform Either 'android' or 'ios'
+ * @returns the set of asset hashes
+ */
+export declare function getExportedMetadataHashSet(metadata: ExportedMetadata, platform: Platform): Set<string>;

package/build-cli/assetsVerifyAsync.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExportedMetadataHashSet = exports.getExportedMetadataAsync = exports.getFullAssetDumpHashSet = exports.getFullAssetDumpAsync = exports.getBuildManifestHashSet = exports.getBuildManifestAsync = exports.getMissingAssetsAsync = void 0;
+const fs_1 = require("fs");
+const debug = require('debug')('expo-updates:assets:verify');
+/**
+ * Finds any assets that will be missing from an app given a build and an exported update bundle.
+ *
+ * @param buildManifestPath Path to the `app.manifest` file created by expo-updates in an Expo application build (either ios or android)
+ * @param exportMetadataPath Path to the `metadata.json` in an export produced by the command `npx expo export --dump-assetmap`
+ * @param assetMapPath Path to the `assetmap.json` in an export produced by the command `npx expo export --dump-assetmap`
+ * @param projectRoot The project root path
+ * @returns An array containing any assets that are found in the Metro asset dump, but not included in either app.manifest or the exported bundle
+ */
+async function getMissingAssetsAsync(buildManifestPath, exportMetadataPath, assetMapPath, platform) {
+    const buildManifestHashSet = getBuildManifestHashSet(await getBuildManifestAsync(buildManifestPath));
+    const fullAssetDump = await getFullAssetDumpAsync(assetMapPath);
+    const { fullAssetHashSet, fullAssetHashMap } = getFullAssetDumpHashSet(fullAssetDump);
+    const exportedAssetSet = getExportedMetadataHashSet(await getExportedMetadataAsync(exportMetadataPath), platform);
+    debug(`Assets in build: ${JSON.stringify([...buildManifestHashSet], null, 2)}`);
+    debug(`Assets in exported bundle: ${JSON.stringify([...exportedAssetSet], null, 2)}`);
+    debug(`All assets resolved by Metro: ${JSON.stringify([...fullAssetHashSet], null, 2)}`);
+    const buildAssetsPlusExportedAssets = new Set(buildManifestHashSet);
+    exportedAssetSet.forEach((hash) => buildAssetsPlusExportedAssets.add(hash));
+    const missingAssets = [];
+    fullAssetHashSet.forEach((hash) => {
+        if (!buildAssetsPlusExportedAssets.has(hash)) {
+            const asset = fullAssetHashMap.get(hash);
+            asset === null || asset === void 0 ? void 0 : asset.fileHashes.forEach((fileHash, index) => {
+                if ((asset === null || asset === void 0 ? void 0 : asset.fileHashes[index]) === hash) {
+                    missingAssets.push({
+                        hash,
+                        path: asset === null || asset === void 0 ? void 0 : asset.files[index],
+                    });
+                }
+            });
+        }
+    });
+    return missingAssets;
+}
+exports.getMissingAssetsAsync = getMissingAssetsAsync;
+/**
+ * Reads and returns the embedded manifest (app.manifest) for a build.
+ *
+ * @param buildManifestPath Path to the build folder
+ * @param platform Either 'android' or 'ios'
+ * @param projectRoot The project root path
+ * @returns the JSON structure of the manifest
+ */
+async function getBuildManifestAsync(buildManifestPath) {
+    const buildManifestString = await fs_1.promises.readFile(buildManifestPath, { encoding: 'utf-8' });
+    const buildManifest = JSON.parse(buildManifestString);
+    return buildManifest;
+}
+exports.getBuildManifestAsync = getBuildManifestAsync;
+/**
+ * Extracts the set of asset hashes from a build manifest.
+ *
+ * @param buildManifest The build manifest
+ * @returns The set of asset hashes contained in the build manifest
+ */
+function getBuildManifestHashSet(buildManifest) {
+    var _a;
+    return new Set(((_a = buildManifest.assets) !== null && _a !== void 0 ? _a : []).map((asset) => asset.packagerHash));
+}
+exports.getBuildManifestHashSet = getBuildManifestHashSet;
+/**
+ * Reads and extracts the asset dump for an exported bundle.
+ *
+ * @param assetMapPath The path to the exported assetmap.json.
+ * @returns The asset dump as an object.
+ */
+async function getFullAssetDumpAsync(assetMapPath) {
+    const assetMapString = await fs_1.promises.readFile(assetMapPath, { encoding: 'utf-8' });
+    const assetMap = new Map(Object.entries(JSON.parse(assetMapString)));
+    return assetMap;
+}
+exports.getFullAssetDumpAsync = getFullAssetDumpAsync;
+/**
+ * Extracts the set of asset hashes from an asset dump.
+ *
+ * @param assetDump
+ * @returns The set of asset hashes in the asset dump, and a map of hash to asset
+ */
+function getFullAssetDumpHashSet(assetDump) {
+    const fullAssetHashSet = new Set();
+    const fullAssetHashMap = new Map();
+    assetDump.forEach((asset) => asset.fileHashes.forEach((hash) => {
+        fullAssetHashSet.add(hash);
+        fullAssetHashMap.set(hash, asset);
+    }));
+    return {
+        fullAssetHashSet,
+        fullAssetHashMap,
+    };
+}
+exports.getFullAssetDumpHashSet = getFullAssetDumpHashSet;
+/**
+ * Reads and extracts the metadata.json from an exported bundle.
+ *
+ * @param exportedMetadataPath Path to the exported metadata.json.
+ * @returns The metadata of the bundle.
+ */
+async function getExportedMetadataAsync(exportedMetadataPath) {
+    const metadataString = await fs_1.promises.readFile(exportedMetadataPath, { encoding: 'utf-8' });
+    const metadata = JSON.parse(metadataString);
+    return metadata;
+}
+exports.getExportedMetadataAsync = getExportedMetadataAsync;
+/**
+ * Extracts the set of asset hashes from an exported bundle's metadata for a given platform.
+ *
+ * @param metadata The metadata from the exported bundle
+ * @param platform Either 'android' or 'ios'
+ * @returns the set of asset hashes
+ */
+function getExportedMetadataHashSet(metadata, platform) {
+    var _a;
+    const fileMetadata = platform === 'android' ? metadata.fileMetadata.android : metadata.fileMetadata.ios;
+    if (!fileMetadata) {
+        throw new Error(`Exported bundle was not exported for platform ${platform}`);
+    }
+    const assets = (_a = fileMetadata === null || fileMetadata === void 0 ? void 0 : fileMetadata.assets) !== null && _a !== void 0 ? _a : [];
+    // Asset paths in the export metadata are of the form 'assets/<hash string>'
+    return new Set(assets.map((asset) => asset.path.substring(7, asset.path.length)));
+}
+exports.getExportedMetadataHashSet = getExportedMetadataHashSet;

package/build-cli/assetsVerifyTypes.d.ts

@@ -0,0 +1,45 @@
+export declare const validPlatforms: string[];
+export type Platform = (typeof validPlatforms)[number];
+export declare const isValidPlatform: (p: any) => boolean;
+export interface ValidatedOptions {
+    exportedManifestPath: string;
+    buildManifestPath: string;
+    assetMapPath: string;
+    platform: Platform;
+}
+export type FullAssetDumpEntry = {
+    files: string[];
+    hash: string;
+    name: string;
+    type: string;
+    fileHashes: string[];
+};
+export type FullAssetDump = Map<string, FullAssetDumpEntry>;
+export type BuildManifestAsset = {
+    name: string;
+    type: string;
+    packagerHash: string;
+};
+export type BuildManifest = {
+    assets: BuildManifestAsset[];
+} & {
+    [key: string]: any;
+};
+export type ExportedMetadataAsset = {
+    path: string;
+    ext: string;
+};
+export type FileMetadata = {
+    bundle: string;
+    assets: ExportedMetadataAsset[];
+};
+export type ExportedMetadata = {
+    fileMetadata: {
+        ios?: FileMetadata;
+        android?: FileMetadata;
+    };
+};
+export type MissingAsset = {
+    hash: string;
+    path: string;
+};

package/build-cli/assetsVerifyTypes.js

@@ -0,0 +1,7 @@
+"use strict";
+// Types for the options passed into the command
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidPlatform = exports.validPlatforms = void 0;
+exports.validPlatforms = ['android', 'ios'];
+const isValidPlatform = (p) => exports.validPlatforms.includes(p);
+exports.isValidPlatform = isValidPlatform;

package/build-cli/cli.js

@@ -4,11 +4,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const arg_1 = tslib_1.__importDefault(require("arg"));
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const getenv_1 = require("getenv");
 const Log = tslib_1.__importStar(require("./utils/log"));
+// Setup before requiring `debug`.
+if ((0, getenv_1.boolish)('EXPO_DEBUG', false)) {
+    debug_1.default.enable('expo-updates:*');
+}
+else if (debug_1.default.enabled('expo-updates:')) {
+    process.env.EXPO_DEBUG = '1';
+}
 const commands = {
     // Add a new command here
     'codesigning:generate': () => import('./generateCodeSigning.js').then((i) => i.generateCodeSigning),
     'codesigning:configure': () => import('./configureCodeSigning.js').then((i) => i.configureCodeSigning),
+    'assets:verify': () => import('./assetsVerify.js').then((i) => i.expoAssetsVerify),
 };
 const args = (0, arg_1.default)({
     // Types

package/cli/assetsVerify.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import arg from 'arg';
+import chalk from 'chalk';
+import path from 'path';
+
+import { getMissingAssetsAsync } from './assetsVerifyAsync';
+import {
+  isValidPlatform,
+  validPlatforms,
+  type ValidatedOptions,
+  type Platform,
+} from './assetsVerifyTypes';
+import { Command } from './cli';
+import { assertArgs, getProjectRoot } from './utils/args';
+import * as Log from './utils/log';
+
+const debug = require('debug')('expo-updates:assets:verify') as typeof console.log;
+
+export const expoAssetsVerify: Command = async (argv) => {
+  const args = assertArgs(
+    {
+      // Types
+      '--asset-map-path': String,
+      '--exported-manifest-path': String,
+      '--build-manifest-path': String,
+      '--platform': String,
+      '--help': Boolean,
+      // Aliases
+      '-a': '--asset-map-path',
+      '-e': '--exported-manifest-path',
+      '-b': '--build-manifest-path',
+      '-p': '--platform',
+      '-h': '--help',
+    },
+    argv ?? []
+  );
+
+  if (args['--help']) {
+    Log.exit(
+      chalk`
+{bold Description}
+Verify that all static files in an exported bundle are in either the export or an embedded bundle
+
+{bold Usage}
+  {dim $} npx expo-updates assets:verify {dim <dir>}
+
+  Options
+  <dir>                                  Directory of the Expo project. Default: Current working directory
+  -a, --asset-map-path <path>            Path to the \`assetmap.json\` in an export produced by the command \`npx expo export --dump-assetmap\`
+  -e, --exported-manifest-path <path>    Path to the \`metadata.json\` in an export produced by the command \`npx expo export --dump-assetmap\`
+  -b, --build-manifest-path <path>       Path to the \`app.manifest\` file created by expo-updates in an Expo application build (either ios or android)
+  -p, --platform <platform>              Options: ${JSON.stringify(validPlatforms)}
+  -h, --help                             Usage info
+  `,
+      0
+    );
+  }
+
+  return (async () => {
+    const projectRoot = getProjectRoot(args);
+
+    const validatedArgs = resolveOptions(projectRoot, args);
+    debug(`Validated params: ${JSON.stringify(validatedArgs, null, 2)}`);
+
+    const { buildManifestPath, exportedManifestPath, assetMapPath, platform } = validatedArgs;
+
+    const missingAssets = await getMissingAssetsAsync(
+      buildManifestPath,
+      exportedManifestPath,
+      assetMapPath,
+      platform
+    );
+
+    if (missingAssets.length > 0) {
+      throw new Error(
+        `${
+          missingAssets.length
+        } assets not found in either embedded manifest or in exported bundle:${JSON.stringify(
+          missingAssets,
+          null,
+          2
+        )}`
+      );
+    } else {
+      Log.log(`All resolved assets found in either embedded manifest or in exported bundle.`);
+    }
+    process.exit(0);
+  })().catch((e) => {
+    Log.log(`${e}`);
+    process.exit(1);
+  });
+};
+
+function resolveOptions(projectRoot: string, args: arg.Result<arg.Spec>): ValidatedOptions {
+  const exportedManifestPath = validatedPathFromArgument(
+    projectRoot,
+    args,
+    '--exported-manifest-path'
+  );
+  const buildManifestPath = validatedPathFromArgument(projectRoot, args, '--build-manifest-path');
+  const assetMapPath = validatedPathFromArgument(projectRoot, args, '--asset-map-path');
+
+  const platform = args['--platform'] as unknown as Platform;
+  if (!isValidPlatform(platform)) {
+    throw new Error(`Platform must be one of ${JSON.stringify(validPlatforms)}`);
+  }
+
+  return {
+    exportedManifestPath,
+    buildManifestPath,
+    assetMapPath,
+    platform,
+  };
+}
+
+function validatedPathFromArgument(projectRoot: string, args: arg.Result<arg.Spec>, key: string) {
+  const maybeRelativePath = args[key] as unknown as string;
+  if (!maybeRelativePath) {
+    throw new Error(`No value for ${key}`);
+  }
+  if (maybeRelativePath.indexOf('/') === 0) {
+    return maybeRelativePath; // absolute path
+  }
+  return path.resolve(projectRoot, maybeRelativePath);
+}

package/cli/assetsVerifyAsync.ts

@@ -0,0 +1,153 @@
+import { promises as fs } from 'fs';
+
+import {
+  BuildManifest,
+  ExportedMetadata,
+  ExportedMetadataAsset,
+  FullAssetDump,
+  FullAssetDumpEntry,
+  MissingAsset,
+  Platform,
+} from './assetsVerifyTypes';
+
+const debug = require('debug')('expo-updates:assets:verify') as typeof console.log;
+
+/**
+ * Finds any assets that will be missing from an app given a build and an exported update bundle.
+ *
+ * @param buildManifestPath Path to the `app.manifest` file created by expo-updates in an Expo application build (either ios or android)
+ * @param exportMetadataPath Path to the `metadata.json` in an export produced by the command `npx expo export --dump-assetmap`
+ * @param assetMapPath Path to the `assetmap.json` in an export produced by the command `npx expo export --dump-assetmap`
+ * @param projectRoot The project root path
+ * @returns An array containing any assets that are found in the Metro asset dump, but not included in either app.manifest or the exported bundle
+ */
+export async function getMissingAssetsAsync(
+  buildManifestPath: string,
+  exportMetadataPath: string,
+  assetMapPath: string,
+  platform: Platform
+) {
+  const buildManifestHashSet = getBuildManifestHashSet(
+    await getBuildManifestAsync(buildManifestPath)
+  );
+
+  const fullAssetDump = await getFullAssetDumpAsync(assetMapPath);
+  const { fullAssetHashSet, fullAssetHashMap } = getFullAssetDumpHashSet(fullAssetDump);
+
+  const exportedAssetSet = getExportedMetadataHashSet(
+    await getExportedMetadataAsync(exportMetadataPath),
+    platform
+  );
+
+  debug(`Assets in build: ${JSON.stringify([...buildManifestHashSet], null, 2)}`);
+  debug(`Assets in exported bundle: ${JSON.stringify([...exportedAssetSet], null, 2)}`);
+  debug(`All assets resolved by Metro: ${JSON.stringify([...fullAssetHashSet], null, 2)}`);
+
+  const buildAssetsPlusExportedAssets = new Set(buildManifestHashSet);
+  exportedAssetSet.forEach((hash) => buildAssetsPlusExportedAssets.add(hash));
+
+  const missingAssets: MissingAsset[] = [];
+
+  fullAssetHashSet.forEach((hash) => {
+    if (!buildAssetsPlusExportedAssets.has(hash)) {
+      const asset = fullAssetHashMap.get(hash);
+      asset?.fileHashes.forEach((fileHash, index) => {
+        if (asset?.fileHashes[index] === hash) {
+          missingAssets.push({
+            hash,
+            path: asset?.files[index],
+          });
+        }
+      });
+    }
+  });
+
+  return missingAssets;
+}
+
+/**
+ * Reads and returns the embedded manifest (app.manifest) for a build.
+ *
+ * @param buildManifestPath Path to the build folder
+ * @param platform Either 'android' or 'ios'
+ * @param projectRoot The project root path
+ * @returns the JSON structure of the manifest
+ */
+export async function getBuildManifestAsync(buildManifestPath: string) {
+  const buildManifestString = await fs.readFile(buildManifestPath, { encoding: 'utf-8' });
+  const buildManifest: BuildManifest = JSON.parse(buildManifestString);
+  return buildManifest;
+}
+
+/**
+ * Extracts the set of asset hashes from a build manifest.
+ *
+ * @param buildManifest The build manifest
+ * @returns The set of asset hashes contained in the build manifest
+ */
+export function getBuildManifestHashSet(buildManifest: BuildManifest) {
+  return new Set((buildManifest.assets ?? []).map((asset) => asset.packagerHash));
+}
+
+/**
+ * Reads and extracts the asset dump for an exported bundle.
+ *
+ * @param assetMapPath The path to the exported assetmap.json.
+ * @returns The asset dump as an object.
+ */
+export async function getFullAssetDumpAsync(assetMapPath: string) {
+  const assetMapString = await fs.readFile(assetMapPath, { encoding: 'utf-8' });
+  const assetMap: FullAssetDump = new Map(Object.entries(JSON.parse(assetMapString)));
+  return assetMap;
+}
+
+/**
+ * Extracts the set of asset hashes from an asset dump.
+ *
+ * @param assetDump
+ * @returns The set of asset hashes in the asset dump, and a map of hash to asset
+ */
+export function getFullAssetDumpHashSet(assetDump: FullAssetDump) {
+  const fullAssetHashSet = new Set<string>();
+  const fullAssetHashMap = new Map<string, FullAssetDumpEntry>();
+  assetDump.forEach((asset) =>
+    asset.fileHashes.forEach((hash) => {
+      fullAssetHashSet.add(hash);
+      fullAssetHashMap.set(hash, asset);
+    })
+  );
+  return {
+    fullAssetHashSet,
+    fullAssetHashMap,
+  };
+}
+
+/**
+ * Reads and extracts the metadata.json from an exported bundle.
+ *
+ * @param exportedMetadataPath Path to the exported metadata.json.
+ * @returns The metadata of the bundle.
+ */
+export async function getExportedMetadataAsync(exportedMetadataPath: string) {
+  const metadataString = await fs.readFile(exportedMetadataPath, { encoding: 'utf-8' });
+  const metadata: ExportedMetadata = JSON.parse(metadataString);
+  return metadata;
+}
+
+/**
+ * Extracts the set of asset hashes from an exported bundle's metadata for a given platform.
+ *
+ * @param metadata The metadata from the exported bundle
+ * @param platform Either 'android' or 'ios'
+ * @returns the set of asset hashes
+ */
+export function getExportedMetadataHashSet(metadata: ExportedMetadata, platform: Platform) {
+  const fileMetadata =
+    platform === 'android' ? metadata.fileMetadata.android : metadata.fileMetadata.ios;
+  if (!fileMetadata) {
+    throw new Error(`Exported bundle was not exported for platform ${platform}`);
+  }
+  const assets: ExportedMetadataAsset[] = fileMetadata?.assets ?? [];
+  // Asset paths in the export metadata are of the form 'assets/<hash string>'
+  return new Set(assets.map((asset) => asset.path.substring(7, asset.path.length)));
+}

package/cli/assetsVerifyTypes.ts

@@ -0,0 +1,64 @@
+// Types for the options passed into the command
+
+export const validPlatforms = ['android', 'ios'];
+
+export type Platform = (typeof validPlatforms)[number];
+
+export const isValidPlatform = (p: any) => validPlatforms.includes(p);
+
+export interface ValidatedOptions {
+  exportedManifestPath: string;
+  buildManifestPath: string;
+  assetMapPath: string;
+  platform: Platform;
+}
+
+// Types for the full asset map (npx expo export --dump-assets)
+
+export type FullAssetDumpEntry = {
+  files: string[];
+  hash: string;
+  name: string;
+  type: string;
+  fileHashes: string[];
+};
+
+export type FullAssetDump = Map<string, FullAssetDumpEntry>;
+
+// Types for the embedded manifest created by expo-updates
+
+export type BuildManifestAsset = {
+  name: string;
+  type: string;
+  packagerHash: string;
+};
+
+export type BuildManifest = {
+  assets: BuildManifestAsset[];
+} & { [key: string]: any };
+
+// Types for the metadata exported by npx expo export
+
+export type ExportedMetadataAsset = {
+  path: string;
+  ext: string;
+};
+
+export type FileMetadata = {
+  bundle: string;
+  assets: ExportedMetadataAsset[];
+};
+
+export type ExportedMetadata = {
+  fileMetadata: {
+    ios?: FileMetadata;
+    android?: FileMetadata;
+  };
+};
+
+// Type for the missing asset array returned by getMissingAssetsAsync
+
+export type MissingAsset = {
+  hash: string;
+  path: string;
+};

package/cli/cli.ts

@@ -1,9 +1,18 @@
 #!/usr/bin/env node
 import arg from 'arg';
 import chalk from 'chalk';
+import Debug from 'debug';
+import { boolish } from 'getenv';
 
 import * as Log from './utils/log';
 
+// Setup before requiring `debug`.
+if (boolish('EXPO_DEBUG', false)) {
+  Debug.enable('expo-updates:*');
+} else if (Debug.enabled('expo-updates:')) {
+  process.env.EXPO_DEBUG = '1';
+}
+
 export type Command = (argv?: string[]) => void;
 
 const commands: { [command: string]: () => Promise<Command> } = {
@@ -12,6 +21,7 @@ const commands: { [command: string]: () => Promise<Command> } = {
     import('./generateCodeSigning.js').then((i) => i.generateCodeSigning),
   'codesigning:configure': () =>
     import('./configureCodeSigning.js').then((i) => i.configureCodeSigning),
+  'assets:verify': () => import('./assetsVerify.js').then((i) => i.expoAssetsVerify),
 };
 
 const args = arg(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-updates",
-  "version": "0.24.9",
+  "version": "0.24.10",
   "description": "Fetches and manages remotely-hosted assets and updates to your app's JS bundle.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -58,11 +58,12 @@
     "expo-module-scripts": "^3.0.0",
     "express": "^4.17.2",
     "form-data": "^4.0.0",
+    "fs-extra": "~8.1.0",
     "memfs": "^3.2.0",
     "xstate": "^4.37.2"
   },
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "82b69cba5b2e967806ca03413c3277f1d53bff8d"
+  "gitHead": "c4956bb901ddaffc2ad04ed22fd85aa36b8f3435"
 }