@userflow-tech/react-native 0.3.0 → 0.3.1

package/src/anchors/elementTapMonitor.ts

@@ -0,0 +1,95 @@
+/**
+ * Pass-through tap observation for ELEMENT CLICK / NOT_CLICK conditions.
+ *
+ * Many conditions can subscribe at once. Touch start/end are paired per finger
+ * and a tap is emitted only when movement stays within the same slop the
+ * tooltip target-press monitor uses. The host fiber is the one captured at
+ * touch start, before the press's setState commits a new tree.
+ *
+ * With no subscribers the monitor stores nothing, so the bridge can skip the
+ * fiber lookup entirely.
+ */
+import type { AnyFiber } from './fiber/fiberInternals';
+import { type TouchIdentifier, type TouchPoint, withinTapSlop } from './targetPressMonitor';
+
+export interface ElementTap {
+  targetFiber: AnyFiber;
+}
+
+export type ElementTapListener = (tap: ElementTap) => void;
+
+interface TouchStart extends TouchPoint {
+  targetFiber: AnyFiber | null;
+}
+
+export class ElementTapMonitor {
+  private readonly listeners = new Set<ElementTapListener>();
+  private readonly touchStarts = new Map<TouchIdentifier, TouchStart>();
+
+  get subscriberCount(): number {
+    return this.listeners.size;
+  }
+
+  subscribe(listener: ElementTapListener): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+      if (this.listeners.size === 0) {
+        this.touchStarts.clear();
+      }
+    };
+  }
+
+  handleTouchStart(
+    identifier: TouchIdentifier,
+    pageX: number,
+    pageY: number,
+    targetFiber: AnyFiber | null,
+  ): void {
+    if (this.listeners.size === 0) {
+      this.touchStarts.clear();
+      return;
+    }
+    this.touchStarts.set(identifier, { pageX, pageY, targetFiber });
+  }
+
+  /**
+   * Emit a tap when this finger started and ended within slop on a resolved
+   * host. Never claims the responder.
+   */
+  handleTouchEnd(identifier: TouchIdentifier, pageX: number, pageY: number): void {
+    const start = this.touchStarts.get(identifier) ?? null;
+    this.touchStarts.delete(identifier);
+    if (!start || this.listeners.size === 0 || !start.targetFiber) return;
+    if (!withinTapSlop(start, { pageX, pageY })) return;
+
+    const tap: ElementTap = { targetFiber: start.targetFiber };
+    for (const listener of this.listeners) {
+      // One condition's failure must not cost the others this tap, or abort
+      // the bridge's handling of the event's remaining touches.
+      try {
+        listener(tap);
+      } catch {
+        // The condition stays at its current value.
+      }
+    }
+  }
+
+  /** Drop in-progress gesture(s). Omit `identifier` to clear every finger. */
+  cancelTouch(identifier?: TouchIdentifier): void {
+    if (identifier == null) {
+      this.touchStarts.clear();
+      return;
+    }
+    this.touchStarts.delete(identifier);
+  }
+
+  /** Test helper. */
+  resetForTests(): void {
+    this.listeners.clear();
+    this.touchStarts.clear();
+  }
+}
+
+/** Shared singleton used by TargetPressBridge and the element-condition evaluator. */
+export const elementTapMonitor = new ElementTapMonitor();

package/src/anchors/elementTargetMatch.ts

@@ -0,0 +1,90 @@
+/**
+ * Compare a touch-start fiber with a host resolved later, tolerating the
+ * alternate swap a Pressable `pressed` re-render does mid-gesture.
+ */
+import type { ElementTap } from './elementTapMonitor';
+import {
+  type AnyFiber,
+  MAX_ANCESTOR_WALK,
+  getAlternate,
+  getLiveHostProps,
+  getMemoizedProps,
+  getReturn,
+} from './fiber/fiberInternals';
+import { ANCHOR_PROP_TIERS } from './fiber/findAnchorFiber';
+
+const anchorIdsByTap = new WeakMap<ElementTap, ReadonlySet<string>>();
+
+/**
+ * Anchor ids on the tapped fiber and its ancestors, built once per tap and
+ * shared by every click condition it is delivered to.
+ */
+export function anchorIdsAboveTap(tap: ElementTap): ReadonlySet<string> {
+  const cached = anchorIdsByTap.get(tap);
+  if (cached) return cached;
+
+  const ids = new Set<string>();
+  let current: AnyFiber = tap.targetFiber;
+  for (let depth = 0; current && depth < MAX_ANCESTOR_WALK; depth += 1) {
+    const props = getMemoizedProps(current);
+    if (props) {
+      for (const tier of ANCHOR_PROP_TIERS) {
+        const value = props[tier];
+        if (typeof value === 'string') ids.add(value);
+      }
+    }
+    current = getReturn(current);
+  }
+  anchorIdsByTap.set(tap, ids);
+  return ids;
+}
+
+export function sameFiber(a: AnyFiber, b: AnyFiber): boolean {
+  if (a == null || b == null) return false;
+  if (a === b) return true;
+  const aAlt = getAlternate(a);
+  const bAlt = getAlternate(b);
+  return a === bAlt || aAlt === b || (aAlt != null && aAlt === bAlt);
+}
+
+/** True when `node` is `host` or a descendant of it. */
+export function fiberIsUnder(node: AnyFiber, host: AnyFiber): boolean {
+  let current: AnyFiber = node;
+  for (let depth = 0; current && depth < MAX_ANCESTOR_WALK; depth += 1) {
+    if (sameFiber(current, host)) return true;
+    current = getReturn(current);
+  }
+  return false;
+}
+
+function fiberDisabled(fiber: AnyFiber): boolean {
+  let props: Record<string, unknown> | undefined;
+  try {
+    props = getLiveHostProps(fiber);
+  } catch {
+    return false;
+  }
+  if (!props) return false;
+  if (props.disabled === true) return true;
+  if (props['aria-disabled'] === true) return true;
+  const state = props.accessibilityState;
+  return (
+    typeof state === 'object' &&
+    state !== null &&
+    (state as { disabled?: unknown }).disabled === true
+  );
+}
+
+/**
+ * True when the tapped fiber, the matched host, or a fiber between them is
+ * disabled. Browsers do not fire `click` on a disabled control.
+ */
+export function tapPathDisabled(tapped: AnyFiber, host: AnyFiber): boolean {
+  let current: AnyFiber = tapped;
+  for (let depth = 0; current && depth < MAX_ANCESTOR_WALK; depth += 1) {
+    if (fiberDisabled(current)) return true;
+    if (sameFiber(current, host)) return false;
+    current = getReturn(current);
+  }
+  return fiberDisabled(host);
+}

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);
 }
 
 /**