@ansight/react-native 1.3.0-preview.2 → 1.3.0-preview.5

package/README.md

@@ -77,8 +77,8 @@ bundle; its API requires the native Ansight module.
 
 This package version expects matching native SDK packages:
 
-- CocoaPods: `Ansight`, `AnsightObjC` version `1.3.0-preview.2`
-- Maven: `ai.ansight:ansight-android:1.3.0-preview.2`
+- CocoaPods: `Ansight`, `AnsightObjC` version `1.3.0-preview.5`
+- Maven: `ai.ansight:ansight-android:1.3.0-preview.5`
 
 ## Quickstart
 
@@ -136,10 +136,12 @@ The TypeScript `AnsightOptions` surface mirrors Android `AnsightOptions`, iOS
 | `retentionPeriodSeconds` | Local metric/event retention window. |
 | `enableFramesPerSecond` | Enables native FPS sampling. |
 | `enableBatteryLevel` | Enables battery sampling where available. |
+| `enableOpenFileHandleTracking` | Enables native process open-file-handle sampling. Disabled by default. |
+| `enableJniReferenceCountTracking` | Enables JNI reference-count tracking where the runtime can supply it. Disabled by default. |
 | `defaultMemoryChannels` | Selects built-in memory channels. Prefer `managedHeap`, `nativeHeap`, `residentSetSize`, and `physicalFootprint`; `javaHeap` and `rss` are accepted as Android/RN compatibility aliases. |
 | `reactNativeMemory` | Controls native React Native runtime memory channels. Enabled by default; set to `false` to disable, or use `{ jsHeapUsed, jsHeapTotal }`. |
 | `additionalChannels` | Registers custom metric channels. |
-| `sessionJpegCapture` | Object to enable/configure capture, or `false` to disable. Supports `captureGpuBackedSurfaces`; on iOS it defaults to `true` so Metal, SceneKit, and similar GPU-backed views are included. |
+| `sessionJpegCapture` | Object to enable/configure capture, or `false` to disable. `mode` accepts `screenshotOnly`, `screenshotAndVisualTree`, or `screenshotWithVisualTreeOnTouch`. Supports `captureGpuBackedSurfaces`; on iOS it defaults to `true` so Metal, SceneKit, and similar GPU-backed views are included. |
 | `touchCapture` | Object to enable/configure capture, or `false` to disable. |
 | `lifecycleCapture` | Native lifecycle and screen-view capture options. |
 | `toolGuard` | `"disabled"`, `"readOnly"`, `"readWrite"`, or `"fullAccess"`. |
@@ -150,6 +152,11 @@ The TypeScript `AnsightOptions` surface mirrors Android `AnsightOptions`, iOS
 | `remoteTools` | Native visual tree, file, database, preferences, reflection, and secure-storage tool options. |
 | `lifecycle` | JS AppState tracking toggle. Defaults to true. |
 
+Use `withOpenFileHandleTracking()` and `withJniReferenceCountTracking()` to
+opt in through the builder. Matching `without...` methods disable the channels
+again. Open handles are sampled by the native Android/iOS runtime. JNI counts
+are available on Android only when the host integration can supply them.
+
 Cellular host connections are disabled by default. The restriction applies to
 enrollment and reconnect requests. Opt in only for a trusted development host
 or personal hotspot:
