@userflow-tech/react-native 0.3.0 → 0.4.0

package/src/anchors/fiber/findAnchorFiber.ts

@@ -19,35 +19,65 @@ const MAX_NODES = 60_000;
 /** One production warning per process — truncation must not look like "missing". */
 let maxNodesWarned = false;
 
-export type AnchorPropTier = 'testID' | 'nativeID' | 'accessibilityLabel';
+export type AnchorPropTier = 'userflowId' | 'testID' | 'nativeID' | 'accessibilityLabel';
 
-const TIER_ORDER: AnchorPropTier[] = ['testID', 'nativeID', 'accessibilityLabel'];
+/** Props an anchor id can sit on, strongest first. */
+export const ANCHOR_PROP_TIERS: readonly AnchorPropTier[] = [
+  'userflowId',
+  'testID',
+  'nativeID',
+  'accessibilityLabel',
+];
 
 export type FindAnchorFiberResult =
   | { status: 'found'; fiber: AnyFiber; tier: AnchorPropTier }
   | { status: 'ambiguous'; tier: AnchorPropTier }
   | { status: 'missing' };
 
+/** Every collapsed host of the winning tier. Duplicates stay in the list. */
+export type FindAnchorFibersResult =
+  | { status: 'found'; fibers: AnyFiber[]; tier: AnchorPropTier }
+  | { status: 'missing' };
+
 /**
  * Bounded DFS under `rootFiber` looking for fibers whose memoizedProps match
- * `id` on testID, then nativeID, then accessibilityLabel. Uses the highest
- * tier that has any match so a testID hit is never made ambiguous by an
- * unrelated accessibilityLabel.
+ * `id` on userflowId, then testID, then nativeID, then accessibilityLabel.
+ * Uses the highest tier that has any match so a testID hit is never made
+ * ambiguous by an unrelated accessibilityLabel.
  *
  * A composite match resolves to the host beneath it that carries the same id
  * (e.g. a tab item that wraps its button in a View and forwards testID to the
  * button), else to its shallowest host descendant. Multiple matches on a single
  * root-to-leaf chain (e.g. Pressable forwarding testID to its inner View)
- * collapse to the outermost host. Disjoint matches fail closed as ambiguous.
+ * collapse to the outermost host. Disjoint matches stay in the list returned by
+ * {@link findAnchorFibers}; {@link findAnchorFiber} fails closed on those.
  *
  * The walk never follows `rootFiber.sibling` so the Userflow overlay (a sibling
  * of {@link FiberScanRoot} in UserflowProvider) cannot self-match SDK testIDs.
  */
