@flareapp/react-native 2.6.0

package/README.md

@@ -0,0 +1,60 @@
+# @flareapp/react-native
+
+React Native SDK for [Flare](https://flareapp.io) error tracking by Spatie.
+
+Pure JavaScript — works on both Expo (managed) and bare React Native with no
+required native module.
+
+## Requirements
+
+React Native **0.79+** (Expo SDK 53+). The package relies on Metro's package
+exports support, which is on by default from RN 0.79. It ships a Metro-targeted
+CJS build via the `"react-native"` export condition, and the `FlareErrorBoundary`
+imports `@flareapp/react/inject` (an export-map subpath) — both need package
+exports enabled.
+
+## Install
+
+```bash
+npm install @flareapp/react-native @flareapp/react
+```
+
+## Usage
+
+```ts
+import { flare, FlareErrorBoundary } from '@flareapp/react-native';
+
+flare.light('your-project-key');
+flare.setUser({ id: 1, email: 'user@example.com' });
+```
+
+Wrap your app in the boundary to capture React render errors:
+
+```tsx
+<FlareErrorBoundary>
+    <App />
+</FlareErrorBoundary>
+```
+
+## What it captures
+
+- Uncaught JS errors (via `ErrorUtils`)
+- React render errors (via `FlareErrorBoundary`)
+- Unhandled promise rejections (best-effort; uses the active JS engine's hook —
+  Hermes or JSC)
+
+Device/app context is collected from React Native core, enriched with
+`expo-device` / `expo-application` when present. Note: on iOS, Expo's `app.id`
+(Android package name) is not available as a sync constant, so that attribute is
+Android-only.
+
+Delivery is best-effort. Reports are sent with `fetch`, which React Native does
+not back with `keepalive`, so a report fired during a fatal JS crash (or while
+the app is being backgrounded/suspended) may not finish sending. This applies to
+JS-fatal errors too, not only native crashes.
+
+## Not yet included
+
+- Native crash capture (requires a native module)
+- Metro sourcemap upload (planned as a separate package)
+- Automatic breadcrumbs (use `flare.glow(...)` manually for now)

package/dist/index.cjs

@@ -0,0 +1,484 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _flareapp_core = require("@flareapp/core");
+let react_native = require("react-native");
+let _flareapp_react_inject = require("@flareapp/react/inject");
+let react = require("react");
+
+//#region src/context/expo.ts
+/**
+* Lazy, synchronous Expo load. The `require(...)` calls are DIRECT string
+* literals on purpose: Metro statically collects only literal `require('pkg')`
+* calls and treats those inside a try/catch as OPTIONAL dependencies
+* (`allowOptionalDependencies` is on by default for the React Native CLI and
+* Expo), so a missing package degrades to a caught runtime throw instead of a
+* build error. Aliasing `require` to a local (`const req = require; req('pkg')`)
+* would defeat that static collection — Metro never adds the module to this
+* file's dependency map, so the require would fail to resolve even when the
+* package IS installed. So do NOT reintroduce an alias here.
+*
+* The `typeof require` guard keeps non-Metro/ESM environments (e.g. some test
+* runners, where `require` is undefined) safe; under Metro `require` always
+* exists in the `react-native`/CJS build this package ships.
+*/
+function loadExpoModules() {
+	const mods = {};
+	if (typeof require === "undefined") return mods;
+	try {
+		mods.device = require("expo-device");
+	} catch {}
+	try {
+		mods.application = require("expo-application");
+	} catch {}
+	return mods;
+}
+const DEVICE_TYPE_LABELS = {
+	1: "phone",
+	2: "tablet",
+	3: "desktop",
+	4: "tv"
+};
+/**
+* Project the synchronous Expo constants into report attributes. Only the
+* fields that are present (non-null, non-undefined) are emitted. Async Expo
+* getters are intentionally not used (the context collector is synchronous).
+*/
+function projectExpoContext(expo) {
+	const attrs = {};
+	const device = expo.device;
+	if (device) {
+		if (device.modelName != null) attrs["device.model.name"] = device.modelName;
+		if (device.osName != null) attrs["os.name"] = device.osName;
+		if (device.osVersion != null) attrs["os.version"] = device.osVersion;
+		if (device.deviceType != null) {
+			const label = DEVICE_TYPE_LABELS[device.deviceType];
+			if (label) attrs["device.type"] = label;
+		}
+	}
+	const application = expo.application;
+	if (application) {
+		if (application.nativeApplicationVersion != null) attrs["app.version"] = application.nativeApplicationVersion;
+		if (application.applicationId != null) attrs["app.id"] = application.applicationId;
+	}
+	return attrs;
+}
+
+//#endregion
+//#region src/context/collectReactNative.ts
+/**
+* Build the React Native `ContextCollector` that core's `Flare` calls on every
+* report. Synchronous, matching `ContextCollector = (config) => Attributes`.
+*
+* Sources, layered:
+* 1. RN core (`Platform`, `Dimensions`) — read on every call.
+* 2. Expo constants — resolved once (injected for tests, else `loadExpoModules()`)
+*    and projected; absent on bare RN.
+*
+* The authenticated user is NOT projected here: `Flare.setUser` (inherited from
+* core) writes the `user.*` identity keys straight to the active scope, the same
+* model node and electron use.
+*
+* `Platform.Version` is a string on iOS but a number on Android, so it is
+* stringified for the `os.version` attribute. `Platform.OS` maps to `os.name`
+* (NOT `os.type`, which conventionally means the kernel family); when Expo is
+* present its `osName`/`osVersion` overwrite these coarser values.
+*/
+function makeReactNativeContextCollector(expo = loadExpoModules()) {
+	const expoAttrs = projectExpoContext(expo);
+	return (_config) => {
+		const screen = react_native.Dimensions.get("window");
+		const attrs = {
+			"os.name": react_native.Platform.OS,
+			"os.version": String(react_native.Platform.Version),
+			"device.screen.width": screen.width,
+			"device.screen.height": screen.height,
+			"device.screen.scale": screen.scale,
+			...expoAttrs
+		};
+		if (attrs["device.model.name"] == null) {
+			const model = nativeModelName();
+			if (model) attrs["device.model.name"] = model;
+		}
+		const device = buildDeviceContext(attrs);
+		if (Object.keys(device).length > 0) attrs["context.device"] = device;
+		return attrs;
+	};
+}
+/**
+* Native device model from `Platform.constants`. Android exposes
+* `Model`/`Manufacturer`/`Brand`; iOS core does not surface a device model (it
+* needs `expo-device` or a native module), so iOS returns undefined. Prefixes the
+* model with its maker when available (e.g. `Google Pixel 7`).
+*/
+function nativeModelName() {
+	if (react_native.Platform.OS !== "android") return void 0;
+	const constants = react_native.Platform.constants;
+	if (!constants?.Model) return void 0;
+	const maker = constants.Manufacturer ?? constants.Brand;
+	return maker ? `${maker} ${constants.Model}` : constants.Model;
+}
+/**
+* Build a human-readable `context.device` group from the collected semantic
+* attributes. Only present fields are included, so the bare app (no Expo)
+* naturally omits `model` / `appVersion` / `appId`.
+*/
+function buildDeviceContext(attrs) {
+	const device = {};
+	if (attrs["device.model.name"] != null) device.model = attrs["device.model.name"];
+	const os = [attrs["os.name"], attrs["os.version"]].filter((v) => v != null).join(" ");
+	if (os) device.OS = os;
+	const width = attrs["device.screen.width"];
+	const height = attrs["device.screen.height"];
+	const scale = attrs["device.screen.scale"];
+	if (width != null && height != null) device.screen = scale != null ? `${width} × ${height} @ ${scale}x` : `${width} × ${height}`;
+	if (attrs["app.version"] != null) device.appVersion = attrs["app.version"];
+	if (attrs["app.id"] != null) device.appId = attrs["app.id"];
+	return device;
+}
+
+//#endregion
+//#region src/handlers/appStateFlush.ts
+/**
+* Flush the log buffer when the app moves to the background. iOS fires
+* `inactive` on every transient interruption (app-switcher peek, Control Center,
+* incoming call), so we gate on `background` ONLY to avoid flooding the network
+* with redundant flushes. This mirrors the browser scheduler gating on `hidden`
+* (not every blur).
+*
+* Delivery is best-effort: see `ReactNativeFlushScheduler`.
+*
+* Returns an uninstaller that removes the listener via the subscription handle
+* (modern RN API — do NOT use the removed `AppState.removeEventListener`).
+*/
+function installAppStateFlush(getFlush) {
+	const subscription = react_native.AppState.addEventListener("change", (state) => {
+		if (state === "background") getFlush()?.();
+	});
+	return () => subscription.remove();
+}
+
+//#endregion
+//#region src/devMode.ts
+/** True only in a React Native dev bundle. Safe (false) everywhere else. */
+function inDevMode() {
+	return typeof __DEV__ !== "undefined" && __DEV__ === true;
+}
+
+//#endregion
+//#region src/handlers/globalErrorHandler.ts
+function getErrorUtils() {
+	return globalThis.ErrorUtils;
+}
+/**
+* Wrap RN's `ErrorUtils` global handler. The wrapper reports the error and then
+* delegates to the previously-registered handler, so React Native's own behavior
+* (red box in dev, process crash in prod) is preserved — we observe, we do not
+* swallow. No-op when `ErrorUtils` is unavailable.
+*
+* Fatal delivery (`onFatal`). On a FATAL error in a PRODUCTION bundle the
+* previous handler is what tears the app down, and our report is an async
+* `fetch` the OS would kill the instant the app dies — so a bare report almost
+* never sends. When `onFatal` is supplied we DEFER the previous handler until
+* `onFatal()` settles; it drains the transport via core's `flush(timeoutMs)`,
+* buying the report time to send before the crash. RN does not crash on its own
+* (the default handler triggers it), so deferring the delegate genuinely delays
+* the crash. This mirrors Sentry's React Native SDK. It is skipped in `__DEV__`
+* (don't fight the red box / debugger) and guarded by a re-entrancy latch, so a
+* second fatal arriving mid-flush delegates immediately rather than racing two
+* shutdowns.
+*
+* Returns an uninstaller that restores the previous handler.
+*/
+function installGlobalErrorHandler(report, onFatal) {
+	const errorUtils = getErrorUtils();
+	if (!errorUtils) return () => {};
+	const previous = errorUtils.getGlobalHandler();
+	let handlingFatal = false;
+	const handler = (error, isFatal) => {
+		try {
+			report((0, _flareapp_core.convertToError)(error), Boolean(isFatal));
+		} catch {}
+		if (isFatal && onFatal && !inDevMode() && !handlingFatal) {
+			handlingFatal = true;
+			onFatal().catch(() => {}).then(() => {
+				try {
+					previous?.(error, isFatal);
+				} finally {
+					handlingFatal = false;
+				}
+			});
+			return;
+		}
+		previous?.(error, isFatal);
+	};
+	errorUtils.setGlobalHandler(handler);
+	return () => {
+		errorUtils.setGlobalHandler(previous ?? (() => {}));
+	};
+}
+
+//#endregion
+//#region src/handlers/rejectionTracking.ts
+/**
+* Resolve the promise-rejection enabler for the ACTIVE JS engine.
+*
+* - Hermes (RN's default engine since 0.70) tracks rejections on its native
+*   Promise via `global.HermesInternal.enablePromiseRejectionTracker`. The
+*   `promise` npm polyfill is NOT the runtime Promise on Hermes, so the
+*   polyfill's `rejection-tracking.enable()` would hook unused objects and
+*   silently never fire — we must use the Hermes hook here.
+* - JSC / non-Hermes: RN polyfills `global.Promise` with the `promise` package,
+*   so `promise/setimmediate/rejection-tracking.enable()` is the real hook.
+*
+* Returns null when neither is reachable. Exported (with injectable deps) for
+* direct unit testing of the ordering; not re-exported from the package entry.
+*/
+function resolveRejectionEnabler(deps = {}) {
+	const hermes = deps.hermes !== void 0 ? deps.hermes : globalThis.HermesInternal;
+	if (hermes && typeof hermes.enablePromiseRejectionTracker === "function") return (options) => hermes.enablePromiseRejectionTracker(options);
+	const req = deps.requirePolyfill !== void 0 ? deps.requirePolyfill : typeof require !== "undefined" ? require : null;
+	if (req) try {
+		const tracker = req("promise/setimmediate/rejection-tracking");
+		if (tracker && typeof tracker.enable === "function") return (options) => tracker.enable(options);
+	} catch {}
+	return null;
+}
+/**
+* Best-effort capture of unhandled promise rejections, engine-aware. RN routes
+* these through its engine's tracker (NOT `window.onunhandledrejection`):
+* `HermesInternal.enablePromiseRejectionTracker` on Hermes, the `promise`
+* polyfill on JSC. Reasons are routed exactly like the browser
+* `unhandledrejection` handler (core's `routeRejection`), so Error reasons keep
+* their stack via `reportSilently`.
+*
+* Engine-dependent, NOT version-dependent: if no engine hook is reachable this
+* is a no-op (uncaught throws via ErrorUtils still work) and emits a dev-only
+* debug line; it must never crash. The `enable(...)` invocation is wrapped so a
+* throwing engine hook degrades to no-op instead of propagating.
+*
+* Chaining caveat: enabling REPLACES the engine's current callbacks (RN
+* registers its own dev warning) and neither engine exposes a getter for the
+* previous ones, so we cannot truly chain RN's default. To avoid swallowing that
+* developer signal, `onUnhandled` re-emits a `console.warn` in dev (`__DEV__`).
+*
+* Returns an uninstaller that re-enables with no-op callbacks (no clean disable
+* exists on either engine).
+*/
+function installRejectionTracking(reporter, deps = {}) {
+	const enable = deps.enable !== void 0 ? deps.enable : resolveRejectionEnabler();
+	if (!enable) {
+		if (inDevMode()) console.debug("[flare] No promise-rejection hook for this JS engine; rejections not captured.");
+		return () => {};
+	}
+	try {
+		enable({
+			allRejections: true,
+			onUnhandled: (_id, error) => {
+				if (inDevMode()) console.warn("[flare] Unhandled promise rejection:", error);
+				(0, _flareapp_core.routeRejection)(reporter, error);
+			},
+			onHandled: () => {}
+		});
+	} catch {
+		if (inDevMode()) console.debug("[flare] Promise-rejection hook threw on enable; rejections not captured.");
+		return () => {};
+	}
+	return () => {
+		try {
+			enable({
+				allRejections: true,
+				onUnhandled: () => {},
+				onHandled: () => {}
+			});
+		} catch {}
+	};
+}
+
+//#endregion
+//#region src/ReactNativeFlushScheduler.ts
+/**
+* Passive flush scheduler for React Native. Core's `Logger` calls `register`
+* once during construction; this stores the flush callback and exposes a plain,
+* argument-less caller via `getFlush()`. The actual trigger (AppState ->
+* background) is wired separately in `Flare.install()` so it stays symmetric
+* with handler teardown.
+*
+* Deliberately calls `flush()` WITHOUT `{ keepalive: true }`: RN's fetch (over
+* XMLHttpRequest) does not reliably honor keepalive, so a backgrounding flush is
+* best-effort and may be dropped if the OS suspends the app mid-request.
+*/
+var ReactNativeFlushScheduler = class {
+	flushFn = null;
+	register(flush) {
+		this.flushFn = flush;
+	}
+	getFlush() {
+		const flush = this.flushFn;
+		if (!flush) return void 0;
+		return () => {
+			flush();
+		};
+	}
+};
+
+//#endregion
+//#region src/Flare.ts
+const RN_SDK_NAME = "@flareapp/react-native";
+const RN_SDK_VERSION = "2.6.0";
+const RN_FRAMEWORK_NAME = "React Native";
+const FATAL_FLUSH_TIMEOUT_MS = 2e3;
+/**
+* React Native `Flare` singleton (exposed as `flare` from the package root).
+*
+* Subclasses core's `Flare`, injecting the RN seams:
+* - core `Api` (fetch is native in RN),
+* - `makeReactNativeContextCollector(() => this.user)` for device/app/user attrs,
+* - core `NullFileReader` (no runtime source snippets; sourcemaps are a Metro
+*   follow-up),
+* - core `GlobalScopeProvider` (RN is a single app scope),
+* - `ReactNativeFlushScheduler` (flush on background, best-effort).
+*
+* Adds RN-only surface: `removeHandlers` and an idempotent handler install folded
+* into `light()`. `setUser` is inherited from core, which writes the backend-read
+* `user.*` identity keys to the active scope (RN uses the single global scope).
+*/
+var ReactNativeFlare = class extends _flareapp_core.Flare {
+	scheduler;
+	rejectionDeps;
+	installed = false;
+	uninstallers = [];
+	/**
+	* @param rejectionDeps test seam for the rejection hook. Defaults to `{}`
+	*        (resolve the active engine's tracker — Hermes or JSC). Tests pass
+	*        `{ enable: null }` so `light()` does NOT enable a global rejection
+	*        tracker as a leaking side effect.
+	*/
+	constructor(rejectionDeps = {}) {
+		const scheduler = new ReactNativeFlushScheduler();
+		const collector = makeReactNativeContextCollector();
+		super(new _flareapp_core.Api(), collector, new _flareapp_core.NullFileReader(), new _flareapp_core.GlobalScopeProvider(), scheduler);
+		this.scheduler = scheduler;
+		this.rejectionDeps = rejectionDeps;
+		this.setSdkInfo({
+			name: RN_SDK_NAME,
+			version: RN_SDK_VERSION
+		});
+		this.setFramework({ name: RN_FRAMEWORK_NAME });
+	}
+	/**
+	* Force the framework identity to "React Native". The wrapped
+	* `@flareapp/react` boundary tags every flare it injects as `React` (via
+	* `tagReactFramework`), which is wrong on the RN singleton — so coerce the
+	* name here while preserving whatever version the caller supplied (the React
+	* renderer version when the boundary tags it).
+	*/
+	setFramework(framework) {
+		return super.setFramework({
+			...framework,
+			name: RN_FRAMEWORK_NAME
+		});
+	}
+	/**
+	* Set the API key (and optional debug flag), then install the global
+	* handlers. The install is idempotent — calling `light()` twice does NOT
+	* double-wrap `ErrorUtils` (which, unlike node's reconcile, is not naturally
+	* idempotent).
+	*/
+	light(key, debug) {
+		super.light(key, debug);
+		this.install();
+		return this;
+	}
+	/**
+	* Detach the global error handler, rejection tracker, and AppState listener,
+	* and clear the install guard so a later `light()` re-installs. For tests
+	* and manual teardown (mirrors node's `removeProcessListeners`).
+	*/
+	removeHandlers() {
+		for (const uninstall of this.uninstallers) try {
+			uninstall();
+		} catch {}
+		this.uninstallers = [];
+		this.installed = false;
+	}
+	install() {
+		if (this.installed) return;
+		this.installed = true;
+		this.uninstallers.push(installGlobalErrorHandler((error, isFatal) => {
+			this.reportSilently(error, { "error.fatal": isFatal });
+		}, () => this.flush(FATAL_FLUSH_TIMEOUT_MS)), installRejectionTracking({
+			reportSilently: (error) => this.reportSilently(error),
+			reportUnhandledRejection: (message) => this.reportUnhandledRejection(message)
+		}, this.rejectionDeps), installAppStateFlush(() => this.scheduler.getFlush()));
+	}
+};
+
+//#endregion
+//#region src/singleton.ts
+const flare = new ReactNativeFlare();
+
+//#endregion
+//#region src/FlareErrorBoundary.ts
+/**
+* React Native error boundary. A thin wrapper over `@flareapp/react`'s
+* `/inject` boundary that injects the RN `flare` singleton.
+*
+* `flare` is applied AFTER `{...props}` so a consumer cannot override the
+* singleton. The `as unknown as Flare` cast is required: the boundary prop is
+* typed against `@flareapp/js/browser`'s `Flare` (a superset of
+* `ReactNativeFlare`), so structural assignment does not hold. Safe at runtime —
+* the boundary only calls a core-level method (`reportSilently`), which
+* `ReactNativeFlare` inherits.
+*/
+function FlareErrorBoundary(props) {
+	return (0, react.createElement)(_flareapp_react_inject.FlareErrorBoundary, {
+		...props,
+		flare
+	});
+}
+
+//#endregion
+Object.defineProperty(exports, 'DEFAULT_URL_DENYLIST', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.DEFAULT_URL_DENYLIST;
+  }
+});
+Object.defineProperty(exports, 'Flare', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.Flare;
+  }
+});
+exports.FlareErrorBoundary = FlareErrorBoundary;
+Object.defineProperty(exports, 'GlobalScopeProvider', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.GlobalScopeProvider;
+  }
+});
+Object.defineProperty(exports, 'NullFileReader', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.NullFileReader;
+  }
+});
+exports.ReactNativeFlare = ReactNativeFlare;
+Object.defineProperty(exports, 'convertToError', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.convertToError;
+  }
+});
+exports.flare = flare;
+Object.defineProperty(exports, 'redactUrlQuery', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.redactUrlQuery;
+  }
+});
+Object.defineProperty(exports, 'resolveDenylist', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.resolveDenylist;
+  }
+});

