@flareapp/react-native 2.7.0 → 2.8.0

package/dist/index.cjs

@@ -6,19 +6,11 @@ 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.
+* Lazy, synchronous Expo load. The `require(...)` calls MUST be direct string literals: Metro statically
+* collects only literal `require('pkg')` calls, treating those inside a try/catch as optional deps
+* (`allowOptionalDependencies` is on by default), so a missing package degrades to a caught throw not a
+* build error. Do NOT alias `require` to a local; that defeats the static collection and the module never
+* resolves even when installed. The `typeof require` guard keeps non-Metro/ESM envs (some test runners) safe.
 */
 function loadExpoModules() {
 	const mods = {};
@@ -31,6 +23,7 @@ function loadExpoModules() {
 	} catch {}
 	return mods;
 }
+/** Maps Expo's `DeviceType` enum (UNKNOWN=0, PHONE=1, TABLET=2, DESKTOP=3, TV=4) to a label. */
 const DEVICE_TYPE_LABELS = {
 	1: "phone",
 	2: "tablet",
@@ -38,9 +31,8 @@ const DEVICE_TYPE_LABELS = {
 	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).
+* Turn the synchronous Expo constants into report attributes. Only present (non-null) fields are emitted.
+* Async Expo getters are not used, since the context collector is synchronous.
 */
 function projectExpoContext(expo) {
 	const attrs = {};
@@ -65,22 +57,11 @@ function projectExpoContext(expo) {
 //#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.
+* Two layers: RN core (`Platform`, `Dimensions`) read per call, and Expo constants resolved once and
+* absent on bare RN. Expo's `osName`/`osVersion` override the RN values where present.
 *
-* `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.
+* `Platform.Version` is a string on iOS and a number on Android, hence the stringify. `Platform.OS` maps
+* to `os.name`, not `os.type`, which is the kernel family.
 */
 function makeReactNativeContextCollector(expo = loadExpoModules()) {
 	const expoAttrs = projectExpoContext(expo);
@@ -104,22 +85,19 @@ function makeReactNativeContextCollector(expo = loadExpoModules()) {
 	};
 }
 /**
-* 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`).
+* Native device model from `Platform.constants`, maker-prefixed when available (e.g. `Google Pixel 7`).
+* Android exposes `Model`/`Manufacturer`/`Brand`; iOS core surfaces none (needs `expo-device`), so undefined.
 */
 function nativeModelName() {
-	if (react_native.Platform.OS !== "android") return void 0;
+	if (react_native.Platform.OS !== "android") return;
 	const constants = react_native.Platform.constants;
-	if (!constants?.Model) return void 0;
+	if (!constants?.Model) return;
 	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`.
+* Build a human-readable `context.device` group from the semantic attributes. Only present fields are
+* included, so bare RN (no Expo) omits `model`/`appVersion`/`appId`.
 */
 function buildDeviceContext(attrs) {
 	const device = {};
@@ -138,16 +116,13 @@ function buildDeviceContext(attrs) {
 //#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).
+* Flush the log buffer when the app backgrounds. Gate on `background` only: iOS fires `inactive` on every
+* transient interruption (app-switcher peek, Control Center, incoming call), so gating avoids flooding the
+* network. Mirrors the browser scheduler gating on `hidden`, not every blur. Delivery is best-effort (see
+* `ReactNativeFlushScheduler`).
 *
-* 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`).
+* 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) => {
@@ -169,24 +144,14 @@ 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.
+* Wraps RN's `ErrorUtils` global handler: observe, do not swallow. The wrapper reports and then delegates
+* to the previous handler, so RN's own behaviour (red box in dev, crash in prod) is preserved.
 *
-* Returns an uninstaller that restores the previous handler.
+* `onFatal` exists because a production fatal tears the app down while our report is still an async fetch
+* the OS kills, so a bare report rarely sends. With it, the previous handler is deferred until the
+* transport drains. Skipped in `__DEV__` so it does not fight the red box, and it only runs for the
+* first fatal, so a second one mid-flush hands straight over instead of starting a second shutdown.
+* Mirrors Sentry's RN SDK.
 */
 function installGlobalErrorHandler(report, onFatal) {
 	const errorUtils = getErrorUtils();
@@ -218,50 +183,44 @@ function installGlobalErrorHandler(report, onFatal) {
 
 //#endregion
 //#region src/handlers/rejectionTracking.ts
+/** An injected `null` means "engine absent" and must win over the live global, so this tests for
+*  `undefined` rather than falsiness. */
+function resolveHermes(deps) {
+	if (deps.hermes !== void 0) return deps.hermes;
+	return globalThis.HermesInternal;
+}
+/** Same `undefined`-not-falsy rule as `resolveHermes`. */
+function resolveRequire(deps) {
+	if (deps.requirePolyfill !== void 0) return deps.requirePolyfill;
+	if (typeof require === "undefined") return null;
+	return require;
+}
 /**
-* 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.
+* The rejection enabler for the active JS engine, null when neither is reachable. Order matters: on
+* Hermes the `promise` npm polyfill is not the runtime Promise, so its `rejection-tracking.enable()`
+* would hook unused objects and never fire. On JSC, RN does polyfill `global.Promise` with that package,
+* making it the real hook. Exported with injectable deps so the ordering is unit-testable.
 */
 function resolveRejectionEnabler(deps = {}) {
-	const hermes = deps.hermes !== void 0 ? deps.hermes : globalThis.HermesInternal;
+	const hermes = resolveHermes(deps);
 	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 req = resolveRequire(deps);
+	if (!req) return null;
+	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`.
+* Best-effort, engine-aware capture of unhandled rejections. RN routes these through the engine's tracker
+* rather than `window.onunhandledrejection`. With no engine hook reachable this is a no-op; uncaught
+* throws still arrive via ErrorUtils.
 *
-* 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).
+* Enabling REPLACES the engine's current callbacks, including RN's own dev warning, and neither engine
+* exposes a getter for the previous ones, so chaining is impossible. `onUnhandled` re-emits a
+* `console.warn` in dev to avoid swallowing that signal. For the same reason the uninstaller re-enables
+* with no-op callbacks: neither engine offers a clean disable.
 */
 function installRejectionTracking(reporter, deps = {}) {
 	const enable = deps.enable !== void 0 ? deps.enable : resolveRejectionEnabler();
@@ -296,15 +255,9 @@ function installRejectionTracking(reporter, deps = {}) {
 //#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.
+* Passive: the AppState -> background trigger is wired separately in `Flare.install()`, to stay symmetric
+* with handler teardown. Flushes without `{ keepalive: true }` because RN's fetch runs over XMLHttpRequest
+* and does not reliably honour it, so a backgrounding flush is best-effort.
 */
 var ReactNativeFlushScheduler = class {
 	flushFn = null;
@@ -313,7 +266,7 @@ var ReactNativeFlushScheduler = class {
 	}
 	getFlush() {
 		const flush = this.flushFn;
-		if (!flush) return void 0;
+		if (!flush) return;
 		return () => {
 			flush();
 		};
@@ -323,23 +276,13 @@ var ReactNativeFlushScheduler = class {
 //#endregion
 //#region src/Flare.ts
 const RN_SDK_NAME = "@flareapp/react-native";
-const RN_SDK_VERSION = "2.7.0";
-const RN_FRAMEWORK_NAME = "React Native";
+const RN_SDK_VERSION = "2.8.0";
+/** How long a fatal JS crash holds the app open to drain the transport before RN's default handler runs. */
 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).
+* The RN `Flare` singleton, exposed as `flare` from the package root. Uses `NullFileReader` because there
+* are no runtime snippets on a device (sourcemaps are a Metro follow-up) and `GlobalScopeProvider` because
+* RN has a single app scope.
 */
 var ReactNativeFlare = class extends _flareapp_core.Flare {
 	scheduler;
@@ -347,10 +290,8 @@ var ReactNativeFlare = class extends _flareapp_core.Flare {
 	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.
+	* @param rejectionDeps test seam. Default `{}` resolves the active engine's tracker (Hermes or JSC);
+	*        tests pass `{ enable: null }` so `light()` installs no leaking global tracker.
 	*/
 	constructor(rejectionDeps = {}) {
 		const scheduler = new ReactNativeFlushScheduler();
@@ -362,37 +303,25 @@ var ReactNativeFlare = class extends _flareapp_core.Flare {
 			name: RN_SDK_NAME,
 			version: RN_SDK_VERSION
 		});
-		this.setFramework({ name: RN_FRAMEWORK_NAME });
+		this.setFramework({ name: _flareapp_core.FrameworkName.ReactNative });
 	}
 	/**
-	* 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).
+	* The wrapped `@flareapp/react` boundary tags every flare it injects as `react`, which is wrong here,
+	* so coerce the name while keeping whatever version the caller supplied.
 	*/
 	setFramework(framework) {
 		return super.setFramework({
 			...framework,
-			name: RN_FRAMEWORK_NAME
+			name: _flareapp_core.FrameworkName.ReactNative
 		});
 	}
-	/**
-	* 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).
-	*/
+	/** Idempotent: a second `light()` must not double-wrap `ErrorUtils`, which node's reconcile gets for free. */
 	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`).
-	*/
+	/** For tests and manual teardown. Clears the install guard, so a later `light()` re-installs. */
 	removeHandlers() {
 		for (const uninstall of this.uninstallers) try {
 			uninstall();
@@ -419,15 +348,10 @@ 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.
+* 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 it. The
+* `as unknown as Flare` cast is needed because the prop is typed against `@flareapp/js/browser`'s `Flare`
+* (a superset); safe at runtime since the boundary only calls `reportSilently`, which RN inherits.
 */
 function FlareErrorBoundary(props) {
 	return (0, react.createElement)(_flareapp_react_inject.FlareErrorBoundary, {

package/dist/index.d.cts

@@ -15,19 +15,9 @@ type RejectionDeps = {
 //#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).
+ * The RN `Flare` singleton, exposed as `flare` from the package root. Uses `NullFileReader` because there
+ * are no runtime snippets on a device (sourcemaps are a Metro follow-up) and `GlobalScopeProvider` because
+ * RN has a single app scope.
  */
 declare class ReactNativeFlare extends Flare$1 {
   private readonly scheduler;
@@ -35,32 +25,18 @@ declare class ReactNativeFlare extends Flare$1 {
   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.
+   * @param rejectionDeps test seam. Default `{}` resolves the active engine's tracker (Hermes or JSC);
+   *        tests pass `{ enable: null }` so `light()` installs no leaking global tracker.
    */
   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).
+   * The wrapped `@flareapp/react` boundary tags every flare it injects as `react`, which is wrong here,
+   * so coerce the name while keeping whatever version the caller supplied.
    */
   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).
-   */
+  /** Idempotent: a second `light()` must not double-wrap `ErrorUtils`, which node's reconcile gets for free. */
   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`).
-   */
+  /** For tests and manual teardown. Clears the install guard, so a later `light()` re-installs. */
   removeHandlers(): void;
   private install;
 }
@@ -70,15 +46,10 @@ 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.
+ * 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 it. The
+ * `as unknown as Flare` cast is needed because the prop is typed against `@flareapp/js/browser`'s `Flare`
+ * (a superset); safe at runtime since the boundary only calls `reportSilently`, which RN inherits.
  */
 declare function FlareErrorBoundary(props: Omit<FlareErrorBoundaryProps, 'flare'>): ReactElement;
 //#endregion

package/dist/index.d.mts

@@ -15,19 +15,9 @@ type RejectionDeps = {
 //#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).
+ * The RN `Flare` singleton, exposed as `flare` from the package root. Uses `NullFileReader` because there
+ * are no runtime snippets on a device (sourcemaps are a Metro follow-up) and `GlobalScopeProvider` because
+ * RN has a single app scope.
  */
 declare class ReactNativeFlare extends Flare$1 {
   private readonly scheduler;
@@ -35,32 +25,18 @@ declare class ReactNativeFlare extends Flare$1 {
   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.
+   * @param rejectionDeps test seam. Default `{}` resolves the active engine's tracker (Hermes or JSC);
+   *        tests pass `{ enable: null }` so `light()` installs no leaking global tracker.
    */
   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).
+   * The wrapped `@flareapp/react` boundary tags every flare it injects as `react`, which is wrong here,
+   * so coerce the name while keeping whatever version the caller supplied.
    */
   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).
-   */
+  /** Idempotent: a second `light()` must not double-wrap `ErrorUtils`, which node's reconcile gets for free. */
   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`).
-   */
+  /** For tests and manual teardown. Clears the install guard, so a later `light()` re-installs. */
   removeHandlers(): void;
   private install;
 }
@@ -70,15 +46,10 @@ 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.
+ * 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 it. The
+ * `as unknown as Flare` cast is needed because the prop is typed against `@flareapp/js/browser`'s `Flare`
+ * (a superset); safe at runtime since the boundary only calls `reportSilently`, which RN inherits.
  */
 declare function FlareErrorBoundary(props: Omit<FlareErrorBoundaryProps, 'flare'>): ReactElement;
 //#endregion

package/dist/index.mjs

@@ -1,5 +1,5 @@
 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 { Api, DEFAULT_URL_DENYLIST, Flare, Flare as Flare$1, FrameworkName, 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";
@@ -10,19 +10,11 @@ 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.
+* Lazy, synchronous Expo load. The `require(...)` calls MUST be direct string literals: Metro statically
+* collects only literal `require('pkg')` calls, treating those inside a try/catch as optional deps
+* (`allowOptionalDependencies` is on by default), so a missing package degrades to a caught throw not a
+* build error. Do NOT alias `require` to a local; that defeats the static collection and the module never
+* resolves even when installed. The `typeof require` guard keeps non-Metro/ESM envs (some test runners) safe.
 */
 function loadExpoModules() {
 	const mods = {};
@@ -35,6 +27,7 @@ function loadExpoModules() {
 	} catch {}
 	return mods;
 }
+/** Maps Expo's `DeviceType` enum (UNKNOWN=0, PHONE=1, TABLET=2, DESKTOP=3, TV=4) to a label. */
 const DEVICE_TYPE_LABELS = {
 	1: "phone",
 	2: "tablet",
@@ -42,9 +35,8 @@ const DEVICE_TYPE_LABELS = {
 	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).
+* Turn the synchronous Expo constants into report attributes. Only present (non-null) fields are emitted.
+* Async Expo getters are not used, since the context collector is synchronous.
 */
 function projectExpoContext(expo) {
 	const attrs = {};
@@ -69,22 +61,11 @@ function projectExpoContext(expo) {
 //#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.
+* Two layers: RN core (`Platform`, `Dimensions`) read per call, and Expo constants resolved once and
+* absent on bare RN. Expo's `osName`/`osVersion` override the RN values where present.
 *
-* `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.
+* `Platform.Version` is a string on iOS and a number on Android, hence the stringify. `Platform.OS` maps
+* to `os.name`, not `os.type`, which is the kernel family.
 */
 function makeReactNativeContextCollector(expo = loadExpoModules()) {
 	const expoAttrs = projectExpoContext(expo);
@@ -108,22 +89,19 @@ function makeReactNativeContextCollector(expo = loadExpoModules()) {
 	};
 }
 /**
-* 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`).
+* Native device model from `Platform.constants`, maker-prefixed when available (e.g. `Google Pixel 7`).
+* Android exposes `Model`/`Manufacturer`/`Brand`; iOS core surfaces none (needs `expo-device`), so undefined.
 */
 function nativeModelName() {
-	if (Platform.OS !== "android") return void 0;
+	if (Platform.OS !== "android") return;
 	const constants = Platform.constants;
-	if (!constants?.Model) return void 0;
+	if (!constants?.Model) return;
 	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`.
+* Build a human-readable `context.device` group from the semantic attributes. Only present fields are
+* included, so bare RN (no Expo) omits `model`/`appVersion`/`appId`.
 */
 function buildDeviceContext(attrs) {
 	const device = {};
@@ -142,16 +120,13 @@ function buildDeviceContext(attrs) {
 //#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).
+* Flush the log buffer when the app backgrounds. Gate on `background` only: iOS fires `inactive` on every
+* transient interruption (app-switcher peek, Control Center, incoming call), so gating avoids flooding the
+* network. Mirrors the browser scheduler gating on `hidden`, not every blur. Delivery is best-effort (see
+* `ReactNativeFlushScheduler`).
 *
-* 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`).
+* 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) => {
@@ -173,24 +148,14 @@ 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.
+* Wraps RN's `ErrorUtils` global handler: observe, do not swallow. The wrapper reports and then delegates
+* to the previous handler, so RN's own behaviour (red box in dev, crash in prod) is preserved.
 *
-* Returns an uninstaller that restores the previous handler.
+* `onFatal` exists because a production fatal tears the app down while our report is still an async fetch
+* the OS kills, so a bare report rarely sends. With it, the previous handler is deferred until the
+* transport drains. Skipped in `__DEV__` so it does not fight the red box, and it only runs for the
+* first fatal, so a second one mid-flush hands straight over instead of starting a second shutdown.
+* Mirrors Sentry's RN SDK.
 */
 function installGlobalErrorHandler(report, onFatal) {
 	const errorUtils = getErrorUtils();
@@ -222,50 +187,44 @@ function installGlobalErrorHandler(report, onFatal) {
 
 //#endregion
 //#region src/handlers/rejectionTracking.ts
+/** An injected `null` means "engine absent" and must win over the live global, so this tests for
+*  `undefined` rather than falsiness. */
+function resolveHermes(deps) {
+	if (deps.hermes !== void 0) return deps.hermes;
+	return globalThis.HermesInternal;
+}
+/** Same `undefined`-not-falsy rule as `resolveHermes`. */
+function resolveRequire(deps) {
+	if (deps.requirePolyfill !== void 0) return deps.requirePolyfill;
+	if (typeof __require === "undefined") return null;
+	return __require;
+}
 /**
-* 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.
+* The rejection enabler for the active JS engine, null when neither is reachable. Order matters: on
+* Hermes the `promise` npm polyfill is not the runtime Promise, so its `rejection-tracking.enable()`
+* would hook unused objects and never fire. On JSC, RN does polyfill `global.Promise` with that package,
+* making it the real hook. Exported with injectable deps so the ordering is unit-testable.
 */
 function resolveRejectionEnabler(deps = {}) {
-	const hermes = deps.hermes !== void 0 ? deps.hermes : globalThis.HermesInternal;
+	const hermes = resolveHermes(deps);
 	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 req = resolveRequire(deps);
+	if (!req) return null;
+	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`.
+* Best-effort, engine-aware capture of unhandled rejections. RN routes these through the engine's tracker
+* rather than `window.onunhandledrejection`. With no engine hook reachable this is a no-op; uncaught
+* throws still arrive via ErrorUtils.
 *
-* 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).
+* Enabling REPLACES the engine's current callbacks, including RN's own dev warning, and neither engine
+* exposes a getter for the previous ones, so chaining is impossible. `onUnhandled` re-emits a
+* `console.warn` in dev to avoid swallowing that signal. For the same reason the uninstaller re-enables
+* with no-op callbacks: neither engine offers a clean disable.
 */
 function installRejectionTracking(reporter, deps = {}) {
 	const enable = deps.enable !== void 0 ? deps.enable : resolveRejectionEnabler();
@@ -300,15 +259,9 @@ function installRejectionTracking(reporter, deps = {}) {
 //#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.
+* Passive: the AppState -> background trigger is wired separately in `Flare.install()`, to stay symmetric
+* with handler teardown. Flushes without `{ keepalive: true }` because RN's fetch runs over XMLHttpRequest
+* and does not reliably honour it, so a backgrounding flush is best-effort.
 */
 var ReactNativeFlushScheduler = class {
 	flushFn = null;
@@ -317,7 +270,7 @@ var ReactNativeFlushScheduler = class {
 	}
 	getFlush() {
 		const flush = this.flushFn;
-		if (!flush) return void 0;
+		if (!flush) return;
 		return () => {
 			flush();
 		};
@@ -327,23 +280,13 @@ var ReactNativeFlushScheduler = class {
 //#endregion
 //#region src/Flare.ts
 const RN_SDK_NAME = "@flareapp/react-native";
-const RN_SDK_VERSION = "2.7.0";
-const RN_FRAMEWORK_NAME = "React Native";
+const RN_SDK_VERSION = "2.8.0";
+/** How long a fatal JS crash holds the app open to drain the transport before RN's default handler runs. */
 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).
+* The RN `Flare` singleton, exposed as `flare` from the package root. Uses `NullFileReader` because there
+* are no runtime snippets on a device (sourcemaps are a Metro follow-up) and `GlobalScopeProvider` because
+* RN has a single app scope.
 */
 var ReactNativeFlare = class extends Flare$1 {
 	scheduler;
@@ -351,10 +294,8 @@ var ReactNativeFlare = class extends Flare$1 {
 	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.
+	* @param rejectionDeps test seam. Default `{}` resolves the active engine's tracker (Hermes or JSC);
+	*        tests pass `{ enable: null }` so `light()` installs no leaking global tracker.
 	*/
 	constructor(rejectionDeps = {}) {
 		const scheduler = new ReactNativeFlushScheduler();
@@ -366,37 +307,25 @@ var ReactNativeFlare = class extends Flare$1 {
 			name: RN_SDK_NAME,
 			version: RN_SDK_VERSION
 		});
-		this.setFramework({ name: RN_FRAMEWORK_NAME });
+		this.setFramework({ name: FrameworkName.ReactNative });
 	}
 	/**
-	* 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).
+	* The wrapped `@flareapp/react` boundary tags every flare it injects as `react`, which is wrong here,
+	* so coerce the name while keeping whatever version the caller supplied.
 	*/
 	setFramework(framework) {
 		return super.setFramework({
 			...framework,
-			name: RN_FRAMEWORK_NAME
+			name: FrameworkName.ReactNative
 		});
 	}
-	/**
-	* 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).
-	*/
+	/** Idempotent: a second `light()` must not double-wrap `ErrorUtils`, which node's reconcile gets for free. */
 	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`).
-	*/
+	/** For tests and manual teardown. Clears the install guard, so a later `light()` re-installs. */
 	removeHandlers() {
 		for (const uninstall of this.uninstallers) try {
 			uninstall();
@@ -423,15 +352,10 @@ 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.
+* 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 it. The
+* `as unknown as Flare` cast is needed because the prop is typed against `@flareapp/js/browser`'s `Flare`
+* (a superset); safe at runtime since the boundary only calls `reportSilently`, which RN inherits.
 */
 function FlareErrorBoundary(props) {
 	return createElement(FlareErrorBoundary$1, {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flareapp/react-native",
-    "version": "2.7.0",
+    "version": "2.8.0",
     "description": "React Native SDK for flareapp.io",
     "homepage": "https://flareapp.io",
     "bugs": {
@@ -15,6 +15,9 @@
         "name": "Spatie",
         "email": "info@spatie.be"
     },
+    "contributors": [
+        "Dries Heyninck <dries@spatie.be>"
+    ],
     "files": [
         "dist"
     ],
@@ -46,7 +49,7 @@
         "release": "release-it"
     },
     "dependencies": {
-        "@flareapp/core": "2.7.0"
+        "@flareapp/core": "2.8.0"
     },
     "peerDependencies": {
         "@flareapp/react": "^2.5.0",
@@ -56,6 +59,7 @@
     "devDependencies": {
         "@flareapp/js": "file:../js",
         "@flareapp/react": "file:../react",
+        "@flareapp/test-helpers": "*",
         "@types/react": "^19.0.0",
         "react": "^19.0.0",
         "react-native": "^0.79.0",