@everframe/react-native 1.1.0 → 1.2.1

package/EverframeRN.podspec

@@ -35,8 +35,12 @@ package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
 # evaluated from inside the published npm tarball at a consumer's install, where
 # no workspace path exists. Unset — every consumer install — the derivation
 # below is the only source of truth, unchanged.
+#
+# The bridge calls `EverframeConfig(sdkKey:)`, which first ships in native
+# 1.2.0, so the range already asks for 1.2 while package.json is still 1.1.0.
+# The 1.2.0 release moves package.json to match.
 native_version_override = ENV['EVERFRAME_NATIVE_POD_VERSION'].to_s.strip
-native_minor_range = native_version_override.empty? ? '~> 1.1.0' : native_version_override
+native_minor_range = native_version_override.empty? ? '~> 1.2.1' : native_version_override
 
 Pod::Spec.new do |s|
   s.name         = 'EverframeRN'

package/README.md

@@ -11,6 +11,9 @@ modal to RN host apps via a TurboModule + a thin React provider/hook API.
 
 ---
 
+See the [crash-reporting support matrix](../../docs/crash-reporting-support.md)
+for exact tested paths, unsupported combinations and remaining qualification.
+
 ## Installation
 
 ```bash
@@ -26,6 +29,25 @@ Then install pods (iOS) / sync Gradle (Android) as usual:
 cd ios && pod install
 ```
 
