@symbiote-native/sensors 0.1.0

package/src/core/barometer.ts

@@ -0,0 +1,15 @@
+import { DeviceSensor } from './device-sensor';
+import { exponentBarometer } from './native/exponent-barometer';
+
+// Pressure is in hectopascals (hPa); relativeAltitude (meters) is iOS-only; timestamp is in seconds.
+export type IBarometerMeasurement = {
+  pressure: number;
+  relativeAltitude?: number;
+  timestamp: number;
+};
+
+export class BarometerSensor extends DeviceSensor<IBarometerMeasurement> {}
+
+const BAROMETER_DID_UPDATE_EVENT_NAME = 'barometerDidUpdate';
+
+export const Barometer = new BarometerSensor(exponentBarometer, BAROMETER_DID_UPDATE_EVENT_NAME);

package/src/core/device-motion.test.ts

@@ -0,0 +1,60 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_GRAVITY = 9.80665;
+
+const FAKE_NATIVE_DEVICE_MOTION = {
+  addListener: vi.fn(() => ({ remove: vi.fn() })),
+  listenerCount: vi.fn(() => 0),
+  removeAllListeners: vi.fn(),
+  setUpdateInterval: vi.fn(),
+  Gravity: FAKE_GRAVITY,
+};
+
+// The real ExponentDeviceMotion native module only exists on device — resolving it via
+// requireNativeModule() at import time would throw in this headless test run, so the
+// module-lookup file is faked in place of `expo-modules-core`'s runtime resolution.
+vi.mock('./native/exponent-device-motion', () => ({
+  exponentDeviceMotion: FAKE_NATIVE_DEVICE_MOTION,
+}));
+
+// device-sensor.ts (imported transitively through ./device-motion) pulls Platform/PermissionStatus
+// from expo-modules-core, whose real entry drags in the Flow-typed 'react-native' source that
+// Vitest's Oxc transform can't parse — same fake as device-sensor.test.ts.
+vi.mock('expo-modules-core', () => ({
+  Platform: { OS: 'ios' },
+  PermissionStatus: { GRANTED: 'granted', UNDETERMINED: 'undetermined', DENIED: 'denied' },
+}));
+
+const { DeviceMotion, gravity } = await import('./device-motion');
+
+afterEach(() => {
+  DeviceMotion.removeAllListeners();
+  vi.clearAllMocks();
+});
+
+describe('DeviceMotion', () => {
+  it('sets the update interval', () => {
+    DeviceMotion.setUpdateInterval(1234);
+
+    expect(FAKE_NATIVE_DEVICE_MOTION.setUpdateInterval).toHaveBeenCalledTimes(1);
+    expect(FAKE_NATIVE_DEVICE_MOTION.setUpdateInterval).toHaveBeenCalledWith(1234);
+  });
+
+  it('subscribes through the shared deviceMotionDidUpdate event name', () => {
+    const listener = vi.fn();
+    DeviceMotion.addListener(listener);
+
+    expect(FAKE_NATIVE_DEVICE_MOTION.addListener).toHaveBeenCalledWith(
+      'deviceMotionDidUpdate',
+      listener,
+    );
+  });
+
+  it('exposes the native Gravity constant as a standalone export', () => {
+    expect(gravity).toBe(FAKE_GRAVITY);
+  });
+
+  it('exposes the native Gravity constant as an instance property', () => {
+    expect(DeviceMotion.gravity).toBe(FAKE_GRAVITY);
+  });
+});

package/src/core/device-motion.ts