package/dist/index.d.cts

@@ -0,0 +1,85 @@
+import { AttributeValue, Attributes, Config, ContextCollector, DEFAULT_URL_DENYLIST, FileReader, Flare, Flare as Flare$1, FlushFn, FlushScheduler, Framework, Framework as Framework$1, GlobalScopeProvider, Glow, MessageLevel, NullFileReader, Report, ScopeProvider, SdkInfo, StackFrame, User, convertToError, redactUrlQuery, resolveDenylist } from "@flareapp/core";
+import { FlareErrorBoundaryProps } from "@flareapp/react/inject";
+import { ReactElement } from "react";
+
+//#region src/handlers/rejectionTracking.d.ts
+type EnableOptions = {
+  allRejections?: boolean;
+  onUnhandled?: (id: number, error: unknown) => void;
+  onHandled?: (id: number) => void;
+};
+type RejectionEnabler = (options: EnableOptions) => void;
+type RejectionDeps = {
+  enable?: RejectionEnabler | null;
+};
+//#endregion
+//#region src/Flare.d.ts
+/**
+ * React Native `Flare` singleton (exposed as `flare` from the package root).
+ *
+ * Subclasses core's `Flare`, injecting the RN seams:
+ * - core `Api` (fetch is native in RN),
+ * - `makeReactNativeContextCollector(() => this.user)` for device/app/user attrs,
+ * - core `NullFileReader` (no runtime source snippets; sourcemaps are a Metro
+ *   follow-up),
+ * - core `GlobalScopeProvider` (RN is a single app scope),
+ * - `ReactNativeFlushScheduler` (flush on background, best-effort).
+ *
+ * Adds RN-only surface: `removeHandlers` and an idempotent handler install folded
+ * into `light()`. `setUser` is inherited from core, which writes the backend-read
+ * `user.*` identity keys to the active scope (RN uses the single global scope).
+ */
+declare class ReactNativeFlare extends Flare$1 {
+  private readonly scheduler;
+  private readonly rejectionDeps;
+  private installed;
+  private uninstallers;
+  /**
+   * @param rejectionDeps test seam for the rejection hook. Defaults to `{}`
+   *        (resolve the active engine's tracker — Hermes or JSC). Tests pass
+   *        `{ enable: null }` so `light()` does NOT enable a global rejection
+   *        tracker as a leaking side effect.
+   */
+  constructor(rejectionDeps?: RejectionDeps);
+  /**
+   * Force the framework identity to "React Native". The wrapped
+   * `@flareapp/react` boundary tags every flare it injects as `React` (via
+   * `tagReactFramework`), which is wrong on the RN singleton — so coerce the
+   * name here while preserving whatever version the caller supplied (the React
+   * renderer version when the boundary tags it).
+   */
+  setFramework(framework: Framework$1): this;
+  /**
+   * Set the API key (and optional debug flag), then install the global
+   * handlers. The install is idempotent — calling `light()` twice does NOT
+   * double-wrap `ErrorUtils` (which, unlike node's reconcile, is not naturally
+   * idempotent).
+   */
+  light(key?: string, debug?: boolean): this;
+  /**
+   * Detach the global error handler, rejection tracker, and AppState listener,
+   * and clear the install guard so a later `light()` re-installs. For tests
+   * and manual teardown (mirrors node's `removeProcessListeners`).
+   */
+  removeHandlers(): void;
+  private install;
+}
+//#endregion
+//#region src/singleton.d.ts
+declare const flare: ReactNativeFlare;
+//#endregion
+//#region src/FlareErrorBoundary.d.ts
+/**
+ * React Native error boundary. A thin wrapper over `@flareapp/react`'s
+ * `/inject` boundary that injects the RN `flare` singleton.
+ *
+ * `flare` is applied AFTER `{...props}` so a consumer cannot override the
+ * singleton. The `as unknown as Flare` cast is required: the boundary prop is
+ * typed against `@flareapp/js/browser`'s `Flare` (a superset of
+ * `ReactNativeFlare`), so structural assignment does not hold. Safe at runtime —
+ * the boundary only calls a core-level method (`reportSilently`), which
+ * `ReactNativeFlare` inherits.
+ */
+declare function FlareErrorBoundary(props: Omit<FlareErrorBoundaryProps, 'flare'>): ReactElement;
+//#endregion
+export { type AttributeValue, type Attributes, type Config, type ContextCollector, DEFAULT_URL_DENYLIST, type FileReader, Flare, FlareErrorBoundary, type FlushFn, type FlushScheduler, type Framework, GlobalScopeProvider, type Glow, type MessageLevel, NullFileReader, ReactNativeFlare, type Report, type ScopeProvider, type SdkInfo, type StackFrame, type User, convertToError, flare, redactUrlQuery, resolveDenylist };

