@everframe/react-native 1.1.0 → 1.2.1

package/dist/index.d.ts

@@ -2,8 +2,8 @@ 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 { 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 { R as ReportDeliveryStatus, E as ErrorCaptureStatus, P as PromiseRejectionStatus } from './promise-rejection-types-Bf5iLv8n.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-Bf5iLv8n.js';
 import { z } from 'zod';
 import { ViewProps, EventSubscription } from 'react-native';
 
@@ -21,6 +21,7 @@ declare const ReportEnvelope: z.ZodObject<{
         error: "error";
         manual: "manual";
         crash: "crash";
+        diagnostic: "diagnostic";
     }>>;
     sessionId: z.ZodOptional<z.ZodString>;
     sdk: z.ZodObject<{
@@ -33,17 +34,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";
@@ -127,13 +130,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<{
@@ -212,8 +215,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;
@@ -235,6 +239,27 @@ declare const ReportEnvelope: z.ZodObject<{
                 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;
@@ -270,6 +295,29 @@ declare const ReportEnvelope: z.ZodObject<{
                     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<{
@@ -286,12 +334,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;
@@ -446,6 +727,17 @@ declare class EverframeNotMountedError extends Error {
     readonly name = "EverframeNotMountedError";
     constructor(message?: string);
 }
+/**
+ * Rejected by `open()` when the host turned the reporter off
+ * (`reporter: { disabled: true }`, a crash-only session). The session keeps
+ * this for its whole life, including after a companion bond upgrades it:
+ * reports then come through the companion, not through `open()`. Same name
+ * as the web SDK's error of the same purpose.
+ */
+declare class EverframeReporterDisabledError extends Error {
+    readonly name = "EverframeReporterDisabledError";
+    constructor(message?: string);
+}
 
 declare const ErrorSeverity: z.ZodEnum<{
     error: "error";
@@ -501,19 +793,19 @@ 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;
+    /** Cached native delivery observations, independent of JS admission. */
+    getReportDeliveryStatus(): ReportDeliveryStatus;
+    /** Local admission only. */
+    getErrorCaptureStatus(): ErrorCaptureStatus;
+    getPromiseRejectionStatus(): PromiseRejectionStatus;
     /** Capture a handled exception without opening the reporter. No-op outside the owning mount. */
     captureException(error: unknown, options?: CaptureExceptionOptions): void;
     /**
      * Open the native reporter modal. Resolves with the user-facing outcome
      * (`submitted` / `queued` / `cancelled`). Replaces the pre-0.3 nested
      * `report.open()` — the `.report` namespace held only `.open` so flattening
-     * matches sdk-react.
+     * matches sdk-react. Rejects with `EverframeReporterDisabledError` when the
+     * config sets `reporter: { disabled: true }`.
      */
     open(): Promise<ReporterResult>;
     sensitive: {
@@ -659,19 +951,38 @@ declare function getReportDeliveryStatus(): ReportDeliveryStatus;
  * 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" | "reporterDisabled" | "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
@@ -680,10 +991,12 @@ 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;
@@ -756,6 +1069,21 @@ interface RuntimeConfig extends Omit<ConfigOpts, "sdkVersion" | "installIdentifi
     shakeToReport?: {
         enabled?: boolean;
     };
+    /**
+     * Crash-only session switch (spec 2026-10-12). CLIENT VETO only.
+     * `disabled: true` turns off every on-device way to open the reporter
+     * (shake, `open()`, which then rejects with
+     * `EverframeReporterDisabledError`), keeps network bodies off and samples
+     * session replay with the server's crash-only rate (default 0) instead of
+     * the normal one. A companion bond upgrades the session: replay and bodies
+     * then follow the normal server rules for the rest of the session, and
+     * reports come through the companion. Crash and error capture are
+     * unaffected. Flattened onto `ConfigOpts.reporterDisabled` by
+     * `extractBridgeConfig`.
+     */
+    reporter?: {
+        disabled?: boolean;
+    };
     /**
      * Inline reporter theme (reporter branding spec 2026-08-25, RN slice) —
      * 8 optional `#rrggbb` role strings for the NATIVE report dialogs the RN
@@ -795,9 +1123,11 @@ interface RuntimeConfig extends Omit<ConfigOpts, "sdkVersion" | "installIdentifi
         captureSourceQuery?: boolean;
     };
 }
+/** The provider config as a host passes it. */
+type EverframeProviderConfig = RuntimeConfig;
 
 interface EverframeProviderProps {
-    config: RuntimeConfig;
+    config: EverframeProviderConfig;
     children: React.ReactNode;
 }
 declare function EverframeProvider(props: EverframeProviderProps): React.ReactElement;
@@ -1063,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, 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 };
+export { AttachmentRef, type CaptureExceptionOptions, type CompanionState, ConfigOpts, type DeviceMetadata, EXTRA_MAX_CHARS, ErrorCaptureStatus, type EverframeContextValue, EverframeIntegration, EverframeNotMountedError, EverframeProvider, type EverframeProviderProps, EverframeReporterDisabledError, 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 };