@goliapkg/sentori-react-native 0.9.11 → 1.0.0-rc.10

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

@@ -1,13 +1,11 @@
 package com.sentori
 
-import android.app.Activity
 import android.app.Application
 import android.graphics.Bitmap
 import android.graphics.Canvas
 import android.graphics.Color
 import android.graphics.Paint
 import android.os.Build
-import android.os.Bundle
 import android.os.Handler
 import android.os.HandlerThread
 import android.util.Base64
@@ -16,7 +14,6 @@ import android.view.View
 import android.view.ViewGroup
 import android.view.Window
 import java.io.ByteArrayOutputStream
-import java.lang.ref.WeakReference
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 import org.json.JSONArray
@@ -60,36 +57,44 @@ object SentoriScreenshotCapture {
     private const val MAX_NODES = 1500
     private const val PIXEL_COPY_TIMEOUT_MS = 200L
 
-    /// Latest activity we've seen via `ActivityLifecycleCallbacks` —
-    /// used to find the window to screenshot when neither the JS
-    /// side (which knows of `Activity.this` via React Native) nor
-    /// the crash handler hands one to us.
-    @Volatile private var lastActivity: WeakReference<Activity>? = null
+    // v1.0.0-rc.2 — diagnostic readout so the JS side can ask
+    // "why did screenshot return null" without parsing logcat. Mirrors
+    // SentoriReplayCapture.probe() and the iOS Swift probe.
+    @Volatile private var lastDiagPath: String = "none(not-yet-called)"
+    @Volatile private var lastDiagW: Int = 0
+    @Volatile private var lastDiagH: Int = 0
 
     /**
-     * Attach an `ActivityLifecycleCallbacks` so subsequent
-     * `captureScreen()` calls know which Activity (and therefore
-     * Window) to target. Idempotent; call from
-     * `SentoriCrashHandler.register(context)`.
+     * Snapshot of the most recent capture attempt — what code path
+     * resolved an Activity, what the decor view's dimensions were,
+     * and what call source the foreground tracker last saw the
+     * Activity from. Used by `probeNativeScreenshot()` on the JS
+     * side so Insight can ship raw diagnostic state back without
+     * needing logcat access.
+     */
+    @JvmStatic
+    fun probe(): Map<String, Any> {
+        val tracked = SentoriForegroundActivity.current()
+        return mapOf(
+            "lastPath" to lastDiagPath,
+            "lastWidth" to lastDiagW,
+            "lastHeight" to lastDiagH,
+            "trackedSource" to SentoriForegroundActivity.lastPath,
+            "trackedActivity" to (tracked?.javaClass?.name ?: "null"),
+            "decorViewFound" to (tracked?.window?.decorView != null),
+        )
+    }
+
+    /**
+     * Idempotent. Wires the screenshot helper into the shared
+     * foreground-activity tracker; kept as a public entrypoint for
+     * backwards compat with existing call sites (the crash handler
+     * still calls this), but the actual lifecycle subscription lives
+     * in [SentoriForegroundActivity].
      */
     @JvmStatic
     fun register(application: Application) {
-        application.registerActivityLifecycleCallbacks(object :
-            Application.ActivityLifecycleCallbacks {
-            override fun onActivityCreated(a: Activity, b: Bundle?) {
-                lastActivity = WeakReference(a)
-            }
-            override fun onActivityStarted(a: Activity) {
-                lastActivity = WeakReference(a)
-            }
-            override fun onActivityResumed(a: Activity) {
-                lastActivity = WeakReference(a)
-            }
-            override fun onActivityPaused(a: Activity) {}
-            override fun onActivityStopped(a: Activity) {}
-            override fun onActivitySaveInstanceState(a: Activity, b: Bundle) {}
-            override fun onActivityDestroyed(a: Activity) {}
-        })
+        SentoriForegroundActivity.install(application)
     }
 
     /**
@@ -102,8 +107,16 @@ object SentoriScreenshotCapture {
      */
     @JvmStatic
     fun captureKeyWindow(): Map<String, Any>? {
-        val activity = lastActivity?.get() ?: return null
-        val window = activity.window ?: return null
+        val activity = SentoriForegroundActivity.current()
+        if (activity == null) {
+            lastDiagPath = "activity.null"
+            return null
+        }
+        val window = activity.window
+        if (window == null) {
+            lastDiagPath = "window.null"
+            return null
+        }
         val out = mutableMapOf<String, Any>()
         captureScreen(window, emptySet())?.let { (base64, mediaType) ->
             out["screenshot"] = mapOf("base64" to base64, "mediaType" to mediaType)
@@ -120,8 +133,16 @@ object SentoriScreenshotCapture {
     /// masked subview's frame on the captured bitmap.
     @JvmStatic
     fun captureScreenshotWithMask(maskedIds: List<String>): Map<String, String>? {
-        val activity = lastActivity?.get() ?: return null
-        val window = activity.window ?: return null
+        val activity = SentoriForegroundActivity.current()
+        if (activity == null) {
+            lastDiagPath = "activity.null"
+            return null
+        }
+        val window = activity.window
+        if (window == null) {
+            lastDiagPath = "window.null"
+            return null
+        }
         val (base64, mediaType) = captureScreen(window, maskedIds.toHashSet()) ?: return null
         return mapOf("base64" to base64, "mediaType" to mediaType)
     }
@@ -135,12 +156,22 @@ object SentoriScreenshotCapture {
             // requires the activity not to be torn down. Skip for
             // now; v0.6.1 SDK can add the fallback if real-world
             // data shows we have users below API 24.
+            lastDiagPath = "api.unsupported"
+            return null
+        }
+        val decor = window.decorView
+        if (decor == null) {
+            lastDiagPath = "decorView.null"
             return null
         }
-        val decor = window.decorView ?: return null
         val w = decor.width
         val h = decor.height
-        if (w <= 0 || h <= 0) return null
+        lastDiagW = w
+        lastDiagH = h
+        if (w <= 0 || h <= 0) {
+            lastDiagPath = "decorView.zero-size"
+            return null
+        }
 
         // Long-edge scale.
         val longEdge = maxOf(w, h).toFloat()
@@ -175,12 +206,17 @@ object SentoriScreenshotCapture {
                 )
             }
             latch.await(PIXEL_COPY_TIMEOUT_MS, TimeUnit.MILLISECONDS)
-        } catch (_: Throwable) {
+        } catch (t: Throwable) {
+            lastDiagPath = "pixelCopy.threw:${t.javaClass.simpleName}"
             return null
         } finally {
             handlerThread.quitSafely()
         }
-        if (!success) return null
+        if (!success) {
+            lastDiagPath = "pixelCopy.notSuccess"
+            return null
+        }
+        lastDiagPath = "ok"
 
         // v0.7.3 — paint black rectangles over masked subviews on the
         // already-captured bitmap. We get window-relative coordinates

package/ios/SentoriModule.swift

@@ -30,6 +30,21 @@ public class SentoriModule: Module {
             return SentoriReplayCapture.captureWireframe(maskedIds: maskedIds)
         }
 
+        // v0.9.12 — diagnostic readout for replay. Returns the last
+        // keyWindow resolution path + scene/window counts so a single
+        // JS-side button can answer "why is my ring empty?" without
+        // re-rolling the pod. See SentoriReplayCapture.swift.
+        Function("probeWireframe") { () -> [String: Any] in
+            return SentoriReplayCapture.probe()
+        }
+
+        // v1.0.0-rc.2 — diagnostic readout for screenshot. Same shape
+        // as Android side; lets Insight ship raw state back when the
+        // captureScreenshot path returns null.
+        Function("probeScreenshot") { () -> [String: Any] in
+            return SentoriScreenshotCapture.probe()
+        }
+
         // v0.9.4 #1 — Mobile Vitals exposure.
         Function("markJsBridgeReady") {
             SentoriMobileVitals.markJsBridgeReady()

package/ios/SentoriReplayCapture.swift

@@ -29,16 +29,69 @@ import UIKit
         return result
     }
 
+    /// Diagnostic readouts exposed to JS via `probeWireframe()`.
+    ///
+    /// v0.9.12: lastPath / lastNodes / scene-window counts
+    /// v1.0.0-rc.3: + lastDepthMax / lastSizeBytes / totalTicks /
+    ///              totalEmptyResultTicks — answers "the ring isn't
+    ///              empty but the dashboard renders nothing, which
+    ///              layer dropped the data?" without a re-roll.
+    @objc public static var lastDiagPath: String = "none(not-yet-called)"
+    @objc public static var lastDiagNodes: Int = 0
+    @objc public static var lastDiagSceneCount: Int = 0
+    @objc public static var lastDiagWindowCount: Int = 0
+    @objc public static var lastDiagDepthMax: Int = 0
+    @objc public static var lastDiagSizeBytes: Int = 0
+    @objc public static var totalTicks: Int = 0
+    @objc public static var totalEmptyResultTicks: Int = 0
+    private static var loggedFirstResult = false
+
     private static func captureSync(maskedIds: Set<String>) -> String? {
-        guard let window = keyWindow() else { return nil }
+        totalTicks += 1
+        let (winOpt, path) = resolveKeyWindow()
+        lastDiagPath = path
+        lastDiagSceneCount = currentSceneCount()
+        lastDiagWindowCount = currentWindowCount()
+        guard let window = winOpt else {
+            totalEmptyResultTicks += 1
+            if !loggedFirstResult {
+                NSLog(
+                    "[sentori] wireframe: returning nil — keyWindow path=%@ scenes=%d windows=%d",
+                    path,
+                    lastDiagSceneCount,
+                    lastDiagWindowCount
+                )
+                loggedFirstResult = true
+            }
+            return nil
+        }
         var nodes: [[String: Any]] = []
+        var depthMax = 0
         walk(
             view: window,
+            depth: 0,
+            depthMax: &depthMax,
             parentMasked: false,
             maskedIds: maskedIds,
             window: window,
             nodes: &nodes
         )
+        lastDiagNodes = nodes.count
+        lastDiagDepthMax = depthMax
+        if nodes.isEmpty {
+            totalEmptyResultTicks += 1
+        }
+        if !loggedFirstResult {
+            NSLog(
+                "[sentori] wireframe: first capture ok — keyWindow path=%@ bounds=%.0fx%.0f nodes=%d depthMax=%d",
+                path,
+                window.bounds.width,
+                window.bounds.height,
+                nodes.count,
+                depthMax
+            )
+            loggedFirstResult = true
+        }
         let payload: [String: Any] = [
             "ts": Int(Date().timeIntervalSince1970 * 1000),
             "width": Double(window.bounds.width),
@@ -46,40 +99,110 @@ import UIKit
             "nodes": nodes,
         ]
         if let data = try? JSONSerialization.data(withJSONObject: payload, options: []) {
-            return String(data: data, encoding: .utf8)
+            let s = String(data: data, encoding: .utf8)
+            lastDiagSizeBytes = s?.utf8.count ?? 0
+            return s
         }
         return nil
     }
 
-    private static func keyWindow() -> UIWindow? {
+    /// Four-tier window resolution. The previous single-pass loop
+    /// returned nil whenever the first connected scene was a
+    /// `.background` or `.unattached` SwiftUI/preview scene that had
+    /// no windows yet — common on iOS 26 cold-start where the JS
+    /// thread spins up the replay tick before scene activation
+    /// settles (the v0.9.6 default 1 Hz fires within ~200 ms).
+    private static func resolveKeyWindow() -> (UIWindow?, String) {
         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
+            let scenes = Array(UIApplication.shared.connectedScenes)
+            // Pass 1: foregroundActive scene with a key window.
+            for scene in scenes where scene.activationState == .foregroundActive {
+                if let ws = scene as? UIWindowScene,
+                   let key = ws.windows.first(where: { $0.isKeyWindow }) {
+                    return (key, "scene.fg.key")
                 }
-                if let first = ws.windows.first {
-                    return first
+            }
+            // Pass 2: foregroundActive scene's first window (no key set yet).
+            for scene in scenes where scene.activationState == .foregroundActive {
+                if let ws = scene as? UIWindowScene, let win = ws.windows.first {
+                    return (win, "scene.fg.first")
                 }
             }
+            // Pass 3: foregroundInactive (mid-transition) scene with any window.
+            for scene in scenes where scene.activationState == .foregroundInactive {
+                if let ws = scene as? UIWindowScene, let win = ws.windows.first {
+                    return (win, "scene.fgi.first")
+                }
+            }
+            // Pass 4: any scene at all with windows.
+            for scene in scenes {
+                if let ws = scene as? UIWindowScene, let win = ws.windows.first {
+                    return (win, "scene.any.first")
+                }
+            }
+            // Fallthrough → legacy windows list.
+        }
+        if let leg = UIApplication.shared.windows.first {
+            return (leg, "legacy.first")
         }
-        return UIApplication.shared.windows.first
+        return (nil, "none")
+    }
+
+    private static func currentSceneCount() -> Int {
+        if #available(iOS 13.0, *) {
+            return UIApplication.shared.connectedScenes.count
+        }
+        return 0
+    }
+
+    private static func currentWindowCount() -> Int {
+        if #available(iOS 13.0, *) {
+            return UIApplication.shared.connectedScenes.reduce(0) { acc, scene in
+                acc + ((scene as? UIWindowScene)?.windows.count ?? 0)
+            }
+        }
+        return UIApplication.shared.windows.count
+    }
+
+    /// JS-side probe. Returns a dict the example/dashboard can render
+    /// to ask "why is the ring empty?" without parsing Metro logs.
+    /// `lastNodes == 0 && lastPath != "none"` means the window walk
+    /// happened but the tree was empty (unusual — backgrounded?).
+    /// `lastPath == "none(...)"` means no UIWindow was reachable at
+    /// the moment of the last tick.
+    @objc public static func probe() -> [String: Any] {
+        return [
+            "lastPath": lastDiagPath,
+            "lastNodes": lastDiagNodes,
+            "sceneCount": lastDiagSceneCount,
+            "windowCount": lastDiagWindowCount,
+            "lastDepthMax": lastDiagDepthMax,
+            "lastSizeBytes": lastDiagSizeBytes,
+            "totalTicks": totalTicks,
+            "totalEmptyResultTicks": totalEmptyResultTicks,
+        ]
     }
 
     /// Cap on nodes per snapshot — extremely deep / wide trees can
     /// have thousands of subviews (UICollectionView recyclers).
     private static let MAX_NODES = 800
+    private static let MAX_DEPTH = 60
 
     private static func walk(
         view: UIView,
+        depth: Int,
+        depthMax: inout Int,
         parentMasked: Bool,
         maskedIds: Set<String>,
         window: UIWindow,
         nodes: inout [[String: Any]]
     ) {
         if nodes.count >= MAX_NODES { return }
+        if depth >= MAX_DEPTH { return }
         if view.isHidden || view.alpha < 0.01 { return }
 
+        if depth > depthMax { depthMax = depth }
+
         let isThisMasked = view.accessibilityIdentifier
             .map { maskedIds.contains($0) } ?? false
         let masked = parentMasked || isThisMasked
@@ -125,6 +248,8 @@ import UIKit
             for sub in view.subviews {
                 walk(
                     view: sub,
+                    depth: depth + 1,
+                    depthMax: &depthMax,
                     parentMasked: masked,
                     maskedIds: maskedIds,
                     window: window,

package/ios/SentoriScreenshotCapture.swift

@@ -82,10 +82,15 @@ import UIKit
     }
 
     private static func captureWithMaskSync(maskedIds: [String]) -> [String: String]? {
-        guard let window = keyWindow() else { return nil }
+        guard let window = keyWindowDiag().window else {
+            lastDiagPath = "window.null"
+            return nil
+        }
         guard let jpeg = renderJpegBase64(window: window, maskedIds: Set(maskedIds)) else {
+            lastDiagPath = "render.failed"
             return nil
         }
+        lastDiagPath = "ok"
         return [
             "base64": jpeg,
             "mediaType": "image/jpeg",
@@ -94,8 +99,28 @@ import UIKit
 
     // MARK: - Internals
 
+    // v1.0.0-rc.2 — diagnostic readout mirror of the replay-capture
+    // probe. The JS side calls `probeScreenshot()` to ship raw state
+    // back when screenshot returns null.
+    private static var lastDiagPath: String = "none(not-yet-called)"
+
+    @objc public static func probe() -> [String: Any] {
+        let (win, path) = keyWindowDiag()
+        return [
+            "lastPath": lastDiagPath,
+            "resolvedPath": path,
+            "windowFound": win != nil,
+            "rootViewControllerFound": win?.rootViewController != nil,
+            "boundsW": win.map { Double($0.bounds.width) } ?? 0.0,
+            "boundsH": win.map { Double($0.bounds.height) } ?? 0.0,
+        ]
+    }
+
     private static func captureSync() -> [String: Any]? {
-        guard let window = keyWindow() else { return nil }
+        guard let window = keyWindowDiag().window else {
+            lastDiagPath = "window.null"
+            return nil
+        }
         var out: [String: Any] = [:]
         if let jpeg = renderJpegBase64(window: window) {
             out["screenshot"] = [
@@ -104,7 +129,48 @@ import UIKit
             ]
         }
         out["viewTree"] = walkTree(root: window)
-        return out.isEmpty ? nil : out
+        if out.isEmpty {
+            lastDiagPath = "empty"
+            return nil
+        }
+        lastDiagPath = "ok"
+        return out
+    }
+
+    /// keyWindow with the same 4-tier resolution as the replay capture,
+    /// plus the diagnostic path tag for the probe. The original
+    /// single-pass `keyWindow()` is kept for source-compat callers but
+    /// new paths funnel through this so screenshot + replay agree on
+    /// which window they are pointing at.
+    private static func keyWindowDiag() -> (window: UIWindow?, path: String) {
+        if #available(iOS 13.0, *) {
+            let scenes = Array(UIApplication.shared.connectedScenes)
+            for scene in scenes where scene.activationState == .foregroundActive {
+                if let ws = scene as? UIWindowScene,
+                   let key = ws.windows.first(where: { $0.isKeyWindow }) {
+                    return (key, "scene.fg.key")
+                }
+            }
+            for scene in scenes where scene.activationState == .foregroundActive {
+                if let ws = scene as? UIWindowScene, let win = ws.windows.first {
+                    return (win, "scene.fg.first")
+                }
+            }
+            for scene in scenes where scene.activationState == .foregroundInactive {
+                if let ws = scene as? UIWindowScene, let win = ws.windows.first {
+                    return (win, "scene.fgi.first")
+                }
+            }
+            for scene in scenes {
+                if let ws = scene as? UIWindowScene, let win = ws.windows.first {
+                    return (win, "scene.any.first")
+                }
+            }
+        }
+        if let leg = UIApplication.shared.windows.first {
+            return (leg, "legacy.first")
+        }
+        return (nil, "none")
     }
 
     private static func keyWindow() -> UIWindow? {

package/lib/base64.d.ts

@@ -0,0 +1,25 @@
+/**
+ * UTF-8-safe base64 encoder used by every JSON attachment path
+ * (sessionTrail, stateSnapshot, replay).
+ *
+ * Why this needs its own helper:
+ *   • Hermes' `globalThis.btoa` (and the WHATWG spec) is **Latin-1
+ *     only** — it throws `InvalidCharacterError` on any code point
+ *     > 0xFF. A wireframe NDJSON that includes a TextView with
+ *     Japanese / Chinese / em-dash text triggers it; the JS-side
+ *     `try / catch` then swallows the throw and the replay
+ *     attachment silently never lands.
+ *   • Insight 2026-05-18 rc.3 verify hit exactly this on Android —
+ *     the walker fix in rc.3 surfaced deep TextView text, which
+ *     then collided with the unsafe `btoa(ndjson)` path that had
+ *     worked accidentally on rc.2's shallow (text-free) snapshots.
+ *
+ * The pattern `btoa(unescape(encodeURIComponent(s)))` rewrites the
+ * UTF-8 byte sequence into a Latin-1-equivalent string that btoa
+ * can chew. `unescape` is deprecated for HTML but its byte-level
+ * behaviour is stable across every JS engine we ship to.
+ *
+ * Node / bun test fallback uses `Buffer` directly.
+ */
+export declare function base64Utf8(s: string): string;
+//# sourceMappingURL=base64.d.ts.map

package/lib/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../src/base64.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAK5C"}

package/lib/base64.js

@@ -0,0 +1,30 @@
+/**
+ * UTF-8-safe base64 encoder used by every JSON attachment path
+ * (sessionTrail, stateSnapshot, replay).
+ *
+ * Why this needs its own helper:
+ *   • Hermes' `globalThis.btoa` (and the WHATWG spec) is **Latin-1
+ *     only** — it throws `InvalidCharacterError` on any code point
+ *     > 0xFF. A wireframe NDJSON that includes a TextView with
+ *     Japanese / Chinese / em-dash text triggers it; the JS-side
+ *     `try / catch` then swallows the throw and the replay
+ *     attachment silently never lands.
+ *   • Insight 2026-05-18 rc.3 verify hit exactly this on Android —
+ *     the walker fix in rc.3 surfaced deep TextView text, which
+ *     then collided with the unsafe `btoa(ndjson)` path that had
+ *     worked accidentally on rc.2's shallow (text-free) snapshots.
+ *
+ * The pattern `btoa(unescape(encodeURIComponent(s)))` rewrites the
+ * UTF-8 byte sequence into a Latin-1-equivalent string that btoa
+ * can chew. `unescape` is deprecated for HTML but its byte-level
+ * behaviour is stable across every JS engine we ship to.
+ *
+ * Node / bun test fallback uses `Buffer` directly.
+ */
+export function base64Utf8(s) {
+    if (typeof globalThis.btoa === 'function') {
+        return globalThis.btoa(unescape(encodeURIComponent(s)));
+    }
+    return Buffer.from(s, 'utf8').toString('base64');
+}
+//# sourceMappingURL=base64.js.map

package/lib/base64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.js","sourceRoot":"","sources":["../src/base64.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,UAAU,CAAC,CAAS;IAClC,IAAI,OAAO,UAAU,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QAC1C,OAAO,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1D,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;AACnD,CAAC"}

package/lib/capture.d.ts

@@ -1,4 +1,4 @@
-import type { Tags, User } from './types';
+import type { Event, Tags, User } from './types';
 export { captureStep, __resetTrailForTests } from './trail';
 export declare const __resetScreenshotBudgetForTests: () => void;
 /**
@@ -49,5 +49,24 @@ export declare const sendUserFeedback: (input: {
     issueId: null | string;
 }>;
 export declare const captureError: (error: Error, extras?: CaptureExtras) => void;
+/** 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.
+ *
+ *  rc.4: route through `base64Utf8` so non-Latin-1 text inside any
+ *  walked TextView (Japanese / Chinese / em-dash etc.) doesn't blow
+ *  up the Hermes-spec `btoa`. The pre-rc.4 inline `btoa(ndjson)` path
+ *  threw `InvalidCharacterError` on those code points, the
+ *  surrounding catch swallowed it silently, and the replay
+ *  attachment never landed. Insight 2026-05-18 verify caught it
+ *  after rc.3's walker fix surfaced deep TextView content. Dev
+ *  logs replace the silent catch so the next failure shape is
+ *  visible. */
+declare function captureAndAttachReplay(event: Event, ndjson: string): Promise<void>;
 export declare const captureException: (error: Error, extras?: CaptureExtras) => void;
+/** rc.4 — test hook. The real replay attach path is internal so we
+ *  don't bloat the public surface, but the encoding bug Insight hit
+ *  on 2026-05-18 needs a behaviour-level test that exercises the
+ *  same code path captureException runs in production. */
+export declare const __captureAndAttachReplayForTests: typeof captureAndAttachReplay;
 //# sourceMappingURL=capture.d.ts.map

package/lib/capture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../src/capture.ts"],"names":[],"mappings":"AAqBA,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;sEACsE;AACtE,eAAO,MAAM,gBAAgB,QAAO,MAAM,GAAG,SAAmC,CAAC;AAEjF,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,IAqGnE,CAAC;AAyFF,eAAO,MAAM,gBAAgB,UA9LO,KAAK,WAAW,aAAa,KAAG,IA8LxB,CAAC"}
+{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../src/capture.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAA+B,KAAK,EAAgB,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;sEACsE;AACtE,eAAO,MAAM,gBAAgB,QAAO,MAAM,GAAG,SAAmC,CAAC;AAEjF,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,IAiHnE,CAAC;AAEF;;;;;;;;;;;;eAYe;AACf,iBAAe,sBAAsB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiCjF;AAwDD,eAAO,MAAM,gBAAgB,UAzNO,KAAK,WAAW,aAAa,KAAG,IAyNxB,CAAC;AAE7C;;;0DAG0D;AAC1D,eAAO,MAAM,gCAAgC,+BAAyB,CAAC"}