@goliapkg/sentori-react-native 0.9.0 → 0.9.2

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

@@ -47,6 +47,9 @@ object SentoriCrashHandler {
         // foreground Activity so it knows which Window to PixelCopy.
         (appCtx as? android.app.Application)?.let {
             SentoriScreenshotCapture.register(it)
+            // v0.9.6 #2 — replay capture also tracks the activity for
+            // wireframe view-tree walks.
+            SentoriReplayCapture.register(it)
         }
     }
 
@@ -119,6 +122,16 @@ object SentoriCrashHandler {
 
         val error = errorToJson(throwable)
 
+        // v0.9.5 #7 — detect crashes originating from native code (JNI
+        // / .so libs). Pure SIGSEGV in a stripped .so won't reach us
+        // without breakpad (queued for v1.1), but throws that surface
+        // as UnsatisfiedLinkError or have native frames in the stack
+        // are tagged so the dashboard can split them out.
+        val tags = JSONObject()
+        if (SentoriNativeOrigin.looksNative(throwable)) {
+            tags.put("native_signal", "true")
+        }
+
         val event = JSONObject().apply {
             put("id", uuidLower())
             put("timestamp", iso8601Now())
@@ -129,7 +142,7 @@ object SentoriCrashHandler {
             put("device", device)
             put("app", app)
             put("user", JSONObject.NULL)
-            put("tags", JSONObject())
+            put("tags", tags)
             put("breadcrumbs", JSONArray())
             put("error", error)
             put("fingerprint", JSONArray())

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

@@ -24,6 +24,16 @@ class SentoriModule : Module() {
             SentoriMobileVitals.startFrameWatch()
         }
 
+        // v0.9.5 #8 — TurboModule exception bridge readout.
+        Function("getRecentNativeException") {
+            SentoriNativeExceptionBridge.getRecent()
+        }
+
+        // v0.9.6 #2 — wireframe session replay capture.
+        Function("captureWireframe") { maskedIds: List<String> ->
+            SentoriReplayCapture.captureWireframe(maskedIds)
+        }
+
         // v0.9.4 #1 — Mobile Vitals exposure.
         Function("markJsBridgeReady") {
             SentoriMobileVitals.markJsBridgeReady()

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

@@ -0,0 +1,75 @@
+package com.sentori
+
+import java.util.concurrent.ConcurrentLinkedDeque
+import java.util.concurrent.atomic.AtomicLong
+
+/**
+ * v0.9.5 #8 — partial fix for TurboModule swallowing native
+ * exceptions into a generic JSError.
+ *
+ * Android side mirrors the iOS implementation. Host TurboModule code:
+ *
+ *   try {
+ *     riskyOperation()
+ *   } catch (e: Exception) {
+ *     SentoriNativeExceptionBridge.record(e)
+ *     throw e
+ *   }
+ *
+ * JS-side coerceError calls `getRecent()` and, if an exception
+ * within the last 1 s exists, attaches its stack to the resulting
+ * sentori event.
+ */
+object SentoriNativeExceptionBridge {
+
+    private const val RING_SIZE = 8
+    private const val WINDOW_MS = 1_000L
+
+    private data class Stash(
+        val timestamp: Long,
+        val name: String,
+        val reason: String,
+        val stack: List<String>,
+    )
+
+    private val ring = ConcurrentLinkedDeque<Stash>()
+    private val lastPurgeAt = AtomicLong(0)
+
+    @JvmStatic
+    fun record(t: Throwable) {
+        val frames = t.stackTrace.take(48).map { it.toString() }
+        val stash = Stash(
+            timestamp = System.currentTimeMillis(),
+            name = t.javaClass.simpleName,
+            reason = t.message ?: "",
+            stack = frames,
+        )
+        ring.addLast(stash)
+        while (ring.size > RING_SIZE) ring.pollFirst()
+        purgeIfDue()
+    }
+
+    @JvmStatic
+    fun getRecent(): Map<String, Any?>? {
+        purgeIfDue()
+        val latest = ring.peekLast() ?: return null
+        return mapOf(
+            "name" to latest.name,
+            "reason" to latest.reason,
+            "stack" to latest.stack,
+            "ageMs" to (System.currentTimeMillis() - latest.timestamp).toInt(),
+        )
+    }
+
+    private fun purgeIfDue() {
+        val now = System.currentTimeMillis()
+        val last = lastPurgeAt.get()
+        if (now - last < 100) return
+        lastPurgeAt.set(now)
+        val cutoff = now - WINDOW_MS
+        val it = ring.iterator()
+        while (it.hasNext()) {
+            if (it.next().timestamp < cutoff) it.remove()
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+package com.sentori
+
+/**
+ * v0.9.5 #7 — Android NDK origin detection (stub).
+ *
+ * Pure-Kotlin heuristics to tag a Throwable as "originated in native
+ * code" so the dashboard can show NDK crashes separately from JVM
+ * crashes. Real breakpad/crashpad integration (with minidump +
+ * dump_syms symbolicator) is queued for v1.1 — see
+ * `docs/design/v1-roadmap.md` #7.
+ */
+object SentoriNativeOrigin {
+
+    /** Returns true iff this throwable likely originated in native
+     *  (NDK / .so / JNI) code. Used by `SentoriCrashHandler.write` to
+     *  flip the `native_signal` tag on the event. */
+    @JvmStatic
+    fun looksNative(t: Throwable): Boolean {
+        val name = t.javaClass.simpleName
+        if (name == "UnsatisfiedLinkError") return true
+        // OutOfMemoryError can be either JVM or native allocator;
+        // bias toward native since pure-JVM OOM is rare on modern
+        // Android with heap auto-growth.
+        if (name == "OutOfMemoryError") return true
+        return t.stackTrace.any { f ->
+            val cls = f.className
+            cls.contains("jni", ignoreCase = true) ||
+                cls.contains("native", ignoreCase = true) ||
+                f.fileName?.endsWith(".so") == true
+        }
+    }
+}

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

@@ -0,0 +1,153 @@
+package com.sentori
+
+import android.app.Activity
+import android.graphics.Rect
+import android.view.View
+import android.view.ViewGroup
+import android.widget.EditText
+import android.widget.ImageView
+import android.widget.TextView
+import org.json.JSONArray
+import org.json.JSONObject
+import java.lang.ref.WeakReference
+
+/**
+ * v0.9.6 #2 — wireframe session replay (Android side).
+ *
+ * Mirrors SentoriReplayCapture.swift. Walks View hierarchy from the
+ * current activity's decor view at 1 Hz. Each visible node becomes
+ * a JSON dict { kind, x, y, w, h, text?, color? }. Returns one JSON
+ * object string per snapshot.
+ *
+ * Mask: nodes whose `View.tag` (cast to String) matches `maskedIds`
+ * render as a single black "mask" rect. Descendants of a masked
+ * node are not emitted.
+ */
+object SentoriReplayCapture {
+
+    private const val MAX_NODES = 800
+
+    @Volatile private var lastActivity: WeakReference<Activity>? = null
+
+    @JvmStatic
+    fun setActivity(activity: Activity?) {
+        lastActivity = activity?.let { WeakReference(it) }
+    }
+
+    /** Attach an ActivityLifecycleCallbacks so future
+     *  `captureWireframe()` calls know which Activity to walk. */
+    @JvmStatic
+    fun register(application: android.app.Application) {
+        application.registerActivityLifecycleCallbacks(object :
+            android.app.Application.ActivityLifecycleCallbacks {
+            override fun onActivityCreated(a: Activity, b: android.os.Bundle?) { setActivity(a) }
+            override fun onActivityStarted(a: Activity) { setActivity(a) }
+            override fun onActivityResumed(a: Activity) { setActivity(a) }
+            override fun onActivityPaused(a: Activity) {}
+            override fun onActivityStopped(a: Activity) {}
+            override fun onActivitySaveInstanceState(a: Activity, b: android.os.Bundle) {}
+            override fun onActivityDestroyed(a: Activity) {}
+        })
+    }
+
+    @JvmStatic
+    fun captureWireframe(maskedIds: List<String>): String? {
+        val activity = lastActivity?.get() ?: return null
+        val root = activity.window?.decorView ?: return null
+        if (root.width <= 0 || root.height <= 0) return null
+
+        val maskedSet = maskedIds.toHashSet()
+        val nodes = JSONArray()
+        val rect = Rect()
+        val rootLoc = IntArray(2).also { root.getLocationInWindow(it) }
+        walk(root, false, maskedSet, rootLoc, rect, nodes)
+
+        val payload = JSONObject().apply {
+            put("ts", System.currentTimeMillis())
+            put("width", root.width)
+            put("height", root.height)
+            put("nodes", nodes)
+        }
+        return payload.toString()
+    }
+
+    private fun walk(
+        view: View,
+        parentMasked: Boolean,
+        maskedSet: Set<String>,
+        rootLoc: IntArray,
+        scratch: Rect,
+        nodes: JSONArray,
+    ) {
+        if (nodes.length() >= MAX_NODES) return
+        if (view.visibility != View.VISIBLE || view.alpha < 0.01) return
+
+        val viewTag = view.tag as? String
+        val isThisMasked = viewTag != null && maskedSet.contains(viewTag)
+        val masked = parentMasked || isThisMasked
+
+        val loc = IntArray(2)
+        view.getLocationInWindow(loc)
+        val x = loc[0] - rootLoc[0]
+        val y = loc[1] - rootLoc[1]
+        val w = view.width
+        val h = view.height
+        if (w <= 0 || h <= 0) return
+
+        val node = JSONObject().apply {
+            put("x", x)
+            put("y", y)
+            put("w", w)
+            put("h", h)
+        }
+
+        var kindEmitted = false
+        when {
+            masked -> {
+                node.put("kind", "mask")
+                kindEmitted = true
+            }
+            view is TextView && !view.text.isNullOrEmpty() -> {
+                node.put("kind", "text")
+                val text = view.text.toString().let { if (it.length > 200) it.substring(0, 200) else it }
+                node.put("text", text)
+                node.put("color", colorToHex(view.currentTextColor))
+                kindEmitted = true
+            }
+            view is EditText -> {
+                node.put("kind", "text")
+                val text = (view.text ?: "").toString().let { if (it.length > 200) it.substring(0, 200) else it }
+                node.put("text", text)
+                kindEmitted = true
+            }
+            view is ImageView -> {
+                node.put("kind", "image")
+                kindEmitted = true
+            }
+            view.background != null -> {
+                node.put("kind", "rect")
+                // Background drawables don't always expose color directly.
+                // Skip color for non-ColorDrawable; renderer falls back to neutral.
+                kindEmitted = true
+            }
+        }
+
+        if (kindEmitted) {
+            nodes.put(node)
+        }
+
+        if (!masked && view is ViewGroup) {
+            for (i in 0 until view.childCount) {
+                walk(view.getChildAt(i), masked, maskedSet, rootLoc, scratch, nodes)
+            }
+        }
+    }
+
+    private fun colorToHex(c: Int): String {
+        val a = (c shr 24) and 0xff
+        val r = (c shr 16) and 0xff
+        val g = (c shr 8) and 0xff
+        val b = c and 0xff
+        return String.format("#%02X%02X%02X%02X", r, g, b, a)
+    }
+}

package/ios/SentoriModule.swift

@@ -19,6 +19,17 @@ public class SentoriModule: Module {
             SentoriMobileVitals.startFrameWatch()
         }
 
+        // v0.9.5 #8 — TurboModule exception bridge readout for
+        // coerceError to attach native stack to wrapped JSError.
+        Function("getRecentNativeException") { () -> [String: Any]? in
+            return SentoriNativeExceptionBridge.getRecentException()
+        }
+
+        // v0.9.6 #2 — wireframe session replay capture.
+        Function("captureWireframe") { (maskedIds: [String]) -> String? in
+            return SentoriReplayCapture.captureWireframe(maskedIds: maskedIds)
+        }
+
         // v0.9.4 #1 — Mobile Vitals exposure.
         Function("markJsBridgeReady") {
             SentoriMobileVitals.markJsBridgeReady()

package/ios/SentoriNativeExceptionBridge.swift

@@ -0,0 +1,90 @@
+import Foundation
+
+/// v0.9.5 #8 — partial-fix for the "TurboModule swallows NSException
+/// into a generic JSError" gap.
+///
+/// We can't easily swizzle the C++ ObjCTurboModule call site that does
+/// the swallowing. What we *can* offer is an escape hatch: host code
+/// inside a TurboModule method wraps its native call in `@try @catch`
+/// and calls `SentoriNativeExceptionBridge.record(exception)` from the
+/// catch block. We stash the exception (name + reason + callStackSymbols)
+/// in a static ring with timestamps. When the JS side then receives
+/// the generic JSError that RN wraps it into, `coerceError` checks the
+/// ring for an exception within the last 1 s and attaches the native
+/// stack to the JS error event.
+///
+/// Usage from a host TurboModule (Swift example):
+///
+///   @objc func mySensitiveMethod() {
+///     do {
+///       try riskyNativeOperation()
+///     } catch let nsException as NSException {
+///       SentoriNativeExceptionBridge.record(nsException)
+///       throw nsException
+///     }
+///   }
+///
+/// Or Objective-C:
+///
+///   @try {
+///     riskyOp();
+///   } @catch (NSException *e) {
+///     [SentoriNativeExceptionBridge recordException:e];
+///     @throw;
+///   }
+
+@objc public final class SentoriNativeExceptionBridge: NSObject {
+
+    private static let RING_SIZE = 8
+    private static let WINDOW_MS: Double = 1000
+
+    private struct Stash {
+        let timestamp: Date
+        let name: String
+        let reason: String
+        let stack: [String]
+    }
+
+    private static var ring: [Stash] = []
+    private static let lock = NSLock()
+
+    /// Called from a `@catch` inside a TurboModule method. Records
+    /// the exception's name + reason + callStackSymbols for ~1 s so
+    /// the JS-side coerceError can pick it up.
+    @objc public static func recordException(_ exception: NSException) {
+        let stash = Stash(
+            timestamp: Date(),
+            name: exception.name.rawValue,
+            reason: exception.reason ?? "",
+            stack: exception.callStackSymbols
+        )
+        lock.lock()
+        defer { lock.unlock() }
+        ring.append(stash)
+        while ring.count > RING_SIZE {
+            ring.removeFirst()
+        }
+    }
+
+    /// Called by JS-side bridge. Returns the most recent exception
+    /// within the last 1 s, or nil. Does NOT remove from the ring —
+    /// the same NSException may surface as multiple JSError frames
+    /// across the bridge. Ring is cleared by `purge()` on a timer.
+    @objc public static func getRecentException() -> [String: Any]? {
+        lock.lock()
+        defer { lock.unlock() }
+        purgeLocked()
+        guard let latest = ring.last else { return nil }
+        return [
+            "name": latest.name,
+            "reason": latest.reason,
+            "stack": latest.stack,
+            "ageMs": Int(Date().timeIntervalSince(latest.timestamp) * 1000),
+        ]
+    }
+
+    private static func purgeLocked() {
+        let now = Date()
+        ring.removeAll { now.timeIntervalSince($0.timestamp) * 1000 > WINDOW_MS }
+    }
+}

package/ios/SentoriReplayCapture.swift

@@ -0,0 +1,147 @@
+import Foundation
+import UIKit
+
+/// v0.9.6 #2 — wireframe session replay (iOS side).
+///
+/// Walks the UIView hierarchy at 1 Hz and serializes each visible
+/// node as a compact JSON dict:
+///   { kind, x, y, w, h, text?, color? }
+///
+/// Mask: nodes whose `accessibilityIdentifier` matches the JS-side
+/// mask registry (passed in as `maskedIds`) have their text replaced
+/// with "***" and the masked flag set so descendants render as
+/// black-filled rects in the dashboard player.
+///
+/// Output: one JSON object per snapshot, returned as a string. The
+/// JS side appends each snapshot to a 60-slot ring buffer; on
+/// `captureException` the ring is uploaded as a `replay` attachment
+/// (NDJSON: one snapshot per line).
+@objc public final class SentoriReplayCapture: NSObject {
+
+    @objc public static func captureWireframe(maskedIds: [String]) -> String? {
+        if Thread.isMainThread {
+            return captureSync(maskedIds: Set(maskedIds))
+        }
+        var result: String?
+        DispatchQueue.main.sync {
+            result = captureSync(maskedIds: Set(maskedIds))
+        }
+        return result
+    }
+
+    private static func captureSync(maskedIds: Set<String>) -> String? {
+        guard let window = keyWindow() else { return nil }
+        var nodes: [[String: Any]] = []
+        walk(
+            view: window,
+            parentMasked: false,
+            maskedIds: maskedIds,
+            window: window,
+            nodes: &nodes
+        )
+        let payload: [String: Any] = [
+            "ts": Int(Date().timeIntervalSince1970 * 1000),
+            "width": Double(window.bounds.width),
+            "height": Double(window.bounds.height),
+            "nodes": nodes,
+        ]
+        if let data = try? JSONSerialization.data(withJSONObject: payload, options: []) {
+            return String(data: data, encoding: .utf8)
+        }
+        return nil
+    }
+
+    private static func keyWindow() -> UIWindow? {
+        if #available(iOS 13.0, *) {
+            for scene in UIApplication.shared.connectedScenes {
+                guard let ws = scene as? UIWindowScene else { continue }
+                if let key = ws.windows.first(where: { $0.isKeyWindow }) {
+                    return key
+                }
+                if let first = ws.windows.first {
+                    return first
+                }
+            }
+        }
+        return UIApplication.shared.windows.first
+    }
+
+    /// Cap on nodes per snapshot — extremely deep / wide trees can
+    /// have thousands of subviews (UICollectionView recyclers).
+    private static let MAX_NODES = 800
+
+    private static func walk(
+        view: UIView,
+        parentMasked: Bool,
+        maskedIds: Set<String>,
+        window: UIWindow,
+        nodes: inout [[String: Any]]
+    ) {
+        if nodes.count >= MAX_NODES { return }
+        if view.isHidden || view.alpha < 0.01 { return }
+
+        let isThisMasked = view.accessibilityIdentifier
+            .map { maskedIds.contains($0) } ?? false
+        let masked = parentMasked || isThisMasked
+
+        let frame = view.convert(view.bounds, to: window)
+        // Skip nodes outside the window bounds (off-screen recyclers).
+        if !frame.intersects(window.bounds) {
+            return
+        }
+
+        var node: [String: Any] = [
+            "x": Double(frame.origin.x),
+            "y": Double(frame.origin.y),
+            "w": Double(frame.size.width),
+            "h": Double(frame.size.height),
+        ]
+
+        if masked {
+            node["kind"] = "mask"
+        } else if let label = view as? UILabel, let text = label.text, !text.isEmpty {
+            node["kind"] = "text"
+            node["text"] = text.count > 200 ? String(text.prefix(200)) : text
+            if let color = label.textColor.flatMap(colorToHex) {
+                node["color"] = color
+            }
+        } else if let textView = view as? UITextView, let text = textView.text, !text.isEmpty {
+            node["kind"] = "text"
+            node["text"] = text.count > 200 ? String(text.prefix(200)) : text
+        } else if view is UIImageView {
+            node["kind"] = "image"
+        } else if let bg = view.backgroundColor, let hex = colorToHex(bg), hex != "#00000000" {
+            node["kind"] = "rect"
+            node["color"] = hex
+        }
+        // else: invisible container — skip emitting but recurse.
+
+        if node["kind"] != nil {
+            nodes.append(node)
+        }
+
+        if !masked {
+            // Don't expose internals of masked subtrees.
+            for sub in view.subviews {
+                walk(
+                    view: sub,
+                    parentMasked: masked,
+                    maskedIds: maskedIds,
+                    window: window,
+                    nodes: &nodes
+                )
+            }
+        }
+    }
+
+    private static func colorToHex(_ color: UIColor?) -> String? {
+        guard let c = color else { return nil }
+        var r: CGFloat = 0, g: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
+        c.getRed(&r, green: &g, blue: &b, alpha: &a)
+        let ri = max(0, min(255, Int(r * 255)))
+        let gi = max(0, min(255, Int(g * 255)))
+        let bi = max(0, min(255, Int(b * 255)))
+        let ai = max(0, min(255, Int(a * 255)))
+        return String(format: "#%02X%02X%02X%02X", ri, gi, bi, ai)
+    }
+}

package/lib/capture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../src/capture.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAoD,IAAI,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE5F,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAgB5D,eAAO,MAAM,+BAA+B,QAAO,IAElD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,IAAI,GAAG,IAAI,KAAG,IAE3C,CAAC;AAEF,eAAO,MAAM,OAAO,QAAO,IAAI,GAAG,IAAa,CAAC;AAEhD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB;;;qDAGiD;IACjD,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAAU,OAAO;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,KAAG,OAAO,CAAC,IAAI,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,GAAG,MAAM,CAAA;CAAE,CAKxD,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,OAAO,KAAK,EAAE,SAAS,aAAa,KAAG,IAqEnE,CAAC;AAiEF,eAAO,MAAM,gBAAgB,UAtIO,KAAK,WAAW,aAAa,KAAG,IAsIxB,CAAC"}
+{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../src/capture.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAoD,IAAI,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE5F,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAgB5D,eAAO,MAAM,+BAA+B,QAAO,IAElD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,IAAI,GAAG,IAAI,KAAG,IAE3C,CAAC;AAEF,eAAO,MAAM,OAAO,QAAO,IAAI,GAAG,IAAa,CAAC;AAEhD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB;;;qDAGiD;IACjD,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAAU,OAAO;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,KAAG,OAAO,CAAC,IAAI,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,GAAG,MAAM,CAAA;CAAE,CAKxD,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,OAAO,KAAK,EAAE,SAAS,aAAa,KAAG,IA2EnE,CAAC;AAyFF,eAAO,MAAM,gBAAgB,UApKO,KAAK,WAAW,aAAa,KAAG,IAoKxB,CAAC"}

package/lib/capture.js

@@ -3,6 +3,7 @@ import { addBreadcrumb, getBreadcrumbs } from './breadcrumbs';
 import { getBundleInfo } from './bundle-info';
 import { getConfig, isInitialized } from './config';
 import { getFeatureFlagSnapshot } from './feature-flags';
+import { drainReplay } from './replay';
 import { clearStateSnapshots, getStateSnapshots } from './state-snapshots';
 import { symbolicateErrorViaMetro } from './handlers/dev-symbolicate';
 import { captureScreenshot } from './handlers/screenshot';
@@ -12,6 +13,7 @@ import { getTrailBuffer } from './trail';
 import { enqueue, sendUserReport, uploadAttachment } from './transport';
 import { uuidV7 } from './uuid';
 import { getCachedNetworkType } from './netinfo';
+import { getRecentNativeException } from './native';
 export { captureStep, __resetTrailForTests } from './trail';
 let _user = null;
 // Phase 42 sub-D.08 — per-session screenshot quota. Defaults: 10 in
@@ -121,10 +123,35 @@ export const captureError = (error, extras) => {
             await captureAndAttachStateSnapshots(event, stateSnapshots);
             clearStateSnapshots();
         }
+        // v0.9.6 #2 — wireframe replay attachment. drainReplay clears the
+        // ring as a side effect so next session's replay starts fresh.
+        const replayNdjson = drainReplay();
+        if (replayNdjson.length > 0) {
+            await captureAndAttachReplay(event, replayNdjson);
+        }
         enqueue(event);
     };
     void pipeline();
 };
+/** v0.9.6 #2 — upload the wireframe replay ring as a `replay`
+ *  attachment. Plain NDJSON (one snapshot per line) — server may
+ *  gzip on storage; the network upload is base64. */
+async function captureAndAttachReplay(event, ndjson) {
+    try {
+        const base64 = typeof globalThis.btoa === 'function'
+            ? globalThis.btoa(ndjson)
+            : Buffer.from(ndjson, 'utf8').toString('base64');
+        const meta = await uploadAttachment(event.id, 'replay', { base64, mediaType: 'application/x-ndjson' }, { source: 'js' });
+        if (meta) {
+            if (!event.attachments)
+                event.attachments = [];
+            event.attachments.push(meta);
+        }
+    }
+    catch {
+        // best-effort
+    }
+}
 /** v0.9.2 +S2 — upload the rolling state-snapshot ring as a
  *  `stateSnapshot` attachment so the dashboard time-travel viewer can
  *  scrub through diffs alongside the breadcrumb timeline. */
@@ -219,6 +246,26 @@ const errorToObject = (error) => {
     if (causeRaw instanceof Error) {
         cause = errorToObject(causeRaw);
     }
+    // v0.9.5 #8 — TurboModule swallowed-exception bridge. If the host
+    // wrapped a native call with `@try @catch + recordException`, the
+    // native ring may hold a fresh entry (< 1 s old). Synthesize that
+    // as a `cause` so the JS event includes the original native stack.
+    if (cause === null) {
+        const recent = getRecentNativeException();
+        if (recent && recent.ageMs <= 1500) {
+            cause = {
+                type: recent.name || 'NativeException',
+                message: recent.reason,
+                stack: recent.stack.map((line, i) => ({
+                    function: line.trim(),
+                    file: '<native>',
+                    inApp: false,
+                    line: i + 1,
+                })),
+                cause: null,
+            };
+        }
+    }
     return {
         type: error.name || 'Error',
         message: error.message,