@userflow-tech/react-native 0.2.0 → 0.3.1

package/src/anchors/fiber/visibleRect.ts

@@ -0,0 +1,153 @@
+/**
+ * Geometry helpers for "what the user can actually see".
+ *
+ * `measureInWindow` reports a view's full layout rect, including the part
+ * scrolled under a tab bar or clipped by a ScrollView. Native hit-testing
+ * already accounts for that; the JS fallback and the tooltip tap rect do not,
+ * so they clip against scroll viewports and the topmost modal.
+ */
+import {
+  type AnyFiber,
+  getChild,
+  getHostTypeName,
+  getMemoizedProps,
+  getReturn,
+  getSibling,
+  isHostFiber,
+} from './fiberInternals';
+import { findScrollAncestors } from './findScrollAncestors';
+import { measureHostFiber } from './measureHostFiber';
+
+export interface VisibleRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+const MEASURE_TIMEOUT_MS = 400;
+
+/** Paper and Fabric names for React Native's `<Modal>`. */
+const MODAL_HOST_TYPES = new Set(['RCTModalHostView', 'ModalHostView']);
+
+type MeasureCallback = (x: number, y: number, width: number, height: number) => void;
+
+function measureFiberRect(fiber: AnyFiber): Promise<VisibleRect | null> {
+  return new Promise((resolve) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      resolve(null);
+    }, MEASURE_TIMEOUT_MS);
+    try {
+      measureHostFiber(fiber, (x, y, width, height) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        if (width <= 0 || height <= 0) {
+          resolve(null);
+          return;
+        }
+        resolve({ x, y, width, height });
+      });
+    } catch {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(null);
+    }
+  });
+}
+
+export function intersectRects(a: VisibleRect, b: VisibleRect): VisibleRect | null {
+  const x = Math.max(a.x, b.x);
+  const y = Math.max(a.y, b.y);
+  const right = Math.min(a.x + a.width, b.x + b.width);
+  const bottom = Math.min(a.y + a.height, b.y + b.height);
+  const width = right - x;
+  const height = bottom - y;
+  if (width <= 0 || height <= 0) return null;
+  return { x, y, width, height };
+}
+
+/**
+ * Intersect `rect` with every scroll viewport above `fiber` (innermost first).
+ * Returns null when the rect is entirely outside a viewport. No scroll ancestor
+ * leaves `rect` unchanged.
+ */
+export async function clipToScrollViewports(
+  fiber: AnyFiber | null,
+  rect: VisibleRect,
+): Promise<VisibleRect | null> {
+  if (!fiber) return rect;
+  let ancestors;
+  try {
+    ancestors = findScrollAncestors(fiber);
+  } catch {
+    return rect;
+  }
+  let clipped: VisibleRect | null = rect;
+  for (const ancestor of ancestors) {
+    if (!clipped || !ancestor.containerFiber) continue;
+    const viewport = await measureFiberRect(ancestor.containerFiber);
+    if (!viewport) continue;
+    clipped = intersectRects(clipped, viewport);
+  }
+  return clipped;
+}
+
+function isModalHost(fiber: AnyFiber): boolean {
+  const type = getHostTypeName(fiber);
+  return type !== undefined && MODAL_HOST_TYPES.has(type);
+}
+
+function isModalVisible(fiber: AnyFiber): boolean {
+  const props = getMemoizedProps(fiber);
+  if (!props) return true;
+  if (props.visible === false) return false;
+  return true;
+}
+
+/**
+ * The visible modal host drawn on top, or null. Later siblings win: React
+ * Native mounts a newer `<Modal>` after the previous one.
+ */
+export function topmostVisibleModalHost(root: AnyFiber | null, maxNodes = 8_000): AnyFiber | null {
+  if (!root) return null;
+  const stack: AnyFiber[] = [root];
+  let topmost: AnyFiber | null = null;
+  let visited = 0;
+  try {
+    while (stack.length > 0 && visited < maxNodes) {
+      const fiber = stack.pop();
+      if (!fiber) continue;
+      visited += 1;
+      if (fiber !== root && isHostFiber(fiber) && isModalHost(fiber) && isModalVisible(fiber)) {
+        topmost = fiber;
+      }
+      if (fiber !== root) {
+        const sibling = getSibling(fiber);
+        if (sibling) stack.push(sibling);
+      }
+      const child = getChild(fiber);
+      if (child) stack.push(child);
+    }
+  } catch {
+    return topmost;
+  }
+  return topmost;
+}
+
+/** True when `fiber` is `ancestor` or sits under it. */
+export function fiberIsUnder(fiber: AnyFiber, ancestor: AnyFiber, maxDepth = 10_000): boolean {
+  let current: AnyFiber | null = fiber;
+  for (let depth = 0; current && depth < maxDepth; depth += 1) {
+    if (current === ancestor) return true;
+    if (ancestor.alternate && current === ancestor.alternate) return true;
+    current = getReturn(current);
+  }
+  return false;
+}
+
+export type { MeasureCallback };

