@goliapkg/sentori-react-native 1.0.0-rc.2 → 1.0.0-rc.4

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

@@ -1,7 +1,6 @@
 package com.sentori
 
 import android.app.Activity
-import android.graphics.Rect
 import android.view.View
 import android.view.ViewGroup
 import android.widget.EditText
@@ -25,11 +24,29 @@ import org.json.JSONObject
 object SentoriReplayCapture {
 
     private const val MAX_NODES = 800
-
-    // v0.9.12 — diagnostic readout so the JS side can ask "why is the
-    // ring empty?" without parsing logcat. Mirrors the iOS side.
+    private const val MAX_DEPTH = 60
+
+    // Diagnostic readouts. Mirrors the iOS side. Surfaced via
+    // `probe()` so JS can answer "why is the ring shallow?" without
+    // parsing logcat.
+    //
+    // v0.9.12: lastPath + lastNodes
+    // v1.0.0-rc.3:
+    //   * lastDepthMax — deepest descendant the walker reached. If
+    //     this stays at 2 or 3 we know the recursion bailed early
+    //     (the rc.2 zero-size-bails-subtree bug).
+    //   * lastSizeBytes — byte length of the serialised payload. ~50
+    //     bytes per node is typical; a 1 KB result with 800 nodes
+    //     would be a red flag.
+    //   * totalTicks / lastEmptyResultTicks — lifetime counters for
+    //     ring health, so a thin-but-non-null capture doesn't slip
+    //     through unnoticed.
     @Volatile private var lastDiagPath: String = "none(not-yet-called)"
     @Volatile private var lastDiagNodes: Int = 0
+    @Volatile private var lastDiagDepthMax: Int = 0
+    @Volatile private var lastDiagSizeBytes: Int = 0
+    @Volatile private var totalTicks: Long = 0
+    @Volatile private var totalEmptyResultTicks: Long = 0
 
     @JvmStatic
     fun probe(): Map<String, Any> {
@@ -37,6 +54,10 @@ object SentoriReplayCapture {
         return mapOf(
             "lastPath" to lastDiagPath,
             "lastNodes" to lastDiagNodes,
+            "lastDepthMax" to lastDiagDepthMax,
+            "lastSizeBytes" to lastDiagSizeBytes,
+            "totalTicks" to totalTicks,
+            "totalEmptyResultTicks" to totalEmptyResultTicks,
             "trackedSource" to SentoriForegroundActivity.lastPath,
             "trackedActivity" to (activity?.javaClass?.name ?: "null"),
             "decorViewFound" to (activity?.window?.decorView != null),
@@ -61,29 +82,30 @@ object SentoriReplayCapture {
 
     @JvmStatic
     fun captureWireframe(maskedIds: List<String>): String? {
+        totalTicks++
         val activity = SentoriForegroundActivity.current()
         if (activity == null) {
             lastDiagPath = "activity.null"
+            totalEmptyResultTicks++
             return null
         }
         val root = activity.window?.decorView
         if (root == null) {
             lastDiagPath = "decorView.null"
+            totalEmptyResultTicks++
             return null
         }
         if (root.width <= 0 || root.height <= 0) {
             lastDiagPath = "root.zero-size"
+            totalEmptyResultTicks++
             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)
-
-        lastDiagPath = "ok(${SentoriForegroundActivity.lastPath})"
-        lastDiagNodes = nodes.length()
+        val ctx = WalkContext(rootLoc = rootLoc, maskedSet = maskedSet)
+        walk(root, depth = 0, parentMasked = false, ctx = ctx, nodes = nodes)
 
         val payload = JSONObject().apply {
             put("ts", System.currentTimeMillis())
@@ -91,77 +113,123 @@ object SentoriReplayCapture {
             put("height", root.height)
             put("nodes", nodes)
         }
-        return payload.toString()
+        val serialised = payload.toString()
+
+        lastDiagPath = "ok(${SentoriForegroundActivity.lastPath})"
+        lastDiagNodes = nodes.length()
+        lastDiagDepthMax = ctx.depthMax
+        lastDiagSizeBytes = serialised.length
+
+        if (nodes.length() == 0) totalEmptyResultTicks++
+
+        return serialised
     }
 
+    /** Per-walk scratch: tracks the deepest descendant reached so
+     *  the probe can surface whether the recursion ran or bailed.
+     *  Bundled into one object to keep the recursive signature
+     *  manageable. */
+    private class WalkContext(
+        val rootLoc: IntArray,
+        val maskedSet: Set<String>,
+        var depthMax: Int = 0,
+    )
+
+    /**
+     * Recursive walker.
+     *
+     * v1.0.0-rc.3 fix: previously this function returned ENTIRELY
+     * when the view itself had `width <= 0 || height <= 0`. That
+     * meant any ViewGroup wrapper that happened to measure to zero
+     * size during the tick (common on Fabric / RN's intermediate
+     * shadow-tree wrappers, and on lazy-layout phases) skipped the
+     * whole descendant subtree — Insight 2026-05-17 verify event
+     * saw 800-node frames whose subtree was actually thousands of
+     * Views deep but only the root + 2-3 wrappers made it into the
+     * JSON.
+     *
+     * Now we separate "emit a node for this view" from "recurse into
+     * its children". A zero-size view doesn't get an emitted node
+     * (no visual contribution) but its descendants still get walked
+     * — they may have real frames.
+     */
     private fun walk(
         view: View,
+        depth: Int,
         parentMasked: Boolean,
-        maskedSet: Set<String>,
-        rootLoc: IntArray,
-        scratch: Rect,
+        ctx: WalkContext,
         nodes: JSONArray,
     ) {
         if (nodes.length() >= MAX_NODES) return
+        if (depth >= MAX_DEPTH) return
         if (view.visibility != View.VISIBLE || view.alpha < 0.01) return
 
+        if (depth > ctx.depthMax) ctx.depthMax = depth
+
         val viewTag = view.tag as? String
-        val isThisMasked = viewTag != null && maskedSet.contains(viewTag)
+        val isThisMasked = viewTag != null && ctx.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
+        // Emit a node ONLY when the view has visual extent. A zero-
+        // size view contributes nothing to render but its subtree
+        // might; recurse below regardless.
+        if (w > 0 && h > 0) {
+            val loc = IntArray(2)
+            view.getLocationInWindow(loc)
+            val x = loc[0] - ctx.rootLoc[0]
+            val y = loc[1] - ctx.rootLoc[1]
+
+            val node = JSONObject().apply {
+                put("x", x)
+                put("y", y)
+                put("w", w)
+                put("h", h)
             }
-            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
+
+            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 (kindEmitted) {
+                nodes.put(node)
+            }
         }
 
+        // Always recurse — even zero-size wrappers can host real
+        // descendants (the rc.3 fix).
         if (!masked && view is ViewGroup) {
             for (i in 0 until view.childCount) {
-                walk(view.getChildAt(i), masked, maskedSet, rootLoc, scratch, nodes)
+                walk(view.getChildAt(i), depth + 1, masked, ctx, nodes)
             }
         }
     }

package/ios/SentoriReplayCapture.swift

@@ -29,22 +29,31 @@ import UIKit
         return result
     }
 
-    /// Last path the keyWindow lookup took. Exposed to JS via
-    /// `probeWireframe()` so the failure-mode diagnostic in Metro can
-    /// tell scene-race from "no window at all" without re-rolling the
-    /// pod. Updated on every captureSync call.
+    /// 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? {
+        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",
@@ -57,21 +66,29 @@ import UIKit
             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",
+                "[sentori] wireframe: first capture ok — keyWindow path=%@ bounds=%.0fx%.0f nodes=%d depthMax=%d",
                 path,
                 window.bounds.width,
                 window.bounds.height,
-                nodes.count
+                nodes.count,
+                depthMax
             )
             loggedFirstResult = true
         }
@@ -82,7 +99,9 @@ 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
     }
@@ -157,23 +176,33 @@ import UIKit
             "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
@@ -219,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/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"}

package/lib/capture.js

@@ -1,9 +1,10 @@
 import { sealTrail, shouldSample } from '@goliapkg/sentori-core';
+import { base64Utf8 } from './base64';
 import { __peekBreadcrumbCount, addBreadcrumb, getBreadcrumbs, } from './breadcrumbs';
 import { getBundleInfo } from './bundle-info';
 import { getConfig, isInitialized } from './config';
 import { getFeatureFlagSnapshot } from './feature-flags';
-import { drainReplay } from './replay';
+import { drainReplay, isReplayRunning } from './replay';
 import { clearStateSnapshots, getStateSnapshots } from './state-snapshots';
 import { symbolicateErrorViaMetro } from './handlers/dev-symbolicate';
 import { captureScreenshot } from './handlers/screenshot';
@@ -104,7 +105,7 @@ export const captureError = (error, extras) => {
     // been silently dropped on the wire. Production builds gate out.
     if (typeof __DEV__ !== 'undefined' && __DEV__) {
         // eslint-disable-next-line no-console
-        console.warn('[sentori] captureException', 'eventId=', event.id, 'breadcrumbs=', crumbs.length, 'wantScreenshot=', config.screenshotsEnabled && extras?.screenshot !== false, 'wantSessionTrail=', config.sessionTrailEnabled);
+        console.warn('[sentori] captureException', 'eventId=', event.id, 'breadcrumbs=', crumbs.length, 'wantScreenshot=', config.screenshotsEnabled && extras?.screenshot !== false, 'wantSessionTrail=', config.sessionTrailEnabled, 'wantReplay=', isReplayRunning());
     }
     // Phase 26 sub-B: a captured error promotes the current session to
     // `errored` so the next AppState=background ping reports unhealthy.
@@ -142,6 +143,15 @@ export const captureError = (error, extras) => {
         if (replayNdjson.length > 0) {
             await captureAndAttachReplay(event, replayNdjson);
         }
+        else if (typeof __DEV__ !== 'undefined' && __DEV__ && isReplayRunning()) {
+            // rc.4 — explicit "replay was on but ring drained empty" signal.
+            // Without this, "kinds=screenshot,sessionTrail" looks
+            // indistinguishable from `replay: off` even though the ticks
+            // were healthy upstream. Insight 2026-05-18 verify shape made
+            // this gap painful to triage.
+            // eslint-disable-next-line no-console
+            console.warn('[sentori] replay drain empty (no frames buffered at captureException)', 'eventId=', event.id);
+        }
         if (typeof __DEV__ !== 'undefined' && __DEV__) {
             // eslint-disable-next-line no-console
             console.warn('[sentori] enqueue', 'eventId=', event.id, 'attachments=', event.attachments?.length ?? 0, 'kinds=', (event.attachments ?? []).map((a) => a.kind).join(',') || '(none)', 'breadcrumbsAtEnqueue=', __peekBreadcrumbCount());
@@ -152,21 +162,37 @@ export const captureError = (error, extras) => {
 };
 /** 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. */
+ *  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. */
 async function captureAndAttachReplay(event, ndjson) {
     try {
-        const base64 = typeof globalThis.btoa === 'function'
-            ? globalThis.btoa(ndjson)
-            : Buffer.from(ndjson, 'utf8').toString('base64');
+        const base64 = base64Utf8(ndjson);
         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);
+        if (!meta) {
+            if (typeof __DEV__ !== 'undefined' && __DEV__) {
+                // eslint-disable-next-line no-console
+                console.warn('[sentori] replay upload returned null', 'eventId=', event.id, 'ndjsonBytes=', ndjson.length);
+            }
+            return;
         }
+        if (!event.attachments)
+            event.attachments = [];
+        event.attachments.push(meta);
     }
-    catch {
-        // best-effort
+    catch (e) {
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+            // eslint-disable-next-line no-console
+            console.warn('[sentori] replay attachment threw', 'eventId=', event.id, 'ndjsonBytes=', ndjson.length, e);
+        }
     }
 }
 /** v0.9.2 +S2 — upload the rolling state-snapshot ring as a
@@ -175,10 +201,7 @@ async function captureAndAttachReplay(event, ndjson) {
 async function captureAndAttachStateSnapshots(event, snapshots) {
     try {
         const payload = JSON.stringify({ snapshots });
-        const base64 = typeof globalThis.btoa === 'function'
-            ? globalThis.btoa(payload)
-            : // Bun / node fallback
-                Buffer.from(payload, 'utf8').toString('base64');
+        const base64 = base64Utf8(payload);
         const meta = await uploadAttachment(event.id, 'stateSnapshot', { base64, mediaType: 'application/json' }, { source: 'js' });
         if (meta) {
             if (!event.attachments)
@@ -204,11 +227,7 @@ async function captureAndAttachSessionTrail(event) {
     const payload = sealTrail(trail);
     trail.clear();
     const json = JSON.stringify(payload);
-    // base64 the JSON for the `data:` URI multipart bridge (same
-    // trick the screenshot path uses).
-    const base64 = typeof globalThis.btoa === 'function'
-        ? globalThis.btoa(unescape(encodeURIComponent(json)))
-        : Buffer.from(json, 'utf-8').toString('base64');
+    const base64 = base64Utf8(json);
     const attachment = await uploadAttachment(event.id, 'sessionTrail', { base64, mediaType: 'application/json' }, { source: 'js' });
     if (!attachment) {
         addBreadcrumb({ type: 'custom', data: { reason: 'session-trail-upload-failed' } });
@@ -219,6 +238,11 @@ async function captureAndAttachSessionTrail(event) {
     event.attachments.push(attachment);
 }
 export const captureException = captureError;
+/** 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 const __captureAndAttachReplayForTests = captureAndAttachReplay;
 /** Phase 42 sub-D.08: per-session screenshot quota gate. */
 function allowScreenshot() {
     const budget = screenshotBudget();