@userflow-tech/react-native 0.2.0 → 0.3.1

package/src/index.ts

@@ -29,7 +29,6 @@ import {
   type CustomScrollIntoView,
   type ScrollPadding,
 } from './anchors/scrollConfig';
-import { setSurfaceInteractionBlocking as setSurfaceInteractionBlockingConfig } from './surfaces/surfaceInteractionConfig';
 import { clearAnonymousId, getOrCreateAnonymousId } from './anonymousId';
 import {
   didHandleURL,
@@ -44,6 +43,8 @@ import {
   mergeDeviceContextUserAttributes,
   type DeviceContext,
 } from './deviceContext';
+import { setEvalJsBridgeHandlers } from './evalJs/evalJsBridge';
+import { evalJsController } from './evalJs/evalJsController';
 import {
   cacheHostAppVersionAtInit,
   getCachedHostAppVersion,
@@ -51,21 +52,41 @@ import {
   mergeHostAppVersionUserAttributes,
   type HostAppVersion,
 } from './hostAppVersion';
+import {
+  commitInitOptions,
+  releaseFailedInitOptions,
+  warnIfInitOptionsIgnored,
+  warnIfInstallIncomplete,
+} from './installCheck';
 import { LifecycleController } from './lifecycle';
-import { setHostOnNavigate, type FlowNavigateHandler } from './navigation/openFlowNavigateUrl';
+import {
+  openFlowNavigateUrl,
+  setHostOnNavigate,
+  type FlowNavigateHandler,
+} from './navigation/openFlowNavigateUrl';
 import { NetworkController } from './network';
 import { getPairingController, installPairingController } from './pairing/pairingRuntime';
+import {
+  attachBannerSessionEngine,
+  clearBannerSessionEngineLocalSession,
+  getBannerSessionEngine,
+  resetBannerSessionEngine,
+} from './runtime/bannerEngine';
 import {
   attachClientConditionEngine,
   resetClientConditionEngine,
 } from './runtime/clientConditions';
 import {
   attachFlowSessionEngine,
+  cancelPendingDraftEnd,
   clearFlowSessionEngineLocalSession,
+  endDraftFlowSession,
+  endEvalJsFlowSession,
   getFlowSessionEngine,
   hasActiveFlowSession,
   resetFlowSessionEngine,
 } from './runtime/flowEngine';
+import { isolateAsync, isolateSync } from './runtime/isolateCall';
 import { getUserflowCore } from './runtime/userflowCore';
 import {
   disableScreenTracking,
@@ -77,10 +98,13 @@ import {
   screenViewedAttributes,
   setScreenChangeReporter,
 } from './screenTracker';
+import { setSurfaceInteractionBlocking as setSurfaceInteractionBlockingConfig } from './surfaces/surfaceInteractionConfig';
 
 export { SDK_VERSION } from './version';
 export type { DeviceContext, DeviceOs, DeviceType, SdkPlatform } from './deviceContext';
 export type { HostAppVersion, HostAppVersionSource } from './hostAppVersion';
+export { EmbedBannerPlaceholder } from './runtime/EmbedBannerPlaceholder';
+export type { EmbedBannerPlaceholderProps } from './runtime/EmbedBannerPlaceholder';
 export { UserflowProvider, useUserflow } from './runtime/UserflowProvider';
 export type { UserflowProviderProps, UserflowContextValue } from './runtime/UserflowProvider';
 export { useFlowSessionState } from './runtime/useFlowSessionState';
@@ -156,11 +180,14 @@ const lifecycle = new LifecycleController({
     core.resume();
     // After reconnect, flush mid-flow client messages that failed while offline.
     void getFlowSessionEngine(core).flushPendingSends();
+    void getBannerSessionEngine(core).flushPendingSends();
   },
   clearLocalSession: () => {
     clearFlowSessionEngineLocalSession();
+    clearBannerSessionEngineLocalSession();
     // Engine may not exist yet; still clear any transport join resume id.
     core.setFlowSessionId(null);
+    core.setBannerSessionId(null);
   },
   ensureAlive: () => core.ensureAlive(),
   hasActiveSession: () => hasActiveFlowSession(),
@@ -185,49 +212,43 @@ function armScreenViewedForNextIdentify(): void {
 
 function wireScreenChangeReporter(): void {
   setScreenChangeReporter((location) => {
-    lifecycle.reportActivity();
-    const screenKey = 'path' in location ? `path:${location.path}` : `screen:${location.screen}`;
-    notifyAnchorScreenChange(screenKey);
-    anchorChangeTicker.notify();
-    const identified = core.getUserId() != null;
-    if (__DEV__) {
-      // eslint-disable-next-line no-console -- intentional development diagnostic
-      console.log(
-        '[Userflow] updateScreen',
-        location,
-        identified ? '(push UpdateClientContext)' : '(buffered until identify)',
-      );
-    }
-    // Mirrors web: only pushes UpdateClientContext after identify; before that the
-    // location is remembered and included on the next end-user channel join.
-    void core.updateScreen(location).catch((error: unknown) => {
-      // Screen updates are best-effort; connection drops / rate limits should not
-      // surface to the host app's navigation path.
+    isolateSync('updateScreen', () => {
+      lifecycle.reportActivity();
+      const screenKey = 'path' in location ? `path:${location.path}` : `screen:${location.screen}`;
+      notifyAnchorScreenChange(screenKey);
+      anchorChangeTicker.notify();
+      const identified = core.getUserId() != null;
       if (__DEV__) {
         // eslint-disable-next-line no-console -- intentional development diagnostic
-        console.warn('[Userflow] updateScreen failed', error);
+        console.log(
+          '[Userflow] updateScreen',
+          location,
+          identified ? '(push UpdateClientContext)' : '(buffered until identify)',
+        );
       }
-    });
+      // Mirrors web: only pushes UpdateClientContext after identify; before that the
+      // location is remembered and included on the next end-user channel join.
+      void isolateAsync('updateScreen', () => core.updateScreen(location), {
+        rethrowHostContract: false,
+      });
 
-    const attrs = screenViewedAttributes(location);
-    if (!attrs) return;
-    if (!identified) {
-      screenViewedAwaitingIdentify = true;
-      return;
-    }
-    screenViewedAwaitingIdentify = false;
-    if (__DEV__) {
-      // eslint-disable-next-line no-console -- intentional development diagnostic
-      console.log('[Userflow] track', SCREEN_VIEWED_EVENT, attrs);
-    }
-    void core.track(SCREEN_VIEWED_EVENT, attrs).catch((error: unknown) => {
-      // Screen views are best-effort; connection drops / rate limits should not
-      // surface to the host app's navigation path. Each accepted screen sends
-      // UpdateClientContext + TrackEvent (two slots of the 100/min cap).
+      const attrs = screenViewedAttributes(location);
+      if (!attrs) return;
+      if (!identified) {
+        screenViewedAwaitingIdentify = true;
+        return;
+      }
+      screenViewedAwaitingIdentify = false;
       if (__DEV__) {
         // eslint-disable-next-line no-console -- intentional development diagnostic
-        console.warn('[Userflow] track', SCREEN_VIEWED_EVENT, 'failed', error);
+        console.log('[Userflow] track', SCREEN_VIEWED_EVENT, attrs);
       }
+      // Screen views are best-effort; connection drops / rate limits should not
+      // surface to the host app's navigation path. Each accepted screen sends
+      // UpdateClientContext + TrackEvent (two slots of the 100/min cap).
+      void isolateAsync('track', () => core.track(SCREEN_VIEWED_EVENT, attrs), {
+        rethrowHostContract: false,
+      });
     });
   });
 }
@@ -249,6 +270,7 @@ function mergeSystemUserAttributes<T extends Record<string, unknown>>(
 
 async function afterIdentify(): Promise<void> {
   attachFlowSessionEngine(core);
+  attachBannerSessionEngine(core);
   attachClientConditionEngine(core);
   getPairingController(core).notifyIdentified();
   lifecycle.reportActivity();
@@ -269,10 +291,12 @@ async function afterIdentify(): Promise<void> {
 export const Userflow = {
   /** Validate credentials, store configuration, and wire app-lifecycle handling. */
   init(config: UserflowInitConfig): Promise<UserflowConfig> {
+    warnIfInitOptionsIgnored(config);
     cacheHostAppVersionAtInit({
       ...(config.appVersion !== undefined ? { appVersion: config.appVersion } : {}),
       ...(config.appBuild !== undefined ? { appBuild: config.appBuild } : {}),
     });
+    warnIfInstallIncomplete();
     cacheDeviceContextAtInit();
     setHostOnNavigate(config.onNavigate);
     lifecycle.start();
@@ -290,18 +314,28 @@ export const Userflow = {
       clearLocalSession: () => {
         clearFlowSessionEngineLocalSession();
         core.setFlowSessionId(null);
+        clearBannerSessionEngineLocalSession();
+        core.setBannerSessionId(null);
+        evalJsController.reset();
       },
+      endDraftSession: endDraftFlowSession,
+      cancelPendingDraftEnd,
     });
     pairing.notifyInitStarted();
     void pairing.start();
 
     return core.init(config).then(
-      async (resolved) => {
+      (resolved) => {
+        commitInitOptions();
         enableScreenTracking();
-        await pairing.notifyInitialized();
+        // Pairing connect can take the full socket timeout. Identify, and the
+        // end-user socket that delivers the preview, must not wait on it.
+        // notifyInitialized never rejects; the relay queue covers either order.
+        void pairing.notifyInitialized();
         return resolved;
       },
       (error: unknown) => {
+        releaseFailedInitOptions();
         pairing.notifyInitFailed(error);
         throw error;
       },
@@ -338,6 +372,9 @@ export const Userflow = {
     if (previousId != null && previousId !== userId) {
       resetClientConditionEngine();
       core.setClientConditions([]);
+      clearBannerSessionEngineLocalSession();
+      core.setBannerSessionId(null);
+      evalJsController.reset();
       await clearAnonymousId();
       armScreenViewedForNextIdentify();
     }
@@ -354,6 +391,9 @@ export const Userflow = {
     if (previousId != null && previousId !== anonymousId) {
       resetClientConditionEngine();
       core.setClientConditions([]);
+      clearBannerSessionEngineLocalSession();
+      core.setBannerSessionId(null);
+      evalJsController.reset();
       armScreenViewedForNextIdentify();
     }
     await core.identify(anonymousId, mergeSystemUserAttributes(attributes), options);
@@ -394,14 +434,21 @@ export const Userflow = {
     lifecycle.reportActivity();
     return core.updateGroup(attributes, options);
   },
-  /** Record a custom analytics event for the current user (and group, unless `userOnly`). */
+  /**
+   * Record a custom analytics event for the current user (and group, unless `userOnly`).
+   * Operational failures (network, rate limit, unexpected SDK bugs) are isolated and
+   * logged; the promise still resolves. `UserflowAuthError` for missing
+   * `init` / `identify` or an invalid event name still rejects.
+   */
   track(
     name: string,
     attributes?: UserflowEventAttributes,
     options?: UserflowTrackOptions,
   ): Promise<void> {
-    lifecycle.reportActivity();
-    return core.track(name, attributes, options);
+    return isolateAsync('track', async () => {
+      lifecycle.reportActivity();
+      await core.track(name, attributes, options);
+    }).then(() => undefined);
   },
   /** The currently identified user id, or `null` before identify. */
   getUserId(): string | null {
@@ -429,10 +476,16 @@ export const Userflow = {
   getFlowSessionEngine() {
     return getFlowSessionEngine(core);
   },
+  /** The banner session engine (created lazily; attach runs after identify). */
+  getBannerSessionEngine() {
+    return getBannerSessionEngine(core);
+  },
   /** Clears the current user identity and disconnects from Userflow. */
   async reset(): Promise<void> {
     resetClientConditionEngine();
     resetFlowSessionEngine();
+    resetBannerSessionEngine();
+    evalJsController.reset();
     core.reset();
     armScreenViewedForNextIdentify();
     await clearAnonymousId();
@@ -442,6 +495,7 @@ export const Userflow = {
     getPairingController(core).stop();
     lifecycle.stop();
     network.stop();
+    evalJsController.reset();
     disableScreenTracking();
     screenViewedAwaitingIdentify = false;
     stopDeepLinking();
@@ -453,7 +507,9 @@ export const Userflow = {
    * host-app activity the SDK does not observe.
    */
   reportActivity(): void {
-    lifecycle.reportActivity();
+    isolateSync('reportActivity', () => {
+      lifecycle.reportActivity();
+    });
   },
   /**
    * Report the active React Navigation (or manual) screen name. Prefer
@@ -462,7 +518,9 @@ export const Userflow = {
    * with `screen` set (Expo Router pathnames use `path` via the Expo helper).
    */
   updateScreen(screenName: string | undefined): void {
-    handleScreenChange(screenName ? { screen: screenName } : undefined);
+    isolateSync('updateScreen', () => {
+      handleScreenChange(screenName ? { screen: screenName } : undefined);
+    });
   },
   /**
    * Sticky header/footer insets applied when scrolling tooltip targets into
@@ -487,6 +545,14 @@ export const Userflow = {
   setSurfaceInteractionBlocking(enabled: boolean | null | undefined): void {
     setSurfaceInteractionBlockingConfig(enabled);
   },
+  /**
+   * Values exposed to Evaluate JavaScript as `window.userflowContext.host`
+   * (language, theme, tab bar height, and anything else the page used to read
+   * from the DOM). Replaces the previous host bag.
+   */
+  setEvalJsContext(values: Record<string, unknown> | null | undefined): void {
+    evalJsController.setHostContext(values ?? {});
+  },
   /**
    * Log the host app's native marketing version (store version), not
    * {@link SDK_VERSION}, and the platform OS (`ios` / `android` / …).
@@ -504,3 +570,31 @@ export const Userflow = {
     logDeviceContextToConsole();
   },
 };
+
+setEvalJsBridgeHandlers({
+  track: (name, attributes) => {
+    void Userflow.track(name, attributes as UserflowAttributes | undefined);
+  },
+  updateUser: (attributes) => {
+    void Userflow.updateUser(attributes as PublicAttributes);
+  },
+  updateGroup: (attributes, options) => {
+    void Userflow.updateGroup(
+      attributes as PublicAttributes,
+      options?.membership ? { membership: options.membership as PublicAttributes } : undefined,
+    );
+  },
+  openUrl: (url) => {
+    void isolateAsync('eval-js-open-url', () => openFlowNavigateUrl(url), {
+      rethrowHostContract: false,
+    });
+  },
+  endFlow: (sessionIds) => {
+    void isolateAsync('eval-js-end-flow', () => endEvalJsFlowSession(sessionIds), {
+      rethrowHostContract: false,
+    });
+  },
+  warn: (message) => {
+    console.warn(message);
+  },
+});

package/src/installCheck.ts

@@ -0,0 +1,191 @@
+import { isEvalJsWebViewNativeLinked } from './evalJs/getWebView';
+import { isAsyncStorageLinked } from './storage/asyncStorage';
+
+export const INSTALL_CHECK_HEADER =
+  '[Userflow] Native setup is incomplete. Flows may not run until you fix the following, then rebuild the app (a Metro reload is not enough):';
+
+export const INSTALL_ASYNC_STORAGE_LINE =
+  '- @react-native-async-storage/async-storage is not linked. Anonymous users and Builder pairing will not persist. Add it to the app package.json (npx expo install @react-native-async-storage/async-storage), run pod install on iOS, and rebuild.';
+
+export const INSTALL_VIEW_SHOT_LINE =
+  '- react-native-view-shot is not linked, so Builder element selection gets no screenshot. Install react-native-view-shot@^5.0.0 and rebuild. On Expo SDK 54, pin ^5.0.0; an unpinned npx expo install resolves 4.0.3.';
+
+export const INSTALL_WEBVIEW_LINE =
+  '- react-native-webview is not linked. Evaluate JavaScript and WebView banners will not run. Install it (npx expo install react-native-webview) and rebuild.';
+
+export const INSTALL_DEVICE_INFO_LINE =
+  '- react-native-device-info is not linked, so app_version and app_build are not sent. npm install react-native-device-info, then rebuild.';
+
+export const INSTALL_CHECK_FOOTER = 'See docs/troubleshooting.md.';
+
+export const EXPO_GO_WARNING =
+  '[Userflow] This app is running in Expo Go, which cannot load the SDK native modules. Builder preview links will not open the app. Use a development build (npx expo run:ios / npx expo run:android).';
+
+export const INIT_OPTIONS_IGNORED_WARNING =
+  '[Userflow] Userflow.init() already ran with different options. The new clientToken, serverEndpoint, and pairingEndpoint are ignored because init runs once per process. Userflow.reset() does not apply new credentials. Restart the app to change them.';
+
+const VIEW_SHOT_MODULE = 'RNViewShot';
+const DEVICE_INFO_MODULE = 'RNDeviceInfo';
+
+interface NativeLookup {
+  NativeModules?: Record<string, unknown>;
+  TurboModuleRegistry?: { get?: (name: string) => unknown };
+}
+
+interface ExpoConstantsModule {
+  executionEnvironment?: string;
+  default?: { executionEnvironment?: string };
+}
+
+let didWarn = false;
+
+function loadReactNative(): NativeLookup | null {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+    return require('react-native') as NativeLookup;
+  } catch {
+    return null;
+  }
+}
+
+function isNativeModuleLinked(name: string): boolean {
+  const reactNative = loadReactNative();
+  if (!reactNative) return false;
+  try {
+    const turbo = reactNative.TurboModuleRegistry;
+    if (typeof turbo?.get === 'function' && turbo.get(name) != null) return true;
+  } catch {
+    // Fall through to the legacy registry.
+  }
+  try {
+    return reactNative.NativeModules?.[name] != null;
+  } catch {
+    return false;
+  }
+}
+
+function readExpoConstants(): ExpoConstantsModule | null {
+  try {
+    // Optional. Bare React Native does not have this package.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+    const mod = require('expo-constants') as ExpoConstantsModule;
+    const record = mod?.default ?? mod;
+    if (record == null || typeof record !== 'object') return null;
+    // Touch the field so a throwing getter (missing package stand-in) is caught.
+    void record.executionEnvironment;
+    return record;
+  } catch {
+    return null;
+  }
+}
+
+/** Lines for missing native modules. Empty when the build looks complete. */
+export function collectInstallFindings(): string[] {
+  const findings: string[] = [];
+  if (!isAsyncStorageLinked()) findings.push(INSTALL_ASYNC_STORAGE_LINE);
+  if (!isNativeModuleLinked(VIEW_SHOT_MODULE)) findings.push(INSTALL_VIEW_SHOT_LINE);
+  if (!isEvalJsWebViewNativeLinked()) findings.push(INSTALL_WEBVIEW_LINE);
+  // Expo reads the store version from expo-constants / expo-application.
+  // device-info is the bare React Native path.
+  if (readExpoConstants() == null && !isNativeModuleLinked(DEVICE_INFO_MODULE)) {
+    findings.push(INSTALL_DEVICE_INFO_LINE);
+  }
+  return findings;
+}
+
+export function expoGoWarning(): string | null {
+  const constants = readExpoConstants();
+  const environment = constants?.executionEnvironment;
+  return environment === 'storeClient' ? EXPO_GO_WARNING : null;
+}
+
+export function formatInstallWarning(findings: readonly string[]): string {
+  return [INSTALL_CHECK_HEADER, ...findings, INSTALL_CHECK_FOOTER].join('\n');
+}
+
+/**
+ * One development warning for missing native modules, plus a separate warning
+ * when the host is Expo Go. Release builds stay quiet.
+ */
+export function warnIfInstallIncomplete(): void {
+  if (!__DEV__ || didWarn) return;
+  didWarn = true;
+
+  const findings = collectInstallFindings();
+  if (findings.length > 0) {
+    // eslint-disable-next-line no-console -- intentional install diagnostic
+    console.warn(formatInstallWarning(findings));
+  }
+
+  const expoGo = expoGoWarning();
+  if (expoGo) {
+    // eslint-disable-next-line no-console -- intentional install diagnostic
+    console.warn(expoGo);
+  }
+}
+
+/** @internal */
+export function resetInstallCheckForTests(): void {
+  didWarn = false;
+  recordedInitOptions = null;
+  initOptionsCommitted = false;
+}
+
+interface RecordedInitOptions {
+  clientToken: string;
+  serverEndpoint: string;
+  pairingEndpoint: string;
+}
+
+let recordedInitOptions: RecordedInitOptions | null = null;
+/** True once an `init` promise has resolved. A rejection before that clears the record. */
+let initOptionsCommitted = false;
+
+function recordInitOptions(config: {
+  clientToken: string;
+  serverEndpoint?: string;
+  pairingEndpoint?: string;
+}): RecordedInitOptions {
+  return {
+    clientToken: config.clientToken,
+    serverEndpoint: config.serverEndpoint ?? '',
+    pairingEndpoint: config.pairingEndpoint ?? '',
+  };
+}
+
+export function warnIfInitOptionsIgnored(config: {
+  clientToken: string;
+  serverEndpoint?: string;
+  pairingEndpoint?: string;
+}): void {
+  const next = recordInitOptions(config);
+  if (!recordedInitOptions) {
+    recordedInitOptions = next;
+    return;
+  }
+  if (
+    recordedInitOptions.clientToken === next.clientToken &&
+    recordedInitOptions.serverEndpoint === next.serverEndpoint &&
+    recordedInitOptions.pairingEndpoint === next.pairingEndpoint
+  ) {
+    return;
+  }
+  if (!__DEV__) return;
+  // eslint-disable-next-line no-console -- intentional install diagnostic
+  console.warn(INIT_OPTIONS_IGNORED_WARNING);
+}
+
+/** The in-flight `init` resolved, so later calls really are ignored. */
+export function commitInitOptions(): void {
+  initOptionsCommitted = true;
+}
+
+/**
+ * The in-flight `init` rejected. Core drops its cached promise and will run
+ * the next call, so a corrected token or endpoint must not warn.
+ * A rejection after a successful init does not forget that success.
+ */
+export function releaseFailedInitOptions(): void {
+  if (initOptionsCommitted) return;
+  recordedInitOptions = null;
+}

package/src/lifecycle.ts

@@ -49,7 +49,10 @@ export interface LifecycleControllerDeps {
    * Do not call while lifecycle-suspended — use {@link resume} instead.
    */
   ensureAlive: () => void;
-  /** True while any mid-flow session (live or draft/preview) is on screen. */
+  /**
+   * True while a mid-flow session is held, including one Temporarily Hide is
+   * suppressing. Idle suspend waits so a later attribute update can still unhide it.
+   */
   hasActiveSession: () => boolean;
   /**
    * Re-fire the current screen view after a real background (away past grace).

package/src/navigation/WithUserflowReactNavigation.tsx

@@ -7,6 +7,7 @@ import type {
 import { cloneElement, isValidElement, useCallback, useEffect, useRef } from 'react';
 import type React from 'react';
 
+import { isolateSync } from '../runtime/isolateCall';
 import { handleScreenChange } from '../screenTracker';
 
 import { chainCallbacks } from './chainCallbacks';
@@ -63,16 +64,18 @@ export function WithUserflowReactNavigation({
 
   const reportFocusedScreen = useCallback(
     (state?: NavigationState) => {
-      if (isOverlayPresentation(readNavigationPresentation(navigationRef))) {
-        overlayWasFocusedRef.current = true;
-        return;
-      }
-      const name = getActiveRouteName(state ?? navigationRef.getRootState());
-      handleScreenChange(
-        name ? { screen: name } : undefined,
-        overlayWasFocusedRef.current ? { force: true } : undefined,
-      );
-      overlayWasFocusedRef.current = false;
+      isolateSync('react-navigation-screen', () => {
+        if (isOverlayPresentation(readNavigationPresentation(navigationRef))) {
+          overlayWasFocusedRef.current = true;
+          return;
+        }
+        const name = getActiveRouteName(state ?? navigationRef.getRootState());
+        handleScreenChange(
+          name ? { screen: name } : undefined,
+          overlayWasFocusedRef.current ? { force: true } : undefined,
+        );
+        overlayWasFocusedRef.current = false;
+      });
     },
     [navigationRef],
   );

package/src/navigation/openFlowNavigateUrl.ts

@@ -2,6 +2,7 @@ import type { NavigationContainerRef, ParamListBase } from '@react-navigation/na
 import { Linking } from 'react-native';
 
 import { isSafeUrl, openSafeUrl } from '../content/openSafeUrl';
+import { isolateAsync, isolateSync } from '../runtime/isolateCall';
 
 export type FlowNavigateHandler = (url: string) => void | boolean | Promise<void | boolean>;
 
@@ -75,7 +76,9 @@ export async function openFlowNavigateUrl(url: string): Promise<void> {
   if (!trimmed) return;
 
   if (hostOnNavigate) {
-    await hostOnNavigate(trimmed);
+    await isolateAsync('onNavigate', async () => {
+      await hostOnNavigate!(trimmed);
+    });
     return;
   }
 
@@ -86,13 +89,17 @@ export async function openFlowNavigateUrl(url: string): Promise<void> {
 
   if (isInAppNavigateUrl(trimmed)) {
     if (expoRouter) {
-      expoRouter.push(normalizeInAppPath(trimmed));
+      isolateSync('onNavigate', () => {
+        expoRouter!.push(normalizeInAppPath(trimmed));
+      });
       return;
     }
     if (navigationRef?.isReady()) {
-      const name = routeNameFromPath(trimmed);
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- route names are host-defined
-      (navigationRef as NavigationContainerRef<ParamListBase>).navigate(name as any);
+      isolateSync('onNavigate', () => {
+        const name = routeNameFromPath(trimmed);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- route names are host-defined
+        (navigationRef as NavigationContainerRef<ParamListBase>).navigate(name as any);
+      });
       return;
     }
   }