+### Source maps and symbols
+
+Release builds can upload their Hermes source maps, dSYMs, R8 mappings and
+native libraries, so crashes show your code. Wrap Metro with
+`withEverframe` from `@everframe/metro`, add `@everframe/cli`, and set up the
+native projects once. In Expo, apply `withEverframe` from `@everframe/expo`
+with your App ID in `app.config.js`. In a bare app, run:
+
+```bash
+npx @everframe/cli setup react-native --app-id "$EVERFRAME_APP_ID"
+```
+
+Either way, Android gets `apply plugin: "dev.everframe"` and
+`everframe { appId = "…" }` plus one classpath line, and Xcode gets a Run
+Script phase that runs `everframe xcode build-phase`. The upload logic lives in
+the Gradle plugin and the CLI. Set `EVERFRAME_API_TOKEN` in release builds;
+without it the build warns and continues. See the
+[CLI guide](../cli/README.md#react-native-and-expo).
+
 ## React Native Web
 
 `@everframe/react-native` has a browser entry and an explicit
@@ -46,6 +68,8 @@ 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.
 
+Replays also attach to errors; see [session replay](../../docs/session-replay.md).
+
 ## Usage
 
 Wrap your app with `<EverframeProvider>` at the highest practical level
@@ -56,11 +80,11 @@ import { EverframeProvider, useEverframe } from '@everframe/react-native';
 
 export default function App() {
   return (
-    // `apiKey` is the only required field. The ingest endpoint is a
+    // `sdkKey` is the only required field. The ingest endpoint is a
     // compile-time constant in the SDK and is not configurable in v1.
     <EverframeProvider
       config={{
-        apiKey: 'txx_live_xxxxxxxxxxxxxxxx',
+        sdkKey: 'evf_live_xxxxxxxxxxxxxxxx',
         // Recommended in RN/Expo development: shake also opens the dev menu.
         shakeToReport: { enabled: !__DEV__ },
       }}
@@ -96,6 +120,30 @@ 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.
 
+## Release health
+
+Release health counts crash-free foreground sessions for each version of your
+app. It is on by default, and debug builds of the native app aren't counted.
+Turn it off in the `EverframeProvider` config:
+
+```tsx
+releaseHealth: { enabled: false },
+```
+
+Sessions come from the Android and iOS SDKs and count toward the native app
+version, which an over-the-air update doesn't change. Release health needs the
+Hermes bundle identity that `@everframe/metro` adds at build time (or the
+`jsBundle` option); without it, release health stays off and the SDK logs an
+`[everframe]` warning (in development builds only, unless you set
+`releaseHealth`). Add `userId: accountId` to count crash-free users, and
+`includeDebugBuilds: true` to count debug builds too. The configuration is read
+when the Provider mounts, so remount it with a changed `key` to change `enabled`
+or `userId`. A configure with `enabled: false` turns release health off and
+erases its queued records on the device.
+Release health skips a debug build, which is `__DEV__` unless you set
+`debugBuild` on the Provider. See
+[release health](../../docs/release-health.md).
+
 ## Promise rejection observation
 
 Automatic Hermes rejection observation is opt-in:
@@ -104,7 +152,7 @@ Automatic Hermes rejection observation is opt-in:
 import { EverframeProvider, getPromiseRejectionStatus } from '@everframe/react-native';
 
 <EverframeProvider config={{
-  apiKey: '…',
+  sdkKey: '…',
   crashReporting: { promiseRejections: { enabled: true } },
 }}>
   <App />
@@ -173,6 +221,27 @@ browser SDK's own error handling.
 
 ## Error capture and diagnostics
 
+### Native crashes and ANRs
+
+Crash reporting also turns on the native SDKs' automatic crash capture. On Android that covers JVM exceptions, native crashes (OS exit records on API 30+, with tombstone frames on API 31+) and ANRs on API 30+; see the [Android SDK guide](../sdk-android/README.md#crash-capture-on-by-default). On iOS it is the native crash recorder. `crashReporting: { disabled: true }` turns all of it off on both platforms.
+
+### Errors no boundary catches
+
+Since React Native 0.78, React reports an error that no error boundary catches
+(thrown while rendering, in an effect or in a lifecycle method) through the
+root's `onUncaughtError`. That calls React Native's `ExceptionsManager`, never
+the `ErrorUtils` handler. Crash reporting hooks
+`ExceptionsManager.handleException` too, so such an error is reported as a fatal
+JavaScript crash (`mechanism: "errorutils"`) with its Hermes stack, and React's
+component stack follows the message after `This error is located at:`, as in
+React Native's own report. React unmounts the whole tree, `EverframeProvider`
+included, before it reports the error; the hook stays until the end of that
+task, so the error is still captured. The native fatal React Native raises for
+the same error (`RCTFatalException` on iOS and tvOS, `JavascriptException` on
+Android) is not reported a second time. An error in the render that first
+mounts the provider comes before this capture is installed. Errors a boundary
+catches are not reported automatically; use the callback below.
+
 ### React error boundary callback
 
 An existing React class boundary can opt into handled capture. Render the
@@ -194,7 +263,7 @@ class Boundary extends React.Component<React.PropsWithChildren, { failed: boolea
 
 export default function App() {
   return (
-    <EverframeProvider config={{ apiKey: '…' }}>
+    <EverframeProvider config={{ sdkKey: '…' }}>
       <Boundary>
         <RootNavigator />
       </Boundary>
@@ -233,17 +302,14 @@ 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:
+`errorUtils` (including errors no boundary catches), 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
+`nativeRefused`, `captureFailed`, `reentrantSuppressed`, or `inactiveAborted`.
+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
+`accepted` requires exactly true from the native capture method. It does
+not mean upload success, server processing or outbox removal. 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.
@@ -293,8 +359,7 @@ bridges. iOS marks `jvm-uncaught` unsupported and implies no automatic iOS nativ
 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
+export is `unsupported/platform`. A missing or 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
@@ -303,7 +368,7 @@ guarantee or trigger a retry.
 ## Network body capture (client veto)
 
 ```tsx
-<EverframeProvider config={{ apiKey: '…', networkBodies: { disabled: true } }}>
+<EverframeProvider config={{ sdkKey: '…', networkBodies: { disabled: true } }}>
 ```
 
 `networkBodies.disabled: true` is a **client veto** — it can only turn body
@@ -331,6 +396,34 @@ capturing network traffic in the first place:
 Do not enable this option expecting RN's own network calls to show up in
 reports — that capability doesn't exist yet.
 
+## Crash-only sessions
+
+```tsx
+<EverframeProvider config={{ sdkKey: '…', reporter: { disabled: true } }}>
+```
+
+`reporter.disabled: true` turns the bug reporter off for the session and
+keeps crash and error reporting, for example in production builds. It is a
+**client veto**: the dashboard can't turn the reporter back on for this
+session.
+
+In a crash-only session:
+
+- Shake-to-report is off, and `open()` rejects with
+  `EverframeReporterDisabledError`.
+- Session replay uses the app's crash-only sampling rate, which is 0 by
+  default. An error carries a replay only while the session records.
+- Network bodies aren't captured.
+- Crash and error capture, breadcrumbs, vitals, release health and the
+  companion work as usual.
+
+A companion bond (a phone scanning the QR code, or a dashboard member
+attaching) upgrades the session. Replay and network bodies then follow the
+app's normal settings for the rest of the session, and recording starts at
+the bond. The reporter stays off: reports from an upgraded session come
+through the companion. See
+[crash-only sessions](../../docs/session-replay.md#crash-only-sessions).
+
 ## Navigation breadcrumbs
 
 Mark screens with one line; the native SDK derives `from → to` from a global
@@ -386,7 +479,7 @@ import { createNavigationContainerRef } from '@react-navigation/native';
 const navigationRef = createNavigationContainerRef();
 const txNav = reactNavigationIntegration({ navigationRef });
 
-<EverframeProvider config={{ apiKey, integrations: [consoleIntegration(), txNav] }}>
+<EverframeProvider config={{ sdkKey, integrations: [consoleIntegration(), txNav] }}>
   <NavigationContainer ref={navigationRef} onReady={txNav.onReady}>
     ...
 ```
@@ -415,7 +508,7 @@ inside a native view and never reaches JS.
 ### Config
 
 ```tsx
-<EverframeProvider config={{ apiKey, vitals: { enabled: true, sampleRate: 0.5, captureSourceQuery: false } }}>
+<EverframeProvider config={{ sdkKey, vitals: { enabled: true, sampleRate: 0.5, captureSourceQuery: false } }}>
 ```
 
 - `enabled` — absent follows the dashboard toggle; `false` opts out locally;
@@ -426,7 +519,9 @@ inside a native view and never reaches JS.
 
 **Reconfiguring.** A Provider remount with the *same* config does not restart
 the SDK: both native sides compare the incoming config against the *installed*
-one and skip the start entirely. A **changed** config does restart it — and a
+one and skip the start entirely. A **changed** config does restart it (on iOS,
+except a change confined to `releaseHealth` or the loaded bundle; see
+[Release health](#release-health)) — and a
 start supersedes the running SDK, detaching every player integration it had
 announced. **Limitation:** players tracked before that restart stay untracked
 until their screens remount; nothing re-registers them automatically. Two React
@@ -598,7 +693,7 @@ on Android), so React Native's focus engine never sees it — the native VC
 manages focus on its own UIWindow / Activity.
 
 ```tsx
-<EverframeProvider config={{ apiKey }}>
+<EverframeProvider config={{ sdkKey }}>
   <NavigationContainer>{/* focus engine root */}</NavigationContainer>
 </EverframeProvider>
 ```
@@ -727,28 +822,12 @@ 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
+apps that disable AndroidX Startup. 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.
+configuration does not register another lifecycle observer. Capture configuration
+remains synchronous without waiting for reporter UI initialization. A failure
+while opening is reported to JavaScript. Background or unavailable activities
+return a cancelled result with reason `no_active_activity`.
 
 Activity destruction while a reporter is open resolves the pending call with
 `{ status: "cancelled", reason: "activity_destroyed" }`, releases that report's

package/android/build.gradle.kts

@@ -21,11 +21,10 @@
 //   spec); a host on the new architecture can flip the parent class with a
 //   1-line patch once codegen output is available in the consuming build.
 //
-// ZERO-PERMISSION:
-//   No `<uses-permission>` in AndroidManifest.xml. The bridge adds zero
-//   permissions on top of whatever `:everframe-core` declares (the core also
-//   has none — Phase 5 zero-permission AAR contract). Verified by the 06-03
-//   acceptance grep.
+// PERMISSIONS:
+//   No `<uses-permission>` in AndroidManifest.xml. The bridge adds no
+//   permissions on top of what `:everframe-core` declares (INTERNET only,
+//   merged into the host app's manifest).
 //
 // SCOPE (NOT in this build):
 //   • Namespace is `dev.everframe.rn`.
@@ -152,7 +151,9 @@ 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 ?: "[1.1.0,1.2.0)"
+// Native 1.2.0 is the release that renamed the SDK key to `sdkKey`; the
+// bridge moves with it, ahead of package.json, which the 1.2.0 release bumps.
+val nativeMinorRange: String = nativeVersionOverride ?: "[1.2.1,1.3.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

@@ -22,7 +22,7 @@
 //   signalCompanionReportRequestReady(id) → void           (Plan 06.2-13)
 //   trackPlayer/detachPlayer/recordPlayerEvent/updatePlayerStats/
 //   trackVitals                           → void           (spec 2026-09-06)
-//   configure(opts.vitals*)               → void           (spec 2026-09-06)
+//   configureSync(opts.vitals*)           → boolean        (spec 2026-09-06)
 //   addListener(name)/removeListeners(n)  → void (RN event-emitter no-ops)
 //
 // The native TXReporterPresenter owns the entire report UX (capture, annotate,
@@ -30,8 +30,7 @@
 // and the sensitive-rect bridge. Native mobile shake stays below this bridge.
 //
 // THREADING:
-//   • configureSync runs on the JS thread (blocking synchronous); legacy
-//     void configure retains React Native's queued native dispatch.
+//   • configureSync runs on the JS thread (blocking synchronous).
 //   • openReporter dispatches presenter.openReporter onto the activity from
 //     MainScope (presenter manages its own UI thread hops internally).
 //   • registerSensitiveRect runs on the UI thread (UIManager view resolution).
@@ -76,6 +75,8 @@ import dev.everframe.companion.CompanionSubmissionComposer
 import dev.everframe.companion.PreviewCapture
 import dev.everframe.companion.RelayWSClient
 import dev.everframe.companion.parseCompanionBadgePosition
+import dev.everframe.config.ReleaseHealthConfig
+import dev.everframe.config.ReleaseHealthBundleStatus
 import dev.everframe.config.CaptureConfig
 import dev.everframe.config.Environment
 import dev.everframe.config.ReportResult
@@ -146,6 +147,8 @@ class EverframeModule(
         internal const val REJECT_CAPTURE_DISABLED: String = "capture_disabled"
         internal const val REJECT_NO_ACTIVITY: String = "no_activity"
         internal const val REJECT_OPEN_REPORTER_FAILED: String = "open_reporter_failed"
+        /** Crash-only sessions (spec 2026-10-12). The JS facade maps this exact code to `EverframeReporterDisabledError`. */
+        internal const val REJECT_REPORTER_DISABLED: String = "EVERFRAME_REPORTER_DISABLED"
 
         // Plan 06.2-11 — JS-side event names. Keep in lock-step with
         // `packages/sdk-react-native/src/companion.ts` and the iOS
@@ -173,13 +176,10 @@ class EverframeModule(
         // below for the full contract.
         internal const val COMPANION_ATTACH_CHALLENGE_EVENT: String =
             "everframe.companion.attachChallenge"
-        // Fired when a `report.request` arrives from the paired phone. This
-        // used to give JS a window to walk the React fiber tree and call
-        // `attachReactTree`; both the tree payload and that spec method are
-        // gone (spec 2026-08-29). The event and its
-        // `signalCompanionReportRequestReady` acknowledgement survive as the
-        // companion's JS-ready handshake — the bounded wait is part of the
-        // pairing flow, not of tap-to-identify.
+        // Fired when a `report.request` arrives from the paired phone. The
+        // event and its `signalCompanionReportRequestReady` acknowledgement
+        // are the companion's JS-ready handshake — the bounded wait is part
+        // of the pairing flow.
         internal const val COMPANION_REPORT_REQUESTED_EVENT: String = "everframe.companion.reportRequested"
 
         // Spec 2026-09-17 setExtra-resolver — NOT a companion event (no
@@ -207,20 +207,48 @@ class EverframeModule(
 
     // ---------------- configure ----------------
 
-    @ReactMethod
-    override fun configure(opts: ReadableMap) {
-        configureInternal(opts)
-    }
-
     @ReactMethod(isBlockingSynchronousMethod = true)
     override fun configureSync(opts: ReadableMap): Boolean = configureInternal(opts)
 
+    private fun parseReleaseHealth(opts: ReadableMap): ReleaseHealthConfig? {
+        // Invalid bridge input revokes earlier monitoring instead of retaining an old subject.
+        // The SDK reads the app version itself; the bridge carries the loaded bundle, the user ID and
+        // whether debug builds count. Release health is on by default: a missing or null flag is on, and
+        // only an explicit false is off. It still needs a valid loaded bundle, so no id means off.
+        return runCatching {
+            if (opts.takeIfHasBoolean("releaseHealthEnabled") == false) return null
+            val loaded = opts.takeIfHasString("releaseHealthLoadedBuildId") ?: return null
+            val user = opts.takeIfHasString("releaseHealthUserId")
+            if (!validHealthText(loaded, 200) || (user != null && !validHealthText(user, 128))) return null
+            val includeDebugBuilds = opts.takeIfHasBoolean("releaseHealthIncludeDebugBuilds") ?: false
+            ReleaseHealthConfig(enabled = true, userId = user, loadedBuildId = loaded,
+                loadedBundleStatus = ReleaseHealthBundleStatus.KNOWN, includeDebugBuilds = includeDebugBuilds)
+        }.getOrNull()
+    }
+
+    private fun validHealthText(value: String, maximum: Int): Boolean {
+        // Match the wire's UTF-16 limit and ECMAScript blank definition, preserving ID bytes.
+        fun blank(c: Char) = c in '\u0009'..'\u000d' || c == ' ' || c == '\u00a0' ||
+            c == '\u1680' || c in '\u2000'..'\u200a' || c == '\u2028' || c == '\u2029' ||
+            c == '\u202f' || c == '\u205f' || c == '\u3000' || c == '\ufeff'
+        if (value.length > maximum || value.all(::blank)) return false
+        var index = 0
+        while (index < value.length) {
+            val c = value[index++]
+            if (c.code < 32 || Character.isLowSurrogate(c)) return false
+            if (Character.isHighSurrogate(c)) {
+                if (index >= value.length || !Character.isLowSurrogate(value[index++])) return false
+            }
+        }
+        return true
+    }
+
     private fun configureInternal(opts: ReadableMap): Boolean {
         var completed = false
         txGuardSurface("configure") {
-            val sdkKey = opts.takeIfHasString("apiKey")
+            val sdkKey = opts.takeIfHasString("sdkKey")
                 ?: throw JSApplicationIllegalArgumentException(
-                    "configure: required field 'apiKey' missing",
+                    "configure: required field 'sdkKey' missing",
                 )
             val sdkVersion = opts.takeIfHasString("sdkVersion") ?: Everframe.SDK_VERSION
 
@@ -233,6 +261,13 @@ class EverframeModule(
             // Polarity flips exactly once, here: JS sends the veto
             // (`installIdentifierDisabled`), native stores the permission.
             val installIdentifierDisabled = opts.takeIfHasBoolean("installIdentifierDisabled") ?: false
+            // Polarity flips exactly once, here: JS sends the veto
+            // (`crashReportingDisabled`), native stores the permission.
+            val crashReportingDisabled = opts.takeIfHasBoolean("crashReportingDisabled") ?: false
+            // Polarity flips exactly once, here: JS sends the crash-only switch
+            // (`reporterDisabled`, flattened from `reporter: { disabled }`),
+            // native stores the permission.
+            val reporterDisabled = opts.takeIfHasBoolean("reporterDisabled") ?: false
             // Attach-PIN UI mode (spec 2026-08-19) — a flat optional STRING
             // field (codegen cannot express a string-literal union), parsed
             // here and stashed for `startCompanion()` to read (the flag is a
@@ -245,12 +280,20 @@ class EverframeModule(
             val attachPinUi = parseAttachPinUi(opts.takeIfHasString("attachPinUi"))
 
             val config = EverframeConfig(
+                // The JS config carries no App ID, and the native SDK requires a
+                // non-blank one. It only keys this app's low-memory-kill issue, so
+                // the SDK key stands in, as it always has; changing it would split
+                // existing React Native low-memory issues.
                 appId = sdkKey,
                 sdkKey = sdkKey,
                 environment = Environment.production,
                 release = sdkVersion,
-                capture = CaptureConfig(networkBodies = !networkBodiesDisabled),
+                capture = CaptureConfig(networkBodies = !networkBodiesDisabled, crash = !crashReportingDisabled),
                 installIdentifierEnabled = !installIdentifierDisabled,
+                releaseHealth = parseReleaseHealth(opts),
+                // The JS facade always sends React Native's `__DEV__` (or the host's override). A missing
+                // or null key stays null so the native SDK decides for itself, as for any other caller.
+                debugBuild = opts.takeIfHasBoolean("debugBuild"),
                 // Explicit companion device-identity override (naming spec
                 // 2026-08-24) — read straight off the flat ConfigOpts field,
                 // same shape as attachPinUi above. Absent/blank falls
@@ -268,6 +311,7 @@ class EverframeModule(
                 // `startCompanion()` time, mirroring `attachPinUi`.
                 companionBadgeEnabled = opts.takeIfHasBoolean("companionBadgeEnabled") ?: true,
                 shakeToReportEnabled = opts.takeIfHasBoolean("shakeToReportEnabled") ?: true,
+                reporterEnabled = !reporterDisabled,
                 companionBadgePosition = opts.takeIfHasString("companionBadgePosition"),
                 // Inline reporter theme (reporter branding spec 2026-08-25,
                 // RN slice) — 8 flat optional STRING fields on ConfigOpts
@@ -377,6 +421,9 @@ class EverframeModule(
      *   { status: "submitted", reportId: "<uuid>" }
      *   { status: "queued",    reportId: "<uuid>" }
      *   { status: "cancelled" }
+     *
+     * Rejects with [REJECT_REPORTER_DISABLED] in a crash-only session
+     * (`reporterDisabled`), including after a companion bond upgraded it.
      */
     @ReactMethod
     override fun openReporter(promise: Promise) {
@@ -384,6 +431,12 @@ class EverframeModule(
             promise.reject(REJECT_CAPTURE_DISABLED, "Everframe not started (captureGate=false). Call configure() first.")
             return
         }
+        // Crash-only session: rejected here because ReporterBridge reduces every core failure to one
+        // generic message, which would hide `ReporterDisabledException` from JS.
+        if (Everframe.currentConfig?.reporterEnabled == false) {
+            promise.reject(REJECT_REPORTER_DISABLED, "The reporter is turned off for this session (reporter.disabled).")
+            return
+        }
         MainScope().launch {
             try {
                 val result: ReportResult = reporterBridge.open(reactContext)
@@ -454,7 +507,7 @@ class EverframeModule(
      * `Everframe.addBreadcrumb` (Task 9) — NO validation/coercion here. That
      * singleton already owns kind/level/data coercion AND gating (no-op
      * pre-start / while killed via its own `txGuardVoid` + `captureGate`
-     * check), exactly like `setExtra`/`attachReactTree` above never re-check
+     * check), exactly like `setExtra` above never re-checks
      * `captureGate` themselves. `data` crosses as a `ReadableMap?` — the
      * codegen-typed freeform-object boundary — converted with RN's own
      * `toHashMap()` (no re-shaping) before handing off.
@@ -591,7 +644,7 @@ class EverframeModule(
      *
      * The primary fix is the JS projection in `src/user-projection.ts`, applied
      * before the value ever crosses the bridge. This is the second layer, for a
-     * hand-wired native caller (or a host on an older JS bundle) that reaches
+     * hand-wired native caller that reaches
      * this method directly: bad fields degrade to `null` — a partial user, or
      * anonymous — and `Everframe.setUser` is ALWAYS reached, so the call always
      * replaces what was installed before.
@@ -641,11 +694,11 @@ class EverframeModule(
     @ReactMethod(isBlockingSynchronousMethod = true)
     override fun getReportDeliveryStatusJson(): String = Everframe.getReportDeliveryStatus().toJson()
 
-    /** Automatic ErrorUtils capture; true acknowledges completed sidecar storage. */
+    /** Automatic ErrorUtils and unhandled-rejection capture; true acknowledges completed sidecar storage. A non-fatal error may carry a replay. */
     @ReactMethod(isBlockingSynchronousMethod = true)
     override fun reportCrash(crashJson: String): Boolean = captureCrashJson(crashJson, handled = false)
 
-    /** Explicit capture always enforces handled=true, fatal=false, captureException. */
+    /** Explicit capture always enforces handled=true, fatal=false, captureException, and may carry a replay. */
     @ReactMethod(isBlockingSynchronousMethod = true)
     override fun captureHandledException(crashJson: String): Boolean = captureCrashJson(crashJson, handled = true)
 
@@ -672,12 +725,17 @@ class EverframeModule(
             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.captureHandledFactsWithCauses(
+            // Only errors the app survives ask for a replay. Eligibility and export remain in the core;
+            // fatal errors keep the entry point that never carries a replay.
+            val accepted = when {
+                handled -> dev.everframe.crash.CrashReporter.captureHandledFactsWithReplay(
                     exceptionType, message, frames, occurredAt, jsBundle, details, causeChain, "everframe-android",
                 )
-            } else {
-                dev.everframe.crash.CrashReporter.captureFactsAcceptedWithCauses(
+                fatal -> dev.everframe.crash.CrashReporter.captureFactsAcceptedWithCauses(
+                    exceptionType, message, frames, obj.optString("mechanism", "errorutils"),
+                    fatal, occurredAt, jsBundle, details, causeChain,
+                )
+                else -> dev.everframe.crash.CrashReporter.captureFactsAcceptedWithReplay(
                     exceptionType, message, frames, obj.optString("mechanism", "errorutils"),
                     fatal, occurredAt, jsBundle, details, causeChain,
                 )
@@ -1051,14 +1109,6 @@ class EverframeModule(
         val capture: ScreenshotCapture.CaptureResult,
         val reportCapture: dev.everframe.capture.video.FrozenReportCapture,
         val hostExtra: String?,
-        /**
-         * Drained-and-discarded host React tree (spec 2026-08-29). Nothing
-         * reads it any more, and RN can no longer attach one — the
-         * TurboModule spec method is gone. Kept only because the native core
-         * `Everframe.attachReactTree` remains callable by pure-native hosts,
-         * so the consume-once drain must still clear the slot.
-         */
-        val hostReactTreeJson: String?,
     )
 
     private val companionCaptureStash = ConcurrentHashMap<String, CompanionCapture>()
@@ -1115,7 +1165,7 @@ class EverframeModule(
                         //    same reason the screenshot capture above is —
                         //    this whole provider runs on the OkHttp WS
                         //    thread, never the UI thread.
-                        val (hostExtraRaw, hostReactTreeJson) =
+                        val hostExtraRaw =
                             runBlocking { Everframe.consumePendingAttachments() }
                         val hostExtra = hostExtraRaw?.takeIf { it.isNotEmpty() }
 
@@ -1127,7 +1177,6 @@ class EverframeModule(
                                 capture = capture,
                                 reportCapture = reportCapture,
                                 hostExtra = hostExtra,
-                                hostReactTreeJson = hostReactTreeJson?.takeIf { it.isNotEmpty() },
                             )
                         }
                         if (!published) {
@@ -1439,9 +1488,7 @@ class EverframeModule(
     /**
      * Called by the JS companion module from the `everframe.companion
      * .reportRequested` event handler once it is ready for capture to
-     * proceed. (It used to walk the React fiber tree and call
-     * `attachReactTree` first; both are gone — spec 2026-08-29.) Releases
-     * the `awaitJsReactTreeAttach` waiter for this correlation id so the
+     * proceed. Releases the `awaitJsReactTreeAttach` waiter for this correlation id so the
      * capture provider can proceed. Idempotent — late signals after the
      * timeout fired are harmless.
      */

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

@@ -9,7 +9,6 @@ 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
@@ -19,7 +18,7 @@ import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
-/** Reflection preserves compatibility with separately built native reporter artifacts. */
+/** Resolves the reporter installer reflectively, so tests can substitute it. */
 internal class ReporterBridge(
     private val resolveInstaller: () -> Class<*> = { Class.forName("dev.everframe.ui.ReporterResolverInstaller") },
 ) {
@@ -46,17 +45,9 @@ internal class ReporterBridge(
         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)
-                }
+            val method = type.getMethod("openForActivity", Context::class.java, Activity::class.java, Continuation::class.java)
+            suspendCoroutineUninterceptedOrReturn<ReportResult> { continuation ->
+                invoke(method, instance, context.applicationContext, activity, continuation)
             }
         } catch (failure: Throwable) {
             when (failure) {