@@ -175,6 +182,7 @@ await Ansight.initializeAndActivate({
     quality: 60,
     maxWidth: 480,
     captureGpuBackedSurfaces: true,
+    mode: "screenshotWithVisualTreeOnTouch",
   },
   touchCapture: {
     captureMoveEvents: true,
@@ -192,6 +200,10 @@ await Ansight.initializeAndActivate({
 });
 ```
 
+The touch mode captures native visual trees at gesture start, every 250 ms
+throughout the gesture, and at the final up or cancel. It requires native touch
+capture and visual-tree tools/providers to remain enabled.
+
 On iOS, `captureGpuBackedSurfaces` defaults to `true` so Metal, SceneKit, and
 similar GPU-backed views are included. Set it to `false` to use a lower-overhead
 capture path when those surfaces are not needed.

package/android/build.gradle

@@ -67,6 +67,6 @@ repositories {
 dependencies {
   implementation("com.facebook.react:react-android")
   def ansightAndroidVersion =
-      findProperty("ansightAndroidVersion") ?: "1.3.0-preview.2"
-  implementation("ai.ansight:ansight-android:1.3.0-preview.2")
+      findProperty("ansightAndroidVersion") ?: "1.3.0-preview.5"
+  implementation("ai.ansight:ansight-android:1.3.0-preview.5")
 }

package/android/src/main/kotlin/ai/ansight/reactnative/AnsightReactNativeModule.kt

@@ -6,6 +6,7 @@ import ai.ansight.runtime.AndroidToolExecutionContext
 import ai.ansight.runtime.AndroidToolResult
 import ai.ansight.runtime.AnsightChannel
 import ai.ansight.runtime.AnsightChannels
+import ai.ansight.runtime.AnsightCrashCaptureOptions
 import ai.ansight.runtime.AnsightHostAutoProbeOptions
 import ai.ansight.runtime.AnsightHostConnectionOptions
 import ai.ansight.runtime.AnsightLogCallback
@@ -225,6 +226,21 @@ class AnsightReactNativeModule(
         }.resolve(promise)
     }
 
+    @ReactMethod
+    fun recordCrashCandidate(input: ReadableMap, promise: Promise) {
+        runCatching {
+            val candidateId = AnsightRuntime.recordCrashCandidate(
+                runtime = input.stringValue("runtime") ?: "react-native-javascript",
+                kind = input.stringValue("kind") ?: "unhandled_javascript_error",
+                message = input.stringValue("message"),
+                stack = input.stringValue("stack"),
+                fatal = input.booleanValue("fatal", false),
+                metadataJson = input.stringValue("metadata"),
+            )
+            Arguments.createMap().apply { putString("candidateId", candidateId) }
+        }.resolve(promise)
+    }
+
     @ReactMethod
     fun screenViewed(name: String, details: ReadableMap?, promise: Promise) {
         runCatching {
@@ -693,6 +709,22 @@ class AnsightReactNativeModule(
         if (map.hasBoolean("enableBatteryLevel")) {
             options = options.copy(enableBatteryLevel = map.booleanValue("enableBatteryLevel", options.enableBatteryLevel))
         }
+        if (map.hasBoolean("enableOpenFileHandleTracking")) {
+            options = options.copy(
+                enableOpenFileHandleTracking = map.booleanValue(
+                    "enableOpenFileHandleTracking",
+                    options.enableOpenFileHandleTracking,
+                ),
+            )
+        }
+        if (map.hasBoolean("enableJniReferenceCountTracking")) {
+            options = options.copy(
+                enableJniReferenceCountTracking = map.booleanValue(
+                    "enableJniReferenceCountTracking",
+                    options.enableJniReferenceCountTracking,
+                ),
+            )
+        }
         if (map.hasMap("defaultMemoryChannels")) {
             val memory = map.getMapOrNull("defaultMemoryChannels")
             val managedHeap = if (memory.hasBoolean("managedHeap")) {
@@ -768,6 +800,24 @@ class AnsightReactNativeModule(
                 },
             )
         }
+        if (map.hasKey("crashCapture")) {
+            options = options.copy(
+                crashCapture = if (map.isFalse("crashCapture")) {
+                    options.crashCapture.copy(enabled = false)
+                } else {
+                    val crash = map.getMapOrNull("crashCapture")
+                    AnsightCrashCaptureOptions(
+                        enabled = crash.booleanValue("enabled", true),
+                        studioHandoffEnabled = crash.booleanValue("studioHandoffEnabled", true),
+                        offlineCaptureAttachmentEnabled = crash.booleanValue("offlineCaptureAttachmentEnabled", true),
+                        maximumPendingReports = crash.intValue("maximumPendingReports", 8),
+                        retentionDays = crash.intValue("retentionDays", 7),
+                        maximumBreadcrumbs = crash.intValue("maximumBreadcrumbs", 64),
+                        maximumTraceBytes = crash.intValue("maximumTraceBytes", 1_048_576),
+                    )
+                },
+            )
+        }
         if (map.hasString("toolGuard")) {
             options = options.copy(toolGuard = toolGuard(map.stringValue("toolGuard")))
         }
@@ -935,10 +985,10 @@ class AnsightReactNativeModule(
     }
 
     private fun sessionJpegCaptureMode(value: String?): AnsightSessionJpegCaptureMode =
-        if (value == "screenshotAndVisualTree") {
-            AnsightSessionJpegCaptureMode.ScreenshotAndVisualTree
-        } else {
-            AnsightSessionJpegCaptureMode.ScreenshotOnly
+        when (value) {
+            "screenshotAndVisualTree" -> AnsightSessionJpegCaptureMode.ScreenshotAndVisualTree
+            "screenshotWithVisualTreeOnTouch" -> AnsightSessionJpegCaptureMode.ScreenshotWithVisualTreeOnTouch
+            else -> AnsightSessionJpegCaptureMode.ScreenshotOnly
         }
 
     private fun toolDefinition(map: ReadableMap): ToolDefinition =
@@ -1111,6 +1161,8 @@ class AnsightReactNativeModule(
             putInt("retentionPeriodSeconds", options.retentionPeriodSeconds)
             putBoolean("enableFramesPerSecond", options.enableFramesPerSecond)
             putBoolean("enableBatteryLevel", options.enableBatteryLevel)
+            putBoolean("enableOpenFileHandleTracking", options.enableOpenFileHandleTracking)
+            putBoolean("enableJniReferenceCountTracking", options.enableJniReferenceCountTracking)
             putMap("defaultMemoryChannels", mapOf(
                 "managedHeap" to options.defaultMemoryChannels.javaHeap,
                 "javaHeap" to options.defaultMemoryChannels.javaHeap,
@@ -1127,10 +1179,10 @@ class AnsightReactNativeModule(
                     "quality" to capture.quality,
                     "maxWidth" to capture.maxWidth,
                     "captureGpuBackedSurfaces" to capture.captureGpuBackedSurfaces,
-                    "mode" to if (capture.mode == AnsightSessionJpegCaptureMode.ScreenshotAndVisualTree) {
-                        "screenshotAndVisualTree"
-                    } else {
-                        "screenshotOnly"
+                    "mode" to when (capture.mode) {
+                        AnsightSessionJpegCaptureMode.ScreenshotAndVisualTree -> "screenshotAndVisualTree"
+                        AnsightSessionJpegCaptureMode.ScreenshotWithVisualTreeOnTouch -> "screenshotWithVisualTreeOnTouch"
+                        else -> "screenshotOnly"
                     },
                 ).toWritableMap())
             } ?: putNull("sessionJpegCapture")

package/index.d.ts

@@ -37,7 +37,7 @@ export interface AnsightSessionJpegCaptureOptions {
   quality?: number;
   maxWidth?: number;
   captureGpuBackedSurfaces?: boolean;
-  mode?: "screenshotOnly" | "screenshotAndVisualTree";
+  mode?: "screenshotOnly" | "screenshotAndVisualTree" | "screenshotWithVisualTreeOnTouch";
 }
 
 export interface AnsightTouchCaptureOptions {
@@ -110,6 +110,8 @@ export interface AnsightOptions {
   retentionPeriodSeconds?: number;
   enableFramesPerSecond?: boolean;
   enableBatteryLevel?: boolean;
+  enableOpenFileHandleTracking?: boolean;
+  enableJniReferenceCountTracking?: boolean;
   defaultMemoryChannels?: {
     managedHeap?: boolean;
     physicalFootprint?: boolean;
@@ -121,6 +123,7 @@ export interface AnsightOptions {
   reactNativeMemory?: false | AnsightReactNativeMemoryOptions;
   sessionJpegCapture?: false | AnsightSessionJpegCaptureOptions;
   touchCapture?: false | AnsightTouchCaptureOptions;
+  crashCapture?: false | AnsightCrashCaptureOptions;
   lifecycleCapture?: {
     enabled?: boolean;
     captureAppLifecycle?: boolean;
@@ -153,6 +156,25 @@ export interface AnsightOptions {
   lifecycle?: boolean;
 }
 
+export interface AnsightCrashCaptureOptions {
+  enabled?: boolean;
+  studioHandoffEnabled?: boolean;
+  offlineCaptureAttachmentEnabled?: boolean;
+  maximumPendingReports?: number;
+  retentionDays?: number;
+  maximumBreadcrumbs?: number;
+  maximumTraceBytes?: number;
+}
+
+export interface AnsightCrashCandidate {
+  runtime?: string;
+  kind?: string;
+  message?: string;
+  stack?: string;
+  fatal?: boolean;
+  metadata?: string | Record<string, string>;
+}
+
 export interface AnsightOperationResult {
   success: boolean;
   message: string;
@@ -251,6 +273,10 @@ export class AnsightOptionsBuilder {
   withoutFramesPerSecond(): this;
   withBatteryLevel(): this;
   withoutBatteryLevel(): this;
+  withOpenFileHandleTracking(): this;
+  withoutOpenFileHandleTracking(): this;
+  withJniReferenceCountTracking(): this;
+  withoutJniReferenceCountTracking(): this;
   withRetentionPeriodSeconds(retentionPeriodSeconds: number): this;
   withAdditionalChannels(additionalChannels: AnsightChannel[]): this;
   addAdditionalChannel(additionalChannel: AnsightChannel): this;
@@ -264,11 +290,13 @@ export class AnsightOptionsBuilder {
     quality?: number,
     maxWidth?: number | null,
     captureGpuBackedSurfaces?: boolean,
-    mode?: "screenshotOnly" | "screenshotAndVisualTree"
+    mode?: "screenshotOnly" | "screenshotAndVisualTree" | "screenshotWithVisualTreeOnTouch"
   ): this;
   withoutSessionJpegCapture(): this;
   withTouchCapture(touchCapture?: AnsightTouchCaptureOptions): this;
   withoutTouchCapture(): this;
+  withCrashCapture(crashCapture?: AnsightCrashCaptureOptions): this;
+  withoutCrashCapture(): this;
   withLifecycleCapture(lifecycleCapture?: NonNullable<AnsightOptions["lifecycleCapture"]>): this;
   withToolGuard(toolGuard: NonNullable<AnsightOptions["toolGuard"]>): this;
   withToolsDisabled(): this;
@@ -512,6 +540,7 @@ export function metric(value: number, channel?: number): Promise<AnsightDebugSna
 export function recordMetric(value: number, channel?: number): Promise<AnsightDebugSnapshot>;
 export function event(input: string | { label: string; type?: string; details?: string; channel?: number }): Promise<AnsightDebugSnapshot>;
 export function recordEvent(input: string | { label: string; type?: string; details?: string; channel?: number }): Promise<AnsightDebugSnapshot>;
+export function recordCrashCandidate(input?: AnsightCrashCandidate): Promise<{ candidateId?: string }>;
 export function screenViewed(name: string, details?: Record<string, string>): Promise<AnsightDebugSnapshot>;
 export function trackRoute(name: string, details?: Record<string, string>): Promise<AnsightDebugSnapshot>;
 export function setAppLifecycleState(state: AnsightLifecycleState): Promise<AnsightDebugSnapshot>;
@@ -585,6 +614,7 @@ declare const Ansight: {
   recordMetric: typeof recordMetric;
   event: typeof event;
   recordEvent: typeof recordEvent;
+  recordCrashCandidate: typeof recordCrashCandidate;
   screenViewed: typeof screenViewed;
   trackRoute: typeof trackRoute;
   setAppLifecycleState: typeof setAppLifecycleState;

package/index.js

@@ -61,6 +61,9 @@ function cloneOptions(options = {}) {
   if (options.touchCapture && typeof options.touchCapture === "object") {
     clone.touchCapture = { ...options.touchCapture };
   }
+  if (options.crashCapture && typeof options.crashCapture === "object") {
+    clone.crashCapture = { ...options.crashCapture };
+  }
   if (options.lifecycleCapture) {
     clone.lifecycleCapture = { ...options.lifecycleCapture };
   }
@@ -157,6 +160,8 @@ class AnsightOptionsBuilder {
       retentionPeriodSeconds: 120,
       enableFramesPerSecond: true,
       enableBatteryLevel: false,
+      enableOpenFileHandleTracking: false,
+      enableJniReferenceCountTracking: false,
       sessionJpegCapture: {
         intervalMilliseconds: 2000,
         quality: 60,
@@ -209,6 +214,26 @@ class AnsightOptionsBuilder {
     return this;
   }
 
+  withOpenFileHandleTracking() {
+    this._options.enableOpenFileHandleTracking = true;
+    return this;
+  }
+
+  withoutOpenFileHandleTracking() {
+    this._options.enableOpenFileHandleTracking = false;
+    return this;
+  }
+
+  withJniReferenceCountTracking() {
+    this._options.enableJniReferenceCountTracking = true;
+    return this;
+  }
+
+  withoutJniReferenceCountTracking() {
+    this._options.enableJniReferenceCountTracking = false;
+    return this;
+  }
+
   withRetentionPeriodSeconds(retentionPeriodSeconds) {
     this._options.retentionPeriodSeconds = retentionPeriodSeconds;
     return this;
@@ -297,6 +322,16 @@ class AnsightOptionsBuilder {
     return this;
   }
 
+  withCrashCapture(crashCapture = {}) {
+    this._options.crashCapture = { ...crashCapture, enabled: true };
+    return this;
+  }
+
+  withoutCrashCapture() {
+    this._options.crashCapture = false;
+    return this;
+  }
+
   withLifecycleCapture(lifecycleCapture = {}) {
     this._options.lifecycleCapture = { ...lifecycleCapture };
     return this;
@@ -1489,6 +1524,28 @@ function createReactVisual(fiber, props, maxStringLength) {
   return visual;
 }
 
+function createReactZIndex(props) {
+  const style = StyleSheet && typeof StyleSheet.flatten === "function"
+    ? StyleSheet.flatten(props && props.style)
+    : props && props.style;
+  const zIndex = style && style.zIndex != null ? Number(style.zIndex) : NaN;
+  const elevation = style && style.elevation != null ? Number(style.elevation) : NaN;
+  if (Number.isFinite(zIndex) && zIndex !== 0) return zIndex;
+  if (Number.isFinite(elevation) && elevation !== 0) return elevation;
+  return null;
+}
+
+function registerReactType(context, typeName) {
+  const normalizedTypeName = String(typeName || "UnknownComponent").trim() || "UnknownComponent";
+  const existingTypeId = context.typeIdsByName.get(normalizedTypeName);
+  if (existingTypeId != null) return existingTypeId;
+
+  const typeId = context.types.length;
+  context.types.push(normalizedTypeName);
+  context.typeIdsByName.set(normalizedTypeName, typeId);
+  return typeId;
+}
+
 function nativeTagForFiber(fiber) {
   const stateNode = fiber && fiber.stateNode;
   if (!stateNode) {
@@ -1560,17 +1617,17 @@ function serializeFiber(fiber, context, depth) {
 
   const props = fiber.memoizedProps || fiber.pendingProps || {};
   const type = reactFiberTypeName(fiber);
-  const kind = reactFiberKind(fiber.tag);
   const node = {
     id: reactFiberId(fiber),
-    type,
-    kind,
+    typeId: registerReactType(context, type),
     tag: fiber.tag,
     key: fiber.key == null ? null : String(fiber.key),
     depth,
     visual: createReactVisual(fiber, props, context.maxStringLength),
     children: [],
   };
+  const zIndex = createReactZIndex(props);
+  if (zIndex != null) node.z = zIndex;
 
   if (fiber._debugSource) {
     node.source = {
@@ -1582,7 +1639,7 @@ function serializeFiber(fiber, context, depth) {
 
   const owner = fiber._debugOwner && reactFiberTypeName(fiber._debugOwner);
   if (owner) {
-    node.owner = owner;
+    node.ownerTypeId = registerReactType(context, owner);
   }
 
   const nativeTag = nativeTagForFiber(fiber);
@@ -1641,14 +1698,15 @@ function createShadowTreeNode(fiber, context, depth) {
   const type = reactFiberTypeName(fiber);
   const node = {
     id: reactFiberId(fiber),
-    type,
-    kind: fiber.tag === 3 ? "root" : fiber.tag === 6 ? "text" : "host",
+    typeId: registerReactType(context, type),
     tag: fiber.tag,
     key: fiber.key == null ? null : String(fiber.key),
     depth,
     visual: createReactVisual(fiber, props, context.maxStringLength),
     children: [],
   };
+  const zIndex = createReactZIndex(props);
+  if (zIndex != null) node.z = zIndex;
 
   const nativeTag = nativeTagForFiber(fiber);
   if (nativeTag != null) {
@@ -1732,19 +1790,21 @@ async function captureReactVisualTree(rawOptions = {}) {
     maxStringLength: rawOptions.maxStringLength || 180,
     maxValueDepth: rawOptions.maxValueDepth || 2,
     nodesWithNativeTags: [],
+    typeIdsByName: new Map(),
+    types: [],
     count: 0,
     truncated: false,
     visited: new Set(),
   };
   const roots = getReactRoots();
-  const rootNodes = roots.roots.map((root, index) => {
+  const rootNodes = roots.roots.map((root) => {
     const node = serializeFiber(root.fiber, context, 0);
     if (node) {
       node.rendererId = root.rendererId;
-      node.rootIndex = index;
     }
     return node;
   }).filter(Boolean);
+  const rootTypeId = registerReactType(context, "ReactRoots");
 
   if (includeBounds && context.nodesWithNativeTags.length > 0) {
     await Promise.all(context.nodesWithNativeTags.slice(0, 300).map(async (node) => {
@@ -1756,6 +1816,7 @@ async function captureReactVisualTree(rawOptions = {}) {
   }
 
   return {
+    format: "ansight.react.visual-tree.compact.v2",
     platform: Platform.OS,
     source: "react",
     adapter: "react.fiber",
@@ -1765,11 +1826,11 @@ async function captureReactVisualTree(rawOptions = {}) {
     renderers: roots.renderers,
     root: {
       id: "react:roots",
-      type: "ReactRoots",
-      kind: "container",
+      typeId: rootTypeId,
+      childCount: rootNodes.length,
       children: rootNodes,
     },
-    roots: rootNodes,
+    types: context.types,
     nodeCount: context.count,
     truncated: context.truncated,
     unavailableReason: roots.hookAvailable ? undefined : "React DevTools global hook is not available in this runtime.",
@@ -1789,19 +1850,21 @@ async function captureReactShadowTree(rawOptions = {}) {
     maxStringLength: rawOptions.maxStringLength || 180,
     maxValueDepth: rawOptions.maxValueDepth || 2,
     nodesWithNativeTags: [],
+    typeIdsByName: new Map(),
+    types: [],
     count: 0,
     truncated: false,
     visited: new Set(),
   };
   const roots = getReactRoots();
-  const rootNodes = roots.roots.flatMap((root, index) => {
+  const rootNodes = roots.roots.flatMap((root) => {
     const nodes = serializeShadowFiber(root.fiber, context, 0);
     nodes.forEach((node) => {
       node.rendererId = root.rendererId;
-      node.rootIndex = index;
     });
     return nodes;
   });
+  const rootTypeId = registerReactType(context, "ReactNativeShadowRoots");
 
   if (includeBounds && context.nodesWithNativeTags.length > 0) {
     await Promise.all(context.nodesWithNativeTags.slice(0, 300).map(async (node) => {
@@ -1813,6 +1876,7 @@ async function captureReactShadowTree(rawOptions = {}) {
   }
 
   return {
+    format: "ansight.react.visual-tree.compact.v2",
     platform: Platform.OS,
     source: "react-native",
     adapter: "react-native.host-fiber",
@@ -1822,11 +1886,11 @@ async function captureReactShadowTree(rawOptions = {}) {
     renderers: roots.renderers,
     root: {
       id: "react:shadow-roots",
-      type: "ReactNativeShadowRoots",
-      kind: "container",
+      typeId: rootTypeId,
+      childCount: rootNodes.length,
       children: rootNodes,
     },
-    roots: rootNodes,
+    types: context.types,
     nodeCount: context.count,
     truncated: context.truncated,
     unavailableReason: roots.hookAvailable ? undefined : "React DevTools global hook is not available in this runtime.",
@@ -1842,13 +1906,18 @@ function flattenReactTree(node, output = []) {
   return output;
 }
 
-function nodeSearchText(node) {
+function createReactNodeSnapshot(node) {
+  const snapshot = { ...node };
+  delete snapshot.children;
+  return snapshot;
+}
+
+function nodeSearchText(node, types) {
   return [
     node.id,
-    node.type,
-    node.kind,
+    types[node.typeId],
     node.label,
-    node.owner,
+    types[node.ownerTypeId],
     node.propsSummary && node.propsSummary.testID,
     node.propsSummary && node.propsSummary.nativeID,
     node.propsSummary && node.propsSummary.accessibilityLabel,
@@ -1856,14 +1925,14 @@ function nodeSearchText(node) {
   ].filter(Boolean).join(" ").toLowerCase();
 }
 
-function matchesReactNode(node, args) {
+function matchesReactNode(node, args, types) {
   const query = args.query ? String(args.query).toLowerCase() : null;
   const type = args.type ? String(args.type).toLowerCase() : null;
   const testID = args.testID ? String(args.testID).toLowerCase() : null;
   const text = args.text ? String(args.text).toLowerCase() : null;
-  const searchText = nodeSearchText(node);
+  const searchText = nodeSearchText(node, types);
   return (!query || searchText.includes(query)) &&
-    (!type || String(node.type || "").toLowerCase().includes(type)) &&
+    (!type || String(types[node.typeId] || "").toLowerCase().includes(type)) &&
     (!testID || String((node.propsSummary && node.propsSummary.testID) || "").toLowerCase() === testID) &&
     (!text || searchText.includes(text));
 }
@@ -2084,12 +2153,14 @@ function installReactTools(options = {}) {
         });
         const maxResults = parseInteger(args.maxResults, 50, 1, 500);
         const matches = flattenReactTree(tree.root)
-          .filter((node) => node.id !== "react:roots" && matchesReactNode(node, args))
-          .slice(0, maxResults);
+          .filter((node) => node.id !== "react:roots" && matchesReactNode(node, args, tree.types))
+          .slice(0, maxResults)
+          .map(createReactNodeSnapshot);
         return {
           success: tree.hookAvailable,
           message: `Found ${matches.length} React component(s).`,
           result: {
+            types: tree.types,
             matches,
             count: matches.length,
             truncated: matches.length === maxResults,
@@ -2101,7 +2172,11 @@ function installReactTools(options = {}) {
         const tree = await captureReactVisualTree(reactToolOptions(options, args));
         const node = flattenReactTree(tree.root).find((candidate) => candidate.id === args.nodeId);
         return node
-          ? { success: true, message: "React component captured.", result: node }
+          ? {
+            success: true,
+            message: "React component captured.",
+            result: { types: tree.types, node: createReactNodeSnapshot(node) },
+          }
           : { success: false, message: `React component '${args.nodeId}' was not found.`, errorCode: "react_component_not_found" };
       }
 
@@ -2142,7 +2217,7 @@ function installReactTools(options = {}) {
           result: {
             nodeId: args.nodeId,
             prop,
-            type: node.type,
+            type: tree.types[node.typeId],
           },
         };
       }
@@ -2178,6 +2253,14 @@ function installErrorHandlers(options = {}) {
 
   if (global.ErrorUtils && global.ErrorUtils.setGlobalHandler) {
     global.ErrorUtils.setGlobalHandler((error, isFatal) => {
+      nativeModule.recordCrashCandidate({
+        runtime: "react-native-javascript",
+        kind: "unhandled_javascript_error",
+        message: error && error.message,
+        stack: error && error.stack,
+        fatal: !!isFatal,
+        metadata: JSON.stringify({ name: error && error.name }),
+      }).catch(() => {});
       nativeModule.recordEvent({
         label: error && error.message ? error.message : "Unhandled JavaScript error",
         type: "Exception",
@@ -2200,6 +2283,13 @@ function installErrorHandlers(options = {}) {
     global.__ansightUnhandledRejectionTrackingInstalled = true;
     global.addEventListener("unhandledrejection", (event) => {
       const reason = event && event.reason;
+      nativeModule.recordCrashCandidate({
+        runtime: "react-native-javascript",
+        kind: "unhandled_promise_rejection",
+        message: reason && reason.message ? reason.message : String(reason),
+        stack: reason && reason.stack,
+        fatal: false,
+      }).catch(() => {});
       nativeModule.recordEvent({
         label: reason && reason.message ? reason.message : "Unhandled JavaScript promise rejection",
         type: "Exception",
@@ -2294,6 +2384,16 @@ function recordEvent(input) {
   return nativeModule.recordEvent(input || {});
 }
 
+function recordCrashCandidate(input = {}) {
+  const metadata = input.metadata && typeof input.metadata === "object"
+    ? JSON.stringify(input.metadata)
+    : input.metadata;
+  return nativeModule.recordCrashCandidate({
+    ...input,
+    metadata,
+  });
+}
+
 function screenViewed(name, details) {
   return nativeModule.screenViewed(name, details || {});
 }
@@ -2336,6 +2436,7 @@ const Ansight = {
   recordMetric: (value, channel = 255) => nativeModule.recordMetric(value, channel),
   event: recordEvent,
   recordEvent,
+  recordCrashCandidate,
   screenViewed,
   trackRoute,
   setAppLifecycleState: (state) => nativeModule.setAppLifecycleState(state),

package/ios/AnsightReactNative.swift

@@ -292,6 +292,31 @@ final class AnsightReactNative: RCTEventEmitter {
         }
     }
 
+    @objc(recordCrashCandidate:resolver:rejecter:)
+    func recordCrashCandidate(
+        _ input: NSDictionary,
+        resolver resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        let metadata: [String: String]
+        if let metadataJson = stringValue(input, "metadata"),
+           let data = metadataJson.data(using: .utf8),
+           let decoded = try? JSONDecoder().decode([String: String].self, from: data) {
+            metadata = decoded
+        } else {
+            metadata = [:]
+        }
+        let candidateId = AnsightRuntime.shared.recordCrashCandidate(
+            runtime: stringValue(input, "runtime") ?? "react-native-javascript",
+            kind: stringValue(input, "kind") ?? "unhandled_javascript_error",
+            message: stringValue(input, "message"),
+            stack: stringValue(input, "stack"),
+            fatal: boolValue(input, "fatal", defaultValue: false),
+            metadata: metadata
+        )
+        resolve(candidateId.map { ["candidateId": $0] } ?? [:])
+    }
+
     @objc(screenViewed:details:resolver:rejecter:)
     func screenViewed(
         _ name: NSString,
@@ -895,6 +920,13 @@ final class AnsightReactNative: RCTEventEmitter {
         if hasBool(dictionary, "enableBatteryLevel") {
             options.enableBatteryLevel = boolValue(dictionary, "enableBatteryLevel", defaultValue: options.enableBatteryLevel)
         }
+        if hasBool(dictionary, "enableOpenFileHandleTracking") {
+            options.enableOpenFileHandleTracking = boolValue(
+                dictionary,
+                "enableOpenFileHandleTracking",
+                defaultValue: options.enableOpenFileHandleTracking
+            )
+        }
         if let memory = dictionary?["defaultMemoryChannels"] as? NSDictionary {
             var channels: DefaultMemoryChannels = []
             if boolValue(memory, "managedHeap", defaultValue: boolValue(memory, "javaHeap", defaultValue: false)) {
@@ -942,9 +974,9 @@ final class AnsightReactNative: RCTEventEmitter {
                         "captureGpuBackedSurfaces",
                         defaultValue: AnsightSessionJpegCaptureOptions.defaultCaptureGpuBackedSurfaces
                     ),
-                    mode: stringValue(jpeg, "mode") == "screenshotAndVisualTree"
-                        ? .screenshotAndVisualTree
-                        : .screenshotOnly
+                    mode: AnsightSessionJpegCaptureMode(
+                        rawValue: stringValue(jpeg, "mode") ?? ""
+                    ) ?? .screenshotOnly
                 )
             }
         }
@@ -960,6 +992,21 @@ final class AnsightReactNative: RCTEventEmitter {
                 )
             }
         }
+        if let raw = dictionary?["crashCapture"] {
+            if (raw as? Bool) == false {
+                options.crashCapture.enabled = false
+            } else if let crash = raw as? NSDictionary {
+                options.crashCapture = AnsightCrashCaptureOptions(
+                    enabled: boolValue(crash, "enabled", defaultValue: true),
+                    studioHandoffEnabled: boolValue(crash, "studioHandoffEnabled", defaultValue: true),
+                    offlineCaptureAttachmentEnabled: boolValue(crash, "offlineCaptureAttachmentEnabled", defaultValue: true),
+                    maximumPendingReports: intValue(crash, "maximumPendingReports", defaultValue: 8),
+                    retentionDays: intValue(crash, "retentionDays", defaultValue: 7),
+                    maximumBreadcrumbs: intValue(crash, "maximumBreadcrumbs", defaultValue: 64),
+                    maximumTraceBytes: intValue(crash, "maximumTraceBytes", defaultValue: 1_048_576)
+                )
+            }
+        }
         if let lifecycle = dictionary?["lifecycleCapture"] as? NSDictionary {
             options.lifecycleCapture = AnsightLifecycleCaptureOptions(
                 enabled: boolValue(lifecycle, "enabled", defaultValue: options.lifecycleCapture.enabled),
@@ -1271,9 +1318,9 @@ final class AnsightReactNative: RCTEventEmitter {
                 "captureGpuBackedSurfaces",
                 defaultValue: AnsightSessionJpegCaptureOptions.defaultCaptureGpuBackedSurfaces
             ),
-            mode: stringValue(dictionary, "mode") == "screenshotAndVisualTree"
-                ? .screenshotAndVisualTree
-                : .screenshotOnly
+            mode: AnsightSessionJpegCaptureMode(
+                rawValue: stringValue(dictionary, "mode") ?? ""
+            ) ?? .screenshotOnly
         )
     }
 
@@ -1283,6 +1330,8 @@ final class AnsightReactNative: RCTEventEmitter {
             "retentionPeriodSeconds": options.retentionPeriodSeconds,
             "enableFramesPerSecond": options.enableFramesPerSecond,
             "enableBatteryLevel": options.enableBatteryLevel,
+            "enableOpenFileHandleTracking": options.enableOpenFileHandleTracking,
+            "enableJniReferenceCountTracking": false,
             "defaultMemoryChannels": [
                 "managedHeap": options.defaultMemoryChannels.contains(.managedHeap),
                 "javaHeap": options.defaultMemoryChannels.contains(.managedHeap),

package/ios/AnsightReactNativeModule.m

@@ -33,6 +33,10 @@ RCT_EXTERN_METHOD(recordEvent:(NSDictionary *)input
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(recordCrashCandidate:(NSDictionary *)input
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(screenViewed:(NSString *)name
                   details:(NSDictionary *)details
                   resolver:(RCTPromiseResolveBlock)resolve

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ansight/react-native",
-  "version": "1.3.0-preview.2",
+  "version": "1.3.0-preview.5",
   "description": "React Native bridge for the Ansight mobile SDK.",
   "main": "index.js",
   "types": "index.d.ts",