@lumin-monitor/react-native 0.1.0 → 0.4.0

package/CHANGELOG.md

@@ -0,0 +1,139 @@
+# Changelog
+
+All notable changes to `@lumin-monitor/react-native` are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.4.0] - 2026-05-26
+
+### Added
+
+- **Mobile device classification.** The SDK now sends an `X-Lumin-Client`
+  header on every batch — `sdk=rn/0.4.0; os=ios; os_version=17.4` plus
+  optional `device=<model>` when the new `deviceInfo` init option is
+  provided. The Lumin API uses the header to fill the same `ua_os` /
+  `ua_device_type` columns the browser SDK has always populated via the
+  User-Agent header, so mobile sessions stop showing up as empty / desktop
+  in the sessions UI. A new `ua_device` column captures the device model.
+- `init({ deviceInfo })` — pass an instance of `react-native-device-info`
+  (or any `DeviceInfoLike` shim) to include the device model. Opt-in;
+  omit it and the SDK still reports `os` + `os_version` from React Native's
+  built-in `Platform` constants. Not auto-detected — same opt-in policy as
+  `storage` (0.3.0), to keep Metro bundling clean.
+- Exported `DeviceInfoLike` type for consumers writing their own shims.
+
+### Server compatibility
+
+Requires Lumin API at or after the matching server release (which adds the
+`X-Lumin-Client` parser and the `ua_device` column migration). Older
+servers will ignore the header — events still ingest, mobile rows just
+keep landing with empty `ua_*` columns.
+
+## [0.3.0] - 2026-05-26
+
+### Fixed
+
+- **`init()` no longer throws under Metro / Expo** ([report]). The 0.1.0–0.2.0
+  releases used a runtime `require("react-native")` inside `detectAppState()`.
+  Metro's static dependency scanner doesn't see requires nested in function
+  bodies, so `react-native` was excluded from the bundle and the call threw
+  `Requiring unknown module "react-native"` at app startup. Replaced with a
+  top-level `import { AppState } from "react-native"`, which Metro picks up
+  and resolves through the consumer's already-installed peer dep. tsup keeps
+  `react-native` externalised so the import survives into the published
+  artifact untouched.
+
+### Changed (BREAKING)
+
+- **AsyncStorage is no longer auto-detected.** The previous behaviour did a
+  runtime `require("@react-native-async-storage/async-storage")`, which has
+  the same Metro problem as the `react-native` require above — and forced
+  every consumer to declare an unused peer dep even when they didn't want
+  persistence. Apps that want persistence now import AsyncStorage themselves
+  and pass it through:
+
+  ```ts
+  import AsyncStorage from "@react-native-async-storage/async-storage";
+  import { init } from "@lumin-monitor/react-native";
+
+  const lumin = init({ apiKey, storage: AsyncStorage });
+  ```
+
+  Omitting `storage` falls back to in-memory ids (the same behaviour 0.2.0
+  exhibited when the optional peer dep wasn't installed). `@react-native-async-storage/async-storage`
+  has been removed from `peerDependencies` and `peerDependenciesMeta`; the
+  SDK itself no longer references the package.
+
+### Migration
+
+- If you were on 0.2.0 and had `@react-native-async-storage/async-storage`
+  installed: import it and pass it as `storage` to `init()`. Two lines of
+  app code.
+- If you didn't have it installed: nothing to change. You were already getting
+  in-memory ids (silently), which is still the default in 0.3.0.
+
+[report]: https://github.com/tamso-labs/lumin/issues  <!-- replace with the actual issue link when filed -->
+
+## [0.2.0] - 2026-05-26
+
+### Added
+
+- `captureError(err, properties?)` — capture an exception as a Lumin event.
+  Accepts a real `Error` (preferred — preserves stack and constructor name as
+  `error_type`), a string, or a plain object with a `message` field. `null` /
+  `undefined` are silently ignored. The same `Error` instance captured twice
+  in one tick is deduped.
+- Automatic capture of unhandled JS errors via `ErrorUtils.setGlobalHandler`.
+  Enabled by default; opt out with `captureUnhandledErrors: false`. The
+  handler **chains to the previous handler**, so RN's red-box, LogBox, and any
+  other error tool already installed still fires — the SDK never swallows the
+  throw.
+- Fatal errors (`isFatal: true`) trigger an immediate `flush()` so the error
+  row has a chance to leave the device before the RN runtime tears down, and
+  are stamped with `properties: { fatal: true }`.
+- `errorUtils` init option — override the auto-detected global ErrorUtils
+  (mainly for tests).
+- New wire `EventType` value `"error"` plus optional `error_message`,
+  `error_stack`, and `error_type` fields on `WireEvent`.
+
+### Notes
+
+- Native iOS / Android crashes are not captured. `ErrorUtils` is JS-only;
+  native crash reporting requires a native module (Crashlytics, Sentry-native,
+  Bugsnag's native bridge) which is out of scope for this SDK.
+- Source maps are not symbolicated server-side. Stacks ship as the RN bundle's
+  minified frames.
+- Requires Lumin API v0.x (this release) or newer — older servers will reject
+  `type: "error"` events with a 400.
+
+## [0.1.0] - 2026-05-26
+
+Initial release. Mirrors `@lumin-monitor/browser` for React Native; same
+`/v1/events` ingest, same `lmn_pub_*` API key kind, so a single Lumin project
+can hold events from web and mobile and tie them to the same user via
+`identify`.
+
+### Added
+
+- `init(options)` returning a `LuminClient` with bound `screen` / `track` /
+  `identify` / `flush` / `close` / `getSessionId` / `getAnonymousId` methods.
+- Synchronous `init()` with lazy AsyncStorage id hydration — buffered events
+  await hydration before the first flush, so apps can call `screen` /
+  `track` immediately after `init`.
+- Persistent `anonymous_id` and `session_id` via
+  `@react-native-async-storage/async-storage` (optional peer dep); graceful
+  in-memory fallback when the peer dep is missing.
+- Idle-based session rotation (`sessionIdleMs`, default 30 min) — matches the
+  GA / Mixpanel convention for mobile sessions.
+- Auto-flush on `AppState` transition to `background` or `inactive`.
+- `screen()` method (RN idiom); emits wire `type: "page"` for cross-platform
+  compatibility with the browser SDK.
+- Optional `@lumin-monitor/react-native/react-navigation` subpath exporting
+  `useLuminScreenviews(client, navigationRef)` for React Navigation v6+ apps.
+- Ships dual ESM + CJS bundle with full `.d.ts` types.
+
+[0.4.0]: https://github.com/tamso-labs/lumin/releases/tag/sdk-react-native-v0.4.0
+[0.3.0]: https://github.com/tamso-labs/lumin/releases/tag/sdk-react-native-v0.3.0
+[0.2.0]: https://github.com/tamso-labs/lumin/releases/tag/sdk-react-native-v0.2.0
+[0.1.0]: https://github.com/tamso-labs/lumin/releases/tag/sdk-react-native-v0.1.0

package/README.md

@@ -13,26 +13,36 @@ the same user.
 ## Install
 
 ```sh
-pnpm add @lumin-monitor/react-native @react-native-async-storage/async-storage
-# or: npm install … / yarn add …
+pnpm add @lumin-monitor/react-native
+# plus, if you want persistent ids across app launches (recommended):
+pnpm add @react-native-async-storage/async-storage
+# plus, if you want device-model tracking in the sessions UI:
+pnpm add react-native-device-info
 ```
 
-`@react-native-async-storage/async-storage` is an optional peer dep. The
-SDK uses it to persist `anonymous_id` across app launches and to expire
-`session_id` after 30 minutes of inactivity. If it is not installed, the
-SDK falls back to in-memory ids that reset on every cold start — useful
-for prototypes, but you almost certainly want the peer dep in production.
+`@react-native-async-storage/async-storage` is no longer auto-detected
+(it broke Metro bundling — see [CHANGELOG 0.3.0](./CHANGELOG.md)). Install
+it and pass it to `init({ storage })` to persist `anonymous_id` across app
+launches and let the 30-minute idle session window survive a cold start.
+Omit `storage` (or pass `null`) to use in-memory ids that reset on every
+cold start — fine for prototypes.
 
-React Navigation is also an optional peer dep, only needed if you import
+`react-native-device-info` is also opt-in (same reason). Without it the
+SDK still reports `os` + `os_version` via the `X-Lumin-Client` header —
+see [Device classification](#device-classification).
+
+React Navigation is an optional peer dep, only needed if you import
 `@lumin-monitor/react-native/react-navigation`.
 
 ## Quick start
 
 ```ts
+import AsyncStorage from "@react-native-async-storage/async-storage";
 import { init } from "@lumin-monitor/react-native";
 
 export const lumin = init({
   apiKey: process.env.EXPO_PUBLIC_LUMIN_BROWSER_API_KEY!,
+  storage: AsyncStorage,
 });
 
 // Bound methods, safe to destructure:
@@ -72,8 +82,11 @@ hydration to complete before sending.
 | `sessionIdleMs`   | `1800000` (30 min)            | A new session id is minted on the next event after this much inactivity.   |
 | `onError`         | `console.warn`                | Called as `(err, droppedCount)` when a batch fails.                         |
 | `fetch`           | global `fetch`                | Override for tests.                                                         |
-| `storage`         | auto-detect AsyncStorage      | Pass a custom `AsyncStorageLike`, or `null` to opt out (in-memory ids).     |
+| `storage`         | `null` (in-memory ids)        | Pass `AsyncStorage` for persistence across launches. See *Install* above.    |
 | `appState`        | auto-detect react-native      | Pass `null` to disable the background-flush listener.                       |
+| `captureUnhandledErrors` | `true`                 | Install an `ErrorUtils.setGlobalHandler` chain. See *Error capture* below.  |
+| `errorUtils`      | auto-detect global ErrorUtils | Override the ErrorUtils-like object the SDK installs into.                  |
+| `deviceInfo`      | `null` (no device model)      | Pass `DeviceInfo` from `react-native-device-info` to include the device model in the `X-Lumin-Client` header. See *Device classification* below. |
 
 ### `screen(name?, properties?)`
 
@@ -115,6 +128,50 @@ identify("user_abc123", { plan: "indie", signedUpAt: "2026-05-01" });
 Re-call on every app launch while the user is signed in. It is cheap
 and ensures a cold start still binds the session.
 
+### `captureError(err, properties?)`
+
+Capture an error. The auto-installed global handler catches uncaught JS
+throws (and rejected promises that bubble up to RN); call this directly
+from `try/catch` blocks where you'd otherwise swallow the failure.
+
+```ts
+try {
+  await applyDiscount(code);
+} catch (err) {
+  captureError(err, { code, step: "checkout" });
+  showToast("Discount didn't apply");
+}
+```
+
+Accepts a real `Error` (preferred — preserves stack and constructor name
+as `error_type`), or any value that will be stringified for the message.
+`null` / `undefined` are silently ignored. The same `Error` object
+captured twice in the same tick is deduped.
+
+### Auto error capture
+
+When `captureUnhandledErrors` is true (the default), the SDK installs a
+handler via `ErrorUtils.setGlobalHandler` that **chains to the previous
+handler**, so RN's red-box, the LogBox, and any other error tool already
+installed still fire. The SDK does not swallow the throw.
+
+Fatal errors (`isFatal: true`) trigger an immediate `flush()` so the
+error row has a chance to leave the device before the RN runtime tears
+down. Best-effort: the OS may suspend the JS thread before the request
+lands, but the standard ~30 s background grace window covers the
+common case.
+
+**What is NOT captured**:
+- **Native iOS / Android crashes.** RN's `ErrorUtils` is JS-only. Native
+  crashes need a native module (Crashlytics, Sentry-native, Bugsnag's
+  native bridge) — out of scope for this SDK.
+- **Source-mapped stacks.** Stacks ship as the minified RN bundle frames
+  ship them. Symbolication against the bundle's source maps is a v2
+  concern.
+
+Opt out with `captureUnhandledErrors: false` if another tool already
+owns the global handler; manual `captureError(err)` still works.
+
 ### `flush(): Promise<void>`
 
 Force a flush of any buffered events. The SDK auto-flushes on AppState
@@ -161,6 +218,45 @@ tracking, call `screen()` manually from the route's effect.
 Peer deps: `react >= 18`, `@react-navigation/native >= 6`. Both are
 optional — the subpath only loads them when imported.
 
+## Device classification
+
+Browser SDKs send a meaningful `User-Agent`; the Lumin server parses it
+into `ua_browser` / `ua_os` / `ua_device_type` columns that the sessions
+UI groups by. React Native's `fetch` sends `okhttp/…` or `CFNetwork/…`,
+which carries no device info, so the SDK ships an `X-Lumin-Client` header
+on every batch instead:
+
+```
+X-Lumin-Client: sdk=rn/0.4.0; os=ios; os_version=17.4
+```
+
+`os` and `os_version` come from React Native's built-in `Platform`
+constants — no peer dep required. The server folds the header into the
+same `ua_os` / `ua_device_type` columns the browser SDK has always used,
+so mobile sessions show up in the UI alongside web sessions.
+
+For the device model (`iPhone15,3`, `Pixel 7`), install
+[`react-native-device-info`](https://www.npmjs.com/package/react-native-device-info)
+and pass it through:
+
+```ts
+import DeviceInfo from "react-native-device-info";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { init } from "@lumin-monitor/react-native";
+
+export const lumin = init({
+  apiKey: process.env.EXPO_PUBLIC_LUMIN_BROWSER_API_KEY!,
+  storage: AsyncStorage,
+  deviceInfo: DeviceInfo, // populates X-Lumin-Client: device=<model>
+});
+```
+
+The SDK never `require()`s `react-native-device-info` — same opt-in
+policy as `storage`, to keep Metro bundling clean (see CHANGELOG 0.3.0).
+If the installed version of `react-native-device-info` ever changes its
+shape, ship a tiny adapter that satisfies `DeviceInfoLike`
+(`{ getModel(): string }`).
+
 ## Session semantics
 
 Sessions are **idle-based**, not tied to a single foreground period:

package/dist/index.cjs

@@ -25,6 +25,9 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/client.ts
+var import_react_native = require("react-native");
+
 // src/ids.ts
 function uuidv4() {
   const c = globalThis.crypto;
@@ -41,19 +44,6 @@ function uuidv4() {
 var ANON_KEY = "lumin.anonymous_id";
 var SESSION_KEY = "lumin.session_id";
 var SESSION_LAST_SEEN_KEY = "lumin.session_last_seen";
-function detectAsyncStorage() {
-  try {
-    if (typeof require === "undefined") return null;
-    const mod = require("@react-native-async-storage/async-storage");
-    const candidate = mod?.default ?? mod;
-    if (candidate && typeof candidate.getItem === "function" && typeof candidate.setItem === "function") {
-      return candidate;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
 function memoryStorage() {
   const m = /* @__PURE__ */ new Map();
   return {
@@ -107,8 +97,14 @@ var DEFAULT_FLUSH_MS = 500;
 var DEFAULT_SESSION_IDLE_MS = 30 * 60 * 1e3;
 var SERVER_MAX_BATCH = 1e3;
 var DEFAULT_ENDPOINT = "https://api.getlumin.dev";
+var SDK_VERSION = "0.4.0";
 var Client = class {
   constructor(opts) {
+    this.prevErrorHandler = void 0;
+    this.errorHandlerInstalled = false;
+    // Dedup the same Error captured twice (e.g. via captureError + the global
+    // handler firing on the same throw). WeakSet so we don't pin GC.
+    this.recentErrors = /* @__PURE__ */ new WeakSet();
     this.userId = null;
     this.cachedIds = null;
     // Pending events queued before ids hydrate. `user_id` is stamped at enqueue
@@ -131,11 +127,15 @@ var Client = class {
       console.warn("[lumin] flush failed", { err, dropped });
     });
     this.fetchImpl = opts.fetch ?? fetch.bind(globalThis);
-    const resolvedStorage = opts.storage === null ? memoryStorage() : opts.storage ?? detectAsyncStorage() ?? memoryStorage();
-    this.storage = resolvedStorage;
+    this.storage = opts.storage ?? memoryStorage();
     this.appState = opts.appState === void 0 ? detectAppState() : opts.appState;
+    this.errorUtils = opts.errorUtils === void 0 ? detectErrorUtils() : opts.errorUtils;
+    this.clientHeader = buildClientHeader(opts.deviceInfo ?? null);
     this.idsReady = this.hydrateIds();
     this.installBackgroundFlush();
+    if (opts.captureUnhandledErrors !== false) {
+      this.installErrorHandler();
+    }
   }
   screen(name, properties) {
     if (this.closed) return;
@@ -153,6 +153,22 @@ var Client = class {
     }
     this.enqueue({ type: "track", name, ...properties !== void 0 ? { properties } : {} });
   }
+  captureError(err, properties) {
+    if (this.closed) return;
+    const e = normalizeError(err);
+    if (!e) return;
+    if (typeof err === "object" && err !== null) {
+      if (this.recentErrors.has(err)) return;
+      this.recentErrors.add(err);
+    }
+    this.enqueue({
+      type: "error",
+      ...properties !== void 0 ? { properties } : {},
+      error_message: e.message,
+      ...e.stack ? { error_stack: e.stack } : {},
+      ...e.type ? { error_type: e.type } : {}
+    });
+  }
   identify(userId, traits) {
     if (this.closed) return;
     if (!userId) {
@@ -189,6 +205,7 @@ var Client = class {
     if (this.closed) return;
     this.closed = true;
     this.removeBackgroundFlush();
+    this.restoreErrorHandler();
     await this.flush();
     await Promise.allSettled(this.inflight);
   }
@@ -276,13 +293,15 @@ var Client = class {
       return;
     }
     const body = JSON.stringify({ events: batch });
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: "Bearer " + this.apiKey
+    };
+    if (this.clientHeader) headers["X-Lumin-Client"] = this.clientHeader;
     try {
       const res = await this.fetchImpl(this.endpoint + "/v1/events", {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + this.apiKey
-        },
+        headers,
         body
       });
       if (!res.ok) {
@@ -314,24 +333,110 @@ var Client = class {
       this.appStateSub = null;
     }
   }
+  // --- error handler -----------------------------------------------------
+  /**
+   * Install a global JS error handler via ErrorUtils.setGlobalHandler that
+   * captures + chains to whatever handler was already in place. RN's
+   * red-box and any other observability tool that installed before us
+   * still fires — we do not swallow the throw.
+   */
+  installErrorHandler() {
+    if (!this.errorUtils) return;
+    this.prevErrorHandler = this.errorUtils.getGlobalHandler?.();
+    const handler = (err, isFatal) => {
+      try {
+        this.captureError(err, isFatal ? { fatal: true } : void 0);
+        if (isFatal) void this.flush();
+      } catch {
+      }
+      if (this.prevErrorHandler) {
+        this.prevErrorHandler(err, isFatal);
+      }
+    };
+    this.errorUtils.setGlobalHandler(handler);
+    this.errorHandlerInstalled = true;
+  }
+  restoreErrorHandler() {
+    if (!this.errorHandlerInstalled || !this.errorUtils) return;
+    this.errorUtils.setGlobalHandler(
+      this.prevErrorHandler ?? defaultNoopErrorHandler
+    );
+    this.errorHandlerInstalled = false;
+  }
 };
+function defaultNoopErrorHandler() {
+}
+function detectErrorUtils() {
+  const g = globalThis;
+  const eu = g.ErrorUtils;
+  if (eu && typeof eu.setGlobalHandler === "function") {
+    return eu;
+  }
+  return null;
+}
+function normalizeError(raw) {
+  if (raw == null) return null;
+  if (raw instanceof Error) {
+    return {
+      message: raw.message || raw.name || "Error",
+      ...raw.stack ? { stack: raw.stack } : {},
+      type: raw.name || raw.constructor?.name
+    };
+  }
+  if (typeof raw === "string") {
+    return { message: raw };
+  }
+  if (typeof raw === "object") {
+    const obj = raw;
+    const message = typeof obj.message === "string" ? obj.message : safeStringify(raw);
+    return {
+      message,
+      ...typeof obj.stack === "string" ? { stack: obj.stack } : {},
+      ...typeof obj.name === "string" ? { type: obj.name } : {}
+    };
+  }
+  return { message: String(raw) };
+}
+function safeStringify(v) {
+  try {
+    return JSON.stringify(v) ?? String(v);
+  } catch {
+    return String(v);
+  }
+}
 function clampBatch(n) {
   if (!Number.isFinite(n) || n < 1) return 1;
   if (n > SERVER_MAX_BATCH) return SERVER_MAX_BATCH;
   return Math.floor(n);
 }
-function detectAppState() {
-  try {
-    if (typeof require === "undefined") return null;
-    const rn = require("react-native");
-    const candidate = rn?.AppState;
-    if (candidate && typeof candidate.addEventListener === "function") {
-      return candidate;
+function buildClientHeader(deviceInfo) {
+  const parts = [`sdk=rn/${SDK_VERSION}`];
+  const platform = import_react_native.Platform;
+  const osRaw = platform?.OS;
+  if (typeof osRaw === "string" && osRaw) {
+    parts.push(`os=${encodeURIComponent(osRaw)}`);
+  } else {
+    return "";
+  }
+  const versionRaw = platform?.Version;
+  if (versionRaw !== void 0 && versionRaw !== null && versionRaw !== "") {
+    parts.push(`os_version=${encodeURIComponent(String(versionRaw))}`);
+  }
+  if (deviceInfo && typeof deviceInfo.getModel === "function") {
+    try {
+      const model = deviceInfo.getModel();
+      if (model) parts.push(`device=${encodeURIComponent(model)}`);
+    } catch {
     }
-    return null;
-  } catch {
-    return null;
   }
+  return parts.join("; ");
+}
+function detectAppState() {
+  const candidate = import_react_native.AppState;
+  if (candidate && typeof candidate.addEventListener === "function") {
+    return candidate;
+  }
+  return null;
 }
 function validateEndpoint(raw) {
   let url;
@@ -369,6 +474,7 @@ function init(opts) {
     screen: c.screen.bind(c),
     track: c.track.bind(c),
     identify: c.identify.bind(c),
+    captureError: c.captureError.bind(c),
     flush: c.flush.bind(c),
     close: c.close.bind(c),
     getSessionId: c.getSessionId.bind(c),

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { L as LuminClient, I as InitOptions } from './types-BeHbtR1J.cjs';
-export { A as AppStateLike, a as AsyncStorageLike, E as EventType, W as WireEvent } from './types-BeHbtR1J.cjs';
+import { L as LuminClient, I as InitOptions } from './types-B6rqS9Vp.cjs';
+export { A as AppStateLike, a as AsyncStorageLike, D as DeviceInfoLike, E as ErrorUtilsLike, b as EventType, W as WireEvent } from './types-B6rqS9Vp.cjs';
 
 declare class Client implements LuminClient {
     private readonly endpoint;
@@ -11,6 +11,11 @@ declare class Client implements LuminClient {
     private readonly fetchImpl;
     private readonly storage;
     private readonly appState;
+    private readonly errorUtils;
+    private readonly clientHeader;
+    private prevErrorHandler;
+    private errorHandlerInstalled;
+    private readonly recentErrors;
     private userId;
     private idsReady;
     private cachedIds;
@@ -23,6 +28,7 @@ declare class Client implements LuminClient {
     constructor(opts: InitOptions);
     screen(name?: string, properties?: Record<string, unknown>): void;
     track(name: string, properties?: Record<string, unknown>): void;
+    captureError(err: unknown, properties?: Record<string, unknown>): void;
     identify(userId: string, traits?: Record<string, unknown>): void;
     /**
      * Drain the buffer to the server. Returns when the in-flight request
@@ -59,6 +65,14 @@ declare class Client implements LuminClient {
      */
     private installBackgroundFlush;
     private removeBackgroundFlush;
+    /**
+     * Install a global JS error handler via ErrorUtils.setGlobalHandler that
+     * captures + chains to whatever handler was already in place. RN's
+     * red-box and any other observability tool that installed before us
+     * still fires — we do not swallow the throw.
+     */
+    private installErrorHandler;
+    private restoreErrorHandler;
 }
 
 /**

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { L as LuminClient, I as InitOptions } from './types-BeHbtR1J.js';
-export { A as AppStateLike, a as AsyncStorageLike, E as EventType, W as WireEvent } from './types-BeHbtR1J.js';
+import { L as LuminClient, I as InitOptions } from './types-B6rqS9Vp.js';
+export { A as AppStateLike, a as AsyncStorageLike, D as DeviceInfoLike, E as ErrorUtilsLike, b as EventType, W as WireEvent } from './types-B6rqS9Vp.js';
 
 declare class Client implements LuminClient {
     private readonly endpoint;
@@ -11,6 +11,11 @@ declare class Client implements LuminClient {
     private readonly fetchImpl;
     private readonly storage;
     private readonly appState;
+    private readonly errorUtils;
+    private readonly clientHeader;
+    private prevErrorHandler;
+    private errorHandlerInstalled;
+    private readonly recentErrors;
     private userId;
     private idsReady;
     private cachedIds;
@@ -23,6 +28,7 @@ declare class Client implements LuminClient {
     constructor(opts: InitOptions);
     screen(name?: string, properties?: Record<string, unknown>): void;
     track(name: string, properties?: Record<string, unknown>): void;
+    captureError(err: unknown, properties?: Record<string, unknown>): void;
     identify(userId: string, traits?: Record<string, unknown>): void;
     /**
      * Drain the buffer to the server. Returns when the in-flight request
@@ -59,6 +65,14 @@ declare class Client implements LuminClient {
      */
     private installBackgroundFlush;
     private removeBackgroundFlush;
+    /**
+     * Install a global JS error handler via ErrorUtils.setGlobalHandler that
+     * captures + chains to whatever handler was already in place. RN's
+     * red-box and any other observability tool that installed before us
+     * still fires — we do not swallow the throw.
+     */
+    private installErrorHandler;
+    private restoreErrorHandler;
 }
 
 /**