expo-updates 0.25.24 → 0.25.25

package/CHANGELOG.md

@@ -10,6 +10,12 @@
 
 ### 💡 Others
 
+## 0.25.25 — 2024-09-20
+
+### 🐛 Bug fixes
+
+- [ios] Store strong references to long-lived objects created in procedures ([#31599](https://github.com/expo/expo/pull/31599) by [@wschurman](https://github.com/wschurman))
+
 ## 0.25.24 — 2024-08-23
 
 _This version does not introduce any user-facing changes._

package/android/build.gradle

@@ -2,7 +2,7 @@ apply plugin: 'com.android.library'
 apply plugin: 'kotlin-kapt'
 
 group = 'host.exp.exponent'
-version = '0.25.24'
+version = '0.25.25'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 apply from: expoModulesCorePlugin
@@ -49,7 +49,7 @@ android {
   namespace "expo.modules.updates"
   defaultConfig {
     versionCode 31
-    versionName '0.25.24'
+    versionName '0.25.25'
     consumerProguardFiles(rnVersion >= versionToNumber(0, 75, 0) ? 'proguard-rules-75.pro' : '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/ios/EXUpdates/Procedures/CheckForUpdateProcedure.swift

@@ -13,6 +13,8 @@ final class CheckForUpdateProcedure: StateMachineProcedure {
   private let successBlock: (_ checkForUpdateResult: CheckForUpdateResult) -> Void
   private let errorBlock: (_ error: Exception) -> Void
 
+  private let fileDownloader: FileDownloader
+
   init(
     database: UpdatesDatabase,
     config: UpdatesConfig,
@@ -29,6 +31,8 @@ final class CheckForUpdateProcedure: StateMachineProcedure {
     self.getLaunchedUpdate = getLaunchedUpdate
     self.successBlock = successBlock
     self.errorBlock = errorBlock
+
+    self.fileDownloader = FileDownloader(config: self.config)
   }
 
   func getLoggerTimerLabel() -> String {
@@ -47,7 +51,7 @@ final class CheckForUpdateProcedure: StateMachineProcedure {
         embeddedUpdate: embeddedUpdate
       )
 
-      FileDownloader(config: self.config).downloadRemoteUpdate(
+      self.fileDownloader.downloadRemoteUpdate(
         fromURL: self.config.updateUrl,
         withDatabase: self.database,
         extraHeaders: extraHeaders) { updateResponse in

package/ios/EXUpdates/Procedures/FetchUpdateProcedure.swift

@@ -15,6 +15,8 @@ final class FetchUpdateProcedure: StateMachineProcedure {
   private let successBlock: (_ fetchUpdateResult: FetchUpdateResult) -> Void
   private let errorBlock: (_ error: Exception) -> Void
 
+  private let remoteAppLoader: RemoteAppLoader
+
   init(
     database: UpdatesDatabase,
     config: UpdatesConfig,
@@ -35,6 +37,14 @@ final class FetchUpdateProcedure: StateMachineProcedure {
     self.getLaunchedUpdate = getLaunchedUpdate
     self.successBlock = successBlock
     self.errorBlock = errorBlock
+
+    self.remoteAppLoader = RemoteAppLoader(
+      config: self.config,
+      database: self.database,
+      directory: self.updatesDirectory,
+      launchedUpdate: self.getLaunchedUpdate(),
+      completionQueue: controllerQueue
+    )
   }
 
   func getLoggerTimerLabel() -> String {
@@ -43,14 +53,6 @@ final class FetchUpdateProcedure: StateMachineProcedure {
 
   func run(procedureContext: ProcedureContext) {
     procedureContext.processStateEvent(UpdatesStateEventDownload())
-
-    let remoteAppLoader = RemoteAppLoader(
-      config: self.config,
-      database: self.database,
-      directory: self.updatesDirectory,
-      launchedUpdate: self.getLaunchedUpdate(),
-      completionQueue: controllerQueue
-    )
     remoteAppLoader.loadUpdate(
       fromURL: self.config.updateUrl
     ) { updateResponse in

package/ios/EXUpdates/Procedures/RelaunchProcedure.swift

@@ -18,6 +18,8 @@ final class RelaunchProcedure: StateMachineProcedure {
   private let successBlock: () -> Void
   private let errorBlock: (_ error: Exception) -> Void
 
+  private let launcherWithDatabase: AppLauncherWithDatabase
+
   init(
     database: UpdatesDatabase,
     config: UpdatesConfig,
@@ -46,6 +48,13 @@ final class RelaunchProcedure: StateMachineProcedure {
     self.requestStartErrorMonitoring = requestStartErrorMonitoring
     self.successBlock = successBlock
     self.errorBlock = errorBlock
+
+    self.launcherWithDatabase = AppLauncherWithDatabase(
+      config: config,
+      database: database,
+      directory: updatesDirectory,
+      completionQueue: controllerQueue
+    )
   }
 
   func getLoggerTimerLabel() -> String {
@@ -54,17 +63,11 @@ final class RelaunchProcedure: StateMachineProcedure {
 
   func run(procedureContext: ProcedureContext) {
     procedureContext.processStateEvent(UpdatesStateEventRestart())
-    let launcherWithDatabase = AppLauncherWithDatabase(
-      config: config,
-      database: database,
-      directory: updatesDirectory,
-      completionQueue: controllerQueue
-    )
     launcherWithDatabase.launchUpdate(withSelectionPolicy: selectionPolicy) { error, success in
       if success {
-        self.setLauncher(launcherWithDatabase)
+        self.setLauncher(self.launcherWithDatabase)
         self.requestStartErrorMonitoring()
-        RCTReloadCommandSetBundleURL(launcherWithDatabase.launchAssetUrl)
+        RCTReloadCommandSetBundleURL(self.launcherWithDatabase.launchAssetUrl)
         RCTTriggerReloadCommandListeners(self.triggerReloadCommandListenersReason)
 
         // TODO(wschurman): this was moved to after the RCT calls to unify reload

package/ios/EXUpdates/Procedures/StartupProcedure.swift

@@ -49,6 +49,7 @@ final class StartupProcedure: StateMachineProcedure, AppLoaderTaskDelegate, AppL
   }
 
   private let errorRecovery = ErrorRecovery()
+  private var errorRecoveryRemoteAppLoader: RemoteAppLoader?
   internal func requestStartErrorMonitoring() {
     errorRecovery.startMonitoring()
   }
@@ -250,14 +251,15 @@ final class StartupProcedure: StateMachineProcedure, AppLoaderTaskDelegate, AppL
 
     remoteLoadStatus = .Loading
 
-    let remoteAppLoader = RemoteAppLoader(
+    // swiftlint:disable force_unwrapping
+    errorRecoveryRemoteAppLoader = RemoteAppLoader(
       config: config,
       database: database,
       directory: self.updatesDirectory,
       launchedUpdate: launchedUpdate(),
       completionQueue: controllerQueue
     )
-    remoteAppLoader.loadUpdate(
+    errorRecoveryRemoteAppLoader!.loadUpdate(
       fromURL: config.updateUrl
     ) { updateResponse in
       if let updateDirective = updateResponse.directiveUpdateResponsePart?.updateDirective {
@@ -291,6 +293,7 @@ final class StartupProcedure: StateMachineProcedure, AppLoaderTaskDelegate, AppL
       self.remoteLoadStatus = .Idle
       self.errorRecovery.notify(newRemoteLoadStatus: self.remoteLoadStatus)
     }
+    // swiftlint:enable force_unwrapping
   }
 
   func markFailedLaunchForLaunchedUpdate() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-updates",
-  "version": "0.25.24",
+  "version": "0.25.25",
   "description": "Fetches and manages remotely-hosted assets and updates to your app's JS bundle.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -67,5 +67,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "a1b4a5fbbc9e1a5bb310cac977ed84da13040ad5"
+  "gitHead": "db4f687820352ae5bc206eecbcd6faf57d6fdd61"
 }