@everframe/react-native 0.9.0 → 1.1.0

package/EverframeRN.podspec

@@ -36,7 +36,7 @@ package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
 # no workspace path exists. Unset — every consumer install — the derivation
 # below is the only source of truth, unchanged.
 native_version_override = ENV['EVERFRAME_NATIVE_POD_VERSION'].to_s.strip
-native_minor_range = native_version_override.empty? ? '~> 0.9.0' : native_version_override
+native_minor_range = native_version_override.empty? ? '~> 1.1.0' : native_version_override
 
 Pod::Spec.new do |s|
   s.name         = 'EverframeRN'

package/README.md

@@ -26,6 +26,26 @@ Then install pods (iOS) / sync Gradle (Android) as usual:
 cd ios && pod install
 ```
 
+## React Native Web
+
+`@everframe/react-native` has a browser entry and an explicit
+`@everframe/react-native/web` entry. Both re-export the existing
+`@everframe/react` package, which is installed as a dependency. Your app
+imports from `@everframe/react-native` on every platform:
+
+```sh
+pnpm add @everframe/react-native
+```
+
+React Native Web hosts also need React DOM, as usual. The browser entry uses
+the React web reporter, DOM screenshot, and rrweb replay. It does not load the
+native TurboModule. `EverframeSensitive` is an alias of
+the React SDK's `Sensitive` component on web, so shared app code can keep the
+same import. `useEverframeSensitiveRef` also registers a browser element with
+the web mask registry. Native iOS and Android use their native capture. A web
+bundler that honors the `browser` export condition can keep the regular package
+import; use the `/web` subpath if its resolver does not select that condition.
+
 ## Usage
 
 Wrap your app with `<EverframeProvider>` at the highest practical level
@@ -76,6 +96,210 @@ provider context and attach any non-sensitive context needed for diagnosis.
 The source API requires matching rebuilt native components; published `0.7.0`
 artifacts are not evidence of support.
 
+## Promise rejection observation
+
+Automatic Hermes rejection observation is opt-in:
+
+```tsx
+import { EverframeProvider, getPromiseRejectionStatus } from '@everframe/react-native';
+
+<EverframeProvider config={{
+  apiKey: '…',
+  crashReporting: { promiseRejections: { enabled: true } },
+}}>
+  <App />
+</EverframeProvider>
+
+// Read after mount. This reports observer coverage, not delivery confirmation.
+const status = getPromiseRejectionStatus();
+```
+
+The verified runtime is Android/iOS `react-native-tvos@0.85.3-0` with Hermes
+release `250829098.0.10`, Release/Static Hermes and bytecode 98. Qualification
+uses optimized apps on an Android API 35 arm64 emulator and an iOS 26.5 arm64
+simulator with Debug/local native SDK transport, including expiry after the app
+process is suspended, source mapping and encrypted retry after relaunch.
+Physical devices, device sleep and production transport are not qualified by
+these checks. Matching the SDK's broader RN peer range does not establish
+rejection support. Other versions, JSC, browser execution, tvOS,
+unverified Promise replacements and incompatible hooks return `unsupported`.
+The adapter checks runtime identity and a fulfilled-only hook handshake; it
+does not generate a test rejection or replace the Promise constructor.
+
+Rejections still unhandled after 2 seconds enter the existing nonfatal capture
+path. A handler attached within that interval cancels capture; later handling
+does not retract an accepted report. The notification uses a JavaScript timer.
+Android pauses JavaScript timers while the app's activity is paused (in the
+background, behind another activity or in picture-in-picture), although
+JavaScript can keep running. Rejections observed then are notified on later
+Promise activity or when the activity resumes. Explicit capture and automatic
+reporting share accepted error identity, and automatic reports retain their
+existing 10-distinct-key allowance per mount. Automatic reports are
+deduplicated by exception type and top stack frame. Non-Error reasons have no
+stack and are deduplicated by their reported value with digit runs ignored, so
+`Request 1001 failed` repeats `Request 1000 failed` and all object reasons
+share one report per mount. They spend at most 5 of the 10 keys, so values that
+differ in other ways, such as hex identifiers, still leave 5 keys for `Error`
+rejections and other automatic reports.
+
+The observer retains at most 16 detached snapshots, each at most 64 KiB of
+serialized UTF-8 data. It drops new arrivals when full and oversize snapshots
+rather than retaining arbitrary error graphs. Work is counted as expired
+instead of reported when it is notified more than 30 seconds after the
+rejection. Age is measured on the platform's elapsed clock and bounded by
+wall-clock time, which keeps advancing while an Android device sleeps. Cleanup
+cannot run while JavaScript is suspended, so stale work expires when
+JavaScript resumes. Error facts and causes are snapshotted at rejection time.
+Rejection reasons that are not `Error` objects are reported as `UnhandledValue`
+without a stack or cause chain, even when they carry a `cause`. Strings,
+numbers, booleans, `null` and `undefined` keep their bounded value; objects,
+arrays, functions, symbols and bigints are reported only as a type label such
+as `[object]` rather than serialized.
+Native context and breadcrumbs are collected at notification time. A preserved
+external tracker may independently retain errors or generate its own reports.
+
+`getPromiseRejectionStatus()` returns `disabled`, `unsupported`, `observing`,
+`displaced`, `install-failed`, or `not-mounted`, with a reason and bounded
+counters for pending, accepted, cancelled, dropped, expired, suppressed,
+refused, failed and discarded captures. A rejection handled within the 2-second interval counts as cancelled,
+even if it was dropped or failed to snapshot on arrival. Counters saturate at
+2,147,483,647 and reset on each mount; they contain no captured messages or
+stacks. Replacing either hook stops this observer until a new mount and
+releases its pending work, counted as `discarded`.
+`crashReporting.disabled: true` overrides the opt-in, and unmount discards
+pending work. Configuration changes take effect on a new mount.
+The browser export reports Hermes observation as unsupported and preserves the
+browser SDK's own error handling.
+
+## Error capture and diagnostics
+
+### React error boundary callback
+
+An existing React class boundary can opt into handled capture. Render the
+boundary inside `EverframeProvider`:
+
+```tsx
+import * as React from 'react';
+import { EverframeProvider } from '@everframe/react-native';
+import { captureReactError } from '@everframe/react-native/integrations/react';
+
+class Boundary extends React.Component<React.PropsWithChildren, { failed: boolean }> {
+  state = { failed: false };
+  static getDerivedStateFromError() { return { failed: true }; }
+  componentDidCatch(error: unknown, info: React.ErrorInfo) {
+    captureReactError(error, info);
+  }
+  render() { return this.state.failed ? null : this.props.children; }
+}
+
+export default function App() {
+  return (
+    <EverframeProvider config={{ apiKey: '…' }}>
+      <Boundary>
+        <RootNavigator />
+      </Boundary>
+    </EverframeProvider>
+  );
+}
+```
+
+A boundary that wraps `EverframeProvider` does not report through it: its
+fallback replaces the provider in the same commit, before `componentDidCatch`
+runs. Such a boundary reports only if its fallback renders its own
+`EverframeProvider`, which mounts before `componentDidCatch` runs. Errors that a
+boundary inside the provider catches during the provider's first commit (the
+initial render that also mounts the provider) are not captured, and they are
+not replayed. Disabled crash reporting and calls after unmount are also inert.
+In development builds, a call that finds no mounted provider logs a warning, at
+most once until a provider mounts or unmounts.
+
+The application owns fallback and recovery UI. This callback reports caught
+component errors; it does not install global renderer hooks or capture arbitrary
+async/event-handler errors. Component-stack metadata is bounded and redacted by
+the existing capture pipeline, without replacing exception frames or cause data.
+
+The original error shares accepted identity with manual and nonfatal automatic
+capture within a mount. Native refusal permits recapture; equal fingerprint keys
+can also suppress distinct objects. A later fatal escalation may report separately.
+The adapter subpath is unavailable to browser-conditioned consumers.
+
+### Local capture admission diagnostics
+
+```ts
+import { getErrorCaptureStatus } from '@everframe/react-native';
+const status = getErrorCaptureStatus();
+const { attempted, accepted, duplicateSuppressed } = status.counters.handled;
+```
+
+Snapshots are detached, contain no captured content, reset on remount, and perform
+no native query or upload. Paths are `handled` (including the boundary callback),
+`errorUtils`, and `rejection` (submission only). Each active attempt has one outcome:
+`accepted`, `duplicateSuppressed`, `allowanceSuppressed`, `bridgeUnavailable`,
+`nativeRefused`, `captureFailed`, `reentrantSuppressed`, `inactiveAborted`, or
+`legacyAttempted`. Counters saturate at 2,147,483,647. Existing limits are ten
+handled and ten automatic distinct keys; fatal capture bypasses them.
+
+`accepted` requires exactly true from a current native capture method. It does
+not mean upload success, server processing or outbox removal. An automatic call
+to an older native fallback is only `legacyAttempted`, regardless of its return.
+Old-binary unavailable/throwing methods are covered by unit controls, not an
+installed old-binary qualification. This snapshot excludes native queue and
+delivery observations; read those with `getReportDeliveryStatus()`. Status is
+neutral `not-mounted` without a provider, `disabled` under the crash-reporting
+veto, and `unsupported` on the browser root entry.
+
+Installed boundary qualification passes on Android API 35 arm64 emulator and
+iOS 26.5 arm64 simulator for this exact phone-host row:
+React 19.2.5, `react-native-tvos` 0.85.3-0 aliased as `react-native`, Expo
+56.0.0-preview.7, Hermes 250829098.0.10 / bytecode 98. Other RN distributions,
+versions, TV, physical devices and production endpoints are not qualified by
+this matrix. Installed checks cover four genuine boundary capture cases,
+disabled/initial zero controls, mapped causes, and byte-identical encrypted retry
+after relaunch. The application/JS builds are optimized; native SDKs are
+Debug/local. Physical-device and production-endpoint qualification remains open.
+
+### Native report delivery diagnostics
+
+`getReportDeliveryStatus()` synchronously copies cached native observations. It
+performs no file reads, uploads, drains, or hook installation. Use
+`getErrorCaptureStatus()` separately for JavaScript admission decisions.
+
+```ts
+import { getReportDeliveryStatus } from '@everframe/react-native';
+const status = getReportDeliveryStatus();
+console.log(status.status, status.queue.observation, status.queue.pendingCount);
+```
+
+The schema separates native capture acceptance, queue operations and settled
+transport attempts (`live-submit` and `outbox-drain`). `server-accepted` means an
+HTTP 2xx response; it does not establish processing, symbolication, dashboard
+visibility or queue removal. Removal has its own operation counter. Counters are
+operations, not unique reports, and saturate at 2,147,483,647.
+
+The queue is the SDK's shared report outbox, including reporter submissions and
+entries from earlier configurations. Its count is last-observed, not a fresh
+measurement or a current-project/crash-only total. Missing counts mean unknown;
+`partial` means only readable entries were counted. Android rejects new entries
+at capacity and retains terminal HTTP responses during drain. iOS can evict older
+entries and attempts removal after terminal HTTP responses. Custom standalone
+outbox/submitter instances are not automatically included.
+
+Snapshots contain only fixed codes and counters, never report content, IDs,
+URLs, credentials or exception strings. Observations are process-local and reset
+on native start/reconfiguration or kill. They are best-effort: contention and
+termination may lose observations; a busy getter reports `snapshot-busy`.
+`bridge-handled` and `bridge-automatic` cover fact entry paths shared by framework
+bridges. iOS marks `jvm-uncaught` unsupported and implies no automatic iOS native
+crash collector.
+
+Without a mounted provider the result is `not-mounted/no-mount`; the browser
+export is `unsupported/platform`. Older native SDKs without the getter return
+`unsupported/native-method-missing`. A throwing native call returns
+`unavailable/native-call-failed`, and malformed native responses return
+`unavailable/invalid-native-snapshot`. These fallbacks have an unobserved queue
+and `unknown` platform policies. This API does not provide a per-report delivery
+guarantee or trigger a retry.
+
 ## Network body capture (client veto)
 
 ```tsx