package/dist/index.d.mts

@@ -0,0 +1,85 @@
+import { AttributeValue, Attributes, Config, ContextCollector, DEFAULT_URL_DENYLIST, FileReader, Flare, Flare as Flare$1, FlushFn, FlushScheduler, Framework, Framework as Framework$1, GlobalScopeProvider, Glow, MessageLevel, NullFileReader, Report, ScopeProvider, SdkInfo, StackFrame, User, convertToError, redactUrlQuery, resolveDenylist } from "@flareapp/core";
+import { FlareErrorBoundaryProps } from "@flareapp/react/inject";
+import { ReactElement } from "react";
+
+//#region src/handlers/rejectionTracking.d.ts
+type EnableOptions = {
+  allRejections?: boolean;
+  onUnhandled?: (id: number, error: unknown) => void;
+  onHandled?: (id: number) => void;
+};
+type RejectionEnabler = (options: EnableOptions) => void;
+type RejectionDeps = {
+  enable?: RejectionEnabler | null;
+};
+//#endregion
+//#region src/Flare.d.ts
+/**
+ * React Native `Flare` singleton (exposed as `flare` from the package root).
+ *
+ * Subclasses core's `Flare`, injecting the RN seams:
+ * - core `Api` (fetch is native in RN),
+ * - `makeReactNativeContextCollector(() => this.user)` for device/app/user attrs,
+ * - core `NullFileReader` (no runtime source snippets; sourcemaps are a Metro
+ *   follow-up),
+ * - core `GlobalScopeProvider` (RN is a single app scope),
+ * - `ReactNativeFlushScheduler` (flush on background, best-effort).
+ *
+ * Adds RN-only surface: `removeHandlers` and an idempotent handler install folded
+ * into `light()`. `setUser` is inherited from core, which writes the backend-read
+ * `user.*` identity keys to the active scope (RN uses the single global scope).
+ */
+declare class ReactNativeFlare extends Flare$1 {
+  private readonly scheduler;
+  private readonly rejectionDeps;
+  private installed;
+  private uninstallers;
+  /**
+   * @param rejectionDeps test seam for the rejection hook. Defaults to `{}`
+   *        (resolve the active engine's tracker — Hermes or JSC). Tests pass
+   *        `{ enable: null }` so `light()` does NOT enable a global rejection
+   *        tracker as a leaking side effect.
+   */
+  constructor(rejectionDeps?: RejectionDeps);
+  /**
+   * Force the framework identity to "React Native". The wrapped
+   * `@flareapp/react` boundary tags every flare it injects as `React` (via
+   * `tagReactFramework`), which is wrong on the RN singleton — so coerce the
+   * name here while preserving whatever version the caller supplied (the React
+   * renderer version when the boundary tags it).
+   */
+  setFramework(framework: Framework$1): this;
+  /**
+   * Set the API key (and optional debug flag), then install the global
+   * handlers. The install is idempotent — calling `light()` twice does NOT
+   * double-wrap `ErrorUtils` (which, unlike node's reconcile, is not naturally
+   * idempotent).
+   */
+  light(key?: string, debug?: boolean): this;
+  /**
+   * Detach the global error handler, rejection tracker, and AppState listener,
+   * and clear the install guard so a later `light()` re-installs. For tests
+   * and manual teardown (mirrors node's `removeProcessListeners`).
+   */
+  removeHandlers(): void;
+  private install;
+}
+//#endregion
+//#region src/singleton.d.ts
+declare const flare: ReactNativeFlare;
+//#endregion
+//#region src/FlareErrorBoundary.d.ts
+/**
+ * React Native error boundary. A thin wrapper over `@flareapp/react`'s
+ * `/inject` boundary that injects the RN `flare` singleton.
+ *
+ * `flare` is applied AFTER `{...props}` so a consumer cannot override the
+ * singleton. The `as unknown as Flare` cast is required: the boundary prop is
+ * typed against `@flareapp/js/browser`'s `Flare` (a superset of
+ * `ReactNativeFlare`), so structural assignment does not hold. Safe at runtime —
+ * the boundary only calls a core-level method (`reportSilently`), which
+ * `ReactNativeFlare` inherits.
+ */
+declare function FlareErrorBoundary(props: Omit<FlareErrorBoundaryProps, 'flare'>): ReactElement;
+//#endregion
+export { type AttributeValue, type Attributes, type Config, type ContextCollector, DEFAULT_URL_DENYLIST, type FileReader, Flare, FlareErrorBoundary, type FlushFn, type FlushScheduler, type Framework, GlobalScopeProvider, type Glow, type MessageLevel, NullFileReader, ReactNativeFlare, type Report, type ScopeProvider, type SdkInfo, type StackFrame, type User, convertToError, flare, redactUrlQuery, resolveDenylist };

