@mobileai/react-native 0.9.26 → 0.9.28

package/lib/module/core/FiberTreeWalker.js

@@ -9,6 +9,7 @@
  *
  */
 
+import { Dimensions } from 'react-native';
 import { logger } from "../utils/logger.js";
 import { getChild, getSibling, getParent, getProps, getStateNode, getType, getDisplayName } from "./FiberAdapter.js";
 import { getActiveAlert } from "./NativeAlertInterceptor.js";
@@ -25,6 +26,7 @@ const SLIDER_TYPES = new Set(['Slider', 'RNCSlider', 'RCTSlider']);
 const PICKER_TYPES = new Set(['Picker', 'RNCPicker', 'RNPickerSelect', 'DropDownPicker', 'SelectDropdown']);
 const DATE_PICKER_TYPES = new Set(['DateTimePicker', 'RNDateTimePicker', 'DatePicker', 'RNDatePicker']);
 const TEXT_TYPES = new Set(['Text', 'RCTText']);
+const RADIO_TYPES = new Set(['Radio', 'RadioButton', 'RadioItem', 'RadioButtonItem', 'RadioGroupItem']);
 
 // Media component types for Component-Context Media Inference
 const IMAGE_TYPES = new Set(['Image', 'RCTImageView', 'ExpoImage', 'FastImage', 'CachedImage']);