@@ -500,6 +724,40 @@ recipes above.
 
 ---
 
+## Android reporter initialization
+
+The Android reporter can be opened after the host activity has resumed, including
+apps that disable AndroidX Startup. Use matching updated React Native bridge and
+`dev.everframe:reporter-ui` artifacts: the bridge supplies the current resumed
+activity, and installation and presentation run on the main thread. Repeated
+configuration with matching updated artifacts does not register another lifecycle observer. Capture configuration
+remains synchronous without waiting for reporter UI initialization.
+
+The existing `ReporterResolverInstaller.create(Context)` entry point is retained
+for compiled callers. A new bridge with an older reporter uses its legacy entry
+point when the activity-aware method is absent; that combination retains the old
+late-initialization limitation. A failure from an available method is reported,
+not retried through the legacy path. Background or unavailable activities return
+a cancelled result with reason `no_active_activity`.
+
+Legacy off-main `create(Context)` schedules installation and returns before it is
+ready; use the awaited activity-aware bridge to open immediately after configure.
+With a new bridge and an older reporter, each configure, companion start, and
+open invokes legacy installation again. This can add duplicate lifecycle
+callbacks and overwrite that older reporter's resolver and activity supplier;
+the previous bridge limited installation to once per module. Conversely, an old
+compiled bridge with the new reporter can announce companion PIN capability
+before asynchronous reporter installation finishes, temporarily advertising no
+PIN support. Use the matching updated pair for the qualified behavior.
+
+Activity destruction while a reporter is open resolves the pending call with
+`{ status: "cancelled", reason: "activity_destroyed" }`, releases that report's
+frozen replay capture, and clears presenting state so the reporter can open
+again. Backgrounding alone does not cancel the dialog. Once Send is tapped,
+submission owns the result and continues independently of activity destruction;
+its normal delivery result is preserved. Unsaved drafts are not restored after
+activity recreation.
+
 ## License
 
 MIT

