@dynamic-labs/react-native-extension 4.90.0 → 4.91.0

package/index.cjs

@@ -35,7 +35,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var version = "4.90.0";
+var version = "4.91.0";
 
 function _extends() {
   return _extends = Object.assign ? Object.assign.bind() : function (n) {
@@ -877,6 +877,26 @@ https://docs.dynamic.xyz/react-native/react-native-extension
 
 // eslint-disable-next-line import/no-extraneous-dependencies
 const NATIVE_MODULE_NAME = 'EmbeddedWebView';
+/**
+ * Reports whether the EmbeddedWebView native module is linked into the
+ * currently running native binary.
+ *
+ * The embedded webview was introduced mid-version, so an over-the-air JS
+ * update can land on an older binary that predates the native module. Callers
+ * use this to decide between the native overlay path and the
+ * react-native-webview fallback before wiring any side effects.
+ *
+ * `requireOptionalNativeModule` returns `null` (instead of throwing) when the
+ * module is absent. Any unexpected throw is treated as "unavailable" so a
+ * runtime quirk can never break the calling flow.
+ */
+const isEmbeddedWebViewAvailable = () => {
+  try {
+    return Boolean(expoModulesCore.requireOptionalNativeModule(NATIVE_MODULE_NAME));
+  } catch (_a) {
+    return false;
+  }
+};
 const getEmbeddedWebView = () => {
   try {
     return expoModulesCore.requireNativeModule(NATIVE_MODULE_NAME);
@@ -945,6 +965,11 @@ const createEmbeddedWebViewPhaseTimers = ({
 const EMBEDDED_SUCCESS_LOG_COOLDOWN_STORAGE_KEY = 'dynamic.embeddedWebView.successLogLastEmittedAt';
 const DEFAULT_LOADING_TIMEOUT_MS = 20000;
 const DEFAULT_RECOVERY_TIMEOUT_MS = 20000;
+// Debug log labels matching the react-native-webview bridge
+// (`useMessageTransportWebViewBridge`) so both paths surface the same
+// HOST/WEBVIEW message trace under `core.debug.messageTransport`.
+const HOST_TO_WEBVIEW_LOG = 'HOST >>>> WEBVIEW';
+const WEBVIEW_TO_HOST_LOG = 'WEBVIEW >>>> HOST';
 // Wires the JS-side bridge to the native WKWebView singleton owned by Swift.
 // This is intentionally not a React component: the embedded webview lives
 // outside the React tree (in a dedicated UIWindow on iOS), so its setup runs
@@ -1010,7 +1035,11 @@ const setupEmbeddedWebView = ({
     });
   });
   const handleHostMessage = message => {
+    var _a;
     if (message.origin !== 'host') return;
+    if ((_a = core.debug) === null || _a === void 0 ? void 0 : _a.messageTransport) {
+      logger.debug(HOST_TO_WEBVIEW_LOG, JSON.stringify(message, null, 2));
+    }
     native.postMessage(JSON.stringify(message, messageTransport.messageTransportDataJsonReplacer)).catch(err => {
       logger.warn('EmbeddedWebView.postMessage failed', err);
     });
@@ -1041,15 +1070,19 @@ const setupEmbeddedWebView = ({
   };
   core.messageTransport.on(handleSdkReady);
   const onMessageSub = native.addListener('onMessage', event => {
+    var _a;
     let parsed = null;
     try {
       parsed = JSON.parse(event.message, messageTransport.messageTransportDataJsonReviver);
-    } catch (_a) {
+    } catch (_b) {
       return;
     }
     const message = messageTransport.parseMessageTransportData(parsed);
     if (!message) return;
     if (message.origin === 'webview') {
+      if ((_a = core.debug) === null || _a === void 0 ? void 0 : _a.messageTransport) {
+        logger.debug(WEBVIEW_TO_HOST_LOG, JSON.stringify(message, null, 2));
+      }
       core.messageTransport.emit(message);
     }
   });
@@ -1131,6 +1164,71 @@ const setupEmbeddedWebView = ({
   };
 };
 
+// eslint-disable-next-line import/no-extraneous-dependencies
+const KEYCHAIN_MODULE_NAME = 'Keychain';
+/**
+ * Reports whether the Keychain native module is linked into the currently
+ * running native binary. Mirrors `isEmbeddedWebViewAvailable`: an over-the-air
+ * JS update can run on an older binary that predates the module, so any
+ * unexpected throw is treated as "unavailable".
+ */
+const isKeychainAvailable = () => {
+  try {
+    return Boolean(expoModulesCore.requireOptionalNativeModule(KEYCHAIN_MODULE_NAME));
+  } catch (_a) {
+    return false;
+  }
+};
+const getKeychain = () => {
+  try {
+    const keychain = expoModulesCore.requireNativeModule(KEYCHAIN_MODULE_NAME);
+    return keychain;
+  } catch (error) {
+    logger.warn('Could not get dynamic keychain, using unavailable keychain');
+    const keychainUnavailableError = new Error('Keychain is not available');
+    const unavailableKeychain = {
+      deleteKey: () => Promise.reject(keychainUnavailableError),
+      generateKeyPair: () => Promise.reject(keychainUnavailableError),
+      getPublicKey: () => Promise.reject(keychainUnavailableError),
+      hasKey: () => Promise.reject(keychainUnavailableError),
+      isAvailable: () => Promise.resolve(false),
+      sign: () => Promise.reject(keychainUnavailableError)
+    };
+    return unavailableKeychain;
+  }
+};
+
+const NATIVE_MODULES_INSTRUMENT_KEY = 'react_native_extension.native_modules';
+const describeAvailability = available => available ? 'available' : 'unavailable';
+/**
+ * Reports the running package version and which native modules are linked into
+ * the current binary. The embedded webview / keychain modules were introduced
+ * mid-version, so an over-the-air JS update can run ahead of the native binary;
+ * pairing the version with the availability matrix surfaces that gap (and lets
+ * `embeddedWebViewRequested && !embeddedWebViewAvailable` quantify the
+ * react-native-webview fallback rate).
+ */
+const logNativeModuleAvailability = ({
+  core,
+  embeddedWebView,
+  embeddedWebViewAvailable,
+  keychainAvailable
+}) => {
+  const platform = reactNative.Platform.OS;
+  logger.instrument('React Native extension native module availability', {
+    embeddedWebViewAvailable,
+    embeddedWebViewRequested: embeddedWebView,
+    environmentId: core.environmentId,
+    hostSdkSessionId: core.hostSdkSessionId,
+    key: NATIVE_MODULES_INSTRUMENT_KEY,
+    keychainAvailable,
+    platform,
+    time: 0,
+    version
+  });
+  logger.info(`@dynamic-labs/react-native-extension v${version} (${platform}) — native modules: Keychain=${describeAvailability(keychainAvailable)}, EmbeddedWebView=${describeAvailability(embeddedWebViewAvailable)}`);
+};
+
 const setupPasskeyHandler = core => {
   const passkeyRequestChannel = messageTransport.createRequestChannel(core.messageTransport);
   passkeyRequestChannel.handle('passkey_register', _a => __awaiter(void 0, [_a], void 0, function* ({
@@ -1347,26 +1445,6 @@ const setupTurnkeyPasskeyHandler = core => {
   }));
 };
 
-// eslint-disable-next-line import/no-extraneous-dependencies
-const getKeychain = () => {
-  try {
-    const keychain = expoModulesCore.requireNativeModule('Keychain');
-    return keychain;
-  } catch (error) {
-    logger.warn('Could not get dynamic keychain, using unavailable keychain');
-    const keychainUnavailableError = new Error('Keychain is not available');
-    const unavailableKeychain = {
-      deleteKey: () => Promise.reject(keychainUnavailableError),
-      generateKeyPair: () => Promise.reject(keychainUnavailableError),
-      getPublicKey: () => Promise.reject(keychainUnavailableError),
-      hasKey: () => Promise.reject(keychainUnavailableError),
-      isAvailable: () => Promise.resolve(false),
-      sign: () => Promise.reject(keychainUnavailableError)
-    };
-    return unavailableKeychain;
-  }
-};
-
 const setupKeychainHandler = core => {
   const keychainRequestChannel = messageTransport.createRequestChannel(core.messageTransport);
   const keychain = getKeychain();
@@ -1426,15 +1504,31 @@ const ReactNativeExtension = ({
       }
     };
   }
+  // The embedded webview / keychain modules were introduced mid-version, so
+  // an over-the-air JS update can run on an older binary that predates them.
+  // Resolve availability once, here, and reuse it for both telemetry and the
+  // path-selection gate below. (We are past the web early-return, so the
+  // native resolvers only ever run on iOS / Android.)
+  const embeddedWebViewAvailable = isEmbeddedWebViewAvailable();
+  const keychainAvailable = isKeychainAvailable();
+  logNativeModuleAvailability({
+    core,
+    embeddedWebView: _embeddedWebView,
+    embeddedWebViewAvailable,
+    keychainAvailable
+  });
   if (appOrigin) core.manifest.setAppOrigin(appOrigin);
   setupPasskeyHandler(core);
   setupTurnkeyPasskeyHandler(core);
   setupPlatformHandler(core);
   setupStorageHandler(core);
   setupKeychainHandler(core);
-  // Native overlay-webview path supported on iOS (WKWebView) and Android
-  // (android.webkit.WebView). Other platforms fall back to react-native-webview.
-  const useNativeEmbeddedWebView = _embeddedWebView && (reactNative.Platform.OS === 'ios' || reactNative.Platform.OS === 'android');
+  // Native overlay-webview path (iOS WKWebView / Android android.webkit
+  // .WebView). When the native module isn't linked — e.g. an OTA JS update on
+  // an older binary that predates it — fall through to the
+  // react-native-webview path instead of wiring a bridge to a missing module
+  // (which would hang silently).
+  const useNativeEmbeddedWebView = _embeddedWebView && embeddedWebViewAvailable;
   if (useNativeEmbeddedWebView) {
     // The native WKWebView lives in its own UIWindow, outside the React
     // tree. Wire the JS bridge once at extension construction and hand the

package/index.js

@@ -7,13 +7,13 @@ import { messageTransportDataJsonReviver, parseMessageTransportData, messageTran
 import { sdkHasLoadedEventName } from '@dynamic-labs/webview-messages';
 import { setItemAsync, getItemAsync, deleteItemAsync } from 'expo-secure-store';
 import { jsx } from 'react/jsx-runtime';
-import { requireNativeModule } from 'expo-modules-core';
+import { requireOptionalNativeModule, requireNativeModule } from 'expo-modules-core';
 import { Passkey } from 'react-native-passkey';
 import { createURL, getInitialURL, addEventListener, openURL } from 'expo-linking';
 import { openAuthSessionAsync } from 'expo-web-browser';
 import { createPasskey, PasskeyStamper } from '@turnkey/react-native-passkey-stamper';
 
-var version = "4.90.0";
+var version = "4.91.0";
 
 function _extends() {
   return _extends = Object.assign ? Object.assign.bind() : function (n) {
@@ -855,6 +855,26 @@ https://docs.dynamic.xyz/react-native/react-native-extension
 
 // eslint-disable-next-line import/no-extraneous-dependencies
 const NATIVE_MODULE_NAME = 'EmbeddedWebView';
+/**
+ * Reports whether the EmbeddedWebView native module is linked into the
+ * currently running native binary.
+ *
+ * The embedded webview was introduced mid-version, so an over-the-air JS
+ * update can land on an older binary that predates the native module. Callers
+ * use this to decide between the native overlay path and the
+ * react-native-webview fallback before wiring any side effects.
+ *
+ * `requireOptionalNativeModule` returns `null` (instead of throwing) when the
+ * module is absent. Any unexpected throw is treated as "unavailable" so a
+ * runtime quirk can never break the calling flow.
+ */
+const isEmbeddedWebViewAvailable = () => {
+  try {
+    return Boolean(requireOptionalNativeModule(NATIVE_MODULE_NAME));
+  } catch (_a) {
+    return false;
+  }
+};
 const getEmbeddedWebView = () => {
   try {
     return requireNativeModule(NATIVE_MODULE_NAME);
@@ -923,6 +943,11 @@ const createEmbeddedWebViewPhaseTimers = ({
 const EMBEDDED_SUCCESS_LOG_COOLDOWN_STORAGE_KEY = 'dynamic.embeddedWebView.successLogLastEmittedAt';
 const DEFAULT_LOADING_TIMEOUT_MS = 20000;
 const DEFAULT_RECOVERY_TIMEOUT_MS = 20000;
+// Debug log labels matching the react-native-webview bridge
+// (`useMessageTransportWebViewBridge`) so both paths surface the same
+// HOST/WEBVIEW message trace under `core.debug.messageTransport`.
+const HOST_TO_WEBVIEW_LOG = 'HOST >>>> WEBVIEW';
+const WEBVIEW_TO_HOST_LOG = 'WEBVIEW >>>> HOST';
 // Wires the JS-side bridge to the native WKWebView singleton owned by Swift.
 // This is intentionally not a React component: the embedded webview lives
 // outside the React tree (in a dedicated UIWindow on iOS), so its setup runs
@@ -988,7 +1013,11 @@ const setupEmbeddedWebView = ({
     });
   });
   const handleHostMessage = message => {
+    var _a;
     if (message.origin !== 'host') return;
+    if ((_a = core.debug) === null || _a === void 0 ? void 0 : _a.messageTransport) {
+      logger.debug(HOST_TO_WEBVIEW_LOG, JSON.stringify(message, null, 2));
+    }
     native.postMessage(JSON.stringify(message, messageTransportDataJsonReplacer)).catch(err => {
       logger.warn('EmbeddedWebView.postMessage failed', err);
     });
@@ -1019,15 +1048,19 @@ const setupEmbeddedWebView = ({
   };
   core.messageTransport.on(handleSdkReady);
   const onMessageSub = native.addListener('onMessage', event => {
+    var _a;
     let parsed = null;
     try {
       parsed = JSON.parse(event.message, messageTransportDataJsonReviver);
-    } catch (_a) {
+    } catch (_b) {
       return;
     }
     const message = parseMessageTransportData(parsed);
     if (!message) return;
     if (message.origin === 'webview') {
+      if ((_a = core.debug) === null || _a === void 0 ? void 0 : _a.messageTransport) {
+        logger.debug(WEBVIEW_TO_HOST_LOG, JSON.stringify(message, null, 2));
+      }
       core.messageTransport.emit(message);
     }
   });
@@ -1109,6 +1142,71 @@ const setupEmbeddedWebView = ({
   };
 };
 
+// eslint-disable-next-line import/no-extraneous-dependencies
+const KEYCHAIN_MODULE_NAME = 'Keychain';
+/**
+ * Reports whether the Keychain native module is linked into the currently
+ * running native binary. Mirrors `isEmbeddedWebViewAvailable`: an over-the-air
+ * JS update can run on an older binary that predates the module, so any
+ * unexpected throw is treated as "unavailable".
+ */
+const isKeychainAvailable = () => {
+  try {
+    return Boolean(requireOptionalNativeModule(KEYCHAIN_MODULE_NAME));
+  } catch (_a) {
+    return false;
+  }
+};
+const getKeychain = () => {
+  try {
+    const keychain = requireNativeModule(KEYCHAIN_MODULE_NAME);
+    return keychain;
+  } catch (error) {
+    logger.warn('Could not get dynamic keychain, using unavailable keychain');
+    const keychainUnavailableError = new Error('Keychain is not available');
+    const unavailableKeychain = {
+      deleteKey: () => Promise.reject(keychainUnavailableError),
+      generateKeyPair: () => Promise.reject(keychainUnavailableError),
+      getPublicKey: () => Promise.reject(keychainUnavailableError),
+      hasKey: () => Promise.reject(keychainUnavailableError),
+      isAvailable: () => Promise.resolve(false),
+      sign: () => Promise.reject(keychainUnavailableError)
+    };
+    return unavailableKeychain;
+  }
+};
+
+const NATIVE_MODULES_INSTRUMENT_KEY = 'react_native_extension.native_modules';
+const describeAvailability = available => available ? 'available' : 'unavailable';
+/**
+ * Reports the running package version and which native modules are linked into
+ * the current binary. The embedded webview / keychain modules were introduced
+ * mid-version, so an over-the-air JS update can run ahead of the native binary;
+ * pairing the version with the availability matrix surfaces that gap (and lets
+ * `embeddedWebViewRequested && !embeddedWebViewAvailable` quantify the
+ * react-native-webview fallback rate).
+ */
+const logNativeModuleAvailability = ({
+  core,
+  embeddedWebView,
+  embeddedWebViewAvailable,
+  keychainAvailable
+}) => {
+  const platform = Platform.OS;
+  logger.instrument('React Native extension native module availability', {
+    embeddedWebViewAvailable,
+    embeddedWebViewRequested: embeddedWebView,
+    environmentId: core.environmentId,
+    hostSdkSessionId: core.hostSdkSessionId,
+    key: NATIVE_MODULES_INSTRUMENT_KEY,
+    keychainAvailable,
+    platform,
+    time: 0,
+    version
+  });
+  logger.info(`@dynamic-labs/react-native-extension v${version} (${platform}) — native modules: Keychain=${describeAvailability(keychainAvailable)}, EmbeddedWebView=${describeAvailability(embeddedWebViewAvailable)}`);
+};
+
 const setupPasskeyHandler = core => {
   const passkeyRequestChannel = createRequestChannel(core.messageTransport);
   passkeyRequestChannel.handle('passkey_register', _a => __awaiter(void 0, [_a], void 0, function* ({
@@ -1325,26 +1423,6 @@ const setupTurnkeyPasskeyHandler = core => {
   }));
 };
 
-// eslint-disable-next-line import/no-extraneous-dependencies
-const getKeychain = () => {
-  try {
-    const keychain = requireNativeModule('Keychain');
-    return keychain;
-  } catch (error) {
-    logger.warn('Could not get dynamic keychain, using unavailable keychain');
-    const keychainUnavailableError = new Error('Keychain is not available');
-    const unavailableKeychain = {
-      deleteKey: () => Promise.reject(keychainUnavailableError),
-      generateKeyPair: () => Promise.reject(keychainUnavailableError),
-      getPublicKey: () => Promise.reject(keychainUnavailableError),
-      hasKey: () => Promise.reject(keychainUnavailableError),
-      isAvailable: () => Promise.resolve(false),
-      sign: () => Promise.reject(keychainUnavailableError)
-    };
-    return unavailableKeychain;
-  }
-};
-
 const setupKeychainHandler = core => {
   const keychainRequestChannel = createRequestChannel(core.messageTransport);
   const keychain = getKeychain();
@@ -1404,15 +1482,31 @@ const ReactNativeExtension = ({
       }
     };
   }
+  // The embedded webview / keychain modules were introduced mid-version, so
+  // an over-the-air JS update can run on an older binary that predates them.
+  // Resolve availability once, here, and reuse it for both telemetry and the
+  // path-selection gate below. (We are past the web early-return, so the
+  // native resolvers only ever run on iOS / Android.)
+  const embeddedWebViewAvailable = isEmbeddedWebViewAvailable();
+  const keychainAvailable = isKeychainAvailable();
+  logNativeModuleAvailability({
+    core,
+    embeddedWebView: _embeddedWebView,
+    embeddedWebViewAvailable,
+    keychainAvailable
+  });
   if (appOrigin) core.manifest.setAppOrigin(appOrigin);
   setupPasskeyHandler(core);
   setupTurnkeyPasskeyHandler(core);
   setupPlatformHandler(core);
   setupStorageHandler(core);
   setupKeychainHandler(core);
-  // Native overlay-webview path supported on iOS (WKWebView) and Android
-  // (android.webkit.WebView). Other platforms fall back to react-native-webview.
-  const useNativeEmbeddedWebView = _embeddedWebView && (Platform.OS === 'ios' || Platform.OS === 'android');
+  // Native overlay-webview path (iOS WKWebView / Android android.webkit
+  // .WebView). When the native module isn't linked — e.g. an OTA JS update on
+  // an older binary that predates it — fall through to the
+  // react-native-webview path instead of wiring a bridge to a missing module
+  // (which would hang silently).
+  const useNativeEmbeddedWebView = _embeddedWebView && embeddedWebViewAvailable;
   if (useNativeEmbeddedWebView) {
     // The native WKWebView lives in its own UIWindow, outside the React
     // tree. Wire the JS bridge once at extension construction and hand the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/react-native-extension",
-  "version": "4.90.0",
+  "version": "4.91.0",
   "main": "./index.cjs",
   "module": "./index.js",
   "types": "./src/index.d.ts",
@@ -18,11 +18,11 @@
     "@turnkey/react-native-passkey-stamper": "1.2.7",
     "@react-native-documents/picker": "^11.0.0",
     "react-native-fs": ">=2.20.0",
-    "@dynamic-labs/assert-package-version": "4.90.0",
-    "@dynamic-labs/client": "4.90.0",
-    "@dynamic-labs/logger": "4.90.0",
-    "@dynamic-labs/message-transport": "4.90.0",
-    "@dynamic-labs/webview-messages": "4.90.0"
+    "@dynamic-labs/assert-package-version": "4.91.0",
+    "@dynamic-labs/client": "4.91.0",
+    "@dynamic-labs/logger": "4.91.0",
+    "@dynamic-labs/message-transport": "4.91.0",
+    "@dynamic-labs/webview-messages": "4.91.0"
   },
   "peerDependencies": {
     "react": ">=18.0.0 <20.0.0",

package/src/ReactNativeExtension/ReactNativeExtension.d.ts

@@ -23,17 +23,24 @@ export type ReactNativeExtensionProps = {
      * isolates the webview from RN re-renders, navigation transitions, and
      * other lifecycle events.
      *
-     * When this flag is on, the `WebView` returned under
-     * `extension.reactNative.WebView` is a no-op component — do not render it.
-     * The native overlay is created lazily and retained for the process
-     * lifetime; subsequent extension factory invocations re-bind the JS bridge
-     * to the same native overlay (e.g. when the consumer recreates the client
-     * with a new `environmentId`).
+     * Always render the `WebView` returned under
+     * `extension.reactNative.WebView`. When the native overlay is active it is a
+     * no-op component that renders nothing — the native overlay is created
+     * lazily and retained for the process lifetime, and subsequent extension
+     * factory invocations re-bind the JS bridge to the same native overlay (e.g.
+     * when the consumer recreates the client with a new `environmentId`).
      *
-     * There is no automatic load recovery on this path. Any HTTP error,
-     * network failure, blocked navigation, SSL error, or process termination
-     * surfaces as `core.initialization.error` with `WebViewFailedToLoadError`
-     * — consumers should treat the SDK as un-initialised and react accordingly.
+     * The native module was introduced mid-version, so an over-the-air JS update
+     * can land on an older native binary that predates it. When the module is not
+     * linked, this flag is transparently ignored and the returned `WebView`
+     * becomes the regular react-native-webview component, which must be mounted
+     * for the SDK to initialise — hence always render it.
+     *
+     * On the native overlay path there is no automatic load recovery. Any HTTP
+     * error, network failure, blocked navigation, SSL error, or process
+     * termination surfaces as `core.initialization.error` with
+     * `WebViewFailedToLoadError` — consumers should treat the SDK as
+     * un-initialised and react accordingly.
      *
      * On platforms other than iOS / Android (e.g. web), this flag is ignored.
      * Defaults to false.

package/src/ReactNativeExtension/logNativeModuleAvailability.d.ts

@@ -0,0 +1,19 @@
+import { Core } from '@dynamic-labs/client';
+export type LogNativeModuleAvailabilityArgs = {
+    core: Core;
+    /** The `embeddedWebView` flag the consumer requested. */
+    embeddedWebView: boolean;
+    /** Whether the EmbeddedWebView native module is linked in this binary. */
+    embeddedWebViewAvailable: boolean;
+    /** Whether the Keychain native module is linked in this binary. */
+    keychainAvailable: boolean;
+};
+/**
+ * Reports the running package version and which native modules are linked into
+ * the current binary. The embedded webview / keychain modules were introduced
+ * mid-version, so an over-the-air JS update can run ahead of the native binary;
+ * pairing the version with the availability matrix surfaces that gap (and lets
+ * `embeddedWebViewRequested && !embeddedWebViewAvailable` quantify the
+ * react-native-webview fallback rate).
+ */
+export declare const logNativeModuleAvailability: ({ core, embeddedWebView, embeddedWebViewAvailable, keychainAvailable, }: LogNativeModuleAvailabilityArgs) => void;

package/src/nativeModules/EmbeddedWebView.d.ts

@@ -51,4 +51,18 @@ export type EmbeddedWebViewNativeModule = {
     respondToShouldStartLoad: (id: string, allow: boolean) => Promise<void>;
     addListener: <T extends EmbeddedWebViewOnMessageEvent | EmbeddedWebViewOnShouldStartLoadEvent | EmbeddedWebViewOnLoadErrorEvent | EmbeddedWebViewOnLoadStartEvent | EmbeddedWebViewOnLoadEvent | EmbeddedWebViewOnLoadEndEvent>(eventName: EmbeddedWebViewEventName, listener: (event: T) => void) => EmbeddedWebViewSubscription;
 };
+/**
+ * Reports whether the EmbeddedWebView native module is linked into the
+ * currently running native binary.
+ *
+ * The embedded webview was introduced mid-version, so an over-the-air JS
+ * update can land on an older binary that predates the native module. Callers
+ * use this to decide between the native overlay path and the
+ * react-native-webview fallback before wiring any side effects.
+ *
+ * `requireOptionalNativeModule` returns `null` (instead of throwing) when the
+ * module is absent. Any unexpected throw is treated as "unavailable" so a
+ * runtime quirk can never break the calling flow.
+ */
+export declare const isEmbeddedWebViewAvailable: () => boolean;
 export declare const getEmbeddedWebView: () => EmbeddedWebViewNativeModule;

package/src/nativeModules/Keychain.d.ts

@@ -12,5 +12,12 @@ type KeychainNativeModule = {
     }>;
     deleteKey: (key: string) => Promise<void>;
 };
+/**
+ * Reports whether the Keychain native module is linked into the currently
+ * running native binary. Mirrors `isEmbeddedWebViewAvailable`: an over-the-air
+ * JS update can run on an older binary that predates the module, so any
+ * unexpected throw is treated as "unavailable".
+ */
+export declare const isKeychainAvailable: () => boolean;
 export declare const getKeychain: () => KeychainNativeModule;
 export {};