package/src/anchors/fiber/visibleScreens.ts

@@ -32,6 +32,7 @@ import {
   getMemoizedProps,
   getReturn,
   getSibling,
+  resolveCurrentFiber,
 } from './fiberInternals';
 
 /** Host screen types (push screens and iOS modal presentations). */
@@ -98,13 +99,17 @@ function isActive(screen: AnyFiber): boolean {
   return getMemoizedProps(screen)?.activityState === ACTIVITY_STATE_ACTIVE;
 }
 
-/**
- * Branches of `container` that are covered by another screen and so must not be
- * scanned. Empty when there is nothing to prune. Alternates are included so a
- * fiber captured on a previous render still matches.
- */
-export function coveredScreenBranches(container: AnyFiber): Set<AnyFiber> {
-  const branches: Array<{ branch: AnyFiber; screen: AnyFiber }> = [];
+interface ScreenBranch {
+  branch: AnyFiber;
+  screen: AnyFiber;
+}
+
+/** Every branch of `container` that owns a screen, and the ones currently visible. */
+function screenBranches(container: AnyFiber): {
+  branches: ScreenBranch[];
+  visible: ScreenBranch[];
+} {
+  const branches: ScreenBranch[] = [];
   let child = getChild(container);
   let guard = 0;
   while (child && guard < 200) {
@@ -114,21 +119,30 @@ export function coveredScreenBranches(container: AnyFiber): Set<AnyFiber> {
     guard += 1;
   }
 
-  const covered = new Set<AnyFiber>();
-  if (branches.length <= 1) return covered;
+  if (branches.length <= 1) return { branches, visible: branches };
 
-  let visible: Array<{ branch: AnyFiber; screen: AnyFiber }>;
   if (isStackContainer(container)) {
     // Native stack: activityState is always 2 for mounted screens; last branch
     // owns the top of the stack (including an iOS RNSModalScreen presentation).
-    visible = [branches[branches.length - 1]!];
-  } else {
-    const active = branches.filter((entry) => isActive(entry.screen));
-    // Keep every active pane (tabs + multi-visible). If none report active
-    // (transition), fall back to last sibling rather than pruning everything.
-    visible = active.length > 0 ? active : [branches[branches.length - 1]!];
+    return { branches, visible: [branches[branches.length - 1]!] };
   }
+  const active = branches.filter((entry) => isActive(entry.screen));
+  // Keep every active pane (tabs + multi-visible). If none report active
+  // (transition), fall back to last sibling rather than pruning everything.
+  return {
+    branches,
+    visible: active.length > 0 ? active : [branches[branches.length - 1]!],
+  };
+}
 
+/**
+ * Branches of `container` that are covered by another screen and so must not be
+ * scanned. Empty when there is nothing to prune. Alternates are included so a
+ * fiber captured on a previous render still matches.
+ */
+export function coveredScreenBranches(container: AnyFiber): Set<AnyFiber> {
+  const { branches, visible } = screenBranches(container);
+  const covered = new Set<AnyFiber>();
   for (const entry of branches) {
     if (visible.includes(entry)) continue;
     covered.add(entry.branch);
@@ -138,36 +152,60 @@ export function coveredScreenBranches(container: AnyFiber): Set<AnyFiber> {
   return covered;
 }
 
+/**
+ * The innermost container that hides the branch holding `fiber`, or null when
+ * `fiber` is on a visible screen. Walks outward so nested navigators are handled.
+ */
+function coveringContainer(fiber: AnyFiber): AnyFiber | null {
+  let previous: AnyFiber | null = null;
+  let current: AnyFiber = fiber;
+  for (let depth = 0; current && depth < MAX_ANCESTOR_WALK; depth += 1) {
+    if (previous && isScreenContainerFiber(current)) {
+      // A cached fiber's `return` chain can point at the previous render, whose
+      // branches still carry the old activityState. Only the committed
+      // container says which screen is visible now.
+      const container = resolveCurrentFiber(current);
+      const covered = coveredScreenBranches(container);
+      if (covered.has(previous)) return container;
+      const previousAlternate = getAlternate(previous);
+      if (previousAlternate && covered.has(previousAlternate)) return container;
+    }
+    previous = current;
+    current = getReturn(current);
+  }
+  return null;
+}
+
 /**
  * Whether `fiber` lives on a screen the user can currently see.
  *
  * Needed in addition to scan-time pruning: a resolved anchor is cached, and the
  * cache would otherwise keep serving a host after its screen was covered by a
- * newly pushed one. Walks outward so nested navigators are handled.
+ * newly pushed one.
  */
 export function isFiberOnVisibleScreen(fiber: AnyFiber): boolean {
   if (!fiber) return false;
   try {
-    let previous: AnyFiber | null = null;
-    let current: AnyFiber = fiber;
-    for (let depth = 0; current && depth < MAX_ANCESTOR_WALK; depth += 1) {
-      if (previous) {
-        // A cached fiber's `return` chain can point at the previous render, whose
-        // container still lists the old branches — so consult both alternates.
-        for (const container of [current, getAlternate(current)]) {
-          if (!container || !isScreenContainerFiber(container)) continue;
-          const covered = coveredScreenBranches(container);
-          if (covered.size === 0) continue;
-          if (covered.has(previous)) return false;
-          const previousAlternate = getAlternate(previous);
-          if (previousAlternate && covered.has(previousAlternate)) return false;
-        }
-      }
-      previous = current;
-      current = getReturn(current);
-    }
+    return coveringContainer(fiber) === null;
   } catch {
     // Visibility is a refinement; never let it break resolution.
+    return true;
+  }
+}
+
+/**
+ * When `fiber` is on a covered screen, the visible screens of the navigator
+ * that covers it, topmost first. Empty when `fiber` is visible.
+ */
+export function screensCoveringFiber(fiber: AnyFiber): AnyFiber[] {
+  if (!fiber) return [];
+  try {
+    const container = coveringContainer(fiber);
+    if (!container) return [];
+    return screenBranches(container)
+      .visible.map((entry) => entry.screen)
+      .reverse();
+  } catch {
+    return [];
   }
-  return true;
 }

package/src/anchors/fiber/walkVisibleFibers.ts

@@ -0,0 +1,65 @@
+/**
+ * Bounded DFS under a fiber that skips screens the user cannot see.
+ *
+ * Same pruning as {@link findAnchorFiber}: covered navigator branches are not
+ * visited, but their siblings still are. The walk never follows `root.sibling`,
+ * so the Userflow overlay (a sibling of FiberScanRoot) stays out of the scan.
+ */
+import { type AnyFiber, getChild, getSibling } from './fiberInternals';
+import { coveredScreenBranches, isScreenContainerFiber } from './visibleScreens';
+
+/** Same cap as the anchor scan: several mounted screens of a modest app. */
+export const WALK_VISIBLE_MAX_NODES = 60_000;
+
+export interface WalkVisibleFibersResult {
+  visited: number;
+  truncated: boolean;
+}
+
+/**
+ * Visit fibers under `root`, skipping covered screen branches.
+ * `visit` returning `false` stops the walk early.
+ */
+export function walkVisibleFibers(
+  root: AnyFiber,
+  visit: (fiber: AnyFiber) => void | false,
+  maxNodes = WALK_VISIBLE_MAX_NODES,
+): WalkVisibleFibersResult {
+  if (!root) return { visited: 0, truncated: false };
+
+  const stack: AnyFiber[] = [root];
+  const covered = new Set<AnyFiber>();
+  let visited = 0;
+
+  while (stack.length > 0 && visited < maxNodes) {
+    const fiber = stack.pop();
+    if (!fiber) continue;
+    visited += 1;
+
+    if (covered.has(fiber)) {
+      if (fiber !== root) {
+        const sibling = getSibling(fiber);
+        if (sibling) stack.push(sibling);
+      }
+      continue;
+    }
+
+    if (visit(fiber) === false) {
+      return { visited, truncated: false };
+    }
+
+    if (fiber !== root) {
+      const sibling = getSibling(fiber);
+      if (sibling) stack.push(sibling);
+    }
+    if (isScreenContainerFiber(fiber)) {
+      for (const branch of coveredScreenBranches(fiber)) {
+        covered.add(branch);
+      }
+    }
+    const child = getChild(fiber);
+    if (child) stack.push(child);
+  }
+
+  return { visited, truncated: visited >= maxNodes };
+}

package/src/anchors/isInstanceOnVisibleScreen.ts

@@ -0,0 +1,55 @@
+import type { AutoAnchorInstance } from './AutoAnchorRegistry';
+import type { AnyFiber } from './fiber/fiberInternals';
+import {
+  createLazyHostFiberIndex,
+  lookupHostFiber,
+  type HostFiberIndex,
+} from './fiber/indexHostFibers';
+import { isFiberOnVisibleScreen } from './fiber/visibleScreens';
+
+type HostFiberIndexGetter = () => HostFiberIndex;
+
+function fiberForInstance(
+  inst: AutoAnchorInstance,
+  getIndex: HostFiberIndexGetter,
+): AnyFiber | null {
+  try {
+    return lookupHostFiber(getIndex, inst.ref.current);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Whether a scored instance is on a screen the user can see.
+ *
+ * No fiber pointer means we cannot prove the host is covered (tests, and hosts
+ * whose public instance has no internals link) — same fail-open as apps without
+ * react-native-screens.
+ */
+export function isInstanceOnVisibleScreen(inst: AutoAnchorInstance): boolean {
+  const fiber = fiberForInstance(inst, createLazyHostFiberIndex());
+  if (!fiber) return true;
+  return isFiberOnVisibleScreen(fiber);
+}
+
+/**
+ * One lazy host-fiber index and one verdict per instance, for a single pass.
+ *
+ * A factory rather than an extra argument: `Array.filter` passes the index as
+ * the second parameter. Sharing the index matters on Paper release builds,
+ * where a host ref cannot reach its fiber and each lookup would otherwise walk
+ * the tree.
+ */
+export function createVisibleInstanceFilter(): (inst: AutoAnchorInstance) => boolean {
+  const getIndex = createLazyHostFiberIndex();
+  const memo = new Map<string, boolean>();
+  return (inst) => {
+    const cached = memo.get(inst.instanceId);
+    if (cached !== undefined) return cached;
+    const fiber = fiberForInstance(inst, getIndex);
+    const visible = !fiber || isFiberOnVisibleScreen(fiber);
+    memo.set(inst.instanceId, visible);
+    return visible;
+  };
+}

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

@@ -9,7 +9,8 @@ import type { AutoAnchorInstance } from './AutoAnchorRegistry';
 import type { AnyFiber } from './fiber/fiberInternals';
 import { fiberFromPublicInstance } from './fiber/fiberInternals';
 import { createFiberMeasureInWindow } from './fiber/measureHostFiber';
-import { isFiberOnVisibleScreen } from './fiber/visibleScreens';
+import { resolveFiberPath } from './fiber/resolveFiberPath';
+import { createVisibleInstanceFilter } from './isInstanceOnVisibleScreen';
 import { resolveAnchorHost } from './resolveAnchorHost';
 import { matchFingerprint, type MatchResult } from './semanticMatcher';
 
@@ -73,21 +74,8 @@ function fiberFromInstance(inst: AutoAnchorInstance): AnyFiber | null {
   return fiberFromPublicInstance(inst.ref.current);
 }
 
-/**
- * Whether a scored instance is on a screen the user can see.
- *
- * No fiber pointer means we cannot prove the host is covered (tests, and hosts
- * whose public instance has no internals link) — same fail-open as apps without
- * react-native-screens.
- */
-function isInstanceOnVisibleScreen(inst: AutoAnchorInstance): boolean {
-  const fiber = fiberFromInstance(inst);
-  if (!fiber) return true;
-  return isFiberOnVisibleScreen(fiber);
-}
-
 /** 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;
@@ -128,8 +116,8 @@ 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 {
-  const visible = matchFingerprint(fp, { instanceFilter: isInstanceOnVisibleScreen });
+export function resolveScoredAutoAnchor(fp: MobileFingerprint): AutoAnchorResolution {
+  const visible = matchFingerprint(fp, { instanceFilter: createVisibleInstanceFilter() });
   if (visible.instance) return mapMatch(visible);
 
   if (visible.reason === 'no-candidates') {
@@ -160,6 +148,20 @@ export function resolveAutoAnchorHost(
   const fp = decoded?.fingerprint;
   if (!fp) return { status: 'unknown' };
 
+  if (decoded.resolver === 'fiber' && decoded.fiberPath) {
+    const fiberHit = resolveFiberPath(decoded.fiberPath);
+    if (fiberHit.status === 'found') {
+      return {
+        status: 'found',
+        host: { measureInWindow: createFiberMeasureInWindow(fiberHit.fiber) },
+        fiber: fiberHit.fiber,
+        fiberCacheId: fiberHit.cacheId,
+      };
+    }
+    if (fiberHit.status === 'ambiguous') return { status: 'ambiguous' };
+    return { status: 'unknown' };
+  }
+
   const exactId = exactIdFromFingerprint(fp);
   if (exactId) {
     const exact = resolveAnchorHost(exactId);
@@ -176,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;
+  }
+}