package/android/build.gradle.kts

@@ -152,7 +152,7 @@ val nativeVersionOverride = (findProperty("everframeNativeVersion") as String?)
 val rnSdkPkg = groovy.json.JsonSlurper()
     .parse(file("../package.json")) as Map<*, *>
 val rnSdkVersion = rnSdkPkg["version"] as String
-val nativeMinorRange: String = nativeVersionOverride ?: "[0.9.0,0.10.0)"
+val nativeMinorRange: String = nativeVersionOverride ?: "[1.1.0,1.2.0)"
 if (nativeVersionOverride != null) {
     logger.lifecycle(
         "[everframe-rn] native AAR pinned to $nativeVersionOverride via everframeNativeVersion " +

package/android/src/main/java/dev/everframe/rn/EverframeModule.kt

@@ -105,6 +105,8 @@ class EverframeModule(
     private val reactContext: ReactApplicationContext,
 ) : NativeEverframeSpec(reactContext) {
 
+    private val reporterBridge = ReporterBridge()
+
     private val videoPrivacyAdapter = Everframe.__registerVideoPrivacyAdapter(RnVideoPrivacyAdapter)
     private val sensitiveRegistration = RnSensitiveRegistration(
         { tag -> UIManagerHelper.getUIManagerForReactTag(reactContext, tag)?.resolveView(tag) },
@@ -331,7 +333,7 @@ class EverframeModule(
                     "Everframe.rn",
                     "configure: SDK already running this exact config — skipping start()",
                 )
-                installPresenterResolverIfNeeded()
+                reporterBridge.scheduleInstall(reactContext)
                 completed = true
                 return@txGuardSurface
             }
@@ -357,10 +359,10 @@ class EverframeModule(
 
             // Wire TXReporterPresenter as the resolver for
             // Everframe.shared.report.open(). Mirrors iOS TXReporterPresenter
-            // .installResolver(). Reflective lookup keeps :sdk-react-native
-            // from a hard dependency on :everframe-reporter-ui (which the host
-            // app pulls in via its app build.gradle).
-            installPresenterResolverIfNeeded()
+            // .installResolver(). Reflection preserves compatibility with
+            // separately built reporter artifacts; the awaited open retries
+            // installation on main before selecting the resumed host.
+            reporterBridge.scheduleInstall(reactContext)
             completed = true
         }
         return completed
@@ -382,16 +384,9 @@ class EverframeModule(
             promise.reject(REJECT_CAPTURE_DISABLED, "Everframe not started (captureGate=false). Call configure() first.")
             return
         }
-        // ReporterResolverInstaller tracks the active Activity via its own
-        // ActivityRegistry — we don't pass currentActivity through. But we
-        // ensure the resolver is installed so report.open() doesn't throw.
-        installPresenterResolverIfNeeded()
-
         MainScope().launch {
             try {
-                val result: ReportResult = withContext(Dispatchers.Main) {
-                    Everframe.report.open()
-                }
+                val result: ReportResult = reporterBridge.open(reactContext)
                 val dict = Arguments.createMap().apply {
                     when (result) {
                         is ReportResult.Submitted -> {
@@ -410,7 +405,8 @@ class EverframeModule(
                 }
                 promise.resolve(dict)
             } catch (t: Throwable) {
-                promise.reject(REJECT_OPEN_REPORTER_FAILED, t.message, t)
+                promise.reject(REJECT_OPEN_REPORTER_FAILED, reporterBridge.rejectionMessage(t))
+                if (t is kotlinx.coroutines.CancellationException) throw t
             }
         }
     }
@@ -641,6 +637,10 @@ class EverframeModule(
 
     // ---------------- synchronous crash persistence ----------------
 
+    /** Copies cached native facts; never initializes storage or starts a drain. */
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun getReportDeliveryStatusJson(): String = Everframe.getReportDeliveryStatus().toJson()
+
     /** Automatic ErrorUtils capture; true acknowledges completed sidecar storage. */
     @ReactMethod(isBlockingSynchronousMethod = true)
     override fun reportCrash(crashJson: String): Boolean = captureCrashJson(crashJson, handled = false)
@@ -670,15 +670,16 @@ class EverframeModule(
                 }
             }.getOrNull()
             val details = if (obj.has("details")) obj.get("details") else null
+            val causeChain = if (obj.has("causeChain")) obj.get("causeChain") else null
             val fatal = !handled && obj.optBoolean("fatal", false)
             val accepted = if (handled) {
-                dev.everframe.crash.CrashReporter.captureHandledFactsWithDetails(
-                    exceptionType, message, frames, occurredAt, jsBundle, details,
+                dev.everframe.crash.CrashReporter.captureHandledFactsWithCauses(
+                    exceptionType, message, frames, occurredAt, jsBundle, details, causeChain, "everframe-android",
                 )
             } else {
-                dev.everframe.crash.CrashReporter.captureFactsAcceptedWithDetails(
+                dev.everframe.crash.CrashReporter.captureFactsAcceptedWithCauses(
                     exceptionType, message, frames, obj.optString("mechanism", "errorutils"),
-                    fatal, occurredAt, jsBundle, details,
+                    fatal, occurredAt, jsBundle, details, causeChain,
                 )
             }
             // Scheduling is best-effort after acceptance; a scheduler failure
@@ -851,6 +852,10 @@ class EverframeModule(
 
     @ReactMethod
     override fun startCompanion() {
+        if (android.os.Looper.myLooper() != android.os.Looper.getMainLooper()) {
+            android.os.Handler(android.os.Looper.getMainLooper()).post { startCompanion() }
+            return
+        }
         txGuardVoid("startCompanion") {
             // Idempotent: a live client means a prior startCompanion already
             // opened the socket. Do NOT recreate it — callers must
@@ -864,13 +869,16 @@ class EverframeModule(
                 return@txGuardVoid
             }
 
+            // Await the main-thread install before the relay can announce PIN capability.
+            // configureSync itself remains non-blocking with respect to main.
+            reporterBridge.scheduleInstall(reactContext)
             installCompanionCollectorsIfNeeded()
 
             // Runtime suppression of the built-in PIN presenter (spec
             // 2026-08-19, controller ruling): a runtime flag, not an
             // install-site gate. `:everframe-reporter-ui`'s
             // `CompanionPinPresenter` is auto-installed via
-            // `ReporterResolverInstaller` (androidx.startup) regardless of
+            // `ReporterResolverInstaller` (Startup or the bridge above) regardless of
             // the configured mode, so `Everframe.__attachPinUiInstalled`
             // stays an honest capability signal — only the PRESENTING is
             // silenced, here, at the one site where the mode is already
@@ -976,6 +984,10 @@ class EverframeModule(
 
     @ReactMethod
     override fun stopCompanion() {
+        if (android.os.Looper.myLooper() != android.os.Looper.getMainLooper()) {
+            android.os.Handler(android.os.Looper.getMainLooper()).post { stopCompanion() }
+            return
+        }
         txGuardVoid("stopCompanion") {
             // External review, finding NN1 — only ever stop/unregister OUR
             // OWN client. `companionClient` is non-null here ONLY when a
@@ -1607,34 +1619,7 @@ class EverframeModule(
 
     // ---------------- Helpers ----------------
 
-    @Volatile
-    private var resolverInstalled = false
 
-    /**
-     * Idempotently runs `ReporterResolverInstaller.create(applicationContext)`
-     * — the androidx.startup `Initializer` from :everframe-reporter-ui. Hosts
-     * using AndroidX App Startup will have this run automatically at process
-     * launch; this method covers hosts that disable App Startup (common in
-     * React Native apps) by invoking the same code path reflectively. No-op
-     * after the first successful call.
-     */
-    private fun installPresenterResolverIfNeeded() {
-        if (resolverInstalled) return
-        try {
-            val cls = Class.forName("dev.everframe.ui.ReporterResolverInstaller")
-            val ctor = cls.getDeclaredConstructor()
-            ctor.isAccessible = true
-            val instance = ctor.newInstance()
-            val create = cls.getMethod("create", android.content.Context::class.java)
-            create.invoke(instance, reactContext.applicationContext)
-            resolverInstalled = true
-        } catch (t: Throwable) {
-            android.util.Log.w(
-                "Everframe.rn",
-                "ReporterResolverInstaller not on classpath; openReporter will fail until the host app depends on :everframe-reporter-ui (${t.javaClass.simpleName}: ${t.message})",
-            )
-        }
-    }
 
     private fun ReadableMap.takeIfHasString(key: String): String? =
         if (hasKey(key) && !isNull(key)) getString(key) else null

package/android/src/main/java/dev/everframe/rn/ReporterBridge.kt

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 ScriptX
+package dev.everframe.rn
+
+import android.app.Activity
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.common.LifecycleState
+import dev.everframe.Everframe
+import dev.everframe.config.ReportResult
+import java.lang.reflect.InvocationTargetException
+import java.lang.reflect.Method
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+/** Reflection preserves compatibility with separately built native reporter artifacts. */
+internal class ReporterBridge(
+    private val resolveInstaller: () -> Class<*> = { Class.forName("dev.everframe.ui.ReporterResolverInstaller") },
+) {
+    fun scheduleInstall(context: Context) {
+        val application = context.applicationContext
+        val install = Runnable {
+            try {
+                val type = installerType()
+                invoke(type.getMethod("create", Context::class.java), type.getDeclaredConstructor().newInstance(), application)
+            } catch (_: Throwable) {
+                Log.w("Everframe.rn", "Reporter initialization deferred; opening will retry")
+            }
+        }
+        if (Looper.myLooper() == Looper.getMainLooper()) install.run()
+        else Handler(Looper.getMainLooper()).post(install)
+    }
+
+    suspend fun open(context: ReactApplicationContext): ReportResult = withContext(Dispatchers.Main.immediate) {
+        val activity = context.currentActivity
+        if (context.lifecycleState != LifecycleState.RESUMED || activity == null ||
+            activity.isFinishing || activity.isDestroyed || activity.application !== context.applicationContext) {
+            return@withContext ReportResult.Cancelled("no_active_activity")
+        }
+        try {
+            val type = installerType()
+            val instance = type.getDeclaredConstructor().newInstance()
+            val method = try {
+                type.getMethod("openForActivity", Context::class.java, Activity::class.java, Continuation::class.java)
+            } catch (_: NoSuchMethodException) { null }
+            if (method == null) {
+                // Absence is the only legacy fallback. A present method's failure is final.
+                invoke(type.getMethod("create", Context::class.java), instance, context.applicationContext)
+                Everframe.report.open()
+            } else {
+                suspendCoroutineUninterceptedOrReturn<ReportResult> { continuation ->
+                    invoke(method, instance, context.applicationContext, activity, continuation)
+                }
+            }
+        } catch (failure: Throwable) {
+            when (failure) {
+                is CancellationException -> throw failure
+                is ReporterBridgeFailure -> throw failure
+                is NoSuchMethodException -> throw ReporterBridgeFailure("Reporter UI is incompatible; update the native reporter dependency")
+                else -> throw ReporterBridgeFailure("Reporter initialization or opening failed")
+            }
+        }
+    }
+
+    private fun installerType(): Class<*> = try { resolveInstaller() }
+    catch (_: ClassNotFoundException) {
+        throw ReporterBridgeFailure("Reporter UI dependency is missing; add dev.everframe:reporter-ui")
+    }
+
+    private fun invoke(method: Method, instance: Any, vararg arguments: Any?): Any? =
+        try { method.invoke(instance, *arguments) }
+        catch (failure: InvocationTargetException) { throw failure.targetException }
+
+    /** Only SDK-owned constant messages may cross the JS promise boundary. */
+    fun rejectionMessage(failure: Throwable): String = when (failure) {
+        is ReporterBridgeFailure -> failure.message!!
+        is CancellationException -> "Reporter opening was cancelled"
+        else -> "Reporter initialization or opening failed"
+    }
+
+    // No host exception/cause is forwarded to JS or diagnostic logs.
+    private class ReporterBridgeFailure(message: String) : IllegalStateException(message)
+}

package/dist/NativeEverframe.d.ts

@@ -228,6 +228,8 @@ interface Spec extends TurboModule {
      * freeform-object escape hatch; `from`/`to` win over its keys.
      */
     recordScreen(name: string, data?: UnsafeObject): void;
+    /** Additive diagnostic bridge: bounded JSON of cached native observations; no I/O. */
+    getReportDeliveryStatusJson(): string;
     /**
      * Crash/error reporting (spec 2026-07-18). SYNCHRONOUS by design (non-void
      * return forces a sync TurboModule method): the fatal path must complete

package/dist/chunk-ENPQ66EV.js

@@ -0,0 +1 @@
+import{a as o}from"./chunk-XUSV3KOD.js";var h=["native-handled","bridge-handled","bridge-automatic","jvm-uncaught"],A=["persisted","disabled","admission-suppressed","reentrant","invalid-input","ownership-lost","storage-unavailable","failed"],S=["enqueue-committed","enqueue-failed","capacity-evicted","removed-after-acceptance","removed-after-terminal","removal-failed","read-failed"],T=["capacity","key-unavailable","corrupt","io","revoked","invalid-entry","busy","unknown","unsupported-format"],R=["live-submit","outbox-drain"],K=["server-accepted","retryable-http","terminal-http","network-failure","authorization-cancelled","cancelled","failed"],V=JSON.parse,H=Object.keys,y=Object.hasOwn,Q=Array.isArray,U=Number.isInteger,I=Reflect.apply,z=RegExp.prototype.test,_=/[^\x00-\x7f]/,k=2147483647;function d(e,t){let r={};for(let n=0;n<e.length;n++){let a=e[n];r[a]=t(a)}return r}o(d,"mapKeys");function J(e,t){return{schemaVersion:1,status:e,reason:t,scope:"native-runtime-observations",coverage:"best-effort",revision:0,capture:{enabled:!1,paths:d(h,()=>({supported:!1,settledAttempts:0,outcomes:d(A,()=>0)}))},queue:{scope:"sdk-report-outbox",observation:"not-observed",quality:"unknown",capacityPolicy:"unknown",terminalHttpPolicy:"unknown",operations:d(S,()=>0),migration:"not-observed"},transport:d(R,()=>({settledAttempts:0,outcomes:d(K,()=>0)}))}}o(J,"emptyReportDeliveryStatus");function l(e,t,r=[]){if(!e||typeof e!="object"||Q(e))throw new Error;let n=H(e);for(let a=0;a<t.length;a++)if(!y(e,t[a]))throw new Error;for(let a=0;a<n.length;a++){let i=n[a];if(!g(t,i)&&!g(r,i))throw new Error}return e}o(l,"record");function g(e,t){for(let r=0;r<e.length;r++)if(e[r]===t)return!0;return!1}o(g,"contains");function c(e,t){if(typeof e!="string"||!g(t,e))throw new Error;return e}o(c,"enumeration");function v(e){if(typeof e!="number"||!U(e)||e<0||e>k)throw new Error;return e}o(v,"counter");function P(e){if(typeof e!="boolean")throw new Error;return e}o(P,"boolean");function q(e,t){let r=l(e,t);return d(t,n=>v(r[n]))}o(q,"counters");function j(e,t){let r=q(e.outcomes,t),n=v(e.settledAttempts),a=0;for(let b=0;b<t.length;b++)a+=r[t[b]];if((a>k?k:a)!==n)throw new Error;let i=y(e,"lastOutcome")?c(e.lastOutcome,t):void 0;if(n>0!=(i!==void 0)||i!==void 0&&r[i]===0)throw new Error;return{settledAttempts:n,outcomes:r,...i===void 0?{}:{lastOutcome:i}}}o(j,"settled");function C(e,t,r){for(let n=0;n<t.length;n++)if(r(e[t[n]])!==0)return!0;return!1}o(C,"nonzero");function M(e){try{if(typeof e!="string"||e.length>16384||I(z,_,[e]))return null;let t=l(V(e),["schemaVersion","status","reason","scope","coverage","revision","capture","queue","transport"]);if(t.schemaVersion!==1||t.scope!=="native-runtime-observations"||t.coverage!=="best-effort")return null;let r=c(t.status,["active","not-started","disabled","unavailable"]),n=c(t.reason,["none","no-start","capture-disabled","snapshot-busy"]);if({active:"none","not-started":"no-start",disabled:"capture-disabled",unavailable:"snapshot-busy"}[r]!==n)return null;let a=l(t.capture,["enabled","paths"]),i=l(a.paths,h),b=d(h,p=>{let f=l(i[p],["supported","settledAttempts","outcomes"],["lastOutcome"]),m={supported:P(f.supported),...j(f,A)};if(!m.supported&&m.settledAttempts!==0)throw new Error;return m}),u=l(t.queue,["scope","observation","quality","capacityPolicy","terminalHttpPolicy","operations","migration"],["pendingCount","lastFailure"]);if(u.scope!=="sdk-report-outbox")return null;let s={scope:"sdk-report-outbox",observation:c(u.observation,["not-observed","observed","failed"]),quality:c(u.quality,["complete","partial","unknown"]),capacityPolicy:c(u.capacityPolicy,["reject-new","evict-oldest"]),terminalHttpPolicy:c(u.terminalHttpPolicy,["retain","attempt-remove"]),operations:q(u.operations,S),migration:c(u.migration,["not-observed","clear","blocked","unknown"]),...y(u,"pendingCount")?{pendingCount:v(u.pendingCount)}:{},...y(u,"lastFailure")?{lastFailure:c(u.lastFailure,T)}:{}};if(s.capacityPolicy==="reject-new"!=(s.terminalHttpPolicy==="retain")||(s.observation!=="observed"||s.quality==="unknown")&&s.pendingCount!==void 0||s.observation!=="observed"&&s.quality!=="unknown"||s.observation==="failed"!=(s.lastFailure!==void 0))return null;let D=l(t.transport,R),E=d(R,p=>{let f=l(D[p],["settledAttempts","outcomes"],["lastOutcome","lastHttpStatus"]),m=j(f,K);if(y(f,"lastHttpStatus")){let x=v(f.lastHttpStatus);if(x<100||x>599||!g(["server-accepted","retryable-http","terminal-http"],m.lastOutcome??""))throw new Error;m.lastHttpStatus=x}return m}),w={schemaVersion:1,status:r,reason:n,scope:"native-runtime-observations",coverage:"best-effort",revision:v(t.revision),capture:{enabled:P(a.enabled),paths:b},queue:s,transport:E};return r!=="active"&&(w.revision!==0||w.capture.enabled||s.observation!=="not-observed"||C(b,h,p=>p.settledAttempts)||C(E,R,p=>p.settledAttempts)||C(s.operations,S,p=>p))?null:w}catch{return null}}o(M,"parseReportDeliveryStatus");function O(){return{attempted:0,accepted:0,duplicateSuppressed:0,allowanceSuppressed:0,bridgeUnavailable:0,nativeRefused:0,captureFailed:0,reentrantSuppressed:0,inactiveAborted:0,legacyAttempted:0}}o(O,"emptyCounters");function N(e,t){return{status:e,reason:t,scope:"mounted-js-admission",limits:{handled:10,automatic:10},counters:{handled:O(),errorUtils:O(),rejection:O()}}}o(N,"emptyErrorCaptureStatus");function F(e,t){e[t]=Math.min(2147483647,e[t]+1)}o(F,"incrementErrorCaptureCounter");function B(){let e=N("active","none").counters;return{begin(t){F(e[t],"attempted");let r=!1;return n=>{r||(r=!0,F(e[t],n))}},snapshot(){return{handled:{...e.handled},errorUtils:{...e.errorUtils},rejection:{...e.rejection}}}}}o(B,"createErrorCaptureLedger");function Y(e,t){return{status:e,reason:t,previousCallbacksPresent:!1,counters:{pending:0,accepted:0,cancelled:0,capacityDropped:0,sizeDropped:0,expired:0,duplicateSuppressed:0,allowanceSuppressed:0,nativeRefused:0,captureFailed:0,discarded:0}}}o(Y,"emptyPromiseRejectionStatus");export{J as a,M as b,N as c,B as d,Y as e};

package/dist/chunk-POE5CSO5.js

@@ -0,0 +1 @@
+import{a as i,c as s,e as u}from"./chunk-ENPQ66EV.js";import{a as t}from"./chunk-XUSV3KOD.js";var n=class extends Error{static{t(this,"EverframeNotMountedError")}name="EverframeNotMountedError";constructor(o){super(o??"EverframeProvider is not mounted; wrap your app root.")}};var r=null,a={};function x(){return a}t(x,"__getContextEpoch");function f(){try{return r?.getPromiseRejectionStatus?.()??u("not-mounted","no-mount")}catch{return u("install-failed","hook-install")}}t(f,"getPromiseRejectionStatus");function E(e){r=e,a={}}t(E,"__setCurrentContext");function g(){return r}t(g,"__getCurrentContext");function R(){let e=r;return e?e.open():Promise.reject(new n("EverframeProvider not mounted; wrap your root with <EverframeProvider>."))}t(R,"open");function S(e){r?.setExtra(e)}t(S,"setExtra");function y(e){r?.addBreadcrumb(e)}t(y,"addBreadcrumb");function C(e,o){o!==void 0?r?.recordScreen(e,o):r?.recordScreen(e)}t(C,"recordScreen");function b(e){r?.setUser(e)}t(b,"setUser");function j(e,o){r?.captureException(e,o)}t(j,"captureException");function w(){try{return r?.getErrorCaptureStatus?.()??s("not-mounted","no-mount")}catch{return s("not-mounted","no-mount")}}t(w,"getErrorCaptureStatus");function P(){let e=r;try{let o=e?.getReportDeliveryStatus?.();return e===r&&o?o:i("not-mounted","no-mount")}catch{return i("unavailable","native-call-failed")}}t(P,"getReportDeliveryStatus");export{n as a,x as b,f as c,E as d,g as e,R as f,S as g,y as h,C as i,b as j,j as k,w as l,P as m};