@goliapkg/sentori-react-native 0.2.0 → 0.3.1

package/android/src/main/java/com/sentori/SentoriAnrWatchdog.kt

@@ -0,0 +1,227 @@
+package com.sentori
+
+import android.content.Context
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+import java.util.UUID
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * ANR (Application Not Responding) detector.
+ *
+ * Lightweight watchdog: a worker thread posts a tick onto the main
+ * Looper every `intervalMs` and sleeps for `timeoutMs`. If the main
+ * thread didn't acknowledge the tick within that window we capture the
+ * main thread's stack trace as a Sentori event with `kind = "anr"`
+ * and write it to the same pending dir SentoriCrashHandler uses, so
+ * the next-launch drain delivers it.
+ *
+ * Design notes:
+ *   - Single-shot per ANR: once we report, we wait for the main
+ *     thread to recover before re-arming. Otherwise a 30 s freeze
+ *     would dump six events.
+ *   - We DON'T kill the process or rethrow. The OS does that on its
+ *     own ANR threshold (~5 s for input-driven, longer otherwise).
+ *   - Worker thread is a daemon so it doesn't keep the process alive.
+ *   - Disabled in debug builds by default — the JS debugger pauses
+ *     the main thread routinely and we don't want a flood. The host
+ *     app can override via `SentoriAnrWatchdog.start(ctx, force = true)`.
+ */
+object SentoriAnrWatchdog {
+
+    private const val DEFAULT_TIMEOUT_MS = 5_000L
+    private const val DEFAULT_INTERVAL_MS = 1_000L
+    private const val PENDING_DIR_NAME = "sentori/pending"
+
+    @Volatile private var running = AtomicBoolean(false)
+    @Volatile private var thread: Thread? = null
+    @Volatile private var appCtx: Context? = null
+
+    /**
+     * Start the watchdog. Idempotent — calling start() twice is a
+     * no-op. Pass `force = true` to enable in debug builds.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun start(
+        context: Context,
+        timeoutMs: Long = DEFAULT_TIMEOUT_MS,
+        intervalMs: Long = DEFAULT_INTERVAL_MS,
+        force: Boolean = false,
+    ) {
+        if (!force && isDebuggable(context)) return
+        if (running.getAndSet(true)) return
+        appCtx = context.applicationContext
+
+        val mainHandler = Handler(Looper.getMainLooper())
+        val watchdogThread = Thread {
+            val tick = MainTick()
+            while (running.get()) {
+                tick.armed = true
+                mainHandler.post(tick)
+                try {
+                    Thread.sleep(timeoutMs)
+                } catch (_: InterruptedException) {
+                    return@Thread
+                }
+                if (tick.armed) {
+                    // Main thread is wedged — capture once, then wait
+                    // for the tick to land before arming again.
+                    captureAnr()
+                    while (running.get() && tick.armed) {
+                        try {
+                            Thread.sleep(intervalMs)
+                        } catch (_: InterruptedException) {
+                            return@Thread
+                        }
+                    }
+                }
+            }
+        }
+        watchdogThread.name = "Sentori-ANR-Watchdog"
+        watchdogThread.isDaemon = true
+        watchdogThread.start()
+        thread = watchdogThread
+    }
+
+    @JvmStatic
+    fun stop() {
+        running.set(false)
+        thread?.interrupt()
+        thread = null
+    }
+
+    private fun captureAnr() {
+        val ctx = appCtx ?: return
+        try {
+            val mainStack = Looper.getMainLooper().thread.stackTrace
+            val event = buildAnrEvent(ctx, mainStack)
+            val dir = File(ctx.filesDir, PENDING_DIR_NAME)
+            if (!dir.exists()) dir.mkdirs()
+            val file = File(dir, "${uuid()}.json")
+            file.writeText(event.toString())
+        } catch (_: Throwable) {
+            // never throw from inside the watchdog — losing one
+            // capture beats killing the worker thread.
+        }
+    }
+
+    private fun buildAnrEvent(ctx: Context, mainStack: Array<StackTraceElement>): JSONObject {
+        val cfg = configMap(ctx)
+        val release = cfg["release"] ?: "unknown"
+        val environment = cfg["environment"] ?: "prod"
+
+        val device = JSONObject().apply {
+            put("os", "android")
+            put("osVersion", Build.VERSION.RELEASE)
+            put("model", "${Build.MANUFACTURER} ${Build.MODEL}")
+        }
+        val app = JSONObject().apply {
+            put("version", appVersion(ctx))
+            put("build", appBuild(ctx))
+        }
+
+        val frames = JSONArray()
+        for (f in mainStack) {
+            frames.put(
+                JSONObject().apply {
+                    put("function", "${f.className}.${f.methodName}")
+                    put("file", f.fileName ?: "<unknown>")
+                    put("line", f.lineNumber.coerceAtLeast(0))
+                    put("inApp", isInApp(f.className))
+                },
+            )
+        }
+
+        val error = JSONObject().apply {
+            put("type", "ApplicationNotResponding")
+            put("message", "Main thread blocked for ≥ ${DEFAULT_TIMEOUT_MS} ms")
+            put("stack", frames)
+            put("cause", JSONObject.NULL)
+        }
+
+        return JSONObject().apply {
+            put("id", uuid())
+            put("timestamp", iso8601Now())
+            put("kind", "anr")
+            put("platform", "android")
+            put("release", release)
+            put("environment", environment)
+            put("device", device)
+            put("app", app)
+            put("user", JSONObject.NULL)
+            put("tags", JSONObject().apply { put("source", "sentori.anrWatchdog") })
+            put("breadcrumbs", JSONArray())
+            put("error", error)
+            put("fingerprint", JSONArray())
+            put("traceId", JSONObject.NULL)
+            put("spanId", JSONObject.NULL)
+        }
+    }
+
+    private fun configMap(ctx: Context): Map<String, String> {
+        val prefs = ctx.getSharedPreferences("sentori", Context.MODE_PRIVATE)
+        val out = mutableMapOf<String, String>()
+        for ((k, v) in prefs.all) if (v is String) out[k] = v
+        return out
+    }
+
+    private fun isInApp(cls: String): Boolean {
+        if (cls.startsWith("android.")) return false
+        if (cls.startsWith("androidx.")) return false
+        if (cls.startsWith("java.")) return false
+        if (cls.startsWith("javax.")) return false
+        if (cls.startsWith("kotlin.")) return false
+        if (cls.startsWith("kotlinx.")) return false
+        if (cls.startsWith("com.facebook.react.")) return false
+        if (cls.startsWith("com.android.")) return false
+        if (cls.startsWith("dalvik.")) return false
+        if (cls.startsWith("sun.")) return false
+        return true
+    }
+
+    private fun iso8601Now(): String {
+        val f = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US)
+        f.timeZone = TimeZone.getTimeZone("UTC")
+        return f.format(Date())
+    }
+
+    private fun uuid(): String = UUID.randomUUID().toString().lowercase(Locale.US)
+
+    private fun appVersion(ctx: Context): String =
+        try {
+            val pi = ctx.packageManager.getPackageInfo(ctx.packageName, 0)
+            pi.versionName ?: "0.0.0"
+        } catch (_: Throwable) {
+            "0.0.0"
+        }
+
+    private fun appBuild(ctx: Context): String =
+        try {
+            val pi = ctx.packageManager.getPackageInfo(ctx.packageName, 0)
+            pi.longVersionCode.toString()
+        } catch (_: Throwable) {
+            "0"
+        }
+
+    private fun isDebuggable(ctx: Context): Boolean =
+        (ctx.applicationInfo.flags and android.content.pm.ApplicationInfo.FLAG_DEBUGGABLE) != 0
+
+    /** Posted to the main thread every poll. `armed` is flipped to
+     *  false once it actually runs. */
+    private class MainTick : Runnable {
+        @Volatile var armed = true
+
+        override fun run() {
+            armed = false
+        }
+    }
+}