package/dist/index.mjs

@@ -0,0 +1,444 @@
+import { createRequire } from "node:module";
+import { Api, DEFAULT_URL_DENYLIST, Flare, Flare as Flare$1, GlobalScopeProvider, GlobalScopeProvider as GlobalScopeProvider$1, NullFileReader, NullFileReader as NullFileReader$1, convertToError, convertToError as convertToError$1, redactUrlQuery, resolveDenylist, routeRejection } from "@flareapp/core";
+import { AppState, Dimensions, Platform } from "react-native";
+import { FlareErrorBoundary as FlareErrorBoundary$1 } from "@flareapp/react/inject";
+import { createElement } from "react";
+
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/context/expo.ts
+/**
+* Lazy, synchronous Expo load. The `require(...)` calls are DIRECT string
+* literals on purpose: Metro statically collects only literal `require('pkg')`
+* calls and treats those inside a try/catch as OPTIONAL dependencies
+* (`allowOptionalDependencies` is on by default for the React Native CLI and
+* Expo), so a missing package degrades to a caught runtime throw instead of a
+* build error. Aliasing `require` to a local (`const req = require; req('pkg')`)
+* would defeat that static collection — Metro never adds the module to this
+* file's dependency map, so the require would fail to resolve even when the
+* package IS installed. So do NOT reintroduce an alias here.
+*
+* The `typeof require` guard keeps non-Metro/ESM environments (e.g. some test
+* runners, where `require` is undefined) safe; under Metro `require` always
+* exists in the `react-native`/CJS build this package ships.
+*/
+function loadExpoModules() {
+	const mods = {};
+	if (typeof __require === "undefined") return mods;
+	try {
+		mods.device = __require("expo-device");
+	} catch {}
+	try {
+		mods.application = __require("expo-application");
+	} catch {}
+	return mods;
+}
+const DEVICE_TYPE_LABELS = {
+	1: "phone",
+	2: "tablet",
+	3: "desktop",
+	4: "tv"
+};
+/**
+* Project the synchronous Expo constants into report attributes. Only the
+* fields that are present (non-null, non-undefined) are emitted. Async Expo
+* getters are intentionally not used (the context collector is synchronous).
+*/
+function projectExpoContext(expo) {
+	const attrs = {};
+	const device = expo.device;
+	if (device) {
+		if (device.modelName != null) attrs["device.model.name"] = device.modelName;
+		if (device.osName != null) attrs["os.name"] = device.osName;
+		if (device.osVersion != null) attrs["os.version"] = device.osVersion;
+		if (device.deviceType != null) {
+			const label = DEVICE_TYPE_LABELS[device.deviceType];
+			if (label) attrs["device.type"] = label;
+		}
+	}
+	const application = expo.application;
+	if (application) {
+		if (application.nativeApplicationVersion != null) attrs["app.version"] = application.nativeApplicationVersion;
+		if (application.applicationId != null) attrs["app.id"] = application.applicationId;
+	}
+	return attrs;
+}
+
+//#endregion
+//#region src/context/collectReactNative.ts
+/**
+* Build the React Native `ContextCollector` that core's `Flare` calls on every
+* report. Synchronous, matching `ContextCollector = (config) => Attributes`.
+*
+* Sources, layered:
+* 1. RN core (`Platform`, `Dimensions`) — read on every call.
+* 2. Expo constants — resolved once (injected for tests, else `loadExpoModules()`)
+*    and projected; absent on bare RN.
+*
+* The authenticated user is NOT projected here: `Flare.setUser` (inherited from
+* core) writes the `user.*` identity keys straight to the active scope, the same
+* model node and electron use.
+*
+* `Platform.Version` is a string on iOS but a number on Android, so it is
+* stringified for the `os.version` attribute. `Platform.OS` maps to `os.name`
+* (NOT `os.type`, which conventionally means the kernel family); when Expo is
+* present its `osName`/`osVersion` overwrite these coarser values.
+*/
+function makeReactNativeContextCollector(expo = loadExpoModules()) {
+	const expoAttrs = projectExpoContext(expo);
+	return (_config) => {
+		const screen = Dimensions.get("window");
+		const attrs = {
+			"os.name": Platform.OS,
+			"os.version": String(Platform.Version),
+			"device.screen.width": screen.width,
+			"device.screen.height": screen.height,
+			"device.screen.scale": screen.scale,
+			...expoAttrs
+		};
+		if (attrs["device.model.name"] == null) {
+			const model = nativeModelName();
+			if (model) attrs["device.model.name"] = model;
+		}
+		const device = buildDeviceContext(attrs);
+		if (Object.keys(device).length > 0) attrs["context.device"] = device;
+		return attrs;
+	};
+}
+/**
+* Native device model from `Platform.constants`. Android exposes
+* `Model`/`Manufacturer`/`Brand`; iOS core does not surface a device model (it
+* needs `expo-device` or a native module), so iOS returns undefined. Prefixes the
+* model with its maker when available (e.g. `Google Pixel 7`).
+*/
+function nativeModelName() {
+	if (Platform.OS !== "android") return void 0;
+	const constants = Platform.constants;
+	if (!constants?.Model) return void 0;
+	const maker = constants.Manufacturer ?? constants.Brand;
+	return maker ? `${maker} ${constants.Model}` : constants.Model;
+}
+/**
+* Build a human-readable `context.device` group from the collected semantic
+* attributes. Only present fields are included, so the bare app (no Expo)
+* naturally omits `model` / `appVersion` / `appId`.
+*/
+function buildDeviceContext(attrs) {
+	const device = {};
+	if (attrs["device.model.name"] != null) device.model = attrs["device.model.name"];
+	const os = [attrs["os.name"], attrs["os.version"]].filter((v) => v != null).join(" ");
+	if (os) device.OS = os;
+	const width = attrs["device.screen.width"];
+	const height = attrs["device.screen.height"];
+	const scale = attrs["device.screen.scale"];
+	if (width != null && height != null) device.screen = scale != null ? `${width} × ${height} @ ${scale}x` : `${width} × ${height}`;
+	if (attrs["app.version"] != null) device.appVersion = attrs["app.version"];
+	if (attrs["app.id"] != null) device.appId = attrs["app.id"];
+	return device;
+}
+
+//#endregion
+//#region src/handlers/appStateFlush.ts
+/**
+* Flush the log buffer when the app moves to the background. iOS fires
+* `inactive` on every transient interruption (app-switcher peek, Control Center,
+* incoming call), so we gate on `background` ONLY to avoid flooding the network
+* with redundant flushes. This mirrors the browser scheduler gating on `hidden`
+* (not every blur).
+*
+* Delivery is best-effort: see `ReactNativeFlushScheduler`.
+*
+* Returns an uninstaller that removes the listener via the subscription handle
+* (modern RN API — do NOT use the removed `AppState.removeEventListener`).
+*/
+function installAppStateFlush(getFlush) {
+	const subscription = AppState.addEventListener("change", (state) => {
+		if (state === "background") getFlush()?.();
+	});
+	return () => subscription.remove();
+}
+
+//#endregion
+//#region src/devMode.ts
+/** True only in a React Native dev bundle. Safe (false) everywhere else. */
+function inDevMode() {
+	return typeof __DEV__ !== "undefined" && __DEV__ === true;
+}
+
+//#endregion
+//#region src/handlers/globalErrorHandler.ts
+function getErrorUtils() {
+	return globalThis.ErrorUtils;
+}
+/**
+* Wrap RN's `ErrorUtils` global handler. The wrapper reports the error and then
+* delegates to the previously-registered handler, so React Native's own behavior
+* (red box in dev, process crash in prod) is preserved — we observe, we do not
+* swallow. No-op when `ErrorUtils` is unavailable.
+*
+* Fatal delivery (`onFatal`). On a FATAL error in a PRODUCTION bundle the
+* previous handler is what tears the app down, and our report is an async
+* `fetch` the OS would kill the instant the app dies — so a bare report almost
+* never sends. When `onFatal` is supplied we DEFER the previous handler until
+* `onFatal()` settles; it drains the transport via core's `flush(timeoutMs)`,
+* buying the report time to send before the crash. RN does not crash on its own
+* (the default handler triggers it), so deferring the delegate genuinely delays
+* the crash. This mirrors Sentry's React Native SDK. It is skipped in `__DEV__`
+* (don't fight the red box / debugger) and guarded by a re-entrancy latch, so a
+* second fatal arriving mid-flush delegates immediately rather than racing two
+* shutdowns.
+*
+* Returns an uninstaller that restores the previous handler.
+*/
+function installGlobalErrorHandler(report, onFatal) {
+	const errorUtils = getErrorUtils();
+	if (!errorUtils) return () => {};
+	const previous = errorUtils.getGlobalHandler();
+	let handlingFatal = false;
+	const handler = (error, isFatal) => {
+		try {
+			report(convertToError$1(error), Boolean(isFatal));
+		} catch {}
+		if (isFatal && onFatal && !inDevMode() && !handlingFatal) {
+			handlingFatal = true;
+			onFatal().catch(() => {}).then(() => {
+				try {
+					previous?.(error, isFatal);
+				} finally {
+					handlingFatal = false;
+				}
+			});
+			return;
+		}
+		previous?.(error, isFatal);
+	};
+	errorUtils.setGlobalHandler(handler);
+	return () => {
+		errorUtils.setGlobalHandler(previous ?? (() => {}));
+	};
+}
+
+//#endregion
+//#region src/handlers/rejectionTracking.ts
+/**
+* Resolve the promise-rejection enabler for the ACTIVE JS engine.
+*
+* - Hermes (RN's default engine since 0.70) tracks rejections on its native
+*   Promise via `global.HermesInternal.enablePromiseRejectionTracker`. The
+*   `promise` npm polyfill is NOT the runtime Promise on Hermes, so the
+*   polyfill's `rejection-tracking.enable()` would hook unused objects and
+*   silently never fire — we must use the Hermes hook here.
+* - JSC / non-Hermes: RN polyfills `global.Promise` with the `promise` package,
+*   so `promise/setimmediate/rejection-tracking.enable()` is the real hook.
+*
+* Returns null when neither is reachable. Exported (with injectable deps) for
+* direct unit testing of the ordering; not re-exported from the package entry.
+*/
+function resolveRejectionEnabler(deps = {}) {
+	const hermes = deps.hermes !== void 0 ? deps.hermes : globalThis.HermesInternal;
+	if (hermes && typeof hermes.enablePromiseRejectionTracker === "function") return (options) => hermes.enablePromiseRejectionTracker(options);
+	const req = deps.requirePolyfill !== void 0 ? deps.requirePolyfill : typeof __require !== "undefined" ? __require : null;
+	if (req) try {
+		const tracker = req("promise/setimmediate/rejection-tracking");
+		if (tracker && typeof tracker.enable === "function") return (options) => tracker.enable(options);
+	} catch {}
+	return null;
+}
+/**
+* Best-effort capture of unhandled promise rejections, engine-aware. RN routes
+* these through its engine's tracker (NOT `window.onunhandledrejection`):
+* `HermesInternal.enablePromiseRejectionTracker` on Hermes, the `promise`
+* polyfill on JSC. Reasons are routed exactly like the browser
+* `unhandledrejection` handler (core's `routeRejection`), so Error reasons keep
+* their stack via `reportSilently`.
+*
+* Engine-dependent, NOT version-dependent: if no engine hook is reachable this
+* is a no-op (uncaught throws via ErrorUtils still work) and emits a dev-only
+* debug line; it must never crash. The `enable(...)` invocation is wrapped so a
+* throwing engine hook degrades to no-op instead of propagating.
+*
+* Chaining caveat: enabling REPLACES the engine's current callbacks (RN
+* registers its own dev warning) and neither engine exposes a getter for the
+* previous ones, so we cannot truly chain RN's default. To avoid swallowing that
+* developer signal, `onUnhandled` re-emits a `console.warn` in dev (`__DEV__`).
+*
+* Returns an uninstaller that re-enables with no-op callbacks (no clean disable
+* exists on either engine).
+*/
+function installRejectionTracking(reporter, deps = {}) {
+	const enable = deps.enable !== void 0 ? deps.enable : resolveRejectionEnabler();
+	if (!enable) {
+		if (inDevMode()) console.debug("[flare] No promise-rejection hook for this JS engine; rejections not captured.");
+		return () => {};
+	}
+	try {
+		enable({
+			allRejections: true,
+			onUnhandled: (_id, error) => {
+				if (inDevMode()) console.warn("[flare] Unhandled promise rejection:", error);
+				routeRejection(reporter, error);
+			},
+			onHandled: () => {}
+		});
+	} catch {
+		if (inDevMode()) console.debug("[flare] Promise-rejection hook threw on enable; rejections not captured.");
+		return () => {};
+	}
+	return () => {
+		try {
+			enable({
+				allRejections: true,
+				onUnhandled: () => {},
+				onHandled: () => {}
+			});
+		} catch {}
+	};
+}
+
+//#endregion
+//#region src/ReactNativeFlushScheduler.ts
+/**
+* Passive flush scheduler for React Native. Core's `Logger` calls `register`
+* once during construction; this stores the flush callback and exposes a plain,
+* argument-less caller via `getFlush()`. The actual trigger (AppState ->
+* background) is wired separately in `Flare.install()` so it stays symmetric
+* with handler teardown.
+*
+* Deliberately calls `flush()` WITHOUT `{ keepalive: true }`: RN's fetch (over
+* XMLHttpRequest) does not reliably honor keepalive, so a backgrounding flush is
+* best-effort and may be dropped if the OS suspends the app mid-request.
+*/
+var ReactNativeFlushScheduler = class {
+	flushFn = null;
+	register(flush) {
+		this.flushFn = flush;
+	}
+	getFlush() {
+		const flush = this.flushFn;
+		if (!flush) return void 0;
+		return () => {
+			flush();
+		};
+	}
+};
+
+//#endregion
+//#region src/Flare.ts
+const RN_SDK_NAME = "@flareapp/react-native";
+const RN_SDK_VERSION = "2.6.0";
+const RN_FRAMEWORK_NAME = "React Native";
+const FATAL_FLUSH_TIMEOUT_MS = 2e3;
+/**
+* React Native `Flare` singleton (exposed as `flare` from the package root).
+*
+* Subclasses core's `Flare`, injecting the RN seams:
+* - core `Api` (fetch is native in RN),
+* - `makeReactNativeContextCollector(() => this.user)` for device/app/user attrs,
+* - core `NullFileReader` (no runtime source snippets; sourcemaps are a Metro
+*   follow-up),
+* - core `GlobalScopeProvider` (RN is a single app scope),
+* - `ReactNativeFlushScheduler` (flush on background, best-effort).
+*
+* Adds RN-only surface: `removeHandlers` and an idempotent handler install folded
+* into `light()`. `setUser` is inherited from core, which writes the backend-read
+* `user.*` identity keys to the active scope (RN uses the single global scope).
+*/
+var ReactNativeFlare = class extends Flare$1 {
+	scheduler;
+	rejectionDeps;
+	installed = false;
+	uninstallers = [];
+	/**
+	* @param rejectionDeps test seam for the rejection hook. Defaults to `{}`
+	*        (resolve the active engine's tracker — Hermes or JSC). Tests pass
+	*        `{ enable: null }` so `light()` does NOT enable a global rejection
+	*        tracker as a leaking side effect.
+	*/
+	constructor(rejectionDeps = {}) {
+		const scheduler = new ReactNativeFlushScheduler();
+		const collector = makeReactNativeContextCollector();
+		super(new Api(), collector, new NullFileReader$1(), new GlobalScopeProvider$1(), scheduler);
+		this.scheduler = scheduler;
+		this.rejectionDeps = rejectionDeps;
+		this.setSdkInfo({
+			name: RN_SDK_NAME,
+			version: RN_SDK_VERSION
+		});
+		this.setFramework({ name: RN_FRAMEWORK_NAME });
+	}
+	/**
+	* Force the framework identity to "React Native". The wrapped
+	* `@flareapp/react` boundary tags every flare it injects as `React` (via
+	* `tagReactFramework`), which is wrong on the RN singleton — so coerce the
+	* name here while preserving whatever version the caller supplied (the React
+	* renderer version when the boundary tags it).
+	*/
+	setFramework(framework) {
+		return super.setFramework({
+			...framework,
+			name: RN_FRAMEWORK_NAME
+		});
+	}
+	/**
+	* Set the API key (and optional debug flag), then install the global
+	* handlers. The install is idempotent — calling `light()` twice does NOT
+	* double-wrap `ErrorUtils` (which, unlike node's reconcile, is not naturally
+	* idempotent).
+	*/
+	light(key, debug) {
+		super.light(key, debug);
+		this.install();
+		return this;
+	}
+	/**
+	* Detach the global error handler, rejection tracker, and AppState listener,
+	* and clear the install guard so a later `light()` re-installs. For tests
+	* and manual teardown (mirrors node's `removeProcessListeners`).
+	*/
+	removeHandlers() {
+		for (const uninstall of this.uninstallers) try {
+			uninstall();
+		} catch {}
+		this.uninstallers = [];
+		this.installed = false;
+	}
+	install() {
+		if (this.installed) return;
+		this.installed = true;
+		this.uninstallers.push(installGlobalErrorHandler((error, isFatal) => {
+			this.reportSilently(error, { "error.fatal": isFatal });
+		}, () => this.flush(FATAL_FLUSH_TIMEOUT_MS)), installRejectionTracking({
+			reportSilently: (error) => this.reportSilently(error),
+			reportUnhandledRejection: (message) => this.reportUnhandledRejection(message)
+		}, this.rejectionDeps), installAppStateFlush(() => this.scheduler.getFlush()));
+	}
+};
+
+//#endregion
+//#region src/singleton.ts
+const flare = new ReactNativeFlare();
+
+//#endregion
+//#region src/FlareErrorBoundary.ts
+/**
+* React Native error boundary. A thin wrapper over `@flareapp/react`'s
+* `/inject` boundary that injects the RN `flare` singleton.
+*
+* `flare` is applied AFTER `{...props}` so a consumer cannot override the
+* singleton. The `as unknown as Flare` cast is required: the boundary prop is
+* typed against `@flareapp/js/browser`'s `Flare` (a superset of
+* `ReactNativeFlare`), so structural assignment does not hold. Safe at runtime —
+* the boundary only calls a core-level method (`reportSilently`), which
+* `ReactNativeFlare` inherits.
+*/
+function FlareErrorBoundary(props) {
+	return createElement(FlareErrorBoundary$1, {
+		...props,
+		flare
+	});
+}
+
+//#endregion
+export { DEFAULT_URL_DENYLIST, Flare, FlareErrorBoundary, GlobalScopeProvider, NullFileReader, ReactNativeFlare, convertToError, flare, redactUrlQuery, resolveDenylist };

