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

package/index.cjs

@@ -35,7 +35,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var version = "4.89.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.89.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.89.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.89.0",
-    "@dynamic-labs/client": "4.89.0",
-    "@dynamic-labs/logger": "4.89.0",
-    "@dynamic-labs/message-transport": "4.89.0",
-    "@dynamic-labs/webview-messages": "4.89.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",
@@ -32,5 +32,13 @@
     "expo-web-browser": ">=12.0.0",
     "expo-secure-store": ">=12.0.0",
     "expo-modules-core": ">=2.0.0"
+  },
+  "codegenConfig": {
+    "name": "DynamicClientSpec",
+    "type": "modules",
+    "jsSrcsDir": "turboModules",
+    "android": {
+      "javaPackageName": "xyz.dynamic.client"
+    }
   }
 }

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 {};

package/turboModules/NativeDynamicWebView.ts

@@ -0,0 +1,47 @@
+// VENDORED from @dynamic-labs-sdk/client (src/turboModules/NativeDynamicWebView.ts).
+// The OLD SDK pulls @dynamic-labs-sdk/client in transitively, and iOS React
+// Native codegen only generates TurboModule specs for DIRECT app dependencies.
+// react-native-extension is a direct dependency of old-SDK apps, so carrying the
+// codegen spec here makes the consuming app generate DynamicClientSpec/*.h for
+// the transitively-linked native module. Keep byte-identical to the source spec
+// in @dynamic-labs-sdk/client — update there and re-copy, do not edit here.
+//
+// The `interface`, `default export`, and the `react-native` import are hard
+// requirements of the codegen parser and intentionally deviate from the
+// project's conventions. Codegen discovers specs by the `Native*` filename
+// prefix, so this file cannot be renamed to `.native.ts`.
+
+import { type TurboModule, TurboModuleRegistry } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+
+export interface Spec extends TurboModule {
+  addListener(eventName: string): void;
+  close(instanceId: string): void;
+  /**
+   * Creates a WKWebView for the given instanceId and begins loading `url`.
+   *
+   * Resolves on `didCommit` — i.e. the first byte of a 2xx/3xx HTTP
+   * response has been received and content parsing has started. Page-ready
+   * (e.g. the hosted iframe's `iframe-ready-*` handshake) is a separate
+   * concern and must be observed by the caller via the message bus; this
+   * Promise does not wait for it.
+   *
+   * Rejects with a `code` of `webview_<reason>` where `<reason>` is one of:
+   *   - `invalid_url` — URL string was not parseable
+   *   - `no_host_view` — no foreground window to attach the WebView
+   *   - `http_error` — response status was >= 400 (userInfo contains `DynamicWebViewStatusCode`)
+   *   - `navigation_failed` — DNS, TLS, connection failure, or post-commit abort
+   *   - `cancelled` — `close(instanceId)` was called while this open was pending
+   *   - `instance_busy` — `open` was called for an instanceId that already has an active WebView
+   *   - `content_process_terminated` — the WKWebView WebContent process died during load
+   *   - `unsupported` — the device's Android System WebView is too old to support the secure bridge (Android only)
+   *
+   * rejection codes into typed `WebViewLoadFailedError` instances.
+   */
+  open(instanceId: string, url: string): Promise<void>;
+  removeListeners(count: number): void;
+  sendMessage(instanceId: string, data: UnsafeObject): void;
+}
+
+// eslint-disable-next-line import/no-default-export
+export default TurboModuleRegistry.get<Spec>('DynamicClientWebView');

package/turboModules/NativeKeychain.ts

@@ -0,0 +1,22 @@
+// VENDORED from @dynamic-labs-sdk/client (src/turboModules/NativeKeychain.ts).
+// See NativeDynamicWebView.ts in this directory for why the spec is carried here.
+// Keep byte-identical to the source spec in @dynamic-labs-sdk/client.
+//
+// The `interface`, `default export`, and `react-native` import are hard
+// requirements of the codegen parser and intentionally deviate from the
+// project's conventions. Codegen discovers specs by the `Native*` filename
+// prefix, so this file cannot be renamed to `.native.ts`.
+
+import { type TurboModule, TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  deleteKey(key: string): Promise<void>;
+  generateKeyPair(key: string): Promise<{ publicKey: string }>;
+  getPublicKey(key: string): Promise<{ publicKey: string } | null>;
+  hasKey(key: string): Promise<boolean>;
+  isAvailable(): Promise<boolean>;
+  sign(key: string, payload: string): Promise<{ signature: string }>;
+}
+
+// eslint-disable-next-line import/no-default-export
+export default TurboModuleRegistry.getEnforcing<Spec>('DynamicClientKeychain');

package/turboModules/NativeReactNativeManifest.ts

@@ -0,0 +1,24 @@
+// VENDORED from @dynamic-labs-sdk/client (src/turboModules/NativeReactNativeManifest.ts).
+// See NativeDynamicWebView.ts in this directory for why the spec is carried here.
+// Keep byte-identical to the source spec in @dynamic-labs-sdk/client.
+//
+// Consumed by React Native codegen to emit the Android/iOS native interfaces.
+// The filename must stay prefixed with `Native` — codegen's parser discovers
+// spec files by that convention and will silently skip anything else. The
+// `interface` keyword, the `default export`, and the locally-declared
+// `ReactNativeManifest` type are hard requirements of the codegen parser:
+// codegen parses this file statically and does NOT follow imported type
+// aliases, so the return shape must be defined inline here.
+
+import { type TurboModule, TurboModuleRegistry } from 'react-native';
+
+export type ReactNativeManifest = {
+  sdkVersion: string;
+};
+
+export interface Spec extends TurboModule {
+  getManifest(): ReactNativeManifest;
+}
+
+// eslint-disable-next-line import/no-default-export -- codegen requires a default export of the TurboModule spec
+export default TurboModuleRegistry.get<Spec>('DynamicClientManifest');

package/turboModules/NativeScreenshotProtection.ts

@@ -0,0 +1,29 @@
+// VENDORED from @dynamic-labs-sdk/client (src/turboModules/NativeScreenshotProtection.ts).
+// See NativeDynamicWebView.ts in this directory for why the spec is carried here.
+// Keep byte-identical to the source spec in @dynamic-labs-sdk/client.
+//
+// The `interface`, `default export`, and the `react-native` import are hard
+// requirements of the codegen parser and intentionally deviate from the
+// project's conventions. Codegen discovers specs by the `Native*` filename
+// prefix, so this file cannot be renamed to `.native.ts`.
+
+import { type TurboModule, TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  /**
+   * Toggles window-level screenshot/screen-recording protection on the
+   * foreground window while a sensitive surface (e.g. the private-key export
+   * display) is visible.
+   *
+   * Android applies `FLAG_SECURE` on the current Activity window when `enabled`
+   * is `true` and clears it when `false` (only if it set the flag itself, so a
+   * host app's own `FLAG_SECURE` is never cleared). iOS reparents the key
+   * window under a `secureTextEntry` field's canvas so captures render blank.
+   * The protection is window-level and independent of any WebView, so it works
+   * regardless of how the protected UI is rendered.
+   */
+  setEnabled(enabled: boolean): void;
+}
+
+// eslint-disable-next-line import/no-default-export
+export default TurboModuleRegistry.get<Spec>('DynamicClientScreenshotProtection');