@mobileai/react-native 0.9.28 → 0.9.29

package/README.md

@@ -307,14 +307,13 @@ npm install react-native-agentic-ai
 
 No native modules required by default. Works with **Expo managed workflow** out of the box — no eject needed.
 
-### Optional Dependencies
+### Screenshot Capture
 
 <details>
 <summary><b>📸 Screenshots</b> — for image/video content understanding</summary>
 
-```bash
-npx expo install react-native-view-shot
-```
+`react-native-view-shot` is a required dependency for screenshot capture and is included with
+`@mobileai/react-native`, so you do **not** need to add it separately.
 
 </details>
 
@@ -1275,7 +1274,7 @@ Tag any element with `aiPriority` to control AI visibility:
 | `date_picker(index, date)` | Set a date on a date picker |
 | `navigate(screen)` | Navigate to any screen |
 | `wait(seconds)` | Wait for loading states before acting |
-| `capture_screenshot(reason)` | Capture the screen as an image (requires `react-native-view-shot`) |
+| `capture_screenshot(reason)` | Capture the SDK root component as an image (requires `react-native-view-shot`) |
 | `done(text)` | Finish the task with a response |
 | `ask_user(question)` | Ask the user for clarification |
 | `query_knowledge(question)` | Search the knowledge base |

package/ios/MobileAIFloatingOverlayComponentView.h

@@ -0,0 +1,8 @@
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MobileAIFloatingOverlayComponentView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/MobileAIFloatingOverlayComponentView.mm

@@ -0,0 +1,44 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "MobileAIFloatingOverlayComponentView.h"
+#import <React/RCTFabricComponentsPlugins.h>
+#import <react/renderer/components/RNMobileAIOverlaySpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNMobileAIOverlaySpec/Props.h>
+#import <react/renderer/components/RNMobileAIOverlaySpec/RCTComponentViewHelpers.h>
+
+using namespace facebook::react;
+
+@implementation MobileAIFloatingOverlayComponentView
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<MobileAIFloatingOverlayComponentDescriptor>();
+}
+
++ (void)load
+{
+  [super load];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const MobileAIFloatingOverlayProps>();
+    _props = defaultProps;
+  }
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const&)props oldProps:(Props::Shared const&)oldProps
+{
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> MobileAIFloatingOverlayCls(void)
+{
+  return MobileAIFloatingOverlayComponentView.class;
+}
+
+#endif

package/lib/module/components/AIAgent.js

@@ -28,7 +28,7 @@ import { VoiceService } from "../services/VoiceService.js";
 import { AudioInputService } from "../services/AudioInputService.js";
 import { AudioOutputService } from "../services/AudioOutputService.js";
 import { TelemetryService, bindTelemetryService } from "../services/telemetry/index.js";
-import { extractTouchLabel, checkRageClick } from "../services/telemetry/TouchAutoCapture.js";
+import { extractTouchTargetMetadata, checkRageClick } from "../services/telemetry/TouchAutoCapture.js";
 import { initDeviceId, getDeviceId } from "../services/telemetry/device.js";
 import { AgentErrorBoundary } from "./AgentErrorBoundary.js";
 import { HighlightOverlay } from "./HighlightOverlay.js";
@@ -69,6 +69,29 @@ function getTooltipStorage() {
     return null;
   }
 }
+function sanitizeWireframeScreenshot(value) {
+  if (!value || typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const base64 = trimmed.startsWith('data:') ? trimmed.split(',')[1] ?? '' : trimmed;
+  return base64.length > 0 ? base64 : null;
+}
+async function captureHeatmapScreenshot(rootView) {
+  try {
+    if (!rootView) return null;
+    const viewShot = require('react-native-view-shot');
+    const captureRef = viewShot.captureRef || viewShot.default?.captureRef;
+    if (!captureRef || typeof captureRef !== 'function') return null;
+    const raw = await captureRef(rootView, {
+      format: 'jpg',
+      quality: 0.28,
+      result: 'base64'
+    });
+    return sanitizeWireframeScreenshot(raw);
+  } catch {
+    return null;
+  }
+}
 
 // ─── Props ─────────────────────────────────────────────────────
 
@@ -240,7 +263,9 @@ export function AIAgent({
         try {
           const AS = getTooltipStorage();
           await AS?.setItem('@mobileai_onboarding_completed', 'true');
-        } catch {/* graceful */}
+        } catch {
+          /* graceful */
+        }
       })();
     } else {
       setCurrentOnboardingIndex(prev => prev + 1);
@@ -272,7 +297,9 @@ export function AIAgent({
       try {
         const AS = getTooltipStorage();
         await AS?.setItem('@mobileai_tooltip_seen', 'true');
-      } catch {/* graceful */}
+      } catch {
+        /* graceful */
+      }
     })();
   }, []);
   useEffect(() => {
@@ -434,17 +461,50 @@ export function AIAgent({
       });
     });
   }, []);