package/package.json

@@ -0,0 +1,69 @@
+{
+    "name": "@flareapp/react-native",
+    "version": "2.6.0",
+    "description": "React Native SDK for flareapp.io",
+    "homepage": "https://flareapp.io",
+    "bugs": {
+        "url": "https://github.com/spatie/flare-client-js/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/spatie/flare-client-js.git"
+    },
+    "license": "MIT",
+    "author": {
+        "name": "Spatie",
+        "email": "info@spatie.be"
+    },
+    "files": [
+        "dist"
+    ],
+    "main": "./dist/index.cjs",
+    "module": "./dist/index.mjs",
+    "types": "./dist/index.d.cts",
+    "exports": {
+        ".": {
+            "react-native": {
+                "types": "./dist/index.d.cts",
+                "default": "./dist/index.cjs"
+            },
+            "import": {
+                "types": "./dist/index.d.mts",
+                "default": "./dist/index.mjs"
+            },
+            "require": {
+                "types": "./dist/index.d.cts",
+                "default": "./dist/index.cjs"
+            }
+        },
+        "./package.json": "./package.json"
+    },
+    "scripts": {
+        "prepublishOnly": "npm run build",
+        "build": "tsdown src/index.ts --format cjs,esm --dts --env.FLARE_JS_CLIENT_VERSION=$(node -p \"require('./package.json').version\") --clean",
+        "test": "vitest run",
+        "typescript": "tsc --noEmit",
+        "release": "release-it"
+    },
+    "dependencies": {
+        "@flareapp/core": "2.6.0"
+    },
+    "peerDependencies": {
+        "@flareapp/react": "^2.5.0",
+        "react": "^18.0.0||^19.0.0",
+        "react-native": ">=0.79.0"
+    },
+    "devDependencies": {
+        "@flareapp/js": "file:../js",
+        "@flareapp/react": "file:../react",
+        "@types/react": "^19.0.0",
+        "react": "^19.0.0",
+        "react-native": "^0.79.0",
+        "tsdown": "^0.20.3",
+        "typescript": "^5.7.0",
+        "vitest": "^4.0.18"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}