@userflow-tech/react-native 0.4.5 → 0.6.0

package/src/anchors/semanticMatcher.ts

@@ -190,18 +190,21 @@ function intrinsicNonTextAgrees(fp: MobileFingerprint, inst: AutoAnchorInstance)
   );
 }
 
+/**
+ * An id or kind conflict, or a childText disagreement no text-independent
+ * identity (authoritative id, matching icon/image) vouches for.
+ */
+function isContradicted(fp: MobileFingerprint, inst: AutoAnchorInstance): boolean {
+  if (contradictsStrong(fp, inst)) return true;
+  return childTextDisagrees(fp, inst) && !idAgrees(fp, inst) && !intrinsicNonTextAgrees(fp, inst);
+}
+
 function scoreInstance(
   fp: MobileFingerprint,
   inst: AutoAnchorInstance,
   ambiguous: boolean,
 ): number {
-  if (contradictsStrong(fp, inst)) return -Infinity;
-
-  // A childText disagreement is disqualifying unless a text-independent identity
-  // vouches for the element (authoritative id, or matching icon/image).
-  if (childTextDisagrees(fp, inst) && !idAgrees(fp, inst) && !intrinsicNonTextAgrees(fp, inst)) {
-    return -Infinity;
-  }
+  if (isContradicted(fp, inst)) return -Infinity;
 
   let score = 0;
 
@@ -231,11 +234,14 @@ function scoreInstance(
 
   score += scoreAncestors(fp.ancestors ?? [], inst.ancestors ?? []);
 
-  const window = autoAnchorRegistry.siblingWindow(inst.instanceId, 2);
-  score += scoreSiblingWindow(fp.previousSiblings ?? [], window.previous);
-  // Score next siblings once. The POC added a reversed pass *and* a direct pass,
-  // which double-counted the next window.
-  score += scoreSiblingWindow(fp.nextSiblings ?? [], window.next);
+  // The window scans the registry, so skip it when there is nothing to compare.
+  if (fp.previousSiblings?.length || fp.nextSiblings?.length) {
+    const window = autoAnchorRegistry.siblingWindow(inst.instanceId, 2);
+    score += scoreSiblingWindow(fp.previousSiblings ?? [], window.previous);
+    // Score next siblings once. The POC added a reversed pass *and* a direct pass,
+    // which double-counted the next window.
+    score += scoreSiblingWindow(fp.nextSiblings ?? [], window.next);
+  }
 
   if (ambiguous && !inst.manualId) score -= 40;
 
@@ -246,6 +252,8 @@ type InstanceFilter = (inst: AutoAnchorInstance) => boolean;
 
 interface MatchOptions {
   instanceFilter?: InstanceFilter;
+  /** The caller refreshed live content earlier in this same synchronous call. */
+  liveContentFresh?: boolean;
 }
 
 /** Each instance's visibility is computed once per match. */
@@ -260,10 +268,7 @@ function memoizeFilter(filter: InstanceFilter): InstanceFilter {
   };
 }
 
-function candidatePool(
-  fp: MobileFingerprint,
-  instanceFilter?: InstanceFilter,
-): AutoAnchorInstance[] {
+function candidatePool(fp: MobileFingerprint): AutoAnchorInstance[] {
   // Explicit ids are authoritative: a miss is no-candidates, not a full-registry search.
   let pool: AutoAnchorInstance[];
   if (fp.manualId) {
@@ -286,29 +291,45 @@ function candidatePool(
       if (filtered.length > 0) pool = filtered;
     }
   }
-  return instanceFilter ? pool.filter(instanceFilter) : pool;
+  return pool;
 }
 
 function miss(reason: MatchMissReason, score = 0, secondScore = 0): MatchResult {
   return { instance: null, score, secondScore, reason };
 }
 
-function matchFingerprintCore(fp: MobileFingerprint, instanceFilter?: InstanceFilter): MatchResult {
+function matchFingerprintCore(
+  fp: MobileFingerprint,
+  instanceFilter?: InstanceFilter,
+  liveContentFresh = false,
+): MatchResult {
   // Live text / testID must be applied *before* pooling. A shared Babel helper
   // (`const field = () => <TextInput testID={id} />`) reuses one auto-anchor
   // callback, so the runtime bag is last-writer-wins until we read the host.
+  // An unchanged host is a fiber and props-identity check after one shared
+  // ancestor walk per pass, so refreshing every instance stays cheap; the
+  // per-instance screen walk is what is not, and it only runs for the pool
+  // below.
+  const all = autoAnchorRegistry.allInstances();
+  if (all.length > 0 && !liveContentFresh) {
+    autoAnchorRegistry.refreshLiveContent(all);
+  }
+
   // A filter's verdict is memoized so covered-screen checks run once per instance.
   const filter = instanceFilter ? memoizeFilter(instanceFilter) : undefined;
-  const broad = filter
-    ? autoAnchorRegistry.allInstances().filter(filter)
-    : autoAnchorRegistry.allInstances();
-  if (broad.length > 0) {
-    autoAnchorRegistry.refreshLiveContent(broad);
+  const candidates = candidatePool(fp);
+  // A contradiction does not depend on visibility, so settle it before the
+  // covered-screen check. Visibility of contradicted instances only matters to
+  // tell `all-contradicted` from `no-candidates` when nothing else is left.
+  const viable: AutoAnchorInstance[] = [];
+  const contradicted: AutoAnchorInstance[] = [];
+  for (const inst of candidates) {
+    (isContradicted(fp, inst) ? contradicted : viable).push(inst);
   }
-
-  const pool = candidatePool(fp, filter);
+  const pool = filter ? viable.filter(filter) : viable;
   if (pool.length === 0) {
-    return miss('no-candidates');
+    const anyContradictedCandidate = filter ? contradicted.some(filter) : contradicted.length > 0;
+    return miss(anyContradictedCandidate ? 'all-contradicted' : 'no-candidates');
   }
 
   // Visibility can clear a registry-wide ambiguous flag (a covered twin) but
@@ -367,7 +388,7 @@ function matchFingerprintCore(fp: MobileFingerprint, instanceFilter?: InstanceFi
  * can flag weak (`structural`) targets.
  */
 export function matchFingerprint(fp: MobileFingerprint, opts?: MatchOptions): MatchResult {
-  const result = matchFingerprintCore(fp, opts?.instanceFilter);
+  const result = matchFingerprintCore(fp, opts?.instanceFilter, opts?.liveContentFresh);
   if (fp.identityStrength) result.identityStrength = fp.identityStrength;
   return result;
 }

package/src/anchors/tapSlop.ts

@@ -0,0 +1,18 @@
+/** Max finger travel (px) between start and end to count as a tap, not a scroll. */
+export const TARGET_PRESS_TAP_SLOP = 10;
+
+export interface TouchPoint {
+  pageX: number;
+  pageY: number;
+}
+
+/** True when the finger moved no more than `slop` between start and end. */
+export function withinTapSlop(
+  start: TouchPoint,
+  end: TouchPoint,
+  slop: number = TARGET_PRESS_TAP_SLOP,
+): boolean {
+  const dx = end.pageX - start.pageX;
+  const dy = end.pageY - start.pageY;
+  return dx * dx + dy * dy <= slop * slop;
+}

package/src/anchors/targetPressMonitor.ts

@@ -1,3 +1,8 @@
+import { gestureHandlerHandoff } from './gestureHandlerHandoff';
+import { TARGET_PRESS_TAP_SLOP, type TouchPoint, withinTapSlop } from './tapSlop';
+
+export { TARGET_PRESS_TAP_SLOP, type TouchPoint, withinTapSlop };
+
 /**
  * Active tooltip target-press subscription.
  *
@@ -19,29 +24,10 @@ export interface TargetPressSubscription {
   onPress: () => void;
 }
 
-/** Max finger travel (px) between start and end to count as a tap, not a scroll. */
-export const TARGET_PRESS_TAP_SLOP = 10;
-
 export function pointInRect(x: number, y: number, rect: TargetPressRect): boolean {
   return x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height;
 }
 
-export interface TouchPoint {
-  pageX: number;
-  pageY: number;
-}
-
-/** True when the finger moved no more than `slop` between start and end. */
-export function withinTapSlop(
-  start: TouchPoint,
-  end: TouchPoint,
-  slop: number = TARGET_PRESS_TAP_SLOP,
-): boolean {
-  const dx = end.pageX - start.pageX;
-  const dy = end.pageY - start.pageY;
-  return dx * dx + dy * dy <= slop * slop;
-}
-
 /**
  * True when start and end both land in `rect` and movement stays within tap
  * slop — mirrors a DOM click on the target without claiming the responder.
@@ -70,14 +56,25 @@ export type TouchIdentifier = number | string;
 export class TargetPressMonitor {
   private subscription: TargetPressSubscription | null = null;
   private touchStarts = new Map<TouchIdentifier, TouchPoint>();
+  private handoffStops = new Map<TouchIdentifier, () => void>();
 
   set(subscription: TargetPressSubscription | null): void {
     this.subscription = subscription;
     if (!subscription) {
       this.touchStarts.clear();
+      this.dropHandoffs();
     }
   }
 
+  /** Fingers with a recorded start that have not ended, cancelled, or been handed off. */
+  inProgressIdentifiers(): TouchIdentifier[] {
+    return [...this.touchStarts.keys()];
+  }
+
+  hasTouch(identifier: TouchIdentifier): boolean {
+    return this.touchStarts.has(identifier);
+  }
+
   clear(): void {
     this.set(null);
   }
@@ -113,6 +110,38 @@ export class TargetPressMonitor {
     }
   }
 
+  /**
+   * Gesture-handler cancelled this finger. Press if that handler later ends as
+   * a tap and the start (and the end, when the payload has one) is inside the
+   * current target rect.
+   */
+  handOffTouch(identifier: TouchIdentifier, handlerTags: readonly number[]): void {
+    const start = this.touchStarts.get(identifier);
+    if (!start) return;
+    this.touchStarts.delete(identifier);
+    this.handoffStops.get(identifier)?.();
+    if (!this.subscription || handlerTags.length === 0) return;
+    const stop = gestureHandlerHandoff.track({
+      identifier,
+      pageX: start.pageX,
+      pageY: start.pageY,
+      handlerTags,
+      onResolve: (end) => {
+        const sub = this.subscription;
+        if (!sub) return;
+        const rect = sub.getRect();
+        if (!rect || rect.width <= 0 || rect.height <= 0) return;
+        if (!pointInRect(start.pageX, start.pageY, rect)) return;
+        if (end && !pointInRect(end.pageX, end.pageY, rect)) return;
+        sub.onPress();
+      },
+    });
+    this.handoffStops.set(identifier, () => {
+      stop();
+      this.handoffStops.delete(identifier);
+    });
+  }
+
   /**
    * Drop in-progress gesture(s). With `identifier`, cancels that finger only;
    * otherwise clears all (e.g. blanket `onTouchCancel`).
@@ -120,15 +149,23 @@ export class TargetPressMonitor {
   cancelTouch(identifier?: TouchIdentifier): void {
     if (identifier == null) {
       this.touchStarts.clear();
+      this.dropHandoffs();
       return;
     }
     this.touchStarts.delete(identifier);
+    this.handoffStops.get(identifier)?.();
   }
 
   /** Test helper. */
   resetForTests(): void {
     this.subscription = null;
     this.touchStarts.clear();
+    this.dropHandoffs();
+  }
+
+  private dropHandoffs(): void {
+    for (const stop of this.handoffStops.values()) stop();
+    this.handoffStops.clear();
   }
 }
 

package/src/authoring/fingerprintFromInstance.ts

@@ -16,7 +16,7 @@ import { fibersMatch, resolveFiberPath } from '../anchors/fiber/resolveFiberPath
 import { createVisibleInstanceFilter } from '../anchors/isInstanceOnVisibleScreen';
 import * as semanticMatcher from '../anchors/semanticMatcher';
 import type { MatchMissReason } from '../anchors/semanticMatcher';
-import { getCurrentScreenLocation } from '../screenTracker';
+import { getCurrentScreenLocation, screenIdFromLocation } from '../screenTracker';
 
 import type { PickTarget } from './hitTest';
 
@@ -35,10 +35,9 @@ function deriveIdentityStrength(inst: AutoAnchorInstance): IdentityStrength {
 }
 
 function screenFromLocation(): { screenId: string; screenName?: string } {
-  const location = getCurrentScreenLocation();
-  if (!location) return { screenId: 'unknown' };
-  if ('path' in location) return { screenId: location.path, screenName: location.path };
-  return { screenId: location.screen, screenName: location.screen };
+  const screenId = screenIdFromLocation(getCurrentScreenLocation());
+  if (screenId === 'unknown') return { screenId };
+  return { screenId, screenName: screenId };
 }
 
 function deviceMetadata(): DeviceMetadata | undefined {

package/src/content/BannerStepButton.tsx

@@ -14,6 +14,7 @@ import {
 } from '../surfaces/resolveBannerTheme';
 
 import { resolveBannerButtonChrome } from './resolveBannerButtonChrome';
+import { resolveContentFontFamily } from './resolveContentFontFamily';
 import { stepButtonContainerStyle } from './resolveStepButtonChrome';
 
 export interface BannerStepButtonProps {
@@ -57,7 +58,7 @@ export function BannerStepButton({
           styles.label,
           {
             color: chrome.fontColor,
-            fontFamily: theme.fontFamily || undefined,
+            fontFamily: resolveContentFontFamily(theme),
             fontSize: chrome.fontSize,
             fontWeight: chrome.fontWeight,
             ...labelMetrics(chrome.lineHeight),

package/src/content/RichContentRenderer.tsx

@@ -8,6 +8,8 @@ import * as React from 'react';
 import type { TextStyle, ViewStyle } from 'react-native';
 import { Image, Platform, Pressable, ScrollView, StyleSheet, Text, View } from 'react-native';
 
+import { openFlowNavigateUrl } from '../navigation/openFlowNavigateUrl';
+
 import { StepButton } from './StepButton';
 import {
   deserializeRichContentDoc,
@@ -17,7 +19,7 @@ import {
 } from './deserialize';
 import { resolveImageFrame } from './imageLayout';
 import { migrateFlowBlocksIntoContent } from './migrateFlowBlocks';
-import { openSafeUrl } from './openSafeUrl';
+import { resolveContentFontFamily } from './resolveContentFontFamily';
 import {
   ROOT_CONTENT_GAP,
   WEB_CODE_BG_ALPHA,
@@ -401,7 +403,7 @@ function RenderedLink({
       accessibilityRole="link"
       accessibilityHint={href || undefined}
       onPress={() => {
-        void openSafeUrl(href);
+        void openFlowNavigateUrl(href);
       }}
     >
       <InlineChildren
@@ -480,7 +482,7 @@ function RenderedImage({
         accessibilityRole="link"
         accessibilityLabel="Image link"
         onPress={() => {
-          void openSafeUrl(href);
+          void openFlowNavigateUrl(href);
         }}
       >
         {framed}
@@ -562,23 +564,27 @@ function RenderedButton({
 }
 
 function baseText(theme: ThemeFragment): TextStyle {
+  const fontFamily = resolveContentFontFamily(theme);
   return {
     color: theme.fontColor,
-    fontFamily: theme.fontFamily || undefined,
     fontSize: theme.fontSize,
+    // Omit the key when unset. An explicit `undefined` is flattened to null,
+    // and RN treats that as "use the default face" rather than keeping a
+    // family set earlier on the same run.
+    ...(fontFamily != null ? { fontFamily } : {}),
   };
 }
 
 function markStyle(node: AbstractRichContentTextFormatting): TextStyle {
-  return {
-    fontWeight: node.bold ? '700' : undefined,
-    fontStyle: node.italic ? 'italic' : undefined,
-    textDecorationLine: textDecoration(node),
-    fontSize: node.small ? 12 : node.sup ? 10 : undefined,
-    color: node.color || undefined,
-    // Inline `code` uses View chrome via RenderedText / RenderedAttribute.
-    fontFamily: node.code ? monoFontFamily() : undefined,
-  };
+  const style: TextStyle = {};
+  if (node.bold) style.fontWeight = '700';
+  if (node.italic) style.fontStyle = 'italic';
+  const decoration = textDecoration(node);
+  if (decoration) style.textDecorationLine = decoration;
+  if (node.small) style.fontSize = 12;
+  else if (node.sup) style.fontSize = 10;
+  if (node.color) style.color = node.color;
+  return style;
 }
 
 /** View wrapper so inline code padding/radius work reliably on Android. */

package/src/content/StepButton.tsx

@@ -9,6 +9,7 @@ import type { TextStyle } from 'react-native';
 import { Platform, Pressable, StyleSheet, Text } from 'react-native';
 
 import { isPrimaryButtonAppearance } from './buttonAppearance';
+import { resolveContentFontFamily } from './resolveContentFontFamily';
 import { resolveStepButtonChrome, stepButtonContainerStyle } from './resolveStepButtonChrome';
 
 export interface StepButtonProps {
@@ -45,7 +46,7 @@ export function StepButton({
           styles.label,
           {
             color: chrome.fontColor,
-            fontFamily: theme.fontFamily || undefined,
+            fontFamily: resolveContentFontFamily(theme),
             fontSize: chrome.fontSize,
             fontWeight: chrome.fontWeight,
             ...labelMetrics(chrome.lineHeight),

package/src/content/openSafeUrl.ts

@@ -15,7 +15,9 @@ export function isSafeUrl(url: string | null | undefined): boolean {
     const parsed = new URL(trimmed);
     return ALLOWED_PROTOCOLS.has(parsed.protocol);
   } catch {
-    return false;
+    // Hermes / older runtimes can lack a full URL implementation; still allow
+    // obvious http(s) strings so NAVIGATE does not fall through to Expo Router.
+    return /^https?:\/\//i.test(trimmed);
   }
 }
 

package/src/content/resolveContentFontFamily.ts

@@ -0,0 +1,119 @@
+/**
+ * Font family for SDK content text.
+ *
+ * A single concrete theme family is kept. A comma-separated custom list keeps
+ * the first family that is not part of the default system stack. That stack,
+ * generics, and empty values use the detected app font, or omit `fontFamily`
+ * so the platform face renders with no warning.
+ */
+import type { ThemeFragment } from '@userflow-tech/protocol';
+
+import {
+  concreteFontFamily,
+  detectAppFontFamily,
+  isBareCssFamily,
+  isIconFontFamily,
+  splitCssFamilies,
+  themeConcreteFontFamily,
+} from '../anchors/fiber/detectAppFontFamily';
+
+export type AppFontDetector = () => string | null;
+
+const CSS_FONT_FALLBACK = 'system-ui, sans-serif';
+
+export function resolveContentFontFamily(
+  theme: ThemeFragment,
+  detect: AppFontDetector = detectAppFontFamily,
+): string | undefined {
+  return explicitThemeFamily(theme) ?? detectedFamily(detect);
+}
+
+/**
+ * CSS `font-family` for banner WebViews. Names are quoted so a multi-word
+ * family stays one face. A substituted app face keeps a platform fallback for
+ * when the WebView cannot resolve it.
+ */
+export function contentFontFamilyCss(
+  theme: ThemeFragment,
+  detect: AppFontDetector = detectAppFontFamily,
+): string {
+  const authored = explicitThemeCss(theme);
+  if (authored) return authored;
+  const family = detectedFamily(detect);
+  if (!family) return CSS_FONT_FALLBACK;
+  return `${quoteCssFamily(family)}, ${CSS_FONT_FALLBACK}`;
+}
+
+/**
+ * `@font-face` rule that publishes the native family name inside the WebView.
+ *
+ * One regular face only. A weight range would make that static file match
+ * bold, and an italic rule with the same upright source would match italic,
+ * so the WebView would not synthesize either. `local()` is the family native
+ * text already uses. A `file://` source is not included: iOS treats that URL
+ * as a navigation and replaces the banner page.
+ */
+export function contentFontFaceCss(
+  theme: ThemeFragment,
+  detect: AppFontDetector = detectAppFontFamily,
+): string {
+  const family = resolvedFamily(theme, detect);
+  if (!family) return '';
+  const quoted = quoteCssFamily(family);
+  return `@font-face{font-family:${quoted};src:local(${quoted});font-weight:400;font-style:normal;font-display:swap;}`;
+}
+
+/**
+ * Re-applies the banner face after theme custom.css. Equal-specificity rules
+ * in that stylesheet would otherwise replace it with a web font the WebView
+ * has not loaded. Code stays mono, including `<strong>`, `<em>`, and `<u>`
+ * wrapped inside `<code>`.
+ */
+export function bannerContentFontLockCss(
+  theme: ThemeFragment,
+  detect: AppFontDetector = detectAppFontFamily,
+): string {
+  const family = contentFontFamilyCss(theme, detect);
+  return (
+    `.userflowjs-banner-root,.userflowjs-banner-root *:not(code):not(pre){font-family:${family};}` +
+    `.userflowjs-banner-root code,.userflowjs-banner-root pre,` +
+    `.userflowjs-banner-root code *,.userflowjs-banner-root pre *{font-family:ui-monospace,Menlo,monospace;}`
+  );
+}
+
+function resolvedFamily(theme: ThemeFragment, detect: AppFontDetector): string | undefined {
+  return explicitThemeFamily(theme) ?? detectedFamily(detect);
+}
+
+function explicitThemeFamily(theme: ThemeFragment): string | undefined {
+  return themeConcreteFontFamily(theme.fontFamily);
+}
+
+/** Authored theme list, quoted so a multi-word family stays one face. */
+function explicitThemeCss(theme: ThemeFragment): string | undefined {
+  const native = explicitThemeFamily(theme);
+  if (!native) return undefined;
+  const parts = splitCssFamilies(theme.fontFamily);
+  if (parts.length <= 1) return quoteCssFamily(native);
+  return parts.map((part) => (isBareCssFamily(part) ? part : quoteCssFamily(part))).join(', ');
+}
+
+function detectedFamily(detect: AppFontDetector): string | undefined {
+  try {
+    const detected = detect();
+    if (typeof detected !== 'string') return undefined;
+    const concrete = concreteFontFamily(detected);
+    if (!concrete || isIconFontFamily(concrete)) return undefined;
+    return concrete;
+  } catch {
+    return undefined;
+  }
+}
+
+function quoteCssFamily(name: string): string {
+  return `"${escapeCssFamily(name)}"`;
+}
+
+function escapeCssFamily(name: string): string {
+  return name.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}

package/src/expo-router/useUserflowExpoRouter.ts

@@ -6,7 +6,11 @@ import {
   readNavigationPresentation,
   subscribeNavigationState,
 } from '../navigation/isOverlayPresentation';
-import { setExpoRouterNavigator } from '../navigation/openFlowNavigateUrl';
+import {
+  mustNotUseExpoRouterPush,
+  shouldOpenExternalNavigateUrl,
+} from '../navigation/navigateUrlUtils';
+import { openFlowNavigateUrl, setExpoRouterNavigator } from '../navigation/openFlowNavigateUrl';
 import { handleScreenChange } from '../screenTracker';
 
 /**
@@ -73,6 +77,11 @@ export function useUserflowExpoRouter(): void {
   useEffect(() => {
     setExpoRouterNavigator({
       push: (href) => {
+        const trimmed = String(href).trim();
+        if (mustNotUseExpoRouterPush(trimmed) || shouldOpenExternalNavigateUrl(trimmed)) {
+          void openFlowNavigateUrl(trimmed);
+          return;
+        }
         router.push(href as never);
       },
     });

package/src/index.ts

@@ -22,6 +22,7 @@ import type {
 
 import './anchors/autoAnchor';
 import { anchorChangeTicker } from './anchors/anchorChangeTicker';
+import { resetDetectedAppFont } from './anchors/fiber/detectAppFontFamily';
 import { notifyAnchorScreenChange } from './anchors/resolveAnchorHost';
 import {
   setCustomScrollIntoView as setCustomScrollIntoViewConfig,
@@ -80,13 +81,13 @@ import {
   attachFlowSessionEngine,
   cancelPendingDraftEnd,
   clearFlowSessionEngineLocalSession,
-  endDraftFlowSession,
   endEvalJsFlowSession,
   getFlowSessionEngine,
   hasActiveFlowSession,
   resetFlowSessionEngine,
 } from './runtime/flowEngine';
 import { isolateAsync, isolateSync } from './runtime/isolateCall';
+import { endDraftPreviewSessions, prepareForBuilderPreviewStart } from './runtime/previewStart';
 import { getUserflowCore } from './runtime/userflowCore';
 import {
   disableScreenTracking,
@@ -100,7 +101,9 @@ import {
 } from './screenTracker';
 import { setSurfaceInteractionBlocking as setSurfaceInteractionBlockingConfig } from './surfaces/surfaceInteractionConfig';
 
-export { SDK_VERSION } from './version';
+import { SDK_VERSION } from './version';
+
+export { SDK_VERSION };
 export type { DeviceContext, DeviceOs, DeviceType, SdkPlatform } from './deviceContext';
 export type { HostAppVersion, HostAppVersionSource } from './hostAppVersion';
 export { EmbedBannerPlaceholder } from './runtime/EmbedBannerPlaceholder';
@@ -141,8 +144,8 @@ export type {
 /** Configuration passed to {@link Userflow.init}. */
 export type UserflowInitConfig = UserflowInitOptions & {
   /**
-   * Optional host handler for flow NAVIGATE actions. When set, wins over
-   * React Navigation / Expo Router / Linking.
+   * Optional host handler for flow and banner NAVIGATE actions. When set, wins
+   * over React Navigation / Expo Router / Linking.
    */
   onNavigate?: FlowNavigateHandler;
   /**
@@ -297,6 +300,10 @@ export const Userflow = {
       ...(config.appBuild !== undefined ? { appBuild: config.appBuild } : {}),
     });
     warnIfInstallIncomplete();
+    if (__DEV__) {
+      // eslint-disable-next-line no-console -- intentional development diagnostic
+      console.log(`[Userflow] react-native SDK ${SDK_VERSION} (source)`);
+    }
     cacheDeviceContextAtInit();
     setHostOnNavigate(config.onNavigate);
     lifecycle.start();
@@ -311,6 +318,7 @@ export const Userflow = {
     // the success path makes a failed init look like a broken deep link.
     const pairing = installPairingController(core, {
       ...(config.pairingEndpoint !== undefined ? { pairingEndpoint: config.pairingEndpoint } : {}),
+      prepareForBuilderPreviewStart: () => prepareForBuilderPreviewStart(core),
       clearLocalSession: () => {
         clearFlowSessionEngineLocalSession();
         core.setFlowSessionId(null);
@@ -318,7 +326,7 @@ export const Userflow = {
         core.setBannerSessionId(null);
         evalJsController.reset();
       },
-      endDraftSession: endDraftFlowSession,
+      endDraftSession: endDraftPreviewSessions,
       cancelPendingDraftEnd,
     });
     pairing.notifyInitStarted();
@@ -354,8 +362,8 @@ export const Userflow = {
     return getPairingController(core).exitPreview();
   },
   /**
-   * Override or clear the host NAVIGATE handler (same as `init({ onNavigate })`).
-   * Wins over React Navigation / Expo Router / Linking when set.
+   * Override or clear the host NAVIGATE handler for flows and banners (same as
+   * `init({ onNavigate })`). Wins over React Navigation / Expo Router / Linking.
    */
   setOnNavigate(handler: FlowNavigateHandler | null | undefined): void {
     setHostOnNavigate(handler);
@@ -372,7 +380,9 @@ export const Userflow = {
     if (previousId != null && previousId !== userId) {
       resetClientConditionEngine();
       core.setClientConditions([]);
-      clearBannerSessionEngineLocalSession();
+      clearFlowSessionEngineLocalSession();
+      clearBannerSessionEngineLocalSession({ rememberDraftForPreviewEnd: false });
+      core.setFlowSessionId(null);
       core.setBannerSessionId(null);
       evalJsController.reset();
       await clearAnonymousId();
@@ -391,7 +401,9 @@ export const Userflow = {
     if (previousId != null && previousId !== anonymousId) {
       resetClientConditionEngine();
       core.setClientConditions([]);
-      clearBannerSessionEngineLocalSession();
+      clearFlowSessionEngineLocalSession();
+      clearBannerSessionEngineLocalSession({ rememberDraftForPreviewEnd: false });
+      core.setFlowSessionId(null);
       core.setBannerSessionId(null);
       evalJsController.reset();
       armScreenViewedForNextIdentify();
@@ -482,6 +494,7 @@ export const Userflow = {
   },
   /** Clears the current user identity and disconnects from Userflow. */
   async reset(): Promise<void> {
+    resetDetectedAppFont();
     resetClientConditionEngine();
     resetFlowSessionEngine();
     resetBannerSessionEngine();