@@ -0,0 +1,41 @@
+import { DeviceSensor } from './device-sensor';
+import { exponentDeviceMotion } from './native/exponent-device-motion';
+
+// Acceleration figures are in meters per second squared (m/s^2); rotation is in degrees and
+// rotationRate in degrees per second (deg/s); interval is in milliseconds; timestamps are in
+// seconds. `acceleration` and `rotationRate` are null on devices that can't isolate gravity
+// from raw acceleration.
+export type IDeviceMotionMeasurement = {
+  acceleration: null | { x: number; y: number; z: number; timestamp: number };
+  accelerationIncludingGravity: { x: number; y: number; z: number; timestamp: number };
+  rotation: { alpha: number; beta: number; gamma: number; timestamp: number };
+  rotationRate: null | { alpha: number; beta: number; gamma: number; timestamp: number };
+  interval: number;
+  orientation: DeviceMotionOrientation;
+};
+
+// Device orientation based on screen rotation.
+export enum DeviceMotionOrientation {
+  Portrait = 0,
+  RightLandscape = 90,
+  UpsideDown = 180,
+  LeftLandscape = -90,
+}
+
+export class DeviceMotionSensor extends DeviceSensor<IDeviceMotionMeasurement> {
+  // Standard gravitational acceleration for Earth (m/s^2), read off the native module rather
+  // than hardcoded — mirrors upstream's dual exposure as both an instance property and the
+  // standalone `gravity` export below.
+  readonly gravity: number = exponentDeviceMotion.Gravity;
+}
+
+const DEVICE_MOTION_DID_UPDATE_EVENT_NAME = 'deviceMotionDidUpdate';
+
+export const DeviceMotion = new DeviceMotionSensor(
+  exponentDeviceMotion,
+  DEVICE_MOTION_DID_UPDATE_EVENT_NAME,
+);
+
+// Standalone export mirroring the instance property above, for callers that only need the
+// constant and not the full sensor singleton.
+export const gravity: number = exponentDeviceMotion.Gravity;

package/src/core/device-sensor.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { INativeSensorModule } from './device-sensor';
+
+// expo-modules-core's real entry transitively imports the 'react-native' package for
+// Platform/TurboModuleRegistry, whose Flow-typed source Vitest's Oxc transform cannot parse
+// (Metro strips Flow on-device, Vitest has no such pipeline) — faked here the same way
+// react-native-bootsplash is faked in the splash-screen package's own composable tests.
+vi.mock('expo-modules-core', () => ({
+  Platform: { OS: 'ios' },
+  PermissionStatus: { GRANTED: 'granted', UNDETERMINED: 'undetermined', DENIED: 'denied' },
+}));
+
+const { DeviceSensor } = await import('./device-sensor');
+
+// DeviceSensor only ever calls addListener/listenerCount/removeAllListeners on its native
+// module — a plain fake satisfying INativeSensorModule is enough, no need to extend
+// expo-modules-core's real NativeModule (which requires a live native JSI runtime to construct).
+function createFakeNativeModule(): INativeSensorModule<unknown> {
+  const listeners = new Set<(measurement: unknown) => void>();
+  return {
+    addListener: vi.fn((_eventName: string, listener: (measurement: unknown) => void) => {
+      listeners.add(listener);
+      return { remove: () => listeners.delete(listener) };
+    }),
+    listenerCount: vi.fn(() => listeners.size),
+    removeAllListeners: vi.fn(() => listeners.clear()),
+    setUpdateInterval: vi.fn(),
+  };
+}
+
+describe('DeviceSensor', () => {
+  it('counts the number of listeners', () => {
+    const nativeModule = createFakeNativeModule();
+    const sensor = new DeviceSensor(nativeModule, 'mockDidUpdate');
+
+    const subscription1 = sensor.addListener(() => {});
+    expect(sensor.hasListeners()).toBe(true);
+    expect(sensor.getListenerCount()).toBe(1);
+
+    const subscription2 = sensor.addListener(() => {});
+    sensor.addListener(() => {});
+    expect(sensor.getListenerCount()).toBe(3);
+
+    subscription2.remove();
+    expect(sensor.getListenerCount()).toBe(2);
+
+    sensor.removeSubscription(subscription1);
+    expect(sensor.getListenerCount()).toBe(1);
+
+    sensor.removeAllListeners();
+    expect(sensor.getListenerCount()).toBe(0);
+  });
+
+  it('forwards setUpdateInterval to the native module', () => {
+    const nativeModule = createFakeNativeModule();
+    const sensor = new DeviceSensor(nativeModule, 'mockDidUpdate');
+
+    sensor.setUpdateInterval(1234);
+
+    expect(nativeModule.setUpdateInterval).toHaveBeenCalledTimes(1);
+    expect(nativeModule.setUpdateInterval).toHaveBeenCalledWith(1234);
+  });
+
+  it('falls back to a granted default permission response when the native module has none', async () => {
+    const nativeModule = createFakeNativeModule();
+    const sensor = new DeviceSensor(nativeModule, 'mockDidUpdate');
+
+    await expect(sensor.getPermissionsAsync()).resolves.toEqual({
+      granted: true,
+      expires: 'never',
+      canAskAgain: true,
+      status: 'granted',
+    });
+    await expect(sensor.isAvailableAsync()).resolves.toBe(false);
+  });
+});

package/src/core/device-sensor.ts

@@ -0,0 +1,95 @@
+// expo-sensors' own DeviceSensor imports PermissionResponse/PermissionExpiration/PermissionStatus
+// from the `expo` meta-package. We never depend on `expo` itself (it drags in a second
+// Metro/babel pipeline — see the symbiote-expo-native-module skill) so this pulls the same
+// three exports straight from expo-modules-core, which is where `expo` re-exports them from.
+import {
+  Platform,
+  PermissionStatus,
+  type EventSubscription,
+  type PermissionExpiration,
+  type PermissionResponse,
+} from 'expo-modules-core';
+
+export type IListener<Measurement> = (measurement: Measurement) => void;
+
+export type INativeSensorModule<Measurement> = {
+  addListener(eventName: string, listener: IListener<Measurement>): EventSubscription;
+  listenerCount(eventName: string): number;
+  removeAllListeners(eventName: string): void;
+  setUpdateInterval?(intervalMs: number): void;
+  isAvailableAsync?(): Promise<boolean>;
+  getPermissionsAsync?(): Promise<PermissionResponse>;
+  requestPermissionsAsync?(): Promise<PermissionResponse>;
+};
+
+const DEFAULT_PERMISSION_RESPONSE: PermissionResponse = {
+  granted: true,
+  expires: 'never',
+  canAskAgain: true,
+  status: PermissionStatus.GRANTED,
+};
+
+export class DeviceSensor<Measurement> {
+  readonly nativeModule: INativeSensorModule<Measurement>;
+  readonly nativeEventName: string;
+
+  constructor(nativeModule: INativeSensorModule<Measurement>, nativeEventName: string) {
+    this.nativeModule = nativeModule;
+    this.nativeEventName = nativeEventName;
+  }
+
+  addListener(listener: IListener<Measurement>): EventSubscription {
+    return this.nativeModule.addListener(this.nativeEventName, listener);
+  }
+
+  hasListeners(): boolean {
+    return this.getListenerCount() > 0;
+  }
+
+  getListenerCount(): number {
+    return this.nativeModule.listenerCount(this.nativeEventName);
+  }
+
+  removeAllListeners(): void {
+    this.nativeModule.removeAllListeners(this.nativeEventName);
+  }
+
+  // upstream keeps this only for callers still holding a pre-subscription-object reference.
+  removeSubscription(subscription: EventSubscription): void {
+    subscription.remove();
+  }
+
+  setUpdateInterval(intervalMs: number): void {
+    if (!this.nativeModule.setUpdateInterval) {
+      console.warn(
+        `@symbiote-native/sensors: setUpdateInterval() is not supported on ${Platform.OS}`,
+      );
+      return;
+    }
+    this.nativeModule.setUpdateInterval(intervalMs);
+  }
+
+  async isAvailableAsync(): Promise<boolean> {
+    if (!this.nativeModule.isAvailableAsync) {
+      return false;
+    }
+    return this.nativeModule.isAvailableAsync();
+  }
+
+  async getPermissionsAsync(): Promise<PermissionResponse> {
+    if (!this.nativeModule.getPermissionsAsync) {
+      return DEFAULT_PERMISSION_RESPONSE;
+    }
+    return this.nativeModule.getPermissionsAsync();
+  }
+
+  async requestPermissionsAsync(): Promise<PermissionResponse> {
+    if (!this.nativeModule.requestPermissionsAsync) {
+      return DEFAULT_PERMISSION_RESPONSE;
+    }
+    return this.nativeModule.requestPermissionsAsync();
+  }
+}
+
+export { PermissionStatus };
+export type { EventSubscription, PermissionExpiration, PermissionResponse };

package/src/core/gyroscope.test.ts

@@ -0,0 +1,46 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_NATIVE_GYROSCOPE = {
+  addListener: vi.fn(() => ({ remove: vi.fn() })),
+  listenerCount: vi.fn(() => 0),
+  removeAllListeners: vi.fn(),
+  setUpdateInterval: vi.fn(),
+};
+
+// The real ExponentGyroscope native module only exists on device — resolving it via
+// requireNativeModule() at import time would throw in this headless test run, so the
+// module-lookup file is faked in place of `expo-modules-core`'s runtime resolution.
+vi.mock('./native/exponent-gyroscope', () => ({
+  exponentGyroscope: FAKE_NATIVE_GYROSCOPE,
+}));
+
+// device-sensor.ts (imported transitively through ./gyroscope) pulls Platform/PermissionStatus
+// from expo-modules-core, whose real entry drags in the Flow-typed 'react-native' source that
+// Vitest's Oxc transform can't parse — same fake as device-sensor.test.ts.
+vi.mock('expo-modules-core', () => ({
+  Platform: { OS: 'ios' },
+  PermissionStatus: { GRANTED: 'granted', UNDETERMINED: 'undetermined', DENIED: 'denied' },
+}));
+
+const { Gyroscope } = await import('./gyroscope');
+
+afterEach(() => {
+  Gyroscope.removeAllListeners();
+  vi.clearAllMocks();
+});
+
+describe('Gyroscope', () => {
+  it('sets the update interval', () => {
+    Gyroscope.setUpdateInterval(1234);
+
+    expect(FAKE_NATIVE_GYROSCOPE.setUpdateInterval).toHaveBeenCalledTimes(1);
+    expect(FAKE_NATIVE_GYROSCOPE.setUpdateInterval).toHaveBeenCalledWith(1234);
+  });
+
+  it('subscribes through the shared gyroscopeDidUpdate event name', () => {
+    const listener = vi.fn();
+    Gyroscope.addListener(listener);
+
+    expect(FAKE_NATIVE_GYROSCOPE.addListener).toHaveBeenCalledWith('gyroscopeDidUpdate', listener);
+  });
+});

package/src/core/gyroscope.ts

@@ -0,0 +1,16 @@
+import { DeviceSensor } from './device-sensor';
+import { exponentGyroscope } from './native/exponent-gyroscope';
+
+// Values are rotation rate in radians/second reported along each axis; timestamp is in seconds.
+export type IGyroscopeMeasurement = {
+  x: number;
+  y: number;
+  z: number;
+  timestamp: number;
+};
+
+export class GyroscopeSensor extends DeviceSensor<IGyroscopeMeasurement> {}
+
+const GYROSCOPE_DID_UPDATE_EVENT_NAME = 'gyroscopeDidUpdate';
+
+export const Gyroscope = new GyroscopeSensor(exponentGyroscope, GYROSCOPE_DID_UPDATE_EVENT_NAME);

package/src/core/index.ts

@@ -0,0 +1,37 @@
+export {
+  Accelerometer,
+  AccelerometerSensor,
+  type IAccelerometerMeasurement,
+} from './accelerometer';
+export { Barometer, BarometerSensor, type IBarometerMeasurement } from './barometer';
+export {
+  DeviceMotion,
+  DeviceMotionSensor,
+  DeviceMotionOrientation,
+  gravity,
+  type IDeviceMotionMeasurement,
+} from './device-motion';
+export { Gyroscope, GyroscopeSensor, type IGyroscopeMeasurement } from './gyroscope';
+export { LightSensor, LightSensorSensor, type ILightSensorMeasurement } from './light-sensor';
+export { Magnetometer, MagnetometerSensor, type IMagnetometerMeasurement } from './magnetometer';
+export {
+  MagnetometerUncalibrated,
+  MagnetometerUncalibratedSensor,
+  type IMagnetometerUncalibratedMeasurement,
+} from './magnetometer-uncalibrated';
+export {
+  watchStepCount,
+  getStepCountAsync,
+  isAvailableAsync,
+  getPermissionsAsync,
+  requestPermissionsAsync,
+  type IPedometerResult,
+  type IPedometerUpdateCallback,
+} from './pedometer';
+export { DeviceSensor, type IListener, type INativeSensorModule } from './device-sensor';
+export type {
+  EventSubscription,
+  PermissionExpiration,
+  PermissionResponse,
+} from 'expo-modules-core';
+export { PermissionStatus } from 'expo-modules-core';

package/src/core/light-sensor.test.ts

@@ -0,0 +1,49 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_NATIVE_LIGHT_SENSOR = {
+  addListener: vi.fn(() => ({ remove: vi.fn() })),
+  listenerCount: vi.fn(() => 0),
+  removeAllListeners: vi.fn(),
+  setUpdateInterval: vi.fn(),
+};
+
+// The real ExpoLightSensor native module only exists on device — resolving it via
+// requireNativeModule() at import time would throw in this headless test run, so the
+// module-lookup file is faked in place of `expo-modules-core`'s runtime resolution.
+vi.mock('./native/exponent-light-sensor', () => ({
+  exponentLightSensor: FAKE_NATIVE_LIGHT_SENSOR,
+}));
+
+// device-sensor.ts (imported transitively through ./light-sensor) pulls Platform/PermissionStatus
+// from expo-modules-core, whose real entry drags in the Flow-typed 'react-native' source that
+// Vitest's Oxc transform can't parse — same fake as device-sensor.test.ts.
+vi.mock('expo-modules-core', () => ({
+  Platform: { OS: 'ios' },
+  PermissionStatus: { GRANTED: 'granted', UNDETERMINED: 'undetermined', DENIED: 'denied' },
+}));
+
+const { LightSensor } = await import('./light-sensor');
+
+afterEach(() => {
+  LightSensor.removeAllListeners();
+  vi.clearAllMocks();
+});
+
+describe('LightSensor', () => {
+  it('sets the update interval', () => {
+    LightSensor.setUpdateInterval(1234);
+
+    expect(FAKE_NATIVE_LIGHT_SENSOR.setUpdateInterval).toHaveBeenCalledTimes(1);
+    expect(FAKE_NATIVE_LIGHT_SENSOR.setUpdateInterval).toHaveBeenCalledWith(1234);
+  });
+
+  it('subscribes through the shared lightSensorDidUpdate event name', () => {
+    const listener = vi.fn();
+    LightSensor.addListener(listener);
+
+    expect(FAKE_NATIVE_LIGHT_SENSOR.addListener).toHaveBeenCalledWith(
+      'lightSensorDidUpdate',
+      listener,
+    );
+  });
+});

package/src/core/light-sensor.ts

@@ -0,0 +1,18 @@
+import { DeviceSensor } from './device-sensor';
+import { exponentLightSensor } from './native/exponent-light-sensor';
+
+// Ambient light level in lux (lx); timestamp is in seconds. Android-only — see
+// core/native/exponent-light-sensor/index.ios.ts for the iOS stub.
+export type ILightSensorMeasurement = {
+  illuminance: number;
+  timestamp: number;
+};
+
+export class LightSensorSensor extends DeviceSensor<ILightSensorMeasurement> {}
+
+const LIGHT_SENSOR_DID_UPDATE_EVENT_NAME = 'lightSensorDidUpdate';
+
+export const LightSensor = new LightSensorSensor(
+  exponentLightSensor,
+  LIGHT_SENSOR_DID_UPDATE_EVENT_NAME,
+);

package/src/core/magnetometer-uncalibrated.test.ts

@@ -0,0 +1,49 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_NATIVE_MAGNETOMETER_UNCALIBRATED = {
+  addListener: vi.fn(() => ({ remove: vi.fn() })),
+  listenerCount: vi.fn(() => 0),
+  removeAllListeners: vi.fn(),
+  setUpdateInterval: vi.fn(),
+};
+
+// The real ExponentMagnetometerUncalibrated native module only exists on device — resolving it
+// via requireNativeModule() at import time would throw in this headless test run, so the
+// module-lookup file is faked in place of `expo-modules-core`'s runtime resolution.
+vi.mock('./native/exponent-magnetometer-uncalibrated', () => ({
+  exponentMagnetometerUncalibrated: FAKE_NATIVE_MAGNETOMETER_UNCALIBRATED,
+}));
+
+// device-sensor.ts (imported transitively through ./magnetometer-uncalibrated) pulls
+// Platform/PermissionStatus from expo-modules-core, whose real entry drags in the Flow-typed
+// 'react-native' source that Vitest's Oxc transform can't parse — same fake as device-sensor.test.ts.
+vi.mock('expo-modules-core', () => ({
+  Platform: { OS: 'ios' },
+  PermissionStatus: { GRANTED: 'granted', UNDETERMINED: 'undetermined', DENIED: 'denied' },
+}));
+
+const { MagnetometerUncalibrated } = await import('./magnetometer-uncalibrated');
+
+afterEach(() => {
+  MagnetometerUncalibrated.removeAllListeners();
+  vi.clearAllMocks();
+});
+
+describe('MagnetometerUncalibrated', () => {
+  it('sets the update interval', () => {
+    MagnetometerUncalibrated.setUpdateInterval(1234);
+
+    expect(FAKE_NATIVE_MAGNETOMETER_UNCALIBRATED.setUpdateInterval).toHaveBeenCalledTimes(1);
+    expect(FAKE_NATIVE_MAGNETOMETER_UNCALIBRATED.setUpdateInterval).toHaveBeenCalledWith(1234);
+  });
+
+  it('subscribes through the shared magnetometerUncalibratedDidUpdate event name', () => {
+    const listener = vi.fn();
+    MagnetometerUncalibrated.addListener(listener);
+
+    expect(FAKE_NATIVE_MAGNETOMETER_UNCALIBRATED.addListener).toHaveBeenCalledWith(
+      'magnetometerUncalibratedDidUpdate',
+      listener,
+    );
+  });
+});

package/src/core/magnetometer-uncalibrated.ts

@@ -0,0 +1,20 @@
+import { DeviceSensor } from './device-sensor';
+import { exponentMagnetometerUncalibrated } from './native/exponent-magnetometer-uncalibrated';
+
+// Values are the uncalibrated strength of the magnetic field along each axis, in microteslas
+// (`μT`); timestamp is in seconds.
+export type IMagnetometerUncalibratedMeasurement = {
+  x: number;
+  y: number;
+  z: number;
+  timestamp: number;
+};
+
+export class MagnetometerUncalibratedSensor extends DeviceSensor<IMagnetometerUncalibratedMeasurement> {}
+
+const MAGNETOMETER_UNCALIBRATED_DID_UPDATE_EVENT_NAME = 'magnetometerUncalibratedDidUpdate';
+
+export const MagnetometerUncalibrated = new MagnetometerUncalibratedSensor(
+  exponentMagnetometerUncalibrated,
+  MAGNETOMETER_UNCALIBRATED_DID_UPDATE_EVENT_NAME,
+);

package/src/core/magnetometer.test.ts

@@ -0,0 +1,49 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_NATIVE_MAGNETOMETER = {
+  addListener: vi.fn(() => ({ remove: vi.fn() })),
+  listenerCount: vi.fn(() => 0),
+  removeAllListeners: vi.fn(),
+  setUpdateInterval: vi.fn(),
+};
+
+// The real ExponentMagnetometer native module only exists on device — resolving it via
+// requireNativeModule() at import time would throw in this headless test run, so the
+// module-lookup file is faked in place of `expo-modules-core`'s runtime resolution.
+vi.mock('./native/exponent-magnetometer', () => ({
+  exponentMagnetometer: FAKE_NATIVE_MAGNETOMETER,
+}));
+
+// device-sensor.ts (imported transitively through ./magnetometer) pulls Platform/PermissionStatus
+// from expo-modules-core, whose real entry drags in the Flow-typed 'react-native' source that
+// Vitest's Oxc transform can't parse — same fake as device-sensor.test.ts.
+vi.mock('expo-modules-core', () => ({
+  Platform: { OS: 'ios' },
+  PermissionStatus: { GRANTED: 'granted', UNDETERMINED: 'undetermined', DENIED: 'denied' },
+}));
+
+const { Magnetometer } = await import('./magnetometer');
+
+afterEach(() => {
+  Magnetometer.removeAllListeners();
+  vi.clearAllMocks();
+});
+
+describe('Magnetometer', () => {
+  it('sets the update interval', () => {
+    Magnetometer.setUpdateInterval(1234);
+
+    expect(FAKE_NATIVE_MAGNETOMETER.setUpdateInterval).toHaveBeenCalledTimes(1);
+    expect(FAKE_NATIVE_MAGNETOMETER.setUpdateInterval).toHaveBeenCalledWith(1234);
+  });
+
+  it('subscribes through the shared magnetometerDidUpdate event name', () => {
+    const listener = vi.fn();
+    Magnetometer.addListener(listener);
+
+    expect(FAKE_NATIVE_MAGNETOMETER.addListener).toHaveBeenCalledWith(
+      'magnetometerDidUpdate',
+      listener,
+    );
+  });
+});

