@ansight/react-native 1.3.0-preview.3 → 1.3.0-preview.8

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.3`
-- Maven: `ai.ansight:ansight-android:1.3.0-preview.3`
+- CocoaPods: `Ansight`, `AnsightObjC` version `1.3.0-preview.8`
+- Maven: `ai.ansight:ansight-android:1.3.0-preview.8`
 
 ## 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.3"
-  implementation("ai.ansight:ansight-android:1.3.0-preview.3")
+      findProperty("ansightAndroidVersion") ?: "1.3.0-preview.8"
+  implementation("ai.ansight:ansight-android:1.3.0-preview.8")
 }

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")) {
@@ -751,6 +783,10 @@ class AnsightReactNativeModule(
                             AnsightSessionJpegCaptureOptions.DefaultCaptureGpuBackedSurfaces,
                         ),
                         mode = sessionJpegCaptureMode(jpeg.stringValue("mode")),
+                        captureKeyboardPresence = jpeg.booleanValue(
+                            "captureKeyboardPresence",
+                            AnsightSessionJpegCaptureOptions.DefaultCaptureKeyboardPresence,
+                        ),
                     )
                 },
             )
@@ -768,6 +804,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")))
         }
@@ -931,14 +985,18 @@ class AnsightReactNativeModule(
                 AnsightSessionJpegCaptureOptions.DefaultCaptureGpuBackedSurfaces,
             ),
             mode = sessionJpegCaptureMode(map.stringValue("mode")),
+            captureKeyboardPresence = map.booleanValue(
+                "captureKeyboardPresence",
+                AnsightSessionJpegCaptureOptions.DefaultCaptureKeyboardPresence,
+            ),
         )
     }
 
     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 +1169,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 +1187,11 @@ class AnsightReactNativeModule(
                     "quality" to capture.quality,
                     "maxWidth" to capture.maxWidth,
                     "captureGpuBackedSurfaces" to capture.captureGpuBackedSurfaces,
-                    "mode" to if (capture.mode == AnsightSessionJpegCaptureMode.ScreenshotAndVisualTree) {
-                        "screenshotAndVisualTree"
-                    } else {
-                        "screenshotOnly"
+                    "captureKeyboardPresence" to capture.captureKeyboardPresence,
+                    "mode" to when (capture.mode) {
+                        AnsightSessionJpegCaptureMode.ScreenshotAndVisualTree -> "screenshotAndVisualTree"
+                        AnsightSessionJpegCaptureMode.ScreenshotWithVisualTreeOnTouch -> "screenshotWithVisualTreeOnTouch"
+                        else -> "screenshotOnly"
                     },
                 ).toWritableMap())
             } ?: putNull("sessionJpegCapture")

package/index.d.ts

@@ -37,7 +37,8 @@ export interface AnsightSessionJpegCaptureOptions {
   quality?: number;
   maxWidth?: number;
   captureGpuBackedSurfaces?: boolean;
-  mode?: "screenshotOnly" | "screenshotAndVisualTree";
+  captureKeyboardPresence?: boolean;
+  mode?: "screenshotOnly" | "screenshotAndVisualTree" | "screenshotWithVisualTreeOnTouch";
 }
 
 export interface AnsightTouchCaptureOptions {
@@ -110,6 +111,8 @@ export interface AnsightOptions {
   retentionPeriodSeconds?: number;
   enableFramesPerSecond?: boolean;
   enableBatteryLevel?: boolean;
+  enableOpenFileHandleTracking?: boolean;
+  enableJniReferenceCountTracking?: boolean;
   defaultMemoryChannels?: {
     managedHeap?: boolean;
     physicalFootprint?: boolean;
@@ -121,6 +124,7 @@ export interface AnsightOptions {
   reactNativeMemory?: false | AnsightReactNativeMemoryOptions;
   sessionJpegCapture?: false | AnsightSessionJpegCaptureOptions;
   touchCapture?: false | AnsightTouchCaptureOptions;
+  crashCapture?: false | AnsightCrashCaptureOptions;
   lifecycleCapture?: {
     enabled?: boolean;
     captureAppLifecycle?: boolean;
@@ -153,6 +157,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 +274,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 +291,14 @@ export class AnsightOptionsBuilder {
     quality?: number,
     maxWidth?: number | null,
     captureGpuBackedSurfaces?: boolean,
-    mode?: "screenshotOnly" | "screenshotAndVisualTree"
+    mode?: "screenshotOnly" | "screenshotAndVisualTree" | "screenshotWithVisualTreeOnTouch",
+    captureKeyboardPresence?: boolean
   ): 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 +542,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 +616,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;
@@ -269,6 +294,7 @@ class AnsightOptionsBuilder {
         maxWidth: arguments.length > 2 ? arguments[2] : 480,
         captureGpuBackedSurfaces: arguments.length > 3 ? arguments[3] : true,
         mode: arguments.length > 4 ? arguments[4] : "screenshotOnly",
+        captureKeyboardPresence: arguments.length > 5 ? arguments[5] : false,
       };
       return this;
     }
@@ -276,6 +302,7 @@ class AnsightOptionsBuilder {
       intervalMilliseconds: 2000,
       quality: 60,
       maxWidth: 480,
+      captureKeyboardPresence: false,
       mode: "screenshotOnly",
       ...(optionsOrIntervalMilliseconds || {}),
     };
@@ -297,6 +324,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;
@@ -2218,6 +2255,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",
@@ -2240,6 +2285,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",
@@ -2334,6 +2386,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 || {});
 }
@@ -2376,6 +2438,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,14 @@ final class AnsightReactNative: RCTEventEmitter {
                         "captureGpuBackedSurfaces",
                         defaultValue: AnsightSessionJpegCaptureOptions.defaultCaptureGpuBackedSurfaces
                     ),
-                    mode: stringValue(jpeg, "mode") == "screenshotAndVisualTree"
-                        ? .screenshotAndVisualTree
-                        : .screenshotOnly
+                    mode: AnsightSessionJpegCaptureMode(
+                        rawValue: stringValue(jpeg, "mode") ?? ""
+                    ) ?? .screenshotOnly,
+                    captureKeyboardPresence: boolValue(
+                        jpeg,
+                        "captureKeyboardPresence",
+                        defaultValue: AnsightSessionJpegCaptureOptions.defaultCaptureKeyboardPresence
+                    )
                 )
             }
         }
@@ -960,6 +997,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 +1323,14 @@ final class AnsightReactNative: RCTEventEmitter {
                 "captureGpuBackedSurfaces",
                 defaultValue: AnsightSessionJpegCaptureOptions.defaultCaptureGpuBackedSurfaces
             ),
-            mode: stringValue(dictionary, "mode") == "screenshotAndVisualTree"
-                ? .screenshotAndVisualTree
-                : .screenshotOnly
+            mode: AnsightSessionJpegCaptureMode(
+                rawValue: stringValue(dictionary, "mode") ?? ""
+            ) ?? .screenshotOnly,
+            captureKeyboardPresence: boolValue(
+                dictionary,
+                "captureKeyboardPresence",
+                defaultValue: AnsightSessionJpegCaptureOptions.defaultCaptureKeyboardPresence
+            )
         )
     }
 
@@ -1283,6 +1340,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),
@@ -1322,6 +1381,7 @@ final class AnsightReactNative: RCTEventEmitter {
                 "quality": capture.quality,
                 "maxWidth": capture.maxWidth as Any,
                 "captureGpuBackedSurfaces": capture.captureGpuBackedSurfaces,
+                "captureKeyboardPresence": capture.captureKeyboardPresence,
                 "mode": capture.mode.rawValue,
             ]
         } else {

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.3",
+  "version": "1.3.0-preview.8",
   "description": "React Native bridge for the Ansight mobile SDK.",
   "main": "index.js",
   "types": "index.d.ts",