-export function findAnchorFiber(rootFiber: AnyFiber, id: string): FindAnchorFiberResult {
+export function findAnchorFibers(rootFiber: AnyFiber, id: string): FindAnchorFibersResult {
   if (!rootFiber || !id) return { status: 'missing' };
+  const won = winningTier(rootFiber, id);
+  if (!won) return { status: 'missing' };
+  return { status: 'found', fibers: won.hosts, tier: won.tier };
+}
+
+export function findAnchorFiber(rootFiber: AnyFiber, id: string): FindAnchorFiberResult {
+  const many = findAnchorFibers(rootFiber, id);
+  if (many.status === 'missing') return { status: 'missing' };
+  if (many.fibers.length === 1) {
+    return { status: 'found', fiber: many.fibers[0]!, tier: many.tier };
+  }
+  return { status: 'ambiguous', tier: many.tier };
+}
 
+function winningTier(
+  rootFiber: AnyFiber,
+  id: string,
+): { tier: AnchorPropTier; hosts: AnyFiber[] } | null {
   try {
     const byTier: Record<AnchorPropTier, AnyFiber[]> = {
+      userflowId: [],
       testID: [],
       nativeID: [],
       accessibilityLabel: [],
@@ -58,6 +88,9 @@ export function findAnchorFiber(rootFiber: AnyFiber, id: string): FindAnchorFibe
       (fiber) => {
         const props = getMemoizedProps(fiber);
         if (!props) return;
+        if (typeof props.userflowId === 'string' && props.userflowId === id) {
+          byTier.userflowId.push(fiber);
+        }
         if (typeof props.testID === 'string' && props.testID === id) {
           byTier.testID.push(fiber);
         }
@@ -72,44 +105,42 @@ export function findAnchorFiber(rootFiber: AnyFiber, id: string): FindAnchorFibe
     );
 
     if (truncated || visited >= MAX_NODES) {
-      // Truncation would otherwise look exactly like "the anchor isn't there".
-      // eslint-disable-next-line no-console -- actionable: the anchor may exist but was not reached
-      const warn = (message: string): void => console.warn(message);
-      if (__DEV__) {
-        warn(
-          `[Userflow] Anchor scan for "${id}" stopped after ${MAX_NODES} nodes. ` +
-            `The element may exist but was not reached. Register it explicitly with ` +
-            `useUserflowAnchor("${id}") to skip the scan.`,
-        );
-      } else if (!maxNodesWarned) {
-        maxNodesWarned = true;
-        warn(
-          `[Userflow] Anchor scan stopped after ${MAX_NODES} nodes; some anchors may ` +
-            `be missed. Prefer useUserflowAnchor for deep or dense trees.`,
-        );
-      }
+      warnScanTruncated(id);
     }
 
-    for (const tier of TIER_ORDER) {
+    for (const tier of ANCHOR_PROP_TIERS) {
       const matches = byTier[tier];
       if (matches.length === 0) continue;
 
       const hosts = uniqueHosts(matches);
       if (hosts.length === 0) continue;
-      if (hosts.length === 1) {
-        return { status: 'found', fiber: hosts[0]!, tier };
-      }
-
-      const collapsed = collapseToChains(hosts);
-      if (collapsed.length === 1) {
-        return { status: 'found', fiber: collapsed[0]!, tier };
-      }
-      return { status: 'ambiguous', tier };
+      return { tier, hosts: collapseToChains(hosts) };
     }
 
-    return { status: 'missing' };
+    return null;
   } catch {
-    return { status: 'missing' };
+    return null;
+  }
+}
+
+function warnScanTruncated(id: string): void {
+  // Truncation would otherwise look exactly like "the anchor isn't there".
+  // eslint-disable-next-line no-console -- actionable: the anchor may exist but was not reached
+  const warn = (message: string): void => console.warn(message);
+  if (__DEV__) {
+    warn(
+      `[Userflow] Anchor scan for "${id}" stopped after ${MAX_NODES} nodes. ` +
+        `The element may exist but was not reached. Register it explicitly with ` +
+        `useUserflowAnchor("${id}") to skip the scan.`,
+    );
+    return;
+  }
+  if (!maxNodesWarned) {
+    maxNodesWarned = true;
+    warn(
+      `[Userflow] Anchor scan stopped after ${MAX_NODES} nodes; some anchors may ` +
+        `be missed. Prefer useUserflowAnchor for deep or dense trees.`,
+    );
   }
 }
 

package/src/anchors/fiber/touchTargetFiber.ts

@@ -0,0 +1,125 @@
+/**
+ * Host fiber under a touch, resolved synchronously from the responder event.
+ *
+ * Feature-detected and never throws. A renderer that does not expose any of
+ * these pointers degrades to "no target", so a click condition simply does not
+ * latch.
+ *
+ * Order:
+ * 1. `event._targetInst` (React's fiber for the touched component)
+ * 2. `event.target` public instance via {@link lookupHostFiber}
+ * 3. The touch's native tag (`changedTouches[].target`, else `nativeEvent.target`)
+ *    via the scan-root host index
+ */
+import type { GestureResponderEvent } from 'react-native';
+
+import {
+  type AnyFiber,
+  isHostFiber,
+  isReactFiber,
+  nativeTagFromHostFiber,
+  resolveCurrentFiber,
+} from './fiberInternals';
+import { nearestHostDescendant } from './findAnchorFiber';
+import { createLazyHostFiberIndex, lookupHostFiber } from './indexHostFibers';
+
+export function touchTargetFiber(
+  event: GestureResponderEvent,
+  identifier?: number | string,
+): AnyFiber | null {
+  try {
+    const tag = nativeTagForTouch(event, identifier);
+
+    const fromInst = hostFromFiber(readTargetInst(event));
+    if (fromInst && tagMatches(fromInst, tag)) return fromInst;
+
+    const fromInstance = hostFromInstance(event.target);
+    if (fromInstance && tagMatches(fromInstance, tag)) return fromInstance;
+
+    if (tag === undefined) return null;
+    // The event-level fibers belong to another finger's view, so only the
+    // index can name this one. A miss must not fall back to theirs.
+    return createLazyHostFiberIndex()().byNativeTag.get(tag) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Fabric sends one touch event per touched view, and each lists every finger
+ * that changed. True when `identifier`'s finger is on this event's own view,
+ * so a caller can record each finger once, from its own event, instead of
+ * overwriting it from another finger's. Unreadable tags count as this event's.
+ */
+export function touchBelongsToEvent(
+  event: GestureResponderEvent,
+  identifier: number | string,
+): boolean {
+  try {
+    const tag = nativeTagForTouch(event, identifier);
+    if (tag === undefined) return true;
+    const own = hostFromFiber(readTargetInst(event)) ?? hostFromInstance(event.target);
+    return own == null || tagMatches(own, tag);
+  } catch {
+    return true;
+  }
+}
+
+function readTargetInst(event: GestureResponderEvent): unknown {
+  return (event as { _targetInst?: unknown })._targetInst;
+}
+
+function nativeTagForTouch(
+  event: GestureResponderEvent,
+  identifier: number | string | undefined,
+): number | undefined {
+  const native = event.nativeEvent as {
+    target?: unknown;
+    changedTouches?: Array<{ identifier?: number | string; target?: unknown }>;
+  };
+  if (identifier != null && native.changedTouches) {
+    const touch = native.changedTouches.find((entry) => entry.identifier === identifier);
+    const touchTag = asTag(touch?.target);
+    if (touchTag !== undefined) return touchTag;
+  }
+  return asTag(native.target);
+}
+
+function asTag(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+/**
+ * Accept a host whose tag we cannot read (test renderer, older Paper). Reject
+ * only when both sides have a tag and they differ — that event-level fiber
+ * belongs to a different finger.
+ */
+function tagMatches(fiber: AnyFiber, tag: number | undefined): boolean {
+  if (tag === undefined) return true;
+  const fiberTag = nativeTagFromHostFiber(fiber);
+  if (fiberTag === undefined) return true;
+  return fiberTag === tag;
+}
+
+function hostFromFiber(value: unknown): AnyFiber | null {
+  if (!isReactFiber(value)) return null;
+  try {
+    const current = resolveCurrentFiber(value);
+    if (isHostFiber(current)) return current;
+    return nearestHostDescendant(current);
+  } catch {
+    return null;
+  }
+}
+
+function hostFromInstance(value: unknown): AnyFiber | null {
+  if (!value || typeof value !== 'object') return null;
+  try {
+    const fiber = lookupHostFiber(createLazyHostFiberIndex(), value);
+    if (!fiber) return null;
+    if (isHostFiber(fiber)) return fiber;
+    return nearestHostDescendant(fiber);
+  } catch {
+    return null;
+  }
+}

package/src/anchors/resolveAnchorHost.ts

@@ -43,7 +43,8 @@ export function invalidateFiberAnchor(id: string): void {
  *
  * Tier 0: {@link anchorRegistry} (`useUserflowAnchor`) — higher priority, fails
  * closed on ambiguous registry keys.
- * Tier 1+: fiber scan for `testID`, then `nativeID`, then `accessibilityLabel`.
+ * Tier 1+: fiber scan for `userflowId`, then `testID`, then `nativeID`, then
+ * `accessibilityLabel`.
  *
  * Synchronous (the walk is pure JS; only measurement is async via the returned
  * host). Caches the resolved fiber per id and revalidates cheaply before reuse.

package/src/anchors/resolveAutoAnchorHost.ts

@@ -75,7 +75,7 @@ function fiberFromInstance(inst: AutoAnchorInstance): AnyFiber | null {
 }
 
 /** Authoritative id that the existing fiber / manual resolver can look up. */
-function exactIdFromFingerprint(fp: MobileFingerprint): string | null {
+export function exactIdFromFingerprint(fp: MobileFingerprint): string | null {
   if (fp.userflowId) return fp.userflowId;
   if (fp.testID) return fp.testID;
   if (fp.nativeID && !fp.nativeID.startsWith('uf_')) return fp.nativeID;
@@ -116,7 +116,7 @@ function mapMatch(match: MatchResult): AutoAnchorResolution {
  * scored and the unfiltered pool still has a hit, that hit is on a covered
  * screen — `absent`, matching MANUAL covered-screen semantics.
  */
-function mapScored(fp: MobileFingerprint): AutoAnchorResolution {
+export function resolveScoredAutoAnchor(fp: MobileFingerprint): AutoAnchorResolution {
   const visible = matchFingerprint(fp, { instanceFilter: createVisibleInstanceFilter() });
   if (visible.instance) return mapMatch(visible);
 
@@ -178,5 +178,5 @@ export function resolveAutoAnchorHost(
     }
   }
 
-  return mapScored(fp);
+  return resolveScoredAutoAnchor(fp);
 }

package/src/anchors/resolveElementTargets.ts

@@ -0,0 +1,165 @@
+/**
+ * Resolve every host an ELEMENT condition should consider.
+ *
+ * Tooltips fail closed when an id matches more than one view. Conditions follow
+ * the web SDK instead: any match counts. AUTO exact ids (`userflowId`, then
+ * `testID`, then a real `nativeID`) use that same multi-host lookup, and fall
+ * through to scoring only when nothing matched.
+ */
+import { decodeMobileAutoData, type FlowSelectorFragment } from '@userflow-tech/protocol';
+
+import { type AnchorHost, anchorRegistry } from './AnchorRegistry';
+import type { ElementTap } from './elementTapMonitor';
+import { anchorIdsAboveTap } from './elementTargetMatch';
+import { fiberScanRoot } from './fiber/FiberScanRoot';
+import { type AnyFiber, publicInstanceFromHostFiber } from './fiber/fiberInternals';
+import { findAnchorFibers } from './fiber/findAnchorFiber';
+import {
+  createLazyHostFiberIndex,
+  lookupHostFiber,
+  type HostFiberIndexSource,
+} from './fiber/indexHostFibers';
+import { createFiberMeasureInWindow } from './fiber/measureHostFiber';
+import { isFiberOnVisibleScreen } from './fiber/visibleScreens';
+import {
+  exactIdFromFingerprint,
+  resolveAutoAnchorHost,
+  resolveScoredAutoAnchor,
+  type AutoAnchorResolution,
+} from './resolveAutoAnchorHost';
+import { resolveManualAnchorId } from './resolveManualAnchorId';
+
+export interface ElementTarget {
+  host: AnchorHost;
+  fiber?: AnyFiber;
+}
+
+export type ElementTargetResolution =
+  | { status: 'found'; targets: ElementTarget[] }
+  | { status: 'absent' }
+  | {
+      status: 'unknown';
+      /**
+       * Ambiguous scored matches stay unknown without a warning. A missing
+       * selector or an AUTO payload that cannot be decoded still warns.
+       */
+      silent?: boolean;
+    };
+
+export function resolveElementTargets(
+  selector: FlowSelectorFragment | null | undefined,
+): ElementTargetResolution {
+  if (selector == null) return { status: 'unknown' };
+
+  if ((selector.type as string | null) === 'AUTO') {
+    return resolveAutoTargets(selector.autoData);
+  }
+
+  const anchorId = resolveManualAnchorId(selector.css);
+  if (anchorId == null) return { status: 'unknown' };
+  return resolveManualTargets(anchorId);
+}
+
+/**
+ * False when no target of `selector` can contain `tap`, decided without a tree
+ * scan. A fiber-scan target carries its id itself or sits under a composite
+ * that does, so a MANUAL id that is neither registered nor on the tap's
+ * ancestor chain cannot match. AUTO selectors are not gated: only a scan tells
+ * whether the exact id or a scored match applies.
+ */
+export function tapMayHitSelector(
+  selector: FlowSelectorFragment | null | undefined,
+  tap: ElementTap,
+): boolean {
+  if (selector == null) return false;
+  if ((selector.type as string | null) === 'AUTO') return true;
+
+  const anchorId = resolveManualAnchorId(selector.css);
+  if (anchorId == null) return false;
+  return anchorRegistry.get(anchorId) != null || anchorIdsAboveTap(tap).has(anchorId);
+}
+
+function resolveAutoTargets(autoData: string | null): ElementTargetResolution {
+  const decoded = decodeMobileAutoData(autoData);
+  const fingerprint = decoded?.fingerprint;
+  if (!decoded || !fingerprint) return { status: 'unknown' };
+
+  if (decoded.resolver === 'fiber' && decoded.fiberPath) {
+    return fromAutoResolution(resolveAutoAnchorHost(decoded));
+  }
+
+  const exactId = exactIdFromFingerprint(fingerprint);
+  if (exactId) {
+    const manual = resolveManualTargets(exactId);
+    if (manual.status === 'found') return manual;
+  }
+
+  // The exact id already missed above, so go straight to scoring rather than
+  // letting resolveAutoAnchorHost scan for it again.
+  return fromAutoResolution(resolveScoredAutoAnchor(fingerprint));
+}
+
+function fromAutoResolution(resolution: AutoAnchorResolution): ElementTargetResolution {
+  if (resolution.status === 'found') {
+    // Scored matches only try the direct ref pointer, which Paper release
+    // builds null out. Without the index fallback a tap could never match.
+    const fiber =
+      resolution.fiber ??
+      fiberForNode(createLazyHostFiberIndex(), resolution.match?.instance?.ref.current);
+    return {
+      status: 'found',
+      targets: [{ host: resolution.host, ...(fiber ? { fiber } : {}) }],
+    };
+  }
+  if (resolution.status === 'absent') return { status: 'absent' };
+  // Ambiguous and unknown both fail closed. Ambiguous is a real tie, not a
+  // broken selector, so it does not warn.
+  if (resolution.status === 'ambiguous') return { status: 'unknown', silent: true };
+  return { status: 'unknown' };
+}
+
+function resolveManualTargets(id: string): ElementTargetResolution {
+  const registered = anchorRegistry.getAll(id);
+  if (registered.length > 0) {
+    const index = createLazyHostFiberIndex();
+    // Registered views on a covered navigator screen still measure non-zero,
+    // so drop them here the way the fiber scan skips covered screens. A host
+    // whose fiber cannot be found is kept.
+    const targets = registered
+      .map((host): ElementTarget => {
+        const fiber = fiberForNode(index, host.node);
+        return fiber ? { host, fiber } : { host };
+      })
+      .filter((target) => !target.fiber || isFiberOnVisibleScreen(target.fiber));
+    return targets.length > 0 ? { status: 'found', targets } : { status: 'absent' };
+  }
+
+  const root = fiberScanRoot.getFiber();
+  if (!root) return { status: 'absent' };
+
+  const found = findAnchorFibers(root, id);
+  if (found.status === 'missing') return { status: 'absent' };
+
+  return {
+    status: 'found',
+    targets: found.fibers.map((fiber) => {
+      const node = publicInstanceFromHostFiber(fiber);
+      return {
+        host: {
+          measureInWindow: createFiberMeasureInWindow(fiber),
+          ...(node ? { node } : {}),
+        },
+        fiber,
+      };
+    }),
+  };
+}
+
+function fiberForNode(index: HostFiberIndexSource, node: unknown): AnyFiber | undefined {
+  if (!node) return undefined;
+  try {
+    return lookupHostFiber(index, node) ?? undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/anchors/targetPressMonitor.ts

@@ -31,6 +31,17 @@ export interface TouchPoint {
   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.
@@ -43,9 +54,7 @@ export function isTargetTap(
 ): boolean {
   if (!pointInRect(start.pageX, start.pageY, rect)) return false;
   if (!pointInRect(end.pageX, end.pageY, rect)) return false;
-  const dx = end.pageX - start.pageX;
-  const dy = end.pageY - start.pageY;
-  return dx * dx + dy * dy <= slop * slop;
+  return withinTapSlop(start, end, slop);
 }
 
 /**

package/src/anchors/useUserflowAnchor.ts

@@ -71,6 +71,7 @@ export function useUserflowAnchor(id: string): React.RefCallback<View> {
       measureInWindow: (callback) => {
         node.measureInWindow(callback);
       },
+      node,
       scrollIntoView: () => {
         const scrollable = node as View & {
           scrollIntoView?: (options?: { block?: string; inline?: string }) => void;

package/src/anonymousId.ts

@@ -1,9 +1,17 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
 import { UserflowAuthError } from '@userflow-tech/core';
 
+import { getAsyncStorage } from './storage/asyncStorage';
+
 /** Matches the web SDK's `userflow:anonymousId` localStorage key. */
 export const ANONYMOUS_ID_STORAGE_KEY = 'userflow:anonymousId';
 
+export const ANONYMOUS_STORAGE_UNAVAILABLE =
+  'Userflow.identifyAnonymous() is not supported when persistent storage is unavailable.';
+
+export const ANONYMOUS_STORAGE_NOT_LINKED =
+  'Userflow.identifyAnonymous() needs @react-native-async-storage/async-storage, which is not ' +
+  "linked in this native build. Add it to your app's package.json, run pod install, and rebuild.";
+
 export function uuid(): string {
   const webcrypto = globalThis.crypto;
   if (webcrypto?.randomUUID) return webcrypto.randomUUID();
@@ -15,24 +23,27 @@ export function uuid(): string {
 }
 
 export async function getOrCreateAnonymousId(): Promise<string> {
+  const storage = getAsyncStorage();
+  if (!storage) {
+    throw new UserflowAuthError(ANONYMOUS_STORAGE_NOT_LINKED, { isHostContract: true });
+  }
   try {
-    let externalId = await AsyncStorage.getItem(ANONYMOUS_ID_STORAGE_KEY);
+    let externalId = await storage.getItem(ANONYMOUS_ID_STORAGE_KEY);
     if (!externalId) {
       externalId = `anon-${uuid()}`;
-      await AsyncStorage.setItem(ANONYMOUS_ID_STORAGE_KEY, externalId);
+      await storage.setItem(ANONYMOUS_ID_STORAGE_KEY, externalId);
     }
     return externalId;
   } catch {
-    throw new UserflowAuthError(
-      'Userflow.identifyAnonymous() is not supported when persistent storage is unavailable.',
-      { isHostContract: true },
-    );
+    throw new UserflowAuthError(ANONYMOUS_STORAGE_UNAVAILABLE, { isHostContract: true });
   }
 }
 
 export async function clearAnonymousId(): Promise<void> {
+  const storage = getAsyncStorage();
+  if (!storage) return;
   try {
-    await AsyncStorage.removeItem(ANONYMOUS_ID_STORAGE_KEY);
+    await storage.removeItem(ANONYMOUS_ID_STORAGE_KEY);
   } catch {
     // Best-effort clear, mirroring the web SDK when storage access is denied.
   }

package/src/authoring/capturePickerScreenshot.ts

@@ -1,9 +1,12 @@
 import { Dimensions } from 'react-native';
 
+import { isNativeModuleLinked } from '../nativeModules';
+
 import type { ElementPickerScreenshot } from './elementPickerController';
 import type { HitRect } from './hitTest';
 
 const MAX_CAPTURE_WIDTH = 480;
+const VIEW_SHOT_MODULE = 'RNViewShot';
 
 const MISSING_VIEW_SHOT_WARNING =
   '[Userflow] Required peer react-native-view-shot is not installed; ' +
@@ -31,8 +34,14 @@ function warnMissingViewShot(): void {
 }
 
 function loadViewShot(): ViewShotModule | null {
+  // view-shot 4 calls TurboModuleRegistry.getEnforcing at import. Metro reports
+  // that throw as fatal before this try/catch can see it.
+  if (!isNativeModuleLinked(VIEW_SHOT_MODULE)) {
+    warnMissingViewShot();
+    return null;
+  }
   try {
-    // Required peer; degrade if unlinked or the JS package is missing.
+    // Required peer; degrade if the JS package is missing.
     // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports
     return require('react-native-view-shot') as ViewShotModule;
   } catch {

package/src/evalJs/getWebView.ts

@@ -1,5 +1,6 @@
 import type { ComponentType, Ref } from 'react';
-import { NativeModules, TurboModuleRegistry } from 'react-native';
+
+import { isNativeModuleLinked } from '../nativeModules';
 
 /**
  * Minimal surface of `react-native-webview` this spike uses.
@@ -45,20 +46,11 @@ let warnedMissing = false;
 /**
  * True when the native `react-native-webview` binary is linked. Do not
  * `require('react-native-webview')` before this passes — the JS entry calls
- * `TurboModuleRegistry.getEnforcing('RNCWebViewModule')` and can red-screen.
+ * `TurboModuleRegistry.getEnforcing('RNCWebViewModule')` and Metro reports that
+ * throw as fatal before try/catch.
  */
 export function isEvalJsWebViewNativeLinked(): boolean {
-  try {
-    if (typeof TurboModuleRegistry?.get === 'function') {
-      if (TurboModuleRegistry.get('RNCWebViewModule') != null) {
-        return true;
-      }
-    }
-    const legacy = NativeModules.RNCWebViewModule as unknown;
-    return legacy != null;
-  } catch {
-    return false;
-  }
+  return isNativeModuleLinked('RNCWebViewModule');
 }
 
 /**
@@ -101,6 +93,7 @@ export function getEvalJsWebView(): EvalJsWebViewComponent | null {
 function warnMissing(reason: 'native' | 'js' | 'unavailable'): void {
   if (warnedMissing) return;
   warnedMissing = true;
+  if (!__DEV__) return;
   if (reason === 'native') {
     console.warn(
       'Userflow: react-native-webview is listed in package.json but RNCWebViewModule is not in ' +

package/src/hostAppVersion.ts

@@ -2,7 +2,7 @@
  * Read the host app's native marketing version (store version), not the
  * SDK package version. React Native does not expose the store version on
  * `Platform`; Expo hosts may use optional expo modules; bare RN reads
- * `NativeModules.RNDeviceInfo` constants from the bundled device-info native
+ * `NativeModules.RNDeviceInfo` constants from the device-info native
  * module (after autolink + rebuild). The OS name is `Platform.OS`.
  *
  * Do not `require('react-native-device-info')` — that package throws at import
@@ -10,6 +10,8 @@
  * even inside try/catch.
  */
 
+import { isNativeModuleLinked } from './nativeModules';
+
 export type HostAppVersionSource =
   | 'expo-application'
   | 'expo-constants'
@@ -42,6 +44,10 @@ function unwrapModule(mod: unknown): Record<string, unknown> | null {
 }
 
 function tryRequireExpoApplication(): unknown {
+  // expo-application calls requireNativeModule('ExpoApplication') at import.
+  // Skip the require when that module is not registered so a missing binary
+  // cannot surface as a fatal error.
+  if (!isNativeModuleLinked('ExpoApplication')) return undefined;
   try {
     // Optional on bare RN — Metro requires a string literal.
     // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires