react-native-nitro-compass 1.0.9 → 1.2.0

package/lib/module/multiplex.js

@@ -71,6 +71,13 @@ export function addHeadingListener(cb) {
   };
 }
 
+// Module-level no-op kept stable so we can swap it back into the native
+// callback slot when the last listener leaves — releasing references
+// to old dispatcher closures, which matters when the JS module is
+// re-evaluated (Metro Fast Refresh, jest module reset).
+const NOOP_CALIBRATION = _ => {};
+const NOOP_INTERFERENCE = _ => {};
+
 /**
  * Subscribe to calibration-bucket transitions. Only fires while a
  * heading subscription is active. Returns the unsubscribe function.
@@ -82,7 +89,17 @@ export function addCalibrationListener(cb) {
   }
   calibrationListeners.add(cb);
   return () => {
-    calibrationListeners.delete(cb);
+    if (!calibrationListeners.delete(cb)) return;
+    if (calibrationListeners.size === 0) {
+      // Detach our dispatcher from the native side. Without this, a
+      // module reload (Metro Fast Refresh, jest resetModules) leaves
+      // the old dispatcher pinned in native memory while a new module
+      // load installs a *second* dispatcher pointing at a fresh
+      // listener Set — splitting events between the two and silently
+      // dropping the now-orphaned listeners.
+      NitroCompass.setOnCalibrationNeeded(NOOP_CALIBRATION);
+      calibrationRegistered = false;
+    }
   };
 }
 
@@ -97,7 +114,11 @@ export function addInterferenceListener(cb) {
   }
   interferenceListeners.add(cb);
   return () => {
-    interferenceListeners.delete(cb);
+    if (!interferenceListeners.delete(cb)) return;
+    if (interferenceListeners.size === 0) {
+      NitroCompass.setOnInterferenceDetected(NOOP_INTERFERENCE);
+      interferenceRegistered = false;
+    }
   };
 }
 //# sourceMappingURL=multiplex.js.map

package/lib/module/multiplex.js.map

@@ -1 +1 @@
-{"version":3,"names":["NitroCompass","headingListeners","Set","calibrationListeners","interferenceListeners","calibrationRegistered","interferenceRegistered","DEFAULT_FILTER_DEG","dispatchHeading","sample","cb","Array","from","e","console","error","dispatchCalibration","quality","dispatchInterference","detected","addHeadingListener","wasEmpty","size","add","start","delete","stop","addCalibrationListener","setOnCalibrationNeeded","addInterferenceListener","setOnInterferenceDetected"],"sourceRoot":"../../src","sources":["multiplex.ts"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["NitroCompass","headingListeners","Set","calibrationListeners","interferenceListeners","calibrationRegistered","interferenceRegistered","DEFAULT_FILTER_DEG","dispatchHeading","sample","cb","Array","from","e","console","error","dispatchCalibration","quality","dispatchInterference","detected","addHeadingListener","wasEmpty","size","add","start","delete","stop","NOOP_CALIBRATION","_","NOOP_INTERFERENCE","addCalibrationListener","setOnCalibrationNeeded","addInterferenceListener","setOnInterferenceDetected"],"sourceRoot":"../../src","sources":["multiplex.ts"],"mappings":"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","ignoreList":[]}

package/lib/typescript/src/hook.d.ts

@@ -1,4 +1,4 @@
-import type { AccuracyQuality, CompassSample, SensorDiagnostics } from './specs/NitroCompass.nitro';
+import type { AccuracyQuality, CompassSample, PermissionStatus, SensorDiagnostics } from './specs/NitroCompass.nitro';
 export interface UseCompassOptions {
     /**
      * Minimum change between samples in degrees. Pass `0` for "every
@@ -7,6 +7,16 @@ export interface UseCompassOptions {
      * the library — last-write-wins.
      */
     filterDegrees?: number;
+    /**
+     * Low-pass smoothing factor (EMA α) applied to heading samples.
+     * Range `(0, 1]`. Default `0.2` ≈ 100ms time constant at typical
+     * Android sample rates. `1.0` disables smoothing. Smaller values
+     * smooth more (kills jitter, adds a touch of latency).
+     *
+     * No-op on iOS — CLLocationManager filters internally.
+     * Shared global state — last-write-wins.
+     */
+    smoothingAlpha?: number;
     /**
      * Magnetic-to-true offset in signed degrees. Default `0` (magnetic).
      * Pull from a model like `geomagnetism` keyed on the user's lat/lon.
@@ -37,6 +47,44 @@ export interface UseCompassResult {
     hasCompass: boolean;
     /** Which sensor backs the readings on this device. */
     diagnostics: SensorDiagnostics | undefined;
+    /**
+     * Latest platform permission status. Always `'granted'` on Android.
+     * On iOS may transition from `'unknown'` → `'granted'`/`'denied'`
+     * after `requestPermission()` resolves.
+     */
+    permission: PermissionStatus;
+    /**
+     * Synchronous read of the most recent emitted sample (with declination
+     * already applied), or `undefined` if not started yet or no sample
+     * has arrived. Useful inside event handlers without re-rendering.
+     */
+    getCurrentHeading: () => CompassSample | undefined;
+    /**
+     * Force a best-effort sensor recalibration. On Android this re-registers
+     * the sensor listeners (often nudges the magnetometer driver to
+     * re-evaluate calibration); on iOS it dismisses the heading-calibration
+     * overlay and stop/restarts heading updates.
+     */
+    recalibrate: () => void;
+    /**
+     * Set the user's geographic location for a tighter interference gate.
+     * Android uses the WMM2025 model bundled in `GeomagneticField` to
+     * derive the expected field strength at the location; iOS is a no-op
+     * because `CLLocationManager` already uses GPS-derived location
+     * internally for all field-related reasoning. Pass `NaN` or
+     * out-of-range values to revert to the generic 20–70 µT band.
+     */
+    setLocation: (latitude: number, longitude: number) => void;
+    /**
+     * Request the platform permission required to deliver headings.
+     * Android resolves immediately with `'granted'`. On iOS this prompts
+     * the system "Allow location" dialog if the status is `'unknown'`,
+     * resolving once the user makes a choice; subsequent calls resolve
+     * immediately with the cached status (iOS does not re-prompt). The
+     * hook's `permission` field updates automatically when the promise
+     * resolves.
+     */
+    requestPermission: () => Promise<PermissionStatus>;
 }
 /**
  * Ergonomic React wrapper for the NitroCompass surface. Handles

package/lib/typescript/src/hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../../src/hook.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,iBAAiB,EAClB,MAAM,4BAA4B,CAAA;AAQnC,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,gEAAgE;IAChE,OAAO,EAAE,aAAa,GAAG,IAAI,CAAA;IAC7B,oEAAoE;IACpE,OAAO,EAAE,eAAe,GAAG,IAAI,CAAA;IAC/B,oEAAoE;IACpE,WAAW,EAAE,OAAO,CAAA;IACpB,yDAAyD;IACzD,UAAU,EAAE,OAAO,CAAA;IACnB,sDAAsD;IACtD,WAAW,EAAE,iBAAiB,GAAG,SAAS,CAAA;CAC3C;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB,CAsDlB"}
+{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../../src/hook.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,4BAA4B,CAAA;AAQnC,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,gEAAgE;IAChE,OAAO,EAAE,aAAa,GAAG,IAAI,CAAA;IAC7B,oEAAoE;IACpE,OAAO,EAAE,eAAe,GAAG,IAAI,CAAA;IAC/B,oEAAoE;IACpE,WAAW,EAAE,OAAO,CAAA;IACpB,yDAAyD;IACzD,UAAU,EAAE,OAAO,CAAA;IACnB,sDAAsD;IACtD,WAAW,EAAE,iBAAiB,GAAG,SAAS,CAAA;IAC1C;;;;OAIG;IACH,UAAU,EAAE,gBAAgB,CAAA;IAC5B;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,aAAa,GAAG,SAAS,CAAA;IAClD;;;;;OAKG;IACH,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB;;;;;;;OAOG;IACH,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1D;;;;;;;;OAQG;IACH,iBAAiB,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,CAAA;CACnD;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB,CA0JlB"}

package/lib/typescript/src/index.d.ts

@@ -1,6 +1,6 @@
-import type { AccuracyQuality, CompassSample, NitroCompass as NitroCompassSpec, PermissionStatus, SensorDiagnostics, SensorKind } from './specs/NitroCompass.nitro';
+import type { AccuracyQuality, CompassSample, DebugInfo, NitroCompass as NitroCompassSpec, PermissionStatus, SensorDiagnostics, SensorKind } from './specs/NitroCompass.nitro';
 export { NitroCompass } from './native';
-export type { AccuracyQuality, CompassSample, PermissionStatus, SensorDiagnostics, SensorKind, };
+export type { AccuracyQuality, CompassSample, DebugInfo, PermissionStatus, SensorDiagnostics, SensorKind, };
 export type { NitroCompassSpec as NitroCompassHybridObject };
 export { addCalibrationListener, addHeadingListener, addInterferenceListener, } from './multiplex';
 export { useCompass } from './hook';

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,YAAY,IAAI,gBAAgB,EAChC,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACX,MAAM,4BAA4B,CAAA;AAEnC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC,YAAY,EACV,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,GACX,CAAA;AACD,YAAY,EAAE,gBAAgB,IAAI,wBAAwB,EAAE,CAAA;AAE5D,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACnC,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,SAAS,EACT,YAAY,IAAI,gBAAgB,EAChC,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACX,MAAM,4BAA4B,CAAA;AAEnC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC,YAAY,EACV,eAAe,EACf,aAAa,EACb,SAAS,EACT,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,GACX,CAAA;AACD,YAAY,EAAE,gBAAgB,IAAI,wBAAwB,EAAE,CAAA;AAE5D,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACnC,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA"}

package/lib/typescript/src/multiplex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplex.d.ts","sourceRoot":"","sources":["../../../src/multiplex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACd,MAAM,4BAA4B,CAAA;AAGnC,KAAK,eAAe,GAAG,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAA;AACtD,KAAK,mBAAmB,GAAG,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAA;AAC7D,KAAK,oBAAoB,GAAG,CAAC,oBAAoB,EAAE,OAAO,KAAK,IAAI,CAAA;AAyCnE;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,GAAG,MAAM,IAAI,CAYlE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,mBAAmB,GACtB,MAAM,IAAI,CASZ;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,oBAAoB,GACvB,MAAM,IAAI,CASZ"}
+{"version":3,"file":"multiplex.d.ts","sourceRoot":"","sources":["../../../src/multiplex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACd,MAAM,4BAA4B,CAAA;AAGnC,KAAK,eAAe,GAAG,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAA;AACtD,KAAK,mBAAmB,GAAG,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAA;AAC7D,KAAK,oBAAoB,GAAG,CAAC,oBAAoB,EAAE,OAAO,KAAK,IAAI,CAAA;AAyCnE;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,GAAG,MAAM,IAAI,CAYlE;AASD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,mBAAmB,GACtB,MAAM,IAAI,CAmBZ;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,oBAAoB,GACvB,MAAM,IAAI,CAaZ"}

package/lib/typescript/src/specs/NitroCompass.nitro.d.ts

@@ -1,7 +1,7 @@
 import type { HybridObject } from 'react-native-nitro-modules';
 /**
  * One compass heading sample, delivered to the JS callback registered with
- * `start()`. Both fields are in degrees.
+ * `start()`. Angular fields are in degrees; field strength is in microtesla.
  *
  * - `heading`: heading clockwise from north, in `[0, 360)`. Magnetic by
  *   default; if you call `setDeclination(deg)` the offset is applied
@@ -9,41 +9,122 @@ import type { HybridObject } from 'react-native-nitro-modules';
  *   `getCurrentHeading()`).
  * - `accuracy`: estimated heading uncertainty in degrees, or `-1` when the
  *   platform has not yet reported a usable accuracy. Smaller is better.
- *   On Android this is read from `event.values[4]` of the rotation-vector
- *   sensor when available, otherwise mapped from `SensorManager.SENSOR_STATUS_*`.
- *   On iOS this is `CLHeading.headingAccuracy`.
+ *   On Android, mapped from the magnetometer's `SENSOR_STATUS_*` accuracy
+ *   bucket (the figure-8 calibration signal). On iOS this is
+ *   `CLHeading.headingAccuracy`.
+ * - `fieldStrengthMicroTesla`: magnitude of the local magnetic field in
+ *   microteslas (µT), or `-1` when no reading is available yet. Earth's
+ *   field is normally 25–65 µT; values well outside this band signal
+ *   external interference (laptops, monitors, magnets, metal). Useful
+ *   for rendering a "strength" meter à la consumer compass apps.
  */
 export interface CompassSample {
     heading: number;
     accuracy: number;
+    fieldStrengthMicroTesla: number;
 }
 /**
- * Coarse calibration bucket reported via `setOnCalibrationNeeded`. Buckets
- * are derived from numeric heading accuracy on both platforms (same
- * thresholds), so values agree across iOS and Android:
+ * Coarse calibration bucket reported via `setOnCalibrationNeeded`. The
+ * bucket is derived from a numeric heading-accuracy estimate on both
+ * platforms, but the thresholds differ because the underlying scales
+ * disagree:
  *
- *   `<5°` → `high`, `<15°` → `medium`, `<30°` → `low`, otherwise `unreliable`.
+ * - **Android** — direct mapping from `SensorManager.SENSOR_STATUS_*`:
+ *   `HIGH` → `high`, `MEDIUM` → `medium`, `LOW` → `low`,
+ *   `UNRELIABLE`/`NO_CONTACT` → `unreliable`. The numeric `accuracy`
+ *   field on `CompassSample` is a synthetic upper bound (`<5°`,
+ *   `<15°`, `<30°`, `-1`).
+ * - **iOS** — bucketed from `CLHeading.headingAccuracy` (degrees) with
+ *   relaxed thresholds because Apple's stack rarely reports under 5°
+ *   even on a perfectly-calibrated compass:
+ *   `<20°` → `high`, `<35°` → `medium`, `<55°` → `low`, otherwise
+ *   `unreliable`. `unreliable` is also reported when iOS asks to
+ *   display its built-in calibration UI (we suppress the system UI so
+ *   you can render your own banner).
  *
- * On iOS `unreliable` is also reported when the system asks to display
- * its built-in calibration UI (we suppress it).
+ * The buckets are intended for UX ("show calibrate prompt") — exact
+ * cross-platform parity isn't possible because the platforms emit
+ * different underlying signals.
  */
 export type AccuracyQuality = 'high' | 'medium' | 'low' | 'unreliable';
 /**
  * Identifies which underlying sensor / framework is producing headings.
  *
- * - `rotationVector` — Android `Sensor.TYPE_ROTATION_VECTOR` (gyro + accel
- *   + magnetometer fused). Best quality.
- * - `geomagneticRotationVector` — Android
- *   `Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR` (accel + magnetometer only).
- *   Used as fallback on gyroless / budget devices; lower update rate and
- *   more susceptible to magnetic interference.
+ * - `magnetometer` — Android raw `TYPE_MAGNETIC_FIELD` + `TYPE_ACCELEROMETER`
+ *   computed via `SensorManager.getRotationMatrix()` + `getOrientation()`.
+ *   Stateless: snaps back instantly when external interference (magnets,
+ *   electronics) is removed, instead of waiting for OS-level fusion to
+ *   re-converge.
  * - `coreLocation` — iOS `CLLocationManager` heading. Apple's stack
  *   handles fusion natively.
+ * - `rotationVector` / `geomagneticRotationVector` — legacy values kept
+ *   in the union for source compatibility; no longer returned by current
+ *   builds.
  */
-export type SensorKind = 'rotationVector' | 'geomagneticRotationVector' | 'coreLocation';
+export type SensorKind = 'magnetometer' | 'coreLocation' | 'rotationVector' | 'geomagneticRotationVector';
 export interface SensorDiagnostics {
     sensor: SensorKind;
 }
+/**
+ * Live introspection of the native compass pipeline. Use for
+ * diagnosing user-reported issues (heading wrong, banner stuck,
+ * compass frozen) — none of these fields are needed for normal
+ * operation.
+ *
+ * Numeric fields use `-1` (or `NaN` for `fusedYawDeg`) as a
+ * "not-applicable / not-yet-available" sentinel; consumers should
+ * treat those as missing rather than literal values. Most fields
+ * are Android-only — iOS uses `CLLocationManager` and doesn't expose
+ * the underlying state, so the iOS implementation reports a minimal
+ * subset (`lastFieldMicroTesla`, `interferenceActive`).
+ */
+export interface DebugInfo {
+    /**
+     * Whether the library currently considers external interference to
+     * be active. Driven by field-magnitude band checks AND (Android,
+     * uncalibrated mag only) recent OS hard-iron-bias jumps.
+     */
+    interferenceActive: boolean;
+    /**
+     * Milliseconds since the most recent OS hard-iron bias jump on
+     * Android's uncalibrated magnetometer. `-1` if never seen.
+     * iOS / fallback path: always `-1`.
+     */
+    msSinceLastBiasJump: number;
+    /**
+     * The expected magnetic field magnitude (µT) at the user's
+     * location, derived from `setLocation()`. Used to tighten the
+     * interference band. `-1` if `setLocation()` hasn't been called
+     * with valid coordinates.
+     */
+    expectedFieldMicroTesla: number;
+    /**
+     * Most recent measured field magnitude (µT) — same value surfaced
+     * on `CompassSample.fieldStrengthMicroTesla`. `-1` if no reading.
+     */
+    lastFieldMicroTesla: number;
+    /**
+     * Current value of the gyro-corrected fused yaw (deg, [0, 360)).
+     * `NaN` before any sample has been processed, or on iOS where
+     * gyro fusion is handled inside CLLocationManager.
+     */
+    fusedYawDeg: number;
+    /**
+     * Latest yaw rate (deg/s) derived from game-rotation-vector
+     * deltas. Used to drive the adaptive input low-pass filter.
+     * `0` if game-RV is unavailable / hasn't fired yet.
+     */
+    lastYawRateDegPerS: number;
+    /** Whether `TYPE_GAME_ROTATION_VECTOR` is currently producing events. Always `false` on iOS. */
+    hasGameRotationVector: boolean;
+    /**
+     * Whether Android is sourcing magnetometer data from
+     * `TYPE_MAGNETIC_FIELD_UNCALIBRATED` (preferred — bias-jump
+     * detection works) vs. the `TYPE_MAGNETIC_FIELD` fallback. Always
+     * `false` on iOS.
+     */
+    usingUncalibratedMag: boolean;
+}
 /**
  * Platform permission state required to deliver headings.
  *
@@ -95,15 +176,38 @@ export interface NitroCompass extends HybridObject<{
      * effect until `start()` is called.
      */
     setFilter(degrees: number): void;
+    /**
+     * Set the low-pass smoothing factor (EMA α) applied to heading samples
+     * before delivery. Range `(0, 1]`. Default `0.2` ≈ 100ms time constant
+     * at Android's typical 50 Hz sample rate.
+     *
+     * - `1.0` disables smoothing (every sample passes through unfiltered).
+     * - Smaller values smooth more — eliminates rotation-vector jitter at
+     *   the cost of a small amount of latency.
+     *
+     * Implemented as a circular EMA on `(sin θ, cos θ)` so the 359°→0°
+     * wraparound doesn't bias the average. Survives `start`/`stop`.
+     *
+     * **No-op on iOS.** `CLLocationManager` filters heading internally with
+     * Apple's own algorithm; layering EMA on top would only add latency.
+     */
+    setSmoothing(alpha: number): void;
     /**
      * Describe which underlying sensor / framework would produce headings on
      * this device. Returns `undefined` if the device has no compass hardware
      * (equivalent to `hasCompass() === false`). Safe to call before `start()`.
      */
     getDiagnostics(): SensorDiagnostics | undefined;
+    /**
+     * Snapshot of the internal compass pipeline. Only intended for
+     * diagnosing user-reported issues — see {@link DebugInfo} for
+     * field-by-field semantics. Cheap to call (no allocations beyond
+     * the returned object); poll at any rate the host UI prefers.
+     */
+    getDebugInfo(): DebugInfo;
     /**
      * Whether the device has the hardware required for a compass reading.
-     * Android: a rotation-vector sensor (fused or geomagnetic) is present.
+     * Android: both a magnetometer and an accelerometer are present.
      * iOS: `CLLocationManager.headingAvailable()`.
      */
     hasCompass(): boolean;
@@ -120,6 +224,24 @@ export interface NitroCompass extends HybridObject<{
      * model like `geomagnetism` keyed on the user's lat/lon.
      */
     setDeclination(degrees: number): void;
+    /**
+     * Set the user's geographic location for a tighter interference
+     * gate. With a valid location, the library replaces the generic
+     * 20–70 µT "Earth field band" with `expectedField ± 15 µT`, where
+     * `expectedField` comes from the WMM2025 model shipped on Android
+     * (`GeomagneticField`). This catches weak interference the generic
+     * band misses — especially at high/low latitudes where Earth's
+     * field is naturally near or above 60 µT.
+     *
+     * Pass `NaN` for either coordinate, or values outside the valid
+     * range (`|lat| > 90`, `|lon| > 180`), to revert to the generic
+     * band. Survives across `start`/`stop`.
+     *
+     * **No-op on iOS.** `CLLocationManager` uses GPS-derived location
+     * internally for all field-related reasoning; layering our own
+     * lookup on top would be redundant.
+     */
+    setLocation(latitude: number, longitude: number): void;
     /**
      * Register a callback fired when the calibration bucket transitions.
      * Replaces any previously registered callback. Pass a no-op to mute.
@@ -157,6 +279,24 @@ export interface NitroCompass extends HybridObject<{
      * `start()`; takes effect immediately.
      */
     setPauseOnBackground(enabled: boolean): void;
+    /**
+     * Force a best-effort sensor recalibration. Resets internal smoothing
+     * and quality-bucket state, then re-registers the underlying sensor
+     * listeners. On many Android OEMs the re-registration nudges the
+     * magnetometer driver to re-evaluate soft/hard-iron calibration, which
+     * unsticks an `UNRELIABLE` bucket that's lingering after a strong
+     * magnetic excursion (e.g. another phone placed on top, then removed).
+     *
+     * On iOS this dismisses the system heading-calibration overlay and
+     * stops/restarts heading updates. Apple's stack handles the
+     * underlying calibration internally.
+     *
+     * Idempotent — safe to call when not started, in which case it's a
+     * no-op. Calibration recovery still requires the user to move the
+     * device through varying orientations; this method just clears the
+     * library's cached state so progress is reflected promptly.
+     */
+    recalibrate(): void;
     /**
      * Read the current platform permission state synchronously.
      * On Android this is always `'granted'` (sensors require no permission);

package/lib/typescript/src/specs/NitroCompass.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NitroCompass.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/NitroCompass.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,YAAY,CAAA;AAEtE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,UAAU,GAClB,gBAAgB,GAChB,2BAA2B,GAC3B,cAAc,CAAA;AAElB,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,UAAU,CAAA;CACnB;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAA;AAE/D;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,YAAa,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACrF;;;;;;;;;;OAUG;IACH,KAAK,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,GAAG,IAAI,CAAA;IAE9E,8GAA8G;IAC9G,IAAI,IAAI,IAAI,CAAA;IAEZ,qEAAqE;IACrE,SAAS,IAAI,OAAO,CAAA;IAEpB;;;;OAIG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAEhC;;;;OAIG;IACH,cAAc,IAAI,iBAAiB,GAAG,SAAS,CAAA;IAE/C;;;;OAIG;IACH,UAAU,IAAI,OAAO,CAAA;IAErB;;;;OAIG;IACH,iBAAiB,IAAI,aAAa,GAAG,SAAS,CAAA;IAE9C;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAErC;;;;OAIG;IACH,sBAAsB,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,GAAG,IAAI,CAAA;IAE1E;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,yBAAyB,CAAC,QAAQ,EAAE,CAAC,oBAAoB,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAAA;IAElF;;;;;;;OAOG;IACH,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;IAE5C;;;;OAIG;IACH,mBAAmB,IAAI,gBAAgB,CAAA;IAEvC;;;;;;;OAOG;IACH,iBAAiB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAA;CAC/C"}
+{"version":3,"file":"NitroCompass.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/NitroCompass.nitro.ts"],"names":[],"mappings":"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"}

package/nitrogen/generated/android/c++/JCompassSample.hpp

@@ -35,9 +35,12 @@ namespace margelo::nitro::nitrocompass {
       double heading = this->getFieldValue(fieldHeading);
       static const auto fieldAccuracy = clazz->getField<double>("accuracy");
       double accuracy = this->getFieldValue(fieldAccuracy);
+      static const auto fieldFieldStrengthMicroTesla = clazz->getField<double>("fieldStrengthMicroTesla");
+      double fieldStrengthMicroTesla = this->getFieldValue(fieldFieldStrengthMicroTesla);
       return CompassSample(
         heading,
-        accuracy
+        accuracy,
+        fieldStrengthMicroTesla
       );
     }
 
@@ -47,13 +50,14 @@ namespace margelo::nitro::nitrocompass {
      */
     [[maybe_unused]]
     static jni::local_ref<JCompassSample::javaobject> fromCpp(const CompassSample& value) {
-      using JSignature = JCompassSample(double, double);
+      using JSignature = JCompassSample(double, double, double);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
         value.heading,
-        value.accuracy
+        value.accuracy,
+        value.fieldStrengthMicroTesla
       );
     }
   };

package/nitrogen/generated/android/c++/JDebugInfo.hpp

@@ -0,0 +1,85 @@
+///
+/// JDebugInfo.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "DebugInfo.hpp"
+
+
+
+namespace margelo::nitro::nitrocompass {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "DebugInfo" and the the Kotlin data class "DebugInfo".
+   */
+  struct JDebugInfo final: public jni::JavaClass<JDebugInfo> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocompass/DebugInfo;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DebugInfo by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DebugInfo toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldInterferenceActive = clazz->getField<jboolean>("interferenceActive");
+      jboolean interferenceActive = this->getFieldValue(fieldInterferenceActive);
+      static const auto fieldMsSinceLastBiasJump = clazz->getField<double>("msSinceLastBiasJump");
+      double msSinceLastBiasJump = this->getFieldValue(fieldMsSinceLastBiasJump);
+      static const auto fieldExpectedFieldMicroTesla = clazz->getField<double>("expectedFieldMicroTesla");
+      double expectedFieldMicroTesla = this->getFieldValue(fieldExpectedFieldMicroTesla);
+      static const auto fieldLastFieldMicroTesla = clazz->getField<double>("lastFieldMicroTesla");
+      double lastFieldMicroTesla = this->getFieldValue(fieldLastFieldMicroTesla);
+      static const auto fieldFusedYawDeg = clazz->getField<double>("fusedYawDeg");
+      double fusedYawDeg = this->getFieldValue(fieldFusedYawDeg);
+      static const auto fieldLastYawRateDegPerS = clazz->getField<double>("lastYawRateDegPerS");
+      double lastYawRateDegPerS = this->getFieldValue(fieldLastYawRateDegPerS);
+      static const auto fieldHasGameRotationVector = clazz->getField<jboolean>("hasGameRotationVector");
+      jboolean hasGameRotationVector = this->getFieldValue(fieldHasGameRotationVector);
+      static const auto fieldUsingUncalibratedMag = clazz->getField<jboolean>("usingUncalibratedMag");
+      jboolean usingUncalibratedMag = this->getFieldValue(fieldUsingUncalibratedMag);
+      return DebugInfo(
+        static_cast<bool>(interferenceActive),
+        msSinceLastBiasJump,
+        expectedFieldMicroTesla,
+        lastFieldMicroTesla,
+        fusedYawDeg,
+        lastYawRateDegPerS,
+        static_cast<bool>(hasGameRotationVector),
+        static_cast<bool>(usingUncalibratedMag)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JDebugInfo::javaobject> fromCpp(const DebugInfo& value) {
+      using JSignature = JDebugInfo(jboolean, double, double, double, double, double, jboolean, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.interferenceActive,
+        value.msSinceLastBiasJump,
+        value.expectedFieldMicroTesla,
+        value.lastFieldMicroTesla,
+        value.fusedYawDeg,
+        value.lastYawRateDegPerS,
+        value.hasGameRotationVector,
+        value.usingUncalibratedMag
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrocompass

package/nitrogen/generated/android/c++/JHybridNitroCompassSpec.cpp

@@ -11,6 +11,8 @@
 namespace margelo::nitro::nitrocompass { struct SensorDiagnostics; }
 // Forward declaration of `SensorKind` to properly resolve imports.
 namespace margelo::nitro::nitrocompass { enum class SensorKind; }
+// Forward declaration of `DebugInfo` to properly resolve imports.
+namespace margelo::nitro::nitrocompass { struct DebugInfo; }
 // Forward declaration of `CompassSample` to properly resolve imports.
 namespace margelo::nitro::nitrocompass { struct CompassSample; }
 // Forward declaration of `PermissionStatus` to properly resolve imports.
@@ -23,6 +25,8 @@ namespace margelo::nitro::nitrocompass { enum class AccuracyQuality; }
 #include "JSensorDiagnostics.hpp"
 #include "SensorKind.hpp"
 #include "JSensorKind.hpp"
+#include "DebugInfo.hpp"
+#include "JDebugInfo.hpp"
 #include "CompassSample.hpp"
 #include "JCompassSample.hpp"
 #include "PermissionStatus.hpp"
@@ -87,11 +91,20 @@ namespace margelo::nitro::nitrocompass {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* degrees */)>("setFilter");
     method(_javaPart, degrees);
   }
+  void JHybridNitroCompassSpec::setSmoothing(double alpha) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* alpha */)>("setSmoothing");
+    method(_javaPart, alpha);
+  }
   std::optional<SensorDiagnostics> JHybridNitroCompassSpec::getDiagnostics() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JSensorDiagnostics>()>("getDiagnostics");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
   }
+  DebugInfo JHybridNitroCompassSpec::getDebugInfo() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JDebugInfo>()>("getDebugInfo");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
   bool JHybridNitroCompassSpec::hasCompass() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("hasCompass");
     auto __result = method(_javaPart);
@@ -106,6 +119,10 @@ namespace margelo::nitro::nitrocompass {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* degrees */)>("setDeclination");
     method(_javaPart, degrees);
   }
+  void JHybridNitroCompassSpec::setLocation(double latitude, double longitude) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* latitude */, double /* longitude */)>("setLocation");
+    method(_javaPart, latitude, longitude);
+  }
   void JHybridNitroCompassSpec::setOnCalibrationNeeded(const std::function<void(AccuracyQuality /* quality */)>& onChange) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_AccuracyQuality::javaobject> /* onChange */)>("setOnCalibrationNeeded_cxx");
     method(_javaPart, JFunc_void_AccuracyQuality_cxx::fromCpp(onChange));
@@ -118,6 +135,10 @@ namespace margelo::nitro::nitrocompass {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* enabled */)>("setPauseOnBackground");
     method(_javaPart, enabled);
   }
+  void JHybridNitroCompassSpec::recalibrate() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("recalibrate");
+    method(_javaPart);
+  }
   PermissionStatus JHybridNitroCompassSpec::getPermissionStatus() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPermissionStatus>()>("getPermissionStatus");
     auto __result = method(_javaPart);

package/nitrogen/generated/android/c++/JHybridNitroCompassSpec.hpp

@@ -58,13 +58,17 @@ namespace margelo::nitro::nitrocompass {
     void stop() override;
     bool isStarted() override;
     void setFilter(double degrees) override;
+    void setSmoothing(double alpha) override;
     std::optional<SensorDiagnostics> getDiagnostics() override;
+    DebugInfo getDebugInfo() override;
     bool hasCompass() override;
     std::optional<CompassSample> getCurrentHeading() override;
     void setDeclination(double degrees) override;
+    void setLocation(double latitude, double longitude) override;
     void setOnCalibrationNeeded(const std::function<void(AccuracyQuality /* quality */)>& onChange) override;
     void setOnInterferenceDetected(const std::function<void(bool /* interferenceDetected */)>& onChange) override;
     void setPauseOnBackground(bool enabled) override;
+    void recalibrate() override;
     PermissionStatus getPermissionStatus() override;
     std::shared_ptr<Promise<PermissionStatus>> requestPermission() override;
 

package/nitrogen/generated/android/c++/JSensorKind.hpp

@@ -42,15 +42,18 @@ namespace margelo::nitro::nitrocompass {
     static jni::alias_ref<JSensorKind> fromCpp(SensorKind value) {
       static const auto clazz = javaClassStatic();
       switch (value) {
+        case SensorKind::MAGNETOMETER:
+          static const auto fieldMAGNETOMETER = clazz->getStaticField<JSensorKind>("MAGNETOMETER");
+          return clazz->getStaticFieldValue(fieldMAGNETOMETER);
+        case SensorKind::CORELOCATION:
+          static const auto fieldCORELOCATION = clazz->getStaticField<JSensorKind>("CORELOCATION");
+          return clazz->getStaticFieldValue(fieldCORELOCATION);
         case SensorKind::ROTATIONVECTOR:
           static const auto fieldROTATIONVECTOR = clazz->getStaticField<JSensorKind>("ROTATIONVECTOR");
           return clazz->getStaticFieldValue(fieldROTATIONVECTOR);
         case SensorKind::GEOMAGNETICROTATIONVECTOR:
           static const auto fieldGEOMAGNETICROTATIONVECTOR = clazz->getStaticField<JSensorKind>("GEOMAGNETICROTATIONVECTOR");
           return clazz->getStaticFieldValue(fieldGEOMAGNETICROTATIONVECTOR);
-        case SensorKind::CORELOCATION:
-          static const auto fieldCORELOCATION = clazz->getStaticField<JSensorKind>("CORELOCATION");
-          return clazz->getStaticFieldValue(fieldCORELOCATION);
         default:
           std::string stringValue = std::to_string(static_cast<int>(value));
           throw std::invalid_argument("Invalid enum value (" + stringValue + "!");