@userflow-tech/react-native 0.1.1 → 0.3.0

package/src/anchors/AutoAnchorRegistry.ts

@@ -1,6 +1,14 @@
 import type { SemanticRole, SemanticSegment, SiblingDescriptor } from '@userflow-tech/protocol';
 import type { MutableRefObject, RefObject } from 'react';
 
+import { getLiveHostProps, type AnyFiber } from './fiber/fiberInternals';
+import {
+  createLazyHostFiberIndex,
+  lookupHostFiber,
+  type HostFiberIndex,
+} from './fiber/indexHostFibers';
+import { readHostPlaceholder, readHostText } from './fiber/readHostContent';
+
 /**
  * Multi-instance auto-anchor registry for Stage 3.
  *
@@ -113,11 +121,31 @@ function siblingGroupKey(inst: AutoAnchorInstance): string {
   return idx === -1 ? path : path.slice(0, idx);
 }
 
+/**
+ * What an author can see that tells this instance apart from a lookalike.
+ * Same signals `deriveIdentityStrength` calls `content`. Undefined when the
+ * instance shows nothing of its own.
+ */
+function contentSignature(inst: AutoAnchorInstance): string | undefined {
+  const parts = [inst.childText, inst.accessibilityLabel, inst.iconName, inst.imageSrc].filter(
+    (part): part is string => !!part,
+  );
+  return parts.length > 0 ? parts.join('\u0000') : undefined;
+}
+
+interface LiveContentCache {
+  fiber: AnyFiber;
+  /** Props object identity — React replaces it on every render. */
+  props: Record<string, unknown> | undefined;
+  childText: string;
+}
+
 export class AutoAnchorRegistry {
   private readonly instances = new Map<string, AutoAnchorInstance>();
   private readonly byRegistryKey = new Map<string, Set<string>>();
   private readonly byManualId = new Map<string, Set<string>>();
   private readonly byTemplatePath = new Map<string, Set<string>>();
+  private readonly liveContent = new Map<string, LiveContentCache>();
   private readonly listeners = new Set<AutoAnchorListener>();
   private notifyScheduled = false;
 
@@ -219,6 +247,10 @@ export class AutoAnchorRegistry {
   ): void {
     const inst = this.instances.get(instanceId);
     if (!inst) return;
+    // Stamped hosts call this on every render; notifying for a no-op patch
+    // re-renders registry subscribers, which re-render the stamps.
+    const keys = Object.keys(patch) as (keyof typeof patch)[];
+    if (keys.every((key) => Object.is(inst[key], patch[key]))) return;
 
     const prevIds = {
       manualId: inst.manualId,
@@ -301,6 +333,97 @@ export class AutoAnchorRegistry {
     };
   }
 
+  /**
+   * Fill `childText` (and live `testID`) from the host fiber. Live content
+   * wins when readable; the build-time hint is the fallback.
+   *
+   * Direct fiber pointers are preferred; the scan-root index is built lazily
+   * and only if some instance cannot reach its fiber that way (Paper release
+   * builds, mainly), then reused for the rest of the pass.
+   *
+   * Silent — does not notify listeners.
+   */
+  refreshLiveContent(instances?: AutoAnchorInstance[]): void {
+    const list = instances ?? this.allInstances();
+    const getIndex = createLazyHostFiberIndex();
+    const seen = new Set<string>();
+    for (const inst of list) {
+      if (seen.has(inst.instanceId)) continue;
+      seen.add(inst.instanceId);
+      this.refreshOneLiveContent(inst, getIndex);
+    }
+  }
+
+  private refreshOneLiveContent(inst: AutoAnchorInstance, getIndex: () => HostFiberIndex): void {
+    let fiber: AnyFiber | null = null;
+    try {
+      fiber = lookupHostFiber(getIndex, inst.ref.current);
+    } catch {
+      fiber = null;
+    }
+    if (!fiber) return;
+
+    let props: Record<string, unknown> | undefined;
+    try {
+      props = getLiveHostProps(fiber);
+    } catch {
+      props = undefined;
+    }
+
+    const cached = this.liveContent.get(inst.instanceId);
+    // Same fiber and same props object means no re-render since the last read,
+    // so the subtree walk would return what we already have. Matters because
+    // resolution polls this for every registered instance.
+    if (cached && cached.fiber === fiber && props !== undefined && cached.props === props) {
+      inst.childText = cached.childText;
+      return;
+    }
+
+    if (props) this.applyLiveIdentity(inst, props);
+
+    let live: string | undefined;
+    try {
+      live =
+        inst.role === 'Input'
+          ? (readHostPlaceholder(fiber) ?? readHostText(fiber))
+          : readHostText(fiber);
+    } catch {
+      live = undefined;
+    }
+
+    if (live) {
+      const changed = inst.childText !== live;
+      inst.childText = live;
+      this.liveContent.set(inst.instanceId, { fiber, props, childText: live });
+      // Text is what separates helper-rendered twins, so the group's ambiguity
+      // verdict is only trustworthy once it has been read.
+      if (changed) this.recomputeAmbiguity(inst.registryKey, inst.templatePath, inst.manualId);
+      return;
+    }
+    if (cached && cached.fiber !== fiber) {
+      this.liveContent.delete(inst.instanceId);
+    }
+  }
+
+  /**
+   * Copy `testID` off the live host so a shared `__userflowAutoAnchor` callback
+   * (helper-rendered rows) cannot pin every instance to the last render's bag.
+   * Silent — no listener notify.
+   */
+  private applyLiveIdentity(inst: AutoAnchorInstance, props: Record<string, unknown>): void {
+    const raw = props.testID;
+    const liveTestID = typeof raw === 'string' && raw.trim() ? raw.trim() : undefined;
+    if (!liveTestID || liveTestID === inst.testID) return;
+
+    const prev = { manualId: inst.manualId, userflowId: inst.userflowId, testID: inst.testID };
+    inst.testID = liveTestID;
+    if (!inst.userflowId && (!inst.manualId || inst.manualId === prev.testID)) {
+      inst.manualId = liveTestID;
+    }
+    this.refreshManualIndexes(inst, prev);
+    this.recomputeAmbiguity(inst.registryKey, inst.templatePath, inst.manualId);
+  }
+
   subscribe(listener: AutoAnchorListener): () => void {
     this.listeners.add(listener);
     return () => {
@@ -315,12 +438,30 @@ export class AutoAnchorRegistry {
     return byManual.length > 1 || byManual.some((i) => i.ambiguous);
   }
 
+  /**
+   * Whether `inst` still has a look-alike inside `include`.
+   *
+   * The stored {@link AutoAnchorInstance.ambiguous} flag is registry-wide, so a
+   * copy on a covered screen keeps it set. Visibility can only clear that, never
+   * add ambiguity: an instance the registry considers unique stays unique.
+   */
+  isAmbiguousAmong(inst: AutoAnchorInstance, include: (i: AutoAnchorInstance) => boolean): boolean {
+    if (!inst.ambiguous) return false;
+    const peers = (list: AutoAnchorInstance[]) => list.filter((i) => i === inst || include(i));
+    if (inst.manualId) return peers(this.getInstancesByManualId(inst.manualId)).length > 1;
+    return (
+      this.isTwinWithin(inst, peers(this.getInstancesByTemplatePath(inst.templatePath))) ||
+      this.isTwinWithin(inst, peers(this.getInstancesByRegistryKey(inst.registryKey)))
+    );
+  }
+
   /** Test helper — drop every instance and reset ids. */
   clear(): void {
     this.instances.clear();
     this.byRegistryKey.clear();
     this.byManualId.clear();
     this.byTemplatePath.clear();
+    this.liveContent.clear();
     this.notifyScheduled = false;
     nextInstanceSeq = 1;
   }
@@ -341,6 +482,7 @@ export class AutoAnchorRegistry {
     }
 
     this.instances.delete(instanceId);
+    this.liveContent.delete(instanceId);
     this.removeIndex(this.byRegistryKey, inst.registryKey, instanceId);
     this.removeIndex(this.byTemplatePath, inst.templatePath, instanceId);
     if (inst.manualId) this.removeIndex(this.byManualId, inst.manualId, instanceId);
@@ -373,12 +515,37 @@ export class AutoAnchorRegistry {
     }
   }
 
+  /**
+   * True when `inst` cannot be told apart from another instance in `list`.
+   * An unlabelled group only: no content of its own, or a content signature a
+   * peer shares.
+   */
+  private isTwinWithin(inst: AutoAnchorInstance, list: AutoAnchorInstance[]): boolean {
+    const unlabelled = list.length > 1 && list.every((i) => !i.manualId);
+    if (!unlabelled) return false;
+    const sig = contentSignature(inst);
+    if (!sig) return true;
+    let count = 0;
+    for (const peer of list) {
+      if (contentSignature(peer) === sig) count += 1;
+      if (count > 1) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Instances sharing a template path are only twins while they look alike.
+   * Four rows from one `field()` helper are indistinguishable at register time
+   * and separate once their labels are read, so ambiguity is decided on
+   * content, not on the shared path alone. An instance stays ambiguous when it
+   * carries no content of its own, or when a peer carries the same content.
+   */
   private recomputeAmbiguity(registryKey: string, templatePath: string, manualId?: string): void {
     const mark = (list: AutoAnchorInstance[]) => {
-      const ambiguous = list.length > 1 && list.every((i) => !i.manualId);
       for (const i of list) {
         i.ambiguous =
-          ambiguous || (i.manualId ? this.getInstancesByManualId(i.manualId).length > 1 : false);
+          this.isTwinWithin(i, list) ||
+          (i.manualId ? this.getInstancesByManualId(i.manualId).length > 1 : false);
       }
     };
     mark(this.getInstancesByRegistryKey(registryKey));

package/src/anchors/anchorChangeTicker.ts

@@ -1,4 +1,5 @@
 import { anchorRegistry } from './AnchorRegistry';
+import { autoAnchorRegistry } from './AutoAnchorRegistry';
 import { fiberScanRoot } from './fiber/FiberScanRoot';
 
 type Listener = () => void;
@@ -9,6 +10,7 @@ type Listener = () => void;
  * Fiber-resolved anchors (testID / nativeID / accessibilityLabel) do not emit
  * registry events, so we combine:
  * - {@link anchorRegistry} mount/unmount
+ * - {@link autoAnchorRegistry} mount/unmount
  * - {@link fiberScanRoot} mount/unmount
  * - screen-change notifications
  * - a slow interval that only runs while at least one listener is subscribed
@@ -17,6 +19,7 @@ class AnchorChangeTicker {
   private readonly listeners = new Set<Listener>();
   private intervalHandle: ReturnType<typeof setInterval> | null = null;
   private unsubRegistry: (() => void) | null = null;
+  private unsubAuto: (() => void) | null = null;
   private unsubScan: (() => void) | null = null;
 
   /** Poll interval while ELEMENT conditions are tracked (ms). */
@@ -51,6 +54,9 @@ class AnchorChangeTicker {
     if (!this.unsubRegistry) {
       this.unsubRegistry = anchorRegistry.subscribe(() => this.emit());
     }
+    if (!this.unsubAuto) {
+      this.unsubAuto = autoAnchorRegistry.subscribe(() => this.emit());
+    }
     if (!this.unsubScan) {
       this.unsubScan = fiberScanRoot.subscribe(() => this.emit());
     }
@@ -68,6 +74,10 @@ class AnchorChangeTicker {
       this.unsubRegistry();
       this.unsubRegistry = null;
     }
+    if (this.unsubAuto) {
+      this.unsubAuto();
+      this.unsubAuto = null;
+    }
     if (this.unsubScan) {
       this.unsubScan();
       this.unsubScan = null;

package/src/anchors/elementConditionEvaluator.ts

@@ -3,24 +3,29 @@ import type { FlowConditionFragment } from '@userflow-tech/protocol';
 
 import { anchorChangeTicker } from './anchorChangeTicker';
 import { resolveAnchorHost } from './resolveAnchorHost';
+import { resolveAutoAnchorHost } from './resolveAutoAnchorHost';
 import { resolveManualAnchorId } from './resolveManualAnchorId';
 
 /** ELEMENT states the mobile SDK can evaluate today. */
 const SUPPORTED_ELEMENT_STATES = new Set(['PRESENT', 'NOT_PRESENT']);
 
 /**
- * Evaluate ELEMENT client conditions against manual anchors and fiber-resolved
- * `testID` / `nativeID` / `accessibilityLabel` targets.
+ * Evaluate ELEMENT client conditions against manual anchors, fiber-resolved
+ * `testID` / `nativeID` / `accessibilityLabel` targets, and AUTO (codeless)
+ * selectors.
  *
- * Supports PRESENT / NOT_PRESENT for MANUAL selectors (`css` → anchor id).
- * AUTO / codeless selectors and web-interaction states (CLICK, DISABLED, …)
- * report unknown (`null`) so gated flows stay blocked rather than inventing
- * a truth value.
+ * Supports PRESENT / NOT_PRESENT for MANUAL selectors (`css` → anchor id) and
+ * AUTO selectors (`autoData` → {@link resolveAutoAnchorHost}). AUTO fails
+ * closed: `unknown` / `ambiguous` stay `null` so a gated flow never starts
+ * just because the auto-anchor registry is empty. Web-interaction states
+ * (CLICK, DISABLED, …) still report unknown.
  *
- * "Present" means `resolveAnchorHost` finds a unique host. That already skips
- * screens covered by another navigator screen, so an id on a pushed-under
- * screen counts as absent. Pixel visibility (off-screen inside a ScrollView,
- * opacity 0, etc.) would need async `measureInWindow` and is out of scope.
+ * "Present" means a unique host on a **visible** navigator screen. MANUAL
+ * goes through `resolveAnchorHost`; AUTO through `resolveAutoAnchorHost`.
+ * Both skip screens covered by another navigator screen, so an id on a
+ * pushed-under screen counts as absent. Pixel visibility (off-screen inside a
+ * ScrollView, opacity 0, etc.) would need async `measureInWindow` and is out
+ * of scope.
  *
  * Note: compares string literals rather than importing protocol enums so Jest
  * (which cannot resolve the ESM-only `@userflow-tech/protocol` package) stays
@@ -78,12 +83,20 @@ function evaluateElementCondition(
   }
 
   if ((selector.type as string | null) === 'AUTO') {
-    warnOnce(
-      condition.id,
-      `[Userflow] ELEMENT condition ${condition.id} uses an AUTO (codeless) selector; ` +
-        'manual anchors only are supported today — leaving unknown',
-    );
-    return null;
+    const resolution = resolveAutoAnchorHost(selector.autoData);
+    if (resolution.status === 'unknown') {
+      warnOnce(
+        condition.id,
+        `[Userflow] ELEMENT condition ${condition.id} uses an AUTO (codeless) selector ` +
+          'that could not be resolved; leaving unknown',
+      );
+      return null;
+    }
+    if (resolution.status === 'ambiguous') {
+      return null;
+    }
+    const present = resolution.status === 'found';
+    return elementState === 'PRESENT' ? present : !present;
   }
 
   const anchorId = resolveManualAnchorId(selector.css);

package/src/anchors/fiber/FiberScanRoot.tsx

@@ -1,57 +1,9 @@
 import * as React from 'react';
 import { StyleSheet, View } from 'react-native';
 
-import { type AnyFiber, fiberFromPublicInstance, resolveCurrentFiber } from './fiberInternals';
+import { fiberScanRoot } from './FiberScanRootStore';
 
-type Listener = () => void;
-
-/**
- * Module singleton holding the fiber under which testID / nativeID /
- * accessibilityLabel scans run. Seeded by {@link FiberScanRoot}.
- */
-class FiberScanRootStore {
-  private instance: unknown = null;
-  private readonly listeners = new Set<Listener>();
-
-  set(instance: unknown): void {
-    this.instance = instance;
-    this.emit();
-  }
-
-  clear(): void {
-    this.instance = null;
-    this.emit();
-  }
-
-  /** Current (resolved) fiber under the scan root, or null when unmounted. */
-  getFiber(): AnyFiber | null {
-    if (!this.instance) return null;
-    const fiber = fiberFromPublicInstance(this.instance);
-    if (!fiber) return null;
-    return resolveCurrentFiber(fiber);
-  }
-
-  subscribe(listener: Listener): () => void {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-
-  /** Test helper. */
-  resetForTests(): void {
-    this.instance = null;
-    this.listeners.clear();
-  }
-
-  private emit(): void {
-    for (const listener of this.listeners) {
-      listener();
-    }
-  }
-}
-
-export const fiberScanRoot = new FiberScanRootStore();
+export { fiberScanRoot } from './FiberScanRootStore';
 
 export interface FiberScanRootProps {
   children: React.ReactNode;

package/src/anchors/fiber/FiberScanRootStore.ts

@@ -0,0 +1,51 @@
+import { type AnyFiber, fiberFromPublicInstance, resolveCurrentFiber } from './fiberInternals';
+
+type Listener = () => void;
+
+/**
+ * Module singleton holding the fiber under which testID / nativeID /
+ * accessibilityLabel scans run. Seeded by {@link FiberScanRoot}.
+ */
+class FiberScanRootStore {
+  private instance: unknown = null;
+  private readonly listeners = new Set<Listener>();
+
+  set(instance: unknown): void {
+    this.instance = instance;
+    this.emit();
+  }
+
+  clear(): void {
+    this.instance = null;
+    this.emit();
+  }
+
+  /** Current (resolved) fiber under the scan root, or null when unmounted. */
+  getFiber(): AnyFiber | null {
+    if (!this.instance) return null;
+    const fiber = fiberFromPublicInstance(this.instance);
+    if (!fiber) return null;
+    return resolveCurrentFiber(fiber);
+  }
+
+  subscribe(listener: Listener): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  /** Test helper. */
+  resetForTests(): void {
+    this.instance = null;
+    this.listeners.clear();
+  }
+
+  private emit(): void {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+}
+
+export const fiberScanRoot = new FiberScanRootStore();

package/src/anchors/fiber/fiberInternals.ts

@@ -59,6 +59,163 @@ export function getMemoizedProps(fiber: AnyFiber): Record<string, unknown> | und
   return p && typeof p === 'object' ? (p as Record<string, unknown>) : undefined;
 }
 
+/**
+ * React fiber `tag` values are a small enum (ClassComponent = 1,
+ * HostComponent = 5, HostText = 6, …). Generous ceiling so a future React tag
+ * is not rejected; note this bound alone proves nothing, because Fabric native
+ * view tags also start small (2, 4, 6, …). The structural and negative checks
+ * below are what actually discriminate.
+ */
+const MAX_REACT_FIBER_TAG = 60;
+
+/** Fields only a fiber carries. */
+const FIBER_STRUCTURAL_KEYS = [
+  'child',
+  'return',
+  'sibling',
+  'stateNode',
+  'memoizedProps',
+  'alternate',
+] as const;
+
+/** Fields that mark a host node / public instance rather than a fiber. */
+function looksLikeHostNode(value: object): boolean {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const v = value as any;
+  return (
+    typeof v.__nativeTag === 'number' ||
+    typeof v._nativeTag === 'number' ||
+    '__viewConfig' in value ||
+    'viewConfig' in value ||
+    ('node' in value && 'canonical' in value)
+  );
+}
+
+/**
+ * True when `value` looks like a JS React fiber, and not a Fabric shadow node,
+ * `stateNode`, or public instance. Never throws.
+ *
+ * Fabric on current RN stores the real fiber on `__internalInstanceHandle`, so
+ * this normally passes on the first try. It exists so a renderer that stores
+ * something else there degrades to the native-tag lookup instead of silently
+ * walking a non-fiber object and reading nothing.
+ */
+export function isReactFiber(value: unknown): value is AnyFiber {
+  if (!value || typeof value !== 'object') return false;
+  try {
+    const tag = (value as { tag?: unknown }).tag;
+    if (typeof tag !== 'number' || !Number.isInteger(tag) || tag < 0 || tag > MAX_REACT_FIBER_TAG) {
+      return false;
+    }
+    if (looksLikeHostNode(value)) return false;
+    return FIBER_STRUCTURAL_KEYS.some((key) => key in value);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * If `value` is a fiber, return it. If it is a host `stateNode` that carries a
+ * fiber (Fabric `{ node, canonical: { internalInstanceHandle } }`, or the older
+ * `canonical._internalInstanceHandle`), unwrap to the fiber.
+ */
+export function coerceToFiber(value: unknown): AnyFiber | null {
+  if (isReactFiber(value)) return value;
+  if (!value || typeof value !== 'object') return null;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const v = value as any;
+    const candidates = [
+      v.canonical?.internalInstanceHandle,
+      v.canonical?._internalInstanceHandle,
+      v.internalInstanceHandle,
+    ];
+    for (const candidate of candidates) {
+      if (isReactFiber(candidate)) return candidate;
+    }
+  } catch {
+    // Feature-detection must itself never throw.
+  }
+  return null;
+}
+
+/**
+ * Native view tag on a public instance or host `stateNode`, across renderers:
+ *
+ * - `__nativeTag` — Fabric `ReactNativeElement` (RN 0.74+)
+ * - `_nativeTag` — Paper `ReactNativeFiberHostComponent`, older Fabric canonical
+ * - `canonical.nativeTag` / `canonical._nativeTag` — Fabric `stateNode`
+ */
+export function nativeTagFromNode(value: unknown): number | undefined {
+  if (!value || typeof value !== 'object') return undefined;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const v = value as any;
+    const tag =
+      v.__nativeTag ??
+      v._nativeTag ??
+      v.nativeTag ??
+      v.canonical?.nativeTag ??
+      v.canonical?._nativeTag;
+    if (typeof tag === 'number' && Number.isFinite(tag)) return tag;
+  } catch {
+    // Best-effort.
+  }
+  return undefined;
+}
+
+export function nativeTagFromHostFiber(fiber: AnyFiber): number | undefined {
+  return nativeTagFromNode(getStateNode(fiber)) ?? nativeTagFromNode(fiber);
+}
+
+/**
+ * Public host instance for a host fiber, if one exists. Covers, in order:
+ * materialized Fabric `canonical.publicInstance`, the older Fabric
+ * `canonical` host component, and the Paper `stateNode` itself (which *is*
+ * the object an app `ref` receives).
+ */
+export function publicInstanceFromHostFiber(fiber: AnyFiber): object | null {
+  try {
+    const node = getStateNode(fiber);
+    if (!node || typeof node !== 'object') return null;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const n = node as any;
+    const pub = n.canonical?.publicInstance;
+    if (pub && typeof pub === 'object') return pub as object;
+    const canonical = n.canonical;
+    if (canonical && typeof canonical === 'object' && nativeTagFromNode(canonical) !== undefined) {
+      return canonical as object;
+    }
+    if (
+      typeof n.measureInWindow === 'function' ||
+      typeof n.measure === 'function' ||
+      nativeTagFromNode(n) !== undefined
+    ) {
+      return n as object;
+    }
+  } catch {
+    // Best-effort.
+  }
+  return null;
+}
+
+/**
+ * Host props for content reads. Prefers `memoizedProps`; Fabric also keeps the
+ * last committed props on `stateNode.canonical.currentProps`.
+ */
+export function getLiveHostProps(fiber: AnyFiber): Record<string, unknown> | undefined {
+  const memo = getMemoizedProps(fiber);
+  if (memo) return memo;
+  try {
+    const node = getStateNode(fiber) as { canonical?: { currentProps?: unknown } } | null;
+    const current = node?.canonical?.currentProps;
+    if (current && typeof current === 'object') return current as Record<string, unknown>;
+  } catch {
+    // Best-effort.
+  }
+  return undefined;
+}
+
 export function getStateNode(fiber: AnyFiber): unknown {
   return fiber?.stateNode ?? null;
 }
@@ -109,16 +266,22 @@ const INSTANCE_FIBER_KEYS = [
   '_internalInstanceHandle', // older Fabric / Paper bridge
 ] as const;
 
-/** Resolve a fiber from a class or host public instance. Returns null when unavailable. */
+/**
+ * Resolve a fiber from a class or host public instance. Returns null when
+ * unavailable, and also when the stored handle is a Fabric shadow node rather
+ * than a JS fiber (callers then look up by native tag under FiberScanRoot).
+ */
 export function fiberFromPublicInstance(instance: unknown): AnyFiber | null {
   if (!instance || typeof instance !== 'object') return null;
   try {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const inst = instance as any;
     for (const key of INSTANCE_FIBER_KEYS) {
-      const handle = inst[key];
-      if (handle) return handle;
+      const fiber = coerceToFiber(inst[key]);
+      if (fiber) return fiber;
     }
+    const fromCanonical = coerceToFiber(inst.canonical?.internalInstanceHandle);
+    if (fromCanonical) return fromCanonical;
   } catch {
     // Feature-detection must itself never throw.
   }