@everframe/react-native 1.0.0 → 1.2.0

package/dist/index.d.ts

@@ -1,10 +1,87 @@
 import * as React from 'react';
 import { EverframeUserSpec, ConfigOpts } from './NativeEverframe.js';
 export { Rect, Spec } from './NativeEverframe.js';
-import { E as EverframeIntegration } from './types-D5e4kWaw.js';
 import { z } from 'zod';
+import { E as EverframeIntegration } from './types-D5e4kWaw.js';
+import { R as ReportDeliveryStatus, E as ErrorCaptureStatus, P as PromiseRejectionStatus } from './promise-rejection-types-C-lxCdDl.js';
+export { a as ErrorCaptureCounters, b as ErrorCaptureOutcome, c as ErrorCapturePath, d as PromiseRejectionCounters, e as RejectionReason, f as ReportCaptureOutcome, g as ReportCapturePath, h as ReportCapturePathStatus, i as ReportDeliveryReason, j as ReportQueueOperation, k as ReportQueueStatus, l as ReportStorageFailure, m as ReportTransportOrigin, n as ReportTransportOutcome, o as ReportTransportStatus } from './promise-rejection-types-C-lxCdDl.js';
 import { ViewProps, EventSubscription } from 'react-native';
 
+declare const ErrorSeverity: z.ZodEnum<{
+    error: "error";
+    info: "info";
+    warning: "warning";
+}>;
+type ErrorSeverity = z.infer<typeof ErrorSeverity>;
+
+/** Optional per-occurrence details captured with a handled exception. */
+interface CaptureExceptionOptions {
+    severity?: ErrorSeverity;
+    context?: string;
+    metadata?: Record<string, unknown>;
+}
+interface DeviceMetadata {
+    os: string;
+    osVersion: string;
+    model?: string;
+    screenSize: {
+        width: number;
+        height: number;
+    };
+    pixelRatio: number;
+    locale: string;
+    timezone: string;
+    network?: string;
+    /**
+     * Raw User-Agent string from `navigator.userAgent`. Surfaced to triagers so
+     * they can disambiguate things our OS/version parser doesn't capture
+     * (browser engine + version, in-app webviews, bot signatures, accessibility
+     * UA overrides). Web SDK only — native SDKs leave this undefined.
+     */
+    userAgent?: string;
+}
+interface ReportDraft {
+    title: string;
+    description: string;
+    excludedArtifacts: string[];
+    annotations: unknown[];
+    redactions: unknown[];
+    /** Host-supplied free-form metadata (from `setExtra`). Opaque string, ≤2000 chars. */
+    extra?: string;
+}
+/**
+ * The SDK key under its name, `sdkKey`, or under `apiKey`, its name before
+ * 1.2. `apiKey` is deprecated but still accepted, so a 1.1 config keeps
+ * working; `sdkKey` wins when both are set. Exactly one is required.
+ */
+type SdkKeyField = {
+    /**
+     * Per-app SDK key (`evf_live_…`; publishable, not secret). Every
+     * Everframe SDK names this field `sdkKey`. It is not the App ID (a UUID)
+     * that symbol and source-map uploads take.
+     */
+    sdkKey: string;
+    /** @deprecated Renamed to `sdkKey`. Still accepted; `sdkKey` wins when both are set. */
+    apiKey?: string;
+} | {
+    sdkKey?: undefined;
+    /** @deprecated Renamed to `sdkKey`. Still accepted. */
+    apiKey: string;
+};
+/** `C` as a host passes it: the SDK key as `sdkKey` or the deprecated `apiKey`. */
+type WithSdkKeyField<C extends {
+    sdkKey: string;
+}> = Omit<C, 'sdkKey'> & SdkKeyField;
+/**
+ * A host-supplied function that produces the next report's `extra` payload
+ * on demand. Registered via `setExtra(resolve)`; invoked once per report
+ * assembly (see `resolveClientExtra`), never at registration time.
+ */
+type ExtraResolver = () => string | Record<string, unknown>;
+
+/** Protocol ceiling — `packages/protocol/src/envelope.ts`. */
+declare const EXTRA_MAX_CHARS = 16384;
+
 type JsonScalar = string | number | boolean | null;
 type JsonValue = JsonScalar | JsonValue[] | JsonObject;
 type JsonObject = {
@@ -19,6 +96,7 @@ declare const ReportEnvelope: z.ZodObject<{
         error: "error";
         manual: "manual";
         crash: "crash";
+        diagnostic: "diagnostic";
     }>>;
     sessionId: z.ZodOptional<z.ZodString>;
     sdk: z.ZodObject<{
@@ -31,17 +109,19 @@ declare const ReportEnvelope: z.ZodObject<{
             "everframe-ios": "everframe-ios";
             "everframe-android": "everframe-android";
             "everframe-roku": "everframe-roku";
+            "everframe-vega": "everframe-vega";
         }>;
         version: z.ZodString;
         platform: z.ZodEnum<{
-            web: "web";
-            ios: "ios";
             android: "android";
+            ios: "ios";
+            web: "web";
             tvos: "tvos";
             tizen: "tizen";
             webos: "webos";
             androidtv: "androidtv";
             roku: "roku";
+            vega: "vega";
         }>;
         formFactor: z.ZodEnum<{
             phone: "phone";
@@ -125,13 +205,13 @@ declare const ReportEnvelope: z.ZodObject<{
             resHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             reqBodySkipped: z.ZodOptional<z.ZodEnum<{
                 error: "error";
-                "content-type": "content-type";
                 unsupported: "unsupported";
+                "content-type": "content-type";
             }>>;
             resBodySkipped: z.ZodOptional<z.ZodEnum<{
                 error: "error";
-                "content-type": "content-type";
                 unsupported: "unsupported";
+                "content-type": "content-type";
             }>>;
         }, z.core.$loose>>>;
         vitals: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -210,8 +290,9 @@ declare const ReportEnvelope: z.ZodObject<{
             jsBundle: z.ZodOptional<z.ZodObject<{
                 engine: z.ZodLiteral<"hermes">;
                 platform: z.ZodEnum<{
-                    ios: "ios";
                     android: "android";
+                    ios: "ios";
+                    vega: "vega";
                 }>;
                 buildId: z.ZodString;
                 bundleName: z.ZodString;
@@ -232,6 +313,86 @@ declare const ReportEnvelope: z.ZodObject<{
                 }, z.core.$strip>>;
                 causesTruncated: z.ZodBoolean;
             }, z.core.$strip>>;
+            native: z.ZodOptional<z.ZodObject<{
+                releaseHealthEvidence: z.ZodOptional<z.ZodObject<{
+                    version: z.ZodLiteral<1>;
+                    attribution: z.ZodLiteral<"immutable_fatal_context">;
+                    contextId: z.ZodString;
+                    exposure: z.ZodObject<{
+                        loadedBuildId: z.ZodNullable<z.ZodString>;
+                        loadedBundleStatus: z.ZodEnum<{
+                            unknown: "unknown";
+                            known: "known";
+                            not_applicable: "not_applicable";
+                        }>;
+                        exposureId: z.ZodString;
+                        processLaunchId: z.ZodString;
+                        startedAt: z.ZodISODateTime;
+                        app: z.ZodObject<{
+                            version: z.ZodString;
+                            build: z.ZodNullable<z.ZodString>;
+                            debug: z.ZodBoolean;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                platform: z.ZodLiteral<"apple">;
+                timestampMicros: z.ZodString;
+                crashedThreadIndex: z.ZodNumber;
+                framesIncomplete: z.ZodBoolean;
+                imagesIncomplete: z.ZodBoolean;
+                images: z.ZodArray<z.ZodObject<{
+                    uuid: z.ZodString;
+                    name: z.ZodString;
+                    loadAddress: z.ZodString;
+                    vmAddress: z.ZodOptional<z.ZodString>;
+                    size: z.ZodString;
+                    cpuType: z.ZodNumber;
+                    cpuSubtype: z.ZodNumber;
+                    architecture: z.ZodEnum<{
+                        unknown: "unknown";
+                        arm64e: "arm64e";
+                        arm64: "arm64";
+                        x86_64: "x86_64";
+                        x86_64h: "x86_64h";
+                    }>;
+                }, z.core.$strip>>;
+                frames: z.ZodArray<z.ZodObject<{
+                    instructionAddress: z.ZodString;
+                    imageIndex: z.ZodOptional<z.ZodNumber>;
+                    imageOffset: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                error: z.ZodObject<{
+                    signalNumber: z.ZodOptional<z.ZodNumber>;
+                    signalCode: z.ZodOptional<z.ZodNumber>;
+                    machException: z.ZodOptional<z.ZodNumber>;
+                    machCode: z.ZodOptional<z.ZodString>;
+                    machSubcode: z.ZodOptional<z.ZodString>;
+                    faultAddress: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            androidNative: z.ZodOptional<z.ZodObject<{
+                source: z.ZodEnum<{
+                    "android-exit-info": "android-exit-info";
+                    "android-native-handler": "android-native-handler";
+                }>;
+                abi: z.ZodEnum<{
+                    x86_64: "x86_64";
+                    "armeabi-v7a": "armeabi-v7a";
+                    "arm64-v8a": "arm64-v8a";
+                    x86: "x86";
+                    riscv64: "riscv64";
+                }>;
+                crashedThreadId: z.ZodNumber;
+                framesIncomplete: z.ZodBoolean;
+                frames: z.ZodArray<z.ZodObject<{
+                    pc: z.ZodString;
+                    relativePc: z.ZodString;
+                    module: z.ZodOptional<z.ZodString>;
+                    buildId: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                signalNumber: z.ZodOptional<z.ZodNumber>;
+                signalCode: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
             exceptionType: z.ZodString;
             message: z.ZodString;
             frames: z.ZodArray<z.ZodObject<{
@@ -248,12 +409,245 @@ declare const ReportEnvelope: z.ZodObject<{
             occurredAt: z.ZodString;
             fingerprint: z.ZodString;
         }, z.core.$loose>>;
+        diagnostic: z.ZodOptional<z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            evidenceId: z.ZodString;
+            processLaunchId: z.ZodString;
+            nativeExposure: z.ZodOptional<z.ZodObject<{
+                loadedBuildId: z.ZodNullable<z.ZodString>;
+                loadedBundleStatus: z.ZodEnum<{
+                    unknown: "unknown";
+                    known: "known";
+                    not_applicable: "not_applicable";
+                }>;
+                exposureId: z.ZodString;
+                processLaunchId: z.ZodString;
+                startedAt: z.ZodISODateTime;
+                app: z.ZodObject<{
+                    version: z.ZodString;
+                    build: z.ZodNullable<z.ZodString>;
+                    debug: z.ZodBoolean;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            kind: z.ZodLiteral<"process_exit">;
+            provenance: z.ZodLiteral<"android_application_exit_info">;
+            scope: z.ZodLiteral<"os_process">;
+            outcome: z.ZodLiteral<"terminated">;
+            cause: z.ZodEnum<{
+                unknown: "unknown";
+                anr: "anr";
+                native_crash: "native_crash";
+                java_crash: "java_crash";
+                system_low_memory: "system_low_memory";
+                user_requested: "user_requested";
+                system_other: "system_other";
+            }>;
+            occurredAt: z.ZodString;
+            collectedAt: z.ZodString;
+            attribution: z.ZodObject<{
+                process: z.ZodLiteral<"exact_os_token">;
+                release: z.ZodLiteral<"frozen">;
+                session: z.ZodLiteral<"unavailable">;
+                webExposure: z.ZodLiteral<"unavailable">;
+            }, z.core.$strict>;
+            android: z.ZodObject<{
+                apiLevel: z.ZodNumber;
+                reason: z.ZodNumber;
+                pid: z.ZodNumber;
+                importance: z.ZodOptional<z.ZodNumber>;
+                pssKb: z.ZodOptional<z.ZodNumber>;
+                rssKb: z.ZodOptional<z.ZodNumber>;
+                description: z.ZodOptional<z.ZodString>;
+                mappingId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            trace: z.ZodObject<{
+                status: z.ZodEnum<{
+                    unavailable: "unavailable";
+                    available: "available";
+                    malformed: "malformed";
+                    unsupported: "unsupported";
+                    not_requested: "not_requested";
+                }>;
+                format: z.ZodEnum<{
+                    none: "none";
+                    android_anr_text: "android_anr_text";
+                    android_tombstone: "android_tombstone";
+                }>;
+                truncated: z.ZodBoolean;
+                frames: z.ZodArray<z.ZodObject<{
+                    function: z.ZodString;
+                    file: z.ZodOptional<z.ZodString>;
+                    line: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        appleDiagnostic: z.ZodOptional<z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            evidenceId: z.ZodString;
+            ownershipId: z.ZodString;
+            kind: z.ZodEnum<{
+                hang_batch: "hang_batch";
+                app_exit_summary: "app_exit_summary";
+            }>;
+            provenance: z.ZodLiteral<"apple_metrickit">;
+            scope: z.ZodLiteral<"reporting_interval">;
+            outcome: z.ZodLiteral<"unknown">;
+            interval: z.ZodObject<{
+                begin: z.ZodString;
+                end: z.ZodString;
+            }, z.core.$strict>;
+            collectedAt: z.ZodString;
+            attribution: z.ZodObject<{
+                process: z.ZodLiteral<"unavailable">;
+                release: z.ZodLiteral<"frozen">;
+                session: z.ZodLiteral<"unavailable">;
+                webExposure: z.ZodLiteral<"unavailable">;
+            }, z.core.$strict>;
+            apple: z.ZodObject<{
+                applicationVersion: z.ZodString;
+                applicationBuild: z.ZodString;
+                osVersion: z.ZodString;
+            }, z.core.$strict>;
+            truncated: z.ZodBoolean;
+            hangs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                durationMs: z.ZodNumber;
+                stack: z.ZodObject<{
+                    status: z.ZodEnum<{
+                        unavailable: "unavailable";
+                        available: "available";
+                        malformed: "malformed";
+                        oversized: "oversized";
+                    }>;
+                    truncated: z.ZodBoolean;
+                    frames: z.ZodArray<z.ZodObject<{
+                        binaryUUID: z.ZodString;
+                        binaryName: z.ZodString;
+                        address: z.ZodString;
+                        offset: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            exits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                state: z.ZodEnum<{
+                    background: "background";
+                    foreground: "foreground";
+                }>;
+                reason: z.ZodEnum<{
+                    normal: "normal";
+                    memory_resource_limit: "memory_resource_limit";
+                    bad_access: "bad_access";
+                    abnormal: "abnormal";
+                    illegal_instruction: "illegal_instruction";
+                    watchdog: "watchdog";
+                    cpu_resource_limit: "cpu_resource_limit";
+                    memory_pressure: "memory_pressure";
+                    suspended_locked_file: "suspended_locked_file";
+                    background_task_timeout: "background_task_timeout";
+                }>;
+                count: z.ZodNumber;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        recoveredStall: z.ZodOptional<z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            evidenceId: z.ZodString;
+            kind: z.ZodLiteral<"recovered_main_thread_stall">;
+            provenance: z.ZodLiteral<"android_main_looper_probe">;
+            outcome: z.ZodLiteral<"recovered">;
+            scope: z.ZodLiteral<"main_looper">;
+            queuedAt: z.ZodString;
+            recoveredAt: z.ZodString;
+            probeDelayMs: z.ZodNumber;
+            thresholdMs: z.ZodLiteral<5000>;
+            sampleIntervalMs: z.ZodLiteral<1000>;
+            clock: z.ZodLiteral<"uptime">;
+            eligibility: z.ZodLiteral<"foreground-debugger-checked-v1">;
+            trace: z.ZodLiteral<"not_collected">;
+            attribution: z.ZodObject<{
+                release: z.ZodLiteral<"frozen">;
+                session: z.ZodLiteral<"unavailable">;
+                webExposure: z.ZodLiteral<"unavailable">;
+                nativeExposure: z.ZodLiteral<"unavailable">;
+            }, z.core.$strict>;
+            android: z.ZodObject<{
+                apiLevel: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        inferredTermination: z.ZodOptional<z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            evidenceId: z.ZodString;
+            processLaunchId: z.ZodString;
+            nativeExposure: z.ZodOptional<z.ZodObject<{
+                loadedBuildId: z.ZodNullable<z.ZodString>;
+                loadedBundleStatus: z.ZodEnum<{
+                    unknown: "unknown";
+                    known: "known";
+                    not_applicable: "not_applicable";
+                }>;
+                exposureId: z.ZodString;
+                processLaunchId: z.ZodString;
+                startedAt: z.ZodISODateTime;
+                app: z.ZodObject<{
+                    version: z.ZodString;
+                    build: z.ZodNullable<z.ZodString>;
+                    debug: z.ZodBoolean;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            kind: z.ZodLiteral<"process_exit">;
+            provenance: z.ZodEnum<{
+                apple_next_launch_inference: "apple_next_launch_inference";
+            }>;
+            scope: z.ZodLiteral<"os_process">;
+            outcome: z.ZodLiteral<"terminated">;
+            rules: z.ZodEnum<{
+                "apple-foreground-v1": "apple-foreground-v1";
+            }>;
+            cause: z.ZodEnum<{
+                low_memory: "low_memory";
+                unresponsive: "unresponsive";
+                unexplained: "unexplained";
+            }>;
+            lastSeenAt: z.ZodString;
+            collectedAt: z.ZodString;
+            attribution: z.ZodObject<{
+                process: z.ZodEnum<{
+                    sdk_run_record: "sdk_run_record";
+                }>;
+                release: z.ZodLiteral<"frozen">;
+                session: z.ZodLiteral<"unavailable">;
+                webExposure: z.ZodLiteral<"unavailable">;
+            }, z.core.$strict>;
+            apple: z.ZodObject<{
+                appState: z.ZodEnum<{
+                    active: "active";
+                    inactive: "inactive";
+                    launching: "launching";
+                }>;
+                footprintKb: z.ZodOptional<z.ZodNumber>;
+                availableKb: z.ZodOptional<z.ZodNumber>;
+                memorySampledAt: z.ZodOptional<z.ZodString>;
+                memoryWarnings: z.ZodNumber;
+                lastMemoryWarningAt: z.ZodOptional<z.ZodString>;
+                memoryPressure: z.ZodEnum<{
+                    warning: "warning";
+                    normal: "normal";
+                    critical: "critical";
+                }>;
+                mainThreadStallMs: z.ZodOptional<z.ZodNumber>;
+                thermalState: z.ZodEnum<{
+                    critical: "critical";
+                    nominal: "nominal";
+                    fair: "fair";
+                    serious: "serious";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
     }, z.core.$loose>;
     context: z.ZodObject<{
         app: z.ZodObject<{
             name: z.ZodString;
             version: z.ZodString;
             build: z.ZodOptional<z.ZodString>;
+            debug: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$loose>;
         device: z.ZodObject<{
             os: z.ZodString;
@@ -409,60 +803,14 @@ declare class EverframeNotMountedError extends Error {
     constructor(message?: string);
 }
 
-declare const ErrorSeverity: z.ZodEnum<{
-    error: "error";
-    info: "info";
-    warning: "warning";
-}>;
-type ErrorSeverity = z.infer<typeof ErrorSeverity>;
-
-/** Optional per-occurrence details captured with a handled exception. */
-interface CaptureExceptionOptions {
-    severity?: ErrorSeverity;
-    context?: string;
-    metadata?: Record<string, unknown>;
-}
-interface DeviceMetadata {
-    os: string;
-    osVersion: string;
-    model?: string;
-    screenSize: {
-        width: number;
-        height: number;
-    };
-    pixelRatio: number;
-    locale: string;
-    timezone: string;
-    network?: string;
-    /**
-     * Raw User-Agent string from `navigator.userAgent`. Surfaced to triagers so
-     * they can disambiguate things our OS/version parser doesn't capture
-     * (browser engine + version, in-app webviews, bot signatures, accessibility
-     * UA overrides). Web SDK only — native SDKs leave this undefined.
-     */
-    userAgent?: string;
-}
-interface ReportDraft {
-    title: string;
-    description: string;
-    excludedArtifacts: string[];
-    annotations: unknown[];
-    redactions: unknown[];
-    /** Host-supplied free-form metadata (from `setExtra`). Opaque string, ≤2000 chars. */
-    extra?: string;
-}
-/**
- * A host-supplied function that produces the next report's `extra` payload
- * on demand. Registered via `setExtra(resolve)`; invoked once per report
- * assembly (see `resolveClientExtra`), never at registration time.
- */
-type ExtraResolver = () => string | Record<string, unknown>;
-
-/** Protocol ceiling — `packages/protocol/src/envelope.ts`. */
-declare const EXTRA_MAX_CHARS = 16384;
-
 /** Shape exposed via `useEverframe()` and the top-level `open` re-export. */
 interface EverframeContextValue {
+    /** Cached native delivery observations, independent of JS admission; optional for older context implementations. */
+    getReportDeliveryStatus?(): ReportDeliveryStatus;
+    /** Local admission only; optional for older context implementations. */
+    getErrorCaptureStatus?(): ErrorCaptureStatus;
+    /** Optional for compatibility with existing context implementations. */
+    getPromiseRejectionStatus?(): PromiseRejectionStatus;
     /** Capture a handled exception without opening the reporter. No-op outside the owning mount. */
     captureException(error: unknown, options?: CaptureExceptionOptions): void;
     /**
@@ -550,6 +898,8 @@ interface EverframeContextValue {
      */
     setUser(user?: EverframeUserSpec): void;
 }
+/** Bounded coverage status only; does not install an observer or report delivery. */
+declare function getPromiseRejectionStatus(): PromiseRejectionStatus;
 /**
  * Top-level imperative `open` re-export. Inside the React tree, prefer
  * `useEverframe().open()`. This re-export exists for non-component call
@@ -582,6 +932,10 @@ declare function recordScreen(name: string, data?: Record<string, unknown>): voi
 declare function setUser(user?: EverframeUserSpec): void;
 /** Capture a handled exception from any call site. No-op without a mounted provider. */
 declare function captureException(error: unknown, options?: CaptureExceptionOptions): void;
+/** Detached local admission snapshot. Does not query native delivery or install hooks. */
+declare function getErrorCaptureStatus(): ErrorCaptureStatus;
+/** Cached native delivery observations, independent of JS admission. */
+declare function getReportDeliveryStatus(): ReportDeliveryStatus;
 
 /**
  * Runtime configuration — the host-facing `EverframeProvider config` shape.
@@ -609,19 +963,38 @@ declare function captureException(error: unknown, options?: CaptureExceptionOpti
  * review instruction, left as pre-existing behavior rather than folded in
  * here.
  */
-interface RuntimeConfig extends Omit<ConfigOpts, "sdkVersion" | "installIdentifierDisabled" | "companionBadgeEnabled" | "companionBadgePosition" | "shakeToReportEnabled" | "themeBackground" | "themeSurface" | "themeBorder" | "themeText" | "themeTextMuted" | "themeAccent" | "themeAccentForeground" | "themeDestructive" | "vitalsEnabled" | "vitalsSampleRate" | "vitalsCaptureSourceQuery"> {
+interface RuntimeConfig extends Omit<ConfigOpts, "sdkVersion" | "installIdentifierDisabled" | "crashReportingDisabled" | "companionBadgeEnabled" | "companionBadgePosition" | "shakeToReportEnabled" | "themeBackground" | "themeSurface" | "themeBorder" | "themeText" | "themeTextMuted" | "themeAccent" | "themeAccentForeground" | "themeDestructive" | "vitalsEnabled" | "vitalsSampleRate" | "vitalsCaptureSourceQuery" | "releaseHealthEnabled" | "releaseHealthLoadedBuildId" | "releaseHealthUserId" | "releaseHealthIncludeDebugBuilds"> {
     /**
      * Per-app SDK key (publishable, not secret). Required on the host-facing
-     * config — narrows the bridge `ConfigOpts.apiKey?` to required so a missing
+     * config — narrows the bridge `ConfigOpts.sdkKey?` to required so a missing
      * key is a compile-time error, matching the React SDK. The bridge type stays
      * optional (extractBridgeConfig builds `{}`); only this host surface requires it.
      */
-    apiKey: string;
+    sdkKey: string;
     appName?: string;
-    appVersion?: string;
-    appBuild?: string;
     /** Exact loaded Hermes bundle identity, independent of the native app build. */
     jsBundle?: JsBundleConfig;
+    /**
+     * Whether this is a debug build. Everframe never makes a release out of a debug build, and release
+     * health skips it. Defaults to React Native's `__DEV__`; set it only to override that.
+     */
+    debugBuild?: boolean;
+    /**
+     * Native foreground-session monitoring (release health). On by default:
+     * leave this out, or leave `enabled` out, and it is on; `enabled: false`
+     * turns it off and erases undelivered records on the device. The native SDK
+     * reads the app version and build; the loaded build comes from validated
+     * Hermes jsBundle metadata, and without that identity release health stays
+     * off. userId is an optional opaque identifier supplied for this purpose;
+     * null or omitted means anonymous, and setUser never supplies it implicitly.
+     * The native SDKs skip debug builds; `includeDebugBuilds: true` counts them,
+     * for checking an integration.
+     */
+    releaseHealth?: {
+        enabled?: boolean;
+        userId?: string | null;
+        includeDebugBuilds?: boolean;
+    };
     /**
      * Opt-in JS-side capture integrations (spec 2026-07-14 RN-iOS parity).
      * Import from '@everframe/react-native/integrations/*'; nothing
@@ -630,13 +1003,19 @@ interface RuntimeConfig extends Omit<ConfigOpts, "sdkVersion" | "installIdentifi
     integrations?: EverframeIntegration[];
     /**
      * Crash/error reporting (spec 2026-07-18). Installs a default-on global
-     * ErrorUtils handler on mount — deliberately NOT gated behind
+     * ErrorUtils handler on mount, plus a hook on React Native's
+     * ExceptionsManager for errors no React error boundary catches (React 19
+     * reports those through the root, not ErrorUtils) — deliberately NOT gated behind
      * `integrations` (deviation from the RN integrations doctrine, recorded in
      * the spec): crash capture is a safety net, not an opt-in enrichment. Set
-     * `disabled: true` to veto it entirely.
+     * `disabled: true` to veto it entirely, including native crash and ANR capture.
      */
     crashReporting?: {
         disabled?: boolean;
+        /** Opt-in automatic observation on qualified RN/Hermes runtimes. */
+        promiseRejections?: {
+            enabled?: boolean;
+        };
     };
     /**
      * Network request/response body capture (spec 2026-08-12). CLIENT VETO
@@ -741,9 +1120,14 @@ interface RuntimeConfig extends Omit<ConfigOpts, "sdkVersion" | "installIdentifi
         captureSourceQuery?: boolean;
     };
 }
+/**
+ * The provider config as a host passes it: the SDK key as `sdkKey`, or as the
+ * deprecated `apiKey` (its name before 1.2).
+ */
+type EverframeProviderConfig = WithSdkKeyField<RuntimeConfig>;
 
 interface EverframeProviderProps {
-    config: RuntimeConfig;
+    config: EverframeProviderConfig;
     children: React.ReactNode;
 }
 declare function EverframeProvider(props: EverframeProviderProps): React.ReactElement;
@@ -1009,4 +1393,4 @@ declare namespace companion {
   export { type companion_CompanionAttachChallenge as CompanionAttachChallenge, type companion_CompanionState as CompanionState, companion_getEmitter as getEmitter, companion_onAttachChallenge as onAttachChallenge, companion_onAttachedUserName as onAttachedUserName, companion_onCode as onCode, companion_onPairUrl as onPairUrl, companion_onResolvedName as onResolvedName, companion_onRunning as onRunning, companion_onState as onState, companion_start as start, companion_stop as stop, companion_useCompanion as useCompanion };
 }
 
-export { AttachmentRef, type CaptureExceptionOptions, type CompanionState, ConfigOpts, type DeviceMetadata, EXTRA_MAX_CHARS, type EverframeContextValue, EverframeIntegration, EverframeNotMountedError, EverframeProvider, type EverframeProviderProps, EverframeScreen, type EverframeScreenProps, EverframeSensitive, EverframeUserSpec, type HostPlayerEventType, type PlayerHandle, type PlayerStats, type ReportDraft, ReportEnvelope, type ReporterResult, EverframeSensitive as Sensitive, type TrackPlayerOptions, UINode, UITree, VitalsPlayerEventType, addBreadcrumb, captureException, companion, open, recordScreen, setExtra, setUser, trackPlayer, trackVitals, useCompanion, useEverframe, useEverframeScreen, useEverframeSensitiveRef, useTrackPlayer };
+export { AttachmentRef, type CaptureExceptionOptions, type CompanionState, ConfigOpts, type DeviceMetadata, EXTRA_MAX_CHARS, ErrorCaptureStatus, type EverframeContextValue, EverframeIntegration, EverframeNotMountedError, EverframeProvider, type EverframeProviderProps, EverframeScreen, type EverframeScreenProps, EverframeSensitive, EverframeUserSpec, type HostPlayerEventType, type PlayerHandle, type PlayerStats, PromiseRejectionStatus, ReportDeliveryStatus, type ReportDraft, ReportEnvelope, type ReporterResult, EverframeSensitive as Sensitive, type TrackPlayerOptions, UINode, UITree, VitalsPlayerEventType, addBreadcrumb, captureException, companion, getErrorCaptureStatus, getPromiseRejectionStatus, getReportDeliveryStatus, open, recordScreen, setExtra, setUser, trackPlayer, trackVitals, useCompanion, useEverframe, useEverframeScreen, useEverframeSensitiveRef, useTrackPlayer };