package/src/core/magnetometer.ts

@@ -0,0 +1,19 @@
+import { DeviceSensor } from './device-sensor';
+import { exponentMagnetometer } from './native/exponent-magnetometer';
+
+// Values are the strength of the magnetic field along each axis, measured in microteslas (μT); timestamp is in seconds.
+export type IMagnetometerMeasurement = {
+  x: number;
+  y: number;
+  z: number;
+  timestamp: number;
+};
+
+export class MagnetometerSensor extends DeviceSensor<IMagnetometerMeasurement> {}
+
+const MAGNETOMETER_DID_UPDATE_EVENT_NAME = 'magnetometerDidUpdate';
+
+export const Magnetometer = new MagnetometerSensor(
+  exponentMagnetometer,
+  MAGNETOMETER_DID_UPDATE_EVENT_NAME,
+);

package/src/core/native/exponent-accelerometer.ts

@@ -0,0 +1,9 @@
+import { requireNativeModule } from 'expo-modules-core';
+import type { INativeSensorModule } from '../device-sensor';
+import type { IAccelerometerMeasurement } from '../accelerometer';
+
+const EXPONENT_ACCELEROMETER_MODULE_NAME = 'ExponentAccelerometer';
+
+export const exponentAccelerometer = requireNativeModule<
+  INativeSensorModule<IAccelerometerMeasurement>
+>(EXPONENT_ACCELEROMETER_MODULE_NAME);

package/src/core/native/exponent-barometer.ts

@@ -0,0 +1,9 @@
+import { requireNativeModule } from 'expo-modules-core';
+import type { INativeSensorModule } from '../device-sensor';
+import type { IBarometerMeasurement } from '../barometer';
+
+const EXPO_BAROMETER_MODULE_NAME = 'ExpoBarometer';
+
+export const exponentBarometer = requireNativeModule<INativeSensorModule<IBarometerMeasurement>>(
+  EXPO_BAROMETER_MODULE_NAME,
+);

package/src/core/native/exponent-device-motion.ts

@@ -0,0 +1,15 @@
+import { requireNativeModule } from 'expo-modules-core';
+import type { INativeSensorModule } from '../device-sensor';
+import type { IDeviceMotionMeasurement } from '../device-motion';
+
+const EXPONENT_DEVICE_MOTION_MODULE_NAME = 'ExponentDeviceMotion';
+
+// The native module also exposes a `Gravity` numeric constant (standard gravitational
+// acceleration, 9.80665 m/s^2) alongside the shared sensor surface.
+type IExponentDeviceMotionModule = INativeSensorModule<IDeviceMotionMeasurement> & {
+  Gravity: number;
+};
+
+export const exponentDeviceMotion = requireNativeModule<IExponentDeviceMotionModule>(
+  EXPONENT_DEVICE_MOTION_MODULE_NAME,
+);

package/src/core/native/exponent-gyroscope.ts

@@ -0,0 +1,9 @@
+import { requireNativeModule } from 'expo-modules-core';
+import type { INativeSensorModule } from '../device-sensor';
+import type { IGyroscopeMeasurement } from '../gyroscope';
+
+const EXPONENT_GYROSCOPE_MODULE_NAME = 'ExponentGyroscope';
+
+export const exponentGyroscope = requireNativeModule<INativeSensorModule<IGyroscopeMeasurement>>(
+  EXPONENT_GYROSCOPE_MODULE_NAME,
+);

package/src/core/native/exponent-light-sensor/index.android.ts

@@ -0,0 +1,9 @@
+import { requireNativeModule } from 'expo-modules-core';
+import type { INativeSensorModule } from '../../device-sensor';
+import type { ILightSensorMeasurement } from '../../light-sensor';
+
+const EXPONENT_LIGHT_SENSOR_MODULE_NAME = 'ExpoLightSensor';
+
+export const exponentLightSensor = requireNativeModule<
+  INativeSensorModule<ILightSensorMeasurement>
+>(EXPONENT_LIGHT_SENSOR_MODULE_NAME);