package/android/src/main/java/com/sentori/SentoriModule.kt

@@ -8,6 +8,8 @@ import expo.modules.kotlin.modules.ModuleDefinition
  * as the iOS module:
  *   - setConfig({ token, release, environment })
  *   - drainPending() -> List<String>  (JSON bodies)
+ *   - startAnrWatchdog({ timeoutMs?, intervalMs?, force? })
+ *   - stopAnrWatchdog()
  */
 class SentoriModule : Module() {
     override fun definition() = ModuleDefinition {
@@ -26,6 +28,22 @@ class SentoriModule : Module() {
             SentoriCrashHandler.consumePending()
         }
 
+        // Watchdog is opt-in from JS so the host app picks the
+        // trade-off — stricter detection vs noise from the Metro
+        // debugger pausing the main thread. Pass `force: true` to
+        // run in debug builds.
+        Function("startAnrWatchdog") { options: Map<String, Any?>? ->
+            val ctx = appContext.reactContext ?: return@Function
+            val timeoutMs = (options?.get("timeoutMs") as? Number)?.toLong() ?: 5_000L
+            val intervalMs = (options?.get("intervalMs") as? Number)?.toLong() ?: 1_000L
+            val force = (options?.get("force") as? Boolean) ?: false
+            SentoriAnrWatchdog.start(ctx, timeoutMs, intervalMs, force)
+        }
+
+        Function("stopAnrWatchdog") {
+            SentoriAnrWatchdog.stop()
+        }
+
         // Dev-only helper — schedules an uncaught RuntimeException after
         // a tick so the JS bridge has time to return; the crash is then
         // captured by SentoriCrashHandler and written to

package/ios/SentoriHangWatchdog.swift

@@ -0,0 +1,219 @@
+import Foundation
+
+/// iOS hang detector — mirrors the Android ANR watchdog (Phase 22 sub-D).
+///
+/// A background thread posts a tick onto the main queue every
+/// `intervalMs` and waits `timeoutMs` for it to run. If the main run
+/// loop didn't drain the tick in time we capture the main thread's
+/// call stack and write a Sentori event with `kind = "anr"` (the
+/// dashboard already groups Android ANR + iOS hang under that kind —
+/// the user-visible distinction lives in `tags.source`).
+///
+/// Single-shot per hang: once we report, we wait for the tick to
+/// land before re-arming so a 30-second freeze doesn't dump six
+/// events. Daemon thread (DispatchSourceTimer in a background
+/// queue) so it can't keep the process alive on shutdown.
+///
+/// Disabled in DEBUG builds by default — the Xcode debugger
+/// pauses the main thread routinely and we don't want a flood. The
+/// host app can override via `start(force: true)`.
+@objc public final class SentoriHangWatchdog: NSObject {
+
+    private static let pendingDirName = "sentori/pending"
+    private static let configKey = "com.sentori.config"
+
+    private static var running: Bool = false
+    private static var queue: DispatchQueue?
+    private static var timer: DispatchSourceTimer?
+    private static let lock = NSLock()
+
+    /// Start the watchdog. Idempotent.
+    @objc public static func start(timeoutMs: Int, intervalMs: Int, force: Bool) {
+        lock.lock()
+        defer { lock.unlock() }
+        if running { return }
+        if isDebug() && !force { return }
+
+        let q = DispatchQueue(label: "com.sentori.hangWatchdog", qos: .utility)
+        let t = DispatchSource.makeTimerSource(queue: q)
+        let interval = DispatchTimeInterval.milliseconds(intervalMs)
+        let timeoutNs = UInt64(max(0, timeoutMs)) * NSEC_PER_MSEC
+
+        // The "tick" path: post a Bool flip onto the main queue and
+        // record the time we did so. Read both fields in the worker
+        // tick to decide whether the main loop is alive.
+        let state = HangState()
+
+        t.schedule(deadline: .now() + interval, repeating: interval)
+        t.setEventHandler {
+            // If the previous tick is still pending after the timeout
+            // window, the main thread is wedged. Capture once, then
+            // hold off until the main loop catches up.
+            if state.armed.value, let armedAt = state.armedAt.value {
+                let elapsedNs = DispatchTime.now().uptimeNanoseconds &- armedAt.uptimeNanoseconds
+                if elapsedNs >= timeoutNs && !state.reportedThisHang.value {
+                    state.reportedThisHang.value = true
+                    captureHang(durationMs: Int(elapsedNs / NSEC_PER_MSEC))
+                }
+                return
+            }
+
+            // Main is responsive — re-arm.
+            state.armed.value = true
+            state.armedAt.value = DispatchTime.now()
+            state.reportedThisHang.value = false
+            DispatchQueue.main.async {
+                state.armed.value = false
+                state.armedAt.value = nil
+            }
+        }
+        t.resume()
+        timer = t
+        queue = q
+        running = true
+    }
+
+    @objc public static func stop() {
+        lock.lock()
+        defer { lock.unlock() }
+        timer?.cancel()
+        timer = nil
+        queue = nil
+        running = false
+    }
+
+    private static func isDebug() -> Bool {
+        #if DEBUG
+            return true
+        #else
+            return false
+        #endif
+    }
+
+    // MARK: - capture
+
+    private static func captureHang(durationMs: Int) {
+        let cfg = UserDefaults.standard.dictionary(forKey: configKey) ?? [:]
+        let release = (cfg["release"] as? String) ?? "unknown"
+        let environment = (cfg["environment"] as? String) ?? "prod"
+
+        // Thread.callStackSymbols on the main thread is what we want;
+        // cross-thread inspection requires Mach APIs that App Store
+        // review tends to flag. Posting onto main blocks if main is
+        // wedged — we want the wedged stack, but we can't get it
+        // without main cooperation. Best-effort: capture this thread's
+        // stack (the watchdog) which is at least informative about
+        // the timing path. Phase 22 sub-F gets a proper main-thread
+        // stack via thread_state_t when we sit down with mach.
+        let frames = Thread.callStackSymbols.map { sym -> [String: Any] in
+            let parts = sym.split(
+                separator: " ", omittingEmptySubsequences: true
+            ).map(String.init)
+            let module = parts.count > 1 ? parts[1] : "<unknown>"
+            let function =
+                parts.count > 3
+                ? parts.dropFirst(3).joined(separator: " ")
+                : "<anonymous>"
+            return [
+                "function": function,
+                "file": module,
+                "line": 0,
+                "inApp": !module.contains("UIKit")
+                    && !module.contains("Foundation")
+                    && !module.contains("CoreFoundation")
+                    && !module.contains("libsystem")
+                    && !module.contains("libobjc"),
+            ]
+        }
+
+        let event: [String: Any] = [
+            "id": UUID().uuidString.lowercased(),
+            "timestamp": iso8601(Date()),
+            "kind": "anr",
+            "platform": "ios",
+            "release": release,
+            "environment": environment,
+            "device": [
+                "os": "ios",
+                "osVersion": osVersion(),
+                "model": deviceModel(),
+            ],
+            "app": appInfo(),
+            "user": NSNull(),
+            "tags": ["source": "sentori.hangWatchdog"],
+            "breadcrumbs": [Any](),
+            "error": [
+                "type": "ApplicationNotResponding",
+                "message": "Main thread blocked for ≥ \(durationMs) ms",
+                "stack": frames,
+                "cause": NSNull(),
+            ],
+            "fingerprint": [String](),
+            "traceId": NSNull(),
+            "spanId": NSNull(),
+        ]
+
+        guard
+            let docs = FileManager.default.urls(
+                for: .documentDirectory, in: .userDomainMask
+            ).first
+        else { return }
+        let dir = docs.appendingPathComponent(pendingDirName)
+        try? FileManager.default.createDirectory(
+            at: dir, withIntermediateDirectories: true)
+        let url = dir.appendingPathComponent(
+            "\(UUID().uuidString.lowercased()).json")
+        if let data = try? JSONSerialization.data(
+            withJSONObject: event, options: [])
+        {
+            try? data.write(to: url)
+        }
+    }
+
+    private static func iso8601(_ date: Date) -> String {
+        let f = ISO8601DateFormatter()
+        f.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        return f.string(from: date)
+    }
+
+    private static func osVersion() -> String {
+        let v = ProcessInfo.processInfo.operatingSystemVersion
+        return "\(v.majorVersion).\(v.minorVersion).\(v.patchVersion)"
+    }
+
+    private static func deviceModel() -> String {
+        var s = utsname()
+        uname(&s)
+        return withUnsafePointer(to: &s.machine) { ptr in
+            ptr.withMemoryRebound(to: CChar.self, capacity: 1) {
+                String(validatingUTF8: $0) ?? "unknown"
+            }
+        }
+    }
+
+    private static func appInfo() -> [String: Any] {
+        let info = Bundle.main.infoDictionary ?? [:]
+        var d: [String: Any] = [
+            "version": (info["CFBundleShortVersionString"] as? String)
+                ?? "0.0.0"
+        ]
+        if let build = info["CFBundleVersion"] as? String {
+            d["build"] = build
+        }
+        return d
+    }
+}
+
+/// Mutable boxes shared between the watchdog tick and the main-queue
+/// ack. Class so the closures can mutate without `inout` and so the
+/// references survive across the `setEventHandler` capture.
+private final class HangState {
+    let armed = Box(false)
+    let armedAt = Box<DispatchTime?>(nil)
+    let reportedThisHang = Box(false)
+}
+
+private final class Box<T> {
+    var value: T
+    init(_ v: T) { self.value = v }
+}

package/ios/SentoriModule.swift

@@ -24,6 +24,25 @@ public class SentoriModule: Module {
             return SentoriCrashHandler.consumePending()
         }
 
+        // Phase 22 sub-E: opt-in iOS hang watchdog. Same JS function
+        // name as Android (sub-D) so the host app calls
+        // `startAnrWatchdog(...)` once, both platforms react.
+        // Defaults: 2 s timeout, 1 s tick interval, debug-build off.
+        Function("startAnrWatchdog") { (options: [String: Any]?) in
+            let timeoutMs = (options?["timeoutMs"] as? Int) ?? 2000
+            let intervalMs = (options?["intervalMs"] as? Int) ?? 1000
+            let force = (options?["force"] as? Bool) ?? false
+            SentoriHangWatchdog.start(
+                timeoutMs: timeoutMs,
+                intervalMs: intervalMs,
+                force: force
+            )
+        }
+
+        Function("stopAnrWatchdog") {
+            SentoriHangWatchdog.stop()
+        }
+
         // Dev-only helper used by the example app to verify the
         // crash-write / drain round-trip without writing native code in
         // the host app. Schedules a real NSException after a tick so

package/lib/index.d.ts

@@ -13,6 +13,6 @@ export { init, init as initSentori } from './init';
 export { addBreadcrumb } from './breadcrumbs';
 export { setUser, getUser, captureError, captureException } from './capture';
 export { ErrorBoundary } from './error-boundary';
-export { triggerNativeCrash } from './native';
+export { startAnrWatchdog, stopAnrWatchdog, triggerNativeCrash, } from './native';
 export type { Event, SentoriError, Frame, Breadcrumb, BreadcrumbType, Device, DeviceOS, App, User, Tags, EventKind, Platform, } from './types';
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,eAAO,MAAM,OAAO;;;;;;;;CAQnB,CAAC;AAEF,eAAe,OAAO,CAAC;AAEvB,OAAO,EAAE,IAAI,EAAE,IAAI,IAAI,WAAW,EAAE,MAAM,QAAQ,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAE9C,YAAY,EACV,KAAK,EACL,YAAY,EACZ,KAAK,EACL,UAAU,EACV,cAAc,EACd,MAAM,EACN,QAAQ,EACR,GAAG,EACH,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,QAAQ,GACT,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,eAAO,MAAM,OAAO;;;;;;;;CAQnB,CAAC;AAEF,eAAe,OAAO,CAAC;AAEvB,OAAO,EAAE,IAAI,EAAE,IAAI,IAAI,WAAW,EAAE,MAAM,QAAQ,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,kBAAkB,GACnB,MAAM,UAAU,CAAC;AAElB,YAAY,EACV,KAAK,EACL,YAAY,EACZ,KAAK,EACL,UAAU,EACV,cAAc,EACd,MAAM,EACN,QAAQ,EACR,GAAG,EACH,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,QAAQ,GACT,MAAM,SAAS,CAAC"}

package/lib/index.js

@@ -16,5 +16,5 @@ export { init, init as initSentori } from './init';
 export { addBreadcrumb } from './breadcrumbs';
 export { setUser, getUser, captureError, captureException } from './capture';
 export { ErrorBoundary } from './error-boundary';
-export { triggerNativeCrash } from './native';
+export { startAnrWatchdog, stopAnrWatchdog, triggerNativeCrash, } from './native';
 //# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,IAAI;IACJ,aAAa;IACb,OAAO;IACP,OAAO;IACP,YAAY;IACZ,gBAAgB;IAChB,aAAa;CACd,CAAC;AAEF,eAAe,OAAO,CAAC;AAEvB,OAAO,EAAE,IAAI,EAAE,IAAI,IAAI,WAAW,EAAE,MAAM,QAAQ,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,IAAI;IACJ,aAAa;IACb,OAAO;IACP,OAAO;IACP,YAAY;IACZ,gBAAgB;IAChB,aAAa;CACd,CAAC;AAEF,eAAe,OAAO,CAAC;AAEvB,OAAO,EAAE,IAAI,EAAE,IAAI,IAAI,WAAW,EAAE,MAAM,QAAQ,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,kBAAkB,GACnB,MAAM,UAAU,CAAC"}

package/lib/native.d.ts

@@ -20,4 +20,20 @@ export declare function drainNativePending(): Promise<string[]>;
  * No-op when the native module isn't installed (jest, bun test, web).
  */
 export declare function triggerNativeCrash(): void;
+/**
+ * Phase 22 sub-D: start the Android ANR watchdog.
+ *
+ *     startAnrWatchdog()                       // default 5s/1s, prod-only
+ *     startAnrWatchdog({ force: true })        // include debug builds
+ *     startAnrWatchdog({ timeoutMs: 3000 })    // tighter threshold
+ *
+ * Returns silently on iOS / web / jest. iOS hang detection (sub-E)
+ * will hook the same JS function once landed.
+ */
+export declare function startAnrWatchdog(options?: {
+    force?: boolean;
+    intervalMs?: number;
+    timeoutMs?: number;
+}): void;
+export declare function stopAnrWatchdog(): void;
 //# sourceMappingURL=native.d.ts.map

package/lib/native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../src/native.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA4BH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IACtC,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,GAAG,IAAI,CAMP;AAED,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAQ5D;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAMzC"}
+{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../src/native.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAwCH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IACtC,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,GAAG,IAAI,CAMP;AAED,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAQ5D;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAMzC;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE;IACzC,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,IAAI,CAMP;AAED,wBAAgB,eAAe,IAAI,IAAI,CAMtC"}

package/lib/native.js

@@ -53,4 +53,30 @@ export function triggerNativeCrash() {
         // never throw from a debugging helper
     }
 }
+/**
+ * Phase 22 sub-D: start the Android ANR watchdog.
+ *
+ *     startAnrWatchdog()                       // default 5s/1s, prod-only
+ *     startAnrWatchdog({ force: true })        // include debug builds
+ *     startAnrWatchdog({ timeoutMs: 3000 })    // tighter threshold
+ *
+ * Returns silently on iOS / web / jest. iOS hang detection (sub-E)
+ * will hook the same JS function once landed.
+ */
+export function startAnrWatchdog(options) {
+    try {
+        native()?.startAnrWatchdog?.(options);
+    }
+    catch {
+        // never throw from init helpers
+    }
+}
+export function stopAnrWatchdog() {
+    try {
+        native()?.stopAnrWatchdog?.();
+    }
+    catch {
+        // ignore
+    }
+}
 //# sourceMappingURL=native.js.map

package/lib/native.js.map

@@ -1 +1 @@
-{"version":3,"file":"native.js","sourceRoot":"","sources":["../src/native.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAaH,IAAI,OAA+C,CAAA;AAEnD,SAAS,MAAM;IACb,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,OAAO,CAAA;IACzC,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,OAAO,CAAC,mBAAmB,CAEvC,CAAA;QACD,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAsB,SAAS,CAAC,CAAA;IACpE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,GAAG,IAAI,CAAA;IAChB,CAAC;IACD,OAAO,OAAO,CAAA;AAChB,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,MAI/B;IACC,IAAI,CAAC;QACH,MAAM,EAAE,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;IAC7B,CAAC;IAAC,MAAM,CAAC;QACP,sBAAsB;IACxB,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,kBAAkB;IACtC,MAAM,CAAC,GAAG,MAAM,EAAE,CAAA;IAClB,IAAI,CAAC,CAAC;QAAE,OAAO,EAAE,CAAA;IACjB,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,CAAC,YAAY,EAAE,CAAA;IAC/B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAA;IACX,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB;IAChC,IAAI,CAAC;QACH,MAAM,EAAE,EAAE,sBAAsB,EAAE,EAAE,CAAA;IACtC,CAAC;IAAC,MAAM,CAAC;QACP,sCAAsC;IACxC,CAAC;AACH,CAAC"}
+{"version":3,"file":"native.js","sourceRoot":"","sources":["../src/native.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAyBH,IAAI,OAA+C,CAAA;AAEnD,SAAS,MAAM;IACb,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,OAAO,CAAA;IACzC,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,OAAO,CAAC,mBAAmB,CAEvC,CAAA;QACD,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAsB,SAAS,CAAC,CAAA;IACpE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,GAAG,IAAI,CAAA;IAChB,CAAC;IACD,OAAO,OAAO,CAAA;AAChB,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,MAI/B;IACC,IAAI,CAAC;QACH,MAAM,EAAE,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;IAC7B,CAAC;IAAC,MAAM,CAAC;QACP,sBAAsB;IACxB,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,kBAAkB;IACtC,MAAM,CAAC,GAAG,MAAM,EAAE,CAAA;IAClB,IAAI,CAAC,CAAC;QAAE,OAAO,EAAE,CAAA;IACjB,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,CAAC,YAAY,EAAE,CAAA;IAC/B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAA;IACX,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB;IAChC,IAAI,CAAC;QACH,MAAM,EAAE,EAAE,sBAAsB,EAAE,EAAE,CAAA;IACtC,CAAC;IAAC,MAAM,CAAC;QACP,sCAAsC;IACxC,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAIhC;IACC,IAAI,CAAC;QACH,MAAM,EAAE,EAAE,gBAAgB,EAAE,CAAC,OAAO,CAAC,CAAA;IACvC,CAAC;IAAC,MAAM,CAAC;QACP,gCAAgC;IAClC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,IAAI,CAAC;QACH,MAAM,EAAE,EAAE,eAAe,EAAE,EAAE,CAAA;IAC/B,CAAC;IAAC,MAAM,CAAC;QACP,SAAS;IACX,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goliapkg/sentori-react-native",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Sentori SDK for React Native \u2014 JS-layer error capture, native crash handlers (iOS / Android), batched transport.",
   "license": "MIT",
   "homepage": "https://sentori.golia.jp",
@@ -64,6 +64,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@goliapkg/sentori-core": "0.1.0"
+    "@goliapkg/sentori-core": "0.2.0"
   }
 }

package/src/index.ts

@@ -19,7 +19,11 @@ export { init, init as initSentori } from './init';
 export { addBreadcrumb } from './breadcrumbs';
 export { setUser, getUser, captureError, captureException } from './capture';
 export { ErrorBoundary } from './error-boundary';
-export { triggerNativeCrash } from './native';
+export {
+  startAnrWatchdog,
+  stopAnrWatchdog,
+  triggerNativeCrash,
+} from './native';
 
 export type {
   Event,

package/src/native.ts

@@ -11,6 +11,18 @@ type SentoriNativeModule = {
     release: string
     token: string
   }) => void
+  /**
+   * Phase 22 sub-D: opt-in Android ANR watchdog. Posts a tick to the
+   * main looper every `intervalMs`; if not acknowledged within
+   * `timeoutMs`, captures the main-thread stack as an `anr` event.
+   * No-op on iOS today — iOS hang detection lands in sub-E.
+   */
+  startAnrWatchdog?: (options?: {
+    force?: boolean
+    intervalMs?: number
+    timeoutMs?: number
+  }) => void
+  stopAnrWatchdog?: () => void
   /** Dev-only — example app uses this to verify the crash flow. */
   triggerTestNativeCrash?: () => void
 }
@@ -69,3 +81,33 @@ export function triggerNativeCrash(): void {
     // never throw from a debugging helper
   }
 }
+
+/**
+ * Phase 22 sub-D: start the Android ANR watchdog.
+ *
+ *     startAnrWatchdog()                       // default 5s/1s, prod-only
+ *     startAnrWatchdog({ force: true })        // include debug builds
+ *     startAnrWatchdog({ timeoutMs: 3000 })    // tighter threshold
+ *
+ * Returns silently on iOS / web / jest. iOS hang detection (sub-E)
+ * will hook the same JS function once landed.
+ */
+export function startAnrWatchdog(options?: {
+  force?: boolean
+  intervalMs?: number
+  timeoutMs?: number
+}): void {
+  try {
+    native()?.startAnrWatchdog?.(options)
+  } catch {
+    // never throw from init helpers
+  }
+}
+
+export function stopAnrWatchdog(): void {
+  try {
+    native()?.stopAnrWatchdog?.()
+  } catch {
+    // ignore
+  }
+}