@@ -33,11 +35,16 @@ const VIDEO_TYPES = new Set(['Video', 'ExpoVideo', 'RCTVideo', 'VideoPlayer', 'V
 // Known RN internal component names to skip when walking up for context
 const RN_INTERNAL_NAMES = new Set(['View', 'RCTView', 'Pressable', 'TouchableOpacity', 'TouchableHighlight', 'ScrollView', 'RCTScrollView', 'FlatList', 'SectionList', 'SafeAreaView', 'RNCSafeAreaView', 'KeyboardAvoidingView', 'Modal', 'StatusBar', 'Text', 'RCTText', 'AnimatedComponent', 'AnimatedComponentWrapper', 'Animated']);
 const LOW_SIGNAL_RUNTIME_LABELS = new Set(['button', 'buttons', 'label', 'labels', 'title', 'titles', 'name', 'text', 'value', 'values', 'content', 'card', 'cards', 'row', 'rows', 'item', 'items', 'component', 'screen']);
-
+const EXTERNALLY_LABELED_TYPES = new Set(['switch', 'radio', 'slider', 'picker', 'date-picker']);
 // ─── State Extraction ──
 
 /** Props to extract as state attributes — covers lazy devs who skip accessibility */
 const STATE_PROPS = ['value', 'checked', 'selected', 'active', 'on', 'isOn', 'toggled', 'enabled'];
+const RADIO_SELECTION_KEYS = ['checked', 'selected', 'isChecked', 'isSelected'];
+const RADIO_TRUE_VALUES = new Set(['true', 'checked', 'selected', 'on']);
+const RADIO_FALSE_VALUES = new Set(['false', 'unchecked', 'unselected', 'off']);
+const RADIO_DECORATION_PATTERN = /(indicator|icon|label|provider|context)$/i;
+const RADIO_GROUP_PATTERN = /(radiobuttongroup|radiogroup)/i;
 
 /**
  * Extract state attributes from a fiber node's props.
@@ -123,6 +130,240 @@ function getComponentName(fiber) {
   if (type.render?.name) return type.render.name;
   return null;
 }
+function hasSliderLikeSemantics(props) {
+  if (!props || typeof props !== 'object') return false;
+  if (typeof props.onSlidingComplete === 'function') return true;
+  const hasOnValueChange = typeof props.onValueChange === 'function';
+  if (!hasOnValueChange) return false;
+  const hasExplicitRange = props.minimumValue !== undefined || props.maximumValue !== undefined;
+  if (hasExplicitRange) return true;
+  const accessibilityValue = props.accessibilityValue;
+  const hasAccessibilityRange = !!accessibilityValue && typeof accessibilityValue === 'object' && (accessibilityValue.min !== undefined || accessibilityValue.max !== undefined);
+  if (hasAccessibilityRange) return true;
+  return typeof props.value === 'number';
+}
+function isScalarSelectionValue(value) {
+  return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+}
+function coerceRadioBoolean(value) {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    if (RADIO_TRUE_VALUES.has(normalized)) return true;
+    if (RADIO_FALSE_VALUES.has(normalized)) return false;
+  }
+  return undefined;
+}
+function getOwnRadioCheckedState(props) {
+  if (!props || typeof props !== 'object') return undefined;
+  if (props.accessibilityState && typeof props.accessibilityState === 'object') {
+    const accessibilityChecked = coerceRadioBoolean(props.accessibilityState.checked);
+    if (accessibilityChecked !== undefined) return accessibilityChecked;
+  }
+  for (const key of RADIO_SELECTION_KEYS) {
+    const checked = coerceRadioBoolean(props[key]);
+    if (checked !== undefined) return checked;
+  }
+  const statusChecked = coerceRadioBoolean(props.status);
+  if (statusChecked !== undefined) return statusChecked;
+  return undefined;
+}
+function getRadioSelectionValue(props) {
+  if (!props || typeof props !== 'object') return undefined;
+  return isScalarSelectionValue(props.value) ? props.value : undefined;
+}
+function isRadioGroupComponentName(name) {
+  if (!name) return false;
+  return RADIO_GROUP_PATTERN.test(name) && !/(item|option)/i.test(name);
+}
+function isRadioLikeComponentName(name) {
+  if (!name || !/radio/i.test(name)) return false;
+  if (RADIO_TYPES.has(name)) return true;
+  if (RADIO_DECORATION_PATTERN.test(name)) return false;
+  if (isRadioGroupComponentName(name)) return false;
+  return true;
+}
+function getRadioSelectionHandler(props) {
+  if (!props || typeof props !== 'object') return null;
+  if (typeof props.onValueChange === 'function') {
+    return {
+      channel: 'onValueChange',
+      handler: props.onValueChange
+    };
+  }
+  if (typeof props.onCheckedChange === 'function') {
+    return {
+      channel: 'onCheckedChange',
+      handler: props.onCheckedChange
+    };
+  }
+  if (typeof props.onChange === 'function') {
+    return {
+      channel: 'onChange',
+      handler: props.onChange
+    };
+  }
+  if (typeof props.onSelect === 'function') {
+    return {
+      channel: 'onSelect',
+      handler: props.onSelect
+    };
+  }
+  return null;
+}
+function findAncestorRadioSelectionController(fiber, maxDepth = 8) {
+  let current = getParent(fiber);
+  let depth = 0;
+  while (current && depth < maxDepth) {
+    const name = getComponentName(current);
+    const props = getProps(current);
+    const role = props.accessibilityRole || props.role;
+    const handler = getRadioSelectionHandler(props);
+    const selectedValue = isScalarSelectionValue(props.selectedValue) ? props.selectedValue : isScalarSelectionValue(props.value) ? props.value : undefined;
+    if (isRadioGroupComponentName(name) || role === 'radiogroup') {
+      return {
+        channel: handler?.channel,
+        handler: handler?.handler,
+        selectedValue
+      };
+    }
+    current = getParent(current);
+    depth++;
+  }
+  return null;
+}
+function inferRadioCheckedState(fiber, props) {
+  const ownState = getOwnRadioCheckedState(props);
+  if (ownState !== undefined) return ownState;
+  const itemValue = getRadioSelectionValue(props);
+  if (itemValue === undefined) return undefined;
+  const controller = findAncestorRadioSelectionController(fiber);
+  if (controller?.selectedValue !== undefined) {
+    return controller.selectedValue === itemValue;
+  }
+  return undefined;
+}
+function hasRadioLikeSemantics(fiber, name, props) {
+  if (!props || typeof props !== 'object') return false;
+  const role = props.accessibilityRole || props.role;
+  if (role === 'radio') return true;
+  if (!isRadioLikeComponentName(name)) return false;
+  if (typeof props.onPress === 'function' || typeof props.onLongPress === 'function') return true;
+  if (getRadioSelectionHandler(props)) return true;
+  if (getOwnRadioCheckedState(props) !== undefined) return true;
+  const itemValue = getRadioSelectionValue(props);
+  if (itemValue !== undefined && findAncestorRadioSelectionController(fiber)) return true;
+  return false;
+}
+function buildDerivedElementProps(fiber, elementType, props) {
+  const derivedProps = {
+    ...props
+  };
+  if (elementType === 'radio') {
+    const checked = inferRadioCheckedState(fiber, props);
+    if (checked !== undefined && derivedProps.checked === undefined) {
+      derivedProps.checked = checked;
+    }
+  }
+  return derivedProps;
+}
+function getInteractionSignature(elementType, props) {
+  if (!elementType || !props || typeof props !== 'object') return null;
+  if (elementType === 'pressable') {
+    if (typeof props.onPress === 'function') {
+      return {
+        type: elementType,
+        channel: 'onPress',
+        handler: props.onPress
+      };
+    }
+    if (typeof props.onLongPress === 'function') {
+      return {
+        type: elementType,
+        channel: 'onLongPress',
+        handler: props.onLongPress
+      };
+    }
+    return null;
+  }
+  if (elementType === 'text-input' && typeof props.onChangeText === 'function') {
+    return {
+      type: elementType,
+      channel: 'onChangeText',
+      handler: props.onChangeText
+    };
+  }
+  if (elementType === 'switch' && typeof props.onValueChange === 'function') {
+    return {
+      type: elementType,
+      channel: 'onValueChange',
+      handler: props.onValueChange
+    };
+  }
+  if (elementType === 'radio') {
+    if (typeof props.onPress === 'function') {
+      return {
+        type: elementType,
+        channel: 'onPress',
+        handler: props.onPress
+      };
+    }
+    const selectionHandler = getRadioSelectionHandler(props);
+    if (selectionHandler) {
+      return {
+        type: elementType,
+        channel: selectionHandler.channel,
+        handler: selectionHandler.handler
+      };
+    }
+    return null;
+  }
+  if (elementType === 'slider') {
+    if (typeof props.onSlidingComplete === 'function') {
+      return {
+        type: elementType,
+        channel: 'onSlidingComplete',
+        handler: props.onSlidingComplete
+      };
+    }
+    if (typeof props.onValueChange === 'function') {
+      return {
+        type: elementType,
+        channel: 'onValueChange',
+        handler: props.onValueChange
+      };
+    }
+    return null;
+  }
+  if (elementType === 'picker' && typeof props.onValueChange === 'function') {
+    return {
+      type: elementType,
+      channel: 'onValueChange',
+      handler: props.onValueChange
+    };
+  }
+  if (elementType === 'date-picker') {
+    if (typeof props.onChange === 'function') {
+      return {
+        type: elementType,
+        channel: 'onChange',
+        handler: props.onChange
+      };
+    }
+    if (typeof props.onDateChange === 'function') {
+      return {
+        type: elementType,
+        channel: 'onDateChange',
+        handler: props.onDateChange
+      };
+    }
+  }
+  return null;
+}
+function interactionSignaturesMatch(a, b) {
+  if (!a || !b) return false;
+  return a.channel === b.channel && a.handler === b.handler;
+}
 
 /**
  * Check if a fiber node represents an interactive element.
@@ -130,20 +371,24 @@ function getComponentName(fiber) {
 function getElementType(fiber) {
   const name = getComponentName(fiber);
   const props = getProps(fiber);
+  if (isRadioGroupComponentName(name)) return null;
 
   // Check by component name (known React Native types)
   if (name && PRESSABLE_TYPES.has(name)) return 'pressable';
   if (name && TEXT_INPUT_TYPES.has(name)) return 'text-input';
   if (name && SWITCH_TYPES.has(name)) return 'switch';
+  if (hasRadioLikeSemantics(fiber, name, props)) return 'radio';
   if (name && SLIDER_TYPES.has(name)) return 'slider';
   if (name && PICKER_TYPES.has(name)) return 'picker';
   if (name && DATE_PICKER_TYPES.has(name)) return 'date-picker';
 
   // Check by accessibilityRole (covers custom components with proper ARIA)
   const role = props.accessibilityRole || props.role;
+  if (role === 'radiogroup') return null;
+  if (role === 'radio') return 'radio';
   if (role === 'switch') return 'switch';
-  if (role === 'adjustable') return 'slider';
-  if (role === 'button' || role === 'link' || role === 'checkbox' || role === 'radio') {
+  if (role === 'adjustable' && hasSliderLikeSemantics(props)) return 'slider';
+  if (role === 'button' || role === 'link' || role === 'checkbox') {
     return 'pressable';
   }
 
@@ -153,9 +398,8 @@ function getElementType(fiber) {
   // TextInput detection by props
   if (props.onChangeText && typeof props.onChangeText === 'function') return 'text-input';
 
-  // Slider detection by props (has both onValueChange AND min/max values)
-  if (props.onSlidingComplete && typeof props.onSlidingComplete === 'function') return 'slider';
-  if (props.onValueChange && typeof props.onValueChange === 'function' && (props.minimumValue !== undefined || props.maximumValue !== undefined)) return 'slider';
+  // Slider detection by props
+  if (hasSliderLikeSemantics(props)) return 'slider';
 
   // DatePicker detection by props
   if (props.onChange && typeof props.onChange === 'function' && (props.mode === 'date' || props.mode === 'time' || props.mode === 'datetime')) return 'date-picker';
@@ -233,6 +477,7 @@ function scoreRuntimeLabel(text, source) {
   const words = normalized.split(/\s+/).filter(Boolean);
   const lowered = normalized.toLowerCase();
   if (source === 'deep-text') score += 70;
+  if (source === 'sibling-text') score += 58;
   if (source === 'accessibility') score += 80;
   if (source === 'placeholder') score += 25;
   if (source === 'context') score += 10;
@@ -254,6 +499,25 @@ function chooseBestRuntimeLabel(candidates) {
   })).filter(candidate => candidate.text).sort((a, b) => b.score - a.score)[0];
   return best?.text || null;
 }
+function extractSiblingTextLabel(fiber) {
+  const parent = getParent(fiber);
+  if (!parent) return '';
+  const candidates = [];
+  let sibling = getChild(parent);
+  while (sibling) {
+    if (sibling !== fiber) {
+      const text = extractDeepTextContent(sibling, 4);
+      if (text) {
+        candidates.push({
+          text,
+          source: 'sibling-text'
+        });
+      }
+    }
+    sibling = getSibling(sibling);
+  }
+  return chooseBestRuntimeLabel(candidates) || '';
+}
 
 /**
  * Extract raw text from React children prop.
@@ -457,13 +721,14 @@ export function walkFiberTree(rootRef, config) {
     };
   }
 
-  // Always walk from the root Fiber — inactive screens are pruned inside
-  // processNode by checking for display:none, which React Navigation applies
-  // to all inactive screens. This ensures navigation chrome (tab bar, header)
-  // is always included without hardcoding any component names.
-  const startNode = fiber;
+  // Always walk from the absolute root Fiber (HostRoot) — this ensures we
+  // capture portals, overlays, and bottom sheets mounted outside the AIAgent.
+  let startNode = fiber;
+  while (getParent(startNode)) {
+    startNode = getParent(startNode);
+  }
   if (config?.screenName) {
-    logger.debug('FiberTreeWalker', `Walk active for screen "${config.screenName}" (inactive screens pruned via display:none)`);
+    logger.debug('FiberTreeWalker', `Walk active for screen "${config.screenName}" (inactive screens pruned via display checks)`);
   }
 
   // Overlay detection is superseded by root-level walk — all visible nodes
@@ -472,7 +737,7 @@ export function walkFiberTree(rootRef, config) {
   const interactives = [];
   let currentIndex = 0;
   const hasWhitelist = config?.interactiveWhitelist && (config.interactiveWhitelist.length ?? 0) > 0;
-  function processNode(node, depth = 0, isInsideInteractive = false, ancestorOnPress = null, currentZoneId = undefined) {
+  function processNode(node, depth = 0, isInsideInteractive = false, ancestorInteractionSignature = null, currentZoneId = undefined) {
     if (!node) return '';
     const props = getProps(node);
 
@@ -492,23 +757,36 @@ export function walkFiberTree(rootRef, config) {
     if (props.activityState === 0) return '';
     if (props.pointerEvents === 'none') return '';
 
+    // Fast heuristic for inline hidden styles (avoids expensive StyleSheet.flatten)
+    // Ensures Modals/Portals that are technically mounted but visually hidden are skipped.
+    if (props.style) {
+      if (props.style.display === 'none' || props.style.opacity === 0) return '';
+      if (Array.isArray(props.style)) {
+        for (let i = props.style.length - 1; i >= 0; i--) {
+          const s = props.style[i];
+          if (s && (s.display === 'none' || s.opacity === 0)) return '';
+        }
+      }
+    }
+
     // ── Security Constraints ──
     if (props.aiIgnore === true) return '';
     if (matchesRefList(node, config?.interactiveBlacklist)) {
       let childText = '';
       let currentChild = getChild(node);
       while (currentChild) {
-        childText += processNode(currentChild, depth, isInsideInteractive);
+        childText += processNode(currentChild, depth, isInsideInteractive, ancestorInteractionSignature, currentZoneId);
         currentChild = getSibling(currentChild);
       }
       return childText;
     }
 
-    // Interactive check — nested interactives with a DIFFERENT onPress than
-    // their ancestor are separate actions (e.g. "+" button inside a dish card).
-    // Only suppress true wrapper duplicates (same onPress reference).
+    // Interactive check — nested interactives should only be suppressed when
+    // they reuse the same actionable handler as their interactive ancestor.
+    // This keeps real child controls like switches, pickers, and text inputs.
     const isWhitelisted = matchesRefList(node, config?.interactiveWhitelist);
     const elementType = getElementType(node);
+    const ownInteractionSignature = getInteractionSignature(elementType, props);
     let shouldInclude = false;
     if (hasWhitelist) {
       shouldInclude = isWhitelisted;
@@ -516,14 +794,12 @@ export function walkFiberTree(rootRef, config) {
       if (!isInsideInteractive) {
         shouldInclude = true;
       } else {
-        // Inside an ancestor interactive — only include if onPress is DIFFERENT
-        const ownOnPress = props.onPress;
-        shouldInclude = !!ownOnPress && ownOnPress !== ancestorOnPress;
+        shouldInclude = !!ownInteractionSignature && !interactionSignaturesMatch(ownInteractionSignature, ancestorInteractionSignature);
       }
     }
 
-    // Track the onPress for descendant dedup
-    const nextAncestorOnPress = shouldInclude ? props.onPress || ancestorOnPress : ancestorOnPress;
+    // Track the actionable signature for descendant dedup.
+    const nextAncestorInteractionSignature = shouldInclude ? ownInteractionSignature || ancestorInteractionSignature : ancestorInteractionSignature;
 
     // Determine if this node produces visible output (affects depth for children)
     // Only visible nodes (interactives, text, images, videos) should increment
@@ -559,7 +835,7 @@ export function walkFiberTree(rootRef, config) {
     let childrenText = '';
     let currentChild = getChild(node);
     while (currentChild) {
-      childrenText += processNode(currentChild, childDepth, isInsideInteractive || !!shouldInclude, nextAncestorOnPress, nextZoneId);
+      childrenText += processNode(currentChild, childDepth, isInsideInteractive || !!shouldInclude, nextAncestorInteractionSignature, nextZoneId);
       currentChild = getSibling(currentChild);
     }
 
@@ -569,21 +845,26 @@ export function walkFiberTree(rootRef, config) {
     }
     if (shouldInclude) {
       const resolvedType = elementType || 'pressable';
+      const derivedProps = buildDerivedElementProps(node, resolvedType, props);
       const parentContext = getNearestCustomComponentName(node);
+      const siblingTextLabel = EXTERNALLY_LABELED_TYPES.has(resolvedType) ? extractSiblingTextLabel(node) : null;
       const label = chooseBestRuntimeLabel([{
-        text: props.accessibilityLabel,
+        text: derivedProps.accessibilityLabel,
         source: 'accessibility'
       }, {
         text: extractDeepTextContent(node),
         source: 'deep-text'
       }, {
-        text: resolvedType === 'text-input' ? props.placeholder : null,
+        text: siblingTextLabel,
+        source: 'sibling-text'
+      }, {
+        text: resolvedType === 'text-input' ? derivedProps.placeholder : null,
         source: 'placeholder'
       }, {
         text: extractIconName(node),
         source: 'icon'
       }, {
-        text: props.testID || props.nativeID,
+        text: derivedProps.testID || derivedProps.nativeID,
         source: 'test-id'
       }, {
         text: parentContext && !new Set(['ScrollViewContext', 'VirtualizedListContext', 'ViewabilityHelper', 'ScrollResponder', 'AnimatedComponent', 'TouchableOpacity']).has(parentContext) ? parentContext : null,
@@ -596,20 +877,18 @@ export function walkFiberTree(rootRef, config) {
         aiPriority: props.aiPriority,
         zoneId: currentZoneId,
         fiberNode: node,
-        props: {
-          ...props
-        },
-        requiresConfirmation: props.aiConfirm === true
+        props: derivedProps,
+        requiresConfirmation: derivedProps.aiConfirm === true
       });
 
       // Build output tag with state attributes
-      const stateAttrs = extractStateAttributes(props);
+      const stateAttrs = extractStateAttributes(derivedProps);
       let attrStr = stateAttrs ? ` ${stateAttrs}` : '';
-      if (props.aiPriority) {
-        attrStr += ` aiPriority="${props.aiPriority}"`;
+      if (derivedProps.aiPriority) {
+        attrStr += ` aiPriority="${derivedProps.aiPriority}"`;
         if (currentZoneId) attrStr += ` zoneId="${currentZoneId}"`;
       }
-      if (props.aiConfirm === true) {
+      if (derivedProps.aiConfirm === true) {
         attrStr += ' aiConfirm';
       }
       const textContent = label || '';
@@ -893,4 +1172,101 @@ function resolveNativeScrollRef(fiberNode) {
   logger.debug('FiberTreeWalker', 'Could not resolve native scroll ref — returning stateNode as fallback');
   return stateNode;
 }
+
+// ─── Wireframe Capture ─────────────────────────────────────────
+
+/** Max elements to measure — keeps bridge work bounded */
+const WIREFRAME_MAX_ELEMENTS = 50;
+/** Measure this many elements per frame, then yield */
+const WIREFRAME_BATCH_SIZE = 10;
+
+/**
+ * Measure a single element on the native bridge.
+ * Returns null if the element is off-screen or unmeasurable.
+ */
+function measureElement(el) {
+  return new Promise(resolve => {
+    try {
+      const stateNode = getStateNode(el.fiberNode);
+      if (!stateNode || typeof stateNode.measure !== 'function') {
+        resolve(null);
+        return;
+      }
+      stateNode.measure((_x, _y, width, height, pageX, pageY) => {
+        if (width > 0 && height > 0) {
+          resolve({
+            type: el.type,
+            label: el.label || el.type,
+            x: pageX,
+            y: pageY,
+            width,
+            height
+          });
+        } else {
+          resolve(null);
+        }
+      });
+    } catch {
+      resolve(null);
+    }
+  });
+}
+
+/**
+ * Yield one frame so measure work doesn't block gestures/animations.
+ * Uses requestAnimationFrame where available, falls back to setTimeout(16ms).
+ */
+function yieldFrame() {
+  return new Promise(resolve => {
+    if (typeof requestAnimationFrame === 'function') {
+      requestAnimationFrame(() => resolve());
+    } else {
+      setTimeout(resolve, 16);
+    }
+  });
+}
+
+/**
+ * Capture a privacy-safe wireframe of the current screen.
+ *
+ * Performance guarantees:
+ * - Capped at WIREFRAME_MAX_ELEMENTS (50) — enough for wireframe context
+ * - Measures in batches of WIREFRAME_BATCH_SIZE (10), yielding a frame
+ *   between batches so the bridge stays free for user interactions
+ * - The caller (AIAgent) defers this via InteractionManager so it
+ *   never competes with screen transitions or gestures
+ */
+export async function captureWireframe(rootRef, config = {}) {
+  const result = walkFiberTree(rootRef, config);
+  const elements = result.interactives;
+  if (elements.length === 0) return null;
+
+  // Cap the number of elements to keep bridge work bounded
+  const capped = elements.slice(0, WIREFRAME_MAX_ELEMENTS);
+  const components = [];
+  for (let i = 0; i < capped.length; i += WIREFRAME_BATCH_SIZE) {
+    const batch = capped.slice(i, i + WIREFRAME_BATCH_SIZE);
+    const batchResults = await Promise.all(batch.map(measureElement));
+    for (const r of batchResults) {
+      if (r) components.push(r);
+    }
+
+    // Yield between batches — never monopolize the bridge
+    if (i + WIREFRAME_BATCH_SIZE < capped.length) {
+      await yieldFrame();
+    }
+  }
+  if (components.length === 0) return null;
+  const {
+    width: deviceWidth,
+    height: deviceHeight
+  } = Dimensions.get('window');
+  return {
+    screen: config.screenName || 'Unknown',
+    components,
+    deviceWidth,
+    deviceHeight,
+    capturedAt: new Date().toISOString()
+  };
+}
 //# sourceMappingURL=FiberTreeWalker.js.map