-  const getResolvedScreenName = useCallback(() => {
+  const getDeepestRouteName = useCallback(state => {
+    if (!state || !Array.isArray(state.routes) || state.index == null) {
+      return null;
+    }
+    const route = state.routes[state.index];
+    if (!route) return null;
+    const nested = route.state;
+    if (nested) {
+      const nestedName = getDeepestRouteName(nested);
+      if (nestedName) return nestedName;
+    }
+    return typeof route.name === 'string' ? route.name : null;
+  }, []);
+  const resolveScreenName = useCallback(() => {
+    if (pathname) {
+      const humanizedPath = humanizeScreenName(pathname === '/' ? 'index' : pathname);
+      if (humanizedPath) return humanizedPath;
+    }
+    const navState = navRef?.getRootState?.() ?? navRef?.getState?.();
+    const deepestFromState = getDeepestRouteName(navState);
+    if (deepestFromState) {
+      const humanized = humanizeScreenName(deepestFromState);
+      if (humanized) return humanized;
+    }
     const routeName = navRef?.getCurrentRoute?.()?.name;
     if (typeof routeName === 'string' && routeName.trim().length > 0) {
-      return routeName;
+      const humanized = humanizeScreenName(routeName);
+      if (humanized) return humanized;
     }
     const telemetryScreen = telemetryRef.current?.screen;
-    if (typeof telemetryScreen === 'string' && telemetryScreen !== 'Unknown') {
+    if (typeof telemetryScreen === 'string' && telemetryScreen !== 'Unknown' && telemetryScreen.trim().length > 0) {
       return telemetryScreen;
     }
     return 'unknown';
-  }, [navRef]);
+  }, [pathname, navRef, getDeepestRouteName]);
+  const syncTelemetryScreen = useCallback(() => {
+    const screen = resolveScreenName();
+    if (screen === 'unknown') {
+      return screen;
+    }
+    telemetryRef.current?.setScreen(screen);
+    return screen;
+  }, [resolveScreenName]);
+  const getResolvedScreenName = useCallback(() => resolveScreenName(), [resolveScreenName]);
   const resolvedKnowledgeBase = useMemo(() => {
     if (knowledgeBase) return knowledgeBase;
     if (!analyticsKey) return undefined;
@@ -1289,18 +1349,14 @@ export function AIAgent({
       bindTelemetryService(telemetry);
       telemetry.start();
       // NavigationContainer is a child of AIAgent, so navRef may not be
-      // ready yet when this effect runs. Poll briefly until it's available.
+      // ready yet when this effect runs. Poll briefly until it is.
       const resolveInitialScreen = () => {
         let attempts = 0;
         const maxAttempts = 15; // 15 × 200ms = 3s max wait
         const timer = setInterval(() => {
           attempts++;
-          const route = navRef?.getCurrentRoute?.();
-          if (route?.name) {
-            const cleanName = humanizeScreenName(route.name);
-            if (cleanName) {
-              telemetry.setScreen(cleanName);
-            }
+          const cleanName = syncTelemetryScreen();
+          if (cleanName !== 'unknown') {
             clearInterval(timer);
           } else if (attempts >= maxAttempts) {
             clearInterval(timer);
@@ -1309,7 +1365,7 @@ export function AIAgent({
       };
       resolveInitialScreen();
     }); // initDeviceId
-  }, [analyticsKey, analyticsProxyUrl, analyticsProxyHeaders, bindTelemetryService, debug, navRef]);
+  }, [analyticsKey, analyticsProxyUrl, analyticsProxyHeaders, bindTelemetryService, debug, navRef, syncTelemetryScreen]);
 
   // ─── Security warnings ──────────────────────────────────────
 
@@ -1332,11 +1388,14 @@ export function AIAgent({
       if (rootViewRef.current) {
         const handle = InteractionManager.runAfterInteractions(() => {
           requestAnimationFrame(() => {
-            captureWireframe(rootViewRef, {
+            Promise.all([captureWireframe(rootViewRef, {
               screenName
-            }).then(wireframe => {
+            }), captureHeatmapScreenshot(rootViewRef.current)]).then(([wireframe, screenshot]) => {
               if (wireframe && telemetryRef.current) {
-                telemetryRef.current.trackWireframe(wireframe);
+                telemetryRef.current.trackWireframe({
+                  ...wireframe,
+                  screenshot: screenshot || undefined
+                });
               }
             }).catch(err => {
               if (debug) logger.debug('AIAgent', 'Wireframe capture failed:', err);
@@ -1378,16 +1437,13 @@ export function AIAgent({
       }
     };
     const unsubscribe = navRef.addListener('state', () => {
-      const currentRoute = navRef.getCurrentRoute?.();
-      if (currentRoute?.name) {
-        const cleanName = humanizeScreenName(currentRoute.name);
-        if (cleanName) {
-          checkScreenMilestone(cleanName);
-        }
+      const cleanName = resolveScreenName();
+      if (cleanName) {
+        checkScreenMilestone(cleanName);
       }
     });
     return () => unsubscribe?.();
-  }, [navRef, customerSuccess, isOnboardingActive, onboarding, currentOnboardingIndex, advanceOnboarding]);
+  }, [navRef, resolveScreenName, customerSuccess, isOnboardingActive, onboarding, currentOnboardingIndex, advanceOnboarding]);
 
   // ─── MCP Bridge ──────────────────────────────────────────────
 
@@ -1424,7 +1480,7 @@ export function AIAgent({
         setProactiveStage('badge');
       },
       onReset: () => setProactiveStage('hidden'),
-      generateSuggestion: () => proactiveHelp?.generateSuggestion?.(telemetryRef.current?.screen || 'Home') || proactiveHelp?.badgeText || "Need help with this screen?",
+      generateSuggestion: () => proactiveHelp?.generateSuggestion?.(telemetryRef.current?.screen || 'Home') || proactiveHelp?.badgeText || 'Need help with this screen?',
       behaviorTriggers: proactiveHelp?.behaviorTriggers
     });
     return () => {
@@ -2187,29 +2243,46 @@ export function AIAgent({
           // Skip if the AI agent is currently executing a tool — those are
           // already tracked as `agent_step` events with full context.
           if (telemetryRef.current && !telemetryRef.current.isAgentActing) {
-            const label = extractTouchLabel(event);
-            if (label && label !== 'Unknown Element' && label !== '[pressable]') {
+            syncTelemetryScreen();
+            const target = extractTouchTargetMetadata(event);
+            const pageX = Math.round(event.nativeEvent.pageX);
+            const pageY = Math.round(event.nativeEvent.pageY);
+            if (target.label) {
               telemetryRef.current.track('user_action', {
                 canonical_type: 'button_tapped',
                 type: 'tap',
-                action: label,
-                label,
-                element_label: label,
+                action: target.label,
+                label: target.label,
+                element_label: target.label,
+                element_kind: target.elementKind,
+                label_confidence: target.labelConfidence,
+                zone_id: target.zoneId,
+                ancestor_path: target.ancestorPath,
+                sibling_labels: target.siblingLabels,
+                component_name: target.componentName,
                 actor: 'user',
-                x: Math.round(event.nativeEvent.pageX),
-                y: Math.round(event.nativeEvent.pageY)
+                x: pageX,
+                y: pageY
               });
 
               // Track if user is rage-tapping this specific element
-              checkRageClick(label, telemetryRef.current);
+              checkRageClick({
+                ...target,
+                x: pageX,
+                y: pageY
+              }, telemetryRef.current);
             } else {
               // Tapped an unlabelled/empty area
               telemetryRef.current.track('dead_click', {
                 canonical_type: 'dead_click_detected',
-                x: Math.round(event.nativeEvent.pageX),
-                y: Math.round(event.nativeEvent.pageY),
+                x: pageX,
+                y: pageY,
                 screen: telemetryRef.current.screen,
-                screen_area: 'unknown'
+                screen_area: 'unknown',
+                zone_id: target.zoneId,
+                ancestor_path: target.ancestorPath,
+                sibling_labels: target.siblingLabels,
+                component_name: target.componentName
               });
             }
           }

package/lib/module/core/AgentRuntime.js

@@ -442,14 +442,14 @@ export class AgentRuntime {
     // capture_screenshot — on-demand visual capture (for image/video content questions)
     this.tools.set('capture_screenshot', {
       name: 'capture_screenshot',
-      description: 'Capture a screenshot of the current screen. Use when the user asks about visual content (images, videos, colors, layout appearance) that cannot be determined from the element tree alone.',
+      description: 'Capture the SDK root component as an image. Use when the user asks about visual content (images, videos, colors, layout appearance) that cannot be determined from the element tree alone.',
       parameters: {},
       execute: async () => {
         const screenshot = await this.captureScreenshot();
         if (screenshot) {
           return `✅ Screenshot captured (${Math.round(screenshot.length / 1024)}KB). Visual content is now available for analysis.`;
         }
-        return '❌ Screenshot capture failed. react-native-view-shot may not be installed.';
+        return '❌ Screenshot capture failed. react-native-view-shot is required and must be installed in your app.';
       }
     });
 
@@ -676,12 +676,12 @@ export class AgentRuntime {
     }
   }
 
-  // ─── Screenshot Capture (optional react-native-view-shot) ─────
+  // ─── Screenshot Capture (react-native-view-shot) ─────
 
   /**
-   * Captures the current screen as a base64 JPEG for Gemini vision.
-   * Uses react-native-view-shot as an optional peer dependency.
-   * Returns null if the library is not installed (graceful fallback).
+   * Captures the root component as a base64 JPEG for vision tools.
+   * Uses react-native-view-shot as a required peer dependency.
+   * Returns null only when capture is temporarily unavailable.
    */
   async captureScreenshot() {
     try {
@@ -699,7 +699,7 @@ export class AgentRuntime {
       return uri || undefined;
     } catch (error) {
       if (error.message?.includes('Cannot find module') || error.code === 'MODULE_NOT_FOUND' || error.message?.includes('unknown module')) {
-        logger.warn('AgentRuntime', 'Screenshot requires react-native-view-shot. Install with: npx expo install react-native-view-shot');
+        logger.warn('AgentRuntime', 'Screenshot requires react-native-view-shot. It is a peer dependency; install it in your host app with: npx expo install react-native-view-shot');
       } else {
         logger.debug('AgentRuntime', `Screenshot skipped: ${error.message}`);
       }

package/lib/module/core/FiberTreeWalker.js

@@ -13,6 +13,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";
+import { chooseBestAnalyticsTarget, getAnalyticsElementKind } from "../services/telemetry/analyticsLabeling.js";
 
 // ─── Walk Configuration ─────────
 
@@ -130,6 +131,69 @@ function getComponentName(fiber) {
   if (type.render?.name) return type.render.name;
   return null;
 }
+function getCustomAncestorPath(fiber, maxDepth = 6) {
+  const path = [];
+  const seen = new Set();
+  let current = getParent(fiber);
+  let depth = 0;
+  while (current && depth < maxDepth) {
+    const name = getComponentName(current);
+    const props = getProps(current);
+    const candidate = name === 'AIZone' && typeof props.id === 'string' && props.id.trim() ? props.id.trim() : name;
+    if (candidate && !RN_INTERNAL_NAMES.has(candidate) && !PRESSABLE_TYPES.has(candidate) && !seen.has(candidate)) {
+      path.push(candidate);
+      seen.add(candidate);
+    }
+    current = getParent(current);
+    depth++;
+  }
+  return path;
+}
+function getAnalyticsTargetForNode(fiber, resolvedType) {
+  const props = getProps(fiber);
+  const siblingTextLabel = resolvedType && EXTERNALLY_LABELED_TYPES.has(resolvedType) ? extractSiblingTextLabel(fiber) : null;
+  return chooseBestAnalyticsTarget([{
+    text: props.accessibilityLabel,
+    source: 'accessibility'
+  }, {
+    text: extractDeepTextContent(fiber),
+    source: 'deep-text'
+  }, {
+    text: siblingTextLabel,
+    source: 'sibling-text'
+  }, {
+    text: props.title,
+    source: 'title'
+  }, {
+    text: resolvedType === 'text-input' ? props.placeholder : null,
+    source: 'placeholder'
+  }, {
+    text: props.testID || props.nativeID,
+    source: 'test-id'
+  }], getAnalyticsElementKind(resolvedType));
+}
+function getSiblingAnalyticsLabels(fiber, maxLabels = 6) {
+  const parent = getParent(fiber);
+  if (!parent) return [];
+  const labels = [];
+  const seen = new Set();
+  let sibling = getChild(parent);
+  while (sibling) {
+    if (sibling !== fiber) {
+      const siblingType = getElementType(sibling);
+      if (siblingType && !isDisabled(sibling)) {
+        const label = getAnalyticsTargetForNode(sibling, siblingType).label;
+        if (label && !seen.has(label.toLowerCase())) {
+          labels.push(label);
+          seen.add(label.toLowerCase());
+          if (labels.length >= maxLabels) break;
+        }
+      }
+    }
+    sibling = getSibling(sibling);
+  }
+  return labels;
+}
 function hasSliderLikeSemantics(props) {
   if (!props || typeof props !== 'object') return false;
   if (typeof props.onSlidingComplete === 'function') return true;
@@ -421,7 +485,7 @@ function isDisabled(fiber) {
  * Recursively extract ALL text content from a fiber's children.
  * Pierces through nested interactive elements — unlike typical tree walkers
  * that stop at inner Pressable/TouchableOpacity boundaries.
- * 
+ *
  * This is critical for wrapper components (e.g. ZButton → internal
  * TouchableOpacity → Text) where stopping at nested interactives
  * would lose the text label entirely.
@@ -464,7 +528,7 @@ function isIconGlyph(text) {
   const trimmed = text.trim();
   if (trimmed.length === 0 || trimmed.length > 2) return false; // Glyphs are 1-2 chars (surrogate pairs)
   const code = trimmed.codePointAt(0) || 0;
-  return code >= 0xE000 && code <= 0xF8FF || code >= 0xF0000 && code <= 0xFFFFF || code >= 0x100000 && code <= 0x10FFFF;
+  return code >= 0xe000 && code <= 0xf8ff || code >= 0xf0000 && code <= 0xfffff || code >= 0x100000 && code <= 0x10ffff;
 }
 function normalizeRuntimeLabel(text) {
   if (!text) return '';
@@ -541,11 +605,11 @@ function extractRawText(children) {
 /**
  * Recursively search a fiber subtree for icon/symbol components and
  * return their `name` prop as a semantic label.
- * 
+ *
  * Works generically: any non-RN-internal child component with a string
  * `name` prop is treated as an icon (covers Ionicons, MaterialIcons,
  * FontAwesome, custom SVG wrappers, etc. — no hardcoded list needed).
- * 
+ *
  * e.g. a TouchableOpacity wrapping <Ionicons name="add-circle" /> → "icon:add-circle"
  */
 function extractIconName(fiber, maxDepth = 5) {
@@ -870,6 +934,28 @@ export function walkFiberTree(rootRef, config) {
         text: parentContext && !new Set(['ScrollViewContext', 'VirtualizedListContext', 'ViewabilityHelper', 'ScrollResponder', 'AnimatedComponent', 'TouchableOpacity']).has(parentContext) ? parentContext : null,
         source: 'context'
       }]);
+      const analyticsTarget = chooseBestAnalyticsTarget([{
+        text: derivedProps.accessibilityLabel,
+        source: 'accessibility'
+      }, {
+        text: extractDeepTextContent(node),
+        source: 'deep-text'
+      }, {
+        text: siblingTextLabel,
+        source: 'sibling-text'
+      }, {
+        text: derivedProps.title,
+        source: 'title'
+      }, {
+        text: resolvedType === 'text-input' ? derivedProps.placeholder : null,
+        source: 'placeholder'
+      }, {
+        text: derivedProps.testID || derivedProps.nativeID,
+        source: 'test-id'
+      }], getAnalyticsElementKind(resolvedType));
+      const ancestorPath = getCustomAncestorPath(node);
+      const siblingLabels = getSiblingAnalyticsLabels(node);
+      const componentName = getComponentName(node);
       interactives.push({
         index: currentIndex,
         type: resolvedType,
@@ -878,7 +964,14 @@ export function walkFiberTree(rootRef, config) {
         zoneId: currentZoneId,
         fiberNode: node,
         props: derivedProps,
-        requiresConfirmation: derivedProps.aiConfirm === true
+        requiresConfirmation: derivedProps.aiConfirm === true,
+        analyticsLabel: analyticsTarget.label,
+        analyticsElementKind: analyticsTarget.elementKind,
+        analyticsLabelConfidence: analyticsTarget.labelConfidence,
+        analyticsZoneId: currentZoneId,
+        analyticsAncestorPath: ancestorPath,
+        analyticsSiblingLabels: siblingLabels,
+        analyticsComponentName: componentName
       });
 
       // Build output tag with state attributes
@@ -1080,7 +1173,7 @@ export function findScrollableContainers(rootRef, screenName) {
       const contextLabel = getNearestCustomComponentName(node) || name || 'Unknown';
 
       // For scrollable containers, we need the native scroll ref.
-      // FlatList Fiber stateNode may be the component instance — 
+      // FlatList Fiber stateNode may be the component instance —
       // we need to find the underlying native ScrollView.
       let scrollRef = isPagerLike ? getStateNode(node) : resolveNativeScrollRef(node);
       if (scrollRef) {
@@ -1109,13 +1202,13 @@ export function findScrollableContainers(rootRef, screenName) {
 
 /**
  * Resolve the native scroll view reference from a Fiber node.
- * 
+ *
  * Handles multiple React Native internals:
  * - RCTScrollView: stateNode IS the native scroll view
  * - FlatList/VirtualizedList: stateNode is a component instance,
  *   need to find the inner ScrollView via getNativeScrollRef() or
  *   by walking down the Fiber tree to find the RCTScrollView child
-*/
+ */
 function resolveNativeScrollRef(fiberNode) {
   const stateNode = getStateNode(fiberNode);
 
@@ -1129,7 +1222,9 @@ function resolveNativeScrollRef(fiberNode) {
     try {
       const ref = stateNode.getNativeScrollRef();
       if (ref && typeof ref.scrollTo === 'function') return ref;
-    } catch {/* fall through */}
+    } catch {
+      /* fall through */
+    }
   }
 
   // Case 3: stateNode has getScrollRef (another VirtualizedList pattern)
@@ -1142,7 +1237,9 @@ function resolveNativeScrollRef(fiberNode) {
         const nativeRef = ref.getNativeScrollRef();
         if (nativeRef && typeof nativeRef.scrollTo === 'function') return nativeRef;
       }
-    } catch {/* fall through */}
+    } catch {
+      /* fall through */
+    }
   }
 
   // Case 4: stateNode has scrollToOffset directly (VirtualizedList instance)
@@ -1196,7 +1293,13 @@ function measureElement(el) {
         if (width > 0 && height > 0) {
           resolve({
             type: el.type,
-            label: el.label || el.type,
+            label: el.analyticsLabel || '',
+            elementKind: el.analyticsElementKind,
+            labelConfidence: el.analyticsLabelConfidence,
+            zoneId: el.analyticsZoneId,
+            ancestorPath: el.analyticsAncestorPath,
+            siblingLabels: el.analyticsSiblingLabels,
+            componentName: el.analyticsComponentName,
             x: pageX,
             y: pageY,
             width,

package/lib/module/services/telemetry/TouchAutoCapture.js

@@ -16,6 +16,9 @@
 
 // React Native imports not needed — we use Fiber internals directly
 
+import { chooseBestAnalyticsTarget, getAnalyticsElementKind } from "./analyticsLabeling.js";
+import { getChild, getDisplayName, getParent, getProps, getSibling, getType } from "../../core/FiberAdapter.js";
+
 // ─── Rage Click Detection ──────────────────────────────────────────
 //
 // Industry-standard approach (FullStory, PostHog, LogRocket):
@@ -31,6 +34,158 @@ const MAX_TAP_BUFFER = 8;
 
 // Labels that are naturally tapped multiple times in sequence (wizards, onboarding, etc.)
 const NAVIGATION_LABELS = new Set(['next', 'continue', 'skip', 'back', 'done', 'ok', 'cancel', 'previous', 'dismiss', 'close', 'got it', 'confirm', 'proceed', 'التالي', 'متابعة', 'تخطي', 'رجوع', 'تم', 'إلغاء', 'إغلاق', 'حسناً']);
+const INTERACTIVE_PROP_KEYS = new Set(['onPress', 'onPressIn', 'onPressOut', 'onLongPress', 'onValueChange', 'onChangeText', 'onChange', 'onBlur', 'onFocus', 'onSubmitEditing', 'onScrollToTop', 'onDateChange', 'onValueChangeComplete', 'onSlidingComplete', 'onRefresh', 'onEndEditing', 'onSelect', 'onCheckedChange']);
+const INTERACTIVE_ROLES = new Set(['button', 'link', 'menuitem', 'tab', 'checkbox', 'switch', 'radio', 'slider', 'search', 'text', 'textbox']);
+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']);
+function isInteractiveNode(props, typeName) {
+  if (!props || typeof props !== 'object') return false;
+  for (const key of Object.keys(props)) {
+    if (INTERACTIVE_PROP_KEYS.has(key) && typeof props[key] === 'function') {
+      return true;
+    }
+  }
+  const role = props.accessibilityRole;
+  if (typeof role === 'string' && INTERACTIVE_ROLES.has(role.toLowerCase())) {
+    return true;
+  }
+  if (!typeName) return false;
+  const normalizedType = typeName.toLowerCase();
+  return normalizedType.includes('pressable') || normalizedType.includes('touchable') || normalizedType.includes('button') || normalizedType.includes('textfield') || normalizedType.includes('textinput') || normalizedType.includes('switch') || normalizedType.includes('checkbox') || normalizedType.includes('slider') || normalizedType.includes('picker') || normalizedType.includes('datepicker');
+}
+function getComponentName(fiber) {
+  const type = getType(fiber);
+  if (!type) return null;
+  if (typeof type === 'string') return type;
+  const displayName = getDisplayName(fiber);
+  if (displayName) return displayName;
+  if (type.name) return type.name;
+  if (type.render?.displayName) return type.render.displayName;
+  if (type.render?.name) return type.render.name;
+  return null;
+}
+function getZoneId(fiber, maxDepth = 8) {
+  let current = fiber;
+  let depth = 0;
+  while (current && depth < maxDepth) {
+    const name = getComponentName(current);
+    const props = getProps(current);
+    if (name === 'AIZone' && typeof props.id === 'string' && props.id.trim().length > 0) {
+      return props.id.trim();
+    }
+    current = getParent(current);
+    depth++;
+  }
+  return null;
+}
+function getAncestorPath(fiber, maxDepth = 6) {
+  const labels = [];
+  const seen = new Set();
+  let current = getParent(fiber);
+  let depth = 0;
+  while (current && depth < maxDepth) {
+    const name = getComponentName(current);
+    const props = getProps(current);
+    const candidate = name === 'AIZone' && typeof props.id === 'string' && props.id.trim() ? props.id.trim() : name;
+    if (candidate && !RN_INTERNAL_NAMES.has(candidate) && !seen.has(candidate)) {
+      labels.push(candidate);
+      seen.add(candidate);
+    }
+    current = getParent(current);
+    depth++;
+  }
+  return labels;
+}
+function getLabelForFiberNode(fiber) {
+  const props = getProps(fiber);
+  return chooseBestAnalyticsTarget([{
+    text: props.accessibilityLabel,
+    source: 'accessibility'
+  }, {
+    text: props.title,
+    source: 'title'
+  }, {
+    text: props.placeholder,
+    source: 'placeholder'
+  }, {
+    text: props.testID,
+    source: 'test-id'
+  }, {
+    text: typeof props.children === 'string' ? props.children : Array.isArray(props.children) ? findTextInChildren(props.children) : props.children && typeof props.children === 'object' ? findTextInChildren([props.children]) : null,
+    source: 'deep-text'
+  }], getAnalyticsElementKind(props.accessibilityRole || getComponentName(fiber))).label;
+}
+function getSiblingLabels(fiber, maxLabels = 6) {
+  const parent = getParent(fiber);
+  if (!parent) return [];
+  const labels = [];
+  const seen = new Set();
+  let sibling = getChild(parent);
+  while (sibling) {
+    if (sibling !== fiber) {
+      const siblingProps = getProps(sibling);
+      const siblingName = getComponentName(sibling) || undefined;
+      if (isInteractiveNode(siblingProps, siblingName)) {
+        const label = getLabelForFiberNode(sibling);
+        if (label && !seen.has(label.toLowerCase())) {
+          labels.push(label);
+          seen.add(label.toLowerCase());
+          if (labels.length >= maxLabels) break;
+        }
+      }
+    }
+    sibling = getSibling(sibling);
+  }
+  return labels;
+}
+function addCandidatesFromProps(candidates, props, isInteractiveContext = false) {
+  if (!props) return;
+  const candidateSources = [{
+    source: 'accessibility',
+    text: props.accessibilityLabel
+  }, {
+    source: 'title',
+    text: props.title
+  }, {
+    source: 'placeholder',
+    text: props.placeholder
+  }, {
+    source: 'test-id',
+    text: props.testID
+  }];
+  for (const item of candidateSources) {
+    if (!item.text) continue;
+    candidates.push({
+      text: item.text,
+      source: item.source,
+      isInteractiveContext
+    });
+  }
+  if (typeof props.children === 'string' && props.children.trim()) {
+    candidates.push({
+      text: props.children.trim(),
+      source: 'deep-text',
+      isInteractiveContext
+    });
+  } else if (Array.isArray(props.children)) {
+    const text = findTextInChildren(props.children);
+    if (text) {
+      candidates.push({
+        text,
+        source: 'deep-text',
+        isInteractiveContext
+      });
+    }
+  } else if (props.children && typeof props.children === 'object') {
+    const text = findTextInChildren([props.children]);
+    if (text) {
+      candidates.push({
+        text,
+        source: 'deep-text',
+        isInteractiveContext
+      });
+    }
+  }
+}
 function isNavigationLabel(label) {
   return NAVIGATION_LABELS.has(label.toLowerCase().trim());
 }
@@ -43,7 +198,10 @@ function isNavigationLabel(label) {
  * 2. Taps must be on the SAME screen (screen change = not rage, it's navigation)
  * 3. Navigation labels ("Next", "Skip", etc.) are excluded
  */
-export function checkRageClick(label, telemetry) {
+export function checkRageClick(target, telemetry) {
+  const label = target.label;
+  if (!label) return;
+
   // Skip navigation-style labels — sequential tapping is by design
   if (isNavigationLabel(label)) return;
   const now = Date.now();
@@ -64,8 +222,16 @@ export function checkRageClick(label, telemetry) {
       canonical_type: 'rage_click_detected',
       label,
       element_label: label,
+      element_kind: target.elementKind,
+      label_confidence: target.labelConfidence,
+      zone_id: target.zoneId,
+      ancestor_path: target.ancestorPath,
+      sibling_labels: target.siblingLabels,
+      component_name: target.componentName,
       count: matching.length,
-      screen: currentScreen
+      screen: currentScreen,
+      x: target.x,
+      y: target.y
     });
     // Reset buffer after emitting to avoid duplicate rage events
     recentTaps.length = 0;
@@ -78,69 +244,90 @@ export function checkRageClick(label, telemetry) {
  * @param event - The GestureResponderEvent from onStartShouldSetResponderCapture
  * @returns A descriptive label string for the tapped element
  */
-export function extractTouchLabel(event) {
+export function extractTouchTargetMetadata(event) {
   const target = event?.nativeEvent?.target;
-  if (!target) return 'Unknown Element';
+  if (!target) {
+    return {
+      label: null,
+      elementKind: 'unknown',
+      labelConfidence: 'low'
+    };
+  }
   try {
     let fiber = event?._targetInst || getFiberFromNativeTag(target);
     if (fiber) {
       let current = fiber;
       let depth = 0;
       const MAX_DEPTH = 12;
-      let bestLabel = null;
-      let detectedRole = null;
+      let foundInteractive = false;
+      const candidates = [];
+      let detectedKind = getAnalyticsElementKind(null);
+      let interactiveFiber = null;
       while (current && depth < MAX_DEPTH) {
+        const props = current.memoizedProps;
+        const typeName = current.type?.name || current.type?.displayName;
+        const nodeInteractive = isInteractiveNode(props, typeName);
+        if (nodeInteractive) {
+          foundInteractive = true;
+          interactiveFiber = current;
+        }
         // 1. Detect Component Type Context
-        if (!detectedRole) {
-          if (current.memoizedProps?.accessibilityRole) {
-            detectedRole = current.memoizedProps.accessibilityRole;
-          } else if (current.memoizedProps?.onValueChange && typeof current.memoizedProps?.value === 'boolean') {
-            detectedRole = 'Toggle/Switch';
-          } else if (current.memoizedProps?.onChangeText) {
-            detectedRole = 'TextInput';
-          } else if (current.memoizedProps?.onPress) {
-            detectedRole = 'Button';
-          } else if (current.type?.name || current.type?.displayName) {
-            const name = current.type.name || current.type.displayName;
-            if (typeof name === 'string' && name.length > 2 && !name.toLowerCase().includes('wrapper') && !name.startsWith('RCT')) {
-              detectedRole = name;
-            }
+        if (detectedKind === 'unknown') {
+          if (props?.accessibilityRole) {
+            detectedKind = getAnalyticsElementKind(props.accessibilityRole);
+          } else if (props?.onValueChange && typeof props?.value === 'boolean') {
+            detectedKind = 'toggle';
+          } else if (props?.onChangeText) {
+            detectedKind = 'text_input';
+          } else if (props?.onPress) {
+            detectedKind = 'button';
+          } else if (typeName) {
+            detectedKind = getAnalyticsElementKind(typeName);
           }
         }
+        if (!props) {
+          break;
+        }
+        addCandidatesFromProps(candidates, props, nodeInteractive);
 
-        // 2. Detect String Label Output
-        if (!bestLabel) {
-          if (current.memoizedProps?.accessibilityLabel) {
-            bestLabel = current.memoizedProps.accessibilityLabel;
-          } else if (current.memoizedProps?.testID) {
-            bestLabel = current.memoizedProps.testID;
-          } else if (current.memoizedProps?.title) {
-            bestLabel = current.memoizedProps.title;
-          } else if (current.memoizedProps?.placeholder) {
-            bestLabel = current.memoizedProps.placeholder;
-          } else if (typeof current.memoizedProps?.children === 'string' && current.memoizedProps.children.trim()) {
-            bestLabel = current.memoizedProps.children.trim();
-          } else if (Array.isArray(current.memoizedProps?.children)) {
-            bestLabel = findTextInChildren(current.memoizedProps.children);
-          } else if (current.memoizedProps?.children && typeof current.memoizedProps.children === 'object') {
-            bestLabel = findTextInChildren([current.memoizedProps.children]);
-          }
+        // Stop at the nearest interactive node. If this node does not provide a
+        // usable label, still allow a child text fallback from descendants.
+        if (foundInteractive) {
+          break;
         }
         current = current.return;
         depth++;
       }
-      if (bestLabel) {
-        if (detectedRole && detectedRole.toLowerCase() !== 'text' && detectedRole.toLowerCase() !== 'view') {
-          const formattedRole = detectedRole.charAt(0).toUpperCase() + detectedRole.slice(1);
-          return `[${formattedRole}] ${bestLabel}`;
-        }
-        return bestLabel;
+      if (!foundInteractive) {
+        return {
+          label: null,
+          elementKind: detectedKind,
+          labelConfidence: 'low'
+        };
       }
+
+      // Prioritize nearest interactive context when available.
+      const resolved = chooseBestAnalyticsTarget(candidates, detectedKind);
+      const sourceFiber = interactiveFiber || fiber;
+      return {
+        ...resolved,
+        zoneId: getZoneId(sourceFiber),
+        ancestorPath: getAncestorPath(sourceFiber),
+        siblingLabels: getSiblingLabels(sourceFiber),
+        componentName: getComponentName(sourceFiber)
+      };
     }
   } catch {
     // Fiber access failed — fall back gracefully
   }
-  return 'Unknown Element';
+  return {
+    label: null,
+    elementKind: 'unknown',
+    labelConfidence: 'low'
+  };
+}
+export function extractTouchLabel(event) {
+  return extractTouchTargetMetadata(event).label ?? 'Unknown Element';
 }
 
 /**

package/lib/module/services/telemetry/analyticsLabeling.js

@@ -0,0 +1,187 @@
+"use strict";
+
+const GENERIC_LABELS = new Set(['button', 'buttons', 'component', 'components', 'container', 'containers', 'content', 'cta', 'item', 'items', 'label', 'labels', 'root', 'row', 'rows', 'screen', 'screens', 'text', 'texts', 'title', 'titles', 'unknown', 'value', 'values', 'view', 'views', 'wrapper', 'wrappers']);
+const GENERIC_IDENTIFIER_TOKENS = new Set(['btn', 'button', 'card', 'cell', 'component', 'container', 'content', 'cta', 'icon', 'input', 'item', 'label', 'node', 'pressable', 'root', 'row', 'screen', 'target', 'text', 'tile', 'toggle', 'view', 'wrapper']);
+const INTERNAL_NAME_PATTERNS = [/^RCT[A-Z]/, /^React/, /^TextImpl/i, /^Android/i, /^UI[A-Z]/, /^RN[A-Z]/, /^Virtualized/i, /^ScrollResponder$/i, /^Animated(Component|.*Wrapper)?$/i, /^Touchable[A-Z]/, /^Pressable$/i, /^View$/i, /^Text$/i, /^Modal$/i, /Legacy/i, /Wrapper/i, /Context$/i, /Provider$/i];
+function normalizeWhitespace(value) {
+  if (!value) return '';
+  return String(value).replace(/\s+/g, ' ').trim();
+}
+function toTitleCase(value) {
+  return value.split(/\s+/).filter(Boolean).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(' ');
+}
+function humanizeIdentifier(value) {
+  const humanized = value.replace(/^icon:/i, '').replace(/[_./-]+/g, ' ').replace(/([a-z])([A-Z])/g, '$1 $2').replace(/\b\d+\b/g, ' ').replace(/\s+/g, ' ').trim();
+  return toTitleCase(humanized);
+}
+function stripDecorators(value) {
+  return value.replace(/^\[[^\]]+\]\s*/g, '').replace(/^["'`]+|["'`]+$/g, '').trim();
+}
+function looksInternal(value) {
+  return INTERNAL_NAME_PATTERNS.some(pattern => pattern.test(value));
+}
+function isLowSignalValue(value) {
+  const lowered = value.toLowerCase();
+  return GENERIC_LABELS.has(lowered);
+}
+function sanitizeLabelValue(rawValue, source) {
+  let normalized = normalizeWhitespace(rawValue);
+  if (!normalized) return null;
+  normalized = stripDecorators(normalized);
+  if (!normalized) return null;
+  if (source === 'test-id' || source === 'icon' || source === 'context') {
+    normalized = humanizeIdentifier(normalized);
+  }
+  if (!normalized) return null;
+  if (normalized.length > 80) return null;
+  if (looksInternal(normalized)) return null;
+  const words = normalized.split(/\s+/).filter(Boolean);
+  if (words.length === 0) return null;
+  if (words.length === 1) {
+    const token = words[0].toLowerCase();
+    if (GENERIC_IDENTIFIER_TOKENS.has(token) || GENERIC_LABELS.has(token)) {
+      return null;
+    }
+  }
+  if (isLowSignalValue(normalized)) return null;
+  return normalized;
+}
+function scoreAnalyticsLabel(label, source, isInteractiveContext = false) {
+  let score = 0;
+  const words = label.split(/\s+/).filter(Boolean);
+  if (source === 'accessibility') score += 95;
+  if (source === 'deep-text') score += 78;
+  if (source === 'sibling-text') score += 64;
+  if (source === 'title') score += 56;
+  if (source === 'placeholder') score += 42;
+  if (source === 'context') score += 12;
+  if (source === 'icon') score -= 8;
+  if (source === 'test-id') score -= 14;
+  if (isInteractiveContext) score += 18;
+  if (words.length >= 2 && words.length <= 6) score += 20;else if (words.length === 1) score += 4;
+  if (label.length >= 4 && label.length <= 36) score += 18;else if (label.length > 56) score -= 20;
+  if (/^[A-Z]/.test(label)) score += 8;
+  if (/[A-Za-z]/.test(label) && !/[_./]/.test(label)) score += 10;
+  return score;
+}
+export function getFallbackAnalyticsLabel(elementKind) {
+  switch (elementKind) {
+    case 'button':
+      return 'Primary action';
+    case 'text_input':
+      return 'Text input';
+    case 'toggle':
+      return 'Toggle';
+    case 'picker':
+      return 'Picker';
+    case 'slider':
+      return 'Slider';
+    case 'link':
+      return 'Link';
+    case 'tab':
+      return 'Tab';
+    case 'list_item':
+      return 'List item';
+    case 'image':
+      return 'Image';
+    case 'icon':
+      return 'Icon';
+    case 'text':
+      return 'Text';
+    case 'card':
+      return 'Card';
+    case 'modal':
+      return 'Modal';
+    case 'sheet':
+      return 'Bottom sheet';
+    case 'scroll_area':
+      return 'Scrollable area';
+    default:
+      return null;
+  }
+}
+export function getAnalyticsElementKind(elementType) {
+  switch (elementType) {
+    case 'pressable':
+    case 'radio':
+    case 'button':
+    case 'checkbox':
+      return 'button';
+    case 'link':
+      return 'link';
+    case 'tab':
+    case 'tabbar':
+      return 'tab';
+    case 'listitem':
+    case 'list-item':
+    case 'menuitem':
+      return 'list_item';
+    case 'text-input':
+    case 'text_input':
+    case 'textinput':
+      return 'text_input';
+    case 'switch':
+    case 'toggle':
+      return 'toggle';
+    case 'slider':
+      return 'slider';
+    case 'picker':
+      return 'picker';
+    case 'date-picker':
+    case 'select':
+    case 'dropdown':
+      return 'picker';
+    case 'image':
+    case 'imagebutton':
+      return 'image';
+    case 'icon':
+      return 'icon';
+    case 'text':
+    case 'label':
+    case 'header':
+      return 'text';
+    case 'card':
+      return 'card';
+    case 'modal':
+      return 'modal';
+    case 'sheet':
+    case 'bottomsheet':
+      return 'sheet';
+    case 'scrollable':
+    case 'scrollview':
+    case 'flatlist':
+    case 'sectionlist':
+    case 'adjustable':
+      return 'scroll_area';
+    default:
+      return 'unknown';
+  }
+}
+export function chooseBestAnalyticsTarget(candidates, elementKind) {
+  let best;
+  for (const candidate of candidates) {
+    const label = sanitizeLabelValue(candidate.text, candidate.source);
+    if (!label) continue;
+    const score = scoreAnalyticsLabel(label, candidate.source, candidate.isInteractiveContext === true);
+    if (!best || score > best.score) {
+      best = {
+        label,
+        score
+      };
+    }
+  }
+  if (best) {
+    const labelConfidence = best.score >= 100 ? 'high' : 'low';
+    return {
+      label: best.label,
+      elementKind,
+      labelConfidence
+    };
+  }
+  return {
+    label: getFallbackAnalyticsLabel(elementKind),
+    elementKind,
+    labelConfidence: 'low'
+  };
+}
+//# sourceMappingURL=analyticsLabeling.js.map

package/lib/typescript/src/core/AgentRuntime.d.ts

@@ -82,9 +82,9 @@ export declare class AgentRuntime {
     /** Maps a tool call to a user-friendly status label for the loading overlay. */
     private getToolStatusLabel;
     /**
-     * Captures the current screen as a base64 JPEG for Gemini vision.
-     * Uses react-native-view-shot as an optional peer dependency.
-     * Returns null if the library is not installed (graceful fallback).
+     * Captures the root component as a base64 JPEG for vision tools.
+     * Uses react-native-view-shot as a required peer dependency.
+     * Returns null only when capture is temporarily unavailable.
      */
     private captureScreenshot;
     /**

package/lib/typescript/src/core/types.d.ts

@@ -22,6 +22,8 @@ export interface VerifierConfig {
     maxFollowupSteps?: number;
 }
 export type ElementType = 'pressable' | 'text-input' | 'switch' | 'radio' | 'scrollable' | 'slider' | 'picker' | 'date-picker';
+export type AnalyticsElementKind = 'button' | 'text_input' | 'toggle' | 'slider' | 'picker' | 'link' | 'tab' | 'list_item' | 'image' | 'icon' | 'text' | 'card' | 'modal' | 'sheet' | 'scroll_area' | 'unknown';
+export type AnalyticsLabelConfidence = 'high' | 'low';
 export interface InteractiveElement {
     /** Unique index assigned during tree walk */
     index: number;
@@ -60,10 +62,30 @@ export interface InteractiveElement {
         /** 0-based index of the button in the active alert */
         alertButtonIndex: number;
     };
+    /** Sanitized analytics label used for telemetry and wireframes. */
+    analyticsLabel?: string | null;
+    /** Generic analytics-facing element kind. */
+    analyticsElementKind?: AnalyticsElementKind;
+    /** Confidence that the analytics label is user-facing. */
+    analyticsLabelConfidence?: AnalyticsLabelConfidence;
+    /** Nearest enclosing AI zone id, preserved for analytics/debugging. */
+    analyticsZoneId?: string | null;
+    /** Nearest custom component ancestry above the interactive node. */
+    analyticsAncestorPath?: string[];
+    /** Nearby sibling interactive labels from the same parent group. */
+    analyticsSiblingLabels?: string[];
+    /** Concrete component name for the matched interactive host. */
+    analyticsComponentName?: string | null;
 }
 export interface WireframeComponent {
     type: ElementType;
     label: string;
+    elementKind?: AnalyticsElementKind;
+    labelConfidence?: AnalyticsLabelConfidence;
+    zoneId?: string | null;
+    ancestorPath?: string[];
+    siblingLabels?: string[];
+    componentName?: string | null;
     x: number;
     y: number;
     width: number;
@@ -75,6 +97,12 @@ export interface WireframeSnapshot {
     deviceWidth: number;
     deviceHeight: number;
     capturedAt: string;
+    /**
+     * Optional JPEG screenshot captured at the same moment as this wireframe.
+     * Base64 payload (without data URI prefix) to avoid embedding UI-dependent
+     * image schemes in analytics payloads.
+     */
+    screenshot?: string | null;
 }
 export interface DehydratedScreen {
     /** Current screen name (from navigation state) */

package/lib/typescript/src/services/telemetry/TouchAutoCapture.d.ts

@@ -12,6 +12,7 @@
  * 4. Last resort: "Unknown Element".
  */
 import type { TelemetryService } from './TelemetryService';
+import type { AnalyticsTargetMetadata } from './analyticsLabeling';
 /**
  * Checks if the user is rage-tapping an element.
  *
@@ -20,12 +21,16 @@ import type { TelemetryService } from './TelemetryService';
  * 2. Taps must be on the SAME screen (screen change = not rage, it's navigation)
  * 3. Navigation labels ("Next", "Skip", etc.) are excluded
  */
-export declare function checkRageClick(label: string, telemetry: TelemetryService): void;
+export declare function checkRageClick(target: AnalyticsTargetMetadata & {
+    x: number;
+    y: number;
+}, telemetry: TelemetryService): void;
 /**
  * Extract a label from a GestureResponderEvent.
  *
  * @param event - The GestureResponderEvent from onStartShouldSetResponderCapture
  * @returns A descriptive label string for the tapped element
  */
+export declare function extractTouchTargetMetadata(event: any): AnalyticsTargetMetadata;
 export declare function extractTouchLabel(event: any): string;
 //# sourceMappingURL=TouchAutoCapture.d.ts.map

package/lib/typescript/src/services/telemetry/analyticsLabeling.d.ts

@@ -0,0 +1,20 @@
+import type { AnalyticsElementKind, AnalyticsLabelConfidence, ElementType } from '../../core/types';
+export type AnalyticsLabelSource = 'accessibility' | 'deep-text' | 'sibling-text' | 'placeholder' | 'title' | 'test-id' | 'icon' | 'context';
+export interface AnalyticsLabelCandidate {
+    text?: string | null;
+    source: AnalyticsLabelSource;
+    isInteractiveContext?: boolean;
+}
+export interface AnalyticsTargetMetadata {
+    label: string | null;
+    elementKind: AnalyticsElementKind;
+    labelConfidence: AnalyticsLabelConfidence;
+    zoneId?: string | null;
+    ancestorPath?: string[];
+    siblingLabels?: string[];
+    componentName?: string | null;
+}
+export declare function getFallbackAnalyticsLabel(elementKind: AnalyticsElementKind): string | null;
+export declare function getAnalyticsElementKind(elementType?: ElementType | string | null): AnalyticsElementKind;
+export declare function chooseBestAnalyticsTarget(candidates: AnalyticsLabelCandidate[], elementKind: AnalyticsElementKind): AnalyticsTargetMetadata;
+//# sourceMappingURL=analyticsLabeling.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mobileai/react-native",
-  "version": "0.9.28",
+  "version": "0.9.29",
   "description": "Build autonomous AI agents for React Native and Expo apps. Provides AI-native UI traversal, tool calling, and structured reasoning.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -82,14 +82,14 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/MobileAIAgent/react-native.git"
+    "url": "git+https://github.com/mohamed2m2018/react-native-agentic-ai.git"
   },
   "author": "Mohamed Salah <mohamed2m2018@gmail.com> (https://example.com)",
   "license": "SEE LICENSE IN LICENSE",
   "bugs": {
-    "url": "https://github.com/MobileAIAgent/react-native/issues"
+    "url": "https://github.com/mohamed2m2018/react-native-agentic-ai/issues"
   },
-  "homepage": "https://github.com/MobileAIAgent/react-native#readme",
+  "homepage": "https://github.com/mohamed2m2018/react-native-agentic-ai#readme",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
@@ -98,6 +98,7 @@
     "@babel/traverse": "^7.29.0",
     "@babel/types": "^7.29.0",
     "expo": "~55.0.8",
+    "react-native-view-shot": "4.0.3",
     "react": "19.2.0",
     "react-native": "0.83.2"
   },
@@ -134,8 +135,7 @@
     "react": "*",
     "react-native": "*",
     "react-native-audio-api": "*",
-    "react-native-screens": "*",
-    "react-native-view-shot": "*"
+    "react-native-screens": "*"
   },
   "peerDependenciesMeta": {
     "@react-native-async-storage/async-storage": {
@@ -147,9 +147,6 @@
     "react-native-screens": {
       "optional": true
     },
-    "react-native-view-shot": {
-      "optional": true
-    },
     "expo-speech-recognition": {
       "optional": true
     }